signal.c 12 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2
 *    Copyright IBM Corp. 1999, 2006
Linus Torvalds's avatar
Linus Torvalds committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *
 *    Based on Intel version
 * 
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 */

#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/stddef.h>
#include <linux/tty.h>
#include <linux/personality.h>
#include <linux/binfmts.h>
Martin Schwidefsky's avatar
Martin Schwidefsky committed
25
#include <linux/tracehook.h>
26
#include <linux/syscalls.h>
27
#include <linux/compat.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/lowcore.h>
31
#include <asm/switch_to.h>
32
#include "entry.h"
Linus Torvalds's avatar
Linus Torvalds committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	struct sigcontext sc;
	_sigregs sregs;
	int signo;
	__u8 retcode[S390_SYSCALL_SIZE];
} sigframe;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
	__u8 retcode[S390_SYSCALL_SIZE];
	struct siginfo info;
	struct ucontext uc;
} rt_sigframe;

/* Returns non-zero on fault. */
static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
{
54 55
	_sigregs user_sregs;

Linus Torvalds's avatar
Linus Torvalds committed
56 57 58 59
	save_access_regs(current->thread.acrs);

	/* Copy a 'clean' PSW mask to the user to avoid leaking
	   information about whether PER is currently on.  */
60
	user_sregs.regs.psw.mask = PSW_USER_BITS |
61
		(regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
62 63
	user_sregs.regs.psw.addr = regs->psw.addr;
	memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
64
	memcpy(&user_sregs.regs.acrs, current->thread.acrs,
65
	       sizeof(user_sregs.regs.acrs));
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69
	/* 
	 * We have to store the fp registers to current->thread.fp_regs
	 * to merge them with the emulated registers.
	 */
70 71
	save_fp_ctl(&current->thread.fp_regs.fpc);
	save_fp_regs(current->thread.fp_regs.fprs);
72
	memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
73
	       sizeof(user_sregs.fpregs));
74 75 76
	if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
		return -EFAULT;
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
77 78 79 80
}

static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
{
81
	_sigregs user_sregs;
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84 85

	/* Alwys make any pending restarted system call return -EINTR */
	current_thread_info()->restart_block.fn = do_no_restart_syscall;

86
	if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
87
		return -EFAULT;
88

89 90 91
	if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
		return -EINVAL;

92 93 94 95
	/* Loading the floating-point-control word can fail. Do that first. */
	if (restore_fp_ctl(&user_sregs.fpregs.fpc))
		return -EINVAL;

96
	/* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
97
	regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
98
		(user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
99
	/* Check for invalid user address space control. */
100 101
	if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
		regs->psw.mask = PSW_ASC_PRIMARY |
102
			(regs->psw.mask & ~PSW_MASK_ASC);
103 104 105 106
	/* Check for invalid amode */
	if (regs->psw.mask & PSW_MASK_EA)
		regs->psw.mask |= PSW_MASK_BA;
	regs->psw.addr = user_sregs.regs.psw.addr;
107
	memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
108
	memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
109
	       sizeof(current->thread.acrs));
Linus Torvalds's avatar
Linus Torvalds committed
110 111
	restore_access_regs(current->thread.acrs);

112
	memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
113
	       sizeof(current->thread.fp_regs));
Linus Torvalds's avatar
Linus Torvalds committed
114

115
	restore_fp_regs(current->thread.fp_regs.fprs);
116
	clear_thread_flag(TIF_SYSCALL);	/* No longer in a system call */
Linus Torvalds's avatar
Linus Torvalds committed
117 118 119
	return 0;
}

