1 /* $Id: sys_sparc32.c,v 1.184 2002/02/09 19:49:31 davem Exp $
2 * sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
4 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
7 * These routines maintain argument size conversion between 32bit and 64bit
11 #include <linux/config.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
16 #include <linux/file.h>
17 #include <linux/signal.h>
18 #include <linux/resource.h>
19 #include <linux/times.h>
20 #include <linux/utsname.h>
21 #include <linux/timex.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/sem.h>
25 #include <linux/msg.h>
26 #include <linux/shm.h>
27 #include <linux/slab.h>
28 #include <linux/uio.h>
29 #include <linux/nfs_fs.h>
30 #include <linux/quota.h>
31 #include <linux/module.h>
32 #include <linux/sunrpc/svc.h>
33 #include <linux/nfsd/nfsd.h>
34 #include <linux/nfsd/cache.h>
35 #include <linux/nfsd/xdr.h>
36 #include <linux/nfsd/syscall.h>
37 #include <linux/poll.h>
38 #include <linux/personality.h>
39 #include <linux/stat.h>
40 #include <linux/filter.h>
41 #include <linux/highmem.h>
42 #include <linux/highuid.h>
43 #include <linux/mman.h>
44 #include <linux/ipv6.h>
46 #include <linux/icmpv6.h>
47 #include <linux/syscalls.h>
48 #include <linux/sysctl.h>
49 #include <linux/binfmts.h>
50 #include <linux/dnotify.h>
51 #include <linux/security.h>
52 #include <linux/compat.h>
53 #include <linux/vfs.h>
54 #include <linux/netfilter_ipv4/ip_tables.h>
55 #include <linux/ptrace.h>
56 #include <linux/highuid.h>
58 #include <asm/types.h>
60 #include <asm/uaccess.h>
61 #include <asm/fpumacro.h>
62 #include <asm/semaphore.h>
63 #include <asm/mmu_context.h>
65 /* Use this to get at 32-bit user passed pointers. */
66 /* Things to consider: the low-level assembly stub does
67 srl x, 0, x for first four arguments, so if you have
68 pointer to something in the first four arguments, just
69 declare it as a pointer, not u32. On the other side,
70 arguments from 5th onwards should be declared as u32
71 for pointers, and need AA() around each usage.
72 A() macro should be used for places where you e.g.
73 have some internal variable u32 and just want to get
74 rid of a compiler warning. AA() has to be used in
75 places where you want to convert a function argument
76 to 32bit pointer or when you e.g. access pt_regs
77 structure and want to consider 32bit registers only.
80 #define A(__x) ((unsigned long)(__x))
82 ({ unsigned long __ret; \
83 __asm__ ("srl %0, 0, %0" \
90 asmlinkage long sys32_chown16(const char * filename, u16 user, u16 group)
92 return sys_chown(filename, low2highuid(user), low2highgid(group));
95 asmlinkage long sys32_lchown16(const char * filename, u16 user, u16 group)
97 return sys_lchown(filename, low2highuid(user), low2highgid(group));
100 asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group)
102 return sys_fchown(fd, low2highuid(user), low2highgid(group));
105 asmlinkage long sys32_setregid16(u16 rgid, u16 egid)
107 return sys_setregid(low2highgid(rgid), low2highgid(egid));
110 asmlinkage long sys32_setgid16(u16 gid)
112 return sys_setgid((gid_t)gid);
115 asmlinkage long sys32_setreuid16(u16 ruid, u16 euid)
117 return sys_setreuid(low2highuid(ruid), low2highuid(euid));
120 asmlinkage long sys32_setuid16(u16 uid)
122 return sys_setuid((uid_t)uid);
125 asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
127 return sys_setresuid(low2highuid(ruid), low2highuid(euid),
131 asmlinkage long sys32_getresuid16(u16 *ruid, u16 *euid, u16 *suid)
135 if (!(retval = put_user(high2lowuid(current->uid), ruid)) &&
136 !(retval = put_user(high2lowuid(current->euid), euid)))
137 retval = put_user(high2lowuid(current->suid), suid);
142 asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
144 return sys_setresgid(low2highgid(rgid), low2highgid(egid),
148 asmlinkage long sys32_getresgid16(u16 *rgid, u16 *egid, u16 *sgid)
152 if (!(retval = put_user(high2lowgid(current->gid), rgid)) &&
153 !(retval = put_user(high2lowgid(current->egid), egid)))
154 retval = put_user(high2lowgid(current->sgid), sgid);
159 asmlinkage long sys32_setfsuid16(u16 uid)
161 return sys_setfsuid((uid_t)uid);
164 asmlinkage long sys32_setfsgid16(u16 gid)
166 return sys_setfsgid((gid_t)gid);
169 static int groups16_to_user(u16 *grouplist, struct group_info *group_info)
174 for (i = 0; i < group_info->ngroups; i++) {
175 group = (u16)GROUP_AT(group_info, i);
176 if (put_user(group, grouplist+i))
183 static int groups16_from_user(struct group_info *group_info, u16 *grouplist)
188 for (i = 0; i < group_info->ngroups; i++) {
189 if (get_user(group, grouplist+i))
191 GROUP_AT(group_info, i) = (gid_t)group;
197 asmlinkage long sys32_getgroups16(int gidsetsize, u16 *grouplist)
204 get_group_info(current->group_info);
205 i = current->group_info->ngroups;
207 if (i > gidsetsize) {
211 if (groups16_to_user(grouplist, current->group_info)) {
217 put_group_info(current->group_info);
221 asmlinkage long sys32_setgroups16(int gidsetsize, u16 *grouplist)
223 struct group_info *group_info;
226 if (!capable(CAP_SETGID))
228 if ((unsigned)gidsetsize > NGROUPS_MAX)
231 group_info = groups_alloc(gidsetsize);
234 retval = groups16_from_user(group_info, grouplist);
236 put_group_info(group_info);
240 retval = set_current_groups(group_info);
241 put_group_info(group_info);
246 asmlinkage long sys32_getuid16(void)
248 return high2lowuid(current->uid);
251 asmlinkage long sys32_geteuid16(void)
253 return high2lowuid(current->euid);
256 asmlinkage long sys32_getgid16(void)
258 return high2lowgid(current->gid);
261 asmlinkage long sys32_getegid16(void)
263 return high2lowgid(current->egid);
266 /* 32-bit timeval and related flotsam. */
268 static long get_tv32(struct timeval *o, struct compat_timeval *i)
270 return (!access_ok(VERIFY_READ, tv32, sizeof(*tv32)) ||
271 (__get_user(o->tv_sec, &i->tv_sec) |
272 __get_user(o->tv_usec, &i->tv_usec)));
275 static inline long put_tv32(struct compat_timeval *o, struct timeval *i)
277 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
278 (__put_user(i->tv_sec, &o->tv_sec) |
279 __put_user(i->tv_usec, &o->tv_usec)));
282 struct msgbuf32 { s32 mtype; char mtext[1]; };
296 struct ipc_perm32 sem_perm; /* permissions .. see ipc.h */
297 compat_time_t sem_otime; /* last semop time */
298 compat_time_t sem_ctime; /* last change time */
299 u32 sem_base; /* ptr to first semaphore in array */
300 u32 sem_pending; /* pending operations to be processed */
301 u32 sem_pending_last; /* last pending operation */
302 u32 undo; /* undo requests on this array */
303 unsigned short sem_nsems; /* no. of semaphores in array */
306 struct semid64_ds32 {
307 struct ipc64_perm sem_perm; /* this structure is the same on sparc32 and sparc64 */
309 compat_time_t sem_otime;
311 compat_time_t sem_ctime;
319 struct ipc_perm32 msg_perm;
322 compat_time_t msg_stime;
323 compat_time_t msg_rtime;
324 compat_time_t msg_ctime;
327 unsigned short msg_cbytes;
328 unsigned short msg_qnum;
329 unsigned short msg_qbytes;
330 compat_ipc_pid_t msg_lspid;
331 compat_ipc_pid_t msg_lrpid;
334 struct msqid64_ds32 {
335 struct ipc64_perm msg_perm;
337 compat_time_t msg_stime;
339 compat_time_t msg_rtime;
341 compat_time_t msg_ctime;
342 unsigned int msg_cbytes;
343 unsigned int msg_qnum;
344 unsigned int msg_qbytes;
345 compat_pid_t msg_lspid;
346 compat_pid_t msg_lrpid;
347 unsigned int __unused1;
348 unsigned int __unused2;
353 struct ipc_perm32 shm_perm;
355 compat_time_t shm_atime;
356 compat_time_t shm_dtime;
357 compat_time_t shm_ctime;
358 compat_ipc_pid_t shm_cpid;
359 compat_ipc_pid_t shm_lpid;
360 unsigned short shm_nattch;
363 struct shmid64_ds32 {
364 struct ipc64_perm shm_perm;
366 compat_time_t shm_atime;
368 compat_time_t shm_dtime;
370 compat_time_t shm_ctime;
371 compat_size_t shm_segsz;
372 compat_pid_t shm_cpid;
373 compat_pid_t shm_lpid;
374 unsigned int shm_nattch;
375 unsigned int __unused1;
376 unsigned int __unused2;
381 * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation..
383 * This is really horribly ugly.
385 #define IPCOP_MASK(__x) (1UL << ((__x)&~IPC_64))
386 static int do_sys32_semctl(int first, int second, int third, void *uptr)
395 if (get_user (pad, (u32 *)uptr))
397 if ((third & ~IPC_64) == SETVAL)
398 fourth.val = (int)pad;
400 fourth.__pad = (void *)A(pad);
401 if (IPCOP_MASK (third) &
402 (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SEM_INFO) | IPCOP_MASK (GETVAL) |
403 IPCOP_MASK (GETPID) | IPCOP_MASK (GETNCNT) | IPCOP_MASK (GETZCNT) |
404 IPCOP_MASK (GETALL) | IPCOP_MASK (SETALL) | IPCOP_MASK (IPC_RMID))) {
405 err = sys_semctl (first, second, third, fourth);
406 } else if (third & IPC_64) {
408 struct semid64_ds32 *usp = (struct semid64_ds32 *)A(pad);
410 int need_back_translation;
412 if (third == (IPC_SET|IPC_64)) {
413 err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
414 err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
415 err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
420 need_back_translation =
421 (IPCOP_MASK (third) &
422 (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
423 if (need_back_translation)
427 err = sys_semctl (first, second, third, fourth);
429 if (need_back_translation) {
430 int err2 = copy_to_user (&usp->sem_perm, &s.sem_perm, sizeof(struct ipc64_perm) + 2*sizeof(time_t));
431 err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
432 if (err2) err = -EFAULT;
436 struct semid_ds32 *usp = (struct semid_ds32 *)A(pad);
438 int need_back_translation;
440 if (third == IPC_SET) {
441 err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
442 err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
443 err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
448 need_back_translation =
449 (IPCOP_MASK (third) &
450 (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
451 if (need_back_translation)
455 err = sys_semctl (first, second, third, fourth);
457 if (need_back_translation) {
458 int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
459 err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
460 err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
461 err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
462 err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
463 err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
464 err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
465 err2 |= __put_user (s.sem_otime, &usp->sem_otime);
466 err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
467 err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
468 if (err2) err = -EFAULT;
475 static int do_sys32_msgsnd (int first, int second, int third, void *uptr)
477 struct msgbuf *p = kmalloc (second + sizeof (struct msgbuf), GFP_USER);
478 struct msgbuf32 *up = (struct msgbuf32 *)uptr;
485 if (get_user (p->mtype, &up->mtype) ||
486 __copy_from_user (p->mtext, &up->mtext, second))
490 err = sys_msgsnd (first, p, second, third);
497 static int do_sys32_msgrcv (int first, int second, int msgtyp, int third,
498 int version, void *uptr)
506 struct ipc_kludge *uipck = (struct ipc_kludge *)uptr;
507 struct ipc_kludge ipck;
513 if (copy_from_user (&ipck, uipck, sizeof (struct ipc_kludge)))
515 uptr = (void *)A(ipck.msgp);
516 msgtyp = ipck.msgtyp;
519 p = kmalloc (second + sizeof (struct msgbuf), GFP_USER);
524 err = sys_msgrcv (first, p, second, msgtyp, third);
528 up = (struct msgbuf32 *)uptr;
529 if (put_user (p->mtype, &up->mtype) ||
530 __copy_to_user (&up->mtext, p->mtext, err))
538 static int do_sys32_msgctl (int first, int second, void *uptr)
542 if (IPCOP_MASK (second) &
543 (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (MSG_INFO) |
544 IPCOP_MASK (IPC_RMID))) {
545 err = sys_msgctl (first, second, (struct msqid_ds *)uptr);
546 } else if (second & IPC_64) {
548 struct msqid64_ds32 *up = (struct msqid64_ds32 *)uptr;
551 if (second == (IPC_SET|IPC_64)) {
552 err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
553 err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
554 err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
555 err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
561 err = sys_msgctl (first, second, (struct msqid_ds *)&m);
563 if (IPCOP_MASK (second) &
564 (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
565 int err2 = copy_to_user(&up->msg_perm, &m.msg_perm, sizeof(struct ipc64_perm) + 3*sizeof(time_t));
566 err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
567 err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
568 err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
569 err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
570 err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
576 struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;
579 if (second == IPC_SET) {
580 err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
581 err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
582 err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
583 err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
589 err = sys_msgctl (first, second, &m);
591 if (IPCOP_MASK (second) &
592 (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
593 int err2 = put_user (m.msg_perm.key, &up->msg_perm.key);
594 err2 |= __put_user (high2lowuid(m.msg_perm.uid), &up->msg_perm.uid);
595 err2 |= __put_user (high2lowgid(m.msg_perm.gid), &up->msg_perm.gid);
596 err2 |= __put_user (high2lowuid(m.msg_perm.cuid), &up->msg_perm.cuid);
597 err2 |= __put_user (high2lowgid(m.msg_perm.cgid), &up->msg_perm.cgid);
598 err2 |= __put_user (m.msg_perm.mode, &up->msg_perm.mode);
599 err2 |= __put_user (m.msg_perm.seq, &up->msg_perm.seq);
600 err2 |= __put_user (m.msg_stime, &up->msg_stime);
601 err2 |= __put_user (m.msg_rtime, &up->msg_rtime);
602 err2 |= __put_user (m.msg_ctime, &up->msg_ctime);
603 err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
604 err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
605 err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
606 err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
607 err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
617 static int do_sys32_shmat (int first, int second, int third, int version, void *uptr)
620 u32 *uaddr = (u32 *)A((u32)third);
625 err = do_shmat (first, uptr, second, &raddr);
628 err = put_user (raddr, uaddr);
633 static int do_sys32_shmctl (int first, int second, void *uptr)
637 if (IPCOP_MASK (second) &
638 (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SHM_LOCK) | IPCOP_MASK (SHM_UNLOCK) |
639 IPCOP_MASK (IPC_RMID))) {
640 if (second == (IPC_INFO|IPC_64))
641 second = IPC_INFO; /* So that we don't have to translate it */
642 err = sys_shmctl (first, second, (struct shmid_ds *)uptr);
643 } else if ((second & IPC_64) && second != (SHM_INFO|IPC_64)) {
645 struct shmid64_ds32 *up = (struct shmid64_ds32 *)uptr;
648 if (second == (IPC_SET|IPC_64)) {
649 err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
650 err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
651 err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
657 err = sys_shmctl (first, second, (struct shmid_ds *)&s);
662 /* Mask it even in this case so it becomes a CSE. */
663 if (IPCOP_MASK (second) &
664 (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
665 int err2 = copy_to_user (&up->shm_perm, &s.shm_perm, sizeof(struct ipc64_perm) + 3*sizeof(time_t));
666 err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
667 err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
668 err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
669 err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
675 struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
679 if (second == IPC_SET) {
680 err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
681 err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
682 err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
688 err = sys_shmctl (first, second, &s);
693 /* Mask it even in this case so it becomes a CSE. */
694 if (second == SHM_INFO) {
697 u32 shm_tot, shm_rss, shm_swp;
698 u32 swap_attempts, swap_successes;
699 } *uip = (struct shm_info32 *)uptr;
700 struct shm_info *kp = (struct shm_info *)&s;
701 int err2 = put_user (kp->used_ids, &uip->used_ids);
702 err2 |= __put_user (kp->shm_tot, &uip->shm_tot);
703 err2 |= __put_user (kp->shm_rss, &uip->shm_rss);
704 err2 |= __put_user (kp->shm_swp, &uip->shm_swp);
705 err2 |= __put_user (kp->swap_attempts, &uip->swap_attempts);
706 err2 |= __put_user (kp->swap_successes, &uip->swap_successes);
709 } else if (IPCOP_MASK (second) &
710 (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
711 int err2 = put_user (s.shm_perm.key, &up->shm_perm.key);
712 err2 |= __put_user (high2lowuid(s.shm_perm.uid), &up->shm_perm.uid);
713 err2 |= __put_user (high2lowuid(s.shm_perm.gid), &up->shm_perm.gid);
714 err2 |= __put_user (high2lowuid(s.shm_perm.cuid), &up->shm_perm.cuid);
715 err2 |= __put_user (high2lowuid(s.shm_perm.cgid), &up->shm_perm.cgid);
716 err2 |= __put_user (s.shm_perm.mode, &up->shm_perm.mode);
717 err2 |= __put_user (s.shm_perm.seq, &up->shm_perm.seq);
718 err2 |= __put_user (s.shm_atime, &up->shm_atime);
719 err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
720 err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
721 err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
722 err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
723 err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
724 err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
733 static int sys32_semtimedop(int semid, struct sembuf *tsems, int nsems,
734 const struct compat_timespec *timeout32)
736 struct compat_timespec t32;
737 struct timespec *t64 = compat_alloc_user_space(sizeof(*t64));
739 if (copy_from_user(&t32, timeout32, sizeof(t32)))
742 if (put_user(t32.tv_sec, &t64->tv_sec) ||
743 put_user(t32.tv_nsec, &t64->tv_nsec))
746 return sys_semtimedop(semid, tsems, nsems, t64);
749 asmlinkage int sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
753 version = call >> 16; /* hack for backward compatibility */
759 /* struct sembuf is the same on 32 and 64bit :)) */
760 err = sys_semtimedop (first, (struct sembuf *)AA(ptr), second, NULL);
763 err = sys32_semtimedop (first, (struct sembuf *)AA(ptr), second, (const struct compat_timespec *) AA(fifth));
765 err = sys_semget (first, second, third);
768 err = do_sys32_semctl (first, second, third, (void *)AA(ptr));
777 err = do_sys32_msgsnd (first, second, third, (void *)AA(ptr));
780 err = do_sys32_msgrcv (first, second, fifth, third,
781 version, (void *)AA(ptr));
784 err = sys_msgget ((key_t) first, second);
787 err = do_sys32_msgctl (first, second, (void *)AA(ptr));
796 err = do_sys32_shmat (first, second, third,
797 version, (void *)AA(ptr));
800 err = sys_shmdt ((char *)AA(ptr));
803 err = sys_shmget (first, second, third);
806 err = do_sys32_shmctl (first, second, (void *)AA(ptr));
819 asmlinkage int sys32_truncate64(const char * path, unsigned long high, unsigned long low)
824 return sys_truncate(path, (high << 32) | low);
827 asmlinkage int sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
832 return sys_ftruncate(fd, (high << 32) | low);
835 typedef ssize_t (*io_fn_t)(struct file *, char *, size_t, loff_t *);
836 typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
838 static long do_readv_writev32(int type, struct file *file,
839 const struct compat_iovec *vector, u32 count)
841 compat_ssize_t tot_len;
842 struct iovec iovstack[UIO_FASTIOV];
843 struct iovec *iov=iovstack, *ivp;
850 * SuS says "The readv() function *may* fail if the iovcnt argument
851 * was less than or equal to 0, or greater than {IOV_MAX}. Linux has
852 * traditionally returned zero for zero segments, so...
858 /* First get the "struct iovec" from user memory and
859 * verify all the pointers
862 if (count > UIO_MAXIOV)
866 if (count > UIO_FASTIOV) {
868 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
873 if (verify_area(VERIFY_READ, vector, sizeof(struct compat_iovec)*count))
877 * Single unix specification:
878 * We should -EINVAL if an element length is not >= 0 and fitting an
879 * ssize_t. The total length is fitting an ssize_t
881 * Be careful here because iov_len is a size_t not an ssize_t
888 compat_ssize_t tmp = tot_len;
892 if (__get_user(len, &vector->iov_len) ||
893 __get_user(buf, &vector->iov_base)) {
897 if (len < 0) /* size_t not fitting an ssize_t32 .. */
900 if (tot_len < tmp) /* maths overflow on the compat_ssize_t */
902 ivp->iov_base = (void *)A(buf);
903 ivp->iov_len = (__kernel_size_t) len;
913 inode = file->f_dentry->d_inode;
914 /* VERIFY_WRITE actually means a read, as we write to user space */
915 retval = locks_verify_area((type == READ
916 ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
917 inode, file, file->f_pos, tot_len);
922 fn = file->f_op->read;
923 fnv = file->f_op->readv;
925 fn = (io_fn_t)file->f_op->write;
926 fnv = file->f_op->writev;
929 retval = fnv(file, iov, count, &file->f_pos);
933 /* Do it by hand, with file-ops */
939 base = ivp->iov_base;
944 nr = fn(file, base, len, &file->f_pos);
958 if ((retval + (type == READ)) > 0)
959 dnotify_parent(file->f_dentry,
960 (type == READ) ? DN_ACCESS : DN_MODIFY);
965 asmlinkage long sys32_readv(int fd, struct compat_iovec *vector, u32 count)
975 if (!(file->f_mode & FMODE_READ))
978 if (!file->f_op || (!file->f_op->readv && !file->f_op->read))
981 ret = do_readv_writev32(READ, file, vector, count);
988 asmlinkage long sys32_writev(int fd, struct compat_iovec *vector, u32 count)
998 if (!(file->f_mode & FMODE_WRITE))
1001 if (!file->f_op || (!file->f_op->writev && !file->f_op->write))
1004 ret = do_readv_writev32(WRITE, file, vector, count);
1011 /* readdir & getdents */
1013 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
1014 #define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
1016 struct old_linux_dirent32 {
1019 unsigned short d_namlen;
1023 struct readdir_callback32 {
1024 struct old_linux_dirent32 * dirent;
1028 static int fillonedir(void * __buf, const char * name, int namlen,
1029 loff_t offset, ino_t ino, unsigned int d_type)
1031 struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
1032 struct old_linux_dirent32 * dirent;
1037 dirent = buf->dirent;
1038 put_user(ino, &dirent->d_ino);
1039 put_user(offset, &dirent->d_offset);
1040 put_user(namlen, &dirent->d_namlen);
1041 copy_to_user(dirent->d_name, name, namlen);
1042 put_user(0, dirent->d_name + namlen);
1046 asmlinkage int old32_readdir(unsigned int fd, struct old_linux_dirent32 *dirent, unsigned int count)
1050 struct readdir_callback32 buf;
1057 buf.dirent = dirent;
1059 error = vfs_readdir(file, fillonedir, &buf);
1070 struct linux_dirent32 {
1073 unsigned short d_reclen;
1077 struct getdents_callback32 {
1078 struct linux_dirent32 * current_dir;
1079 struct linux_dirent32 * previous;
1084 static int filldir(void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
1085 unsigned int d_type)
1087 struct linux_dirent32 * dirent;
1088 struct getdents_callback32 * buf = (struct getdents_callback32 *) __buf;
1089 int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
1091 buf->error = -EINVAL; /* only used if we fail.. */
1092 if (reclen > buf->count)
1094 dirent = buf->previous;
1096 put_user(offset, &dirent->d_off);
1097 dirent = buf->current_dir;
1098 buf->previous = dirent;
1099 put_user(ino, &dirent->d_ino);
1100 put_user(reclen, &dirent->d_reclen);
1101 copy_to_user(dirent->d_name, name, namlen);
1102 put_user(0, dirent->d_name + namlen);
1103 put_user(d_type, (char *) dirent + reclen - 1);
1104 dirent = (void *) dirent + reclen;
1105 buf->current_dir = dirent;
1106 buf->count -= reclen;
1110 asmlinkage int sys32_getdents(unsigned int fd, struct linux_dirent32 *dirent, unsigned int count)
1113 struct linux_dirent32 * lastdirent;
1114 struct getdents_callback32 buf;
1121 buf.current_dir = dirent;
1122 buf.previous = NULL;
1126 error = vfs_readdir(file, filldir, &buf);
1129 lastdirent = buf.previous;
1132 put_user(file->f_pos, &lastdirent->d_off);
1133 error = count - buf.count;
1141 /* end of readdir & getdents */
1144 * Ooo, nasty. We need here to frob 32-bit unsigned longs to
1145 * 64-bit unsigned longs.
1148 static int get_fd_set32(unsigned long n, unsigned long *fdset, u32 *ufdset)
1153 if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32)))
1160 __get_user(l, ufdset);
1161 __get_user(h, ufdset+1);
1163 *fdset++ = h << 32 | l;
1167 __get_user(*fdset, ufdset);
1169 /* Tricky, must clear full unsigned long in the
1170 * kernel fdset at the end, this makes sure that
1173 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
1178 static void set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
1191 __put_user(l, ufdset);
1192 __put_user(h, ufdset+1);
1197 __put_user(*fdset, ufdset);
1200 #define MAX_SELECT_SECONDS \
1201 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
1203 asmlinkage int sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, u32 tvp_x)
1206 struct compat_timeval *tvp = (struct compat_timeval *)AA(tvp_x);
1212 timeout = MAX_SCHEDULE_TIMEOUT;
1216 if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
1217 || (ret = __get_user(sec, &tvp->tv_sec))
1218 || (ret = __get_user(usec, &tvp->tv_usec)))
1222 if(sec < 0 || usec < 0)
1225 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1226 timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
1227 timeout += sec * (unsigned long) HZ;
1234 if (n > current->files->max_fdset)
1235 n = current->files->max_fdset;
1238 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1239 * since we used fdset we need to allocate memory in units of
1243 size = FDS_BYTES(n);
1244 bits = kmalloc(6 * size, GFP_KERNEL);
1247 fds.in = (unsigned long *) bits;
1248 fds.out = (unsigned long *) (bits + size);
1249 fds.ex = (unsigned long *) (bits + 2*size);
1250 fds.res_in = (unsigned long *) (bits + 3*size);
1251 fds.res_out = (unsigned long *) (bits + 4*size);
1252 fds.res_ex = (unsigned long *) (bits + 5*size);
1254 nn = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
1255 if ((ret = get_fd_set32(nn, fds.in, inp)) ||
1256 (ret = get_fd_set32(nn, fds.out, outp)) ||
1257 (ret = get_fd_set32(nn, fds.ex, exp)))
1259 zero_fd_set(n, fds.res_in);
1260 zero_fd_set(n, fds.res_out);
1261 zero_fd_set(n, fds.res_ex);
1263 ret = do_select(n, &fds, &timeout);
1265 if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
1266 time_t sec = 0, usec = 0;
1269 usec = timeout % HZ;
1270 usec *= (1000000/HZ);
1272 put_user(sec, &tvp->tv_sec);
1273 put_user(usec, &tvp->tv_usec);
1279 ret = -ERESTARTNOHAND;
1280 if (signal_pending(current))
1285 set_fd_set32(nn, inp, fds.res_in);
1286 set_fd_set32(nn, outp, fds.res_out);
1287 set_fd_set32(nn, exp, fds.res_ex);
1295 int cp_compat_stat(struct kstat *stat, struct compat_stat *statbuf)
1299 if (stat->size > MAX_NON_LFS || !old_valid_dev(stat->dev) ||
1300 !old_valid_dev(stat->rdev))
1303 err = put_user(old_encode_dev(stat->dev), &statbuf->st_dev);
1304 err |= put_user(stat->ino, &statbuf->st_ino);
1305 err |= put_user(stat->mode, &statbuf->st_mode);
1306 err |= put_user(stat->nlink, &statbuf->st_nlink);
1307 err |= put_user(high2lowuid(stat->uid), &statbuf->st_uid);
1308 err |= put_user(high2lowgid(stat->gid), &statbuf->st_gid);
1309 err |= put_user(old_encode_dev(stat->rdev), &statbuf->st_rdev);
1310 err |= put_user(stat->size, &statbuf->st_size);
1311 err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
1312 err |= put_user(0, &statbuf->__unused1);
1313 err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
1314 err |= put_user(0, &statbuf->__unused2);
1315 err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
1316 err |= put_user(0, &statbuf->__unused3);
1317 err |= put_user(stat->blksize, &statbuf->st_blksize);
1318 err |= put_user(stat->blocks, &statbuf->st_blocks);
1319 err |= put_user(0, &statbuf->__unused4[0]);
1320 err |= put_user(0, &statbuf->__unused4[1]);
1325 asmlinkage int sys32_sysfs(int option, u32 arg1, u32 arg2)
1327 return sys_sysfs(option, arg1, arg2);
1339 unsigned short procs;
1344 char _f[20-2*sizeof(int)-sizeof(int)];
1347 asmlinkage int sys32_sysinfo(struct sysinfo32 *info)
1352 mm_segment_t old_fs = get_fs ();
1355 ret = sys_sysinfo(&s);
1357 /* Check to see if any memory value is too large for 32-bit and
1358 * scale down if needed.
1360 if ((s.totalram >> 32) || (s.totalswap >> 32)) {
1361 while (s.mem_unit < PAGE_SIZE) {
1365 s.totalram >>= bitcount;
1366 s.freeram >>= bitcount;
1367 s.sharedram >>= bitcount;
1368 s.bufferram >>= bitcount;
1369 s.totalswap >>= bitcount;
1370 s.freeswap >>= bitcount;
1371 s.totalhigh >>= bitcount;
1372 s.freehigh >>= bitcount;
1375 err = put_user (s.uptime, &info->uptime);
1376 err |= __put_user (s.loads[0], &info->loads[0]);
1377 err |= __put_user (s.loads[1], &info->loads[1]);
1378 err |= __put_user (s.loads[2], &info->loads[2]);
1379 err |= __put_user (s.totalram, &info->totalram);
1380 err |= __put_user (s.freeram, &info->freeram);
1381 err |= __put_user (s.sharedram, &info->sharedram);
1382 err |= __put_user (s.bufferram, &info->bufferram);
1383 err |= __put_user (s.totalswap, &info->totalswap);
1384 err |= __put_user (s.freeswap, &info->freeswap);
1385 err |= __put_user (s.procs, &info->procs);
1386 err |= __put_user (s.totalhigh, &info->totalhigh);
1387 err |= __put_user (s.freehigh, &info->freehigh);
1388 err |= __put_user (s.mem_unit, &info->mem_unit);
1394 asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid, struct compat_timespec *interval)
1398 mm_segment_t old_fs = get_fs ();
1401 ret = sys_sched_rr_get_interval(pid, &t);
1403 if (put_compat_timespec(&t, interval))
1408 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set, compat_sigset_t *oset, compat_size_t sigsetsize)
1411 compat_sigset_t s32;
1413 mm_segment_t old_fs = get_fs();
1416 if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
1418 switch (_NSIG_WORDS) {
1419 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
1420 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
1421 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
1422 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
1426 ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sigsetsize);
1428 if (ret) return ret;
1430 switch (_NSIG_WORDS) {
1431 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
1432 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
1433 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
1434 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
1436 if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
1442 asmlinkage int sys32_rt_sigpending(compat_sigset_t *set, compat_size_t sigsetsize)
1445 compat_sigset_t s32;
1447 mm_segment_t old_fs = get_fs();
1450 ret = sys_rt_sigpending(&s, sigsetsize);
1453 switch (_NSIG_WORDS) {
1454 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
1455 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
1456 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
1457 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
1459 if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
1466 sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
1467 struct compat_timespec *uts, compat_size_t sigsetsize)
1471 compat_sigset_t these32;
1476 /* XXX: Don't preclude handling different sized sigset_t's. */
1477 if (sigsetsize != sizeof(sigset_t))
1480 if (copy_from_user (&these32, uthese, sizeof(compat_sigset_t)))
1483 switch (_NSIG_WORDS) {
1484 case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
1485 case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
1486 case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
1487 case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
1491 * Invert the set of allowed signals to get those we
1494 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
1498 if (get_compat_timespec(&ts, uts))
1500 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
1505 spin_lock_irq(¤t->sighand->siglock);
1506 sig = dequeue_signal(current, &these, &info);
1508 timeout = MAX_SCHEDULE_TIMEOUT;
1510 timeout = (timespec_to_jiffies(&ts)
1511 + (ts.tv_sec || ts.tv_nsec));
1514 /* None ready -- temporarily unblock those we're
1515 * interested while we are sleeping in so that we'll
1516 * be awakened when they arrive. */
1517 current->real_blocked = current->blocked;
1518 sigandsets(¤t->blocked, ¤t->blocked, &these);
1519 recalc_sigpending();
1520 spin_unlock_irq(¤t->sighand->siglock);
1522 current->state = TASK_INTERRUPTIBLE;
1523 timeout = schedule_timeout(timeout);
1525 spin_lock_irq(¤t->sighand->siglock);
1526 sig = dequeue_signal(current, &these, &info);
1527 current->blocked = current->real_blocked;
1528 siginitset(¤t->real_blocked, 0);
1529 recalc_sigpending();
1532 spin_unlock_irq(¤t->sighand->siglock);
1537 if (copy_siginfo_to_user32(uinfo, &info))
1550 sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
1554 mm_segment_t old_fs = get_fs();
1556 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
1557 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
1560 ret = sys_rt_sigqueueinfo(pid, sig, &info);
1565 extern void check_pending(int signum);
1567 asmlinkage int sys32_sigaction (int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
1569 struct k_sigaction new_ka, old_ka;
1573 set_thread_flag(TIF_NEWSIGNALS);
1578 compat_old_sigset_t mask;
1579 u32 u_handler, u_restorer;
1581 ret = get_user(u_handler, &act->sa_handler);
1582 new_ka.sa.sa_handler = (void *) (long) u_handler;
1583 ret |= __get_user(u_restorer, &act->sa_restorer);
1584 new_ka.sa.sa_restorer = (void *) (long) u_restorer;
1585 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
1586 ret |= __get_user(mask, &act->sa_mask);
1589 new_ka.ka_restorer = NULL;
1590 siginitset(&new_ka.sa.sa_mask, mask);
1593 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
1596 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
1597 ret |= __put_user((long)old_ka.sa.sa_restorer, &oact->sa_restorer);
1598 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
1599 ret |= __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
1606 sys32_rt_sigaction(int sig, struct sigaction32 *act, struct sigaction32 *oact,
1607 void *restorer, compat_size_t sigsetsize)
1609 struct k_sigaction new_ka, old_ka;
1611 compat_sigset_t set32;
1613 /* XXX: Don't preclude handling different sized sigset_t's. */
1614 if (sigsetsize != sizeof(compat_sigset_t))
1617 /* All tasks which use RT signals (effectively) use
1618 * new style signals.
1620 set_thread_flag(TIF_NEWSIGNALS);
1623 u32 u_handler, u_restorer;
1625 new_ka.ka_restorer = restorer;
1626 ret = get_user(u_handler, &act->sa_handler);
1627 new_ka.sa.sa_handler = (void *) (long) u_handler;
1628 ret |= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
1629 switch (_NSIG_WORDS) {
1630 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] | (((long)set32.sig[7]) << 32);
1631 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] | (((long)set32.sig[5]) << 32);
1632 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] | (((long)set32.sig[3]) << 32);
1633 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] | (((long)set32.sig[1]) << 32);
1635 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
1636 ret |= __get_user(u_restorer, &act->sa_restorer);
1637 new_ka.sa.sa_restorer = (void *) (long) u_restorer;
1642 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
1645 switch (_NSIG_WORDS) {
1646 case 4: set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); set32.sig[6] = old_ka.sa.sa_mask.sig[3];
1647 case 3: set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); set32.sig[4] = old_ka.sa.sa_mask.sig[2];
1648 case 2: set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); set32.sig[2] = old_ka.sa.sa_mask.sig[1];
1649 case 1: set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); set32.sig[0] = old_ka.sa.sa_mask.sig[0];
1651 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
1652 ret |= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
1653 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
1654 ret |= __put_user((long)old_ka.sa.sa_restorer, &oact->sa_restorer);
1664 * count32() counts the number of arguments/envelopes
1666 static int count32(u32 * argv, int max)
1674 error = get_user(p,argv);
1688 * 'copy_string32()' copies argument/envelope strings from user
1689 * memory to free pages in kernel mem. These are in a format ready
1690 * to be put directly into the top of new user memory.
1692 static int copy_strings32(int argc, u32 * argv, struct linux_binprm *bprm)
1694 while (argc-- > 0) {
1699 if (get_user(str, argv + argc) ||
1701 !(len = strnlen_user((char *)A(str), bprm->p)))
1713 int offset, bytes_to_copy, new, err;
1715 offset = pos % PAGE_SIZE;
1716 page = bprm->page[pos / PAGE_SIZE];
1719 page = alloc_page(GFP_USER);
1720 bprm->page[pos / PAGE_SIZE] = page;
1728 memset(kaddr, 0, offset);
1729 bytes_to_copy = PAGE_SIZE - offset;
1730 if (bytes_to_copy > len) {
1731 bytes_to_copy = len;
1733 memset(kaddr+offset+len, 0,
1734 PAGE_SIZE-offset-len);
1737 err = copy_from_user(kaddr + offset, (char *)A(str),
1744 pos += bytes_to_copy;
1745 str += bytes_to_copy;
1746 len -= bytes_to_copy;
1753 * sys32_execve() executes a new program.
1756 do_execve32(char * filename, u32 * argv, u32 * envp, struct pt_regs * regs)
1758 struct linux_binprm bprm;
1763 sched_balance_exec();
1765 file = open_exec(filename);
1767 retval = PTR_ERR(file);
1771 bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
1772 memset(bprm.page, 0, MAX_ARG_PAGES * sizeof(bprm.page[0]));
1775 bprm.filename = filename;
1776 bprm.interp = filename;
1780 bprm.security = NULL;
1781 bprm.mm = mm_alloc();
1786 retval = init_new_context(current, bprm.mm);
1790 bprm.argc = count32(argv, bprm.p / sizeof(u32));
1791 if ((retval = bprm.argc) < 0)
1794 bprm.envc = count32(envp, bprm.p / sizeof(u32));
1795 if ((retval = bprm.envc) < 0)
1798 retval = security_bprm_alloc(&bprm);
1802 retval = prepare_binprm(&bprm);
1806 retval = copy_strings_kernel(1, &bprm.filename, &bprm);
1811 retval = copy_strings32(bprm.envc, envp, &bprm);
1815 retval = copy_strings32(bprm.argc, argv, &bprm);
1819 retval = search_binary_handler(&bprm, regs);
1821 /* execve success */
1822 security_bprm_free(&bprm);
1827 /* Something went wrong, return the inode and free the argument pages*/
1828 for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
1829 struct page * page = bprm.page[i];
1835 security_bprm_free(&bprm);
1843 allow_write_access(bprm.file);
1850 * sparc32_execve() executes a new program after the asm stub has set
1851 * things up for us. This should basically do what I want it to.
1853 asmlinkage int sparc32_execve(struct pt_regs *regs)
1855 int error, base = 0;
1858 /* User register window flush is done by entry.S */
1860 /* Check for indirect call. */
1861 if((u32)regs->u_regs[UREG_G1] == 0)
1864 filename = getname((char *)AA(regs->u_regs[base + UREG_I0]));
1865 error = PTR_ERR(filename);
1866 if(IS_ERR(filename))
1868 error = do_execve32(filename,
1869 (u32 *)AA((u32)regs->u_regs[base + UREG_I1]),
1870 (u32 *)AA((u32)regs->u_regs[base + UREG_I2]), regs);
1875 current_thread_info()->xfsr[0] = 0;
1876 current_thread_info()->fpsaved[0] = 0;
1877 regs->tstate &= ~TSTATE_PEF;
1878 current->ptrace &= ~PT_DTRACE;
1884 #ifdef CONFIG_MODULES
1886 asmlinkage int sys32_init_module(void *umod, u32 len, const char *uargs)
1888 return sys_init_module(umod, len, uargs);
1891 asmlinkage int sys32_delete_module(const char *name_user, unsigned int flags)
1893 return sys_delete_module(name_user, flags);
1896 #else /* CONFIG_MODULES */
1899 sys32_init_module(const char *name_user, struct module *mod_user)
1905 sys32_delete_module(const char *name_user)
1910 #endif /* CONFIG_MODULES */
1912 #if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)
1913 /* Stuff for NFS server syscalls... */
1914 struct nfsctl_svc32 {
1919 struct nfsctl_client32 {
1920 s8 cl32_ident[NFSCLNT_IDMAX+1];
1922 struct in_addr cl32_addrlist[NFSCLNT_ADDRMAX];
1925 u8 cl32_fhkey[NFSCLNT_KEYMAX];
1928 struct nfsctl_export32 {
1929 s8 ex32_client[NFSCLNT_IDMAX+1];
1930 s8 ex32_path[NFS_MAXPATHLEN+1];
1931 compat_dev_t ex32_dev;
1932 compat_ino_t ex32_ino;
1934 compat_uid_t ex32_anon_uid;
1935 compat_gid_t ex32_anon_gid;
1938 struct nfsctl_fdparm32 {
1939 struct sockaddr gd32_addr;
1940 s8 gd32_path[NFS_MAXPATHLEN+1];
1944 struct nfsctl_fsparm32 {
1945 struct sockaddr gd32_addr;
1946 s8 gd32_path[NFS_MAXPATHLEN+1];
1950 struct nfsctl_arg32 {
1951 s32 ca32_version; /* safeguard */
1953 struct nfsctl_svc32 u32_svc;
1954 struct nfsctl_client32 u32_client;
1955 struct nfsctl_export32 u32_export;
1956 struct nfsctl_fdparm32 u32_getfd;
1957 struct nfsctl_fsparm32 u32_getfs;
1959 #define ca32_svc u.u32_svc
1960 #define ca32_client u.u32_client
1961 #define ca32_export u.u32_export
1962 #define ca32_getfd u.u32_getfd
1963 #define ca32_getfs u.u32_getfs
1966 union nfsctl_res32 {
1967 __u8 cr32_getfh[NFS_FHSIZE];
1968 struct knfsd_fh cr32_getfs;
1971 static int nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
1975 err = __get_user(karg->ca_version, &arg32->ca32_version);
1976 err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
1977 err |= __get_user(karg->ca_svc.svc_nthreads, &arg32->ca32_svc.svc32_nthreads);
1981 static int nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
1985 err = __get_user(karg->ca_version, &arg32->ca32_version);
1986 err |= copy_from_user(&karg->ca_client.cl_ident[0],
1987 &arg32->ca32_client.cl32_ident[0],
1989 err |= __get_user(karg->ca_client.cl_naddr, &arg32->ca32_client.cl32_naddr);
1990 err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
1991 &arg32->ca32_client.cl32_addrlist[0],
1992 (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
1993 err |= __get_user(karg->ca_client.cl_fhkeytype,
1994 &arg32->ca32_client.cl32_fhkeytype);
1995 err |= __get_user(karg->ca_client.cl_fhkeylen,
1996 &arg32->ca32_client.cl32_fhkeylen);
1997 err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
1998 &arg32->ca32_client.cl32_fhkey[0],
2000 return (err ? -EFAULT : 0);
2003 static int nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2007 err = __get_user(karg->ca_version, &arg32->ca32_version);
2008 err |= copy_from_user(&karg->ca_export.ex_client[0],
2009 &arg32->ca32_export.ex32_client[0],
2011 err |= copy_from_user(&karg->ca_export.ex_path[0],
2012 &arg32->ca32_export.ex32_path[0],
2014 err |= __get_user(karg->ca_export.ex_dev,
2015 &arg32->ca32_export.ex32_dev);
2016 err |= __get_user(karg->ca_export.ex_ino,
2017 &arg32->ca32_export.ex32_ino);
2018 err |= __get_user(karg->ca_export.ex_flags,
2019 &arg32->ca32_export.ex32_flags);
2020 err |= __get_user(karg->ca_export.ex_anon_uid,
2021 &arg32->ca32_export.ex32_anon_uid);
2022 err |= __get_user(karg->ca_export.ex_anon_gid,
2023 &arg32->ca32_export.ex32_anon_gid);
2024 karg->ca_export.ex_anon_uid = high2lowuid(karg->ca_export.ex_anon_uid);
2025 karg->ca_export.ex_anon_gid = high2lowgid(karg->ca_export.ex_anon_gid);
2026 return (err ? -EFAULT : 0);
2029 static int nfs_getfd32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2033 err = __get_user(karg->ca_version, &arg32->ca32_version);
2034 err |= copy_from_user(&karg->ca_getfd.gd_addr,
2035 &arg32->ca32_getfd.gd32_addr,
2036 (sizeof(struct sockaddr)));
2037 err |= copy_from_user(&karg->ca_getfd.gd_path,
2038 &arg32->ca32_getfd.gd32_path,
2039 (NFS_MAXPATHLEN+1));
2040 err |= __get_user(karg->ca_getfd.gd_version,
2041 &arg32->ca32_getfd.gd32_version);
2042 return (err ? -EFAULT : 0);
2045 static int nfs_getfs32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
2049 err = __get_user(karg->ca_version, &arg32->ca32_version);
2050 err |= copy_from_user(&karg->ca_getfs.gd_addr,
2051 &arg32->ca32_getfs.gd32_addr,
2052 (sizeof(struct sockaddr)));
2053 err |= copy_from_user(&karg->ca_getfs.gd_path,
2054 &arg32->ca32_getfs.gd32_path,
2055 (NFS_MAXPATHLEN+1));
2056 err |= __get_user(karg->ca_getfs.gd_maxlen,
2057 &arg32->ca32_getfs.gd32_maxlen);
2058 return (err ? -EFAULT : 0);
2061 /* This really doesn't need translations, we are only passing
2062 * back a union which contains opaque nfs file handle data.
2064 static int nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
2066 return (copy_to_user(res32, kres, sizeof(*res32)) ? -EFAULT : 0);
2069 int asmlinkage sys32_nfsservctl(int cmd, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
2071 struct nfsctl_arg *karg = NULL;
2072 union nfsctl_res *kres = NULL;
2076 karg = kmalloc(sizeof(*karg), GFP_USER);
2080 kres = kmalloc(sizeof(*kres), GFP_USER);
2088 err = nfs_svc32_trans(karg, arg32);
2090 case NFSCTL_ADDCLIENT:
2091 err = nfs_clnt32_trans(karg, arg32);
2093 case NFSCTL_DELCLIENT:
2094 err = nfs_clnt32_trans(karg, arg32);
2097 case NFSCTL_UNEXPORT:
2098 err = nfs_exp32_trans(karg, arg32);
2101 err = nfs_getfd32_trans(karg, arg32);
2104 err = nfs_getfs32_trans(karg, arg32);
2114 err = sys_nfsservctl(cmd, karg, kres);
2120 if((cmd == NFSCTL_GETFD) ||
2121 (cmd == NFSCTL_GETFS))
2122 err = nfs_getfh32_res_trans(kres, res32);
2132 int asmlinkage sys32_nfsservctl(int cmd, void *notused, void *notused2)
2134 return sys_ni_syscall();
2138 /* Translations due to time_t size differences. Which affects all
2139 sorts of things, like timeval and itimerval. */
2141 extern struct timezone sys_tz;
2143 asmlinkage int sys32_gettimeofday(struct compat_timeval *tv, struct timezone *tz)
2147 do_gettimeofday(&ktv);
2148 if (put_tv32(tv, &ktv))
2152 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
2158 static inline long get_ts32(struct timespec *o, struct compat_timeval *i)
2162 if (!access_ok(VERIFY_READ, i, sizeof(*i)))
2164 if (__get_user(o->tv_sec, &i->tv_sec))
2166 if (__get_user(usec, &i->tv_usec))
2168 o->tv_nsec = usec * 1000;
2172 asmlinkage int sys32_settimeofday(struct compat_timeval *tv, struct timezone *tz)
2174 struct timespec kts;
2175 struct timezone ktz;
2178 if (get_ts32(&kts, tv))
2182 if (copy_from_user(&ktz, tz, sizeof(ktz)))
2186 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
2189 asmlinkage int sys32_utimes(char *filename, struct compat_timeval *tvs)
2192 struct timeval ktvs[2];
2193 mm_segment_t old_fs;
2196 kfilename = getname(filename);
2197 ret = PTR_ERR(kfilename);
2198 if (!IS_ERR(kfilename)) {
2200 if (get_tv32(&ktvs[0], tvs) ||
2201 get_tv32(&ktvs[1], 1+tvs))
2207 ret = do_utimes(kfilename, (tvs ? &ktvs[0] : NULL));
2215 /* These are here just in case some old sparc32 binary calls it. */
2216 asmlinkage int sys32_pause(void)
2218 current->state = TASK_INTERRUPTIBLE;
2220 return -ERESTARTNOHAND;
2223 /* PCI config space poking. */
2225 asmlinkage int sys32_pciconfig_read(u32 bus, u32 dfn, u32 off, u32 len, u32 ubuf)
2227 return sys_pciconfig_read((unsigned long) bus,
2228 (unsigned long) dfn,
2229 (unsigned long) off,
2230 (unsigned long) len,
2231 (unsigned char *)AA(ubuf));
2234 asmlinkage int sys32_pciconfig_write(u32 bus, u32 dfn, u32 off, u32 len, u32 ubuf)
2236 return sys_pciconfig_write((unsigned long) bus,
2237 (unsigned long) dfn,
2238 (unsigned long) off,
2239 (unsigned long) len,
2240 (unsigned char *)AA(ubuf));
2243 asmlinkage int sys32_prctl(int option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
2245 return sys_prctl(option,
2246 (unsigned long) arg2,
2247 (unsigned long) arg3,
2248 (unsigned long) arg4,
2249 (unsigned long) arg5);
2253 asmlinkage compat_ssize_t sys32_pread64(unsigned int fd, char *ubuf,
2254 compat_size_t count, u32 poshi, u32 poslo)
2256 return sys_pread64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
2259 asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd, char *ubuf,
2260 compat_size_t count, u32 poshi, u32 poslo)
2262 return sys_pwrite64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
2265 asmlinkage compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 count)
2267 return sys_readahead(fd, ((loff_t)AA(offhi) << 32) | AA(offlo), count);
2270 long sys32_fadvise64(int fd, u32 offhi, u32 offlo, s32 len, int advice)
2272 return sys_fadvise64_64(fd, ((loff_t)AA(offhi)<<32)|AA(offlo), len, advice);
2275 long sys32_fadvise64_64(int fd, u32 offhi, u32 offlo, u32 lenhi, u32 lenlo, int advice)
2277 return sys_fadvise64_64(fd, ((loff_t)AA(offhi)<<32)|AA(offlo),
2278 ((loff_t)AA(lenhi)<<32)|AA(lenlo), advice);
2281 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t *offset, s32 count)
2283 mm_segment_t old_fs = get_fs();
2287 if (offset && get_user(of, offset))
2291 ret = sys_sendfile(out_fd, in_fd, offset ? &of : NULL, count);
2294 if (offset && put_user(of, offset))
2300 asmlinkage int sys32_sendfile64(int out_fd, int in_fd, compat_loff_t *offset, s32 count)
2302 mm_segment_t old_fs = get_fs();
2306 if (offset && get_user(lof, offset))
2310 ret = sys_sendfile64(out_fd, in_fd, offset ? &lof : NULL, count);
2313 if (offset && put_user(lof, offset))
2319 /* Handle adjtimex compatibility. */
2323 s32 offset, freq, maxerror, esterror;
2324 s32 status, constant, precision, tolerance;
2325 struct compat_timeval time;
2327 s32 ppsfreq, jitter, shift, stabil;
2328 s32 jitcnt, calcnt, errcnt, stbcnt;
2329 s32 :32; s32 :32; s32 :32; s32 :32;
2330 s32 :32; s32 :32; s32 :32; s32 :32;
2331 s32 :32; s32 :32; s32 :32; s32 :32;
2334 extern int do_adjtimex(struct timex *);
2336 asmlinkage int sys32_adjtimex(struct timex32 *utp)
2341 memset(&txc, 0, sizeof(struct timex));
2343 if(get_user(txc.modes, &utp->modes) ||
2344 __get_user(txc.offset, &utp->offset) ||
2345 __get_user(txc.freq, &utp->freq) ||
2346 __get_user(txc.maxerror, &utp->maxerror) ||
2347 __get_user(txc.esterror, &utp->esterror) ||
2348 __get_user(txc.status, &utp->status) ||
2349 __get_user(txc.constant, &utp->constant) ||
2350 __get_user(txc.precision, &utp->precision) ||
2351 __get_user(txc.tolerance, &utp->tolerance) ||
2352 __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2353 __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2354 __get_user(txc.tick, &utp->tick) ||
2355 __get_user(txc.ppsfreq, &utp->ppsfreq) ||
2356 __get_user(txc.jitter, &utp->jitter) ||
2357 __get_user(txc.shift, &utp->shift) ||
2358 __get_user(txc.stabil, &utp->stabil) ||
2359 __get_user(txc.jitcnt, &utp->jitcnt) ||
2360 __get_user(txc.calcnt, &utp->calcnt) ||
2361 __get_user(txc.errcnt, &utp->errcnt) ||
2362 __get_user(txc.stbcnt, &utp->stbcnt))
2365 ret = do_adjtimex(&txc);
2367 if(put_user(txc.modes, &utp->modes) ||
2368 __put_user(txc.offset, &utp->offset) ||
2369 __put_user(txc.freq, &utp->freq) ||
2370 __put_user(txc.maxerror, &utp->maxerror) ||
2371 __put_user(txc.esterror, &utp->esterror) ||
2372 __put_user(txc.status, &utp->status) ||
2373 __put_user(txc.constant, &utp->constant) ||
2374 __put_user(txc.precision, &utp->precision) ||
2375 __put_user(txc.tolerance, &utp->tolerance) ||
2376 __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2377 __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2378 __put_user(txc.tick, &utp->tick) ||
2379 __put_user(txc.ppsfreq, &utp->ppsfreq) ||
2380 __put_user(txc.jitter, &utp->jitter) ||
2381 __put_user(txc.shift, &utp->shift) ||
2382 __put_user(txc.stabil, &utp->stabil) ||
2383 __put_user(txc.jitcnt, &utp->jitcnt) ||
2384 __put_user(txc.calcnt, &utp->calcnt) ||
2385 __put_user(txc.errcnt, &utp->errcnt) ||
2386 __put_user(txc.stbcnt, &utp->stbcnt))
2392 /* This is just a version for 32-bit applications which does
2393 * not force O_LARGEFILE on.
2396 asmlinkage long sparc32_open(const char * filename, int flags, int mode)
2401 tmp = getname(filename);
2404 fd = get_unused_fd();
2406 struct file * f = filp_open(tmp, flags, mode);
2423 extern unsigned long do_mremap(unsigned long addr,
2424 unsigned long old_len, unsigned long new_len,
2425 unsigned long flags, unsigned long new_addr);
2427 asmlinkage unsigned long sys32_mremap(unsigned long addr,
2428 unsigned long old_len, unsigned long new_len,
2429 unsigned long flags, u32 __new_addr)
2431 struct vm_area_struct *vma;
2432 unsigned long ret = -EINVAL;
2433 unsigned long new_addr = AA(__new_addr);
2435 if (old_len > 0xf0000000UL || new_len > 0xf0000000UL)
2437 if (addr > 0xf0000000UL - old_len)
2439 down_write(¤t->mm->mmap_sem);
2440 if (flags & MREMAP_FIXED) {
2441 if (new_addr > 0xf0000000UL - new_len)
2443 } else if (addr > 0xf0000000UL - new_len) {
2444 unsigned long map_flags = 0;
2445 struct file *file = NULL;
2448 if (!(flags & MREMAP_MAYMOVE))
2451 vma = find_vma(current->mm, addr);
2453 if (vma->vm_flags & VM_SHARED)
2454 map_flags |= MAP_SHARED;
2455 file = vma->vm_file;
2458 /* MREMAP_FIXED checked above. */
2459 new_addr = get_unmapped_area(file, addr, new_len,
2460 vma ? vma->vm_pgoff : 0,
2463 if (new_addr & ~PAGE_MASK)
2465 flags |= MREMAP_FIXED;
2467 ret = do_mremap(addr, old_len, new_len, flags, new_addr);
2469 up_write(¤t->mm->mmap_sem);
2474 asmlinkage int sys_setpriority32(u32 which, u32 who, u32 niceval)
2476 return sys_setpriority((int) which,
2481 struct __sysctl_args32 {
2491 asmlinkage long sys32_sysctl(struct __sysctl_args32 *args)
2493 #ifndef CONFIG_SYSCTL
2496 struct __sysctl_args32 tmp;
2498 size_t oldlen, *oldlenp = NULL;
2499 unsigned long addr = (((long)&args->__unused[0]) + 7) & ~7;
2501 if (copy_from_user(&tmp, args, sizeof(tmp)))
2504 if (tmp.oldval && tmp.oldlenp) {
2505 /* Duh, this is ugly and might not work if sysctl_args
2506 is in read-only memory, but do_sysctl does indirectly
2507 a lot of uaccess in both directions and we'd have to
2508 basically copy the whole sysctl.c here, and
2509 glibc's __sysctl uses rw memory for the structure
2511 if (get_user(oldlen, (u32 *)A(tmp.oldlenp)) ||
2512 put_user(oldlen, (size_t *)addr))
2514 oldlenp = (size_t *)addr;
2518 error = do_sysctl((int *)A(tmp.name), tmp.nlen, (void *)A(tmp.oldval),
2519 oldlenp, (void *)A(tmp.newval), tmp.newlen);
2523 if (get_user(oldlen, (size_t *)addr) ||
2524 put_user(oldlen, (u32 *)A(tmp.oldlenp)))
2527 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
2533 long sys32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char *buf, size_t len)
2535 return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
2539 extern asmlinkage long
2540 sys_timer_create(clockid_t which_clock, struct sigevent *timer_event_spec,
2541 timer_t * created_timer_id);
2544 sys32_timer_create(u32 clock, struct sigevent32 *se32, timer_t *timer_id)
2552 return sys_timer_create(clock, NULL, timer_id);
2554 memset(&se, 0, sizeof(struct sigevent));
2555 if (get_user(se.sigev_value.sival_int, &se32->sigev_value.sival_int) ||
2556 __get_user(se.sigev_signo, &se32->sigev_signo) ||
2557 __get_user(se.sigev_notify, &se32->sigev_notify) ||
2558 __copy_from_user(&se._sigev_un._pad, &se32->_sigev_un._pad,
2559 sizeof(se._sigev_un._pad)))
2562 if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
2567 err = sys_timer_create(clock, &se, &t);
2571 err = __put_user (t, timer_id);