[mirror_spl-debian.git] / module / spl / spl-kstat.c

/*
 *  This file is part of the SPL: Solaris Porting Layer.
 *
 *  Copyright (c) 2008 Lawrence Livermore National Security, LLC.
 *  Produced at Lawrence Livermore National Laboratory
 *  Written by:
 *          Brian Behlendorf <behlendorf1@llnl.gov>,
 *          Herb Wartens <wartens2@llnl.gov>,
 *          Jim Garlick <garlick@llnl.gov>
 *  UCRL-CODE-235197
 *
 *  This 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.
 *
 *  This 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 this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
 */

#include <sys/kstat.h>

static spinlock_t kstat_lock;
static struct list_head kstat_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;
                default:
                        SBUG(); /* Unreachable */
        }
}

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:
                        SBUG(); /* Unreachable */
        }

        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(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;
                default:
                        SBUG(); /* Unreachable */
        }

        return rc;
}

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

	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;
                default:
                        SBUG(); /* Unreachable */
        }

        RETURN(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);
        ENTRY;

        spin_lock(&ksp->ks_lock);
	ksp->ks_snaptime = gethrtime();

        if (!n)
                kstat_seq_show_headers(f);

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

        RETURN(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);
        ENTRY;

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

        RETURN(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);

        spin_unlock(&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 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(inode)->data;

        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;

	spin_lock(&kstat_lock);
	ksp->ks_kid = kstat_id;
        kstat_id++;
	spin_unlock(&kstat_lock);

        ksp->ks_magic = KS_MAGIC;
	spin_lock_init(&ksp->ks_lock);
	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;

	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;
                default:
                        SBUG(); /* Unreachable */
        }

	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)
{
	struct proc_dir_entry *de_module, *de_name;
	kstat_t *tmp;
	int rc = 0;
	ENTRY;

	spin_lock(&kstat_lock);

	/* Item may only be added to the list once */
        list_for_each_entry(tmp, &kstat_list, ks_list) {
                if (tmp == ksp) {
		        spin_unlock(&kstat_lock);
			GOTO(out, rc = -EEXIST);
		}
	}

        list_add_tail(&ksp->ks_list, &kstat_list);
	spin_unlock(&kstat_lock);

	de_module = proc_dir_entry_find(proc_spl_kstat, ksp->ks_module);
	if (de_module == NULL) {
                de_module = proc_mkdir(ksp->ks_module, proc_spl_kstat);
		if (de_module == NULL)
			GOTO(out, rc = -EUNATCH);
	}

	de_name = create_proc_entry(ksp->ks_name, 0444, de_module);
	if (de_name == NULL)
		GOTO(out, rc = -EUNATCH);

	spin_lock(&ksp->ks_lock);
	ksp->ks_proc = de_name;
	de_name->proc_fops = &proc_kstat_operations;
        de_name->data = (void *)ksp;
	spin_unlock(&ksp->ks_lock);
out:
	if (rc) {
		spin_lock(&kstat_lock);
	        list_del_init(&ksp->ks_list);
		spin_unlock(&kstat_lock);
	}

	EXIT;
}
EXPORT_SYMBOL(__kstat_install);

void
__kstat_delete(kstat_t *ksp)
{
	struct proc_dir_entry *de_module;

	spin_lock(&kstat_lock);
        list_del_init(&ksp->ks_list);
	spin_unlock(&kstat_lock);

        if (ksp->ks_proc) {
	        de_module = ksp->ks_proc->parent;
	        remove_proc_entry(ksp->ks_name, de_module);

	        /* Remove top level module directory if it's empty */
	        if (proc_dir_entries(de_module) == 0)
		        remove_proc_entry(de_module->name, de_module->parent);
	}

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

	kmem_free(ksp, sizeof(*ksp));

	return;
}
EXPORT_SYMBOL(__kstat_delete);

int
kstat_init(void)
{
	ENTRY;
	spin_lock_init(&kstat_lock);
	INIT_LIST_HEAD(&kstat_list);
        kstat_id = 0;
	RETURN(0);
}

