compat_signal.c 17.4 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  arch/s390/kernel/compat_signal.c
L
Linus Torvalds 已提交
3
 *
4
 *    Copyright (C) IBM Corp. 2000,2006
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
 *               Gerhard Tonn (ton@de.ibm.com)                  
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
 */

#include <linux/compat.h>
#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>
#include <asm/ucontext.h>
#include <asm/uaccess.h>
#include <asm/lowcore.h>
#include "compat_linux.h"
#include "compat_ptrace.h"
32
#include "entry.h"
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41

#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	struct sigcontext32 sc;
	_sigregs32 sregs;
	int signo;
42
	__u32 gprs_high[NUM_GPRS];
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51
	__u8 retcode[S390_SYSCALL_SIZE];
} sigframe32;

typedef struct 
{
	__u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
	__u8 retcode[S390_SYSCALL_SIZE];
	compat_siginfo_t info;
	struct ucontext32 uc;
52
	__u32 gprs_high[NUM_GPRS];
L
Linus Torvalds 已提交
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
} rt_sigframe32;

int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
{
	int err;

	if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
		return -EFAULT;

	/* If you change siginfo_t structure, please be sure
	   this code is fixed accordingly.
	   It should never copy any pad contained in the structure
	   to avoid security leaks, but must copy the generic
	   3 ints plus the relevant union member.  
	   This routine must convert siginfo from 64bit to 32bit as well
	   at the same time.  */
	err = __put_user(from->si_signo, &to->si_signo);
	err |= __put_user(from->si_errno, &to->si_errno);
	err |= __put_user((short)from->si_code, &to->si_code);
	if (from->si_code < 0)
		err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	else {
		switch (from->si_code >> 16) {
		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
		case __SI_MESGQ >> 16:
			err |= __put_user(from->si_int, &to->si_int);
			/* fallthrough */
		case __SI_KILL >> 16:
			err |= __put_user(from->si_pid, &to->si_pid);
			err |= __put_user(from->si_uid, &to->si_uid);
			break;
		case __SI_CHLD >> 16:
			err |= __put_user(from->si_pid, &to->si_pid);
			err |= __put_user(from->si_uid, &to->si_uid);
			err |= __put_user(from->si_utime, &to->si_utime);
			err |= __put_user(from->si_stime, &to->si_stime);
			err |= __put_user(from->si_status, &to->si_status);
			break;
		case __SI_FAULT >> 16:
			err |= __put_user((unsigned long) from->si_addr,
					  &to->si_addr);
			break;
		case __SI_POLL >> 16:
			err |= __put_user(from->si_band, &to->si_band);
			err |= __put_user(from->si_fd, &to->si_fd);
			break;
		case __SI_TIMER >> 16:
			err |= __put_user(from->si_tid, &to->si_tid);
			err |= __put_user(from->si_overrun, &to->si_overrun);
			err |= __put_user(from->si_int, &to->si_int);
			break;
		default:
			break;
		}
	}
	return err;
}

int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
{
	int err;
	u32 tmp;

	if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
		return -EFAULT;

	err = __get_user(to->si_signo, &from->si_signo);
	err |= __get_user(to->si_errno, &from->si_errno);
	err |= __get_user(to->si_code, &from->si_code);

	if (to->si_code < 0)
		err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
	else {
		switch (to->si_code >> 16) {
		case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
		case __SI_MESGQ >> 16:
			err |= __get_user(to->si_int, &from->si_int);
			/* fallthrough */
		case __SI_KILL >> 16:
			err |= __get_user(to->si_pid, &from->si_pid);
			err |= __get_user(to->si_uid, &from->si_uid);
			break;
		case __SI_CHLD >> 16:
			err |= __get_user(to->si_pid, &from->si_pid);
			err |= __get_user(to->si_uid, &from->si_uid);
			err |= __get_user(to->si_utime, &from->si_utime);
			err |= __get_user(to->si_stime, &from->si_stime);
			err |= __get_user(to->si_status, &from->si_status);
			break;
		case __SI_FAULT >> 16:
			err |= __get_user(tmp, &from->si_addr);
144 145
			to->si_addr = (void __force __user *)
				(u64) (tmp & PSW32_ADDR_INSN);
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
			break;
		case __SI_POLL >> 16:
			err |= __get_user(to->si_band, &from->si_band);
			err |= __get_user(to->si_fd, &from->si_fd);
			break;
		case __SI_TIMER >> 16:
			err |= __get_user(to->si_tid, &from->si_tid);
			err |= __get_user(to->si_overrun, &from->si_overrun);
			err |= __get_user(to->si_int, &from->si_int);
			break;
		default:
			break;
		}
	}
	return err;
}

