Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6
[linux-2.6] / arch / sh64 / kernel / sys_sh64.c
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  * arch/sh64/kernel/sys_sh64.c
7  *
8  * Copyright (C) 2000, 2001  Paolo Alberelli
9  *
10  * This file contains various random system calls that
11  * have a non-standard calling sequence on the Linux/SH5
12  * platform.
13  *
14  * Mostly taken from i386 version.
15  *
16  */
17
18 #include <linux/errno.h>
19 #include <linux/rwsem.h>
20 #include <linux/sched.h>
21 #include <linux/mm.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/sem.h>
25 #include <linux/msg.h>
26 #include <linux/shm.h>
27 #include <linux/stat.h>
28 #include <linux/mman.h>
29 #include <linux/file.h>
30 #include <linux/utsname.h>
31 #include <linux/syscalls.h>
32 #include <asm/uaccess.h>
33 #include <asm/ipc.h>
34 #include <asm/ptrace.h>
35 #include <asm/unistd.h>
36
37 #define REG_3   3
38
39 /*
40  * sys_pipe() is the normal C calling standard for creating
41  * a pipe. It's not the way Unix traditionally does this, though.
42  */
43 #ifdef NEW_PIPE_IMPLEMENTATION
44 asmlinkage int sys_pipe(unsigned long * fildes,
45                         unsigned long   dummy_r3,
46                         unsigned long   dummy_r4,
47                         unsigned long   dummy_r5,
48                         unsigned long   dummy_r6,
49                         unsigned long   dummy_r7,
50                         struct pt_regs * regs)     /* r8 = pt_regs  forced by entry.S */
51 {
52         int fd[2];
53         int ret;
54
55         ret = do_pipe(fd);
56         if (ret == 0)
57                 /*
58                  ***********************************************************************
59                  *   To avoid the copy_to_user we prefer to break the ABIs convention, *
60                  *   packing the valid pair of file IDs into a single register (r3);   *
61                  *   while r2 is the return code as defined by the sh5-ABIs.           *
62                  *   BE CAREFUL: pipe stub, into glibc, must be aware of this solution *
63                  ***********************************************************************
64
65 #ifdef __LITTLE_ENDIAN__
66                 regs->regs[REG_3] = (((unsigned long long) fd[1]) << 32) | ((unsigned long long) fd[0]);
67 #else
68                 regs->regs[REG_3] = (((unsigned long long) fd[0]) << 32) | ((unsigned long long) fd[1]);
69 #endif
70
71                 */
72                /* although not very clever this is endianess independent */
73                 regs->regs[REG_3] = (unsigned long long) *((unsigned long long *) fd);
74
75         return ret;
76 }
77
78 #else
79 asmlinkage int sys_pipe(unsigned long * fildes)
80 {
81         int fd[2];
82         int error;
83
84         error = do_pipe(fd);
85         if (!error) {
86                 if (copy_to_user(fildes, fd, 2*sizeof(int)))
87                         error = -EFAULT;
88         }
89         return error;
90 }
91
92 #endif
93
94 /*
95  * To avoid cache alias, we map the shard page with same color.
96  */
97 #define COLOUR_ALIGN(addr)      (((addr)+SHMLBA-1)&~(SHMLBA-1))
98
99 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
100         unsigned long len, unsigned long pgoff, unsigned long flags)
101 {
102         struct vm_area_struct *vma;
103
104         if (flags & MAP_FIXED) {
105                 /* We do not accept a shared mapping if it would violate
106                  * cache aliasing constraints.
107                  */
108                 if ((flags & MAP_SHARED) && (addr & (SHMLBA - 1)))
109                         return -EINVAL;
110                 return addr;
111         }
112
113         if (len > TASK_SIZE)
114                 return -ENOMEM;
115         if (!addr)
116                 addr = TASK_UNMAPPED_BASE;
117
118         if (flags & MAP_PRIVATE)
119                 addr = PAGE_ALIGN(addr);
120         else
121                 addr = COLOUR_ALIGN(addr);
122
123         for (vma = find_vma(current->mm, addr); ; vma = vma->vm_next) {
124                 /* At this point:  (!vma || addr < vma->vm_end). */
125                 if (TASK_SIZE - len < addr)
126                         return -ENOMEM;
127                 if (!vma || addr + len <= vma->vm_start)
128                         return addr;
129                 addr = vma->vm_end;
130                 if (!(flags & MAP_PRIVATE))
131                         addr = COLOUR_ALIGN(addr);
132         }
133 }
134
135 /* common code for old and new mmaps */
136 static inline long do_mmap2(
137         unsigned long addr, unsigned long len,
138         unsigned long prot, unsigned long flags,
139         unsigned long fd, unsigned long pgoff)
140 {
141         int error = -EBADF;
142         struct file * file = NULL;
143
144         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
145         if (!(flags & MAP_ANONYMOUS)) {
146                 file = fget(fd);
147                 if (!file)
148                         goto out;
149         }
150
151         down_write(&current->mm->mmap_sem);
152         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
153         up_write(&current->mm->mmap_sem);
154
155         if (file)
156                 fput(file);
157 out:
158         return error;
159 }
160
161 asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
162         unsigned long prot, unsigned long flags,
163         unsigned long fd, unsigned long pgoff)
164 {
165         return do_mmap2(addr, len, prot, flags, fd, pgoff);
166 }
167
168 asmlinkage int old_mmap(unsigned long addr, unsigned long len,
169         unsigned long prot, unsigned long flags,
170         int fd, unsigned long off)
171 {
172         if (off & ~PAGE_MASK)
173                 return -EINVAL;
174         return do_mmap2(addr, len, prot, flags, fd, off>>PAGE_SHIFT);
175 }
176
177 /*
178  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
179  *
180  * This is really horribly ugly.
181  */
182 asmlinkage int sys_ipc(uint call, int first, int second,
183                        int third, void __user *ptr, long fifth)
184 {
185         int version, ret;
186
187         version = call >> 16; /* hack for backward compatibility */
188         call &= 0xffff;
189
190         if (call <= SEMCTL)
191                 switch (call) {
192                 case SEMOP:
193                         return sys_semtimedop(first, (struct sembuf __user *)ptr,
194                                               second, NULL);
195                 case SEMTIMEDOP:
196                         return sys_semtimedop(first, (struct sembuf __user *)ptr,
197                                               second,
198                                               (const struct timespec __user *)fifth);
199                 case SEMGET:
200                         return sys_semget (first, second, third);
201                 case SEMCTL: {
202                         union semun fourth;
203                         if (!ptr)
204                                 return -EINVAL;
205                         if (get_user(fourth.__pad, (void * __user *) ptr))
206                                 return -EFAULT;
207                         return sys_semctl (first, second, third, fourth);
208                         }
209                 default:
210                         return -EINVAL;
211                 }
212
213         if (call <= MSGCTL)
214                 switch (call) {
215                 case MSGSND:
216                         return sys_msgsnd (first, (struct msgbuf __user *) ptr,
217                                           second, third);
218                 case MSGRCV:
219                         switch (version) {
220                         case 0: {
221                                 struct ipc_kludge tmp;
222                                 if (!ptr)
223                                         return -EINVAL;
224
225                                 if (copy_from_user(&tmp,
226                                                    (struct ipc_kludge __user *) ptr,
227                                                    sizeof (tmp)))
228                                         return -EFAULT;
229                                 return sys_msgrcv (first, tmp.msgp, second,
230                                                    tmp.msgtyp, third);
231                                 }
232                         default:
233                                 return sys_msgrcv (first,
234                                                    (struct msgbuf __user *) ptr,
235                                                    second, fifth, third);
236                         }
237                 case MSGGET:
238                         return sys_msgget ((key_t) first, second);
239                 case MSGCTL:
240                         return sys_msgctl (first, second,
241                                            (struct msqid_ds __user *) ptr);
242                 default:
243                         return -EINVAL;
244                 }
245         if (call <= SHMCTL)
246                 switch (call) {
247                 case SHMAT:
248                         switch (version) {
249                         default: {
250                                 ulong raddr;
251                                 ret = do_shmat (first, (char __user *) ptr,
252                                                  second, &raddr);
253                                 if (ret)
254                                         return ret;
255                                 return put_user (raddr, (ulong __user *) third);
256                         }
257                         case 1: /* iBCS2 emulator entry point */
258                                 if (!segment_eq(get_fs(), get_ds()))
259                                         return -EINVAL;
260                                 return do_shmat (first, (char __user *) ptr,
261                                                   second, (ulong *) third);
262                         }
263                 case SHMDT:
264                         return sys_shmdt ((char __user *)ptr);
265                 case SHMGET:
266                         return sys_shmget (first, second, third);
267                 case SHMCTL:
268                         return sys_shmctl (first, second,
269                                            (struct shmid_ds __user *) ptr);
270                 default:
271                         return -EINVAL;
272                 }
273
274         return -EINVAL;
275 }
276
277 asmlinkage int sys_uname(struct old_utsname * name)
278 {
279         int err;
280         if (!name)
281                 return -EFAULT;
282         down_read(&uts_sem);
283         err = copy_to_user(name, utsname(), sizeof (*name));
284         up_read(&uts_sem);
285         return err?-EFAULT:0;
286 }
287
288 /*
289  * Do a system call from kernel instead of calling sys_execve so we
290  * end up with proper pt_regs.
291  */
292 int kernel_execve(const char *filename, char *const argv[], char *const envp[])
293 {
294         register unsigned long __sc0 __asm__ ("r9") = ((0x13 << 16) | __NR_execve);
295         register unsigned long __sc2 __asm__ ("r2") = (unsigned long) filename;
296         register unsigned long __sc3 __asm__ ("r3") = (unsigned long) argv;
297         register unsigned long __sc4 __asm__ ("r4") = (unsigned long) envp;
298         __asm__ __volatile__ ("trapa    %1 !\t\t\t execve(%2,%3,%4)"
299         : "=r" (__sc0)
300         : "r" (__sc0), "r" (__sc2), "r" (__sc3), "r" (__sc4) );
301         __asm__ __volatile__ ("!dummy   %0 %1 %2 %3"
302         : : "r" (__sc0), "r" (__sc2), "r" (__sc3), "r" (__sc4) : "memory");
303         return __sc0;
304 }