7cede7a9e0dc4831cf80349ce2a049b88cf8cab8
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
20 * hopefully all marked. This should be fixed.
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
26 #include <linux/file.h>
27 #include <linux/signal.h>
28 #include <linux/syscalls.h>
29 #include <linux/times.h>
30 #include <linux/utsname.h>
31 #include <linux/smp_lock.h>
33 #include <linux/uio.h>
34 #include <linux/poll.h>
35 #include <linux/personality.h>
36 #include <linux/stat.h>
37 #include <linux/rwsem.h>
38 #include <linux/compat.h>
39 #include <linux/vfs.h>
40 #include <linux/ptrace.h>
41 #include <linux/highuid.h>
42 #include <linux/sysctl.h>
44 #include <asm/types.h>
45 #include <asm/uaccess.h>
46 #include <asm/semaphore.h>
47 #include <asm/atomic.h>
49 #include <asm/vgtod.h>
51 #define AA(__x) ((unsigned long)(__x))
53 int cp_compat_stat(struct kstat
*kbuf
, struct compat_stat __user
*ubuf
)
57 typeof(ubuf
->st_uid
) uid
= 0;
58 typeof(ubuf
->st_gid
) gid
= 0;
59 SET_UID(uid
, kbuf
->uid
);
60 SET_GID(gid
, kbuf
->gid
);
61 if (!old_valid_dev(kbuf
->dev
) || !old_valid_dev(kbuf
->rdev
))
63 if (kbuf
->size
>= 0x7fffffff)
66 if (sizeof(ino
) < sizeof(kbuf
->ino
) && ino
!= kbuf
->ino
)
68 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct compat_stat
)) ||
69 __put_user(old_encode_dev(kbuf
->dev
), &ubuf
->st_dev
) ||
70 __put_user(ino
, &ubuf
->st_ino
) ||
71 __put_user(kbuf
->mode
, &ubuf
->st_mode
) ||
72 __put_user(kbuf
->nlink
, &ubuf
->st_nlink
) ||
73 __put_user(uid
, &ubuf
->st_uid
) ||
74 __put_user(gid
, &ubuf
->st_gid
) ||
75 __put_user(old_encode_dev(kbuf
->rdev
), &ubuf
->st_rdev
) ||
76 __put_user(kbuf
->size
, &ubuf
->st_size
) ||
77 __put_user(kbuf
->atime
.tv_sec
, &ubuf
->st_atime
) ||
78 __put_user(kbuf
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
79 __put_user(kbuf
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
80 __put_user(kbuf
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
81 __put_user(kbuf
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
82 __put_user(kbuf
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
83 __put_user(kbuf
->blksize
, &ubuf
->st_blksize
) ||
84 __put_user(kbuf
->blocks
, &ubuf
->st_blocks
))
89 asmlinkage
long sys32_truncate64(char __user
*filename
,
90 unsigned long offset_low
,
91 unsigned long offset_high
)
93 return sys_truncate(filename
, ((loff_t
) offset_high
<< 32) | offset_low
);
96 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long offset_low
,
97 unsigned long offset_high
)
99 return sys_ftruncate(fd
, ((loff_t
) offset_high
<< 32) | offset_low
);
103 * Another set for IA32/LFS -- x86_64 struct stat is different due to
104 * support for 64bit inode numbers.
106 static int cp_stat64(struct stat64 __user
*ubuf
, struct kstat
*stat
)
108 typeof(ubuf
->st_uid
) uid
= 0;
109 typeof(ubuf
->st_gid
) gid
= 0;
110 SET_UID(uid
, stat
->uid
);
111 SET_GID(gid
, stat
->gid
);
112 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(struct stat64
)) ||
113 __put_user(huge_encode_dev(stat
->dev
), &ubuf
->st_dev
) ||
114 __put_user(stat
->ino
, &ubuf
->__st_ino
) ||
115 __put_user(stat
->ino
, &ubuf
->st_ino
) ||
116 __put_user(stat
->mode
, &ubuf
->st_mode
) ||
117 __put_user(stat
->nlink
, &ubuf
->st_nlink
) ||
118 __put_user(uid
, &ubuf
->st_uid
) ||
119 __put_user(gid
, &ubuf
->st_gid
) ||
120 __put_user(huge_encode_dev(stat
->rdev
), &ubuf
->st_rdev
) ||
121 __put_user(stat
->size
, &ubuf
->st_size
) ||
122 __put_user(stat
->atime
.tv_sec
, &ubuf
->st_atime
) ||
123 __put_user(stat
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
) ||
124 __put_user(stat
->mtime
.tv_sec
, &ubuf
->st_mtime
) ||
125 __put_user(stat
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
) ||
126 __put_user(stat
->ctime
.tv_sec
, &ubuf
->st_ctime
) ||
127 __put_user(stat
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
) ||
128 __put_user(stat
->blksize
, &ubuf
->st_blksize
) ||
129 __put_user(stat
->blocks
, &ubuf
->st_blocks
))
134 asmlinkage
long sys32_stat64(char __user
*filename
,
135 struct stat64 __user
*statbuf
)
138 int ret
= vfs_stat(filename
, &stat
);
141 ret
= cp_stat64(statbuf
, &stat
);
145 asmlinkage
long sys32_lstat64(char __user
*filename
,
146 struct stat64 __user
*statbuf
)
149 int ret
= vfs_lstat(filename
, &stat
);
151 ret
= cp_stat64(statbuf
, &stat
);
155 asmlinkage
long sys32_fstat64(unsigned int fd
, struct stat64 __user
*statbuf
)
158 int ret
= vfs_fstat(fd
, &stat
);
160 ret
= cp_stat64(statbuf
, &stat
);
164 asmlinkage
long sys32_fstatat(unsigned int dfd
, char __user
*filename
,
165 struct stat64 __user
*statbuf
, int flag
)
170 if ((flag
& ~AT_SYMLINK_NOFOLLOW
) != 0)
173 if (flag
& AT_SYMLINK_NOFOLLOW
)
174 error
= vfs_lstat_fd(dfd
, filename
, &stat
);
176 error
= vfs_stat_fd(dfd
, filename
, &stat
);
179 error
= cp_stat64(statbuf
, &stat
);
186 * Linux/i386 didn't use to be able to handle more than
187 * 4 system call parameters, so these system calls used a memory
188 * block for parameter passing..
191 struct mmap_arg_struct
{
200 asmlinkage
long sys32_mmap(struct mmap_arg_struct __user
*arg
)
202 struct mmap_arg_struct a
;
203 struct file
*file
= NULL
;
204 unsigned long retval
;
205 struct mm_struct
*mm
;
207 if (copy_from_user(&a
, arg
, sizeof(a
)))
210 if (a
.offset
& ~PAGE_MASK
)
213 if (!(a
.flags
& MAP_ANONYMOUS
)) {
220 down_write(&mm
->mmap_sem
);
221 retval
= do_mmap_pgoff(file
, a
.addr
, a
.len
, a
.prot
, a
.flags
,
222 a
.offset
>>PAGE_SHIFT
);
226 up_write(&mm
->mmap_sem
);
231 asmlinkage
long sys32_mprotect(unsigned long start
, size_t len
,
234 return sys_mprotect(start
, len
, prot
);
237 asmlinkage
long sys32_pipe(int __user
*fd
)
242 retval
= do_pipe(fds
);
245 if (copy_to_user(fd
, fds
, sizeof(fds
)))
251 asmlinkage
long sys32_rt_sigaction(int sig
, struct sigaction32 __user
*act
,
252 struct sigaction32 __user
*oact
,
253 unsigned int sigsetsize
)
255 struct k_sigaction new_ka
, old_ka
;
257 compat_sigset_t set32
;
259 /* XXX: Don't preclude handling different sized sigset_t's. */
260 if (sigsetsize
!= sizeof(compat_sigset_t
))
264 compat_uptr_t handler
, restorer
;
266 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
267 __get_user(handler
, &act
->sa_handler
) ||
268 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
269 __get_user(restorer
, &act
->sa_restorer
) ||
270 __copy_from_user(&set32
, &act
->sa_mask
,
271 sizeof(compat_sigset_t
)))
273 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
274 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
277 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
278 * than _NSIG_WORDS << 1
280 switch (_NSIG_WORDS
) {
281 case 4: new_ka
.sa
.sa_mask
.sig
[3] = set32
.sig
[6]
282 | (((long)set32
.sig
[7]) << 32);
283 case 3: new_ka
.sa
.sa_mask
.sig
[2] = set32
.sig
[4]
284 | (((long)set32
.sig
[5]) << 32);
285 case 2: new_ka
.sa
.sa_mask
.sig
[1] = set32
.sig
[2]
286 | (((long)set32
.sig
[3]) << 32);
287 case 1: new_ka
.sa
.sa_mask
.sig
[0] = set32
.sig
[0]
288 | (((long)set32
.sig
[1]) << 32);
292 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
296 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
297 * than _NSIG_WORDS << 1
299 switch (_NSIG_WORDS
) {
301 set32
.sig
[7] = (old_ka
.sa
.sa_mask
.sig
[3] >> 32);
302 set32
.sig
[6] = old_ka
.sa
.sa_mask
.sig
[3];
304 set32
.sig
[5] = (old_ka
.sa
.sa_mask
.sig
[2] >> 32);
305 set32
.sig
[4] = old_ka
.sa
.sa_mask
.sig
[2];
307 set32
.sig
[3] = (old_ka
.sa
.sa_mask
.sig
[1] >> 32);
308 set32
.sig
[2] = old_ka
.sa
.sa_mask
.sig
[1];
310 set32
.sig
[1] = (old_ka
.sa
.sa_mask
.sig
[0] >> 32);
311 set32
.sig
[0] = old_ka
.sa
.sa_mask
.sig
[0];
313 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
314 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
),
315 &oact
->sa_handler
) ||
316 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
),
317 &oact
->sa_restorer
) ||
318 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
319 __copy_to_user(&oact
->sa_mask
, &set32
,
320 sizeof(compat_sigset_t
)))
327 asmlinkage
long sys32_sigaction(int sig
, struct old_sigaction32 __user
*act
,
328 struct old_sigaction32 __user
*oact
)
330 struct k_sigaction new_ka
, old_ka
;
334 compat_old_sigset_t mask
;
335 compat_uptr_t handler
, restorer
;
337 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
338 __get_user(handler
, &act
->sa_handler
) ||
339 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
) ||
340 __get_user(restorer
, &act
->sa_restorer
) ||
341 __get_user(mask
, &act
->sa_mask
))
344 new_ka
.sa
.sa_handler
= compat_ptr(handler
);
345 new_ka
.sa
.sa_restorer
= compat_ptr(restorer
);
347 siginitset(&new_ka
.sa
.sa_mask
, mask
);
350 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
353 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
354 __put_user(ptr_to_compat(old_ka
.sa
.sa_handler
),
355 &oact
->sa_handler
) ||
356 __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
),
357 &oact
->sa_restorer
) ||
358 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
) ||
359 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
))
366 asmlinkage
long sys32_rt_sigprocmask(int how
, compat_sigset_t __user
*set
,
367 compat_sigset_t __user
*oset
,
368 unsigned int sigsetsize
)
373 mm_segment_t old_fs
= get_fs();
376 if (copy_from_user(&s32
, set
, sizeof(compat_sigset_t
)))
378 switch (_NSIG_WORDS
) {
379 case 4: s
.sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
380 case 3: s
.sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
381 case 2: s
.sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
382 case 1: s
.sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
386 ret
= sys_rt_sigprocmask(how
,
387 set
? (sigset_t __user
*)&s
: NULL
,
388 oset
? (sigset_t __user
*)&s
: NULL
,
394 switch (_NSIG_WORDS
) {
395 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
396 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
397 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
398 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
400 if (copy_to_user(oset
, &s32
, sizeof(compat_sigset_t
)))
406 static inline long get_tv32(struct timeval
*o
, struct compat_timeval __user
*i
)
410 if (access_ok(VERIFY_READ
, i
, sizeof(*i
))) {
411 err
= __get_user(o
->tv_sec
, &i
->tv_sec
);
412 err
|= __get_user(o
->tv_usec
, &i
->tv_usec
);
417 static inline long put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
421 if (access_ok(VERIFY_WRITE
, o
, sizeof(*o
))) {
422 err
= __put_user(i
->tv_sec
, &o
->tv_sec
);
423 err
|= __put_user(i
->tv_usec
, &o
->tv_usec
);
428 asmlinkage
long sys32_alarm(unsigned int seconds
)
430 return alarm_setitimer(seconds
);
434 * Translations due to time_t size differences. Which affects all
435 * sorts of things, like timeval and itimerval.
437 asmlinkage
long sys32_gettimeofday(struct compat_timeval __user
*tv
,
438 struct timezone __user
*tz
)
443 do_gettimeofday(&ktv
);
444 if (put_tv32(tv
, &ktv
))
448 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
454 asmlinkage
long sys32_settimeofday(struct compat_timeval __user
*tv
,
455 struct timezone __user
*tz
)
462 if (get_tv32(&ktv
, tv
))
464 kts
.tv_sec
= ktv
.tv_sec
;
465 kts
.tv_nsec
= ktv
.tv_usec
* NSEC_PER_USEC
;
468 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
472 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
475 struct sel_arg_struct
{
483 asmlinkage
long sys32_old_select(struct sel_arg_struct __user
*arg
)
485 struct sel_arg_struct a
;
487 if (copy_from_user(&a
, arg
, sizeof(a
)))
489 return compat_sys_select(a
.n
, compat_ptr(a
.inp
), compat_ptr(a
.outp
),
490 compat_ptr(a
.exp
), compat_ptr(a
.tvp
));
493 asmlinkage
long sys32_waitpid(compat_pid_t pid
, unsigned int *stat_addr
,
496 return compat_sys_wait4(pid
, stat_addr
, options
, NULL
);
499 /* 32-bit timeval and related flotsam. */
501 asmlinkage
long sys32_sysfs(int option
, u32 arg1
, u32 arg2
)
503 return sys_sysfs(option
, arg1
, arg2
);
506 asmlinkage
long sys32_sched_rr_get_interval(compat_pid_t pid
,
507 struct compat_timespec __user
*interval
)
511 mm_segment_t old_fs
= get_fs();
514 ret
= sys_sched_rr_get_interval(pid
, (struct timespec __user
*)&t
);
516 if (put_compat_timespec(&t
, interval
))
521 asmlinkage
long sys32_rt_sigpending(compat_sigset_t __user
*set
,
522 compat_size_t sigsetsize
)
527 mm_segment_t old_fs
= get_fs();
530 ret
= sys_rt_sigpending((sigset_t __user
*)&s
, sigsetsize
);
533 switch (_NSIG_WORDS
) {
534 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
535 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
536 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
537 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
539 if (copy_to_user(set
, &s32
, sizeof(compat_sigset_t
)))
545 asmlinkage
long sys32_rt_sigqueueinfo(int pid
, int sig
,
546 compat_siginfo_t __user
*uinfo
)
550 mm_segment_t old_fs
= get_fs();
552 if (copy_siginfo_from_user32(&info
, uinfo
))
555 ret
= sys_rt_sigqueueinfo(pid
, sig
, (siginfo_t __user
*)&info
);
560 /* These are here just in case some old ia32 binary calls it. */
561 asmlinkage
long sys32_pause(void)
563 current
->state
= TASK_INTERRUPTIBLE
;
565 return -ERESTARTNOHAND
;
569 #ifdef CONFIG_SYSCTL_SYSCALL
574 unsigned int oldlenp
;
577 unsigned int __unused
[4];
581 asmlinkage
long sys32_sysctl(struct sysctl_ia32 __user
*args32
)
583 struct sysctl_ia32 a32
;
584 mm_segment_t old_fs
= get_fs();
585 void __user
*oldvalp
, *newvalp
;
590 if (copy_from_user(&a32
, args32
, sizeof(a32
)))
594 * We need to pre-validate these because we have to disable
595 * address checking before calling do_sysctl() because of
596 * OLDLEN but we can't run the risk of the user specifying bad
597 * addresses here. Well, since we're dealing with 32 bit
598 * addresses, we KNOW that access_ok() will always succeed, so
599 * this is an expensive NOP, but so what...
601 namep
= compat_ptr(a32
.name
);
602 oldvalp
= compat_ptr(a32
.oldval
);
603 newvalp
= compat_ptr(a32
.newval
);
605 if ((oldvalp
&& get_user(oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
606 || !access_ok(VERIFY_WRITE
, namep
, 0)
607 || !access_ok(VERIFY_WRITE
, oldvalp
, 0)
608 || !access_ok(VERIFY_WRITE
, newvalp
, 0))
613 ret
= do_sysctl(namep
, a32
.nlen
, oldvalp
, (size_t __user
*)&oldlen
,
614 newvalp
, (size_t) a32
.newlen
);
618 if (oldvalp
&& put_user(oldlen
, (int __user
*)compat_ptr(a32
.oldlenp
)))
625 /* warning: next two assume little endian */
626 asmlinkage
long sys32_pread(unsigned int fd
, char __user
*ubuf
, u32 count
,
627 u32 poslo
, u32 poshi
)
629 return sys_pread64(fd
, ubuf
, count
,
630 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
633 asmlinkage
long sys32_pwrite(unsigned int fd
, char __user
*ubuf
, u32 count
,
634 u32 poslo
, u32 poshi
)
636 return sys_pwrite64(fd
, ubuf
, count
,
637 ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
641 asmlinkage
long sys32_personality(unsigned long personality
)
645 if (personality(current
->personality
) == PER_LINUX32
&&
646 personality
== PER_LINUX
)
647 personality
= PER_LINUX32
;
648 ret
= sys_personality(personality
);
649 if (ret
== PER_LINUX32
)
654 asmlinkage
long sys32_sendfile(int out_fd
, int in_fd
,
655 compat_off_t __user
*offset
, s32 count
)
657 mm_segment_t old_fs
= get_fs();
661 if (offset
&& get_user(of
, offset
))
665 ret
= sys_sendfile(out_fd
, in_fd
, offset
? (off_t __user
*)&of
: NULL
,
669 if (offset
&& put_user(of
, offset
))
674 asmlinkage
long sys32_mmap2(unsigned long addr
, unsigned long len
,
675 unsigned long prot
, unsigned long flags
,
676 unsigned long fd
, unsigned long pgoff
)
678 struct mm_struct
*mm
= current
->mm
;
680 struct file
*file
= NULL
;
682 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
683 if (!(flags
& MAP_ANONYMOUS
)) {
689 down_write(&mm
->mmap_sem
);
690 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
691 up_write(&mm
->mmap_sem
);
698 asmlinkage
long sys32_olduname(struct oldold_utsname __user
*name
)
700 char *arch
= "x86_64";
705 if (!access_ok(VERIFY_WRITE
, name
, sizeof(struct oldold_utsname
)))
710 err
= __copy_to_user(&name
->sysname
, &utsname()->sysname
,
712 err
|= __put_user(0, name
->sysname
+__OLD_UTS_LEN
);
713 err
|= __copy_to_user(&name
->nodename
, &utsname()->nodename
,
715 err
|= __put_user(0, name
->nodename
+__OLD_UTS_LEN
);
716 err
|= __copy_to_user(&name
->release
, &utsname()->release
,
718 err
|= __put_user(0, name
->release
+__OLD_UTS_LEN
);
719 err
|= __copy_to_user(&name
->version
, &utsname()->version
,
721 err
|= __put_user(0, name
->version
+__OLD_UTS_LEN
);
723 if (personality(current
->personality
) == PER_LINUX32
)
726 err
|= __copy_to_user(&name
->machine
, arch
, strlen(arch
) + 1);
730 err
= err
? -EFAULT
: 0;
735 long sys32_uname(struct old_utsname __user
*name
)
742 err
= copy_to_user(name
, utsname(), sizeof(*name
));
744 if (personality(current
->personality
) == PER_LINUX32
)
745 err
|= copy_to_user(&name
->machine
, "i686", 5);
747 return err
? -EFAULT
: 0;
750 long sys32_ustat(unsigned dev
, struct ustat32 __user
*u32p
)
758 ret
= sys_ustat(dev
, (struct ustat __user
*)&u
);
763 if (!access_ok(VERIFY_WRITE
, u32p
, sizeof(struct ustat32
)) ||
764 __put_user((__u32
) u
.f_tfree
, &u32p
->f_tfree
) ||
765 __put_user((__u32
) u
.f_tinode
, &u32p
->f_tfree
) ||
766 __copy_to_user(&u32p
->f_fname
, u
.f_fname
, sizeof(u
.f_fname
)) ||
767 __copy_to_user(&u32p
->f_fpack
, u
.f_fpack
, sizeof(u
.f_fpack
)))
772 asmlinkage
long sys32_execve(char __user
*name
, compat_uptr_t __user
*argv
,
773 compat_uptr_t __user
*envp
, struct pt_regs
*regs
)
778 filename
= getname(name
);
779 error
= PTR_ERR(filename
);
780 if (IS_ERR(filename
))
782 error
= compat_do_execve(filename
, argv
, envp
, regs
);
787 asmlinkage
long sys32_clone(unsigned int clone_flags
, unsigned int newsp
,
788 struct pt_regs
*regs
)
790 void __user
*parent_tid
= (void __user
*)regs
->dx
;
791 void __user
*child_tid
= (void __user
*)regs
->di
;
795 return do_fork(clone_flags
, newsp
, regs
, 0, parent_tid
, child_tid
);
799 * Some system calls that need sign extended arguments. This could be
800 * done by a generic wrapper.
802 long sys32_lseek(unsigned int fd
, int offset
, unsigned int whence
)
804 return sys_lseek(fd
, offset
, whence
);
807 long sys32_kill(int pid
, int sig
)
809 return sys_kill(pid
, sig
);
812 long sys32_fadvise64_64(int fd
, __u32 offset_low
, __u32 offset_high
,
813 __u32 len_low
, __u32 len_high
, int advice
)
815 return sys_fadvise64_64(fd
,
816 (((u64
)offset_high
)<<32) | offset_low
,
817 (((u64
)len_high
)<<32) | len_low
,
821 long sys32_vm86_warning(void)
823 struct task_struct
*me
= current
;
824 static char lastcomm
[sizeof(me
->comm
)];
826 if (strncmp(lastcomm
, me
->comm
, sizeof(lastcomm
))) {
827 compat_printk(KERN_INFO
828 "%s: vm86 mode not supported on 64 bit kernel\n",
830 strncpy(lastcomm
, me
->comm
, sizeof(lastcomm
));
835 long sys32_lookup_dcookie(u32 addr_low
, u32 addr_high
,
836 char __user
*buf
, size_t len
)
838 return sys_lookup_dcookie(((u64
)addr_high
<< 32) | addr_low
, buf
, len
);
841 asmlinkage ssize_t
sys32_readahead(int fd
, unsigned off_lo
, unsigned off_hi
,
844 return sys_readahead(fd
, ((u64
)off_hi
<< 32) | off_lo
, count
);
847 asmlinkage
long sys32_sync_file_range(int fd
, unsigned off_low
, unsigned off_hi
,
848 unsigned n_low
, unsigned n_hi
, int flags
)
850 return sys_sync_file_range(fd
,
851 ((u64
)off_hi
<< 32) | off_low
,
852 ((u64
)n_hi
<< 32) | n_low
, flags
);
855 asmlinkage
long sys32_fadvise64(int fd
, unsigned offset_lo
, unsigned offset_hi
,
856 size_t len
, int advice
)
858 return sys_fadvise64_64(fd
, ((u64
)offset_hi
<< 32) | offset_lo
,
862 asmlinkage
long sys32_fallocate(int fd
, int mode
, unsigned offset_lo
,
863 unsigned offset_hi
, unsigned len_lo
,
866 return sys_fallocate(fd
, mode
, ((u64
)offset_hi
<< 32) | offset_lo
,
867 ((u64
)len_hi
<< 32) | len_lo
);
This page took 0.047063 seconds and 4 git commands to generate.