1 /* 2 * linux/kernel/ptrace.c 3 * 4 * (C) Copyright 1999 Linus Torvalds 5 * 6 * Common interfaces for "ptrace()" which we do not want 7 * to continually duplicate across every architecture. 8 */ 9 10 #include <linux/capability.h> 11 #include <linux/export.h> 12 #include <linux/sched.h> 13 #include <linux/errno.h> 14 #include <linux/mm.h> 15 #include <linux/highmem.h> 16 #include <linux/pagemap.h> 17 #include <linux/ptrace.h> 18 #include <linux/security.h> 19 #include <linux/signal.h> 20 #include <linux/audit.h> 21 #include <linux/pid_namespace.h> 22 #include <linux/syscalls.h> 23 #include <linux/uaccess.h> 24 #include <linux/regset.h> 25 #include <linux/hw_breakpoint.h> 26 #include <linux/cn_proc.h> 27 28 29 static int ptrace_trapping_sleep_fn(void *flags) 30 { 31 schedule(); 32 return 0; 33 } 34 35 /* 36 * ptrace a task: make the debugger its new parent and 37 * move it to the ptrace list. 38 * 39 * Must be called with the tasklist lock write-held. 40 */ 41 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent) 42 { 43 BUG_ON(!list_empty(&child->ptrace_entry)); 44 list_add(&child->ptrace_entry, &new_parent->ptraced); 45 child->parent = new_parent; 46 } 47 48 /** 49 * __ptrace_unlink - unlink ptracee and restore its execution state 50 * @child: ptracee to be unlinked 51 * 52 * Remove @child from the ptrace list, move it back to the original parent, 53 * and restore the execution state so that it conforms to the group stop 54 * state. 55 * 56 * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer 57 * exiting. For PTRACE_DETACH, unless the ptracee has been killed between 58 * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED. 59 * If the ptracer is exiting, the ptracee can be in any state. 60 * 61 * After detach, the ptracee should be in a state which conforms to the 62 * group stop. If the group is stopped or in the process of stopping, the 63 * ptracee should be put into TASK_STOPPED; otherwise, it should be woken 64 * up from TASK_TRACED. 65 * 66 * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED, 67 * it goes through TRACED -> RUNNING -> STOPPED transition which is similar 68 * to but in the opposite direction of what happens while attaching to a 69 * stopped task. However, in this direction, the intermediate RUNNING 70 * state is not hidden even from the current ptracer and if it immediately 71 * re-attaches and performs a WNOHANG wait(2), it may fail. 72 * 73 * CONTEXT: 74 * write_lock_irq(tasklist_lock) 75 */ 76 void __ptrace_unlink(struct task_struct *child) 77 { 78 BUG_ON(!child->ptrace); 79 80 child->ptrace = 0; 81 child->parent = child->real_parent; 82 list_del_init(&child->ptrace_entry); 83 84 spin_lock(&child->sighand->siglock); 85 86 /* 87 * Clear all pending traps and TRAPPING. TRAPPING should be 88 * cleared regardless of JOBCTL_STOP_PENDING. Do it explicitly. 89 */ 90 task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK); 91 task_clear_jobctl_trapping(child); 92 93 /* 94 * Reinstate JOBCTL_STOP_PENDING if group stop is in effect and 95 * @child isn't dead. 96 */ 97 if (!(child->flags & PF_EXITING) && 98 (child->signal->flags & SIGNAL_STOP_STOPPED || 99 child->signal->group_stop_count)) { 100 child->jobctl |= JOBCTL_STOP_PENDING; 101 102 /* 103 * This is only possible if this thread was cloned by the 104 * traced task running in the stopped group, set the signal 105 * for the future reports. 106 * FIXME: we should change ptrace_init_task() to handle this 107 * case. 108 */ 109 if (!(child->jobctl & JOBCTL_STOP_SIGMASK)) 110 child->jobctl |= SIGSTOP; 111 } 112 113 /* 114 * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick 115 * @child in the butt. Note that @resume should be used iff @child 116 * is in TASK_TRACED; otherwise, we might unduly disrupt 117 * TASK_KILLABLE sleeps. 118 */ 119 if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child)) 120 signal_wake_up(child, task_is_traced(child)); 121 122 spin_unlock(&child->sighand->siglock); 123 } 124 125 /** 126 * ptrace_check_attach - check whether ptracee is ready for ptrace operation 127 * @child: ptracee to check for 128 * @ignore_state: don't check whether @child is currently %TASK_TRACED 129 * 130 * Check whether @child is being ptraced by %current and ready for further 131 * ptrace operations. If @ignore_state is %false, @child also should be in 132 * %TASK_TRACED state and on return the child is guaranteed to be traced 133 * and not executing. If @ignore_state is %true, @child can be in any 134 * state. 135 * 136 * CONTEXT: 137 * Grabs and releases tasklist_lock and @child->sighand->siglock. 138 * 139 * RETURNS: 140 * 0 on success, -ESRCH if %child is not ready. 141 */ 142 int ptrace_check_attach(struct task_struct *child, bool ignore_state) 143 { 144 int ret = -ESRCH; 145 146 /* 147 * We take the read lock around doing both checks to close a 148 * possible race where someone else was tracing our child and 149 * detached between these two checks. After this locked check, 150 * we are sure that this is our traced child and that can only 151 * be changed by us so it's not changing right after this. 152 */ 153 read_lock(&tasklist_lock); 154 if ((child->ptrace & PT_PTRACED) && child->parent == current) { 155 /* 156 * child->sighand can't be NULL, release_task() 157 * does ptrace_unlink() before __exit_signal(). 158 */ 159 spin_lock_irq(&child->sighand->siglock); 160 WARN_ON_ONCE(task_is_stopped(child)); 161 if (ignore_state || (task_is_traced(child) && 162 !(child->jobctl & JOBCTL_LISTENING))) 163 ret = 0; 164 spin_unlock_irq(&child->sighand->siglock); 165 } 166 read_unlock(&tasklist_lock); 167 168 if (!ret && !ignore_state) 169 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH; 170 171 /* All systems go.. */ 172 return ret; 173 } 174 175 static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode) 176 { 177 if (mode & PTRACE_MODE_NOAUDIT) 178 return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE); 179 else 180 return has_ns_capability(current, ns, CAP_SYS_PTRACE); 181 } 182 183 /* Returns 0 on success, -errno on denial. */ 184 static int __ptrace_may_access(struct task_struct *task, unsigned int mode) 185 { 186 const struct cred *cred = current_cred(), *tcred; 187 188 /* May we inspect the given task? 189 * This check is used both for attaching with ptrace 190 * and for allowing access to sensitive information in /proc. 191 * 192 * ptrace_attach denies several cases that /proc allows 193 * because setting up the necessary parent/child relationship 194 * or halting the specified task is impossible. 195 */ 196 int dumpable = 0; 197 /* Don't let security modules deny introspection */ 198 if (task == current) 199 return 0; 200 rcu_read_lock(); 201 tcred = __task_cred(task); 202 if (uid_eq(cred->uid, tcred->euid) && 203 uid_eq(cred->uid, tcred->suid) && 204 uid_eq(cred->uid, tcred->uid) && 205 gid_eq(cred->gid, tcred->egid) && 206 gid_eq(cred->gid, tcred->sgid) && 207 gid_eq(cred->gid, tcred->gid)) 208 goto ok; 209 if (ptrace_has_cap(tcred->user_ns, mode)) 210 goto ok; 211 rcu_read_unlock(); 212 return -EPERM; 213 ok: 214 rcu_read_unlock(); 215 smp_rmb(); 216 if (task->mm) 217 dumpable = get_dumpable(task->mm); 218 if (!dumpable && !ptrace_has_cap(task_user_ns(task), mode)) 219 return -EPERM; 220 221 return security_ptrace_access_check(task, mode); 222 } 223 224 bool ptrace_may_access(struct task_struct *task, unsigned int mode) 225 { 226 int err; 227 task_lock(task); 228 err = __ptrace_may_access(task, mode); 229 task_unlock(task); 230 return !err; 231 } 232 233 static int ptrace_attach(struct task_struct *task, long request, 234 unsigned long addr, 235 unsigned long flags) 236 { 237 bool seize = (request == PTRACE_SEIZE); 238 int retval; 239 240 retval = -EIO; 241 if (seize) { 242 if (addr != 0) 243 goto out; 244 if (flags & ~(unsigned long)PTRACE_O_MASK) 245 goto out; 246 flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT); 247 } else { 248 flags = PT_PTRACED; 249 } 250 251 audit_ptrace(task); 252 253 retval = -EPERM; 254 if (unlikely(task->flags & PF_KTHREAD)) 255 goto out; 256 if (same_thread_group(task, current)) 257 goto out; 258 259 /* 260 * Protect exec's credential calculations against our interference; 261 * SUID, SGID and LSM creds get determined differently 262 * under ptrace. 263 */ 264 retval = -ERESTARTNOINTR; 265 if (mutex_lock_interruptible(&task->signal->cred_guard_mutex)) 266 goto out; 267 268 task_lock(task); 269 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH); 270 task_unlock(task); 271 if (retval) 272 goto unlock_creds; 273 274 write_lock_irq(&tasklist_lock); 275 retval = -EPERM; 276 if (unlikely(task->exit_state)) 277 goto unlock_tasklist; 278 if (task->ptrace) 279 goto unlock_tasklist; 280 281 if (seize) 282 flags |= PT_SEIZED; 283 if (ns_capable(task_user_ns(task), CAP_SYS_PTRACE)) 284 flags |= PT_PTRACE_CAP; 285 task->ptrace = flags; 286 287 __ptrace_link(task, current); 288 289 /* SEIZE doesn't trap tracee on attach */ 290 if (!seize) 291 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task); 292 293 spin_lock(&task->sighand->siglock); 294 295 /* 296 * If the task is already STOPPED, set JOBCTL_TRAP_STOP and 297 * TRAPPING, and kick it so that it transits to TRACED. TRAPPING 298 * will be cleared if the child completes the transition or any 299 * event which clears the group stop states happens. We'll wait 300 * for the transition to complete before returning from this 301 * function. 302 * 303 * This hides STOPPED -> RUNNING -> TRACED transition from the 304 * attaching thread but a different thread in the same group can 305 * still observe the transient RUNNING state. IOW, if another 306 * thread's WNOHANG wait(2) on the stopped tracee races against 307 * ATTACH, the wait(2) may fail due to the transient RUNNING. 308 * 309 * The following task_is_stopped() test is safe as both transitions 310 * in and out of STOPPED are protected by siglock. 311 */ 312 if (task_is_stopped(task) && 313 task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING)) 314 signal_wake_up(task, 1); 315 316 spin_unlock(&task->sighand->siglock); 317 318 retval = 0; 319 unlock_tasklist: 320 write_unlock_irq(&tasklist_lock); 321 unlock_creds: 322 mutex_unlock(&task->signal->cred_guard_mutex); 323 out: 324 if (!retval) { 325 wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT, 326 ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE); 327 proc_ptrace_connector(task, PTRACE_ATTACH); 328 } 329 330 return retval; 331 } 332 333 /** 334 * ptrace_traceme -- helper for PTRACE_TRACEME 335 * 336 * Performs checks and sets PT_PTRACED. 337 * Should be used by all ptrace implementations for PTRACE_TRACEME. 338 */ 339 static int ptrace_traceme(void) 340 { 341 int ret = -EPERM; 342 343 write_lock_irq(&tasklist_lock); 344 /* Are we already being traced? */ 345 if (!current->ptrace) { 346 ret = security_ptrace_traceme(current->parent); 347 /* 348 * Check PF_EXITING to ensure ->real_parent has not passed 349 * exit_ptrace(). Otherwise we don't report the error but 350 * pretend ->real_parent untraces us right after return. 351 */ 352 if (!ret && !(current->real_parent->flags & PF_EXITING)) { 353 current->ptrace = PT_PTRACED; 354 __ptrace_link(current, current->real_parent); 355 } 356 } 357 write_unlock_irq(&tasklist_lock); 358 359 return ret; 360 } 361 362 /* 363 * Called with irqs disabled, returns true if childs should reap themselves. 364 */ 365 static int ignoring_children(struct sighand_struct *sigh) 366 { 367 int ret; 368 spin_lock(&sigh->siglock); 369 ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) || 370 (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT); 371 spin_unlock(&sigh->siglock); 372 return ret; 373 } 374 375 /* 376 * Called with tasklist_lock held for writing. 377 * Unlink a traced task, and clean it up if it was a traced zombie. 378 * Return true if it needs to be reaped with release_task(). 379 * (We can't call release_task() here because we already hold tasklist_lock.) 380 * 381 * If it's a zombie, our attachedness prevented normal parent notification 382 * or self-reaping. Do notification now if it would have happened earlier. 383 * If it should reap itself, return true. 384 * 385 * If it's our own child, there is no notification to do. But if our normal 386 * children self-reap, then this child was prevented by ptrace and we must 387 * reap it now, in that case we must also wake up sub-threads sleeping in 388 * do_wait(). 389 */ 390 static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p) 391 { 392 bool dead; 393 394 __ptrace_unlink(p); 395 396 if (p->exit_state != EXIT_ZOMBIE) 397 return false; 398 399 dead = !thread_group_leader(p); 400 401 if (!dead && thread_group_empty(p)) { 402 if (!same_thread_group(p->real_parent, tracer)) 403 dead = do_notify_parent(p, p->exit_signal); 404 else if (ignoring_children(tracer->sighand)) { 405 __wake_up_parent(p, tracer); 406 dead = true; 407 } 408 } 409 /* Mark it as in the process of being reaped. */ 410 if (dead) 411 p->exit_state = EXIT_DEAD; 412 return dead; 413 } 414 415 static int ptrace_detach(struct task_struct *child, unsigned int data) 416 { 417 bool dead = false; 418 419 if (!valid_signal(data)) 420 return -EIO; 421 422 /* Architecture-specific hardware disable .. */ 423 ptrace_disable(child); 424 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 425 426 write_lock_irq(&tasklist_lock); 427 /* 428 * This child can be already killed. Make sure de_thread() or 429 * our sub-thread doing do_wait() didn't do release_task() yet. 430 */ 431 if (child->ptrace) { 432 child->exit_code = data; 433 dead = __ptrace_detach(current, child); 434 } 435 write_unlock_irq(&tasklist_lock); 436 437 proc_ptrace_connector(child, PTRACE_DETACH); 438 if (unlikely(dead)) 439 release_task(child); 440 441 return 0; 442 } 443 444 /* 445 * Detach all tasks we were using ptrace on. Called with tasklist held 446 * for writing, and returns with it held too. But note it can release 447 * and reacquire the lock. 448 */ 449 void exit_ptrace(struct task_struct *tracer) 450 __releases(&tasklist_lock) 451 __acquires(&tasklist_lock) 452 { 453 struct task_struct *p, *n; 454 LIST_HEAD(ptrace_dead); 455 456 if (likely(list_empty(&tracer->ptraced))) 457 return; 458 459 list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) { 460 if (unlikely(p->ptrace & PT_EXITKILL)) 461 send_sig_info(SIGKILL, SEND_SIG_FORCED, p); 462 463 if (__ptrace_detach(tracer, p)) 464 list_add(&p->ptrace_entry, &ptrace_dead); 465 } 466 467 write_unlock_irq(&tasklist_lock); 468 BUG_ON(!list_empty(&tracer->ptraced)); 469 470 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) { 471 list_del_init(&p->ptrace_entry); 472 release_task(p); 473 } 474 475 write_lock_irq(&tasklist_lock); 476 } 477 478 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len) 479 { 480 int copied = 0; 481 482 while (len > 0) { 483 char buf[128]; 484 int this_len, retval; 485 486 this_len = (len > sizeof(buf)) ? sizeof(buf) : len; 487 retval = access_process_vm(tsk, src, buf, this_len, 0); 488 if (!retval) { 489 if (copied) 490 break; 491 return -EIO; 492 } 493 if (copy_to_user(dst, buf, retval)) 494 return -EFAULT; 495 copied += retval; 496 src += retval; 497 dst += retval; 498 len -= retval; 499 } 500 return copied; 501 } 502 503 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len) 504 { 505 int copied = 0; 506 507 while (len > 0) { 508 char buf[128]; 509 int this_len, retval; 510 511 this_len = (len > sizeof(buf)) ? sizeof(buf) : len; 512 if (copy_from_user(buf, src, this_len)) 513 return -EFAULT; 514 retval = access_process_vm(tsk, dst, buf, this_len, 1); 515 if (!retval) { 516 if (copied) 517 break; 518 return -EIO; 519 } 520 copied += retval; 521 src += retval; 522 dst += retval; 523 len -= retval; 524 } 525 return copied; 526 } 527 528 static int ptrace_setoptions(struct task_struct *child, unsigned long data) 529 { 530 unsigned flags; 531 532 if (data & ~(unsigned long)PTRACE_O_MASK) 533 return -EINVAL; 534 535 /* Avoid intermediate state when all opts are cleared */ 536 flags = child->ptrace; 537 flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT); 538 flags |= (data << PT_OPT_FLAG_SHIFT); 539 child->ptrace = flags; 540 541 return 0; 542 } 543 544 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info) 545 { 546 unsigned long flags; 547 int error = -ESRCH; 548 549 if (lock_task_sighand(child, &flags)) { 550 error = -EINVAL; 551 if (likely(child->last_siginfo != NULL)) { 552 *info = *child->last_siginfo; 553 error = 0; 554 } 555 unlock_task_sighand(child, &flags); 556 } 557 return error; 558 } 559 560 static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info) 561 { 562 unsigned long flags; 563 int error = -ESRCH; 564 565 if (lock_task_sighand(child, &flags)) { 566 error = -EINVAL; 567 if (likely(child->last_siginfo != NULL)) { 568 *child->last_siginfo = *info; 569 error = 0; 570 } 571 unlock_task_sighand(child, &flags); 572 } 573 return error; 574 } 575 576 577 #ifdef PTRACE_SINGLESTEP 578 #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP) 579 #else 580 #define is_singlestep(request) 0 581 #endif 582 583 #ifdef PTRACE_SINGLEBLOCK 584 #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK) 585 #else 586 #define is_singleblock(request) 0 587 #endif 588 589 #ifdef PTRACE_SYSEMU 590 #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP) 591 #else 592 #define is_sysemu_singlestep(request) 0 593 #endif 594 595 static int ptrace_resume(struct task_struct *child, long request, 596 unsigned long data) 597 { 598 if (!valid_signal(data)) 599 return -EIO; 600 601 if (request == PTRACE_SYSCALL) 602 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 603 else 604 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 605 606 #ifdef TIF_SYSCALL_EMU 607 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP) 608 set_tsk_thread_flag(child, TIF_SYSCALL_EMU); 609 else 610 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); 611 #endif 612 613 if (is_singleblock(request)) { 614 if (unlikely(!arch_has_block_step())) 615 return -EIO; 616 user_enable_block_step(child); 617 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) { 618 if (unlikely(!arch_has_single_step())) 619 return -EIO; 620 user_enable_single_step(child); 621 } else { 622 user_disable_single_step(child); 623 } 624 625 child->exit_code = data; 626 wake_up_state(child, __TASK_TRACED); 627 628 return 0; 629 } 630 631 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 632 633 static const struct user_regset * 634 find_regset(const struct user_regset_view *view, unsigned int type) 635 { 636 const struct user_regset *regset; 637 int n; 638 639 for (n = 0; n < view->n; ++n) { 640 regset = view->regsets + n; 641 if (regset->core_note_type == type) 642 return regset; 643 } 644 645 return NULL; 646 } 647 648 static int ptrace_regset(struct task_struct *task, int req, unsigned int type, 649 struct iovec *kiov) 650 { 651 const struct user_regset_view *view = task_user_regset_view(task); 652 const struct user_regset *regset = find_regset(view, type); 653 int regset_no; 654 655 if (!regset || (kiov->iov_len % regset->size) != 0) 656 return -EINVAL; 657 658 regset_no = regset - view->regsets; 659 kiov->iov_len = min(kiov->iov_len, 660 (__kernel_size_t) (regset->n * regset->size)); 661 662 if (req == PTRACE_GETREGSET) 663 return copy_regset_to_user(task, view, regset_no, 0, 664 kiov->iov_len, kiov->iov_base); 665 else 666 return copy_regset_from_user(task, view, regset_no, 0, 667 kiov->iov_len, kiov->iov_base); 668 } 669 670 #endif 671 672 int ptrace_request(struct task_struct *child, long request, 673 unsigned long addr, unsigned long data) 674 { 675 bool seized = child->ptrace & PT_SEIZED; 676 int ret = -EIO; 677 siginfo_t siginfo, *si; 678 void __user *datavp = (void __user *) data; 679 unsigned long __user *datalp = datavp; 680 unsigned long flags; 681 682 switch (request) { 683 case PTRACE_PEEKTEXT: 684 case PTRACE_PEEKDATA: 685 return generic_ptrace_peekdata(child, addr, data); 686 case PTRACE_POKETEXT: 687 case PTRACE_POKEDATA: 688 return generic_ptrace_pokedata(child, addr, data); 689 690 #ifdef PTRACE_OLDSETOPTIONS 691 case PTRACE_OLDSETOPTIONS: 692 #endif 693 case PTRACE_SETOPTIONS: 694 ret = ptrace_setoptions(child, data); 695 break; 696 case PTRACE_GETEVENTMSG: 697 ret = put_user(child->ptrace_message, datalp); 698 break; 699 700 case PTRACE_GETSIGINFO: 701 ret = ptrace_getsiginfo(child, &siginfo); 702 if (!ret) 703 ret = copy_siginfo_to_user(datavp, &siginfo); 704 break; 705 706 case PTRACE_SETSIGINFO: 707 if (copy_from_user(&siginfo, datavp, sizeof siginfo)) 708 ret = -EFAULT; 709 else 710 ret = ptrace_setsiginfo(child, &siginfo); 711 break; 712 713 case PTRACE_INTERRUPT: 714 /* 715 * Stop tracee without any side-effect on signal or job 716 * control. At least one trap is guaranteed to happen 717 * after this request. If @child is already trapped, the 718 * current trap is not disturbed and another trap will 719 * happen after the current trap is ended with PTRACE_CONT. 720 * 721 * The actual trap might not be PTRACE_EVENT_STOP trap but 722 * the pending condition is cleared regardless. 723 */ 724 if (unlikely(!seized || !lock_task_sighand(child, &flags))) 725 break; 726 727 /* 728 * INTERRUPT doesn't disturb existing trap sans one 729 * exception. If ptracer issued LISTEN for the current 730 * STOP, this INTERRUPT should clear LISTEN and re-trap 731 * tracee into STOP. 732 */ 733 if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP))) 734 signal_wake_up(child, child->jobctl & JOBCTL_LISTENING); 735 736 unlock_task_sighand(child, &flags); 737 ret = 0; 738 break; 739 740 case PTRACE_LISTEN: 741 /* 742 * Listen for events. Tracee must be in STOP. It's not 743 * resumed per-se but is not considered to be in TRACED by 744 * wait(2) or ptrace(2). If an async event (e.g. group 745 * stop state change) happens, tracee will enter STOP trap 746 * again. Alternatively, ptracer can issue INTERRUPT to 747 * finish listening and re-trap tracee into STOP. 748 */ 749 if (unlikely(!seized || !lock_task_sighand(child, &flags))) 750 break; 751 752 si = child->last_siginfo; 753 if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) { 754 child->jobctl |= JOBCTL_LISTENING; 755 /* 756 * If NOTIFY is set, it means event happened between 757 * start of this trap and now. Trigger re-trap. 758 */ 759 if (child->jobctl & JOBCTL_TRAP_NOTIFY) 760 signal_wake_up(child, true); 761 ret = 0; 762 } 763 unlock_task_sighand(child, &flags); 764 break; 765 766 case PTRACE_DETACH: /* detach a process that was attached. */ 767 ret = ptrace_detach(child, data); 768 break; 769 770 #ifdef CONFIG_BINFMT_ELF_FDPIC 771 case PTRACE_GETFDPIC: { 772 struct mm_struct *mm = get_task_mm(child); 773 unsigned long tmp = 0; 774 775 ret = -ESRCH; 776 if (!mm) 777 break; 778 779 switch (addr) { 780 case PTRACE_GETFDPIC_EXEC: 781 tmp = mm->context.exec_fdpic_loadmap; 782 break; 783 case PTRACE_GETFDPIC_INTERP: 784 tmp = mm->context.interp_fdpic_loadmap; 785 break; 786 default: 787 break; 788 } 789 mmput(mm); 790 791 ret = put_user(tmp, datalp); 792 break; 793 } 794 #endif 795 796 #ifdef PTRACE_SINGLESTEP 797 case PTRACE_SINGLESTEP: 798 #endif 799 #ifdef PTRACE_SINGLEBLOCK 800 case PTRACE_SINGLEBLOCK: 801 #endif 802 #ifdef PTRACE_SYSEMU 803 case PTRACE_SYSEMU: 804 case PTRACE_SYSEMU_SINGLESTEP: 805 #endif 806 case PTRACE_SYSCALL: 807 case PTRACE_CONT: 808 return ptrace_resume(child, request, data); 809 810 case PTRACE_KILL: 811 if (child->exit_state) /* already dead */ 812 return 0; 813 return ptrace_resume(child, request, SIGKILL); 814 815 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 816 case PTRACE_GETREGSET: 817 case PTRACE_SETREGSET: 818 { 819 struct iovec kiov; 820 struct iovec __user *uiov = datavp; 821 822 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) 823 return -EFAULT; 824 825 if (__get_user(kiov.iov_base, &uiov->iov_base) || 826 __get_user(kiov.iov_len, &uiov->iov_len)) 827 return -EFAULT; 828 829 ret = ptrace_regset(child, request, addr, &kiov); 830 if (!ret) 831 ret = __put_user(kiov.iov_len, &uiov->iov_len); 832 break; 833 } 834 #endif 835 default: 836 break; 837 } 838 839 return ret; 840 } 841 842 static struct task_struct *ptrace_get_task_struct(pid_t pid) 843 { 844 struct task_struct *child; 845 846 rcu_read_lock(); 847 child = find_task_by_vpid(pid); 848 if (child) 849 get_task_struct(child); 850 rcu_read_unlock(); 851 852 if (!child) 853 return ERR_PTR(-ESRCH); 854 return child; 855 } 856 857 #ifndef arch_ptrace_attach 858 #define arch_ptrace_attach(child) do { } while (0) 859 #endif 860 861 SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr, 862 unsigned long, data) 863 { 864 struct task_struct *child; 865 long ret; 866 867 if (request == PTRACE_TRACEME) { 868 ret = ptrace_traceme(); 869 if (!ret) 870 arch_ptrace_attach(current); 871 goto out; 872 } 873 874 child = ptrace_get_task_struct(pid); 875 if (IS_ERR(child)) { 876 ret = PTR_ERR(child); 877 goto out; 878 } 879 880 if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) { 881 ret = ptrace_attach(child, request, addr, data); 882 /* 883 * Some architectures need to do book-keeping after 884 * a ptrace attach. 885 */ 886 if (!ret) 887 arch_ptrace_attach(child); 888 goto out_put_task_struct; 889 } 890 891 ret = ptrace_check_attach(child, request == PTRACE_KILL || 892 request == PTRACE_INTERRUPT); 893 if (ret < 0) 894 goto out_put_task_struct; 895 896 ret = arch_ptrace(child, request, addr, data); 897 898 out_put_task_struct: 899 put_task_struct(child); 900 out: 901 return ret; 902 } 903 904 int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr, 905 unsigned long data) 906 { 907 unsigned long tmp; 908 int copied; 909 910 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0); 911 if (copied != sizeof(tmp)) 912 return -EIO; 913 return put_user(tmp, (unsigned long __user *)data); 914 } 915 916 int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr, 917 unsigned long data) 918 { 919 int copied; 920 921 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1); 922 return (copied == sizeof(data)) ? 0 : -EIO; 923 } 924 925 #if defined CONFIG_COMPAT 926 #include <linux/compat.h> 927 928 int compat_ptrace_request(struct task_struct *child, compat_long_t request, 929 compat_ulong_t addr, compat_ulong_t data) 930 { 931 compat_ulong_t __user *datap = compat_ptr(data); 932 compat_ulong_t word; 933 siginfo_t siginfo; 934 int ret; 935 936 switch (request) { 937 case PTRACE_PEEKTEXT: 938 case PTRACE_PEEKDATA: 939 ret = access_process_vm(child, addr, &word, sizeof(word), 0); 940 if (ret != sizeof(word)) 941 ret = -EIO; 942 else 943 ret = put_user(word, datap); 944 break; 945 946 case PTRACE_POKETEXT: 947 case PTRACE_POKEDATA: 948 ret = access_process_vm(child, addr, &data, sizeof(data), 1); 949 ret = (ret != sizeof(data) ? -EIO : 0); 950 break; 951 952 case PTRACE_GETEVENTMSG: 953 ret = put_user((compat_ulong_t) child->ptrace_message, datap); 954 break; 955 956 case PTRACE_GETSIGINFO: 957 ret = ptrace_getsiginfo(child, &siginfo); 958 if (!ret) 959 ret = copy_siginfo_to_user32( 960 (struct compat_siginfo __user *) datap, 961 &siginfo); 962 break; 963 964 case PTRACE_SETSIGINFO: 965 memset(&siginfo, 0, sizeof siginfo); 966 if (copy_siginfo_from_user32( 967 &siginfo, (struct compat_siginfo __user *) datap)) 968 ret = -EFAULT; 969 else 970 ret = ptrace_setsiginfo(child, &siginfo); 971 break; 972 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 973 case PTRACE_GETREGSET: 974 case PTRACE_SETREGSET: 975 { 976 struct iovec kiov; 977 struct compat_iovec __user *uiov = 978 (struct compat_iovec __user *) datap; 979 compat_uptr_t ptr; 980 compat_size_t len; 981 982 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) 983 return -EFAULT; 984 985 if (__get_user(ptr, &uiov->iov_base) || 986 __get_user(len, &uiov->iov_len)) 987 return -EFAULT; 988 989 kiov.iov_base = compat_ptr(ptr); 990 kiov.iov_len = len; 991 992 ret = ptrace_regset(child, request, addr, &kiov); 993 if (!ret) 994 ret = __put_user(kiov.iov_len, &uiov->iov_len); 995 break; 996 } 997 #endif 998 999 default: 1000 ret = ptrace_request(child, request, addr, data); 1001 } 1002 1003 return ret; 1004 } 1005 1006 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid, 1007 compat_long_t addr, compat_long_t data) 1008 { 1009 struct task_struct *child; 1010 long ret; 1011 1012 if (request == PTRACE_TRACEME) { 1013 ret = ptrace_traceme(); 1014 goto out; 1015 } 1016 1017 child = ptrace_get_task_struct(pid); 1018 if (IS_ERR(child)) { 1019 ret = PTR_ERR(child); 1020 goto out; 1021 } 1022 1023 if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) { 1024 ret = ptrace_attach(child, request, addr, data); 1025 /* 1026 * Some architectures need to do book-keeping after 1027 * a ptrace attach. 1028 */ 1029 if (!ret) 1030 arch_ptrace_attach(child); 1031 goto out_put_task_struct; 1032 } 1033 1034 ret = ptrace_check_attach(child, request == PTRACE_KILL || 1035 request == PTRACE_INTERRUPT); 1036 if (!ret) 1037 ret = compat_arch_ptrace(child, request, addr, data); 1038 1039 out_put_task_struct: 1040 put_task_struct(child); 1041 out: 1042 return ret; 1043 } 1044 #endif /* CONFIG_COMPAT */ 1045 1046 #ifdef CONFIG_HAVE_HW_BREAKPOINT 1047 int ptrace_get_breakpoints(struct task_struct *tsk) 1048 { 1049 if (atomic_inc_not_zero(&tsk->ptrace_bp_refcnt)) 1050 return 0; 1051 1052 return -1; 1053 } 1054 1055 void ptrace_put_breakpoints(struct task_struct *tsk) 1056 { 1057 if (atomic_dec_and_test(&tsk->ptrace_bp_refcnt)) 1058 flush_ptrace_hw_breakpoint(tsk); 1059 } 1060 #endif /* CONFIG_HAVE_HW_BREAKPOINT */ 1061