Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / sys / vfs / procfs / procfs_mem.c
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 $
41  * $DragonFly: src/sys/vfs/procfs/procfs_mem.c,v 1.2 2003/06/17 04:28:42 dillon Exp $
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>
52 #include <sys/vnode.h>
53 #include <miscfs/procfs/procfs.h>
54 #include <vm/vm.h>
55 #include <vm/vm_param.h>
56 #include <sys/lock.h>
57 #include <vm/pmap.h>
58 #include <vm/vm_extern.h>
59 #include <vm/vm_map.h>
60 #include <vm/vm_kern.h>
61 #include <vm/vm_object.h>
62 #include <vm/vm_page.h>
63 #include <sys/user.h>
64 #include <sys/ptrace.h>
65
66 static int      procfs_rwmem __P((struct proc *curp,
67                                   struct proc *p, struct uio *uio));
68
69 static int
70 procfs_rwmem(curp, p, uio)
71         struct proc *curp;
72         struct proc *p;
73         struct uio *uio;
74 {
75         int error;
76         int writing;
77         struct vmspace *vm;
78         vm_map_t map;
79         vm_object_t object = NULL;
80         vm_offset_t pageno = 0;         /* page number */
81         vm_prot_t reqprot;
82         vm_offset_t kva;
83
84         /*
85          * if the vmspace is in the midst of being deallocated or the
86          * process is exiting, don't try to grab anything.  The page table
87          * usage in that process can be messed up.
88          */
89         vm = p->p_vmspace;
90         if ((p->p_flag & P_WEXIT) || (vm->vm_refcnt < 1))
91                 return EFAULT;
92         ++vm->vm_refcnt;
93         /*
94          * The map we want...
95          */
96         map = &vm->vm_map;
97
98         writing = uio->uio_rw == UIO_WRITE;
99         reqprot = writing ? (VM_PROT_WRITE | VM_PROT_OVERRIDE_WRITE) : VM_PROT_READ;
100
101         kva = kmem_alloc_pageable(kernel_map, PAGE_SIZE);
102
103         /*
104          * Only map in one page at a time.  We don't have to, but it
105          * makes things easier.  This way is trivial - right?
106          */
107         do {
108                 vm_map_t tmap;
109                 vm_offset_t uva;
110                 int page_offset;                /* offset into page */
111                 vm_map_entry_t out_entry;
112                 vm_prot_t out_prot;
113                 boolean_t wired;
114                 vm_pindex_t pindex;
115                 u_int len;
116                 vm_page_t m;
117
118                 object = NULL;
119
120                 uva = (vm_offset_t) uio->uio_offset;
121
122                 /*
123                  * Get the page number of this segment.
124                  */
125                 pageno = trunc_page(uva);
126                 page_offset = uva - pageno;
127
128                 /*
129                  * How many bytes to copy
130                  */
131                 len = min(PAGE_SIZE - page_offset, uio->uio_resid);
132
133                 /*
134                  * Fault the page on behalf of the process
135                  */
136                 error = vm_fault(map, pageno, reqprot, VM_FAULT_NORMAL);
137                 if (error) {
138                         error = EFAULT;
139                         break;
140                 }
141
142                 /*
143                  * Now we need to get the page.  out_entry, out_prot, wired,
144                  * and single_use aren't used.  One would think the vm code
145                  * would be a *bit* nicer...  We use tmap because
146                  * vm_map_lookup() can change the map argument.
147                  */
148                 tmap = map;
149                 error = vm_map_lookup(&tmap, pageno, reqprot,
150                               &out_entry, &object, &pindex, &out_prot,
151                               &wired);
152
153                 if (error) {
154                         error = EFAULT;
155
156                         /*
157                          * Make sure that there is no residue in 'object' from
158                          * an error return on vm_map_lookup.
159                          */
160                         object = NULL;
161
162                         break;
163                 }
164
165                 m = vm_page_lookup(object, pindex);
166
167                 /* Allow fallback to backing objects if we are reading */
168
169                 while (m == NULL && !writing && object->backing_object) {
170
171                   pindex += OFF_TO_IDX(object->backing_object_offset);
172                   object = object->backing_object;
173
174                   m = vm_page_lookup(object, pindex);
175                 }
176
177                 if (m == NULL) {
178                         error = EFAULT;
179
180                         /*
181                          * Make sure that there is no residue in 'object' from
182                          * an error return on vm_map_lookup.
183                          */
184                         object = NULL;
185
186                         vm_map_lookup_done(tmap, out_entry);
187
188                         break;
189                 }
190
191                 /*
192                  * Wire the page into memory
193                  */
194                 vm_page_wire(m);
195
196                 /*
197                  * We're done with tmap now.
198                  * But reference the object first, so that we won't loose
199                  * it.
200                  */
201                 vm_object_reference(object);
202                 vm_map_lookup_done(tmap, out_entry);
203
204                 pmap_kenter(kva, VM_PAGE_TO_PHYS(m));
205
206                 /*
207                  * Now do the i/o move.
208                  */
209                 error = uiomove((caddr_t)(kva + page_offset), len, uio);
210
211                 pmap_kremove(kva);
212
213                 /*
214                  * release the page and the object
215                  */
216                 vm_page_unwire(m, 1);
217                 vm_object_deallocate(object);
218
219                 object = NULL;
220
221         } while (error == 0 && uio->uio_resid > 0);
222
223         if (object)
224                 vm_object_deallocate(object);
225
226         kmem_free(kernel_map, kva, PAGE_SIZE);
227         vmspace_free(vm);
228         return (error);
229 }
230
231 /*
232  * Copy data in and out of the target process.
233  * We do this by mapping the process's page into
234  * the kernel and then doing a uiomove direct
235  * from the kernel address space.
236  */
237 int
238 procfs_domem(curp, p, pfs, uio)
239         struct proc *curp;
240         struct proc *p;
241         struct pfsnode *pfs;
242         struct uio *uio;
243 {
244
245         if (uio->uio_resid == 0)
246                 return (0);
247
248         /* Can't trace a process that's currently exec'ing. */ 
249         if ((p->p_flag & P_INEXEC) != 0)
250                 return EAGAIN;
251         if (!CHECKIO(curp, p) || p_trespass(curp, p))
252                 return EPERM;
253
254         return (procfs_rwmem(curp, p, uio));
255 }
256
257 /*
258  * Given process (p), find the vnode from which
259  * its text segment is being executed.
260  *
261  * It would be nice to grab this information from
262  * the VM system, however, there is no sure-fire
263  * way of doing that.  Instead, fork(), exec() and
264  * wait() all maintain the p_textvp field in the
265  * process proc structure which contains a held
266  * reference to the exec'ed vnode.
267  *
268  * XXX - Currently, this is not not used, as the
269  * /proc/pid/file object exposes an information leak
270  * that shouldn't happen.  Using a mount option would
271  * make it configurable on a per-system (or, at least,
272  * per-mount) basis; however, that's not really best.
273  * The best way to do it, I think, would be as an
274  * ioctl; this would restrict it to the uid running
275  * program, or root, which seems a reasonable compromise.
276  * However, the number of applications for this is
277  * minimal, if it can't be seen in the filesytem space,
278  * and doint it as an ioctl makes it somewhat less
279  * useful due to the, well, inelegance.
280  *
281  */
282 struct vnode *
283 procfs_findtextvp(p)
284         struct proc *p;
285 {
286
287         return (p->p_textvp);
288 }