[mirror_spl.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 int
kstat_resize_raw(kstat_t *ksp)
{
	if (ksp->ks_raw_bufsize == KSTAT_RAW_MAX)
		return ENOMEM;

	vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);
	ksp->ks_raw_bufsize = MIN(ksp->ks_raw_bufsize * 2, KSTAT_RAW_MAX);
	ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);

	return 0;
}

void
kstat_waitq_enter(kstat_io_t *kiop)
{
	hrtime_t new, delta;
	ulong_t wcnt;

	new = gethrtime();
	delta = new - kiop->wlastupdate;
	kiop->wlastupdate = new;
	wcnt = kiop->wcnt++;
	if (wcnt != 0) {
		kiop->wlentime += delta * wcnt;
		kiop->wtime += delta;
	}
}
EXPORT_SYMBOL(kstat_waitq_enter);

void
kstat_waitq_exit(kstat_io_t *kiop)
{
	hrtime_t new, delta;
	ulong_t wcnt;

	new = gethrtime();
	delta = new - kiop->wlastupdate;
	kiop->wlastupdate = new;
	wcnt = kiop->wcnt--;
	ASSERT((int)wcnt > 0);
	kiop->wlentime += delta * wcnt;
	kiop->wtime += delta;
}
EXPORT_SYMBOL(kstat_waitq_exit);

void
kstat_runq_enter(kstat_io_t *kiop)
{
	hrtime_t new, delta;
	ulong_t rcnt;

	new = gethrtime();
	delta = new - kiop->rlastupdate;
	kiop->rlastupdate = new;
	rcnt = kiop->rcnt++;
	if (rcnt != 0) {
		kiop->rlentime += delta * rcnt;
		kiop->rtime += delta;
	}
}
EXPORT_SYMBOL(kstat_runq_enter);

void
kstat_runq_exit(kstat_io_t *kiop)
{
	hrtime_t new, delta;
	ulong_t rcnt;

	new = gethrtime();
	delta = new - kiop->rlastupdate;
	kiop->rlastupdate = new;
	rcnt = kiop->rcnt--;
	ASSERT((int)rcnt > 0);
	kiop->rlentime += delta * rcnt;
	kiop->rtime += delta;
}
EXPORT_SYMBOL(kstat_runq_exit);