120
SYSCALL_DEFINE0(sigreturn)
Linus Torvalds's avatar
Linus Torvalds committed
121
{
122
	struct pt_regs *regs = task_pt_regs(current);
Linus Torvalds's avatar
Linus Torvalds committed
123 124 125 126 127
	sigframe __user *frame = (sigframe __user *)regs->gprs[15];
	sigset_t set;

	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
		goto badframe;
128
	set_current_blocked(&set);
Linus Torvalds's avatar
Linus Torvalds committed
129 130 131 132 133 134 135 136
	if (restore_sigregs(regs, &frame->sregs))
		goto badframe;
	return regs->gprs[2];
badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

137
SYSCALL_DEFINE0(rt_sigreturn)
Linus Torvalds's avatar
Linus Torvalds committed
138
{
139
	struct pt_regs *regs = task_pt_regs(current);
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142 143 144
	rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
	sigset_t set;

	if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;
145
	set_current_blocked(&set);
Linus Torvalds's avatar
Linus Torvalds committed
146 147
	if (restore_sigregs(regs, &frame->uc.uc_mcontext))
		goto badframe;
148
	if (restore_altstack(&frame->uc.uc_stack))
149
		goto badframe;
Linus Torvalds's avatar
Linus Torvalds committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
	return regs->gprs[2];
badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

/*
 * Set up a signal frame.
 */


/*
 * Determine which stack to use..
 */
static inline void __user *
get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
{
	unsigned long sp;

	/* Default to using normal stack */
	sp = regs->gprs[15];

172 173 174 175
	/* Overflow on alternate signal stack gives SIGSEGV. */
	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
		return (void __user *) -1UL;

Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
		if (! sas_ss_flags(sp))
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

	return (void __user *)((sp - frame_size) & -8ul);
}

static inline int map_signal(int sig)
{
	if (current_thread_info()->exec_domain
	    && current_thread_info()->exec_domain->signal_invmap
	    && sig < 32)
		return current_thread_info()->exec_domain->signal_invmap[sig];
	else
		return sig;
}

195 196
static int setup_frame(int sig, struct k_sigaction *ka,
		       sigset_t *set, struct pt_regs * regs)
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201
{
	sigframe __user *frame;

	frame = get_sigframe(ka, regs, sizeof(sigframe));

202 203 204
	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

Linus Torvalds's avatar
Linus Torvalds committed
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
		goto give_sigsegv;

	if (save_sigregs(regs, &frame->sregs))
		goto give_sigsegv;
	if (__put_user(&frame->sregs, &frame->sc.sregs))
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
                regs->gprs[14] = (unsigned long)
			ka->sa.sa_restorer | PSW_ADDR_AMODE;
	} else {
                regs->gprs[14] = (unsigned long)
			frame->retcode | PSW_ADDR_AMODE;
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
	                       (u16 __user *)(frame->retcode)))
			goto give_sigsegv;
	}

	/* Set up backchain. */
	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->gprs[15] = (unsigned long) frame;
232 233
	/* Force default amode and default user address space control. */
	regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
234
		(PSW_USER_BITS & PSW_MASK_ASC) |
235
		(regs->psw.mask & ~PSW_MASK_ASC);
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238 239 240 241 242
	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (unsigned long) &frame->sc;

	/* We forgot to include these in the sigcontext.
	   To avoid breaking binary compatibility, they are passed as args. */
243 244 245 246 247 248 249
	if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
	    sig == SIGTRAP || sig == SIGFPE) {
		/* set extra registers only for synchronous signals */
		regs->gprs[4] = regs->int_code & 127;
		regs->gprs[5] = regs->int_parm_long;
		regs->gprs[6] = task_thread_info(current)->last_break;
	}
Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253

	/* Place signal number on stack to allow backtrace from handler.  */
	if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
		goto give_sigsegv;
254
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
255 256 257

give_sigsegv:
	force_sigsegv(sig, current);
258
	return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
259 260
}

261
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
Linus Torvalds's avatar
Linus Torvalds committed
262 263 264 265 266 267 268
			   sigset_t *set, struct pt_regs * regs)
{
	int err = 0;
	rt_sigframe __user *frame;

	frame = get_sigframe(ka, regs, sizeof(rt_sigframe));

269 270 271
	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

Linus Torvalds's avatar
Linus Torvalds committed
272 273 274 275 276
	if (copy_siginfo_to_user(&frame->info, info))
		goto give_sigsegv;

	/* Create the ucontext.  */
	err |= __put_user(0, &frame->uc.uc_flags);
Al Viro's avatar
Al Viro committed
277
	err |= __put_user(NULL, &frame->uc.uc_link);
278
	err |= __save_altstack(&frame->uc.uc_stack, regs->gprs[15]);
Linus Torvalds's avatar
Linus Torvalds committed
279 280 281 282 283 284 285 286 287 288 289 290 291
	err |= save_sigregs(regs, &frame->uc.uc_mcontext);
	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
	if (err)
		goto give_sigsegv;

	/* Set up to return from userspace.  If provided, use a stub
	   already in userspace.  */
	if (ka->sa.sa_flags & SA_RESTORER) {
                regs->gprs[14] = (unsigned long)
			ka->sa.sa_restorer | PSW_ADDR_AMODE;
	} else {
                regs->gprs[14] = (unsigned long)
			frame->retcode | PSW_ADDR_AMODE;
292 293 294
		if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
			       (u16 __user *)(frame->retcode)))
			goto give_sigsegv;
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297 298 299 300 301 302
	}

	/* Set up backchain. */
	if (__put_user(regs->gprs[15], (addr_t __user *) frame))
		goto give_sigsegv;

	/* Set up registers for signal handler */
	regs->gprs[15] = (unsigned long) frame;
303 304
	/* Force default amode and default user address space control. */
	regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
305
		(PSW_USER_BITS & PSW_MASK_ASC) |
306
		(regs->psw.mask & ~PSW_MASK_ASC);
