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. *
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 *******************************************************************/
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>
32 #include <scsi/scsi.h>
33 #include <scsi/scsi_device.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi_transport_fc.h>
39 #include "lpfc_disc.h"
40 #include "lpfc_scsi.h"
42 #include "lpfc_logmsg.h"
43 #include "lpfc_crtn.h"
44 #include "lpfc_vport.h"
45 #include "lpfc_version.h"
46 #include "lpfc_vport.h"
47 #include "lpfc_debugfs.h"
49 #ifdef CONFIG_LPFC_DEBUG_FS
52 * To access this interface the user should:
54 * # mount -t debugfs none /debug
56 * The lpfc debugfs directory hierachy is:
58 * where X is the lpfc hba unique_id
59 * where Y is the vport VPI on that hba
61 * Debugging services available per vport:
63 * This is an ACSII readable file that contains a trace of the last
64 * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
65 * See lpfc_debugfs.h for different categories of
66 * discovery events. To enable the discovery trace, the following
67 * module parameters must be set:
68 * lpfc_debugfs_enable=1 Turns on lpfc debugfs filesystem support
69 * lpfc_debugfs_max_disc_trc=X Where X is the event trace depth for
70 * EACH vport. X MUST also be a power of 2.
71 * lpfc_debugfs_mask_disc_trc=Y Where Y is an event mask as defined in
74 static int lpfc_debugfs_enable = 0;
75 module_param(lpfc_debugfs_enable, int, 0);
76 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
78 /* This MUST be a power of 2 */
79 static int lpfc_debugfs_max_disc_trc = 0;
80 module_param(lpfc_debugfs_max_disc_trc, int, 0);
81 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
82 "Set debugfs discovery trace depth");
84 /* This MUST be a power of 2 */
85 static int lpfc_debugfs_max_slow_ring_trc = 0;
86 module_param(lpfc_debugfs_max_slow_ring_trc, int, 0);
87 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
88 "Set debugfs slow ring trace depth");
90 static int lpfc_debugfs_mask_disc_trc = 0;
91 module_param(lpfc_debugfs_mask_disc_trc, int, 0);
92 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
93 "Set debugfs discovery trace mask");
95 #include <linux/debugfs.h>
97 /* size of output line, for discovery_trace and slow_ring_trace */
98 #define LPFC_DEBUG_TRC_ENTRY_SIZE 100
100 /* nodelist output buffer size */
101 #define LPFC_NODELIST_SIZE 8192
102 #define LPFC_NODELIST_ENTRY_SIZE 120
104 /* dumpslim output buffer size */
105 #define LPFC_DUMPSLIM_SIZE 4096
107 /* hbqinfo output buffer size */
108 #define LPFC_HBQINFO_SIZE 8192
115 extern struct lpfc_hbq_init *lpfc_hbq_defs[];
116 extern int lpfc_sli_hbq_count(void);
118 atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
119 unsigned long lpfc_debugfs_start_time = 0L;
122 lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
124 int i, index, len, enable;
126 struct lpfc_debugfs_trc *dtp;
127 char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
130 enable = lpfc_debugfs_enable;
131 lpfc_debugfs_enable = 0;
134 index = (atomic_read(&vport->disc_trc_cnt) + 1) &
135 (lpfc_debugfs_max_disc_trc - 1);
136 for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
137 dtp = vport->disc_trc + i;
140 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
142 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
143 dtp->seq_cnt, ms, dtp->fmt);
144 len += snprintf(buf+len, size-len, buffer,
145 dtp->data1, dtp->data2, dtp->data3);
147 for (i = 0; i < index; i++) {
148 dtp = vport->disc_trc + i;
151 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
153 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
154 dtp->seq_cnt, ms, dtp->fmt);
155 len += snprintf(buf+len, size-len, buffer,
156 dtp->data1, dtp->data2, dtp->data3);
159 lpfc_debugfs_enable = enable;
164 lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
166 int i, index, len, enable;
168 struct lpfc_debugfs_trc *dtp;
169 char buffer[LPFC_DEBUG_TRC_ENTRY_SIZE];
172 enable = lpfc_debugfs_enable;
173 lpfc_debugfs_enable = 0;
176 index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
177 (lpfc_debugfs_max_slow_ring_trc - 1);
178 for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
179 dtp = phba->slow_ring_trc + i;
182 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
184 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
185 dtp->seq_cnt, ms, dtp->fmt);
186 len += snprintf(buf+len, size-len, buffer,
187 dtp->data1, dtp->data2, dtp->data3);
189 for (i = 0; i < index; i++) {
190 dtp = phba->slow_ring_trc + i;
193 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
195 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
196 dtp->seq_cnt, ms, dtp->fmt);
197 len += snprintf(buf+len, size-len, buffer,
198 dtp->data1, dtp->data2, dtp->data3);
201 lpfc_debugfs_enable = enable;
205 int lpfc_debugfs_last_hbq = -1;
208 lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
211 int cnt, i, j, found, posted, low;
212 uint32_t phys, raw_index, getidx;
213 struct lpfc_hbq_init *hip;
215 struct lpfc_hbq_entry *hbqe;
216 struct lpfc_dmabuf *d_buf;
217 struct hbq_dmabuf *hbq_buf;
219 cnt = LPFC_HBQINFO_SIZE;
220 spin_lock_irq(&phba->hbalock);
222 /* toggle between multiple hbqs, if any */
223 i = lpfc_sli_hbq_count();
225 lpfc_debugfs_last_hbq++;
226 if (lpfc_debugfs_last_hbq >= i)
227 lpfc_debugfs_last_hbq = 0;
230 lpfc_debugfs_last_hbq = 0;
232 i = lpfc_debugfs_last_hbq;
234 len += snprintf(buf+len, size-len, "HBQ %d Info\n", i);
237 list_for_each_entry(d_buf, &phba->hbq_buffer_list, list)
240 hip = lpfc_hbq_defs[i];
241 len += snprintf(buf+len, size-len,
242 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
243 hip->hbq_index, hip->profile, hip->rn,
244 hip->buffer_count, hip->init_count, hip->add_count, posted);
246 hbqs = &phba->hbqs[i];
247 raw_index = phba->hbq_get[i];
248 getidx = le32_to_cpu(raw_index);
249 len += snprintf(buf+len, size-len,
250 "entrys:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
251 hbqs->entry_count, hbqs->hbqPutIdx, hbqs->next_hbqPutIdx,
252 hbqs->local_hbqGetIdx, getidx);
254 hbqe = (struct lpfc_hbq_entry *) phba->hbqslimp.virt;
255 for (j=0; j<hbqs->entry_count; j++) {
256 len += snprintf(buf+len, size-len,
257 "%03d: %08x %04x %05x ", j,
258 hbqe->bde.addrLow, hbqe->bde.tus.w, hbqe->buffer_tag);
263 /* First calculate if slot has an associated posted buffer */
264 low = hbqs->hbqPutIdx - posted;
266 if ((j >= hbqs->hbqPutIdx) || (j < low)) {
267 len += snprintf(buf+len, size-len, "Unused\n");
272 if ((j >= hbqs->hbqPutIdx) &&
273 (j < (hbqs->entry_count+low))) {
274 len += snprintf(buf+len, size-len, "Unused\n");
279 /* Get the Buffer info for the posted buffer */
280 list_for_each_entry(d_buf, &phba->hbq_buffer_list, list) {
281 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
282 phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
283 if (phys == hbqe->bde.addrLow) {
284 len += snprintf(buf+len, size-len,
285 "Buf%d: %p %06x\n", i,
286 hbq_buf->dbuf.virt, hbq_buf->tag);
293 len += snprintf(buf+len, size-len, "No DMAinfo?\n");
297 if (len > LPFC_HBQINFO_SIZE - 54)
300 spin_unlock_irq(&phba->hbalock);
305 lpfc_debugfs_dumpslim_data(struct lpfc_hba *phba, char *buf, int size)
309 uint32_t word0, word1, word2, word3;
311 struct lpfc_pgp *pgpp;
312 struct lpfc_sli *psli = &phba->sli;
313 struct lpfc_sli_ring *pring;
315 cnt = LPFC_DUMPSLIM_SIZE;
317 spin_lock_irq(&phba->hbalock);
319 len += snprintf(buf+len, size-len, "SLIM Mailbox\n");
320 ptr = (uint32_t *)phba->slim2p;
321 i = sizeof(MAILBOX_t);
323 len += snprintf(buf+len, size-len,
324 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
325 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
326 *(ptr+5), *(ptr+6), *(ptr+7));
328 i -= (8 * sizeof(uint32_t));
329 off += (8 * sizeof(uint32_t));
332 len += snprintf(buf+len, size-len, "SLIM PCB\n");
333 ptr = (uint32_t *)&phba->slim2p->pcb;
336 len += snprintf(buf+len, size-len,
337 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
338 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
339 *(ptr+5), *(ptr+6), *(ptr+7));
341 i -= (8 * sizeof(uint32_t));
342 off += (8 * sizeof(uint32_t));
345 pgpp = (struct lpfc_pgp *)&phba->slim2p->mbx.us.s3_pgp.port;
346 pring = &psli->ring[0];
347 len += snprintf(buf+len, size-len,
348 "Ring 0: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x) "
349 "RSP PutInx:%d Max:%d\n",
350 pgpp->cmdGetInx, pring->numCiocb,
351 pring->next_cmdidx, pring->local_getidx, pring->flag,
352 pgpp->rspPutInx, pring->numRiocb);
355 pring = &psli->ring[1];
356 len += snprintf(buf+len, size-len,
357 "Ring 1: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x) "
358 "RSP PutInx:%d Max:%d\n",
359 pgpp->cmdGetInx, pring->numCiocb,
360 pring->next_cmdidx, pring->local_getidx, pring->flag,
361 pgpp->rspPutInx, pring->numRiocb);
364 pring = &psli->ring[2];
365 len += snprintf(buf+len, size-len,
366 "Ring 2: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x) "
367 "RSP PutInx:%d Max:%d\n",
368 pgpp->cmdGetInx, pring->numCiocb,
369 pring->next_cmdidx, pring->local_getidx, pring->flag,
370 pgpp->rspPutInx, pring->numRiocb);
373 pring = &psli->ring[3];
374 len += snprintf(buf+len, size-len,
375 "Ring 3: CMD GetInx:%d (Max:%d Next:%d Local:%d flg:x%x) "
376 "RSP PutInx:%d Max:%d\n",
377 pgpp->cmdGetInx, pring->numCiocb,
378 pring->next_cmdidx, pring->local_getidx, pring->flag,
379 pgpp->rspPutInx, pring->numRiocb);
382 ptr = (uint32_t *)&phba->slim2p->mbx.us.s3_pgp.hbq_get;
383 word0 = readl(phba->HAregaddr);
384 word1 = readl(phba->CAregaddr);
385 word2 = readl(phba->HSregaddr);
386 word3 = readl(phba->HCregaddr);
387 len += snprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x HC:%08x\n",
388 word0, word1, word2, word3);
389 spin_unlock_irq(&phba->hbalock);
394 lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
398 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
399 struct lpfc_nodelist *ndlp;
400 unsigned char *statep, *name;
402 cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
404 spin_lock_irq(shost->host_lock);
405 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
407 len += snprintf(buf+len, size-len,
408 "Missing Nodelist Entries\n");
412 switch (ndlp->nlp_state) {
413 case NLP_STE_UNUSED_NODE:
416 case NLP_STE_PLOGI_ISSUE:
419 case NLP_STE_ADISC_ISSUE:
422 case NLP_STE_REG_LOGIN_ISSUE:
425 case NLP_STE_PRLI_ISSUE:
428 case NLP_STE_UNMAPPED_NODE:
431 case NLP_STE_MAPPED_NODE:
434 case NLP_STE_NPR_NODE:
440 len += snprintf(buf+len, size-len, "%s DID:x%06x ",
441 statep, ndlp->nlp_DID);
442 name = (unsigned char *)&ndlp->nlp_portname;
443 len += snprintf(buf+len, size-len,
444 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
445 *name, *(name+1), *(name+2), *(name+3),
446 *(name+4), *(name+5), *(name+6), *(name+7));
447 name = (unsigned char *)&ndlp->nlp_nodename;
448 len += snprintf(buf+len, size-len,
449 "WWNN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x ",
450 *name, *(name+1), *(name+2), *(name+3),
451 *(name+4), *(name+5), *(name+6), *(name+7));
452 len += snprintf(buf+len, size-len, "RPI:%03d flag:x%08x ",
453 ndlp->nlp_rpi, ndlp->nlp_flag);
455 len += snprintf(buf+len, size-len, "UNKNOWN_TYPE ");
456 if (ndlp->nlp_type & NLP_FC_NODE)
457 len += snprintf(buf+len, size-len, "FC_NODE ");
458 if (ndlp->nlp_type & NLP_FABRIC)
459 len += snprintf(buf+len, size-len, "FABRIC ");
460 if (ndlp->nlp_type & NLP_FCP_TARGET)
461 len += snprintf(buf+len, size-len, "FCP_TGT sid:%d ",
463 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
464 len += snprintf(buf+len, size-len, "FCP_INITIATOR ");
465 len += snprintf(buf+len, size-len, "refcnt:%x",
466 atomic_read(&ndlp->kref.refcount));
467 len += snprintf(buf+len, size-len, "\n");
469 spin_unlock_irq(shost->host_lock);
476 lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
477 uint32_t data1, uint32_t data2, uint32_t data3)
479 #ifdef CONFIG_LPFC_DEBUG_FS
480 struct lpfc_debugfs_trc *dtp;
483 if (!(lpfc_debugfs_mask_disc_trc & mask))
486 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
487 !vport || !vport->disc_trc)
490 index = atomic_inc_return(&vport->disc_trc_cnt) &
491 (lpfc_debugfs_max_disc_trc - 1);
492 dtp = vport->disc_trc + index;
497 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
504 lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
505 uint32_t data1, uint32_t data2, uint32_t data3)
507 #ifdef CONFIG_LPFC_DEBUG_FS
508 struct lpfc_debugfs_trc *dtp;
511 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
512 !phba || !phba->slow_ring_trc)
515 index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
516 (lpfc_debugfs_max_slow_ring_trc - 1);
517 dtp = phba->slow_ring_trc + index;
522 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
528 #ifdef CONFIG_LPFC_DEBUG_FS
530 lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
532 struct lpfc_vport *vport = inode->i_private;
533 struct lpfc_debug *debug;
537 if (!lpfc_debugfs_max_disc_trc) {
542 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
546 /* Round to page boundry */
547 size = (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
548 size = PAGE_ALIGN(size);
550 debug->buffer = kmalloc(size, GFP_KERNEL);
551 if (!debug->buffer) {
556 debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
557 file->private_data = debug;
565 lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
567 struct lpfc_hba *phba = inode->i_private;
568 struct lpfc_debug *debug;
572 if (!lpfc_debugfs_max_slow_ring_trc) {
577 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
581 /* Round to page boundry */
582 size = (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
583 size = PAGE_ALIGN(size);
585 debug->buffer = kmalloc(size, GFP_KERNEL);
586 if (!debug->buffer) {
591 debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
592 file->private_data = debug;
600 lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
602 struct lpfc_hba *phba = inode->i_private;
603 struct lpfc_debug *debug;
606 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
610 /* Round to page boundry */
611 debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
612 if (!debug->buffer) {
617 debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
619 file->private_data = debug;
627 lpfc_debugfs_dumpslim_open(struct inode *inode, struct file *file)
629 struct lpfc_hba *phba = inode->i_private;
630 struct lpfc_debug *debug;
633 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
637 /* Round to page boundry */
638 debug->buffer = kmalloc(LPFC_DUMPSLIM_SIZE, GFP_KERNEL);
639 if (!debug->buffer) {
644 debug->len = lpfc_debugfs_dumpslim_data(phba, debug->buffer,
646 file->private_data = debug;
654 lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
656 struct lpfc_vport *vport = inode->i_private;
657 struct lpfc_debug *debug;
660 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
664 /* Round to page boundry */
665 debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
666 if (!debug->buffer) {
671 debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
673 file->private_data = debug;
681 lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
683 struct lpfc_debug *debug;
686 debug = file->private_data;
693 pos = file->f_pos + off;
696 pos = debug->len - off;
698 return (pos < 0 || pos > debug->len) ? -EINVAL : (file->f_pos = pos);
702 lpfc_debugfs_read(struct file *file, char __user *buf,
703 size_t nbytes, loff_t *ppos)
705 struct lpfc_debug *debug = file->private_data;
706 return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
711 lpfc_debugfs_release(struct inode *inode, struct file *file)
713 struct lpfc_debug *debug = file->private_data;
715 kfree(debug->buffer);
721 #undef lpfc_debugfs_op_disc_trc
722 static struct file_operations lpfc_debugfs_op_disc_trc = {
723 .owner = THIS_MODULE,
724 .open = lpfc_debugfs_disc_trc_open,
725 .llseek = lpfc_debugfs_lseek,
726 .read = lpfc_debugfs_read,
727 .release = lpfc_debugfs_release,
730 #undef lpfc_debugfs_op_nodelist
731 static struct file_operations lpfc_debugfs_op_nodelist = {
732 .owner = THIS_MODULE,
733 .open = lpfc_debugfs_nodelist_open,
734 .llseek = lpfc_debugfs_lseek,
735 .read = lpfc_debugfs_read,
736 .release = lpfc_debugfs_release,
739 #undef lpfc_debugfs_op_hbqinfo
740 static struct file_operations lpfc_debugfs_op_hbqinfo = {
741 .owner = THIS_MODULE,
742 .open = lpfc_debugfs_hbqinfo_open,
743 .llseek = lpfc_debugfs_lseek,
744 .read = lpfc_debugfs_read,
745 .release = lpfc_debugfs_release,
748 #undef lpfc_debugfs_op_dumpslim
749 static struct file_operations lpfc_debugfs_op_dumpslim = {
750 .owner = THIS_MODULE,
751 .open = lpfc_debugfs_dumpslim_open,
752 .llseek = lpfc_debugfs_lseek,
753 .read = lpfc_debugfs_read,
754 .release = lpfc_debugfs_release,
757 #undef lpfc_debugfs_op_slow_ring_trc
758 static struct file_operations lpfc_debugfs_op_slow_ring_trc = {
759 .owner = THIS_MODULE,
760 .open = lpfc_debugfs_slow_ring_trc_open,
761 .llseek = lpfc_debugfs_lseek,
762 .read = lpfc_debugfs_read,
763 .release = lpfc_debugfs_release,
766 static struct dentry *lpfc_debugfs_root = NULL;
767 static atomic_t lpfc_debugfs_hba_count;
771 lpfc_debugfs_initialize(struct lpfc_vport *vport)
773 #ifdef CONFIG_LPFC_DEBUG_FS
774 struct lpfc_hba *phba = vport->phba;
778 if (!lpfc_debugfs_enable)
781 /* Setup lpfc root directory */
782 if (!lpfc_debugfs_root) {
783 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
784 atomic_set(&lpfc_debugfs_hba_count, 0);
785 if (!lpfc_debugfs_root) {
786 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
787 "0409 Cannot create debugfs root\n");
791 if (!lpfc_debugfs_start_time)
792 lpfc_debugfs_start_time = jiffies;
794 /* Setup lpfcX directory for specific HBA */
795 snprintf(name, sizeof(name), "lpfc%d", phba->brd_no);
796 if (!phba->hba_debugfs_root) {
797 phba->hba_debugfs_root =
798 debugfs_create_dir(name, lpfc_debugfs_root);
799 if (!phba->hba_debugfs_root) {
800 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
801 "0409 Cannot create debugfs hba\n");
804 atomic_inc(&lpfc_debugfs_hba_count);
805 atomic_set(&phba->debugfs_vport_count, 0);
808 snprintf(name, sizeof(name), "hbqinfo");
809 phba->debug_hbqinfo =
810 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
811 phba->hba_debugfs_root,
812 phba, &lpfc_debugfs_op_hbqinfo);
813 if (!phba->debug_hbqinfo) {
814 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
815 "0409 Cannot create debugfs hbqinfo\n");
820 snprintf(name, sizeof(name), "dumpslim");
821 phba->debug_dumpslim =
822 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
823 phba->hba_debugfs_root,
824 phba, &lpfc_debugfs_op_dumpslim);
825 if (!phba->debug_dumpslim) {
826 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
827 "0409 Cannot create debugfs dumpslim\n");
831 /* Setup slow ring trace */
832 if (lpfc_debugfs_max_slow_ring_trc) {
833 num = lpfc_debugfs_max_slow_ring_trc - 1;
834 if (num & lpfc_debugfs_max_slow_ring_trc) {
835 /* Change to be a power of 2 */
836 num = lpfc_debugfs_max_slow_ring_trc;
842 lpfc_debugfs_max_slow_ring_trc = (1 << i);
844 "lpfc_debugfs_max_disc_trc changed to "
845 "%d\n", lpfc_debugfs_max_disc_trc);
850 snprintf(name, sizeof(name), "slow_ring_trace");
851 phba->debug_slow_ring_trc =
852 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
853 phba->hba_debugfs_root,
854 phba, &lpfc_debugfs_op_slow_ring_trc);
855 if (!phba->debug_slow_ring_trc) {
856 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
857 "0409 Cannot create debugfs "
858 "slow_ring_trace\n");
861 if (!phba->slow_ring_trc) {
862 phba->slow_ring_trc = kmalloc(
863 (sizeof(struct lpfc_debugfs_trc) *
864 lpfc_debugfs_max_slow_ring_trc),
866 if (!phba->slow_ring_trc) {
867 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
868 "0409 Cannot create debugfs "
869 "slow_ring buffer\n");
872 atomic_set(&phba->slow_ring_trc_cnt, 0);
873 memset(phba->slow_ring_trc, 0,
874 (sizeof(struct lpfc_debugfs_trc) *
875 lpfc_debugfs_max_slow_ring_trc));
879 snprintf(name, sizeof(name), "vport%d", vport->vpi);
880 if (!vport->vport_debugfs_root) {
881 vport->vport_debugfs_root =
882 debugfs_create_dir(name, phba->hba_debugfs_root);
883 if (!vport->vport_debugfs_root) {
884 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
885 "0409 Cant create debugfs");
888 atomic_inc(&phba->debugfs_vport_count);
891 if (lpfc_debugfs_max_disc_trc) {
892 num = lpfc_debugfs_max_disc_trc - 1;
893 if (num & lpfc_debugfs_max_disc_trc) {
894 /* Change to be a power of 2 */
895 num = lpfc_debugfs_max_disc_trc;
901 lpfc_debugfs_max_disc_trc = (1 << i);
903 "lpfc_debugfs_max_disc_trc changed to %d\n",
904 lpfc_debugfs_max_disc_trc);
908 vport->disc_trc = kmalloc(
909 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
912 if (!vport->disc_trc) {
913 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
914 "0409 Cannot create debugfs disc trace "
918 atomic_set(&vport->disc_trc_cnt, 0);
919 memset(vport->disc_trc, 0,
920 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc));
922 snprintf(name, sizeof(name), "discovery_trace");
923 vport->debug_disc_trc =
924 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
925 vport->vport_debugfs_root,
926 vport, &lpfc_debugfs_op_disc_trc);
927 if (!vport->debug_disc_trc) {
928 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
929 "0409 Cannot create debugfs "
930 "discovery_trace\n");
933 snprintf(name, sizeof(name), "nodelist");
934 vport->debug_nodelist =
935 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
936 vport->vport_debugfs_root,
937 vport, &lpfc_debugfs_op_nodelist);
938 if (!vport->debug_nodelist) {
939 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
940 "0409 Cant create debugfs nodelist");
950 lpfc_debugfs_terminate(struct lpfc_vport *vport)
952 #ifdef CONFIG_LPFC_DEBUG_FS
953 struct lpfc_hba *phba = vport->phba;
955 if (vport->disc_trc) {
956 kfree(vport->disc_trc);
957 vport->disc_trc = NULL;
959 if (vport->debug_disc_trc) {
960 debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
961 vport->debug_disc_trc = NULL;
963 if (vport->debug_nodelist) {
964 debugfs_remove(vport->debug_nodelist); /* nodelist */
965 vport->debug_nodelist = NULL;
968 if (vport->vport_debugfs_root) {
969 debugfs_remove(vport->vport_debugfs_root); /* vportX */
970 vport->vport_debugfs_root = NULL;
971 atomic_dec(&phba->debugfs_vport_count);
973 if (atomic_read(&phba->debugfs_vport_count) == 0) {
975 if (phba->debug_hbqinfo) {
976 debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
977 phba->debug_hbqinfo = NULL;
979 if (phba->debug_dumpslim) {
980 debugfs_remove(phba->debug_dumpslim); /* dumpslim */
981 phba->debug_dumpslim = NULL;
983 if (phba->slow_ring_trc) {
984 kfree(phba->slow_ring_trc);
985 phba->slow_ring_trc = NULL;
987 if (phba->debug_slow_ring_trc) {
988 /* slow_ring_trace */
989 debugfs_remove(phba->debug_slow_ring_trc);
990 phba->debug_slow_ring_trc = NULL;
993 if (phba->hba_debugfs_root) {
994 debugfs_remove(phba->hba_debugfs_root); /* lpfcX */
995 phba->hba_debugfs_root = NULL;
996 atomic_dec(&lpfc_debugfs_hba_count);
999 if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
1000 debugfs_remove(lpfc_debugfs_root); /* lpfc */
1001 lpfc_debugfs_root = NULL;