[mirror_spl-debian.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 <sys/vmem.h>
#include <sys/cmn_err.h>

#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;
		/*
		 * NOTE - 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->rlentime, 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);
}

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

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

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

	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 (!(ksp->ks_flags & KSTAT_FLAG_NO_HEADERS) && !n &&
	    kstat_seq_show_headers(f))
		return (NULL);

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

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

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

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

static int
kstat_detect_collision(kstat_t *ksp)
{
	kstat_module_t *module;
	kstat_t *tmp;
	char *parent;
	char *cp;

	parent = kmem_asprintf("%s", ksp->ks_module);

	if ((cp = strrchr(parent, '/')) == NULL) {
		strfree(parent);
		return (0);
	}

	cp[0] = '\0';
	if ((module = kstat_find_module(parent)) != NULL) {
		list_for_each_entry(tmp, &module->ksm_kstat_list, ks_list) {
			if (strncmp(tmp->ks_name, cp+1, KSTAT_STRLEN) == 0) {
				strfree(parent);
				return (EEXIST);
			}
		}
	}

	strfree(parent);
	return (0);
}

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) {
		if (kstat_detect_collision(ksp) != 0) {
			cmn_err(CE_WARN, "kstat_create('%s', '%s'): namespace" \
			    " collision", ksp->ks_module, ksp->ks_name);
			goto out;
		}
		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));
}
EXPORT_SYMBOL(__kstat_delete);

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

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