fix file specification in comments
[linux-2.6.git] / arch / xtensa / kernel / syscalls.c
1 /*
2  * arch/xtensa/kernel/syscalls.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/linkage.h>
22 #include <linux/mm.h>
23 #include <linux/smp.h>
24 #include <linux/smp_lock.h>
25 #include <linux/mman.h>
26 #include <linux/sched.h>
27 #include <linux/file.h>
28 #include <linux/slab.h>
29 #include <linux/utsname.h>
30 #include <linux/unistd.h>
31 #include <linux/stringify.h>
32 #include <linux/syscalls.h>
33 #include <linux/sem.h>
34 #include <linux/msg.h>
35 #include <linux/shm.h>
36 #include <linux/errno.h>
37 #include <asm/ptrace.h>
38 #include <asm/signal.h>
39 #include <asm/uaccess.h>
40 #include <asm/hardirq.h>
41 #include <asm/mman.h>
42 #include <asm/shmparam.h>
43 #include <asm/page.h>
44
45 extern void do_syscall_trace(void);
46 typedef int (*syscall_t)(void *a0,...);
47 extern syscall_t sys_call_table[];
48 extern unsigned char sys_narg_table[];
49
50 /*
51  * sys_pipe() is the normal C calling standard for creating a pipe. It's not
52  * the way unix traditional does this, though.
53  */
54
55 int sys_pipe(int __user *userfds)
56 {
57         int fd[2];
58         int error;
59
60         error = do_pipe(fd);
61         if (!error) {
62                 if (copy_to_user(userfds, fd, 2 * sizeof(int)))
63                         error = -EFAULT;
64         }
65         return error;
66 }
67
68 /*
69  * Common code for old and new mmaps.
70  */
71 long sys_mmap(unsigned long addr, unsigned long len, unsigned long prot,
72               unsigned long flags, 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 int sys_clone(struct pt_regs *regs)
95 {
96         unsigned long clone_flags;
97         unsigned long newsp;
98         int __user *parent_tidptr, *child_tidptr;
99         clone_flags = regs->areg[4];
100         newsp = regs->areg[3];
101         parent_tidptr = (int __user *)regs->areg[5];
102         child_tidptr = (int __user *)regs->areg[6];
103         if (!newsp)
104                 newsp = regs->areg[1];
105         return do_fork(clone_flags,newsp,regs,0,parent_tidptr,child_tidptr);
106 }
107
108 /*
109  * sys_execve() executes a new program.
110  */
111
112 int sys_execve(struct pt_regs *regs)
113 {
114         int error;
115         char * filename;
116
117         filename = getname((char *) (long)regs->areg[5]);
118         error = PTR_ERR(filename);
119         if (IS_ERR(filename))
120                 goto out;
121         error = do_execve(filename, (char **) (long)regs->areg[3],
122                           (char **) (long)regs->areg[4], regs);
123         putname(filename);
124
125 out:
126         return error;
127 }
128
129 int sys_uname(struct old_utsname * name)
130 {
131         if (name && !copy_to_user(name, utsname(), sizeof (*name)))
132                 return 0;
133         return -EFAULT;
134 }
135
136 /*
137  * Build the string table for the builtin "poor man's strace".
138  */
139
140 #if DEBUG
141 #define SYSCALL(fun, narg) #fun,
142 static char *sfnames[] = {
143 #include "syscalls.h"
144 };
145 #undef SYS
146 #endif
147
148 void system_call (struct pt_regs *regs)
149 {
150         syscall_t syscall;
151         unsigned long parm0, parm1, parm2, parm3, parm4, parm5;
152         int nargs, res;
153         unsigned int syscallnr;
154         int ps;
155
156 #if DEBUG
157         int i;
158         unsigned long parms[6];
159         char *sysname;
160 #endif
161
162         regs->syscall = regs->areg[2];
163
164         do_syscall_trace();
165
166         /* Have to load after syscall_trace because strace
167          * sometimes changes regs->syscall.
168          */
169         syscallnr = regs->syscall;
170
171         parm0 = parm1 = parm2 = parm3 = parm4 = parm5 = 0;
172
173         /* Restore interrupt level to syscall invoker's.
174          * If this were in assembly, we wouldn't disable
175          * interrupts in the first place:
176          */
177         local_save_flags (ps);
178         local_irq_restore((ps & ~XCHAL_PS_INTLEVEL_MASK) |
179                           (regs->ps & XCHAL_PS_INTLEVEL_MASK) );
180
181         if (syscallnr > __NR_Linux_syscalls) {
182                 regs->areg[2] = -ENOSYS;
183                 return;
184         }
185
186         syscall = sys_call_table[syscallnr];
187         nargs = sys_narg_table[syscallnr];
188
189         if (syscall == NULL) {
190                 regs->areg[2] = -ENOSYS;
191                 return;
192         }
193
194         /* There shouldn't be more than six arguments in the table! */
195
196         if (nargs > 6)
197                 panic("Internal error - too many syscall arguments (%d)!\n",
198                       nargs);
199
200         /* Linux takes system-call arguments in registers.  The ABI
201          * and Xtensa software conventions require the system-call
202          * number in a2.  If an argument exists in a2, we move it to
203          * the next available register.  Note that for improved
204          * efficiency, we do NOT shift all parameters down one
205          * register to maintain the original order.
206          *
207          * At best case (zero arguments), we just write the syscall
208          * number to a2.  At worst case (1 to 6 arguments), we move
209          * the argument in a2 to the next available register, then
210          * write the syscall number to a2.
211          *
212          * For clarity, the following truth table enumerates all
213          * possibilities.
214          *
215          * arguments    syscall number  arg0, arg1, arg2, arg3, arg4, arg5
216          * ---------    --------------  ----------------------------------
217          *      0             a2
218          *      1             a2        a3
219          *      2             a2        a4,   a3
220          *      3             a2        a5,   a3,   a4
221          *      4             a2        a6,   a3,   a4,   a5
222          *      5             a2        a7,   a3,   a4,   a5,   a6
223          *      6             a2        a8,   a3,   a4,   a5,   a6,   a7
224          */
225         if (nargs) {
226                 parm0 = regs->areg[nargs+2];
227                 parm1 = regs->areg[3];
228                 parm2 = regs->areg[4];
229                 parm3 = regs->areg[5];
230                 parm4 = regs->areg[6];
231                 parm5 = regs->areg[7];
232         } else /* nargs == 0 */
233                 parm0 = (unsigned long) regs;
234
235 #if DEBUG
236         parms[0] = parm0;
237         parms[1] = parm1;
238         parms[2] = parm2;
239         parms[3] = parm3;
240         parms[4] = parm4;
241         parms[5] = parm5;
242
243         sysname = sfnames[syscallnr];
244         if (strncmp(sysname, "sys_", 4) == 0)
245                 sysname = sysname + 4;
246
247         printk("\017SYSCALL:I:%x:%d:%s  %s(", regs->pc, current->pid,
248                current->comm, sysname);
249         for (i = 0; i < nargs; i++)
250                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
251         printk(")\n");
252 #endif
253
254         res = syscall((void *)parm0, parm1, parm2, parm3, parm4, parm5);
255
256 #if DEBUG
257         printk("\017SYSCALL:O:%d:%s  %s(",current->pid, current->comm, sysname);
258         for (i = 0; i < nargs; i++)
259                 printk((i>0) ? ", %#lx" : "%#lx", parms[i]);
260         if (res < 4096)
261                 printk(") = %d\n", res);
262         else
263                 printk(") = %#x\n", res);
264 #endif /* DEBUG */
265
266         regs->areg[2] = res;
267         do_syscall_trace();
268 }
269
270 /*
271  * Do a system call from kernel instead of calling sys_execve so we
272  * end up with proper pt_regs.
273  */
274 int kernel_execve(const char *filename, char *const argv[], char *const envp[])
275 {
276         long __res;
277         asm volatile (
278                 "  mov   a5, %2 \n"
279                 "  mov   a4, %4 \n"
280                 "  mov   a3, %3 \n"
281                 "  movi  a2, %1 \n"
282                 "  syscall      \n"
283                 "  mov   %0, a2 \n"
284                 : "=a" (__res)
285                 : "i" (__NR_execve), "a" (filename), "a" (argv), "a" (envp)
286                 : "a2", "a3", "a4", "a5");
287         return __res;
288 }