Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 * linux/kernel/ptrace.c

 *

 * (C) Copyright 1999 Linus Torvalds

 *

 * Common interfaces for "ptrace()" which we do not want

 * to continually duplicate across every architecture.

 */

#include <linux/capability.h>

#include <linux/module.h>

#include <linux/sched.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/highmem.h>

#include <linux/pagemap.h>

#include <linux/smp_lock.h>

#include <linux/ptrace.h>

#include <linux/security.h>

#include <linux/signal.h>

#include <linux/audit.h>

#include <linux/pid_namespace.h>

#include <asm/pgtable.h>

#include <asm/uaccess.h>

/*

 * ptrace a task: make the debugger its new parent and

 * move it to the ptrace list.

 *

 * Must be called with the tasklist lock write-held.

 */

void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)

{

        BUG_ON(!list_empty(&child->ptrace_list));

        if (child->parent == new_parent)

                return;

        list_add(&child->ptrace_list, &child->parent->ptrace_children);

        remove_parent(child);

        child->parent = new_parent;

        add_parent(child);

}

/*

 * Turn a tracing stop into a normal stop now, since with no tracer there

 * would be no way to wake it up with SIGCONT or SIGKILL.  If there was a

 * signal sent that would resume the child, but didn't because it was in

 * TASK_TRACED, resume it now.

 * Requires that irqs be disabled.

 */

void ptrace_untrace(struct task_struct *child)

{

        spin_lock(&child->sighand->siglock);

        if (child->state == TASK_TRACED) {

                if (child->signal->flags & SIGNAL_STOP_STOPPED) {

                        child->state = TASK_STOPPED;

                } else {

                        signal_wake_up(child, 1);

                }

        }

        spin_unlock(&child->sighand->siglock);

}

/*

 * unptrace a task: move it back to its original parent and

 * remove it from the ptrace list.

 *

 * Must be called with the tasklist lock write-held.

 */

void __ptrace_unlink(struct task_struct *child)

{

        BUG_ON(!child->ptrace);

        child->ptrace = 0;

        if (!list_empty(&child->ptrace_list)) {

                list_del_init(&child->ptrace_list);

                remove_parent(child);

                child->parent = child->real_parent;

                add_parent(child);

        }

        if (child->state == TASK_TRACED)

                ptrace_untrace(child);

}

/*

 * Check that we have indeed attached to the thing..

 */

int ptrace_check_attach(struct task_struct *child, int kill)

{

        int ret = -ESRCH;

        /*

         * We take the read lock around doing both checks to close a

         * possible race where someone else was tracing our child and

         * detached between these two checks.  After this locked check,

         * we are sure that this is our traced child and that can only

         * be changed by us so it's not changing right after this.

         */

        read_lock(&tasklist_lock);

        if ((child->ptrace & PT_PTRACED) && child->parent == current &&

            (!(child->ptrace & PT_ATTACHED) || child->real_parent != current)

            && child->signal != NULL) {

                ret = 0;

                spin_lock_irq(&child->sighand->siglock);

                if (child->state == TASK_STOPPED) {

                        child->state = TASK_TRACED;

                } else if (child->state != TASK_TRACED && !kill) {

                        ret = -ESRCH;

                }

                spin_unlock_irq(&child->sighand->siglock);

        }

        read_unlock(&tasklist_lock);

        if (!ret && !kill) {

                wait_task_inactive(child);

        }

        /* All systems go.. */

        return ret;

}

int __ptrace_may_attach(struct task_struct *task)

