1 /* linux/arch/sparc/kernel/sys_sparc.c
3 * This file contains various random system calls that
4 * have a non-standard calling sequence on the Linux/sparc
8 #include <linux/errno.h>
9 #include <linux/types.h>
10 #include <linux/sched.h>
13 #include <linux/file.h>
14 #include <linux/sem.h>
15 #include <linux/msg.h>
16 #include <linux/shm.h>
17 #include <linux/stat.h>
18 #include <linux/syscalls.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/ipc.h>
25 #include <asm/uaccess.h>
26 #include <asm/unistd.h>
28 /* #define DEBUG_UNIMP_SYSCALL */
30 /* XXX Make this per-binary type, this way we can detect the type of
31 * XXX a binary. Every Sparc executable calls this very early on.
33 asmlinkage
unsigned long sys_getpagesize(void)
35 return PAGE_SIZE
; /* Possibly older binaries want 8192 on sun4's? */
38 #define COLOUR_ALIGN(addr) (((addr)+SHMLBA-1)&~(SHMLBA-1))
40 unsigned long arch_get_unmapped_area(struct file
*filp
, unsigned long addr
, unsigned long len
, unsigned long pgoff
, unsigned long flags
)
42 struct vm_area_struct
* vmm
;
44 if (flags
& MAP_FIXED
) {
45 /* We do not accept a shared mapping if it would violate
46 * cache aliasing constraints.
48 if ((flags
& MAP_SHARED
) &&
49 ((addr
- (pgoff
<< PAGE_SHIFT
)) & (SHMLBA
- 1)))
54 /* See asm-sparc/uaccess.h */
55 if (len
> TASK_SIZE
- PAGE_SIZE
)
57 if (ARCH_SUN4C
&& len
> 0x20000000)
60 addr
= TASK_UNMAPPED_BASE
;
62 if (flags
& MAP_SHARED
)
63 addr
= COLOUR_ALIGN(addr
);
65 addr
= PAGE_ALIGN(addr
);
67 for (vmm
= find_vma(current
->mm
, addr
); ; vmm
= vmm
->vm_next
) {
68 /* At this point: (!vmm || addr < vmm->vm_end). */
69 if (ARCH_SUN4C
&& addr
< 0xe0000000 && 0x20000000 - len
< addr
) {
71 vmm
= find_vma(current
->mm
, PAGE_OFFSET
);
73 if (TASK_SIZE
- PAGE_SIZE
- len
< addr
)
75 if (!vmm
|| addr
+ len
<= vmm
->vm_start
)
78 if (flags
& MAP_SHARED
)
79 addr
= COLOUR_ALIGN(addr
);
84 * sys_pipe() is the normal C calling standard for creating
85 * a pipe. It's not the way unix traditionally does this, though.
87 asmlinkage
int sparc_pipe(struct pt_regs
*regs
)
92 error
= do_pipe_flags(fd
, 0);
95 regs
->u_regs
[UREG_I1
] = fd
[1];
102 * sys_ipc() is the de-multiplexer for the SysV IPC calls..
104 * This is really horribly ugly.
107 asmlinkage
int sys_ipc (uint call
, int first
, int second
, int third
, void __user
*ptr
, long fifth
)
111 version
= call
>> 16; /* hack for backward compatibility */
117 err
= sys_semtimedop (first
, (struct sembuf __user
*)ptr
, second
, NULL
);
120 err
= sys_semtimedop (first
, (struct sembuf __user
*)ptr
, second
, (const struct timespec __user
*) fifth
);
123 err
= sys_semget (first
, second
, third
);
131 if (get_user(fourth
.__pad
,
132 (void __user
* __user
*)ptr
))
134 err
= sys_semctl (first
, second
, third
, fourth
);
144 err
= sys_msgsnd (first
, (struct msgbuf __user
*) ptr
,
150 struct ipc_kludge tmp
;
155 if (copy_from_user(&tmp
, (struct ipc_kludge __user
*) ptr
, sizeof (tmp
)))
157 err
= sys_msgrcv (first
, tmp
.msgp
, second
, tmp
.msgtyp
, third
);
161 err
= sys_msgrcv (first
,
162 (struct msgbuf __user
*) ptr
,
163 second
, fifth
, third
);
167 err
= sys_msgget ((key_t
) first
, second
);
170 err
= sys_msgctl (first
, second
, (struct msqid_ds __user
*) ptr
);
182 err
= do_shmat (first
, (char __user
*) ptr
, second
, &raddr
);
186 if (put_user (raddr
, (ulong __user
*) third
))
191 case 1: /* iBCS2 emulator entry point */
196 err
= sys_shmdt ((char __user
*)ptr
);
199 err
= sys_shmget (first
, second
, third
);
202 err
= sys_shmctl (first
, second
, (struct shmid_ds __user
*) ptr
);
214 int sparc_mmap_check(unsigned long addr
, unsigned long len
)
218 (addr
< 0xe0000000 && addr
+ len
> 0x20000000)))
221 /* See asm-sparc/uaccess.h */
222 if (len
> TASK_SIZE
- PAGE_SIZE
|| addr
+ len
> TASK_SIZE
- PAGE_SIZE
)
228 /* Linux version of mmap */
230 asmlinkage
unsigned long sys_mmap2(unsigned long addr
, unsigned long len
,
231 unsigned long prot
, unsigned long flags
, unsigned long fd
,
234 /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
236 return sys_mmap_pgoff(addr
, len
, prot
, flags
, fd
,
237 pgoff
>> (PAGE_SHIFT
- 12));
240 asmlinkage
unsigned long sys_mmap(unsigned long addr
, unsigned long len
,
241 unsigned long prot
, unsigned long flags
, unsigned long fd
,
244 /* no alignment check? */
245 return sys_mmap_pgoff(addr
, len
, prot
, flags
, fd
, off
>> PAGE_SHIFT
);
248 long sparc_remap_file_pages(unsigned long start
, unsigned long size
,
249 unsigned long prot
, unsigned long pgoff
,
252 /* This works on an existing mmap so we don't need to validate
253 * the range as that was done at the original mmap call.
255 return sys_remap_file_pages(start
, size
, prot
,
256 (pgoff
>> (PAGE_SHIFT
- 12)), flags
);
259 /* we come to here via sys_nis_syscall so it can setup the regs argument */
260 asmlinkage
unsigned long
261 c_sys_nis_syscall (struct pt_regs
*regs
)
263 static int count
= 0;
267 printk ("%s[%d]: Unimplemented SPARC system call %d\n",
268 current
->comm
, task_pid_nr(current
), (int)regs
->u_regs
[1]);
269 #ifdef DEBUG_UNIMP_SYSCALL
275 /* #define DEBUG_SPARC_BREAKPOINT */
278 sparc_breakpoint (struct pt_regs
*regs
)
283 #ifdef DEBUG_SPARC_BREAKPOINT
284 printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs
->pc
, regs
->npc
);
286 info
.si_signo
= SIGTRAP
;
288 info
.si_code
= TRAP_BRKPT
;
289 info
.si_addr
= (void __user
*)regs
->pc
;
291 force_sig_info(SIGTRAP
, &info
, current
);
293 #ifdef DEBUG_SPARC_BREAKPOINT
294 printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs
->pc
, regs
->npc
);
300 sparc_sigaction (int sig
, const struct old_sigaction __user
*act
,
301 struct old_sigaction __user
*oact
)
303 struct k_sigaction new_ka
, old_ka
;
306 WARN_ON_ONCE(sig
>= 0);
312 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
313 __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
) ||
314 __get_user(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
))
316 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
317 __get_user(mask
, &act
->sa_mask
);
318 siginitset(&new_ka
.sa
.sa_mask
, mask
);
319 new_ka
.ka_restorer
= NULL
;
322 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
325 /* In the clone() case we could copy half consistent
326 * state to the user, however this could sleep and
327 * deadlock us if we held the signal lock on SMP. So for
328 * now I take the easy way out and do no locking.
330 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
331 __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
) ||
332 __put_user(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
))
334 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
335 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
342 sys_rt_sigaction(int sig
,
343 const struct sigaction __user
*act
,
344 struct sigaction __user
*oact
,
345 void __user
*restorer
,
348 struct k_sigaction new_ka
, old_ka
;
351 /* XXX: Don't preclude handling different sized sigset_t's. */
352 if (sigsetsize
!= sizeof(sigset_t
))
356 new_ka
.ka_restorer
= restorer
;
357 if (copy_from_user(&new_ka
.sa
, act
, sizeof(*act
)))
361 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
364 if (copy_to_user(oact
, &old_ka
.sa
, sizeof(*oact
)))
371 asmlinkage
int sys_getdomainname(char __user
*name
, int len
)
380 nlen
= strlen(utsname()->domainname
) + 1;
386 if (!copy_to_user(name
, utsname()->domainname
, nlen
))
395 * Do a system call from kernel instead of calling sys_execve so we
396 * end up with proper pt_regs.
398 int kernel_execve(const char *filename
, char *const argv
[], char *const envp
[])
401 register long __g1
__asm__ ("g1") = __NR_execve
;
402 register long __o0
__asm__ ("o0") = (long)(filename
);
403 register long __o1
__asm__ ("o1") = (long)(argv
);
404 register long __o2
__asm__ ("o2") = (long)(envp
);
405 asm volatile ("t 0x10\n\t"
408 "sub %%g0, %%o0, %0\n\t"
410 : "=r" (__res
), "=&r" (__o0
)
411 : "1" (__o0
), "r" (__o1
), "r" (__o2
), "r" (__g1
)