[mirror_zfs.git] / module / spl / spl-kstat.c

/*****************************************************************************\
 *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
 *  Copyright (C) 2007 The Regents of the University of California.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
 *  UCRL-CODE-235197
 *
 *  This file is part of the SPL, Solaris Porting Layer.
 *  For details, see <http://zfsonlinux.org/>.
 *
 *  The SPL is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  The SPL is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
 *****************************************************************************
 *  Solaris Porting Layer (SPL) Kstat Implementation.
\*****************************************************************************/

#include <linux/seq_file.h>
#include <sys/kstat.h>
#include <spl-debug.h>

#ifdef SS_DEBUG_SUBSYS
#undef SS_DEBUG_SUBSYS
#endif

#define SS_DEBUG_SUBSYS SS_KSTAT
#ifndef HAVE_PDE_DATA
#define PDE_DATA(x) (PDE(x)->data)
#endif

static kmutex_t kstat_module_lock;
static struct list_head kstat_module_list;
static kid_t kstat_id;

static void
kstat_seq_show_headers(struct seq_file *f)
{
        kstat_t *ksp = (kstat_t *)f->private;
        ASSERT(ksp->ks_magic == KS_MAGIC);

        seq_printf(f, "%d %d 0x%02x %d %d %lld %lld\n",
		   ksp->ks_kid, ksp->ks_type, ksp->ks_flags,
		   ksp->ks_ndata, (int)ksp->ks_data_size,
		   ksp->ks_crtime, ksp->ks_snaptime);

	switch (ksp->ks_type) {
                case KSTAT_TYPE_RAW:
                        seq_printf(f, "raw data");
                        break;
                case KSTAT_TYPE_NAMED:
                        seq_printf(f, "%-31s %-4s %s\n",
                                   "name", "type", "data");
                        break;
                case KSTAT_TYPE_INTR:
                        seq_printf(f, "%-8s %-8s %-8s %-8s %-8s\n",
                                   "hard", "soft", "watchdog",
                                   "spurious", "multsvc");
                        break;
                case KSTAT_TYPE_IO:
                        seq_printf(f,
                                   "%-8s %-8s %-8s %-8s %-8s %-8s "
                                   "%-8s %-8s %-8s %-8s %-8s %-8s\n",
                                   "nread", "nwritten", "reads", "writes",
                                   "wtime", "wlentime", "wupdate",
                                   "rtime", "rlentime", "rupdate",
                                   "wcnt", "rcnt");
                        break;
                case KSTAT_TYPE_TIMER:
                        seq_printf(f,
                                   "%-31s %-8s "
                                   "%-8s %-8s %-8s %-8s %-8s\n",
                                   "name", "events", "elapsed",
                                   "min", "max", "start", "stop");
                        break;
                case KSTAT_TYPE_TXG:
                        seq_printf(f,
                                   "%-8s %-5s %-13s %-12s %-12s %-8s %-8s "
                                   "%-12s %-12s %-12s\n",
                                   "txg", "state", "birth",
                                   "nread", "nwritten", "reads", "writes",
                                   "otime", "qtime", "stime");
                        break;
                default:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }
}

static int
kstat_seq_show_raw(struct seq_file *f, unsigned char *p, int l)
{
        int i, j;

        for (i = 0; ; i++) {
                seq_printf(f, "%03x:", i);

                for (j = 0; j < 16; j++) {
                        if (i * 16 + j >= l) {
                                seq_printf(f, "\n");
                                goto out;
                        }

                        seq_printf(f, " %02x", (unsigned char)p[i * 16 + j]);
                }
                seq_printf(f, "\n");
        }
out:
        return 0;
}

static int
kstat_seq_show_named(struct seq_file *f, kstat_named_t *knp)
{
        seq_printf(f, "%-31s %-4d ", knp->name, knp->data_type);

        switch (knp->data_type) {
                case KSTAT_DATA_CHAR:
                        knp->value.c[15] = '\0'; /* NULL terminate */
                        seq_printf(f, "%-16s", knp->value.c);
                        break;
                /* XXX - We need to be more careful able what tokens are
                 * used for each arch, for now this is correct for x86_64.
                 */
                case KSTAT_DATA_INT32:
                        seq_printf(f, "%d", knp->value.i32);
                        break;
                case KSTAT_DATA_UINT32:
                        seq_printf(f, "%u", knp->value.ui32);
                        break;
                case KSTAT_DATA_INT64:
                        seq_printf(f, "%lld", (signed long long)knp->value.i64);
                        break;
                case KSTAT_DATA_UINT64:
                        seq_printf(f, "%llu", (unsigned long long)knp->value.ui64);
                        break;
                case KSTAT_DATA_LONG:
                        seq_printf(f, "%ld", knp->value.l);
                        break;
                case KSTAT_DATA_ULONG:
                        seq_printf(f, "%lu", knp->value.ul);
                        break;
                case KSTAT_DATA_STRING:
                        KSTAT_NAMED_STR_PTR(knp)
                                [KSTAT_NAMED_STR_BUFLEN(knp)-1] = '\0';
                        seq_printf(f, "%s", KSTAT_NAMED_STR_PTR(knp));
                        break;
                default:
                        PANIC("Undefined kstat data type %d\n", knp->data_type);
        }

        seq_printf(f, "\n");

        return 0;
}