{

        /* May we inspect the given task?

         * This check is used both for attaching with ptrace

         * and for allowing access to sensitive information in /proc.

         *

         * ptrace_attach denies several cases that /proc allows

         * because setting up the necessary parent/child relationship

         * or halting the specified task is impossible.

         */

        int dumpable = 0;

        /* Don't let security modules deny introspection */

        if (task == current)

                return 0;

        if (((current->uid != task->euid) ||

             (current->uid != task->suid) ||

             (current->uid != task->uid) ||

             (current->gid != task->egid) ||

             (current->gid != task->sgid) ||

             (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))

                return -EPERM;

        smp_rmb();

        if (task->mm)

                dumpable = get_dumpable(task->mm);

        if (!dumpable && !capable(CAP_SYS_PTRACE))

                return -EPERM;

        return security_ptrace(current, task);

}

int ptrace_may_attach(struct task_struct *task)

{

        int err;

        task_lock(task);

        err = __ptrace_may_attach(task);

        task_unlock(task);

        return !err;

}

int ptrace_attach(struct task_struct *task)

{

        int retval;

        unsigned long flags;

        audit_ptrace(task);

        retval = -EPERM;

        if (task->pid <= 1)

                goto out;

        if (same_thread_group(task, current))

                goto out;

repeat:

        /*

         * Nasty, nasty.

         *

         * We want to hold both the task-lock and the

         * tasklist_lock for writing at the same time.

         * But that's against the rules (tasklist_lock

         * is taken for reading by interrupts on other

         * cpu's that may have task_lock).

         */

        task_lock(task);

        if (!write_trylock_irqsave(&tasklist_lock, flags)) {

                task_unlock(task);

                do {

                        cpu_relax();

                } while (!write_can_lock(&tasklist_lock));

                goto repeat;

        }

        if (!task->mm)

                goto bad;

        /* the same process cannot be attached many times */

        if (task->ptrace & PT_PTRACED)

                goto bad;

        retval = __ptrace_may_attach(task);

        if (retval)

                goto bad;

        /* Go */

        task->ptrace |= PT_PTRACED | ((task->real_parent != current)

                                      ? PT_ATTACHED : 0);

        if (capable(CAP_SYS_PTRACE))

                task->ptrace |= PT_PTRACE_CAP;

        __ptrace_link(task, current);

        force_sig_specific(SIGSTOP, task);

bad:

        write_unlock_irqrestore(&tasklist_lock, flags);

        task_unlock(task);

out:

        return retval;

}

static inline void __ptrace_detach(struct task_struct *child, unsigned int data)

{

        child->exit_code = data;

        /* .. re-parent .. */

        __ptrace_unlink(child);

        /* .. and wake it up. */

        if (child->exit_state != EXIT_ZOMBIE)

                wake_up_process(child);

}

int ptrace_detach(struct task_struct *child, unsigned int data)

{

        if (!valid_signal(data))

                return -EIO;

        /* Architecture-specific hardware disable .. */

        ptrace_disable(child);

        clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);

        write_lock_irq(&tasklist_lock);

        /* protect against de_thread()->release_task() */

        if (child->ptrace)

                __ptrace_detach(child, data);

        write_unlock_irq(&tasklist_lock);

        return 0;

}

int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)

{

        int copied = 0;

        while (len > 0) {

                char buf[128];

                int this_len, retval;

                this_len = (len > sizeof(buf)) ? sizeof(buf) : len;

                retval = access_process_vm(tsk, src, buf, this_len, 0);

                if (!retval) {

                        if (copied)

                                break;

                        return -EIO;

                }

                if (copy_to_user(dst, buf, retval))

                        return -EFAULT;

                copied += retval;

                src += retval;

                dst += retval;

                len -= retval;

        }

        return copied;

}

int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)

{

        int copied = 0;

        while (len > 0) {

                char buf[128];

                int this_len, retval;

                this_len = (len > sizeof(buf)) ? sizeof(buf) : len;

                if (copy_from_user(buf, src, this_len))

                        return -EFAULT;

                retval = access_process_vm(tsk, dst, buf, this_len, 1);

                if (!retval) {

                        if (copied)

                                break;

                        return -EIO;

                }

                copied += retval;

                src += retval;

                dst += retval;

                len -= retval;

        }

        return copied;

}

static int ptrace_setoptions(struct task_struct *child, long data)

{

        child->ptrace &= ~PT_TRACE_MASK;

        if (data & PTRACE_O_TRACESYSGOOD)

                child->ptrace |= PT_TRACESYSGOOD;

        if (data & PTRACE_O_TRACEFORK)

                child->ptrace |= PT_TRACE_FORK;

        if (data & PTRACE_O_TRACEVFORK)

                child->ptrace |= PT_TRACE_VFORK;

        if (data & PTRACE_O_TRACECLONE)

                child->ptrace |= PT_TRACE_CLONE;

        if (data & PTRACE_O_TRACEEXEC)

                child->ptrace |= PT_TRACE_EXEC;

        if (data & PTRACE_O_TRACEVFORKDONE)

                child->ptrace |= PT_TRACE_VFORK_DONE;

        if (data & PTRACE_O_TRACEEXIT)

                child->ptrace |= PT_TRACE_EXIT;

        return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;

}

static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)

{

        siginfo_t lastinfo;

        int error = -ESRCH;

        read_lock(&tasklist_lock);

        if (likely(child->sighand != NULL)) {

                error = -EINVAL;

                spin_lock_irq(&child->sighand->siglock);

                if (likely(child->last_siginfo != NULL)) {

                        lastinfo = *child->last_siginfo;

                        error = 0;

                }

                spin_unlock_irq(&child->sighand->siglock);

        }

        read_unlock(&tasklist_lock);

        if (!error)

                return copy_siginfo_to_user(data, &lastinfo);

        return error;

}

