19454b2d8SWarner Losh /*- 28a36da99SPedro F. Giffuni * SPDX-License-Identifier: BSD-4-Clause 38a36da99SPedro F. Giffuni * 44e68ceabSDavid Greenman * Copyright (c) 1994, Sean Eric Fagan 54e68ceabSDavid Greenman * All rights reserved. 6df8bae1dSRodney W. Grimes * 7df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 8df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 9df8bae1dSRodney W. Grimes * are met: 10df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 12df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 13df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 14df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 15df8bae1dSRodney W. Grimes * 3. All advertising materials mentioning features or use of this software 16df8bae1dSRodney W. Grimes * must display the following acknowledgement: 174e68ceabSDavid Greenman * This product includes software developed by Sean Eric Fagan. 184e68ceabSDavid Greenman * 4. The name of the author may not be used to endorse or promote products 194e68ceabSDavid Greenman * derived from this software without specific prior written permission. 20df8bae1dSRodney W. Grimes * 214e68ceabSDavid Greenman * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 244e68ceabSDavid Greenman * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 25df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31df8bae1dSRodney W. Grimes * SUCH DAMAGE. 32df8bae1dSRodney W. Grimes */ 33df8bae1dSRodney W. Grimes 34677b542eSDavid E. O'Brien #include <sys/cdefs.h> 35677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 36677b542eSDavid E. O'Brien 37df8bae1dSRodney W. Grimes #include <sys/param.h> 38f23b4c91SGarrett Wollman #include <sys/systm.h> 39daec9284SConrad Meyer #include <sys/ktr.h> 40fb919e4dSMark Murray #include <sys/lock.h> 41fb919e4dSMark Murray #include <sys/mutex.h> 42012e544fSIan Dowse #include <sys/syscallsubr.h> 432883703eSKonstantin Belousov #include <sys/sysent.h> 44d2d3e875SBruce Evans #include <sys/sysproto.h> 45b4490c6eSKonstantin Belousov #include <sys/pioctl.h> 4655648840SJohn Baldwin #include <sys/priv.h> 47df8bae1dSRodney W. Grimes #include <sys/proc.h> 484e68ceabSDavid Greenman #include <sys/vnode.h> 494e68ceabSDavid Greenman #include <sys/ptrace.h> 5089f6b863SAttilio Rao #include <sys/rwlock.h> 511005a129SJohn Baldwin #include <sys/sx.h> 52ef9457beSDavid Xu #include <sys/malloc.h> 536004362eSDavid Schultz #include <sys/signalvar.h> 54df8bae1dSRodney W. Grimes 554e68ceabSDavid Greenman #include <machine/reg.h> 56fb919e4dSMark Murray 57085a0d43SWayne Salamon #include <security/audit/audit.h> 58085a0d43SWayne Salamon 594e68ceabSDavid Greenman #include <vm/vm.h> 60efeaf95aSDavid Greenman #include <vm/pmap.h> 613da32491SDag-Erling Smørgrav #include <vm/vm_extern.h> 62efeaf95aSDavid Greenman #include <vm/vm_map.h> 633da32491SDag-Erling Smørgrav #include <vm/vm_kern.h> 643da32491SDag-Erling Smørgrav #include <vm/vm_object.h> 654e68ceabSDavid Greenman #include <vm/vm_page.h> 663364c323SKonstantin Belousov #include <vm/vm_param.h> 674e68ceabSDavid Greenman 68841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 6962919d78SPeter Wemm #include <sys/procfs.h> 708a260079SKonstantin Belousov #include <compat/freebsd32/freebsd32_signal.h> 7162919d78SPeter Wemm 7262919d78SPeter Wemm struct ptrace_io_desc32 { 7362919d78SPeter Wemm int piod_op; 7460ae52f7SEd Schouten uint32_t piod_offs; 7560ae52f7SEd Schouten uint32_t piod_addr; 7660ae52f7SEd Schouten uint32_t piod_len; 7762919d78SPeter Wemm }; 788a25c0c7SMarcel Moolenaar 79*32451fb9SJohn Baldwin struct ptrace_sc_ret32 { 80*32451fb9SJohn Baldwin uint32_t sr_retval[2]; 81*32451fb9SJohn Baldwin int sr_error; 82*32451fb9SJohn Baldwin }; 83*32451fb9SJohn Baldwin 848a25c0c7SMarcel Moolenaar struct ptrace_vm_entry32 { 8516211027SMarcel Moolenaar int pve_entry; 8616211027SMarcel Moolenaar int pve_timestamp; 878a25c0c7SMarcel Moolenaar uint32_t pve_start; 888a25c0c7SMarcel Moolenaar uint32_t pve_end; 898a25c0c7SMarcel Moolenaar uint32_t pve_offset; 908a25c0c7SMarcel Moolenaar u_int pve_prot; 918a25c0c7SMarcel Moolenaar u_int pve_pathlen; 9216211027SMarcel Moolenaar int32_t pve_fileid; 9316211027SMarcel Moolenaar u_int pve_fsid; 948a25c0c7SMarcel Moolenaar uint32_t pve_path; 958a25c0c7SMarcel Moolenaar }; 9662919d78SPeter Wemm #endif 9762919d78SPeter Wemm 984b1aa58bSBruce Evans /* 994b1aa58bSBruce Evans * Functions implemented using PROC_ACTION(): 1004b1aa58bSBruce Evans * 1014b1aa58bSBruce Evans * proc_read_regs(proc, regs) 1024b1aa58bSBruce Evans * Get the current user-visible register set from the process 1034b1aa58bSBruce Evans * and copy it into the regs structure (<machine/reg.h>). 1044b1aa58bSBruce Evans * The process is stopped at the time read_regs is called. 1054b1aa58bSBruce Evans * 1064b1aa58bSBruce Evans * proc_write_regs(proc, regs) 1074b1aa58bSBruce Evans * Update the current register set from the passed in regs 1084b1aa58bSBruce Evans * structure. Take care to avoid clobbering special CPU 1094b1aa58bSBruce Evans * registers or privileged bits in the PSL. 1104b1aa58bSBruce Evans * Depending on the architecture this may have fix-up work to do, 1114b1aa58bSBruce Evans * especially if the IAR or PCW are modified. 1124b1aa58bSBruce Evans * The process is stopped at the time write_regs is called. 1134b1aa58bSBruce Evans * 1144b1aa58bSBruce Evans * proc_read_fpregs, proc_write_fpregs 1154b1aa58bSBruce Evans * deal with the floating point register set, otherwise as above. 1164b1aa58bSBruce Evans * 1174b1aa58bSBruce Evans * proc_read_dbregs, proc_write_dbregs 1184b1aa58bSBruce Evans * deal with the processor debug register set, otherwise as above. 1194b1aa58bSBruce Evans * 1204b1aa58bSBruce Evans * proc_sstep(proc) 1214b1aa58bSBruce Evans * Arrange for the process to trap after executing a single instruction. 1224b1aa58bSBruce Evans */ 1234b1aa58bSBruce Evans 1244b1aa58bSBruce Evans #define PROC_ACTION(action) do { \ 1257c629906SDag-Erling Smørgrav int error; \ 1267c629906SDag-Erling Smørgrav \ 127eeec6babSJohn Baldwin PROC_LOCK_ASSERT(td->td_proc, MA_OWNED); \ 128b61ce5b0SJeff Roberson if ((td->td_proc->p_flag & P_INMEM) == 0) \ 1294b1aa58bSBruce Evans error = EIO; \ 1304b1aa58bSBruce Evans else \ 1314b1aa58bSBruce Evans error = (action); \ 1327c629906SDag-Erling Smørgrav return (error); \ 1334b1aa58bSBruce Evans } while(0) 1344b1aa58bSBruce Evans 1354b1aa58bSBruce Evans int 1364b1aa58bSBruce Evans proc_read_regs(struct thread *td, struct reg *regs) 1374b1aa58bSBruce Evans { 1384b1aa58bSBruce Evans 1394b1aa58bSBruce Evans PROC_ACTION(fill_regs(td, regs)); 1407c629906SDag-Erling Smørgrav } 1417c629906SDag-Erling Smørgrav 1424b1aa58bSBruce Evans int 1434b1aa58bSBruce Evans proc_write_regs(struct thread *td, struct reg *regs) 1444b1aa58bSBruce Evans { 1454b1aa58bSBruce Evans 1464b1aa58bSBruce Evans PROC_ACTION(set_regs(td, regs)); 1474b1aa58bSBruce Evans } 1484b1aa58bSBruce Evans 1494b1aa58bSBruce Evans int 1504b1aa58bSBruce Evans proc_read_dbregs(struct thread *td, struct dbreg *dbregs) 1514b1aa58bSBruce Evans { 1524b1aa58bSBruce Evans 1534b1aa58bSBruce Evans PROC_ACTION(fill_dbregs(td, dbregs)); 1544b1aa58bSBruce Evans } 1554b1aa58bSBruce Evans 1564b1aa58bSBruce Evans int 1574b1aa58bSBruce Evans proc_write_dbregs(struct thread *td, struct dbreg *dbregs) 1584b1aa58bSBruce Evans { 1594b1aa58bSBruce Evans 1604b1aa58bSBruce Evans PROC_ACTION(set_dbregs(td, dbregs)); 1614b1aa58bSBruce Evans } 1624b1aa58bSBruce Evans 1634b1aa58bSBruce Evans /* 1644b1aa58bSBruce Evans * Ptrace doesn't support fpregs at all, and there are no security holes 1654b1aa58bSBruce Evans * or translations for fpregs, so we can just copy them. 1664b1aa58bSBruce Evans */ 1674b1aa58bSBruce Evans int 1684b1aa58bSBruce Evans proc_read_fpregs(struct thread *td, struct fpreg *fpregs) 1694b1aa58bSBruce Evans { 1704b1aa58bSBruce Evans 1714b1aa58bSBruce Evans PROC_ACTION(fill_fpregs(td, fpregs)); 1724b1aa58bSBruce Evans } 1734b1aa58bSBruce Evans 1744b1aa58bSBruce Evans int 1754b1aa58bSBruce Evans proc_write_fpregs(struct thread *td, struct fpreg *fpregs) 1764b1aa58bSBruce Evans { 1774b1aa58bSBruce Evans 1784b1aa58bSBruce Evans PROC_ACTION(set_fpregs(td, fpregs)); 1794b1aa58bSBruce Evans } 1807c629906SDag-Erling Smørgrav 181841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 18262919d78SPeter Wemm /* For 32 bit binaries, we need to expose the 32 bit regs layouts. */ 18362919d78SPeter Wemm int 18462919d78SPeter Wemm proc_read_regs32(struct thread *td, struct reg32 *regs32) 18562919d78SPeter Wemm { 18662919d78SPeter Wemm 18762919d78SPeter Wemm PROC_ACTION(fill_regs32(td, regs32)); 18862919d78SPeter Wemm } 18962919d78SPeter Wemm 19062919d78SPeter Wemm int 19162919d78SPeter Wemm proc_write_regs32(struct thread *td, struct reg32 *regs32) 19262919d78SPeter Wemm { 19362919d78SPeter Wemm 19462919d78SPeter Wemm PROC_ACTION(set_regs32(td, regs32)); 19562919d78SPeter Wemm } 19662919d78SPeter Wemm 19762919d78SPeter Wemm int 19862919d78SPeter Wemm proc_read_dbregs32(struct thread *td, struct dbreg32 *dbregs32) 19962919d78SPeter Wemm { 20062919d78SPeter Wemm 20162919d78SPeter Wemm PROC_ACTION(fill_dbregs32(td, dbregs32)); 20262919d78SPeter Wemm } 20362919d78SPeter Wemm 20462919d78SPeter Wemm int 20562919d78SPeter Wemm proc_write_dbregs32(struct thread *td, struct dbreg32 *dbregs32) 20662919d78SPeter Wemm { 20762919d78SPeter Wemm 20862919d78SPeter Wemm PROC_ACTION(set_dbregs32(td, dbregs32)); 20962919d78SPeter Wemm } 21062919d78SPeter Wemm 21162919d78SPeter Wemm int 21262919d78SPeter Wemm proc_read_fpregs32(struct thread *td, struct fpreg32 *fpregs32) 21362919d78SPeter Wemm { 21462919d78SPeter Wemm 21562919d78SPeter Wemm PROC_ACTION(fill_fpregs32(td, fpregs32)); 21662919d78SPeter Wemm } 21762919d78SPeter Wemm 21862919d78SPeter Wemm int 21962919d78SPeter Wemm proc_write_fpregs32(struct thread *td, struct fpreg32 *fpregs32) 22062919d78SPeter Wemm { 22162919d78SPeter Wemm 22262919d78SPeter Wemm PROC_ACTION(set_fpregs32(td, fpregs32)); 22362919d78SPeter Wemm } 22462919d78SPeter Wemm #endif 22562919d78SPeter Wemm 2267c629906SDag-Erling Smørgrav int 2277c629906SDag-Erling Smørgrav proc_sstep(struct thread *td) 2287c629906SDag-Erling Smørgrav { 2297c629906SDag-Erling Smørgrav 2304b1aa58bSBruce Evans PROC_ACTION(ptrace_single_step(td)); 2317c629906SDag-Erling Smørgrav } 2327c629906SDag-Erling Smørgrav 2333da32491SDag-Erling Smørgrav int 2343da32491SDag-Erling Smørgrav proc_rwmem(struct proc *p, struct uio *uio) 23550f74e92SDag-Erling Smørgrav { 2363da32491SDag-Erling Smørgrav vm_map_t map; 237a6d42a0dSAlan Cox vm_offset_t pageno; /* page number */ 2383da32491SDag-Erling Smørgrav vm_prot_t reqprot; 239acd11c74SAlan Cox int error, fault_flags, page_offset, writing; 2404e68ceabSDavid Greenman 2414e68ceabSDavid Greenman /* 24206ad42b2SJohn Baldwin * Assert that someone has locked this vmspace. (Should be 24306ad42b2SJohn Baldwin * curthread but we can't assert that.) This keeps the process 24406ad42b2SJohn Baldwin * from exiting out from under us until this operation completes. 2454e68ceabSDavid Greenman */ 246d2871337SMark Johnston PROC_ASSERT_HELD(p); 247711fbd17SMark Johnston PROC_LOCK_ASSERT(p, MA_NOTOWNED); 2481a276a3fSAlan Cox 2493da32491SDag-Erling Smørgrav /* 2503da32491SDag-Erling Smørgrav * The map we want... 2513da32491SDag-Erling Smørgrav */ 25206ad42b2SJohn Baldwin map = &p->p_vmspace->vm_map; 2534e68ceabSDavid Greenman 254acd11c74SAlan Cox /* 255acd11c74SAlan Cox * If we are writing, then we request vm_fault() to create a private 256acd11c74SAlan Cox * copy of each page. Since these copies will not be writeable by the 257acd11c74SAlan Cox * process, we must explicity request that they be dirtied. 258acd11c74SAlan Cox */ 2593da32491SDag-Erling Smørgrav writing = uio->uio_rw == UIO_WRITE; 260a6d42a0dSAlan Cox reqprot = writing ? VM_PROT_COPY | VM_PROT_READ : VM_PROT_READ; 261acd11c74SAlan Cox fault_flags = writing ? VM_FAULT_DIRTY : VM_FAULT_NORMAL; 2623da32491SDag-Erling Smørgrav 2633da32491SDag-Erling Smørgrav /* 2643da32491SDag-Erling Smørgrav * Only map in one page at a time. We don't have to, but it 2653da32491SDag-Erling Smørgrav * makes things easier. This way is trivial - right? 2663da32491SDag-Erling Smørgrav */ 2673da32491SDag-Erling Smørgrav do { 2683da32491SDag-Erling Smørgrav vm_offset_t uva; 2693da32491SDag-Erling Smørgrav u_int len; 2703da32491SDag-Erling Smørgrav vm_page_t m; 2713da32491SDag-Erling Smørgrav 2723da32491SDag-Erling Smørgrav uva = (vm_offset_t)uio->uio_offset; 2733da32491SDag-Erling Smørgrav 2743da32491SDag-Erling Smørgrav /* 2753da32491SDag-Erling Smørgrav * Get the page number of this segment. 2763da32491SDag-Erling Smørgrav */ 2773da32491SDag-Erling Smørgrav pageno = trunc_page(uva); 2783da32491SDag-Erling Smørgrav page_offset = uva - pageno; 2793da32491SDag-Erling Smørgrav 2803da32491SDag-Erling Smørgrav /* 2813da32491SDag-Erling Smørgrav * How many bytes to copy 2823da32491SDag-Erling Smørgrav */ 2833da32491SDag-Erling Smørgrav len = min(PAGE_SIZE - page_offset, uio->uio_resid); 2843da32491SDag-Erling Smørgrav 2853da32491SDag-Erling Smørgrav /* 286be996836SAttilio Rao * Fault and hold the page on behalf of the process. 2873da32491SDag-Erling Smørgrav */ 288be996836SAttilio Rao error = vm_fault_hold(map, pageno, reqprot, fault_flags, &m); 289acd11c74SAlan Cox if (error != KERN_SUCCESS) { 2903364c323SKonstantin Belousov if (error == KERN_RESOURCE_SHORTAGE) 2913364c323SKonstantin Belousov error = ENOMEM; 2923364c323SKonstantin Belousov else 2933da32491SDag-Erling Smørgrav error = EFAULT; 2943da32491SDag-Erling Smørgrav break; 2953da32491SDag-Erling Smørgrav } 2963da32491SDag-Erling Smørgrav 2973da32491SDag-Erling Smørgrav /* 2983da32491SDag-Erling Smørgrav * Now do the i/o move. 2993da32491SDag-Erling Smørgrav */ 3002b63e7f3SAlan Cox error = uiomove_fromphys(&m, page_offset, len, uio); 3013da32491SDag-Erling Smørgrav 3021a4fcaebSMarcel Moolenaar /* Make the I-cache coherent for breakpoints. */ 303acd11c74SAlan Cox if (writing && error == 0) { 304acd11c74SAlan Cox vm_map_lock_read(map); 305acd11c74SAlan Cox if (vm_map_check_protection(map, pageno, pageno + 306acd11c74SAlan Cox PAGE_SIZE, VM_PROT_EXECUTE)) 3071a4fcaebSMarcel Moolenaar vm_sync_icache(map, uva, len); 308acd11c74SAlan Cox vm_map_unlock_read(map); 309acd11c74SAlan Cox } 3101a4fcaebSMarcel Moolenaar 3113da32491SDag-Erling Smørgrav /* 312c6eb850aSAlan Cox * Release the page. 3133da32491SDag-Erling Smørgrav */ 314be996836SAttilio Rao vm_page_lock(m); 315eeacb3b0SMark Johnston if (vm_page_unwire(m, PQ_ACTIVE) && m->object == NULL) 316eeacb3b0SMark Johnston vm_page_free(m); 317be996836SAttilio Rao vm_page_unlock(m); 3183da32491SDag-Erling Smørgrav 3193da32491SDag-Erling Smørgrav } while (error == 0 && uio->uio_resid > 0); 3203da32491SDag-Erling Smørgrav 3213da32491SDag-Erling Smørgrav return (error); 3224e68ceabSDavid Greenman } 3234e68ceabSDavid Greenman 324711fbd17SMark Johnston static ssize_t 325711fbd17SMark Johnston proc_iop(struct thread *td, struct proc *p, vm_offset_t va, void *buf, 326711fbd17SMark Johnston size_t len, enum uio_rw rw) 327711fbd17SMark Johnston { 328711fbd17SMark Johnston struct iovec iov; 329711fbd17SMark Johnston struct uio uio; 330711fbd17SMark Johnston ssize_t slen; 331711fbd17SMark Johnston 332711fbd17SMark Johnston MPASS(len < SSIZE_MAX); 333711fbd17SMark Johnston slen = (ssize_t)len; 334711fbd17SMark Johnston 335711fbd17SMark Johnston iov.iov_base = (caddr_t)buf; 336711fbd17SMark Johnston iov.iov_len = len; 337711fbd17SMark Johnston uio.uio_iov = &iov; 338711fbd17SMark Johnston uio.uio_iovcnt = 1; 339711fbd17SMark Johnston uio.uio_offset = va; 340711fbd17SMark Johnston uio.uio_resid = slen; 341711fbd17SMark Johnston uio.uio_segflg = UIO_SYSSPACE; 342711fbd17SMark Johnston uio.uio_rw = rw; 343711fbd17SMark Johnston uio.uio_td = td; 344ac8b2d5cSMatt Macy proc_rwmem(p, &uio); 345711fbd17SMark Johnston if (uio.uio_resid == slen) 346711fbd17SMark Johnston return (-1); 347711fbd17SMark Johnston return (slen - uio.uio_resid); 348711fbd17SMark Johnston } 349711fbd17SMark Johnston 350711fbd17SMark Johnston ssize_t 351711fbd17SMark Johnston proc_readmem(struct thread *td, struct proc *p, vm_offset_t va, void *buf, 352711fbd17SMark Johnston size_t len) 353711fbd17SMark Johnston { 354711fbd17SMark Johnston 355711fbd17SMark Johnston return (proc_iop(td, p, va, buf, len, UIO_READ)); 356711fbd17SMark Johnston } 357711fbd17SMark Johnston 358711fbd17SMark Johnston ssize_t 359711fbd17SMark Johnston proc_writemem(struct thread *td, struct proc *p, vm_offset_t va, void *buf, 360711fbd17SMark Johnston size_t len) 361711fbd17SMark Johnston { 362711fbd17SMark Johnston 363711fbd17SMark Johnston return (proc_iop(td, p, va, buf, len, UIO_WRITE)); 364711fbd17SMark Johnston } 365711fbd17SMark Johnston 36690b4621aSMarcel Moolenaar static int 36790b4621aSMarcel Moolenaar ptrace_vm_entry(struct thread *td, struct proc *p, struct ptrace_vm_entry *pve) 36890b4621aSMarcel Moolenaar { 36916211027SMarcel Moolenaar struct vattr vattr; 37090b4621aSMarcel Moolenaar vm_map_t map; 37190b4621aSMarcel Moolenaar vm_map_entry_t entry; 37290b4621aSMarcel Moolenaar vm_object_t obj, tobj, lobj; 37316211027SMarcel Moolenaar struct vmspace *vm; 37490b4621aSMarcel Moolenaar struct vnode *vp; 37590b4621aSMarcel Moolenaar char *freepath, *fullpath; 37690b4621aSMarcel Moolenaar u_int pathlen; 3775050aa86SKonstantin Belousov int error, index; 37890b4621aSMarcel Moolenaar 37916211027SMarcel Moolenaar error = 0; 38016211027SMarcel Moolenaar obj = NULL; 38116211027SMarcel Moolenaar 38216211027SMarcel Moolenaar vm = vmspace_acquire_ref(p); 38316211027SMarcel Moolenaar map = &vm->vm_map; 38416211027SMarcel Moolenaar vm_map_lock_read(map); 38516211027SMarcel Moolenaar 38616211027SMarcel Moolenaar do { 38790b4621aSMarcel Moolenaar entry = map->header.next; 38816211027SMarcel Moolenaar index = 0; 38916211027SMarcel Moolenaar while (index < pve->pve_entry && entry != &map->header) { 39090b4621aSMarcel Moolenaar entry = entry->next; 39116211027SMarcel Moolenaar index++; 39290b4621aSMarcel Moolenaar } 39316211027SMarcel Moolenaar if (index != pve->pve_entry) { 39416211027SMarcel Moolenaar error = EINVAL; 39516211027SMarcel Moolenaar break; 39616211027SMarcel Moolenaar } 3972203c46dSMark Johnston KASSERT((map->header.eflags & MAP_ENTRY_IS_SUB_MAP) == 0, 3982203c46dSMark Johnston ("Submap in map header")); 3992203c46dSMark Johnston while ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) != 0) { 40090b4621aSMarcel Moolenaar entry = entry->next; 40116211027SMarcel Moolenaar index++; 40216211027SMarcel Moolenaar } 40316211027SMarcel Moolenaar if (entry == &map->header) { 40416211027SMarcel Moolenaar error = ENOENT; 40516211027SMarcel Moolenaar break; 40616211027SMarcel Moolenaar } 40790b4621aSMarcel Moolenaar 40890b4621aSMarcel Moolenaar /* We got an entry. */ 40916211027SMarcel Moolenaar pve->pve_entry = index + 1; 41016211027SMarcel Moolenaar pve->pve_timestamp = map->timestamp; 41190b4621aSMarcel Moolenaar pve->pve_start = entry->start; 41290b4621aSMarcel Moolenaar pve->pve_end = entry->end - 1; 41390b4621aSMarcel Moolenaar pve->pve_offset = entry->offset; 41490b4621aSMarcel Moolenaar pve->pve_prot = entry->protection; 41590b4621aSMarcel Moolenaar 41690b4621aSMarcel Moolenaar /* Backing object's path needed? */ 41790b4621aSMarcel Moolenaar if (pve->pve_pathlen == 0) 41816211027SMarcel Moolenaar break; 41990b4621aSMarcel Moolenaar 42090b4621aSMarcel Moolenaar pathlen = pve->pve_pathlen; 42190b4621aSMarcel Moolenaar pve->pve_pathlen = 0; 42290b4621aSMarcel Moolenaar 42390b4621aSMarcel Moolenaar obj = entry->object.vm_object; 42416211027SMarcel Moolenaar if (obj != NULL) 425bc403f03SAttilio Rao VM_OBJECT_RLOCK(obj); 42616211027SMarcel Moolenaar } while (0); 42716211027SMarcel Moolenaar 42816211027SMarcel Moolenaar vm_map_unlock_read(map); 42916211027SMarcel Moolenaar 430af002ab8SMarcel Moolenaar pve->pve_fsid = VNOVAL; 431af002ab8SMarcel Moolenaar pve->pve_fileid = VNOVAL; 432af002ab8SMarcel Moolenaar 43316211027SMarcel Moolenaar if (error == 0 && obj != NULL) { 43416211027SMarcel Moolenaar lobj = obj; 43516211027SMarcel Moolenaar for (tobj = obj; tobj != NULL; tobj = tobj->backing_object) { 43690b4621aSMarcel Moolenaar if (tobj != obj) 437bc403f03SAttilio Rao VM_OBJECT_RLOCK(tobj); 43890b4621aSMarcel Moolenaar if (lobj != obj) 439bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(lobj); 44090b4621aSMarcel Moolenaar lobj = tobj; 44190b4621aSMarcel Moolenaar pve->pve_offset += tobj->backing_object_offset; 44290b4621aSMarcel Moolenaar } 44363e4c6cdSEric van Gyzen vp = vm_object_vnode(lobj); 44490b4621aSMarcel Moolenaar if (vp != NULL) 44590b4621aSMarcel Moolenaar vref(vp); 44690b4621aSMarcel Moolenaar if (lobj != obj) 447bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(lobj); 448bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(obj); 44990b4621aSMarcel Moolenaar 45016211027SMarcel Moolenaar if (vp != NULL) { 45190b4621aSMarcel Moolenaar freepath = NULL; 45290b4621aSMarcel Moolenaar fullpath = NULL; 45390b4621aSMarcel Moolenaar vn_fullpath(td, vp, &fullpath, &freepath); 45416211027SMarcel Moolenaar vn_lock(vp, LK_SHARED | LK_RETRY); 45516211027SMarcel Moolenaar if (VOP_GETATTR(vp, &vattr, td->td_ucred) == 0) { 45616211027SMarcel Moolenaar pve->pve_fileid = vattr.va_fileid; 45716211027SMarcel Moolenaar pve->pve_fsid = vattr.va_fsid; 45816211027SMarcel Moolenaar } 45916211027SMarcel Moolenaar vput(vp); 46090b4621aSMarcel Moolenaar 46190b4621aSMarcel Moolenaar if (fullpath != NULL) { 46290b4621aSMarcel Moolenaar pve->pve_pathlen = strlen(fullpath) + 1; 46390b4621aSMarcel Moolenaar if (pve->pve_pathlen <= pathlen) { 46490b4621aSMarcel Moolenaar error = copyout(fullpath, pve->pve_path, 46590b4621aSMarcel Moolenaar pve->pve_pathlen); 46690b4621aSMarcel Moolenaar } else 46790b4621aSMarcel Moolenaar error = ENAMETOOLONG; 46890b4621aSMarcel Moolenaar } 46990b4621aSMarcel Moolenaar if (freepath != NULL) 47090b4621aSMarcel Moolenaar free(freepath, M_TEMP); 47116211027SMarcel Moolenaar } 47216211027SMarcel Moolenaar } 473f470cca5SKonstantin Belousov vmspace_free(vm); 474515b7a0bSJohn Baldwin if (error == 0) 475515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_VM_ENTRY: pid %d, entry %d, start %p", 476515b7a0bSJohn Baldwin p->p_pid, pve->pve_entry, pve->pve_start); 47716211027SMarcel Moolenaar 47890b4621aSMarcel Moolenaar return (error); 47990b4621aSMarcel Moolenaar } 48090b4621aSMarcel Moolenaar 481841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 48216211027SMarcel Moolenaar static int 48316211027SMarcel Moolenaar ptrace_vm_entry32(struct thread *td, struct proc *p, 48416211027SMarcel Moolenaar struct ptrace_vm_entry32 *pve32) 48516211027SMarcel Moolenaar { 48616211027SMarcel Moolenaar struct ptrace_vm_entry pve; 48716211027SMarcel Moolenaar int error; 48816211027SMarcel Moolenaar 48916211027SMarcel Moolenaar pve.pve_entry = pve32->pve_entry; 49016211027SMarcel Moolenaar pve.pve_pathlen = pve32->pve_pathlen; 49116211027SMarcel Moolenaar pve.pve_path = (void *)(uintptr_t)pve32->pve_path; 49216211027SMarcel Moolenaar 49316211027SMarcel Moolenaar error = ptrace_vm_entry(td, p, &pve); 49416211027SMarcel Moolenaar if (error == 0) { 49516211027SMarcel Moolenaar pve32->pve_entry = pve.pve_entry; 49616211027SMarcel Moolenaar pve32->pve_timestamp = pve.pve_timestamp; 49716211027SMarcel Moolenaar pve32->pve_start = pve.pve_start; 49816211027SMarcel Moolenaar pve32->pve_end = pve.pve_end; 49916211027SMarcel Moolenaar pve32->pve_offset = pve.pve_offset; 50016211027SMarcel Moolenaar pve32->pve_prot = pve.pve_prot; 50116211027SMarcel Moolenaar pve32->pve_fileid = pve.pve_fileid; 50216211027SMarcel Moolenaar pve32->pve_fsid = pve.pve_fsid; 50316211027SMarcel Moolenaar } 50416211027SMarcel Moolenaar 50516211027SMarcel Moolenaar pve32->pve_pathlen = pve.pve_pathlen; 50616211027SMarcel Moolenaar return (error); 50716211027SMarcel Moolenaar } 5088a260079SKonstantin Belousov 5098a260079SKonstantin Belousov static void 5108a260079SKonstantin Belousov ptrace_lwpinfo_to32(const struct ptrace_lwpinfo *pl, 5118a260079SKonstantin Belousov struct ptrace_lwpinfo32 *pl32) 5128a260079SKonstantin Belousov { 5138a260079SKonstantin Belousov 5149acf7b13SKonstantin Belousov bzero(pl32, sizeof(*pl32)); 5158a260079SKonstantin Belousov pl32->pl_lwpid = pl->pl_lwpid; 5168a260079SKonstantin Belousov pl32->pl_event = pl->pl_event; 5178a260079SKonstantin Belousov pl32->pl_flags = pl->pl_flags; 5188a260079SKonstantin Belousov pl32->pl_sigmask = pl->pl_sigmask; 5198a260079SKonstantin Belousov pl32->pl_siglist = pl->pl_siglist; 5208a260079SKonstantin Belousov siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo); 5217f08176eSAttilio Rao strcpy(pl32->pl_tdname, pl->pl_tdname); 5226fa39a73SKonstantin Belousov pl32->pl_child_pid = pl->pl_child_pid; 523183b68f7SJohn Baldwin pl32->pl_syscall_code = pl->pl_syscall_code; 524183b68f7SJohn Baldwin pl32->pl_syscall_narg = pl->pl_syscall_narg; 5258a260079SKonstantin Belousov } 526*32451fb9SJohn Baldwin 527*32451fb9SJohn Baldwin static void 528*32451fb9SJohn Baldwin ptrace_sc_ret_to32(const struct ptrace_sc_ret *psr, 529*32451fb9SJohn Baldwin struct ptrace_sc_ret32 *psr32) 530*32451fb9SJohn Baldwin { 531*32451fb9SJohn Baldwin 532*32451fb9SJohn Baldwin bzero(psr32, sizeof(*psr32)); 533*32451fb9SJohn Baldwin psr32->sr_retval[0] = psr->sr_retval[0]; 534*32451fb9SJohn Baldwin psr32->sr_retval[1] = psr->sr_retval[1]; 535*32451fb9SJohn Baldwin psr32->sr_error = psr->sr_error; 536*32451fb9SJohn Baldwin } 537841c0c7eSNathan Whitehorn #endif /* COMPAT_FREEBSD32 */ 53816211027SMarcel Moolenaar 539df8bae1dSRodney W. Grimes /* 540df8bae1dSRodney W. Grimes * Process debugging system call. 541df8bae1dSRodney W. Grimes */ 542d2d3e875SBruce Evans #ifndef _SYS_SYSPROTO_H_ 543df8bae1dSRodney W. Grimes struct ptrace_args { 544df8bae1dSRodney W. Grimes int req; 545df8bae1dSRodney W. Grimes pid_t pid; 546df8bae1dSRodney W. Grimes caddr_t addr; 547df8bae1dSRodney W. Grimes int data; 548df8bae1dSRodney W. Grimes }; 549d2d3e875SBruce Evans #endif 550df8bae1dSRodney W. Grimes 551841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 55262919d78SPeter Wemm /* 55362919d78SPeter Wemm * This CPP subterfuge is to try and reduce the number of ifdefs in 55462919d78SPeter Wemm * the body of the code. 55562919d78SPeter Wemm * COPYIN(uap->addr, &r.reg, sizeof r.reg); 55662919d78SPeter Wemm * becomes either: 55762919d78SPeter Wemm * copyin(uap->addr, &r.reg, sizeof r.reg); 55862919d78SPeter Wemm * or 55962919d78SPeter Wemm * copyin(uap->addr, &r.reg32, sizeof r.reg32); 56062919d78SPeter Wemm * .. except this is done at runtime. 56162919d78SPeter Wemm */ 562352aaa51SMark Johnston #define BZERO(a, s) wrap32 ? \ 563352aaa51SMark Johnston bzero(a ## 32, s ## 32) : \ 564352aaa51SMark Johnston bzero(a, s) 56562919d78SPeter Wemm #define COPYIN(u, k, s) wrap32 ? \ 56662919d78SPeter Wemm copyin(u, k ## 32, s ## 32) : \ 56762919d78SPeter Wemm copyin(u, k, s) 56862919d78SPeter Wemm #define COPYOUT(k, u, s) wrap32 ? \ 56962919d78SPeter Wemm copyout(k ## 32, u, s ## 32) : \ 57062919d78SPeter Wemm copyout(k, u, s) 57162919d78SPeter Wemm #else 57202164d36SMark Johnston #define BZERO(a, s) bzero(a, s) 57362919d78SPeter Wemm #define COPYIN(u, k, s) copyin(u, k, s) 57462919d78SPeter Wemm #define COPYOUT(k, u, s) copyout(k, u, s) 57562919d78SPeter Wemm #endif 5764e68ceabSDavid Greenman int 5778451d0ddSKip Macy sys_ptrace(struct thread *td, struct ptrace_args *uap) 5784e68ceabSDavid Greenman { 57919610b66SBruce Evans /* 58019610b66SBruce Evans * XXX this obfuscation is to reduce stack usage, but the register 58119610b66SBruce Evans * structs may be too large to put on the stack anyway. 58219610b66SBruce Evans */ 5833da32491SDag-Erling Smørgrav union { 5848bc814e6SDag-Erling Smørgrav struct ptrace_io_desc piod; 585fbc3247dSMarcel Moolenaar struct ptrace_lwpinfo pl; 58690b4621aSMarcel Moolenaar struct ptrace_vm_entry pve; 5873da32491SDag-Erling Smørgrav struct dbreg dbreg; 5883da32491SDag-Erling Smørgrav struct fpreg fpreg; 58919610b66SBruce Evans struct reg reg; 590841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 59162919d78SPeter Wemm struct dbreg32 dbreg32; 59262919d78SPeter Wemm struct fpreg32 fpreg32; 59362919d78SPeter Wemm struct reg32 reg32; 59462919d78SPeter Wemm struct ptrace_io_desc32 piod32; 5958a260079SKonstantin Belousov struct ptrace_lwpinfo32 pl32; 5968a25c0c7SMarcel Moolenaar struct ptrace_vm_entry32 pve32; 59762919d78SPeter Wemm #endif 598352aaa51SMark Johnston char args[sizeof(td->td_sa.args)]; 599*32451fb9SJohn Baldwin struct ptrace_sc_ret psr; 6008d570f64SJohn Baldwin int ptevents; 6013da32491SDag-Erling Smørgrav } r; 602012e544fSIan Dowse void *addr; 603012e544fSIan Dowse int error = 0; 604841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 60562919d78SPeter Wemm int wrap32 = 0; 606012e544fSIan Dowse 6072883703eSKonstantin Belousov if (SV_CURPROC_FLAG(SV_ILP32)) 60862919d78SPeter Wemm wrap32 = 1; 60962919d78SPeter Wemm #endif 61014961ba7SRobert Watson AUDIT_ARG_PID(uap->pid); 61114961ba7SRobert Watson AUDIT_ARG_CMD(uap->req); 61214961ba7SRobert Watson AUDIT_ARG_VALUE(uap->data); 613012e544fSIan Dowse addr = &r; 614012e544fSIan Dowse switch (uap->req) { 6158d570f64SJohn Baldwin case PT_GET_EVENT_MASK: 616fbc3247dSMarcel Moolenaar case PT_LWPINFO: 617b43ce76cSKonstantin Belousov case PT_GET_SC_ARGS: 618*32451fb9SJohn Baldwin case PT_GET_SC_RET: 619012e544fSIan Dowse break; 620352aaa51SMark Johnston case PT_GETREGS: 621352aaa51SMark Johnston BZERO(&r.reg, sizeof r.reg); 622352aaa51SMark Johnston break; 623352aaa51SMark Johnston case PT_GETFPREGS: 624352aaa51SMark Johnston BZERO(&r.fpreg, sizeof r.fpreg); 625352aaa51SMark Johnston break; 626352aaa51SMark Johnston case PT_GETDBREGS: 627352aaa51SMark Johnston BZERO(&r.dbreg, sizeof r.dbreg); 628352aaa51SMark Johnston break; 629012e544fSIan Dowse case PT_SETREGS: 63062919d78SPeter Wemm error = COPYIN(uap->addr, &r.reg, sizeof r.reg); 631012e544fSIan Dowse break; 632012e544fSIan Dowse case PT_SETFPREGS: 63362919d78SPeter Wemm error = COPYIN(uap->addr, &r.fpreg, sizeof r.fpreg); 634012e544fSIan Dowse break; 635012e544fSIan Dowse case PT_SETDBREGS: 63662919d78SPeter Wemm error = COPYIN(uap->addr, &r.dbreg, sizeof r.dbreg); 637012e544fSIan Dowse break; 6388d570f64SJohn Baldwin case PT_SET_EVENT_MASK: 6398d570f64SJohn Baldwin if (uap->data != sizeof(r.ptevents)) 6408d570f64SJohn Baldwin error = EINVAL; 6418d570f64SJohn Baldwin else 6428d570f64SJohn Baldwin error = copyin(uap->addr, &r.ptevents, uap->data); 6438d570f64SJohn Baldwin break; 644012e544fSIan Dowse case PT_IO: 64562919d78SPeter Wemm error = COPYIN(uap->addr, &r.piod, sizeof r.piod); 646012e544fSIan Dowse break; 64790b4621aSMarcel Moolenaar case PT_VM_ENTRY: 64890b4621aSMarcel Moolenaar error = COPYIN(uap->addr, &r.pve, sizeof r.pve); 64990b4621aSMarcel Moolenaar break; 650012e544fSIan Dowse default: 651012e544fSIan Dowse addr = uap->addr; 6521c843354SMarcel Moolenaar break; 653012e544fSIan Dowse } 654012e544fSIan Dowse if (error) 655012e544fSIan Dowse return (error); 656012e544fSIan Dowse 657012e544fSIan Dowse error = kern_ptrace(td, uap->req, uap->pid, addr, uap->data); 658012e544fSIan Dowse if (error) 659012e544fSIan Dowse return (error); 660012e544fSIan Dowse 661012e544fSIan Dowse switch (uap->req) { 66290b4621aSMarcel Moolenaar case PT_VM_ENTRY: 66390b4621aSMarcel Moolenaar error = COPYOUT(&r.pve, uap->addr, sizeof r.pve); 66490b4621aSMarcel Moolenaar break; 665012e544fSIan Dowse case PT_IO: 66662919d78SPeter Wemm error = COPYOUT(&r.piod, uap->addr, sizeof r.piod); 667012e544fSIan Dowse break; 668012e544fSIan Dowse case PT_GETREGS: 66962919d78SPeter Wemm error = COPYOUT(&r.reg, uap->addr, sizeof r.reg); 670012e544fSIan Dowse break; 671012e544fSIan Dowse case PT_GETFPREGS: 67262919d78SPeter Wemm error = COPYOUT(&r.fpreg, uap->addr, sizeof r.fpreg); 673012e544fSIan Dowse break; 674012e544fSIan Dowse case PT_GETDBREGS: 67562919d78SPeter Wemm error = COPYOUT(&r.dbreg, uap->addr, sizeof r.dbreg); 676012e544fSIan Dowse break; 6778d570f64SJohn Baldwin case PT_GET_EVENT_MASK: 6788d570f64SJohn Baldwin /* NB: The size in uap->data is validated in kern_ptrace(). */ 6798d570f64SJohn Baldwin error = copyout(&r.ptevents, uap->addr, uap->data); 6808d570f64SJohn Baldwin break; 681fbc3247dSMarcel Moolenaar case PT_LWPINFO: 6828d570f64SJohn Baldwin /* NB: The size in uap->data is validated in kern_ptrace(). */ 683fbc3247dSMarcel Moolenaar error = copyout(&r.pl, uap->addr, uap->data); 684fbc3247dSMarcel Moolenaar break; 685b43ce76cSKonstantin Belousov case PT_GET_SC_ARGS: 686b43ce76cSKonstantin Belousov error = copyout(r.args, uap->addr, MIN(uap->data, 687b43ce76cSKonstantin Belousov sizeof(r.args))); 688b43ce76cSKonstantin Belousov break; 689*32451fb9SJohn Baldwin case PT_GET_SC_RET: 690*32451fb9SJohn Baldwin error = copyout(&r.psr, uap->addr, MIN(uap->data, 691*32451fb9SJohn Baldwin sizeof(r.psr))); 692*32451fb9SJohn Baldwin break; 693012e544fSIan Dowse } 694012e544fSIan Dowse 695012e544fSIan Dowse return (error); 696012e544fSIan Dowse } 69762919d78SPeter Wemm #undef COPYIN 69862919d78SPeter Wemm #undef COPYOUT 699352aaa51SMark Johnston #undef BZERO 70062919d78SPeter Wemm 701841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 70262919d78SPeter Wemm /* 70362919d78SPeter Wemm * PROC_READ(regs, td2, addr); 70462919d78SPeter Wemm * becomes either: 70562919d78SPeter Wemm * proc_read_regs(td2, addr); 70662919d78SPeter Wemm * or 70762919d78SPeter Wemm * proc_read_regs32(td2, addr); 70862919d78SPeter Wemm * .. except this is done at runtime. There is an additional 70962919d78SPeter Wemm * complication in that PROC_WRITE disallows 32 bit consumers 71062919d78SPeter Wemm * from writing to 64 bit address space targets. 71162919d78SPeter Wemm */ 71262919d78SPeter Wemm #define PROC_READ(w, t, a) wrap32 ? \ 71362919d78SPeter Wemm proc_read_ ## w ## 32(t, a) : \ 71462919d78SPeter Wemm proc_read_ ## w (t, a) 71562919d78SPeter Wemm #define PROC_WRITE(w, t, a) wrap32 ? \ 71662919d78SPeter Wemm (safe ? proc_write_ ## w ## 32(t, a) : EINVAL ) : \ 71762919d78SPeter Wemm proc_write_ ## w (t, a) 71862919d78SPeter Wemm #else 71962919d78SPeter Wemm #define PROC_READ(w, t, a) proc_read_ ## w (t, a) 72062919d78SPeter Wemm #define PROC_WRITE(w, t, a) proc_write_ ## w (t, a) 72162919d78SPeter Wemm #endif 722012e544fSIan Dowse 723b7a25e63SKonstantin Belousov void 724e5574e09SMark Johnston proc_set_traced(struct proc *p, bool stop) 725b7a25e63SKonstantin Belousov { 726b7a25e63SKonstantin Belousov 727ac4bc0c1SKonstantin Belousov sx_assert(&proctree_lock, SX_XLOCKED); 728b7a25e63SKonstantin Belousov PROC_LOCK_ASSERT(p, MA_OWNED); 729b7a25e63SKonstantin Belousov p->p_flag |= P_TRACED; 730e5574e09SMark Johnston if (stop) 731b7a25e63SKonstantin Belousov p->p_flag2 |= P2_PTRACE_FSTP; 732b7a25e63SKonstantin Belousov p->p_ptevents = PTRACE_DEFAULT; 733b7a25e63SKonstantin Belousov } 734b7a25e63SKonstantin Belousov 735012e544fSIan Dowse int 736012e544fSIan Dowse kern_ptrace(struct thread *td, int req, pid_t pid, void *addr, int data) 737012e544fSIan Dowse { 738012e544fSIan Dowse struct iovec iov; 739012e544fSIan Dowse struct uio uio; 74046e12b42SAlfred Perlstein struct proc *curp, *p, *pp; 7415985d615SDavid Xu struct thread *td2 = NULL, *td3; 74262919d78SPeter Wemm struct ptrace_io_desc *piod = NULL; 743fbc3247dSMarcel Moolenaar struct ptrace_lwpinfo *pl; 744*32451fb9SJohn Baldwin struct ptrace_sc_ret *psr; 745711fbd17SMark Johnston int error, num, tmp; 7466871a6c8SJohn Baldwin int proctree_locked = 0; 747ef9457beSDavid Xu lwpid_t tid = 0, *buf; 748841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 74962919d78SPeter Wemm int wrap32 = 0, safe = 0; 75062919d78SPeter Wemm struct ptrace_io_desc32 *piod32 = NULL; 7518a260079SKonstantin Belousov struct ptrace_lwpinfo32 *pl32 = NULL; 752*32451fb9SJohn Baldwin struct ptrace_sc_ret32 *psr32 = NULL; 753*32451fb9SJohn Baldwin union { 754*32451fb9SJohn Baldwin struct ptrace_lwpinfo pl; 755*32451fb9SJohn Baldwin struct ptrace_sc_ret psr; 756*32451fb9SJohn Baldwin } r; 75762919d78SPeter Wemm #endif 7584e68ceabSDavid Greenman 75946e12b42SAlfred Perlstein curp = td->td_proc; 76046e12b42SAlfred Perlstein 761012e544fSIan Dowse /* Lock proctree before locking the process. */ 762012e544fSIan Dowse switch (req) { 7636871a6c8SJohn Baldwin case PT_TRACE_ME: 7646871a6c8SJohn Baldwin case PT_ATTACH: 7656871a6c8SJohn Baldwin case PT_STEP: 7666871a6c8SJohn Baldwin case PT_CONTINUE: 767ea924c4cSRobert Drehmel case PT_TO_SCE: 768ea924c4cSRobert Drehmel case PT_TO_SCX: 769f7fdcd45SDavid Schultz case PT_SYSCALL: 7706fa39a73SKonstantin Belousov case PT_FOLLOW_FORK: 7715fcfab6eSJohn Baldwin case PT_LWP_EVENTS: 7728d570f64SJohn Baldwin case PT_GET_EVENT_MASK: 7738d570f64SJohn Baldwin case PT_SET_EVENT_MASK: 7746871a6c8SJohn Baldwin case PT_DETACH: 775b43ce76cSKonstantin Belousov case PT_GET_SC_ARGS: 7766871a6c8SJohn Baldwin sx_xlock(&proctree_lock); 7776871a6c8SJohn Baldwin proctree_locked = 1; 7786871a6c8SJohn Baldwin break; 7796871a6c8SJohn Baldwin default: 7809daa5b14SMarcel Moolenaar break; 7816871a6c8SJohn Baldwin } 7826871a6c8SJohn Baldwin 783012e544fSIan Dowse if (req == PT_TRACE_ME) { 7846871a6c8SJohn Baldwin p = td->td_proc; 78533a9ed9dSJohn Baldwin PROC_LOCK(p); 78633a9ed9dSJohn Baldwin } else { 787f3b929bfSDavid Xu if (pid <= PID_MAX) { 788012e544fSIan Dowse if ((p = pfind(pid)) == NULL) { 7896871a6c8SJohn Baldwin if (proctree_locked) 7906871a6c8SJohn Baldwin sx_xunlock(&proctree_lock); 791c5799337SDag-Erling Smørgrav return (ESRCH); 7924e68ceabSDavid Greenman } 793f3b929bfSDavid Xu } else { 794cf7d9a8cSDavid Xu td2 = tdfind(pid, -1); 795cf7d9a8cSDavid Xu if (td2 == NULL) { 796f3b929bfSDavid Xu if (proctree_locked) 797f3b929bfSDavid Xu sx_xunlock(&proctree_lock); 798f3b929bfSDavid Xu return (ESRCH); 799f3b929bfSDavid Xu } 800cf7d9a8cSDavid Xu p = td2->td_proc; 801f3b929bfSDavid Xu tid = pid; 802f3b929bfSDavid Xu pid = p->p_pid; 803f3b929bfSDavid Xu } 80433a9ed9dSJohn Baldwin } 80514961ba7SRobert Watson AUDIT_ARG_PROCESS(p); 80606ad42b2SJohn Baldwin 80706ad42b2SJohn Baldwin if ((p->p_flag & P_WEXIT) != 0) { 80806ad42b2SJohn Baldwin error = ESRCH; 80906ad42b2SJohn Baldwin goto fail; 81006ad42b2SJohn Baldwin } 8114f18efe2SRobert Watson if ((error = p_cansee(td, p)) != 0) 8126871a6c8SJohn Baldwin goto fail; 8133da32491SDag-Erling Smørgrav 814f44d9e24SJohn Baldwin if ((error = p_candebug(td, p)) != 0) 8156871a6c8SJohn Baldwin goto fail; 8166871a6c8SJohn Baldwin 8173da32491SDag-Erling Smørgrav /* 81819610b66SBruce Evans * System processes can't be debugged. 8193da32491SDag-Erling Smørgrav */ 8203da32491SDag-Erling Smørgrav if ((p->p_flag & P_SYSTEM) != 0) { 8216871a6c8SJohn Baldwin error = EINVAL; 8226871a6c8SJohn Baldwin goto fail; 8233da32491SDag-Erling Smørgrav } 8243da32491SDag-Erling Smørgrav 825f3b929bfSDavid Xu if (tid == 0) { 826d7bc12b0SDavid Xu if ((p->p_flag & P_STOPPED_TRACE) != 0) { 827d7bc12b0SDavid Xu KASSERT(p->p_xthread != NULL, ("NULL p_xthread")); 828d7bc12b0SDavid Xu td2 = p->p_xthread; 829d7bc12b0SDavid Xu } else { 830f3b929bfSDavid Xu td2 = FIRST_THREAD_IN_PROC(p); 831d7bc12b0SDavid Xu } 832f3b929bfSDavid Xu tid = td2->td_tid; 833f3b929bfSDavid Xu } 834f3b929bfSDavid Xu 835841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 83662919d78SPeter Wemm /* 83762919d78SPeter Wemm * Test if we're a 32 bit client and what the target is. 83862919d78SPeter Wemm * Set the wrap controls accordingly. 83962919d78SPeter Wemm */ 8402883703eSKonstantin Belousov if (SV_CURPROC_FLAG(SV_ILP32)) { 841a5c1afadSDmitry Chagin if (SV_PROC_FLAG(td2->td_proc, SV_ILP32)) 84262919d78SPeter Wemm safe = 1; 84362919d78SPeter Wemm wrap32 = 1; 84462919d78SPeter Wemm } 84562919d78SPeter Wemm #endif 846b0281cefSPeter Wemm /* 847b0281cefSPeter Wemm * Permissions check 848b0281cefSPeter Wemm */ 849012e544fSIan Dowse switch (req) { 850b0281cefSPeter Wemm case PT_TRACE_ME: 85177b9bec3SKonstantin Belousov /* 85277b9bec3SKonstantin Belousov * Always legal, when there is a parent process which 85377b9bec3SKonstantin Belousov * could trace us. Otherwise, reject. 85477b9bec3SKonstantin Belousov */ 85577b9bec3SKonstantin Belousov if ((p->p_flag & P_TRACED) != 0) { 85677b9bec3SKonstantin Belousov error = EBUSY; 85777b9bec3SKonstantin Belousov goto fail; 85877b9bec3SKonstantin Belousov } 85977b9bec3SKonstantin Belousov if (p->p_pptr == initproc) { 86077b9bec3SKonstantin Belousov error = EPERM; 86177b9bec3SKonstantin Belousov goto fail; 86277b9bec3SKonstantin Belousov } 863b0281cefSPeter Wemm break; 8644e68ceabSDavid Greenman 865b0281cefSPeter Wemm case PT_ATTACH: 866b0281cefSPeter Wemm /* Self */ 8671ed2e49bSKonstantin Belousov if (p == td->td_proc) { 8686871a6c8SJohn Baldwin error = EINVAL; 8696871a6c8SJohn Baldwin goto fail; 87033a9ed9dSJohn Baldwin } 871b0281cefSPeter Wemm 872b0281cefSPeter Wemm /* Already traced */ 873731a1aeaSJohn Baldwin if (p->p_flag & P_TRACED) { 8746871a6c8SJohn Baldwin error = EBUSY; 8756871a6c8SJohn Baldwin goto fail; 876731a1aeaSJohn Baldwin } 877b0281cefSPeter Wemm 87846e12b42SAlfred Perlstein /* Can't trace an ancestor if you're being traced. */ 87946e12b42SAlfred Perlstein if (curp->p_flag & P_TRACED) { 88046e12b42SAlfred Perlstein for (pp = curp->p_pptr; pp != NULL; pp = pp->p_pptr) { 88146e12b42SAlfred Perlstein if (pp == p) { 88246e12b42SAlfred Perlstein error = EINVAL; 88346e12b42SAlfred Perlstein goto fail; 88446e12b42SAlfred Perlstein } 88546e12b42SAlfred Perlstein } 88646e12b42SAlfred Perlstein } 88746e12b42SAlfred Perlstein 88846e12b42SAlfred Perlstein 889b0281cefSPeter Wemm /* OK */ 890b0281cefSPeter Wemm break; 891b0281cefSPeter Wemm 892ef9457beSDavid Xu case PT_CLEARSTEP: 893ef9457beSDavid Xu /* Allow thread to clear single step for itself */ 894ef9457beSDavid Xu if (td->td_tid == tid) 895ef9457beSDavid Xu break; 896ef9457beSDavid Xu 897ef9457beSDavid Xu /* FALLTHROUGH */ 8981c843354SMarcel Moolenaar default: 899b0281cefSPeter Wemm /* not being traced... */ 900731a1aeaSJohn Baldwin if ((p->p_flag & P_TRACED) == 0) { 9016871a6c8SJohn Baldwin error = EPERM; 9026871a6c8SJohn Baldwin goto fail; 903731a1aeaSJohn Baldwin } 904b0281cefSPeter Wemm 905b0281cefSPeter Wemm /* not being traced by YOU */ 9066871a6c8SJohn Baldwin if (p->p_pptr != td->td_proc) { 9076871a6c8SJohn Baldwin error = EBUSY; 9086871a6c8SJohn Baldwin goto fail; 90998f03f90SJake Burkholder } 910b0281cefSPeter Wemm 911b0281cefSPeter Wemm /* not currently stopped */ 912feeaec18SJohn Baldwin if ((p->p_flag & P_STOPPED_TRACE) == 0 || 913d7bc12b0SDavid Xu p->p_suspcount != p->p_numthreads || 914ef9457beSDavid Xu (p->p_flag & P_WAITED) == 0) { 9156871a6c8SJohn Baldwin error = EBUSY; 9166871a6c8SJohn Baldwin goto fail; 9170ebabc93SJohn Baldwin } 918b0281cefSPeter Wemm 919b0281cefSPeter Wemm /* OK */ 920b0281cefSPeter Wemm break; 9214e68ceabSDavid Greenman } 922b0281cefSPeter Wemm 92306ad42b2SJohn Baldwin /* Keep this process around until we finish this request. */ 92406ad42b2SJohn Baldwin _PHOLD(p); 92506ad42b2SJohn Baldwin 926b0281cefSPeter Wemm #ifdef FIX_SSTEP 927df8bae1dSRodney W. Grimes /* 928b0281cefSPeter Wemm * Single step fixup ala procfs 929b0281cefSPeter Wemm */ 93006ad42b2SJohn Baldwin FIX_SSTEP(td2); 931b0281cefSPeter Wemm #endif 932b0281cefSPeter Wemm 933b0281cefSPeter Wemm /* 934b0281cefSPeter Wemm * Actually do the requests 935df8bae1dSRodney W. Grimes */ 9364e68ceabSDavid Greenman 937b40ce416SJulian Elischer td->td_retval[0] = 0; 9384e68ceabSDavid Greenman 939012e544fSIan Dowse switch (req) { 940b0281cefSPeter Wemm case PT_TRACE_ME: 941b0281cefSPeter Wemm /* set my trace flag and "owner" so it can read/write me */ 942e5574e09SMark Johnston proc_set_traced(p, false); 943888d4d4fSKonstantin Belousov if (p->p_flag & P_PPWAIT) 944888d4d4fSKonstantin Belousov p->p_flag |= P_PPTRACE; 945515b7a0bSJohn Baldwin CTR1(KTR_PTRACE, "PT_TRACE_ME: pid %d", p->p_pid); 94606ad42b2SJohn Baldwin break; 9474e68ceabSDavid Greenman 948b0281cefSPeter Wemm case PT_ATTACH: 949b0281cefSPeter Wemm /* security check done above */ 95052e95a64SDavid E. O'Brien /* 95152e95a64SDavid E. O'Brien * It would be nice if the tracing relationship was separate 95252e95a64SDavid E. O'Brien * from the parent relationship but that would require 95352e95a64SDavid E. O'Brien * another set of links in the proc struct or for "wait" 95452e95a64SDavid E. O'Brien * to scan the entire proc table. To make life easier, 95552e95a64SDavid E. O'Brien * we just re-parent the process we're trying to trace. 95652e95a64SDavid E. O'Brien * The old parent is remembered so we can put things back 95752e95a64SDavid E. O'Brien * on a "detach". 95852e95a64SDavid E. O'Brien */ 959e5574e09SMark Johnston proc_set_traced(p, true); 960f528c3fdSDavid E. O'Brien if (p->p_pptr != td->td_proc) { 9612c054ce9SMateusz Guzik proc_reparent(p, td->td_proc, false); 962f528c3fdSDavid E. O'Brien } 963515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_ATTACH: pid %d, oppid %d", p->p_pid, 964515b7a0bSJohn Baldwin p->p_oppid); 9652a2b23caSJohn Baldwin 9662a2b23caSJohn Baldwin sx_xunlock(&proctree_lock); 9672a2b23caSJohn Baldwin proctree_locked = 0; 9682a2b23caSJohn Baldwin MPASS(p->p_xthread == NULL); 9692a2b23caSJohn Baldwin MPASS((p->p_flag & P_STOPPED_TRACE) == 0); 9702a2b23caSJohn Baldwin 9712a2b23caSJohn Baldwin /* 9722a2b23caSJohn Baldwin * If already stopped due to a stop signal, clear the 9732a2b23caSJohn Baldwin * existing stop before triggering a traced SIGSTOP. 9742a2b23caSJohn Baldwin */ 9752a2b23caSJohn Baldwin if ((p->p_flag & P_STOPPED_SIG) != 0) { 9762a2b23caSJohn Baldwin PROC_SLOCK(p); 9772a2b23caSJohn Baldwin p->p_flag &= ~(P_STOPPED_SIG | P_WAITED); 9782a2b23caSJohn Baldwin thread_unsuspend(p); 9792a2b23caSJohn Baldwin PROC_SUNLOCK(p); 9802a2b23caSJohn Baldwin } 9812a2b23caSJohn Baldwin 9822a2b23caSJohn Baldwin kern_psignal(p, SIGSTOP); 9832a2b23caSJohn Baldwin break; 984b0281cefSPeter Wemm 985ef9457beSDavid Xu case PT_CLEARSTEP: 986515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_CLEARSTEP: tid %d (pid %d)", td2->td_tid, 987515b7a0bSJohn Baldwin p->p_pid); 988ef9457beSDavid Xu error = ptrace_clear_single_step(td2); 98906ad42b2SJohn Baldwin break; 990ef9457beSDavid Xu 991ef9457beSDavid Xu case PT_SETSTEP: 992515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_SETSTEP: tid %d (pid %d)", td2->td_tid, 993515b7a0bSJohn Baldwin p->p_pid); 994ef9457beSDavid Xu error = ptrace_single_step(td2); 99506ad42b2SJohn Baldwin break; 996ef9457beSDavid Xu 997ef9457beSDavid Xu case PT_SUSPEND: 998515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_SUSPEND: tid %d (pid %d)", td2->td_tid, 999515b7a0bSJohn Baldwin p->p_pid); 1000904c5ec4SDavid Xu td2->td_dbgflags |= TDB_SUSPEND; 1001982d11f8SJeff Roberson thread_lock(td2); 1002904c5ec4SDavid Xu td2->td_flags |= TDF_NEEDSUSPCHK; 1003982d11f8SJeff Roberson thread_unlock(td2); 100406ad42b2SJohn Baldwin break; 1005ef9457beSDavid Xu 1006ef9457beSDavid Xu case PT_RESUME: 1007515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_RESUME: tid %d (pid %d)", td2->td_tid, 1008515b7a0bSJohn Baldwin p->p_pid); 1009904c5ec4SDavid Xu td2->td_dbgflags &= ~TDB_SUSPEND; 101006ad42b2SJohn Baldwin break; 1011ef9457beSDavid Xu 10126fa39a73SKonstantin Belousov case PT_FOLLOW_FORK: 1013515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_FOLLOW_FORK: pid %d %s -> %s", p->p_pid, 10148d570f64SJohn Baldwin p->p_ptevents & PTRACE_FORK ? "enabled" : "disabled", 1015515b7a0bSJohn Baldwin data ? "enabled" : "disabled"); 10166fa39a73SKonstantin Belousov if (data) 10178d570f64SJohn Baldwin p->p_ptevents |= PTRACE_FORK; 10186fa39a73SKonstantin Belousov else 10198d570f64SJohn Baldwin p->p_ptevents &= ~PTRACE_FORK; 10206fa39a73SKonstantin Belousov break; 10216fa39a73SKonstantin Belousov 10225fcfab6eSJohn Baldwin case PT_LWP_EVENTS: 10235fcfab6eSJohn Baldwin CTR3(KTR_PTRACE, "PT_LWP_EVENTS: pid %d %s -> %s", p->p_pid, 10248d570f64SJohn Baldwin p->p_ptevents & PTRACE_LWP ? "enabled" : "disabled", 10255fcfab6eSJohn Baldwin data ? "enabled" : "disabled"); 10265fcfab6eSJohn Baldwin if (data) 10278d570f64SJohn Baldwin p->p_ptevents |= PTRACE_LWP; 10285fcfab6eSJohn Baldwin else 10298d570f64SJohn Baldwin p->p_ptevents &= ~PTRACE_LWP; 10308d570f64SJohn Baldwin break; 10318d570f64SJohn Baldwin 10328d570f64SJohn Baldwin case PT_GET_EVENT_MASK: 10338d570f64SJohn Baldwin if (data != sizeof(p->p_ptevents)) { 10348d570f64SJohn Baldwin error = EINVAL; 10358d570f64SJohn Baldwin break; 10368d570f64SJohn Baldwin } 10378d570f64SJohn Baldwin CTR2(KTR_PTRACE, "PT_GET_EVENT_MASK: pid %d mask %#x", p->p_pid, 10388d570f64SJohn Baldwin p->p_ptevents); 10398d570f64SJohn Baldwin *(int *)addr = p->p_ptevents; 10408d570f64SJohn Baldwin break; 10418d570f64SJohn Baldwin 10428d570f64SJohn Baldwin case PT_SET_EVENT_MASK: 10438d570f64SJohn Baldwin if (data != sizeof(p->p_ptevents)) { 10448d570f64SJohn Baldwin error = EINVAL; 10458d570f64SJohn Baldwin break; 10468d570f64SJohn Baldwin } 10478d570f64SJohn Baldwin tmp = *(int *)addr; 10488d570f64SJohn Baldwin if ((tmp & ~(PTRACE_EXEC | PTRACE_SCE | PTRACE_SCX | 1049fc4f075aSJohn Baldwin PTRACE_FORK | PTRACE_LWP | PTRACE_VFORK)) != 0) { 10508d570f64SJohn Baldwin error = EINVAL; 10518d570f64SJohn Baldwin break; 10528d570f64SJohn Baldwin } 10538d570f64SJohn Baldwin CTR3(KTR_PTRACE, "PT_SET_EVENT_MASK: pid %d mask %#x -> %#x", 10548d570f64SJohn Baldwin p->p_pid, p->p_ptevents, tmp); 10558d570f64SJohn Baldwin p->p_ptevents = tmp; 10565fcfab6eSJohn Baldwin break; 10575fcfab6eSJohn Baldwin 1058b43ce76cSKonstantin Belousov case PT_GET_SC_ARGS: 1059b43ce76cSKonstantin Belousov CTR1(KTR_PTRACE, "PT_GET_SC_ARGS: pid %d", p->p_pid); 1060b43ce76cSKonstantin Belousov if ((td2->td_dbgflags & (TDB_SCE | TDB_SCX)) == 0 1061b43ce76cSKonstantin Belousov #ifdef COMPAT_FREEBSD32 1062b43ce76cSKonstantin Belousov || (wrap32 && !safe) 1063b43ce76cSKonstantin Belousov #endif 1064b43ce76cSKonstantin Belousov ) { 1065b43ce76cSKonstantin Belousov error = EINVAL; 1066b43ce76cSKonstantin Belousov break; 1067b43ce76cSKonstantin Belousov } 1068b43ce76cSKonstantin Belousov bzero(addr, sizeof(td2->td_sa.args)); 1069b43ce76cSKonstantin Belousov #ifdef COMPAT_FREEBSD32 1070b43ce76cSKonstantin Belousov if (wrap32) 1071b43ce76cSKonstantin Belousov for (num = 0; num < nitems(td2->td_sa.args); num++) 1072b43ce76cSKonstantin Belousov ((uint32_t *)addr)[num] = (uint32_t) 1073b43ce76cSKonstantin Belousov td2->td_sa.args[num]; 1074b43ce76cSKonstantin Belousov else 1075b43ce76cSKonstantin Belousov #endif 1076b43ce76cSKonstantin Belousov bcopy(td2->td_sa.args, addr, td2->td_sa.narg * 1077b43ce76cSKonstantin Belousov sizeof(register_t)); 1078b43ce76cSKonstantin Belousov break; 1079b43ce76cSKonstantin Belousov 1080*32451fb9SJohn Baldwin case PT_GET_SC_RET: 1081*32451fb9SJohn Baldwin if ((td2->td_dbgflags & (TDB_SCX)) == 0 1082*32451fb9SJohn Baldwin #ifdef COMPAT_FREEBSD32 1083*32451fb9SJohn Baldwin || (wrap32 && !safe) 1084*32451fb9SJohn Baldwin #endif 1085*32451fb9SJohn Baldwin ) { 1086*32451fb9SJohn Baldwin error = EINVAL; 1087*32451fb9SJohn Baldwin break; 1088*32451fb9SJohn Baldwin } 1089*32451fb9SJohn Baldwin #ifdef COMPAT_FREEBSD32 1090*32451fb9SJohn Baldwin if (wrap32) { 1091*32451fb9SJohn Baldwin psr = &r.psr; 1092*32451fb9SJohn Baldwin psr32 = addr; 1093*32451fb9SJohn Baldwin } else 1094*32451fb9SJohn Baldwin #endif 1095*32451fb9SJohn Baldwin psr = addr; 1096*32451fb9SJohn Baldwin bzero(psr, sizeof(*psr)); 1097*32451fb9SJohn Baldwin psr->sr_error = td2->td_errno; 1098*32451fb9SJohn Baldwin if (psr->sr_error == 0) { 1099*32451fb9SJohn Baldwin psr->sr_retval[0] = td2->td_retval[0]; 1100*32451fb9SJohn Baldwin psr->sr_retval[1] = td2->td_retval[1]; 1101*32451fb9SJohn Baldwin } 1102*32451fb9SJohn Baldwin #ifdef COMPAT_FREEBSD32 1103*32451fb9SJohn Baldwin if (wrap32) 1104*32451fb9SJohn Baldwin ptrace_sc_ret_to32(psr, psr32); 1105*32451fb9SJohn Baldwin #endif 1106*32451fb9SJohn Baldwin CTR4(KTR_PTRACE, 1107*32451fb9SJohn Baldwin "PT_GET_SC_RET: pid %d error %d retval %#lx,%#lx", 1108*32451fb9SJohn Baldwin p->p_pid, psr->sr_error, psr->sr_retval[0], 1109*32451fb9SJohn Baldwin psr->sr_retval[1]); 1110*32451fb9SJohn Baldwin break; 1111*32451fb9SJohn Baldwin 1112b0281cefSPeter Wemm case PT_STEP: 1113b0281cefSPeter Wemm case PT_CONTINUE: 1114ea924c4cSRobert Drehmel case PT_TO_SCE: 1115ea924c4cSRobert Drehmel case PT_TO_SCX: 1116f7fdcd45SDavid Schultz case PT_SYSCALL: 11174e68ceabSDavid Greenman case PT_DETACH: 1118007e25d9SJacques Vidrine /* Zero means do not send any signal */ 1119007e25d9SJacques Vidrine if (data < 0 || data > _SIG_MAXSIG) { 11206871a6c8SJohn Baldwin error = EINVAL; 112106ad42b2SJohn Baldwin break; 11226871a6c8SJohn Baldwin } 1123b0281cefSPeter Wemm 1124ea924c4cSRobert Drehmel switch (req) { 1125ea924c4cSRobert Drehmel case PT_STEP: 112609f3bb87SJohn Baldwin CTR3(KTR_PTRACE, "PT_STEP: tid %d (pid %d), sig = %d", 112709f3bb87SJohn Baldwin td2->td_tid, p->p_pid, data); 1128fe0d0493SPeter Wemm error = ptrace_single_step(td2); 112906ad42b2SJohn Baldwin if (error) 113006ad42b2SJohn Baldwin goto out; 1131ea924c4cSRobert Drehmel break; 11320bfbf4d2SJohn Baldwin case PT_CONTINUE: 11330bfbf4d2SJohn Baldwin case PT_TO_SCE: 11340bfbf4d2SJohn Baldwin case PT_TO_SCX: 11350bfbf4d2SJohn Baldwin case PT_SYSCALL: 11360bfbf4d2SJohn Baldwin if (addr != (void *)1) { 11370bfbf4d2SJohn Baldwin error = ptrace_set_pc(td2, 11380bfbf4d2SJohn Baldwin (u_long)(uintfptr_t)addr); 11390bfbf4d2SJohn Baldwin if (error) 11400bfbf4d2SJohn Baldwin goto out; 11410bfbf4d2SJohn Baldwin } 11420bfbf4d2SJohn Baldwin switch (req) { 1143ea924c4cSRobert Drehmel case PT_TO_SCE: 11448d570f64SJohn Baldwin p->p_ptevents |= PTRACE_SCE; 11453edd0fffSJohn Baldwin CTR4(KTR_PTRACE, 11468d570f64SJohn Baldwin "PT_TO_SCE: pid %d, events = %#x, PC = %#lx, sig = %d", 11478d570f64SJohn Baldwin p->p_pid, p->p_ptevents, 11483edd0fffSJohn Baldwin (u_long)(uintfptr_t)addr, data); 1149ea924c4cSRobert Drehmel break; 1150ea924c4cSRobert Drehmel case PT_TO_SCX: 11518d570f64SJohn Baldwin p->p_ptevents |= PTRACE_SCX; 11523edd0fffSJohn Baldwin CTR4(KTR_PTRACE, 11538d570f64SJohn Baldwin "PT_TO_SCX: pid %d, events = %#x, PC = %#lx, sig = %d", 11548d570f64SJohn Baldwin p->p_pid, p->p_ptevents, 11553edd0fffSJohn Baldwin (u_long)(uintfptr_t)addr, data); 1156ea924c4cSRobert Drehmel break; 1157ea924c4cSRobert Drehmel case PT_SYSCALL: 11588d570f64SJohn Baldwin p->p_ptevents |= PTRACE_SYSCALL; 11593edd0fffSJohn Baldwin CTR4(KTR_PTRACE, 11608d570f64SJohn Baldwin "PT_SYSCALL: pid %d, events = %#x, PC = %#lx, sig = %d", 11618d570f64SJohn Baldwin p->p_pid, p->p_ptevents, 11623edd0fffSJohn Baldwin (u_long)(uintfptr_t)addr, data); 1163515b7a0bSJohn Baldwin break; 1164515b7a0bSJohn Baldwin case PT_CONTINUE: 11653edd0fffSJohn Baldwin CTR3(KTR_PTRACE, 11663edd0fffSJohn Baldwin "PT_CONTINUE: pid %d, PC = %#lx, sig = %d", 11673edd0fffSJohn Baldwin p->p_pid, (u_long)(uintfptr_t)addr, data); 1168ea924c4cSRobert Drehmel break; 1169b0281cefSPeter Wemm } 117006ad42b2SJohn Baldwin break; 11710bfbf4d2SJohn Baldwin case PT_DETACH: 117298685dc8SJohn Baldwin /* 117398685dc8SJohn Baldwin * Reset the process parent. 117498685dc8SJohn Baldwin * 117598685dc8SJohn Baldwin * NB: This clears P_TRACED before reparenting 117698685dc8SJohn Baldwin * a detached process back to its original 117798685dc8SJohn Baldwin * parent. Otherwise the debugee will be set 117898685dc8SJohn Baldwin * as an orphan of the debugger. 117998685dc8SJohn Baldwin */ 11808d570f64SJohn Baldwin p->p_flag &= ~(P_TRACED | P_WAITED); 1181b0281cefSPeter Wemm if (p->p_oppid != p->p_pptr->p_pid) { 1182c20cedbfSDavid Xu PROC_LOCK(p->p_pptr); 1183c20cedbfSDavid Xu sigqueue_take(p->p_ksi); 1184c20cedbfSDavid Xu PROC_UNLOCK(p->p_pptr); 1185c20cedbfSDavid Xu 1186d7359980SKonstantin Belousov pp = proc_realparent(p); 11872c054ce9SMateusz Guzik proc_reparent(p, pp, false); 1188cf93aa16SDon Lewis if (pp == initproc) 118955b5f2a2SDon Lewis p->p_sigparent = SIGCHLD; 11903edd0fffSJohn Baldwin CTR3(KTR_PTRACE, 11913edd0fffSJohn Baldwin "PT_DETACH: pid %d reparented to pid %d, sig %d", 11923edd0fffSJohn Baldwin p->p_pid, pp->p_pid, data); 1193515b7a0bSJohn Baldwin } else 11943edd0fffSJohn Baldwin CTR2(KTR_PTRACE, "PT_DETACH: pid %d, sig %d", 11953edd0fffSJohn Baldwin p->p_pid, data); 11968d570f64SJohn Baldwin p->p_ptevents = 0; 1197b7a25e63SKonstantin Belousov FOREACH_THREAD_IN_PROC(p, td3) { 1198b7a25e63SKonstantin Belousov if ((td3->td_dbgflags & TDB_FSTP) != 0) { 1199b7a25e63SKonstantin Belousov sigqueue_delete(&td3->td_sigqueue, 1200b7a25e63SKonstantin Belousov SIGSTOP); 1201b7a25e63SKonstantin Belousov } 12027e3e3606SJohn Baldwin td3->td_dbgflags &= ~(TDB_XSIG | TDB_FSTP | 12037e3e3606SJohn Baldwin TDB_SUSPEND); 1204b7a25e63SKonstantin Belousov } 12057e3e3606SJohn Baldwin 1206b7a25e63SKonstantin Belousov if ((p->p_flag2 & P2_PTRACE_FSTP) != 0) { 1207b7a25e63SKonstantin Belousov sigqueue_delete(&p->p_sigqueue, SIGSTOP); 1208b7a25e63SKonstantin Belousov p->p_flag2 &= ~P2_PTRACE_FSTP; 1209b7a25e63SKonstantin Belousov } 1210731a1aeaSJohn Baldwin 1211b0281cefSPeter Wemm /* should we send SIGCHLD? */ 1212c20cedbfSDavid Xu /* childproc_continued(p); */ 12130bfbf4d2SJohn Baldwin break; 1214b0281cefSPeter Wemm } 1215b0281cefSPeter Wemm 1216feeaec18SJohn Baldwin sx_xunlock(&proctree_lock); 1217feeaec18SJohn Baldwin proctree_locked = 0; 12182a2b23caSJohn Baldwin 12192a2b23caSJohn Baldwin sendsig: 12202a2b23caSJohn Baldwin MPASS(proctree_locked == 0); 1221feeaec18SJohn Baldwin 1222e012fe34SJohn Baldwin /* 1223e012fe34SJohn Baldwin * Clear the pending event for the thread that just 1224e012fe34SJohn Baldwin * reported its event (p_xthread). This may not be 1225e012fe34SJohn Baldwin * the thread passed to PT_CONTINUE, PT_STEP, etc. if 1226e012fe34SJohn Baldwin * the debugger is resuming a different thread. 1227feeaec18SJohn Baldwin * 1228feeaec18SJohn Baldwin * Deliver any pending signal via the reporting thread. 1229e012fe34SJohn Baldwin */ 1230feeaec18SJohn Baldwin MPASS(p->p_xthread != NULL); 1231feeaec18SJohn Baldwin p->p_xthread->td_dbgflags &= ~TDB_XSIG; 1232feeaec18SJohn Baldwin p->p_xthread->td_xsig = data; 12338753688fSJeff Roberson p->p_xthread = NULL; 1234feeaec18SJohn Baldwin p->p_xsig = data; 12358753688fSJeff Roberson 123682a4538fSEric Badger /* 12372a2b23caSJohn Baldwin * P_WKILLED is insurance that a PT_KILL/SIGKILL 12382a2b23caSJohn Baldwin * always works immediately, even if another thread is 12392a2b23caSJohn Baldwin * unsuspended first and attempts to handle a 12402a2b23caSJohn Baldwin * different signal or if the POSIX.1b style signal 12412a2b23caSJohn Baldwin * queue cannot accommodate any new signals. 124282a4538fSEric Badger */ 124382a4538fSEric Badger if (data == SIGKILL) 1244a70e9a13SKonstantin Belousov proc_wkilled(p); 124582a4538fSEric Badger 1246ef9457beSDavid Xu /* 1247feeaec18SJohn Baldwin * Unsuspend all threads. To leave a thread 12482a2b23caSJohn Baldwin * suspended, use PT_SUSPEND to suspend it before 12492a2b23caSJohn Baldwin * continuing the process. 1250ef9457beSDavid Xu */ 12517b4a950aSDavid Xu PROC_SLOCK(p); 1252d7bc12b0SDavid Xu p->p_flag &= ~(P_STOPPED_TRACE | P_STOPPED_SIG | P_WAITED); 12538c6d7a8dSDavid Xu thread_unsuspend(p); 12547b4a950aSDavid Xu PROC_SUNLOCK(p); 125506ad42b2SJohn Baldwin break; 12564e68ceabSDavid Greenman 12574e68ceabSDavid Greenman case PT_WRITE_I: 12584e68ceabSDavid Greenman case PT_WRITE_D: 12595b1162b9SKonstantin Belousov td2->td_dbgflags |= TDB_USERWR; 1260711fbd17SMark Johnston PROC_UNLOCK(p); 1261711fbd17SMark Johnston error = 0; 1262711fbd17SMark Johnston if (proc_writemem(td, p, (off_t)(uintptr_t)addr, &data, 1263711fbd17SMark Johnston sizeof(int)) != sizeof(int)) 1264711fbd17SMark Johnston error = ENOMEM; 1265711fbd17SMark Johnston else 1266711fbd17SMark Johnston CTR3(KTR_PTRACE, "PT_WRITE: pid %d: %p <= %#x", 1267711fbd17SMark Johnston p->p_pid, addr, data); 1268711fbd17SMark Johnston PROC_LOCK(p); 1269711fbd17SMark Johnston break; 1270711fbd17SMark Johnston 1271b0281cefSPeter Wemm case PT_READ_I: 1272b0281cefSPeter Wemm case PT_READ_D: 12736871a6c8SJohn Baldwin PROC_UNLOCK(p); 1274711fbd17SMark Johnston error = tmp = 0; 1275711fbd17SMark Johnston if (proc_readmem(td, p, (off_t)(uintptr_t)addr, &tmp, 1276711fbd17SMark Johnston sizeof(int)) != sizeof(int)) 1277711fbd17SMark Johnston error = ENOMEM; 1278515b7a0bSJohn Baldwin else 1279515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_READ: pid %d: %p >= %#x", 1280515b7a0bSJohn Baldwin p->p_pid, addr, tmp); 1281711fbd17SMark Johnston td->td_retval[0] = tmp; 128206ad42b2SJohn Baldwin PROC_LOCK(p); 128306ad42b2SJohn Baldwin break; 12844e68ceabSDavid Greenman 12858bc814e6SDag-Erling Smørgrav case PT_IO: 1286841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 128762919d78SPeter Wemm if (wrap32) { 128862919d78SPeter Wemm piod32 = addr; 128962919d78SPeter Wemm iov.iov_base = (void *)(uintptr_t)piod32->piod_addr; 129062919d78SPeter Wemm iov.iov_len = piod32->piod_len; 129162919d78SPeter Wemm uio.uio_offset = (off_t)(uintptr_t)piod32->piod_offs; 129262919d78SPeter Wemm uio.uio_resid = piod32->piod_len; 129362919d78SPeter Wemm } else 129462919d78SPeter Wemm #endif 129562919d78SPeter Wemm { 1296012e544fSIan Dowse piod = addr; 1297012e544fSIan Dowse iov.iov_base = piod->piod_addr; 1298012e544fSIan Dowse iov.iov_len = piod->piod_len; 1299012e544fSIan Dowse uio.uio_offset = (off_t)(uintptr_t)piod->piod_offs; 1300012e544fSIan Dowse uio.uio_resid = piod->piod_len; 130162919d78SPeter Wemm } 130262919d78SPeter Wemm uio.uio_iov = &iov; 130362919d78SPeter Wemm uio.uio_iovcnt = 1; 13048bc814e6SDag-Erling Smørgrav uio.uio_segflg = UIO_USERSPACE; 13058bc814e6SDag-Erling Smørgrav uio.uio_td = td; 1306841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 130762919d78SPeter Wemm tmp = wrap32 ? piod32->piod_op : piod->piod_op; 130862919d78SPeter Wemm #else 130962919d78SPeter Wemm tmp = piod->piod_op; 131062919d78SPeter Wemm #endif 131162919d78SPeter Wemm switch (tmp) { 13128bc814e6SDag-Erling Smørgrav case PIOD_READ_D: 13138bc814e6SDag-Erling Smørgrav case PIOD_READ_I: 1314515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_IO: pid %d: READ (%p, %#x)", 1315515b7a0bSJohn Baldwin p->p_pid, (uintptr_t)uio.uio_offset, uio.uio_resid); 13168bc814e6SDag-Erling Smørgrav uio.uio_rw = UIO_READ; 13178bc814e6SDag-Erling Smørgrav break; 13188bc814e6SDag-Erling Smørgrav case PIOD_WRITE_D: 13198bc814e6SDag-Erling Smørgrav case PIOD_WRITE_I: 1320515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_IO: pid %d: WRITE (%p, %#x)", 1321515b7a0bSJohn Baldwin p->p_pid, (uintptr_t)uio.uio_offset, uio.uio_resid); 13225b1162b9SKonstantin Belousov td2->td_dbgflags |= TDB_USERWR; 13238bc814e6SDag-Erling Smørgrav uio.uio_rw = UIO_WRITE; 13248bc814e6SDag-Erling Smørgrav break; 13258bc814e6SDag-Erling Smørgrav default: 132606ad42b2SJohn Baldwin error = EINVAL; 132706ad42b2SJohn Baldwin goto out; 13288bc814e6SDag-Erling Smørgrav } 132906ad42b2SJohn Baldwin PROC_UNLOCK(p); 13308bc814e6SDag-Erling Smørgrav error = proc_rwmem(p, &uio); 1331841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 133262919d78SPeter Wemm if (wrap32) 133362919d78SPeter Wemm piod32->piod_len -= uio.uio_resid; 133462919d78SPeter Wemm else 133562919d78SPeter Wemm #endif 1336012e544fSIan Dowse piod->piod_len -= uio.uio_resid; 133706ad42b2SJohn Baldwin PROC_LOCK(p); 133806ad42b2SJohn Baldwin break; 13398bc814e6SDag-Erling Smørgrav 13404e68ceabSDavid Greenman case PT_KILL: 1341515b7a0bSJohn Baldwin CTR1(KTR_PTRACE, "PT_KILL: pid %d", p->p_pid); 1342012e544fSIan Dowse data = SIGKILL; 1343b0281cefSPeter Wemm goto sendsig; /* in PT_CONTINUE above */ 1344b0281cefSPeter Wemm 1345b0281cefSPeter Wemm case PT_SETREGS: 1346515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_SETREGS: tid %d (pid %d)", td2->td_tid, 1347515b7a0bSJohn Baldwin p->p_pid); 13485b1162b9SKonstantin Belousov td2->td_dbgflags |= TDB_USERWR; 134962919d78SPeter Wemm error = PROC_WRITE(regs, td2, addr); 135006ad42b2SJohn Baldwin break; 13513da32491SDag-Erling Smørgrav 13524e68ceabSDavid Greenman case PT_GETREGS: 1353515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_GETREGS: tid %d (pid %d)", td2->td_tid, 1354515b7a0bSJohn Baldwin p->p_pid); 135562919d78SPeter Wemm error = PROC_READ(regs, td2, addr); 135606ad42b2SJohn Baldwin break; 1357b0281cefSPeter Wemm 1358b0281cefSPeter Wemm case PT_SETFPREGS: 1359515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_SETFPREGS: tid %d (pid %d)", td2->td_tid, 1360515b7a0bSJohn Baldwin p->p_pid); 13615b1162b9SKonstantin Belousov td2->td_dbgflags |= TDB_USERWR; 136262919d78SPeter Wemm error = PROC_WRITE(fpregs, td2, addr); 136306ad42b2SJohn Baldwin break; 13643da32491SDag-Erling Smørgrav 1365b0281cefSPeter Wemm case PT_GETFPREGS: 1366515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_GETFPREGS: tid %d (pid %d)", td2->td_tid, 1367515b7a0bSJohn Baldwin p->p_pid); 136862919d78SPeter Wemm error = PROC_READ(fpregs, td2, addr); 136906ad42b2SJohn Baldwin break; 1370b0281cefSPeter Wemm 1371ab001a72SJonathan Lemon case PT_SETDBREGS: 1372515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_SETDBREGS: tid %d (pid %d)", td2->td_tid, 1373515b7a0bSJohn Baldwin p->p_pid); 13745b1162b9SKonstantin Belousov td2->td_dbgflags |= TDB_USERWR; 137562919d78SPeter Wemm error = PROC_WRITE(dbregs, td2, addr); 137606ad42b2SJohn Baldwin break; 13773da32491SDag-Erling Smørgrav 1378ab001a72SJonathan Lemon case PT_GETDBREGS: 1379515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_GETDBREGS: tid %d (pid %d)", td2->td_tid, 1380515b7a0bSJohn Baldwin p->p_pid); 138162919d78SPeter Wemm error = PROC_READ(dbregs, td2, addr); 138206ad42b2SJohn Baldwin break; 1383ab001a72SJonathan Lemon 1384fbc3247dSMarcel Moolenaar case PT_LWPINFO: 13858a260079SKonstantin Belousov if (data <= 0 || 13868a260079SKonstantin Belousov #ifdef COMPAT_FREEBSD32 13878a260079SKonstantin Belousov (!wrap32 && data > sizeof(*pl)) || 13888a260079SKonstantin Belousov (wrap32 && data > sizeof(*pl32))) { 13898a260079SKonstantin Belousov #else 13908a260079SKonstantin Belousov data > sizeof(*pl)) { 13918a260079SKonstantin Belousov #endif 139206ad42b2SJohn Baldwin error = EINVAL; 139306ad42b2SJohn Baldwin break; 139406ad42b2SJohn Baldwin } 13958a260079SKonstantin Belousov #ifdef COMPAT_FREEBSD32 13968a260079SKonstantin Belousov if (wrap32) { 1397*32451fb9SJohn Baldwin pl = &r.pl; 13988a260079SKonstantin Belousov pl32 = addr; 13998a260079SKonstantin Belousov } else 14008a260079SKonstantin Belousov #endif 1401fbc3247dSMarcel Moolenaar pl = addr; 14029acf7b13SKonstantin Belousov bzero(pl, sizeof(*pl)); 1403ef9457beSDavid Xu pl->pl_lwpid = td2->td_tid; 1404c0c6e95fSKonstantin Belousov pl->pl_event = PL_EVENT_NONE; 14051f2eac6cSDavid Xu pl->pl_flags = 0; 14068a260079SKonstantin Belousov if (td2->td_dbgflags & TDB_XSIG) { 14078a260079SKonstantin Belousov pl->pl_event = PL_EVENT_SIGNAL; 140886be94fcSTycho Nightingale if (td2->td_si.si_signo != 0 && 14098a260079SKonstantin Belousov #ifdef COMPAT_FREEBSD32 14108a260079SKonstantin Belousov ((!wrap32 && data >= offsetof(struct ptrace_lwpinfo, 14118a260079SKonstantin Belousov pl_siginfo) + sizeof(pl->pl_siginfo)) || 14128a260079SKonstantin Belousov (wrap32 && data >= offsetof(struct ptrace_lwpinfo32, 14138a260079SKonstantin Belousov pl_siginfo) + sizeof(struct siginfo32))) 14148a260079SKonstantin Belousov #else 14158a260079SKonstantin Belousov data >= offsetof(struct ptrace_lwpinfo, pl_siginfo) 14168a260079SKonstantin Belousov + sizeof(pl->pl_siginfo) 14178a260079SKonstantin Belousov #endif 14188a260079SKonstantin Belousov ){ 14198a260079SKonstantin Belousov pl->pl_flags |= PL_FLAG_SI; 142086be94fcSTycho Nightingale pl->pl_siginfo = td2->td_si; 14218a260079SKonstantin Belousov } 14228a260079SKonstantin Belousov } 1423afe1a688SKonstantin Belousov if (td2->td_dbgflags & TDB_SCE) 1424afe1a688SKonstantin Belousov pl->pl_flags |= PL_FLAG_SCE; 1425afe1a688SKonstantin Belousov else if (td2->td_dbgflags & TDB_SCX) 1426afe1a688SKonstantin Belousov pl->pl_flags |= PL_FLAG_SCX; 1427afe1a688SKonstantin Belousov if (td2->td_dbgflags & TDB_EXEC) 1428afe1a688SKonstantin Belousov pl->pl_flags |= PL_FLAG_EXEC; 14296fa39a73SKonstantin Belousov if (td2->td_dbgflags & TDB_FORK) { 14306fa39a73SKonstantin Belousov pl->pl_flags |= PL_FLAG_FORKED; 14316fa39a73SKonstantin Belousov pl->pl_child_pid = td2->td_dbg_forked; 1432fc4f075aSJohn Baldwin if (td2->td_dbgflags & TDB_VFORK) 1433fc4f075aSJohn Baldwin pl->pl_flags |= PL_FLAG_VFORKED; 1434fc4f075aSJohn Baldwin } else if ((td2->td_dbgflags & (TDB_SCX | TDB_VFORK)) == 1435fc4f075aSJohn Baldwin TDB_VFORK) 1436fc4f075aSJohn Baldwin pl->pl_flags |= PL_FLAG_VFORK_DONE; 1437db327339SKonstantin Belousov if (td2->td_dbgflags & TDB_CHILD) 1438db327339SKonstantin Belousov pl->pl_flags |= PL_FLAG_CHILD; 14395fcfab6eSJohn Baldwin if (td2->td_dbgflags & TDB_BORN) 14405fcfab6eSJohn Baldwin pl->pl_flags |= PL_FLAG_BORN; 14415fcfab6eSJohn Baldwin if (td2->td_dbgflags & TDB_EXIT) 14425fcfab6eSJohn Baldwin pl->pl_flags |= PL_FLAG_EXITED; 1443ea8e65b0SDavid Xu pl->pl_sigmask = td2->td_sigmask; 1444ea8e65b0SDavid Xu pl->pl_siglist = td2->td_siglist; 14457f08176eSAttilio Rao strcpy(pl->pl_tdname, td2->td_name); 1446183b68f7SJohn Baldwin if ((td2->td_dbgflags & (TDB_SCE | TDB_SCX)) != 0) { 14472d88da2fSKonstantin Belousov pl->pl_syscall_code = td2->td_sa.code; 14482d88da2fSKonstantin Belousov pl->pl_syscall_narg = td2->td_sa.narg; 1449183b68f7SJohn Baldwin } else { 1450183b68f7SJohn Baldwin pl->pl_syscall_code = 0; 1451183b68f7SJohn Baldwin pl->pl_syscall_narg = 0; 1452183b68f7SJohn Baldwin } 14538a260079SKonstantin Belousov #ifdef COMPAT_FREEBSD32 14548a260079SKonstantin Belousov if (wrap32) 14558a260079SKonstantin Belousov ptrace_lwpinfo_to32(pl, pl32); 14568a260079SKonstantin Belousov #endif 14573edd0fffSJohn Baldwin CTR6(KTR_PTRACE, 14583edd0fffSJohn Baldwin "PT_LWPINFO: tid %d (pid %d) event %d flags %#x child pid %d syscall %d", 1459515b7a0bSJohn Baldwin td2->td_tid, p->p_pid, pl->pl_event, pl->pl_flags, 14603edd0fffSJohn Baldwin pl->pl_child_pid, pl->pl_syscall_code); 146106ad42b2SJohn Baldwin break; 1462fbc3247dSMarcel Moolenaar 1463ef9457beSDavid Xu case PT_GETNUMLWPS: 1464515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_GETNUMLWPS: pid %d: %d threads", p->p_pid, 1465515b7a0bSJohn Baldwin p->p_numthreads); 1466ef9457beSDavid Xu td->td_retval[0] = p->p_numthreads; 146706ad42b2SJohn Baldwin break; 1468ef9457beSDavid Xu 1469ef9457beSDavid Xu case PT_GETLWPLIST: 1470515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "PT_GETLWPLIST: pid %d: data %d, actual %d", 1471515b7a0bSJohn Baldwin p->p_pid, data, p->p_numthreads); 1472ef9457beSDavid Xu if (data <= 0) { 147306ad42b2SJohn Baldwin error = EINVAL; 147406ad42b2SJohn Baldwin break; 1475ef9457beSDavid Xu } 1476ef9457beSDavid Xu num = imin(p->p_numthreads, data); 1477ef9457beSDavid Xu PROC_UNLOCK(p); 1478ef9457beSDavid Xu buf = malloc(num * sizeof(lwpid_t), M_TEMP, M_WAITOK); 1479ef9457beSDavid Xu tmp = 0; 1480ef9457beSDavid Xu PROC_LOCK(p); 1481ef9457beSDavid Xu FOREACH_THREAD_IN_PROC(p, td2) { 1482ef9457beSDavid Xu if (tmp >= num) 1483ef9457beSDavid Xu break; 1484ef9457beSDavid Xu buf[tmp++] = td2->td_tid; 1485ef9457beSDavid Xu } 1486ef9457beSDavid Xu PROC_UNLOCK(p); 1487ef9457beSDavid Xu error = copyout(buf, addr, tmp * sizeof(lwpid_t)); 1488ef9457beSDavid Xu free(buf, M_TEMP); 1489ef9457beSDavid Xu if (!error) 1490f51bf07aSTom Rhodes td->td_retval[0] = tmp; 149106ad42b2SJohn Baldwin PROC_LOCK(p); 149206ad42b2SJohn Baldwin break; 1493ef9457beSDavid Xu 149490b4621aSMarcel Moolenaar case PT_VM_TIMESTAMP: 1495515b7a0bSJohn Baldwin CTR2(KTR_PTRACE, "PT_VM_TIMESTAMP: pid %d: timestamp %d", 1496515b7a0bSJohn Baldwin p->p_pid, p->p_vmspace->vm_map.timestamp); 149790b4621aSMarcel Moolenaar td->td_retval[0] = p->p_vmspace->vm_map.timestamp; 149890b4621aSMarcel Moolenaar break; 149990b4621aSMarcel Moolenaar 150090b4621aSMarcel Moolenaar case PT_VM_ENTRY: 150190b4621aSMarcel Moolenaar PROC_UNLOCK(p); 1502841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32 150316211027SMarcel Moolenaar if (wrap32) 150416211027SMarcel Moolenaar error = ptrace_vm_entry32(td, p, addr); 150516211027SMarcel Moolenaar else 150616211027SMarcel Moolenaar #endif 150790b4621aSMarcel Moolenaar error = ptrace_vm_entry(td, p, addr); 150890b4621aSMarcel Moolenaar PROC_LOCK(p); 150990b4621aSMarcel Moolenaar break; 151090b4621aSMarcel Moolenaar 15114e68ceabSDavid Greenman default: 15121c843354SMarcel Moolenaar #ifdef __HAVE_PTRACE_MACHDEP 15131c843354SMarcel Moolenaar if (req >= PT_FIRSTMACH) { 15141c843354SMarcel Moolenaar PROC_UNLOCK(p); 15158ac61436SJohn Baldwin error = cpu_ptrace(td2, req, addr, data); 151606ad42b2SJohn Baldwin PROC_LOCK(p); 151706ad42b2SJohn Baldwin } else 15181c843354SMarcel Moolenaar #endif 151906ad42b2SJohn Baldwin /* Unknown request. */ 152006ad42b2SJohn Baldwin error = EINVAL; 15214e68ceabSDavid Greenman break; 15224e68ceabSDavid Greenman } 15234e68ceabSDavid Greenman 152406ad42b2SJohn Baldwin out: 152506ad42b2SJohn Baldwin /* Drop our hold on this process now that the request has completed. */ 152606ad42b2SJohn Baldwin _PRELE(p); 15276871a6c8SJohn Baldwin fail: 15286871a6c8SJohn Baldwin PROC_UNLOCK(p); 15296871a6c8SJohn Baldwin if (proctree_locked) 15306871a6c8SJohn Baldwin sx_xunlock(&proctree_lock); 15316871a6c8SJohn Baldwin return (error); 1532df8bae1dSRodney W. Grimes } 153362919d78SPeter Wemm #undef PROC_READ 153462919d78SPeter Wemm #undef PROC_WRITE 1535df8bae1dSRodney W. Grimes 15362a024a2bSSean Eric Fagan /* 15373da32491SDag-Erling Smørgrav * Stop a process because of a debugging event; 15382a024a2bSSean Eric Fagan * stay stopped until p->p_step is cleared 15392a024a2bSSean Eric Fagan * (cleared by PIOCCONT in procfs). 15402a024a2bSSean Eric Fagan */ 15412a024a2bSSean Eric Fagan void 15423da32491SDag-Erling Smørgrav stopevent(struct proc *p, unsigned int event, unsigned int val) 15433897ca7cSJohn Baldwin { 15443897ca7cSJohn Baldwin 1545b68e0849SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 15462a024a2bSSean Eric Fagan p->p_step = 1; 1547515b7a0bSJohn Baldwin CTR3(KTR_PTRACE, "stopevent: pid %d event %u val %u", p->p_pid, event, 1548515b7a0bSJohn Baldwin val); 15492a024a2bSSean Eric Fagan do { 1550b4490c6eSKonstantin Belousov if (event != S_EXIT) 1551b4490c6eSKonstantin Belousov p->p_xsig = val; 1552ef9457beSDavid Xu p->p_xthread = NULL; 15532a024a2bSSean Eric Fagan p->p_stype = event; /* Which event caused the stop? */ 15542a024a2bSSean Eric Fagan wakeup(&p->p_stype); /* Wake up any PIOCWAIT'ing procs */ 15553897ca7cSJohn Baldwin msleep(&p->p_step, &p->p_mtx, PWAIT, "stopevent", 0); 15562a024a2bSSean Eric Fagan } while (p->p_step); 15572a024a2bSSean Eric Fagan } 1558