static int
kstat_seq_show_intr(struct seq_file *f, kstat_intr_t *kip)
{
        seq_printf(f, "%-8u %-8u %-8u %-8u %-8u\n",
                   kip->intrs[KSTAT_INTR_HARD],
                   kip->intrs[KSTAT_INTR_SOFT],
                   kip->intrs[KSTAT_INTR_WATCHDOG],
                   kip->intrs[KSTAT_INTR_SPURIOUS],
                   kip->intrs[KSTAT_INTR_MULTSVC]);

        return 0;
}

static int
kstat_seq_show_io(struct seq_file *f, kstat_io_t *kip)
{
        seq_printf(f,
                   "%-8llu %-8llu %-8u %-8u %-8lld %-8lld "
                   "%-8lld %-8lld %-8lld %-8lld %-8u %-8u\n",
                   kip->nread, kip->nwritten,
                   kip->reads, kip->writes,
                   kip->wtime, kip->wlentime, kip->wlastupdate,
                   kip->rtime, kip->wlentime, kip->rlastupdate,
                   kip->wcnt,  kip->rcnt);

        return 0;
}

static int
kstat_seq_show_timer(struct seq_file *f, kstat_timer_t *ktp)
{
        seq_printf(f,
                   "%-31s %-8llu %-8lld %-8lld %-8lld %-8lld %-8lld\n",
                   ktp->name, ktp->num_events, ktp->elapsed_time,
                   ktp->min_time, ktp->max_time,
                   ktp->start_time, ktp->stop_time);

        return 0;
}

static int
kstat_seq_show_txg(struct seq_file *f, kstat_txg_t *ktp)
{
	char state;

	switch (ktp->state) {
		case TXG_STATE_OPEN:		state = 'O';	break;
		case TXG_STATE_QUIESCING:	state = 'Q';	break;
		case TXG_STATE_SYNCING:		state = 'S';	break;
		case TXG_STATE_COMMITTED:	state = 'C';	break;
		default:			state = '?';	break;
	}

        seq_printf(f,
                   "%-8llu %-5c %-13llu %-12llu %-12llu %-8u %-8u "
                   "%12lld %12lld %12lld\n", ktp->txg, state, ktp->birth,
                    ktp->nread, ktp->nwritten, ktp->reads, ktp->writes,
                    ktp->open_time, ktp->quiesce_time, ktp->sync_time);
	return 0;
}

static int
kstat_seq_show(struct seq_file *f, void *p)
{
        kstat_t *ksp = (kstat_t *)f->private;
        int rc = 0;

        ASSERT(ksp->ks_magic == KS_MAGIC);

	switch (ksp->ks_type) {
                case KSTAT_TYPE_RAW:
                        ASSERT(ksp->ks_ndata == 1);
                        rc = kstat_seq_show_raw(f, ksp->ks_data,
                                                ksp->ks_data_size);
                        break;
                case KSTAT_TYPE_NAMED:
                        rc = kstat_seq_show_named(f, (kstat_named_t *)p);
                        break;
                case KSTAT_TYPE_INTR:
                        rc = kstat_seq_show_intr(f, (kstat_intr_t *)p);
                        break;
                case KSTAT_TYPE_IO:
                        rc = kstat_seq_show_io(f, (kstat_io_t *)p);
                        break;
                case KSTAT_TYPE_TIMER:
                        rc = kstat_seq_show_timer(f, (kstat_timer_t *)p);
                        break;
                case KSTAT_TYPE_TXG:
                        rc = kstat_seq_show_txg(f, (kstat_txg_t *)p);
                        break;
                default:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }

        return rc;
}

int
kstat_default_update(kstat_t *ksp, int rw)
{
	ASSERT(ksp != NULL);
	return 0;
}

static void *
kstat_seq_data_addr(kstat_t *ksp, loff_t n)
{
        void *rc = NULL;
        SENTRY;

	switch (ksp->ks_type) {
                case KSTAT_TYPE_RAW:
	                rc = ksp->ks_data;
                        break;
                case KSTAT_TYPE_NAMED:
                        rc = ksp->ks_data + n * sizeof(kstat_named_t);
                        break;
                case KSTAT_TYPE_INTR:
                        rc = ksp->ks_data + n * sizeof(kstat_intr_t);
                        break;
                case KSTAT_TYPE_IO:
                        rc = ksp->ks_data + n * sizeof(kstat_io_t);
                        break;
                case KSTAT_TYPE_TIMER:
                        rc = ksp->ks_data + n * sizeof(kstat_timer_t);
                        break;
                case KSTAT_TYPE_TXG:
                        rc = ksp->ks_data + n * sizeof(kstat_txg_t);
                        break;
                default:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }

        SRETURN(rc);
}

static void *
kstat_seq_start(struct seq_file *f, loff_t *pos)
{
        loff_t n = *pos;
        kstat_t *ksp = (kstat_t *)f->private;
        ASSERT(ksp->ks_magic == KS_MAGIC);
        SENTRY;

        mutex_enter(&ksp->ks_lock);

        /* Dynamically update kstat, on error existing kstats are used */
        (void) ksp->ks_update(ksp, KSTAT_READ);

	ksp->ks_snaptime = gethrtime();

        if (!n)
                kstat_seq_show_headers(f);

        if (n >= ksp->ks_ndata)
                SRETURN(NULL);

        SRETURN(kstat_seq_data_addr(ksp, n));
}

