2 * Copyright (c) 1993 Jan-Simon Pendry
3 * Copyright (c) 1993 Sean Eric Fagan
5 * The Regents of the University of California. All rights reserved.
7 * This code is derived from software contributed to Berkeley by
8 * Jan-Simon Pendry and Sean Eric Fagan.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * @(#)procfs_mem.c 8.5 (Berkeley) 6/15/94
36 * $FreeBSD: src/sys/miscfs/procfs/procfs_mem.c,v 1.46.2.3 2002/01/22 17:22:59 nectar Exp $
37 * $DragonFly: src/sys/vfs/procfs/procfs_mem.c,v 1.16 2007/04/29 18:25:40 dillon Exp $
41 * This is a lightly hacked and merged version
42 * of sef's pread/pwrite functions
45 #include <sys/param.h>
46 #include <sys/systm.h>
49 #include <sys/vnode.h>
50 #include <vfs/procfs/procfs.h>
52 #include <vm/vm_param.h>
55 #include <vm/vm_extern.h>
56 #include <vm/vm_map.h>
57 #include <vm/vm_kern.h>
58 #include <vm/vm_object.h>
59 #include <vm/vm_page.h>
61 #include <sys/ptrace.h>
63 #include <machine/vmm.h>
65 #include <sys/thread2.h>
66 #include <sys/sysref2.h>
68 static int procfs_rwmem (struct proc
*curp
,
69 struct proc
*p
, struct uio
*uio
);
72 * p->p_token is held on entry.
75 procfs_rwmem(struct proc
*curp
, struct proc
*p
, struct uio
*uio
)
81 vm_offset_t pageno
= 0; /* page number */
86 * if the vmspace is in the midst of being allocated or deallocated,
87 * or the process is exiting, don't try to grab anything. The
88 * page table usage in that process may be messed up.
91 if (p
->p_stat
== SIDL
|| p
->p_stat
== SZOMB
)
93 if ((p
->p_flags
& (P_WEXIT
| P_INEXEC
)) || vmspace_getrefs(vm
) < 0)
102 writing
= (uio
->uio_rw
== UIO_WRITE
);
103 reqprot
= VM_PROT_READ
;
105 reqprot
|= VM_PROT_WRITE
| VM_PROT_OVERRIDE_WRITE
;
107 kva
= kmem_alloc_pageable(&kernel_map
, PAGE_SIZE
);
110 * Only map in one page at a time. We don't have to, but it
111 * makes things easier. This way is trivial - right?
115 vm_offset_t page_offset
; /* offset into page */
119 uva
= (vm_offset_t
) uio
->uio_offset
;
122 * Get the page number of this segment.
124 pageno
= trunc_page(uva
);
125 page_offset
= uva
- pageno
;
128 * If the target process is running in VMM mode
129 * translate the address into a GPA (Guest Physical
130 * Address) via the EPT before doing the lookup.
134 vmm_vm_get_gpa(p
, &gpa
, (register_t
) pageno
);
135 pageno
= (vm_offset_t
)gpa
;
139 * How many bytes to copy
141 len
= szmin(PAGE_SIZE
- page_offset
, uio
->uio_resid
);
144 * Fault the page on behalf of the process
146 m
= vm_fault_page(map
, pageno
, reqprot
,
147 VM_FAULT_NORMAL
, &error
);
155 * Cleanup tmap then create a temporary KVA mapping and
156 * do the I/O. We can switch between cpus so don't bother
157 * synchronizing across all cores.
159 pmap_kenter_quick(kva
, VM_PAGE_TO_PHYS(m
));
160 error
= uiomove((caddr_t
)(kva
+ page_offset
), len
, uio
);
161 pmap_kremove_quick(kva
);
164 * release the page and we are done
167 } while (error
== 0 && uio
->uio_resid
> 0);
170 kmem_free(&kernel_map
, kva
, PAGE_SIZE
);
176 * Copy data in and out of the target process.
177 * We do this by mapping the process's page into
178 * the kernel and then doing a uiomove direct
179 * from the kernel address space.
181 * lp->lwp_proc->p_token is held on entry.
184 procfs_domem(struct proc
*curp
, struct lwp
*lp
, struct pfsnode
*pfs
,
187 struct proc
*p
= lp
->lwp_proc
;
190 if (uio
->uio_resid
== 0)
193 if ((p
->p_flags
& P_INEXEC
) != 0) {
195 * Can't trace a process that's currently exec'ing.
198 } else if (!CHECKIO(curp
, p
) || p_trespass(curp
->p_ucred
, p
->p_ucred
)) {
200 * Can't trace processes outside our jail
204 error
= procfs_rwmem(curp
, p
, uio
);
210 * Given process (p), find the vnode from which
211 * its text segment is being executed.
213 * It would be nice to grab this information from
214 * the VM system, however, there is no sure-fire
215 * way of doing that. Instead, fork(), exec() and
216 * wait() all maintain the p_textvp field in the
217 * process proc structure which contains a held
218 * reference to the exec'ed vnode.
220 * XXX - Currently, this is not not used, as the
221 * /proc/pid/file object exposes an information leak
222 * that shouldn't happen. Using a mount option would
223 * make it configurable on a per-system (or, at least,
224 * per-mount) basis; however, that's not really best.
225 * The best way to do it, I think, would be as an
226 * ioctl; this would restrict it to the uid running
227 * program, or root, which seems a reasonable compromise.
228 * However, the number of applications for this is
229 * minimal, if it can't be seen in the filesytem space,
230 * and doint it as an ioctl makes it somewhat less
231 * useful due to the, well, inelegance.
235 procfs_findtextvp(struct proc
*p
)
237 return (p
->p_textvp
);