xref: /freebsd/sys/kern/sys_process.c (revision 32451fb9fc71518dd5cf58a06d217eaa777e0206)
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