compat.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678
  1. /*
  2. * 32 bit compatibility code for System V IPC
  3. *
  4. * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  5. * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  6. * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
  7. * Copyright (C) 2000 VA Linux Co
  8. * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
  9. * Copyright (C) 2000 Hewlett-Packard Co.
  10. * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
  11. * Copyright (C) 2000 Gerhard Tonn (ton@de.ibm.com)
  12. * Copyright (C) 2000-2002 Andi Kleen, SuSE Labs (x86-64 port)
  13. * Copyright (C) 2000 Silicon Graphics, Inc.
  14. * Copyright (C) 2001 IBM
  15. * Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
  16. * Copyright (C) 2004 Arnd Bergmann (arnd@arndb.de)
  17. *
  18. * This code is collected from the versions for sparc64, mips64, s390x, ia64,
  19. * ppc64 and x86_64, all of which are based on the original sparc64 version
  20. * by Jakub Jelinek.
  21. *
  22. */
  23. #include <linux/compat.h>
  24. #include <linux/errno.h>
  25. #include <linux/highuid.h>
  26. #include <linux/init.h>
  27. #include <linux/msg.h>
  28. #include <linux/shm.h>
  29. #include <linux/slab.h>
  30. #include <linux/syscalls.h>
  31. #include <linux/mutex.h>
  32. #include <asm/uaccess.h>
  33. #include "util.h"
  34. struct compat_msgbuf {
  35. compat_long_t mtype;
  36. char mtext[1];
  37. };
  38. struct compat_ipc_perm {
  39. key_t key;
  40. __compat_uid_t uid;
  41. __compat_gid_t gid;
  42. __compat_uid_t cuid;
  43. __compat_gid_t cgid;
  44. compat_mode_t mode;
  45. unsigned short seq;
  46. };
  47. struct compat_semid_ds {
  48. struct compat_ipc_perm sem_perm;
  49. compat_time_t sem_otime;
  50. compat_time_t sem_ctime;
  51. compat_uptr_t sem_base;
  52. compat_uptr_t sem_pending;
  53. compat_uptr_t sem_pending_last;
  54. compat_uptr_t undo;
  55. unsigned short sem_nsems;
  56. };
  57. struct compat_msqid_ds {
  58. struct compat_ipc_perm msg_perm;
  59. compat_uptr_t msg_first;
  60. compat_uptr_t msg_last;
  61. compat_time_t msg_stime;
  62. compat_time_t msg_rtime;
  63. compat_time_t msg_ctime;
  64. compat_ulong_t msg_lcbytes;
  65. compat_ulong_t msg_lqbytes;
  66. unsigned short msg_cbytes;
  67. unsigned short msg_qnum;
  68. unsigned short msg_qbytes;
  69. compat_ipc_pid_t msg_lspid;
  70. compat_ipc_pid_t msg_lrpid;
  71. };
  72. struct compat_shmid_ds {
  73. struct compat_ipc_perm shm_perm;
  74. int shm_segsz;
  75. compat_time_t shm_atime;
  76. compat_time_t shm_dtime;
  77. compat_time_t shm_ctime;
  78. compat_ipc_pid_t shm_cpid;
  79. compat_ipc_pid_t shm_lpid;
  80. unsigned short shm_nattch;
  81. unsigned short shm_unused;
  82. compat_uptr_t shm_unused2;
  83. compat_uptr_t shm_unused3;
  84. };
  85. struct compat_ipc_kludge {
  86. compat_uptr_t msgp;
  87. compat_long_t msgtyp;
  88. };
  89. struct compat_shminfo64 {
  90. compat_ulong_t shmmax;
  91. compat_ulong_t shmmin;
  92. compat_ulong_t shmmni;
  93. compat_ulong_t shmseg;
  94. compat_ulong_t shmall;
  95. compat_ulong_t __unused1;
  96. compat_ulong_t __unused2;
  97. compat_ulong_t __unused3;
  98. compat_ulong_t __unused4;
  99. };
  100. struct compat_shm_info {
  101. compat_int_t used_ids;
  102. compat_ulong_t shm_tot, shm_rss, shm_swp;
  103. compat_ulong_t swap_attempts, swap_successes;
  104. };
  105. extern int sem_ctls[];
  106. #define sc_semopm (sem_ctls[2])
  107. static inline int compat_ipc_parse_version(int *cmd)
  108. {
  109. int version = *cmd & IPC_64;
  110. /* this is tricky: architectures that have support for the old
  111. * ipc structures in 64 bit binaries need to have IPC_64 set
  112. * in cmd, the others need to have it cleared */
  113. #ifndef ipc_parse_version
  114. *cmd |= IPC_64;
  115. #else
  116. *cmd &= ~IPC_64;
  117. #endif
  118. return version;
  119. }
  120. static inline int __get_compat_ipc64_perm(struct ipc64_perm *p64,
  121. struct compat_ipc64_perm __user *up64)
  122. {
  123. int err;
  124. err = __get_user(p64->uid, &up64->uid);
  125. err |= __get_user(p64->gid, &up64->gid);
  126. err |= __get_user(p64->mode, &up64->mode);
  127. return err;
  128. }
  129. static inline int __get_compat_ipc_perm(struct ipc64_perm *p,
  130. struct compat_ipc_perm __user *up)
  131. {
  132. int err;
  133. err = __get_user(p->uid, &up->uid);
  134. err |= __get_user(p->gid, &up->gid);
  135. err |= __get_user(p->mode, &up->mode);
  136. return err;
  137. }
  138. static inline int __put_compat_ipc64_perm(struct ipc64_perm *p64,
  139. struct compat_ipc64_perm __user *up64)
  140. {
  141. int err;
  142. err = __put_user(p64->key, &up64->key);
  143. err |= __put_user(p64->uid, &up64->uid);
  144. err |= __put_user(p64->gid, &up64->gid);
  145. err |= __put_user(p64->cuid, &up64->cuid);
  146. err |= __put_user(p64->cgid, &up64->cgid);
  147. err |= __put_user(p64->mode, &up64->mode);
  148. err |= __put_user(p64->seq, &up64->seq);
  149. return err;
  150. }
  151. static inline int __put_compat_ipc_perm(struct ipc64_perm *p,
  152. struct compat_ipc_perm __user *up)
  153. {
  154. int err;
  155. __compat_uid_t u;
  156. __compat_gid_t g;
  157. err = __put_user(p->key, &up->key);
  158. SET_UID(u, p->uid);
  159. err |= __put_user(u, &up->uid);
  160. SET_GID(g, p->gid);
  161. err |= __put_user(g, &up->gid);
  162. SET_UID(u, p->cuid);
  163. err |= __put_user(u, &up->cuid);
  164. SET_GID(g, p->cgid);
  165. err |= __put_user(g, &up->cgid);
  166. err |= __put_user(p->mode, &up->mode);
  167. err |= __put_user(p->seq, &up->seq);
  168. return err;
  169. }
  170. static inline int get_compat_semid64_ds(struct semid64_ds *s64,
  171. struct compat_semid64_ds __user *up64)
  172. {
  173. if (!access_ok (VERIFY_READ, up64, sizeof(*up64)))
  174. return -EFAULT;
  175. return __get_compat_ipc64_perm(&s64->sem_perm, &up64->sem_perm);
  176. }
  177. static inline int get_compat_semid_ds(struct semid64_ds *s,
  178. struct compat_semid_ds __user *up)
  179. {
  180. if (!access_ok (VERIFY_READ, up, sizeof(*up)))
  181. return -EFAULT;
  182. return __get_compat_ipc_perm(&s->sem_perm, &up->sem_perm);
  183. }
  184. static inline int put_compat_semid64_ds(struct semid64_ds *s64,
  185. struct compat_semid64_ds __user *up64)
  186. {
  187. int err;
  188. if (!access_ok (VERIFY_WRITE, up64, sizeof(*up64)))
  189. return -EFAULT;
  190. err = __put_compat_ipc64_perm(&s64->sem_perm, &up64->sem_perm);
  191. err |= __put_user(s64->sem_otime, &up64->sem_otime);
  192. err |= __put_user(s64->sem_ctime, &up64->sem_ctime);
  193. err |= __put_user(s64->sem_nsems, &up64->sem_nsems);
  194. return err;
  195. }
  196. static inline int put_compat_semid_ds(struct semid64_ds *s,
  197. struct compat_semid_ds __user *up)
  198. {
  199. int err;
  200. if (!access_ok (VERIFY_WRITE, up, sizeof(*up)))
  201. err = -EFAULT;
  202. err = __put_compat_ipc_perm(&s->sem_perm, &up->sem_perm);
  203. err |= __put_user(s->sem_otime, &up->sem_otime);
  204. err |= __put_user(s->sem_ctime, &up->sem_ctime);
  205. err |= __put_user(s->sem_nsems, &up->sem_nsems);
  206. return err;
  207. }
  208. long compat_sys_semctl(int first, int second, int third, void __user *uptr)
  209. {
  210. union semun fourth;
  211. u32 pad;
  212. int err, err2;
  213. struct semid64_ds s64;
  214. struct semid64_ds __user *up64;
  215. int version = compat_ipc_parse_version(&third);
  216. if (!uptr)
  217. return -EINVAL;
  218. if (get_user(pad, (u32 __user *) uptr))
  219. return -EFAULT;
  220. if ((third & (~IPC_64)) == SETVAL)
  221. fourth.val = (int) pad;
  222. else
  223. fourth.__pad = compat_ptr(pad);
  224. switch (third & (~IPC_64)) {
  225. case IPC_INFO:
  226. case IPC_RMID:
  227. case SEM_INFO:
  228. case GETVAL:
  229. case GETPID:
  230. case GETNCNT:
  231. case GETZCNT:
  232. case GETALL:
  233. case SETVAL:
  234. case SETALL:
  235. err = sys_semctl(first, second, third, fourth);
  236. break;
  237. case IPC_STAT:
  238. case SEM_STAT:
  239. up64 = compat_alloc_user_space(sizeof(s64));
  240. fourth.__pad = up64;
  241. err = sys_semctl(first, second, third, fourth);
  242. if (err < 0)
  243. break;
  244. if (copy_from_user(&s64, up64, sizeof(s64)))
  245. err2 = -EFAULT;
  246. else if (version == IPC_64)
  247. err2 = put_compat_semid64_ds(&s64, compat_ptr(pad));
  248. else
  249. err2 = put_compat_semid_ds(&s64, compat_ptr(pad));
  250. if (err2)
  251. err = -EFAULT;
  252. break;
  253. case IPC_SET:
  254. if (version == IPC_64) {
  255. err = get_compat_semid64_ds(&s64, compat_ptr(pad));
  256. } else {
  257. err = get_compat_semid_ds(&s64, compat_ptr(pad));
  258. }
  259. up64 = compat_alloc_user_space(sizeof(s64));
  260. if (copy_to_user(up64, &s64, sizeof(s64)))
  261. err = -EFAULT;
  262. if (err)
  263. break;
  264. fourth.__pad = up64;
  265. err = sys_semctl(first, second, third, fourth);
  266. break;
  267. default:
  268. err = -EINVAL;
  269. break;
  270. }
  271. return err;
  272. }
  273. long compat_sys_msgsnd(int first, int second, int third, void __user *uptr)
  274. {
  275. struct compat_msgbuf __user *up = uptr;
  276. long type;
  277. if (first < 0)
  278. return -EINVAL;
  279. if (second < 0)
  280. return -EINVAL;
  281. if (get_user(type, &up->mtype))
  282. return -EFAULT;
  283. return do_msgsnd(first, type, up->mtext, second, third);
  284. }
  285. long compat_sys_msgrcv(int first, int second, int msgtyp, int third,
  286. int version, void __user *uptr)
  287. {
  288. struct compat_msgbuf __user *up;
  289. long type;
  290. int err;
  291. if (first < 0)
  292. return -EINVAL;
  293. if (second < 0)
  294. return -EINVAL;
  295. if (!version) {
  296. struct compat_ipc_kludge ipck;
  297. err = -EINVAL;
  298. if (!uptr)
  299. goto out;
  300. err = -EFAULT;
  301. if (copy_from_user (&ipck, uptr, sizeof(ipck)))
  302. goto out;
  303. uptr = compat_ptr(ipck.msgp);
  304. msgtyp = ipck.msgtyp;
  305. }
  306. up = uptr;
  307. err = do_msgrcv(first, &type, up->mtext, second, msgtyp, third);
  308. if (err < 0)
  309. goto out;
  310. if (put_user(type, &up->mtype))
  311. err = -EFAULT;
  312. out:
  313. return err;
  314. }
  315. static inline int get_compat_msqid64(struct msqid64_ds *m64,
  316. struct compat_msqid64_ds __user *up64)
  317. {
  318. int err;
  319. if (!access_ok(VERIFY_READ, up64, sizeof(*up64)))
  320. return -EFAULT;
  321. err = __get_compat_ipc64_perm(&m64->msg_perm, &up64->msg_perm);
  322. err |= __get_user(m64->msg_qbytes, &up64->msg_qbytes);
  323. return err;
  324. }
  325. static inline int get_compat_msqid(struct msqid64_ds *m,
  326. struct compat_msqid_ds __user *up)
  327. {
  328. int err;
  329. if (!access_ok(VERIFY_READ, up, sizeof(*up)))
  330. return -EFAULT;
  331. err = __get_compat_ipc_perm(&m->msg_perm, &up->msg_perm);
  332. err |= __get_user(m->msg_qbytes, &up->msg_qbytes);
  333. return err;
  334. }
  335. static inline int put_compat_msqid64_ds(struct msqid64_ds *m64,
  336. struct compat_msqid64_ds __user *up64)
  337. {
  338. int err;
  339. if (!access_ok(VERIFY_WRITE, up64, sizeof(*up64)))
  340. return -EFAULT;
  341. err = __put_compat_ipc64_perm(&m64->msg_perm, &up64->msg_perm);
  342. err |= __put_user(m64->msg_stime, &up64->msg_stime);
  343. err |= __put_user(m64->msg_rtime, &up64->msg_rtime);
  344. err |= __put_user(m64->msg_ctime, &up64->msg_ctime);
  345. err |= __put_user(m64->msg_cbytes, &up64->msg_cbytes);
  346. err |= __put_user(m64->msg_qnum, &up64->msg_qnum);
  347. err |= __put_user(m64->msg_qbytes, &up64->msg_qbytes);
  348. err |= __put_user(m64->msg_lspid, &up64->msg_lspid);
  349. err |= __put_user(m64->msg_lrpid, &up64->msg_lrpid);
  350. return err;
  351. }
  352. static inline int put_compat_msqid_ds(struct msqid64_ds *m,
  353. struct compat_msqid_ds __user *up)
  354. {
  355. int err;
  356. if (!access_ok(VERIFY_WRITE, up, sizeof(*up)))
  357. return -EFAULT;
  358. err = __put_compat_ipc_perm(&m->msg_perm, &up->msg_perm);
  359. err |= __put_user(m->msg_stime, &up->msg_stime);
  360. err |= __put_user(m->msg_rtime, &up->msg_rtime);
  361. err |= __put_user(m->msg_ctime, &up->msg_ctime);
  362. err |= __put_user(m->msg_cbytes, &up->msg_cbytes);
  363. err |= __put_user(m->msg_qnum, &up->msg_qnum);
  364. err |= __put_user(m->msg_qbytes, &up->msg_qbytes);
  365. err |= __put_user(m->msg_lspid, &up->msg_lspid);
  366. err |= __put_user(m->msg_lrpid, &up->msg_lrpid);
  367. return err;
  368. }
  369. long compat_sys_msgctl(int first, int second, void __user *uptr)
  370. {
  371. int err, err2;
  372. struct msqid64_ds m64;
  373. int version = compat_ipc_parse_version(&second);
  374. void __user *p;
  375. switch (second & (~IPC_64)) {
  376. case IPC_INFO:
  377. case IPC_RMID:
  378. case MSG_INFO:
  379. err = sys_msgctl(first, second, uptr);
  380. break;
  381. case IPC_SET:
  382. if (version == IPC_64) {
  383. err = get_compat_msqid64(&m64, uptr);
  384. } else {
  385. err = get_compat_msqid(&m64, uptr);
  386. }
  387. if (err)
  388. break;
  389. p = compat_alloc_user_space(sizeof(m64));
  390. if (copy_to_user(p, &m64, sizeof(m64)))
  391. err = -EFAULT;
  392. else
  393. err = sys_msgctl(first, second, p);
  394. break;
  395. case IPC_STAT:
  396. case MSG_STAT:
  397. p = compat_alloc_user_space(sizeof(m64));
  398. err = sys_msgctl(first, second, p);
  399. if (err < 0)
  400. break;
  401. if (copy_from_user(&m64, p, sizeof(m64)))
  402. err2 = -EFAULT;
  403. else if (version == IPC_64)
  404. err2 = put_compat_msqid64_ds(&m64, uptr);
  405. else
  406. err2 = put_compat_msqid_ds(&m64, uptr);
  407. if (err2)
  408. err = -EFAULT;
  409. break;
  410. default:
  411. err = -EINVAL;
  412. break;
  413. }
  414. return err;
  415. }
  416. long compat_sys_shmat(int first, int second, compat_uptr_t third, int version,
  417. void __user *uptr)
  418. {
  419. int err;
  420. unsigned long raddr;
  421. compat_ulong_t __user *uaddr;
  422. if (version == 1)
  423. return -EINVAL;
  424. err = do_shmat(first, uptr, second, &raddr);
  425. if (err < 0)
  426. return err;
  427. uaddr = compat_ptr(third);
  428. return put_user(raddr, uaddr);
  429. }
  430. static inline int get_compat_shmid64_ds(struct shmid64_ds *s64,
  431. struct compat_shmid64_ds __user *up64)
  432. {
  433. if (!access_ok(VERIFY_READ, up64, sizeof(*up64)))
  434. return -EFAULT;
  435. return __get_compat_ipc64_perm(&s64->shm_perm, &up64->shm_perm);
  436. }
  437. static inline int get_compat_shmid_ds(struct shmid64_ds *s,
  438. struct compat_shmid_ds __user *up)
  439. {
  440. if (!access_ok(VERIFY_READ, up, sizeof(*up)))
  441. return -EFAULT;
  442. return __get_compat_ipc_perm(&s->shm_perm, &up->shm_perm);
  443. }
  444. static inline int put_compat_shmid64_ds(struct shmid64_ds *s64,
  445. struct compat_shmid64_ds __user *up64)
  446. {
  447. int err;
  448. if (!access_ok(VERIFY_WRITE, up64, sizeof(*up64)))
  449. return -EFAULT;
  450. err = __put_compat_ipc64_perm(&s64->shm_perm, &up64->shm_perm);
  451. err |= __put_user(s64->shm_atime, &up64->shm_atime);
  452. err |= __put_user(s64->shm_dtime, &up64->shm_dtime);
  453. err |= __put_user(s64->shm_ctime, &up64->shm_ctime);
  454. err |= __put_user(s64->shm_segsz, &up64->shm_segsz);
  455. err |= __put_user(s64->shm_nattch, &up64->shm_nattch);
  456. err |= __put_user(s64->shm_cpid, &up64->shm_cpid);
  457. err |= __put_user(s64->shm_lpid, &up64->shm_lpid);
  458. return err;
  459. }
  460. static inline int put_compat_shmid_ds(struct shmid64_ds *s,
  461. struct compat_shmid_ds __user *up)
  462. {
  463. int err;
  464. if (!access_ok(VERIFY_WRITE, up, sizeof(*up)))
  465. return -EFAULT;
  466. err = __put_compat_ipc_perm(&s->shm_perm, &up->shm_perm);
  467. err |= __put_user(s->shm_atime, &up->shm_atime);
  468. err |= __put_user(s->shm_dtime, &up->shm_dtime);
  469. err |= __put_user(s->shm_ctime, &up->shm_ctime);
  470. err |= __put_user(s->shm_segsz, &up->shm_segsz);
  471. err |= __put_user(s->shm_nattch, &up->shm_nattch);
  472. err |= __put_user(s->shm_cpid, &up->shm_cpid);
  473. err |= __put_user(s->shm_lpid, &up->shm_lpid);
  474. return err;
  475. }
  476. static inline int put_compat_shminfo64(struct shminfo64 *smi,
  477. struct compat_shminfo64 __user *up64)
  478. {
  479. int err;
  480. if (!access_ok(VERIFY_WRITE, up64, sizeof(*up64)))
  481. return -EFAULT;
  482. err = __put_user(smi->shmmax, &up64->shmmax);
  483. err |= __put_user(smi->shmmin, &up64->shmmin);
  484. err |= __put_user(smi->shmmni, &up64->shmmni);
  485. err |= __put_user(smi->shmseg, &up64->shmseg);
  486. err |= __put_user(smi->shmall, &up64->shmall);
  487. return err;
  488. }
  489. static inline int put_compat_shminfo(struct shminfo64 *smi,
  490. struct shminfo __user *up)
  491. {
  492. int err;
  493. if (!access_ok(VERIFY_WRITE, up, sizeof(*up)))
  494. return -EFAULT;
  495. err = __put_user(smi->shmmax, &up->shmmax);
  496. err |= __put_user(smi->shmmin, &up->shmmin);
  497. err |= __put_user(smi->shmmni, &up->shmmni);
  498. err |= __put_user(smi->shmseg, &up->shmseg);
  499. err |= __put_user(smi->shmall, &up->shmall);
  500. return err;
  501. }
  502. static inline int put_compat_shm_info(struct shm_info __user *ip,
  503. struct compat_shm_info __user *uip)
  504. {
  505. int err;
  506. struct shm_info si;
  507. if (!access_ok(VERIFY_WRITE, uip, sizeof(*uip)) ||
  508. copy_from_user(&si, ip, sizeof(si)))
  509. return -EFAULT;
  510. err = __put_user(si.used_ids, &uip->used_ids);
  511. err |= __put_user(si.shm_tot, &uip->shm_tot);
  512. err |= __put_user(si.shm_rss, &uip->shm_rss);
  513. err |= __put_user(si.shm_swp, &uip->shm_swp);
  514. err |= __put_user(si.swap_attempts, &uip->swap_attempts);
  515. err |= __put_user(si.swap_successes, &uip->swap_successes);
  516. return err;
  517. }
  518. long compat_sys_shmctl(int first, int second, void __user *uptr)
  519. {
  520. void __user *p;
  521. struct shmid64_ds s64;
  522. struct shminfo64 smi;
  523. int err, err2;
  524. int version = compat_ipc_parse_version(&second);
  525. switch (second & (~IPC_64)) {
  526. case IPC_RMID:
  527. case SHM_LOCK:
  528. case SHM_UNLOCK:
  529. err = sys_shmctl(first, second, uptr);
  530. break;
  531. case IPC_INFO:
  532. p = compat_alloc_user_space(sizeof(smi));
  533. err = sys_shmctl(first, second, p);
  534. if (err < 0)
  535. break;
  536. if (copy_from_user(&smi, p, sizeof(smi)))
  537. err2 = -EFAULT;
  538. else if (version == IPC_64)
  539. err2 = put_compat_shminfo64(&smi, uptr);
  540. else
  541. err2 = put_compat_shminfo(&smi, uptr);
  542. if (err2)
  543. err = -EFAULT;
  544. break;
  545. case IPC_SET:
  546. if (version == IPC_64) {
  547. err = get_compat_shmid64_ds(&s64, uptr);
  548. } else {
  549. err = get_compat_shmid_ds(&s64, uptr);
  550. }
  551. if (err)
  552. break;
  553. p = compat_alloc_user_space(sizeof(s64));
  554. if (copy_to_user(p, &s64, sizeof(s64)))
  555. err = -EFAULT;
  556. else
  557. err = sys_shmctl(first, second, p);
  558. break;
  559. case IPC_STAT:
  560. case SHM_STAT:
  561. p = compat_alloc_user_space(sizeof(s64));
  562. err = sys_shmctl(first, second, p);
  563. if (err < 0)
  564. break;
  565. if (copy_from_user(&s64, p, sizeof(s64)))
  566. err2 = -EFAULT;
  567. else if (version == IPC_64)
  568. err2 = put_compat_shmid64_ds(&s64, uptr);
  569. else
  570. err2 = put_compat_shmid_ds(&s64, uptr);
  571. if (err2)
  572. err = -EFAULT;
  573. break;
  574. case SHM_INFO:
  575. p = compat_alloc_user_space(sizeof(struct shm_info));
  576. err = sys_shmctl(first, second, p);
  577. if (err < 0)
  578. break;
  579. err2 = put_compat_shm_info(p, uptr);
  580. if (err2)
  581. err = -EFAULT;
  582. break;
  583. default:
  584. err = -EINVAL;
  585. break;
  586. }
  587. return err;
  588. }
  589. long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
  590. unsigned nsops, const struct compat_timespec __user *timeout)
  591. {
  592. struct timespec __user *ts64 = NULL;
  593. if (timeout) {
  594. struct timespec ts;
  595. ts64 = compat_alloc_user_space(sizeof(*ts64));
  596. if (get_compat_timespec(&ts, timeout))
  597. return -EFAULT;
  598. if (copy_to_user(ts64, &ts, sizeof(ts)))
  599. return -EFAULT;
  600. }
  601. return sys_semtimedop(semid, tsems, nsops, ts64);
  602. }