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