static void *
kstat_seq_next(struct seq_file *f, void *p, loff_t *pos)
{
        kstat_t *ksp = (kstat_t *)f->private;
        ASSERT(ksp->ks_magic == KS_MAGIC);
        SENTRY;

        ++*pos;
        if (*pos >= ksp->ks_ndata)
                SRETURN(NULL);

        SRETURN(kstat_seq_data_addr(ksp, *pos));
}

static void
kstat_seq_stop(struct seq_file *f, void *v)
{
        kstat_t *ksp = (kstat_t *)f->private;
        ASSERT(ksp->ks_magic == KS_MAGIC);

        mutex_exit(&ksp->ks_lock);
}

static struct seq_operations kstat_seq_ops = {
        .show  = kstat_seq_show,
        .start = kstat_seq_start,
        .next  = kstat_seq_next,
        .stop  = kstat_seq_stop,
};

static kstat_module_t *
kstat_find_module(char *name)
{
	kstat_module_t *module;

	list_for_each_entry(module, &kstat_module_list, ksm_module_list)
		if (strncmp(name, module->ksm_name, KSTAT_STRLEN) == 0)
			return (module);

	return (NULL);
}

static kstat_module_t *
kstat_create_module(char *name)
{
	kstat_module_t *module;
	struct proc_dir_entry *pde;

	pde = proc_mkdir(name, proc_spl_kstat);
	if (pde == NULL)
		return (NULL);

	module = kmem_alloc(sizeof (kstat_module_t), KM_SLEEP);
	module->ksm_proc = pde;
	strlcpy(module->ksm_name, name, KSTAT_STRLEN+1);
	INIT_LIST_HEAD(&module->ksm_kstat_list);
	list_add_tail(&module->ksm_module_list, &kstat_module_list);

	return (module);

}

static void
kstat_delete_module(kstat_module_t *module)
{
	ASSERT(list_empty(&module->ksm_kstat_list));
	remove_proc_entry(module->ksm_name, proc_spl_kstat);
	list_del(&module->ksm_module_list);
	kmem_free(module, sizeof(kstat_module_t));
}

static int
proc_kstat_open(struct inode *inode, struct file *filp)
{
        struct seq_file *f;
        int rc;

        rc = seq_open(filp, &kstat_seq_ops);
        if (rc)
                return rc;

        f = filp->private_data;
        f->private = PDE_DATA(inode);

        return rc;
}

static struct file_operations proc_kstat_operations = {
        .open           = proc_kstat_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
        .release        = seq_release,
};

kstat_t *
__kstat_create(const char *ks_module, int ks_instance, const char *ks_name,
             const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
             uchar_t ks_flags)
{
	kstat_t *ksp;

	ASSERT(ks_module);
	ASSERT(ks_instance == 0);
	ASSERT(ks_name);
	ASSERT(!(ks_flags & KSTAT_FLAG_UNSUPPORTED));

	if ((ks_type == KSTAT_TYPE_INTR) || (ks_type == KSTAT_TYPE_IO))
                ASSERT(ks_ndata == 1);

	ksp = kmem_zalloc(sizeof(*ksp), KM_SLEEP);
	if (ksp == NULL)
		return ksp;

	mutex_enter(&kstat_module_lock);
	ksp->ks_kid = kstat_id;
        kstat_id++;
	mutex_exit(&kstat_module_lock);

        ksp->ks_magic = KS_MAGIC;
	mutex_init(&ksp->ks_lock, NULL, MUTEX_DEFAULT, NULL);
	INIT_LIST_HEAD(&ksp->ks_list);

	ksp->ks_crtime = gethrtime();
        ksp->ks_snaptime = ksp->ks_crtime;
	strncpy(ksp->ks_module, ks_module, KSTAT_STRLEN);
	ksp->ks_instance = ks_instance;
	strncpy(ksp->ks_name, ks_name, KSTAT_STRLEN);
	strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
	ksp->ks_type = ks_type;
	ksp->ks_flags = ks_flags;
	ksp->ks_update = kstat_default_update;
	ksp->ks_private = NULL;

	switch (ksp->ks_type) {
                case KSTAT_TYPE_RAW:
	                ksp->ks_ndata = 1;
                        ksp->ks_data_size = ks_ndata;
                        break;
                case KSTAT_TYPE_NAMED:
	                ksp->ks_ndata = ks_ndata;
                        ksp->ks_data_size = ks_ndata * sizeof(kstat_named_t);
                        break;
                case KSTAT_TYPE_INTR:
	                ksp->ks_ndata = ks_ndata;
                        ksp->ks_data_size = ks_ndata * sizeof(kstat_intr_t);
                        break;
                case KSTAT_TYPE_IO:
	                ksp->ks_ndata = ks_ndata;
                        ksp->ks_data_size = ks_ndata * sizeof(kstat_io_t);
                        break;
                case KSTAT_TYPE_TIMER:
	                ksp->ks_ndata = ks_ndata;
                        ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
                        break;
		case KSTAT_TYPE_TXG:
			ksp->ks_ndata = ks_ndata;
			ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
			break;
                default:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }

	if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
                ksp->ks_data = NULL;
        } else {
                ksp->ks_data = kmem_alloc(ksp->ks_data_size, KM_SLEEP);
                if (ksp->ks_data == NULL) {
                        kmem_free(ksp, sizeof(*ksp));
                        ksp = NULL;
                }
        }

	return ksp;
}
EXPORT_SYMBOL(__kstat_create);

