1 /*
2 * Copyright (c) 2007 Pawel Jakub Dawidek <[email protected]>
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
__kstat_set_raw_ops(kstat_t * ksp,int (* headers)(char * buf,size_t size),int (* data)(char * buf,size_t size,void * data),void * (* addr)(kstat_t * ksp,loff_t index))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
__kstat_set_seq_raw_ops(kstat_t * ksp,int (* headers)(struct seq_file * f),int (* data)(char * buf,size_t size,void * data),void * (* addr)(kstat_t * ksp,loff_t index))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
kstat_default_update(kstat_t * ksp,int rw)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
kstat_resize_raw(kstat_t * ksp)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 *
kstat_raw_default_addr(kstat_t * ksp,loff_t n)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
kstat_sysctl(SYSCTL_HANDLER_ARGS)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
kstat_sysctl_string(SYSCTL_HANDLER_ARGS)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
kstat_sysctl_dataset(SYSCTL_HANDLER_ARGS)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
kstat_sysctl_dataset_string(SYSCTL_HANDLER_ARGS)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
kstat_sysctl_io(SYSCTL_HANDLER_ARGS)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 sbuf_new_for_sysctl(&sb, NULL, 0, req);
196
197 /* Update the aggsums before reading */
198 (void) ksp->ks_update(ksp, KSTAT_READ);
199
200 /* though wlentime & friends are signed, they will never be negative */
201 sbuf_printf(&sb,
202 "%-8llu %-8llu %-8u %-8u %-8llu %-8llu "
203 "%-8llu %-8llu %-8llu %-8llu %-8u %-8u\n",
204 kip->nread, kip->nwritten,
205 kip->reads, kip->writes,
206 kip->wtime, kip->wlentime, kip->wlastupdate,
207 kip->rtime, kip->rlentime, kip->rlastupdate,
208 kip->wcnt, kip->rcnt);
209 rc = sbuf_finish(&sb);
210 sbuf_delete(&sb);
211 return (rc);
212 }
213
214 static int
kstat_sysctl_raw(SYSCTL_HANDLER_ARGS)215 kstat_sysctl_raw(SYSCTL_HANDLER_ARGS)
216 {
217 struct sbuf sb;
218 void *data;
219 kstat_t *ksp = arg1;
220 void *(*addr_op)(kstat_t *ksp, loff_t index);
221 int n, has_header, rc = 0;
222
223 sbuf_new_for_sysctl(&sb, NULL, PAGE_SIZE, req);
224
225 if (ksp->ks_raw_ops.addr)
226 addr_op = ksp->ks_raw_ops.addr;
227 else
228 addr_op = kstat_raw_default_addr;
229
230 mutex_enter(ksp->ks_lock);
231
232 /* Update the aggsums before reading */
233 (void) ksp->ks_update(ksp, KSTAT_READ);
234
235 ksp->ks_raw_bufsize = PAGE_SIZE;
236 ksp->ks_raw_buf = malloc(PAGE_SIZE, M_TEMP, M_WAITOK);
237
238 n = 0;
239 has_header = (ksp->ks_raw_ops.headers ||
240 ksp->ks_raw_ops.seq_headers);
241
242 restart_headers:
243 if (ksp->ks_raw_ops.headers) {
244 rc = ksp->ks_raw_ops.headers(
245 ksp->ks_raw_buf, ksp->ks_raw_bufsize);
246 } else if (ksp->ks_raw_ops.seq_headers) {
247 struct seq_file f;
248
249 f.sf_buf = ksp->ks_raw_buf;
250 f.sf_size = ksp->ks_raw_bufsize;
251 rc = ksp->ks_raw_ops.seq_headers(&f);
252 }
253 if (has_header) {
254 if (rc == ENOMEM && !kstat_resize_raw(ksp))
255 goto restart_headers;
256 if (rc == 0) {
257 sbuf_cat(&sb, "\n");
258 sbuf_cat(&sb, ksp->ks_raw_buf);
259 }
260 }
261
262 while ((data = addr_op(ksp, n)) != NULL) {
263 restart:
264 if (ksp->ks_raw_ops.data) {
265 rc = ksp->ks_raw_ops.data(ksp->ks_raw_buf,
266 ksp->ks_raw_bufsize, data);
267 if (rc == ENOMEM && !kstat_resize_raw(ksp))
268 goto restart;
269 if (rc == 0)
270 sbuf_cat(&sb, ksp->ks_raw_buf);
271
272 } else {
273 ASSERT3U(ksp->ks_ndata, ==, 1);
274 sbuf_hexdump(&sb, ksp->ks_data,
275 ksp->ks_data_size, NULL, 0);
276 }
277 n++;
278 }
279 free(ksp->ks_raw_buf, M_TEMP);
280 mutex_exit(ksp->ks_lock);
281 rc = sbuf_finish(&sb);
282 sbuf_delete(&sb);
283 return (rc);
284 }
285
286 kstat_t *
__kstat_create(const char * module,int instance,const char * name,const char * class,uchar_t ks_type,uint_t ks_ndata,uchar_t flags)287 __kstat_create(const char *module, int instance, const char *name,
288 const char *class, uchar_t ks_type, uint_t ks_ndata, uchar_t flags)
289 {
290 char buf[KSTAT_STRLEN];
291 struct sysctl_oid *root;
292 kstat_t *ksp;
293 char *pool;
294
295 KASSERT(instance == 0, ("instance=%d", instance));
296 if ((ks_type == KSTAT_TYPE_INTR) || (ks_type == KSTAT_TYPE_IO))
297 ASSERT3U(ks_ndata, ==, 1);
298
299 if (class == NULL)
300 class = "misc";
301
302 /*
303 * Allocate the main structure. We don't need to keep a copy of
304 * module in here, because it is only used for sysctl node creation
305 * done in this function.
306 */
307 ksp = malloc(sizeof (*ksp), M_KSTAT, M_WAITOK|M_ZERO);
308
309 ksp->ks_crtime = gethrtime();
310 ksp->ks_snaptime = ksp->ks_crtime;
311 ksp->ks_instance = instance;
312 (void) strlcpy(ksp->ks_name, name, KSTAT_STRLEN);
313 (void) strlcpy(ksp->ks_class, class, KSTAT_STRLEN);
314 ksp->ks_type = ks_type;
315 ksp->ks_flags = flags;
316 ksp->ks_update = kstat_default_update;
317
318 mutex_init(&ksp->ks_private_lock, NULL, MUTEX_DEFAULT, NULL);
319 ksp->ks_lock = &ksp->ks_private_lock;
320
321 switch (ksp->ks_type) {
322 case KSTAT_TYPE_RAW:
323 ksp->ks_ndata = 1;
324 ksp->ks_data_size = ks_ndata;
325 break;
326 case KSTAT_TYPE_NAMED:
327 ksp->ks_ndata = ks_ndata;
328 ksp->ks_data_size = ks_ndata * sizeof (kstat_named_t);
329 break;
330 case KSTAT_TYPE_INTR:
331 ksp->ks_ndata = ks_ndata;
332 ksp->ks_data_size = ks_ndata * sizeof (kstat_intr_t);
333 break;
334 case KSTAT_TYPE_IO:
335 ksp->ks_ndata = ks_ndata;
336 ksp->ks_data_size = ks_ndata * sizeof (kstat_io_t);
337 break;
338 case KSTAT_TYPE_TIMER:
339 ksp->ks_ndata = ks_ndata;
340 ksp->ks_data_size = ks_ndata * sizeof (kstat_timer_t);
341 break;
342 default:
343 panic("Undefined kstat type %d\n", ksp->ks_type);
344 }
345
346 if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL)
347 ksp->ks_data = NULL;
348 else
349 ksp->ks_data = kmem_zalloc(ksp->ks_data_size, KM_SLEEP);
350
351 /*
352 * Some kstats use a module name like "zfs/poolname" to distinguish a
353 * set of kstats belonging to a specific pool. Split on '/' to add an
354 * extra node for the pool name if needed.
355 */
356 (void) strlcpy(buf, module, KSTAT_STRLEN);
357 module = buf;
358 pool = strchr(module, '/');
359 if (pool != NULL)
360 *pool++ = '\0';
361
362 /*
363 * Create sysctl tree for those statistics:
364 *
365 * kstat.<module>[.<pool>].<class>.<name>
366 */
367 sysctl_ctx_init(&ksp->ks_sysctl_ctx);
368 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
369 SYSCTL_STATIC_CHILDREN(_kstat), OID_AUTO, module, CTLFLAG_RW, 0,
370 "");
371 if (root == NULL) {
372 printf("%s: Cannot create kstat.%s tree!\n", __func__, module);
373 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
374 free(ksp, M_KSTAT);
375 return (NULL);
376 }
377 if (pool != NULL) {
378 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
379 SYSCTL_CHILDREN(root), OID_AUTO, pool, CTLFLAG_RW, 0, "");
380 if (root == NULL) {
381 printf("%s: Cannot create kstat.%s.%s tree!\n",
382 __func__, module, pool);
383 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
384 free(ksp, M_KSTAT);
385 return (NULL);
386 }
387 }
388 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx, SYSCTL_CHILDREN(root),
389 OID_AUTO, class, CTLFLAG_RW, 0, "");
390 if (root == NULL) {
391 if (pool != NULL)
392 printf("%s: Cannot create kstat.%s.%s.%s tree!\n",
393 __func__, module, pool, class);
394 else
395 printf("%s: Cannot create kstat.%s.%s tree!\n",
396 __func__, module, class);
397 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
398 free(ksp, M_KSTAT);
399 return (NULL);
400 }
401 if (ksp->ks_type == KSTAT_TYPE_NAMED) {
402 root = SYSCTL_ADD_NODE(&ksp->ks_sysctl_ctx,
403 SYSCTL_CHILDREN(root),
404 OID_AUTO, name, CTLFLAG_RW, 0, "");
405 if (root == NULL) {
406 if (pool != NULL)
407 printf("%s: Cannot create kstat.%s.%s.%s.%s "
408 "tree!\n", __func__, module, pool, class,
409 name);
410 else
411 printf("%s: Cannot create kstat.%s.%s.%s "
412 "tree!\n", __func__, module, class, name);
413 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
414 free(ksp, M_KSTAT);
415 return (NULL);
416 }
417
418 }
419 ksp->ks_sysctl_root = root;
420
421 return (ksp);
422 }
423
424 static void
kstat_install_named(kstat_t * ksp)425 kstat_install_named(kstat_t *ksp)
426 {
427 kstat_named_t *ksent;
428 char *namelast;
429 int typelast;
430
431 ksent = ksp->ks_data;
432
433 VERIFY((ksp->ks_flags & KSTAT_FLAG_VIRTUAL) || ksent != NULL);
434
435 typelast = 0;
436 namelast = NULL;
437
438 for (int i = 0; i < ksp->ks_ndata; i++, ksent++) {
439 if (ksent->data_type != 0) {
440 typelast = ksent->data_type;
441 namelast = ksent->name;
442 }
443 switch (typelast) {
444 case KSTAT_DATA_CHAR:
445 /* Not Implemented */
446 break;
447 case KSTAT_DATA_INT32:
448 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
449 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
450 OID_AUTO, namelast,
451 CTLTYPE_S32 | CTLFLAG_RD | CTLFLAG_MPSAFE,
452 ksp, i, kstat_sysctl, "I", namelast);
453 break;
454 case KSTAT_DATA_UINT32:
455 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
456 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
457 OID_AUTO, namelast,
458 CTLTYPE_U32 | CTLFLAG_RD | CTLFLAG_MPSAFE,
459 ksp, i, kstat_sysctl, "IU", namelast);
460 break;
461 case KSTAT_DATA_INT64:
462 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
463 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
464 OID_AUTO, namelast,
465 CTLTYPE_S64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
466 ksp, i, kstat_sysctl, "Q", namelast);
467 break;
468 case KSTAT_DATA_UINT64:
469 if (strcmp(ksp->ks_class, "dataset") == 0) {
470 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
471 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
472 OID_AUTO, namelast,
473 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
474 ksp, i, kstat_sysctl_dataset, "QU",
475 namelast);
476 } else {
477 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
478 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
479 OID_AUTO, namelast,
480 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_MPSAFE,
481 ksp, i, kstat_sysctl, "QU", namelast);
482 }
483 break;
484 case KSTAT_DATA_LONG:
485 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
486 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
487 OID_AUTO, namelast,
488 CTLTYPE_LONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
489 ksp, i, kstat_sysctl, "L", namelast);
490 break;
491 case KSTAT_DATA_ULONG:
492 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
493 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
494 OID_AUTO, namelast,
495 CTLTYPE_ULONG | CTLFLAG_RD | CTLFLAG_MPSAFE,
496 ksp, i, kstat_sysctl, "LU", namelast);
497 break;
498 case KSTAT_DATA_STRING:
499 if (strcmp(ksp->ks_class, "dataset") == 0) {
500 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
501 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
502 OID_AUTO, namelast, CTLTYPE_STRING |
503 CTLFLAG_RD | CTLFLAG_MPSAFE,
504 ksp, i, kstat_sysctl_dataset_string, "A",
505 namelast);
506 } else {
507 SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
508 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
509 OID_AUTO, namelast, CTLTYPE_STRING |
510 CTLFLAG_RD | CTLFLAG_MPSAFE,
511 ksp, i, kstat_sysctl_string, "A",
512 namelast);
513 }
514 break;
515 default:
516 panic("unsupported type: %d", typelast);
517 }
518 }
519 }
520
521 void
kstat_install(kstat_t * ksp)522 kstat_install(kstat_t *ksp)
523 {
524 struct sysctl_oid *root;
525
526 if (ksp->ks_ndata == UINT32_MAX)
527 VERIFY3U(ksp->ks_type, ==, KSTAT_TYPE_RAW);
528
529 switch (ksp->ks_type) {
530 case KSTAT_TYPE_NAMED:
531 return (kstat_install_named(ksp));
532 case KSTAT_TYPE_RAW:
533 if (ksp->ks_raw_ops.data) {
534 root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
535 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
536 OID_AUTO, ksp->ks_name, CTLTYPE_STRING | CTLFLAG_RD
537 | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
538 ksp, 0, kstat_sysctl_raw, "A", ksp->ks_name);
539 } else {
540 root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
541 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
542 OID_AUTO, ksp->ks_name, CTLTYPE_OPAQUE | CTLFLAG_RD
543 | CTLFLAG_MPSAFE | CTLFLAG_SKIP,
544 ksp, 0, kstat_sysctl_raw, "", ksp->ks_name);
545 }
546 break;
547 case KSTAT_TYPE_IO:
548 root = SYSCTL_ADD_PROC(&ksp->ks_sysctl_ctx,
549 SYSCTL_CHILDREN(ksp->ks_sysctl_root),
550 OID_AUTO, ksp->ks_name,
551 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
552 ksp, 0, kstat_sysctl_io, "A", ksp->ks_name);
553 break;
554 case KSTAT_TYPE_TIMER:
555 case KSTAT_TYPE_INTR:
556 default:
557 panic("unsupported kstat type %d\n", ksp->ks_type);
558 }
559 VERIFY3P(root, !=, NULL);
560 ksp->ks_sysctl_root = root;
561 }
562
563 void
kstat_delete(kstat_t * ksp)564 kstat_delete(kstat_t *ksp)
565 {
566
567 sysctl_ctx_free(&ksp->ks_sysctl_ctx);
568 ksp->ks_lock = NULL;
569 mutex_destroy(&ksp->ks_private_lock);
570 if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
571 kmem_free(ksp->ks_data, ksp->ks_data_size);
572 free(ksp, M_KSTAT);
573 }
574