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 } 440