void
__kstat_install(kstat_t *ksp)
{
	kstat_module_t *module;
	kstat_t *tmp;

	ASSERT(ksp);

	mutex_enter(&kstat_module_lock);

	module = kstat_find_module(ksp->ks_module);
	if (module == NULL) {
		module = kstat_create_module(ksp->ks_module);
		if (module == NULL)
			goto out;
	}

	/*
	 * Only one entry by this name per-module, on failure the module
	 * shouldn't be deleted because we know it has at least one entry.
	 */
	list_for_each_entry(tmp, &module->ksm_kstat_list, ks_list)
		if (strncmp(tmp->ks_name, ksp->ks_name, KSTAT_STRLEN) == 0)
			goto out;

	list_add_tail(&ksp->ks_list, &module->ksm_kstat_list);

	mutex_enter(&ksp->ks_lock);
	ksp->ks_owner = module;
	ksp->ks_proc = proc_create_data(ksp->ks_name, 0444,
	    module->ksm_proc, &proc_kstat_operations, (void *)ksp);
	if (ksp->ks_proc == NULL) {
		list_del_init(&ksp->ks_list);
		if (list_empty(&module->ksm_kstat_list))
			kstat_delete_module(module);
	}
	mutex_exit(&ksp->ks_lock);
out:
	mutex_exit(&kstat_module_lock);
}
EXPORT_SYMBOL(__kstat_install);

void
__kstat_delete(kstat_t *ksp)
{
	kstat_module_t *module = ksp->ks_owner;

	mutex_enter(&kstat_module_lock);
	list_del_init(&ksp->ks_list);
	mutex_exit(&kstat_module_lock);

	if (ksp->ks_proc) {
		remove_proc_entry(ksp->ks_name, module->ksm_proc);

		/* Remove top level module directory if it's empty */
		if (list_empty(&module->ksm_kstat_list))
			kstat_delete_module(module);
	}

	if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
		kmem_free(ksp->ks_data, ksp->ks_data_size);

	mutex_destroy(&ksp->ks_lock);
	kmem_free(ksp, sizeof(*ksp));

	return;
}
EXPORT_SYMBOL(__kstat_delete);

int
spl_kstat_init(void)
{
	SENTRY;
	mutex_init(&kstat_module_lock, NULL, MUTEX_DEFAULT, NULL);
	INIT_LIST_HEAD(&kstat_module_list);
        kstat_id = 0;
	SRETURN(0);
}

void
spl_kstat_fini(void)
{
	SENTRY;
	ASSERT(list_empty(&kstat_module_list));
	mutex_destroy(&kstat_module_lock);
	SEXIT;
}
Commit	Line	Data
716154c5 BB	1	/*****************************************************************************\
	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>.
715f6251 BB	6	* UCRL-CODE-235197
715f6251 BB	7	*
716154c5	8	* This file is part of the SPL, Solaris Porting Layer.
3d6af2dd	9	* For details, see <http://zfsonlinux.org/>.
716154c5 BB	10	*
	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.
715f6251	15	*
716154c5	16	* The SPL is distributed in the hope that it will be useful, but WITHOUT
715f6251 BB	17	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	18	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	19	* for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License along
716154c5 BB	22	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	23	*****************************************************************************
	24	* Solaris Porting Layer (SPL) Kstat Implementation.
	25	\*****************************************************************************/
715f6251	26
ae4c36ad	27	#include <linux/seq_file.h>
55abb092 BB	28	#include <sys/kstat.h>
55abb092 BB	29	#include <spl-debug.h>
04a479f7	30
b17edc10 BB	31	#ifdef SS_DEBUG_SUBSYS
	32	#undef SS_DEBUG_SUBSYS
	33	#endif
	34
	35	#define SS_DEBUG_SUBSYS SS_KSTAT
1ddf9722 YS	36	#ifndef HAVE_PDE_DATA
	37	#define PDE_DATA(x) (PDE(x)->data)
	38	#endif
