Home | History | Annotate | Line # | Download | only in procfs
procfs_mem.c revision 1.8.4.1
      1  1.8.4.1   mycroft /*	$NetBSD: procfs_mem.c,v 1.8.4.1 1996/12/10 04:37:43 mycroft 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.8  christos static int procfs_rwmem __P((struct proc *, struct uio *));
     60      1.8  christos 
     61      1.1       cgd static int
     62      1.4   mycroft procfs_rwmem(p, uio)
     63      1.1       cgd 	struct proc *p;
     64      1.1       cgd 	struct uio *uio;
     65      1.1       cgd {
     66      1.1       cgd 	int error;
     67      1.1       cgd 	int writing;
     68      1.1       cgd 
     69      1.1       cgd 	writing = uio->uio_rw == UIO_WRITE;
     70      1.1       cgd 
     71      1.1       cgd 	/*
     72      1.1       cgd 	 * Only map in one page at a time.  We don't have to, but it
     73      1.1       cgd 	 * makes things easier.  This way is trivial - right?
     74      1.1       cgd 	 */
     75      1.1       cgd 	do {
     76      1.1       cgd 		vm_map_t map, tmap;
     77      1.1       cgd 		vm_object_t object;
     78      1.1       cgd 		vm_offset_t kva;
     79      1.1       cgd 		vm_offset_t uva;
     80      1.1       cgd 		int page_offset;		/* offset into page */
     81      1.1       cgd 		vm_offset_t pageno;		/* page number */
     82      1.1       cgd 		vm_map_entry_t out_entry;
     83      1.1       cgd 		vm_prot_t out_prot;
     84      1.1       cgd 		vm_page_t m;
     85      1.1       cgd 		boolean_t wired, single_use;
     86      1.1       cgd 		vm_offset_t off;
     87      1.1       cgd 		u_int len;
     88      1.1       cgd 		int fix_prot;
     89      1.1       cgd 
     90      1.1       cgd 		uva = (vm_offset_t) uio->uio_offset;
     91      1.1       cgd 		if (uva > VM_MAXUSER_ADDRESS) {
     92      1.1       cgd 			error = 0;
     93      1.1       cgd 			break;
     94      1.1       cgd 		}
     95      1.1       cgd 
     96      1.1       cgd 		/*
     97      1.1       cgd 		 * Get the page number of this segment.
     98      1.1       cgd 		 */
     99      1.1       cgd 		pageno = trunc_page(uva);
    100      1.1       cgd 		page_offset = uva - pageno;
    101      1.1       cgd 
    102      1.1       cgd 		/*
    103      1.1       cgd 		 * How many bytes to copy
    104      1.1       cgd 		 */
    105      1.1       cgd 		len = min(PAGE_SIZE - page_offset, uio->uio_resid);
    106      1.1       cgd 
    107      1.1       cgd 		/*
    108      1.1       cgd 		 * The map we want...
    109      1.1       cgd 		 */
    110      1.1       cgd 		map = &p->p_vmspace->vm_map;
    111      1.1       cgd 
    112      1.1       cgd 		/*
    113      1.1       cgd 		 * Check the permissions for the area we're interested
    114      1.1       cgd 		 * in.
    115      1.1       cgd 		 */
    116      1.1       cgd 		fix_prot = 0;
    117      1.1       cgd 		if (writing)
    118      1.1       cgd 			fix_prot = !vm_map_check_protection(map, pageno,
    119      1.1       cgd 					pageno + PAGE_SIZE, VM_PROT_WRITE);
    120      1.1       cgd 
    121      1.1       cgd 		if (fix_prot) {
    122      1.1       cgd 			/*
    123      1.1       cgd 			 * If the page is not writable, we make it so.
    124      1.1       cgd 			 * XXX It is possible that a page may *not* be
    125      1.1       cgd 			 * read/executable, if a process changes that!
    126      1.1       cgd 			 * We will assume, for now, that a page is either
    127      1.1       cgd 			 * VM_PROT_ALL, or VM_PROT_READ|VM_PROT_EXECUTE.
    128      1.1       cgd 			 */
    129      1.1       cgd 			error = vm_map_protect(map, pageno,
    130      1.1       cgd 					pageno + PAGE_SIZE, VM_PROT_ALL, 0);
    131      1.1       cgd 			if (error)
    132      1.1       cgd 				break;
    133      1.1       cgd 		}
    134      1.1       cgd 
    135      1.1       cgd 		/*
    136      1.1       cgd 		 * Now we need to get the page.  out_entry, out_prot, wired,
    137      1.1       cgd 		 * and single_use aren't used.  One would think the vm code
    138      1.1       cgd 		 * would be a *bit* nicer...  We use tmap because
    139      1.1       cgd 		 * vm_map_lookup() can change the map argument.
    140      1.1       cgd 		 */
    141      1.1       cgd 		tmap = map;
    142      1.1       cgd 		error = vm_map_lookup(&tmap, pageno,
    143      1.1       cgd 				      writing ? VM_PROT_WRITE : VM_PROT_READ,
    144      1.1       cgd 				      &out_entry, &object, &off, &out_prot,
    145      1.1       cgd 				      &wired, &single_use);
    146      1.1       cgd 		/*
    147      1.1       cgd 		 * We're done with tmap now.
    148      1.1       cgd 		 */
    149      1.1       cgd 		if (!error)
    150      1.1       cgd 			vm_map_lookup_done(tmap, out_entry);
    151      1.1       cgd 
    152      1.1       cgd 		/*
    153      1.1       cgd 		 * Fault the page in...
    154      1.1       cgd 		 */
    155      1.1       cgd 		if (!error && writing && object->shadow) {
    156      1.1       cgd 			m = vm_page_lookup(object, off);
    157      1.3    briggs 			if (m == 0 || (m->flags & PG_COPYONWRITE))
    158      1.1       cgd 				error = vm_fault(map, pageno,
    159      1.1       cgd 							VM_PROT_WRITE, FALSE);
    160      1.1       cgd 		}
    161      1.1       cgd 
    162      1.1       cgd 		/* Find space in kernel_map for the page we're interested in */
    163      1.7    chopps 		if (!error) {
    164      1.7    chopps 			kva = VM_MIN_KERNEL_ADDRESS;
    165      1.1       cgd 			error = vm_map_find(kernel_map, object, off, &kva,
    166      1.1       cgd 					PAGE_SIZE, 1);
    167      1.7    chopps 		}
    168      1.1       cgd 
    169      1.1       cgd 		if (!error) {
    170      1.1       cgd 			/*
    171      1.1       cgd 			 * Neither vm_map_lookup() nor vm_map_find() appear
    172      1.1       cgd 			 * to add a reference count to the object, so we do
    173      1.1       cgd 			 * that here and now.
    174      1.1       cgd 			 */
    175      1.1       cgd 			vm_object_reference(object);
    176      1.1       cgd 
    177      1.1       cgd 			/*
    178      1.1       cgd 			 * Mark the page we just found as pageable.
    179      1.1       cgd 			 */
    180      1.1       cgd 			error = vm_map_pageable(kernel_map, kva,
    181      1.1       cgd 				kva + PAGE_SIZE, 0);
    182      1.1       cgd 
    183      1.1       cgd 			/*
    184      1.1       cgd 			 * Now do the i/o move.
    185      1.1       cgd 			 */
    186      1.1       cgd 			if (!error)
    187      1.8  christos 				error = uiomove((caddr_t) (kva + page_offset),
    188      1.8  christos 						len, uio);
    189      1.1       cgd 
    190      1.1       cgd 			vm_map_remove(kernel_map, kva, kva + PAGE_SIZE);
    191      1.1       cgd 		}
    192      1.1       cgd 		if (fix_prot)
    193      1.1       cgd 			vm_map_protect(map, pageno, pageno + PAGE_SIZE,
    194      1.1       cgd 					VM_PROT_READ|VM_PROT_EXECUTE, 0);
    195      1.1       cgd 	} while (error == 0 && uio->uio_resid > 0);
    196      1.1       cgd 
    197      1.1       cgd 	return (error);
    198      1.1       cgd }
    199      1.1       cgd 
    200      1.1       cgd /*
    201      1.1       cgd  * Copy data in and out of the target process.
    202      1.1       cgd  * We do this by mapping the process's page into
    203      1.1       cgd  * the kernel and then doing a uiomove direct
    204      1.1       cgd  * from the kernel address space.
    205      1.1       cgd  */
    206      1.4   mycroft int
    207      1.4   mycroft procfs_domem(curp, p, pfs, uio)
    208      1.1       cgd 	struct proc *curp;
    209      1.1       cgd 	struct proc *p;
    210      1.1       cgd 	struct pfsnode *pfs;
    211      1.1       cgd 	struct uio *uio;
    212      1.1       cgd {
    213  1.8.4.1   mycroft 	int error;
    214      1.1       cgd 
    215      1.1       cgd 	if (uio->uio_resid == 0)
    216      1.1       cgd 		return (0);
    217      1.1       cgd 
    218  1.8.4.1   mycroft 	PHOLD(p);
    219  1.8.4.1   mycroft 	error = procfs_rwmem(p, uio);
    220  1.8.4.1   mycroft 	PRELE(p);
    221  1.8.4.1   mycroft 	return (error);
    222      1.1       cgd }
    223      1.1       cgd 
    224      1.1       cgd /*
    225      1.1       cgd  * Given process (p), find the vnode from which
    226      1.1       cgd  * it's text segment is being executed.
    227      1.1       cgd  *
    228      1.1       cgd  * It would be nice to grab this information from
    229      1.1       cgd  * the VM system, however, there is no sure-fire
    230      1.1       cgd  * way of doing that.  Instead, fork(), exec() and
    231      1.1       cgd  * wait() all maintain the p_textvp field in the
    232      1.1       cgd  * process proc structure which contains a held
    233      1.1       cgd  * reference to the exec'ed vnode.
    234      1.1       cgd  */
    235      1.1       cgd struct vnode *
    236      1.1       cgd procfs_findtextvp(p)
    237      1.1       cgd 	struct proc *p;
    238      1.1       cgd {
    239      1.4   mycroft 
    240      1.1       cgd 	return (p->p_textvp);
    241      1.1       cgd }
    242      1.1       cgd 
    243      1.1       cgd 
    244      1.1       cgd #ifdef probably_never
    245      1.1       cgd /*
    246      1.1       cgd  * Given process (p), find the vnode from which
    247      1.1       cgd  * it's text segment is being mapped.
    248      1.1       cgd  *
    249      1.1       cgd  * (This is here, rather than in procfs_subr in order
    250      1.1       cgd  * to keep all the VM related code in one place.)
    251      1.1       cgd  */
    252      1.1       cgd struct vnode *
    253      1.1       cgd procfs_findtextvp(p)
    254      1.1       cgd 	struct proc *p;
    255      1.1       cgd {
    256      1.1       cgd 	int error;
    257      1.1       cgd 	vm_object_t object;
    258      1.1       cgd 	vm_offset_t pageno;		/* page number */
    259      1.1       cgd 
    260      1.1       cgd 	/* find a vnode pager for the user address space */
    261      1.1       cgd 
    262      1.1       cgd 	for (pageno = VM_MIN_ADDRESS;
    263      1.1       cgd 			pageno < VM_MAXUSER_ADDRESS;
    264      1.1       cgd 			pageno += PAGE_SIZE) {
    265      1.1       cgd 		vm_map_t map;
    266      1.1       cgd 		vm_map_entry_t out_entry;
    267      1.1       cgd 		vm_prot_t out_prot;
    268      1.1       cgd 		boolean_t wired, single_use;
    269      1.1       cgd 		vm_offset_t off;
    270      1.1       cgd 
    271      1.1       cgd 		map = &p->p_vmspace->vm_map;
    272      1.1       cgd 		error = vm_map_lookup(&map, pageno,
    273      1.1       cgd 			      VM_PROT_READ,
    274      1.1       cgd 			      &out_entry, &object, &off, &out_prot,
    275      1.1       cgd 			      &wired, &single_use);
    276      1.1       cgd 
    277      1.1       cgd 		if (!error) {
    278      1.1       cgd 			vm_pager_t pager;
    279      1.1       cgd 
    280      1.4   mycroft 			printf("procfs: found vm object\n");
    281      1.1       cgd 			vm_map_lookup_done(map, out_entry);
    282      1.4   mycroft 			printf("procfs: vm object = %x\n", object);
    283      1.1       cgd 
    284      1.1       cgd 			/*
    285      1.1       cgd 			 * At this point, assuming no errors, object
    286      1.1       cgd 			 * is the VM object mapping UVA (pageno).
    287      1.1       cgd 			 * Ensure it has a vnode pager, then grab
    288      1.1       cgd 			 * the vnode from that pager's handle.
    289      1.1       cgd 			 */
    290      1.1       cgd 
    291      1.1       cgd 			pager = object->pager;
    292      1.1       cgd 			printf("procfs: pager = %x\n", pager);
    293      1.1       cgd 			if (pager)
    294      1.1       cgd 				printf("procfs: found pager, type = %d\n", pager->pg_type);
    295      1.1       cgd 			if (pager && pager->pg_type == PG_VNODE) {
    296      1.1       cgd 				struct vnode *vp;
    297      1.1       cgd 
    298      1.1       cgd 				vp = (struct vnode *) pager->pg_handle;
    299      1.1       cgd 				printf("procfs: vp = 0x%x\n", vp);
    300      1.1       cgd 				return (vp);
    301      1.1       cgd 			}
    302      1.1       cgd 		}
    303      1.1       cgd 	}
    304      1.1       cgd 
    305      1.4   mycroft 	printf("procfs: text object not found\n");
    306      1.1       cgd 	return (0);
    307      1.1       cgd }
    308      1.4   mycroft #endif /* probably_never */
    309