Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 1 | /* |
| 2 | * Implementation of various system calls for Linux/PowerPC |
| 3 | * |
| 4 | * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) |
| 5 | * |
| 6 | * Derived from "arch/i386/kernel/sys_i386.c" |
| 7 | * Adapted from the i386 version by Gary Thomas |
| 8 | * Modified by Cort Dougan (cort@cs.nmt.edu) |
| 9 | * and Paul Mackerras (paulus@cs.anu.edu.au). |
| 10 | * |
| 11 | * This file contains various random system calls that |
| 12 | * have a non-standard calling sequence on the Linux/PPC |
| 13 | * platform. |
| 14 | * |
| 15 | * This program is free software; you can redistribute it and/or |
| 16 | * modify it under the terms of the GNU General Public License |
| 17 | * as published by the Free Software Foundation; either version |
| 18 | * 2 of the License, or (at your option) any later version. |
| 19 | * |
| 20 | */ |
| 21 | |
| 22 | #include <linux/errno.h> |
| 23 | #include <linux/sched.h> |
| 24 | #include <linux/syscalls.h> |
| 25 | #include <linux/mm.h> |
Alexey Dobriyan | 4e950f6 | 2007-07-30 02:36:13 +0400 | [diff] [blame^] | 26 | #include <linux/fs.h> |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 27 | #include <linux/smp.h> |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 28 | #include <linux/sem.h> |
| 29 | #include <linux/msg.h> |
| 30 | #include <linux/shm.h> |
| 31 | #include <linux/stat.h> |
| 32 | #include <linux/mman.h> |
| 33 | #include <linux/sys.h> |
| 34 | #include <linux/ipc.h> |
| 35 | #include <linux/utsname.h> |
| 36 | #include <linux/file.h> |
| 37 | #include <linux/init.h> |
| 38 | #include <linux/personality.h> |
| 39 | |
| 40 | #include <asm/uaccess.h> |
| 41 | #include <asm/ipc.h> |
| 42 | #include <asm/semaphore.h> |
Arnd Bergmann | a7f3184 | 2006-03-23 00:00:08 +0100 | [diff] [blame] | 43 | #include <asm/syscalls.h> |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 44 | #include <asm/time.h> |
| 45 | #include <asm/unistd.h> |
| 46 | |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 47 | /* |
| 48 | * sys_ipc() is the de-multiplexer for the SysV IPC calls.. |
| 49 | * |
| 50 | * This is really horribly ugly. |
| 51 | */ |
| 52 | int sys_ipc(uint call, int first, unsigned long second, long third, |
| 53 | void __user *ptr, long fifth) |
| 54 | { |
| 55 | int version, ret; |
| 56 | |
| 57 | version = call >> 16; /* hack for backward compatibility */ |
| 58 | call &= 0xffff; |
| 59 | |
| 60 | ret = -ENOSYS; |
| 61 | switch (call) { |
| 62 | case SEMOP: |
| 63 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, |
| 64 | (unsigned)second, NULL); |
| 65 | break; |
| 66 | case SEMTIMEDOP: |
| 67 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, |
| 68 | (unsigned)second, |
| 69 | (const struct timespec __user *) fifth); |
| 70 | break; |
| 71 | case SEMGET: |
| 72 | ret = sys_semget (first, (int)second, third); |
| 73 | break; |
| 74 | case SEMCTL: { |
| 75 | union semun fourth; |
| 76 | |
| 77 | ret = -EINVAL; |
| 78 | if (!ptr) |
| 79 | break; |
| 80 | if ((ret = get_user(fourth.__pad, (void __user * __user *)ptr))) |
| 81 | break; |
| 82 | ret = sys_semctl(first, (int)second, third, fourth); |
| 83 | break; |
| 84 | } |
| 85 | case MSGSND: |
| 86 | ret = sys_msgsnd(first, (struct msgbuf __user *)ptr, |
| 87 | (size_t)second, third); |
| 88 | break; |
| 89 | case MSGRCV: |
| 90 | switch (version) { |
| 91 | case 0: { |
| 92 | struct ipc_kludge tmp; |
| 93 | |
| 94 | ret = -EINVAL; |
| 95 | if (!ptr) |
| 96 | break; |
| 97 | if ((ret = copy_from_user(&tmp, |
| 98 | (struct ipc_kludge __user *) ptr, |
| 99 | sizeof (tmp)) ? -EFAULT : 0)) |
| 100 | break; |
| 101 | ret = sys_msgrcv(first, tmp.msgp, (size_t) second, |
| 102 | tmp.msgtyp, third); |
| 103 | break; |
| 104 | } |
| 105 | default: |
| 106 | ret = sys_msgrcv (first, (struct msgbuf __user *) ptr, |
| 107 | (size_t)second, fifth, third); |
| 108 | break; |
| 109 | } |
| 110 | break; |
| 111 | case MSGGET: |
| 112 | ret = sys_msgget((key_t)first, (int)second); |
| 113 | break; |
| 114 | case MSGCTL: |
| 115 | ret = sys_msgctl(first, (int)second, |
| 116 | (struct msqid_ds __user *)ptr); |
| 117 | break; |
| 118 | case SHMAT: { |
| 119 | ulong raddr; |
| 120 | ret = do_shmat(first, (char __user *)ptr, (int)second, &raddr); |
| 121 | if (ret) |
| 122 | break; |
| 123 | ret = put_user(raddr, (ulong __user *) third); |
| 124 | break; |
| 125 | } |
| 126 | case SHMDT: |
| 127 | ret = sys_shmdt((char __user *)ptr); |
| 128 | break; |
| 129 | case SHMGET: |
| 130 | ret = sys_shmget(first, (size_t)second, third); |
| 131 | break; |
| 132 | case SHMCTL: |
| 133 | ret = sys_shmctl(first, (int)second, |
| 134 | (struct shmid_ds __user *)ptr); |
| 135 | break; |
| 136 | } |
| 137 | |
| 138 | return ret; |
| 139 | } |
| 140 | |
| 141 | /* |
| 142 | * sys_pipe() is the normal C calling standard for creating |
| 143 | * a pipe. It's not the way unix traditionally does this, though. |
| 144 | */ |
| 145 | int sys_pipe(int __user *fildes) |
| 146 | { |
| 147 | int fd[2]; |
| 148 | int error; |
| 149 | |
| 150 | error = do_pipe(fd); |
| 151 | if (!error) { |
| 152 | if (copy_to_user(fildes, fd, 2*sizeof(int))) |
| 153 | error = -EFAULT; |
| 154 | } |
| 155 | return error; |
| 156 | } |
| 157 | |
| 158 | static inline unsigned long do_mmap2(unsigned long addr, size_t len, |
| 159 | unsigned long prot, unsigned long flags, |
| 160 | unsigned long fd, unsigned long off, int shift) |
| 161 | { |
| 162 | struct file * file = NULL; |
Michael Ellerman | 05d8468 | 2005-10-21 16:01:34 +1000 | [diff] [blame] | 163 | unsigned long ret = -EINVAL; |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 164 | |
| 165 | if (shift) { |
| 166 | if (off & ((1 << shift) - 1)) |
| 167 | goto out; |
| 168 | off >>= shift; |
| 169 | } |
| 170 | |
| 171 | ret = -EBADF; |
| 172 | if (!(flags & MAP_ANONYMOUS)) { |
| 173 | if (!(file = fget(fd))) |
| 174 | goto out; |
| 175 | } |
| 176 | |
| 177 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); |
| 178 | |
| 179 | down_write(¤t->mm->mmap_sem); |
| 180 | ret = do_mmap_pgoff(file, addr, len, prot, flags, off); |
| 181 | up_write(¤t->mm->mmap_sem); |
| 182 | if (file) |
| 183 | fput(file); |
| 184 | out: |
| 185 | return ret; |
| 186 | } |
| 187 | |
| 188 | unsigned long sys_mmap2(unsigned long addr, size_t len, |
| 189 | unsigned long prot, unsigned long flags, |
| 190 | unsigned long fd, unsigned long pgoff) |
| 191 | { |
| 192 | return do_mmap2(addr, len, prot, flags, fd, pgoff, PAGE_SHIFT-12); |
| 193 | } |
| 194 | |
| 195 | unsigned long sys_mmap(unsigned long addr, size_t len, |
| 196 | unsigned long prot, unsigned long flags, |
| 197 | unsigned long fd, off_t offset) |
| 198 | { |
| 199 | return do_mmap2(addr, len, prot, flags, fd, offset, PAGE_SHIFT); |
| 200 | } |
| 201 | |
| 202 | #ifdef CONFIG_PPC32 |
| 203 | /* |
| 204 | * Due to some executables calling the wrong select we sometimes |
| 205 | * get wrong args. This determines how the args are being passed |
| 206 | * (a single ptr to them all args passed) then calls |
| 207 | * sys_select() with the appropriate args. -- Cort |
| 208 | */ |
| 209 | int |
| 210 | ppc_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp) |
| 211 | { |
| 212 | if ( (unsigned long)n >= 4096 ) |
| 213 | { |
| 214 | unsigned long __user *buffer = (unsigned long __user *)n; |
| 215 | if (!access_ok(VERIFY_READ, buffer, 5*sizeof(unsigned long)) |
| 216 | || __get_user(n, buffer) |
| 217 | || __get_user(inp, ((fd_set __user * __user *)(buffer+1))) |
| 218 | || __get_user(outp, ((fd_set __user * __user *)(buffer+2))) |
| 219 | || __get_user(exp, ((fd_set __user * __user *)(buffer+3))) |
| 220 | || __get_user(tvp, ((struct timeval __user * __user *)(buffer+4)))) |
| 221 | return -EFAULT; |
| 222 | } |
| 223 | return sys_select(n, inp, outp, exp, tvp); |
| 224 | } |
| 225 | #endif |
| 226 | |
| 227 | #ifdef CONFIG_PPC64 |
| 228 | long ppc64_personality(unsigned long personality) |
| 229 | { |
| 230 | long ret; |
| 231 | |
| 232 | if (personality(current->personality) == PER_LINUX32 |
| 233 | && personality == PER_LINUX) |
| 234 | personality = PER_LINUX32; |
| 235 | ret = sys_personality(personality); |
| 236 | if (ret == PER_LINUX32) |
| 237 | ret = PER_LINUX; |
| 238 | return ret; |
| 239 | } |
| 240 | #endif |
| 241 | |
| 242 | #ifdef CONFIG_PPC64 |
| 243 | #define OVERRIDE_MACHINE (personality(current->personality) == PER_LINUX32) |
| 244 | #else |
| 245 | #define OVERRIDE_MACHINE 0 |
| 246 | #endif |
| 247 | |
Al Viro | ebbd1bc | 2005-12-15 09:19:10 +0000 | [diff] [blame] | 248 | static inline int override_machine(char __user *mach) |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 249 | { |
| 250 | if (OVERRIDE_MACHINE) { |
| 251 | /* change ppc64 to ppc */ |
| 252 | if (__put_user(0, mach+3) || __put_user(0, mach+4)) |
| 253 | return -EFAULT; |
| 254 | } |
| 255 | return 0; |
| 256 | } |
| 257 | |
| 258 | long ppc_newuname(struct new_utsname __user * name) |
| 259 | { |
| 260 | int err = 0; |
| 261 | |
| 262 | down_read(&uts_sem); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 263 | if (copy_to_user(name, utsname(), sizeof(*name))) |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 264 | err = -EFAULT; |
| 265 | up_read(&uts_sem); |
| 266 | if (!err) |
| 267 | err = override_machine(name->machine); |
| 268 | return err; |
| 269 | } |
| 270 | |
| 271 | int sys_uname(struct old_utsname __user *name) |
| 272 | { |
| 273 | int err = 0; |
| 274 | |
| 275 | down_read(&uts_sem); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 276 | if (copy_to_user(name, utsname(), sizeof(*name))) |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 277 | err = -EFAULT; |
| 278 | up_read(&uts_sem); |
| 279 | if (!err) |
| 280 | err = override_machine(name->machine); |
| 281 | return err; |
| 282 | } |
| 283 | |
| 284 | int sys_olduname(struct oldold_utsname __user *name) |
| 285 | { |
| 286 | int error; |
| 287 | |
| 288 | if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname))) |
| 289 | return -EFAULT; |
| 290 | |
| 291 | down_read(&uts_sem); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 292 | error = __copy_to_user(&name->sysname, &utsname()->sysname, |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 293 | __OLD_UTS_LEN); |
| 294 | error |= __put_user(0, name->sysname + __OLD_UTS_LEN); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 295 | error |= __copy_to_user(&name->nodename, &utsname()->nodename, |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 296 | __OLD_UTS_LEN); |
| 297 | error |= __put_user(0, name->nodename + __OLD_UTS_LEN); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 298 | error |= __copy_to_user(&name->release, &utsname()->release, |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 299 | __OLD_UTS_LEN); |
| 300 | error |= __put_user(0, name->release + __OLD_UTS_LEN); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 301 | error |= __copy_to_user(&name->version, &utsname()->version, |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 302 | __OLD_UTS_LEN); |
| 303 | error |= __put_user(0, name->version + __OLD_UTS_LEN); |
Serge E. Hallyn | e9ff399 | 2006-10-02 02:18:11 -0700 | [diff] [blame] | 304 | error |= __copy_to_user(&name->machine, &utsname()->machine, |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 305 | __OLD_UTS_LEN); |
| 306 | error |= override_machine(name->machine); |
| 307 | up_read(&uts_sem); |
| 308 | |
| 309 | return error? -EFAULT: 0; |
| 310 | } |
| 311 | |
Paul Mackerras | 77f543c | 2005-10-18 14:19:41 +1000 | [diff] [blame] | 312 | long ppc_fadvise64_64(int fd, int advice, u32 offset_high, u32 offset_low, |
| 313 | u32 len_high, u32 len_low) |
| 314 | { |
| 315 | return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, |
| 316 | (u64)len_high << 32 | len_low, advice); |
| 317 | } |
| 318 | |
Paul Mackerras | 30286ef | 2005-10-17 20:10:13 +1000 | [diff] [blame] | 319 | void do_show_syscall(unsigned long r3, unsigned long r4, unsigned long r5, |
| 320 | unsigned long r6, unsigned long r7, unsigned long r8, |
| 321 | struct pt_regs *regs) |
| 322 | { |
| 323 | printk("syscall %ld(%lx, %lx, %lx, %lx, %lx, %lx) regs=%p current=%p" |
| 324 | " cpu=%d\n", regs->gpr[0], r3, r4, r5, r6, r7, r8, regs, |
| 325 | current, smp_processor_id()); |
| 326 | } |
| 327 | |
| 328 | void do_show_syscall_exit(unsigned long r3) |
| 329 | { |
| 330 | printk(" -> %lx, current=%p cpu=%d\n", r3, current, smp_processor_id()); |
| 331 | } |