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/module.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/smp_lock.h> 18 #include <linux/ptrace.h> 19 #include <linux/security.h> 20 #include <linux/signal.h> 21 #include <linux/audit.h> 22 #include <linux/pid_namespace.h> 23 #include <linux/syscalls.h> 24 #include <linux/uaccess.h> 25 #include <linux/regset.h> 26 27 28 /* 29 * ptrace a task: make the debugger its new parent and 30 * move it to the ptrace list. 31 * 32 * Must be called with the tasklist lock write-held. 33 */ 34 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent) 35 { 36 BUG_ON(!list_empty(&child->ptrace_entry)); 37 list_add(&child->ptrace_entry, &new_parent->ptraced); 38 child->parent = new_parent; 39 } 40 41 /* 42 * Turn a tracing stop into a normal stop now, since with no tracer there 43 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a 44 * signal sent that would resume the child, but didn't because it was in 45 * TASK_TRACED, resume it now. 46 * Requires that irqs be disabled. 47 */ 48 static void ptrace_untrace(struct task_struct *child) 49 { 50 spin_lock(&child->sighand->siglock); 51 if (task_is_traced(child)) { 52 /* 53 * If the group stop is completed or in progress, 54 * this thread was already counted as stopped. 55 */ 56 if (child->signal->flags & SIGNAL_STOP_STOPPED || 57 child->signal->group_stop_count) 58 __set_task_state(child, TASK_STOPPED); 59 else 60 signal_wake_up(child, 1); 61 } 62 spin_unlock(&child->sighand->siglock); 63 } 64 65 /* 66 * unptrace a task: move it back to its original parent and 67 * remove it from the ptrace list. 68 * 69 * Must be called with the tasklist lock write-held. 70 */ 71 void __ptrace_unlink(struct task_struct *child) 72 { 73 BUG_ON(!child->ptrace); 74 75 child->ptrace = 0; 76 child->parent = child->real_parent; 77 list_del_init(&child->ptrace_entry); 78 79 arch_ptrace_untrace(child); 80 if (task_is_traced(child)) 81 ptrace_untrace(child); 82 } 83 84 /* 85 * Check that we have indeed attached to the thing.. 86 */ 87 int ptrace_check_attach(struct task_struct *child, int kill) 88 { 89 int ret = -ESRCH; 90 91 /* 92 * We take the read lock around doing both checks to close a 93 * possible race where someone else was tracing our child and 94 * detached between these two checks. After this locked check, 95 * we are sure that this is our traced child and that can only 96 * be changed by us so it's not changing right after this. 97 */ 98 read_lock(&tasklist_lock); 99 if ((child->ptrace & PT_PTRACED) && child->parent == current) { 100 ret = 0; 101 /* 102 * child->sighand can't be NULL, release_task() 103 * does ptrace_unlink() before __exit_signal(). 104 */ 105 spin_lock_irq(&child->sighand->siglock); 106 if (task_is_stopped(child)) 107 child->state = TASK_TRACED; 108 else if (!task_is_traced(child) && !kill) 109 ret = -ESRCH; 110 spin_unlock_irq(&child->sighand->siglock); 111 } 112 read_unlock(&tasklist_lock); 113 114 if (!ret && !kill) 115 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH; 116 117 /* All systems go.. */ 118 return ret; 119 } 120 121 int __ptrace_may_access(struct task_struct *task, unsigned int mode) 122 { 123 const struct cred *cred = current_cred(), *tcred; 124 125 /* May we inspect the given task? 126 * This check is used both for attaching with ptrace 127 * and for allowing access to sensitive information in /proc. 128 * 129 * ptrace_attach denies several cases that /proc allows 130 * because setting up the necessary parent/child relationship 131 * or halting the specified task is impossible. 132 */ 133 int dumpable = 0; 134 /* Don't let security modules deny introspection */ 135 if (task == current) 136 return 0; 137 rcu_read_lock(); 138 tcred = __task_cred(task); 139 if ((cred->uid != tcred->euid || 140 cred->uid != tcred->suid || 141 cred->uid != tcred->uid || 142 cred->gid != tcred->egid || 143 cred->gid != tcred->sgid || 144 cred->gid != tcred->gid) && 145 !capable(CAP_SYS_PTRACE)) { 146 rcu_read_unlock(); 147 return -EPERM; 148 } 149 rcu_read_unlock(); 150 smp_rmb(); 151 if (task->mm) 152 dumpable = get_dumpable(task->mm); 153 if (!dumpable && !capable(CAP_SYS_PTRACE)) 154 return -EPERM; 155 156 return security_ptrace_access_check(task, mode); 157 } 158 159 bool ptrace_may_access(struct task_struct *task, unsigned int mode) 160 { 161 int err; 162 task_lock(task); 163 err = __ptrace_may_access(task, mode); 164 task_unlock(task); 165 return !err; 166 } 167 168 int ptrace_attach(struct task_struct *task) 169 { 170 int retval; 171 172 audit_ptrace(task); 173 174 retval = -EPERM; 175 if (unlikely(task->flags & PF_KTHREAD)) 176 goto out; 177 if (same_thread_group(task, current)) 178 goto out; 179 180 /* 181 * Protect exec's credential calculations against our interference; 182 * interference; SUID, SGID and LSM creds get determined differently 183 * under ptrace. 184 */ 185 retval = -ERESTARTNOINTR; 186 if (mutex_lock_interruptible(&task->cred_guard_mutex)) 187 goto out; 188 189 task_lock(task); 190 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH); 191 task_unlock(task); 192 if (retval) 193 goto unlock_creds; 194 195 write_lock_irq(&tasklist_lock); 196 retval = -EPERM; 197 if (unlikely(task->exit_state)) 198 goto unlock_tasklist; 199 if (task->ptrace) 200 goto unlock_tasklist; 201 202 task->ptrace = PT_PTRACED; 203 if (capable(CAP_SYS_PTRACE)) 204 task->ptrace |= PT_PTRACE_CAP; 205 206 __ptrace_link(task, current); 207 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task); 208 209 retval = 0; 210 unlock_tasklist: 211 write_unlock_irq(&tasklist_lock); 212 unlock_creds: 213 mutex_unlock(&task->cred_guard_mutex); 214 out: 215 return retval; 216 } 217 218 /** 219 * ptrace_traceme -- helper for PTRACE_TRACEME 220 * 221 * Performs checks and sets PT_PTRACED. 222 * Should be used by all ptrace implementations for PTRACE_TRACEME. 223 */ 224 int ptrace_traceme(void) 225 { 226 int ret = -EPERM; 227 228 write_lock_irq(&tasklist_lock); 229 /* Are we already being traced? */ 230 if (!current->ptrace) { 231 ret = security_ptrace_traceme(current->parent); 232 /* 233 * Check PF_EXITING to ensure ->real_parent has not passed 234 * exit_ptrace(). Otherwise we don't report the error but 235 * pretend ->real_parent untraces us right after return. 236 */ 237 if (!ret && !(current->real_parent->flags & PF_EXITING)) { 238 current->ptrace = PT_PTRACED; 239 __ptrace_link(current, current->real_parent); 240 } 241 } 242 write_unlock_irq(&tasklist_lock); 243 244 return ret; 245 } 246 247 /* 248 * Called with irqs disabled, returns true if childs should reap themselves. 249 */ 250 static int ignoring_children(struct sighand_struct *sigh) 251 { 252 int ret; 253 spin_lock(&sigh->siglock); 254 ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) || 255 (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT); 256 spin_unlock(&sigh->siglock); 257 return ret; 258 } 259 260 /* 261 * Called with tasklist_lock held for writing. 262 * Unlink a traced task, and clean it up if it was a traced zombie. 263 * Return true if it needs to be reaped with release_task(). 264 * (We can't call release_task() here because we already hold tasklist_lock.) 265 * 266 * If it's a zombie, our attachedness prevented normal parent notification 267 * or self-reaping. Do notification now if it would have happened earlier. 268 * If it should reap itself, return true. 269 * 270 * If it's our own child, there is no notification to do. But if our normal 271 * children self-reap, then this child was prevented by ptrace and we must 272 * reap it now, in that case we must also wake up sub-threads sleeping in 273 * do_wait(). 274 */ 275 static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p) 276 { 277 __ptrace_unlink(p); 278 279 if (p->exit_state == EXIT_ZOMBIE) { 280 if (!task_detached(p) && thread_group_empty(p)) { 281 if (!same_thread_group(p->real_parent, tracer)) 282 do_notify_parent(p, p->exit_signal); 283 else if (ignoring_children(tracer->sighand)) { 284 __wake_up_parent(p, tracer); 285 p->exit_signal = -1; 286 } 287 } 288 if (task_detached(p)) { 289 /* Mark it as in the process of being reaped. */ 290 p->exit_state = EXIT_DEAD; 291 return true; 292 } 293 } 294 295 return false; 296 } 297 298 int ptrace_detach(struct task_struct *child, unsigned int data) 299 { 300 bool dead = false; 301 302 if (!valid_signal(data)) 303 return -EIO; 304 305 /* Architecture-specific hardware disable .. */ 306 ptrace_disable(child); 307 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 308 309 write_lock_irq(&tasklist_lock); 310 /* 311 * This child can be already killed. Make sure de_thread() or 312 * our sub-thread doing do_wait() didn't do release_task() yet. 313 */ 314 if (child->ptrace) { 315 child->exit_code = data; 316 dead = __ptrace_detach(current, child); 317 if (!child->exit_state) 318 wake_up_process(child); 319 } 320 write_unlock_irq(&tasklist_lock); 321 322 if (unlikely(dead)) 323 release_task(child); 324 325 return 0; 326 } 327 328 /* 329 * Detach all tasks we were using ptrace on. 330 */ 331 void exit_ptrace(struct task_struct *tracer) 332 { 333 struct task_struct *p, *n; 334 LIST_HEAD(ptrace_dead); 335 336 write_lock_irq(&tasklist_lock); 337 list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) { 338 if (__ptrace_detach(tracer, p)) 339 list_add(&p->ptrace_entry, &ptrace_dead); 340 } 341 write_unlock_irq(&tasklist_lock); 342 343 BUG_ON(!list_empty(&tracer->ptraced)); 344 345 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) { 346 list_del_init(&p->ptrace_entry); 347 release_task(p); 348 } 349 } 350 351 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len) 352 { 353 int copied = 0; 354 355 while (len > 0) { 356 char buf[128]; 357 int this_len, retval; 358 359 this_len = (len > sizeof(buf)) ? sizeof(buf) : len; 360 retval = access_process_vm(tsk, src, buf, this_len, 0); 361 if (!retval) { 362 if (copied) 363 break; 364 return -EIO; 365 } 366 if (copy_to_user(dst, buf, retval)) 367 return -EFAULT; 368 copied += retval; 369 src += retval; 370 dst += retval; 371 len -= retval; 372 } 373 return copied; 374 } 375 376 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len) 377 { 378 int copied = 0; 379 380 while (len > 0) { 381 char buf[128]; 382 int this_len, retval; 383 384 this_len = (len > sizeof(buf)) ? sizeof(buf) : len; 385 if (copy_from_user(buf, src, this_len)) 386 return -EFAULT; 387 retval = access_process_vm(tsk, dst, buf, this_len, 1); 388 if (!retval) { 389 if (copied) 390 break; 391 return -EIO; 392 } 393 copied += retval; 394 src += retval; 395 dst += retval; 396 len -= retval; 397 } 398 return copied; 399 } 400 401 static int ptrace_setoptions(struct task_struct *child, long data) 402 { 403 child->ptrace &= ~PT_TRACE_MASK; 404 405 if (data & PTRACE_O_TRACESYSGOOD) 406 child->ptrace |= PT_TRACESYSGOOD; 407 408 if (data & PTRACE_O_TRACEFORK) 409 child->ptrace |= PT_TRACE_FORK; 410 411 if (data & PTRACE_O_TRACEVFORK) 412 child->ptrace |= PT_TRACE_VFORK; 413 414 if (data & PTRACE_O_TRACECLONE) 415 child->ptrace |= PT_TRACE_CLONE; 416 417 if (data & PTRACE_O_TRACEEXEC) 418 child->ptrace |= PT_TRACE_EXEC; 419 420 if (data & PTRACE_O_TRACEVFORKDONE) 421 child->ptrace |= PT_TRACE_VFORK_DONE; 422 423 if (data & PTRACE_O_TRACEEXIT) 424 child->ptrace |= PT_TRACE_EXIT; 425 426 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0; 427 } 428 429 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info) 430 { 431 unsigned long flags; 432 int error = -ESRCH; 433 434 if (lock_task_sighand(child, &flags)) { 435 error = -EINVAL; 436 if (likely(child->last_siginfo != NULL)) { 437 *info = *child->last_siginfo; 438 error = 0; 439 } 440 unlock_task_sighand(child, &flags); 441 } 442 return error; 443 } 444 445 static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info) 446 { 447 unsigned long flags; 448 int error = -ESRCH; 449 450 if (lock_task_sighand(child, &flags)) { 451 error = -EINVAL; 452 if (likely(child->last_siginfo != NULL)) { 453 *child->last_siginfo = *info; 454 error = 0; 455 } 456 unlock_task_sighand(child, &flags); 457 } 458 return error; 459 } 460 461 462 #ifdef PTRACE_SINGLESTEP 463 #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP) 464 #else 465 #define is_singlestep(request) 0 466 #endif 467 468 #ifdef PTRACE_SINGLEBLOCK 469 #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK) 470 #else 471 #define is_singleblock(request) 0 472 #endif 473 474 #ifdef PTRACE_SYSEMU 475 #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP) 476 #else 477 #define is_sysemu_singlestep(request) 0 478 #endif 479 480 static int ptrace_resume(struct task_struct *child, long request, long data) 481 { 482 if (!valid_signal(data)) 483 return -EIO; 484 485 if (request == PTRACE_SYSCALL) 486 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 487 else 488 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); 489 490 #ifdef TIF_SYSCALL_EMU 491 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP) 492 set_tsk_thread_flag(child, TIF_SYSCALL_EMU); 493 else 494 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); 495 #endif 496 497 if (is_singleblock(request)) { 498 if (unlikely(!arch_has_block_step())) 499 return -EIO; 500 user_enable_block_step(child); 501 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) { 502 if (unlikely(!arch_has_single_step())) 503 return -EIO; 504 user_enable_single_step(child); 505 } else { 506 user_disable_single_step(child); 507 } 508 509 child->exit_code = data; 510 wake_up_process(child); 511 512 return 0; 513 } 514 515 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 516 517 static const struct user_regset * 518 find_regset(const struct user_regset_view *view, unsigned int type) 519 { 520 const struct user_regset *regset; 521 int n; 522 523 for (n = 0; n < view->n; ++n) { 524 regset = view->regsets + n; 525 if (regset->core_note_type == type) 526 return regset; 527 } 528 529 return NULL; 530 } 531 532 static int ptrace_regset(struct task_struct *task, int req, unsigned int type, 533 struct iovec *kiov) 534 { 535 const struct user_regset_view *view = task_user_regset_view(task); 536 const struct user_regset *regset = find_regset(view, type); 537 int regset_no; 538 539 if (!regset || (kiov->iov_len % regset->size) != 0) 540 return -EINVAL; 541 542 regset_no = regset - view->regsets; 543 kiov->iov_len = min(kiov->iov_len, 544 (__kernel_size_t) (regset->n * regset->size)); 545 546 if (req == PTRACE_GETREGSET) 547 return copy_regset_to_user(task, view, regset_no, 0, 548 kiov->iov_len, kiov->iov_base); 549 else 550 return copy_regset_from_user(task, view, regset_no, 0, 551 kiov->iov_len, kiov->iov_base); 552 } 553 554 #endif 555 556 int ptrace_request(struct task_struct *child, long request, 557 long addr, long data) 558 { 559 int ret = -EIO; 560 siginfo_t siginfo; 561 562 switch (request) { 563 case PTRACE_PEEKTEXT: 564 case PTRACE_PEEKDATA: 565 return generic_ptrace_peekdata(child, addr, data); 566 case PTRACE_POKETEXT: 567 case PTRACE_POKEDATA: 568 return generic_ptrace_pokedata(child, addr, data); 569 570 #ifdef PTRACE_OLDSETOPTIONS 571 case PTRACE_OLDSETOPTIONS: 572 #endif 573 case PTRACE_SETOPTIONS: 574 ret = ptrace_setoptions(child, data); 575 break; 576 case PTRACE_GETEVENTMSG: 577 ret = put_user(child->ptrace_message, (unsigned long __user *) data); 578 break; 579 580 case PTRACE_GETSIGINFO: 581 ret = ptrace_getsiginfo(child, &siginfo); 582 if (!ret) 583 ret = copy_siginfo_to_user((siginfo_t __user *) data, 584 &siginfo); 585 break; 586 587 case PTRACE_SETSIGINFO: 588 if (copy_from_user(&siginfo, (siginfo_t __user *) data, 589 sizeof siginfo)) 590 ret = -EFAULT; 591 else 592 ret = ptrace_setsiginfo(child, &siginfo); 593 break; 594 595 case PTRACE_DETACH: /* detach a process that was attached. */ 596 ret = ptrace_detach(child, data); 597 break; 598 599 #ifdef PTRACE_SINGLESTEP 600 case PTRACE_SINGLESTEP: 601 #endif 602 #ifdef PTRACE_SINGLEBLOCK 603 case PTRACE_SINGLEBLOCK: 604 #endif 605 #ifdef PTRACE_SYSEMU 606 case PTRACE_SYSEMU: 607 case PTRACE_SYSEMU_SINGLESTEP: 608 #endif 609 case PTRACE_SYSCALL: 610 case PTRACE_CONT: 611 return ptrace_resume(child, request, data); 612 613 case PTRACE_KILL: 614 if (child->exit_state) /* already dead */ 615 return 0; 616 return ptrace_resume(child, request, SIGKILL); 617 618 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 619 case PTRACE_GETREGSET: 620 case PTRACE_SETREGSET: 621 { 622 struct iovec kiov; 623 struct iovec __user *uiov = (struct iovec __user *) data; 624 625 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) 626 return -EFAULT; 627 628 if (__get_user(kiov.iov_base, &uiov->iov_base) || 629 __get_user(kiov.iov_len, &uiov->iov_len)) 630 return -EFAULT; 631 632 ret = ptrace_regset(child, request, addr, &kiov); 633 if (!ret) 634 ret = __put_user(kiov.iov_len, &uiov->iov_len); 635 break; 636 } 637 #endif 638 default: 639 break; 640 } 641 642 return ret; 643 } 644 645 static struct task_struct *ptrace_get_task_struct(pid_t pid) 646 { 647 struct task_struct *child; 648 649 rcu_read_lock(); 650 child = find_task_by_vpid(pid); 651 if (child) 652 get_task_struct(child); 653 rcu_read_unlock(); 654 655 if (!child) 656 return ERR_PTR(-ESRCH); 657 return child; 658 } 659 660 #ifndef arch_ptrace_attach 661 #define arch_ptrace_attach(child) do { } while (0) 662 #endif 663 664 SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data) 665 { 666 struct task_struct *child; 667 long ret; 668 669 /* 670 * This lock_kernel fixes a subtle race with suid exec 671 */ 672 lock_kernel(); 673 if (request == PTRACE_TRACEME) { 674 ret = ptrace_traceme(); 675 if (!ret) 676 arch_ptrace_attach(current); 677 goto out; 678 } 679 680 child = ptrace_get_task_struct(pid); 681 if (IS_ERR(child)) { 682 ret = PTR_ERR(child); 683 goto out; 684 } 685 686 if (request == PTRACE_ATTACH) { 687 ret = ptrace_attach(child); 688 /* 689 * Some architectures need to do book-keeping after 690 * a ptrace attach. 691 */ 692 if (!ret) 693 arch_ptrace_attach(child); 694 goto out_put_task_struct; 695 } 696 697 ret = ptrace_check_attach(child, request == PTRACE_KILL); 698 if (ret < 0) 699 goto out_put_task_struct; 700 701 ret = arch_ptrace(child, request, addr, data); 702 703 out_put_task_struct: 704 put_task_struct(child); 705 out: 706 unlock_kernel(); 707 return ret; 708 } 709 710 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data) 711 { 712 unsigned long tmp; 713 int copied; 714 715 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0); 716 if (copied != sizeof(tmp)) 717 return -EIO; 718 return put_user(tmp, (unsigned long __user *)data); 719 } 720 721 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data) 722 { 723 int copied; 724 725 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1); 726 return (copied == sizeof(data)) ? 0 : -EIO; 727 } 728 729 #if defined CONFIG_COMPAT 730 #include <linux/compat.h> 731 732 int compat_ptrace_request(struct task_struct *child, compat_long_t request, 733 compat_ulong_t addr, compat_ulong_t data) 734 { 735 compat_ulong_t __user *datap = compat_ptr(data); 736 compat_ulong_t word; 737 siginfo_t siginfo; 738 int ret; 739 740 switch (request) { 741 case PTRACE_PEEKTEXT: 742 case PTRACE_PEEKDATA: 743 ret = access_process_vm(child, addr, &word, sizeof(word), 0); 744 if (ret != sizeof(word)) 745 ret = -EIO; 746 else 747 ret = put_user(word, datap); 748 break; 749 750 case PTRACE_POKETEXT: 751 case PTRACE_POKEDATA: 752 ret = access_process_vm(child, addr, &data, sizeof(data), 1); 753 ret = (ret != sizeof(data) ? -EIO : 0); 754 break; 755 756 case PTRACE_GETEVENTMSG: 757 ret = put_user((compat_ulong_t) child->ptrace_message, datap); 758 break; 759 760 case PTRACE_GETSIGINFO: 761 ret = ptrace_getsiginfo(child, &siginfo); 762 if (!ret) 763 ret = copy_siginfo_to_user32( 764 (struct compat_siginfo __user *) datap, 765 &siginfo); 766 break; 767 768 case PTRACE_SETSIGINFO: 769 memset(&siginfo, 0, sizeof siginfo); 770 if (copy_siginfo_from_user32( 771 &siginfo, (struct compat_siginfo __user *) datap)) 772 ret = -EFAULT; 773 else 774 ret = ptrace_setsiginfo(child, &siginfo); 775 break; 776 #ifdef CONFIG_HAVE_ARCH_TRACEHOOK 777 case PTRACE_GETREGSET: 778 case PTRACE_SETREGSET: 779 { 780 struct iovec kiov; 781 struct compat_iovec __user *uiov = 782 (struct compat_iovec __user *) datap; 783 compat_uptr_t ptr; 784 compat_size_t len; 785 786 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) 787 return -EFAULT; 788 789 if (__get_user(ptr, &uiov->iov_base) || 790 __get_user(len, &uiov->iov_len)) 791 return -EFAULT; 792 793 kiov.iov_base = compat_ptr(ptr); 794 kiov.iov_len = len; 795 796 ret = ptrace_regset(child, request, addr, &kiov); 797 if (!ret) 798 ret = __put_user(kiov.iov_len, &uiov->iov_len); 799 break; 800 } 801 #endif 802 803 default: 804 ret = ptrace_request(child, request, addr, data); 805 } 806 807 return ret; 808 } 809 810 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid, 811 compat_long_t addr, compat_long_t data) 812 { 813 struct task_struct *child; 814 long ret; 815 816 /* 817 * This lock_kernel fixes a subtle race with suid exec 818 */ 819 lock_kernel(); 820 if (request == PTRACE_TRACEME) { 821 ret = ptrace_traceme(); 822 goto out; 823 } 824 825 child = ptrace_get_task_struct(pid); 826 if (IS_ERR(child)) { 827 ret = PTR_ERR(child); 828 goto out; 829 } 830 831 if (request == PTRACE_ATTACH) { 832 ret = ptrace_attach(child); 833 /* 834 * Some architectures need to do book-keeping after 835 * a ptrace attach. 836 */ 837 if (!ret) 838 arch_ptrace_attach(child); 839 goto out_put_task_struct; 840 } 841 842 ret = ptrace_check_attach(child, request == PTRACE_KILL); 843 if (!ret) 844 ret = compat_arch_ptrace(child, request, addr, data); 845 846 out_put_task_struct: 847 put_task_struct(child); 848 out: 849 unlock_kernel(); 850 return ret; 851 } 852 #endif /* CONFIG_COMPAT */ 853