kvm_proc.c revision 1.69 1 /* $NetBSD: kvm_proc.c,v 1.69 2007/05/01 06:58:08 dsl Exp $ */
2
3 /*-
4 * Copyright (c) 1998 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Charles M. Hannum.
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 NetBSD
21 * Foundation, Inc. and its contributors.
22 * 4. Neither the name of The NetBSD Foundation nor the names of its
23 * contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36 * POSSIBILITY OF SUCH DAMAGE.
37 */
38
39 /*-
40 * Copyright (c) 1989, 1992, 1993
41 * The Regents of the University of California. All rights reserved.
42 *
43 * This code is derived from software developed by the Computer Systems
44 * Engineering group at Lawrence Berkeley Laboratory under DARPA contract
45 * BG 91-66 and contributed to Berkeley.
46 *
47 * Redistribution and use in source and binary forms, with or without
48 * modification, are permitted provided that the following conditions
49 * are met:
50 * 1. Redistributions of source code must retain the above copyright
51 * notice, this list of conditions and the following disclaimer.
52 * 2. Redistributions in binary form must reproduce the above copyright
53 * notice, this list of conditions and the following disclaimer in the
54 * documentation and/or other materials provided with the distribution.
55 * 3. Neither the name of the University nor the names of its contributors
56 * may be used to endorse or promote products derived from this software
57 * without specific prior written permission.
58 *
59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69 * SUCH DAMAGE.
70 */
71
72 #include <sys/cdefs.h>
73 #if defined(LIBC_SCCS) && !defined(lint)
74 #if 0
75 static char sccsid[] = "@(#)kvm_proc.c 8.3 (Berkeley) 9/23/93";
76 #else
77 __RCSID("$NetBSD: kvm_proc.c,v 1.69 2007/05/01 06:58:08 dsl Exp $");
78 #endif
79 #endif /* LIBC_SCCS and not lint */
80
81 /*
82 * Proc traversal interface for kvm. ps and w are (probably) the exclusive
83 * users of this code, so we've factored it out into a separate module.
84 * Thus, we keep this grunge out of the other kvm applications (i.e.,
85 * most other applications are interested only in open/close/read/nlist).
86 */
87
88 #include <sys/param.h>
89 #include <sys/user.h>
90 #include <sys/lwp.h>
91 #include <sys/proc.h>
92 #include <sys/exec.h>
93 #include <sys/stat.h>
94 #include <sys/ioctl.h>
95 #include <sys/tty.h>
96 #include <sys/resourcevar.h>
97 #include <sys/mutex.h>
98 #include <sys/specificdata.h>
99
100 #include <errno.h>
101 #include <stdlib.h>
102 #include <stddef.h>
103 #include <string.h>
104 #include <unistd.h>
105 #include <nlist.h>
106 #include <kvm.h>
107
108 #include <uvm/uvm_extern.h>
109 #include <uvm/uvm_amap.h>
110
111 #include <sys/sysctl.h>
112
113 #include <limits.h>
114 #include <db.h>
115 #include <paths.h>
116
117 #include "kvm_private.h"
118
119 /*
120 * Common info from kinfo_proc and kinfo_proc2 used by helper routines.
121 */
122 struct miniproc {
123 struct vmspace *p_vmspace;
124 char p_stat;
125 struct proc *p_paddr;
126 pid_t p_pid;
127 };
128
129 /*
130 * Convert from struct proc and kinfo_proc{,2} to miniproc.
131 */
132 #define PTOMINI(kp, p) \
133 do { \
134 (p)->p_stat = (kp)->p_stat; \
135 (p)->p_pid = (kp)->p_pid; \
136 (p)->p_paddr = NULL; \
137 (p)->p_vmspace = (kp)->p_vmspace; \
138 } while (/*CONSTCOND*/0);
139
140 #define KPTOMINI(kp, p) \
141 do { \
142 (p)->p_stat = (kp)->kp_proc.p_stat; \
143 (p)->p_pid = (kp)->kp_proc.p_pid; \
144 (p)->p_paddr = (kp)->kp_eproc.e_paddr; \
145 (p)->p_vmspace = (kp)->kp_proc.p_vmspace; \
146 } while (/*CONSTCOND*/0);
147
148 #define KP2TOMINI(kp, p) \
149 do { \
150 (p)->p_stat = (kp)->p_stat; \
151 (p)->p_pid = (kp)->p_pid; \
152 (p)->p_paddr = (void *)(long)(kp)->p_paddr; \
153 (p)->p_vmspace = (void *)(long)(kp)->p_vmspace; \
154 } while (/*CONSTCOND*/0);
155
156 /*
157 * NetBSD uses kauth(9) to manage credentials, which are stored in kauth_cred_t,
158 * a kernel-only opaque type. This is an embedded version which is *INTERNAL* to
159 * kvm(3) so dumps can be read properly.
160 *
161 * Whenever NetBSD starts exporting credentials to userland consistently (using
162 * 'struct uucred', or something) this will have to be updated again.
163 */
164 struct kvm_kauth_cred {
165 kmutex_t cr_lock; /* lock on cr_refcnt */
166 u_int cr_refcnt; /* reference count */
167 uid_t cr_uid; /* user id */
168 uid_t cr_euid; /* effective user id */
169 uid_t cr_svuid; /* saved effective user id */
170 gid_t cr_gid; /* group id */
171 gid_t cr_egid; /* effective group id */
172 gid_t cr_svgid; /* saved effective group id */
173 u_int cr_ngroups; /* number of groups */
174 gid_t cr_groups[NGROUPS]; /* group memberships */
175 specificdata_reference cr_sd; /* specific data */
176 };
177
178 #define KREAD(kd, addr, obj) \
179 (kvm_read(kd, addr, (obj), sizeof(*obj)) != sizeof(*obj))
180
181 /* XXX: What uses these two functions? */
182 char *_kvm_uread __P((kvm_t *, const struct proc *, u_long,
183 u_long *));
184 ssize_t kvm_uread __P((kvm_t *, const struct proc *, u_long, char *,
185 size_t));
186
187 static char *_kvm_ureadm __P((kvm_t *, const struct miniproc *, u_long,
188 u_long *));
189 static ssize_t kvm_ureadm __P((kvm_t *, const struct miniproc *, u_long,
190 char *, size_t));
191
192 static char **kvm_argv __P((kvm_t *, const struct miniproc *, u_long, int,
193 int));
194 static int kvm_deadprocs __P((kvm_t *, int, int, u_long, u_long, int));
195 static char **kvm_doargv __P((kvm_t *, const struct miniproc *, int,
196 void (*)(struct ps_strings *, u_long *, int *)));
197 static char **kvm_doargv2 __P((kvm_t *, pid_t, int, int));
198 static int kvm_proclist __P((kvm_t *, int, int, struct proc *,
199 struct kinfo_proc *, int));
200 static int proc_verify __P((kvm_t *, u_long, const struct miniproc *));
201 static void ps_str_a __P((struct ps_strings *, u_long *, int *));
202 static void ps_str_e __P((struct ps_strings *, u_long *, int *));
203
204
205 static char *
206 _kvm_ureadm(kd, p, va, cnt)
207 kvm_t *kd;
208 const struct miniproc *p;
209 u_long va;
210 u_long *cnt;
211 {
212 int true = 1;
213 u_long addr, head;
214 u_long offset;
215 struct vm_map_entry vme;
216 struct vm_amap amap;
217 struct vm_anon *anonp, anon;
218 struct vm_page pg;
219 u_long slot;
220
221 if (kd->swapspc == NULL) {
222 kd->swapspc = _kvm_malloc(kd, (size_t)kd->nbpg);
223 if (kd->swapspc == NULL)
224 return (NULL);
225 }
226
227 /*
228 * Look through the address map for the memory object
229 * that corresponds to the given virtual address.
230 * The header just has the entire valid range.
231 */
232 head = (u_long)&p->p_vmspace->vm_map.header;
233 addr = head;
234 while (true) {
235 if (KREAD(kd, addr, &vme))
236 return (NULL);
237
238 if (va >= vme.start && va < vme.end &&
239 vme.aref.ar_amap != NULL)
240 break;
241
242 addr = (u_long)vme.next;
243 if (addr == head)
244 return (NULL);
245 }
246
247 /*
248 * we found the map entry, now to find the object...
249 */
250 if (vme.aref.ar_amap == NULL)
251 return (NULL);
252
253 addr = (u_long)vme.aref.ar_amap;
254 if (KREAD(kd, addr, &amap))
255 return (NULL);
256
257 offset = va - vme.start;
258 slot = offset / kd->nbpg + vme.aref.ar_pageoff;
259 /* sanity-check slot number */
260 if (slot > amap.am_nslot)
261 return (NULL);
262
263 addr = (u_long)amap.am_anon + (offset / kd->nbpg) * sizeof(anonp);
264 if (KREAD(kd, addr, &anonp))
265 return (NULL);
266
267 addr = (u_long)anonp;
268 if (KREAD(kd, addr, &anon))
269 return (NULL);
270
271 addr = (u_long)anon.an_page;
272 if (addr) {
273 if (KREAD(kd, addr, &pg))
274 return (NULL);
275
276 if (pread(kd->pmfd, kd->swapspc, (size_t)kd->nbpg,
277 (off_t)pg.phys_addr) != kd->nbpg)
278 return (NULL);
279 } else {
280 if (kd->swfd < 0 ||
281 pread(kd->swfd, kd->swapspc, (size_t)kd->nbpg,
282 (off_t)(anon.an_swslot * kd->nbpg)) != kd->nbpg)
283 return (NULL);
284 }
285
286 /* Found the page. */
287 offset %= kd->nbpg;
288 *cnt = kd->nbpg - offset;
289 return (&kd->swapspc[(size_t)offset]);
290 }
291
292 char *
293 _kvm_uread(kd, p, va, cnt)
294 kvm_t *kd;
295 const struct proc *p;
296 u_long va;
297 u_long *cnt;
298 {
299 struct miniproc mp;
300
301 PTOMINI(p, &mp);
302 return (_kvm_ureadm(kd, &mp, va, cnt));
303 }
304
305 /*
306 * Convert credentials located in kernel space address 'cred' and store
307 * them in the appropriate members of 'eproc'.
308 */
309 static int
310 _kvm_convertcred(kvm_t *kd, u_long cred, struct eproc *eproc)
311 {
312 struct kvm_kauth_cred kauthcred;
313 struct ki_pcred *pc = &eproc->e_pcred;
314 struct ki_ucred *uc = &eproc->e_ucred;
315
316 if (KREAD(kd, cred, &kauthcred) != 0)
317 return (-1);
318
319 /* inlined version of kauth_cred_to_pcred, see kauth(9). */
320 pc->p_ruid = kauthcred.cr_uid;
321 pc->p_svuid = kauthcred.cr_svuid;
322 pc->p_rgid = kauthcred.cr_gid;
323 pc->p_svgid = kauthcred.cr_svgid;
324 pc->p_refcnt = kauthcred.cr_refcnt;
325 pc->p_pad = NULL;
326
327 /* inlined version of kauth_cred_to_ucred(), see kauth(9). */
328 uc->cr_ref = kauthcred.cr_refcnt;
329 uc->cr_uid = kauthcred.cr_euid;
330 uc->cr_gid = kauthcred.cr_egid;
331 uc->cr_ngroups = MIN(kauthcred.cr_ngroups,
332 sizeof(uc->cr_groups) / sizeof(uc->cr_groups[0]));
333 memcpy(uc->cr_groups, kauthcred.cr_groups,
334 uc->cr_ngroups * sizeof(uc->cr_groups[0]));
335
336 return (0);
337 }
338
339 /*
340 * Read proc's from memory file into buffer bp, which has space to hold
341 * at most maxcnt procs.
342 */
343 static int
344 kvm_proclist(kd, what, arg, p, bp, maxcnt)
345 kvm_t *kd;
346 int what, arg;
347 struct proc *p;
348 struct kinfo_proc *bp;
349 int maxcnt;
350 {
351 int cnt = 0;
352 int nlwps;
353 struct kinfo_lwp *kl;
354 struct eproc eproc;
355 struct pgrp pgrp;
356 struct session sess;
357 struct tty tty;
358 struct proc proc;
359
360 for (; cnt < maxcnt && p != NULL; p = proc.p_list.le_next) {
361 if (KREAD(kd, (u_long)p, &proc)) {
362 _kvm_err(kd, kd->program, "can't read proc at %p", p);
363 return (-1);
364 }
365 if (_kvm_convertcred(kd, (u_long)proc.p_cred, &eproc) != 0) {
366 _kvm_err(kd, kd->program,
367 "can't read proc credentials at %p", p);
368 return (-1);
369 }
370
371 switch (what) {
372
373 case KERN_PROC_PID:
374 if (proc.p_pid != (pid_t)arg)
375 continue;
376 break;
377
378 case KERN_PROC_UID:
379 if (eproc.e_ucred.cr_uid != (uid_t)arg)
380 continue;
381 break;
382
383 case KERN_PROC_RUID:
384 if (eproc.e_pcred.p_ruid != (uid_t)arg)
385 continue;
386 break;
387 }
388 /*
389 * We're going to add another proc to the set. If this
390 * will overflow the buffer, assume the reason is because
391 * nprocs (or the proc list) is corrupt and declare an error.
392 */
393 if (cnt >= maxcnt) {
394 _kvm_err(kd, kd->program, "nprocs corrupt");
395 return (-1);
396 }
397 /*
398 * gather eproc
399 */
400 eproc.e_paddr = p;
401 if (KREAD(kd, (u_long)proc.p_pgrp, &pgrp)) {
402 _kvm_err(kd, kd->program, "can't read pgrp at %p",
403 proc.p_pgrp);
404 return (-1);
405 }
406 eproc.e_sess = pgrp.pg_session;
407 eproc.e_pgid = pgrp.pg_id;
408 eproc.e_jobc = pgrp.pg_jobc;
409 if (KREAD(kd, (u_long)pgrp.pg_session, &sess)) {
410 _kvm_err(kd, kd->program, "can't read session at %p",
411 pgrp.pg_session);
412 return (-1);
413 }
414 if ((proc.p_lflag & PL_CONTROLT) && sess.s_ttyp != NULL) {
415 if (KREAD(kd, (u_long)sess.s_ttyp, &tty)) {
416 _kvm_err(kd, kd->program,
417 "can't read tty at %p", sess.s_ttyp);
418 return (-1);
419 }
420 eproc.e_tdev = tty.t_dev;
421 eproc.e_tsess = tty.t_session;
422 if (tty.t_pgrp != NULL) {
423 if (KREAD(kd, (u_long)tty.t_pgrp, &pgrp)) {
424 _kvm_err(kd, kd->program,
425 "can't read tpgrp at %p",
426 tty.t_pgrp);
427 return (-1);
428 }
429 eproc.e_tpgid = pgrp.pg_id;
430 } else
431 eproc.e_tpgid = -1;
432 } else
433 eproc.e_tdev = NODEV;
434 eproc.e_flag = sess.s_ttyvp ? EPROC_CTTY : 0;
435 eproc.e_sid = sess.s_sid;
436 if (sess.s_leader == p)
437 eproc.e_flag |= EPROC_SLEADER;
438 /*
439 * Fill in the old-style proc.p_wmesg by copying the wmesg
440 * from the first available LWP.
441 */
442 kl = kvm_getlwps(kd, proc.p_pid,
443 (u_long)PTRTOUINT64(eproc.e_paddr),
444 sizeof(struct kinfo_lwp), &nlwps);
445 if (kl) {
446 if (nlwps > 0) {
447 strcpy(eproc.e_wmesg, kl[0].l_wmesg);
448 }
449 }
450 (void)kvm_read(kd, (u_long)proc.p_vmspace, &eproc.e_vm,
451 sizeof(eproc.e_vm));
452
453 eproc.e_xsize = eproc.e_xrssize = 0;
454 eproc.e_xccount = eproc.e_xswrss = 0;
455
456 switch (what) {
457
458 case KERN_PROC_PGRP:
459 if (eproc.e_pgid != (pid_t)arg)
460 continue;
461 break;
462
463 case KERN_PROC_TTY:
464 if ((proc.p_lflag & PL_CONTROLT) == 0 ||
465 eproc.e_tdev != (dev_t)arg)
466 continue;
467 break;
468 }
469 memcpy(&bp->kp_proc, &proc, sizeof(proc));
470 memcpy(&bp->kp_eproc, &eproc, sizeof(eproc));
471 ++bp;
472 ++cnt;
473 }
474 return (cnt);
475 }
476
477 /*
478 * Build proc info array by reading in proc list from a crash dump.
479 * Return number of procs read. maxcnt is the max we will read.
480 */
481 static int
482 kvm_deadprocs(kd, what, arg, a_allproc, a_zombproc, maxcnt)
483 kvm_t *kd;
484 int what, arg;
485 u_long a_allproc;
486 u_long a_zombproc;
487 int maxcnt;
488 {
489 struct kinfo_proc *bp = kd->procbase;
490 int acnt, zcnt;
491 struct proc *p;
492
493 if (KREAD(kd, a_allproc, &p)) {
494 _kvm_err(kd, kd->program, "cannot read allproc");
495 return (-1);
496 }
497 acnt = kvm_proclist(kd, what, arg, p, bp, maxcnt);
498 if (acnt < 0)
499 return (acnt);
500
501 if (KREAD(kd, a_zombproc, &p)) {
502 _kvm_err(kd, kd->program, "cannot read zombproc");
503 return (-1);
504 }
505 zcnt = kvm_proclist(kd, what, arg, p, bp + acnt,
506 maxcnt - acnt);
507 if (zcnt < 0)
508 zcnt = 0;
509
510 return (acnt + zcnt);
511 }
512
513 struct kinfo_proc2 *
514 kvm_getproc2(kd, op, arg, esize, cnt)
515 kvm_t *kd;
516 int op, arg;
517 size_t esize;
518 int *cnt;
519 {
520 size_t size;
521 int mib[6], st, nprocs;
522 struct pstats pstats;
523
524 if (ISSYSCTL(kd)) {
525 size = 0;
526 mib[0] = CTL_KERN;
527 mib[1] = KERN_PROC2;
528 mib[2] = op;
529 mib[3] = arg;
530 mib[4] = (int)esize;
531 again:
532 mib[5] = 0;
533 st = sysctl(mib, 6, NULL, &size, NULL, (size_t)0);
534 if (st == -1) {
535 _kvm_syserr(kd, kd->program, "kvm_getproc2");
536 return (NULL);
537 }
538
539 mib[5] = (int) (size / esize);
540 KVM_ALLOC(kd, procbase2, size);
541 st = sysctl(mib, 6, kd->procbase2, &size, NULL, (size_t)0);
542 if (st == -1) {
543 if (errno == ENOMEM) {
544 goto again;
545 }
546 _kvm_syserr(kd, kd->program, "kvm_getproc2");
547 return (NULL);
548 }
549 nprocs = (int) (size / esize);
550 } else {
551 char *kp2c;
552 struct kinfo_proc *kp;
553 struct kinfo_proc2 kp2, *kp2p;
554 struct kinfo_lwp *kl;
555 int i, nlwps;
556
557 kp = kvm_getprocs(kd, op, arg, &nprocs);
558 if (kp == NULL)
559 return (NULL);
560
561 size = nprocs * esize;
562 KVM_ALLOC(kd, procbase2, size);
563 kp2c = (char *)(void *)kd->procbase2;
564 kp2p = &kp2;
565 for (i = 0; i < nprocs; i++, kp++) {
566 kl = kvm_getlwps(kd, kp->kp_proc.p_pid,
567 (u_long)PTRTOUINT64(kp->kp_eproc.e_paddr),
568 sizeof(struct kinfo_lwp), &nlwps);
569
570 /* We use kl[0] as the "representative" LWP */
571 memset(kp2p, 0, sizeof(kp2));
572 kp2p->p_forw = kl[0].l_forw;
573 kp2p->p_back = kl[0].l_back;
574 kp2p->p_paddr = PTRTOUINT64(kp->kp_eproc.e_paddr);
575 kp2p->p_addr = kl[0].l_addr;
576 kp2p->p_fd = PTRTOUINT64(kp->kp_proc.p_fd);
577 kp2p->p_cwdi = PTRTOUINT64(kp->kp_proc.p_cwdi);
578 kp2p->p_stats = PTRTOUINT64(kp->kp_proc.p_stats);
579 kp2p->p_limit = PTRTOUINT64(kp->kp_proc.p_limit);
580 kp2p->p_vmspace = PTRTOUINT64(kp->kp_proc.p_vmspace);
581 kp2p->p_sigacts = PTRTOUINT64(kp->kp_proc.p_sigacts);
582 kp2p->p_sess = PTRTOUINT64(kp->kp_eproc.e_sess);
583 kp2p->p_tsess = 0;
584 #if 1 /* XXX: dsl - p_ru was only ever non-zero for zombies */
585 kp2p->p_ru = 0;
586 #else
587 kp2p->p_ru = PTRTOUINT64(pstats.p_ru);
588 #endif
589
590 kp2p->p_eflag = 0;
591 kp2p->p_exitsig = kp->kp_proc.p_exitsig;
592 kp2p->p_flag = kp->kp_proc.p_flag;
593
594 kp2p->p_pid = kp->kp_proc.p_pid;
595
596 kp2p->p_ppid = kp->kp_eproc.e_ppid;
597 kp2p->p_sid = kp->kp_eproc.e_sid;
598 kp2p->p__pgid = kp->kp_eproc.e_pgid;
599
600 kp2p->p_tpgid = -1 /* XXX NO_PGID! */;
601
602 kp2p->p_uid = kp->kp_eproc.e_ucred.cr_uid;
603 kp2p->p_ruid = kp->kp_eproc.e_pcred.p_ruid;
604 kp2p->p_svuid = kp->kp_eproc.e_pcred.p_svuid;
605 kp2p->p_gid = kp->kp_eproc.e_ucred.cr_gid;
606 kp2p->p_rgid = kp->kp_eproc.e_pcred.p_rgid;
607 kp2p->p_svgid = kp->kp_eproc.e_pcred.p_svgid;
608
609 /*CONSTCOND*/
610 memcpy(kp2p->p_groups, kp->kp_eproc.e_ucred.cr_groups,
611 MIN(sizeof(kp2p->p_groups),
612 sizeof(kp->kp_eproc.e_ucred.cr_groups)));
613 kp2p->p_ngroups = kp->kp_eproc.e_ucred.cr_ngroups;
614
615 kp2p->p_jobc = kp->kp_eproc.e_jobc;
616 kp2p->p_tdev = kp->kp_eproc.e_tdev;
617 kp2p->p_tpgid = kp->kp_eproc.e_tpgid;
618 kp2p->p_tsess = PTRTOUINT64(kp->kp_eproc.e_tsess);
619
620 kp2p->p_estcpu = kp->kp_proc.p_estcpu;
621 kp2p->p_rtime_sec = kp->kp_proc.p_rtime.tv_sec;
622 kp2p->p_rtime_usec = kp->kp_proc.p_rtime.tv_usec;
623 kp2p->p_cpticks = kp->kp_proc.p_cpticks;
624 kp2p->p_pctcpu = kp->kp_proc.p_pctcpu;
625 kp2p->p_swtime = kl[0].l_swtime;
626 kp2p->p_slptime = kl[0].l_slptime;
627 #if 0 /* XXX thorpej */
628 kp2p->p_schedflags = kp->kp_proc.p_schedflags;
629 #else
630 kp2p->p_schedflags = 0;
631 #endif
632
633 kp2p->p_uticks = kp->kp_proc.p_uticks;
634 kp2p->p_sticks = kp->kp_proc.p_sticks;
635 kp2p->p_iticks = kp->kp_proc.p_iticks;
636
637 kp2p->p_tracep = PTRTOUINT64(kp->kp_proc.p_tracep);
638 kp2p->p_traceflag = kp->kp_proc.p_traceflag;
639
640 kp2p->p_holdcnt = kl[0].l_holdcnt;
641
642 memcpy(&kp2p->p_siglist,
643 &kp->kp_proc.p_sigpend.sp_set,
644 sizeof(ki_sigset_t));
645 memset(&kp2p->p_sigmask, 0,
646 sizeof(ki_sigset_t));
647 memcpy(&kp2p->p_sigignore,
648 &kp->kp_proc.p_sigctx.ps_sigignore,
649 sizeof(ki_sigset_t));
650 memcpy(&kp2p->p_sigcatch,
651 &kp->kp_proc.p_sigctx.ps_sigcatch,
652 sizeof(ki_sigset_t));
653
654 kp2p->p_stat = kl[0].l_stat;
655 kp2p->p_priority = kl[0].l_priority;
656 kp2p->p_usrpri = kl[0].l_usrpri;
657 kp2p->p_nice = kp->kp_proc.p_nice;
658
659 kp2p->p_xstat = kp->kp_proc.p_xstat;
660 kp2p->p_acflag = kp->kp_proc.p_acflag;
661
662 /*CONSTCOND*/
663 strncpy(kp2p->p_comm, kp->kp_proc.p_comm,
664 MIN(sizeof(kp2p->p_comm),
665 sizeof(kp->kp_proc.p_comm)));
666
667 strncpy(kp2p->p_wmesg, kp->kp_eproc.e_wmesg,
668 sizeof(kp2p->p_wmesg));
669 kp2p->p_wchan = kl[0].l_wchan;
670 strncpy(kp2p->p_login, kp->kp_eproc.e_login,
671 sizeof(kp2p->p_login));
672
673 kp2p->p_vm_rssize = kp->kp_eproc.e_xrssize;
674 kp2p->p_vm_tsize = kp->kp_eproc.e_vm.vm_tsize;
675 kp2p->p_vm_dsize = kp->kp_eproc.e_vm.vm_dsize;
676 kp2p->p_vm_ssize = kp->kp_eproc.e_vm.vm_ssize;
677
678 kp2p->p_eflag = (int32_t)kp->kp_eproc.e_flag;
679
680 kp2p->p_realflag = kp->kp_proc.p_flag;
681 kp2p->p_nlwps = kp->kp_proc.p_nlwps;
682 kp2p->p_nrlwps = kp->kp_proc.p_nrlwps;
683 kp2p->p_realstat = kp->kp_proc.p_stat;
684
685 if (P_ZOMBIE(&kp->kp_proc) ||
686 kp->kp_proc.p_stats == NULL ||
687 KREAD(kd, (u_long)kp->kp_proc.p_stats, &pstats)) {
688 kp2p->p_uvalid = 0;
689 } else {
690 kp2p->p_uvalid = 1;
691
692 kp2p->p_ustart_sec = (u_int32_t)
693 pstats.p_start.tv_sec;
694 kp2p->p_ustart_usec = (u_int32_t)
695 pstats.p_start.tv_usec;
696
697 kp2p->p_uutime_sec = (u_int32_t)
698 pstats.p_ru.ru_utime.tv_sec;
699 kp2p->p_uutime_usec = (u_int32_t)
700 pstats.p_ru.ru_utime.tv_usec;
701 kp2p->p_ustime_sec = (u_int32_t)
702 pstats.p_ru.ru_stime.tv_sec;
703 kp2p->p_ustime_usec = (u_int32_t)
704 pstats.p_ru.ru_stime.tv_usec;
705
706 kp2p->p_uru_maxrss = pstats.p_ru.ru_maxrss;
707 kp2p->p_uru_ixrss = pstats.p_ru.ru_ixrss;
708 kp2p->p_uru_idrss = pstats.p_ru.ru_idrss;
709 kp2p->p_uru_isrss = pstats.p_ru.ru_isrss;
710 kp2p->p_uru_minflt = pstats.p_ru.ru_minflt;
711 kp2p->p_uru_majflt = pstats.p_ru.ru_majflt;
712 kp2p->p_uru_nswap = pstats.p_ru.ru_nswap;
713 kp2p->p_uru_inblock = pstats.p_ru.ru_inblock;
714 kp2p->p_uru_oublock = pstats.p_ru.ru_oublock;
715 kp2p->p_uru_msgsnd = pstats.p_ru.ru_msgsnd;
716 kp2p->p_uru_msgrcv = pstats.p_ru.ru_msgrcv;
717 kp2p->p_uru_nsignals = pstats.p_ru.ru_nsignals;
718 kp2p->p_uru_nvcsw = pstats.p_ru.ru_nvcsw;
719 kp2p->p_uru_nivcsw = pstats.p_ru.ru_nivcsw;
720
721 kp2p->p_uctime_sec = (u_int32_t)
722 (pstats.p_cru.ru_utime.tv_sec +
723 pstats.p_cru.ru_stime.tv_sec);
724 kp2p->p_uctime_usec = (u_int32_t)
725 (pstats.p_cru.ru_utime.tv_usec +
726 pstats.p_cru.ru_stime.tv_usec);
727 }
728
729 memcpy(kp2c, &kp2, esize);
730 kp2c += esize;
731 }
732 }
733 *cnt = nprocs;
734 return (kd->procbase2);
735 }
736
737 struct kinfo_lwp *
738 kvm_getlwps(kd, pid, paddr, esize, cnt)
739 kvm_t *kd;
740 int pid;
741 u_long paddr;
742 size_t esize;
743 int *cnt;
744 {
745 size_t size;
746 int mib[5], nlwps;
747 ssize_t st;
748 struct kinfo_lwp *kl;
749
750 if (ISSYSCTL(kd)) {
751 size = 0;
752 mib[0] = CTL_KERN;
753 mib[1] = KERN_LWP;
754 mib[2] = pid;
755 mib[3] = (int)esize;
756 mib[4] = 0;
757 st = sysctl(mib, 5, NULL, &size, NULL, (size_t)0);
758 if (st == -1) {
759 _kvm_syserr(kd, kd->program, "kvm_getlwps");
760 return (NULL);
761 }
762
763 mib[4] = (int) (size / esize);
764 KVM_ALLOC(kd, lwpbase, size);
765 st = sysctl(mib, 5, kd->lwpbase, &size, NULL, (size_t)0);
766 if (st == -1) {
767 _kvm_syserr(kd, kd->program, "kvm_getlwps");
768 return (NULL);
769 }
770 nlwps = (int) (size / esize);
771 } else {
772 /* grovel through the memory image */
773 struct proc p;
774 struct lwp l;
775 u_long laddr;
776 int i;
777
778 st = kvm_read(kd, paddr, &p, sizeof(p));
779 if (st == -1) {
780 _kvm_syserr(kd, kd->program, "kvm_getlwps");
781 return (NULL);
782 }
783
784 nlwps = p.p_nlwps;
785 size = nlwps * sizeof(*kd->lwpbase);
786 KVM_ALLOC(kd, lwpbase, size);
787 laddr = (u_long)PTRTOUINT64(p.p_lwps.lh_first);
788 for (i = 0; (i < nlwps) && (laddr != 0); i++) {
789 st = kvm_read(kd, laddr, &l, sizeof(l));
790 if (st == -1) {
791 _kvm_syserr(kd, kd->program, "kvm_getlwps");
792 return (NULL);
793 }
794 kl = &kd->lwpbase[i];
795 kl->l_laddr = laddr;
796 kl->l_forw = PTRTOUINT64(l.l_forw);
797 kl->l_back = PTRTOUINT64(l.l_back);
798 kl->l_addr = PTRTOUINT64(l.l_addr);
799 kl->l_lid = l.l_lid;
800 kl->l_flag = l.l_flag;
801 kl->l_swtime = l.l_swtime;
802 kl->l_slptime = l.l_slptime;
803 kl->l_schedflags = 0; /* XXX */
804 kl->l_holdcnt = l.l_holdcnt;
805 kl->l_priority = l.l_priority;
806 kl->l_usrpri = l.l_usrpri;
807 kl->l_stat = l.l_stat;
808 kl->l_wchan = PTRTOUINT64(l.l_wchan);
809 if (l.l_wmesg)
810 (void)kvm_read(kd, (u_long)l.l_wmesg,
811 kl->l_wmesg, (size_t)WMESGLEN);
812 kl->l_cpuid = KI_NOCPU;
813 laddr = (u_long)PTRTOUINT64(l.l_sibling.le_next);
814 }
815 }
816
817 *cnt = nlwps;
818 return (kd->lwpbase);
819 }
820
821 struct kinfo_proc *
822 kvm_getprocs(kd, op, arg, cnt)
823 kvm_t *kd;
824 int op, arg;
825 int *cnt;
826 {
827 size_t size;
828 int mib[4], st, nprocs;
829
830 if (ISKMEM(kd)) {
831 size = 0;
832 mib[0] = CTL_KERN;
833 mib[1] = KERN_PROC;
834 mib[2] = op;
835 mib[3] = arg;
836 st = sysctl(mib, 4, NULL, &size, NULL, (size_t)0);
837 if (st == -1) {
838 _kvm_syserr(kd, kd->program, "kvm_getprocs");
839 return (NULL);
840 }
841 KVM_ALLOC(kd, procbase, size);
842 st = sysctl(mib, 4, kd->procbase, &size, NULL, (size_t)0);
843 if (st == -1) {
844 _kvm_syserr(kd, kd->program, "kvm_getprocs");
845 return (NULL);
846 }
847 if (size % sizeof(struct kinfo_proc) != 0) {
848 _kvm_err(kd, kd->program,
849 "proc size mismatch (%lu total, %lu chunks)",
850 (u_long)size, (u_long)sizeof(struct kinfo_proc));
851 return (NULL);
852 }
853 nprocs = (int) (size / sizeof(struct kinfo_proc));
854 } else if (ISSYSCTL(kd)) {
855 _kvm_err(kd, kd->program, "kvm_open called with KVM_NO_FILES, "
856 "can't use kvm_getprocs");
857 return (NULL);
858 } else {
859 struct nlist nl[4], *p;
860
861 (void)memset(nl, 0, sizeof(nl));
862 nl[0].n_name = "_nprocs";
863 nl[1].n_name = "_allproc";
864 nl[2].n_name = "_zombproc";
865 nl[3].n_name = NULL;
866
867 if (kvm_nlist(kd, nl) != 0) {
868 for (p = nl; p->n_type != 0; ++p)
869 continue;
870 _kvm_err(kd, kd->program,
871 "%s: no such symbol", p->n_name);
872 return (NULL);
873 }
874 if (KREAD(kd, nl[0].n_value, &nprocs)) {
875 _kvm_err(kd, kd->program, "can't read nprocs");
876 return (NULL);
877 }
878 size = nprocs * sizeof(*kd->procbase);
879 KVM_ALLOC(kd, procbase, size);
880 nprocs = kvm_deadprocs(kd, op, arg, nl[1].n_value,
881 nl[2].n_value, nprocs);
882 if (nprocs < 0)
883 return (NULL);
884 #ifdef notdef
885 size = nprocs * sizeof(struct kinfo_proc);
886 (void)realloc(kd->procbase, size);
887 #endif
888 }
889 *cnt = nprocs;
890 return (kd->procbase);
891 }
892
893 void *
894 _kvm_realloc(kd, p, n)
895 kvm_t *kd;
896 void *p;
897 size_t n;
898 {
899 void *np = realloc(p, n);
900
901 if (np == NULL)
902 _kvm_err(kd, kd->program, "out of memory");
903 return (np);
904 }
905
906 /*
907 * Read in an argument vector from the user address space of process p.
908 * addr if the user-space base address of narg null-terminated contiguous
909 * strings. This is used to read in both the command arguments and
910 * environment strings. Read at most maxcnt characters of strings.
911 */
912 static char **
913 kvm_argv(kd, p, addr, narg, maxcnt)
914 kvm_t *kd;
915 const struct miniproc *p;
916 u_long addr;
917 int narg;
918 int maxcnt;
919 {
920 char *np, *cp, *ep, *ap;
921 u_long oaddr = (u_long)~0L;
922 u_long len;
923 size_t cc;
924 char **argv;
925
926 /*
927 * Check that there aren't an unreasonable number of arguments,
928 * and that the address is in user space.
929 */
930 if (narg > ARG_MAX || addr < kd->min_uva || addr >= kd->max_uva)
931 return (NULL);
932
933 if (kd->argv == NULL) {
934 /*
935 * Try to avoid reallocs.
936 */
937 kd->argc = MAX(narg + 1, 32);
938 kd->argv = _kvm_malloc(kd, kd->argc * sizeof(*kd->argv));
939 if (kd->argv == NULL)
940 return (NULL);
941 } else if (narg + 1 > kd->argc) {
942 kd->argc = MAX(2 * kd->argc, narg + 1);
943 kd->argv = _kvm_realloc(kd, kd->argv, kd->argc *
944 sizeof(*kd->argv));
945 if (kd->argv == NULL)
946 return (NULL);
947 }
948 if (kd->argspc == NULL) {
949 kd->argspc = _kvm_malloc(kd, (size_t)kd->nbpg);
950 if (kd->argspc == NULL)
951 return (NULL);
952 kd->argspc_len = kd->nbpg;
953 }
954 if (kd->argbuf == NULL) {
955 kd->argbuf = _kvm_malloc(kd, (size_t)kd->nbpg);
956 if (kd->argbuf == NULL)
957 return (NULL);
958 }
959 cc = sizeof(char *) * narg;
960 if (kvm_ureadm(kd, p, addr, (void *)kd->argv, cc) != cc)
961 return (NULL);
962 ap = np = kd->argspc;
963 argv = kd->argv;
964 len = 0;
965 /*
966 * Loop over pages, filling in the argument vector.
967 */
968 while (argv < kd->argv + narg && *argv != NULL) {
969 addr = (u_long)*argv & ~(kd->nbpg - 1);
970 if (addr != oaddr) {
971 if (kvm_ureadm(kd, p, addr, kd->argbuf,
972 (size_t)kd->nbpg) != kd->nbpg)
973 return (NULL);
974 oaddr = addr;
975 }
976 addr = (u_long)*argv & (kd->nbpg - 1);
977 cp = kd->argbuf + (size_t)addr;
978 cc = kd->nbpg - (size_t)addr;
979 if (maxcnt > 0 && cc > (size_t)(maxcnt - len))
980 cc = (size_t)(maxcnt - len);
981 ep = memchr(cp, '\0', cc);
982 if (ep != NULL)
983 cc = ep - cp + 1;
984 if (len + cc > kd->argspc_len) {
985 ptrdiff_t off;
986 char **pp;
987 char *op = kd->argspc;
988
989 kd->argspc_len *= 2;
990 kd->argspc = _kvm_realloc(kd, kd->argspc,
991 kd->argspc_len);
992 if (kd->argspc == NULL)
993 return (NULL);
994 /*
995 * Adjust argv pointers in case realloc moved
996 * the string space.
997 */
998 off = kd->argspc - op;
999 for (pp = kd->argv; pp < argv; pp++)
1000 *pp += off;
1001 ap += off;
1002 np += off;
1003 }
1004 memcpy(np, cp, cc);
1005 np += cc;
1006 len += cc;
1007 if (ep != NULL) {
1008 *argv++ = ap;
1009 ap = np;
1010 } else
1011 *argv += cc;
1012 if (maxcnt > 0 && len >= maxcnt) {
1013 /*
1014 * We're stopping prematurely. Terminate the
1015 * current string.
1016 */
1017 if (ep == NULL) {
1018 *np = '\0';
1019 *argv++ = ap;
1020 }
1021 break;
1022 }
1023 }
1024 /* Make sure argv is terminated. */
1025 *argv = NULL;
1026 return (kd->argv);
1027 }
1028
1029 static void
1030 ps_str_a(p, addr, n)
1031 struct ps_strings *p;
1032 u_long *addr;
1033 int *n;
1034 {
1035
1036 *addr = (u_long)p->ps_argvstr;
1037 *n = p->ps_nargvstr;
1038 }
1039
1040 static void
1041 ps_str_e(p, addr, n)
1042 struct ps_strings *p;
1043 u_long *addr;
1044 int *n;
1045 {
1046
1047 *addr = (u_long)p->ps_envstr;
1048 *n = p->ps_nenvstr;
1049 }
1050
1051 /*
1052 * Determine if the proc indicated by p is still active.
1053 * This test is not 100% foolproof in theory, but chances of
1054 * being wrong are very low.
1055 */
1056 static int
1057 proc_verify(kd, kernp, p)
1058 kvm_t *kd;
1059 u_long kernp;
1060 const struct miniproc *p;
1061 {
1062 struct proc kernproc;
1063
1064 /*
1065 * Just read in the whole proc. It's not that big relative
1066 * to the cost of the read system call.
1067 */
1068 if (kvm_read(kd, kernp, &kernproc, sizeof(kernproc)) !=
1069 sizeof(kernproc))
1070 return (0);
1071 return (p->p_pid == kernproc.p_pid &&
1072 (kernproc.p_stat != SZOMB || p->p_stat == SZOMB));
1073 }
1074
1075 static char **
1076 kvm_doargv(kd, p, nchr, info)
1077 kvm_t *kd;
1078 const struct miniproc *p;
1079 int nchr;
1080 void (*info)(struct ps_strings *, u_long *, int *);
1081 {
1082 char **ap;
1083 u_long addr;
1084 int cnt;
1085 struct ps_strings arginfo;
1086
1087 /*
1088 * Pointers are stored at the top of the user stack.
1089 */
1090 if (p->p_stat == SZOMB)
1091 return (NULL);
1092 cnt = (int)kvm_ureadm(kd, p, kd->usrstack - sizeof(arginfo),
1093 (void *)&arginfo, sizeof(arginfo));
1094 if (cnt != sizeof(arginfo))
1095 return (NULL);
1096
1097 (*info)(&arginfo, &addr, &cnt);
1098 if (cnt == 0)
1099 return (NULL);
1100 ap = kvm_argv(kd, p, addr, cnt, nchr);
1101 /*
1102 * For live kernels, make sure this process didn't go away.
1103 */
1104 if (ap != NULL && ISALIVE(kd) &&
1105 !proc_verify(kd, (u_long)p->p_paddr, p))
1106 ap = NULL;
1107 return (ap);
1108 }
1109
1110 /*
1111 * Get the command args. This code is now machine independent.
1112 */
1113 char **
1114 kvm_getargv(kd, kp, nchr)
1115 kvm_t *kd;
1116 const struct kinfo_proc *kp;
1117 int nchr;
1118 {
1119 struct miniproc p;
1120
1121 KPTOMINI(kp, &p);
1122 return (kvm_doargv(kd, &p, nchr, ps_str_a));
1123 }
1124
1125 char **
1126 kvm_getenvv(kd, kp, nchr)
1127 kvm_t *kd;
1128 const struct kinfo_proc *kp;
1129 int nchr;
1130 {
1131 struct miniproc p;
1132
1133 KPTOMINI(kp, &p);
1134 return (kvm_doargv(kd, &p, nchr, ps_str_e));
1135 }
1136
1137 static char **
1138 kvm_doargv2(kd, pid, type, nchr)
1139 kvm_t *kd;
1140 pid_t pid;
1141 int type;
1142 int nchr;
1143 {
1144 size_t bufs;
1145 int narg, mib[4];
1146 size_t newargspc_len;
1147 char **ap, *bp, *endp;
1148
1149 /*
1150 * Check that there aren't an unreasonable number of arguments.
1151 */
1152 if (nchr > ARG_MAX)
1153 return (NULL);
1154
1155 if (nchr == 0)
1156 nchr = ARG_MAX;
1157
1158 /* Get number of strings in argv */
1159 mib[0] = CTL_KERN;
1160 mib[1] = KERN_PROC_ARGS;
1161 mib[2] = pid;
1162 mib[3] = type == KERN_PROC_ARGV ? KERN_PROC_NARGV : KERN_PROC_NENV;
1163 bufs = sizeof(narg);
1164 if (sysctl(mib, 4, &narg, &bufs, NULL, (size_t)0) == -1)
1165 return (NULL);
1166
1167 if (kd->argv == NULL) {
1168 /*
1169 * Try to avoid reallocs.
1170 */
1171 kd->argc = MAX(narg + 1, 32);
1172 kd->argv = _kvm_malloc(kd, kd->argc * sizeof(*kd->argv));
1173 if (kd->argv == NULL)
1174 return (NULL);
1175 } else if (narg + 1 > kd->argc) {
1176 kd->argc = MAX(2 * kd->argc, narg + 1);
1177 kd->argv = _kvm_realloc(kd, kd->argv, kd->argc *
1178 sizeof(*kd->argv));
1179 if (kd->argv == NULL)
1180 return (NULL);
1181 }
1182
1183 newargspc_len = MIN(nchr, ARG_MAX);
1184 KVM_ALLOC(kd, argspc, newargspc_len);
1185 memset(kd->argspc, 0, (size_t)kd->argspc_len); /* XXX necessary? */
1186
1187 mib[0] = CTL_KERN;
1188 mib[1] = KERN_PROC_ARGS;
1189 mib[2] = pid;
1190 mib[3] = type;
1191 bufs = kd->argspc_len;
1192 if (sysctl(mib, 4, kd->argspc, &bufs, NULL, (size_t)0) == -1)
1193 return (NULL);
1194
1195 bp = kd->argspc;
1196 bp[kd->argspc_len-1] = '\0'; /* make sure the string ends with nul */
1197 ap = kd->argv;
1198 endp = bp + MIN(nchr, bufs);
1199
1200 while (bp < endp) {
1201 *ap++ = bp;
1202 /*
1203 * XXX: don't need following anymore, or stick check
1204 * for max argc in above while loop?
1205 */
1206 if (ap >= kd->argv + kd->argc) {
1207 kd->argc *= 2;
1208 kd->argv = _kvm_realloc(kd, kd->argv,
1209 kd->argc * sizeof(*kd->argv));
1210 ap = kd->argv;
1211 }
1212 bp += strlen(bp) + 1;
1213 }
1214 *ap = NULL;
1215
1216 return (kd->argv);
1217 }
1218
1219 char **
1220 kvm_getargv2(kd, kp, nchr)
1221 kvm_t *kd;
1222 const struct kinfo_proc2 *kp;
1223 int nchr;
1224 {
1225
1226 return (kvm_doargv2(kd, kp->p_pid, KERN_PROC_ARGV, nchr));
1227 }
1228
1229 char **
1230 kvm_getenvv2(kd, kp, nchr)
1231 kvm_t *kd;
1232 const struct kinfo_proc2 *kp;
1233 int nchr;
1234 {
1235
1236 return (kvm_doargv2(kd, kp->p_pid, KERN_PROC_ENV, nchr));
1237 }
1238
1239 /*
1240 * Read from user space. The user context is given by p.
1241 */
1242 static ssize_t
1243 kvm_ureadm(kd, p, uva, buf, len)
1244 kvm_t *kd;
1245 const struct miniproc *p;
1246 u_long uva;
1247 char *buf;
1248 size_t len;
1249 {
1250 char *cp;
1251
1252 cp = buf;
1253 while (len > 0) {
1254 size_t cc;
1255 char *dp;
1256 u_long cnt;
1257
1258 dp = _kvm_ureadm(kd, p, uva, &cnt);
1259 if (dp == NULL) {
1260 _kvm_err(kd, 0, "invalid address (%lx)", uva);
1261 return (0);
1262 }
1263 cc = (size_t)MIN(cnt, len);
1264 memcpy(cp, dp, cc);
1265 cp += cc;
1266 uva += cc;
1267 len -= cc;
1268 }
1269 return (ssize_t)(cp - buf);
1270 }
1271
1272 ssize_t
1273 kvm_uread(kd, p, uva, buf, len)
1274 kvm_t *kd;
1275 const struct proc *p;
1276 u_long uva;
1277 char *buf;
1278 size_t len;
1279 {
1280 struct miniproc mp;
1281
1282 PTOMINI(p, &mp);
1283 return (kvm_ureadm(kd, &mp, uva, buf, len));
1284 }
1285