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/vs_cvirt.h>
30 #include <asm/uaccess.h>
32 #include <asm/utrap.h>
33 #include <asm/perfctr.h>
35 /* #define DEBUG_UNIMP_SYSCALL */
37 /* XXX Make this per-binary type, this way we can detect the type of
38 * XXX a binary. Every Sparc executable calls this very early on.
40 asmlinkage unsigned long sys_getpagesize(void)
45 #define COLOUR_ALIGN(addr,pgoff) \
46 ((((addr)+SHMLBA-1)&~(SHMLBA-1)) + \
47 (((pgoff)<<PAGE_SHIFT) & (SHMLBA-1)))
49 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags)
51 struct mm_struct *mm = current->mm;
52 struct vm_area_struct * vma;
53 unsigned long task_size = TASK_SIZE;
54 unsigned long start_addr;
57 if (flags & MAP_FIXED) {
58 /* We do not accept a shared mapping if it would violate
59 * cache aliasing constraints.
61 if ((flags & MAP_SHARED) &&
62 ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1)))
67 if (test_thread_flag(TIF_32BIT))
68 task_size = 0xf0000000UL;
69 if (len > task_size || len > -PAGE_OFFSET)
73 if (filp || (flags & MAP_SHARED))
78 addr = COLOUR_ALIGN(addr, pgoff);
80 addr = PAGE_ALIGN(addr);
82 vma = find_vma(mm, addr);
83 if (task_size - len >= addr &&
84 (!vma || addr + len <= vma->vm_start))
88 if (len <= mm->cached_hole_size) {
89 mm->cached_hole_size = 0;
90 mm->free_area_cache = TASK_UNMAPPED_BASE;
92 start_addr = addr = mm->free_area_cache;
98 addr = COLOUR_ALIGN(addr, pgoff);
100 addr = PAGE_ALIGN(addr);
102 for (vma = find_vma(mm, addr); ; vma = vma->vm_next) {
103 /* At this point: (!vma || addr < vma->vm_end). */
104 if (addr < PAGE_OFFSET && -PAGE_OFFSET - len < addr) {
106 vma = find_vma(mm, PAGE_OFFSET);
108 if (task_size < addr) {
109 if (start_addr != TASK_UNMAPPED_BASE) {
110 start_addr = addr = TASK_UNMAPPED_BASE;
111 mm->cached_hole_size = 0;
116 if (!vma || addr + len <= vma->vm_start) {
118 * Remember the place where we stopped the search:
120 mm->free_area_cache = addr + len;
123 if (addr + mm->cached_hole_size < vma->vm_start)
124 mm->cached_hole_size = vma->vm_start - addr;
128 addr = COLOUR_ALIGN(addr, pgoff);
132 /* Try to align mapping such that we align it as much as possible. */
133 unsigned long get_fb_unmapped_area(struct file *filp, unsigned long orig_addr, unsigned long len, unsigned long pgoff, unsigned long flags)
135 unsigned long align_goal, addr = -ENOMEM;
137 if (flags & MAP_FIXED) {
138 /* Ok, don't mess with it. */
139 return get_unmapped_area(NULL, addr, len, pgoff, flags);
141 flags &= ~MAP_SHARED;
143 align_goal = PAGE_SIZE;
144 if (len >= (4UL * 1024 * 1024))
145 align_goal = (4UL * 1024 * 1024);
146 else if (len >= (512UL * 1024))
147 align_goal = (512UL * 1024);
148 else if (len >= (64UL * 1024))
149 align_goal = (64UL * 1024);
152 addr = get_unmapped_area(NULL, orig_addr, len + (align_goal - PAGE_SIZE), pgoff, flags);
153 if (!(addr & ~PAGE_MASK)) {
154 addr = (addr + (align_goal - 1UL)) & ~(align_goal - 1UL);
158 if (align_goal == (4UL * 1024 * 1024))
159 align_goal = (512UL * 1024);
160 else if (align_goal == (512UL * 1024))
161 align_goal = (64UL * 1024);
163 align_goal = PAGE_SIZE;
164 } while ((addr & ~PAGE_MASK) && align_goal > PAGE_SIZE);
166 /* Mapping is smaller than 64K or larger areas could not
169 if (addr & ~PAGE_MASK)
170 addr = get_unmapped_area(NULL, orig_addr, len, pgoff, flags);
175 asmlinkage unsigned long sparc_brk(unsigned long brk)
177 /* People could try to be nasty and use ta 0x6d in 32bit programs */
178 if (test_thread_flag(TIF_32BIT) &&
180 return current->mm->brk;
182 if ((current->mm->brk & PAGE_OFFSET) != (brk & PAGE_OFFSET))
183 return current->mm->brk;
188 * sys_pipe() is the normal C calling standard for creating
189 * a pipe. It's not the way unix traditionally does this, though.
191 asmlinkage long sparc_pipe(struct pt_regs *regs)
199 regs->u_regs[UREG_I1] = fd[1];
206 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
208 * This is really horribly ugly.
211 asmlinkage long sys_ipc(unsigned int call, int first, unsigned long second,
212 unsigned long third, void __user *ptr, long fifth)
216 /* No need for backward compatibility. We can start fresh... */
217 if (call <= SEMCTL) {
220 err = sys_semtimedop(first, ptr,
221 (unsigned)second, NULL);
224 err = sys_semtimedop(first, ptr, (unsigned)second,
225 (const struct timespec __user *) fifth);
228 err = sys_semget(first, (int)second, (int)third);
236 if (get_user(fourth.__pad,
237 (void __user * __user *) ptr))
239 err = sys_semctl(first, (int)second | IPC_64,
248 if (call <= MSGCTL) {
251 err = sys_msgsnd(first, ptr, (size_t)second,
255 err = sys_msgrcv(first, ptr, (size_t)second, fifth,
259 err = sys_msgget((key_t)first, (int)second);
262 err = sys_msgctl(first, (int)second | IPC_64, ptr);
269 if (call <= SHMCTL) {
273 err = do_shmat(first, ptr, (int)second, &raddr);
276 (ulong __user *) third))
282 err = sys_shmdt(ptr);
285 err = sys_shmget(first, (size_t)second, (int)third);
288 err = sys_shmctl(first, (int)second | IPC_64, ptr);
301 asmlinkage long sparc64_newuname(struct new_utsname __user *name)
303 int ret = sys_newuname(name);
305 if (current->personality == PER_LINUX32 && !ret) {
306 ret = (copy_to_user(name->machine, "sparc\0\0", 8)
312 asmlinkage long sparc64_personality(unsigned long personality)
316 if (current->personality == PER_LINUX32 &&
317 personality == PER_LINUX)
318 personality = PER_LINUX32;
319 ret = sys_personality(personality);
320 if (ret == PER_LINUX32)
326 int sparc64_mmap_check(unsigned long addr, unsigned long len,
329 if (test_thread_flag(TIF_32BIT)) {
330 if (len > 0xf0000000UL ||
331 ((flags & MAP_FIXED) && addr > 0xf0000000UL - len))
334 if (len > -PAGE_OFFSET ||
335 ((flags & MAP_FIXED) &&
336 addr < PAGE_OFFSET && addr + len > -PAGE_OFFSET))
343 /* Linux version of mmap */
344 asmlinkage unsigned long sys_mmap(unsigned long addr, unsigned long len,
345 unsigned long prot, unsigned long flags, unsigned long fd,
348 struct file * file = NULL;
349 unsigned long retval = -EBADF;
351 if (!(flags & MAP_ANONYMOUS)) {
356 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
357 len = PAGE_ALIGN(len);
359 down_write(¤t->mm->mmap_sem);
360 retval = do_mmap(file, addr, len, prot, flags, off);
361 up_write(¤t->mm->mmap_sem);
369 asmlinkage long sys64_munmap(unsigned long addr, size_t len)
373 if (len > -PAGE_OFFSET ||
374 (addr < PAGE_OFFSET && addr + len > -PAGE_OFFSET))
376 down_write(¤t->mm->mmap_sem);
377 ret = do_munmap(current->mm, addr, len);
378 up_write(¤t->mm->mmap_sem);
382 extern unsigned long do_mremap(unsigned long addr,
383 unsigned long old_len, unsigned long new_len,
384 unsigned long flags, unsigned long new_addr);
386 asmlinkage unsigned long sys64_mremap(unsigned long addr,
387 unsigned long old_len, unsigned long new_len,
388 unsigned long flags, unsigned long new_addr)
390 struct vm_area_struct *vma;
391 unsigned long ret = -EINVAL;
392 if (test_thread_flag(TIF_32BIT))
394 if (old_len > -PAGE_OFFSET || new_len > -PAGE_OFFSET)
396 if (addr < PAGE_OFFSET && addr + old_len > -PAGE_OFFSET)
398 down_write(¤t->mm->mmap_sem);
399 if (flags & MREMAP_FIXED) {
400 if (new_addr < PAGE_OFFSET &&
401 new_addr + new_len > -PAGE_OFFSET)
403 } else if (addr < PAGE_OFFSET && addr + new_len > -PAGE_OFFSET) {
404 unsigned long map_flags = 0;
405 struct file *file = NULL;
408 if (!(flags & MREMAP_MAYMOVE))
411 vma = find_vma(current->mm, addr);
413 if (vma->vm_flags & VM_SHARED)
414 map_flags |= MAP_SHARED;
418 /* MREMAP_FIXED checked above. */
419 new_addr = get_unmapped_area(file, addr, new_len,
420 vma ? vma->vm_pgoff : 0,
423 if (new_addr & ~PAGE_MASK)
425 flags |= MREMAP_FIXED;
427 ret = do_mremap(addr, old_len, new_len, flags, new_addr);
429 up_write(¤t->mm->mmap_sem);
434 /* we come to here via sys_nis_syscall so it can setup the regs argument */
435 asmlinkage unsigned long c_sys_nis_syscall(struct pt_regs *regs)
439 /* Don't make the system unusable, if someone goes stuck */
443 printk ("Unimplemented SPARC system call %ld\n",regs->u_regs[1]);
444 #ifdef DEBUG_UNIMP_SYSCALL
451 /* #define DEBUG_SPARC_BREAKPOINT */
453 asmlinkage void sparc_breakpoint(struct pt_regs *regs)
457 if (test_thread_flag(TIF_32BIT)) {
458 regs->tpc &= 0xffffffff;
459 regs->tnpc &= 0xffffffff;
461 #ifdef DEBUG_SPARC_BREAKPOINT
462 printk ("TRAP: Entering kernel PC=%lx, nPC=%lx\n", regs->tpc, regs->tnpc);
464 info.si_signo = SIGTRAP;
466 info.si_code = TRAP_BRKPT;
467 info.si_addr = (void __user *)regs->tpc;
469 force_sig_info(SIGTRAP, &info, current);
470 #ifdef DEBUG_SPARC_BREAKPOINT
471 printk ("TRAP: Returning to space: PC=%lx nPC=%lx\n", regs->tpc, regs->tnpc);
475 extern void check_pending(int signum);
477 asmlinkage long sys_getdomainname(char __user *name, int len)
484 nlen = strlen(vx_new_uts(domainname)) + 1;
488 if (len > __NEW_UTS_LEN)
490 if (copy_to_user(name, vx_new_uts(domainname), len))
498 asmlinkage long solaris_syscall(struct pt_regs *regs)
502 regs->tpc = regs->tnpc;
504 if (test_thread_flag(TIF_32BIT)) {
505 regs->tpc &= 0xffffffff;
506 regs->tnpc &= 0xffffffff;
509 printk ("For Solaris binary emulation you need solaris module loaded\n");
512 send_sig(SIGSEGV, current, 1);
517 #ifndef CONFIG_SUNOS_EMUL
518 asmlinkage long sunos_syscall(struct pt_regs *regs)
522 regs->tpc = regs->tnpc;
524 if (test_thread_flag(TIF_32BIT)) {
525 regs->tpc &= 0xffffffff;
526 regs->tnpc &= 0xffffffff;
529 printk ("SunOS binary emulation not compiled in\n");
530 force_sig(SIGSEGV, current);
536 asmlinkage long sys_utrap_install(utrap_entry_t type,
537 utrap_handler_t new_p,
538 utrap_handler_t new_d,
539 utrap_handler_t __user *old_p,
540 utrap_handler_t __user *old_d)
542 if (type < UT_INSTRUCTION_EXCEPTION || type > UT_TRAP_INSTRUCTION_31)
544 if (new_p == (utrap_handler_t)(long)UTH_NOCHANGE) {
546 if (!current_thread_info()->utraps) {
547 if (put_user(NULL, old_p))
550 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
555 if (put_user(NULL, old_d))
560 if (!current_thread_info()->utraps) {
561 current_thread_info()->utraps =
562 kmalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long), GFP_KERNEL);
563 if (!current_thread_info()->utraps)
565 current_thread_info()->utraps[0] = 1;
566 memset(current_thread_info()->utraps+1, 0,
567 UT_TRAP_INSTRUCTION_31*sizeof(long));
569 if ((utrap_handler_t)current_thread_info()->utraps[type] != new_p &&
570 current_thread_info()->utraps[0] > 1) {
571 long *p = current_thread_info()->utraps;
573 current_thread_info()->utraps =
574 kmalloc((UT_TRAP_INSTRUCTION_31+1)*sizeof(long),
576 if (!current_thread_info()->utraps) {
577 current_thread_info()->utraps = p;
581 current_thread_info()->utraps[0] = 1;
582 memcpy(current_thread_info()->utraps+1, p+1,
583 UT_TRAP_INSTRUCTION_31*sizeof(long));
587 if (put_user((utrap_handler_t)(current_thread_info()->utraps[type]), old_p))
591 if (put_user(NULL, old_d))
594 current_thread_info()->utraps[type] = (long)new_p;
599 long sparc_memory_ordering(unsigned long model, struct pt_regs *regs)
603 regs->tstate = (regs->tstate & ~TSTATE_MM) | (model << 14);
607 asmlinkage long sys_rt_sigaction(int sig,
608 const struct sigaction __user *act,
609 struct sigaction __user *oact,
610 void __user *restorer,
613 struct k_sigaction new_ka, old_ka;
616 /* XXX: Don't preclude handling different sized sigset_t's. */
617 if (sigsetsize != sizeof(sigset_t))
621 new_ka.ka_restorer = restorer;
622 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
626 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
629 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
636 /* Invoked by rtrap code to update performance counters in
639 asmlinkage void update_perfctrs(void)
641 unsigned long pic, tmp;
644 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
645 __put_user(tmp, current_thread_info()->user_cntd0);
646 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
647 __put_user(tmp, current_thread_info()->user_cntd1);
651 asmlinkage long sys_perfctr(int opcode, unsigned long arg0, unsigned long arg1, unsigned long arg2)
657 current_thread_info()->pcr_reg = arg2;
658 current_thread_info()->user_cntd0 = (u64 __user *) arg0;
659 current_thread_info()->user_cntd1 = (u64 __user *) arg1;
660 current_thread_info()->kernel_cntd0 =
661 current_thread_info()->kernel_cntd1 = 0;
664 set_thread_flag(TIF_PERFCTR);
669 if (test_thread_flag(TIF_PERFCTR)) {
670 current_thread_info()->user_cntd0 =
671 current_thread_info()->user_cntd1 = NULL;
672 current_thread_info()->pcr_reg = 0;
674 clear_thread_flag(TIF_PERFCTR);
680 unsigned long pic, tmp;
682 if (!test_thread_flag(TIF_PERFCTR)) {
687 tmp = (current_thread_info()->kernel_cntd0 += (unsigned int)pic);
688 err |= __put_user(tmp, current_thread_info()->user_cntd0);
689 tmp = (current_thread_info()->kernel_cntd1 += (pic >> 32));
690 err |= __put_user(tmp, current_thread_info()->user_cntd1);
696 if (!test_thread_flag(TIF_PERFCTR)) {
700 current_thread_info()->kernel_cntd0 =
701 current_thread_info()->kernel_cntd1 = 0;
705 case PERFCTR_SETPCR: {
706 u64 __user *user_pcr = (u64 __user *)arg0;
708 if (!test_thread_flag(TIF_PERFCTR)) {
712 err |= __get_user(current_thread_info()->pcr_reg, user_pcr);
713 write_pcr(current_thread_info()->pcr_reg);
714 current_thread_info()->kernel_cntd0 =
715 current_thread_info()->kernel_cntd1 = 0;
720 case PERFCTR_GETPCR: {
721 u64 __user *user_pcr = (u64 __user *)arg0;
723 if (!test_thread_flag(TIF_PERFCTR)) {
727 err |= __put_user(current_thread_info()->pcr_reg, user_pcr);