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