f62a6ead4b1c4ddbce301aa63e63315948324669
[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.16 2007/04/29 18:25:40 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/priv.h>
53 #include <sys/vnode.h>
54 #include <vfs/procfs/procfs.h>
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
67 #include <sys/thread2.h>
68 #include <sys/sysref2.h>
69
70 static int      procfs_rwmem (struct proc *curp,
71                                   struct proc *p, struct uio *uio);
72
73 static int
74 procfs_rwmem(struct proc *curp, struct proc *p, struct uio *uio)
75 {
76         int error;
77         int writing;
78         struct vmspace *vm;
79         vm_map_t map;
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 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.
88          */
89         vm = p->p_vmspace;
90         sysref_get(&vm->vm_sysref);
91         if ((p->p_flag & P_WEXIT) || sysref_isinactive(&vm->vm_sysref)) {
92                 sysref_put(&vm->vm_sysref);
93                 return EFAULT;
94         }
95
96         /*
97          * The map we want...
98          */
99         map = &vm->vm_map;
100
101         writing = uio->uio_rw == UIO_WRITE;
102         reqprot = VM_PROT_READ;
103         if (writing)
104                 reqprot |= VM_PROT_WRITE | VM_PROT_OVERRIDE_WRITE;
105
106         kva = kmem_alloc_pageable(&kernel_map, PAGE_SIZE);
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 {
113                 vm_offset_t uva;
114                 int page_offset;                /* offset into page */
115                 u_int len;
116                 vm_page_t m;
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                  */
129                 len = szmin(PAGE_SIZE - page_offset, uio->uio_resid);
130
131                 /*
132                  * Fault the page on behalf of the process
133                  */
134                 m = vm_fault_page(map, pageno, reqprot,
135                                   VM_FAULT_NORMAL, &error);
136                 if (error) {
137                         KKASSERT(m == NULL);
138                         error = EFAULT;
139                         break;
140                 }
141
142                 /*
143                  * Cleanup tmap then create a temporary KVA mapping and
144                  * do the I/O.
145                  */
146                 pmap_kenter(kva, VM_PAGE_TO_PHYS(m));
147                 error = uiomove((caddr_t)(kva + page_offset), len, uio);
148                 pmap_kremove(kva);
149
150                 /*
151                  * release the page and we are done
152                  */
153                 crit_enter();
154                 vm_page_unhold(m);
155                 crit_exit();
156         } while (error == 0 && uio->uio_resid > 0);
157
158         kmem_free(&kernel_map, kva, PAGE_SIZE);
159         sysref_put(&vm->vm_sysref);
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
170 procfs_domem(struct proc *curp, struct lwp *lp, struct pfsnode *pfs,
171              struct uio *uio)
172 {
173         struct proc *p = lp->lwp_proc;
174
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;
181         if (!CHECKIO(curp, p) || p_trespass(curp->p_ucred, p->p_ucred))
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 *
213 procfs_findtextvp(struct proc *p)
214 {
215         return (p->p_textvp);
216 }