xref: /openbmc/linux/arch/s390/kernel/signal.c (revision 33a03aad) 
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 <linux/tracehook.h>
28 #include <linux/syscalls.h>
29 #include <linux/compat.h>
30 #include <asm/ucontext.h>
31 #include <asm/uaccess.h>
32 #include <asm/lowcore.h>
33 #include <asm/switch_to.h>
34 #include "entry.h"
35 
36 typedef struct
37 {
38 	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
39 	struct sigcontext sc;
40 	_sigregs sregs;
41 	int signo;
42 	__u8 retcode[S390_SYSCALL_SIZE];
43 } sigframe;
44 
45 typedef struct
46 {
47 	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
48 	__u8 retcode[S390_SYSCALL_SIZE];
49 	struct siginfo info;
50 	struct ucontext uc;
51 } rt_sigframe;
52 
53 /*
54  * Atomically swap in the new signal mask, and wait for a signal.
55  */
56 SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask)
57 {
58 	sigset_t blocked;
59 	siginitset(&blocked, mask);
60 	return sigsuspend(&blocked);
61 }
62 
63 SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act,
64 		struct old_sigaction __user *, oact)
65 {
66 	struct k_sigaction new_ka, old_ka;
67 	int ret;
68 
69 	if (act) {
70 		old_sigset_t mask;
71 		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
72 		    __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
73 		    __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
74 		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
75 		    __get_user(mask, &act->sa_mask))
76 			return -EFAULT;
77 		siginitset(&new_ka.sa.sa_mask, mask);
78 	}
79 
80 	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
81 
82 	if (!ret && oact) {
83 		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
84 		    __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
85 		    __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
86 		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
87 		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
88 			return -EFAULT;
89 	}
90 
91 	return ret;
92 }
93 
94 SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
95 		stack_t __user *, uoss)
96 {
97 	struct pt_regs *regs = task_pt_regs(current);
98 	return do_sigaltstack(uss, uoss, regs->gprs[15]);
99 }
100 
101 /* Returns non-zero on fault. */
102 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
103 {
104 	_sigregs user_sregs;
105 
106 	save_access_regs(current->thread.acrs);
107 
108 	/* Copy a 'clean' PSW mask to the user to avoid leaking
109 	   information about whether PER is currently on.  */
110 	user_sregs.regs.psw.mask = psw_user_bits |
111 		(regs->psw.mask & PSW_MASK_USER);
112 	user_sregs.regs.psw.addr = regs->psw.addr;
113 	memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
114 	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
115 	       sizeof(sregs->regs.acrs));
116 	/*
117 	 * We have to store the fp registers to current->thread.fp_regs
118 	 * to merge them with the emulated registers.
119 	 */
120 	save_fp_regs(&current->thread.fp_regs);
121 	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
122 	       sizeof(s390_fp_regs));
123 	return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
124 }
125 
126 /* Returns positive number on error */
127 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
128 {
129 	int err;
130 	_sigregs user_sregs;
131 
132 	/* Alwys make any pending restarted system call return -EINTR */
133 	current_thread_info()->restart_block.fn = do_no_restart_syscall;
134 
135 	err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
136 	if (err)
137 		return err;
138 	/* Use regs->psw.mask instead of psw_user_bits to preserve PER bit. */
139 	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
140 		(user_sregs.regs.psw.mask & PSW_MASK_USER);
141 	/* Check for invalid amode */
142 	if (regs->psw.mask & PSW_MASK_EA)
143 		regs->psw.mask |= PSW_MASK_BA;
144 	regs->psw.addr = user_sregs.regs.psw.addr;
145 	memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
146 	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
147 	       sizeof(sregs->regs.acrs));
148 	restore_access_regs(current->thread.acrs);
149 
150 	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
151 	       sizeof(s390_fp_regs));
152 	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
153 
154 	restore_fp_regs(&current->thread.fp_regs);
155 	clear_thread_flag(TIF_SYSCALL);	/* No longer in a system call */
156 	return 0;
157 }
158 
159 SYSCALL_DEFINE0(sigreturn)
160 {
161 	struct pt_regs *regs = task_pt_regs(current);
162 	sigframe __user *frame = (sigframe __user *)regs->gprs[15];
163 	sigset_t set;
164 
165 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
166 		goto badframe;
167 	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
168 		goto badframe;
169 	set_current_blocked(&set);
170 	if (restore_sigregs(regs, &frame->sregs))
171 		goto badframe;
172 	return regs->gprs[2];
173 badframe:
174 	force_sig(SIGSEGV, current);
175 	return 0;
176 }
177 
178 SYSCALL_DEFINE0(rt_sigreturn)
179 {
180 	struct pt_regs *regs = task_pt_regs(current);
181 	rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
182 	sigset_t set;
183 
184 	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
185 		goto badframe;
186 	if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
187 		goto badframe;
188 	set_current_blocked(&set);
189 	if (restore_sigregs(regs, &frame->uc.uc_mcontext))
190 		goto badframe;
191 	if (do_sigaltstack(&frame->uc.uc_stack, NULL,
192 			   regs->gprs[15]) == -EFAULT)
193 		goto badframe;
194 	return regs->gprs[2];
195 badframe:
196 	force_sig(SIGSEGV, current);
197 	return 0;
198 }
199 
200 /*
201  * Set up a signal frame.
202  */
203 
204 
205 /*
206  * Determine which stack to use..
207  */
208 static inline void __user *
209 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
210 {
211 	unsigned long sp;
212 
213 	/* Default to using normal stack */
214 	sp = regs->gprs[15];
215 
216 	/* Overflow on alternate signal stack gives SIGSEGV. */
217 	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
218 		return (void __user *) -1UL;
219 
220 	/* This is the X/Open sanctioned signal stack switching.  */
221 	if (ka->sa.sa_flags & SA_ONSTACK) {
222 		if (! sas_ss_flags(sp))
223 			sp = current->sas_ss_sp + current->sas_ss_size;
224 	}
225 
226 	return (void __user *)((sp - frame_size) & -8ul);
227 }
228 
229 static inline int map_signal(int sig)
230 {
231 	if (current_thread_info()->exec_domain
232 	    && current_thread_info()->exec_domain->signal_invmap
233 	    && sig < 32)
234 		return current_thread_info()->exec_domain->signal_invmap[sig];
235 	else
236 		return sig;
237 }
238 
239 static int setup_frame(int sig, struct k_sigaction *ka,
240 		       sigset_t *set, struct pt_regs * regs)
241 {
242 	sigframe __user *frame;
243 
244 	frame = get_sigframe(ka, regs, sizeof(sigframe));
245 	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
246 		goto give_sigsegv;
247 
248 	if (frame == (void __user *) -1UL)
249 		goto give_sigsegv;
250 
251 	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
252 		goto give_sigsegv;
253 
254 	if (save_sigregs(regs, &frame->sregs))
255 		goto give_sigsegv;
256 	if (__put_user(&frame->sregs, &frame->sc.sregs))
257 		goto give_sigsegv;
258 
259 	/* Set up to return from userspace.  If provided, use a stub
260 	   already in userspace.  */
261 	if (ka->sa.sa_flags & SA_RESTORER) {
262                 regs->gprs[14] = (unsigned long)
263 			ka->sa.sa_restorer | PSW_ADDR_AMODE;
264 	} else {
265                 regs->gprs[14] = (unsigned long)
266 			frame->retcode | PSW_ADDR_AMODE;
267 		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
268 	                       (u16 __user *)(frame->retcode)))
269 			goto give_sigsegv;
270 	}
271 
272 	/* Set up backchain. */
273 	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
274 		goto give_sigsegv;
275 
276 	/* Set up registers for signal handler */
277 	regs->gprs[15] = (unsigned long) frame;
278 	regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA;	/* 64 bit amode */
279 	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
280 
281 	regs->gprs[2] = map_signal(sig);
282 	regs->gprs[3] = (unsigned long) &frame->sc;
283 
284 	/* We forgot to include these in the sigcontext.
285 	   To avoid breaking binary compatibility, they are passed as args. */
286 	if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
287 	    sig == SIGTRAP || sig == SIGFPE) {
288 		/* set extra registers only for synchronous signals */
289 		regs->gprs[4] = regs->int_code & 127;
290 		regs->gprs[5] = regs->int_parm_long;
291 		regs->gprs[6] = task_thread_info(current)->last_break;
292 	}
293 
294 	/* Place signal number on stack to allow backtrace from handler.  */
295 	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
296 		goto give_sigsegv;
297 	return 0;
298 
299 give_sigsegv:
300 	force_sigsegv(sig, current);
301 	return -EFAULT;
302 }
303 
304 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
305 			   sigset_t *set, struct pt_regs * regs)
306 {
307 	int err = 0;
308 	rt_sigframe __user *frame;
309 
310 	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
311 	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
312 		goto give_sigsegv;
313 
314 	if (frame == (void __user *) -1UL)
315 		goto give_sigsegv;
316 
317 	if (copy_siginfo_to_user(&frame->info, info))
318 		goto give_sigsegv;
319 
320 	/* Create the ucontext.  */
321 	err |= __put_user(0, &frame->uc.uc_flags);
322 	err |= __put_user(NULL, &frame->uc.uc_link);
323 	err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
324 	err |= __put_user(sas_ss_flags(regs->gprs[15]),
325 			  &frame->uc.uc_stack.ss_flags);
326 	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
327 	err |= save_sigregs(regs, &frame->uc.uc_mcontext);
328 	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
329 	if (err)
330 		goto give_sigsegv;
331 
332 	/* Set up to return from userspace.  If provided, use a stub
333 	   already in userspace.  */
334 	if (ka->sa.sa_flags & SA_RESTORER) {
335                 regs->gprs[14] = (unsigned long)
336 			ka->sa.sa_restorer | PSW_ADDR_AMODE;
337 	} else {
338                 regs->gprs[14] = (unsigned long)
339 			frame->retcode | PSW_ADDR_AMODE;
340 		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
341 			       (u16 __user *)(frame->retcode)))
342 			goto give_sigsegv;
343 	}
344 
345 	/* Set up backchain. */
346 	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
347 		goto give_sigsegv;
348 
349 	/* Set up registers for signal handler */
350 	regs->gprs[15] = (unsigned long) frame;
351 	regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA;	/* 64 bit amode */
352 	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
353 
354 	regs->gprs[2] = map_signal(sig);
355 	regs->gprs[3] = (unsigned long) &frame->info;
356 	regs->gprs[4] = (unsigned long) &frame->uc;
357 	regs->gprs[5] = task_thread_info(current)->last_break;
358 	return 0;
359 
360 give_sigsegv:
361 	force_sigsegv(sig, current);
362 	return -EFAULT;
363 }
364 
365 static void handle_signal(unsigned long sig, struct k_sigaction *ka,
366 			 siginfo_t *info, sigset_t *oldset,
367 			 struct pt_regs *regs)
368 {
369 	int ret;
370 
371 	/* Set up the stack frame */
372 	if (ka->sa.sa_flags & SA_SIGINFO)
373 		ret = setup_rt_frame(sig, ka, info, oldset, regs);
374 	else
375 		ret = setup_frame(sig, ka, oldset, regs);
376 	if (ret)
377 		return;
378 	signal_delivered(sig, info, ka, regs,
379 				 test_thread_flag(TIF_SINGLE_STEP));
380 }
381 
382 /*
383  * Note that 'init' is a special process: it doesn't get signals it doesn't
384  * want to handle. Thus you cannot kill init even with a SIGKILL even by
385  * mistake.
386  *
387  * Note that we go through the signals twice: once to check the signals that
388  * the kernel can handle, and then we build all the user-level signal handling
389  * stack-frames in one go after that.
390  */
391 void do_signal(struct pt_regs *regs)
392 {
393 	siginfo_t info;
394 	int signr;
395 	struct k_sigaction ka;
396 	sigset_t *oldset = sigmask_to_save();
397 
398 	/*
399 	 * Get signal to deliver. When running under ptrace, at this point
400 	 * the debugger may change all our registers, including the system
401 	 * call information.
402 	 */
403 	current_thread_info()->system_call =
404 		test_thread_flag(TIF_SYSCALL) ? regs->int_code : 0;
405 	signr = get_signal_to_deliver(&info, &ka, regs, NULL);
406 
407 	if (signr > 0) {
408 		/* Whee!  Actually deliver the signal.  */
409 		if (current_thread_info()->system_call) {
410 			regs->int_code = current_thread_info()->system_call;
411 			/* Check for system call restarting. */
412 			switch (regs->gprs[2]) {
413 			case -ERESTART_RESTARTBLOCK:
414 			case -ERESTARTNOHAND:
415 				regs->gprs[2] = -EINTR;
416 				break;
417 			case -ERESTARTSYS:
418 				if (!(ka.sa.sa_flags & SA_RESTART)) {
419 					regs->gprs[2] = -EINTR;
420 					break;
421 				}
422 			/* fallthrough */
423 			case -ERESTARTNOINTR:
424 				regs->gprs[2] = regs->orig_gpr2;
425 				regs->psw.addr =
426 					__rewind_psw(regs->psw,
427 						     regs->int_code >> 16);
428 				break;
429 			}
430 		}
431 		/* No longer in a system call */
432 		clear_thread_flag(TIF_SYSCALL);
433 
434 		if (is_compat_task())
435 			handle_signal32(signr, &ka, &info, oldset, regs);
436 		else
437 			handle_signal(signr, &ka, &info, oldset, regs);
438 		return;
439 	}
440 
441 	/* No handlers present - check for system call restart */
442 	clear_thread_flag(TIF_SYSCALL);
443 	if (current_thread_info()->system_call) {
444 		regs->int_code = current_thread_info()->system_call;
445 		switch (regs->gprs[2]) {
446 		case -ERESTART_RESTARTBLOCK:
447 			/* Restart with sys_restart_syscall */
448 			regs->int_code = __NR_restart_syscall;
449 		/* fallthrough */
450 		case -ERESTARTNOHAND:
451 		case -ERESTARTSYS:
452 		case -ERESTARTNOINTR:
453 			/* Restart system call with magic TIF bit. */
454 			regs->gprs[2] = regs->orig_gpr2;
455 			set_thread_flag(TIF_SYSCALL);
456 			break;
457 		}
458 	}
459 
460 	/*
461 	 * If there's no signal to deliver, we just put the saved sigmask back.
462 	 */
463 	restore_saved_sigmask();
464 }
465 
466 void do_notify_resume(struct pt_regs *regs)
467 {
468 	clear_thread_flag(TIF_NOTIFY_RESUME);
469 	tracehook_notify_resume(regs);
470 }
471