b17edc10	39
f2a745c4 RY	40	static kmutex_t kstat_module_lock;
f2a745c4 RY	41	static struct list_head kstat_module_list;
04a479f7 BB	42	static kid_t kstat_id;
	43
	44	static void
	45	kstat_seq_show_headers(struct seq_file *f)
	46	{
	47	kstat_t ksp = (kstat_t )f->private;
	48	ASSERT(ksp->ks_magic == KS_MAGIC);
	49
	50	seq_printf(f, "%d %d 0x%02x %d %d %lld %lld\n",
	51	ksp->ks_kid, ksp->ks_type, ksp->ks_flags,
	52	ksp->ks_ndata, (int)ksp->ks_data_size,
	53	ksp->ks_crtime, ksp->ks_snaptime);
	54
	55	switch (ksp->ks_type) {
	56	case KSTAT_TYPE_RAW:
	57	seq_printf(f, "raw data");
	58	break;
	59	case KSTAT_TYPE_NAMED:
	60	seq_printf(f, "%-31s %-4s %s\n",
	61	"name", "type", "data");
	62	break;
	63	case KSTAT_TYPE_INTR:
	64	seq_printf(f, "%-8s %-8s %-8s %-8s %-8s\n",
	65	"hard", "soft", "watchdog",
	66	"spurious", "multsvc");
	67	break;
	68	case KSTAT_TYPE_IO:
	69	seq_printf(f,
	70	"%-8s %-8s %-8s %-8s %-8s %-8s "
	71	"%-8s %-8s %-8s %-8s %-8s %-8s\n",
	72	"nread", "nwritten", "reads", "writes",
	73	"wtime", "wlentime", "wupdate",
	74	"rtime", "rlentime", "rupdate",
	75	"wcnt", "rcnt");
	76	break;
	77	case KSTAT_TYPE_TIMER:
	78	seq_printf(f,
	79	"%-31s %-8s "
	80	"%-8s %-8s %-8s %-8s %-8s\n",
	81	"name", "events", "elapsed",
	82	"min", "max", "start", "stop");
	83	break;
dba79fcb BB	84	case KSTAT_TYPE_TXG:
	85	seq_printf(f,
	86	"%-8s %-5s %-13s %-12s %-12s %-8s %-8s "
	87	"%-12s %-12s %-12s\n",
	88	"txg", "state", "birth",
	89	"nread", "nwritten", "reads", "writes",
	90	"otime", "qtime", "stime");
	91	break;
04a479f7	92	default:
55abb092	93	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7 BB	94	}
	95	}
	96
	97	static int
	98	kstat_seq_show_raw(struct seq_file f, unsigned char p, int l)
	99	{
	100	int i, j;
	101
	102	for (i = 0; ; i++) {
	103	seq_printf(f, "%03x:", i);
	104
	105	for (j = 0; j < 16; j++) {
	106	if (i * 16 + j >= l) {
	107	seq_printf(f, "\n");
	108	goto out;
	109	}
	110
	111	seq_printf(f, " %02x", (unsigned char)p[i * 16 + j]);
	112	}
	113	seq_printf(f, "\n");
	114	}
	115	out:
	116	return 0;
	117	}
	118
	119	static int
	120	kstat_seq_show_named(struct seq_file f, kstat_named_t knp)
	121	{
	122	seq_printf(f, "%-31s %-4d ", knp->name, knp->data_type);
	123
	124	switch (knp->data_type) {
	125	case KSTAT_DATA_CHAR:
	126	knp->value.c[15] = '\0'; /* NULL terminate */
	127	seq_printf(f, "%-16s", knp->value.c);
	128	break;
	129	/* XXX - We need to be more careful able what tokens are
	130	* used for each arch, for now this is correct for x86_64.
	131	*/
	132	case KSTAT_DATA_INT32:
	133	seq_printf(f, "%d", knp->value.i32);
	134	break;
	135	case KSTAT_DATA_UINT32:
	136	seq_printf(f, "%u", knp->value.ui32);
	137	break;
	138	case KSTAT_DATA_INT64:
cfe57499	139	seq_printf(f, "%lld", (signed long long)knp->value.i64);
04a479f7 BB	140	break;
04a479f7 BB	141	case KSTAT_DATA_UINT64:
cfe57499	142	seq_printf(f, "%llu", (unsigned long long)knp->value.ui64);
04a479f7 BB	143	break;
	144	case KSTAT_DATA_LONG:
	145	seq_printf(f, "%ld", knp->value.l);
	146	break;
	147	case KSTAT_DATA_ULONG:
cfe57499	148	seq_printf(f, "%lu", knp->value.ul);
04a479f7 BB	149	break;
	150	case KSTAT_DATA_STRING:
	151	KSTAT_NAMED_STR_PTR(knp)
	152	[KSTAT_NAMED_STR_BUFLEN(knp)-1] = '\0';
	153	seq_printf(f, "%s", KSTAT_NAMED_STR_PTR(knp));
	154	break;
	155	default:
55abb092	156	PANIC("Undefined kstat data type %d\n", knp->data_type);
04a479f7 BB	157	}
	158
	159	seq_printf(f, "\n");
	160
	161	return 0;
	162	}
	163
	164	static int
	165	kstat_seq_show_intr(struct seq_file f, kstat_intr_t kip)
	166	{
	167	seq_printf(f, "%-8u %-8u %-8u %-8u %-8u\n",
	168	kip->intrs[KSTAT_INTR_HARD],
	169	kip->intrs[KSTAT_INTR_SOFT],
	170	kip->intrs[KSTAT_INTR_WATCHDOG],
	171	kip->intrs[KSTAT_INTR_SPURIOUS],
	172	kip->intrs[KSTAT_INTR_MULTSVC]);
	173
	174	return 0;
	175	}
	176
	177	static int
	178	kstat_seq_show_io(struct seq_file f, kstat_io_t kip)
	179	{
	180	seq_printf(f,
	181	"%-8llu %-8llu %-8u %-8u %-8lld %-8lld "
	182	"%-8lld %-8lld %-8lld %-8lld %-8u %-8u\n",
	183	kip->nread, kip->nwritten,
	184	kip->reads, kip->writes,
	185	kip->wtime, kip->wlentime, kip->wlastupdate,
	186	kip->rtime, kip->wlentime, kip->rlastupdate,
	187	kip->wcnt, kip->rcnt);
	188
	189	return 0;
	190	}
	191
	192	static int
	193	kstat_seq_show_timer(struct seq_file f, kstat_timer_t ktp)
	194	{
	195	seq_printf(f,
	196	"%-31s %-8llu %-8lld %-8lld %-8lld %-8lld %-8lld\n",
	197	ktp->name, ktp->num_events, ktp->elapsed_time,
	198	ktp->min_time, ktp->max_time,
	199	ktp->start_time, ktp->stop_time);
	200
	201	return 0;
	202	}
	203
