drivers/scsi/lpfc/lpfc_debugfs.c

   1 /*******************************************************************
   2  * This file is part of the Emulex Linux Device Driver for         *
   3  * Fibre Channel Host Bus Adapters.                                *
   4  * Copyright (C) 2007 Emulex.  All rights reserved.                *
   5  * EMULEX and SLI are trademarks of Emulex.                        *
   6  * www.emulex.com                                                  *
   7  *                                                                 *
   8  * This program is free software; you can redistribute it and/or   *
   9  * modify it under the terms of version 2 of the GNU General       *
  10  * Public License as published by the Free Software Foundation.    *
  11  * This program is distributed in the hope that it will be useful. *
  12  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
  13  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
  14  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
  15  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
  16  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
  17  * more details, a copy of which can be found in the file COPYING  *
  18  * included with this package.                                     *
  19  *******************************************************************/
  20
  21 #include <linux/blkdev.h>
  22 #include <linux/delay.h>
  23 #include <linux/dma-mapping.h>
  24 #include <linux/idr.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/kthread.h>
  27 #include <linux/pci.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/ctype.h>
  30 #include <linux/version.h>
  31
  32 #include <scsi/scsi.h>
  33 #include <scsi/scsi_device.h>
  34 #include <scsi/scsi_host.h>
  35 #include <scsi/scsi_transport_fc.h>
  36
  37 #include "lpfc_hw.h"
  38 #include "lpfc_sli.h"
  39 #include "lpfc_disc.h"
  40 #include "lpfc_scsi.h"
  41 #include "lpfc.h"
  42 #include "lpfc_logmsg.h"
  43 #include "lpfc_crtn.h"
  44 #include "lpfc_vport.h"
  45 #include "lpfc_version.h"
  46 #include "lpfc_vport.h"
  47 #include "lpfc_debugfs.h"
  48
  49 #ifdef CONFIG_LPFC_DEBUG_FS
  50 /* debugfs interface
  51  *
  52  * To access this interface the user should:
  53  * # mkdir /debug
  54  * # mount -t debugfs none /debug
  55  *
  56  * The lpfc debugfs directory hierachy is:
  57  * lpfc/lpfcX/vportY
  58  * where X is the lpfc hba unique_id
  59  * where Y is the vport VPI on that hba
  60  *
  61  * Debugging services available per vport:
  62  * discovery_trace
  63  * This is an ACSII readable file that contains a trace of the last
  64  * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
  65  * See lpfc_debugfs.h for different categories of
  66  * discovery events. To enable the discovery trace, the following
  67  * module parameters must be set:
  68  * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
  69  * lpfc_debugfs_max_disc_trc=X   Where X is the event trace depth for
  70  *                               EACH vport. X MUST also be a power of 2.
  71  * lpfc_debugfs_mask_disc_trc=Y  Where Y is an event mask as defined in
  72  *                               lpfc_debugfs.h .
  73  */
  74 static int lpfc_debugfs_enable = 1;
  75 module_param(lpfc_debugfs_enable, int, 0);
  76 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
  77
  78 /* This MUST be a power of 2 */
  79 static int lpfc_debugfs_max_disc_trc = 0;
  80 module_param(lpfc_debugfs_max_disc_trc, int, 0);
  81 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
  82         "Set debugfs discovery trace depth");
  83
  84 /* This MUST be a power of 2 */
  85 static int lpfc_debugfs_max_slow_ring_trc = 0;
  86 module_param(lpfc_debugfs_max_slow_ring_trc, int, 0);
  87 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
  88         "Set debugfs slow ring trace depth");
  89
  90 static int lpfc_debugfs_mask_disc_trc = 0;
  91 module_param(lpfc_debugfs_mask_disc_trc, int, 0);
  92 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
  93         "Set debugfs discovery trace mask");
  94
  95 #include <linux/debugfs.h>
  96
  97 /* size of output line, for discovery_trace and slow_ring_trace */
  98 #define LPFC_DEBUG_TRC_ENTRY_SIZE 100
  99
 100 /* nodelist output buffer size */
 101 #define LPFC_NODELIST_SIZE 8192
 102 #define LPFC_NODELIST_ENTRY_SIZE 120
 103
 104 /* dumpslim output buffer size */
 105 #define LPFC_DUMPSLIM_SIZE 4096
 106
 107 /* hbqinfo output buffer size */
 108 #define LPFC_HBQINFO_SIZE 8192
 109
 110 struct lpfc_debug {
 111         char *buffer;
 112         int  len;
 113 };
 114
 115 extern struct lpfc_hbq_init *lpfc_hbq_defs[];
 116
 117 atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
 118 unsigned long lpfc_debugfs_start_time = 0L;
 119
 120 static int
 121 lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
 122 {
 123         int i, index, len, enable;
 124         uint32_t ms;
 125         struct lpfc_debugfs_trc *dtp;
 126         char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
 127
 128
 129         enable = lpfc_debugfs_enable;
 130         lpfc_debugfs_enable = 0;
 131
 132         len = 0;
 133         index = (atomic_read(&vport->disc_trc_cnt) + 1) &
 134                 (lpfc_debugfs_max_disc_trc - 1);
 135         for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
 136                 dtp = vport->disc_trc + i;
 137                 if (!dtp->fmt)
 138                         continue;
 139                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 140                 snprintf(buffer,
 141                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 142                         dtp->seq_cnt, ms, dtp->fmt);
 143                 len +=  snprintf(buf+len, size-len, buffer,
 144                         dtp->data1, dtp->data2, dtp->data3);
 145         }
 146         for (i = 0; i < index; i++) {
 147                 dtp = vport->disc_trc + i;
 148                 if (!dtp->fmt)
 149                         continue;
 150                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 151                 snprintf(buffer,
 152                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 153                         dtp->seq_cnt, ms, dtp->fmt);
 154                 len +=  snprintf(buf+len, size-len, buffer,
 155                         dtp->data1, dtp->data2, dtp->data3);
 156         }
 157
 158         lpfc_debugfs_enable = enable;
 159         return len;
 160 }
 161
 162 static int
 163 lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
 164 {
 165         int i, index, len, enable;
 166         uint32_t ms;
 167         struct lpfc_debugfs_trc *dtp;
 168         char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
 169
 170
 171         enable = lpfc_debugfs_enable;
 172         lpfc_debugfs_enable = 0;
 173
 174         len = 0;
 175         index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
 176                 (lpfc_debugfs_max_slow_ring_trc - 1);
 177         for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
 178                 dtp = phba->slow_ring_trc + i;
 179                 if (!dtp->fmt)
 180                         continue;
 181                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 182                 snprintf(buffer,
 183                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 184                         dtp->seq_cnt, ms, dtp->fmt);
 185                 len +=  snprintf(buf+len, size-len, buffer,
 186                         dtp->data1, dtp->data2, dtp->data3);
 187         }
 188         for (i = 0; i < index; i++) {
 189                 dtp = phba->slow_ring_trc + i;
 190                 if (!dtp->fmt)
 191                         continue;
 192                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
 193                 snprintf(buffer,
 194                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
 195                         dtp->seq_cnt, ms, dtp->fmt);
 196                 len +=  snprintf(buf+len, size-len, buffer,
 197                         dtp->data1, dtp->data2, dtp->data3);
 198         }
 199
 200         lpfc_debugfs_enable = enable;
 201         return len;
 202 }
 203
 204 int lpfc_debugfs_last_hbq = -1;
 205
 206 static int
 207 lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
 208 {
 209         int len = 0;
 210         int cnt, i, j, found, posted, low;
 211         uint32_t phys, raw_index, getidx;
 212         struct lpfc_hbq_init *hip;
 213         struct hbq_s *hbqs;
 214         struct lpfc_hbq_entry *hbqe;
 215         struct lpfc_dmabuf *d_buf;
 216         struct hbq_dmabuf *hbq_buf;
 217
 218         cnt = LPFC_HBQINFO_SIZE;
 219         spin_lock_irq(&phba->hbalock);
 220
 221         /* toggle between multiple hbqs, if any */
 222         i = lpfc_sli_hbq_count();
 223         if (i > 1) {
 224                  lpfc_debugfs_last_hbq++;
 225                  if (lpfc_debugfs_last_hbq >= i)
 226                         lpfc_debugfs_last_hbq = 0;
 227         }
 228         else
 229                 lpfc_debugfs_last_hbq = 0;
 230
 231         i = lpfc_debugfs_last_hbq;
 232
 233         len +=  snprintf(buf+len, size-len, "HBQ %d Info\n", i);
 234
 235         hbqs =  &phba->hbqs[i];
 236         posted = 0;
 237         list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list)
 238                 posted++;
 239
 240         hip =  lpfc_hbq_defs[i];
 241         len +=  snprintf(buf+len, size-len,
 242                 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
 243                 hip->hbq_index, hip->profile, hip->rn,
 244                 hip->buffer_count, hip->init_count, hip->add_count, posted);
 245
 246         raw_index = phba->hbq_get[i];
 247         getidx = le32_to_cpu(raw_index);
 248         len +=  snprintf(buf+len, size-len,
 249                 "entrys:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
 250                 hbqs->entry_count, hbqs->hbqPutIdx, hbqs->next_hbqPutIdx,
 251                 hbqs->local_hbqGetIdx, getidx);
 252
 253         hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
 254         for (j=0; j<hbqs->entry_count; j++) {
 255                 len +=  snprintf(buf+len, size-len,
 256                         "%03d: %08x %04x %05x ", j,
 257                         hbqe->bde.addrLow, hbqe->bde.tus.w, hbqe->buffer_tag);
 258
 259                 i = 0;
 260                 found = 0;
 261
 262                 /* First calculate if slot has an associated posted buffer */
 263                 low = hbqs->hbqPutIdx - posted;
 264                 if (low >= 0) {
 265                         if ((j >= hbqs->hbqPutIdx) || (j < low)) {
 266                                 len +=  snprintf(buf+len, size-len, "Unused\n");
 267                                 goto skipit;
 268                         }
 269                 }
 270                 else {
 271                         if ((j >= hbqs->hbqPutIdx) &&
 272                                 (j < (hbqs->entry_count+low))) {
 273                                 len +=  snprintf(buf+len, size-len, "Unused\n");
 274                                 goto skipit;
 275                         }
 276                 }
 277
 278                 /* Get the Buffer info for the posted buffer */
 279                 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) {
 280                         hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
 281                         phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
 282                         if (phys == hbqe->bde.addrLow) {
 283                                 len +=  snprintf(buf+len, size-len,
 284                                         "Buf%d: %p %06x\n", i,
 285                                         hbq_buf->dbuf.virt, hbq_buf->tag);
 286                                 found = 1;
 287                                 break;
 288                         }
 289                         i++;
 290                 }
 291                 if (!found) {
 292                         len +=  snprintf(buf+len, size-len, "No DMAinfo?\n");
 293                 }
 294 skipit:
 295                 hbqe++;
 296                 if (len > LPFC_HBQINFO_SIZE - 54)
 297                         break;
 298         }
 299         spin_unlock_irq(&phba->hbalock);
 300         return len;
 301 }
 302
 303 static int
 304 lpfc_debugfs_dumpslim_data(struct lpfc_hba *phba, char *buf, int size)
 305 {
 306         int len = 0;
 307         int cnt, i, off;
 308         uint32_t word0, word1, word2, word3;
 309         uint32_t *ptr;
 310         struct lpfc_pgp *pgpp;
 311         struct lpfc_sli *psli = &phba->sli;
 312         struct lpfc_sli_ring *pring;
 313
 314         cnt = LPFC_DUMPSLIM_SIZE;
 315         off = 0;
 316         spin_lock_irq(&phba->hbalock);
 317
 318         len +=  snprintf(buf+len, size-len, "SLIM Mailbox\n");
 319         ptr = (uint32_t *)phba->slim2p;
 320         i = sizeof(MAILBOX_t);
 321         while (i > 0) {
 322                 len +=  snprintf(buf+len, size-len,
 323                 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
 324                 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
 325                 *(ptr+5), *(ptr+6), *(ptr+7));
 326                 ptr += 8;
 327                 i -= (8 * sizeof(uint32_t));
 328                 off += (8 * sizeof(uint32_t));
 329         }
 330
 331         len +=  snprintf(buf+len, size-len, "SLIM PCB\n");
 332         ptr = (uint32_t *)&phba->slim2p->pcb;
 333         i = sizeof(PCB_t);
 334         while (i > 0) {
 335                 len +=  snprintf(buf+len, size-len,
 336                 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
 337                 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
 338                 *(ptr+5), *(ptr+6), *(ptr+7));
 339                 ptr += 8;
 340                 i -= (8 * sizeof(uint32_t));
 341                 off += (8 * sizeof(uint32_t));
 342         }
 343
 344         pgpp = (struct lpfc_pgp *)&phba->slim2p->mbx.us.s3_pgp.port;
 345         pring = &psli->ring[0];
 346         len +=  snprintf(buf+len, size-len,
 347                 "Ring 0: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x)  "
 348                 "RSP PutInx:%d Max:%d\n",
 349                 pgpp->cmdGetInx, pring->numCiocb,
 350                 pring->next_cmdidx, pring->local_getidx, pring->flag,
 351                 pgpp->rspPutInx, pring->numRiocb);
 352         pgpp++;
 353
 354         pring = &psli->ring[1];
 355         len +=  snprintf(buf+len, size-len,
 356                 "Ring 1: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x)  "
 357                 "RSP PutInx:%d Max:%d\n",
 358                 pgpp->cmdGetInx, pring->numCiocb,
 359                 pring->next_cmdidx, pring->local_getidx, pring->flag,
 360                 pgpp->rspPutInx, pring->numRiocb);
 361         pgpp++;
 362
 363         pring = &psli->ring[2];
 364         len +=  snprintf(buf+len, size-len,
 365                 "Ring 2: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x)  "
 366                 "RSP PutInx:%d Max:%d\n",
 367                 pgpp->cmdGetInx, pring->numCiocb,
 368                 pring->next_cmdidx, pring->local_getidx, pring->flag,
 369                 pgpp->rspPutInx, pring->numRiocb);
 370         pgpp++;
 371
 372         pring = &psli->ring[3];
 373         len +=  snprintf(buf+len, size-len,
 374                 "Ring 3: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x)  "
 375                 "RSP PutInx:%d Max:%d\n",
 376                 pgpp->cmdGetInx, pring->numCiocb,
 377                 pring->next_cmdidx, pring->local_getidx, pring->flag,
 378                 pgpp->rspPutInx, pring->numRiocb);
 379
 380
 381         ptr = (uint32_t *)&phba->slim2p->mbx.us.s3_pgp.hbq_get;
 382         word0 = readl(phba->HAregaddr);
 383         word1 = readl(phba->CAregaddr);
 384         word2 = readl(phba->HSregaddr);
 385         word3 = readl(phba->HCregaddr);
 386         len +=  snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x HC:%08x\n",
 387         word0, word1, word2, word3);
 388         spin_unlock_irq(&phba->hbalock);
 389         return len;
 390 }
 391
 392 static int
 393 lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
 394 {
 395         int len = 0;
 396         int cnt;
 397         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 398         struct lpfc_nodelist *ndlp;
 399         unsigned char *statep, *name;
 400
 401         cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
 402
 403         spin_lock_irq(shost->host_lock);
 404         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
 405                 if (!cnt) {
 406                         len +=  snprintf(buf+len, size-len,
 407                                 "Missing Nodelist Entries\n");
 408                         break;
 409                 }
 410                 cnt--;
 411                 switch (ndlp->nlp_state) {
 412                 case NLP_STE_UNUSED_NODE:
 413                         statep = "UNUSED";
 414                         break;
 415                 case NLP_STE_PLOGI_ISSUE:
 416                         statep = "PLOGI ";
 417                         break;
 418                 case NLP_STE_ADISC_ISSUE:
 419                         statep = "ADISC ";
 420                         break;
 421                 case NLP_STE_REG_LOGIN_ISSUE:
 422                         statep = "REGLOG";
 423                         break;
 424                 case NLP_STE_PRLI_ISSUE:
 425                         statep = "PRLI  ";
 426                         break;
 427                 case NLP_STE_UNMAPPED_NODE:
 428                         statep = "UNMAP ";
 429                         break;
 430                 case NLP_STE_MAPPED_NODE:
 431                         statep = "MAPPED";
 432                         break;
 433                 case NLP_STE_NPR_NODE:
 434                         statep = "NPR   ";
 435                         break;
 436                 default:
 437                         statep = "UNKNOWN";
 438                 }
 439                 len +=  snprintf(buf+len, size-len, "%s DID:x%06x ",
 440                         statep, ndlp->nlp_DID);
 441                 name = (unsigned char *)&ndlp->nlp_portname;
 442                 len +=  snprintf(buf+len, size-len,
 443                         "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
 444                         *name, *(name+1), *(name+2), *(name+3),
 445                         *(name+4), *(name+5), *(name+6), *(name+7));
 446                 name = (unsigned char *)&ndlp->nlp_nodename;
 447                 len +=  snprintf(buf+len, size-len,
 448                         "WWNN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
 449                         *name, *(name+1), *(name+2), *(name+3),
 450                         *(name+4), *(name+5), *(name+6), *(name+7));
 451                 len +=  snprintf(buf+len, size-len, "RPI:%03d flag:x%08x ",
 452                         ndlp->nlp_rpi, ndlp->nlp_flag);
 453                 if (!ndlp->nlp_type)
 454                         len +=  snprintf(buf+len, size-len, "UNKNOWN_TYPE ");
 455                 if (ndlp->nlp_type & NLP_FC_NODE)
 456                         len +=  snprintf(buf+len, size-len, "FC_NODE ");
 457                 if (ndlp->nlp_type & NLP_FABRIC)
 458                         len +=  snprintf(buf+len, size-len, "FABRIC ");
 459                 if (ndlp->nlp_type & NLP_FCP_TARGET)
 460                         len +=  snprintf(buf+len, size-len, "FCP_TGT sid:%d ",
 461                                 ndlp->nlp_sid);
 462                 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
 463                         len +=  snprintf(buf+len, size-len, "FCP_INITIATOR ");
 464                 len += snprintf(buf+len, size-len, "refcnt:%x",
 465                         atomic_read(&ndlp->kref.refcount));
 466                 len +=  snprintf(buf+len, size-len, "\n");
 467         }
 468         spin_unlock_irq(shost->host_lock);
 469         return len;
 470 }
 471 #endif
 472
 473
 474 inline void
 475 lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
 476         uint32_t data1, uint32_t data2, uint32_t data3)
 477 {
 478 #ifdef CONFIG_LPFC_DEBUG_FS
 479         struct lpfc_debugfs_trc *dtp;
 480         int index;
 481
 482         if (!(lpfc_debugfs_mask_disc_trc & mask))
 483                 return;
 484
 485         if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
 486                 !vport || !vport->disc_trc)
 487                 return;
 488
 489         index = atomic_inc_return(&vport->disc_trc_cnt) &
 490                 (lpfc_debugfs_max_disc_trc - 1);
 491         dtp = vport->disc_trc + index;
 492         dtp->fmt = fmt;
 493         dtp->data1 = data1;
 494         dtp->data2 = data2;
 495         dtp->data3 = data3;
 496         dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
 497         dtp->jif = jiffies;
 498 #endif
 499         return;
 500 }
 501
 502 inline void
 503 lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
 504         uint32_t data1, uint32_t data2, uint32_t data3)
 505 {
 506 #ifdef CONFIG_LPFC_DEBUG_FS
 507         struct lpfc_debugfs_trc *dtp;
 508         int index;
 509
 510         if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
 511                 !phba || !phba->slow_ring_trc)
 512                 return;
 513
 514         index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
 515                 (lpfc_debugfs_max_slow_ring_trc - 1);
 516         dtp = phba->slow_ring_trc + index;
 517         dtp->fmt = fmt;
 518         dtp->data1 = data1;
 519         dtp->data2 = data2;
 520         dtp->data3 = data3;
 521         dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
 522         dtp->jif = jiffies;
 523 #endif
 524         return;
 525 }
 526
 527 #ifdef CONFIG_LPFC_DEBUG_FS
 528 static int
 529 lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
 530 {
 531         struct lpfc_vport *vport = inode->i_private;
 532         struct lpfc_debug *debug;
 533         int size;
 534         int rc = -ENOMEM;
 535
 536         if (!lpfc_debugfs_max_disc_trc) {
 537                  rc = -ENOSPC;
 538                 goto out;
 539         }
 540
 541         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
 542         if (!debug)
 543                 goto out;
 544
 545         /* Round to page boundry */
 546         size =  (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
 547         size = PAGE_ALIGN(size);
 548
 549         debug->buffer = kmalloc(size, GFP_KERNEL);
 550         if (!debug->buffer) {
 551                 kfree(debug);
 552                 goto out;
 553         }
 554
 555         debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
 556         file->private_data = debug;
 557
 558         rc = 0;
 559 out:
 560         return rc;
 561 }
 562
 563 static int
 564 lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
 565 {
 566         struct lpfc_hba *phba = inode->i_private;
 567         struct lpfc_debug *debug;
 568         int size;
 569         int rc = -ENOMEM;
 570
 571         if (!lpfc_debugfs_max_slow_ring_trc) {
 572                  rc = -ENOSPC;
 573                 goto out;
 574         }
 575
 576         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
 577         if (!debug)
 578                 goto out;
 579
 580         /* Round to page boundry */
 581         size =  (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
 582         size = PAGE_ALIGN(size);
 583
 584         debug->buffer = kmalloc(size, GFP_KERNEL);
 585         if (!debug->buffer) {
 586                 kfree(debug);
 587                 goto out;
 588         }
 589
 590         debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
 591         file->private_data = debug;
 592
 593         rc = 0;
 594 out:
 595         return rc;
 596 }
 597
 598 static int
 599 lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
 600 {
 601         struct lpfc_hba *phba = inode->i_private;
 602         struct lpfc_debug *debug;
 603         int rc = -ENOMEM;
 604
 605         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
 606         if (!debug)
 607                 goto out;
 608
 609         /* Round to page boundry */
 610         debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
 611         if (!debug->buffer) {
 612                 kfree(debug);
 613                 goto out;
 614         }
 615
 616         debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
 617                 LPFC_HBQINFO_SIZE);
 618         file->private_data = debug;
 619
 620         rc = 0;
 621 out:
 622         return rc;
 623 }
 624
 625 static int
 626 lpfc_debugfs_dumpslim_open(struct inode *inode, struct file *file)
 627 {
 628         struct lpfc_hba *phba = inode->i_private;
 629         struct lpfc_debug *debug;
 630         int rc = -ENOMEM;
 631
 632         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
 633         if (!debug)
 634                 goto out;
 635
 636         /* Round to page boundry */
 637         debug->buffer = kmalloc(LPFC_DUMPSLIM_SIZE, GFP_KERNEL);
 638         if (!debug->buffer) {
 639                 kfree(debug);
 640                 goto out;
 641         }
 642
 643         debug->len = lpfc_debugfs_dumpslim_data(phba, debug->buffer,
 644                 LPFC_DUMPSLIM_SIZE);
 645         file->private_data = debug;
 646
 647         rc = 0;
 648 out:
 649         return rc;
 650 }
 651
 652 static int
 653 lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
 654 {
 655         struct lpfc_vport *vport = inode->i_private;
 656         struct lpfc_debug *debug;
 657         int rc = -ENOMEM;
 658
 659         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
 660         if (!debug)
 661                 goto out;
 662
 663         /* Round to page boundry */
 664         debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
 665         if (!debug->buffer) {
 666                 kfree(debug);
 667                 goto out;
 668         }
 669
 670         debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
 671                 LPFC_NODELIST_SIZE);
 672         file->private_data = debug;
 673
 674         rc = 0;
 675 out:
 676         return rc;
 677 }
 678
 679 static loff_t
 680 lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
 681 {
 682         struct lpfc_debug *debug;
 683         loff_t pos = -1;
 684
 685         debug = file->private_data;
 686
 687         switch (whence) {
 688         case 0:
 689                 pos = off;
 690                 break;
 691         case 1:
 692                 pos = file->f_pos + off;
 693                 break;
 694         case 2:
 695                 pos = debug->len - off;
 696         }
 697         return (pos < 0 || pos > debug->len) ? -EINVAL : (file->f_pos = pos);
 698 }
 699
 700 static ssize_t
 701 lpfc_debugfs_read(struct file *file, char __user *buf,
 702                   size_t nbytes, loff_t *ppos)
 703 {
 704         struct lpfc_debug *debug = file->private_data;
 705         return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
 706                                        debug->len);
 707 }
 708
 709 static int
 710 lpfc_debugfs_release(struct inode *inode, struct file *file)
 711 {
 712         struct lpfc_debug *debug = file->private_data;
 713
 714         kfree(debug->buffer);
 715         kfree(debug);
 716
 717         return 0;
 718 }
 719
 720 #undef lpfc_debugfs_op_disc_trc
 721 static struct file_operations lpfc_debugfs_op_disc_trc = {
 722         .owner =        THIS_MODULE,
 723         .open =         lpfc_debugfs_disc_trc_open,
 724         .llseek =       lpfc_debugfs_lseek,
 725         .read =         lpfc_debugfs_read,
 726         .release =      lpfc_debugfs_release,
 727 };
 728
 729 #undef lpfc_debugfs_op_nodelist
 730 static struct file_operations lpfc_debugfs_op_nodelist = {
 731         .owner =        THIS_MODULE,
 732         .open =         lpfc_debugfs_nodelist_open,
 733         .llseek =       lpfc_debugfs_lseek,
 734         .read =         lpfc_debugfs_read,
 735         .release =      lpfc_debugfs_release,
 736 };
 737
 738 #undef lpfc_debugfs_op_hbqinfo
 739 static struct file_operations lpfc_debugfs_op_hbqinfo = {
 740         .owner =        THIS_MODULE,
 741         .open =         lpfc_debugfs_hbqinfo_open,
 742         .llseek =       lpfc_debugfs_lseek,
 743         .read =         lpfc_debugfs_read,
 744         .release =      lpfc_debugfs_release,
 745 };
 746
 747 #undef lpfc_debugfs_op_dumpslim
 748 static struct file_operations lpfc_debugfs_op_dumpslim = {
 749         .owner =        THIS_MODULE,
 750         .open =         lpfc_debugfs_dumpslim_open,
 751         .llseek =       lpfc_debugfs_lseek,
 752         .read =         lpfc_debugfs_read,
 753         .release =      lpfc_debugfs_release,
 754 };
 755
 756 #undef lpfc_debugfs_op_slow_ring_trc
 757 static struct file_operations lpfc_debugfs_op_slow_ring_trc = {
 758         .owner =        THIS_MODULE,
 759         .open =         lpfc_debugfs_slow_ring_trc_open,
 760         .llseek =       lpfc_debugfs_lseek,
 761         .read =         lpfc_debugfs_read,
 762         .release =      lpfc_debugfs_release,
 763 };
 764
 765 static struct dentry *lpfc_debugfs_root = NULL;
 766 static atomic_t lpfc_debugfs_hba_count;
 767 #endif
 768
 769 inline void
 770 lpfc_debugfs_initialize(struct lpfc_vport *vport)
 771 {
 772 #ifdef CONFIG_LPFC_DEBUG_FS
 773         struct lpfc_hba   *phba = vport->phba;
 774         char name[64];
 775         uint32_t num, i;
 776
 777         if (!lpfc_debugfs_enable)
 778                 return;
 779
 780         /* Setup lpfc root directory */
 781         if (!lpfc_debugfs_root) {
 782                 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
 783                 atomic_set(&lpfc_debugfs_hba_count, 0);
 784                 if (!lpfc_debugfs_root) {
 785                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 786                                          "0409 Cannot create debugfs root\n");
 787                         goto debug_failed;
 788                 }
 789         }
 790         if (!lpfc_debugfs_start_time)
 791                 lpfc_debugfs_start_time = jiffies;
 792
 793         /* Setup lpfcX directory for specific HBA */
 794         snprintf(name, sizeof(name), "lpfc%d", phba->brd_no);
 795         if (!phba->hba_debugfs_root) {
 796                 phba->hba_debugfs_root =
 797                         debugfs_create_dir(name, lpfc_debugfs_root);
 798                 if (!phba->hba_debugfs_root) {
 799                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 800                                          "0409 Cannot create debugfs hba\n");
 801                         goto debug_failed;
 802                 }
 803                 atomic_inc(&lpfc_debugfs_hba_count);
 804                 atomic_set(&phba->debugfs_vport_count, 0);
 805
 806                 /* Setup hbqinfo */
 807                 snprintf(name, sizeof(name), "hbqinfo");
 808                 phba->debug_hbqinfo =
 809                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
 810                                  phba->hba_debugfs_root,
 811                                  phba, &lpfc_debugfs_op_hbqinfo);
 812                 if (!phba->debug_hbqinfo) {
 813                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 814                                 "0409 Cannot create debugfs hbqinfo\n");
 815                         goto debug_failed;
 816                 }
 817
 818                 /* Setup dumpslim */
 819                 snprintf(name, sizeof(name), "dumpslim");
 820                 phba->debug_dumpslim =
 821                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
 822                                  phba->hba_debugfs_root,
 823                                  phba, &lpfc_debugfs_op_dumpslim);
 824                 if (!phba->debug_dumpslim) {
 825                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 826                                 "0409 Cannot create debugfs dumpslim\n");
 827                         goto debug_failed;
 828                 }
 829
 830                 /* Setup slow ring trace */
 831                 if (lpfc_debugfs_max_slow_ring_trc) {
 832                         num = lpfc_debugfs_max_slow_ring_trc - 1;
 833                         if (num & lpfc_debugfs_max_slow_ring_trc) {
 834                                 /* Change to be a power of 2 */
 835                                 num = lpfc_debugfs_max_slow_ring_trc;
 836                                 i = 0;
 837                                 while (num > 1) {
 838                                         num = num >> 1;
 839                                         i++;
 840                                 }
 841                                 lpfc_debugfs_max_slow_ring_trc = (1 << i);
 842                                 printk(KERN_ERR
 843                                        "lpfc_debugfs_max_disc_trc changed to "
 844                                        "%d\n", lpfc_debugfs_max_disc_trc);
 845                         }
 846                 }
 847
 848
 849                 snprintf(name, sizeof(name), "slow_ring_trace");
 850                 phba->debug_slow_ring_trc =
 851                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
 852                                  phba->hba_debugfs_root,
 853                                  phba, &lpfc_debugfs_op_slow_ring_trc);
 854                 if (!phba->debug_slow_ring_trc) {
 855                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 856                                          "0409 Cannot create debugfs "
 857                                          "slow_ring_trace\n");
 858                         goto debug_failed;
 859                 }
 860                 if (!phba->slow_ring_trc) {
 861                         phba->slow_ring_trc = kmalloc(
 862                                 (sizeof(struct lpfc_debugfs_trc) *
 863                                 lpfc_debugfs_max_slow_ring_trc),
 864                                 GFP_KERNEL);
 865                         if (!phba->slow_ring_trc) {
 866                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 867                                                  "0409 Cannot create debugfs "
 868                                                  "slow_ring buffer\n");
 869                                 goto debug_failed;
 870                         }
 871                         atomic_set(&phba->slow_ring_trc_cnt, 0);
 872                         memset(phba->slow_ring_trc, 0,
 873                                 (sizeof(struct lpfc_debugfs_trc) *
 874                                 lpfc_debugfs_max_slow_ring_trc));
 875                 }
 876         }
 877
 878         snprintf(name, sizeof(name), "vport%d", vport->vpi);
 879         if (!vport->vport_debugfs_root) {
 880                 vport->vport_debugfs_root =
 881                         debugfs_create_dir(name, phba->hba_debugfs_root);
 882                 if (!vport->vport_debugfs_root) {
 883                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 884                                          "0409 Cant create debugfs");
 885                         goto debug_failed;
 886                 }
 887                 atomic_inc(&phba->debugfs_vport_count);
 888         }
 889
 890         if (lpfc_debugfs_max_disc_trc) {
 891                 num = lpfc_debugfs_max_disc_trc - 1;
 892                 if (num & lpfc_debugfs_max_disc_trc) {
 893                         /* Change to be a power of 2 */
 894                         num = lpfc_debugfs_max_disc_trc;
 895                         i = 0;
 896                         while (num > 1) {
 897                                 num = num >> 1;
 898                                 i++;
 899                         }
 900                         lpfc_debugfs_max_disc_trc = (1 << i);
 901                         printk(KERN_ERR
 902                                "lpfc_debugfs_max_disc_trc changed to %d\n",
 903                                lpfc_debugfs_max_disc_trc);
 904                 }
 905         }
 906
 907         vport->disc_trc = kmalloc(
 908                 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
 909                 GFP_KERNEL);
 910
 911         if (!vport->disc_trc) {
 912                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 913                                  "0409 Cannot create debugfs disc trace "
 914                                  "buffer\n");
 915                 goto debug_failed;
 916         }
 917         atomic_set(&vport->disc_trc_cnt, 0);
 918         memset(vport->disc_trc, 0,
 919                 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc));
 920
 921         snprintf(name, sizeof(name), "discovery_trace");
 922         vport->debug_disc_trc =
 923                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
 924                                  vport->vport_debugfs_root,
 925                                  vport, &lpfc_debugfs_op_disc_trc);
 926         if (!vport->debug_disc_trc) {
 927                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 928                                  "0409 Cannot create debugfs "
 929                                  "discovery_trace\n");
 930                 goto debug_failed;
 931         }
 932         snprintf(name, sizeof(name), "nodelist");
 933         vport->debug_nodelist =
 934                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
 935                                  vport->vport_debugfs_root,
 936                                  vport, &lpfc_debugfs_op_nodelist);
 937         if (!vport->debug_nodelist) {
 938                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
 939                                  "0409 Cant create debugfs nodelist");
 940                 goto debug_failed;
 941         }
 942 debug_failed:
 943         return;
 944 #endif
 945 }
 946
 947
 948 inline void
 949 lpfc_debugfs_terminate(struct lpfc_vport *vport)
 950 {
 951 #ifdef CONFIG_LPFC_DEBUG_FS
 952         struct lpfc_hba   *phba = vport->phba;
 953
 954         if (vport->disc_trc) {
 955                 kfree(vport->disc_trc);
 956                 vport->disc_trc = NULL;
 957         }
 958         if (vport->debug_disc_trc) {
 959                 debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
 960                 vport->debug_disc_trc = NULL;
 961         }
 962         if (vport->debug_nodelist) {
 963                 debugfs_remove(vport->debug_nodelist); /* nodelist */
 964                 vport->debug_nodelist = NULL;
 965         }
 966
 967         if (vport->vport_debugfs_root) {
 968                 debugfs_remove(vport->vport_debugfs_root); /* vportX */
 969                 vport->vport_debugfs_root = NULL;
 970                 atomic_dec(&phba->debugfs_vport_count);
 971         }
 972         if (atomic_read(&phba->debugfs_vport_count) == 0) {
 973
 974                 if (phba->debug_hbqinfo) {
 975                         debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
 976                         phba->debug_hbqinfo = NULL;
 977                 }
 978                 if (phba->debug_dumpslim) {
 979                         debugfs_remove(phba->debug_dumpslim); /* dumpslim */
 980                         phba->debug_dumpslim = NULL;
 981                 }
 982                 if (phba->slow_ring_trc) {
 983                         kfree(phba->slow_ring_trc);
 984                         phba->slow_ring_trc = NULL;
 985                 }
 986                 if (phba->debug_slow_ring_trc) {
 987                         /* slow_ring_trace */
 988                         debugfs_remove(phba->debug_slow_ring_trc);
 989                         phba->debug_slow_ring_trc = NULL;
 990                 }
 991
 992                 if (phba->hba_debugfs_root) {
 993                         debugfs_remove(phba->hba_debugfs_root); /* lpfcX */
 994                         phba->hba_debugfs_root = NULL;
 995                         atomic_dec(&lpfc_debugfs_hba_count);
 996                 }
 997
 998                 if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
 999                         debugfs_remove(lpfc_debugfs_root); /* lpfc */
1000                         lpfc_debugfs_root = NULL;
1001                 }
1002         }
1003 #endif
1004         return;
1005 }
1006
1007