static int elf_loadnotes(struct lwp *lp, prpsinfo_t *psinfo, prstatus_t *status, prfpregset_t *fpregset, prsavetls_t *tls) { struct proc *p = lp->lwp_proc; //struct lwp *nlp; int error; /* validate status and psinfo */ TRACE_ENTER; if (status->pr_version != PRSTATUS_VERSION || status->pr_statussz != sizeof(prstatus_t) || status->pr_gregsetsz != sizeof(gregset_t) || status->pr_fpregsetsz != sizeof(fpregset_t) || psinfo->pr_version != PRPSINFO_VERSION || psinfo->pr_psinfosz != sizeof(prpsinfo_t)) { PRINTF(("status check failed\n")); error = EINVAL; goto done; } /* XXX lwp handle more than one lwp*/ /* XXX restore each thread */ if ((error = set_regs(lp, &status->pr_reg)) != 0) goto done; error = set_fpregs(lp, fpregset); /* XXX SJG */ kprintf("Avem la load %i\n", p->p_nthreads); kprintf("xxx: restoring TLS-fu\n"); bcopy(tls, &lp->lwp_thread->td_tls, sizeof *tls); // crit_enter(); // set_user_TLS(); // crit_exit(); /* Try to recreate another thread */ #if 0 kprintf("xxx restoring a second thread\n"); status++; fpregset++; tls++; // create new thread lwp_rb_tree_RB_INSERT(&p->p_lwp_tree, nlp); //nlp->lwp_cpumask = (cpumask_t)-1; //nlp->lwp_thread ? p->p_nthreads++; p->p_lasttid++; nlp->lwp_proc = p; // append stored info if ((error = set_regs(nlp, &status->pr_reg)) != 0) goto done; error = set_fpregs(nlp, fpregset); bcopy(tls, &nlp->lwp_thread->td_tls, sizeof *tls); #endif strlcpy(p->p_comm, psinfo->pr_fname, sizeof(p->p_comm)); /* XXX psinfo->pr_psargs not yet implemented */ done: TRACE_EXIT; return error; }
long int ptrace (enum __ptrace_request __request, ...) { pid_t pid; void *addr, *data; va_list ap; va_start(ap, __request); pid = va_arg(ap, pid_t); addr = va_arg(ap, void *); data = va_arg(ap, void *); va_end(ap); if(__request == PTRACE_GETREGS) { return get_regs(pid, addr, data); } else if(__request == PTRACE_SETREGS) { return set_regs(pid, addr, data); } #if 0 //some old system may require this command to get register else if(__request == PTRACE_PEEKUSER) { } #endif else if(__request == PTRACE_GETFPREGS) { return get_fpregs(pid, addr, data, FALSE); } else if(__request == PTRACE_SETFPREGS) { return set_fpregs(pid, addr, data, FALSE); } else if(__request == PTRACE_GETFPXREGS) { return get_fpregs(pid, addr, data, TRUE); } else if(__request == PTRACE_SETFPXREGS) { return set_fpregs(pid, addr, data, TRUE); } //xstave for avx else if(__request == PTRACE_GETREGSET) { return get_regset(pid, addr, data); } else if(__request == PTRACE_SETREGSET) { return set_regset(pid, addr, data); } //For other request just forward it to real ptrace call; return g_sys_ptrace(__request, pid, addr, data); }
int set_fpregs32(struct thread *td, struct fpreg32 *fpregs) { struct fpreg fp; unsigned i; for (i = 0; i < NUMFPREGS; i++) fp.r_regs[i] = fpregs->r_regs[i]; return (set_fpregs(td, &fp)); }
/* * Here are the old "legacy" powerpc specific getregs/setregs ptrace calls, * we mark them as obsolete now, they will be removed in a future version */ static long arch_ptrace_old(struct task_struct *child, long request, long addr, long data) { int ret = -EPERM; switch(request) { case PPC_PTRACE_GETREGS: { /* Get GPRs 0 - 31. */ int i; unsigned long *reg = &((unsigned long *)child->thread.regs)[0]; unsigned long __user *tmp = (unsigned long __user *)addr; CHECK_FULL_REGS(child->thread.regs); for (i = 0; i < 32; i++) { ret = put_user(*reg, tmp); if (ret) break; reg++; tmp++; } break; } case PPC_PTRACE_SETREGS: { /* Set GPRs 0 - 31. */ int i; unsigned long *reg = &((unsigned long *)child->thread.regs)[0]; unsigned long __user *tmp = (unsigned long __user *)addr; CHECK_FULL_REGS(child->thread.regs); for (i = 0; i < 32; i++) { ret = get_user(*reg, tmp); if (ret) break; reg++; tmp++; } break; } case PPC_PTRACE_GETFPREGS: { /* Get FPRs 0 - 31. */ flush_fp_to_thread(child); ret = get_fpregs((void __user *)addr, child, 0); break; } case PPC_PTRACE_SETFPREGS: { /* Get FPRs 0 - 31. */ flush_fp_to_thread(child); ret = set_fpregs((void __user *)addr, child, 0); break; } } return ret; }
long arch_ptrace(struct task_struct *child, long request, unsigned long addr, unsigned long data) { int i, ret; unsigned long __user *p = (void __user *)data; void __user *vp = p; switch (request) { /* read word at location addr. */ case PTRACE_PEEKTEXT: case PTRACE_PEEKDATA: ret = generic_ptrace_peekdata(child, addr, data); break; /* read the word at location addr in the USER area. */ case PTRACE_PEEKUSR: ret = peek_user(child, addr, data); break; /* write the word at location addr. */ case PTRACE_POKETEXT: case PTRACE_POKEDATA: ret = generic_ptrace_pokedata(child, addr, data); break; /* write the word at location addr in the USER area */ case PTRACE_POKEUSR: ret = poke_user(child, addr, data); break; case PTRACE_SYSEMU: case PTRACE_SYSEMU_SINGLESTEP: ret = -EIO; break; #ifdef PTRACE_GETREGS case PTRACE_GETREGS: { /* Get all gp regs from the child. */ if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __put_user(getreg(child, i), p); p++; } ret = 0; break; } #endif #ifdef PTRACE_SETREGS case PTRACE_SETREGS: { /* Set all gp regs in the child. */ unsigned long tmp = 0; if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __get_user(tmp, p); putreg(child, i, tmp); p++; } ret = 0; break; } #endif #ifdef PTRACE_GETFPREGS case PTRACE_GETFPREGS: /* Get the child FPU state. */ ret = get_fpregs(vp, child); break; #endif #ifdef PTRACE_SETFPREGS case PTRACE_SETFPREGS: /* Set the child FPU state. */ ret = set_fpregs(vp, child); break; #endif case PTRACE_GET_THREAD_AREA: ret = ptrace_get_thread_area(child, addr, vp); break; case PTRACE_SET_THREAD_AREA: ret = ptrace_set_thread_area(child, addr, vp); break; case PTRACE_FAULTINFO: { /* * Take the info from thread->arch->faultinfo, * but transfer max. sizeof(struct ptrace_faultinfo). * On i386, ptrace_faultinfo is smaller! */ ret = copy_to_user(p, &child->thread.arch.faultinfo, sizeof(struct ptrace_faultinfo)) ? -EIO : 0; break; } #ifdef PTRACE_LDT case PTRACE_LDT: { struct ptrace_ldt ldt; if (copy_from_user(&ldt, p, sizeof(ldt))) { ret = -EIO; break; } /* * This one is confusing, so just punt and return -EIO for * now */ ret = -EIO; break; } #endif #ifdef PTRACE_ARCH_PRCTL case PTRACE_ARCH_PRCTL: /* XXX Calls ptrace on the host - needs some SMP thinking */ ret = arch_prctl(child, data, (void __user *) addr); break; #endif default: ret = ptrace_request(child, request, addr, data); if (ret == -EIO) ret = subarch_ptrace(child, request, addr, data); break; } return ret; }
int procfs_write_fpregs(struct lwp *lp, struct fpreg *fpregs) { return (set_fpregs(lp, fpregs)); }
long arch_ptrace(struct task_struct *child, long request, long addr, long data) { int ret = -EPERM; switch (request) { /* when I and D space are separate, these will need to be fixed. */ case PTRACE_PEEKTEXT: /* read word at location addr. */ case PTRACE_PEEKDATA: ret = generic_ptrace_peekdata(child, addr, data); break; /* read the word at location addr in the USER area. */ case PTRACE_PEEKUSR: { unsigned long index, tmp; ret = -EIO; /* convert to index and check */ #ifdef CONFIG_PPC32 index = (unsigned long) addr >> 2; if ((addr & 3) || (index > PT_FPSCR) || (child->thread.regs == NULL)) #else index = (unsigned long) addr >> 3; if ((addr & 7) || (index > PT_FPSCR)) #endif break; CHECK_FULL_REGS(child->thread.regs); if (index < PT_FPR0) { tmp = ptrace_get_reg(child, (int) index); } else { flush_fp_to_thread(child); tmp = ((unsigned long *)child->thread.fpr)[index - PT_FPR0]; } ret = put_user(tmp,(unsigned long __user *) data); break; } /* If I and D space are separate, this will have to be fixed. */ case PTRACE_POKETEXT: /* write the word at location addr. */ case PTRACE_POKEDATA: ret = generic_ptrace_pokedata(child, addr, data); break; /* write the word at location addr in the USER area */ case PTRACE_POKEUSR: { unsigned long index; ret = -EIO; /* convert to index and check */ #ifdef CONFIG_PPC32 index = (unsigned long) addr >> 2; if ((addr & 3) || (index > PT_FPSCR) || (child->thread.regs == NULL)) #else index = (unsigned long) addr >> 3; if ((addr & 7) || (index > PT_FPSCR)) #endif break; CHECK_FULL_REGS(child->thread.regs); if (index < PT_FPR0) { ret = ptrace_put_reg(child, index, data); } else { flush_fp_to_thread(child); ((unsigned long *)child->thread.fpr)[index - PT_FPR0] = data; ret = 0; } break; } case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ case PTRACE_CONT: { /* restart after signal. */ ret = -EIO; if (!valid_signal(data)) break; if (request == PTRACE_SYSCALL) set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); else clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); child->exit_code = data; /* make sure the single step bit is not set. */ clear_single_step(child); wake_up_process(child); ret = 0; break; } /* * make the child exit. Best I can do is send it a sigkill. * perhaps it should be put in the status that it wants to * exit. */ case PTRACE_KILL: { ret = 0; if (child->exit_state == EXIT_ZOMBIE) /* already dead */ break; child->exit_code = SIGKILL; /* make sure the single step bit is not set. */ clear_single_step(child); wake_up_process(child); break; } case PTRACE_SINGLESTEP: { /* set the trap flag. */ ret = -EIO; if (!valid_signal(data)) break; clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); set_single_step(child); child->exit_code = data; /* give it a chance to run. */ wake_up_process(child); ret = 0; break; } case PTRACE_GET_DEBUGREG: { ret = -EINVAL; /* We only support one DABR and no IABRS at the moment */ if (addr > 0) break; ret = put_user(child->thread.dabr, (unsigned long __user *)data); break; } case PTRACE_SET_DEBUGREG: ret = ptrace_set_debugreg(child, addr, data); break; #ifdef CONFIG_PPC64 case PTRACE_GETREGS64: #endif case PTRACE_GETREGS: { /* Get all pt_regs from the child. */ int ui; if (!access_ok(VERIFY_WRITE, (void __user *)data, sizeof(struct pt_regs))) { ret = -EIO; break; } CHECK_FULL_REGS(child->thread.regs); ret = 0; for (ui = 0; ui < PT_REGS_COUNT; ui ++) { ret |= __put_user(ptrace_get_reg(child, ui), (unsigned long __user *) data); data += sizeof(long); } break; } #ifdef CONFIG_PPC64 case PTRACE_SETREGS64: #endif case PTRACE_SETREGS: { /* Set all gp regs in the child. */ unsigned long tmp; int ui; if (!access_ok(VERIFY_READ, (void __user *)data, sizeof(struct pt_regs))) { ret = -EIO; break; } CHECK_FULL_REGS(child->thread.regs); ret = 0; for (ui = 0; ui < PT_REGS_COUNT; ui ++) { ret = __get_user(tmp, (unsigned long __user *) data); if (ret) break; ptrace_put_reg(child, ui, tmp); data += sizeof(long); } break; } case PTRACE_GETFPREGS: { /* Get the child FPU state (FPR0...31 + FPSCR) */ flush_fp_to_thread(child); ret = get_fpregs((void __user *)data, child, 1); break; } case PTRACE_SETFPREGS: { /* Set the child FPU state (FPR0...31 + FPSCR) */ flush_fp_to_thread(child); ret = set_fpregs((void __user *)data, child, 1); break; } #ifdef CONFIG_ALTIVEC case PTRACE_GETVRREGS: /* Get the child altivec register state. */ flush_altivec_to_thread(child); ret = get_vrregs((unsigned long __user *)data, child); break; case PTRACE_SETVRREGS: /* Set the child altivec register state. */ flush_altivec_to_thread(child); ret = set_vrregs(child, (unsigned long __user *)data); break; #endif #ifdef CONFIG_SPE case PTRACE_GETEVRREGS: /* Get the child spe register state. */ flush_spe_to_thread(child); ret = get_evrregs((unsigned long __user *)data, child); break; case PTRACE_SETEVRREGS: /* Set the child spe register state. */ /* this is to clear the MSR_SPE bit to force a reload * of register state from memory */ flush_spe_to_thread(child); ret = set_evrregs(child, (unsigned long __user *)data); break; #endif /* Old reverse args ptrace callss */ case PPC_PTRACE_GETREGS: /* Get GPRs 0 - 31. */ case PPC_PTRACE_SETREGS: /* Set GPRs 0 - 31. */ case PPC_PTRACE_GETFPREGS: /* Get FPRs 0 - 31. */ case PPC_PTRACE_SETFPREGS: /* Get FPRs 0 - 31. */ ret = arch_ptrace_old(child, request, addr, data); break; default: ret = ptrace_request(child, request, addr, data); break; } return ret; }
int proc_write_fpregs(struct thread *td, struct fpreg *fpregs) { PROC_ACTION(set_fpregs(td, fpregs)); }
long arch_ptrace(struct task_struct *child, long request, long addr, long data) { int i, ret; unsigned long __user *p = (void __user *)(unsigned long)data; switch (request) { /* when I and D space are separate, these will need to be fixed. */ case PTRACE_PEEKTEXT: /* read word at location addr. */ case PTRACE_PEEKDATA: { unsigned long tmp; int copied; ret = -EIO; copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); if (copied != sizeof(tmp)) break; ret = put_user(tmp, p); break; } /* read the word at location addr in the USER area. */ case PTRACE_PEEKUSR: ret = peek_user(child, addr, data); break; /* when I and D space are separate, this will have to be fixed. */ case PTRACE_POKETEXT: /* write the word at location addr. */ case PTRACE_POKEDATA: ret = -EIO; if (access_process_vm(child, addr, &data, sizeof(data), 1) != sizeof(data)) break; ret = 0; break; case PTRACE_POKEUSR: /* write the word at location addr in the USER area */ ret = poke_user(child, addr, data); break; case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ case PTRACE_CONT: { /* restart after signal. */ ret = -EIO; if (!valid_signal(data)) break; set_singlestepping(child, 0); if (request == PTRACE_SYSCALL) { set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); } else { clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); } child->exit_code = data; wake_up_process(child); ret = 0; break; } /* * make the child exit. Best I can do is send it a sigkill. * perhaps it should be put in the status that it wants to * exit. */ case PTRACE_KILL: { ret = 0; if (child->exit_state == EXIT_ZOMBIE) /* already dead */ break; set_singlestepping(child, 0); child->exit_code = SIGKILL; wake_up_process(child); break; } case PTRACE_SINGLESTEP: { /* set the trap flag. */ ret = -EIO; if (!valid_signal(data)) break; clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); set_singlestepping(child, 1); child->exit_code = data; /* give it a chance to run. */ wake_up_process(child); ret = 0; break; } case PTRACE_DETACH: /* detach a process that was attached. */ ret = ptrace_detach(child, data); break; #ifdef PTRACE_GETREGS case PTRACE_GETREGS: { /* Get all gp regs from the child. */ if (!access_ok(VERIFY_WRITE, p, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __put_user(getreg(child, i), p); p++; } ret = 0; break; } #endif #ifdef PTRACE_SETREGS case PTRACE_SETREGS: { /* Set all gp regs in the child. */ unsigned long tmp = 0; if (!access_ok(VERIFY_READ, p, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __get_user(tmp, p); putreg(child, i, tmp); p++; } ret = 0; break; } #endif #ifdef PTRACE_GETFPREGS case PTRACE_GETFPREGS: /* Get the child FPU state. */ ret = get_fpregs(data, child); break; #endif #ifdef PTRACE_SETFPREGS case PTRACE_SETFPREGS: /* Set the child FPU state. */ ret = set_fpregs(data, child); break; #endif #ifdef PTRACE_GETFPXREGS case PTRACE_GETFPXREGS: /* Get the child FPU state. */ ret = get_fpxregs(data, child); break; #endif #ifdef PTRACE_SETFPXREGS case PTRACE_SETFPXREGS: /* Set the child FPU state. */ ret = set_fpxregs(data, child); break; #endif case PTRACE_GET_THREAD_AREA: ret = ptrace_get_thread_area(child, addr, (struct user_desc __user *) data); break; case PTRACE_SET_THREAD_AREA: ret = ptrace_set_thread_area(child, addr, (struct user_desc __user *) data); break; case PTRACE_FAULTINFO: { /* Take the info from thread->arch->faultinfo, * but transfer max. sizeof(struct ptrace_faultinfo). * On i386, ptrace_faultinfo is smaller! */ ret = copy_to_user(p, &child->thread.arch.faultinfo, sizeof(struct ptrace_faultinfo)); if(ret) break; break; } #ifdef PTRACE_LDT case PTRACE_LDT: { struct ptrace_ldt ldt; if(copy_from_user(&ldt, p, sizeof(ldt))) { ret = -EIO; break; } /* This one is confusing, so just punt and return -EIO for * now */ ret = -EIO; break; } #endif #ifdef CONFIG_PROC_MM case PTRACE_SWITCH_MM: { struct mm_struct *old = child->mm; struct mm_struct *new = proc_mm_get_mm(data); if(IS_ERR(new)) { ret = PTR_ERR(new); break; } atomic_inc(&new->mm_users); child->mm = new; child->active_mm = new; mmput(old); ret = 0; break; } #endif default: ret = ptrace_request(child, request, addr, data); break; } return ret; }
long sys_ptrace(long request, long pid, long addr, long data) { struct task_struct *child; int i, ret; lock_kernel(); ret = -EPERM; if (request == PTRACE_TRACEME) { /* are we already being traced? */ if (current->ptrace & PT_PTRACED) goto out; ret = security_ptrace(current->parent, current); if (ret) goto out; /* set the ptrace bit in the process flags. */ current->ptrace |= PT_PTRACED; ret = 0; goto out; } ret = -ESRCH; read_lock(&tasklist_lock); child = find_task_by_pid(pid); if (child) get_task_struct(child); read_unlock(&tasklist_lock); if (!child) goto out; ret = -EPERM; if (pid == 1) /* you may not mess with init */ goto out_tsk; if (request == PTRACE_ATTACH) { ret = ptrace_attach(child); goto out_tsk; } #ifdef SUBACH_PTRACE_SPECIAL SUBARCH_PTRACE_SPECIAL(child,request,addr,data); #endif ret = ptrace_check_attach(child, request == PTRACE_KILL); if (ret < 0) goto out_tsk; switch (request) { /* when I and D space are separate, these will need to be fixed. */ case PTRACE_PEEKTEXT: /* read word at location addr. */ case PTRACE_PEEKDATA: { unsigned long tmp; int copied; ret = -EIO; copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0); if (copied != sizeof(tmp)) break; ret = put_user(tmp, (unsigned long __user *) data); break; } /* read the word at location addr in the USER area. */ case PTRACE_PEEKUSR: ret = peek_user(child, addr, data); break; /* when I and D space are separate, this will have to be fixed. */ case PTRACE_POKETEXT: /* write the word at location addr. */ case PTRACE_POKEDATA: ret = -EIO; if (access_process_vm(child, addr, &data, sizeof(data), 1) != sizeof(data)) break; ret = 0; break; case PTRACE_POKEUSR: /* write the word at location addr in the USER area */ ret = poke_user(child, addr, data); break; case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ case PTRACE_CONT: { /* restart after signal. */ ret = -EIO; if (!valid_signal(data)) break; set_singlestepping(child, 0); if (request == PTRACE_SYSCALL) { set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); } else { clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); } child->exit_code = data; wake_up_process(child); ret = 0; break; } /* * make the child exit. Best I can do is send it a sigkill. * perhaps it should be put in the status that it wants to * exit. */ case PTRACE_KILL: { ret = 0; if (child->exit_state == EXIT_ZOMBIE) /* already dead */ break; set_singlestepping(child, 0); child->exit_code = SIGKILL; wake_up_process(child); break; } case PTRACE_SINGLESTEP: { /* set the trap flag. */ ret = -EIO; if (!valid_signal(data)) break; clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); set_singlestepping(child, 1); child->exit_code = data; /* give it a chance to run. */ wake_up_process(child); ret = 0; break; } case PTRACE_DETACH: /* detach a process that was attached. */ ret = ptrace_detach(child, data); break; #ifdef PTRACE_GETREGS case PTRACE_GETREGS: { /* Get all gp regs from the child. */ if (!access_ok(VERIFY_WRITE, (unsigned long *)data, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __put_user(getreg(child, i), (unsigned long __user *) data); data += sizeof(long); } ret = 0; break; } #endif #ifdef PTRACE_SETREGS case PTRACE_SETREGS: { /* Set all gp regs in the child. */ unsigned long tmp = 0; if (!access_ok(VERIFY_READ, (unsigned *)data, MAX_REG_OFFSET)) { ret = -EIO; break; } for ( i = 0; i < MAX_REG_OFFSET; i += sizeof(long) ) { __get_user(tmp, (unsigned long __user *) data); putreg(child, i, tmp); data += sizeof(long); } ret = 0; break; } #endif #ifdef PTRACE_GETFPREGS case PTRACE_GETFPREGS: /* Get the child FPU state. */ ret = get_fpregs(data, child); break; #endif #ifdef PTRACE_SETFPREGS case PTRACE_SETFPREGS: /* Set the child FPU state. */ ret = set_fpregs(data, child); break; #endif #ifdef PTRACE_GETFPXREGS case PTRACE_GETFPXREGS: /* Get the child FPU state. */ ret = get_fpxregs(data, child); break; #endif #ifdef PTRACE_SETFPXREGS case PTRACE_SETFPXREGS: /* Set the child FPU state. */ ret = set_fpxregs(data, child); break; #endif case PTRACE_FAULTINFO: { /* Take the info from thread->arch->faultinfo, * but transfer max. sizeof(struct ptrace_faultinfo). * On i386, ptrace_faultinfo is smaller! */ ret = copy_to_user((unsigned long __user *) data, &child->thread.arch.faultinfo, sizeof(struct ptrace_faultinfo)); if(ret) break; break; } #ifdef PTRACE_LDT case PTRACE_LDT: { struct ptrace_ldt ldt; if(copy_from_user(&ldt, (unsigned long __user *) data, sizeof(ldt))) { ret = -EIO; break; } /* This one is confusing, so just punt and return -EIO for * now */ ret = -EIO; break; } #endif #ifdef CONFIG_PROC_MM case PTRACE_SWITCH_MM: { struct mm_struct *old = child->mm; struct mm_struct *new = proc_mm_get_mm(data); if(IS_ERR(new)) { ret = PTR_ERR(new); break; } atomic_inc(&new->mm_users); child->mm = new; child->active_mm = new; mmput(old); ret = 0; break; } #endif default: ret = ptrace_request(child, request, addr, data); break; } out_tsk: put_task_struct(child); out: unlock_kernel(); return ret; }