aboutsummaryrefslogtreecommitdiffstats
path: root/arch/sparc64/solaris/signal.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /arch/sparc64/solaris/signal.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'arch/sparc64/solaris/signal.c')
-rw-r--r--arch/sparc64/solaris/signal.c430
1 files changed, 430 insertions, 0 deletions
diff --git a/arch/sparc64/solaris/signal.c b/arch/sparc64/solaris/signal.c
new file mode 100644
index 000000000000..7fa2634e2085
--- /dev/null
+++ b/arch/sparc64/solaris/signal.c
@@ -0,0 +1,430 @@
1/* $Id: signal.c,v 1.7 2000/09/05 21:44:54 davem Exp $
2 * signal.c: Signal emulation for Solaris
3 *
4 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
5 */
6
7#include <linux/types.h>
8#include <linux/smp_lock.h>
9#include <linux/errno.h>
10
11#include <asm/uaccess.h>
12#include <asm/svr4.h>
13#include <asm/string.h>
14
15#include "conv.h"
16#include "signal.h"
17
18#define _S(nr) (1L<<((nr)-1))
19
20#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
21
22long linux_to_solaris_signals[] = {
23 0,
24 SOLARIS_SIGHUP, SOLARIS_SIGINT,
25 SOLARIS_SIGQUIT, SOLARIS_SIGILL,
26 SOLARIS_SIGTRAP, SOLARIS_SIGIOT,
27 SOLARIS_SIGEMT, SOLARIS_SIGFPE,
28 SOLARIS_SIGKILL, SOLARIS_SIGBUS,
29 SOLARIS_SIGSEGV, SOLARIS_SIGSYS,
30 SOLARIS_SIGPIPE, SOLARIS_SIGALRM,
31 SOLARIS_SIGTERM, SOLARIS_SIGURG,
32 SOLARIS_SIGSTOP, SOLARIS_SIGTSTP,
33 SOLARIS_SIGCONT, SOLARIS_SIGCLD,
34 SOLARIS_SIGTTIN, SOLARIS_SIGTTOU,
35 SOLARIS_SIGPOLL, SOLARIS_SIGXCPU,
36 SOLARIS_SIGXFSZ, SOLARIS_SIGVTALRM,
37 SOLARIS_SIGPROF, SOLARIS_SIGWINCH,
38 SOLARIS_SIGUSR1, SOLARIS_SIGUSR1,
39 SOLARIS_SIGUSR2, -1,
40};
41
42long solaris_to_linux_signals[] = {
43 0,
44 SIGHUP, SIGINT, SIGQUIT, SIGILL,
45 SIGTRAP, SIGIOT, SIGEMT, SIGFPE,
46 SIGKILL, SIGBUS, SIGSEGV, SIGSYS,
47 SIGPIPE, SIGALRM, SIGTERM, SIGUSR1,
48 SIGUSR2, SIGCHLD, -1, SIGWINCH,
49 SIGURG, SIGPOLL, SIGSTOP, SIGTSTP,
50 SIGCONT, SIGTTIN, SIGTTOU, SIGVTALRM,
51 SIGPROF, SIGXCPU, SIGXFSZ, -1,
52 -1, -1, -1, -1,
53 -1, -1, -1, -1,
54 -1, -1, -1, -1,
55};
56
57static inline long mapsig(long sig)
58{
59 if ((unsigned long)sig > SOLARIS_NSIGNALS)
60 return -EINVAL;
61 return solaris_to_linux_signals[sig];
62}
63
64asmlinkage int solaris_kill(int pid, int sig)
65{
66 int (*sys_kill)(int,int) =
67 (int (*)(int,int))SYS(kill);
68 int s = mapsig(sig);
69
70 if (s < 0) return s;
71 return sys_kill(pid, s);
72}
73
74static long sig_handler(int sig, u32 arg, int one_shot)
75{
76 struct sigaction sa, old;
77 int ret;
78 mm_segment_t old_fs = get_fs();
79 int (*sys_sigaction)(int,struct sigaction __user *,struct sigaction __user *) =
80 (int (*)(int,struct sigaction __user *,struct sigaction __user *))SYS(sigaction);
81
82 sigemptyset(&sa.sa_mask);
83 sa.sa_restorer = NULL;
84 sa.sa_handler = (__sighandler_t)A(arg);
85 sa.sa_flags = 0;
86 if (one_shot) sa.sa_flags = SA_ONESHOT | SA_NOMASK;
87 set_fs (KERNEL_DS);
88 ret = sys_sigaction(sig, (void __user *)&sa, (void __user *)&old);
89 set_fs (old_fs);
90 if (ret < 0) return ret;
91 return (u32)(unsigned long)old.sa_handler;
92}
93
94static inline long solaris_signal(int sig, u32 arg)
95{
96 return sig_handler (sig, arg, 1);
97}
98
99static long solaris_sigset(int sig, u32 arg)
100{
101 if (arg != 2) /* HOLD */ {
102 spin_lock_irq(&current->sighand->siglock);
103 sigdelsetmask(&current->blocked, _S(sig));
104 recalc_sigpending();
105 spin_unlock_irq(&current->sighand->siglock);
106 return sig_handler (sig, arg, 0);
107 } else {
108 spin_lock_irq(&current->sighand->siglock);
109 sigaddsetmask(&current->blocked, (_S(sig) & ~_BLOCKABLE));
110 recalc_sigpending();
111 spin_unlock_irq(&current->sighand->siglock);
112 return 0;
113 }
114}
115
116static inline long solaris_sighold(int sig)
117{
118 return solaris_sigset(sig, 2);
119}
120
121static inline long solaris_sigrelse(int sig)
122{
123 spin_lock_irq(&current->sighand->siglock);
124 sigdelsetmask(&current->blocked, _S(sig));
125 recalc_sigpending();
126 spin_unlock_irq(&current->sighand->siglock);
127 return 0;
128}
129
130static inline long solaris_sigignore(int sig)
131{
132 return sig_handler(sig, (u32)(unsigned long)SIG_IGN, 0);
133}
134
135static inline long solaris_sigpause(int sig)
136{
137 printk ("Need to support solaris sigpause\n");
138 return -ENOSYS;
139}
140
141asmlinkage long solaris_sigfunc(int sig, u32 arg)
142{
143 int func = sig & ~0xff;
144
145 sig = mapsig(sig & 0xff);
146 if (sig < 0) return sig;
147 switch (func) {
148 case 0: return solaris_signal(sig, arg);
149 case 0x100: return solaris_sigset(sig, arg);
150 case 0x200: return solaris_sighold(sig);
151 case 0x400: return solaris_sigrelse(sig);
152 case 0x800: return solaris_sigignore(sig);
153 case 0x1000: return solaris_sigpause(sig);
154 }
155 return -EINVAL;
156}
157
158typedef struct {
159 u32 __sigbits[4];
160} sol_sigset_t;
161
162static inline int mapin(u32 *p, sigset_t *q)
163{
164 int i;
165 u32 x;
166 int sig;
167
168 sigemptyset(q);
169 x = p[0];
170 for (i = 1; i <= SOLARIS_NSIGNALS; i++) {
171 if (x & 1) {
172 sig = solaris_to_linux_signals[i];
173 if (sig == -1)
174 return -EINVAL;
175 sigaddsetmask(q, (1L << (sig - 1)));
176 }
177 x >>= 1;
178 if (i == 32)
179 x = p[1];
180 }
181 return 0;
182}
183
184static inline int mapout(sigset_t *q, u32 *p)
185{
186 int i;
187 int sig;
188
189 p[0] = 0;
190 p[1] = 0;
191 for (i = 1; i <= 32; i++) {
192 if (sigismember(q, sigmask(i))) {
193 sig = linux_to_solaris_signals[i];
194 if (sig == -1)
195 return -EINVAL;
196 if (sig > 32)
197 p[1] |= 1L << (sig - 33);
198 else
199 p[0] |= 1L << (sig - 1);
200 }
201 }
202 return 0;
203}
204
205asmlinkage int solaris_sigprocmask(int how, u32 in, u32 out)
206{
207 sigset_t in_s, *ins, out_s, *outs;
208 mm_segment_t old_fs = get_fs();
209 int ret;
210 int (*sys_sigprocmask)(int,sigset_t __user *,sigset_t __user *) =
211 (int (*)(int,sigset_t __user *,sigset_t __user *))SYS(sigprocmask);
212
213 ins = NULL; outs = NULL;
214 if (in) {
215 u32 tmp[2];
216
217 if (copy_from_user (tmp, (void __user *)A(in), 2*sizeof(u32)))
218 return -EFAULT;
219 ins = &in_s;
220 if (mapin (tmp, ins)) return -EINVAL;
221 }
222 if (out) outs = &out_s;
223 set_fs (KERNEL_DS);
224 ret = sys_sigprocmask((how == 3) ? SIG_SETMASK : how,
225 (void __user *)ins, (void __user *)outs);
226 set_fs (old_fs);
227 if (ret) return ret;
228 if (out) {
229 u32 tmp[4];
230
231 tmp[2] = 0; tmp[3] = 0;
232 if (mapout (outs, tmp)) return -EINVAL;
233 if (copy_to_user((void __user *)A(out), tmp, 4*sizeof(u32)))
234 return -EFAULT;
235 }
236 return 0;
237}
238
239asmlinkage long do_sol_sigsuspend(u32 mask)
240{
241 sigset_t s;
242 u32 tmp[2];
243
244 if (copy_from_user (tmp, (sol_sigset_t __user *)A(mask), 2*sizeof(u32)))
245 return -EFAULT;
246 if (mapin (tmp, &s)) return -EINVAL;
247 return (long)s.sig[0];
248}
249
250struct sol_sigaction {
251 int sa_flags;
252 u32 sa_handler;
253 u32 sa_mask[4];
254 int sa_resv[2];
255};
256
257asmlinkage int solaris_sigaction(int sig, u32 act, u32 old)
258{
259 u32 tmp, tmp2[4];
260 struct sigaction s, s2;
261 int ret;
262 mm_segment_t old_fs = get_fs();
263 struct sol_sigaction __user *p = (void __user *)A(old);
264 int (*sys_sigaction)(int,struct sigaction __user *,struct sigaction __user *) =
265 (int (*)(int,struct sigaction __user *,struct sigaction __user *))SYS(sigaction);
266
267 sig = mapsig(sig);
268 if (sig < 0) {
269 /* We cheat a little bit for Solaris only signals */
270 if (old && clear_user(p, sizeof(struct sol_sigaction)))
271 return -EFAULT;
272 return 0;
273 }
274 if (act) {
275 if (get_user (tmp, &p->sa_flags))
276 return -EFAULT;
277 s.sa_flags = 0;
278 if (tmp & SOLARIS_SA_ONSTACK) s.sa_flags |= SA_STACK;
279 if (tmp & SOLARIS_SA_RESTART) s.sa_flags |= SA_RESTART;
280 if (tmp & SOLARIS_SA_NODEFER) s.sa_flags |= SA_NOMASK;
281 if (tmp & SOLARIS_SA_RESETHAND) s.sa_flags |= SA_ONESHOT;
282 if (tmp & SOLARIS_SA_NOCLDSTOP) s.sa_flags |= SA_NOCLDSTOP;
283 if (get_user (tmp, &p->sa_handler) ||
284 copy_from_user (tmp2, &p->sa_mask, 2*sizeof(u32)))
285 return -EFAULT;
286 s.sa_handler = (__sighandler_t)A(tmp);
287 if (mapin (tmp2, &s.sa_mask)) return -EINVAL;
288 s.sa_restorer = NULL;
289 }
290 set_fs(KERNEL_DS);
291 ret = sys_sigaction(sig, act ? (void __user *)&s : NULL,
292 old ? (void __user *)&s2 : NULL);
293 set_fs(old_fs);
294 if (ret) return ret;
295 if (old) {
296 if (mapout (&s2.sa_mask, tmp2)) return -EINVAL;
297 tmp = 0; tmp2[2] = 0; tmp2[3] = 0;
298 if (s2.sa_flags & SA_STACK) tmp |= SOLARIS_SA_ONSTACK;
299 if (s2.sa_flags & SA_RESTART) tmp |= SOLARIS_SA_RESTART;
300 if (s2.sa_flags & SA_NOMASK) tmp |= SOLARIS_SA_NODEFER;
301 if (s2.sa_flags & SA_ONESHOT) tmp |= SOLARIS_SA_RESETHAND;
302 if (s2.sa_flags & SA_NOCLDSTOP) tmp |= SOLARIS_SA_NOCLDSTOP;
303 if (put_user (tmp, &p->sa_flags) ||
304 __put_user ((u32)(unsigned long)s2.sa_handler, &p->sa_handler) ||
305 copy_to_user (&p->sa_mask, tmp2, 4*sizeof(u32)))
306 return -EFAULT;
307 }
308 return 0;
309}
310
311asmlinkage int solaris_sigpending(int which, u32 set)
312{
313 sigset_t s;
314 u32 tmp[4];
315 switch (which) {
316 case 1: /* sigpending */
317 spin_lock_irq(&current->sighand->siglock);
318 sigandsets(&s, &current->blocked, &current->pending.signal);
319 recalc_sigpending();
320 spin_unlock_irq(&current->sighand->siglock);
321 break;
322 case 2: /* sigfillset - I just set signals which have linux equivalents */
323 sigfillset(&s);
324 break;
325 default: return -EINVAL;
326 }
327 if (mapout (&s, tmp)) return -EINVAL;
328 tmp[2] = 0; tmp[3] = 0;
329 if (copy_to_user ((u32 __user *)A(set), tmp, sizeof(tmp)))
330 return -EFAULT;
331 return 0;
332}
333
334asmlinkage int solaris_wait(u32 stat_loc)
335{
336 unsigned __user *p = (unsigned __user *)A(stat_loc);
337 int (*sys_wait4)(pid_t,unsigned __user *, int, struct rusage __user *) =
338 (int (*)(pid_t,unsigned __user *, int, struct rusage __user *))SYS(wait4);
339 int ret, status;
340
341 ret = sys_wait4(-1, p, WUNTRACED, NULL);
342 if (ret >= 0 && stat_loc) {
343 if (get_user (status, p))
344 return -EFAULT;
345 if (((status - 1) & 0xffff) < 0xff)
346 status = linux_to_solaris_signals[status & 0x7f] & 0x7f;
347 else if ((status & 0xff) == 0x7f)
348 status = (linux_to_solaris_signals[(status >> 8) & 0xff] << 8) | 0x7f;
349 if (__put_user (status, p))
350 return -EFAULT;
351 }
352 return ret;
353}
354
355asmlinkage int solaris_waitid(int idtype, s32 pid, u32 info, int options)
356{
357 int (*sys_wait4)(pid_t,unsigned __user *, int, struct rusage __user *) =
358 (int (*)(pid_t,unsigned __user *, int, struct rusage __user *))SYS(wait4);
359 int opts, status, ret;
360
361 switch (idtype) {
362 case 0: /* P_PID */ break;
363 case 1: /* P_PGID */ pid = -pid; break;
364 case 7: /* P_ALL */ pid = -1; break;
365 default: return -EINVAL;
366 }
367 opts = 0;
368 if (options & SOLARIS_WUNTRACED) opts |= WUNTRACED;
369 if (options & SOLARIS_WNOHANG) opts |= WNOHANG;
370 current->state = TASK_RUNNING;
371 ret = sys_wait4(pid, (unsigned int __user *)A(info), opts, NULL);
372 if (ret < 0) return ret;
373 if (info) {
374 struct sol_siginfo __user *s = (void __user *)A(info);
375
376 if (get_user (status, (unsigned int __user *)A(info)))
377 return -EFAULT;
378
379 if (__put_user (SOLARIS_SIGCLD, &s->si_signo) ||
380 __put_user (ret, &s->_data._proc._pid))
381 return -EFAULT;
382
383 switch (status & 0xff) {
384 case 0: ret = SOLARIS_CLD_EXITED;
385 status = (status >> 8) & 0xff;
386 break;
387 case 0x7f:
388 status = (status >> 8) & 0xff;
389 switch (status) {
390 case SIGSTOP:
391 case SIGTSTP: ret = SOLARIS_CLD_STOPPED;
392 default: ret = SOLARIS_CLD_EXITED;
393 }
394 status = linux_to_solaris_signals[status];
395 break;
396 default:
397 if (status & 0x80) ret = SOLARIS_CLD_DUMPED;
398 else ret = SOLARIS_CLD_KILLED;
399 status = linux_to_solaris_signals[status & 0x7f];
400 break;
401 }
402
403 if (__put_user (ret, &s->si_code) ||
404 __put_user (status, &s->_data._proc._pdata._cld._status))
405 return -EFAULT;
406 }
407 return 0;
408}
409
410extern int svr4_setcontext(svr4_ucontext_t *c, struct pt_regs *regs);
411extern int svr4_getcontext(svr4_ucontext_t *c, struct pt_regs *regs);
412
413asmlinkage int solaris_context(struct pt_regs *regs)
414{
415 switch ((unsigned)regs->u_regs[UREG_I0]) {
416 case 0: /* getcontext */
417 return svr4_getcontext((svr4_ucontext_t *)(long)(u32)regs->u_regs[UREG_I1], regs);
418 case 1: /* setcontext */
419 return svr4_setcontext((svr4_ucontext_t *)(long)(u32)regs->u_regs[UREG_I1], regs);
420 default:
421 return -EINVAL;
422
423 }
424}
425
426asmlinkage int solaris_sigaltstack(u32 ss, u32 oss)
427{
428/* XXX Implement this soon */
429 return 0;
430}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-29 05:56:32 -0500