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> | |
4e950f6f | 26 | #include <linux/fs.h> |
1da177e4 | 27 | #include <linux/smp.h> |
1da177e4 LT |
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> | |
a7f31841 | 41 | #include <asm/syscalls.h> |
1da177e4 LT |
42 | #include <asm/time.h> |
43 | #include <asm/unistd.h> | |
44 | ||
1da177e4 LT |
45 | /* |
46 | * sys_ipc() is the de-multiplexer for the SysV IPC calls.. | |
47 | * | |
48 | * This is really horribly ugly. | |
49 | */ | |
30286ef6 PM |
50 | int sys_ipc(uint call, int first, unsigned long second, long third, |
51 | void __user *ptr, long fifth) | |
1da177e4 LT |
52 | { |
53 | int version, ret; | |
54 | ||
55 | version = call >> 16; /* hack for backward compatibility */ | |
56 | call &= 0xffff; | |
57 | ||
58 | ret = -ENOSYS; | |
59 | switch (call) { | |
60 | case SEMOP: | |
61 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, | |
62 | (unsigned)second, NULL); | |
63 | break; | |
64 | case SEMTIMEDOP: | |
65 | ret = sys_semtimedop(first, (struct sembuf __user *)ptr, | |
66 | (unsigned)second, | |
67 | (const struct timespec __user *) fifth); | |
68 | break; | |
69 | case SEMGET: | |
70 | ret = sys_semget (first, (int)second, third); | |
71 | break; | |
72 | case SEMCTL: { | |
73 | union semun fourth; | |
74 | ||
75 | ret = -EINVAL; | |
76 | if (!ptr) | |
77 | break; | |
78 | if ((ret = get_user(fourth.__pad, (void __user * __user *)ptr))) | |
79 | break; | |
80 | ret = sys_semctl(first, (int)second, third, fourth); | |
81 | break; | |
82 | } | |
83 | case MSGSND: | |
84 | ret = sys_msgsnd(first, (struct msgbuf __user *)ptr, | |
30286ef6 | 85 | (size_t)second, third); |
1da177e4 LT |
86 | break; |
87 | case MSGRCV: | |
88 | switch (version) { | |
89 | case 0: { | |
90 | struct ipc_kludge tmp; | |
91 | ||
92 | ret = -EINVAL; | |
93 | if (!ptr) | |
94 | break; | |
95 | if ((ret = copy_from_user(&tmp, | |
96 | (struct ipc_kludge __user *) ptr, | |
97 | sizeof (tmp)) ? -EFAULT : 0)) | |
98 | break; | |
99 | ret = sys_msgrcv(first, tmp.msgp, (size_t) second, | |
100 | tmp.msgtyp, third); | |
101 | break; | |
102 | } | |
103 | default: | |
104 | ret = sys_msgrcv (first, (struct msgbuf __user *) ptr, | |
105 | (size_t)second, fifth, third); | |
106 | break; | |
107 | } | |
108 | break; | |
109 | case MSGGET: | |
30286ef6 | 110 | ret = sys_msgget((key_t)first, (int)second); |
1da177e4 LT |
111 | break; |
112 | case MSGCTL: | |
113 | ret = sys_msgctl(first, (int)second, | |
114 | (struct msqid_ds __user *)ptr); | |
115 | break; | |
30286ef6 PM |
116 | case SHMAT: { |
117 | ulong raddr; | |
118 | ret = do_shmat(first, (char __user *)ptr, (int)second, &raddr); | |
119 | if (ret) | |
1da177e4 | 120 | break; |
30286ef6 | 121 | ret = put_user(raddr, (ulong __user *) third); |
1da177e4 | 122 | break; |
30286ef6 PM |
123 | } |
124 | case SHMDT: | |
125 | ret = sys_shmdt((char __user *)ptr); | |
1da177e4 LT |
126 | break; |
127 | case SHMGET: | |
30286ef6 | 128 | ret = sys_shmget(first, (size_t)second, third); |
1da177e4 LT |
129 | break; |
130 | case SHMCTL: | |
131 | ret = sys_shmctl(first, (int)second, | |
30286ef6 | 132 | (struct shmid_ds __user *)ptr); |
1da177e4 LT |
133 | break; |
134 | } | |
135 | ||
136 | return ret; | |
137 | } | |
138 | ||
30286ef6 PM |
139 | static inline unsigned long do_mmap2(unsigned long addr, size_t len, |
140 | unsigned long prot, unsigned long flags, | |
141 | unsigned long fd, unsigned long off, int shift) | |
1da177e4 LT |
142 | { |
143 | struct file * file = NULL; | |
05d84681 | 144 | unsigned long ret = -EINVAL; |
1da177e4 | 145 | |
30286ef6 PM |
146 | if (shift) { |
147 | if (off & ((1 << shift) - 1)) | |
148 | goto out; | |
149 | off >>= shift; | |
150 | } | |
151 | ||
152 | ret = -EBADF; | |
1da177e4 LT |
153 | if (!(flags & MAP_ANONYMOUS)) { |
154 | if (!(file = fget(fd))) | |
155 | goto out; | |
156 | } | |
157 | ||
158 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); | |
30286ef6 | 159 | |
1da177e4 | 160 | down_write(¤t->mm->mmap_sem); |
30286ef6 | 161 | ret = do_mmap_pgoff(file, addr, len, prot, flags, off); |
1da177e4 LT |
162 | up_write(¤t->mm->mmap_sem); |
163 | if (file) | |
164 | fput(file); | |
1da177e4 LT |
165 | out: |
166 | return ret; | |
167 | } | |
168 | ||
30286ef6 PM |
169 | unsigned long sys_mmap2(unsigned long addr, size_t len, |
170 | unsigned long prot, unsigned long flags, | |
171 | unsigned long fd, unsigned long pgoff) | |
172 | { | |
173 | return do_mmap2(addr, len, prot, flags, fd, pgoff, PAGE_SHIFT-12); | |
174 | } | |
175 | ||
176 | unsigned long sys_mmap(unsigned long addr, size_t len, | |
177 | unsigned long prot, unsigned long flags, | |
178 | unsigned long fd, off_t offset) | |
179 | { | |
180 | return do_mmap2(addr, len, prot, flags, fd, offset, PAGE_SHIFT); | |
181 | } | |
182 | ||
183 | #ifdef CONFIG_PPC32 | |
184 | /* | |
185 | * Due to some executables calling the wrong select we sometimes | |
186 | * get wrong args. This determines how the args are being passed | |
187 | * (a single ptr to them all args passed) then calls | |
188 | * sys_select() with the appropriate args. -- Cort | |
189 | */ | |
190 | int | |
191 | ppc_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp) | |
192 | { | |
193 | if ( (unsigned long)n >= 4096 ) | |
194 | { | |
195 | unsigned long __user *buffer = (unsigned long __user *)n; | |
196 | if (!access_ok(VERIFY_READ, buffer, 5*sizeof(unsigned long)) | |
197 | || __get_user(n, buffer) | |
198 | || __get_user(inp, ((fd_set __user * __user *)(buffer+1))) | |
199 | || __get_user(outp, ((fd_set __user * __user *)(buffer+2))) | |
200 | || __get_user(exp, ((fd_set __user * __user *)(buffer+3))) | |
201 | || __get_user(tvp, ((struct timeval __user * __user *)(buffer+4)))) | |
202 | return -EFAULT; | |
203 | } | |
204 | return sys_select(n, inp, outp, exp, tvp); | |
205 | } | |
206 | #endif | |
207 | ||
208 | #ifdef CONFIG_PPC64 | |
ce10d979 | 209 | long ppc64_personality(unsigned long personality) |
1da177e4 | 210 | { |
ce10d979 PM |
211 | long ret; |
212 | ||
213 | if (personality(current->personality) == PER_LINUX32 | |
214 | && personality == PER_LINUX) | |
215 | personality = PER_LINUX32; | |
216 | ret = sys_personality(personality); | |
217 | if (ret == PER_LINUX32) | |
218 | ret = PER_LINUX; | |
219 | return ret; | |
1da177e4 | 220 | } |
30286ef6 PM |
221 | #endif |
222 | ||
223 | #ifdef CONFIG_PPC64 | |
224 | #define OVERRIDE_MACHINE (personality(current->personality) == PER_LINUX32) | |
225 | #else | |
226 | #define OVERRIDE_MACHINE 0 | |
227 | #endif | |
1da177e4 | 228 | |
ebbd1bce | 229 | static inline int override_machine(char __user *mach) |
30286ef6 PM |
230 | { |
231 | if (OVERRIDE_MACHINE) { | |
232 | /* change ppc64 to ppc */ | |
233 | if (__put_user(0, mach+3) || __put_user(0, mach+4)) | |
234 | return -EFAULT; | |
235 | } | |
236 | return 0; | |
237 | } | |
238 | ||
239 | long ppc_newuname(struct new_utsname __user * name) | |
1da177e4 | 240 | { |
ce10d979 PM |
241 | int err = 0; |
242 | ||
1da177e4 | 243 | down_read(&uts_sem); |
e9ff3990 | 244 | if (copy_to_user(name, utsname(), sizeof(*name))) |
ce10d979 | 245 | err = -EFAULT; |
1da177e4 | 246 | up_read(&uts_sem); |
30286ef6 PM |
247 | if (!err) |
248 | err = override_machine(name->machine); | |
1da177e4 LT |
249 | return err; |
250 | } | |
251 | ||
30286ef6 PM |
252 | int sys_uname(struct old_utsname __user *name) |
253 | { | |
254 | int err = 0; | |
255 | ||
256 | down_read(&uts_sem); | |
e9ff3990 | 257 | if (copy_to_user(name, utsname(), sizeof(*name))) |
30286ef6 PM |
258 | err = -EFAULT; |
259 | up_read(&uts_sem); | |
260 | if (!err) | |
261 | err = override_machine(name->machine); | |
262 | return err; | |
263 | } | |
264 | ||
265 | int sys_olduname(struct oldold_utsname __user *name) | |
266 | { | |
267 | int error; | |
268 | ||
269 | if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname))) | |
270 | return -EFAULT; | |
271 | ||
272 | down_read(&uts_sem); | |
e9ff3990 | 273 | error = __copy_to_user(&name->sysname, &utsname()->sysname, |
30286ef6 PM |
274 | __OLD_UTS_LEN); |
275 | error |= __put_user(0, name->sysname + __OLD_UTS_LEN); | |
e9ff3990 | 276 | error |= __copy_to_user(&name->nodename, &utsname()->nodename, |
30286ef6 PM |
277 | __OLD_UTS_LEN); |
278 | error |= __put_user(0, name->nodename + __OLD_UTS_LEN); | |
e9ff3990 | 279 | error |= __copy_to_user(&name->release, &utsname()->release, |
30286ef6 PM |
280 | __OLD_UTS_LEN); |
281 | error |= __put_user(0, name->release + __OLD_UTS_LEN); | |
e9ff3990 | 282 | error |= __copy_to_user(&name->version, &utsname()->version, |
30286ef6 PM |
283 | __OLD_UTS_LEN); |
284 | error |= __put_user(0, name->version + __OLD_UTS_LEN); | |
e9ff3990 | 285 | error |= __copy_to_user(&name->machine, &utsname()->machine, |
30286ef6 PM |
286 | __OLD_UTS_LEN); |
287 | error |= override_machine(name->machine); | |
288 | up_read(&uts_sem); | |
289 | ||
290 | return error? -EFAULT: 0; | |
291 | } | |
292 | ||
77f543cb PM |
293 | long ppc_fadvise64_64(int fd, int advice, u32 offset_high, u32 offset_low, |
294 | u32 len_high, u32 len_low) | |
295 | { | |
296 | return sys_fadvise64(fd, (u64)offset_high << 32 | offset_low, | |
297 | (u64)len_high << 32 | len_low, advice); | |
298 | } | |
299 | ||
1da177e4 LT |
300 | void do_show_syscall(unsigned long r3, unsigned long r4, unsigned long r5, |
301 | unsigned long r6, unsigned long r7, unsigned long r8, | |
302 | struct pt_regs *regs) | |
303 | { | |
304 | printk("syscall %ld(%lx, %lx, %lx, %lx, %lx, %lx) regs=%p current=%p" | |
305 | " cpu=%d\n", regs->gpr[0], r3, r4, r5, r6, r7, r8, regs, | |
306 | current, smp_processor_id()); | |
307 | } | |
308 | ||
309 | void do_show_syscall_exit(unsigned long r3) | |
310 | { | |
311 | printk(" -> %lx, current=%p cpu=%d\n", r3, current, smp_processor_id()); | |
312 | } |