1/*
2 *  arch/s390/kernel/signal.c
3 *
4 *    Copyright (C) IBM Corp. 1999,2006
5 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 *
7 *    Based on Intel version
8 *
9 *  Copyright (C) 1991, 1992  Linus Torvalds
10 *
11 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
12 */
13
14#include <linux/sched.h>
15#include <linux/mm.h>
16#include <linux/smp.h>
17#include <linux/kernel.h>
18#include <linux/signal.h>
19#include <linux/errno.h>
20#include <linux/wait.h>
21#include <linux/ptrace.h>
22#include <linux/unistd.h>
23#include <linux/stddef.h>
24#include <linux/tty.h>
25#include <linux/personality.h>
26#include <linux/binfmts.h>
27#include <asm/ucontext.h>
28#include <asm/uaccess.h>
29#include <asm/lowcore.h>
30
31#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32
33
34typedef struct
35{
36	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
37	struct sigcontext sc;
38	_sigregs sregs;
39	int signo;
40	__u8 retcode[S390_SYSCALL_SIZE];
41} sigframe;
42
43typedef struct
44{
45	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
46	__u8 retcode[S390_SYSCALL_SIZE];
47	struct siginfo info;
48	struct ucontext uc;
49} rt_sigframe;
50
51/*
52 * Atomically swap in the new signal mask, and wait for a signal.
53 */
54asmlinkage int
55sys_sigsuspend(int history0, int history1, old_sigset_t mask)
56{
57	mask &= _BLOCKABLE;
58	spin_lock_irq(&current->sighand->siglock);
59	current->saved_sigmask = current->blocked;
60	siginitset(&current->blocked, mask);
61	recalc_sigpending();
62	spin_unlock_irq(&current->sighand->siglock);
63
64	current->state = TASK_INTERRUPTIBLE;
65	schedule();
66	set_thread_flag(TIF_RESTORE_SIGMASK);
67
68	return -ERESTARTNOHAND;
69}
70
71asmlinkage long
72sys_sigaction(int sig, const struct old_sigaction __user *act,
73	      struct old_sigaction __user *oact)
74{
75	struct k_sigaction new_ka, old_ka;
76	int ret;
77
78	if (act) {
79		old_sigset_t mask;
80		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
81		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
82		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
83		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
84		    __get_user(mask, &act->sa_mask))
85			return -EFAULT;
86		siginitset(&new_ka.sa.sa_mask, mask);
87	}
88
89	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
90
91	if (!ret && oact) {
92		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
93		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
94		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
95		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
96		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
97			return -EFAULT;
98	}
99
100	return ret;
101}
102
103asmlinkage long
104sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
105{
106	struct pt_regs *regs = task_pt_regs(current);
107	return do_sigaltstack(uss, uoss, regs->gprs[15]);
108}
109
110
111
112/* Returns non-zero on fault. */
113static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
114{
115	_sigregs user_sregs;
116
117	save_access_regs(current->thread.acrs);
118
119	/* Copy a 'clean' PSW mask to the user to avoid leaking
120	   information about whether PER is currently on.  */
121	user_sregs.regs.psw.mask = PSW_MASK_MERGE(psw_user_bits, regs->psw.mask);
122	user_sregs.regs.psw.addr = regs->psw.addr;
123	memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
124	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
125	       sizeof(sregs->regs.acrs));
126	/*
127	 * We have to store the fp registers to current->thread.fp_regs
128	 * to merge them with the emulated registers.
129	 */
130	save_fp_regs(&current->thread.fp_regs);
131	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
132	       sizeof(s390_fp_regs));
133	return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
134}
135
136/* Returns positive number on error */
137static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
138{
139	int err;
140	_sigregs user_sregs;
141
142	/* Alwys make any pending restarted system call return -EINTR */
143	current_thread_info()->restart_block.fn = do_no_restart_syscall;
144
145	err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
146	if (err)
147		return err;
148	regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
149					user_sregs.regs.psw.mask);
150	regs->psw.addr = PSW_ADDR_AMODE | user_sregs.regs.psw.addr;
151	memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
152	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
153	       sizeof(sregs->regs.acrs));
154	restore_access_regs(current->thread.acrs);
155
156	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
157	       sizeof(s390_fp_regs));
158	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
159
160	restore_fp_regs(&current->thread.fp_regs);
161	regs->trap = -1;	/* disable syscall checks */
162	return 0;
163}
164
165asmlinkage long sys_sigreturn(void)
166{
167	struct pt_regs *regs = task_pt_regs(current);
168	sigframe __user *frame = (sigframe __user *)regs->gprs[15];
169	sigset_t set;
170
171	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
172		goto badframe;
173	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
174		goto badframe;
175
176	sigdelsetmask(&set, ~_BLOCKABLE);
177	spin_lock_irq(&current->sighand->siglock);
178	current->blocked = set;
179	recalc_sigpending();
180	spin_unlock_irq(&current->sighand->siglock);
181
182	if (restore_sigregs(regs, &frame->sregs))
183		goto badframe;
184
185	return regs->gprs[2];
186
187badframe:
188	force_sig(SIGSEGV, current);
189	return 0;
190}
191
192asmlinkage long sys_rt_sigreturn(void)
193{
194	struct pt_regs *regs = task_pt_regs(current);
195	rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
196	sigset_t set;
197
198	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
199		goto badframe;
200	if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
201		goto badframe;
202
203	sigdelsetmask(&set, ~_BLOCKABLE);
204	spin_lock_irq(&current->sighand->siglock);
205	current->blocked = set;
206	recalc_sigpending();
207	spin_unlock_irq(&current->sighand->siglock);
208
209	if (restore_sigregs(regs, &frame->uc.uc_mcontext))
210		goto badframe;
211
212	if (do_sigaltstack(&frame->uc.uc_stack, NULL,
213			   regs->gprs[15]) == -EFAULT)
214		goto badframe;
215	return regs->gprs[2];
216
217badframe:
218	force_sig(SIGSEGV, current);
219	return 0;
220}
221
222/*
223 * Set up a signal frame.
224 */
225
226
227/*
228 * Determine which stack to use..
229 */
230static inline void __user *
231get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
232{
233	unsigned long sp;
234
235	/* Default to using normal stack */
236	sp = regs->gprs[15];
237
238	/* This is the X/Open sanctioned signal stack switching.  */
239	if (ka->sa.sa_flags & SA_ONSTACK) {
240		if (! sas_ss_flags(sp))
241			sp = current->sas_ss_sp + current->sas_ss_size;
242	}
243
244	/* This is the legacy signal stack switching. */
245	else if (!user_mode(regs) &&
246		 !(ka->sa.sa_flags & SA_RESTORER) &&
247		 ka->sa.sa_restorer) {
248		sp = (unsigned long) ka->sa.sa_restorer;
249	}
250
251	return (void __user *)((sp - frame_size) & -8ul);
252}
253
254static inline int map_signal(int sig)
255{
256	if (current_thread_info()->exec_domain
257	    && current_thread_info()->exec_domain->signal_invmap
258	    && sig < 32)
259		return current_thread_info()->exec_domain->signal_invmap[sig];
260	else
261		return sig;
262}
263
264static int setup_frame(int sig, struct k_sigaction *ka,
265		       sigset_t *set, struct pt_regs * regs)
266{
267	sigframe __user *frame;
268
269	frame = get_sigframe(ka, regs, sizeof(sigframe));
270	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
271		goto give_sigsegv;
272
273	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
274		goto give_sigsegv;
275
276	if (save_sigregs(regs, &frame->sregs))
277		goto give_sigsegv;
278	if (__put_user(&frame->sregs, &frame->sc.sregs))
279		goto give_sigsegv;
280
281	/* Set up to return from userspace.  If provided, use a stub
282	   already in userspace.  */
283	if (ka->sa.sa_flags & SA_RESTORER) {
284                regs->gprs[14] = (unsigned long)
285			ka->sa.sa_restorer | PSW_ADDR_AMODE;
286	} else {
287                regs->gprs[14] = (unsigned long)
288			frame->retcode | PSW_ADDR_AMODE;
289		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
290	                       (u16 __user *)(frame->retcode)))
291			goto give_sigsegv;
292	}
293
294	/* Set up backchain. */
295	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
296		goto give_sigsegv;
297
298	/* Set up registers for signal handler */
299	regs->gprs[15] = (unsigned long) frame;
300	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
301
302	regs->gprs[2] = map_signal(sig);
303	regs->gprs[3] = (unsigned long) &frame->sc;
304
305	/* We forgot to include these in the sigcontext.
306	   To avoid breaking binary compatibility, they are passed as args. */
307	regs->gprs[4] = current->thread.trap_no;
308	regs->gprs[5] = current->thread.prot_addr;
309
310	/* Place signal number on stack to allow backtrace from handler.  */
311	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
312		goto give_sigsegv;
313	return 0;
314
315give_sigsegv:
316	force_sigsegv(sig, current);
317	return -EFAULT;
318}
319
320static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
321			   sigset_t *set, struct pt_regs * regs)
322{
323	int err = 0;
324	rt_sigframe __user *frame;
325
326	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
327	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
328		goto give_sigsegv;
329
330	if (copy_siginfo_to_user(&frame->info, info))
331		goto give_sigsegv;
332
333	/* Create the ucontext.  */
334	err |= __put_user(0, &frame->uc.uc_flags);
335	err |= __put_user(NULL, &frame->uc.uc_link);
336	err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
337	err |= __put_user(sas_ss_flags(regs->gprs[15]),
338			  &frame->uc.uc_stack.ss_flags);
339	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
340	err |= save_sigregs(regs, &frame->uc.uc_mcontext);
341	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
342	if (err)
343		goto give_sigsegv;
344
345	/* Set up to return from userspace.  If provided, use a stub
346	   already in userspace.  */
347	if (ka->sa.sa_flags & SA_RESTORER) {
348                regs->gprs[14] = (unsigned long)
349			ka->sa.sa_restorer | PSW_ADDR_AMODE;
350	} else {
351                regs->gprs[14] = (unsigned long)
352			frame->retcode | PSW_ADDR_AMODE;
353		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
354			       (u16 __user *)(frame->retcode)))
355			goto give_sigsegv;
356	}
357
358	/* Set up backchain. */
359	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
360		goto give_sigsegv;
361
362	/* Set up registers for signal handler */
363	regs->gprs[15] = (unsigned long) frame;
364	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
365
366	regs->gprs[2] = map_signal(sig);
367	regs->gprs[3] = (unsigned long) &frame->info;
368	regs->gprs[4] = (unsigned long) &frame->uc;
369	return 0;
370
371give_sigsegv:
372	force_sigsegv(sig, current);
373	return -EFAULT;
374}
375
376/*
377 * OK, we're invoking a handler
378 */
379
380static int
381handle_signal(unsigned long sig, struct k_sigaction *ka,
382	      siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
383{
384	int ret;
385
386	/* Set up the stack frame */
387	if (ka->sa.sa_flags & SA_SIGINFO)
388		ret = setup_rt_frame(sig, ka, info, oldset, regs);
389	else
390		ret = setup_frame(sig, ka, oldset, regs);
391
392	if (ret == 0) {
393		spin_lock_irq(&current->sighand->siglock);
394		sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
395		if (!(ka->sa.sa_flags & SA_NODEFER))
396			sigaddset(&current->blocked,sig);
397		recalc_sigpending();
398		spin_unlock_irq(&current->sighand->siglock);
399	}
400
401	return ret;
402}
403
404/*
405 * Note that 'init' is a special process: it doesn't get signals it doesn't
406 * want to handle. Thus you cannot kill init even with a SIGKILL even by
407 * mistake.
408 *
409 * Note that we go through the signals twice: once to check the signals that
410 * the kernel can handle, and then we build all the user-level signal handling
411 * stack-frames in one go after that.
412 */
413void do_signal(struct pt_regs *regs)
414{
415	unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
416	siginfo_t info;
417	int signr;
418	struct k_sigaction ka;
419	sigset_t *oldset;
420
421	/*
422	 * We want the common case to go fast, which
423	 * is why we may in certain cases get here from
424	 * kernel mode. Just return without doing anything
425	 * if so.
426	 */
427	if (!user_mode(regs))
428		return;
429
430	if (test_thread_flag(TIF_RESTORE_SIGMASK))
431		oldset = &current->saved_sigmask;
432	else
433		oldset = &current->blocked;
434
435	/* Are we from a system call? */
436	if (regs->trap == __LC_SVC_OLD_PSW) {
437		continue_addr = regs->psw.addr;
438		restart_addr = continue_addr - regs->ilc;
439		retval = regs->gprs[2];
440
441		/* Prepare for system call restart.  We do this here so that a
442		   debugger will see the already changed PSW. */
443		switch (retval) {
444		case -ERESTARTNOHAND:
445		case -ERESTARTSYS:
446		case -ERESTARTNOINTR:
447			regs->gprs[2] = regs->orig_gpr2;
448			regs->psw.addr = restart_addr;
449			break;
450		case -ERESTART_RESTARTBLOCK:
451			regs->gprs[2] = -EINTR;
452		}
453		regs->trap = -1;	/* Don't deal with this again. */
454	}
455
456	/* Get signal to deliver.  When running under ptrace, at this point
457	   the debugger may change all our registers ... */
458	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
459
460	/* Depending on the signal settings we may need to revert the
461	   decision to restart the system call. */
462	if (signr > 0 && regs->psw.addr == restart_addr) {
463		if (retval == -ERESTARTNOHAND
464		    || (retval == -ERESTARTSYS
465			 && !(current->sighand->action[signr-1].sa.sa_flags
466			      & SA_RESTART))) {
467			regs->gprs[2] = -EINTR;
468			regs->psw.addr = continue_addr;
469		}
470	}
471
472	if (signr > 0) {
473		/* Whee!  Actually deliver the signal.  */
474#ifdef CONFIG_COMPAT
475		if (test_thread_flag(TIF_31BIT)) {
476			extern int handle_signal32(unsigned long sig,
477						   struct k_sigaction *ka,
478						   siginfo_t *info,
479						   sigset_t *oldset,
480						   struct pt_regs *regs);
481			if (handle_signal32(
482				    signr, &ka, &info, oldset, regs) == 0) {
483				if (test_thread_flag(TIF_RESTORE_SIGMASK))
484					clear_thread_flag(TIF_RESTORE_SIGMASK);
485			}
486			return;
487	        }
488#endif
489		if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
490			/*
491			 * A signal was successfully delivered; the saved
492			 * sigmask will have been stored in the signal frame,
493			 * and will be restored by sigreturn, so we can simply
494			 * clear the TIF_RESTORE_SIGMASK flag.
495			 */
496			if (test_thread_flag(TIF_RESTORE_SIGMASK))
497				clear_thread_flag(TIF_RESTORE_SIGMASK);
498		}
499		return;
500	}
501
502	/*
503	 * If there's no signal to deliver, we just put the saved sigmask back.
504	 */
505	if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
506		clear_thread_flag(TIF_RESTORE_SIGMASK);
507		sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
508	}
509
510	/* Restart a different system call. */
511	if (retval == -ERESTART_RESTARTBLOCK
512	    && regs->psw.addr == continue_addr) {
513		regs->gprs[2] = __NR_restart_syscall;
514		set_thread_flag(TIF_RESTART_SVC);
515	}
516}
517