static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)

{

        siginfo_t newinfo;

        int error = -ESRCH;

        if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))

                return -EFAULT;

        read_lock(&tasklist_lock);

        if (likely(child->sighand != NULL)) {

                error = -EINVAL;

                spin_lock_irq(&child->sighand->siglock);

                if (likely(child->last_siginfo != NULL)) {

                        *child->last_siginfo = newinfo;

                        error = 0;

                }

                spin_unlock_irq(&child->sighand->siglock);

        }

        read_unlock(&tasklist_lock);

        return error;

}

int ptrace_request(struct task_struct *child, long request,

                   long addr, long data)

{

        int ret = -EIO;

        switch (request) {

#ifdef PTRACE_OLDSETOPTIONS

        case PTRACE_OLDSETOPTIONS:

#endif

        case PTRACE_SETOPTIONS:

                ret = ptrace_setoptions(child, data);

                break;

        case PTRACE_GETEVENTMSG:

                ret = put_user(child->ptrace_message, (unsigned long __user *) data);

                break;

        case PTRACE_GETSIGINFO:

                ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);

                break;

        case PTRACE_SETSIGINFO:

                ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);

                break;

        case PTRACE_DETACH:      /* detach a process that was attached. */

                ret = ptrace_detach(child, data);

                break;

        default:

                break;

        }

        return ret;

}

/**

 * ptrace_traceme  --  helper for PTRACE_TRACEME

 *

 * Performs checks and sets PT_PTRACED.

 * Should be used by all ptrace implementations for PTRACE_TRACEME.

 */

int ptrace_traceme(void)

{

        int ret = -EPERM;

        /*

         * Are we already being traced?

         */

        task_lock(current);

        if (!(current->ptrace & PT_PTRACED)) {

                ret = security_ptrace(current->parent, current);

                /*

                 * Set the ptrace bit in the process ptrace flags.

                 */

                if (!ret)

                        current->ptrace |= PT_PTRACED;

        }

        task_unlock(current);

        return ret;

}

/**

 * ptrace_get_task_struct  --  grab a task struct reference for ptrace

 * @pid:       process id to grab a task_struct reference of

 *

 * This function is a helper for ptrace implementations.  It checks

 * permissions and then grabs a task struct for use of the actual

 * ptrace implementation.

 *

 * Returns the task_struct for @pid or an ERR_PTR() on failure.

 */

struct task_struct *ptrace_get_task_struct(pid_t pid)

{

        struct task_struct *child;

        /*

         * Tracing init is not allowed.

         */

        if (pid == 1)

                return ERR_PTR(-EPERM);

        read_lock(&tasklist_lock);

        child = find_task_by_vpid(pid);

        if (child)

                get_task_struct(child);

        read_unlock(&tasklist_lock);

        if (!child)

                return ERR_PTR(-ESRCH);

        return child;

}

#ifndef arch_ptrace_attach

#define arch_ptrace_attach(child)       do { } while (0)

#endif

#ifndef __ARCH_SYS_PTRACE

asmlinkage long sys_ptrace(long request, long pid, long addr, long data)

{

        struct task_struct *child;

        long ret;

        /*

         * This lock_kernel fixes a subtle race with suid exec

         */

        lock_kernel();

        if (request == PTRACE_TRACEME) {

                ret = ptrace_traceme();

                goto out;

        }

        child = ptrace_get_task_struct(pid);

        if (IS_ERR(child)) {

                ret = PTR_ERR(child);

                goto out;

        }

        if (request == PTRACE_ATTACH) {

                ret = ptrace_attach(child);

                /*

                 * Some architectures need to do book-keeping after

                 * a ptrace attach.

                 */

                if (!ret)

                        arch_ptrace_attach(child);

                goto out_put_task_struct;

        }

        ret = ptrace_check_attach(child, request == PTRACE_KILL);

        if (ret < 0)

                goto out_put_task_struct;

        ret = arch_ptrace(child, request, addr, data);

        if (ret < 0)

                goto out_put_task_struct;

 out_put_task_struct:

        put_task_struct(child);

 out:

        unlock_kernel();

        return ret;

}

#endif /* __ARCH_SYS_PTRACE */

int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)

{

        unsigned long tmp;

        int copied;

        copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);

        if (copied != sizeof(tmp))

                return -EIO;

        return put_user(tmp, (unsigned long __user *)data);

}

int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)

{

        int copied;

        copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);

        return (copied == sizeof(data)) ? 0 : -EIO;

}