usr/src/cmd/avs/dsstat/report.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  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <kstat.h>
  30 #include <sys/inttypes.h>
  31
  32 #include <nsctl.h>
  33
  34 #include "dsstat.h"
  35 #include "common.h"
  36
  37 #include "sdbc_stats.h"
  38 #include "report.h"
  39
  40 extern short dflags;
  41
  42 /*
  43  * Return the number of ticks delta between two hrtime_t
  44  * values. Attempt to cater for various kinds of overflow
  45  * in hrtime_t - no matter how improbable.
  46  */
  47 uint64_t
  48 hrtime_delta(hrtime_t old, hrtime_t new)
  49 {
  50
  51         uint64_t del;
  52
  53         if ((new >= old) && (old >= 0L)) {
  54                 return (new - old);
  55         } else {
  56                 /*
  57                  * We've overflowed the positive portion of an
  58                  * hrtime_t.
  59                  */
  60                 if (new < 0L) {
  61                         /*
  62                          * The new value is negative. Handle the
  63                          * case where the old value is positive or
  64                          * negative.
  65                          */
  66                         uint64_t n1;
  67                         uint64_t o1;
  68
  69                         n1 = -new;
  70
  71                         if (old > 0L) {
  72                                 return (n1 - old);
  73                         } else {
  74                                 o1 = -old;
  75                                 del = n1 - o1;
  76                                 return (del);
  77                         }
  78                 } else {
  79                         /*
  80                          * Either we've just gone from being negative
  81                          * to positive *or* the last entry was positive
  82                          * and the new entry is also positive but *less*
  83                          * than the old entry. This implies we waited
  84                          * quite a few days on a very fast system between
  85                          * iostat displays.
  86                          */
  87                         if (old < 0L) {
  88                                 uint64_t o2;
  89
  90                                 o2 = -old;
  91                                 del = UINT64_MAX - o2;
  92                         } else {
  93                                 del = UINT64_MAX - old;
  94                         }
  95
  96                         del += new;
  97
  98                         return (del);
  99                 }
 100         }
 101 }
 102
 103 /*
 104  * Take the difference of an unsigned 32
 105  * bit int attempting to cater for
 106  * overflow.
 107  */
 108 uint32_t
 109 u32_delta(uint32_t old, uint32_t new)
 110 {
 111
 112         if (new >= old)
 113                 return (new - old);
 114         else
 115                 return ((UINT32_MAX - old) + new + 1);
 116 }
 117
 118 /*
 119  * Take the difference of an unsigned 64
 120  * bit int attempting to cater for
 121  * overflow.
 122  */
 123 uint64_t
 124 u64_delta(uint64_t old, uint64_t new)
 125 {
 126
 127         if (new >= old)
 128                 return (new - old);
 129         else
 130                 return ((UINT64_MAX - old) + new + 1);
 131 }
 132
 133 /*
 134  * io_report() - diffs and reports data contained in
 135  * kstat_io_t structures.
 136  *
 137  * parameters
 138  *      kstat_io_t *cur - pointer to current data
 139  *
 140  *      kstat_io_t *pre - pointer to data as it was
 141  *      at the beginning of an interval.
 142  */
 143 void
 144 io_report(kstat_t *cur_kstat, kstat_t *pre_kstat, sdbcstat_t *sdbcstat)
 145 {
 146         sdbcvals_t vals;
 147
 148         double rd_cnt, wr_cnt;
 149         double rd_kb, wr_kb, hr_etime;
 150
 151         double rtm, tps, avs, etime;
 152
 153         kstat_io_t *cur = cur_kstat->ks_data;
 154         kstat_io_t *pre = pre_kstat->ks_data;
 155
 156         if (sdbcstat &&
 157             sdbc_getvalues(sdbcstat, &vals, (SDBC_KBYTES | SDBC_INTAVG)))
 158                 return;
 159
 160         /* Time */
 161         hr_etime = hrtime_delta(pre_kstat->ks_snaptime, cur_kstat->ks_snaptime);
 162         etime = hr_etime / (double)NANOSEC;
 163
 164         /* Read count */
 165         rd_cnt = (double)u32_delta(pre->reads, cur->reads);
 166         if (rd_cnt) rd_cnt /= etime;
 167
 168         /* Bytes read */
 169         rd_kb = (double)u64_delta(pre->nread, cur->nread) / KILOBYTE;
 170         if (rd_kb) rd_kb /= etime;
 171
 172         /* Write count    */
 173         wr_cnt = (double)u32_delta(pre->writes, cur->writes);
 174         if (wr_cnt) wr_cnt /= etime;
 175
 176         /* Bytes written  */
 177         wr_kb = (double)u64_delta(pre->nwritten, cur->nwritten) / KILOBYTE;
 178         if (wr_kb) wr_kb /= etime;
 179
 180         /* Calculate service times */
 181         avs = (double)hrtime_delta(pre->rlentime, cur->rlentime) / hr_etime;
 182         tps = (double)rd_cnt + wr_cnt;
 183
 184         if (tps > 0)
 185                 rtm = (1000 / tps) * avs;
 186         else
 187                 rtm = 0.0;
 188
 189         /* Output */
 190         if (dflags & SUMMARY) {
 191                 if ((mode & MULTI) && (mode & SDBC)) {
 192                         if (sdbcstat) {
 193                                 (void) printf(KPS_INF_FMT,
 194                                     (float)vals.total_cache);
 195                                 (void) printf(KPS_INF_FMT,
 196                                     (float)vals.total_disk);
 197                         } else {
 198                                 (void) printf(DATA_C6, NO_INFO);
 199                                 (void) printf(KPS_INF_FMT, rd_kb + wr_kb);
 200                         }
 201                 } else
 202                         (void) printf(KPS_INF_FMT, rd_kb + wr_kb);
 203
 204                 (void) printf(TPS_INF_FMT, (uint32_t)(rd_cnt + wr_cnt));
 205                 (void) printf(SVT_INF_FMT, rtm);
 206
 207                 goto done;
 208         }
 209
 210         if (dflags & READ) {
 211                 if ((mode & MULTI) && (mode & SDBC)) {
 212                         if (sdbcstat) {
 213                                 (void) printf(KPS_INF_FMT,
 214                                     (float)vals.cache_read);
 215                                 (void) printf(KPS_INF_FMT,
 216                                     (float)vals.disk_read);
 217                         } else {
 218                                 (void) printf(DATA_C6, NO_INFO);
 219                                 (void) printf(KPS_INF_FMT, rd_kb);
 220                         }
 221
 222                 } else
 223                         (void) printf(KPS_INF_FMT, rd_kb);
 224
 225                 (void) printf(TPS_INF_FMT, (uint32_t)rd_cnt);
 226         }
 227
 228         if (dflags & WRITE) {
 229                 if ((mode & MULTI) && (mode & SDBC)) {
 230                         if (sdbcstat) {
 231                                 (void) printf(KPS_INF_FMT,
 232                                     (float)vals.cache_write);
 233                                 (void) printf(KPS_INF_FMT,
 234                                     (float)vals.disk_write);
 235                         } else {
 236                                 (void) printf(DATA_C6, NO_INFO);
 237                                 (void) printf(KPS_INF_FMT, wr_kb);
 238                         }
 239
 240                 } else
 241                         (void) printf(KPS_INF_FMT, wr_kb);
 242
 243                 (void) printf(TPS_INF_FMT, (uint32_t)wr_cnt);
 244         }
 245
 246         if (dflags & TIMING) {
 247                 (void) printf(SVT_INF_FMT, rtm);
 248         }
 249
 250 done:
 251         linesout++;
 252 }
 253
 254 int
 255 io_value_check(kstat_io_t *pre, kstat_io_t *cur)
 256 {
 257         if (u32_delta(pre->reads, cur->reads))
 258                 return (1);
 259         if (u32_delta(pre->writes, cur->writes))
 260                 return (1);
 261
 262         return (0);
 263 }
 264
 265 /*
 266  * cd_report() - reports cache desriptor related statistics
 267  * based on the dflags global variable
 268  *
 269  * parameters
 270  *      sdbcstat_t *sdbcstat - pointer to the cache structure
 271  *      to be reported on.
 272  */
 273 void
 274 cd_report(sdbcstat_t *sdbcstat)
 275 {
 276         sdbcvals_t vals;
 277
 278         /* Extract statistics, average for time */
 279         if (sdbc_getvalues(sdbcstat, &vals, (SDBC_KBYTES | SDBC_INTAVG)))
 280                 return;
 281
 282         /* Output */
 283         if (rflags & MULTI) {
 284                 (void) printf(VOL_HDR_FMT, "");
 285
 286                 if (dflags & FLAGS) {
 287                         (void) printf(STAT_HDR_FMT, "");
 288                         (void) printf(STAT_HDR_FMT, "");
 289                 }
 290
 291                 if (dflags & PCTS)
 292                         (void) printf(PCT_HDR_FMT, "");
 293
 294                 if (dflags & SUMMARY) {
 295                         (void) printf(KPS_INF_FMT, (float)vals.total_cache);
 296                         (void) printf(DATA_C4, NO_INFO);
 297                         (void) printf(DATA_C4, NO_INFO);
 298                         (void) printf("\n");
 299                         linesout++;
 300                         return;
 301                 }
 302
 303                 if (dflags & READ) {
 304                         (void) printf(KPS_INF_FMT, (float)vals.cache_read);
 305                         (void) printf(DATA_C4, NO_INFO);
 306                 }
 307
 308                 if (dflags & WRITE) {
 309                         (void) printf(KPS_INF_FMT, (float)vals.cache_write);
 310                         (void) printf(DATA_C4, NO_INFO);
 311                 }
 312
 313                 if (dflags & TIMING) {
 314                         (void) printf(DATA_C4, NO_INFO);
 315                 }
 316
 317                 linesout++;
 318                 (void) printf("\n");
 319                 return;
 320         }
 321
 322         if (dflags & SUMMARY) {
 323                 (void) printf(DATA_I32, vals.total_cache);
 324                 (void) printf(DATA_I32, vals.total_disk);
 325                 (void) printf(HIT_INF_FMT, vals.cache_hit);
 326
 327                 linesout++;
 328                 (void) printf("\n");
 329                 return;
 330         }
 331
 332         if (dflags & READ) {
 333                 (void) printf(DATA_I32, vals.cache_read);
 334                 (void) printf(DATA_I32, vals.disk_read);
 335                 (void) printf(HIT_INF_FMT, vals.read_hit);
 336         }
 337
 338         if (dflags & WRITE) {
 339                 (void) printf(DATA_I32, vals.cache_write);
 340                 (void) printf(DATA_I32, vals.disk_write);
 341                 (void) printf(HIT_INF_FMT, vals.write_hit);
 342         }
 343
 344         if (dflags & DESTAGED)
 345                 (void) printf(DATA_I32, vals.destaged);
 346
 347         if (dflags & WRCANCEL)
 348                 (void) printf(DATA_I32, vals.write_cancellations);
 349
 350         linesout++;
 351         (void) printf("\n");
 352 }
 353
 354 /*
 355  * header() - outputs an appropriate header by referencing the
 356  * global variables dflsgs and rflags
 357  *
 358  */
 359 void
 360 header()
 361 {
 362         if (hflags & HEADERS_EXL)
 363                 if ((linesout % DISPLAY_LINES) != 0)
 364                         return;
 365
 366         if (hflags & HEADERS_BOR)
 367                 if (linesout != 0)
 368                         return;
 369
 370         if (hflags & HEADERS_ATT)
 371                 if (hflags & HEADERS_OUT)
 372                         return;
 373                 else
 374                         hflags |= HEADERS_OUT;
 375
 376         if (linesout)
 377                 (void) printf("\n");
 378
 379         (void) printf(VOL_HDR_FMT, SET_HDR_TXT);
 380
 381         if (dflags & FLAGS) {
 382                 (void) printf(STAT_HDR_FMT, TYPE_HDR_TXT);
 383                 (void) printf(STAT_HDR_FMT, STAT_HDR_TXT);
 384         }
 385
 386         if (dflags & ASYNC_QUEUE)
 387                 (void) printf(STAT_HDR_FMT, QUEUE_HDR_TXT);
 388
 389         if (dflags & PCTS)
 390                 (void) printf(PCT_HDR_FMT, PCT_HDR_TXT);
 391
 392         (void) printf(ROLE_HDR_FMT, ROLE_HDR_TXT);
 393
 394         if (dflags & ASYNC_QUEUE) {
 395                 (void) printf(TPS_HDR_FMT, QUEUE_ITEMS_TXT);
 396                 (void) printf(KPS_HDR_FMT, QUEUE_KBYTES_TXT);
 397                 (void) printf(TPS_HDR_FMT, QUEUE_ITEMS_HW_TXT);
 398                 (void) printf(KPS_HDR_FMT, QUEUE_KBYTES_HW_TXT);
 399         }
 400
 401         if (dflags & SUMMARY) {
 402                 if ((mode & MULTI) && (mode & SDBC)) {
 403                         (void) printf(KPS_HDR_FMT, CKPS_HDR_TXT);
 404                         (void) printf(KPS_HDR_FMT, DKPS_HDR_TXT);
 405                 } else
 406                         (void) printf(KPS_HDR_FMT, KPS_HDR_TXT);
 407                 (void) printf(TPS_HDR_FMT, TPS_HDR_TXT);
 408                 (void) printf(SVT_HDR_FMT, SVT_HDR_TXT);
 409
 410                 (void) printf("\n");
 411
 412                 return;
 413         }
 414
 415         if (dflags & READ) {
 416                 if ((mode & MULTI) && (mode & SDBC)) {
 417                         (void) printf(KPS_HDR_FMT, CRKPS_HDR_TXT);
 418                         (void) printf(KPS_HDR_FMT, DRKPS_HDR_TXT);
 419                 } else
 420                         (void) printf(KPS_HDR_FMT, RKPS_HDR_TXT);
 421
 422                 (void) printf(TPS_HDR_FMT, RTPS_HDR_TXT);
 423         }
 424
 425         if (dflags & WRITE) {
 426                 if ((mode & MULTI) && (mode & SDBC)) {
 427                         (void) printf(KPS_HDR_FMT, CWKPS_HDR_TXT);
 428                         (void) printf(KPS_HDR_FMT, DWKPS_HDR_TXT);
 429                 } else
 430                         (void) printf(KPS_HDR_FMT, WKPS_HDR_TXT);
 431
 432                 (void) printf(TPS_HDR_FMT, WTPS_HDR_TXT);
 433         }
 434
 435         if (dflags & TIMING)
 436                 (void) printf(SVT_HDR_FMT, SVT_HDR_TXT);
 437
 438         (void) printf("\n");
 439 }