Home | History | Annotate | Line # | Download | only in libkvm
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