drivers/scsi/snic/snic_debugfs.c

   1 /*
   2  * Copyright 2014 Cisco Systems, Inc.  All rights reserved.
   3  *
   4  * This program is free software; you may redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
   9  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  10  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  11  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  12  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  13  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  14  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  15  * SOFTWARE.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/errno.h>
  20 #include <linux/debugfs.h>
  21
  22 #include "snic.h"
  23
  24 /*
  25  * snic_debugfs_init - Initialize debugfs for snic debug logging
  26  *
  27  * Description:
  28  * When Debugfs is configured this routine sets up fnic debugfs
  29  * filesystem. If not already created. this routine will crate the
  30  * fnic directory and statistics directory for trace buffer and
  31  * stats logging
  32  */
  33
  34 int
  35 snic_debugfs_init(void)
  36 {
  37         int rc = -1;
  38         struct dentry *de = NULL;
  39
  40         de = debugfs_create_dir("snic", NULL);
  41         if (!de) {
  42                 SNIC_DBG("Cannot create debugfs root\n");
  43
  44                 return rc;
  45         }
  46         snic_glob->trc_root = de;
  47
  48         de = debugfs_create_dir("statistics", snic_glob->trc_root);
  49         if (!de) {
  50                 SNIC_DBG("Cannot create Statistics directory\n");
  51
  52                 return rc;
  53         }
  54         snic_glob->stats_root = de;
  55
  56         rc = 0;
  57
  58         return rc;
  59 } /* end of snic_debugfs_init */
  60
  61 /*
  62  * snic_debugfs_term - Tear down debugfs intrastructure
  63  *
  64  * Description:
  65  * When Debufs is configured this routine removes debugfs file system
  66  * elements that are specific to snic
  67  */
  68 void
  69 snic_debugfs_term(void)
  70 {
  71         debugfs_remove(snic_glob->stats_root);
  72         snic_glob->stats_root = NULL;
  73
  74         debugfs_remove(snic_glob->trc_root);
  75         snic_glob->trc_root = NULL;
  76 }
  77
  78 /*
  79  * snic_reset_stats_open - Open the reset_stats file
  80  */
  81 static int
  82 snic_reset_stats_open(struct inode *inode, struct file *filp)
  83 {
  84         SNIC_BUG_ON(!inode->i_private);
  85         filp->private_data = inode->i_private;
  86
  87         return 0;
  88 }
  89
  90 /*
  91  * snic_reset_stats_read - Read a reset_stats debugfs file
  92  * @filp: The file pointer to read from.
  93  * @ubuf: The buffer tocopy the data to.
  94  * @cnt: The number of bytes to read.
  95  * @ppos: The position in the file to start reading frm.
  96  *
  97  * Description:
  98  * This routine reads value of variable reset_stats
  99  * and stores into local @buf. It will start reading file @ppos and
 100  * copy up to @cnt of data to @ubuf from @buf.
 101  *
 102  * Returns:
 103  * This function returns the amount of data that was read.
 104  */
 105 static ssize_t
 106 snic_reset_stats_read(struct file *filp,
 107                       char __user *ubuf,
 108                       size_t cnt,
 109                       loff_t *ppos)
 110 {
 111         struct snic *snic = (struct snic *) filp->private_data;
 112         char buf[64];
 113         int len;
 114
 115         len = sprintf(buf, "%u\n", snic->reset_stats);
 116
 117         return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
 118 }
 119
 120 /*
 121  * snic_reset_stats_write - Write to reset_stats debugfs file
 122  * @filp: The file pointer to write from
 123  * @ubuf: The buffer to copy the data from.
 124  * @cnt: The number of bytes to write.
 125  * @ppos: The position in the file to start writing to.
 126  *
 127  * Description:
 128  * This routine writes data from user buffer @ubuf to buffer @buf and
 129  * resets cumulative stats of snic.
 130  *
 131  * Returns:
 132  * This function returns the amount of data that was written.
 133  */
 134 static ssize_t
 135 snic_reset_stats_write(struct file *filp,
 136                        const char __user *ubuf,
 137                        size_t cnt,
 138                        loff_t *ppos)
 139 {
 140         struct snic *snic = (struct snic *) filp->private_data;
 141         struct snic_stats *stats = &snic->s_stats;
 142         u64 *io_stats_p = (u64 *) &stats->io;
 143         u64 *fw_stats_p = (u64 *) &stats->fw;
 144         char buf[64];
 145         unsigned long val;
 146         int ret;
 147
 148         if (cnt >= sizeof(buf))
 149                 return -EINVAL;
 150
 151         if (copy_from_user(&buf, ubuf, cnt))
 152                 return -EFAULT;
 153
 154         buf[cnt] = '\0';
 155
 156         ret = kstrtoul(buf, 10, &val);
 157         if (ret < 0)
 158                 return ret;
 159
 160         snic->reset_stats = val;
 161
 162         if (snic->reset_stats) {
 163                 /* Skip variable is used to avoid descrepancies to Num IOs
 164                  * and IO Completions stats. Skip incrementing No IO Compls
 165                  * for pending active IOs after reset_stats
 166                  */
 167                 atomic64_set(&snic->io_cmpl_skip,
 168                              atomic64_read(&stats->io.active));
 169                 memset(&stats->abts, 0, sizeof(struct snic_abort_stats));
 170                 memset(&stats->reset, 0, sizeof(struct snic_reset_stats));
 171                 memset(&stats->misc, 0, sizeof(struct snic_misc_stats));
 172                 memset(io_stats_p+1,
 173                         0,
 174                         sizeof(struct snic_io_stats) - sizeof(u64));
 175                 memset(fw_stats_p+1,
 176                         0,
 177                         sizeof(struct snic_fw_stats) - sizeof(u64));
 178         }
 179
 180         (*ppos)++;
 181
 182         SNIC_HOST_INFO(snic->shost, "Reset Op: Driver statistics.\n");
 183
 184         return cnt;
 185 }
 186
 187 static int
 188 snic_reset_stats_release(struct inode *inode, struct file *filp)
 189 {
 190         filp->private_data = NULL;
 191
 192         return 0;
 193 }
 194
 195 /*
 196  * snic_stats_show - Formats and prints per host specific driver stats.
 197  */
 198 static int
 199 snic_stats_show(struct seq_file *sfp, void *data)
 200 {
 201         struct snic *snic = (struct snic *) sfp->private;
 202         struct snic_stats *stats = &snic->s_stats;
 203         struct timespec last_isr_tms, last_ack_tms;
 204         u64 maxio_tm;
 205         int i;
 206
 207         /* Dump IO Stats */
 208         seq_printf(sfp,
 209                    "------------------------------------------\n"
 210                    "\t\t IO Statistics\n"
 211                    "------------------------------------------\n");
 212
 213         maxio_tm = (u64) atomic64_read(&stats->io.max_time);
 214         seq_printf(sfp,
 215                    "Active IOs                  : %lld\n"
 216                    "Max Active IOs              : %lld\n"
 217                    "Total IOs                   : %lld\n"
 218                    "IOs Completed               : %lld\n"
 219                    "IOs Failed                  : %lld\n"
 220                    "IOs Not Found               : %lld\n"
 221                    "Memory Alloc Failures       : %lld\n"
 222                    "REQs Null                   : %lld\n"
 223                    "SCSI Cmd Pointers Null      : %lld\n"
 224                    "Max SGL for any IO          : %lld\n"
 225                    "Max IO Size                 : %lld Sectors\n"
 226                    "Max Queuing Time            : %lld\n"
 227                    "Max Completion Time         : %lld\n"
 228                    "Max IO Process Time(FW)     : %lld (%u msec)\n",
 229                    (u64) atomic64_read(&stats->io.active),
 230                    (u64) atomic64_read(&stats->io.max_active),
 231                    (u64) atomic64_read(&stats->io.num_ios),
 232                    (u64) atomic64_read(&stats->io.compl),
 233                    (u64) atomic64_read(&stats->io.fail),
 234                    (u64) atomic64_read(&stats->io.io_not_found),
 235                    (u64) atomic64_read(&stats->io.alloc_fail),
 236                    (u64) atomic64_read(&stats->io.req_null),
 237                    (u64) atomic64_read(&stats->io.sc_null),
 238                    (u64) atomic64_read(&stats->io.max_sgl),
 239                    (u64) atomic64_read(&stats->io.max_io_sz),
 240                    (u64) atomic64_read(&stats->io.max_qtime),
 241                    (u64) atomic64_read(&stats->io.max_cmpl_time),
 242                    maxio_tm,
 243                    jiffies_to_msecs(maxio_tm));
 244
 245         seq_puts(sfp, "\nSGL Counters\n");
 246
 247         for (i = 0; i < SNIC_MAX_SG_DESC_CNT; i++) {
 248                 seq_printf(sfp,
 249                            "%10lld ",
 250                            (u64) atomic64_read(&stats->io.sgl_cnt[i]));
 251
 252                 if ((i + 1) % 8 == 0)
 253                         seq_puts(sfp, "\n");
 254         }
 255
 256         /* Dump Abort Stats */
 257         seq_printf(sfp,
 258                    "\n-------------------------------------------\n"
 259                    "\t\t Abort Statistics\n"
 260                    "---------------------------------------------\n");
 261
 262         seq_printf(sfp,
 263                    "Aborts                      : %lld\n"
 264                    "Aborts Fail                 : %lld\n"
 265                    "Aborts Driver Timeout       : %lld\n"
 266                    "Abort FW Timeout            : %lld\n"
 267                    "Abort IO NOT Found          : %lld\n"
 268                    "Abort Queuing Failed        : %lld\n",
 269                    (u64) atomic64_read(&stats->abts.num),
 270                    (u64) atomic64_read(&stats->abts.fail),
 271                    (u64) atomic64_read(&stats->abts.drv_tmo),
 272                    (u64) atomic64_read(&stats->abts.fw_tmo),
 273                    (u64) atomic64_read(&stats->abts.io_not_found),
 274                    (u64) atomic64_read(&stats->abts.q_fail));
 275
 276         /* Dump Reset Stats */
 277         seq_printf(sfp,
 278                    "\n-------------------------------------------\n"
 279                    "\t\t Reset Statistics\n"
 280                    "---------------------------------------------\n");
 281
 282         seq_printf(sfp,
 283                    "HBA Resets                  : %lld\n"
 284                    "HBA Reset Cmpls             : %lld\n"
 285                    "HBA Reset Fail              : %lld\n",
 286                    (u64) atomic64_read(&stats->reset.hba_resets),
 287                    (u64) atomic64_read(&stats->reset.hba_reset_cmpl),
 288                    (u64) atomic64_read(&stats->reset.hba_reset_fail));
 289
 290         /* Dump Firmware Stats */
 291         seq_printf(sfp,
 292                    "\n-------------------------------------------\n"
 293                    "\t\t Firmware Statistics\n"
 294                    "---------------------------------------------\n");
 295
 296         seq_printf(sfp,
 297                 "Active FW Requests             : %lld\n"
 298                 "Max FW Requests                : %lld\n"
 299                 "FW Out Of Resource Errs        : %lld\n"
 300                 "FW IO Errors                   : %lld\n"
 301                 "FW SCSI Errors                 : %lld\n",
 302                 (u64) atomic64_read(&stats->fw.actv_reqs),
 303                 (u64) atomic64_read(&stats->fw.max_actv_reqs),
 304                 (u64) atomic64_read(&stats->fw.out_of_res),
 305                 (u64) atomic64_read(&stats->fw.io_errs),
 306                 (u64) atomic64_read(&stats->fw.scsi_errs));
 307
 308
 309         /* Dump Miscellenous Stats */
 310         seq_printf(sfp,
 311                    "\n---------------------------------------------\n"
 312                    "\t\t Other Statistics\n"
 313                    "\n---------------------------------------------\n");
 314
 315         jiffies_to_timespec(stats->misc.last_isr_time, &last_isr_tms);
 316         jiffies_to_timespec(stats->misc.last_ack_time, &last_ack_tms);
 317
 318         seq_printf(sfp,
 319                    "Last ISR Time               : %llu (%8lu.%8lu)\n"
 320                    "Last Ack Time               : %llu (%8lu.%8lu)\n"
 321                    "Ack ISRs                    : %llu\n"
 322                    "IO Cmpl ISRs                : %llu\n"
 323                    "Err Notify ISRs             : %llu\n"
 324                    "Max CQ Entries              : %lld\n"
 325                    "Data Count Mismatch         : %lld\n"
 326                    "IOs w/ Timeout Status       : %lld\n"
 327                    "IOs w/ Aborted Status       : %lld\n"
 328                    "IOs w/ SGL Invalid Stat     : %lld\n"
 329                    "WQ Desc Alloc Fail          : %lld\n"
 330                    "Queue Full                  : %lld\n"
 331                    "Queue Ramp Up               : %lld\n"
 332                    "Queue Ramp Down             : %lld\n"
 333                    "Queue Last Queue Depth      : %lld\n"
 334                    "Target Not Ready            : %lld\n",
 335                    (u64) stats->misc.last_isr_time,
 336                    last_isr_tms.tv_sec, last_isr_tms.tv_nsec,
 337                    (u64)stats->misc.last_ack_time,
 338                    last_ack_tms.tv_sec, last_ack_tms.tv_nsec,
 339                    (u64) atomic64_read(&stats->misc.ack_isr_cnt),
 340                    (u64) atomic64_read(&stats->misc.cmpl_isr_cnt),
 341                    (u64) atomic64_read(&stats->misc.errnotify_isr_cnt),
 342                    (u64) atomic64_read(&stats->misc.max_cq_ents),
 343                    (u64) atomic64_read(&stats->misc.data_cnt_mismat),
 344                    (u64) atomic64_read(&stats->misc.io_tmo),
 345                    (u64) atomic64_read(&stats->misc.io_aborted),
 346                    (u64) atomic64_read(&stats->misc.sgl_inval),
 347                    (u64) atomic64_read(&stats->misc.wq_alloc_fail),
 348                    (u64) atomic64_read(&stats->misc.qfull),
 349                    (u64) atomic64_read(&stats->misc.qsz_rampup),
 350                    (u64) atomic64_read(&stats->misc.qsz_rampdown),
 351                    (u64) atomic64_read(&stats->misc.last_qsz),
 352                    (u64) atomic64_read(&stats->misc.tgt_not_rdy));
 353
 354         return 0;
 355 }
 356
 357 /*
 358  * snic_stats_open - Open the stats file for specific host
 359  *
 360  * Description:
 361  * This routine opens a debugfs file stats of specific host
 362  */
 363 static int
 364 snic_stats_open(struct inode *inode, struct file *filp)
 365 {
 366         return single_open(filp, snic_stats_show, inode->i_private);
 367 }
 368
 369 static const struct file_operations snic_stats_fops = {
 370         .owner  = THIS_MODULE,
 371         .open   = snic_stats_open,
 372         .read   = seq_read,
 373         .llseek = seq_lseek,
 374         .release = single_release,
 375 };
 376
 377 static const struct file_operations snic_reset_stats_fops = {
 378         .owner = THIS_MODULE,
 379         .open = snic_reset_stats_open,
 380         .read = snic_reset_stats_read,
 381         .write = snic_reset_stats_write,
 382         .release = snic_reset_stats_release,
 383 };
 384
 385 /*
 386  * snic_stats_init - Initialize stats struct and create stats file
 387  * per snic
 388  *
 389  * Description:
 390  * When debugfs is cofigured this routine sets up the stats file per snic
 391  * It will create file stats and reset_stats under statistics/host# directory
 392  * to log per snic stats
 393  */
 394 int
 395 snic_stats_debugfs_init(struct snic *snic)
 396 {
 397         int rc = -1;
 398         char name[16];
 399         struct dentry *de = NULL;
 400
 401         snprintf(name, sizeof(name), "host%d", snic->shost->host_no);
 402         if (!snic_glob->stats_root) {
 403                 SNIC_DBG("snic_stats root doesn't exist\n");
 404
 405                 return rc;
 406         }
 407
 408         de = debugfs_create_dir(name, snic_glob->stats_root);
 409         if (!de) {
 410                 SNIC_DBG("Cannot create host directory\n");
 411
 412                 return rc;
 413         }
 414         snic->stats_host = de;
 415
 416         de = debugfs_create_file("stats",
 417                                 S_IFREG|S_IRUGO,
 418                                 snic->stats_host,
 419                                 snic,
 420                                 &snic_stats_fops);
 421         if (!de) {
 422                 SNIC_DBG("Cannot create host's stats file\n");
 423
 424                 return rc;
 425         }
 426         snic->stats_file = de;
 427
 428         de = debugfs_create_file("reset_stats",
 429                                 S_IFREG|S_IRUGO|S_IWUSR,
 430                                 snic->stats_host,
 431                                 snic,
 432                                 &snic_reset_stats_fops);
 433
 434         if (!de) {
 435                 SNIC_DBG("Cannot create host's reset_stats file\n");
 436
 437                 return rc;
 438         }
 439         snic->reset_stats_file = de;
 440         rc = 0;
 441
 442         return rc;
 443 } /* end of snic_stats_debugfs_init */
 444
 445 /*
 446  * snic_stats_debugfs_remove - Tear down debugfs infrastructure of stats
 447  *
 448  * Description:
 449  * When Debufs is configured this routine removes debugfs file system
 450  * elements that are specific to to snic stats
 451  */
 452 void
 453 snic_stats_debugfs_remove(struct snic *snic)
 454 {
 455         debugfs_remove(snic->stats_file);
 456         snic->stats_file = NULL;
 457
 458         debugfs_remove(snic->reset_stats_file);
 459         snic->reset_stats_file = NULL;
 460
 461         debugfs_remove(snic->stats_host);
 462         snic->stats_host = NULL;
 463 }
 464
 465 /* Trace Facility related API */
 466 static void *
 467 snic_trc_seq_start(struct seq_file *sfp, loff_t *pos)
 468 {
 469         return &snic_glob->trc;
 470 }
 471
 472 static void *
 473 snic_trc_seq_next(struct seq_file *sfp, void *data, loff_t *pos)
 474 {
 475         return NULL;
 476 }
 477
 478 static void
 479 snic_trc_seq_stop(struct seq_file *sfp, void *data)
 480 {
 481 }
 482
 483 #define SNIC_TRC_PBLEN  256
 484 static int
 485 snic_trc_seq_show(struct seq_file *sfp, void *data)
 486 {
 487         char buf[SNIC_TRC_PBLEN];
 488
 489         if (snic_get_trc_data(buf, SNIC_TRC_PBLEN) > 0)
 490                 seq_printf(sfp, "%s\n", buf);
 491
 492         return 0;
 493 }
 494
 495 static const struct seq_operations snic_trc_seq_ops = {
 496         .start  = snic_trc_seq_start,
 497         .next   = snic_trc_seq_next,
 498         .stop   = snic_trc_seq_stop,
 499         .show   = snic_trc_seq_show,
 500 };
 501
 502 static int
 503 snic_trc_open(struct inode *inode, struct file *filp)
 504 {
 505         return seq_open(filp, &snic_trc_seq_ops);
 506 }
 507
 508 static const struct file_operations snic_trc_fops = {
 509         .owner  = THIS_MODULE,
 510         .open   = snic_trc_open,
 511         .read   = seq_read,
 512         .llseek = seq_lseek,
 513         .release = seq_release,
 514 };
 515
 516 /*
 517  * snic_trc_debugfs_init : creates trace/tracing_enable files for trace
 518  * under debugfs
 519  */
 520 int
 521 snic_trc_debugfs_init(void)
 522 {
 523         struct dentry *de = NULL;
 524         int ret = -1;
 525
 526         if (!snic_glob->trc_root) {
 527                 SNIC_ERR("Debugfs root directory for snic doesn't exist.\n");
 528
 529                 return ret;
 530         }
 531
 532         de = debugfs_create_bool("tracing_enable",
 533                                  S_IFREG | S_IRUGO | S_IWUSR,
 534                                  snic_glob->trc_root,
 535                                  &snic_glob->trc.enable);
 536
 537         if (!de) {
 538                 SNIC_ERR("Can't create trace_enable file.\n");
 539
 540                 return ret;
 541         }
 542         snic_glob->trc.trc_enable = de;
 543
 544         de = debugfs_create_file("trace",
 545                                  S_IFREG | S_IRUGO | S_IWUSR,
 546                                  snic_glob->trc_root,
 547                                  NULL,
 548                                  &snic_trc_fops);
 549
 550         if (!de) {
 551                 SNIC_ERR("Cannot create trace file.\n");
 552
 553                 return ret;
 554         }
 555         snic_glob->trc.trc_file = de;
 556         ret = 0;
 557
 558         return ret;
 559 } /* end of snic_trc_debugfs_init */
 560
 561 /*
 562  * snic_trc_debugfs_term : cleans up the files created for trace under debugfs
 563  */
 564 void
 565 snic_trc_debugfs_term(void)
 566 {
 567         debugfs_remove(snic_glob->trc.trc_file);
 568         snic_glob->trc.trc_file = NULL;
 569
 570         debugfs_remove(snic_glob->trc.trc_enable);
 571         snic_glob->trc.trc_enable = NULL;
 572 }