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
*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 *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
);
167 unsigned short d_reclen
;
168 char d_name
[NAME_MAX
+ 1];
172 xlate_dirent(void *dirent64
, void *dirent32
, long n
)
176 struct dirent32
*dirp32
;
180 dirp
= (struct dirent
*)(dirent64
+ off
);
181 dirp32
= (struct dirent32
*)(dirent32
+ off
);
182 off
+= dirp
->d_reclen
;
183 dirp32
->d_ino
= dirp
->d_ino
;
184 dirp32
->d_off
= (unsigned int)dirp
->d_off
;
185 dirp32
->d_reclen
= dirp
->d_reclen
;
186 strncpy(dirp32
->d_name
, dirp
->d_name
, dirp
->d_reclen
- ((3 * 4) + 2));
192 sys32_getdents(unsigned int fd
, void * dirent32
, unsigned int count
)
197 dirent64
= (void *)((unsigned long)(dirent32
+ (sizeof(long) - 1)) & ~(sizeof(long) - 1));
198 if ((n
= sys_getdents(fd
, dirent64
, count
- (dirent64
- dirent32
))) < 0)
200 xlate_dirent(dirent64
, dirent32
, n
);
204 asmlinkage
int old_readdir(unsigned int fd
, void * dirent
, unsigned int count
);
207 sys32_readdir(unsigned int fd
, void * dirent32
, unsigned int count
)
210 struct dirent dirent64
;
212 if ((n
= old_readdir(fd
, &dirent64
, count
)) < 0)
214 xlate_dirent(&dirent64
, dirent32
, dirent64
.d_reclen
);
219 sys32_waitpid(compat_pid_t pid
, unsigned int *stat_addr
, int options
)
221 return compat_sys_wait4(pid
, stat_addr
, options
, NULL
);
225 sysn32_waitid(int which
, compat_pid_t pid
,
226 siginfo_t __user
*uinfo
, int options
,
227 struct compat_rusage __user
*uru
)
231 mm_segment_t old_fs
= get_fs();
234 ret
= sys_waitid(which
, pid
, uinfo
, options
,
235 uru
? (struct rusage __user
*) &ru
: NULL
);
238 if (ret
< 0 || uinfo
->si_signo
== 0)
242 ret
= put_compat_rusage(&ru
, uru
);
262 asmlinkage
int sys32_sysinfo(struct sysinfo32
*info
)
266 mm_segment_t old_fs
= get_fs ();
269 ret
= sys_sysinfo(&s
);
271 err
= put_user (s
.uptime
, &info
->uptime
);
272 err
|= __put_user (s
.loads
[0], &info
->loads
[0]);
273 err
|= __put_user (s
.loads
[1], &info
->loads
[1]);
274 err
|= __put_user (s
.loads
[2], &info
->loads
[2]);
275 err
|= __put_user (s
.totalram
, &info
->totalram
);
276 err
|= __put_user (s
.freeram
, &info
->freeram
);
277 err
|= __put_user (s
.sharedram
, &info
->sharedram
);
278 err
|= __put_user (s
.bufferram
, &info
->bufferram
);
279 err
|= __put_user (s
.totalswap
, &info
->totalswap
);
280 err
|= __put_user (s
.freeswap
, &info
->freeswap
);
281 err
|= __put_user (s
.procs
, &info
->procs
);
282 err
|= __put_user (s
.totalhigh
, &info
->totalhigh
);
283 err
|= __put_user (s
.freehigh
, &info
->freehigh
);
284 err
|= __put_user (s
.mem_unit
, &info
->mem_unit
);
290 #define RLIM_INFINITY32 0x7fffffff
291 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
299 asmlinkage
long sys32_truncate64(const char * path
, unsigned long __dummy
,
300 int length_hi
, int length_lo
)
303 asmlinkage
long sys32_truncate64(const char * path
, unsigned long __dummy
,
304 int length_lo
, int length_hi
)
309 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
311 return sys_truncate(path
, length
);
315 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
316 int length_hi
, int length_lo
)
319 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
320 int length_lo
, int length_hi
)
325 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
327 return sys_ftruncate(fd
, length
);
331 get_tv32(struct timeval
*o
, struct compat_timeval
*i
)
333 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
334 (__get_user(o
->tv_sec
, &i
->tv_sec
) |
335 __get_user(o
->tv_usec
, &i
->tv_usec
)));
339 put_tv32(struct compat_timeval
*o
, struct timeval
*i
)
341 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
342 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
343 __put_user(i
->tv_usec
, &o
->tv_usec
)));
346 extern struct timezone sys_tz
;
349 sys32_gettimeofday(struct compat_timeval
*tv
, struct timezone
*tz
)
353 do_gettimeofday(&ktv
);
354 if (put_tv32(tv
, &ktv
))
358 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
364 static inline long get_ts32(struct timespec
*o
, struct compat_timeval
*i
)
368 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
370 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
372 if (__get_user(usec
, &i
->tv_usec
))
374 o
->tv_nsec
= usec
* 1000;
379 sys32_settimeofday(struct compat_timeval
*tv
, struct timezone
*tz
)
385 if (get_ts32(&kts
, tv
))
389 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
393 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
396 asmlinkage
int sys32_llseek(unsigned int fd
, unsigned int offset_high
,
397 unsigned int offset_low
, loff_t
* result
,
400 return sys_llseek(fd
, offset_high
, offset_low
, result
, origin
);
403 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
404 lseek back to original location. They fail just like lseek does on
405 non-seekable files. */
407 asmlinkage ssize_t
sys32_pread(unsigned int fd
, char * buf
,
408 size_t count
, u32 unused
, u64 a4
, u64 a5
)
412 ssize_t (*read
)(struct file
*, char *, size_t, loff_t
*);
419 if (!(file
->f_mode
& FMODE_READ
))
421 pos
= merge_64(a4
, a5
);
422 ret
= rw_verify_area(READ
, file
, &pos
, count
);
426 if (!file
->f_op
|| !(read
= file
->f_op
->read
))
431 if (!(file
->f_mode
& FMODE_PREAD
))
433 ret
= read(file
, buf
, count
, &pos
);
435 dnotify_parent(file
->f_dentry
, DN_ACCESS
);
442 asmlinkage ssize_t
sys32_pwrite(unsigned int fd
, const char * buf
,
443 size_t count
, u32 unused
, u64 a4
, u64 a5
)
447 ssize_t (*write
)(struct file
*, const char *, size_t, loff_t
*);
454 if (!(file
->f_mode
& FMODE_WRITE
))
456 pos
= merge_64(a4
, a5
);
457 ret
= rw_verify_area(WRITE
, file
, &pos
, count
);
461 if (!file
->f_op
|| !(write
= file
->f_op
->write
))
467 if (!(file
->f_mode
& FMODE_PWRITE
))
470 ret
= write(file
, buf
, count
, &pos
);
472 dnotify_parent(file
->f_dentry
, DN_MODIFY
);
479 asmlinkage
int sys32_sched_rr_get_interval(compat_pid_t pid
,
480 struct compat_timespec
*interval
)
484 mm_segment_t old_fs
= get_fs ();
487 ret
= sys_sched_rr_get_interval(pid
, &t
);
489 if (put_user (t
.tv_sec
, &interval
->tv_sec
) ||
490 __put_user (t
.tv_nsec
, &interval
->tv_nsec
))
495 struct msgbuf32
{ s32 mtype
; char mtext
[1]; };
508 struct ipc64_perm32
{
516 unsigned short __pad1
;
517 unsigned int __unused1
;
518 unsigned int __unused2
;
522 struct ipc_perm32 sem_perm
; /* permissions .. see ipc.h */
523 compat_time_t sem_otime
; /* last semop time */
524 compat_time_t sem_ctime
; /* last change time */
525 u32 sem_base
; /* ptr to first semaphore in array */
526 u32 sem_pending
; /* pending operations to be processed */
527 u32 sem_pending_last
; /* last pending operation */
528 u32 undo
; /* undo requests on this array */
529 unsigned short sem_nsems
; /* no. of semaphores in array */
532 struct semid64_ds32
{
533 struct ipc64_perm32 sem_perm
;
534 compat_time_t sem_otime
;
535 compat_time_t sem_ctime
;
536 unsigned int sem_nsems
;
537 unsigned int __unused1
;
538 unsigned int __unused2
;
543 struct ipc_perm32 msg_perm
;
546 compat_time_t msg_stime
;
547 compat_time_t msg_rtime
;
548 compat_time_t msg_ctime
;
551 unsigned short msg_cbytes
;
552 unsigned short msg_qnum
;
553 unsigned short msg_qbytes
;
554 compat_ipc_pid_t msg_lspid
;
555 compat_ipc_pid_t msg_lrpid
;
558 struct msqid64_ds32
{
559 struct ipc64_perm32 msg_perm
;
560 compat_time_t msg_stime
;
561 unsigned int __unused1
;
562 compat_time_t msg_rtime
;
563 unsigned int __unused2
;
564 compat_time_t msg_ctime
;
565 unsigned int __unused3
;
566 unsigned int msg_cbytes
;
567 unsigned int msg_qnum
;
568 unsigned int msg_qbytes
;
569 compat_pid_t msg_lspid
;
570 compat_pid_t msg_lrpid
;
571 unsigned int __unused4
;
572 unsigned int __unused5
;
576 struct ipc_perm32 shm_perm
;
578 compat_time_t shm_atime
;
579 compat_time_t shm_dtime
;
580 compat_time_t shm_ctime
;
581 compat_ipc_pid_t shm_cpid
;
582 compat_ipc_pid_t shm_lpid
;
583 unsigned short shm_nattch
;
586 struct shmid64_ds32
{
587 struct ipc64_perm32 shm_perm
;
588 compat_size_t shm_segsz
;
589 compat_time_t shm_atime
;
590 compat_time_t shm_dtime
;
591 compat_time_t shm_ctime
;
592 compat_pid_t shm_cpid
;
593 compat_pid_t shm_lpid
;
594 unsigned int shm_nattch
;
595 unsigned int __unused1
;
596 unsigned int __unused2
;
599 struct ipc_kludge32
{
605 do_sys32_semctl(int first
, int second
, int third
, void *uptr
)
616 if (get_user (pad
, (u32
*)uptr
))
618 if ((third
& ~IPC_64
) == SETVAL
)
619 fourth
.val
= (int)pad
;
621 fourth
.__pad
= (void *)A(pad
);
622 switch (third
& ~IPC_64
) {
634 err
= sys_semctl (first
, second
, third
, fourth
);
642 err
= sys_semctl(first
, second
, third
| IPC_64
, fourth
);
645 if (third
& IPC_64
) {
646 struct semid64_ds32
*usp64
= (struct semid64_ds32
*) A(pad
);
648 if (!access_ok(VERIFY_WRITE
, usp64
, sizeof(*usp64
))) {
652 err2
= __put_user(s
.sem_perm
.key
, &usp64
->sem_perm
.key
);
653 err2
|= __put_user(s
.sem_perm
.uid
, &usp64
->sem_perm
.uid
);
654 err2
|= __put_user(s
.sem_perm
.gid
, &usp64
->sem_perm
.gid
);
655 err2
|= __put_user(s
.sem_perm
.cuid
, &usp64
->sem_perm
.cuid
);
656 err2
|= __put_user(s
.sem_perm
.cgid
, &usp64
->sem_perm
.cgid
);
657 err2
|= __put_user(s
.sem_perm
.mode
, &usp64
->sem_perm
.mode
);
658 err2
|= __put_user(s
.sem_perm
.seq
, &usp64
->sem_perm
.seq
);
659 err2
|= __put_user(s
.sem_otime
, &usp64
->sem_otime
);
660 err2
|= __put_user(s
.sem_ctime
, &usp64
->sem_ctime
);
661 err2
|= __put_user(s
.sem_nsems
, &usp64
->sem_nsems
);
663 struct semid_ds32
*usp32
= (struct semid_ds32
*) A(pad
);
665 if (!access_ok(VERIFY_WRITE
, usp32
, sizeof(*usp32
))) {
669 err2
= __put_user(s
.sem_perm
.key
, &usp32
->sem_perm
.key
);
670 err2
|= __put_user(s
.sem_perm
.uid
, &usp32
->sem_perm
.uid
);
671 err2
|= __put_user(s
.sem_perm
.gid
, &usp32
->sem_perm
.gid
);
672 err2
|= __put_user(s
.sem_perm
.cuid
, &usp32
->sem_perm
.cuid
);
673 err2
|= __put_user(s
.sem_perm
.cgid
, &usp32
->sem_perm
.cgid
);
674 err2
|= __put_user(s
.sem_perm
.mode
, &usp32
->sem_perm
.mode
);
675 err2
|= __put_user(s
.sem_perm
.seq
, &usp32
->sem_perm
.seq
);
676 err2
|= __put_user(s
.sem_otime
, &usp32
->sem_otime
);
677 err2
|= __put_user(s
.sem_ctime
, &usp32
->sem_ctime
);
678 err2
|= __put_user(s
.sem_nsems
, &usp32
->sem_nsems
);
693 do_sys32_msgsnd (int first
, int second
, int third
, void *uptr
)
695 struct msgbuf32
*up
= (struct msgbuf32
*)uptr
;
702 p
= kmalloc (second
+ sizeof (struct msgbuf
)
706 err
= get_user (p
->mtype
, &up
->mtype
);
709 err
|= __copy_from_user (p
->mtext
, &up
->mtext
, second
);
714 err
= sys_msgsnd (first
, p
, second
, third
);
723 do_sys32_msgrcv (int first
, int second
, int msgtyp
, int third
,
724 int version
, void *uptr
)
732 struct ipc_kludge32
*uipck
= (struct ipc_kludge32
*)uptr
;
733 struct ipc_kludge32 ipck
;
739 if (copy_from_user (&ipck
, uipck
, sizeof (struct ipc_kludge32
)))
741 uptr
= (void *)AA(ipck
.msgp
);
742 msgtyp
= ipck
.msgtyp
;
748 p
= kmalloc (second
+ sizeof (struct msgbuf
) + 4, GFP_USER
);
753 err
= sys_msgrcv (first
, p
, second
+ 4, msgtyp
, third
);
757 up
= (struct msgbuf32
*)uptr
;
758 if (put_user (p
->mtype
, &up
->mtype
) ||
759 __copy_to_user (&up
->mtext
, p
->mtext
, err
))
768 do_sys32_msgctl (int first
, int second
, void *uptr
)
770 int err
= -EINVAL
, err2
;
772 struct msqid_ds32
*up32
= (struct msqid_ds32
*)uptr
;
773 struct msqid64_ds32
*up64
= (struct msqid64_ds32
*)uptr
;
776 switch (second
& ~IPC_64
) {
780 err
= sys_msgctl (first
, second
, (struct msqid_ds
*)uptr
);
784 if (second
& IPC_64
) {
785 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
))) {
789 err
= __get_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
790 err
|= __get_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
791 err
|= __get_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
792 err
|= __get_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
794 if (!access_ok(VERIFY_READ
, up32
, sizeof(*up32
))) {
798 err
= __get_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
799 err
|= __get_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
800 err
|= __get_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
801 err
|= __get_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
807 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds
*)&m
);
815 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds
*)&m
);
817 if (second
& IPC_64
) {
818 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
822 err2
= __put_user(m
.msg_perm
.key
, &up64
->msg_perm
.key
);
823 err2
|= __put_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
824 err2
|= __put_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
825 err2
|= __put_user(m
.msg_perm
.cuid
, &up64
->msg_perm
.cuid
);
826 err2
|= __put_user(m
.msg_perm
.cgid
, &up64
->msg_perm
.cgid
);
827 err2
|= __put_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
828 err2
|= __put_user(m
.msg_perm
.seq
, &up64
->msg_perm
.seq
);
829 err2
|= __put_user(m
.msg_stime
, &up64
->msg_stime
);
830 err2
|= __put_user(m
.msg_rtime
, &up64
->msg_rtime
);
831 err2
|= __put_user(m
.msg_ctime
, &up64
->msg_ctime
);
832 err2
|= __put_user(m
.msg_cbytes
, &up64
->msg_cbytes
);
833 err2
|= __put_user(m
.msg_qnum
, &up64
->msg_qnum
);
834 err2
|= __put_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
835 err2
|= __put_user(m
.msg_lspid
, &up64
->msg_lspid
);
836 err2
|= __put_user(m
.msg_lrpid
, &up64
->msg_lrpid
);
840 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
844 err2
= __put_user(m
.msg_perm
.key
, &up32
->msg_perm
.key
);
845 err2
|= __put_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
846 err2
|= __put_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
847 err2
|= __put_user(m
.msg_perm
.cuid
, &up32
->msg_perm
.cuid
);
848 err2
|= __put_user(m
.msg_perm
.cgid
, &up32
->msg_perm
.cgid
);
849 err2
|= __put_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
850 err2
|= __put_user(m
.msg_perm
.seq
, &up32
->msg_perm
.seq
);
851 err2
|= __put_user(m
.msg_stime
, &up32
->msg_stime
);
852 err2
|= __put_user(m
.msg_rtime
, &up32
->msg_rtime
);
853 err2
|= __put_user(m
.msg_ctime
, &up32
->msg_ctime
);
854 err2
|= __put_user(m
.msg_cbytes
, &up32
->msg_cbytes
);
855 err2
|= __put_user(m
.msg_qnum
, &up32
->msg_qnum
);
856 err2
|= __put_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
857 err2
|= __put_user(m
.msg_lspid
, &up32
->msg_lspid
);
858 err2
|= __put_user(m
.msg_lrpid
, &up32
->msg_lrpid
);
869 do_sys32_shmat (int first
, int second
, int third
, int version
, void *uptr
)
872 u32
*uaddr
= (u32
*)A((u32
)third
);
877 err
= do_shmat (first
, uptr
, second
, &raddr
);
880 err
= put_user (raddr
, uaddr
);
886 u32 shm_tot
, shm_rss
, shm_swp
;
887 u32 swap_attempts
, swap_successes
;
891 do_sys32_shmctl (int first
, int second
, void *uptr
)
893 struct shmid64_ds32
*up64
= (struct shmid64_ds32
*)uptr
;
894 struct shmid_ds32
*up32
= (struct shmid_ds32
*)uptr
;
895 struct shm_info32
*uip
= (struct shm_info32
*)uptr
;
896 int err
= -EFAULT
, err2
;
897 struct shmid64_ds s64
;
902 switch (second
& ~IPC_64
) {
904 second
= IPC_INFO
; /* So that we don't have to translate it */
908 err
= sys_shmctl(first
, second
, (struct shmid_ds
*)uptr
);
911 if (second
& IPC_64
) {
912 err
= get_user(s
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
913 err
|= get_user(s
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
914 err
|= get_user(s
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
916 err
= get_user(s
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
917 err
|= get_user(s
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
918 err
|= get_user(s
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
924 err
= sys_shmctl(first
, second
& ~IPC_64
, &s
);
932 err
= sys_shmctl(first
, second
| IPC_64
, (void *) &s64
);
936 if (second
& IPC_64
) {
937 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
941 err2
= __put_user(s64
.shm_perm
.key
, &up64
->shm_perm
.key
);
942 err2
|= __put_user(s64
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
943 err2
|= __put_user(s64
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
944 err2
|= __put_user(s64
.shm_perm
.cuid
, &up64
->shm_perm
.cuid
);
945 err2
|= __put_user(s64
.shm_perm
.cgid
, &up64
->shm_perm
.cgid
);
946 err2
|= __put_user(s64
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
947 err2
|= __put_user(s64
.shm_perm
.seq
, &up64
->shm_perm
.seq
);
948 err2
|= __put_user(s64
.shm_atime
, &up64
->shm_atime
);
949 err2
|= __put_user(s64
.shm_dtime
, &up64
->shm_dtime
);
950 err2
|= __put_user(s64
.shm_ctime
, &up64
->shm_ctime
);
951 err2
|= __put_user(s64
.shm_segsz
, &up64
->shm_segsz
);
952 err2
|= __put_user(s64
.shm_nattch
, &up64
->shm_nattch
);
953 err2
|= __put_user(s64
.shm_cpid
, &up64
->shm_cpid
);
954 err2
|= __put_user(s64
.shm_lpid
, &up64
->shm_lpid
);
956 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
960 err2
= __put_user(s64
.shm_perm
.key
, &up32
->shm_perm
.key
);
961 err2
|= __put_user(s64
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
962 err2
|= __put_user(s64
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
963 err2
|= __put_user(s64
.shm_perm
.cuid
, &up32
->shm_perm
.cuid
);
964 err2
|= __put_user(s64
.shm_perm
.cgid
, &up32
->shm_perm
.cgid
);
965 err2
|= __put_user(s64
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
966 err2
|= __put_user(s64
.shm_perm
.seq
, &up32
->shm_perm
.seq
);
967 err2
|= __put_user(s64
.shm_atime
, &up32
->shm_atime
);
968 err2
|= __put_user(s64
.shm_dtime
, &up32
->shm_dtime
);
969 err2
|= __put_user(s64
.shm_ctime
, &up32
->shm_ctime
);
970 err2
|= __put_user(s64
.shm_segsz
, &up32
->shm_segsz
);
971 err2
|= __put_user(s64
.shm_nattch
, &up32
->shm_nattch
);
972 err2
|= __put_user(s64
.shm_cpid
, &up32
->shm_cpid
);
973 err2
|= __put_user(s64
.shm_lpid
, &up32
->shm_lpid
);
982 err
= sys_shmctl(first
, second
, (void *)&si
);
986 err2
= put_user(si
.used_ids
, &uip
->used_ids
);
987 err2
|= __put_user(si
.shm_tot
, &uip
->shm_tot
);
988 err2
|= __put_user(si
.shm_rss
, &uip
->shm_rss
);
989 err2
|= __put_user(si
.shm_swp
, &uip
->shm_swp
);
990 err2
|= __put_user(si
.swap_attempts
, &uip
->swap_attempts
);
991 err2
|= __put_user (si
.swap_successes
, &uip
->swap_successes
);
1004 static int sys32_semtimedop(int semid
, struct sembuf
*tsems
, int nsems
,
1005 const struct compat_timespec
*timeout32
)
1007 struct compat_timespec t32
;
1008 struct timespec
*t64
= compat_alloc_user_space(sizeof(*t64
));
1010 if (copy_from_user(&t32
, timeout32
, sizeof(t32
)))
1013 if (put_user(t32
.tv_sec
, &t64
->tv_sec
) ||
1014 put_user(t32
.tv_nsec
, &t64
->tv_nsec
))
1017 return sys_semtimedop(semid
, tsems
, nsems
, t64
);
1021 sys32_ipc (u32 call
, int first
, int second
, int third
, u32 ptr
, u32 fifth
)
1025 version
= call
>> 16; /* hack for backward compatibility */
1030 /* struct sembuf is the same on 32 and 64bit :)) */
1031 err
= sys_semtimedop (first
, (struct sembuf
*)AA(ptr
), second
,
1035 err
= sys32_semtimedop (first
, (struct sembuf
*)AA(ptr
), second
,
1036 (const struct compat_timespec __user
*)AA(fifth
));
1039 err
= sys_semget (first
, second
, third
);
1042 err
= do_sys32_semctl (first
, second
, third
,
1047 err
= do_sys32_msgsnd (first
, second
, third
,
1051 err
= do_sys32_msgrcv (first
, second
, fifth
, third
,
1052 version
, (void *)AA(ptr
));
1055 err
= sys_msgget ((key_t
) first
, second
);
1058 err
= do_sys32_msgctl (first
, second
, (void *)AA(ptr
));
1062 err
= do_sys32_shmat (first
, second
, third
,
1063 version
, (void *)AA(ptr
));
1066 err
= sys_shmdt ((char *)A(ptr
));
1069 err
= sys_shmget (first
, (unsigned)second
, third
);
1072 err
= do_sys32_shmctl (first
, second
, (void *)AA(ptr
));
1082 asmlinkage
long sys32_shmat(int shmid
, char __user
*shmaddr
,
1083 int shmflg
, int32_t *addr
)
1085 unsigned long raddr
;
1088 err
= do_shmat(shmid
, shmaddr
, shmflg
, &raddr
);
1092 return put_user(raddr
, addr
);
1095 struct sysctl_args32
1097 compat_caddr_t name
;
1099 compat_caddr_t oldval
;
1100 compat_caddr_t oldlenp
;
1101 compat_caddr_t newval
;
1102 compat_size_t newlen
;
1103 unsigned int __unused
[4];
1106 #ifdef CONFIG_SYSCTL
1108 asmlinkage
long sys32_sysctl(struct sysctl_args32
*args
)
1110 struct sysctl_args32 tmp
;
1112 size_t oldlen
, *oldlenp
= NULL
;
1113 unsigned long addr
= (((long)&args
->__unused
[0]) + 7) & ~7;
1115 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
1118 if (tmp
.oldval
&& tmp
.oldlenp
) {
1119 /* Duh, this is ugly and might not work if sysctl_args
1120 is in read-only memory, but do_sysctl does indirectly
1121 a lot of uaccess in both directions and we'd have to
1122 basically copy the whole sysctl.c here, and
1123 glibc's __sysctl uses rw memory for the structure
1125 if (get_user(oldlen
, (u32
*)A(tmp
.oldlenp
)) ||
1126 put_user(oldlen
, (size_t *)addr
))
1128 oldlenp
= (size_t *)addr
;
1132 error
= do_sysctl((int *)A(tmp
.name
), tmp
.nlen
, (void *)A(tmp
.oldval
),
1133 oldlenp
, (void *)A(tmp
.newval
), tmp
.newlen
);
1137 if (get_user(oldlen
, (size_t *)addr
) ||
1138 put_user(oldlen
, (u32
*)A(tmp
.oldlenp
)))
1141 copy_to_user(args
->__unused
, tmp
.__unused
, sizeof(tmp
.__unused
));
1146 #endif /* CONFIG_SYSCTL */
1148 asmlinkage
long sys32_newuname(struct new_utsname
* name
)
1152 down_read(&uts_sem
);
1153 if (copy_to_user(name
,&system_utsname
,sizeof *name
))
1157 if (current
->personality
== PER_LINUX32
&& !ret
)
1158 if (copy_to_user(name
->machine
, "mips\0\0\0", 8))
1164 asmlinkage
int sys32_personality(unsigned long personality
)
1167 if (current
->personality
== PER_LINUX32
&& personality
== PER_LINUX
)
1168 personality
= PER_LINUX32
;
1169 ret
= sys_personality(personality
);
1170 if (ret
== PER_LINUX32
)
1175 /* ustat compatibility */
1177 compat_daddr_t f_tfree
;
1178 compat_ino_t f_tinode
;
1183 extern asmlinkage
long sys_ustat(dev_t dev
, struct ustat
* ubuf
);
1185 asmlinkage
int sys32_ustat(dev_t dev
, struct ustat32
* ubuf32
)
1189 struct ustat32 tmp32
;
1190 mm_segment_t old_fs
= get_fs();
1193 err
= sys_ustat(dev
, &tmp
);
1199 memset(&tmp32
,0,sizeof(struct ustat32
));
1200 tmp32
.f_tfree
= tmp
.f_tfree
;
1201 tmp32
.f_tinode
= tmp
.f_tinode
;
1203 err
= copy_to_user(ubuf32
,&tmp32
,sizeof(struct ustat32
)) ? -EFAULT
: 0;
1209 /* Handle adjtimex compatibility. */
1213 s32 offset
, freq
, maxerror
, esterror
;
1214 s32 status
, constant
, precision
, tolerance
;
1215 struct compat_timeval time
;
1217 s32 ppsfreq
, jitter
, shift
, stabil
;
1218 s32 jitcnt
, calcnt
, errcnt
, stbcnt
;
1219 s32
:32; s32
:32; s32
:32; s32
:32;
1220 s32
:32; s32
:32; s32
:32; s32
:32;
1221 s32
:32; s32
:32; s32
:32; s32
:32;
1224 extern int do_adjtimex(struct timex
*);
1226 asmlinkage
int sys32_adjtimex(struct timex32
*utp
)
1231 memset(&txc
, 0, sizeof(struct timex
));
1233 if (get_user(txc
.modes
, &utp
->modes
) ||
1234 __get_user(txc
.offset
, &utp
->offset
) ||
1235 __get_user(txc
.freq
, &utp
->freq
) ||
1236 __get_user(txc
.maxerror
, &utp
->maxerror
) ||
1237 __get_user(txc
.esterror
, &utp
->esterror
) ||
1238 __get_user(txc
.status
, &utp
->status
) ||
1239 __get_user(txc
.constant
, &utp
->constant
) ||
1240 __get_user(txc
.precision
, &utp
->precision
) ||
1241 __get_user(txc
.tolerance
, &utp
->tolerance
) ||
1242 __get_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1243 __get_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1244 __get_user(txc
.tick
, &utp
->tick
) ||
1245 __get_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1246 __get_user(txc
.jitter
, &utp
->jitter
) ||
1247 __get_user(txc
.shift
, &utp
->shift
) ||
1248 __get_user(txc
.stabil
, &utp
->stabil
) ||
1249 __get_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1250 __get_user(txc
.calcnt
, &utp
->calcnt
) ||
1251 __get_user(txc
.errcnt
, &utp
->errcnt
) ||
1252 __get_user(txc
.stbcnt
, &utp
->stbcnt
))
1255 ret
= do_adjtimex(&txc
);
1257 if (put_user(txc
.modes
, &utp
->modes
) ||
1258 __put_user(txc
.offset
, &utp
->offset
) ||
1259 __put_user(txc
.freq
, &utp
->freq
) ||
1260 __put_user(txc
.maxerror
, &utp
->maxerror
) ||
1261 __put_user(txc
.esterror
, &utp
->esterror
) ||
1262 __put_user(txc
.status
, &utp
->status
) ||
1263 __put_user(txc
.constant
, &utp
->constant
) ||
1264 __put_user(txc
.precision
, &utp
->precision
) ||
1265 __put_user(txc
.tolerance
, &utp
->tolerance
) ||
1266 __put_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1267 __put_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1268 __put_user(txc
.tick
, &utp
->tick
) ||
1269 __put_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1270 __put_user(txc
.jitter
, &utp
->jitter
) ||
1271 __put_user(txc
.shift
, &utp
->shift
) ||
1272 __put_user(txc
.stabil
, &utp
->stabil
) ||
1273 __put_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1274 __put_user(txc
.calcnt
, &utp
->calcnt
) ||
1275 __put_user(txc
.errcnt
, &utp
->errcnt
) ||
1276 __put_user(txc
.stbcnt
, &utp
->stbcnt
))
1282 asmlinkage
int sys32_sendfile(int out_fd
, int in_fd
, compat_off_t
*offset
,
1285 mm_segment_t old_fs
= get_fs();
1289 if (offset
&& get_user(of
, offset
))
1293 ret
= sys_sendfile(out_fd
, in_fd
, offset
? &of
: NULL
, count
);
1296 if (offset
&& put_user(of
, offset
))
1302 asmlinkage ssize_t
sys32_readahead(int fd
, u32 pad0
, u64 a2
, u64 a3
,
1305 return sys_readahead(fd
, merge_64(a2
, a3
), count
);
1308 /* Argument list sizes for sys_socketcall */
1309 #define AL(x) ((x) * sizeof(unsigned int))
1310 static unsigned char socketcall_nargs
[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
1311 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
1312 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
1316 * System call vectors.
1318 * Argument checking cleaned up. Saved 20% in size.
1319 * This function doesn't need to set the kernel lock because
1320 * it is set by the callees.
1323 asmlinkage
long sys32_socketcall(int call
, unsigned int *args32
)
1329 extern asmlinkage
long sys_socket(int family
, int type
, int protocol
);
1330 extern asmlinkage
long sys_bind(int fd
, struct sockaddr __user
*umyaddr
, int addrlen
);
1331 extern asmlinkage
long sys_connect(int fd
, struct sockaddr __user
*uservaddr
, int addrlen
);
1332 extern asmlinkage
long sys_listen(int fd
, int backlog
);
1333 extern asmlinkage
long sys_accept(int fd
, struct sockaddr __user
*upeer_sockaddr
, int __user
*upeer_addrlen
);
1334 extern asmlinkage
long sys_getsockname(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1335 extern asmlinkage
long sys_getpeername(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1336 extern asmlinkage
long sys_socketpair(int family
, int type
, int protocol
, int __user
*usockvec
);
1337 extern asmlinkage
long sys_send(int fd
, void __user
* buff
, size_t len
, unsigned flags
);
1338 extern asmlinkage
long sys_sendto(int fd
, void __user
* buff
, size_t len
, unsigned flags
,
1339 struct sockaddr __user
*addr
, int addr_len
);
1340 extern asmlinkage
long sys_recv(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
);
1341 extern asmlinkage
long sys_recvfrom(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
,
1342 struct sockaddr __user
*addr
, int __user
*addr_len
);
1343 extern asmlinkage
long sys_shutdown(int fd
, int how
);
1344 extern asmlinkage
long sys_setsockopt(int fd
, int level
, int optname
, char __user
*optval
, int optlen
);
1345 extern asmlinkage
long sys_getsockopt(int fd
, int level
, int optname
, char __user
*optval
, int *optlen
);
1346 extern asmlinkage
long sys_sendmsg(int fd
, struct msghdr __user
*msg
, unsigned flags
);
1347 extern asmlinkage
long sys_recvmsg(int fd
, struct msghdr __user
*msg
, unsigned int flags
);
1350 if(call
<1||call
>SYS_RECVMSG
)
1353 /* copy_from_user should be SMP safe. */
1354 if (copy_from_user(a
, args32
, socketcall_nargs
[call
]))
1363 err
= sys_socket(a0
,a1
,a
[2]);
1366 err
= sys_bind(a0
,(struct sockaddr __user
*)A(a1
), a
[2]);
1369 err
= sys_connect(a0
, (struct sockaddr __user
*)A(a1
), a
[2]);
1372 err
= sys_listen(a0
,a1
);
1375 err
= sys_accept(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1377 case SYS_GETSOCKNAME
:
1378 err
= sys_getsockname(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1380 case SYS_GETPEERNAME
:
1381 err
= sys_getpeername(a0
, (struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1383 case SYS_SOCKETPAIR
:
1384 err
= sys_socketpair(a0
,a1
, a
[2], (int __user
*)A(a
[3]));
1387 err
= sys_send(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1390 err
= sys_sendto(a0
,(void __user
*)A(a1
), a
[2], a
[3],
1391 (struct sockaddr __user
*)A(a
[4]), a
[5]);
1394 err
= sys_recv(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1397 err
= sys_recvfrom(a0
, (void __user
*)A(a1
), a
[2], a
[3],
1398 (struct sockaddr __user
*)A(a
[4]), (int __user
*)A(a
[5]));
1401 err
= sys_shutdown(a0
,a1
);
1403 case SYS_SETSOCKOPT
:
1404 err
= sys_setsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), a
[4]);
1406 case SYS_GETSOCKOPT
:
1407 err
= sys_getsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), (int __user
*)A(a
[4]));
1410 err
= sys_sendmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1413 err
= sys_recvmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1426 u32 payload
[(64 / 4) - 3];
1429 extern asmlinkage
long
1430 sys_timer_create(clockid_t which_clock
,
1431 struct sigevent __user
*timer_event_spec
,
1432 timer_t __user
* created_timer_id
);
1435 sys32_timer_create(u32 clock
, struct sigevent32 __user
*se32
, timer_t __user
*timer_id
)
1437 struct sigevent __user
*p
= NULL
;
1440 p
= compat_alloc_user_space(sizeof(struct sigevent
));
1441 memset(&se
, 0, sizeof(struct sigevent
));
1442 if (get_user(se
.sigev_value
.sival_int
, &se32
->sigev_value
) ||
1443 __get_user(se
.sigev_signo
, &se32
->sigev_signo
) ||
1444 __get_user(se
.sigev_notify
, &se32
->sigev_notify
) ||
1445 __copy_from_user(&se
._sigev_un
._pad
, &se32
->payload
,
1446 sizeof(se32
->payload
)) ||
1447 copy_to_user(p
, &se
, sizeof(se
)))
1450 return sys_timer_create(clock
, p
, timer_id
);
1454 sysn32_rt_sigtimedwait(const sigset_t __user
*uthese
,
1455 siginfo_t __user
*uinfo
,
1456 const struct compat_timespec __user
*uts32
,
1459 struct timespec __user
*uts
= NULL
;
1463 uts
= compat_alloc_user_space(sizeof(struct timespec
));
1464 if (get_user(ts
.tv_sec
, &uts32
->tv_sec
) ||
1465 get_user(ts
.tv_nsec
, &uts32
->tv_nsec
) ||
1466 copy_to_user (uts
, &ts
, sizeof (ts
)))
1469 return sys_rt_sigtimedwait(uthese
, uinfo
, uts
, sigsetsize
);
1472 save_static_function(sys32_clone
);
1473 __attribute_used__ noinline
static int
1474 _sys32_clone(nabi_no_regargs
struct pt_regs regs
)
1476 unsigned long clone_flags
;
1477 unsigned long newsp
;
1478 int __user
*parent_tidptr
, *child_tidptr
;
1480 clone_flags
= regs
.regs
[4];
1481 newsp
= regs
.regs
[5];
1483 newsp
= regs
.regs
[29];
1484 parent_tidptr
= (int *) regs
.regs
[6];
1486 /* Use __dummy4 instead of getting it off the stack, so that
1488 child_tidptr
= (int __user
*) __dummy4
;
1489 return do_fork(clone_flags
, newsp
, ®s
, 0,
1490 parent_tidptr
, child_tidptr
);
1493 extern asmlinkage
void sys_set_thread_area(u32 addr
);
1494 asmlinkage
void sys32_set_thread_area(u32 addr
)
1496 sys_set_thread_area(AA(addr
));