asmlinkage long
sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
		 struct old_sigaction32 __user *oact)
{
        struct k_sigaction new_ka, old_ka;
	unsigned long sa_handler, sa_restorer;
        int ret;

        if (act) {
		compat_old_sigset_t mask;
		if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
		    __get_user(sa_handler, &act->sa_handler) ||
H
Heiko Carstens 已提交
175 176 177
		    __get_user(sa_restorer, &act->sa_restorer) ||
		    __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
		    __get_user(mask, &act->sa_mask))
L
Linus Torvalds 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190
			return -EFAULT;
		new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
		new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
		siginitset(&new_ka.sa.sa_mask, mask);
        }

        ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
		sa_handler = (unsigned long) old_ka.sa.sa_handler;
		sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
		if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
		    __put_user(sa_handler, &oact->sa_handler) ||
H
Heiko Carstens 已提交
191 192 193
		    __put_user(sa_restorer, &oact->sa_restorer) ||
		    __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
		    __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
L
Linus Torvalds 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
			return -EFAULT;
        }

	return ret;
}

asmlinkage long
sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
	   struct sigaction32 __user *oact,  size_t sigsetsize)
{
	struct k_sigaction new_ka, old_ka;
	unsigned long sa_handler;
	int ret;
	compat_sigset_t set32;

	/* XXX: Don't preclude handling different sized sigset_t's.  */
	if (sigsetsize != sizeof(compat_sigset_t))
		return -EINVAL;

	if (act) {
		ret = get_user(sa_handler, &act->sa_handler);
		ret |= __copy_from_user(&set32, &act->sa_mask,
					sizeof(compat_sigset_t));
217 218
		new_ka.sa.sa_mask.sig[0] =
			set32.sig[0] | (((long)set32.sig[1]) << 32);
L
Linus Torvalds 已提交
219 220 221 222 223 224 225 226 227 228
		ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
		
		if (ret)
			return -EFAULT;
		new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
	}

	ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);

	if (!ret && oact) {
229 230
		set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
		set32.sig[0] = old_ka.sa.sa_mask.sig[0];
L
Linus Torvalds 已提交
231 232 233 234 235 236 237 238 239 240
		ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
		ret |= __copy_to_user(&oact->sa_mask, &set32,
				      sizeof(compat_sigset_t));
		ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
	}

	return ret;
}

asmlinkage long
M
Martin Schwidefsky 已提交
241
sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
L
Linus Torvalds 已提交
242
{
M
Martin Schwidefsky 已提交
243
	struct pt_regs *regs = task_pt_regs(current);
L
Linus Torvalds 已提交
244 245 246 247 248 249 250 251 252 253 254 255 256
	stack_t kss, koss;
	unsigned long ss_sp;
	int ret, err = 0;
	mm_segment_t old_fs = get_fs();

	if (uss) {
		if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
			return -EFAULT;
		err |= __get_user(ss_sp, &uss->ss_sp);
		err |= __get_user(kss.ss_size, &uss->ss_size);
		err |= __get_user(kss.ss_flags, &uss->ss_flags);
		if (err)
			return -EFAULT;
A
Al Viro 已提交
257
		kss.ss_sp = (void __user *) ss_sp;
L
Linus Torvalds 已提交
258 259 260
	}

	set_fs (KERNEL_DS);
261 262
	ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
			     (stack_t __force __user *) (uoss ? &koss : NULL),
L
Linus Torvalds 已提交
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
			     regs->gprs[15]);
	set_fs (old_fs);

	if (!ret && uoss) {
		if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
			return -EFAULT;
		ss_sp = (unsigned long) koss.ss_sp;
		err |= __put_user(ss_sp, &uoss->ss_sp);
		err |= __put_user(koss.ss_size, &uoss->ss_size);
		err |= __put_user(koss.ss_flags, &uoss->ss_flags);
		if (err)
			return -EFAULT;
	}
	return ret;
}

