/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. * Copyright 2015 Nexenta Systems, Inc. All rights reserved. */ #include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <ctype.h> #include <unistd.h> #include <memory.h> #include <strings.h> #include <string.h> #include <fcntl.h> #include <errno.h> #include <poll.h> #include "kstat.h" /*LINTLIBRARY*/ static void kstat_zalloc(void **ptr, size_t size, int free_first) { if (free_first) free(*ptr); *ptr = calloc(size, 1); } static void kstat_chain_free(kstat_ctl_t *kc) { kstat_t *ksp, *nksp; ksp = kc->kc_chain; while (ksp) { nksp = ksp->ks_next; free(ksp->ks_data); free(ksp); ksp = nksp; } kc->kc_chain = NULL; kc->kc_chain_id = 0; } kstat_ctl_t * kstat_open(void) { kstat_ctl_t *kc; int kd; kd = open("/dev/kstat", O_RDONLY); if (kd == -1) return (NULL); kstat_zalloc((void **)&kc, sizeof (kstat_ctl_t), 0); if (kc == NULL) return (NULL); kc->kc_kd = kd; kc->kc_chain = NULL; kc->kc_chain_id = 0; if (kstat_chain_update(kc) == -1) { int saved_err = errno; (void) kstat_close(kc); errno = saved_err; return (NULL); } return (kc); } int kstat_close(kstat_ctl_t *kc) { int rc; kstat_chain_free(kc); rc = close(kc->kc_kd); free(kc); return (rc); } kid_t kstat_read(kstat_ctl_t *kc, kstat_t *ksp, void *data) { kid_t kcid; if (ksp->ks_data == NULL && ksp->ks_data_size > 0) { kstat_zalloc(&ksp->ks_data, ksp->ks_data_size, 0); if (ksp->ks_data == NULL) return (-1); } while ((kcid = (kid_t)ioctl(kc->kc_kd, KSTAT_IOC_READ, ksp)) == -1) { if (errno == EAGAIN) { (void) poll(NULL, 0, 100); /* back off a moment */ continue; /* and try again */ } /* * Mating dance for variable-size kstats. * You start with a buffer of a certain size, * which you hope will hold all the data. * If your buffer is too small, the kstat driver * returns ENOMEM and sets ksp->ks_data_size to * the current size of the kstat's data. You then * resize your buffer and try again. In practice, * this almost always converges in two passes. */ if (errno == ENOMEM && (ksp->ks_flags & (KSTAT_FLAG_VAR_SIZE | KSTAT_FLAG_LONGSTRINGS))) { kstat_zalloc(&ksp->ks_data, ksp->ks_data_size, 1); if (ksp->ks_data != NULL) continue; } return (-1); } if (data != NULL) { (void) memcpy(data, ksp->ks_data, ksp->ks_data_size); if (ksp->ks_type == KSTAT_TYPE_NAMED && ksp->ks_data_size != ksp->ks_ndata * sizeof (kstat_named_t)) { /* * Has KSTAT_DATA_STRING fields. Fix the pointers. */ uint_t i; kstat_named_t *knp = data; for (i = 0; i < ksp->ks_ndata; i++, knp++) { if (knp->data_type != KSTAT_DATA_STRING) continue; if (KSTAT_NAMED_STR_PTR(knp) == NULL) continue; /* * The offsets of the strings within the * buffers are the same, so add the offset of * the string to the beginning of 'data' to fix * the pointer so that strings in 'data' don't * point at memory in 'ksp->ks_data'. */ KSTAT_NAMED_STR_PTR(knp) = (char *)data + (KSTAT_NAMED_STR_PTR(knp) - (char *)ksp->ks_data); } } } return (kcid); } kid_t kstat_write(kstat_ctl_t *kc, kstat_t *ksp, void *data) { kid_t kcid; if (ksp->ks_data == NULL && ksp->ks_data_size > 0) { kstat_zalloc(&ksp->ks_data, ksp->ks_data_size, 0); if (ksp->ks_data == NULL) return (-1); } if (data != NULL) { (void) memcpy(ksp->ks_data, data, ksp->ks_data_size); if (ksp->ks_type == KSTAT_TYPE_NAMED) { kstat_named_t *oknp = data; kstat_named_t *nknp = KSTAT_NAMED_PTR(ksp); uint_t i; for (i = 0; i < ksp->ks_ndata; i++, oknp++, nknp++) { if (nknp->data_type != KSTAT_DATA_STRING) continue; if (KSTAT_NAMED_STR_PTR(nknp) == NULL) continue; /* * The buffer passed in as 'data' has string * pointers that point within 'data'. Fix the * pointers so they point into the same offset * within the newly allocated buffer. */ KSTAT_NAMED_STR_PTR(nknp) = (char *)ksp->ks_data + (KSTAT_NAMED_STR_PTR(oknp) - (char *)data); } } } while ((kcid = (kid_t)ioctl(kc->kc_kd, KSTAT_IOC_WRITE, ksp)) == -1) { if (errno == EAGAIN) { (void) poll(NULL, 0, 100); /* back off a moment */ continue; /* and try again */ } break; } return (kcid); } /* * If the current KCID is the same as kc->kc_chain_id, return 0; * if different, update the chain and return the new KCID. * This operation is non-destructive for unchanged kstats. */ kid_t kstat_chain_update(kstat_ctl_t *kc) { kstat_t k0, *headers, *oksp, *nksp, **okspp, *next; int i; kid_t kcid; kcid = (kid_t)ioctl(kc->kc_kd, KSTAT_IOC_CHAIN_ID, NULL); if (kcid == -1) return (-1); if (kcid == kc->kc_chain_id) return (0); /* * kstat 0's data is the kstat chain, so we can get the chain * by doing a kstat_read() of this kstat. The only fields the * kstat driver needs are ks_kid (this identifies the kstat), * ks_data (the pointer to our buffer), and ks_data_size (the * size of our buffer). By zeroing the struct we set ks_data = NULL * and ks_data_size = 0, so that kstat_read() will automatically * determine the size and allocate space for us. We also fill in the * name, so that truss can print something meaningful. */ bzero(&k0, sizeof (k0)); (void) strcpy(k0.ks_name, "kstat_headers"); kcid = kstat_read(kc, &k0, NULL); if (kcid == -1) { free(k0.ks_data); /* errno set by kstat_read() */ return (-1); } headers = k0.ks_data; /* * Chain the new headers together */ for (i = 1; i < k0.ks_ndata; i++) headers[i - 1].ks_next = &headers[i]; headers[k0.ks_ndata - 1].ks_next = NULL; /* * Remove all deleted kstats from the chain. */ nksp = headers; okspp = &kc->kc_chain; oksp = kc->kc_chain; while (oksp != NULL) { next = oksp->ks_next; if (nksp != NULL && oksp->ks_kid == nksp->ks_kid) { okspp = &oksp->ks_next; nksp = nksp->ks_next; } else { *okspp = oksp->ks_next; free(oksp->ks_data); free(oksp); } oksp = next; } /* * Add all new kstats to the chain. */ while (nksp != NULL) { kstat_zalloc((void **)okspp, sizeof (kstat_t), 0); if ((oksp = *okspp) == NULL) { free(headers); return (-1); } *oksp = *nksp; okspp = &oksp->ks_next; oksp->ks_next = NULL; oksp->ks_data = NULL; nksp = nksp->ks_next; } free(headers); kc->kc_chain_id = kcid; return (kcid); } kstat_t * kstat_lookup(kstat_ctl_t *kc, char *ks_module, int ks_instance, char *ks_name) { kstat_t *ksp; for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { if ((ks_module == NULL || strcmp(ksp->ks_module, ks_module) == 0) && (ks_instance == -1 || ksp->ks_instance == ks_instance) && (ks_name == NULL || strcmp(ksp->ks_name, ks_name) == 0)) return (ksp); } errno = ENOENT; return (NULL); } void * kstat_data_lookup(kstat_t *ksp, char *name) { int i, size; char *namep, *datap; switch (ksp->ks_type) { case KSTAT_TYPE_NAMED: size = sizeof (kstat_named_t); namep = KSTAT_NAMED_PTR(ksp)->name; break; case KSTAT_TYPE_TIMER: size = sizeof (kstat_timer_t); namep = KSTAT_TIMER_PTR(ksp)->name; break; default: errno = EINVAL; return (NULL); } datap = ksp->ks_data; for (i = 0; i < ksp->ks_ndata; i++) { if (strcmp(name, namep) == 0) return (datap); namep += size; datap += size; } errno = ENOENT; return (NULL); }