xref: /freebsd/lib/libkvm/kvm_proc.c (revision 9c4fb6619c04bc81af36f8785d664eb2520c249a)
158f0484fSRodney W. Grimes /*-
258f0484fSRodney W. Grimes  * Copyright (c) 1989, 1992, 1993
358f0484fSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
458f0484fSRodney W. Grimes  *
558f0484fSRodney W. Grimes  * This code is derived from software developed by the Computer Systems
658f0484fSRodney W. Grimes  * Engineering group at Lawrence Berkeley Laboratory under DARPA contract
758f0484fSRodney W. Grimes  * BG 91-66 and contributed to Berkeley.
858f0484fSRodney W. Grimes  *
958f0484fSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
1058f0484fSRodney W. Grimes  * modification, are permitted provided that the following conditions
1158f0484fSRodney W. Grimes  * are met:
1258f0484fSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
1358f0484fSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
1458f0484fSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
1558f0484fSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
1658f0484fSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
1758f0484fSRodney W. Grimes  * 3. All advertising materials mentioning features or use of this software
1858f0484fSRodney W. Grimes  *    must display the following acknowledgement:
1958f0484fSRodney W. Grimes  *	This product includes software developed by the University of
2058f0484fSRodney W. Grimes  *	California, Berkeley and its contributors.
2158f0484fSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
2258f0484fSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
2358f0484fSRodney W. Grimes  *    without specific prior written permission.
2458f0484fSRodney W. Grimes  *
2558f0484fSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
2658f0484fSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
2758f0484fSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
2858f0484fSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
2958f0484fSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
3058f0484fSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
3158f0484fSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
3258f0484fSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
3358f0484fSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
3458f0484fSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
3558f0484fSRodney W. Grimes  * SUCH DAMAGE.
3658f0484fSRodney W. Grimes  */
3758f0484fSRodney W. Grimes 
38f86e3350SBruce Evans #if 0
3958f0484fSRodney W. Grimes #if defined(LIBC_SCCS) && !defined(lint)
4058f0484fSRodney W. Grimes static char sccsid[] = "@(#)kvm_proc.c	8.3 (Berkeley) 9/23/93";
4158f0484fSRodney W. Grimes #endif /* LIBC_SCCS and not lint */
42f86e3350SBruce Evans #endif
43f86e3350SBruce Evans 
44f86e3350SBruce Evans #include <sys/cdefs.h>
45f86e3350SBruce Evans __FBSDID("$FreeBSD$");
4658f0484fSRodney W. Grimes 
4758f0484fSRodney W. Grimes /*
4858f0484fSRodney W. Grimes  * Proc traversal interface for kvm.  ps and w are (probably) the exclusive
4958f0484fSRodney W. Grimes  * users of this code, so we've factored it out into a separate module.
5058f0484fSRodney W. Grimes  * Thus, we keep this grunge out of the other kvm applications (i.e.,
5158f0484fSRodney W. Grimes  * most other applications are interested only in open/close/read/nlist).
5258f0484fSRodney W. Grimes  */
5358f0484fSRodney W. Grimes 
5458f0484fSRodney W. Grimes #include <sys/param.h>
55b20ea179SAlfred Perlstein #define _WANT_UCRED	/* make ucred.h give us 'struct ucred' */
56aa22cbfeSAlfred Perlstein #include <sys/ucred.h>
5758f0484fSRodney W. Grimes #include <sys/user.h>
5858f0484fSRodney W. Grimes #include <sys/proc.h>
5958f0484fSRodney W. Grimes #include <sys/exec.h>
6058f0484fSRodney W. Grimes #include <sys/stat.h>
61276de18cSGarance A Drosehn #include <sys/sysent.h>
6258f0484fSRodney W. Grimes #include <sys/ioctl.h>
6358f0484fSRodney W. Grimes #include <sys/tty.h>
64338c7541SDavid Greenman #include <sys/file.h>
652bdd5609SPeter Wemm #include <sys/conf.h>
6651295a4dSJordan K. Hubbard #include <stdio.h>
6751295a4dSJordan K. Hubbard #include <stdlib.h>
6858f0484fSRodney W. Grimes #include <unistd.h>
6958f0484fSRodney W. Grimes #include <nlist.h>
7058f0484fSRodney W. Grimes #include <kvm.h>
7158f0484fSRodney W. Grimes 
7258f0484fSRodney W. Grimes #include <vm/vm.h>
7358f0484fSRodney W. Grimes #include <vm/vm_param.h>
7458f0484fSRodney W. Grimes 
7558f0484fSRodney W. Grimes #include <sys/sysctl.h>
7658f0484fSRodney W. Grimes 
7758f0484fSRodney W. Grimes #include <limits.h>
7877721f53SPeter Wemm #include <memory.h>
7958f0484fSRodney W. Grimes #include <paths.h>
8058f0484fSRodney W. Grimes 
8158f0484fSRodney W. Grimes #include "kvm_private.h"
8258f0484fSRodney W. Grimes 
8358f0484fSRodney W. Grimes #define KREAD(kd, addr, obj) \
8458f0484fSRodney W. Grimes 	(kvm_read(kd, addr, (char *)(obj), sizeof(*obj)) != sizeof(*obj))
8558f0484fSRodney W. Grimes 
8658f0484fSRodney W. Grimes /*
8758f0484fSRodney W. Grimes  * Read proc's from memory file into buffer bp, which has space to hold
8858f0484fSRodney W. Grimes  * at most maxcnt procs.
8958f0484fSRodney W. Grimes  */
9058f0484fSRodney W. Grimes static int
9158f0484fSRodney W. Grimes kvm_proclist(kd, what, arg, p, bp, maxcnt)
9258f0484fSRodney W. Grimes 	kvm_t *kd;
9358f0484fSRodney W. Grimes 	int what, arg;
9458f0484fSRodney W. Grimes 	struct proc *p;
9558f0484fSRodney W. Grimes 	struct kinfo_proc *bp;
9658f0484fSRodney W. Grimes 	int maxcnt;
9758f0484fSRodney W. Grimes {
98be04b6d1SDavid E. O'Brien 	int cnt = 0;
991f7d2501SKirk McKusick 	struct kinfo_proc kinfo_proc, *kp;
10058f0484fSRodney W. Grimes 	struct pgrp pgrp;
10158f0484fSRodney W. Grimes 	struct session sess;
1022bdd5609SPeter Wemm 	struct cdev t_cdev;
10358f0484fSRodney W. Grimes 	struct tty tty;
1041f7d2501SKirk McKusick 	struct vmspace vmspace;
105840558b9SJohn Baldwin 	struct sigacts sigacts;
1061f7d2501SKirk McKusick 	struct pstats pstats;
1071f7d2501SKirk McKusick 	struct ucred ucred;
10871fad9fdSJulian Elischer 	struct thread mtd;
109ed062c8dSJulian Elischer 	/*struct kse mke;*/
1104f0db5e0SJulian Elischer 	struct ksegrp mkg;
11158f0484fSRodney W. Grimes 	struct proc proc;
112a58930d8STor Egge 	struct proc pproc;
11349b33de8SBrian Feldman 	struct timeval tv;
114276de18cSGarance A Drosehn 	struct sysentvec sysent;
115276de18cSGarance A Drosehn 	char svname[KI_EMULNAMELEN];
11658f0484fSRodney W. Grimes 
1171f7d2501SKirk McKusick 	kp = &kinfo_proc;
1181f7d2501SKirk McKusick 	kp->ki_structsize = sizeof(kinfo_proc);
11942680b3aSBen Smithurst 	for (; cnt < maxcnt && p != NULL; p = LIST_NEXT(&proc, p_list)) {
1206f8c6a69SPeter Wemm 		memset(kp, 0, sizeof *kp);
12158f0484fSRodney W. Grimes 		if (KREAD(kd, (u_long)p, &proc)) {
12258f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program, "can't read proc at %x", p);
12358f0484fSRodney W. Grimes 			return (-1);
12458f0484fSRodney W. Grimes 		}
12558551c03SJulian Elischer 		if (proc.p_state != PRS_ZOMBIE) {
1263daf63fcSJulian Elischer 			if (KREAD(kd, (u_long)TAILQ_FIRST(&proc.p_threads),
12771fad9fdSJulian Elischer 			    &mtd)) {
12858551c03SJulian Elischer 				_kvm_err(kd, kd->program,
12958551c03SJulian Elischer 				    "can't read thread at %x",
1303daf63fcSJulian Elischer 				    TAILQ_FIRST(&proc.p_threads));
1313daf63fcSJulian Elischer 				return (-1);
1323daf63fcSJulian Elischer 			}
1331566329bSGarance A Drosehn 			if ((proc.p_flag & P_SA) == 0) {
1344f0db5e0SJulian Elischer 				if (KREAD(kd,
1354f0db5e0SJulian Elischer 				    (u_long)TAILQ_FIRST(&proc.p_ksegrps),
1364f0db5e0SJulian Elischer 				    &mkg)) {
1374f0db5e0SJulian Elischer 					_kvm_err(kd, kd->program,
1384f0db5e0SJulian Elischer 					    "can't read ksegrp at %x",
1394f0db5e0SJulian Elischer 					    TAILQ_FIRST(&proc.p_ksegrps));
1404f0db5e0SJulian Elischer 					return (-1);
1414f0db5e0SJulian Elischer 				}
142ed062c8dSJulian Elischer #if 0
1434f0db5e0SJulian Elischer 				if (KREAD(kd,
1444f0db5e0SJulian Elischer 				    (u_long)TAILQ_FIRST(&mkg.kg_kseq), &mke)) {
1454f0db5e0SJulian Elischer 					_kvm_err(kd, kd->program,
1464f0db5e0SJulian Elischer 					    "can't read kse at %x",
1474f0db5e0SJulian Elischer 					    TAILQ_FIRST(&mkg.kg_kseq));
1484f0db5e0SJulian Elischer 					return (-1);
1494f0db5e0SJulian Elischer 				}
150ed062c8dSJulian Elischer #endif
1514f0db5e0SJulian Elischer 			}
15258551c03SJulian Elischer 		}
153b1fc0ec1SRobert Watson 		if (KREAD(kd, (u_long)proc.p_ucred, &ucred) == 0) {
154b1fc0ec1SRobert Watson 			kp->ki_ruid = ucred.cr_ruid;
155b1fc0ec1SRobert Watson 			kp->ki_svuid = ucred.cr_svuid;
156b1fc0ec1SRobert Watson 			kp->ki_rgid = ucred.cr_rgid;
157b1fc0ec1SRobert Watson 			kp->ki_svgid = ucred.cr_svgid;
1581f7d2501SKirk McKusick 			kp->ki_ngroups = ucred.cr_ngroups;
1591f7d2501SKirk McKusick 			bcopy(ucred.cr_groups, kp->ki_groups,
1601f7d2501SKirk McKusick 			    NGROUPS * sizeof(gid_t));
1611f7d2501SKirk McKusick 			kp->ki_uid = ucred.cr_uid;
1621f7d2501SKirk McKusick 		}
16358f0484fSRodney W. Grimes 
164694127f8SDaniel Eischen 		switch(what & ~KERN_PROC_INC_THREAD) {
16558f0484fSRodney W. Grimes 
166276de18cSGarance A Drosehn 		case KERN_PROC_GID:
167276de18cSGarance A Drosehn 			if (kp->ki_groups[0] != (gid_t)arg)
168276de18cSGarance A Drosehn 				continue;
169276de18cSGarance A Drosehn 			break;
170276de18cSGarance A Drosehn 
17158f0484fSRodney W. Grimes 		case KERN_PROC_PID:
17258f0484fSRodney W. Grimes 			if (proc.p_pid != (pid_t)arg)
17358f0484fSRodney W. Grimes 				continue;
17458f0484fSRodney W. Grimes 			break;
17558f0484fSRodney W. Grimes 
176276de18cSGarance A Drosehn 		case KERN_PROC_RGID:
177276de18cSGarance A Drosehn 			if (kp->ki_rgid != (gid_t)arg)
178276de18cSGarance A Drosehn 				continue;
179276de18cSGarance A Drosehn 			break;
180276de18cSGarance A Drosehn 
18158f0484fSRodney W. Grimes 		case KERN_PROC_UID:
1821f7d2501SKirk McKusick 			if (kp->ki_uid != (uid_t)arg)
18358f0484fSRodney W. Grimes 				continue;
18458f0484fSRodney W. Grimes 			break;
18558f0484fSRodney W. Grimes 
18658f0484fSRodney W. Grimes 		case KERN_PROC_RUID:
1871f7d2501SKirk McKusick 			if (kp->ki_ruid != (uid_t)arg)
18858f0484fSRodney W. Grimes 				continue;
18958f0484fSRodney W. Grimes 			break;
19058f0484fSRodney W. Grimes 		}
19158f0484fSRodney W. Grimes 		/*
19258f0484fSRodney W. Grimes 		 * We're going to add another proc to the set.  If this
19358f0484fSRodney W. Grimes 		 * will overflow the buffer, assume the reason is because
19458f0484fSRodney W. Grimes 		 * nprocs (or the proc list) is corrupt and declare an error.
19558f0484fSRodney W. Grimes 		 */
19658f0484fSRodney W. Grimes 		if (cnt >= maxcnt) {
19758f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program, "nprocs corrupt");
19858f0484fSRodney W. Grimes 			return (-1);
19958f0484fSRodney W. Grimes 		}
20058f0484fSRodney W. Grimes 		/*
2011f7d2501SKirk McKusick 		 * gather kinfo_proc
20258f0484fSRodney W. Grimes 		 */
2031f7d2501SKirk McKusick 		kp->ki_paddr = p;
2047a62aa8aSDavid Schultz 		kp->ki_addr = 0;	/* XXX uarea */
205b40ce416SJulian Elischer 		/* kp->ki_kstack = proc.p_thread.td_kstack; XXXKSE */
2061f7d2501SKirk McKusick 		kp->ki_args = proc.p_args;
2078b7a975eSJohn Baldwin 		kp->ki_tracep = proc.p_tracevp;
2081f7d2501SKirk McKusick 		kp->ki_textvp = proc.p_textvp;
2091f7d2501SKirk McKusick 		kp->ki_fd = proc.p_fd;
2101f7d2501SKirk McKusick 		kp->ki_vmspace = proc.p_vmspace;
211840558b9SJohn Baldwin 		if (proc.p_sigacts != NULL) {
212840558b9SJohn Baldwin 			if (KREAD(kd, (u_long)proc.p_sigacts, &sigacts)) {
2131f7d2501SKirk McKusick 				_kvm_err(kd, kd->program,
214840558b9SJohn Baldwin 				    "can't read sigacts at %x", proc.p_sigacts);
2151f7d2501SKirk McKusick 				return (-1);
2161f7d2501SKirk McKusick 			}
217840558b9SJohn Baldwin 			kp->ki_sigignore = sigacts.ps_sigignore;
218840558b9SJohn Baldwin 			kp->ki_sigcatch = sigacts.ps_sigcatch;
2191f7d2501SKirk McKusick 		}
2206d3e7b9bSJohn Baldwin 		if ((proc.p_sflag & PS_INMEM) && proc.p_stats != NULL) {
2211f7d2501SKirk McKusick 			if (KREAD(kd, (u_long)proc.p_stats, &pstats)) {
2221f7d2501SKirk McKusick 				_kvm_err(kd, kd->program,
2231f7d2501SKirk McKusick 				    "can't read stats at %x", proc.p_stats);
2241f7d2501SKirk McKusick 				return (-1);
2251f7d2501SKirk McKusick 			}
2261f7d2501SKirk McKusick 			kp->ki_start = pstats.p_start;
22709ff687cSJohn Baldwin 
22809ff687cSJohn Baldwin 			/*
22909ff687cSJohn Baldwin 			 * XXX: The times here are probably zero and need
23009ff687cSJohn Baldwin 			 * to be calculated from the raw data in p_rux and
23109ff687cSJohn Baldwin 			 * p_crux.
23209ff687cSJohn Baldwin 			 */
2331f7d2501SKirk McKusick 			kp->ki_rusage = pstats.p_ru;
234276de18cSGarance A Drosehn 			kp->ki_childstime = pstats.p_cru.ru_stime;
235276de18cSGarance A Drosehn 			kp->ki_childutime = pstats.p_cru.ru_utime;
236276de18cSGarance A Drosehn 			/* Some callers want child-times in a single value */
237276de18cSGarance A Drosehn 			timeradd(&kp->ki_childstime, &kp->ki_childutime,
238276de18cSGarance A Drosehn 			    &kp->ki_childtime);
2391f7d2501SKirk McKusick 		}
240a58930d8STor Egge 		if (proc.p_oppid)
2411f7d2501SKirk McKusick 			kp->ki_ppid = proc.p_oppid;
242a58930d8STor Egge 		else if (proc.p_pptr) {
243a58930d8STor Egge 			if (KREAD(kd, (u_long)proc.p_pptr, &pproc)) {
2441f7d2501SKirk McKusick 				_kvm_err(kd, kd->program,
2451f7d2501SKirk McKusick 				    "can't read pproc at %x", proc.p_pptr);
246a58930d8STor Egge 				return (-1);
247a58930d8STor Egge 			}
2481f7d2501SKirk McKusick 			kp->ki_ppid = pproc.p_pid;
249a58930d8STor Egge 		} else
2501f7d2501SKirk McKusick 			kp->ki_ppid = 0;
2516f8c6a69SPeter Wemm 		if (proc.p_pgrp == NULL)
2526f8c6a69SPeter Wemm 			goto nopgrp;
2536f8c6a69SPeter Wemm 		if (KREAD(kd, (u_long)proc.p_pgrp, &pgrp)) {
2546f8c6a69SPeter Wemm 			_kvm_err(kd, kd->program, "can't read pgrp at %x",
2556f8c6a69SPeter Wemm 				 proc.p_pgrp);
2566f8c6a69SPeter Wemm 			return (-1);
2576f8c6a69SPeter Wemm 		}
2581f7d2501SKirk McKusick 		kp->ki_pgid = pgrp.pg_id;
2591f7d2501SKirk McKusick 		kp->ki_jobc = pgrp.pg_jobc;
26058f0484fSRodney W. Grimes 		if (KREAD(kd, (u_long)pgrp.pg_session, &sess)) {
26158f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program, "can't read session at %x",
26258f0484fSRodney W. Grimes 				pgrp.pg_session);
26358f0484fSRodney W. Grimes 			return (-1);
26458f0484fSRodney W. Grimes 		}
2651f7d2501SKirk McKusick 		kp->ki_sid = sess.s_sid;
2661f7d2501SKirk McKusick 		(void)memcpy(kp->ki_login, sess.s_login,
2671f7d2501SKirk McKusick 						sizeof(kp->ki_login));
2681f7d2501SKirk McKusick 		kp->ki_kiflag = sess.s_ttyvp ? KI_CTTY : 0;
2691f7d2501SKirk McKusick 		if (sess.s_leader == p)
2701f7d2501SKirk McKusick 			kp->ki_kiflag |= KI_SLEADER;
27158f0484fSRodney W. Grimes 		if ((proc.p_flag & P_CONTROLT) && sess.s_ttyp != NULL) {
27258f0484fSRodney W. Grimes 			if (KREAD(kd, (u_long)sess.s_ttyp, &tty)) {
27358f0484fSRodney W. Grimes 				_kvm_err(kd, kd->program,
27458f0484fSRodney W. Grimes 					 "can't read tty at %x", sess.s_ttyp);
27558f0484fSRodney W. Grimes 				return (-1);
27658f0484fSRodney W. Grimes 			}
2772bdd5609SPeter Wemm 			if (tty.t_dev != NULL) {
2782bdd5609SPeter Wemm 				if (KREAD(kd, (u_long)tty.t_dev, &t_cdev)) {
2792bdd5609SPeter Wemm 					_kvm_err(kd, kd->program,
2802bdd5609SPeter Wemm 						 "can't read cdev at %x",
2812bdd5609SPeter Wemm 						tty.t_dev);
2822bdd5609SPeter Wemm 					return (-1);
2832bdd5609SPeter Wemm 				}
2849c4fb661SPoul-Henning Kamp #if 0
2852bdd5609SPeter Wemm 				kp->ki_tdev = t_cdev.si_udev;
2869c4fb661SPoul-Henning Kamp #else
2879c4fb661SPoul-Henning Kamp 				kp->ki_tdev = NULL;
2889c4fb661SPoul-Henning Kamp #endif
2892bdd5609SPeter Wemm 			}
29058f0484fSRodney W. Grimes 			if (tty.t_pgrp != NULL) {
29158f0484fSRodney W. Grimes 				if (KREAD(kd, (u_long)tty.t_pgrp, &pgrp)) {
29258f0484fSRodney W. Grimes 					_kvm_err(kd, kd->program,
293d3cf4981SKris Kennaway 						 "can't read tpgrp at %x",
29458f0484fSRodney W. Grimes 						tty.t_pgrp);
29558f0484fSRodney W. Grimes 					return (-1);
29658f0484fSRodney W. Grimes 				}
2971f7d2501SKirk McKusick 				kp->ki_tpgid = pgrp.pg_id;
29858f0484fSRodney W. Grimes 			} else
2991f7d2501SKirk McKusick 				kp->ki_tpgid = -1;
3001f7d2501SKirk McKusick 			if (tty.t_session != NULL) {
3011f7d2501SKirk McKusick 				if (KREAD(kd, (u_long)tty.t_session, &sess)) {
3021f7d2501SKirk McKusick 					_kvm_err(kd, kd->program,
3031f7d2501SKirk McKusick 					    "can't read session at %x",
3041f7d2501SKirk McKusick 					    tty.t_session);
3051f7d2501SKirk McKusick 					return (-1);
3061f7d2501SKirk McKusick 				}
3071f7d2501SKirk McKusick 				kp->ki_tsid = sess.s_sid;
3081f7d2501SKirk McKusick 			}
3096f8c6a69SPeter Wemm 		} else {
3106f8c6a69SPeter Wemm nopgrp:
3111f7d2501SKirk McKusick 			kp->ki_tdev = NODEV;
3126f8c6a69SPeter Wemm 		}
31371fad9fdSJulian Elischer 		if ((proc.p_state != PRS_ZOMBIE) && mtd.td_wmesg)
31471fad9fdSJulian Elischer 			(void)kvm_read(kd, (u_long)mtd.td_wmesg,
3151f7d2501SKirk McKusick 			    kp->ki_wmesg, WMESGLEN);
31658f0484fSRodney W. Grimes 
31758f0484fSRodney W. Grimes 		(void)kvm_read(kd, (u_long)proc.p_vmspace,
3181f7d2501SKirk McKusick 		    (char *)&vmspace, sizeof(vmspace));
3191f7d2501SKirk McKusick 		kp->ki_size = vmspace.vm_map.size;
3201f7d2501SKirk McKusick 		kp->ki_rssize = vmspace.vm_swrss; /* XXX */
3211f7d2501SKirk McKusick 		kp->ki_swrss = vmspace.vm_swrss;
3221f7d2501SKirk McKusick 		kp->ki_tsize = vmspace.vm_tsize;
3231f7d2501SKirk McKusick 		kp->ki_dsize = vmspace.vm_dsize;
3241f7d2501SKirk McKusick 		kp->ki_ssize = vmspace.vm_ssize;
32558f0484fSRodney W. Grimes 
326694127f8SDaniel Eischen 		switch (what & ~KERN_PROC_INC_THREAD) {
32758f0484fSRodney W. Grimes 
32858f0484fSRodney W. Grimes 		case KERN_PROC_PGRP:
3291f7d2501SKirk McKusick 			if (kp->ki_pgid != (pid_t)arg)
33058f0484fSRodney W. Grimes 				continue;
33158f0484fSRodney W. Grimes 			break;
33258f0484fSRodney W. Grimes 
333276de18cSGarance A Drosehn 		case KERN_PROC_SESSION:
334276de18cSGarance A Drosehn 			if (kp->ki_sid != (pid_t)arg)
335276de18cSGarance A Drosehn 				continue;
336276de18cSGarance A Drosehn 			break;
337276de18cSGarance A Drosehn 
33858f0484fSRodney W. Grimes 		case KERN_PROC_TTY:
33958f0484fSRodney W. Grimes 			if ((proc.p_flag & P_CONTROLT) == 0 ||
3401f7d2501SKirk McKusick 			     kp->ki_tdev != (dev_t)arg)
34158f0484fSRodney W. Grimes 				continue;
34258f0484fSRodney W. Grimes 			break;
34358f0484fSRodney W. Grimes 		}
344b7e7c21aSGarance A Drosehn 		if (proc.p_comm[0] != 0)
345b7e7c21aSGarance A Drosehn 			strlcpy(kp->ki_comm, proc.p_comm, MAXCOMLEN);
346276de18cSGarance A Drosehn 		(void)kvm_read(kd, (u_long)proc.p_sysent, (char *)&sysent,
347276de18cSGarance A Drosehn 		    sizeof(sysent));
348276de18cSGarance A Drosehn 		(void)kvm_read(kd, (u_long)sysent.sv_name, (char *)&svname,
349276de18cSGarance A Drosehn 		    sizeof(svname));
350276de18cSGarance A Drosehn 		if (svname[0] != 0)
351276de18cSGarance A Drosehn 			strlcpy(kp->ki_emul, svname, KI_EMULNAMELEN);
352bff4151cSJulian Elischer 		if ((proc.p_state != PRS_ZOMBIE) &&
35371fad9fdSJulian Elischer 		    (mtd.td_blocked != 0)) {
3540d632649SJohn Baldwin 			kp->ki_kiflag |= KI_LOCKBLOCK;
3550d632649SJohn Baldwin 			if (mtd.td_lockname)
356bff4151cSJulian Elischer 				(void)kvm_read(kd,
3570d632649SJohn Baldwin 				    (u_long)mtd.td_lockname,
3580d632649SJohn Baldwin 				    kp->ki_lockname, LOCKNAMELEN);
3590d632649SJohn Baldwin 			kp->ki_lockname[LOCKNAMELEN] = 0;
3601f7d2501SKirk McKusick 		}
36109ff687cSJohn Baldwin 		bintime2timeval(&proc.p_rux.rux_runtime, &tv);
36249b33de8SBrian Feldman 		kp->ki_runtime = (u_int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3631f7d2501SKirk McKusick 		kp->ki_pid = proc.p_pid;
364e8a58a83SJuli Mallett 		kp->ki_siglist = proc.p_siglist;
36542d3ad71SJeff Roberson 		SIGSETOR(kp->ki_siglist, mtd.td_siglist);
36631a9779eSJeff Roberson 		kp->ki_sigmask = mtd.td_sigmask;
3671f7d2501SKirk McKusick 		kp->ki_xstat = proc.p_xstat;
3681f7d2501SKirk McKusick 		kp->ki_acflag = proc.p_acflag;
3694f0db5e0SJulian Elischer 		kp->ki_lock = proc.p_lock;
370bff4151cSJulian Elischer 		if (proc.p_state != PRS_ZOMBIE) {
3711f7d2501SKirk McKusick 			kp->ki_swtime = proc.p_swtime;
3726143c383SJulian Elischer 			kp->ki_flag = proc.p_flag;
3736d3e7b9bSJohn Baldwin 			kp->ki_sflag = proc.p_sflag;
37430105366SJulian Elischer 			kp->ki_nice = proc.p_nice;
3751f7d2501SKirk McKusick 			kp->ki_traceflag = proc.p_traceflag;
3766143c383SJulian Elischer 			if (proc.p_state == PRS_NORMAL) {
37771fad9fdSJulian Elischer 				if (TD_ON_RUNQ(&mtd) ||
37871fad9fdSJulian Elischer 				    TD_CAN_RUN(&mtd) ||
37971fad9fdSJulian Elischer 				    TD_IS_RUNNING(&mtd)) {
380e602ba25SJulian Elischer 					kp->ki_stat = SRUN;
3814f0db5e0SJulian Elischer 				} else if (mtd.td_state ==
3824f0db5e0SJulian Elischer 				    TDS_INHIBITED) {
38371fad9fdSJulian Elischer 					if (P_SHOULDSTOP(&proc)) {
384e602ba25SJulian Elischer 						kp->ki_stat = SSTOP;
3854f0db5e0SJulian Elischer 					} else if (
3864f0db5e0SJulian Elischer 					    TD_IS_SLEEPING(&mtd)) {
38771fad9fdSJulian Elischer 						kp->ki_stat = SSLEEP;
3880d632649SJohn Baldwin 					} else if (TD_ON_LOCK(&mtd)) {
3890d632649SJohn Baldwin 						kp->ki_stat = SLOCK;
390e602ba25SJulian Elischer 					} else {
391e602ba25SJulian Elischer 						kp->ki_stat = SWAIT;
392e602ba25SJulian Elischer 					}
39371fad9fdSJulian Elischer 				}
394e602ba25SJulian Elischer 			} else {
395e602ba25SJulian Elischer 				kp->ki_stat = SIDL;
396e602ba25SJulian Elischer 			}
3974f0db5e0SJulian Elischer 			/* Stuff from the thread */
39871fad9fdSJulian Elischer 			kp->ki_pri.pri_level = mtd.td_priority;
39971fad9fdSJulian Elischer 			kp->ki_pri.pri_native = mtd.td_base_pri;
40071fad9fdSJulian Elischer 			kp->ki_lastcpu = mtd.td_lastcpu;
4014f0db5e0SJulian Elischer 			kp->ki_wchan = mtd.td_wchan;
402a0ddbf49SJulian Elischer 			kp->ki_oncpu = mtd.td_oncpu;
4034f0db5e0SJulian Elischer 
404d8406adaSDavid Xu 			if (!(proc.p_flag & P_SA)) {
4054f0db5e0SJulian Elischer 				/* stuff from the ksegrp */
4064f0db5e0SJulian Elischer 				kp->ki_slptime = mkg.kg_slptime;
4074f0db5e0SJulian Elischer 				kp->ki_pri.pri_class = mkg.kg_pri_class;
4084f0db5e0SJulian Elischer 				kp->ki_pri.pri_user = mkg.kg_user_pri;
4094f0db5e0SJulian Elischer 				kp->ki_estcpu = mkg.kg_estcpu;
4104f0db5e0SJulian Elischer 
411ed062c8dSJulian Elischer #if 0
4124f0db5e0SJulian Elischer 				/* Stuff from the kse */
4134f0db5e0SJulian Elischer 				kp->ki_pctcpu = mke.ke_pctcpu;
4144f0db5e0SJulian Elischer 				kp->ki_rqindex = mke.ke_rqindex;
415ed062c8dSJulian Elischer #else
416ed062c8dSJulian Elischer 				kp->ki_pctcpu = 0;
417ed062c8dSJulian Elischer 				kp->ki_rqindex = 0;
418ed062c8dSJulian Elischer #endif
4194f0db5e0SJulian Elischer 			} else {
4204f0db5e0SJulian Elischer 				kp->ki_tdflags = -1;
4214f0db5e0SJulian Elischer 				/* All the rest are 0 for now */
4224f0db5e0SJulian Elischer 			}
4236143c383SJulian Elischer 		} else {
4246143c383SJulian Elischer 			kp->ki_stat = SZOMB;
4256143c383SJulian Elischer 		}
4261f7d2501SKirk McKusick 		bcopy(&kinfo_proc, bp, sizeof(kinfo_proc));
42758f0484fSRodney W. Grimes 		++bp;
42858f0484fSRodney W. Grimes 		++cnt;
42958f0484fSRodney W. Grimes 	}
43058f0484fSRodney W. Grimes 	return (cnt);
43158f0484fSRodney W. Grimes }
43258f0484fSRodney W. Grimes 
43358f0484fSRodney W. Grimes /*
43458f0484fSRodney W. Grimes  * Build proc info array by reading in proc list from a crash dump.
43558f0484fSRodney W. Grimes  * Return number of procs read.  maxcnt is the max we will read.
43658f0484fSRodney W. Grimes  */
43758f0484fSRodney W. Grimes static int
43858f0484fSRodney W. Grimes kvm_deadprocs(kd, what, arg, a_allproc, a_zombproc, maxcnt)
43958f0484fSRodney W. Grimes 	kvm_t *kd;
44058f0484fSRodney W. Grimes 	int what, arg;
44158f0484fSRodney W. Grimes 	u_long a_allproc;
44258f0484fSRodney W. Grimes 	u_long a_zombproc;
44358f0484fSRodney W. Grimes 	int maxcnt;
44458f0484fSRodney W. Grimes {
445be04b6d1SDavid E. O'Brien 	struct kinfo_proc *bp = kd->procbase;
446be04b6d1SDavid E. O'Brien 	int acnt, zcnt;
44758f0484fSRodney W. Grimes 	struct proc *p;
44858f0484fSRodney W. Grimes 
44958f0484fSRodney W. Grimes 	if (KREAD(kd, a_allproc, &p)) {
45058f0484fSRodney W. Grimes 		_kvm_err(kd, kd->program, "cannot read allproc");
45158f0484fSRodney W. Grimes 		return (-1);
45258f0484fSRodney W. Grimes 	}
45358f0484fSRodney W. Grimes 	acnt = kvm_proclist(kd, what, arg, p, bp, maxcnt);
45458f0484fSRodney W. Grimes 	if (acnt < 0)
45558f0484fSRodney W. Grimes 		return (acnt);
45658f0484fSRodney W. Grimes 
45758f0484fSRodney W. Grimes 	if (KREAD(kd, a_zombproc, &p)) {
45858f0484fSRodney W. Grimes 		_kvm_err(kd, kd->program, "cannot read zombproc");
45958f0484fSRodney W. Grimes 		return (-1);
46058f0484fSRodney W. Grimes 	}
46158f0484fSRodney W. Grimes 	zcnt = kvm_proclist(kd, what, arg, p, bp + acnt, maxcnt - acnt);
46258f0484fSRodney W. Grimes 	if (zcnt < 0)
46358f0484fSRodney W. Grimes 		zcnt = 0;
46458f0484fSRodney W. Grimes 
46558f0484fSRodney W. Grimes 	return (acnt + zcnt);
46658f0484fSRodney W. Grimes }
46758f0484fSRodney W. Grimes 
46858f0484fSRodney W. Grimes struct kinfo_proc *
46958f0484fSRodney W. Grimes kvm_getprocs(kd, op, arg, cnt)
47058f0484fSRodney W. Grimes 	kvm_t *kd;
47158f0484fSRodney W. Grimes 	int op, arg;
47258f0484fSRodney W. Grimes 	int *cnt;
47358f0484fSRodney W. Grimes {
474c2ac238cSDoug Rabson 	int mib[4], st, nprocs;
475c2ac238cSDoug Rabson 	size_t size;
476694127f8SDaniel Eischen 	int temp_op;
47758f0484fSRodney W. Grimes 
47858f0484fSRodney W. Grimes 	if (kd->procbase != 0) {
47958f0484fSRodney W. Grimes 		free((void *)kd->procbase);
48058f0484fSRodney W. Grimes 		/*
48158f0484fSRodney W. Grimes 		 * Clear this pointer in case this call fails.  Otherwise,
48258f0484fSRodney W. Grimes 		 * kvm_close() will free it again.
48358f0484fSRodney W. Grimes 		 */
48458f0484fSRodney W. Grimes 		kd->procbase = 0;
48558f0484fSRodney W. Grimes 	}
48658f0484fSRodney W. Grimes 	if (ISALIVE(kd)) {
48758f0484fSRodney W. Grimes 		size = 0;
48858f0484fSRodney W. Grimes 		mib[0] = CTL_KERN;
48958f0484fSRodney W. Grimes 		mib[1] = KERN_PROC;
49058f0484fSRodney W. Grimes 		mib[2] = op;
49158f0484fSRodney W. Grimes 		mib[3] = arg;
492694127f8SDaniel Eischen 		temp_op = op & ~KERN_PROC_INC_THREAD;
493694127f8SDaniel Eischen 		st = sysctl(mib,
494694127f8SDaniel Eischen 		    temp_op == KERN_PROC_ALL || temp_op == KERN_PROC_PROC ?
495f2dd06abSTim J. Robbins 		    3 : 4, NULL, &size, NULL, 0);
49658f0484fSRodney W. Grimes 		if (st == -1) {
49758f0484fSRodney W. Grimes 			_kvm_syserr(kd, kd->program, "kvm_getprocs");
49858f0484fSRodney W. Grimes 			return (0);
49958f0484fSRodney W. Grimes 		}
50021687047SDima Dorfman 		/*
50121687047SDima Dorfman 		 * We can't continue with a size of 0 because we pass
50221687047SDima Dorfman 		 * it to realloc() (via _kvm_realloc()), and passing 0
50321687047SDima Dorfman 		 * to realloc() results in undefined behavior.
50421687047SDima Dorfman 		 */
50521687047SDima Dorfman 		if (size == 0) {
50621687047SDima Dorfman 			/*
50721687047SDima Dorfman 			 * XXX: We should probably return an invalid,
50821687047SDima Dorfman 			 * but non-NULL, pointer here so any client
50921687047SDima Dorfman 			 * program trying to dereference it will
51021687047SDima Dorfman 			 * crash.  However, _kvm_freeprocs() calls
51121687047SDima Dorfman 			 * free() on kd->procbase if it isn't NULL,
51221687047SDima Dorfman 			 * and free()'ing a junk pointer isn't good.
51321687047SDima Dorfman 			 * Then again, _kvm_freeprocs() isn't used
51421687047SDima Dorfman 			 * anywhere . . .
51521687047SDima Dorfman 			 */
51621687047SDima Dorfman 			kd->procbase = _kvm_malloc(kd, 1);
51721687047SDima Dorfman 			goto liveout;
51821687047SDima Dorfman 		}
519b2d3d0f0SDag-Erling Smørgrav 		do {
520b2d3d0f0SDag-Erling Smørgrav 			size += size / 10;
521b2d3d0f0SDag-Erling Smørgrav 			kd->procbase = (struct kinfo_proc *)
522b2d3d0f0SDag-Erling Smørgrav 			    _kvm_realloc(kd, kd->procbase, size);
52358f0484fSRodney W. Grimes 			if (kd->procbase == 0)
52458f0484fSRodney W. Grimes 				return (0);
525694127f8SDaniel Eischen 			st = sysctl(mib, temp_op == KERN_PROC_ALL ||
526694127f8SDaniel Eischen 			    temp_op == KERN_PROC_PROC ? 3 : 4,
527b2d3d0f0SDag-Erling Smørgrav 			    kd->procbase, &size, NULL, 0);
528b2d3d0f0SDag-Erling Smørgrav 		} while (st == -1 && errno == ENOMEM);
52958f0484fSRodney W. Grimes 		if (st == -1) {
53058f0484fSRodney W. Grimes 			_kvm_syserr(kd, kd->program, "kvm_getprocs");
53158f0484fSRodney W. Grimes 			return (0);
53258f0484fSRodney W. Grimes 		}
53321687047SDima Dorfman 		/*
53421687047SDima Dorfman 		 * We have to check the size again because sysctl()
53521687047SDima Dorfman 		 * may "round up" oldlenp if oldp is NULL; hence it
53621687047SDima Dorfman 		 * might've told us that there was data to get when
53721687047SDima Dorfman 		 * there really isn't any.
53821687047SDima Dorfman 		 */
5390627f53bSDavid Malone 		if (size > 0 &&
5400627f53bSDavid Malone 		    kd->procbase->ki_structsize != sizeof(struct kinfo_proc)) {
54158f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program,
5421f7d2501SKirk McKusick 			    "kinfo_proc size mismatch (expected %d, got %d)",
5431f7d2501SKirk McKusick 			    sizeof(struct kinfo_proc),
5441f7d2501SKirk McKusick 			    kd->procbase->ki_structsize);
54558f0484fSRodney W. Grimes 			return (0);
54658f0484fSRodney W. Grimes 		}
54721687047SDima Dorfman liveout:
548d339edcfSDavid Malone 		nprocs = size == 0 ? 0 : size / kd->procbase->ki_structsize;
54958f0484fSRodney W. Grimes 	} else {
55058f0484fSRodney W. Grimes 		struct nlist nl[4], *p;
55158f0484fSRodney W. Grimes 
55258f0484fSRodney W. Grimes 		nl[0].n_name = "_nprocs";
55358f0484fSRodney W. Grimes 		nl[1].n_name = "_allproc";
55458f0484fSRodney W. Grimes 		nl[2].n_name = "_zombproc";
55558f0484fSRodney W. Grimes 		nl[3].n_name = 0;
55658f0484fSRodney W. Grimes 
55758f0484fSRodney W. Grimes 		if (kvm_nlist(kd, nl) != 0) {
55858f0484fSRodney W. Grimes 			for (p = nl; p->n_type != 0; ++p)
55958f0484fSRodney W. Grimes 				;
56058f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program,
56158f0484fSRodney W. Grimes 				 "%s: no such symbol", p->n_name);
56258f0484fSRodney W. Grimes 			return (0);
56358f0484fSRodney W. Grimes 		}
56458f0484fSRodney W. Grimes 		if (KREAD(kd, nl[0].n_value, &nprocs)) {
56558f0484fSRodney W. Grimes 			_kvm_err(kd, kd->program, "can't read nprocs");
56658f0484fSRodney W. Grimes 			return (0);
56758f0484fSRodney W. Grimes 		}
56858f0484fSRodney W. Grimes 		size = nprocs * sizeof(struct kinfo_proc);
56958f0484fSRodney W. Grimes 		kd->procbase = (struct kinfo_proc *)_kvm_malloc(kd, size);
57058f0484fSRodney W. Grimes 		if (kd->procbase == 0)
57158f0484fSRodney W. Grimes 			return (0);
57258f0484fSRodney W. Grimes 
57358f0484fSRodney W. Grimes 		nprocs = kvm_deadprocs(kd, op, arg, nl[1].n_value,
57458f0484fSRodney W. Grimes 				      nl[2].n_value, nprocs);
57558f0484fSRodney W. Grimes #ifdef notdef
57658f0484fSRodney W. Grimes 		size = nprocs * sizeof(struct kinfo_proc);
57758f0484fSRodney W. Grimes 		(void)realloc(kd->procbase, size);
57858f0484fSRodney W. Grimes #endif
57958f0484fSRodney W. Grimes 	}
58058f0484fSRodney W. Grimes 	*cnt = nprocs;
58158f0484fSRodney W. Grimes 	return (kd->procbase);
58258f0484fSRodney W. Grimes }
58358f0484fSRodney W. Grimes 
58458f0484fSRodney W. Grimes void
58558f0484fSRodney W. Grimes _kvm_freeprocs(kd)
58658f0484fSRodney W. Grimes 	kvm_t *kd;
58758f0484fSRodney W. Grimes {
58858f0484fSRodney W. Grimes 	if (kd->procbase) {
58958f0484fSRodney W. Grimes 		free(kd->procbase);
59058f0484fSRodney W. Grimes 		kd->procbase = 0;
59158f0484fSRodney W. Grimes 	}
59258f0484fSRodney W. Grimes }
59358f0484fSRodney W. Grimes 
59458f0484fSRodney W. Grimes void *
59558f0484fSRodney W. Grimes _kvm_realloc(kd, p, n)
59658f0484fSRodney W. Grimes 	kvm_t *kd;
59758f0484fSRodney W. Grimes 	void *p;
59858f0484fSRodney W. Grimes 	size_t n;
59958f0484fSRodney W. Grimes {
60058f0484fSRodney W. Grimes 	void *np = (void *)realloc(p, n);
60158f0484fSRodney W. Grimes 
602e8420087SWarner Losh 	if (np == 0) {
603e8420087SWarner Losh 		free(p);
60458f0484fSRodney W. Grimes 		_kvm_err(kd, kd->program, "out of memory");
605e8420087SWarner Losh 	}
60658f0484fSRodney W. Grimes 	return (np);
60758f0484fSRodney W. Grimes }
60858f0484fSRodney W. Grimes 
60958f0484fSRodney W. Grimes #ifndef MAX
61058f0484fSRodney W. Grimes #define MAX(a, b) ((a) > (b) ? (a) : (b))
61158f0484fSRodney W. Grimes #endif
61258f0484fSRodney W. Grimes 
61358f0484fSRodney W. Grimes /*
6141f7d2501SKirk McKusick  * Read in an argument vector from the user address space of process kp.
61577721f53SPeter Wemm  * addr if the user-space base address of narg null-terminated contiguous
61658f0484fSRodney W. Grimes  * strings.  This is used to read in both the command arguments and
61758f0484fSRodney W. Grimes  * environment strings.  Read at most maxcnt characters of strings.
61858f0484fSRodney W. Grimes  */
61958f0484fSRodney W. Grimes static char **
6201f7d2501SKirk McKusick kvm_argv(kd, kp, addr, narg, maxcnt)
62158f0484fSRodney W. Grimes 	kvm_t *kd;
6221f7d2501SKirk McKusick 	struct kinfo_proc *kp;
623be04b6d1SDavid E. O'Brien 	u_long addr;
624be04b6d1SDavid E. O'Brien 	int narg;
625be04b6d1SDavid E. O'Brien 	int maxcnt;
62658f0484fSRodney W. Grimes {
627be04b6d1SDavid E. O'Brien 	char *np, *cp, *ep, *ap;
628be04b6d1SDavid E. O'Brien 	u_long oaddr = -1;
629be04b6d1SDavid E. O'Brien 	int len, cc;
630be04b6d1SDavid E. O'Brien 	char **argv;
63158f0484fSRodney W. Grimes 
63258f0484fSRodney W. Grimes 	/*
63358f0484fSRodney W. Grimes 	 * Check that there aren't an unreasonable number of agruments,
63458f0484fSRodney W. Grimes 	 * and that the address is in user space.
63558f0484fSRodney W. Grimes 	 */
6366b492ae4SPeter Wemm 	if (narg > 512 || addr < VM_MIN_ADDRESS || addr >= VM_MAXUSER_ADDRESS)
63758f0484fSRodney W. Grimes 		return (0);
63858f0484fSRodney W. Grimes 
6396b492ae4SPeter Wemm 	/*
6406b492ae4SPeter Wemm 	 * kd->argv : work space for fetching the strings from the target
6416b492ae4SPeter Wemm 	 *            process's space, and is converted for returning to caller
6426b492ae4SPeter Wemm 	 */
64358f0484fSRodney W. Grimes 	if (kd->argv == 0) {
64458f0484fSRodney W. Grimes 		/*
64558f0484fSRodney W. Grimes 		 * Try to avoid reallocs.
64658f0484fSRodney W. Grimes 		 */
64758f0484fSRodney W. Grimes 		kd->argc = MAX(narg + 1, 32);
64858f0484fSRodney W. Grimes 		kd->argv = (char **)_kvm_malloc(kd, kd->argc *
64958f0484fSRodney W. Grimes 						sizeof(*kd->argv));
65058f0484fSRodney W. Grimes 		if (kd->argv == 0)
65158f0484fSRodney W. Grimes 			return (0);
65258f0484fSRodney W. Grimes 	} else if (narg + 1 > kd->argc) {
65358f0484fSRodney W. Grimes 		kd->argc = MAX(2 * kd->argc, narg + 1);
65458f0484fSRodney W. Grimes 		kd->argv = (char **)_kvm_realloc(kd, kd->argv, kd->argc *
65558f0484fSRodney W. Grimes 						sizeof(*kd->argv));
65658f0484fSRodney W. Grimes 		if (kd->argv == 0)
65758f0484fSRodney W. Grimes 			return (0);
65858f0484fSRodney W. Grimes 	}
6596b492ae4SPeter Wemm 	/*
6606b492ae4SPeter Wemm 	 * kd->argspc : returned to user, this is where the kd->argv
6616b492ae4SPeter Wemm 	 *              arrays are left pointing to the collected strings.
6626b492ae4SPeter Wemm 	 */
66358f0484fSRodney W. Grimes 	if (kd->argspc == 0) {
6642572133eSPoul-Henning Kamp 		kd->argspc = (char *)_kvm_malloc(kd, PAGE_SIZE);
66558f0484fSRodney W. Grimes 		if (kd->argspc == 0)
66658f0484fSRodney W. Grimes 			return (0);
6672572133eSPoul-Henning Kamp 		kd->arglen = PAGE_SIZE;
66858f0484fSRodney W. Grimes 	}
6696b492ae4SPeter Wemm 	/*
6706b492ae4SPeter Wemm 	 * kd->argbuf : used to pull in pages from the target process.
6716b492ae4SPeter Wemm 	 *              the strings are copied out of here.
6726b492ae4SPeter Wemm 	 */
67377721f53SPeter Wemm 	if (kd->argbuf == 0) {
6742572133eSPoul-Henning Kamp 		kd->argbuf = (char *)_kvm_malloc(kd, PAGE_SIZE);
67577721f53SPeter Wemm 		if (kd->argbuf == 0)
67677721f53SPeter Wemm 			return (0);
67777721f53SPeter Wemm 	}
6786b492ae4SPeter Wemm 
6796b492ae4SPeter Wemm 	/* Pull in the target process'es argv vector */
68077721f53SPeter Wemm 	cc = sizeof(char *) * narg;
6811f7d2501SKirk McKusick 	if (kvm_uread(kd, kp, addr, (char *)kd->argv, cc) != cc)
68277721f53SPeter Wemm 		return (0);
6836b492ae4SPeter Wemm 	/*
6846b492ae4SPeter Wemm 	 * ap : saved start address of string we're working on in kd->argspc
6856b492ae4SPeter Wemm 	 * np : pointer to next place to write in kd->argspc
6866b492ae4SPeter Wemm 	 * len: length of data in kd->argspc
6876b492ae4SPeter Wemm 	 * argv: pointer to the argv vector that we are hunting around the
6886b492ae4SPeter Wemm 	 *       target process space for, and converting to addresses in
6896b492ae4SPeter Wemm 	 *       our address space (kd->argspc).
6906b492ae4SPeter Wemm 	 */
69177721f53SPeter Wemm 	ap = np = kd->argspc;
69258f0484fSRodney W. Grimes 	argv = kd->argv;
69358f0484fSRodney W. Grimes 	len = 0;
69458f0484fSRodney W. Grimes 	/*
69558f0484fSRodney W. Grimes 	 * Loop over pages, filling in the argument vector.
6966b492ae4SPeter Wemm 	 * Note that the argv strings could be pointing *anywhere* in
6976b492ae4SPeter Wemm 	 * the user address space and are no longer contiguous.
6986b492ae4SPeter Wemm 	 * Note that *argv is modified when we are going to fetch a string
6996b492ae4SPeter Wemm 	 * that crosses a page boundary.  We copy the next part of the string
7006b492ae4SPeter Wemm 	 * into to "np" and eventually convert the pointer.
70158f0484fSRodney W. Grimes 	 */
70277721f53SPeter Wemm 	while (argv < kd->argv + narg && *argv != 0) {
7036b492ae4SPeter Wemm 
7046b492ae4SPeter Wemm 		/* get the address that the current argv string is on */
7052572133eSPoul-Henning Kamp 		addr = (u_long)*argv & ~(PAGE_SIZE - 1);
7066b492ae4SPeter Wemm 
7076b492ae4SPeter Wemm 		/* is it the same page as the last one? */
70877721f53SPeter Wemm 		if (addr != oaddr) {
7091f7d2501SKirk McKusick 			if (kvm_uread(kd, kp, addr, kd->argbuf, PAGE_SIZE) !=
7102572133eSPoul-Henning Kamp 			    PAGE_SIZE)
71177721f53SPeter Wemm 				return (0);
71277721f53SPeter Wemm 			oaddr = addr;
71377721f53SPeter Wemm 		}
7146b492ae4SPeter Wemm 
7156b492ae4SPeter Wemm 		/* offset within the page... kd->argbuf */
7162572133eSPoul-Henning Kamp 		addr = (u_long)*argv & (PAGE_SIZE - 1);
7176b492ae4SPeter Wemm 
7186b492ae4SPeter Wemm 		/* cp = start of string, cc = count of chars in this chunk */
71977721f53SPeter Wemm 		cp = kd->argbuf + addr;
7202572133eSPoul-Henning Kamp 		cc = PAGE_SIZE - addr;
7216b492ae4SPeter Wemm 
7226b492ae4SPeter Wemm 		/* dont get more than asked for by user process */
72358f0484fSRodney W. Grimes 		if (maxcnt > 0 && cc > maxcnt - len)
7246b492ae4SPeter Wemm 			cc = maxcnt - len;
7256b492ae4SPeter Wemm 
7266b492ae4SPeter Wemm 		/* pointer to end of string if we found it in this page */
72777721f53SPeter Wemm 		ep = memchr(cp, '\0', cc);
72877721f53SPeter Wemm 		if (ep != 0)
72977721f53SPeter Wemm 			cc = ep - cp + 1;
7306b492ae4SPeter Wemm 		/*
7316b492ae4SPeter Wemm 		 * at this point, cc is the count of the chars that we are
7326b492ae4SPeter Wemm 		 * going to retrieve this time. we may or may not have found
7336b492ae4SPeter Wemm 		 * the end of it.  (ep points to the null if the end is known)
7346b492ae4SPeter Wemm 		 */
7356b492ae4SPeter Wemm 
7366b492ae4SPeter Wemm 		/* will we exceed the malloc/realloced buffer? */
73758f0484fSRodney W. Grimes 		if (len + cc > kd->arglen) {
738be04b6d1SDavid E. O'Brien 			int off;
739be04b6d1SDavid E. O'Brien 			char **pp;
740be04b6d1SDavid E. O'Brien 			char *op = kd->argspc;
74158f0484fSRodney W. Grimes 
74258f0484fSRodney W. Grimes 			kd->arglen *= 2;
74358f0484fSRodney W. Grimes 			kd->argspc = (char *)_kvm_realloc(kd, kd->argspc,
74458f0484fSRodney W. Grimes 							  kd->arglen);
74558f0484fSRodney W. Grimes 			if (kd->argspc == 0)
74658f0484fSRodney W. Grimes 				return (0);
74758f0484fSRodney W. Grimes 			/*
74858f0484fSRodney W. Grimes 			 * Adjust argv pointers in case realloc moved
74958f0484fSRodney W. Grimes 			 * the string space.
75058f0484fSRodney W. Grimes 			 */
75158f0484fSRodney W. Grimes 			off = kd->argspc - op;
75277721f53SPeter Wemm 			for (pp = kd->argv; pp < argv; pp++)
75358f0484fSRodney W. Grimes 				*pp += off;
75477721f53SPeter Wemm 			ap += off;
75577721f53SPeter Wemm 			np += off;
75658f0484fSRodney W. Grimes 		}
7576b492ae4SPeter Wemm 		/* np = where to put the next part of the string in kd->argspc*/
7586b492ae4SPeter Wemm 		/* np is kinda redundant.. could use "kd->argspc + len" */
75977721f53SPeter Wemm 		memcpy(np, cp, cc);
7606b492ae4SPeter Wemm 		np += cc;	/* inc counters */
76158f0484fSRodney W. Grimes 		len += cc;
7626b492ae4SPeter Wemm 
7636b492ae4SPeter Wemm 		/*
7646b492ae4SPeter Wemm 		 * if end of string found, set the *argv pointer to the
7656b492ae4SPeter Wemm 		 * saved beginning of string, and advance. argv points to
7666b492ae4SPeter Wemm 		 * somewhere in kd->argv..  This is initially relative
7676b492ae4SPeter Wemm 		 * to the target process, but when we close it off, we set
7686b492ae4SPeter Wemm 		 * it to point in our address space.
7696b492ae4SPeter Wemm 		 */
77077721f53SPeter Wemm 		if (ep != 0) {
77177721f53SPeter Wemm 			*argv++ = ap;
77277721f53SPeter Wemm 			ap = np;
7736b492ae4SPeter Wemm 		} else {
7746b492ae4SPeter Wemm 			/* update the address relative to the target process */
77577721f53SPeter Wemm 			*argv += cc;
7766b492ae4SPeter Wemm 		}
7776b492ae4SPeter Wemm 
77858f0484fSRodney W. Grimes 		if (maxcnt > 0 && len >= maxcnt) {
77958f0484fSRodney W. Grimes 			/*
78058f0484fSRodney W. Grimes 			 * We're stopping prematurely.  Terminate the
78177721f53SPeter Wemm 			 * current string.
78258f0484fSRodney W. Grimes 			 */
78377721f53SPeter Wemm 			if (ep == 0) {
78477721f53SPeter Wemm 				*np = '\0';
78577721f53SPeter Wemm 				*argv++ = ap;
78677721f53SPeter Wemm 			}
78777721f53SPeter Wemm 			break;
78877721f53SPeter Wemm 		}
78977721f53SPeter Wemm 	}
79077721f53SPeter Wemm 	/* Make sure argv is terminated. */
79177721f53SPeter Wemm 	*argv = 0;
79258f0484fSRodney W. Grimes 	return (kd->argv);
79358f0484fSRodney W. Grimes }
79458f0484fSRodney W. Grimes 
79558f0484fSRodney W. Grimes static void
79658f0484fSRodney W. Grimes ps_str_a(p, addr, n)
79758f0484fSRodney W. Grimes 	struct ps_strings *p;
79858f0484fSRodney W. Grimes 	u_long *addr;
79958f0484fSRodney W. Grimes 	int *n;
80058f0484fSRodney W. Grimes {
80158f0484fSRodney W. Grimes 	*addr = (u_long)p->ps_argvstr;
80258f0484fSRodney W. Grimes 	*n = p->ps_nargvstr;
80358f0484fSRodney W. Grimes }
80458f0484fSRodney W. Grimes 
80558f0484fSRodney W. Grimes static void
80658f0484fSRodney W. Grimes ps_str_e(p, addr, n)
80758f0484fSRodney W. Grimes 	struct ps_strings *p;
80858f0484fSRodney W. Grimes 	u_long *addr;
80958f0484fSRodney W. Grimes 	int *n;
81058f0484fSRodney W. Grimes {
81158f0484fSRodney W. Grimes 	*addr = (u_long)p->ps_envstr;
81258f0484fSRodney W. Grimes 	*n = p->ps_nenvstr;
81358f0484fSRodney W. Grimes }
81458f0484fSRodney W. Grimes 
81558f0484fSRodney W. Grimes /*
81658f0484fSRodney W. Grimes  * Determine if the proc indicated by p is still active.
81758f0484fSRodney W. Grimes  * This test is not 100% foolproof in theory, but chances of
81858f0484fSRodney W. Grimes  * being wrong are very low.
81958f0484fSRodney W. Grimes  */
82058f0484fSRodney W. Grimes static int
8211f7d2501SKirk McKusick proc_verify(curkp)
8221f7d2501SKirk McKusick 	struct kinfo_proc *curkp;
82358f0484fSRodney W. Grimes {
8241f7d2501SKirk McKusick 	struct kinfo_proc newkp;
82560160c5eSBruce Evans 	int mib[4];
826c2ac238cSDoug Rabson 	size_t len;
82758f0484fSRodney W. Grimes 
82835e6b695SPoul-Henning Kamp 	mib[0] = CTL_KERN;
82935e6b695SPoul-Henning Kamp 	mib[1] = KERN_PROC;
83035e6b695SPoul-Henning Kamp 	mib[2] = KERN_PROC_PID;
8311f7d2501SKirk McKusick 	mib[3] = curkp->ki_pid;
8321f7d2501SKirk McKusick 	len = sizeof(newkp);
8331f7d2501SKirk McKusick 	if (sysctl(mib, 4, &newkp, &len, NULL, 0) == -1)
83458f0484fSRodney W. Grimes 		return (0);
8351f7d2501SKirk McKusick 	return (curkp->ki_pid == newkp.ki_pid &&
8361f7d2501SKirk McKusick 	    (newkp.ki_stat != SZOMB || curkp->ki_stat == SZOMB));
83758f0484fSRodney W. Grimes }
83858f0484fSRodney W. Grimes 
83958f0484fSRodney W. Grimes static char **
84058f0484fSRodney W. Grimes kvm_doargv(kd, kp, nchr, info)
84158f0484fSRodney W. Grimes 	kvm_t *kd;
8421f7d2501SKirk McKusick 	struct kinfo_proc *kp;
84358f0484fSRodney W. Grimes 	int nchr;
84477721f53SPeter Wemm 	void (*info)(struct ps_strings *, u_long *, int *);
84558f0484fSRodney W. Grimes {
8461f7d2501SKirk McKusick 	char **ap;
84758f0484fSRodney W. Grimes 	u_long addr;
84858f0484fSRodney W. Grimes 	int cnt;
84960160c5eSBruce Evans 	static struct ps_strings arginfo;
85060160c5eSBruce Evans 	static u_long ps_strings;
8517350dd84SPeter Wemm 	size_t len;
8527350dd84SPeter Wemm 
8535aaa432dSJens Schweikhardt 	if (ps_strings == 0) {
85460160c5eSBruce Evans 		len = sizeof(ps_strings);
85560160c5eSBruce Evans 		if (sysctlbyname("kern.ps_strings", &ps_strings, &len, NULL,
85660160c5eSBruce Evans 		    0) == -1)
8577350dd84SPeter Wemm 			ps_strings = PS_STRINGS;
85835e6b695SPoul-Henning Kamp 	}
85958f0484fSRodney W. Grimes 
86058f0484fSRodney W. Grimes 	/*
86158f0484fSRodney W. Grimes 	 * Pointers are stored at the top of the user stack.
86258f0484fSRodney W. Grimes 	 */
8631f7d2501SKirk McKusick 	if (kp->ki_stat == SZOMB ||
8641f7d2501SKirk McKusick 	    kvm_uread(kd, kp, ps_strings, (char *)&arginfo,
86577721f53SPeter Wemm 		      sizeof(arginfo)) != sizeof(arginfo))
86658f0484fSRodney W. Grimes 		return (0);
86758f0484fSRodney W. Grimes 
86858f0484fSRodney W. Grimes 	(*info)(&arginfo, &addr, &cnt);
86977721f53SPeter Wemm 	if (cnt == 0)
87077721f53SPeter Wemm 		return (0);
8711f7d2501SKirk McKusick 	ap = kvm_argv(kd, kp, addr, cnt, nchr);
87258f0484fSRodney W. Grimes 	/*
87358f0484fSRodney W. Grimes 	 * For live kernels, make sure this process didn't go away.
87458f0484fSRodney W. Grimes 	 */
8751f7d2501SKirk McKusick 	if (ap != 0 && ISALIVE(kd) && !proc_verify(kp))
87658f0484fSRodney W. Grimes 		ap = 0;
87758f0484fSRodney W. Grimes 	return (ap);
87858f0484fSRodney W. Grimes }
87958f0484fSRodney W. Grimes 
88058f0484fSRodney W. Grimes /*
88158f0484fSRodney W. Grimes  * Get the command args.  This code is now machine independent.
88258f0484fSRodney W. Grimes  */
88358f0484fSRodney W. Grimes char **
88458f0484fSRodney W. Grimes kvm_getargv(kd, kp, nchr)
88558f0484fSRodney W. Grimes 	kvm_t *kd;
88658f0484fSRodney W. Grimes 	const struct kinfo_proc *kp;
88758f0484fSRodney W. Grimes 	int nchr;
88858f0484fSRodney W. Grimes {
889b9df5231SPoul-Henning Kamp 	int oid[4];
890b7875890SDavid E. O'Brien 	int i;
891b7875890SDavid E. O'Brien 	size_t bufsz;
89215d2f5f0SPeter Wemm 	static unsigned long buflen;
893b9df5231SPoul-Henning Kamp 	static char *buf, *p;
894b9df5231SPoul-Henning Kamp 	static char **bufp;
895b9df5231SPoul-Henning Kamp 	static int argc;
896b9df5231SPoul-Henning Kamp 
897c4a7cdb3SPeter Wemm 	if (!ISALIVE(kd)) {
898c4a7cdb3SPeter Wemm 		_kvm_err(kd, kd->program,
899c4a7cdb3SPeter Wemm 		    "cannot read user space from dead kernel");
900c4a7cdb3SPeter Wemm 		return (0);
901c4a7cdb3SPeter Wemm 	}
902c4a7cdb3SPeter Wemm 
903b9df5231SPoul-Henning Kamp 	if (!buflen) {
904b7875890SDavid E. O'Brien 		bufsz = sizeof(buflen);
905b9df5231SPoul-Henning Kamp 		i = sysctlbyname("kern.ps_arg_cache_limit",
906b7875890SDavid E. O'Brien 		    &buflen, &bufsz, NULL, 0);
907b9df5231SPoul-Henning Kamp 		if (i == -1) {
908b7875890SDavid E. O'Brien 			buflen = 0;
909b9df5231SPoul-Henning Kamp 		} else {
910b9df5231SPoul-Henning Kamp 			buf = malloc(buflen);
911b9df5231SPoul-Henning Kamp 			if (buf == NULL)
912b9df5231SPoul-Henning Kamp 				buflen = 0;
913b9df5231SPoul-Henning Kamp 			argc = 32;
914b9df5231SPoul-Henning Kamp 			bufp = malloc(sizeof(char *) * argc);
915b9df5231SPoul-Henning Kamp 		}
916b9df5231SPoul-Henning Kamp 	}
917b9df5231SPoul-Henning Kamp 	if (buf != NULL) {
918b9df5231SPoul-Henning Kamp 		oid[0] = CTL_KERN;
919b9df5231SPoul-Henning Kamp 		oid[1] = KERN_PROC;
920b9df5231SPoul-Henning Kamp 		oid[2] = KERN_PROC_ARGS;
9211f7d2501SKirk McKusick 		oid[3] = kp->ki_pid;
922b7875890SDavid E. O'Brien 		bufsz = buflen;
923b7875890SDavid E. O'Brien 		i = sysctl(oid, 4, buf, &bufsz, 0, 0);
924b7875890SDavid E. O'Brien 		if (i == 0 && bufsz > 0) {
925b9df5231SPoul-Henning Kamp 			i = 0;
926b9df5231SPoul-Henning Kamp 			p = buf;
927b9df5231SPoul-Henning Kamp 			do {
928b9df5231SPoul-Henning Kamp 				bufp[i++] = p;
929b9df5231SPoul-Henning Kamp 				p += strlen(p) + 1;
930b9df5231SPoul-Henning Kamp 				if (i >= argc) {
931b9df5231SPoul-Henning Kamp 					argc += argc;
932b9df5231SPoul-Henning Kamp 					bufp = realloc(bufp,
933b9df5231SPoul-Henning Kamp 					    sizeof(char *) * argc);
934b9df5231SPoul-Henning Kamp 				}
935b7875890SDavid E. O'Brien 			} while (p < buf + bufsz);
936b9df5231SPoul-Henning Kamp 			bufp[i++] = 0;
937b9df5231SPoul-Henning Kamp 			return (bufp);
938b9df5231SPoul-Henning Kamp 		}
939b9df5231SPoul-Henning Kamp 	}
9401f7d2501SKirk McKusick 	if (kp->ki_flag & P_SYSTEM)
941b9df5231SPoul-Henning Kamp 		return (NULL);
94258f0484fSRodney W. Grimes 	return (kvm_doargv(kd, kp, nchr, ps_str_a));
94358f0484fSRodney W. Grimes }
94458f0484fSRodney W. Grimes 
94558f0484fSRodney W. Grimes char **
94658f0484fSRodney W. Grimes kvm_getenvv(kd, kp, nchr)
94758f0484fSRodney W. Grimes 	kvm_t *kd;
94858f0484fSRodney W. Grimes 	const struct kinfo_proc *kp;
94958f0484fSRodney W. Grimes 	int nchr;
95058f0484fSRodney W. Grimes {
95158f0484fSRodney W. Grimes 	return (kvm_doargv(kd, kp, nchr, ps_str_e));
95258f0484fSRodney W. Grimes }
95358f0484fSRodney W. Grimes 
95458f0484fSRodney W. Grimes /*
95558f0484fSRodney W. Grimes  * Read from user space.  The user context is given by p.
95658f0484fSRodney W. Grimes  */
95758f0484fSRodney W. Grimes ssize_t
9581f7d2501SKirk McKusick kvm_uread(kd, kp, uva, buf, len)
95958f0484fSRodney W. Grimes 	kvm_t *kd;
9601f7d2501SKirk McKusick 	struct kinfo_proc *kp;
961be04b6d1SDavid E. O'Brien 	u_long uva;
962be04b6d1SDavid E. O'Brien 	char *buf;
963be04b6d1SDavid E. O'Brien 	size_t len;
96458f0484fSRodney W. Grimes {
965be04b6d1SDavid E. O'Brien 	char *cp;
966338c7541SDavid Greenman 	char procfile[MAXPATHLEN];
967338c7541SDavid Greenman 	ssize_t amount;
968338c7541SDavid Greenman 	int fd;
96958f0484fSRodney W. Grimes 
9707350dd84SPeter Wemm 	if (!ISALIVE(kd)) {
971d7fb4b13SBruce Evans 		_kvm_err(kd, kd->program,
972d7fb4b13SBruce Evans 		    "cannot read user space from dead kernel");
9737350dd84SPeter Wemm 		return (0);
9747350dd84SPeter Wemm 	}
9757350dd84SPeter Wemm 
9761f7d2501SKirk McKusick 	sprintf(procfile, "/proc/%d/mem", kp->ki_pid);
977338c7541SDavid Greenman 	fd = open(procfile, O_RDONLY, 0);
978338c7541SDavid Greenman 	if (fd < 0) {
979338c7541SDavid Greenman 		_kvm_err(kd, kd->program, "cannot open %s", procfile);
98058f0484fSRodney W. Grimes 		return (0);
98158f0484fSRodney W. Grimes 	}
982338c7541SDavid Greenman 
983d7fb4b13SBruce Evans 	cp = buf;
984338c7541SDavid Greenman 	while (len > 0) {
985d7fb4b13SBruce Evans 		errno = 0;
986ec4f2251SJoerg Wunsch 		if (lseek(fd, (off_t)uva, 0) == -1 && errno != 0) {
987d7fb4b13SBruce Evans 			_kvm_err(kd, kd->program, "invalid address (%x) in %s",
988d7fb4b13SBruce Evans 			    uva, procfile);
98958f0484fSRodney W. Grimes 			break;
99058f0484fSRodney W. Grimes 		}
991567127faSDavid Greenman 		amount = read(fd, cp, len);
992338c7541SDavid Greenman 		if (amount < 0) {
993d7fb4b13SBruce Evans 			_kvm_syserr(kd, kd->program, "error reading %s",
994d7fb4b13SBruce Evans 			    procfile);
995d7fb4b13SBruce Evans 			break;
996d7fb4b13SBruce Evans 		}
997d7fb4b13SBruce Evans 		if (amount == 0) {
998d7fb4b13SBruce Evans 			_kvm_err(kd, kd->program, "EOF reading %s", procfile);
999338c7541SDavid Greenman 			break;
1000338c7541SDavid Greenman 		}
1001338c7541SDavid Greenman 		cp += amount;
1002338c7541SDavid Greenman 		uva += amount;
1003338c7541SDavid Greenman 		len -= amount;
1004338c7541SDavid Greenman 	}
1005338c7541SDavid Greenman 
1006338c7541SDavid Greenman 	close(fd);
1007d7fb4b13SBruce Evans 	return ((ssize_t)(cp - buf));
100858f0484fSRodney W. Grimes }
1009