FreeBSD-5.3/usr.sbin/pstat/pstat.c
/*-
* Copyright (c) 1980, 1991, 1993, 1994
* The Regents of the University of California. All rights reserved.
* Copyright (c) 2002 Networks Associates Technologies, Inc.
* All rights reserved.
*
* Portions of this software were developed for the FreeBSD Project by
* ThinkSec AS and NAI Labs, the Security Research Division of Network
* Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035
* ("CBOSS"), as part of the DARPA CHATS research program.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#if 0
#ifndef lint
static const char copyright[] =
"@(#) Copyright (c) 1980, 1991, 1993, 1994\n\
The Regents of the University of California. All rights reserved.\n";
#endif /* not lint */
#ifndef lint
static char sccsid[] = "@(#)pstat.c 8.16 (Berkeley) 5/9/95";
#endif /* not lint */
#endif
#include <sys/cdefs.h>
__FBSDID("$FreeBSD: src/usr.sbin/pstat/pstat.c,v 1.91 2004/08/07 04:27:52 imp Exp $");
#include <sys/param.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/stdint.h>
#include <sys/ioctl.h>
#include <sys/ioctl_compat.h> /* XXX NTTYDISC is too well hidden */
#include <sys/tty.h>
#include <sys/blist.h>
#include <sys/user.h>
#include <sys/sysctl.h>
#include <err.h>
#include <fcntl.h>
#include <kvm.h>
#include <limits.h>
#include <nlist.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
enum {
NL_CONSTTY,
NL_MAXFILES,
NL_NFILES,
NL_TTY_LIST
};
static struct nlist nl[] = {
{ "_constty", 0 },
{ "_maxfiles", 0 },
{ "_nfiles", 0 },
{ "_tty_list", 0 },
{ "" }
};
static int usenumflag;
static int totalflag;
static int swapflag;
static char *nlistf;
static char *memf;
static kvm_t *kd;
static char *usagestr;
static void filemode(void);
static int getfiles(char **, size_t *);
static void swapmode(void);
static void ttymode(void);
static void ttyprt(struct xtty *);
static void usage(void);
int
main(int argc, char *argv[])
{
int ch, i, quit, ret;
int fileflag, ttyflag;
char buf[_POSIX2_LINE_MAX],*opts;
fileflag = swapflag = ttyflag = 0;
/* We will behave like good old swapinfo if thus invoked */
opts = strrchr(argv[0], '/');
if (opts)
opts++;
else
opts = argv[0];
if (!strcmp(opts, "swapinfo")) {
swapflag = 1;
opts = "kM:N:";
usagestr = "swapinfo [-k] [-M core [-N system]]";
} else {
opts = "TM:N:fknst";
usagestr = "pstat [-Tfknst] [-M core [-N system]]";
}
while ((ch = getopt(argc, argv, opts)) != -1)
switch (ch) {
case 'f':
fileflag = 1;
break;
case 'k':
putenv("BLOCKSIZE=1K");
break;
case 'M':
memf = optarg;
break;
case 'N':
nlistf = optarg;
break;
case 'n':
usenumflag = 1;
break;
case 's':
++swapflag;
break;
case 'T':
totalflag = 1;
break;
case 't':
ttyflag = 1;
break;
default:
usage();
}
argc -= optind;
argv += optind;
if (memf != NULL) {
kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, buf);
if (kd == NULL)
errx(1, "kvm_openfiles: %s", buf);
if ((ret = kvm_nlist(kd, nl)) != 0) {
if (ret == -1)
errx(1, "kvm_nlist: %s", kvm_geterr(kd));
quit = 0;
for (i = 0; nl[i].n_name[0] != '\0'; ++i)
if (nl[i].n_value == 0) {
quit = 1;
warnx("undefined symbol: %s",
nl[i].n_name);
}
if (quit)
exit(1);
}
}
if (!(fileflag | ttyflag | swapflag | totalflag))
usage();
if (fileflag || totalflag)
filemode();
if (ttyflag)
ttymode();
if (swapflag || totalflag)
swapmode();
exit (0);
}
static void
usage(void)
{
fprintf(stderr, "usage: %s\n", usagestr);
exit (1);
}
static const char fhdr32[] =
" LOC TYPE FLG CNT MSG DATA OFFSET\n";
/* c0000000 ------ RWAI 123 123 c0000000 1000000000000000 */
static const char fhdr64[] =
" LOC TYPE FLG CNT MSG DATA OFFSET\n";
/* c000000000000000 ------ RWAI 123 123 c000000000000000 1000000000000000 */
static const char hdr[] =
" LINE RAW CAN OUT IHIWT ILOWT OHWT LWT COL STATE SESS PGID DISC\n";
static void
ttymode_kvm(void)
{
TAILQ_HEAD(, tty) tl;
struct tty *tp, tty;
struct xtty xt;
(void)printf("%s", hdr);
bzero(&xt, sizeof xt);
xt.xt_size = sizeof xt;
if (kvm_read(kd, nl[NL_TTY_LIST].n_value, &tl, sizeof tl) != sizeof tl)
errx(1, "kvm_read(): %s", kvm_geterr(kd));
tp = TAILQ_FIRST(&tl);
while (tp != NULL) {
if (kvm_read(kd, (u_long)tp, &tty, sizeof tty) != sizeof tty)
errx(1, "kvm_read(): %s", kvm_geterr(kd));
xt.xt_rawcc = tty.t_rawq.c_cc;
xt.xt_cancc = tty.t_canq.c_cc;
xt.xt_outcc = tty.t_outq.c_cc;
#define XT_COPY(field) xt.xt_##field = tty.t_##field
XT_COPY(line);
XT_COPY(state);
XT_COPY(column);
XT_COPY(ihiwat);
XT_COPY(ilowat);
XT_COPY(ohiwat);
XT_COPY(olowat);
#undef XT_COPY
ttyprt(&xt);
tp = TAILQ_NEXT(tp, t_list);
}
}
static void
ttymode_sysctl(void)
{
struct xtty *xt, *end;
void *xttys;
size_t len;
(void)printf("%s", hdr);
if ((xttys = malloc(len = sizeof *xt)) == NULL)
err(1, "malloc()");
while (sysctlbyname("kern.ttys", xttys, &len, 0, 0) == -1) {
if (errno != ENOMEM)
err(1, "sysctlbyname()");
len *= 2;
if ((xttys = realloc(xttys, len)) == NULL)
err(1, "realloc()");
}
if (len > 0) {
end = (struct xtty *)((char *)xttys + len);
for (xt = xttys; xt < end; xt++)
ttyprt(xt);
}
}
static void
ttymode(void)
{
if (kd != NULL)
ttymode_kvm();
else
ttymode_sysctl();
}
static struct {
int flag;
char val;
} ttystates[] = {
#ifdef TS_WOPEN
{ TS_WOPEN, 'W'},
#endif
{ TS_ISOPEN, 'O'},
{ TS_CARR_ON, 'C'},
#ifdef TS_CONNECTED
{ TS_CONNECTED, 'c'},
#endif
{ TS_TIMEOUT, 'T'},
{ TS_FLUSH, 'F'},
{ TS_BUSY, 'B'},
#ifdef TS_ASLEEP
{ TS_ASLEEP, 'A'},
#endif
#ifdef TS_SO_OLOWAT
{ TS_SO_OLOWAT, 'A'},
#endif
#ifdef TS_SO_OCOMPLETE
{ TS_SO_OCOMPLETE, 'a'},
#endif
{ TS_XCLUDE, 'X'},
{ TS_TTSTOP, 'S'},
#ifdef TS_CAR_OFLOW
{ TS_CAR_OFLOW, 'm'},
#endif
#ifdef TS_CTS_OFLOW
{ TS_CTS_OFLOW, 'o'},
#endif
#ifdef TS_DSR_OFLOW
{ TS_DSR_OFLOW, 'd'},
#endif
{ TS_TBLOCK, 'K'},
{ TS_ASYNC, 'Y'},
{ TS_BKSL, 'D'},
{ TS_ERASE, 'E'},
{ TS_LNCH, 'L'},
{ TS_TYPEN, 'P'},
{ TS_CNTTB, 'N'},
#ifdef TS_CAN_BYPASS_L_RINT
{ TS_CAN_BYPASS_L_RINT, 'l'},
#endif
#ifdef TS_SNOOP
{ TS_SNOOP, 's'},
#endif
#ifdef TS_ZOMBIE
{ TS_ZOMBIE, 'Z'},
#endif
{ 0, '\0'},
};
static void
ttyprt(struct xtty *xt)
{
int i, j;
pid_t pgid;
char *name, state[20];
if (xt->xt_size != sizeof *xt)
errx(1, "struct xtty size mismatch");
if (usenumflag || xt->xt_dev == 0 ||
(name = devname(xt->xt_dev, S_IFCHR)) == NULL)
printf(" %2d,%-2d", major(xt->xt_dev), minor(xt->xt_dev));
else
(void)printf("%7s ", name);
(void)printf("%2ld %3ld ", xt->xt_rawcc, xt->xt_cancc);
(void)printf("%3ld %5d %5d %4d %3d %7d ", xt->xt_outcc,
xt->xt_ihiwat, xt->xt_ilowat, xt->xt_ohiwat, xt->xt_olowat,
xt->xt_column);
for (i = j = 0; ttystates[i].flag; i++)
if (xt->xt_state & ttystates[i].flag)
state[j++] = ttystates[i].val;
if (j == 0)
state[j++] = '-';
state[j] = '\0';
(void)printf("%-6s %8d", state, xt->xt_sid);
pgid = 0;
(void)printf("%6d ", xt->xt_pgid);
switch (xt->xt_line) {
case TTYDISC:
(void)printf("term\n");
break;
case NTTYDISC:
(void)printf("ntty\n");
break;
case SLIPDISC:
(void)printf("slip\n");
break;
case PPPDISC:
(void)printf("ppp\n");
break;
default:
(void)printf("%d\n", xt->xt_line);
break;
}
}
static void
filemode(void)
{
struct xfile *fp;
char *buf, flagbuf[16], *fbp;
int maxf, openf;
size_t len;
static char *dtypes[] = { "???", "inode", "socket", "pipe",
"fifo", "kqueue", "crypto" };
int i;
int wid;
if (kd != NULL) {
if (kvm_read(kd, nl[NL_MAXFILES].n_value,
&maxf, sizeof maxf) != sizeof maxf ||
kvm_read(kd, nl[NL_NFILES].n_value,
&openf, sizeof openf) != sizeof openf)
errx(1, "kvm_read(): %s", kvm_geterr(kd));
} else {
len = sizeof(int);
if (sysctlbyname("kern.maxfiles", &maxf, &len, 0, 0) == -1 ||
sysctlbyname("kern.openfiles", &openf, &len, 0, 0) == -1)
err(1, "sysctlbyname()");
}
if (totalflag) {
(void)printf("%3d/%3d files\n", openf, maxf);
return;
}
if (getfiles(&buf, &len) == -1)
return;
openf = len / sizeof *fp;
(void)printf("%d/%d open files\n", openf, maxf);
printf(sizeof(uintptr_t) == 4 ? fhdr32 : fhdr64);
wid = (int)sizeof(uintptr_t) * 2;
for (fp = (struct xfile *)buf, i = 0; i < openf; ++fp, ++i) {
if ((size_t)fp->xf_type >= sizeof(dtypes) / sizeof(dtypes[0]))
continue;
(void)printf("%*jx", wid, (uintmax_t)(uintptr_t)fp->xf_file);
(void)printf(" %-6.6s", dtypes[fp->xf_type]);
fbp = flagbuf;
if (fp->xf_flag & FREAD)
*fbp++ = 'R';
if (fp->xf_flag & FWRITE)
*fbp++ = 'W';
if (fp->xf_flag & FAPPEND)
*fbp++ = 'A';
if (fp->xf_flag & FASYNC)
*fbp++ = 'I';
*fbp = '\0';
(void)printf(" %4s %3d", flagbuf, fp->xf_count);
(void)printf(" %3d", fp->xf_msgcount);
(void)printf(" %*jx", wid, (uintmax_t)(uintptr_t)fp->xf_data);
(void)printf(" %*jx\n", (int)sizeof(fp->xf_offset) * 2,
(uintmax_t)fp->xf_offset);
}
free(buf);
}
static int
getfiles(char **abuf, size_t *alen)
{
size_t len;
int mib[2];
char *buf;
/*
* XXX
* Add emulation of KINFO_FILE here.
*/
if (kd != NULL)
errx(1, "files on dead kernel, not implemented");
mib[0] = CTL_KERN;
mib[1] = KERN_FILE;
if (sysctl(mib, 2, NULL, &len, NULL, 0) == -1) {
warn("sysctl: KERN_FILE");
return (-1);
}
if ((buf = malloc(len)) == NULL)
errx(1, "malloc");
if (sysctl(mib, 2, buf, &len, NULL, 0) == -1) {
warn("sysctl: KERN_FILE");
return (-1);
}
*abuf = buf;
*alen = len;
return (0);
}
/*
* swapmode is based on a program called swapinfo written
* by Kevin Lahey <kml@rokkaku.atl.ga.us>.
*/
#define CONVERT(v) ((int)((intmax_t)(v) * pagesize / blocksize))
static struct kvm_swap swtot;
static int nswdev;
static void
print_swap_header(void)
{
int hlen;
long blocksize;
const char *header;
header = getbsize(&hlen, &blocksize);
if (totalflag == 0)
(void)printf("%-15s %*s %8s %8s %8s\n",
"Device", hlen, header,
"Used", "Avail", "Capacity");
}
static void
print_swap(struct kvm_swap *ksw)
{
int hlen, pagesize;
long blocksize;
pagesize = getpagesize();
getbsize(&hlen, &blocksize);
swtot.ksw_total += ksw->ksw_total;
swtot.ksw_used += ksw->ksw_used;
++nswdev;
if (totalflag == 0) {
(void)printf("%-15s %*d ",
ksw->ksw_devname, hlen,
CONVERT(ksw->ksw_total));
(void)printf("%8d %8d %5.0f%%\n",
CONVERT(ksw->ksw_used),
CONVERT(ksw->ksw_total - ksw->ksw_used),
(ksw->ksw_used * 100.0) / ksw->ksw_total);
}
}
static void
print_swap_total(void)
{
int hlen, pagesize;
long blocksize;
pagesize = getpagesize();
getbsize(&hlen, &blocksize);
if (totalflag) {
blocksize = 1024 * 1024;
(void)printf("%dM/%dM swap space\n",
CONVERT(swtot.ksw_used), CONVERT(swtot.ksw_total));
} else if (nswdev > 1) {
(void)printf("%-15s %*d %8d %8d %5.0f%%\n",
"Total", hlen, CONVERT(swtot.ksw_total),
CONVERT(swtot.ksw_used),
CONVERT(swtot.ksw_total - swtot.ksw_used),
(swtot.ksw_used * 100.0) / swtot.ksw_total);
}
}
static void
swapmode_kvm(void)
{
struct kvm_swap kswap[16];
int i, n;
n = kvm_getswapinfo(kd, kswap, sizeof kswap / sizeof kswap[0],
SWIF_DEV_PREFIX);
print_swap_header();
for (i = 0; i < n; ++i)
print_swap(&kswap[i]);
print_swap_total();
}
static void
swapmode_sysctl(void)
{
struct kvm_swap ksw;
struct xswdev xsw;
size_t mibsize, size;
int mib[16], n;
print_swap_header();
mibsize = sizeof mib / sizeof mib[0];
if (sysctlnametomib("vm.swap_info", mib, &mibsize) == -1)
err(1, "sysctlnametomib()");
for (n = 0; ; ++n) {
mib[mibsize] = n;
size = sizeof xsw;
if (sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1)
break;
if (xsw.xsw_version != XSWDEV_VERSION)
errx(1, "xswdev version mismatch");
if (xsw.xsw_dev == NODEV)
snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname,
"<NFSfile>");
else
snprintf(ksw.ksw_devname, sizeof ksw.ksw_devname,
"/dev/%s", devname(xsw.xsw_dev, S_IFCHR));
ksw.ksw_used = xsw.xsw_used;
ksw.ksw_total = xsw.xsw_nblks;
ksw.ksw_flags = xsw.xsw_flags;
print_swap(&ksw);
}
if (errno != ENOENT)
err(1, "sysctl()");
print_swap_total();
}
static void
swapmode(void)
{
if (kd != NULL)
swapmode_kvm();
else
swapmode_sysctl();
}