2 * Conversion between 32-bit and 64-bit native system calls.
4 * Copyright (C) 2000 Silicon Graphics, Inc.
5 * Written by Ulf Carlsson (ulfc@engr.sgi.com)
6 * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com)
8 #include <linux/config.h>
9 #include <linux/compiler.h>
11 #include <linux/errno.h>
12 #include <linux/file.h>
13 #include <linux/smp_lock.h>
14 #include <linux/highuid.h>
15 #include <linux/dirent.h>
16 #include <linux/resource.h>
17 #include <linux/highmem.h>
18 #include <linux/time.h>
19 #include <linux/times.h>
20 #include <linux/poll.h>
21 #include <linux/slab.h>
22 #include <linux/skbuff.h>
23 #include <linux/filter.h>
24 #include <linux/shm.h>
25 #include <linux/sem.h>
26 #include <linux/msg.h>
27 #include <linux/icmpv6.h>
28 #include <linux/syscalls.h>
29 #include <linux/sysctl.h>
30 #include <linux/utime.h>
31 #include <linux/utsname.h>
32 #include <linux/personality.h>
33 #include <linux/timex.h>
34 #include <linux/dnotify.h>
35 #include <linux/module.h>
36 #include <linux/binfmts.h>
37 #include <linux/security.h>
38 #include <linux/compat.h>
39 #include <linux/vfs.h>
46 #include <asm/uaccess.h>
47 #include <asm/mmu_context.h>
50 /* Use this to get at 32-bit user passed pointers. */
51 /* A() macro should be used for places where you e.g.
52 have some internal variable u32 and just want to get
53 rid of a compiler warning. AA() has to be used in
54 places where you want to convert a function argument
55 to 32bit pointer or when you e.g. access pt_regs
56 structure and want to consider 32bit registers only.
58 #define A(__x) ((unsigned long)(__x))
59 #define AA(__x) ((unsigned long)((int)__x))
62 #define merge_64(r1,r2) ((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL))
65 #define merge_64(r1,r2) ((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL))
69 * Revalidate the inode. This is required for proper NFS attribute caching.
72 int cp_compat_stat(struct kstat
*stat
, struct compat_stat __user
*statbuf
)
74 struct compat_stat tmp
;
76 if (!new_valid_dev(stat
->dev
) || !new_valid_dev(stat
->rdev
))
79 memset(&tmp
, 0, sizeof(tmp
));
80 tmp
.st_dev
= new_encode_dev(stat
->dev
);
81 tmp
.st_ino
= stat
->ino
;
82 tmp
.st_mode
= stat
->mode
;
83 tmp
.st_nlink
= stat
->nlink
;
84 SET_UID(tmp
.st_uid
, stat
->uid
);
85 SET_GID(tmp
.st_gid
, stat
->gid
);
86 tmp
.st_rdev
= new_encode_dev(stat
->rdev
);
87 tmp
.st_size
= stat
->size
;
88 tmp
.st_atime
= stat
->atime
.tv_sec
;
89 tmp
.st_mtime
= stat
->mtime
.tv_sec
;
90 tmp
.st_ctime
= stat
->ctime
.tv_sec
;
92 tmp
.st_atime_nsec
= stat
->atime
.tv_nsec
;
93 tmp
.st_mtime_nsec
= stat
->mtime
.tv_nsec
;
94 tmp
.st_ctime_nsec
= stat
->ctime
.tv_nsec
;
96 tmp
.st_blocks
= stat
->blocks
;
97 tmp
.st_blksize
= stat
->blksize
;
98 return copy_to_user(statbuf
,&tmp
,sizeof(tmp
)) ? -EFAULT
: 0;
101 asmlinkage
unsigned long
102 sys32_mmap2(unsigned long addr
, unsigned long len
, unsigned long prot
,
103 unsigned long flags
, unsigned long fd
, unsigned long pgoff
)
105 struct file
* file
= NULL
;
109 if (!(flags
& MAP_ANONYMOUS
)) {
115 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
117 down_write(¤t
->mm
->mmap_sem
);
118 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
119 up_write(¤t
->mm
->mmap_sem
);
128 asmlinkage
int sys_truncate64(const char __user
*path
, unsigned int high
,
133 return sys_truncate(path
, ((long) high
<< 32) | low
);
136 asmlinkage
int sys_ftruncate64(unsigned int fd
, unsigned int high
,
141 return sys_ftruncate(fd
, ((long) high
<< 32) | low
);
145 * sys_execve() executes a new program.
147 asmlinkage
int sys32_execve(nabi_no_regargs
struct pt_regs regs
)
152 filename
= getname(compat_ptr(regs
.regs
[4]));
153 error
= PTR_ERR(filename
);
154 if (IS_ERR(filename
))
156 error
= compat_do_execve(filename
, compat_ptr(regs
.regs
[5]),
157 compat_ptr(regs
.regs
[6]), ®s
);
165 sysn32_waitid(int which
, compat_pid_t pid
,
166 siginfo_t __user
*uinfo
, int options
,
167 struct compat_rusage __user
*uru
)
171 mm_segment_t old_fs
= get_fs();
174 if (!access_ok(VERIFY_WRITE
, uinfo
, sizeof(*uinfo
)))
178 ret
= sys_waitid(which
, pid
, uinfo
, options
,
179 uru
? (struct rusage __user
*) &ru
: NULL
);
182 if (__get_user(si_signo
, &uinfo
->si_signo
))
184 if (ret
< 0 || si_signo
== 0)
188 ret
= put_compat_rusage(&ru
, uru
);
208 asmlinkage
int sys32_sysinfo(struct sysinfo32 __user
*info
)
212 mm_segment_t old_fs
= get_fs ();
215 ret
= sys_sysinfo((struct sysinfo __user
*)&s
);
217 err
= put_user (s
.uptime
, &info
->uptime
);
218 err
|= __put_user (s
.loads
[0], &info
->loads
[0]);
219 err
|= __put_user (s
.loads
[1], &info
->loads
[1]);
220 err
|= __put_user (s
.loads
[2], &info
->loads
[2]);
221 err
|= __put_user (s
.totalram
, &info
->totalram
);
222 err
|= __put_user (s
.freeram
, &info
->freeram
);
223 err
|= __put_user (s
.sharedram
, &info
->sharedram
);
224 err
|= __put_user (s
.bufferram
, &info
->bufferram
);
225 err
|= __put_user (s
.totalswap
, &info
->totalswap
);
226 err
|= __put_user (s
.freeswap
, &info
->freeswap
);
227 err
|= __put_user (s
.procs
, &info
->procs
);
228 err
|= __put_user (s
.totalhigh
, &info
->totalhigh
);
229 err
|= __put_user (s
.freehigh
, &info
->freehigh
);
230 err
|= __put_user (s
.mem_unit
, &info
->mem_unit
);
236 #define RLIM_INFINITY32 0x7fffffff
237 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
245 asmlinkage
long sys32_truncate64(const char __user
* path
, unsigned long __dummy
,
246 int length_hi
, int length_lo
)
249 asmlinkage
long sys32_truncate64(const char __user
* path
, unsigned long __dummy
,
250 int length_lo
, int length_hi
)
255 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
257 return sys_truncate(path
, length
);
261 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
262 int length_hi
, int length_lo
)
265 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
266 int length_lo
, int length_hi
)
271 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
273 return sys_ftruncate(fd
, length
);
277 get_tv32(struct timeval
*o
, struct compat_timeval __user
*i
)
279 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
280 (__get_user(o
->tv_sec
, &i
->tv_sec
) |
281 __get_user(o
->tv_usec
, &i
->tv_usec
)));
285 put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
287 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
288 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
289 __put_user(i
->tv_usec
, &o
->tv_usec
)));
292 extern struct timezone sys_tz
;
295 sys32_gettimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
299 do_gettimeofday(&ktv
);
300 if (put_tv32(tv
, &ktv
))
304 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
310 static inline long get_ts32(struct timespec
*o
, struct compat_timeval __user
*i
)
314 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
316 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
318 if (__get_user(usec
, &i
->tv_usec
))
320 o
->tv_nsec
= usec
* 1000;
325 sys32_settimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
331 if (get_ts32(&kts
, tv
))
335 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
339 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
342 asmlinkage
int sys32_llseek(unsigned int fd
, unsigned int offset_high
,
343 unsigned int offset_low
, loff_t __user
* result
,
346 return sys_llseek(fd
, offset_high
, offset_low
, result
, origin
);
349 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
350 lseek back to original location. They fail just like lseek does on
351 non-seekable files. */
353 asmlinkage ssize_t
sys32_pread(unsigned int fd
, char __user
* buf
,
354 size_t count
, u32 unused
, u64 a4
, u64 a5
)
358 ssize_t (*read
)(struct file
*, char __user
*, size_t, loff_t
*);
365 if (!(file
->f_mode
& FMODE_READ
))
367 pos
= merge_64(a4
, a5
);
368 ret
= rw_verify_area(READ
, file
, &pos
, count
);
372 if (!file
->f_op
|| !(read
= file
->f_op
->read
))
377 if (!(file
->f_mode
& FMODE_PREAD
))
379 ret
= read(file
, buf
, count
, &pos
);
381 dnotify_parent(file
->f_dentry
, DN_ACCESS
);
388 asmlinkage ssize_t
sys32_pwrite(unsigned int fd
, const char __user
* buf
,
389 size_t count
, u32 unused
, u64 a4
, u64 a5
)
393 ssize_t (*write
)(struct file
*, const char __user
*, size_t, loff_t
*);
400 if (!(file
->f_mode
& FMODE_WRITE
))
402 pos
= merge_64(a4
, a5
);
403 ret
= rw_verify_area(WRITE
, file
, &pos
, count
);
407 if (!file
->f_op
|| !(write
= file
->f_op
->write
))
413 if (!(file
->f_mode
& FMODE_PWRITE
))
416 ret
= write(file
, buf
, count
, &pos
);
418 dnotify_parent(file
->f_dentry
, DN_MODIFY
);
425 asmlinkage
int sys32_sched_rr_get_interval(compat_pid_t pid
,
426 struct compat_timespec __user
*interval
)
430 mm_segment_t old_fs
= get_fs ();
433 ret
= sys_sched_rr_get_interval(pid
, (struct timespec __user
*)&t
);
435 if (put_user (t
.tv_sec
, &interval
->tv_sec
) ||
436 __put_user (t
.tv_nsec
, &interval
->tv_nsec
))
441 struct msgbuf32
{ s32 mtype
; char mtext
[1]; };
454 struct ipc64_perm32
{
462 unsigned short __pad1
;
463 unsigned int __unused1
;
464 unsigned int __unused2
;
468 struct ipc_perm32 sem_perm
; /* permissions .. see ipc.h */
469 compat_time_t sem_otime
; /* last semop time */
470 compat_time_t sem_ctime
; /* last change time */
471 u32 sem_base
; /* ptr to first semaphore in array */
472 u32 sem_pending
; /* pending operations to be processed */
473 u32 sem_pending_last
; /* last pending operation */
474 u32 undo
; /* undo requests on this array */
475 unsigned short sem_nsems
; /* no. of semaphores in array */
478 struct semid64_ds32
{
479 struct ipc64_perm32 sem_perm
;
480 compat_time_t sem_otime
;
481 compat_time_t sem_ctime
;
482 unsigned int sem_nsems
;
483 unsigned int __unused1
;
484 unsigned int __unused2
;
489 struct ipc_perm32 msg_perm
;
492 compat_time_t msg_stime
;
493 compat_time_t msg_rtime
;
494 compat_time_t msg_ctime
;
497 unsigned short msg_cbytes
;
498 unsigned short msg_qnum
;
499 unsigned short msg_qbytes
;
500 compat_ipc_pid_t msg_lspid
;
501 compat_ipc_pid_t msg_lrpid
;
504 struct msqid64_ds32
{
505 struct ipc64_perm32 msg_perm
;
506 compat_time_t msg_stime
;
507 unsigned int __unused1
;
508 compat_time_t msg_rtime
;
509 unsigned int __unused2
;
510 compat_time_t msg_ctime
;
511 unsigned int __unused3
;
512 unsigned int msg_cbytes
;
513 unsigned int msg_qnum
;
514 unsigned int msg_qbytes
;
515 compat_pid_t msg_lspid
;
516 compat_pid_t msg_lrpid
;
517 unsigned int __unused4
;
518 unsigned int __unused5
;
522 struct ipc_perm32 shm_perm
;
524 compat_time_t shm_atime
;
525 compat_time_t shm_dtime
;
526 compat_time_t shm_ctime
;
527 compat_ipc_pid_t shm_cpid
;
528 compat_ipc_pid_t shm_lpid
;
529 unsigned short shm_nattch
;
532 struct shmid64_ds32
{
533 struct ipc64_perm32 shm_perm
;
534 compat_size_t shm_segsz
;
535 compat_time_t shm_atime
;
536 compat_time_t shm_dtime
;
537 compat_time_t shm_ctime
;
538 compat_pid_t shm_cpid
;
539 compat_pid_t shm_lpid
;
540 unsigned int shm_nattch
;
541 unsigned int __unused1
;
542 unsigned int __unused2
;
545 struct ipc_kludge32
{
551 do_sys32_semctl(int first
, int second
, int third
, void __user
*uptr
)
562 if (get_user (pad
, (u32 __user
*)uptr
))
564 if ((third
& ~IPC_64
) == SETVAL
)
565 fourth
.val
= (int)pad
;
567 fourth
.__pad
= (void __user
*)A(pad
);
568 switch (third
& ~IPC_64
) {
580 err
= sys_semctl (first
, second
, third
, fourth
);
585 fourth
.__pad
= (struct semid64_ds __user
*)&s
;
588 err
= sys_semctl(first
, second
, third
| IPC_64
, fourth
);
591 if (third
& IPC_64
) {
592 struct semid64_ds32 __user
*usp64
= (struct semid64_ds32 __user
*) A(pad
);
594 if (!access_ok(VERIFY_WRITE
, usp64
, sizeof(*usp64
))) {
598 err2
= __put_user(s
.sem_perm
.key
, &usp64
->sem_perm
.key
);
599 err2
|= __put_user(s
.sem_perm
.uid
, &usp64
->sem_perm
.uid
);
600 err2
|= __put_user(s
.sem_perm
.gid
, &usp64
->sem_perm
.gid
);
601 err2
|= __put_user(s
.sem_perm
.cuid
, &usp64
->sem_perm
.cuid
);
602 err2
|= __put_user(s
.sem_perm
.cgid
, &usp64
->sem_perm
.cgid
);
603 err2
|= __put_user(s
.sem_perm
.mode
, &usp64
->sem_perm
.mode
);
604 err2
|= __put_user(s
.sem_perm
.seq
, &usp64
->sem_perm
.seq
);
605 err2
|= __put_user(s
.sem_otime
, &usp64
->sem_otime
);
606 err2
|= __put_user(s
.sem_ctime
, &usp64
->sem_ctime
);
607 err2
|= __put_user(s
.sem_nsems
, &usp64
->sem_nsems
);
609 struct semid_ds32 __user
*usp32
= (struct semid_ds32 __user
*) A(pad
);
611 if (!access_ok(VERIFY_WRITE
, usp32
, sizeof(*usp32
))) {
615 err2
= __put_user(s
.sem_perm
.key
, &usp32
->sem_perm
.key
);
616 err2
|= __put_user(s
.sem_perm
.uid
, &usp32
->sem_perm
.uid
);
617 err2
|= __put_user(s
.sem_perm
.gid
, &usp32
->sem_perm
.gid
);
618 err2
|= __put_user(s
.sem_perm
.cuid
, &usp32
->sem_perm
.cuid
);
619 err2
|= __put_user(s
.sem_perm
.cgid
, &usp32
->sem_perm
.cgid
);
620 err2
|= __put_user(s
.sem_perm
.mode
, &usp32
->sem_perm
.mode
);
621 err2
|= __put_user(s
.sem_perm
.seq
, &usp32
->sem_perm
.seq
);
622 err2
|= __put_user(s
.sem_otime
, &usp32
->sem_otime
);
623 err2
|= __put_user(s
.sem_ctime
, &usp32
->sem_ctime
);
624 err2
|= __put_user(s
.sem_nsems
, &usp32
->sem_nsems
);
639 do_sys32_msgsnd (int first
, int second
, int third
, void __user
*uptr
)
641 struct msgbuf32 __user
*up
= (struct msgbuf32 __user
*)uptr
;
648 p
= kmalloc (second
+ sizeof (struct msgbuf
)
652 err
= get_user (p
->mtype
, &up
->mtype
);
655 err
|= __copy_from_user (p
->mtext
, &up
->mtext
, second
);
660 err
= sys_msgsnd (first
, (struct msgbuf __user
*)p
, second
, third
);
669 do_sys32_msgrcv (int first
, int second
, int msgtyp
, int third
,
670 int version
, void __user
*uptr
)
672 struct msgbuf32 __user
*up
;
678 struct ipc_kludge32 __user
*uipck
= (struct ipc_kludge32 __user
*)uptr
;
679 struct ipc_kludge32 ipck
;
685 if (copy_from_user (&ipck
, uipck
, sizeof (struct ipc_kludge32
)))
687 uptr
= (void __user
*)AA(ipck
.msgp
);
688 msgtyp
= ipck
.msgtyp
;
694 p
= kmalloc (second
+ sizeof (struct msgbuf
) + 4, GFP_USER
);
699 err
= sys_msgrcv (first
, (struct msgbuf __user
*)p
, second
+ 4, msgtyp
, third
);
703 up
= (struct msgbuf32 __user
*)uptr
;
704 if (put_user (p
->mtype
, &up
->mtype
) ||
705 __copy_to_user (&up
->mtext
, p
->mtext
, err
))
714 do_sys32_msgctl (int first
, int second
, void __user
*uptr
)
716 int err
= -EINVAL
, err2
;
718 struct msqid_ds32 __user
*up32
= (struct msqid_ds32 __user
*)uptr
;
719 struct msqid64_ds32 __user
*up64
= (struct msqid64_ds32 __user
*)uptr
;
722 switch (second
& ~IPC_64
) {
726 err
= sys_msgctl (first
, second
, (struct msqid_ds __user
*)uptr
);
730 if (second
& IPC_64
) {
731 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
))) {
735 err
= __get_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
736 err
|= __get_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
737 err
|= __get_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
738 err
|= __get_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
740 if (!access_ok(VERIFY_READ
, up32
, sizeof(*up32
))) {
744 err
= __get_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
745 err
|= __get_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
746 err
|= __get_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
747 err
|= __get_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
753 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds __user
*)&m
);
761 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds __user
*)&m
);
763 if (second
& IPC_64
) {
764 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
768 err2
= __put_user(m
.msg_perm
.key
, &up64
->msg_perm
.key
);
769 err2
|= __put_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
770 err2
|= __put_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
771 err2
|= __put_user(m
.msg_perm
.cuid
, &up64
->msg_perm
.cuid
);
772 err2
|= __put_user(m
.msg_perm
.cgid
, &up64
->msg_perm
.cgid
);
773 err2
|= __put_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
774 err2
|= __put_user(m
.msg_perm
.seq
, &up64
->msg_perm
.seq
);
775 err2
|= __put_user(m
.msg_stime
, &up64
->msg_stime
);
776 err2
|= __put_user(m
.msg_rtime
, &up64
->msg_rtime
);
777 err2
|= __put_user(m
.msg_ctime
, &up64
->msg_ctime
);
778 err2
|= __put_user(m
.msg_cbytes
, &up64
->msg_cbytes
);
779 err2
|= __put_user(m
.msg_qnum
, &up64
->msg_qnum
);
780 err2
|= __put_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
781 err2
|= __put_user(m
.msg_lspid
, &up64
->msg_lspid
);
782 err2
|= __put_user(m
.msg_lrpid
, &up64
->msg_lrpid
);
786 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
790 err2
= __put_user(m
.msg_perm
.key
, &up32
->msg_perm
.key
);
791 err2
|= __put_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
792 err2
|= __put_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
793 err2
|= __put_user(m
.msg_perm
.cuid
, &up32
->msg_perm
.cuid
);
794 err2
|= __put_user(m
.msg_perm
.cgid
, &up32
->msg_perm
.cgid
);
795 err2
|= __put_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
796 err2
|= __put_user(m
.msg_perm
.seq
, &up32
->msg_perm
.seq
);
797 err2
|= __put_user(m
.msg_stime
, &up32
->msg_stime
);
798 err2
|= __put_user(m
.msg_rtime
, &up32
->msg_rtime
);
799 err2
|= __put_user(m
.msg_ctime
, &up32
->msg_ctime
);
800 err2
|= __put_user(m
.msg_cbytes
, &up32
->msg_cbytes
);
801 err2
|= __put_user(m
.msg_qnum
, &up32
->msg_qnum
);
802 err2
|= __put_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
803 err2
|= __put_user(m
.msg_lspid
, &up32
->msg_lspid
);
804 err2
|= __put_user(m
.msg_lrpid
, &up32
->msg_lrpid
);
815 do_sys32_shmat (int first
, int second
, int third
, int version
, void __user
*uptr
)
818 u32 __user
*uaddr
= (u32 __user
*)A((u32
)third
);
823 err
= do_shmat (first
, uptr
, second
, &raddr
);
826 err
= put_user (raddr
, uaddr
);
832 u32 shm_tot
, shm_rss
, shm_swp
;
833 u32 swap_attempts
, swap_successes
;
837 do_sys32_shmctl (int first
, int second
, void __user
*uptr
)
839 struct shmid64_ds32 __user
*up64
= (struct shmid64_ds32 __user
*)uptr
;
840 struct shmid_ds32 __user
*up32
= (struct shmid_ds32 __user
*)uptr
;
841 struct shm_info32 __user
*uip
= (struct shm_info32 __user
*)uptr
;
842 int err
= -EFAULT
, err2
;
843 struct shmid64_ds s64
;
848 switch (second
& ~IPC_64
) {
850 second
= IPC_INFO
; /* So that we don't have to translate it */
854 err
= sys_shmctl(first
, second
, (struct shmid_ds __user
*)uptr
);
857 if (second
& IPC_64
) {
858 err
= get_user(s
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
859 err
|= get_user(s
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
860 err
|= get_user(s
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
862 err
= get_user(s
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
863 err
|= get_user(s
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
864 err
|= get_user(s
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
870 err
= sys_shmctl(first
, second
& ~IPC_64
, (struct shmid_ds __user
*)&s
);
878 err
= sys_shmctl(first
, second
| IPC_64
, (void __user
*) &s64
);
882 if (second
& IPC_64
) {
883 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
887 err2
= __put_user(s64
.shm_perm
.key
, &up64
->shm_perm
.key
);
888 err2
|= __put_user(s64
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
889 err2
|= __put_user(s64
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
890 err2
|= __put_user(s64
.shm_perm
.cuid
, &up64
->shm_perm
.cuid
);
891 err2
|= __put_user(s64
.shm_perm
.cgid
, &up64
->shm_perm
.cgid
);
892 err2
|= __put_user(s64
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
893 err2
|= __put_user(s64
.shm_perm
.seq
, &up64
->shm_perm
.seq
);
894 err2
|= __put_user(s64
.shm_atime
, &up64
->shm_atime
);
895 err2
|= __put_user(s64
.shm_dtime
, &up64
->shm_dtime
);
896 err2
|= __put_user(s64
.shm_ctime
, &up64
->shm_ctime
);
897 err2
|= __put_user(s64
.shm_segsz
, &up64
->shm_segsz
);
898 err2
|= __put_user(s64
.shm_nattch
, &up64
->shm_nattch
);
899 err2
|= __put_user(s64
.shm_cpid
, &up64
->shm_cpid
);
900 err2
|= __put_user(s64
.shm_lpid
, &up64
->shm_lpid
);
902 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
906 err2
= __put_user(s64
.shm_perm
.key
, &up32
->shm_perm
.key
);
907 err2
|= __put_user(s64
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
908 err2
|= __put_user(s64
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
909 err2
|= __put_user(s64
.shm_perm
.cuid
, &up32
->shm_perm
.cuid
);
910 err2
|= __put_user(s64
.shm_perm
.cgid
, &up32
->shm_perm
.cgid
);
911 err2
|= __put_user(s64
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
912 err2
|= __put_user(s64
.shm_perm
.seq
, &up32
->shm_perm
.seq
);
913 err2
|= __put_user(s64
.shm_atime
, &up32
->shm_atime
);
914 err2
|= __put_user(s64
.shm_dtime
, &up32
->shm_dtime
);
915 err2
|= __put_user(s64
.shm_ctime
, &up32
->shm_ctime
);
916 err2
|= __put_user(s64
.shm_segsz
, &up32
->shm_segsz
);
917 err2
|= __put_user(s64
.shm_nattch
, &up32
->shm_nattch
);
918 err2
|= __put_user(s64
.shm_cpid
, &up32
->shm_cpid
);
919 err2
|= __put_user(s64
.shm_lpid
, &up32
->shm_lpid
);
928 err
= sys_shmctl(first
, second
, (void __user
*)&si
);
932 err2
= put_user(si
.used_ids
, &uip
->used_ids
);
933 err2
|= __put_user(si
.shm_tot
, &uip
->shm_tot
);
934 err2
|= __put_user(si
.shm_rss
, &uip
->shm_rss
);
935 err2
|= __put_user(si
.shm_swp
, &uip
->shm_swp
);
936 err2
|= __put_user(si
.swap_attempts
, &uip
->swap_attempts
);
937 err2
|= __put_user (si
.swap_successes
, &uip
->swap_successes
);
950 static int sys32_semtimedop(int semid
, struct sembuf __user
*tsems
, int nsems
,
951 const struct compat_timespec __user
*timeout32
)
953 struct compat_timespec t32
;
954 struct timespec __user
*t64
= compat_alloc_user_space(sizeof(*t64
));
956 if (copy_from_user(&t32
, timeout32
, sizeof(t32
)))
959 if (put_user(t32
.tv_sec
, &t64
->tv_sec
) ||
960 put_user(t32
.tv_nsec
, &t64
->tv_nsec
))
963 return sys_semtimedop(semid
, tsems
, nsems
, t64
);
967 sys32_ipc (u32 call
, int first
, int second
, int third
, u32 ptr
, u32 fifth
)
971 version
= call
>> 16; /* hack for backward compatibility */
976 /* struct sembuf is the same on 32 and 64bit :)) */
977 err
= sys_semtimedop (first
, (struct sembuf __user
*)AA(ptr
), second
,
981 err
= sys32_semtimedop (first
, (struct sembuf __user
*)AA(ptr
), second
,
982 (const struct compat_timespec __user
*)AA(fifth
));
985 err
= sys_semget (first
, second
, third
);
988 err
= do_sys32_semctl (first
, second
, third
,
989 (void __user
*)AA(ptr
));
993 err
= do_sys32_msgsnd (first
, second
, third
,
994 (void __user
*)AA(ptr
));
997 err
= do_sys32_msgrcv (first
, second
, fifth
, third
,
998 version
, (void __user
*)AA(ptr
));
1001 err
= sys_msgget ((key_t
) first
, second
);
1004 err
= do_sys32_msgctl (first
, second
, (void __user
*)AA(ptr
));
1008 err
= do_sys32_shmat (first
, second
, third
,
1009 version
, (void __user
*)AA(ptr
));
1012 err
= sys_shmdt ((char __user
*)A(ptr
));
1015 err
= sys_shmget (first
, (unsigned)second
, third
);
1018 err
= do_sys32_shmctl (first
, second
, (void __user
*)AA(ptr
));
1028 asmlinkage
long sys32_shmat(int shmid
, char __user
*shmaddr
,
1029 int shmflg
, int32_t __user
*addr
)
1031 unsigned long raddr
;
1034 err
= do_shmat(shmid
, shmaddr
, shmflg
, &raddr
);
1038 return put_user(raddr
, addr
);
1041 struct sysctl_args32
1043 compat_caddr_t name
;
1045 compat_caddr_t oldval
;
1046 compat_caddr_t oldlenp
;
1047 compat_caddr_t newval
;
1048 compat_size_t newlen
;
1049 unsigned int __unused
[4];
1052 #ifdef CONFIG_SYSCTL
1054 asmlinkage
long sys32_sysctl(struct sysctl_args32 __user
*args
)
1056 struct sysctl_args32 tmp
;
1059 size_t __user
*oldlenp
= NULL
;
1060 unsigned long addr
= (((unsigned long)&args
->__unused
[0]) + 7) & ~7;
1062 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
1065 if (tmp
.oldval
&& tmp
.oldlenp
) {
1066 /* Duh, this is ugly and might not work if sysctl_args
1067 is in read-only memory, but do_sysctl does indirectly
1068 a lot of uaccess in both directions and we'd have to
1069 basically copy the whole sysctl.c here, and
1070 glibc's __sysctl uses rw memory for the structure
1072 if (get_user(oldlen
, (u32 __user
*)A(tmp
.oldlenp
)) ||
1073 put_user(oldlen
, (size_t __user
*)addr
))
1075 oldlenp
= (size_t __user
*)addr
;
1079 error
= do_sysctl((int __user
*)A(tmp
.name
), tmp
.nlen
, (void __user
*)A(tmp
.oldval
),
1080 oldlenp
, (void __user
*)A(tmp
.newval
), tmp
.newlen
);
1084 if (get_user(oldlen
, (size_t __user
*)addr
) ||
1085 put_user(oldlen
, (u32 __user
*)A(tmp
.oldlenp
)))
1088 copy_to_user(args
->__unused
, tmp
.__unused
, sizeof(tmp
.__unused
));
1093 #endif /* CONFIG_SYSCTL */
1095 asmlinkage
long sys32_newuname(struct new_utsname __user
* name
)
1099 down_read(&uts_sem
);
1100 if (copy_to_user(name
,&system_utsname
,sizeof *name
))
1104 if (current
->personality
== PER_LINUX32
&& !ret
)
1105 if (copy_to_user(name
->machine
, "mips\0\0\0", 8))
1111 asmlinkage
int sys32_personality(unsigned long personality
)
1114 if (current
->personality
== PER_LINUX32
&& personality
== PER_LINUX
)
1115 personality
= PER_LINUX32
;
1116 ret
= sys_personality(personality
);
1117 if (ret
== PER_LINUX32
)
1122 /* ustat compatibility */
1124 compat_daddr_t f_tfree
;
1125 compat_ino_t f_tinode
;
1130 extern asmlinkage
long sys_ustat(dev_t dev
, struct ustat __user
* ubuf
);
1132 asmlinkage
int sys32_ustat(dev_t dev
, struct ustat32 __user
* ubuf32
)
1136 struct ustat32 tmp32
;
1137 mm_segment_t old_fs
= get_fs();
1140 err
= sys_ustat(dev
, (struct ustat __user
*)&tmp
);
1146 memset(&tmp32
,0,sizeof(struct ustat32
));
1147 tmp32
.f_tfree
= tmp
.f_tfree
;
1148 tmp32
.f_tinode
= tmp
.f_tinode
;
1150 err
= copy_to_user(ubuf32
,&tmp32
,sizeof(struct ustat32
)) ? -EFAULT
: 0;
1156 /* Handle adjtimex compatibility. */
1160 s32 offset
, freq
, maxerror
, esterror
;
1161 s32 status
, constant
, precision
, tolerance
;
1162 struct compat_timeval time
;
1164 s32 ppsfreq
, jitter
, shift
, stabil
;
1165 s32 jitcnt
, calcnt
, errcnt
, stbcnt
;
1166 s32
:32; s32
:32; s32
:32; s32
:32;
1167 s32
:32; s32
:32; s32
:32; s32
:32;
1168 s32
:32; s32
:32; s32
:32; s32
:32;
1171 extern int do_adjtimex(struct timex
*);
1173 asmlinkage
int sys32_adjtimex(struct timex32 __user
*utp
)
1178 memset(&txc
, 0, sizeof(struct timex
));
1180 if (get_user(txc
.modes
, &utp
->modes
) ||
1181 __get_user(txc
.offset
, &utp
->offset
) ||
1182 __get_user(txc
.freq
, &utp
->freq
) ||
1183 __get_user(txc
.maxerror
, &utp
->maxerror
) ||
1184 __get_user(txc
.esterror
, &utp
->esterror
) ||
1185 __get_user(txc
.status
, &utp
->status
) ||
1186 __get_user(txc
.constant
, &utp
->constant
) ||
1187 __get_user(txc
.precision
, &utp
->precision
) ||
1188 __get_user(txc
.tolerance
, &utp
->tolerance
) ||
1189 __get_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1190 __get_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1191 __get_user(txc
.tick
, &utp
->tick
) ||
1192 __get_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1193 __get_user(txc
.jitter
, &utp
->jitter
) ||
1194 __get_user(txc
.shift
, &utp
->shift
) ||
1195 __get_user(txc
.stabil
, &utp
->stabil
) ||
1196 __get_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1197 __get_user(txc
.calcnt
, &utp
->calcnt
) ||
1198 __get_user(txc
.errcnt
, &utp
->errcnt
) ||
1199 __get_user(txc
.stbcnt
, &utp
->stbcnt
))
1202 ret
= do_adjtimex(&txc
);
1204 if (put_user(txc
.modes
, &utp
->modes
) ||
1205 __put_user(txc
.offset
, &utp
->offset
) ||
1206 __put_user(txc
.freq
, &utp
->freq
) ||
1207 __put_user(txc
.maxerror
, &utp
->maxerror
) ||
1208 __put_user(txc
.esterror
, &utp
->esterror
) ||
1209 __put_user(txc
.status
, &utp
->status
) ||
1210 __put_user(txc
.constant
, &utp
->constant
) ||
1211 __put_user(txc
.precision
, &utp
->precision
) ||
1212 __put_user(txc
.tolerance
, &utp
->tolerance
) ||
1213 __put_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1214 __put_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1215 __put_user(txc
.tick
, &utp
->tick
) ||
1216 __put_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1217 __put_user(txc
.jitter
, &utp
->jitter
) ||
1218 __put_user(txc
.shift
, &utp
->shift
) ||
1219 __put_user(txc
.stabil
, &utp
->stabil
) ||
1220 __put_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1221 __put_user(txc
.calcnt
, &utp
->calcnt
) ||
1222 __put_user(txc
.errcnt
, &utp
->errcnt
) ||
1223 __put_user(txc
.stbcnt
, &utp
->stbcnt
))
1229 asmlinkage
int sys32_sendfile(int out_fd
, int in_fd
, compat_off_t __user
*offset
,
1232 mm_segment_t old_fs
= get_fs();
1236 if (offset
&& get_user(of
, offset
))
1240 ret
= sys_sendfile(out_fd
, in_fd
, offset
? (off_t __user
*)&of
: NULL
, count
);
1243 if (offset
&& put_user(of
, offset
))
1249 asmlinkage ssize_t
sys32_readahead(int fd
, u32 pad0
, u64 a2
, u64 a3
,
1252 return sys_readahead(fd
, merge_64(a2
, a3
), count
);
1255 /* Argument list sizes for sys_socketcall */
1256 #define AL(x) ((x) * sizeof(unsigned int))
1257 static unsigned char socketcall_nargs
[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
1258 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
1259 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
1263 * System call vectors.
1265 * Argument checking cleaned up. Saved 20% in size.
1266 * This function doesn't need to set the kernel lock because
1267 * it is set by the callees.
1270 asmlinkage
long sys32_socketcall(int call
, unsigned int __user
*args32
)
1276 extern asmlinkage
long sys_socket(int family
, int type
, int protocol
);
1277 extern asmlinkage
long sys_bind(int fd
, struct sockaddr __user
*umyaddr
, int addrlen
);
1278 extern asmlinkage
long sys_connect(int fd
, struct sockaddr __user
*uservaddr
, int addrlen
);
1279 extern asmlinkage
long sys_listen(int fd
, int backlog
);
1280 extern asmlinkage
long sys_accept(int fd
, struct sockaddr __user
*upeer_sockaddr
, int __user
*upeer_addrlen
);
1281 extern asmlinkage
long sys_getsockname(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1282 extern asmlinkage
long sys_getpeername(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1283 extern asmlinkage
long sys_socketpair(int family
, int type
, int protocol
, int __user
*usockvec
);
1284 extern asmlinkage
long sys_send(int fd
, void __user
* buff
, size_t len
, unsigned flags
);
1285 extern asmlinkage
long sys_sendto(int fd
, void __user
* buff
, size_t len
, unsigned flags
,
1286 struct sockaddr __user
*addr
, int addr_len
);
1287 extern asmlinkage
long sys_recv(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
);
1288 extern asmlinkage
long sys_recvfrom(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
,
1289 struct sockaddr __user
*addr
, int __user
*addr_len
);
1290 extern asmlinkage
long sys_shutdown(int fd
, int how
);
1291 extern asmlinkage
long sys_setsockopt(int fd
, int level
, int optname
, char __user
*optval
, int optlen
);
1292 extern asmlinkage
long sys_getsockopt(int fd
, int level
, int optname
, char __user
*optval
, int __user
*optlen
);
1293 extern asmlinkage
long sys_sendmsg(int fd
, struct msghdr __user
*msg
, unsigned flags
);
1294 extern asmlinkage
long sys_recvmsg(int fd
, struct msghdr __user
*msg
, unsigned int flags
);
1297 if(call
<1||call
>SYS_RECVMSG
)
1300 /* copy_from_user should be SMP safe. */
1301 if (copy_from_user(a
, args32
, socketcall_nargs
[call
]))
1310 err
= sys_socket(a0
,a1
,a
[2]);
1313 err
= sys_bind(a0
,(struct sockaddr __user
*)A(a1
), a
[2]);
1316 err
= sys_connect(a0
, (struct sockaddr __user
*)A(a1
), a
[2]);
1319 err
= sys_listen(a0
,a1
);
1322 err
= sys_accept(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1324 case SYS_GETSOCKNAME
:
1325 err
= sys_getsockname(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1327 case SYS_GETPEERNAME
:
1328 err
= sys_getpeername(a0
, (struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1330 case SYS_SOCKETPAIR
:
1331 err
= sys_socketpair(a0
,a1
, a
[2], (int __user
*)A(a
[3]));
1334 err
= sys_send(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1337 err
= sys_sendto(a0
,(void __user
*)A(a1
), a
[2], a
[3],
1338 (struct sockaddr __user
*)A(a
[4]), a
[5]);
1341 err
= sys_recv(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1344 err
= sys_recvfrom(a0
, (void __user
*)A(a1
), a
[2], a
[3],
1345 (struct sockaddr __user
*)A(a
[4]), (int __user
*)A(a
[5]));
1348 err
= sys_shutdown(a0
,a1
);
1350 case SYS_SETSOCKOPT
:
1351 err
= sys_setsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), a
[4]);
1353 case SYS_GETSOCKOPT
:
1354 err
= sys_getsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), (int __user
*)A(a
[4]));
1357 err
= sys_sendmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1360 err
= sys_recvmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1373 u32 payload
[(64 / 4) - 3];
1376 extern asmlinkage
long
1377 sys_timer_create(clockid_t which_clock
,
1378 struct sigevent __user
*timer_event_spec
,
1379 timer_t __user
* created_timer_id
);
1382 sys32_timer_create(u32 clock
, struct sigevent32 __user
*se32
, timer_t __user
*timer_id
)
1384 struct sigevent __user
*p
= NULL
;
1387 p
= compat_alloc_user_space(sizeof(struct sigevent
));
1388 memset(&se
, 0, sizeof(struct sigevent
));
1389 if (get_user(se
.sigev_value
.sival_int
, &se32
->sigev_value
) ||
1390 __get_user(se
.sigev_signo
, &se32
->sigev_signo
) ||
1391 __get_user(se
.sigev_notify
, &se32
->sigev_notify
) ||
1392 __copy_from_user(&se
._sigev_un
._pad
, &se32
->payload
,
1393 sizeof(se32
->payload
)) ||
1394 copy_to_user(p
, &se
, sizeof(se
)))
1397 return sys_timer_create(clock
, p
, timer_id
);
1400 save_static_function(sys32_clone
);
1401 __attribute_used__ noinline
static int
1402 _sys32_clone(nabi_no_regargs
struct pt_regs regs
)
1404 unsigned long clone_flags
;
1405 unsigned long newsp
;
1406 int __user
*parent_tidptr
, *child_tidptr
;
1408 clone_flags
= regs
.regs
[4];
1409 newsp
= regs
.regs
[5];
1411 newsp
= regs
.regs
[29];
1412 parent_tidptr
= (int __user
*) regs
.regs
[6];
1414 /* Use __dummy4 instead of getting it off the stack, so that
1416 child_tidptr
= (int __user
*) __dummy4
;
1417 return do_fork(clone_flags
, newsp
, ®s
, 0,
1418 parent_tidptr
, child_tidptr
);
1421 extern asmlinkage
void sys_set_thread_area(u32 addr
);
1422 asmlinkage
void sys32_set_thread_area(u32 addr
)
1424 sys_set_thread_area(AA(addr
));