[PATCH] xtensa: Architecture support for Tensilica Xtensa Part 3
[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 int (*do_syscalls)(struct pt_regs *regs, syscall_t fun,
50                                      int narg);
51 extern syscall_t sys_call_table[];
52 extern unsigned char sys_narg_table[];
53
54 /*
55  * sys_pipe() is the normal C calling standard for creating a pipe. It's not
56  * the way unix traditional does this, though.
57  */
58
59 int sys_pipe(int __user *userfds)
60 {
61         int fd[2];
62         int error;
63
64         error = do_pipe(fd);
65         if (!error) {
66                 if (copy_to_user(userfds, fd, 2 * sizeof(int)))
67                         error = -EFAULT;
68         }
69         return error;
70 }
71
72 /*
73  * Common code for old and new mmaps.
74  */
75
76 static inline long do_mmap2(unsigned long addr, unsigned long len,
77                             unsigned long prot, unsigned long flags,
78                             unsigned long fd, unsigned long pgoff)
79 {
80         int error = -EBADF;
81         struct file * file = NULL;
82
83         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
84         if (!(flags & MAP_ANONYMOUS)) {
85                 file = fget(fd);
86                 if (!file)
87                         goto out;
88         }
89
90         down_write(&current->mm->mmap_sem);
91         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
92         up_write(&current->mm->mmap_sem);
93
94         if (file)
95                 fput(file);
96 out:
97         return error;
98 }
99
100 unsigned long old_mmap(unsigned long addr, size_t len, int prot,
101                        int flags, int fd, off_t offset)
102 {
103         return do_mmap2(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
104 }
105
106 long sys_mmap2(unsigned long addr, unsigned long len, unsigned long prot,
107                unsigned long flags, unsigned long fd, unsigned long pgoff)
108 {
109         return do_mmap2(addr, len, prot, flags, fd, pgoff);
110 }
111
112 int sys_fork(struct pt_regs *regs)
113 {
114         return do_fork(SIGCHLD, regs->areg[1], regs, 0, NULL, NULL);
115 }
116
117 int sys_vfork(struct pt_regs *regs)
118 {
119         return do_fork(CLONE_VFORK|CLONE_VM|SIGCHLD, regs->areg[1],
120                        regs, 0, NULL, NULL);
121 }
122
123 int sys_clone(struct pt_regs *regs)
124 {
125         unsigned long clone_flags;
126         unsigned long newsp;
127         int __user *parent_tidptr, *child_tidptr;
128         clone_flags = regs->areg[4];
129         newsp = regs->areg[3];
130         parent_tidptr = (int __user *)regs->areg[5];
131         child_tidptr = (int __user *)regs->areg[6];
132         if (!newsp)
133                 newsp = regs->areg[1];
134         return do_fork(clone_flags,newsp,regs,0,parent_tidptr,child_tidptr);
135 }
136
137 /*
138  * sys_execve() executes a new program.
139  */
140
141 int sys_execve(struct pt_regs *regs)
142 {
143         int error;
144         char * filename;
145
146         filename = getname((char *) (long)regs->areg[5]);
147         error = PTR_ERR(filename);
148         if (IS_ERR(filename))
149                 goto out;
150         error = do_execve(filename, (char **) (long)regs->areg[3],
151                           (char **) (long)regs->areg[4], regs);
152         putname(filename);
153
154 out:
155         return error;
156 }
157
158 int sys_uname(struct old_utsname * name)
159 {
160         if (name && !copy_to_user(name, &system_utsname, sizeof (*name)))
161                 return 0;
162         return -EFAULT;
163 }
164
165 int sys_olduname(struct oldold_utsname * name)
166 {
167         int error;
168
169         if (!name)
170                 return -EFAULT;
171         if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
172                 return -EFAULT;
173
174         error = __copy_to_user(&name->sysname,&system_utsname.sysname,__OLD_UTS_LEN);
175         error -= __put_user(0,name->sysname+__OLD_UTS_LEN);
176         error -= __copy_to_user(&name->nodename,&system_utsname.nodename,__OLD_UTS_LEN);
177         error -= __put_user(0,name->nodename+__OLD_UTS_LEN);
178         error -= __copy_to_user(&name->release,&system_utsname.release,__OLD_UTS_LEN);
179         error -= __put_user(0,name->release+__OLD_UTS_LEN);
180         error -= __copy_to_user(&name->version,&system_utsname.version,__OLD_UTS_LEN);
181         error -= __put_user(0,name->version+__OLD_UTS_LEN);
182         error -= __copy_to_user(&name->machine,&system_utsname.machine,__OLD_UTS_LEN);
183         error -= __put_user(0,name->machine+__OLD_UTS_LEN);
184
185         return error ? -EFAULT : 0;
186 }
187
188
189 /*
190  * Build the string table for the builtin "poor man's strace".
191  */
192
193 #if DEBUG
194 #define SYSCALL(fun, narg) #fun,
195 static char *sfnames[] = {
196 #include "syscalls.h"
197 };
198 #undef SYS
199 #endif
200
201 void system_call (struct pt_regs *regs)
202 {
203         syscall_t syscall;
204         unsigned long parm0, parm1, parm2, parm3, parm4, parm5;
205         int nargs, res;
206         unsigned int syscallnr;
207         int ps;
208
209 #if DEBUG
210         int i;
211         unsigned long parms[6];
212         char *sysname;
213 #endif
214
215         regs->syscall = regs->areg[2];
216
217         do_syscall_trace();
218
219         /* Have to load after syscall_trace because strace
220          * sometimes changes regs->syscall.
221          */
222         syscallnr = regs->syscall;
223
224         parm0 = parm1 = parm2 = parm3 = parm4 = parm5 = 0;
225
226         /* Restore interrupt level to syscall invoker's.
227          * If this were in assembly, we wouldn't disable
228          * interrupts in the first place:
229          */
230         local_save_flags (ps);
231         local_irq_restore((ps & ~XCHAL_PS_INTLEVEL_MASK) |
232                           (regs->ps & XCHAL_PS_INTLEVEL_MASK) );
233
234         if (syscallnr > __NR_Linux_syscalls) {
235                 regs->areg[2] = -ENOSYS;
236                 return;
237         }
238
239         syscall = sys_call_table[syscallnr];
240         nargs = sys_narg_table[syscallnr];
241
242         if (syscall == NULL) {
243                 regs->areg[2] = -ENOSYS;
244                 return;
245         }
246
247         /* There shouldn't be more than six arguments in the table! */
248
249         if (nargs > 6)
250                 panic("Internal error - too many syscall arguments (%d)!\n",
251                       nargs);
252
253         /* Linux takes system-call arguments in registers.  The ABI
254          * and Xtensa software conventions require the system-call
255          * number in a2.  If an argument exists in a2, we move it to
256          * the next available register.  Note that for improved
257          * efficiency, we do NOT shift all parameters down one
258          * register to maintain the original order.
259          *
260          * At best case (zero arguments), we just write the syscall
261          * number to a2.  At worst case (1 to 6 arguments), we move
262          * the argument in a2 to the next available register, then
263          * write the syscall number to a2.
264          *
265          * For clarity, the following truth table enumerates all
266          * possibilities.
267          *
268          * arguments    syscall number  arg0, arg1, arg2, arg3, arg4, arg5
269          * ---------    --------------  ----------------------------------
270          *      0             a2
271          *      1             a2        a3
272          *      2             a2        a4,   a3
273          *      3             a2        a5,   a3,   a4
274          *      4             a2        a6,   a3,   a4,   a5
275          *      5             a2        a7,   a3,   a4,   a5,   a6
276          *      6             a2        a8,   a3,   a4,   a5,   a6,   a7
277          */
278         if (nargs) {
279                 parm0 = regs->areg[nargs+2];
280                 parm1 = regs->areg[3];
281                 parm2 = regs->areg[4];
282                 parm3 = regs->areg[5];
283                 parm4 = regs->areg[6];
284                 parm5 = regs->areg[7];
285         } else /* nargs == 0 */
286                 parm0 = (unsigned long) regs;
287
288 #if DEBUG
289         parms[0] = parm0;
290         parms[1] = parm1;
291         parms[2] = parm2;
292         parms[3] = parm3;
293         parms[4] = parm4;
294         parms[5] = parm5;
295
296         sysname = sfnames[syscallnr];
297         if (strncmp(sysname, "sys_", 4) == 0)
298                 sysname = sysname + 4;
299
300         printk("\017SYSCALL:I:%x:%d:%s  %s(", regs->pc, current->pid,
301                current->comm, sysname);
302         for (i = 0; i < nargs; i++)
303                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
304         printk(")\n");
305 #endif
306
307         res = syscall((void *)parm0, parm1, parm2, parm3, parm4, parm5);
308
309 #if DEBUG
310         printk("\017SYSCALL:O:%d:%s  %s(",current->pid, current->comm, sysname);
311         for (i = 0; i < nargs; i++)
312                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
313         if (res < 4096)
314                 printk(") = %d\n", res);
315         else
316                 printk(") = %#x\n", res);
317 #endif /* DEBUG */
318
319         regs->areg[2] = res;
320         do_syscall_trace();
321 }
322
323 /*
324  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
325  *
326  * This is really horribly ugly.
327  */
328
329 int sys_ipc (uint call, int first, int second,
330                         int third, void __user *ptr, long fifth)
331 {
332         int version, ret;
333
334         version = call >> 16; /* hack for backward compatibility */
335         call &= 0xffff;
336         ret = -ENOSYS;
337
338         switch (call) {
339         case SEMOP:
340                 ret = sys_semtimedop (first, (struct sembuf __user *)ptr,
341                                      second, NULL);
342                 break;
343
344         case SEMTIMEDOP:
345                 ret = sys_semtimedop (first, (struct sembuf __user *)ptr,
346                                       second, (const struct timespec *) fifth);
347                 break;
348
349         case SEMGET:
350                 ret = sys_semget (first, second, third);
351                 break;
352
353         case SEMCTL: {
354                 union semun fourth;
355
356                 if (ptr && !get_user(fourth.__pad, (void *__user *) ptr))
357                         ret = sys_semctl (first, second, third, fourth);
358                 break;
359                 }
360
361         case MSGSND:
362                 ret = sys_msgsnd (first, (struct msgbuf __user*) ptr,
363                                   second, third);
364                 break;
365
366         case MSGRCV:
367                 switch (version) {
368                 case 0: {
369                         struct ipc_kludge tmp;
370
371                         if (ptr && !copy_from_user(&tmp,
372                                            (struct ipc_kludge *) ptr,
373                                            sizeof (tmp)))
374                                 ret = sys_msgrcv (first, tmp.msgp, second,
375                                                   tmp.msgtyp, third);
376                         break;
377                         }
378
379                 default:
380                         ret = sys_msgrcv (first, (struct msgbuf __user *) ptr,
381                                           second, 0, third);
382                         break;
383                 }
384                 break;
385
386         case MSGGET:
387                 ret = sys_msgget ((key_t) first, second);
388                 break;
389
390         case MSGCTL:
391                 ret = sys_msgctl (first, second, (struct msqid_ds __user*) ptr);
392                 break;
393
394         case SHMAT: {
395                 ulong raddr;
396                 ret = do_shmat (first, (char __user *) ptr, second, &raddr);
397
398                 if (!ret)
399                         ret = put_user (raddr, (ulong __user *) third);
400
401                 break;
402                 }
403
404         case SHMDT:
405                 ret = sys_shmdt ((char __user *)ptr);
406                 break;
407
408         case SHMGET:
409                 ret = sys_shmget (first, second, third);
410                 break;
411
412         case SHMCTL:
413                 ret = sys_shmctl (first, second, (struct shmid_ds __user*) ptr);
414                 break;
415         }
416         return ret;
417 }
418