Linus Torvalds's avatar
Linus Torvalds committed
307 308 309 310 311
	regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;

	regs->gprs[2] = map_signal(sig);
	regs->gprs[3] = (unsigned long) &frame->info;
	regs->gprs[4] = (unsigned long) &frame->uc;
312
	regs->gprs[5] = task_thread_info(current)->last_break;
313
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316

give_sigsegv:
	force_sigsegv(sig, current);
317
	return -EFAULT;
Linus Torvalds's avatar
Linus Torvalds committed
318 319
}

320
static void handle_signal(unsigned long sig, struct k_sigaction *ka,
321 322
			 siginfo_t *info, sigset_t *oldset,
			 struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
323
{
324 325
	int ret;

Linus Torvalds's avatar
Linus Torvalds committed
326 327
	/* Set up the stack frame */
	if (ka->sa.sa_flags & SA_SIGINFO)
328
		ret = setup_rt_frame(sig, ka, info, oldset, regs);
Linus Torvalds's avatar
Linus Torvalds committed
329
	else
330
		ret = setup_frame(sig, ka, oldset, regs);
331
	if (ret)
332
		return;
Al Viro's avatar
Al Viro committed
333
	signal_delivered(sig, info, ka, regs,
334
				 test_thread_flag(TIF_SINGLE_STEP));
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337 338 339 340 341 342 343 344 345
}

/*
 * Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 *
 * Note that we go through the signals twice: once to check the signals that
 * the kernel can handle, and then we build all the user-level signal handling
 * stack-frames in one go after that.
 */
346
void do_signal(struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349 350
{
	siginfo_t info;
	int signr;
	struct k_sigaction ka;
Al Viro's avatar
Al Viro committed
351
	sigset_t *oldset = sigmask_to_save();
Linus Torvalds's avatar
Linus Torvalds committed
352

353 354 355 356 357
	/*
	 * Get signal to deliver. When running under ptrace, at this point
	 * the debugger may change all our registers, including the system
	 * call information.
	 */
358
	current_thread_info()->system_call =
359
		test_thread_flag(TIF_SYSCALL) ? regs->int_code : 0;
Linus Torvalds's avatar
Linus Torvalds committed
360 361 362 363
	signr = get_signal_to_deliver(&info, &ka, regs, NULL);

	if (signr > 0) {
		/* Whee!  Actually deliver the signal.  */
364
		if (current_thread_info()->system_call) {
365
			regs->int_code = current_thread_info()->system_call;
366 367 368 369 370 371 372 373 374 375 376 377 378 379
			/* Check for system call restarting. */
			switch (regs->gprs[2]) {
			case -ERESTART_RESTARTBLOCK:
			case -ERESTARTNOHAND:
				regs->gprs[2] = -EINTR;
				break;
			case -ERESTARTSYS:
				if (!(ka.sa.sa_flags & SA_RESTART)) {
					regs->gprs[2] = -EINTR;
					break;
				}
			/* fallthrough */
			case -ERESTARTNOINTR:
				regs->gprs[2] = regs->orig_gpr2;
380 381
				regs->psw.addr =
					__rewind_psw(regs->psw,
382
						     regs->int_code >> 16);
383 384 385
				break;
			}
		}
386 387
		/* No longer in a system call */
		clear_thread_flag(TIF_SYSCALL);
388

389 390 391 392
		if (is_compat_task())
			handle_signal32(signr, &ka, &info, oldset, regs);
		else
			handle_signal(signr, &ka, &info, oldset, regs);
393 394 395
		return;
	}

396
	/* No handlers present - check for system call restart */
397
	clear_thread_flag(TIF_SYSCALL);
398
	if (current_thread_info()->system_call) {
399
		regs->int_code = current_thread_info()->system_call;
400 401 402
		switch (regs->gprs[2]) {
		case -ERESTART_RESTARTBLOCK:
			/* Restart with sys_restart_syscall */
403
			regs->int_code = __NR_restart_syscall;
404 405 406 407 408 409
		/* fallthrough */
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			/* Restart system call with magic TIF bit. */
			regs->gprs[2] = regs->orig_gpr2;
410
			set_thread_flag(TIF_SYSCALL);
411 412
			if (test_thread_flag(TIF_SINGLE_STEP))
				set_thread_flag(TIF_PER_TRAP);
413
			break;
414 415 416
		}
	}

417 418 419
	/*
	 * If there's no signal to deliver, we just put the saved sigmask back.
	 */
420
	restore_saved_sigmask();
Linus Torvalds's avatar
Linus Torvalds committed
421
}
Martin Schwidefsky's avatar
Martin Schwidefsky committed
422 423 424 425 426 427

void do_notify_resume(struct pt_regs *regs)
{
	clear_thread_flag(TIF_NOTIFY_RESUME);
	tracehook_notify_resume(regs);
}