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/syscalls.h>
30 #include <linux/ptrace.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 #ifdef CONFIG_ARCH_WANT_COMPAT_IPC_PARSE_VERSION
122 int version
= *cmd
& IPC_64
;
124 /* this is tricky: architectures that have support for the old
125 * ipc structures in 64 bit binaries need to have IPC_64 set
126 * in cmd, the others need to have it cleared */
127 #ifndef ipc_parse_version
134 /* With the asm-generic APIs, we always use the 64-bit versions. */
139 static inline int __get_compat_ipc64_perm(struct ipc64_perm
*p64
,
140 struct compat_ipc64_perm __user
*up64
)
144 err
= __get_user(p64
->uid
, &up64
->uid
);
145 err
|= __get_user(p64
->gid
, &up64
->gid
);
146 err
|= __get_user(p64
->mode
, &up64
->mode
);
150 static inline int __get_compat_ipc_perm(struct ipc64_perm
*p
,
151 struct compat_ipc_perm __user
*up
)
155 err
= __get_user(p
->uid
, &up
->uid
);
156 err
|= __get_user(p
->gid
, &up
->gid
);
157 err
|= __get_user(p
->mode
, &up
->mode
);
161 static inline int __put_compat_ipc64_perm(struct ipc64_perm
*p64
,
162 struct compat_ipc64_perm __user
*up64
)
166 err
= __put_user(p64
->key
, &up64
->key
);
167 err
|= __put_user(p64
->uid
, &up64
->uid
);
168 err
|= __put_user(p64
->gid
, &up64
->gid
);
169 err
|= __put_user(p64
->cuid
, &up64
->cuid
);
170 err
|= __put_user(p64
->cgid
, &up64
->cgid
);
171 err
|= __put_user(p64
->mode
, &up64
->mode
);
172 err
|= __put_user(p64
->seq
, &up64
->seq
);
176 static inline int __put_compat_ipc_perm(struct ipc64_perm
*p
,
177 struct compat_ipc_perm __user
*up
)
183 err
= __put_user(p
->key
, &up
->key
);
185 err
|= __put_user(u
, &up
->uid
);
187 err
|= __put_user(g
, &up
->gid
);
189 err
|= __put_user(u
, &up
->cuid
);
191 err
|= __put_user(g
, &up
->cgid
);
192 err
|= __put_user(p
->mode
, &up
->mode
);
193 err
|= __put_user(p
->seq
, &up
->seq
);
197 static inline int get_compat_semid64_ds(struct semid64_ds
*s64
,
198 struct compat_semid64_ds __user
*up64
)
200 if (!access_ok (VERIFY_READ
, up64
, sizeof(*up64
)))
202 return __get_compat_ipc64_perm(&s64
->sem_perm
, &up64
->sem_perm
);
205 static inline int get_compat_semid_ds(struct semid64_ds
*s
,
206 struct compat_semid_ds __user
*up
)
208 if (!access_ok (VERIFY_READ
, up
, sizeof(*up
)))
210 return __get_compat_ipc_perm(&s
->sem_perm
, &up
->sem_perm
);
213 static inline int put_compat_semid64_ds(struct semid64_ds
*s64
,
214 struct compat_semid64_ds __user
*up64
)
218 if (!access_ok (VERIFY_WRITE
, up64
, sizeof(*up64
)))
220 err
= __put_compat_ipc64_perm(&s64
->sem_perm
, &up64
->sem_perm
);
221 err
|= __put_user(s64
->sem_otime
, &up64
->sem_otime
);
222 err
|= __put_user(s64
->sem_ctime
, &up64
->sem_ctime
);
223 err
|= __put_user(s64
->sem_nsems
, &up64
->sem_nsems
);
227 static inline int put_compat_semid_ds(struct semid64_ds
*s
,
228 struct compat_semid_ds __user
*up
)
232 if (!access_ok (VERIFY_WRITE
, up
, sizeof(*up
)))
234 err
= __put_compat_ipc_perm(&s
->sem_perm
, &up
->sem_perm
);
235 err
|= __put_user(s
->sem_otime
, &up
->sem_otime
);
236 err
|= __put_user(s
->sem_ctime
, &up
->sem_ctime
);
237 err
|= __put_user(s
->sem_nsems
, &up
->sem_nsems
);
241 static long do_compat_semctl(int first
, int second
, int third
, u32 pad
)
245 struct semid64_ds s64
;
246 struct semid64_ds __user
*up64
;
247 int version
= compat_ipc_parse_version(&third
);
249 memset(&s64
, 0, sizeof(s64
));
251 if ((third
& (~IPC_64
)) == SETVAL
)
252 fourth
.val
= (int) pad
;
254 fourth
.__pad
= compat_ptr(pad
);
255 switch (third
& (~IPC_64
)) {
266 err
= sys_semctl(first
, second
, third
, fourth
);
271 up64
= compat_alloc_user_space(sizeof(s64
));
273 err
= sys_semctl(first
, second
, third
, fourth
);
276 if (copy_from_user(&s64
, up64
, sizeof(s64
)))
278 else if (version
== IPC_64
)
279 err2
= put_compat_semid64_ds(&s64
, compat_ptr(pad
));
281 err2
= put_compat_semid_ds(&s64
, compat_ptr(pad
));
287 if (version
== IPC_64
) {
288 err
= get_compat_semid64_ds(&s64
, compat_ptr(pad
));
290 err
= get_compat_semid_ds(&s64
, compat_ptr(pad
));
292 up64
= compat_alloc_user_space(sizeof(s64
));
293 if (copy_to_user(up64
, &s64
, sizeof(s64
)))
299 err
= sys_semctl(first
, second
, third
, fourth
);
309 long compat_do_msg_fill(void __user
*dest
, struct msg_msg
*msg
, size_t bufsz
)
311 struct compat_msgbuf __user
*msgp
= dest
;
314 if (put_user(msg
->m_type
, &msgp
->mtype
))
317 msgsz
= (bufsz
> msg
->m_ts
) ? msg
->m_ts
: bufsz
;
318 if (store_msg(msgp
->mtext
, msg
, msgsz
))
323 #ifdef CONFIG_ARCH_WANT_OLD_COMPAT_IPC
324 long compat_sys_semctl(int first
, int second
, int third
, void __user
*uptr
)
330 if (get_user(pad
, (u32 __user
*) uptr
))
332 return do_compat_semctl(first
, second
, third
, pad
);
335 long compat_sys_msgsnd(int first
, int second
, int third
, void __user
*uptr
)
337 struct compat_msgbuf __user
*up
= uptr
;
345 if (get_user(type
, &up
->mtype
))
348 return do_msgsnd(first
, type
, up
->mtext
, second
, third
);
351 long compat_sys_msgrcv(int first
, int second
, int msgtyp
, int third
,
352 int version
, void __user
*uptr
)
360 struct compat_ipc_kludge ipck
;
363 if (copy_from_user (&ipck
, uptr
, sizeof(ipck
)))
365 uptr
= compat_ptr(ipck
.msgp
);
366 msgtyp
= ipck
.msgtyp
;
368 return do_msgrcv(first
, uptr
, second
, msgtyp
, third
,
372 long compat_sys_semctl(int semid
, int semnum
, int cmd
, int arg
)
374 return do_compat_semctl(semid
, semnum
, cmd
, arg
);
377 long compat_sys_msgsnd(int msqid
, struct compat_msgbuf __user
*msgp
,
378 compat_ssize_t msgsz
, int msgflg
)
382 if (get_user(mtype
, &msgp
->mtype
))
384 return do_msgsnd(msqid
, mtype
, msgp
->mtext
, (ssize_t
)msgsz
, msgflg
);
387 long compat_sys_msgrcv(int msqid
, struct compat_msgbuf __user
*msgp
,
388 compat_ssize_t msgsz
, long msgtyp
, int msgflg
)
390 return do_msgrcv(msqid
, msgp
, (ssize_t
)msgsz
, msgtyp
, msgflg
,
395 static inline int get_compat_msqid64(struct msqid64_ds
*m64
,
396 struct compat_msqid64_ds __user
*up64
)
400 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
)))
402 err
= __get_compat_ipc64_perm(&m64
->msg_perm
, &up64
->msg_perm
);
403 err
|= __get_user(m64
->msg_qbytes
, &up64
->msg_qbytes
);
407 static inline int get_compat_msqid(struct msqid64_ds
*m
,
408 struct compat_msqid_ds __user
*up
)
412 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)))
414 err
= __get_compat_ipc_perm(&m
->msg_perm
, &up
->msg_perm
);
415 err
|= __get_user(m
->msg_qbytes
, &up
->msg_qbytes
);
419 static inline int put_compat_msqid64_ds(struct msqid64_ds
*m64
,
420 struct compat_msqid64_ds __user
*up64
)
424 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
426 err
= __put_compat_ipc64_perm(&m64
->msg_perm
, &up64
->msg_perm
);
427 err
|= __put_user(m64
->msg_stime
, &up64
->msg_stime
);
428 err
|= __put_user(m64
->msg_rtime
, &up64
->msg_rtime
);
429 err
|= __put_user(m64
->msg_ctime
, &up64
->msg_ctime
);
430 err
|= __put_user(m64
->msg_cbytes
, &up64
->msg_cbytes
);
431 err
|= __put_user(m64
->msg_qnum
, &up64
->msg_qnum
);
432 err
|= __put_user(m64
->msg_qbytes
, &up64
->msg_qbytes
);
433 err
|= __put_user(m64
->msg_lspid
, &up64
->msg_lspid
);
434 err
|= __put_user(m64
->msg_lrpid
, &up64
->msg_lrpid
);
438 static inline int put_compat_msqid_ds(struct msqid64_ds
*m
,
439 struct compat_msqid_ds __user
*up
)
443 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
445 err
= __put_compat_ipc_perm(&m
->msg_perm
, &up
->msg_perm
);
446 err
|= __put_user(m
->msg_stime
, &up
->msg_stime
);
447 err
|= __put_user(m
->msg_rtime
, &up
->msg_rtime
);
448 err
|= __put_user(m
->msg_ctime
, &up
->msg_ctime
);
449 err
|= __put_user(m
->msg_cbytes
, &up
->msg_cbytes
);
450 err
|= __put_user(m
->msg_qnum
, &up
->msg_qnum
);
451 err
|= __put_user(m
->msg_qbytes
, &up
->msg_qbytes
);
452 err
|= __put_user(m
->msg_lspid
, &up
->msg_lspid
);
453 err
|= __put_user(m
->msg_lrpid
, &up
->msg_lrpid
);
457 long compat_sys_msgctl(int first
, int second
, void __user
*uptr
)
460 struct msqid64_ds m64
;
461 int version
= compat_ipc_parse_version(&second
);
464 memset(&m64
, 0, sizeof(m64
));
466 switch (second
& (~IPC_64
)) {
470 err
= sys_msgctl(first
, second
, uptr
);
474 if (version
== IPC_64
) {
475 err
= get_compat_msqid64(&m64
, uptr
);
477 err
= get_compat_msqid(&m64
, uptr
);
481 p
= compat_alloc_user_space(sizeof(m64
));
482 if (copy_to_user(p
, &m64
, sizeof(m64
)))
485 err
= sys_msgctl(first
, second
, p
);
490 p
= compat_alloc_user_space(sizeof(m64
));
491 err
= sys_msgctl(first
, second
, p
);
494 if (copy_from_user(&m64
, p
, sizeof(m64
)))
496 else if (version
== IPC_64
)
497 err2
= put_compat_msqid64_ds(&m64
, uptr
);
499 err2
= put_compat_msqid_ds(&m64
, uptr
);
511 #ifndef COMPAT_SHMLBA
512 #define COMPAT_SHMLBA SHMLBA
515 #ifdef CONFIG_ARCH_WANT_OLD_COMPAT_IPC
516 long compat_sys_shmat(int first
, int second
, compat_uptr_t third
, int version
,
521 compat_ulong_t __user
*uaddr
;
525 err
= do_shmat(first
, uptr
, second
, &raddr
, COMPAT_SHMLBA
);
528 uaddr
= compat_ptr(third
);
529 return put_user(raddr
, uaddr
);
532 long compat_sys_shmat(int shmid
, compat_uptr_t shmaddr
, int shmflg
)
537 err
= do_shmat(shmid
, compat_ptr(shmaddr
), shmflg
, &ret
, COMPAT_SHMLBA
);
540 force_successful_syscall_return();
545 static inline int get_compat_shmid64_ds(struct shmid64_ds
*s64
,
546 struct compat_shmid64_ds __user
*up64
)
548 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
)))
550 return __get_compat_ipc64_perm(&s64
->shm_perm
, &up64
->shm_perm
);
553 static inline int get_compat_shmid_ds(struct shmid64_ds
*s
,
554 struct compat_shmid_ds __user
*up
)
556 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)))
558 return __get_compat_ipc_perm(&s
->shm_perm
, &up
->shm_perm
);
561 static inline int put_compat_shmid64_ds(struct shmid64_ds
*s64
,
562 struct compat_shmid64_ds __user
*up64
)
566 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
568 err
= __put_compat_ipc64_perm(&s64
->shm_perm
, &up64
->shm_perm
);
569 err
|= __put_user(s64
->shm_atime
, &up64
->shm_atime
);
570 err
|= __put_user(s64
->shm_dtime
, &up64
->shm_dtime
);
571 err
|= __put_user(s64
->shm_ctime
, &up64
->shm_ctime
);
572 err
|= __put_user(s64
->shm_segsz
, &up64
->shm_segsz
);
573 err
|= __put_user(s64
->shm_nattch
, &up64
->shm_nattch
);
574 err
|= __put_user(s64
->shm_cpid
, &up64
->shm_cpid
);
575 err
|= __put_user(s64
->shm_lpid
, &up64
->shm_lpid
);
579 static inline int put_compat_shmid_ds(struct shmid64_ds
*s
,
580 struct compat_shmid_ds __user
*up
)
584 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
586 err
= __put_compat_ipc_perm(&s
->shm_perm
, &up
->shm_perm
);
587 err
|= __put_user(s
->shm_atime
, &up
->shm_atime
);
588 err
|= __put_user(s
->shm_dtime
, &up
->shm_dtime
);
589 err
|= __put_user(s
->shm_ctime
, &up
->shm_ctime
);
590 err
|= __put_user(s
->shm_segsz
, &up
->shm_segsz
);
591 err
|= __put_user(s
->shm_nattch
, &up
->shm_nattch
);
592 err
|= __put_user(s
->shm_cpid
, &up
->shm_cpid
);
593 err
|= __put_user(s
->shm_lpid
, &up
->shm_lpid
);
597 static inline int put_compat_shminfo64(struct shminfo64
*smi
,
598 struct compat_shminfo64 __user
*up64
)
602 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
)))
604 if (smi
->shmmax
> INT_MAX
)
605 smi
->shmmax
= INT_MAX
;
606 err
= __put_user(smi
->shmmax
, &up64
->shmmax
);
607 err
|= __put_user(smi
->shmmin
, &up64
->shmmin
);
608 err
|= __put_user(smi
->shmmni
, &up64
->shmmni
);
609 err
|= __put_user(smi
->shmseg
, &up64
->shmseg
);
610 err
|= __put_user(smi
->shmall
, &up64
->shmall
);
614 static inline int put_compat_shminfo(struct shminfo64
*smi
,
615 struct shminfo __user
*up
)
619 if (!access_ok(VERIFY_WRITE
, up
, sizeof(*up
)))
621 if (smi
->shmmax
> INT_MAX
)
622 smi
->shmmax
= INT_MAX
;
623 err
= __put_user(smi
->shmmax
, &up
->shmmax
);
624 err
|= __put_user(smi
->shmmin
, &up
->shmmin
);
625 err
|= __put_user(smi
->shmmni
, &up
->shmmni
);
626 err
|= __put_user(smi
->shmseg
, &up
->shmseg
);
627 err
|= __put_user(smi
->shmall
, &up
->shmall
);
631 static inline int put_compat_shm_info(struct shm_info __user
*ip
,
632 struct compat_shm_info __user
*uip
)
637 if (!access_ok(VERIFY_WRITE
, uip
, sizeof(*uip
)) ||
638 copy_from_user(&si
, ip
, sizeof(si
)))
640 err
= __put_user(si
.used_ids
, &uip
->used_ids
);
641 err
|= __put_user(si
.shm_tot
, &uip
->shm_tot
);
642 err
|= __put_user(si
.shm_rss
, &uip
->shm_rss
);
643 err
|= __put_user(si
.shm_swp
, &uip
->shm_swp
);
644 err
|= __put_user(si
.swap_attempts
, &uip
->swap_attempts
);
645 err
|= __put_user(si
.swap_successes
, &uip
->swap_successes
);
649 long compat_sys_shmctl(int first
, int second
, void __user
*uptr
)
652 struct shmid64_ds s64
;
653 struct shminfo64 smi
;
655 int version
= compat_ipc_parse_version(&second
);
657 memset(&s64
, 0, sizeof(s64
));
659 switch (second
& (~IPC_64
)) {
663 err
= sys_shmctl(first
, second
, uptr
);
667 p
= compat_alloc_user_space(sizeof(smi
));
668 err
= sys_shmctl(first
, second
, p
);
671 if (copy_from_user(&smi
, p
, sizeof(smi
)))
673 else if (version
== IPC_64
)
674 err2
= put_compat_shminfo64(&smi
, uptr
);
676 err2
= put_compat_shminfo(&smi
, uptr
);
683 if (version
== IPC_64
) {
684 err
= get_compat_shmid64_ds(&s64
, uptr
);
686 err
= get_compat_shmid_ds(&s64
, uptr
);
690 p
= compat_alloc_user_space(sizeof(s64
));
691 if (copy_to_user(p
, &s64
, sizeof(s64
)))
694 err
= sys_shmctl(first
, second
, p
);
699 p
= compat_alloc_user_space(sizeof(s64
));
700 err
= sys_shmctl(first
, second
, p
);
703 if (copy_from_user(&s64
, p
, sizeof(s64
)))
705 else if (version
== IPC_64
)
706 err2
= put_compat_shmid64_ds(&s64
, uptr
);
708 err2
= put_compat_shmid_ds(&s64
, uptr
);
714 p
= compat_alloc_user_space(sizeof(struct shm_info
));
715 err
= sys_shmctl(first
, second
, p
);
718 err2
= put_compat_shm_info(p
, uptr
);
730 long compat_sys_semtimedop(int semid
, struct sembuf __user
*tsems
,
731 unsigned nsops
, const struct compat_timespec __user
*timeout
)
733 struct timespec __user
*ts64
= NULL
;
736 ts64
= compat_alloc_user_space(sizeof(*ts64
));
737 if (get_compat_timespec(&ts
, timeout
))
739 if (copy_to_user(ts64
, &ts
, sizeof(ts
)))
742 return sys_semtimedop(semid
, tsems
, nsops
, ts64
);