1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* linux/arch/sparc/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/signal.h> |
12 | #include <linux/sched/mm.h> |
13 | #include <linux/sched/debug.h> |
14 | #include <linux/mm.h> |
15 | #include <linux/fs.h> |
16 | #include <linux/file.h> |
17 | #include <linux/sem.h> |
18 | #include <linux/msg.h> |
19 | #include <linux/shm.h> |
20 | #include <linux/stat.h> |
21 | #include <linux/syscalls.h> |
22 | #include <linux/mman.h> |
23 | #include <linux/utsname.h> |
24 | #include <linux/smp.h> |
25 | #include <linux/ipc.h> |
26 | |
27 | #include <linux/uaccess.h> |
28 | #include <asm/unistd.h> |
29 | |
30 | #include "systbls.h" |
31 | |
32 | /* #define DEBUG_UNIMP_SYSCALL */ |
33 | |
34 | /* XXX Make this per-binary type, this way we can detect the type of |
35 | * XXX a binary. Every Sparc executable calls this very early on. |
36 | */ |
37 | SYSCALL_DEFINE0(getpagesize) |
38 | { |
39 | return PAGE_SIZE; /* Possibly older binaries want 8192 on sun4's? */ |
40 | } |
41 | |
42 | unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags) |
43 | { |
44 | struct vm_unmapped_area_info info; |
45 | |
46 | if (flags & MAP_FIXED) { |
47 | /* We do not accept a shared mapping if it would violate |
48 | * cache aliasing constraints. |
49 | */ |
50 | if ((flags & MAP_SHARED) && |
51 | ((addr - (pgoff << PAGE_SHIFT)) & (SHMLBA - 1))) |
52 | return -EINVAL; |
53 | return addr; |
54 | } |
55 | |
56 | /* See asm-sparc/uaccess.h */ |
57 | if (len > TASK_SIZE - PAGE_SIZE) |
58 | return -ENOMEM; |
59 | if (!addr) |
60 | addr = TASK_UNMAPPED_BASE; |
61 | |
62 | info.flags = 0; |
63 | info.length = len; |
64 | info.low_limit = addr; |
65 | info.high_limit = TASK_SIZE; |
66 | info.align_mask = (flags & MAP_SHARED) ? |
67 | (PAGE_MASK & (SHMLBA - 1)) : 0; |
68 | info.align_offset = pgoff << PAGE_SHIFT; |
69 | return vm_unmapped_area(info: &info); |
70 | } |
71 | |
72 | /* |
73 | * sys_pipe() is the normal C calling standard for creating |
74 | * a pipe. It's not the way unix traditionally does this, though. |
75 | */ |
76 | SYSCALL_DEFINE0(sparc_pipe) |
77 | { |
78 | int fd[2]; |
79 | int error; |
80 | |
81 | error = do_pipe_flags(fd, 0); |
82 | if (error) |
83 | goto out; |
84 | current_pt_regs()->u_regs[UREG_I1] = fd[1]; |
85 | error = fd[0]; |
86 | out: |
87 | return error; |
88 | } |
89 | |
90 | int sparc_mmap_check(unsigned long addr, unsigned long len) |
91 | { |
92 | /* See asm-sparc/uaccess.h */ |
93 | if (len > TASK_SIZE - PAGE_SIZE || addr + len > TASK_SIZE - PAGE_SIZE) |
94 | return -EINVAL; |
95 | |
96 | return 0; |
97 | } |
98 | |
99 | /* Linux version of mmap */ |
100 | |
101 | SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len, |
102 | unsigned long, prot, unsigned long, flags, unsigned long, fd, |
103 | unsigned long, pgoff) |
104 | { |
105 | /* Make sure the shift for mmap2 is constant (12), no matter what PAGE_SIZE |
106 | we have. */ |
107 | return ksys_mmap_pgoff(addr, len, prot, flags, fd, |
108 | pgoff: pgoff >> (PAGE_SHIFT - 12)); |
109 | } |
110 | |
111 | SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len, |
112 | unsigned long, prot, unsigned long, flags, unsigned long, fd, |
113 | unsigned long, off) |
114 | { |
115 | /* no alignment check? */ |
116 | return ksys_mmap_pgoff(addr, len, prot, flags, fd, pgoff: off >> PAGE_SHIFT); |
117 | } |
118 | |
119 | SYSCALL_DEFINE5(sparc_remap_file_pages, unsigned long, start, unsigned long, size, |
120 | unsigned long, prot, unsigned long, pgoff, |
121 | unsigned long, flags) |
122 | { |
123 | /* This works on an existing mmap so we don't need to validate |
124 | * the range as that was done at the original mmap call. |
125 | */ |
126 | return sys_remap_file_pages(start, size, prot, |
127 | (pgoff >> (PAGE_SHIFT - 12)), flags); |
128 | } |
129 | |
130 | SYSCALL_DEFINE0(nis_syscall) |
131 | { |
132 | static int count = 0; |
133 | struct pt_regs *regs = current_pt_regs(); |
134 | |
135 | if (count++ > 5) |
136 | return -ENOSYS; |
137 | printk ("%s[%d]: Unimplemented SPARC system call %d\n" , |
138 | current->comm, task_pid_nr(current), (int)regs->u_regs[1]); |
139 | #ifdef DEBUG_UNIMP_SYSCALL |
140 | show_regs (regs); |
141 | #endif |
142 | return -ENOSYS; |
143 | } |
144 | |
145 | /* #define DEBUG_SPARC_BREAKPOINT */ |
146 | |
147 | asmlinkage void |
148 | sparc_breakpoint (struct pt_regs *regs) |
149 | { |
150 | |
151 | #ifdef DEBUG_SPARC_BREAKPOINT |
152 | printk ("TRAP: Entering kernel PC=%x, nPC=%x\n" , regs->pc, regs->npc); |
153 | #endif |
154 | force_sig_fault(SIGTRAP, TRAP_BRKPT, addr: (void __user *)regs->pc); |
155 | |
156 | #ifdef DEBUG_SPARC_BREAKPOINT |
157 | printk ("TRAP: Returning to space: PC=%x nPC=%x\n" , regs->pc, regs->npc); |
158 | #endif |
159 | } |
160 | |
161 | SYSCALL_DEFINE3(sparc_sigaction, int, sig, |
162 | struct old_sigaction __user *,act, |
163 | struct old_sigaction __user *,oact) |
164 | { |
165 | WARN_ON_ONCE(sig >= 0); |
166 | return sys_sigaction(-sig, act, oact); |
167 | } |
168 | |
169 | SYSCALL_DEFINE5(rt_sigaction, int, sig, |
170 | const struct sigaction __user *, act, |
171 | struct sigaction __user *, oact, |
172 | void __user *, restorer, |
173 | size_t, sigsetsize) |
174 | { |
175 | struct k_sigaction new_ka, old_ka; |
176 | int ret; |
177 | |
178 | /* XXX: Don't preclude handling different sized sigset_t's. */ |
179 | if (sigsetsize != sizeof(sigset_t)) |
180 | return -EINVAL; |
181 | |
182 | if (act) { |
183 | new_ka.ka_restorer = restorer; |
184 | if (copy_from_user(to: &new_ka.sa, from: act, n: sizeof(*act))) |
185 | return -EFAULT; |
186 | } |
187 | |
188 | ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); |
189 | |
190 | if (!ret && oact) { |
191 | if (copy_to_user(to: oact, from: &old_ka.sa, n: sizeof(*oact))) |
192 | return -EFAULT; |
193 | } |
194 | |
195 | return ret; |
196 | } |
197 | |
198 | SYSCALL_DEFINE2(getdomainname, char __user *, name, int, len) |
199 | { |
200 | int nlen, err; |
201 | char tmp[__NEW_UTS_LEN + 1]; |
202 | |
203 | if (len < 0) |
204 | return -EINVAL; |
205 | |
206 | down_read(sem: &uts_sem); |
207 | |
208 | nlen = strlen(utsname()->domainname) + 1; |
209 | err = -EINVAL; |
210 | if (nlen > len) |
211 | goto out_unlock; |
212 | memcpy(tmp, utsname()->domainname, nlen); |
213 | |
214 | up_read(sem: &uts_sem); |
215 | |
216 | if (copy_to_user(to: name, from: tmp, n: nlen)) |
217 | return -EFAULT; |
218 | return 0; |
219 | |
220 | out_unlock: |
221 | up_read(sem: &uts_sem); |
222 | return err; |
223 | } |
224 | |