[dragonfly.git] / sys / vfs / procfs / procfs_mem.c

/*
 * Copyright (c) 1993 Jan-Simon Pendry
 * Copyright (c) 1993 Sean Eric Fagan
 * Copyright (c) 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Jan-Simon Pendry and Sean Eric Fagan.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)procfs_mem.c	8.5 (Berkeley) 6/15/94
 *
 * $FreeBSD: src/sys/miscfs/procfs/procfs_mem.c,v 1.46.2.3 2002/01/22 17:22:59 nectar Exp $
 * $DragonFly: src/sys/vfs/procfs/procfs_mem.c,v 1.16 2007/04/29 18:25:40 dillon Exp $
 */

/*
 * This is a lightly hacked and merged version
 * of sef's pread/pwrite functions
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/priv.h>
#include <sys/vnode.h>
#include <vfs/procfs/procfs.h>
#include <vm/vm.h>
#include <vm/vm_param.h>
#include <sys/lock.h>
#include <vm/pmap.h>
#include <vm/vm_extern.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <sys/user.h>
#include <sys/ptrace.h>

#include <sys/thread2.h>
#include <sys/sysref2.h>

static int	procfs_rwmem (struct proc *curp,
				  struct proc *p, struct uio *uio);

static int
procfs_rwmem(struct proc *curp, struct proc *p, struct uio *uio)
{
	int error;
	int writing;
	struct vmspace *vm;
	vm_map_t map;
	vm_offset_t pageno = 0;		/* page number */
	vm_prot_t reqprot;
	vm_offset_t kva;

	/*
	 * if the vmspace is in the midst of being allocated or deallocated,
	 * or the process is exiting, don't try to grab anything.  The
	 * page table usage in that process may be messed up.
	 */
	vm = p->p_vmspace;
	sysref_get(&vm->vm_sysref);
	if ((p->p_flag & P_WEXIT) || sysref_isinactive(&vm->vm_sysref)) {
		sysref_put(&vm->vm_sysref);
		return EFAULT;
	}

	/*
	 * The map we want...
	 */
	map = &vm->vm_map;

	writing = uio->uio_rw == UIO_WRITE;
	reqprot = VM_PROT_READ;
	if (writing)
		reqprot |= VM_PROT_WRITE | VM_PROT_OVERRIDE_WRITE;

	kva = kmem_alloc_pageable(&kernel_map, PAGE_SIZE);

	/*
	 * Only map in one page at a time.  We don't have to, but it
	 * makes things easier.  This way is trivial - right?
	 */
	do {
		vm_offset_t uva;
		int page_offset;		/* offset into page */
		u_int len;
		vm_page_t m;

		uva = (vm_offset_t) uio->uio_offset;

		/*
		 * Get the page number of this segment.
		 */
		pageno = trunc_page(uva);
		page_offset = uva - pageno;

		/*
		 * How many bytes to copy
		 */
		len = szmin(PAGE_SIZE - page_offset, uio->uio_resid);

		/*
		 * Fault the page on behalf of the process
		 */
		m = vm_fault_page(map, pageno, reqprot,
				  VM_FAULT_NORMAL, &error);
		if (error) {
			KKASSERT(m == NULL);
			error = EFAULT;
			break;
		}

		/*
		 * Cleanup tmap then create a temporary KVA mapping and
		 * do the I/O.
		 */
		pmap_kenter(kva, VM_PAGE_TO_PHYS(m));
		error = uiomove((caddr_t)(kva + page_offset), len, uio);
		pmap_kremove(kva);

		/*
		 * release the page and we are done
		 */
		crit_enter();
		vm_page_unhold(m);
		crit_exit();
	} while (error == 0 && uio->uio_resid > 0);

	kmem_free(&kernel_map, kva, PAGE_SIZE);
	sysref_put(&vm->vm_sysref);
	return (error);
}

/*
 * Copy data in and out of the target process.
 * We do this by mapping the process's page into
 * the kernel and then doing a uiomove direct
 * from the kernel address space.
 */
int
procfs_domem(struct proc *curp, struct lwp *lp, struct pfsnode *pfs,
	     struct uio *uio)
{
	struct proc *p = lp->lwp_proc;

	if (uio->uio_resid == 0)
		return (0);

	/* Can't trace a process that's currently exec'ing. */ 
	if ((p->p_flag & P_INEXEC) != 0)
		return EAGAIN;
 	if (!CHECKIO(curp, p) || p_trespass(curp->p_ucred, p->p_ucred))
 		return EPERM;

	return (procfs_rwmem(curp, p, uio));
}

