[PATCH] xtensa: remove old syscalls
[linux-3.10.git] / arch / xtensa / kernel / syscalls.c
1 /*
2  * arch/xtensa/kernel/syscall.c
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * Copyright (C) 2001 - 2005 Tensilica Inc.
9  * Copyright (C) 2000 Silicon Graphics, Inc.
10  * Copyright (C) 1995 - 2000 by Ralf Baechle
11  *
12  * Joe Taylor <joe@tensilica.com, joetylr@yahoo.com>
13  * Marc Gauthier <marc@tensilica.com, marc@alumni.uwaterloo.ca>
14  * Chris Zankel <chris@zankel.net>
15  * Kevin Chea
16  *
17  */
18
19 #define DEBUG   0
20
21 #include <linux/config.h>
22 #include <linux/linkage.h>
23 #include <linux/mm.h>
24 #include <linux/smp.h>
25 #include <linux/smp_lock.h>
26 #include <linux/mman.h>
27 #include <linux/sched.h>
28 #include <linux/file.h>
29 #include <linux/slab.h>
30 #include <linux/utsname.h>
31 #include <linux/unistd.h>
32 #include <linux/stringify.h>
33 #include <linux/syscalls.h>
34 #include <linux/sem.h>
35 #include <linux/msg.h>
36 #include <linux/shm.h>
37 #include <linux/errno.h>
38 #include <asm/ptrace.h>
39 #include <asm/signal.h>
40 #include <asm/uaccess.h>
41 #include <asm/hardirq.h>
42 #include <asm/mman.h>
43 #include <asm/shmparam.h>
44 #include <asm/page.h>
45 #include <asm/ipc.h>
46
47 extern void do_syscall_trace(void);
48 typedef int (*syscall_t)(void *a0,...);
49 extern syscall_t sys_call_table[];
50 extern unsigned char sys_narg_table[];
51
52 /*
53  * sys_pipe() is the normal C calling standard for creating a pipe. It's not
54  * the way unix traditional does this, though.
55  */
56
57 int sys_pipe(int __user *userfds)
58 {
59         int fd[2];
60         int error;
61
62         error = do_pipe(fd);
63         if (!error) {
64                 if (copy_to_user(userfds, fd, 2 * sizeof(int)))
65                         error = -EFAULT;
66         }
67         return error;
68 }
69
70 /*
71  * Common code for old and new mmaps.
72  */
73 long sys_mmap2(unsigned long addr, unsigned long len, unsigned long prot,
74                unsigned long flags, unsigned long fd, unsigned long pgoff)
75 {
76         int error = -EBADF;
77         struct file * file = NULL;
78
79         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
80         if (!(flags & MAP_ANONYMOUS)) {
81                 file = fget(fd);
82                 if (!file)
83                         goto out;
84         }
85
86         down_write(&current->mm->mmap_sem);
87         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
88         up_write(&current->mm->mmap_sem);
89
90         if (file)
91                 fput(file);
92 out:
93         return error;
94 }
95
96 int sys_clone(struct pt_regs *regs)
97 {
98         unsigned long clone_flags;
99         unsigned long newsp;
100         int __user *parent_tidptr, *child_tidptr;
101         clone_flags = regs->areg[4];
102         newsp = regs->areg[3];
103         parent_tidptr = (int __user *)regs->areg[5];
104         child_tidptr = (int __user *)regs->areg[6];
105         if (!newsp)
106                 newsp = regs->areg[1];
107         return do_fork(clone_flags,newsp,regs,0,parent_tidptr,child_tidptr);
108 }
109
110 /*
111  * sys_execve() executes a new program.
112  */
113
114 int sys_execve(struct pt_regs *regs)
115 {
116         int error;
117         char * filename;
118
119         filename = getname((char *) (long)regs->areg[5]);
120         error = PTR_ERR(filename);
121         if (IS_ERR(filename))
122                 goto out;
123         error = do_execve(filename, (char **) (long)regs->areg[3],
124                           (char **) (long)regs->areg[4], regs);
125         putname(filename);
126
127 out:
128         return error;
129 }
130
131 int sys_uname(struct old_utsname * name)
132 {
133         if (name && !copy_to_user(name, &system_utsname, sizeof (*name)))
134                 return 0;
135         return -EFAULT;
136 }
137
138 /*
139  * Build the string table for the builtin "poor man's strace".
140  */
141
142 #if DEBUG
143 #define SYSCALL(fun, narg) #fun,
144 static char *sfnames[] = {
145 #include "syscalls.h"
146 };
147 #undef SYS
148 #endif
149
150 void system_call (struct pt_regs *regs)
151 {
152         syscall_t syscall;
153         unsigned long parm0, parm1, parm2, parm3, parm4, parm5;
154         int nargs, res;
155         unsigned int syscallnr;
156         int ps;
157
158 #if DEBUG
159         int i;
160         unsigned long parms[6];
161         char *sysname;
162 #endif
163
164         regs->syscall = regs->areg[2];
165
166         do_syscall_trace();
167
168         /* Have to load after syscall_trace because strace
169          * sometimes changes regs->syscall.
170          */
171         syscallnr = regs->syscall;
172
173         parm0 = parm1 = parm2 = parm3 = parm4 = parm5 = 0;
174
175         /* Restore interrupt level to syscall invoker's.
176          * If this were in assembly, we wouldn't disable
177          * interrupts in the first place:
178          */
179         local_save_flags (ps);
180         local_irq_restore((ps & ~XCHAL_PS_INTLEVEL_MASK) |
181                           (regs->ps & XCHAL_PS_INTLEVEL_MASK) );
182
183         if (syscallnr > __NR_Linux_syscalls) {
184                 regs->areg[2] = -ENOSYS;
185                 return;
186         }
187
188         syscall = sys_call_table[syscallnr];
189         nargs = sys_narg_table[syscallnr];
190
191         if (syscall == NULL) {
192                 regs->areg[2] = -ENOSYS;
193                 return;
194         }
195
196         /* There shouldn't be more than six arguments in the table! */
197
198         if (nargs > 6)
199                 panic("Internal error - too many syscall arguments (%d)!\n",
200                       nargs);
201
202         /* Linux takes system-call arguments in registers.  The ABI
203          * and Xtensa software conventions require the system-call
204          * number in a2.  If an argument exists in a2, we move it to
205          * the next available register.  Note that for improved
206          * efficiency, we do NOT shift all parameters down one
207          * register to maintain the original order.
208          *
209          * At best case (zero arguments), we just write the syscall
210          * number to a2.  At worst case (1 to 6 arguments), we move
211          * the argument in a2 to the next available register, then
212          * write the syscall number to a2.
213          *
214          * For clarity, the following truth table enumerates all
215          * possibilities.
216          *
217          * arguments    syscall number  arg0, arg1, arg2, arg3, arg4, arg5
218          * ---------    --------------  ----------------------------------
219          *      0             a2
220          *      1             a2        a3
221          *      2             a2        a4,   a3
222          *      3             a2        a5,   a3,   a4
223          *      4             a2        a6,   a3,   a4,   a5
224          *      5             a2        a7,   a3,   a4,   a5,   a6
225          *      6             a2        a8,   a3,   a4,   a5,   a6,   a7
226          */
227         if (nargs) {
228                 parm0 = regs->areg[nargs+2];
229                 parm1 = regs->areg[3];
230                 parm2 = regs->areg[4];
231                 parm3 = regs->areg[5];
232                 parm4 = regs->areg[6];
233                 parm5 = regs->areg[7];
234         } else /* nargs == 0 */
235                 parm0 = (unsigned long) regs;
236
237 #if DEBUG
238         parms[0] = parm0;
239         parms[1] = parm1;
240         parms[2] = parm2;
241         parms[3] = parm3;
242         parms[4] = parm4;
243         parms[5] = parm5;
244
245         sysname = sfnames[syscallnr];
246         if (strncmp(sysname, "sys_", 4) == 0)
247                 sysname = sysname + 4;
248
249         printk("\017SYSCALL:I:%x:%d:%s  %s(", regs->pc, current->pid,
250                current->comm, sysname);
251         for (i = 0; i < nargs; i++)
252                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
253         printk(")\n");
254 #endif
255
256         res = syscall((void *)parm0, parm1, parm2, parm3, parm4, parm5);
257
258 #if DEBUG
259         printk("\017SYSCALL:O:%d:%s  %s(",current->pid, current->comm, sysname);
260         for (i = 0; i < nargs; i++)
261                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
262         if (res < 4096)
263                 printk(") = %d\n", res);
264         else
265                 printk(") = %#x\n", res);
266 #endif /* DEBUG */
267
268         regs->areg[2] = res;
269         do_syscall_trace();
270 }