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