dba79fcb BB	204	static int
	205	kstat_seq_show_txg(struct seq_file f, kstat_txg_t ktp)
	206	{
	207	char state;
	208
	209	switch (ktp->state) {
	210	case TXG_STATE_OPEN: state = 'O'; break;
	211	case TXG_STATE_QUIESCING: state = 'Q'; break;
	212	case TXG_STATE_SYNCING: state = 'S'; break;
	213	case TXG_STATE_COMMITTED: state = 'C'; break;
	214	default: state = '?'; break;
	215	}
	216
	217	seq_printf(f,
	218	"%-8llu %-5c %-13llu %-12llu %-12llu %-8u %-8u "
	219	"%12lld %12lld %12lld\n", ktp->txg, state, ktp->birth,
	220	ktp->nread, ktp->nwritten, ktp->reads, ktp->writes,
	221	ktp->open_time, ktp->quiesce_time, ktp->sync_time);
	222	return 0;
	223	}
	224
04a479f7 BB	225	static int
	226	kstat_seq_show(struct seq_file f, void p)
	227	{
	228	kstat_t ksp = (kstat_t )f->private;
	229	int rc = 0;
	230
	231	ASSERT(ksp->ks_magic == KS_MAGIC);
	232
	233	switch (ksp->ks_type) {
	234	case KSTAT_TYPE_RAW:
	235	ASSERT(ksp->ks_ndata == 1);
	236	rc = kstat_seq_show_raw(f, ksp->ks_data,
	237	ksp->ks_data_size);
	238	break;
	239	case KSTAT_TYPE_NAMED:
	240	rc = kstat_seq_show_named(f, (kstat_named_t *)p);
	241	break;
	242	case KSTAT_TYPE_INTR:
	243	rc = kstat_seq_show_intr(f, (kstat_intr_t *)p);
	244	break;
	245	case KSTAT_TYPE_IO:
	246	rc = kstat_seq_show_io(f, (kstat_io_t *)p);
	247	break;
	248	case KSTAT_TYPE_TIMER:
	249	rc = kstat_seq_show_timer(f, (kstat_timer_t *)p);
	250	break;
dba79fcb BB	251	case KSTAT_TYPE_TXG:
	252	rc = kstat_seq_show_txg(f, (kstat_txg_t *)p);
	253	break;
04a479f7	254	default:
55abb092	255	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7 BB	256	}
	257
	258	return rc;
	259	}
	260
9a8b7a74 BB	261	int
	262	kstat_default_update(kstat_t *ksp, int rw)
	263	{
	264	ASSERT(ksp != NULL);
	265	return 0;
	266	}
	267
04a479f7 BB	268	static void *
	269	kstat_seq_data_addr(kstat_t *ksp, loff_t n)
	270	{
	271	void *rc = NULL;
b17edc10	272	SENTRY;
04a479f7 BB	273
	274	switch (ksp->ks_type) {
	275	case KSTAT_TYPE_RAW:
	276	rc = ksp->ks_data;
	277	break;
	278	case KSTAT_TYPE_NAMED:
	279	rc = ksp->ks_data + n * sizeof(kstat_named_t);
	280	break;
	281	case KSTAT_TYPE_INTR:
	282	rc = ksp->ks_data + n * sizeof(kstat_intr_t);
	283	break;
	284	case KSTAT_TYPE_IO:
	285	rc = ksp->ks_data + n * sizeof(kstat_io_t);
	286	break;
	287	case KSTAT_TYPE_TIMER:
	288	rc = ksp->ks_data + n * sizeof(kstat_timer_t);
	289	break;
dba79fcb BB	290	case KSTAT_TYPE_TXG:
	291	rc = ksp->ks_data + n * sizeof(kstat_txg_t);
	292	break;
04a479f7	293	default:
55abb092	294	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7 BB	295	}
04a479f7 BB	296
b17edc10	297	SRETURN(rc);
04a479f7 BB	298	}
	299
	300	static void *
	301	kstat_seq_start(struct seq_file f, loff_t pos)
	302	{
	303	loff_t n = *pos;
	304	kstat_t ksp = (kstat_t )f->private;
	305	ASSERT(ksp->ks_magic == KS_MAGIC);
b17edc10	306	SENTRY;
04a479f7	307
71c9f0b0 BB	308	mutex_enter(&ksp->ks_lock);
71c9f0b0 BB	309
9a8b7a74 BB	310	/* Dynamically update kstat, on error existing kstats are used */
	311	(void) ksp->ks_update(ksp, KSTAT_READ);
	312
04a479f7 BB	313	ksp->ks_snaptime = gethrtime();
	314
	315	if (!n)
	316	kstat_seq_show_headers(f);
	317
	318	if (n >= ksp->ks_ndata)
b17edc10	319	SRETURN(NULL);
04a479f7	320
b17edc10	321	SRETURN(kstat_seq_data_addr(ksp, n));
04a479f7 BB	322	}
	323
	324	static void *
	325	kstat_seq_next(struct seq_file f, void p, loff_t *pos)
	326	{
	327	kstat_t ksp = (kstat_t )f->private;
	328	ASSERT(ksp->ks_magic == KS_MAGIC);
b17edc10	329	SENTRY;
04a479f7 BB	330
	331	++*pos;
	332	if (*pos >= ksp->ks_ndata)
b17edc10	333	SRETURN(NULL);
04a479f7	334
b17edc10	335	SRETURN(kstat_seq_data_addr(ksp, *pos));
04a479f7 BB	336	}
	337
	338	static void
	339	kstat_seq_stop(struct seq_file f, void v)
	340	{
	341	kstat_t ksp = (kstat_t )f->private;
	342	ASSERT(ksp->ks_magic == KS_MAGIC);
	343
71c9f0b0	344	mutex_exit(&ksp->ks_lock);
04a479f7 BB	345	}
	346
	347	static struct seq_operations kstat_seq_ops = {
	348	.show = kstat_seq_show,
	349	.start = kstat_seq_start,
	350	.next = kstat_seq_next,
	351	.stop = kstat_seq_stop,
	352	};
	353
