[SCSI] lpfc 8.3.1 : Fix up kernel-doc function comments
[linux-2.6.git] / 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-2008 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
31 #include <scsi/scsi.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_host.h>
34 #include <scsi/scsi_transport_fc.h>
35
36 #include "lpfc_hw.h"
37 #include "lpfc_sli.h"
38 #include "lpfc_nl.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_compat.h"
47 #include "lpfc_debugfs.h"
48
49 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
50 /*
51  * debugfs interface
52  *
53  * To access this interface the user should:
54  * # mkdir /debug
55  * # mount -t debugfs none /debug
56  *
57  * The lpfc debugfs directory hierarchy is:
58  * lpfc/lpfcX/vportY
59  * where X is the lpfc hba unique_id
60  * where Y is the vport VPI on that hba
61  *
62  * Debugging services available per vport:
63  * discovery_trace
64  * This is an ACSII readable file that contains a trace of the last
65  * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
66  * See lpfc_debugfs.h for different categories of  discovery events.
67  * To enable the discovery trace, the following 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  * slow_ring_trace
75  * This is an ACSII readable file that contains a trace of the last
76  * lpfc_debugfs_max_slow_ring_trc events that happened on a specific HBA.
77  * To enable the slow ring trace, the following module parameters must be set:
78  * lpfc_debugfs_enable=1         Turns on lpfc debugfs filesystem support
79  * lpfc_debugfs_max_slow_ring_trc=X   Where X is the event trace depth for
80  *                               the HBA. X MUST also be a power of 2.
81  */
82 static int lpfc_debugfs_enable = 1;
83 module_param(lpfc_debugfs_enable, int, 0);
84 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
85
86 /* This MUST be a power of 2 */
87 static int lpfc_debugfs_max_disc_trc;
88 module_param(lpfc_debugfs_max_disc_trc, int, 0);
89 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
90         "Set debugfs discovery trace depth");
91
92 /* This MUST be a power of 2 */
93 static int lpfc_debugfs_max_slow_ring_trc;
94 module_param(lpfc_debugfs_max_slow_ring_trc, int, 0);
95 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
96         "Set debugfs slow ring trace depth");
97
98 int lpfc_debugfs_mask_disc_trc;
99 module_param(lpfc_debugfs_mask_disc_trc, int, 0);
100 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
101         "Set debugfs discovery trace mask");
102
103 #include <linux/debugfs.h>
104
105 /* size of output line, for discovery_trace and slow_ring_trace */
106 #define LPFC_DEBUG_TRC_ENTRY_SIZE 100
107
108 /* nodelist output buffer size */
109 #define LPFC_NODELIST_SIZE 8192
110 #define LPFC_NODELIST_ENTRY_SIZE 120
111
112 /* dumpHBASlim output buffer size */
113 #define LPFC_DUMPHBASLIM_SIZE 4096
114
115 /* dumpHostSlim output buffer size */
116 #define LPFC_DUMPHOSTSLIM_SIZE 4096
117
118 /* hbqinfo output buffer size */
119 #define LPFC_HBQINFO_SIZE 8192
120
121 struct lpfc_debug {
122         char *buffer;
123         int  len;
124 };
125
126 static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
127 static unsigned long lpfc_debugfs_start_time = 0L;
128
129 /**
130  * lpfc_debugfs_disc_trc_data - Dump discovery logging to a buffer
131  * @vport: The vport to gather the log info from.
132  * @buf: The buffer to dump log into.
133  * @size: The maximum amount of data to process.
134  *
135  * Description:
136  * This routine gathers the lpfc discovery debugfs data from the @vport and
137  * dumps it to @buf up to @size number of bytes. It will start at the next entry
138  * in the log and process the log until the end of the buffer. Then it will
139  * gather from the beginning of the log and process until the current entry.
140  *
141  * Notes:
142  * Discovery logging will be disabled while while this routine dumps the log.
143  *
144  * Return Value:
145  * This routine returns the amount of bytes that were dumped into @buf and will
146  * not exceed @size.
147  **/
148 static int
149 lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
150 {
151         int i, index, len, enable;
152         uint32_t ms;
153         struct lpfc_debugfs_trc *dtp;
154         char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
155
156         enable = lpfc_debugfs_enable;
157         lpfc_debugfs_enable = 0;
158
159         len = 0;
160         index = (atomic_read(&vport->disc_trc_cnt) + 1) &
161                 (lpfc_debugfs_max_disc_trc - 1);
162         for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
163                 dtp = vport->disc_trc + i;
164                 if (!dtp->fmt)
165                         continue;
166                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
167                 snprintf(buffer,
168                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
169                         dtp->seq_cnt, ms, dtp->fmt);
170                 len +=  snprintf(buf+len, size-len, buffer,
171                         dtp->data1, dtp->data2, dtp->data3);
172         }
173         for (i = 0; i < index; i++) {
174                 dtp = vport->disc_trc + i;
175                 if (!dtp->fmt)
176                         continue;
177                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
178                 snprintf(buffer,
179                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
180                         dtp->seq_cnt, ms, dtp->fmt);
181                 len +=  snprintf(buf+len, size-len, buffer,
182                         dtp->data1, dtp->data2, dtp->data3);
183         }
184
185         lpfc_debugfs_enable = enable;
186         return len;
187 }
188
189 /**
190  * lpfc_debugfs_slow_ring_trc_data - Dump slow ring logging to a buffer
191  * @phba: The HBA to gather the log info from.
192  * @buf: The buffer to dump log into.
193  * @size: The maximum amount of data to process.
194  *
195  * Description:
196  * This routine gathers the lpfc slow ring debugfs data from the @phba and
197  * dumps it to @buf up to @size number of bytes. It will start at the next entry
198  * in the log and process the log until the end of the buffer. Then it will
199  * gather from the beginning of the log and process until the current entry.
200  *
201  * Notes:
202  * Slow ring logging will be disabled while while this routine dumps the log.
203  *
204  * Return Value:
205  * This routine returns the amount of bytes that were dumped into @buf and will
206  * not exceed @size.
207  **/
208 static int
209 lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
210 {
211         int i, index, len, enable;
212         uint32_t ms;
213         struct lpfc_debugfs_trc *dtp;
214         char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
215
216
217         enable = lpfc_debugfs_enable;
218         lpfc_debugfs_enable = 0;
219
220         len = 0;
221         index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
222                 (lpfc_debugfs_max_slow_ring_trc - 1);
223         for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
224                 dtp = phba->slow_ring_trc + i;
225                 if (!dtp->fmt)
226                         continue;
227                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
228                 snprintf(buffer,
229                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
230                         dtp->seq_cnt, ms, dtp->fmt);
231                 len +=  snprintf(buf+len, size-len, buffer,
232                         dtp->data1, dtp->data2, dtp->data3);
233         }
234         for (i = 0; i < index; i++) {
235                 dtp = phba->slow_ring_trc + i;
236                 if (!dtp->fmt)
237                         continue;
238                 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
239                 snprintf(buffer,
240                         LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
241                         dtp->seq_cnt, ms, dtp->fmt);
242                 len +=  snprintf(buf+len, size-len, buffer,
243                         dtp->data1, dtp->data2, dtp->data3);
244         }
245
246         lpfc_debugfs_enable = enable;
247         return len;
248 }
249
250 static int lpfc_debugfs_last_hbq = -1;
251
252 /**
253  * lpfc_debugfs_hbqinfo_data - Dump host buffer queue info to a buffer
254  * @phba: The HBA to gather host buffer info from.
255  * @buf: The buffer to dump log into.
256  * @size: The maximum amount of data to process.
257  *
258  * Description:
259  * This routine dumps the host buffer queue info from the @phba to @buf up to
260  * @size number of bytes. A header that describes the current hbq state will be
261  * dumped to @buf first and then info on each hbq entry will be dumped to @buf
262  * until @size bytes have been dumped or all the hbq info has been dumped.
263  *
264  * Notes:
265  * This routine will rotate through each configured HBQ each time called.
266  *
267  * Return Value:
268  * This routine returns the amount of bytes that were dumped into @buf and will
269  * not exceed @size.
270  **/
271 static int
272 lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
273 {
274         int len = 0;
275         int cnt, i, j, found, posted, low;
276         uint32_t phys, raw_index, getidx;
277         struct lpfc_hbq_init *hip;
278         struct hbq_s *hbqs;
279         struct lpfc_hbq_entry *hbqe;
280         struct lpfc_dmabuf *d_buf;
281         struct hbq_dmabuf *hbq_buf;
282
283         cnt = LPFC_HBQINFO_SIZE;
284         spin_lock_irq(&phba->hbalock);
285
286         /* toggle between multiple hbqs, if any */
287         i = lpfc_sli_hbq_count();
288         if (i > 1) {
289                  lpfc_debugfs_last_hbq++;
290                  if (lpfc_debugfs_last_hbq >= i)
291                         lpfc_debugfs_last_hbq = 0;
292         }
293         else
294                 lpfc_debugfs_last_hbq = 0;
295
296         i = lpfc_debugfs_last_hbq;
297
298         len +=  snprintf(buf+len, size-len, "HBQ %d Info\n", i);
299
300         hbqs =  &phba->hbqs[i];
301         posted = 0;
302         list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list)
303                 posted++;
304
305         hip =  lpfc_hbq_defs[i];
306         len +=  snprintf(buf+len, size-len,
307                 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
308                 hip->hbq_index, hip->profile, hip->rn,
309                 hip->buffer_count, hip->init_count, hip->add_count, posted);
310
311         raw_index = phba->hbq_get[i];
312         getidx = le32_to_cpu(raw_index);
313         len +=  snprintf(buf+len, size-len,
314                 "entrys:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
315                 hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx,
316                 hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx);
317
318         hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
319         for (j=0; j<hbqs->entry_count; j++) {
320                 len +=  snprintf(buf+len, size-len,
321                         "%03d: %08x %04x %05x ", j,
322                         le32_to_cpu(hbqe->bde.addrLow),
323                         le32_to_cpu(hbqe->bde.tus.w),
324                         le32_to_cpu(hbqe->buffer_tag));
325                 i = 0;
326                 found = 0;
327
328                 /* First calculate if slot has an associated posted buffer */
329                 low = hbqs->hbqPutIdx - posted;
330                 if (low >= 0) {
331                         if ((j >= hbqs->hbqPutIdx) || (j < low)) {
332                                 len +=  snprintf(buf+len, size-len, "Unused\n");
333                                 goto skipit;
334                         }
335                 }
336                 else {
337                         if ((j >= hbqs->hbqPutIdx) &&
338                                 (j < (hbqs->entry_count+low))) {
339                                 len +=  snprintf(buf+len, size-len, "Unused\n");
340                                 goto skipit;
341                         }
342                 }
343
344                 /* Get the Buffer info for the posted buffer */
345                 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) {
346                         hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
347                         phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
348                         if (phys == le32_to_cpu(hbqe->bde.addrLow)) {
349                                 len +=  snprintf(buf+len, size-len,
350                                         "Buf%d: %p %06x\n", i,
351                                         hbq_buf->dbuf.virt, hbq_buf->tag);
352                                 found = 1;
353                                 break;
354                         }
355                         i++;
356                 }
357                 if (!found) {
358                         len +=  snprintf(buf+len, size-len, "No DMAinfo?\n");
359                 }
360 skipit:
361                 hbqe++;
362                 if (len > LPFC_HBQINFO_SIZE - 54)
363                         break;
364         }
365         spin_unlock_irq(&phba->hbalock);
366         return len;
367 }
368
369 static int lpfc_debugfs_last_hba_slim_off;
370
371 /**
372  * lpfc_debugfs_dumpHBASlim_data - Dump HBA SLIM info to a buffer
373  * @phba: The HBA to gather SLIM info from.
374  * @buf: The buffer to dump log into.
375  * @size: The maximum amount of data to process.
376  *
377  * Description:
378  * This routine dumps the current contents of HBA SLIM for the HBA associated
379  * with @phba to @buf up to @size bytes of data. This is the raw HBA SLIM data.
380  *
381  * Notes:
382  * This routine will only dump up to 1024 bytes of data each time called and
383  * should be called multiple times to dump the entire HBA SLIM.
384  *
385  * Return Value:
386  * This routine returns the amount of bytes that were dumped into @buf and will
387  * not exceed @size.
388  **/
389 static int
390 lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
391 {
392         int len = 0;
393         int i, off;
394         uint32_t *ptr;
395         char buffer[1024];
396
397         off = 0;
398         spin_lock_irq(&phba->hbalock);
399
400         len +=  snprintf(buf+len, size-len, "HBA SLIM\n");
401         lpfc_memcpy_from_slim(buffer,
402                 ((uint8_t *)phba->MBslimaddr) + lpfc_debugfs_last_hba_slim_off,
403                 1024);
404
405         ptr = (uint32_t *)&buffer[0];
406         off = lpfc_debugfs_last_hba_slim_off;
407
408         /* Set it up for the next time */
409         lpfc_debugfs_last_hba_slim_off += 1024;
410         if (lpfc_debugfs_last_hba_slim_off >= 4096)
411                 lpfc_debugfs_last_hba_slim_off = 0;
412
413         i = 1024;
414         while (i > 0) {
415                 len +=  snprintf(buf+len, size-len,
416                 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
417                 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
418                 *(ptr+5), *(ptr+6), *(ptr+7));
419                 ptr += 8;
420                 i -= (8 * sizeof(uint32_t));
421                 off += (8 * sizeof(uint32_t));
422         }
423
424         spin_unlock_irq(&phba->hbalock);
425         return len;
426 }
427
428 /**
429  * lpfc_debugfs_dumpHostSlim_data - Dump host SLIM info to a buffer
430  * @phba: The HBA to gather Host SLIM info from.
431  * @buf: The buffer to dump log into.
432  * @size: The maximum amount of data to process.
433  *
434  * Description:
435  * This routine dumps the current contents of host SLIM for the host associated
436  * with @phba to @buf up to @size bytes of data. The dump will contain the
437  * Mailbox, PCB, Rings, and Registers that are located in host memory.
438  *
439  * Return Value:
440  * This routine returns the amount of bytes that were dumped into @buf and will
441  * not exceed @size.
442  **/
443 static int
444 lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
445 {
446         int len = 0;
447         int i, off;
448         uint32_t word0, word1, word2, word3;
449         uint32_t *ptr;
450         struct lpfc_pgp *pgpp;
451         struct lpfc_sli *psli = &phba->sli;
452         struct lpfc_sli_ring *pring;
453
454         off = 0;
455         spin_lock_irq(&phba->hbalock);
456
457         len +=  snprintf(buf+len, size-len, "SLIM Mailbox\n");
458         ptr = (uint32_t *)phba->slim2p.virt;
459         i = sizeof(MAILBOX_t);
460         while (i > 0) {
461                 len +=  snprintf(buf+len, size-len,
462                 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
463                 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
464                 *(ptr+5), *(ptr+6), *(ptr+7));
465                 ptr += 8;
466                 i -= (8 * sizeof(uint32_t));
467                 off += (8 * sizeof(uint32_t));
468         }
469
470         len +=  snprintf(buf+len, size-len, "SLIM PCB\n");
471         ptr = (uint32_t *)phba->pcb;
472         i = sizeof(PCB_t);
473         while (i > 0) {
474                 len +=  snprintf(buf+len, size-len,
475                 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
476                 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
477                 *(ptr+5), *(ptr+6), *(ptr+7));
478                 ptr += 8;
479                 i -= (8 * sizeof(uint32_t));
480                 off += (8 * sizeof(uint32_t));
481         }
482
483         for (i = 0; i < 4; i++) {
484                 pgpp = &phba->port_gp[i];
485                 pring = &psli->ring[i];
486                 len +=  snprintf(buf+len, size-len,
487                                  "Ring %d: CMD GetInx:%d (Max:%d Next:%d "
488                                  "Local:%d flg:x%x)  RSP PutInx:%d Max:%d\n",
489                                  i, pgpp->cmdGetInx, pring->numCiocb,
490                                  pring->next_cmdidx, pring->local_getidx,
491                                  pring->flag, pgpp->rspPutInx, pring->numRiocb);
492         }
493         word0 = readl(phba->HAregaddr);
494         word1 = readl(phba->CAregaddr);
495         word2 = readl(phba->HSregaddr);
496         word3 = readl(phba->HCregaddr);
497         len +=  snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x HC:%08x\n",
498         word0, word1, word2, word3);
499         spin_unlock_irq(&phba->hbalock);
500         return len;
501 }
502
503 /**
504  * lpfc_debugfs_nodelist_data - Dump target node list to a buffer
505  * @vport: The vport to gather target node info from.
506  * @buf: The buffer to dump log into.
507  * @size: The maximum amount of data to process.
508  *
509  * Description:
510  * This routine dumps the current target node list associated with @vport to
511  * @buf up to @size bytes of data. Each node entry in the dump will contain a
512  * node state, DID, WWPN, WWNN, RPI, flags, type, and other useful fields.
513  *
514  * Return Value:
515  * This routine returns the amount of bytes that were dumped into @buf and will
516  * not exceed @size.
517  **/
518 static int
519 lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
520 {
521         int len = 0;
522         int cnt;
523         struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
524         struct lpfc_nodelist *ndlp;
525         unsigned char *statep, *name;
526
527         cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
528
529         spin_lock_irq(shost->host_lock);
530         list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
531                 if (!cnt) {
532                         len +=  snprintf(buf+len, size-len,
533                                 "Missing Nodelist Entries\n");
534                         break;
535                 }
536                 cnt--;
537                 switch (ndlp->nlp_state) {
538                 case NLP_STE_UNUSED_NODE:
539                         statep = "UNUSED";
540                         break;
541                 case NLP_STE_PLOGI_ISSUE:
542                         statep = "PLOGI ";
543                         break;
544                 case NLP_STE_ADISC_ISSUE:
545                         statep = "ADISC ";
546                         break;
547                 case NLP_STE_REG_LOGIN_ISSUE:
548                         statep = "REGLOG";
549                         break;
550                 case NLP_STE_PRLI_ISSUE:
551                         statep = "PRLI  ";
552                         break;
553                 case NLP_STE_UNMAPPED_NODE:
554                         statep = "UNMAP ";
555                         break;
556                 case NLP_STE_MAPPED_NODE:
557                         statep = "MAPPED";
558                         break;
559                 case NLP_STE_NPR_NODE:
560                         statep = "NPR   ";
561                         break;
562                 default:
563                         statep = "UNKNOWN";
564                 }
565                 len +=  snprintf(buf+len, size-len, "%s DID:x%06x ",
566                         statep, ndlp->nlp_DID);
567                 name = (unsigned char *)&ndlp->nlp_portname;
568                 len +=  snprintf(buf+len, size-len,
569                         "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
570                         *name, *(name+1), *(name+2), *(name+3),
571                         *(name+4), *(name+5), *(name+6), *(name+7));
572                 name = (unsigned char *)&ndlp->nlp_nodename;
573                 len +=  snprintf(buf+len, size-len,
574                         "WWNN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
575                         *name, *(name+1), *(name+2), *(name+3),
576                         *(name+4), *(name+5), *(name+6), *(name+7));
577                 len +=  snprintf(buf+len, size-len, "RPI:%03d flag:x%08x ",
578                         ndlp->nlp_rpi, ndlp->nlp_flag);
579                 if (!ndlp->nlp_type)
580                         len +=  snprintf(buf+len, size-len, "UNKNOWN_TYPE ");
581                 if (ndlp->nlp_type & NLP_FC_NODE)
582                         len +=  snprintf(buf+len, size-len, "FC_NODE ");
583                 if (ndlp->nlp_type & NLP_FABRIC)
584                         len +=  snprintf(buf+len, size-len, "FABRIC ");
585                 if (ndlp->nlp_type & NLP_FCP_TARGET)
586                         len +=  snprintf(buf+len, size-len, "FCP_TGT sid:%d ",
587                                 ndlp->nlp_sid);
588                 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
589                         len +=  snprintf(buf+len, size-len, "FCP_INITIATOR ");
590                 len += snprintf(buf+len, size-len, "usgmap:%x ",
591                         ndlp->nlp_usg_map);
592                 len += snprintf(buf+len, size-len, "refcnt:%x",
593                         atomic_read(&ndlp->kref.refcount));
594                 len +=  snprintf(buf+len, size-len, "\n");
595         }
596         spin_unlock_irq(shost->host_lock);
597         return len;
598 }
599 #endif
600
601 /**
602  * lpfc_debugfs_disc_trc - Store discovery trace log
603  * @vport: The vport to associate this trace string with for retrieval.
604  * @mask: Log entry classification.
605  * @fmt: Format string to be displayed when dumping the log.
606  * @data1: 1st data parameter to be applied to @fmt.
607  * @data2: 2nd data parameter to be applied to @fmt.
608  * @data3: 3rd data parameter to be applied to @fmt.
609  *
610  * Description:
611  * This routine is used by the driver code to add a debugfs log entry to the
612  * discovery trace buffer associated with @vport. Only entries with a @mask that
613  * match the current debugfs discovery mask will be saved. Entries that do not
614  * match will be thrown away. @fmt, @data1, @data2, and @data3 are used like
615  * printf when displaying the log.
616  **/
617 inline void
618 lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
619         uint32_t data1, uint32_t data2, uint32_t data3)
620 {
621 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
622         struct lpfc_debugfs_trc *dtp;
623         int index;
624
625         if (!(lpfc_debugfs_mask_disc_trc & mask))
626                 return;
627
628         if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
629                 !vport || !vport->disc_trc)
630                 return;
631
632         index = atomic_inc_return(&vport->disc_trc_cnt) &
633                 (lpfc_debugfs_max_disc_trc - 1);
634         dtp = vport->disc_trc + index;
635         dtp->fmt = fmt;
636         dtp->data1 = data1;
637         dtp->data2 = data2;
638         dtp->data3 = data3;
639         dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
640         dtp->jif = jiffies;
641 #endif
642         return;
643 }
644
645 /**
646  * lpfc_debugfs_slow_ring_trc - Store slow ring trace log
647  * @phba: The phba to associate this trace string with for retrieval.
648  * @fmt: Format string to be displayed when dumping the log.
649  * @data1: 1st data parameter to be applied to @fmt.
650  * @data2: 2nd data parameter to be applied to @fmt.
651  * @data3: 3rd data parameter to be applied to @fmt.
652  *
653  * Description:
654  * This routine is used by the driver code to add a debugfs log entry to the
655  * discovery trace buffer associated with @vport. @fmt, @data1, @data2, and
656  * @data3 are used like printf when displaying the log.
657  **/
658 inline void
659 lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
660         uint32_t data1, uint32_t data2, uint32_t data3)
661 {
662 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
663         struct lpfc_debugfs_trc *dtp;
664         int index;
665
666         if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
667                 !phba || !phba->slow_ring_trc)
668                 return;
669
670         index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
671                 (lpfc_debugfs_max_slow_ring_trc - 1);
672         dtp = phba->slow_ring_trc + index;
673         dtp->fmt = fmt;
674         dtp->data1 = data1;
675         dtp->data2 = data2;
676         dtp->data3 = data3;
677         dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
678         dtp->jif = jiffies;
679 #endif
680         return;
681 }
682
683 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
684 /**
685  * lpfc_debugfs_disc_trc_open - Open the discovery trace log
686  * @inode: The inode pointer that contains a vport pointer.
687  * @file: The file pointer to attach the log output.
688  *
689  * Description:
690  * This routine is the entry point for the debugfs open file operation. It gets
691  * the vport from the i_private field in @inode, allocates the necessary buffer
692  * for the log, fills the buffer from the in-memory log for this vport, and then
693  * returns a pointer to that log in the private_data field in @file.
694  *
695  * Returns:
696  * This function returns zero if successful. On error it will return an negative
697  * error value.
698  **/
699 static int
700 lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
701 {
702         struct lpfc_vport *vport = inode->i_private;
703         struct lpfc_debug *debug;
704         int size;
705         int rc = -ENOMEM;
706
707         if (!lpfc_debugfs_max_disc_trc) {
708                  rc = -ENOSPC;
709                 goto out;
710         }
711
712         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
713         if (!debug)
714                 goto out;
715
716         /* Round to page boundary */
717         size =  (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
718         size = PAGE_ALIGN(size);
719
720         debug->buffer = kmalloc(size, GFP_KERNEL);
721         if (!debug->buffer) {
722                 kfree(debug);
723                 goto out;
724         }
725
726         debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
727         file->private_data = debug;
728
729         rc = 0;
730 out:
731         return rc;
732 }
733
734 /**
735  * lpfc_debugfs_slow_ring_trc_open - Open the Slow Ring trace log
736  * @inode: The inode pointer that contains a vport pointer.
737  * @file: The file pointer to attach the log output.
738  *
739  * Description:
740  * This routine is the entry point for the debugfs open file operation. It gets
741  * the vport from the i_private field in @inode, allocates the necessary buffer
742  * for the log, fills the buffer from the in-memory log for this vport, and then
743  * returns a pointer to that log in the private_data field in @file.
744  *
745  * Returns:
746  * This function returns zero if successful. On error it will return an negative
747  * error value.
748  **/
749 static int
750 lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
751 {
752         struct lpfc_hba *phba = inode->i_private;
753         struct lpfc_debug *debug;
754         int size;
755         int rc = -ENOMEM;
756
757         if (!lpfc_debugfs_max_slow_ring_trc) {
758                  rc = -ENOSPC;
759                 goto out;
760         }
761
762         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
763         if (!debug)
764                 goto out;
765
766         /* Round to page boundary */
767         size =  (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
768         size = PAGE_ALIGN(size);
769
770         debug->buffer = kmalloc(size, GFP_KERNEL);
771         if (!debug->buffer) {
772                 kfree(debug);
773                 goto out;
774         }
775
776         debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
777         file->private_data = debug;
778
779         rc = 0;
780 out:
781         return rc;
782 }
783
784 /**
785  * lpfc_debugfs_hbqinfo_open - Open the hbqinfo debugfs buffer
786  * @inode: The inode pointer that contains a vport pointer.
787  * @file: The file pointer to attach the log output.
788  *
789  * Description:
790  * This routine is the entry point for the debugfs open file operation. It gets
791  * the vport from the i_private field in @inode, allocates the necessary buffer
792  * for the log, fills the buffer from the in-memory log for this vport, and then
793  * returns a pointer to that log in the private_data field in @file.
794  *
795  * Returns:
796  * This function returns zero if successful. On error it will return an negative
797  * error value.
798  **/
799 static int
800 lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
801 {
802         struct lpfc_hba *phba = inode->i_private;
803         struct lpfc_debug *debug;
804         int rc = -ENOMEM;
805
806         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
807         if (!debug)
808                 goto out;
809
810         /* Round to page boundary */
811         debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
812         if (!debug->buffer) {
813                 kfree(debug);
814                 goto out;
815         }
816
817         debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
818                 LPFC_HBQINFO_SIZE);
819         file->private_data = debug;
820
821         rc = 0;
822 out:
823         return rc;
824 }
825
826 /**
827  * lpfc_debugfs_dumpHBASlim_open - Open the Dump HBA SLIM debugfs buffer
828  * @inode: The inode pointer that contains a vport pointer.
829  * @file: The file pointer to attach the log output.
830  *
831  * Description:
832  * This routine is the entry point for the debugfs open file operation. It gets
833  * the vport from the i_private field in @inode, allocates the necessary buffer
834  * for the log, fills the buffer from the in-memory log for this vport, and then
835  * returns a pointer to that log in the private_data field in @file.
836  *
837  * Returns:
838  * This function returns zero if successful. On error it will return an negative
839  * error value.
840  **/
841 static int
842 lpfc_debugfs_dumpHBASlim_open(struct inode *inode, struct file *file)
843 {
844         struct lpfc_hba *phba = inode->i_private;
845         struct lpfc_debug *debug;
846         int rc = -ENOMEM;
847
848         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
849         if (!debug)
850                 goto out;
851
852         /* Round to page boundary */
853         debug->buffer = kmalloc(LPFC_DUMPHBASLIM_SIZE, GFP_KERNEL);
854         if (!debug->buffer) {
855                 kfree(debug);
856                 goto out;
857         }
858
859         debug->len = lpfc_debugfs_dumpHBASlim_data(phba, debug->buffer,
860                 LPFC_DUMPHBASLIM_SIZE);
861         file->private_data = debug;
862
863         rc = 0;
864 out:
865         return rc;
866 }
867
868 /**
869  * lpfc_debugfs_dumpHostSlim_open - Open the Dump Host SLIM debugfs buffer
870  * @inode: The inode pointer that contains a vport pointer.
871  * @file: The file pointer to attach the log output.
872  *
873  * Description:
874  * This routine is the entry point for the debugfs open file operation. It gets
875  * the vport from the i_private field in @inode, allocates the necessary buffer
876  * for the log, fills the buffer from the in-memory log for this vport, and then
877  * returns a pointer to that log in the private_data field in @file.
878  *
879  * Returns:
880  * This function returns zero if successful. On error it will return an negative
881  * error value.
882  **/
883 static int
884 lpfc_debugfs_dumpHostSlim_open(struct inode *inode, struct file *file)
885 {
886         struct lpfc_hba *phba = inode->i_private;
887         struct lpfc_debug *debug;
888         int rc = -ENOMEM;
889
890         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
891         if (!debug)
892                 goto out;
893
894         /* Round to page boundary */
895         debug->buffer = kmalloc(LPFC_DUMPHOSTSLIM_SIZE, GFP_KERNEL);
896         if (!debug->buffer) {
897                 kfree(debug);
898                 goto out;
899         }
900
901         debug->len = lpfc_debugfs_dumpHostSlim_data(phba, debug->buffer,
902                 LPFC_DUMPHOSTSLIM_SIZE);
903         file->private_data = debug;
904
905         rc = 0;
906 out:
907         return rc;
908 }
909
910 static int
911 lpfc_debugfs_dumpData_open(struct inode *inode, struct file *file)
912 {
913         struct lpfc_debug *debug;
914         int rc = -ENOMEM;
915
916         if (!_dump_buf_data)
917                 return -EBUSY;
918
919         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
920         if (!debug)
921                 goto out;
922
923         /* Round to page boundry */
924         printk(KERN_ERR "BLKGRD %s: _dump_buf_data=0x%p\n",
925                         __func__, _dump_buf_data);
926         debug->buffer = _dump_buf_data;
927         if (!debug->buffer) {
928                 kfree(debug);
929                 goto out;
930         }
931
932         debug->len = (1 << _dump_buf_data_order) << PAGE_SHIFT;
933         file->private_data = debug;
934
935         rc = 0;
936 out:
937         return rc;
938 }
939
940 static int
941 lpfc_debugfs_dumpDif_open(struct inode *inode, struct file *file)
942 {
943         struct lpfc_debug *debug;
944         int rc = -ENOMEM;
945
946         if (!_dump_buf_dif)
947                 return -EBUSY;
948
949         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
950         if (!debug)
951                 goto out;
952
953         /* Round to page boundry */
954         printk(KERN_ERR "BLKGRD %s: _dump_buf_dif=0x%p file=%s\n", __func__,
955                _dump_buf_dif, file->f_dentry->d_name.name);
956         debug->buffer = _dump_buf_dif;
957         if (!debug->buffer) {
958                 kfree(debug);
959                 goto out;
960         }
961
962         debug->len = (1 << _dump_buf_dif_order) << PAGE_SHIFT;
963         file->private_data = debug;
964
965         rc = 0;
966 out:
967         return rc;
968 }
969
970 static ssize_t
971 lpfc_debugfs_dumpDataDif_write(struct file *file, const char __user *buf,
972                   size_t nbytes, loff_t *ppos)
973 {
974         /*
975          * The Data/DIF buffers only save one failing IO
976          * The write op is used as a reset mechanism after an IO has
977          * already been saved to the next one can be saved
978          */
979         spin_lock(&_dump_buf_lock);
980
981         memset((void *)_dump_buf_data, 0,
982                         ((1 << PAGE_SHIFT) << _dump_buf_data_order));
983         memset((void *)_dump_buf_dif, 0,
984                         ((1 << PAGE_SHIFT) << _dump_buf_dif_order));
985
986         _dump_buf_done = 0;
987
988         spin_unlock(&_dump_buf_lock);
989
990         return nbytes;
991 }
992
993
994
995 /**
996  * lpfc_debugfs_nodelist_open - Open the nodelist debugfs file
997  * @inode: The inode pointer that contains a vport pointer.
998  * @file: The file pointer to attach the log output.
999  *
1000  * Description:
1001  * This routine is the entry point for the debugfs open file operation. It gets
1002  * the vport from the i_private field in @inode, allocates the necessary buffer
1003  * for the log, fills the buffer from the in-memory log for this vport, and then
1004  * returns a pointer to that log in the private_data field in @file.
1005  *
1006  * Returns:
1007  * This function returns zero if successful. On error it will return an negative
1008  * error value.
1009  **/
1010 static int
1011 lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
1012 {
1013         struct lpfc_vport *vport = inode->i_private;
1014         struct lpfc_debug *debug;
1015         int rc = -ENOMEM;
1016
1017         debug = kmalloc(sizeof(*debug), GFP_KERNEL);
1018         if (!debug)
1019                 goto out;
1020
1021         /* Round to page boundary */
1022         debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
1023         if (!debug->buffer) {
1024                 kfree(debug);
1025                 goto out;
1026         }
1027
1028         debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
1029                 LPFC_NODELIST_SIZE);
1030         file->private_data = debug;
1031
1032         rc = 0;
1033 out:
1034         return rc;
1035 }
1036
1037 /**
1038  * lpfc_debugfs_lseek - Seek through a debugfs file
1039  * @file: The file pointer to seek through.
1040  * @off: The offset to seek to or the amount to seek by.
1041  * @whence: Indicates how to seek.
1042  *
1043  * Description:
1044  * This routine is the entry point for the debugfs lseek file operation. The
1045  * @whence parameter indicates whether @off is the offset to directly seek to,
1046  * or if it is a value to seek forward or reverse by. This function figures out
1047  * what the new offset of the debugfs file will be and assigns that value to the
1048  * f_pos field of @file.
1049  *
1050  * Returns:
1051  * This function returns the new offset if successful and returns a negative
1052  * error if unable to process the seek.
1053  **/
1054 static loff_t
1055 lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
1056 {
1057         struct lpfc_debug *debug;
1058         loff_t pos = -1;
1059
1060         debug = file->private_data;
1061
1062         switch (whence) {
1063         case 0:
1064                 pos = off;
1065                 break;
1066         case 1:
1067                 pos = file->f_pos + off;
1068                 break;
1069         case 2:
1070                 pos = debug->len - off;
1071         }
1072         return (pos < 0 || pos > debug->len) ? -EINVAL : (file->f_pos = pos);
1073 }
1074
1075 /**
1076  * lpfc_debugfs_read - Read a debugfs file
1077  * @file: The file pointer to read from.
1078  * @buf: The buffer to copy the data to.
1079  * @nbytes: The number of bytes to read.
1080  * @ppos: The position in the file to start reading from.
1081  *
1082  * Description:
1083  * This routine reads data from from the buffer indicated in the private_data
1084  * field of @file. It will start reading at @ppos and copy up to @nbytes of
1085  * data to @buf.
1086  *
1087  * Returns:
1088  * This function returns the amount of data that was read (this could be less
1089  * than @nbytes if the end of the file was reached) or a negative error value.
1090  **/
1091 static ssize_t
1092 lpfc_debugfs_read(struct file *file, char __user *buf,
1093                   size_t nbytes, loff_t *ppos)
1094 {
1095         struct lpfc_debug *debug = file->private_data;
1096         return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
1097                                        debug->len);
1098 }
1099
1100 /**
1101  * lpfc_debugfs_release - Release the buffer used to store debugfs file data
1102  * @inode: The inode pointer that contains a vport pointer. (unused)
1103  * @file: The file pointer that contains the buffer to release.
1104  *
1105  * Description:
1106  * This routine frees the buffer that was allocated when the debugfs file was
1107  * opened.
1108  *
1109  * Returns:
1110  * This function returns zero.
1111  **/
1112 static int
1113 lpfc_debugfs_release(struct inode *inode, struct file *file)
1114 {
1115         struct lpfc_debug *debug = file->private_data;
1116
1117         kfree(debug->buffer);
1118         kfree(debug);
1119
1120         return 0;
1121 }
1122
1123 static int
1124 lpfc_debugfs_dumpDataDif_release(struct inode *inode, struct file *file)
1125 {
1126         struct lpfc_debug *debug = file->private_data;
1127
1128         debug->buffer = NULL;
1129         kfree(debug);
1130
1131         return 0;
1132 }
1133
1134 #undef lpfc_debugfs_op_disc_trc
1135 static const struct file_operations lpfc_debugfs_op_disc_trc = {
1136         .owner =        THIS_MODULE,
1137         .open =         lpfc_debugfs_disc_trc_open,
1138         .llseek =       lpfc_debugfs_lseek,
1139         .read =         lpfc_debugfs_read,
1140         .release =      lpfc_debugfs_release,
1141 };
1142
1143 #undef lpfc_debugfs_op_nodelist
1144 static const struct file_operations lpfc_debugfs_op_nodelist = {
1145         .owner =        THIS_MODULE,
1146         .open =         lpfc_debugfs_nodelist_open,
1147         .llseek =       lpfc_debugfs_lseek,
1148         .read =         lpfc_debugfs_read,
1149         .release =      lpfc_debugfs_release,
1150 };
1151
1152 #undef lpfc_debugfs_op_hbqinfo
1153 static const struct file_operations lpfc_debugfs_op_hbqinfo = {
1154         .owner =        THIS_MODULE,
1155         .open =         lpfc_debugfs_hbqinfo_open,
1156         .llseek =       lpfc_debugfs_lseek,
1157         .read =         lpfc_debugfs_read,
1158         .release =      lpfc_debugfs_release,
1159 };
1160
1161 #undef lpfc_debugfs_op_dumpHBASlim
1162 static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {
1163         .owner =        THIS_MODULE,
1164         .open =         lpfc_debugfs_dumpHBASlim_open,
1165         .llseek =       lpfc_debugfs_lseek,
1166         .read =         lpfc_debugfs_read,
1167         .release =      lpfc_debugfs_release,
1168 };
1169
1170 #undef lpfc_debugfs_op_dumpHostSlim
1171 static const struct file_operations lpfc_debugfs_op_dumpHostSlim = {
1172         .owner =        THIS_MODULE,
1173         .open =         lpfc_debugfs_dumpHostSlim_open,
1174         .llseek =       lpfc_debugfs_lseek,
1175         .read =         lpfc_debugfs_read,
1176         .release =      lpfc_debugfs_release,
1177 };
1178
1179 #undef lpfc_debugfs_op_dumpData
1180 static const struct file_operations lpfc_debugfs_op_dumpData = {
1181         .owner =        THIS_MODULE,
1182         .open =         lpfc_debugfs_dumpData_open,
1183         .llseek =       lpfc_debugfs_lseek,
1184         .read =         lpfc_debugfs_read,
1185         .write =        lpfc_debugfs_dumpDataDif_write,
1186         .release =      lpfc_debugfs_dumpDataDif_release,
1187 };
1188
1189 #undef lpfc_debugfs_op_dumpDif
1190 static const struct file_operations lpfc_debugfs_op_dumpDif = {
1191         .owner =        THIS_MODULE,
1192         .open =         lpfc_debugfs_dumpDif_open,
1193         .llseek =       lpfc_debugfs_lseek,
1194         .read =         lpfc_debugfs_read,
1195         .write =        lpfc_debugfs_dumpDataDif_write,
1196         .release =      lpfc_debugfs_dumpDataDif_release,
1197 };
1198
1199 #undef lpfc_debugfs_op_slow_ring_trc
1200 static const struct file_operations lpfc_debugfs_op_slow_ring_trc = {
1201         .owner =        THIS_MODULE,
1202         .open =         lpfc_debugfs_slow_ring_trc_open,
1203         .llseek =       lpfc_debugfs_lseek,
1204         .read =         lpfc_debugfs_read,
1205         .release =      lpfc_debugfs_release,
1206 };
1207
1208 static struct dentry *lpfc_debugfs_root = NULL;
1209 static atomic_t lpfc_debugfs_hba_count;
1210 #endif
1211
1212 /**
1213  * lpfc_debugfs_initialize - Initialize debugfs for a vport
1214  * @vport: The vport pointer to initialize.
1215  *
1216  * Description:
1217  * When Debugfs is configured this routine sets up the lpfc debugfs file system.
1218  * If not already created, this routine will create the lpfc directory, and
1219  * lpfcX directory (for this HBA), and vportX directory for this vport. It will
1220  * also create each file used to access lpfc specific debugfs information.
1221  **/
1222 inline void
1223 lpfc_debugfs_initialize(struct lpfc_vport *vport)
1224 {
1225 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1226         struct lpfc_hba   *phba = vport->phba;
1227         char name[64];
1228         uint32_t num, i;
1229
1230         if (!lpfc_debugfs_enable)
1231                 return;
1232
1233         /* Setup lpfc root directory */
1234         if (!lpfc_debugfs_root) {
1235                 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
1236                 atomic_set(&lpfc_debugfs_hba_count, 0);
1237                 if (!lpfc_debugfs_root) {
1238                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1239                                          "0408 Cannot create debugfs root\n");
1240                         goto debug_failed;
1241                 }
1242         }
1243         if (!lpfc_debugfs_start_time)
1244                 lpfc_debugfs_start_time = jiffies;
1245
1246         /* Setup lpfcX directory for specific HBA */
1247         snprintf(name, sizeof(name), "lpfc%d", phba->brd_no);
1248         if (!phba->hba_debugfs_root) {
1249                 phba->hba_debugfs_root =
1250                         debugfs_create_dir(name, lpfc_debugfs_root);
1251                 if (!phba->hba_debugfs_root) {
1252                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1253                                          "0412 Cannot create debugfs hba\n");
1254                         goto debug_failed;
1255                 }
1256                 atomic_inc(&lpfc_debugfs_hba_count);
1257                 atomic_set(&phba->debugfs_vport_count, 0);
1258
1259                 /* Setup hbqinfo */
1260                 snprintf(name, sizeof(name), "hbqinfo");
1261                 phba->debug_hbqinfo =
1262                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1263                                  phba->hba_debugfs_root,
1264                                  phba, &lpfc_debugfs_op_hbqinfo);
1265                 if (!phba->debug_hbqinfo) {
1266                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1267                                 "0411 Cannot create debugfs hbqinfo\n");
1268                         goto debug_failed;
1269                 }
1270
1271                 /* Setup dumpHBASlim */
1272                 snprintf(name, sizeof(name), "dumpHBASlim");
1273                 phba->debug_dumpHBASlim =
1274                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1275                                  phba->hba_debugfs_root,
1276                                  phba, &lpfc_debugfs_op_dumpHBASlim);
1277                 if (!phba->debug_dumpHBASlim) {
1278                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1279                                 "0413 Cannot create debugfs dumpHBASlim\n");
1280                         goto debug_failed;
1281                 }
1282
1283                 /* Setup dumpHostSlim */
1284                 snprintf(name, sizeof(name), "dumpHostSlim");
1285                 phba->debug_dumpHostSlim =
1286                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1287                                  phba->hba_debugfs_root,
1288                                  phba, &lpfc_debugfs_op_dumpHostSlim);
1289                 if (!phba->debug_dumpHostSlim) {
1290                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1291                                 "0414 Cannot create debugfs dumpHostSlim\n");
1292                         goto debug_failed;
1293                 }
1294
1295                 /* Setup dumpData */
1296                 snprintf(name, sizeof(name), "dumpData");
1297                 phba->debug_dumpData =
1298                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1299                                  phba->hba_debugfs_root,
1300                                  phba, &lpfc_debugfs_op_dumpData);
1301                 if (!phba->debug_dumpData) {
1302                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1303                                 "0800 Cannot create debugfs dumpData\n");
1304                         goto debug_failed;
1305                 }
1306
1307                 /* Setup dumpDif */
1308                 snprintf(name, sizeof(name), "dumpDif");
1309                 phba->debug_dumpDif =
1310                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1311                                  phba->hba_debugfs_root,
1312                                  phba, &lpfc_debugfs_op_dumpDif);
1313                 if (!phba->debug_dumpDif) {
1314                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1315                                 "0801 Cannot create debugfs dumpDif\n");
1316                         goto debug_failed;
1317                 }
1318
1319
1320
1321                 /* Setup slow ring trace */
1322                 if (lpfc_debugfs_max_slow_ring_trc) {
1323                         num = lpfc_debugfs_max_slow_ring_trc - 1;
1324                         if (num & lpfc_debugfs_max_slow_ring_trc) {
1325                                 /* Change to be a power of 2 */
1326                                 num = lpfc_debugfs_max_slow_ring_trc;
1327                                 i = 0;
1328                                 while (num > 1) {
1329                                         num = num >> 1;
1330                                         i++;
1331                                 }
1332                                 lpfc_debugfs_max_slow_ring_trc = (1 << i);
1333                                 printk(KERN_ERR
1334                                        "lpfc_debugfs_max_disc_trc changed to "
1335                                        "%d\n", lpfc_debugfs_max_disc_trc);
1336                         }
1337                 }
1338
1339
1340                 snprintf(name, sizeof(name), "slow_ring_trace");
1341                 phba->debug_slow_ring_trc =
1342                         debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1343                                  phba->hba_debugfs_root,
1344                                  phba, &lpfc_debugfs_op_slow_ring_trc);
1345                 if (!phba->debug_slow_ring_trc) {
1346                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1347                                          "0415 Cannot create debugfs "
1348                                          "slow_ring_trace\n");
1349                         goto debug_failed;
1350                 }
1351                 if (!phba->slow_ring_trc) {
1352                         phba->slow_ring_trc = kmalloc(
1353                                 (sizeof(struct lpfc_debugfs_trc) *
1354                                 lpfc_debugfs_max_slow_ring_trc),
1355                                 GFP_KERNEL);
1356                         if (!phba->slow_ring_trc) {
1357                                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1358                                                  "0416 Cannot create debugfs "
1359                                                  "slow_ring buffer\n");
1360                                 goto debug_failed;
1361                         }
1362                         atomic_set(&phba->slow_ring_trc_cnt, 0);
1363                         memset(phba->slow_ring_trc, 0,
1364                                 (sizeof(struct lpfc_debugfs_trc) *
1365                                 lpfc_debugfs_max_slow_ring_trc));
1366                 }
1367         }
1368
1369         snprintf(name, sizeof(name), "vport%d", vport->vpi);
1370         if (!vport->vport_debugfs_root) {
1371                 vport->vport_debugfs_root =
1372                         debugfs_create_dir(name, phba->hba_debugfs_root);
1373                 if (!vport->vport_debugfs_root) {
1374                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1375                                          "0417 Cant create debugfs");
1376                         goto debug_failed;
1377                 }
1378                 atomic_inc(&phba->debugfs_vport_count);
1379         }
1380
1381         if (lpfc_debugfs_max_disc_trc) {
1382                 num = lpfc_debugfs_max_disc_trc - 1;
1383                 if (num & lpfc_debugfs_max_disc_trc) {
1384                         /* Change to be a power of 2 */
1385                         num = lpfc_debugfs_max_disc_trc;
1386                         i = 0;
1387                         while (num > 1) {
1388                                 num = num >> 1;
1389                                 i++;
1390                         }
1391                         lpfc_debugfs_max_disc_trc = (1 << i);
1392                         printk(KERN_ERR
1393                                "lpfc_debugfs_max_disc_trc changed to %d\n",
1394                                lpfc_debugfs_max_disc_trc);
1395                 }
1396         }
1397
1398         vport->disc_trc = kzalloc(
1399                 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
1400                 GFP_KERNEL);
1401
1402         if (!vport->disc_trc) {
1403                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1404                                  "0418 Cannot create debugfs disc trace "
1405                                  "buffer\n");
1406                 goto debug_failed;
1407         }
1408         atomic_set(&vport->disc_trc_cnt, 0);
1409
1410         snprintf(name, sizeof(name), "discovery_trace");
1411         vport->debug_disc_trc =
1412                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1413                                  vport->vport_debugfs_root,
1414                                  vport, &lpfc_debugfs_op_disc_trc);
1415         if (!vport->debug_disc_trc) {
1416                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1417                                  "0419 Cannot create debugfs "
1418                                  "discovery_trace\n");
1419                 goto debug_failed;
1420         }
1421         snprintf(name, sizeof(name), "nodelist");
1422         vport->debug_nodelist =
1423                 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
1424                                  vport->vport_debugfs_root,
1425                                  vport, &lpfc_debugfs_op_nodelist);
1426         if (!vport->debug_nodelist) {
1427                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1428                                  "0409 Cant create debugfs nodelist");
1429                 goto debug_failed;
1430         }
1431 debug_failed:
1432         return;
1433 #endif
1434 }
1435
1436 /**
1437  * lpfc_debugfs_terminate -  Tear down debugfs infrastructure for this vport
1438  * @vport: The vport pointer to remove from debugfs.
1439  *
1440  * Description:
1441  * When Debugfs is configured this routine removes debugfs file system elements
1442  * that are specific to this vport. It also checks to see if there are any
1443  * users left for the debugfs directories associated with the HBA and driver. If
1444  * this is the last user of the HBA directory or driver directory then it will
1445  * remove those from the debugfs infrastructure as well.
1446  **/
1447 inline void
1448 lpfc_debugfs_terminate(struct lpfc_vport *vport)
1449 {
1450 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1451         struct lpfc_hba   *phba = vport->phba;
1452
1453         if (vport->disc_trc) {
1454                 kfree(vport->disc_trc);
1455                 vport->disc_trc = NULL;
1456         }
1457         if (vport->debug_disc_trc) {
1458                 debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
1459                 vport->debug_disc_trc = NULL;
1460         }
1461         if (vport->debug_nodelist) {
1462                 debugfs_remove(vport->debug_nodelist); /* nodelist */
1463                 vport->debug_nodelist = NULL;
1464         }
1465
1466         if (vport->vport_debugfs_root) {
1467                 debugfs_remove(vport->vport_debugfs_root); /* vportX */
1468                 vport->vport_debugfs_root = NULL;
1469                 atomic_dec(&phba->debugfs_vport_count);
1470         }
1471         if (atomic_read(&phba->debugfs_vport_count) == 0) {
1472
1473                 if (phba->debug_hbqinfo) {
1474                         debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
1475                         phba->debug_hbqinfo = NULL;
1476                 }
1477                 if (phba->debug_dumpHBASlim) {
1478                         debugfs_remove(phba->debug_dumpHBASlim); /* HBASlim */
1479                         phba->debug_dumpHBASlim = NULL;
1480                 }
1481                 if (phba->debug_dumpHostSlim) {
1482                         debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */
1483                         phba->debug_dumpHostSlim = NULL;
1484                 }
1485                 if (phba->debug_dumpData) {
1486                         debugfs_remove(phba->debug_dumpData); /* dumpData */
1487                         phba->debug_dumpData = NULL;
1488                 }
1489
1490                 if (phba->debug_dumpDif) {
1491                         debugfs_remove(phba->debug_dumpDif); /* dumpDif */
1492                         phba->debug_dumpDif = NULL;
1493                 }
1494
1495                 if (phba->slow_ring_trc) {
1496                         kfree(phba->slow_ring_trc);
1497                         phba->slow_ring_trc = NULL;
1498                 }
1499                 if (phba->debug_slow_ring_trc) {
1500                         /* slow_ring_trace */
1501                         debugfs_remove(phba->debug_slow_ring_trc);
1502                         phba->debug_slow_ring_trc = NULL;
1503                 }
1504
1505                 if (phba->hba_debugfs_root) {
1506                         debugfs_remove(phba->hba_debugfs_root); /* lpfcX */
1507                         phba->hba_debugfs_root = NULL;
1508                         atomic_dec(&lpfc_debugfs_hba_count);
1509                 }
1510
1511                 if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
1512                         debugfs_remove(lpfc_debugfs_root); /* lpfc */
1513                         lpfc_debugfs_root = NULL;
1514                 }
1515         }
1516 #endif
1517         return;
1518 }