1 /* $Id: sys_sparc.c,v 1.57 2002/02/09 19:49:30 davem Exp $
2 * linux/arch/sparc64/kernel/sys_sparc.c
4 * This file contains various random system calls that
5 * have a non-standard calling sequence on the Linux/sparc
9 #include <linux/config.h>
10 #include <linux/errno.h>
11 #include <linux/types.h>
12 #include <linux/sched.h>
14 #include <linux/file.h>
16 #include <linux/sem.h>
17 #include <linux/msg.h>
18 #include <linux/shm.h>
19 #include <linux/stat.h>
20 #include <linux/mman.h>
21 #include <linux/utsname.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/slab.h>
25 #include <linux/syscalls.h>
26 #include <linux/ipc.h>
27 #include <linux/personality.h>
28 #include <linux/random.h>
29 #include <linux/vs_cvirt.h>
31 #include <asm/uaccess.h>
33 #include <asm/utrap.h>
34 #include <asm/perfctr.h>
35 #include <asm/a.out.h>
37 /* #define DEBUG_UNIMP_SYSCALL */
39 asmlinkage unsigned long sys_getpagesize(void)
44 #define VA_EXCLUDE_START (0x0000080000000000UL - (1UL << 32UL))
45 #define VA_EXCLUDE_END (0xfffff80000000000UL + (1UL << 32UL))
47 /* Does addr --> addr+len fall within 4GB of the VA-space hole or
48 * overflow past the end of the 64-bit address space?
50 static inline int invalid_64bit_range(unsigned long addr, unsigned long len)
52 unsigned long va_exclude_start, va_exclude_end;
54 va_exclude_start = VA_EXCLUDE_START;
55 va_exclude_end = VA_EXCLUDE_END;
57 if (unlikely(len >= va_exclude_start))
60 if (unlikely((addr + len) < addr))
63 if (unlikely((addr >= va_exclude_start && addr < va_exclude_end) ||
64 ((addr + len) >= va_exclude_start &&
65 (addr + len) < va_exclude_end)))
71 /* Does start,end straddle the VA-space hole? */
72 static inline int straddles_64bit_va_hole(unsigned long start, unsigned long end)
74 unsigned long va_exclude_start, va_exclude_end;
76 va_exclude_start = VA_EXCLUDE_START;
77 va_exclude_end = VA_EXCLUDE_END;
79 if (likely(start < va_exclude_start && end < va_exclude_start))
82 if (likely(start >= va_exclude_end && end >= va_exclude_end))
88 /* These functions differ from the default implementations in
89 * mm/mmap.c in two ways:
91 * 1) For file backed MAP_SHARED mmap()'s we D-cache color align,
92 * for fixed such mappings we just validate what the user gave us.
93 * 2) For 64-bit tasks we avoid mapping anything within 4GB of
94 * the spitfire/niagara VA-hole.
97 static inline unsigned long COLOUR_ALIGN(unsigned long addr,
100 unsigned long base = (addr+SHMLBA-1)&~(SHMLBA-1);
101 unsigned long off = (pgoff<<PAGE_SHIFT) & (SHMLBA-1);
106 static inline unsigned long COLOUR_ALIGN_DOWN(unsigned long addr,
109 unsigned long base = addr & ~(SHMLBA-1);
110 unsigned long off = (pgoff<<PAGE_SHIFT) & (SHMLBA-1);
112 if (base + off <= addr)
117 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags)
119 struct mm_struct *mm = current->mm;
120 struct vm_area_struct * vma;
121 unsigned long task_size = TASK_SIZE;
122 unsigned long start_addr;
125 if (flags & MAP_FIXED) {
126 /* We do not accept a shared mapping if it would violate
127 * cache aliasing constraints.
129 if ((flags & MAP_SHARED) &&
130 ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
135 if (test_thread_flag(TIF_32BIT))
136 task_size = STACK_TOP32;
137 if (unlikely(len > task_size || len >= VA_EXCLUDE_START))
141 if (filp || (flags & MAP_SHARED))
146 addr = COLOUR_ALIGN(addr, pgoff);
148 addr = PAGE_ALIGN(addr);
150 vma = find_vma(mm, addr);
151 if (task_size - len >= addr &&
152 (!vma || addr + len <= vma->vm_start))
156 if (len > mm->cached_hole_size) {
157 start_addr = addr = mm->free_area_cache;
159 start_addr = addr = TASK_UNMAPPED_BASE;
160 mm->cached_hole_size = 0;
167 addr = COLOUR_ALIGN(addr, pgoff);
169 addr = PAGE_ALIGN(addr);
171 for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
172 /* At this point: (!vma || addr < vma->vm_end). */
173 if (addr < VA_EXCLUDE_START &&
174 (addr + len) >= VA_EXCLUDE_START) {
175 addr = VA_EXCLUDE_END;
176 vma = find_vma(mm, VA_EXCLUDE_END);
178 if (unlikely(task_size < addr)) {
179 if (start_addr != TASK_UNMAPPED_BASE) {
180 start_addr = addr = TASK_UNMAPPED_BASE;
181 mm->cached_hole_size = 0;
186 if (likely(!vma || addr + len <= vma->vm_start)) {
188 * Remember the place where we stopped the search:
190 mm->free_area_cache = addr + len;
193 if (addr + mm->cached_hole_size < vma->vm_start)
194 mm->cached_hole_size = vma->vm_start - addr;
198 addr = COLOUR_ALIGN(addr, pgoff);
203 arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
204 const unsigned long len, const unsigned long pgoff,
205 const unsigned long flags)
207 struct vm_area_struct *vma;
208 struct mm_struct *mm = current->mm;
209 unsigned long task_size = STACK_TOP32;
210 unsigned long addr = addr0;
213 /* This should only ever run for 32-bit processes. */
214 BUG_ON(!test_thread_flag(TIF_32BIT));
216 if (flags & MAP_FIXED) {
217 /* We do not accept a shared mapping if it would violate
218 * cache aliasing constraints.
220 if ((flags & MAP_SHARED) &&
221 ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
226 if (unlikely(len > task_size))
230 if (filp || (flags & MAP_SHARED))
233 /* requesting a specific address */
236 addr = COLOUR_ALIGN(addr, pgoff);
238 addr = PAGE_ALIGN(addr);
240 vma = find_vma(mm, addr);
241 if (task_size - len >= addr &&
242 (!vma || addr + len <= vma->vm_start))
246 /* check if free_area_cache is useful for us */
247 if (len <= mm->cached_hole_size) {
248 mm->cached_hole_size = 0;
249 mm->free_area_cache = mm->mmap_base;
252 /* either no address requested or can't fit in requested address hole */
253 addr = mm->free_area_cache;
254 if (do_color_align) {
255 unsigned long base = COLOUR_ALIGN_DOWN(addr-len, pgoff);
260 /* make sure it can fit in the remaining address space */
261 if (likely(addr > len)) {
262 vma = find_vma(mm, addr-len);
263 if (!vma || addr <= vma->vm_start) {
264 /* remember the address as a hint for next time */
265 return (mm->free_area_cache = addr-len);
269 if (unlikely(mm->mmap_base < len))
272 addr = mm->mmap_base-len;
274 addr = COLOUR_ALIGN_DOWN(addr, pgoff);
278 * Lookup failure means no vma is above this address,
279 * else if new region fits below vma->vm_start,
280 * return with success:
282 vma = find_vma(mm, addr);
283 if (likely(!vma || addr+len <= vma->vm_start)) {
284 /* remember the address as a hint for next time */
285 return (mm->free_area_cache = addr);
288 /* remember the largest hole we saw so far */
289 if (addr + mm->cached_hole_size < vma->vm_start)
290 mm->cached_hole_size = vma->vm_start - addr;
292 /* try just below the current vma->vm_start */
293 addr = vma->vm_start-len;
295 addr = COLOUR_ALIGN_DOWN(addr, pgoff);
296 } while (likely(len < vma->vm_start));
300 * A failed mmap() very likely causes application failure,
301 * so fall back to the bottom-up function here. This scenario
302 * can happen with large stack limits and large mmap()
305 mm->cached_hole_size = ~0UL;
306 mm->free_area_cache = TASK_UNMAPPED_BASE;
307 addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
309 * Restore the topdown base:
311 mm->free_area_cache = mm->mmap_base;
312 mm->cached_hole_size = ~0UL;
317 /* Try to align mapping such that we align it as much as possible. */
318 unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, unsigned long len, unsigned long pgoff, unsigned long flags)
320 unsigned long align_goal, addr = -ENOMEM;
322 if (flags & MAP_FIXED) {
323 /* Ok, don't mess with it. */
324 return get_unmapped_area(NULL, addr, len, pgoff, flags);
326 flags &= ~MAP_SHARED;
328 align_goal = PAGE_SIZE;
329 if (len >= (4UL * 1024 * 1024))
330 align_goal = (4UL * 1024 * 1024);
331 else if (len >= (512UL * 1024))
332 align_goal = (512UL * 1024);
333 else if (len >= (64UL * 1024))
334 align_goal = (64UL * 1024);
337 addr = get_unmapped_area(NULL, orig_addr, len + (align_goal - PAGE_SIZE), pgoff, flags);
338 if (!(addr & ~PAGE_MASK)) {
339 addr = (addr + (align_goal - 1UL)) & ~(align_goal - 1UL);
343 if (align_goal == (4UL * 1024 * 1024))
344 align_goal = (512UL * 1024);
345 else if (align_goal == (512UL * 1024))
346 align_goal = (64UL * 1024);
348 align_goal = PAGE_SIZE;
349 } while ((addr & ~PAGE_MASK) && align_goal > PAGE_SIZE);
351 /* Mapping is smaller than 64K or larger areas could not
354 if (addr & ~PAGE_MASK)
355 addr = get_unmapped_area(NULL, orig_addr, len, pgoff, flags);
360 /* Essentially the same as PowerPC... */
361 void arch_pick_mmap_layout(struct mm_struct *mm)
363 unsigned long random_factor = 0UL;
365 if (current->flags & PF_RANDOMIZE) {
366 random_factor = get_random_int();
367 if (test_thread_flag(TIF_32BIT))
368 random_factor &= ((1 * 1024 * 1024) - 1);
370 random_factor = ((random_factor << PAGE_SHIFT) &
375 * Fall back to the standard layout if the personality
376 * bit is set, or if the expected stack growth is unlimited:
378 if (!test_thread_flag(TIF_32BIT) ||
379 (current->personality & ADDR_COMPAT_LAYOUT) ||
380 current->signal->rlim[RLIMIT_STACK].rlim_cur == RLIM_INFINITY ||
381 sysctl_legacy_va_layout) {
382 mm->mmap_base = TASK_UNMAPPED_BASE + random_factor;
383 mm->get_unmapped_area = arch_get_unmapped_area;
384 mm->unmap_area = arch_unmap_area;
386 /* We know it's 32-bit */
387 unsigned long task_size = STACK_TOP32;
390 gap = current->signal->rlim[RLIMIT_STACK].rlim_cur;
391 if (gap < 128 * 1024 * 1024)
392 gap = 128 * 1024 * 1024;
393 if (gap > (task_size / 6 * 5))
394 gap = (task_size / 6 * 5);
396 mm->mmap_base = PAGE_ALIGN(task_size - gap - random_factor);
397 mm->get_unmapped_area = arch_get_unmapped_area_topdown;
398 mm->unmap_area = arch_unmap_area_topdown;
402 asmlinkage unsigned long sparc_brk(unsigned long brk)
404 /* People could try to be nasty and use ta 0x6d in 32bit programs */
405 if (test_thread_flag(TIF_32BIT) && brk >= STACK_TOP32)
406 return current->mm->brk;
408 if (unlikely(straddles_64bit_va_hole(current->mm->brk, brk)))
409 return current->mm->brk;
415 * sys_pipe() is the normal C calling standard for creating
416 * a pipe. It's not the way unix traditionally does this, though.
418 asmlinkage long sparc_pipe(struct pt_regs *regs)
426 regs->u_regs[UREG_I1] = fd[1];
433 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
435 * This is really horribly ugly.
438 asmlinkage long sys_ipc(unsigned int call, int first, unsigned long second,
439 unsigned long third, void __user *ptr, long fifth)
443 /* No need for backward compatibility. We can start fresh... */
444 if (call <= SEMCTL) {
447 err = sys_semtimedop(first, ptr,
448 (unsigned)second, NULL);
451 err = sys_semtimedop(first, ptr, (unsigned)second,
452 (const struct timespec __user *) fifth);
455 err = sys_semget(first, (int)second, (int)third);
463 if (get_user(fourth.__pad,
464 (void __user * __user *) ptr))
466 err = sys_semctl(first, (int)second | IPC_64,
475 if (call <= MSGCTL) {
478 err = sys_msgsnd(first, ptr, (size_t)second,
482 err = sys_msgrcv(first, ptr, (size_t)second, fifth,
486 err = sys_msgget((key_t)first, (int)second);
489 err = sys_msgctl(first, (int)second | IPC_64, ptr);
496 if (call <= SHMCTL) {
500 err = do_shmat(first, ptr, (int)second, &raddr);
503 (ulong __user *) third))
509 err = sys_shmdt(ptr);
512 err = sys_shmget(first, (size_t)second, (int)third);
515 err = sys_shmctl(first, (int)second | IPC_64, ptr);
528 asmlinkage long sparc64_newuname(struct new_utsname __user *name)
530 int ret = sys_newuname(name);
532 if (current->personality == PER_LINUX32 && !ret) {
533 ret = (copy_to_user(name->machine, "sparc\0\0", 8)
539 asmlinkage long sparc64_personality(unsigned long personality)
543 if (current->personality == PER_LINUX32 &&
544 personality == PER_LINUX)
545 personality = PER_LINUX32;
546 ret = sys_personality(personality);
547 if (ret == PER_LINUX32)
553 int sparc64_mmap_check(unsigned long addr, unsigned long len,
556 if (test_thread_flag(TIF_32BIT)) {
557 if (len >= STACK_TOP32)
560 if ((flags & MAP_FIXED) && addr > STACK_TOP32 - len)
563 if (len >= VA_EXCLUDE_START)
566 if ((flags & MAP_FIXED) && invalid_64bit_range(addr, len))
573 /* Linux version of mmap */
574 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
575 unsigned long prot, unsigned long flags, unsigned long fd,
578 struct file * file = NULL;
579 unsigned long retval = -EBADF;
581 if (!(flags & MAP_ANONYMOUS)) {
586 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
587 len = PAGE_ALIGN(len);
589 down_write(¤t->mm->mmap_sem);
590 retval = do_mmap(file, addr, len, prot, flags, off);
591 up_write(¤t->mm->mmap_sem);
599 asmlinkage long sys64_munmap(unsigned long addr, size_t len)
603 if (invalid_64bit_range(addr, len))
606 down_write(¤t->mm->mmap_sem);
607 ret = do_munmap(current->mm, addr, len);
608 up_write(¤t->mm->mmap_sem);
612 extern unsigned long do_mremap(unsigned long addr,
613 unsigned long old_len, unsigned long new_len,
614 unsigned long flags, unsigned long new_addr);
616 asmlinkage unsigned long sys64_mremap(unsigned long addr,
617 unsigned long old_len, unsigned long new_len,
618 unsigned long flags, unsigned long new_addr)
620 struct vm_area_struct *vma;
621 unsigned long ret = -EINVAL;
623 if (test_thread_flag(TIF_32BIT))
625 if (unlikely(new_len >= VA_EXCLUDE_START))
627 if (unlikely(invalid_64bit_range(addr, old_len)))
630 down_write(¤t->mm->mmap_sem);
631 if (flags & MREMAP_FIXED) {
632 if (invalid_64bit_range(new_addr, new_len))
634 } else if (invalid_64bit_range(addr, new_len)) {
635 unsigned long map_flags = 0;
636 struct file *file = NULL;
639 if (!(flags & MREMAP_MAYMOVE))
642 vma = find_vma(current->mm, addr);
644 if (vma->vm_flags & VM_SHARED)
645 map_flags |= MAP_SHARED;
649 /* MREMAP_FIXED checked above. */
650 new_addr = get_unmapped_area(file, addr, new_len,
651 vma ? vma->vm_pgoff : 0,
654 if (new_addr & ~PAGE_MASK)
656 flags |= MREMAP_FIXED;
658 ret = do_mremap(addr, old_len, new_len, flags, new_addr);
660 up_write(¤t->mm->mmap_sem);
665 /* we come to here via sys_nis_syscall so it can setup the regs argument */
666 asmlinkage unsigned long c_sys_nis_syscall(struct pt_regs *regs)
670 /* Don't make the system unusable, if someone goes stuck */
674 printk ("Unimplemented SPARC system call %ld\n",regs->u_regs[1]);
675 #ifdef DEBUG_UNIMP_SYSCALL
682 /* #define DEBUG_SPARC_BREAKPOINT */
684 asmlinkage void sparc_breakpoint(struct pt_regs *regs)
688 if (test_thread_flag(TIF_32BIT)) {
689 regs->tpc &= 0xffffffff;
690 regs->tnpc &= 0xffffffff;
692 #ifdef DEBUG_SPARC_BREAKPOINT
693 printk ("TRAP: Entering kernel PC=%lx, nPC=%lx\n", regs->tpc, regs->tnpc);
695 info.si_signo = SIGTRAP;
697 info.si_code = TRAP_BRKPT;
698 info.si_addr = (void __user *)regs->tpc;
700 force_sig_info(SIGTRAP, &info, current);
701 #ifdef DEBUG_SPARC_BREAKPOINT
702 printk ("TRAP: Returning to space: PC=%lx nPC=%lx\n", regs->tpc, regs->tnpc);
706 extern void check_pending(int signum);
708 asmlinkage long sys_getdomainname(char __user *name, int len)
715 nlen = strlen(vx_new_uts(domainname)) + 1;
719 if (len > __NEW_UTS_LEN)
721 if (copy_to_user(name, vx_new_uts(domainname), len))
729 asmlinkage long solaris_syscall(struct pt_regs *regs)
733 regs->tpc = regs->tnpc;
735 if (test_thread_flag(TIF_32BIT)) {
736 regs->tpc &= 0xffffffff;
737 regs->tnpc &= 0xffffffff;
740 printk ("For Solaris binary emulation you need solaris module loaded\n");
743 send_sig(SIGSEGV, current, 1);
748 #ifndef CONFIG_SUNOS_EMUL
749 asmlinkage long sunos_syscall(struct pt_regs *regs)
753 regs->tpc = regs->tnpc;
755 if (test_thread_flag(TIF_32BIT)) {
756 regs->tpc &= 0xffffffff;
757 regs->tnpc &= 0xffffffff;
760 printk ("SunOS binary emulation not compiled in\n");
761 force_sig(SIGSEGV, current);
767 asmlinkage long sys_utrap_install(utrap_entry_t type,
768 utrap_handler_t new_p,
769 utrap_handler_t new_d,
770 utrap_handler_t __user *old_p,
771 utrap_handler_t __user *old_d)
773 if (type < UT_INSTRUCTION_EXCEPTION || type > UT_TRAP_INSTRUCTION_31)
775 if (new_p == (utrap_handler_t)(long)UTH_NOCHANGE) {
777 if (!current_thread_info()->utraps) {
778 if (put_user(NULL, old_p))
781 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
786 if (put_user(NULL, old_d))
791 if (!current_thread_info()->utraps) {
792 current_thread_info()->utraps =
793 kzalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long), GFP_KERNEL);
794 if (!current_thread_info()->utraps)
796 current_thread_info()->utraps[0] = 1;
798 if ((utrap_handler_t)current_thread_info()->utraps[type] != new_p &&
799 current_thread_info()->utraps[0] > 1) {
800 long *p = current_thread_info()->utraps;
802 current_thread_info()->utraps =
803 kmalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long),
805 if (!current_thread_info()->utraps) {
806 current_thread_info()->utraps = p;
810 current_thread_info()->utraps[0] = 1;
811 memcpy(current_thread_info()->utraps+1, p+1,
812 UT_TRAP_INSTRUCTION_31*sizeof(long));
816 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
820 if (put_user(NULL, old_d))
823 current_thread_info()->utraps[type] = (long)new_p;
828 long sparc_memory_ordering(unsigned long model, struct pt_regs *regs)
832 regs->tstate = (regs->tstate & ~TSTATE_MM) | (model << 14);
836 asmlinkage long sys_rt_sigaction(int sig,
837 const struct sigaction __user *act,
838 struct sigaction __user *oact,
839 void __user *restorer,
842 struct k_sigaction new_ka, old_ka;
845 /* XXX: Don't preclude handling different sized sigset_t's. */
846 if (sigsetsize != sizeof(sigset_t))
850 new_ka.ka_restorer = restorer;
851 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
855 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
858 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
865 /* Invoked by rtrap code to update performance counters in
868 asmlinkage void update_perfctrs(void)
870 unsigned long pic, tmp;
873 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
874 __put_user(tmp, current_thread_info()->user_cntd0);
875 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
876 __put_user(tmp, current_thread_info()->user_cntd1);
880 asmlinkage long sys_perfctr(int opcode, unsigned long arg0, unsigned long arg1, unsigned long arg2)
886 current_thread_info()->pcr_reg = arg2;
887 current_thread_info()->user_cntd0 = (u64 __user *) arg0;
888 current_thread_info()->user_cntd1 = (u64 __user *) arg1;
889 current_thread_info()->kernel_cntd0 =
890 current_thread_info()->kernel_cntd1 = 0;
893 set_thread_flag(TIF_PERFCTR);
898 if (test_thread_flag(TIF_PERFCTR)) {
899 current_thread_info()->user_cntd0 =
900 current_thread_info()->user_cntd1 = NULL;
901 current_thread_info()->pcr_reg = 0;
903 clear_thread_flag(TIF_PERFCTR);
909 unsigned long pic, tmp;
911 if (!test_thread_flag(TIF_PERFCTR)) {
916 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
917 err |= __put_user(tmp, current_thread_info()->user_cntd0);
918 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
919 err |= __put_user(tmp, current_thread_info()->user_cntd1);
925 if (!test_thread_flag(TIF_PERFCTR)) {
929 current_thread_info()->kernel_cntd0 =
930 current_thread_info()->kernel_cntd1 = 0;
934 case PERFCTR_SETPCR: {
935 u64 __user *user_pcr = (u64 __user *)arg0;
937 if (!test_thread_flag(TIF_PERFCTR)) {
941 err |= __get_user(current_thread_info()->pcr_reg, user_pcr);
942 write_pcr(current_thread_info()->pcr_reg);
943 current_thread_info()->kernel_cntd0 =
944 current_thread_info()->kernel_cntd1 = 0;
949 case PERFCTR_GETPCR: {
950 u64 __user *user_pcr = (u64 __user *)arg0;
952 if (!test_thread_flag(TIF_PERFCTR)) {
956 err |= __put_user(current_thread_info()->pcr_reg, user_pcr);