static int
kstat_seq_show_headers(struct seq_file *f)
{
        kstat_t *ksp = (kstat_t *)f->private;
	int rc = 0;

        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:
restart:
                        if (ksp->ks_raw_ops.headers) {
                                rc = ksp->ks_raw_ops.headers(
                                    ksp->ks_raw_buf, ksp->ks_raw_bufsize);
				if (rc == ENOMEM && !kstat_resize_raw(ksp))
					goto restart;
				if (!rc)
	                                seq_puts(f, ksp->ks_raw_buf);
                        } else {
                                seq_printf(f, "raw data\n");
                        }
                        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:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }

	return -rc;
}

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(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:
restart:
                        if (ksp->ks_raw_ops.data) {
                                rc = ksp->ks_raw_ops.data(
				    ksp->ks_raw_buf, ksp->ks_raw_bufsize, p);
				if (rc == ENOMEM && !kstat_resize_raw(ksp))
					goto restart;
				if (!rc)
	                                seq_puts(f, ksp->ks_raw_buf);
                        } else {
                                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:
                        PANIC("Undefined kstat type %d\n", ksp->ks_type);
        }

        return -rc;
}

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

	if (rw == KSTAT_WRITE)
		return (EACCES);

	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:
                        if (ksp->ks_raw_ops.addr)
                                rc = ksp->ks_raw_ops.addr(ksp, n);
                        else
                                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:
                        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);

        if (ksp->ks_type == KSTAT_TYPE_RAW) {
                ksp->ks_raw_bufsize = PAGE_SIZE;
                ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);
        }

        /* 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))
		SRETURN(NULL);

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

	if (ksp->ks_type == KSTAT_TYPE_RAW)
		vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);

	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 ssize_t
proc_kstat_write(struct file *filp, const char __user *buf,
		 size_t len, loff_t *ppos)
{
	struct seq_file *f = filp->private_data;
	kstat_t *ksp = f->private;
	int rc;

	ASSERT(ksp->ks_magic == KS_MAGIC);

	mutex_enter(ksp->ks_lock);
	rc = ksp->ks_update(ksp, KSTAT_WRITE);
	mutex_exit(ksp->ks_lock);

	if (rc)
		return (-rc);

	*ppos += len;
	return (len);
}

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

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))
{
	ksp->ks_raw_ops.headers = headers;
	ksp->ks_raw_ops.data    = data;
	ksp->ks_raw_ops.addr    = addr;
}
EXPORT_SYMBOL(__kstat_set_raw_ops);

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_private_lock, NULL, MUTEX_DEFAULT, NULL);
	ksp->ks_lock = &ksp->ks_private_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;
	ksp->ks_update = kstat_default_update;
	ksp->ks_private = NULL;
	ksp->ks_raw_ops.headers = NULL;
	ksp->ks_raw_ops.data = NULL;
	ksp->ks_raw_ops.addr = NULL;
	ksp->ks_raw_buf = NULL;
	ksp->ks_raw_bufsize = 0;

	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:
                        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_zalloc(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, 0644,
	    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);

	ksp->ks_lock = NULL;
	mutex_destroy(&ksp->ks_private_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	6	* UCRL-CODE-235197
715f6251	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	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	42	static kid_t kstat_id;
04a479f7	43
56d40a68 PS	44	static int
	45	kstat_resize_raw(kstat_t *ksp)
	46	{
	47	if (ksp->ks_raw_bufsize == KSTAT_RAW_MAX)
	48	return ENOMEM;
	49
	50	vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);
	51	ksp->ks_raw_bufsize = MIN(ksp->ks_raw_bufsize * 2, KSTAT_RAW_MAX);
	52	ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);
	53
	54	return 0;
	55	}
	56
f483a97a NB	57	void
	58	kstat_waitq_enter(kstat_io_t *kiop)
	59	{
	60	hrtime_t new, delta;
	61	ulong_t wcnt;
	62
	63	new = gethrtime();
	64	delta = new - kiop->wlastupdate;
	65	kiop->wlastupdate = new;
	66	wcnt = kiop->wcnt++;
	67	if (wcnt != 0) {
	68	kiop->wlentime += delta * wcnt;
	69	kiop->wtime += delta;
	70	}
	71	}
	72	EXPORT_SYMBOL(kstat_waitq_enter);
	73
	74	void
	75	kstat_waitq_exit(kstat_io_t *kiop)
	76	{
	77	hrtime_t new, delta;
	78	ulong_t wcnt;
	79
	80	new = gethrtime();
	81	delta = new - kiop->wlastupdate;
	82	kiop->wlastupdate = new;
	83	wcnt = kiop->wcnt--;
	84	ASSERT((int)wcnt > 0);
	85	kiop->wlentime += delta * wcnt;
	86	kiop->wtime += delta;
	87	}
	88	EXPORT_SYMBOL(kstat_waitq_exit);
	89
	90	void
	91	kstat_runq_enter(kstat_io_t *kiop)
	92	{
	93	hrtime_t new, delta;
	94	ulong_t rcnt;
	95
	96	new = gethrtime();
	97	delta = new - kiop->rlastupdate;
	98	kiop->rlastupdate = new;
	99	rcnt = kiop->rcnt++;
	100	if (rcnt != 0) {
	101	kiop->rlentime += delta * rcnt;
	102	kiop->rtime += delta;
	103	}
	104	}
	105	EXPORT_SYMBOL(kstat_runq_enter);
	106
	107	void
	108	kstat_runq_exit(kstat_io_t *kiop)
	109	{
	110	hrtime_t new, delta;
	111	ulong_t rcnt;
	112
	113	new = gethrtime();
	114	delta = new - kiop->rlastupdate;
	115	kiop->rlastupdate = new;
	116	rcnt = kiop->rcnt--;
	117	ASSERT((int)rcnt > 0);
	118	kiop->rlentime += delta * rcnt;
	119	kiop->rtime += delta;
	120	}
121	EXPORT_SYMBOL(kstat_runq_exit);
122
56d40a68	123	static int
04a479f7	124	kstat_seq_show_headers(struct seq_file *f)
	125	{
	126	kstat_t ksp = (kstat_t )f->private;
56d40a68 PS	127	int rc = 0;
56d40a68 PS	128
04a479f7	129	ASSERT(ksp->ks_magic == KS_MAGIC);
	130
	131	seq_printf(f, "%d %d 0x%02x %d %d %lld %lld\n",
	132	ksp->ks_kid, ksp->ks_type, ksp->ks_flags,
	133	ksp->ks_ndata, (int)ksp->ks_data_size,
	134	ksp->ks_crtime, ksp->ks_snaptime);
	135
	136	switch (ksp->ks_type) {
	137	case KSTAT_TYPE_RAW:
56d40a68 PS	138	restart:
	139	if (ksp->ks_raw_ops.headers) {
	140	rc = ksp->ks_raw_ops.headers(
	141	ksp->ks_raw_buf, ksp->ks_raw_bufsize);
	142	if (rc == ENOMEM && !kstat_resize_raw(ksp))
	143	goto restart;
	144	if (!rc)
	145	seq_puts(f, ksp->ks_raw_buf);
	146	} else {
	147	seq_printf(f, "raw data\n");
	148	}
04a479f7	149	break;
	150	case KSTAT_TYPE_NAMED:
	151	seq_printf(f, "%-31s %-4s %s\n",
	152	"name", "type", "data");
	153	break;
	154	case KSTAT_TYPE_INTR:
	155	seq_printf(f, "%-8s %-8s %-8s %-8s %-8s\n",
	156	"hard", "soft", "watchdog",
	157	"spurious", "multsvc");
	158	break;
	159	case KSTAT_TYPE_IO:
	160	seq_printf(f,
	161	"%-8s %-8s %-8s %-8s %-8s %-8s "
	162	"%-8s %-8s %-8s %-8s %-8s %-8s\n",
	163	"nread", "nwritten", "reads", "writes",
	164	"wtime", "wlentime", "wupdate",
	165	"rtime", "rlentime", "rupdate",
	166	"wcnt", "rcnt");
	167	break;
	168	case KSTAT_TYPE_TIMER:
	169	seq_printf(f,
	170	"%-31s %-8s "
	171	"%-8s %-8s %-8s %-8s %-8s\n",
	172	"name", "events", "elapsed",
	173	"min", "max", "start", "stop");
	174	break;
	175	default:
55abb092	176	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7	177	}
56d40a68 PS	178
56d40a68 PS	179	return -rc;
04a479f7	180	}
	181
	182	static int
	183	kstat_seq_show_raw(struct seq_file f, unsigned char p, int l)
	184	{
	185	int i, j;
	186
	187	for (i = 0; ; i++) {
	188	seq_printf(f, "%03x:", i);
	189
	190	for (j = 0; j < 16; j++) {
	191	if (i * 16 + j >= l) {
	192	seq_printf(f, "\n");
	193	goto out;
	194	}
	195
	196	seq_printf(f, " %02x", (unsigned char)p[i * 16 + j]);
	197	}
	198	seq_printf(f, "\n");
	199	}
	200	out:
	201	return 0;
	202	}
	203
	204	static int
	205	kstat_seq_show_named(struct seq_file f, kstat_named_t knp)
	206	{
	207	seq_printf(f, "%-31s %-4d ", knp->name, knp->data_type);
	208
	209	switch (knp->data_type) {
	210	case KSTAT_DATA_CHAR:
	211	knp->value.c[15] = '\0'; /* NULL terminate */
	212	seq_printf(f, "%-16s", knp->value.c);
	213	break;
	214	/* XXX - We need to be more careful able what tokens are
	215	* used for each arch, for now this is correct for x86_64.
	216	*/
	217	case KSTAT_DATA_INT32:
	218	seq_printf(f, "%d", knp->value.i32);
	219	break;
	220	case KSTAT_DATA_UINT32:
	221	seq_printf(f, "%u", knp->value.ui32);
	222	break;
	223	case KSTAT_DATA_INT64:
cfe57499	224	seq_printf(f, "%lld", (signed long long)knp->value.i64);
04a479f7	225	break;
04a479f7	226	case KSTAT_DATA_UINT64:
cfe57499	227	seq_printf(f, "%llu", (unsigned long long)knp->value.ui64);
04a479f7	228	break;
	229	case KSTAT_DATA_LONG:
	230	seq_printf(f, "%ld", knp->value.l);
	231	break;
	232	case KSTAT_DATA_ULONG:
cfe57499	233	seq_printf(f, "%lu", knp->value.ul);
04a479f7	234	break;
	235	case KSTAT_DATA_STRING:
	236	KSTAT_NAMED_STR_PTR(knp)
	237	[KSTAT_NAMED_STR_BUFLEN(knp)-1] = '\0';
	238	seq_printf(f, "%s", KSTAT_NAMED_STR_PTR(knp));
	239	break;
	240	default:
55abb092	241	PANIC("Undefined kstat data type %d\n", knp->data_type);
04a479f7	242	}
	243
	244	seq_printf(f, "\n");
	245
	246	return 0;
	247	}
	248
	249	static int
	250	kstat_seq_show_intr(struct seq_file f, kstat_intr_t kip)
	251	{
	252	seq_printf(f, "%-8u %-8u %-8u %-8u %-8u\n",
	253	kip->intrs[KSTAT_INTR_HARD],
	254	kip->intrs[KSTAT_INTR_SOFT],
	255	kip->intrs[KSTAT_INTR_WATCHDOG],
	256	kip->intrs[KSTAT_INTR_SPURIOUS],
	257	kip->intrs[KSTAT_INTR_MULTSVC]);
	258
	259	return 0;
	260	}
	261
	262	static int
	263	kstat_seq_show_io(struct seq_file f, kstat_io_t kip)
	264	{
	265	seq_printf(f,
	266	"%-8llu %-8llu %-8u %-8u %-8lld %-8lld "
	267	"%-8lld %-8lld %-8lld %-8lld %-8u %-8u\n",
	268	kip->nread, kip->nwritten,
	269	kip->reads, kip->writes,
	270	kip->wtime, kip->wlentime, kip->wlastupdate,
	271	kip->rtime, kip->wlentime, kip->rlastupdate,
	272	kip->wcnt, kip->rcnt);
	273
	274	return 0;
	275	}
	276
	277	static int
	278	kstat_seq_show_timer(struct seq_file f, kstat_timer_t ktp)
	279	{
	280	seq_printf(f,
	281	"%-31s %-8llu %-8lld %-8lld %-8lld %-8lld %-8lld\n",
	282	ktp->name, ktp->num_events, ktp->elapsed_time,
	283	ktp->min_time, ktp->max_time,
	284	ktp->start_time, ktp->stop_time);
	285
	286	return 0;
	287	}
	288
	289	static int
	290	kstat_seq_show(struct seq_file f, void p)
	291	{
	292	kstat_t ksp = (kstat_t )f->private;
	293	int rc = 0;
	294
	295	ASSERT(ksp->ks_magic == KS_MAGIC);
	296
	297	switch (ksp->ks_type) {
	298	case KSTAT_TYPE_RAW:
56d40a68 PS	299	restart:
	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))
	304	goto restart;
	305	if (!rc)
	306	seq_puts(f, ksp->ks_raw_buf);
	307	} else {
	308	ASSERT(ksp->ks_ndata == 1);
	309	rc = kstat_seq_show_raw(f, ksp->ks_data,
	310	ksp->ks_data_size);
	311	}