f2a745c4 RY	354	static kstat_module_t *
	355	kstat_find_module(char *name)
	356	{
	357	kstat_module_t *module;
	358
	359	list_for_each_entry(module, &kstat_module_list, ksm_module_list)
	360	if (strncmp(name, module->ksm_name, KSTAT_STRLEN) == 0)
	361	return (module);
	362
	363	return (NULL);
	364	}
	365
	366	static kstat_module_t *
	367	kstat_create_module(char *name)
	368	{
	369	kstat_module_t *module;
	370	struct proc_dir_entry *pde;
	371
	372	pde = proc_mkdir(name, proc_spl_kstat);
	373	if (pde == NULL)
	374	return (NULL);
	375
	376	module = kmem_alloc(sizeof (kstat_module_t), KM_SLEEP);
	377	module->ksm_proc = pde;
	378	strlcpy(module->ksm_name, name, KSTAT_STRLEN+1);
	379	INIT_LIST_HEAD(&module->ksm_kstat_list);
	380	list_add_tail(&module->ksm_module_list, &kstat_module_list);
	381
	382	return (module);
	383
	384	}
	385
	386	static void
	387	kstat_delete_module(kstat_module_t *module)
	388	{
	389	ASSERT(list_empty(&module->ksm_kstat_list));
	390	remove_proc_entry(module->ksm_name, proc_spl_kstat);
	391	list_del(&module->ksm_module_list);
	392	kmem_free(module, sizeof(kstat_module_t));
	393	}
	394
