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