2 * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
3 * Copyright (C) 2007 The Regents of the University of California.
4 * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
5 * Written by Brian Behlendorf <behlendorf1@llnl.gov>.
8 * This file is part of the SPL, Solaris Porting Layer.
9 * For details, see <http://zfsonlinux.org/>.
11 * The SPL is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
16 * The SPL is distributed in the hope that it will be useful, but WITHOUT
17 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 * You should have received a copy of the GNU General Public License along
22 * with the SPL. If not, see <http://www.gnu.org/licenses/>.
24 * Solaris Porting Layer (SPL) Kstat Implementation.
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
31 #include <linux/seq_file.h>
32 #include <sys/kstat.h>
34 #include <sys/cmn_err.h>
35 #include <sys/sysmacros.h>
37 static kmutex_t kstat_module_lock;
38 static struct list_head kstat_module_list;
39 static kid_t kstat_id;
42 kstat_resize_raw(kstat_t *ksp)
44 if (ksp->ks_raw_bufsize == KSTAT_RAW_MAX)
47 vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);
48 ksp->ks_raw_bufsize = MIN(ksp->ks_raw_bufsize * 2, KSTAT_RAW_MAX);
49 ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);
55 kstat_waitq_enter(kstat_io_t *kiop)
61 delta = new - kiop->wlastupdate;
62 kiop->wlastupdate = new;
65 kiop->wlentime += delta * wcnt;
69 EXPORT_SYMBOL(kstat_waitq_enter);
72 kstat_waitq_exit(kstat_io_t *kiop)
78 delta = new - kiop->wlastupdate;
79 kiop->wlastupdate = new;
81 ASSERT((int)wcnt > 0);
82 kiop->wlentime += delta * wcnt;
85 EXPORT_SYMBOL(kstat_waitq_exit);
88 kstat_runq_enter(kstat_io_t *kiop)
94 delta = new - kiop->rlastupdate;
95 kiop->rlastupdate = new;
98 kiop->rlentime += delta * rcnt;
102 EXPORT_SYMBOL(kstat_runq_enter);
105 kstat_runq_exit(kstat_io_t *kiop)
111 delta = new - kiop->rlastupdate;
112 kiop->rlastupdate = new;
114 ASSERT((int)rcnt > 0);
115 kiop->rlentime += delta * rcnt;
116 kiop->rtime += delta;
118 EXPORT_SYMBOL(kstat_runq_exit);
121 kstat_seq_show_headers(struct seq_file *f)
123 kstat_t *ksp = (kstat_t *)f->private;
126 ASSERT(ksp->ks_magic == KS_MAGIC);
128 seq_printf(f, "%d %d 0x%02x %d %d %lld %lld\n",
129 ksp->ks_kid, ksp->ks_type, ksp->ks_flags,
130 ksp->ks_ndata, (int)ksp->ks_data_size,
131 ksp->ks_crtime, ksp->ks_snaptime);
133 switch (ksp->ks_type) {
136 if (ksp->ks_raw_ops.headers) {
137 rc = ksp->ks_raw_ops.headers(
138 ksp->ks_raw_buf, ksp->ks_raw_bufsize);
139 if (rc == ENOMEM && !kstat_resize_raw(ksp))
142 seq_puts(f, ksp->ks_raw_buf);
144 seq_printf(f, "raw data\n");
147 case KSTAT_TYPE_NAMED:
148 seq_printf(f, "%-31s %-4s %s\n",
149 "name", "type", "data");
151 case KSTAT_TYPE_INTR:
152 seq_printf(f, "%-8s %-8s %-8s %-8s %-8s\n",
153 "hard", "soft", "watchdog",
154 "spurious", "multsvc");
158 "%-8s %-8s %-8s %-8s %-8s %-8s "
159 "%-8s %-8s %-8s %-8s %-8s %-8s\n",
160 "nread", "nwritten", "reads", "writes",
161 "wtime", "wlentime", "wupdate",
162 "rtime", "rlentime", "rupdate",
165 case KSTAT_TYPE_TIMER:
168 "%-8s %-8s %-8s %-8s %-8s\n",
169 "name", "events", "elapsed",
170 "min", "max", "start", "stop");
173 PANIC("Undefined kstat type %d\n", ksp->ks_type);
180 kstat_seq_show_raw(struct seq_file *f, unsigned char *p, int l)
185 seq_printf(f, "%03x:", i);
187 for (j = 0; j < 16; j++) {
188 if (i * 16 + j >= l) {
193 seq_printf(f, " %02x", (unsigned char)p[i * 16 + j]);
202 kstat_seq_show_named(struct seq_file *f, kstat_named_t *knp)
204 seq_printf(f, "%-31s %-4d ", knp->name, knp->data_type);
206 switch (knp->data_type) {
207 case KSTAT_DATA_CHAR:
208 knp->value.c[15] = '\0'; /* NULL terminate */
209 seq_printf(f, "%-16s", knp->value.c);
212 * NOTE - We need to be more careful able what tokens are
213 * used for each arch, for now this is correct for x86_64.
215 case KSTAT_DATA_INT32:
216 seq_printf(f, "%d", knp->value.i32);
218 case KSTAT_DATA_UINT32:
219 seq_printf(f, "%u", knp->value.ui32);
221 case KSTAT_DATA_INT64:
222 seq_printf(f, "%lld", (signed long long)knp->value.i64);
224 case KSTAT_DATA_UINT64:
225 seq_printf(f, "%llu",
226 (unsigned long long)knp->value.ui64);
228 case KSTAT_DATA_LONG:
229 seq_printf(f, "%ld", knp->value.l);
231 case KSTAT_DATA_ULONG:
232 seq_printf(f, "%lu", knp->value.ul);
234 case KSTAT_DATA_STRING:
235 KSTAT_NAMED_STR_PTR(knp)
236 [KSTAT_NAMED_STR_BUFLEN(knp)-1] = '\0';
237 seq_printf(f, "%s", KSTAT_NAMED_STR_PTR(knp));
240 PANIC("Undefined kstat data type %d\n", knp->data_type);
249 kstat_seq_show_intr(struct seq_file *f, kstat_intr_t *kip)
251 seq_printf(f, "%-8u %-8u %-8u %-8u %-8u\n",
252 kip->intrs[KSTAT_INTR_HARD],
253 kip->intrs[KSTAT_INTR_SOFT],
254 kip->intrs[KSTAT_INTR_WATCHDOG],
255 kip->intrs[KSTAT_INTR_SPURIOUS],
256 kip->intrs[KSTAT_INTR_MULTSVC]);
262 kstat_seq_show_io(struct seq_file *f, kstat_io_t *kip)
264 /* though wlentime & friends are signed, they will never be negative */
266 "%-8llu %-8llu %-8u %-8u %-8llu %-8llu "
267 "%-8llu %-8llu %-8llu %-8llu %-8u %-8u\n",
268 kip->nread, kip->nwritten,
269 kip->reads, kip->writes,
270 kip->wtime, kip->wlentime, kip->wlastupdate,
271 kip->rtime, kip->rlentime, kip->rlastupdate,
272 kip->wcnt, kip->rcnt);
278 kstat_seq_show_timer(struct seq_file *f, kstat_timer_t *ktp)
281 "%-31s %-8llu %-8llu %-8llu %-8llu %-8llu %-8llu\n",
282 ktp->name, ktp->num_events, ktp->elapsed_time,
283 ktp->min_time, ktp->max_time,
284 ktp->start_time, ktp->stop_time);
290 kstat_seq_show(struct seq_file *f, void *p)
292 kstat_t *ksp = (kstat_t *)f->private;
295 ASSERT(ksp->ks_magic == KS_MAGIC);
297 switch (ksp->ks_type) {
300 if (ksp->ks_raw_ops.data) {
301 rc = ksp->ks_raw_ops.data(
302 ksp->ks_raw_buf, ksp->ks_raw_bufsize, p);
303 if (rc == ENOMEM && !kstat_resize_raw(ksp))
306 seq_puts(f, ksp->ks_raw_buf);
308 ASSERT(ksp->ks_ndata == 1);
309 rc = kstat_seq_show_raw(f, ksp->ks_data,
313 case KSTAT_TYPE_NAMED:
314 rc = kstat_seq_show_named(f, (kstat_named_t *)p);
316 case KSTAT_TYPE_INTR:
317 rc = kstat_seq_show_intr(f, (kstat_intr_t *)p);
320 rc = kstat_seq_show_io(f, (kstat_io_t *)p);
322 case KSTAT_TYPE_TIMER:
323 rc = kstat_seq_show_timer(f, (kstat_timer_t *)p);
326 PANIC("Undefined kstat type %d\n", ksp->ks_type);
333 kstat_default_update(kstat_t *ksp, int rw)
337 if (rw == KSTAT_WRITE)
344 kstat_seq_data_addr(kstat_t *ksp, loff_t n)
348 switch (ksp->ks_type) {
350 if (ksp->ks_raw_ops.addr)
351 rc = ksp->ks_raw_ops.addr(ksp, n);
355 case KSTAT_TYPE_NAMED:
356 rc = ksp->ks_data + n * sizeof (kstat_named_t);
358 case KSTAT_TYPE_INTR:
359 rc = ksp->ks_data + n * sizeof (kstat_intr_t);
362 rc = ksp->ks_data + n * sizeof (kstat_io_t);
364 case KSTAT_TYPE_TIMER:
365 rc = ksp->ks_data + n * sizeof (kstat_timer_t);
368 PANIC("Undefined kstat type %d\n", ksp->ks_type);
375 kstat_seq_start(struct seq_file *f, loff_t *pos)
378 kstat_t *ksp = (kstat_t *)f->private;
379 ASSERT(ksp->ks_magic == KS_MAGIC);
381 mutex_enter(ksp->ks_lock);
383 if (ksp->ks_type == KSTAT_TYPE_RAW) {
384 ksp->ks_raw_bufsize = PAGE_SIZE;
385 ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);
388 /* Dynamically update kstat, on error existing kstats are used */
389 (void) ksp->ks_update(ksp, KSTAT_READ);
391 ksp->ks_snaptime = gethrtime();
393 if (!(ksp->ks_flags & KSTAT_FLAG_NO_HEADERS) && !n &&
394 kstat_seq_show_headers(f))
397 if (n >= ksp->ks_ndata)
400 return (kstat_seq_data_addr(ksp, n));
404 kstat_seq_next(struct seq_file *f, void *p, loff_t *pos)
406 kstat_t *ksp = (kstat_t *)f->private;
407 ASSERT(ksp->ks_magic == KS_MAGIC);
410 if (*pos >= ksp->ks_ndata)
413 return (kstat_seq_data_addr(ksp, *pos));
417 kstat_seq_stop(struct seq_file *f, void *v)
419 kstat_t *ksp = (kstat_t *)f->private;
420 ASSERT(ksp->ks_magic == KS_MAGIC);
422 if (ksp->ks_type == KSTAT_TYPE_RAW)
423 vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);
425 mutex_exit(ksp->ks_lock);
428 static struct seq_operations kstat_seq_ops = {
429 .show = kstat_seq_show,
430 .start = kstat_seq_start,
431 .next = kstat_seq_next,
432 .stop = kstat_seq_stop,
435 static kstat_module_t *
436 kstat_find_module(char *name)
438 kstat_module_t *module = NULL;
440 list_for_each_entry(module, &kstat_module_list, ksm_module_list) {
441 if (strncmp(name, module->ksm_name, KSTAT_STRLEN) == 0)
448 static kstat_module_t *
449 kstat_create_module(char *name)
451 kstat_module_t *module;
452 struct proc_dir_entry *pde;
454 pde = proc_mkdir(name, proc_spl_kstat);
458 module = kmem_alloc(sizeof (kstat_module_t), KM_SLEEP);
459 module->ksm_proc = pde;
460 strlcpy(module->ksm_name, name, KSTAT_STRLEN+1);
461 INIT_LIST_HEAD(&module->ksm_kstat_list);
462 list_add_tail(&module->ksm_module_list, &kstat_module_list);
469 kstat_delete_module(kstat_module_t *module)
471 ASSERT(list_empty(&module->ksm_kstat_list));
472 remove_proc_entry(module->ksm_name, proc_spl_kstat);
473 list_del(&module->ksm_module_list);
474 kmem_free(module, sizeof (kstat_module_t));
478 proc_kstat_open(struct inode *inode, struct file *filp)
483 rc = seq_open(filp, &kstat_seq_ops);
487 f = filp->private_data;
488 f->private = PDE_DATA(inode);
494 proc_kstat_write(struct file *filp, const char __user *buf, size_t len,
497 struct seq_file *f = filp->private_data;
498 kstat_t *ksp = f->private;
501 ASSERT(ksp->ks_magic == KS_MAGIC);
503 mutex_enter(ksp->ks_lock);
504 rc = ksp->ks_update(ksp, KSTAT_WRITE);
505 mutex_exit(ksp->ks_lock);
514 static const kstat_proc_op_t proc_kstat_operations = {
515 #ifdef HAVE_PROC_OPS_STRUCT
516 .proc_open = proc_kstat_open,
517 .proc_write = proc_kstat_write,
518 .proc_read = seq_read,
519 .proc_lseek = seq_lseek,
520 .proc_release = seq_release,
522 .open = proc_kstat_open,
523 .write = proc_kstat_write,
526 .release = seq_release,
531 __kstat_set_raw_ops(kstat_t *ksp,
532 int (*headers)(char *buf, size_t size),
533 int (*data)(char *buf, size_t size, void *data),
534 void *(*addr)(kstat_t *ksp, loff_t index))
536 ksp->ks_raw_ops.headers = headers;
537 ksp->ks_raw_ops.data = data;
538 ksp->ks_raw_ops.addr = addr;
540 EXPORT_SYMBOL(__kstat_set_raw_ops);
543 kstat_proc_entry_init(kstat_proc_entry_t *kpep, const char *module,
546 kpep->kpe_owner = NULL;
547 kpep->kpe_proc = NULL;
548 INIT_LIST_HEAD(&kpep->kpe_list);
549 strncpy(kpep->kpe_module, module, KSTAT_STRLEN);
550 strncpy(kpep->kpe_name, name, KSTAT_STRLEN);
552 EXPORT_SYMBOL(kstat_proc_entry_init);
555 __kstat_create(const char *ks_module, int ks_instance, const char *ks_name,
556 const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
562 ASSERT(ks_instance == 0);
565 if ((ks_type == KSTAT_TYPE_INTR) || (ks_type == KSTAT_TYPE_IO))
566 ASSERT(ks_ndata == 1);
568 ksp = kmem_zalloc(sizeof (*ksp), KM_SLEEP);
572 mutex_enter(&kstat_module_lock);
573 ksp->ks_kid = kstat_id;
575 mutex_exit(&kstat_module_lock);
577 ksp->ks_magic = KS_MAGIC;
578 mutex_init(&ksp->ks_private_lock, NULL, MUTEX_DEFAULT, NULL);
579 ksp->ks_lock = &ksp->ks_private_lock;
581 ksp->ks_crtime = gethrtime();
582 ksp->ks_snaptime = ksp->ks_crtime;
583 ksp->ks_instance = ks_instance;
584 strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
585 ksp->ks_type = ks_type;
586 ksp->ks_flags = ks_flags;
587 ksp->ks_update = kstat_default_update;
588 ksp->ks_private = NULL;
589 ksp->ks_raw_ops.headers = NULL;
590 ksp->ks_raw_ops.data = NULL;
591 ksp->ks_raw_ops.addr = NULL;
592 ksp->ks_raw_buf = NULL;
593 ksp->ks_raw_bufsize = 0;
594 kstat_proc_entry_init(&ksp->ks_proc, ks_module, ks_name);
596 switch (ksp->ks_type) {
599 ksp->ks_data_size = ks_ndata;
601 case KSTAT_TYPE_NAMED:
602 ksp->ks_ndata = ks_ndata;
603 ksp->ks_data_size = ks_ndata * sizeof (kstat_named_t);
605 case KSTAT_TYPE_INTR:
606 ksp->ks_ndata = ks_ndata;
607 ksp->ks_data_size = ks_ndata * sizeof (kstat_intr_t);
610 ksp->ks_ndata = ks_ndata;
611 ksp->ks_data_size = ks_ndata * sizeof (kstat_io_t);
613 case KSTAT_TYPE_TIMER:
614 ksp->ks_ndata = ks_ndata;
615 ksp->ks_data_size = ks_ndata * sizeof (kstat_timer_t);
618 PANIC("Undefined kstat type %d\n", ksp->ks_type);
621 if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
624 ksp->ks_data = kmem_zalloc(ksp->ks_data_size, KM_SLEEP);
625 if (ksp->ks_data == NULL) {
626 kmem_free(ksp, sizeof (*ksp));
633 EXPORT_SYMBOL(__kstat_create);
636 kstat_detect_collision(kstat_proc_entry_t *kpep)
638 kstat_module_t *module;
639 kstat_proc_entry_t *tmp = NULL;
643 parent = kmem_asprintf("%s", kpep->kpe_module);
645 if ((cp = strrchr(parent, '/')) == NULL) {
646 kmem_strfree(parent);
651 if ((module = kstat_find_module(parent)) != NULL) {
652 list_for_each_entry(tmp, &module->ksm_kstat_list, kpe_list) {
653 if (strncmp(tmp->kpe_name, cp+1, KSTAT_STRLEN) == 0) {
654 kmem_strfree(parent);
660 kmem_strfree(parent);
665 * Add a file to the proc filesystem under the kstat namespace (i.e.
666 * /proc/spl/kstat/). The file need not necessarily be implemented as a
670 kstat_proc_entry_install(kstat_proc_entry_t *kpep, mode_t mode,
671 const kstat_proc_op_t *proc_ops, void *data)
673 kstat_module_t *module;
674 kstat_proc_entry_t *tmp = NULL;
678 mutex_enter(&kstat_module_lock);
680 module = kstat_find_module(kpep->kpe_module);
681 if (module == NULL) {
682 if (kstat_detect_collision(kpep) != 0) {
683 cmn_err(CE_WARN, "kstat_create('%s', '%s'): namespace" \
684 " collision", kpep->kpe_module, kpep->kpe_name);
687 module = kstat_create_module(kpep->kpe_module);
693 * Only one entry by this name per-module, on failure the module
694 * shouldn't be deleted because we know it has at least one entry.
696 list_for_each_entry(tmp, &module->ksm_kstat_list, kpe_list) {
697 if (strncmp(tmp->kpe_name, kpep->kpe_name, KSTAT_STRLEN) == 0)
701 list_add_tail(&kpep->kpe_list, &module->ksm_kstat_list);
703 kpep->kpe_owner = module;
704 kpep->kpe_proc = proc_create_data(kpep->kpe_name, mode,
705 module->ksm_proc, proc_ops, data);
706 if (kpep->kpe_proc == NULL) {
707 list_del_init(&kpep->kpe_list);
708 if (list_empty(&module->ksm_kstat_list))
709 kstat_delete_module(module);
712 mutex_exit(&kstat_module_lock);
715 EXPORT_SYMBOL(kstat_proc_entry_install);
718 __kstat_install(kstat_t *ksp)
722 /* Specify permission modes for different kstats */
723 if (strncmp(ksp->ks_proc.kpe_name, "dbufs", KSTAT_STRLEN) == 0) {
728 kstat_proc_entry_install(
729 &ksp->ks_proc, mode, &proc_kstat_operations, ksp);
731 EXPORT_SYMBOL(__kstat_install);
734 kstat_proc_entry_delete(kstat_proc_entry_t *kpep)
736 kstat_module_t *module = kpep->kpe_owner;
738 remove_proc_entry(kpep->kpe_name, module->ksm_proc);
740 mutex_enter(&kstat_module_lock);
741 list_del_init(&kpep->kpe_list);
744 * Remove top level module directory if it wasn't empty before, but now
747 if (kpep->kpe_proc && list_empty(&module->ksm_kstat_list))
748 kstat_delete_module(module);
749 mutex_exit(&kstat_module_lock);
752 EXPORT_SYMBOL(kstat_proc_entry_delete);
755 __kstat_delete(kstat_t *ksp)
757 kstat_proc_entry_delete(&ksp->ks_proc);
759 if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
760 kmem_free(ksp->ks_data, ksp->ks_data_size);
763 mutex_destroy(&ksp->ks_private_lock);
764 kmem_free(ksp, sizeof (*ksp));
766 EXPORT_SYMBOL(__kstat_delete);
771 mutex_init(&kstat_module_lock, NULL, MUTEX_DEFAULT, NULL);
772 INIT_LIST_HEAD(&kstat_module_list);
780 ASSERT(list_empty(&kstat_module_list));
781 mutex_destroy(&kstat_module_lock);