Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
30286ef6 | 2 | * Implementation of various system calls for Linux/PowerPC |
1da177e4 | 3 | * |
1da177e4 LT |
4 | * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) |
5 | * | |
6 | * Derived from "arch/i386/kernel/sys_i386.c" | |
7 | * Adapted from the i386 version by Gary Thomas | |
8 | * Modified by Cort Dougan (cort@cs.nmt.edu) | |
9 | * and Paul Mackerras (paulus@cs.anu.edu.au). | |
10 | * | |
11 | * This file contains various random system calls that | |
12 | * have a non-standard calling sequence on the Linux/PPC | |
13 | * platform. | |
14 | * | |
15 | * This program is free software; you can redistribute it and/or | |
16 | * modify it under the terms of the GNU General Public License | |
17 | * as published by the Free Software Foundation; either version | |
18 | * 2 of the License, or (at your option) any later version. | |
19 | * | |
20 | */ | |
21 | ||
22 | #include <linux/errno.h> | |
23 | #include <linux/sched.h> | |
24 | #include <linux/syscalls.h> | |
25 | #include <linux/mm.h> | |
26 | #include <linux/smp.h> | |
27 | #include <linux/smp_lock.h> | |
28 | #include <linux/sem.h> | |
29 | #include <linux/msg.h> | |
30 | #include <linux/shm.h> | |
31 | #include <linux/stat.h> | |
32 | #include <linux/mman.h> | |
33 | #include <linux/sys.h> | |
34 | #include <linux/ipc.h> | |
35 | #include <linux/utsname.h> | |
36 | #include <linux/file.h> | |
37 | #include <linux/init.h> | |
38 | #include <linux/personality.h> | |
39 | ||
40 | #include <asm/uaccess.h> | |
41 | #include <asm/ipc.h> | |
42 | #include <asm/semaphore.h> | |
a7f31841 | 43 | #include <asm/syscalls.h> |
1da177e4 LT |
44 | #include <asm/time.h> |
45 | #include <asm/unistd.h> | |
46 | ||
1da177e4 LT |
47 | /* |
48 | * sys_ipc() is the de-multiplexer for the SysV IPC calls.. | |
49 | * | |
50 | * This is really horribly ugly. | |
51 | */ | |
30286ef6 PM |
52 | int sys_ipc(uint call, int first, unsigned long second, long third, |
53 | void __user *ptr, long fifth) | |
1da177e4 LT |
54 | { |
55 | int version, ret; | |
56 | ||
57 | version = call >> 16; /* hack for backward compatibility */ | |
58 | call &= 0xffff; | |
59 | ||
60 | ret = -ENOSYS; | |
61 | switch (call) { | |
62 | case SEMOP: | |
63 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, | |
64 | (unsigned)second, NULL); | |
65 | break; | |
66 | case SEMTIMEDOP: | |
67 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, | |
68 | (unsigned)second, | |
69 | (const struct timespec __user *) fifth); | |
70 | break; | |
71 | case SEMGET: | |
72 | ret = sys_semget (first, (int)second, third); | |
73 | break; | |
74 | case SEMCTL: { | |
75 | union semun fourth; | |
76 | ||
77 | ret = -EINVAL; | |
78 | if (!ptr) | |
79 | break; | |
80 | if ((ret = get_user(fourth.__pad, (void __user * __user *)ptr))) | |
81 | break; | |
82 | ret = sys_semctl(first, (int)second, third, fourth); | |
83 | break; | |
84 | } | |
85 | case MSGSND: | |
86 | ret = sys_msgsnd(first, (struct msgbuf __user *)ptr, | |
30286ef6 | 87 | (size_t)second, third); |
1da177e4 LT |
88 | break; |
89 | case MSGRCV: | |
90 | switch (version) { | |
91 | case 0: { | |
92 | struct ipc_kludge tmp; | |
93 | ||
94 | ret = -EINVAL; | |
95 | if (!ptr) | |
96 | break; | |
97 | if ((ret = copy_from_user(&tmp, | |
98 | (struct ipc_kludge __user *) ptr, | |
99 | sizeof (tmp)) ? -EFAULT : 0)) | |
100 | break; | |
101 | ret = sys_msgrcv(first, tmp.msgp, (size_t) second, | |
102 | tmp.msgtyp, third); | |
103 | break; | |
104 | } | |
105 | default: | |
106 | ret = sys_msgrcv (first, (struct msgbuf __user *) ptr, | |
107 | (size_t)second, fifth, third); | |
108 | break; | |
109 | } | |
110 | break; | |
111 | case MSGGET: | |
30286ef6 | 112 | ret = sys_msgget((key_t)first, (int)second); |
1da177e4 LT |
113 | break; |
114 | case MSGCTL: | |
115 | ret = sys_msgctl(first, (int)second, | |
116 | (struct msqid_ds __user *)ptr); | |
117 | break; | |
30286ef6 PM |
118 | case SHMAT: { |
119 | ulong raddr; | |
120 | ret = do_shmat(first, (char __user *)ptr, (int)second, &raddr); | |
121 | if (ret) | |
1da177e4 | 122 | break; |
30286ef6 | 123 | ret = put_user(raddr, (ulong __user *) third); |
1da177e4 | 124 | break; |
30286ef6 PM |
125 | } |
126 | case SHMDT: | |
127 | ret = sys_shmdt((char __user *)ptr); | |
1da177e4 LT |
128 | break; |
129 | case SHMGET: | |
30286ef6 | 130 | ret = sys_shmget(first, (size_t)second, third); |
1da177e4 LT |
131 | break; |
132 | case SHMCTL: | |
133 | ret = sys_shmctl(first, (int)second, | |
30286ef6 | 134 | (struct shmid_ds __user *)ptr); |
1da177e4 LT |
135 | break; |
136 | } | |
137 | ||
138 | return ret; | |
139 | } | |
140 | ||
141 | /* | |
142 | * sys_pipe() is the normal C calling standard for creating | |
143 | * a pipe. It's not the way unix traditionally does this, though. | |
144 | */ | |
30286ef6 | 145 | int sys_pipe(int __user *fildes) |
1da177e4 LT |
146 | { |
147 | int fd[2]; | |
148 | int error; | |
30286ef6 | 149 | |
1da177e4 LT |
150 | error = do_pipe(fd); |
151 | if (!error) { | |
152 | if (copy_to_user(fildes, fd, 2*sizeof(int))) | |
153 | error = -EFAULT; | |
154 | } | |
1da177e4 LT |
155 | return error; |
156 | } | |
157 | ||
30286ef6 PM |
158 | static inline unsigned long do_mmap2(unsigned long addr, size_t len, |
159 | unsigned long prot, unsigned long flags, | |
160 | unsigned long fd, unsigned long off, int shift) | |
1da177e4 LT |
161 | { |
162 | struct file * file = NULL; | |
05d84681 | 163 | unsigned long ret = -EINVAL; |
1da177e4 | 164 | |
30286ef6 PM |
165 | if (shift) { |
166 | if (off & ((1 << shift) - 1)) | |
167 | goto out; | |
168 | off >>= shift; | |
169 | } | |
170 | ||
171 | ret = -EBADF; | |
1da177e4 LT |
172 | if (!(flags & MAP_ANONYMOUS)) { |
173 | if (!(file = fget(fd))) | |
174 | goto out; | |
175 | } | |
176 | ||
177 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); | |
30286ef6 | 178 | |
1da177e4 | 179 | down_write(¤t->mm->mmap_sem); |
30286ef6 | 180 | ret = do_mmap_pgoff(file, addr, len, prot, flags, off); |
1da177e4 LT |
181 | up_write(¤t->mm->mmap_sem); |
182 | if (file) | |
183 | fput(file); | |
1da177e4 LT |
184 | out: |
185 | return ret; | |
186 | } | |
187 | ||
30286ef6 PM |
188 | unsigned long sys_mmap2(unsigned long addr, size_t len, |
189 | unsigned long prot, unsigned long flags, | |
190 | unsigned long fd, unsigned long pgoff) | |
191 | { | |
192 | return do_mmap2(addr, len, prot, flags, fd, pgoff, PAGE_SHIFT-12); | |
193 | } | |
194 | ||
195 | unsigned long sys_mmap(unsigned long addr, size_t len, | |
196 | unsigned long prot, unsigned long flags, | |
197 | unsigned long fd, off_t offset) | |
198 | { | |
199 | return do_mmap2(addr, len, prot, flags, fd, offset, PAGE_SHIFT); | |
200 | } | |
201 | ||
202 | #ifdef CONFIG_PPC32 | |
203 | /* | |
204 | * Due to some executables calling the wrong select we sometimes | |
205 | * get wrong args. This determines how the args are being passed | |
206 | * (a single ptr to them all args passed) then calls | |
207 | * sys_select() with the appropriate args. -- Cort | |
208 | */ | |
209 | int | |
210 | ppc_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp) | |
211 | { | |
212 | if ( (unsigned long)n >= 4096 ) | |
213 | { | |
214 | unsigned long __user *buffer = (unsigned long __user *)n; | |
215 | if (!access_ok(VERIFY_READ, buffer, 5*sizeof(unsigned long)) | |
216 | || __get_user(n, buffer) | |
217 | || __get_user(inp, ((fd_set __user * __user *)(buffer+1))) | |
218 | || __get_user(outp, ((fd_set __user * __user *)(buffer+2))) | |
219 | || __get_user(exp, ((fd_set __user * __user *)(buffer+3))) | |
220 | || __get_user(tvp, ((struct timeval __user * __user *)(buffer+4)))) | |
221 | return -EFAULT; | |
222 | } | |
223 | return sys_select(n, inp, outp, exp, tvp); | |
224 | } | |
225 | #endif | |
226 | ||
227 | #ifdef CONFIG_PPC64 | |
ce10d979 | 228 | long ppc64_personality(unsigned long personality) |
1da177e4 | 229 | { |
ce10d979 PM |
230 | long ret; |
231 | ||
232 | if (personality(current->personality) == PER_LINUX32 | |
233 | && personality == PER_LINUX) | |
234 | personality = PER_LINUX32; | |
235 | ret = sys_personality(personality); | |
236 | if (ret == PER_LINUX32) | |
237 | ret = PER_LINUX; | |
238 | return ret; | |
1da177e4 | 239 | } |
30286ef6 PM |
240 | #endif |
241 | ||
242 | #ifdef CONFIG_PPC64 | |
243 | #define OVERRIDE_MACHINE (personality(current->personality) == PER_LINUX32) | |
244 | #else | |
245 | #define OVERRIDE_MACHINE 0 | |
246 | #endif | |
1da177e4 | 247 | |
ebbd1bce | 248 | static inline int override_machine(char __user *mach) |
30286ef6 PM |
249 | { |
250 | if (OVERRIDE_MACHINE) { | |
251 | /* change ppc64 to ppc */ | |
252 | if (__put_user(0, mach+3) || __put_user(0, mach+4)) | |
253 | return -EFAULT; | |
254 | } | |
255 | return 0; | |
256 | } | |
257 | ||
258 | long ppc_newuname(struct new_utsname __user * name) | |
1da177e4 | 259 | { |
ce10d979 PM |
260 | int err = 0; |
261 | ||
1da177e4 | 262 | down_read(&uts_sem); |
ce10d979 PM |
263 | if (copy_to_user(name, &system_utsname, sizeof(*name))) |
264 | err = -EFAULT; | |
1da177e4 | 265 | up_read(&uts_sem); |
30286ef6 PM |
266 | if (!err) |
267 | err = override_machine(name->machine); | |
1da177e4 LT |
268 | return err; |
269 | } | |
270 | ||
30286ef6 PM |
271 | int sys_uname(struct old_utsname __user *name) |
272 | { | |
273 | int err = 0; | |
274 | ||
275 | down_read(&uts_sem); | |
276 | if (copy_to_user(name, &system_utsname, sizeof(*name))) | |
277 | err = -EFAULT; | |
278 | up_read(&uts_sem); | |
279 | if (!err) | |
280 | err = override_machine(name->machine); | |
281 | return err; | |
282 | } | |
283 | ||
284 | int sys_olduname(struct oldold_utsname __user *name) | |
285 | { | |
286 | int error; | |
287 | ||
288 | if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname))) | |
289 | return -EFAULT; | |
290 | ||
291 | down_read(&uts_sem); | |
292 | error = __copy_to_user(&name->sysname, &system_utsname.sysname, | |
293 | __OLD_UTS_LEN); | |
294 | error |= __put_user(0, name->sysname + __OLD_UTS_LEN); | |
295 | error |= __copy_to_user(&name->nodename, &system_utsname.nodename, | |
296 | __OLD_UTS_LEN); | |
297 | error |= __put_user(0, name->nodename + __OLD_UTS_LEN); | |
298 | error |= __copy_to_user(&name->release, &system_utsname.release, | |
299 | __OLD_UTS_LEN); | |
300 | error |= __put_user(0, name->release + __OLD_UTS_LEN); | |
301 | error |= __copy_to_user(&name->version, &system_utsname.version, | |
302 | __OLD_UTS_LEN); | |
303 | error |= __put_user(0, name->version + __OLD_UTS_LEN); | |
304 | error |= __copy_to_user(&name->machine, &system_utsname.machine, | |
305 | __OLD_UTS_LEN); | |
306 | error |= override_machine(name->machine); | |
307 | up_read(&uts_sem); | |
308 | ||
309 | return error? -EFAULT: 0; | |
310 | } | |
311 | ||
77f543cb PM |
312 | long ppc_fadvise64_64(int fd, int advice, u32 offset_high, u32 offset_low, |
313 | u32 len_high, u32 len_low) | |
314 | { | |
315 | return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, | |
316 | (u64)len_high << 32 | len_low, advice); | |
317 | } | |
318 | ||
1da177e4 LT |
319 | void do_show_syscall(unsigned long r3, unsigned long r4, unsigned long r5, |
320 | unsigned long r6, unsigned long r7, unsigned long r8, | |
321 | struct pt_regs *regs) | |
322 | { | |
323 | printk("syscall %ld(%lx, %lx, %lx, %lx, %lx, %lx) regs=%p current=%p" | |
324 | " cpu=%d\n", regs->gpr[0], r3, r4, r5, r6, r7, r8, regs, | |
325 | current, smp_processor_id()); | |
326 | } | |
327 | ||
328 | void do_show_syscall_exit(unsigned long r3) | |
329 | { | |
330 | printk(" -> %lx, current=%p cpu=%d\n", r3, current, smp_processor_id()); | |
331 | } |