usr/src/cmd/fm/fmstat/common/fmstat.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <fm/fmd_adm.h>
  28
  29 #include <strings.h>
  30 #include <limits.h>
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <errno.h>
  35 #include <poll.h>
  36 #include <locale.h>
  37
  38 #include "statcommon.h"
  39
  40 #define FMSTAT_EXIT_SUCCESS     0
  41 #define FMSTAT_EXIT_ERROR       1
  42 #define FMSTAT_EXIT_USAGE       2
  43
  44 static const struct stats {
  45         fmd_stat_t module;
  46         fmd_stat_t authority;
  47         fmd_stat_t state;
  48         fmd_stat_t loadtime;
  49         fmd_stat_t snaptime;
  50         fmd_stat_t received;
  51         fmd_stat_t discarded;
  52         fmd_stat_t retried;
  53         fmd_stat_t replayed;
  54         fmd_stat_t lost;
  55         fmd_stat_t dispatched;
  56         fmd_stat_t dequeued;
  57         fmd_stat_t prdequeued;
  58         fmd_stat_t accepted;
  59         fmd_stat_t memtotal;
  60         fmd_stat_t buftotal;
  61         fmd_stat_t caseopen;
  62         fmd_stat_t casesolved;
  63         fmd_stat_t wcnt;
  64         fmd_stat_t wtime;
  65         fmd_stat_t wlentime;
  66         fmd_stat_t wlastupdate;
  67         fmd_stat_t dtime;
  68         fmd_stat_t dlastupdate;
  69 } stats_template = {
  70         { "module", FMD_TYPE_STRING },
  71         { "authority", FMD_TYPE_STRING },
  72         { "state", FMD_TYPE_STRING },
  73         { "loadtime", FMD_TYPE_TIME },
  74         { "snaptime", FMD_TYPE_TIME },
  75         { "received", FMD_TYPE_UINT64 },
  76         { "discarded", FMD_TYPE_UINT64 },
  77         { "retried", FMD_TYPE_UINT64 },
  78         { "replayed", FMD_TYPE_UINT64 },
  79         { "lost", FMD_TYPE_UINT64 },
  80         { "dispatched", FMD_TYPE_UINT64 },
  81         { "dequeued", FMD_TYPE_UINT64 },
  82         { "prdequeued", FMD_TYPE_UINT64 },
  83         { "accepted", FMD_TYPE_UINT64 },
  84         { "memtotal", FMD_TYPE_SIZE },
  85         { "buftotal", FMD_TYPE_SIZE },
  86         { "caseopen", FMD_TYPE_UINT64 },
  87         { "casesolved", FMD_TYPE_UINT64 },
  88         { "wcnt", FMD_TYPE_UINT32 },
  89         { "wtime", FMD_TYPE_TIME },
  90         { "wlentime", FMD_TYPE_TIME },
  91         { "wlastupdate", FMD_TYPE_TIME },
  92         { "dtime", FMD_TYPE_TIME },
  93         { "dlastupdate", FMD_TYPE_TIME },
  94 };
  95
  96 static const char *g_pname;
  97 static fmd_adm_t *g_adm;
  98
  99 static struct modstats {
 100         char *m_name;
 101         struct modstats *m_next;
 102         struct stats m_stbuf[2];
 103         int m_stidx;
 104         int m_id;
 105         struct stats *m_old;
 106         struct stats *m_new;
 107         double m_wait;
 108         double m_svc;
 109         double m_pct_b;
 110         double m_pct_w;
 111 } *g_mods;
 112
 113 static uint_t timestamp_fmt = NODATE;
 114
 115 #if !defined(TEXT_DOMAIN)               /* Should be defined by cc -D */
 116 #define TEXT_DOMAIN "SYS_TEST"          /* Use this only if it isn't */
 117 #endif
 118
 119 static void
 120 vwarn(const char *format, va_list ap)
 121 {
 122         int err = errno;
 123
 124         (void) fprintf(stderr, "%s: ", g_pname);
 125
 126         if (format != NULL)
 127                 (void) vfprintf(stderr, format, ap);
 128
 129         errno = err; /* restore errno for fmd_adm_errmsg() */
 130
 131         if (format == NULL)
 132                 (void) fprintf(stderr, "%s\n", fmd_adm_errmsg(g_adm));
 133         else if (strchr(format, '\n') == NULL)
 134                 (void) fprintf(stderr, ": %s\n", fmd_adm_errmsg(g_adm));
 135 }
 136
 137 /*PRINTFLIKE1*/
 138 void
 139 warn(const char *format, ...)
 140 {
 141         va_list ap;
 142
 143         va_start(ap, format);
 144         vwarn(format, ap);
 145         va_end(ap);
 146 }
 147
 148 /*PRINTFLIKE1*/
 149 void
 150 die(const char *format, ...)
 151 {
 152         va_list ap;
 153
 154         va_start(ap, format);
 155         vwarn(format, ap);
 156         va_end(ap);
 157
 158         fmd_adm_close(g_adm);
 159         exit(FMSTAT_EXIT_ERROR);
 160 }
 161
 162 static char *
 163 time2str(char *buf, size_t len, uint64_t time)
 164 {
 165         static const struct unit {
 166                 const char *u_name;
 167                 hrtime_t u_mul;
 168         } units[] = {
 169                 { "d",  NANOSEC * (hrtime_t)(24 * 60 * 60) },
 170                 { "h",  NANOSEC * (hrtime_t)(60 * 60) },
 171                 { "m",  NANOSEC * (hrtime_t)60 },
 172                 { "s",  NANOSEC / SEC },
 173                 { "ms", NANOSEC / MILLISEC },
 174                 { "us", NANOSEC / MICROSEC },
 175                 { "ns", NANOSEC / NANOSEC },
 176         };
 177
 178         const struct unit *up;
 179
 180         for (up = units; time % up->u_mul != 0; up++)
 181                 continue; /* find largest unit of which 'time' is a multiple */
 182
 183         (void) snprintf(buf, len, "%llu%s", time / up->u_mul, up->u_name);
 184         return (buf);
 185 }
 186
 187 static char *
 188 size2str(char *buf, size_t len, uint64_t size)
 189 {
 190         static const char units[] = "bKMGTPE";
 191         const uint64_t scale = 1024;
 192         const char *up = units;
 193         uint64_t osize = 0;
 194
 195         /*
 196          * Convert the input size to a round number of the appropriately
 197          * scaled units (saved in 'size') and a remainder (saved in 'osize').
 198          */
 199         while (size >= scale && up < (units + sizeof (units) - 2)) {
 200                 up++;
 201                 osize = size;
 202                 size = (size + (scale / 2)) / scale;
 203         }
 204
 205         /*
 206          * Format the result using at most one decimal place and the unit
 207          * depending upon the amount of remainder (same as df -h algorithm).
 208          */
 209         if (osize != 0 && (osize / scale) < 10)
 210                 (void) snprintf(buf, len, "%.1f%c", (float)osize / scale, *up);
 211         else if (size != 0)
 212                 (void) snprintf(buf, len, "%llu%c", size, *up);
 213         else
 214                 (void) snprintf(buf, len, "0");
 215
 216         return (buf);
 217 }
 218
 219 static uint64_t
 220 u64delta(uint64_t old, uint64_t new)
 221 {
 222         return (new >= old ? (new - old) : ((UINT64_MAX - old) + new + 1));
 223 }
 224
 225 static struct modstats *
 226 modstat_create(const char *name, id_t id)
 227 {
 228         struct modstats *mp = malloc(sizeof (struct modstats));
 229
 230         if (mp == NULL)
 231                 return (NULL);
 232
 233         bzero(mp, sizeof (struct modstats));
 234
 235         if (name != NULL && (mp->m_name = strdup(name)) == NULL) {
 236                 free(mp);
 237                 return (NULL);
 238         }
 239
 240         mp->m_id = id;
 241         mp->m_next = g_mods;
 242         g_mods = mp;
 243         return (mp);
 244 }
 245
 246 /*
 247  * Given a statistics buffer containing event queue statistics, compute the
 248  * common queue statistics for the given module and store the results in 'mp'.
 249  * We set m_new and m_old for the caller, and store the compute values of
 250  * m_svc, m_wait, m_pct_w, and m_pct_b there as well.  The caller must not free
 251  * 'ams' until after using the results as m_new may contain pointers to it.
 252  */
 253 static void
 254 modstat_compute(struct modstats *mp, fmd_adm_stats_t *ams)
 255 {
 256         static fmd_stat_t *t_beg = (fmd_stat_t *)(&stats_template + 0);
 257         static fmd_stat_t *t_end = (fmd_stat_t *)(&stats_template + 1);
 258
 259         struct stats *old, *new;
 260         fmd_stat_t *tsp, *nsp, *sp;
 261         double elapsed, avg_w, avg_d;
 262         uint64_t delta;
 263
 264         old = mp->m_old = &mp->m_stbuf[mp->m_stidx];
 265         mp->m_stidx = 1 - mp->m_stidx;
 266         new = mp->m_new = &mp->m_stbuf[mp->m_stidx];
 267
 268         /*
 269          * The statistics can come in any order; we compare each one to the
 270          * template of statistics of interest, find the matching ones, and copy
 271          * their values into the appropriate slot of the 'new' stats.
 272          */
 273         for (nsp = ams->ams_buf; nsp < ams->ams_buf + ams->ams_len; nsp++) {
 274                 for (tsp = t_beg; tsp < t_end; tsp++) {
 275                         const char *p = strrchr(nsp->fmds_name, '.');
 276
 277                         /*
 278                          * The fmd queue stats can either be named fmd.<name>
 279                          * or fmd.xprt.%u.<name> depending on whether we're
 280                          * looking at the module queue or the transport queue.
 281                          * So we match using the patterns fmd.* and *.<name>
 282                          * and store only the value of <name> in stats_template.
 283                          */
 284                         if (p == NULL || strcmp(p + 1, tsp->fmds_name) != 0 ||
 285                             strncmp(nsp->fmds_name, "fmd.", 4) != 0)
 286                                 continue; /* continue until we match the stat */
 287
 288                         if (tsp->fmds_type != nsp->fmds_type) {
 289                                 warn("%s has unexpected type (%u != %u)\n",
 290                                     nsp->fmds_name, tsp->fmds_type,
 291                                     nsp->fmds_type);
 292                         } else {
 293                                 sp = (fmd_stat_t *)new + (tsp - t_beg);
 294                                 sp->fmds_value = nsp->fmds_value;
 295                         }
 296                 }
 297         }
 298
 299         /*
 300          * Compute the elapsed time by taking the delta between 'snaptime', or
 301          * or between snaptime and loadtime if there is no previous snapshot.
 302          * If delta is zero, set it to 1sec so we don't divide by zero later.
 303          */
 304         delta = u64delta(old->snaptime.fmds_value.ui64 ?
 305             old->snaptime.fmds_value.ui64 : old->loadtime.fmds_value.ui64,
 306             new->snaptime.fmds_value.ui64);
 307
 308         elapsed = delta ? (double)delta : (double)NANOSEC;
 309
 310         /*
 311          * Compute average wait queue len by taking the delta in the wait queue
 312          * len * time products (wlentime stat) and dividing by the elapsed time.
 313          */
 314         delta = u64delta(old->wlentime.fmds_value.ui64,
 315             new->wlentime.fmds_value.ui64);
 316
 317         if (delta != 0)
 318                 mp->m_wait = (double)delta / elapsed;
 319         else
 320                 mp->m_wait = 0.0;
 321
 322         /*
 323          * Compute average wait time by taking the delta in the wait queue time
 324          * (wtime) and dividing by the delta in the number of dispatches.
 325          */
 326         delta = u64delta(old->dispatched.fmds_value.ui64,
 327             new->dispatched.fmds_value.ui64);
 328
 329         if (delta != 0) {
 330                 avg_w = (double)u64delta(old->wtime.fmds_value.ui64,
 331                     new->wtime.fmds_value.ui64) / (double)delta;
 332         } else
 333                 avg_w = 0.0;
 334
 335         /*
 336          * Compute average dispatch time by taking the delta in the dispatch
 337          * time (dtime) and dividing by the delta in the number of dequeues.
 338          */
 339         delta = u64delta(old->dequeued.fmds_value.ui64,
 340             new->dequeued.fmds_value.ui64);
 341
 342         if (delta != 0) {
 343                 avg_d = (double)u64delta(old->dtime.fmds_value.ui64,
 344                     new->dtime.fmds_value.ui64) / (double)delta;
 345         } else
 346                 avg_d = 0.0;
 347
 348         /*
 349          * Finally compute the average overall service time by adding together
 350          * the average wait and dispatch times and converting to milliseconds.
 351          */
 352         mp->m_svc = ((avg_w + avg_d) * (double)MILLISEC) / (double)NANOSEC;
 353
 354         /*
 355          * Compute the %wait and %busy times by taking the delta in wait and
 356          * busy times, dividing by the elapsed time, and multiplying by 100.
 357          */
 358         delta = u64delta(old->wtime.fmds_value.ui64,
 359             new->wtime.fmds_value.ui64);
 360
 361         if (delta != 0)
 362                 mp->m_pct_w = ((double)delta / elapsed) * 100.0;
 363         else
 364                 mp->m_pct_w = 0.0;
 365
 366         delta = u64delta(old->dtime.fmds_value.ui64,
 367             new->dtime.fmds_value.ui64);
 368
 369         if (delta != 0)
 370                 mp->m_pct_b = ((double)delta / elapsed) * 100.0;
 371         else
 372                 mp->m_pct_b = 0.0;
 373 }
 374
 375 /*ARGSUSED*/
 376 static int
 377 stat_one_xprt(id_t id, void *ignored)
 378 {
 379         fmd_adm_stats_t ams;
 380         struct modstats *mp;
 381
 382         if (fmd_adm_xprt_stats(g_adm, id, &ams) != 0) {
 383                 warn("failed to retrieve statistics for transport %d", (int)id);
 384                 return (0); /* continue on to the next transport */
 385         }
 386
 387         for (mp = g_mods; mp != NULL; mp = mp->m_next) {
 388                 if (mp->m_id == id)
 389                         break;
 390         }
 391
 392         if (mp == NULL && (mp = modstat_create(NULL, id)) == NULL) {
 393                 warn("failed to allocate memory for transport %d", (int)id);
 394                 (void) fmd_adm_stats_free(g_adm, &ams);
 395                 return (0);
 396         }
 397
 398         modstat_compute(mp, &ams);
 399
 400         (void) printf("%3d %5s %7llu %7llu %7llu %7llu "
 401             "%4.1f %6.1f %3.0f %3.0f %s\n", (int)id,
 402             mp->m_new->state.fmds_value.str,
 403             u64delta(mp->m_old->prdequeued.fmds_value.ui64,
 404             mp->m_new->prdequeued.fmds_value.ui64),
 405             u64delta(mp->m_old->received.fmds_value.ui64,
 406             mp->m_new->received.fmds_value.ui64),
 407             u64delta(mp->m_old->discarded.fmds_value.ui64,
 408             mp->m_new->discarded.fmds_value.ui64),
 409             u64delta(mp->m_old->lost.fmds_value.ui64,
 410             mp->m_new->lost.fmds_value.ui64),
 411             mp->m_wait, mp->m_svc, mp->m_pct_w, mp->m_pct_b,
 412             mp->m_new->module.fmds_value.str);
 413
 414         (void) fmd_adm_stats_free(g_adm, &ams);
 415         return (0);
 416 }
 417
 418 static void
 419 stat_xprt(void)
 420 {
 421         (void) printf("%3s %5s %7s %7s %7s %7s %4s %6s %3s %3s %s\n",
 422             "id", "state", "ev_send", "ev_recv", "ev_drop", "ev_lost",
 423             "wait", "svc_t", "%w", "%b", "module");
 424
 425         if (fmd_adm_xprt_iter(g_adm, stat_one_xprt, NULL) != 0)
 426                 die("failed to retrieve list of transports");
 427 }
 428
 429 static int
 430 stat_one_xprt_auth(id_t id, void *arg)
 431 {
 432         const char *module = arg;
 433         fmd_adm_stats_t ams;
 434         struct modstats *mp;
 435
 436         if (fmd_adm_xprt_stats(g_adm, id, &ams) != 0) {
 437                 warn("failed to retrieve statistics for transport %d", (int)id);
 438                 return (0); /* continue on to the next transport */
 439         }
 440
 441         for (mp = g_mods; mp != NULL; mp = mp->m_next) {
 442                 if (mp->m_id == id)
 443                         break;
 444         }
 445
 446         if (mp == NULL && (mp = modstat_create(NULL, id)) == NULL) {
 447                 warn("failed to allocate memory for transport %d", (int)id);
 448                 (void) fmd_adm_stats_free(g_adm, &ams);
 449                 return (0);
 450         }
 451
 452         modstat_compute(mp, &ams);
 453
 454         if (module == NULL ||
 455             strcmp(module, mp->m_new->module.fmds_value.str) == 0) {
 456                 (void) printf("%3d %5s %-18s  %s\n", (int)id,
 457                     mp->m_new->state.fmds_value.str,
 458                     mp->m_new->module.fmds_value.str,
 459                     mp->m_new->authority.fmds_value.str ?
 460                     mp->m_new->authority.fmds_value.str : "-");
 461         }
 462
 463         (void) fmd_adm_stats_free(g_adm, &ams);
 464         return (0);
 465 }
 466
 467 static void
 468 stat_xprt_auth(const char *module)
 469 {
 470         (void) printf("%3s %5s %-18s  %s\n",
 471             "id", "state", "module", "authority");
 472
 473         if (fmd_adm_xprt_iter(g_adm, stat_one_xprt_auth, (void *)module) != 0)
 474                 die("failed to retrieve list of transports");
 475 }
 476
 477 /*ARGSUSED*/
 478 static int
 479 stat_one_fmd(const fmd_adm_modinfo_t *ami, void *ignored)
 480 {
 481         char memsz[8], bufsz[8];
 482         fmd_adm_stats_t ams;
 483         struct modstats *mp;
 484
 485         if (fmd_adm_module_stats(g_adm, ami->ami_name, &ams) != 0) {
 486                 warn("failed to retrieve statistics for %s", ami->ami_name);
 487                 return (0); /* continue on to the next module */
 488         }
 489
 490         for (mp = g_mods; mp != NULL; mp = mp->m_next) {
 491                 if (strcmp(mp->m_name, ami->ami_name) == 0)
 492                         break;
 493         }
 494
 495         if (mp == NULL && (mp = modstat_create(ami->ami_name, 0)) == NULL) {
 496                 warn("failed to allocate memory for %s", ami->ami_name);
 497                 (void) fmd_adm_stats_free(g_adm, &ams);
 498                 return (0);
 499         }
 500
 501         modstat_compute(mp, &ams);
 502
 503         (void) printf("%-18s %7llu %7llu %4.1f %6.1f %3.0f %3.0f "
 504             "%5llu %5llu %6s %6s\n", ami->ami_name,
 505             u64delta(mp->m_old->prdequeued.fmds_value.ui64,
 506             mp->m_new->prdequeued.fmds_value.ui64),
 507             u64delta(mp->m_old->accepted.fmds_value.ui64,
 508             mp->m_new->accepted.fmds_value.ui64),
 509             mp->m_wait, mp->m_svc, mp->m_pct_w, mp->m_pct_b,
 510             mp->m_new->caseopen.fmds_value.ui64,
 511             mp->m_new->casesolved.fmds_value.ui64,
 512             size2str(memsz, sizeof (memsz),
 513             mp->m_new->memtotal.fmds_value.ui64),
 514             size2str(bufsz, sizeof (bufsz),
 515             mp->m_new->buftotal.fmds_value.ui64));
 516
 517         (void) fmd_adm_stats_free(g_adm, &ams);
 518         return (0);
 519 }
 520
 521 static void
 522 stat_fmd(void)
 523 {
 524         (void) printf("%-18s %7s %7s %4s %6s %3s %3s %5s %5s %6s %6s\n",
 525             "module", "ev_recv", "ev_acpt", "wait", "svc_t", "%w", "%b",
 526             "open", "solve", "memsz", "bufsz");
 527
 528         if (fmd_adm_module_iter(g_adm, stat_one_fmd, NULL) != 0)
 529                 die("failed to retrieve list of modules");
 530 }
 531
 532 static void
 533 stat_mod(const char *name, int aflag, int zflag)
 534 {
 535         fmd_adm_stats_t ams;
 536         fmd_stat_t *sp;
 537         char buf[64];
 538
 539         if (fmd_adm_stats_read(g_adm, name, &ams) != 0) {
 540                 die("failed to retrieve statistics for %s",
 541                     name ? name : "fmd(1M)");
 542         }
 543
 544         (void) printf("%20s %-16s %s\n", "NAME", "VALUE", "DESCRIPTION");
 545
 546         for (sp = ams.ams_buf; sp < ams.ams_buf + ams.ams_len; sp++) {
 547                 if (aflag == 0 && strncmp(sp->fmds_name, "fmd.", 4) == 0)
 548                         continue; /* skip fmd-internal stats unless -a used */
 549
 550                 if (zflag) {
 551                         switch (sp->fmds_type) {
 552                         case FMD_TYPE_INT32:
 553                         case FMD_TYPE_UINT32:
 554                                 if (sp->fmds_value.ui32 == 0)
 555                                         continue;
 556                                 break;
 557                         case FMD_TYPE_INT64:
 558                         case FMD_TYPE_UINT64:
 559                         case FMD_TYPE_TIME:
 560                         case FMD_TYPE_SIZE:
 561                                 if (sp->fmds_value.ui64 == 0)
 562                                         continue;
 563                                 break;
 564                         case FMD_TYPE_STRING:
 565                                 if (sp->fmds_value.str == NULL ||
 566                                     sp->fmds_value.str[0] == '\0')
 567                                         continue;
 568                                 break;
 569                         }
 570                 }
 571
 572                 (void) printf("%20s ", sp->fmds_name);
 573
 574                 switch (sp->fmds_type) {
 575                 case FMD_TYPE_BOOL:
 576                         (void) printf("%-16s",
 577                             sp->fmds_value.b ? "true" : "false");
 578                         break;
 579                 case FMD_TYPE_INT32:
 580                         (void) printf("%-16d", sp->fmds_value.i32);
 581                         break;
 582                 case FMD_TYPE_UINT32:
 583                         (void) printf("%-16u", sp->fmds_value.ui32);
 584                         break;
 585                 case FMD_TYPE_INT64:
 586                         (void) printf("%-16lld", sp->fmds_value.i64);
 587                         break;
 588                 case FMD_TYPE_UINT64:
 589                         (void) printf("%-16llu", sp->fmds_value.ui64);
 590                         break;
 591                 case FMD_TYPE_STRING:
 592                         (void) printf("%-16s", sp->fmds_value.str ?
 593                             sp->fmds_value.str : "<<null>>");
 594                         break;
 595                 case FMD_TYPE_TIME:
 596                         (void) printf("%-16s",
 597                             time2str(buf, sizeof (buf), sp->fmds_value.ui64));
 598                         break;
 599                 case FMD_TYPE_SIZE:
 600                         (void) printf("%-16s",
 601                             size2str(buf, sizeof (buf), sp->fmds_value.ui64));
 602                         break;
 603                 default:
 604                         (void) snprintf(buf, sizeof (buf),
 605                             "<<type=%u>>\n", sp->fmds_type);
 606                         (void) printf("%-16s", buf);
 607                 }
 608
 609                 (void) printf(" %s\n", sp->fmds_desc);
 610         }
 611
 612         (void) fmd_adm_stats_free(g_adm, &ams);
 613 }
 614
 615 /*ARGSUSED*/
 616 static int
 617 stat_one_serd(const fmd_adm_serdinfo_t *asi, void *ignored)
 618 {
 619         char buf1[32], buf2[32], n[32];
 620
 621         (void) snprintf(n, sizeof (n), ">%llu", asi->asi_n);
 622
 623         (void) printf("%-36s %3s %5s %3u %24s %s\n",
 624             asi->asi_name, n, time2str(buf1, sizeof (buf1), asi->asi_t),
 625             asi->asi_count, time2str(buf2, sizeof (buf2), asi->asi_delta),
 626             (asi->asi_flags & FMD_ADM_SERD_FIRED) ? "fire" : "pend");
 627
 628         return (0);
 629 }
 630
 631 static void
 632 stat_mod_serd(const char *name)
 633 {
 634         (void) printf("%-36s %3s %5s %3s %24s %4s\n",
 635             "NAME", ">N", "T", "CNT", "DELTA", "STAT");
 636
 637         if (fmd_adm_serd_iter(g_adm, name, stat_one_serd, NULL) != 0)
 638                 die("failed to retrieve serd engines for %s", name);
 639 }
 640
 641 static int
 642 getint(const char *name, const char *s)
 643 {
 644         long val;
 645         char *p;
 646
 647         errno = 0;
 648         val = strtol(s, &p, 10);
 649
 650         if (errno != 0 || p == s || *p != '\0' || val < 0 || val > INT_MAX) {
 651                 (void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
 652                     g_pname, name, s);
 653                 exit(FMSTAT_EXIT_USAGE);
 654         }
 655
 656         return ((int)val);
 657 }
 658
 659 static uint32_t
 660 getu32(const char *name, const char *s)
 661 {
 662         u_longlong_t val;
 663         char *p;
 664
 665         errno = 0;
 666         val = strtoull(s, &p, 0);
 667
 668         if (errno != 0 || p == s || *p != '\0' || val > UINT32_MAX) {
 669                 (void) fprintf(stderr, "%s: invalid %s argument -- %s\n",
 670                     g_pname, name, s);
 671                 exit(FMSTAT_EXIT_USAGE);
 672         }
 673
 674         return ((uint32_t)val);
 675 }
 676
 677 static int
 678 usage(FILE *fp)
 679 {
 680         (void) fprintf(fp, "Usage: %s [-astTz] [-m module] "
 681             "[-P prog] [-d d|u] [interval [count]]\n\n", g_pname);
 682
 683         (void) fprintf(fp,
 684             "\t-a show all statistics, including those kept by fmd\n"
 685             "\t-d display a timestamp in date (d) or unix time_t (u)\n"
 686             "\t-m show module-specific statistics\n"
 687             "\t-P connect to alternate fmd program\n"
 688             "\t-s show module-specific serd engines\n"
 689             "\t-t show transport-specific statistics\n"
 690             "\t-T show transport modules and authorities\n"
 691             "\t-z suppress zero-valued statistics\n");
 692
 693         return (FMSTAT_EXIT_USAGE);
 694 }
 695
 696 int
 697 main(int argc, char *argv[])
 698 {
 699         int opt_a = 0, opt_s = 0, opt_t = 0, opt_T = 0, opt_z = 0;
 700         const char *opt_m = NULL;
 701         int msec = 0, iter = 1;
 702
 703         uint32_t program;
 704         char *p;
 705         int c;
 706
 707         if ((p = strrchr(argv[0], '/')) == NULL)
 708                 g_pname = argv[0];
 709         else
 710                 g_pname = p + 1;
 711
 712         if ((p = getenv("FMD_PROGRAM")) != NULL)
 713                 program = getu32("$FMD_PROGRAM", p);
 714         else
 715                 program = FMD_ADM_PROGRAM;
 716
 717         (void) setlocale(LC_ALL, "");
 718         (void) textdomain(TEXT_DOMAIN);
 719
 720         while ((c = getopt(argc, argv, "ad:m:P:stTz")) != EOF) {
 721                 switch (c) {
 722                 case 'a':
 723                         opt_a++;
 724                         break;
 725                 case 'd':
 726                         if (optarg) {
 727                                 if (*optarg == 'u')
 728                                         timestamp_fmt = UDATE;
 729                                 else if (*optarg == 'd')
 730                                         timestamp_fmt = DDATE;
 731                                 else
 732                                         return (usage(stderr));
 733                         } else {
 734                                 return (usage(stderr));
 735                         }
 736                         break;
 737                 case 'm':
 738                         opt_m = optarg;
 739                         break;
 740                 case 'P':
 741                         program = getu32("program", optarg);
 742                         break;
 743                 case 's':
 744                         opt_s++;
 745                         break;
 746                 case 't':
 747                         opt_t++;
 748                         break;
 749                 case 'T':
 750                         opt_T++;
 751                         break;
 752                 case 'z':
 753                         opt_z++;
 754                         break;
 755                 default:
 756                         return (usage(stderr));
 757                 }
 758         }
 759
 760         if (optind < argc) {
 761                 msec = getint("interval", argv[optind++]) * MILLISEC;
 762                 iter = -1;
 763         }
 764
 765         if (optind < argc)
 766                 iter = getint("count", argv[optind++]);
 767
 768         if (optind < argc)
 769                 return (usage(stderr));
 770
 771         if (opt_t != 0 && (opt_m != NULL || opt_s != 0)) {
 772                 (void) fprintf(stderr,
 773                     "%s: -t cannot be used with -m or -s\n", g_pname);
 774                 return (FMSTAT_EXIT_USAGE);
 775         }
 776
 777         if (opt_t != 0 && opt_T != 0) {
 778                 (void) fprintf(stderr,
 779                     "%s: -t and -T are mutually exclusive options\n", g_pname);
 780                 return (FMSTAT_EXIT_USAGE);
 781         }
 782
 783         if (opt_m == NULL && opt_s != 0) {
 784                 (void) fprintf(stderr,
 785                     "%s: -s requires -m <module>\n", g_pname);
 786                 return (FMSTAT_EXIT_USAGE);
 787         }
 788
 789         if ((g_adm = fmd_adm_open(NULL, program, FMD_ADM_VERSION)) == NULL)
 790                 die(NULL); /* fmd_adm_errmsg() has enough info */
 791
 792         while (iter < 0 || iter-- > 0) {
 793                 if (timestamp_fmt != NODATE)
 794                         print_timestamp(timestamp_fmt);
 795                 if (opt_s)
 796                         stat_mod_serd(opt_m);
 797                 else if (opt_T)
 798                         stat_xprt_auth(opt_m);
 799                 else if (opt_a || opt_m)
 800                         stat_mod(opt_m, opt_a, opt_z);
 801                 else if (opt_t)
 802                         stat_xprt();
 803                 else
 804                         stat_fmd();
 805
 806                 if (iter != 0) {
 807                         (void) poll(NULL, 0, msec);
 808                         (void) putchar('\n');
 809                 }
 810         }
 811
 812         fmd_adm_close(g_adm);
 813         return (FMSTAT_EXIT_SUCCESS);
 814 }