04a479f7	312	break;
	313	case KSTAT_TYPE_NAMED:
	314	rc = kstat_seq_show_named(f, (kstat_named_t *)p);
	315	break;
	316	case KSTAT_TYPE_INTR:
	317	rc = kstat_seq_show_intr(f, (kstat_intr_t *)p);
	318	break;
	319	case KSTAT_TYPE_IO:
	320	rc = kstat_seq_show_io(f, (kstat_io_t *)p);
	321	break;
	322	case KSTAT_TYPE_TIMER:
	323	rc = kstat_seq_show_timer(f, (kstat_timer_t *)p);
	324	break;
	325	default:
55abb092	326	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7	327	}
04a479f7	328
56d40a68	329	return -rc;
04a479f7	330	}
04a479f7	331
9a8b7a74 BB	332	int
	333	kstat_default_update(kstat_t *ksp, int rw)
	334	{
	335	ASSERT(ksp != NULL);
56d40a68 PS	336
	337	if (rw == KSTAT_WRITE)
	338	return (EACCES);
	339
9a8b7a74 BB	340	return 0;
	341	}
	342
04a479f7	343	static void *
	344	kstat_seq_data_addr(kstat_t *ksp, loff_t n)
	345	{
	346	void *rc = NULL;
b17edc10	347	SENTRY;
04a479f7	348
	349	switch (ksp->ks_type) {
	350	case KSTAT_TYPE_RAW:
56d40a68 PS	351	if (ksp->ks_raw_ops.addr)
	352	rc = ksp->ks_raw_ops.addr(ksp, n);
	353	else
	354	rc = ksp->ks_data;
04a479f7	355	break;
	356	case KSTAT_TYPE_NAMED:
	357	rc = ksp->ks_data + n * sizeof(kstat_named_t);
	358	break;
	359	case KSTAT_TYPE_INTR:
	360	rc = ksp->ks_data + n * sizeof(kstat_intr_t);
	361	break;
	362	case KSTAT_TYPE_IO:
	363	rc = ksp->ks_data + n * sizeof(kstat_io_t);
	364	break;
	365	case KSTAT_TYPE_TIMER:
	366	rc = ksp->ks_data + n * sizeof(kstat_timer_t);
	367	break;
	368	default:
55abb092	369	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7	370	}
04a479f7	371
b17edc10	372	SRETURN(rc);
04a479f7	373	}
	374
	375	static void *
	376	kstat_seq_start(struct seq_file f, loff_t pos)
	377	{
	378	loff_t n = *pos;
	379	kstat_t ksp = (kstat_t )f->private;
	380	ASSERT(ksp->ks_magic == KS_MAGIC);
b17edc10	381	SENTRY;
04a479f7	382
ffbf0e57	383	mutex_enter(ksp->ks_lock);
71c9f0b0	384
56d40a68 PS	385	if (ksp->ks_type == KSTAT_TYPE_RAW) {
	386	ksp->ks_raw_bufsize = PAGE_SIZE;
	387	ksp->ks_raw_buf = vmem_alloc(ksp->ks_raw_bufsize, KM_SLEEP);
	388	}
	389
9a8b7a74 BB	390	/* Dynamically update kstat, on error existing kstats are used */
	391	(void) ksp->ks_update(ksp, KSTAT_READ);
	392
04a479f7	393	ksp->ks_snaptime = gethrtime();
04a479f7	394
56d40a68 PS	395	if (!n && kstat_seq_show_headers(f))
56d40a68 PS	396	SRETURN(NULL);
04a479f7	397
04a479f7	398	if (n >= ksp->ks_ndata)
b17edc10	399	SRETURN(NULL);
04a479f7	400
b17edc10	401	SRETURN(kstat_seq_data_addr(ksp, n));
04a479f7	402	}
	403
	404	static void *
	405	kstat_seq_next(struct seq_file f, void p, loff_t *pos)
	406	{
	407	kstat_t ksp = (kstat_t )f->private;
	408	ASSERT(ksp->ks_magic == KS_MAGIC);
b17edc10	409	SENTRY;
04a479f7	410
	411	++*pos;
	412	if (*pos >= ksp->ks_ndata)
b17edc10	413	SRETURN(NULL);
04a479f7	414
b17edc10	415	SRETURN(kstat_seq_data_addr(ksp, *pos));
04a479f7	416	}
	417
	418	static void
	419	kstat_seq_stop(struct seq_file f, void v)
	420	{
ffbf0e57 CP	421	kstat_t ksp = (kstat_t )f->private;
ffbf0e57 CP	422	ASSERT(ksp->ks_magic == KS_MAGIC);
04a479f7	423
56d40a68 PS	424	if (ksp->ks_type == KSTAT_TYPE_RAW)
	425	vmem_free(ksp->ks_raw_buf, ksp->ks_raw_bufsize);
	426
ffbf0e57	427	mutex_exit(ksp->ks_lock);
04a479f7	428	}
	429
	430	static struct seq_operations kstat_seq_ops = {
	431	.show = kstat_seq_show,
	432	.start = kstat_seq_start,
	433	.next = kstat_seq_next,
	434	.stop = kstat_seq_stop,
	435	};
	436
