2 * sys_ppc32.c: Conversion between 32bit and 64bit native syscalls.
4 * Copyright (C) 2001 IBM
5 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
6 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
8 * These routines maintain argument size conversion between 32bit and 64bit
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
17 #include <linux/kernel.h>
18 #include <linux/sched.h>
21 #include <linux/file.h>
22 #include <linux/signal.h>
23 #include <linux/resource.h>
24 #include <linux/times.h>
25 #include <linux/utsname.h>
26 #include <linux/smp.h>
27 #include <linux/smp_lock.h>
28 #include <linux/sem.h>
29 #include <linux/msg.h>
30 #include <linux/shm.h>
31 #include <linux/poll.h>
32 #include <linux/personality.h>
33 #include <linux/stat.h>
34 #include <linux/mman.h>
36 #include <linux/syscalls.h>
37 #include <linux/unistd.h>
38 #include <linux/sysctl.h>
39 #include <linux/binfmts.h>
40 #include <linux/security.h>
41 #include <linux/compat.h>
42 #include <linux/ptrace.h>
43 #include <linux/elf.h>
45 #include <asm/ptrace.h>
46 #include <asm/types.h>
48 #include <asm/uaccess.h>
49 #include <asm/unistd.h>
50 #include <asm/semaphore.h>
52 #include <asm/mmu_context.h>
53 #include <asm/ppc-pci.h>
54 #include <asm/syscalls.h>
56 /* readdir & getdents */
57 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
58 #define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
60 struct old_linux_dirent32
{
63 unsigned short d_namlen
;
67 struct readdir_callback32
{
68 struct old_linux_dirent32 __user
* dirent
;
72 static int fillonedir(void * __buf
, const char * name
, int namlen
,
73 off_t offset
, u64 ino
, unsigned int d_type
)
75 struct readdir_callback32
* buf
= (struct readdir_callback32
*) __buf
;
76 struct old_linux_dirent32 __user
* dirent
;
82 if (sizeof(d_ino
) < sizeof(ino
) && d_ino
!= ino
)
86 put_user(d_ino
, &dirent
->d_ino
);
87 put_user(offset
, &dirent
->d_offset
);
88 put_user(namlen
, &dirent
->d_namlen
);
89 copy_to_user(dirent
->d_name
, name
, namlen
);
90 put_user(0, dirent
->d_name
+ namlen
);
94 asmlinkage
int old32_readdir(unsigned int fd
, struct old_linux_dirent32 __user
*dirent
, unsigned int count
)
98 struct readdir_callback32 buf
;
107 error
= vfs_readdir(file
, (filldir_t
)fillonedir
, &buf
);
118 asmlinkage
long ppc32_select(u32 n
, compat_ulong_t __user
*inp
,
119 compat_ulong_t __user
*outp
, compat_ulong_t __user
*exp
,
123 return compat_sys_select((int)n
, inp
, outp
, exp
, compat_ptr(tvp_x
));
126 int cp_compat_stat(struct kstat
*stat
, struct compat_stat __user
*statbuf
)
131 if (stat
->size
> MAX_NON_LFS
|| !new_valid_dev(stat
->dev
) ||
132 !new_valid_dev(stat
->rdev
))
136 if (sizeof(ino
) < sizeof(stat
->ino
) && ino
!= stat
->ino
)
139 err
= access_ok(VERIFY_WRITE
, statbuf
, sizeof(*statbuf
)) ? 0 : -EFAULT
;
140 err
|= __put_user(new_encode_dev(stat
->dev
), &statbuf
->st_dev
);
141 err
|= __put_user(ino
, &statbuf
->st_ino
);
142 err
|= __put_user(stat
->mode
, &statbuf
->st_mode
);
143 err
|= __put_user(stat
->nlink
, &statbuf
->st_nlink
);
144 err
|= __put_user(stat
->uid
, &statbuf
->st_uid
);
145 err
|= __put_user(stat
->gid
, &statbuf
->st_gid
);
146 err
|= __put_user(new_encode_dev(stat
->rdev
), &statbuf
->st_rdev
);
147 err
|= __put_user(stat
->size
, &statbuf
->st_size
);
148 err
|= __put_user(stat
->atime
.tv_sec
, &statbuf
->st_atime
);
149 err
|= __put_user(stat
->atime
.tv_nsec
, &statbuf
->st_atime_nsec
);
150 err
|= __put_user(stat
->mtime
.tv_sec
, &statbuf
->st_mtime
);
151 err
|= __put_user(stat
->mtime
.tv_nsec
, &statbuf
->st_mtime_nsec
);
152 err
|= __put_user(stat
->ctime
.tv_sec
, &statbuf
->st_ctime
);
153 err
|= __put_user(stat
->ctime
.tv_nsec
, &statbuf
->st_ctime_nsec
);
154 err
|= __put_user(stat
->blksize
, &statbuf
->st_blksize
);
155 err
|= __put_user(stat
->blocks
, &statbuf
->st_blocks
);
156 err
|= __put_user(0, &statbuf
->__unused4
[0]);
157 err
|= __put_user(0, &statbuf
->__unused4
[1]);
162 /* Note: it is necessary to treat option as an unsigned int,
163 * with the corresponding cast to a signed int to insure that the
164 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
165 * and the register representation of a signed int (msr in 64-bit mode) is performed.
167 asmlinkage
long compat_sys_sysfs(u32 option
, u32 arg1
, u32 arg2
)
169 return sys_sysfs((int)option
, arg1
, arg2
);
172 asmlinkage
long compat_sys_pause(void)
174 current
->state
= TASK_INTERRUPTIBLE
;
177 return -ERESTARTNOHAND
;
180 static inline long get_ts32(struct timespec
*o
, struct compat_timeval __user
*i
)
184 if (!access_ok(VERIFY_READ
, i
, sizeof(*i
)))
186 if (__get_user(o
->tv_sec
, &i
->tv_sec
))
188 if (__get_user(usec
, &i
->tv_usec
))
190 o
->tv_nsec
= usec
* 1000;
194 static inline long put_tv32(struct compat_timeval __user
*o
, struct timeval
*i
)
196 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
197 (__put_user(i
->tv_sec
, &o
->tv_sec
) |
198 __put_user(i
->tv_usec
, &o
->tv_usec
)));
204 /* Translations due to time_t size differences. Which affects all
205 sorts of things, like timeval and itimerval. */
206 extern struct timezone sys_tz
;
208 asmlinkage
long compat_sys_gettimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
212 do_gettimeofday(&ktv
);
213 if (put_tv32(tv
, &ktv
))
217 if (copy_to_user(tz
, &sys_tz
, sizeof(sys_tz
)))
226 asmlinkage
long compat_sys_settimeofday(struct compat_timeval __user
*tv
, struct timezone __user
*tz
)
232 if (get_ts32(&kts
, tv
))
236 if (copy_from_user(&ktz
, tz
, sizeof(ktz
)))
240 return do_sys_settimeofday(tv
? &kts
: NULL
, tz
? &ktz
: NULL
);
243 #ifdef CONFIG_SYSVIPC
244 long compat_sys_ipc(u32 call
, u32 first
, u32 second
, u32 third
, compat_uptr_t ptr
,
249 version
= call
>> 16; /* hack for backward compatibility */
256 /* sign extend semid */
257 return compat_sys_semtimedop((int)first
,
258 compat_ptr(ptr
), second
,
260 /* else fall through for normal semop() */
262 /* struct sembuf is the same on 32 and 64bit :)) */
263 /* sign extend semid */
264 return sys_semtimedop((int)first
, compat_ptr(ptr
), second
,
267 /* sign extend key, nsems */
268 return sys_semget((int)first
, (int)second
, third
);
270 /* sign extend semid, semnum */
271 return compat_sys_semctl((int)first
, (int)second
, third
,
275 /* sign extend msqid */
276 return compat_sys_msgsnd((int)first
, (int)second
, third
,
279 /* sign extend msqid, msgtyp */
280 return compat_sys_msgrcv((int)first
, second
, (int)fifth
,
281 third
, version
, compat_ptr(ptr
));
283 /* sign extend key */
284 return sys_msgget((int)first
, second
);
286 /* sign extend msqid */
287 return compat_sys_msgctl((int)first
, second
, compat_ptr(ptr
));
290 /* sign extend shmid */
291 return compat_sys_shmat((int)first
, second
, third
, version
,
294 return sys_shmdt(compat_ptr(ptr
));
296 /* sign extend key_t */
297 return sys_shmget((int)first
, second
, third
);
299 /* sign extend shmid */
300 return compat_sys_shmctl((int)first
, second
, compat_ptr(ptr
));
310 /* Note: it is necessary to treat out_fd and in_fd as unsigned ints,
311 * with the corresponding cast to a signed int to insure that the
312 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
313 * and the register representation of a signed int (msr in 64-bit mode) is performed.
315 asmlinkage
long compat_sys_sendfile(u32 out_fd
, u32 in_fd
, compat_off_t __user
* offset
, u32 count
)
317 mm_segment_t old_fs
= get_fs();
322 if (offset
&& get_user(of
, offset
))
325 /* The __user pointer cast is valid because of the set_fs() */
327 up
= offset
? (off_t __user
*) &of
: NULL
;
328 ret
= sys_sendfile((int)out_fd
, (int)in_fd
, up
, count
);
331 if (offset
&& put_user(of
, offset
))
337 asmlinkage
int compat_sys_sendfile64(int out_fd
, int in_fd
, compat_loff_t __user
*offset
, s32 count
)
339 mm_segment_t old_fs
= get_fs();
344 if (offset
&& get_user(lof
, offset
))
347 /* The __user pointer cast is valid because of the set_fs() */
349 up
= offset
? (loff_t __user
*) &lof
: NULL
;
350 ret
= sys_sendfile64(out_fd
, in_fd
, up
, count
);
353 if (offset
&& put_user(lof
, offset
))
359 long compat_sys_execve(unsigned long a0
, unsigned long a1
, unsigned long a2
,
360 unsigned long a3
, unsigned long a4
, unsigned long a5
,
361 struct pt_regs
*regs
)
366 filename
= getname((char __user
*) a0
);
367 error
= PTR_ERR(filename
);
368 if (IS_ERR(filename
))
370 flush_fp_to_thread(current
);
371 flush_altivec_to_thread(current
);
373 error
= compat_do_execve(filename
, compat_ptr(a1
), compat_ptr(a2
), regs
);
377 current
->ptrace
&= ~PT_DTRACE
;
378 task_unlock(current
);
386 /* Note: it is necessary to treat option as an unsigned int,
387 * with the corresponding cast to a signed int to insure that the
388 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
389 * and the register representation of a signed int (msr in 64-bit mode) is performed.
391 asmlinkage
long compat_sys_prctl(u32 option
, u32 arg2
, u32 arg3
, u32 arg4
, u32 arg5
)
393 return sys_prctl((int)option
,
394 (unsigned long) arg2
,
395 (unsigned long) arg3
,
396 (unsigned long) arg4
,
397 (unsigned long) arg5
);
400 /* Note: it is necessary to treat pid as an unsigned int,
401 * with the corresponding cast to a signed int to insure that the
402 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
403 * and the register representation of a signed int (msr in 64-bit mode) is performed.
405 asmlinkage
long compat_sys_sched_rr_get_interval(u32 pid
, struct compat_timespec __user
*interval
)
409 mm_segment_t old_fs
= get_fs ();
411 /* The __user pointer cast is valid because of the set_fs() */
413 ret
= sys_sched_rr_get_interval((int)pid
, (struct timespec __user
*) &t
);
415 if (put_compat_timespec(&t
, interval
))
420 /* Note: it is necessary to treat mode as an unsigned int,
421 * with the corresponding cast to a signed int to insure that the
422 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
423 * and the register representation of a signed int (msr in 64-bit mode) is performed.
425 asmlinkage
long compat_sys_access(const char __user
* filename
, u32 mode
)
427 return sys_access(filename
, (int)mode
);
431 /* Note: it is necessary to treat mode as an unsigned int,
432 * with the corresponding cast to a signed int to insure that the
433 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
434 * and the register representation of a signed int (msr in 64-bit mode) is performed.
436 asmlinkage
long compat_sys_creat(const char __user
* pathname
, u32 mode
)
438 return sys_creat(pathname
, (int)mode
);
442 /* Note: it is necessary to treat pid and options as unsigned ints,
443 * with the corresponding cast to a signed int to insure that the
444 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
445 * and the register representation of a signed int (msr in 64-bit mode) is performed.
447 asmlinkage
long compat_sys_waitpid(u32 pid
, unsigned int __user
* stat_addr
, u32 options
)
449 return sys_waitpid((int)pid
, stat_addr
, (int)options
);
453 /* Note: it is necessary to treat gidsetsize as an unsigned int,
454 * with the corresponding cast to a signed int to insure that the
455 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
456 * and the register representation of a signed int (msr in 64-bit mode) is performed.
458 asmlinkage
long compat_sys_getgroups(u32 gidsetsize
, gid_t __user
*grouplist
)
460 return sys_getgroups((int)gidsetsize
, grouplist
);
464 /* Note: it is necessary to treat pid as an unsigned int,
465 * with the corresponding cast to a signed int to insure that the
466 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
467 * and the register representation of a signed int (msr in 64-bit mode) is performed.
469 asmlinkage
long compat_sys_getpgid(u32 pid
)
471 return sys_getpgid((int)pid
);
476 /* Note: it is necessary to treat pid as an unsigned int,
477 * with the corresponding cast to a signed int to insure that the
478 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
479 * and the register representation of a signed int (msr in 64-bit mode) is performed.
481 asmlinkage
long compat_sys_getsid(u32 pid
)
483 return sys_getsid((int)pid
);
487 /* Note: it is necessary to treat pid and sig as unsigned ints,
488 * with the corresponding cast to a signed int to insure that the
489 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
490 * and the register representation of a signed int (msr in 64-bit mode) is performed.
492 asmlinkage
long compat_sys_kill(u32 pid
, u32 sig
)
494 return sys_kill((int)pid
, (int)sig
);
498 /* Note: it is necessary to treat mode as an unsigned int,
499 * with the corresponding cast to a signed int to insure that the
500 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
501 * and the register representation of a signed int (msr in 64-bit mode) is performed.
503 asmlinkage
long compat_sys_mkdir(const char __user
* pathname
, u32 mode
)
505 return sys_mkdir(pathname
, (int)mode
);
508 long compat_sys_nice(u32 increment
)
510 /* sign extend increment */
511 return sys_nice((int)increment
);
514 off_t
ppc32_lseek(unsigned int fd
, u32 offset
, unsigned int origin
)
517 return sys_lseek(fd
, (int)offset
, origin
);
520 /* Note: it is necessary to treat bufsiz as an unsigned int,
521 * with the corresponding cast to a signed int to insure that the
522 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
523 * and the register representation of a signed int (msr in 64-bit mode) is performed.
525 asmlinkage
long compat_sys_readlink(const char __user
* path
, char __user
* buf
, u32 bufsiz
)
527 return sys_readlink(path
, buf
, (int)bufsiz
);
530 /* Note: it is necessary to treat option as an unsigned int,
531 * with the corresponding cast to a signed int to insure that the
532 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
533 * and the register representation of a signed int (msr in 64-bit mode) is performed.
535 asmlinkage
long compat_sys_sched_get_priority_max(u32 policy
)
537 return sys_sched_get_priority_max((int)policy
);
541 /* Note: it is necessary to treat policy as an unsigned int,
542 * with the corresponding cast to a signed int to insure that the
543 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
544 * and the register representation of a signed int (msr in 64-bit mode) is performed.
546 asmlinkage
long compat_sys_sched_get_priority_min(u32 policy
)
548 return sys_sched_get_priority_min((int)policy
);
552 /* Note: it is necessary to treat pid as an unsigned int,
553 * with the corresponding cast to a signed int to insure that the
554 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
555 * and the register representation of a signed int (msr in 64-bit mode) is performed.
557 asmlinkage
long compat_sys_sched_getparam(u32 pid
, struct sched_param __user
*param
)
559 return sys_sched_getparam((int)pid
, param
);
563 /* Note: it is necessary to treat pid as an unsigned int,
564 * with the corresponding cast to a signed int to insure that the
565 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
566 * and the register representation of a signed int (msr in 64-bit mode) is performed.
568 asmlinkage
long compat_sys_sched_getscheduler(u32 pid
)
570 return sys_sched_getscheduler((int)pid
);
574 /* Note: it is necessary to treat pid as an unsigned int,
575 * with the corresponding cast to a signed int to insure that the
576 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
577 * and the register representation of a signed int (msr in 64-bit mode) is performed.
579 asmlinkage
long compat_sys_sched_setparam(u32 pid
, struct sched_param __user
*param
)
581 return sys_sched_setparam((int)pid
, param
);
585 /* Note: it is necessary to treat pid and policy as unsigned ints,
586 * with the corresponding cast to a signed int to insure that the
587 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
588 * and the register representation of a signed int (msr in 64-bit mode) is performed.
590 asmlinkage
long compat_sys_sched_setscheduler(u32 pid
, u32 policy
, struct sched_param __user
*param
)
592 return sys_sched_setscheduler((int)pid
, (int)policy
, param
);
596 /* Note: it is necessary to treat len as an unsigned int,
597 * with the corresponding cast to a signed int to insure that the
598 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
599 * and the register representation of a signed int (msr in 64-bit mode) is performed.
601 asmlinkage
long compat_sys_setdomainname(char __user
*name
, u32 len
)
603 return sys_setdomainname(name
, (int)len
);
607 /* Note: it is necessary to treat gidsetsize as an unsigned int,
608 * with the corresponding cast to a signed int to insure that the
609 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
610 * and the register representation of a signed int (msr in 64-bit mode) is performed.
612 asmlinkage
long compat_sys_setgroups(u32 gidsetsize
, gid_t __user
*grouplist
)
614 return sys_setgroups((int)gidsetsize
, grouplist
);
618 asmlinkage
long compat_sys_sethostname(char __user
*name
, u32 len
)
620 /* sign extend len */
621 return sys_sethostname(name
, (int)len
);
625 /* Note: it is necessary to treat pid and pgid as unsigned ints,
626 * with the corresponding cast to a signed int to insure that the
627 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
628 * and the register representation of a signed int (msr in 64-bit mode) is performed.
630 asmlinkage
long compat_sys_setpgid(u32 pid
, u32 pgid
)
632 return sys_setpgid((int)pid
, (int)pgid
);
635 long compat_sys_getpriority(u32 which
, u32 who
)
637 /* sign extend which and who */
638 return sys_getpriority((int)which
, (int)who
);
641 long compat_sys_setpriority(u32 which
, u32 who
, u32 niceval
)
643 /* sign extend which, who and niceval */
644 return sys_setpriority((int)which
, (int)who
, (int)niceval
);
647 long compat_sys_ioprio_get(u32 which
, u32 who
)
649 /* sign extend which and who */
650 return sys_ioprio_get((int)which
, (int)who
);
653 long compat_sys_ioprio_set(u32 which
, u32 who
, u32 ioprio
)
655 /* sign extend which, who and ioprio */
656 return sys_ioprio_set((int)which
, (int)who
, (int)ioprio
);
659 /* Note: it is necessary to treat newmask as an unsigned int,
660 * with the corresponding cast to a signed int to insure that the
661 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
662 * and the register representation of a signed int (msr in 64-bit mode) is performed.
664 asmlinkage
long compat_sys_ssetmask(u32 newmask
)
666 return sys_ssetmask((int) newmask
);
669 asmlinkage
long compat_sys_syslog(u32 type
, char __user
* buf
, u32 len
)
671 /* sign extend len */
672 return sys_syslog(type
, buf
, (int)len
);
676 /* Note: it is necessary to treat mask as an unsigned int,
677 * with the corresponding cast to a signed int to insure that the
678 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
679 * and the register representation of a signed int (msr in 64-bit mode) is performed.
681 asmlinkage
long compat_sys_umask(u32 mask
)
683 return sys_umask((int)mask
);
686 #ifdef CONFIG_SYSCTL_SYSCALL
687 struct __sysctl_args32
{
697 asmlinkage
long compat_sys_sysctl(struct __sysctl_args32 __user
*args
)
699 struct __sysctl_args32 tmp
;
702 size_t __user
*oldlenp
= NULL
;
703 unsigned long addr
= (((unsigned long)&args
->__unused
[0]) + 7) & ~7;
705 if (copy_from_user(&tmp
, args
, sizeof(tmp
)))
708 if (tmp
.oldval
&& tmp
.oldlenp
) {
709 /* Duh, this is ugly and might not work if sysctl_args
710 is in read-only memory, but do_sysctl does indirectly
711 a lot of uaccess in both directions and we'd have to
712 basically copy the whole sysctl.c here, and
713 glibc's __sysctl uses rw memory for the structure
715 oldlenp
= (size_t __user
*)addr
;
716 if (get_user(oldlen
, (compat_size_t __user
*)compat_ptr(tmp
.oldlenp
)) ||
717 put_user(oldlen
, oldlenp
))
722 error
= do_sysctl(compat_ptr(tmp
.name
), tmp
.nlen
,
723 compat_ptr(tmp
.oldval
), oldlenp
,
724 compat_ptr(tmp
.newval
), tmp
.newlen
);
728 if (get_user(oldlen
, oldlenp
) ||
729 put_user(oldlen
, (compat_size_t __user
*)compat_ptr(tmp
.oldlenp
)))
732 copy_to_user(args
->__unused
, tmp
.__unused
, sizeof(tmp
.__unused
));
738 unsigned long compat_sys_mmap2(unsigned long addr
, size_t len
,
739 unsigned long prot
, unsigned long flags
,
740 unsigned long fd
, unsigned long pgoff
)
742 /* This should remain 12 even if PAGE_SIZE changes */
743 return sys_mmap(addr
, len
, prot
, flags
, fd
, pgoff
<< 12);
746 long compat_sys_tgkill(u32 tgid
, u32 pid
, int sig
)
748 /* sign extend tgid, pid */
749 return sys_tgkill((int)tgid
, (int)pid
, sig
);
754 * The 32 bit ABI passes long longs in an odd even register pair.
757 compat_ssize_t
compat_sys_pread64(unsigned int fd
, char __user
*ubuf
, compat_size_t count
,
758 u32 reg6
, u32 poshi
, u32 poslo
)
760 return sys_pread64(fd
, ubuf
, count
, ((loff_t
)poshi
<< 32) | poslo
);
763 compat_ssize_t
compat_sys_pwrite64(unsigned int fd
, char __user
*ubuf
, compat_size_t count
,
764 u32 reg6
, u32 poshi
, u32 poslo
)
766 return sys_pwrite64(fd
, ubuf
, count
, ((loff_t
)poshi
<< 32) | poslo
);
769 compat_ssize_t
compat_sys_readahead(int fd
, u32 r4
, u32 offhi
, u32 offlo
, u32 count
)
771 return sys_readahead(fd
, ((loff_t
)offhi
<< 32) | offlo
, count
);
774 asmlinkage
int compat_sys_truncate64(const char __user
* path
, u32 reg4
,
775 unsigned long high
, unsigned long low
)
777 return sys_truncate(path
, (high
<< 32) | low
);
780 asmlinkage
int compat_sys_ftruncate64(unsigned int fd
, u32 reg4
, unsigned long high
,
783 return sys_ftruncate(fd
, (high
<< 32) | low
);
786 long ppc32_lookup_dcookie(u32 cookie_high
, u32 cookie_low
, char __user
*buf
,
789 return sys_lookup_dcookie((u64
)cookie_high
<< 32 | cookie_low
,
793 long ppc32_fadvise64(int fd
, u32 unused
, u32 offset_high
, u32 offset_low
,
794 size_t len
, int advice
)
796 return sys_fadvise64(fd
, (u64
)offset_high
<< 32 | offset_low
, len
,
800 asmlinkage
long compat_sys_add_key(const char __user
*_type
,
801 const char __user
*_description
,
802 const void __user
*_payload
,
806 return sys_add_key(_type
, _description
, _payload
, plen
, ringid
);
809 asmlinkage
long compat_sys_request_key(const char __user
*_type
,
810 const char __user
*_description
,
811 const char __user
*_callout_info
,
814 return sys_request_key(_type
, _description
, _callout_info
, destringid
);