/*
 * Given process (p), find the vnode from which
 * its text segment is being executed.
 *
 * It would be nice to grab this information from
 * the VM system, however, there is no sure-fire
 * way of doing that.  Instead, fork(), exec() and
 * wait() all maintain the p_textvp field in the
 * process proc structure which contains a held
 * reference to the exec'ed vnode.
 *
 * XXX - Currently, this is not not used, as the
 * /proc/pid/file object exposes an information leak
 * that shouldn't happen.  Using a mount option would
 * make it configurable on a per-system (or, at least,
 * per-mount) basis; however, that's not really best.
 * The best way to do it, I think, would be as an
 * ioctl; this would restrict it to the uid running
 * program, or root, which seems a reasonable compromise.
 * However, the number of applications for this is
 * minimal, if it can't be seen in the filesytem space,
 * and doint it as an ioctl makes it somewhat less
 * useful due to the, well, inelegance.
 *
 */
struct vnode *
procfs_findtextvp(struct proc *p)
{
	return (p->p_textvp);
}
Commit	Line	Data
984263bc MD	1	/*
	2	* Copyright (c) 1993 Jan-Simon Pendry
	3	* Copyright (c) 1993 Sean Eric Fagan
	4	* Copyright (c) 1993
	5	* The Regents of the University of California. All rights reserved.
	6	*
	7	* This code is derived from software contributed to Berkeley by
	8	* Jan-Simon Pendry and Sean Eric Fagan.
	9	*
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions
	12	* are met:
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	* 3. All advertising materials mentioning features or use of this software
	19	* must display the following acknowledgement:
	20	* This product includes software developed by the University of
	21	* California, Berkeley and its contributors.
	22	* 4. Neither the name of the University nor the names of its contributors
	23	* may be used to endorse or promote products derived from this software
	24	* without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	36	* SUCH DAMAGE.
	37	*
	38	* @(#)procfs_mem.c 8.5 (Berkeley) 6/15/94
	39	*
	40	* $FreeBSD: src/sys/miscfs/procfs/procfs_mem.c,v 1.46.2.3 2002/01/22 17:22:59 nectar Exp $
e3161323	41	* $DragonFly: src/sys/vfs/procfs/procfs_mem.c,v 1.16 2007/04/29 18:25:40 dillon Exp $
984263bc MD	42	*/
	43
	44	/*
	45	* This is a lightly hacked and merged version
	46	* of sef's pread/pwrite functions
	47	*/
	48
	49	#include <sys/param.h>
	50	#include <sys/systm.h>
	51	#include <sys/proc.h>
75bda2d9	52	#include <sys/priv.h>
984263bc	53	#include <sys/vnode.h>
1f2de5d4	54	#include <vfs/procfs/procfs.h>
984263bc MD	55	#include <vm/vm.h>
	56	#include <vm/vm_param.h>
	57	#include <sys/lock.h>
	58	#include <vm/pmap.h>
	59	#include <vm/vm_extern.h>
	60	#include <vm/vm_map.h>
	61	#include <vm/vm_kern.h>
	62	#include <vm/vm_object.h>
	63	#include <vm/vm_page.h>
	64	#include <sys/user.h>
	65	#include <sys/ptrace.h>
	66
