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