Root/kernel/ptrace.c

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 */
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    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 */
87int 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
121int __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
159bool 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
168int 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;
210unlock_tasklist:
211    write_unlock_irq(&tasklist_lock);
212unlock_creds:
213    mutex_unlock(&task->cred_guard_mutex);
214out:
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 */
224int 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 */
250static 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 */
275static 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
298int 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 */
331void 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
351int 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
376int 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
401static 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
429static 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
445static 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
480static 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
517static const struct user_regset *
518find_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
532static 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
556int 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
645static 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
664SYSCALL_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
710int 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
721int 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
732int 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
810asmlinkage 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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive