Pileus Git - ~andy/linux/blob - arch/sparc/kernel/sys_sparc_32.c

   1 /* linux/arch/sparc/kernel/sys_sparc.c
   2  *
   3  * This file contains various random system calls that
   4  * have a non-standard calling sequence on the Linux/sparc
   5  * platform.
   6  */
   7
   8 #include <linux/errno.h>
   9 #include <linux/types.h>
  10 #include <linux/sched.h>
  11 #include <linux/mm.h>
  12 #include <linux/fs.h>
  13 #include <linux/file.h>
  14 #include <linux/sem.h>
  15 #include <linux/msg.h>
  16 #include <linux/shm.h>
  17 #include <linux/stat.h>
  18 #include <linux/syscalls.h>
  19 #include <linux/mman.h>
  20 #include <linux/utsname.h>
  21 #include <linux/smp.h>
  22 #include <linux/ipc.h>
  23
  24 #include <asm/uaccess.h>
  25 #include <asm/unistd.h>
  26
  27 /* #define DEBUG_UNIMP_SYSCALL */
  28
  29 /* XXX Make this per-binary type, this way we can detect the type of
  30  * XXX a binary.  Every Sparc executable calls this very early on.
  31  */
  32 asmlinkage unsigned long sys_getpagesize(void)
  33 {
  34         return PAGE_SIZE; /* Possibly older binaries want 8192 on sun4's? */
  35 }
  36
  37 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags)
  38 {
  39         struct vm_unmapped_area_info info;
  40
  41         if (flags & MAP_FIXED) {
  42                 /* We do not accept a shared mapping if it would violate
  43                  * cache aliasing constraints.
  44                  */
  45                 if ((flags & MAP_SHARED) &&
  46                     ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
  47                         return -EINVAL;
  48                 return addr;
  49         }
  50
  51         /* See asm-sparc/uaccess.h */
  52         if (len > TASK_SIZE - PAGE_SIZE)
  53                 return -ENOMEM;
  54         if (!addr)
  55                 addr = TASK_UNMAPPED_BASE;
  56
  57         info.flags = 0;
  58         info.length = len;
  59         info.low_limit = addr;
  60         info.high_limit = TASK_SIZE;
  61         info.align_mask = (flags & MAP_SHARED) ?
  62                 (PAGE_MASK & (SHMLBA - 1)) : 0;
  63         info.align_offset = pgoff << PAGE_SHIFT;
  64         return vm_unmapped_area(&info);
  65 }
  66
  67 /*
  68  * sys_pipe() is the normal C calling standard for creating
  69  * a pipe. It's not the way unix traditionally does this, though.
  70  */
  71 asmlinkage int sparc_pipe(struct pt_regs *regs)
  72 {
  73         int fd[2];
  74         int error;
  75
  76         error = do_pipe_flags(fd, 0);
  77         if (error)
  78                 goto out;
  79         regs->u_regs[UREG_I1] = fd[1];
  80         error = fd[0];
  81 out:
  82         return error;
  83 }
  84
  85 int sparc_mmap_check(unsigned long addr, unsigned long len)
  86 {
  87         /* See asm-sparc/uaccess.h */
  88         if (len > TASK_SIZE - PAGE_SIZE || addr + len > TASK_SIZE - PAGE_SIZE)
  89                 return -EINVAL;
  90
  91         return 0;
  92 }
  93
  94 /* Linux version of mmap */
  95
  96 asmlinkage unsigned long sys_mmap2(unsigned long addr, unsigned long len,
  97         unsigned long prot, unsigned long flags, unsigned long fd,
  98         unsigned long pgoff)
  99 {
 100         /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
 101            we have. */
 102         return sys_mmap_pgoff(addr, len, prot, flags, fd,
 103                               pgoff >> (PAGE_SHIFT - 12));
 104 }
 105
 106 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
 107         unsigned long prot, unsigned long flags, unsigned long fd,
 108         unsigned long off)
 109 {
 110         /* no alignment check? */
 111         return sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
 112 }
 113
 114 long sparc_remap_file_pages(unsigned long start, unsigned long size,
 115                            unsigned long prot, unsigned long pgoff,
 116                            unsigned long flags)
 117 {
 118         /* This works on an existing mmap so we don't need to validate
 119          * the range as that was done at the original mmap call.
 120          */
 121         return sys_remap_file_pages(start, size, prot,
 122                                     (pgoff >> (PAGE_SHIFT - 12)), flags);
 123 }
 124
 125 /* we come to here via sys_nis_syscall so it can setup the regs argument */
 126 asmlinkage unsigned long
 127 c_sys_nis_syscall (struct pt_regs *regs)
 128 {
 129         static int count = 0;
 130
 131         if (count++ > 5)
 132                 return -ENOSYS;
 133         printk ("%s[%d]: Unimplemented SPARC system call %d\n",
 134                 current->comm, task_pid_nr(current), (int)regs->u_regs[1]);
 135 #ifdef DEBUG_UNIMP_SYSCALL
 136         show_regs (regs);
 137 #endif
 138         return -ENOSYS;
 139 }
 140
 141 /* #define DEBUG_SPARC_BREAKPOINT */
 142
 143 asmlinkage void
 144 sparc_breakpoint (struct pt_regs *regs)
 145 {
 146         siginfo_t info;
 147
 148 #ifdef DEBUG_SPARC_BREAKPOINT
 149         printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs->pc, regs->npc);
 150 #endif
 151         info.si_signo = SIGTRAP;
 152         info.si_errno = 0;
 153         info.si_code = TRAP_BRKPT;
 154         info.si_addr = (void __user *)regs->pc;
 155         info.si_trapno = 0;
 156         force_sig_info(SIGTRAP, &info, current);
 157
 158 #ifdef DEBUG_SPARC_BREAKPOINT
 159         printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs->pc, regs->npc);
 160 #endif
 161 }
 162
 163 asmlinkage int
 164 sparc_sigaction (int sig, const struct old_sigaction __user *act,
 165                  struct old_sigaction __user *oact)
 166 {
 167         struct k_sigaction new_ka, old_ka;
 168         int ret;
 169
 170         WARN_ON_ONCE(sig >= 0);
 171         sig = -sig;
 172
 173         if (act) {
 174                 unsigned long mask;
 175
 176                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 177                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 178                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
 179                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
 180                     __get_user(mask, &act->sa_mask))
 181                         return -EFAULT;
 182                 siginitset(&new_ka.sa.sa_mask, mask);
 183                 new_ka.ka_restorer = NULL;
 184         }
 185
 186         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 187
 188         if (!ret && oact) {
 189                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 190                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 191                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
 192                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
 193                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
 194                         return -EFAULT;
 195         }
 196
 197         return ret;
 198 }
 199
 200 asmlinkage long
 201 sys_rt_sigaction(int sig,
 202                  const struct sigaction __user *act,
 203                  struct sigaction __user *oact,
 204                  void __user *restorer,
 205                  size_t sigsetsize)
 206 {
 207         struct k_sigaction new_ka, old_ka;
 208         int ret;
 209
 210         /* XXX: Don't preclude handling different sized sigset_t's.  */
 211         if (sigsetsize != sizeof(sigset_t))
 212                 return -EINVAL;
 213
 214         if (act) {
 215                 new_ka.ka_restorer = restorer;
 216                 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
 217                         return -EFAULT;
 218         }
 219
 220         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 221
 222         if (!ret && oact) {
 223                 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
 224                         return -EFAULT;
 225         }
 226
 227         return ret;
 228 }
 229
 230 asmlinkage int sys_getdomainname(char __user *name, int len)
 231 {
 232         int nlen, err;
 233
 234         if (len < 0)
 235                 return -EINVAL;
 236
 237         down_read(&uts_sem);
 238
 239         nlen = strlen(utsname()->domainname) + 1;
 240         err = -EINVAL;
 241         if (nlen > len)
 242                 goto out;
 243
 244         err = -EFAULT;
 245         if (!copy_to_user(name, utsname()->domainname, nlen))
 246                 err = 0;
 247
 248 out:
 249         up_read(&uts_sem);
 250         return err;
 251 }