LXR linux-old/arch/i386/kernel/sys

   1/*
   2 * linux/arch/i386/kernel/sys_i386.c
   3 *
   4 * This file contains various random system calls that
   5 * have a non-standard calling sequence on the Linux/i386
   6 * platform.
   7 */
   8
   9#include <linux/errno.h>
  10#include <linux/sched.h>
  11#include <linux/mm.h>
  12#include <linux/smp.h>
  13#include <linux/smp_lock.h>
  14#include <linux/sem.h>
  15#include <linux/msg.h>
  16#include <linux/shm.h>
  17#include <linux/stat.h>
  18#include <linux/mman.h>
  19#include <linux/file.h>
  20#include <linux/utsname.h>
  21
  22#include <asm/uaccess.h>
  23#include <asm/ipc.h>
  24
  25/*
  26 * sys_pipe() is the normal C calling standard for creating
  27 * a pipe. It's not the way Unix traditionally does this, though.
  28 */
  29asmlinkage int sys_pipe(unsigned long * fildes)
  30{
  31        int fd[2];
  32        int error;
  33
  34        error = do_pipe(fd);
  35        if (!error) {
  36                if (copy_to_user(fildes, fd, 2*sizeof(int)))
  37                        error = -EFAULT;
  38        }
  39        return error;
  40}
  41
  42/* common code for old and new mmaps */
  43static inline long do_mmap2(
  44        unsigned long addr, unsigned long len,
  45        unsigned long prot, unsigned long flags,
  46        unsigned long fd, unsigned long pgoff)
  47{
  48        int error = -EBADF;
  49        struct file * file = NULL;
  50
  51        flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  52        if (!(flags & MAP_ANONYMOUS)) {
  53                file = fget(fd);
  54                if (!file)
  55                        goto out;
  56        }
  57
  58        down_write(&current->mm->mmap_sem);
  59        error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  60        up_write(&current->mm->mmap_sem);
  61
  62        if (file)
  63                fput(file);
  64out:
  65        return error;
  66}
  67
  68asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
  69        unsigned long prot, unsigned long flags,
  70        unsigned long fd, unsigned long pgoff)
  71{
  72        return do_mmap2(addr, len, prot, flags, fd, pgoff);
  73}
  74
  75/*
  76 * Perform the select(nd, in, out, ex, tv) and mmap() system
  77 * calls. Linux/i386 didn't use to be able to handle more than
  78 * 4 system call parameters, so these system calls used a memory
  79 * block for parameter passing..
  80 */
  81
  82struct mmap_arg_struct {
  83        unsigned long addr;
  84        unsigned long len;
  85        unsigned long prot;
  86        unsigned long flags;
  87        unsigned long fd;
  88        unsigned long offset;
  89};
  90
  91asmlinkage int old_mmap(struct mmap_arg_struct *arg)
  92{
  93        struct mmap_arg_struct a;
  94        int err = -EFAULT;
  95
  96        if (copy_from_user(&a, arg, sizeof(a)))
  97                goto out;
  98
  99        err = -EINVAL;
 100        if (a.offset & ~PAGE_MASK)
 101                goto out;
 102
 103        err = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);
 104out:
 105        return err;
 106}
 107
 108
 109extern asmlinkage int sys_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
 110
 111struct sel_arg_struct {
 112        unsigned long n;
 113        fd_set *inp, *outp, *exp;
 114        struct timeval *tvp;
 115};
 116
 117asmlinkage int old_select(struct sel_arg_struct *arg)
 118{
 119        struct sel_arg_struct a;
 120
 121        if (copy_from_user(&a, arg, sizeof(a)))
 122                return -EFAULT;
 123        /* sys_select() does the appropriate kernel locking */
 124        return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
 125}
 126
 127/*
 128 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 129 *
 130 * This is really horribly ugly.
 131 */
 132asmlinkage int sys_ipc (uint call, int first, int second,
 133                        int third, void *ptr, long fifth)
 134{
 135        int version, ret;
 136
 137        version = call >> 16; /* hack for backward compatibility */
 138        call &= 0xffff;
 139
 140        switch (call) {
 141        case SEMOP:
 142                return sys_semop (first, (struct sembuf *)ptr, second);
 143        case SEMGET:
 144                return sys_semget (first, second, third);
 145        case SEMCTL: {
 146                union semun fourth;
 147                if (!ptr)
 148                        return -EINVAL;
 149                if (get_user(fourth.__pad, (void **) ptr))
 150                        return -EFAULT;
 151                return sys_semctl (first, second, third, fourth);
 152        }
 153
 154        case MSGSND:
 155                return sys_msgsnd (first, (struct msgbuf *) ptr, 
 156                                   second, third);
 157        case MSGRCV:
 158                switch (version) {
 159                case 0: {
 160                        struct ipc_kludge tmp;
 161                        if (!ptr)
 162                                return -EINVAL;
 163                        
 164                        if (copy_from_user(&tmp,
 165                                           (struct ipc_kludge *) ptr, 
 166                                           sizeof (tmp)))
 167                                return -EFAULT;
 168                        return sys_msgrcv (first, tmp.msgp, second,
 169                                           tmp.msgtyp, third);
 170                }
 171                default:
 172                        return sys_msgrcv (first,
 173                                           (struct msgbuf *) ptr,
 174                                           second, fifth, third);
 175                }
 176        case MSGGET:
 177                return sys_msgget ((key_t) first, second);
 178        case MSGCTL:
 179                return sys_msgctl (first, second, (struct msqid_ds *) ptr);
 180
 181        case SHMAT:
 182                switch (version) {
 183                default: {
 184                        ulong raddr;
 185                        ret = sys_shmat (first, (char *) ptr, second, &raddr);
 186                        if (ret)
 187                                return ret;
 188                        return put_user (raddr, (ulong *) third);
 189                }
 190                case 1: /* iBCS2 emulator entry point */
 191                        if (!segment_eq(get_fs(), get_ds()))
 192                                return -EINVAL;
 193                        return sys_shmat (first, (char *) ptr, second, (ulong *) third);
 194                }
 195        case SHMDT: 
 196                return sys_shmdt ((char *)ptr);
 197        case SHMGET:
 198                return sys_shmget (first, second, third);
 199        case SHMCTL:
 200                return sys_shmctl (first, second,
 201                                   (struct shmid_ds *) ptr);
 202        default:
 203                return -EINVAL;
 204        }
 205}
 206
 207/*
 208 * Old cruft
 209 */
 210asmlinkage int sys_uname(struct old_utsname * name)
 211{
 212        int err;
 213        if (!name)
 214                return -EFAULT;
 215        down_read(&uts_sem);
 216        err=copy_to_user(name, &system_utsname, sizeof (*name));
 217        up_read(&uts_sem);
 218        return err?-EFAULT:0;
 219}
 220
 221asmlinkage int sys_olduname(struct oldold_utsname * name)
 222{
 223        int error;
 224
 225        if (!name)
 226                return -EFAULT;
 227        if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
 228                return -EFAULT;
 229  
 230        down_read(&uts_sem);
 231        
 232        error = __copy_to_user(&name->sysname,&system_utsname.sysname,__OLD_UTS_LEN);
 233        error |= __put_user(0,name->sysname+__OLD_UTS_LEN);
 234        error |= __copy_to_user(&name->nodename,&system_utsname.nodename,__OLD_UTS_LEN);
 235        error |= __put_user(0,name->nodename+__OLD_UTS_LEN);
 236        error |= __copy_to_user(&name->release,&system_utsname.release,__OLD_UTS_LEN);
 237        error |= __put_user(0,name->release+__OLD_UTS_LEN);
 238        error |= __copy_to_user(&name->version,&system_utsname.version,__OLD_UTS_LEN);
 239        error |= __put_user(0,name->version+__OLD_UTS_LEN);
 240        error |= __copy_to_user(&name->machine,&system_utsname.machine,__OLD_UTS_LEN);
 241        error |= __put_user(0,name->machine+__OLD_UTS_LEN);
 242        
 243        up_read(&uts_sem);
 244        
 245        error = error ? -EFAULT : 0;
 246
 247        return error;
 248}
 249
 250asmlinkage int sys_pause(void)
 251{
 252        current->state = TASK_INTERRUPTIBLE;
 253        schedule();
 254        return -ERESTARTNOHAND;
 255}
 256
 257