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