1 /* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
3 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
4 * Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net)
6 * These routines maintain argument size conversion between 32bit and 64bit
10 #include <linux/kernel.h>
11 #include <linux/sched.h>
12 #include <linux/capability.h>
15 #include <linux/file.h>
16 #include <linux/signal.h>
17 #include <linux/resource.h>
18 #include <linux/times.h>
19 #include <linux/utsname.h>
20 #include <linux/smp.h>
21 #include <linux/smp_lock.h>
22 #include <linux/sem.h>
23 #include <linux/msg.h>
24 #include <linux/shm.h>
25 #include <linux/slab.h>
26 #include <linux/uio.h>
27 #include <linux/nfs_fs.h>
28 #include <linux/quota.h>
29 #include <linux/module.h>
30 #include <linux/sunrpc/svc.h>
31 #include <linux/nfsd/nfsd.h>
32 #include <linux/nfsd/cache.h>
33 #include <linux/nfsd/xdr.h>
34 #include <linux/nfsd/syscall.h>
35 #include <linux/poll.h>
36 #include <linux/personality.h>
37 #include <linux/stat.h>
38 #include <linux/filter.h>
39 #include <linux/highmem.h>
40 #include <linux/highuid.h>
41 #include <linux/mman.h>
42 #include <linux/ipv6.h>
44 #include <linux/icmpv6.h>
45 #include <linux/syscalls.h>
46 #include <linux/sysctl.h>
47 #include <linux/binfmts.h>
48 #include <linux/dnotify.h>
49 #include <linux/security.h>
50 #include <linux/compat.h>
51 #include <linux/vfs.h>
52 #include <linux/netfilter_ipv4/ip_tables.h>
53 #include <linux/ptrace.h>
55 #include <asm/types.h>
56 #include <asm/uaccess.h>
57 #include <asm/fpumacro.h>
58 #include <asm/mmu_context.h>
59 #include <asm/compat_signal.h>
61 /* 32-bit timeval and related flotsam. */
63 static inline long put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
65 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
66 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
67 __put_user(i
->tv_usec
, &o
->tv_usec
)));
71 asmlinkage
long compat_sys_ipc(u32 call
, u32 first
, u32 second
, u32 third
, compat_uptr_t ptr
, u32 fifth
)
75 version
= call
>> 16; /* hack for backward compatibility */
81 /* sign extend semid */
82 return compat_sys_semtimedop((int)first
,
83 compat_ptr(ptr
), second
,
85 /* else fall through for normal semop() */
87 /* struct sembuf is the same on 32 and 64bit :)) */
88 /* sign extend semid */
89 return sys_semtimedop((int)first
, compat_ptr(ptr
), second
,
92 /* sign extend key, nsems */
93 return sys_semget((int)first
, (int)second
, third
);
95 /* sign extend semid, semnum */
96 return compat_sys_semctl((int)first
, (int)second
, third
,
100 /* sign extend msqid */
101 return compat_sys_msgsnd((int)first
, (int)second
, third
,
104 /* sign extend msqid, msgtyp */
105 return compat_sys_msgrcv((int)first
, second
, (int)fifth
,
106 third
, version
, compat_ptr(ptr
));
108 /* sign extend key */
109 return sys_msgget((int)first
, second
);
111 /* sign extend msqid */
112 return compat_sys_msgctl((int)first
, second
, compat_ptr(ptr
));
115 /* sign extend shmid */
116 return compat_sys_shmat((int)first
, second
, third
, version
,
119 return sys_shmdt(compat_ptr(ptr
));
121 /* sign extend key_t */
122 return sys_shmget((int)first
, second
, third
);
124 /* sign extend shmid */
125 return compat_sys_shmctl((int)first
, second
, compat_ptr(ptr
));
135 asmlinkage
long sys32_truncate64(const char __user
* path
, unsigned long high
, unsigned long low
)
140 return sys_truncate(path
, (high
<< 32) | low
);
143 asmlinkage
long sys32_ftruncate64(unsigned int fd
, unsigned long high
, unsigned long low
)
148 return sys_ftruncate(fd
, (high
<< 32) | low
);
151 int cp_compat_stat(struct kstat
*stat
, struct compat_stat __user
*statbuf
)
156 if (stat
->size
> MAX_NON_LFS
|| !old_valid_dev(stat
->dev
) ||
157 !old_valid_dev(stat
->rdev
))
161 if (sizeof(ino
) < sizeof(stat
->ino
) && ino
!= stat
->ino
)
164 err
= put_user(old_encode_dev(stat
->dev
), &statbuf
->st_dev
);
165 err
|= put_user(stat
->ino
, &statbuf
->st_ino
);
166 err
|= put_user(stat
->mode
, &statbuf
->st_mode
);
167 err
|= put_user(stat
->nlink
, &statbuf
->st_nlink
);
168 err
|= put_user(high2lowuid(stat
->uid
), &statbuf
->st_uid
);
169 err
|= put_user(high2lowgid(stat
->gid
), &statbuf
->st_gid
);
170 err
|= put_user(old_encode_dev(stat
->rdev
), &statbuf
->st_rdev
);
171 err
|= put_user(stat
->size
, &statbuf
->st_size
);
172 err
|= put_user(stat
->atime
.tv_sec
, &statbuf
->st_atime
);
173 err
|= put_user(stat
->atime
.tv_nsec
, &statbuf
->st_atime_nsec
);
174 err
|= put_user(stat
->mtime
.tv_sec
, &statbuf
->st_mtime
);
175 err
|= put_user(stat
->mtime
.tv_nsec
, &statbuf
->st_mtime_nsec
);
176 err
|= put_user(stat
->ctime
.tv_sec
, &statbuf
->st_ctime
);
177 err
|= put_user(stat
->ctime
.tv_nsec
, &statbuf
->st_ctime_nsec
);
178 err
|= put_user(stat
->blksize
, &statbuf
->st_blksize
);
179 err
|= put_user(stat
->blocks
, &statbuf
->st_blocks
);
180 err
|= put_user(0, &statbuf
->__unused4
[0]);
181 err
|= put_user(0, &statbuf
->__unused4
[1]);
186 static int cp_compat_stat64(struct kstat
*stat
,
187 struct compat_stat64 __user
*statbuf
)
191 err
= put_user(huge_encode_dev(stat
->dev
), &statbuf
->st_dev
);
192 err
|= put_user(stat
->ino
, &statbuf
->st_ino
);
193 err
|= put_user(stat
->mode
, &statbuf
->st_mode
);
194 err
|= put_user(stat
->nlink
, &statbuf
->st_nlink
);
195 err
|= put_user(stat
->uid
, &statbuf
->st_uid
);
196 err
|= put_user(stat
->gid
, &statbuf
->st_gid
);
197 err
|= put_user(huge_encode_dev(stat
->rdev
), &statbuf
->st_rdev
);
198 err
|= put_user(0, (unsigned long __user
*) &statbuf
->__pad3
[0]);
199 err
|= put_user(stat
->size
, &statbuf
->st_size
);
200 err
|= put_user(stat
->blksize
, &statbuf
->st_blksize
);
201 err
|= put_user(0, (unsigned int __user
*) &statbuf
->__pad4
[0]);
202 err
|= put_user(0, (unsigned int __user
*) &statbuf
->__pad4
[4]);
203 err
|= put_user(stat
->blocks
, &statbuf
->st_blocks
);
204 err
|= put_user(stat
->atime
.tv_sec
, &statbuf
->st_atime
);
205 err
|= put_user(stat
->atime
.tv_nsec
, &statbuf
->st_atime_nsec
);
206 err
|= put_user(stat
->mtime
.tv_sec
, &statbuf
->st_mtime
);
207 err
|= put_user(stat
->mtime
.tv_nsec
, &statbuf
->st_mtime_nsec
);
208 err
|= put_user(stat
->ctime
.tv_sec
, &statbuf
->st_ctime
);
209 err
|= put_user(stat
->ctime
.tv_nsec
, &statbuf
->st_ctime_nsec
);
210 err
|= put_user(0, &statbuf
->__unused4
);
211 err
|= put_user(0, &statbuf
->__unused5
);
216 asmlinkage
long compat_sys_stat64(char __user
* filename
,
217 struct compat_stat64 __user
*statbuf
)
220 int error
= vfs_stat(filename
, &stat
);
223 error
= cp_compat_stat64(&stat
, statbuf
);
227 asmlinkage
long compat_sys_lstat64(char __user
* filename
,
228 struct compat_stat64 __user
*statbuf
)
231 int error
= vfs_lstat(filename
, &stat
);
234 error
= cp_compat_stat64(&stat
, statbuf
);
238 asmlinkage
long compat_sys_fstat64(unsigned int fd
,
239 struct compat_stat64 __user
* statbuf
)
242 int error
= vfs_fstat(fd
, &stat
);
245 error
= cp_compat_stat64(&stat
, statbuf
);
249 asmlinkage
long compat_sys_fstatat64(unsigned int dfd
, char __user
*filename
,
250 struct compat_stat64 __user
* statbuf
, int flag
)
255 if ((flag
& ~AT_SYMLINK_NOFOLLOW
) != 0)
258 if (flag
& AT_SYMLINK_NOFOLLOW
)
259 error
= vfs_lstat_fd(dfd
, filename
, &stat
);
261 error
= vfs_stat_fd(dfd
, filename
, &stat
);
264 error
= cp_compat_stat64(&stat
, statbuf
);
270 asmlinkage
long compat_sys_sysfs(int option
, u32 arg1
, u32 arg2
)
272 return sys_sysfs(option
, arg1
, arg2
);
275 asmlinkage
long compat_sys_sched_rr_get_interval(compat_pid_t pid
, struct compat_timespec __user
*interval
)
279 mm_segment_t old_fs
= get_fs ();
282 ret
= sys_sched_rr_get_interval(pid
, (struct timespec __user
*) &t
);
284 if (put_compat_timespec(&t
, interval
))
289 asmlinkage
long compat_sys_rt_sigprocmask(int how
,
290 compat_sigset_t __user
*set
,
291 compat_sigset_t __user
*oset
,
292 compat_size_t sigsetsize
)
297 mm_segment_t old_fs
= get_fs();
300 if (copy_from_user (&s32
, set
, sizeof(compat_sigset_t
)))
302 switch (_NSIG_WORDS
) {
303 case 4: s
.sig
[3] = s32
.sig
[6] | (((long)s32
.sig
[7]) << 32);
304 case 3: s
.sig
[2] = s32
.sig
[4] | (((long)s32
.sig
[5]) << 32);
305 case 2: s
.sig
[1] = s32
.sig
[2] | (((long)s32
.sig
[3]) << 32);
306 case 1: s
.sig
[0] = s32
.sig
[0] | (((long)s32
.sig
[1]) << 32);
310 ret
= sys_rt_sigprocmask(how
,
311 set
? (sigset_t __user
*) &s
: NULL
,
312 oset
? (sigset_t __user
*) &s
: NULL
,
317 switch (_NSIG_WORDS
) {
318 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
319 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
320 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
321 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
323 if (copy_to_user (oset
, &s32
, sizeof(compat_sigset_t
)))
329 asmlinkage
long sys32_rt_sigpending(compat_sigset_t __user
*set
,
330 compat_size_t sigsetsize
)
335 mm_segment_t old_fs
= get_fs();
338 ret
= sys_rt_sigpending((sigset_t __user
*) &s
, sigsetsize
);
341 switch (_NSIG_WORDS
) {
342 case 4: s32
.sig
[7] = (s
.sig
[3] >> 32); s32
.sig
[6] = s
.sig
[3];
343 case 3: s32
.sig
[5] = (s
.sig
[2] >> 32); s32
.sig
[4] = s
.sig
[2];
344 case 2: s32
.sig
[3] = (s
.sig
[1] >> 32); s32
.sig
[2] = s
.sig
[1];
345 case 1: s32
.sig
[1] = (s
.sig
[0] >> 32); s32
.sig
[0] = s
.sig
[0];
347 if (copy_to_user (set
, &s32
, sizeof(compat_sigset_t
)))
353 asmlinkage
long compat_sys_rt_sigqueueinfo(int pid
, int sig
,
354 struct compat_siginfo __user
*uinfo
)
358 mm_segment_t old_fs
= get_fs();
360 if (copy_siginfo_from_user32(&info
, uinfo
))
364 ret
= sys_rt_sigqueueinfo(pid
, sig
, (siginfo_t __user
*) &info
);
369 asmlinkage
long compat_sys_sigaction(int sig
, struct old_sigaction32 __user
*act
,
370 struct old_sigaction32 __user
*oact
)
372 struct k_sigaction new_ka
, old_ka
;
375 WARN_ON_ONCE(sig
>= 0);
379 compat_old_sigset_t mask
;
380 u32 u_handler
, u_restorer
;
382 ret
= get_user(u_handler
, &act
->sa_handler
);
383 new_ka
.sa
.sa_handler
= compat_ptr(u_handler
);
384 ret
|= __get_user(u_restorer
, &act
->sa_restorer
);
385 new_ka
.sa
.sa_restorer
= compat_ptr(u_restorer
);
386 ret
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
387 ret
|= __get_user(mask
, &act
->sa_mask
);
390 new_ka
.ka_restorer
= NULL
;
391 siginitset(&new_ka
.sa
.sa_mask
, mask
);
394 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
397 ret
= put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
);
398 ret
|= __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
);
399 ret
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
400 ret
|= __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
406 asmlinkage
long compat_sys_rt_sigaction(int sig
,
407 struct sigaction32 __user
*act
,
408 struct sigaction32 __user
*oact
,
409 void __user
*restorer
,
410 compat_size_t sigsetsize
)
412 struct k_sigaction new_ka
, old_ka
;
414 compat_sigset_t set32
;
416 /* XXX: Don't preclude handling different sized sigset_t's. */
417 if (sigsetsize
!= sizeof(compat_sigset_t
))
421 u32 u_handler
, u_restorer
;
423 new_ka
.ka_restorer
= restorer
;
424 ret
= get_user(u_handler
, &act
->sa_handler
);
425 new_ka
.sa
.sa_handler
= compat_ptr(u_handler
);
426 ret
|= __copy_from_user(&set32
, &act
->sa_mask
, sizeof(compat_sigset_t
));
427 switch (_NSIG_WORDS
) {
428 case 4: new_ka
.sa
.sa_mask
.sig
[3] = set32
.sig
[6] | (((long)set32
.sig
[7]) << 32);
429 case 3: new_ka
.sa
.sa_mask
.sig
[2] = set32
.sig
[4] | (((long)set32
.sig
[5]) << 32);
430 case 2: new_ka
.sa
.sa_mask
.sig
[1] = set32
.sig
[2] | (((long)set32
.sig
[3]) << 32);
431 case 1: new_ka
.sa
.sa_mask
.sig
[0] = set32
.sig
[0] | (((long)set32
.sig
[1]) << 32);
433 ret
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
434 ret
|= __get_user(u_restorer
, &act
->sa_restorer
);
435 new_ka
.sa
.sa_restorer
= compat_ptr(u_restorer
);
440 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
443 switch (_NSIG_WORDS
) {
444 case 4: set32
.sig
[7] = (old_ka
.sa
.sa_mask
.sig
[3] >> 32); set32
.sig
[6] = old_ka
.sa
.sa_mask
.sig
[3];
445 case 3: set32
.sig
[5] = (old_ka
.sa
.sa_mask
.sig
[2] >> 32); set32
.sig
[4] = old_ka
.sa
.sa_mask
.sig
[2];
446 case 2: set32
.sig
[3] = (old_ka
.sa
.sa_mask
.sig
[1] >> 32); set32
.sig
[2] = old_ka
.sa
.sa_mask
.sig
[1];
447 case 1: set32
.sig
[1] = (old_ka
.sa
.sa_mask
.sig
[0] >> 32); set32
.sig
[0] = old_ka
.sa
.sa_mask
.sig
[0];
449 ret
= put_user(ptr_to_compat(old_ka
.sa
.sa_handler
), &oact
->sa_handler
);
450 ret
|= __copy_to_user(&oact
->sa_mask
, &set32
, sizeof(compat_sigset_t
));
451 ret
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
452 ret
|= __put_user(ptr_to_compat(old_ka
.sa
.sa_restorer
), &oact
->sa_restorer
);
461 * sparc32_execve() executes a new program after the asm stub has set
462 * things up for us. This should basically do what I want it to.
464 asmlinkage
long sparc32_execve(struct pt_regs
*regs
)
469 /* User register window flush is done by entry.S */
471 /* Check for indirect call. */
472 if ((u32
)regs
->u_regs
[UREG_G1
] == 0)
475 filename
= getname(compat_ptr(regs
->u_regs
[base
+ UREG_I0
]));
476 error
= PTR_ERR(filename
);
477 if (IS_ERR(filename
))
480 error
= compat_do_execve(filename
,
481 compat_ptr(regs
->u_regs
[base
+ UREG_I1
]),
482 compat_ptr(regs
->u_regs
[base
+ UREG_I2
]), regs
);
488 current_thread_info()->xfsr
[0] = 0;
489 current_thread_info()->fpsaved
[0] = 0;
490 regs
->tstate
&= ~TSTATE_PEF
;
496 #ifdef CONFIG_MODULES
498 asmlinkage
long sys32_init_module(void __user
*umod
, u32 len
,
499 const char __user
*uargs
)
501 return sys_init_module(umod
, len
, uargs
);
504 asmlinkage
long sys32_delete_module(const char __user
*name_user
,
507 return sys_delete_module(name_user
, flags
);
510 #else /* CONFIG_MODULES */
512 asmlinkage
long sys32_init_module(const char __user
*name_user
,
513 struct module __user
*mod_user
)
518 asmlinkage
long sys32_delete_module(const char __user
*name_user
)
523 #endif /* CONFIG_MODULES */
525 /* Translations due to time_t size differences. Which affects all
526 sorts of things, like timeval and itimerval. */
528 extern struct timezone sys_tz
;
530 asmlinkage
long sys32_gettimeofday(struct compat_timeval __user
*tv
,
531 struct timezone __user
*tz
)
535 do_gettimeofday(&ktv
);
536 if (put_tv32(tv
, &ktv
))
540 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
546 static inline long get_ts32(struct timespec
*o
, struct compat_timeval __user
*i
)
550 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
552 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
554 if (__get_user(usec
, &i
->tv_usec
))
556 o
->tv_nsec
= usec
* 1000;
560 asmlinkage
long sys32_settimeofday(struct compat_timeval __user
*tv
,
561 struct timezone __user
*tz
)
567 if (get_ts32(&kts
, tv
))
571 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
575 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
578 /* These are here just in case some old sparc32 binary calls it. */
579 asmlinkage
long sys32_pause(void)
581 current
->state
= TASK_INTERRUPTIBLE
;
583 return -ERESTARTNOHAND
;
586 asmlinkage compat_ssize_t
sys32_pread64(unsigned int fd
,
592 return sys_pread64(fd
, ubuf
, count
, (poshi
<< 32) | poslo
);
595 asmlinkage compat_ssize_t
sys32_pwrite64(unsigned int fd
,
601 return sys_pwrite64(fd
, ubuf
, count
, (poshi
<< 32) | poslo
);
604 asmlinkage
long compat_sys_readahead(int fd
,
609 return sys_readahead(fd
, (offhi
<< 32) | offlo
, count
);
612 long compat_sys_fadvise64(int fd
,
615 compat_size_t len
, int advice
)
617 return sys_fadvise64_64(fd
, (offhi
<< 32) | offlo
, len
, advice
);
620 long compat_sys_fadvise64_64(int fd
,
621 unsigned long offhi
, unsigned long offlo
,
622 unsigned long lenhi
, unsigned long lenlo
,
625 return sys_fadvise64_64(fd
,
626 (offhi
<< 32) | offlo
,
627 (lenhi
<< 32) | lenlo
,
631 asmlinkage
long compat_sys_sendfile(int out_fd
, int in_fd
,
632 compat_off_t __user
*offset
,
635 mm_segment_t old_fs
= get_fs();
639 if (offset
&& get_user(of
, offset
))
643 ret
= sys_sendfile(out_fd
, in_fd
,
644 offset
? (off_t __user
*) &of
: NULL
,
648 if (offset
&& put_user(of
, offset
))
654 asmlinkage
long compat_sys_sendfile64(int out_fd
, int in_fd
,
655 compat_loff_t __user
*offset
,
658 mm_segment_t old_fs
= get_fs();
662 if (offset
&& get_user(lof
, offset
))
666 ret
= sys_sendfile64(out_fd
, in_fd
,
667 offset
? (loff_t __user
*) &lof
: NULL
,
671 if (offset
&& put_user(lof
, offset
))
677 /* This is just a version for 32-bit applications which does
678 * not force O_LARGEFILE on.
681 asmlinkage
long sparc32_open(const char __user
*filename
,
684 return do_sys_open(AT_FDCWD
, filename
, flags
, mode
);
687 extern unsigned long do_mremap(unsigned long addr
,
688 unsigned long old_len
, unsigned long new_len
,
689 unsigned long flags
, unsigned long new_addr
);
691 asmlinkage
unsigned long sys32_mremap(unsigned long addr
,
692 unsigned long old_len
, unsigned long new_len
,
693 unsigned long flags
, u32 __new_addr
)
695 unsigned long ret
= -EINVAL
;
696 unsigned long new_addr
= __new_addr
;
698 if (unlikely(sparc_mmap_check(addr
, old_len
)))
700 if (unlikely(sparc_mmap_check(new_addr
, new_len
)))
702 down_write(¤t
->mm
->mmap_sem
);
703 ret
= do_mremap(addr
, old_len
, new_len
, flags
, new_addr
);
704 up_write(¤t
->mm
->mmap_sem
);
709 struct __sysctl_args32
{
719 asmlinkage
long sys32_sysctl(struct __sysctl_args32 __user
*args
)
721 #ifndef CONFIG_SYSCTL_SYSCALL
724 struct __sysctl_args32 tmp
;
726 size_t oldlen
, __user
*oldlenp
= NULL
;
727 unsigned long addr
= (((unsigned long)&args
->__unused
[0]) + 7UL) & ~7UL;
729 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
732 if (tmp
.oldval
&& tmp
.oldlenp
) {
733 /* Duh, this is ugly and might not work if sysctl_args
734 is in read-only memory, but do_sysctl does indirectly
735 a lot of uaccess in both directions and we'd have to
736 basically copy the whole sysctl.c here, and
737 glibc's __sysctl uses rw memory for the structure
739 if (get_user(oldlen
, (u32 __user
*)(unsigned long)tmp
.oldlenp
) ||
740 put_user(oldlen
, (size_t __user
*)addr
))
742 oldlenp
= (size_t __user
*)addr
;
746 error
= do_sysctl((int __user
*)(unsigned long) tmp
.name
,
748 (void __user
*)(unsigned long) tmp
.oldval
,
750 (void __user
*)(unsigned long) tmp
.newval
,
755 if (get_user(oldlen
, (size_t __user
*)addr
) ||
756 put_user(oldlen
, (u32 __user
*)(unsigned long) tmp
.oldlenp
))
759 if (copy_to_user(args
->__unused
, tmp
.__unused
, sizeof(tmp
.__unused
)))
766 long sys32_lookup_dcookie(unsigned long cookie_high
,
767 unsigned long cookie_low
,
768 char __user
*buf
, size_t len
)
770 return sys_lookup_dcookie((cookie_high
<< 32) | cookie_low
,
774 long compat_sync_file_range(int fd
, unsigned long off_high
, unsigned long off_low
, unsigned long nb_high
, unsigned long nb_low
, int flags
)
776 return sys_sync_file_range(fd
,
777 (off_high
<< 32) | off_low
,
778 (nb_high
<< 32) | nb_low
,
782 asmlinkage
long compat_sys_fallocate(int fd
, int mode
, u32 offhi
, u32 offlo
,
783 u32 lenhi
, u32 lenlo
)
785 return sys_fallocate(fd
, mode
, ((loff_t
)offhi
<< 32) | offlo
,
786 ((loff_t
)lenhi
<< 32) | lenlo
);