LXR linux/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/sem.h>
  14#include <linux/msg.h>
  15#include <linux/shm.h>
  16#include <linux/stat.h>
  17#include <linux/syscalls.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/unistd.h>
  24#include <asm/ipc.h>
  25
  26/*
  27 * sys_pipe() is the normal C calling standard for creating
  28 * a pipe. It's not the way Unix traditionally does this, though.
  29 */
  30asmlinkage int sys_pipe(unsigned long __user * fildes)
  31{
  32        int fd[2];
  33        int error;
  34
  35        error = do_pipe(fd);
  36        if (!error) {
  37                if (copy_to_user(fildes, fd, 2*sizeof(int)))
  38                        error = -EFAULT;
  39        }
  40        return error;
  41}
  42
  43asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
  44                          unsigned long prot, unsigned long flags,
  45                          unsigned long fd, unsigned long pgoff)
  46{
  47        int error = -EBADF;
  48        struct file *file = NULL;
  49        struct mm_struct *mm = current->mm;
  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(&mm->mmap_sem);
  59        error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  60        up_write(&mm->mmap_sem);
  61
  62        if (file)
  63                fput(file);
  64out:
  65        return error;
  66}
  67
  68/*
  69 * Perform the select(nd, in, out, ex, tv) and mmap() system
  70 * calls. Linux/i386 didn't use to be able to handle more than
  71 * 4 system call parameters, so these system calls used a memory
  72 * block for parameter passing..
  73 */
  74
  75struct mmap_arg_struct {
  76        unsigned long addr;
  77        unsigned long len;
  78        unsigned long prot;
  79        unsigned long flags;
  80        unsigned long fd;
  81        unsigned long offset;
  82};
  83
  84asmlinkage int old_mmap(struct mmap_arg_struct __user *arg)
  85{
  86        struct mmap_arg_struct a;
  87        int err = -EFAULT;
  88
  89        if (copy_from_user(&a, arg, sizeof(a)))
  90                goto out;
  91
  92        err = -EINVAL;
  93        if (a.offset & ~PAGE_MASK)
  94                goto out;
  95
  96        err = sys_mmap2(a.addr, a.len, a.prot, a.flags,
  97                        a.fd, a.offset >> PAGE_SHIFT);
  98out:
  99        return err;
 100}
 101
 102
 103struct sel_arg_struct {
 104        unsigned long n;
 105        fd_set __user *inp, *outp, *exp;
 106        struct timeval __user *tvp;
 107};
 108
 109asmlinkage int old_select(struct sel_arg_struct __user *arg)
 110{
 111        struct sel_arg_struct a;
 112
 113        if (copy_from_user(&a, arg, sizeof(a)))
 114                return -EFAULT;
 115        /* sys_select() does the appropriate kernel locking */
 116        return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
 117}
 118
 119/*
 120 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 121 *
 122 * This is really horribly ugly.
 123 */
 124asmlinkage int sys_ipc (uint call, int first, int second,
 125                        int third, void __user *ptr, long fifth)
 126{
 127        int version, ret;
 128
 129        version = call >> 16; /* hack for backward compatibility */
 130        call &= 0xffff;
 131
 132        switch (call) {
 133        case SEMOP:
 134                return sys_semtimedop (first, (struct sembuf __user *)ptr, second, NULL);
 135        case SEMTIMEDOP:
 136                return sys_semtimedop(first, (struct sembuf __user *)ptr, second,
 137                                        (const struct timespec __user *)fifth);
 138
 139        case SEMGET:
 140                return sys_semget (first, second, third);
 141        case SEMCTL: {
 142                union semun fourth;
 143                if (!ptr)
 144                        return -EINVAL;
 145                if (get_user(fourth.__pad, (void __user * __user *) ptr))
 146                        return -EFAULT;
 147                return sys_semctl (first, second, third, fourth);
 148        }
 149
 150        case MSGSND:
 151                return sys_msgsnd (first, (struct msgbuf __user *) ptr, 
 152                                   second, third);
 153        case MSGRCV:
 154                switch (version) {
 155                case 0: {
 156                        struct ipc_kludge tmp;
 157                        if (!ptr)
 158                                return -EINVAL;
 159                        
 160                        if (copy_from_user(&tmp,
 161                                           (struct ipc_kludge __user *) ptr, 
 162                                           sizeof (tmp)))
 163                                return -EFAULT;
 164                        return sys_msgrcv (first, tmp.msgp, second,
 165                                           tmp.msgtyp, third);
 166                }
 167                default:
 168                        return sys_msgrcv (first,
 169                                           (struct msgbuf __user *) ptr,
 170                                           second, fifth, third);
 171                }
 172        case MSGGET:
 173                return sys_msgget ((key_t) first, second);
 174        case MSGCTL:
 175                return sys_msgctl (first, second, (struct msqid_ds __user *) ptr);
 176
 177        case SHMAT:
 178                switch (version) {
 179                default: {
 180                        ulong raddr;
 181                        ret = do_shmat (first, (char __user *) ptr, second, &raddr);
 182                        if (ret)
 183                                return ret;
 184                        return put_user (raddr, (ulong __user *) third);
 185                }
 186                case 1: /* iBCS2 emulator entry point */
 187                        if (!segment_eq(get_fs(), get_ds()))
 188                                return -EINVAL;
 189                        /* The "(ulong *) third" is valid _only_ because of the kernel segment thing */
 190                        return do_shmat (first, (char __user *) ptr, second, (ulong *) third);
 191                }
 192        case SHMDT: 
 193                return sys_shmdt ((char __user *)ptr);
 194        case SHMGET:
 195                return sys_shmget (first, second, third);
 196        case SHMCTL:
 197                return sys_shmctl (first, second,
 198                                   (struct shmid_ds __user *) ptr);
 199        default:
 200                return -ENOSYS;
 201        }
 202}
 203
 204/*
 205 * Old cruft
 206 */
 207asmlinkage int sys_uname(struct old_utsname __user * name)
 208{
 209        int err;
 210        if (!name)
 211                return -EFAULT;
 212        down_read(&uts_sem);
 213        err = copy_to_user(name, utsname(), sizeof (*name));
 214        up_read(&uts_sem);
 215        return err?-EFAULT:0;
 216}
 217
 218asmlinkage int sys_olduname(struct oldold_utsname __user * name)
 219{
 220        int error;
 221
 222        if (!name)
 223                return -EFAULT;
 224        if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
 225                return -EFAULT;
 226  
 227        down_read(&uts_sem);
 228        
 229        error = __copy_to_user(&name->sysname, &utsname()->sysname,
 230                               __OLD_UTS_LEN);
 231        error |= __put_user(0, name->sysname + __OLD_UTS_LEN);
 232        error |= __copy_to_user(&name->nodename, &utsname()->nodename,
 233                                __OLD_UTS_LEN);
 234        error |= __put_user(0, name->nodename + __OLD_UTS_LEN);
 235        error |= __copy_to_user(&name->release, &utsname()->release,
 236                                __OLD_UTS_LEN);
 237        error |= __put_user(0, name->release + __OLD_UTS_LEN);
 238        error |= __copy_to_user(&name->version, &utsname()->version,
 239                                __OLD_UTS_LEN);
 240        error |= __put_user(0, name->version + __OLD_UTS_LEN);
 241        error |= __copy_to_user(&name->machine, &utsname()->machine,
 242                                __OLD_UTS_LEN);
 243        error |= __put_user(0, name->machine + __OLD_UTS_LEN);
 244        
 245        up_read(&uts_sem);
 246        
 247        error = error ? -EFAULT : 0;
 248
 249        return error;
 250}
 251
 252
 253/*
 254 * Do a system call from kernel instead of calling sys_execve so we
 255 * end up with proper pt_regs.
 256 */
 257int kernel_execve(const char *filename, char *const argv[], char *const envp[])
 258{
 259        long __res;
 260        asm volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx"
 261        : "=a" (__res)
 262        : "0" (__NR_execve),"ri" (filename),"c" (argv), "d" (envp) : "memory");
 263        return __res;
 264}
 265