linux/drivers/scsi/lpfc/lpfc_debugfs.c
<<
>>
Prefs
   1/*******************************************************************
   2 * This file is part of the Emulex Linux Device Driver for         *
   3 * Fibre Channel Host Bus Adapters.                                *
   4 * Copyright (C) 2017-2021 Broadcom. All Rights Reserved. The term *
   5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.  *
   6 * Copyright (C) 2007-2015 Emulex.  All rights reserved.           *
   7 * EMULEX and SLI are trademarks of Emulex.                        *
   8 * www.broadcom.com                                                *
   9 *                                                                 *
  10 * This program is free software; you can redistribute it and/or   *
  11 * modify it under the terms of version 2 of the GNU General       *
  12 * Public License as published by the Free Software Foundation.    *
  13 * This program is distributed in the hope that it will be useful. *
  14 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  15 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  16 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  17 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  18 * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  19 * more details, a copy of which can be found in the file COPYING  *
  20 * included with this package.                                     *
  21 *******************************************************************/
  22
  23#include <linux/blkdev.h>
  24#include <linux/delay.h>
  25#include <linux/module.h>
  26#include <linux/dma-mapping.h>
  27#include <linux/idr.h>
  28#include <linux/interrupt.h>
  29#include <linux/kthread.h>
  30#include <linux/slab.h>
  31#include <linux/pci.h>
  32#include <linux/spinlock.h>
  33#include <linux/ctype.h>
  34#include <linux/vmalloc.h>
  35
  36#include <scsi/scsi.h>
  37#include <scsi/scsi_device.h>
  38#include <scsi/scsi_host.h>
  39#include <scsi/scsi_transport_fc.h>
  40#include <scsi/fc/fc_fs.h>
  41
  42#include "lpfc_hw4.h"
  43#include "lpfc_hw.h"
  44#include "lpfc_sli.h"
  45#include "lpfc_sli4.h"
  46#include "lpfc_nl.h"
  47#include "lpfc_disc.h"
  48#include "lpfc.h"
  49#include "lpfc_scsi.h"
  50#include "lpfc_nvme.h"
  51#include "lpfc_logmsg.h"
  52#include "lpfc_crtn.h"
  53#include "lpfc_vport.h"
  54#include "lpfc_version.h"
  55#include "lpfc_compat.h"
  56#include "lpfc_debugfs.h"
  57#include "lpfc_bsg.h"
  58
  59#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
  60/*
  61 * debugfs interface
  62 *
  63 * To access this interface the user should:
  64 * # mount -t debugfs none /sys/kernel/debug
  65 *
  66 * The lpfc debugfs directory hierarchy is:
  67 * /sys/kernel/debug/lpfc/fnX/vportY
  68 * where X is the lpfc hba function unique_id
  69 * where Y is the vport VPI on that hba
  70 *
  71 * Debugging services available per vport:
  72 * discovery_trace
  73 * This is an ACSII readable file that contains a trace of the last
  74 * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
  75 * See lpfc_debugfs.h for different categories of  discovery events.
  76 * To enable the discovery trace, the following module parameters must be set:
  77 * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
  78 * lpfc_debugfs_max_disc_trc=X   Where X is the event trace depth for
  79 *                               EACH vport. X MUST also be a power of 2.
  80 * lpfc_debugfs_mask_disc_trc=Y  Where Y is an event mask as defined in
  81 *                               lpfc_debugfs.h .
  82 *
  83 * slow_ring_trace
  84 * This is an ACSII readable file that contains a trace of the last
  85 * lpfc_debugfs_max_slow_ring_trc events that happened on a specific HBA.
  86 * To enable the slow ring trace, the following module parameters must be set:
  87 * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
  88 * lpfc_debugfs_max_slow_ring_trc=X   Where X is the event trace depth for
  89 *                               the HBA. X MUST also be a power of 2.
  90 */
  91static int lpfc_debugfs_enable = 1;
  92module_param(lpfc_debugfs_enable, int, S_IRUGO);
  93MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
  94
  95/* This MUST be a power of 2 */
  96static int lpfc_debugfs_max_disc_trc;
  97module_param(lpfc_debugfs_max_disc_trc, int, S_IRUGO);
  98MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
  99        "Set debugfs discovery trace depth");
 100
 101/* This MUST be a power of 2 */
 102static int lpfc_debugfs_max_slow_ring_trc;
 103module_param(lpfc_debugfs_max_slow_ring_trc, int, S_IRUGO);
 104MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
 105        "Set debugfs slow ring trace depth");
 106
 107/* This MUST be a power of 2 */
 108static int lpfc_debugfs_max_nvmeio_trc;
 109module_param(lpfc_debugfs_max_nvmeio_trc, int, 0444);
 110MODULE_PARM_DESC(lpfc_debugfs_max_nvmeio_trc,
 111                 "Set debugfs NVME IO trace depth");
 112
 113static int lpfc_debugfs_mask_disc_trc;
 114module_param(lpfc_debugfs_mask_disc_trc, int, S_IRUGO);
 115MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
 116        "Set debugfs discovery trace mask");
 117
 118#include <linux/debugfs.h>
 119
 120static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
 121static unsigned long lpfc_debugfs_start_time = 0L;
 122
 123/* iDiag */
 124static struct lpfc_idiag idiag;
 125
 126/**
 127 * lpfc_debugfs_disc_trc_data - Dump discovery logging to a buffer
 128 * @vport: The vport to gather the log info from.
 129 * @buf: The buffer to dump log into.
 130 * @size: The maximum amount of data to process.
 131 *
 132 * Description:
 133 * This routine gathers the lpfc discovery debugfs data from the @vport and
 134 * dumps it to @buf up to @size number of bytes. It will start at the next entry
 135 * in the log and process the log until the end of the buffer. Then it will
 136 * gather from the beginning of the log and process until the current entry.
 137 *
 138 * Notes:
 139 * Discovery logging will be disabled while while this routine dumps the log.
 140 *
 141 * Return Value:
 142 * This routine returns the amount of bytes that were dumped into @buf and will
 143 * not exceed @size.
 144 **/
 145static int
 146lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
 147{
 148        int i, index, len, enable;
 149        uint32_t ms;
 150        struct lpfc_debugfs_trc *dtp;
 151        char *buffer;
 152
 153        buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
 154        if (!buffer)
 155                return 0;
 156
 157        enable = lpfc_debugfs_enable;
 158        lpfc_debugfs_enable = 0;
 159
 160        len = 0;
 161        index = (atomic_read(&vport->disc_trc_cnt) + 1) &
 162                (lpfc_debugfs_max_disc_trc - 1);
 163        for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
 164                dtp = vport->disc_trc + i;
 165                if (!dtp->fmt)
 166                        continue;
 167                ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 168                snprintf(buffer,
 169                        LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 170                        dtp->seq_cnt, ms, dtp->fmt);
 171                len +=  scnprintf(buf+len, size-len, buffer,
 172                        dtp->data1, dtp->data2, dtp->data3);
 173        }
 174        for (i = 0; i < index; i++) {
 175                dtp = vport->disc_trc + i;
 176                if (!dtp->fmt)
 177                        continue;
 178                ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 179                snprintf(buffer,
 180                        LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 181                        dtp->seq_cnt, ms, dtp->fmt);
 182                len +=  scnprintf(buf+len, size-len, buffer,
 183                        dtp->data1, dtp->data2, dtp->data3);
 184        }
 185
 186        lpfc_debugfs_enable = enable;
 187        kfree(buffer);
 188
 189        return len;
 190}
 191
 192/**
 193 * lpfc_debugfs_slow_ring_trc_data - Dump slow ring logging to a buffer
 194 * @phba: The HBA to gather the log info from.
 195 * @buf: The buffer to dump log into.
 196 * @size: The maximum amount of data to process.
 197 *
 198 * Description:
 199 * This routine gathers the lpfc slow ring debugfs data from the @phba and
 200 * dumps it to @buf up to @size number of bytes. It will start at the next entry
 201 * in the log and process the log until the end of the buffer. Then it will
 202 * gather from the beginning of the log and process until the current entry.
 203 *
 204 * Notes:
 205 * Slow ring logging will be disabled while while this routine dumps the log.
 206 *
 207 * Return Value:
 208 * This routine returns the amount of bytes that were dumped into @buf and will
 209 * not exceed @size.
 210 **/
 211static int
 212lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
 213{
 214        int i, index, len, enable;
 215        uint32_t ms;
 216        struct lpfc_debugfs_trc *dtp;
 217        char *buffer;
 218
 219        buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
 220        if (!buffer)
 221                return 0;
 222
 223        enable = lpfc_debugfs_enable;
 224        lpfc_debugfs_enable = 0;
 225
 226        len = 0;
 227        index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
 228                (lpfc_debugfs_max_slow_ring_trc - 1);
 229        for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
 230                dtp = phba->slow_ring_trc + i;
 231                if (!dtp->fmt)
 232                        continue;
 233                ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 234                snprintf(buffer,
 235                        LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 236                        dtp->seq_cnt, ms, dtp->fmt);
 237                len +=  scnprintf(buf+len, size-len, buffer,
 238                        dtp->data1, dtp->data2, dtp->data3);
 239        }
 240        for (i = 0; i < index; i++) {
 241                dtp = phba->slow_ring_trc + i;
 242                if (!dtp->fmt)
 243                        continue;
 244                ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 245                snprintf(buffer,
 246                        LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 247                        dtp->seq_cnt, ms, dtp->fmt);
 248                len +=  scnprintf(buf+len, size-len, buffer,
 249                        dtp->data1, dtp->data2, dtp->data3);
 250        }
 251
 252        lpfc_debugfs_enable = enable;
 253        kfree(buffer);
 254
 255        return len;
 256}
 257
 258static int lpfc_debugfs_last_hbq = -1;
 259
 260/**
 261 * lpfc_debugfs_hbqinfo_data - Dump host buffer queue info to a buffer
 262 * @phba: The HBA to gather host buffer info from.
 263 * @buf: The buffer to dump log into.
 264 * @size: The maximum amount of data to process.
 265 *
 266 * Description:
 267 * This routine dumps the host buffer queue info from the @phba to @buf up to
 268 * @size number of bytes. A header that describes the current hbq state will be
 269 * dumped to @buf first and then info on each hbq entry will be dumped to @buf
 270 * until @size bytes have been dumped or all the hbq info has been dumped.
 271 *
 272 * Notes:
 273 * This routine will rotate through each configured HBQ each time called.
 274 *
 275 * Return Value:
 276 * This routine returns the amount of bytes that were dumped into @buf and will
 277 * not exceed @size.
 278 **/
 279static int
 280lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
 281{
 282        int len = 0;
 283        int i, j, found, posted, low;
 284        uint32_t phys, raw_index, getidx;
 285        struct lpfc_hbq_init *hip;
 286        struct hbq_s *hbqs;
 287        struct lpfc_hbq_entry *hbqe;
 288        struct lpfc_dmabuf *d_buf;
 289        struct hbq_dmabuf *hbq_buf;
 290
 291        if (phba->sli_rev != 3)
 292                return 0;
 293
 294        spin_lock_irq(&phba->hbalock);
 295
 296        /* toggle between multiple hbqs, if any */
 297        i = lpfc_sli_hbq_count();
 298        if (i > 1) {
 299                 lpfc_debugfs_last_hbq++;
 300                 if (lpfc_debugfs_last_hbq >= i)
 301                        lpfc_debugfs_last_hbq = 0;
 302        }
 303        else
 304                lpfc_debugfs_last_hbq = 0;
 305
 306        i = lpfc_debugfs_last_hbq;
 307
 308        len +=  scnprintf(buf+len, size-len, "HBQ %d Info\n", i);
 309
 310        hbqs =  &phba->hbqs[i];
 311        posted = 0;
 312        list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list)
 313                posted++;
 314
 315        hip =  lpfc_hbq_defs[i];
 316        len +=  scnprintf(buf+len, size-len,
 317                "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
 318                hip->hbq_index, hip->profile, hip->rn,
 319                hip->buffer_count, hip->init_count, hip->add_count, posted);
 320
 321        raw_index = phba->hbq_get[i];
 322        getidx = le32_to_cpu(raw_index);
 323        len +=  scnprintf(buf+len, size-len,
 324                "entries:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
 325                hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx,
 326                hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx);
 327
 328        hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
 329        for (j=0; j<hbqs->entry_count; j++) {
 330                len +=  scnprintf(buf+len, size-len,
 331                        "%03d: %08x %04x %05x ", j,
 332                        le32_to_cpu(hbqe->bde.addrLow),
 333                        le32_to_cpu(hbqe->bde.tus.w),
 334                        le32_to_cpu(hbqe->buffer_tag));
 335                i = 0;
 336                found = 0;
 337
 338                /* First calculate if slot has an associated posted buffer */
 339                low = hbqs->hbqPutIdx - posted;
 340                if (low >= 0) {
 341                        if ((j >= hbqs->hbqPutIdx) || (j < low)) {
 342                                len +=  scnprintf(buf + len, size - len,
 343                                                "Unused\n");
 344                                goto skipit;
 345                        }
 346                }
 347                else {
 348                        if ((j >= hbqs->hbqPutIdx) &&
 349                                (j < (hbqs->entry_count+low))) {
 350                                len +=  scnprintf(buf + len, size - len,
 351                                                "Unused\n");
 352                                goto skipit;
 353                        }
 354                }
 355
 356                /* Get the Buffer info for the posted buffer */
 357                list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) {
 358                        hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
 359                        phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
 360                        if (phys == le32_to_cpu(hbqe->bde.addrLow)) {
 361                                len +=  scnprintf(buf+len, size-len,
 362                                        "Buf%d: x%px %06x\n", i,
 363                                        hbq_buf->dbuf.virt, hbq_buf->tag);
 364                                found = 1;
 365                                break;
 366                        }
 367                        i++;
 368                }
 369                if (!found) {
 370                        len +=  scnprintf(buf+len, size-len, "No DMAinfo?\n");
 371                }
 372skipit:
 373                hbqe++;
 374                if (len > LPFC_HBQINFO_SIZE - 54)
 375                        break;
 376        }
 377        spin_unlock_irq(&phba->hbalock);
 378        return len;
 379}
 380
 381static int lpfc_debugfs_last_xripool;
 382
 383/**
 384 * lpfc_debugfs_commonxripools_data - Dump Hardware Queue info to a buffer
 385 * @phba: The HBA to gather host buffer info from.
 386 * @buf: The buffer to dump log into.
 387 * @size: The maximum amount of data to process.
 388 *
 389 * Description:
 390 * This routine dumps the Hardware Queue info from the @phba to @buf up to
 391 * @size number of bytes. A header that describes the current hdwq state will be
 392 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
 393 * until @size bytes have been dumped or all the hdwq info has been dumped.
 394 *
 395 * Notes:
 396 * This routine will rotate through each configured Hardware Queue each
 397 * time called.
 398 *
 399 * Return Value:
 400 * This routine returns the amount of bytes that were dumped into @buf and will
 401 * not exceed @size.
 402 **/
 403static int
 404lpfc_debugfs_commonxripools_data(struct lpfc_hba *phba, char *buf, int size)
 405{
 406        struct lpfc_sli4_hdw_queue *qp;
 407        int len = 0;
 408        int i, out;
 409        unsigned long iflag;
 410
 411        for (i = 0; i < phba->cfg_hdw_queue; i++) {
 412                if (len > (LPFC_DUMP_MULTIXRIPOOL_SIZE - 80))
 413                        break;
 414                qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_xripool];
 415
 416                len += scnprintf(buf + len, size - len, "HdwQ %d Info ", i);
 417                spin_lock_irqsave(&qp->abts_io_buf_list_lock, iflag);
 418                spin_lock(&qp->io_buf_list_get_lock);
 419                spin_lock(&qp->io_buf_list_put_lock);
 420                out = qp->total_io_bufs - (qp->get_io_bufs + qp->put_io_bufs +
 421                        qp->abts_scsi_io_bufs + qp->abts_nvme_io_bufs);
 422                len += scnprintf(buf + len, size - len,
 423                                 "tot:%d get:%d put:%d mt:%d "
 424                                 "ABTS scsi:%d nvme:%d Out:%d\n",
 425                        qp->total_io_bufs, qp->get_io_bufs, qp->put_io_bufs,
 426                        qp->empty_io_bufs, qp->abts_scsi_io_bufs,
 427                        qp->abts_nvme_io_bufs, out);
 428                spin_unlock(&qp->io_buf_list_put_lock);
 429                spin_unlock(&qp->io_buf_list_get_lock);
 430                spin_unlock_irqrestore(&qp->abts_io_buf_list_lock, iflag);
 431
 432                lpfc_debugfs_last_xripool++;
 433                if (lpfc_debugfs_last_xripool >= phba->cfg_hdw_queue)
 434                        lpfc_debugfs_last_xripool = 0;
 435        }
 436
 437        return len;
 438}
 439
 440/**
 441 * lpfc_debugfs_multixripools_data - Display multi-XRI pools information
 442 * @phba: The HBA to gather host buffer info from.
 443 * @buf: The buffer to dump log into.
 444 * @size: The maximum amount of data to process.
 445 *
 446 * Description:
 447 * This routine displays current multi-XRI pools information including XRI
 448 * count in public, private and txcmplq. It also displays current high and
 449 * low watermark.
 450 *
 451 * Return Value:
 452 * This routine returns the amount of bytes that were dumped into @buf and will
 453 * not exceed @size.
 454 **/
 455static int
 456lpfc_debugfs_multixripools_data(struct lpfc_hba *phba, char *buf, int size)
 457{
 458        u32 i;
 459        u32 hwq_count;
 460        struct lpfc_sli4_hdw_queue *qp;
 461        struct lpfc_multixri_pool *multixri_pool;
 462        struct lpfc_pvt_pool *pvt_pool;
 463        struct lpfc_pbl_pool *pbl_pool;
 464        u32 txcmplq_cnt;
 465        char tmp[LPFC_DEBUG_OUT_LINE_SZ] = {0};
 466
 467        if (phba->sli_rev != LPFC_SLI_REV4)
 468                return 0;
 469
 470        if (!phba->sli4_hba.hdwq)
 471                return 0;
 472
 473        if (!phba->cfg_xri_rebalancing) {
 474                i = lpfc_debugfs_commonxripools_data(phba, buf, size);
 475                return i;
 476        }
 477
 478        /*
 479         * Pbl: Current number of free XRIs in public pool
 480         * Pvt: Current number of free XRIs in private pool
 481         * Busy: Current number of outstanding XRIs
 482         * HWM: Current high watermark
 483         * pvt_empty: Incremented by 1 when IO submission fails (no xri)
 484         * pbl_empty: Incremented by 1 when all pbl_pool are empty during
 485         *            IO submission
 486         */
 487        scnprintf(tmp, sizeof(tmp),
 488                  "HWQ:  Pbl  Pvt Busy  HWM |  pvt_empty  pbl_empty ");
 489        if (strlcat(buf, tmp, size) >= size)
 490                return strnlen(buf, size);
 491
 492#ifdef LPFC_MXP_STAT
 493        /*
 494         * MAXH: Max high watermark seen so far
 495         * above_lmt: Incremented by 1 if xri_owned > xri_limit during
 496         *            IO submission
 497         * below_lmt: Incremented by 1 if xri_owned <= xri_limit  during
 498         *            IO submission
 499         * locPbl_hit: Incremented by 1 if successfully get a batch of XRI from
 500         *             local pbl_pool
 501         * othPbl_hit: Incremented by 1 if successfully get a batch of XRI from
 502         *             other pbl_pool
 503         */
 504        scnprintf(tmp, sizeof(tmp),
 505                  "MAXH  above_lmt  below_lmt locPbl_hit othPbl_hit");
 506        if (strlcat(buf, tmp, size) >= size)
 507                return strnlen(buf, size);
 508
 509        /*
 510         * sPbl: snapshot of Pbl 15 sec after stat gets cleared
 511         * sPvt: snapshot of Pvt 15 sec after stat gets cleared
 512         * sBusy: snapshot of Busy 15 sec after stat gets cleared
 513         */
 514        scnprintf(tmp, sizeof(tmp),
 515                  " | sPbl sPvt sBusy");
 516        if (strlcat(buf, tmp, size) >= size)
 517                return strnlen(buf, size);
 518#endif
 519
 520        scnprintf(tmp, sizeof(tmp), "\n");
 521        if (strlcat(buf, tmp, size) >= size)
 522                return strnlen(buf, size);
 523
 524        hwq_count = phba->cfg_hdw_queue;
 525        for (i = 0; i < hwq_count; i++) {
 526                qp = &phba->sli4_hba.hdwq[i];
 527                multixri_pool = qp->p_multixri_pool;
 528                if (!multixri_pool)
 529                        continue;
 530                pbl_pool = &multixri_pool->pbl_pool;
 531                pvt_pool = &multixri_pool->pvt_pool;
 532                txcmplq_cnt = qp->io_wq->pring->txcmplq_cnt;
 533
 534                scnprintf(tmp, sizeof(tmp),
 535                          "%03d: %4d %4d %4d %4d | %10d %10d ",
 536                          i, pbl_pool->count, pvt_pool->count,
 537                          txcmplq_cnt, pvt_pool->high_watermark,
 538                          qp->empty_io_bufs, multixri_pool->pbl_empty_count);
 539                if (strlcat(buf, tmp, size) >= size)
 540                        break;
 541
 542#ifdef LPFC_MXP_STAT
 543                scnprintf(tmp, sizeof(tmp),
 544                          "%4d %10d %10d %10d %10d",
 545                          multixri_pool->stat_max_hwm,
 546                          multixri_pool->above_limit_count,
 547                          multixri_pool->below_limit_count,
 548                          multixri_pool->local_pbl_hit_count,
 549                          multixri_pool->other_pbl_hit_count);
 550                if (strlcat(buf, tmp, size) >= size)
 551                        break;
 552
 553                scnprintf(tmp, sizeof(tmp),
 554                          " | %4d %4d %5d",
 555                          multixri_pool->stat_pbl_count,
 556                          multixri_pool->stat_pvt_count,
 557                          multixri_pool->stat_busy_count);
 558                if (strlcat(buf, tmp, size) >= size)
 559                        break;
 560#endif
 561
 562                scnprintf(tmp, sizeof(tmp), "\n");
 563                if (strlcat(buf, tmp, size) >= size)
 564                        break;
 565        }
 566        return strnlen(buf, size);
 567}
 568
 569
 570#ifdef LPFC_HDWQ_LOCK_STAT
 571static int lpfc_debugfs_last_lock;
 572
 573/**
 574 * lpfc_debugfs_lockstat_data - Dump Hardware Queue info to a buffer
 575 * @phba: The HBA to gather host buffer info from.
 576 * @buf: The buffer to dump log into.
 577 * @size: The maximum amount of data to process.
 578 *
 579 * Description:
 580 * This routine dumps the Hardware Queue info from the @phba to @buf up to
 581 * @size number of bytes. A header that describes the current hdwq state will be
 582 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
 583 * until @size bytes have been dumped or all the hdwq info has been dumped.
 584 *
 585 * Notes:
 586 * This routine will rotate through each configured Hardware Queue each
 587 * time called.
 588 *
 589 * Return Value:
 590 * This routine returns the amount of bytes that were dumped into @buf and will
 591 * not exceed @size.
 592 **/
 593static int
 594lpfc_debugfs_lockstat_data(struct lpfc_hba *phba, char *buf, int size)
 595{
 596        struct lpfc_sli4_hdw_queue *qp;
 597        int len = 0;
 598        int i;
 599
 600        if (phba->sli_rev != LPFC_SLI_REV4)
 601                return 0;
 602
 603        if (!phba->sli4_hba.hdwq)
 604                return 0;
 605
 606        for (i = 0; i < phba->cfg_hdw_queue; i++) {
 607                if (len > (LPFC_HDWQINFO_SIZE - 100))
 608                        break;
 609                qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_lock];
 610
 611                len += scnprintf(buf + len, size - len, "HdwQ %03d Lock ", i);
 612                if (phba->cfg_xri_rebalancing) {
 613                        len += scnprintf(buf + len, size - len,
 614                                         "get_pvt:%d mv_pvt:%d "
 615                                         "mv2pub:%d mv2pvt:%d "
 616                                         "put_pvt:%d put_pub:%d wq:%d\n",
 617                                         qp->lock_conflict.alloc_pvt_pool,
 618                                         qp->lock_conflict.mv_from_pvt_pool,
 619                                         qp->lock_conflict.mv_to_pub_pool,
 620                                         qp->lock_conflict.mv_to_pvt_pool,
 621                                         qp->lock_conflict.free_pvt_pool,
 622                                         qp->lock_conflict.free_pub_pool,
 623                                         qp->lock_conflict.wq_access);
 624                } else {
 625                        len += scnprintf(buf + len, size - len,
 626                                         "get:%d put:%d free:%d wq:%d\n",
 627                                         qp->lock_conflict.alloc_xri_get,
 628                                         qp->lock_conflict.alloc_xri_put,
 629                                         qp->lock_conflict.free_xri,
 630                                         qp->lock_conflict.wq_access);
 631                }
 632
 633                lpfc_debugfs_last_lock++;
 634                if (lpfc_debugfs_last_lock >= phba->cfg_hdw_queue)
 635                        lpfc_debugfs_last_lock = 0;
 636        }
 637
 638        return len;
 639}
 640#endif
 641
 642static int lpfc_debugfs_last_hba_slim_off;
 643
 644/**
 645 * lpfc_debugfs_dumpHBASlim_data - Dump HBA SLIM info to a buffer
 646 * @phba: The HBA to gather SLIM info from.
 647 * @buf: The buffer to dump log into.
 648 * @size: The maximum amount of data to process.
 649 *
 650 * Description:
 651 * This routine dumps the current contents of HBA SLIM for the HBA associated
 652 * with @phba to @buf up to @size bytes of data. This is the raw HBA SLIM data.
 653 *
 654 * Notes:
 655 * This routine will only dump up to 1024 bytes of data each time called and
 656 * should be called multiple times to dump the entire HBA SLIM.
 657 *
 658 * Return Value:
 659 * This routine returns the amount of bytes that were dumped into @buf and will
 660 * not exceed @size.
 661 **/
 662static int
 663lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
 664{
 665        int len = 0;
 666        int i, off;
 667        uint32_t *ptr;
 668        char *buffer;
 669
 670        buffer = kmalloc(1024, GFP_KERNEL);
 671        if (!buffer)
 672                return 0;
 673
 674        off = 0;
 675        spin_lock_irq(&phba->hbalock);
 676
 677        len +=  scnprintf(buf+len, size-len, "HBA SLIM\n");
 678        lpfc_memcpy_from_slim(buffer,
 679                phba->MBslimaddr + lpfc_debugfs_last_hba_slim_off, 1024);
 680
 681        ptr = (uint32_t *)&buffer[0];
 682        off = lpfc_debugfs_last_hba_slim_off;
 683
 684        /* Set it up for the next time */
 685        lpfc_debugfs_last_hba_slim_off += 1024;
 686        if (lpfc_debugfs_last_hba_slim_off >= 4096)
 687                lpfc_debugfs_last_hba_slim_off = 0;
 688
 689        i = 1024;
 690        while (i > 0) {
 691                len +=  scnprintf(buf+len, size-len,
 692                "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
 693                off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
 694                *(ptr+5), *(ptr+6), *(ptr+7));
 695                ptr += 8;
 696                i -= (8 * sizeof(uint32_t));
 697                off += (8 * sizeof(uint32_t));
 698        }
 699
 700        spin_unlock_irq(&phba->hbalock);
 701        kfree(buffer);
 702
 703        return len;
 704}
 705
 706/**
 707 * lpfc_debugfs_dumpHostSlim_data - Dump host SLIM info to a buffer
 708 * @phba: The HBA to gather Host SLIM info from.
 709 * @buf: The buffer to dump log into.
 710 * @size: The maximum amount of data to process.
 711 *
 712 * Description:
 713 * This routine dumps the current contents of host SLIM for the host associated
 714 * with @phba to @buf up to @size bytes of data. The dump will contain the
 715 * Mailbox, PCB, Rings, and Registers that are located in host memory.
 716 *
 717 * Return Value:
 718 * This routine returns the amount of bytes that were dumped into @buf and will
 719 * not exceed @size.
 720 **/
 721static int
 722lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
 723{
 724        int len = 0;
 725        int i, off;
 726        uint32_t word0, word1, word2, word3;
 727        uint32_t *ptr;
 728        struct lpfc_pgp *pgpp;
 729        struct lpfc_sli *psli = &phba->sli;
 730        struct lpfc_sli_ring *pring;
 731
 732        off = 0;
 733        spin_lock_irq(&phba->hbalock);
 734
 735        len +=  scnprintf(buf+len, size-len, "SLIM Mailbox\n");
 736        ptr = (uint32_t *)phba->slim2p.virt;
 737        i = sizeof(MAILBOX_t);
 738        while (i > 0) {
 739                len +=  scnprintf(buf+len, size-len,
 740                "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
 741                off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
 742                *(ptr+5), *(ptr+6), *(ptr+7));
 743                ptr += 8;
 744                i -= (8 * sizeof(uint32_t));
 745                off += (8 * sizeof(uint32_t));
 746        }
 747
 748        len +=  scnprintf(buf+len, size-len, "SLIM PCB\n");
 749        ptr = (uint32_t *)phba->pcb;
 750        i = sizeof(PCB_t);
 751        while (i > 0) {
 752                len +=  scnprintf(buf+len, size-len,
 753                "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
 754                off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
 755                *(ptr+5), *(ptr+6), *(ptr+7));
 756                ptr += 8;
 757                i -= (8 * sizeof(uint32_t));
 758                off += (8 * sizeof(uint32_t));
 759        }
 760
 761        if (phba->sli_rev <= LPFC_SLI_REV3) {
 762                for (i = 0; i < 4; i++) {
 763                        pgpp = &phba->port_gp[i];
 764                        pring = &psli->sli3_ring[i];
 765                        len +=  scnprintf(buf+len, size-len,
 766                                         "Ring %d: CMD GetInx:%d "
 767                                         "(Max:%d Next:%d "
 768                                         "Local:%d flg:x%x)  "
 769                                         "RSP PutInx:%d Max:%d\n",
 770                                         i, pgpp->cmdGetInx,
 771                                         pring->sli.sli3.numCiocb,
 772                                         pring->sli.sli3.next_cmdidx,
 773                                         pring->sli.sli3.local_getidx,
 774                                         pring->flag, pgpp->rspPutInx,
 775                                         pring->sli.sli3.numRiocb);
 776                }
 777
 778                word0 = readl(phba->HAregaddr);
 779                word1 = readl(phba->CAregaddr);
 780                word2 = readl(phba->HSregaddr);
 781                word3 = readl(phba->HCregaddr);
 782                len +=  scnprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
 783                                 "HC:%08x\n", word0, word1, word2, word3);
 784        }
 785        spin_unlock_irq(&phba->hbalock);
 786        return len;
 787}
 788
 789/**
 790 * lpfc_debugfs_nodelist_data - Dump target node list to a buffer
 791 * @vport: The vport to gather target node info from.
 792 * @buf: The buffer to dump log into.
 793 * @size: The maximum amount of data to process.
 794 *
 795 * Description:
 796 * This routine dumps the current target node list associated with @vport to
 797 * @buf up to @size bytes of data. Each node entry in the dump will contain a
 798 * node state, DID, WWPN, WWNN, RPI, flags, type, and other useful fields.
 799 *
 800 * Return Value:
 801 * This routine returns the amount of bytes that were dumped into @buf and will
 802 * not exceed @size.
 803 **/
 804static int
 805lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
 806{
 807        int len = 0;
 808        int i, iocnt, outio, cnt;
 809        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 810        struct lpfc_hba  *phba = vport->phba;
 811        struct lpfc_nodelist *ndlp;
 812        unsigned char *statep;
 813        struct nvme_fc_local_port *localport;
 814        struct nvme_fc_remote_port *nrport = NULL;
 815        struct lpfc_nvme_rport *rport;
 816
 817        cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
 818        outio = 0;
 819
 820        len += scnprintf(buf+len, size-len, "\nFCP Nodelist Entries ...\n");
 821        spin_lock_irq(shost->host_lock);
 822        list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 823                iocnt = 0;
 824                if (!cnt) {
 825                        len +=  scnprintf(buf+len, size-len,
 826                                "Missing Nodelist Entries\n");
 827                        break;
 828                }
 829                cnt--;
 830                switch (ndlp->nlp_state) {
 831                case NLP_STE_UNUSED_NODE:
 832                        statep = "UNUSED";
 833                        break;
 834                case NLP_STE_PLOGI_ISSUE:
 835                        statep = "PLOGI ";
 836                        break;
 837                case NLP_STE_ADISC_ISSUE:
 838                        statep = "ADISC ";
 839                        break;
 840                case NLP_STE_REG_LOGIN_ISSUE:
 841                        statep = "REGLOG";
 842                        break;
 843                case NLP_STE_PRLI_ISSUE:
 844                        statep = "PRLI  ";
 845                        break;
 846                case NLP_STE_LOGO_ISSUE:
 847                        statep = "LOGO  ";
 848                        break;
 849                case NLP_STE_UNMAPPED_NODE:
 850                        statep = "UNMAP ";
 851                        iocnt = 1;
 852                        break;
 853                case NLP_STE_MAPPED_NODE:
 854                        statep = "MAPPED";
 855                        iocnt = 1;
 856                        break;
 857                case NLP_STE_NPR_NODE:
 858                        statep = "NPR   ";
 859                        break;
 860                default:
 861                        statep = "UNKNOWN";
 862                }
 863                len += scnprintf(buf+len, size-len, "%s DID:x%06x ",
 864                                statep, ndlp->nlp_DID);
 865                len += scnprintf(buf+len, size-len,
 866                                "WWPN x%016llx ",
 867                                wwn_to_u64(ndlp->nlp_portname.u.wwn));
 868                len += scnprintf(buf+len, size-len,
 869                                "WWNN x%016llx ",
 870                                wwn_to_u64(ndlp->nlp_nodename.u.wwn));
 871                len += scnprintf(buf+len, size-len, "RPI:x%04x ",
 872                                 ndlp->nlp_rpi);
 873                len +=  scnprintf(buf+len, size-len, "flag:x%08x ",
 874                        ndlp->nlp_flag);
 875                if (!ndlp->nlp_type)
 876                        len += scnprintf(buf+len, size-len, "UNKNOWN_TYPE ");
 877                if (ndlp->nlp_type & NLP_FC_NODE)
 878                        len += scnprintf(buf+len, size-len, "FC_NODE ");
 879                if (ndlp->nlp_type & NLP_FABRIC) {
 880                        len += scnprintf(buf+len, size-len, "FABRIC ");
 881                        iocnt = 0;
 882                }
 883                if (ndlp->nlp_type & NLP_FCP_TARGET)
 884                        len += scnprintf(buf+len, size-len, "FCP_TGT sid:%d ",
 885                                ndlp->nlp_sid);
 886                if (ndlp->nlp_type & NLP_FCP_INITIATOR)
 887                        len += scnprintf(buf+len, size-len, "FCP_INITIATOR ");
 888                if (ndlp->nlp_type & NLP_NVME_TARGET)
 889                        len += scnprintf(buf + len,
 890                                        size - len, "NVME_TGT sid:%d ",
 891                                        NLP_NO_SID);
 892                if (ndlp->nlp_type & NLP_NVME_INITIATOR)
 893                        len += scnprintf(buf + len,
 894                                        size - len, "NVME_INITIATOR ");
 895                len += scnprintf(buf+len, size-len, "refcnt:%d",
 896                        kref_read(&ndlp->kref));
 897                if (iocnt) {
 898                        i = atomic_read(&ndlp->cmd_pending);
 899                        len += scnprintf(buf + len, size - len,
 900                                        " OutIO:x%x Qdepth x%x",
 901                                        i, ndlp->cmd_qdepth);
 902                        outio += i;
 903                }
 904                len += scnprintf(buf+len, size-len, " xpt:x%x",
 905                                 ndlp->fc4_xpt_flags);
 906                if (ndlp->nlp_defer_did != NLP_EVT_NOTHING_PENDING)
 907                        len += scnprintf(buf+len, size-len, " defer:%x",
 908                                         ndlp->nlp_defer_did);
 909                len +=  scnprintf(buf+len, size-len, "\n");
 910        }
 911        spin_unlock_irq(shost->host_lock);
 912
 913        len += scnprintf(buf + len, size - len,
 914                        "\nOutstanding IO x%x\n",  outio);
 915
 916        if (phba->nvmet_support && phba->targetport && (vport == phba->pport)) {
 917                len += scnprintf(buf + len, size - len,
 918                                "\nNVME Targetport Entry ...\n");
 919
 920                /* Port state is only one of two values for now. */
 921                if (phba->targetport->port_id)
 922                        statep = "REGISTERED";
 923                else
 924                        statep = "INIT";
 925                len += scnprintf(buf + len, size - len,
 926                                "TGT WWNN x%llx WWPN x%llx State %s\n",
 927                                wwn_to_u64(vport->fc_nodename.u.wwn),
 928                                wwn_to_u64(vport->fc_portname.u.wwn),
 929                                statep);
 930                len += scnprintf(buf + len, size - len,
 931                                "    Targetport DID x%06x\n",
 932                                phba->targetport->port_id);
 933                goto out_exit;
 934        }
 935
 936        len += scnprintf(buf + len, size - len,
 937                                "\nNVME Lport/Rport Entries ...\n");
 938
 939        localport = vport->localport;
 940        if (!localport)
 941                goto out_exit;
 942
 943        spin_lock_irq(shost->host_lock);
 944
 945        /* Port state is only one of two values for now. */
 946        if (localport->port_id)
 947                statep = "ONLINE";
 948        else
 949                statep = "UNKNOWN ";
 950
 951        len += scnprintf(buf + len, size - len,
 952                        "Lport DID x%06x PortState %s\n",
 953                        localport->port_id, statep);
 954
 955        len += scnprintf(buf + len, size - len, "\tRport List:\n");
 956        list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 957                /* local short-hand pointer. */
 958                spin_lock(&ndlp->lock);
 959                rport = lpfc_ndlp_get_nrport(ndlp);
 960                if (rport)
 961                        nrport = rport->remoteport;
 962                else
 963                        nrport = NULL;
 964                spin_unlock(&ndlp->lock);
 965                if (!nrport)
 966                        continue;
 967
 968                /* Port state is only one of two values for now. */
 969                switch (nrport->port_state) {
 970                case FC_OBJSTATE_ONLINE:
 971                        statep = "ONLINE";
 972                        break;
 973                case FC_OBJSTATE_UNKNOWN:
 974                        statep = "UNKNOWN ";
 975                        break;
 976                default:
 977                        statep = "UNSUPPORTED";
 978                        break;
 979                }
 980
 981                /* Tab in to show lport ownership. */
 982                len += scnprintf(buf + len, size - len,
 983                                "\t%s Port ID:x%06x ",
 984                                statep, nrport->port_id);
 985                len += scnprintf(buf + len, size - len, "WWPN x%llx ",
 986                                nrport->port_name);
 987                len += scnprintf(buf + len, size - len, "WWNN x%llx ",
 988                                nrport->node_name);
 989
 990                /* An NVME rport can have multiple roles. */
 991                if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR)
 992                        len +=  scnprintf(buf + len, size - len,
 993                                         "INITIATOR ");
 994                if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET)
 995                        len +=  scnprintf(buf + len, size - len,
 996                                         "TARGET ");
 997                if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY)
 998                        len +=  scnprintf(buf + len, size - len,
 999                                         "DISCSRVC ");