04a479f7 BB	395	static int
	396	proc_kstat_open(struct inode inode, struct file filp)
	397	{
	398	struct seq_file *f;
	399	int rc;
	400
	401	rc = seq_open(filp, &kstat_seq_ops);
	402	if (rc)
	403	return rc;
	404
	405	f = filp->private_data;
1ddf9722	406	f->private = PDE_DATA(inode);
04a479f7 BB	407
	408	return rc;
	409	}
	410
	411	static struct file_operations proc_kstat_operations = {
	412	.open = proc_kstat_open,
	413	.read = seq_read,
	414	.llseek = seq_lseek,
	415	.release = seq_release,
	416	};
	417
	418	kstat_t *
	419	__kstat_create(const char ks_module, int ks_instance, const char ks_name,
	420	const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
	421	uchar_t ks_flags)
	422	{
	423	kstat_t *ksp;
	424
	425	ASSERT(ks_module);
	426	ASSERT(ks_instance == 0);
	427	ASSERT(ks_name);
	428	ASSERT(!(ks_flags & KSTAT_FLAG_UNSUPPORTED));
	429
	430	if ((ks_type == KSTAT_TYPE_INTR) \|\| (ks_type == KSTAT_TYPE_IO))
	431	ASSERT(ks_ndata == 1);
	432
	433	ksp = kmem_zalloc(sizeof(*ksp), KM_SLEEP);
	434	if (ksp == NULL)
	435	return ksp;
	436
f2a745c4	437	mutex_enter(&kstat_module_lock);
04a479f7 BB	438	ksp->ks_kid = kstat_id;
04a479f7 BB	439	kstat_id++;
f2a745c4	440	mutex_exit(&kstat_module_lock);
04a479f7 BB	441
04a479f7 BB	442	ksp->ks_magic = KS_MAGIC;
71c9f0b0	443	mutex_init(&ksp->ks_lock, NULL, MUTEX_DEFAULT, NULL);
04a479f7 BB	444	INIT_LIST_HEAD(&ksp->ks_list);
	445
	446	ksp->ks_crtime = gethrtime();
	447	ksp->ks_snaptime = ksp->ks_crtime;
	448	strncpy(ksp->ks_module, ks_module, KSTAT_STRLEN);
	449	ksp->ks_instance = ks_instance;
	450	strncpy(ksp->ks_name, ks_name, KSTAT_STRLEN);
	451	strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
	452	ksp->ks_type = ks_type;
	453	ksp->ks_flags = ks_flags;
9a8b7a74 BB	454	ksp->ks_update = kstat_default_update;
9a8b7a74 BB	455	ksp->ks_private = NULL;
04a479f7 BB	456
	457	switch (ksp->ks_type) {
	458	case KSTAT_TYPE_RAW:
	459	ksp->ks_ndata = 1;
	460	ksp->ks_data_size = ks_ndata;
	461	break;
	462	case KSTAT_TYPE_NAMED:
	463	ksp->ks_ndata = ks_ndata;
	464	ksp->ks_data_size = ks_ndata * sizeof(kstat_named_t);
	465	break;
	466	case KSTAT_TYPE_INTR:
	467	ksp->ks_ndata = ks_ndata;
	468	ksp->ks_data_size = ks_ndata * sizeof(kstat_intr_t);
	469	break;
	470	case KSTAT_TYPE_IO:
	471	ksp->ks_ndata = ks_ndata;
	472	ksp->ks_data_size = ks_ndata * sizeof(kstat_io_t);
	473	break;
	474	case KSTAT_TYPE_TIMER:
	475	ksp->ks_ndata = ks_ndata;
	476	ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
	477	break;
dba79fcb BB	478	case KSTAT_TYPE_TXG:
	479	ksp->ks_ndata = ks_ndata;
	480	ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
	481	break;
04a479f7	482	default:
55abb092	483	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7 BB	484	}
	485
	486	if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
	487	ksp->ks_data = NULL;
	488	} else {
	489	ksp->ks_data = kmem_alloc(ksp->ks_data_size, KM_SLEEP);
	490	if (ksp->ks_data == NULL) {
	491	kmem_free(ksp, sizeof(*ksp));
	492	ksp = NULL;
	493	}
	494	}
	495
	496	return ksp;
	497	}
	498	EXPORT_SYMBOL(__kstat_create);
	499
	500	void
	501	__kstat_install(kstat_t *ksp)
	502	{
f2a745c4	503	kstat_module_t *module;
04a479f7	504	kstat_t *tmp;
04a479f7	505
f2a745c4	506	ASSERT(ksp);
04a479f7	507
f2a745c4	508	mutex_enter(&kstat_module_lock);
04a479f7	509
f2a745c4 RY	510	module = kstat_find_module(ksp->ks_module);
	511	if (module == NULL) {
	512	module = kstat_create_module(ksp->ks_module);
	513	if (module == NULL)
	514	goto out;
04a479f7 BB	515	}
04a479f7 BB	516
f2a745c4 RY	517	/*
	518	* Only one entry by this name per-module, on failure the module
	519	* shouldn't be deleted because we know it has at least one entry.
	520	*/
	521	list_for_each_entry(tmp, &module->ksm_kstat_list, ks_list)
	522	if (strncmp(tmp->ks_name, ksp->ks_name, KSTAT_STRLEN) == 0)
	523	goto out;
	524
	525	list_add_tail(&ksp->ks_list, &module->ksm_kstat_list);
04a479f7	526
71c9f0b0	527	mutex_enter(&ksp->ks_lock);
f2a745c4 RY	528	ksp->ks_owner = module;
	529	ksp->ks_proc = proc_create_data(ksp->ks_name, 0444,
	530	module->ksm_proc, &proc_kstat_operations, (void *)ksp);
	531	if (ksp->ks_proc == NULL) {
	532	list_del_init(&ksp->ks_list);
	533	if (list_empty(&module->ksm_kstat_list))
	534	kstat_delete_module(module);
	535	}
71c9f0b0	536	mutex_exit(&ksp->ks_lock);
04a479f7	537	out:
f2a745c4	538	mutex_exit(&kstat_module_lock);
04a479f7 BB	539	}
	540	EXPORT_SYMBOL(__kstat_install);
	541
	542	void
	543	__kstat_delete(kstat_t *ksp)
	544	{
f2a745c4	545	kstat_module_t *module = ksp->ks_owner;
04a479f7	546
f2a745c4 RY	547	mutex_enter(&kstat_module_lock);
	548	list_del_init(&ksp->ks_list);
	549	mutex_exit(&kstat_module_lock);
04a479f7	550
f2a745c4 RY	551	if (ksp->ks_proc) {
f2a745c4 RY	552	remove_proc_entry(ksp->ks_name, module->ksm_proc);
04a479f7	553
f2a745c4 RY	554	/* Remove top level module directory if it's empty */
	555	if (list_empty(&module->ksm_kstat_list))
	556	kstat_delete_module(module);
04a479f7 BB	557	}
	558
	559	if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
f2a745c4	560	kmem_free(ksp->ks_data, ksp->ks_data_size);
04a479f7	561
71c9f0b0	562	mutex_destroy(&ksp->ks_lock);
04a479f7 BB	563	kmem_free(ksp, sizeof(*ksp));
	564
	565	return;
	566	}
	567	EXPORT_SYMBOL(__kstat_delete);
	568
04a479f7	569	int
1114ae6a	570	spl_kstat_init(void)
04a479f7	571	{
b17edc10	572	SENTRY;
f2a745c4 RY	573	mutex_init(&kstat_module_lock, NULL, MUTEX_DEFAULT, NULL);
f2a745c4 RY	574	INIT_LIST_HEAD(&kstat_module_list);
04a479f7	575	kstat_id = 0;
b17edc10	576	SRETURN(0);
04a479f7 BB	577	}
	578
	579	void
1114ae6a	580	spl_kstat_fini(void)
04a479f7	581	{
b17edc10	582	SENTRY;
f2a745c4 RY	583	ASSERT(list_empty(&kstat_module_list));
f2a745c4 RY	584	mutex_destroy(&kstat_module_lock);
b17edc10	585	SEXIT;
04a479f7 BB	586	}
04a479f7 BB	587