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 static void *
 227 kstat_seq_data_addr(kstat_t *ksp, loff_t n)
 228 {
 229         void *rc = NULL;
 230         SENTRY;
 231
 232         switch (ksp->ks_type) {
 233                 case KSTAT_TYPE_RAW:
 234                         rc = ksp->ks_data;
 235                         break;
 236                 case KSTAT_TYPE_NAMED:
 237                         rc = ksp->ks_data + n * sizeof(kstat_named_t);
 238                         break;
 239                 case KSTAT_TYPE_INTR:
 240                         rc = ksp->ks_data + n * sizeof(kstat_intr_t);
 241                         break;
 242                 case KSTAT_TYPE_IO:
 243                         rc = ksp->ks_data + n * sizeof(kstat_io_t);
 244                         break;
 245                 case KSTAT_TYPE_TIMER:
 246                         rc = ksp->ks_data + n * sizeof(kstat_timer_t);
 247                         break;
 248                 default:
 249                         PANIC("Undefined kstat type %d\n", ksp->ks_type);
 250         }
 251
 252         SRETURN(rc);
 253 }
 254
 255 static void *
 256 kstat_seq_start(struct seq_file *f, loff_t *pos)
 257 {
 258         loff_t n = *pos;
 259         kstat_t *ksp = (kstat_t *)f->private;
 260         ASSERT(ksp->ks_magic == KS_MAGIC);
 261         SENTRY;
 262
 263         spin_lock(&ksp->ks_lock);
 264         ksp->ks_snaptime = gethrtime();
 265
 266         if (!n)
 267                 kstat_seq_show_headers(f);
 268
 269         if (n >= ksp->ks_ndata)
 270                 SRETURN(NULL);
 271
 272         SRETURN(kstat_seq_data_addr(ksp, n));
 273 }
 274
 275 static void *
 276 kstat_seq_next(struct seq_file *f, void *p, loff_t *pos)
 277 {
 278         kstat_t *ksp = (kstat_t *)f->private;
 279         ASSERT(ksp->ks_magic == KS_MAGIC);
 280         SENTRY;
 281
 282         ++*pos;
 283         if (*pos >= ksp->ks_ndata)
 284                 SRETURN(NULL);
 285
 286         SRETURN(kstat_seq_data_addr(ksp, *pos));
 287 }
 288
 289 static void
 290 kstat_seq_stop(struct seq_file *f, void *v)
 291 {
 292         kstat_t *ksp = (kstat_t *)f->private;
 293         ASSERT(ksp->ks_magic == KS_MAGIC);
 294
 295         spin_unlock(&ksp->ks_lock);
 296 }
 297
 298 static struct seq_operations kstat_seq_ops = {
 299         .show  = kstat_seq_show,
 300         .start = kstat_seq_start,
 301         .next  = kstat_seq_next,
 302         .stop  = kstat_seq_stop,
 303 };
 304
 305 static int
 306 proc_kstat_open(struct inode *inode, struct file *filp)
 307 {
 308         struct seq_file *f;
 309         int rc;
 310
 311         rc = seq_open(filp, &kstat_seq_ops);
 312         if (rc)
 313                 return rc;
 314
 315         f = filp->private_data;
 316         f->private = PDE(inode)->data;
 317
 318         return rc;
 319 }
 320
 321 static struct file_operations proc_kstat_operations = {
 322         .open           = proc_kstat_open,
 323         .read           = seq_read,
 324         .llseek         = seq_lseek,
 325         .release        = seq_release,
 326 };
 327
 328 kstat_t *
 329 __kstat_create(const char *ks_module, int ks_instance, const char *ks_name,
 330              const char *ks_class, uchar_t ks_type, uint_t ks_ndata,
 331              uchar_t ks_flags)
 332 {
 333         kstat_t *ksp;
 334
 335         ASSERT(ks_module);
 336         ASSERT(ks_instance == 0);
 337         ASSERT(ks_name);
 338         ASSERT(!(ks_flags & KSTAT_FLAG_UNSUPPORTED));
 339
 340         if ((ks_type == KSTAT_TYPE_INTR) || (ks_type == KSTAT_TYPE_IO))
 341                 ASSERT(ks_ndata == 1);
 342
 343         ksp = kmem_zalloc(sizeof(*ksp), KM_SLEEP);
 344         if (ksp == NULL)
 345                 return ksp;
 346
 347         spin_lock(&kstat_lock);
 348         ksp->ks_kid = kstat_id;
 349         kstat_id++;
 350         spin_unlock(&kstat_lock);
 351
 352         ksp->ks_magic = KS_MAGIC;
 353         spin_lock_init(&ksp->ks_lock);
 354         INIT_LIST_HEAD(&ksp->ks_list);
 355
 356         ksp->ks_crtime = gethrtime();
 357         ksp->ks_snaptime = ksp->ks_crtime;
 358         strncpy(ksp->ks_module, ks_module, KSTAT_STRLEN);
 359         ksp->ks_instance = ks_instance;
 360         strncpy(ksp->ks_name, ks_name, KSTAT_STRLEN);
 361         strncpy(ksp->ks_class, ks_class, KSTAT_STRLEN);
 362         ksp->ks_type = ks_type;
 363         ksp->ks_flags = ks_flags;
 364
 365         switch (ksp->ks_type) {
 366                 case KSTAT_TYPE_RAW:
 367                         ksp->ks_ndata = 1;
 368                         ksp->ks_data_size = ks_ndata;
 369                         break;
 370                 case KSTAT_TYPE_NAMED:
 371                         ksp->ks_ndata = ks_ndata;
 372                         ksp->ks_data_size = ks_ndata * sizeof(kstat_named_t);
 373                         break;
 374                 case KSTAT_TYPE_INTR:
 375                         ksp->ks_ndata = ks_ndata;
 376                         ksp->ks_data_size = ks_ndata * sizeof(kstat_intr_t);
 377                         break;
 378                 case KSTAT_TYPE_IO:
 379                         ksp->ks_ndata = ks_ndata;
 380                         ksp->ks_data_size = ks_ndata * sizeof(kstat_io_t);
 381                         break;
 382                 case KSTAT_TYPE_TIMER:
 383                         ksp->ks_ndata = ks_ndata;
 384                         ksp->ks_data_size = ks_ndata * sizeof(kstat_timer_t);
 385                         break;
 386                 default:
 387                         PANIC("Undefined kstat type %d\n", ksp->ks_type);
 388         }
 389
 390         if (ksp->ks_flags & KSTAT_FLAG_VIRTUAL) {
 391                 ksp->ks_data = NULL;
 392         } else {
 393                 ksp->ks_data = kmem_alloc(ksp->ks_data_size, KM_SLEEP);
 394                 if (ksp->ks_data == NULL) {
 395                         kmem_free(ksp, sizeof(*ksp));
 396                         ksp = NULL;
 397                 }
 398         }
 399
 400         return ksp;
 401 }
 402 EXPORT_SYMBOL(__kstat_create);
 403
 404 void
 405 __kstat_install(kstat_t *ksp)
 406 {
 407         struct proc_dir_entry *de_module, *de_name;
 408         kstat_t *tmp;
 409         int rc = 0;
 410         SENTRY;
 411
 412         spin_lock(&kstat_lock);
 413
 414         /* Item may only be added to the list once */
 415         list_for_each_entry(tmp, &kstat_list, ks_list) {
 416                 if (tmp == ksp) {
 417                         spin_unlock(&kstat_lock);
 418                         SGOTO(out, rc = -EEXIST);
 419                 }
 420         }
 421
 422         list_add_tail(&ksp->ks_list, &kstat_list);
 423         spin_unlock(&kstat_lock);
 424
 425         de_module = proc_dir_entry_find(proc_spl_kstat, ksp->ks_module);
 426         if (de_module == NULL) {
 427                 de_module = proc_mkdir(ksp->ks_module, proc_spl_kstat);
 428                 if (de_module == NULL)
 429                         SGOTO(out, rc = -EUNATCH);
 430         }
 431
 432         de_name = create_proc_entry(ksp->ks_name, 0444, de_module);
 433         if (de_name == NULL)
 434                 SGOTO(out, rc = -EUNATCH);
 435
 436         spin_lock(&ksp->ks_lock);
 437         ksp->ks_proc = de_name;
 438         de_name->proc_fops = &proc_kstat_operations;
 439         de_name->data = (void *)ksp;
 440         spin_unlock(&ksp->ks_lock);
 441 out:
 442         if (rc) {
 443                 spin_lock(&kstat_lock);
 444                 list_del_init(&ksp->ks_list);
 445                 spin_unlock(&kstat_lock);
 446         }
 447
 448         SEXIT;
 449 }
 450 EXPORT_SYMBOL(__kstat_install);
 451
 452 void
 453 __kstat_delete(kstat_t *ksp)
 454 {
 455         struct proc_dir_entry *de_module;
 456
 457         spin_lock(&kstat_lock);
 458         list_del_init(&ksp->ks_list);
 459         spin_unlock(&kstat_lock);
 460
 461         if (ksp->ks_proc) {
 462                 de_module = ksp->ks_proc->parent;
 463                 remove_proc_entry(ksp->ks_name, de_module);
 464
 465                 /* Remove top level module directory if it's empty */
 466                 if (proc_dir_entries(de_module) == 0)
 467                         remove_proc_entry(de_module->name, de_module->parent);
 468         }
 469
 470         if (!(ksp->ks_flags & KSTAT_FLAG_VIRTUAL))
 471                 kmem_free(ksp->ks_data, ksp->ks_data_size);
 472
 473         kmem_free(ksp, sizeof(*ksp));
 474
 475         return;
 476 }
 477 EXPORT_SYMBOL(__kstat_delete);
 478
 479 int
 480 spl_kstat_init(void)
 481 {
 482         SENTRY;
 483         spin_lock_init(&kstat_lock);
 484         INIT_LIST_HEAD(&kstat_list);
 485         kstat_id = 0;
 486         SRETURN(0);
 487 }
 488
 489 void
 490 spl_kstat_fini(void)
 491 {
 492         SENTRY;
 493         ASSERT(list_empty(&kstat_list));
 494         SEXIT;
 495 }
 496