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