arch/mips/kernel/syscall.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1995, 1996, 1997, 2000, 2001, 05 by Ralf Baechle
   7  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   8  * Copyright (C) 2001 MIPS Technologies, Inc.
   9  */
  10 #include <linux/capability.h>
  11 #include <linux/errno.h>
  12 #include <linux/linkage.h>
  13 #include <linux/fs.h>
  14 #include <linux/smp.h>
  15 #include <linux/ptrace.h>
  16 #include <linux/string.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/file.h>
  19 #include <linux/utsname.h>
  20 #include <linux/unistd.h>
  21 #include <linux/sem.h>
  22 #include <linux/msg.h>
  23 #include <linux/shm.h>
  24 #include <linux/compiler.h>
  25 #include <linux/ipc.h>
  26 #include <linux/uaccess.h>
  27 #include <linux/slab.h>
  28 #include <linux/elf.h>
  29
  30 #include <asm/asm.h>
  31 #include <asm/branch.h>
  32 #include <asm/cachectl.h>
  33 #include <asm/cacheflush.h>
  34 #include <asm/asm-offsets.h>
  35 #include <asm/signal.h>
  36 #include <asm/sim.h>
  37 #include <asm/shmparam.h>
  38 #include <asm/sysmips.h>
  39 #include <asm/uaccess.h>
  40 #include <asm/switch_to.h>
  41
  42 /*
  43  * For historic reasons the pipe(2) syscall on MIPS has an unusual calling
  44  * convention.  It returns results in registers $v0 / $v1 which means there
  45  * is no need for it to do verify the validity of a userspace pointer
  46  * argument.  Historically that used to be expensive in Linux.  These days
  47  * the performance advantage is negligible.
  48  */
  49 asmlinkage int sysm_pipe(nabi_no_regargs volatile struct pt_regs regs)
  50 {
  51         int fd[2];
  52         int error, res;
  53
  54         error = do_pipe_flags(fd, 0);
  55         if (error) {
  56                 res = error;
  57                 goto out;
  58         }
  59         regs.regs[3] = fd[1];
  60         res = fd[0];
  61 out:
  62         return res;
  63 }
  64
  65 SYSCALL_DEFINE6(mips_mmap, unsigned long, addr, unsigned long, len,
  66         unsigned long, prot, unsigned long, flags, unsigned long,
  67         fd, off_t, offset)
  68 {
  69         unsigned long result;
  70
  71         result = -EINVAL;
  72         if (offset & ~PAGE_MASK)
  73                 goto out;
  74
  75         result = sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
  76
  77 out:
  78         return result;
  79 }
  80
  81 SYSCALL_DEFINE6(mips_mmap2, unsigned long, addr, unsigned long, len,
  82         unsigned long, prot, unsigned long, flags, unsigned long, fd,
  83         unsigned long, pgoff)
  84 {
  85         if (pgoff & (~PAGE_MASK >> 12))
  86                 return -EINVAL;
  87
  88         return sys_mmap_pgoff(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT-12));
  89 }
  90
  91 save_static_function(sys_fork);
  92 static int __used noinline
  93 _sys_fork(nabi_no_regargs struct pt_regs regs)
  94 {
  95         return do_fork(SIGCHLD, regs.regs[29], 0, NULL, NULL);
  96 }
  97
  98 save_static_function(sys_clone);
  99 static int __used noinline
 100 _sys_clone(nabi_no_regargs struct pt_regs regs)
 101 {
 102         unsigned long clone_flags;
 103         unsigned long newsp;
 104         int __user *parent_tidptr, *child_tidptr;
 105
 106         clone_flags = regs.regs[4];
 107         newsp = regs.regs[5];
 108         if (!newsp)
 109                 newsp = regs.regs[29];
 110         parent_tidptr = (int __user *) regs.regs[6];
 111 #ifdef CONFIG_32BIT
 112         /* We need to fetch the fifth argument off the stack.  */
 113         child_tidptr = NULL;
 114         if (clone_flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) {
 115                 int __user *__user *usp = (int __user *__user *) regs.regs[29];
 116                 if (regs.regs[2] == __NR_syscall) {
 117                         if (get_user (child_tidptr, &usp[5]))
 118                                 return -EFAULT;
 119                 }
 120                 else if (get_user (child_tidptr, &usp[4]))
 121                         return -EFAULT;
 122         }
 123 #else
 124         child_tidptr = (int __user *) regs.regs[8];
 125 #endif
 126         return do_fork(clone_flags, newsp, 0,
 127                        parent_tidptr, child_tidptr);
 128 }
 129
 130 SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)
 131 {
 132         struct thread_info *ti = task_thread_info(current);
 133
 134         ti->tp_value = addr;
 135         if (cpu_has_userlocal)
 136                 write_c0_userlocal(addr);
 137
 138         return 0;
 139 }
 140
 141 static inline int mips_atomic_set(unsigned long addr, unsigned long new)
 142 {
 143         unsigned long old, tmp;
 144         struct pt_regs *regs;
 145         unsigned int err;
 146
 147         if (unlikely(addr & 3))
 148                 return -EINVAL;
 149
 150         if (unlikely(!access_ok(VERIFY_WRITE, addr, 4)))
 151                 return -EINVAL;
 152
 153         if (cpu_has_llsc && R10000_LLSC_WAR) {
 154                 __asm__ __volatile__ (
 155                 "       .set    mips3                                   \n"
 156                 "       li      %[err], 0                               \n"
 157                 "1:     ll      %[old], (%[addr])                       \n"
 158                 "       move    %[tmp], %[new]                          \n"
 159                 "2:     sc      %[tmp], (%[addr])                       \n"
 160                 "       beqzl   %[tmp], 1b                              \n"
 161                 "3:                                                     \n"
 162                 "       .section .fixup,\"ax\"                          \n"
 163                 "4:     li      %[err], %[efault]                       \n"
 164                 "       j       3b                                      \n"
 165                 "       .previous                                       \n"
 166                 "       .section __ex_table,\"a\"                       \n"
 167                 "       "STR(PTR)"      1b, 4b                          \n"
 168                 "       "STR(PTR)"      2b, 4b                          \n"
 169                 "       .previous                                       \n"
 170                 "       .set    mips0                                   \n"
 171                 : [old] "=&r" (old),
 172                   [err] "=&r" (err),
 173                   [tmp] "=&r" (tmp)
 174                 : [addr] "r" (addr),
 175                   [new] "r" (new),
 176                   [efault] "i" (-EFAULT)
 177                 : "memory");
 178         } else if (cpu_has_llsc) {
 179                 __asm__ __volatile__ (
 180                 "       .set    mips3                                   \n"
 181                 "       li      %[err], 0                               \n"
 182                 "1:     ll      %[old], (%[addr])                       \n"
 183                 "       move    %[tmp], %[new]                          \n"
 184                 "2:     sc      %[tmp], (%[addr])                       \n"
 185                 "       bnez    %[tmp], 4f                              \n"
 186                 "3:                                                     \n"
 187                 "       .subsection 2                                   \n"
 188                 "4:     b       1b                                      \n"
 189                 "       .previous                                       \n"
 190                 "                                                       \n"
 191                 "       .section .fixup,\"ax\"                          \n"
 192                 "5:     li      %[err], %[efault]                       \n"
 193                 "       j       3b                                      \n"
 194                 "       .previous                                       \n"
 195                 "       .section __ex_table,\"a\"                       \n"
 196                 "       "STR(PTR)"      1b, 5b                          \n"
 197                 "       "STR(PTR)"      2b, 5b                          \n"
 198                 "       .previous                                       \n"
 199                 "       .set    mips0                                   \n"
 200                 : [old] "=&r" (old),
 201                   [err] "=&r" (err),
 202                   [tmp] "=&r" (tmp)
 203                 : [addr] "r" (addr),
 204                   [new] "r" (new),
 205                   [efault] "i" (-EFAULT)
 206                 : "memory");
 207         } else {
 208                 do {
 209                         preempt_disable();
 210                         ll_bit = 1;
 211                         ll_task = current;
 212                         preempt_enable();
 213
 214                         err = __get_user(old, (unsigned int *) addr);
 215                         err |= __put_user(new, (unsigned int *) addr);
 216                         if (err)
 217                                 break;
 218                         rmb();
 219                 } while (!ll_bit);
 220         }
 221
 222         if (unlikely(err))
 223                 return err;
 224
 225         regs = current_pt_regs();
 226         regs->regs[2] = old;
 227         regs->regs[7] = 0;      /* No error */
 228
 229         /*
 230          * Don't let your children do this ...
 231          */
 232         __asm__ __volatile__(
 233         "       move    $29, %0                                         \n"
 234         "       j       syscall_exit                                    \n"
 235         : /* no outputs */
 236         : "r" (regs));
 237
 238         /* unreached.  Honestly.  */
 239         unreachable();
 240 }
 241
 242 SYSCALL_DEFINE3(sysmips, long, cmd, long, arg1, long, arg2)
 243 {
 244         switch (cmd) {
 245         case MIPS_ATOMIC_SET:
 246                 return mips_atomic_set(arg1, arg2);
 247
 248         case MIPS_FIXADE:
 249                 if (arg1 & ~3)
 250                         return -EINVAL;
 251
 252                 if (arg1 & 1)
 253                         set_thread_flag(TIF_FIXADE);
 254                 else
 255                         clear_thread_flag(TIF_FIXADE);
 256                 if (arg1 & 2)
 257                         set_thread_flag(TIF_LOGADE);
 258                 else
 259                         clear_thread_flag(TIF_LOGADE);
 260
 261                 return 0;
 262
 263         case FLUSH_CACHE:
 264                 __flush_cache_all();
 265                 return 0;
 266         }
 267
 268         return -EINVAL;
 269 }
 270
 271 /*
 272  * No implemented yet ...
 273  */
 274 SYSCALL_DEFINE3(cachectl, char *, addr, int, nbytes, int, op)
 275 {
 276         return -ENOSYS;
 277 }
 278
 279 /*
 280  * If we ever come here the user sp is bad.  Zap the process right away.
 281  * Due to the bad stack signaling wouldn't work.
 282  */
 283 asmlinkage void bad_stack(void)
 284 {
 285         do_exit(SIGSEGV);
 286 }