xref: /netbsd-src/lib/libkvm/kvm_proc.c (revision aaf4ece63a859a04e37cf3a7229b5fab0157cc06)
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