static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
{
	_s390_regs_common32 regs32;
	int err, i;

284 285
	regs32.psw.mask = psw32_user_bits |
		((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
286 287
	regs32.psw.addr = (__u32) regs->psw.addr |
		(__u32)(regs->psw.mask & PSW_MASK_BA);
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
	for (i = 0; i < NUM_GPRS; i++)
		regs32.gprs[i] = (__u32) regs->gprs[i];
	save_access_regs(current->thread.acrs);
	memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
	err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
	if (err)
		return err;
	save_fp_regs(&current->thread.fp_regs);
	/* s390_fp_regs and _s390_fp_regs32 are the same ! */
	return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
			      sizeof(_s390_fp_regs32));
}

static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
{
	_s390_regs_common32 regs32;
	int err, i;

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

	err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
	if (err)
		return err;
312
	regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
313 314
		(__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 |
		(__u64)(regs32.psw.addr & PSW32_ADDR_AMODE);
L
Linus Torvalds 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327
	regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
	for (i = 0; i < NUM_GPRS; i++)
		regs->gprs[i] = (__u64) regs32.gprs[i];
	memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
	restore_access_regs(current->thread.acrs);

	err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
			       sizeof(_s390_fp_regs32));
	current->thread.fp_regs.fpc &= FPC_VALID_MASK;
	if (err)
		return err;

	restore_fp_regs(&current->thread.fp_regs);
328
	clear_thread_flag(TIF_SYSCALL);	/* No longer in a system call */
L
Linus Torvalds 已提交
329 330 331
	return 0;
}

332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
{
	__u32 gprs_high[NUM_GPRS];
	int i;

	for (i = 0; i < NUM_GPRS; i++)
		gprs_high[i] = regs->gprs[i] >> 32;

	return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
}

static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
{
	__u32 gprs_high[NUM_GPRS];
	int err, i;

	err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
	if (err)
		return err;
	for (i = 0; i < NUM_GPRS; i++)
		*(__u32 *)&regs->gprs[i] = gprs_high[i];
	return 0;
}

M
Martin Schwidefsky 已提交
356
asmlinkage long sys32_sigreturn(void)
L
Linus Torvalds 已提交
357
{
M
Martin Schwidefsky 已提交
358
	struct pt_regs *regs = task_pt_regs(current);
L
Linus Torvalds 已提交
359 360 361 362 363 364 365 366
	sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
	sigset_t set;

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
		goto badframe;
	sigdelsetmask(&set, ~_BLOCKABLE);
367
	set_current_blocked(&set);
L
Linus Torvalds 已提交
368 369
	if (restore_sigregs32(regs, &frame->sregs))
		goto badframe;
370 371
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;
L
Linus Torvalds 已提交
372 373 374 375 376 377
	return regs->gprs[2];
badframe:
	force_sig(SIGSEGV, current);
	return 0;
}

M
Martin Schwidefsky 已提交
378
asmlinkage long sys32_rt_sigreturn(void)
L
Linus Torvalds 已提交
379
{
M
Martin Schwidefsky 已提交
380
	struct pt_regs *regs = task_pt_regs(current);
L
Linus Torvalds 已提交
381 382 383 384 385 386 387 388 389 390 391 392
	rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
	sigset_t set;
	stack_t st;
	__u32 ss_sp;
	int err;
	mm_segment_t old_fs = get_fs();

	if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
		goto badframe;
	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
		goto badframe;
	sigdelsetmask(&set, ~_BLOCKABLE);
393
	set_current_blocked(&set);
L
Linus Torvalds 已提交
394 395
	if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
		goto badframe;
396 397
	if (restore_sigregs_gprs_high(regs, frame->gprs_high))
		goto badframe;
L
Linus Torvalds 已提交
398
	err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
A
Al Viro 已提交
399
	st.ss_sp = compat_ptr(ss_sp);
L
Linus Torvalds 已提交
400 401 402 403 404
	err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
	err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
	if (err)
		goto badframe; 
	set_fs (KERNEL_DS);
405
	do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
L
Linus Torvalds 已提交
406 407 408
	set_fs (old_fs);
	return regs->gprs[2];
badframe:
M
Martin Schwidefsky 已提交
409 410
	force_sig(SIGSEGV, current);
	return 0;
L
Linus Torvalds 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
}	

/*
 * 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 = (unsigned long) A(regs->gprs[15]);

429 430 431 432
	/* Overflow on alternate signal stack gives SIGSEGV. */
	if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
		return (void __user *) -1UL;

L
Linus Torvalds 已提交
433 434
	/* This is the X/Open sanctioned signal stack switching.  */
	if (ka->sa.sa_flags & SA_ONSTACK) {
435
		if (! sas_ss_flags(sp))
L
Linus Torvalds 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
			sp = current->sas_ss_sp + current->sas_ss_size;
	}

	/* This is the legacy signal stack switching. */
	else if (!user_mode(regs) &&
		 !(ka->sa.sa_flags & SA_RESTORER) &&
		 ka->sa.sa_restorer) {
		sp = (unsigned long) ka->sa.sa_restorer;
	}

	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;
}

