Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * sys_ppc32.c: Conversion between 32bit and 64bit native syscalls.
4 *
5 * Copyright (C) 2001 IBM
6 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
7 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
8 *
9 * These routines maintain argument size conversion between 32bit and 64bit
10 * environment.
11 */
12
13#include <linux/kernel.h>
14#include <linux/sched.h>
15#include <linux/fs.h>
16#include <linux/mm.h>
17#include <linux/file.h>
18#include <linux/signal.h>
19#include <linux/resource.h>
20#include <linux/times.h>
21#include <linux/smp.h>
22#include <linux/sem.h>
23#include <linux/msg.h>
24#include <linux/shm.h>
25#include <linux/poll.h>
26#include <linux/personality.h>
27#include <linux/stat.h>
28#include <linux/mman.h>
29#include <linux/in.h>
30#include <linux/syscalls.h>
31#include <linux/unistd.h>
32#include <linux/sysctl.h>
33#include <linux/binfmts.h>
34#include <linux/security.h>
35#include <linux/compat.h>
36#include <linux/ptrace.h>
37#include <linux/elf.h>
38#include <linux/ipc.h>
39#include <linux/slab.h>
40
41#include <asm/ptrace.h>
42#include <asm/types.h>
43#include <linux/uaccess.h>
44#include <asm/unistd.h>
45#include <asm/time.h>
46#include <asm/mmu_context.h>
47#include <asm/ppc-pci.h>
48#include <asm/syscalls.h>
49#include <asm/switch_to.h>
50
51unsigned long compat_sys_mmap2(unsigned long addr, size_t len,
52 unsigned long prot, unsigned long flags,
53 unsigned long fd, unsigned long pgoff)
54{
55 /* This should remain 12 even if PAGE_SIZE changes */
56 return sys_mmap(addr, len, prot, flags, fd, pgoff << 12);
57}
58
59/*
60 * long long munging:
61 * The 32 bit ABI passes long longs in an odd even register pair.
62 * High and low parts are swapped depending on endian mode,
63 * so define a macro (similar to mips linux32) to handle that.
64 */
65#ifdef __LITTLE_ENDIAN__
66#define merge_64(low, high) ((u64)high << 32) | low
67#else
68#define merge_64(high, low) ((u64)high << 32) | low
69#endif
70
71compat_ssize_t compat_sys_pread64(unsigned int fd, char __user *ubuf, compat_size_t count,
72 u32 reg6, u32 pos1, u32 pos2)
73{
74 return ksys_pread64(fd, ubuf, count, merge_64(pos1, pos2));
75}
76
77compat_ssize_t compat_sys_pwrite64(unsigned int fd, const char __user *ubuf, compat_size_t count,
78 u32 reg6, u32 pos1, u32 pos2)
79{
80 return ksys_pwrite64(fd, ubuf, count, merge_64(pos1, pos2));
81}
82
83compat_ssize_t compat_sys_readahead(int fd, u32 r4, u32 offset1, u32 offset2, u32 count)
84{
85 return ksys_readahead(fd, merge_64(offset1, offset2), count);
86}
87
88asmlinkage int compat_sys_truncate64(const char __user * path, u32 reg4,
89 unsigned long len1, unsigned long len2)
90{
91 return ksys_truncate(path, merge_64(len1, len2));
92}
93
94asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offset1, u32 offset2,
95 u32 len1, u32 len2)
96{
97 return ksys_fallocate(fd, mode, ((loff_t)offset1 << 32) | offset2,
98 merge_64(len1, len2));
99}
100
101asmlinkage int compat_sys_ftruncate64(unsigned int fd, u32 reg4, unsigned long len1,
102 unsigned long len2)
103{
104 return ksys_ftruncate(fd, merge_64(len1, len2));
105}
106
107long ppc32_fadvise64(int fd, u32 unused, u32 offset1, u32 offset2,
108 size_t len, int advice)
109{
110 return ksys_fadvise64_64(fd, merge_64(offset1, offset2), len,
111 advice);
112}
113
114asmlinkage long compat_sys_sync_file_range2(int fd, unsigned int flags,
115 unsigned offset1, unsigned offset2,
116 unsigned nbytes1, unsigned nbytes2)
117{
118 loff_t offset = merge_64(offset1, offset2);
119 loff_t nbytes = merge_64(nbytes1, nbytes2);
120
121 return ksys_sync_file_range(fd, offset, nbytes, flags);
122}
1/*
2 * sys_ppc32.c: Conversion between 32bit and 64bit native syscalls.
3 *
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)
7 *
8 * These routines maintain argument size conversion between 32bit and 64bit
9 * environment.
10 *
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.
15 */
16
17#include <linux/kernel.h>
18#include <linux/sched.h>
19#include <linux/fs.h>
20#include <linux/mm.h>
21#include <linux/file.h>
22#include <linux/signal.h>
23#include <linux/resource.h>
24#include <linux/times.h>
25#include <linux/smp.h>
26#include <linux/sem.h>
27#include <linux/msg.h>
28#include <linux/shm.h>
29#include <linux/poll.h>
30#include <linux/personality.h>
31#include <linux/stat.h>
32#include <linux/mman.h>
33#include <linux/in.h>
34#include <linux/syscalls.h>
35#include <linux/unistd.h>
36#include <linux/sysctl.h>
37#include <linux/binfmts.h>
38#include <linux/security.h>
39#include <linux/compat.h>
40#include <linux/ptrace.h>
41#include <linux/elf.h>
42#include <linux/ipc.h>
43#include <linux/slab.h>
44
45#include <asm/ptrace.h>
46#include <asm/types.h>
47#include <asm/uaccess.h>
48#include <asm/unistd.h>
49#include <asm/time.h>
50#include <asm/mmu_context.h>
51#include <asm/ppc-pci.h>
52#include <asm/syscalls.h>
53#include <asm/switch_to.h>
54
55
56asmlinkage long ppc32_select(u32 n, compat_ulong_t __user *inp,
57 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
58 compat_uptr_t tvp_x)
59{
60 /* sign extend n */
61 return compat_sys_select((int)n, inp, outp, exp, compat_ptr(tvp_x));
62}
63
64/* Note: it is necessary to treat option as an unsigned int,
65 * with the corresponding cast to a signed int to insure that the
66 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
67 * and the register representation of a signed int (msr in 64-bit mode) is performed.
68 */
69asmlinkage long compat_sys_sysfs(u32 option, u32 arg1, u32 arg2)
70{
71 return sys_sysfs((int)option, arg1, arg2);
72}
73
74#ifdef CONFIG_SYSVIPC
75long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr,
76 u32 fifth)
77{
78 int version;
79
80 version = call >> 16; /* hack for backward compatibility */
81 call &= 0xffff;
82
83 switch (call) {
84
85 case SEMTIMEDOP:
86 if (fifth)
87 /* sign extend semid */
88 return compat_sys_semtimedop((int)first,
89 compat_ptr(ptr), second,
90 compat_ptr(fifth));
91 /* else fall through for normal semop() */
92 case SEMOP:
93 /* struct sembuf is the same on 32 and 64bit :)) */
94 /* sign extend semid */
95 return sys_semtimedop((int)first, compat_ptr(ptr), second,
96 NULL);
97 case SEMGET:
98 /* sign extend key, nsems */
99 return sys_semget((int)first, (int)second, third);
100 case SEMCTL:
101 /* sign extend semid, semnum */
102 return compat_sys_semctl((int)first, (int)second, third,
103 compat_ptr(ptr));
104
105 case MSGSND:
106 /* sign extend msqid */
107 return compat_sys_msgsnd((int)first, (int)second, third,
108 compat_ptr(ptr));
109 case MSGRCV:
110 /* sign extend msqid, msgtyp */
111 return compat_sys_msgrcv((int)first, second, (int)fifth,
112 third, version, compat_ptr(ptr));
113 case MSGGET:
114 /* sign extend key */
115 return sys_msgget((int)first, second);
116 case MSGCTL:
117 /* sign extend msqid */
118 return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
119
120 case SHMAT:
121 /* sign extend shmid */
122 return compat_sys_shmat((int)first, second, third, version,
123 compat_ptr(ptr));
124 case SHMDT:
125 return sys_shmdt(compat_ptr(ptr));
126 case SHMGET:
127 /* sign extend key_t */
128 return sys_shmget((int)first, second, third);
129 case SHMCTL:
130 /* sign extend shmid */
131 return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
132
133 default:
134 return -ENOSYS;
135 }
136
137 return -ENOSYS;
138}
139#endif
140
141/* Note: it is necessary to treat out_fd and in_fd as unsigned ints,
142 * with the corresponding cast to a signed int to insure that the
143 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
144 * and the register representation of a signed int (msr in 64-bit mode) is performed.
145 */
146asmlinkage long compat_sys_sendfile(u32 out_fd, u32 in_fd, compat_off_t __user * offset, u32 count)
147{
148 mm_segment_t old_fs = get_fs();
149 int ret;
150 off_t of;
151 off_t __user *up;
152
153 if (offset && get_user(of, offset))
154 return -EFAULT;
155
156 /* The __user pointer cast is valid because of the set_fs() */
157 set_fs(KERNEL_DS);
158 up = offset ? (off_t __user *) &of : NULL;
159 ret = sys_sendfile((int)out_fd, (int)in_fd, up, count);
160 set_fs(old_fs);
161
162 if (offset && put_user(of, offset))
163 return -EFAULT;
164
165 return ret;
166}
167
168asmlinkage int compat_sys_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset, s32 count)
169{
170 mm_segment_t old_fs = get_fs();
171 int ret;
172 loff_t lof;
173 loff_t __user *up;
174
175 if (offset && get_user(lof, offset))
176 return -EFAULT;
177
178 /* The __user pointer cast is valid because of the set_fs() */
179 set_fs(KERNEL_DS);
180 up = offset ? (loff_t __user *) &lof : NULL;
181 ret = sys_sendfile64(out_fd, in_fd, up, count);
182 set_fs(old_fs);
183
184 if (offset && put_user(lof, offset))
185 return -EFAULT;
186
187 return ret;
188}
189
190long compat_sys_execve(unsigned long a0, unsigned long a1, unsigned long a2,
191 unsigned long a3, unsigned long a4, unsigned long a5,
192 struct pt_regs *regs)
193{
194 int error;
195 char * filename;
196
197 filename = getname((char __user *) a0);
198 error = PTR_ERR(filename);
199 if (IS_ERR(filename))
200 goto out;
201 flush_fp_to_thread(current);
202 flush_altivec_to_thread(current);
203
204 error = compat_do_execve(filename, compat_ptr(a1), compat_ptr(a2), regs);
205
206 putname(filename);
207
208out:
209 return error;
210}
211
212/* Note: it is necessary to treat option as an unsigned int,
213 * with the corresponding cast to a signed int to insure that the
214 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
215 * and the register representation of a signed int (msr in 64-bit mode) is performed.
216 */
217asmlinkage long compat_sys_prctl(u32 option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
218{
219 return sys_prctl((int)option,
220 (unsigned long) arg2,
221 (unsigned long) arg3,
222 (unsigned long) arg4,
223 (unsigned long) arg5);
224}
225
226/* Note: it is necessary to treat pid as an unsigned int,
227 * with the corresponding cast to a signed int to insure that the
228 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
229 * and the register representation of a signed int (msr in 64-bit mode) is performed.
230 */
231asmlinkage long compat_sys_sched_rr_get_interval(u32 pid, struct compat_timespec __user *interval)
232{
233 struct timespec t;
234 int ret;
235 mm_segment_t old_fs = get_fs ();
236
237 /* The __user pointer cast is valid because of the set_fs() */
238 set_fs (KERNEL_DS);
239 ret = sys_sched_rr_get_interval((int)pid, (struct timespec __user *) &t);
240 set_fs (old_fs);
241 if (put_compat_timespec(&t, interval))
242 return -EFAULT;
243 return ret;
244}
245
246/* Note: it is necessary to treat mode as an unsigned int,
247 * with the corresponding cast to a signed int to insure that the
248 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
249 * and the register representation of a signed int (msr in 64-bit mode) is performed.
250 */
251asmlinkage long compat_sys_access(const char __user * filename, u32 mode)
252{
253 return sys_access(filename, (int)mode);
254}
255
256
257/* Note: it is necessary to treat mode as an unsigned int,
258 * with the corresponding cast to a signed int to insure that the
259 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
260 * and the register representation of a signed int (msr in 64-bit mode) is performed.
261 */
262asmlinkage long compat_sys_creat(const char __user * pathname, u32 mode)
263{
264 return sys_creat(pathname, (int)mode);
265}
266
267
268/* Note: it is necessary to treat pid and options as unsigned ints,
269 * with the corresponding cast to a signed int to insure that the
270 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
271 * and the register representation of a signed int (msr in 64-bit mode) is performed.
272 */
273asmlinkage long compat_sys_waitpid(u32 pid, unsigned int __user * stat_addr, u32 options)
274{
275 return sys_waitpid((int)pid, stat_addr, (int)options);
276}
277
278
279/* Note: it is necessary to treat gidsetsize as an unsigned int,
280 * with the corresponding cast to a signed int to insure that the
281 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
282 * and the register representation of a signed int (msr in 64-bit mode) is performed.
283 */
284asmlinkage long compat_sys_getgroups(u32 gidsetsize, gid_t __user *grouplist)
285{
286 return sys_getgroups((int)gidsetsize, grouplist);
287}
288
289
290/* Note: it is necessary to treat pid as an unsigned int,
291 * with the corresponding cast to a signed int to insure that the
292 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
293 * and the register representation of a signed int (msr in 64-bit mode) is performed.
294 */
295asmlinkage long compat_sys_getpgid(u32 pid)
296{
297 return sys_getpgid((int)pid);
298}
299
300
301
302/* Note: it is necessary to treat pid as an unsigned int,
303 * with the corresponding cast to a signed int to insure that the
304 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
305 * and the register representation of a signed int (msr in 64-bit mode) is performed.
306 */
307asmlinkage long compat_sys_getsid(u32 pid)
308{
309 return sys_getsid((int)pid);
310}
311
312
313/* Note: it is necessary to treat pid and sig as unsigned ints,
314 * with the corresponding cast to a signed int to insure that the
315 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
316 * and the register representation of a signed int (msr in 64-bit mode) is performed.
317 */
318asmlinkage long compat_sys_kill(u32 pid, u32 sig)
319{
320 return sys_kill((int)pid, (int)sig);
321}
322
323
324/* Note: it is necessary to treat mode as an unsigned int,
325 * with the corresponding cast to a signed int to insure that the
326 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
327 * and the register representation of a signed int (msr in 64-bit mode) is performed.
328 */
329asmlinkage long compat_sys_mkdir(const char __user * pathname, u32 mode)
330{
331 return sys_mkdir(pathname, (int)mode);
332}
333
334long compat_sys_nice(u32 increment)
335{
336 /* sign extend increment */
337 return sys_nice((int)increment);
338}
339
340off_t ppc32_lseek(unsigned int fd, u32 offset, unsigned int origin)
341{
342 /* sign extend n */
343 return sys_lseek(fd, (int)offset, origin);
344}
345
346long compat_sys_truncate(const char __user * path, u32 length)
347{
348 /* sign extend length */
349 return sys_truncate(path, (int)length);
350}
351
352long compat_sys_ftruncate(int fd, u32 length)
353{
354 /* sign extend length */
355 return sys_ftruncate(fd, (int)length);
356}
357
358/* Note: it is necessary to treat bufsiz as an unsigned int,
359 * with the corresponding cast to a signed int to insure that the
360 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
361 * and the register representation of a signed int (msr in 64-bit mode) is performed.
362 */
363asmlinkage long compat_sys_readlink(const char __user * path, char __user * buf, u32 bufsiz)
364{
365 return sys_readlink(path, buf, (int)bufsiz);
366}
367
368/* Note: it is necessary to treat option as an unsigned int,
369 * with the corresponding cast to a signed int to insure that the
370 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
371 * and the register representation of a signed int (msr in 64-bit mode) is performed.
372 */
373asmlinkage long compat_sys_sched_get_priority_max(u32 policy)
374{
375 return sys_sched_get_priority_max((int)policy);
376}
377
378
379/* Note: it is necessary to treat policy as an unsigned int,
380 * with the corresponding cast to a signed int to insure that the
381 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
382 * and the register representation of a signed int (msr in 64-bit mode) is performed.
383 */
384asmlinkage long compat_sys_sched_get_priority_min(u32 policy)
385{
386 return sys_sched_get_priority_min((int)policy);
387}
388
389
390/* Note: it is necessary to treat pid as an unsigned int,
391 * with the corresponding cast to a signed int to insure that the
392 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
393 * and the register representation of a signed int (msr in 64-bit mode) is performed.
394 */
395asmlinkage long compat_sys_sched_getparam(u32 pid, struct sched_param __user *param)
396{
397 return sys_sched_getparam((int)pid, param);
398}
399
400
401/* Note: it is necessary to treat pid as an unsigned int,
402 * with the corresponding cast to a signed int to insure that the
403 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
404 * and the register representation of a signed int (msr in 64-bit mode) is performed.
405 */
406asmlinkage long compat_sys_sched_getscheduler(u32 pid)
407{
408 return sys_sched_getscheduler((int)pid);
409}
410
411
412/* Note: it is necessary to treat pid as an unsigned int,
413 * with the corresponding cast to a signed int to insure that the
414 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
415 * and the register representation of a signed int (msr in 64-bit mode) is performed.
416 */
417asmlinkage long compat_sys_sched_setparam(u32 pid, struct sched_param __user *param)
418{
419 return sys_sched_setparam((int)pid, param);
420}
421
422
423/* Note: it is necessary to treat pid and policy as unsigned ints,
424 * with the corresponding cast to a signed int to insure that the
425 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
426 * and the register representation of a signed int (msr in 64-bit mode) is performed.
427 */
428asmlinkage long compat_sys_sched_setscheduler(u32 pid, u32 policy, struct sched_param __user *param)
429{
430 return sys_sched_setscheduler((int)pid, (int)policy, param);
431}
432
433
434/* Note: it is necessary to treat len as an unsigned int,
435 * with the corresponding cast to a signed int to insure that the
436 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
437 * and the register representation of a signed int (msr in 64-bit mode) is performed.
438 */
439asmlinkage long compat_sys_setdomainname(char __user *name, u32 len)
440{
441 return sys_setdomainname(name, (int)len);
442}
443
444
445/* Note: it is necessary to treat gidsetsize as an unsigned int,
446 * with the corresponding cast to a signed int to insure that the
447 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
448 * and the register representation of a signed int (msr in 64-bit mode) is performed.
449 */
450asmlinkage long compat_sys_setgroups(u32 gidsetsize, gid_t __user *grouplist)
451{
452 return sys_setgroups((int)gidsetsize, grouplist);
453}
454
455
456asmlinkage long compat_sys_sethostname(char __user *name, u32 len)
457{
458 /* sign extend len */
459 return sys_sethostname(name, (int)len);
460}
461
462
463/* Note: it is necessary to treat pid and pgid as unsigned ints,
464 * with the corresponding cast to a signed int to insure that the
465 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
466 * and the register representation of a signed int (msr in 64-bit mode) is performed.
467 */
468asmlinkage long compat_sys_setpgid(u32 pid, u32 pgid)
469{
470 return sys_setpgid((int)pid, (int)pgid);
471}
472
473long compat_sys_getpriority(u32 which, u32 who)
474{
475 /* sign extend which and who */
476 return sys_getpriority((int)which, (int)who);
477}
478
479long compat_sys_setpriority(u32 which, u32 who, u32 niceval)
480{
481 /* sign extend which, who and niceval */
482 return sys_setpriority((int)which, (int)who, (int)niceval);
483}
484
485long compat_sys_ioprio_get(u32 which, u32 who)
486{
487 /* sign extend which and who */
488 return sys_ioprio_get((int)which, (int)who);
489}
490
491long compat_sys_ioprio_set(u32 which, u32 who, u32 ioprio)
492{
493 /* sign extend which, who and ioprio */
494 return sys_ioprio_set((int)which, (int)who, (int)ioprio);
495}
496
497/* Note: it is necessary to treat newmask as an unsigned int,
498 * with the corresponding cast to a signed int to insure that the
499 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
500 * and the register representation of a signed int (msr in 64-bit mode) is performed.
501 */
502asmlinkage long compat_sys_ssetmask(u32 newmask)
503{
504 return sys_ssetmask((int) newmask);
505}
506
507asmlinkage long compat_sys_syslog(u32 type, char __user * buf, u32 len)
508{
509 /* sign extend len */
510 return sys_syslog(type, buf, (int)len);
511}
512
513
514/* Note: it is necessary to treat mask as an unsigned int,
515 * with the corresponding cast to a signed int to insure that the
516 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
517 * and the register representation of a signed int (msr in 64-bit mode) is performed.
518 */
519asmlinkage long compat_sys_umask(u32 mask)
520{
521 return sys_umask((int)mask);
522}
523
524unsigned long compat_sys_mmap2(unsigned long addr, size_t len,
525 unsigned long prot, unsigned long flags,
526 unsigned long fd, unsigned long pgoff)
527{
528 /* This should remain 12 even if PAGE_SIZE changes */
529 return sys_mmap(addr, len, prot, flags, fd, pgoff << 12);
530}
531
532long compat_sys_tgkill(u32 tgid, u32 pid, int sig)
533{
534 /* sign extend tgid, pid */
535 return sys_tgkill((int)tgid, (int)pid, sig);
536}
537
538/*
539 * long long munging:
540 * The 32 bit ABI passes long longs in an odd even register pair.
541 */
542
543compat_ssize_t compat_sys_pread64(unsigned int fd, char __user *ubuf, compat_size_t count,
544 u32 reg6, u32 poshi, u32 poslo)
545{
546 return sys_pread64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
547}
548
549compat_ssize_t compat_sys_pwrite64(unsigned int fd, const char __user *ubuf, compat_size_t count,
550 u32 reg6, u32 poshi, u32 poslo)
551{
552 return sys_pwrite64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
553}
554
555compat_ssize_t compat_sys_readahead(int fd, u32 r4, u32 offhi, u32 offlo, u32 count)
556{
557 return sys_readahead(fd, ((loff_t)offhi << 32) | offlo, count);
558}
559
560asmlinkage int compat_sys_truncate64(const char __user * path, u32 reg4,
561 unsigned long high, unsigned long low)
562{
563 return sys_truncate(path, (high << 32) | low);
564}
565
566asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo,
567 u32 lenhi, u32 lenlo)
568{
569 return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo,
570 ((loff_t)lenhi << 32) | lenlo);
571}
572
573asmlinkage int compat_sys_ftruncate64(unsigned int fd, u32 reg4, unsigned long high,
574 unsigned long low)
575{
576 return sys_ftruncate(fd, (high << 32) | low);
577}
578
579long ppc32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
580 size_t len)
581{
582 return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
583 buf, len);
584}
585
586long ppc32_fadvise64(int fd, u32 unused, u32 offset_high, u32 offset_low,
587 size_t len, int advice)
588{
589 return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, len,
590 advice);
591}
592
593asmlinkage long compat_sys_add_key(const char __user *_type,
594 const char __user *_description,
595 const void __user *_payload,
596 u32 plen,
597 u32 ringid)
598{
599 return sys_add_key(_type, _description, _payload, plen, ringid);
600}
601
602asmlinkage long compat_sys_request_key(const char __user *_type,
603 const char __user *_description,
604 const char __user *_callout_info,
605 u32 destringid)
606{
607 return sys_request_key(_type, _description, _callout_info, destringid);
608}
609
610asmlinkage long compat_sys_sync_file_range2(int fd, unsigned int flags,
611 unsigned offset_hi, unsigned offset_lo,
612 unsigned nbytes_hi, unsigned nbytes_lo)
613{
614 loff_t offset = ((loff_t)offset_hi << 32) | offset_lo;
615 loff_t nbytes = ((loff_t)nbytes_hi << 32) | nbytes_lo;
616
617 return sys_sync_file_range(fd, offset, nbytes, flags);
618}
619
620asmlinkage long compat_sys_fanotify_mark(int fanotify_fd, unsigned int flags,
621 unsigned mask_hi, unsigned mask_lo,
622 int dfd, const char __user *pathname)
623{
624 u64 mask = ((u64)mask_hi << 32) | mask_lo;
625 return sys_fanotify_mark(fanotify_fd, flags, mask, dfd, pathname);
626}