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