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 asmlinkage
unsigned long sys_getpagesize(void)
32 return PAGE_SIZE
; /* Possibly older binaries want 8192 on sun4's? */
35 #define COLOUR_ALIGN(addr) (((addr)+SHMLBA-1)&~(SHMLBA-1))
37 unsigned long arch_get_unmapped_area(struct file
*filp
, unsigned long addr
, unsigned long len
, unsigned long pgoff
, unsigned long flags
)
39 struct vm_area_struct
* vmm
;
41 if (flags
& MAP_FIXED
) {
42 /* We do not accept a shared mapping if it would violate
43 * cache aliasing constraints.
45 if ((flags
& MAP_SHARED
) &&
46 ((addr
- (pgoff
<< PAGE_SHIFT
)) & (SHMLBA
- 1)))
51 /* See asm-sparc/uaccess.h */
52 if (len
> TASK_SIZE
- PAGE_SIZE
)
54 if (ARCH_SUN4C
&& len
> 0x20000000)
57 addr
= TASK_UNMAPPED_BASE
;
59 if (flags
& MAP_SHARED
)
60 addr
= COLOUR_ALIGN(addr
);
62 addr
= PAGE_ALIGN(addr
);
64 for (vmm
= find_vma(current
->mm
, addr
); ; vmm
= vmm
->vm_next
) {
65 /* At this point: (!vmm || addr < vmm->vm_end). */
66 if (ARCH_SUN4C
&& addr
< 0xe0000000 && 0x20000000 - len
< addr
) {
68 vmm
= find_vma(current
->mm
, PAGE_OFFSET
);
70 if (TASK_SIZE
- PAGE_SIZE
- len
< addr
)
72 if (!vmm
|| addr
+ len
<= vmm
->vm_start
)
75 if (flags
& MAP_SHARED
)
76 addr
= COLOUR_ALIGN(addr
);
81 * sys_pipe() is the normal C calling standard for creating
82 * a pipe. It's not the way unix traditionally does this, though.
84 asmlinkage
int sparc_pipe(struct pt_regs
*regs
)
89 error
= do_pipe_flags(fd
, 0);
92 regs
->u_regs
[UREG_I1
] = fd
[1];
98 int sparc_mmap_check(unsigned long addr
, unsigned long len
)
102 (addr
< 0xe0000000 && addr
+ len
> 0x20000000)))
105 /* See asm-sparc/uaccess.h */
106 if (len
> TASK_SIZE
- PAGE_SIZE
|| addr
+ len
> TASK_SIZE
- PAGE_SIZE
)
112 /* Linux version of mmap */
114 asmlinkage
unsigned long sys_mmap2(unsigned long addr
, unsigned long len
,
115 unsigned long prot
, unsigned long flags
, unsigned long fd
,
118 /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE
120 return sys_mmap_pgoff(addr
, len
, prot
, flags
, fd
,
121 pgoff
>> (PAGE_SHIFT
- 12));
124 asmlinkage
unsigned long sys_mmap(unsigned long addr
, unsigned long len
,
125 unsigned long prot
, unsigned long flags
, unsigned long fd
,
128 /* no alignment check? */
129 return sys_mmap_pgoff(addr
, len
, prot
, flags
, fd
, off
>> PAGE_SHIFT
);
132 long sparc_remap_file_pages(unsigned long start
, unsigned long size
,
133 unsigned long prot
, unsigned long pgoff
,
136 /* This works on an existing mmap so we don't need to validate
137 * the range as that was done at the original mmap call.
139 return sys_remap_file_pages(start
, size
, prot
,
140 (pgoff
>> (PAGE_SHIFT
- 12)), flags
);
143 /* we come to here via sys_nis_syscall so it can setup the regs argument */
144 asmlinkage
unsigned long
145 c_sys_nis_syscall (struct pt_regs
*regs
)
147 static int count
= 0;
151 printk ("%s[%d]: Unimplemented SPARC system call %d\n",
152 current
->comm
, task_pid_nr(current
), (int)regs
->u_regs
[1]);
153 #ifdef DEBUG_UNIMP_SYSCALL
159 /* #define DEBUG_SPARC_BREAKPOINT */
162 sparc_breakpoint (struct pt_regs
*regs
)
166 #ifdef DEBUG_SPARC_BREAKPOINT
167 printk ("TRAP: Entering kernel PC=%x, nPC=%x\n", regs
->pc
, regs
->npc
);
169 info
.si_signo
= SIGTRAP
;
171 info
.si_code
= TRAP_BRKPT
;
172 info
.si_addr
= (void __user
*)regs
->pc
;
174 force_sig_info(SIGTRAP
, &info
, current
);
176 #ifdef DEBUG_SPARC_BREAKPOINT
177 printk ("TRAP: Returning to space: PC=%x nPC=%x\n", regs
->pc
, regs
->npc
);
182 sparc_sigaction (int sig
, const struct old_sigaction __user
*act
,
183 struct old_sigaction __user
*oact
)
185 struct k_sigaction new_ka
, old_ka
;
188 WARN_ON_ONCE(sig
>= 0);
194 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)) ||
195 __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
) ||
196 __get_user(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
))
198 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
199 __get_user(mask
, &act
->sa_mask
);
200 siginitset(&new_ka
.sa
.sa_mask
, mask
);
201 new_ka
.ka_restorer
= NULL
;
204 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
207 /* In the clone() case we could copy half consistent
208 * state to the user, however this could sleep and
209 * deadlock us if we held the signal lock on SMP. So for
210 * now I take the easy way out and do no locking.
212 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
213 __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
) ||
214 __put_user(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
))
216 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
217 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
224 sys_rt_sigaction(int sig
,
225 const struct sigaction __user
*act
,
226 struct sigaction __user
*oact
,
227 void __user
*restorer
,
230 struct k_sigaction new_ka
, old_ka
;
233 if (sigsetsize
!= sizeof(sigset_t
))
237 new_ka
.ka_restorer
= restorer
;
238 if (copy_from_user(&new_ka
.sa
, act
, sizeof(*act
)))
242 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
245 if (copy_to_user(oact
, &old_ka
.sa
, sizeof(*oact
)))
252 asmlinkage
int sys_getdomainname(char __user
*name
, int len
)
261 nlen
= strlen(utsname()->domainname
) + 1;
267 if (!copy_to_user(name
, utsname()->domainname
, nlen
))
276 * Do a system call from kernel instead of calling sys_execve so we
277 * end up with proper pt_regs.
279 int kernel_execve(const char *filename
,
280 const char *const argv
[],
281 const char *const envp
[])
284 register long __g1
__asm__ ("g1") = __NR_execve
;
285 register long __o0
__asm__ ("o0") = (long)(filename
);
286 register long __o1
__asm__ ("o1") = (long)(argv
);
287 register long __o2
__asm__ ("o2") = (long)(envp
);
288 asm volatile ("t 0x10\n\t"
291 "sub %%g0, %%o0, %0\n\t"
293 : "=r" (__res
), "=&r" (__o0
)
294 : "1" (__o0
), "r" (__o1
), "r" (__o2
), "r" (__g1
)