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