]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | */ | |
a9415644 | 10 | #include <linux/capability.h> |
1da177e4 LT |
11 | #include <linux/errno.h> |
12 | #include <linux/linkage.h> | |
4e950f6f | 13 | #include <linux/fs.h> |
1da177e4 | 14 | #include <linux/smp.h> |
1da177e4 | 15 | #include <linux/ptrace.h> |
1da177e4 LT |
16 | #include <linux/string.h> |
17 | #include <linux/syscalls.h> | |
18 | #include <linux/file.h> | |
1da177e4 LT |
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> | |
cba4fbbf | 25 | #include <linux/ipc.h> |
f1e39a4a | 26 | #include <linux/uaccess.h> |
5a0e3ad6 | 27 | #include <linux/slab.h> |
652b14aa | 28 | #include <linux/elf.h> |
1da177e4 | 29 | |
f1e39a4a | 30 | #include <asm/asm.h> |
1da177e4 LT |
31 | #include <asm/branch.h> |
32 | #include <asm/cachectl.h> | |
33 | #include <asm/cacheflush.h> | |
048eb582 | 34 | #include <asm/asm-offsets.h> |
1da177e4 LT |
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> | |
b81947c6 | 40 | #include <asm/switch_to.h> |
1da177e4 | 41 | |
8213bbf9 RB |
42 | /* |
43 | * For historic reasons the pipe(2) syscall on MIPS has an unusual calling | |
70342287 | 44 | * convention. It returns results in registers $v0 / $v1 which means there |
8213bbf9 | 45 | * is no need for it to do verify the validity of a userspace pointer |
70342287 | 46 | * argument. Historically that used to be expensive in Linux. These days |
8213bbf9 RB |
47 | * the performance advantage is negligible. |
48 | */ | |
49 | asmlinkage int sysm_pipe(nabi_no_regargs volatile struct pt_regs regs) | |
1da177e4 LT |
50 | { |
51 | int fd[2]; | |
52 | int error, res; | |
53 | ||
ed8cae8b | 54 | error = do_pipe_flags(fd, 0); |
1da177e4 LT |
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 | ||
dbda6ac0 RB |
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) | |
1da177e4 LT |
68 | { |
69 | unsigned long result; | |
70 | ||
71 | result = -EINVAL; | |
72 | if (offset & ~PAGE_MASK) | |
73 | goto out; | |
74 | ||
f8b72560 | 75 | result = sys_mmap_pgoff(addr, len, prot, flags, fd, offset >> PAGE_SHIFT); |
1da177e4 LT |
76 | |
77 | out: | |
78 | return result; | |
79 | } | |
80 | ||
dbda6ac0 RB |
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) | |
1da177e4 | 84 | { |
947df17c PA |
85 | if (pgoff & (~PAGE_MASK >> 12)) |
86 | return -EINVAL; | |
87 | ||
f8b72560 | 88 | return sys_mmap_pgoff(addr, len, prot, flags, fd, pgoff >> (PAGE_SHIFT-12)); |
1da177e4 LT |
89 | } |
90 | ||
91 | save_static_function(sys_fork); | |
f5dbeaf5 | 92 | static int __used noinline |
1da177e4 LT |
93 | _sys_fork(nabi_no_regargs struct pt_regs regs) |
94 | { | |
e80d6661 | 95 | return do_fork(SIGCHLD, regs.regs[29], 0, NULL, NULL); |
1da177e4 LT |
96 | } |
97 | ||
98 | save_static_function(sys_clone); | |
f5dbeaf5 | 99 | static int __used noinline |
1da177e4 LT |
100 | _sys_clone(nabi_no_regargs struct pt_regs regs) |
101 | { | |
102 | unsigned long clone_flags; | |
103 | unsigned long newsp; | |
3c37026d | 104 | int __user *parent_tidptr, *child_tidptr; |
1da177e4 LT |
105 | |
106 | clone_flags = regs.regs[4]; | |
107 | newsp = regs.regs[5]; | |
108 | if (!newsp) | |
109 | newsp = regs.regs[29]; | |
3c37026d RB |
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 | |
e80d6661 | 126 | return do_fork(clone_flags, newsp, 0, |
70342287 | 127 | parent_tidptr, child_tidptr); |
1da177e4 LT |
128 | } |
129 | ||
dbda6ac0 | 130 | SYSCALL_DEFINE1(set_thread_area, unsigned long, addr) |
3c37026d | 131 | { |
dc8f6029 | 132 | struct thread_info *ti = task_thread_info(current); |
3c37026d RB |
133 | |
134 | ti->tp_value = addr; | |
a3692020 RB |
135 | if (cpu_has_userlocal) |
136 | write_c0_userlocal(addr); | |
06be375b RB |
137 | |
138 | return 0; | |
3c37026d RB |
139 | } |
140 | ||
bc4f2975 | 141 | static inline int mips_atomic_set(unsigned long addr, unsigned long new) |
1da177e4 | 142 | { |
f1e39a4a | 143 | unsigned long old, tmp; |
bc4f2975 | 144 | struct pt_regs *regs; |
f1e39a4a RB |
145 | unsigned int err; |
146 | ||
147 | if (unlikely(addr & 3)) | |
148 | return -EINVAL; | |
149 | ||
150 | if (unlikely(!access_ok(VERIFY_WRITE, addr, 4))) | |
151 | return -EINVAL; | |
152 | ||
153 | if (cpu_has_llsc && R10000_LLSC_WAR) { | |
154 | __asm__ __volatile__ ( | |
a91be9ee | 155 | " .set mips3 \n" |
f1e39a4a RB |
156 | " li %[err], 0 \n" |
157 | "1: ll %[old], (%[addr]) \n" | |
158 | " move %[tmp], %[new] \n" | |
159 | "2: sc %[tmp], (%[addr]) \n" | |
160 | " beqzl %[tmp], 1b \n" | |
161 | "3: \n" | |
162 | " .section .fixup,\"ax\" \n" | |
163 | "4: li %[err], %[efault] \n" | |
164 | " j 3b \n" | |
165 | " .previous \n" | |
166 | " .section __ex_table,\"a\" \n" | |
167 | " "STR(PTR)" 1b, 4b \n" | |
168 | " "STR(PTR)" 2b, 4b \n" | |
169 | " .previous \n" | |
a91be9ee | 170 | " .set mips0 \n" |
f1e39a4a RB |
171 | : [old] "=&r" (old), |
172 | [err] "=&r" (err), | |
173 | [tmp] "=&r" (tmp) | |
174 | : [addr] "r" (addr), | |
175 | [new] "r" (new), | |
176 | [efault] "i" (-EFAULT) | |
177 | : "memory"); | |
178 | } else if (cpu_has_llsc) { | |
179 | __asm__ __volatile__ ( | |
a91be9ee | 180 | " .set mips3 \n" |
f1e39a4a RB |
181 | " li %[err], 0 \n" |
182 | "1: ll %[old], (%[addr]) \n" | |
183 | " move %[tmp], %[new] \n" | |
184 | "2: sc %[tmp], (%[addr]) \n" | |
185 | " bnez %[tmp], 4f \n" | |
186 | "3: \n" | |
187 | " .subsection 2 \n" | |
188 | "4: b 1b \n" | |
189 | " .previous \n" | |
190 | " \n" | |
191 | " .section .fixup,\"ax\" \n" | |
192 | "5: li %[err], %[efault] \n" | |
193 | " j 3b \n" | |
194 | " .previous \n" | |
195 | " .section __ex_table,\"a\" \n" | |
196 | " "STR(PTR)" 1b, 5b \n" | |
197 | " "STR(PTR)" 2b, 5b \n" | |
198 | " .previous \n" | |
a91be9ee | 199 | " .set mips0 \n" |
f1e39a4a RB |
200 | : [old] "=&r" (old), |
201 | [err] "=&r" (err), | |
202 | [tmp] "=&r" (tmp) | |
203 | : [addr] "r" (addr), | |
204 | [new] "r" (new), | |
205 | [efault] "i" (-EFAULT) | |
206 | : "memory"); | |
207 | } else { | |
208 | do { | |
209 | preempt_disable(); | |
210 | ll_bit = 1; | |
211 | ll_task = current; | |
212 | preempt_enable(); | |
213 | ||
214 | err = __get_user(old, (unsigned int *) addr); | |
215 | err |= __put_user(new, (unsigned int *) addr); | |
216 | if (err) | |
217 | break; | |
218 | rmb(); | |
219 | } while (!ll_bit); | |
220 | } | |
221 | ||
222 | if (unlikely(err)) | |
223 | return err; | |
224 | ||
bc4f2975 | 225 | regs = current_pt_regs(); |
f1e39a4a RB |
226 | regs->regs[2] = old; |
227 | regs->regs[7] = 0; /* No error */ | |
228 | ||
229 | /* | |
230 | * Don't let your children do this ... | |
231 | */ | |
232 | __asm__ __volatile__( | |
233 | " move $29, %0 \n" | |
234 | " j syscall_exit \n" | |
235 | : /* no outputs */ | |
236 | : "r" (regs)); | |
237 | ||
238 | /* unreached. Honestly. */ | |
33722a2e | 239 | unreachable(); |
f1e39a4a RB |
240 | } |
241 | ||
bc4f2975 | 242 | SYSCALL_DEFINE3(sysmips, long, cmd, long, arg1, long, arg2) |
f1e39a4a | 243 | { |
293c5bd1 | 244 | switch (cmd) { |
1da177e4 | 245 | case MIPS_ATOMIC_SET: |
bc4f2975 | 246 | return mips_atomic_set(arg1, arg2); |
1da177e4 LT |
247 | |
248 | case MIPS_FIXADE: | |
293c5bd1 RB |
249 | if (arg1 & ~3) |
250 | return -EINVAL; | |
251 | ||
252 | if (arg1 & 1) | |
253 | set_thread_flag(TIF_FIXADE); | |
254 | else | |
255 | clear_thread_flag(TIF_FIXADE); | |
256 | if (arg1 & 2) | |
257 | set_thread_flag(TIF_LOGADE); | |
258 | else | |
e56293b1 | 259 | clear_thread_flag(TIF_LOGADE); |
293c5bd1 | 260 | |
1da177e4 LT |
261 | return 0; |
262 | ||
263 | case FLUSH_CACHE: | |
264 | __flush_cache_all(); | |
265 | return 0; | |
1da177e4 LT |
266 | } |
267 | ||
268 | return -EINVAL; | |
269 | } | |
270 | ||
1da177e4 LT |
271 | /* |
272 | * No implemented yet ... | |
273 | */ | |
dbda6ac0 | 274 | SYSCALL_DEFINE3(cachectl, char *, addr, int, nbytes, int, op) |
1da177e4 LT |
275 | { |
276 | return -ENOSYS; | |
277 | } | |
278 | ||
279 | /* | |
280 | * If we ever come here the user sp is bad. Zap the process right away. | |
281 | * Due to the bad stack signaling wouldn't work. | |
282 | */ | |
283 | asmlinkage void bad_stack(void) | |
284 | { | |
285 | do_exit(SIGSEGV); | |
286 | } |