static void save_simmstat(ks_returner_t *ret, kstat_t *kp, ks_instance_t *ksi) { uchar_t *simmstat; char *simm_buf; char *list = NULL; int i; assert(kp->ks_data_size == sizeof (uchar_t) * SIMM_COUNT); for (i = 0, simmstat = (uchar_t *)(kp->ks_data); i < SIMM_COUNT - 1; i++, simmstat++) { if (list == NULL) { (void) asprintf(&simm_buf, "%d,", *simmstat); } else { (void) asprintf(&simm_buf, "%s%d,", list, *simmstat); free(list); } list = simm_buf; } (void) asprintf(&simm_buf, "%s%d", list, *simmstat); SAVE_STRING_X(ret, ksi, "status", simm_buf); free(list); free(simm_buf); }
static void save_temp_over(ks_returner_t *ret, kstat_t *kp, ks_instance_t *ksi) { short *sh = (short *)(kp->ks_data); char *value; assert(kp->ks_data_size == sizeof (short)); (void) asprintf(&value, "%hu", *sh); SAVE_STRING_X(ret, ksi, "override", value); free(value); }
static void save_temperature(ks_returner_t *ret, kstat_t *kp, ks_instance_t *ksi) { struct temp_stats *temps = (struct temp_stats *)(kp->ks_data); char *buf; assert(kp->ks_data_size == sizeof (struct temp_stats)); SAVE_UINT32(ret, ksi, temps, index); buf = short_array_to_string(temps->l1, L1_SZ); SAVE_STRING_X(ret, ksi, "l1", buf); free(buf); buf = short_array_to_string(temps->l2, L2_SZ); SAVE_STRING_X(ret, ksi, "l2", buf); free(buf); buf = short_array_to_string(temps->l3, L3_SZ); SAVE_STRING_X(ret, ksi, "l3", buf); free(buf); buf = short_array_to_string(temps->l4, L4_SZ); SAVE_STRING_X(ret, ksi, "l4", buf); free(buf); buf = short_array_to_string(temps->l5, L5_SZ); SAVE_STRING_X(ret, ksi, "l5", buf); free(buf); SAVE_INT32(ret, ksi, temps, max); SAVE_INT32(ret, ksi, temps, min); SAVE_INT32(ret, ksi, temps, state); SAVE_INT32(ret, ksi, temps, temp_cnt); SAVE_INT32(ret, ksi, temps, shutdown_cnt); SAVE_INT32(ret, ksi, temps, version); SAVE_INT32(ret, ksi, temps, trend); SAVE_INT32(ret, ksi, temps, override); }
static void save_fault_list(ks_returner_t *ret, kstat_t *kp, ks_instance_t *ksi) { struct ft_list *fault; char name[KSTAT_STRLEN + 7]; int i; for (i = 1, fault = (struct ft_list *)(kp->ks_data); i <= 999999 && i <= kp->ks_data_size / sizeof (struct ft_list); i++, fault++) { (void) snprintf(name, sizeof (name), "unit_%d", i); SAVE_INT32_X(ret, ksi, name, fault->unit); (void) snprintf(name, sizeof (name), "type_%d", i); SAVE_INT32_X(ret, ksi, name, fault->type); (void) snprintf(name, sizeof (name), "fclass_%d", i); SAVE_INT32_X(ret, ksi, name, fault->fclass); (void) snprintf(name, sizeof (name), "create_time_%d", i); SAVE_HRTIME_X(ret, ksi, name, fault->create_time); (void) snprintf(name, sizeof (name), "msg_%d", i); SAVE_STRING_X(ret, ksi, name, fault->msg); } }
static void save_named(ks_returner_t *ret, kstat_t *kp, ks_instance_t *ksi) { kstat_named_t *knp; int n; for (n = kp->ks_ndata, knp = KSTAT_NAMED_PTR(kp); n > 0; n--, knp++) { switch (knp->data_type) { case KSTAT_DATA_CHAR: nvpair_insert(ret, ksi, knp->name, (ks_value_t *)&knp->value, KSTAT_DATA_CHAR); break; case KSTAT_DATA_INT32: nvpair_insert(ret, ksi, knp->name, (ks_value_t *)&knp->value, KSTAT_DATA_INT32); break; case KSTAT_DATA_UINT32: nvpair_insert(ret, ksi, knp->name, (ks_value_t *)&knp->value, KSTAT_DATA_UINT32); break; case KSTAT_DATA_INT64: nvpair_insert(ret, ksi, knp->name, (ks_value_t *)&knp->value, KSTAT_DATA_INT64); break; case KSTAT_DATA_UINT64: nvpair_insert(ret, ksi, knp->name, (ks_value_t *)&knp->value, KSTAT_DATA_UINT64); break; case KSTAT_DATA_STRING: SAVE_STRING_X(ret, ksi, knp->name, KSTAT_NAMED_STR_PTR(knp)); break; default: assert(B_FALSE); /* Invalid data type */ break; } } }
/* * Iterate over all kernel statistics and save matches. */ static void ks_instances_read(kstat_ctl_t *kc) { kstat_raw_reader_t save_raw = NULL; kid_t id; ks_selector_t *selector; ks_instance_t *ksi; ks_instance_t *tmp; kstat_t *kp; boolean_t skip; for (kp = kc->kc_chain; kp != NULL; kp = kp->ks_next) { /* Don't bother storing the kstat headers */ if (strncmp(kp->ks_name, "kstat_", 6) == 0) { continue; } /* Don't bother storing raw stats we don't understand */ if (kp->ks_type == KSTAT_TYPE_RAW) { save_raw = lookup_raw_kstat_fn(kp->ks_module, kp->ks_name); if (save_raw == NULL) { #ifdef REPORT_UNKNOWN (void) fprintf(stderr, "Unknown kstat type %s:%d:%s - " "%d of size %d\n", kp->ks_module, kp->ks_instance, kp->ks_name, kp->ks_ndata, kp->ks_data_size); #endif continue; } } /* * Iterate over the list of selectors and skip * instances we dont want. We filter for statistics * later, as we dont know them yet. */ skip = B_TRUE; selector = list_head(&selector_list); while (selector != NULL) { if (ks_match(kp->ks_module, &selector->ks_module) && ks_match(kp->ks_name, &selector->ks_name)) { skip = B_FALSE; break; } selector = list_next(&selector_list, selector); } if (skip) { continue; } /* * Allocate a new instance and fill in the values * we know so far. */ ksi = (ks_instance_t *)malloc(sizeof (ks_instance_t)); if (ksi == NULL) { perror("malloc"); exit(3); } list_link_init(&ksi->ks_next); (void) strlcpy(ksi->ks_zone, "global", KSTAT_STRLEN); (void) strlcpy(ksi->ks_module, kp->ks_module, KSTAT_STRLEN); (void) strlcpy(ksi->ks_name, kp->ks_name, KSTAT_STRLEN); (void) strlcpy(ksi->ks_class, kp->ks_class, KSTAT_STRLEN); ksi->ks_instance = kp->ks_instance; ksi->ks_snaptime = kp->ks_snaptime; ksi->ks_type = kp->ks_type; list_create(&ksi->ks_nvlist, sizeof (ks_nvpair_t), offsetof(ks_nvpair_t, nv_next)); SAVE_HRTIME_X(ksi, "crtime", kp->ks_crtime); SAVE_HRTIME_X(ksi, "snaptime", kp->ks_snaptime); if (g_pflg) { SAVE_STRING_X(ksi, "class", kp->ks_class); } /* Insert this instance into a sorted list */ tmp = list_head(&instances_list); while (tmp != NULL && compare_instances(ksi, tmp) > 0) tmp = list_next(&instances_list, tmp); list_insert_before(&instances_list, tmp, ksi); /* Read the actual statistics */ id = kstat_read(kc, kp, NULL); if (id == -1) { #ifdef REPORT_UNKNOWN perror("kstat_read"); #endif continue; } switch (kp->ks_type) { case KSTAT_TYPE_RAW: save_raw(kp, ksi); break; case KSTAT_TYPE_NAMED: save_named(kp, ksi); break; case KSTAT_TYPE_INTR: save_intr(kp, ksi); break; case KSTAT_TYPE_IO: save_io(kp, ksi); break; case KSTAT_TYPE_TIMER: save_timer(kp, ksi); break; default: assert(B_FALSE); /* Invalid type */ break; } } }