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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * rstat service: built with rstat.x 30 */ 31 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <stdarg.h> 35 #include <string.h> 36 #include <signal.h> 37 #include <utmpx.h> 38 #include <nlist.h> 39 #include <fcntl.h> 40 #include <syslog.h> 41 #include <kstat.h> 42 43 #include <rpc/rpc.h> 44 45 #include <sys/socket.h> 46 #include <sys/cpuvar.h> 47 #include <sys/sysinfo.h> 48 #include <sys/systm.h> 49 #include <errno.h> 50 #include <sys/stropts.h> 51 #include <sys/tihdr.h> 52 #include <sys/sysmacros.h> 53 54 #include <net/if.h> 55 #include <inet/mib2.h> 56 57 #include "rstat.h" 58 #include "rstat_v2.h" 59 60 typedef struct { 61 kstat_t sys; 62 kstat_t vm; 63 } _cpu_stats_t; 64 65 /* 66 * system and cpu stats 67 */ 68 static kstat_ctl_t *kc; /* libkstat cookie */ 69 static int ncpus; 70 static _cpu_stats_t *cpu_stats_list = NULL; 71 static kstat_t *system_misc_ksp; 72 static kstat_named_t *boot_time_knp; 73 static kstat_named_t *avenrun_1min_knp, *avenrun_5min_knp, *avenrun_15min_knp; 74 static int hz; 75 static struct timeval btm; /* boottime */ 76 77 /* 78 * network interface stats 79 */ 80 81 typedef struct mib_item_s { 82 struct mib_item_s *next_item; 83 long group; 84 long mib_id; 85 long length; 86 char *valp; 87 } mib_item_t; 88 89 mib_item_t *netstat_item; 90 91 /* 92 * disk stats 93 */ 94 95 struct diskinfo { 96 struct diskinfo *next; 97 kstat_t *ks; 98 kstat_io_t kios; 99 }; 100 101 #define NULLDISK (struct diskinfo *)0 102 static struct diskinfo zerodisk = { NULL, NULL }; 103 static struct diskinfo *firstdisk = NULLDISK; 104 static struct diskinfo *lastdisk = NULLDISK; 105 static struct diskinfo *snip = NULLDISK; 106 static int ndisks; 107 108 /* 109 * net stats 110 */ 111 112 struct netinfo { 113 struct netinfo *next; 114 kstat_t *ks; 115 kstat_named_t *ipackets; 116 kstat_named_t *opackets; 117 kstat_named_t *ierrors; 118 kstat_named_t *oerrors; 119 kstat_named_t *collisions; 120 }; 121 122 #define NULLNET (struct netinfo *)0 123 static struct netinfo zeronet = { NULL, NULL, NULL, NULL, NULL, NULL, NULL }; 124 static struct netinfo *firstnet = NULLNET; 125 static struct netinfo *lastnet = NULLNET; 126 static struct netinfo *netsnip = NULLNET; 127 static int nnets; 128 129 /* 130 * Define EXIT_WHEN_IDLE if you are able to have this program invoked 131 * automatically on demand (as from inetd). When defined, the service 132 * will terminated after being idle for 120 seconds. 133 */ 134 135 #define EXIT_WHEN_IDLE 1 136 137 int sincelastreq = 0; /* number of alarms since last request */ 138 #ifdef EXIT_WHEN_IDLE 139 #define CLOSEDOWN 120 /* how long to wait before exiting */ 140 #endif /* def EXIT_WHEN_IDLE */ 141 142 statstime stats_s3; 143 statsvar stats_s4; 144 /* V2 support for backwards compatibility to pre-5.0 systems */ 145 statsswtch stats_s2; 146 147 static int stat_is_init = 0; 148 149 static void fail(int, char *, ...); 150 static void safe_zalloc(void **, int, int); 151 static kid_t safe_kstat_read(kstat_ctl_t *, kstat_t *, void *); 152 static kstat_t *safe_kstat_lookup(kstat_ctl_t *, char *, int, char *); 153 static void *safe_kstat_data_lookup(kstat_t *, char *); 154 static void system_stat_init(void); 155 static int system_stat_load(void); 156 static void init_disks(void); 157 static int diskinfo_load(void); 158 static void init_net(void); 159 static int netinfo_load(void); 160 161 static void updatestat(int); 162 163 static mib_item_t *mibget(int sd); 164 static int mibopen(void); 165 static char *octetstr(char *buf, Octet_t *op, int code); 166 167 static void kstat_copy(kstat_t *, kstat_t *, int); 168 169 static char *cmdname = "rpc.rstatd"; 170 171 #define CPU_STAT(ksp, name) (((kstat_named_t *)safe_kstat_data_lookup( \ 172 (ksp), (name)))->value.ui64) 173 static _cpu_stats_t cpu_stats_all = { 0 }; 174 175 static void 176 stat_init(void) 177 { 178 struct utmpx *utmpx, utmpx_id; 179 180 stat_is_init = 1; 181 182 if ((kc = kstat_open()) == NULL) 183 fail(1, "kstat_open(): can't open /dev/kstat"); 184 185 /* 186 * Preallocate minimal set of drive entries. 187 */ 188 189 if (stats_s4.dk_xfer.dk_xfer_val == NULL) { 190 stats_s4.dk_xfer.dk_xfer_len = RSTAT_DK_NDRIVE; 191 stats_s4.dk_xfer.dk_xfer_val = 192 (int *)calloc(RSTAT_DK_NDRIVE, sizeof (int)); 193 } 194 195 system_stat_init(); 196 init_disks(); 197 init_net(); 198 199 /* 200 * To get the boot time, use utmpx, which is per-zone, but fall back 201 * to the system-wide kstat if utmpx is hosed for any reason. 202 */ 203 utmpx_id.ut_type = BOOT_TIME; 204 if ((utmpx = getutxid(&utmpx_id)) != NULL) 205 btm = utmpx->ut_tv; 206 else { 207 btm.tv_sec = boot_time_knp->value.ul; 208 btm.tv_usec = 0; /* don't bother with usecs for boot time */ 209 } 210 endutxent(); 211 stats_s4.boottime.tv_sec = 212 stats_s2.boottime.tv_sec = 213 stats_s3.boottime.tv_sec = btm.tv_sec; 214 stats_s4.boottime.tv_usec = 215 stats_s2.boottime.tv_usec = 216 stats_s3.boottime.tv_usec = btm.tv_usec; 217 218 updatestat(0); 219 alarm(1); 220 signal(SIGALRM, updatestat); 221 sleep(2); /* allow for one wake-up */ 222 } 223 224 statsvar * 225 rstatproc_stats_4_svc(argp, svcrq) 226 void *argp; 227 struct svc_req *svcrq; 228 { 229 if (! stat_is_init) 230 stat_init(); 231 #ifdef EXIT_WHEN_IDLE 232 sincelastreq = 0; 233 #endif 234 return (&stats_s4); 235 } 236 237 statstime * 238 rstatproc_stats_3_svc(argp, svcrq) 239 void *argp; 240 struct svc_req *svcrq; 241 { 242 if (! stat_is_init) 243 stat_init(); 244 #ifdef EXIT_WHEN_IDLE 245 sincelastreq = 0; 246 #endif 247 return (&stats_s3); 248 } 249 250 statsswtch * 251 rstatproc_stats_2_svc(argp, svcrq) 252 void *argp; 253 struct svc_req *svcrq; 254 { 255 if (! stat_is_init) 256 stat_init(); 257 #ifdef EXIT_WHEN_IDLE 258 sincelastreq = 0; 259 #endif 260 return (&stats_s2); 261 } 262 263 264 uint_t * 265 rstatproc_havedisk_4_svc(argp, svcrq) 266 void *argp; 267 struct svc_req *svcrq; 268 { 269 return (rstatproc_havedisk_3_svc(argp, svcrq)); 270 } 271 272 uint_t * 273 rstatproc_havedisk_3_svc(argp, svcrq) 274 void *argp; 275 struct svc_req *svcrq; 276 { 277 static uint_t have; 278 279 if (! stat_is_init) 280 stat_init(); 281 #ifdef EXIT_WHEN_IDLE 282 sincelastreq = 0; 283 #endif 284 have = (ndisks != 0); 285 return (&have); 286 } 287 288 uint_t * 289 rstatproc_havedisk_2_svc(argp, svcrq) 290 void *argp; 291 struct svc_req *svcrq; 292 { 293 return (rstatproc_havedisk_3_svc(argp, svcrq)); 294 } 295 296 void 297 updatestat(int ignored) 298 { 299 extern int _rpcpmstart; /* Started by a port monitor ? */ 300 extern int _rpcsvcdirty; /* Still serving ? */ 301 302 #ifdef DEBUG 303 fprintf(stderr, "entering updatestat\n"); 304 #endif 305 #ifdef EXIT_WHEN_IDLE 306 if (_rpcpmstart && sincelastreq >= CLOSEDOWN && !_rpcsvcdirty) { 307 #ifdef DEBUG 308 fprintf(stderr, "about to closedown\n"); 309 #endif 310 exit(0); 311 } 312 sincelastreq++; 313 #endif /* def EXIT_WHEN_IDLE */ 314 315 (void) alarm(0); 316 #ifdef DEBUG 317 fprintf(stderr, "boottime: %d %d\n", stats_s3.boottime.tv_sec, 318 stats_s3.boottime.tv_usec); 319 #endif 320 while (system_stat_load() || diskinfo_load() || netinfo_load()) { 321 (void) kstat_chain_update(kc); 322 system_stat_init(); 323 init_disks(); 324 init_net(); 325 } 326 stats_s4.cp_time.cp_time_len = CPU_STATES; 327 if (stats_s4.cp_time.cp_time_val == NULL) 328 stats_s4.cp_time.cp_time_val = 329 malloc(stats_s4.cp_time.cp_time_len * sizeof (int)); 330 stats_s2.cp_time[RSTAT_CPU_USER] = 331 stats_s3.cp_time[RSTAT_CPU_USER] = 332 stats_s4.cp_time.cp_time_val[RSTAT_CPU_USER] = 333 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_user"); 334 stats_s2.cp_time[RSTAT_CPU_NICE] = 335 stats_s3.cp_time[RSTAT_CPU_NICE] = 336 stats_s4.cp_time.cp_time_val[RSTAT_CPU_NICE] = 337 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_wait"); 338 stats_s2.cp_time[RSTAT_CPU_SYS] = 339 stats_s3.cp_time[RSTAT_CPU_SYS] = 340 stats_s4.cp_time.cp_time_val[RSTAT_CPU_SYS] = 341 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_kernel"); 342 stats_s2.cp_time[RSTAT_CPU_IDLE] = 343 stats_s3.cp_time[RSTAT_CPU_IDLE] = 344 stats_s4.cp_time.cp_time_val[RSTAT_CPU_IDLE] = 345 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_idle"); 346 347 #ifdef DEBUG 348 fprintf(stderr, "cpu: %d %d %d %d\n", 349 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_user"), 350 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_wait"), 351 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_kernel"), 352 CPU_STAT(&cpu_stats_all.sys, "cpu_ticks_idle")); 353 fprintf(stderr, "cp_time: %d %d %d %d\n", 354 stats_s3.cp_time[RSTAT_CPU_USER], 355 stats_s3.cp_time[RSTAT_CPU_NICE], 356 stats_s3.cp_time[RSTAT_CPU_SYS], 357 stats_s3.cp_time[RSTAT_CPU_IDLE]); 358 #endif 359 360 /* current time */ 361 gettimeofday((struct timeval *)&stats_s3.curtime, NULL); 362 stats_s4.curtime = stats_s3.curtime; 363 364 stats_s2.v_pgpgin = 365 stats_s3.v_pgpgin = 366 stats_s4.v_pgpgin = CPU_STAT(&cpu_stats_all.vm, "pgpgin"); 367 stats_s2.v_pgpgout = 368 stats_s3.v_pgpgout = 369 stats_s4.v_pgpgout = CPU_STAT(&cpu_stats_all.vm, "pgpgout"); 370 stats_s2.v_pswpin = 371 stats_s3.v_pswpin = 372 stats_s4.v_pswpin = CPU_STAT(&cpu_stats_all.vm, "pgswapin"); 373 stats_s2.v_pswpout = 374 stats_s3.v_pswpout = 375 stats_s4.v_pswpout = CPU_STAT(&cpu_stats_all.vm, "pgswapout"); 376 stats_s3.v_intr = CPU_STAT(&cpu_stats_all.sys, "intr"); 377 stats_s3.v_intr -= hz*(stats_s3.curtime.tv_sec - btm.tv_sec) + 378 hz*(stats_s3.curtime.tv_usec - btm.tv_usec)/1000000; 379 stats_s2.v_intr = 380 stats_s4.v_intr = stats_s3.v_intr; 381 /* swtch not in V1 */ 382 stats_s2.v_swtch = 383 stats_s3.v_swtch = 384 stats_s4.v_swtch = CPU_STAT(&cpu_stats_all.sys, "pswitch"); 385 386 #ifdef DEBUG 387 fprintf(stderr, 388 "pgin: %d pgout: %d swpin: %d swpout: %d intr: %d swtch: %d\n", 389 stats_s3.v_pgpgin, 390 stats_s3.v_pgpgout, 391 stats_s3.v_pswpin, 392 stats_s3.v_pswpout, 393 stats_s3.v_intr, 394 stats_s3.v_swtch); 395 #endif 396 /* 397 * V2 and V3 of rstat are limited to RSTAT_DK_NDRIVE drives 398 */ 399 memcpy(stats_s3.dk_xfer, stats_s4.dk_xfer.dk_xfer_val, 400 RSTAT_DK_NDRIVE * sizeof (int)); 401 memcpy(stats_s2.dk_xfer, stats_s4.dk_xfer.dk_xfer_val, 402 RSTAT_DK_NDRIVE * sizeof (int)); 403 #ifdef DEBUG 404 fprintf(stderr, "dk_xfer: %d %d %d %d\n", 405 stats_s4.dk_xfer.dk_xfer_val[0], 406 stats_s4.dk_xfer.dk_xfer_val[1], 407 stats_s4.dk_xfer.dk_xfer_val[2], 408 stats_s4.dk_xfer.dk_xfer_val[3]); 409 #endif 410 411 stats_s2.if_ipackets = 412 stats_s3.if_ipackets = stats_s4.if_ipackets; 413 /* no s2 opackets */ 414 stats_s3.if_opackets = stats_s4.if_opackets; 415 stats_s2.if_ierrors = 416 stats_s3.if_ierrors = stats_s4.if_ierrors; 417 stats_s2.if_oerrors = 418 stats_s3.if_oerrors = stats_s4.if_oerrors; 419 stats_s2.if_collisions = 420 stats_s3.if_collisions = stats_s4.if_collisions; 421 422 stats_s2.avenrun[0] = 423 stats_s3.avenrun[0] = 424 stats_s4.avenrun[0] = avenrun_1min_knp->value.ul; 425 stats_s2.avenrun[1] = 426 stats_s3.avenrun[1] = 427 stats_s4.avenrun[1] = avenrun_5min_knp->value.ul; 428 stats_s2.avenrun[2] = 429 stats_s3.avenrun[2] = 430 stats_s4.avenrun[2] = avenrun_15min_knp->value.ul; 431 #ifdef DEBUG 432 fprintf(stderr, "avenrun: %d %d %d\n", stats_s3.avenrun[0], 433 stats_s3.avenrun[1], stats_s3.avenrun[2]); 434 #endif 435 signal(SIGALRM, updatestat); 436 alarm(1); 437 } 438 439 /* --------------------------------- MIBGET -------------------------------- */ 440 441 static mib_item_t * 442 mibget(int sd) 443 { 444 int flags; 445 int j, getcode; 446 struct strbuf ctlbuf, databuf; 447 char buf[512]; 448 struct T_optmgmt_req *tor = (struct T_optmgmt_req *)buf; 449 struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *)buf; 450 struct T_error_ack *tea = (struct T_error_ack *)buf; 451 struct opthdr *req; 452 mib_item_t *first_item = NULL; 453 mib_item_t *last_item = NULL; 454 mib_item_t *temp; 455 456 tor->PRIM_type = T_SVR4_OPTMGMT_REQ; 457 tor->OPT_offset = sizeof (struct T_optmgmt_req); 458 tor->OPT_length = sizeof (struct opthdr); 459 tor->MGMT_flags = T_CURRENT; 460 req = (struct opthdr *)&tor[1]; 461 req->level = MIB2_IP; /* any MIB2_xxx value ok here */ 462 req->name = 0; 463 req->len = 0; 464 465 ctlbuf.buf = buf; 466 ctlbuf.len = tor->OPT_length + tor->OPT_offset; 467 flags = 0; 468 if (putmsg(sd, &ctlbuf, NULL, flags) == -1) { 469 perror("mibget: putmsg(ctl) failed"); 470 goto error_exit; 471 } 472 /* 473 * each reply consists of a ctl part for one fixed structure 474 * or table, as defined in mib2.h. The format is a T_OPTMGMT_ACK, 475 * containing an opthdr structure. level/name identify the entry, 476 * len is the size of the data part of the message. 477 */ 478 req = (struct opthdr *)&toa[1]; 479 ctlbuf.maxlen = sizeof (buf); 480 /*CSTYLED*/ 481 for (j = 1; ; j++) { 482 flags = 0; 483 getcode = getmsg(sd, &ctlbuf, NULL, &flags); 484 if (getcode == -1) { 485 #ifdef DEBUG_MIB 486 perror("mibget getmsg(ctl) failed"); 487 fprintf(stderr, "# level name len\n"); 488 i = 0; 489 for (last_item = first_item; last_item; 490 last_item = last_item->next_item) 491 fprintf(stderr, "%d %4d %5d %d\n", ++i, 492 last_item->group, 493 last_item->mib_id, 494 last_item->length); 495 #endif /* DEBUG_MIB */ 496 goto error_exit; 497 } 498 if (getcode == 0 && 499 (ctlbuf.len >= sizeof (struct T_optmgmt_ack)) && 500 (toa->PRIM_type == T_OPTMGMT_ACK) && 501 (toa->MGMT_flags == T_SUCCESS) && 502 req->len == 0) { 503 #ifdef DEBUG_MIB 504 fprintf(stderr, 505 "mibget getmsg() %d returned EOD (level %d, name %d)\n", 506 j, req->level, req->name); 507 #endif /* DEBUG_MIB */ 508 return (first_item); /* this is EOD msg */ 509 } 510 511 if (ctlbuf.len >= sizeof (struct T_error_ack) && 512 (tea->PRIM_type == T_ERROR_ACK)) { 513 #ifdef DEBUG_MIB 514 fprintf(stderr, 515 "mibget %d gives T_ERROR_ACK: TLI_error = 0x%x, UNIX_error = 0x%x\n", 516 j, getcode, tea->TLI_error, tea->UNIX_error); 517 #endif /* DEBUG_MIB */ 518 errno = (tea->TLI_error == TSYSERR) 519 ? tea->UNIX_error : EPROTO; 520 goto error_exit; 521 } 522 523 if (getcode != MOREDATA || 524 (ctlbuf.len < sizeof (struct T_optmgmt_ack)) || 525 (toa->PRIM_type != T_OPTMGMT_ACK) || 526 (toa->MGMT_flags != T_SUCCESS)) { 527 #ifdef DEBUG_MIB 528 fprintf(stderr, 529 "mibget getmsg(ctl) %d returned %d, ctlbuf.len = %d, PRIM_type = %d\n", 530 j, getcode, ctlbuf.len, toa->PRIM_type); 531 if (toa->PRIM_type == T_OPTMGMT_ACK) 532 fprintf(stderr, 533 "T_OPTMGMT_ACK: MGMT_flags = 0x%x, req->len = %d\n", 534 toa->MGMT_flags, req->len); 535 #endif /* DEBUG_MIB */ 536 errno = ENOMSG; 537 goto error_exit; 538 } 539 540 temp = malloc(sizeof (mib_item_t)); 541 if (!temp) { 542 perror("mibget malloc failed"); 543 goto error_exit; 544 } 545 if (last_item) 546 last_item->next_item = temp; 547 else 548 first_item = temp; 549 last_item = temp; 550 last_item->next_item = NULL; 551 last_item->group = req->level; 552 last_item->mib_id = req->name; 553 last_item->length = req->len; 554 last_item->valp = malloc(req->len); 555 #ifdef DEBUG_MIB 556 fprintf(stderr, 557 "msg %d: group = %4d mib_id = %5d length = %d\n", 558 j, last_item->group, last_item->mib_id, 559 last_item->length); 560 #endif /* DEBUG_MIB */ 561 databuf.maxlen = last_item->length; 562 databuf.buf = last_item->valp; 563 databuf.len = 0; 564 flags = 0; 565 getcode = getmsg(sd, NULL, &databuf, &flags); 566 if (getcode == -1) { 567 perror("mibget getmsg(data) failed"); 568 goto error_exit; 569 } else if (getcode != 0) { 570 fprintf(stderr, 571 "mibget getmsg(data) returned %d, databuf.maxlen = %d, databuf.len = %d\n", 572 getcode, databuf.maxlen, databuf.len); 573 goto error_exit; 574 } 575 } 576 577 error_exit: 578 while (first_item) { 579 last_item = first_item; 580 first_item = first_item->next_item; 581 if (last_item->valp) { 582 free(last_item->valp); 583 } 584 free(last_item); 585 } 586 return (first_item); 587 } 588 589 static int 590 mibopen(void) 591 { 592 int sd; 593 594 /* gives us ip w/ arp on top */ 595 sd = open("/dev/arp", O_RDWR); 596 if (sd == -1) { 597 perror("arp open"); 598 close(sd); 599 return (-1); 600 } 601 if (ioctl(sd, I_PUSH, "tcp") == -1) { 602 perror("tcp I_PUSH"); 603 close(sd); 604 return (-1); 605 } 606 if (ioctl(sd, I_PUSH, "udp") == -1) { 607 perror("udp I_PUSH"); 608 close(sd); 609 return (-1); 610 } 611 return (sd); 612 } 613 614 static char * 615 octetstr(char *buf, Octet_t *op, int code) 616 { 617 int i; 618 char *cp; 619 620 cp = buf; 621 if (op) 622 for (i = 0; i < op->o_length; i++) 623 switch (code) { 624 case 'd': 625 sprintf(cp, "%d.", 0xff & op->o_bytes[i]); 626 cp = strchr(cp, '\0'); 627 break; 628 case 'a': 629 *cp++ = op->o_bytes[i]; 630 break; 631 case 'h': 632 default: 633 sprintf(cp, "%02x:", 0xff & op->o_bytes[i]); 634 cp += 3; 635 break; 636 } 637 if (code != 'a' && cp != buf) 638 cp--; 639 *cp = '\0'; 640 return (buf); 641 } 642 643 static void 644 fail(int do_perror, char *message, ...) 645 { 646 va_list args; 647 648 va_start(args, message); 649 fprintf(stderr, "%s: ", cmdname); 650 vfprintf(stderr, message, args); 651 va_end(args); 652 if (do_perror) 653 fprintf(stderr, ": %s", strerror(errno)); 654 fprintf(stderr, "\n"); 655 exit(2); 656 } 657 658 static void 659 safe_zalloc(void **ptr, int size, int free_first) 660 { 661 if (free_first && *ptr != NULL) 662 free(*ptr); 663 if ((*ptr = malloc(size)) == NULL) 664 fail(1, "malloc failed"); 665 memset(*ptr, 0, size); 666 } 667 668 kid_t 669 safe_kstat_read(kstat_ctl_t *kctl, kstat_t *ksp, void *data) 670 { 671 kid_t kstat_chain_id = kstat_read(kctl, ksp, data); 672 673 if (kstat_chain_id == -1) 674 fail(1, "kstat_read(%x, '%s') failed", kctl, ksp->ks_name); 675 return (kstat_chain_id); 676 } 677 678 kstat_t * 679 safe_kstat_lookup(kstat_ctl_t *kctl, char *ks_module, int ks_instance, 680 char *ks_name) 681 { 682 kstat_t *ksp = kstat_lookup(kctl, ks_module, ks_instance, ks_name); 683 684 if (ksp == NULL) 685 fail(0, "kstat_lookup('%s', %d, '%s') failed", 686 ks_module == NULL ? "" : ks_module, 687 ks_instance, 688 ks_name == NULL ? "" : ks_name); 689 return (ksp); 690 } 691 692 void * 693 safe_kstat_data_lookup(kstat_t *ksp, char *name) 694 { 695 void *fp = kstat_data_lookup(ksp, name); 696 697 if (fp == NULL) { 698 fail(0, "kstat_data_lookup('%s', '%s') failed", 699 ksp->ks_name, name); 700 } 701 return (fp); 702 } 703 704 /* 705 * Get various KIDs for subsequent system_stat_load operations. 706 */ 707 708 static void 709 system_stat_init(void) 710 { 711 kstat_t *ksp; 712 int i, nvmks; 713 714 /* 715 * Global statistics 716 */ 717 718 system_misc_ksp = safe_kstat_lookup(kc, "unix", 0, "system_misc"); 719 720 safe_kstat_read(kc, system_misc_ksp, NULL); 721 boot_time_knp = safe_kstat_data_lookup(system_misc_ksp, "boot_time"); 722 avenrun_1min_knp = safe_kstat_data_lookup(system_misc_ksp, 723 "avenrun_1min"); 724 avenrun_5min_knp = safe_kstat_data_lookup(system_misc_ksp, 725 "avenrun_5min"); 726 avenrun_15min_knp = safe_kstat_data_lookup(system_misc_ksp, 727 "avenrun_15min"); 728 729 /* 730 * Per-CPU statistics 731 */ 732 733 ncpus = 0; 734 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) 735 if (strcmp(ksp->ks_module, "cpu") == 0 && 736 strcmp(ksp->ks_name, "sys") == 0) 737 ncpus++; 738 739 safe_zalloc((void **)&cpu_stats_list, ncpus * sizeof (*cpu_stats_list), 740 1); 741 742 ncpus = 0; 743 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) 744 if (strcmp(ksp->ks_module, "cpu") == 0 && 745 strcmp(ksp->ks_name, "sys") == 0 && 746 kstat_read(kc, ksp, NULL) != -1) { 747 kstat_copy(ksp, &cpu_stats_list[ncpus].sys, 748 1); 749 if ((ksp = kstat_lookup(kc, "cpu", ksp->ks_instance, 750 "vm")) != NULL && kstat_read(kc, ksp, NULL) != -1) 751 kstat_copy(ksp, &cpu_stats_list[ncpus].vm, 1); 752 else 753 fail(0, "couldn't find per-CPU VM statistics"); 754 ncpus++; 755 } 756 757 if (ncpus == 0) 758 fail(0, "couldn't find per-CPU statistics"); 759 } 760 761 /* 762 * load statistics, summing across CPUs where needed 763 */ 764 765 static int 766 system_stat_load(void) 767 { 768 int i, j; 769 _cpu_stats_t cs; 770 ulong_t *np, *tp; 771 772 /* 773 * Global statistics 774 */ 775 776 safe_kstat_read(kc, system_misc_ksp, NULL); 777 778 /* 779 * Per-CPU statistics. 780 */ 781 782 for (i = 0; i < ncpus; i++) { 783 if (kstat_read(kc, &cpu_stats_list[i].sys, NULL) == -1 || 784 kstat_read(kc, &cpu_stats_list[i].vm, NULL) == -1) 785 return (1); 786 if (i == 0) { 787 kstat_copy(&cpu_stats_list[0].sys, &cpu_stats_all.sys, 788 1); 789 kstat_copy(&cpu_stats_list[0].vm, &cpu_stats_all.vm, 1); 790 } else { 791 kstat_named_t *nkp; 792 kstat_named_t *tkp; 793 794 /* 795 * Other CPUs' statistics are accumulated in 796 * cpu_stats_all, initialized at the first iteration of 797 * the loop. 798 */ 799 nkp = (kstat_named_t *)cpu_stats_all.sys.ks_data; 800 tkp = (kstat_named_t *)cpu_stats_list[i].sys.ks_data; 801 for (j = 0; j < cpu_stats_list[i].sys.ks_ndata; j++) 802 (nkp++)->value.ui64 += (tkp++)->value.ui64; 803 nkp = (kstat_named_t *)cpu_stats_all.vm.ks_data; 804 tkp = (kstat_named_t *)cpu_stats_list[i].vm.ks_data; 805 for (j = 0; j < cpu_stats_list[i].vm.ks_ndata; j++) 806 (nkp++)->value.ui64 += (tkp++)->value.ui64; 807 } 808 } 809 return (0); 810 } 811 812 static int 813 kscmp(kstat_t *ks1, kstat_t *ks2) 814 { 815 int cmp; 816 817 cmp = strcmp(ks1->ks_module, ks2->ks_module); 818 if (cmp != 0) 819 return (cmp); 820 cmp = ks1->ks_instance - ks2->ks_instance; 821 if (cmp != 0) 822 return (cmp); 823 return (strcmp(ks1->ks_name, ks2->ks_name)); 824 } 825 826 static void 827 init_disks(void) 828 { 829 struct diskinfo *disk, *prevdisk, *comp; 830 kstat_t *ksp; 831 832 ndisks = 0; 833 disk = &zerodisk; 834 835 /* 836 * Patch the snip in the diskinfo list (see below) 837 */ 838 if (snip) 839 lastdisk->next = snip; 840 841 for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { 842 843 if (ksp->ks_type != KSTAT_TYPE_IO || 844 strcmp(ksp->ks_class, "disk") != 0) 845 continue; 846 prevdisk = disk; 847 if (disk->next) 848 disk = disk->next; 849 else { 850 safe_zalloc((void **)&disk->next, 851 sizeof (struct diskinfo), 0); 852 disk = disk->next; 853 disk->next = NULLDISK; 854 } 855 disk->ks = ksp; 856 memset((void *)&disk->kios, 0, sizeof (kstat_io_t)); 857 disk->kios.wlastupdate = disk->ks->ks_crtime; 858 disk->kios.rlastupdate = disk->ks->ks_crtime; 859 860 /* 861 * Insertion sort on (ks_module, ks_instance, ks_name) 862 */ 863 comp = &zerodisk; 864 while (kscmp(disk->ks, comp->next->ks) > 0) 865 comp = comp->next; 866 if (prevdisk != comp) { 867 prevdisk->next = disk->next; 868 disk->next = comp->next; 869 comp->next = disk; 870 disk = prevdisk; 871 } 872 ndisks++; 873 } 874 /* 875 * Put a snip in the linked list of diskinfos. The idea: 876 * If there was a state change such that now there are fewer 877 * disks, we snip the list and retain the tail, rather than 878 * freeing it. At the next state change, we clip the tail back on. 879 * This prevents a lot of malloc/free activity, and it's simpler. 880 */ 881 lastdisk = disk; 882 snip = disk->next; 883 disk->next = NULLDISK; 884 885 firstdisk = zerodisk.next; 886 887 if (ndisks > stats_s4.dk_xfer.dk_xfer_len) { 888 stats_s4.dk_xfer.dk_xfer_len = ndisks; 889 safe_zalloc((void **)&stats_s4.dk_xfer.dk_xfer_val, 890 ndisks * sizeof (int), 1); 891 } 892 } 893 894 static int 895 diskinfo_load(void) 896 { 897 struct diskinfo *disk; 898 int i; 899 900 for (disk = firstdisk, i = 0; disk; disk = disk->next, i++) { 901 if (kstat_read(kc, disk->ks, (void *)&disk->kios) == -1) 902 return (1); 903 stats_s4.dk_xfer.dk_xfer_val[i] = disk->kios.reads + 904 disk->kios.writes; 905 } 906 return (0); 907 } 908 909 static void 910 init_net(void) 911 { 912 static int sd; 913 mib_item_t *item; 914 mib2_ipAddrEntry_t *ap; 915 char namebuf[KSTAT_STRLEN]; 916 struct netinfo *net, *prevnet, *comp; 917 kstat_t *ksp; 918 919 if (sd) { 920 close(sd); 921 } 922 while (netstat_item) { 923 item = netstat_item; 924 netstat_item = netstat_item->next_item; 925 if (item->valp) { 926 free(item->valp); 927 } 928 free(item); 929 } 930 sd = mibopen(); 931 if (sd == -1) { 932 #ifdef DEBUG 933 fprintf(stderr, "mibopen() failed\n"); 934 #endif 935 sd = 0; 936 } else { 937 if ((netstat_item = mibget(sd)) == NULL) { 938 #ifdef DEBUG 939 fprintf(stderr, "mibget() failed\n"); 940 #endif 941 close(sd); 942 sd = 0; 943 } 944 } 945 #ifdef DEBUG 946 fprintf(stderr, "mibget returned item: %x\n", netstat_item); 947 #endif 948 949 nnets = 0; 950 net = &zeronet; 951 952 if (netsnip) 953 lastnet->next = netsnip; 954 955 for (item = netstat_item; item; item = item->next_item) { 956 #ifdef DEBUG_MIB 957 fprintf(stderr, "\n--- Item %x ---\n", item); 958 fprintf(stderr, 959 "Group = %d, mib_id = %d, length = %d, valp = 0x%x\n", 960 item->group, item->mib_id, item->length, 961 item->valp); 962 #endif 963 if (item->group != MIB2_IP || item->mib_id != MIB2_IP_20) 964 continue; 965 ap = (mib2_ipAddrEntry_t *)item->valp; 966 for (; (char *)ap < item->valp + item->length; ap++) { 967 968 octetstr(namebuf, &ap->ipAdEntIfIndex, 'a'); 969 #ifdef DEBUG 970 fprintf(stderr, "%s ", namebuf); 971 #endif 972 if (strlen(namebuf) == 0) 973 continue; 974 /* 975 * We found a device of interest. 976 * Now, let's see if there's a kstat for it. 977 * First we try to query the "link" kstats in case 978 * the link is renamed. If that fails, fallback 979 * to legacy ktats for those non-GLDv3 links. 980 */ 981 if (((ksp = kstat_lookup(kc, "link", 0, namebuf)) 982 == NULL) && ((ksp = kstat_lookup(kc, NULL, -1, 983 namebuf)) == NULL)) { 984 continue; 985 } 986 if (ksp->ks_type != KSTAT_TYPE_NAMED) 987 continue; 988 if (kstat_read(kc, ksp, NULL) == -1) 989 continue; 990 prevnet = net; 991 if (net->next) 992 net = net->next; 993 else { 994 safe_zalloc((void **)&net->next, 995 sizeof (struct netinfo), 0); 996 net = net->next; 997 net->next = NULLNET; 998 } 999 net->ks = ksp; 1000 net->ipackets = kstat_data_lookup(net->ks, 1001 "ipackets"); 1002 net->opackets = kstat_data_lookup(net->ks, 1003 "opackets"); 1004 net->ierrors = kstat_data_lookup(net->ks, 1005 "ierrors"); 1006 net->oerrors = kstat_data_lookup(net->ks, 1007 "oerrors"); 1008 net->collisions = kstat_data_lookup(net->ks, 1009 "collisions"); 1010 /* 1011 * Insertion sort on the name 1012 */ 1013 comp = &zeronet; 1014 while (strcmp(net->ks->ks_name, 1015 comp->next->ks->ks_name) > 0) 1016 comp = comp->next; 1017 if (prevnet != comp) { 1018 prevnet->next = net->next; 1019 net->next = comp->next; 1020 comp->next = net; 1021 net = prevnet; 1022 } 1023 nnets++; 1024 } 1025 #ifdef DEBUG 1026 fprintf(stderr, "\n"); 1027 #endif 1028 } 1029 /* 1030 * Put a snip in the linked list of netinfos. The idea: 1031 * If there was a state change such that now there are fewer 1032 * nets, we snip the list and retain the tail, rather than 1033 * freeing it. At the next state change, we clip the tail back on. 1034 * This prevents a lot of malloc/free activity, and it's simpler. 1035 */ 1036 lastnet = net; 1037 netsnip = net->next; 1038 net->next = NULLNET; 1039 1040 firstnet = zeronet.next; 1041 } 1042 1043 static int 1044 netinfo_load(void) 1045 { 1046 struct netinfo *net; 1047 1048 if (netstat_item == NULL) { 1049 #ifdef DEBUG 1050 fprintf(stderr, "No net stats\n"); 1051 #endif 1052 return (0); 1053 } 1054 1055 stats_s4.if_ipackets = 1056 stats_s4.if_opackets = 1057 stats_s4.if_ierrors = 1058 stats_s4.if_oerrors = 1059 stats_s4.if_collisions = 0; 1060 1061 for (net = firstnet; net; net = net->next) { 1062 if (kstat_read(kc, net->ks, NULL) == -1) 1063 return (1); 1064 if (net->ipackets) 1065 stats_s4.if_ipackets += net->ipackets->value.ul; 1066 if (net->opackets) 1067 stats_s4.if_opackets += net->opackets->value.ul; 1068 if (net->ierrors) 1069 stats_s4.if_ierrors += net->ierrors->value.ul; 1070 if (net->oerrors) 1071 stats_s4.if_oerrors += net->oerrors->value.ul; 1072 if (net->collisions) 1073 stats_s4.if_collisions += net->collisions->value.ul; 1074 } 1075 #ifdef DEBUG 1076 fprintf(stderr, 1077 "ipackets: %d opackets: %d ierrors: %d oerrors: %d colls: %d\n", 1078 stats_s4.if_ipackets, 1079 stats_s4.if_opackets, 1080 stats_s4.if_ierrors, 1081 stats_s4.if_oerrors, 1082 stats_s4.if_collisions); 1083 #endif 1084 return (0); 1085 } 1086 1087 static void 1088 kstat_copy(kstat_t *src, kstat_t *dst, int fr) 1089 { 1090 if (fr) 1091 free(dst->ks_data); 1092 *dst = *src; 1093 if (src->ks_data != NULL) { 1094 safe_zalloc(&dst->ks_data, src->ks_data_size, 0); 1095 (void) memcpy(dst->ks_data, src->ks_data, src->ks_data_size); 1096 } else { 1097 dst->ks_data = NULL; 1098 dst->ks_data_size = 0; 1099 } 1100 } 1101