arch/sparc/kernel/sys_sparc.c

   1 /* $Id: sys_sparc.c,v 1.56 2000/01/04 11:01:26 jj Exp $
   2  * linux/arch/sparc/kernel/sys_sparc.c
   3  *
   4  * This file contains various random system calls that
   5  * have a non-standard calling sequence on the Linux/sparc
   6  * platform.
   7  */
   8
   9 #include <linux/errno.h>
  10 #include <linux/types.h>
  11 #include <linux/sched.h>
  12 #include <linux/config.h>
  13 #include <linux/mm.h>
  14 #include <linux/fs.h>
  15 #include <linux/file.h>
  16 #include <linux/sem.h>
  17 #include <linux/msg.h>
  18 #include <linux/shm.h>
  19 #include <linux/stat.h>
  20 #include <linux/mman.h>
  21 #include <linux/utsname.h>
  22 #include <linux/smp.h>
  23 #include <linux/smp_lock.h>
  24
  25 #include <asm/uaccess.h>
  26 #include <asm/ipc.h>
  27
  28 /* #define DEBUG_UNIMP_SYSCALL */
  29
  30 /* XXX Make this per-binary type, this way we can detect the type of
  31  * XXX a binary.  Every Sparc executable calls this very early on.
  32  */
  33 asmlinkage unsigned long sys_getpagesize(void)
  34 {
  35         return PAGE_SIZE; /* Possibly older binaries want 8192 on sun4's? */
  36 }
  37
  38 extern asmlinkage unsigned long sys_brk(unsigned long brk);
  39
  40 asmlinkage unsigned long sparc_brk(unsigned long brk)
  41 {
  42         if(ARCH_SUN4C_SUN4) {
  43                 if(brk >= 0x20000000 && brk < 0xe0000000)
  44                         return current->mm->brk;
  45         }
  46         return sys_brk(brk);
  47 }
  48
  49 /*
  50  * sys_pipe() is the normal C calling standard for creating
  51  * a pipe. It's not the way unix traditionally does this, though.
  52  */
  53 asmlinkage int sparc_pipe(struct pt_regs *regs)
  54 {
  55         int fd[2];
  56         int error;
  57
  58         lock_kernel();
  59         error = do_pipe(fd);
  60         if (error)
  61                 goto out;
  62         regs->u_regs[UREG_I1] = fd[1];
  63         error = fd[0];
  64 out:
  65         unlock_kernel();
  66         return error;
  67 }
  68
  69 /*
  70  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
  71  *
  72  * This is really horribly ugly.
  73  */
  74
  75 asmlinkage int sys_ipc (uint call, int first, int second, int third, void *ptr, long fifth)
  76 {
  77         int version, err;
  78
  79         lock_kernel();
  80         version = call >> 16; /* hack for backward compatibility */
  81         call &= 0xffff;
  82
  83         if (call <= SEMCTL)
  84                 switch (call) {
  85                 case SEMOP:
  86                         err = sys_semop (first, (struct sembuf *)ptr, second);
  87                         goto out;
  88                 case SEMGET:
  89                         err = sys_semget (first, second, third);
  90                         goto out;
  91                 case SEMCTL: {
  92                         union semun fourth;
  93                         err = -EINVAL;
  94                         if (!ptr)
  95                                 goto out;
  96                         err = -EFAULT;
  97                         if(get_user(fourth.__pad, (void **)ptr))
  98                                 goto out;
  99                         err = sys_semctl (first, second, third, fourth);
 100                         goto out;
 101                         }
 102                 default:
 103                         err = -EINVAL;
 104                         goto out;
 105                 }
 106         if (call <= MSGCTL)
 107                 switch (call) {
 108                 case MSGSND:
 109                         err = sys_msgsnd (first, (struct msgbuf *) ptr,
 110                                           second, third);
 111                         goto out;
 112                 case MSGRCV:
 113                         switch (version) {
 114                         case 0: {
 115                                 struct ipc_kludge tmp;
 116                                 err = -EINVAL;
 117                                 if (!ptr)
 118                                         goto out;
 119                                 err = -EFAULT;
 120                                 if(copy_from_user(&tmp,(struct ipc_kludge *) ptr, sizeof (tmp)))
 121                                         goto out;
 122                                 err = sys_msgrcv (first, tmp.msgp, second, tmp.msgtyp, third);
 123                                 goto out;
 124                                 }
 125                         case 1: default:
 126                                 err = sys_msgrcv (first, (struct msgbuf *) ptr, second, fifth, third);
 127                                 goto out;
 128                         }
 129                 case MSGGET:
 130                         err = sys_msgget ((key_t) first, second);
 131                         goto out;
 132                 case MSGCTL:
 133                         err = sys_msgctl (first, second, (struct msqid_ds *) ptr);
 134                         goto out;
 135                 default:
 136                         err = -EINVAL;
 137                         goto out;
 138                 }
 139         if (call <= SHMCTL)
 140                 switch (call) {
 141                 case SHMAT:
 142                         switch (version) {
 143                         case 0: default: {
 144                                 ulong raddr;
 145                                 err = sys_shmat (first, (char *) ptr, second, &raddr);
 146                                 if (err)
 147                                         goto out;
 148                                 err = -EFAULT;
 149                                 if(put_user (raddr, (ulong *) third))
 150                                         goto out;
 151                                 err = 0;
 152                                 goto out;
 153                                 }
 154                         case 1: /* iBCS2 emulator entry point */
 155                                 err = sys_shmat (first, (char *) ptr, second, (ulong *) third);
 156                                 goto out;
 157                         }
 158                 case SHMDT:
 159                         err = sys_shmdt ((char *)ptr);
 160                         goto out;
 161                 case SHMGET:
 162                         err = sys_shmget (first, second, third);
 163                         goto out;
 164                 case SHMCTL:
 165                         err = sys_shmctl (first, second, (struct shmid_ds *) ptr);
 166                         goto out;
 167                 default:
 168                         err = -EINVAL;
 169                         goto out;
 170                 }
 171         else
 172                 err = -EINVAL;
 173 out:
 174         unlock_kernel();
 175         return err;
 176 }
 177
 178 /* Linux version of mmap */
 179 static unsigned long do_mmap2(unsigned long addr, unsigned long len,
 180         unsigned long prot, unsigned long flags, unsigned long fd,
 181         unsigned long pgoff)
 182 {
 183         struct file * file = NULL;
 184         unsigned long retval = -EBADF;
 185
 186         if (!(flags & MAP_ANONYMOUS)) {
 187                 file = fget(fd);
 188                 if (!file)
 189                         goto out;
 190         }
 191
 192         down(&current->mm->mmap_sem);
 193         lock_kernel();
 194         retval = -ENOMEM;
 195         len = PAGE_ALIGN(len);
 196         if(!(flags & MAP_FIXED) &&
 197            (!addr || (ARCH_SUN4C_SUN4 &&
 198                       (addr >= 0x20000000 && addr < 0xe0000000)))) {
 199                 addr = get_unmapped_area(0, len);
 200                 if(!addr)
 201                         goto out_putf;
 202                 if (ARCH_SUN4C_SUN4 &&
 203                     (addr >= 0x20000000 && addr < 0xe0000000)) {
 204                         retval = -EINVAL;
 205                         goto out_putf;
 206                 }
 207         }
 208
 209         /* See asm-sparc/uaccess.h */
 210         retval = -EINVAL;
 211         if((len > (TASK_SIZE - PAGE_SIZE)) || (addr > (TASK_SIZE-len-PAGE_SIZE)))
 212                 goto out_putf;
 213
 214         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 215         retval = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
 216
 217 out_putf:
 218         unlock_kernel();
 219         up(&current->mm->mmap_sem);
 220         if (file)
 221                 fput(file);
 222 out:
 223         return retval;
 224 }
 225
 226 asmlinkage unsigned long sys_mmap2(unsigned long addr, unsigned long len,
 227         unsigned long prot, unsigned long flags, unsigned long fd,
 228         unsigned long pgoff)
 229 {
 230         /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
 231            we have. */
 232         return do_mmap2(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT - 12));
 233 }
 234
 235 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
 236         unsigned long prot, unsigned long flags, unsigned long fd,
 237         unsigned long off)
 238 {
 239         return do_mmap2(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
 240 }
 241
 242 /* we come to here via sys_nis_syscall so it can setup the regs argument */
 243 asmlinkage unsigned long
 244 c_sys_nis_syscall (struct pt_regs *regs)
 245 {
 246         static int count = 0;
 247
 248         if (count++ > 5) return -ENOSYS;
 249         lock_kernel();
 250         printk ("%s[%d]: Unimplemented SPARC system call %d\n", current->comm, current->pid, (int)regs->u_regs[1]);
 251 #ifdef DEBUG_UNIMP_SYSCALL
 252         show_regs (regs);
 253 #endif
 254         unlock_kernel();
 255         return -ENOSYS;
 256 }
 257
 258 /* #define DEBUG_SPARC_BREAKPOINT */
 259
 260 asmlinkage void
 261 sparc_breakpoint (struct pt_regs *regs)
 262 {
 263         lock_kernel();
 264 #ifdef DEBUG_SPARC_BREAKPOINT
 265         printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs->pc, regs->npc);
 266 #endif
 267         force_sig(SIGTRAP, current);
 268 #ifdef DEBUG_SPARC_BREAKPOINT
 269         printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs->pc, regs->npc);
 270 #endif
 271         unlock_kernel();
 272 }
 273
 274 asmlinkage int
 275 sparc_sigaction (int sig, const struct old_sigaction *act,
 276                  struct old_sigaction *oact)
 277 {
 278         struct k_sigaction new_ka, old_ka;
 279         int ret;
 280
 281         if (sig < 0) {
 282                 current->thread.new_signal = 1;
 283                 sig = -sig;
 284         }
 285
 286         if (act) {
 287                 unsigned long mask;
 288
 289                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 290                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 291                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 292                         return -EFAULT;
 293                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 294                 __get_user(mask, &act->sa_mask);
 295                 siginitset(&new_ka.sa.sa_mask, mask);
 296                 new_ka.ka_restorer = NULL;
 297         }
 298
 299         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 300
 301         if (!ret && oact) {
 302                 /* In the clone() case we could copy half consistant
 303                  * state to the user, however this could sleep and
 304                  * deadlock us if we held the signal lock on SMP.  So for
 305                  * now I take the easy way out and do no locking.
 306                  */
 307                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 308                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 309                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 310                         return -EFAULT;
 311                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 312                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 313         }
 314
 315         return ret;
 316 }
 317
 318 asmlinkage int
 319 sys_rt_sigaction(int sig, const struct sigaction *act, struct sigaction *oact,
 320                  void *restorer, size_t sigsetsize)
 321 {
 322         struct k_sigaction new_ka, old_ka;
 323         int ret;
 324
 325         /* XXX: Don't preclude handling different sized sigset_t's.  */
 326         if (sigsetsize != sizeof(sigset_t))
 327                 return -EINVAL;
 328
 329         /* All tasks which use RT signals (effectively) use
 330          * new style signals.
 331          */
 332         current->thread.new_signal = 1;
 333
 334         if (act) {
 335                 new_ka.ka_restorer = restorer;
 336                 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
 337                         return -EFAULT;
 338         }
 339
 340         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 341
 342         if (!ret && oact) {
 343                 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
 344                         return -EFAULT;
 345         }
 346
 347         return ret;
 348 }
 349
 350 /* Just in case some old old binary calls this. */
 351 asmlinkage int sys_pause(void)
 352 {
 353         current->state = TASK_INTERRUPTIBLE;
 354         schedule();
 355         return -ERESTARTNOHAND;
 356 }
 357
 358 asmlinkage int sys_getdomainname(char *name, int len)
 359 {
 360         int nlen;
 361         int err = -EFAULT;
 362
 363         down(&uts_sem);
 364
 365         nlen = strlen(system_utsname.domainname) + 1;
 366
 367         if (nlen < len)
 368                 len = nlen;
 369         if(len > __NEW_UTS_LEN)
 370                 goto done;
 371         if(copy_to_user(name, system_utsname.domainname, len))
 372                 goto done;
 373         err = 0;
 374 done:
 375         up(&uts_sem);
 376         return err;
 377 }
 378
 379
 380 #ifndef CONFIG_AP1000
 381 /* only AP+ systems have sys_aplib */
 382 asmlinkage int sys_aplib(void)
 383 {
 384         return -ENOSYS;
 385 }
 386 #endif