1000                if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
1001                                          FC_PORT_ROLE_NVME_TARGET |
1002                                          FC_PORT_ROLE_NVME_DISCOVERY))
1003                        len +=  scnprintf(buf + len, size - len,
1004                                         "UNKNOWN ROLE x%x",
1005                                         nrport->port_role);
1006                /* Terminate the string. */
1007                len +=  scnprintf(buf + len, size - len, "\n");
1008        }
1009
1010        spin_unlock_irq(shost->host_lock);
1011 out_exit:
1012        return len;
1013}
1014
1015/**
1016 * lpfc_debugfs_nvmestat_data - Dump target node list to a buffer
1017 * @vport: The vport to gather target node info from.
1018 * @buf: The buffer to dump log into.
1019 * @size: The maximum amount of data to process.
1020 *
1021 * Description:
1022 * This routine dumps the NVME statistics associated with @vport
1023 *
1024 * Return Value:
1025 * This routine returns the amount of bytes that were dumped into @buf and will
1026 * not exceed @size.
1027 **/
1028static int
1029lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
1030{
1031        struct lpfc_hba   *phba = vport->phba;
1032        struct lpfc_nvmet_tgtport *tgtp;
1033        struct lpfc_async_xchg_ctx *ctxp, *next_ctxp;
1034        struct nvme_fc_local_port *localport;
1035        struct lpfc_fc4_ctrl_stat *cstat;
1036        struct lpfc_nvme_lport *lport;
1037        uint64_t data1, data2, data3;
1038        uint64_t tot, totin, totout;
1039        int cnt, i;
1040        int len = 0;
1041
1042        if (phba->nvmet_support) {
1043                if (!phba->targetport)
1044                        return len;
1045                tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
1046                len += scnprintf(buf + len, size - len,
1047                                "\nNVME Targetport Statistics\n");
1048
1049                len += scnprintf(buf + len, size - len,
1050                                "LS: Rcv %08x Drop %08x Abort %08x\n",
1051                                atomic_read(&tgtp->rcv_ls_req_in),
1052                                atomic_read(&tgtp->rcv_ls_req_drop),
1053                                atomic_read(&tgtp->xmt_ls_abort));
1054                if (atomic_read(&tgtp->rcv_ls_req_in) !=
1055                    atomic_read(&tgtp->rcv_ls_req_out)) {
1056                        len += scnprintf(buf + len, size - len,
1057                                        "Rcv LS: in %08x != out %08x\n",
1058                                        atomic_read(&tgtp->rcv_ls_req_in),
1059                                        atomic_read(&tgtp->rcv_ls_req_out));
1060                }
1061
1062                len += scnprintf(buf + len, size - len,
1063                                "LS: Xmt %08x Drop %08x Cmpl %08x\n",
1064                                atomic_read(&tgtp->xmt_ls_rsp),
1065                                atomic_read(&tgtp->xmt_ls_drop),
1066                                atomic_read(&tgtp->xmt_ls_rsp_cmpl));
1067
1068                len += scnprintf(buf + len, size - len,
1069                                "LS: RSP Abort %08x xb %08x Err %08x\n",
1070                                atomic_read(&tgtp->xmt_ls_rsp_aborted),
1071                                atomic_read(&tgtp->xmt_ls_rsp_xb_set),
1072                                atomic_read(&tgtp->xmt_ls_rsp_error));
1073
1074                len += scnprintf(buf + len, size - len,
1075                                "FCP: Rcv %08x Defer %08x Release %08x "
1076                                "Drop %08x\n",
1077                                atomic_read(&tgtp->rcv_fcp_cmd_in),
1078                                atomic_read(&tgtp->rcv_fcp_cmd_defer),
1079                                atomic_read(&tgtp->xmt_fcp_release),
1080                                atomic_read(&tgtp->rcv_fcp_cmd_drop));
1081
1082                if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
1083                    atomic_read(&tgtp->rcv_fcp_cmd_out)) {
1084                        len += scnprintf(buf + len, size - len,
1085                                        "Rcv FCP: in %08x != out %08x\n",
1086                                        atomic_read(&tgtp->rcv_fcp_cmd_in),
1087                                        atomic_read(&tgtp->rcv_fcp_cmd_out));
1088                }
1089
1090                len += scnprintf(buf + len, size - len,
1091                                "FCP Rsp: read %08x readrsp %08x "
1092                                "write %08x rsp %08x\n",
1093                                atomic_read(&tgtp->xmt_fcp_read),
1094                                atomic_read(&tgtp->xmt_fcp_read_rsp),
1095                                atomic_read(&tgtp->xmt_fcp_write),
1096                                atomic_read(&tgtp->xmt_fcp_rsp));
1097
1098                len += scnprintf(buf + len, size - len,
1099                                "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
1100                                atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
1101                                atomic_read(&tgtp->xmt_fcp_rsp_error),
1102                                atomic_read(&tgtp->xmt_fcp_rsp_drop));
1103
1104                len += scnprintf(buf + len, size - len,
1105                                "FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
1106                                atomic_read(&tgtp->xmt_fcp_rsp_aborted),
1107                                atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
1108                                atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
1109
1110                len += scnprintf(buf + len, size - len,
1111                                "ABORT: Xmt %08x Cmpl %08x\n",
1112                                atomic_read(&tgtp->xmt_fcp_abort),
1113                                atomic_read(&tgtp->xmt_fcp_abort_cmpl));
1114
1115                len += scnprintf(buf + len, size - len,
1116                                "ABORT: Sol %08x  Usol %08x Err %08x Cmpl %08x",
1117                                atomic_read(&tgtp->xmt_abort_sol),
1118                                atomic_read(&tgtp->xmt_abort_unsol),
1119                                atomic_read(&tgtp->xmt_abort_rsp),
1120                                atomic_read(&tgtp->xmt_abort_rsp_error));
1121
1122                len +=  scnprintf(buf + len, size - len, "\n");
1123
1124                cnt = 0;
1125                spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1126                list_for_each_entry_safe(ctxp, next_ctxp,
1127                                &phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
1128                                list) {
1129                        cnt++;
1130                }
1131                spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1132                if (cnt) {
1133                        len += scnprintf(buf + len, size - len,
1134                                        "ABORT: %d ctx entries\n", cnt);
1135                        spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1136                        list_for_each_entry_safe(ctxp, next_ctxp,
1137                                    &phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
1138                                    list) {
1139                                if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ))
1140                                        break;
1141                                len += scnprintf(buf + len, size - len,
1142                                                "Entry: oxid %x state %x "
1143                                                "flag %x\n",
1144                                                ctxp->oxid, ctxp->state,
1145                                                ctxp->flag);
1146                        }
1147                        spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1148                }
1149
1150                /* Calculate outstanding IOs */
1151                tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
1152                tot += atomic_read(&tgtp->xmt_fcp_release);
1153                tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
1154
1155                len += scnprintf(buf + len, size - len,
1156                                "IO_CTX: %08x  WAIT: cur %08x tot %08x\n"
1157                                "CTX Outstanding %08llx\n",
1158                                phba->sli4_hba.nvmet_xri_cnt,
1159                                phba->sli4_hba.nvmet_io_wait_cnt,
1160                                phba->sli4_hba.nvmet_io_wait_total,
1161                                tot);
1162        } else {
1163                if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
1164                        return len;
1165
1166                localport = vport->localport;
1167                if (!localport)
1168                        return len;
1169                lport = (struct lpfc_nvme_lport *)localport->private;
1170                if (!lport)
1171                        return len;
1172
1173                len += scnprintf(buf + len, size - len,
1174                                "\nNVME HDWQ Statistics\n");
1175
1176                len += scnprintf(buf + len, size - len,
1177                                "LS: Xmt %016x Cmpl %016x\n",
1178                                atomic_read(&lport->fc4NvmeLsRequests),
1179                                atomic_read(&lport->fc4NvmeLsCmpls));
1180
1181                totin = 0;
1182                totout = 0;
1183                for (i = 0; i < phba->cfg_hdw_queue; i++) {
1184                        cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
1185                        tot = cstat->io_cmpls;
1186                        totin += tot;
1187                        data1 = cstat->input_requests;
1188                        data2 = cstat->output_requests;
1189                        data3 = cstat->control_requests;
1190                        totout += (data1 + data2 + data3);
1191
1192                        /* Limit to 32, debugfs display buffer limitation */
1193                        if (i >= 32)
1194                                continue;
1195
1196                        len += scnprintf(buf + len, PAGE_SIZE - len,
1197                                        "HDWQ (%d): Rd %016llx Wr %016llx "
1198                                        "IO %016llx ",
1199                                        i, data1, data2, data3);
1200                        len += scnprintf(buf + len, PAGE_SIZE - len,
1201                                        "Cmpl %016llx OutIO %016llx\n",
1202                                        tot, ((data1 + data2 + data3) - tot));
1203                }
1204                len += scnprintf(buf + len, PAGE_SIZE - len,
1205                                "Total FCP Cmpl %016llx Issue %016llx "
1206                                "OutIO %016llx\n",
1207                                totin, totout, totout - totin);
1208
1209                len += scnprintf(buf + len, size - len,
1210                                "LS Xmt Err: Abrt %08x Err %08x  "
1211                                "Cmpl Err: xb %08x Err %08x\n",
1212                                atomic_read(&lport->xmt_ls_abort),
1213                                atomic_read(&lport->xmt_ls_err),
1214                                atomic_read(&lport->cmpl_ls_xb),
1215                                atomic_read(&lport->cmpl_ls_err));
1216
1217                len += scnprintf(buf + len, size - len,
1218                                "FCP Xmt Err: noxri %06x nondlp %06x "
1219                                "qdepth %06x wqerr %06x err %06x Abrt %06x\n",
1220                                atomic_read(&lport->xmt_fcp_noxri),
1221                                atomic_read(&lport->xmt_fcp_bad_ndlp),
1222                                atomic_read(&lport->xmt_fcp_qdepth),
1223                                atomic_read(&lport->xmt_fcp_wqerr),
1224                                atomic_read(&lport->xmt_fcp_err),
1225                                atomic_read(&lport->xmt_fcp_abort));
1226
1227                len += scnprintf(buf + len, size - len,
1228                                "FCP Cmpl Err: xb %08x Err %08x\n",
1229                                atomic_read(&lport->cmpl_fcp_xb),
1230                                atomic_read(&lport->cmpl_fcp_err));
1231
1232        }
1233
1234        return len;
1235}
1236
1237/**
1238 * lpfc_debugfs_scsistat_data - Dump target node list to a buffer
1239 * @vport: The vport to gather target node info from.
1240 * @buf: The buffer to dump log into.
1241 * @size: The maximum amount of data to process.
1242 *
1243 * Description:
1244 * This routine dumps the SCSI statistics associated with @vport
1245 *
1246 * Return Value:
1247 * This routine returns the amount of bytes that were dumped into @buf and will
1248 * not exceed @size.
1249 **/
1250static int
1251lpfc_debugfs_scsistat_data(struct lpfc_vport *vport, char *buf, int size)
1252{
1253        int len;
1254        struct lpfc_hba *phba = vport->phba;
1255        struct lpfc_fc4_ctrl_stat *cstat;
1256        u64 data1, data2, data3;
1257        u64 tot, totin, totout;
1258        int i;
1259        char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
1260
1261        if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
1262            (phba->sli_rev != LPFC_SLI_REV4))
1263                return 0;
1264
1265        scnprintf(buf, size, "SCSI HDWQ Statistics\n");
1266
1267        totin = 0;
1268        totout = 0;
1269        for (i = 0; i < phba->cfg_hdw_queue; i++) {
1270                cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
1271                tot = cstat->io_cmpls;
1272                totin += tot;
1273                data1 = cstat->input_requests;
1274                data2 = cstat->output_requests;
1275                data3 = cstat->control_requests;
1276                totout += (data1 + data2 + data3);
1277
1278                scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
1279                          "IO %016llx ", i, data1, data2, data3);
1280                if (strlcat(buf, tmp, size) >= size)
1281                        goto buffer_done;
1282
1283                scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
1284                          tot, ((data1 + data2 + data3) - tot));
1285                if (strlcat(buf, tmp, size) >= size)
1286                        goto buffer_done;
1287        }
1288        scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
1289                  "OutIO %016llx\n", totin, totout, totout - totin);
1290        strlcat(buf, tmp, size);
1291
1292buffer_done:
1293        len = strnlen(buf, size);
1294
1295        return len;
1296}
1297
1298void
1299lpfc_io_ktime(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
1300{
1301        uint64_t seg1, seg2, seg3, seg4;
1302        uint64_t segsum;
1303
1304        if (!lpfc_cmd->ts_last_cmd ||
1305            !lpfc_cmd->ts_cmd_start ||
1306            !lpfc_cmd->ts_cmd_wqput ||
1307            !lpfc_cmd->ts_isr_cmpl ||
1308            !lpfc_cmd->ts_data_io)
1309                return;
1310
1311        if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_cmd_start)
1312                return;
1313        if (lpfc_cmd->ts_cmd_start < lpfc_cmd->ts_last_cmd)
1314                return;
1315        if (lpfc_cmd->ts_cmd_wqput < lpfc_cmd->ts_cmd_start)
1316                return;
1317        if (lpfc_cmd->ts_isr_cmpl < lpfc_cmd->ts_cmd_wqput)
1318                return;
1319        if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_isr_cmpl)
1320                return;
1321        /*
1322         * Segment 1 - Time from Last FCP command cmpl is handed
1323         * off to NVME Layer to start of next command.
1324         * Segment 2 - Time from Driver receives a IO cmd start
1325         * from NVME Layer to WQ put is done on IO cmd.
1326         * Segment 3 - Time from Driver WQ put is done on IO cmd
1327         * to MSI-X ISR for IO cmpl.
1328         * Segment 4 - Time from MSI-X ISR for IO cmpl to when
1329         * cmpl is handled off to the NVME Layer.
1330         */
1331        seg1 = lpfc_cmd->ts_cmd_start - lpfc_cmd->ts_last_cmd;
1332        if (seg1 > 5000000)  /* 5 ms - for sequential IOs only */
1333                seg1 = 0;
1334
1335        /* Calculate times relative to start of IO */
1336        seg2 = (lpfc_cmd->ts_cmd_wqput - lpfc_cmd->ts_cmd_start);
1337        segsum = seg2;
1338        seg3 = lpfc_cmd->ts_isr_cmpl - lpfc_cmd->ts_cmd_start;
1339        if (segsum > seg3)
1340                return;
1341        seg3 -= segsum;
1342        segsum += seg3;
1343
1344        seg4 = lpfc_cmd->ts_data_io - lpfc_cmd->ts_cmd_start;
1345        if (segsum > seg4)
1346                return;
1347        seg4 -= segsum;
1348
1349        phba->ktime_data_samples++;
1350        phba->ktime_seg1_total += seg1;
1351        if (seg1 < phba->ktime_seg1_min)
1352                phba->ktime_seg1_min = seg1;
1353        else if (seg1 > phba->ktime_seg1_max)
1354                phba->ktime_seg1_max = seg1;
1355        phba->ktime_seg2_total += seg2;
1356        if (seg2 < phba->ktime_seg2_min)
1357                phba->ktime_seg2_min = seg2;
1358        else if (seg2 > phba->ktime_seg2_max)
1359                phba->ktime_seg2_max = seg2;
1360        phba->ktime_seg3_total += seg3;
1361        if (seg3 < phba->ktime_seg3_min)
1362                phba->ktime_seg3_min = seg3;
1363        else if (seg3 > phba->ktime_seg3_max)
1364                phba->ktime_seg3_max = seg3;
1365        phba->ktime_seg4_total += seg4;
1366        if (seg4 < phba->ktime_seg4_min)
1367                phba->ktime_seg4_min = seg4;
1368        else if (seg4 > phba->ktime_seg4_max)
1369                phba->ktime_seg4_max = seg4;
1370
1371        lpfc_cmd->ts_last_cmd = 0;
1372        lpfc_cmd->ts_cmd_start = 0;
1373        lpfc_cmd->ts_cmd_wqput  = 0;
1374        lpfc_cmd->ts_isr_cmpl = 0;
1375        lpfc_cmd->ts_data_io = 0;
1376}
1377
1378/**
1379 * lpfc_debugfs_ioktime_data - Dump target node list to a buffer
1380 * @vport: The vport to gather target node info from.
1381 * @buf: The buffer to dump log into.
1382 * @size: The maximum amount of data to process.
1383 *
1384 * Description:
1385 * This routine dumps the NVME statistics associated with @vport
1386 *
1387 * Return Value:
1388 * This routine returns the amount of bytes that were dumped into @buf and will
1389 * not exceed @size.
1390 **/
1391static int
1392lpfc_debugfs_ioktime_data(struct lpfc_vport *vport, char *buf, int size)
1393{
1394        struct lpfc_hba   *phba = vport->phba;
1395        int len = 0;
1396
1397        if (phba->nvmet_support == 0) {
1398                /* Initiator */
1399                len += scnprintf(buf + len, PAGE_SIZE - len,
1400                                "ktime %s: Total Samples: %lld\n",
1401                                (phba->ktime_on ?  "Enabled" : "Disabled"),
1402                                phba->ktime_data_samples);
1403                if (phba->ktime_data_samples == 0)
1404                        return len;
1405
1406                len += scnprintf(
1407                        buf + len, PAGE_SIZE - len,
1408                        "Segment 1: Last Cmd cmpl "
1409                        "done -to- Start of next Cmd (in driver)\n");
1410                len += scnprintf(
1411                        buf + len, PAGE_SIZE - len,
1412                        "avg:%08lld min:%08lld max %08lld\n",
1413                        div_u64(phba->ktime_seg1_total,
1414                                phba->ktime_data_samples),
1415                        phba->ktime_seg1_min,
1416                        phba->ktime_seg1_max);
1417                len += scnprintf(
1418                        buf + len, PAGE_SIZE - len,
1419                        "Segment 2: Driver start of Cmd "
1420                        "-to- Firmware WQ doorbell\n");
1421                len += scnprintf(
1422                        buf + len, PAGE_SIZE - len,
1423                        "avg:%08lld min:%08lld max %08lld\n",
1424                        div_u64(phba->ktime_seg2_total,
1425                                phba->ktime_data_samples),
1426                        phba->ktime_seg2_min,
1427                        phba->ktime_seg2_max);
1428                len += scnprintf(
1429                        buf + len, PAGE_SIZE - len,
1430                        "Segment 3: Firmware WQ doorbell -to- "
1431                        "MSI-X ISR cmpl\n");
1432                len += scnprintf(
1433                        buf + len, PAGE_SIZE - len,
1434                        "avg:%08lld min:%08lld max %08lld\n",
1435                        div_u64(phba->ktime_seg3_total,
1436                                phba->ktime_data_samples),
1437                        phba->ktime_seg3_min,
1438                        phba->ktime_seg3_max);
1439                len += scnprintf(
1440                        buf + len, PAGE_SIZE - len,
1441                        "Segment 4: MSI-X ISR cmpl -to- "
1442                        "Cmd cmpl done\n");
1443                len += scnprintf(
1444                        buf + len, PAGE_SIZE - len,
1445                        "avg:%08lld min:%08lld max %08lld\n",
1446                        div_u64(phba->ktime_seg4_total,
1447                                phba->ktime_data_samples),
1448                        phba->ktime_seg4_min,
1449                        phba->ktime_seg4_max);
1450                len += scnprintf(
1451                        buf + len, PAGE_SIZE - len,
1452                        "Total IO avg time: %08lld\n",
1453                        div_u64(phba->ktime_seg1_total +
1454                        phba->ktime_seg2_total  +
1455                        phba->ktime_seg3_total +
1456                        phba->ktime_seg4_total,
1457                        phba->ktime_data_samples));
1458                return len;
1459        }
1460
1461        /* NVME Target */
1462        len += scnprintf(buf + len, PAGE_SIZE-len,
1463                        "ktime %s: Total Samples: %lld %lld\n",
1464                        (phba->ktime_on ? "Enabled" : "Disabled"),
1465                        phba->ktime_data_samples,
1466                        phba->ktime_status_samples);
1467        if (phba->ktime_data_samples == 0)
1468                return len;
1469
1470        len += scnprintf(buf + len, PAGE_SIZE-len,
1471                        "Segment 1: MSI-X ISR Rcv cmd -to- "
1472                        "cmd pass to NVME Layer\n");
1473        len += scnprintf(buf + len, PAGE_SIZE-len,
1474                        "avg:%08lld min:%08lld max %08lld\n",
1475                        div_u64(phba->ktime_seg1_total,
1476                                phba->ktime_data_samples),
1477                        phba->ktime_seg1_min,
1478                        phba->ktime_seg1_max);
1479        len += scnprintf(buf + len, PAGE_SIZE-len,
1480                        "Segment 2: cmd pass to NVME Layer- "
1481                        "-to- Driver rcv cmd OP (action)\n");
1482        len += scnprintf(buf + len, PAGE_SIZE-len,
1483                        "avg:%08lld min:%08lld max %08lld\n",
1484                        div_u64(phba->ktime_seg2_total,
1485                                phba->ktime_data_samples),
1486                        phba->ktime_seg2_min,
1487                        phba->ktime_seg2_max);
1488        len += scnprintf(buf + len, PAGE_SIZE-len,
1489                        "Segment 3: Driver rcv cmd OP -to- "
1490                        "Firmware WQ doorbell: cmd\n");
1491        len += scnprintf(buf + len, PAGE_SIZE-len,
1492                        "avg:%08lld min:%08lld max %08lld\n",
1493                        div_u64(phba->ktime_seg3_total,
1494                                phba->ktime_data_samples),
1495                        phba->ktime_seg3_min,
1496                        phba->ktime_seg3_max);
1497        len += scnprintf(buf + len, PAGE_SIZE-len,
1498                        "Segment 4: Firmware WQ doorbell: cmd "
1499                        "-to- MSI-X ISR for cmd cmpl\n");
1500        len += scnprintf(buf + len, PAGE_SIZE-len,
1501                        "avg:%08lld min:%08lld max %08lld\n",
1502                        div_u64(phba->ktime_seg4_total,
1503                                phba->ktime_data_samples),
1504                        phba->ktime_seg4_min,
1505                        phba->ktime_seg4_max);
1506        len += scnprintf(buf + len, PAGE_SIZE-len,
1507                        "Segment 5: MSI-X ISR for cmd cmpl "
1508                        "-to- NVME layer passed cmd done\n");
1509        len += scnprintf(buf + len, PAGE_SIZE-len,
1510                        "avg:%08lld min:%08lld max %08lld\n",
1511                        div_u64(phba->ktime_seg5_total,
1512                                phba->ktime_data_samples),
1513                        phba->ktime_seg5_min,
1514                        phba->ktime_seg5_max);
1515
1516        if (phba->ktime_status_samples == 0) {
1517                len += scnprintf(buf + len, PAGE_SIZE-len,
1518                                "Total: cmd received by MSI-X ISR "
1519                                "-to- cmd completed on wire\n");
1520                len += scnprintf(buf + len, PAGE_SIZE-len,
1521                                "avg:%08lld min:%08lld "
1522                                "max %08lld\n",
1523                                div_u64(phba->ktime_seg10_total,
1524                                        phba->ktime_data_samples),
1525                                phba->ktime_seg10_min,
1526                                phba->ktime_seg10_max);
1527                return len;
1528        }
1529
1530        len += scnprintf(buf + len, PAGE_SIZE-len,
1531                        "Segment 6: NVME layer passed cmd done "
1532                        "-to- Driver rcv rsp status OP\n");
1533        len += scnprintf(buf + len, PAGE_SIZE-len,
1534                        "avg:%08lld min:%08lld max %08lld\n",
1535                        div_u64(phba->ktime_seg6_total,
1536                                phba->ktime_status_samples),
1537                        phba->ktime_seg6_min,
1538                        phba->ktime_seg6_max);
1539        len += scnprintf(buf + len, PAGE_SIZE-len,
1540                        "Segment 7: Driver rcv rsp status OP "
1541                        "-to- Firmware WQ doorbell: status\n");
1542        len += scnprintf(buf + len, PAGE_SIZE-len,
1543                        "avg:%08lld min:%08lld max %08lld\n",
1544                        div_u64(phba->ktime_seg7_total,
1545                                phba->ktime_status_samples),
1546                        phba->ktime_seg7_min,
1547                        phba->ktime_seg7_max);
1548        len += scnprintf(buf + len, PAGE_SIZE-len,
1549                        "Segment 8: Firmware WQ doorbell: status"
1550                        " -to- MSI-X ISR for status cmpl\n");
1551        len += scnprintf(buf + len, PAGE_SIZE-len,
1552                        "avg:%08lld min:%08lld max %08lld\n",
1553                        div_u64(phba->ktime_seg8_total,
1554                                phba->ktime_status_samples),
1555                        phba->ktime_seg8_min,
1556                        phba->ktime_seg8_max);
1557        len += scnprintf(buf + len, PAGE_SIZE-len,
1558                        "Segment 9: MSI-X ISR for status cmpl  "
1559                        "-to- NVME layer passed status done\n");
1560        len += scnprintf(buf + len, PAGE_SIZE-len,
1561                        "avg:%08lld min:%08lld max %08lld\n",
1562                        div_u64(phba->ktime_seg9_total,
1563                                phba->ktime_status_samples),
1564                        phba->ktime_seg9_min,
1565                        phba->ktime_seg9_max);
1566        len += scnprintf(buf + len, PAGE_SIZE-len,
1567                        "Total: cmd received by MSI-X ISR -to- "
1568                        "cmd completed on wire\n");
1569        len += scnprintf(buf + len, PAGE_SIZE-len,
1570                        "avg:%08lld min:%08lld max %08lld\n",
1571                        div_u64(phba->ktime_seg10_total,
1572                                phba->ktime_status_samples),
1573                        phba->ktime_seg10_min,
1574                        phba->ktime_seg10_max);
1575        return len;
1576}
1577
1578/**
1579 * lpfc_debugfs_nvmeio_trc_data - Dump NVME IO trace list to a buffer
1580 * @phba: The phba to gather target node info from.
1581 * @buf: The buffer to dump log into.
1582 * @size: The maximum amount of data to process.
1583 *
1584 * Description:
1585 * This routine dumps the NVME IO trace associated with @phba
1586 *
1587 * Return Value:
1588 * This routine returns the amount of bytes that were dumped into @buf and will
1589 * not exceed @size.
1590 **/
1591static int
1592lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
1593{
1594        struct lpfc_debugfs_nvmeio_trc *dtp;
1595        int i, state, index, skip;
1596        int len = 0;
1597
1598        state = phba->nvmeio_trc_on;
1599
1600        index = (atomic_read(&phba->nvmeio_trc_cnt) + 1) &
1601                (phba->nvmeio_trc_size - 1);
1602        skip = phba->nvmeio_trc_output_idx;
1603
1604        len += scnprintf(buf + len, size - len,
1605                        "%s IO Trace %s: next_idx %d skip %d size %d\n",
1606                        (phba->nvmet_support ? "NVME" : "NVMET"),
1607                        (state ? "Enabled" : "Disabled"),
1608                        index, skip, phba->nvmeio_trc_size);
1609
1610        if (!phba->nvmeio_trc || state)
1611                return len;
1612
1613        /* trace MUST bhe off to continue */
1614
1615        for (i = index; i < phba->nvmeio_trc_size; i++) {
1616                if (skip) {
1617                        skip--;
1618                        continue;
1619                }
1620                dtp = phba->nvmeio_trc + i;
1621                phba->nvmeio_trc_output_idx++;
1622
1623                if (!dtp->fmt)
1624                        continue;
1625
1626                len +=  scnprintf(buf + len, size - len, dtp->fmt,
1627                        dtp->data1, dtp->data2, dtp->data3);
1628
1629                if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
1630                        phba->nvmeio_trc_output_idx = 0;
1631                        len += scnprintf(buf + len, size - len,
1632                                        "Trace Complete\n");
1633                        goto out;
1634                }
1635
1636                if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
1637                        len += scnprintf(buf + len, size - len,
1638                                        "Trace Continue (%d of %d)\n",
1639                                        phba->nvmeio_trc_output_idx,
1640                                        phba->nvmeio_trc_size);
1641                        goto out;
1642                }
1643        }
1644        for (i = 0; i < index; i++) {
1645                if (skip) {
1646                        skip--;
1647                        continue;
1648                }
1649                dtp = phba->nvmeio_trc + i;
1650                phba->nvmeio_trc_output_idx++;
1651
1652                if (!dtp->fmt)
1653                        continue;
1654
1655                len +=  scnprintf(buf + len, size - len, dtp->fmt,
1656                        dtp->data1, dtp->data2, dtp->data3);
1657
1658                if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
1659                        phba->nvmeio_trc_output_idx = 0;
1660                        len += scnprintf(buf + len, size - len,
1661                                        "Trace Complete\n");
1662                        goto out;
1663                }
1664
1665                if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
1666                        len += scnprintf(buf + len, size - len,
1667                                        "Trace Continue (%d of %d)\n",
1668                                        phba->nvmeio_trc_output_idx,
1669                                        phba->nvmeio_trc_size);
1670                        goto out;
1671                }
1672        }
1673
1674        len += scnprintf(buf + len, size - len,
1675                        "Trace Done\n");
1676out:
1677        return len;
1678}
1679
1680/**
1681 * lpfc_debugfs_hdwqstat_data - Dump I/O stats to a buffer
1682 * @vport: The vport to gather target node info from.
1683 * @buf: The buffer to dump log into.
1684 * @size: The maximum amount of data to process.
1685 *
1686 * Description:
1687 * This routine dumps the NVME + SCSI statistics associated with @vport
1688 *
1689 * Return Value:
1690 * This routine returns the amount of bytes that were dumped into @buf and will
1691 * not exceed @size.
1692 **/
1693static int
1694lpfc_debugfs_hdwqstat_data(struct lpfc_vport *vport, char *buf, int size)
1695{
1696        struct lpfc_hba   *phba = vport->phba;
1697        struct lpfc_hdwq_stat *c_stat;
1698        int i, j, len;
1699        uint32_t tot_xmt;
1700        uint32_t tot_rcv;
1701        uint32_t tot_cmpl;
1702        char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
1703
1704        scnprintf(tmp, sizeof(tmp), "HDWQ Stats:\n\n");
1705        if (strlcat(buf, tmp, size) >= size)
1706                goto buffer_done;
1707
1708        scnprintf(tmp, sizeof(tmp), "(NVME Accounting: %s) ",
1709                  (phba->hdwqstat_on &
1710                  (LPFC_CHECK_NVME_IO | LPFC_CHECK_NVMET_IO) ?
1711                  "Enabled" : "Disabled"));
1712        if (strlcat(buf, tmp, size) >= size)
1713                goto buffer_done;
1714
1715        scnprintf(tmp, sizeof(tmp), "(SCSI Accounting: %s) ",
1716                  (phba->hdwqstat_on & LPFC_CHECK_SCSI_IO ?
1717                  "Enabled" : "Disabled"));
1718        if (strlcat(buf, tmp, size) >= size)
1719                goto buffer_done;
1720
1721        scnprintf(tmp, sizeof(tmp), "\n\n");
1722        if (strlcat(buf, tmp, size) >= size)
1723                goto buffer_done;
1724
1725        for (i = 0; i < phba->cfg_hdw_queue; i++) {
1726                tot_rcv = 0;
1727                tot_xmt = 0;
1728                tot_cmpl = 0;
1729
1730                for_each_present_cpu(j) {
1731                        c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, j);
1732
1733                        /* Only display for this HDWQ */
1734                        if (i != c_stat->hdwq_no)
1735                                continue;
1736
1737                        /* Only display non-zero counters */
1738                        if (!c_stat->xmt_io && !c_stat->cmpl_io &&
1739                            !c_stat->rcv_io)
1740                                continue;
1741
1742                        if (!tot_xmt && !tot_cmpl && !tot_rcv) {
1743                                /* Print HDWQ string only the first time */
1744                                scnprintf(tmp, sizeof(tmp), "[HDWQ %d]:\t", i);
1745                                if (strlcat(buf, tmp, size) >= size)
1746                                        goto buffer_done;
1747                        }
1748
1749                        tot_xmt += c_stat->xmt_io;
1750                        tot_cmpl += c_stat->cmpl_io;
1751                        if (phba->nvmet_support)
1752                                tot_rcv += c_stat->rcv_io;
1753
1754                        scnprintf(tmp, sizeof(tmp), "| [CPU %d]: ", j);
1755                        if (strlcat(buf, tmp, size) >= size)
1756                                goto buffer_done;
1757
1758                        if (phba->nvmet_support) {
1759                                scnprintf(tmp, sizeof(tmp),
1760                                          "XMT 0x%x CMPL 0x%x RCV 0x%x |",
1761                                          c_stat->xmt_io, c_stat->cmpl_io,
1762                                          c_stat->rcv_io);
1763                                if (strlcat(buf, tmp, size) >= size)
1764                                        goto buffer_done;
1765                        } else {
1766                                scnprintf(tmp, sizeof(tmp),
1767                                          "XMT 0x%x CMPL 0x%x |",
1768                                          c_stat->xmt_io, c_stat->cmpl_io);
1769                                if (strlcat(buf, tmp, size) >= size)
1770                                        goto buffer_done;
1771                        }
1772                }
1773
1774                /* Check if nothing to display */
1775                if (!tot_xmt && !tot_cmpl && !tot_rcv)
1776                        continue;
1777
1778                scnprintf(tmp, sizeof(tmp), "\t->\t[HDWQ Total: ");
1779                if (strlcat(buf, tmp, size) >= size)
1780                        goto buffer_done;
1781
1782                if (phba->nvmet_support) {
1783                        scnprintf(tmp, sizeof(tmp),
1784                                  "XMT 0x%x CMPL 0x%x RCV 0x%x]\n\n",
1785                                  tot_xmt, tot_cmpl, tot_rcv);
1786                        if (strlcat(buf, tmp, size) >= size)
1787                                goto buffer_done;
1788                } else {
1789                        scnprintf(tmp, sizeof(tmp),
1790                                  "XMT 0x%x CMPL 0x%x]\n\n",
1791                                  tot_xmt, tot_cmpl);
1792                        if (strlcat(buf, tmp, size) >= size)
1793                                goto buffer_done;
1794                }
1795        }
1796
1797buffer_done:
1798        len = strnlen(buf, size);
1799        return len;
1800}
1801
1802#endif
1803
1804/**
1805 * lpfc_debugfs_disc_trc - Store discovery trace log
1806 * @vport: The vport to associate this trace string with for retrieval.
1807 * @mask: Log entry classification.
1808 * @fmt: Format string to be displayed when dumping the log.
1809 * @data1: 1st data parameter to be applied to @fmt.
1810 * @data2: 2nd data parameter to be applied to @fmt.
1811 * @data3: 3rd data parameter to be applied to @fmt.
1812 *
1813 * Description:
1814 * This routine is used by the driver code to add a debugfs log entry to the
1815 * discovery trace buffer associated with @vport. Only entries with a @mask that
1816 * match the current debugfs discovery mask will be saved. Entries that do not
1817 * match will be thrown away. @fmt, @data1, @data2, and @data3 are used like
1818 * printf when displaying the log.
1819 **/
1820inline void
1821lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
1822        uint32_t data1, uint32_t data2, uint32_t data3)
1823{
1824#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1825        struct lpfc_debugfs_trc *dtp;
1826        int index;
1827
1828        if (!(lpfc_debugfs_mask_disc_trc & mask))
1829                return;
1830
1831        if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
1832                !vport || !vport->disc_trc)
1833                return;
1834
1835        index = atomic_inc_return(&vport->disc_trc_cnt) &
1836                (lpfc_debugfs_max_disc_trc - 1);
1837        dtp = vport->disc_trc + index;
1838        dtp->fmt = fmt;
1839        dtp->data1 = data1;
1840        dtp->data2 = data2;
1841        dtp->data3 = data3;
1842        dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
1843        dtp->jif = jiffies;
1844#endif
1845        return;
1846}
1847
1848/**
1849 * lpfc_debugfs_slow_ring_trc - Store slow ring trace log
1850 * @phba: The phba to associate this trace string with for retrieval.
1851 * @fmt: Format string to be displayed when dumping the log.
1852 * @data1: 1st data parameter to be applied to @fmt.
1853 * @data2: 2nd data parameter to be applied to @fmt.
1854 * @data3: 3rd data parameter to be applied to @fmt.
1855 *
1856 * Description:
1857 * This routine is used by the driver code to add a debugfs log entry to the
1858 * discovery trace buffer associated with @vport. @fmt, @data1, @data2, and
1859 * @data3 are used like printf when displaying the log.
1860 **/
1861inline void
1862lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
1863        uint32_t data1, uint32_t data2, uint32_t data3)
1864{
1865#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1866        struct lpfc_debugfs_trc *dtp;
1867        int index;
1868
1869        if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
1870                !phba || !phba->slow_ring_trc)
1871                return;
1872
1873        index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
1874                (lpfc_debugfs_max_slow_ring_trc - 1);
1875        dtp = phba->slow_ring_trc + index;
1876        dtp->fmt = fmt;
1877        dtp->data1 = data1;
1878        dtp->data2 = data2;
1879        dtp->data3 = data3;
1880        dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
1881        dtp->jif = jiffies;
1882#endif
1883        return;
1884}
1885
1886/**
1887 * lpfc_debugfs_nvme_trc - Store NVME/NVMET trace log
1888 * @phba: The phba to associate this trace string with for retrieval.
1889 * @fmt: Format string to be displayed when dumping the log.
1890 * @data1: 1st data parameter to be applied to @fmt.
1891 * @data2: 2nd data parameter to be applied to @fmt.
1892 * @data3: 3rd data parameter to be applied to @fmt.
1893 *
1894 * Description:
1895 * This routine is used by the driver code to add a debugfs log entry to the
1896 * nvme trace buffer associated with @phba. @fmt, @data1, @data2, and
1897 * @data3 are used like printf when displaying the log.
1898 **/
1899inline void
1900lpfc_debugfs_nvme_trc(struct lpfc_hba *phba, char *fmt,
1901                      uint16_t data1, uint16_t data2, uint32_t data3)
1902{
1903#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1904        struct lpfc_debugfs_nvmeio_trc *dtp;
1905        int index;
1906
1907        if (!phba->nvmeio_trc_on || !phba->nvmeio_trc)
1908                return;
1909
1910        index = atomic_inc_return(&phba->nvmeio_trc_cnt) &
1911                (phba->nvmeio_trc_size - 1);
1912        dtp = phba->nvmeio_trc + index;
1913        dtp->fmt = fmt;
1914        dtp->data1 = data1;
1915        dtp->data2 = data2;
1916        dtp->data3 = data3;
1917#endif
1918}
1919
1920#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1921/**
1922 * lpfc_debugfs_disc_trc_open - Open the discovery trace log
1923 * @inode: The inode pointer that contains a vport pointer.
1924 * @file: The file pointer to attach the log output.
1925 *
1926 * Description:
1927 * This routine is the entry point for the debugfs open file operation. It gets
1928 * the vport from the i_private field in @inode, allocates the necessary buffer
1929 * for the log, fills the buffer from the in-memory log for this vport, and then
1930 * returns a pointer to that log in the private_data field in @file.
1931 *
1932 * Returns:
1933 * This function returns zero if successful. On error it will return a negative
1934 * error value.
1935 **/
1936static int
1937lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
1938{
1939        struct lpfc_vport *vport = inode->i_private;
1940        struct lpfc_debug *debug;
1941        int size;
1942        int rc = -ENOMEM;
1943
1944        if (!lpfc_debugfs_max_disc_trc) {
1945                rc = -ENOSPC;
1946                goto out;
1947        }
1948
1949        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
1950        if (!debug)
1951                goto out;
1952
1953        /* Round to page boundary */
1954        size =  (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
1955        size = PAGE_ALIGN(size);
1956
1957        debug->buffer = kmalloc(size, GFP_KERNEL);
1958        if (!debug->buffer) {
1959                kfree(debug);
1960                goto out;
1961        }
1962
1963        debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
1964        file->private_data = debug;
1965
1966        rc = 0;
1967out:
1968        return rc;
1969}
1970
1971/**
1972 * lpfc_debugfs_slow_ring_trc_open - Open the Slow Ring trace log
1973 * @inode: The inode pointer that contains a vport pointer.
1974 * @file: The file pointer to attach the log output.
1975 *
1976 * Description:
1977 * This routine is the entry point for the debugfs open file operation. It gets
1978 * the vport from the i_private field in @inode, allocates the necessary buffer
1979 * for the log, fills the buffer from the in-memory log for this vport, and then
1980 * returns a pointer to that log in the private_data field in @file.
1981 *
1982 * Returns:
1983 * This function returns zero if successful. On error it will return a negative
1984 * error value.
1985 **/
1986static int
1987lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
1988{
1989        struct lpfc_hba *phba = inode->i_private;
1990        struct lpfc_debug *debug;
1991        int size;
1992        int rc = -ENOMEM;
1993
1994        if (!lpfc_debugfs_max_slow_ring_trc) {
1995                rc = -ENOSPC;
1996                goto out;
1997        }
1998
1999        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2000        if (!debug)
2001                goto out;
2002
2003        /* Round to page boundary */
2004        size =  (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
2005        size = PAGE_ALIGN(size);
2006
2007        debug->buffer = kmalloc(size, GFP_KERNEL);
2008        if (!debug->buffer) {
2009                kfree(debug);
2010                goto out;
2011        }
2012
2013        debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
2014        file->private_data = debug;
2015
2016        rc = 0;
2017out:
2018        return rc;
2019}
2020
2021/**
2022 * lpfc_debugfs_hbqinfo_open - Open the hbqinfo debugfs buffer
2023 * @inode: The inode pointer that contains a vport pointer.
2024 * @file: The file pointer to attach the log output.
2025 *
2026 * Description:
2027 * This routine is the entry point for the debugfs open file operation. It gets
2028 * the vport from the i_private field in @inode, allocates the necessary buffer
2029 * for the log, fills the buffer from the in-memory log for this vport, and then
2030 * returns a pointer to that log in the private_data field in @file.
2031 *
2032 * Returns:
2033 * This function returns zero if successful. On error it will return a negative
2034 * error value.
2035 **/
2036static int
2037lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
2038{
2039        struct lpfc_hba *phba = inode->i_private;
2040        struct lpfc_debug *debug;
2041        int rc = -ENOMEM;
2042
2043        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2044        if (!debug)
2045                goto out;
2046
2047        /* Round to page boundary */
2048        debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
2049        if (!debug->buffer) {
2050                kfree(debug);
2051                goto out;
2052        }
2053
2054        debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
2055                LPFC_HBQINFO_SIZE);
2056        file->private_data = debug;
2057
2058        rc = 0;
2059out:
2060        return rc;
2061}
2062
2063/**
2064 * lpfc_debugfs_multixripools_open - Open the multixripool debugfs buffer
2065 * @inode: The inode pointer that contains a hba pointer.
2066 * @file: The file pointer to attach the log output.
2067 *
2068 * Description:
2069 * This routine is the entry point for the debugfs open file operation. It gets
2070 * the hba from the i_private field in @inode, allocates the necessary buffer
2071 * for the log, fills the buffer from the in-memory log for this hba, and then
2072 * returns a pointer to that log in the private_data field in @file.
2073 *
2074 * Returns:
2075 * This function returns zero if successful. On error it will return a negative
2076 * error value.
2077 **/
2078static int
2079lpfc_debugfs_multixripools_open(struct inode *inode, struct file *file)
2080{
2081        struct lpfc_hba *phba = inode->i_private;
2082        struct lpfc_debug *debug;
2083        int rc = -ENOMEM;
2084
2085        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2086        if (!debug)
2087                goto out;
2088
2089        /* Round to page boundary */
2090        debug->buffer = kzalloc(LPFC_DUMP_MULTIXRIPOOL_SIZE, GFP_KERNEL);
2091        if (!debug->buffer) {
2092                kfree(debug);
2093                goto out;
2094        }
2095
2096        debug->len = lpfc_debugfs_multixripools_data(
2097                phba, debug->buffer, LPFC_DUMP_MULTIXRIPOOL_SIZE);
2098
2099        debug->i_private = inode->i_private;
2100        file->private_data = debug;
2101
2102        rc = 0;
2103out:
2104        return rc;
2105}
2106
2107#ifdef LPFC_HDWQ_LOCK_STAT
2108/**
2109 * lpfc_debugfs_lockstat_open - Open the lockstat debugfs buffer
2110 * @inode: The inode pointer that contains a vport pointer.
2111 * @file: The file pointer to attach the log output.
2112 *
2113 * Description:
2114 * This routine is the entry point for the debugfs open file operation. It gets
2115 * the vport from the i_private field in @inode, allocates the necessary buffer
2116 * for the log, fills the buffer from the in-memory log for this vport, and then
2117 * returns a pointer to that log in the private_data field in @file.
2118 *
2119 * Returns:
2120 * This function returns zero if successful. On error it will return a negative
2121 * error value.
2122 **/
2123static int
2124lpfc_debugfs_lockstat_open(struct inode *inode, struct file *file)
2125{
2126        struct lpfc_hba *phba = inode->i_private;
2127        struct lpfc_debug *debug;
2128        int rc = -ENOMEM;
2129
2130        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2131        if (!debug)
2132                goto out;
2133
2134        /* Round to page boundary */
2135        debug->buffer = kmalloc(LPFC_HDWQINFO_SIZE, GFP_KERNEL);
2136        if (!debug->buffer) {
2137                kfree(debug);
2138                goto out;
2139        }
2140
2141        debug->len = lpfc_debugfs_lockstat_data(phba, debug->buffer,
2142                LPFC_HBQINFO_SIZE);
2143        file->private_data = debug;
2144
2145        rc = 0;
2146out:
2147        return rc;
2148}
2149
2150static ssize_t
2151lpfc_debugfs_lockstat_write(struct file *file, const char __user *buf,
2152                            size_t nbytes, loff_t *ppos)
2153{
2154        struct lpfc_debug *debug = file->private_data;
2155        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2156        struct lpfc_sli4_hdw_queue *qp;
2157        char mybuf[64];
2158        char *pbuf;
2159        int i;
2160
2161        memset(mybuf, 0, sizeof(mybuf));
2162
2163        if (copy_from_user(mybuf, buf, nbytes))
2164                return -EFAULT;
2165        pbuf = &mybuf[0];
2166
2167        if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
2168            (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
2169                for (i = 0; i < phba->cfg_hdw_queue; i++) {
2170                        qp = &phba->sli4_hba.hdwq[i];
2171                        qp->lock_conflict.alloc_xri_get = 0;
2172                        qp->lock_conflict.alloc_xri_put = 0;
2173                        qp->lock_conflict.free_xri = 0;
2174                        qp->lock_conflict.wq_access = 0;
2175                        qp->lock_conflict.alloc_pvt_pool = 0;
2176                        qp->lock_conflict.mv_from_pvt_pool = 0;
2177                        qp->lock_conflict.mv_to_pub_pool = 0;
2178                        qp->lock_conflict.mv_to_pvt_pool = 0;
2179                        qp->lock_conflict.free_pvt_pool = 0;
2180                        qp->lock_conflict.free_pub_pool = 0;
2181                        qp->lock_conflict.wq_access = 0;
2182                }
2183        }
2184        return nbytes;
2185}
2186#endif
2187
2188static int lpfc_debugfs_ras_log_data(struct lpfc_hba *phba,
2189                                     char *buffer, int size)
2190{
2191        int copied = 0;
2192        struct lpfc_dmabuf *dmabuf, *next;
2193
2194        memset(buffer, 0, size);
2195
2196        spin_lock_irq(&phba->hbalock);
2197        if (phba->ras_fwlog.state != ACTIVE) {
2198                spin_unlock_irq(&phba->hbalock);
2199                return -EINVAL;
2200        }
2201        spin_unlock_irq(&phba->hbalock);
2202
2203        list_for_each_entry_safe(dmabuf, next,
2204                                 &phba->ras_fwlog.fwlog_buff_list, list) {
2205                /* Check if copying will go over size and a '\0' char */
2206                if ((copied + LPFC_RAS_MAX_ENTRY_SIZE) >= (size - 1)) {
2207                        memcpy(buffer + copied, dmabuf->virt,
2208                               size - copied - 1);
2209                        copied += size - copied - 1;
2210                        break;
2211                }
2212                memcpy(buffer + copied, dmabuf->virt, LPFC_RAS_MAX_ENTRY_SIZE);
2213                copied += LPFC_RAS_MAX_ENTRY_SIZE;
2214        }
2215        return copied;
2216}
2217
2218static int
2219lpfc_debugfs_ras_log_release(struct inode *inode, struct file *file)
2220{
2221        struct lpfc_debug *debug = file->private_data;
2222
2223        vfree(debug->buffer);
2224        kfree(debug);
2225
2226        return 0;
2227}
2228
2229/**
2230 * lpfc_debugfs_ras_log_open - Open the RAS log debugfs buffer
2231 * @inode: The inode pointer that contains a vport pointer.
2232 * @file: The file pointer to attach the log output.
2233 *
2234 * Description:
2235 * This routine is the entry point for the debugfs open file operation. It gets
2236 * the vport from the i_private field in @inode, allocates the necessary buffer
2237 * for the log, fills the buffer from the in-memory log for this vport, and then
2238 * returns a pointer to that log in the private_data field in @file.
2239 *
2240 * Returns:
2241 * This function returns zero if successful. On error it will return a negative
2242 * error value.
2243 **/
2244static int
2245lpfc_debugfs_ras_log_open(struct inode *inode, struct file *file)
2246{
2247        struct lpfc_hba *phba = inode->i_private;
2248        struct lpfc_debug *debug;
2249        int size;
2250        int rc = -ENOMEM;
2251
2252        spin_lock_irq(&phba->hbalock);
2253        if (phba->ras_fwlog.state != ACTIVE) {
2254                spin_unlock_irq(&phba->hbalock);
2255                rc = -EINVAL;
2256                goto out;
2257        }
2258        spin_unlock_irq(&phba->hbalock);
2259        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2260        if (!debug)
2261                goto out;
2262
2263        size = LPFC_RAS_MIN_BUFF_POST_SIZE * phba->cfg_ras_fwlog_buffsize;
2264        debug->buffer = vmalloc(size);
2265        if (!debug->buffer)
2266                goto free_debug;
2267
2268        debug->len = lpfc_debugfs_ras_log_data(phba, debug->buffer, size);
2269        if (debug->len < 0) {
2270                rc = -EINVAL;
2271                goto free_buffer;
2272        }
2273        file->private_data = debug;
2274
2275        return 0;
2276
2277free_buffer:
2278        vfree(debug->buffer);
2279free_debug:
2280        kfree(debug);
2281out:
2282        return rc;
2283}
2284
2285/**
2286 * lpfc_debugfs_dumpHBASlim_open - Open the Dump HBA SLIM debugfs buffer
2287 * @inode: The inode pointer that contains a vport pointer.
2288 * @file: The file pointer to attach the log output.
2289 *
2290 * Description:
2291 * This routine is the entry point for the debugfs open file operation. It gets
2292 * the vport from the i_private field in @inode, allocates the necessary buffer
2293 * for the log, fills the buffer from the in-memory log for this vport, and then
2294 * returns a pointer to that log in the private_data field in @file.
2295 *
2296 * Returns:
2297 * This function returns zero if successful. On error it will return a negative
2298 * error value.
2299 **/
2300static int
2301lpfc_debugfs_dumpHBASlim_open(struct inode *inode, struct file *file)
2302{
2303        struct lpfc_hba *phba = inode->i_private;
2304        struct lpfc_debug *debug;
2305        int rc = -ENOMEM;
2306
2307        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2308        if (!debug)
2309                goto out;
2310
2311        /* Round to page boundary */
2312        debug->buffer = kmalloc(LPFC_DUMPHBASLIM_SIZE, GFP_KERNEL);
2313        if (!debug->buffer) {
2314                kfree(debug);
2315                goto out;
2316        }
2317
2318        debug->len = lpfc_debugfs_dumpHBASlim_data(phba, debug->buffer,
2319                LPFC_DUMPHBASLIM_SIZE);
2320        file->private_data = debug;
2321
2322        rc = 0;
2323out:
2324        return rc;
2325}
2326
2327/**
2328 * lpfc_debugfs_dumpHostSlim_open - Open the Dump Host SLIM debugfs buffer
2329 * @inode: The inode pointer that contains a vport pointer.
2330 * @file: The file pointer to attach the log output.
2331 *
2332 * Description:
2333 * This routine is the entry point for the debugfs open file operation. It gets
2334 * the vport from the i_private field in @inode, allocates the necessary buffer
2335 * for the log, fills the buffer from the in-memory log for this vport, and then
2336 * returns a pointer to that log in the private_data field in @file.
2337 *
2338 * Returns:
2339 * This function returns zero if successful. On error it will return a negative
2340 * error value.
2341 **/
2342static int
2343lpfc_debugfs_dumpHostSlim_open(struct inode *inode, struct file *file)
2344{
2345        struct lpfc_hba *phba = inode->i_private;
2346        struct lpfc_debug *debug;
2347        int rc = -ENOMEM;
2348
2349        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2350        if (!debug)
2351                goto out;
2352
2353        /* Round to page boundary */
2354        debug->buffer = kmalloc(LPFC_DUMPHOSTSLIM_SIZE, GFP_KERNEL);
2355        if (!debug->buffer) {
2356                kfree(debug);
2357                goto out;
2358        }
2359
2360        debug->len = lpfc_debugfs_dumpHostSlim_data(phba, debug->buffer,
2361                LPFC_DUMPHOSTSLIM_SIZE);
2362        file->private_data = debug;
2363
2364        rc = 0;
2365out:
2366        return rc;
2367}
2368
2369static ssize_t
2370lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
2371        size_t nbytes, loff_t *ppos)
2372{
2373        struct dentry *dent = file->f_path.dentry;
2374        struct lpfc_hba *phba = file->private_data;
2375        char cbuf[32];
2376        uint64_t tmp = 0;
2377        int cnt = 0;
2378
2379        if (dent == phba->debug_writeGuard)
2380                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wgrd_cnt);
2381        else if (dent == phba->debug_writeApp)
2382                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wapp_cnt);
2383        else if (dent == phba->debug_writeRef)
2384                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wref_cnt);
2385        else if (dent == phba->debug_readGuard)
2386                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rgrd_cnt);
2387        else if (dent == phba->debug_readApp)
2388                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rapp_cnt);
2389        else if (dent == phba->debug_readRef)
2390                cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rref_cnt);
2391        else if (dent == phba->debug_InjErrNPortID)
2392                cnt = scnprintf(cbuf, 32, "0x%06x\n",
2393                                phba->lpfc_injerr_nportid);
2394        else if (dent == phba->debug_InjErrWWPN) {
2395                memcpy(&tmp, &phba->lpfc_injerr_wwpn, sizeof(struct lpfc_name));
2396                tmp = cpu_to_be64(tmp);
2397                cnt = scnprintf(cbuf, 32, "0x%016llx\n", tmp);
2398        } else if (dent == phba->debug_InjErrLBA) {
2399                if (phba->lpfc_injerr_lba == (sector_t)(-1))
2400                        cnt = scnprintf(cbuf, 32, "off\n");
2401                else
2402                        cnt = scnprintf(cbuf, 32, "0x%llx\n",
2403                                 (uint64_t) phba->lpfc_injerr_lba);
2404        } else
2405                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2406                         "0547 Unknown debugfs error injection entry\n");
2407
2408        return simple_read_from_buffer(buf, nbytes, ppos, &cbuf, cnt);
2409}
2410
2411static ssize_t
2412lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
2413        size_t nbytes, loff_t *ppos)
2414{
2415        struct dentry *dent = file->f_path.dentry;
2416        struct lpfc_hba *phba = file->private_data;
2417        char dstbuf[33];
2418        uint64_t tmp = 0;
2419        int size;
2420
2421        memset(dstbuf, 0, 33);
2422        size = (nbytes < 32) ? nbytes : 32;
2423        if (copy_from_user(dstbuf, buf, size))
2424                return -EFAULT;
2425
2426        if (dent == phba->debug_InjErrLBA) {
2427                if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&
2428                    (dstbuf[2] == 'f'))
2429                        tmp = (uint64_t)(-1);
2430        }
2431
2432        if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
2433                return -EINVAL;
2434
2435        if (dent == phba->debug_writeGuard)
2436                phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;
2437        else if (dent == phba->debug_writeApp)
2438                phba->lpfc_injerr_wapp_cnt = (uint32_t)tmp;
2439        else if (dent == phba->debug_writeRef)
2440                phba->lpfc_injerr_wref_cnt = (uint32_t)tmp;
2441        else if (dent == phba->debug_readGuard)
2442                phba->lpfc_injerr_rgrd_cnt = (uint32_t)tmp;
2443        else if (dent == phba->debug_readApp)
2444                phba->lpfc_injerr_rapp_cnt = (uint32_t)tmp;
2445        else if (dent == phba->debug_readRef)
2446                phba->lpfc_injerr_rref_cnt = (uint32_t)tmp;
2447        else if (dent == phba->debug_InjErrLBA)
2448                phba->lpfc_injerr_lba = (sector_t)tmp;
2449        else if (dent == phba->debug_InjErrNPortID)
2450                phba->lpfc_injerr_nportid = (uint32_t)(tmp & Mask_DID);
2451        else if (dent == phba->debug_InjErrWWPN) {
2452                tmp = cpu_to_be64(tmp);
2453                memcpy(&phba->lpfc_injerr_wwpn, &tmp, sizeof(struct lpfc_name));
2454        } else
2455                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2456                         "0548 Unknown debugfs error injection entry\n");
2457
2458        return nbytes;
2459}
2460
2461static int
2462lpfc_debugfs_dif_err_release(struct inode *inode, struct file *file)
2463{
2464        return 0;
2465}
2466
2467/**
2468 * lpfc_debugfs_nodelist_open - Open the nodelist debugfs file
2469 * @inode: The inode pointer that contains a vport pointer.
2470 * @file: The file pointer to attach the log output.
2471 *
2472 * Description:
2473 * This routine is the entry point for the debugfs open file operation. It gets
2474 * the vport from the i_private field in @inode, allocates the necessary buffer
2475 * for the log, fills the buffer from the in-memory log for this vport, and then
2476 * returns a pointer to that log in the private_data field in @file.
2477 *
2478 * Returns:
2479 * This function returns zero if successful. On error it will return a negative
2480 * error value.
2481 **/
2482static int
2483lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
2484{
2485        struct lpfc_vport *vport = inode->i_private;
2486        struct lpfc_debug *debug;
2487        int rc = -ENOMEM;
2488
2489        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2490        if (!debug)
2491                goto out;
2492
2493        /* Round to page boundary */
2494        debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
2495        if (!debug->buffer) {
2496                kfree(debug);
2497                goto out;
2498        }
2499
2500        debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
2501                LPFC_NODELIST_SIZE);
2502        file->private_data = debug;
2503
2504        rc = 0;
2505out:
2506        return rc;
2507}
2508
2509/**
2510 * lpfc_debugfs_lseek - Seek through a debugfs file
2511 * @file: The file pointer to seek through.
2512 * @off: The offset to seek to or the amount to seek by.
2513 * @whence: Indicates how to seek.
2514 *
2515 * Description:
2516 * This routine is the entry point for the debugfs lseek file operation. The
2517 * @whence parameter indicates whether @off is the offset to directly seek to,
2518 * or if it is a value to seek forward or reverse by. This function figures out
2519 * what the new offset of the debugfs file will be and assigns that value to the
2520 * f_pos field of @file.
2521 *
2522 * Returns:
2523 * This function returns the new offset if successful and returns a negative
2524 * error if unable to process the seek.
2525 **/
2526static loff_t
2527lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
2528{
2529        struct lpfc_debug *debug = file->private_data;
2530        return fixed_size_llseek(file, off, whence, debug->len);
2531}
2532
2533/**
2534 * lpfc_debugfs_read - Read a debugfs file
2535 * @file: The file pointer to read from.
2536 * @buf: The buffer to copy the data to.
2537 * @nbytes: The number of bytes to read.
2538 * @ppos: The position in the file to start reading from.
2539 *
2540 * Description:
2541 * This routine reads data from from the buffer indicated in the private_data
2542 * field of @file. It will start reading at @ppos and copy up to @nbytes of
2543 * data to @buf.
2544 *
2545 * Returns:
2546 * This function returns the amount of data that was read (this could be less
2547 * than @nbytes if the end of the file was reached) or a negative error value.
2548 **/
2549static ssize_t
2550lpfc_debugfs_read(struct file *file, char __user *buf,
2551                  size_t nbytes, loff_t *ppos)
2552{
2553        struct lpfc_debug *debug = file->private_data;
2554
2555        return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
2556                                       debug->len);
2557}
2558
2559/**
2560 * lpfc_debugfs_release - Release the buffer used to store debugfs file data
2561 * @inode: The inode pointer that contains a vport pointer. (unused)
2562 * @file: The file pointer that contains the buffer to release.
2563 *
2564 * Description:
2565 * This routine frees the buffer that was allocated when the debugfs file was
2566 * opened.
2567 *
2568 * Returns:
2569 * This function returns zero.
2570 **/
2571static int
2572lpfc_debugfs_release(struct inode *inode, struct file *file)
2573{
2574        struct lpfc_debug *debug = file->private_data;
2575
2576        kfree(debug->buffer);
2577        kfree(debug);
2578
2579        return 0;
2580}
2581
2582/**
2583 * lpfc_debugfs_multixripools_write - Clear multi-XRI pools statistics
2584 * @file: The file pointer to read from.
2585 * @buf: The buffer to copy the user data from.
2586 * @nbytes: The number of bytes to get.
2587 * @ppos: The position in the file to start reading from.
2588 *
2589 * Description:
2590 * This routine clears multi-XRI pools statistics when buf contains "clear".
2591 *
2592 * Return Value:
2593 * It returns the @nbytges passing in from debugfs user space when successful.
2594 * In case of error conditions, it returns proper error code back to the user
2595 * space.
2596 **/
2597static ssize_t
2598lpfc_debugfs_multixripools_write(struct file *file, const char __user *buf,
2599                                 size_t nbytes, loff_t *ppos)
2600{
2601        struct lpfc_debug *debug = file->private_data;
2602        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2603        char mybuf[64];
2604        char *pbuf;
2605        u32 i;
2606        u32 hwq_count;
2607        struct lpfc_sli4_hdw_queue *qp;
2608        struct lpfc_multixri_pool *multixri_pool;
2609
2610        if (nbytes > 64)
2611                nbytes = 64;
2612
2613        memset(mybuf, 0, sizeof(mybuf));
2614
2615        if (copy_from_user(mybuf, buf, nbytes))
2616                return -EFAULT;
2617        pbuf = &mybuf[0];
2618
2619        if ((strncmp(pbuf, "clear", strlen("clear"))) == 0) {
2620                hwq_count = phba->cfg_hdw_queue;
2621                for (i = 0; i < hwq_count; i++) {
2622                        qp = &phba->sli4_hba.hdwq[i];
2623                        multixri_pool = qp->p_multixri_pool;
2624                        if (!multixri_pool)
2625                                continue;
2626
2627                        qp->empty_io_bufs = 0;
2628                        multixri_pool->pbl_empty_count = 0;
2629#ifdef LPFC_MXP_STAT
2630                        multixri_pool->above_limit_count = 0;
2631                        multixri_pool->below_limit_count = 0;
2632                        multixri_pool->stat_max_hwm = 0;
2633                        multixri_pool->local_pbl_hit_count = 0;
2634                        multixri_pool->other_pbl_hit_count = 0;
2635
2636                        multixri_pool->stat_pbl_count = 0;
2637                        multixri_pool->stat_pvt_count = 0;
2638                        multixri_pool->stat_busy_count = 0;
2639                        multixri_pool->stat_snapshot_taken = 0;
2640#endif
2641                }
2642                return strlen(pbuf);
2643        }
2644
2645        return -EINVAL;
2646}
2647
2648static int
2649lpfc_debugfs_nvmestat_open(struct inode *inode, struct file *file)
2650{
2651        struct lpfc_vport *vport = inode->i_private;
2652        struct lpfc_debug *debug;
2653        int rc = -ENOMEM;
2654
2655        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2656        if (!debug)
2657                goto out;
2658
2659         /* Round to page boundary */
2660        debug->buffer = kmalloc(LPFC_NVMESTAT_SIZE, GFP_KERNEL);
2661        if (!debug->buffer) {
2662                kfree(debug);
2663                goto out;
2664        }
2665
2666        debug->len = lpfc_debugfs_nvmestat_data(vport, debug->buffer,
2667                LPFC_NVMESTAT_SIZE);
2668
2669        debug->i_private = inode->i_private;
2670        file->private_data = debug;
2671
2672        rc = 0;
2673out:
2674        return rc;
2675}
2676
2677static ssize_t
2678lpfc_debugfs_nvmestat_write(struct file *file, const char __user *buf,
2679                            size_t nbytes, loff_t *ppos)
2680{
2681        struct lpfc_debug *debug = file->private_data;
2682        struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2683        struct lpfc_hba   *phba = vport->phba;
2684        struct lpfc_nvmet_tgtport *tgtp;
2685        char mybuf[64];
2686        char *pbuf;
2687
2688        if (!phba->targetport)
2689                return -ENXIO;
2690
2691        if (nbytes > 64)
2692                nbytes = 64;
2693
2694        memset(mybuf, 0, sizeof(mybuf));
2695
2696        if (copy_from_user(mybuf, buf, nbytes))
2697                return -EFAULT;
2698        pbuf = &mybuf[0];
2699
2700        tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
2701        if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
2702            (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
2703                atomic_set(&tgtp->rcv_ls_req_in, 0);
2704                atomic_set(&tgtp->rcv_ls_req_out, 0);
2705                atomic_set(&tgtp->rcv_ls_req_drop, 0);
2706                atomic_set(&tgtp->xmt_ls_abort, 0);
2707                atomic_set(&tgtp->xmt_ls_abort_cmpl, 0);
2708                atomic_set(&tgtp->xmt_ls_rsp, 0);
2709                atomic_set(&tgtp->xmt_ls_drop, 0);
2710                atomic_set(&tgtp->xmt_ls_rsp_error, 0);
2711                atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0);
2712
2713                atomic_set(&tgtp->rcv_fcp_cmd_in, 0);
2714                atomic_set(&tgtp->rcv_fcp_cmd_out, 0);
2715                atomic_set(&tgtp->rcv_fcp_cmd_drop, 0);
2716                atomic_set(&tgtp->xmt_fcp_drop, 0);
2717                atomic_set(&tgtp->xmt_fcp_read_rsp, 0);
2718                atomic_set(&tgtp->xmt_fcp_read, 0);
2719                atomic_set(&tgtp->xmt_fcp_write, 0);
2720                atomic_set(&tgtp->xmt_fcp_rsp, 0);
2721                atomic_set(&tgtp->xmt_fcp_release, 0);
2722                atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0);
2723                atomic_set(&tgtp->xmt_fcp_rsp_error, 0);
2724                atomic_set(&tgtp->xmt_fcp_rsp_drop, 0);
2725
2726                atomic_set(&tgtp->xmt_fcp_abort, 0);
2727                atomic_set(&tgtp->xmt_fcp_abort_cmpl, 0);
2728                atomic_set(&tgtp->xmt_abort_sol, 0);
2729                atomic_set(&tgtp->xmt_abort_unsol, 0);
2730                atomic_set(&tgtp->xmt_abort_rsp, 0);
2731                atomic_set(&tgtp->xmt_abort_rsp_error, 0);
2732        }
2733        return nbytes;
2734}
2735
2736static int
2737lpfc_debugfs_scsistat_open(struct inode *inode, struct file *file)
2738{
2739        struct lpfc_vport *vport = inode->i_private;
2740        struct lpfc_debug *debug;
2741        int rc = -ENOMEM;
2742
2743        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2744        if (!debug)
2745                goto out;
2746
2747         /* Round to page boundary */
2748        debug->buffer = kzalloc(LPFC_SCSISTAT_SIZE, GFP_KERNEL);
2749        if (!debug->buffer) {
2750                kfree(debug);
2751                goto out;
2752        }
2753
2754        debug->len = lpfc_debugfs_scsistat_data(vport, debug->buffer,
2755                LPFC_SCSISTAT_SIZE);
2756
2757        debug->i_private = inode->i_private;
2758        file->private_data = debug;
2759
2760        rc = 0;
2761out:
2762        return rc;
2763}
2764
2765static ssize_t
2766lpfc_debugfs_scsistat_write(struct file *file, const char __user *buf,
2767                            size_t nbytes, loff_t *ppos)
2768{
2769        struct lpfc_debug *debug = file->private_data;
2770        struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2771        struct lpfc_hba *phba = vport->phba;
2772        char mybuf[6] = {0};
2773        int i;
2774
2775        if (copy_from_user(mybuf, buf, (nbytes >= sizeof(mybuf)) ?
2776                                       (sizeof(mybuf) - 1) : nbytes))
2777                return -EFAULT;
2778
2779        if ((strncmp(&mybuf[0], "reset", strlen("reset")) == 0) ||
2780            (strncmp(&mybuf[0], "zero", strlen("zero")) == 0)) {
2781                for (i = 0; i < phba->cfg_hdw_queue; i++) {
2782                        memset(&phba->sli4_hba.hdwq[i].scsi_cstat, 0,
2783                               sizeof(phba->sli4_hba.hdwq[i].scsi_cstat));
2784                }
2785        }
2786
2787        return nbytes;
2788}
2789
2790static int
2791lpfc_debugfs_ioktime_open(struct inode *inode, struct file *file)
2792{
2793        struct lpfc_vport *vport = inode->i_private;
2794        struct lpfc_debug *debug;
2795        int rc = -ENOMEM;
2796
2797        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2798        if (!debug)
2799                goto out;
2800
2801         /* Round to page boundary */
2802        debug->buffer = kmalloc(LPFC_IOKTIME_SIZE, GFP_KERNEL);
2803        if (!debug->buffer) {
2804                kfree(debug);
2805                goto out;
2806        }
2807
2808        debug->len = lpfc_debugfs_ioktime_data(vport, debug->buffer,
2809                LPFC_IOKTIME_SIZE);
2810
2811        debug->i_private = inode->i_private;
2812        file->private_data = debug;
2813
2814        rc = 0;
2815out:
2816        return rc;
2817}
2818
2819static ssize_t
2820lpfc_debugfs_ioktime_write(struct file *file, const char __user *buf,
2821                           size_t nbytes, loff_t *ppos)
2822{
2823        struct lpfc_debug *debug = file->private_data;
2824        struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2825        struct lpfc_hba   *phba = vport->phba;
2826        char mybuf[64];
2827        char *pbuf;
2828
2829        if (nbytes > 64)
2830                nbytes = 64;
2831
2832        memset(mybuf, 0, sizeof(mybuf));
2833
2834        if (copy_from_user(mybuf, buf, nbytes))
2835                return -EFAULT;
2836        pbuf = &mybuf[0];
2837
2838        if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
2839                phba->ktime_data_samples = 0;
2840                phba->ktime_status_samples = 0;
2841                phba->ktime_seg1_total = 0;
2842                phba->ktime_seg1_max = 0;
2843                phba->ktime_seg1_min = 0xffffffff;
2844                phba->ktime_seg2_total = 0;
2845                phba->ktime_seg2_max = 0;
2846                phba->ktime_seg2_min = 0xffffffff;
2847                phba->ktime_seg3_total = 0;
2848                phba->ktime_seg3_max = 0;
2849                phba->ktime_seg3_min = 0xffffffff;
2850                phba->ktime_seg4_total = 0;
2851                phba->ktime_seg4_max = 0;
2852                phba->ktime_seg4_min = 0xffffffff;
2853                phba->ktime_seg5_total = 0;
2854                phba->ktime_seg5_max = 0;
2855                phba->ktime_seg5_min = 0xffffffff;
2856                phba->ktime_seg6_total = 0;
2857                phba->ktime_seg6_max = 0;
2858                phba->ktime_seg6_min = 0xffffffff;
2859                phba->ktime_seg7_total = 0;
2860                phba->ktime_seg7_max = 0;
2861                phba->ktime_seg7_min = 0xffffffff;
2862                phba->ktime_seg8_total = 0;
2863                phba->ktime_seg8_max = 0;
2864                phba->ktime_seg8_min = 0xffffffff;
2865                phba->ktime_seg9_total = 0;
2866                phba->ktime_seg9_max = 0;
2867                phba->ktime_seg9_min = 0xffffffff;
2868                phba->ktime_seg10_total = 0;
2869                phba->ktime_seg10_max = 0;
2870                phba->ktime_seg10_min = 0xffffffff;
2871
2872                phba->ktime_on = 1;
2873                return strlen(pbuf);
2874        } else if ((strncmp(pbuf, "off",
2875                   sizeof("off") - 1) == 0)) {
2876                phba->ktime_on = 0;
2877                return strlen(pbuf);
2878        } else if ((strncmp(pbuf, "zero",
2879                   sizeof("zero") - 1) == 0)) {
2880                phba->ktime_data_samples = 0;
2881                phba->ktime_status_samples = 0;
2882                phba->ktime_seg1_total = 0;
2883                phba->ktime_seg1_max = 0;
2884                phba->ktime_seg1_min = 0xffffffff;
2885                phba->ktime_seg2_total = 0;
2886                phba->ktime_seg2_max = 0;
2887                phba->ktime_seg2_min = 0xffffffff;
2888                phba->ktime_seg3_total = 0;
2889                phba->ktime_seg3_max = 0;
2890                phba->ktime_seg3_min = 0xffffffff;
2891                phba->ktime_seg4_total = 0;
2892                phba->ktime_seg4_max = 0;
2893                phba->ktime_seg4_min = 0xffffffff;
2894                phba->ktime_seg5_total = 0;
2895                phba->ktime_seg5_max = 0;
2896                phba->ktime_seg5_min = 0xffffffff;
2897                phba->ktime_seg6_total = 0;
2898                phba->ktime_seg6_max = 0;
2899                phba->ktime_seg6_min = 0xffffffff;
2900                phba->ktime_seg7_total = 0;
2901                phba->ktime_seg7_max = 0;
2902                phba->ktime_seg7_min = 0xffffffff;
2903                phba->ktime_seg8_total = 0;
2904                phba->ktime_seg8_max = 0;
2905                phba->ktime_seg8_min = 0xffffffff;
2906                phba->ktime_seg9_total = 0;
2907                phba->ktime_seg9_max = 0;
2908                phba->ktime_seg9_min = 0xffffffff;
2909                phba->ktime_seg10_total = 0;
2910                phba->ktime_seg10_max = 0;
2911                phba->ktime_seg10_min = 0xffffffff;
2912                return strlen(pbuf);
2913        }
2914        return -EINVAL;
2915}
2916
2917static int
2918lpfc_debugfs_nvmeio_trc_open(struct inode *inode, struct file *file)
2919{
2920        struct lpfc_hba *phba = inode->i_private;
2921        struct lpfc_debug *debug;
2922        int rc = -ENOMEM;
2923
2924        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2925        if (!debug)
2926                goto out;
2927
2928         /* Round to page boundary */
2929        debug->buffer = kmalloc(LPFC_NVMEIO_TRC_SIZE, GFP_KERNEL);
2930        if (!debug->buffer) {
2931                kfree(debug);
2932                goto out;
2933        }
2934
2935        debug->len = lpfc_debugfs_nvmeio_trc_data(phba, debug->buffer,
2936                LPFC_NVMEIO_TRC_SIZE);
2937
2938        debug->i_private = inode->i_private;
2939        file->private_data = debug;
2940
2941        rc = 0;
2942out:
2943        return rc;
2944}
2945
2946static ssize_t
2947lpfc_debugfs_nvmeio_trc_write(struct file *file, const char __user *buf,
2948                              size_t nbytes, loff_t *ppos)
2949{
2950        struct lpfc_debug *debug = file->private_data;
2951        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2952        int i;
2953        unsigned long sz;
2954        char mybuf[64];
2955        char *pbuf;
2956
2957        if (nbytes > 64)
2958                nbytes = 64;
2959
2960        memset(mybuf, 0, sizeof(mybuf));
2961
2962        if (copy_from_user(mybuf, buf, nbytes))
2963                return -EFAULT;
2964        pbuf = &mybuf[0];
2965
2966        if ((strncmp(pbuf, "off", sizeof("off") - 1) == 0)) {
2967                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2968                                "0570 nvmeio_trc_off\n");
2969                phba->nvmeio_trc_output_idx = 0;
2970                phba->nvmeio_trc_on = 0;
2971                return strlen(pbuf);
2972        } else if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
2973                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2974                                "0571 nvmeio_trc_on\n");
2975                phba->nvmeio_trc_output_idx = 0;
2976                phba->nvmeio_trc_on = 1;
2977                return strlen(pbuf);
2978        }
2979
2980        /* We must be off to allocate the trace buffer */
2981        if (phba->nvmeio_trc_on != 0)
2982                return -EINVAL;
2983
2984        /* If not on or off, the parameter is the trace buffer size */
2985        i = kstrtoul(pbuf, 0, &sz);
2986        if (i)
2987                return -EINVAL;
2988        phba->nvmeio_trc_size = (uint32_t)sz;
2989
2990        /* It must be a power of 2 - round down */
2991        i = 0;
2992        while (sz > 1) {
2993                sz = sz >> 1;
2994                i++;
2995        }
2996        sz = (1 << i);
2997        if (phba->nvmeio_trc_size != sz)
2998                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2999                                "0572 nvmeio_trc_size changed to %ld\n",
3000                                sz);
3001        phba->nvmeio_trc_size = (uint32_t)sz;
3002
3003        /* If one previously exists, free it */
3004        kfree(phba->nvmeio_trc);
3005
3006        /* Allocate new trace buffer and initialize */
3007        phba->nvmeio_trc = kzalloc((sizeof(struct lpfc_debugfs_nvmeio_trc) *
3008                                    sz), GFP_KERNEL);
3009        if (!phba->nvmeio_trc) {
3010                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3011                                "0573 Cannot create debugfs "
3012                                "nvmeio_trc buffer\n");
3013                return -ENOMEM;
3014        }
3015        atomic_set(&phba->nvmeio_trc_cnt, 0);
3016        phba->nvmeio_trc_on = 0;
3017        phba->nvmeio_trc_output_idx = 0;
3018
3019        return strlen(pbuf);
3020}
3021
3022static int
3023lpfc_debugfs_hdwqstat_open(struct inode *inode, struct file *file)
3024{
3025        struct lpfc_vport *vport = inode->i_private;
3026        struct lpfc_debug *debug;
3027        int rc = -ENOMEM;
3028
3029        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
3030        if (!debug)
3031                goto out;
3032
3033         /* Round to page boundary */
3034        debug->buffer = kcalloc(1, LPFC_SCSISTAT_SIZE, GFP_KERNEL);
3035        if (!debug->buffer) {
3036                kfree(debug);
3037                goto out;
3038        }
3039
3040        debug->len = lpfc_debugfs_hdwqstat_data(vport, debug->buffer,
3041                                                LPFC_SCSISTAT_SIZE);
3042
3043        debug->i_private = inode->i_private;
3044        file->private_data = debug;
3045
3046        rc = 0;
3047out:
3048        return rc;
3049}
3050
3051static ssize_t
3052lpfc_debugfs_hdwqstat_write(struct file *file, const char __user *buf,
3053                            size_t nbytes, loff_t *ppos)
3054{
3055        struct lpfc_debug *debug = file->private_data;
3056        struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
3057        struct lpfc_hba   *phba = vport->phba;
3058        struct lpfc_hdwq_stat *c_stat;
3059        char mybuf[64];
3060        char *pbuf;
3061        int i;
3062
3063        if (nbytes > 64)
3064                nbytes = 64;
3065
3066        memset(mybuf, 0, sizeof(mybuf));
3067
3068        if (copy_from_user(mybuf, buf, nbytes))
3069                return -EFAULT;
3070        pbuf = &mybuf[0];
3071
3072        if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
3073                if (phba->nvmet_support)
3074                        phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
3075                else
3076                        phba->hdwqstat_on |= (LPFC_CHECK_NVME_IO |
3077                                LPFC_CHECK_SCSI_IO);
3078                return strlen(pbuf);
3079        } else if ((strncmp(pbuf, "nvme_on", sizeof("nvme_on") - 1) == 0)) {
3080                if (phba->nvmet_support)
3081                        phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
3082                else
3083                        phba->hdwqstat_on |= LPFC_CHECK_NVME_IO;
3084                return strlen(pbuf);
3085        } else if ((strncmp(pbuf, "scsi_on", sizeof("scsi_on") - 1) == 0)) {
3086                if (!phba->nvmet_support)
3087                        phba->hdwqstat_on |= LPFC_CHECK_SCSI_IO;
3088                return strlen(pbuf);
3089        } else if ((strncmp(pbuf, "nvme_off", sizeof("nvme_off") - 1) == 0)) {
3090                phba->hdwqstat_on &= ~(LPFC_CHECK_NVME_IO |
3091                                       LPFC_CHECK_NVMET_IO);
3092                return strlen(pbuf);
3093        } else if ((strncmp(pbuf, "scsi_off", sizeof("scsi_off") - 1) == 0)) {
3094                phba->hdwqstat_on &= ~LPFC_CHECK_SCSI_IO;
3095                return strlen(pbuf);
3096        } else if ((strncmp(pbuf, "off",
3097                   sizeof("off") - 1) == 0)) {
3098                phba->hdwqstat_on = LPFC_CHECK_OFF;
3099                return strlen(pbuf);
3100        } else if ((strncmp(pbuf, "zero",
3101                   sizeof("zero") - 1) == 0)) {
3102                for_each_present_cpu(i) {
3103                        c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, i);
3104                        c_stat->xmt_io = 0;
3105                        c_stat->cmpl_io = 0;
3106                        c_stat->rcv_io = 0;
3107                }
3108                return strlen(pbuf);
3109        }
3110        return -EINVAL;
3111}
3112
3113/*
3114 * ---------------------------------
3115 * iDiag debugfs file access methods
3116 * ---------------------------------
3117 *
3118 * All access methods are through the proper SLI4 PCI function's debugfs
3119 * iDiag directory:
3120 *
3121 *     /sys/kernel/debug/lpfc/fn<#>/iDiag
3122 */
3123
3124/**
3125 * lpfc_idiag_cmd_get - Get and parse idiag debugfs comands from user space
3126 * @buf: The pointer to the user space buffer.
3127 * @nbytes: The number of bytes in the user space buffer.
3128 * @idiag_cmd: pointer to the idiag command struct.
3129 *
3130 * This routine reads data from debugfs user space buffer and parses the
3131 * buffer for getting the idiag command and arguments. The while space in
3132 * between the set of data is used as the parsing separator.
3133 *
3134 * This routine returns 0 when successful, it returns proper error code
3135 * back to the user space in error conditions.
3136 */
3137static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes,
3138                              struct lpfc_idiag_cmd *idiag_cmd)
3139{
3140        char mybuf[64];
3141        char *pbuf, *step_str;
3142        int i;
3143        size_t bsize;
3144
3145        memset(mybuf, 0, sizeof(mybuf));
3146        memset(idiag_cmd, 0, sizeof(*idiag_cmd));
3147        bsize = min(nbytes, (sizeof(mybuf)-1));
3148
3149        if (copy_from_user(mybuf, buf, bsize))
3150                return -EFAULT;
3151        pbuf = &mybuf[0];
3152        step_str = strsep(&pbuf, "\t ");
3153
3154        /* The opcode must present */
3155        if (!step_str)
3156                return -EINVAL;
3157
3158        idiag_cmd->opcode = simple_strtol(step_str, NULL, 0);
3159        if (idiag_cmd->opcode == 0)
3160                return -EINVAL;
3161
3162        for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) {
3163                step_str = strsep(&pbuf, "\t ");
3164                if (!step_str)
3165                        return i;
3166                idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0);
3167        }
3168        return i;
3169}
3170
3171/**
3172 * lpfc_idiag_open - idiag open debugfs
3173 * @inode: The inode pointer that contains a pointer to phba.
3174 * @file: The file pointer to attach the file operation.
3175 *
3176 * Description:
3177 * This routine is the entry point for the debugfs open file operation. It
3178 * gets the reference to phba from the i_private field in @inode, it then
3179 * allocates buffer for the file operation, performs the necessary PCI config
3180 * space read into the allocated buffer according to the idiag user command
3181 * setup, and then returns a pointer to buffer in the private_data field in
3182 * @file.
3183 *
3184 * Returns:
3185 * This function returns zero if successful. On error it will return an
3186 * negative error value.
3187 **/
3188static int
3189lpfc_idiag_open(struct inode *inode, struct file *file)
3190{
3191        struct lpfc_debug *debug;
3192
3193        debug = kmalloc(sizeof(*debug), GFP_KERNEL);
3194        if (!debug)
3195                return -ENOMEM;
3196
3197        debug->i_private = inode->i_private;
3198        debug->buffer = NULL;
3199        file->private_data = debug;
3200
3201        return 0;
3202}
3203
3204/**
3205 * lpfc_idiag_release - Release idiag access file operation
3206 * @inode: The inode pointer that contains a vport pointer. (unused)
3207 * @file: The file pointer that contains the buffer to release.
3208 *
3209 * Description:
3210 * This routine is the generic release routine for the idiag access file
3211 * operation, it frees the buffer that was allocated when the debugfs file
3212 * was opened.
3213 *
3214 * Returns:
3215 * This function returns zero.
3216 **/
3217static int
3218lpfc_idiag_release(struct inode *inode, struct file *file)
3219{
3220        struct lpfc_debug *debug = file->private_data;
3221
3222        /* Free the buffers to the file operation */
3223        kfree(debug->buffer);
3224        kfree(debug);
3225
3226        return 0;
3227}
3228
3229/**
3230 * lpfc_idiag_cmd_release - Release idiag cmd access file operation
3231 * @inode: The inode pointer that contains a vport pointer. (unused)
3232 * @file: The file pointer that contains the buffer to release.
3233 *
3234 * Description:
3235 * This routine frees the buffer that was allocated when the debugfs file
3236 * was opened. It also reset the fields in the idiag command struct in the
3237 * case of command for write operation.
3238 *
3239 * Returns:
3240 * This function returns zero.
3241 **/
3242static int
3243lpfc_idiag_cmd_release(struct inode *inode, struct file *file)
3244{
3245        struct lpfc_debug *debug = file->private_data;
3246
3247        if (debug->op == LPFC_IDIAG_OP_WR) {
3248                switch (idiag.cmd.opcode) {
3249                case LPFC_IDIAG_CMD_PCICFG_WR:
3250                case LPFC_IDIAG_CMD_PCICFG_ST:
3251                case LPFC_IDIAG_CMD_PCICFG_CL:
3252                case LPFC_IDIAG_CMD_QUEACC_WR:
3253                case LPFC_IDIAG_CMD_QUEACC_ST:
3254                case LPFC_IDIAG_CMD_QUEACC_CL:
3255                        memset(&idiag, 0, sizeof(idiag));
3256                        break;
3257                default:
3258                        break;
3259                }
3260        }
3261
3262        /* Free the buffers to the file operation */
3263        kfree(debug->buffer);
3264        kfree(debug);
3265
3266        return 0;
3267}
3268
3269/**
3270 * lpfc_idiag_pcicfg_read - idiag debugfs read pcicfg
3271 * @file: The file pointer to read from.
3272 * @buf: The buffer to copy the data to.
3273 * @nbytes: The number of bytes to read.
3274 * @ppos: The position in the file to start reading from.
3275 *
3276 * Description:
3277 * This routine reads data from the @phba pci config space according to the
3278 * idiag command, and copies to user @buf. Depending on the PCI config space
3279 * read command setup, it does either a single register read of a byte
3280 * (8 bits), a word (16 bits), or a dword (32 bits) or browsing through all
3281 * registers from the 4K extended PCI config space.
3282 *
3283 * Returns:
3284 * This function returns the amount of data that was read (this could be less
3285 * than @nbytes if the end of the file was reached) or a negative error value.
3286 **/
3287static ssize_t
3288lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
3289                       loff_t *ppos)
3290{
3291        struct lpfc_debug *debug = file->private_data;
3292        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3293        int offset_label, offset, len = 0, index = LPFC_PCI_CFG_RD_SIZE;
3294        int where, count;
3295        char *pbuffer;
3296        struct pci_dev *pdev;
3297        uint32_t u32val;
3298        uint16_t u16val;
3299        uint8_t u8val;
3300
3301        pdev = phba->pcidev;
3302        if (!pdev)
3303                return 0;
3304
3305        /* This is a user read operation */
3306        debug->op = LPFC_IDIAG_OP_RD;
3307
3308        if (!debug->buffer)
3309                debug->buffer = kmalloc(LPFC_PCI_CFG_SIZE, GFP_KERNEL);
3310        if (!debug->buffer)
3311                return 0;
3312        pbuffer = debug->buffer;
3313
3314        if (*ppos)
3315                return 0;
3316
3317        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
3318                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3319                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3320        } else
3321                return 0;
3322
3323        /* Read single PCI config space register */
3324        switch (count) {
3325        case SIZE_U8: /* byte (8 bits) */
3326                pci_read_config_byte(pdev, where, &u8val);
3327                len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3328                                "%03x: %02x\n", where, u8val);
3329                break;
3330        case SIZE_U16: /* word (16 bits) */
3331                pci_read_config_word(pdev, where, &u16val);
3332                len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3333                                "%03x: %04x\n", where, u16val);
3334                break;
3335        case SIZE_U32: /* double word (32 bits) */
3336                pci_read_config_dword(pdev, where, &u32val);
3337                len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3338                                "%03x: %08x\n", where, u32val);
3339                break;
3340        case LPFC_PCI_CFG_BROWSE: /* browse all */
3341                goto pcicfg_browse;
3342        default:
3343                /* illegal count */
3344                len = 0;
3345                break;
3346        }
3347        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3348
3349pcicfg_browse:
3350
3351        /* Browse all PCI config space registers */
3352        offset_label = idiag.offset.last_rd;
3353        offset = offset_label;
3354
3355        /* Read PCI config space */
3356        len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3357                        "%03x: ", offset_label);
3358        while (index > 0) {
3359                pci_read_config_dword(pdev, offset, &u32val);
3360                len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3361                                "%08x ", u32val);
3362                offset += sizeof(uint32_t);
3363                if (offset >= LPFC_PCI_CFG_SIZE) {
3364                        len += scnprintf(pbuffer+len,
3365                                        LPFC_PCI_CFG_SIZE-len, "\n");
3366                        break;
3367                }
3368                index -= sizeof(uint32_t);
3369                if (!index)
3370                        len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3371                                        "\n");
3372                else if (!(index % (8 * sizeof(uint32_t)))) {
3373                        offset_label += (8 * sizeof(uint32_t));
3374                        len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3375                                        "\n%03x: ", offset_label);
3376                }
3377        }
3378
3379        /* Set up the offset for next portion of pci cfg read */
3380        if (index == 0) {
3381                idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE;
3382                if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE)
3383                        idiag.offset.last_rd = 0;
3384        } else
3385                idiag.offset.last_rd = 0;
3386
3387        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3388}
3389
3390/**
3391 * lpfc_idiag_pcicfg_write - Syntax check and set up idiag pcicfg commands
3392 * @file: The file pointer to read from.
3393 * @buf: The buffer to copy the user data from.
3394 * @nbytes: The number of bytes to get.
3395 * @ppos: The position in the file to start reading from.
3396 *
3397 * This routine get the debugfs idiag command struct from user space and
3398 * then perform the syntax check for PCI config space read or write command
3399 * accordingly. In the case of PCI config space read command, it sets up
3400 * the command in the idiag command struct for the debugfs read operation.
3401 * In the case of PCI config space write operation, it executes the write
3402 * operation into the PCI config space accordingly.
3403 *
3404 * It returns the @nbytges passing in from debugfs user space when successful.
3405 * In case of error conditions, it returns proper error code back to the user
3406 * space.
3407 */
3408static ssize_t
3409lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
3410                        size_t nbytes, loff_t *ppos)
3411{
3412        struct lpfc_debug *debug = file->private_data;
3413        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3414        uint32_t where, value, count;
3415        uint32_t u32val;
3416        uint16_t u16val;
3417        uint8_t u8val;
3418        struct pci_dev *pdev;
3419        int rc;
3420
3421        pdev = phba->pcidev;
3422        if (!pdev)
3423                return -EFAULT;
3424
3425        /* This is a user write operation */
3426        debug->op = LPFC_IDIAG_OP_WR;
3427
3428        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
3429        if (rc < 0)
3430                return rc;
3431
3432        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
3433                /* Sanity check on PCI config read command line arguments */
3434                if (rc != LPFC_PCI_CFG_RD_CMD_ARG)
3435                        goto error_out;
3436                /* Read command from PCI config space, set up command fields */
3437                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3438                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3439                if (count == LPFC_PCI_CFG_BROWSE) {
3440                        if (where % sizeof(uint32_t))
3441                                goto error_out;
3442                        /* Starting offset to browse */
3443                        idiag.offset.last_rd = where;
3444                } else if ((count != sizeof(uint8_t)) &&
3445                           (count != sizeof(uint16_t)) &&
3446                           (count != sizeof(uint32_t)))
3447                        goto error_out;
3448                if (count == sizeof(uint8_t)) {
3449                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
3450                                goto error_out;
3451                        if (where % sizeof(uint8_t))
3452                                goto error_out;
3453                }
3454                if (count == sizeof(uint16_t)) {
3455                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
3456                                goto error_out;
3457                        if (where % sizeof(uint16_t))
3458                                goto error_out;
3459                }
3460                if (count == sizeof(uint32_t)) {
3461                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
3462                                goto error_out;
3463                        if (where % sizeof(uint32_t))
3464                                goto error_out;
3465                }
3466        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR ||
3467                   idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST ||
3468                   idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3469                /* Sanity check on PCI config write command line arguments */
3470                if (rc != LPFC_PCI_CFG_WR_CMD_ARG)
3471                        goto error_out;
3472                /* Write command to PCI config space, read-modify-write */
3473                where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3474                count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3475                value = idiag.cmd.data[IDIAG_PCICFG_VALUE_INDX];
3476                /* Sanity checks */
3477                if ((count != sizeof(uint8_t)) &&
3478                    (count != sizeof(uint16_t)) &&
3479                    (count != sizeof(uint32_t)))
3480                        goto error_out;
3481                if (count == sizeof(uint8_t)) {
3482                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
3483                                goto error_out;
3484                        if (where % sizeof(uint8_t))
3485                                goto error_out;
3486                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3487                                pci_write_config_byte(pdev, where,
3488                                                      (uint8_t)value);
3489                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3490                                rc = pci_read_config_byte(pdev, where, &u8val);
3491                                if (!rc) {
3492                                        u8val |= (uint8_t)value;
3493                                        pci_write_config_byte(pdev, where,
3494                                                              u8val);
3495                                }
3496                        }
3497                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3498                                rc = pci_read_config_byte(pdev, where, &u8val);
3499                                if (!rc) {
3500                                        u8val &= (uint8_t)(~value);
3501                                        pci_write_config_byte(pdev, where,
3502                                                              u8val);
3503                                }
3504                        }
3505                }
3506                if (count == sizeof(uint16_t)) {
3507                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
3508                                goto error_out;
3509                        if (where % sizeof(uint16_t))
3510                                goto error_out;
3511                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3512                                pci_write_config_word(pdev, where,
3513                                                      (uint16_t)value);
3514                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3515                                rc = pci_read_config_word(pdev, where, &u16val);
3516                                if (!rc) {
3517                                        u16val |= (uint16_t)value;
3518                                        pci_write_config_word(pdev, where,
3519                                                              u16val);
3520                                }
3521                        }
3522                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3523                                rc = pci_read_config_word(pdev, where, &u16val);
3524                                if (!rc) {
3525                                        u16val &= (uint16_t)(~value);
3526                                        pci_write_config_word(pdev, where,
3527                                                              u16val);
3528                                }
3529                        }
3530                }
3531                if (count == sizeof(uint32_t)) {
3532                        if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
3533                                goto error_out;
3534                        if (where % sizeof(uint32_t))
3535                                goto error_out;
3536                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3537                                pci_write_config_dword(pdev, where, value);
3538                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3539                                rc = pci_read_config_dword(pdev, where,
3540                                                           &u32val);
3541                                if (!rc) {
3542                                        u32val |= value;
3543                                        pci_write_config_dword(pdev, where,
3544                                                               u32val);
3545                                }
3546                        }
3547                        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3548                                rc = pci_read_config_dword(pdev, where,
3549                                                           &u32val);
3550                                if (!rc) {
3551                                        u32val &= ~value;
3552                                        pci_write_config_dword(pdev, where,
3553                                                               u32val);
3554                                }
3555                        }
3556                }
3557        } else
3558                /* All other opecodes are illegal for now */
3559                goto error_out;
3560
3561        return nbytes;
3562error_out:
3563        memset(&idiag, 0, sizeof(idiag));
3564        return -EINVAL;
3565}
3566
3567/**
3568 * lpfc_idiag_baracc_read - idiag debugfs pci bar access read
3569 * @file: The file pointer to read from.
3570 * @buf: The buffer to copy the data to.
3571 * @nbytes: The number of bytes to read.
3572 * @ppos: The position in the file to start reading from.
3573 *
3574 * Description:
3575 * This routine reads data from the @phba pci bar memory mapped space
3576 * according to the idiag command, and copies to user @buf.
3577 *
3578 * Returns:
3579 * This function returns the amount of data that was read (this could be less
3580 * than @nbytes if the end of the file was reached) or a negative error value.
3581 **/
3582static ssize_t
3583lpfc_idiag_baracc_read(struct file *file, char __user *buf, size_t nbytes,
3584                       loff_t *ppos)
3585{
3586        struct lpfc_debug *debug = file->private_data;
3587        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3588        int offset_label, offset, offset_run, len = 0, index;
3589        int bar_num, acc_range, bar_size;
3590        char *pbuffer;
3591        void __iomem *mem_mapped_bar;
3592        uint32_t if_type;
3593        struct pci_dev *pdev;
3594        uint32_t u32val;
3595
3596        pdev = phba->pcidev;
3597        if (!pdev)
3598                return 0;
3599
3600        /* This is a user read operation */
3601        debug->op = LPFC_IDIAG_OP_RD;
3602
3603        if (!debug->buffer)
3604                debug->buffer = kmalloc(LPFC_PCI_BAR_RD_BUF_SIZE, GFP_KERNEL);
3605        if (!debug->buffer)
3606                return 0;
3607        pbuffer = debug->buffer;
3608
3609        if (*ppos)
3610                return 0;
3611
3612        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
3613                bar_num   = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
3614                offset    = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
3615                acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
3616                bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
3617        } else
3618                return 0;
3619
3620        if (acc_range == 0)
3621                return 0;
3622
3623        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
3624        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3625                if (bar_num == IDIAG_BARACC_BAR_0)
3626                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3627                else if (bar_num == IDIAG_BARACC_BAR_1)
3628                        mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
3629                else if (bar_num == IDIAG_BARACC_BAR_2)
3630                        mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
3631                else
3632                        return 0;
3633        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3634                if (bar_num == IDIAG_BARACC_BAR_0)
3635                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3636                else
3637                        return 0;
3638        } else
3639                return 0;
3640
3641        /* Read single PCI bar space register */
3642        if (acc_range == SINGLE_WORD) {
3643                offset_run = offset;
3644                u32val = readl(mem_mapped_bar + offset_run);
3645                len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3646                                "%05x: %08x\n", offset_run, u32val);
3647        } else
3648                goto baracc_browse;
3649
3650        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3651
3652baracc_browse:
3653
3654        /* Browse all PCI bar space registers */
3655        offset_label = idiag.offset.last_rd;
3656        offset_run = offset_label;
3657
3658        /* Read PCI bar memory mapped space */
3659        len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3660                        "%05x: ", offset_label);
3661        index = LPFC_PCI_BAR_RD_SIZE;
3662        while (index > 0) {
3663                u32val = readl(mem_mapped_bar + offset_run);
3664                len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3665                                "%08x ", u32val);
3666                offset_run += sizeof(uint32_t);
3667                if (acc_range == LPFC_PCI_BAR_BROWSE) {
3668                        if (offset_run >= bar_size) {
3669                                len += scnprintf(pbuffer+len,
3670                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3671                                break;
3672                        }
3673                } else {
3674                        if (offset_run >= offset +
3675                            (acc_range * sizeof(uint32_t))) {
3676                                len += scnprintf(pbuffer+len,
3677                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3678                                break;
3679                        }
3680                }
3681                index -= sizeof(uint32_t);
3682                if (!index)
3683                        len += scnprintf(pbuffer+len,
3684                                        LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3685                else if (!(index % (8 * sizeof(uint32_t)))) {
3686                        offset_label += (8 * sizeof(uint32_t));
3687                        len += scnprintf(pbuffer+len,
3688                                        LPFC_PCI_BAR_RD_BUF_SIZE-len,
3689                                        "\n%05x: ", offset_label);
3690                }
3691        }
3692
3693        /* Set up the offset for next portion of pci bar read */
3694        if (index == 0) {
3695                idiag.offset.last_rd += LPFC_PCI_BAR_RD_SIZE;
3696                if (acc_range == LPFC_PCI_BAR_BROWSE) {
3697                        if (idiag.offset.last_rd >= bar_size)
3698                                idiag.offset.last_rd = 0;
3699                } else {
3700                        if (offset_run >= offset +
3701                            (acc_range * sizeof(uint32_t)))
3702                                idiag.offset.last_rd = offset;
3703                }
3704        } else {
3705                if (acc_range == LPFC_PCI_BAR_BROWSE)
3706                        idiag.offset.last_rd = 0;
3707                else
3708                        idiag.offset.last_rd = offset;
3709        }
3710
3711        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3712}
3713
3714/**
3715 * lpfc_idiag_baracc_write - Syntax check and set up idiag bar access commands
3716 * @file: The file pointer to read from.
3717 * @buf: The buffer to copy the user data from.
3718 * @nbytes: The number of bytes to get.
3719 * @ppos: The position in the file to start reading from.
3720 *
3721 * This routine get the debugfs idiag command struct from user space and
3722 * then perform the syntax check for PCI bar memory mapped space read or
3723 * write command accordingly. In the case of PCI bar memory mapped space
3724 * read command, it sets up the command in the idiag command struct for
3725 * the debugfs read operation. In the case of PCI bar memorpy mapped space
3726 * write operation, it executes the write operation into the PCI bar memory
3727 * mapped space accordingly.
3728 *
3729 * It returns the @nbytges passing in from debugfs user space when successful.
3730 * In case of error conditions, it returns proper error code back to the user
3731 * space.
3732 */
3733static ssize_t
3734lpfc_idiag_baracc_write(struct file *file, const char __user *buf,
3735                        size_t nbytes, loff_t *ppos)
3736{
3737        struct lpfc_debug *debug = file->private_data;
3738        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3739        uint32_t bar_num, bar_size, offset, value, acc_range;
3740        struct pci_dev *pdev;
3741        void __iomem *mem_mapped_bar;
3742        uint32_t if_type;
3743        uint32_t u32val;
3744        int rc;
3745
3746        pdev = phba->pcidev;
3747        if (!pdev)
3748                return -EFAULT;
3749
3750        /* This is a user write operation */
3751        debug->op = LPFC_IDIAG_OP_WR;
3752
3753        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
3754        if (rc < 0)
3755                return rc;
3756
3757        if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
3758        bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
3759
3760        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3761                if ((bar_num != IDIAG_BARACC_BAR_0) &&
3762                    (bar_num != IDIAG_BARACC_BAR_1) &&
3763                    (bar_num != IDIAG_BARACC_BAR_2))
3764                        goto error_out;
3765        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3766                if (bar_num != IDIAG_BARACC_BAR_0)
3767                        goto error_out;
3768        } else
3769                goto error_out;
3770
3771        if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3772                if (bar_num == IDIAG_BARACC_BAR_0) {
3773                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3774                                LPFC_PCI_IF0_BAR0_SIZE;
3775                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3776                } else if (bar_num == IDIAG_BARACC_BAR_1) {
3777                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3778                                LPFC_PCI_IF0_BAR1_SIZE;
3779                        mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
3780                } else if (bar_num == IDIAG_BARACC_BAR_2) {
3781                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3782                                LPFC_PCI_IF0_BAR2_SIZE;
3783                        mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
3784                } else
3785                        goto error_out;
3786        } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3787                if (bar_num == IDIAG_BARACC_BAR_0) {
3788                        idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3789                                LPFC_PCI_IF2_BAR0_SIZE;
3790                        mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3791                } else
3792                        goto error_out;
3793        } else
3794                goto error_out;
3795
3796        offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
3797        if (offset % sizeof(uint32_t))
3798                goto error_out;
3799
3800        bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
3801        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
3802                /* Sanity check on PCI config read command line arguments */
3803                if (rc != LPFC_PCI_BAR_RD_CMD_ARG)
3804                        goto error_out;
3805                acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
3806                if (acc_range == LPFC_PCI_BAR_BROWSE) {
3807                        if (offset > bar_size - sizeof(uint32_t))
3808                                goto error_out;
3809                        /* Starting offset to browse */
3810                        idiag.offset.last_rd = offset;
3811                } else if (acc_range > SINGLE_WORD) {
3812                        if (offset + acc_range * sizeof(uint32_t) > bar_size)
3813                                goto error_out;
3814                        /* Starting offset to browse */
3815                        idiag.offset.last_rd = offset;
3816                } else if (acc_range != SINGLE_WORD)
3817                        goto error_out;
3818        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR ||
3819                   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST ||
3820                   idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
3821                /* Sanity check on PCI bar write command line arguments */
3822                if (rc != LPFC_PCI_BAR_WR_CMD_ARG)
3823                        goto error_out;
3824                /* Write command to PCI bar space, read-modify-write */
3825                acc_range = SINGLE_WORD;
3826                value = idiag.cmd.data[IDIAG_BARACC_REG_VAL_INDX];
3827                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR) {
3828                        writel(value, mem_mapped_bar + offset);
3829                        readl(mem_mapped_bar + offset);
3830                }
3831                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST) {
3832                        u32val = readl(mem_mapped_bar + offset);
3833                        u32val |= value;
3834                        writel(u32val, mem_mapped_bar + offset);
3835                        readl(mem_mapped_bar + offset);
3836                }
3837                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
3838                        u32val = readl(mem_mapped_bar + offset);
3839                        u32val &= ~value;
3840                        writel(u32val, mem_mapped_bar + offset);
3841                        readl(mem_mapped_bar + offset);
3842                }
3843        } else
3844                /* All other opecodes are illegal for now */
3845                goto error_out;
3846
3847        return nbytes;
3848error_out:
3849        memset(&idiag, 0, sizeof(idiag));
3850        return -EINVAL;
3851}
3852
3853static int
3854__lpfc_idiag_print_wq(struct lpfc_queue *qp, char *wqtype,
3855                        char *pbuffer, int len)
3856{
3857        if (!qp)
3858                return len;
3859
3860        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3861                        "\t\t%s WQ info: ", wqtype);
3862        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3863                        "AssocCQID[%04d]: WQ-STAT[oflow:x%x posted:x%llx]\n",
3864                        qp->assoc_qid, qp->q_cnt_1,
3865                        (unsigned long long)qp->q_cnt_4);
3866        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3867                        "\t\tWQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3868                        "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]",
3869                        qp->queue_id, qp->entry_count,
3870                        qp->entry_size, qp->host_index,
3871                        qp->hba_index, qp->notify_interval);
3872        len +=  scnprintf(pbuffer + len,
3873                        LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
3874        return len;
3875}
3876
3877static int
3878lpfc_idiag_wqs_for_cq(struct lpfc_hba *phba, char *wqtype, char *pbuffer,
3879                int *len, int max_cnt, int cq_id)
3880{
3881        struct lpfc_queue *qp;
3882        int qidx;
3883
3884        for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
3885                qp = phba->sli4_hba.hdwq[qidx].io_wq;
3886                if (qp->assoc_qid != cq_id)
3887                        continue;
3888                *len = __lpfc_idiag_print_wq(qp, wqtype, pbuffer, *len);
3889                if (*len >= max_cnt)
3890                        return 1;
3891        }
3892        return 0;
3893}
3894
3895static int
3896__lpfc_idiag_print_cq(struct lpfc_queue *qp, char *cqtype,
3897                        char *pbuffer, int len)
3898{
3899        if (!qp)
3900                return len;
3901
3902        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3903                        "\t%s CQ info: ", cqtype);
3904        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3905                        "AssocEQID[%02d]: CQ STAT[max:x%x relw:x%x "
3906                        "xabt:x%x wq:x%llx]\n",
3907                        qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
3908                        qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
3909        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3910                        "\tCQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3911                        "HST-IDX[%04d], NTFI[%03d], PLMT[%03d]",
3912                        qp->queue_id, qp->entry_count,
3913                        qp->entry_size, qp->host_index,
3914                        qp->notify_interval, qp->max_proc_limit);
3915
3916        len +=  scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3917                        "\n");
3918
3919        return len;
3920}
3921
3922static int
3923__lpfc_idiag_print_rqpair(struct lpfc_queue *qp, struct lpfc_queue *datqp,
3924                        char *rqtype, char *pbuffer, int len)
3925{
3926        if (!qp || !datqp)
3927                return len;
3928
3929        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3930                        "\t\t%s RQ info: ", rqtype);
3931        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3932                        "AssocCQID[%02d]: RQ-STAT[nopost:x%x nobuf:x%x "
3933                        "posted:x%x rcv:x%llx]\n",
3934                        qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
3935                        qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
3936        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3937                        "\t\tHQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3938                        "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
3939                        qp->queue_id, qp->entry_count, qp->entry_size,
3940                        qp->host_index, qp->hba_index, qp->notify_interval);
3941        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3942                        "\t\tDQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3943                        "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
3944                        datqp->queue_id, datqp->entry_count,
3945                        datqp->entry_size, datqp->host_index,
3946                        datqp->hba_index, datqp->notify_interval);
3947        return len;
3948}
3949
3950static int
3951lpfc_idiag_cqs_for_eq(struct lpfc_hba *phba, char *pbuffer,
3952                int *len, int max_cnt, int eqidx, int eq_id)
3953{
3954        struct lpfc_queue *qp;
3955        int rc;
3956
3957        qp = phba->sli4_hba.hdwq[eqidx].io_cq;
3958
3959        *len = __lpfc_idiag_print_cq(qp, "IO", pbuffer, *len);
3960
3961        /* Reset max counter */
3962        qp->CQ_max_cqe = 0;
3963
3964        if (*len >= max_cnt)
3965                return 1;
3966
3967        rc = lpfc_idiag_wqs_for_cq(phba, "IO", pbuffer, len,
3968                                   max_cnt, qp->queue_id);
3969        if (rc)
3970                return 1;
3971
3972        if ((eqidx < phba->cfg_nvmet_mrq) && phba->nvmet_support) {
3973                /* NVMET CQset */
3974                qp = phba->sli4_hba.nvmet_cqset[eqidx];
3975                *len = __lpfc_idiag_print_cq(qp, "NVMET CQset", pbuffer, *len);
3976
3977                /* Reset max counter */
3978                qp->CQ_max_cqe = 0;
3979
3980                if (*len >= max_cnt)
3981                        return 1;
3982
3983                /* RQ header */
3984                qp = phba->sli4_hba.nvmet_mrq_hdr[eqidx];
3985                *len = __lpfc_idiag_print_rqpair(qp,
3986                                phba->sli4_hba.nvmet_mrq_data[eqidx],
3987                                "NVMET MRQ", pbuffer, *len);
3988
3989                if (*len >= max_cnt)
3990                        return 1;
3991        }
3992
3993        return 0;
3994}
3995
3996static int
3997__lpfc_idiag_print_eq(struct lpfc_queue *qp, char *eqtype,
3998                        char *pbuffer, int len)
3999{
4000        if (!qp)
4001                return len;
4002
4003        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4004                        "\n%s EQ info: EQ-STAT[max:x%x noE:x%x "
4005                        "cqe_proc:x%x eqe_proc:x%llx eqd %d]\n",
4006                        eqtype, qp->q_cnt_1, qp->q_cnt_2, qp->q_cnt_3,
4007                        (unsigned long long)qp->q_cnt_4, qp->q_mode);
4008        len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4009                        "EQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
4010                        "HST-IDX[%04d], NTFI[%03d], PLMT[%03d], AFFIN[%03d]",
4011                        qp->queue_id, qp->entry_count, qp->entry_size,
4012                        qp->host_index, qp->notify_interval,
4013                        qp->max_proc_limit, qp->chann);
4014        len +=  scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4015                        "\n");
4016
4017        return len;
4018}
4019
4020/**
4021 * lpfc_idiag_queinfo_read - idiag debugfs read queue information
4022 * @file: The file pointer to read from.
4023 * @buf: The buffer to copy the data to.
4024 * @nbytes: The number of bytes to read.
4025 * @ppos: The position in the file to start reading from.
4026 *
4027 * Description:
4028 * This routine reads data from the @phba SLI4 PCI function queue information,
4029 * and copies to user @buf.
4030 * This routine only returns 1 EQs worth of information. It remembers the last
4031 * EQ read and jumps to the next EQ. Thus subsequent calls to queInfo will
4032 * retrieve all EQs allocated for the phba.
4033 *
4034 * Returns:
4035 * This function returns the amount of data that was read (this could be less
4036 * than @nbytes if the end of the file was reached) or a negative error value.
4037 **/
4038static ssize_t
4039lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
4040                        loff_t *ppos)
4041{
4042        struct lpfc_debug *debug = file->private_data;
4043        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4044        char *pbuffer;
4045        int max_cnt, rc, x, len = 0;
4046        struct lpfc_queue *qp = NULL;
4047
4048        if (!debug->buffer)
4049                debug->buffer = kmalloc(LPFC_QUE_INFO_GET_BUF_SIZE, GFP_KERNEL);
4050        if (!debug->buffer)
4051                return 0;
4052        pbuffer = debug->buffer;
4053        max_cnt = LPFC_QUE_INFO_GET_BUF_SIZE - 256;
4054
4055        if (*ppos)
4056                return 0;
4057
4058        spin_lock_irq(&phba->hbalock);
4059
4060        /* Fast-path event queue */
4061        if (phba->sli4_hba.hdwq && phba->cfg_hdw_queue) {
4062
4063                x = phba->lpfc_idiag_last_eq;
4064                phba->lpfc_idiag_last_eq++;
4065                if (phba->lpfc_idiag_last_eq >= phba->cfg_hdw_queue)
4066                        phba->lpfc_idiag_last_eq = 0;
4067
4068                len += scnprintf(pbuffer + len,
4069                                 LPFC_QUE_INFO_GET_BUF_SIZE - len,
4070                                 "HDWQ %d out of %d HBA HDWQs\n",
4071                                 x, phba->cfg_hdw_queue);
4072
4073                /* Fast-path EQ */
4074                qp = phba->sli4_hba.hdwq[x].hba_eq;
4075                if (!qp)
4076                        goto out;
4077
4078                len = __lpfc_idiag_print_eq(qp, "HBA", pbuffer, len);
4079
4080                /* Reset max counter */
4081                qp->EQ_max_eqe = 0;
4082
4083                if (len >= max_cnt)
4084                        goto too_big;
4085
4086                /* will dump both fcp and nvme cqs/wqs for the eq */
4087                rc = lpfc_idiag_cqs_for_eq(phba, pbuffer, &len,
4088                        max_cnt, x, qp->queue_id);
4089                if (rc)
4090                        goto too_big;
4091
4092                /* Only EQ 0 has slow path CQs configured */
4093                if (x)
4094                        goto out;
4095
4096                /* Slow-path mailbox CQ */
4097                qp = phba->sli4_hba.mbx_cq;
4098                len = __lpfc_idiag_print_cq(qp, "MBX", pbuffer, len);
4099                if (len >= max_cnt)
4100                        goto too_big;
4101
4102                /* Slow-path MBOX MQ */
4103                qp = phba->sli4_hba.mbx_wq;
4104                len = __lpfc_idiag_print_wq(qp, "MBX"