f2a745c4 RY	437	static kstat_module_t *
	438	kstat_find_module(char *name)
	439	{
	440	kstat_module_t *module;
	441
	442	list_for_each_entry(module, &kstat_module_list, ksm_module_list)
	443	if (strncmp(name, module->ksm_name, KSTAT_STRLEN) == 0)
	444	return (module);
	445
	446	return (NULL);
	447	}
	448
	449	static kstat_module_t *
	450	kstat_create_module(char *name)
	451	{
	452	kstat_module_t *module;
	453	struct proc_dir_entry *pde;
	454
	455	pde = proc_mkdir(name, proc_spl_kstat);
	456	if (pde == NULL)
	457	return (NULL);
	458
	459	module = kmem_alloc(sizeof (kstat_module_t), KM_SLEEP);
	460	module->ksm_proc = pde;
	461	strlcpy(module->ksm_name, name, KSTAT_STRLEN+1);
	462	INIT_LIST_HEAD(&module->ksm_kstat_list);
	463	list_add_tail(&module->ksm_module_list, &kstat_module_list);
	464
	465	return (module);
	466
	467	}
	468
	469	static void
	470	kstat_delete_module(kstat_module_t *module)
	471	{
	472	ASSERT(list_empty(&module->ksm_kstat_list));
	473	remove_proc_entry(module->ksm_name, proc_spl_kstat);
	474	list_del(&module->ksm_module_list);
	475	kmem_free(module, sizeof(kstat_module_t));
	476	}
	477
