19454b2d8SWarner Losh /*- 24e68ceabSDavid Greenman * Copyright (c) 1994, Sean Eric Fagan 34e68ceabSDavid Greenman * All rights reserved. 4df8bae1dSRodney W. Grimes * 5df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 6df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 7df8bae1dSRodney W. Grimes * are met: 8df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 9df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 10df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 12df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 13df8bae1dSRodney W. Grimes * 3. All advertising materials mentioning features or use of this software 14df8bae1dSRodney W. Grimes * must display the following acknowledgement: 154e68ceabSDavid Greenman * This product includes software developed by Sean Eric Fagan. 164e68ceabSDavid Greenman * 4. The name of the author may not be used to endorse or promote products 174e68ceabSDavid Greenman * derived from this software without specific prior written permission. 18df8bae1dSRodney W. Grimes * 194e68ceabSDavid Greenman * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 224e68ceabSDavid Greenman * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29df8bae1dSRodney W. Grimes * SUCH DAMAGE. 30df8bae1dSRodney W. Grimes */ 31df8bae1dSRodney W. Grimes 32677b542eSDavid E. O'Brien #include <sys/cdefs.h> 33677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 34677b542eSDavid E. O'Brien 3562919d78SPeter Wemm #include "opt_compat.h" 3662919d78SPeter Wemm 37df8bae1dSRodney W. Grimes #include <sys/param.h> 38f23b4c91SGarrett Wollman #include <sys/systm.h> 39fb919e4dSMark Murray #include <sys/lock.h> 40fb919e4dSMark Murray #include <sys/mutex.h> 41012e544fSIan Dowse #include <sys/syscallsubr.h> 42d2d3e875SBruce Evans #include <sys/sysproto.h> 43df8bae1dSRodney W. Grimes #include <sys/proc.h> 444e68ceabSDavid Greenman #include <sys/vnode.h> 454e68ceabSDavid Greenman #include <sys/ptrace.h> 461005a129SJohn Baldwin #include <sys/sx.h> 47ef9457beSDavid Xu #include <sys/malloc.h> 486004362eSDavid Schultz #include <sys/signalvar.h> 49df8bae1dSRodney W. Grimes 504e68ceabSDavid Greenman #include <machine/reg.h> 51fb919e4dSMark Murray 524e68ceabSDavid Greenman #include <vm/vm.h> 53efeaf95aSDavid Greenman #include <vm/pmap.h> 543da32491SDag-Erling Smørgrav #include <vm/vm_extern.h> 55efeaf95aSDavid Greenman #include <vm/vm_map.h> 563da32491SDag-Erling Smørgrav #include <vm/vm_kern.h> 573da32491SDag-Erling Smørgrav #include <vm/vm_object.h> 584e68ceabSDavid Greenman #include <vm/vm_page.h> 594e68ceabSDavid Greenman 6062919d78SPeter Wemm #ifdef COMPAT_IA32 6162919d78SPeter Wemm #include <sys/procfs.h> 6262919d78SPeter Wemm #include <machine/fpu.h> 6362919d78SPeter Wemm #include <compat/ia32/ia32_reg.h> 6462919d78SPeter Wemm 6562919d78SPeter Wemm extern struct sysentvec ia32_freebsd_sysvec; 6662919d78SPeter Wemm 6762919d78SPeter Wemm struct ptrace_io_desc32 { 6862919d78SPeter Wemm int piod_op; 6962919d78SPeter Wemm u_int32_t piod_offs; 7062919d78SPeter Wemm u_int32_t piod_addr; 7162919d78SPeter Wemm u_int32_t piod_len; 7262919d78SPeter Wemm }; 7362919d78SPeter Wemm #endif 7462919d78SPeter Wemm 754b1aa58bSBruce Evans /* 764b1aa58bSBruce Evans * Functions implemented using PROC_ACTION(): 774b1aa58bSBruce Evans * 784b1aa58bSBruce Evans * proc_read_regs(proc, regs) 794b1aa58bSBruce Evans * Get the current user-visible register set from the process 804b1aa58bSBruce Evans * and copy it into the regs structure (<machine/reg.h>). 814b1aa58bSBruce Evans * The process is stopped at the time read_regs is called. 824b1aa58bSBruce Evans * 834b1aa58bSBruce Evans * proc_write_regs(proc, regs) 844b1aa58bSBruce Evans * Update the current register set from the passed in regs 854b1aa58bSBruce Evans * structure. Take care to avoid clobbering special CPU 864b1aa58bSBruce Evans * registers or privileged bits in the PSL. 874b1aa58bSBruce Evans * Depending on the architecture this may have fix-up work to do, 884b1aa58bSBruce Evans * especially if the IAR or PCW are modified. 894b1aa58bSBruce Evans * The process is stopped at the time write_regs is called. 904b1aa58bSBruce Evans * 914b1aa58bSBruce Evans * proc_read_fpregs, proc_write_fpregs 924b1aa58bSBruce Evans * deal with the floating point register set, otherwise as above. 934b1aa58bSBruce Evans * 944b1aa58bSBruce Evans * proc_read_dbregs, proc_write_dbregs 954b1aa58bSBruce Evans * deal with the processor debug register set, otherwise as above. 964b1aa58bSBruce Evans * 974b1aa58bSBruce Evans * proc_sstep(proc) 984b1aa58bSBruce Evans * Arrange for the process to trap after executing a single instruction. 994b1aa58bSBruce Evans */ 1004b1aa58bSBruce Evans 1014b1aa58bSBruce Evans #define PROC_ACTION(action) do { \ 1027c629906SDag-Erling Smørgrav int error; \ 1037c629906SDag-Erling Smørgrav \ 104eeec6babSJohn Baldwin PROC_LOCK_ASSERT(td->td_proc, MA_OWNED); \ 1054b1aa58bSBruce Evans if ((td->td_proc->p_sflag & PS_INMEM) == 0) \ 1064b1aa58bSBruce Evans error = EIO; \ 1074b1aa58bSBruce Evans else \ 1084b1aa58bSBruce Evans error = (action); \ 1097c629906SDag-Erling Smørgrav return (error); \ 1104b1aa58bSBruce Evans } while(0) 1114b1aa58bSBruce Evans 1124b1aa58bSBruce Evans int 1134b1aa58bSBruce Evans proc_read_regs(struct thread *td, struct reg *regs) 1144b1aa58bSBruce Evans { 1154b1aa58bSBruce Evans 1164b1aa58bSBruce Evans PROC_ACTION(fill_regs(td, regs)); 1177c629906SDag-Erling Smørgrav } 1187c629906SDag-Erling Smørgrav 1194b1aa58bSBruce Evans int 1204b1aa58bSBruce Evans proc_write_regs(struct thread *td, struct reg *regs) 1214b1aa58bSBruce Evans { 1224b1aa58bSBruce Evans 1234b1aa58bSBruce Evans PROC_ACTION(set_regs(td, regs)); 1244b1aa58bSBruce Evans } 1254b1aa58bSBruce Evans 1264b1aa58bSBruce Evans int 1274b1aa58bSBruce Evans proc_read_dbregs(struct thread *td, struct dbreg *dbregs) 1284b1aa58bSBruce Evans { 1294b1aa58bSBruce Evans 1304b1aa58bSBruce Evans PROC_ACTION(fill_dbregs(td, dbregs)); 1314b1aa58bSBruce Evans } 1324b1aa58bSBruce Evans 1334b1aa58bSBruce Evans int 1344b1aa58bSBruce Evans proc_write_dbregs(struct thread *td, struct dbreg *dbregs) 1354b1aa58bSBruce Evans { 1364b1aa58bSBruce Evans 1374b1aa58bSBruce Evans PROC_ACTION(set_dbregs(td, dbregs)); 1384b1aa58bSBruce Evans } 1394b1aa58bSBruce Evans 1404b1aa58bSBruce Evans /* 1414b1aa58bSBruce Evans * Ptrace doesn't support fpregs at all, and there are no security holes 1424b1aa58bSBruce Evans * or translations for fpregs, so we can just copy them. 1434b1aa58bSBruce Evans */ 1444b1aa58bSBruce Evans int 1454b1aa58bSBruce Evans proc_read_fpregs(struct thread *td, struct fpreg *fpregs) 1464b1aa58bSBruce Evans { 1474b1aa58bSBruce Evans 1484b1aa58bSBruce Evans PROC_ACTION(fill_fpregs(td, fpregs)); 1494b1aa58bSBruce Evans } 1504b1aa58bSBruce Evans 1514b1aa58bSBruce Evans int 1524b1aa58bSBruce Evans proc_write_fpregs(struct thread *td, struct fpreg *fpregs) 1534b1aa58bSBruce Evans { 1544b1aa58bSBruce Evans 1554b1aa58bSBruce Evans PROC_ACTION(set_fpregs(td, fpregs)); 1564b1aa58bSBruce Evans } 1577c629906SDag-Erling Smørgrav 15862919d78SPeter Wemm #ifdef COMPAT_IA32 15962919d78SPeter Wemm /* For 32 bit binaries, we need to expose the 32 bit regs layouts. */ 16062919d78SPeter Wemm int 16162919d78SPeter Wemm proc_read_regs32(struct thread *td, struct reg32 *regs32) 16262919d78SPeter Wemm { 16362919d78SPeter Wemm 16462919d78SPeter Wemm PROC_ACTION(fill_regs32(td, regs32)); 16562919d78SPeter Wemm } 16662919d78SPeter Wemm 16762919d78SPeter Wemm int 16862919d78SPeter Wemm proc_write_regs32(struct thread *td, struct reg32 *regs32) 16962919d78SPeter Wemm { 17062919d78SPeter Wemm 17162919d78SPeter Wemm PROC_ACTION(set_regs32(td, regs32)); 17262919d78SPeter Wemm } 17362919d78SPeter Wemm 17462919d78SPeter Wemm int 17562919d78SPeter Wemm proc_read_dbregs32(struct thread *td, struct dbreg32 *dbregs32) 17662919d78SPeter Wemm { 17762919d78SPeter Wemm 17862919d78SPeter Wemm PROC_ACTION(fill_dbregs32(td, dbregs32)); 17962919d78SPeter Wemm } 18062919d78SPeter Wemm 18162919d78SPeter Wemm int 18262919d78SPeter Wemm proc_write_dbregs32(struct thread *td, struct dbreg32 *dbregs32) 18362919d78SPeter Wemm { 18462919d78SPeter Wemm 18562919d78SPeter Wemm PROC_ACTION(set_dbregs32(td, dbregs32)); 18662919d78SPeter Wemm } 18762919d78SPeter Wemm 18862919d78SPeter Wemm int 18962919d78SPeter Wemm proc_read_fpregs32(struct thread *td, struct fpreg32 *fpregs32) 19062919d78SPeter Wemm { 19162919d78SPeter Wemm 19262919d78SPeter Wemm PROC_ACTION(fill_fpregs32(td, fpregs32)); 19362919d78SPeter Wemm } 19462919d78SPeter Wemm 19562919d78SPeter Wemm int 19662919d78SPeter Wemm proc_write_fpregs32(struct thread *td, struct fpreg32 *fpregs32) 19762919d78SPeter Wemm { 19862919d78SPeter Wemm 19962919d78SPeter Wemm PROC_ACTION(set_fpregs32(td, fpregs32)); 20062919d78SPeter Wemm } 20162919d78SPeter Wemm #endif 20262919d78SPeter Wemm 2037c629906SDag-Erling Smørgrav int 2047c629906SDag-Erling Smørgrav proc_sstep(struct thread *td) 2057c629906SDag-Erling Smørgrav { 2067c629906SDag-Erling Smørgrav 2074b1aa58bSBruce Evans PROC_ACTION(ptrace_single_step(td)); 2087c629906SDag-Erling Smørgrav } 2097c629906SDag-Erling Smørgrav 2103da32491SDag-Erling Smørgrav int 2113da32491SDag-Erling Smørgrav proc_rwmem(struct proc *p, struct uio *uio) 21250f74e92SDag-Erling Smørgrav { 2133da32491SDag-Erling Smørgrav struct vmspace *vm; 2143da32491SDag-Erling Smørgrav vm_map_t map; 215c40f7377SAlan Cox vm_object_t backing_object, object = NULL; 2163da32491SDag-Erling Smørgrav vm_offset_t pageno = 0; /* page number */ 2173da32491SDag-Erling Smørgrav vm_prot_t reqprot; 2181a276a3fSAlan Cox int error, refcnt, writing; 2194e68ceabSDavid Greenman 2204e68ceabSDavid Greenman /* 2213da32491SDag-Erling Smørgrav * if the vmspace is in the midst of being deallocated or the 2223da32491SDag-Erling Smørgrav * process is exiting, don't try to grab anything. The page table 2233da32491SDag-Erling Smørgrav * usage in that process can be messed up. 2244e68ceabSDavid Greenman */ 2253da32491SDag-Erling Smørgrav vm = p->p_vmspace; 2261a276a3fSAlan Cox if ((p->p_flag & P_WEXIT)) 227c5799337SDag-Erling Smørgrav return (EFAULT); 2281a276a3fSAlan Cox do { 2291a276a3fSAlan Cox if ((refcnt = vm->vm_refcnt) < 1) 2303da32491SDag-Erling Smørgrav return (EFAULT); 2311a276a3fSAlan Cox } while (!atomic_cmpset_int(&vm->vm_refcnt, refcnt, refcnt + 1)); 2321a276a3fSAlan Cox 2333da32491SDag-Erling Smørgrav /* 2343da32491SDag-Erling Smørgrav * The map we want... 2353da32491SDag-Erling Smørgrav */ 2363da32491SDag-Erling Smørgrav map = &vm->vm_map; 2374e68ceabSDavid Greenman 2383da32491SDag-Erling Smørgrav writing = uio->uio_rw == UIO_WRITE; 2393da32491SDag-Erling Smørgrav reqprot = writing ? (VM_PROT_WRITE | VM_PROT_OVERRIDE_WRITE) : 2403da32491SDag-Erling Smørgrav VM_PROT_READ; 2413da32491SDag-Erling Smørgrav 2423da32491SDag-Erling Smørgrav /* 2433da32491SDag-Erling Smørgrav * Only map in one page at a time. We don't have to, but it 2443da32491SDag-Erling Smørgrav * makes things easier. This way is trivial - right? 2453da32491SDag-Erling Smørgrav */ 2463da32491SDag-Erling Smørgrav do { 2473da32491SDag-Erling Smørgrav vm_map_t tmap; 2483da32491SDag-Erling Smørgrav vm_offset_t uva; 2493da32491SDag-Erling Smørgrav int page_offset; /* offset into page */ 2503da32491SDag-Erling Smørgrav vm_map_entry_t out_entry; 2513da32491SDag-Erling Smørgrav vm_prot_t out_prot; 2523da32491SDag-Erling Smørgrav boolean_t wired; 2533da32491SDag-Erling Smørgrav vm_pindex_t pindex; 2543da32491SDag-Erling Smørgrav u_int len; 2553da32491SDag-Erling Smørgrav vm_page_t m; 2563da32491SDag-Erling Smørgrav 2573da32491SDag-Erling Smørgrav object = NULL; 2583da32491SDag-Erling Smørgrav 2593da32491SDag-Erling Smørgrav uva = (vm_offset_t)uio->uio_offset; 2603da32491SDag-Erling Smørgrav 2613da32491SDag-Erling Smørgrav /* 2623da32491SDag-Erling Smørgrav * Get the page number of this segment. 2633da32491SDag-Erling Smørgrav */ 2643da32491SDag-Erling Smørgrav pageno = trunc_page(uva); 2653da32491SDag-Erling Smørgrav page_offset = uva - pageno; 2663da32491SDag-Erling Smørgrav 2673da32491SDag-Erling Smørgrav /* 2683da32491SDag-Erling Smørgrav * How many bytes to copy 2693da32491SDag-Erling Smørgrav */ 2703da32491SDag-Erling Smørgrav len = min(PAGE_SIZE - page_offset, uio->uio_resid); 2713da32491SDag-Erling Smørgrav 2723da32491SDag-Erling Smørgrav /* 2733da32491SDag-Erling Smørgrav * Fault the page on behalf of the process 2743da32491SDag-Erling Smørgrav */ 2753da32491SDag-Erling Smørgrav error = vm_fault(map, pageno, reqprot, VM_FAULT_NORMAL); 2763da32491SDag-Erling Smørgrav if (error) { 2773da32491SDag-Erling Smørgrav error = EFAULT; 2783da32491SDag-Erling Smørgrav break; 2793da32491SDag-Erling Smørgrav } 2803da32491SDag-Erling Smørgrav 2813da32491SDag-Erling Smørgrav /* 2823da32491SDag-Erling Smørgrav * Now we need to get the page. out_entry, out_prot, wired, 2833da32491SDag-Erling Smørgrav * and single_use aren't used. One would think the vm code 2843da32491SDag-Erling Smørgrav * would be a *bit* nicer... We use tmap because 2853da32491SDag-Erling Smørgrav * vm_map_lookup() can change the map argument. 2863da32491SDag-Erling Smørgrav */ 2873da32491SDag-Erling Smørgrav tmap = map; 2883da32491SDag-Erling Smørgrav error = vm_map_lookup(&tmap, pageno, reqprot, &out_entry, 2893da32491SDag-Erling Smørgrav &object, &pindex, &out_prot, &wired); 2903da32491SDag-Erling Smørgrav if (error) { 2913da32491SDag-Erling Smørgrav error = EFAULT; 2923da32491SDag-Erling Smørgrav break; 2933da32491SDag-Erling Smørgrav } 294c40f7377SAlan Cox VM_OBJECT_LOCK(object); 295c40f7377SAlan Cox while ((m = vm_page_lookup(object, pindex)) == NULL && 296c40f7377SAlan Cox !writing && 297c40f7377SAlan Cox (backing_object = object->backing_object) != NULL) { 298c40f7377SAlan Cox /* 299c40f7377SAlan Cox * Allow fallback to backing objects if we are reading. 300c40f7377SAlan Cox */ 301c40f7377SAlan Cox VM_OBJECT_LOCK(backing_object); 3023da32491SDag-Erling Smørgrav pindex += OFF_TO_IDX(object->backing_object_offset); 303c40f7377SAlan Cox VM_OBJECT_UNLOCK(object); 304c40f7377SAlan Cox object = backing_object; 3053da32491SDag-Erling Smørgrav } 306c40f7377SAlan Cox VM_OBJECT_UNLOCK(object); 3073da32491SDag-Erling Smørgrav if (m == NULL) { 3083da32491SDag-Erling Smørgrav vm_map_lookup_done(tmap, out_entry); 309c6eb850aSAlan Cox error = EFAULT; 3103da32491SDag-Erling Smørgrav break; 3113da32491SDag-Erling Smørgrav } 3123da32491SDag-Erling Smørgrav 3133da32491SDag-Erling Smørgrav /* 314c6eb850aSAlan Cox * Hold the page in memory. 3153da32491SDag-Erling Smørgrav */ 316a4e80b6bSAlan Cox vm_page_lock_queues(); 317c6eb850aSAlan Cox vm_page_hold(m); 318a4e80b6bSAlan Cox vm_page_unlock_queues(); 3193da32491SDag-Erling Smørgrav 3203da32491SDag-Erling Smørgrav /* 3213da32491SDag-Erling Smørgrav * We're done with tmap now. 3223da32491SDag-Erling Smørgrav */ 3233da32491SDag-Erling Smørgrav vm_map_lookup_done(tmap, out_entry); 3244e68ceabSDavid Greenman 3253da32491SDag-Erling Smørgrav /* 3263da32491SDag-Erling Smørgrav * Now do the i/o move. 3273da32491SDag-Erling Smørgrav */ 3282b63e7f3SAlan Cox error = uiomove_fromphys(&m, page_offset, len, uio); 3293da32491SDag-Erling Smørgrav 3303da32491SDag-Erling Smørgrav /* 331c6eb850aSAlan Cox * Release the page. 3323da32491SDag-Erling Smørgrav */ 333a4e80b6bSAlan Cox vm_page_lock_queues(); 334c6eb850aSAlan Cox vm_page_unhold(m); 335a4e80b6bSAlan Cox vm_page_unlock_queues(); 3363da32491SDag-Erling Smørgrav 3373da32491SDag-Erling Smørgrav } while (error == 0 && uio->uio_resid > 0); 3383da32491SDag-Erling Smørgrav 3393da32491SDag-Erling Smørgrav vmspace_free(vm); 3403da32491SDag-Erling Smørgrav return (error); 3414e68ceabSDavid Greenman } 3424e68ceabSDavid Greenman 343df8bae1dSRodney W. Grimes /* 344df8bae1dSRodney W. Grimes * Process debugging system call. 345df8bae1dSRodney W. Grimes */ 346d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 347df8bae1dSRodney W. Grimes struct ptrace_args { 348df8bae1dSRodney W. Grimes int req; 349df8bae1dSRodney W. Grimes pid_t pid; 350df8bae1dSRodney W. Grimes caddr_t addr; 351df8bae1dSRodney W. Grimes int data; 352df8bae1dSRodney W. Grimes }; 353d2d3e875SBruce Evans #endif 354df8bae1dSRodney W. Grimes 35562919d78SPeter Wemm #ifdef COMPAT_IA32 35662919d78SPeter Wemm /* 35762919d78SPeter Wemm * This CPP subterfuge is to try and reduce the number of ifdefs in 35862919d78SPeter Wemm * the body of the code. 35962919d78SPeter Wemm * COPYIN(uap->addr, &r.reg, sizeof r.reg); 36062919d78SPeter Wemm * becomes either: 36162919d78SPeter Wemm * copyin(uap->addr, &r.reg, sizeof r.reg); 36262919d78SPeter Wemm * or 36362919d78SPeter Wemm * copyin(uap->addr, &r.reg32, sizeof r.reg32); 36462919d78SPeter Wemm * .. except this is done at runtime. 36562919d78SPeter Wemm */ 36662919d78SPeter Wemm #define COPYIN(u, k, s) wrap32 ? \ 36762919d78SPeter Wemm copyin(u, k ## 32, s ## 32) : \ 36862919d78SPeter Wemm copyin(u, k, s) 36962919d78SPeter Wemm #define COPYOUT(k, u, s) wrap32 ? \ 37062919d78SPeter Wemm copyout(k ## 32, u, s ## 32) : \ 37162919d78SPeter Wemm copyout(k, u, s) 37262919d78SPeter Wemm #else 37362919d78SPeter Wemm #define COPYIN(u, k, s) copyin(u, k, s) 37462919d78SPeter Wemm #define COPYOUT(k, u, s) copyout(k, u, s) 37562919d78SPeter Wemm #endif 37617b8a8a7SJohn Baldwin /* 37717b8a8a7SJohn Baldwin * MPSAFE 37817b8a8a7SJohn Baldwin */ 3794e68ceabSDavid Greenman int 3803da32491SDag-Erling Smørgrav ptrace(struct thread *td, struct ptrace_args *uap) 3814e68ceabSDavid Greenman { 38219610b66SBruce Evans /* 38319610b66SBruce Evans * XXX this obfuscation is to reduce stack usage, but the register 38419610b66SBruce Evans * structs may be too large to put on the stack anyway. 38519610b66SBruce Evans */ 3863da32491SDag-Erling Smørgrav union { 3878bc814e6SDag-Erling Smørgrav struct ptrace_io_desc piod; 388fbc3247dSMarcel Moolenaar struct ptrace_lwpinfo pl; 3893da32491SDag-Erling Smørgrav struct dbreg dbreg; 3903da32491SDag-Erling Smørgrav struct fpreg fpreg; 39119610b66SBruce Evans struct reg reg; 39262919d78SPeter Wemm #ifdef COMPAT_IA32 39362919d78SPeter Wemm struct dbreg32 dbreg32; 39462919d78SPeter Wemm struct fpreg32 fpreg32; 39562919d78SPeter Wemm struct reg32 reg32; 39662919d78SPeter Wemm struct ptrace_io_desc32 piod32; 39762919d78SPeter Wemm #endif 3983da32491SDag-Erling Smørgrav } r; 399012e544fSIan Dowse void *addr; 400012e544fSIan Dowse int error = 0; 40162919d78SPeter Wemm #ifdef COMPAT_IA32 40262919d78SPeter Wemm int wrap32 = 0; 403012e544fSIan Dowse 40462919d78SPeter Wemm if (td->td_proc->p_sysent == &ia32_freebsd_sysvec) 40562919d78SPeter Wemm wrap32 = 1; 40662919d78SPeter Wemm #endif 407012e544fSIan Dowse addr = &r; 408012e544fSIan Dowse switch (uap->req) { 409012e544fSIan Dowse case PT_GETREGS: 410012e544fSIan Dowse case PT_GETFPREGS: 411012e544fSIan Dowse case PT_GETDBREGS: 412fbc3247dSMarcel Moolenaar case PT_LWPINFO: 413012e544fSIan Dowse break; 414012e544fSIan Dowse case PT_SETREGS: 41562919d78SPeter Wemm error = COPYIN(uap->addr, &r.reg, sizeof r.reg); 416012e544fSIan Dowse break; 417012e544fSIan Dowse case PT_SETFPREGS: 41862919d78SPeter Wemm error = COPYIN(uap->addr, &r.fpreg, sizeof r.fpreg); 419012e544fSIan Dowse break; 420012e544fSIan Dowse case PT_SETDBREGS: 42162919d78SPeter Wemm error = COPYIN(uap->addr, &r.dbreg, sizeof r.dbreg); 422012e544fSIan Dowse break; 423012e544fSIan Dowse case PT_IO: 42462919d78SPeter Wemm error = COPYIN(uap->addr, &r.piod, sizeof r.piod); 425012e544fSIan Dowse break; 426012e544fSIan Dowse default: 427012e544fSIan Dowse addr = uap->addr; 4281c843354SMarcel Moolenaar break; 429012e544fSIan Dowse } 430012e544fSIan Dowse if (error) 431012e544fSIan Dowse return (error); 432012e544fSIan Dowse 433012e544fSIan Dowse error = kern_ptrace(td, uap->req, uap->pid, addr, uap->data); 434012e544fSIan Dowse if (error) 435012e544fSIan Dowse return (error); 436012e544fSIan Dowse 437012e544fSIan Dowse switch (uap->req) { 438012e544fSIan Dowse case PT_IO: 43962919d78SPeter Wemm error = COPYOUT(&r.piod, uap->addr, sizeof r.piod); 440012e544fSIan Dowse break; 441012e544fSIan Dowse case PT_GETREGS: 44262919d78SPeter Wemm error = COPYOUT(&r.reg, uap->addr, sizeof r.reg); 443012e544fSIan Dowse break; 444012e544fSIan Dowse case PT_GETFPREGS: 44562919d78SPeter Wemm error = COPYOUT(&r.fpreg, uap->addr, sizeof r.fpreg); 446012e544fSIan Dowse break; 447012e544fSIan Dowse case PT_GETDBREGS: 44862919d78SPeter Wemm error = COPYOUT(&r.dbreg, uap->addr, sizeof r.dbreg); 449012e544fSIan Dowse break; 450fbc3247dSMarcel Moolenaar case PT_LWPINFO: 451fbc3247dSMarcel Moolenaar error = copyout(&r.pl, uap->addr, uap->data); 452fbc3247dSMarcel Moolenaar break; 453012e544fSIan Dowse } 454012e544fSIan Dowse 455012e544fSIan Dowse return (error); 456012e544fSIan Dowse } 45762919d78SPeter Wemm #undef COPYIN 45862919d78SPeter Wemm #undef COPYOUT 45962919d78SPeter Wemm 46062919d78SPeter Wemm #ifdef COMPAT_IA32 46162919d78SPeter Wemm /* 46262919d78SPeter Wemm * PROC_READ(regs, td2, addr); 46362919d78SPeter Wemm * becomes either: 46462919d78SPeter Wemm * proc_read_regs(td2, addr); 46562919d78SPeter Wemm * or 46662919d78SPeter Wemm * proc_read_regs32(td2, addr); 46762919d78SPeter Wemm * .. except this is done at runtime. There is an additional 46862919d78SPeter Wemm * complication in that PROC_WRITE disallows 32 bit consumers 46962919d78SPeter Wemm * from writing to 64 bit address space targets. 47062919d78SPeter Wemm */ 47162919d78SPeter Wemm #define PROC_READ(w, t, a) wrap32 ? \ 47262919d78SPeter Wemm proc_read_ ## w ## 32(t, a) : \ 47362919d78SPeter Wemm proc_read_ ## w (t, a) 47462919d78SPeter Wemm #define PROC_WRITE(w, t, a) wrap32 ? \ 47562919d78SPeter Wemm (safe ? proc_write_ ## w ## 32(t, a) : EINVAL ) : \ 47662919d78SPeter Wemm proc_write_ ## w (t, a) 47762919d78SPeter Wemm #else 47862919d78SPeter Wemm #define PROC_READ(w, t, a) proc_read_ ## w (t, a) 47962919d78SPeter Wemm #define PROC_WRITE(w, t, a) proc_write_ ## w (t, a) 48062919d78SPeter Wemm #endif 481012e544fSIan Dowse 482012e544fSIan Dowse int 483012e544fSIan Dowse kern_ptrace(struct thread *td, int req, pid_t pid, void *addr, int data) 484012e544fSIan Dowse { 485012e544fSIan Dowse struct iovec iov; 486012e544fSIan Dowse struct uio uio; 48746e12b42SAlfred Perlstein struct proc *curp, *p, *pp; 488f3b929bfSDavid Xu struct thread *td2 = NULL; 48962919d78SPeter Wemm struct ptrace_io_desc *piod = NULL; 490fbc3247dSMarcel Moolenaar struct ptrace_lwpinfo *pl; 491ef9457beSDavid Xu int error, write, tmp, num; 4926871a6c8SJohn Baldwin int proctree_locked = 0; 493ef9457beSDavid Xu lwpid_t tid = 0, *buf; 494ef9457beSDavid Xu pid_t saved_pid = pid; 49562919d78SPeter Wemm #ifdef COMPAT_IA32 49662919d78SPeter Wemm int wrap32 = 0, safe = 0; 49762919d78SPeter Wemm struct ptrace_io_desc32 *piod32 = NULL; 49862919d78SPeter Wemm #endif 4994e68ceabSDavid Greenman 50046e12b42SAlfred Perlstein curp = td->td_proc; 50146e12b42SAlfred Perlstein 502012e544fSIan Dowse /* Lock proctree before locking the process. */ 503012e544fSIan Dowse switch (req) { 5046871a6c8SJohn Baldwin case PT_TRACE_ME: 5056871a6c8SJohn Baldwin case PT_ATTACH: 5066871a6c8SJohn Baldwin case PT_STEP: 5076871a6c8SJohn Baldwin case PT_CONTINUE: 508ea924c4cSRobert Drehmel case PT_TO_SCE: 509ea924c4cSRobert Drehmel case PT_TO_SCX: 510f7fdcd45SDavid Schultz case PT_SYSCALL: 5116871a6c8SJohn Baldwin case PT_DETACH: 5126871a6c8SJohn Baldwin sx_xlock(&proctree_lock); 5136871a6c8SJohn Baldwin proctree_locked = 1; 5146871a6c8SJohn Baldwin break; 5156871a6c8SJohn Baldwin default: 5169daa5b14SMarcel Moolenaar break; 5176871a6c8SJohn Baldwin } 5186871a6c8SJohn Baldwin 5197a0dde68SPeter Wemm write = 0; 520012e544fSIan Dowse if (req == PT_TRACE_ME) { 5216871a6c8SJohn Baldwin p = td->td_proc; 52233a9ed9dSJohn Baldwin PROC_LOCK(p); 52333a9ed9dSJohn Baldwin } else { 524f3b929bfSDavid Xu if (pid <= PID_MAX) { 525012e544fSIan Dowse if ((p = pfind(pid)) == NULL) { 5266871a6c8SJohn Baldwin if (proctree_locked) 5276871a6c8SJohn Baldwin sx_xunlock(&proctree_lock); 528c5799337SDag-Erling Smørgrav return (ESRCH); 5294e68ceabSDavid Greenman } 530f3b929bfSDavid Xu } else { 531f3b929bfSDavid Xu /* this is slow, should be optimized */ 532f3b929bfSDavid Xu sx_slock(&allproc_lock); 533f3b929bfSDavid Xu FOREACH_PROC_IN_SYSTEM(p) { 534f3b929bfSDavid Xu PROC_LOCK(p); 535f3b929bfSDavid Xu mtx_lock_spin(&sched_lock); 536f3b929bfSDavid Xu FOREACH_THREAD_IN_PROC(p, td2) { 537f3b929bfSDavid Xu if (td2->td_tid == pid) 538f3b929bfSDavid Xu break; 539f3b929bfSDavid Xu } 540f3b929bfSDavid Xu mtx_unlock_spin(&sched_lock); 541f3b929bfSDavid Xu if (td2 != NULL) 542f3b929bfSDavid Xu break; /* proc lock held */ 543f3b929bfSDavid Xu PROC_UNLOCK(p); 544f3b929bfSDavid Xu } 545f3b929bfSDavid Xu sx_sunlock(&allproc_lock); 546f3b929bfSDavid Xu if (p == NULL) { 547f3b929bfSDavid Xu if (proctree_locked) 548f3b929bfSDavid Xu sx_xunlock(&proctree_lock); 549f3b929bfSDavid Xu return (ESRCH); 550f3b929bfSDavid Xu } 551f3b929bfSDavid Xu tid = pid; 552f3b929bfSDavid Xu pid = p->p_pid; 553f3b929bfSDavid Xu } 55433a9ed9dSJohn Baldwin } 5554f18efe2SRobert Watson if ((error = p_cansee(td, p)) != 0) 5566871a6c8SJohn Baldwin goto fail; 5573da32491SDag-Erling Smørgrav 558f44d9e24SJohn Baldwin if ((error = p_candebug(td, p)) != 0) 5596871a6c8SJohn Baldwin goto fail; 5606871a6c8SJohn Baldwin 5613da32491SDag-Erling Smørgrav /* 56219610b66SBruce Evans * System processes can't be debugged. 5633da32491SDag-Erling Smørgrav */ 5643da32491SDag-Erling Smørgrav if ((p->p_flag & P_SYSTEM) != 0) { 5656871a6c8SJohn Baldwin error = EINVAL; 5666871a6c8SJohn Baldwin goto fail; 5673da32491SDag-Erling Smørgrav } 5683da32491SDag-Erling Smørgrav 569f3b929bfSDavid Xu if (tid == 0) { 570f3b929bfSDavid Xu td2 = FIRST_THREAD_IN_PROC(p); 571f3b929bfSDavid Xu tid = td2->td_tid; 572f3b929bfSDavid Xu } 573f3b929bfSDavid Xu 57462919d78SPeter Wemm #ifdef COMPAT_IA32 57562919d78SPeter Wemm /* 57662919d78SPeter Wemm * Test if we're a 32 bit client and what the target is. 57762919d78SPeter Wemm * Set the wrap controls accordingly. 57862919d78SPeter Wemm */ 57962919d78SPeter Wemm if (td->td_proc->p_sysent == &ia32_freebsd_sysvec) { 58062919d78SPeter Wemm if (td2->td_proc->p_sysent == &ia32_freebsd_sysvec) 58162919d78SPeter Wemm safe = 1; 58262919d78SPeter Wemm wrap32 = 1; 58362919d78SPeter Wemm } 58462919d78SPeter Wemm #endif 585b0281cefSPeter Wemm /* 586b0281cefSPeter Wemm * Permissions check 587b0281cefSPeter Wemm */ 588012e544fSIan Dowse switch (req) { 589b0281cefSPeter Wemm case PT_TRACE_ME: 590b0281cefSPeter Wemm /* Always legal. */ 591b0281cefSPeter Wemm break; 5924e68ceabSDavid Greenman 593b0281cefSPeter Wemm case PT_ATTACH: 594b0281cefSPeter Wemm /* Self */ 5956871a6c8SJohn Baldwin if (p->p_pid == td->td_proc->p_pid) { 5966871a6c8SJohn Baldwin error = EINVAL; 5976871a6c8SJohn Baldwin goto fail; 59833a9ed9dSJohn Baldwin } 599b0281cefSPeter Wemm 600b0281cefSPeter Wemm /* Already traced */ 601731a1aeaSJohn Baldwin if (p->p_flag & P_TRACED) { 6026871a6c8SJohn Baldwin error = EBUSY; 6036871a6c8SJohn Baldwin goto fail; 604731a1aeaSJohn Baldwin } 605b0281cefSPeter Wemm 60646e12b42SAlfred Perlstein /* Can't trace an ancestor if you're being traced. */ 60746e12b42SAlfred Perlstein if (curp->p_flag & P_TRACED) { 60846e12b42SAlfred Perlstein for (pp = curp->p_pptr; pp != NULL; pp = pp->p_pptr) { 60946e12b42SAlfred Perlstein if (pp == p) { 61046e12b42SAlfred Perlstein error = EINVAL; 61146e12b42SAlfred Perlstein goto fail; 61246e12b42SAlfred Perlstein } 61346e12b42SAlfred Perlstein } 61446e12b42SAlfred Perlstein } 61546e12b42SAlfred Perlstein 61646e12b42SAlfred Perlstein 617b0281cefSPeter Wemm /* OK */ 618b0281cefSPeter Wemm break; 619b0281cefSPeter Wemm 620ef9457beSDavid Xu case PT_CLEARSTEP: 621ef9457beSDavid Xu /* Allow thread to clear single step for itself */ 622ef9457beSDavid Xu if (td->td_tid == tid) 623ef9457beSDavid Xu break; 624ef9457beSDavid Xu 625ef9457beSDavid Xu /* FALLTHROUGH */ 6261c843354SMarcel Moolenaar default: 627b0281cefSPeter Wemm /* not being traced... */ 628731a1aeaSJohn Baldwin if ((p->p_flag & P_TRACED) == 0) { 6296871a6c8SJohn Baldwin error = EPERM; 6306871a6c8SJohn Baldwin goto fail; 631731a1aeaSJohn Baldwin } 632b0281cefSPeter Wemm 633b0281cefSPeter Wemm /* not being traced by YOU */ 6346871a6c8SJohn Baldwin if (p->p_pptr != td->td_proc) { 6356871a6c8SJohn Baldwin error = EBUSY; 6366871a6c8SJohn Baldwin goto fail; 63798f03f90SJake Burkholder } 638b0281cefSPeter Wemm 639b0281cefSPeter Wemm /* not currently stopped */ 640ef9457beSDavid Xu if (!P_SHOULDSTOP(p) || p->p_suspcount != p->p_numthreads || 641ef9457beSDavid Xu (p->p_flag & P_WAITED) == 0) { 6426871a6c8SJohn Baldwin error = EBUSY; 6436871a6c8SJohn Baldwin goto fail; 6440ebabc93SJohn Baldwin } 645b0281cefSPeter Wemm 646b0281cefSPeter Wemm /* OK */ 647b0281cefSPeter Wemm break; 6484e68ceabSDavid Greenman } 649b0281cefSPeter Wemm 650b0281cefSPeter Wemm #ifdef FIX_SSTEP 651df8bae1dSRodney W. Grimes /* 652b0281cefSPeter Wemm * Single step fixup ala procfs 653b0281cefSPeter Wemm */ 654fe0d0493SPeter Wemm FIX_SSTEP(td2); /* XXXKSE */ 655b0281cefSPeter Wemm #endif 656b0281cefSPeter Wemm 657b0281cefSPeter Wemm /* 658b0281cefSPeter Wemm * Actually do the requests 659df8bae1dSRodney W. Grimes */ 6604e68ceabSDavid Greenman 661b40ce416SJulian Elischer td->td_retval[0] = 0; 6624e68ceabSDavid Greenman 663012e544fSIan Dowse switch (req) { 664b0281cefSPeter Wemm case PT_TRACE_ME: 665b0281cefSPeter Wemm /* set my trace flag and "owner" so it can read/write me */ 6664e68ceabSDavid Greenman p->p_flag |= P_TRACED; 667b0281cefSPeter Wemm p->p_oppid = p->p_pptr->p_pid; 668731a1aeaSJohn Baldwin PROC_UNLOCK(p); 6691005a129SJohn Baldwin sx_xunlock(&proctree_lock); 670c5799337SDag-Erling Smørgrav return (0); 6714e68ceabSDavid Greenman 672b0281cefSPeter Wemm case PT_ATTACH: 673b0281cefSPeter Wemm /* security check done above */ 674731a1aeaSJohn Baldwin p->p_flag |= P_TRACED; 675b0281cefSPeter Wemm p->p_oppid = p->p_pptr->p_pid; 6766871a6c8SJohn Baldwin if (p->p_pptr != td->td_proc) 6776871a6c8SJohn Baldwin proc_reparent(p, td->td_proc); 678012e544fSIan Dowse data = SIGSTOP; 679b0281cefSPeter Wemm goto sendsig; /* in PT_CONTINUE below */ 680b0281cefSPeter Wemm 681ef9457beSDavid Xu case PT_CLEARSTEP: 682ef9457beSDavid Xu _PHOLD(p); 683ef9457beSDavid Xu error = ptrace_clear_single_step(td2); 684ef9457beSDavid Xu _PRELE(p); 685ef9457beSDavid Xu if (error) 686ef9457beSDavid Xu goto fail; 687ef9457beSDavid Xu PROC_UNLOCK(p); 688ef9457beSDavid Xu return (0); 689ef9457beSDavid Xu 690ef9457beSDavid Xu case PT_SETSTEP: 691ef9457beSDavid Xu _PHOLD(p); 692ef9457beSDavid Xu error = ptrace_single_step(td2); 693ef9457beSDavid Xu _PRELE(p); 694ef9457beSDavid Xu if (error) 695ef9457beSDavid Xu goto fail; 696ef9457beSDavid Xu PROC_UNLOCK(p); 697ef9457beSDavid Xu return (0); 698ef9457beSDavid Xu 699ef9457beSDavid Xu case PT_SUSPEND: 700ef9457beSDavid Xu _PHOLD(p); 701ef9457beSDavid Xu mtx_lock_spin(&sched_lock); 702ef9457beSDavid Xu td2->td_flags |= TDF_DBSUSPEND; 703ef9457beSDavid Xu mtx_unlock_spin(&sched_lock); 704ef9457beSDavid Xu _PRELE(p); 705ef9457beSDavid Xu PROC_UNLOCK(p); 706ef9457beSDavid Xu return (0); 707ef9457beSDavid Xu 708ef9457beSDavid Xu case PT_RESUME: 709ef9457beSDavid Xu _PHOLD(p); 710ef9457beSDavid Xu mtx_lock_spin(&sched_lock); 711ef9457beSDavid Xu td2->td_flags &= ~TDF_DBSUSPEND; 712ef9457beSDavid Xu mtx_unlock_spin(&sched_lock); 713ef9457beSDavid Xu _PRELE(p); 714ef9457beSDavid Xu PROC_UNLOCK(p); 715ef9457beSDavid Xu return (0); 716ef9457beSDavid Xu 717b0281cefSPeter Wemm case PT_STEP: 718b0281cefSPeter Wemm case PT_CONTINUE: 719ea924c4cSRobert Drehmel case PT_TO_SCE: 720ea924c4cSRobert Drehmel case PT_TO_SCX: 721f7fdcd45SDavid Schultz case PT_SYSCALL: 7224e68ceabSDavid Greenman case PT_DETACH: 723007e25d9SJacques Vidrine /* Zero means do not send any signal */ 724007e25d9SJacques Vidrine if (data < 0 || data > _SIG_MAXSIG) { 7256871a6c8SJohn Baldwin error = EINVAL; 7266871a6c8SJohn Baldwin goto fail; 7276871a6c8SJohn Baldwin } 728b0281cefSPeter Wemm 7296871a6c8SJohn Baldwin _PHOLD(p); 730b0281cefSPeter Wemm 731ea924c4cSRobert Drehmel switch (req) { 732ea924c4cSRobert Drehmel case PT_STEP: 7338ac61436SJohn Baldwin PROC_UNLOCK(p); 734fe0d0493SPeter Wemm error = ptrace_single_step(td2); 7352d008b44SPeter Wemm if (error) { 7368ac61436SJohn Baldwin PRELE(p); 7378ac61436SJohn Baldwin goto fail_noproc; 738b0281cefSPeter Wemm } 7398ac61436SJohn Baldwin PROC_LOCK(p); 740ea924c4cSRobert Drehmel break; 741ea924c4cSRobert Drehmel case PT_TO_SCE: 742ea924c4cSRobert Drehmel p->p_stops |= S_PT_SCE; 743ea924c4cSRobert Drehmel break; 744ea924c4cSRobert Drehmel case PT_TO_SCX: 745ea924c4cSRobert Drehmel p->p_stops |= S_PT_SCX; 746ea924c4cSRobert Drehmel break; 747ea924c4cSRobert Drehmel case PT_SYSCALL: 748ea924c4cSRobert Drehmel p->p_stops |= S_PT_SCE | S_PT_SCX; 749ea924c4cSRobert Drehmel break; 750b0281cefSPeter Wemm } 751b0281cefSPeter Wemm 752012e544fSIan Dowse if (addr != (void *)1) { 7538ac61436SJohn Baldwin PROC_UNLOCK(p); 754012e544fSIan Dowse error = ptrace_set_pc(td2, (u_long)(uintfptr_t)addr); 7552d008b44SPeter Wemm if (error) { 7568ac61436SJohn Baldwin PRELE(p); 7578ac61436SJohn Baldwin goto fail_noproc; 758b0281cefSPeter Wemm } 7598ac61436SJohn Baldwin PROC_LOCK(p); 760b0281cefSPeter Wemm } 7616871a6c8SJohn Baldwin _PRELE(p); 762b0281cefSPeter Wemm 763012e544fSIan Dowse if (req == PT_DETACH) { 764b0281cefSPeter Wemm /* reset process parent */ 765b0281cefSPeter Wemm if (p->p_oppid != p->p_pptr->p_pid) { 766b0281cefSPeter Wemm struct proc *pp; 767b0281cefSPeter Wemm 7686871a6c8SJohn Baldwin PROC_UNLOCK(p); 769b0281cefSPeter Wemm pp = pfind(p->p_oppid); 770f591779bSSeigo Tanimura if (pp == NULL) 7716c49a8e2SJohn Baldwin pp = initproc; 772f591779bSSeigo Tanimura else 773f591779bSSeigo Tanimura PROC_UNLOCK(pp); 7746c49a8e2SJohn Baldwin PROC_LOCK(p); 7756c49a8e2SJohn Baldwin proc_reparent(p, pp); 776cf93aa16SDon Lewis if (pp == initproc) 77755b5f2a2SDon Lewis p->p_sigparent = SIGCHLD; 7786871a6c8SJohn Baldwin } 779b0281cefSPeter Wemm p->p_flag &= ~(P_TRACED | P_WAITED); 780b0281cefSPeter Wemm p->p_oppid = 0; 781731a1aeaSJohn Baldwin 782b0281cefSPeter Wemm /* should we send SIGCHLD? */ 783b0281cefSPeter Wemm } 784b0281cefSPeter Wemm 785b0281cefSPeter Wemm sendsig: 7866871a6c8SJohn Baldwin if (proctree_locked) 7876871a6c8SJohn Baldwin sx_xunlock(&proctree_lock); 788b0281cefSPeter Wemm /* deliver or queue signal */ 789e602ba25SJulian Elischer if (P_SHOULDSTOP(p)) { 790012e544fSIan Dowse p->p_xstat = data; 7911279572aSDavid Xu p->p_flag &= ~(P_STOPPED_TRACE|P_STOPPED_SIG); 792b68e0849SJohn Baldwin mtx_lock_spin(&sched_lock); 793ef9457beSDavid Xu if (saved_pid <= PID_MAX) { 794ef9457beSDavid Xu p->p_xthread->td_flags &= ~TDF_XSIG; 795ef9457beSDavid Xu p->p_xthread->td_xsig = data; 796ef9457beSDavid Xu } else { 797ef9457beSDavid Xu td2->td_flags &= ~TDF_XSIG; 798ef9457beSDavid Xu td2->td_xsig = data; 799ef9457beSDavid Xu } 800ef9457beSDavid Xu p->p_xthread = NULL; 801ef9457beSDavid Xu if (req == PT_DETACH) { 802ef9457beSDavid Xu struct thread *td3; 803ef9457beSDavid Xu FOREACH_THREAD_IN_PROC(p, td3) 804c3d88cbaSDavid Xu td3->td_flags &= ~TDF_DBSUSPEND; 805ef9457beSDavid Xu } 806ef9457beSDavid Xu /* 807ef9457beSDavid Xu * unsuspend all threads, to not let a thread run, 808ef9457beSDavid Xu * you should use PT_SUSPEND to suspend it before 809ef9457beSDavid Xu * continuing process. 810ef9457beSDavid Xu */ 81171fad9fdSJulian Elischer thread_unsuspend(p); 812ef9457beSDavid Xu thread_continued(p); 8139ed346baSBosko Milekic mtx_unlock_spin(&sched_lock); 814ef9457beSDavid Xu } else if (data) { 815012e544fSIan Dowse psignal(p, data); 816ef9457beSDavid Xu } 817731a1aeaSJohn Baldwin PROC_UNLOCK(p); 8186871a6c8SJohn Baldwin 819c5799337SDag-Erling Smørgrav return (0); 8204e68ceabSDavid Greenman 8214e68ceabSDavid Greenman case PT_WRITE_I: 8224e68ceabSDavid Greenman case PT_WRITE_D: 823b0281cefSPeter Wemm write = 1; 82493b0017fSPhilippe Charnier /* FALLTHROUGH */ 825b0281cefSPeter Wemm case PT_READ_I: 826b0281cefSPeter Wemm case PT_READ_D: 8276871a6c8SJohn Baldwin PROC_UNLOCK(p); 8285c859660SThomas Moestl tmp = 0; 829b0281cefSPeter Wemm /* write = 0 set above */ 830012e544fSIan Dowse iov.iov_base = write ? (caddr_t)&data : (caddr_t)&tmp; 831b0281cefSPeter Wemm iov.iov_len = sizeof(int); 832b0281cefSPeter Wemm uio.uio_iov = &iov; 833b0281cefSPeter Wemm uio.uio_iovcnt = 1; 834012e544fSIan Dowse uio.uio_offset = (off_t)(uintptr_t)addr; 835b0281cefSPeter Wemm uio.uio_resid = sizeof(int); 83619610b66SBruce Evans uio.uio_segflg = UIO_SYSSPACE; /* i.e.: the uap */ 837b0281cefSPeter Wemm uio.uio_rw = write ? UIO_WRITE : UIO_READ; 838b40ce416SJulian Elischer uio.uio_td = td; 8393da32491SDag-Erling Smørgrav error = proc_rwmem(p, &uio); 8402eb80d36SPeter Wemm if (uio.uio_resid != 0) { 8412eb80d36SPeter Wemm /* 8423da32491SDag-Erling Smørgrav * XXX proc_rwmem() doesn't currently return ENOSPC, 8432eb80d36SPeter Wemm * so I think write() can bogusly return 0. 8442eb80d36SPeter Wemm * XXX what happens for short writes? We don't want 8452eb80d36SPeter Wemm * to write partial data. 8463da32491SDag-Erling Smørgrav * XXX proc_rwmem() returns EPERM for other invalid 8472eb80d36SPeter Wemm * addresses. Convert this to EINVAL. Does this 8482eb80d36SPeter Wemm * clobber returns of EPERM for other reasons? 8492eb80d36SPeter Wemm */ 8502eb80d36SPeter Wemm if (error == 0 || error == ENOSPC || error == EPERM) 8512eb80d36SPeter Wemm error = EINVAL; /* EOF */ 8522eb80d36SPeter Wemm } 8535c859660SThomas Moestl if (!write) 8545c859660SThomas Moestl td->td_retval[0] = tmp; 8552eb80d36SPeter Wemm return (error); 8564e68ceabSDavid Greenman 8578bc814e6SDag-Erling Smørgrav case PT_IO: 8585c0cc63cSJohn Baldwin PROC_UNLOCK(p); 85962919d78SPeter Wemm #ifdef COMPAT_IA32 86062919d78SPeter Wemm if (wrap32) { 86162919d78SPeter Wemm piod32 = addr; 86262919d78SPeter Wemm iov.iov_base = (void *)(uintptr_t)piod32->piod_addr; 86362919d78SPeter Wemm iov.iov_len = piod32->piod_len; 86462919d78SPeter Wemm uio.uio_offset = (off_t)(uintptr_t)piod32->piod_offs; 86562919d78SPeter Wemm uio.uio_resid = piod32->piod_len; 86662919d78SPeter Wemm } else 86762919d78SPeter Wemm #endif 86862919d78SPeter Wemm { 869012e544fSIan Dowse piod = addr; 870012e544fSIan Dowse iov.iov_base = piod->piod_addr; 871012e544fSIan Dowse iov.iov_len = piod->piod_len; 872012e544fSIan Dowse uio.uio_offset = (off_t)(uintptr_t)piod->piod_offs; 873012e544fSIan Dowse uio.uio_resid = piod->piod_len; 87462919d78SPeter Wemm } 87562919d78SPeter Wemm uio.uio_iov = &iov; 87662919d78SPeter Wemm uio.uio_iovcnt = 1; 8778bc814e6SDag-Erling Smørgrav uio.uio_segflg = UIO_USERSPACE; 8788bc814e6SDag-Erling Smørgrav uio.uio_td = td; 87962919d78SPeter Wemm #ifdef COMPAT_IA32 88062919d78SPeter Wemm tmp = wrap32 ? piod32->piod_op : piod->piod_op; 88162919d78SPeter Wemm #else 88262919d78SPeter Wemm tmp = piod->piod_op; 88362919d78SPeter Wemm #endif 88462919d78SPeter Wemm switch (tmp) { 8858bc814e6SDag-Erling Smørgrav case PIOD_READ_D: 8868bc814e6SDag-Erling Smørgrav case PIOD_READ_I: 8878bc814e6SDag-Erling Smørgrav uio.uio_rw = UIO_READ; 8888bc814e6SDag-Erling Smørgrav break; 8898bc814e6SDag-Erling Smørgrav case PIOD_WRITE_D: 8908bc814e6SDag-Erling Smørgrav case PIOD_WRITE_I: 8918bc814e6SDag-Erling Smørgrav uio.uio_rw = UIO_WRITE; 8928bc814e6SDag-Erling Smørgrav break; 8938bc814e6SDag-Erling Smørgrav default: 8948bc814e6SDag-Erling Smørgrav return (EINVAL); 8958bc814e6SDag-Erling Smørgrav } 8968bc814e6SDag-Erling Smørgrav error = proc_rwmem(p, &uio); 89762919d78SPeter Wemm #ifdef COMPAT_IA32 89862919d78SPeter Wemm if (wrap32) 89962919d78SPeter Wemm piod32->piod_len -= uio.uio_resid; 90062919d78SPeter Wemm else 90162919d78SPeter Wemm #endif 902012e544fSIan Dowse piod->piod_len -= uio.uio_resid; 9038bc814e6SDag-Erling Smørgrav return (error); 9048bc814e6SDag-Erling Smørgrav 9054e68ceabSDavid Greenman case PT_KILL: 906012e544fSIan Dowse data = SIGKILL; 907b0281cefSPeter Wemm goto sendsig; /* in PT_CONTINUE above */ 908b0281cefSPeter Wemm 909b0281cefSPeter Wemm case PT_SETREGS: 9106871a6c8SJohn Baldwin _PHOLD(p); 91162919d78SPeter Wemm error = PROC_WRITE(regs, td2, addr); 9126871a6c8SJohn Baldwin _PRELE(p); 9136871a6c8SJohn Baldwin PROC_UNLOCK(p); 9143da32491SDag-Erling Smørgrav return (error); 9153da32491SDag-Erling Smørgrav 9164e68ceabSDavid Greenman case PT_GETREGS: 9176871a6c8SJohn Baldwin _PHOLD(p); 91862919d78SPeter Wemm error = PROC_READ(regs, td2, addr); 9196871a6c8SJohn Baldwin _PRELE(p); 9206871a6c8SJohn Baldwin PROC_UNLOCK(p); 9213da32491SDag-Erling Smørgrav return (error); 922b0281cefSPeter Wemm 923b0281cefSPeter Wemm case PT_SETFPREGS: 9246871a6c8SJohn Baldwin _PHOLD(p); 92562919d78SPeter Wemm error = PROC_WRITE(fpregs, td2, addr); 9266871a6c8SJohn Baldwin _PRELE(p); 9276871a6c8SJohn Baldwin PROC_UNLOCK(p); 9283da32491SDag-Erling Smørgrav return (error); 9293da32491SDag-Erling Smørgrav 930b0281cefSPeter Wemm case PT_GETFPREGS: 9316871a6c8SJohn Baldwin _PHOLD(p); 93262919d78SPeter Wemm error = PROC_READ(fpregs, td2, addr); 9336871a6c8SJohn Baldwin _PRELE(p); 9346871a6c8SJohn Baldwin PROC_UNLOCK(p); 9353da32491SDag-Erling Smørgrav return (error); 936b0281cefSPeter Wemm 937ab001a72SJonathan Lemon case PT_SETDBREGS: 9386871a6c8SJohn Baldwin _PHOLD(p); 93962919d78SPeter Wemm error = PROC_WRITE(dbregs, td2, addr); 9406871a6c8SJohn Baldwin _PRELE(p); 9416871a6c8SJohn Baldwin PROC_UNLOCK(p); 9423da32491SDag-Erling Smørgrav return (error); 9433da32491SDag-Erling Smørgrav 944ab001a72SJonathan Lemon case PT_GETDBREGS: 9456871a6c8SJohn Baldwin _PHOLD(p); 94662919d78SPeter Wemm error = PROC_READ(dbregs, td2, addr); 9476871a6c8SJohn Baldwin _PRELE(p); 9486871a6c8SJohn Baldwin PROC_UNLOCK(p); 9493da32491SDag-Erling Smørgrav return (error); 950ab001a72SJonathan Lemon 951fbc3247dSMarcel Moolenaar case PT_LWPINFO: 952fbc3247dSMarcel Moolenaar if (data == 0 || data > sizeof(*pl)) 953fbc3247dSMarcel Moolenaar return (EINVAL); 954fbc3247dSMarcel Moolenaar pl = addr; 955fbc3247dSMarcel Moolenaar _PHOLD(p); 956ef9457beSDavid Xu if (saved_pid <= PID_MAX) { 957ef9457beSDavid Xu pl->pl_lwpid = p->p_xthread->td_tid; 958ef9457beSDavid Xu pl->pl_event = PL_EVENT_SIGNAL; 959ef9457beSDavid Xu } else { 960ef9457beSDavid Xu pl->pl_lwpid = td2->td_tid; 961ef9457beSDavid Xu if (td2->td_flags & TDF_XSIG) 962ef9457beSDavid Xu pl->pl_event = PL_EVENT_SIGNAL; 963ef9457beSDavid Xu else 964ef9457beSDavid Xu pl->pl_event = 0; 965ef9457beSDavid Xu } 9661f2eac6cSDavid Xu if (td2->td_pflags & TDP_SA) { 9671f2eac6cSDavid Xu pl->pl_flags = PL_FLAG_SA; 9681f2eac6cSDavid Xu if (td2->td_upcall && !TD_CAN_UNBIND(td2)) 9691f2eac6cSDavid Xu pl->pl_flags |= PL_FLAG_BOUND; 9701f2eac6cSDavid Xu } else { 9711f2eac6cSDavid Xu pl->pl_flags = 0; 9721f2eac6cSDavid Xu } 973fbc3247dSMarcel Moolenaar _PRELE(p); 974fbc3247dSMarcel Moolenaar PROC_UNLOCK(p); 975fbc3247dSMarcel Moolenaar return (0); 976fbc3247dSMarcel Moolenaar 977ef9457beSDavid Xu case PT_GETNUMLWPS: 978ef9457beSDavid Xu td->td_retval[0] = p->p_numthreads; 979ef9457beSDavid Xu PROC_UNLOCK(p); 980ef9457beSDavid Xu return (0); 981ef9457beSDavid Xu 982ef9457beSDavid Xu case PT_GETLWPLIST: 983ef9457beSDavid Xu if (data <= 0) { 984ef9457beSDavid Xu PROC_UNLOCK(p); 985ef9457beSDavid Xu return (EINVAL); 986ef9457beSDavid Xu } 987ef9457beSDavid Xu num = imin(p->p_numthreads, data); 988ef9457beSDavid Xu PROC_UNLOCK(p); 989ef9457beSDavid Xu buf = malloc(num * sizeof(lwpid_t), M_TEMP, M_WAITOK); 990ef9457beSDavid Xu tmp = 0; 991ef9457beSDavid Xu PROC_LOCK(p); 992ef9457beSDavid Xu mtx_lock_spin(&sched_lock); 993ef9457beSDavid Xu FOREACH_THREAD_IN_PROC(p, td2) { 994ef9457beSDavid Xu if (tmp >= num) 995ef9457beSDavid Xu break; 996ef9457beSDavid Xu buf[tmp++] = td2->td_tid; 997ef9457beSDavid Xu } 998ef9457beSDavid Xu mtx_unlock_spin(&sched_lock); 999ef9457beSDavid Xu PROC_UNLOCK(p); 1000ef9457beSDavid Xu error = copyout(buf, addr, tmp * sizeof(lwpid_t)); 1001ef9457beSDavid Xu free(buf, M_TEMP); 1002ef9457beSDavid Xu if (!error) 1003ef9457beSDavid Xu td->td_retval[0] = num; 1004ef9457beSDavid Xu return (error); 1005ef9457beSDavid Xu 10064e68ceabSDavid Greenman default: 10071c843354SMarcel Moolenaar #ifdef __HAVE_PTRACE_MACHDEP 10081c843354SMarcel Moolenaar if (req >= PT_FIRSTMACH) { 10091c843354SMarcel Moolenaar _PHOLD(p); 10101c843354SMarcel Moolenaar PROC_UNLOCK(p); 10118ac61436SJohn Baldwin error = cpu_ptrace(td2, req, addr, data); 10128ac61436SJohn Baldwin PRELE(p); 10131c843354SMarcel Moolenaar return (error); 10141c843354SMarcel Moolenaar } 10151c843354SMarcel Moolenaar #endif 10164e68ceabSDavid Greenman break; 10174e68ceabSDavid Greenman } 10184e68ceabSDavid Greenman 10191c843354SMarcel Moolenaar /* Unknown request. */ 10201c843354SMarcel Moolenaar error = EINVAL; 10216871a6c8SJohn Baldwin 10226871a6c8SJohn Baldwin fail: 10236871a6c8SJohn Baldwin PROC_UNLOCK(p); 10248ac61436SJohn Baldwin fail_noproc: 10256871a6c8SJohn Baldwin if (proctree_locked) 10266871a6c8SJohn Baldwin sx_xunlock(&proctree_lock); 10276871a6c8SJohn Baldwin return (error); 1028df8bae1dSRodney W. Grimes } 102962919d78SPeter Wemm #undef PROC_READ 103062919d78SPeter Wemm #undef PROC_WRITE 1031df8bae1dSRodney W. Grimes 10322a024a2bSSean Eric Fagan /* 10333da32491SDag-Erling Smørgrav * Stop a process because of a debugging event; 10342a024a2bSSean Eric Fagan * stay stopped until p->p_step is cleared 10352a024a2bSSean Eric Fagan * (cleared by PIOCCONT in procfs). 10362a024a2bSSean Eric Fagan */ 10372a024a2bSSean Eric Fagan void 10383da32491SDag-Erling Smørgrav stopevent(struct proc *p, unsigned int event, unsigned int val) 10393897ca7cSJohn Baldwin { 10403897ca7cSJohn Baldwin 1041b68e0849SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 10422a024a2bSSean Eric Fagan p->p_step = 1; 10432a024a2bSSean Eric Fagan do { 10442a024a2bSSean Eric Fagan p->p_xstat = val; 1045ef9457beSDavid Xu p->p_xthread = NULL; 10462a024a2bSSean Eric Fagan p->p_stype = event; /* Which event caused the stop? */ 10472a024a2bSSean Eric Fagan wakeup(&p->p_stype); /* Wake up any PIOCWAIT'ing procs */ 10483897ca7cSJohn Baldwin msleep(&p->p_step, &p->p_mtx, PWAIT, "stopevent", 0); 10492a024a2bSSean Eric Fagan } while (p->p_step); 10502a024a2bSSean Eric Fagan } 1051