module/os/linux/spl/spl-kstat.c

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