04a479f7	478	static int
	479	proc_kstat_open(struct inode inode, struct file filp)
	480	{
	481	struct seq_file *f;
	482	int rc;
	483
	484	rc = seq_open(filp, &kstat_seq_ops);
	485	if (rc)
	486	return rc;
	487
	488	f = filp->private_data;
1ddf9722	489	f->private = PDE_DATA(inode);
04a479f7	490
	491	return rc;
	492	}
	493
56d40a68 PS	494	static ssize_t
	495	proc_kstat_write(struct file filp, const char __user buf,
	496	size_t len, loff_t *ppos)
	497	{
	498	struct seq_file *f = filp->private_data;
	499	kstat_t *ksp = f->private;
	500	int rc;
	501
	502	ASSERT(ksp->ks_magic == KS_MAGIC);
	503
	504	mutex_enter(ksp->ks_lock);
	505	rc = ksp->ks_update(ksp, KSTAT_WRITE);
	506	mutex_exit(ksp->ks_lock);
	507
	508	if (rc)
	509	return (-rc);
	510
	511	*ppos += len;
	512	return (len);
	513	}
	514
04a479f7	515	static struct file_operations proc_kstat_operations = {
56d40a68 PS	516	.open = proc_kstat_open,
	517	.write = proc_kstat_write,
	518	.read = seq_read,
	519	.llseek = seq_lseek,
	520	.release = seq_release,
04a479f7	521	};
04a479f7	522
56d40a68 PS	523	void
	524	__kstat_set_raw_ops(kstat_t *ksp,
	525	int (headers)(char buf, size_t size),
	526	int (data)(char buf, size_t size, void *data),
	527	void (addr)(kstat_t *ksp, loff_t index))
	528	{
	529	ksp->ks_raw_ops.headers = headers;
	530	ksp->ks_raw_ops.data = data;
	531	ksp->ks_raw_ops.addr = addr;
	532	}
	533	EXPORT_SYMBOL(__kstat_set_raw_ops);
	534