654a39f0	67	#include <sys/thread2.h>
e3161323	68	#include <sys/sysref2.h>
654a39f0	69
a6ee311a RG	70	static int procfs_rwmem (struct proc *curp,
a6ee311a RG	71	struct proc p, struct uio uio);
984263bc MD	72
984263bc MD	73	static int
ac424f9b	74	procfs_rwmem(struct proc curp, struct proc p, struct uio *uio)
984263bc MD	75	{
	76	int error;
	77	int writing;
	78	struct vmspace *vm;
	79	vm_map_t map;
984263bc MD	80	vm_offset_t pageno = 0; /* page number */
	81	vm_prot_t reqprot;
	82	vm_offset_t kva;
	83
	84	/*
e3161323 MD	85	* if the vmspace is in the midst of being allocated or deallocated,
	86	* or the process is exiting, don't try to grab anything. The
	87	* page table usage in that process may be messed up.
984263bc MD	88	*/
984263bc MD	89	vm = p->p_vmspace;
e3161323 MD	90	sysref_get(&vm->vm_sysref);
	91	if ((p->p_flag & P_WEXIT) \|\| sysref_isinactive(&vm->vm_sysref)) {
	92	sysref_put(&vm->vm_sysref);
984263bc	93	return EFAULT;
e3161323 MD	94	}
e3161323 MD	95
984263bc MD	96	/*
	97	* The map we want...
	98	*/
	99	map = &vm->vm_map;
	100
	101	writing = uio->uio_rw == UIO_WRITE;
0035dca9 MD	102	reqprot = VM_PROT_READ;
	103	if (writing)
	104	reqprot \|= VM_PROT_WRITE \| VM_PROT_OVERRIDE_WRITE;
984263bc	105
e4846942	106	kva = kmem_alloc_pageable(&kernel_map, PAGE_SIZE);
984263bc MD	107
	108	/*
	109	* Only map in one page at a time. We don't have to, but it
	110	* makes things easier. This way is trivial - right?
	111	*/
	112	do {
984263bc MD	113	vm_offset_t uva;
984263bc MD	114	int page_offset; /* offset into page */
984263bc MD	115	u_int len;
984263bc MD	116	vm_page_t m;
984263bc MD	117
	118	uva = (vm_offset_t) uio->uio_offset;
	119
	120	/*
	121	* Get the page number of this segment.
	122	*/
	123	pageno = trunc_page(uva);
	124	page_offset = uva - pageno;
	125
	126	/*
	127	* How many bytes to copy
	128	*/
e54488bb	129	len = szmin(PAGE_SIZE - page_offset, uio->uio_resid);
984263bc MD	130
	131	/*
	132	* Fault the page on behalf of the process
	133	*/
4e158347 MD	134	m = vm_fault_page(map, pageno, reqprot,
4e158347 MD	135	VM_FAULT_NORMAL, &error);
984263bc	136	if (error) {
4e158347	137	KKASSERT(m == NULL);
06ecca5a	138	error = EFAULT;
984263bc MD	139	break;
	140	}
	141
	142	/*
06ecca5a MD	143	* Cleanup tmap then create a temporary KVA mapping and
06ecca5a MD	144	* do the I/O.
984263bc	145	*/
984263bc	146	pmap_kenter(kva, VM_PAGE_TO_PHYS(m));
984263bc	147	error = uiomove((caddr_t)(kva + page_offset), len, uio);
984263bc MD	148	pmap_kremove(kva);
	149
	150	/*
06ecca5a	151	* release the page and we are done
984263bc	152	*/
654a39f0	153	crit_enter();
b6f5e86b	154	vm_page_unhold(m);
654a39f0	155	crit_exit();
984263bc MD	156	} while (error == 0 && uio->uio_resid > 0);
984263bc MD	157
e4846942	158	kmem_free(&kernel_map, kva, PAGE_SIZE);
e3161323	159	sysref_put(&vm->vm_sysref);
984263bc MD	160	return (error);
	161	}
	162
	163	/*
	164	* Copy data in and out of the target process.
	165	* We do this by mapping the process's page into
	166	* the kernel and then doing a uiomove direct
	167	* from the kernel address space.
	168	*/
	169	int
c7e98b2f	170	procfs_domem(struct proc curp, struct lwp lp, struct pfsnode *pfs,
ac424f9b	171	struct uio *uio)
984263bc	172	{
c7e98b2f SS	173	struct proc *p = lp->lwp_proc;
c7e98b2f SS	174
984263bc MD	175	if (uio->uio_resid == 0)
	176	return (0);
	177
	178	/* Can't trace a process that's currently exec'ing. */
	179	if ((p->p_flag & P_INEXEC) != 0)
	180	return EAGAIN;
41c20dac	181	if (!CHECKIO(curp, p) \|\| p_trespass(curp->p_ucred, p->p_ucred))
984263bc MD	182	return EPERM;
	183
	184	return (procfs_rwmem(curp, p, uio));
	185	}
	186
	187	/*
	188	* Given process (p), find the vnode from which
	189	* its text segment is being executed.
	190	*
	191	* It would be nice to grab this information from
	192	* the VM system, however, there is no sure-fire
	193	* way of doing that. Instead, fork(), exec() and
	194	* wait() all maintain the p_textvp field in the
	195	* process proc structure which contains a held
	196	* reference to the exec'ed vnode.
	197	*
	198	* XXX - Currently, this is not not used, as the
	199	* /proc/pid/file object exposes an information leak
	200	* that shouldn't happen. Using a mount option would
	201	* make it configurable on a per-system (or, at least,
	202	* per-mount) basis; however, that's not really best.
	203	* The best way to do it, I think, would be as an
	204	* ioctl; this would restrict it to the uid running
	205	* program, or root, which seems a reasonable compromise.
	206	* However, the number of applications for this is
	207	* minimal, if it can't be seen in the filesytem space,
	208	* and doint it as an ioctl makes it somewhat less
	209	* useful due to the, well, inelegance.
	210	*
	211	*/
	212	struct vnode *
ac424f9b	213	procfs_findtextvp(struct proc *p)
984263bc	214	{
984263bc MD	215	return (p->p_textvp);
984263bc MD	216	}