Linux Audio

Check our new training course

Loading...
v5.4
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *  linux/arch/parisc/kernel/signal.c: Architecture-specific signal
  4 *  handling support.
  5 *
  6 *  Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
  7 *  Copyright (C) 2000 Linuxcare, Inc.
  8 *
  9 *  Based on the ia64, i386, and alpha versions.
 10 *
 11 *  Like the IA-64, we are a recent enough port (we are *starting*
 12 *  with glibc2.2) that we do not need to support the old non-realtime
 13 *  Linux signals.  Therefore we don't.
 14 */
 15
 16#include <linux/sched.h>
 17#include <linux/sched/debug.h>
 18#include <linux/mm.h>
 19#include <linux/smp.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/tracehook.h>
 26#include <linux/unistd.h>
 27#include <linux/stddef.h>
 28#include <linux/compat.h>
 29#include <linux/elf.h>
 30#include <asm/ucontext.h>
 31#include <asm/rt_sigframe.h>
 32#include <linux/uaccess.h>
 33#include <asm/pgalloc.h>
 34#include <asm/cacheflush.h>
 35#include <asm/asm-offsets.h>
 36
 37#ifdef CONFIG_COMPAT
 38#include "signal32.h"
 39#endif
 40
 41#define DEBUG_SIG 0 
 42#define DEBUG_SIG_LEVEL 2
 43
 44#if DEBUG_SIG
 45#define DBG(LEVEL, ...) \
 46        ((DEBUG_SIG_LEVEL >= LEVEL) \
 47	? printk(__VA_ARGS__) : (void) 0)
 48#else
 49#define DBG(LEVEL, ...)
 50#endif
 51	
 52/* gcc will complain if a pointer is cast to an integer of different
 53 * size.  If you really need to do this (and we do for an ELF32 user
 54 * application in an ELF64 kernel) then you have to do a cast to an
 55 * integer of the same size first.  The A() macro accomplishes
 56 * this. */
 57#define A(__x)	((unsigned long)(__x))
 58
 59/*
 60 * Do a signal return - restore sigcontext.
 61 */
 62
 63/* Trampoline for calling rt_sigreturn() */
 64#define INSN_LDI_R25_0	 0x34190000 /* ldi  0,%r25 (in_syscall=0) */
 65#define INSN_LDI_R25_1	 0x34190002 /* ldi  1,%r25 (in_syscall=1) */
 66#define INSN_LDI_R20	 0x3414015a /* ldi  __NR_rt_sigreturn,%r20 */
 67#define INSN_BLE_SR2_R0  0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
 68/* For debugging */
 69#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
 70
 71static long
 72restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
 73{
 74	long err = 0;
 75
 76	err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
 77	err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
 78	err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
 79	err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
 80	err |= __get_user(regs->sar, &sc->sc_sar);
 81	DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
 82			regs->iaoq[0],regs->iaoq[1]);
 83	DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
 84	return err;
 85}
 86
 87void
 88sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
 89{
 90	struct rt_sigframe __user *frame;
 91	sigset_t set;
 92	unsigned long usp = (regs->gr[30] & ~(0x01UL));
 93	unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 94#ifdef CONFIG_64BIT
 95	struct compat_rt_sigframe __user * compat_frame;
 96	
 97	if (is_compat_task())
 98		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 99#endif
100
101	current->restart_block.fn = do_no_restart_syscall;
102
103	/* Unwind the user stack to get the rt_sigframe structure. */
104	frame = (struct rt_sigframe __user *)
105		(usp - sigframe_size);
106	DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
107
108	regs->orig_r28 = 1; /* no restarts for sigreturn */
109
110#ifdef CONFIG_64BIT
111	compat_frame = (struct compat_rt_sigframe __user *)frame;
112	
113	if (is_compat_task()) {
114		DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
115		if (get_compat_sigset(&set, &compat_frame->uc.uc_sigmask))
116			goto give_sigsegv;
117	} else
118#endif
119	{
120		if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
121			goto give_sigsegv;
122	}
123		
124	set_current_blocked(&set);
125
126	/* Good thing we saved the old gr[30], eh? */
127#ifdef CONFIG_64BIT
128	if (is_compat_task()) {
129		DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
130				&compat_frame->uc.uc_mcontext);
131// FIXME: Load upper half from register file
132		if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 
133					&compat_frame->regs, regs))
134			goto give_sigsegv;
135		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
136				usp, &compat_frame->uc.uc_stack);
137		if (compat_restore_altstack(&compat_frame->uc.uc_stack))
138			goto give_sigsegv;
139	} else
140#endif
141	{
142		DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
143				&frame->uc.uc_mcontext);
144		if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
145			goto give_sigsegv;
146		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
147				usp, &frame->uc.uc_stack);
148		if (restore_altstack(&frame->uc.uc_stack))
149			goto give_sigsegv;
150	}
151		
152
153
154	/* If we are on the syscall path IAOQ will not be restored, and
155	 * if we are on the interrupt path we must not corrupt gr31.
156	 */
157	if (in_syscall)
158		regs->gr[31] = regs->iaoq[0];
159#if DEBUG_SIG
160	DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
161	show_regs(regs);
162#endif
163	return;
164
165give_sigsegv:
166	DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
167	force_sig(SIGSEGV);
168	return;
169}
170
171/*
172 * Set up a signal frame.
173 */
174
175static inline void __user *
176get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
177{
178	/*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
179	  don't use the parameter it doesn't matter */
180
181	DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
182			(unsigned long)ka, sp, frame_size);
183	
184	/* Align alternate stack and reserve 64 bytes for the signal
185	   handler's frame marker.  */
186	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
187		sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
188
189	DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
190	return (void __user *) sp; /* Stacks grow up.  Fun. */
191}
192
193static long
194setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
195		 
196{
197	unsigned long flags = 0;
198	long err = 0;
199
200	if (on_sig_stack((unsigned long) sc))
201		flags |= PARISC_SC_FLAG_ONSTACK;
202	if (in_syscall) {
203		flags |= PARISC_SC_FLAG_IN_SYSCALL;
204		/* regs->iaoq is undefined in the syscall return path */
205		err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
206		err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
207		err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
208		err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
209		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
210			regs->gr[31], regs->gr[31]+4);
211	} else {
212		err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
213		err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
214		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 
215			regs->iaoq[0], regs->iaoq[1]);
216	}
217
218	err |= __put_user(flags, &sc->sc_flags);
219	err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
220	err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
221	err |= __put_user(regs->sar, &sc->sc_sar);
222	DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
223
224	return err;
225}
226
227static long
228setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs,
229	       int in_syscall)
230{
231	struct rt_sigframe __user *frame;
232	unsigned long rp, usp;
233	unsigned long haddr, sigframe_size;
234	unsigned long start, end;
235	int err = 0;
236#ifdef CONFIG_64BIT
237	struct compat_rt_sigframe __user * compat_frame;
238#endif
239	
240	usp = (regs->gr[30] & ~(0x01UL));
 
 
 
 
 
 
241	/*FIXME: frame_size parameter is unused, remove it. */
242	frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
243
244	DBG(1,"SETUP_RT_FRAME: START\n");
245	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
246
247	
248#ifdef CONFIG_64BIT
249
250	compat_frame = (struct compat_rt_sigframe __user *)frame;
251	
252	if (is_compat_task()) {
253		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
254		err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
255		err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
256		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
257		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
258		err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 
259					&compat_frame->regs, regs, in_syscall);
260		err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
261					 sizeof(compat_sigset_t));
262	} else
263#endif
264	{	
265		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
266		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
267		err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
268		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
269		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
270		err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
271		/* FIXME: Should probably be converted as well for the compat case */
272		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
273	}
274	
275	if (err)
276		return -EFAULT;
277
278	/* Set up to return from userspace.  If provided, use a stub
279	   already in userspace. The first words of tramp are used to
280	   save the previous sigrestartblock trampoline that might be
281	   on the stack. We start the sigreturn trampoline at 
282	   SIGRESTARTBLOCK_TRAMP+X. */
283	err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
284			&frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
285	err |= __put_user(INSN_LDI_R20, 
286			&frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
287	err |= __put_user(INSN_BLE_SR2_R0, 
288			&frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
289	err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
290
291#if DEBUG_SIG
292	/* Assert that we're flushing in the correct space... */
293	{
294		unsigned long sid;
295		asm ("mfsp %%sr3,%0" : "=r" (sid));
296		DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
297		       sid, frame->tramp);
298	}
299#endif
300
301	start = (unsigned long) &frame->tramp[0];
302	end = (unsigned long) &frame->tramp[TRAMP_SIZE];
303	flush_user_dcache_range_asm(start, end);
304	flush_user_icache_range_asm(start, end);
305
306	/* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
307	 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
308	 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
309	 */
310	rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
311
312	if (err)
313		return -EFAULT;
314
315	haddr = A(ksig->ka.sa.sa_handler);
316	/* The sa_handler may be a pointer to a function descriptor */
317#ifdef CONFIG_64BIT
318	if (is_compat_task()) {
319#endif
320		if (haddr & PA_PLABEL_FDESC) {
321			Elf32_Fdesc fdesc;
322			Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
323
324			err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
325
326			if (err)
327				return -EFAULT;
328
329			haddr = fdesc.addr;
330			regs->gr[19] = fdesc.gp;
331		}
332#ifdef CONFIG_64BIT
333	} else {
334		Elf64_Fdesc fdesc;
335		Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
336		
337		err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
338		
339		if (err)
340			return -EFAULT;
341		
342		haddr = fdesc.addr;
343		regs->gr[19] = fdesc.gp;
344		DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
345		     haddr, regs->gr[19], in_syscall);
346	}
347#endif
348
349	/* The syscall return path will create IAOQ values from r31.
350	 */
351	sigframe_size = PARISC_RT_SIGFRAME_SIZE;
352#ifdef CONFIG_64BIT
353	if (is_compat_task())
354		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
355#endif
356	if (in_syscall) {
357		regs->gr[31] = haddr;
358#ifdef CONFIG_64BIT
359		if (!test_thread_flag(TIF_32BIT))
360			sigframe_size |= 1;
361#endif
362	} else {
363		unsigned long psw = USER_PSW;
364#ifdef CONFIG_64BIT
365		if (!test_thread_flag(TIF_32BIT))
366			psw |= PSW_W;
367#endif
368
369		/* If we are singlestepping, arrange a trap to be delivered
370		   when we return to userspace. Note the semantics -- we
371		   should trap before the first insn in the handler is
372		   executed. Ref:
373			http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
374		 */
375		if (pa_psw(current)->r) {
376			pa_psw(current)->r = 0;
377			psw |= PSW_R;
378			mtctl(-1, 0);
379		}
380
381		regs->gr[0] = psw;
382		regs->iaoq[0] = haddr | 3;
383		regs->iaoq[1] = regs->iaoq[0] + 4;
384	}
385
386	regs->gr[2]  = rp;                /* userland return pointer */
387	regs->gr[26] = ksig->sig;               /* signal number */
388	
389#ifdef CONFIG_64BIT
390	if (is_compat_task()) {
391		regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
392		regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
393	} else
394#endif
395	{		
396		regs->gr[25] = A(&frame->info); /* siginfo pointer */
397		regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
398	}
399	
400	DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
401	       regs->gr[30], sigframe_size,
402	       regs->gr[30] + sigframe_size);
403	/* Raise the user stack pointer to make a proper call frame. */
404	regs->gr[30] = (A(frame) + sigframe_size);
405
406
407	DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
408	       current->comm, current->pid, frame, regs->gr[30],
409	       regs->iaoq[0], regs->iaoq[1], rp);
410
411	return 0;
412}
413
414/*
415 * OK, we're invoking a handler.
416 */	
417
418static void
419handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
420{
421	int ret;
422	sigset_t *oldset = sigmask_to_save();
423
424	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
425	       ksig->sig, ksig->ka, ksig->info, oldset, regs);
426	
427	/* Set up the stack frame */
428	ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
429
430	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
431			  test_thread_flag(TIF_BLOCKSTEP));
432
433	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
434		regs->gr[28]);
435}
436
437/*
438 * Check how the syscall number gets loaded into %r20 within
439 * the delay branch in userspace and adjust as needed.
440 */
441
442static void check_syscallno_in_delay_branch(struct pt_regs *regs)
443{
444	u32 opcode, source_reg;
445	u32 __user *uaddr;
446	int err;
447
448	/* Usually we don't have to restore %r20 (the system call number)
449	 * because it gets loaded in the delay slot of the branch external
450	 * instruction via the ldi instruction.
451	 * In some cases a register-to-register copy instruction might have
452	 * been used instead, in which case we need to copy the syscall
453	 * number into the source register before returning to userspace.
454	 */
455
456	/* A syscall is just a branch, so all we have to do is fiddle the
457	 * return pointer so that the ble instruction gets executed again.
458	 */
459	regs->gr[31] -= 8; /* delayed branching */
460
461	/* Get assembler opcode of code in delay branch */
462	uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
463	err = get_user(opcode, uaddr);
464	if (err)
465		return;
466
467	/* Check if delay branch uses "ldi int,%r20" */
468	if ((opcode & 0xffff0000) == 0x34140000)
469		return;	/* everything ok, just return */
470
471	/* Check if delay branch uses "nop" */
472	if (opcode == INSN_NOP)
473		return;
474
475	/* Check if delay branch uses "copy %rX,%r20" */
476	if ((opcode & 0xffe0ffff) == 0x08000254) {
477		source_reg = (opcode >> 16) & 31;
478		regs->gr[source_reg] = regs->gr[20];
479		return;
480	}
481
482	pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
483		current->comm, task_pid_nr(current), opcode);
484}
485
486static inline void
487syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
488{
489	if (regs->orig_r28)
490		return;
491	regs->orig_r28 = 1; /* no more restarts */
492	/* Check the return code */
493	switch (regs->gr[28]) {
494	case -ERESTART_RESTARTBLOCK:
495	case -ERESTARTNOHAND:
496		DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
497		regs->gr[28] = -EINTR;
498		break;
499
500	case -ERESTARTSYS:
501		if (!(ka->sa.sa_flags & SA_RESTART)) {
502			DBG(1,"ERESTARTSYS: putting -EINTR\n");
503			regs->gr[28] = -EINTR;
504			break;
505		}
506		/* fallthrough */
507	case -ERESTARTNOINTR:
508		check_syscallno_in_delay_branch(regs);
509		break;
510	}
511}
512
513static inline void
514insert_restart_trampoline(struct pt_regs *regs)
515{
516	if (regs->orig_r28)
517		return;
518	regs->orig_r28 = 1; /* no more restarts */
519	switch(regs->gr[28]) {
520	case -ERESTART_RESTARTBLOCK: {
521		/* Restart the system call - no handlers present */
522		unsigned int *usp = (unsigned int *)regs->gr[30];
523		unsigned long start = (unsigned long) &usp[2];
524		unsigned long end  = (unsigned long) &usp[5];
525		long err = 0;
526
527		/* Setup a trampoline to restart the syscall
528		 * with __NR_restart_syscall
529		 *
530		 *  0: <return address (orig r31)>
531		 *  4: <2nd half for 64-bit>
532		 *  8: ldw 0(%sp), %r31
533		 * 12: be 0x100(%sr2, %r0)
534		 * 16: ldi __NR_restart_syscall, %r20
535		 */
536#ifdef CONFIG_64BIT
537		err |= put_user(regs->gr[31] >> 32, &usp[0]);
538		err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
539		err |= put_user(0x0fc010df, &usp[2]);
540#else
541		err |= put_user(regs->gr[31], &usp[0]);
542		err |= put_user(0x0fc0109f, &usp[2]);
543#endif
544		err |= put_user(0xe0008200, &usp[3]);
545		err |= put_user(0x34140000, &usp[4]);
546
547		WARN_ON(err);
548
549		/* flush data/instruction cache for new insns */
550		flush_user_dcache_range_asm(start, end);
551		flush_user_icache_range_asm(start, end);
552
553		regs->gr[31] = regs->gr[30] + 8;
554		return;
555	}
556	case -ERESTARTNOHAND:
557	case -ERESTARTSYS:
558	case -ERESTARTNOINTR:
559		check_syscallno_in_delay_branch(regs);
560		return;
561	default:
562		break;
563	}
564}
565
566/*
567 * Note that 'init' is a special process: it doesn't get signals it doesn't
568 * want to handle. Thus you cannot kill init even with a SIGKILL even by
569 * mistake.
570 *
571 * We need to be able to restore the syscall arguments (r21-r26) to
572 * restart syscalls.  Thus, the syscall path should save them in the
573 * pt_regs structure (it's okay to do so since they are caller-save
574 * registers).  As noted below, the syscall number gets restored for
575 * us due to the magic of delayed branching.
576 */
577asmlinkage void
578do_signal(struct pt_regs *regs, long in_syscall)
579{
580	struct ksignal ksig;
581
582	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
583	       regs, regs->sr[7], in_syscall);
584
585	if (get_signal(&ksig)) {
586		DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
587		/* Restart a system call if necessary. */
588		if (in_syscall)
589			syscall_restart(regs, &ksig.ka);
590
591		handle_signal(&ksig, regs, in_syscall);
592		return;
593	}
594
595	/* Did we come from a system call? */
596	if (in_syscall)
597		insert_restart_trampoline(regs);
598	
599	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
600		regs->gr[28]);
601
602	restore_saved_sigmask();
603}
604
605void do_notify_resume(struct pt_regs *regs, long in_syscall)
606{
607	if (test_thread_flag(TIF_SIGPENDING))
 
608		do_signal(regs, in_syscall);
609
610	if (test_thread_flag(TIF_NOTIFY_RESUME)) {
611		clear_thread_flag(TIF_NOTIFY_RESUME);
612		tracehook_notify_resume(regs);
613	}
614}
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *  linux/arch/parisc/kernel/signal.c: Architecture-specific signal
  4 *  handling support.
  5 *
  6 *  Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
  7 *  Copyright (C) 2000 Linuxcare, Inc.
  8 *
  9 *  Based on the ia64, i386, and alpha versions.
 10 *
 11 *  Like the IA-64, we are a recent enough port (we are *starting*
 12 *  with glibc2.2) that we do not need to support the old non-realtime
 13 *  Linux signals.  Therefore we don't.
 14 */
 15
 16#include <linux/sched.h>
 17#include <linux/sched/debug.h>
 18#include <linux/mm.h>
 19#include <linux/smp.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/tracehook.h>
 26#include <linux/unistd.h>
 27#include <linux/stddef.h>
 28#include <linux/compat.h>
 29#include <linux/elf.h>
 30#include <asm/ucontext.h>
 31#include <asm/rt_sigframe.h>
 32#include <linux/uaccess.h>
 
 33#include <asm/cacheflush.h>
 34#include <asm/asm-offsets.h>
 35
 36#ifdef CONFIG_COMPAT
 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/* gcc will complain if a pointer is cast to an integer of different
 52 * size.  If you really need to do this (and we do for an ELF32 user
 53 * application in an ELF64 kernel) then you have to do a cast to an
 54 * integer of the same size first.  The A() macro accomplishes
 55 * this. */
 56#define A(__x)	((unsigned long)(__x))
 57
 58/*
 59 * Do a signal return - restore sigcontext.
 60 */
 61
 62/* Trampoline for calling rt_sigreturn() */
 63#define INSN_LDI_R25_0	 0x34190000 /* ldi  0,%r25 (in_syscall=0) */
 64#define INSN_LDI_R25_1	 0x34190002 /* ldi  1,%r25 (in_syscall=1) */
 65#define INSN_LDI_R20	 0x3414015a /* ldi  __NR_rt_sigreturn,%r20 */
 66#define INSN_BLE_SR2_R0  0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
 67/* For debugging */
 68#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
 69
 70static long
 71restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
 72{
 73	long err = 0;
 74
 75	err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
 76	err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
 77	err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
 78	err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
 79	err |= __get_user(regs->sar, &sc->sc_sar);
 80	DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
 81			regs->iaoq[0],regs->iaoq[1]);
 82	DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
 83	return err;
 84}
 85
 86void
 87sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
 88{
 89	struct rt_sigframe __user *frame;
 90	sigset_t set;
 91	unsigned long usp = (regs->gr[30] & ~(0x01UL));
 92	unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 93#ifdef CONFIG_64BIT
 94	struct compat_rt_sigframe __user * compat_frame;
 95	
 96	if (is_compat_task())
 97		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 98#endif
 99
100	current->restart_block.fn = do_no_restart_syscall;
101
102	/* Unwind the user stack to get the rt_sigframe structure. */
103	frame = (struct rt_sigframe __user *)
104		(usp - sigframe_size);
105	DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
106
107	regs->orig_r28 = 1; /* no restarts for sigreturn */
108
109#ifdef CONFIG_64BIT
110	compat_frame = (struct compat_rt_sigframe __user *)frame;
111	
112	if (is_compat_task()) {
113		DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
114		if (get_compat_sigset(&set, &compat_frame->uc.uc_sigmask))
115			goto give_sigsegv;
116	} else
117#endif
118	{
119		if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
120			goto give_sigsegv;
121	}
122		
123	set_current_blocked(&set);
124
125	/* Good thing we saved the old gr[30], eh? */
126#ifdef CONFIG_64BIT
127	if (is_compat_task()) {
128		DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
129				&compat_frame->uc.uc_mcontext);
130// FIXME: Load upper half from register file
131		if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 
132					&compat_frame->regs, regs))
133			goto give_sigsegv;
134		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
135				usp, &compat_frame->uc.uc_stack);
136		if (compat_restore_altstack(&compat_frame->uc.uc_stack))
137			goto give_sigsegv;
138	} else
139#endif
140	{
141		DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
142				&frame->uc.uc_mcontext);
143		if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
144			goto give_sigsegv;
145		DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
146				usp, &frame->uc.uc_stack);
147		if (restore_altstack(&frame->uc.uc_stack))
148			goto give_sigsegv;
149	}
150		
151
152
153	/* If we are on the syscall path IAOQ will not be restored, and
154	 * if we are on the interrupt path we must not corrupt gr31.
155	 */
156	if (in_syscall)
157		regs->gr[31] = regs->iaoq[0];
158#if DEBUG_SIG
159	DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
160	show_regs(regs);
161#endif
162	return;
163
164give_sigsegv:
165	DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
166	force_sig(SIGSEGV);
167	return;
168}
169
170/*
171 * Set up a signal frame.
172 */
173
174static inline void __user *
175get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
176{
177	/*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
178	  don't use the parameter it doesn't matter */
179
180	DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
181			(unsigned long)ka, sp, frame_size);
182	
183	/* Align alternate stack and reserve 64 bytes for the signal
184	   handler's frame marker.  */
185	if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
186		sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
187
188	DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
189	return (void __user *) sp; /* Stacks grow up.  Fun. */
190}
191
192static long
193setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
194		 
195{
196	unsigned long flags = 0;
197	long err = 0;
198
199	if (on_sig_stack((unsigned long) sc))
200		flags |= PARISC_SC_FLAG_ONSTACK;
201	if (in_syscall) {
202		flags |= PARISC_SC_FLAG_IN_SYSCALL;
203		/* regs->iaoq is undefined in the syscall return path */
204		err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
205		err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
206		err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
207		err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
208		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
209			regs->gr[31], regs->gr[31]+4);
210	} else {
211		err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
212		err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
213		DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 
214			regs->iaoq[0], regs->iaoq[1]);
215	}
216
217	err |= __put_user(flags, &sc->sc_flags);
218	err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
219	err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
220	err |= __put_user(regs->sar, &sc->sc_sar);
221	DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
222
223	return err;
224}
225
226static long
227setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs,
228	       int in_syscall)
229{
230	struct rt_sigframe __user *frame;
231	unsigned long rp, usp;
232	unsigned long haddr, sigframe_size;
233	unsigned long start, end;
234	int err = 0;
235#ifdef CONFIG_64BIT
236	struct compat_rt_sigframe __user * compat_frame;
237#endif
238	
239	usp = (regs->gr[30] & ~(0x01UL));
240#ifdef CONFIG_64BIT
241	if (is_compat_task()) {
242		/* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
243		usp = (compat_uint_t)usp;
244	}
245#endif
246	/*FIXME: frame_size parameter is unused, remove it. */
247	frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
248
249	DBG(1,"SETUP_RT_FRAME: START\n");
250	DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
251
252	
253#ifdef CONFIG_64BIT
254
255	compat_frame = (struct compat_rt_sigframe __user *)frame;
256	
257	if (is_compat_task()) {
258		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
259		err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
260		err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
261		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
262		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
263		err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 
264					&compat_frame->regs, regs, in_syscall);
265		err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
266					 sizeof(compat_sigset_t));
267	} else
268#endif
269	{	
270		DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
271		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
272		err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
273		DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
274		DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
275		err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
276		/* FIXME: Should probably be converted as well for the compat case */
277		err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
278	}
279	
280	if (err)
281		return -EFAULT;
282
283	/* Set up to return from userspace.  If provided, use a stub
284	   already in userspace. The first words of tramp are used to
285	   save the previous sigrestartblock trampoline that might be
286	   on the stack. We start the sigreturn trampoline at 
287	   SIGRESTARTBLOCK_TRAMP+X. */
288	err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
289			&frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
290	err |= __put_user(INSN_LDI_R20, 
291			&frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
292	err |= __put_user(INSN_BLE_SR2_R0, 
293			&frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
294	err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
295
296#if DEBUG_SIG
297	/* Assert that we're flushing in the correct space... */
298	{
299		unsigned long sid;
300		asm ("mfsp %%sr3,%0" : "=r" (sid));
301		DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
302		       sid, frame->tramp);
303	}
304#endif
305
306	start = (unsigned long) &frame->tramp[0];
307	end = (unsigned long) &frame->tramp[TRAMP_SIZE];
308	flush_user_dcache_range_asm(start, end);
309	flush_user_icache_range_asm(start, end);
310
311	/* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
312	 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
313	 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
314	 */
315	rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
316
317	if (err)
318		return -EFAULT;
319
320	haddr = A(ksig->ka.sa.sa_handler);
321	/* The sa_handler may be a pointer to a function descriptor */
322#ifdef CONFIG_64BIT
323	if (is_compat_task()) {
324#endif
325		if (haddr & PA_PLABEL_FDESC) {
326			Elf32_Fdesc fdesc;
327			Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
328
329			err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
330
331			if (err)
332				return -EFAULT;
333
334			haddr = fdesc.addr;
335			regs->gr[19] = fdesc.gp;
336		}
337#ifdef CONFIG_64BIT
338	} else {
339		Elf64_Fdesc fdesc;
340		Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
341		
342		err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
343		
344		if (err)
345			return -EFAULT;
346		
347		haddr = fdesc.addr;
348		regs->gr[19] = fdesc.gp;
349		DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
350		     haddr, regs->gr[19], in_syscall);
351	}
352#endif
353
354	/* The syscall return path will create IAOQ values from r31.
355	 */
356	sigframe_size = PARISC_RT_SIGFRAME_SIZE;
357#ifdef CONFIG_64BIT
358	if (is_compat_task())
359		sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
360#endif
361	if (in_syscall) {
362		regs->gr[31] = haddr;
363#ifdef CONFIG_64BIT
364		if (!test_thread_flag(TIF_32BIT))
365			sigframe_size |= 1;
366#endif
367	} else {
368		unsigned long psw = USER_PSW;
369#ifdef CONFIG_64BIT
370		if (!test_thread_flag(TIF_32BIT))
371			psw |= PSW_W;
372#endif
373
374		/* If we are singlestepping, arrange a trap to be delivered
375		   when we return to userspace. Note the semantics -- we
376		   should trap before the first insn in the handler is
377		   executed. Ref:
378			http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
379		 */
380		if (pa_psw(current)->r) {
381			pa_psw(current)->r = 0;
382			psw |= PSW_R;
383			mtctl(-1, 0);
384		}
385
386		regs->gr[0] = psw;
387		regs->iaoq[0] = haddr | 3;
388		regs->iaoq[1] = regs->iaoq[0] + 4;
389	}
390
391	regs->gr[2]  = rp;                /* userland return pointer */
392	regs->gr[26] = ksig->sig;               /* signal number */
393	
394#ifdef CONFIG_64BIT
395	if (is_compat_task()) {
396		regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
397		regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
398	} else
399#endif
400	{		
401		regs->gr[25] = A(&frame->info); /* siginfo pointer */
402		regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
403	}
404	
405	DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
406	       regs->gr[30], sigframe_size,
407	       regs->gr[30] + sigframe_size);
408	/* Raise the user stack pointer to make a proper call frame. */
409	regs->gr[30] = (A(frame) + sigframe_size);
410
411
412	DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
413	       current->comm, current->pid, frame, regs->gr[30],
414	       regs->iaoq[0], regs->iaoq[1], rp);
415
416	return 0;
417}
418
419/*
420 * OK, we're invoking a handler.
421 */	
422
423static void
424handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
425{
426	int ret;
427	sigset_t *oldset = sigmask_to_save();
428
429	DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
430	       ksig->sig, ksig->ka, ksig->info, oldset, regs);
431	
432	/* Set up the stack frame */
433	ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
434
435	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
436			  test_thread_flag(TIF_BLOCKSTEP));
437
438	DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
439		regs->gr[28]);
440}
441
442/*
443 * Check how the syscall number gets loaded into %r20 within
444 * the delay branch in userspace and adjust as needed.
445 */
446
447static void check_syscallno_in_delay_branch(struct pt_regs *regs)
448{
449	u32 opcode, source_reg;
450	u32 __user *uaddr;
451	int err;
452
453	/* Usually we don't have to restore %r20 (the system call number)
454	 * because it gets loaded in the delay slot of the branch external
455	 * instruction via the ldi instruction.
456	 * In some cases a register-to-register copy instruction might have
457	 * been used instead, in which case we need to copy the syscall
458	 * number into the source register before returning to userspace.
459	 */
460
461	/* A syscall is just a branch, so all we have to do is fiddle the
462	 * return pointer so that the ble instruction gets executed again.
463	 */
464	regs->gr[31] -= 8; /* delayed branching */
465
466	/* Get assembler opcode of code in delay branch */
467	uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
468	err = get_user(opcode, uaddr);
469	if (err)
470		return;
471
472	/* Check if delay branch uses "ldi int,%r20" */
473	if ((opcode & 0xffff0000) == 0x34140000)
474		return;	/* everything ok, just return */
475
476	/* Check if delay branch uses "nop" */
477	if (opcode == INSN_NOP)
478		return;
479
480	/* Check if delay branch uses "copy %rX,%r20" */
481	if ((opcode & 0xffe0ffff) == 0x08000254) {
482		source_reg = (opcode >> 16) & 31;
483		regs->gr[source_reg] = regs->gr[20];
484		return;
485	}
486
487	pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
488		current->comm, task_pid_nr(current), opcode);
489}
490
491static inline void
492syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
493{
494	if (regs->orig_r28)
495		return;
496	regs->orig_r28 = 1; /* no more restarts */
497	/* Check the return code */
498	switch (regs->gr[28]) {
499	case -ERESTART_RESTARTBLOCK:
500	case -ERESTARTNOHAND:
501		DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
502		regs->gr[28] = -EINTR;
503		break;
504
505	case -ERESTARTSYS:
506		if (!(ka->sa.sa_flags & SA_RESTART)) {
507			DBG(1,"ERESTARTSYS: putting -EINTR\n");
508			regs->gr[28] = -EINTR;
509			break;
510		}
511		fallthrough;
512	case -ERESTARTNOINTR:
513		check_syscallno_in_delay_branch(regs);
514		break;
515	}
516}
517
518static inline void
519insert_restart_trampoline(struct pt_regs *regs)
520{
521	if (regs->orig_r28)
522		return;
523	regs->orig_r28 = 1; /* no more restarts */
524	switch(regs->gr[28]) {
525	case -ERESTART_RESTARTBLOCK: {
526		/* Restart the system call - no handlers present */
527		unsigned int *usp = (unsigned int *)regs->gr[30];
528		unsigned long start = (unsigned long) &usp[2];
529		unsigned long end  = (unsigned long) &usp[5];
530		long err = 0;
531
532		/* Setup a trampoline to restart the syscall
533		 * with __NR_restart_syscall
534		 *
535		 *  0: <return address (orig r31)>
536		 *  4: <2nd half for 64-bit>
537		 *  8: ldw 0(%sp), %r31
538		 * 12: be 0x100(%sr2, %r0)
539		 * 16: ldi __NR_restart_syscall, %r20
540		 */
541#ifdef CONFIG_64BIT
542		err |= put_user(regs->gr[31] >> 32, &usp[0]);
543		err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
544		err |= put_user(0x0fc010df, &usp[2]);
545#else
546		err |= put_user(regs->gr[31], &usp[0]);
547		err |= put_user(0x0fc0109f, &usp[2]);
548#endif
549		err |= put_user(0xe0008200, &usp[3]);
550		err |= put_user(0x34140000, &usp[4]);
551
552		WARN_ON(err);
553
554		/* flush data/instruction cache for new insns */
555		flush_user_dcache_range_asm(start, end);
556		flush_user_icache_range_asm(start, end);
557
558		regs->gr[31] = regs->gr[30] + 8;
559		return;
560	}
561	case -ERESTARTNOHAND:
562	case -ERESTARTSYS:
563	case -ERESTARTNOINTR:
564		check_syscallno_in_delay_branch(regs);
565		return;
566	default:
567		break;
568	}
569}
570
571/*
572 * Note that 'init' is a special process: it doesn't get signals it doesn't
573 * want to handle. Thus you cannot kill init even with a SIGKILL even by
574 * mistake.
575 *
576 * We need to be able to restore the syscall arguments (r21-r26) to
577 * restart syscalls.  Thus, the syscall path should save them in the
578 * pt_regs structure (it's okay to do so since they are caller-save
579 * registers).  As noted below, the syscall number gets restored for
580 * us due to the magic of delayed branching.
581 */
582asmlinkage void
583do_signal(struct pt_regs *regs, long in_syscall)
584{
585	struct ksignal ksig;
586
587	DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
588	       regs, regs->sr[7], in_syscall);
589
590	if (get_signal(&ksig)) {
591		DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
592		/* Restart a system call if necessary. */
593		if (in_syscall)
594			syscall_restart(regs, &ksig.ka);
595
596		handle_signal(&ksig, regs, in_syscall);
597		return;
598	}
599
600	/* Did we come from a system call? */
601	if (in_syscall)
602		insert_restart_trampoline(regs);
603	
604	DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
605		regs->gr[28]);
606
607	restore_saved_sigmask();
608}
609
610void do_notify_resume(struct pt_regs *regs, long in_syscall)
611{
612	if (test_thread_flag(TIF_SIGPENDING) ||
613	    test_thread_flag(TIF_NOTIFY_SIGNAL))
614		do_signal(regs, in_syscall);
615
616	if (test_thread_flag(TIF_NOTIFY_RESUME))
 
617		tracehook_notify_resume(regs);
 
618}