]>
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/smp.h>
34 #include <linux/smp_lock.h>
35 #include <linux/sem.h>
36 #include <linux/msg.h>
38 #include <linux/shm.h>
39 #include <linux/slab.h>
40 #include <linux/uio.h>
41 #include <linux/nfs_fs.h>
42 #include <linux/quota.h>
43 #include <linux/module.h>
44 #include <linux/sunrpc/svc.h>
45 #include <linux/nfsd/nfsd.h>
46 #include <linux/nfsd/cache.h>
47 #include <linux/nfsd/xdr.h>
48 #include <linux/nfsd/syscall.h>
49 #include <linux/poll.h>
50 #include <linux/personality.h>
51 #include <linux/stat.h>
52 #include <linux/ipc.h>
53 #include <linux/rwsem.h>
54 #include <linux/binfmts.h>
55 #include <linux/init.h>
56 #include <linux/aio_abi.h>
57 #include <linux/aio.h>
58 #include <linux/compat.h>
59 #include <linux/vfs.h>
60 #include <linux/ptrace.h>
61 #include <linux/highuid.h>
62 #include <linux/vmalloc.h>
63 #include <linux/fsnotify.h>
65 #include <asm/types.h>
66 #include <asm/uaccess.h>
67 #include <asm/semaphore.h>
68 #include <asm/atomic.h>
75 #define AA(__x) ((unsigned long)(__x))
77 int cp_compat_stat(struct kstat
*kbuf
, struct compat_stat __user
*ubuf
)
79 typeof(ubuf
->st_uid
) uid
= 0;
80 typeof(ubuf
->st_gid
) gid
= 0;
81 SET_UID(uid
, kbuf
->uid
);
82 SET_GID(gid
, kbuf
->gid
);
83 if (!old_valid_dev(kbuf
->dev
) || !old_valid_dev(kbuf
->rdev
))
85 if (kbuf
->size
>= 0x7fffffff)
87 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct compat_stat
)) ||
88 __put_user (old_encode_dev(kbuf
->dev
), &ubuf
->st_dev
) ||
89 __put_user (kbuf
->ino
, &ubuf
->st_ino
) ||
90 __put_user (kbuf
->mode
, &ubuf
->st_mode
) ||
91 __put_user (kbuf
->nlink
, &ubuf
->st_nlink
) ||
92 __put_user (uid
, &ubuf
->st_uid
) ||
93 __put_user (gid
, &ubuf
->st_gid
) ||
94 __put_user (old_encode_dev(kbuf
->rdev
), &ubuf
->st_rdev
) ||
95 __put_user (kbuf
->size
, &ubuf
->st_size
) ||
96 __put_user (kbuf
->atime
.tv_sec
, &ubuf
->st_atime
) ||
97 __put_user (kbuf
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
98 __put_user (kbuf
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
99 __put_user (kbuf
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
100 __put_user (kbuf
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
101 __put_user (kbuf
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
102 __put_user (kbuf
->blksize
, &ubuf
->st_blksize
) ||
103 __put_user (kbuf
->blocks
, &ubuf
->st_blocks
))
109 sys32_truncate64(char __user
* filename
, unsigned long offset_low
, unsigned long offset_high
)
111 return sys_truncate(filename
, ((loff_t
) offset_high
<< 32) | offset_low
);
115 sys32_ftruncate64(unsigned int fd
, unsigned long offset_low
, unsigned long offset_high
)
117 return sys_ftruncate(fd
, ((loff_t
) offset_high
<< 32) | offset_low
);
120 /* Another set for IA32/LFS -- x86_64 struct stat is different due to
121 support for 64bit inode numbers. */
124 cp_stat64(struct stat64 __user
*ubuf
, struct kstat
*stat
)
126 typeof(ubuf
->st_uid
) uid
= 0;
127 typeof(ubuf
->st_gid
) gid
= 0;
128 SET_UID(uid
, stat
->uid
);
129 SET_GID(gid
, stat
->gid
);
130 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct stat64
)) ||
131 __put_user(huge_encode_dev(stat
->dev
), &ubuf
->st_dev
) ||
132 __put_user (stat
->ino
, &ubuf
->__st_ino
) ||
133 __put_user (stat
->ino
, &ubuf
->st_ino
) ||
134 __put_user (stat
->mode
, &ubuf
->st_mode
) ||
135 __put_user (stat
->nlink
, &ubuf
->st_nlink
) ||
136 __put_user (uid
, &ubuf
->st_uid
) ||
137 __put_user (gid
, &ubuf
->st_gid
) ||
138 __put_user (huge_encode_dev(stat
->rdev
), &ubuf
->st_rdev
) ||
139 __put_user (stat
->size
, &ubuf
->st_size
) ||
140 __put_user (stat
->atime
.tv_sec
, &ubuf
->st_atime
) ||
141 __put_user (stat
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
142 __put_user (stat
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
143 __put_user (stat
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
144 __put_user (stat
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
145 __put_user (stat
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
146 __put_user (stat
->blksize
, &ubuf
->st_blksize
) ||
147 __put_user (stat
->blocks
, &ubuf
->st_blocks
))
153 sys32_stat64(char __user
* filename
, struct stat64 __user
*statbuf
)
156 int ret
= vfs_stat(filename
, &stat
);
158 ret
= cp_stat64(statbuf
, &stat
);
163 sys32_lstat64(char __user
* filename
, struct stat64 __user
*statbuf
)
166 int ret
= vfs_lstat(filename
, &stat
);
168 ret
= cp_stat64(statbuf
, &stat
);
173 sys32_fstat64(unsigned int fd
, struct stat64 __user
*statbuf
)
176 int ret
= vfs_fstat(fd
, &stat
);
178 ret
= cp_stat64(statbuf
, &stat
);
183 sys32_fstatat(unsigned int dfd
, char __user
*filename
,
184 struct stat64 __user
* statbuf
, int flag
)
189 if ((flag
& ~AT_SYMLINK_NOFOLLOW
) != 0)
192 if (flag
& AT_SYMLINK_NOFOLLOW
)
193 error
= vfs_lstat_fd(dfd
, filename
, &stat
);
195 error
= vfs_stat_fd(dfd
, filename
, &stat
);
198 error
= cp_stat64(statbuf
, &stat
);
205 * Linux/i386 didn't use to be able to handle more than
206 * 4 system call parameters, so these system calls used a memory
207 * block for parameter passing..
210 struct mmap_arg_struct
{
220 sys32_mmap(struct mmap_arg_struct __user
*arg
)
222 struct mmap_arg_struct a
;
223 struct file
*file
= NULL
;
224 unsigned long retval
;
225 struct mm_struct
*mm
;
227 if (copy_from_user(&a
, arg
, sizeof(a
)))
230 if (a
.offset
& ~PAGE_MASK
)
233 if (!(a
.flags
& MAP_ANONYMOUS
)) {
240 down_write(&mm
->mmap_sem
);
241 retval
= do_mmap_pgoff(file
, a
.addr
, a
.len
, a
.prot
, a
.flags
, a
.offset
>>PAGE_SHIFT
);
245 up_write(&mm
->mmap_sem
);
251 sys32_mprotect(unsigned long start
, size_t len
, unsigned long prot
)
253 return sys_mprotect(start
,len
,prot
);
257 sys32_pipe(int __user
*fd
)
262 retval
= do_pipe(fds
);
265 if (copy_to_user(fd
, fds
, sizeof(fds
)))
272 sys32_rt_sigaction(int sig
, struct sigaction32 __user
*act
,
273 struct sigaction32 __user
*oact
, unsigned int sigsetsize
)
275 struct k_sigaction new_ka
, old_ka
;
277 compat_sigset_t set32
;
279 /* XXX: Don't preclude handling different sized sigset_t's. */
280 if (sigsetsize
!= sizeof(compat_sigset_t
))
284 compat_uptr_t handler
, restorer
;
286 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
287 __get_user(handler
, &act
->sa_handler
) ||
288 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
289 __get_user(restorer
, &act
->sa_restorer
)||
290 __copy_from_user(&set32
, &act
->sa_mask
, sizeof(compat_sigset_t
)))
292 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
293 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
294 /* FIXME: here we rely on _COMPAT_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
295 switch (_NSIG_WORDS
) {
296 case 4: new_ka
.sa
.sa_mask
.sig
[3] = set32
.sig
[6]
297 | (((long)set32
.sig
[7]) << 32);
298 case 3: new_ka
.sa
.sa_mask
.sig
[2] = set32
.sig
[4]
299 | (((long)set32
.sig
[5]) << 32);
300 case 2: new_ka
.sa
.sa_mask
.sig
[1] = set32
.sig
[2]
301 | (((long)set32
.sig
[3]) << 32);
302 case 1: new_ka
.sa
.sa_mask
.sig
[0] = set32
.sig
[0]
303 | (((long)set32
.sig
[1]) << 32);
307 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
310 /* FIXME: here we rely on _COMPAT_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
311 switch (_NSIG_WORDS
) {
313 set32
.sig
[7] = (old_ka
.sa
.sa_mask
.sig
[3] >> 32);
314 set32
.sig
[6] = old_ka
.sa
.sa_mask
.sig
[3];
316 set32
.sig
[5] = (old_ka
.sa
.sa_mask
.sig
[2] >> 32);
317 set32
.sig
[4] = old_ka
.sa
.sa_mask
.sig
[2];
319 set32
.sig
[3] = (old_ka
.sa
.sa_mask
.sig
[1] >> 32);
320 set32
.sig
[2] = old_ka
.sa
.sa_mask
.sig
[1];
322 set32
.sig
[1] = (old_ka
.sa
.sa_mask
.sig
[0] >> 32);
323 set32
.sig
[0] = old_ka
.sa
.sa_mask
.sig
[0];
325 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
326 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
) ||
327 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
) ||
328 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
329 __copy_to_user(&oact
->sa_mask
, &set32
, sizeof(compat_sigset_t
)))
337 sys32_sigaction (int sig
, struct old_sigaction32 __user
*act
, struct old_sigaction32 __user
*oact
)
339 struct k_sigaction new_ka
, old_ka
;
343 compat_old_sigset_t mask
;
344 compat_uptr_t handler
, restorer
;
346 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
347 __get_user(handler
, &act
->sa_handler
) ||
348 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
349 __get_user(restorer
, &act
->sa_restorer
) ||
350 __get_user(mask
, &act
->sa_mask
))
353 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
354 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
356 siginitset(&new_ka
.sa
.sa_mask
, mask
);
359 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
362 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
363 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
) ||
364 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
) ||
365 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
366 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
374 sys32_rt_sigprocmask(int how
, compat_sigset_t __user
*set
,
375 compat_sigset_t __user
*oset
, unsigned int sigsetsize
)
380 mm_segment_t old_fs
= get_fs();
383 if (copy_from_user (&s32
, set
, sizeof(compat_sigset_t
)))
385 switch (_NSIG_WORDS
) {
386 case 4: s
.sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
387 case 3: s
.sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
388 case 2: s
.sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
389 case 1: s
.sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
393 ret
= sys_rt_sigprocmask(how
, set
? &s
: NULL
, oset
? &s
: NULL
,
398 switch (_NSIG_WORDS
) {
399 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
400 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
401 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
402 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
404 if (copy_to_user (oset
, &s32
, sizeof(compat_sigset_t
)))
411 get_tv32(struct timeval
*o
, struct compat_timeval __user
*i
)
414 if (access_ok(VERIFY_READ
, i
, sizeof(*i
))) {
415 err
= __get_user(o
->tv_sec
, &i
->tv_sec
);
416 err
|= __get_user(o
->tv_usec
, &i
->tv_usec
);
422 put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
425 if (access_ok(VERIFY_WRITE
, o
, sizeof(*o
))) {
426 err
= __put_user(i
->tv_sec
, &o
->tv_sec
);
427 err
|= __put_user(i
->tv_usec
, &o
->tv_usec
);
432 extern unsigned int alarm_setitimer(unsigned int seconds
);
435 sys32_alarm(unsigned int seconds
)
437 return alarm_setitimer(seconds
);
440 /* Translations due to time_t size differences. Which affects all
441 sorts of things, like timeval and itimerval. */
443 extern struct timezone sys_tz
;
446 sys32_gettimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
450 do_gettimeofday(&ktv
);
451 if (put_tv32(tv
, &ktv
))
455 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
462 sys32_settimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
469 if (get_tv32(&ktv
, tv
))
471 kts
.tv_sec
= ktv
.tv_sec
;
472 kts
.tv_nsec
= ktv
.tv_usec
* NSEC_PER_USEC
;
475 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
479 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
482 struct sel_arg_struct
{
491 sys32_old_select(struct sel_arg_struct __user
*arg
)
493 struct sel_arg_struct a
;
495 if (copy_from_user(&a
, arg
, sizeof(a
)))
497 return compat_sys_select(a
.n
, compat_ptr(a
.inp
), compat_ptr(a
.outp
),
498 compat_ptr(a
.exp
), compat_ptr(a
.tvp
));
501 extern asmlinkage
long
502 compat_sys_wait4(compat_pid_t pid
, compat_uint_t
* stat_addr
, int options
,
503 struct compat_rusage
*ru
);
506 sys32_waitpid(compat_pid_t pid
, unsigned int *stat_addr
, int options
)
508 return compat_sys_wait4(pid
, stat_addr
, options
, NULL
);
511 /* 32-bit timeval and related flotsam. */
514 sys32_sysfs(int option
, u32 arg1
, u32 arg2
)
516 return sys_sysfs(option
, arg1
, arg2
);
528 unsigned short procs
;
533 char _f
[20-2*sizeof(u32
)-sizeof(int)];
537 sys32_sysinfo(struct sysinfo32 __user
*info
)
541 mm_segment_t old_fs
= get_fs ();
545 ret
= sys_sysinfo(&s
);
548 /* Check to see if any memory value is too large for 32-bit and scale
551 if ((s
.totalram
>> 32) || (s
.totalswap
>> 32)) {
552 while (s
.mem_unit
< PAGE_SIZE
) {
556 s
.totalram
>>= bitcount
;
557 s
.freeram
>>= bitcount
;
558 s
.sharedram
>>= bitcount
;
559 s
.bufferram
>>= bitcount
;
560 s
.totalswap
>>= bitcount
;
561 s
.freeswap
>>= bitcount
;
562 s
.totalhigh
>>= bitcount
;
563 s
.freehigh
>>= bitcount
;
566 if (!access_ok(VERIFY_WRITE
, info
, sizeof(struct sysinfo32
)) ||
567 __put_user (s
.uptime
, &info
->uptime
) ||
568 __put_user (s
.loads
[0], &info
->loads
[0]) ||
569 __put_user (s
.loads
[1], &info
->loads
[1]) ||
570 __put_user (s
.loads
[2], &info
->loads
[2]) ||
571 __put_user (s
.totalram
, &info
->totalram
) ||
572 __put_user (s
.freeram
, &info
->freeram
) ||
573 __put_user (s
.sharedram
, &info
->sharedram
) ||
574 __put_user (s
.bufferram
, &info
->bufferram
) ||
575 __put_user (s
.totalswap
, &info
->totalswap
) ||
576 __put_user (s
.freeswap
, &info
->freeswap
) ||
577 __put_user (s
.procs
, &info
->procs
) ||
578 __put_user (s
.totalhigh
, &info
->totalhigh
) ||
579 __put_user (s
.freehigh
, &info
->freehigh
) ||
580 __put_user (s
.mem_unit
, &info
->mem_unit
))
586 sys32_sched_rr_get_interval(compat_pid_t pid
, struct compat_timespec __user
*interval
)
590 mm_segment_t old_fs
= get_fs ();
593 ret
= sys_sched_rr_get_interval(pid
, &t
);
595 if (put_compat_timespec(&t
, interval
))
601 sys32_rt_sigpending(compat_sigset_t __user
*set
, compat_size_t sigsetsize
)
606 mm_segment_t old_fs
= get_fs();
609 ret
= sys_rt_sigpending(&s
, sigsetsize
);
612 switch (_NSIG_WORDS
) {
613 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
614 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
615 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
616 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
618 if (copy_to_user (set
, &s32
, sizeof(compat_sigset_t
)))
625 sys32_rt_sigqueueinfo(int pid
, int sig
, compat_siginfo_t __user
*uinfo
)
629 mm_segment_t old_fs
= get_fs();
631 if (copy_siginfo_from_user32(&info
, uinfo
))
634 ret
= sys_rt_sigqueueinfo(pid
, sig
, &info
);
639 /* These are here just in case some old ia32 binary calls it. */
643 current
->state
= TASK_INTERRUPTIBLE
;
645 return -ERESTARTNOHAND
;
654 unsigned int oldlenp
;
657 unsigned int __unused
[4];
662 sys32_sysctl(struct sysctl_ia32 __user
*args32
)
664 struct sysctl_ia32 a32
;
665 mm_segment_t old_fs
= get_fs ();
666 void __user
*oldvalp
, *newvalp
;
670 extern int do_sysctl(int *name
, int nlen
, void *oldval
, size_t *oldlenp
,
671 void *newval
, size_t newlen
);
674 if (copy_from_user(&a32
, args32
, sizeof (a32
)))
678 * We need to pre-validate these because we have to disable address checking
679 * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
680 * user specifying bad addresses here. Well, since we're dealing with 32 bit
681 * addresses, we KNOW that access_ok() will always succeed, so this is an
682 * expensive NOP, but so what...
684 namep
= compat_ptr(a32
.name
);
685 oldvalp
= compat_ptr(a32
.oldval
);
686 newvalp
= compat_ptr(a32
.newval
);
688 if ((oldvalp
&& get_user(oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
689 || !access_ok(VERIFY_WRITE
, namep
, 0)
690 || !access_ok(VERIFY_WRITE
, oldvalp
, 0)
691 || !access_ok(VERIFY_WRITE
, newvalp
, 0))
696 ret
= do_sysctl(namep
, a32
.nlen
, oldvalp
, &oldlen
, newvalp
, (size_t) a32
.newlen
);
700 if (oldvalp
&& put_user (oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
707 /* warning: next two assume little endian */
709 sys32_pread(unsigned int fd
, char __user
*ubuf
, u32 count
, u32 poslo
, u32 poshi
)
711 return sys_pread64(fd
, ubuf
, count
,
712 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
716 sys32_pwrite(unsigned int fd
, char __user
*ubuf
, u32 count
, u32 poslo
, u32 poshi
)
718 return sys_pwrite64(fd
, ubuf
, count
,
719 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
724 sys32_personality(unsigned long personality
)
727 if (personality(current
->personality
) == PER_LINUX32
&&
728 personality
== PER_LINUX
)
729 personality
= PER_LINUX32
;
730 ret
= sys_personality(personality
);
731 if (ret
== PER_LINUX32
)
737 sys32_sendfile(int out_fd
, int in_fd
, compat_off_t __user
*offset
, s32 count
)
739 mm_segment_t old_fs
= get_fs();
743 if (offset
&& get_user(of
, offset
))
747 ret
= sys_sendfile(out_fd
, in_fd
, offset
? &of
: NULL
, count
);
750 if (offset
&& put_user(of
, offset
))
756 asmlinkage
long sys32_mmap2(unsigned long addr
, unsigned long len
,
757 unsigned long prot
, unsigned long flags
,
758 unsigned long fd
, unsigned long pgoff
)
760 struct mm_struct
*mm
= current
->mm
;
762 struct file
* file
= NULL
;
764 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
765 if (!(flags
& MAP_ANONYMOUS
)) {
771 down_write(&mm
->mmap_sem
);
772 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
773 up_write(&mm
->mmap_sem
);
780 asmlinkage
long sys32_olduname(struct oldold_utsname __user
* name
)
786 if (!access_ok(VERIFY_WRITE
,name
,sizeof(struct oldold_utsname
)))
791 error
= __copy_to_user(&name
->sysname
,&system_utsname
.sysname
,__OLD_UTS_LEN
);
792 __put_user(0,name
->sysname
+__OLD_UTS_LEN
);
793 __copy_to_user(&name
->nodename
,&system_utsname
.nodename
,__OLD_UTS_LEN
);
794 __put_user(0,name
->nodename
+__OLD_UTS_LEN
);
795 __copy_to_user(&name
->release
,&system_utsname
.release
,__OLD_UTS_LEN
);
796 __put_user(0,name
->release
+__OLD_UTS_LEN
);
797 __copy_to_user(&name
->version
,&system_utsname
.version
,__OLD_UTS_LEN
);
798 __put_user(0,name
->version
+__OLD_UTS_LEN
);
800 char *arch
= "x86_64";
801 if (personality(current
->personality
) == PER_LINUX32
)
804 __copy_to_user(&name
->machine
,arch
,strlen(arch
)+1);
809 error
= error
? -EFAULT
: 0;
814 long sys32_uname(struct old_utsname __user
* name
)
820 err
=copy_to_user(name
, &system_utsname
, sizeof (*name
));
822 if (personality(current
->personality
) == PER_LINUX32
)
823 err
|= copy_to_user(&name
->machine
, "i686", 5);
824 return err
?-EFAULT
:0;
827 long sys32_ustat(unsigned dev
, struct ustat32 __user
*u32p
)
835 ret
= sys_ustat(dev
,&u
);
838 if (!access_ok(VERIFY_WRITE
,u32p
,sizeof(struct ustat32
)) ||
839 __put_user((__u32
) u
.f_tfree
, &u32p
->f_tfree
) ||
840 __put_user((__u32
) u
.f_tinode
, &u32p
->f_tfree
) ||
841 __copy_to_user(&u32p
->f_fname
, u
.f_fname
, sizeof(u
.f_fname
)) ||
842 __copy_to_user(&u32p
->f_fpack
, u
.f_fpack
, sizeof(u
.f_fpack
)))
848 asmlinkage
long sys32_execve(char __user
*name
, compat_uptr_t __user
*argv
,
849 compat_uptr_t __user
*envp
, struct pt_regs
*regs
)
854 filename
= getname(name
);
855 error
= PTR_ERR(filename
);
856 if (IS_ERR(filename
))
858 error
= compat_do_execve(filename
, argv
, envp
, regs
);
861 current
->ptrace
&= ~PT_DTRACE
;
862 task_unlock(current
);
868 asmlinkage
long sys32_clone(unsigned int clone_flags
, unsigned int newsp
,
869 struct pt_regs
*regs
)
871 void __user
*parent_tid
= (void __user
*)regs
->rdx
;
872 void __user
*child_tid
= (void __user
*)regs
->rdi
;
875 return do_fork(clone_flags
, newsp
, regs
, 0, parent_tid
, child_tid
);
879 * Some system calls that need sign extended arguments. This could be done by a generic wrapper.
882 long sys32_lseek (unsigned int fd
, int offset
, unsigned int whence
)
884 return sys_lseek(fd
, offset
, whence
);
887 long sys32_kill(int pid
, int sig
)
889 return sys_kill(pid
, sig
);
892 long sys32_fadvise64_64(int fd
, __u32 offset_low
, __u32 offset_high
,
893 __u32 len_low
, __u32 len_high
, int advice
)
895 return sys_fadvise64_64(fd
,
896 (((u64
)offset_high
)<<32) | offset_low
,
897 (((u64
)len_high
)<<32) | len_low
,
901 long sys32_vm86_warning(void)
903 struct task_struct
*me
= current
;
904 static char lastcomm
[sizeof(me
->comm
)];
905 if (strncmp(lastcomm
, me
->comm
, sizeof(lastcomm
))) {
906 compat_printk(KERN_INFO
"%s: vm86 mode not supported on 64 bit kernel\n",
908 strncpy(lastcomm
, me
->comm
, sizeof(lastcomm
));
913 long sys32_lookup_dcookie(u32 addr_low
, u32 addr_high
,
914 char __user
* buf
, size_t len
)
916 return sys_lookup_dcookie(((u64
)addr_high
<< 32) | addr_low
, buf
, len
);