?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SPARC64]: Force dummy host controller onto bus zero.
[usb.git] / arch / sparc64 / kernel / sys_sparc.c
bloba53d4abb4b49de1193b6a21d1d7e10a96c8eba51
1 /* $Id: sys_sparc.c,v 1.57 2002/02/09 19:49:30 davem Exp $
2 * linux/arch/sparc64/kernel/sys_sparc.c
3 *
4 * This file contains various random system calls that
5 * have a non-standard calling sequence on the Linux/sparc
6 * platform.
7 */
8
9 #include <linux/errno.h>
10 #include <linux/types.h>
11 #include <linux/sched.h>
12 #include <linux/fs.h>
13 #include <linux/file.h>
14 #include <linux/mm.h>
15 #include <linux/sem.h>
16 #include <linux/msg.h>
17 #include <linux/shm.h>
18 #include <linux/stat.h>
19 #include <linux/mman.h>
20 #include <linux/utsname.h>
21 #include <linux/smp.h>
22 #include <linux/smp_lock.h>
23 #include <linux/slab.h>
24 #include <linux/syscalls.h>
25 #include <linux/ipc.h>
26 #include <linux/personality.h>
27 #include <linux/random.h>
28
29 #include <asm/uaccess.h>
30 #include <asm/ipc.h>
31 #include <asm/utrap.h>
32 #include <asm/perfctr.h>
33 #include <asm/a.out.h>
34 #include <asm/unistd.h>
35
36 /* #define DEBUG_UNIMP_SYSCALL */
37
38 asmlinkage unsigned long sys_getpagesize(void)
39 {
40 return PAGE_SIZE;
41 }
42
43 #define VA_EXCLUDE_START (0x0000080000000000UL - (1UL << 32UL))
44 #define VA_EXCLUDE_END (0xfffff80000000000UL + (1UL << 32UL))
45
46 /* Does addr --> addr+len fall within 4GB of the VA-space hole or
47 * overflow past the end of the 64-bit address space?
48 */
49 static inline int invalid_64bit_range(unsigned long addr, unsigned long len)
50 {
51 unsigned long va_exclude_start, va_exclude_end;
52
53 va_exclude_start = VA_EXCLUDE_START;
54 va_exclude_end = VA_EXCLUDE_END;
55
56 if (unlikely(len >= va_exclude_start))
57 return 1;
58
59 if (unlikely((addr + len) < addr))
60 return 1;
61
62 if (unlikely((addr >= va_exclude_start && addr < va_exclude_end) ||
63 ((addr + len) >= va_exclude_start &&
64 (addr + len) < va_exclude_end)))
65 return 1;
66
67 return 0;
68 }
69
70 /* Does start,end straddle the VA-space hole? */
71 static inline int straddles_64bit_va_hole(unsigned long start, unsigned long end)
72 {
73 unsigned long va_exclude_start, va_exclude_end;
74
75 va_exclude_start = VA_EXCLUDE_START;
76 va_exclude_end = VA_EXCLUDE_END;
77
78 if (likely(start < va_exclude_start && end < va_exclude_start))
79 return 0;
80
81 if (likely(start >= va_exclude_end && end >= va_exclude_end))
82 return 0;
83
84 return 1;
85 }
86
87 /* These functions differ from the default implementations in
88 * mm/mmap.c in two ways:
89 *
90 * 1) For file backed MAP_SHARED mmap()'s we D-cache color align,
91 * for fixed such mappings we just validate what the user gave us.
92 * 2) For 64-bit tasks we avoid mapping anything within 4GB of
93 * the spitfire/niagara VA-hole.
94 */
95
96 static inline unsigned long COLOUR_ALIGN(unsigned long addr,
97 unsigned long pgoff)
98 {
99 unsigned long base = (addr+SHMLBA-1)&~(SHMLBA-1);
100 unsigned long off = (pgoff<<PAGE_SHIFT) & (SHMLBA-1);
101
102 return base + off;
103 }
104
105 static inline unsigned long COLOUR_ALIGN_DOWN(unsigned long addr,
106 unsigned long pgoff)
107 {
108 unsigned long base = addr & ~(SHMLBA-1);
109 unsigned long off = (pgoff<<PAGE_SHIFT) & (SHMLBA-1);
110
111 if (base + off <= addr)
112 return base + off;
113 return base - off;
114 }
115
116 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags)
117 {
118 struct mm_struct *mm = current->mm;
119 struct vm_area_struct * vma;
120 unsigned long task_size = TASK_SIZE;
121 unsigned long start_addr;
122 int do_color_align;
123
124 if (flags & MAP_FIXED) {
125 /* We do not accept a shared mapping if it would violate
126 * cache aliasing constraints.
127 */
128 if ((flags & MAP_SHARED) &&
129 ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
130 return -EINVAL;
131 return addr;
132 }
133
134 if (test_thread_flag(TIF_32BIT))
135 task_size = STACK_TOP32;
136 if (unlikely(len > task_size || len >= VA_EXCLUDE_START))
137 return -ENOMEM;
138
139 do_color_align = 0;
140 if (filp || (flags & MAP_SHARED))
141 do_color_align = 1;
142
143 if (addr) {
144 if (do_color_align)
145 addr = COLOUR_ALIGN(addr, pgoff);
146 else
147 addr = PAGE_ALIGN(addr);
148
149 vma = find_vma(mm, addr);
150 if (task_size - len >= addr &&
151 (!vma || addr + len <= vma->vm_start))
152 return addr;
153 }
154
155 if (len > mm->cached_hole_size) {
156 start_addr = addr = mm->free_area_cache;
157 } else {
158 start_addr = addr = TASK_UNMAPPED_BASE;
159 mm->cached_hole_size = 0;
160 }
161
162 task_size -= len;
163
164 full_search:
165 if (do_color_align)
166 addr = COLOUR_ALIGN(addr, pgoff);
167 else
168 addr = PAGE_ALIGN(addr);
169
170 for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
171 /* At this point: (!vma || addr < vma->vm_end). */
172 if (addr < VA_EXCLUDE_START &&
173 (addr + len) >= VA_EXCLUDE_START) {
174 addr = VA_EXCLUDE_END;
175 vma = find_vma(mm, VA_EXCLUDE_END);
176 }
177 if (unlikely(task_size < addr)) {
178 if (start_addr != TASK_UNMAPPED_BASE) {
179 start_addr = addr = TASK_UNMAPPED_BASE;
180 mm->cached_hole_size = 0;
181 goto full_search;
182 }
183 return -ENOMEM;
184 }
185 if (likely(!vma || addr + len <= vma->vm_start)) {
186 /*
187 * Remember the place where we stopped the search:
188 */
189 mm->free_area_cache = addr + len;
190 return addr;
191 }
192 if (addr + mm->cached_hole_size < vma->vm_start)
193 mm->cached_hole_size = vma->vm_start - addr;
194
195 addr = vma->vm_end;
196 if (do_color_align)
197 addr = COLOUR_ALIGN(addr, pgoff);
198 }
199 }
200
201 unsigned long
202 arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
203 const unsigned long len, const unsigned long pgoff,
204 const unsigned long flags)
205 {
206 struct vm_area_struct *vma;
207 struct mm_struct *mm = current->mm;
208 unsigned long task_size = STACK_TOP32;
209 unsigned long addr = addr0;
210 int do_color_align;
211
212 /* This should only ever run for 32-bit processes. */
213 BUG_ON(!test_thread_flag(TIF_32BIT));
214
215 if (flags & MAP_FIXED) {
216 /* We do not accept a shared mapping if it would violate
217 * cache aliasing constraints.
218 */
219 if ((flags & MAP_SHARED) &&
220 ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
221 return -EINVAL;
222 return addr;
223 }
224
225 if (unlikely(len > task_size))
226 return -ENOMEM;
227
228 do_color_align = 0;
229 if (filp || (flags & MAP_SHARED))
230 do_color_align = 1;
231
232 /* requesting a specific address */
233 if (addr) {
234 if (do_color_align)
235 addr = COLOUR_ALIGN(addr, pgoff);
236 else
237 addr = PAGE_ALIGN(addr);
238
239 vma = find_vma(mm, addr);
240 if (task_size - len >= addr &&
241 (!vma || addr + len <= vma->vm_start))
242 return addr;
243 }
244
245 /* check if free_area_cache is useful for us */
246 if (len <= mm->cached_hole_size) {
247 mm->cached_hole_size = 0;
248 mm->free_area_cache = mm->mmap_base;
249 }
250
251 /* either no address requested or can't fit in requested address hole */
252 addr = mm->free_area_cache;
253 if (do_color_align) {
254 unsigned long base = COLOUR_ALIGN_DOWN(addr-len, pgoff);
255
256 addr = base + len;
257 }
258
259 /* make sure it can fit in the remaining address space */
260 if (likely(addr > len)) {
261 vma = find_vma(mm, addr-len);
262 if (!vma || addr <= vma->vm_start) {
263 /* remember the address as a hint for next time */
264 return (mm->free_area_cache = addr-len);
265 }
266 }
267
268 if (unlikely(mm->mmap_base < len))
269 goto bottomup;
270
271 addr = mm->mmap_base-len;
272 if (do_color_align)
273 addr = COLOUR_ALIGN_DOWN(addr, pgoff);
274
275 do {
276 /*
277 * Lookup failure means no vma is above this address,
278 * else if new region fits below vma->vm_start,
279 * return with success:
280 */
281 vma = find_vma(mm, addr);
282 if (likely(!vma || addr+len <= vma->vm_start)) {
283 /* remember the address as a hint for next time */
284 return (mm->free_area_cache = addr);
285 }
286
287 /* remember the largest hole we saw so far */
288 if (addr + mm->cached_hole_size < vma->vm_start)
289 mm->cached_hole_size = vma->vm_start - addr;
290
291 /* try just below the current vma->vm_start */
292 addr = vma->vm_start-len;
293 if (do_color_align)
294 addr = COLOUR_ALIGN_DOWN(addr, pgoff);
295 } while (likely(len < vma->vm_start));
296
297 bottomup:
298 /*
299 * A failed mmap() very likely causes application failure,
300 * so fall back to the bottom-up function here. This scenario
301 * can happen with large stack limits and large mmap()
302 * allocations.
303 */
304 mm->cached_hole_size = ~0UL;
305 mm->free_area_cache = TASK_UNMAPPED_BASE;
306 addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
307 /*
308 * Restore the topdown base:
309 */
310 mm->free_area_cache = mm->mmap_base;
311 mm->cached_hole_size = ~0UL;
312
313 return addr;
314 }
315
316 /* Try to align mapping such that we align it as much as possible. */
317 unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, unsigned long len, unsigned long pgoff, unsigned long flags)
318 {
319 unsigned long align_goal, addr = -ENOMEM;
320
321 if (flags & MAP_FIXED) {
322 /* Ok, don't mess with it. */
323 return get_unmapped_area(NULL, addr, len, pgoff, flags);
324 }
325 flags &= ~MAP_SHARED;
326
327 align_goal = PAGE_SIZE;
328 if (len >= (4UL * 1024 * 1024))
329 align_goal = (4UL * 1024 * 1024);
330 else if (len >= (512UL * 1024))
331 align_goal = (512UL * 1024);
332 else if (len >= (64UL * 1024))
333 align_goal = (64UL * 1024);
334
335 do {
336 addr = get_unmapped_area(NULL, orig_addr, len + (align_goal - PAGE_SIZE), pgoff, flags);
337 if (!(addr & ~PAGE_MASK)) {
338 addr = (addr + (align_goal - 1UL)) & ~(align_goal - 1UL);
339 break;
340 }
341
342 if (align_goal == (4UL * 1024 * 1024))
343 align_goal = (512UL * 1024);
344 else if (align_goal == (512UL * 1024))
345 align_goal = (64UL * 1024);
346 else
347 align_goal = PAGE_SIZE;
348 } while ((addr & ~PAGE_MASK) && align_goal > PAGE_SIZE);
349
350 /* Mapping is smaller than 64K or larger areas could not
351 * be obtained.
352 */
353 if (addr & ~PAGE_MASK)
354 addr = get_unmapped_area(NULL, orig_addr, len, pgoff, flags);
355
356 return addr;
357 }
358
359 /* Essentially the same as PowerPC... */
360 void arch_pick_mmap_layout(struct mm_struct *mm)
361 {
362 unsigned long random_factor = 0UL;
363
364 if (current->flags & PF_RANDOMIZE) {
365 random_factor = get_random_int();
366 if (test_thread_flag(TIF_32BIT))
367 random_factor &= ((1 * 1024 * 1024) - 1);
368 else
369 random_factor = ((random_factor << PAGE_SHIFT) &
370 0xffffffffUL);
371 }
372
373 /*
374 * Fall back to the standard layout if the personality
375 * bit is set, or if the expected stack growth is unlimited:
376 */
377 if (!test_thread_flag(TIF_32BIT) ||
378 (current->personality & ADDR_COMPAT_LAYOUT) ||
379 current->signal->rlim[RLIMIT_STACK].rlim_cur == RLIM_INFINITY ||
380 sysctl_legacy_va_layout) {
381 mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
382 mm->get_unmapped_area = arch_get_unmapped_area;
383 mm->unmap_area = arch_unmap_area;
384 } else {
385 /* We know it's 32-bit */
386 unsigned long task_size = STACK_TOP32;
387 unsigned long gap;
388
389 gap = current->signal->rlim[RLIMIT_STACK].rlim_cur;
390 if (gap < 128 * 1024 * 1024)
391 gap = 128 * 1024 * 1024;
392 if (gap > (task_size / 6 * 5))
393 gap = (task_size / 6 * 5);
394
395 mm->mmap_base = PAGE_ALIGN(task_size - gap - random_factor);
396 mm->get_unmapped_area = arch_get_unmapped_area_topdown;
397 mm->unmap_area = arch_unmap_area_topdown;
398 }
399 }
400
401 asmlinkage unsigned long sparc_brk(unsigned long brk)
402 {
403 /* People could try to be nasty and use ta 0x6d in 32bit programs */
404 if (test_thread_flag(TIF_32BIT) && brk >= STACK_TOP32)
405 return current->mm->brk;
406
407 if (unlikely(straddles_64bit_va_hole(current->mm->brk, brk)))
408 return current->mm->brk;
409
410 return sys_brk(brk);
411 }
412
413 /*
414 * sys_pipe() is the normal C calling standard for creating
415 * a pipe. It's not the way unix traditionally does this, though.
416 */
417 asmlinkage long sparc_pipe(struct pt_regs *regs)
418 {
419 int fd[2];
420 int error;
421
422 error = do_pipe(fd);
423 if (error)
424 goto out;
425 regs->u_regs[UREG_I1] = fd[1];
426 error = fd[0];
427 out:
428 return error;
429 }
430
431 /*
432 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
433 *
434 * This is really horribly ugly.
435 */
436
437 asmlinkage long sys_ipc(unsigned int call, int first, unsigned long second,
438 unsigned long third, void __user *ptr, long fifth)
439 {
440 int err;
441
442 /* No need for backward compatibility. We can start fresh... */
443 if (call <= SEMCTL) {
444 switch (call) {
445 case SEMOP:
446 err = sys_semtimedop(first, ptr,
447 (unsigned)second, NULL);
448 goto out;
449 case SEMTIMEDOP:
450 err = sys_semtimedop(first, ptr, (unsigned)second,
451 (const struct timespec __user *) fifth);
452 goto out;
453 case SEMGET:
454 err = sys_semget(first, (int)second, (int)third);
455 goto out;
456 case SEMCTL: {
457 union semun fourth;
458 err = -EINVAL;
459 if (!ptr)
460 goto out;
461 err = -EFAULT;
462 if (get_user(fourth.__pad,
463 (void __user * __user *) ptr))
464 goto out;
465 err = sys_semctl(first, (int)second | IPC_64,
466 (int)third, fourth);
467 goto out;
468 }
469 default:
470 err = -ENOSYS;
471 goto out;
472 };
473 }
474 if (call <= MSGCTL) {
475 switch (call) {
476 case MSGSND:
477 err = sys_msgsnd(first, ptr, (size_t)second,
478 (int)third);
479 goto out;
480 case MSGRCV:
481 err = sys_msgrcv(first, ptr, (size_t)second, fifth,
482 (int)third);
483 goto out;
484 case MSGGET:
485 err = sys_msgget((key_t)first, (int)second);
486 goto out;
487 case MSGCTL:
488 err = sys_msgctl(first, (int)second | IPC_64, ptr);
489 goto out;
490 default:
491 err = -ENOSYS;
492 goto out;
493 };
494 }
495 if (call <= SHMCTL) {
496 switch (call) {
497 case SHMAT: {
498 ulong raddr;
499 err = do_shmat(first, ptr, (int)second, &raddr);
500 if (!err) {
501 if (put_user(raddr,
502 (ulong __user *) third))
503 err = -EFAULT;
504 }
505 goto out;
506 }
507 case SHMDT:
508 err = sys_shmdt(ptr);
509 goto out;
510 case SHMGET:
511 err = sys_shmget(first, (size_t)second, (int)third);
512 goto out;
513 case SHMCTL:
514 err = sys_shmctl(first, (int)second | IPC_64, ptr);
515 goto out;
516 default:
517 err = -ENOSYS;
518 goto out;
519 };
520 } else {
521 err = -ENOSYS;
522 }
523 out:
524 return err;
525 }
526
527 asmlinkage long sparc64_newuname(struct new_utsname __user *name)
528 {
529 int ret = sys_newuname(name);
530
531 if (current->personality == PER_LINUX32 && !ret) {
532 ret = (copy_to_user(name->machine, "sparc\0\0", 8)
533 ? -EFAULT : 0);
534 }
535 return ret;
536 }
537
538 asmlinkage long sparc64_personality(unsigned long personality)
539 {
540 int ret;
541
542 if (current->personality == PER_LINUX32 &&
543 personality == PER_LINUX)
544 personality = PER_LINUX32;
545 ret = sys_personality(personality);
546 if (ret == PER_LINUX32)
547 ret = PER_LINUX;
548
549 return ret;
550 }
551
552 int sparc64_mmap_check(unsigned long addr, unsigned long len,
553 unsigned long flags)
554 {
555 if (test_thread_flag(TIF_32BIT)) {
556 if (len >= STACK_TOP32)
557 return -EINVAL;
558
559 if ((flags & MAP_FIXED) && addr > STACK_TOP32 - len)
560 return -EINVAL;
561 } else {
562 if (len >= VA_EXCLUDE_START)
563 return -EINVAL;
564
565 if ((flags & MAP_FIXED) && invalid_64bit_range(addr, len))
566 return -EINVAL;
567 }
568
569 return 0;
570 }
571
572 /* Linux version of mmap */
573 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
574 unsigned long prot, unsigned long flags, unsigned long fd,
575 unsigned long off)
576 {
577 struct file * file = NULL;
578 unsigned long retval = -EBADF;
579
580 if (!(flags & MAP_ANONYMOUS)) {
581 file = fget(fd);
582 if (!file)
583 goto out;
584 }
585 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
586 len = PAGE_ALIGN(len);
587
588 down_write(&current->mm->mmap_sem);
589 retval = do_mmap(file, addr, len, prot, flags, off);
590 up_write(&current->mm->mmap_sem);
591
592 if (file)
593 fput(file);
594 out:
595 return retval;
596 }
597
598 asmlinkage long sys64_munmap(unsigned long addr, size_t len)
599 {
600 long ret;
601
602 if (invalid_64bit_range(addr, len))
603 return -EINVAL;
604
605 down_write(&current->mm->mmap_sem);
606 ret = do_munmap(current->mm, addr, len);
607 up_write(&current->mm->mmap_sem);
608 return ret;
609 }
610
611 extern unsigned long do_mremap(unsigned long addr,
612 unsigned long old_len, unsigned long new_len,
613 unsigned long flags, unsigned long new_addr);
614
615 asmlinkage unsigned long sys64_mremap(unsigned long addr,
616 unsigned long old_len, unsigned long new_len,
617 unsigned long flags, unsigned long new_addr)
618 {
619 struct vm_area_struct *vma;
620 unsigned long ret = -EINVAL;
621
622 if (test_thread_flag(TIF_32BIT))
623 goto out;
624 if (unlikely(new_len >= VA_EXCLUDE_START))
625 goto out;
626 if (unlikely(invalid_64bit_range(addr, old_len)))
627 goto out;
628
629 down_write(&current->mm->mmap_sem);
630 if (flags & MREMAP_FIXED) {
631 if (invalid_64bit_range(new_addr, new_len))
632 goto out_sem;
633 } else if (invalid_64bit_range(addr, new_len)) {
634 unsigned long map_flags = 0;
635 struct file *file = NULL;
636
637 ret = -ENOMEM;
638 if (!(flags & MREMAP_MAYMOVE))
639 goto out_sem;
640
641 vma = find_vma(current->mm, addr);
642 if (vma) {
643 if (vma->vm_flags & VM_SHARED)
644 map_flags |= MAP_SHARED;
645 file = vma->vm_file;
646 }
647
648 /* MREMAP_FIXED checked above. */
649 new_addr = get_unmapped_area(file, addr, new_len,
650 vma ? vma->vm_pgoff : 0,
651 map_flags);
652 ret = new_addr;
653 if (new_addr & ~PAGE_MASK)
654 goto out_sem;
655 flags |= MREMAP_FIXED;
656 }
657 ret = do_mremap(addr, old_len, new_len, flags, new_addr);
658 out_sem:
659 up_write(&current->mm->mmap_sem);
660 out:
661 return ret;
662 }
663
664 /* we come to here via sys_nis_syscall so it can setup the regs argument */
665 asmlinkage unsigned long c_sys_nis_syscall(struct pt_regs *regs)
666 {
667 static int count;
668
669 /* Don't make the system unusable, if someone goes stuck */
670 if (count++ > 5)
671 return -ENOSYS;
672
673 printk ("Unimplemented SPARC system call %ld\n",regs->u_regs[1]);
674 #ifdef DEBUG_UNIMP_SYSCALL
675 show_regs (regs);
676 #endif
677
678 return -ENOSYS;
679 }
680
681 /* #define DEBUG_SPARC_BREAKPOINT */
682
683 asmlinkage void sparc_breakpoint(struct pt_regs *regs)
684 {
685 siginfo_t info;
686
687 if (test_thread_flag(TIF_32BIT)) {
688 regs->tpc &= 0xffffffff;
689 regs->tnpc &= 0xffffffff;
690 }
691 #ifdef DEBUG_SPARC_BREAKPOINT
692 printk ("TRAP: Entering kernel PC=%lx, nPC=%lx\n", regs->tpc, regs->tnpc);
693 #endif
694 info.si_signo = SIGTRAP;
695 info.si_errno = 0;
696 info.si_code = TRAP_BRKPT;
697 info.si_addr = (void __user *)regs->tpc;
698 info.si_trapno = 0;
699 force_sig_info(SIGTRAP, &info, current);
700 #ifdef DEBUG_SPARC_BREAKPOINT
701 printk ("TRAP: Returning to space: PC=%lx nPC=%lx\n", regs->tpc, regs->tnpc);
702 #endif
703 }
704
705 extern void check_pending(int signum);
706
707 asmlinkage long sys_getdomainname(char __user *name, int len)
708 {
709 int nlen, err;
710
711 if (len < 0)
712 return -EINVAL;
713
714 down_read(&uts_sem);
715
716 nlen = strlen(utsname()->domainname) + 1;
717 err = -EINVAL;
718 if (nlen > len)
719 goto out;
720
721 err = -EFAULT;
722 if (!copy_to_user(name, utsname()->domainname, nlen))
723 err = 0;
724
725 out:
726 up_read(&uts_sem);
727 return err;
728 }
729
730 asmlinkage long solaris_syscall(struct pt_regs *regs)
731 {
732 static int count;
733
734 regs->tpc = regs->tnpc;
735 regs->tnpc += 4;
736 if (test_thread_flag(TIF_32BIT)) {
737 regs->tpc &= 0xffffffff;
738 regs->tnpc &= 0xffffffff;
739 }
740 if (++count <= 5) {
741 printk ("For Solaris binary emulation you need solaris module loaded\n");
742 show_regs (regs);
743 }
744 send_sig(SIGSEGV, current, 1);
745
746 return -ENOSYS;
747 }
748
749 #ifndef CONFIG_SUNOS_EMUL
750 asmlinkage long sunos_syscall(struct pt_regs *regs)
751 {
752 static int count;
753
754 regs->tpc = regs->tnpc;
755 regs->tnpc += 4;
756 if (test_thread_flag(TIF_32BIT)) {
757 regs->tpc &= 0xffffffff;
758 regs->tnpc &= 0xffffffff;
759 }
760 if (++count <= 20)
761 printk ("SunOS binary emulation not compiled in\n");
762 force_sig(SIGSEGV, current);
763
764 return -ENOSYS;
765 }
766 #endif
767
768 asmlinkage long sys_utrap_install(utrap_entry_t type,
769 utrap_handler_t new_p,
770 utrap_handler_t new_d,
771 utrap_handler_t __user *old_p,
772 utrap_handler_t __user *old_d)
773 {
774 if (type < UT_INSTRUCTION_EXCEPTION || type > UT_TRAP_INSTRUCTION_31)
775 return -EINVAL;
776 if (new_p == (utrap_handler_t)(long)UTH_NOCHANGE) {
777 if (old_p) {
778 if (!current_thread_info()->utraps) {
779 if (put_user(NULL, old_p))
780 return -EFAULT;
781 } else {
782 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
783 return -EFAULT;
784 }
785 }
786 if (old_d) {
787 if (put_user(NULL, old_d))
788 return -EFAULT;
789 }
790 return 0;
791 }
792 if (!current_thread_info()->utraps) {
793 current_thread_info()->utraps =
794 kzalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long), GFP_KERNEL);
795 if (!current_thread_info()->utraps)
796 return -ENOMEM;
797 current_thread_info()->utraps[0] = 1;
798 } else {
799 if ((utrap_handler_t)current_thread_info()->utraps[type] != new_p &&
800 current_thread_info()->utraps[0] > 1) {
801 long *p = current_thread_info()->utraps;
802
803 current_thread_info()->utraps =
804 kmalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long),
805 GFP_KERNEL);
806 if (!current_thread_info()->utraps) {
807 current_thread_info()->utraps = p;
808 return -ENOMEM;
809 }
810 p[0]--;
811 current_thread_info()->utraps[0] = 1;
812 memcpy(current_thread_info()->utraps+1, p+1,
813 UT_TRAP_INSTRUCTION_31*sizeof(long));
814 }
815 }
816 if (old_p) {
817 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
818 return -EFAULT;
819 }
820 if (old_d) {
821 if (put_user(NULL, old_d))
822 return -EFAULT;
823 }
824 current_thread_info()->utraps[type] = (long)new_p;
825
826 return 0;
827 }
828
829 long sparc_memory_ordering(unsigned long model, struct pt_regs *regs)
830 {
831 if (model >= 3)
832 return -EINVAL;
833 regs->tstate = (regs->tstate & ~TSTATE_MM) | (model << 14);
834 return 0;
835 }
836
837 asmlinkage long sys_rt_sigaction(int sig,
838 const struct sigaction __user *act,
839 struct sigaction __user *oact,
840 void __user *restorer,
841 size_t sigsetsize)
842 {
843 struct k_sigaction new_ka, old_ka;
844 int ret;
845
846 /* XXX: Don't preclude handling different sized sigset_t's. */
847 if (sigsetsize != sizeof(sigset_t))
848 return -EINVAL;
849
850 if (act) {
851 new_ka.ka_restorer = restorer;
852 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
853 return -EFAULT;
854 }
855
856 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
857
858 if (!ret && oact) {
859 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
860 return -EFAULT;
861 }
862
863 return ret;
864 }
865
866 /* Invoked by rtrap code to update performance counters in
867 * user space.
868 */
869 asmlinkage void update_perfctrs(void)
870 {
871 unsigned long pic, tmp;
872
873 read_pic(pic);
874 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
875 __put_user(tmp, current_thread_info()->user_cntd0);
876 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
877 __put_user(tmp, current_thread_info()->user_cntd1);
878 reset_pic();
879 }
880
881 asmlinkage long sys_perfctr(int opcode, unsigned long arg0, unsigned long arg1, unsigned long arg2)
882 {
883 int err = 0;
884
885 switch(opcode) {
886 case PERFCTR_ON:
887 current_thread_info()->pcr_reg = arg2;
888 current_thread_info()->user_cntd0 = (u64 __user *) arg0;
889 current_thread_info()->user_cntd1 = (u64 __user *) arg1;
890 current_thread_info()->kernel_cntd0 =
891 current_thread_info()->kernel_cntd1 = 0;
892 write_pcr(arg2);
893 reset_pic();
894 set_thread_flag(TIF_PERFCTR);
895 break;
896
897 case PERFCTR_OFF:
898 err = -EINVAL;
899 if (test_thread_flag(TIF_PERFCTR)) {
900 current_thread_info()->user_cntd0 =
901 current_thread_info()->user_cntd1 = NULL;
902 current_thread_info()->pcr_reg = 0;
903 write_pcr(0);
904 clear_thread_flag(TIF_PERFCTR);
905 err = 0;
906 }
907 break;
908
909 case PERFCTR_READ: {
910 unsigned long pic, tmp;
911
912 if (!test_thread_flag(TIF_PERFCTR)) {
913 err = -EINVAL;
914 break;
915 }
916 read_pic(pic);
917 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
918 err |= __put_user(tmp, current_thread_info()->user_cntd0);
919 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
920 err |= __put_user(tmp, current_thread_info()->user_cntd1);
921 reset_pic();
922 break;
923 }
924
925 case PERFCTR_CLRPIC:
926 if (!test_thread_flag(TIF_PERFCTR)) {
927 err = -EINVAL;
928 break;
929 }
930 current_thread_info()->kernel_cntd0 =
931 current_thread_info()->kernel_cntd1 = 0;
932 reset_pic();
933 break;
934
935 case PERFCTR_SETPCR: {
936 u64 __user *user_pcr = (u64 __user *)arg0;
937
938 if (!test_thread_flag(TIF_PERFCTR)) {
939 err = -EINVAL;
940 break;
941 }
942 err |= __get_user(current_thread_info()->pcr_reg, user_pcr);
943 write_pcr(current_thread_info()->pcr_reg);
944 current_thread_info()->kernel_cntd0 =
945 current_thread_info()->kernel_cntd1 = 0;
946 reset_pic();
947 break;
948 }
949
950 case PERFCTR_GETPCR: {
951 u64 __user *user_pcr = (u64 __user *)arg0;
952
953 if (!test_thread_flag(TIF_PERFCTR)) {
954 err = -EINVAL;
955 break;
956 }
957 err |= __put_user(current_thread_info()->pcr_reg, user_pcr);
958 break;
959 }
960
961 default:
962 err = -EINVAL;
963 break;
964 };
965 return err;
966 }
967
968 /*
969 * Do a system call from kernel instead of calling sys_execve so we
970 * end up with proper pt_regs.
971 */
972 int kernel_execve(const char *filename, char *const argv[], char *const envp[])
973 {
974 long __res;
975 register long __g1 __asm__ ("g1") = __NR_execve;
976 register long __o0 __asm__ ("o0") = (long)(filename);
977 register long __o1 __asm__ ("o1") = (long)(argv);
978 register long __o2 __asm__ ("o2") = (long)(envp);
979 asm volatile ("t 0x6d\n\t"
980 "sub %%g0, %%o0, %0\n\t"
981 "movcc %%xcc, %%o0, %0\n\t"
982 : "=r" (__res), "=&r" (__o0)
983 : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__g1)
984 : "cc");
985 return __res;
986 }
USB Experimental Work