void
kstat_fini(void)
{
	ENTRY;
	ASSERT(list_empty(&kstat_list));
	EXIT;
}
Commit	Line	Data
715f6251	1	/*
	2	* This file is part of the SPL: Solaris Porting Layer.
	3	*
	4	* Copyright (c) 2008 Lawrence Livermore National Security, LLC.
	5	* Produced at Lawrence Livermore National Laboratory
	6	* Written by:
	7	* Brian Behlendorf <behlendorf1@llnl.gov>,
	8	* Herb Wartens <wartens2@llnl.gov>,
	9	* Jim Garlick <garlick@llnl.gov>
	10	* UCRL-CODE-235197
	11	*
	12	* This is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This is distributed in the hope that it will be useful, but WITHOUT
	18	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	19	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	20	* for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	25	*/
	26
04a479f7	27	#include <sys/kstat.h>
04a479f7	28
04a479f7	29	static spinlock_t kstat_lock;
	30	static struct list_head kstat_list;
	31	static kid_t kstat_id;
	32
	33	static void
	34	kstat_seq_show_headers(struct seq_file *f)
	35	{
	36	kstat_t ksp = (kstat_t )f->private;
	37	ASSERT(ksp->ks_magic == KS_MAGIC);
	38
	39	seq_printf(f, "%d %d 0x%02x %d %d %lld %lld\n",
	40	ksp->ks_kid, ksp->ks_type, ksp->ks_flags,
	41	ksp->ks_ndata, (int)ksp->ks_data_size,
	42	ksp->ks_crtime, ksp->ks_snaptime);
	43
	44	switch (ksp->ks_type) {
	45	case KSTAT_TYPE_RAW:
	46	seq_printf(f, "raw data");
	47	break;
	48	case KSTAT_TYPE_NAMED:
	49	seq_printf(f, "%-31s %-4s %s\n",
	50	"name", "type", "data");
	51	break;
	52	case KSTAT_TYPE_INTR:
	53	seq_printf(f, "%-8s %-8s %-8s %-8s %-8s\n",
	54	"hard", "soft", "watchdog",
	55	"spurious", "multsvc");
	56	break;
	57	case KSTAT_TYPE_IO:
	58	seq_printf(f,
	59	"%-8s %-8s %-8s %-8s %-8s %-8s "
	60	"%-8s %-8s %-8s %-8s %-8s %-8s\n",
	61	"nread", "nwritten", "reads", "writes",
	62	"wtime", "wlentime", "wupdate",
	63	"rtime", "rlentime", "rupdate",
	64	"wcnt", "rcnt");
	65	break;
	66	case KSTAT_TYPE_TIMER:
	67	seq_printf(f,
	68	"%-31s %-8s "
	69	"%-8s %-8s %-8s %-8s %-8s\n",
	70	"name", "events", "elapsed",
	71	"min", "max", "start", "stop");
	72	break;
	73	default:
	74	SBUG(); /* Unreachable */
	75	}
	76	}
	77
	78	static int
	79	kstat_seq_show_raw(struct seq_file f, unsigned char p, int l)
	80	{
	81	int i, j;
	82
	83	for (i = 0; ; i++) {
	84	seq_printf(f, "%03x:", i);
	85
	86	for (j = 0; j < 16; j++) {
	87	if (i * 16 + j >= l) {
	88	seq_printf(f, "\n");
	89	goto out;
	90	}
	91
	92	seq_printf(f, " %02x", (unsigned char)p[i * 16 + j]);
93	}
94	seq_printf(f, "\n");
95	}
96	out:
97	return 0;
98	}
99
100	static int
101	kstat_seq_show_named(struct seq_file f, kstat_named_t knp)
102	{
103	seq_printf(f, "%-31s %-4d ", knp->name, knp->data_type);
104
105	switch (knp->data_type) {
106	case KSTAT_DATA_CHAR:
107	knp->value.c[15] = '\0'; /* NULL terminate */
108	seq_printf(f, "%-16s", knp->value.c);
109	break;
110	/* XXX - We need to be more careful able what tokens are
111	* used for each arch, for now this is correct for x86_64.
112	*/
113	case KSTAT_DATA_INT32:
114	seq_printf(f, "%d", knp->value.i32);
115	break;
116	case KSTAT_DATA_UINT32:
117	seq_printf(f, "%u", knp->value.ui32);
118	break;
119	case KSTAT_DATA_INT64:
cfe57499	120	seq_printf(f, "%lld", (signed long long)knp->value.i64);
04a479f7	121	break;
04a479f7	122	case KSTAT_DATA_UINT64:
cfe57499	123	seq_printf(f, "%llu", (unsigned long long)knp->value.ui64);
04a479f7	124	break;
	125	case KSTAT_DATA_LONG:
	126	seq_printf(f, "%ld", knp->value.l);
	127	break;
	128	case KSTAT_DATA_ULONG:
cfe57499	129	seq_printf(f, "%lu", knp->value.ul);
04a479f7	130	break;
	131	case KSTAT_DATA_STRING:
	132	KSTAT_NAMED_STR_PTR(knp)
	133	[KSTAT_NAMED_STR_BUFLEN(knp)-1] = '\0';
	134	seq_printf(f, "%s", KSTAT_NAMED_STR_PTR(knp));
	135	break;
	136	default:
	137	SBUG(); /* Unreachable */
	138	}
	139
	140	seq_printf(f, "\n");
	141
	142	return 0;
	143	}
	144
	145	static int
	146	kstat_seq_show_intr(struct seq_file f, kstat_intr_t kip)
	147	{
	148	seq_printf(f, "%-8u %-8u %-8u %-8u %-8u\n",
	149	kip->intrs[KSTAT_INTR_HARD],
	150	kip->intrs[KSTAT_INTR_SOFT],
	151	kip->intrs[KSTAT_INTR_WATCHDOG],
	152	kip->intrs[KSTAT_INTR_SPURIOUS],
	153	kip->intrs[KSTAT_INTR_MULTSVC]);
	154
	155	return 0;
	156	}
	157
	158	static int
	159	kstat_seq_show_io(struct seq_file f, kstat_io_t kip)
	160	{
	161	seq_printf(f,
	162	"%-8llu %-8llu %-8u %-8u %-8lld %-8lld "
	163	"%-8lld %-8lld %-8lld %-8lld %-8u %-8u\n",
	164	kip->nread, kip->nwritten,
	165	kip->reads, kip->writes,
	166	kip->wtime, kip->wlentime, kip->wlastupdate,
	167	kip->rtime, kip->wlentime, kip->rlastupdate,
	168	kip->wcnt, kip->rcnt);
	169
	170	return 0;
	171	}
	172
	173	static int
	174	kstat_seq_show_timer(struct seq_file f, kstat_timer_t ktp)
	175	{
	176	seq_printf(f,
	177	"%-31s %-8llu %-8lld %-8lld %-8lld %-8lld %-8lld\n",
	178	ktp->name, ktp->num_events, ktp->elapsed_time,
	179	ktp->min_time, ktp->max_time,
	180	ktp->start_time, ktp->stop_time);
	181
	182	return 0;
	183	}
	184
	185	static int
	186	kstat_seq_show(struct seq_file f, void p)
	187	{
	188	kstat_t ksp = (kstat_t )f->private;
	189	int rc = 0;
	190
	191	ASSERT(ksp->ks_magic == KS_MAGIC);
	192
	193	switch (ksp->ks_type) {
194	case KSTAT_TYPE_RAW:
195	ASSERT(ksp->ks_ndata == 1);
196	rc = kstat_seq_show_raw(f, ksp->ks_data,
197	ksp->ks_data_size);
198	break;
199	case KSTAT_TYPE_NAMED:
200	rc = kstat_seq_show_named(f, (kstat_named_t *)p);
201	break;
202	case KSTAT_TYPE_INTR:
203	rc = kstat_seq_show_intr(f, (kstat_intr_t *)p);
204	break;
205	case KSTAT_TYPE_IO:
206	rc = kstat_seq_show_io(f, (kstat_io_t *)p);
207	break;
208	case KSTAT_TYPE_TIMER:
209	rc = kstat_seq_show_timer(f, (kstat_timer_t *)p);
210	break;
211	default:
212	SBUG(); /* Unreachable */
213	}
214
215	return rc;
216	}
217
218	static void *
219	kstat_seq_data_addr(kstat_t *ksp, loff_t n)
220	{
221	void *rc = NULL;
222	ENTRY;
223
224	switch (ksp->ks_type) {
225	case KSTAT_TYPE_RAW:
226	rc = ksp->ks_data;
227	break;
228	case KSTAT_TYPE_NAMED:
229	rc = ksp->ks_data + n * sizeof(kstat_named_t);
230	break;
231	case KSTAT_TYPE_INTR:
232	rc = ksp->ks_data + n * sizeof(kstat_intr_t);
233	break;
234	case KSTAT_TYPE_IO:
235	rc = ksp->ks_data + n * sizeof(kstat_io_t);
236	break;
237	case KSTAT_TYPE_TIMER:
238	rc = ksp->ks_data + n * sizeof(kstat_timer_t);
239	break;
240	default:
241	SBUG(); /* Unreachable */
242	}
243
244	RETURN(rc);
245	}
246
247	static void *
248	kstat_seq_start(struct seq_file f, loff_t pos)
249	{
250	loff_t n = *pos;
251	kstat_t ksp = (kstat_t )f->private;
252	ASSERT(ksp->ks_magic == KS_MAGIC);
253	ENTRY;
254
255	spin_lock(&ksp->ks_lock);
256	ksp->ks_snaptime = gethrtime();
257
258	if (!n)
259	kstat_seq_show_headers(f);
260
261	if (n >= ksp->ks_ndata)
262	RETURN(NULL);
263
264	RETURN(kstat_seq_data_addr(ksp, n));
265	}
266
267	static void *
268	kstat_seq_next(struct seq_file f, void p, loff_t *pos)
269	{
270	kstat_t ksp = (kstat_t )f->private;
271	ASSERT(ksp->ks_magic == KS_MAGIC);
272	ENTRY;
273
274	++*pos;
275	if (*pos >= ksp->ks_ndata)
276	RETURN(NULL);
277
278	RETURN(kstat_seq_data_addr(ksp, *pos));
279	}
280
281	static void
282	kstat_seq_stop(struct seq_file f, void v)
283	{
284	kstat_t ksp = (kstat_t )f->private;
285	ASSERT(ksp->ks_magic == KS_MAGIC);
286
287	spin_unlock(&ksp->ks_lock);
288	}
289
290	static struct seq_operations kstat_seq_ops = {
291	.show = kstat_seq_show,
292	.start = kstat_seq_start,
293	.next = kstat_seq_next,
294	.stop = kstat_seq_stop,
295	};
296
297	static int
298	proc_kstat_open(struct inode inode, struct file filp)
299	{
300	struct seq_file *f;
301	int rc;
302
303	rc = seq_open(filp, &kstat_seq_ops);
304	if (rc)
305	return rc;
306
307	f = filp->private_data;
308	f->private = PDE(inode)->data;
309
310	return rc;
311	}
312
313	static struct file_operations proc_kstat_operations = {
314	.open = proc_kstat_open,
315	.read = seq_read,
316	.llseek = seq_lseek,
317	.release = seq_release,
318	};
319
320	kstat_t *
321	__kstat_create(const char ks_module, int ks_instance, const char ks_name,
322	const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
323	uchar_t ks_flags)
324	{
325	kstat_t *ksp;
326
327	ASSERT(ks_module);
328	ASSERT(ks_instance == 0);
329	ASSERT(ks_name);
330	ASSERT(!(ks_flags & KSTAT_FLAG_UNSUPPORTED));
331
332	if ((ks_type == KSTAT_TYPE_INTR) \|\| (ks_type == KSTAT_TYPE_IO))
333	ASSERT(ks_ndata == 1);
334
335	ksp = kmem_zalloc(sizeof(*ksp), KM_SLEEP);
336	if (ksp == NULL)
337	return ksp;
338
339	spin_lock(&kstat_lock);
340	ksp->ks_kid = kstat_id;
341	kstat_id++;
342	spin_unlock(&kstat_lock);
343
344	ksp->ks_magic = KS_MAGIC;
345	spin_lock_init(&ksp->ks_lock);
346	INIT_LIST_HEAD(&ksp->ks_list);
347
348	ksp->ks_crtime = gethrtime();
349	ksp->ks_snaptime = ksp->ks_crtime;
350	strncpy(ksp->ks_module, ks_module, KSTAT_STRLEN);
351	ksp->ks_instance = ks_instance;
352	strncpy(ksp->ks_name, ks_name, KSTAT_STRLEN);
353	strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
354	ksp->ks_type = ks_type;
355	ksp->ks_flags = ks_flags;
356
357	switch (ksp->ks_type) {
358	case KSTAT_TYPE_RAW:
359	ksp->ks_ndata = 1;
360	ksp->ks_data_size = ks_ndata;
361	break;
362	case KSTAT_TYPE_NAMED:
363	ksp->ks_ndata = ks_ndata;
364	ksp->ks_data_size = ks_ndata * sizeof(kstat_named_t);
365	break;
366	case KSTAT_TYPE_INTR:
367	ksp->ks_ndata = ks_ndata;
368	ksp->ks_data_size = ks_ndata * sizeof(kstat_intr_t);
369	break;
370	case KSTAT_TYPE_IO:
371	ksp->ks_ndata = ks_ndata;
372	ksp->ks_data_size = ks_ndata * sizeof(kstat_io_t);
373	break;
374	case KSTAT_TYPE_TIMER:
375	ksp->ks_ndata = ks_ndata;
376	ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
377	break;
378	default:
379	SBUG(); /* Unreachable */
380	}
381
382	if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
383	ksp->ks_data = NULL;
384	} else {
385	ksp->ks_data = kmem_alloc(ksp->ks_data_size, KM_SLEEP);
386	if (ksp->ks_data == NULL) {
387	kmem_free(ksp, sizeof(*ksp));
388	ksp = NULL;
389	}
390	}
391
392	return ksp;
393	}
394	EXPORT_SYMBOL(__kstat_create);
395
396	void
397	__kstat_install(kstat_t *ksp)
398	{
399	struct proc_dir_entry de_module, de_name;
400	kstat_t *tmp;
401	int rc = 0;
402	ENTRY;
403
404	spin_lock(&kstat_lock);
405
406	/* Item may only be added to the list once */
407	list_for_each_entry(tmp, &kstat_list, ks_list) {
408	if (tmp == ksp) {
409	spin_unlock(&kstat_lock);
410	GOTO(out, rc = -EEXIST);
411	}
412	}
413
414	list_add_tail(&ksp->ks_list, &kstat_list);
415	spin_unlock(&kstat_lock);
416
c30df9c8	417	de_module = proc_dir_entry_find(proc_spl_kstat, ksp->ks_module);
04a479f7	418	if (de_module == NULL) {
c30df9c8	419	de_module = proc_mkdir(ksp->ks_module, proc_spl_kstat);
04a479f7	420	if (de_module == NULL)
	421	GOTO(out, rc = -EUNATCH);
	422	}
	423
	424	de_name = create_proc_entry(ksp->ks_name, 0444, de_module);
	425	if (de_name == NULL)
	426	GOTO(out, rc = -EUNATCH);
	427
	428	spin_lock(&ksp->ks_lock);
	429	ksp->ks_proc = de_name;
	430	de_name->proc_fops = &proc_kstat_operations;
	431	de_name->data = (void *)ksp;
	432	spin_unlock(&ksp->ks_lock);
	433	out:
	434	if (rc) {
	435	spin_lock(&kstat_lock);
	436	list_del_init(&ksp->ks_list);
	437	spin_unlock(&kstat_lock);
	438	}
	439
	440	EXIT;
	441	}
	442	EXPORT_SYMBOL(__kstat_install);
	443
	444	void
	445	__kstat_delete(kstat_t *ksp)
	446	{
	447	struct proc_dir_entry *de_module;
	448
	449	spin_lock(&kstat_lock);
	450	list_del_init(&ksp->ks_list);
	451	spin_unlock(&kstat_lock);
	452
	453	if (ksp->ks_proc) {
	454	de_module = ksp->ks_proc->parent;
	455	remove_proc_entry(ksp->ks_name, de_module);
	456
	457	/* Remove top level module directory if it's empty */
	458	if (proc_dir_entries(de_module) == 0)
	459	remove_proc_entry(de_module->name, de_module->parent);
	460	}
	461
	462	if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
	463	kmem_free(ksp->ks_data, ksp->ks_data_size);
	464
	465	kmem_free(ksp, sizeof(*ksp));
	466
	467	return;
	468	}
	469	EXPORT_SYMBOL(__kstat_delete);
	470
04a479f7	471	int
	472	kstat_init(void)
	473	{
	474	ENTRY;
04a479f7	475	spin_lock_init(&kstat_lock);
	476	INIT_LIST_HEAD(&kstat_list);
	477	kstat_id = 0;
04a479f7	478	RETURN(0);
	479	}
	480
	481	void
	482	kstat_fini(void)
	483	{
	484	ENTRY;
04a479f7	485	ASSERT(list_empty(&kstat_list));
04a479f7	486	EXIT;
	487	}
	488