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();
233 if (!access_ok(VERIFY_WRITE
, uinfo
, sizeof(*uinfo
)))
237 ret
= sys_waitid(which
, pid
, uinfo
, options
,
238 uru
? (struct rusage __user
*) &ru
: NULL
);
241 if (ret
< 0 || uinfo
->si_signo
== 0)
245 ret
= put_compat_rusage(&ru
, uru
);
265 asmlinkage
int sys32_sysinfo(struct sysinfo32
*info
)
269 mm_segment_t old_fs
= get_fs ();
272 ret
= sys_sysinfo(&s
);
274 err
= put_user (s
.uptime
, &info
->uptime
);
275 err
|= __put_user (s
.loads
[0], &info
->loads
[0]);
276 err
|= __put_user (s
.loads
[1], &info
->loads
[1]);
277 err
|= __put_user (s
.loads
[2], &info
->loads
[2]);
278 err
|= __put_user (s
.totalram
, &info
->totalram
);
279 err
|= __put_user (s
.freeram
, &info
->freeram
);
280 err
|= __put_user (s
.sharedram
, &info
->sharedram
);
281 err
|= __put_user (s
.bufferram
, &info
->bufferram
);
282 err
|= __put_user (s
.totalswap
, &info
->totalswap
);
283 err
|= __put_user (s
.freeswap
, &info
->freeswap
);
284 err
|= __put_user (s
.procs
, &info
->procs
);
285 err
|= __put_user (s
.totalhigh
, &info
->totalhigh
);
286 err
|= __put_user (s
.freehigh
, &info
->freehigh
);
287 err
|= __put_user (s
.mem_unit
, &info
->mem_unit
);
293 #define RLIM_INFINITY32 0x7fffffff
294 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
302 asmlinkage
long sys32_truncate64(const char * path
, unsigned long __dummy
,
303 int length_hi
, int length_lo
)
306 asmlinkage
long sys32_truncate64(const char * path
, unsigned long __dummy
,
307 int length_lo
, int length_hi
)
312 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
314 return sys_truncate(path
, length
);
318 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
319 int length_hi
, int length_lo
)
322 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long __dummy
,
323 int length_lo
, int length_hi
)
328 length
= ((unsigned long) length_hi
<< 32) | (unsigned int) length_lo
;
330 return sys_ftruncate(fd
, length
);
334 get_tv32(struct timeval
*o
, struct compat_timeval
*i
)
336 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
337 (__get_user(o
->tv_sec
, &i
->tv_sec
) |
338 __get_user(o
->tv_usec
, &i
->tv_usec
)));
342 put_tv32(struct compat_timeval
*o
, struct timeval
*i
)
344 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
345 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
346 __put_user(i
->tv_usec
, &o
->tv_usec
)));
349 extern struct timezone sys_tz
;
352 sys32_gettimeofday(struct compat_timeval
*tv
, struct timezone
*tz
)
356 do_gettimeofday(&ktv
);
357 if (put_tv32(tv
, &ktv
))
361 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
367 static inline long get_ts32(struct timespec
*o
, struct compat_timeval
*i
)
371 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
373 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
375 if (__get_user(usec
, &i
->tv_usec
))
377 o
->tv_nsec
= usec
* 1000;
382 sys32_settimeofday(struct compat_timeval
*tv
, struct timezone
*tz
)
388 if (get_ts32(&kts
, tv
))
392 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
396 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
399 asmlinkage
int sys32_llseek(unsigned int fd
, unsigned int offset_high
,
400 unsigned int offset_low
, loff_t
* result
,
403 return sys_llseek(fd
, offset_high
, offset_low
, result
, origin
);
406 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
407 lseek back to original location. They fail just like lseek does on
408 non-seekable files. */
410 asmlinkage ssize_t
sys32_pread(unsigned int fd
, char * buf
,
411 size_t count
, u32 unused
, u64 a4
, u64 a5
)
415 ssize_t (*read
)(struct file
*, char *, size_t, loff_t
*);
422 if (!(file
->f_mode
& FMODE_READ
))
424 pos
= merge_64(a4
, a5
);
425 ret
= rw_verify_area(READ
, file
, &pos
, count
);
429 if (!file
->f_op
|| !(read
= file
->f_op
->read
))
434 if (!(file
->f_mode
& FMODE_PREAD
))
436 ret
= read(file
, buf
, count
, &pos
);
438 dnotify_parent(file
->f_dentry
, DN_ACCESS
);
445 asmlinkage ssize_t
sys32_pwrite(unsigned int fd
, const char * buf
,
446 size_t count
, u32 unused
, u64 a4
, u64 a5
)
450 ssize_t (*write
)(struct file
*, const char *, size_t, loff_t
*);
457 if (!(file
->f_mode
& FMODE_WRITE
))
459 pos
= merge_64(a4
, a5
);
460 ret
= rw_verify_area(WRITE
, file
, &pos
, count
);
464 if (!file
->f_op
|| !(write
= file
->f_op
->write
))
470 if (!(file
->f_mode
& FMODE_PWRITE
))
473 ret
= write(file
, buf
, count
, &pos
);
475 dnotify_parent(file
->f_dentry
, DN_MODIFY
);
482 asmlinkage
int sys32_sched_rr_get_interval(compat_pid_t pid
,
483 struct compat_timespec
*interval
)
487 mm_segment_t old_fs
= get_fs ();
490 ret
= sys_sched_rr_get_interval(pid
, &t
);
492 if (put_user (t
.tv_sec
, &interval
->tv_sec
) ||
493 __put_user (t
.tv_nsec
, &interval
->tv_nsec
))
498 struct msgbuf32
{ s32 mtype
; char mtext
[1]; };
511 struct ipc64_perm32
{
519 unsigned short __pad1
;
520 unsigned int __unused1
;
521 unsigned int __unused2
;
525 struct ipc_perm32 sem_perm
; /* permissions .. see ipc.h */
526 compat_time_t sem_otime
; /* last semop time */
527 compat_time_t sem_ctime
; /* last change time */
528 u32 sem_base
; /* ptr to first semaphore in array */
529 u32 sem_pending
; /* pending operations to be processed */
530 u32 sem_pending_last
; /* last pending operation */
531 u32 undo
; /* undo requests on this array */
532 unsigned short sem_nsems
; /* no. of semaphores in array */
535 struct semid64_ds32
{
536 struct ipc64_perm32 sem_perm
;
537 compat_time_t sem_otime
;
538 compat_time_t sem_ctime
;
539 unsigned int sem_nsems
;
540 unsigned int __unused1
;
541 unsigned int __unused2
;
546 struct ipc_perm32 msg_perm
;
549 compat_time_t msg_stime
;
550 compat_time_t msg_rtime
;
551 compat_time_t msg_ctime
;
554 unsigned short msg_cbytes
;
555 unsigned short msg_qnum
;
556 unsigned short msg_qbytes
;
557 compat_ipc_pid_t msg_lspid
;
558 compat_ipc_pid_t msg_lrpid
;
561 struct msqid64_ds32
{
562 struct ipc64_perm32 msg_perm
;
563 compat_time_t msg_stime
;
564 unsigned int __unused1
;
565 compat_time_t msg_rtime
;
566 unsigned int __unused2
;
567 compat_time_t msg_ctime
;
568 unsigned int __unused3
;
569 unsigned int msg_cbytes
;
570 unsigned int msg_qnum
;
571 unsigned int msg_qbytes
;
572 compat_pid_t msg_lspid
;
573 compat_pid_t msg_lrpid
;
574 unsigned int __unused4
;
575 unsigned int __unused5
;
579 struct ipc_perm32 shm_perm
;
581 compat_time_t shm_atime
;
582 compat_time_t shm_dtime
;
583 compat_time_t shm_ctime
;
584 compat_ipc_pid_t shm_cpid
;
585 compat_ipc_pid_t shm_lpid
;
586 unsigned short shm_nattch
;
589 struct shmid64_ds32
{
590 struct ipc64_perm32 shm_perm
;
591 compat_size_t shm_segsz
;
592 compat_time_t shm_atime
;
593 compat_time_t shm_dtime
;
594 compat_time_t shm_ctime
;
595 compat_pid_t shm_cpid
;
596 compat_pid_t shm_lpid
;
597 unsigned int shm_nattch
;
598 unsigned int __unused1
;
599 unsigned int __unused2
;
602 struct ipc_kludge32
{
608 do_sys32_semctl(int first
, int second
, int third
, void *uptr
)
619 if (get_user (pad
, (u32
*)uptr
))
621 if ((third
& ~IPC_64
) == SETVAL
)
622 fourth
.val
= (int)pad
;
624 fourth
.__pad
= (void *)A(pad
);
625 switch (third
& ~IPC_64
) {
637 err
= sys_semctl (first
, second
, third
, fourth
);
645 err
= sys_semctl(first
, second
, third
| IPC_64
, fourth
);
648 if (third
& IPC_64
) {
649 struct semid64_ds32
*usp64
= (struct semid64_ds32
*) A(pad
);
651 if (!access_ok(VERIFY_WRITE
, usp64
, sizeof(*usp64
))) {
655 err2
= __put_user(s
.sem_perm
.key
, &usp64
->sem_perm
.key
);
656 err2
|= __put_user(s
.sem_perm
.uid
, &usp64
->sem_perm
.uid
);
657 err2
|= __put_user(s
.sem_perm
.gid
, &usp64
->sem_perm
.gid
);
658 err2
|= __put_user(s
.sem_perm
.cuid
, &usp64
->sem_perm
.cuid
);
659 err2
|= __put_user(s
.sem_perm
.cgid
, &usp64
->sem_perm
.cgid
);
660 err2
|= __put_user(s
.sem_perm
.mode
, &usp64
->sem_perm
.mode
);
661 err2
|= __put_user(s
.sem_perm
.seq
, &usp64
->sem_perm
.seq
);
662 err2
|= __put_user(s
.sem_otime
, &usp64
->sem_otime
);
663 err2
|= __put_user(s
.sem_ctime
, &usp64
->sem_ctime
);
664 err2
|= __put_user(s
.sem_nsems
, &usp64
->sem_nsems
);
666 struct semid_ds32
*usp32
= (struct semid_ds32
*) A(pad
);
668 if (!access_ok(VERIFY_WRITE
, usp32
, sizeof(*usp32
))) {
672 err2
= __put_user(s
.sem_perm
.key
, &usp32
->sem_perm
.key
);
673 err2
|= __put_user(s
.sem_perm
.uid
, &usp32
->sem_perm
.uid
);
674 err2
|= __put_user(s
.sem_perm
.gid
, &usp32
->sem_perm
.gid
);
675 err2
|= __put_user(s
.sem_perm
.cuid
, &usp32
->sem_perm
.cuid
);
676 err2
|= __put_user(s
.sem_perm
.cgid
, &usp32
->sem_perm
.cgid
);
677 err2
|= __put_user(s
.sem_perm
.mode
, &usp32
->sem_perm
.mode
);
678 err2
|= __put_user(s
.sem_perm
.seq
, &usp32
->sem_perm
.seq
);
679 err2
|= __put_user(s
.sem_otime
, &usp32
->sem_otime
);
680 err2
|= __put_user(s
.sem_ctime
, &usp32
->sem_ctime
);
681 err2
|= __put_user(s
.sem_nsems
, &usp32
->sem_nsems
);
696 do_sys32_msgsnd (int first
, int second
, int third
, void *uptr
)
698 struct msgbuf32
*up
= (struct msgbuf32
*)uptr
;
705 p
= kmalloc (second
+ sizeof (struct msgbuf
)
709 err
= get_user (p
->mtype
, &up
->mtype
);
712 err
|= __copy_from_user (p
->mtext
, &up
->mtext
, second
);
717 err
= sys_msgsnd (first
, p
, second
, third
);
726 do_sys32_msgrcv (int first
, int second
, int msgtyp
, int third
,
727 int version
, void *uptr
)
735 struct ipc_kludge32
*uipck
= (struct ipc_kludge32
*)uptr
;
736 struct ipc_kludge32 ipck
;
742 if (copy_from_user (&ipck
, uipck
, sizeof (struct ipc_kludge32
)))
744 uptr
= (void *)AA(ipck
.msgp
);
745 msgtyp
= ipck
.msgtyp
;
751 p
= kmalloc (second
+ sizeof (struct msgbuf
) + 4, GFP_USER
);
756 err
= sys_msgrcv (first
, p
, second
+ 4, msgtyp
, third
);
760 up
= (struct msgbuf32
*)uptr
;
761 if (put_user (p
->mtype
, &up
->mtype
) ||
762 __copy_to_user (&up
->mtext
, p
->mtext
, err
))
771 do_sys32_msgctl (int first
, int second
, void *uptr
)
773 int err
= -EINVAL
, err2
;
775 struct msqid_ds32
*up32
= (struct msqid_ds32
*)uptr
;
776 struct msqid64_ds32
*up64
= (struct msqid64_ds32
*)uptr
;
779 switch (second
& ~IPC_64
) {
783 err
= sys_msgctl (first
, second
, (struct msqid_ds
*)uptr
);
787 if (second
& IPC_64
) {
788 if (!access_ok(VERIFY_READ
, up64
, sizeof(*up64
))) {
792 err
= __get_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
793 err
|= __get_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
794 err
|= __get_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
795 err
|= __get_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
797 if (!access_ok(VERIFY_READ
, up32
, sizeof(*up32
))) {
801 err
= __get_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
802 err
|= __get_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
803 err
|= __get_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
804 err
|= __get_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
810 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds
*)&m
);
818 err
= sys_msgctl(first
, second
| IPC_64
, (struct msqid_ds
*)&m
);
820 if (second
& IPC_64
) {
821 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
825 err2
= __put_user(m
.msg_perm
.key
, &up64
->msg_perm
.key
);
826 err2
|= __put_user(m
.msg_perm
.uid
, &up64
->msg_perm
.uid
);
827 err2
|= __put_user(m
.msg_perm
.gid
, &up64
->msg_perm
.gid
);
828 err2
|= __put_user(m
.msg_perm
.cuid
, &up64
->msg_perm
.cuid
);
829 err2
|= __put_user(m
.msg_perm
.cgid
, &up64
->msg_perm
.cgid
);
830 err2
|= __put_user(m
.msg_perm
.mode
, &up64
->msg_perm
.mode
);
831 err2
|= __put_user(m
.msg_perm
.seq
, &up64
->msg_perm
.seq
);
832 err2
|= __put_user(m
.msg_stime
, &up64
->msg_stime
);
833 err2
|= __put_user(m
.msg_rtime
, &up64
->msg_rtime
);
834 err2
|= __put_user(m
.msg_ctime
, &up64
->msg_ctime
);
835 err2
|= __put_user(m
.msg_cbytes
, &up64
->msg_cbytes
);
836 err2
|= __put_user(m
.msg_qnum
, &up64
->msg_qnum
);
837 err2
|= __put_user(m
.msg_qbytes
, &up64
->msg_qbytes
);
838 err2
|= __put_user(m
.msg_lspid
, &up64
->msg_lspid
);
839 err2
|= __put_user(m
.msg_lrpid
, &up64
->msg_lrpid
);
843 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
847 err2
= __put_user(m
.msg_perm
.key
, &up32
->msg_perm
.key
);
848 err2
|= __put_user(m
.msg_perm
.uid
, &up32
->msg_perm
.uid
);
849 err2
|= __put_user(m
.msg_perm
.gid
, &up32
->msg_perm
.gid
);
850 err2
|= __put_user(m
.msg_perm
.cuid
, &up32
->msg_perm
.cuid
);
851 err2
|= __put_user(m
.msg_perm
.cgid
, &up32
->msg_perm
.cgid
);
852 err2
|= __put_user(m
.msg_perm
.mode
, &up32
->msg_perm
.mode
);
853 err2
|= __put_user(m
.msg_perm
.seq
, &up32
->msg_perm
.seq
);
854 err2
|= __put_user(m
.msg_stime
, &up32
->msg_stime
);
855 err2
|= __put_user(m
.msg_rtime
, &up32
->msg_rtime
);
856 err2
|= __put_user(m
.msg_ctime
, &up32
->msg_ctime
);
857 err2
|= __put_user(m
.msg_cbytes
, &up32
->msg_cbytes
);
858 err2
|= __put_user(m
.msg_qnum
, &up32
->msg_qnum
);
859 err2
|= __put_user(m
.msg_qbytes
, &up32
->msg_qbytes
);
860 err2
|= __put_user(m
.msg_lspid
, &up32
->msg_lspid
);
861 err2
|= __put_user(m
.msg_lrpid
, &up32
->msg_lrpid
);
872 do_sys32_shmat (int first
, int second
, int third
, int version
, void *uptr
)
875 u32
*uaddr
= (u32
*)A((u32
)third
);
880 err
= do_shmat (first
, uptr
, second
, &raddr
);
883 err
= put_user (raddr
, uaddr
);
889 u32 shm_tot
, shm_rss
, shm_swp
;
890 u32 swap_attempts
, swap_successes
;
894 do_sys32_shmctl (int first
, int second
, void *uptr
)
896 struct shmid64_ds32
*up64
= (struct shmid64_ds32
*)uptr
;
897 struct shmid_ds32
*up32
= (struct shmid_ds32
*)uptr
;
898 struct shm_info32
*uip
= (struct shm_info32
*)uptr
;
899 int err
= -EFAULT
, err2
;
900 struct shmid64_ds s64
;
905 switch (second
& ~IPC_64
) {
907 second
= IPC_INFO
; /* So that we don't have to translate it */
911 err
= sys_shmctl(first
, second
, (struct shmid_ds
*)uptr
);
914 if (second
& IPC_64
) {
915 err
= get_user(s
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
916 err
|= get_user(s
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
917 err
|= get_user(s
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
919 err
= get_user(s
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
920 err
|= get_user(s
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
921 err
|= get_user(s
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
927 err
= sys_shmctl(first
, second
& ~IPC_64
, &s
);
935 err
= sys_shmctl(first
, second
| IPC_64
, (void *) &s64
);
939 if (second
& IPC_64
) {
940 if (!access_ok(VERIFY_WRITE
, up64
, sizeof(*up64
))) {
944 err2
= __put_user(s64
.shm_perm
.key
, &up64
->shm_perm
.key
);
945 err2
|= __put_user(s64
.shm_perm
.uid
, &up64
->shm_perm
.uid
);
946 err2
|= __put_user(s64
.shm_perm
.gid
, &up64
->shm_perm
.gid
);
947 err2
|= __put_user(s64
.shm_perm
.cuid
, &up64
->shm_perm
.cuid
);
948 err2
|= __put_user(s64
.shm_perm
.cgid
, &up64
->shm_perm
.cgid
);
949 err2
|= __put_user(s64
.shm_perm
.mode
, &up64
->shm_perm
.mode
);
950 err2
|= __put_user(s64
.shm_perm
.seq
, &up64
->shm_perm
.seq
);
951 err2
|= __put_user(s64
.shm_atime
, &up64
->shm_atime
);
952 err2
|= __put_user(s64
.shm_dtime
, &up64
->shm_dtime
);
953 err2
|= __put_user(s64
.shm_ctime
, &up64
->shm_ctime
);
954 err2
|= __put_user(s64
.shm_segsz
, &up64
->shm_segsz
);
955 err2
|= __put_user(s64
.shm_nattch
, &up64
->shm_nattch
);
956 err2
|= __put_user(s64
.shm_cpid
, &up64
->shm_cpid
);
957 err2
|= __put_user(s64
.shm_lpid
, &up64
->shm_lpid
);
959 if (!access_ok(VERIFY_WRITE
, up32
, sizeof(*up32
))) {
963 err2
= __put_user(s64
.shm_perm
.key
, &up32
->shm_perm
.key
);
964 err2
|= __put_user(s64
.shm_perm
.uid
, &up32
->shm_perm
.uid
);
965 err2
|= __put_user(s64
.shm_perm
.gid
, &up32
->shm_perm
.gid
);
966 err2
|= __put_user(s64
.shm_perm
.cuid
, &up32
->shm_perm
.cuid
);
967 err2
|= __put_user(s64
.shm_perm
.cgid
, &up32
->shm_perm
.cgid
);
968 err2
|= __put_user(s64
.shm_perm
.mode
, &up32
->shm_perm
.mode
);
969 err2
|= __put_user(s64
.shm_perm
.seq
, &up32
->shm_perm
.seq
);
970 err2
|= __put_user(s64
.shm_atime
, &up32
->shm_atime
);
971 err2
|= __put_user(s64
.shm_dtime
, &up32
->shm_dtime
);
972 err2
|= __put_user(s64
.shm_ctime
, &up32
->shm_ctime
);
973 err2
|= __put_user(s64
.shm_segsz
, &up32
->shm_segsz
);
974 err2
|= __put_user(s64
.shm_nattch
, &up32
->shm_nattch
);
975 err2
|= __put_user(s64
.shm_cpid
, &up32
->shm_cpid
);
976 err2
|= __put_user(s64
.shm_lpid
, &up32
->shm_lpid
);
985 err
= sys_shmctl(first
, second
, (void *)&si
);
989 err2
= put_user(si
.used_ids
, &uip
->used_ids
);
990 err2
|= __put_user(si
.shm_tot
, &uip
->shm_tot
);
991 err2
|= __put_user(si
.shm_rss
, &uip
->shm_rss
);
992 err2
|= __put_user(si
.shm_swp
, &uip
->shm_swp
);
993 err2
|= __put_user(si
.swap_attempts
, &uip
->swap_attempts
);
994 err2
|= __put_user (si
.swap_successes
, &uip
->swap_successes
);
1007 static int sys32_semtimedop(int semid
, struct sembuf
*tsems
, int nsems
,
1008 const struct compat_timespec
*timeout32
)
1010 struct compat_timespec t32
;
1011 struct timespec
*t64
= compat_alloc_user_space(sizeof(*t64
));
1013 if (copy_from_user(&t32
, timeout32
, sizeof(t32
)))
1016 if (put_user(t32
.tv_sec
, &t64
->tv_sec
) ||
1017 put_user(t32
.tv_nsec
, &t64
->tv_nsec
))
1020 return sys_semtimedop(semid
, tsems
, nsems
, t64
);
1024 sys32_ipc (u32 call
, int first
, int second
, int third
, u32 ptr
, u32 fifth
)
1028 version
= call
>> 16; /* hack for backward compatibility */
1033 /* struct sembuf is the same on 32 and 64bit :)) */
1034 err
= sys_semtimedop (first
, (struct sembuf
*)AA(ptr
), second
,
1038 err
= sys32_semtimedop (first
, (struct sembuf
*)AA(ptr
), second
,
1039 (const struct compat_timespec __user
*)AA(fifth
));
1042 err
= sys_semget (first
, second
, third
);
1045 err
= do_sys32_semctl (first
, second
, third
,
1050 err
= do_sys32_msgsnd (first
, second
, third
,
1054 err
= do_sys32_msgrcv (first
, second
, fifth
, third
,
1055 version
, (void *)AA(ptr
));
1058 err
= sys_msgget ((key_t
) first
, second
);
1061 err
= do_sys32_msgctl (first
, second
, (void *)AA(ptr
));
1065 err
= do_sys32_shmat (first
, second
, third
,
1066 version
, (void *)AA(ptr
));
1069 err
= sys_shmdt ((char *)A(ptr
));
1072 err
= sys_shmget (first
, (unsigned)second
, third
);
1075 err
= do_sys32_shmctl (first
, second
, (void *)AA(ptr
));
1085 asmlinkage
long sys32_shmat(int shmid
, char __user
*shmaddr
,
1086 int shmflg
, int32_t *addr
)
1088 unsigned long raddr
;
1091 err
= do_shmat(shmid
, shmaddr
, shmflg
, &raddr
);
1095 return put_user(raddr
, addr
);
1098 struct sysctl_args32
1100 compat_caddr_t name
;
1102 compat_caddr_t oldval
;
1103 compat_caddr_t oldlenp
;
1104 compat_caddr_t newval
;
1105 compat_size_t newlen
;
1106 unsigned int __unused
[4];
1109 #ifdef CONFIG_SYSCTL
1111 asmlinkage
long sys32_sysctl(struct sysctl_args32
*args
)
1113 struct sysctl_args32 tmp
;
1115 size_t oldlen
, *oldlenp
= NULL
;
1116 unsigned long addr
= (((long)&args
->__unused
[0]) + 7) & ~7;
1118 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
1121 if (tmp
.oldval
&& tmp
.oldlenp
) {
1122 /* Duh, this is ugly and might not work if sysctl_args
1123 is in read-only memory, but do_sysctl does indirectly
1124 a lot of uaccess in both directions and we'd have to
1125 basically copy the whole sysctl.c here, and
1126 glibc's __sysctl uses rw memory for the structure
1128 if (get_user(oldlen
, (u32
*)A(tmp
.oldlenp
)) ||
1129 put_user(oldlen
, (size_t *)addr
))
1131 oldlenp
= (size_t *)addr
;
1135 error
= do_sysctl((int *)A(tmp
.name
), tmp
.nlen
, (void *)A(tmp
.oldval
),
1136 oldlenp
, (void *)A(tmp
.newval
), tmp
.newlen
);
1140 if (get_user(oldlen
, (size_t *)addr
) ||
1141 put_user(oldlen
, (u32
*)A(tmp
.oldlenp
)))
1144 copy_to_user(args
->__unused
, tmp
.__unused
, sizeof(tmp
.__unused
));
1149 #endif /* CONFIG_SYSCTL */
1151 asmlinkage
long sys32_newuname(struct new_utsname
* name
)
1155 down_read(&uts_sem
);
1156 if (copy_to_user(name
,&system_utsname
,sizeof *name
))
1160 if (current
->personality
== PER_LINUX32
&& !ret
)
1161 if (copy_to_user(name
->machine
, "mips\0\0\0", 8))
1167 asmlinkage
int sys32_personality(unsigned long personality
)
1170 if (current
->personality
== PER_LINUX32
&& personality
== PER_LINUX
)
1171 personality
= PER_LINUX32
;
1172 ret
= sys_personality(personality
);
1173 if (ret
== PER_LINUX32
)
1178 /* ustat compatibility */
1180 compat_daddr_t f_tfree
;
1181 compat_ino_t f_tinode
;
1186 extern asmlinkage
long sys_ustat(dev_t dev
, struct ustat
* ubuf
);
1188 asmlinkage
int sys32_ustat(dev_t dev
, struct ustat32
* ubuf32
)
1192 struct ustat32 tmp32
;
1193 mm_segment_t old_fs
= get_fs();
1196 err
= sys_ustat(dev
, &tmp
);
1202 memset(&tmp32
,0,sizeof(struct ustat32
));
1203 tmp32
.f_tfree
= tmp
.f_tfree
;
1204 tmp32
.f_tinode
= tmp
.f_tinode
;
1206 err
= copy_to_user(ubuf32
,&tmp32
,sizeof(struct ustat32
)) ? -EFAULT
: 0;
1212 /* Handle adjtimex compatibility. */
1216 s32 offset
, freq
, maxerror
, esterror
;
1217 s32 status
, constant
, precision
, tolerance
;
1218 struct compat_timeval time
;
1220 s32 ppsfreq
, jitter
, shift
, stabil
;
1221 s32 jitcnt
, calcnt
, errcnt
, stbcnt
;
1222 s32
:32; s32
:32; s32
:32; s32
:32;
1223 s32
:32; s32
:32; s32
:32; s32
:32;
1224 s32
:32; s32
:32; s32
:32; s32
:32;
1227 extern int do_adjtimex(struct timex
*);
1229 asmlinkage
int sys32_adjtimex(struct timex32
*utp
)
1234 memset(&txc
, 0, sizeof(struct timex
));
1236 if (get_user(txc
.modes
, &utp
->modes
) ||
1237 __get_user(txc
.offset
, &utp
->offset
) ||
1238 __get_user(txc
.freq
, &utp
->freq
) ||
1239 __get_user(txc
.maxerror
, &utp
->maxerror
) ||
1240 __get_user(txc
.esterror
, &utp
->esterror
) ||
1241 __get_user(txc
.status
, &utp
->status
) ||
1242 __get_user(txc
.constant
, &utp
->constant
) ||
1243 __get_user(txc
.precision
, &utp
->precision
) ||
1244 __get_user(txc
.tolerance
, &utp
->tolerance
) ||
1245 __get_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1246 __get_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1247 __get_user(txc
.tick
, &utp
->tick
) ||
1248 __get_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1249 __get_user(txc
.jitter
, &utp
->jitter
) ||
1250 __get_user(txc
.shift
, &utp
->shift
) ||
1251 __get_user(txc
.stabil
, &utp
->stabil
) ||
1252 __get_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1253 __get_user(txc
.calcnt
, &utp
->calcnt
) ||
1254 __get_user(txc
.errcnt
, &utp
->errcnt
) ||
1255 __get_user(txc
.stbcnt
, &utp
->stbcnt
))
1258 ret
= do_adjtimex(&txc
);
1260 if (put_user(txc
.modes
, &utp
->modes
) ||
1261 __put_user(txc
.offset
, &utp
->offset
) ||
1262 __put_user(txc
.freq
, &utp
->freq
) ||
1263 __put_user(txc
.maxerror
, &utp
->maxerror
) ||
1264 __put_user(txc
.esterror
, &utp
->esterror
) ||
1265 __put_user(txc
.status
, &utp
->status
) ||
1266 __put_user(txc
.constant
, &utp
->constant
) ||
1267 __put_user(txc
.precision
, &utp
->precision
) ||
1268 __put_user(txc
.tolerance
, &utp
->tolerance
) ||
1269 __put_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
1270 __put_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
1271 __put_user(txc
.tick
, &utp
->tick
) ||
1272 __put_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
1273 __put_user(txc
.jitter
, &utp
->jitter
) ||
1274 __put_user(txc
.shift
, &utp
->shift
) ||
1275 __put_user(txc
.stabil
, &utp
->stabil
) ||
1276 __put_user(txc
.jitcnt
, &utp
->jitcnt
) ||
1277 __put_user(txc
.calcnt
, &utp
->calcnt
) ||
1278 __put_user(txc
.errcnt
, &utp
->errcnt
) ||
1279 __put_user(txc
.stbcnt
, &utp
->stbcnt
))
1285 asmlinkage
int sys32_sendfile(int out_fd
, int in_fd
, compat_off_t
*offset
,
1288 mm_segment_t old_fs
= get_fs();
1292 if (offset
&& get_user(of
, offset
))
1296 ret
= sys_sendfile(out_fd
, in_fd
, offset
? &of
: NULL
, count
);
1299 if (offset
&& put_user(of
, offset
))
1305 asmlinkage ssize_t
sys32_readahead(int fd
, u32 pad0
, u64 a2
, u64 a3
,
1308 return sys_readahead(fd
, merge_64(a2
, a3
), count
);
1311 /* Argument list sizes for sys_socketcall */
1312 #define AL(x) ((x) * sizeof(unsigned int))
1313 static unsigned char socketcall_nargs
[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
1314 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
1315 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
1319 * System call vectors.
1321 * Argument checking cleaned up. Saved 20% in size.
1322 * This function doesn't need to set the kernel lock because
1323 * it is set by the callees.
1326 asmlinkage
long sys32_socketcall(int call
, unsigned int *args32
)
1332 extern asmlinkage
long sys_socket(int family
, int type
, int protocol
);
1333 extern asmlinkage
long sys_bind(int fd
, struct sockaddr __user
*umyaddr
, int addrlen
);
1334 extern asmlinkage
long sys_connect(int fd
, struct sockaddr __user
*uservaddr
, int addrlen
);
1335 extern asmlinkage
long sys_listen(int fd
, int backlog
);
1336 extern asmlinkage
long sys_accept(int fd
, struct sockaddr __user
*upeer_sockaddr
, int __user
*upeer_addrlen
);
1337 extern asmlinkage
long sys_getsockname(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1338 extern asmlinkage
long sys_getpeername(int fd
, struct sockaddr __user
*usockaddr
, int __user
*usockaddr_len
);
1339 extern asmlinkage
long sys_socketpair(int family
, int type
, int protocol
, int __user
*usockvec
);
1340 extern asmlinkage
long sys_send(int fd
, void __user
* buff
, size_t len
, unsigned flags
);
1341 extern asmlinkage
long sys_sendto(int fd
, void __user
* buff
, size_t len
, unsigned flags
,
1342 struct sockaddr __user
*addr
, int addr_len
);
1343 extern asmlinkage
long sys_recv(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
);
1344 extern asmlinkage
long sys_recvfrom(int fd
, void __user
* ubuf
, size_t size
, unsigned flags
,
1345 struct sockaddr __user
*addr
, int __user
*addr_len
);
1346 extern asmlinkage
long sys_shutdown(int fd
, int how
);
1347 extern asmlinkage
long sys_setsockopt(int fd
, int level
, int optname
, char __user
*optval
, int optlen
);
1348 extern asmlinkage
long sys_getsockopt(int fd
, int level
, int optname
, char __user
*optval
, int *optlen
);
1349 extern asmlinkage
long sys_sendmsg(int fd
, struct msghdr __user
*msg
, unsigned flags
);
1350 extern asmlinkage
long sys_recvmsg(int fd
, struct msghdr __user
*msg
, unsigned int flags
);
1353 if(call
<1||call
>SYS_RECVMSG
)
1356 /* copy_from_user should be SMP safe. */
1357 if (copy_from_user(a
, args32
, socketcall_nargs
[call
]))
1366 err
= sys_socket(a0
,a1
,a
[2]);
1369 err
= sys_bind(a0
,(struct sockaddr __user
*)A(a1
), a
[2]);
1372 err
= sys_connect(a0
, (struct sockaddr __user
*)A(a1
), a
[2]);
1375 err
= sys_listen(a0
,a1
);
1378 err
= sys_accept(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1380 case SYS_GETSOCKNAME
:
1381 err
= sys_getsockname(a0
,(struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1383 case SYS_GETPEERNAME
:
1384 err
= sys_getpeername(a0
, (struct sockaddr __user
*)A(a1
), (int __user
*)A(a
[2]));
1386 case SYS_SOCKETPAIR
:
1387 err
= sys_socketpair(a0
,a1
, a
[2], (int __user
*)A(a
[3]));
1390 err
= sys_send(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1393 err
= sys_sendto(a0
,(void __user
*)A(a1
), a
[2], a
[3],
1394 (struct sockaddr __user
*)A(a
[4]), a
[5]);
1397 err
= sys_recv(a0
, (void __user
*)A(a1
), a
[2], a
[3]);
1400 err
= sys_recvfrom(a0
, (void __user
*)A(a1
), a
[2], a
[3],
1401 (struct sockaddr __user
*)A(a
[4]), (int __user
*)A(a
[5]));
1404 err
= sys_shutdown(a0
,a1
);
1406 case SYS_SETSOCKOPT
:
1407 err
= sys_setsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), a
[4]);
1409 case SYS_GETSOCKOPT
:
1410 err
= sys_getsockopt(a0
, a1
, a
[2], (char __user
*)A(a
[3]), (int __user
*)A(a
[4]));
1413 err
= sys_sendmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1416 err
= sys_recvmsg(a0
, (struct msghdr __user
*) A(a1
), a
[2]);
1429 u32 payload
[(64 / 4) - 3];
1432 extern asmlinkage
long
1433 sys_timer_create(clockid_t which_clock
,
1434 struct sigevent __user
*timer_event_spec
,
1435 timer_t __user
* created_timer_id
);
1438 sys32_timer_create(u32 clock
, struct sigevent32 __user
*se32
, timer_t __user
*timer_id
)
1440 struct sigevent __user
*p
= NULL
;
1443 p
= compat_alloc_user_space(sizeof(struct sigevent
));
1444 memset(&se
, 0, sizeof(struct sigevent
));
1445 if (get_user(se
.sigev_value
.sival_int
, &se32
->sigev_value
) ||
1446 __get_user(se
.sigev_signo
, &se32
->sigev_signo
) ||
1447 __get_user(se
.sigev_notify
, &se32
->sigev_notify
) ||
1448 __copy_from_user(&se
._sigev_un
._pad
, &se32
->payload
,
1449 sizeof(se32
->payload
)) ||
1450 copy_to_user(p
, &se
, sizeof(se
)))
1453 return sys_timer_create(clock
, p
, timer_id
);
1456 save_static_function(sys32_clone
);
1457 __attribute_used__ noinline
static int
1458 _sys32_clone(nabi_no_regargs
struct pt_regs regs
)
1460 unsigned long clone_flags
;
1461 unsigned long newsp
;
1462 int __user
*parent_tidptr
, *child_tidptr
;
1464 clone_flags
= regs
.regs
[4];
1465 newsp
= regs
.regs
[5];
1467 newsp
= regs
.regs
[29];
1468 parent_tidptr
= (int *) regs
.regs
[6];
1470 /* Use __dummy4 instead of getting it off the stack, so that
1472 child_tidptr
= (int __user
*) __dummy4
;
1473 return do_fork(clone_flags
, newsp
, ®s
, 0,
1474 parent_tidptr
, child_tidptr
);
1477 extern asmlinkage
void sys_set_thread_area(u32 addr
);
1478 asmlinkage
void sys32_set_thread_area(u32 addr
)
1480 sys_set_thread_area(AA(addr
));