2 * arch/s390x/kernel/linux32.c
5 * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
6 * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
7 * Gerhard Tonn (ton@de.ibm.com)
8 * Thomas Spatzier (tspat@de.ibm.com)
10 * Conversion between 31bit and 64bit native syscalls.
12 * Heavily inspired by the 32-bit Sparc compat code which is
13 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
14 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
19 #include <linux/kernel.h>
20 #include <linux/sched.h>
23 #include <linux/file.h>
24 #include <linux/signal.h>
25 #include <linux/resource.h>
26 #include <linux/times.h>
27 #include <linux/utsname.h>
28 #include <linux/smp.h>
29 #include <linux/smp_lock.h>
30 #include <linux/sem.h>
31 #include <linux/msg.h>
32 #include <linux/shm.h>
33 #include <linux/slab.h>
34 #include <linux/uio.h>
35 #include <linux/nfs_fs.h>
36 #include <linux/quota.h>
37 #include <linux/module.h>
38 #include <linux/sunrpc/svc.h>
39 #include <linux/nfsd/nfsd.h>
40 #include <linux/nfsd/cache.h>
41 #include <linux/nfsd/xdr.h>
42 #include <linux/nfsd/syscall.h>
43 #include <linux/poll.h>
44 #include <linux/personality.h>
45 #include <linux/stat.h>
46 #include <linux/filter.h>
47 #include <linux/highmem.h>
48 #include <linux/highuid.h>
49 #include <linux/mman.h>
50 #include <linux/ipv6.h>
52 #include <linux/icmpv6.h>
53 #include <linux/syscalls.h>
54 #include <linux/sysctl.h>
55 #include <linux/binfmts.h>
56 #include <linux/capability.h>
57 #include <linux/compat.h>
58 #include <linux/vfs.h>
59 #include <linux/ptrace.h>
60 #include <linux/fadvise.h>
62 #include <asm/types.h>
64 #include <asm/uaccess.h>
65 #include <asm/semaphore.h>
70 #include "compat_linux.h"
73 /* For this source file, we want overflow handling. */
83 #undef SET_OLDSTAT_UID
84 #undef SET_OLDSTAT_GID
88 #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid)
89 #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid)
90 #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid)
91 #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid)
92 #define SET_UID16(var, uid) var = high2lowuid(uid)
93 #define SET_GID16(var, gid) var = high2lowgid(gid)
94 #define NEW_TO_OLD_UID(uid) high2lowuid(uid)
95 #define NEW_TO_OLD_GID(gid) high2lowgid(gid)
96 #define SET_OLDSTAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid)
97 #define SET_OLDSTAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid)
98 #define SET_STAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid)
99 #define SET_STAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid)
101 asmlinkage
long sys32_chown16(const char __user
* filename
, u16 user
, u16 group
)
103 return sys_chown(filename
, low2highuid(user
), low2highgid(group
));
106 asmlinkage
long sys32_lchown16(const char __user
* filename
, u16 user
, u16 group
)
108 return sys_lchown(filename
, low2highuid(user
), low2highgid(group
));
111 asmlinkage
long sys32_fchown16(unsigned int fd
, u16 user
, u16 group
)
113 return sys_fchown(fd
, low2highuid(user
), low2highgid(group
));
116 asmlinkage
long sys32_setregid16(u16 rgid
, u16 egid
)
118 return sys_setregid(low2highgid(rgid
), low2highgid(egid
));
121 asmlinkage
long sys32_setgid16(u16 gid
)
123 return sys_setgid((gid_t
)gid
);
126 asmlinkage
long sys32_setreuid16(u16 ruid
, u16 euid
)
128 return sys_setreuid(low2highuid(ruid
), low2highuid(euid
));
131 asmlinkage
long sys32_setuid16(u16 uid
)
133 return sys_setuid((uid_t
)uid
);
136 asmlinkage
long sys32_setresuid16(u16 ruid
, u16 euid
, u16 suid
)
138 return sys_setresuid(low2highuid(ruid
), low2highuid(euid
),
142 asmlinkage
long sys32_getresuid16(u16 __user
*ruid
, u16 __user
*euid
, u16 __user
*suid
)
146 if (!(retval
= put_user(high2lowuid(current
->uid
), ruid
)) &&
147 !(retval
= put_user(high2lowuid(current
->euid
), euid
)))
148 retval
= put_user(high2lowuid(current
->suid
), suid
);
153 asmlinkage
long sys32_setresgid16(u16 rgid
, u16 egid
, u16 sgid
)
155 return sys_setresgid(low2highgid(rgid
), low2highgid(egid
),
159 asmlinkage
long sys32_getresgid16(u16 __user
*rgid
, u16 __user
*egid
, u16 __user
*sgid
)
163 if (!(retval
= put_user(high2lowgid(current
->gid
), rgid
)) &&
164 !(retval
= put_user(high2lowgid(current
->egid
), egid
)))
165 retval
= put_user(high2lowgid(current
->sgid
), sgid
);
170 asmlinkage
long sys32_setfsuid16(u16 uid
)
172 return sys_setfsuid((uid_t
)uid
);
175 asmlinkage
long sys32_setfsgid16(u16 gid
)
177 return sys_setfsgid((gid_t
)gid
);
180 static int groups16_to_user(u16 __user
*grouplist
, struct group_info
*group_info
)
185 for (i
= 0; i
< group_info
->ngroups
; i
++) {
186 group
= (u16
)GROUP_AT(group_info
, i
);
187 if (put_user(group
, grouplist
+i
))
194 static int groups16_from_user(struct group_info
*group_info
, u16 __user
*grouplist
)
199 for (i
= 0; i
< group_info
->ngroups
; i
++) {
200 if (get_user(group
, grouplist
+i
))
202 GROUP_AT(group_info
, i
) = (gid_t
)group
;
208 asmlinkage
long sys32_getgroups16(int gidsetsize
, u16 __user
*grouplist
)
215 get_group_info(current
->group_info
);
216 i
= current
->group_info
->ngroups
;
218 if (i
> gidsetsize
) {
222 if (groups16_to_user(grouplist
, current
->group_info
)) {
228 put_group_info(current
->group_info
);
232 asmlinkage
long sys32_setgroups16(int gidsetsize
, u16 __user
*grouplist
)
234 struct group_info
*group_info
;
237 if (!capable(CAP_SETGID
))
239 if ((unsigned)gidsetsize
> NGROUPS_MAX
)
242 group_info
= groups_alloc(gidsetsize
);
245 retval
= groups16_from_user(group_info
, grouplist
);
247 put_group_info(group_info
);
251 retval
= set_current_groups(group_info
);
252 put_group_info(group_info
);
257 asmlinkage
long sys32_getuid16(void)
259 return high2lowuid(current
->uid
);
262 asmlinkage
long sys32_geteuid16(void)
264 return high2lowuid(current
->euid
);
267 asmlinkage
long sys32_getgid16(void)
269 return high2lowgid(current
->gid
);
272 asmlinkage
long sys32_getegid16(void)
274 return high2lowgid(current
->egid
);
277 /* 32-bit timeval and related flotsam. */
279 static inline long get_tv32(struct timeval
*o
, struct compat_timeval __user
*i
)
281 return (!access_ok(VERIFY_READ
, o
, sizeof(*o
)) ||
282 (__get_user(o
->tv_sec
, &i
->tv_sec
) ||
283 __get_user(o
->tv_usec
, &i
->tv_usec
)));
286 static inline long put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
288 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
289 (__put_user(i
->tv_sec
, &o
->tv_sec
) ||
290 __put_user(i
->tv_usec
, &o
->tv_usec
)));
294 * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation.
296 * This is really horribly ugly.
298 #ifdef CONFIG_SYSVIPC
299 asmlinkage
long sys32_ipc(u32 call
, int first
, int second
, int third
, u32 ptr
)
301 if (call
>> 16) /* hack for backward compatibility */
308 return compat_sys_semtimedop(first
, compat_ptr(ptr
),
309 second
, compat_ptr(third
));
311 /* struct sembuf is the same on 32 and 64bit :)) */
312 return sys_semtimedop(first
, compat_ptr(ptr
),
315 return sys_semget(first
, second
, third
);
317 return compat_sys_semctl(first
, second
, third
,
320 return compat_sys_msgsnd(first
, second
, third
,
323 return compat_sys_msgrcv(first
, second
, 0, third
,
326 return sys_msgget((key_t
) first
, second
);
328 return compat_sys_msgctl(first
, second
, compat_ptr(ptr
));
330 return compat_sys_shmat(first
, second
, third
,
333 return sys_shmdt(compat_ptr(ptr
));
335 return sys_shmget(first
, (unsigned)second
, third
);
337 return compat_sys_shmctl(first
, second
, compat_ptr(ptr
));
344 asmlinkage
long sys32_truncate64(const char __user
* path
, unsigned long high
, unsigned long low
)
349 return sys_truncate(path
, (high
<< 32) | low
);
352 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long high
, unsigned long low
)
357 return sys_ftruncate(fd
, (high
<< 32) | low
);
360 int cp_compat_stat(struct kstat
*stat
, struct compat_stat __user
*statbuf
)
365 if (!old_valid_dev(stat
->dev
) || !old_valid_dev(stat
->rdev
))
369 if (sizeof(ino
) < sizeof(stat
->ino
) && ino
!= stat
->ino
)
372 err
= put_user(old_encode_dev(stat
->dev
), &statbuf
->st_dev
);
373 err
|= put_user(stat
->ino
, &statbuf
->st_ino
);
374 err
|= put_user(stat
->mode
, &statbuf
->st_mode
);
375 err
|= put_user(stat
->nlink
, &statbuf
->st_nlink
);
376 err
|= put_user(high2lowuid(stat
->uid
), &statbuf
->st_uid
);
377 err
|= put_user(high2lowgid(stat
->gid
), &statbuf
->st_gid
);
378 err
|= put_user(old_encode_dev(stat
->rdev
), &statbuf
->st_rdev
);
379 err
|= put_user(stat
->size
, &statbuf
->st_size
);
380 err
|= put_user(stat
->atime
.tv_sec
, &statbuf
->st_atime
);
381 err
|= put_user(stat
->atime
.tv_nsec
, &statbuf
->st_atime_nsec
);
382 err
|= put_user(stat
->mtime
.tv_sec
, &statbuf
->st_mtime
);
383 err
|= put_user(stat
->mtime
.tv_nsec
, &statbuf
->st_mtime_nsec
);
384 err
|= put_user(stat
->ctime
.tv_sec
, &statbuf
->st_ctime
);
385 err
|= put_user(stat
->ctime
.tv_nsec
, &statbuf
->st_ctime_nsec
);
386 err
|= put_user(stat
->blksize
, &statbuf
->st_blksize
);
387 err
|= put_user(stat
->blocks
, &statbuf
->st_blocks
);
389 err |= put_user(0, &statbuf->__unused4[0]);
390 err |= put_user(0, &statbuf->__unused4[1]);
404 unsigned short procs
;
408 unsigned int mem_unit
;
412 asmlinkage
long sys32_sysinfo(struct sysinfo32 __user
*info
)
416 mm_segment_t old_fs
= get_fs ();
419 ret
= sys_sysinfo((struct sysinfo __force __user
*) &s
);
421 err
= put_user (s
.uptime
, &info
->uptime
);
422 err
|= __put_user (s
.loads
[0], &info
->loads
[0]);
423 err
|= __put_user (s
.loads
[1], &info
->loads
[1]);
424 err
|= __put_user (s
.loads
[2], &info
->loads
[2]);
425 err
|= __put_user (s
.totalram
, &info
->totalram
);
426 err
|= __put_user (s
.freeram
, &info
->freeram
);
427 err
|= __put_user (s
.sharedram
, &info
->sharedram
);
428 err
|= __put_user (s
.bufferram
, &info
->bufferram
);
429 err
|= __put_user (s
.totalswap
, &info
->totalswap
);
430 err
|= __put_user (s
.freeswap
, &info
->freeswap
);
431 err
|= __put_user (s
.procs
, &info
->procs
);
432 err
|= __put_user (s
.totalhigh
, &info
->totalhigh
);
433 err
|= __put_user (s
.freehigh
, &info
->freehigh
);
434 err
|= __put_user (s
.mem_unit
, &info
->mem_unit
);
440 asmlinkage
long sys32_sched_rr_get_interval(compat_pid_t pid
,
441 struct compat_timespec __user
*interval
)
445 mm_segment_t old_fs
= get_fs ();
448 ret
= sys_sched_rr_get_interval(pid
,
449 (struct timespec __force __user
*) &t
);
451 if (put_compat_timespec(&t
, interval
))
456 asmlinkage
long sys32_rt_sigprocmask(int how
, compat_sigset_t __user
*set
,
457 compat_sigset_t __user
*oset
, size_t sigsetsize
)
462 mm_segment_t old_fs
= get_fs();
465 if (copy_from_user (&s32
, set
, sizeof(compat_sigset_t
)))
467 switch (_NSIG_WORDS
) {
468 case 4: s
.sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
469 case 3: s
.sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
470 case 2: s
.sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
471 case 1: s
.sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
475 ret
= sys_rt_sigprocmask(how
,
476 set
? (sigset_t __force __user
*) &s
: NULL
,
477 oset
? (sigset_t __force __user
*) &s
: NULL
,
482 switch (_NSIG_WORDS
) {
483 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
484 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
485 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
486 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
488 if (copy_to_user (oset
, &s32
, sizeof(compat_sigset_t
)))
494 asmlinkage
long sys32_rt_sigpending(compat_sigset_t __user
*set
,
500 mm_segment_t old_fs
= get_fs();
503 ret
= sys_rt_sigpending((sigset_t __force __user
*) &s
, sigsetsize
);
506 switch (_NSIG_WORDS
) {
507 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
508 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
509 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
510 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
512 if (copy_to_user (set
, &s32
, sizeof(compat_sigset_t
)))
519 sys32_rt_sigqueueinfo(int pid
, int sig
, compat_siginfo_t __user
*uinfo
)
523 mm_segment_t old_fs
= get_fs();
525 if (copy_siginfo_from_user32(&info
, uinfo
))
528 ret
= sys_rt_sigqueueinfo(pid
, sig
, (siginfo_t __force __user
*) &info
);
534 * sys32_execve() executes a new program after the asm stub has set
535 * things up for us. This should basically do what I want it to.
538 sys32_execve(struct pt_regs regs
)
543 filename
= getname(compat_ptr(regs
.orig_gpr2
));
544 error
= PTR_ERR(filename
);
545 if (IS_ERR(filename
))
547 error
= compat_do_execve(filename
, compat_ptr(regs
.gprs
[3]),
548 compat_ptr(regs
.gprs
[4]), ®s
);
552 current
->ptrace
&= ~PT_DTRACE
;
553 task_unlock(current
);
554 current
->thread
.fp_regs
.fpc
=0;
555 asm volatile("sfpc %0,0" : : "d" (0));
563 #ifdef CONFIG_MODULES
566 sys32_init_module(void __user
*umod
, unsigned long len
,
567 const char __user
*uargs
)
569 return sys_init_module(umod
, len
, uargs
);
573 sys32_delete_module(const char __user
*name_user
, unsigned int flags
)
575 return sys_delete_module(name_user
, flags
);
578 #else /* CONFIG_MODULES */
581 sys32_init_module(void __user
*umod
, unsigned long len
,
582 const char __user
*uargs
)
588 sys32_delete_module(const char __user
*name_user
, unsigned int flags
)
593 #endif /* CONFIG_MODULES */
595 /* Translations due to time_t size differences. Which affects all
596 sorts of things, like timeval and itimerval. */
598 extern struct timezone sys_tz
;
600 asmlinkage
long sys32_gettimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
604 do_gettimeofday(&ktv
);
605 if (put_tv32(tv
, &ktv
))
609 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
615 static inline long get_ts32(struct timespec
*o
, struct compat_timeval __user
*i
)
619 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
621 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
623 if (__get_user(usec
, &i
->tv_usec
))
625 o
->tv_nsec
= usec
* 1000;
629 asmlinkage
long sys32_settimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
635 if (get_ts32(&kts
, tv
))
639 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
643 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
646 /* These are here just in case some old sparc32 binary calls it. */
647 asmlinkage
long sys32_pause(void)
649 current
->state
= TASK_INTERRUPTIBLE
;
651 return -ERESTARTNOHAND
;
654 asmlinkage
long sys32_pread64(unsigned int fd
, char __user
*ubuf
,
655 size_t count
, u32 poshi
, u32 poslo
)
657 if ((compat_ssize_t
) count
< 0)
659 return sys_pread64(fd
, ubuf
, count
, ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
662 asmlinkage
long sys32_pwrite64(unsigned int fd
, const char __user
*ubuf
,
663 size_t count
, u32 poshi
, u32 poslo
)
665 if ((compat_ssize_t
) count
< 0)
667 return sys_pwrite64(fd
, ubuf
, count
, ((loff_t
)AA(poshi
) << 32) | AA(poslo
));
670 asmlinkage compat_ssize_t
sys32_readahead(int fd
, u32 offhi
, u32 offlo
, s32 count
)
672 return sys_readahead(fd
, ((loff_t
)AA(offhi
) << 32) | AA(offlo
), count
);
675 asmlinkage
long sys32_sendfile(int out_fd
, int in_fd
, compat_off_t __user
*offset
, size_t count
)
677 mm_segment_t old_fs
= get_fs();
681 if (offset
&& get_user(of
, offset
))
685 ret
= sys_sendfile(out_fd
, in_fd
,
686 offset
? (off_t __force __user
*) &of
: NULL
, count
);
689 if (offset
&& put_user(of
, offset
))
695 asmlinkage
long sys32_sendfile64(int out_fd
, int in_fd
,
696 compat_loff_t __user
*offset
, s32 count
)
698 mm_segment_t old_fs
= get_fs();
702 if (offset
&& get_user(lof
, offset
))
706 ret
= sys_sendfile64(out_fd
, in_fd
,
707 offset
? (loff_t __force __user
*) &lof
: NULL
,
711 if (offset
&& put_user(lof
, offset
))
717 #ifdef CONFIG_SYSCTL_SYSCALL
718 struct __sysctl_args32
{
728 asmlinkage
long sys32_sysctl(struct __sysctl_args32 __user
*args
)
730 struct __sysctl_args32 tmp
;
733 size_t __user
*oldlenp
= NULL
;
734 unsigned long addr
= (((unsigned long)&args
->__unused
[0]) + 7) & ~7;
736 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
739 if (tmp
.oldval
&& tmp
.oldlenp
) {
740 /* Duh, this is ugly and might not work if sysctl_args
741 is in read-only memory, but do_sysctl does indirectly
742 a lot of uaccess in both directions and we'd have to
743 basically copy the whole sysctl.c here, and
744 glibc's __sysctl uses rw memory for the structure
746 if (get_user(oldlen
, (u32 __user
*)compat_ptr(tmp
.oldlenp
)) ||
747 put_user(oldlen
, (size_t __user
*)addr
))
749 oldlenp
= (size_t __user
*)addr
;
753 error
= do_sysctl(compat_ptr(tmp
.name
), tmp
.nlen
, compat_ptr(tmp
.oldval
),
754 oldlenp
, compat_ptr(tmp
.newval
), tmp
.newlen
);
758 if (get_user(oldlen
, (size_t __user
*)addr
) ||
759 put_user(oldlen
, (u32 __user
*)compat_ptr(tmp
.oldlenp
)))
762 if (copy_to_user(args
->__unused
, tmp
.__unused
,
763 sizeof(tmp
.__unused
)))
770 struct stat64_emu31
{
771 unsigned long long st_dev
;
773 #define STAT64_HAS_BROKEN_ST_INO 1
775 unsigned int st_mode
;
776 unsigned int st_nlink
;
779 unsigned long long st_rdev
;
783 unsigned char __pad4
[4];
784 u32 __pad5
; /* future possible st_blocks high bits */
785 u32 st_blocks
; /* Number 512-byte blocks allocated. */
791 u32 __pad8
; /* will be high 32 bits of ctime someday */
792 unsigned long st_ino
;
795 static int cp_stat64(struct stat64_emu31 __user
*ubuf
, struct kstat
*stat
)
797 struct stat64_emu31 tmp
;
799 memset(&tmp
, 0, sizeof(tmp
));
801 tmp
.st_dev
= huge_encode_dev(stat
->dev
);
802 tmp
.st_ino
= stat
->ino
;
803 tmp
.__st_ino
= (u32
)stat
->ino
;
804 tmp
.st_mode
= stat
->mode
;
805 tmp
.st_nlink
= (unsigned int)stat
->nlink
;
806 tmp
.st_uid
= stat
->uid
;
807 tmp
.st_gid
= stat
->gid
;
808 tmp
.st_rdev
= huge_encode_dev(stat
->rdev
);
809 tmp
.st_size
= stat
->size
;
810 tmp
.st_blksize
= (u32
)stat
->blksize
;
811 tmp
.st_blocks
= (u32
)stat
->blocks
;
812 tmp
.st_atime
= (u32
)stat
->atime
.tv_sec
;
813 tmp
.st_mtime
= (u32
)stat
->mtime
.tv_sec
;
814 tmp
.st_ctime
= (u32
)stat
->ctime
.tv_sec
;
816 return copy_to_user(ubuf
,&tmp
,sizeof(tmp
)) ? -EFAULT
: 0;
819 asmlinkage
long sys32_stat64(char __user
* filename
, struct stat64_emu31 __user
* statbuf
)
822 int ret
= vfs_stat(filename
, &stat
);
824 ret
= cp_stat64(statbuf
, &stat
);
828 asmlinkage
long sys32_lstat64(char __user
* filename
, struct stat64_emu31 __user
* statbuf
)
831 int ret
= vfs_lstat(filename
, &stat
);
833 ret
= cp_stat64(statbuf
, &stat
);
837 asmlinkage
long sys32_fstat64(unsigned long fd
, struct stat64_emu31 __user
* statbuf
)
840 int ret
= vfs_fstat(fd
, &stat
);
842 ret
= cp_stat64(statbuf
, &stat
);
846 asmlinkage
long sys32_fstatat64(unsigned int dfd
, char __user
*filename
,
847 struct stat64_emu31 __user
* statbuf
, int flag
)
852 if ((flag
& ~AT_SYMLINK_NOFOLLOW
) != 0)
855 if (flag
& AT_SYMLINK_NOFOLLOW
)
856 error
= vfs_lstat_fd(dfd
, filename
, &stat
);
858 error
= vfs_stat_fd(dfd
, filename
, &stat
);
861 error
= cp_stat64(statbuf
, &stat
);
867 * Linux/i386 didn't use to be able to handle more than
868 * 4 system call parameters, so these system calls used a memory
869 * block for parameter passing..
872 struct mmap_arg_struct_emu31
{
881 /* common code for old and new mmaps */
882 static inline long do_mmap2(
883 unsigned long addr
, unsigned long len
,
884 unsigned long prot
, unsigned long flags
,
885 unsigned long fd
, unsigned long pgoff
)
887 struct file
* file
= NULL
;
888 unsigned long error
= -EBADF
;
890 flags
&= ~(MAP_EXECUTABLE
| MAP_DENYWRITE
);
891 if (!(flags
& MAP_ANONYMOUS
)) {
897 down_write(¤t
->mm
->mmap_sem
);
898 error
= do_mmap_pgoff(file
, addr
, len
, prot
, flags
, pgoff
);
899 if (!IS_ERR((void *) error
) && error
+ len
>= 0x80000000ULL
) {
900 /* Result is out of bounds. */
901 do_munmap(current
->mm
, addr
, len
);
904 up_write(¤t
->mm
->mmap_sem
);
913 asmlinkage
unsigned long
914 old32_mmap(struct mmap_arg_struct_emu31 __user
*arg
)
916 struct mmap_arg_struct_emu31 a
;
919 if (copy_from_user(&a
, arg
, sizeof(a
)))
923 if (a
.offset
& ~PAGE_MASK
)
926 error
= do_mmap2(a
.addr
, a
.len
, a
.prot
, a
.flags
, a
.fd
, a
.offset
>> PAGE_SHIFT
);
932 sys32_mmap2(struct mmap_arg_struct_emu31 __user
*arg
)
934 struct mmap_arg_struct_emu31 a
;
937 if (copy_from_user(&a
, arg
, sizeof(a
)))
939 error
= do_mmap2(a
.addr
, a
.len
, a
.prot
, a
.flags
, a
.fd
, a
.offset
);
944 asmlinkage
long sys32_read(unsigned int fd
, char __user
* buf
, size_t count
)
946 if ((compat_ssize_t
) count
< 0)
949 return sys_read(fd
, buf
, count
);
952 asmlinkage
long sys32_write(unsigned int fd
, char __user
* buf
, size_t count
)
954 if ((compat_ssize_t
) count
< 0)
957 return sys_write(fd
, buf
, count
);
960 asmlinkage
long sys32_clone(struct pt_regs regs
)
962 unsigned long clone_flags
;
964 int __user
*parent_tidptr
, *child_tidptr
;
966 clone_flags
= regs
.gprs
[3] & 0xffffffffUL
;
967 newsp
= regs
.orig_gpr2
& 0x7fffffffUL
;
968 parent_tidptr
= compat_ptr(regs
.gprs
[4]);
969 child_tidptr
= compat_ptr(regs
.gprs
[5]);
971 newsp
= regs
.gprs
[15];
972 return do_fork(clone_flags
, newsp
, ®s
, 0,
973 parent_tidptr
, child_tidptr
);
977 * 31 bit emulation wrapper functions for sys_fadvise64/fadvise64_64.
978 * These need to rewrite the advise values for POSIX_FADV_{DONTNEED,NOREUSE}
979 * because the 31 bit values differ from the 64 bit values.
983 sys32_fadvise64(int fd
, loff_t offset
, size_t len
, int advise
)
986 advise
= POSIX_FADV_DONTNEED
;
987 else if (advise
== 5)
988 advise
= POSIX_FADV_NOREUSE
;
989 return sys_fadvise64(fd
, offset
, len
, advise
);
992 struct fadvise64_64_args
{
1000 sys32_fadvise64_64(struct fadvise64_64_args __user
*args
)
1002 struct fadvise64_64_args a
;
1004 if ( copy_from_user(&a
, args
, sizeof(a
)) )
1007 a
.advice
= POSIX_FADV_DONTNEED
;
1008 else if (a
.advice
== 5)
1009 a
.advice
= POSIX_FADV_NOREUSE
;
1010 return sys_fadvise64_64(a
.fd
, a
.offset
, a
.len
, a
.advice
);