PageRenderTime 43ms CodeModel.GetById 11ms app.highlight 27ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/parisc/kernel/signal.c

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