aboutsummaryrefslogtreecommitdiffstats
path: root/arch/parisc/kernel/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/parisc/kernel/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/parisc/kernel/signal.c')
-rw-r--r--arch/parisc/kernel/signal.c664
1 files changed, 664 insertions, 0 deletions
diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
new file mode 100644
index 000000000000..9421bb98ea63
--- /dev/null
+++ b/arch/parisc/kernel/signal.c
@@ -0,0 +1,664 @@
1/*
2 * linux/arch/parisc/kernel/signal.c: Architecture-specific signal
3 * handling support.
4 *
5 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
6 * Copyright (C) 2000 Linuxcare, Inc.
7 *
8 * Based on the ia64, i386, and alpha versions.
9 *
10 * Like the IA-64, we are a recent enough port (we are *starting*
11 * with glibc2.2) that we do not need to support the old non-realtime
12 * Linux signals. Therefore we don't. HP/UX signals will go in
13 * arch/parisc/hpux/signal.c when we figure out how to do them.
14 */
15
16#include <linux/sched.h>
17#include <linux/mm.h>
18#include <linux/smp.h>
19#include <linux/smp_lock.h>
20#include <linux/kernel.h>
21#include <linux/signal.h>
22#include <linux/errno.h>
23#include <linux/wait.h>
24#include <linux/ptrace.h>
25#include <linux/unistd.h>
26#include <linux/stddef.h>
27#include <linux/compat.h>
28#include <linux/elf.h>
29#include <linux/personality.h>
30#include <asm/ucontext.h>
31#include <asm/rt_sigframe.h>
32#include <asm/uaccess.h>
33#include <asm/pgalloc.h>
34#include <asm/cacheflush.h>
35#include <asm/offsets.h>
36
37#ifdef CONFIG_COMPAT
38#include <linux/compat.h>
39#include "signal32.h"
40#endif
41
42#define DEBUG_SIG 0
43#define DEBUG_SIG_LEVEL 2
44
45#if DEBUG_SIG
46#define DBG(LEVEL, ...) \
47 ((DEBUG_SIG_LEVEL >= LEVEL) \
48 ? printk(__VA_ARGS__) : (void) 0)
49#else
50#define DBG(LEVEL, ...)
51#endif
52
53
54#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
55
56/* gcc will complain if a pointer is cast to an integer of different
57 * size. If you really need to do this (and we do for an ELF32 user
58 * application in an ELF64 kernel) then you have to do a cast to an
59 * integer of the same size first. The A() macro accomplishes
60 * this. */
61#define A(__x) ((unsigned long)(__x))
62
63int do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall);
64
65/*
66 * Atomically swap in the new signal mask, and wait for a signal.
67 */
68#ifdef __LP64__
69#include "sys32.h"
70#endif
71
72asmlinkage int
73sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize, struct pt_regs *regs)
74{
75 sigset_t saveset, newset;
76#ifdef __LP64__
77 compat_sigset_t newset32;
78
79 if(personality(current->personality) == PER_LINUX32){
80 /* XXX: Don't preclude handling different sized sigset_t's. */
81 if (sigsetsize != sizeof(compat_sigset_t))
82 return -EINVAL;
83 if (copy_from_user(&newset32, (compat_sigset_t __user *)unewset, sizeof(newset32)))
84 return -EFAULT;
85 sigset_32to64(&newset,&newset32);
86
87 } else
88#endif
89 {
90 /* XXX: Don't preclude handling different sized sigset_t's. */
91 if (sigsetsize != sizeof(sigset_t))
92 return -EINVAL;
93
94 if (copy_from_user(&newset, unewset, sizeof(newset)))
95 return -EFAULT;
96 }
97
98 sigdelsetmask(&newset, ~_BLOCKABLE);
99
100 spin_lock_irq(&current->sighand->siglock);
101 saveset = current->blocked;
102 current->blocked = newset;
103 recalc_sigpending();
104 spin_unlock_irq(&current->sighand->siglock);
105
106 regs->gr[28] = -EINTR;
107 while (1) {
108 current->state = TASK_INTERRUPTIBLE;
109 schedule();
110 if (do_signal(&saveset, regs, 1))
111 return -EINTR;
112 }
113}
114
115/*
116 * Do a signal return - restore sigcontext.
117 */
118
119/* Trampoline for calling rt_sigreturn() */
120#define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
121#define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
122#define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
123#define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
124#define INSN_NOP 0x08000240 /* nop */
125/* For debugging */
126#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
127
128static long
129restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
130{
131 long err = 0;
132
133 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
134 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
135 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
136 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
137 err |= __get_user(regs->sar, &sc->sc_sar);
138 DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n",
139 regs->iaoq[0],regs->iaoq[1]);
140 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
141 return err;
142}
143
144void
145sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
146{
147 struct rt_sigframe __user *frame;
148 struct siginfo si;
149 sigset_t set;
150 unsigned long usp = (regs->gr[30] & ~(0x01UL));
151 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
152#ifdef __LP64__
153 compat_sigset_t compat_set;
154 struct compat_rt_sigframe __user * compat_frame;
155
156 if(personality(current->personality) == PER_LINUX32)
157 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
158#endif
159
160
161 /* Unwind the user stack to get the rt_sigframe structure. */
162 frame = (struct rt_sigframe __user *)
163 (usp - sigframe_size);
164 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
165
166#ifdef __LP64__
167 compat_frame = (struct compat_rt_sigframe __user *)frame;
168
169 if(personality(current->personality) == PER_LINUX32){
170 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
171 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
172 goto give_sigsegv;
173 sigset_32to64(&set,&compat_set);
174 } else
175#endif
176 {
177 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
178 goto give_sigsegv;
179 }
180
181 sigdelsetmask(&set, ~_BLOCKABLE);
182 spin_lock_irq(&current->sighand->siglock);
183 current->blocked = set;
184 recalc_sigpending();
185 spin_unlock_irq(&current->sighand->siglock);
186
187 /* Good thing we saved the old gr[30], eh? */
188#ifdef __LP64__
189 if(personality(current->personality) == PER_LINUX32){
190 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
191 &compat_frame->uc.uc_mcontext);
192// FIXME: Load upper half from register file
193 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
194 &compat_frame->regs, regs))
195 goto give_sigsegv;
196 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
197 usp, &compat_frame->uc.uc_stack);
198 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
199 goto give_sigsegv;
200 } else
201#endif
202 {
203 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
204 &frame->uc.uc_mcontext);
205 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
206 goto give_sigsegv;
207 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
208 usp, &frame->uc.uc_stack);
209 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
210 goto give_sigsegv;
211 }
212
213
214
215 /* If we are on the syscall path IAOQ will not be restored, and
216 * if we are on the interrupt path we must not corrupt gr31.
217 */
218 if (in_syscall)
219 regs->gr[31] = regs->iaoq[0];
220#if DEBUG_SIG
221 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
222 show_regs(regs);
223#endif
224 return;
225
226give_sigsegv:
227 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
228 si.si_signo = SIGSEGV;
229 si.si_errno = 0;
230 si.si_code = SI_KERNEL;
231 si.si_pid = current->pid;
232 si.si_uid = current->uid;
233 si.si_addr = &frame->uc;
234 force_sig_info(SIGSEGV, &si, current);
235 return;
236}
237
238/*
239 * Set up a signal frame.
240 */
241
242static inline void __user *
243get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
244{
245 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
246 don't use the parameter it doesn't matter */
247
248 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
249 (unsigned long)ka, sp, frame_size);
250
251 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
252 sp = current->sas_ss_sp; /* Stacks grow up! */
253
254 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
255 return (void __user *) sp; /* Stacks grow up. Fun. */
256}
257
258static long
259setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
260
261{
262 unsigned long flags = 0;
263 long err = 0;
264
265 if (on_sig_stack((unsigned long) sc))
266 flags |= PARISC_SC_FLAG_ONSTACK;
267 if (in_syscall) {
268 flags |= PARISC_SC_FLAG_IN_SYSCALL;
269 /* regs->iaoq is undefined in the syscall return path */
270 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
271 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
272 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
273 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
274 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
275 regs->gr[31], regs->gr[31]+4);
276 } else {
277 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
278 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
279 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
280 regs->iaoq[0], regs->iaoq[1]);
281 }
282
283 err |= __put_user(flags, &sc->sc_flags);
284 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
285 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
286 err |= __put_user(regs->sar, &sc->sc_sar);
287 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
288
289 return err;
290}
291
292static long
293setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
294 sigset_t *set, struct pt_regs *regs, int in_syscall)
295{
296 struct rt_sigframe __user *frame;
297 unsigned long rp, usp;
298 unsigned long haddr, sigframe_size;
299 struct siginfo si;
300 int err = 0;
301#ifdef __LP64__
302 compat_int_t compat_val;
303 struct compat_rt_sigframe __user * compat_frame;
304 compat_sigset_t compat_set;
305#endif
306
307 usp = (regs->gr[30] & ~(0x01UL));
308 /*FIXME: frame_size parameter is unused, remove it. */
309 frame = get_sigframe(ka, usp, sizeof(*frame));
310
311 DBG(1,"SETUP_RT_FRAME: START\n");
312 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
313
314
315#ifdef __LP64__
316
317 compat_frame = (struct compat_rt_sigframe __user *)frame;
318
319 if(personality(current->personality) == PER_LINUX32) {
320 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
321 err |= compat_copy_siginfo_to_user(&compat_frame->info, info);
322 DBG(1,"SETUP_RT_FRAME: 1\n");
323 compat_val = (compat_int_t)current->sas_ss_sp;
324 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
325 DBG(1,"SETUP_RT_FRAME: 2\n");
326 compat_val = (compat_int_t)current->sas_ss_size;
327 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
328 DBG(1,"SETUP_RT_FRAME: 3\n");
329 compat_val = sas_ss_flags(regs->gr[30]);
330 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);
331 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
332 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
333 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
334 &compat_frame->regs, regs, in_syscall);
335 sigset_64to32(&compat_set,set);
336 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
337 } else
338#endif
339 {
340 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
341 err |= copy_siginfo_to_user(&frame->info, info);
342 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
343 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
344 err |= __put_user(sas_ss_flags(regs->gr[30]),
345 &frame->uc.uc_stack.ss_flags);
346 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
347 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
348 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
349 /* FIXME: Should probably be converted aswell for the compat case */
350 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
351 }
352
353 if (err)
354 goto give_sigsegv;
355
356 /* Set up to return from userspace. If provided, use a stub
357 already in userspace. The first words of tramp are used to
358 save the previous sigrestartblock trampoline that might be
359 on the stack. We start the sigreturn trampoline at
360 SIGRESTARTBLOCK_TRAMP+X. */
361 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
362 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
363 err |= __put_user(INSN_LDI_R20,
364 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
365 err |= __put_user(INSN_BLE_SR2_R0,
366 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
367 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
368
369#if DEBUG_SIG
370 /* Assert that we're flushing in the correct space... */
371 {
372 int sid;
373 asm ("mfsp %%sr3,%0" : "=r" (sid));
374 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
375 sid, frame->tramp);
376 }
377#endif
378
379 flush_user_dcache_range((unsigned long) &frame->tramp[0],
380 (unsigned long) &frame->tramp[TRAMP_SIZE]);
381 flush_user_icache_range((unsigned long) &frame->tramp[0],
382 (unsigned long) &frame->tramp[TRAMP_SIZE]);
383
384 /* TRAMP Words 0-4, Lenght 5 = SIGRESTARTBLOCK_TRAMP
385 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
386 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
387 */
388 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
389
390 if (err)
391 goto give_sigsegv;
392
393 haddr = A(ka->sa.sa_handler);
394 /* The sa_handler may be a pointer to a function descriptor */
395#ifdef __LP64__
396 if(personality(current->personality) == PER_LINUX32) {
397#endif
398 if (haddr & PA_PLABEL_FDESC) {
399 Elf32_Fdesc fdesc;
400 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
401
402 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
403
404 if (err)
405 goto give_sigsegv;
406
407 haddr = fdesc.addr;
408 regs->gr[19] = fdesc.gp;
409 }
410#ifdef __LP64__
411 } else {
412 Elf64_Fdesc fdesc;
413 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
414
415 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
416
417 if (err)
418 goto give_sigsegv;
419
420 haddr = fdesc.addr;
421 regs->gr[19] = fdesc.gp;
422 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
423 haddr, regs->gr[19], in_syscall);
424 }
425#endif
426
427 /* The syscall return path will create IAOQ values from r31.
428 */
429 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
430#ifdef __LP64__
431 if(personality(current->personality) == PER_LINUX32)
432 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
433#endif
434 if (in_syscall) {
435 regs->gr[31] = haddr;
436#ifdef __LP64__
437 if(personality(current->personality) == PER_LINUX)
438 sigframe_size |= 1;
439#endif
440 } else {
441 unsigned long psw = USER_PSW;
442#ifdef __LP64__
443 if(personality(current->personality) == PER_LINUX)
444 psw |= PSW_W;
445#endif
446
447 /* If we are singlestepping, arrange a trap to be delivered
448 when we return to userspace. Note the semantics -- we
449 should trap before the first insn in the handler is
450 executed. Ref:
451 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
452 */
453 if (pa_psw(current)->r) {
454 pa_psw(current)->r = 0;
455 psw |= PSW_R;
456 mtctl(-1, 0);
457 }
458
459 regs->gr[0] = psw;
460 regs->iaoq[0] = haddr | 3;
461 regs->iaoq[1] = regs->iaoq[0] + 4;
462 }
463
464 regs->gr[2] = rp; /* userland return pointer */
465 regs->gr[26] = sig; /* signal number */
466
467#ifdef __LP64__
468 if(personality(current->personality) == PER_LINUX32){
469 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
470 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
471 } else
472#endif
473 {
474 regs->gr[25] = A(&frame->info); /* siginfo pointer */
475 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
476 }
477
478 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
479 regs->gr[30], sigframe_size,
480 regs->gr[30] + sigframe_size);
481 /* Raise the user stack pointer to make a proper call frame. */
482 regs->gr[30] = (A(frame) + sigframe_size);
483
484
485 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
486 current->comm, current->pid, frame, regs->gr[30],
487 regs->iaoq[0], regs->iaoq[1], rp);
488
489 return 1;
490
491give_sigsegv:
492 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
493 if (sig == SIGSEGV)
494 ka->sa.sa_handler = SIG_DFL;
495 si.si_signo = SIGSEGV;
496 si.si_errno = 0;
497 si.si_code = SI_KERNEL;
498 si.si_pid = current->pid;
499 si.si_uid = current->uid;
500 si.si_addr = frame;
501 force_sig_info(SIGSEGV, &si, current);
502 return 0;
503}
504
505/*
506 * OK, we're invoking a handler.
507 */
508
509static long
510handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
511 sigset_t *oldset, struct pt_regs *regs, int in_syscall)
512{
513 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
514 sig, ka, info, oldset, regs);
515
516 /* Set up the stack frame */
517 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
518 return 0;
519
520 if (!(ka->sa.sa_flags & SA_NODEFER)) {
521 spin_lock_irq(&current->sighand->siglock);
522 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
523 sigaddset(&current->blocked,sig);
524 recalc_sigpending();
525 spin_unlock_irq(&current->sighand->siglock);
526 }
527 return 1;
528}
529
530/*
531 * Note that 'init' is a special process: it doesn't get signals it doesn't
532 * want to handle. Thus you cannot kill init even with a SIGKILL even by
533 * mistake.
534 *
535 * We need to be able to restore the syscall arguments (r21-r26) to
536 * restart syscalls. Thus, the syscall path should save them in the
537 * pt_regs structure (it's okay to do so since they are caller-save
538 * registers). As noted below, the syscall number gets restored for
539 * us due to the magic of delayed branching.
540 */
541
542asmlinkage int
543do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall)
544{
545 siginfo_t info;
546 struct k_sigaction ka;
547 int signr;
548
549 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
550 oldset, regs, regs->sr[7], in_syscall);
551
552 /* Everyone else checks to see if they are in kernel mode at
553 this point and exits if that's the case. I'm not sure why
554 we would be called in that case, but for some reason we
555 are. */
556
557 if (!oldset)
558 oldset = &current->blocked;
559
560 DBG(1,"do_signal: oldset %08lx / %08lx\n",
561 oldset->sig[0], oldset->sig[1]);
562
563
564 /* May need to force signal if handle_signal failed to deliver */
565 while (1) {
566
567 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
568 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
569
570 if (signr <= 0)
571 break;
572
573 /* Restart a system call if necessary. */
574 if (in_syscall) {
575 /* Check the return code */
576 switch (regs->gr[28]) {
577 case -ERESTART_RESTARTBLOCK:
578 current_thread_info()->restart_block.fn = do_no_restart_syscall;
579 case -ERESTARTNOHAND:
580 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
581 regs->gr[28] = -EINTR;
582 break;
583
584 case -ERESTARTSYS:
585 if (!(ka.sa.sa_flags & SA_RESTART)) {
586 DBG(1,"ERESTARTSYS: putting -EINTR\n");
587 regs->gr[28] = -EINTR;
588 break;
589 }
590 /* fallthrough */
591 case -ERESTARTNOINTR:
592 /* A syscall is just a branch, so all
593 we have to do is fiddle the return pointer. */
594 regs->gr[31] -= 8; /* delayed branching */
595 /* Preserve original r28. */
596 regs->gr[28] = regs->orig_r28;
597 break;
598 }
599 }
600 /* Whee! Actually deliver the signal. If the
601 delivery failed, we need to continue to iterate in
602 this loop so we can deliver the SIGSEGV... */
603 if (handle_signal(signr, &info, &ka, oldset, regs, in_syscall)) {
604 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
605 regs->gr[28]);
606 return 1;
607 }
608 }
609 /* end of while(1) looping forever if we can't force a signal */
610
611 /* Did we come from a system call? */
612 if (in_syscall) {
613 /* Restart the system call - no handlers present */
614 if (regs->gr[28] == -ERESTART_RESTARTBLOCK) {
615 unsigned int *usp = (unsigned int *)regs->gr[30];
616
617 /* Setup a trampoline to restart the syscall
618 * with __NR_restart_syscall
619 *
620 * 0: <return address (orig r31)>
621 * 4: <2nd half for 64-bit>
622 * 8: ldw 0(%sp), %r31
623 * 12: be 0x100(%sr2, %r0)
624 * 16: ldi __NR_restart_syscall, %r20
625 */
626#ifndef __LP64__
627 put_user(regs->gr[31], &usp[0]);
628 put_user(0x0fc0109f, &usp[2]);
629#else
630 put_user(regs->gr[31] >> 32, &usp[0]);
631 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
632 put_user(0x0fc010df, &usp[2]);
633#endif
634 put_user(0xe0008200, &usp[3]);
635 put_user(0x34140000, &usp[4]);
636
637 /* Stack is 64-byte aligned, and we only
638 * need to flush 1 cache line */
639 asm("fdc 0(%%sr3, %0)\n"
640 "fic 0(%%sr3, %0)\n"
641 "sync\n"
642 : : "r"(regs->gr[30]));
643
644 regs->gr[31] = regs->gr[30] + 8;
645 /* Preserve original r28. */
646 regs->gr[28] = regs->orig_r28;
647 } else if (regs->gr[28] == -ERESTARTNOHAND ||
648 regs->gr[28] == -ERESTARTSYS ||
649 regs->gr[28] == -ERESTARTNOINTR) {
650 /* Hooray for delayed branching. We don't
651 have to restore %r20 (the system call
652 number) because it gets loaded in the delay
653 slot of the branch external instruction. */
654 regs->gr[31] -= 8;
655 /* Preserve original r28. */
656 regs->gr[28] = regs->orig_r28;
657 }
658 }
659
660 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
661 regs->gr[28]);
662
663 return 0;
664}