04a479f7	535	kstat_t *
	536	__kstat_create(const char ks_module, int ks_instance, const char ks_name,
	537	const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
	538	uchar_t ks_flags)
	539	{
	540	kstat_t *ksp;
	541
	542	ASSERT(ks_module);
	543	ASSERT(ks_instance == 0);
	544	ASSERT(ks_name);
	545	ASSERT(!(ks_flags & KSTAT_FLAG_UNSUPPORTED));
	546
	547	if ((ks_type == KSTAT_TYPE_INTR) \|\| (ks_type == KSTAT_TYPE_IO))
	548	ASSERT(ks_ndata == 1);
	549
	550	ksp = kmem_zalloc(sizeof(*ksp), KM_SLEEP);
	551	if (ksp == NULL)
	552	return ksp;
	553
f2a745c4	554	mutex_enter(&kstat_module_lock);
04a479f7	555	ksp->ks_kid = kstat_id;
04a479f7	556	kstat_id++;
f2a745c4	557	mutex_exit(&kstat_module_lock);
04a479f7	558
04a479f7	559	ksp->ks_magic = KS_MAGIC;
ffbf0e57 CP	560	mutex_init(&ksp->ks_private_lock, NULL, MUTEX_DEFAULT, NULL);
ffbf0e57 CP	561	ksp->ks_lock = &ksp->ks_private_lock;
04a479f7	562	INIT_LIST_HEAD(&ksp->ks_list);
	563
	564	ksp->ks_crtime = gethrtime();
	565	ksp->ks_snaptime = ksp->ks_crtime;
	566	strncpy(ksp->ks_module, ks_module, KSTAT_STRLEN);
	567	ksp->ks_instance = ks_instance;
	568	strncpy(ksp->ks_name, ks_name, KSTAT_STRLEN);
	569	strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
	570	ksp->ks_type = ks_type;
	571	ksp->ks_flags = ks_flags;
9a8b7a74 BB	572	ksp->ks_update = kstat_default_update;
9a8b7a74 BB	573	ksp->ks_private = NULL;
56d40a68 PS	574	ksp->ks_raw_ops.headers = NULL;
	575	ksp->ks_raw_ops.data = NULL;
	576	ksp->ks_raw_ops.addr = NULL;
	577	ksp->ks_raw_buf = NULL;
	578	ksp->ks_raw_bufsize = 0;
04a479f7	579
	580	switch (ksp->ks_type) {
	581	case KSTAT_TYPE_RAW:
	582	ksp->ks_ndata = 1;
	583	ksp->ks_data_size = ks_ndata;
	584	break;
	585	case KSTAT_TYPE_NAMED:
	586	ksp->ks_ndata = ks_ndata;
	587	ksp->ks_data_size = ks_ndata * sizeof(kstat_named_t);
	588	break;
	589	case KSTAT_TYPE_INTR:
	590	ksp->ks_ndata = ks_ndata;
	591	ksp->ks_data_size = ks_ndata * sizeof(kstat_intr_t);
	592	break;
	593	case KSTAT_TYPE_IO:
	594	ksp->ks_ndata = ks_ndata;
	595	ksp->ks_data_size = ks_ndata * sizeof(kstat_io_t);
	596	break;
	597	case KSTAT_TYPE_TIMER:
	598	ksp->ks_ndata = ks_ndata;
	599	ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
	600	break;
	601	default:
55abb092	602	PANIC("Undefined kstat type %d\n", ksp->ks_type);
04a479f7	603	}
	604
	605	if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
	606	ksp->ks_data = NULL;
	607	} else {
f483a97a	608	ksp->ks_data = kmem_zalloc(ksp->ks_data_size, KM_SLEEP);
04a479f7	609	if (ksp->ks_data == NULL) {
	610	kmem_free(ksp, sizeof(*ksp));
	611	ksp = NULL;
	612	}
	613	}
	614
	615	return ksp;
	616	}
	617	EXPORT_SYMBOL(__kstat_create);
	618
	619	void
	620	__kstat_install(kstat_t *ksp)
	621	{
f2a745c4	622	kstat_module_t *module;
04a479f7	623	kstat_t *tmp;
04a479f7	624
f2a745c4	625	ASSERT(ksp);
04a479f7	626
f2a745c4	627	mutex_enter(&kstat_module_lock);
04a479f7	628
f2a745c4 RY	629	module = kstat_find_module(ksp->ks_module);
	630	if (module == NULL) {
	631	module = kstat_create_module(ksp->ks_module);
	632	if (module == NULL)
	633	goto out;
04a479f7	634	}
04a479f7	635
f2a745c4 RY	636	/*
	637	* Only one entry by this name per-module, on failure the module
	638	* shouldn't be deleted because we know it has at least one entry.
	639	*/
	640	list_for_each_entry(tmp, &module->ksm_kstat_list, ks_list)
	641	if (strncmp(tmp->ks_name, ksp->ks_name, KSTAT_STRLEN) == 0)
	642	goto out;
	643
	644	list_add_tail(&ksp->ks_list, &module->ksm_kstat_list);
04a479f7	645
ffbf0e57	646	mutex_enter(ksp->ks_lock);
f2a745c4	647	ksp->ks_owner = module;
56d40a68	648	ksp->ks_proc = proc_create_data(ksp->ks_name, 0644,
f2a745c4 RY	649	module->ksm_proc, &proc_kstat_operations, (void *)ksp);
	650	if (ksp->ks_proc == NULL) {
	651	list_del_init(&ksp->ks_list);
	652	if (list_empty(&module->ksm_kstat_list))
	653	kstat_delete_module(module);
	654	}
ffbf0e57	655	mutex_exit(ksp->ks_lock);
04a479f7	656	out:
f2a745c4	657	mutex_exit(&kstat_module_lock);
04a479f7	658	}
	659	EXPORT_SYMBOL(__kstat_install);
	660
	661	void
	662	__kstat_delete(kstat_t *ksp)
	663	{
f2a745c4	664	kstat_module_t *module = ksp->ks_owner;
04a479f7	665
f2a745c4 RY	666	mutex_enter(&kstat_module_lock);
	667	list_del_init(&ksp->ks_list);
	668	mutex_exit(&kstat_module_lock);
04a479f7	669
f2a745c4 RY	670	if (ksp->ks_proc) {
f2a745c4 RY	671	remove_proc_entry(ksp->ks_name, module->ksm_proc);
04a479f7	672
f2a745c4 RY	673	/* Remove top level module directory if it's empty */
	674	if (list_empty(&module->ksm_kstat_list))
	675	kstat_delete_module(module);
04a479f7	676	}
	677
	678	if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
f2a745c4	679	kmem_free(ksp->ks_data, ksp->ks_data_size);
04a479f7	680
ffbf0e57 CP	681	ksp->ks_lock = NULL;
ffbf0e57 CP	682	mutex_destroy(&ksp->ks_private_lock);
04a479f7	683	kmem_free(ksp, sizeof(*ksp));
	684
	685	return;
	686	}
	687	EXPORT_SYMBOL(__kstat_delete);
	688
04a479f7	689	int
1114ae6a	690	spl_kstat_init(void)
04a479f7	691	{
b17edc10	692	SENTRY;
f2a745c4 RY	693	mutex_init(&kstat_module_lock, NULL, MUTEX_DEFAULT, NULL);
f2a745c4 RY	694	INIT_LIST_HEAD(&kstat_module_list);
04a479f7	695	kstat_id = 0;
b17edc10	696	SRETURN(0);
04a479f7	697	}
	698
	699	void
1114ae6a	700	spl_kstat_fini(void)
04a479f7	701	{
b17edc10	702	SENTRY;
f2a745c4 RY	703	ASSERT(list_empty(&kstat_module_list));
f2a745c4 RY	704	mutex_destroy(&kstat_module_lock);
b17edc10	705	SEXIT;
04a479f7	706	}
04a479f7	707