Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
syscall.c
Go to the documentation of this file.
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License. See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (C) 1995, 1996, 1997, 2000, 2001, 05 by Ralf Baechle
7  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
8  * Copyright (C) 2001 MIPS Technologies, Inc.
9  */
10 #include <linux/capability.h>
11 #include <linux/errno.h>
12 #include <linux/linkage.h>
13 #include <linux/fs.h>
14 #include <linux/smp.h>
15 #include <linux/ptrace.h>
16 #include <linux/string.h>
17 #include <linux/syscalls.h>
18 #include <linux/file.h>
19 #include <linux/utsname.h>
20 #include <linux/unistd.h>
21 #include <linux/sem.h>
22 #include <linux/msg.h>
23 #include <linux/shm.h>
24 #include <linux/compiler.h>
25 #include <linux/ipc.h>
26 #include <linux/uaccess.h>
27 #include <linux/slab.h>
28 #include <linux/elf.h>
29 
30 #include <asm/asm.h>
31 #include <asm/branch.h>
32 #include <asm/cachectl.h>
33 #include <asm/cacheflush.h>
34 #include <asm/asm-offsets.h>
35 #include <asm/signal.h>
36 #include <asm/sim.h>
37 #include <asm/shmparam.h>
38 #include <asm/sysmips.h>
39 #include <asm/uaccess.h>
40 #include <asm/switch_to.h>
41 
42 /*
43  * For historic reasons the pipe(2) syscall on MIPS has an unusual calling
44  * convention. It returns results in registers $v0 / $v1 which means there
45  * is no need for it to do verify the validity of a userspace pointer
46  * argument. Historically that used to be expensive in Linux. These days
47  * the performance advantage is negligible.
48  */
49 asmlinkage int sysm_pipe(nabi_no_regargs volatile struct pt_regs regs)
50 {
51  int fd[2];
52  int error, res;
53 
54  error = do_pipe_flags(fd, 0);
55  if (error) {
56  res = error;
57  goto out;
58  }
59  regs.regs[3] = fd[1];
60  res = fd[0];
61 out:
62  return res;
63 }
64 
65 SYSCALL_DEFINE6(mips_mmap, unsigned long, addr, unsigned long, len,
66  unsigned long, prot, unsigned long, flags, unsigned long,
67  fd, off_t, offset)
68 {
69  unsigned long result;
70 
71  result = -EINVAL;
72  if (offset & ~PAGE_MASK)
73  goto out;
74 
75  result = sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
76 
77 out:
78  return result;
79 }
80 
81 SYSCALL_DEFINE6(mips_mmap2, unsigned long, addr, unsigned long, len,
82  unsigned long, prot, unsigned long, flags, unsigned long, fd,
83  unsigned long, pgoff)
84 {
85  if (pgoff & (~PAGE_MASK >> 12))
86  return -EINVAL;
87 
88  return sys_mmap_pgoff(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT-12));
89 }
90 
91 save_static_function(sys_fork);
92 static int __used noinline
93 _sys_fork(nabi_no_regargs struct pt_regs regs)
94 {
95  return do_fork(SIGCHLD, regs.regs[29], &regs, 0, NULL, NULL);
96 }
97 
98 save_static_function(sys_clone);
99 static int __used noinline
100 _sys_clone(nabi_no_regargs struct pt_regs regs)
101 {
102  unsigned long clone_flags;
103  unsigned long newsp;
104  int __user *parent_tidptr, *child_tidptr;
105 
106  clone_flags = regs.regs[4];
107  newsp = regs.regs[5];
108  if (!newsp)
109  newsp = regs.regs[29];
110  parent_tidptr = (int __user *) regs.regs[6];
111 #ifdef CONFIG_32BIT
112  /* We need to fetch the fifth argument off the stack. */
113  child_tidptr = NULL;
114  if (clone_flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) {
115  int __user *__user *usp = (int __user *__user *) regs.regs[29];
116  if (regs.regs[2] == __NR_syscall) {
117  if (get_user (child_tidptr, &usp[5]))
118  return -EFAULT;
119  }
120  else if (get_user (child_tidptr, &usp[4]))
121  return -EFAULT;
122  }
123 #else
124  child_tidptr = (int __user *) regs.regs[8];
125 #endif
126  return do_fork(clone_flags, newsp, &regs, 0,
127  parent_tidptr, child_tidptr);
128 }
129 
130 /*
131  * sys_execve() executes a new program.
132  */
133 asmlinkage int sys_execve(nabi_no_regargs struct pt_regs regs)
134 {
135  int error;
136  struct filename *filename;
137 
138  filename = getname((const char __user *) (long)regs.regs[4]);
139  error = PTR_ERR(filename);
140  if (IS_ERR(filename))
141  goto out;
142  error = do_execve(filename->name,
143  (const char __user *const __user *) (long)regs.regs[5],
144  (const char __user *const __user *) (long)regs.regs[6],
145  &regs);
146  putname(filename);
147 
148 out:
149  return error;
150 }
151 
152 SYSCALL_DEFINE1(set_thread_area, unsigned long, addr)
153 {
154  struct thread_info *ti = task_thread_info(current);
155 
156  ti->tp_value = addr;
157  if (cpu_has_userlocal)
158  write_c0_userlocal(addr);
159 
160  return 0;
161 }
162 
163 static inline int mips_atomic_set(struct pt_regs *regs,
164  unsigned long addr, unsigned long new)
165 {
166  unsigned long old, tmp;
167  unsigned int err;
168 
169  if (unlikely(addr & 3))
170  return -EINVAL;
171 
172  if (unlikely(!access_ok(VERIFY_WRITE, addr, 4)))
173  return -EINVAL;
174 
175  if (cpu_has_llsc && R10000_LLSC_WAR) {
176  __asm__ __volatile__ (
177  " .set mips3 \n"
178  " li %[err], 0 \n"
179  "1: ll %[old], (%[addr]) \n"
180  " move %[tmp], %[new] \n"
181  "2: sc %[tmp], (%[addr]) \n"
182  " beqzl %[tmp], 1b \n"
183  "3: \n"
184  " .section .fixup,\"ax\" \n"
185  "4: li %[err], %[efault] \n"
186  " j 3b \n"
187  " .previous \n"
188  " .section __ex_table,\"a\" \n"
189  " "STR(PTR)" 1b, 4b \n"
190  " "STR(PTR)" 2b, 4b \n"
191  " .previous \n"
192  " .set mips0 \n"
193  : [old] "=&r" (old),
194  [err] "=&r" (err),
195  [tmp] "=&r" (tmp)
196  : [addr] "r" (addr),
197  [new] "r" (new),
198  [efault] "i" (-EFAULT)
199  : "memory");
200  } else if (cpu_has_llsc) {
201  __asm__ __volatile__ (
202  " .set mips3 \n"
203  " li %[err], 0 \n"
204  "1: ll %[old], (%[addr]) \n"
205  " move %[tmp], %[new] \n"
206  "2: sc %[tmp], (%[addr]) \n"
207  " bnez %[tmp], 4f \n"
208  "3: \n"
209  " .subsection 2 \n"
210  "4: b 1b \n"
211  " .previous \n"
212  " \n"
213  " .section .fixup,\"ax\" \n"
214  "5: li %[err], %[efault] \n"
215  " j 3b \n"
216  " .previous \n"
217  " .section __ex_table,\"a\" \n"
218  " "STR(PTR)" 1b, 5b \n"
219  " "STR(PTR)" 2b, 5b \n"
220  " .previous \n"
221  " .set mips0 \n"
222  : [old] "=&r" (old),
223  [err] "=&r" (err),
224  [tmp] "=&r" (tmp)
225  : [addr] "r" (addr),
226  [new] "r" (new),
227  [efault] "i" (-EFAULT)
228  : "memory");
229  } else {
230  do {
231  preempt_disable();
232  ll_bit = 1;
233  ll_task = current;
234  preempt_enable();
235 
236  err = __get_user(old, (unsigned int *) addr);
237  err |= __put_user(new, (unsigned int *) addr);
238  if (err)
239  break;
240  rmb();
241  } while (!ll_bit);
242  }
243 
244  if (unlikely(err))
245  return err;
246 
247  regs->regs[2] = old;
248  regs->regs[7] = 0; /* No error */
249 
250  /*
251  * Don't let your children do this ...
252  */
253  __asm__ __volatile__(
254  " move $29, %0 \n"
255  " j syscall_exit \n"
256  : /* no outputs */
257  : "r" (regs));
258 
259  /* unreached. Honestly. */
260  while (1);
261 }
262 
263 save_static_function(sys_sysmips);
264 static int __used noinline
265 _sys_sysmips(nabi_no_regargs struct pt_regs regs)
266 {
267  long cmd, arg1, arg2;
268 
269  cmd = regs.regs[4];
270  arg1 = regs.regs[5];
271  arg2 = regs.regs[6];
272 
273  switch (cmd) {
274  case MIPS_ATOMIC_SET:
275  return mips_atomic_set(&regs, arg1, arg2);
276 
277  case MIPS_FIXADE:
278  if (arg1 & ~3)
279  return -EINVAL;
280 
281  if (arg1 & 1)
282  set_thread_flag(TIF_FIXADE);
283  else
284  clear_thread_flag(TIF_FIXADE);
285  if (arg1 & 2)
286  set_thread_flag(TIF_LOGADE);
287  else
288  clear_thread_flag(TIF_LOGADE);
289 
290  return 0;
291 
292  case FLUSH_CACHE:
293  __flush_cache_all();
294  return 0;
295  }
296 
297  return -EINVAL;
298 }
299 
300 /*
301  * No implemented yet ...
302  */
303 SYSCALL_DEFINE3(cachectl, char *, addr, int, nbytes, int, op)
304 {
305  return -ENOSYS;
306 }
307 
308 /*
309  * If we ever come here the user sp is bad. Zap the process right away.
310  * Due to the bad stack signaling wouldn't work.
311  */
312 asmlinkage void bad_stack(void)
313 {
314  do_exit(SIGSEGV);
315 }
316 
317 /*
318  * Do a system call from kernel instead of calling sys_execve so we
319  * end up with proper pt_regs.
320  */
321 int kernel_execve(const char *filename,
322  const char *const argv[],
323  const char *const envp[])
324 {
325  register unsigned long __a0 asm("$4") = (unsigned long) filename;
326  register unsigned long __a1 asm("$5") = (unsigned long) argv;
327  register unsigned long __a2 asm("$6") = (unsigned long) envp;
328  register unsigned long __a3 asm("$7");
329  unsigned long __v0;
330 
331  __asm__ volatile (" \n"
332  " .set noreorder \n"
333  " li $2, %5 # __NR_execve \n"
334  " syscall \n"
335  " move %0, $2 \n"
336  " .set reorder \n"
337  : "=&r" (__v0), "=r" (__a3)
338  : "r" (__a0), "r" (__a1), "r" (__a2), "i" (__NR_execve)
339  : "$2", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", "$24",
340  "memory");
341 
342  if (__a3 == 0)
343  return __v0;
344 
345  return -__v0;
346 }
Generated on Thu Jan 10 2013 13:05:58 for Linux Kernel by   doxygen 1.8.2