1 /* 2 * arch/s390/kernel/signal32.c 3 * 4 * S390 version 5 * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation 6 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 7 * Gerhard Tonn (ton@de.ibm.com) 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/config.h> 15 #include <linux/compat.h> 16 #include <linux/sched.h> 17 #include <linux/mm.h> 18 #include <linux/smp.h> 19 #include <linux/smp_lock.h> 20 #include <linux/kernel.h> 21 #include <linux/signal.h> 22 #include <linux/errno.h> 23 #include <linux/wait.h> 24 #include <linux/ptrace.h> 25 #include <linux/unistd.h> 26 #include <linux/stddef.h> 27 #include <linux/tty.h> 28 #include <linux/personality.h> 29 #include <linux/binfmts.h> 30 #include <asm/ucontext.h> 31 #include <asm/uaccess.h> 32 #include <asm/lowcore.h> 33 #include "compat_linux.h" 34 #include "compat_ptrace.h" 35 36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 37 38 typedef struct 39 { 40 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 41 struct sigcontext32 sc; 42 _sigregs32 sregs; 43 int signo; 44 __u8 retcode[S390_SYSCALL_SIZE]; 45 } sigframe32; 46 47 typedef struct 48 { 49 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 50 __u8 retcode[S390_SYSCALL_SIZE]; 51 compat_siginfo_t info; 52 struct ucontext32 uc; 53 } rt_sigframe32; 54 55 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset)); 56 57 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 58 { 59 int err; 60 61 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 62 return -EFAULT; 63 64 /* If you change siginfo_t structure, please be sure 65 this code is fixed accordingly. 66 It should never copy any pad contained in the structure 67 to avoid security leaks, but must copy the generic 68 3 ints plus the relevant union member. 69 This routine must convert siginfo from 64bit to 32bit as well 70 at the same time. */ 71 err = __put_user(from->si_signo, &to->si_signo); 72 err |= __put_user(from->si_errno, &to->si_errno); 73 err |= __put_user((short)from->si_code, &to->si_code); 74 if (from->si_code < 0) 75 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 76 else { 77 switch (from->si_code >> 16) { 78 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 79 case __SI_MESGQ >> 16: 80 err |= __put_user(from->si_int, &to->si_int); 81 /* fallthrough */ 82 case __SI_KILL >> 16: 83 err |= __put_user(from->si_pid, &to->si_pid); 84 err |= __put_user(from->si_uid, &to->si_uid); 85 break; 86 case __SI_CHLD >> 16: 87 err |= __put_user(from->si_pid, &to->si_pid); 88 err |= __put_user(from->si_uid, &to->si_uid); 89 err |= __put_user(from->si_utime, &to->si_utime); 90 err |= __put_user(from->si_stime, &to->si_stime); 91 err |= __put_user(from->si_status, &to->si_status); 92 break; 93 case __SI_FAULT >> 16: 94 err |= __put_user((unsigned long) from->si_addr, 95 &to->si_addr); 96 break; 97 case __SI_POLL >> 16: 98 err |= __put_user(from->si_band, &to->si_band); 99 err |= __put_user(from->si_fd, &to->si_fd); 100 break; 101 case __SI_TIMER >> 16: 102 err |= __put_user(from->si_tid, &to->si_tid); 103 err |= __put_user(from->si_overrun, &to->si_overrun); 104 err |= __put_user(from->si_int, &to->si_int); 105 break; 106 default: 107 break; 108 } 109 } 110 return err; 111 } 112 113 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) 114 { 115 int err; 116 u32 tmp; 117 118 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t))) 119 return -EFAULT; 120 121 err = __get_user(to->si_signo, &from->si_signo); 122 err |= __get_user(to->si_errno, &from->si_errno); 123 err |= __get_user(to->si_code, &from->si_code); 124 125 if (to->si_code < 0) 126 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 127 else { 128 switch (to->si_code >> 16) { 129 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 130 case __SI_MESGQ >> 16: 131 err |= __get_user(to->si_int, &from->si_int); 132 /* fallthrough */ 133 case __SI_KILL >> 16: 134 err |= __get_user(to->si_pid, &from->si_pid); 135 err |= __get_user(to->si_uid, &from->si_uid); 136 break; 137 case __SI_CHLD >> 16: 138 err |= __get_user(to->si_pid, &from->si_pid); 139 err |= __get_user(to->si_uid, &from->si_uid); 140 err |= __get_user(to->si_utime, &from->si_utime); 141 err |= __get_user(to->si_stime, &from->si_stime); 142 err |= __get_user(to->si_status, &from->si_status); 143 break; 144 case __SI_FAULT >> 16: 145 err |= __get_user(tmp, &from->si_addr); 146 to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN); 147 break; 148 case __SI_POLL >> 16: 149 err |= __get_user(to->si_band, &from->si_band); 150 err |= __get_user(to->si_fd, &from->si_fd); 151 break; 152 case __SI_TIMER >> 16: 153 err |= __get_user(to->si_tid, &from->si_tid); 154 err |= __get_user(to->si_overrun, &from->si_overrun); 155 err |= __get_user(to->si_int, &from->si_int); 156 break; 157 default: 158 break; 159 } 160 } 161 return err; 162 } 163 164 /* 165 * Atomically swap in the new signal mask, and wait for a signal. 166 */ 167 asmlinkage int 168 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask) 169 { 170 sigset_t saveset; 171 172 mask &= _BLOCKABLE; 173 spin_lock_irq(¤t->sighand->siglock); 174 saveset = current->blocked; 175 siginitset(¤t->blocked, mask); 176 recalc_sigpending(); 177 spin_unlock_irq(¤t->sighand->siglock); 178 regs->gprs[2] = -EINTR; 179 180 while (1) { 181 set_current_state(TASK_INTERRUPTIBLE); 182 schedule(); 183 if (do_signal(regs, &saveset)) 184 return -EINTR; 185 } 186 } 187 188 asmlinkage int 189 sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset, 190 size_t sigsetsize) 191 { 192 sigset_t saveset, newset; 193 compat_sigset_t set32; 194 195 /* XXX: Don't preclude handling different sized sigset_t's. */ 196 if (sigsetsize != sizeof(sigset_t)) 197 return -EINVAL; 198 199 if (copy_from_user(&set32, unewset, sizeof(set32))) 200 return -EFAULT; 201 switch (_NSIG_WORDS) { 202 case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32); 203 case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32); 204 case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32); 205 case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32); 206 } 207 sigdelsetmask(&newset, ~_BLOCKABLE); 208 209 spin_lock_irq(¤t->sighand->siglock); 210 saveset = current->blocked; 211 current->blocked = newset; 212 recalc_sigpending(); 213 spin_unlock_irq(¤t->sighand->siglock); 214 regs->gprs[2] = -EINTR; 215 216 while (1) { 217 set_current_state(TASK_INTERRUPTIBLE); 218 schedule(); 219 if (do_signal(regs, &saveset)) 220 return -EINTR; 221 } 222 } 223 224 asmlinkage long 225 sys32_sigaction(int sig, const struct old_sigaction32 __user *act, 226 struct old_sigaction32 __user *oact) 227 { 228 struct k_sigaction new_ka, old_ka; 229 unsigned long sa_handler, sa_restorer; 230 int ret; 231 232 if (act) { 233 compat_old_sigset_t mask; 234 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 235 __get_user(sa_handler, &act->sa_handler) || 236 __get_user(sa_restorer, &act->sa_restorer)) 237 return -EFAULT; 238 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 239 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer; 240 __get_user(new_ka.sa.sa_flags, &act->sa_flags); 241 __get_user(mask, &act->sa_mask); 242 siginitset(&new_ka.sa.sa_mask, mask); 243 } 244 245 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 246 247 if (!ret && oact) { 248 sa_handler = (unsigned long) old_ka.sa.sa_handler; 249 sa_restorer = (unsigned long) old_ka.sa.sa_restorer; 250 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 251 __put_user(sa_handler, &oact->sa_handler) || 252 __put_user(sa_restorer, &oact->sa_restorer)) 253 return -EFAULT; 254 __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 255 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); 256 } 257 258 return ret; 259 } 260 261 int 262 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact); 263 264 asmlinkage long 265 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, 266 struct sigaction32 __user *oact, size_t sigsetsize) 267 { 268 struct k_sigaction new_ka, old_ka; 269 unsigned long sa_handler; 270 int ret; 271 compat_sigset_t set32; 272 273 /* XXX: Don't preclude handling different sized sigset_t's. */ 274 if (sigsetsize != sizeof(compat_sigset_t)) 275 return -EINVAL; 276 277 if (act) { 278 ret = get_user(sa_handler, &act->sa_handler); 279 ret |= __copy_from_user(&set32, &act->sa_mask, 280 sizeof(compat_sigset_t)); 281 switch (_NSIG_WORDS) { 282 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] 283 | (((long)set32.sig[7]) << 32); 284 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] 285 | (((long)set32.sig[5]) << 32); 286 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] 287 | (((long)set32.sig[3]) << 32); 288 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] 289 | (((long)set32.sig[1]) << 32); 290 } 291 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 292 293 if (ret) 294 return -EFAULT; 295 new_ka.sa.sa_handler = (__sighandler_t) sa_handler; 296 } 297 298 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 299 300 if (!ret && oact) { 301 switch (_NSIG_WORDS) { 302 case 4: 303 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); 304 set32.sig[6] = old_ka.sa.sa_mask.sig[3]; 305 case 3: 306 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); 307 set32.sig[4] = old_ka.sa.sa_mask.sig[2]; 308 case 2: 309 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); 310 set32.sig[2] = old_ka.sa.sa_mask.sig[1]; 311 case 1: 312 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); 313 set32.sig[0] = old_ka.sa.sa_mask.sig[0]; 314 } 315 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler); 316 ret |= __copy_to_user(&oact->sa_mask, &set32, 317 sizeof(compat_sigset_t)); 318 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 319 } 320 321 return ret; 322 } 323 324 asmlinkage long 325 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss, 326 struct pt_regs *regs) 327 { 328 stack_t kss, koss; 329 unsigned long ss_sp; 330 int ret, err = 0; 331 mm_segment_t old_fs = get_fs(); 332 333 if (uss) { 334 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 335 return -EFAULT; 336 err |= __get_user(ss_sp, &uss->ss_sp); 337 err |= __get_user(kss.ss_size, &uss->ss_size); 338 err |= __get_user(kss.ss_flags, &uss->ss_flags); 339 if (err) 340 return -EFAULT; 341 kss.ss_sp = (void __user *) ss_sp; 342 } 343 344 set_fs (KERNEL_DS); 345 ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL), 346 (stack_t __user *) (uoss ? &koss : NULL), 347 regs->gprs[15]); 348 set_fs (old_fs); 349 350 if (!ret && uoss) { 351 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 352 return -EFAULT; 353 ss_sp = (unsigned long) koss.ss_sp; 354 err |= __put_user(ss_sp, &uoss->ss_sp); 355 err |= __put_user(koss.ss_size, &uoss->ss_size); 356 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 357 if (err) 358 return -EFAULT; 359 } 360 return ret; 361 } 362 363 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 364 { 365 _s390_regs_common32 regs32; 366 int err, i; 367 368 regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS, 369 (__u32)(regs->psw.mask >> 32)); 370 regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr; 371 for (i = 0; i < NUM_GPRS; i++) 372 regs32.gprs[i] = (__u32) regs->gprs[i]; 373 save_access_regs(current->thread.acrs); 374 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs)); 375 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32)); 376 if (err) 377 return err; 378 save_fp_regs(¤t->thread.fp_regs); 379 /* s390_fp_regs and _s390_fp_regs32 are the same ! */ 380 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs, 381 sizeof(_s390_fp_regs32)); 382 } 383 384 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 385 { 386 _s390_regs_common32 regs32; 387 int err, i; 388 389 /* Alwys make any pending restarted system call return -EINTR */ 390 current_thread_info()->restart_block.fn = do_no_restart_syscall; 391 392 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32)); 393 if (err) 394 return err; 395 regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask, 396 (__u64)regs32.psw.mask << 32); 397 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN); 398 for (i = 0; i < NUM_GPRS; i++) 399 regs->gprs[i] = (__u64) regs32.gprs[i]; 400 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs)); 401 restore_access_regs(current->thread.acrs); 402 403 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs, 404 sizeof(_s390_fp_regs32)); 405 current->thread.fp_regs.fpc &= FPC_VALID_MASK; 406 if (err) 407 return err; 408 409 restore_fp_regs(¤t->thread.fp_regs); 410 regs->trap = -1; /* disable syscall checks */ 411 return 0; 412 } 413 414 asmlinkage long sys32_sigreturn(struct pt_regs *regs) 415 { 416 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 417 sigset_t set; 418 419 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 420 goto badframe; 421 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32)) 422 goto badframe; 423 424 sigdelsetmask(&set, ~_BLOCKABLE); 425 spin_lock_irq(¤t->sighand->siglock); 426 current->blocked = set; 427 recalc_sigpending(); 428 spin_unlock_irq(¤t->sighand->siglock); 429 430 if (restore_sigregs32(regs, &frame->sregs)) 431 goto badframe; 432 433 return regs->gprs[2]; 434 435 badframe: 436 force_sig(SIGSEGV, current); 437 return 0; 438 } 439 440 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs) 441 { 442 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 443 sigset_t set; 444 stack_t st; 445 __u32 ss_sp; 446 int err; 447 mm_segment_t old_fs = get_fs(); 448 449 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 450 goto badframe; 451 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 452 goto badframe; 453 454 sigdelsetmask(&set, ~_BLOCKABLE); 455 spin_lock_irq(¤t->sighand->siglock); 456 current->blocked = set; 457 recalc_sigpending(); 458 spin_unlock_irq(¤t->sighand->siglock); 459 460 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 461 goto badframe; 462 463 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp); 464 st.ss_sp = compat_ptr(ss_sp); 465 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size); 466 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags); 467 if (err) 468 goto badframe; 469 470 set_fs (KERNEL_DS); 471 do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]); 472 set_fs (old_fs); 473 474 return regs->gprs[2]; 475 476 badframe: 477 force_sig(SIGSEGV, current); 478 return 0; 479 } 480 481 /* 482 * Set up a signal frame. 483 */ 484 485 486 /* 487 * Determine which stack to use.. 488 */ 489 static inline void __user * 490 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 491 { 492 unsigned long sp; 493 494 /* Default to using normal stack */ 495 sp = (unsigned long) A(regs->gprs[15]); 496 497 /* This is the X/Open sanctioned signal stack switching. */ 498 if (ka->sa.sa_flags & SA_ONSTACK) { 499 if (! on_sig_stack(sp)) 500 sp = current->sas_ss_sp + current->sas_ss_size; 501 } 502 503 /* This is the legacy signal stack switching. */ 504 else if (!user_mode(regs) && 505 !(ka->sa.sa_flags & SA_RESTORER) && 506 ka->sa.sa_restorer) { 507 sp = (unsigned long) ka->sa.sa_restorer; 508 } 509 510 return (void __user *)((sp - frame_size) & -8ul); 511 } 512 513 static inline int map_signal(int sig) 514 { 515 if (current_thread_info()->exec_domain 516 && current_thread_info()->exec_domain->signal_invmap 517 && sig < 32) 518 return current_thread_info()->exec_domain->signal_invmap[sig]; 519 else 520 return sig; 521 } 522 523 static void setup_frame32(int sig, struct k_sigaction *ka, 524 sigset_t *set, struct pt_regs * regs) 525 { 526 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32)); 527 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32))) 528 goto give_sigsegv; 529 530 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32)) 531 goto give_sigsegv; 532 533 if (save_sigregs32(regs, &frame->sregs)) 534 goto give_sigsegv; 535 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs)) 536 goto give_sigsegv; 537 538 /* Set up to return from userspace. If provided, use a stub 539 already in userspace. */ 540 if (ka->sa.sa_flags & SA_RESTORER) { 541 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 542 } else { 543 regs->gprs[14] = (__u64) frame->retcode; 544 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, 545 (u16 __user *)(frame->retcode))) 546 goto give_sigsegv; 547 } 548 549 /* Set up backchain. */ 550 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 551 goto give_sigsegv; 552 553 /* Set up registers for signal handler */ 554 regs->gprs[15] = (__u64) frame; 555 regs->psw.addr = (__u64) ka->sa.sa_handler; 556 557 regs->gprs[2] = map_signal(sig); 558 regs->gprs[3] = (__u64) &frame->sc; 559 560 /* We forgot to include these in the sigcontext. 561 To avoid breaking binary compatibility, they are passed as args. */ 562 regs->gprs[4] = current->thread.trap_no; 563 regs->gprs[5] = current->thread.prot_addr; 564 565 /* Place signal number on stack to allow backtrace from handler. */ 566 if (__put_user(regs->gprs[2], (int __user *) &frame->signo)) 567 goto give_sigsegv; 568 return; 569 570 give_sigsegv: 571 force_sigsegv(sig, current); 572 } 573 574 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info, 575 sigset_t *set, struct pt_regs * regs) 576 { 577 int err = 0; 578 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32)); 579 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32))) 580 goto give_sigsegv; 581 582 if (copy_siginfo_to_user32(&frame->info, info)) 583 goto give_sigsegv; 584 585 /* Create the ucontext. */ 586 err |= __put_user(0, &frame->uc.uc_flags); 587 err |= __put_user(0, &frame->uc.uc_link); 588 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 589 err |= __put_user(sas_ss_flags(regs->gprs[15]), 590 &frame->uc.uc_stack.ss_flags); 591 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 592 err |= save_sigregs32(regs, &frame->uc.uc_mcontext); 593 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 594 if (err) 595 goto give_sigsegv; 596 597 /* Set up to return from userspace. If provided, use a stub 598 already in userspace. */ 599 if (ka->sa.sa_flags & SA_RESTORER) { 600 regs->gprs[14] = (__u64) ka->sa.sa_restorer; 601 } else { 602 regs->gprs[14] = (__u64) frame->retcode; 603 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, 604 (u16 __user *)(frame->retcode)); 605 } 606 607 /* Set up backchain. */ 608 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 609 goto give_sigsegv; 610 611 /* Set up registers for signal handler */ 612 regs->gprs[15] = (__u64) frame; 613 regs->psw.addr = (__u64) ka->sa.sa_handler; 614 615 regs->gprs[2] = map_signal(sig); 616 regs->gprs[3] = (__u64) &frame->info; 617 regs->gprs[4] = (__u64) &frame->uc; 618 return; 619 620 give_sigsegv: 621 force_sigsegv(sig, current); 622 } 623 624 /* 625 * OK, we're invoking a handler 626 */ 627 628 void 629 handle_signal32(unsigned long sig, struct k_sigaction *ka, 630 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 631 { 632 /* Set up the stack frame */ 633 if (ka->sa.sa_flags & SA_SIGINFO) 634 setup_rt_frame32(sig, ka, info, oldset, regs); 635 else 636 setup_frame32(sig, ka, oldset, regs); 637 638 spin_lock_irq(¤t->sighand->siglock); 639 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 640 if (!(ka->sa.sa_flags & SA_NODEFER)) 641 sigaddset(¤t->blocked,sig); 642 recalc_sigpending(); 643 spin_unlock_irq(¤t->sighand->siglock); 644 } 645 646