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 asmlinkage long sys32_chown16(const char __user * filename, u16 user, u16 group)
67 return sys_chown(filename, low2highuid(user), low2highgid(group));
70 asmlinkage long sys32_lchown16(const char __user * filename, u16 user, u16 group)
72 return sys_lchown(filename, low2highuid(user), low2highgid(group));
75 asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group)
77 return sys_fchown(fd, low2highuid(user), low2highgid(group));
80 asmlinkage long sys32_setregid16(u16 rgid, u16 egid)
82 return sys_setregid(low2highgid(rgid), low2highgid(egid));
85 asmlinkage long sys32_setgid16(u16 gid)
87 return sys_setgid((gid_t)gid);
90 asmlinkage long sys32_setreuid16(u16 ruid, u16 euid)
92 return sys_setreuid(low2highuid(ruid), low2highuid(euid));
95 asmlinkage long sys32_setuid16(u16 uid)
97 return sys_setuid((uid_t)uid);
100 asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
102 return sys_setresuid(low2highuid(ruid), low2highuid(euid),
106 asmlinkage long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid)
110 if (!(retval = put_user(high2lowuid(current->uid), ruid)) &&
111 !(retval = put_user(high2lowuid(current->euid), euid)))
112 retval = put_user(high2lowuid(current->suid), suid);
117 asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
119 return sys_setresgid(low2highgid(rgid), low2highgid(egid),
123 asmlinkage long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
127 if (!(retval = put_user(high2lowgid(current->gid), rgid)) &&
128 !(retval = put_user(high2lowgid(current->egid), egid)))
129 retval = put_user(high2lowgid(current->sgid), sgid);
134 asmlinkage long sys32_setfsuid16(u16 uid)
136 return sys_setfsuid((uid_t)uid);
139 asmlinkage long sys32_setfsgid16(u16 gid)
141 return sys_setfsgid((gid_t)gid);
144 static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info)
149 for (i = 0; i < group_info->ngroups; i++) {
150 group = (u16)GROUP_AT(group_info, i);
151 if (put_user(group, grouplist+i))
158 static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist)
163 for (i = 0; i < group_info->ngroups; i++) {
164 if (get_user(group, grouplist+i))
166 GROUP_AT(group_info, i) = (gid_t)group;
172 asmlinkage long sys32_getgroups16(int gidsetsize, u16 __user *grouplist)
179 get_group_info(current->group_info);
180 i = current->group_info->ngroups;
182 if (i > gidsetsize) {
186 if (groups16_to_user(grouplist, current->group_info)) {
192 put_group_info(current->group_info);
196 asmlinkage long sys32_setgroups16(int gidsetsize, u16 __user *grouplist)
198 struct group_info *group_info;
201 if (!capable(CAP_SETGID))
203 if ((unsigned)gidsetsize > NGROUPS_MAX)
206 group_info = groups_alloc(gidsetsize);
209 retval = groups16_from_user(group_info, grouplist);
211 put_group_info(group_info);
215 retval = set_current_groups(group_info);
216 put_group_info(group_info);
221 asmlinkage long sys32_getuid16(void)
223 return high2lowuid(current->uid);
226 asmlinkage long sys32_geteuid16(void)
228 return high2lowuid(current->euid);
231 asmlinkage long sys32_getgid16(void)
233 return high2lowgid(current->gid);
236 asmlinkage long sys32_getegid16(void)
238 return high2lowgid(current->egid);
241 /* 32-bit timeval and related flotsam. */
243 static long get_tv32(struct timeval *o, struct compat_timeval __user *i)
245 return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
246 (__get_user(o->tv_sec, &i->tv_sec) |
247 __get_user(o->tv_usec, &i->tv_usec)));
250 static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
252 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
253 (__put_user(i->tv_sec, &o->tv_sec) |
254 __put_user(i->tv_usec, &o->tv_usec)));
257 #ifdef CONFIG_SYSVIPC
258 asmlinkage long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr, u32 fifth)
262 version = call >> 16; /* hack for backward compatibility */
268 /* sign extend semid */
269 return compat_sys_semtimedop((int)first,
270 compat_ptr(ptr), second,
272 /* else fall through for normal semop() */
274 /* struct sembuf is the same on 32 and 64bit :)) */
275 /* sign extend semid */
276 return sys_semtimedop((int)first, compat_ptr(ptr), second,
279 /* sign extend key, nsems */
280 return sys_semget((int)first, (int)second, third);
282 /* sign extend semid, semnum */
283 return compat_sys_semctl((int)first, (int)second, third,
287 /* sign extend msqid */
288 return compat_sys_msgsnd((int)first, (int)second, third,
291 /* sign extend msqid, msgtyp */
292 return compat_sys_msgrcv((int)first, second, (int)fifth,
293 third, version, compat_ptr(ptr));
295 /* sign extend key */
296 return sys_msgget((int)first, second);
298 /* sign extend msqid */
299 return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
302 /* sign extend shmid */
303 return compat_sys_shmat((int)first, second, third, version,
306 return sys_shmdt(compat_ptr(ptr));
308 /* sign extend key_t */
309 return sys_shmget((int)first, second, third);
311 /* sign extend shmid */
312 return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
322 asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
327 return sys_truncate(path, (high << 32) | low);
330 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
335 return sys_ftruncate(fd, (high << 32) | low);
338 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
342 if (stat->size > MAX_NON_LFS || !old_valid_dev(stat->dev) ||
343 !old_valid_dev(stat->rdev))
346 err = put_user(old_encode_dev(stat->dev), &statbuf->st_dev);
347 err |= put_user(stat->ino, &statbuf->st_ino);
348 err |= put_user(stat->mode, &statbuf->st_mode);
349 err |= put_user(stat->nlink, &statbuf->st_nlink);
350 err |= put_user(high2lowuid(stat->uid), &statbuf->st_uid);
351 err |= put_user(high2lowgid(stat->gid), &statbuf->st_gid);
352 err |= put_user(old_encode_dev(stat->rdev), &statbuf->st_rdev);
353 err |= put_user(stat->size, &statbuf->st_size);
354 err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
355 err |= put_user(0, &statbuf->__unused1);
356 err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
357 err |= put_user(0, &statbuf->__unused2);
358 err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
359 err |= put_user(0, &statbuf->__unused3);
360 err |= put_user(stat->blksize, &statbuf->st_blksize);
361 err |= put_user(stat->blocks, &statbuf->st_blocks);
362 err |= put_user(0, &statbuf->__unused4[0]);
363 err |= put_user(0, &statbuf->__unused4[1]);
368 asmlinkage long compat_sys_sysfs(int option, u32 arg1, u32 arg2)
370 return sys_sysfs(option, arg1, arg2);
382 unsigned short procs;
387 char _f[20-2*sizeof(int)-sizeof(int)];
390 asmlinkage long sys32_sysinfo(struct sysinfo32 __user *info)
395 mm_segment_t old_fs = get_fs ();
398 ret = sys_sysinfo((struct sysinfo __user *) &s);
400 /* Check to see if any memory value is too large for 32-bit and
401 * scale down if needed.
403 if ((s.totalram >> 32) || (s.totalswap >> 32)) {
404 while (s.mem_unit < PAGE_SIZE) {
408 s.totalram >>= bitcount;
409 s.freeram >>= bitcount;
410 s.sharedram >>= bitcount;
411 s.bufferram >>= bitcount;
412 s.totalswap >>= bitcount;
413 s.freeswap >>= bitcount;
414 s.totalhigh >>= bitcount;
415 s.freehigh >>= bitcount;
418 err = put_user (s.uptime, &info->uptime);
419 err |= __put_user (s.loads[0], &info->loads[0]);
420 err |= __put_user (s.loads[1], &info->loads[1]);
421 err |= __put_user (s.loads[2], &info->loads[2]);
422 err |= __put_user (s.totalram, &info->totalram);
423 err |= __put_user (s.freeram, &info->freeram);
424 err |= __put_user (s.sharedram, &info->sharedram);
425 err |= __put_user (s.bufferram, &info->bufferram);
426 err |= __put_user (s.totalswap, &info->totalswap);
427 err |= __put_user (s.freeswap, &info->freeswap);
428 err |= __put_user (s.procs, &info->procs);
429 err |= __put_user (s.totalhigh, &info->totalhigh);
430 err |= __put_user (s.freehigh, &info->freehigh);
431 err |= __put_user (s.mem_unit, &info->mem_unit);
437 asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid, struct compat_timespec __user *interval)
441 mm_segment_t old_fs = get_fs ();
444 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
446 if (put_compat_timespec(&t, interval))
451 asmlinkage long compat_sys_rt_sigprocmask(int how,
452 compat_sigset_t __user *set,
453 compat_sigset_t __user *oset,
454 compat_size_t sigsetsize)
459 mm_segment_t old_fs = get_fs();
462 if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
464 switch (_NSIG_WORDS) {
465 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
466 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
467 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
468 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
472 ret = sys_rt_sigprocmask(how,
473 set ? (sigset_t __user *) &s : NULL,
474 oset ? (sigset_t __user *) &s : NULL,
479 switch (_NSIG_WORDS) {
480 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
481 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
482 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
483 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
485 if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
491 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
492 compat_size_t sigsetsize)
497 mm_segment_t old_fs = get_fs();
500 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
503 switch (_NSIG_WORDS) {
504 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
505 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
506 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
507 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
509 if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
515 asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig,
516 struct compat_siginfo __user *uinfo)
520 mm_segment_t old_fs = get_fs();
522 if (copy_siginfo_from_user32(&info, uinfo))
526 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
531 asmlinkage long compat_sys_sigaction(int sig, struct old_sigaction32 __user *act,
532 struct old_sigaction32 __user *oact)
534 struct k_sigaction new_ka, old_ka;
538 set_thread_flag(TIF_NEWSIGNALS);
543 compat_old_sigset_t mask;
544 u32 u_handler, u_restorer;
546 ret = get_user(u_handler, &act->sa_handler);
547 new_ka.sa.sa_handler = compat_ptr(u_handler);
548 ret |= __get_user(u_restorer, &act->sa_restorer);
549 new_ka.sa.sa_restorer = compat_ptr(u_restorer);
550 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
551 ret |= __get_user(mask, &act->sa_mask);
554 new_ka.ka_restorer = NULL;
555 siginitset(&new_ka.sa.sa_mask, mask);
558 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
561 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
562 ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
563 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
564 ret |= __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
570 asmlinkage long compat_sys_rt_sigaction(int sig,
571 struct sigaction32 __user *act,
572 struct sigaction32 __user *oact,
573 void __user *restorer,
574 compat_size_t sigsetsize)
576 struct k_sigaction new_ka, old_ka;
578 compat_sigset_t set32;
580 /* XXX: Don't preclude handling different sized sigset_t's. */
581 if (sigsetsize != sizeof(compat_sigset_t))
584 /* All tasks which use RT signals (effectively) use
587 set_thread_flag(TIF_NEWSIGNALS);
590 u32 u_handler, u_restorer;
592 new_ka.ka_restorer = restorer;
593 ret = get_user(u_handler, &act->sa_handler);
594 new_ka.sa.sa_handler = compat_ptr(u_handler);
595 ret |= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
596 switch (_NSIG_WORDS) {
597 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] | (((long)set32.sig[7]) << 32);
598 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] | (((long)set32.sig[5]) << 32);
599 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] | (((long)set32.sig[3]) << 32);
600 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] | (((long)set32.sig[1]) << 32);
602 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
603 ret |= __get_user(u_restorer, &act->sa_restorer);
604 new_ka.sa.sa_restorer = compat_ptr(u_restorer);
609 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
612 switch (_NSIG_WORDS) {
613 case 4: set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); set32.sig[6] = old_ka.sa.sa_mask.sig[3];
614 case 3: set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); set32.sig[4] = old_ka.sa.sa_mask.sig[2];
615 case 2: set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); set32.sig[2] = old_ka.sa.sa_mask.sig[1];
616 case 1: set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); set32.sig[0] = old_ka.sa.sa_mask.sig[0];
618 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
619 ret |= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
620 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
621 ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
630 * sparc32_execve() executes a new program after the asm stub has set
631 * things up for us. This should basically do what I want it to.
633 asmlinkage long sparc32_execve(struct pt_regs *regs)
638 /* User register window flush is done by entry.S */
640 /* Check for indirect call. */
641 if ((u32)regs->u_regs[UREG_G1] == 0)
644 filename = getname(compat_ptr(regs->u_regs[base + UREG_I0]));
645 error = PTR_ERR(filename);
646 if (IS_ERR(filename))
649 error = compat_do_execve(filename,
650 compat_ptr(regs->u_regs[base + UREG_I1]),
651 compat_ptr(regs->u_regs[base + UREG_I2]), regs);
657 current_thread_info()->xfsr[0] = 0;
658 current_thread_info()->fpsaved[0] = 0;
659 regs->tstate &= ~TSTATE_PEF;
661 current->ptrace &= ~PT_DTRACE;
662 task_unlock(current);
668 #ifdef CONFIG_MODULES
670 asmlinkage long sys32_init_module(void __user *umod, u32 len,
671 const char __user *uargs)
673 return sys_init_module(umod, len, uargs);
676 asmlinkage long sys32_delete_module(const char __user *name_user,
679 return sys_delete_module(name_user, flags);
682 #else /* CONFIG_MODULES */
684 asmlinkage long sys32_init_module(const char __user *name_user,
685 struct module __user *mod_user)
690 asmlinkage long sys32_delete_module(const char __user *name_user)
695 #endif /* CONFIG_MODULES */
697 /* Translations due to time_t size differences. Which affects all
698 sorts of things, like timeval and itimerval. */
700 extern struct timezone sys_tz;
702 asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv,
703 struct timezone __user *tz)
707 do_gettimeofday(&ktv);
708 if (put_tv32(tv, &ktv))
712 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
718 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
722 if (!access_ok(VERIFY_READ, i, sizeof(*i)))
724 if (__get_user(o->tv_sec, &i->tv_sec))
726 if (__get_user(usec, &i->tv_usec))
728 o->tv_nsec = usec * 1000;
732 asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv,
733 struct timezone __user *tz)
739 if (get_ts32(&kts, tv))
743 if (copy_from_user(&ktz, tz, sizeof(ktz)))
747 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
750 asmlinkage long sys32_utimes(char __user *filename,
751 struct compat_timeval __user *tvs)
753 struct timeval ktvs[2];
756 if (get_tv32(&ktvs[0], tvs) ||
757 get_tv32(&ktvs[1], 1+tvs))
761 return do_utimes(filename, (tvs ? &ktvs[0] : NULL));
764 /* These are here just in case some old sparc32 binary calls it. */
765 asmlinkage long sys32_pause(void)
767 current->state = TASK_INTERRUPTIBLE;
769 return -ERESTARTNOHAND;
772 asmlinkage compat_ssize_t sys32_pread64(unsigned int fd,
778 return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo);
781 asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd,
787 return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo);
790 asmlinkage long compat_sys_readahead(int fd,
795 return sys_readahead(fd, (offhi << 32) | offlo, count);
798 long compat_sys_fadvise64(int fd,
801 compat_size_t len, int advice)
803 return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice);
806 long compat_sys_fadvise64_64(int fd,
807 unsigned long offhi, unsigned long offlo,
808 unsigned long lenhi, unsigned long lenlo,
811 return sys_fadvise64_64(fd,
812 (offhi << 32) | offlo,
813 (lenhi << 32) | lenlo,
817 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
818 compat_off_t __user *offset,
821 mm_segment_t old_fs = get_fs();
825 if (offset && get_user(of, offset))
829 ret = sys_sendfile(out_fd, in_fd,
830 offset ? (off_t __user *) &of : NULL,
834 if (offset && put_user(of, offset))
840 asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
841 compat_loff_t __user *offset,
844 mm_segment_t old_fs = get_fs();
848 if (offset && get_user(lof, offset))
852 ret = sys_sendfile64(out_fd, in_fd,
853 offset ? (loff_t __user *) &lof : NULL,
857 if (offset && put_user(lof, offset))
863 /* Handle adjtimex compatibility. */
867 s32 offset, freq, maxerror, esterror;
868 s32 status, constant, precision, tolerance;
869 struct compat_timeval time;
871 s32 ppsfreq, jitter, shift, stabil;
872 s32 jitcnt, calcnt, errcnt, stbcnt;
873 s32 :32; s32 :32; s32 :32; s32 :32;
874 s32 :32; s32 :32; s32 :32; s32 :32;
875 s32 :32; s32 :32; s32 :32; s32 :32;
878 extern int do_adjtimex(struct timex *);
880 asmlinkage long sys32_adjtimex(struct timex32 __user *utp)
885 memset(&txc, 0, sizeof(struct timex));
887 if (get_user(txc.modes, &utp->modes) ||
888 __get_user(txc.offset, &utp->offset) ||
889 __get_user(txc.freq, &utp->freq) ||
890 __get_user(txc.maxerror, &utp->maxerror) ||
891 __get_user(txc.esterror, &utp->esterror) ||
892 __get_user(txc.status, &utp->status) ||
893 __get_user(txc.constant, &utp->constant) ||
894 __get_user(txc.precision, &utp->precision) ||
895 __get_user(txc.tolerance, &utp->tolerance) ||
896 __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
897 __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
898 __get_user(txc.tick, &utp->tick) ||
899 __get_user(txc.ppsfreq, &utp->ppsfreq) ||
900 __get_user(txc.jitter, &utp->jitter) ||
901 __get_user(txc.shift, &utp->shift) ||
902 __get_user(txc.stabil, &utp->stabil) ||
903 __get_user(txc.jitcnt, &utp->jitcnt) ||
904 __get_user(txc.calcnt, &utp->calcnt) ||
905 __get_user(txc.errcnt, &utp->errcnt) ||
906 __get_user(txc.stbcnt, &utp->stbcnt))
909 ret = do_adjtimex(&txc);
911 if (put_user(txc.modes, &utp->modes) ||
912 __put_user(txc.offset, &utp->offset) ||
913 __put_user(txc.freq, &utp->freq) ||
914 __put_user(txc.maxerror, &utp->maxerror) ||
915 __put_user(txc.esterror, &utp->esterror) ||
916 __put_user(txc.status, &utp->status) ||
917 __put_user(txc.constant, &utp->constant) ||
918 __put_user(txc.precision, &utp->precision) ||
919 __put_user(txc.tolerance, &utp->tolerance) ||
920 __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
921 __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
922 __put_user(txc.tick, &utp->tick) ||
923 __put_user(txc.ppsfreq, &utp->ppsfreq) ||
924 __put_user(txc.jitter, &utp->jitter) ||
925 __put_user(txc.shift, &utp->shift) ||
926 __put_user(txc.stabil, &utp->stabil) ||
927 __put_user(txc.jitcnt, &utp->jitcnt) ||
928 __put_user(txc.calcnt, &utp->calcnt) ||
929 __put_user(txc.errcnt, &utp->errcnt) ||
930 __put_user(txc.stbcnt, &utp->stbcnt))
936 /* This is just a version for 32-bit applications which does
937 * not force O_LARGEFILE on.
940 asmlinkage long sparc32_open(const char __user *filename,
946 tmp = getname(filename);
949 fd = get_unused_fd();
951 struct file * f = filp_open(tmp, flags, mode);
968 extern unsigned long do_mremap(unsigned long addr,
969 unsigned long old_len, unsigned long new_len,
970 unsigned long flags, unsigned long new_addr);
972 asmlinkage unsigned long sys32_mremap(unsigned long addr,
973 unsigned long old_len, unsigned long new_len,
974 unsigned long flags, u32 __new_addr)
976 struct vm_area_struct *vma;
977 unsigned long ret = -EINVAL;
978 unsigned long new_addr = __new_addr;
980 if (old_len > 0xf0000000UL || new_len > 0xf0000000UL)
982 if (addr > 0xf0000000UL - old_len)
984 down_write(¤t->mm->mmap_sem);
985 if (flags & MREMAP_FIXED) {
986 if (new_addr > 0xf0000000UL - new_len)
988 } else if (addr > 0xf0000000UL - new_len) {
989 unsigned long map_flags = 0;
990 struct file *file = NULL;
993 if (!(flags & MREMAP_MAYMOVE))
996 vma = find_vma(current->mm, addr);
998 if (vma->vm_flags & VM_SHARED)
999 map_flags |= MAP_SHARED;
1000 file = vma->vm_file;
1003 /* MREMAP_FIXED checked above. */
1004 new_addr = get_unmapped_area(file, addr, new_len,
1005 vma ? vma->vm_pgoff : 0,
1008 if (new_addr & ~PAGE_MASK)
1010 flags |= MREMAP_FIXED;
1012 ret = do_mremap(addr, old_len, new_len, flags, new_addr);
1014 up_write(¤t->mm->mmap_sem);
1019 struct __sysctl_args32 {
1029 asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
1031 #ifndef CONFIG_SYSCTL
1034 struct __sysctl_args32 tmp;
1036 size_t oldlen, __user *oldlenp = NULL;
1037 unsigned long addr = (((unsigned long)&args->__unused[0]) + 7UL) & ~7UL;
1039 if (copy_from_user(&tmp, args, sizeof(tmp)))
1042 if (tmp.oldval && tmp.oldlenp) {
1043 /* Duh, this is ugly and might not work if sysctl_args
1044 is in read-only memory, but do_sysctl does indirectly
1045 a lot of uaccess in both directions and we'd have to
1046 basically copy the whole sysctl.c here, and
1047 glibc's __sysctl uses rw memory for the structure
1049 if (get_user(oldlen, (u32 __user *)(unsigned long)tmp.oldlenp) ||
1050 put_user(oldlen, (size_t __user *)addr))
1052 oldlenp = (size_t __user *)addr;
1056 error = do_sysctl((int __user *)(unsigned long) tmp.name,
1058 (void __user *)(unsigned long) tmp.oldval,
1060 (void __user *)(unsigned long) tmp.newval,
1065 if (get_user(oldlen, (size_t __user *)addr) ||
1066 put_user(oldlen, (u32 __user *)(unsigned long) tmp.oldlenp))
1069 if (copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)))
1076 long sys32_lookup_dcookie(unsigned long cookie_high,
1077 unsigned long cookie_low,
1078 char __user *buf, size_t len)
1080 return sys_lookup_dcookie((cookie_high << 32) | cookie_low,
1084 extern asmlinkage long
1085 sys_timer_create(clockid_t which_clock,
1086 struct sigevent __user *timer_event_spec,
1087 timer_t __user *created_timer_id);
1090 sys32_timer_create(u32 clock, struct sigevent32 __user *se32,
1091 timer_t __user *timer_id)
1099 return sys_timer_create(clock, NULL, timer_id);
1101 memset(&se, 0, sizeof(struct sigevent));
1102 if (get_user(se.sigev_value.sival_int, &se32->sigev_value.sival_int) ||
1103 __get_user(se.sigev_signo, &se32->sigev_signo) ||
1104 __get_user(se.sigev_notify, &se32->sigev_notify) ||
1105 __copy_from_user(&se._sigev_un._pad, &se32->_sigev_un._pad,
1106 sizeof(se._sigev_un._pad)))
1109 if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
1114 err = sys_timer_create(clock,
1115 (struct sigevent __user *) &se,
1116 (timer_t __user *) &t);
1120 err = __put_user (t, timer_id);
1125 asmlinkage long compat_sys_waitid(u32 which, u32 pid,
1126 struct compat_siginfo __user *uinfo,
1127 u32 options, struct compat_rusage __user *uru)
1132 mm_segment_t old_fs = get_fs();
1134 memset(&info, 0, sizeof(info));
1137 ret = sys_waitid(which, pid, (siginfo_t __user *) &info,
1139 uru ? (struct rusage __user *) &ru : NULL);
1142 if (ret < 0 || info.si_signo == 0)
1146 ret = put_compat_rusage(&ru, uru);
1151 BUG_ON(info.si_code & __SI_MASK);
1152 info.si_code |= __SI_CHLD;
1153 return copy_siginfo_to_user32(uinfo, &info);