1/* 2 * linux/arch/arm/kernel/signal.c 3 * 4 * Copyright (C) 1995-2001 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10#include <linux/config.h> 11#include <linux/sched.h> 12#include <linux/mm.h> 13#include <linux/smp.h> 14#include <linux/smp_lock.h> 15#include <linux/kernel.h> 16#include <linux/errno.h> 17#include <linux/signal.h> 18#include <linux/wait.h> 19#include <linux/ptrace.h> 20#include <linux/stddef.h> 21#include <linux/unistd.h> 22#include <linux/personality.h> 23#include <linux/tty.h> 24#include <linux/elf.h> 25 26#include <asm/pgalloc.h> 27#include <asm/ucontext.h> 28#include <asm/uaccess.h> 29 30#include "ptrace.h" 31 32#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 33 34/* 35 * For ARM syscalls, we encode the syscall number into the instruction. 36 */ 37#define SWI_SYS_SIGRETURN (0xef000000|(__NR_sigreturn)) 38#define SWI_SYS_RT_SIGRETURN (0xef000000|(__NR_rt_sigreturn)) 39 40/* 41 * For Thumb syscalls, we pass the syscall number via r7. We therefore 42 * need two 16-bit instructions. 43 */ 44#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE)) 45#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE)) 46 47static const unsigned long retcodes[4] = { 48 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN, 49 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN 50}; 51 52asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs, int syscall); 53 54int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from) 55{ 56 int err = -EFAULT;; 57 58 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t))) 59 goto out; 60 61 if (from->si_code < 0) 62 return __copy_to_user(to, from, sizeof(siginfo_t)); 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 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 /* First 32bits of unions are always present. */ 73 err |= __put_user(from->si_pid, &to->si_pid); 74 switch (from->si_code >> 16) { 75 case __SI_FAULT >> 16: 76 break; 77 case __SI_CHLD >> 16: 78 err |= __put_user(from->si_utime, &to->si_utime); 79 err |= __put_user(from->si_stime, &to->si_stime); 80 err |= __put_user(from->si_status, &to->si_status); 81 default: 82 err |= __put_user(from->si_uid, &to->si_uid); 83 break; 84 /* case __SI_RT: This is not generated by the kernel as of now. */ 85 } 86out: 87 return err; 88} 89 90/* 91 * atomically swap in the new signal mask, and wait for a signal. 92 */ 93asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask, struct pt_regs *regs) 94{ 95 sigset_t saveset; 96 97 mask &= _BLOCKABLE; 98 spin_lock_irq(¤t->sigmask_lock); 99 saveset = current->blocked; 100 siginitset(¤t->blocked, mask); 101 recalc_sigpending(current); 102 spin_unlock_irq(¤t->sigmask_lock); 103 regs->ARM_r0 = -EINTR; 104 105 while (1) { 106 current->state = TASK_INTERRUPTIBLE; 107 schedule(); 108 if (do_signal(&saveset, regs, 0)) 109 return regs->ARM_r0; 110 } 111} 112 113asmlinkage int 114sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs) 115{ 116 sigset_t saveset, newset; 117 118 if (sigsetsize != sizeof(sigset_t)) 119 return -EINVAL; 120 121 if (copy_from_user(&newset, unewset, sizeof(newset))) 122 return -EFAULT; 123 sigdelsetmask(&newset, ~_BLOCKABLE); 124 125 spin_lock_irq(¤t->sigmask_lock); 126 saveset = current->blocked; 127 current->blocked = newset; 128 recalc_sigpending(current); 129 spin_unlock_irq(¤t->sigmask_lock); 130 regs->ARM_r0 = -EINTR; 131 132 while (1) { 133 current->state = TASK_INTERRUPTIBLE; 134 schedule(); 135 if (do_signal(&saveset, regs, 0)) 136 return regs->ARM_r0; 137 } 138} 139 140asmlinkage int 141sys_sigaction(int sig, const struct old_sigaction *act, 142 struct old_sigaction *oact) 143{ 144 struct k_sigaction new_ka, old_ka; 145 int ret; 146 147 if (act) { 148 old_sigset_t mask; 149 if (verify_area(VERIFY_READ, act, sizeof(*act)) || 150 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 151 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) 152 return -EFAULT; 153 __get_user(new_ka.sa.sa_flags, &act->sa_flags); 154 __get_user(mask, &act->sa_mask); 155 siginitset(&new_ka.sa.sa_mask, mask); 156 } 157 158 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 159 160 if (!ret && oact) { 161 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) || 162 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 163 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) 164 return -EFAULT; 165 __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 166 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); 167 } 168 169 return ret; 170} 171 172/* 173 * Do a signal return; undo the signal stack. 174 */ 175struct sigframe 176{ 177 struct sigcontext sc; 178 unsigned long extramask[_NSIG_WORDS-1]; 179 unsigned long retcode; 180}; 181 182struct rt_sigframe 183{ 184 struct siginfo *pinfo; 185 void *puc; 186 struct siginfo info; 187 struct ucontext uc; 188 unsigned long retcode; 189}; 190 191static int 192restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc) 193{ 194 int err = 0; 195 196 __get_user_error(regs->ARM_r0, &sc->arm_r0, err); 197 __get_user_error(regs->ARM_r1, &sc->arm_r1, err); 198 __get_user_error(regs->ARM_r2, &sc->arm_r2, err); 199 __get_user_error(regs->ARM_r3, &sc->arm_r3, err); 200 __get_user_error(regs->ARM_r4, &sc->arm_r4, err); 201 __get_user_error(regs->ARM_r5, &sc->arm_r5, err); 202 __get_user_error(regs->ARM_r6, &sc->arm_r6, err); 203 __get_user_error(regs->ARM_r7, &sc->arm_r7, err); 204 __get_user_error(regs->ARM_r8, &sc->arm_r8, err); 205 __get_user_error(regs->ARM_r9, &sc->arm_r9, err); 206 __get_user_error(regs->ARM_r10, &sc->arm_r10, err); 207 __get_user_error(regs->ARM_fp, &sc->arm_fp, err); 208 __get_user_error(regs->ARM_ip, &sc->arm_ip, err); 209 __get_user_error(regs->ARM_sp, &sc->arm_sp, err); 210 __get_user_error(regs->ARM_lr, &sc->arm_lr, err); 211 __get_user_error(regs->ARM_pc, &sc->arm_pc, err); 212#ifdef CONFIG_CPU_32 213 __get_user_error(regs->ARM_cpsr, &sc->arm_cpsr, err); 214#endif 215 216 err |= !valid_user_regs(regs); 217 218 return err; 219} 220 221asmlinkage int sys_sigreturn(struct pt_regs *regs) 222{ 223 struct sigframe *frame; 224 sigset_t set; 225 226 /* 227 * Since we stacked the signal on a 64-bit boundary, 228 * then 'sp' should be word aligned here. If it's 229 * not, then the user is trying to mess with us. 230 */ 231 if (regs->ARM_sp & 7) 232 goto badframe; 233 234 frame = (struct sigframe *)regs->ARM_sp; 235 236 if (verify_area(VERIFY_READ, frame, sizeof (*frame))) 237 goto badframe; 238 if (__get_user(set.sig[0], &frame->sc.oldmask) 239 || (_NSIG_WORDS > 1 240 && __copy_from_user(&set.sig[1], &frame->extramask, 241 sizeof(frame->extramask)))) 242 goto badframe; 243 244 sigdelsetmask(&set, ~_BLOCKABLE); 245 spin_lock_irq(¤t->sigmask_lock); 246 current->blocked = set; 247 recalc_sigpending(current); 248 spin_unlock_irq(¤t->sigmask_lock); 249 250 if (restore_sigcontext(regs, &frame->sc)) 251 goto badframe; 252 253 /* Send SIGTRAP if we're single-stepping */ 254 if (ptrace_cancel_bpt(current)) 255 send_sig(SIGTRAP, current, 1); 256 257 return regs->ARM_r0; 258 259badframe: 260 force_sig(SIGSEGV, current); 261 return 0; 262} 263 264asmlinkage int sys_rt_sigreturn(struct pt_regs *regs) 265{ 266 struct rt_sigframe *frame; 267 sigset_t set; 268 269 /* 270 * Since we stacked the signal on a 64-bit boundary, 271 * then 'sp' should be word aligned here. If it's 272 * not, then the user is trying to mess with us. 273 */ 274 if (regs->ARM_sp & 7) 275 goto badframe; 276 277 frame = (struct rt_sigframe *)regs->ARM_sp; 278 279 if (verify_area(VERIFY_READ, frame, sizeof (*frame))) 280 goto badframe; 281 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 282 goto badframe; 283 284 sigdelsetmask(&set, ~_BLOCKABLE); 285 spin_lock_irq(¤t->sigmask_lock); 286 current->blocked = set; 287 recalc_sigpending(current); 288 spin_unlock_irq(¤t->sigmask_lock); 289 290 if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 291 goto badframe; 292 293 /* Send SIGTRAP if we're single-stepping */ 294 if (ptrace_cancel_bpt(current)) 295 send_sig(SIGTRAP, current, 1); 296 297 return regs->ARM_r0; 298 299badframe: 300 force_sig(SIGSEGV, current); 301 return 0; 302} 303 304static int 305setup_sigcontext(struct sigcontext *sc, /*struct _fpstate *fpstate,*/ 306 struct pt_regs *regs, unsigned long mask) 307{ 308 int err = 0; 309 310 __put_user_error(regs->ARM_r0, &sc->arm_r0, err); 311 __put_user_error(regs->ARM_r1, &sc->arm_r1, err); 312 __put_user_error(regs->ARM_r2, &sc->arm_r2, err); 313 __put_user_error(regs->ARM_r3, &sc->arm_r3, err); 314 __put_user_error(regs->ARM_r4, &sc->arm_r4, err); 315 __put_user_error(regs->ARM_r5, &sc->arm_r5, err); 316 __put_user_error(regs->ARM_r6, &sc->arm_r6, err); 317 __put_user_error(regs->ARM_r7, &sc->arm_r7, err); 318 __put_user_error(regs->ARM_r8, &sc->arm_r8, err); 319 __put_user_error(regs->ARM_r9, &sc->arm_r9, err); 320 __put_user_error(regs->ARM_r10, &sc->arm_r10, err); 321 __put_user_error(regs->ARM_fp, &sc->arm_fp, err); 322 __put_user_error(regs->ARM_ip, &sc->arm_ip, err); 323 __put_user_error(regs->ARM_sp, &sc->arm_sp, err); 324 __put_user_error(regs->ARM_lr, &sc->arm_lr, err); 325 __put_user_error(regs->ARM_pc, &sc->arm_pc, err); 326#ifdef CONFIG_CPU_32 327 __put_user_error(regs->ARM_cpsr, &sc->arm_cpsr, err); 328#endif 329 330 __put_user_error(current->thread.trap_no, &sc->trap_no, err); 331 __put_user_error(current->thread.error_code, &sc->error_code, err); 332 __put_user_error(current->thread.address, &sc->fault_address, err); 333 __put_user_error(mask, &sc->oldmask, err); 334 335 return err; 336} 337 338static inline void * 339get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize) 340{ 341 unsigned long sp = regs->ARM_sp; 342 343 /* 344 * This is the X/Open sanctioned signal stack switching. 345 */ 346 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) 347 sp = current->sas_ss_sp + current->sas_ss_size; 348 349 /* 350 * ATPCS B01 mandates 8-byte alignment 351 */ 352 return (void *)((sp - framesize) & ~7); 353} 354 355static int 356setup_return(struct pt_regs *regs, struct k_sigaction *ka, 357 unsigned long *rc, void *frame, int usig) 358{ 359 unsigned long handler = (unsigned long)ka->sa.sa_handler; 360 unsigned long retcode; 361 int thumb = 0; 362#ifdef CONFIG_CPU_32 363 unsigned long cpsr = regs->ARM_cpsr; 364 365 /* 366 * Maybe we need to deliver a 32-bit signal to a 26-bit task. 367 */ 368 if (ka->sa.sa_flags & SA_THIRTYTWO) 369 cpsr = (cpsr & ~MODE_MASK) | USR_MODE; 370 371#ifdef CONFIG_ARM_THUMB 372 if (elf_hwcap & HWCAP_THUMB) { 373 /* 374 * The LSB of the handler determines if we're going to 375 * be using THUMB or ARM mode for this signal handler. 376 */ 377 thumb = handler & 1; 378 379 if (thumb) 380 cpsr |= T_BIT; 381 else 382 cpsr &= ~T_BIT; 383 } 384#endif 385#endif 386 387 if (ka->sa.sa_flags & SA_RESTORER) { 388 retcode = (unsigned long)ka->sa.sa_restorer; 389 } else { 390 unsigned int idx = thumb; 391 392 if (ka->sa.sa_flags & SA_SIGINFO) 393 idx += 2; 394 395 if (__put_user(retcodes[idx], rc)) 396 return 1; 397 398 flush_icache_range((unsigned long)rc, 399 (unsigned long)(rc + 1)); 400 401 retcode = ((unsigned long)rc) + thumb; 402 } 403 404 regs->ARM_r0 = usig; 405 regs->ARM_sp = (unsigned long)frame; 406 regs->ARM_lr = retcode; 407 regs->ARM_pc = handler & (thumb ? ~1 : ~3); 408 409#ifdef CONFIG_CPU_32 410 regs->ARM_cpsr = cpsr; 411#endif 412 413 return 0; 414} 415 416static int 417setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs) 418{ 419 struct sigframe *frame = get_sigframe(ka, regs, sizeof(*frame)); 420 int err = 0; 421 422 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 423 return 1; 424 425 err |= setup_sigcontext(&frame->sc, /*&frame->fpstate,*/ regs, set->sig[0]); 426 427 if (_NSIG_WORDS > 1) { 428 err |= __copy_to_user(frame->extramask, &set->sig[1], 429 sizeof(frame->extramask)); 430 } 431 432 if (err == 0) 433 err = setup_return(regs, ka, &frame->retcode, frame, usig); 434 435 return err; 436} 437 438static int 439setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info, 440 sigset_t *set, struct pt_regs *regs) 441{ 442 struct rt_sigframe *frame = get_sigframe(ka, regs, sizeof(*frame)); 443 int err = 0; 444 445 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 446 return 1; 447 448 __put_user_error(&frame->info, &frame->pinfo, err); 449 __put_user_error(&frame->uc, &frame->puc, err); 450 err |= copy_siginfo_to_user(&frame->info, info); 451 452 /* Clear all the bits of the ucontext we don't use. */ 453 err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); 454 455 err |= setup_sigcontext(&frame->uc.uc_mcontext, /*&frame->fpstate,*/ 456 regs, set->sig[0]); 457 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 458 459 if (err == 0) 460 err = setup_return(regs, ka, &frame->retcode, frame, usig); 461 462 if (err == 0) { 463 /* 464 * For realtime signals we must also set the second and third 465 * arguments for the signal handler. 466 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06 467 */ 468 regs->ARM_r1 = (unsigned long)frame->pinfo; 469 regs->ARM_r2 = (unsigned long)frame->puc; 470 } 471 472 return err; 473} 474 475/* 476 * OK, we're invoking a handler 477 */ 478static void 479handle_signal(unsigned long sig, struct k_sigaction *ka, 480 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 481{ 482 struct task_struct *tsk = current; 483 int usig = sig; 484 int ret; 485 486 /* 487 * translate the signal 488 */ 489 if (usig < 32 && tsk->exec_domain && tsk->exec_domain->signal_invmap) 490 usig = tsk->exec_domain->signal_invmap[usig]; 491 492 /* 493 * Set up the stack frame 494 */ 495 if (ka->sa.sa_flags & SA_SIGINFO) 496 ret = setup_rt_frame(usig, ka, info, oldset, regs); 497 else 498 ret = setup_frame(usig, ka, oldset, regs); 499 500 /* 501 * Check that the resulting registers are actually sane. 502 */ 503 ret |= !valid_user_regs(regs); 504 505 if (ret == 0) { 506 if (ka->sa.sa_flags & SA_ONESHOT) 507 ka->sa.sa_handler = SIG_DFL; 508 509 if (!(ka->sa.sa_flags & SA_NODEFER)) { 510 spin_lock_irq(&tsk->sigmask_lock); 511 sigorsets(&tsk->blocked, &tsk->blocked, 512 &ka->sa.sa_mask); 513 sigaddset(&tsk->blocked, sig); 514 recalc_sigpending(tsk); 515 spin_unlock_irq(&tsk->sigmask_lock); 516 } 517 return; 518 } 519 520 if (sig == SIGSEGV) 521 ka->sa.sa_handler = SIG_DFL; 522 force_sig(SIGSEGV, tsk); 523} 524 525/* 526 * Note that 'init' is a special process: it doesn't get signals it doesn't 527 * want to handle. Thus you cannot kill init even with a SIGKILL even by 528 * mistake. 529 * 530 * Note that we go through the signals twice: once to check the signals that 531 * the kernel can handle, and then we build all the user-level signal handling 532 * stack-frames in one go after that. 533 */ 534asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall) 535{ 536 struct k_sigaction *ka; 537 siginfo_t info; 538 int single_stepping; 539 540 /* 541 * We want the common case to go fast, which 542 * is why we may in certain cases get here from 543 * kernel mode. Just return without doing anything 544 * if so. 545 */ 546 if (!user_mode(regs)) 547 return 0; 548 549 if (!oldset) 550 oldset = ¤t->blocked; 551 552 single_stepping = ptrace_cancel_bpt(current); 553 554 for (;;) { 555 unsigned long signr; 556 557 spin_lock_irq (¤t->sigmask_lock); 558 signr = dequeue_signal(¤t->blocked, &info); 559 spin_unlock_irq (¤t->sigmask_lock); 560 561 if (!signr) 562 break; 563 564 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) { 565 /* Let the debugger run. */ 566 current->exit_code = signr; 567 current->state = TASK_STOPPED; 568 notify_parent(current, SIGCHLD); 569 schedule(); 570 single_stepping |= ptrace_cancel_bpt(current); 571 572 /* We're back. Did the debugger cancel the sig? */ 573 if (!(signr = current->exit_code)) 574 continue; 575 current->exit_code = 0; 576 577 /* The debugger continued. Ignore SIGSTOP. */ 578 if (signr == SIGSTOP) 579 continue; 580 581 /* Update the siginfo structure. Is this good? */ 582 if (signr != info.si_signo) { 583 info.si_signo = signr; 584 info.si_errno = 0; 585 info.si_code = SI_USER; 586 info.si_pid = current->p_pptr->pid; 587 info.si_uid = current->p_pptr->uid; 588 } 589 590 /* If the (new) signal is now blocked, requeue it. */ 591 if (sigismember(¤t->blocked, signr)) { 592 send_sig_info(signr, &info, current); 593 continue; 594 } 595 } 596 597 ka = ¤t->sig->action[signr-1]; 598 if (ka->sa.sa_handler == SIG_IGN) { 599 if (signr != SIGCHLD) 600 continue; 601 /* Check for SIGCHLD: it's special. */ 602 while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0) 603 /* nothing */; 604 continue; 605 } 606 607 if (ka->sa.sa_handler == SIG_DFL) { 608 int exit_code = signr; 609 610 /* Init gets no signals it doesn't want. */ 611 if (current->pid == 1) 612 continue; 613 614 switch (signr) { 615 case SIGCONT: case SIGCHLD: case SIGWINCH: 616 continue; 617 618 case SIGTSTP: case SIGTTIN: case SIGTTOU: 619 if (is_orphaned_pgrp(current->pgrp)) 620 continue; 621 /* FALLTHRU */ 622 623 case SIGSTOP: 624 current->state = TASK_STOPPED; 625 current->exit_code = signr; 626 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) 627 notify_parent(current, SIGCHLD); 628 schedule(); 629 continue; 630 631 case SIGQUIT: case SIGILL: case SIGTRAP: 632 case SIGABRT: case SIGFPE: case SIGSEGV: 633 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ: 634 if (do_coredump(signr, regs)) 635 exit_code |= 0x80; 636 /* FALLTHRU */ 637 638 default: 639 sigaddset(¤t->pending.signal, signr); 640 recalc_sigpending(current); 641 current->flags |= PF_SIGNALED; 642 do_exit(exit_code); 643 /* NOTREACHED */ 644 } 645 } 646 647 /* Are we from a system call? */ 648 if (syscall) { 649 switch (regs->ARM_r0) { 650 case -ERESTARTNOHAND: 651 regs->ARM_r0 = -EINTR; 652 break; 653 654 case -ERESTARTSYS: 655 if (!(ka->sa.sa_flags & SA_RESTART)) { 656 regs->ARM_r0 = -EINTR; 657 break; 658 } 659 /* fallthrough */ 660 case -ERESTARTNOINTR: 661 regs->ARM_r0 = regs->ARM_ORIG_r0; 662 regs->ARM_pc -= 4; 663 } 664 } 665 /* Whee! Actually deliver the signal. */ 666 handle_signal(signr, ka, &info, oldset, regs); 667 if (single_stepping) 668 ptrace_set_bpt(current); 669 return 1; 670 } 671 672 if (syscall && 673 (regs->ARM_r0 == -ERESTARTNOHAND || 674 regs->ARM_r0 == -ERESTARTSYS || 675 regs->ARM_r0 == -ERESTARTNOINTR)) { 676 regs->ARM_r0 = regs->ARM_ORIG_r0; 677 regs->ARM_pc -= 4; 678 } 679 if (single_stepping) 680 ptrace_set_bpt(current); 681 return 0; 682} 683