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/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>
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>
45 #include <asm/ptrace.h>
46 #include <asm/types.h>
47 #include <asm/uaccess.h>
48 #include <asm/unistd.h>
50 #include <asm/mmu_context.h>
51 #include <asm/ppc-pci.h>
52 #include <asm/syscalls.h>
53 #include <asm/switch_to.h>
56 asmlinkage long ppc32_select(u32 n, compat_ulong_t __user *inp,
57 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
61 return compat_sys_select((int)n, inp, outp, exp, compat_ptr(tvp_x));
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.
69 asmlinkage long compat_sys_sysfs(u32 option, u32 arg1, u32 arg2)
71 return sys_sysfs((int)option, arg1, arg2);
75 long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr,
80 version = call >> 16; /* hack for backward compatibility */
87 /* sign extend semid */
88 return compat_sys_semtimedop((int)first,
89 compat_ptr(ptr), second,
91 /* else fall through for normal 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,
98 /* sign extend key, nsems */
99 return sys_semget((int)first, (int)second, third);
101 /* sign extend semid, semnum */
102 return compat_sys_semctl((int)first, (int)second, third,
106 /* sign extend msqid */
107 return compat_sys_msgsnd((int)first, (int)second, third,
110 /* sign extend msqid, msgtyp */
111 return compat_sys_msgrcv((int)first, second, (int)fifth,
112 third, version, compat_ptr(ptr));
114 /* sign extend key */
115 return sys_msgget((int)first, second);
117 /* sign extend msqid */
118 return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
121 /* sign extend shmid */
122 return compat_sys_shmat((int)first, second, third, version,
125 return sys_shmdt(compat_ptr(ptr));
127 /* sign extend key_t */
128 return sys_shmget((int)first, second, third);
130 /* sign extend shmid */
131 return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
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.
146 asmlinkage long compat_sys_sendfile_wrapper(u32 out_fd, u32 in_fd,
147 compat_off_t __user *offset, u32 count)
149 return compat_sys_sendfile((int)out_fd, (int)in_fd, offset, count);
152 asmlinkage long compat_sys_sendfile64_wrapper(u32 out_fd, u32 in_fd,
153 compat_loff_t __user *offset, u32 count)
155 return sys_sendfile((int)out_fd, (int)in_fd,
156 (off_t __user *)offset, count);
159 /* Note: it is necessary to treat option as an unsigned int,
160 * with the corresponding cast to a signed int to insure that the
161 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
162 * and the register representation of a signed int (msr in 64-bit mode) is performed.
164 asmlinkage long compat_sys_prctl(u32 option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
166 return sys_prctl((int)option,
167 (unsigned long) arg2,
168 (unsigned long) arg3,
169 (unsigned long) arg4,
170 (unsigned long) arg5);
173 /* Note: it is necessary to treat pid as an unsigned int,
174 * with the corresponding cast to a signed int to insure that the
175 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
176 * and the register representation of a signed int (msr in 64-bit mode) is performed.
178 asmlinkage long compat_sys_sched_rr_get_interval_wrapper(u32 pid,
179 struct compat_timespec __user *interval)
181 return compat_sys_sched_rr_get_interval((int)pid, interval);
184 /* Note: it is necessary to treat mode as an unsigned int,
185 * with the corresponding cast to a signed int to insure that the
186 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
187 * and the register representation of a signed int (msr in 64-bit mode) is performed.
189 asmlinkage long compat_sys_access(const char __user * filename, u32 mode)
191 return sys_access(filename, (int)mode);
195 /* Note: it is necessary to treat mode as an unsigned int,
196 * with the corresponding cast to a signed int to insure that the
197 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
198 * and the register representation of a signed int (msr in 64-bit mode) is performed.
200 asmlinkage long compat_sys_creat(const char __user * pathname, u32 mode)
202 return sys_creat(pathname, (int)mode);
206 /* Note: it is necessary to treat pid and options as unsigned ints,
207 * with the corresponding cast to a signed int to insure that the
208 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
209 * and the register representation of a signed int (msr in 64-bit mode) is performed.
211 asmlinkage long compat_sys_waitpid(u32 pid, unsigned int __user * stat_addr, u32 options)
213 return sys_waitpid((int)pid, stat_addr, (int)options);
217 /* Note: it is necessary to treat gidsetsize as an unsigned int,
218 * with the corresponding cast to a signed int to insure that the
219 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
220 * and the register representation of a signed int (msr in 64-bit mode) is performed.
222 asmlinkage long compat_sys_getgroups(u32 gidsetsize, gid_t __user *grouplist)
224 return sys_getgroups((int)gidsetsize, grouplist);
228 /* Note: it is necessary to treat pid as an unsigned int,
229 * with the corresponding cast to a signed int to insure that the
230 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
231 * and the register representation of a signed int (msr in 64-bit mode) is performed.
233 asmlinkage long compat_sys_getpgid(u32 pid)
235 return sys_getpgid((int)pid);
240 /* Note: it is necessary to treat pid as an unsigned int,
241 * with the corresponding cast to a signed int to insure that the
242 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
243 * and the register representation of a signed int (msr in 64-bit mode) is performed.
245 asmlinkage long compat_sys_getsid(u32 pid)
247 return sys_getsid((int)pid);
251 /* Note: it is necessary to treat pid and sig as unsigned ints,
252 * with the corresponding cast to a signed int to insure that the
253 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
254 * and the register representation of a signed int (msr in 64-bit mode) is performed.
256 asmlinkage long compat_sys_kill(u32 pid, u32 sig)
258 return sys_kill((int)pid, (int)sig);
262 /* Note: it is necessary to treat mode as an unsigned int,
263 * with the corresponding cast to a signed int to insure that the
264 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
265 * and the register representation of a signed int (msr in 64-bit mode) is performed.
267 asmlinkage long compat_sys_mkdir(const char __user * pathname, u32 mode)
269 return sys_mkdir(pathname, (int)mode);
272 long compat_sys_nice(u32 increment)
274 /* sign extend increment */
275 return sys_nice((int)increment);
278 off_t ppc32_lseek(unsigned int fd, u32 offset, unsigned int origin)
281 return sys_lseek(fd, (int)offset, origin);
284 long compat_sys_truncate(const char __user * path, u32 length)
286 /* sign extend length */
287 return sys_truncate(path, (int)length);
290 long compat_sys_ftruncate(int fd, u32 length)
292 /* sign extend length */
293 return sys_ftruncate(fd, (int)length);
296 /* Note: it is necessary to treat bufsiz as an unsigned int,
297 * with the corresponding cast to a signed int to insure that the
298 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
299 * and the register representation of a signed int (msr in 64-bit mode) is performed.
301 asmlinkage long compat_sys_readlink(const char __user * path, char __user * buf, u32 bufsiz)
303 return sys_readlink(path, buf, (int)bufsiz);
306 /* Note: it is necessary to treat option as an unsigned int,
307 * with the corresponding cast to a signed int to insure that the
308 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
309 * and the register representation of a signed int (msr in 64-bit mode) is performed.
311 asmlinkage long compat_sys_sched_get_priority_max(u32 policy)
313 return sys_sched_get_priority_max((int)policy);
317 /* Note: it is necessary to treat policy as an unsigned int,
318 * with the corresponding cast to a signed int to insure that the
319 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
320 * and the register representation of a signed int (msr in 64-bit mode) is performed.
322 asmlinkage long compat_sys_sched_get_priority_min(u32 policy)
324 return sys_sched_get_priority_min((int)policy);
328 /* Note: it is necessary to treat pid as an unsigned int,
329 * with the corresponding cast to a signed int to insure that the
330 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
331 * and the register representation of a signed int (msr in 64-bit mode) is performed.
333 asmlinkage long compat_sys_sched_getparam(u32 pid, struct sched_param __user *param)
335 return sys_sched_getparam((int)pid, param);
339 /* Note: it is necessary to treat pid as an unsigned int,
340 * with the corresponding cast to a signed int to insure that the
341 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
342 * and the register representation of a signed int (msr in 64-bit mode) is performed.
344 asmlinkage long compat_sys_sched_getscheduler(u32 pid)
346 return sys_sched_getscheduler((int)pid);
350 /* Note: it is necessary to treat pid as an unsigned int,
351 * with the corresponding cast to a signed int to insure that the
352 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
353 * and the register representation of a signed int (msr in 64-bit mode) is performed.
355 asmlinkage long compat_sys_sched_setparam(u32 pid, struct sched_param __user *param)
357 return sys_sched_setparam((int)pid, param);
361 /* Note: it is necessary to treat pid and policy as unsigned ints,
362 * with the corresponding cast to a signed int to insure that the
363 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
364 * and the register representation of a signed int (msr in 64-bit mode) is performed.
366 asmlinkage long compat_sys_sched_setscheduler(u32 pid, u32 policy, struct sched_param __user *param)
368 return sys_sched_setscheduler((int)pid, (int)policy, param);
372 /* Note: it is necessary to treat len as an unsigned int,
373 * with the corresponding cast to a signed int to insure that the
374 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
375 * and the register representation of a signed int (msr in 64-bit mode) is performed.
377 asmlinkage long compat_sys_setdomainname(char __user *name, u32 len)
379 return sys_setdomainname(name, (int)len);
383 /* Note: it is necessary to treat gidsetsize as an unsigned int,
384 * with the corresponding cast to a signed int to insure that the
385 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
386 * and the register representation of a signed int (msr in 64-bit mode) is performed.
388 asmlinkage long compat_sys_setgroups(u32 gidsetsize, gid_t __user *grouplist)
390 return sys_setgroups((int)gidsetsize, grouplist);
394 asmlinkage long compat_sys_sethostname(char __user *name, u32 len)
396 /* sign extend len */
397 return sys_sethostname(name, (int)len);
401 /* Note: it is necessary to treat pid and pgid as unsigned ints,
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.
406 asmlinkage long compat_sys_setpgid(u32 pid, u32 pgid)
408 return sys_setpgid((int)pid, (int)pgid);
411 long compat_sys_getpriority(u32 which, u32 who)
413 /* sign extend which and who */
414 return sys_getpriority((int)which, (int)who);
417 long compat_sys_setpriority(u32 which, u32 who, u32 niceval)
419 /* sign extend which, who and niceval */
420 return sys_setpriority((int)which, (int)who, (int)niceval);
423 long compat_sys_ioprio_get(u32 which, u32 who)
425 /* sign extend which and who */
426 return sys_ioprio_get((int)which, (int)who);
429 long compat_sys_ioprio_set(u32 which, u32 who, u32 ioprio)
431 /* sign extend which, who and ioprio */
432 return sys_ioprio_set((int)which, (int)who, (int)ioprio);
435 /* Note: it is necessary to treat newmask as an unsigned int,
436 * with the corresponding cast to a signed int to insure that the
437 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
438 * and the register representation of a signed int (msr in 64-bit mode) is performed.
440 asmlinkage long compat_sys_ssetmask(u32 newmask)
442 return sys_ssetmask((int) newmask);
445 asmlinkage long compat_sys_syslog(u32 type, char __user * buf, u32 len)
447 /* sign extend len */
448 return sys_syslog(type, buf, (int)len);
452 /* Note: it is necessary to treat mask as an unsigned int,
453 * with the corresponding cast to a signed int to insure that the
454 * proper conversion (sign extension) between the register representation of a signed int (msr in 32-bit mode)
455 * and the register representation of a signed int (msr in 64-bit mode) is performed.
457 asmlinkage long compat_sys_umask(u32 mask)
459 return sys_umask((int)mask);
462 unsigned long compat_sys_mmap2(unsigned long addr, size_t len,
463 unsigned long prot, unsigned long flags,
464 unsigned long fd, unsigned long pgoff)
466 /* This should remain 12 even if PAGE_SIZE changes */
467 return sys_mmap(addr, len, prot, flags, fd, pgoff << 12);
470 long compat_sys_tgkill(u32 tgid, u32 pid, int sig)
472 /* sign extend tgid, pid */
473 return sys_tgkill((int)tgid, (int)pid, sig);
478 * The 32 bit ABI passes long longs in an odd even register pair.
481 compat_ssize_t compat_sys_pread64(unsigned int fd, char __user *ubuf, compat_size_t count,
482 u32 reg6, u32 poshi, u32 poslo)
484 return sys_pread64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
487 compat_ssize_t compat_sys_pwrite64(unsigned int fd, const char __user *ubuf, compat_size_t count,
488 u32 reg6, u32 poshi, u32 poslo)
490 return sys_pwrite64(fd, ubuf, count, ((loff_t)poshi << 32) | poslo);
493 compat_ssize_t compat_sys_readahead(int fd, u32 r4, u32 offhi, u32 offlo, u32 count)
495 return sys_readahead(fd, ((loff_t)offhi << 32) | offlo, count);
498 asmlinkage int compat_sys_truncate64(const char __user * path, u32 reg4,
499 unsigned long high, unsigned long low)
501 return sys_truncate(path, (high << 32) | low);
504 asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo,
505 u32 lenhi, u32 lenlo)
507 return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo,
508 ((loff_t)lenhi << 32) | lenlo);
511 asmlinkage int compat_sys_ftruncate64(unsigned int fd, u32 reg4, unsigned long high,
514 return sys_ftruncate(fd, (high << 32) | low);
517 long ppc32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
520 return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
524 long ppc32_fadvise64(int fd, u32 unused, u32 offset_high, u32 offset_low,
525 size_t len, int advice)
527 return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, len,
531 asmlinkage long compat_sys_add_key(const char __user *_type,
532 const char __user *_description,
533 const void __user *_payload,
537 return sys_add_key(_type, _description, _payload, plen, ringid);
540 asmlinkage long compat_sys_request_key(const char __user *_type,
541 const char __user *_description,
542 const char __user *_callout_info,
545 return sys_request_key(_type, _description, _callout_info, destringid);
548 asmlinkage long compat_sys_sync_file_range2(int fd, unsigned int flags,
549 unsigned offset_hi, unsigned offset_lo,
550 unsigned nbytes_hi, unsigned nbytes_lo)
552 loff_t offset = ((loff_t)offset_hi << 32) | offset_lo;
553 loff_t nbytes = ((loff_t)nbytes_hi << 32) | nbytes_lo;
555 return sys_sync_file_range(fd, offset, nbytes, flags);
558 asmlinkage long compat_sys_fanotify_mark(int fanotify_fd, unsigned int flags,
559 unsigned mask_hi, unsigned mask_lo,
560 int dfd, const char __user *pathname)
562 u64 mask = ((u64)mask_hi << 32) | mask_lo;
563 return sys_fanotify_mark(fanotify_fd, flags, mask, dfd, pathname);