15a59a8b3Srsb /*
25a59a8b3Srsb * CDDL HEADER START
35a59a8b3Srsb *
45a59a8b3Srsb * The contents of this file are subject to the terms of the
55a59a8b3Srsb * Common Development and Distribution License (the "License").
65a59a8b3Srsb * You may not use this file except in compliance with the License.
75a59a8b3Srsb *
85a59a8b3Srsb * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
95a59a8b3Srsb * or http://www.opensolaris.org/os/licensing.
105a59a8b3Srsb * See the License for the specific language governing permissions
115a59a8b3Srsb * and limitations under the License.
125a59a8b3Srsb *
135a59a8b3Srsb * When distributing Covered Code, include this CDDL HEADER in each
145a59a8b3Srsb * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
155a59a8b3Srsb * If applicable, add the following below this CDDL HEADER, with the
165a59a8b3Srsb * fields enclosed by brackets "[]" replaced with your own identifying
175a59a8b3Srsb * information: Portions Copyright [yyyy] [name of copyright owner]
185a59a8b3Srsb *
195a59a8b3Srsb * CDDL HEADER END
205a59a8b3Srsb */
215a59a8b3Srsb /*
22c242f9a0Schunli zhang - Sun Microsystems - Irvine United States * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
235a59a8b3Srsb * Use is subject to license terms.
2448bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved.
25*0a055120SJason King * Copyright 2017 Jason King
265a59a8b3Srsb */
275a59a8b3Srsb
285a59a8b3Srsb #include <stdio.h>
295a59a8b3Srsb #include <kstat.h>
305a59a8b3Srsb #include <stdlib.h>
315a59a8b3Srsb #include <string.h>
325a59a8b3Srsb #include <strings.h>
335a59a8b3Srsb #include <errno.h>
345a59a8b3Srsb #include <limits.h>
355a59a8b3Srsb #include <sys/types.h>
365a59a8b3Srsb #include <time.h>
375a59a8b3Srsb #include <sys/time.h>
385a59a8b3Srsb #include <sys/uio.h>
395a59a8b3Srsb #include <sys/vnode.h>
405a59a8b3Srsb #include <sys/vfs.h>
415a59a8b3Srsb #include <sys/statvfs.h>
425a59a8b3Srsb #include <sys/fstyp.h>
435a59a8b3Srsb #include <sys/fsid.h>
445a59a8b3Srsb #include <sys/mnttab.h>
45*0a055120SJason King #include <sys/debug.h>
465a59a8b3Srsb #include <values.h>
475a59a8b3Srsb #include <poll.h>
485a59a8b3Srsb #include <ctype.h>
495a59a8b3Srsb #include <libintl.h>
5013c7b6acSrsb #include <locale.h>
5100c76d6fStc #include <signal.h>
52*0a055120SJason King #include <libcmdutils.h>
5300c76d6fStc
5400c76d6fStc #include "statcommon.h"
555a59a8b3Srsb
563a401a6bSrsb /*
573a401a6bSrsb * For now, parsable output is turned off. Once we gather feedback and
583a401a6bSrsb * stablize the output format, we'll turn it back on. This prevents
593a401a6bSrsb * the situation where users build tools which depend on a specific
603a401a6bSrsb * format before we declare the output stable.
613a401a6bSrsb */
623a401a6bSrsb #define PARSABLE_OUTPUT 0
633a401a6bSrsb
643a401a6bSrsb #if PARSABLE_OUTPUT
653a401a6bSrsb #define OPTIONS "FPT:afginv"
663a401a6bSrsb #else
673a401a6bSrsb #define OPTIONS "FT:afginv"
683a401a6bSrsb #endif
695a59a8b3Srsb
705a59a8b3Srsb /* Time stamp values */
715a59a8b3Srsb #define NODATE 0 /* Default: No time stamp */
725a59a8b3Srsb #define DDATE 1 /* Standard date format */
735a59a8b3Srsb #define UDATE 2 /* Internal representation of Unix time */
745a59a8b3Srsb
755a59a8b3Srsb #define RETRY_DELAY 250 /* Timeout for poll() */
763a401a6bSrsb #define HEADERLINES 12 /* Number of lines between display headers */
775a59a8b3Srsb
785a59a8b3Srsb #define LBUFSZ 64 /* Generic size for local buffer */
79*0a055120SJason King CTASSERT(LBUFSZ >= NN_NUMBUF_SZ);
805a59a8b3Srsb
815a59a8b3Srsb #define NENTITY_INIT 1 /* Initial number of entities to allocate */
825a59a8b3Srsb
835a59a8b3Srsb /*
845a59a8b3Srsb * We need to have a mechanism for an old/previous and new/current vopstat
855a59a8b3Srsb * structure. We only need two per entity and we can swap between them.
865a59a8b3Srsb */
875a59a8b3Srsb #define VS_SIZE 2 /* Size of vopstat array */
885a59a8b3Srsb #define CUR_INDEX (vs_i)
895a59a8b3Srsb #define PREV_INDEX ((vs_i == 0) ? 1 : 0) /* Opposite of CUR_INDEX */
905a59a8b3Srsb #define BUMP_INDEX() vs_i = ((vs_i == 0) ? 1 : 0)
915a59a8b3Srsb
925a59a8b3Srsb /*
935a59a8b3Srsb * An "entity" is anything we're collecting statistics on, it could
945a59a8b3Srsb * be a mountpoint or an FS-type.
955a59a8b3Srsb * e_name is the name of the entity (e.g. mount point or FS-type)
965a59a8b3Srsb * e_ksname is the name of the associated kstat
975a59a8b3Srsb * e_vs is an array of vopstats. This is used to keep track of "previous"
985a59a8b3Srsb * and "current" vopstats.
995a59a8b3Srsb */
1005a59a8b3Srsb typedef struct entity {
1015a59a8b3Srsb char *e_name; /* name of entity */
1025a59a8b3Srsb vopstats_t *e_vs; /* Array of vopstats */
1035a59a8b3Srsb ulong_t e_fsid; /* fsid for ENTYPE_MNTPT only */
1045a59a8b3Srsb int e_type; /* type of entity */
1055a59a8b3Srsb char e_ksname[KSTAT_STRLEN]; /* kstat name */
1065a59a8b3Srsb } entity_t;
1075a59a8b3Srsb
1085a59a8b3Srsb /* Types of entities (e_type) */
1095a59a8b3Srsb #define ENTYPE_UNKNOWN 0 /* UNKNOWN must be zero since we calloc() */
1105a59a8b3Srsb #define ENTYPE_FSTYPE 1
1115a59a8b3Srsb #define ENTYPE_MNTPT 2
1125a59a8b3Srsb
11300c76d6fStc char *cmdname; /* name of this command */
11400c76d6fStc int caught_cont = 0; /* have caught a SIGCONT */
1155a59a8b3Srsb
11626fd7700SKrishnendu Sadhukhan - Sun Microsystems static uint_t timestamp_fmt = NODATE; /* print timestamp with stats */
1174944376cSJohn Levon
1185a59a8b3Srsb static int vs_i = 0; /* Index of current vs[] slot */
1195a59a8b3Srsb
1205a59a8b3Srsb static void
usage()1215a59a8b3Srsb usage()
1225a59a8b3Srsb {
1233a401a6bSrsb (void) fprintf(stderr, gettext(
1243a401a6bSrsb "Usage: %s [-a|f|i|n|v] [-T d|u] {-F | {fstype | fspath}...} "
1255a59a8b3Srsb "[interval [count]]\n"), cmdname);
1265a59a8b3Srsb exit(2);
1275a59a8b3Srsb }
1285a59a8b3Srsb
1295a59a8b3Srsb #define RAWVAL(ptr, member) ((ptr)->member.value.ui64)
1305a59a8b3Srsb #define DELTA(member) \
1315a59a8b3Srsb (newvsp->member.value.ui64 - (oldvsp ? oldvsp->member.value.ui64 : 0))
1323a401a6bSrsb
133*0a055120SJason King #define PRINTSTAT(isnice, nicestring, rawstring, rawval, buf) \
1345a59a8b3Srsb (isnice) ? \
135*0a055120SJason King nicenum(rawval, buf, sizeof (buf)), \
136*0a055120SJason King (void) printf((nicestring), (buf)) \
1375a59a8b3Srsb : \
1385a59a8b3Srsb (void) printf((rawstring), (rawval))
1395a59a8b3Srsb
1405a59a8b3Srsb /* Values for display flag */
1415a59a8b3Srsb #define DISP_HEADER 0x1
1425a59a8b3Srsb #define DISP_RAW 0x2
1435a59a8b3Srsb
1445a59a8b3Srsb /*
1455a59a8b3Srsb * The policy for dealing with multiple flags is dealt with here.
1465a59a8b3Srsb * Currently, if we are displaying raw output, then don't allow
1475a59a8b3Srsb * headers to be printed.
1485a59a8b3Srsb */
1495a59a8b3Srsb int
dispflag_policy(int printhdr,int dispflag)1505a59a8b3Srsb dispflag_policy(int printhdr, int dispflag)
1515a59a8b3Srsb {
1525a59a8b3Srsb /* If we're not displaying raw output, then allow headers to print */
1535a59a8b3Srsb if ((dispflag & DISP_RAW) == 0) {
1545a59a8b3Srsb if (printhdr) {
1555a59a8b3Srsb dispflag |= DISP_HEADER;
1565a59a8b3Srsb }
1575a59a8b3Srsb }
1585a59a8b3Srsb
1595a59a8b3Srsb return (dispflag);
1605a59a8b3Srsb }
1615a59a8b3Srsb
1625a59a8b3Srsb static void
dflt_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)1635a59a8b3Srsb dflt_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
1645a59a8b3Srsb {
1655a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
1665a59a8b3Srsb longlong_t nnewfile;
1675a59a8b3Srsb longlong_t nnamerm;
1685a59a8b3Srsb longlong_t nnamechg;
1695a59a8b3Srsb longlong_t nattrret;
1705a59a8b3Srsb longlong_t nattrchg;
1715a59a8b3Srsb longlong_t nlookup;
1725a59a8b3Srsb longlong_t nreaddir;
1735a59a8b3Srsb longlong_t ndataread;
1745a59a8b3Srsb longlong_t ndatawrite;
1755a59a8b3Srsb longlong_t readthruput;
1765a59a8b3Srsb longlong_t writethruput;
1775a59a8b3Srsb char buf[LBUFSZ];
1785a59a8b3Srsb
1795a59a8b3Srsb nnewfile = DELTA(ncreate) + DELTA(nmkdir) + DELTA(nsymlink);
1805a59a8b3Srsb nnamerm = DELTA(nremove) + DELTA(nrmdir);
1815a59a8b3Srsb nnamechg = DELTA(nrename) + DELTA(nlink) + DELTA(nsymlink);
1825a59a8b3Srsb nattrret = DELTA(ngetattr) + DELTA(naccess) +
183f5cd957fSRobert Harris DELTA(ngetsecattr) + DELTA(nfid);
1845a59a8b3Srsb nattrchg = DELTA(nsetattr) + DELTA(nsetsecattr) + DELTA(nspace);
1855a59a8b3Srsb nlookup = DELTA(nlookup);
1865a59a8b3Srsb nreaddir = DELTA(nreaddir);
1875a59a8b3Srsb ndataread = DELTA(nread);
1885a59a8b3Srsb ndatawrite = DELTA(nwrite);
1895a59a8b3Srsb readthruput = DELTA(read_bytes);
1905a59a8b3Srsb writethruput = DELTA(write_bytes);
1915a59a8b3Srsb
1925a59a8b3Srsb if (dispflag & DISP_HEADER) {
193757bea67Srsb (void) printf(
1945a59a8b3Srsb " new name name attr attr lookup rddir read read write write\n"
195757bea67Srsb " file remov chng get set ops ops ops bytes ops bytes\n");
1965a59a8b3Srsb }
1975a59a8b3Srsb
198*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nnewfile, buf);
199*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nnamerm, buf);
200*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nnamechg, buf);
201*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nattrret, buf);
202*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nattrchg, buf);
203*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", nlookup, buf);
204*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", nreaddir, buf);
205*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", ndataread, buf);
206*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", readthruput, buf);
207*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", ndatawrite, buf);
208*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", writethruput, buf);
2095a59a8b3Srsb (void) printf("%s\n", name);
2105a59a8b3Srsb }
2115a59a8b3Srsb
2125a59a8b3Srsb static void
io_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)2135a59a8b3Srsb io_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
2145a59a8b3Srsb {
2155a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
2165a59a8b3Srsb char buf[LBUFSZ];
2175a59a8b3Srsb
2185a59a8b3Srsb if (dispflag & DISP_HEADER) {
219757bea67Srsb (void) printf(
2205a59a8b3Srsb " read read write write rddir rddir rwlock rwulock\n"
221757bea67Srsb " ops bytes ops bytes ops bytes ops ops\n");
2225a59a8b3Srsb }
2235a59a8b3Srsb
224*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nread), buf);
225*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(read_bytes), buf);
2265a59a8b3Srsb
227*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nwrite), buf);
228*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(write_bytes), buf);
2295a59a8b3Srsb
230*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nreaddir), buf);
231*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(readdir_bytes), buf);
2325a59a8b3Srsb
233*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(nrwlock), buf);
234*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nrwunlock), buf);
2355a59a8b3Srsb
2365a59a8b3Srsb (void) printf("%s\n", name);
2375a59a8b3Srsb }
2385a59a8b3Srsb
2395a59a8b3Srsb static void
vm_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)2405a59a8b3Srsb vm_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
2415a59a8b3Srsb {
2425a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
2435a59a8b3Srsb char buf[LBUFSZ];
2445a59a8b3Srsb
2455a59a8b3Srsb if (dispflag & DISP_HEADER) {
246757bea67Srsb (void) printf(" map addmap delmap getpag putpag pagio\n");
2475a59a8b3Srsb }
2485a59a8b3Srsb
249*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nmap), buf);
250*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(naddmap), buf);
251*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(ndelmap), buf);
252*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(ngetpage), buf);
253*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(nputpage), buf);
254*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(npageio), buf);
2555a59a8b3Srsb (void) printf("%s\n", name);
2565a59a8b3Srsb }
2575a59a8b3Srsb
2585a59a8b3Srsb static void
attr_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)2595a59a8b3Srsb attr_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
2605a59a8b3Srsb {
2615a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
2625a59a8b3Srsb char buf[LBUFSZ];
2635a59a8b3Srsb
2645a59a8b3Srsb if (dispflag & DISP_HEADER) {
265757bea67Srsb (void) printf("getattr setattr getsec setsec\n");
2665a59a8b3Srsb }
2675a59a8b3Srsb
268*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(ngetattr), buf);
269*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(nsetattr), buf);
270*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(ngetsecattr), buf);
271*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(nsetsecattr), buf);
2725a59a8b3Srsb
2735a59a8b3Srsb (void) printf("%s\n", name);
2745a59a8b3Srsb }
2755a59a8b3Srsb
2765a59a8b3Srsb static void
naming_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)2775a59a8b3Srsb naming_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
2785a59a8b3Srsb {
2795a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
2805a59a8b3Srsb char buf[LBUFSZ];
2815a59a8b3Srsb
2825a59a8b3Srsb if (dispflag & DISP_HEADER) {
283757bea67Srsb (void) printf(
284757bea67Srsb "lookup creat remov link renam mkdir rmdir rddir symlnk rdlnk\n");
2855a59a8b3Srsb }
2865a59a8b3Srsb
287*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nlookup), buf);
288*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(ncreate), buf);
289*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nremove), buf);
290*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nlink), buf);
291*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nrename), buf);
292*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nmkdir), buf);
293*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nrmdir), buf);
294*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nreaddir), buf);
295*0a055120SJason King PRINTSTAT(niceflag, " %5s ", "%lld:", DELTA(nsymlink), buf);
296*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(nreadlink), buf);
2975a59a8b3Srsb (void) printf("%s\n", name);
2985a59a8b3Srsb }
2995a59a8b3Srsb
3005a59a8b3Srsb
3015a59a8b3Srsb #define PRINT_VOPSTAT_CMN(niceflag, vop) \
3025a59a8b3Srsb if (niceflag) \
3035a59a8b3Srsb (void) printf("%10s ", #vop); \
304*0a055120SJason King PRINTSTAT(niceflag, "%5s ", "%lld:", DELTA(n##vop), buf);
3055a59a8b3Srsb
3065a59a8b3Srsb #define PRINT_VOPSTAT(niceflag, vop) \
3075a59a8b3Srsb PRINT_VOPSTAT_CMN(niceflag, vop); \
3085a59a8b3Srsb if (niceflag) \
3095a59a8b3Srsb (void) printf("\n");
3105a59a8b3Srsb
3115a59a8b3Srsb #define PRINT_VOPSTAT_IO(niceflag, vop) \
3125a59a8b3Srsb PRINT_VOPSTAT_CMN(niceflag, vop); \
3135a59a8b3Srsb PRINTSTAT(niceflag, " %5s\n", "%lld:", \
314*0a055120SJason King DELTA(vop##_bytes), buf);
3155a59a8b3Srsb
3165a59a8b3Srsb static void
vop_display(char * name,vopstats_t * oldvsp,vopstats_t * newvsp,int dispflag)3175a59a8b3Srsb vop_display(char *name, vopstats_t *oldvsp, vopstats_t *newvsp, int dispflag)
3185a59a8b3Srsb {
3195a59a8b3Srsb int niceflag = ((dispflag & DISP_RAW) == 0);
3205a59a8b3Srsb char buf[LBUFSZ];
3215a59a8b3Srsb
3225a59a8b3Srsb if (niceflag) {
3235a59a8b3Srsb (void) printf("%s\n", name);
324757bea67Srsb (void) printf(" operation #ops bytes\n");
3255a59a8b3Srsb }
3265a59a8b3Srsb
3275a59a8b3Srsb PRINT_VOPSTAT(niceflag, open);
3285a59a8b3Srsb PRINT_VOPSTAT(niceflag, close);
3295a59a8b3Srsb PRINT_VOPSTAT_IO(niceflag, read);
3305a59a8b3Srsb PRINT_VOPSTAT_IO(niceflag, write);
3315a59a8b3Srsb PRINT_VOPSTAT(niceflag, ioctl);
3325a59a8b3Srsb PRINT_VOPSTAT(niceflag, setfl);
3335a59a8b3Srsb PRINT_VOPSTAT(niceflag, getattr);
3345a59a8b3Srsb PRINT_VOPSTAT(niceflag, setattr);
3355a59a8b3Srsb PRINT_VOPSTAT(niceflag, access);
3365a59a8b3Srsb PRINT_VOPSTAT(niceflag, lookup);
3375a59a8b3Srsb PRINT_VOPSTAT(niceflag, create);
3385a59a8b3Srsb PRINT_VOPSTAT(niceflag, remove);
3395a59a8b3Srsb PRINT_VOPSTAT(niceflag, link);
3405a59a8b3Srsb PRINT_VOPSTAT(niceflag, rename);
3415a59a8b3Srsb PRINT_VOPSTAT(niceflag, mkdir);
3425a59a8b3Srsb PRINT_VOPSTAT(niceflag, rmdir);
3435a59a8b3Srsb PRINT_VOPSTAT_IO(niceflag, readdir);
3445a59a8b3Srsb PRINT_VOPSTAT(niceflag, symlink);
3455a59a8b3Srsb PRINT_VOPSTAT(niceflag, readlink);
3465a59a8b3Srsb PRINT_VOPSTAT(niceflag, fsync);
3475a59a8b3Srsb PRINT_VOPSTAT(niceflag, inactive);
3485a59a8b3Srsb PRINT_VOPSTAT(niceflag, fid);
3495a59a8b3Srsb PRINT_VOPSTAT(niceflag, rwlock);
3505a59a8b3Srsb PRINT_VOPSTAT(niceflag, rwunlock);
3515a59a8b3Srsb PRINT_VOPSTAT(niceflag, seek);
3525a59a8b3Srsb PRINT_VOPSTAT(niceflag, cmp);
3535a59a8b3Srsb PRINT_VOPSTAT(niceflag, frlock);
3545a59a8b3Srsb PRINT_VOPSTAT(niceflag, space);
3555a59a8b3Srsb PRINT_VOPSTAT(niceflag, realvp);
3565a59a8b3Srsb PRINT_VOPSTAT(niceflag, getpage);
3575a59a8b3Srsb PRINT_VOPSTAT(niceflag, putpage);
3585a59a8b3Srsb PRINT_VOPSTAT(niceflag, map);
3595a59a8b3Srsb PRINT_VOPSTAT(niceflag, addmap);
3605a59a8b3Srsb PRINT_VOPSTAT(niceflag, delmap);
3615a59a8b3Srsb PRINT_VOPSTAT(niceflag, poll);
3625a59a8b3Srsb PRINT_VOPSTAT(niceflag, dump);
3635a59a8b3Srsb PRINT_VOPSTAT(niceflag, pathconf);
3645a59a8b3Srsb PRINT_VOPSTAT(niceflag, pageio);
3655a59a8b3Srsb PRINT_VOPSTAT(niceflag, dumpctl);
3665a59a8b3Srsb PRINT_VOPSTAT(niceflag, dispose);
3675a59a8b3Srsb PRINT_VOPSTAT(niceflag, getsecattr);
3685a59a8b3Srsb PRINT_VOPSTAT(niceflag, setsecattr);
3695a59a8b3Srsb PRINT_VOPSTAT(niceflag, shrlock);
3705a59a8b3Srsb PRINT_VOPSTAT(niceflag, vnevent);
371c242f9a0Schunli zhang - Sun Microsystems - Irvine United States PRINT_VOPSTAT(niceflag, reqzcbuf);
372c242f9a0Schunli zhang - Sun Microsystems - Irvine United States PRINT_VOPSTAT(niceflag, retzcbuf);
3735a59a8b3Srsb
3745a59a8b3Srsb if (niceflag) {
3755a59a8b3Srsb /* Make it easier on the eyes */
3765a59a8b3Srsb (void) printf("\n");
3775a59a8b3Srsb } else {
3785a59a8b3Srsb (void) printf("%s\n", name);
3795a59a8b3Srsb }
3805a59a8b3Srsb }
3815a59a8b3Srsb
3825a59a8b3Srsb
3835a59a8b3Srsb /*
3845a59a8b3Srsb * Retrieve the vopstats. If kspp (pointer to kstat_t pointer) is non-NULL,
3855a59a8b3Srsb * then pass it back to the caller.
3865a59a8b3Srsb *
3875a59a8b3Srsb * Returns 0 on success, non-zero on failure.
3885a59a8b3Srsb */
3895a59a8b3Srsb int
get_vopstats(kstat_ctl_t * kc,char * ksname,vopstats_t * vsp,kstat_t ** kspp)3905a59a8b3Srsb get_vopstats(kstat_ctl_t *kc, char *ksname, vopstats_t *vsp, kstat_t **kspp)
3915a59a8b3Srsb {
3925a59a8b3Srsb kstat_t *ksp;
3935a59a8b3Srsb
3945a59a8b3Srsb if (ksname == NULL || *ksname == 0)
3955a59a8b3Srsb return (1);
3965a59a8b3Srsb
3975a59a8b3Srsb errno = 0;
3985a59a8b3Srsb /* wait for a possibly up-to-date chain */
3995a59a8b3Srsb while (kstat_chain_update(kc) == -1) {
4005a59a8b3Srsb if (errno == EAGAIN) {
4015a59a8b3Srsb errno = 0;
4025a59a8b3Srsb (void) poll(NULL, 0, RETRY_DELAY);
4035a59a8b3Srsb continue;
4045a59a8b3Srsb }
405757bea67Srsb perror("kstat_chain_update");
4065a59a8b3Srsb exit(1);
4075a59a8b3Srsb }
4085a59a8b3Srsb
4095a59a8b3Srsb if ((ksp = kstat_lookup(kc, NULL, -1, ksname)) == NULL) {
4105a59a8b3Srsb return (1);
4115a59a8b3Srsb }
4125a59a8b3Srsb
4135a59a8b3Srsb if (kstat_read(kc, ksp, vsp) == -1) {
4145a59a8b3Srsb return (1);
4155a59a8b3Srsb }
4165a59a8b3Srsb
4175a59a8b3Srsb if (kspp)
4185a59a8b3Srsb *kspp = ksp;
4195a59a8b3Srsb
4205a59a8b3Srsb return (0);
4215a59a8b3Srsb }
4225a59a8b3Srsb
4235a59a8b3Srsb /*
4245a59a8b3Srsb * Given a file system type name, determine if it's part of the
4255a59a8b3Srsb * exception list of file systems that are not to be displayed.
4265a59a8b3Srsb */
4275a59a8b3Srsb int
is_exception(char * fsname)4285a59a8b3Srsb is_exception(char *fsname)
4295a59a8b3Srsb {
4305a59a8b3Srsb char **xlp; /* Pointer into the exception list */
4315a59a8b3Srsb
4325a59a8b3Srsb static char *exception_list[] = {
4335a59a8b3Srsb "specfs",
4345a59a8b3Srsb "fifofs",
4355a59a8b3Srsb "fd",
4365a59a8b3Srsb "swapfs",
4375a59a8b3Srsb "ctfs",
4385a59a8b3Srsb "objfs",
4395a59a8b3Srsb "nfsdyn",
4405a59a8b3Srsb NULL
4415a59a8b3Srsb };
4425a59a8b3Srsb
4435a59a8b3Srsb for (xlp = &exception_list[0]; *xlp != NULL; xlp++) {
4445a59a8b3Srsb if (strcmp(fsname, *xlp) == 0)
4455a59a8b3Srsb return (1);
4465a59a8b3Srsb }
4475a59a8b3Srsb
4485a59a8b3Srsb return (0);
4495a59a8b3Srsb }
4505a59a8b3Srsb
4515a59a8b3Srsb /*
4525a59a8b3Srsb * Plain and simple, build an array of names for fstypes
4535a59a8b3Srsb * Returns 0, if it encounters a problem.
4545a59a8b3Srsb */
4555a59a8b3Srsb int
build_fstype_list(char *** fstypep)4565a59a8b3Srsb build_fstype_list(char ***fstypep)
4575a59a8b3Srsb {
4585a59a8b3Srsb int i;
4595a59a8b3Srsb int nfstype;
4605a59a8b3Srsb char buf[FSTYPSZ + 1];
4615a59a8b3Srsb
4625a59a8b3Srsb if ((nfstype = sysfs(GETNFSTYP)) < 0) {
463757bea67Srsb perror("sysfs(GETNFSTYP)");
4645a59a8b3Srsb return (0);
4655a59a8b3Srsb }
4665a59a8b3Srsb
4675a59a8b3Srsb if ((*fstypep = calloc(nfstype, sizeof (char *))) == NULL) {
468757bea67Srsb perror("calloc() fstypes");
4695a59a8b3Srsb return (0);
4705a59a8b3Srsb }
4715a59a8b3Srsb
4725a59a8b3Srsb for (i = 1; i < nfstype; i++) {
4735a59a8b3Srsb if (sysfs(GETFSTYP, i, buf) < 0) {
474757bea67Srsb perror("sysfs(GETFSTYP)");
4755a59a8b3Srsb return (0);
4765a59a8b3Srsb }
4775a59a8b3Srsb
4785a59a8b3Srsb if (buf[0] == 0)
4795a59a8b3Srsb continue;
4805a59a8b3Srsb
4815a59a8b3Srsb /* If this is part of the exception list, move on */
4825a59a8b3Srsb if (is_exception(buf))
4835a59a8b3Srsb continue;
4845a59a8b3Srsb
4855a59a8b3Srsb if (((*fstypep)[i] = strdup(buf)) == NULL) {
486757bea67Srsb perror("strdup() fstype name");
4875a59a8b3Srsb return (0);
4885a59a8b3Srsb }
4895a59a8b3Srsb }
4905a59a8b3Srsb
4915a59a8b3Srsb return (i);
4925a59a8b3Srsb }
4935a59a8b3Srsb
4945a59a8b3Srsb /*
4955a59a8b3Srsb * After we're done with getopts(), process the rest of the
4965a59a8b3Srsb * operands. We have three cases and this is the priority:
4975a59a8b3Srsb *
4985a59a8b3Srsb * 1) [ operand... ] interval count
4995a59a8b3Srsb * 2) [ operand... ] interval
5005a59a8b3Srsb * 3) [ operand... ]
5015a59a8b3Srsb *
5025a59a8b3Srsb * The trick is that any of the operands might start with a number or even
5035a59a8b3Srsb * be made up exclusively of numbers (and we have to handle negative numbers
5045a59a8b3Srsb * in case a user/script gets out of line). If we find two operands at the
5055a59a8b3Srsb * end of the list then we claim case 1. If we find only one operand at the
5065a59a8b3Srsb * end made up only of number, then we claim case 2. Otherwise, case 3.
5075a59a8b3Srsb * BTW, argc, argv don't change.
5085a59a8b3Srsb */
5095a59a8b3Srsb int
parse_operands(int argc,char ** argv,int optind,long * interval,long * count,entity_t ** entityp)5105a59a8b3Srsb parse_operands(
5115a59a8b3Srsb int argc,
5125a59a8b3Srsb char **argv,
5135a59a8b3Srsb int optind,
5145a59a8b3Srsb long *interval,
5155a59a8b3Srsb long *count,
5165a59a8b3Srsb entity_t **entityp) /* Array of stat-able entities */
5175a59a8b3Srsb {
5185a59a8b3Srsb int nentities = 0; /* Number of entities found */
5195a59a8b3Srsb int out_of_range; /* Set if 2nd-to-last operand out-of-range */
5205a59a8b3Srsb
5215a59a8b3Srsb if (argc == optind)
5225a59a8b3Srsb return (nentities); /* None found, returns 0 */
5235a59a8b3Srsb /*
5245a59a8b3Srsb * We know exactly what the maximum number of entities is going
5255a59a8b3Srsb * to be: argc - optind
5265a59a8b3Srsb */
5275a59a8b3Srsb if ((*entityp = calloc((argc - optind), sizeof (entity_t))) == NULL) {
528757bea67Srsb perror("calloc() entities");
5295a59a8b3Srsb return (-1);
5305a59a8b3Srsb }
5315a59a8b3Srsb
5325a59a8b3Srsb for (/* void */; argc > optind; optind++) {
5335a59a8b3Srsb char *endptr;
5345a59a8b3Srsb
5355a59a8b3Srsb /* If we have more than two operands left to process */
5365a59a8b3Srsb if ((argc - optind) > 2) {
5375a59a8b3Srsb (*entityp)[nentities++].e_name = strdup(argv[optind]);
5385a59a8b3Srsb continue;
5395a59a8b3Srsb }
5405a59a8b3Srsb
5415a59a8b3Srsb /* If we're here, then we only have one or two operands left */
5425a59a8b3Srsb errno = 0;
5435a59a8b3Srsb out_of_range = 0;
5445a59a8b3Srsb *interval = strtol(argv[optind], &endptr, 10);
5455a59a8b3Srsb if (*endptr && !isdigit((int)*endptr)) {
5465a59a8b3Srsb /* Operand was not a number */
5475a59a8b3Srsb (*entityp)[nentities++].e_name = strdup(argv[optind]);
5485a59a8b3Srsb continue;
5495a59a8b3Srsb } else if (errno == ERANGE || *interval <= 0 ||
550f5cd957fSRobert Harris *interval > MAXLONG) {
5515a59a8b3Srsb /* Operand was a number, just out of range */
5525a59a8b3Srsb out_of_range++;
5535a59a8b3Srsb }
5545a59a8b3Srsb
5555a59a8b3Srsb /*
5565a59a8b3Srsb * The last operand we saw was a number. If it happened to
5575a59a8b3Srsb * be the last operand, then it is the interval...
5585a59a8b3Srsb */
5595a59a8b3Srsb if ((argc - optind) == 1) {
5605a59a8b3Srsb /* ...but we need to check the range. */
5615a59a8b3Srsb if (out_of_range) {
5625a59a8b3Srsb (void) fprintf(stderr, gettext(
5635a59a8b3Srsb "interval must be between 1 and "
5645a59a8b3Srsb "%ld (inclusive)\n"), MAXLONG);
5655a59a8b3Srsb return (-1);
5665a59a8b3Srsb } else {
5675a59a8b3Srsb /*
5685a59a8b3Srsb * The value of the interval is valid. Set
5695a59a8b3Srsb * count to something really big so it goes
5705a59a8b3Srsb * virtually forever.
5715a59a8b3Srsb */
5725a59a8b3Srsb *count = MAXLONG;
5735a59a8b3Srsb break;
5745a59a8b3Srsb }
5755a59a8b3Srsb }
5765a59a8b3Srsb
5775a59a8b3Srsb /*
5785a59a8b3Srsb * At this point, we *might* have the interval, but if the
5795a59a8b3Srsb * next operand isn't a number, then we don't have either
5805a59a8b3Srsb * the interval nor the count. Both must be set to the
5815a59a8b3Srsb * defaults. In that case, both the current and the previous
5825a59a8b3Srsb * operands are stat-able entities.
5835a59a8b3Srsb */
5845a59a8b3Srsb errno = 0;
5855a59a8b3Srsb *count = strtol(argv[optind + 1], &endptr, 10);
5865a59a8b3Srsb if (*endptr && !isdigit((int)*endptr)) {
5875a59a8b3Srsb /*
5885a59a8b3Srsb * Faked out! The last operand wasn't a number so
5895a59a8b3Srsb * the current and previous operands should be
5905a59a8b3Srsb * stat-able entities. We also need to reset interval.
5915a59a8b3Srsb */
5925a59a8b3Srsb *interval = 0;
5935a59a8b3Srsb (*entityp)[nentities++].e_name = strdup(argv[optind++]);
5945a59a8b3Srsb (*entityp)[nentities++].e_name = strdup(argv[optind++]);
5955a59a8b3Srsb } else if (out_of_range || errno == ERANGE || *count <= 0) {
5965a59a8b3Srsb (void) fprintf(stderr, gettext(
5975a59a8b3Srsb "Both interval and count must be between 1 "
5985a59a8b3Srsb "and %ld (inclusive)\n"), MAXLONG);
5995a59a8b3Srsb return (-1);
6005a59a8b3Srsb }
6015a59a8b3Srsb break; /* Done! */
6025a59a8b3Srsb }
6035a59a8b3Srsb return (nentities);
6045a59a8b3Srsb }
6055a59a8b3Srsb
6065a59a8b3Srsb /*
6075a59a8b3Srsb * set_mntpt() looks at the entity's name (e_name) and finds its
6085a59a8b3Srsb * mountpoint. To do this, we need to build a list of mountpoints
6095a59a8b3Srsb * from /etc/mnttab. We only need to do this once and we don't do it
6105a59a8b3Srsb * if we don't need to look at any mountpoints.
6115a59a8b3Srsb * Returns 0 on success, non-zero if it couldn't find a mount-point.
6125a59a8b3Srsb */
6135a59a8b3Srsb int
set_mntpt(entity_t * ep)6145a59a8b3Srsb set_mntpt(entity_t *ep)
6155a59a8b3Srsb {
6165a59a8b3Srsb static struct mnt {
6175a59a8b3Srsb struct mnt *m_next;
6185a59a8b3Srsb char *m_mntpt;
6195a59a8b3Srsb ulong_t m_fsid; /* From statvfs(), set only as needed */
6205a59a8b3Srsb } *mnt_list = NULL; /* Linked list of mount-points */
6215a59a8b3Srsb struct mnt *mntp;
62206f33e8dSrsb struct statvfs64 statvfsbuf;
6235a59a8b3Srsb char *original_name = ep->e_name;
6245a59a8b3Srsb char path[PATH_MAX];
6255a59a8b3Srsb
6265a59a8b3Srsb if (original_name == NULL) /* Shouldn't happen */
6275a59a8b3Srsb return (1);
6285a59a8b3Srsb
6295a59a8b3Srsb /* We only set up mnt_list the first time this is called */
6305a59a8b3Srsb if (mnt_list == NULL) {
6315a59a8b3Srsb FILE *fp;
6325a59a8b3Srsb struct mnttab mnttab;
6335a59a8b3Srsb
6345a59a8b3Srsb if ((fp = fopen(MNTTAB, "r")) == NULL) {
6355a59a8b3Srsb perror(MNTTAB);
6365a59a8b3Srsb return (1);
6375a59a8b3Srsb }
6385a59a8b3Srsb resetmnttab(fp);
6395a59a8b3Srsb /*
6405a59a8b3Srsb * We insert at the front of the list so that when we
6415a59a8b3Srsb * search entries we'll have the last mounted entries
6425a59a8b3Srsb * first in the list so that we can match the longest
6435a59a8b3Srsb * mountpoint.
6445a59a8b3Srsb */
6455a59a8b3Srsb while (getmntent(fp, &mnttab) == 0) {
6465a59a8b3Srsb if ((mntp = malloc(sizeof (*mntp))) == NULL) {
647757bea67Srsb perror("malloc() mount list");
6485a59a8b3Srsb return (1);
6495a59a8b3Srsb }
6505a59a8b3Srsb mntp->m_mntpt = strdup(mnttab.mnt_mountp);
6515a59a8b3Srsb mntp->m_next = mnt_list;
6525a59a8b3Srsb mnt_list = mntp;
6535a59a8b3Srsb }
6545a59a8b3Srsb (void) fclose(fp);
6555a59a8b3Srsb }
6565a59a8b3Srsb
6575a59a8b3Srsb if (realpath(original_name, path) == NULL) {
6585a59a8b3Srsb perror(original_name);
6595a59a8b3Srsb return (1);
6605a59a8b3Srsb }
6615a59a8b3Srsb
6625a59a8b3Srsb /*
6635a59a8b3Srsb * Now that we have the path, walk through the mnt_list and
6645a59a8b3Srsb * look for the first (best) match.
6655a59a8b3Srsb */
6665a59a8b3Srsb for (mntp = mnt_list; mntp; mntp = mntp->m_next) {
6675a59a8b3Srsb if (strncmp(path, mntp->m_mntpt, strlen(mntp->m_mntpt)) == 0) {
6685a59a8b3Srsb if (mntp->m_fsid == 0) {
66906f33e8dSrsb if (statvfs64(mntp->m_mntpt, &statvfsbuf)) {
6705a59a8b3Srsb /* Can't statvfs so no match */
6715a59a8b3Srsb continue;
6725a59a8b3Srsb } else {
6735a59a8b3Srsb mntp->m_fsid = statvfsbuf.f_fsid;
6745a59a8b3Srsb }
6755a59a8b3Srsb }
6765a59a8b3Srsb
6775a59a8b3Srsb if (ep->e_fsid != mntp->m_fsid) {
6785a59a8b3Srsb /* No match - Move on */
6795a59a8b3Srsb continue;
6805a59a8b3Srsb }
6815a59a8b3Srsb
6825a59a8b3Srsb break;
6835a59a8b3Srsb }
6845a59a8b3Srsb }
6855a59a8b3Srsb
6865a59a8b3Srsb if (mntp == NULL) {
6875a59a8b3Srsb (void) fprintf(stderr, gettext(
6885a59a8b3Srsb "Can't find mount point for %s\n"), path);
6895a59a8b3Srsb return (1);
6905a59a8b3Srsb }
6915a59a8b3Srsb
6925a59a8b3Srsb ep->e_name = strdup(mntp->m_mntpt);
6935a59a8b3Srsb free(original_name);
6945a59a8b3Srsb return (0);
6955a59a8b3Srsb }
6965a59a8b3Srsb
6975a59a8b3Srsb /*
6985a59a8b3Srsb * We have an array of entities that are potentially stat-able. Using
6995a59a8b3Srsb * the name (e_name) of the entity, attempt to construct a ksname suitable
7005a59a8b3Srsb * for use by kstat_lookup(3kstat) and fill it into the e_ksname member.
7015a59a8b3Srsb *
7025a59a8b3Srsb * We check the e_name against the list of file system types. If there is
7035a59a8b3Srsb * no match then test to see if the path is valid. If the path is valid,
7045a59a8b3Srsb * then determine the mountpoint.
7055a59a8b3Srsb */
7065a59a8b3Srsb void
set_ksnames(entity_t * entities,int nentities,char ** fstypes,int nfstypes)7075a59a8b3Srsb set_ksnames(entity_t *entities, int nentities, char **fstypes, int nfstypes)
7085a59a8b3Srsb {
7095a59a8b3Srsb int i, j;
71006f33e8dSrsb struct statvfs64 statvfsbuf;
7115a59a8b3Srsb
7125a59a8b3Srsb for (i = 0; i < nentities; i++) {
7135a59a8b3Srsb entity_t *ep = &entities[i];
7145a59a8b3Srsb
7155a59a8b3Srsb /* Check the name against the list of fstypes */
7165a59a8b3Srsb for (j = 1; j < nfstypes; j++) {
7175a59a8b3Srsb if (fstypes[j] && ep->e_name &&
7185a59a8b3Srsb strcmp(ep->e_name, fstypes[j]) == 0) {
7195a59a8b3Srsb /* It's a file system type */
7205a59a8b3Srsb ep->e_type = ENTYPE_FSTYPE;
721f5cd957fSRobert Harris (void) snprintf(ep->e_ksname, KSTAT_STRLEN,
722f5cd957fSRobert Harris "%s%s", VOPSTATS_STR, ep->e_name);
7235a59a8b3Srsb /* Now allocate the vopstats array */
7245a59a8b3Srsb ep->e_vs = calloc(VS_SIZE, sizeof (vopstats_t));
7255a59a8b3Srsb if (entities[i].e_vs == NULL) {
726757bea67Srsb perror("calloc() fstype vopstats");
7275a59a8b3Srsb exit(1);
7285a59a8b3Srsb }
7295a59a8b3Srsb break;
7305a59a8b3Srsb }
7315a59a8b3Srsb }
7325a59a8b3Srsb if (j < nfstypes) /* Found it! */
7335a59a8b3Srsb continue;
7345a59a8b3Srsb
7355a59a8b3Srsb /*
7365a59a8b3Srsb * If the entity in the exception list of fstypes, then
7375a59a8b3Srsb * null out the entry so it isn't displayed and move along.
7385a59a8b3Srsb */
7395a59a8b3Srsb if (is_exception(ep->e_name)) {
7405a59a8b3Srsb ep->e_ksname[0] = 0;
7415a59a8b3Srsb continue;
7425a59a8b3Srsb }
7435a59a8b3Srsb
7445a59a8b3Srsb /* If we didn't find it, see if it's a path */
74506f33e8dSrsb if (ep->e_name == NULL || statvfs64(ep->e_name, &statvfsbuf)) {
7465a59a8b3Srsb /* Error - Make sure the entry is nulled out */
7475a59a8b3Srsb ep->e_ksname[0] = 0;
7485a59a8b3Srsb continue;
7495a59a8b3Srsb }
7505a59a8b3Srsb (void) snprintf(ep->e_ksname, KSTAT_STRLEN, "%s%lx",
7515a59a8b3Srsb VOPSTATS_STR, statvfsbuf.f_fsid);
7525a59a8b3Srsb ep->e_fsid = statvfsbuf.f_fsid;
7535a59a8b3Srsb if (set_mntpt(ep)) {
7545a59a8b3Srsb (void) fprintf(stderr,
7555a59a8b3Srsb gettext("Can't determine type of \"%s\"\n"),
7565a59a8b3Srsb ep->e_name ? ep->e_name : gettext("<NULL>"));
7575a59a8b3Srsb } else {
7585a59a8b3Srsb ep->e_type = ENTYPE_MNTPT;
7595a59a8b3Srsb }
7605a59a8b3Srsb
7615a59a8b3Srsb /* Now allocate the vopstats array */
7625a59a8b3Srsb ep->e_vs = calloc(VS_SIZE, sizeof (vopstats_t));
7635a59a8b3Srsb if (entities[i].e_vs == NULL) {
764757bea67Srsb perror("calloc() vopstats array");
7655a59a8b3Srsb exit(1);
7665a59a8b3Srsb }
7675a59a8b3Srsb }
7685a59a8b3Srsb }
7695a59a8b3Srsb
7705a59a8b3Srsb /*
7715a59a8b3Srsb * The idea is that 'dspfunc' should only be modified from the default
7725a59a8b3Srsb * once since the display options are mutually exclusive. If 'dspfunc'
7735a59a8b3Srsb * only contains the default display function, then all is good and we
7745a59a8b3Srsb * can set it to the new display function. Otherwise, bail.
7755a59a8b3Srsb */
7765a59a8b3Srsb void
set_dispfunc(void (** dspfunc)(char *,vopstats_t *,vopstats_t *,int),void (* newfunc)(char *,vopstats_t *,vopstats_t *,int))7775a59a8b3Srsb set_dispfunc(
7785a59a8b3Srsb void (**dspfunc)(char *, vopstats_t *, vopstats_t *, int),
7795a59a8b3Srsb void (*newfunc)(char *, vopstats_t *, vopstats_t *, int))
7805a59a8b3Srsb {
7815a59a8b3Srsb if (*dspfunc != dflt_display) {
7825a59a8b3Srsb (void) fprintf(stderr, gettext(
7835a59a8b3Srsb "%s: Display options -{a|f|i|n|v} are mutually exclusive\n"),
7845a59a8b3Srsb cmdname);
7855a59a8b3Srsb usage();
7865a59a8b3Srsb }
7875a59a8b3Srsb *dspfunc = newfunc;
7885a59a8b3Srsb }
7895a59a8b3Srsb
7905a59a8b3Srsb int
main(int argc,char * argv[])7915a59a8b3Srsb main(int argc, char *argv[])
7925a59a8b3Srsb {
7935a59a8b3Srsb int c;
7945a59a8b3Srsb int i, j; /* Generic counters */
7955a59a8b3Srsb int nentities_found;
7964944376cSJohn Levon int linesout = 0; /* Keeps track of lines printed */
7975a59a8b3Srsb int printhdr = 0; /* Print a header? 0 = no, 1 = yes */
7985a59a8b3Srsb int nfstypes; /* Number of fstypes */
7995a59a8b3Srsb int dispflag = 0; /* Flags for display control */
8005a59a8b3Srsb long count = 0; /* Number of iterations for display */
80100c76d6fStc int forever; /* Run forever */
8025a59a8b3Srsb long interval = 0;
8035a59a8b3Srsb boolean_t fstypes_only = B_FALSE; /* Display fstypes only */
8045a59a8b3Srsb char **fstypes; /* Array of names of all fstypes */
8055a59a8b3Srsb int nentities; /* Number of stat-able entities */
8065a59a8b3Srsb entity_t *entities; /* Array of stat-able entities */
8075a59a8b3Srsb kstat_ctl_t *kc;
8085a59a8b3Srsb void (*dfunc)(char *, vopstats_t *, vopstats_t *, int) = dflt_display;
80900c76d6fStc hrtime_t start_n; /* Start time */
81000c76d6fStc hrtime_t period_n; /* Interval in nanoseconds */
8115a59a8b3Srsb
8125a59a8b3Srsb extern int optind;
8135a59a8b3Srsb
81413c7b6acSrsb (void) setlocale(LC_ALL, "");
81513c7b6acSrsb #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
81613c7b6acSrsb #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
81713c7b6acSrsb #endif
81813c7b6acSrsb (void) textdomain(TEXT_DOMAIN);
81913c7b6acSrsb
820f5cd957fSRobert Harris /* Don't let buffering interfere with piped output. */
821f5cd957fSRobert Harris (void) setvbuf(stdout, NULL, _IOLBF, 0);
822f5cd957fSRobert Harris
8235a59a8b3Srsb cmdname = argv[0];
8245a59a8b3Srsb while ((c = getopt(argc, argv, OPTIONS)) != EOF) {
8255a59a8b3Srsb switch (c) {
8265a59a8b3Srsb
8275a59a8b3Srsb default:
8285a59a8b3Srsb usage();
8295a59a8b3Srsb break;
8305a59a8b3Srsb
8313a401a6bSrsb case 'F': /* Only display available FStypes */
8323a401a6bSrsb fstypes_only = B_TRUE;
8333a401a6bSrsb break;
8343a401a6bSrsb
8353a401a6bSrsb #if PARSABLE_OUTPUT
8365a59a8b3Srsb case 'P': /* Parsable output */
8375a59a8b3Srsb dispflag |= DISP_RAW;
8385a59a8b3Srsb break;
8393a401a6bSrsb #endif /* PARSABLE_OUTPUT */
8405a59a8b3Srsb
8415a59a8b3Srsb case 'T': /* Timestamp */
8425a59a8b3Srsb if (optarg) {
8435a59a8b3Srsb if (strcmp(optarg, "u") == 0) {
8444944376cSJohn Levon timestamp_fmt = UDATE;
8455a59a8b3Srsb } else if (strcmp(optarg, "d") == 0) {
8464944376cSJohn Levon timestamp_fmt = DDATE;
8475a59a8b3Srsb }
8485a59a8b3Srsb }
8495a59a8b3Srsb
8505a59a8b3Srsb /* If it was never set properly... */
8514944376cSJohn Levon if (timestamp_fmt == NODATE) {
852f5cd957fSRobert Harris (void) fprintf(stderr, gettext("%s: -T option "
853f5cd957fSRobert Harris "requires either 'u' or 'd'\n"), cmdname);
8545a59a8b3Srsb usage();
8555a59a8b3Srsb }
8565a59a8b3Srsb break;
8575a59a8b3Srsb
8585a59a8b3Srsb case 'a':
8595a59a8b3Srsb set_dispfunc(&dfunc, attr_display);
8605a59a8b3Srsb break;
8615a59a8b3Srsb
8625a59a8b3Srsb case 'f':
8635a59a8b3Srsb set_dispfunc(&dfunc, vop_display);
8645a59a8b3Srsb break;
8655a59a8b3Srsb
8665a59a8b3Srsb case 'i':
8675a59a8b3Srsb set_dispfunc(&dfunc, io_display);
8685a59a8b3Srsb break;
8695a59a8b3Srsb
8705a59a8b3Srsb case 'n':
8715a59a8b3Srsb set_dispfunc(&dfunc, naming_display);
8725a59a8b3Srsb break;
8735a59a8b3Srsb
8745a59a8b3Srsb case 'v':
8755a59a8b3Srsb set_dispfunc(&dfunc, vm_display);
8765a59a8b3Srsb break;
8775a59a8b3Srsb }
8785a59a8b3Srsb }
8795a59a8b3Srsb
8803a401a6bSrsb #if PARSABLE_OUTPUT
8814944376cSJohn Levon if ((dispflag & DISP_RAW) && (timestamp_fmt != NODATE)) {
8825a59a8b3Srsb (void) fprintf(stderr, gettext(
883f5cd957fSRobert Harris "-P and -T options are mutually exclusive\n"));
8845a59a8b3Srsb usage();
8855a59a8b3Srsb }
8863a401a6bSrsb #endif /* PARSABLE_OUTPUT */
8875a59a8b3Srsb
8885a59a8b3Srsb /* Gather the list of filesystem types */
8895a59a8b3Srsb if ((nfstypes = build_fstype_list(&fstypes)) == 0) {
8905a59a8b3Srsb (void) fprintf(stderr,
8915a59a8b3Srsb gettext("Can't build list of fstypes\n"));
8925a59a8b3Srsb exit(1);
8935a59a8b3Srsb }
8945a59a8b3Srsb
8955a59a8b3Srsb nentities = parse_operands(
8965a59a8b3Srsb argc, argv, optind, &interval, &count, &entities);
89700c76d6fStc forever = count == MAXLONG;
89800c76d6fStc period_n = (hrtime_t)interval * NANOSEC;
8995a59a8b3Srsb
9005a59a8b3Srsb if (nentities == -1) /* Set of operands didn't parse properly */
9015a59a8b3Srsb usage();
9025a59a8b3Srsb
9033a401a6bSrsb if ((nentities == 0) && (fstypes_only == B_FALSE)) {
9043a401a6bSrsb (void) fprintf(stderr, gettext(
9053a401a6bSrsb "Must specify -F or at least one fstype or mount point\n"));
9063a401a6bSrsb usage();
9073a401a6bSrsb }
9083a401a6bSrsb
9093a401a6bSrsb if ((nentities > 0) && (fstypes_only == B_TRUE)) {
9103a401a6bSrsb (void) fprintf(stderr, gettext(
9113a401a6bSrsb "Cannot use -F with fstypes or mount points\n"));
9123a401a6bSrsb usage();
9133a401a6bSrsb }
9143a401a6bSrsb
9155a59a8b3Srsb /*
9163a401a6bSrsb * If we had no operands (except for interval/count) and we
9173a401a6bSrsb * requested FStypes only (-F), then fill in the entities[]
9183a401a6bSrsb * array with all available fstypes.
9195a59a8b3Srsb */
9203a401a6bSrsb if ((nentities == 0) && (fstypes_only == B_TRUE)) {
9215a59a8b3Srsb if ((entities = calloc(nfstypes, sizeof (entity_t))) == NULL) {
922757bea67Srsb perror("calloc() fstype stats");
9235a59a8b3Srsb exit(1);
9245a59a8b3Srsb }
9255a59a8b3Srsb
9265a59a8b3Srsb for (i = 1; i < nfstypes; i++) {
9275a59a8b3Srsb if (fstypes[i]) {
9285a59a8b3Srsb entities[nentities].e_name = strdup(fstypes[i]);
9295a59a8b3Srsb nentities++;
9305a59a8b3Srsb }
9315a59a8b3Srsb }
9325a59a8b3Srsb }
9335a59a8b3Srsb
9345a59a8b3Srsb set_ksnames(entities, nentities, fstypes, nfstypes);
9355a59a8b3Srsb
9365a59a8b3Srsb if ((kc = kstat_open()) == NULL) {
937757bea67Srsb perror("kstat_open");
9385a59a8b3Srsb exit(1);
9395a59a8b3Srsb }
9405a59a8b3Srsb
94100c76d6fStc /* Set start time */
94200c76d6fStc start_n = gethrtime();
94300c76d6fStc
9444944376cSJohn Levon /* Initial timestamp */
9454944376cSJohn Levon if (timestamp_fmt != NODATE) {
94626fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt);
9474944376cSJohn Levon linesout++;
9484944376cSJohn Levon }
9494944376cSJohn Levon
9505a59a8b3Srsb /*
9515a59a8b3Srsb * The following loop walks through the entities[] list to "prime
9525a59a8b3Srsb * the pump"
9535a59a8b3Srsb */
9544944376cSJohn Levon for (j = 0, printhdr = 1; j < nentities; j++) {
9555a59a8b3Srsb entity_t *ent = &entities[j];
9565a59a8b3Srsb vopstats_t *vsp = &ent->e_vs[CUR_INDEX];
9575a59a8b3Srsb kstat_t *ksp = NULL;
9585a59a8b3Srsb
9595a59a8b3Srsb if (get_vopstats(kc, ent->e_ksname, vsp, &ksp) == 0) {
9605a59a8b3Srsb (*dfunc)(ent->e_name, NULL, vsp,
9614944376cSJohn Levon dispflag_policy(printhdr, dispflag));
9625a59a8b3Srsb linesout++;
9635a59a8b3Srsb } else {
9645a59a8b3Srsb /*
9655a59a8b3Srsb * If we can't find it the first time through, then
9665a59a8b3Srsb * get rid of it.
9675a59a8b3Srsb */
9685a59a8b3Srsb entities[j].e_ksname[0] = 0;
9695a59a8b3Srsb
9705a59a8b3Srsb /*
9713a401a6bSrsb * If we're only displaying FStypes (-F) then don't
9725a59a8b3Srsb * complain about any file systems that might not
9735a59a8b3Srsb * be loaded. Otherwise, let the user know that
97448bbca81SDaniel Hoffman * they chose poorly.
9755a59a8b3Srsb */
9765a59a8b3Srsb if (fstypes_only == B_FALSE) {
9775a59a8b3Srsb (void) fprintf(stderr, gettext(
9785a59a8b3Srsb "No statistics available for %s\n"),
9795a59a8b3Srsb entities[j].e_name);
9805a59a8b3Srsb }
9815a59a8b3Srsb }
9824944376cSJohn Levon printhdr = 0;
9835a59a8b3Srsb }
9845a59a8b3Srsb
98500c76d6fStc if (count > 1)
98600c76d6fStc /* Set up signal handler for SIGCONT */
98700c76d6fStc if (signal(SIGCONT, cont_handler) == SIG_ERR)
98800c76d6fStc fail(1, "signal failed");
98900c76d6fStc
99000c76d6fStc
9915a59a8b3Srsb BUMP_INDEX(); /* Swap the previous/current indices */
99200c76d6fStc i = 1;
99300c76d6fStc while (forever || i++ <= count) {
9945a59a8b3Srsb /*
9955a59a8b3Srsb * No telling how many lines will be printed in any interval.
9965a59a8b3Srsb * There should be a minimum of HEADERLINES between any
9975a59a8b3Srsb * header. If we exceed that, no big deal.
9985a59a8b3Srsb */
9995a59a8b3Srsb if (linesout > HEADERLINES) {
10005a59a8b3Srsb linesout = 0;
10015a59a8b3Srsb printhdr = 1;
10025a59a8b3Srsb }
100300c76d6fStc /* Have a kip */
100400c76d6fStc sleep_until(&start_n, period_n, forever, &caught_cont);
10055a59a8b3Srsb
10064944376cSJohn Levon if (timestamp_fmt != NODATE) {
100726fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt);
10085a59a8b3Srsb linesout++;
10095a59a8b3Srsb }
10105a59a8b3Srsb
10115a59a8b3Srsb for (j = 0, nentities_found = 0; j < nentities; j++) {
10125a59a8b3Srsb entity_t *ent = &entities[j];
10135a59a8b3Srsb
10145a59a8b3Srsb /*
10155a59a8b3Srsb * If this entry has been cleared, don't attempt
10165a59a8b3Srsb * to process it.
10175a59a8b3Srsb */
10185a59a8b3Srsb if (ent->e_ksname[0] == 0) {
10195a59a8b3Srsb continue;
10205a59a8b3Srsb }
10215a59a8b3Srsb
10225a59a8b3Srsb if (get_vopstats(kc, ent->e_ksname,
10235a59a8b3Srsb &ent->e_vs[CUR_INDEX], NULL) == 0) {
10245a59a8b3Srsb (*dfunc)(ent->e_name, &ent->e_vs[PREV_INDEX],
10255a59a8b3Srsb &ent->e_vs[CUR_INDEX],
10265a59a8b3Srsb dispflag_policy(printhdr, dispflag));
10275a59a8b3Srsb linesout++;
10285a59a8b3Srsb nentities_found++;
10295a59a8b3Srsb } else {
10305a59a8b3Srsb if (ent->e_type == ENTYPE_MNTPT) {
10315a59a8b3Srsb (void) printf(gettext(
10325a59a8b3Srsb "<<mount point no longer "
10335a59a8b3Srsb "available: %s>>\n"), ent->e_name);
10345a59a8b3Srsb } else if (ent->e_type == ENTYPE_FSTYPE) {
10355a59a8b3Srsb (void) printf(gettext(
10365a59a8b3Srsb "<<file system module no longer "
10375a59a8b3Srsb "loaded: %s>>\n"), ent->e_name);
10385a59a8b3Srsb } else {
10395a59a8b3Srsb (void) printf(gettext(
10405a59a8b3Srsb "<<%s no longer available>>\n"),
10415a59a8b3Srsb ent->e_name);
10425a59a8b3Srsb }
10435a59a8b3Srsb /* Disable this so it doesn't print again */
10445a59a8b3Srsb ent->e_ksname[0] = 0;
10455a59a8b3Srsb }
10465a59a8b3Srsb printhdr = 0; /* Always shut this off */
10475a59a8b3Srsb }
10485a59a8b3Srsb BUMP_INDEX(); /* Bump the previous/current indices */
10495a59a8b3Srsb
10505a59a8b3Srsb /*
10515a59a8b3Srsb * If the entities we were observing are no longer there
10525a59a8b3Srsb * (file system modules unloaded, file systems unmounted)
10535a59a8b3Srsb * then we're done.
10545a59a8b3Srsb */
10555a59a8b3Srsb if (nentities_found == 0)
10565a59a8b3Srsb break;
10575a59a8b3Srsb }
10585a59a8b3Srsb
10595a59a8b3Srsb return (0);
10605a59a8b3Srsb }
1061