/*
* sysctl helper to stuff PF_LOCAL pcbs into sysctl structures
*/
static void
sysctl_dounpcb(struct kinfo_pcb *pcb, const struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
struct sockaddr_un *un = unp->unp_addr;
memset(pcb, 0, sizeof(*pcb));
pcb->ki_family = so->so_proto->pr_domain->dom_family;
pcb->ki_type = so->so_proto->pr_type;
pcb->ki_protocol = so->so_proto->pr_protocol;
pcb->ki_pflags = unp->unp_flags;
pcb->ki_pcbaddr = PTRTOUINT64(unp);
/* pcb->ki_ppcbaddr = unp has no ppcb... */
pcb->ki_sockaddr = PTRTOUINT64(so);
pcb->ki_sostate = so->so_state;
/* pcb->ki_prstate = unp has no state... */
pcb->ki_rcvq = so->so_rcv.sb_cc;
pcb->ki_sndq = so->so_snd.sb_cc;
un = (struct sockaddr_un *)&pcb->ki_src;
/*
* local domain sockets may bind without having a local
* endpoint. bleah!
*/
if (unp->unp_addr != NULL) {
un->sun_len = unp->unp_addr->sun_len;
un->sun_family = unp->unp_addr->sun_family;
strlcpy(un->sun_path, unp->unp_addr->sun_path,
sizeof(pcb->ki_s));
}
else {
un->sun_len = offsetof(struct sockaddr_un, sun_path);
un->sun_family = pcb->ki_family;
}
if (unp->unp_conn != NULL) {
un = (struct sockaddr_un *)&pcb->ki_dst;
if (unp->unp_conn->unp_addr != NULL) {
un->sun_len = unp->unp_conn->unp_addr->sun_len;
un->sun_family = unp->unp_conn->unp_addr->sun_family;
un->sun_family = unp->unp_conn->unp_addr->sun_family;
strlcpy(un->sun_path, unp->unp_conn->unp_addr->sun_path,
sizeof(pcb->ki_d));
}
else {
un->sun_len = offsetof(struct sockaddr_un, sun_path);
un->sun_family = pcb->ki_family;
}
}
/*
* sysctl helper to stuff PF_LOCAL pcbs into sysctl structures
*/
static void
sysctl_dounpcb(struct kinfo_pcb *pcb, const struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
struct sockaddr_un *un = unp->unp_addr;
memset(pcb, 0, sizeof(*pcb));
pcb->ki_family = so->so_proto->pr_domain->dom_family;
pcb->ki_type = so->so_proto->pr_type;
pcb->ki_protocol = so->so_proto->pr_protocol;
pcb->ki_pflags = unp->unp_flags;
pcb->ki_pcbaddr = PTRTOUINT64(unp);
/* pcb->ki_ppcbaddr = unp has no ppcb... */
pcb->ki_sockaddr = PTRTOUINT64(so);
pcb->ki_sostate = so->so_state;
/* pcb->ki_prstate = unp has no state... */
pcb->ki_rcvq = so->so_rcv.sb_cc;
pcb->ki_sndq = so->so_snd.sb_cc;
un = (struct sockaddr_un *)pcb->ki_spad;
/*
* local domain sockets may bind without having a local
* endpoint. bleah!
*/
if (unp->unp_addr != NULL) {
/*
* We've added one to sun_len when allocating to
* hold terminating NUL which we want here. See
* makeun().
*/
memcpy(un, unp->unp_addr,
min(sizeof(pcb->ki_spad), unp->unp_addr->sun_len + 1));
}
else {
un->sun_len = offsetof(struct sockaddr_un, sun_path);
un->sun_family = pcb->ki_family;
}
if (unp->unp_conn != NULL) {
un = (struct sockaddr_un *)pcb->ki_dpad;
if (unp->unp_conn->unp_addr != NULL) {
memcpy(un, unp->unp_conn->unp_addr,
min(sizeof(pcb->ki_dpad), unp->unp_conn->unp_addr->sun_len + 1));
}
else {
un->sun_len = offsetof(struct sockaddr_un, sun_path);
un->sun_family = pcb->ki_family;
}
}
un = (struct sockaddr_un *)&pcb->ki_dst;
if (unp->unp_conn->unp_addr != NULL) {
un->sun_len = unp->unp_conn->unp_addr->sun_len;
un->sun_family = unp->unp_conn->unp_addr->sun_family;
un->sun_family = unp->unp_conn->unp_addr->sun_family;
strlcpy(un->sun_path, unp->unp_conn->unp_addr->sun_path,
sizeof(pcb->ki_d));
}
else {
un->sun_len = offsetof(struct sockaddr_un, sun_path);
un->sun_family = pcb->ki_family;
}
}
pcb->ki_inode = unp->unp_ino;
pcb->ki_vnode = PTRTOUINT64(unp->unp_vnode);
pcb->ki_conn = PTRTOUINT64(unp->unp_conn);
pcb->ki_refs = PTRTOUINT64(unp->unp_refs);
pcb->ki_nextref = PTRTOUINT64(unp->unp_nextref);
}
static int
sysctl_unpcblist(SYSCTLFN_ARGS)
{
struct file *fp, *dfp, *np;
struct socket *so;
struct kinfo_pcb pcb;
char *dp;
u_int op, arg;
size_t len, needed, elem_size, out_size;
int error, elem_count, pf, type, pf2;
struct kinfo_lwp *
kvm_getlwps(kvm_t *kd, int pid, u_long paddr, size_t esize, int *cnt)
{
size_t size;
int mib[5], nlwps;
ssize_t st;
struct kinfo_lwp *kl;
if (ISSYSCTL(kd)) {
size = 0;
mib[0] = CTL_KERN;
mib[1] = KERN_LWP;
mib[2] = pid;
mib[3] = (int)esize;
mib[4] = 0;
again:
st = sysctl(mib, 5, NULL, &size, NULL, (size_t)0);
if (st == -1) {
switch (errno) {
case ESRCH: /* Treat this as a soft error; see kvm.c */
_kvm_syserr(kd, NULL, "kvm_getlwps");
return NULL;
default:
_kvm_syserr(kd, kd->program, "kvm_getlwps");
return NULL;
}
}
mib[4] = (int) (size / esize);
KVM_ALLOC(kd, lwpbase, size);
st = sysctl(mib, 5, kd->lwpbase, &size, NULL, (size_t)0);
if (st == -1) {
switch (errno) {
case ESRCH: /* Treat this as a soft error; see kvm.c */
_kvm_syserr(kd, NULL, "kvm_getlwps");
return NULL;
case ENOMEM:
goto again;
default:
_kvm_syserr(kd, kd->program, "kvm_getlwps");
return NULL;
}
}
nlwps = (int) (size / esize);
} else {
/* grovel through the memory image */
struct proc p;
struct lwp l;
u_long laddr;
void *back;
int i;
st = kvm_read(kd, paddr, &p, sizeof(p));
if (st == -1) {
_kvm_syserr(kd, kd->program, "kvm_getlwps");
return (NULL);
}
nlwps = p.p_nlwps;
size = nlwps * sizeof(*kd->lwpbase);
KVM_ALLOC(kd, lwpbase, size);
laddr = (u_long)PTRTOUINT64(p.p_lwps.lh_first);
for (i = 0; (i < nlwps) && (laddr != 0); i++) {
st = kvm_read(kd, laddr, &l, sizeof(l));
if (st == -1) {
_kvm_syserr(kd, kd->program, "kvm_getlwps");
return (NULL);
}
kl = &kd->lwpbase[i];
kl->l_laddr = laddr;
kl->l_forw = PTRTOUINT64(l.l_runq.tqe_next);
laddr = (u_long)PTRTOUINT64(l.l_runq.tqe_prev);
st = kvm_read(kd, laddr, &back, sizeof(back));
if (st == -1) {
_kvm_syserr(kd, kd->program, "kvm_getlwps");
return (NULL);
}
kl->l_back = PTRTOUINT64(back);
kl->l_addr = PTRTOUINT64(l.l_addr);
kl->l_lid = l.l_lid;
kl->l_flag = l.l_flag;
kl->l_swtime = l.l_swtime;
kl->l_slptime = l.l_slptime;
kl->l_schedflags = 0; /* XXX */
kl->l_holdcnt = 0;
kl->l_priority = l.l_priority;
kl->l_usrpri = l.l_priority;
kl->l_stat = l.l_stat;
kl->l_wchan = PTRTOUINT64(l.l_wchan);
if (l.l_wmesg)
(void)kvm_read(kd, (u_long)l.l_wmesg,
kl->l_wmesg, (size_t)WMESGLEN);
kl->l_cpuid = KI_NOCPU;
laddr = (u_long)PTRTOUINT64(l.l_sibling.le_next);
}
}
*cnt = nlwps;
return (kd->lwpbase);
}
struct kinfo_proc2 *
kvm_getproc2(kvm_t *kd, int op, int arg, size_t esize, int *cnt)
{
size_t size;
int mib[6], st, nprocs;
struct pstats pstats;
if (ISSYSCTL(kd)) {
size = 0;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC2;
mib[2] = op;
mib[3] = arg;
mib[4] = (int)esize;
again:
mib[5] = 0;
st = sysctl(mib, 6, NULL, &size, NULL, (size_t)0);
if (st == -1) {
_kvm_syserr(kd, kd->program, "kvm_getproc2");
return (NULL);
}
mib[5] = (int) (size / esize);
KVM_ALLOC(kd, procbase2, size);
st = sysctl(mib, 6, kd->procbase2, &size, NULL, (size_t)0);
if (st == -1) {
if (errno == ENOMEM) {
goto again;
}
_kvm_syserr(kd, kd->program, "kvm_getproc2");
return (NULL);
}
nprocs = (int) (size / esize);
} else {
char *kp2c;
struct kinfo_proc *kp;
struct kinfo_proc2 kp2, *kp2p;
struct kinfo_lwp *kl;
int i, nlwps;
kp = kvm_getprocs(kd, op, arg, &nprocs);
if (kp == NULL)
return (NULL);
size = nprocs * esize;
KVM_ALLOC(kd, procbase2, size);
kp2c = (char *)(void *)kd->procbase2;
kp2p = &kp2;
for (i = 0; i < nprocs; i++, kp++) {
struct timeval tv;
kl = kvm_getlwps(kd, kp->kp_proc.p_pid,
(u_long)PTRTOUINT64(kp->kp_eproc.e_paddr),
sizeof(struct kinfo_lwp), &nlwps);
if (kl == NULL) {
_kvm_syserr(kd, NULL,
"kvm_getlwps() failed on process %u\n",
kp->kp_proc.p_pid);
if (nlwps == 0)
return NULL;
else
continue;
}
/* We use kl[0] as the "representative" LWP */
memset(kp2p, 0, sizeof(kp2));
kp2p->p_forw = kl[0].l_forw;
kp2p->p_back = kl[0].l_back;
kp2p->p_paddr = PTRTOUINT64(kp->kp_eproc.e_paddr);
kp2p->p_addr = kl[0].l_addr;
kp2p->p_fd = PTRTOUINT64(kp->kp_proc.p_fd);
kp2p->p_cwdi = PTRTOUINT64(kp->kp_proc.p_cwdi);
kp2p->p_stats = PTRTOUINT64(kp->kp_proc.p_stats);
kp2p->p_limit = PTRTOUINT64(kp->kp_proc.p_limit);
kp2p->p_vmspace = PTRTOUINT64(kp->kp_proc.p_vmspace);
kp2p->p_sigacts = PTRTOUINT64(kp->kp_proc.p_sigacts);
kp2p->p_sess = PTRTOUINT64(kp->kp_eproc.e_sess);
kp2p->p_tsess = 0;
#if 1 /* XXX: dsl - p_ru was only ever non-zero for zombies */
kp2p->p_ru = 0;
#else
kp2p->p_ru = PTRTOUINT64(pstats.p_ru);
#endif
kp2p->p_eflag = 0;
kp2p->p_exitsig = kp->kp_proc.p_exitsig;
kp2p->p_flag = kp->kp_proc.p_flag;
kp2p->p_pid = kp->kp_proc.p_pid;
kp2p->p_ppid = kp->kp_eproc.e_ppid;
kp2p->p_sid = kp->kp_eproc.e_sid;
kp2p->p__pgid = kp->kp_eproc.e_pgid;
kp2p->p_tpgid = -1 /* XXX NO_PGID! */;
kp2p->p_uid = kp->kp_eproc.e_ucred.cr_uid;
kp2p->p_ruid = kp->kp_eproc.e_pcred.p_ruid;
kp2p->p_svuid = kp->kp_eproc.e_pcred.p_svuid;
kp2p->p_gid = kp->kp_eproc.e_ucred.cr_gid;
kp2p->p_rgid = kp->kp_eproc.e_pcred.p_rgid;
kp2p->p_svgid = kp->kp_eproc.e_pcred.p_svgid;
/*CONSTCOND*/
memcpy(kp2p->p_groups, kp->kp_eproc.e_ucred.cr_groups,
MIN(sizeof(kp2p->p_groups),
sizeof(kp->kp_eproc.e_ucred.cr_groups)));
kp2p->p_ngroups = kp->kp_eproc.e_ucred.cr_ngroups;
kp2p->p_jobc = kp->kp_eproc.e_jobc;
kp2p->p_tdev = kp->kp_eproc.e_tdev;
kp2p->p_tpgid = kp->kp_eproc.e_tpgid;
kp2p->p_tsess = PTRTOUINT64(kp->kp_eproc.e_tsess);
kp2p->p_estcpu = 0;
bintime2timeval(&kp->kp_proc.p_rtime, &tv);
kp2p->p_rtime_sec = (uint32_t)tv.tv_sec;
kp2p->p_rtime_usec = (uint32_t)tv.tv_usec;
kp2p->p_cpticks = kl[0].l_cpticks;
kp2p->p_pctcpu = kp->kp_proc.p_pctcpu;
kp2p->p_swtime = kl[0].l_swtime;
kp2p->p_slptime = kl[0].l_slptime;
#if 0 /* XXX thorpej */
kp2p->p_schedflags = kp->kp_proc.p_schedflags;
#else
kp2p->p_schedflags = 0;
#endif
kp2p->p_uticks = kp->kp_proc.p_uticks;
kp2p->p_sticks = kp->kp_proc.p_sticks;
kp2p->p_iticks = kp->kp_proc.p_iticks;
kp2p->p_tracep = PTRTOUINT64(kp->kp_proc.p_tracep);
kp2p->p_traceflag = kp->kp_proc.p_traceflag;
kp2p->p_holdcnt = kl[0].l_holdcnt;
memcpy(&kp2p->p_siglist,
&kp->kp_proc.p_sigpend.sp_set,
sizeof(ki_sigset_t));
memset(&kp2p->p_sigmask, 0,
sizeof(ki_sigset_t));
memcpy(&kp2p->p_sigignore,
&kp->kp_proc.p_sigctx.ps_sigignore,
sizeof(ki_sigset_t));
memcpy(&kp2p->p_sigcatch,
&kp->kp_proc.p_sigctx.ps_sigcatch,
sizeof(ki_sigset_t));
kp2p->p_stat = kl[0].l_stat;
kp2p->p_priority = kl[0].l_priority;
kp2p->p_usrpri = kl[0].l_priority;
kp2p->p_nice = kp->kp_proc.p_nice;
kp2p->p_xstat = kp->kp_proc.p_xstat;
kp2p->p_acflag = kp->kp_proc.p_acflag;
/*CONSTCOND*/
strncpy(kp2p->p_comm, kp->kp_proc.p_comm,
MIN(sizeof(kp2p->p_comm),
sizeof(kp->kp_proc.p_comm)));
strncpy(kp2p->p_wmesg, kp->kp_eproc.e_wmesg,
sizeof(kp2p->p_wmesg));
kp2p->p_wchan = kl[0].l_wchan;
strncpy(kp2p->p_login, kp->kp_eproc.e_login,
sizeof(kp2p->p_login));
kp2p->p_vm_rssize = kp->kp_eproc.e_xrssize;
kp2p->p_vm_tsize = kp->kp_eproc.e_vm.vm_tsize;
kp2p->p_vm_dsize = kp->kp_eproc.e_vm.vm_dsize;
kp2p->p_vm_ssize = kp->kp_eproc.e_vm.vm_ssize;
kp2p->p_vm_vsize = kp->kp_eproc.e_vm.vm_map.size
/ kd->nbpg;
/* Adjust mapped size */
kp2p->p_vm_msize =
(kp->kp_eproc.e_vm.vm_map.size / kd->nbpg) -
kp->kp_eproc.e_vm.vm_issize +
kp->kp_eproc.e_vm.vm_ssize;
kp2p->p_eflag = (int32_t)kp->kp_eproc.e_flag;
kp2p->p_realflag = kp->kp_proc.p_flag;
kp2p->p_nlwps = kp->kp_proc.p_nlwps;
kp2p->p_nrlwps = kp->kp_proc.p_nrlwps;
kp2p->p_realstat = kp->kp_proc.p_stat;
if (P_ZOMBIE(&kp->kp_proc) ||
kp->kp_proc.p_stats == NULL ||
KREAD(kd, (u_long)kp->kp_proc.p_stats, &pstats)) {
kp2p->p_uvalid = 0;
} else {
kp2p->p_uvalid = 1;
kp2p->p_ustart_sec = (u_int32_t)
pstats.p_start.tv_sec;
kp2p->p_ustart_usec = (u_int32_t)
pstats.p_start.tv_usec;
kp2p->p_uutime_sec = (u_int32_t)
pstats.p_ru.ru_utime.tv_sec;
kp2p->p_uutime_usec = (u_int32_t)
pstats.p_ru.ru_utime.tv_usec;
kp2p->p_ustime_sec = (u_int32_t)
pstats.p_ru.ru_stime.tv_sec;
kp2p->p_ustime_usec = (u_int32_t)
pstats.p_ru.ru_stime.tv_usec;
kp2p->p_uru_maxrss = pstats.p_ru.ru_maxrss;
kp2p->p_uru_ixrss = pstats.p_ru.ru_ixrss;
kp2p->p_uru_idrss = pstats.p_ru.ru_idrss;
kp2p->p_uru_isrss = pstats.p_ru.ru_isrss;
kp2p->p_uru_minflt = pstats.p_ru.ru_minflt;
kp2p->p_uru_majflt = pstats.p_ru.ru_majflt;
kp2p->p_uru_nswap = pstats.p_ru.ru_nswap;
kp2p->p_uru_inblock = pstats.p_ru.ru_inblock;
kp2p->p_uru_oublock = pstats.p_ru.ru_oublock;
kp2p->p_uru_msgsnd = pstats.p_ru.ru_msgsnd;
kp2p->p_uru_msgrcv = pstats.p_ru.ru_msgrcv;
kp2p->p_uru_nsignals = pstats.p_ru.ru_nsignals;
kp2p->p_uru_nvcsw = pstats.p_ru.ru_nvcsw;
kp2p->p_uru_nivcsw = pstats.p_ru.ru_nivcsw;
kp2p->p_uctime_sec = (u_int32_t)
(pstats.p_cru.ru_utime.tv_sec +
pstats.p_cru.ru_stime.tv_sec);
kp2p->p_uctime_usec = (u_int32_t)
(pstats.p_cru.ru_utime.tv_usec +
pstats.p_cru.ru_stime.tv_usec);
}
memcpy(kp2c, &kp2, esize);
kp2c += esize;
}
}
*cnt = nprocs;
return (kd->procbase2);
}
/*
* Read proc's from memory file into buffer bp, which has space to hold
* at most maxcnt procs.
*/
static int
kvm_proclist(kvm_t *kd, int what, int arg, struct proc *p,
struct kinfo_proc *bp, int maxcnt)
{
int cnt = 0;
int nlwps;
struct kinfo_lwp *kl;
struct eproc eproc;
struct pgrp pgrp;
struct session sess;
struct tty tty;
struct proc proc;
for (; cnt < maxcnt && p != NULL; p = proc.p_list.le_next) {
if (KREAD(kd, (u_long)p, &proc)) {
_kvm_err(kd, kd->program, "can't read proc at %p", p);
return (-1);
}
if (_kvm_convertcred(kd, (u_long)proc.p_cred, &eproc) != 0) {
_kvm_err(kd, kd->program,
"can't read proc credentials at %p", p);
return (-1);
}
switch (what) {
case KERN_PROC_PID:
if (proc.p_pid != (pid_t)arg)
continue;
break;
case KERN_PROC_UID:
if (eproc.e_ucred.cr_uid != (uid_t)arg)
continue;
break;
case KERN_PROC_RUID:
if (eproc.e_pcred.p_ruid != (uid_t)arg)
continue;
break;
}
/*
* We're going to add another proc to the set. If this
* will overflow the buffer, assume the reason is because
* nprocs (or the proc list) is corrupt and declare an error.
*/
if (cnt >= maxcnt) {
_kvm_err(kd, kd->program, "nprocs corrupt");
return (-1);
}
/*
* gather eproc
*/
eproc.e_paddr = p;
if (KREAD(kd, (u_long)proc.p_pgrp, &pgrp)) {
_kvm_err(kd, kd->program, "can't read pgrp at %p",
proc.p_pgrp);
return (-1);
}
eproc.e_sess = pgrp.pg_session;
eproc.e_pgid = pgrp.pg_id;
eproc.e_jobc = pgrp.pg_jobc;
if (KREAD(kd, (u_long)pgrp.pg_session, &sess)) {
_kvm_err(kd, kd->program, "can't read session at %p",
pgrp.pg_session);
return (-1);
}
if ((proc.p_lflag & PL_CONTROLT) && sess.s_ttyp != NULL) {
if (KREAD(kd, (u_long)sess.s_ttyp, &tty)) {
_kvm_err(kd, kd->program,
"can't read tty at %p", sess.s_ttyp);
return (-1);
}
eproc.e_tdev = (uint32_t)tty.t_dev;
eproc.e_tsess = tty.t_session;
if (tty.t_pgrp != NULL) {
if (KREAD(kd, (u_long)tty.t_pgrp, &pgrp)) {
_kvm_err(kd, kd->program,
"can't read tpgrp at %p",
tty.t_pgrp);
return (-1);
}
eproc.e_tpgid = pgrp.pg_id;
} else
eproc.e_tpgid = -1;
} else
eproc.e_tdev = (uint32_t)NODEV;
eproc.e_flag = sess.s_ttyvp ? EPROC_CTTY : 0;
eproc.e_sid = sess.s_sid;
if (sess.s_leader == p)
eproc.e_flag |= EPROC_SLEADER;
/*
* Fill in the old-style proc.p_wmesg by copying the wmesg
* from the first available LWP.
*/
kl = kvm_getlwps(kd, proc.p_pid,
(u_long)PTRTOUINT64(eproc.e_paddr),
sizeof(struct kinfo_lwp), &nlwps);
if (kl) {
if (nlwps > 0) {
strcpy(eproc.e_wmesg, kl[0].l_wmesg);
}
}
(void)kvm_read(kd, (u_long)proc.p_vmspace, &eproc.e_vm,
sizeof(eproc.e_vm));
eproc.e_xsize = eproc.e_xrssize = 0;
eproc.e_xccount = eproc.e_xswrss = 0;
switch (what) {
case KERN_PROC_PGRP:
if (eproc.e_pgid != (pid_t)arg)
continue;
break;
case KERN_PROC_TTY:
if ((proc.p_lflag & PL_CONTROLT) == 0 ||
eproc.e_tdev != (dev_t)arg)
continue;
break;
}
memcpy(&bp->kp_proc, &proc, sizeof(proc));
memcpy(&bp->kp_eproc, &eproc, sizeof(eproc));
++bp;
++cnt;
}
return (cnt);
}
