Merge branch 'upstream' of git://ftp.linux-mips.org/pub/scm/upstream-linus
[linux-2.6] / arch / m68k / kernel / sys_m68k.c
1 /*
2  * linux/arch/m68k/kernel/sys_m68k.c
3  *
4  * This file contains various random system calls that
5  * have a non-standard calling sequence on the Linux/m68k
6  * platform.
7  */
8
9 #include <linux/capability.h>
10 #include <linux/errno.h>
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/fs.h>
14 #include <linux/smp.h>
15 #include <linux/smp_lock.h>
16 #include <linux/sem.h>
17 #include <linux/msg.h>
18 #include <linux/shm.h>
19 #include <linux/stat.h>
20 #include <linux/syscalls.h>
21 #include <linux/mman.h>
22 #include <linux/file.h>
23 #include <linux/utsname.h>
24 #include <linux/ipc.h>
25
26 #include <asm/setup.h>
27 #include <asm/uaccess.h>
28 #include <asm/cachectl.h>
29 #include <asm/traps.h>
30 #include <asm/page.h>
31 #include <asm/unistd.h>
32
33 /* common code for old and new mmaps */
34 static inline long do_mmap2(
35         unsigned long addr, unsigned long len,
36         unsigned long prot, unsigned long flags,
37         unsigned long fd, unsigned long pgoff)
38 {
39         int error = -EBADF;
40         struct file * file = NULL;
41
42         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
43         if (!(flags & MAP_ANONYMOUS)) {
44                 file = fget(fd);
45                 if (!file)
46                         goto out;
47         }
48
49         down_write(&current->mm->mmap_sem);
50         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
51         up_write(&current->mm->mmap_sem);
52
53         if (file)
54                 fput(file);
55 out:
56         return error;
57 }
58
59 asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
60         unsigned long prot, unsigned long flags,
61         unsigned long fd, unsigned long pgoff)
62 {
63         return do_mmap2(addr, len, prot, flags, fd, pgoff);
64 }
65
66 /*
67  * Perform the select(nd, in, out, ex, tv) and mmap() system
68  * calls. Linux/m68k cloned Linux/i386, which didn't use to be able to
69  * handle more than 4 system call parameters, so these system calls
70  * used a memory block for parameter passing..
71  */
72
73 struct mmap_arg_struct {
74         unsigned long addr;
75         unsigned long len;
76         unsigned long prot;
77         unsigned long flags;
78         unsigned long fd;
79         unsigned long offset;
80 };
81
82 asmlinkage int old_mmap(struct mmap_arg_struct __user *arg)
83 {
84         struct mmap_arg_struct a;
85         int error = -EFAULT;
86
87         if (copy_from_user(&a, arg, sizeof(a)))
88                 goto out;
89
90         error = -EINVAL;
91         if (a.offset & ~PAGE_MASK)
92                 goto out;
93
94         a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
95
96         error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT);
97 out:
98         return error;
99 }
100
101 #if 0
102 struct mmap_arg_struct64 {
103         __u32 addr;
104         __u32 len;
105         __u32 prot;
106         __u32 flags;
107         __u64 offset; /* 64 bits */
108         __u32 fd;
109 };
110
111 asmlinkage long sys_mmap64(struct mmap_arg_struct64 *arg)
112 {
113         int error = -EFAULT;
114         struct file * file = NULL;
115         struct mmap_arg_struct64 a;
116         unsigned long pgoff;
117
118         if (copy_from_user(&a, arg, sizeof(a)))
119                 return -EFAULT;
120
121         if ((long)a.offset & ~PAGE_MASK)
122                 return -EINVAL;
123
124         pgoff = a.offset >> PAGE_SHIFT;
125         if ((a.offset >> PAGE_SHIFT) != pgoff)
126                 return -EINVAL;
127
128         if (!(a.flags & MAP_ANONYMOUS)) {
129                 error = -EBADF;
130                 file = fget(a.fd);
131                 if (!file)
132                         goto out;
133         }
134         a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
135
136         down_write(&current->mm->mmap_sem);
137         error = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags, pgoff);
138         up_write(&current->mm->mmap_sem);
139         if (file)
140                 fput(file);
141 out:
142         return error;
143 }
144 #endif
145
146 struct sel_arg_struct {
147         unsigned long n;
148         fd_set __user *inp, *outp, *exp;
149         struct timeval __user *tvp;
150 };
151
152 asmlinkage int old_select(struct sel_arg_struct __user *arg)
153 {
154         struct sel_arg_struct a;
155
156         if (copy_from_user(&a, arg, sizeof(a)))
157                 return -EFAULT;
158         /* sys_select() does the appropriate kernel locking */
159         return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
160 }
161
162 /*
163  * sys_ipc() is the de-multiplexer for the SysV IPC calls..
164  *
165  * This is really horribly ugly.
166  */
167 asmlinkage int sys_ipc (uint call, int first, int second,
168                         int third, void __user *ptr, long fifth)
169 {
170         int version, ret;
171
172         version = call >> 16; /* hack for backward compatibility */
173         call &= 0xffff;
174
175         if (call <= SEMCTL)
176                 switch (call) {
177                 case SEMOP:
178                         return sys_semop (first, ptr, second);
179                 case SEMGET:
180                         return sys_semget (first, second, third);
181                 case SEMCTL: {
182                         union semun fourth;
183                         if (!ptr)
184                                 return -EINVAL;
185                         if (get_user(fourth.__pad, (void __user *__user *) ptr))
186                                 return -EFAULT;
187                         return sys_semctl (first, second, third, fourth);
188                         }
189                 default:
190                         return -ENOSYS;
191                 }
192         if (call <= MSGCTL)
193                 switch (call) {
194                 case MSGSND:
195                         return sys_msgsnd (first, ptr, second, third);
196                 case MSGRCV:
197                         switch (version) {
198                         case 0: {
199                                 struct ipc_kludge tmp;
200                                 if (!ptr)
201                                         return -EINVAL;
202                                 if (copy_from_user (&tmp, ptr, sizeof (tmp)))
203                                         return -EFAULT;
204                                 return sys_msgrcv (first, tmp.msgp, second,
205                                                    tmp.msgtyp, third);
206                                 }
207                         default:
208                                 return sys_msgrcv (first, ptr,
209                                                    second, fifth, third);
210                         }
211                 case MSGGET:
212                         return sys_msgget ((key_t) first, second);
213                 case MSGCTL:
214                         return sys_msgctl (first, second, ptr);
215                 default:
216                         return -ENOSYS;
217                 }
218         if (call <= SHMCTL)
219                 switch (call) {
220                 case SHMAT:
221                         switch (version) {
222                         default: {
223                                 ulong raddr;
224                                 ret = do_shmat (first, ptr, second, &raddr);
225                                 if (ret)
226                                         return ret;
227                                 return put_user (raddr, (ulong __user *) third);
228                         }
229                         }
230                 case SHMDT:
231                         return sys_shmdt (ptr);
232                 case SHMGET:
233                         return sys_shmget (first, second, third);
234                 case SHMCTL:
235                         return sys_shmctl (first, second, ptr);
236                 default:
237                         return -ENOSYS;
238                 }
239
240         return -EINVAL;
241 }
242
243 /* Convert virtual (user) address VADDR to physical address PADDR */
244 #define virt_to_phys_040(vaddr)                                         \
245 ({                                                                      \
246   unsigned long _mmusr, _paddr;                                         \
247                                                                         \
248   __asm__ __volatile__ (".chip 68040\n\t"                               \
249                         "ptestr (%1)\n\t"                               \
250                         "movec %%mmusr,%0\n\t"                          \
251                         ".chip 68k"                                     \
252                         : "=r" (_mmusr)                                 \
253                         : "a" (vaddr));                                 \
254   _paddr = (_mmusr & MMU_R_040) ? (_mmusr & PAGE_MASK) : 0;             \
255   _paddr;                                                               \
256 })
257
258 static inline int
259 cache_flush_040 (unsigned long addr, int scope, int cache, unsigned long len)
260 {
261   unsigned long paddr, i;
262
263   switch (scope)
264     {
265     case FLUSH_SCOPE_ALL:
266       switch (cache)
267         {
268         case FLUSH_CACHE_DATA:
269           /* This nop is needed for some broken versions of the 68040.  */
270           __asm__ __volatile__ ("nop\n\t"
271                                 ".chip 68040\n\t"
272                                 "cpusha %dc\n\t"
273                                 ".chip 68k");
274           break;
275         case FLUSH_CACHE_INSN:
276           __asm__ __volatile__ ("nop\n\t"
277                                 ".chip 68040\n\t"
278                                 "cpusha %ic\n\t"
279                                 ".chip 68k");
280           break;
281         default:
282         case FLUSH_CACHE_BOTH:
283           __asm__ __volatile__ ("nop\n\t"
284                                 ".chip 68040\n\t"
285                                 "cpusha %bc\n\t"
286                                 ".chip 68k");
287           break;
288         }
289       break;
290
291     case FLUSH_SCOPE_LINE:
292       /* Find the physical address of the first mapped page in the
293          address range.  */
294       if ((paddr = virt_to_phys_040(addr))) {
295         paddr += addr & ~(PAGE_MASK | 15);
296         len = (len + (addr & 15) + 15) >> 4;
297       } else {
298         unsigned long tmp = PAGE_SIZE - (addr & ~PAGE_MASK);
299
300         if (len <= tmp)
301           return 0;
302         addr += tmp;
303         len -= tmp;
304         tmp = PAGE_SIZE;
305         for (;;)
306           {
307             if ((paddr = virt_to_phys_040(addr)))
308               break;
309             if (len <= tmp)
310               return 0;
311             addr += tmp;
312             len -= tmp;
313           }
314         len = (len + 15) >> 4;
315       }
316       i = (PAGE_SIZE - (paddr & ~PAGE_MASK)) >> 4;
317       while (len--)
318         {
319           switch (cache)
320             {
321             case FLUSH_CACHE_DATA:
322               __asm__ __volatile__ ("nop\n\t"
323                                     ".chip 68040\n\t"
324                                     "cpushl %%dc,(%0)\n\t"
325                                     ".chip 68k"
326                                     : : "a" (paddr));
327               break;
328             case FLUSH_CACHE_INSN:
329               __asm__ __volatile__ ("nop\n\t"
330                                     ".chip 68040\n\t"
331                                     "cpushl %%ic,(%0)\n\t"
332                                     ".chip 68k"
333                                     : : "a" (paddr));
334               break;
335             default:
336             case FLUSH_CACHE_BOTH:
337               __asm__ __volatile__ ("nop\n\t"
338                                     ".chip 68040\n\t"
339                                     "cpushl %%bc,(%0)\n\t"
340                                     ".chip 68k"
341                                     : : "a" (paddr));
342               break;
343             }
344           if (!--i && len)
345             {
346               /*
347                * No need to page align here since it is done by
348                * virt_to_phys_040().
349                */
350               addr += PAGE_SIZE;
351               i = PAGE_SIZE / 16;
352               /* Recompute physical address when crossing a page
353                  boundary. */
354               for (;;)
355                 {
356                   if ((paddr = virt_to_phys_040(addr)))
357                     break;
358                   if (len <= i)
359                     return 0;
360                   len -= i;
361                   addr += PAGE_SIZE;
362                 }
363             }
364           else
365             paddr += 16;
366         }
367       break;
368
369     default:
370     case FLUSH_SCOPE_PAGE:
371       len += (addr & ~PAGE_MASK) + (PAGE_SIZE - 1);
372       for (len >>= PAGE_SHIFT; len--; addr += PAGE_SIZE)
373         {
374           if (!(paddr = virt_to_phys_040(addr)))
375             continue;
376           switch (cache)
377             {
378             case FLUSH_CACHE_DATA:
379               __asm__ __volatile__ ("nop\n\t"
380                                     ".chip 68040\n\t"
381                                     "cpushp %%dc,(%0)\n\t"
382                                     ".chip 68k"
383                                     : : "a" (paddr));
384               break;
385             case FLUSH_CACHE_INSN:
386               __asm__ __volatile__ ("nop\n\t"
387                                     ".chip 68040\n\t"
388                                     "cpushp %%ic,(%0)\n\t"
389                                     ".chip 68k"
390                                     : : "a" (paddr));
391               break;
392             default:
393             case FLUSH_CACHE_BOTH:
394               __asm__ __volatile__ ("nop\n\t"
395                                     ".chip 68040\n\t"
396                                     "cpushp %%bc,(%0)\n\t"
397                                     ".chip 68k"
398                                     : : "a" (paddr));
399               break;
400             }
401         }
402       break;
403     }
404   return 0;
405 }
406
407 #define virt_to_phys_060(vaddr)                         \
408 ({                                                      \
409   unsigned long paddr;                                  \
410   __asm__ __volatile__ (".chip 68060\n\t"               \
411                         "plpar (%0)\n\t"                \
412                         ".chip 68k"                     \
413                         : "=a" (paddr)                  \
414                         : "0" (vaddr));                 \
415   (paddr); /* XXX */                                    \
416 })
417
418 static inline int
419 cache_flush_060 (unsigned long addr, int scope, int cache, unsigned long len)
420 {
421   unsigned long paddr, i;
422
423   /*
424    * 68060 manual says:
425    *  cpush %dc : flush DC, remains valid (with our %cacr setup)
426    *  cpush %ic : invalidate IC
427    *  cpush %bc : flush DC + invalidate IC
428    */
429   switch (scope)
430     {
431     case FLUSH_SCOPE_ALL:
432       switch (cache)
433         {
434         case FLUSH_CACHE_DATA:
435           __asm__ __volatile__ (".chip 68060\n\t"
436                                 "cpusha %dc\n\t"
437                                 ".chip 68k");
438           break;
439         case FLUSH_CACHE_INSN:
440           __asm__ __volatile__ (".chip 68060\n\t"
441                                 "cpusha %ic\n\t"
442                                 ".chip 68k");
443           break;
444         default:
445         case FLUSH_CACHE_BOTH:
446           __asm__ __volatile__ (".chip 68060\n\t"
447                                 "cpusha %bc\n\t"
448                                 ".chip 68k");
449           break;
450         }
451       break;
452
453     case FLUSH_SCOPE_LINE:
454       /* Find the physical address of the first mapped page in the
455          address range.  */
456       len += addr & 15;
457       addr &= -16;
458       if (!(paddr = virt_to_phys_060(addr))) {
459         unsigned long tmp = PAGE_SIZE - (addr & ~PAGE_MASK);
460
461         if (len <= tmp)
462           return 0;
463         addr += tmp;
464         len -= tmp;
465         tmp = PAGE_SIZE;
466         for (;;)
467           {
468             if ((paddr = virt_to_phys_060(addr)))
469               break;
470             if (len <= tmp)
471               return 0;
472             addr += tmp;
473             len -= tmp;
474           }
475       }
476       len = (len + 15) >> 4;
477       i = (PAGE_SIZE - (paddr & ~PAGE_MASK)) >> 4;
478       while (len--)
479         {
480           switch (cache)
481             {
482             case FLUSH_CACHE_DATA:
483               __asm__ __volatile__ (".chip 68060\n\t"
484                                     "cpushl %%dc,(%0)\n\t"
485                                     ".chip 68k"
486                                     : : "a" (paddr));
487               break;
488             case FLUSH_CACHE_INSN:
489               __asm__ __volatile__ (".chip 68060\n\t"
490                                     "cpushl %%ic,(%0)\n\t"
491                                     ".chip 68k"
492                                     : : "a" (paddr));
493               break;
494             default:
495             case FLUSH_CACHE_BOTH:
496               __asm__ __volatile__ (".chip 68060\n\t"
497                                     "cpushl %%bc,(%0)\n\t"
498                                     ".chip 68k"
499                                     : : "a" (paddr));
500               break;
501             }
502           if (!--i && len)
503             {
504
505               /*
506                * We just want to jump to the first cache line
507                * in the next page.
508                */
509               addr += PAGE_SIZE;
510               addr &= PAGE_MASK;
511
512               i = PAGE_SIZE / 16;
513               /* Recompute physical address when crossing a page
514                  boundary. */
515               for (;;)
516                 {
517                   if ((paddr = virt_to_phys_060(addr)))
518                     break;
519                   if (len <= i)
520                     return 0;
521                   len -= i;
522                   addr += PAGE_SIZE;
523                 }
524             }
525           else
526             paddr += 16;
527         }
528       break;
529
530     default:
531     case FLUSH_SCOPE_PAGE:
532       len += (addr & ~PAGE_MASK) + (PAGE_SIZE - 1);
533       addr &= PAGE_MASK;        /* Workaround for bug in some
534                                    revisions of the 68060 */
535       for (len >>= PAGE_SHIFT; len--; addr += PAGE_SIZE)
536         {
537           if (!(paddr = virt_to_phys_060(addr)))
538             continue;
539           switch (cache)
540             {
541             case FLUSH_CACHE_DATA:
542               __asm__ __volatile__ (".chip 68060\n\t"
543                                     "cpushp %%dc,(%0)\n\t"
544                                     ".chip 68k"
545                                     : : "a" (paddr));
546               break;
547             case FLUSH_CACHE_INSN:
548               __asm__ __volatile__ (".chip 68060\n\t"
549                                     "cpushp %%ic,(%0)\n\t"
550                                     ".chip 68k"
551                                     : : "a" (paddr));
552               break;
553             default:
554             case FLUSH_CACHE_BOTH:
555               __asm__ __volatile__ (".chip 68060\n\t"
556                                     "cpushp %%bc,(%0)\n\t"
557                                     ".chip 68k"
558                                     : : "a" (paddr));
559               break;
560             }
561         }
562       break;
563     }
564   return 0;
565 }
566
567 /* sys_cacheflush -- flush (part of) the processor cache.  */
568 asmlinkage int
569 sys_cacheflush (unsigned long addr, int scope, int cache, unsigned long len)
570 {
571         struct vm_area_struct *vma;
572         int ret = -EINVAL;
573
574         lock_kernel();
575         if (scope < FLUSH_SCOPE_LINE || scope > FLUSH_SCOPE_ALL ||
576             cache & ~FLUSH_CACHE_BOTH)
577                 goto out;
578
579         if (scope == FLUSH_SCOPE_ALL) {
580                 /* Only the superuser may explicitly flush the whole cache. */
581                 ret = -EPERM;
582                 if (!capable(CAP_SYS_ADMIN))
583                         goto out;
584         } else {
585                 /*
586                  * Verify that the specified address region actually belongs
587                  * to this process.
588                  */
589                 vma = find_vma (current->mm, addr);
590                 ret = -EINVAL;
591                 /* Check for overflow.  */
592                 if (addr + len < addr)
593                         goto out;
594                 if (vma == NULL || addr < vma->vm_start || addr + len > vma->vm_end)
595                         goto out;
596         }
597
598         if (CPU_IS_020_OR_030) {
599                 if (scope == FLUSH_SCOPE_LINE && len < 256) {
600                         unsigned long cacr;
601                         __asm__ ("movec %%cacr, %0" : "=r" (cacr));
602                         if (cache & FLUSH_CACHE_INSN)
603                                 cacr |= 4;
604                         if (cache & FLUSH_CACHE_DATA)
605                                 cacr |= 0x400;
606                         len >>= 2;
607                         while (len--) {
608                                 __asm__ __volatile__ ("movec %1, %%caar\n\t"
609                                                       "movec %0, %%cacr"
610                                                       : /* no outputs */
611                                                       : "r" (cacr), "r" (addr));
612                                 addr += 4;
613                         }
614                 } else {
615                         /* Flush the whole cache, even if page granularity requested. */
616                         unsigned long cacr;
617                         __asm__ ("movec %%cacr, %0" : "=r" (cacr));
618                         if (cache & FLUSH_CACHE_INSN)
619                                 cacr |= 8;
620                         if (cache & FLUSH_CACHE_DATA)
621                                 cacr |= 0x800;
622                         __asm__ __volatile__ ("movec %0, %%cacr" : : "r" (cacr));
623                 }
624                 ret = 0;
625                 goto out;
626         } else {
627             /*
628              * 040 or 060: don't blindly trust 'scope', someone could
629              * try to flush a few megs of memory.
630              */
631
632             if (len>=3*PAGE_SIZE && scope<FLUSH_SCOPE_PAGE)
633                 scope=FLUSH_SCOPE_PAGE;
634             if (len>=10*PAGE_SIZE && scope<FLUSH_SCOPE_ALL)
635                 scope=FLUSH_SCOPE_ALL;
636             if (CPU_IS_040) {
637                 ret = cache_flush_040 (addr, scope, cache, len);
638             } else if (CPU_IS_060) {
639                 ret = cache_flush_060 (addr, scope, cache, len);
640             }
641         }
642 out:
643         unlock_kernel();
644         return ret;
645 }
646
647 asmlinkage int sys_getpagesize(void)
648 {
649         return PAGE_SIZE;
650 }
651
652 /*
653  * Do a system call from kernel instead of calling sys_execve so we
654  * end up with proper pt_regs.
655  */
656 int kernel_execve(const char *filename, char *const argv[], char *const envp[])
657 {
658         register long __res asm ("%d0") = __NR_execve;
659         register long __a asm ("%d1") = (long)(filename);
660         register long __b asm ("%d2") = (long)(argv);
661         register long __c asm ("%d3") = (long)(envp);
662         asm volatile ("trap  #0" : "+d" (__res)
663                         : "d" (__a), "d" (__b), "d" (__c));
664         return __res;
665 }