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