X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=pppstats%2Fpppstats.c;h=6367988eb96bf03c588b6228ee0c0fdf115f0fbb;hp=8efe48147cf4313ee845d8ed7de941e86be8d6b1;hb=fd25394d146bb83043189608d30dd0eeb983186d;hpb=0dfedbf777b7012d6de9ed5a8e496c98b536ac5b diff --git a/pppstats/pppstats.c b/pppstats/pppstats.c index 8efe481..6367988 100644 --- a/pppstats/pppstats.c +++ b/pppstats/pppstats.c @@ -1,10 +1,19 @@ /* * print PPP statistics: - * pppstats [-i interval] [-v] [interface] [system] [core] + * pppstats [-a|-d] [-v|-r|-z] [-c count] [-w wait] [interface] * + * -a Show absolute values rather than deltas + * -d Show data rate (kB/s) rather than bytes + * -v Show more stats for VJ TCP header compression + * -r Show compression ratio + * -z Show compression statistics instead of default display + * + * History: + * perkins@cps.msu.edu: Added compression statistics and alternate + * display. 11/94 * Brad Parker (brad@cayman.com) 6/92 * - * from the original "slstats" by Van Jaconson + * from the original "slstats" by Van Jacobson * * Copyright (c) 1989 Regents of the University of California. * All rights reserved. @@ -20,358 +29,529 @@ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: - * - Initial distribution. */ +#ifndef __STDC__ +#define const +#endif + #ifndef lint -static char rcsid[] = "$Id: pppstats.c,v 1.4 1994/06/08 00:38:49 paulus Exp $"; +static const char rcsid[] = "$Id: pppstats.c,v 1.29 2002/10/27 12:56:26 fcusack Exp $"; #endif +#include +#include +#include +#include #include #include -#include -#include #include +#include +#include #include -#include #include -#include -#include -#include -#include -#include -#include -#include - -#define VJC 1 -#include +#include #ifndef STREAMS -#include +#if defined(__linux__) && defined(__powerpc__) \ + && (__GLIBC__ == 2 && __GLIBC_MINOR__ == 0) +/* kludge alert! */ +#undef __GLIBC__ #endif - -#ifdef STREAMS -#define PPP_STATS 1 /* should be defined iff it is in ppp_if.c */ -#include -#include +#include /* *BSD, Linux, NeXT, Ultrix etc. */ +#ifndef __linux__ +#include +#include +#include +#else +/* Linux */ +#if __GLIBC__ >= 2 +#include /* glibc 2 conflicts with linux/types.h */ +#include +#else +#include +#include #endif - -#ifdef BSD4_4 -#define KVMLIB +#include +#include +#endif /* __linux__ */ + +#else /* STREAMS */ +#include /* SVR4, Solaris 2, SunOS 4, OSF/1, etc. */ +#include +#include + +#endif /* STREAMS */ + +int vflag, rflag, zflag; /* select type of display */ +int aflag; /* print absolute values, not deltas */ +int dflag; /* print data rates, not bytes */ +int interval, count; +int infinite; +int unit; +int s; /* socket or /dev/ppp file descriptor */ +int signalled; /* set if alarm goes off "early" */ +char *progname; +char *interface; + +#if defined(SUNOS4) || defined(ULTRIX) || defined(NeXT) +extern int optind; +extern char *optarg; #endif -#ifndef KVMLIB +/* + * If PPP_DRV_NAME is not defined, use the legacy "ppp" as the + * device name. + */ +#if !defined(PPP_DRV_NAME) +#define PPP_DRV_NAME "ppp" +#endif /* !defined(PPP_DRV_NAME) */ -#include -#ifdef ultrix -#include -#endif +static void usage __P((void)); +static void catchalarm __P((int)); +static void get_ppp_stats __P((struct ppp_stats *)); +static void get_ppp_cstats __P((struct ppp_comp_stats *)); +static void intpr __P((void)); -struct pte *Sysmap; -int kmem; -char *kmemf = "/dev/kmem"; -extern off_t lseek(); +int main __P((int, char *argv[])); -#else /* KVMLIB */ +static void +usage() +{ + fprintf(stderr, "Usage: %s [-a|-d] [-v|-r|-z] [-c count] [-w wait] [interface]\n", + progname); + exit(1); +} -char *kmemf; +/* + * Called if an interval expires before intpr has completed a loop. + * Sets a flag to not wait for the alarm. + */ +static void +catchalarm(arg) + int arg; +{ + signalled = 1; +} -#ifdef sun -#include -kvm_t *kd; -#define KDARG kd, -#else /* sun */ -#define KDARG -#endif /* sun */ +#ifndef STREAMS +static void +get_ppp_stats(curp) + struct ppp_stats *curp; +{ + struct ifpppstatsreq req; -#endif /* KVMLIB */ + memset (&req, 0, sizeof (req)); -#ifdef STREAMS -struct nlist nl[] = { -#define N_SOFTC 0 - { "_pii" }, - "", -}; -#else -struct nlist nl[] = { -#define N_SOFTC 0 - { "_ppp_softc" }, - "", -}; +#ifdef __linux__ + req.stats_ptr = (caddr_t) &req.stats; +#undef ifr_name +#define ifr_name ifr__name #endif -#ifndef BSD4_4 -char *system = "/vmunix"; -#else -#include -char *system = _PATH_UNIX; -#endif + strncpy(req.ifr_name, interface, sizeof(req.ifr_name)); + if (ioctl(s, SIOCGPPPSTATS, &req) < 0) { + fprintf(stderr, "%s: ", progname); + if (errno == ENOTTY) + fprintf(stderr, "kernel support missing\n"); + else + perror("couldn't get PPP statistics"); + exit(1); + } + *curp = req.stats; +} -int kflag; -int vflag; -unsigned interval = 5; -int unit; +static void +get_ppp_cstats(csp) + struct ppp_comp_stats *csp; +{ + struct ifpppcstatsreq creq; -extern char *malloc(); + memset (&creq, 0, sizeof (creq)); -main(argc, argv) - int argc; - char *argv[]; -{ - --argc; ++argv; - while (argc > 0) { - if (strcmp(argv[0], "-v") == 0) { - ++vflag; - ++argv, --argc; - continue; - } - if (strcmp(argv[0], "-i") == 0 && argv[1] && - isdigit(argv[1][0])) { - interval = atoi(argv[1]); - if (interval <= 0) - usage(); - ++argv, --argc; - ++argv, --argc; - continue; - } - if (isdigit(argv[0][0])) { - unit = atoi(argv[0]); - if (unit < 0) - usage(); - ++argv, --argc; - continue; - } - if (kflag) - usage(); - - system = *argv; - ++argv, --argc; - if (argc > 0) { - kmemf = *argv++; - --argc; - kflag++; - } - } -#ifndef KVMLIB - if (nlist(system, nl) < 0 || nl[0].n_type == 0) { - fprintf(stderr, "%s: no namelist\n", system); - exit(1); - } - kmem = open(kmemf, O_RDONLY); - if (kmem < 0) { - perror(kmemf); - exit(1); - } -#ifndef ultrix - if (kflag) { - off_t off; - - Sysmap = (struct pte *) - malloc((u_int)(nl[N_SYSSIZE].n_value * sizeof(struct pte))); - if (!Sysmap) { - fputs("netstat: can't get memory for Sysmap.\n", stderr); - exit(1); - } - off = nl[N_SYSMAP].n_value & ~KERNBASE; - (void)lseek(kmem, off, L_SET); - (void)read(kmem, (char *)Sysmap, - (int)(nl[N_SYSSIZE].n_value * sizeof(struct pte))); - } -#endif -#else -#ifdef sun - /* SunOS */ - if ((kd = kvm_open(system, kmemf, (char *)0, O_RDONLY, NULL)) == NULL) { - perror("kvm_open"); - exit(1); - } -#else - /* BSD4.3+ */ - if (kvm_openfiles(system, kmemf, (char *)0) == -1) { - fprintf(stderr, "kvm_openfiles: %s", kvm_geterr()); - exit(1); - } +#ifdef __linux__ + creq.stats_ptr = (caddr_t) &creq.stats; +#undef ifr_name +#define ifr_name ifr__name #endif - if (kvm_nlist(KDARG nl)) { - fprintf(stderr, "pppstats: can't find symbols in nlist\n"); + strncpy(creq.ifr_name, interface, sizeof(creq.ifr_name)); + if (ioctl(s, SIOCGPPPCSTATS, &creq) < 0) { + fprintf(stderr, "%s: ", progname); + if (errno == ENOTTY) { + fprintf(stderr, "no kernel compression support\n"); + if (zflag) + exit(1); + rflag = 0; + } else { + perror("couldn't get PPP compression stats"); exit(1); } + } + +#ifdef __linux__ + if (creq.stats.c.bytes_out == 0) { + creq.stats.c.bytes_out = creq.stats.c.comp_bytes + creq.stats.c.inc_bytes; + creq.stats.c.in_count = creq.stats.c.unc_bytes; + } + if (creq.stats.c.bytes_out == 0) + creq.stats.c.ratio = 0.0; + else + creq.stats.c.ratio = 256.0 * creq.stats.c.in_count / + creq.stats.c.bytes_out; + + if (creq.stats.d.bytes_out == 0) { + creq.stats.d.bytes_out = creq.stats.d.comp_bytes + creq.stats.d.inc_bytes; + creq.stats.d.in_count = creq.stats.d.unc_bytes; + } + if (creq.stats.d.bytes_out == 0) + creq.stats.d.ratio = 0.0; + else + creq.stats.d.ratio = 256.0 * creq.stats.d.in_count / + creq.stats.d.bytes_out; #endif - intpr(); - exit(0); + + *csp = creq.stats; } -#ifndef KVMLIB -/* - * Seek into the kernel for a value. - */ -off_t -klseek(fd, base, off) - int fd, off; - off_t base; +#else /* STREAMS */ + +int +strioctl(fd, cmd, ptr, ilen, olen) + int fd, cmd, ilen, olen; + char *ptr; { - if (kflag) { -#ifdef ultrix - base = K0_TO_PHYS(base); -#else - /* get kernel pte */ - base &= ~KERNBASE; - base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET); -#endif - } - return (lseek(fd, base, off)); + struct strioctl str; + + str.ic_cmd = cmd; + str.ic_timout = 0; + str.ic_len = ilen; + str.ic_dp = ptr; + if (ioctl(fd, I_STR, &str) == -1) + return -1; + if (str.ic_len != olen) + fprintf(stderr, "strioctl: expected %d bytes, got %d for cmd %x\n", + olen, str.ic_len, cmd); + return 0; } -#endif -usage() +static void +get_ppp_stats(curp) + struct ppp_stats *curp; { - fprintf(stderr,"usage: pppstats [-i interval] [-v] [unit] [system] [core]\n"); + if (strioctl(s, PPPIO_GETSTAT, curp, 0, sizeof(*curp)) < 0) { + fprintf(stderr, "%s: ", progname); + if (errno == EINVAL) + fprintf(stderr, "kernel support missing\n"); + else + perror("couldn't get PPP statistics"); exit(1); + } } -u_char signalled; /* set if alarm goes off "early" */ +static void +get_ppp_cstats(csp) + struct ppp_comp_stats *csp; +{ + if (strioctl(s, PPPIO_GETCSTAT, csp, 0, sizeof(*csp)) < 0) { + fprintf(stderr, "%s: ", progname); + if (errno == ENOTTY) { + fprintf(stderr, "no kernel compression support\n"); + if (zflag) + exit(1); + rflag = 0; + } else { + perror("couldn't get PPP compression statistics"); + exit(1); + } + } +} -#define V(offset) ((line % 20)? sc->offset - osc->offset : sc->offset) +#endif /* STREAMS */ -#ifdef STREAMS -#define STRUCT struct ppp_if_info -#define COMP pii_sc_comp -#define STATS pii_ifnet -#else -#define STRUCT struct ppp_softc -#define COMP sc_comp -#define STATS sc_if -#endif +#define MAX0(a) ((int)(a) > 0? (a): 0) +#define V(offset) MAX0(cur.offset - old.offset) +#define W(offset) MAX0(ccs.offset - ocs.offset) + +#define RATIO(c, i, u) ((c) == 0? 1.0: (u) / ((double)(c) + (i))) +#define CRATE(x) RATIO(W(x.comp_bytes), W(x.inc_bytes), W(x.unc_bytes)) + +#define KBPS(n) ((n) / (interval * 1000.0)) /* * Print a running summary of interface statistics. * Repeat display every interval seconds, showing statistics * collected over that interval. Assumes that interval is non-zero. - * First line printed at top of screen is always cumulative. + * First line printed is cumulative. */ +static void intpr() { - register int line = 0; - int oldmask; -#ifdef __STDC__ - void catchalarm(int); -#else - void catchalarm(); -#endif - - STRUCT *sc, *osc; - - nl[N_SOFTC].n_value += unit * sizeof(STRUCT); - sc = (STRUCT *)malloc(sizeof(STRUCT)); - osc = (STRUCT *)malloc(sizeof(STRUCT)); - - bzero((char *)osc, sizeof(STRUCT)); + register int line = 0; + sigset_t oldmask, mask; + char *bunit; + int ratef = 0; + struct ppp_stats cur, old; + struct ppp_comp_stats ccs, ocs; + + memset(&old, 0, sizeof(old)); + memset(&ocs, 0, sizeof(ocs)); + + while (1) { + get_ppp_stats(&cur); + if (zflag || rflag) + get_ppp_cstats(&ccs); + + (void)signal(SIGALRM, catchalarm); + signalled = 0; + (void)alarm(interval); + + if ((line % 20) == 0) { + if (zflag) { + printf("IN: COMPRESSED INCOMPRESSIBLE COMP | "); + printf("OUT: COMPRESSED INCOMPRESSIBLE COMP\n"); + bunit = dflag? "KB/S": "BYTE"; + printf(" %s PACK %s PACK RATIO | ", bunit, bunit); + printf(" %s PACK %s PACK RATIO", bunit, bunit); + } else { + printf("%8.8s %6.6s %6.6s", + "IN", "PACK", "VJCOMP"); + + if (!rflag) + printf(" %6.6s %6.6s", "VJUNC", "VJERR"); + if (vflag) + printf(" %6.6s %6.6s", "VJTOSS", "NON-VJ"); + if (rflag) + printf(" %6.6s %6.6s", "RATIO", "UBYTE"); + printf(" | %8.8s %6.6s %6.6s", + "OUT", "PACK", "VJCOMP"); + + if (!rflag) + printf(" %6.6s %6.6s", "VJUNC", "NON-VJ"); + if (vflag) + printf(" %6.6s %6.6s", "VJSRCH", "VJMISS"); + if (rflag) + printf(" %6.6s %6.6s", "RATIO", "UBYTE"); + } + putchar('\n'); + } - while (1) { -#ifndef KVMLIB - if (klseek(kmem, (off_t)nl[N_SOFTC].n_value, 0) == -1) { - perror("kmem seek"); - exit(1); + if (zflag) { + if (ratef) { + printf("%8.3f %6u %8.3f %6u %6.2f", + KBPS(W(d.comp_bytes)), + W(d.comp_packets), + KBPS(W(d.inc_bytes)), + W(d.inc_packets), + ccs.d.ratio / 256.0); + printf(" | %8.3f %6u %8.3f %6u %6.2f", + KBPS(W(c.comp_bytes)), + W(c.comp_packets), + KBPS(W(c.inc_bytes)), + W(c.inc_packets), + ccs.c.ratio / 256.0); + } else { + printf("%8u %6u %8u %6u %6.2f", + W(d.comp_bytes), + W(d.comp_packets), + W(d.inc_bytes), + W(d.inc_packets), + ccs.d.ratio / 256.0); + printf(" | %8u %6u %8u %6u %6.2f", + W(c.comp_bytes), + W(c.comp_packets), + W(c.inc_bytes), + W(c.inc_packets), + ccs.c.ratio / 256.0); } - if (read(kmem, (char *)sc, sizeof(STRUCT)) <= 0) { - perror("kmem read"); - exit(1); + + } else { + if (ratef) + printf("%8.3f", KBPS(V(p.ppp_ibytes))); + else + printf("%8u", V(p.ppp_ibytes)); + printf(" %6u %6u", + V(p.ppp_ipackets), + V(vj.vjs_compressedin)); + if (!rflag) + printf(" %6u %6u", + V(vj.vjs_uncompressedin), + V(vj.vjs_errorin)); + if (vflag) + printf(" %6u %6u", + V(vj.vjs_tossed), + V(p.ppp_ipackets) - V(vj.vjs_compressedin) + - V(vj.vjs_uncompressedin) - V(vj.vjs_errorin)); + if (rflag) { + printf(" %6.2f ", CRATE(d)); + if (ratef) + printf("%6.2f", KBPS(W(d.unc_bytes))); + else + printf("%6u", W(d.unc_bytes)); } -#else - if (kvm_read(KDARG nl[N_SOFTC].n_value, sc, - sizeof(STRUCT)) != sizeof(STRUCT)) { - perror("kvm_read"); - exit(1); + if (ratef) + printf(" | %8.3f", KBPS(V(p.ppp_obytes))); + else + printf(" | %8u", V(p.ppp_obytes)); + printf(" %6u %6u", + V(p.ppp_opackets), + V(vj.vjs_compressed)); + if (!rflag) + printf(" %6u %6u", + V(vj.vjs_packets) - V(vj.vjs_compressed), + V(p.ppp_opackets) - V(vj.vjs_packets)); + if (vflag) + printf(" %6u %6u", + V(vj.vjs_searches), + V(vj.vjs_misses)); + if (rflag) { + printf(" %6.2f ", CRATE(c)); + if (ratef) + printf("%6.2f", KBPS(W(c.unc_bytes))); + else + printf("%6u", W(c.unc_bytes)); } -#endif - (void)signal(SIGALRM, catchalarm); - signalled = 0; - (void)alarm(interval); + } - if ((line % 20) == 0) { - printf("%6.6s %6.6s %6.6s %6.6s %6.6s", - "in", "pack", "comp", "uncomp", "err"); - if (vflag) - printf(" %6.6s %6.6s", "toss", "ip"); - printf(" | %6.6s %6.6s %6.6s %6.6s %6.6s", - "out", "pack", "comp", "uncomp", "ip"); - if (vflag) - printf(" %6.6s %6.6s", "search", "miss"); - putchar('\n'); - } + putchar('\n'); + fflush(stdout); + line++; - printf("%6d %6d %6d %6d %6d", -#ifdef BSD4_4 - V(STATS.if_ibytes), -#else -#ifndef STREAMS - V(sc_bytesrcvd), -#else -#ifdef PPP_STATS - V(pii_stats.ppp_ibytes), -#else - 0, -#endif -#endif + count--; + if (!infinite && !count) + break; + + sigemptyset(&mask); + sigaddset(&mask, SIGALRM); + sigprocmask(SIG_BLOCK, &mask, &oldmask); + if (!signalled) { + sigemptyset(&mask); + sigsuspend(&mask); + } + sigprocmask(SIG_SETMASK, &oldmask, NULL); + signalled = 0; + (void)alarm(interval); + + if (!aflag) { + old = cur; + ocs = ccs; + ratef = dflag; + } + } +} + +int +main(argc, argv) + int argc; + char *argv[]; +{ + int c; +#ifdef STREAMS + char *dev; #endif - V(STATS.if_ipackets), - V(COMP.sls_compressedin), - V(COMP.sls_uncompressedin), - V(COMP.sls_errorin)); - if (vflag) - printf(" %6d %6d", - V(COMP.sls_tossed), - V(STATS.if_ipackets) - V(COMP.sls_compressedin) - - V(COMP.sls_uncompressedin) - V(COMP.sls_errorin)); - printf(" | %6d %6d %6d %6d %6d", -#ifdef BSD4_4 - V(STATS.if_obytes), -#else + + interface = PPP_DRV_NAME "0"; + if ((progname = strrchr(argv[0], '/')) == NULL) + progname = argv[0]; + else + ++progname; + + while ((c = getopt(argc, argv, "advrzc:w:")) != -1) { + switch (c) { + case 'a': + ++aflag; + break; + case 'd': + ++dflag; + break; + case 'v': + ++vflag; + break; + case 'r': + ++rflag; + break; + case 'z': + ++zflag; + break; + case 'c': + count = atoi(optarg); + if (count <= 0) + usage(); + break; + case 'w': + interval = atoi(optarg); + if (interval <= 0) + usage(); + break; + default: + usage(); + } + } + argc -= optind; + argv += optind; + + if (!interval && count) + interval = 5; + if (interval && !count) + infinite = 1; + if (!interval && !count) + count = 1; + if (aflag) + dflag = 0; + + if (argc > 1) + usage(); + if (argc > 0) + interface = argv[0]; + + if (sscanf(interface, PPP_DRV_NAME "%d", &unit) != 1) { + fprintf(stderr, "%s: invalid interface '%s' specified\n", + progname, interface); + } + #ifndef STREAMS - V(sc_bytessent), -#else -#ifdef PPP_STATS - V(pii_stats.ppp_obytes), -#else - 0, -#endif -#endif -#endif - V(STATS.if_opackets), - V(COMP.sls_compressed), - V(COMP.sls_packets) - V(COMP.sls_compressed), - V(STATS.if_opackets) - V(COMP.sls_packets)); - if (vflag) - printf(" %6d %6d", - V(COMP.sls_searches), - V(COMP.sls_misses)); + { + struct ifreq ifr; - putchar('\n'); - fflush(stdout); - line++; + s = socket(AF_INET, SOCK_DGRAM, 0); + if (s < 0) { + fprintf(stderr, "%s: ", progname); + perror("couldn't create IP socket"); + exit(1); + } - oldmask = sigblock(sigmask(SIGALRM)); - if (! signalled) { - sigpause(0); - } - sigsetmask(oldmask); - signalled = 0; - (void)alarm(interval); - bcopy((char *)sc, (char *)osc, sizeof(STRUCT)); +#ifdef __linux__ +#undef ifr_name +#define ifr_name ifr_ifrn.ifrn_name +#endif + strncpy(ifr.ifr_name, interface, sizeof(ifr.ifr_name)); + if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) { + fprintf(stderr, "%s: nonexistent interface '%s' specified\n", + progname, interface); + exit(1); } -} + } -/* - * Called if an interval expires before sidewaysintpr has completed a loop. - * Sets a flag to not wait for the alarm. - */ -void catchalarm(arg) -int arg; -{ - signalled = 1; +#else /* STREAMS */ +#ifdef __osf__ + dev = "/dev/streams/ppp"; +#else + dev = "/dev/" PPP_DRV_NAME; +#endif + if ((s = open(dev, O_RDONLY)) < 0) { + fprintf(stderr, "%s: couldn't open ", progname); + perror(dev); + exit(1); + } + if (strioctl(s, PPPIO_ATTACH, &unit, sizeof(int), 0) < 0) { + fprintf(stderr, "%s: ppp%d is not available\n", progname, unit); + exit(1); + } + +#endif /* STREAMS */ + + intpr(); + exit(0); }