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