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