aboutsummaryrefslogtreecommitdiffstats
path: root/arch/ppc/kernel/syscalls.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/ppc/kernel/syscalls.c')
-rw-r--r--arch/ppc/kernel/syscalls.c272
1 files changed, 272 insertions, 0 deletions
diff --git a/arch/ppc/kernel/syscalls.c b/arch/ppc/kernel/syscalls.c
new file mode 100644
index 000000000000..124313ce3c09
--- /dev/null
+++ b/arch/ppc/kernel/syscalls.c
@@ -0,0 +1,272 @@
1/*
2 * arch/ppc/kernel/sys_ppc.c
3 *
4 * PowerPC version
5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
6 *
7 * Derived from "arch/i386/kernel/sys_i386.c"
8 * Adapted from the i386 version by Gary Thomas
9 * Modified by Cort Dougan (cort@cs.nmt.edu)
10 * and Paul Mackerras (paulus@cs.anu.edu.au).
11 *
12 * This file contains various random system calls that
13 * have a non-standard calling sequence on the Linux/PPC
14 * platform.
15 *
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License
18 * as published by the Free Software Foundation; either version
19 * 2 of the License, or (at your option) any later version.
20 *
21 */
22
23#include <linux/errno.h>
24#include <linux/sched.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/syscalls.h>
33#include <linux/mman.h>
34#include <linux/sys.h>
35#include <linux/ipc.h>
36#include <linux/utsname.h>
37#include <linux/file.h>
38#include <linux/unistd.h>
39
40#include <asm/uaccess.h>
41#include <asm/ipc.h>
42#include <asm/semaphore.h>
43
44void
45check_bugs(void)
46{
47}
48
49/*
50 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
51 *
52 * This is really horribly ugly.
53 */
54int
55sys_ipc (uint call, int first, int second, int third, void __user *ptr, long fifth)
56{
57 int version, ret;
58
59 version = call >> 16; /* hack for backward compatibility */
60 call &= 0xffff;
61
62 ret = -ENOSYS;
63 switch (call) {
64 case SEMOP:
65 ret = sys_semtimedop (first, (struct sembuf __user *)ptr,
66 second, NULL);
67 break;
68 case SEMTIMEDOP:
69 ret = sys_semtimedop (first, (struct sembuf __user *)ptr,
70 second, (const struct timespec __user *) fifth);
71 break;
72 case SEMGET:
73 ret = sys_semget (first, second, third);
74 break;
75 case SEMCTL: {
76 union semun fourth;
77
78 if (!ptr)
79 break;
80 if ((ret = access_ok(VERIFY_READ, ptr, sizeof(long)) ? 0 : -EFAULT)
81 || (ret = get_user(fourth.__pad, (void __user *__user *)ptr)))
82 break;
83 ret = sys_semctl (first, second, third, fourth);
84 break;
85 }
86 case MSGSND:
87 ret = sys_msgsnd (first, (struct msgbuf __user *) ptr, second, third);
88 break;
89 case MSGRCV:
90 switch (version) {
91 case 0: {
92 struct ipc_kludge tmp;
93
94 if (!ptr)
95 break;
96 if ((ret = access_ok(VERIFY_READ, ptr, sizeof(tmp)) ? 0 : -EFAULT)
97 || (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, second, tmp.msgtyp,
102 third);
103 break;
104 }
105 default:
106 ret = sys_msgrcv (first, (struct msgbuf __user *) ptr,
107 second, fifth, third);
108 break;
109 }
110 break;
111 case MSGGET:
112 ret = sys_msgget ((key_t) first, second);
113 break;
114 case MSGCTL:
115 ret = sys_msgctl (first, second, (struct msqid_ds __user *) ptr);
116 break;
117 case SHMAT: {
118 ulong raddr;
119
120 if ((ret = access_ok(VERIFY_WRITE, (ulong __user *) third,
121 sizeof(ulong)) ? 0 : -EFAULT))
122 break;
123 ret = do_shmat (first, (char __user *) ptr, second, &raddr);
124 if (ret)
125 break;
126 ret = put_user (raddr, (ulong __user *) third);
127 break;
128 }
129 case SHMDT:
130 ret = sys_shmdt ((char __user *)ptr);
131 break;
132 case SHMGET:
133 ret = sys_shmget (first, second, third);
134 break;
135 case SHMCTL:
136 ret = sys_shmctl (first, second, (struct shmid_ds __user *) ptr);
137 break;
138 }
139
140 return ret;
141}
142
143/*
144 * sys_pipe() is the normal C calling standard for creating
145 * a pipe. It's not the way unix traditionally does this, though.
146 */
147int sys_pipe(int __user *fildes)
148{
149 int fd[2];
150 int error;
151
152 error = do_pipe(fd);
153 if (!error) {
154 if (copy_to_user(fildes, fd, 2*sizeof(int)))
155 error = -EFAULT;
156 }
157 return error;
158}
159
160static inline unsigned long
161do_mmap2(unsigned long addr, size_t len,
162 unsigned long prot, unsigned long flags,
163 unsigned long fd, unsigned long pgoff)
164{
165 struct file * file = NULL;
166 int ret = -EBADF;
167
168 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
169 if (!(flags & MAP_ANONYMOUS)) {
170 if (!(file = fget(fd)))
171 goto out;
172 }
173
174 down_write(&current->mm->mmap_sem);
175 ret = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
176 up_write(&current->mm->mmap_sem);
177 if (file)
178 fput(file);
179out:
180 return ret;
181}
182
183unsigned long sys_mmap2(unsigned long addr, size_t len,
184 unsigned long prot, unsigned long flags,
185 unsigned long fd, unsigned long pgoff)
186{
187 return do_mmap2(addr, len, prot, flags, fd, pgoff);
188}
189
190unsigned long sys_mmap(unsigned long addr, size_t len,
191 unsigned long prot, unsigned long flags,
192 unsigned long fd, off_t offset)
193{
194 int err = -EINVAL;
195
196 if (offset & ~PAGE_MASK)
197 goto out;
198
199 err = do_mmap2(addr, len, prot, flags, fd, offset >> PAGE_SHIFT);
200out:
201 return err;
202}
203
204/*
205 * Due to some executables calling the wrong select we sometimes
206 * get wrong args. This determines how the args are being passed
207 * (a single ptr to them all args passed) then calls
208 * sys_select() with the appropriate args. -- Cort
209 */
210int
211ppc_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp)
212{
213 if ( (unsigned long)n >= 4096 )
214 {
215 unsigned long __user *buffer = (unsigned long __user *)n;
216 if (!access_ok(VERIFY_READ, buffer, 5*sizeof(unsigned long))
217 || __get_user(n, buffer)
218 || __get_user(inp, ((fd_set __user * __user *)(buffer+1)))
219 || __get_user(outp, ((fd_set __user * __user *)(buffer+2)))
220 || __get_user(exp, ((fd_set __user * __user *)(buffer+3)))
221 || __get_user(tvp, ((struct timeval __user * __user *)(buffer+4))))
222 return -EFAULT;
223 }
224 return sys_select(n, inp, outp, exp, tvp);
225}
226
227int sys_uname(struct old_utsname __user * name)
228{
229 int err = -EFAULT;
230
231 down_read(&uts_sem);
232 if (name && !copy_to_user(name, &system_utsname, sizeof (*name)))
233 err = 0;
234 up_read(&uts_sem);
235 return err;
236}
237
238int sys_olduname(struct oldold_utsname __user * name)
239{
240 int error;
241
242 if (!name)
243 return -EFAULT;
244 if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
245 return -EFAULT;
246
247 down_read(&uts_sem);
248 error = __copy_to_user(&name->sysname,&system_utsname.sysname,__OLD_UTS_LEN);
249 error -= __put_user(0,name->sysname+__OLD_UTS_LEN);
250 error -= __copy_to_user(&name->nodename,&system_utsname.nodename,__OLD_UTS_LEN);
251 error -= __put_user(0,name->nodename+__OLD_UTS_LEN);
252 error -= __copy_to_user(&name->release,&system_utsname.release,__OLD_UTS_LEN);
253 error -= __put_user(0,name->release+__OLD_UTS_LEN);
254 error -= __copy_to_user(&name->version,&system_utsname.version,__OLD_UTS_LEN);
255 error -= __put_user(0,name->version+__OLD_UTS_LEN);
256 error -= __copy_to_user(&name->machine,&system_utsname.machine,__OLD_UTS_LEN);
257 error = __put_user(0,name->machine+__OLD_UTS_LEN);
258 up_read(&uts_sem);
259
260 error = error ? -EFAULT : 0;
261 return error;
262}
263
264/*
265 * We put the arguments in a different order so we only use 6
266 * registers for arguments, rather than 7 as sys_fadvise64_64 needs
267 * (because `offset' goes in r5/r6).
268 */
269long ppc_fadvise64_64(int fd, int advice, loff_t offset, loff_t len)
270{
271 return sys_fadvise64_64(fd, offset, len, advice);
272}
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-04 16:16:53 -0500