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 compat_sigevent __user
*se32
,
1091 timer_t __user
*timer_id
)
1099 return sys_timer_create(clock
, NULL
, timer_id
);
1101 if (get_compat_sigevent(&se
, se32
))
1104 if (!access_ok(VERIFY_WRITE
,timer_id
,sizeof(timer_t
)))
1109 err
= sys_timer_create(clock
,
1110 (struct sigevent __user
*) &se
,
1111 (timer_t __user
*) &t
);
1115 err
= __put_user (t
, timer_id
);