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