Home | History | Annotate | Line # | Download | only in procfs
procfs_mem.c revision 1.11.10.2
      1  1.11.10.2   thorpej /*	$NetBSD: procfs_mem.c,v 1.11.10.2 1997/08/28 00:21:47 thorpej Exp $	*/
      2        1.6       cgd 
      3        1.1       cgd /*
      4        1.1       cgd  * Copyright (c) 1993 Jan-Simon Pendry
      5        1.4   mycroft  * Copyright (c) 1993 Sean Eric Fagan
      6        1.4   mycroft  * Copyright (c) 1993
      7        1.4   mycroft  *	The Regents of the University of California.  All rights reserved.
      8        1.1       cgd  *
      9        1.1       cgd  * This code is derived from software contributed to Berkeley by
     10        1.4   mycroft  * Jan-Simon Pendry and Sean Eric Fagan.
     11        1.1       cgd  *
     12        1.1       cgd  * Redistribution and use in source and binary forms, with or without
     13        1.1       cgd  * modification, are permitted provided that the following conditions
     14        1.1       cgd  * are met:
     15        1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     16        1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     17        1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     18        1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     19        1.1       cgd  *    documentation and/or other materials provided with the distribution.
     20        1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     21        1.1       cgd  *    must display the following acknowledgement:
     22        1.1       cgd  *	This product includes software developed by the University of
     23        1.1       cgd  *	California, Berkeley and its contributors.
     24        1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     25        1.1       cgd  *    may be used to endorse or promote products derived from this software
     26        1.1       cgd  *    without specific prior written permission.
     27        1.1       cgd  *
     28        1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29        1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30        1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31        1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32        1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33        1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34        1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35        1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36        1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37        1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38        1.1       cgd  * SUCH DAMAGE.
     39        1.1       cgd  *
     40        1.6       cgd  *	@(#)procfs_mem.c	8.5 (Berkeley) 6/15/94
     41        1.1       cgd  */
     42        1.1       cgd 
     43        1.1       cgd /*
     44        1.1       cgd  * This is a lightly hacked and merged version
     45        1.1       cgd  * of sef's pread/pwrite functions
     46        1.1       cgd  */
     47        1.1       cgd 
     48        1.1       cgd #include <sys/param.h>
     49        1.1       cgd #include <sys/systm.h>
     50        1.1       cgd #include <sys/time.h>
     51        1.1       cgd #include <sys/kernel.h>
     52        1.1       cgd #include <sys/proc.h>
     53        1.1       cgd #include <sys/vnode.h>
     54        1.1       cgd #include <miscfs/procfs/procfs.h>
     55        1.1       cgd #include <vm/vm.h>
     56        1.1       cgd #include <vm/vm_kern.h>
     57        1.1       cgd #include <vm/vm_page.h>
     58        1.1       cgd 
     59  1.11.10.1   thorpej #define	ISSET(t, f)	((t) & (f))
     60  1.11.10.1   thorpej 
     61        1.8  christos static int procfs_rwmem __P((struct proc *, struct uio *));
     62        1.8  christos 
     63        1.1       cgd static int
     64        1.4   mycroft procfs_rwmem(p, uio)
     65        1.1       cgd 	struct proc *p;
     66        1.1       cgd 	struct uio *uio;
     67        1.1       cgd {
     68        1.1       cgd 	int error;
     69        1.1       cgd 	int writing;
     70        1.1       cgd 
     71        1.1       cgd 	writing = uio->uio_rw == UIO_WRITE;
     72        1.1       cgd 
     73        1.1       cgd 	/*
     74        1.1       cgd 	 * Only map in one page at a time.  We don't have to, but it
     75        1.1       cgd 	 * makes things easier.  This way is trivial - right?
     76        1.1       cgd 	 */
     77        1.1       cgd 	do {
     78        1.1       cgd 		vm_map_t map, tmap;
     79        1.1       cgd 		vm_object_t object;
     80        1.1       cgd 		vm_offset_t kva;
     81        1.1       cgd 		vm_offset_t uva;
     82        1.1       cgd 		int page_offset;		/* offset into page */
     83        1.1       cgd 		vm_offset_t pageno;		/* page number */
     84        1.1       cgd 		vm_map_entry_t out_entry;
     85        1.1       cgd 		vm_prot_t out_prot;
     86        1.1       cgd 		vm_page_t m;
     87        1.1       cgd 		boolean_t wired, single_use;
     88        1.1       cgd 		vm_offset_t off;
     89        1.1       cgd 		u_int len;
     90        1.1       cgd 		int fix_prot;
     91        1.1       cgd 
     92        1.1       cgd 		uva = (vm_offset_t) uio->uio_offset;
     93        1.1       cgd 		if (uva > VM_MAXUSER_ADDRESS) {
     94        1.1       cgd 			error = 0;
     95        1.1       cgd 			break;
     96        1.1       cgd 		}
     97        1.1       cgd 
     98        1.1       cgd 		/*
     99        1.1       cgd 		 * Get the page number of this segment.
    100        1.1       cgd 		 */
    101        1.1       cgd 		pageno = trunc_page(uva);
    102        1.1       cgd 		page_offset = uva - pageno;
    103        1.1       cgd 
    104        1.1       cgd 		/*
    105        1.1       cgd 		 * How many bytes to copy
    106        1.1       cgd 		 */
    107        1.1       cgd 		len = min(PAGE_SIZE - page_offset, uio->uio_resid);
    108        1.1       cgd 
    109        1.1       cgd 		/*
    110        1.1       cgd 		 * The map we want...
    111        1.1       cgd 		 */
    112        1.1       cgd 		map = &p->p_vmspace->vm_map;
    113        1.1       cgd 
    114        1.1       cgd 		/*
    115        1.1       cgd 		 * Check the permissions for the area we're interested
    116        1.1       cgd 		 * in.
    117        1.1       cgd 		 */
    118        1.1       cgd 		fix_prot = 0;
    119        1.1       cgd 		if (writing)
    120        1.1       cgd 			fix_prot = !vm_map_check_protection(map, pageno,
    121        1.1       cgd 					pageno + PAGE_SIZE, VM_PROT_WRITE);
    122        1.1       cgd 
    123        1.1       cgd 		if (fix_prot) {
    124        1.1       cgd 			/*
    125        1.1       cgd 			 * If the page is not writable, we make it so.
    126        1.1       cgd 			 * XXX It is possible that a page may *not* be
    127        1.1       cgd 			 * read/executable, if a process changes that!
    128        1.1       cgd 			 * We will assume, for now, that a page is either
    129        1.1       cgd 			 * VM_PROT_ALL, or VM_PROT_READ|VM_PROT_EXECUTE.
    130        1.1       cgd 			 */
    131        1.1       cgd 			error = vm_map_protect(map, pageno,
    132        1.1       cgd 					pageno + PAGE_SIZE, VM_PROT_ALL, 0);
    133        1.1       cgd 			if (error)
    134        1.1       cgd 				break;
    135        1.1       cgd 		}
    136        1.1       cgd 
    137        1.1       cgd 		/*
    138        1.1       cgd 		 * Now we need to get the page.  out_entry, out_prot, wired,
    139        1.1       cgd 		 * and single_use aren't used.  One would think the vm code
    140        1.1       cgd 		 * would be a *bit* nicer...  We use tmap because
    141        1.1       cgd 		 * vm_map_lookup() can change the map argument.
    142        1.1       cgd 		 */
    143        1.1       cgd 		tmap = map;
    144        1.1       cgd 		error = vm_map_lookup(&tmap, pageno,
    145        1.1       cgd 				      writing ? VM_PROT_WRITE : VM_PROT_READ,
    146        1.1       cgd 				      &out_entry, &object, &off, &out_prot,
    147        1.1       cgd 				      &wired, &single_use);
    148        1.1       cgd 		/*
    149        1.1       cgd 		 * We're done with tmap now.
    150        1.1       cgd 		 */
    151        1.1       cgd 		if (!error)
    152        1.1       cgd 			vm_map_lookup_done(tmap, out_entry);
    153        1.1       cgd 
    154        1.1       cgd 		/*
    155        1.1       cgd 		 * Fault the page in...
    156        1.1       cgd 		 */
    157        1.1       cgd 		if (!error && writing && object->shadow) {
    158        1.1       cgd 			m = vm_page_lookup(object, off);
    159        1.3    briggs 			if (m == 0 || (m->flags & PG_COPYONWRITE))
    160        1.1       cgd 				error = vm_fault(map, pageno,
    161        1.1       cgd 							VM_PROT_WRITE, FALSE);
    162        1.1       cgd 		}
    163        1.1       cgd 
    164        1.1       cgd 		/* Find space in kernel_map for the page we're interested in */
    165        1.7    chopps 		if (!error) {
    166        1.7    chopps 			kva = VM_MIN_KERNEL_ADDRESS;
    167        1.1       cgd 			error = vm_map_find(kernel_map, object, off, &kva,
    168        1.1       cgd 					PAGE_SIZE, 1);
    169        1.7    chopps 		}
    170        1.1       cgd 
    171        1.1       cgd 		if (!error) {
    172        1.1       cgd 			/*
    173        1.1       cgd 			 * Neither vm_map_lookup() nor vm_map_find() appear
    174        1.1       cgd 			 * to add a reference count to the object, so we do
    175        1.1       cgd 			 * that here and now.
    176        1.1       cgd 			 */
    177        1.1       cgd 			vm_object_reference(object);
    178        1.1       cgd 
    179        1.1       cgd 			/*
    180        1.1       cgd 			 * Mark the page we just found as pageable.
    181        1.1       cgd 			 */
    182        1.1       cgd 			error = vm_map_pageable(kernel_map, kva,
    183        1.1       cgd 				kva + PAGE_SIZE, 0);
    184        1.1       cgd 
    185        1.1       cgd 			/*
    186        1.1       cgd 			 * Now do the i/o move.
    187        1.1       cgd 			 */
    188        1.1       cgd 			if (!error)
    189        1.8  christos 				error = uiomove((caddr_t) (kva + page_offset),
    190        1.8  christos 						len, uio);
    191        1.1       cgd 
    192        1.1       cgd 			vm_map_remove(kernel_map, kva, kva + PAGE_SIZE);
    193        1.1       cgd 		}
    194        1.1       cgd 		if (fix_prot)
    195        1.1       cgd 			vm_map_protect(map, pageno, pageno + PAGE_SIZE,
    196        1.1       cgd 					VM_PROT_READ|VM_PROT_EXECUTE, 0);
    197        1.1       cgd 	} while (error == 0 && uio->uio_resid > 0);
    198        1.1       cgd 
    199        1.1       cgd 	return (error);
    200        1.1       cgd }
    201        1.1       cgd 
    202        1.1       cgd /*
    203        1.1       cgd  * Copy data in and out of the target process.
    204        1.1       cgd  * We do this by mapping the process's page into
    205        1.1       cgd  * the kernel and then doing a uiomove direct
    206        1.1       cgd  * from the kernel address space.
    207        1.1       cgd  */
    208        1.4   mycroft int
    209        1.4   mycroft procfs_domem(curp, p, pfs, uio)
    210  1.11.10.2   thorpej 	struct proc *curp;		/* tracer */
    211  1.11.10.2   thorpej 	struct proc *p;			/* traced */
    212        1.1       cgd 	struct pfsnode *pfs;
    213        1.1       cgd 	struct uio *uio;
    214        1.1       cgd {
    215        1.9   mycroft 	int error;
    216        1.1       cgd 
    217        1.1       cgd 	if (uio->uio_resid == 0)
    218        1.1       cgd 		return (0);
    219        1.1       cgd 
    220  1.11.10.1   thorpej 	if ((error = procfs_checkioperm(curp, p)) != 0)
    221  1.11.10.1   thorpej 		return (error);
    222  1.11.10.1   thorpej 
    223        1.9   mycroft 	PHOLD(p);
    224        1.9   mycroft 	error = procfs_rwmem(p, uio);
    225        1.9   mycroft 	PRELE(p);
    226        1.9   mycroft 	return (error);
    227        1.1       cgd }
    228        1.1       cgd 
    229        1.1       cgd /*
    230        1.1       cgd  * Given process (p), find the vnode from which
    231        1.1       cgd  * it's text segment is being executed.
    232        1.1       cgd  *
    233        1.1       cgd  * It would be nice to grab this information from
    234        1.1       cgd  * the VM system, however, there is no sure-fire
    235        1.1       cgd  * way of doing that.  Instead, fork(), exec() and
    236        1.1       cgd  * wait() all maintain the p_textvp field in the
    237        1.1       cgd  * process proc structure which contains a held
    238        1.1       cgd  * reference to the exec'ed vnode.
    239        1.1       cgd  */
    240        1.1       cgd struct vnode *
    241        1.1       cgd procfs_findtextvp(p)
    242        1.1       cgd 	struct proc *p;
    243        1.1       cgd {
    244        1.4   mycroft 
    245        1.1       cgd 	return (p->p_textvp);
    246        1.1       cgd }
    247        1.1       cgd 
    248  1.11.10.2   thorpej /*
    249  1.11.10.2   thorpej  * Ensure that a process has permission to perform I/O on another.
    250  1.11.10.2   thorpej  * Arguments:
    251  1.11.10.2   thorpej  *	p	The process wishing to do the I/O (the tracer).
    252  1.11.10.2   thorpej  *	t	The process who's memory/registers will be read/written.
    253  1.11.10.2   thorpej  */
    254  1.11.10.1   thorpej int
    255  1.11.10.2   thorpej procfs_checkioperm(p, t)
    256  1.11.10.2   thorpej 	struct proc *p, *t;
    257  1.11.10.1   thorpej {
    258  1.11.10.1   thorpej 	int error;
    259  1.11.10.1   thorpej 
    260  1.11.10.1   thorpej 	/*
    261  1.11.10.1   thorpej 	 * You cannot attach to a processes mem/regs if:
    262  1.11.10.1   thorpej 	 *
    263  1.11.10.1   thorpej 	 *	(1) it's not owned by you, or is set-id on exec
    264  1.11.10.1   thorpej 	 *	    (unless you're root), or...
    265  1.11.10.1   thorpej 	 */
    266  1.11.10.1   thorpej 	if ((t->p_cred->p_ruid != p->p_cred->p_ruid ||
    267  1.11.10.1   thorpej 	    ISSET(t->p_flag, P_SUGID)) &&
    268  1.11.10.1   thorpej 	    (error = suser(p->p_ucred, &p->p_acflag)) != 0)
    269  1.11.10.1   thorpej 		return (error);
    270  1.11.10.1   thorpej 
    271  1.11.10.1   thorpej 	/*
    272  1.11.10.1   thorpej 	 *	(2) ...it's init, which controls the security level
    273  1.11.10.1   thorpej 	 *	    of the entire system, and the system was not
    274  1.11.10.1   thorpej 	 *	    compiled with permanetly insecure mode turned on.
    275  1.11.10.1   thorpej 	 */
    276  1.11.10.1   thorpej 	if (t == initproc && securelevel > -1)
    277  1.11.10.1   thorpej 		return (EPERM);
    278  1.11.10.1   thorpej 
    279  1.11.10.1   thorpej 	return (0);
    280  1.11.10.1   thorpej }
    281        1.1       cgd 
    282        1.1       cgd #ifdef probably_never
    283        1.1       cgd /*
    284        1.1       cgd  * Given process (p), find the vnode from which
    285        1.1       cgd  * it's text segment is being mapped.
    286        1.1       cgd  *
    287        1.1       cgd  * (This is here, rather than in procfs_subr in order
    288        1.1       cgd  * to keep all the VM related code in one place.)
    289        1.1       cgd  */
    290        1.1       cgd struct vnode *
    291        1.1       cgd procfs_findtextvp(p)
    292        1.1       cgd 	struct proc *p;
    293        1.1       cgd {
    294        1.1       cgd 	int error;
    295        1.1       cgd 	vm_object_t object;
    296        1.1       cgd 	vm_offset_t pageno;		/* page number */
    297        1.1       cgd 
    298        1.1       cgd 	/* find a vnode pager for the user address space */
    299        1.1       cgd 
    300        1.1       cgd 	for (pageno = VM_MIN_ADDRESS;
    301        1.1       cgd 			pageno < VM_MAXUSER_ADDRESS;
    302        1.1       cgd 			pageno += PAGE_SIZE) {
    303        1.1       cgd 		vm_map_t map;
    304        1.1       cgd 		vm_map_entry_t out_entry;
    305        1.1       cgd 		vm_prot_t out_prot;
    306        1.1       cgd 		boolean_t wired, single_use;
    307        1.1       cgd 		vm_offset_t off;
    308        1.1       cgd 
    309        1.1       cgd 		map = &p->p_vmspace->vm_map;
    310        1.1       cgd 		error = vm_map_lookup(&map, pageno,
    311        1.1       cgd 			      VM_PROT_READ,
    312        1.1       cgd 			      &out_entry, &object, &off, &out_prot,
    313        1.1       cgd 			      &wired, &single_use);
    314        1.1       cgd 
    315        1.1       cgd 		if (!error) {
    316        1.1       cgd 			vm_pager_t pager;
    317        1.1       cgd 
    318       1.11  christos 			printf("procfs: found vm object\n");
    319        1.1       cgd 			vm_map_lookup_done(map, out_entry);
    320       1.11  christos 			printf("procfs: vm object = %x\n", object);
    321        1.1       cgd 
    322        1.1       cgd 			/*
    323        1.1       cgd 			 * At this point, assuming no errors, object
    324        1.1       cgd 			 * is the VM object mapping UVA (pageno).
    325        1.1       cgd 			 * Ensure it has a vnode pager, then grab
    326        1.1       cgd 			 * the vnode from that pager's handle.
    327        1.1       cgd 			 */
    328        1.1       cgd 
    329        1.1       cgd 			pager = object->pager;
    330       1.11  christos 			printf("procfs: pager = %x\n", pager);
    331        1.1       cgd 			if (pager)
    332       1.11  christos 				printf("procfs: found pager, type = %d\n",
    333       1.10  christos 				    pager->pg_type);
    334        1.1       cgd 			if (pager && pager->pg_type == PG_VNODE) {
    335        1.1       cgd 				struct vnode *vp;
    336        1.1       cgd 
    337        1.1       cgd 				vp = (struct vnode *) pager->pg_handle;
    338       1.11  christos 				printf("procfs: vp = 0x%x\n", vp);
    339        1.1       cgd 				return (vp);
    340        1.1       cgd 			}
    341        1.1       cgd 		}
    342        1.1       cgd 	}
    343        1.1       cgd 
    344       1.11  christos 	printf("procfs: text object not found\n");
    345        1.1       cgd 	return (0);
    346        1.1       cgd }
    347        1.4   mycroft #endif /* probably_never */
    348