#include <sys/cdefs.h>
#ifndef lint
__COPYRIGHT("@(#) Copyright (c) 1980, 1986, 1991, 1993\
The Regents of the University of California. All rights reserved.");
#endif
#ifndef lint
#if 0
static char sccsid[] = "@(#)vmstat.c 8.2 (Berkeley) 3/1/95";
#else
__RCSID("$NetBSD: vmstat.c,v 1.265 2026/03/22 11:25:12 yamt Exp $");
#endif
#endif
#define __POOL_EXPOSE
#define __NAMECACHE_PRIVATE
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/evcnt.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/mallocvar.h>
#include <sys/namei.h>
#include <sys/pool.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/queue.h>
#include <sys/kernhist.h>
#include <sys/vnode.h>
#include <sys/vnode_impl.h>
#include <sys/uidinfo.h>
#include <uvm/uvm_extern.h>
#include <uvm/uvm_stat.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <ufs/ufs/inode.h>
#include <nfs/rpcv2.h>
#include <nfs/nfsproto.h>
#include <nfs/nfsnode.h>
#include <assert.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <kvm.h>
#include <limits.h>
#include <nlist.h>
#undef n_hash
#include <paths.h>
#include <signal.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <util.h>
#include "drvstats.h"
#ifdef __HAVE_CPU_DATA_FIRST
# include <sys/cpu_data.h>
struct cpu_info {
struct cpu_data ci_data;
};
#else
# include <sys/cpu.h>
#endif
struct nlist namelist[] =
{
#define X_HZ 0
{ .n_name = "_hz" },
#define X_STATHZ 1
{ .n_name = "_stathz" },
#define X_NCHSTATS 2
{ .n_name = "_nchstats" },
#define X_ALLEVENTS 3
{ .n_name = "_allevents" },
#define X_POOLHEAD 4
{ .n_name = "_pool_head" },
#define X_UVMEXP 5
{ .n_name = "_uvmexp" },
#define X_CPU_INFOS 6
{ .n_name = "_cpu_infos" },
#define X_NL_SIZE 7
{ .n_name = NULL },
};
struct nlist timenl[] =
{
#define X_TIMEBASEBIN 0
{ .n_name = "_timebasebin" },
#define X_TIME_SECOND 1
{ .n_name = "_time_second" },
#define X_TIME 2
{ .n_name = "_time" },
#define X_TIMENL_SIZE 3
{ .n_name = NULL },
};
struct nlist intrnl[] =
{
#define X_INTRNAMES 0
{ .n_name = "_intrnames" },
#define X_EINTRNAMES 1
{ .n_name = "_eintrnames" },
#define X_INTRCNT 2
{ .n_name = "_intrcnt" },
#define X_EINTRCNT 3
{ .n_name = "_eintrcnt" },
#define X_INTRNL_SIZE 4
{ .n_name = NULL },
};
struct nlist hashnl[] =
{
#define X_BUFHASH 0
{ .n_name = "_bufhash" },
#define X_BUFHASHTBL 1
{ .n_name = "_bufhashtbl" },
#define X_UIHASH 2
{ .n_name = "_uihash" },
#define X_UIHASHTBL 3
{ .n_name = "_uihashtbl" },
#define X_IFADDRHASH 4
{ .n_name = "_in_ifaddrhash" },
#define X_IFADDRHASHTBL 5
{ .n_name = "_in_ifaddrhashtbl" },
#define X_VCACHEHASH 6
{ .n_name = "_vcache_hashmask" },
#define X_VCACHETBL 7
{ .n_name = "_vcache_hashtab" },
#define X_HASHNL_SIZE 8
{ .n_name = NULL },
};
struct nlist histnl[] =
{
{ .n_name = "_kern_histories" },
#define X_KERN_HISTORIES 0
{ .n_name = NULL },
};
#define KILO 1024
struct cpu_counter {
uint64_t nintr;
uint64_t nsyscall;
uint64_t nswtch;
uint64_t nfault;
uint64_t ntrap;
uint64_t nsoft;
} cpucounter, ocpucounter;
struct uvmexp_sysctl uvmexp, ouvmexp;
int ndrives;
int winlines = 20;
kvm_t *kd;
#define FORKSTAT 0x001
#define INTRSTAT 0x002
#define MEMSTAT 0x004
#define SUMSTAT 0x008
#define EVCNTSTAT 0x010
#define VMSTAT 0x020
#define HISTLIST 0x040
#define HISTDUMP 0x080
#define HASHSTAT 0x100
#define HASHLIST 0x200
#define VMTOTAL 0x400
#define POOLCACHESTAT 0x800
#define PRWORD(ovflw, fmt, width, fixed, val) do { \
(ovflw) += printf((fmt), \
(width) - (fixed) - (ovflw) > 0 ? \
(width) - (fixed) - (ovflw) : 0, \
(val)) - (width); \
if ((ovflw) < 0) \
(ovflw) = 0; \
} while (0)
void cpustats(int *);
void cpucounters(struct cpu_counter *);
void deref_kptr(const void *, void *, size_t, const char *);
void drvstats(int *);
void doevcnt(int verbose, int type);
void dohashstat(int, int, const char *);
void dohashstat_sysctl(int, int, const char *);
void dointr(int verbose);
void dopool(int, int);
void dopoolcache(int);
void dosum(void);
void dovmstat(struct timespec *, int);
void print_total_hdr(void);
void dovmtotal(struct timespec *, int);
void kread(struct nlist *, int, void *, size_t);
int kreadc(struct nlist *, int, void *, size_t);
void needhdr(int);
void getnlist(int);
long getuptime(void);
void printhdr(void);
long pct(u_long, u_long);
__dead static void usage(void);
void doforkst(void);
void hist_traverse(int, const char *);
void hist_dodump(struct kern_history *);
void hist_traverse_sysctl(int, const char *);
void hist_dodump_sysctl(int[], unsigned int);
char **choosedrives(char **);
char *nlistf, *memf;
#define BACKWARD_COMPATIBILITY
static const int clockrate_mib[] = { CTL_KERN, KERN_CLOCKRATE };
static const int vmmeter_mib[] = { CTL_VM, VM_METER };
static const int uvmexp2_mib[] = { CTL_VM, VM_UVMEXP2 };
static const int boottime_mib[] = { CTL_KERN, KERN_BOOTTIME };
static int numdisks = 2;
int
main(int argc, char *argv[])
{
int c, todo, verbose, wide;
struct timespec interval;
int reps;
const char *histname, *hashname;
char errbuf[_POSIX2_LINE_MAX];
histname = hashname = NULL;
memf = nlistf = NULL;
reps = todo = verbose = wide = 0;
interval.tv_sec = 0;
interval.tv_nsec = 0;
while ((c = getopt(argc, argv, "Cc:efh:HilLM:mN:n:stu:UvWw:")) != -1) {
switch (c) {
case 'c':
reps = atoi(optarg);
break;
case 'C':
todo |= POOLCACHESTAT;
break;
case 'e':
todo |= EVCNTSTAT;
break;
case 'f':
todo |= FORKSTAT;
break;
case 'h':
hashname = optarg;
case 'H':
todo |= HASHSTAT;
break;
case 'i':
todo |= INTRSTAT;
break;
case 'l':
todo |= HISTLIST;
break;
case 'L':
todo |= HASHLIST;
break;
case 'M':
memf = optarg;
break;
case 'm':
todo |= MEMSTAT;
break;
case 'N':
nlistf = optarg;
break;
case 'n':
numdisks = atoi(optarg);
break;
case 's':
todo |= SUMSTAT;
break;
case 't':
todo |= VMTOTAL;
break;
case 'u':
histname = optarg;
case 'U':
todo |= HISTDUMP;
break;
case 'v':
verbose++;
break;
case 'W':
wide++;
break;
case 'w':
interval.tv_sec = atol(optarg);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (todo == 0)
todo = VMSTAT;
if (memf == NULL) {
kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
} else {
kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, errbuf);
}
if (kd == NULL)
errx(EXIT_FAILURE, "%s", errbuf);
if (memf != NULL)
getnlist(todo);
if (todo & VMSTAT) {
struct winsize winsize;
(void)drvinit(0);
argv = choosedrives(argv);
winsize.ws_row = 0;
(void)ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
if (winsize.ws_row > 0)
winlines = winsize.ws_row;
}
#ifdef BACKWARD_COMPATIBILITY
if (*argv) {
interval.tv_sec = atol(*argv);
if (*++argv)
reps = atoi(*argv);
}
#endif
if (interval.tv_sec) {
if (!reps)
reps = -1;
} else if (reps)
interval.tv_sec = 1;
if ((todo & (VMSTAT|VMTOTAL)) == 0) {
for (;;) {
if (todo & (HISTLIST|HISTDUMP)) {
if ((todo & (HISTLIST|HISTDUMP)) ==
(HISTLIST|HISTDUMP))
errx(1, "you may list or dump,"
" but not both!");
if (memf != NULL)
hist_traverse(todo, histname);
else
hist_traverse_sysctl(todo, histname);
(void)putchar('\n');
}
if (todo & FORKSTAT) {
doforkst();
(void)putchar('\n');
}
if (todo & MEMSTAT) {
dopool(verbose, wide);
(void)putchar('\n');
}
if (todo & POOLCACHESTAT) {
dopoolcache(verbose);
(void)putchar('\n');
}
if (todo & SUMSTAT) {
dosum();
(void)putchar('\n');
}
if (todo & INTRSTAT) {
dointr(verbose);
(void)putchar('\n');
}
if (todo & EVCNTSTAT) {
doevcnt(verbose, EVCNT_TYPE_ANY);
(void)putchar('\n');
}
if (todo & (HASHLIST|HASHSTAT)) {
if ((todo & (HASHLIST|HASHSTAT)) ==
(HASHLIST|HASHSTAT))
errx(1, "you may list or display,"
" but not both!");
dohashstat(verbose, todo, hashname);
(void)putchar('\n');
}
fflush(stdout);
if (reps >= 0 && --reps <=0)
break;
(void)nanosleep(&interval, NULL);
}
} else {
if ((todo & (VMSTAT|VMTOTAL)) == (VMSTAT|VMTOTAL)) {
errx(1, "you may not both do vmstat and vmtotal");
}
if (todo & VMSTAT)
dovmstat(&interval, reps);
if (todo & VMTOTAL)
dovmtotal(&interval, reps);
}
return 0;
}
void
getnlist(int todo)
{
static int done = 0;
int c;
size_t i;
if ((c = kvm_nlist(kd, namelist)) != 0) {
int doexit = 0;
if (c == -1)
errx(1, "kvm_nlist: %s %s",
"namelist", kvm_geterr(kd));
for (i = 0; i < __arraycount(namelist)-1; i++)
if (namelist[i].n_type == 0) {
if (doexit++ == 0)
(void)fprintf(stderr,
"%s: undefined symbols:",
getprogname());
(void)fprintf(stderr, " %s",
namelist[i].n_name);
}
if (doexit) {
(void)fputc('\n', stderr);
exit(1);
}
}
if ((todo & (VMSTAT|INTRSTAT)) && !(done & (VMSTAT))) {
done |= VMSTAT;
if ((c = kvm_nlist(kd, timenl)) == -1 || c == X_TIMENL_SIZE)
errx(1, "kvm_nlist: %s %s", "timenl", kvm_geterr(kd));
}
if ((todo & (SUMSTAT|INTRSTAT)) && !(done & (SUMSTAT|INTRSTAT))) {
done |= SUMSTAT|INTRSTAT;
(void) kvm_nlist(kd, intrnl);
}
if ((todo & (HASHLIST|HASHSTAT)) && !(done & (HASHLIST|HASHSTAT))) {
done |= HASHLIST|HASHSTAT;
if ((c = kvm_nlist(kd, hashnl)) == -1 || c == X_HASHNL_SIZE)
errx(1, "kvm_nlist: %s %s", "hashnl", kvm_geterr(kd));
}
if ((todo & (HISTLIST|HISTDUMP)) && !(done & (HISTLIST|HISTDUMP))) {
done |= HISTLIST|HISTDUMP;
if (kvm_nlist(kd, histnl) == -1)
errx(1, "kvm_nlist: %s %s", "histnl", kvm_geterr(kd));
}
}
char **
choosedrives(char **argv)
{
size_t i, j, k;
#define BACKWARD_COMPATIBILITY
for (ndrives = 0; *argv; ++argv) {
#ifdef BACKWARD_COMPATIBILITY
if (isdigit((unsigned char)**argv))
break;
#endif
for (i = 0; i < ndrive; i++) {
if (strcmp(dr_name[i], *argv))
continue;
drv_select[i] = 1;
++ndrives;
break;
}
}
drvreadstats();
for (i = 0; i < ndrive && ndrives < numdisks; i++) {
uint64_t high_bytes = 0, bytes;
k = ndrive;
for (j = 0; j < ndrive; j++) {
if (drv_select[j])
continue;
bytes = cur.rbytes[j] + cur.wbytes[j];
if (bytes > high_bytes) {
high_bytes = bytes;
k = j;
}
}
if (k != ndrive) {
drv_select[k] = 1;
++ndrives;
}
}
return (argv);
}
long
getuptime(void)
{
static struct timespec boottime;
struct timespec now;
time_t uptime, nowsec;
if (memf == NULL) {
if (boottime.tv_sec == 0) {
size_t buflen = sizeof(boottime);
if (sysctl(boottime_mib, __arraycount(boottime_mib),
&boottime, &buflen, NULL, 0) == -1)
warn("Can't get boottime");
}
clock_gettime(CLOCK_REALTIME, &now);
} else {
if (boottime.tv_sec == 0) {
struct bintime bt;
kread(timenl, X_TIMEBASEBIN, &bt, sizeof(bt));
bintime2timespec(&bt, &boottime);
}
if (kreadc(timenl, X_TIME_SECOND, &nowsec, sizeof(nowsec))) {
now.tv_sec = nowsec;
now.tv_nsec = 0;
} else {
kread(timenl, X_TIME, &now, sizeof(now));
}
}
uptime = now.tv_sec - boottime.tv_sec;
if (uptime <= 0 || uptime > 60*60*24*365*10)
errx(1, "time makes no sense; namelist must be wrong.");
return (uptime);
}
int hz, hdrcnt;
void
print_total_hdr(void)
{
(void)printf("procs memory\n");
(void)printf("ru dw pw sl");
(void)printf(" total-v active-v active-r");
(void)printf(" vm-sh avm-sh rm-sh arm-sh free\n");
hdrcnt = winlines - 2;
}
void
dovmtotal(struct timespec *interval, int reps)
{
struct vmtotal total;
size_t size;
(void)signal(SIGCONT, needhdr);
for (hdrcnt = 1;;) {
if (!--hdrcnt)
print_total_hdr();
if (memf != NULL) {
warnx("Unable to get vmtotals from crash dump.");
(void)memset(&total, 0, sizeof(total));
} else {
size = sizeof(total);
if (sysctl(vmmeter_mib, __arraycount(vmmeter_mib),
&total, &size, NULL, 0) == -1) {
warn("Can't get vmtotals");
(void)memset(&total, 0, sizeof(total));
}
}
(void)printf("%2d ", total.t_rq);
(void)printf("%2d ", total.t_dw);
(void)printf("%2d ", total.t_pw);
(void)printf("%2d ", total.t_sl);
(void)printf("%9d ", total.t_vm);
(void)printf("%9d ", total.t_avm);
(void)printf("%9d ", total.t_arm);
(void)printf("%5d ", total.t_vmshr);
(void)printf("%6d ", total.t_avmshr);
(void)printf("%5d ", total.t_rmshr);
(void)printf("%6d ", total.t_armshr);
(void)printf("%5d", total.t_free);
(void)putchar('\n');
(void)fflush(stdout);
if (reps >= 0 && --reps <= 0)
break;
(void)nanosleep(interval, NULL);
}
}
void
dovmstat(struct timespec *interval, int reps)
{
struct vmtotal total;
time_t uptime, halfuptime;
size_t size;
int pagesize = getpagesize();
int ovflw;
uptime = getuptime();
halfuptime = uptime / 2;
(void)signal(SIGCONT, needhdr);
if (memf != NULL) {
if (namelist[X_STATHZ].n_type != 0 && namelist[X_STATHZ].n_value != 0)
kread(namelist, X_STATHZ, &hz, sizeof(hz));
if (!hz)
kread(namelist, X_HZ, &hz, sizeof(hz));
} else {
struct clockinfo clockinfo;
size = sizeof(clockinfo);
if (sysctl(clockrate_mib, 2, &clockinfo, &size, NULL, 0) == -1)
err(1, "sysctl kern.clockrate failed");
hz = clockinfo.stathz;
if (!hz)
hz = clockinfo.hz;
}
for (hdrcnt = 1;;) {
if (!--hdrcnt)
printhdr();
cpureadstats();
drvreadstats();
tkreadstats();
if (memf != NULL) {
struct uvmexp uvmexp_kernel;
warnx("Unable to get vmtotals from crash dump.");
(void)memset(&total, 0, sizeof(total));
kread(namelist, X_UVMEXP, &uvmexp_kernel, sizeof(uvmexp_kernel));
#define COPY(field) uvmexp.field = uvmexp_kernel.field
COPY(pdreact);
COPY(pageins);
COPY(pgswapout);
COPY(pdfreed);
COPY(pdscans);
#undef COPY
} else {
size = sizeof(total);
if (sysctl(vmmeter_mib, __arraycount(vmmeter_mib),
&total, &size, NULL, 0) == -1) {
warn("Can't get vmtotals");
(void)memset(&total, 0, sizeof(total));
}
size = sizeof(uvmexp);
if (sysctl(uvmexp2_mib, __arraycount(uvmexp2_mib), &uvmexp,
&size, NULL, 0) == -1)
warn("sysctl vm.uvmexp2 failed");
}
cpucounters(&cpucounter);
ovflw = 0;
PRWORD(ovflw, " %*d", 2, 1, total.t_rq - 1);
PRWORD(ovflw, " %*d", 2, 1, total.t_dw + total.t_pw);
#define pgtok(a) (long)((a) * ((uint32_t)pagesize >> 10))
#define rate(x) (u_long)(((x) + halfuptime) / uptime)
PRWORD(ovflw, " %*ld", 9, 1, pgtok(total.t_avm));
PRWORD(ovflw, " %*ld", 7, 1, pgtok(total.t_free));
PRWORD(ovflw, " %*ld", 5, 1,
rate(cpucounter.nfault - ocpucounter.nfault));
PRWORD(ovflw, " %*ld", 4, 1,
rate(uvmexp.pdreact - ouvmexp.pdreact));
PRWORD(ovflw, " %*ld", 4, 1,
rate(uvmexp.pageins - ouvmexp.pageins));
PRWORD(ovflw, " %*ld", 5, 1,
rate(uvmexp.pgswapout - ouvmexp.pgswapout));
PRWORD(ovflw, " %*ld", 5, 1,
rate(uvmexp.pdfreed - ouvmexp.pdfreed));
PRWORD(ovflw, " %*ld", 6, 2,
rate(uvmexp.pdscans - ouvmexp.pdscans));
drvstats(&ovflw);
PRWORD(ovflw, " %*ld", 5, 1,
rate(cpucounter.nintr - ocpucounter.nintr));
PRWORD(ovflw, " %*ld", 5, 1,
rate(cpucounter.nsyscall - ocpucounter.nsyscall));
PRWORD(ovflw, " %*ld", 4, 1,
rate(cpucounter.nswtch - ocpucounter.nswtch));
cpustats(&ovflw);
(void)putchar('\n');
(void)fflush(stdout);
if (reps >= 0 && --reps <= 0)
break;
ouvmexp = uvmexp;
ocpucounter = cpucounter;
uptime = interval->tv_sec;
halfuptime = uptime == 1 ? 0 : (uptime + 1) / 2;
(void)nanosleep(interval, NULL);
}
}
void
printhdr(void)
{
size_t i;
(void)printf(" procs memory page%*s", 23, "");
if (ndrives > 0)
(void)printf("%s %*sfaults cpu\n",
((ndrives > 1) ? "disks" : "disk"),
((ndrives > 1) ? ndrives * 3 - 4 : 0), "");
else
(void)printf("%*s faults cpu\n",
ndrives * 3, "");
(void)printf(" r b avm fre flt re pi po fr sr ");
for (i = 0; i < ndrive; i++)
if (drv_select[i])
(void)printf("%c%c ", dr_name[i][0],
dr_name[i][strlen(dr_name[i]) - 1]);
(void)printf(" in sy cs us sy id\n");
hdrcnt = winlines - 2;
}
void
needhdr(int dummy)
{
hdrcnt = 1;
}
long
pct(u_long top, u_long bot)
{
long ans;
if (bot == 0)
return (0);
ans = (long)((quad_t)top * 100 / bot);
return (ans);
}
#define PCT(top, bot) (int)pct((u_long)(top), (u_long)(bot))
void
dosum(void)
{
struct nchstats nch_stats;
uint64_t nchtotal;
size_t ssize;
int active_kernel;
struct cpu_counter cc;
ssize = sizeof(uvmexp);
memset(&uvmexp, 0, ssize);
active_kernel = (memf == NULL);
if (active_kernel) {
if (sysctl(uvmexp2_mib, __arraycount(uvmexp2_mib), &uvmexp,
&ssize, NULL, 0) == -1)
warn("sysctl vm.uvmexp2 failed");
} else {
struct uvmexp uvmexp_kernel;
struct pool pool, *pp = &pool;
struct pool_allocator pa;
TAILQ_HEAD(,pool) pool_head;
void *addr;
uint64_t bytes;
kread(namelist, X_UVMEXP, &uvmexp_kernel, sizeof(uvmexp_kernel));
#define COPY(field) uvmexp.field = uvmexp_kernel.field
COPY(pagesize);
COPY(ncolors);
COPY(npages);
COPY(free);
COPY(paging);
COPY(wired);
COPY(reserve_pagedaemon);
COPY(reserve_kernel);
COPY(anonpages);
COPY(filepages);
COPY(execpages);
COPY(freemin);
COPY(freetarg);
COPY(wiredmax);
COPY(nswapdev);
COPY(swpages);
COPY(swpginuse);
COPY(nswget);
COPY(pageins);
COPY(pdpageouts);
COPY(pgswapin);
COPY(pgswapout);
COPY(forks);
COPY(forks_ppwait);
COPY(forks_sharevm);
COPY(colorhit);
COPY(colormiss);
COPY(cpuhit);
COPY(cpumiss);
COPY(fltnoram);
COPY(fltnoanon);
COPY(fltpgwait);
COPY(fltpgrele);
COPY(fltrelck);
COPY(fltrelckok);
COPY(fltanget);
COPY(fltanretry);
COPY(fltamcopy);
COPY(fltamcopy);
COPY(fltnomap);
COPY(fltlget);
COPY(fltget);
COPY(flt_anon);
COPY(flt_acow);
COPY(flt_obj);
COPY(flt_prcopy);
COPY(flt_przero);
COPY(pdwoke);
COPY(pdrevs);
COPY(pdfreed);
COPY(pdscans);
COPY(pdanscan);
COPY(pdobscan);
COPY(pdreact);
COPY(pdbusy);
COPY(pddeact);
COPY(bootpages);
#undef COPY
kread(namelist, X_POOLHEAD, &pool_head, sizeof(pool_head));
addr = TAILQ_FIRST(&pool_head);
uvmexp.poolpages = 0;
for (; addr != NULL; addr = TAILQ_NEXT(pp, pr_poollist)) {
deref_kptr(addr, pp, sizeof(*pp), "pool chain trashed");
deref_kptr(pp->pr_alloc, &pa, sizeof(pa),
"pool allocator trashed");
bytes = pp->pr_npages * pa.pa_pagesz;
if ((pp->pr_roflags & PR_RECURSIVE) != 0)
bytes -= (pp->pr_nout * pp->pr_size);
uvmexp.poolpages += bytes / uvmexp.pagesize;
}
}
(void)printf("%9" PRIu64 " bytes per page\n", uvmexp.pagesize);
(void)printf("%9" PRIu64 " page color%s\n",
uvmexp.ncolors, uvmexp.ncolors == 1 ? "" : "s");
(void)printf("%9" PRIu64 " pages managed\n", uvmexp.npages);
(void)printf("%9" PRIu64 " pages free\n", uvmexp.free);
if (active_kernel) {
(void)printf("%9" PRIu64 " pages active\n", uvmexp.active);
(void)printf("%9" PRIu64 " pages inactive\n", uvmexp.inactive);
}
(void)printf("%9" PRIu64 " pages paging\n", uvmexp.paging);
(void)printf("%9" PRIu64 " pages wired\n", uvmexp.wired);
(void)printf("%9" PRIu64 " reserve pagedaemon pages\n",
uvmexp.reserve_pagedaemon);
(void)printf("%9" PRIu64 " reserve kernel pages\n", uvmexp.reserve_kernel);
(void)printf("%9" PRIu64 " boot kernel pages\n", uvmexp.bootpages);
(void)printf("%9" PRIu64 " kernel pool pages\n", uvmexp.poolpages);
(void)printf("%9" PRIu64 " anonymous pages\n", uvmexp.anonpages);
(void)printf("%9" PRIu64 " cached file pages\n", uvmexp.filepages);
(void)printf("%9" PRIu64 " cached executable pages\n", uvmexp.execpages);
(void)printf("%9" PRIu64 " minimum free pages\n", uvmexp.freemin);
(void)printf("%9" PRIu64 " target free pages\n", uvmexp.freetarg);
(void)printf("%9" PRIu64 " maximum wired pages\n", uvmexp.wiredmax);
(void)printf("%9" PRIu64 " swap devices\n", uvmexp.nswapdev);
(void)printf("%9" PRIu64 " swap pages\n", uvmexp.swpages);
(void)printf("%9" PRIu64 " swap pages in use\n", uvmexp.swpginuse);
(void)printf("%9" PRIu64 " swap allocations\n", uvmexp.nswget);
cpucounters(&cc);
(void)printf("%9" PRIu64 " total faults taken\n", cc.nfault);
(void)printf("%9" PRIu64 " traps\n", cc.ntrap);
(void)printf("%9" PRIu64 " device interrupts\n", cc.nintr);
(void)printf("%9" PRIu64 " CPU context switches\n", cc.nswtch);
(void)printf("%9" PRIu64 " software interrupts\n", cc.nsoft);
(void)printf("%9" PRIu64 " system calls\n", cc.nsyscall);
(void)printf("%9" PRIu64 " pagein requests\n", uvmexp.pageins);
(void)printf("%9" PRIu64 " pageout requests\n", uvmexp.pdpageouts);
(void)printf("%9" PRIu64 " pages swapped in\n", uvmexp.pgswapin);
(void)printf("%9" PRIu64 " pages swapped out\n", uvmexp.pgswapout);
(void)printf("%9" PRIu64 " forks total\n", uvmexp.forks);
(void)printf("%9" PRIu64 " forks blocked parent\n", uvmexp.forks_ppwait);
(void)printf("%9" PRIu64 " forks shared address space with parent\n",
uvmexp.forks_sharevm);
(void)printf("%9" PRIu64 " pagealloc desired color avail\n",
uvmexp.colorhit);
(void)printf("%9" PRIu64 " pagealloc desired color not avail\n",
uvmexp.colormiss);
(void)printf("%9" PRIu64 " pagealloc local cpu avail\n",
uvmexp.cpuhit);
(void)printf("%9" PRIu64 " pagealloc local cpu not avail\n",
uvmexp.cpumiss);
(void)printf("%9" PRIu64 " faults with no memory\n", uvmexp.fltnoram);
(void)printf("%9" PRIu64 " faults with no anons\n", uvmexp.fltnoanon);
(void)printf("%9" PRIu64 " faults had to wait on pages\n", uvmexp.fltpgwait);
(void)printf("%9" PRIu64 " faults found released page\n", uvmexp.fltpgrele);
(void)printf("%9" PRIu64 " faults relock (%" PRIu64 " ok)\n", uvmexp.fltrelck,
uvmexp.fltrelckok);
(void)printf("%9" PRIu64 " anon page faults\n", uvmexp.fltanget);
(void)printf("%9" PRIu64 " anon retry faults\n", uvmexp.fltanretry);
(void)printf("%9" PRIu64 " amap copy faults\n", uvmexp.fltamcopy);
(void)printf("%9" PRIu64 " neighbour anon page faults\n", uvmexp.fltnamap);
(void)printf("%9" PRIu64 " neighbour object page faults\n", uvmexp.fltnomap);
(void)printf("%9" PRIu64 " locked pager get faults\n", uvmexp.fltlget);
(void)printf("%9" PRIu64 " unlocked pager get faults\n", uvmexp.fltget);
(void)printf("%9" PRIu64 " anon faults\n", uvmexp.flt_anon);
(void)printf("%9" PRIu64 " anon copy on write faults\n", uvmexp.flt_acow);
(void)printf("%9" PRIu64 " object faults\n", uvmexp.flt_obj);
(void)printf("%9" PRIu64 " promote copy faults\n", uvmexp.flt_prcopy);
(void)printf("%9" PRIu64 " promote zero fill faults\n", uvmexp.flt_przero);
(void)printf("%9" PRIu64 " faults upgraded lock\n",
uvmexp.fltup);
(void)printf("%9" PRIu64 " faults couldn't upgrade lock\n",
uvmexp.fltnoup);
(void)printf("%9" PRIu64 " times daemon wokeup\n",uvmexp.pdwoke);
(void)printf("%9" PRIu64 " revolutions of the clock hand\n", uvmexp.pdrevs);
(void)printf("%9" PRIu64 " pages freed by daemon\n", uvmexp.pdfreed);
(void)printf("%9" PRIu64 " pages scanned by daemon\n", uvmexp.pdscans);
(void)printf("%9" PRIu64 " anonymous pages scanned by daemon\n",
uvmexp.pdanscan);
(void)printf("%9" PRIu64 " object pages scanned by daemon\n", uvmexp.pdobscan);
(void)printf("%9" PRIu64 " pages reactivated\n", uvmexp.pdreact);
(void)printf("%9" PRIu64 " pages found busy by daemon\n", uvmexp.pdbusy);
(void)printf("%9" PRIu64 " pages deactivated\n", uvmexp.pddeact);
(void)printf("%9" PRIu64 " per-cpu stats synced\n", uvmexp.countsyncall);
(void)printf("%9" PRIu64 " anon pages possibly dirty\n", uvmexp.anonunknown);
(void)printf("%9" PRIu64 " anon pages dirty\n", uvmexp.anondirty);
(void)printf("%9" PRIu64 " anon pages clean\n", uvmexp.anonclean);
(void)printf("%9" PRIu64 " file pages possibly dirty\n", uvmexp.fileunknown);
(void)printf("%9" PRIu64 " file pages dirty\n", uvmexp.filedirty);
(void)printf("%9" PRIu64 " file pages clean\n", uvmexp.fileclean);
if (active_kernel) {
ssize = sizeof(nch_stats);
if (sysctlbyname("vfs.namecache_stats", &nch_stats, &ssize,
NULL, 0)) {
warn("vfs.namecache_stats failed");
memset(&nch_stats, 0, sizeof(nch_stats));
}
} else {
kread(namelist, X_NCHSTATS, &nch_stats, sizeof(nch_stats));
}
nchtotal = nch_stats.ncs_goodhits + nch_stats.ncs_neghits +
nch_stats.ncs_badhits + nch_stats.ncs_falsehits +
nch_stats.ncs_miss + nch_stats.ncs_long;
(void)printf("%9" PRIu64 " total name lookups\n", nchtotal);
(void)printf("%9" PRIu64 " good hits\n", nch_stats.ncs_goodhits);
(void)printf("%9" PRIu64 " negative hits\n", nch_stats.ncs_neghits);
(void)printf("%9" PRIu64 " bad hits\n", nch_stats.ncs_badhits);
(void)printf("%9" PRIu64 " false hits\n", nch_stats.ncs_falsehits);
(void)printf("%9" PRIu64 " miss\n", nch_stats.ncs_miss);
(void)printf("%9" PRIu64 " too long\n", nch_stats.ncs_long);
(void)printf("%9" PRIu64 " pass2 hits\n", nch_stats.ncs_pass2);
(void)printf("%9" PRIu64 " 2passes\n", nch_stats.ncs_2passes);
(void)printf("%9" PRIu64 " reverse hits\n", nch_stats.ncs_revhits);
(void)printf("%9" PRIu64 " reverse miss\n", nch_stats.ncs_revmiss);
(void)printf("%9" PRIu64 " access denied\n", nch_stats.ncs_denied);
(void)printf(
"%9s cache hits (%d%% pos + %d%% neg) system %d%% per-process\n",
"", PCT(nch_stats.ncs_goodhits, nchtotal),
PCT(nch_stats.ncs_neghits, nchtotal),
PCT(nch_stats.ncs_pass2, nchtotal));
(void)printf("%9s deletions %d%%, falsehits %d%%, toolong %d%%\n", "",
PCT(nch_stats.ncs_badhits, nchtotal),
PCT(nch_stats.ncs_falsehits, nchtotal),
PCT(nch_stats.ncs_long, nchtotal));
}
void
doforkst(void)
{
if (memf != NULL) {
struct uvmexp uvmexp_kernel;
kread(namelist, X_UVMEXP, &uvmexp_kernel, sizeof(uvmexp_kernel));
#define COPY(field) uvmexp.field = uvmexp_kernel.field
COPY(forks);
COPY(forks_ppwait);
COPY(forks_sharevm);
#undef COPY
} else {
size_t size = sizeof(uvmexp);
if (sysctl(uvmexp2_mib, __arraycount(uvmexp2_mib), &uvmexp,
&size, NULL, 0) == -1)
warn("sysctl vm.uvmexp2 failed");
}
(void)printf("%" PRIu64 " forks total\n", uvmexp.forks);
(void)printf("%" PRIu64 " forks blocked parent\n", uvmexp.forks_ppwait);
(void)printf("%" PRIu64 " forks shared address space with parent\n",
uvmexp.forks_sharevm);
}
void
drvstats(int *ovflwp)
{
size_t dn;
double dtime;
int ovflw = *ovflwp;
cpuswap();
drvswap();
tkswap();
for (dn = 0; dn < ndrive; ++dn) {
dtime = cur.cp_etime;
if (cur.timestamp[dn].tv_sec || cur.timestamp[dn].tv_usec) {
dtime = (double)cur.timestamp[dn].tv_sec +
((double)cur.timestamp[dn].tv_usec / (double)1000000);
}
if (!drv_select[dn])
continue;
PRWORD(ovflw, " %*.0f", 3, 1,
(cur.rxfer[dn] + cur.wxfer[dn]) / dtime);
}
*ovflwp = ovflw;
}
void
cpucounters(struct cpu_counter *cc)
{
static struct cpu_info **cpu_infos;
static int initialised;
struct cpu_info **slot;
if (memf == NULL) {
cc->nintr = uvmexp.intrs;
cc->nsyscall = uvmexp.syscalls;
cc->nswtch = uvmexp.swtch;
cc->nfault = uvmexp.faults;
cc->ntrap = uvmexp.traps;
cc->nsoft = uvmexp.softs;
return;
}
if (!initialised) {
kread(namelist, X_CPU_INFOS, &cpu_infos, sizeof(cpu_infos));
initialised = 1;
}
slot = cpu_infos;
memset(cc, 0, sizeof(*cc));
for (;;) {
struct cpu_info tci, *ci = NULL;
deref_kptr(slot++, &ci, sizeof(ci), "CPU array trashed");
if (!ci) {
break;
}
if ((size_t)kvm_read(kd, (u_long)ci, &tci, sizeof(tci))
!= sizeof(tci)) {
warnx("Can't read cpu info from %p (%s)",
ci, kvm_geterr(kd));
memset(cc, 0, sizeof(*cc));
return;
}
cc->nintr += tci.ci_data.cpu_nintr;
cc->nsyscall += tci.ci_data.cpu_nsyscall;
cc->nswtch = tci.ci_data.cpu_nswtch;
cc->nfault = tci.ci_data.cpu_nfault;
cc->ntrap = tci.ci_data.cpu_ntrap;
cc->nsoft = tci.ci_data.cpu_nsoft;
}
}
void
cpustats(int *ovflwp)
{
int state;
double pcnt, total;
double stat_us, stat_sy, stat_id;
int ovflw = *ovflwp;
total = 0;
for (state = 0; state < CPUSTATES; ++state)
total += cur.cp_time[state];
if (total)
pcnt = 100 / total;
else
pcnt = 0;
stat_us = (cur.cp_time[CP_USER] + cur.cp_time[CP_NICE]) * pcnt;
stat_sy = (cur.cp_time[CP_SYS] + cur.cp_time[CP_INTR]) * pcnt;
stat_id = cur.cp_time[CP_IDLE] * pcnt;
PRWORD(ovflw, " %*.0f", ((stat_sy >= 100) ? 2 : 3), 1, stat_us);
PRWORD(ovflw, " %*.0f", ((stat_us >= 100 || stat_id >= 100) ? 2 : 3), 1,
stat_sy);
PRWORD(ovflw, " %*.0f", 3, 1, stat_id);
*ovflwp = ovflw;
}
void
dointr(int verbose)
{
unsigned long *intrcnt, *ointrcnt;
unsigned long long inttotal, uptime;
int nintr, inamlen;
char *intrname, *ointrname;
if (memf == NULL) {
doevcnt(verbose, EVCNT_TYPE_INTR);
return;
}
inttotal = 0;
uptime = getuptime();
nintr = intrnl[X_EINTRCNT].n_value - intrnl[X_INTRCNT].n_value;
inamlen = intrnl[X_EINTRNAMES].n_value - intrnl[X_INTRNAMES].n_value;
if (nintr != 0 && inamlen != 0) {
(void)printf("%-34s %16s %8s\n", "interrupt", "total", "rate");
ointrcnt = intrcnt = malloc((size_t)nintr);
ointrname = intrname = malloc((size_t)inamlen);
if (intrcnt == NULL || intrname == NULL)
errx(1, "%s", "");
kread(intrnl, X_INTRCNT, intrcnt, (size_t)nintr);
kread(intrnl, X_INTRNAMES, intrname, (size_t)inamlen);
nintr /= sizeof(long);
while (--nintr >= 0) {
if (*intrcnt || verbose)
(void)printf("%-34s %16llu %8llu\n", intrname,
(unsigned long long)*intrcnt,
(unsigned long long)
(*intrcnt / uptime));
intrname += strlen(intrname) + 1;
inttotal += *intrcnt++;
}
free(ointrcnt);
free(ointrname);
}
doevcnt(verbose, EVCNT_TYPE_INTR);
}
void
doevcnt(int verbose, int type)
{
static const char * const evtypes [] = { "misc", "intr", "trap" };
uint64_t counttotal, uptime;
struct evcntlist allevents;
struct evcnt evcnt, *evptr;
size_t evlen_max, total_max, rate_max;
char evgroup[EVCNT_STRING_MAX], evname[EVCNT_STRING_MAX];
counttotal = 0;
uptime = getuptime();
if (memf == NULL) {
const int mib[4] = { CTL_KERN, KERN_EVCNT, type,
verbose ? KERN_EVCNT_COUNT_ANY : KERN_EVCNT_COUNT_NONZERO };
size_t buflen0, buflen = 0;
void *buf0, *buf = NULL;
const struct evcnt_sysctl *evs, *last_evs;
for (;;) {
size_t newlen;
int error;
if (buflen)
buf = malloc(buflen);
error = sysctl(mib, __arraycount(mib),
buf, &newlen, NULL, 0);
if (error) {
err(1, "kern.evcnt");
if (buf)
free(buf);
return;
}
if (newlen <= buflen) {
buflen = newlen;
break;
}
if (buf)
free(buf);
buflen = newlen;
}
buflen0 = buflen;
evs = buf0 = buf;
last_evs = (void *)((char *)buf + buflen);
buflen /= sizeof(uint64_t);
evlen_max = 0;
total_max = sizeof("total") - 1;
rate_max = sizeof("rate") - 1;
while (evs < last_evs
&& buflen >= sizeof(*evs)/sizeof(uint64_t)
&& buflen >= evs->ev_len) {
char cbuf[64];
size_t len;
len = strlen(evs->ev_strings + evs->ev_grouplen + 1);
len += evs->ev_grouplen + 1;
if (evlen_max < len)
evlen_max= len;
len = snprintf(cbuf, sizeof(cbuf), "%"PRIu64,
evs->ev_count);
if (total_max < len)
total_max = len;
len = snprintf(cbuf, sizeof(cbuf), "%"PRIu64,
evs->ev_count / uptime);
if (rate_max < len)
rate_max = len;
buflen -= evs->ev_len;
counttotal += evs->ev_count;
evs = (const void *)
((const uint64_t *)evs + evs->ev_len);
}
if (type != EVCNT_TYPE_ANY) {
char cbuf[64];
size_t len;
len = snprintf(cbuf, sizeof(cbuf), "%"PRIu64,
counttotal);
if (total_max < len)
total_max = len;
len = snprintf(cbuf, sizeof(cbuf), "%"PRIu64,
counttotal / uptime);
if (rate_max < len)
rate_max = len;
}
const char *evdesc = type == EVCNT_TYPE_ANY ?
"event" : "interrupt";
const char *typedesc = type == EVCNT_TYPE_ANY ?
" type" : "";
(void)printf("%-*s %*s %*s%s\n",
(int)evlen_max, evdesc,
(int)total_max, "total",
(int)rate_max, "rate",
typedesc);
buflen = buflen0;
evs = buf0;
last_evs = (void *)((char *)buf + buflen);
buflen /= sizeof(uint64_t);
while (evs < last_evs
&& buflen >= sizeof(*evs)/sizeof(uint64_t)
&& buflen >= evs->ev_len) {
(void)printf(type == EVCNT_TYPE_ANY ?
"%s %s%*s %*"PRIu64" %*"PRIu64" %s\n" :
"%s %s%*s %*"PRIu64" %*"PRIu64"\n",
evs->ev_strings,
evs->ev_strings + evs->ev_grouplen + 1,
(int)evlen_max - (evs->ev_grouplen + 1
+ evs->ev_namelen), "",
(int)total_max, evs->ev_count,
(int)rate_max, evs->ev_count / uptime,
(evs->ev_type < __arraycount(evtypes) ?
evtypes[evs->ev_type] : "?"));
buflen -= evs->ev_len;
evs = (const void *)
((const uint64_t *)evs + evs->ev_len);
}
free(buf);
if (type != EVCNT_TYPE_ANY)
(void)printf("%-*s %*"PRIu64" %*"PRIu64"\n",
(int)evlen_max, "Total",
(int)total_max, counttotal,
(int)rate_max, counttotal / uptime);
return;
}
if (type == EVCNT_TYPE_ANY)
(void)printf("%-34s %16s %8s %s\n", "event", "total", "rate",
"type");
kread(namelist, X_ALLEVENTS, &allevents, sizeof allevents);
evptr = TAILQ_FIRST(&allevents);
while (evptr) {
deref_kptr(evptr, &evcnt, sizeof(evcnt), "event chain trashed");
evptr = TAILQ_NEXT(&evcnt, ev_list);
if (evcnt.ev_count == 0 && !verbose)
continue;
if (type != EVCNT_TYPE_ANY && evcnt.ev_type != type)
continue;
deref_kptr(evcnt.ev_group, evgroup,
(size_t)evcnt.ev_grouplen + 1, "event chain trashed");
deref_kptr(evcnt.ev_name, evname,
(size_t)evcnt.ev_namelen + 1, "event chain trashed");
(void)printf(type == EVCNT_TYPE_ANY ?
"%s %s%*s %16"PRIu64" %8"PRIu64" %s\n" :
"%s %s%*s %16"PRIu64" %8"PRIu64"\n",
evgroup, evname,
34 - (evcnt.ev_grouplen + 1 + evcnt.ev_namelen), "",
evcnt.ev_count,
(evcnt.ev_count / uptime),
(evcnt.ev_type < __arraycount(evtypes) ?
evtypes[evcnt.ev_type] : "?"));
counttotal += evcnt.ev_count;
}
if (type != EVCNT_TYPE_ANY)
(void)printf("%-34s %16"PRIu64" %8"PRIu64"\n",
"Total", counttotal, counttotal / uptime);
}
static void
dopool_sysctl(int verbose, int wide)
{
uint64_t total, inuse, this_total, this_inuse;
struct {
uint64_t pt_nget;
uint64_t pt_nfail;
uint64_t pt_nput;
uint64_t pt_nout;
uint64_t pt_nitems;
uint64_t pt_npagealloc;
uint64_t pt_npagefree;
uint64_t pt_npages;
} pool_totals;
size_t i, len;
int name_len, ovflw;
struct pool_sysctl *pp, *data;
char maxp[32];
data = asysctlbyname("kern.pool", &len);
if (data == NULL)
err(1, "failed to read kern.pool");
memset(&pool_totals, 0, sizeof pool_totals);
total = inuse = 0;
len /= sizeof(*data);
(void)printf("Memory resource pool statistics\n");
(void)printf(
"%-*s%*s%*s%*s%*s%s%s%*s%*s%*s%s%*s%6s%*s%*s%s%s%s\n",
wide ? 16 : 11, "Name",
wide ? 9 : 5, "Size",
wide ? 13 : 9, "Requests",
wide ? 8 : 5, "Fail",
wide ? 13 : 9, "Releases",
wide ? " InUse" : "",
wide ? " Avail" : "",
wide ? 11 : 6, "Pgreq",
wide ? 11 : 6, "Pgrel",
wide ? 9 : 6, "Npage",
wide ? " PageSz" : "",
wide ? 8 : 6, "Hiwat",
"Minpg",
wide ? 9 : 6, "Maxpg",
wide ? 8 : 5, "Idle",
wide ? " Flags" : "",
wide ? " Util" : "",
wide ? " TotalKB" : "");
name_len = MIN((int)sizeof(pp->pr_wchan), wide ? 16 : 11);
for (i = 0; i < len; ++i) {
pp = &data[i];
if (pp->pr_nget == 0 && !verbose)
continue;
if (pp->pr_maxpages == UINT_MAX)
(void)snprintf(maxp, sizeof(maxp), "inf");
else
(void)snprintf(maxp, sizeof(maxp), "%" PRIu64,
pp->pr_maxpages);
ovflw = 0;
PRWORD(ovflw, "%-*s", name_len, 0, pp->pr_wchan);
PRWORD(ovflw, " %*" PRIu64, wide ? 9 : 5, 1, pp->pr_size);
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pp->pr_nget);
pool_totals.pt_nget += pp->pr_nget;
PRWORD(ovflw, " %*" PRIu64, wide ? 8 : 5, 1, pp->pr_nfail);
pool_totals.pt_nfail += pp->pr_nfail;
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pp->pr_nput);
pool_totals.pt_nput += pp->pr_nput;
if (wide) {
PRWORD(ovflw, " %*" PRIu64, 9, 1, pp->pr_nout);
pool_totals.pt_nout += pp->pr_nout;
PRWORD(ovflw, " %*" PRIu64, 9, 1, pp->pr_nitems);
pool_totals.pt_nitems += pp->pr_nitems;
}
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pp->pr_npagealloc);
pool_totals.pt_npagealloc += pp->pr_npagealloc;
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pp->pr_npagefree);
pool_totals.pt_npagefree += pp->pr_npagefree;
PRWORD(ovflw, " %*" PRIu64, wide ? 9 : 6, 1, pp->pr_npages);
pool_totals.pt_npages += pp->pr_npages;
if (wide)
PRWORD(ovflw, " %*" PRIu64, 9, 1, pp->pr_pagesize);
PRWORD(ovflw, " %*" PRIu64, wide ? 8 : 6, 1, pp->pr_hiwat);
PRWORD(ovflw, " %*" PRIu64, 6, 1, pp->pr_minpages);
PRWORD(ovflw, " %*s", wide ? 9 : 6, 1, maxp);
PRWORD(ovflw, " %*" PRIu64, wide ? 8 : 5, 1, pp->pr_nidle);
if (wide)
PRWORD(ovflw, " 0x%0*" PRIx64, 6, 1,
pp->pr_flags);
this_inuse = pp->pr_nout * pp->pr_size;
this_total = pp->pr_npages * pp->pr_pagesize;
if (pp->pr_flags & PR_RECURSIVE) {
total += (this_total - this_inuse);
} else {
inuse += this_inuse;
total += this_total;
}
if (wide) {
if (this_total == 0) {
(void)printf(" ---");
} else {
(void)printf(" %5.1f%% %10" PRIu64,
(100.0 * this_inuse) / this_total,
this_total / KILO);
}
}
(void)printf("\n");
}
ovflw = 0;
PRWORD(ovflw, "%-*s", name_len, 0, "Totals");
PRWORD(ovflw, " %*s", wide ? 9 : 5, 1, "");
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pool_totals.pt_nget);
PRWORD(ovflw, " %*" PRIu64, wide ? 8 : 5, 1, pool_totals.pt_nfail);
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pool_totals.pt_nput);
if (wide) {
PRWORD(ovflw, " %*" PRIu64, 9, 1, pool_totals.pt_nout);
PRWORD(ovflw, " %*" PRIu64, 9, 1, pool_totals.pt_nitems);
}
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pool_totals.pt_npagealloc);
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pool_totals.pt_npagefree);
PRWORD(ovflw, " %*" PRIu64, wide ? 9 : 6, 1, pool_totals.pt_npages);
(void)printf("\n");
inuse /= KILO;
total /= KILO;
(void)printf(
"\nIn use %" PRIu64 "K, "
"total allocated %" PRIu64 "K; utilization %.1f%%\n",
inuse, total, (100.0 * inuse) / total);
free(data);
}
void
dopool(int verbose, int wide)
{
int first, ovflw;
void *addr;
uint64_t total, inuse, this_total, this_inuse;
struct {
uint64_t pt_nget;
uint64_t pt_nfail;
uint64_t pt_nput;
uint64_t pt_nout;
uint64_t pt_nitems;
uint64_t pt_npagealloc;
uint64_t pt_npagefree;
uint64_t pt_npages;
} pool_totals;
TAILQ_HEAD(,pool) pool_head;
struct pool pool, *pp = &pool;
struct pool_allocator pa;
char maxp[32], name[32];
if (memf == NULL) {
dopool_sysctl(verbose, wide);
return;
}
memset(&pool_totals, 0, sizeof pool_totals);
kread(namelist, X_POOLHEAD, &pool_head, sizeof(pool_head));
addr = TAILQ_FIRST(&pool_head);
total = inuse = 0;
for (first = 1; addr != NULL; addr = TAILQ_NEXT(pp, pr_poollist) ) {
deref_kptr(addr, pp, sizeof(*pp), "pool chain trashed");
deref_kptr(pp->pr_alloc, &pa, sizeof(pa),
"pool allocator trashed");
deref_kptr(pp->pr_wchan, name, sizeof(name),
"pool wait channel trashed");
name[sizeof(name)-1] = '\0';
if (first) {
(void)printf("Memory resource pool statistics\n");
(void)printf(
"%-*s%*s%*s%*s%*s%s%s%*s%*s%*s%s%*s%6s%*s%*s%s%s%s\n",
wide ? 16 : 11, "Name",
wide ? 9 : 5, "Size",
wide ? 13 : 9, "Requests",
wide ? 8 : 5, "Fail",
wide ? 13 : 9, "Releases",
wide ? " InUse" : "",
wide ? " Avail" : "",
wide ? 11 : 6, "Pgreq",
wide ? 11 : 6, "Pgrel",
wide ? 9 : 6, "Npage",
wide ? " PageSz" : "",
wide ? 8 : 6, "Hiwat",
"Minpg",
wide ? 9 : 6, "Maxpg",
wide ? 8 : 5, "Idle",
wide ? " Flags" : "",
wide ? " Util" : "",
wide ? " TotalKB" : "");
first = 0;
}
if (pp->pr_nget == 0 && !verbose)
continue;
if (pp->pr_maxpages == UINT_MAX)
(void)snprintf(maxp, sizeof(maxp), "inf");
else
(void)snprintf(maxp, sizeof(maxp), "%u",
pp->pr_maxpages);
ovflw = 0;
PRWORD(ovflw, "%-*s", wide ? 16 : 11, 0, name);
PRWORD(ovflw, " %*u", wide ? 9 : 5, 1, pp->pr_size);
PRWORD(ovflw, " %*lu", wide ? 13 : 9, 1, pp->pr_nget);
pool_totals.pt_nget += pp->pr_nget;
PRWORD(ovflw, " %*lu", wide ? 8 : 5, 1, pp->pr_nfail);
pool_totals.pt_nfail += pp->pr_nfail;
PRWORD(ovflw, " %*lu", wide ? 13 : 9, 1, pp->pr_nput);
pool_totals.pt_nput += pp->pr_nput;
if (wide) {
PRWORD(ovflw, " %*u", 9, 1, pp->pr_nout);
pool_totals.pt_nout += pp->pr_nout;
PRWORD(ovflw, " %*u", 9, 1, pp->pr_nitems);
pool_totals.pt_nitems += pp->pr_nitems;
}
PRWORD(ovflw, " %*lu", wide ? 11 : 6, 1, pp->pr_npagealloc);
pool_totals.pt_npagealloc += pp->pr_npagealloc;
PRWORD(ovflw, " %*lu", wide ? 11 : 6, 1, pp->pr_npagefree);
pool_totals.pt_npagefree += pp->pr_npagefree;
PRWORD(ovflw, " %*u", wide ? 9 : 6, 1, pp->pr_npages);
pool_totals.pt_npages += pp->pr_npages;
if (wide)
PRWORD(ovflw, " %*u", 9, 1, pa.pa_pagesz);
PRWORD(ovflw, " %*u", wide ? 8 : 6, 1, pp->pr_hiwat);
PRWORD(ovflw, " %*u", 6, 1, pp->pr_minpages);
PRWORD(ovflw, " %*s", wide ? 9 : 6, 1, maxp);
PRWORD(ovflw, " %*lu", wide ? 8 : 5, 1, pp->pr_nidle);
if (wide)
PRWORD(ovflw, " 0x%0*x", 6, 1,
pp->pr_flags | pp->pr_roflags);
this_inuse = (uint64_t)pp->pr_nout * pp->pr_size;
this_total = (uint64_t)pp->pr_npages * pa.pa_pagesz;
if (pp->pr_roflags & PR_RECURSIVE) {
total += (this_total - this_inuse);
} else {
inuse += this_inuse;
total += this_total;
}
if (wide) {
if (this_total == 0) {
(void)printf(" ---");
} else {
(void)printf(" %5.1f%% %10" PRIu64,
(100.0 * this_inuse) / this_total,
this_total / KILO);
}
}
(void)printf("\n");
}
ovflw = 0;
PRWORD(ovflw, "%-*s", wide ? 16 : 11, 0, "Totals");
PRWORD(ovflw, " %*s", wide ? 9 : 5, 1, "");
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pool_totals.pt_nget);
PRWORD(ovflw, " %*" PRIu64, wide ? 8 : 5, 1, pool_totals.pt_nfail);
PRWORD(ovflw, " %*" PRIu64, wide ? 13 : 9, 1, pool_totals.pt_nput);
if (wide) {
PRWORD(ovflw, " %*" PRIu64, 9, 1, pool_totals.pt_nout);
PRWORD(ovflw, " %*" PRIu64, 9, 1, pool_totals.pt_nitems);
}
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pool_totals.pt_npagealloc);
PRWORD(ovflw, " %*" PRIu64, wide ? 11 : 6, 1, pool_totals.pt_npagefree);
PRWORD(ovflw, " %*" PRIu64, wide ? 9 : 6, 1, pool_totals.pt_npages);
(void)printf("\n");
inuse /= KILO;
total /= KILO;
(void)printf(
"\nIn use %" PRIu64 "K, "
"total allocated %" PRIu64 "K; utilization %.1f%%\n",
inuse, total, (100.0 * inuse) / total);
}
static void
dopoolcache_sysctl(int verbose)
{
struct pool_sysctl *data, *pp;
size_t i, len;
bool first = true;
int ovflw;
uint64_t tot;
double p;
data = asysctlbyname("kern.pool", &len);
if (data == NULL)
err(1, "failed to read kern.pool");
len /= sizeof(*data);
for (i = 0; i < len; ++i) {
pp = &data[i];
if (pp->pr_cache_meta_size == 0)
continue;
if (pp->pr_cache_nmiss_global == 0 && !verbose)
continue;
if (first) {
(void)printf("Pool cache statistics.\n");
(void)printf("%-*s%*s%*s%*s%*s%*s%*s%*s%*s%*s\n",
12, "Name",
6, "Spin",
6, "GrpSz",
5, "Full",
5, "Emty",
10, "PoolLayer",
11, "CacheLayer",
6, "Hit%",
12, "CpuLayer",
6, "Hit%"
);
first = false;
}
ovflw = 0;
PRWORD(ovflw, "%-*s", MIN((int)sizeof(pp->pr_wchan), 13), 1,
pp->pr_wchan);
PRWORD(ovflw, " %*" PRIu64, 6, 1, pp->pr_cache_ncontended);
PRWORD(ovflw, " %*" PRIu64, 6, 1, pp->pr_cache_meta_size);
PRWORD(ovflw, " %*" PRIu64, 5, 1, pp->pr_cache_nfull);
PRWORD(ovflw, " %*" PRIu64, 5, 1, pp->pr_cache_nempty);
PRWORD(ovflw, " %*" PRIu64, 10, 1, pp->pr_cache_nmiss_global);
tot = pp->pr_cache_nhit_global + pp->pr_cache_nmiss_global;
p = pp->pr_cache_nhit_global * 100.0 / tot;
PRWORD(ovflw, " %*" PRIu64, 11, 1, tot);
PRWORD(ovflw, " %*.1f", 6, 1, p);
tot = pp->pr_cache_nhit_pcpu + pp->pr_cache_nmiss_pcpu;
p = pp->pr_cache_nhit_pcpu * 100.0 / tot;
PRWORD(ovflw, " %*" PRIu64, 12, 1, tot);
PRWORD(ovflw, " %*.1f", 6, 1, p);
printf("\n");
}
}
void
dopoolcache(int verbose)
{
struct pool_cache pool_cache, *pc = &pool_cache;
pool_cache_cpu_t cache_cpu, *cc = &cache_cpu;
TAILQ_HEAD(,pool) pool_head;
struct pool pool, *pp = &pool;
char name[32];
uint64_t cpuhit, cpumiss, pchit, pcmiss, contended, tot;
uint32_t nfull;
void *addr;
int first, ovflw;
size_t i;
double p;
if (memf == NULL) {
dopoolcache_sysctl(verbose);
return;
}
kread(namelist, X_POOLHEAD, &pool_head, sizeof(pool_head));
addr = TAILQ_FIRST(&pool_head);
for (first = 1; addr != NULL; addr = TAILQ_NEXT(pp, pr_poollist) ) {
deref_kptr(addr, pp, sizeof(*pp), "pool chain trashed");
if (pp->pr_cache == NULL)
continue;
deref_kptr(pp->pr_wchan, name, sizeof(name),
"pool wait channel trashed");
deref_kptr(pp->pr_cache, pc, sizeof(*pc), "pool cache trashed");
name[sizeof(name)-1] = '\0';
cpuhit = 0;
cpumiss = 0;
pcmiss = 0;
contended = 0;
nfull = 0;
for (i = 0; i < __arraycount(pc->pc_cpus); i++) {
if ((addr = pc->pc_cpus[i]) == NULL)
continue;
deref_kptr(addr, cc, sizeof(*cc),
"pool cache cpu trashed");
cpuhit += cc->cc_hits;
cpumiss += cc->cc_misses;
pcmiss += cc->cc_pcmisses;
nfull += cc->cc_nfull;
contended += cc->cc_contended;
}
pchit = cpumiss - pcmiss;
if (pcmiss == 0 && !verbose)
continue;
if (first) {
(void)printf("Pool cache statistics.\n");
(void)printf("%-*s%*s%*s%*s%*s%*s%*s%*s%*s%*s\n",
12, "Name",
6, "Spin",
6, "GrpSz",
5, "Full",
5, "Emty",
10, "PoolLayer",
11, "CacheLayer",
6, "Hit%",
12, "CpuLayer",
6, "Hit%"
);
first = 0;
}
ovflw = 0;
PRWORD(ovflw, "%-*s", 13, 1, name);
PRWORD(ovflw, " %*llu", 6, 1, (long long)contended);
PRWORD(ovflw, " %*u", 6, 1, pc->pc_pcgsize);
PRWORD(ovflw, " %*u", 5, 1, nfull);
PRWORD(ovflw, " %*u", 5, 1, 0);
PRWORD(ovflw, " %*llu", 10, 1, (long long)pcmiss);
tot = pchit + pcmiss;
p = pchit * 100.0 / (tot);
PRWORD(ovflw, " %*llu", 11, 1, (long long)tot);
PRWORD(ovflw, " %*.1f", 6, 1, p);
tot = cpuhit + cpumiss;
p = cpuhit * 100.0 / (tot);
PRWORD(ovflw, " %*llu", 12, 1, (long long)tot);
PRWORD(ovflw, " %*.1f", 6, 1, p);
printf("\n");
}
}
enum hashtype {
HASH_LIST,
HASH_SLIST,
HASH_TAILQ,
HASH_PSLIST
};
struct kernel_hash {
const char * description;
int hashsize;
int hashtbl;
enum hashtype type;
size_t offset;
} khashes[] =
{
{
"buffer hash",
X_BUFHASH, X_BUFHASHTBL,
HASH_LIST, offsetof(struct buf, b_hash)
}, {
"ipv4 address -> interface hash",
X_IFADDRHASH, X_IFADDRHASHTBL,
HASH_LIST, offsetof(struct in_ifaddr, ia_hash),
}, {
"user info (uid -> used processes) hash",
X_UIHASH, X_UIHASHTBL,
HASH_SLIST, offsetof(struct uidinfo, ui_hash),
}, {
"vnode cache hash",
X_VCACHEHASH, X_VCACHETBL,
HASH_SLIST, offsetof(struct vnode_impl, vi_hash),
}, {
NULL, -1, -1, 0, 0,
}
};
void
dohashstat(int verbose, int todo, const char *hashname)
{
LIST_HEAD(, generic) *hashtbl_list;
SLIST_HEAD(, generic) *hashtbl_slist;
TAILQ_HEAD(, generic) *hashtbl_tailq;
struct kernel_hash *curhash;
void *hashaddr, *hashbuf, *nhashbuf, *nextaddr;
size_t elemsize, hashbufsize, thissize;
u_long hashsize, i;
int used, items, chain, maxchain;
if (memf == NULL) {
dohashstat_sysctl(verbose, todo, hashname);
return;
}
hashbuf = NULL;
hashbufsize = 0;
if (todo & HASHLIST) {
(void)printf("Supported hashes:\n");
for (curhash = khashes; curhash->description; curhash++) {
if (hashnl[curhash->hashsize].n_value == 0 ||
hashnl[curhash->hashtbl].n_value == 0)
continue;
(void)printf("\t%-16s%s\n",
hashnl[curhash->hashsize].n_name + 1,
curhash->description);
}
return;
}
if (hashname != NULL) {
for (curhash = khashes; curhash->description; curhash++) {
if (strcmp(hashnl[curhash->hashsize].n_name + 1,
hashname) == 0 &&
hashnl[curhash->hashsize].n_value != 0 &&
hashnl[curhash->hashtbl].n_value != 0)
break;
}
if (curhash->description == NULL) {
warnx("%s: no such hash", hashname);
return;
}
}
(void)printf(
"%-16s %8s %8s %8s %8s %8s %8s\n"
"%-16s %8s %8s %8s %8s %8s %8s\n",
"", "total", "used", "util", "num", "average", "maximum",
"hash table", "buckets", "buckets", "%", "items", "chain",
"chain");
for (curhash = khashes; curhash->description; curhash++) {
if (hashnl[curhash->hashsize].n_value == 0 ||
hashnl[curhash->hashtbl].n_value == 0)
continue;
if (hashname != NULL &&
strcmp(hashnl[curhash->hashsize].n_name + 1, hashname))
continue;
switch (curhash->type) {
case HASH_LIST:
elemsize = sizeof(*hashtbl_list);
break;
case HASH_SLIST:
elemsize = sizeof(*hashtbl_slist);
break;
case HASH_TAILQ:
elemsize = sizeof(*hashtbl_tailq);
break;
default:
continue;
}
deref_kptr((void *)hashnl[curhash->hashsize].n_value,
&hashsize, sizeof(hashsize),
hashnl[curhash->hashsize].n_name);
hashsize++;
deref_kptr((void *)hashnl[curhash->hashtbl].n_value,
&hashaddr, sizeof(hashaddr),
hashnl[curhash->hashtbl].n_name);
if (verbose)
(void)printf(
"%s %lu, %s %p, offset %ld, elemsize %llu\n",
hashnl[curhash->hashsize].n_name + 1, hashsize,
hashnl[curhash->hashtbl].n_name + 1, hashaddr,
(long)curhash->offset,
(unsigned long long)elemsize);
thissize = hashsize * elemsize;
if (hashbuf == NULL || thissize > hashbufsize) {
if ((nhashbuf = realloc(hashbuf, thissize)) == NULL)
errx(1, "malloc hashbuf %llu",
(unsigned long long)hashbufsize);
hashbuf = nhashbuf;
hashbufsize = thissize;
}
deref_kptr(hashaddr, hashbuf, thissize,
hashnl[curhash->hashtbl].n_name);
used = 0;
items = maxchain = 0;
if (curhash->type == HASH_LIST) {
hashtbl_list = hashbuf;
hashtbl_slist = NULL;
hashtbl_tailq = NULL;
} else if (curhash->type == HASH_SLIST) {
hashtbl_list = NULL;
hashtbl_slist = hashbuf;
hashtbl_tailq = NULL;
} else {
hashtbl_list = NULL;
hashtbl_slist = NULL;
hashtbl_tailq = hashbuf;
}
for (i = 0; i < hashsize; i++) {
if (curhash->type == HASH_LIST)
nextaddr = LIST_FIRST(&hashtbl_list[i]);
else if (curhash->type == HASH_SLIST)
nextaddr = SLIST_FIRST(&hashtbl_slist[i]);
else
nextaddr = TAILQ_FIRST(&hashtbl_tailq[i]);
if (nextaddr == NULL)
continue;
if (verbose)
(void)printf("%5lu: %p\n", i, nextaddr);
used++;
chain = 0;
do {
chain++;
deref_kptr((char *)nextaddr + curhash->offset,
&nextaddr, sizeof(void *),
"hash chain corrupted");
if (verbose > 1)
(void)printf("got nextaddr as %p\n",
nextaddr);
} while (nextaddr != NULL);
items += chain;
if (verbose && chain > 1)
(void)printf("\tchain = %d\n", chain);
if (chain > maxchain)
maxchain = chain;
}
(void)printf("%-16s %8ld %8d %8.2f %8d %8.2f %8d\n",
hashnl[curhash->hashsize].n_name + 1,
hashsize, used, used * 100.0 / hashsize,
items, used ? (double)items / used : 0.0, maxchain);
}
}
void
dohashstat_sysctl(int verbose, int todo, const char *hashname)
{
struct hashstat_sysctl hash, *data, *hs;
int mib[3];
int error;
size_t i, len, miblen;
miblen = __arraycount(mib);
error = sysctlnametomib("kern.hashstat", mib, &miblen);
if (error)
err(EXIT_FAILURE, "nametomib kern.hashstat failed");
assert(miblen < 3);
if (todo & HASHLIST) {
mib[miblen] = CTL_DESCRIBE;
miblen++;
};
if (hashname) {
mib[miblen] = CTL_QUERY;
miblen++;
memset(&hash, 0, sizeof(hash));
strlcpy(hash.hash_name, hashname, sizeof(hash.hash_name));
len = sizeof(hash);
error = sysctl(mib, miblen, &hash, &len, &hash, len);
if (error == ENOENT) {
err(1, "hash '%s' not found", hashname);
return;
} else if (error) {
err(1, "sysctl kern.hashstat query failed");
return;
}
data = &hash;
len = 1;
} else {
data = asysctl(mib, miblen, &len);
if (data == NULL)
err(1, "failed to read kern.hashstat");
len /= sizeof(*data);
}
if (todo & HASHLIST) {
printf("Supported hashes:\n");
for (i = 0, hs = data; i < len; i++, hs++) {
printf("\t%-16s%s\n", hs->hash_name, hs->hash_desc);
}
} else {
printf("%-16s %8s %8s %8s %8s %8s %8s\n"
"%-16s %8s %8s %8s %8s %8s %8s\n",
"", "total", "used", "util", "num", "average", "maximum",
"hash table", "buckets", "buckets", "%", "items", "chain",
"chain");
for (i = 0, hs = data; i < len; i++, hs++) {
printf("%-16s %8"PRId64" %8"PRId64" %8.2f %8"PRId64
" %8.2f %8"PRId64"\n",
hs->hash_name, hs->hash_size, hs->hash_used,
hs->hash_used * 100.0 / hs->hash_size, hs->hash_items,
hs->hash_used ? (double)hs->hash_items / hs->hash_used : 0.0,
hs->hash_maxchain);
}
}
if (!hashname && (data != NULL))
free(data);
}
int
kreadc(struct nlist *nl, int nlx, void *addr, size_t size)
{
const char *sym;
sym = nl[nlx].n_name;
if (*sym == '_')
++sym;
if (nl[nlx].n_type == 0 || nl[nlx].n_value == 0)
return 0;
deref_kptr((void *)nl[nlx].n_value, addr, size, sym);
return 1;
}
void
kread(struct nlist *nl, int nlx, void *addr, size_t size)
{
const char *sym;
sym = nl[nlx].n_name;
if (*sym == '_')
++sym;
if (nl[nlx].n_type == 0 || nl[nlx].n_value == 0)
errx(1, "symbol %s not defined", sym);
deref_kptr((void *)nl[nlx].n_value, addr, size, sym);
}
void
deref_kptr(const void *kptr, void *ptr, size_t len, const char *msg)
{
if (*msg == '_')
msg++;
if ((size_t)kvm_read(kd, (u_long)kptr, (char *)ptr, len) != len)
errx(1, "kptr %lx: %s: %s", (u_long)kptr, msg, kvm_geterr(kd));
}
void
hist_traverse(int todo, const char *histname)
{
struct kern_history_head histhead;
struct kern_history hist, *histkva;
char *name = NULL;
size_t namelen = 0;
if (histnl[0].n_value == 0) {
warnx("kernel history is not compiled into the kernel.");
return;
}
deref_kptr((void *)histnl[X_KERN_HISTORIES].n_value, &histhead,
sizeof(histhead), histnl[X_KERN_HISTORIES].n_name);
if (histhead.lh_first == NULL) {
warnx("No active kernel history logs.");
return;
}
if (todo & HISTLIST)
(void)printf("Active kernel histories:");
for (histkva = LIST_FIRST(&histhead); histkva != NULL;
histkva = LIST_NEXT(&hist, list)) {
deref_kptr(histkva, &hist, sizeof(hist), "histkva");
if (name == NULL || hist.namelen > namelen) {
if (name != NULL)
free(name);
namelen = hist.namelen;
if ((name = malloc(namelen + 1)) == NULL)
err(1, "malloc history name");
}
deref_kptr(hist.name, name, namelen, "history name");
name[namelen] = '\0';
if (todo & HISTLIST)
(void)printf(" %s", name);
else {
if (histname == NULL || strcmp(histname, name) == 0) {
if (histname == NULL)
(void)printf(
"\nkernel history `%s':\n", name);
hist_dodump(&hist);
}
}
}
if (todo & HISTLIST)
(void)putchar('\n');
if (name != NULL)
free(name);
}
void
hist_dodump(struct kern_history *histp)
{
struct kern_history_ent *histents, *e;
struct timeval tv;
size_t histsize;
char *fmt = NULL, *fn = NULL;
size_t fmtlen = 0, fnlen = 0;
unsigned i;
histsize = sizeof(struct kern_history_ent) * histp->n;
if ((histents = malloc(histsize)) == NULL)
err(1, "malloc history entries");
(void)memset(histents, 0, histsize);
(void)printf("%"PRIu32" entries, next is %"PRIu32"\n",
histp->n, histp->f);
deref_kptr(histp->e, histents, histsize, "history entries");
i = histp->f;
do {
e = &histents[i];
if (e->fmt != NULL) {
if (fmt == NULL || e->fmtlen > fmtlen) {
free(fmt);
fmtlen = e->fmtlen;
if ((fmt = malloc(fmtlen + 1)) == NULL)
err(1, "malloc printf format");
}
if (fn == NULL || e->fnlen > fnlen) {
free(fn);
fnlen = e->fnlen;
if ((fn = malloc(fnlen + 1)) == NULL)
err(1, "malloc function name");
}
deref_kptr(e->fmt, fmt, fmtlen, "printf format");
fmt[fmtlen] = '\0';
for (unsigned z = 0; z < fmtlen - 1; z++) {
if (fmt[z] == '%' && fmt[z+1] == 's')
fmt[z+1] = 'p';
}
deref_kptr(e->fn, fn, fnlen, "function name");
fn[fnlen] = '\0';
bintime2timeval(&e->bt, &tv);
(void)printf("%06ld.%06ld ", (long int)tv.tv_sec,
(long int)tv.tv_usec);
(void)printf("%s#%" PRId32 "@%" PRId32 ": ",
fn, e->call, e->cpunum);
(void)printf(fmt, e->v[0], e->v[1], e->v[2], e->v[3]);
(void)putchar('\n');
}
i = (i + 1) % histp->n;
} while (i != histp->f);
free(histents);
free(fmt);
free(fn);
}
void
hist_traverse_sysctl(int todo, const char *histname)
{
int error;
int mib[4];
unsigned int i;
size_t len, miblen;
struct sysctlnode query, histnode[32];
miblen = __arraycount(mib);
error = sysctlnametomib("kern.hist", mib, &miblen);
if (error != 0) {
if (errno == ENOENT) {
warnx("kernel history is not compiled into the kernel.");
return;
} else
err(EXIT_FAILURE, "nametomib kern.hist failed");
}
mib[2] = CTL_QUERY;
memset(&query, 0, sizeof(query));
query.sysctl_flags = SYSCTL_VERSION;
len = sizeof(histnode);
error = sysctl(mib, 3, &histnode[0], &len, &query, sizeof(query));
if (error != 0) {
err(1, "query failed");
return;
}
if (len == 0) {
warnx("No active kernel history logs.");
return;
}
len = len / sizeof(histnode[0]);
if (todo & HISTLIST)
(void)printf("Active kernel histories:");
for (i = 0; i < len; i++) {
if (todo & HISTLIST)
(void)printf(" %s", histnode[i].sysctl_name);
else {
if (histname == NULL ||
strcmp(histname, histnode[i].sysctl_name) == 0) {
if (histname == NULL)
(void)printf(
"\nkernel history `%s':\n",
histnode[i].sysctl_name);
mib[2] = histnode[i].sysctl_num;
mib[3] = CTL_EOL;
hist_dodump_sysctl(mib, 4);
}
}
}
if (todo & HISTLIST)
(void)putchar('\n');
else if (mib[2] == CTL_QUERY)
warnx("history %s not found", histname);
}
void
hist_dodump_sysctl(int mib[], unsigned int miblen)
{
struct sysctl_history *hist;
struct timeval tv;
struct sysctl_history_event *e;
size_t histsize;
char *strp;
unsigned i;
char *fmt = NULL, *fn = NULL;
hist = NULL;
histsize = 0;
do {
errno = 0;
if (sysctl(mib, miblen, hist, &histsize, NULL, 0) == 0)
break;
if (errno != ENOMEM)
break;
if ((hist = realloc(hist, histsize)) == NULL)
errx(1, "realloc history buffer");
} while (errno == ENOMEM);
if (errno != 0)
err(1, "sysctl failed");
strp = (char *)(&hist->sh_events[hist->sh_numentries]);
(void)printf("%"PRIu32" entries, next is %"PRIu32"\n",
hist->sh_numentries,
hist->sh_nextfree);
i = hist->sh_nextfree;
do {
e = &hist->sh_events[i];
if (e->she_fmtoffset != 0) {
fmt = &strp[e->she_fmtoffset];
size_t fmtlen = strlen(fmt);
for (unsigned z = 0; z < fmtlen - 1; z++) {
if (fmt[z] == '%' && fmt[z+1] == 's')
fmt[z+1] = 'p';
}
fn = &strp[e->she_funcoffset];
bintime2timeval(&e->she_bintime, &tv);
(void)printf("%06ld.%06ld %s#%"PRIu32"@%"PRIu32": ",
(long int)tv.tv_sec, (long int)tv.tv_usec,
fn, e->she_callnumber, e->she_cpunum);
(void)printf(fmt, e->she_values[0], e->she_values[1],
e->she_values[2], e->she_values[3]);
(void)putchar('\n');
}
i = (i + 1) % hist->sh_numentries;
} while (i != hist->sh_nextfree);
free(hist);
}
static void
usage(void)
{
(void)fprintf(stderr,
"usage: %s [-CefHiLlmstUvW] [-c count] [-h hashname]\n"
"\t\t[-M core] [-N system] [-n diskcount] [-u histname]\n"
"[-w wait] [disks]\n",
getprogname());
exit(1);
}
