arch/nios2nommu/kernel/sys_nios2.c

   1 /*
   2  * linux/arch/nios2nommu/kernel/sys_nios2.c
   3  *
   4  * Copyright (C) 2004 Microtronix Datacom Ltd.
   5  *
   6  * This file contains various random system calls that
   7  * have a non-standard calling sequence on the Linux/nios2nommu
   8  * platform.
   9  *
  10   * All rights reserved.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful, but
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  20  * NON INFRINGEMENT.  See the GNU General Public License for more
  21  * details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *
  27 */
  28
  29 #include <linux/errno.h>
  30 #include <linux/sched.h>
  31 #include <linux/mm.h>
  32 #include <linux/smp.h>
  33 #include <linux/smp_lock.h>
  34 #include <linux/sem.h>
  35 #include <linux/msg.h>
  36 #include <linux/shm.h>
  37 #include <linux/stat.h>
  38 #include <linux/syscalls.h>
  39 #include <linux/mman.h>
  40 #include <linux/file.h>
  41 #include <linux/utsname.h>
  42
  43 #include <asm/setup.h>
  44 #include <asm/uaccess.h>
  45 #include <asm/cachectl.h>
  46 #include <asm/traps.h>
  47 #include <asm/ipc.h>
  48 #include <asm/cacheflush.h>
  49 #include <asm/unistd.h>
  50
  51 /*
  52  * sys_pipe() is the normal C calling standard for creating
  53  * a pipe. It's not the way unix traditionally does this, though.
  54  */
  55 asmlinkage int sys_pipe(unsigned long * fildes)
  56 {
  57         int fd[2];
  58         int error;
  59
  60         error = do_pipe(fd);
  61         if (!error) {
  62                 if (copy_to_user(fildes, fd, 2*sizeof(int)))
  63                         error = -EFAULT;
  64         }
  65         return error;
  66 }
  67
  68 /* common code for old and new mmaps */
  69 static inline long do_mmap2(
  70         unsigned long addr, unsigned long len,
  71         unsigned long prot, unsigned long flags,
  72         unsigned long fd, unsigned long pgoff)
  73 {
  74         int error = -EBADF;
  75         struct file * file = NULL;
  76
  77         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  78         if (!(flags & MAP_ANONYMOUS)) {
  79                 file = fget(fd);
  80                 if (!file)
  81                         goto out;
  82         }
  83
  84         down_write(&current->mm->mmap_sem);
  85         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  86         up_write(&current->mm->mmap_sem);
  87
  88         if (file)
  89                 fput(file);
  90 out:
  91         return error;
  92 }
  93
  94 asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
  95         unsigned long prot, unsigned long flags,
  96         unsigned long fd, unsigned long pgoff)
  97 {
  98         return do_mmap2(addr, len, prot, flags, fd, pgoff);
  99 }
 100
 101 /*
 102  * Perform the select(nd, in, out, ex, tv) and mmap() system
 103  * calls. Linux/m68k cloned Linux/i386, which didn't use to be able to
 104  * handle more than 4 system call parameters, so these system calls
 105  * used a memory block for parameter passing..
 106  */
 107
 108 struct mmap_arg_struct {
 109         unsigned long addr;
 110         unsigned long len;
 111         unsigned long prot;
 112         unsigned long flags;
 113         unsigned long fd;
 114         unsigned long offset;
 115 };
 116
 117 asmlinkage int old_mmap(struct mmap_arg_struct *arg)
 118 {
 119         struct mmap_arg_struct a;
 120         int error = -EFAULT;
 121
 122         if (copy_from_user(&a, arg, sizeof(a)))
 123                 goto out;
 124
 125         error = -EINVAL;
 126         if (a.offset & ~PAGE_MASK)
 127                 goto out;
 128
 129         a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
 130
 131         error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);
 132 out:
 133         return error;
 134 }
 135
 136 struct sel_arg_struct {
 137         unsigned long n;
 138         fd_set *inp, *outp, *exp;
 139         struct timeval *tvp;
 140 };
 141
 142 asmlinkage int old_select(struct sel_arg_struct *arg)
 143 {
 144         struct sel_arg_struct a;
 145
 146         if (copy_from_user(&a, arg, sizeof(a)))
 147                 return -EFAULT;
 148         /* sys_select() does the appropriate kernel locking */
 149         return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
 150 }
 151
 152 /*
 153  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
 154  *
 155  * This is really horribly ugly.
 156  */
 157 asmlinkage int sys_ipc (uint call, int first, int second,
 158                         int third, void *ptr, long fifth)
 159 {
 160         int version;
 161
 162         version = call >> 16; /* hack for backward compatibility */
 163         call &= 0xffff;
 164
 165         if (call <= SEMCTL)
 166                 switch (call) {
 167                 case SEMOP:
 168                         return sys_semop (first, (struct sembuf *)ptr, second);
 169                 case SEMGET:
 170                         return sys_semget (first, second, third);
 171                 case SEMCTL: {
 172                         union semun fourth;
 173                         if (!ptr)
 174                                 return -EINVAL;
 175                         if (get_user(fourth.__pad, (void **) ptr))
 176                                 return -EFAULT;
 177                         return sys_semctl (first, second, third, fourth);
 178                         }
 179                 default:
 180                         return -EINVAL;
 181                 }
 182         if (call <= MSGCTL)
 183                 switch (call) {
 184                 case MSGSND:
 185                         return sys_msgsnd (first, (struct msgbuf *) ptr,
 186                                           second, third);
 187                 case MSGRCV:
 188                         switch (version) {
 189                         case 0: {
 190                                 struct ipc_kludge tmp;
 191                                 if (!ptr)
 192                                         return -EINVAL;
 193                                 if (copy_from_user (&tmp,
 194                                                     (struct ipc_kludge *)ptr,
 195                                                     sizeof (tmp)))
 196                                         return -EFAULT;
 197                                 return sys_msgrcv (first, tmp.msgp, second,
 198                                                    tmp.msgtyp, third);
 199                                 }
 200                         default:
 201                                 return sys_msgrcv (first,
 202                                                    (struct msgbuf *) ptr,
 203                                                    second, fifth, third);
 204                         }
 205                 case MSGGET:
 206                         return sys_msgget ((key_t) first, second);
 207                 case MSGCTL:
 208                         return sys_msgctl (first, second,
 209                                            (struct msqid_ds *) ptr);
 210                 default:
 211                         return -EINVAL;
 212                 }
 213
 214         return -EINVAL;
 215 }
 216
 217 /* sys_cacheflush -- flush the processor cache.  */
 218 asmlinkage int
 219 sys_cacheflush (unsigned long addr, int scope, int cache, unsigned long len)
 220 {
 221         flush_cache_all();
 222         return(0);
 223 }
 224
 225 asmlinkage int sys_getpagesize(void)
 226 {
 227         return PAGE_SIZE;
 228 }
 229
 230 /*
 231  * Do a system call from kernel instead of calling sys_execve so we
 232  * end up with proper pt_regs.
 233  */
 234 int kernel_execve(const char *filename, char *const argv[], char *const envp[])
 235 {
 236         register long __res __asm__ ("r2") = TRAP_ID_SYSCALL;
 237         register long __sc  __asm__ ("r3") = __NR_execve;
 238         register long __a   __asm__ ("r4") = (long) filename;
 239         register long __b   __asm__ ("r5") = (long) argv;
 240         register long __c   __asm__ ("r6") = (long) envp;
 241         __asm__ __volatile__ ("trap" : "=r" (__res)
 242                         : "0" (__res), "r" (__sc), "r" (__a), "r" (__b), "r" (__c)
 243                         : "memory");
 244
 245         return __res;
 246 }