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