459
static int setup_frame32(int sig, struct k_sigaction *ka,
L
Linus Torvalds 已提交
460 461 462 463 464 465
			sigset_t *set, struct pt_regs * regs)
{
	sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
		goto give_sigsegv;

466 467 468
	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

L
Linus Torvalds 已提交
469 470 471 472 473
	if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
		goto give_sigsegv;

	if (save_sigregs32(regs, &frame->sregs))
		goto give_sigsegv;
474 475
	if (save_sigregs_gprs_high(regs, frame->gprs_high))
		goto give_sigsegv;
L
Linus Torvalds 已提交
476 477 478 479 480 481
	if (__put_user((unsigned long) &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) {
482
		regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
L
Linus Torvalds 已提交
483
	} else {
484
		regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
L
Linus Torvalds 已提交
485
		if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
486
			       (u16 __force __user *)(frame->retcode)))
L
Linus Torvalds 已提交
487 488 489 490 491 492 493 494
			goto give_sigsegv;
        }

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

	/* Set up registers for signal handler */
495
	regs->gprs[15] = (__force __u64) frame;
496
	regs->psw.mask |= PSW_MASK_BA;		/* force amode 31 */
497
	regs->psw.addr = (__force __u64) ka->sa.sa_handler;
L
Linus Torvalds 已提交
498 499

	regs->gprs[2] = map_signal(sig);
500
	regs->gprs[3] = (__force __u64) &frame->sc;
L
Linus Torvalds 已提交
501 502 503

	/* We forgot to include these in the sigcontext.
	   To avoid breaking binary compatibility, they are passed as args. */
M
Martin Schwidefsky 已提交
504 505 506 507 508 509
	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;
	}
L
Linus Torvalds 已提交
510 511

	/* Place signal number on stack to allow backtrace from handler.  */
512
	if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
L
Linus Torvalds 已提交
513
		goto give_sigsegv;
514
	return 0;
L
Linus Torvalds 已提交
515 516 517

give_sigsegv:
	force_sigsegv(sig, current);
518
	return -EFAULT;
L
Linus Torvalds 已提交
519 520
}

521
static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
L
Linus Torvalds 已提交
522 523 524 525 526 527 528
			   sigset_t *set, struct pt_regs * regs)
{
	int err = 0;
	rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
	if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
		goto give_sigsegv;

529 530 531
	if (frame == (void __user *) -1UL)
		goto give_sigsegv;

L
Linus Torvalds 已提交
532 533 534 535
	if (copy_siginfo_to_user32(&frame->info, info))
		goto give_sigsegv;

	/* Create the ucontext.  */
536
	err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
L
Linus Torvalds 已提交
537 538 539 540 541 542
	err |= __put_user(0, &frame->uc.uc_link);
	err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
	err |= __put_user(sas_ss_flags(regs->gprs[15]),
	                  &frame->uc.uc_stack.ss_flags);
	err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
	err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
543
	err |= save_sigregs_gprs_high(regs, frame->gprs_high);
L
Linus Torvalds 已提交
544 545 546 547 548 549 550
	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) {
551
		regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
L
Linus Torvalds 已提交
552
	} else {
553
		regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
L
Linus Torvalds 已提交
554
		err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
555
				  (u16 __force __user *)(frame->retcode));
L
Linus Torvalds 已提交
556 557 558
	}

	/* Set up backchain. */
559
	if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
L
Linus Torvalds 已提交
560 561 562
		goto give_sigsegv;

	/* Set up registers for signal handler */
563
	regs->gprs[15] = (__force __u64) frame;
564
	regs->psw.mask |= PSW_MASK_BA;		/* force amode 31 */
L
Linus Torvalds 已提交
565 566 567
	regs->psw.addr = (__u64) ka->sa.sa_handler;

	regs->gprs[2] = map_signal(sig);
568 569
	regs->gprs[3] = (__force __u64) &frame->info;
	regs->gprs[4] = (__force __u64) &frame->uc;
570
	return 0;
L
Linus Torvalds 已提交
571 572 573

give_sigsegv:
	force_sigsegv(sig, current);
574
	return -EFAULT;
L
Linus Torvalds 已提交
575 576 577 578 579 580
}

/*
 * OK, we're invoking a handler
 */	

581 582
int handle_signal32(unsigned long sig, struct k_sigaction *ka,
		    siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
L
Linus Torvalds 已提交
583
{
584
	sigset_t blocked;
585 586
	int ret;

L
Linus Torvalds 已提交
587 588
	/* Set up the stack frame */
	if (ka->sa.sa_flags & SA_SIGINFO)
589
		ret = setup_rt_frame32(sig, ka, info, oldset, regs);
L
Linus Torvalds 已提交
590
	else
591
		ret = setup_frame32(sig, ka, oldset, regs);
592 593 594 595 596 597 598
	if (ret)
		return ret;
	sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
	if (!(ka->sa.sa_flags & SA_NODEFER))
		sigaddset(&blocked, sig);
	set_current_blocked(&blocked);
	return 0;
L
Linus Torvalds 已提交
599 600
}