2 * 32 bit compatibility code for System V IPC
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)
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
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>
32 #include <linux/mutex.h>
33 #include <asm/uaccess.h>
37 struct compat_msgbuf
{
42 struct compat_ipc_perm
{
52 struct compat_semid_ds
{
53 struct compat_ipc_perm sem_perm
;
54 compat_time_t sem_otime
;
55 compat_time_t sem_ctime
;
56 compat_uptr_t sem_base
;
57 compat_uptr_t sem_pending
;
58 compat_uptr_t sem_pending_last
;
60 unsigned short sem_nsems
;
63 struct compat_msqid_ds
{
64 struct compat_ipc_perm msg_perm
;
65 compat_uptr_t msg_first
;
66 compat_uptr_t msg_last
;
67 compat_time_t msg_stime
;
68 compat_time_t msg_rtime
;
69 compat_time_t msg_ctime
;
70 compat_ulong_t msg_lcbytes
;
71 compat_ulong_t msg_lqbytes
;
72 unsigned short msg_cbytes
;
73 unsigned short msg_qnum
;
74 unsigned short msg_qbytes
;
75 compat_ipc_pid_t msg_lspid
;
76 compat_ipc_pid_t msg_lrpid
;
79 struct compat_shmid_ds
{
80 struct compat_ipc_perm shm_perm
;
82 compat_time_t shm_atime
;
83 compat_time_t shm_dtime
;
84 compat_time_t shm_ctime
;
85 compat_ipc_pid_t shm_cpid
;
86 compat_ipc_pid_t shm_lpid
;
87 unsigned short shm_nattch
;
88 unsigned short shm_unused
;
89 compat_uptr_t shm_unused2
;
90 compat_uptr_t shm_unused3
;
93 struct compat_ipc_kludge
{
98 struct compat_shminfo64
{
99 compat_ulong_t shmmax
;
100 compat_ulong_t shmmin
;
101 compat_ulong_t shmmni
;
102 compat_ulong_t shmseg
;
103 compat_ulong_t shmall
;
104 compat_ulong_t __unused1
;
105 compat_ulong_t __unused2
;
106 compat_ulong_t __unused3
;
107 compat_ulong_t __unused4
;
110 struct compat_shm_info
{
111 compat_int_t used_ids
;
112 compat_ulong_t shm_tot
, shm_rss
, shm_swp
;
113 compat_ulong_t swap_attempts
, swap_successes
;
116 extern int sem_ctls
[];
117 #define sc_semopm (sem_ctls[2])
119 static inline int compat_ipc_parse_version(int *cmd
)
121 int version
= *cmd
& IPC_64
;
123 /* this is tricky: architectures that have support for the old
124 * ipc structures in 64 bit binaries need to have IPC_64 set
125 * in cmd, the others need to have it cleared */
126 #ifndef ipc_parse_version
134 static inline int __get_compat_ipc64_perm(struct ipc64_perm
*p64
,
135 struct compat_ipc64_perm __user
*up64
)
139 err
= __get_user(p64
->uid
, &up64
->uid
);
140 err
|= __get_user(p64
->gid
, &up64
->gid
);
141 err
|= __get_user(p64
->mode
, &up64
->mode
);
145 static inline int __get_compat_ipc_perm(struct ipc64_perm
*p
,
146 struct compat_ipc_perm __user
*up
)
150 err
= __get_user(p
->uid
, &up
->uid
);
151 err
|= __get_user(p
->gid
, &up
->gid
);
152 err
|= __get_user(p
->mode
, &up
->mode
);
156 static inline int __put_compat_ipc64_perm(struct ipc64_perm
*p64
,
157 struct compat_ipc64_perm __user
*up64
)
161 err
= __put_user(p64
->key
, &up64
->key
);
162 err
|= __put_user(p64
->uid
, &up64
->uid
);
163 err
|= __put_user(p64
->gid
, &up64
->gid
);
164 err
|= __put_user(p64
->cuid
, &up64
->cuid
);
165 err
|= __put_user(p64
->cgid
, &up64
->cgid
);
166 err
|= __put_user(p64
->mode
, &up64
->mode
);
167 err
|= __put_user(p64
->seq
, &up64
->seq
);
171 static inline int __put_compat_ipc_perm(struct ipc64_perm
*p
,
172 struct compat_ipc_perm __user
*up
)
178 err
= __put_user(p
->key
, &up
->key
);
180 err
|= __put_user(u
, &up
->uid
);
182 err
|= __put_user(g
, &up
->gid
);
184 err
|= __put_user(u
, &up
->cuid
);
186 err
|= __put_user(g
, &up
->cgid
);
187 err
|= __put_user(p
->mode
, &up
->mode
);
188 err
|= __put_user(p
->seq
, &up
->seq
);
192 static inline int get_compat_semid64_ds(struct semid64_ds
*s64
,
193 struct compat_semid64_ds __user
*up64
)
195 if (!access_ok (VERIFY_READ
, up64
, sizeof(*up64
)))
197 return __get_compat_ipc64_perm(&s64
->sem_perm
, &up64
->sem_perm
);
200 static inline int get_compat_semid_ds(struct semid64_ds
*s
,
201 struct compat_semid_ds __user
*up
)
203 if (!access_ok (VERIFY_READ
, up
, sizeof(*up
)))
205 return __get_compat_ipc_perm(&s
->sem_perm
, &up
->sem_perm
);
208 static inline int put_compat_semid64_ds(struct semid64_ds
*s64
,
209 struct compat_semid64_ds __user
*up64
)
213 if (!access_ok (VERIFY_WRITE
, up64
, sizeof(*up64
)))
215 err
= __put_compat_ipc64_perm(&s64
->sem_perm
, &up64
->sem_perm
);
216 err
|= __put_user(s64
->sem_otime
, &up64
->sem_otime
);
217 err
|= __put_user(s64
->sem_ctime
, &up64
->sem_ctime
);
218 err
|= __put_user(s64
->sem_nsems
, &up64
->sem_nsems
);
222 static inline int put_compat_semid_ds(struct semid64_ds
*s
,
223 struct compat_semid_ds __user
*up
)
227 if (!access_ok (VERIFY_WRITE
, up
, sizeof(*up
)))
229 err
= __put_compat_ipc_perm(&s
->sem_perm
, &up
->sem_perm
);
230 err
|= __put_user(s
->sem_otime
, &up
->sem_otime
);
231 err
|= __put_user(s
->sem_ctime
, &up
->sem_ctime
);
232 err
|= __put_user(s
->sem_nsems
, &up
->sem_nsems
);
236 long compat_sys_semctl(int first
, int second
, int third
, void __user
*uptr
)
241 struct semid64_ds s64
;
242 struct semid64_ds __user
*up64
;
243 int version
= compat_ipc_parse_version(&third
);
247 if (get_user(pad
, (u32 __user
*) uptr
))
249 if ((third
& (~IPC_64
)) == SETVAL
)
250 fourth
.val
= (int) pad
;
252 fourth
.__pad
= compat_ptr(pad
);
253 switch (third
& (~IPC_64
)) {
264 err
= sys_semctl(first
, second
, third
, fourth
);
269 up64
= compat_alloc_user_space(sizeof(s64
));
271 err
= sys_semctl(first
, second
, third
, fourth
);
274 if (copy_from_user(&s64
, up64
, sizeof(s64
)))
276 else if (version
== IPC_64
)
277 err2
= put_compat_semid64_ds(&s64
, compat_ptr(pad
));
279 err2
= put_compat_semid_ds(&s64
, compat_ptr(pad
));
285 if (version
== IPC_64
) {
286 err
= get_compat_semid64_ds(&s64
, compat_ptr(pad
));
288 err
= get_compat_semid_ds(&s64
, compat_ptr(pad
));
290 up64
= compat_alloc_user_space(sizeof(s64
));
291 if (copy_to_user(up64
, &s64
, sizeof(s64
)))
297 err
= sys_semctl(first
, second
, third
, fourth
);
307 long compat_sys_msgsnd(int first
, int second
, int third
, void __user
*uptr
)
309 struct compat_msgbuf __user
*up
= uptr
;
317 if (get_user(type
, &up
->mtype
))
320 return do_msgsnd(first
, type
, up
->mtext
, second
, third
);
323 long compat_sys_msgrcv(int first
, int second
, int msgtyp
, int third
,
324 int version
, void __user
*uptr
)
326 struct compat_msgbuf __user
*up
;
336 struct compat_ipc_kludge ipck
;
341 if (copy_from_user (&ipck
, uptr
, sizeof(ipck
)))
343 uptr
= compat_ptr(ipck
.msgp
);
344 msgtyp
= ipck
.msgtyp
;
347 err
= do_msgrcv(first
, &type
, up
->mtext
, second
, msgtyp
, third
);
350 if (put_user(type
, &up
->mtype
))
356 static inline int get_compat_msqid64(struct msqid64_ds
*m64
,
357 struct compat_msqid64_ds __user
*up64
)
361 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
)))
363 err
= __get_compat_ipc64_perm(&m64
->msg_perm
, &up64
->msg_perm
);
364 err
|= __get_user(m64
->msg_qbytes
, &up64
->msg_qbytes
);
368 static inline int get_compat_msqid(struct msqid64_ds
*m
,
369 struct compat_msqid_ds __user
*up
)
373 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)))
375 err
= __get_compat_ipc_perm(&m
->msg_perm
, &up
->msg_perm
);
376 err
|= __get_user(m
->msg_qbytes
, &up
->msg_qbytes
);
380 static inline int put_compat_msqid64_ds(struct msqid64_ds
*m64
,
381 struct compat_msqid64_ds __user
*up64
)
385 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
387 err
= __put_compat_ipc64_perm(&m64
->msg_perm
, &up64
->msg_perm
);
388 err
|= __put_user(m64
->msg_stime
, &up64
->msg_stime
);
389 err
|= __put_user(m64
->msg_rtime
, &up64
->msg_rtime
);
390 err
|= __put_user(m64
->msg_ctime
, &up64
->msg_ctime
);
391 err
|= __put_user(m64
->msg_cbytes
, &up64
->msg_cbytes
);
392 err
|= __put_user(m64
->msg_qnum
, &up64
->msg_qnum
);
393 err
|= __put_user(m64
->msg_qbytes
, &up64
->msg_qbytes
);
394 err
|= __put_user(m64
->msg_lspid
, &up64
->msg_lspid
);
395 err
|= __put_user(m64
->msg_lrpid
, &up64
->msg_lrpid
);
399 static inline int put_compat_msqid_ds(struct msqid64_ds
*m
,
400 struct compat_msqid_ds __user
*up
)
404 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
406 err
= __put_compat_ipc_perm(&m
->msg_perm
, &up
->msg_perm
);
407 err
|= __put_user(m
->msg_stime
, &up
->msg_stime
);
408 err
|= __put_user(m
->msg_rtime
, &up
->msg_rtime
);
409 err
|= __put_user(m
->msg_ctime
, &up
->msg_ctime
);
410 err
|= __put_user(m
->msg_cbytes
, &up
->msg_cbytes
);
411 err
|= __put_user(m
->msg_qnum
, &up
->msg_qnum
);
412 err
|= __put_user(m
->msg_qbytes
, &up
->msg_qbytes
);
413 err
|= __put_user(m
->msg_lspid
, &up
->msg_lspid
);
414 err
|= __put_user(m
->msg_lrpid
, &up
->msg_lrpid
);
418 long compat_sys_msgctl(int first
, int second
, void __user
*uptr
)
421 struct msqid64_ds m64
;
422 int version
= compat_ipc_parse_version(&second
);
425 switch (second
& (~IPC_64
)) {
429 err
= sys_msgctl(first
, second
, uptr
);
433 if (version
== IPC_64
) {
434 err
= get_compat_msqid64(&m64
, uptr
);
436 err
= get_compat_msqid(&m64
, uptr
);
440 p
= compat_alloc_user_space(sizeof(m64
));
441 if (copy_to_user(p
, &m64
, sizeof(m64
)))
444 err
= sys_msgctl(first
, second
, p
);
449 p
= compat_alloc_user_space(sizeof(m64
));
450 err
= sys_msgctl(first
, second
, p
);
453 if (copy_from_user(&m64
, p
, sizeof(m64
)))
455 else if (version
== IPC_64
)
456 err2
= put_compat_msqid64_ds(&m64
, uptr
);
458 err2
= put_compat_msqid_ds(&m64
, uptr
);
470 long compat_sys_shmat(int first
, int second
, compat_uptr_t third
, int version
,
475 compat_ulong_t __user
*uaddr
;
479 err
= do_shmat(first
, uptr
, second
, &raddr
);
482 uaddr
= compat_ptr(third
);
483 return put_user(raddr
, uaddr
);
486 static inline int get_compat_shmid64_ds(struct shmid64_ds
*s64
,
487 struct compat_shmid64_ds __user
*up64
)
489 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
)))
491 return __get_compat_ipc64_perm(&s64
->shm_perm
, &up64
->shm_perm
);
494 static inline int get_compat_shmid_ds(struct shmid64_ds
*s
,
495 struct compat_shmid_ds __user
*up
)
497 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)))
499 return __get_compat_ipc_perm(&s
->shm_perm
, &up
->shm_perm
);
502 static inline int put_compat_shmid64_ds(struct shmid64_ds
*s64
,
503 struct compat_shmid64_ds __user
*up64
)
507 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
509 err
= __put_compat_ipc64_perm(&s64
->shm_perm
, &up64
->shm_perm
);
510 err
|= __put_user(s64
->shm_atime
, &up64
->shm_atime
);
511 err
|= __put_user(s64
->shm_dtime
, &up64
->shm_dtime
);
512 err
|= __put_user(s64
->shm_ctime
, &up64
->shm_ctime
);
513 err
|= __put_user(s64
->shm_segsz
, &up64
->shm_segsz
);
514 err
|= __put_user(s64
->shm_nattch
, &up64
->shm_nattch
);
515 err
|= __put_user(s64
->shm_cpid
, &up64
->shm_cpid
);
516 err
|= __put_user(s64
->shm_lpid
, &up64
->shm_lpid
);
520 static inline int put_compat_shmid_ds(struct shmid64_ds
*s
,
521 struct compat_shmid_ds __user
*up
)
525 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
527 err
= __put_compat_ipc_perm(&s
->shm_perm
, &up
->shm_perm
);
528 err
|= __put_user(s
->shm_atime
, &up
->shm_atime
);
529 err
|= __put_user(s
->shm_dtime
, &up
->shm_dtime
);
530 err
|= __put_user(s
->shm_ctime
, &up
->shm_ctime
);
531 err
|= __put_user(s
->shm_segsz
, &up
->shm_segsz
);
532 err
|= __put_user(s
->shm_nattch
, &up
->shm_nattch
);
533 err
|= __put_user(s
->shm_cpid
, &up
->shm_cpid
);
534 err
|= __put_user(s
->shm_lpid
, &up
->shm_lpid
);
538 static inline int put_compat_shminfo64(struct shminfo64
*smi
,
539 struct compat_shminfo64 __user
*up64
)
543 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
545 if (smi
->shmmax
> INT_MAX
)
546 smi
->shmmax
= INT_MAX
;
547 err
= __put_user(smi
->shmmax
, &up64
->shmmax
);
548 err
|= __put_user(smi
->shmmin
, &up64
->shmmin
);
549 err
|= __put_user(smi
->shmmni
, &up64
->shmmni
);
550 err
|= __put_user(smi
->shmseg
, &up64
->shmseg
);
551 err
|= __put_user(smi
->shmall
, &up64
->shmall
);
555 static inline int put_compat_shminfo(struct shminfo64
*smi
,
556 struct shminfo __user
*up
)
560 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
562 if (smi
->shmmax
> INT_MAX
)
563 smi
->shmmax
= INT_MAX
;
564 err
= __put_user(smi
->shmmax
, &up
->shmmax
);
565 err
|= __put_user(smi
->shmmin
, &up
->shmmin
);
566 err
|= __put_user(smi
->shmmni
, &up
->shmmni
);
567 err
|= __put_user(smi
->shmseg
, &up
->shmseg
);
568 err
|= __put_user(smi
->shmall
, &up
->shmall
);
572 static inline int put_compat_shm_info(struct shm_info __user
*ip
,
573 struct compat_shm_info __user
*uip
)
578 if (!access_ok(VERIFY_WRITE
, uip
, sizeof(*uip
)) ||
579 copy_from_user(&si
, ip
, sizeof(si
)))
581 err
= __put_user(si
.used_ids
, &uip
->used_ids
);
582 err
|= __put_user(si
.shm_tot
, &uip
->shm_tot
);
583 err
|= __put_user(si
.shm_rss
, &uip
->shm_rss
);
584 err
|= __put_user(si
.shm_swp
, &uip
->shm_swp
);
585 err
|= __put_user(si
.swap_attempts
, &uip
->swap_attempts
);
586 err
|= __put_user(si
.swap_successes
, &uip
->swap_successes
);
590 long compat_sys_shmctl(int first
, int second
, void __user
*uptr
)
593 struct shmid64_ds s64
;
594 struct shminfo64 smi
;
596 int version
= compat_ipc_parse_version(&second
);
598 switch (second
& (~IPC_64
)) {
602 err
= sys_shmctl(first
, second
, uptr
);
606 p
= compat_alloc_user_space(sizeof(smi
));
607 err
= sys_shmctl(first
, second
, p
);
610 if (copy_from_user(&smi
, p
, sizeof(smi
)))
612 else if (version
== IPC_64
)
613 err2
= put_compat_shminfo64(&smi
, uptr
);
615 err2
= put_compat_shminfo(&smi
, uptr
);
622 if (version
== IPC_64
) {
623 err
= get_compat_shmid64_ds(&s64
, uptr
);
625 err
= get_compat_shmid_ds(&s64
, uptr
);
629 p
= compat_alloc_user_space(sizeof(s64
));
630 if (copy_to_user(p
, &s64
, sizeof(s64
)))
633 err
= sys_shmctl(first
, second
, p
);
638 p
= compat_alloc_user_space(sizeof(s64
));
639 err
= sys_shmctl(first
, second
, p
);
642 if (copy_from_user(&s64
, p
, sizeof(s64
)))
644 else if (version
== IPC_64
)
645 err2
= put_compat_shmid64_ds(&s64
, uptr
);
647 err2
= put_compat_shmid_ds(&s64
, uptr
);
653 p
= compat_alloc_user_space(sizeof(struct shm_info
));
654 err
= sys_shmctl(first
, second
, p
);
657 err2
= put_compat_shm_info(p
, uptr
);
669 long compat_sys_semtimedop(int semid
, struct sembuf __user
*tsems
,
670 unsigned nsops
, const struct compat_timespec __user
*timeout
)
672 struct timespec __user
*ts64
= NULL
;
675 ts64
= compat_alloc_user_space(sizeof(*ts64
));
676 if (get_compat_timespec(&ts
, timeout
))
678 if (copy_to_user(ts64
, &ts
, sizeof(ts
)))
681 return sys_semtimedop(semid
, tsems
, nsops
, ts64
);