module/os/freebsd/spl/spl_kstat.c

   1 /*
   2  * Copyright (c) 2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * Links to Illumos.org for more information on kstat function:
  27  * [1] https://illumos.org/man/1M/kstat
  28  * [2] https://illumos.org/man/9f/kstat_create
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/types.h>
  35 #include <sys/param.h>
  36 #include <sys/kernel.h>
  37 #include <sys/systm.h>
  38 #include <sys/malloc.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/kstat.h>
  41 #include <sys/sbuf.h>
  42 #include <sys/zone.h>
  43
  44 static MALLOC_DEFINE(M_KSTAT, "kstat_data", "Kernel statistics");
  45
  46 SYSCTL_ROOT_NODE(OID_AUTO, kstat, CTLFLAG_RW, 0, "Kernel statistics");
  47
  48 void
  49 __kstat_set_raw_ops(kstat_t *ksp,
  50     int (*headers)(char *buf, size_t size),
  51     int (*data)(char *buf, size_t size, void *data),
  52     void *(*addr)(kstat_t *ksp, loff_t index))
  53 {
  54         ksp->ks_raw_ops.headers = headers;
  55         ksp->ks_raw_ops.data    = data;
  56         ksp->ks_raw_ops.addr    = addr;
  57 }
  58
  59 void
  60 __kstat_set_seq_raw_ops(kstat_t *ksp,
  61     int (*headers)(struct seq_file *f),
  62     int (*data)(char *buf, size_t size, void *data),
  63     void *(*addr)(kstat_t *ksp, loff_t index))
  64 {
  65         ksp->ks_raw_ops.seq_headers = headers;
  66         ksp->ks_raw_ops.data    = data;
  67         ksp->ks_raw_ops.addr    = addr;
  68 }
  69
  70 static int
  71 kstat_default_update(kstat_t *ksp, int rw)
  72 {
  73         ASSERT3P(ksp, !=, NULL);
  74
  75         if (rw == KSTAT_WRITE)
  76                 return (EACCES);
  77
  78         return (0);
  79 }
  80
  81 static int
  82 kstat_resize_raw(kstat_t *ksp)
  83 {
  84         if (ksp->ks_raw_bufsize == KSTAT_RAW_MAX)
  85                 return (ENOMEM);
  86
  87         free(ksp->ks_raw_buf, M_TEMP);
  88         ksp->ks_raw_bufsize = MIN(ksp->ks_raw_bufsize * 2, KSTAT_RAW_MAX);
  89         ksp->ks_raw_buf = malloc(ksp->ks_raw_bufsize, M_TEMP, M_WAITOK);
  90
  91         return (0);
  92 }
  93
  94 static void *
  95 kstat_raw_default_addr(kstat_t *ksp, loff_t n)
  96 {
  97         if (n == 0)
  98                 return (ksp->ks_data);
  99         return (NULL);
 100 }
 101
 102 static int
 103 kstat_sysctl(SYSCTL_HANDLER_ARGS)
 104 {
 105         kstat_t *ksp = arg1;
 106         kstat_named_t *ksent;
 107         uint64_t val;
 108
 109         ksent = ksp->ks_data;
 110         /* Select the correct element */
 111         ksent += arg2;
 112         /* Update the aggsums before reading */
 113         (void) ksp->ks_update(ksp, KSTAT_READ);
 114         val = ksent->value.ui64;
 115
 116         return (sysctl_handle_64(oidp, &val, 0, req));
 117 }
 118
 119 static int
 120 kstat_sysctl_string(SYSCTL_HANDLER_ARGS)
 121 {
 122         kstat_t *ksp = arg1;
 123         kstat_named_t *ksent = ksp->ks_data;
 124         char *val;
 125         uint32_t len = 0;
 126
 127         /* Select the correct element */
 128         ksent += arg2;
 129         /* Update the aggsums before reading */
 130         (void) ksp->ks_update(ksp, KSTAT_READ);
 131         val = KSTAT_NAMED_STR_PTR(ksent);
 132         len = KSTAT_NAMED_STR_BUFLEN(ksent);
 133         val[len-1] = '\0';
 134
 135         return (sysctl_handle_string(oidp, val, len, req));
 136 }
 137
 138 static int
 139 kstat_sysctl_dataset(SYSCTL_HANDLER_ARGS)
 140 {
 141         kstat_t *ksp = arg1;
 142         kstat_named_t *ksent;
 143         kstat_named_t *ksent_ds;
 144         uint64_t val;
 145         char *ds_name;
 146         uint32_t ds_len = 0;
 147
 148         ksent_ds = ksent = ksp->ks_data;
 149         ds_name = KSTAT_NAMED_STR_PTR(ksent_ds);
 150         ds_len = KSTAT_NAMED_STR_BUFLEN(ksent_ds);
 151         ds_name[ds_len-1] = '\0';
 152
 153         if (!zone_dataset_visible(ds_name, NULL)) {
 154                 return (EPERM);
 155         }
 156
 157         /* Select the correct element */
 158         ksent += arg2;
 159         /* Update the aggsums before reading */
 160         (void) ksp->ks_update(ksp, KSTAT_READ);
 161         val = ksent->value.ui64;
 162
 163         return (sysctl_handle_64(oidp, &val, 0, req));
 164 }
 165
 166 static int
 167 kstat_sysctl_dataset_string(SYSCTL_HANDLER_ARGS)
 168 {
 169         kstat_t *ksp = arg1;
 170         kstat_named_t *ksent = ksp->ks_data;
 171         char *val;
 172         uint32_t len = 0;
 173
 174         /* Select the correct element */
 175         ksent += arg2;
 176         val = KSTAT_NAMED_STR_PTR(ksent);
 177         len = KSTAT_NAMED_STR_BUFLEN(ksent);
 178         val[len-1] = '\0';
 179
 180         if (!zone_dataset_visible(val, NULL)) {
 181                 return (EPERM);
 182         }
 183
 184         return (sysctl_handle_string(oidp, val, len, req));
 185 }
 186
 187 static int
 188 kstat_sysctl_io(SYSCTL_HANDLER_ARGS)
 189 {
 190         struct sbuf *sb;
 191         kstat_t *ksp = arg1;
 192         kstat_io_t *kip = ksp->ks_data;
 193         int rc;
 194
 195         sb = sbuf_new_auto();
 196         if (sb == NULL)
 197                 return (ENOMEM);
 198         /* Update the aggsums before reading */
 199         (void) ksp->ks_update(ksp, KSTAT_READ);
 200
 201         /* though wlentime & friends are signed, they will never be negative */
 202         sbuf_printf(sb,
 203             "%-8llu %-8llu %-8u %-8u %-8llu %-8llu "
 204             "%-8llu %-8llu %-8llu %-8llu %-8u %-8u\n",
 205             kip->nread, kip->nwritten,
 206             kip->reads, kip->writes,
 207             kip->wtime, kip->wlentime, kip->wlastupdate,
 208             kip->rtime, kip->rlentime, kip->rlastupdate,
 209             kip->wcnt,  kip->rcnt);
 210         rc = sbuf_finish(sb);
 211         if (rc == 0)
 212                 rc = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb));
 213         sbuf_delete(sb);
 214         return (rc);
 215 }
 216
 217 static int
 218 kstat_sysctl_raw(SYSCTL_HANDLER_ARGS)
 219 {
 220         struct sbuf *sb;
 221         void *data;
 222         kstat_t *ksp = arg1;
 223         void *(*addr_op)(kstat_t *ksp, loff_t index);
 224         int n, has_header, rc = 0;
 225
 226         sb = sbuf_new_auto();
 227         if (sb == NULL)
 228                 return (ENOMEM);
 229
 230         if (ksp->ks_raw_ops.addr)
 231                 addr_op = ksp->ks_raw_ops.addr;
 232         else
 233                 addr_op = kstat_raw_default_addr;
 234
 235         mutex_enter(ksp->ks_lock);
 236
 237         /* Update the aggsums before reading */
 238         (void) ksp->ks_update(ksp, KSTAT_READ);
 239
 240         ksp->ks_raw_bufsize = PAGE_SIZE;
 241         ksp->ks_raw_buf = malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
 242
 243         n = 0;
 244         has_header = (ksp->ks_raw_ops.headers ||
 245             ksp->ks_raw_ops.seq_headers);
 246
 247 restart_headers:
 248         if (ksp->ks_raw_ops.headers) {
 249                 rc = ksp->ks_raw_ops.headers(
 250                     ksp->ks_raw_buf, ksp->ks_raw_bufsize);
 251         } else if (ksp->ks_raw_ops.seq_headers) {
 252                 struct seq_file f;
 253
 254                 f.sf_buf = ksp->ks_raw_buf;
 255                 f.sf_size = ksp->ks_raw_bufsize;
 256                 rc = ksp->ks_raw_ops.seq_headers(&f);
 257         }
 258         if (has_header) {
 259                 if (rc == ENOMEM && !kstat_resize_raw(ksp))
 260                         goto restart_headers;
 261                 if (rc == 0)
 262                         sbuf_printf(sb, "\n%s", ksp->ks_raw_buf);
 263         }
 264
 265         while ((data = addr_op(ksp, n)) != NULL) {
 266 restart:
 267                 if (ksp->ks_raw_ops.data) {
 268                         rc = ksp->ks_raw_ops.data(ksp->ks_raw_buf,
 269                             ksp->ks_raw_bufsize, data);
 270                         if (rc == ENOMEM && !kstat_resize_raw(ksp))
 271                                 goto restart;
 272                         if (rc == 0)
 273                                 sbuf_printf(sb, "%s", ksp->ks_raw_buf);
 274
 275                 } else {
 276                         ASSERT3U(ksp->ks_ndata, ==, 1);
 277                         sbuf_hexdump(sb, ksp->ks_data,
 278                             ksp->ks_data_size, NULL, 0);
 279                 }
 280                 n++;
 281         }
 282         free(ksp->ks_raw_buf, M_TEMP);
 283         mutex_exit(ksp->ks_lock);
 284         sbuf_trim(sb);
 285         rc = sbuf_finish(sb);
 286         if (rc == 0)
 287                 rc = SYSCTL_OUT(req, sbuf_data(sb), sbuf_len(sb));
 288         sbuf_delete(sb);
 289         return (rc);
 290 }
 291
 292 kstat_t *
 293 __kstat_create(const char *module, int instance, const char *name,
 294     const char *class, uchar_t ks_type, uint_t ks_ndata, uchar_t flags)
 295 {
 296         char buf[KSTAT_STRLEN];
 297         struct sysctl_oid *root;
 298         kstat_t *ksp;
 299         char *pool;
 300
 301         KASSERT(instance == 0, ("instance=%d", instance));
 302         if ((ks_type == KSTAT_TYPE_INTR) || (ks_type == KSTAT_TYPE_IO))
 303                 ASSERT3U(ks_ndata, ==, 1);
 304
 305         if (class == NULL)
 306                 class = "misc";
 307
 308         /*
 309          * Allocate the main structure. We don't need to keep a copy of
 310          * module in here, because it is only used for sysctl node creation
 311          * done in this function.
 312          */
 313         ksp = malloc(sizeof (*ksp), M_KSTAT, M_WAITOK|M_ZERO);
 314
 315         ksp->ks_crtime = gethrtime();
 316         ksp->ks_snaptime = ksp->ks_crtime;
 317         ksp->ks_instance = instance;
 318         (void) strlcpy(ksp->ks_name, name, KSTAT_STRLEN);
 319         (void) strlcpy(ksp->ks_class, class, KSTAT_STRLEN);
 320         ksp->ks_type = ks_type;
 321         ksp->ks_flags = flags;
 322         ksp->ks_update = kstat_default_update;
 323
 324         mutex_init(&ksp->ks_private_lock, NULL, MUTEX_DEFAULT, NULL);
 325         ksp->ks_lock = &ksp->ks_private_lock;
 326
 327         switch (ksp->ks_type) {
 328         case KSTAT_TYPE_RAW:
 329                 ksp->ks_ndata = 1;
 330                 ksp->ks_data_size = ks_ndata;
 331                 break;
 332         case KSTAT_TYPE_NAMED:
 333                 ksp->ks_ndata = ks_ndata;
 334                 ksp->ks_data_size = ks_ndata * sizeof (kstat_named_t);
 335                 break;
 336         case KSTAT_TYPE_INTR:
 337                 ksp->ks_ndata = ks_ndata;
 338                 ksp->ks_data_size = ks_ndata * sizeof (kstat_intr_t);
 339                 break;
 340         case KSTAT_TYPE_IO:
 341                 ksp->ks_ndata = ks_ndata;
 342                 ksp->ks_data_size = ks_ndata * sizeof (kstat_io_t);
 343                 break;
 344         case KSTAT_TYPE_TIMER:
 345                 ksp->ks_ndata = ks_ndata;
 346                 ksp->ks_data_size = ks_ndata * sizeof (kstat_timer_t);
 347                 break;
 348         default:
 349                 panic("Undefined kstat type %d\n", ksp->ks_type);
 350         }
 351
 352         if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL)
 353                 ksp->ks_data = NULL;
 354         else
 355                 ksp->ks_data = kmem_zalloc(ksp->ks_data_size, KM_SLEEP);
 356
 357         /*
 358          * Some kstats use a module name like "zfs/poolname" to distinguish a
 359          * set of kstats belonging to a specific pool.  Split on '/' to add an
 360          * extra node for the pool name if needed.
 361          */
 362         (void) strlcpy(buf, module, KSTAT_STRLEN);
 363         module = buf;
 364         pool = strchr(module, '/');
 365         if (pool != NULL)
 366                 *pool++ = '\0';
 367
 368         /*
 369          * Create sysctl tree for those statistics:
 370          *
 371          *      kstat.<module>[.<pool>].<class>.<name>
 372          */
 373         sysctl_ctx_init(&ksp->ks_sysctl_ctx);
 374         root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
 375             SYSCTL_STATIC_CHILDREN(_kstat), OID_AUTO, module, CTLFLAG_RW, 0,
 376             "");
 377         if (root == NULL) {
 378                 printf("%s: Cannot create kstat.%s tree!\n", __func__, module);
 379                 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
 380                 free(ksp, M_KSTAT);
 381                 return (NULL);
 382         }
 383         if (pool != NULL) {
 384                 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
 385                     SYSCTL_CHILDREN(root), OID_AUTO, pool, CTLFLAG_RW, 0, "");
 386                 if (root == NULL) {
 387                         printf("%s: Cannot create kstat.%s.%s tree!\n",
 388                             __func__, module, pool);
 389                         sysctl_ctx_free(&ksp->ks_sysctl_ctx);
 390                         free(ksp, M_KSTAT);
 391                         return (NULL);
 392                 }
 393         }
 394         root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx, SYSCTL_CHILDREN(root),
 395             OID_AUTO, class, CTLFLAG_RW, 0, "");
 396         if (root == NULL) {
 397                 if (pool != NULL)
 398                         printf("%s: Cannot create kstat.%s.%s.%s tree!\n",
 399                             __func__, module, pool, class);
 400                 else
 401                         printf("%s: Cannot create kstat.%s.%s tree!\n",
 402                             __func__, module, class);
 403                 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
 404                 free(ksp, M_KSTAT);
 405                 return (NULL);
 406         }
 407         if (ksp->ks_type == KSTAT_TYPE_NAMED) {
 408                 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
 409                     SYSCTL_CHILDREN(root),
 410                     OID_AUTO, name, CTLFLAG_RW, 0, "");
 411                 if (root == NULL) {
 412                         if (pool != NULL)
 413                                 printf("%s: Cannot create kstat.%s.%s.%s.%s "
 414                                     "tree!\n", __func__, module, pool, class,
 415                                     name);
 416                         else
 417                                 printf("%s: Cannot create kstat.%s.%s.%s "
 418                                     "tree!\n", __func__, module, class, name);
 419                         sysctl_ctx_free(&ksp->ks_sysctl_ctx);
 420                         free(ksp, M_KSTAT);
 421                         return (NULL);
 422                 }
 423
 424         }
 425         ksp->ks_sysctl_root = root;
 426
 427         return (ksp);
 428 }
 429
 430 static void
 431 kstat_install_named(kstat_t *ksp)
 432 {
 433         kstat_named_t *ksent;
 434         char *namelast;
 435         int typelast;
 436
 437         ksent = ksp->ks_data;
 438
 439         VERIFY((ksp->ks_flags & KSTAT_FLAG_VIRTUAL) || ksent != NULL);
 440
 441         typelast = 0;
 442         namelast = NULL;
 443
 444         for (int i = 0; i < ksp->ks_ndata; i++, ksent++) {
 445                 if (ksent->data_type != 0) {
 446                         typelast = ksent->data_type;
 447                         namelast = ksent->name;
 448                 }
 449                 switch (typelast) {
 450                 case KSTAT_DATA_CHAR:
 451                         /* Not Implemented */
 452                         break;
 453                 case KSTAT_DATA_INT32:
 454                         SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 455                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 456                             OID_AUTO, namelast,
 457                             CTLTYPE_S32 | CTLFLAG_RD | CTLFLAG_MPSAFE,
 458                             ksp, i, kstat_sysctl, "I", namelast);
 459                         break;
 460                 case KSTAT_DATA_UINT32:
 461                         SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 462                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 463                             OID_AUTO, namelast,
 464                             CTLTYPE_U32 | CTLFLAG_RD | CTLFLAG_MPSAFE,
 465                             ksp, i, kstat_sysctl, "IU", namelast);
 466                         break;
 467                 case KSTAT_DATA_INT64:
 468                         SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 469                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 470                             OID_AUTO, namelast,
 471                             CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
 472                             ksp, i, kstat_sysctl, "Q", namelast);
 473                         break;
 474                 case KSTAT_DATA_UINT64:
 475                         if (strcmp(ksp->ks_class, "dataset") == 0) {
 476                                 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 477                                     SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 478                                     OID_AUTO, namelast,
 479                                     CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
 480                                     ksp, i, kstat_sysctl_dataset, "QU",
 481                                     namelast);
 482                         } else {
 483                                 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 484                                     SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 485                                     OID_AUTO, namelast,
 486                                     CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
 487                                     ksp, i, kstat_sysctl, "QU", namelast);
 488                         }
 489                         break;
 490                 case KSTAT_DATA_LONG:
 491                         SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 492                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 493                             OID_AUTO, namelast,
 494                             CTLTYPE_LONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
 495                             ksp, i, kstat_sysctl, "L", namelast);
 496                         break;
 497                 case KSTAT_DATA_ULONG:
 498                         SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 499                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 500                             OID_AUTO, namelast,
 501                             CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
 502                             ksp, i, kstat_sysctl, "LU", namelast);
 503                         break;
 504                 case KSTAT_DATA_STRING:
 505                         if (strcmp(ksp->ks_class, "dataset") == 0) {
 506                                 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 507                                     SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 508                                     OID_AUTO, namelast, CTLTYPE_STRING |
 509                                     CTLFLAG_RD | CTLFLAG_MPSAFE,
 510                                     ksp, i, kstat_sysctl_dataset_string, "A",
 511                                     namelast);
 512                         } else {
 513                                 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 514                                     SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 515                                     OID_AUTO, namelast, CTLTYPE_STRING |
 516                                     CTLFLAG_RD | CTLFLAG_MPSAFE,
 517                                     ksp, i, kstat_sysctl_string, "A",
 518                                     namelast);
 519                         }
 520                         break;
 521                 default:
 522                         panic("unsupported type: %d", typelast);
 523                 }
 524         }
 525 }
 526
 527 void
 528 kstat_install(kstat_t *ksp)
 529 {
 530         struct sysctl_oid *root;
 531
 532         if (ksp->ks_ndata == UINT32_MAX)
 533                 VERIFY3U(ksp->ks_type, ==, KSTAT_TYPE_RAW);
 534
 535         switch (ksp->ks_type) {
 536         case KSTAT_TYPE_NAMED:
 537                 return (kstat_install_named(ksp));
 538         case KSTAT_TYPE_RAW:
 539                 if (ksp->ks_raw_ops.data) {
 540                         root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 541                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 542                             OID_AUTO, ksp->ks_name, CTLTYPE_STRING | CTLFLAG_RD
 543                             | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
 544                             ksp, 0, kstat_sysctl_raw, "A", ksp->ks_name);
 545                 } else {
 546                         root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 547                             SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 548                             OID_AUTO, ksp->ks_name, CTLTYPE_OPAQUE | CTLFLAG_RD
 549                             | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
 550                             ksp, 0, kstat_sysctl_raw, "", ksp->ks_name);
 551                 }
 552                 break;
 553         case KSTAT_TYPE_IO:
 554                 root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
 555                     SYSCTL_CHILDREN(ksp->ks_sysctl_root),
 556                     OID_AUTO, ksp->ks_name,
 557                     CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
 558                     ksp, 0, kstat_sysctl_io, "A", ksp->ks_name);
 559                 break;
 560         case KSTAT_TYPE_TIMER:
 561         case KSTAT_TYPE_INTR:
 562         default:
 563                 panic("unsupported kstat type %d\n", ksp->ks_type);
 564         }
 565         VERIFY3P(root, !=, NULL);
 566         ksp->ks_sysctl_root = root;
 567 }
 568
 569 void
 570 kstat_delete(kstat_t *ksp)
 571 {
 572
 573         sysctl_ctx_free(&ksp->ks_sysctl_ctx);
 574         ksp->ks_lock = NULL;
 575         mutex_destroy(&ksp->ks_private_lock);
 576         if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
 577                 kmem_free(ksp->ks_data, ksp->ks_data_size);
 578         free(ksp, M_KSTAT);
 579 }