]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - arch/x86_64/ia32/sys_ia32.c
2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
5 * Copyright (C) 2000 VA Linux Co
6 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
7 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
10 * Copyright (C) 2000 Hewlett-Packard Co.
11 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
12 * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
14 * These routines maintain argument size conversion between 32bit and 64bit
15 * environment. In 2.5 most of this should be moved to a generic directory.
17 * This file assumes that there is a hole at the end of user address space.
19 * Some of the functions are LE specific currently. These are hopefully all marked.
20 * This should be fixed.
23 #include <linux/config.h>
24 #include <linux/kernel.h>
25 #include <linux/sched.h>
27 #include <linux/file.h>
28 #include <linux/signal.h>
29 #include <linux/syscalls.h>
30 #include <linux/resource.h>
31 #include <linux/times.h>
32 #include <linux/utsname.h>
33 #include <linux/timex.h>
34 #include <linux/smp.h>
35 #include <linux/smp_lock.h>
36 #include <linux/sem.h>
37 #include <linux/msg.h>
39 #include <linux/shm.h>
40 #include <linux/slab.h>
41 #include <linux/uio.h>
42 #include <linux/nfs_fs.h>
43 #include <linux/quota.h>
44 #include <linux/module.h>
45 #include <linux/sunrpc/svc.h>
46 #include <linux/nfsd/nfsd.h>
47 #include <linux/nfsd/cache.h>
48 #include <linux/nfsd/xdr.h>
49 #include <linux/nfsd/syscall.h>
50 #include <linux/poll.h>
51 #include <linux/personality.h>
52 #include <linux/stat.h>
53 #include <linux/ipc.h>
54 #include <linux/rwsem.h>
55 #include <linux/binfmts.h>
56 #include <linux/init.h>
57 #include <linux/aio_abi.h>
58 #include <linux/aio.h>
59 #include <linux/compat.h>
60 #include <linux/vfs.h>
61 #include <linux/ptrace.h>
62 #include <linux/highuid.h>
63 #include <linux/vmalloc.h>
64 #include <linux/fsnotify.h>
66 #include <asm/types.h>
67 #include <asm/uaccess.h>
68 #include <asm/semaphore.h>
69 #include <asm/atomic.h>
76 #define AA(__x) ((unsigned long)(__x))
78 int cp_compat_stat(struct kstat
*kbuf
, struct compat_stat __user
*ubuf
)
80 typeof(ubuf
->st_uid
) uid
= 0;
81 typeof(ubuf
->st_gid
) gid
= 0;
82 SET_UID(uid
, kbuf
->uid
);
83 SET_GID(gid
, kbuf
->gid
);
84 if (!old_valid_dev(kbuf
->dev
) || !old_valid_dev(kbuf
->rdev
))
86 if (kbuf
->size
>= 0x7fffffff)
88 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct compat_stat
)) ||
89 __put_user (old_encode_dev(kbuf
->dev
), &ubuf
->st_dev
) ||
90 __put_user (kbuf
->ino
, &ubuf
->st_ino
) ||
91 __put_user (kbuf
->mode
, &ubuf
->st_mode
) ||
92 __put_user (kbuf
->nlink
, &ubuf
->st_nlink
) ||
93 __put_user (uid
, &ubuf
->st_uid
) ||
94 __put_user (gid
, &ubuf
->st_gid
) ||
95 __put_user (old_encode_dev(kbuf
->rdev
), &ubuf
->st_rdev
) ||
96 __put_user (kbuf
->size
, &ubuf
->st_size
) ||
97 __put_user (kbuf
->atime
.tv_sec
, &ubuf
->st_atime
) ||
98 __put_user (kbuf
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
99 __put_user (kbuf
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
100 __put_user (kbuf
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
101 __put_user (kbuf
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
102 __put_user (kbuf
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
103 __put_user (kbuf
->blksize
, &ubuf
->st_blksize
) ||
104 __put_user (kbuf
->blocks
, &ubuf
->st_blocks
))
110 sys32_truncate64(char __user
* filename
, unsigned long offset_low
, unsigned long offset_high
)
112 return sys_truncate(filename
, ((loff_t
) offset_high
<< 32) | offset_low
);
116 sys32_ftruncate64(unsigned int fd
, unsigned long offset_low
, unsigned long offset_high
)
118 return sys_ftruncate(fd
, ((loff_t
) offset_high
<< 32) | offset_low
);
121 /* Another set for IA32/LFS -- x86_64 struct stat is different due to
122 support for 64bit inode numbers. */
125 cp_stat64(struct stat64 __user
*ubuf
, struct kstat
*stat
)
127 typeof(ubuf
->st_uid
) uid
= 0;
128 typeof(ubuf
->st_gid
) gid
= 0;
129 SET_UID(uid
, stat
->uid
);
130 SET_GID(gid
, stat
->gid
);
131 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct stat64
)) ||
132 __put_user(huge_encode_dev(stat
->dev
), &ubuf
->st_dev
) ||
133 __put_user (stat
->ino
, &ubuf
->__st_ino
) ||
134 __put_user (stat
->ino
, &ubuf
->st_ino
) ||
135 __put_user (stat
->mode
, &ubuf
->st_mode
) ||
136 __put_user (stat
->nlink
, &ubuf
->st_nlink
) ||
137 __put_user (uid
, &ubuf
->st_uid
) ||
138 __put_user (gid
, &ubuf
->st_gid
) ||
139 __put_user (huge_encode_dev(stat
->rdev
), &ubuf
->st_rdev
) ||
140 __put_user (stat
->size
, &ubuf
->st_size
) ||
141 __put_user (stat
->atime
.tv_sec
, &ubuf
->st_atime
) ||
142 __put_user (stat
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
143 __put_user (stat
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
144 __put_user (stat
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
145 __put_user (stat
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
146 __put_user (stat
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
147 __put_user (stat
->blksize
, &ubuf
->st_blksize
) ||
148 __put_user (stat
->blocks
, &ubuf
->st_blocks
))
154 sys32_stat64(char __user
* filename
, struct stat64 __user
*statbuf
)
157 int ret
= vfs_stat(filename
, &stat
);
159 ret
= cp_stat64(statbuf
, &stat
);
164 sys32_lstat64(char __user
* filename
, struct stat64 __user
*statbuf
)
167 int ret
= vfs_lstat(filename
, &stat
);
169 ret
= cp_stat64(statbuf
, &stat
);
174 sys32_fstat64(unsigned int fd
, struct stat64 __user
*statbuf
)
177 int ret
= vfs_fstat(fd
, &stat
);
179 ret
= cp_stat64(statbuf
, &stat
);
184 sys32_fstatat(unsigned int dfd
, char __user
*filename
,
185 struct stat64 __user
* statbuf
, int flag
)
190 if ((flag
& ~AT_SYMLINK_NOFOLLOW
) != 0)
193 if (flag
& AT_SYMLINK_NOFOLLOW
)
194 error
= vfs_lstat_fd(dfd
, filename
, &stat
);
196 error
= vfs_stat_fd(dfd
, filename
, &stat
);
199 error
= cp_stat64(statbuf
, &stat
);
206 * Linux/i386 didn't use to be able to handle more than
207 * 4 system call parameters, so these system calls used a memory
208 * block for parameter passing..
211 struct mmap_arg_struct
{
221 sys32_mmap(struct mmap_arg_struct __user
*arg
)
223 struct mmap_arg_struct a
;
224 struct file
*file
= NULL
;
225 unsigned long retval
;
226 struct mm_struct
*mm
;
228 if (copy_from_user(&a
, arg
, sizeof(a
)))
231 if (a
.offset
& ~PAGE_MASK
)
234 if (!(a
.flags
& MAP_ANONYMOUS
)) {
241 down_write(&mm
->mmap_sem
);
242 retval
= do_mmap_pgoff(file
, a
.addr
, a
.len
, a
.prot
, a
.flags
, a
.offset
>>PAGE_SHIFT
);
246 up_write(&mm
->mmap_sem
);
252 sys32_mprotect(unsigned long start
, size_t len
, unsigned long prot
)
254 return sys_mprotect(start
,len
,prot
);
258 sys32_pipe(int __user
*fd
)
263 retval
= do_pipe(fds
);
266 if (copy_to_user(fd
, fds
, sizeof(fds
)))
273 sys32_rt_sigaction(int sig
, struct sigaction32 __user
*act
,
274 struct sigaction32 __user
*oact
, unsigned int sigsetsize
)
276 struct k_sigaction new_ka
, old_ka
;
278 compat_sigset_t set32
;
280 /* XXX: Don't preclude handling different sized sigset_t's. */
281 if (sigsetsize
!= sizeof(compat_sigset_t
))
285 compat_uptr_t handler
, restorer
;
287 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
288 __get_user(handler
, &act
->sa_handler
) ||
289 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
290 __get_user(restorer
, &act
->sa_restorer
)||
291 __copy_from_user(&set32
, &act
->sa_mask
, sizeof(compat_sigset_t
)))
293 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
294 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
295 /* FIXME: here we rely on _COMPAT_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
296 switch (_NSIG_WORDS
) {
297 case 4: new_ka
.sa
.sa_mask
.sig
[3] = set32
.sig
[6]
298 | (((long)set32
.sig
[7]) << 32);
299 case 3: new_ka
.sa
.sa_mask
.sig
[2] = set32
.sig
[4]
300 | (((long)set32
.sig
[5]) << 32);
301 case 2: new_ka
.sa
.sa_mask
.sig
[1] = set32
.sig
[2]
302 | (((long)set32
.sig
[3]) << 32);
303 case 1: new_ka
.sa
.sa_mask
.sig
[0] = set32
.sig
[0]
304 | (((long)set32
.sig
[1]) << 32);
308 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
311 /* FIXME: here we rely on _COMPAT_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
312 switch (_NSIG_WORDS
) {
314 set32
.sig
[7] = (old_ka
.sa
.sa_mask
.sig
[3] >> 32);
315 set32
.sig
[6] = old_ka
.sa
.sa_mask
.sig
[3];
317 set32
.sig
[5] = (old_ka
.sa
.sa_mask
.sig
[2] >> 32);
318 set32
.sig
[4] = old_ka
.sa
.sa_mask
.sig
[2];
320 set32
.sig
[3] = (old_ka
.sa
.sa_mask
.sig
[1] >> 32);
321 set32
.sig
[2] = old_ka
.sa
.sa_mask
.sig
[1];
323 set32
.sig
[1] = (old_ka
.sa
.sa_mask
.sig
[0] >> 32);
324 set32
.sig
[0] = old_ka
.sa
.sa_mask
.sig
[0];
326 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
327 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
) ||
328 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
) ||
329 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
330 __copy_to_user(&oact
->sa_mask
, &set32
, sizeof(compat_sigset_t
)))
338 sys32_sigaction (int sig
, struct old_sigaction32 __user
*act
, struct old_sigaction32 __user
*oact
)
340 struct k_sigaction new_ka
, old_ka
;
344 compat_old_sigset_t mask
;
345 compat_uptr_t handler
, restorer
;
347 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
348 __get_user(handler
, &act
->sa_handler
) ||
349 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
350 __get_user(restorer
, &act
->sa_restorer
) ||
351 __get_user(mask
, &act
->sa_mask
))
354 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
355 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
357 siginitset(&new_ka
.sa
.sa_mask
, mask
);
360 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
363 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
364 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
) ||
365 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
) ||
366 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
367 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
375 sys32_rt_sigprocmask(int how
, compat_sigset_t __user
*set
,
376 compat_sigset_t __user
*oset
, unsigned int sigsetsize
)
381 mm_segment_t old_fs
= get_fs();
384 if (copy_from_user (&s32
, set
, sizeof(compat_sigset_t
)))
386 switch (_NSIG_WORDS
) {
387 case 4: s
.sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
388 case 3: s
.sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
389 case 2: s
.sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
390 case 1: s
.sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
394 ret
= sys_rt_sigprocmask(how
, set
? &s
: NULL
, oset
? &s
: NULL
,
399 switch (_NSIG_WORDS
) {
400 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
401 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
402 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
403 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
405 if (copy_to_user (oset
, &s32
, sizeof(compat_sigset_t
)))
412 get_tv32(struct timeval
*o
, struct compat_timeval __user
*i
)
415 if (access_ok(VERIFY_READ
, i
, sizeof(*i
))) {
416 err
= __get_user(o
->tv_sec
, &i
->tv_sec
);
417 err
|= __get_user(o
->tv_usec
, &i
->tv_usec
);
423 put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
426 if (access_ok(VERIFY_WRITE
, o
, sizeof(*o
))) {
427 err
= __put_user(i
->tv_sec
, &o
->tv_sec
);
428 err
|= __put_user(i
->tv_usec
, &o
->tv_usec
);
433 extern int do_setitimer(int which
, struct itimerval
*, struct itimerval
*);
436 sys32_alarm(unsigned int seconds
)
438 struct itimerval it_new
, it_old
;
439 unsigned int oldalarm
;
441 it_new
.it_interval
.tv_sec
= it_new
.it_interval
.tv_usec
= 0;
442 it_new
.it_value
.tv_sec
= seconds
;
443 it_new
.it_value
.tv_usec
= 0;
444 do_setitimer(ITIMER_REAL
, &it_new
, &it_old
);
445 oldalarm
= it_old
.it_value
.tv_sec
;
446 /* ehhh.. We can't return 0 if we have an alarm pending.. */
447 /* And we'd better return too much than too little anyway */
448 if (it_old
.it_value
.tv_usec
)
453 /* Translations due to time_t size differences. Which affects all
454 sorts of things, like timeval and itimerval. */
456 extern struct timezone sys_tz
;
459 sys32_gettimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
463 do_gettimeofday(&ktv
);
464 if (put_tv32(tv
, &ktv
))
468 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
475 sys32_settimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
482 if (get_tv32(&ktv
, tv
))
484 kts
.tv_sec
= ktv
.tv_sec
;
485 kts
.tv_nsec
= ktv
.tv_usec
* NSEC_PER_USEC
;
488 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
492 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
495 struct sel_arg_struct
{
504 sys32_old_select(struct sel_arg_struct __user
*arg
)
506 struct sel_arg_struct a
;
508 if (copy_from_user(&a
, arg
, sizeof(a
)))
510 return compat_sys_select(a
.n
, compat_ptr(a
.inp
), compat_ptr(a
.outp
),
511 compat_ptr(a
.exp
), compat_ptr(a
.tvp
));
514 extern asmlinkage
long
515 compat_sys_wait4(compat_pid_t pid
, compat_uint_t
* stat_addr
, int options
,
516 struct compat_rusage
*ru
);
519 sys32_waitpid(compat_pid_t pid
, unsigned int *stat_addr
, int options
)
521 return compat_sys_wait4(pid
, stat_addr
, options
, NULL
);
524 int sys32_ni_syscall(int call
)
526 struct task_struct
*me
= current
;
527 static char lastcomm
[sizeof(me
->comm
)];
529 if (strncmp(lastcomm
, me
->comm
, sizeof(lastcomm
))) {
530 printk(KERN_INFO
"IA32 syscall %d from %s not implemented\n",
532 strncpy(lastcomm
, me
->comm
, sizeof(lastcomm
));
537 /* 32-bit timeval and related flotsam. */
540 sys32_sysfs(int option
, u32 arg1
, u32 arg2
)
542 return sys_sysfs(option
, arg1
, arg2
);
554 unsigned short procs
;
559 char _f
[20-2*sizeof(u32
)-sizeof(int)];
563 sys32_sysinfo(struct sysinfo32 __user
*info
)
567 mm_segment_t old_fs
= get_fs ();
571 ret
= sys_sysinfo(&s
);
574 /* Check to see if any memory value is too large for 32-bit and scale
577 if ((s
.totalram
>> 32) || (s
.totalswap
>> 32)) {
578 while (s
.mem_unit
< PAGE_SIZE
) {
582 s
.totalram
>>= bitcount
;
583 s
.freeram
>>= bitcount
;
584 s
.sharedram
>>= bitcount
;
585 s
.bufferram
>>= bitcount
;
586 s
.totalswap
>>= bitcount
;
587 s
.freeswap
>>= bitcount
;
588 s
.totalhigh
>>= bitcount
;
589 s
.freehigh
>>= bitcount
;
592 if (!access_ok(VERIFY_WRITE
, info
, sizeof(struct sysinfo32
)) ||
593 __put_user (s
.uptime
, &info
->uptime
) ||
594 __put_user (s
.loads
[0], &info
->loads
[0]) ||
595 __put_user (s
.loads
[1], &info
->loads
[1]) ||
596 __put_user (s
.loads
[2], &info
->loads
[2]) ||
597 __put_user (s
.totalram
, &info
->totalram
) ||
598 __put_user (s
.freeram
, &info
->freeram
) ||
599 __put_user (s
.sharedram
, &info
->sharedram
) ||
600 __put_user (s
.bufferram
, &info
->bufferram
) ||
601 __put_user (s
.totalswap
, &info
->totalswap
) ||
602 __put_user (s
.freeswap
, &info
->freeswap
) ||
603 __put_user (s
.procs
, &info
->procs
) ||
604 __put_user (s
.totalhigh
, &info
->totalhigh
) ||
605 __put_user (s
.freehigh
, &info
->freehigh
) ||
606 __put_user (s
.mem_unit
, &info
->mem_unit
))
612 sys32_sched_rr_get_interval(compat_pid_t pid
, struct compat_timespec __user
*interval
)
616 mm_segment_t old_fs
= get_fs ();
619 ret
= sys_sched_rr_get_interval(pid
, &t
);
621 if (put_compat_timespec(&t
, interval
))
627 sys32_rt_sigpending(compat_sigset_t __user
*set
, compat_size_t sigsetsize
)
632 mm_segment_t old_fs
= get_fs();
635 ret
= sys_rt_sigpending(&s
, sigsetsize
);
638 switch (_NSIG_WORDS
) {
639 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
640 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
641 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
642 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
644 if (copy_to_user (set
, &s32
, sizeof(compat_sigset_t
)))
651 sys32_rt_sigqueueinfo(int pid
, int sig
, compat_siginfo_t __user
*uinfo
)
655 mm_segment_t old_fs
= get_fs();
657 if (copy_siginfo_from_user32(&info
, uinfo
))
660 ret
= sys_rt_sigqueueinfo(pid
, sig
, &info
);
665 /* These are here just in case some old ia32 binary calls it. */
669 current
->state
= TASK_INTERRUPTIBLE
;
671 return -ERESTARTNOHAND
;
680 unsigned int oldlenp
;
683 unsigned int __unused
[4];
688 sys32_sysctl(struct sysctl_ia32 __user
*args32
)
690 struct sysctl_ia32 a32
;
691 mm_segment_t old_fs
= get_fs ();
692 void __user
*oldvalp
, *newvalp
;
696 extern int do_sysctl(int *name
, int nlen
, void *oldval
, size_t *oldlenp
,
697 void *newval
, size_t newlen
);
700 if (copy_from_user(&a32
, args32
, sizeof (a32
)))
704 * We need to pre-validate these because we have to disable address checking
705 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
706 * user specifying bad addresses here. Well, since we're dealing with 32 bit
707 * addresses, we KNOW that access_ok() will always succeed, so this is an
708 * expensive NOP, but so what...
710 namep
= compat_ptr(a32
.name
);
711 oldvalp
= compat_ptr(a32
.oldval
);
712 newvalp
= compat_ptr(a32
.newval
);
714 if ((oldvalp
&& get_user(oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
715 || !access_ok(VERIFY_WRITE
, namep
, 0)
716 || !access_ok(VERIFY_WRITE
, oldvalp
, 0)
717 || !access_ok(VERIFY_WRITE
, newvalp
, 0))
722 ret
= do_sysctl(namep
, a32
.nlen
, oldvalp
, &oldlen
, newvalp
, (size_t) a32
.newlen
);
726 if (oldvalp
&& put_user (oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
733 /* warning: next two assume little endian */
735 sys32_pread(unsigned int fd
, char __user
*ubuf
, u32 count
, u32 poslo
, u32 poshi
)
737 return sys_pread64(fd
, ubuf
, count
,
738 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
742 sys32_pwrite(unsigned int fd
, char __user
*ubuf
, u32 count
, u32 poslo
, u32 poshi
)
744 return sys_pwrite64(fd
, ubuf
, count
,
745 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
750 sys32_personality(unsigned long personality
)
753 if (personality(current
->personality
) == PER_LINUX32
&&
754 personality
== PER_LINUX
)
755 personality
= PER_LINUX32
;
756 ret
= sys_personality(personality
);
757 if (ret
== PER_LINUX32
)
763 sys32_sendfile(int out_fd
, int in_fd
, compat_off_t __user
*offset
, s32 count
)
765 mm_segment_t old_fs
= get_fs();
769 if (offset
&& get_user(of
, offset
))
773 ret
= sys_sendfile(out_fd
, in_fd
, offset
? &of
: NULL
, count
);
776 if (offset
&& put_user(of
, offset
))
782 /* Handle adjtimex compatibility. */
786 s32 offset
, freq
, maxerror
, esterror
;
787 s32 status
, constant
, precision
, tolerance
;
788 struct compat_timeval time
;
790 s32 ppsfreq
, jitter
, shift
, stabil
;
791 s32 jitcnt
, calcnt
, errcnt
, stbcnt
;
792 s32
:32; s32
:32; s32
:32; s32
:32;
793 s32
:32; s32
:32; s32
:32; s32
:32;
794 s32
:32; s32
:32; s32
:32; s32
:32;
797 extern int do_adjtimex(struct timex
*);
800 sys32_adjtimex(struct timex32 __user
*utp
)
805 memset(&txc
, 0, sizeof(struct timex
));
807 if (!access_ok(VERIFY_READ
, utp
, sizeof(struct timex32
)) ||
808 __get_user(txc
.modes
, &utp
->modes
) ||
809 __get_user(txc
.offset
, &utp
->offset
) ||
810 __get_user(txc
.freq
, &utp
->freq
) ||
811 __get_user(txc
.maxerror
, &utp
->maxerror
) ||
812 __get_user(txc
.esterror
, &utp
->esterror
) ||
813 __get_user(txc
.status
, &utp
->status
) ||
814 __get_user(txc
.constant
, &utp
->constant
) ||
815 __get_user(txc
.precision
, &utp
->precision
) ||
816 __get_user(txc
.tolerance
, &utp
->tolerance
) ||
817 __get_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
818 __get_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
819 __get_user(txc
.tick
, &utp
->tick
) ||
820 __get_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
821 __get_user(txc
.jitter
, &utp
->jitter
) ||
822 __get_user(txc
.shift
, &utp
->shift
) ||
823 __get_user(txc
.stabil
, &utp
->stabil
) ||
824 __get_user(txc
.jitcnt
, &utp
->jitcnt
) ||
825 __get_user(txc
.calcnt
, &utp
->calcnt
) ||
826 __get_user(txc
.errcnt
, &utp
->errcnt
) ||
827 __get_user(txc
.stbcnt
, &utp
->stbcnt
))
830 ret
= do_adjtimex(&txc
);
832 if (!access_ok(VERIFY_WRITE
, utp
, sizeof(struct timex32
)) ||
833 __put_user(txc
.modes
, &utp
->modes
) ||
834 __put_user(txc
.offset
, &utp
->offset
) ||
835 __put_user(txc
.freq
, &utp
->freq
) ||
836 __put_user(txc
.maxerror
, &utp
->maxerror
) ||
837 __put_user(txc
.esterror
, &utp
->esterror
) ||
838 __put_user(txc
.status
, &utp
->status
) ||
839 __put_user(txc
.constant
, &utp
->constant
) ||
840 __put_user(txc
.precision
, &utp
->precision
) ||
841 __put_user(txc
.tolerance
, &utp
->tolerance
) ||
842 __put_user(txc
.time
.tv_sec
, &utp
->time
.tv_sec
) ||
843 __put_user(txc
.time
.tv_usec
, &utp
->time
.tv_usec
) ||
844 __put_user(txc
.tick
, &utp
->tick
) ||
845 __put_user(txc
.ppsfreq
, &utp
->ppsfreq
) ||
846 __put_user(txc
.jitter
, &utp
->jitter
) ||
847 __put_user(txc
.shift
, &utp
->shift
) ||
848 __put_user(txc
.stabil
, &utp
->stabil
) ||
849 __put_user(txc
.jitcnt
, &utp
->jitcnt
) ||
850 __put_user(txc
.calcnt
, &utp
->calcnt
) ||
851 __put_user(txc
.errcnt
, &utp
->errcnt
) ||
852 __put_user(txc
.stbcnt
, &utp
->stbcnt
))
858 asmlinkage
long sys32_mmap2(unsigned long addr
, unsigned long len
,
859 unsigned long prot
, unsigned long flags
,
860 unsigned long fd
, unsigned long pgoff
)
862 struct mm_struct
*mm
= current
->mm
;
864 struct file
* file
= NULL
;
866 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
867 if (!(flags
& MAP_ANONYMOUS
)) {
873 down_write(&mm
->mmap_sem
);
874 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
875 up_write(&mm
->mmap_sem
);
882 asmlinkage
long sys32_olduname(struct oldold_utsname __user
* name
)
888 if (!access_ok(VERIFY_WRITE
,name
,sizeof(struct oldold_utsname
)))
893 error
= __copy_to_user(&name
->sysname
,&system_utsname
.sysname
,__OLD_UTS_LEN
);
894 __put_user(0,name
->sysname
+__OLD_UTS_LEN
);
895 __copy_to_user(&name
->nodename
,&system_utsname
.nodename
,__OLD_UTS_LEN
);
896 __put_user(0,name
->nodename
+__OLD_UTS_LEN
);
897 __copy_to_user(&name
->release
,&system_utsname
.release
,__OLD_UTS_LEN
);
898 __put_user(0,name
->release
+__OLD_UTS_LEN
);
899 __copy_to_user(&name
->version
,&system_utsname
.version
,__OLD_UTS_LEN
);
900 __put_user(0,name
->version
+__OLD_UTS_LEN
);
902 char *arch
= "x86_64";
903 if (personality(current
->personality
) == PER_LINUX32
)
906 __copy_to_user(&name
->machine
,arch
,strlen(arch
)+1);
911 error
= error
? -EFAULT
: 0;
916 long sys32_uname(struct old_utsname __user
* name
)
922 err
=copy_to_user(name
, &system_utsname
, sizeof (*name
));
924 if (personality(current
->personality
) == PER_LINUX32
)
925 err
|= copy_to_user(&name
->machine
, "i686", 5);
926 return err
?-EFAULT
:0;
929 long sys32_ustat(unsigned dev
, struct ustat32 __user
*u32p
)
937 ret
= sys_ustat(dev
,&u
);
940 if (!access_ok(VERIFY_WRITE
,u32p
,sizeof(struct ustat32
)) ||
941 __put_user((__u32
) u
.f_tfree
, &u32p
->f_tfree
) ||
942 __put_user((__u32
) u
.f_tinode
, &u32p
->f_tfree
) ||
943 __copy_to_user(&u32p
->f_fname
, u
.f_fname
, sizeof(u
.f_fname
)) ||
944 __copy_to_user(&u32p
->f_fpack
, u
.f_fpack
, sizeof(u
.f_fpack
)))
950 asmlinkage
long sys32_execve(char __user
*name
, compat_uptr_t __user
*argv
,
951 compat_uptr_t __user
*envp
, struct pt_regs
*regs
)
956 filename
= getname(name
);
957 error
= PTR_ERR(filename
);
958 if (IS_ERR(filename
))
960 error
= compat_do_execve(filename
, argv
, envp
, regs
);
963 current
->ptrace
&= ~PT_DTRACE
;
964 task_unlock(current
);
970 asmlinkage
long sys32_clone(unsigned int clone_flags
, unsigned int newsp
,
971 struct pt_regs
*regs
)
973 void __user
*parent_tid
= (void __user
*)regs
->rdx
;
974 void __user
*child_tid
= (void __user
*)regs
->rdi
;
977 return do_fork(clone_flags
, newsp
, regs
, 0, parent_tid
, child_tid
);
981 * Some system calls that need sign extended arguments. This could be done by a generic wrapper.
984 long sys32_lseek (unsigned int fd
, int offset
, unsigned int whence
)
986 return sys_lseek(fd
, offset
, whence
);
989 long sys32_kill(int pid
, int sig
)
991 return sys_kill(pid
, sig
);
994 long sys32_fadvise64_64(int fd
, __u32 offset_low
, __u32 offset_high
,
995 __u32 len_low
, __u32 len_high
, int advice
)
997 return sys_fadvise64_64(fd
,
998 (((u64
)offset_high
)<<32) | offset_low
,
999 (((u64
)len_high
)<<32) | len_low
,
1003 long sys32_vm86_warning(void)
1005 struct task_struct
*me
= current
;
1006 static char lastcomm
[sizeof(me
->comm
)];
1007 if (strncmp(lastcomm
, me
->comm
, sizeof(lastcomm
))) {
1008 printk(KERN_INFO
"%s: vm86 mode not supported on 64 bit kernel\n",
1010 strncpy(lastcomm
, me
->comm
, sizeof(lastcomm
));
1015 long sys32_lookup_dcookie(u32 addr_low
, u32 addr_high
,
1016 char __user
* buf
, size_t len
)
1018 return sys_lookup_dcookie(((u64
)addr_high
<< 32) | addr_low
, buf
, len
);
1021 static int __init
ia32_init (void)
1023 printk("IA32 emulation $Id: sys_ia32.c,v 1.32 2002/03/24 13:02:28 ak Exp $\n");
1027 __initcall(ia32_init
);
1029 extern unsigned long ia32_sys_call_table
[];
1030 EXPORT_SYMBOL(ia32_sys_call_table
);