?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / scsi / lpfc / lpfc_debugfs.c
blob3fd1aa5cc78cc8e252ced71f362890d983e4785d
1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2024 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
6 * Copyright (C) 2007-2015 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
8 * www.broadcom.com *
9 * *
10 * This program is free software; you can redistribute it and/or *
11 * modify it under the terms of version 2 of the GNU General *
12 * Public License as published by the Free Software Foundation. *
13 * This program is distributed in the hope that it will be useful. *
14 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
15 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
16 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
17 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
18 * TO BE LEGALLY INVALID. See the GNU General Public License for *
19 * more details, a copy of which can be found in the file COPYING *
20 * included with this package. *
21 *******************************************************************/
22
23 #include <linux/blkdev.h>
24 #include <linux/delay.h>
25 #include <linux/module.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/idr.h>
28 #include <linux/interrupt.h>
29 #include <linux/kthread.h>
30 #include <linux/slab.h>
31 #include <linux/pci.h>
32 #include <linux/spinlock.h>
33 #include <linux/ctype.h>
34 #include <linux/vmalloc.h>
35
36 #include <scsi/scsi.h>
37 #include <scsi/scsi_device.h>
38 #include <scsi/scsi_host.h>
39 #include <scsi/scsi_transport_fc.h>
40 #include <scsi/fc/fc_fs.h>
41
42 #include "lpfc_hw4.h"
43 #include "lpfc_hw.h"
44 #include "lpfc_sli.h"
45 #include "lpfc_sli4.h"
46 #include "lpfc_nl.h"
47 #include "lpfc_disc.h"
48 #include "lpfc.h"
49 #include "lpfc_scsi.h"
50 #include "lpfc_nvme.h"
51 #include "lpfc_logmsg.h"
52 #include "lpfc_crtn.h"
53 #include "lpfc_vport.h"
54 #include "lpfc_version.h"
55 #include "lpfc_compat.h"
56 #include "lpfc_debugfs.h"
57 #include "lpfc_bsg.h"
58
59 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
60 /*
61 * debugfs interface
62 *
63 * To access this interface the user should:
64 * # mount -t debugfs none /sys/kernel/debug
65 *
66 * The lpfc debugfs directory hierarchy is:
67 * /sys/kernel/debug/lpfc/fnX/vportY
68 * where X is the lpfc hba function unique_id
69 * where Y is the vport VPI on that hba
70 *
71 * Debugging services available per vport:
72 * discovery_trace
73 * This is an ACSII readable file that contains a trace of the last
74 * lpfc_debugfs_max_disc_trc events that happened on a specific vport.
75 * See lpfc_debugfs.h for different categories of discovery events.
76 * To enable the discovery trace, the following module parameters must be set:
77 * lpfc_debugfs_enable=1 Turns on lpfc debugfs filesystem support
78 * lpfc_debugfs_max_disc_trc=X Where X is the event trace depth for
79 * EACH vport. X MUST also be a power of 2.
80 * lpfc_debugfs_mask_disc_trc=Y Where Y is an event mask as defined in
81 * lpfc_debugfs.h .
82 *
83 * slow_ring_trace
84 * This is an ACSII readable file that contains a trace of the last
85 * lpfc_debugfs_max_slow_ring_trc events that happened on a specific HBA.
86 * To enable the slow ring trace, the following module parameters must be set:
87 * lpfc_debugfs_enable=1 Turns on lpfc debugfs filesystem support
88 * lpfc_debugfs_max_slow_ring_trc=X Where X is the event trace depth for
89 * the HBA. X MUST also be a power of 2.
90 */
91 static int lpfc_debugfs_enable = 1;
92 module_param(lpfc_debugfs_enable, int, S_IRUGO);
93 MODULE_PARM_DESC(lpfc_debugfs_enable, "Enable debugfs services");
94
95 /* This MUST be a power of 2 */
96 static int lpfc_debugfs_max_disc_trc;
97 module_param(lpfc_debugfs_max_disc_trc, int, S_IRUGO);
98 MODULE_PARM_DESC(lpfc_debugfs_max_disc_trc,
99 "Set debugfs discovery trace depth");
100
101 /* This MUST be a power of 2 */
102 static int lpfc_debugfs_max_slow_ring_trc;
103 module_param(lpfc_debugfs_max_slow_ring_trc, int, S_IRUGO);
104 MODULE_PARM_DESC(lpfc_debugfs_max_slow_ring_trc,
105 "Set debugfs slow ring trace depth");
106
107 /* This MUST be a power of 2 */
108 static int lpfc_debugfs_max_nvmeio_trc;
109 module_param(lpfc_debugfs_max_nvmeio_trc, int, 0444);
110 MODULE_PARM_DESC(lpfc_debugfs_max_nvmeio_trc,
111 "Set debugfs NVME IO trace depth");
112
113 static int lpfc_debugfs_mask_disc_trc;
114 module_param(lpfc_debugfs_mask_disc_trc, int, S_IRUGO);
115 MODULE_PARM_DESC(lpfc_debugfs_mask_disc_trc,
116 "Set debugfs discovery trace mask");
117
118 #include <linux/debugfs.h>
119
120 static atomic_t lpfc_debugfs_seq_trc_cnt = ATOMIC_INIT(0);
121 static unsigned long lpfc_debugfs_start_time = 0L;
122
123 /* iDiag */
124 static struct lpfc_idiag idiag;
125
126 /**
127 * lpfc_debugfs_disc_trc_data - Dump discovery logging to a buffer
128 * @vport: The vport to gather the log info from.
129 * @buf: The buffer to dump log into.
130 * @size: The maximum amount of data to process.
131 *
132 * Description:
133 * This routine gathers the lpfc discovery debugfs data from the @vport and
134 * dumps it to @buf up to @size number of bytes. It will start at the next entry
135 * in the log and process the log until the end of the buffer. Then it will
136 * gather from the beginning of the log and process until the current entry.
137 *
138 * Notes:
139 * Discovery logging will be disabled while while this routine dumps the log.
140 *
141 * Return Value:
142 * This routine returns the amount of bytes that were dumped into @buf and will
143 * not exceed @size.
144 **/
145 static int
146 lpfc_debugfs_disc_trc_data(struct lpfc_vport *vport, char *buf, int size)
147 {
148 int i, index, len, enable;
149 uint32_t ms;
150 struct lpfc_debugfs_trc *dtp;
151 char *buffer;
152
153 buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
154 if (!buffer)
155 return 0;
156
157 enable = lpfc_debugfs_enable;
158 lpfc_debugfs_enable = 0;
159
160 len = 0;
161 index = (atomic_read(&vport->disc_trc_cnt) + 1) &
162 (lpfc_debugfs_max_disc_trc - 1);
163 for (i = index; i < lpfc_debugfs_max_disc_trc; i++) {
164 dtp = vport->disc_trc + i;
165 if (!dtp->fmt)
166 continue;
167 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
168 snprintf(buffer,
169 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
170 dtp->seq_cnt, ms, dtp->fmt);
171 len += scnprintf(buf+len, size-len, buffer,
172 dtp->data1, dtp->data2, dtp->data3);
173 }
174 for (i = 0; i < index; i++) {
175 dtp = vport->disc_trc + i;
176 if (!dtp->fmt)
177 continue;
178 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
179 snprintf(buffer,
180 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
181 dtp->seq_cnt, ms, dtp->fmt);
182 len += scnprintf(buf+len, size-len, buffer,
183 dtp->data1, dtp->data2, dtp->data3);
184 }
185
186 lpfc_debugfs_enable = enable;
187 kfree(buffer);
188
189 return len;
190 }
191
192 /**
193 * lpfc_debugfs_slow_ring_trc_data - Dump slow ring logging to a buffer
194 * @phba: The HBA to gather the log info from.
195 * @buf: The buffer to dump log into.
196 * @size: The maximum amount of data to process.
197 *
198 * Description:
199 * This routine gathers the lpfc slow ring debugfs data from the @phba and
200 * dumps it to @buf up to @size number of bytes. It will start at the next entry
201 * in the log and process the log until the end of the buffer. Then it will
202 * gather from the beginning of the log and process until the current entry.
203 *
204 * Notes:
205 * Slow ring logging will be disabled while while this routine dumps the log.
206 *
207 * Return Value:
208 * This routine returns the amount of bytes that were dumped into @buf and will
209 * not exceed @size.
210 **/
211 static int
212 lpfc_debugfs_slow_ring_trc_data(struct lpfc_hba *phba, char *buf, int size)
213 {
214 int i, index, len, enable;
215 uint32_t ms;
216 struct lpfc_debugfs_trc *dtp;
217 char *buffer;
218
219 buffer = kmalloc(LPFC_DEBUG_TRC_ENTRY_SIZE, GFP_KERNEL);
220 if (!buffer)
221 return 0;
222
223 enable = lpfc_debugfs_enable;
224 lpfc_debugfs_enable = 0;
225
226 len = 0;
227 index = (atomic_read(&phba->slow_ring_trc_cnt) + 1) &
228 (lpfc_debugfs_max_slow_ring_trc - 1);
229 for (i = index; i < lpfc_debugfs_max_slow_ring_trc; i++) {
230 dtp = phba->slow_ring_trc + i;
231 if (!dtp->fmt)
232 continue;
233 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
234 snprintf(buffer,
235 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
236 dtp->seq_cnt, ms, dtp->fmt);
237 len += scnprintf(buf+len, size-len, buffer,
238 dtp->data1, dtp->data2, dtp->data3);
239 }
240 for (i = 0; i < index; i++) {
241 dtp = phba->slow_ring_trc + i;
242 if (!dtp->fmt)
243 continue;
244 ms = jiffies_to_msecs(dtp->jif - lpfc_debugfs_start_time);
245 snprintf(buffer,
246 LPFC_DEBUG_TRC_ENTRY_SIZE, "%010d:%010d ms:%s\n",
247 dtp->seq_cnt, ms, dtp->fmt);
248 len += scnprintf(buf+len, size-len, buffer,
249 dtp->data1, dtp->data2, dtp->data3);
250 }
251
252 lpfc_debugfs_enable = enable;
253 kfree(buffer);
254
255 return len;
256 }
257
258 static int lpfc_debugfs_last_hbq = -1;
259
260 /**
261 * lpfc_debugfs_hbqinfo_data - Dump host buffer queue info to a buffer
262 * @phba: The HBA to gather host buffer info from.
263 * @buf: The buffer to dump log into.
264 * @size: The maximum amount of data to process.
265 *
266 * Description:
267 * This routine dumps the host buffer queue info from the @phba to @buf up to
268 * @size number of bytes. A header that describes the current hbq state will be
269 * dumped to @buf first and then info on each hbq entry will be dumped to @buf
270 * until @size bytes have been dumped or all the hbq info has been dumped.
271 *
272 * Notes:
273 * This routine will rotate through each configured HBQ each time called.
274 *
275 * Return Value:
276 * This routine returns the amount of bytes that were dumped into @buf and will
277 * not exceed @size.
278 **/
279 static int
280 lpfc_debugfs_hbqinfo_data(struct lpfc_hba *phba, char *buf, int size)
281 {
282 int len = 0;
283 int i, j, found, posted, low;
284 uint32_t phys, raw_index, getidx;
285 struct lpfc_hbq_init *hip;
286 struct hbq_s *hbqs;
287 struct lpfc_hbq_entry *hbqe;
288 struct lpfc_dmabuf *d_buf;
289 struct hbq_dmabuf *hbq_buf;
290
291 if (phba->sli_rev != 3)
292 return 0;
293
294 spin_lock_irq(&phba->hbalock);
295
296 /* toggle between multiple hbqs, if any */
297 i = lpfc_sli_hbq_count();
298 if (i > 1) {
299 lpfc_debugfs_last_hbq++;
300 if (lpfc_debugfs_last_hbq >= i)
301 lpfc_debugfs_last_hbq = 0;
302 }
303 else
304 lpfc_debugfs_last_hbq = 0;
305
306 i = lpfc_debugfs_last_hbq;
307
308 len += scnprintf(buf+len, size-len, "HBQ %d Info\n", i);
309
310 hbqs = &phba->hbqs[i];
311 posted = 0;
312 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list)
313 posted++;
314
315 hip = lpfc_hbq_defs[i];
316 len += scnprintf(buf+len, size-len,
317 "idx:%d prof:%d rn:%d bufcnt:%d icnt:%d acnt:%d posted %d\n",
318 hip->hbq_index, hip->profile, hip->rn,
319 hip->buffer_count, hip->init_count, hip->add_count, posted);
320
321 raw_index = phba->hbq_get[i];
322 getidx = le32_to_cpu(raw_index);
323 len += scnprintf(buf+len, size-len,
324 "entries:%d bufcnt:%d Put:%d nPut:%d localGet:%d hbaGet:%d\n",
325 hbqs->entry_count, hbqs->buffer_count, hbqs->hbqPutIdx,
326 hbqs->next_hbqPutIdx, hbqs->local_hbqGetIdx, getidx);
327
328 hbqe = (struct lpfc_hbq_entry *) phba->hbqs[i].hbq_virt;
329 for (j=0; j<hbqs->entry_count; j++) {
330 len += scnprintf(buf+len, size-len,
331 "%03d: %08x %04x %05x ", j,
332 le32_to_cpu(hbqe->bde.addrLow),
333 le32_to_cpu(hbqe->bde.tus.w),
334 le32_to_cpu(hbqe->buffer_tag));
335 i = 0;
336 found = 0;
337
338 /* First calculate if slot has an associated posted buffer */
339 low = hbqs->hbqPutIdx - posted;
340 if (low >= 0) {
341 if ((j >= hbqs->hbqPutIdx) || (j < low)) {
342 len += scnprintf(buf + len, size - len,
343 "Unused\n");
344 goto skipit;
345 }
346 }
347 else {
348 if ((j >= hbqs->hbqPutIdx) &&
349 (j < (hbqs->entry_count+low))) {
350 len += scnprintf(buf + len, size - len,
351 "Unused\n");
352 goto skipit;
353 }
354 }
355
356 /* Get the Buffer info for the posted buffer */
357 list_for_each_entry(d_buf, &hbqs->hbq_buffer_list, list) {
358 hbq_buf = container_of(d_buf, struct hbq_dmabuf, dbuf);
359 phys = ((uint64_t)hbq_buf->dbuf.phys & 0xffffffff);
360 if (phys == le32_to_cpu(hbqe->bde.addrLow)) {
361 len += scnprintf(buf+len, size-len,
362 "Buf%d: x%px %06x\n", i,
363 hbq_buf->dbuf.virt, hbq_buf->tag);
364 found = 1;
365 break;
366 }
367 i++;
368 }
369 if (!found) {
370 len += scnprintf(buf+len, size-len, "No DMAinfo?\n");
371 }
372 skipit:
373 hbqe++;
374 if (len > LPFC_HBQINFO_SIZE - 54)
375 break;
376 }
377 spin_unlock_irq(&phba->hbalock);
378 return len;
379 }
380
381 static int lpfc_debugfs_last_xripool;
382
383 /**
384 * lpfc_debugfs_commonxripools_data - Dump Hardware Queue info to a buffer
385 * @phba: The HBA to gather host buffer info from.
386 * @buf: The buffer to dump log into.
387 * @size: The maximum amount of data to process.
388 *
389 * Description:
390 * This routine dumps the Hardware Queue info from the @phba to @buf up to
391 * @size number of bytes. A header that describes the current hdwq state will be
392 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
393 * until @size bytes have been dumped or all the hdwq info has been dumped.
394 *
395 * Notes:
396 * This routine will rotate through each configured Hardware Queue each
397 * time called.
398 *
399 * Return Value:
400 * This routine returns the amount of bytes that were dumped into @buf and will
401 * not exceed @size.
402 **/
403 static int
404 lpfc_debugfs_commonxripools_data(struct lpfc_hba *phba, char *buf, int size)
405 {
406 struct lpfc_sli4_hdw_queue *qp;
407 int len = 0;
408 int i, out;
409 unsigned long iflag;
410
411 for (i = 0; i < phba->cfg_hdw_queue; i++) {
412 if (len > (LPFC_DUMP_MULTIXRIPOOL_SIZE - 80))
413 break;
414 qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_xripool];
415
416 len += scnprintf(buf + len, size - len, "HdwQ %d Info ", i);
417 spin_lock_irqsave(&qp->abts_io_buf_list_lock, iflag);
418 spin_lock(&qp->io_buf_list_get_lock);
419 spin_lock(&qp->io_buf_list_put_lock);
420 out = qp->total_io_bufs - (qp->get_io_bufs + qp->put_io_bufs +
421 qp->abts_scsi_io_bufs + qp->abts_nvme_io_bufs);
422 len += scnprintf(buf + len, size - len,
423 "tot:%d get:%d put:%d mt:%d "
424 "ABTS scsi:%d nvme:%d Out:%d\n",
425 qp->total_io_bufs, qp->get_io_bufs, qp->put_io_bufs,
426 qp->empty_io_bufs, qp->abts_scsi_io_bufs,
427 qp->abts_nvme_io_bufs, out);
428 spin_unlock(&qp->io_buf_list_put_lock);
429 spin_unlock(&qp->io_buf_list_get_lock);
430 spin_unlock_irqrestore(&qp->abts_io_buf_list_lock, iflag);
431
432 lpfc_debugfs_last_xripool++;
433 if (lpfc_debugfs_last_xripool >= phba->cfg_hdw_queue)
434 lpfc_debugfs_last_xripool = 0;
435 }
436
437 return len;
438 }
439
440 /**
441 * lpfc_debugfs_multixripools_data - Display multi-XRI pools information
442 * @phba: The HBA to gather host buffer info from.
443 * @buf: The buffer to dump log into.
444 * @size: The maximum amount of data to process.
445 *
446 * Description:
447 * This routine displays current multi-XRI pools information including XRI
448 * count in public, private and txcmplq. It also displays current high and
449 * low watermark.
450 *
451 * Return Value:
452 * This routine returns the amount of bytes that were dumped into @buf and will
453 * not exceed @size.
454 **/
455 static int
456 lpfc_debugfs_multixripools_data(struct lpfc_hba *phba, char *buf, int size)
457 {
458 u32 i;
459 u32 hwq_count;
460 struct lpfc_sli4_hdw_queue *qp;
461 struct lpfc_multixri_pool *multixri_pool;
462 struct lpfc_pvt_pool *pvt_pool;
463 struct lpfc_pbl_pool *pbl_pool;
464 u32 txcmplq_cnt;
465 char tmp[LPFC_DEBUG_OUT_LINE_SZ] = {0};
466
467 if (phba->sli_rev != LPFC_SLI_REV4)
468 return 0;
469
470 if (!phba->sli4_hba.hdwq)
471 return 0;
472
473 if (!phba->cfg_xri_rebalancing) {
474 i = lpfc_debugfs_commonxripools_data(phba, buf, size);
475 return i;
476 }
477
478 /*
479 * Pbl: Current number of free XRIs in public pool
480 * Pvt: Current number of free XRIs in private pool
481 * Busy: Current number of outstanding XRIs
482 * HWM: Current high watermark
483 * pvt_empty: Incremented by 1 when IO submission fails (no xri)
484 * pbl_empty: Incremented by 1 when all pbl_pool are empty during
485 * IO submission
486 */
487 scnprintf(tmp, sizeof(tmp),
488 "HWQ: Pbl Pvt Busy HWM | pvt_empty pbl_empty ");
489 if (strlcat(buf, tmp, size) >= size)
490 return strnlen(buf, size);
491
492 #ifdef LPFC_MXP_STAT
493 /*
494 * MAXH: Max high watermark seen so far
495 * above_lmt: Incremented by 1 if xri_owned > xri_limit during
496 * IO submission
497 * below_lmt: Incremented by 1 if xri_owned <= xri_limit during
498 * IO submission
499 * locPbl_hit: Incremented by 1 if successfully get a batch of XRI from
500 * local pbl_pool
501 * othPbl_hit: Incremented by 1 if successfully get a batch of XRI from
502 * other pbl_pool
503 */
504 scnprintf(tmp, sizeof(tmp),
505 "MAXH above_lmt below_lmt locPbl_hit othPbl_hit");
506 if (strlcat(buf, tmp, size) >= size)
507 return strnlen(buf, size);
508
509 /*
510 * sPbl: snapshot of Pbl 15 sec after stat gets cleared
511 * sPvt: snapshot of Pvt 15 sec after stat gets cleared
512 * sBusy: snapshot of Busy 15 sec after stat gets cleared
513 */
514 scnprintf(tmp, sizeof(tmp),
515 " | sPbl sPvt sBusy");
516 if (strlcat(buf, tmp, size) >= size)
517 return strnlen(buf, size);
518 #endif
519
520 scnprintf(tmp, sizeof(tmp), "\n");
521 if (strlcat(buf, tmp, size) >= size)
522 return strnlen(buf, size);
523
524 hwq_count = phba->cfg_hdw_queue;
525 for (i = 0; i < hwq_count; i++) {
526 qp = &phba->sli4_hba.hdwq[i];
527 multixri_pool = qp->p_multixri_pool;
528 if (!multixri_pool)
529 continue;
530 pbl_pool = &multixri_pool->pbl_pool;
531 pvt_pool = &multixri_pool->pvt_pool;
532 txcmplq_cnt = qp->io_wq->pring->txcmplq_cnt;
533
534 scnprintf(tmp, sizeof(tmp),
535 "%03d: %4d %4d %4d %4d | %10d %10d ",
536 i, pbl_pool->count, pvt_pool->count,
537 txcmplq_cnt, pvt_pool->high_watermark,
538 qp->empty_io_bufs, multixri_pool->pbl_empty_count);
539 if (strlcat(buf, tmp, size) >= size)
540 break;
541
542 #ifdef LPFC_MXP_STAT
543 scnprintf(tmp, sizeof(tmp),
544 "%4d %10d %10d %10d %10d",
545 multixri_pool->stat_max_hwm,
546 multixri_pool->above_limit_count,
547 multixri_pool->below_limit_count,
548 multixri_pool->local_pbl_hit_count,
549 multixri_pool->other_pbl_hit_count);
550 if (strlcat(buf, tmp, size) >= size)
551 break;
552
553 scnprintf(tmp, sizeof(tmp),
554 " | %4d %4d %5d",
555 multixri_pool->stat_pbl_count,
556 multixri_pool->stat_pvt_count,
557 multixri_pool->stat_busy_count);
558 if (strlcat(buf, tmp, size) >= size)
559 break;
560 #endif
561
562 scnprintf(tmp, sizeof(tmp), "\n");
563 if (strlcat(buf, tmp, size) >= size)
564 break;
565 }
566 return strnlen(buf, size);
567 }
568
569
570 #ifdef LPFC_HDWQ_LOCK_STAT
571 static int lpfc_debugfs_last_lock;
572
573 /**
574 * lpfc_debugfs_lockstat_data - Dump Hardware Queue info to a buffer
575 * @phba: The HBA to gather host buffer info from.
576 * @buf: The buffer to dump log into.
577 * @size: The maximum amount of data to process.
578 *
579 * Description:
580 * This routine dumps the Hardware Queue info from the @phba to @buf up to
581 * @size number of bytes. A header that describes the current hdwq state will be
582 * dumped to @buf first and then info on each hdwq entry will be dumped to @buf
583 * until @size bytes have been dumped or all the hdwq info has been dumped.
584 *
585 * Notes:
586 * This routine will rotate through each configured Hardware Queue each
587 * time called.
588 *
589 * Return Value:
590 * This routine returns the amount of bytes that were dumped into @buf and will
591 * not exceed @size.
592 **/
593 static int
594 lpfc_debugfs_lockstat_data(struct lpfc_hba *phba, char *buf, int size)
595 {
596 struct lpfc_sli4_hdw_queue *qp;
597 int len = 0;
598 int i;
599
600 if (phba->sli_rev != LPFC_SLI_REV4)
601 return 0;
602
603 if (!phba->sli4_hba.hdwq)
604 return 0;
605
606 for (i = 0; i < phba->cfg_hdw_queue; i++) {
607 if (len > (LPFC_HDWQINFO_SIZE - 100))
608 break;
609 qp = &phba->sli4_hba.hdwq[lpfc_debugfs_last_lock];
610
611 len += scnprintf(buf + len, size - len, "HdwQ %03d Lock ", i);
612 if (phba->cfg_xri_rebalancing) {
613 len += scnprintf(buf + len, size - len,
614 "get_pvt:%d mv_pvt:%d "
615 "mv2pub:%d mv2pvt:%d "
616 "put_pvt:%d put_pub:%d wq:%d\n",
617 qp->lock_conflict.alloc_pvt_pool,
618 qp->lock_conflict.mv_from_pvt_pool,
619 qp->lock_conflict.mv_to_pub_pool,
620 qp->lock_conflict.mv_to_pvt_pool,
621 qp->lock_conflict.free_pvt_pool,
622 qp->lock_conflict.free_pub_pool,
623 qp->lock_conflict.wq_access);
624 } else {
625 len += scnprintf(buf + len, size - len,
626 "get:%d put:%d free:%d wq:%d\n",
627 qp->lock_conflict.alloc_xri_get,
628 qp->lock_conflict.alloc_xri_put,
629 qp->lock_conflict.free_xri,
630 qp->lock_conflict.wq_access);
631 }
632
633 lpfc_debugfs_last_lock++;
634 if (lpfc_debugfs_last_lock >= phba->cfg_hdw_queue)
635 lpfc_debugfs_last_lock = 0;
636 }
637
638 return len;
639 }
640 #endif
641
642 static int lpfc_debugfs_last_hba_slim_off;
643
644 /**
645 * lpfc_debugfs_dumpHBASlim_data - Dump HBA SLIM info to a buffer
646 * @phba: The HBA to gather SLIM info from.
647 * @buf: The buffer to dump log into.
648 * @size: The maximum amount of data to process.
649 *
650 * Description:
651 * This routine dumps the current contents of HBA SLIM for the HBA associated
652 * with @phba to @buf up to @size bytes of data. This is the raw HBA SLIM data.
653 *
654 * Notes:
655 * This routine will only dump up to 1024 bytes of data each time called and
656 * should be called multiple times to dump the entire HBA SLIM.
657 *
658 * Return Value:
659 * This routine returns the amount of bytes that were dumped into @buf and will
660 * not exceed @size.
661 **/
662 static int
663 lpfc_debugfs_dumpHBASlim_data(struct lpfc_hba *phba, char *buf, int size)
664 {
665 int len = 0;
666 int i, off;
667 uint32_t *ptr;
668 char *buffer;
669
670 buffer = kmalloc(1024, GFP_KERNEL);
671 if (!buffer)
672 return 0;
673
674 off = 0;
675 spin_lock_irq(&phba->hbalock);
676
677 len += scnprintf(buf+len, size-len, "HBA SLIM\n");
678 lpfc_memcpy_from_slim(buffer,
679 phba->MBslimaddr + lpfc_debugfs_last_hba_slim_off, 1024);
680
681 ptr = (uint32_t *)&buffer[0];
682 off = lpfc_debugfs_last_hba_slim_off;
683
684 /* Set it up for the next time */
685 lpfc_debugfs_last_hba_slim_off += 1024;
686 if (lpfc_debugfs_last_hba_slim_off >= 4096)
687 lpfc_debugfs_last_hba_slim_off = 0;
688
689 i = 1024;
690 while (i > 0) {
691 len += scnprintf(buf+len, size-len,
692 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
693 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
694 *(ptr+5), *(ptr+6), *(ptr+7));
695 ptr += 8;
696 i -= (8 * sizeof(uint32_t));
697 off += (8 * sizeof(uint32_t));
698 }
699
700 spin_unlock_irq(&phba->hbalock);
701 kfree(buffer);
702
703 return len;
704 }
705
706 /**
707 * lpfc_debugfs_dumpHostSlim_data - Dump host SLIM info to a buffer
708 * @phba: The HBA to gather Host SLIM info from.
709 * @buf: The buffer to dump log into.
710 * @size: The maximum amount of data to process.
711 *
712 * Description:
713 * This routine dumps the current contents of host SLIM for the host associated
714 * with @phba to @buf up to @size bytes of data. The dump will contain the
715 * Mailbox, PCB, Rings, and Registers that are located in host memory.
716 *
717 * Return Value:
718 * This routine returns the amount of bytes that were dumped into @buf and will
719 * not exceed @size.
720 **/
721 static int
722 lpfc_debugfs_dumpHostSlim_data(struct lpfc_hba *phba, char *buf, int size)
723 {
724 int len = 0;
725 int i, off;
726 uint32_t word0, word1, word2, word3;
727 uint32_t *ptr;
728 struct lpfc_pgp *pgpp;
729 struct lpfc_sli *psli = &phba->sli;
730 struct lpfc_sli_ring *pring;
731
732 off = 0;
733 spin_lock_irq(&phba->hbalock);
734
735 len += scnprintf(buf+len, size-len, "SLIM Mailbox\n");
736 ptr = (uint32_t *)phba->slim2p.virt;
737 i = sizeof(MAILBOX_t);
738 while (i > 0) {
739 len += scnprintf(buf+len, size-len,
740 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
741 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
742 *(ptr+5), *(ptr+6), *(ptr+7));
743 ptr += 8;
744 i -= (8 * sizeof(uint32_t));
745 off += (8 * sizeof(uint32_t));
746 }
747
748 len += scnprintf(buf+len, size-len, "SLIM PCB\n");
749 ptr = (uint32_t *)phba->pcb;
750 i = sizeof(PCB_t);
751 while (i > 0) {
752 len += scnprintf(buf+len, size-len,
753 "%08x: %08x %08x %08x %08x %08x %08x %08x %08x\n",
754 off, *ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4),
755 *(ptr+5), *(ptr+6), *(ptr+7));
756 ptr += 8;
757 i -= (8 * sizeof(uint32_t));
758 off += (8 * sizeof(uint32_t));
759 }
760
761 if (phba->sli_rev <= LPFC_SLI_REV3) {
762 for (i = 0; i < 4; i++) {
763 pgpp = &phba->port_gp[i];
764 pring = &psli->sli3_ring[i];
765 len += scnprintf(buf+len, size-len,
766 "Ring %d: CMD GetInx:%d "
767 "(Max:%d Next:%d "
768 "Local:%d flg:x%x) "
769 "RSP PutInx:%d Max:%d\n",
770 i, pgpp->cmdGetInx,
771 pring->sli.sli3.numCiocb,
772 pring->sli.sli3.next_cmdidx,
773 pring->sli.sli3.local_getidx,
774 pring->flag, pgpp->rspPutInx,
775 pring->sli.sli3.numRiocb);
776 }
777
778 word0 = readl(phba->HAregaddr);
779 word1 = readl(phba->CAregaddr);
780 word2 = readl(phba->HSregaddr);
781 word3 = readl(phba->HCregaddr);
782 len += scnprintf(buf+len, size-len, "HA:%08x CA:%08x HS:%08x "
783 "HC:%08x\n", word0, word1, word2, word3);
784 }
785 spin_unlock_irq(&phba->hbalock);
786 return len;
787 }
788
789 /**
790 * lpfc_debugfs_nodelist_data - Dump target node list to a buffer
791 * @vport: The vport to gather target node info from.
792 * @buf: The buffer to dump log into.
793 * @size: The maximum amount of data to process.
794 *
795 * Description:
796 * This routine dumps the current target node list associated with @vport to
797 * @buf up to @size bytes of data. Each node entry in the dump will contain a
798 * node state, DID, WWPN, WWNN, RPI, flags, type, and other useful fields.
799 *
800 * Return Value:
801 * This routine returns the amount of bytes that were dumped into @buf and will
802 * not exceed @size.
803 **/
804 static int
805 lpfc_debugfs_nodelist_data(struct lpfc_vport *vport, char *buf, int size)
806 {
807 int len = 0;
808 int i, iocnt, outio, cnt;
809 struct lpfc_hba *phba = vport->phba;
810 struct lpfc_nodelist *ndlp;
811 unsigned char *statep;
812 unsigned long iflags;
813 struct nvme_fc_local_port *localport;
814 struct nvme_fc_remote_port *nrport = NULL;
815 struct lpfc_nvme_rport *rport;
816
817 cnt = (LPFC_NODELIST_SIZE / LPFC_NODELIST_ENTRY_SIZE);
818 outio = 0;
819
820 len += scnprintf(buf+len, size-len, "\nFCP Nodelist Entries ...\n");
821 spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
822 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
823 iocnt = 0;
824 if (!cnt) {
825 len += scnprintf(buf+len, size-len,
826 "Missing Nodelist Entries\n");
827 break;
828 }
829 cnt--;
830 switch (ndlp->nlp_state) {
831 case NLP_STE_UNUSED_NODE:
832 statep = "UNUSED";
833 break;
834 case NLP_STE_PLOGI_ISSUE:
835 statep = "PLOGI ";
836 break;
837 case NLP_STE_ADISC_ISSUE:
838 statep = "ADISC ";
839 break;
840 case NLP_STE_REG_LOGIN_ISSUE:
841 statep = "REGLOG";
842 break;
843 case NLP_STE_PRLI_ISSUE:
844 statep = "PRLI ";
845 break;
846 case NLP_STE_LOGO_ISSUE:
847 statep = "LOGO ";
848 break;
849 case NLP_STE_UNMAPPED_NODE:
850 statep = "UNMAP ";
851 iocnt = 1;
852 break;
853 case NLP_STE_MAPPED_NODE:
854 statep = "MAPPED";
855 iocnt = 1;
856 break;
857 case NLP_STE_NPR_NODE:
858 statep = "NPR ";
859 break;
860 default:
861 statep = "UNKNOWN";
862 }
863 len += scnprintf(buf+len, size-len, "%s DID:x%06x ",
864 statep, ndlp->nlp_DID);
865 len += scnprintf(buf+len, size-len,
866 "WWPN x%016llx ",
867 wwn_to_u64(ndlp->nlp_portname.u.wwn));
868 len += scnprintf(buf+len, size-len,
869 "WWNN x%016llx ",
870 wwn_to_u64(ndlp->nlp_nodename.u.wwn));
871 len += scnprintf(buf+len, size-len, "RPI:x%04x ",
872 ndlp->nlp_rpi);
873 len += scnprintf(buf+len, size-len, "flag:x%08lx ",
874 ndlp->nlp_flag);
875 if (!ndlp->nlp_type)
876 len += scnprintf(buf+len, size-len, "UNKNOWN_TYPE ");
877 if (ndlp->nlp_type & NLP_FC_NODE)
878 len += scnprintf(buf+len, size-len, "FC_NODE ");
879 if (ndlp->nlp_type & NLP_FABRIC) {
880 len += scnprintf(buf+len, size-len, "FABRIC ");
881 iocnt = 0;
882 }
883 if (ndlp->nlp_type & NLP_FCP_TARGET)
884 len += scnprintf(buf+len, size-len, "FCP_TGT sid:%d ",
885 ndlp->nlp_sid);
886 if (ndlp->nlp_type & NLP_FCP_INITIATOR)
887 len += scnprintf(buf+len, size-len, "FCP_INITIATOR ");
888 if (ndlp->nlp_type & NLP_NVME_TARGET)
889 len += scnprintf(buf + len,
890 size - len, "NVME_TGT sid:%d ",
891 NLP_NO_SID);
892 if (ndlp->nlp_type & NLP_NVME_INITIATOR)
893 len += scnprintf(buf + len,
894 size - len, "NVME_INITIATOR ");
895 len += scnprintf(buf+len, size-len, "refcnt:%d",
896 kref_read(&ndlp->kref));
897 if (iocnt) {
898 i = atomic_read(&ndlp->cmd_pending);
899 len += scnprintf(buf + len, size - len,
900 " OutIO:x%x Qdepth x%x",
901 i, ndlp->cmd_qdepth);
902 outio += i;
903 }
904 len += scnprintf(buf+len, size-len, " xpt:x%x",
905 ndlp->fc4_xpt_flags);
906 if (ndlp->nlp_defer_did != NLP_EVT_NOTHING_PENDING)
907 len += scnprintf(buf+len, size-len, " defer:%x",
908 ndlp->nlp_defer_did);
909 len += scnprintf(buf+len, size-len, "\n");
910 }
911 spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
912
913 len += scnprintf(buf + len, size - len,
914 "\nOutstanding IO x%x\n", outio);
915
916 if (phba->nvmet_support && phba->targetport && (vport == phba->pport)) {
917 len += scnprintf(buf + len, size - len,
918 "\nNVME Targetport Entry ...\n");
919
920 /* Port state is only one of two values for now. */
921 if (phba->targetport->port_id)
922 statep = "REGISTERED";
923 else
924 statep = "INIT";
925 len += scnprintf(buf + len, size - len,
926 "TGT WWNN x%llx WWPN x%llx State %s\n",
927 wwn_to_u64(vport->fc_nodename.u.wwn),
928 wwn_to_u64(vport->fc_portname.u.wwn),
929 statep);
930 len += scnprintf(buf + len, size - len,
931 " Targetport DID x%06x\n",
932 phba->targetport->port_id);
933 goto out_exit;
934 }
935
936 len += scnprintf(buf + len, size - len,
937 "\nNVME Lport/Rport Entries ...\n");
938
939 localport = vport->localport;
940 if (!localport)
941 goto out_exit;
942
943 /* Port state is only one of two values for now. */
944 if (localport->port_id)
945 statep = "ONLINE";
946 else
947 statep = "UNKNOWN ";
948
949 len += scnprintf(buf + len, size - len,
950 "Lport DID x%06x PortState %s\n",
951 localport->port_id, statep);
952
953 len += scnprintf(buf + len, size - len, "\tRport List:\n");
954 spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
955 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
956 /* local short-hand pointer. */
957 spin_lock(&ndlp->lock);
958 rport = lpfc_ndlp_get_nrport(ndlp);
959 if (rport)
960 nrport = rport->remoteport;
961 else
962 nrport = NULL;
963 spin_unlock(&ndlp->lock);
964 if (!nrport)
965 continue;
966
967 /* Port state is only one of two values for now. */
968 switch (nrport->port_state) {
969 case FC_OBJSTATE_ONLINE:
970 statep = "ONLINE";
971 break;
972 case FC_OBJSTATE_UNKNOWN:
973 statep = "UNKNOWN ";
974 break;
975 default:
976 statep = "UNSUPPORTED";
977 break;
978 }
979
980 /* Tab in to show lport ownership. */
981 len += scnprintf(buf + len, size - len,
982 "\t%s Port ID:x%06x ",
983 statep, nrport->port_id);
984 len += scnprintf(buf + len, size - len, "WWPN x%llx ",
985 nrport->port_name);
986 len += scnprintf(buf + len, size - len, "WWNN x%llx ",
987 nrport->node_name);
988
989 /* An NVME rport can have multiple roles. */
990 if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR)
991 len += scnprintf(buf + len, size - len,
992 "INITIATOR ");
993 if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET)
994 len += scnprintf(buf + len, size - len,
995 "TARGET ");
996 if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY)
997 len += scnprintf(buf + len, size - len,
998 "DISCSRVC ");
999 if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
1000 FC_PORT_ROLE_NVME_TARGET |
1001 FC_PORT_ROLE_NVME_DISCOVERY))
1002 len += scnprintf(buf + len, size - len,
1003 "UNKNOWN ROLE x%x",
1004 nrport->port_role);
1005 /* Terminate the string. */
1006 len += scnprintf(buf + len, size - len, "\n");
1007 }
1008 spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
1009 out_exit:
1010 return len;
1011 }
1012
1013 /**
1014 * lpfc_debugfs_nvmestat_data - Dump target node list to a buffer
1015 * @vport: The vport to gather target node info from.
1016 * @buf: The buffer to dump log into.
1017 * @size: The maximum amount of data to process.
1018 *
1019 * Description:
1020 * This routine dumps the NVME statistics associated with @vport
1021 *
1022 * Return Value:
1023 * This routine returns the amount of bytes that were dumped into @buf and will
1024 * not exceed @size.
1025 **/
1026 static int
1027 lpfc_debugfs_nvmestat_data(struct lpfc_vport *vport, char *buf, int size)
1028 {
1029 struct lpfc_hba *phba = vport->phba;
1030 struct lpfc_nvmet_tgtport *tgtp;
1031 struct lpfc_async_xchg_ctx *ctxp, *next_ctxp;
1032 struct nvme_fc_local_port *localport;
1033 struct lpfc_fc4_ctrl_stat *cstat;
1034 struct lpfc_nvme_lport *lport;
1035 uint64_t data1, data2, data3;
1036 uint64_t tot, totin, totout;
1037 int cnt, i;
1038 int len = 0;
1039
1040 if (phba->nvmet_support) {
1041 if (!phba->targetport)
1042 return len;
1043 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
1044 len += scnprintf(buf + len, size - len,
1045 "\nNVME Targetport Statistics\n");
1046
1047 len += scnprintf(buf + len, size - len,
1048 "LS: Rcv %08x Drop %08x Abort %08x\n",
1049 atomic_read(&tgtp->rcv_ls_req_in),
1050 atomic_read(&tgtp->rcv_ls_req_drop),
1051 atomic_read(&tgtp->xmt_ls_abort));
1052 if (atomic_read(&tgtp->rcv_ls_req_in) !=
1053 atomic_read(&tgtp->rcv_ls_req_out)) {
1054 len += scnprintf(buf + len, size - len,
1055 "Rcv LS: in %08x != out %08x\n",
1056 atomic_read(&tgtp->rcv_ls_req_in),
1057 atomic_read(&tgtp->rcv_ls_req_out));
1058 }
1059
1060 len += scnprintf(buf + len, size - len,
1061 "LS: Xmt %08x Drop %08x Cmpl %08x\n",
1062 atomic_read(&tgtp->xmt_ls_rsp),
1063 atomic_read(&tgtp->xmt_ls_drop),
1064 atomic_read(&tgtp->xmt_ls_rsp_cmpl));
1065
1066 len += scnprintf(buf + len, size - len,
1067 "LS: RSP Abort %08x xb %08x Err %08x\n",
1068 atomic_read(&tgtp->xmt_ls_rsp_aborted),
1069 atomic_read(&tgtp->xmt_ls_rsp_xb_set),
1070 atomic_read(&tgtp->xmt_ls_rsp_error));
1071
1072 len += scnprintf(buf + len, size - len,
1073 "FCP: Rcv %08x Defer %08x Release %08x "
1074 "Drop %08x\n",
1075 atomic_read(&tgtp->rcv_fcp_cmd_in),
1076 atomic_read(&tgtp->rcv_fcp_cmd_defer),
1077 atomic_read(&tgtp->xmt_fcp_release),
1078 atomic_read(&tgtp->rcv_fcp_cmd_drop));
1079
1080 if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
1081 atomic_read(&tgtp->rcv_fcp_cmd_out)) {
1082 len += scnprintf(buf + len, size - len,
1083 "Rcv FCP: in %08x != out %08x\n",
1084 atomic_read(&tgtp->rcv_fcp_cmd_in),
1085 atomic_read(&tgtp->rcv_fcp_cmd_out));
1086 }
1087
1088 len += scnprintf(buf + len, size - len,
1089 "FCP Rsp: read %08x readrsp %08x "
1090 "write %08x rsp %08x\n",
1091 atomic_read(&tgtp->xmt_fcp_read),
1092 atomic_read(&tgtp->xmt_fcp_read_rsp),
1093 atomic_read(&tgtp->xmt_fcp_write),
1094 atomic_read(&tgtp->xmt_fcp_rsp));
1095
1096 len += scnprintf(buf + len, size - len,
1097 "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
1098 atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
1099 atomic_read(&tgtp->xmt_fcp_rsp_error),
1100 atomic_read(&tgtp->xmt_fcp_rsp_drop));
1101
1102 len += scnprintf(buf + len, size - len,
1103 "FCP Rsp Abort: %08x xb %08x xricqe %08x\n",
1104 atomic_read(&tgtp->xmt_fcp_rsp_aborted),
1105 atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
1106 atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
1107
1108 len += scnprintf(buf + len, size - len,
1109 "ABORT: Xmt %08x Cmpl %08x\n",
1110 atomic_read(&tgtp->xmt_fcp_abort),
1111 atomic_read(&tgtp->xmt_fcp_abort_cmpl));
1112
1113 len += scnprintf(buf + len, size - len,
1114 "ABORT: Sol %08x Usol %08x Err %08x Cmpl %08x",
1115 atomic_read(&tgtp->xmt_abort_sol),
1116 atomic_read(&tgtp->xmt_abort_unsol),
1117 atomic_read(&tgtp->xmt_abort_rsp),
1118 atomic_read(&tgtp->xmt_abort_rsp_error));
1119
1120 len += scnprintf(buf + len, size - len, "\n");
1121
1122 cnt = 0;
1123 spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1124 list_for_each_entry_safe(ctxp, next_ctxp,
1125 &phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
1126 list) {
1127 cnt++;
1128 }
1129 spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1130 if (cnt) {
1131 len += scnprintf(buf + len, size - len,
1132 "ABORT: %d ctx entries\n", cnt);
1133 spin_lock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1134 list_for_each_entry_safe(ctxp, next_ctxp,
1135 &phba->sli4_hba.lpfc_abts_nvmet_ctx_list,
1136 list) {
1137 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ))
1138 break;
1139 len += scnprintf(buf + len, size - len,
1140 "Entry: oxid %x state %x "
1141 "flag %x\n",
1142 ctxp->oxid, ctxp->state,
1143 ctxp->flag);
1144 }
1145 spin_unlock(&phba->sli4_hba.abts_nvmet_buf_list_lock);
1146 }
1147
1148 /* Calculate outstanding IOs */
1149 tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
1150 tot += atomic_read(&tgtp->xmt_fcp_release);
1151 tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
1152
1153 len += scnprintf(buf + len, size - len,
1154 "IO_CTX: %08x WAIT: cur %08x tot %08x\n"
1155 "CTX Outstanding %08llx\n",
1156 phba->sli4_hba.nvmet_xri_cnt,
1157 phba->sli4_hba.nvmet_io_wait_cnt,
1158 phba->sli4_hba.nvmet_io_wait_total,
1159 tot);
1160 } else {
1161 if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME))
1162 return len;
1163
1164 localport = vport->localport;
1165 if (!localport)
1166 return len;
1167 lport = (struct lpfc_nvme_lport *)localport->private;
1168 if (!lport)
1169 return len;
1170
1171 len += scnprintf(buf + len, size - len,
1172 "\nNVME HDWQ Statistics\n");
1173
1174 len += scnprintf(buf + len, size - len,
1175 "LS: Xmt %016x Cmpl %016x\n",
1176 atomic_read(&lport->fc4NvmeLsRequests),
1177 atomic_read(&lport->fc4NvmeLsCmpls));
1178
1179 totin = 0;
1180 totout = 0;
1181 for (i = 0; i < phba->cfg_hdw_queue; i++) {
1182 cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
1183 tot = cstat->io_cmpls;
1184 totin += tot;
1185 data1 = cstat->input_requests;
1186 data2 = cstat->output_requests;
1187 data3 = cstat->control_requests;
1188 totout += (data1 + data2 + data3);
1189
1190 /* Limit to 32, debugfs display buffer limitation */
1191 if (i >= 32)
1192 continue;
1193
1194 len += scnprintf(buf + len, PAGE_SIZE - len,
1195 "HDWQ (%d): Rd %016llx Wr %016llx "
1196 "IO %016llx ",
1197 i, data1, data2, data3);
1198 len += scnprintf(buf + len, PAGE_SIZE - len,
1199 "Cmpl %016llx OutIO %016llx\n",
1200 tot, ((data1 + data2 + data3) - tot));
1201 }
1202 len += scnprintf(buf + len, PAGE_SIZE - len,
1203 "Total FCP Cmpl %016llx Issue %016llx "
1204 "OutIO %016llx\n",
1205 totin, totout, totout - totin);
1206
1207 len += scnprintf(buf + len, size - len,
1208 "LS Xmt Err: Abrt %08x Err %08x "
1209 "Cmpl Err: xb %08x Err %08x\n",
1210 atomic_read(&lport->xmt_ls_abort),
1211 atomic_read(&lport->xmt_ls_err),
1212 atomic_read(&lport->cmpl_ls_xb),
1213 atomic_read(&lport->cmpl_ls_err));
1214
1215 len += scnprintf(buf + len, size - len,
1216 "FCP Xmt Err: noxri %06x nondlp %06x "
1217 "qdepth %06x wqerr %06x err %06x Abrt %06x\n",
1218 atomic_read(&lport->xmt_fcp_noxri),
1219 atomic_read(&lport->xmt_fcp_bad_ndlp),
1220 atomic_read(&lport->xmt_fcp_qdepth),
1221 atomic_read(&lport->xmt_fcp_wqerr),
1222 atomic_read(&lport->xmt_fcp_err),
1223 atomic_read(&lport->xmt_fcp_abort));
1224
1225 len += scnprintf(buf + len, size - len,
1226 "FCP Cmpl Err: xb %08x Err %08x\n",
1227 atomic_read(&lport->cmpl_fcp_xb),
1228 atomic_read(&lport->cmpl_fcp_err));
1229
1230 }
1231
1232 return len;
1233 }
1234
1235 /**
1236 * lpfc_debugfs_scsistat_data - Dump target node list to a buffer
1237 * @vport: The vport to gather target node info from.
1238 * @buf: The buffer to dump log into.
1239 * @size: The maximum amount of data to process.
1240 *
1241 * Description:
1242 * This routine dumps the SCSI statistics associated with @vport
1243 *
1244 * Return Value:
1245 * This routine returns the amount of bytes that were dumped into @buf and will
1246 * not exceed @size.
1247 **/
1248 static int
1249 lpfc_debugfs_scsistat_data(struct lpfc_vport *vport, char *buf, int size)
1250 {
1251 int len;
1252 struct lpfc_hba *phba = vport->phba;
1253 struct lpfc_fc4_ctrl_stat *cstat;
1254 u64 data1, data2, data3;
1255 u64 tot, totin, totout;
1256 int i;
1257 char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
1258
1259 if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
1260 (phba->sli_rev != LPFC_SLI_REV4))
1261 return 0;
1262
1263 scnprintf(buf, size, "SCSI HDWQ Statistics\n");
1264
1265 totin = 0;
1266 totout = 0;
1267 for (i = 0; i < phba->cfg_hdw_queue; i++) {
1268 cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
1269 tot = cstat->io_cmpls;
1270 totin += tot;
1271 data1 = cstat->input_requests;
1272 data2 = cstat->output_requests;
1273 data3 = cstat->control_requests;
1274 totout += (data1 + data2 + data3);
1275
1276 scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
1277 "IO %016llx ", i, data1, data2, data3);
1278 if (strlcat(buf, tmp, size) >= size)
1279 goto buffer_done;
1280
1281 scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
1282 tot, ((data1 + data2 + data3) - tot));
1283 if (strlcat(buf, tmp, size) >= size)
1284 goto buffer_done;
1285 }
1286 scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
1287 "OutIO %016llx\n", totin, totout, totout - totin);
1288 strlcat(buf, tmp, size);
1289
1290 buffer_done:
1291 len = strnlen(buf, size);
1292
1293 return len;
1294 }
1295
1296 void
1297 lpfc_io_ktime(struct lpfc_hba *phba, struct lpfc_io_buf *lpfc_cmd)
1298 {
1299 uint64_t seg1, seg2, seg3, seg4;
1300 uint64_t segsum;
1301
1302 if (!lpfc_cmd->ts_last_cmd ||
1303 !lpfc_cmd->ts_cmd_start ||
1304 !lpfc_cmd->ts_cmd_wqput ||
1305 !lpfc_cmd->ts_isr_cmpl ||
1306 !lpfc_cmd->ts_data_io)
1307 return;
1308
1309 if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_cmd_start)
1310 return;
1311 if (lpfc_cmd->ts_cmd_start < lpfc_cmd->ts_last_cmd)
1312 return;
1313 if (lpfc_cmd->ts_cmd_wqput < lpfc_cmd->ts_cmd_start)
1314 return;
1315 if (lpfc_cmd->ts_isr_cmpl < lpfc_cmd->ts_cmd_wqput)
1316 return;
1317 if (lpfc_cmd->ts_data_io < lpfc_cmd->ts_isr_cmpl)
1318 return;
1319 /*
1320 * Segment 1 - Time from Last FCP command cmpl is handed
1321 * off to NVME Layer to start of next command.
1322 * Segment 2 - Time from Driver receives a IO cmd start
1323 * from NVME Layer to WQ put is done on IO cmd.
1324 * Segment 3 - Time from Driver WQ put is done on IO cmd
1325 * to MSI-X ISR for IO cmpl.
1326 * Segment 4 - Time from MSI-X ISR for IO cmpl to when
1327 * cmpl is handled off to the NVME Layer.
1328 */
1329 seg1 = lpfc_cmd->ts_cmd_start - lpfc_cmd->ts_last_cmd;
1330 if (seg1 > 5000000) /* 5 ms - for sequential IOs only */
1331 seg1 = 0;
1332
1333 /* Calculate times relative to start of IO */
1334 seg2 = (lpfc_cmd->ts_cmd_wqput - lpfc_cmd->ts_cmd_start);
1335 segsum = seg2;
1336 seg3 = lpfc_cmd->ts_isr_cmpl - lpfc_cmd->ts_cmd_start;
1337 if (segsum > seg3)
1338 return;
1339 seg3 -= segsum;
1340 segsum += seg3;
1341
1342 seg4 = lpfc_cmd->ts_data_io - lpfc_cmd->ts_cmd_start;
1343 if (segsum > seg4)
1344 return;
1345 seg4 -= segsum;
1346
1347 phba->ktime_data_samples++;
1348 phba->ktime_seg1_total += seg1;
1349 if (seg1 < phba->ktime_seg1_min)
1350 phba->ktime_seg1_min = seg1;
1351 else if (seg1 > phba->ktime_seg1_max)
1352 phba->ktime_seg1_max = seg1;
1353 phba->ktime_seg2_total += seg2;
1354 if (seg2 < phba->ktime_seg2_min)
1355 phba->ktime_seg2_min = seg2;
1356 else if (seg2 > phba->ktime_seg2_max)
1357 phba->ktime_seg2_max = seg2;
1358 phba->ktime_seg3_total += seg3;
1359 if (seg3 < phba->ktime_seg3_min)
1360 phba->ktime_seg3_min = seg3;
1361 else if (seg3 > phba->ktime_seg3_max)
1362 phba->ktime_seg3_max = seg3;
1363 phba->ktime_seg4_total += seg4;
1364 if (seg4 < phba->ktime_seg4_min)
1365 phba->ktime_seg4_min = seg4;
1366 else if (seg4 > phba->ktime_seg4_max)
1367 phba->ktime_seg4_max = seg4;
1368
1369 lpfc_cmd->ts_last_cmd = 0;
1370 lpfc_cmd->ts_cmd_start = 0;
1371 lpfc_cmd->ts_cmd_wqput = 0;
1372 lpfc_cmd->ts_isr_cmpl = 0;
1373 lpfc_cmd->ts_data_io = 0;
1374 }
1375
1376 /**
1377 * lpfc_debugfs_ioktime_data - Dump target node list to a buffer
1378 * @vport: The vport to gather target node info from.
1379 * @buf: The buffer to dump log into.
1380 * @size: The maximum amount of data to process.
1381 *
1382 * Description:
1383 * This routine dumps the NVME statistics associated with @vport
1384 *
1385 * Return Value:
1386 * This routine returns the amount of bytes that were dumped into @buf and will
1387 * not exceed @size.
1388 **/
1389 static int
1390 lpfc_debugfs_ioktime_data(struct lpfc_vport *vport, char *buf, int size)
1391 {
1392 struct lpfc_hba *phba = vport->phba;
1393 int len = 0;
1394
1395 if (phba->nvmet_support == 0) {
1396 /* Initiator */
1397 len += scnprintf(buf + len, PAGE_SIZE - len,
1398 "ktime %s: Total Samples: %lld\n",
1399 (phba->ktime_on ? "Enabled" : "Disabled"),
1400 phba->ktime_data_samples);
1401 if (phba->ktime_data_samples == 0)
1402 return len;
1403
1404 len += scnprintf(
1405 buf + len, PAGE_SIZE - len,
1406 "Segment 1: Last Cmd cmpl "
1407 "done -to- Start of next Cmd (in driver)\n");
1408 len += scnprintf(
1409 buf + len, PAGE_SIZE - len,
1410 "avg:%08lld min:%08lld max %08lld\n",
1411 div_u64(phba->ktime_seg1_total,
1412 phba->ktime_data_samples),
1413 phba->ktime_seg1_min,
1414 phba->ktime_seg1_max);
1415 len += scnprintf(
1416 buf + len, PAGE_SIZE - len,
1417 "Segment 2: Driver start of Cmd "
1418 "-to- Firmware WQ doorbell\n");
1419 len += scnprintf(
1420 buf + len, PAGE_SIZE - len,
1421 "avg:%08lld min:%08lld max %08lld\n",
1422 div_u64(phba->ktime_seg2_total,
1423 phba->ktime_data_samples),
1424 phba->ktime_seg2_min,
1425 phba->ktime_seg2_max);
1426 len += scnprintf(
1427 buf + len, PAGE_SIZE - len,
1428 "Segment 3: Firmware WQ doorbell -to- "
1429 "MSI-X ISR cmpl\n");
1430 len += scnprintf(
1431 buf + len, PAGE_SIZE - len,
1432 "avg:%08lld min:%08lld max %08lld\n",
1433 div_u64(phba->ktime_seg3_total,
1434 phba->ktime_data_samples),
1435 phba->ktime_seg3_min,
1436 phba->ktime_seg3_max);
1437 len += scnprintf(
1438 buf + len, PAGE_SIZE - len,
1439 "Segment 4: MSI-X ISR cmpl -to- "
1440 "Cmd cmpl done\n");
1441 len += scnprintf(
1442 buf + len, PAGE_SIZE - len,
1443 "avg:%08lld min:%08lld max %08lld\n",
1444 div_u64(phba->ktime_seg4_total,
1445 phba->ktime_data_samples),
1446 phba->ktime_seg4_min,
1447 phba->ktime_seg4_max);
1448 len += scnprintf(
1449 buf + len, PAGE_SIZE - len,
1450 "Total IO avg time: %08lld\n",
1451 div_u64(phba->ktime_seg1_total +
1452 phba->ktime_seg2_total +
1453 phba->ktime_seg3_total +
1454 phba->ktime_seg4_total,
1455 phba->ktime_data_samples));
1456 return len;
1457 }
1458
1459 /* NVME Target */
1460 len += scnprintf(buf + len, PAGE_SIZE-len,
1461 "ktime %s: Total Samples: %lld %lld\n",
1462 (phba->ktime_on ? "Enabled" : "Disabled"),
1463 phba->ktime_data_samples,
1464 phba->ktime_status_samples);
1465 if (phba->ktime_data_samples == 0)
1466 return len;
1467
1468 len += scnprintf(buf + len, PAGE_SIZE-len,
1469 "Segment 1: MSI-X ISR Rcv cmd -to- "
1470 "cmd pass to NVME Layer\n");
1471 len += scnprintf(buf + len, PAGE_SIZE-len,
1472 "avg:%08lld min:%08lld max %08lld\n",
1473 div_u64(phba->ktime_seg1_total,
1474 phba->ktime_data_samples),
1475 phba->ktime_seg1_min,
1476 phba->ktime_seg1_max);
1477 len += scnprintf(buf + len, PAGE_SIZE-len,
1478 "Segment 2: cmd pass to NVME Layer- "
1479 "-to- Driver rcv cmd OP (action)\n");
1480 len += scnprintf(buf + len, PAGE_SIZE-len,
1481 "avg:%08lld min:%08lld max %08lld\n",
1482 div_u64(phba->ktime_seg2_total,
1483 phba->ktime_data_samples),
1484 phba->ktime_seg2_min,
1485 phba->ktime_seg2_max);
1486 len += scnprintf(buf + len, PAGE_SIZE-len,
1487 "Segment 3: Driver rcv cmd OP -to- "
1488 "Firmware WQ doorbell: cmd\n");
1489 len += scnprintf(buf + len, PAGE_SIZE-len,
1490 "avg:%08lld min:%08lld max %08lld\n",
1491 div_u64(phba->ktime_seg3_total,
1492 phba->ktime_data_samples),
1493 phba->ktime_seg3_min,
1494 phba->ktime_seg3_max);
1495 len += scnprintf(buf + len, PAGE_SIZE-len,
1496 "Segment 4: Firmware WQ doorbell: cmd "
1497 "-to- MSI-X ISR for cmd cmpl\n");
1498 len += scnprintf(buf + len, PAGE_SIZE-len,
1499 "avg:%08lld min:%08lld max %08lld\n",
1500 div_u64(phba->ktime_seg4_total,
1501 phba->ktime_data_samples),
1502 phba->ktime_seg4_min,
1503 phba->ktime_seg4_max);
1504 len += scnprintf(buf + len, PAGE_SIZE-len,
1505 "Segment 5: MSI-X ISR for cmd cmpl "
1506 "-to- NVME layer passed cmd done\n");
1507 len += scnprintf(buf + len, PAGE_SIZE-len,
1508 "avg:%08lld min:%08lld max %08lld\n",
1509 div_u64(phba->ktime_seg5_total,
1510 phba->ktime_data_samples),
1511 phba->ktime_seg5_min,
1512 phba->ktime_seg5_max);
1513
1514 if (phba->ktime_status_samples == 0) {
1515 len += scnprintf(buf + len, PAGE_SIZE-len,
1516 "Total: cmd received by MSI-X ISR "
1517 "-to- cmd completed on wire\n");
1518 len += scnprintf(buf + len, PAGE_SIZE-len,
1519 "avg:%08lld min:%08lld "
1520 "max %08lld\n",
1521 div_u64(phba->ktime_seg10_total,
1522 phba->ktime_data_samples),
1523 phba->ktime_seg10_min,
1524 phba->ktime_seg10_max);
1525 return len;
1526 }
1527
1528 len += scnprintf(buf + len, PAGE_SIZE-len,
1529 "Segment 6: NVME layer passed cmd done "
1530 "-to- Driver rcv rsp status OP\n");
1531 len += scnprintf(buf + len, PAGE_SIZE-len,
1532 "avg:%08lld min:%08lld max %08lld\n",
1533 div_u64(phba->ktime_seg6_total,
1534 phba->ktime_status_samples),
1535 phba->ktime_seg6_min,
1536 phba->ktime_seg6_max);
1537 len += scnprintf(buf + len, PAGE_SIZE-len,
1538 "Segment 7: Driver rcv rsp status OP "
1539 "-to- Firmware WQ doorbell: status\n");
1540 len += scnprintf(buf + len, PAGE_SIZE-len,
1541 "avg:%08lld min:%08lld max %08lld\n",
1542 div_u64(phba->ktime_seg7_total,
1543 phba->ktime_status_samples),
1544 phba->ktime_seg7_min,
1545 phba->ktime_seg7_max);
1546 len += scnprintf(buf + len, PAGE_SIZE-len,
1547 "Segment 8: Firmware WQ doorbell: status"
1548 " -to- MSI-X ISR for status cmpl\n");
1549 len += scnprintf(buf + len, PAGE_SIZE-len,
1550 "avg:%08lld min:%08lld max %08lld\n",
1551 div_u64(phba->ktime_seg8_total,
1552 phba->ktime_status_samples),
1553 phba->ktime_seg8_min,
1554 phba->ktime_seg8_max);
1555 len += scnprintf(buf + len, PAGE_SIZE-len,
1556 "Segment 9: MSI-X ISR for status cmpl "
1557 "-to- NVME layer passed status done\n");
1558 len += scnprintf(buf + len, PAGE_SIZE-len,
1559 "avg:%08lld min:%08lld max %08lld\n",
1560 div_u64(phba->ktime_seg9_total,
1561 phba->ktime_status_samples),
1562 phba->ktime_seg9_min,
1563 phba->ktime_seg9_max);
1564 len += scnprintf(buf + len, PAGE_SIZE-len,
1565 "Total: cmd received by MSI-X ISR -to- "
1566 "cmd completed on wire\n");
1567 len += scnprintf(buf + len, PAGE_SIZE-len,
1568 "avg:%08lld min:%08lld max %08lld\n",
1569 div_u64(phba->ktime_seg10_total,
1570 phba->ktime_status_samples),
1571 phba->ktime_seg10_min,
1572 phba->ktime_seg10_max);
1573 return len;
1574 }
1575
1576 /**
1577 * lpfc_debugfs_nvmeio_trc_data - Dump NVME IO trace list to a buffer
1578 * @phba: The phba to gather target node info from.
1579 * @buf: The buffer to dump log into.
1580 * @size: The maximum amount of data to process.
1581 *
1582 * Description:
1583 * This routine dumps the NVME IO trace associated with @phba
1584 *
1585 * Return Value:
1586 * This routine returns the amount of bytes that were dumped into @buf and will
1587 * not exceed @size.
1588 **/
1589 static int
1590 lpfc_debugfs_nvmeio_trc_data(struct lpfc_hba *phba, char *buf, int size)
1591 {
1592 struct lpfc_debugfs_nvmeio_trc *dtp;
1593 int i, state, index, skip;
1594 int len = 0;
1595
1596 state = phba->nvmeio_trc_on;
1597
1598 index = (atomic_read(&phba->nvmeio_trc_cnt) + 1) &
1599 (phba->nvmeio_trc_size - 1);
1600 skip = phba->nvmeio_trc_output_idx;
1601
1602 len += scnprintf(buf + len, size - len,
1603 "%s IO Trace %s: next_idx %d skip %d size %d\n",
1604 (phba->nvmet_support ? "NVME" : "NVMET"),
1605 (state ? "Enabled" : "Disabled"),
1606 index, skip, phba->nvmeio_trc_size);
1607
1608 if (!phba->nvmeio_trc || state)
1609 return len;
1610
1611 /* trace MUST bhe off to continue */
1612
1613 for (i = index; i < phba->nvmeio_trc_size; i++) {
1614 if (skip) {
1615 skip--;
1616 continue;
1617 }
1618 dtp = phba->nvmeio_trc + i;
1619 phba->nvmeio_trc_output_idx++;
1620
1621 if (!dtp->fmt)
1622 continue;
1623
1624 len += scnprintf(buf + len, size - len, dtp->fmt,
1625 dtp->data1, dtp->data2, dtp->data3);
1626
1627 if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
1628 phba->nvmeio_trc_output_idx = 0;
1629 len += scnprintf(buf + len, size - len,
1630 "Trace Complete\n");
1631 goto out;
1632 }
1633
1634 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
1635 len += scnprintf(buf + len, size - len,
1636 "Trace Continue (%d of %d)\n",
1637 phba->nvmeio_trc_output_idx,
1638 phba->nvmeio_trc_size);
1639 goto out;
1640 }
1641 }
1642 for (i = 0; i < index; i++) {
1643 if (skip) {
1644 skip--;
1645 continue;
1646 }
1647 dtp = phba->nvmeio_trc + i;
1648 phba->nvmeio_trc_output_idx++;
1649
1650 if (!dtp->fmt)
1651 continue;
1652
1653 len += scnprintf(buf + len, size - len, dtp->fmt,
1654 dtp->data1, dtp->data2, dtp->data3);
1655
1656 if (phba->nvmeio_trc_output_idx >= phba->nvmeio_trc_size) {
1657 phba->nvmeio_trc_output_idx = 0;
1658 len += scnprintf(buf + len, size - len,
1659 "Trace Complete\n");
1660 goto out;
1661 }
1662
1663 if (len >= (size - LPFC_DEBUG_OUT_LINE_SZ)) {
1664 len += scnprintf(buf + len, size - len,
1665 "Trace Continue (%d of %d)\n",
1666 phba->nvmeio_trc_output_idx,
1667 phba->nvmeio_trc_size);
1668 goto out;
1669 }
1670 }
1671
1672 len += scnprintf(buf + len, size - len,
1673 "Trace Done\n");
1674 out:
1675 return len;
1676 }
1677
1678 /**
1679 * lpfc_debugfs_hdwqstat_data - Dump I/O stats to a buffer
1680 * @vport: The vport to gather target node info from.
1681 * @buf: The buffer to dump log into.
1682 * @size: The maximum amount of data to process.
1683 *
1684 * Description:
1685 * This routine dumps the NVME + SCSI statistics associated with @vport
1686 *
1687 * Return Value:
1688 * This routine returns the amount of bytes that were dumped into @buf and will
1689 * not exceed @size.
1690 **/
1691 static int
1692 lpfc_debugfs_hdwqstat_data(struct lpfc_vport *vport, char *buf, int size)
1693 {
1694 struct lpfc_hba *phba = vport->phba;
1695 struct lpfc_hdwq_stat *c_stat;
1696 int i, j, len;
1697 uint32_t tot_xmt;
1698 uint32_t tot_rcv;
1699 uint32_t tot_cmpl;
1700 char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
1701
1702 scnprintf(tmp, sizeof(tmp), "HDWQ Stats:\n\n");
1703 if (strlcat(buf, tmp, size) >= size)
1704 goto buffer_done;
1705
1706 scnprintf(tmp, sizeof(tmp), "(NVME Accounting: %s) ",
1707 (phba->hdwqstat_on &
1708 (LPFC_CHECK_NVME_IO | LPFC_CHECK_NVMET_IO) ?
1709 "Enabled" : "Disabled"));
1710 if (strlcat(buf, tmp, size) >= size)
1711 goto buffer_done;
1712
1713 scnprintf(tmp, sizeof(tmp), "(SCSI Accounting: %s) ",
1714 (phba->hdwqstat_on & LPFC_CHECK_SCSI_IO ?
1715 "Enabled" : "Disabled"));
1716 if (strlcat(buf, tmp, size) >= size)
1717 goto buffer_done;
1718
1719 scnprintf(tmp, sizeof(tmp), "\n\n");
1720 if (strlcat(buf, tmp, size) >= size)
1721 goto buffer_done;
1722
1723 for (i = 0; i < phba->cfg_hdw_queue; i++) {
1724 tot_rcv = 0;
1725 tot_xmt = 0;
1726 tot_cmpl = 0;
1727
1728 for_each_present_cpu(j) {
1729 c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, j);
1730
1731 /* Only display for this HDWQ */
1732 if (i != c_stat->hdwq_no)
1733 continue;
1734
1735 /* Only display non-zero counters */
1736 if (!c_stat->xmt_io && !c_stat->cmpl_io &&
1737 !c_stat->rcv_io)
1738 continue;
1739
1740 if (!tot_xmt && !tot_cmpl && !tot_rcv) {
1741 /* Print HDWQ string only the first time */
1742 scnprintf(tmp, sizeof(tmp), "[HDWQ %d]:\t", i);
1743 if (strlcat(buf, tmp, size) >= size)
1744 goto buffer_done;
1745 }
1746
1747 tot_xmt += c_stat->xmt_io;
1748 tot_cmpl += c_stat->cmpl_io;
1749 if (phba->nvmet_support)
1750 tot_rcv += c_stat->rcv_io;
1751
1752 scnprintf(tmp, sizeof(tmp), "| [CPU %d]: ", j);
1753 if (strlcat(buf, tmp, size) >= size)
1754 goto buffer_done;
1755
1756 if (phba->nvmet_support) {
1757 scnprintf(tmp, sizeof(tmp),
1758 "XMT 0x%x CMPL 0x%x RCV 0x%x |",
1759 c_stat->xmt_io, c_stat->cmpl_io,
1760 c_stat->rcv_io);
1761 if (strlcat(buf, tmp, size) >= size)
1762 goto buffer_done;
1763 } else {
1764 scnprintf(tmp, sizeof(tmp),
1765 "XMT 0x%x CMPL 0x%x |",
1766 c_stat->xmt_io, c_stat->cmpl_io);
1767 if (strlcat(buf, tmp, size) >= size)
1768 goto buffer_done;
1769 }
1770 }
1771
1772 /* Check if nothing to display */
1773 if (!tot_xmt && !tot_cmpl && !tot_rcv)
1774 continue;
1775
1776 scnprintf(tmp, sizeof(tmp), "\t->\t[HDWQ Total: ");
1777 if (strlcat(buf, tmp, size) >= size)
1778 goto buffer_done;
1779
1780 if (phba->nvmet_support) {
1781 scnprintf(tmp, sizeof(tmp),
1782 "XMT 0x%x CMPL 0x%x RCV 0x%x]\n\n",
1783 tot_xmt, tot_cmpl, tot_rcv);
1784 if (strlcat(buf, tmp, size) >= size)
1785 goto buffer_done;
1786 } else {
1787 scnprintf(tmp, sizeof(tmp),
1788 "XMT 0x%x CMPL 0x%x]\n\n",
1789 tot_xmt, tot_cmpl);
1790 if (strlcat(buf, tmp, size) >= size)
1791 goto buffer_done;
1792 }
1793 }
1794
1795 buffer_done:
1796 len = strnlen(buf, size);
1797 return len;
1798 }
1799
1800 #endif
1801
1802 /**
1803 * lpfc_debugfs_disc_trc - Store discovery trace log
1804 * @vport: The vport to associate this trace string with for retrieval.
1805 * @mask: Log entry classification.
1806 * @fmt: Format string to be displayed when dumping the log.
1807 * @data1: 1st data parameter to be applied to @fmt.
1808 * @data2: 2nd data parameter to be applied to @fmt.
1809 * @data3: 3rd data parameter to be applied to @fmt.
1810 *
1811 * Description:
1812 * This routine is used by the driver code to add a debugfs log entry to the
1813 * discovery trace buffer associated with @vport. Only entries with a @mask that
1814 * match the current debugfs discovery mask will be saved. Entries that do not
1815 * match will be thrown away. @fmt, @data1, @data2, and @data3 are used like
1816 * printf when displaying the log.
1817 **/
1818 inline void
1819 lpfc_debugfs_disc_trc(struct lpfc_vport *vport, int mask, char *fmt,
1820 uint32_t data1, uint32_t data2, uint32_t data3)
1821 {
1822 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1823 struct lpfc_debugfs_trc *dtp;
1824 int index;
1825
1826 if (!(lpfc_debugfs_mask_disc_trc & mask))
1827 return;
1828
1829 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_disc_trc ||
1830 !vport || !vport->disc_trc)
1831 return;
1832
1833 index = atomic_inc_return(&vport->disc_trc_cnt) &
1834 (lpfc_debugfs_max_disc_trc - 1);
1835 dtp = vport->disc_trc + index;
1836 dtp->fmt = fmt;
1837 dtp->data1 = data1;
1838 dtp->data2 = data2;
1839 dtp->data3 = data3;
1840 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
1841 dtp->jif = jiffies;
1842 #endif
1843 return;
1844 }
1845
1846 /**
1847 * lpfc_debugfs_slow_ring_trc - Store slow ring trace log
1848 * @phba: The phba to associate this trace string with for retrieval.
1849 * @fmt: Format string to be displayed when dumping the log.
1850 * @data1: 1st data parameter to be applied to @fmt.
1851 * @data2: 2nd data parameter to be applied to @fmt.
1852 * @data3: 3rd data parameter to be applied to @fmt.
1853 *
1854 * Description:
1855 * This routine is used by the driver code to add a debugfs log entry to the
1856 * discovery trace buffer associated with @vport. @fmt, @data1, @data2, and
1857 * @data3 are used like printf when displaying the log.
1858 **/
1859 inline void
1860 lpfc_debugfs_slow_ring_trc(struct lpfc_hba *phba, char *fmt,
1861 uint32_t data1, uint32_t data2, uint32_t data3)
1862 {
1863 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1864 struct lpfc_debugfs_trc *dtp;
1865 int index;
1866
1867 if (!lpfc_debugfs_enable || !lpfc_debugfs_max_slow_ring_trc ||
1868 !phba || !phba->slow_ring_trc)
1869 return;
1870
1871 index = atomic_inc_return(&phba->slow_ring_trc_cnt) &
1872 (lpfc_debugfs_max_slow_ring_trc - 1);
1873 dtp = phba->slow_ring_trc + index;
1874 dtp->fmt = fmt;
1875 dtp->data1 = data1;
1876 dtp->data2 = data2;
1877 dtp->data3 = data3;
1878 dtp->seq_cnt = atomic_inc_return(&lpfc_debugfs_seq_trc_cnt);
1879 dtp->jif = jiffies;
1880 #endif
1881 return;
1882 }
1883
1884 /**
1885 * lpfc_debugfs_nvme_trc - Store NVME/NVMET trace log
1886 * @phba: The phba to associate this trace string with for retrieval.
1887 * @fmt: Format string to be displayed when dumping the log.
1888 * @data1: 1st data parameter to be applied to @fmt.
1889 * @data2: 2nd data parameter to be applied to @fmt.
1890 * @data3: 3rd data parameter to be applied to @fmt.
1891 *
1892 * Description:
1893 * This routine is used by the driver code to add a debugfs log entry to the
1894 * nvme trace buffer associated with @phba. @fmt, @data1, @data2, and
1895 * @data3 are used like printf when displaying the log.
1896 **/
1897 inline void
1898 lpfc_debugfs_nvme_trc(struct lpfc_hba *phba, char *fmt,
1899 uint16_t data1, uint16_t data2, uint32_t data3)
1900 {
1901 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1902 struct lpfc_debugfs_nvmeio_trc *dtp;
1903 int index;
1904
1905 if (!phba->nvmeio_trc_on || !phba->nvmeio_trc)
1906 return;
1907
1908 index = atomic_inc_return(&phba->nvmeio_trc_cnt) &
1909 (phba->nvmeio_trc_size - 1);
1910 dtp = phba->nvmeio_trc + index;
1911 dtp->fmt = fmt;
1912 dtp->data1 = data1;
1913 dtp->data2 = data2;
1914 dtp->data3 = data3;
1915 #endif
1916 }
1917
1918 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
1919 /**
1920 * lpfc_debugfs_disc_trc_open - Open the discovery trace log
1921 * @inode: The inode pointer that contains a vport pointer.
1922 * @file: The file pointer to attach the log output.
1923 *
1924 * Description:
1925 * This routine is the entry point for the debugfs open file operation. It gets
1926 * the vport from the i_private field in @inode, allocates the necessary buffer
1927 * for the log, fills the buffer from the in-memory log for this vport, and then
1928 * returns a pointer to that log in the private_data field in @file.
1929 *
1930 * Returns:
1931 * This function returns zero if successful. On error it will return a negative
1932 * error value.
1933 **/
1934 static int
1935 lpfc_debugfs_disc_trc_open(struct inode *inode, struct file *file)
1936 {
1937 struct lpfc_vport *vport = inode->i_private;
1938 struct lpfc_debug *debug;
1939 int size;
1940 int rc = -ENOMEM;
1941
1942 if (!lpfc_debugfs_max_disc_trc) {
1943 rc = -ENOSPC;
1944 goto out;
1945 }
1946
1947 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
1948 if (!debug)
1949 goto out;
1950
1951 /* Round to page boundary */
1952 size = (lpfc_debugfs_max_disc_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
1953 size = PAGE_ALIGN(size);
1954
1955 debug->buffer = kmalloc(size, GFP_KERNEL);
1956 if (!debug->buffer) {
1957 kfree(debug);
1958 goto out;
1959 }
1960
1961 debug->len = lpfc_debugfs_disc_trc_data(vport, debug->buffer, size);
1962 file->private_data = debug;
1963
1964 rc = 0;
1965 out:
1966 return rc;
1967 }
1968
1969 /**
1970 * lpfc_debugfs_slow_ring_trc_open - Open the Slow Ring trace log
1971 * @inode: The inode pointer that contains a vport pointer.
1972 * @file: The file pointer to attach the log output.
1973 *
1974 * Description:
1975 * This routine is the entry point for the debugfs open file operation. It gets
1976 * the vport from the i_private field in @inode, allocates the necessary buffer
1977 * for the log, fills the buffer from the in-memory log for this vport, and then
1978 * returns a pointer to that log in the private_data field in @file.
1979 *
1980 * Returns:
1981 * This function returns zero if successful. On error it will return a negative
1982 * error value.
1983 **/
1984 static int
1985 lpfc_debugfs_slow_ring_trc_open(struct inode *inode, struct file *file)
1986 {
1987 struct lpfc_hba *phba = inode->i_private;
1988 struct lpfc_debug *debug;
1989 int size;
1990 int rc = -ENOMEM;
1991
1992 if (!lpfc_debugfs_max_slow_ring_trc) {
1993 rc = -ENOSPC;
1994 goto out;
1995 }
1996
1997 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
1998 if (!debug)
1999 goto out;
2000
2001 /* Round to page boundary */
2002 size = (lpfc_debugfs_max_slow_ring_trc * LPFC_DEBUG_TRC_ENTRY_SIZE);
2003 size = PAGE_ALIGN(size);
2004
2005 debug->buffer = kmalloc(size, GFP_KERNEL);
2006 if (!debug->buffer) {
2007 kfree(debug);
2008 goto out;
2009 }
2010
2011 debug->len = lpfc_debugfs_slow_ring_trc_data(phba, debug->buffer, size);
2012 file->private_data = debug;
2013
2014 rc = 0;
2015 out:
2016 return rc;
2017 }
2018
2019 /**
2020 * lpfc_debugfs_hbqinfo_open - Open the hbqinfo debugfs buffer
2021 * @inode: The inode pointer that contains a vport pointer.
2022 * @file: The file pointer to attach the log output.
2023 *
2024 * Description:
2025 * This routine is the entry point for the debugfs open file operation. It gets
2026 * the vport from the i_private field in @inode, allocates the necessary buffer
2027 * for the log, fills the buffer from the in-memory log for this vport, and then
2028 * returns a pointer to that log in the private_data field in @file.
2029 *
2030 * Returns:
2031 * This function returns zero if successful. On error it will return a negative
2032 * error value.
2033 **/
2034 static int
2035 lpfc_debugfs_hbqinfo_open(struct inode *inode, struct file *file)
2036 {
2037 struct lpfc_hba *phba = inode->i_private;
2038 struct lpfc_debug *debug;
2039 int rc = -ENOMEM;
2040
2041 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2042 if (!debug)
2043 goto out;
2044
2045 /* Round to page boundary */
2046 debug->buffer = kmalloc(LPFC_HBQINFO_SIZE, GFP_KERNEL);
2047 if (!debug->buffer) {
2048 kfree(debug);
2049 goto out;
2050 }
2051
2052 debug->len = lpfc_debugfs_hbqinfo_data(phba, debug->buffer,
2053 LPFC_HBQINFO_SIZE);
2054 file->private_data = debug;
2055
2056 rc = 0;
2057 out:
2058 return rc;
2059 }
2060
2061 /**
2062 * lpfc_debugfs_multixripools_open - Open the multixripool debugfs buffer
2063 * @inode: The inode pointer that contains a hba pointer.
2064 * @file: The file pointer to attach the log output.
2065 *
2066 * Description:
2067 * This routine is the entry point for the debugfs open file operation. It gets
2068 * the hba from the i_private field in @inode, allocates the necessary buffer
2069 * for the log, fills the buffer from the in-memory log for this hba, and then
2070 * returns a pointer to that log in the private_data field in @file.
2071 *
2072 * Returns:
2073 * This function returns zero if successful. On error it will return a negative
2074 * error value.
2075 **/
2076 static int
2077 lpfc_debugfs_multixripools_open(struct inode *inode, struct file *file)
2078 {
2079 struct lpfc_hba *phba = inode->i_private;
2080 struct lpfc_debug *debug;
2081 int rc = -ENOMEM;
2082
2083 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2084 if (!debug)
2085 goto out;
2086
2087 /* Round to page boundary */
2088 debug->buffer = kzalloc(LPFC_DUMP_MULTIXRIPOOL_SIZE, GFP_KERNEL);
2089 if (!debug->buffer) {
2090 kfree(debug);
2091 goto out;
2092 }
2093
2094 debug->len = lpfc_debugfs_multixripools_data(
2095 phba, debug->buffer, LPFC_DUMP_MULTIXRIPOOL_SIZE);
2096
2097 debug->i_private = inode->i_private;
2098 file->private_data = debug;
2099
2100 rc = 0;
2101 out:
2102 return rc;
2103 }
2104
2105 #ifdef LPFC_HDWQ_LOCK_STAT
2106 /**
2107 * lpfc_debugfs_lockstat_open - Open the lockstat debugfs buffer
2108 * @inode: The inode pointer that contains a vport pointer.
2109 * @file: The file pointer to attach the log output.
2110 *
2111 * Description:
2112 * This routine is the entry point for the debugfs open file operation. It gets
2113 * the vport from the i_private field in @inode, allocates the necessary buffer
2114 * for the log, fills the buffer from the in-memory log for this vport, and then
2115 * returns a pointer to that log in the private_data field in @file.
2116 *
2117 * Returns:
2118 * This function returns zero if successful. On error it will return a negative
2119 * error value.
2120 **/
2121 static int
2122 lpfc_debugfs_lockstat_open(struct inode *inode, struct file *file)
2123 {
2124 struct lpfc_hba *phba = inode->i_private;
2125 struct lpfc_debug *debug;
2126 int rc = -ENOMEM;
2127
2128 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2129 if (!debug)
2130 goto out;
2131
2132 /* Round to page boundary */
2133 debug->buffer = kmalloc(LPFC_HDWQINFO_SIZE, GFP_KERNEL);
2134 if (!debug->buffer) {
2135 kfree(debug);
2136 goto out;
2137 }
2138
2139 debug->len = lpfc_debugfs_lockstat_data(phba, debug->buffer,
2140 LPFC_HBQINFO_SIZE);
2141 file->private_data = debug;
2142
2143 rc = 0;
2144 out:
2145 return rc;
2146 }
2147
2148 static ssize_t
2149 lpfc_debugfs_lockstat_write(struct file *file, const char __user *buf,
2150 size_t nbytes, loff_t *ppos)
2151 {
2152 struct lpfc_debug *debug = file->private_data;
2153 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2154 struct lpfc_sli4_hdw_queue *qp;
2155 char mybuf[64];
2156 char *pbuf;
2157 int i;
2158 size_t bsize;
2159
2160 memset(mybuf, 0, sizeof(mybuf));
2161
2162 bsize = min(nbytes, (sizeof(mybuf) - 1));
2163
2164 if (copy_from_user(mybuf, buf, bsize))
2165 return -EFAULT;
2166 pbuf = &mybuf[0];
2167
2168 if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
2169 (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
2170 for (i = 0; i < phba->cfg_hdw_queue; i++) {
2171 qp = &phba->sli4_hba.hdwq[i];
2172 qp->lock_conflict.alloc_xri_get = 0;
2173 qp->lock_conflict.alloc_xri_put = 0;
2174 qp->lock_conflict.free_xri = 0;
2175 qp->lock_conflict.wq_access = 0;
2176 qp->lock_conflict.alloc_pvt_pool = 0;
2177 qp->lock_conflict.mv_from_pvt_pool = 0;
2178 qp->lock_conflict.mv_to_pub_pool = 0;
2179 qp->lock_conflict.mv_to_pvt_pool = 0;
2180 qp->lock_conflict.free_pvt_pool = 0;
2181 qp->lock_conflict.free_pub_pool = 0;
2182 qp->lock_conflict.wq_access = 0;
2183 }
2184 }
2185 return bsize;
2186 }
2187 #endif
2188
2189 static int lpfc_debugfs_ras_log_data(struct lpfc_hba *phba,
2190 char *buffer, int size)
2191 {
2192 int copied = 0;
2193 struct lpfc_dmabuf *dmabuf, *next;
2194
2195 memset(buffer, 0, size);
2196
2197 spin_lock_irq(&phba->ras_fwlog_lock);
2198 if (phba->ras_fwlog.state != ACTIVE) {
2199 spin_unlock_irq(&phba->ras_fwlog_lock);
2200 return -EINVAL;
2201 }
2202 spin_unlock_irq(&phba->ras_fwlog_lock);
2203
2204 list_for_each_entry_safe(dmabuf, next,
2205 &phba->ras_fwlog.fwlog_buff_list, list) {
2206 /* Check if copying will go over size and a '\0' char */
2207 if ((copied + LPFC_RAS_MAX_ENTRY_SIZE) >= (size - 1)) {
2208 memcpy(buffer + copied, dmabuf->virt,
2209 size - copied - 1);
2210 copied += size - copied - 1;
2211 break;
2212 }
2213 memcpy(buffer + copied, dmabuf->virt, LPFC_RAS_MAX_ENTRY_SIZE);
2214 copied += LPFC_RAS_MAX_ENTRY_SIZE;
2215 }
2216 return copied;
2217 }
2218
2219 static int
2220 lpfc_debugfs_ras_log_release(struct inode *inode, struct file *file)
2221 {
2222 struct lpfc_debug *debug = file->private_data;
2223
2224 vfree(debug->buffer);
2225 kfree(debug);
2226
2227 return 0;
2228 }
2229
2230 /**
2231 * lpfc_debugfs_ras_log_open - Open the RAS log debugfs buffer
2232 * @inode: The inode pointer that contains a vport pointer.
2233 * @file: The file pointer to attach the log output.
2234 *
2235 * Description:
2236 * This routine is the entry point for the debugfs open file operation. It gets
2237 * the vport from the i_private field in @inode, allocates the necessary buffer
2238 * for the log, fills the buffer from the in-memory log for this vport, and then
2239 * returns a pointer to that log in the private_data field in @file.
2240 *
2241 * Returns:
2242 * This function returns zero if successful. On error it will return a negative
2243 * error value.
2244 **/
2245 static int
2246 lpfc_debugfs_ras_log_open(struct inode *inode, struct file *file)
2247 {
2248 struct lpfc_hba *phba = inode->i_private;
2249 struct lpfc_debug *debug;
2250 int size;
2251 int rc = -ENOMEM;
2252
2253 spin_lock_irq(&phba->ras_fwlog_lock);
2254 if (phba->ras_fwlog.state != ACTIVE) {
2255 spin_unlock_irq(&phba->ras_fwlog_lock);
2256 rc = -EINVAL;
2257 goto out;
2258 }
2259 spin_unlock_irq(&phba->ras_fwlog_lock);
2260
2261 if (check_mul_overflow(LPFC_RAS_MIN_BUFF_POST_SIZE,
2262 phba->cfg_ras_fwlog_buffsize, &size))
2263 goto out;
2264
2265 debug = kzalloc(sizeof(*debug), GFP_KERNEL);
2266 if (!debug)
2267 goto out;
2268
2269 debug->buffer = vmalloc(size);
2270 if (!debug->buffer)
2271 goto free_debug;
2272
2273 debug->len = lpfc_debugfs_ras_log_data(phba, debug->buffer, size);
2274 if (debug->len < 0) {
2275 rc = -EINVAL;
2276 goto free_buffer;
2277 }
2278 file->private_data = debug;
2279
2280 return 0;
2281
2282 free_buffer:
2283 vfree(debug->buffer);
2284 free_debug:
2285 kfree(debug);
2286 out:
2287 return rc;
2288 }
2289
2290 /**
2291 * lpfc_debugfs_dumpHBASlim_open - Open the Dump HBA SLIM debugfs buffer
2292 * @inode: The inode pointer that contains a vport pointer.
2293 * @file: The file pointer to attach the log output.
2294 *
2295 * Description:
2296 * This routine is the entry point for the debugfs open file operation. It gets
2297 * the vport from the i_private field in @inode, allocates the necessary buffer
2298 * for the log, fills the buffer from the in-memory log for this vport, and then
2299 * returns a pointer to that log in the private_data field in @file.
2300 *
2301 * Returns:
2302 * This function returns zero if successful. On error it will return a negative
2303 * error value.
2304 **/
2305 static int
2306 lpfc_debugfs_dumpHBASlim_open(struct inode *inode, struct file *file)
2307 {
2308 struct lpfc_hba *phba = inode->i_private;
2309 struct lpfc_debug *debug;
2310 int rc = -ENOMEM;
2311
2312 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2313 if (!debug)
2314 goto out;
2315
2316 /* Round to page boundary */
2317 debug->buffer = kmalloc(LPFC_DUMPHBASLIM_SIZE, GFP_KERNEL);
2318 if (!debug->buffer) {
2319 kfree(debug);
2320 goto out;
2321 }
2322
2323 debug->len = lpfc_debugfs_dumpHBASlim_data(phba, debug->buffer,
2324 LPFC_DUMPHBASLIM_SIZE);
2325 file->private_data = debug;
2326
2327 rc = 0;
2328 out:
2329 return rc;
2330 }
2331
2332 /**
2333 * lpfc_debugfs_dumpHostSlim_open - Open the Dump Host SLIM debugfs buffer
2334 * @inode: The inode pointer that contains a vport pointer.
2335 * @file: The file pointer to attach the log output.
2336 *
2337 * Description:
2338 * This routine is the entry point for the debugfs open file operation. It gets
2339 * the vport from the i_private field in @inode, allocates the necessary buffer
2340 * for the log, fills the buffer from the in-memory log for this vport, and then
2341 * returns a pointer to that log in the private_data field in @file.
2342 *
2343 * Returns:
2344 * This function returns zero if successful. On error it will return a negative
2345 * error value.
2346 **/
2347 static int
2348 lpfc_debugfs_dumpHostSlim_open(struct inode *inode, struct file *file)
2349 {
2350 struct lpfc_hba *phba = inode->i_private;
2351 struct lpfc_debug *debug;
2352 int rc = -ENOMEM;
2353
2354 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2355 if (!debug)
2356 goto out;
2357
2358 /* Round to page boundary */
2359 debug->buffer = kmalloc(LPFC_DUMPHOSTSLIM_SIZE, GFP_KERNEL);
2360 if (!debug->buffer) {
2361 kfree(debug);
2362 goto out;
2363 }
2364
2365 debug->len = lpfc_debugfs_dumpHostSlim_data(phba, debug->buffer,
2366 LPFC_DUMPHOSTSLIM_SIZE);
2367 file->private_data = debug;
2368
2369 rc = 0;
2370 out:
2371 return rc;
2372 }
2373
2374 static ssize_t
2375 lpfc_debugfs_dif_err_read(struct file *file, char __user *buf,
2376 size_t nbytes, loff_t *ppos)
2377 {
2378 struct dentry *dent = file->f_path.dentry;
2379 struct lpfc_hba *phba = file->private_data;
2380 char cbuf[32];
2381 uint64_t tmp = 0;
2382 int cnt = 0;
2383
2384 if (dent == phba->debug_writeGuard)
2385 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wgrd_cnt);
2386 else if (dent == phba->debug_writeApp)
2387 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wapp_cnt);
2388 else if (dent == phba->debug_writeRef)
2389 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_wref_cnt);
2390 else if (dent == phba->debug_readGuard)
2391 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rgrd_cnt);
2392 else if (dent == phba->debug_readApp)
2393 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rapp_cnt);
2394 else if (dent == phba->debug_readRef)
2395 cnt = scnprintf(cbuf, 32, "%u\n", phba->lpfc_injerr_rref_cnt);
2396 else if (dent == phba->debug_InjErrNPortID)
2397 cnt = scnprintf(cbuf, 32, "0x%06x\n",
2398 phba->lpfc_injerr_nportid);
2399 else if (dent == phba->debug_InjErrWWPN) {
2400 memcpy(&tmp, &phba->lpfc_injerr_wwpn, sizeof(struct lpfc_name));
2401 tmp = cpu_to_be64(tmp);
2402 cnt = scnprintf(cbuf, 32, "0x%016llx\n", tmp);
2403 } else if (dent == phba->debug_InjErrLBA) {
2404 if (phba->lpfc_injerr_lba == (sector_t)(-1))
2405 cnt = scnprintf(cbuf, 32, "off\n");
2406 else
2407 cnt = scnprintf(cbuf, 32, "0x%llx\n",
2408 (uint64_t) phba->lpfc_injerr_lba);
2409 } else
2410 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2411 "0547 Unknown debugfs error injection entry\n");
2412
2413 return simple_read_from_buffer(buf, nbytes, ppos, &cbuf, cnt);
2414 }
2415
2416 static ssize_t
2417 lpfc_debugfs_dif_err_write(struct file *file, const char __user *buf,
2418 size_t nbytes, loff_t *ppos)
2419 {
2420 struct dentry *dent = file->f_path.dentry;
2421 struct lpfc_hba *phba = file->private_data;
2422 char dstbuf[33];
2423 uint64_t tmp = 0;
2424 int size;
2425
2426 memset(dstbuf, 0, 33);
2427 size = (nbytes < 32) ? nbytes : 32;
2428 if (copy_from_user(dstbuf, buf, size))
2429 return -EFAULT;
2430
2431 if (dent == phba->debug_InjErrLBA) {
2432 if ((dstbuf[0] == 'o') && (dstbuf[1] == 'f') &&
2433 (dstbuf[2] == 'f'))
2434 tmp = (uint64_t)(-1);
2435 }
2436
2437 if ((tmp == 0) && (kstrtoull(dstbuf, 0, &tmp)))
2438 return -EINVAL;
2439
2440 if (dent == phba->debug_writeGuard)
2441 phba->lpfc_injerr_wgrd_cnt = (uint32_t)tmp;
2442 else if (dent == phba->debug_writeApp)
2443 phba->lpfc_injerr_wapp_cnt = (uint32_t)tmp;
2444 else if (dent == phba->debug_writeRef)
2445 phba->lpfc_injerr_wref_cnt = (uint32_t)tmp;
2446 else if (dent == phba->debug_readGuard)
2447 phba->lpfc_injerr_rgrd_cnt = (uint32_t)tmp;
2448 else if (dent == phba->debug_readApp)
2449 phba->lpfc_injerr_rapp_cnt = (uint32_t)tmp;
2450 else if (dent == phba->debug_readRef)
2451 phba->lpfc_injerr_rref_cnt = (uint32_t)tmp;
2452 else if (dent == phba->debug_InjErrLBA)
2453 phba->lpfc_injerr_lba = (sector_t)tmp;
2454 else if (dent == phba->debug_InjErrNPortID)
2455 phba->lpfc_injerr_nportid = (uint32_t)(tmp & Mask_DID);
2456 else if (dent == phba->debug_InjErrWWPN) {
2457 tmp = cpu_to_be64(tmp);
2458 memcpy(&phba->lpfc_injerr_wwpn, &tmp, sizeof(struct lpfc_name));
2459 } else
2460 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2461 "0548 Unknown debugfs error injection entry\n");
2462
2463 return nbytes;
2464 }
2465
2466 static int
2467 lpfc_debugfs_dif_err_release(struct inode *inode, struct file *file)
2468 {
2469 return 0;
2470 }
2471
2472 /**
2473 * lpfc_debugfs_nodelist_open - Open the nodelist debugfs file
2474 * @inode: The inode pointer that contains a vport pointer.
2475 * @file: The file pointer to attach the log output.
2476 *
2477 * Description:
2478 * This routine is the entry point for the debugfs open file operation. It gets
2479 * the vport from the i_private field in @inode, allocates the necessary buffer
2480 * for the log, fills the buffer from the in-memory log for this vport, and then
2481 * returns a pointer to that log in the private_data field in @file.
2482 *
2483 * Returns:
2484 * This function returns zero if successful. On error it will return a negative
2485 * error value.
2486 **/
2487 static int
2488 lpfc_debugfs_nodelist_open(struct inode *inode, struct file *file)
2489 {
2490 struct lpfc_vport *vport = inode->i_private;
2491 struct lpfc_debug *debug;
2492 int rc = -ENOMEM;
2493
2494 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2495 if (!debug)
2496 goto out;
2497
2498 /* Round to page boundary */
2499 debug->buffer = kmalloc(LPFC_NODELIST_SIZE, GFP_KERNEL);
2500 if (!debug->buffer) {
2501 kfree(debug);
2502 goto out;
2503 }
2504
2505 debug->len = lpfc_debugfs_nodelist_data(vport, debug->buffer,
2506 LPFC_NODELIST_SIZE);
2507 file->private_data = debug;
2508
2509 rc = 0;
2510 out:
2511 return rc;
2512 }
2513
2514 /**
2515 * lpfc_debugfs_lseek - Seek through a debugfs file
2516 * @file: The file pointer to seek through.
2517 * @off: The offset to seek to or the amount to seek by.
2518 * @whence: Indicates how to seek.
2519 *
2520 * Description:
2521 * This routine is the entry point for the debugfs lseek file operation. The
2522 * @whence parameter indicates whether @off is the offset to directly seek to,
2523 * or if it is a value to seek forward or reverse by. This function figures out
2524 * what the new offset of the debugfs file will be and assigns that value to the
2525 * f_pos field of @file.
2526 *
2527 * Returns:
2528 * This function returns the new offset if successful and returns a negative
2529 * error if unable to process the seek.
2530 **/
2531 static loff_t
2532 lpfc_debugfs_lseek(struct file *file, loff_t off, int whence)
2533 {
2534 struct lpfc_debug *debug = file->private_data;
2535 return fixed_size_llseek(file, off, whence, debug->len);
2536 }
2537
2538 /**
2539 * lpfc_debugfs_read - Read a debugfs file
2540 * @file: The file pointer to read from.
2541 * @buf: The buffer to copy the data to.
2542 * @nbytes: The number of bytes to read.
2543 * @ppos: The position in the file to start reading from.
2544 *
2545 * Description:
2546 * This routine reads data from from the buffer indicated in the private_data
2547 * field of @file. It will start reading at @ppos and copy up to @nbytes of
2548 * data to @buf.
2549 *
2550 * Returns:
2551 * This function returns the amount of data that was read (this could be less
2552 * than @nbytes if the end of the file was reached) or a negative error value.
2553 **/
2554 static ssize_t
2555 lpfc_debugfs_read(struct file *file, char __user *buf,
2556 size_t nbytes, loff_t *ppos)
2557 {
2558 struct lpfc_debug *debug = file->private_data;
2559
2560 return simple_read_from_buffer(buf, nbytes, ppos, debug->buffer,
2561 debug->len);
2562 }
2563
2564 /**
2565 * lpfc_debugfs_release - Release the buffer used to store debugfs file data
2566 * @inode: The inode pointer that contains a vport pointer. (unused)
2567 * @file: The file pointer that contains the buffer to release.
2568 *
2569 * Description:
2570 * This routine frees the buffer that was allocated when the debugfs file was
2571 * opened.
2572 *
2573 * Returns:
2574 * This function returns zero.
2575 **/
2576 static int
2577 lpfc_debugfs_release(struct inode *inode, struct file *file)
2578 {
2579 struct lpfc_debug *debug = file->private_data;
2580
2581 kfree(debug->buffer);
2582 kfree(debug);
2583
2584 return 0;
2585 }
2586
2587 /**
2588 * lpfc_debugfs_multixripools_write - Clear multi-XRI pools statistics
2589 * @file: The file pointer to read from.
2590 * @buf: The buffer to copy the user data from.
2591 * @nbytes: The number of bytes to get.
2592 * @ppos: The position in the file to start reading from.
2593 *
2594 * Description:
2595 * This routine clears multi-XRI pools statistics when buf contains "clear".
2596 *
2597 * Return Value:
2598 * It returns the @nbytges passing in from debugfs user space when successful.
2599 * In case of error conditions, it returns proper error code back to the user
2600 * space.
2601 **/
2602 static ssize_t
2603 lpfc_debugfs_multixripools_write(struct file *file, const char __user *buf,
2604 size_t nbytes, loff_t *ppos)
2605 {
2606 struct lpfc_debug *debug = file->private_data;
2607 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2608 char mybuf[64];
2609 char *pbuf;
2610 u32 i;
2611 u32 hwq_count;
2612 struct lpfc_sli4_hdw_queue *qp;
2613 struct lpfc_multixri_pool *multixri_pool;
2614
2615 if (nbytes > sizeof(mybuf) - 1)
2616 nbytes = sizeof(mybuf) - 1;
2617
2618 memset(mybuf, 0, sizeof(mybuf));
2619
2620 if (copy_from_user(mybuf, buf, nbytes))
2621 return -EFAULT;
2622 pbuf = &mybuf[0];
2623
2624 if ((strncmp(pbuf, "clear", strlen("clear"))) == 0) {
2625 hwq_count = phba->cfg_hdw_queue;
2626 for (i = 0; i < hwq_count; i++) {
2627 qp = &phba->sli4_hba.hdwq[i];
2628 multixri_pool = qp->p_multixri_pool;
2629 if (!multixri_pool)
2630 continue;
2631
2632 qp->empty_io_bufs = 0;
2633 multixri_pool->pbl_empty_count = 0;
2634 #ifdef LPFC_MXP_STAT
2635 multixri_pool->above_limit_count = 0;
2636 multixri_pool->below_limit_count = 0;
2637 multixri_pool->stat_max_hwm = 0;
2638 multixri_pool->local_pbl_hit_count = 0;
2639 multixri_pool->other_pbl_hit_count = 0;
2640
2641 multixri_pool->stat_pbl_count = 0;
2642 multixri_pool->stat_pvt_count = 0;
2643 multixri_pool->stat_busy_count = 0;
2644 multixri_pool->stat_snapshot_taken = 0;
2645 #endif
2646 }
2647 return strlen(pbuf);
2648 }
2649
2650 return -EINVAL;
2651 }
2652
2653 static int
2654 lpfc_debugfs_nvmestat_open(struct inode *inode, struct file *file)
2655 {
2656 struct lpfc_vport *vport = inode->i_private;
2657 struct lpfc_debug *debug;
2658 int rc = -ENOMEM;
2659
2660 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2661 if (!debug)
2662 goto out;
2663
2664 /* Round to page boundary */
2665 debug->buffer = kmalloc(LPFC_NVMESTAT_SIZE, GFP_KERNEL);
2666 if (!debug->buffer) {
2667 kfree(debug);
2668 goto out;
2669 }
2670
2671 debug->len = lpfc_debugfs_nvmestat_data(vport, debug->buffer,
2672 LPFC_NVMESTAT_SIZE);
2673
2674 debug->i_private = inode->i_private;
2675 file->private_data = debug;
2676
2677 rc = 0;
2678 out:
2679 return rc;
2680 }
2681
2682 static ssize_t
2683 lpfc_debugfs_nvmestat_write(struct file *file, const char __user *buf,
2684 size_t nbytes, loff_t *ppos)
2685 {
2686 struct lpfc_debug *debug = file->private_data;
2687 struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2688 struct lpfc_hba *phba = vport->phba;
2689 struct lpfc_nvmet_tgtport *tgtp;
2690 char mybuf[64];
2691 char *pbuf;
2692
2693 if (!phba->targetport)
2694 return -ENXIO;
2695
2696 if (nbytes > sizeof(mybuf) - 1)
2697 nbytes = sizeof(mybuf) - 1;
2698
2699 memset(mybuf, 0, sizeof(mybuf));
2700
2701 if (copy_from_user(mybuf, buf, nbytes))
2702 return -EFAULT;
2703 pbuf = &mybuf[0];
2704
2705 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
2706 if ((strncmp(pbuf, "reset", strlen("reset")) == 0) ||
2707 (strncmp(pbuf, "zero", strlen("zero")) == 0)) {
2708 atomic_set(&tgtp->rcv_ls_req_in, 0);
2709 atomic_set(&tgtp->rcv_ls_req_out, 0);
2710 atomic_set(&tgtp->rcv_ls_req_drop, 0);
2711 atomic_set(&tgtp->xmt_ls_abort, 0);
2712 atomic_set(&tgtp->xmt_ls_abort_cmpl, 0);
2713 atomic_set(&tgtp->xmt_ls_rsp, 0);
2714 atomic_set(&tgtp->xmt_ls_drop, 0);
2715 atomic_set(&tgtp->xmt_ls_rsp_error, 0);
2716 atomic_set(&tgtp->xmt_ls_rsp_cmpl, 0);
2717
2718 atomic_set(&tgtp->rcv_fcp_cmd_in, 0);
2719 atomic_set(&tgtp->rcv_fcp_cmd_out, 0);
2720 atomic_set(&tgtp->rcv_fcp_cmd_drop, 0);
2721 atomic_set(&tgtp->xmt_fcp_drop, 0);
2722 atomic_set(&tgtp->xmt_fcp_read_rsp, 0);
2723 atomic_set(&tgtp->xmt_fcp_read, 0);
2724 atomic_set(&tgtp->xmt_fcp_write, 0);
2725 atomic_set(&tgtp->xmt_fcp_rsp, 0);
2726 atomic_set(&tgtp->xmt_fcp_release, 0);
2727 atomic_set(&tgtp->xmt_fcp_rsp_cmpl, 0);
2728 atomic_set(&tgtp->xmt_fcp_rsp_error, 0);
2729 atomic_set(&tgtp->xmt_fcp_rsp_drop, 0);
2730
2731 atomic_set(&tgtp->xmt_fcp_abort, 0);
2732 atomic_set(&tgtp->xmt_fcp_abort_cmpl, 0);
2733 atomic_set(&tgtp->xmt_abort_sol, 0);
2734 atomic_set(&tgtp->xmt_abort_unsol, 0);
2735 atomic_set(&tgtp->xmt_abort_rsp, 0);
2736 atomic_set(&tgtp->xmt_abort_rsp_error, 0);
2737 }
2738 return nbytes;
2739 }
2740
2741 static int
2742 lpfc_debugfs_scsistat_open(struct inode *inode, struct file *file)
2743 {
2744 struct lpfc_vport *vport = inode->i_private;
2745 struct lpfc_debug *debug;
2746 int rc = -ENOMEM;
2747
2748 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2749 if (!debug)
2750 goto out;
2751
2752 /* Round to page boundary */
2753 debug->buffer = kzalloc(LPFC_SCSISTAT_SIZE, GFP_KERNEL);
2754 if (!debug->buffer) {
2755 kfree(debug);
2756 goto out;
2757 }
2758
2759 debug->len = lpfc_debugfs_scsistat_data(vport, debug->buffer,
2760 LPFC_SCSISTAT_SIZE);
2761
2762 debug->i_private = inode->i_private;
2763 file->private_data = debug;
2764
2765 rc = 0;
2766 out:
2767 return rc;
2768 }
2769
2770 static ssize_t
2771 lpfc_debugfs_scsistat_write(struct file *file, const char __user *buf,
2772 size_t nbytes, loff_t *ppos)
2773 {
2774 struct lpfc_debug *debug = file->private_data;
2775 struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2776 struct lpfc_hba *phba = vport->phba;
2777 char mybuf[6] = {0};
2778 int i;
2779
2780 if (copy_from_user(mybuf, buf, (nbytes >= sizeof(mybuf)) ?
2781 (sizeof(mybuf) - 1) : nbytes))
2782 return -EFAULT;
2783
2784 if ((strncmp(&mybuf[0], "reset", strlen("reset")) == 0) ||
2785 (strncmp(&mybuf[0], "zero", strlen("zero")) == 0)) {
2786 for (i = 0; i < phba->cfg_hdw_queue; i++) {
2787 memset(&phba->sli4_hba.hdwq[i].scsi_cstat, 0,
2788 sizeof(phba->sli4_hba.hdwq[i].scsi_cstat));
2789 }
2790 }
2791
2792 return nbytes;
2793 }
2794
2795 static int
2796 lpfc_debugfs_ioktime_open(struct inode *inode, struct file *file)
2797 {
2798 struct lpfc_vport *vport = inode->i_private;
2799 struct lpfc_debug *debug;
2800 int rc = -ENOMEM;
2801
2802 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2803 if (!debug)
2804 goto out;
2805
2806 /* Round to page boundary */
2807 debug->buffer = kmalloc(LPFC_IOKTIME_SIZE, GFP_KERNEL);
2808 if (!debug->buffer) {
2809 kfree(debug);
2810 goto out;
2811 }
2812
2813 debug->len = lpfc_debugfs_ioktime_data(vport, debug->buffer,
2814 LPFC_IOKTIME_SIZE);
2815
2816 debug->i_private = inode->i_private;
2817 file->private_data = debug;
2818
2819 rc = 0;
2820 out:
2821 return rc;
2822 }
2823
2824 static ssize_t
2825 lpfc_debugfs_ioktime_write(struct file *file, const char __user *buf,
2826 size_t nbytes, loff_t *ppos)
2827 {
2828 struct lpfc_debug *debug = file->private_data;
2829 struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
2830 struct lpfc_hba *phba = vport->phba;
2831 char mybuf[64];
2832 char *pbuf;
2833
2834 if (nbytes > sizeof(mybuf) - 1)
2835 nbytes = sizeof(mybuf) - 1;
2836
2837 memset(mybuf, 0, sizeof(mybuf));
2838
2839 if (copy_from_user(mybuf, buf, nbytes))
2840 return -EFAULT;
2841 pbuf = &mybuf[0];
2842
2843 if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
2844 phba->ktime_data_samples = 0;
2845 phba->ktime_status_samples = 0;
2846 phba->ktime_seg1_total = 0;
2847 phba->ktime_seg1_max = 0;
2848 phba->ktime_seg1_min = 0xffffffff;
2849 phba->ktime_seg2_total = 0;
2850 phba->ktime_seg2_max = 0;
2851 phba->ktime_seg2_min = 0xffffffff;
2852 phba->ktime_seg3_total = 0;
2853 phba->ktime_seg3_max = 0;
2854 phba->ktime_seg3_min = 0xffffffff;
2855 phba->ktime_seg4_total = 0;
2856 phba->ktime_seg4_max = 0;
2857 phba->ktime_seg4_min = 0xffffffff;
2858 phba->ktime_seg5_total = 0;
2859 phba->ktime_seg5_max = 0;
2860 phba->ktime_seg5_min = 0xffffffff;
2861 phba->ktime_seg6_total = 0;
2862 phba->ktime_seg6_max = 0;
2863 phba->ktime_seg6_min = 0xffffffff;
2864 phba->ktime_seg7_total = 0;
2865 phba->ktime_seg7_max = 0;
2866 phba->ktime_seg7_min = 0xffffffff;
2867 phba->ktime_seg8_total = 0;
2868 phba->ktime_seg8_max = 0;
2869 phba->ktime_seg8_min = 0xffffffff;
2870 phba->ktime_seg9_total = 0;
2871 phba->ktime_seg9_max = 0;
2872 phba->ktime_seg9_min = 0xffffffff;
2873 phba->ktime_seg10_total = 0;
2874 phba->ktime_seg10_max = 0;
2875 phba->ktime_seg10_min = 0xffffffff;
2876
2877 phba->ktime_on = 1;
2878 return strlen(pbuf);
2879 } else if ((strncmp(pbuf, "off",
2880 sizeof("off") - 1) == 0)) {
2881 phba->ktime_on = 0;
2882 return strlen(pbuf);
2883 } else if ((strncmp(pbuf, "zero",
2884 sizeof("zero") - 1) == 0)) {
2885 phba->ktime_data_samples = 0;
2886 phba->ktime_status_samples = 0;
2887 phba->ktime_seg1_total = 0;
2888 phba->ktime_seg1_max = 0;
2889 phba->ktime_seg1_min = 0xffffffff;
2890 phba->ktime_seg2_total = 0;
2891 phba->ktime_seg2_max = 0;
2892 phba->ktime_seg2_min = 0xffffffff;
2893 phba->ktime_seg3_total = 0;
2894 phba->ktime_seg3_max = 0;
2895 phba->ktime_seg3_min = 0xffffffff;
2896 phba->ktime_seg4_total = 0;
2897 phba->ktime_seg4_max = 0;
2898 phba->ktime_seg4_min = 0xffffffff;
2899 phba->ktime_seg5_total = 0;
2900 phba->ktime_seg5_max = 0;
2901 phba->ktime_seg5_min = 0xffffffff;
2902 phba->ktime_seg6_total = 0;
2903 phba->ktime_seg6_max = 0;
2904 phba->ktime_seg6_min = 0xffffffff;
2905 phba->ktime_seg7_total = 0;
2906 phba->ktime_seg7_max = 0;
2907 phba->ktime_seg7_min = 0xffffffff;
2908 phba->ktime_seg8_total = 0;
2909 phba->ktime_seg8_max = 0;
2910 phba->ktime_seg8_min = 0xffffffff;
2911 phba->ktime_seg9_total = 0;
2912 phba->ktime_seg9_max = 0;
2913 phba->ktime_seg9_min = 0xffffffff;
2914 phba->ktime_seg10_total = 0;
2915 phba->ktime_seg10_max = 0;
2916 phba->ktime_seg10_min = 0xffffffff;
2917 return strlen(pbuf);
2918 }
2919 return -EINVAL;
2920 }
2921
2922 static int
2923 lpfc_debugfs_nvmeio_trc_open(struct inode *inode, struct file *file)
2924 {
2925 struct lpfc_hba *phba = inode->i_private;
2926 struct lpfc_debug *debug;
2927 int rc = -ENOMEM;
2928
2929 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
2930 if (!debug)
2931 goto out;
2932
2933 /* Round to page boundary */
2934 debug->buffer = kmalloc(LPFC_NVMEIO_TRC_SIZE, GFP_KERNEL);
2935 if (!debug->buffer) {
2936 kfree(debug);
2937 goto out;
2938 }
2939
2940 debug->len = lpfc_debugfs_nvmeio_trc_data(phba, debug->buffer,
2941 LPFC_NVMEIO_TRC_SIZE);
2942
2943 debug->i_private = inode->i_private;
2944 file->private_data = debug;
2945
2946 rc = 0;
2947 out:
2948 return rc;
2949 }
2950
2951 static ssize_t
2952 lpfc_debugfs_nvmeio_trc_write(struct file *file, const char __user *buf,
2953 size_t nbytes, loff_t *ppos)
2954 {
2955 struct lpfc_debug *debug = file->private_data;
2956 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
2957 int i;
2958 unsigned long sz;
2959 char mybuf[64];
2960 char *pbuf;
2961
2962 if (nbytes > sizeof(mybuf) - 1)
2963 nbytes = sizeof(mybuf) - 1;
2964
2965 memset(mybuf, 0, sizeof(mybuf));
2966
2967 if (copy_from_user(mybuf, buf, nbytes))
2968 return -EFAULT;
2969 pbuf = &mybuf[0];
2970
2971 if ((strncmp(pbuf, "off", sizeof("off") - 1) == 0)) {
2972 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2973 "0570 nvmeio_trc_off\n");
2974 phba->nvmeio_trc_output_idx = 0;
2975 phba->nvmeio_trc_on = 0;
2976 return strlen(pbuf);
2977 } else if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
2978 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2979 "0571 nvmeio_trc_on\n");
2980 phba->nvmeio_trc_output_idx = 0;
2981 phba->nvmeio_trc_on = 1;
2982 return strlen(pbuf);
2983 }
2984
2985 /* We must be off to allocate the trace buffer */
2986 if (phba->nvmeio_trc_on != 0)
2987 return -EINVAL;
2988
2989 /* If not on or off, the parameter is the trace buffer size */
2990 i = kstrtoul(pbuf, 0, &sz);
2991 if (i)
2992 return -EINVAL;
2993 phba->nvmeio_trc_size = (uint32_t)sz;
2994
2995 /* It must be a power of 2 - round down */
2996 i = 0;
2997 while (sz > 1) {
2998 sz = sz >> 1;
2999 i++;
3000 }
3001 sz = (1 << i);
3002 if (phba->nvmeio_trc_size != sz)
3003 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3004 "0572 nvmeio_trc_size changed to %ld\n",
3005 sz);
3006 phba->nvmeio_trc_size = (uint32_t)sz;
3007
3008 /* If one previously exists, free it */
3009 kfree(phba->nvmeio_trc);
3010
3011 /* Allocate new trace buffer and initialize */
3012 phba->nvmeio_trc = kzalloc((sizeof(struct lpfc_debugfs_nvmeio_trc) *
3013 sz), GFP_KERNEL);
3014 if (!phba->nvmeio_trc) {
3015 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3016 "0573 Cannot create debugfs "
3017 "nvmeio_trc buffer\n");
3018 return -ENOMEM;
3019 }
3020 atomic_set(&phba->nvmeio_trc_cnt, 0);
3021 phba->nvmeio_trc_on = 0;
3022 phba->nvmeio_trc_output_idx = 0;
3023
3024 return strlen(pbuf);
3025 }
3026
3027 static int
3028 lpfc_debugfs_hdwqstat_open(struct inode *inode, struct file *file)
3029 {
3030 struct lpfc_vport *vport = inode->i_private;
3031 struct lpfc_debug *debug;
3032 int rc = -ENOMEM;
3033
3034 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
3035 if (!debug)
3036 goto out;
3037
3038 /* Round to page boundary */
3039 debug->buffer = kcalloc(1, LPFC_SCSISTAT_SIZE, GFP_KERNEL);
3040 if (!debug->buffer) {
3041 kfree(debug);
3042 goto out;
3043 }
3044
3045 debug->len = lpfc_debugfs_hdwqstat_data(vport, debug->buffer,
3046 LPFC_SCSISTAT_SIZE);
3047
3048 debug->i_private = inode->i_private;
3049 file->private_data = debug;
3050
3051 rc = 0;
3052 out:
3053 return rc;
3054 }
3055
3056 static ssize_t
3057 lpfc_debugfs_hdwqstat_write(struct file *file, const char __user *buf,
3058 size_t nbytes, loff_t *ppos)
3059 {
3060 struct lpfc_debug *debug = file->private_data;
3061 struct lpfc_vport *vport = (struct lpfc_vport *)debug->i_private;
3062 struct lpfc_hba *phba = vport->phba;
3063 struct lpfc_hdwq_stat *c_stat;
3064 char mybuf[64];
3065 char *pbuf;
3066 int i;
3067
3068 if (nbytes > sizeof(mybuf) - 1)
3069 nbytes = sizeof(mybuf) - 1;
3070
3071 memset(mybuf, 0, sizeof(mybuf));
3072
3073 if (copy_from_user(mybuf, buf, nbytes))
3074 return -EFAULT;
3075 pbuf = &mybuf[0];
3076
3077 if ((strncmp(pbuf, "on", sizeof("on") - 1) == 0)) {
3078 if (phba->nvmet_support)
3079 phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
3080 else
3081 phba->hdwqstat_on |= (LPFC_CHECK_NVME_IO |
3082 LPFC_CHECK_SCSI_IO);
3083 return strlen(pbuf);
3084 } else if ((strncmp(pbuf, "nvme_on", sizeof("nvme_on") - 1) == 0)) {
3085 if (phba->nvmet_support)
3086 phba->hdwqstat_on |= LPFC_CHECK_NVMET_IO;
3087 else
3088 phba->hdwqstat_on |= LPFC_CHECK_NVME_IO;
3089 return strlen(pbuf);
3090 } else if ((strncmp(pbuf, "scsi_on", sizeof("scsi_on") - 1) == 0)) {
3091 if (!phba->nvmet_support)
3092 phba->hdwqstat_on |= LPFC_CHECK_SCSI_IO;
3093 return strlen(pbuf);
3094 } else if ((strncmp(pbuf, "nvme_off", sizeof("nvme_off") - 1) == 0)) {
3095 phba->hdwqstat_on &= ~(LPFC_CHECK_NVME_IO |
3096 LPFC_CHECK_NVMET_IO);
3097 return strlen(pbuf);
3098 } else if ((strncmp(pbuf, "scsi_off", sizeof("scsi_off") - 1) == 0)) {
3099 phba->hdwqstat_on &= ~LPFC_CHECK_SCSI_IO;
3100 return strlen(pbuf);
3101 } else if ((strncmp(pbuf, "off",
3102 sizeof("off") - 1) == 0)) {
3103 phba->hdwqstat_on = LPFC_CHECK_OFF;
3104 return strlen(pbuf);
3105 } else if ((strncmp(pbuf, "zero",
3106 sizeof("zero") - 1) == 0)) {
3107 for_each_present_cpu(i) {
3108 c_stat = per_cpu_ptr(phba->sli4_hba.c_stat, i);
3109 c_stat->xmt_io = 0;
3110 c_stat->cmpl_io = 0;
3111 c_stat->rcv_io = 0;
3112 }
3113 return strlen(pbuf);
3114 }
3115 return -EINVAL;
3116 }
3117
3118 /*
3119 * ---------------------------------
3120 * iDiag debugfs file access methods
3121 * ---------------------------------
3122 *
3123 * All access methods are through the proper SLI4 PCI function's debugfs
3124 * iDiag directory:
3125 *
3126 * /sys/kernel/debug/lpfc/fn<#>/iDiag
3127 */
3128
3129 /**
3130 * lpfc_idiag_cmd_get - Get and parse idiag debugfs comands from user space
3131 * @buf: The pointer to the user space buffer.
3132 * @nbytes: The number of bytes in the user space buffer.
3133 * @idiag_cmd: pointer to the idiag command struct.
3134 *
3135 * This routine reads data from debugfs user space buffer and parses the
3136 * buffer for getting the idiag command and arguments. The while space in
3137 * between the set of data is used as the parsing separator.
3138 *
3139 * This routine returns 0 when successful, it returns proper error code
3140 * back to the user space in error conditions.
3141 */
3142 static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes,
3143 struct lpfc_idiag_cmd *idiag_cmd)
3144 {
3145 char mybuf[64];
3146 char *pbuf, *step_str;
3147 int i;
3148 size_t bsize;
3149
3150 memset(mybuf, 0, sizeof(mybuf));
3151 memset(idiag_cmd, 0, sizeof(*idiag_cmd));
3152 bsize = min(nbytes, (sizeof(mybuf)-1));
3153
3154 if (copy_from_user(mybuf, buf, bsize))
3155 return -EFAULT;
3156 pbuf = &mybuf[0];
3157 step_str = strsep(&pbuf, "\t ");
3158
3159 /* The opcode must present */
3160 if (!step_str)
3161 return -EINVAL;
3162
3163 idiag_cmd->opcode = simple_strtol(step_str, NULL, 0);
3164 if (idiag_cmd->opcode == 0)
3165 return -EINVAL;
3166
3167 for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) {
3168 step_str = strsep(&pbuf, "\t ");
3169 if (!step_str)
3170 return i;
3171 idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0);
3172 }
3173 return i;
3174 }
3175
3176 /**
3177 * lpfc_idiag_open - idiag open debugfs
3178 * @inode: The inode pointer that contains a pointer to phba.
3179 * @file: The file pointer to attach the file operation.
3180 *
3181 * Description:
3182 * This routine is the entry point for the debugfs open file operation. It
3183 * gets the reference to phba from the i_private field in @inode, it then
3184 * allocates buffer for the file operation, performs the necessary PCI config
3185 * space read into the allocated buffer according to the idiag user command
3186 * setup, and then returns a pointer to buffer in the private_data field in
3187 * @file.
3188 *
3189 * Returns:
3190 * This function returns zero if successful. On error it will return an
3191 * negative error value.
3192 **/
3193 static int
3194 lpfc_idiag_open(struct inode *inode, struct file *file)
3195 {
3196 struct lpfc_debug *debug;
3197
3198 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
3199 if (!debug)
3200 return -ENOMEM;
3201
3202 debug->i_private = inode->i_private;
3203 debug->buffer = NULL;
3204 file->private_data = debug;
3205
3206 return 0;
3207 }
3208
3209 /**
3210 * lpfc_idiag_release - Release idiag access file operation
3211 * @inode: The inode pointer that contains a vport pointer. (unused)
3212 * @file: The file pointer that contains the buffer to release.
3213 *
3214 * Description:
3215 * This routine is the generic release routine for the idiag access file
3216 * operation, it frees the buffer that was allocated when the debugfs file
3217 * was opened.
3218 *
3219 * Returns:
3220 * This function returns zero.
3221 **/
3222 static int
3223 lpfc_idiag_release(struct inode *inode, struct file *file)
3224 {
3225 struct lpfc_debug *debug = file->private_data;
3226
3227 /* Free the buffers to the file operation */
3228 kfree(debug->buffer);
3229 kfree(debug);
3230
3231 return 0;
3232 }
3233
3234 /**
3235 * lpfc_idiag_cmd_release - Release idiag cmd access file operation
3236 * @inode: The inode pointer that contains a vport pointer. (unused)
3237 * @file: The file pointer that contains the buffer to release.
3238 *
3239 * Description:
3240 * This routine frees the buffer that was allocated when the debugfs file
3241 * was opened. It also reset the fields in the idiag command struct in the
3242 * case of command for write operation.
3243 *
3244 * Returns:
3245 * This function returns zero.
3246 **/
3247 static int
3248 lpfc_idiag_cmd_release(struct inode *inode, struct file *file)
3249 {
3250 struct lpfc_debug *debug = file->private_data;
3251
3252 if (debug->op == LPFC_IDIAG_OP_WR) {
3253 switch (idiag.cmd.opcode) {
3254 case LPFC_IDIAG_CMD_PCICFG_WR:
3255 case LPFC_IDIAG_CMD_PCICFG_ST:
3256 case LPFC_IDIAG_CMD_PCICFG_CL:
3257 case LPFC_IDIAG_CMD_QUEACC_WR:
3258 case LPFC_IDIAG_CMD_QUEACC_ST:
3259 case LPFC_IDIAG_CMD_QUEACC_CL:
3260 memset(&idiag, 0, sizeof(idiag));
3261 break;
3262 default:
3263 break;
3264 }
3265 }
3266
3267 /* Free the buffers to the file operation */
3268 kfree(debug->buffer);
3269 kfree(debug);
3270
3271 return 0;
3272 }
3273
3274 /**
3275 * lpfc_idiag_pcicfg_read - idiag debugfs read pcicfg
3276 * @file: The file pointer to read from.
3277 * @buf: The buffer to copy the data to.
3278 * @nbytes: The number of bytes to read.
3279 * @ppos: The position in the file to start reading from.
3280 *
3281 * Description:
3282 * This routine reads data from the @phba pci config space according to the
3283 * idiag command, and copies to user @buf. Depending on the PCI config space
3284 * read command setup, it does either a single register read of a byte
3285 * (8 bits), a word (16 bits), or a dword (32 bits) or browsing through all
3286 * registers from the 4K extended PCI config space.
3287 *
3288 * Returns:
3289 * This function returns the amount of data that was read (this could be less
3290 * than @nbytes if the end of the file was reached) or a negative error value.
3291 **/
3292 static ssize_t
3293 lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
3294 loff_t *ppos)
3295 {
3296 struct lpfc_debug *debug = file->private_data;
3297 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3298 int offset_label, offset, len = 0, index = LPFC_PCI_CFG_RD_SIZE;
3299 int where, count;
3300 char *pbuffer;
3301 struct pci_dev *pdev;
3302 uint32_t u32val;
3303 uint16_t u16val;
3304 uint8_t u8val;
3305
3306 pdev = phba->pcidev;
3307 if (!pdev)
3308 return 0;
3309
3310 /* This is a user read operation */
3311 debug->op = LPFC_IDIAG_OP_RD;
3312
3313 if (!debug->buffer)
3314 debug->buffer = kmalloc(LPFC_PCI_CFG_SIZE, GFP_KERNEL);
3315 if (!debug->buffer)
3316 return 0;
3317 pbuffer = debug->buffer;
3318
3319 if (*ppos)
3320 return 0;
3321
3322 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
3323 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3324 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3325 } else
3326 return 0;
3327
3328 /* Read single PCI config space register */
3329 switch (count) {
3330 case SIZE_U8: /* byte (8 bits) */
3331 pci_read_config_byte(pdev, where, &u8val);
3332 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3333 "%03x: %02x\n", where, u8val);
3334 break;
3335 case SIZE_U16: /* word (16 bits) */
3336 pci_read_config_word(pdev, where, &u16val);
3337 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3338 "%03x: %04x\n", where, u16val);
3339 break;
3340 case SIZE_U32: /* double word (32 bits) */
3341 pci_read_config_dword(pdev, where, &u32val);
3342 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3343 "%03x: %08x\n", where, u32val);
3344 break;
3345 case LPFC_PCI_CFG_BROWSE: /* browse all */
3346 goto pcicfg_browse;
3347 default:
3348 /* illegal count */
3349 len = 0;
3350 break;
3351 }
3352 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3353
3354 pcicfg_browse:
3355
3356 /* Browse all PCI config space registers */
3357 offset_label = idiag.offset.last_rd;
3358 offset = offset_label;
3359
3360 /* Read PCI config space */
3361 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3362 "%03x: ", offset_label);
3363 while (index > 0) {
3364 pci_read_config_dword(pdev, offset, &u32val);
3365 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3366 "%08x ", u32val);
3367 offset += sizeof(uint32_t);
3368 if (offset >= LPFC_PCI_CFG_SIZE) {
3369 len += scnprintf(pbuffer+len,
3370 LPFC_PCI_CFG_SIZE-len, "\n");
3371 break;
3372 }
3373 index -= sizeof(uint32_t);
3374 if (!index)
3375 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3376 "\n");
3377 else if (!(index % (8 * sizeof(uint32_t)))) {
3378 offset_label += (8 * sizeof(uint32_t));
3379 len += scnprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
3380 "\n%03x: ", offset_label);
3381 }
3382 }
3383
3384 /* Set up the offset for next portion of pci cfg read */
3385 if (index == 0) {
3386 idiag.offset.last_rd += LPFC_PCI_CFG_RD_SIZE;
3387 if (idiag.offset.last_rd >= LPFC_PCI_CFG_SIZE)
3388 idiag.offset.last_rd = 0;
3389 } else
3390 idiag.offset.last_rd = 0;
3391
3392 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3393 }
3394
3395 /**
3396 * lpfc_idiag_pcicfg_write - Syntax check and set up idiag pcicfg commands
3397 * @file: The file pointer to read from.
3398 * @buf: The buffer to copy the user data from.
3399 * @nbytes: The number of bytes to get.
3400 * @ppos: The position in the file to start reading from.
3401 *
3402 * This routine get the debugfs idiag command struct from user space and
3403 * then perform the syntax check for PCI config space read or write command
3404 * accordingly. In the case of PCI config space read command, it sets up
3405 * the command in the idiag command struct for the debugfs read operation.
3406 * In the case of PCI config space write operation, it executes the write
3407 * operation into the PCI config space accordingly.
3408 *
3409 * It returns the @nbytges passing in from debugfs user space when successful.
3410 * In case of error conditions, it returns proper error code back to the user
3411 * space.
3412 */
3413 static ssize_t
3414 lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
3415 size_t nbytes, loff_t *ppos)
3416 {
3417 struct lpfc_debug *debug = file->private_data;
3418 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3419 uint32_t where, value, count;
3420 uint32_t u32val;
3421 uint16_t u16val;
3422 uint8_t u8val;
3423 struct pci_dev *pdev;
3424 int rc;
3425
3426 pdev = phba->pcidev;
3427 if (!pdev)
3428 return -EFAULT;
3429
3430 /* This is a user write operation */
3431 debug->op = LPFC_IDIAG_OP_WR;
3432
3433 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
3434 if (rc < 0)
3435 return rc;
3436
3437 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
3438 /* Sanity check on PCI config read command line arguments */
3439 if (rc != LPFC_PCI_CFG_RD_CMD_ARG)
3440 goto error_out;
3441 /* Read command from PCI config space, set up command fields */
3442 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3443 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3444 if (count == LPFC_PCI_CFG_BROWSE) {
3445 if (where % sizeof(uint32_t))
3446 goto error_out;
3447 /* Starting offset to browse */
3448 idiag.offset.last_rd = where;
3449 } else if ((count != sizeof(uint8_t)) &&
3450 (count != sizeof(uint16_t)) &&
3451 (count != sizeof(uint32_t)))
3452 goto error_out;
3453 if (count == sizeof(uint8_t)) {
3454 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
3455 goto error_out;
3456 if (where % sizeof(uint8_t))
3457 goto error_out;
3458 }
3459 if (count == sizeof(uint16_t)) {
3460 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
3461 goto error_out;
3462 if (where % sizeof(uint16_t))
3463 goto error_out;
3464 }
3465 if (count == sizeof(uint32_t)) {
3466 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
3467 goto error_out;
3468 if (where % sizeof(uint32_t))
3469 goto error_out;
3470 }
3471 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR ||
3472 idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST ||
3473 idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3474 /* Sanity check on PCI config write command line arguments */
3475 if (rc != LPFC_PCI_CFG_WR_CMD_ARG)
3476 goto error_out;
3477 /* Write command to PCI config space, read-modify-write */
3478 where = idiag.cmd.data[IDIAG_PCICFG_WHERE_INDX];
3479 count = idiag.cmd.data[IDIAG_PCICFG_COUNT_INDX];
3480 value = idiag.cmd.data[IDIAG_PCICFG_VALUE_INDX];
3481 /* Sanity checks */
3482 if ((count != sizeof(uint8_t)) &&
3483 (count != sizeof(uint16_t)) &&
3484 (count != sizeof(uint32_t)))
3485 goto error_out;
3486 if (count == sizeof(uint8_t)) {
3487 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint8_t))
3488 goto error_out;
3489 if (where % sizeof(uint8_t))
3490 goto error_out;
3491 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3492 pci_write_config_byte(pdev, where,
3493 (uint8_t)value);
3494 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3495 rc = pci_read_config_byte(pdev, where, &u8val);
3496 if (!rc) {
3497 u8val |= (uint8_t)value;
3498 pci_write_config_byte(pdev, where,
3499 u8val);
3500 }
3501 }
3502 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3503 rc = pci_read_config_byte(pdev, where, &u8val);
3504 if (!rc) {
3505 u8val &= (uint8_t)(~value);
3506 pci_write_config_byte(pdev, where,
3507 u8val);
3508 }
3509 }
3510 }
3511 if (count == sizeof(uint16_t)) {
3512 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint16_t))
3513 goto error_out;
3514 if (where % sizeof(uint16_t))
3515 goto error_out;
3516 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3517 pci_write_config_word(pdev, where,
3518 (uint16_t)value);
3519 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3520 rc = pci_read_config_word(pdev, where, &u16val);
3521 if (!rc) {
3522 u16val |= (uint16_t)value;
3523 pci_write_config_word(pdev, where,
3524 u16val);
3525 }
3526 }
3527 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3528 rc = pci_read_config_word(pdev, where, &u16val);
3529 if (!rc) {
3530 u16val &= (uint16_t)(~value);
3531 pci_write_config_word(pdev, where,
3532 u16val);
3533 }
3534 }
3535 }
3536 if (count == sizeof(uint32_t)) {
3537 if (where > LPFC_PCI_CFG_SIZE - sizeof(uint32_t))
3538 goto error_out;
3539 if (where % sizeof(uint32_t))
3540 goto error_out;
3541 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR)
3542 pci_write_config_dword(pdev, where, value);
3543 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST) {
3544 rc = pci_read_config_dword(pdev, where,
3545 &u32val);
3546 if (!rc) {
3547 u32val |= value;
3548 pci_write_config_dword(pdev, where,
3549 u32val);
3550 }
3551 }
3552 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
3553 rc = pci_read_config_dword(pdev, where,
3554 &u32val);
3555 if (!rc) {
3556 u32val &= ~value;
3557 pci_write_config_dword(pdev, where,
3558 u32val);
3559 }
3560 }
3561 }
3562 } else
3563 /* All other opecodes are illegal for now */
3564 goto error_out;
3565
3566 return nbytes;
3567 error_out:
3568 memset(&idiag, 0, sizeof(idiag));
3569 return -EINVAL;
3570 }
3571
3572 /**
3573 * lpfc_idiag_baracc_read - idiag debugfs pci bar access read
3574 * @file: The file pointer to read from.
3575 * @buf: The buffer to copy the data to.
3576 * @nbytes: The number of bytes to read.
3577 * @ppos: The position in the file to start reading from.
3578 *
3579 * Description:
3580 * This routine reads data from the @phba pci bar memory mapped space
3581 * according to the idiag command, and copies to user @buf.
3582 *
3583 * Returns:
3584 * This function returns the amount of data that was read (this could be less
3585 * than @nbytes if the end of the file was reached) or a negative error value.
3586 **/
3587 static ssize_t
3588 lpfc_idiag_baracc_read(struct file *file, char __user *buf, size_t nbytes,
3589 loff_t *ppos)
3590 {
3591 struct lpfc_debug *debug = file->private_data;
3592 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3593 int offset_label, offset, offset_run, len = 0, index;
3594 int bar_num, acc_range, bar_size;
3595 char *pbuffer;
3596 void __iomem *mem_mapped_bar;
3597 uint32_t if_type;
3598 struct pci_dev *pdev;
3599 uint32_t u32val;
3600
3601 pdev = phba->pcidev;
3602 if (!pdev)
3603 return 0;
3604
3605 /* This is a user read operation */
3606 debug->op = LPFC_IDIAG_OP_RD;
3607
3608 if (!debug->buffer)
3609 debug->buffer = kmalloc(LPFC_PCI_BAR_RD_BUF_SIZE, GFP_KERNEL);
3610 if (!debug->buffer)
3611 return 0;
3612 pbuffer = debug->buffer;
3613
3614 if (*ppos)
3615 return 0;
3616
3617 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
3618 bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
3619 offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
3620 acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
3621 bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
3622 } else
3623 return 0;
3624
3625 if (acc_range == 0)
3626 return 0;
3627
3628 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
3629 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3630 if (bar_num == IDIAG_BARACC_BAR_0)
3631 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3632 else if (bar_num == IDIAG_BARACC_BAR_1)
3633 mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
3634 else if (bar_num == IDIAG_BARACC_BAR_2)
3635 mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
3636 else
3637 return 0;
3638 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3639 if (bar_num == IDIAG_BARACC_BAR_0)
3640 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3641 else
3642 return 0;
3643 } else
3644 return 0;
3645
3646 /* Read single PCI bar space register */
3647 if (acc_range == SINGLE_WORD) {
3648 offset_run = offset;
3649 u32val = readl(mem_mapped_bar + offset_run);
3650 len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3651 "%05x: %08x\n", offset_run, u32val);
3652 } else
3653 goto baracc_browse;
3654
3655 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3656
3657 baracc_browse:
3658
3659 /* Browse all PCI bar space registers */
3660 offset_label = idiag.offset.last_rd;
3661 offset_run = offset_label;
3662
3663 /* Read PCI bar memory mapped space */
3664 len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3665 "%05x: ", offset_label);
3666 index = LPFC_PCI_BAR_RD_SIZE;
3667 while (index > 0) {
3668 u32val = readl(mem_mapped_bar + offset_run);
3669 len += scnprintf(pbuffer+len, LPFC_PCI_BAR_RD_BUF_SIZE-len,
3670 "%08x ", u32val);
3671 offset_run += sizeof(uint32_t);
3672 if (acc_range == LPFC_PCI_BAR_BROWSE) {
3673 if (offset_run >= bar_size) {
3674 len += scnprintf(pbuffer+len,
3675 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3676 break;
3677 }
3678 } else {
3679 if (offset_run >= offset +
3680 (acc_range * sizeof(uint32_t))) {
3681 len += scnprintf(pbuffer+len,
3682 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3683 break;
3684 }
3685 }
3686 index -= sizeof(uint32_t);
3687 if (!index)
3688 len += scnprintf(pbuffer+len,
3689 LPFC_PCI_BAR_RD_BUF_SIZE-len, "\n");
3690 else if (!(index % (8 * sizeof(uint32_t)))) {
3691 offset_label += (8 * sizeof(uint32_t));
3692 len += scnprintf(pbuffer+len,
3693 LPFC_PCI_BAR_RD_BUF_SIZE-len,
3694 "\n%05x: ", offset_label);
3695 }
3696 }
3697
3698 /* Set up the offset for next portion of pci bar read */
3699 if (index == 0) {
3700 idiag.offset.last_rd += LPFC_PCI_BAR_RD_SIZE;
3701 if (acc_range == LPFC_PCI_BAR_BROWSE) {
3702 if (idiag.offset.last_rd >= bar_size)
3703 idiag.offset.last_rd = 0;
3704 } else {
3705 if (offset_run >= offset +
3706 (acc_range * sizeof(uint32_t)))
3707 idiag.offset.last_rd = offset;
3708 }
3709 } else {
3710 if (acc_range == LPFC_PCI_BAR_BROWSE)
3711 idiag.offset.last_rd = 0;
3712 else
3713 idiag.offset.last_rd = offset;
3714 }
3715
3716 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
3717 }
3718
3719 /**
3720 * lpfc_idiag_baracc_write - Syntax check and set up idiag bar access commands
3721 * @file: The file pointer to read from.
3722 * @buf: The buffer to copy the user data from.
3723 * @nbytes: The number of bytes to get.
3724 * @ppos: The position in the file to start reading from.
3725 *
3726 * This routine get the debugfs idiag command struct from user space and
3727 * then perform the syntax check for PCI bar memory mapped space read or
3728 * write command accordingly. In the case of PCI bar memory mapped space
3729 * read command, it sets up the command in the idiag command struct for
3730 * the debugfs read operation. In the case of PCI bar memorpy mapped space
3731 * write operation, it executes the write operation into the PCI bar memory
3732 * mapped space accordingly.
3733 *
3734 * It returns the @nbytges passing in from debugfs user space when successful.
3735 * In case of error conditions, it returns proper error code back to the user
3736 * space.
3737 */
3738 static ssize_t
3739 lpfc_idiag_baracc_write(struct file *file, const char __user *buf,
3740 size_t nbytes, loff_t *ppos)
3741 {
3742 struct lpfc_debug *debug = file->private_data;
3743 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
3744 uint32_t bar_num, bar_size, offset, value, acc_range;
3745 struct pci_dev *pdev;
3746 void __iomem *mem_mapped_bar;
3747 uint32_t if_type;
3748 uint32_t u32val;
3749 int rc;
3750
3751 pdev = phba->pcidev;
3752 if (!pdev)
3753 return -EFAULT;
3754
3755 /* This is a user write operation */
3756 debug->op = LPFC_IDIAG_OP_WR;
3757
3758 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
3759 if (rc < 0)
3760 return rc;
3761
3762 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
3763 bar_num = idiag.cmd.data[IDIAG_BARACC_BAR_NUM_INDX];
3764
3765 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3766 if ((bar_num != IDIAG_BARACC_BAR_0) &&
3767 (bar_num != IDIAG_BARACC_BAR_1) &&
3768 (bar_num != IDIAG_BARACC_BAR_2))
3769 goto error_out;
3770 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3771 if (bar_num != IDIAG_BARACC_BAR_0)
3772 goto error_out;
3773 } else
3774 goto error_out;
3775
3776 if (if_type == LPFC_SLI_INTF_IF_TYPE_0) {
3777 if (bar_num == IDIAG_BARACC_BAR_0) {
3778 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3779 LPFC_PCI_IF0_BAR0_SIZE;
3780 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3781 } else if (bar_num == IDIAG_BARACC_BAR_1) {
3782 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3783 LPFC_PCI_IF0_BAR1_SIZE;
3784 mem_mapped_bar = phba->sli4_hba.ctrl_regs_memmap_p;
3785 } else if (bar_num == IDIAG_BARACC_BAR_2) {
3786 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3787 LPFC_PCI_IF0_BAR2_SIZE;
3788 mem_mapped_bar = phba->sli4_hba.drbl_regs_memmap_p;
3789 } else
3790 goto error_out;
3791 } else if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
3792 if (bar_num == IDIAG_BARACC_BAR_0) {
3793 idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX] =
3794 LPFC_PCI_IF2_BAR0_SIZE;
3795 mem_mapped_bar = phba->sli4_hba.conf_regs_memmap_p;
3796 } else
3797 goto error_out;
3798 } else
3799 goto error_out;
3800
3801 offset = idiag.cmd.data[IDIAG_BARACC_OFF_SET_INDX];
3802 if (offset % sizeof(uint32_t))
3803 goto error_out;
3804
3805 bar_size = idiag.cmd.data[IDIAG_BARACC_BAR_SZE_INDX];
3806 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_RD) {
3807 /* Sanity check on PCI config read command line arguments */
3808 if (rc != LPFC_PCI_BAR_RD_CMD_ARG)
3809 goto error_out;
3810 acc_range = idiag.cmd.data[IDIAG_BARACC_ACC_MOD_INDX];
3811 if (acc_range == LPFC_PCI_BAR_BROWSE) {
3812 if (offset > bar_size - sizeof(uint32_t))
3813 goto error_out;
3814 /* Starting offset to browse */
3815 idiag.offset.last_rd = offset;
3816 } else if (acc_range > SINGLE_WORD) {
3817 if (offset + acc_range * sizeof(uint32_t) > bar_size)
3818 goto error_out;
3819 /* Starting offset to browse */
3820 idiag.offset.last_rd = offset;
3821 } else if (acc_range != SINGLE_WORD)
3822 goto error_out;
3823 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR ||
3824 idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST ||
3825 idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
3826 /* Sanity check on PCI bar write command line arguments */
3827 if (rc != LPFC_PCI_BAR_WR_CMD_ARG)
3828 goto error_out;
3829 /* Write command to PCI bar space, read-modify-write */
3830 acc_range = SINGLE_WORD;
3831 value = idiag.cmd.data[IDIAG_BARACC_REG_VAL_INDX];
3832 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_WR) {
3833 writel(value, mem_mapped_bar + offset);
3834 readl(mem_mapped_bar + offset);
3835 }
3836 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_ST) {
3837 u32val = readl(mem_mapped_bar + offset);
3838 u32val |= value;
3839 writel(u32val, mem_mapped_bar + offset);
3840 readl(mem_mapped_bar + offset);
3841 }
3842 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_BARACC_CL) {
3843 u32val = readl(mem_mapped_bar + offset);
3844 u32val &= ~value;
3845 writel(u32val, mem_mapped_bar + offset);
3846 readl(mem_mapped_bar + offset);
3847 }
3848 } else
3849 /* All other opecodes are illegal for now */
3850 goto error_out;
3851
3852 return nbytes;
3853 error_out:
3854 memset(&idiag, 0, sizeof(idiag));
3855 return -EINVAL;
3856 }
3857
3858 static int
3859 __lpfc_idiag_print_wq(struct lpfc_queue *qp, char *wqtype,
3860 char *pbuffer, int len)
3861 {
3862 if (!qp)
3863 return len;
3864
3865 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3866 "\t\t%s WQ info: ", wqtype);
3867 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3868 "AssocCQID[%04d]: WQ-STAT[oflow:x%x posted:x%llx]\n",
3869 qp->assoc_qid, qp->q_cnt_1,
3870 (unsigned long long)qp->q_cnt_4);
3871 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3872 "\t\tWQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3873 "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]",
3874 qp->queue_id, qp->entry_count,
3875 qp->entry_size, qp->host_index,
3876 qp->hba_index, qp->notify_interval);
3877 len += scnprintf(pbuffer + len,
3878 LPFC_QUE_INFO_GET_BUF_SIZE - len, "\n");
3879 return len;
3880 }
3881
3882 static int
3883 lpfc_idiag_wqs_for_cq(struct lpfc_hba *phba, char *wqtype, char *pbuffer,
3884 int *len, int max_cnt, int cq_id)
3885 {
3886 struct lpfc_queue *qp;
3887 int qidx;
3888
3889 for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
3890 qp = phba->sli4_hba.hdwq[qidx].io_wq;
3891 if (qp->assoc_qid != cq_id)
3892 continue;
3893 *len = __lpfc_idiag_print_wq(qp, wqtype, pbuffer, *len);
3894 if (*len >= max_cnt)
3895 return 1;
3896 }
3897 return 0;
3898 }
3899
3900 static int
3901 __lpfc_idiag_print_cq(struct lpfc_queue *qp, char *cqtype,
3902 char *pbuffer, int len)
3903 {
3904 if (!qp)
3905 return len;
3906
3907 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3908 "\t%s CQ info: ", cqtype);
3909 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3910 "AssocEQID[%02d]: CQ STAT[max:x%x relw:x%x "
3911 "xabt:x%x wq:x%llx]\n",
3912 qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
3913 qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
3914 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3915 "\tCQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3916 "HST-IDX[%04d], NTFI[%03d], PLMT[%03d]",
3917 qp->queue_id, qp->entry_count,
3918 qp->entry_size, qp->host_index,
3919 qp->notify_interval, qp->max_proc_limit);
3920
3921 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3922 "\n");
3923
3924 return len;
3925 }
3926
3927 static int
3928 __lpfc_idiag_print_rqpair(struct lpfc_queue *qp, struct lpfc_queue *datqp,
3929 char *rqtype, char *pbuffer, int len)
3930 {
3931 if (!qp || !datqp)
3932 return len;
3933
3934 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3935 "\t\t%s RQ info: ", rqtype);
3936 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3937 "AssocCQID[%02d]: RQ-STAT[nopost:x%x nobuf:x%x "
3938 "posted:x%x rcv:x%llx]\n",
3939 qp->assoc_qid, qp->q_cnt_1, qp->q_cnt_2,
3940 qp->q_cnt_3, (unsigned long long)qp->q_cnt_4);
3941 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3942 "\t\tHQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3943 "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
3944 qp->queue_id, qp->entry_count, qp->entry_size,
3945 qp->host_index, qp->hba_index, qp->notify_interval);
3946 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
3947 "\t\tDQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
3948 "HST-IDX[%04d], PRT-IDX[%04d], NTFI[%03d]\n",
3949 datqp->queue_id, datqp->entry_count,
3950 datqp->entry_size, datqp->host_index,
3951 datqp->hba_index, datqp->notify_interval);
3952 return len;
3953 }
3954
3955 static int
3956 lpfc_idiag_cqs_for_eq(struct lpfc_hba *phba, char *pbuffer,
3957 int *len, int max_cnt, int eqidx, int eq_id)
3958 {
3959 struct lpfc_queue *qp;
3960 int rc;
3961
3962 qp = phba->sli4_hba.hdwq[eqidx].io_cq;
3963
3964 *len = __lpfc_idiag_print_cq(qp, "IO", pbuffer, *len);
3965
3966 /* Reset max counter */
3967 qp->CQ_max_cqe = 0;
3968
3969 if (*len >= max_cnt)
3970 return 1;
3971
3972 rc = lpfc_idiag_wqs_for_cq(phba, "IO", pbuffer, len,
3973 max_cnt, qp->queue_id);
3974 if (rc)
3975 return 1;
3976
3977 if ((eqidx < phba->cfg_nvmet_mrq) && phba->nvmet_support) {
3978 /* NVMET CQset */
3979 qp = phba->sli4_hba.nvmet_cqset[eqidx];
3980 *len = __lpfc_idiag_print_cq(qp, "NVMET CQset", pbuffer, *len);
3981
3982 /* Reset max counter */
3983 qp->CQ_max_cqe = 0;
3984
3985 if (*len >= max_cnt)
3986 return 1;
3987
3988 /* RQ header */
3989 qp = phba->sli4_hba.nvmet_mrq_hdr[eqidx];
3990 *len = __lpfc_idiag_print_rqpair(qp,
3991 phba->sli4_hba.nvmet_mrq_data[eqidx],
3992 "NVMET MRQ", pbuffer, *len);
3993
3994 if (*len >= max_cnt)
3995 return 1;
3996 }
3997
3998 return 0;
3999 }
4000
4001 static int
4002 __lpfc_idiag_print_eq(struct lpfc_queue *qp, char *eqtype,
4003 char *pbuffer, int len)
4004 {
4005 if (!qp)
4006 return len;
4007
4008 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4009 "\n%s EQ info: EQ-STAT[max:x%x noE:x%x "
4010 "cqe_proc:x%x eqe_proc:x%llx eqd %d]\n",
4011 eqtype, qp->q_cnt_1, qp->q_cnt_2, qp->q_cnt_3,
4012 (unsigned long long)qp->q_cnt_4, qp->q_mode);
4013 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4014 "EQID[%02d], QE-CNT[%04d], QE-SZ[%04d], "
4015 "HST-IDX[%04d], NTFI[%03d], PLMT[%03d], AFFIN[%03d]",
4016 qp->queue_id, qp->entry_count, qp->entry_size,
4017 qp->host_index, qp->notify_interval,
4018 qp->max_proc_limit, qp->chann);
4019 len += scnprintf(pbuffer + len, LPFC_QUE_INFO_GET_BUF_SIZE - len,
4020 "\n");
4021
4022 return len;
4023 }
4024
4025 /**
4026 * lpfc_idiag_queinfo_read - idiag debugfs read queue information
4027 * @file: The file pointer to read from.
4028 * @buf: The buffer to copy the data to.
4029 * @nbytes: The number of bytes to read.
4030 * @ppos: The position in the file to start reading from.
4031 *
4032 * Description:
4033 * This routine reads data from the @phba SLI4 PCI function queue information,
4034 * and copies to user @buf.
4035 * This routine only returns 1 EQs worth of information. It remembers the last
4036 * EQ read and jumps to the next EQ. Thus subsequent calls to queInfo will
4037 * retrieve all EQs allocated for the phba.
4038 *
4039 * Returns:
4040 * This function returns the amount of data that was read (this could be less
4041 * than @nbytes if the end of the file was reached) or a negative error value.
4042 **/
4043 static ssize_t
4044 lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
4045 loff_t *ppos)
4046 {
4047 struct lpfc_debug *debug = file->private_data;
4048 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4049 char *pbuffer;
4050 int max_cnt, rc, x, len = 0;
4051 struct lpfc_queue *qp = NULL;
4052
4053 if (!debug->buffer)
4054 debug->buffer = kmalloc(LPFC_QUE_INFO_GET_BUF_SIZE, GFP_KERNEL);
4055 if (!debug->buffer)
4056 return 0;
4057 pbuffer = debug->buffer;
4058 max_cnt = LPFC_QUE_INFO_GET_BUF_SIZE - 256;
4059
4060 if (*ppos)
4061 return 0;
4062
4063 spin_lock_irq(&phba->hbalock);
4064
4065 /* Fast-path event queue */
4066 if (phba->sli4_hba.hdwq && phba->cfg_hdw_queue) {
4067
4068 x = phba->lpfc_idiag_last_eq;
4069 phba->lpfc_idiag_last_eq++;
4070 if (phba->lpfc_idiag_last_eq >= phba->cfg_hdw_queue)
4071 phba->lpfc_idiag_last_eq = 0;
4072
4073 len += scnprintf(pbuffer + len,
4074 LPFC_QUE_INFO_GET_BUF_SIZE - len,
4075 "HDWQ %d out of %d HBA HDWQs\n",
4076 x, phba->cfg_hdw_queue);
4077
4078 /* Fast-path EQ */
4079 qp = phba->sli4_hba.hdwq[x].hba_eq;
4080 if (!qp)
4081 goto out;
4082
4083 len = __lpfc_idiag_print_eq(qp, "HBA", pbuffer, len);
4084
4085 /* Reset max counter */
4086 qp->EQ_max_eqe = 0;
4087
4088 if (len >= max_cnt)
4089 goto too_big;
4090
4091 /* will dump both fcp and nvme cqs/wqs for the eq */
4092 rc = lpfc_idiag_cqs_for_eq(phba, pbuffer, &len,
4093 max_cnt, x, qp->queue_id);
4094 if (rc)
4095 goto too_big;
4096
4097 /* Only EQ 0 has slow path CQs configured */
4098 if (x)
4099 goto out;
4100
4101 /* Slow-path mailbox CQ */
4102 qp = phba->sli4_hba.mbx_cq;
4103 len = __lpfc_idiag_print_cq(qp, "MBX", pbuffer, len);
4104 if (len >= max_cnt)
4105 goto too_big;
4106
4107 /* Slow-path MBOX MQ */
4108 qp = phba->sli4_hba.mbx_wq;
4109 len = __lpfc_idiag_print_wq(qp, "MBX", pbuffer, len);
4110 if (len >= max_cnt)
4111 goto too_big;
4112
4113 /* Slow-path ELS response CQ */
4114 qp = phba->sli4_hba.els_cq;
4115 len = __lpfc_idiag_print_cq(qp, "ELS", pbuffer, len);
4116 /* Reset max counter */
4117 if (qp)
4118 qp->CQ_max_cqe = 0;
4119 if (len >= max_cnt)
4120 goto too_big;
4121
4122 /* Slow-path ELS WQ */
4123 qp = phba->sli4_hba.els_wq;
4124 len = __lpfc_idiag_print_wq(qp, "ELS", pbuffer, len);
4125 if (len >= max_cnt)
4126 goto too_big;
4127
4128 qp = phba->sli4_hba.hdr_rq;
4129 len = __lpfc_idiag_print_rqpair(qp, phba->sli4_hba.dat_rq,
4130 "ELS RQpair", pbuffer, len);
4131 if (len >= max_cnt)
4132 goto too_big;
4133
4134 /* Slow-path NVME LS response CQ */
4135 qp = phba->sli4_hba.nvmels_cq;
4136 len = __lpfc_idiag_print_cq(qp, "NVME LS",
4137 pbuffer, len);
4138 /* Reset max counter */
4139 if (qp)
4140 qp->CQ_max_cqe = 0;
4141 if (len >= max_cnt)
4142 goto too_big;
4143
4144 /* Slow-path NVME LS WQ */
4145 qp = phba->sli4_hba.nvmels_wq;
4146 len = __lpfc_idiag_print_wq(qp, "NVME LS",
4147 pbuffer, len);
4148 if (len >= max_cnt)
4149 goto too_big;
4150
4151 goto out;
4152 }
4153
4154 spin_unlock_irq(&phba->hbalock);
4155 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4156
4157 too_big:
4158 len += scnprintf(pbuffer + len,
4159 LPFC_QUE_INFO_GET_BUF_SIZE - len, "Truncated ...\n");
4160 out:
4161 spin_unlock_irq(&phba->hbalock);
4162 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4163 }
4164
4165 /**
4166 * lpfc_idiag_que_param_check - queue access command parameter sanity check
4167 * @q: The pointer to queue structure.
4168 * @index: The index into a queue entry.
4169 * @count: The number of queue entries to access.
4170 *
4171 * Description:
4172 * The routine performs sanity check on device queue access method commands.
4173 *
4174 * Returns:
4175 * This function returns -EINVAL when fails the sanity check, otherwise, it
4176 * returns 0.
4177 **/
4178 static int
4179 lpfc_idiag_que_param_check(struct lpfc_queue *q, int index, int count)
4180 {
4181 /* Only support single entry read or browsing */
4182 if ((count != 1) && (count != LPFC_QUE_ACC_BROWSE))
4183 return -EINVAL;
4184 if (index > q->entry_count - 1)
4185 return -EINVAL;
4186 return 0;
4187 }
4188
4189 /**
4190 * lpfc_idiag_queacc_read_qe - read a single entry from the given queue index
4191 * @pbuffer: The pointer to buffer to copy the read data into.
4192 * @len: Length of the buffer.
4193 * @pque: The pointer to the queue to be read.
4194 * @index: The index into the queue entry.
4195 *
4196 * Description:
4197 * This routine reads out a single entry from the given queue's index location
4198 * and copies it into the buffer provided.
4199 *
4200 * Returns:
4201 * This function returns 0 when it fails, otherwise, it returns the length of
4202 * the data read into the buffer provided.
4203 **/
4204 static int
4205 lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque,
4206 uint32_t index)
4207 {
4208 int offset, esize;
4209 uint32_t *pentry;
4210
4211 if (!pbuffer || !pque)
4212 return 0;
4213
4214 esize = pque->entry_size;
4215 len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
4216 "QE-INDEX[%04d]:\n", index);
4217
4218 offset = 0;
4219 pentry = lpfc_sli4_qe(pque, index);
4220 while (esize > 0) {
4221 len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
4222 "%08x ", *pentry);
4223 pentry++;
4224 offset += sizeof(uint32_t);
4225 esize -= sizeof(uint32_t);
4226 if (esize > 0 && !(offset % (4 * sizeof(uint32_t))))
4227 len += scnprintf(pbuffer+len,
4228 LPFC_QUE_ACC_BUF_SIZE-len, "\n");
4229 }
4230 len += scnprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
4231
4232 return len;
4233 }
4234
4235 /**
4236 * lpfc_idiag_queacc_read - idiag debugfs read port queue
4237 * @file: The file pointer to read from.
4238 * @buf: The buffer to copy the data to.
4239 * @nbytes: The number of bytes to read.
4240 * @ppos: The position in the file to start reading from.
4241 *
4242 * Description:
4243 * This routine reads data from the @phba device queue memory according to the
4244 * idiag command, and copies to user @buf. Depending on the queue dump read
4245 * command setup, it does either a single queue entry read or browing through
4246 * all entries of the queue.
4247 *
4248 * Returns:
4249 * This function returns the amount of data that was read (this could be less
4250 * than @nbytes if the end of the file was reached) or a negative error value.
4251 **/
4252 static ssize_t
4253 lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes,
4254 loff_t *ppos)
4255 {
4256 struct lpfc_debug *debug = file->private_data;
4257 uint32_t last_index, index, count;
4258 struct lpfc_queue *pque = NULL;
4259 char *pbuffer;
4260 int len = 0;
4261
4262 /* This is a user read operation */
4263 debug->op = LPFC_IDIAG_OP_RD;
4264
4265 if (!debug->buffer)
4266 debug->buffer = kmalloc(LPFC_QUE_ACC_BUF_SIZE, GFP_KERNEL);
4267 if (!debug->buffer)
4268 return 0;
4269 pbuffer = debug->buffer;
4270
4271 if (*ppos)
4272 return 0;
4273
4274 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
4275 index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
4276 count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
4277 pque = (struct lpfc_queue *)idiag.ptr_private;
4278 } else
4279 return 0;
4280
4281 /* Browse the queue starting from index */
4282 if (count == LPFC_QUE_ACC_BROWSE)
4283 goto que_browse;
4284
4285 /* Read a single entry from the queue */
4286 len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
4287
4288 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4289
4290 que_browse:
4291
4292 /* Browse all entries from the queue */
4293 last_index = idiag.offset.last_rd;
4294 index = last_index;
4295
4296 while (len < LPFC_QUE_ACC_SIZE - pque->entry_size) {
4297 len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
4298 index++;
4299 if (index > pque->entry_count - 1)
4300 break;
4301 }
4302
4303 /* Set up the offset for next portion of pci cfg read */
4304 if (index > pque->entry_count - 1)
4305 index = 0;
4306 idiag.offset.last_rd = index;
4307
4308 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4309 }
4310
4311 /**
4312 * lpfc_idiag_queacc_write - Syntax check and set up idiag queacc commands
4313 * @file: The file pointer to read from.
4314 * @buf: The buffer to copy the user data from.
4315 * @nbytes: The number of bytes to get.
4316 * @ppos: The position in the file to start reading from.
4317 *
4318 * This routine get the debugfs idiag command struct from user space and then
4319 * perform the syntax check for port queue read (dump) or write (set) command
4320 * accordingly. In the case of port queue read command, it sets up the command
4321 * in the idiag command struct for the following debugfs read operation. In
4322 * the case of port queue write operation, it executes the write operation
4323 * into the port queue entry accordingly.
4324 *
4325 * It returns the @nbytges passing in from debugfs user space when successful.
4326 * In case of error conditions, it returns proper error code back to the user
4327 * space.
4328 **/
4329 static ssize_t
4330 lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
4331 size_t nbytes, loff_t *ppos)
4332 {
4333 struct lpfc_debug *debug = file->private_data;
4334 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4335 uint32_t qidx, quetp, queid, index, count, offset, value;
4336 uint32_t *pentry;
4337 struct lpfc_queue *pque, *qp;
4338 int rc;
4339
4340 /* This is a user write operation */
4341 debug->op = LPFC_IDIAG_OP_WR;
4342
4343 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
4344 if (rc < 0)
4345 return rc;
4346
4347 /* Get and sanity check on command feilds */
4348 quetp = idiag.cmd.data[IDIAG_QUEACC_QUETP_INDX];
4349 queid = idiag.cmd.data[IDIAG_QUEACC_QUEID_INDX];
4350 index = idiag.cmd.data[IDIAG_QUEACC_INDEX_INDX];
4351 count = idiag.cmd.data[IDIAG_QUEACC_COUNT_INDX];
4352 offset = idiag.cmd.data[IDIAG_QUEACC_OFFST_INDX];
4353 value = idiag.cmd.data[IDIAG_QUEACC_VALUE_INDX];
4354
4355 /* Sanity check on command line arguments */
4356 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
4357 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
4358 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
4359 if (rc != LPFC_QUE_ACC_WR_CMD_ARG)
4360 goto error_out;
4361 if (count != 1)
4362 goto error_out;
4363 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
4364 if (rc != LPFC_QUE_ACC_RD_CMD_ARG)
4365 goto error_out;
4366 } else
4367 goto error_out;
4368
4369 switch (quetp) {
4370 case LPFC_IDIAG_EQ:
4371 /* HBA event queue */
4372 if (phba->sli4_hba.hdwq) {
4373 for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
4374 qp = phba->sli4_hba.hdwq[qidx].hba_eq;
4375 if (qp && qp->queue_id == queid) {
4376 /* Sanity check */
4377 rc = lpfc_idiag_que_param_check(qp,
4378 index, count);
4379 if (rc)
4380 goto error_out;
4381 idiag.ptr_private = qp;
4382 goto pass_check;
4383 }
4384 }
4385 }
4386 goto error_out;
4387
4388 case LPFC_IDIAG_CQ:
4389 /* MBX complete queue */
4390 if (phba->sli4_hba.mbx_cq &&
4391 phba->sli4_hba.mbx_cq->queue_id == queid) {
4392 /* Sanity check */
4393 rc = lpfc_idiag_que_param_check(
4394 phba->sli4_hba.mbx_cq, index, count);
4395 if (rc)
4396 goto error_out;
4397 idiag.ptr_private = phba->sli4_hba.mbx_cq;
4398 goto pass_check;
4399 }
4400 /* ELS complete queue */
4401 if (phba->sli4_hba.els_cq &&
4402 phba->sli4_hba.els_cq->queue_id == queid) {
4403 /* Sanity check */
4404 rc = lpfc_idiag_que_param_check(
4405 phba->sli4_hba.els_cq, index, count);
4406 if (rc)
4407 goto error_out;
4408 idiag.ptr_private = phba->sli4_hba.els_cq;
4409 goto pass_check;
4410 }
4411 /* NVME LS complete queue */
4412 if (phba->sli4_hba.nvmels_cq &&
4413 phba->sli4_hba.nvmels_cq->queue_id == queid) {
4414 /* Sanity check */
4415 rc = lpfc_idiag_que_param_check(
4416 phba->sli4_hba.nvmels_cq, index, count);
4417 if (rc)
4418 goto error_out;
4419 idiag.ptr_private = phba->sli4_hba.nvmels_cq;
4420 goto pass_check;
4421 }
4422 /* FCP complete queue */
4423 if (phba->sli4_hba.hdwq) {
4424 for (qidx = 0; qidx < phba->cfg_hdw_queue;
4425 qidx++) {
4426 qp = phba->sli4_hba.hdwq[qidx].io_cq;
4427 if (qp && qp->queue_id == queid) {
4428 /* Sanity check */
4429 rc = lpfc_idiag_que_param_check(
4430 qp, index, count);
4431 if (rc)
4432 goto error_out;
4433 idiag.ptr_private = qp;
4434 goto pass_check;
4435 }
4436 }
4437 }
4438 goto error_out;
4439
4440 case LPFC_IDIAG_MQ:
4441 /* MBX work queue */
4442 if (phba->sli4_hba.mbx_wq &&
4443 phba->sli4_hba.mbx_wq->queue_id == queid) {
4444 /* Sanity check */
4445 rc = lpfc_idiag_que_param_check(
4446 phba->sli4_hba.mbx_wq, index, count);
4447 if (rc)
4448 goto error_out;
4449 idiag.ptr_private = phba->sli4_hba.mbx_wq;
4450 goto pass_check;
4451 }
4452 goto error_out;
4453
4454 case LPFC_IDIAG_WQ:
4455 /* ELS work queue */
4456 if (phba->sli4_hba.els_wq &&
4457 phba->sli4_hba.els_wq->queue_id == queid) {
4458 /* Sanity check */
4459 rc = lpfc_idiag_que_param_check(
4460 phba->sli4_hba.els_wq, index, count);
4461 if (rc)
4462 goto error_out;
4463 idiag.ptr_private = phba->sli4_hba.els_wq;
4464 goto pass_check;
4465 }
4466 /* NVME LS work queue */
4467 if (phba->sli4_hba.nvmels_wq &&
4468 phba->sli4_hba.nvmels_wq->queue_id == queid) {
4469 /* Sanity check */
4470 rc = lpfc_idiag_que_param_check(
4471 phba->sli4_hba.nvmels_wq, index, count);
4472 if (rc)
4473 goto error_out;
4474 idiag.ptr_private = phba->sli4_hba.nvmels_wq;
4475 goto pass_check;
4476 }
4477
4478 if (phba->sli4_hba.hdwq) {
4479 /* FCP/SCSI work queue */
4480 for (qidx = 0; qidx < phba->cfg_hdw_queue; qidx++) {
4481 qp = phba->sli4_hba.hdwq[qidx].io_wq;
4482 if (qp && qp->queue_id == queid) {
4483 /* Sanity check */
4484 rc = lpfc_idiag_que_param_check(
4485 qp, index, count);
4486 if (rc)
4487 goto error_out;
4488 idiag.ptr_private = qp;
4489 goto pass_check;
4490 }
4491 }
4492 }
4493 goto error_out;
4494
4495 case LPFC_IDIAG_RQ:
4496 /* HDR queue */
4497 if (phba->sli4_hba.hdr_rq &&
4498 phba->sli4_hba.hdr_rq->queue_id == queid) {
4499 /* Sanity check */
4500 rc = lpfc_idiag_que_param_check(
4501 phba->sli4_hba.hdr_rq, index, count);
4502 if (rc)
4503 goto error_out;
4504 idiag.ptr_private = phba->sli4_hba.hdr_rq;
4505 goto pass_check;
4506 }
4507 /* DAT queue */
4508 if (phba->sli4_hba.dat_rq &&
4509 phba->sli4_hba.dat_rq->queue_id == queid) {
4510 /* Sanity check */
4511 rc = lpfc_idiag_que_param_check(
4512 phba->sli4_hba.dat_rq, index, count);
4513 if (rc)
4514 goto error_out;
4515 idiag.ptr_private = phba->sli4_hba.dat_rq;
4516 goto pass_check;
4517 }
4518 goto error_out;
4519 default:
4520 goto error_out;
4521 }
4522
4523 pass_check:
4524
4525 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
4526 if (count == LPFC_QUE_ACC_BROWSE)
4527 idiag.offset.last_rd = index;
4528 }
4529
4530 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
4531 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
4532 idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
4533 /* Additional sanity checks on write operation */
4534 pque = (struct lpfc_queue *)idiag.ptr_private;
4535 if (offset > pque->entry_size/sizeof(uint32_t) - 1)
4536 goto error_out;
4537 pentry = lpfc_sli4_qe(pque, index);
4538 pentry += offset;
4539 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR)
4540 *pentry = value;
4541 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST)
4542 *pentry |= value;
4543 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL)
4544 *pentry &= ~value;
4545 }
4546 return nbytes;
4547
4548 error_out:
4549 /* Clean out command structure on command error out */
4550 memset(&idiag, 0, sizeof(idiag));
4551 return -EINVAL;
4552 }
4553
4554 /**
4555 * lpfc_idiag_drbacc_read_reg - idiag debugfs read a doorbell register
4556 * @phba: The pointer to hba structure.
4557 * @pbuffer: The pointer to the buffer to copy the data to.
4558 * @len: The length of bytes to copied.
4559 * @drbregid: The id to doorbell registers.
4560 *
4561 * Description:
4562 * This routine reads a doorbell register and copies its content to the
4563 * user buffer pointed to by @pbuffer.
4564 *
4565 * Returns:
4566 * This function returns the amount of data that was copied into @pbuffer.
4567 **/
4568 static int
4569 lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
4570 int len, uint32_t drbregid)
4571 {
4572
4573 if (!pbuffer)
4574 return 0;
4575
4576 switch (drbregid) {
4577 case LPFC_DRB_EQ:
4578 len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE-len,
4579 "EQ-DRB-REG: 0x%08x\n",
4580 readl(phba->sli4_hba.EQDBregaddr));
4581 break;
4582 case LPFC_DRB_CQ:
4583 len += scnprintf(pbuffer + len, LPFC_DRB_ACC_BUF_SIZE - len,
4584 "CQ-DRB-REG: 0x%08x\n",
4585 readl(phba->sli4_hba.CQDBregaddr));
4586 break;
4587 case LPFC_DRB_MQ:
4588 len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
4589 "MQ-DRB-REG: 0x%08x\n",
4590 readl(phba->sli4_hba.MQDBregaddr));
4591 break;
4592 case LPFC_DRB_WQ:
4593 len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
4594 "WQ-DRB-REG: 0x%08x\n",
4595 readl(phba->sli4_hba.WQDBregaddr));
4596 break;
4597 case LPFC_DRB_RQ:
4598 len += scnprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
4599 "RQ-DRB-REG: 0x%08x\n",
4600 readl(phba->sli4_hba.RQDBregaddr));
4601 break;
4602 default:
4603 break;
4604 }
4605
4606 return len;
4607 }
4608
4609 /**
4610 * lpfc_idiag_drbacc_read - idiag debugfs read port doorbell
4611 * @file: The file pointer to read from.
4612 * @buf: The buffer to copy the data to.
4613 * @nbytes: The number of bytes to read.
4614 * @ppos: The position in the file to start reading from.
4615 *
4616 * Description:
4617 * This routine reads data from the @phba device doorbell register according
4618 * to the idiag command, and copies to user @buf. Depending on the doorbell
4619 * register read command setup, it does either a single doorbell register
4620 * read or dump all doorbell registers.
4621 *
4622 * Returns:
4623 * This function returns the amount of data that was read (this could be less
4624 * than @nbytes if the end of the file was reached) or a negative error value.
4625 **/
4626 static ssize_t
4627 lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes,
4628 loff_t *ppos)
4629 {
4630 struct lpfc_debug *debug = file->private_data;
4631 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4632 uint32_t drb_reg_id, i;
4633 char *pbuffer;
4634 int len = 0;
4635
4636 /* This is a user read operation */
4637 debug->op = LPFC_IDIAG_OP_RD;
4638
4639 if (!debug->buffer)
4640 debug->buffer = kmalloc(LPFC_DRB_ACC_BUF_SIZE, GFP_KERNEL);
4641 if (!debug->buffer)
4642 return 0;
4643 pbuffer = debug->buffer;
4644
4645 if (*ppos)
4646 return 0;
4647
4648 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD)
4649 drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
4650 else
4651 return 0;
4652
4653 if (drb_reg_id == LPFC_DRB_ACC_ALL)
4654 for (i = 1; i <= LPFC_DRB_MAX; i++)
4655 len = lpfc_idiag_drbacc_read_reg(phba,
4656 pbuffer, len, i);
4657 else
4658 len = lpfc_idiag_drbacc_read_reg(phba,
4659 pbuffer, len, drb_reg_id);
4660
4661 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4662 }
4663
4664 /**
4665 * lpfc_idiag_drbacc_write - Syntax check and set up idiag drbacc commands
4666 * @file: The file pointer to read from.
4667 * @buf: The buffer to copy the user data from.
4668 * @nbytes: The number of bytes to get.
4669 * @ppos: The position in the file to start reading from.
4670 *
4671 * This routine get the debugfs idiag command struct from user space and then
4672 * perform the syntax check for port doorbell register read (dump) or write
4673 * (set) command accordingly. In the case of port queue read command, it sets
4674 * up the command in the idiag command struct for the following debugfs read
4675 * operation. In the case of port doorbell register write operation, it
4676 * executes the write operation into the port doorbell register accordingly.
4677 *
4678 * It returns the @nbytges passing in from debugfs user space when successful.
4679 * In case of error conditions, it returns proper error code back to the user
4680 * space.
4681 **/
4682 static ssize_t
4683 lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
4684 size_t nbytes, loff_t *ppos)
4685 {
4686 struct lpfc_debug *debug = file->private_data;
4687 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4688 uint32_t drb_reg_id, value, reg_val = 0;
4689 void __iomem *drb_reg;
4690 int rc;
4691
4692 /* This is a user write operation */
4693 debug->op = LPFC_IDIAG_OP_WR;
4694
4695 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
4696 if (rc < 0)
4697 return rc;
4698
4699 /* Sanity check on command line arguments */
4700 drb_reg_id = idiag.cmd.data[IDIAG_DRBACC_REGID_INDX];
4701 value = idiag.cmd.data[IDIAG_DRBACC_VALUE_INDX];
4702
4703 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
4704 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
4705 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
4706 if (rc != LPFC_DRB_ACC_WR_CMD_ARG)
4707 goto error_out;
4708 if (drb_reg_id > LPFC_DRB_MAX)
4709 goto error_out;
4710 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) {
4711 if (rc != LPFC_DRB_ACC_RD_CMD_ARG)
4712 goto error_out;
4713 if ((drb_reg_id > LPFC_DRB_MAX) &&
4714 (drb_reg_id != LPFC_DRB_ACC_ALL))
4715 goto error_out;
4716 } else
4717 goto error_out;
4718
4719 /* Perform the write access operation */
4720 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
4721 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
4722 idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
4723 switch (drb_reg_id) {
4724 case LPFC_DRB_EQ:
4725 drb_reg = phba->sli4_hba.EQDBregaddr;
4726 break;
4727 case LPFC_DRB_CQ:
4728 drb_reg = phba->sli4_hba.CQDBregaddr;
4729 break;
4730 case LPFC_DRB_MQ:
4731 drb_reg = phba->sli4_hba.MQDBregaddr;
4732 break;
4733 case LPFC_DRB_WQ:
4734 drb_reg = phba->sli4_hba.WQDBregaddr;
4735 break;
4736 case LPFC_DRB_RQ:
4737 drb_reg = phba->sli4_hba.RQDBregaddr;
4738 break;
4739 default:
4740 goto error_out;
4741 }
4742
4743 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR)
4744 reg_val = value;
4745 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST) {
4746 reg_val = readl(drb_reg);
4747 reg_val |= value;
4748 }
4749 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
4750 reg_val = readl(drb_reg);
4751 reg_val &= ~value;
4752 }
4753 writel(reg_val, drb_reg);
4754 readl(drb_reg); /* flush */
4755 }
4756 return nbytes;
4757
4758 error_out:
4759 /* Clean out command structure on command error out */
4760 memset(&idiag, 0, sizeof(idiag));
4761 return -EINVAL;
4762 }
4763
4764 /**
4765 * lpfc_idiag_ctlacc_read_reg - idiag debugfs read a control registers
4766 * @phba: The pointer to hba structure.
4767 * @pbuffer: The pointer to the buffer to copy the data to.
4768 * @len: The length of bytes to copied.
4769 * @ctlregid: The id to doorbell registers.
4770 *
4771 * Description:
4772 * This routine reads a control register and copies its content to the
4773 * user buffer pointed to by @pbuffer.
4774 *
4775 * Returns:
4776 * This function returns the amount of data that was copied into @pbuffer.
4777 **/
4778 static int
4779 lpfc_idiag_ctlacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
4780 int len, uint32_t ctlregid)
4781 {
4782
4783 if (!pbuffer)
4784 return 0;
4785
4786 switch (ctlregid) {
4787 case LPFC_CTL_PORT_SEM:
4788 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4789 "Port SemReg: 0x%08x\n",
4790 readl(phba->sli4_hba.conf_regs_memmap_p +
4791 LPFC_CTL_PORT_SEM_OFFSET));
4792 break;
4793 case LPFC_CTL_PORT_STA:
4794 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4795 "Port StaReg: 0x%08x\n",
4796 readl(phba->sli4_hba.conf_regs_memmap_p +
4797 LPFC_CTL_PORT_STA_OFFSET));
4798 break;
4799 case LPFC_CTL_PORT_CTL:
4800 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4801 "Port CtlReg: 0x%08x\n",
4802 readl(phba->sli4_hba.conf_regs_memmap_p +
4803 LPFC_CTL_PORT_CTL_OFFSET));
4804 break;
4805 case LPFC_CTL_PORT_ER1:
4806 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4807 "Port Er1Reg: 0x%08x\n",
4808 readl(phba->sli4_hba.conf_regs_memmap_p +
4809 LPFC_CTL_PORT_ER1_OFFSET));
4810 break;
4811 case LPFC_CTL_PORT_ER2:
4812 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4813 "Port Er2Reg: 0x%08x\n",
4814 readl(phba->sli4_hba.conf_regs_memmap_p +
4815 LPFC_CTL_PORT_ER2_OFFSET));
4816 break;
4817 case LPFC_CTL_PDEV_CTL:
4818 len += scnprintf(pbuffer+len, LPFC_CTL_ACC_BUF_SIZE-len,
4819 "PDev CtlReg: 0x%08x\n",
4820 readl(phba->sli4_hba.conf_regs_memmap_p +
4821 LPFC_CTL_PDEV_CTL_OFFSET));
4822 break;
4823 default:
4824 break;
4825 }
4826 return len;
4827 }
4828
4829 /**
4830 * lpfc_idiag_ctlacc_read - idiag debugfs read port and device control register
4831 * @file: The file pointer to read from.
4832 * @buf: The buffer to copy the data to.
4833 * @nbytes: The number of bytes to read.
4834 * @ppos: The position in the file to start reading from.
4835 *
4836 * Description:
4837 * This routine reads data from the @phba port and device registers according
4838 * to the idiag command, and copies to user @buf.
4839 *
4840 * Returns:
4841 * This function returns the amount of data that was read (this could be less
4842 * than @nbytes if the end of the file was reached) or a negative error value.
4843 **/
4844 static ssize_t
4845 lpfc_idiag_ctlacc_read(struct file *file, char __user *buf, size_t nbytes,
4846 loff_t *ppos)
4847 {
4848 struct lpfc_debug *debug = file->private_data;
4849 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4850 uint32_t ctl_reg_id, i;
4851 char *pbuffer;
4852 int len = 0;
4853
4854 /* This is a user read operation */
4855 debug->op = LPFC_IDIAG_OP_RD;
4856
4857 if (!debug->buffer)
4858 debug->buffer = kmalloc(LPFC_CTL_ACC_BUF_SIZE, GFP_KERNEL);
4859 if (!debug->buffer)
4860 return 0;
4861 pbuffer = debug->buffer;
4862
4863 if (*ppos)
4864 return 0;
4865
4866 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD)
4867 ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
4868 else
4869 return 0;
4870
4871 if (ctl_reg_id == LPFC_CTL_ACC_ALL)
4872 for (i = 1; i <= LPFC_CTL_MAX; i++)
4873 len = lpfc_idiag_ctlacc_read_reg(phba,
4874 pbuffer, len, i);
4875 else
4876 len = lpfc_idiag_ctlacc_read_reg(phba,
4877 pbuffer, len, ctl_reg_id);
4878
4879 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
4880 }
4881
4882 /**
4883 * lpfc_idiag_ctlacc_write - Syntax check and set up idiag ctlacc commands
4884 * @file: The file pointer to read from.
4885 * @buf: The buffer to copy the user data from.
4886 * @nbytes: The number of bytes to get.
4887 * @ppos: The position in the file to start reading from.
4888 *
4889 * This routine get the debugfs idiag command struct from user space and then
4890 * perform the syntax check for port and device control register read (dump)
4891 * or write (set) command accordingly.
4892 *
4893 * It returns the @nbytges passing in from debugfs user space when successful.
4894 * In case of error conditions, it returns proper error code back to the user
4895 * space.
4896 **/
4897 static ssize_t
4898 lpfc_idiag_ctlacc_write(struct file *file, const char __user *buf,
4899 size_t nbytes, loff_t *ppos)
4900 {
4901 struct lpfc_debug *debug = file->private_data;
4902 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
4903 uint32_t ctl_reg_id, value, reg_val = 0;
4904 void __iomem *ctl_reg;
4905 int rc;
4906
4907 /* This is a user write operation */
4908 debug->op = LPFC_IDIAG_OP_WR;
4909
4910 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
4911 if (rc < 0)
4912 return rc;
4913
4914 /* Sanity check on command line arguments */
4915 ctl_reg_id = idiag.cmd.data[IDIAG_CTLACC_REGID_INDX];
4916 value = idiag.cmd.data[IDIAG_CTLACC_VALUE_INDX];
4917
4918 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
4919 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
4920 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
4921 if (rc != LPFC_CTL_ACC_WR_CMD_ARG)
4922 goto error_out;
4923 if (ctl_reg_id > LPFC_CTL_MAX)
4924 goto error_out;
4925 } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_RD) {
4926 if (rc != LPFC_CTL_ACC_RD_CMD_ARG)
4927 goto error_out;
4928 if ((ctl_reg_id > LPFC_CTL_MAX) &&
4929 (ctl_reg_id != LPFC_CTL_ACC_ALL))
4930 goto error_out;
4931 } else
4932 goto error_out;
4933
4934 /* Perform the write access operation */
4935 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR ||
4936 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST ||
4937 idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
4938 switch (ctl_reg_id) {
4939 case LPFC_CTL_PORT_SEM:
4940 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4941 LPFC_CTL_PORT_SEM_OFFSET;
4942 break;
4943 case LPFC_CTL_PORT_STA:
4944 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4945 LPFC_CTL_PORT_STA_OFFSET;
4946 break;
4947 case LPFC_CTL_PORT_CTL:
4948 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4949 LPFC_CTL_PORT_CTL_OFFSET;
4950 break;
4951 case LPFC_CTL_PORT_ER1:
4952 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4953 LPFC_CTL_PORT_ER1_OFFSET;
4954 break;
4955 case LPFC_CTL_PORT_ER2:
4956 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4957 LPFC_CTL_PORT_ER2_OFFSET;
4958 break;
4959 case LPFC_CTL_PDEV_CTL:
4960 ctl_reg = phba->sli4_hba.conf_regs_memmap_p +
4961 LPFC_CTL_PDEV_CTL_OFFSET;
4962 break;
4963 default:
4964 goto error_out;
4965 }
4966
4967 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_WR)
4968 reg_val = value;
4969 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_ST) {
4970 reg_val = readl(ctl_reg);
4971 reg_val |= value;
4972 }
4973 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_CTLACC_CL) {
4974 reg_val = readl(ctl_reg);
4975 reg_val &= ~value;
4976 }
4977 writel(reg_val, ctl_reg);
4978 readl(ctl_reg); /* flush */
4979 }
4980 return nbytes;
4981
4982 error_out:
4983 /* Clean out command structure on command error out */
4984 memset(&idiag, 0, sizeof(idiag));
4985 return -EINVAL;
4986 }
4987
4988 /**
4989 * lpfc_idiag_mbxacc_get_setup - idiag debugfs get mailbox access setup
4990 * @phba: Pointer to HBA context object.
4991 * @pbuffer: Pointer to data buffer.
4992 *
4993 * Description:
4994 * This routine gets the driver mailbox access debugfs setup information.
4995 *
4996 * Returns:
4997 * This function returns the amount of data that was read (this could be less
4998 * than @nbytes if the end of the file was reached) or a negative error value.
4999 **/
5000 static int
5001 lpfc_idiag_mbxacc_get_setup(struct lpfc_hba *phba, char *pbuffer)
5002 {
5003 uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
5004 int len = 0;
5005
5006 mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5007 mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5008 mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5009 mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5010
5011 len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
5012 "mbx_dump_map: 0x%08x\n", mbx_dump_map);
5013 len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
5014 "mbx_dump_cnt: %04d\n", mbx_dump_cnt);
5015 len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
5016 "mbx_word_cnt: %04d\n", mbx_word_cnt);
5017 len += scnprintf(pbuffer+len, LPFC_MBX_ACC_BUF_SIZE-len,
5018 "mbx_mbox_cmd: 0x%02x\n", mbx_mbox_cmd);
5019
5020 return len;
5021 }
5022
5023 /**
5024 * lpfc_idiag_mbxacc_read - idiag debugfs read on mailbox access
5025 * @file: The file pointer to read from.
5026 * @buf: The buffer to copy the data to.
5027 * @nbytes: The number of bytes to read.
5028 * @ppos: The position in the file to start reading from.
5029 *
5030 * Description:
5031 * This routine reads data from the @phba driver mailbox access debugfs setup
5032 * information.
5033 *
5034 * Returns:
5035 * This function returns the amount of data that was read (this could be less
5036 * than @nbytes if the end of the file was reached) or a negative error value.
5037 **/
5038 static ssize_t
5039 lpfc_idiag_mbxacc_read(struct file *file, char __user *buf, size_t nbytes,
5040 loff_t *ppos)
5041 {
5042 struct lpfc_debug *debug = file->private_data;
5043 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
5044 char *pbuffer;
5045 int len = 0;
5046
5047 /* This is a user read operation */
5048 debug->op = LPFC_IDIAG_OP_RD;
5049
5050 if (!debug->buffer)
5051 debug->buffer = kmalloc(LPFC_MBX_ACC_BUF_SIZE, GFP_KERNEL);
5052 if (!debug->buffer)
5053 return 0;
5054 pbuffer = debug->buffer;
5055
5056 if (*ppos)
5057 return 0;
5058
5059 if ((idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP) &&
5060 (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP))
5061 return 0;
5062
5063 len = lpfc_idiag_mbxacc_get_setup(phba, pbuffer);
5064
5065 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
5066 }
5067
5068 /**
5069 * lpfc_idiag_mbxacc_write - Syntax check and set up idiag mbxacc commands
5070 * @file: The file pointer to read from.
5071 * @buf: The buffer to copy the user data from.
5072 * @nbytes: The number of bytes to get.
5073 * @ppos: The position in the file to start reading from.
5074 *
5075 * This routine get the debugfs idiag command struct from user space and then
5076 * perform the syntax check for driver mailbox command (dump) and sets up the
5077 * necessary states in the idiag command struct accordingly.
5078 *
5079 * It returns the @nbytges passing in from debugfs user space when successful.
5080 * In case of error conditions, it returns proper error code back to the user
5081 * space.
5082 **/
5083 static ssize_t
5084 lpfc_idiag_mbxacc_write(struct file *file, const char __user *buf,
5085 size_t nbytes, loff_t *ppos)
5086 {
5087 struct lpfc_debug *debug = file->private_data;
5088 uint32_t mbx_dump_map, mbx_dump_cnt, mbx_word_cnt, mbx_mbox_cmd;
5089 int rc;
5090
5091 /* This is a user write operation */
5092 debug->op = LPFC_IDIAG_OP_WR;
5093
5094 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
5095 if (rc < 0)
5096 return rc;
5097
5098 /* Sanity check on command line arguments */
5099 mbx_mbox_cmd = idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5100 mbx_dump_map = idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5101 mbx_dump_cnt = idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5102 mbx_word_cnt = idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5103
5104 if (idiag.cmd.opcode == LPFC_IDIAG_CMD_MBXACC_DP) {
5105 if (!(mbx_dump_map & LPFC_MBX_DMP_MBX_ALL))
5106 goto error_out;
5107 if ((mbx_dump_map & ~LPFC_MBX_DMP_MBX_ALL) &&
5108 (mbx_dump_map != LPFC_MBX_DMP_ALL))
5109 goto error_out;
5110 if (mbx_word_cnt > sizeof(MAILBOX_t))
5111 goto error_out;
5112 } else if (idiag.cmd.opcode == LPFC_IDIAG_BSG_MBXACC_DP) {
5113 if (!(mbx_dump_map & LPFC_BSG_DMP_MBX_ALL))
5114 goto error_out;
5115 if ((mbx_dump_map & ~LPFC_BSG_DMP_MBX_ALL) &&
5116 (mbx_dump_map != LPFC_MBX_DMP_ALL))
5117 goto error_out;
5118 if (mbx_word_cnt > (BSG_MBOX_SIZE)/4)
5119 goto error_out;
5120 if (mbx_mbox_cmd != 0x9b)
5121 goto error_out;
5122 } else
5123 goto error_out;
5124
5125 if (mbx_word_cnt == 0)
5126 goto error_out;
5127 if (rc != LPFC_MBX_DMP_ARG)
5128 goto error_out;
5129 if (mbx_mbox_cmd & ~0xff)
5130 goto error_out;
5131
5132 /* condition for stop mailbox dump */
5133 if (mbx_dump_cnt == 0)
5134 goto reset_out;
5135
5136 return nbytes;
5137
5138 reset_out:
5139 /* Clean out command structure on command error out */
5140 memset(&idiag, 0, sizeof(idiag));
5141 return nbytes;
5142
5143 error_out:
5144 /* Clean out command structure on command error out */
5145 memset(&idiag, 0, sizeof(idiag));
5146 return -EINVAL;
5147 }
5148
5149 /**
5150 * lpfc_idiag_extacc_avail_get - get the available extents information
5151 * @phba: pointer to lpfc hba data structure.
5152 * @pbuffer: pointer to internal buffer.
5153 * @len: length into the internal buffer data has been copied.
5154 *
5155 * Description:
5156 * This routine is to get the available extent information.
5157 *
5158 * Returns:
5159 * overall length of the data read into the internal buffer.
5160 **/
5161 static int
5162 lpfc_idiag_extacc_avail_get(struct lpfc_hba *phba, char *pbuffer, int len)
5163 {
5164 uint16_t ext_cnt = 0, ext_size = 0;
5165
5166 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5167 "\nAvailable Extents Information:\n");
5168
5169 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5170 "\tPort Available VPI extents: ");
5171 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VPI,
5172 &ext_cnt, &ext_size);
5173 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5174 "Count %3d, Size %3d\n", ext_cnt, ext_size);
5175
5176 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5177 "\tPort Available VFI extents: ");
5178 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_VFI,
5179 &ext_cnt, &ext_size);
5180 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5181 "Count %3d, Size %3d\n", ext_cnt, ext_size);
5182
5183 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5184 "\tPort Available RPI extents: ");
5185 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_RPI,
5186 &ext_cnt, &ext_size);
5187 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5188 "Count %3d, Size %3d\n", ext_cnt, ext_size);
5189
5190 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5191 "\tPort Available XRI extents: ");
5192 lpfc_sli4_get_avail_extnt_rsrc(phba, LPFC_RSC_TYPE_FCOE_XRI,
5193 &ext_cnt, &ext_size);
5194 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5195 "Count %3d, Size %3d\n", ext_cnt, ext_size);
5196
5197 return len;
5198 }
5199
5200 /**
5201 * lpfc_idiag_extacc_alloc_get - get the allocated extents information
5202 * @phba: pointer to lpfc hba data structure.
5203 * @pbuffer: pointer to internal buffer.
5204 * @len: length into the internal buffer data has been copied.
5205 *
5206 * Description:
5207 * This routine is to get the allocated extent information.
5208 *
5209 * Returns:
5210 * overall length of the data read into the internal buffer.
5211 **/
5212 static int
5213 lpfc_idiag_extacc_alloc_get(struct lpfc_hba *phba, char *pbuffer, int len)
5214 {
5215 uint16_t ext_cnt, ext_size;
5216 int rc;
5217
5218 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5219 "\nAllocated Extents Information:\n");
5220
5221 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5222 "\tHost Allocated VPI extents: ");
5223 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VPI,
5224 &ext_cnt, &ext_size);
5225 if (!rc)
5226 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5227 "Port %d Extent %3d, Size %3d\n",
5228 phba->brd_no, ext_cnt, ext_size);
5229 else
5230 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5231 "N/A\n");
5232
5233 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5234 "\tHost Allocated VFI extents: ");
5235 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_VFI,
5236 &ext_cnt, &ext_size);
5237 if (!rc)
5238 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5239 "Port %d Extent %3d, Size %3d\n",
5240 phba->brd_no, ext_cnt, ext_size);
5241 else
5242 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5243 "N/A\n");
5244
5245 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5246 "\tHost Allocated RPI extents: ");
5247 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_RPI,
5248 &ext_cnt, &ext_size);
5249 if (!rc)
5250 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5251 "Port %d Extent %3d, Size %3d\n",
5252 phba->brd_no, ext_cnt, ext_size);
5253 else
5254 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5255 "N/A\n");
5256
5257 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5258 "\tHost Allocated XRI extents: ");
5259 rc = lpfc_sli4_get_allocated_extnts(phba, LPFC_RSC_TYPE_FCOE_XRI,
5260 &ext_cnt, &ext_size);
5261 if (!rc)
5262 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5263 "Port %d Extent %3d, Size %3d\n",
5264 phba->brd_no, ext_cnt, ext_size);
5265 else
5266 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5267 "N/A\n");
5268
5269 return len;
5270 }
5271
5272 /**
5273 * lpfc_idiag_extacc_drivr_get - get driver extent information
5274 * @phba: pointer to lpfc hba data structure.
5275 * @pbuffer: pointer to internal buffer.
5276 * @len: length into the internal buffer data has been copied.
5277 *
5278 * Description:
5279 * This routine is to get the driver extent information.
5280 *
5281 * Returns:
5282 * overall length of the data read into the internal buffer.
5283 **/
5284 static int
5285 lpfc_idiag_extacc_drivr_get(struct lpfc_hba *phba, char *pbuffer, int len)
5286 {
5287 struct lpfc_rsrc_blks *rsrc_blks;
5288 int index;
5289
5290 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5291 "\nDriver Extents Information:\n");
5292
5293 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5294 "\tVPI extents:\n");
5295 index = 0;
5296 list_for_each_entry(rsrc_blks, &phba->lpfc_vpi_blk_list, list) {
5297 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5298 "\t\tBlock %3d: Start %4d, Count %4d\n",
5299 index, rsrc_blks->rsrc_start,
5300 rsrc_blks->rsrc_size);
5301 index++;
5302 }
5303 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5304 "\tVFI extents:\n");
5305 index = 0;
5306 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_vfi_blk_list,
5307 list) {
5308 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5309 "\t\tBlock %3d: Start %4d, Count %4d\n",
5310 index, rsrc_blks->rsrc_start,
5311 rsrc_blks->rsrc_size);
5312 index++;
5313 }
5314
5315 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5316 "\tRPI extents:\n");
5317 index = 0;
5318 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_rpi_blk_list,
5319 list) {
5320 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5321 "\t\tBlock %3d: Start %4d, Count %4d\n",
5322 index, rsrc_blks->rsrc_start,
5323 rsrc_blks->rsrc_size);
5324 index++;
5325 }
5326
5327 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5328 "\tXRI extents:\n");
5329 index = 0;
5330 list_for_each_entry(rsrc_blks, &phba->sli4_hba.lpfc_xri_blk_list,
5331 list) {
5332 len += scnprintf(pbuffer+len, LPFC_EXT_ACC_BUF_SIZE-len,
5333 "\t\tBlock %3d: Start %4d, Count %4d\n",
5334 index, rsrc_blks->rsrc_start,
5335 rsrc_blks->rsrc_size);
5336 index++;
5337 }
5338
5339 return len;
5340 }
5341
5342 /**
5343 * lpfc_idiag_extacc_write - Syntax check and set up idiag extacc commands
5344 * @file: The file pointer to read from.
5345 * @buf: The buffer to copy the user data from.
5346 * @nbytes: The number of bytes to get.
5347 * @ppos: The position in the file to start reading from.
5348 *
5349 * This routine get the debugfs idiag command struct from user space and then
5350 * perform the syntax check for extent information access commands and sets
5351 * up the necessary states in the idiag command struct accordingly.
5352 *
5353 * It returns the @nbytges passing in from debugfs user space when successful.
5354 * In case of error conditions, it returns proper error code back to the user
5355 * space.
5356 **/
5357 static ssize_t
5358 lpfc_idiag_extacc_write(struct file *file, const char __user *buf,
5359 size_t nbytes, loff_t *ppos)
5360 {
5361 struct lpfc_debug *debug = file->private_data;
5362 uint32_t ext_map;
5363 int rc;
5364
5365 /* This is a user write operation */
5366 debug->op = LPFC_IDIAG_OP_WR;
5367
5368 rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
5369 if (rc < 0)
5370 return rc;
5371
5372 ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
5373
5374 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
5375 goto error_out;
5376 if (rc != LPFC_EXT_ACC_CMD_ARG)
5377 goto error_out;
5378 if (!(ext_map & LPFC_EXT_ACC_ALL))
5379 goto error_out;
5380
5381 return nbytes;
5382 error_out:
5383 /* Clean out command structure on command error out */
5384 memset(&idiag, 0, sizeof(idiag));
5385 return -EINVAL;
5386 }
5387
5388 /**
5389 * lpfc_idiag_extacc_read - idiag debugfs read access to extent information
5390 * @file: The file pointer to read from.
5391 * @buf: The buffer to copy the data to.
5392 * @nbytes: The number of bytes to read.
5393 * @ppos: The position in the file to start reading from.
5394 *
5395 * Description:
5396 * This routine reads data from the proper extent information according to
5397 * the idiag command, and copies to user @buf.
5398 *
5399 * Returns:
5400 * This function returns the amount of data that was read (this could be less
5401 * than @nbytes if the end of the file was reached) or a negative error value.
5402 **/
5403 static ssize_t
5404 lpfc_idiag_extacc_read(struct file *file, char __user *buf, size_t nbytes,
5405 loff_t *ppos)
5406 {
5407 struct lpfc_debug *debug = file->private_data;
5408 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
5409 char *pbuffer;
5410 uint32_t ext_map;
5411 int len = 0;
5412
5413 /* This is a user read operation */
5414 debug->op = LPFC_IDIAG_OP_RD;
5415
5416 if (!debug->buffer)
5417 debug->buffer = kmalloc(LPFC_EXT_ACC_BUF_SIZE, GFP_KERNEL);
5418 if (!debug->buffer)
5419 return 0;
5420 pbuffer = debug->buffer;
5421 if (*ppos)
5422 return 0;
5423 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_EXTACC_RD)
5424 return 0;
5425
5426 ext_map = idiag.cmd.data[IDIAG_EXTACC_EXMAP_INDX];
5427 if (ext_map & LPFC_EXT_ACC_AVAIL)
5428 len = lpfc_idiag_extacc_avail_get(phba, pbuffer, len);
5429 if (ext_map & LPFC_EXT_ACC_ALLOC)
5430 len = lpfc_idiag_extacc_alloc_get(phba, pbuffer, len);
5431 if (ext_map & LPFC_EXT_ACC_DRIVR)
5432 len = lpfc_idiag_extacc_drivr_get(phba, pbuffer, len);
5433
5434 return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
5435 }
5436
5437 static int
5438 lpfc_cgn_buffer_open(struct inode *inode, struct file *file)
5439 {
5440 struct lpfc_debug *debug;
5441 int rc = -ENOMEM;
5442
5443 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
5444 if (!debug)
5445 goto out;
5446
5447 debug->buffer = vmalloc(LPFC_CGN_BUF_SIZE);
5448 if (!debug->buffer) {
5449 kfree(debug);
5450 goto out;
5451 }
5452
5453 debug->i_private = inode->i_private;
5454 file->private_data = debug;
5455
5456 rc = 0;
5457 out:
5458 return rc;
5459 }
5460
5461 static ssize_t
5462 lpfc_cgn_buffer_read(struct file *file, char __user *buf, size_t nbytes,
5463 loff_t *ppos)
5464 {
5465 struct lpfc_debug *debug = file->private_data;
5466 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
5467 char *buffer = debug->buffer;
5468 uint32_t *ptr;
5469 int cnt, len = 0;
5470
5471 if (!phba->sli4_hba.pc_sli4_params.mi_ver || !phba->cgn_i) {
5472 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5473 "Congestion Mgmt is not supported\n");
5474 goto out;
5475 }
5476 ptr = (uint32_t *)phba->cgn_i->virt;
5477 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5478 "Congestion Buffer Header\n");
5479 /* Dump the first 32 bytes */
5480 cnt = 32;
5481 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5482 "000: %08x %08x %08x %08x %08x %08x %08x %08x\n",
5483 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3),
5484 *(ptr + 4), *(ptr + 5), *(ptr + 6), *(ptr + 7));
5485 ptr += 8;
5486 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5487 "Congestion Buffer Data\n");
5488 while (cnt < sizeof(struct lpfc_cgn_info)) {
5489 if (len > (LPFC_CGN_BUF_SIZE - LPFC_DEBUG_OUT_LINE_SZ)) {
5490 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5491 "Truncated . . .\n");
5492 goto out;
5493 }
5494 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5495 "%03x: %08x %08x %08x %08x "
5496 "%08x %08x %08x %08x\n",
5497 cnt, *ptr, *(ptr + 1), *(ptr + 2),
5498 *(ptr + 3), *(ptr + 4), *(ptr + 5),
5499 *(ptr + 6), *(ptr + 7));
5500 cnt += 32;
5501 ptr += 8;
5502 }
5503 if (len > (LPFC_CGN_BUF_SIZE - LPFC_DEBUG_OUT_LINE_SZ)) {
5504 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5505 "Truncated . . .\n");
5506 goto out;
5507 }
5508 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5509 "Parameter Data\n");
5510 ptr = (uint32_t *)&phba->cgn_p;
5511 len += scnprintf(buffer + len, LPFC_CGN_BUF_SIZE - len,
5512 "%08x %08x %08x %08x\n",
5513 *ptr, *(ptr + 1), *(ptr + 2), *(ptr + 3));
5514 out:
5515 return simple_read_from_buffer(buf, nbytes, ppos, buffer, len);
5516 }
5517
5518 static int
5519 lpfc_cgn_buffer_release(struct inode *inode, struct file *file)
5520 {
5521 struct lpfc_debug *debug = file->private_data;
5522
5523 vfree(debug->buffer);
5524 kfree(debug);
5525
5526 return 0;
5527 }
5528
5529 static int
5530 lpfc_rx_monitor_open(struct inode *inode, struct file *file)
5531 {
5532 struct lpfc_rx_monitor_debug *debug;
5533 int rc = -ENOMEM;
5534
5535 debug = kmalloc(sizeof(*debug), GFP_KERNEL);
5536 if (!debug)
5537 goto out;
5538
5539 debug->buffer = vmalloc(MAX_DEBUGFS_RX_INFO_SIZE);
5540 if (!debug->buffer) {
5541 kfree(debug);
5542 goto out;
5543 }
5544
5545 debug->i_private = inode->i_private;
5546 file->private_data = debug;
5547
5548 rc = 0;
5549 out:
5550 return rc;
5551 }
5552
5553 static ssize_t
5554 lpfc_rx_monitor_read(struct file *file, char __user *buf, size_t nbytes,
5555 loff_t *ppos)
5556 {
5557 struct lpfc_rx_monitor_debug *debug = file->private_data;
5558 struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
5559 char *buffer = debug->buffer;
5560
5561 if (!phba->rx_monitor) {
5562 scnprintf(buffer, MAX_DEBUGFS_RX_INFO_SIZE,
5563 "Rx Monitor Info is empty.\n");
5564 } else {
5565 lpfc_rx_monitor_report(phba, phba->rx_monitor, buffer,
5566 MAX_DEBUGFS_RX_INFO_SIZE,
5567 LPFC_MAX_RXMONITOR_ENTRY);
5568 }
5569
5570 return simple_read_from_buffer(buf, nbytes, ppos, buffer,
5571 strlen(buffer));
5572 }
5573
5574 static int
5575 lpfc_rx_monitor_release(struct inode *inode, struct file *file)
5576 {
5577 struct lpfc_rx_monitor_debug *debug = file->private_data;
5578
5579 vfree(debug->buffer);
5580 kfree(debug);
5581
5582 return 0;
5583 }
5584
5585 #undef lpfc_debugfs_op_disc_trc
5586 static const struct file_operations lpfc_debugfs_op_disc_trc = {
5587 .owner = THIS_MODULE,
5588 .open = lpfc_debugfs_disc_trc_open,
5589 .llseek = lpfc_debugfs_lseek,
5590 .read = lpfc_debugfs_read,
5591 .release = lpfc_debugfs_release,
5592 };
5593
5594 #undef lpfc_debugfs_op_nodelist
5595 static const struct file_operations lpfc_debugfs_op_nodelist = {
5596 .owner = THIS_MODULE,
5597 .open = lpfc_debugfs_nodelist_open,
5598 .llseek = lpfc_debugfs_lseek,
5599 .read = lpfc_debugfs_read,
5600 .release = lpfc_debugfs_release,
5601 };
5602
5603 #undef lpfc_debugfs_op_multixripools
5604 static const struct file_operations lpfc_debugfs_op_multixripools = {
5605 .owner = THIS_MODULE,
5606 .open = lpfc_debugfs_multixripools_open,
5607 .llseek = lpfc_debugfs_lseek,
5608 .read = lpfc_debugfs_read,
5609 .write = lpfc_debugfs_multixripools_write,
5610 .release = lpfc_debugfs_release,
5611 };
5612
5613 #undef lpfc_debugfs_op_hbqinfo
5614 static const struct file_operations lpfc_debugfs_op_hbqinfo = {
5615 .owner = THIS_MODULE,
5616 .open = lpfc_debugfs_hbqinfo_open,
5617 .llseek = lpfc_debugfs_lseek,
5618 .read = lpfc_debugfs_read,
5619 .release = lpfc_debugfs_release,
5620 };
5621
5622 #ifdef LPFC_HDWQ_LOCK_STAT
5623 #undef lpfc_debugfs_op_lockstat
5624 static const struct file_operations lpfc_debugfs_op_lockstat = {
5625 .owner = THIS_MODULE,
5626 .open = lpfc_debugfs_lockstat_open,
5627 .llseek = lpfc_debugfs_lseek,
5628 .read = lpfc_debugfs_read,
5629 .write = lpfc_debugfs_lockstat_write,
5630 .release = lpfc_debugfs_release,
5631 };
5632 #endif
5633
5634 #undef lpfc_debugfs_ras_log
5635 static const struct file_operations lpfc_debugfs_ras_log = {
5636 .owner = THIS_MODULE,
5637 .open = lpfc_debugfs_ras_log_open,
5638 .llseek = lpfc_debugfs_lseek,
5639 .read = lpfc_debugfs_read,
5640 .release = lpfc_debugfs_ras_log_release,
5641 };
5642
5643 #undef lpfc_debugfs_op_dumpHBASlim
5644 static const struct file_operations lpfc_debugfs_op_dumpHBASlim = {
5645 .owner = THIS_MODULE,
5646 .open = lpfc_debugfs_dumpHBASlim_open,
5647 .llseek = lpfc_debugfs_lseek,
5648 .read = lpfc_debugfs_read,
5649 .release = lpfc_debugfs_release,
5650 };
5651
5652 #undef lpfc_debugfs_op_dumpHostSlim
5653 static const struct file_operations lpfc_debugfs_op_dumpHostSlim = {
5654 .owner = THIS_MODULE,
5655 .open = lpfc_debugfs_dumpHostSlim_open,
5656 .llseek = lpfc_debugfs_lseek,
5657 .read = lpfc_debugfs_read,
5658 .release = lpfc_debugfs_release,
5659 };
5660
5661 #undef lpfc_debugfs_op_nvmestat
5662 static const struct file_operations lpfc_debugfs_op_nvmestat = {
5663 .owner = THIS_MODULE,
5664 .open = lpfc_debugfs_nvmestat_open,
5665 .llseek = lpfc_debugfs_lseek,
5666 .read = lpfc_debugfs_read,
5667 .write = lpfc_debugfs_nvmestat_write,
5668 .release = lpfc_debugfs_release,
5669 };
5670
5671 #undef lpfc_debugfs_op_scsistat
5672 static const struct file_operations lpfc_debugfs_op_scsistat = {
5673 .owner = THIS_MODULE,
5674 .open = lpfc_debugfs_scsistat_open,
5675 .llseek = lpfc_debugfs_lseek,
5676 .read = lpfc_debugfs_read,
5677 .write = lpfc_debugfs_scsistat_write,
5678 .release = lpfc_debugfs_release,
5679 };
5680
5681 #undef lpfc_debugfs_op_ioktime
5682 static const struct file_operations lpfc_debugfs_op_ioktime = {
5683 .owner = THIS_MODULE,
5684 .open = lpfc_debugfs_ioktime_open,
5685 .llseek = lpfc_debugfs_lseek,
5686 .read = lpfc_debugfs_read,
5687 .write = lpfc_debugfs_ioktime_write,
5688 .release = lpfc_debugfs_release,
5689 };
5690
5691 #undef lpfc_debugfs_op_nvmeio_trc
5692 static const struct file_operations lpfc_debugfs_op_nvmeio_trc = {
5693 .owner = THIS_MODULE,
5694 .open = lpfc_debugfs_nvmeio_trc_open,
5695 .llseek = lpfc_debugfs_lseek,
5696 .read = lpfc_debugfs_read,
5697 .write = lpfc_debugfs_nvmeio_trc_write,
5698 .release = lpfc_debugfs_release,
5699 };
5700
5701 #undef lpfc_debugfs_op_hdwqstat
5702 static const struct file_operations lpfc_debugfs_op_hdwqstat = {
5703 .owner = THIS_MODULE,
5704 .open = lpfc_debugfs_hdwqstat_open,
5705 .llseek = lpfc_debugfs_lseek,
5706 .read = lpfc_debugfs_read,
5707 .write = lpfc_debugfs_hdwqstat_write,
5708 .release = lpfc_debugfs_release,
5709 };
5710
5711 #undef lpfc_debugfs_op_dif_err
5712 static const struct file_operations lpfc_debugfs_op_dif_err = {
5713 .owner = THIS_MODULE,
5714 .open = simple_open,
5715 .llseek = lpfc_debugfs_lseek,
5716 .read = lpfc_debugfs_dif_err_read,
5717 .write = lpfc_debugfs_dif_err_write,
5718 .release = lpfc_debugfs_dif_err_release,
5719 };
5720
5721 #undef lpfc_debugfs_op_slow_ring_trc
5722 static const struct file_operations lpfc_debugfs_op_slow_ring_trc = {
5723 .owner = THIS_MODULE,
5724 .open = lpfc_debugfs_slow_ring_trc_open,
5725 .llseek = lpfc_debugfs_lseek,
5726 .read = lpfc_debugfs_read,
5727 .release = lpfc_debugfs_release,
5728 };
5729
5730 static struct dentry *lpfc_debugfs_root = NULL;
5731 static atomic_t lpfc_debugfs_hba_count;
5732
5733 /*
5734 * File operations for the iDiag debugfs
5735 */
5736 #undef lpfc_idiag_op_pciCfg
5737 static const struct file_operations lpfc_idiag_op_pciCfg = {
5738 .owner = THIS_MODULE,
5739 .open = lpfc_idiag_open,
5740 .llseek = lpfc_debugfs_lseek,
5741 .read = lpfc_idiag_pcicfg_read,
5742 .write = lpfc_idiag_pcicfg_write,
5743 .release = lpfc_idiag_cmd_release,
5744 };
5745
5746 #undef lpfc_idiag_op_barAcc
5747 static const struct file_operations lpfc_idiag_op_barAcc = {
5748 .owner = THIS_MODULE,
5749 .open = lpfc_idiag_open,
5750 .llseek = lpfc_debugfs_lseek,
5751 .read = lpfc_idiag_baracc_read,
5752 .write = lpfc_idiag_baracc_write,
5753 .release = lpfc_idiag_cmd_release,
5754 };
5755
5756 #undef lpfc_idiag_op_queInfo
5757 static const struct file_operations lpfc_idiag_op_queInfo = {
5758 .owner = THIS_MODULE,
5759 .open = lpfc_idiag_open,
5760 .read = lpfc_idiag_queinfo_read,
5761 .release = lpfc_idiag_release,
5762 };
5763
5764 #undef lpfc_idiag_op_queAcc
5765 static const struct file_operations lpfc_idiag_op_queAcc = {
5766 .owner = THIS_MODULE,
5767 .open = lpfc_idiag_open,
5768 .llseek = lpfc_debugfs_lseek,
5769 .read = lpfc_idiag_queacc_read,
5770 .write = lpfc_idiag_queacc_write,
5771 .release = lpfc_idiag_cmd_release,
5772 };
5773
5774 #undef lpfc_idiag_op_drbAcc
5775 static const struct file_operations lpfc_idiag_op_drbAcc = {
5776 .owner = THIS_MODULE,
5777 .open = lpfc_idiag_open,
5778 .llseek = lpfc_debugfs_lseek,
5779 .read = lpfc_idiag_drbacc_read,
5780 .write = lpfc_idiag_drbacc_write,
5781 .release = lpfc_idiag_cmd_release,
5782 };
5783
5784 #undef lpfc_idiag_op_ctlAcc
5785 static const struct file_operations lpfc_idiag_op_ctlAcc = {
5786 .owner = THIS_MODULE,
5787 .open = lpfc_idiag_open,
5788 .llseek = lpfc_debugfs_lseek,
5789 .read = lpfc_idiag_ctlacc_read,
5790 .write = lpfc_idiag_ctlacc_write,
5791 .release = lpfc_idiag_cmd_release,
5792 };
5793
5794 #undef lpfc_idiag_op_mbxAcc
5795 static const struct file_operations lpfc_idiag_op_mbxAcc = {
5796 .owner = THIS_MODULE,
5797 .open = lpfc_idiag_open,
5798 .llseek = lpfc_debugfs_lseek,
5799 .read = lpfc_idiag_mbxacc_read,
5800 .write = lpfc_idiag_mbxacc_write,
5801 .release = lpfc_idiag_cmd_release,
5802 };
5803
5804 #undef lpfc_idiag_op_extAcc
5805 static const struct file_operations lpfc_idiag_op_extAcc = {
5806 .owner = THIS_MODULE,
5807 .open = lpfc_idiag_open,
5808 .llseek = lpfc_debugfs_lseek,
5809 .read = lpfc_idiag_extacc_read,
5810 .write = lpfc_idiag_extacc_write,
5811 .release = lpfc_idiag_cmd_release,
5812 };
5813 #undef lpfc_cgn_buffer_op
5814 static const struct file_operations lpfc_cgn_buffer_op = {
5815 .owner = THIS_MODULE,
5816 .open = lpfc_cgn_buffer_open,
5817 .llseek = lpfc_debugfs_lseek,
5818 .read = lpfc_cgn_buffer_read,
5819 .release = lpfc_cgn_buffer_release,
5820 };
5821
5822 #undef lpfc_rx_monitor_op
5823 static const struct file_operations lpfc_rx_monitor_op = {
5824 .owner = THIS_MODULE,
5825 .open = lpfc_rx_monitor_open,
5826 .llseek = lpfc_debugfs_lseek,
5827 .read = lpfc_rx_monitor_read,
5828 .release = lpfc_rx_monitor_release,
5829 };
5830 #endif
5831
5832 /* lpfc_idiag_mbxacc_dump_bsg_mbox - idiag debugfs dump bsg mailbox command
5833 * @phba: Pointer to HBA context object.
5834 * @dmabuf: Pointer to a DMA buffer descriptor.
5835 *
5836 * Description:
5837 * This routine dump a bsg pass-through non-embedded mailbox command with
5838 * external buffer.
5839 **/
5840 void
5841 lpfc_idiag_mbxacc_dump_bsg_mbox(struct lpfc_hba *phba, enum nemb_type nemb_tp,
5842 enum mbox_type mbox_tp, enum dma_type dma_tp,
5843 enum sta_type sta_tp,
5844 struct lpfc_dmabuf *dmabuf, uint32_t ext_buf)
5845 {
5846 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
5847 uint32_t *mbx_mbox_cmd, *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt;
5848 char line_buf[LPFC_MBX_ACC_LBUF_SZ];
5849 int len = 0;
5850 uint32_t do_dump = 0;
5851 uint32_t *pword;
5852 uint32_t i;
5853
5854 if (idiag.cmd.opcode != LPFC_IDIAG_BSG_MBXACC_DP)
5855 return;
5856
5857 mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5858 mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5859 mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5860 mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5861
5862 if (!(*mbx_dump_map & LPFC_MBX_DMP_ALL) ||
5863 (*mbx_dump_cnt == 0) ||
5864 (*mbx_word_cnt == 0))
5865 return;
5866
5867 if (*mbx_mbox_cmd != 0x9B)
5868 return;
5869
5870 if ((mbox_tp == mbox_rd) && (dma_tp == dma_mbox)) {
5871 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_MBX) {
5872 do_dump |= LPFC_BSG_DMP_MBX_RD_MBX;
5873 pr_err("\nRead mbox command (x%x), "
5874 "nemb:0x%x, extbuf_cnt:%d:\n",
5875 sta_tp, nemb_tp, ext_buf);
5876 }
5877 }
5878 if ((mbox_tp == mbox_rd) && (dma_tp == dma_ebuf)) {
5879 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_RD_BUF) {
5880 do_dump |= LPFC_BSG_DMP_MBX_RD_BUF;
5881 pr_err("\nRead mbox buffer (x%x), "
5882 "nemb:0x%x, extbuf_seq:%d:\n",
5883 sta_tp, nemb_tp, ext_buf);
5884 }
5885 }
5886 if ((mbox_tp == mbox_wr) && (dma_tp == dma_mbox)) {
5887 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_MBX) {
5888 do_dump |= LPFC_BSG_DMP_MBX_WR_MBX;
5889 pr_err("\nWrite mbox command (x%x), "
5890 "nemb:0x%x, extbuf_cnt:%d:\n",
5891 sta_tp, nemb_tp, ext_buf);
5892 }
5893 }
5894 if ((mbox_tp == mbox_wr) && (dma_tp == dma_ebuf)) {
5895 if (*mbx_dump_map & LPFC_BSG_DMP_MBX_WR_BUF) {
5896 do_dump |= LPFC_BSG_DMP_MBX_WR_BUF;
5897 pr_err("\nWrite mbox buffer (x%x), "
5898 "nemb:0x%x, extbuf_seq:%d:\n",
5899 sta_tp, nemb_tp, ext_buf);
5900 }
5901 }
5902
5903 /* dump buffer content */
5904 if (do_dump) {
5905 pword = (uint32_t *)dmabuf->virt;
5906 for (i = 0; i < *mbx_word_cnt; i++) {
5907 if (!(i % 8)) {
5908 if (i != 0)
5909 pr_err("%s\n", line_buf);
5910 len = 0;
5911 len += scnprintf(line_buf+len,
5912 LPFC_MBX_ACC_LBUF_SZ-len,
5913 "%03d: ", i);
5914 }
5915 len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
5916 "%08x ", (uint32_t)*pword);
5917 pword++;
5918 }
5919 if ((i - 1) % 8)
5920 pr_err("%s\n", line_buf);
5921 (*mbx_dump_cnt)--;
5922 }
5923
5924 /* Clean out command structure on reaching dump count */
5925 if (*mbx_dump_cnt == 0)
5926 memset(&idiag, 0, sizeof(idiag));
5927 return;
5928 #endif
5929 }
5930
5931 /* lpfc_idiag_mbxacc_dump_issue_mbox - idiag debugfs dump issue mailbox command
5932 * @phba: Pointer to HBA context object.
5933 * @dmabuf: Pointer to a DMA buffer descriptor.
5934 *
5935 * Description:
5936 * This routine dump a pass-through non-embedded mailbox command from issue
5937 * mailbox command.
5938 **/
5939 void
5940 lpfc_idiag_mbxacc_dump_issue_mbox(struct lpfc_hba *phba, MAILBOX_t *pmbox)
5941 {
5942 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
5943 uint32_t *mbx_dump_map, *mbx_dump_cnt, *mbx_word_cnt, *mbx_mbox_cmd;
5944 char line_buf[LPFC_MBX_ACC_LBUF_SZ];
5945 int len = 0;
5946 uint32_t *pword;
5947 uint8_t *pbyte;
5948 uint32_t i, j;
5949
5950 if (idiag.cmd.opcode != LPFC_IDIAG_CMD_MBXACC_DP)
5951 return;
5952
5953 mbx_mbox_cmd = &idiag.cmd.data[IDIAG_MBXACC_MBCMD_INDX];
5954 mbx_dump_map = &idiag.cmd.data[IDIAG_MBXACC_DPMAP_INDX];
5955 mbx_dump_cnt = &idiag.cmd.data[IDIAG_MBXACC_DPCNT_INDX];
5956 mbx_word_cnt = &idiag.cmd.data[IDIAG_MBXACC_WDCNT_INDX];
5957
5958 if (!(*mbx_dump_map & LPFC_MBX_DMP_MBX_ALL) ||
5959 (*mbx_dump_cnt == 0) ||
5960 (*mbx_word_cnt == 0))
5961 return;
5962
5963 if ((*mbx_mbox_cmd != LPFC_MBX_ALL_CMD) &&
5964 (*mbx_mbox_cmd != pmbox->mbxCommand))
5965 return;
5966
5967 /* dump buffer content */
5968 if (*mbx_dump_map & LPFC_MBX_DMP_MBX_WORD) {
5969 pr_err("Mailbox command:0x%x dump by word:\n",
5970 pmbox->mbxCommand);
5971 pword = (uint32_t *)pmbox;
5972 for (i = 0; i < *mbx_word_cnt; i++) {
5973 if (!(i % 8)) {
5974 if (i != 0)
5975 pr_err("%s\n", line_buf);
5976 len = 0;
5977 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
5978 len += scnprintf(line_buf+len,
5979 LPFC_MBX_ACC_LBUF_SZ-len,
5980 "%03d: ", i);
5981 }
5982 len += scnprintf(line_buf+len, LPFC_MBX_ACC_LBUF_SZ-len,
5983 "%08x ",
5984 ((uint32_t)*pword) & 0xffffffff);
5985 pword++;
5986 }
5987 if ((i - 1) % 8)
5988 pr_err("%s\n", line_buf);
5989 pr_err("\n");
5990 }
5991 if (*mbx_dump_map & LPFC_MBX_DMP_MBX_BYTE) {
5992 pr_err("Mailbox command:0x%x dump by byte:\n",
5993 pmbox->mbxCommand);
5994 pbyte = (uint8_t *)pmbox;
5995 for (i = 0; i < *mbx_word_cnt; i++) {
5996 if (!(i % 8)) {
5997 if (i != 0)
5998 pr_err("%s\n", line_buf);
5999 len = 0;
6000 memset(line_buf, 0, LPFC_MBX_ACC_LBUF_SZ);
6001 len += scnprintf(line_buf+len,
6002 LPFC_MBX_ACC_LBUF_SZ-len,
6003 "%03d: ", i);
6004 }
6005 for (j = 0; j < 4; j++) {
6006 len += scnprintf(line_buf+len,
6007 LPFC_MBX_ACC_LBUF_SZ-len,
6008 "%02x",
6009 ((uint8_t)*pbyte) & 0xff);
6010 pbyte++;
6011 }
6012 len += scnprintf(line_buf+len,
6013 LPFC_MBX_ACC_LBUF_SZ-len, " ");
6014 }
6015 if ((i - 1) % 8)
6016 pr_err("%s\n", line_buf);
6017 pr_err("\n");
6018 }
6019 (*mbx_dump_cnt)--;
6020
6021 /* Clean out command structure on reaching dump count */
6022 if (*mbx_dump_cnt == 0)
6023 memset(&idiag, 0, sizeof(idiag));
6024 return;
6025 #endif
6026 }
6027
6028 /**
6029 * lpfc_debugfs_initialize - Initialize debugfs for a vport
6030 * @vport: The vport pointer to initialize.
6031 *
6032 * Description:
6033 * When Debugfs is configured this routine sets up the lpfc debugfs file system.
6034 * If not already created, this routine will create the lpfc directory, and
6035 * lpfcX directory (for this HBA), and vportX directory for this vport. It will
6036 * also create each file used to access lpfc specific debugfs information.
6037 **/
6038 inline void
6039 lpfc_debugfs_initialize(struct lpfc_vport *vport)
6040 {
6041 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
6042 struct lpfc_hba *phba = vport->phba;
6043 char name[64];
6044 uint32_t num, i;
6045 bool pport_setup = false;
6046
6047 if (!lpfc_debugfs_enable)
6048 return;
6049
6050 /* Setup lpfc root directory */
6051 if (!lpfc_debugfs_root) {
6052 lpfc_debugfs_root = debugfs_create_dir("lpfc", NULL);
6053 atomic_set(&lpfc_debugfs_hba_count, 0);
6054 }
6055 if (!lpfc_debugfs_start_time)
6056 lpfc_debugfs_start_time = jiffies;
6057
6058 /* Setup funcX directory for specific HBA PCI function */
6059 snprintf(name, sizeof(name), "fn%d", phba->brd_no);
6060 if (!phba->hba_debugfs_root) {
6061 pport_setup = true;
6062 phba->hba_debugfs_root =
6063 debugfs_create_dir(name, lpfc_debugfs_root);
6064 atomic_inc(&lpfc_debugfs_hba_count);
6065 atomic_set(&phba->debugfs_vport_count, 0);
6066
6067 /* Multi-XRI pools */
6068 snprintf(name, sizeof(name), "multixripools");
6069 phba->debug_multixri_pools =
6070 debugfs_create_file(name, S_IFREG | 0644,
6071 phba->hba_debugfs_root,
6072 phba,
6073 &lpfc_debugfs_op_multixripools);
6074 if (IS_ERR(phba->debug_multixri_pools)) {
6075 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6076 "0527 Cannot create debugfs multixripools\n");
6077 goto debug_failed;
6078 }
6079
6080 /* Congestion Info Buffer */
6081 scnprintf(name, sizeof(name), "cgn_buffer");
6082 phba->debug_cgn_buffer =
6083 debugfs_create_file(name, S_IFREG | 0644,
6084 phba->hba_debugfs_root,
6085 phba, &lpfc_cgn_buffer_op);
6086 if (IS_ERR(phba->debug_cgn_buffer)) {
6087 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6088 "6527 Cannot create debugfs "
6089 "cgn_buffer\n");
6090 goto debug_failed;
6091 }
6092
6093 /* RX Monitor */
6094 scnprintf(name, sizeof(name), "rx_monitor");
6095 phba->debug_rx_monitor =
6096 debugfs_create_file(name, S_IFREG | 0644,
6097 phba->hba_debugfs_root,
6098 phba, &lpfc_rx_monitor_op);
6099 if (IS_ERR(phba->debug_rx_monitor)) {
6100 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6101 "6528 Cannot create debugfs "
6102 "rx_monitor\n");
6103 goto debug_failed;
6104 }
6105
6106 /* RAS log */
6107 snprintf(name, sizeof(name), "ras_log");
6108 phba->debug_ras_log =
6109 debugfs_create_file(name, 0644,
6110 phba->hba_debugfs_root,
6111 phba, &lpfc_debugfs_ras_log);
6112 if (IS_ERR(phba->debug_ras_log)) {
6113 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6114 "6148 Cannot create debugfs"
6115 " ras_log\n");
6116 goto debug_failed;
6117 }
6118
6119 /* Setup hbqinfo */
6120 snprintf(name, sizeof(name), "hbqinfo");
6121 phba->debug_hbqinfo =
6122 debugfs_create_file(name, S_IFREG | 0644,
6123 phba->hba_debugfs_root,
6124 phba, &lpfc_debugfs_op_hbqinfo);
6125
6126 #ifdef LPFC_HDWQ_LOCK_STAT
6127 /* Setup lockstat */
6128 snprintf(name, sizeof(name), "lockstat");
6129 phba->debug_lockstat =
6130 debugfs_create_file(name, S_IFREG | 0644,
6131 phba->hba_debugfs_root,
6132 phba, &lpfc_debugfs_op_lockstat);
6133 if (IS_ERR(phba->debug_lockstat)) {
6134 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6135 "4610 Can't create debugfs lockstat\n");
6136 goto debug_failed;
6137 }
6138 #endif
6139
6140 /* Setup dumpHBASlim */
6141 if (phba->sli_rev < LPFC_SLI_REV4) {
6142 snprintf(name, sizeof(name), "dumpHBASlim");
6143 phba->debug_dumpHBASlim =
6144 debugfs_create_file(name,
6145 S_IFREG|S_IRUGO|S_IWUSR,
6146 phba->hba_debugfs_root,
6147 phba, &lpfc_debugfs_op_dumpHBASlim);
6148 } else
6149 phba->debug_dumpHBASlim = NULL;
6150
6151 /* Setup dumpHostSlim */
6152 if (phba->sli_rev < LPFC_SLI_REV4) {
6153 snprintf(name, sizeof(name), "dumpHostSlim");
6154 phba->debug_dumpHostSlim =
6155 debugfs_create_file(name,
6156 S_IFREG|S_IRUGO|S_IWUSR,
6157 phba->hba_debugfs_root,
6158 phba, &lpfc_debugfs_op_dumpHostSlim);
6159 } else
6160 phba->debug_dumpHostSlim = NULL;
6161
6162 /* Setup DIF Error Injections */
6163 snprintf(name, sizeof(name), "InjErrLBA");
6164 phba->debug_InjErrLBA =
6165 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6166 phba->hba_debugfs_root,
6167 phba, &lpfc_debugfs_op_dif_err);
6168 phba->lpfc_injerr_lba = LPFC_INJERR_LBA_OFF;
6169
6170 snprintf(name, sizeof(name), "InjErrNPortID");
6171 phba->debug_InjErrNPortID =
6172 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6173 phba->hba_debugfs_root,
6174 phba, &lpfc_debugfs_op_dif_err);
6175
6176 snprintf(name, sizeof(name), "InjErrWWPN");
6177 phba->debug_InjErrWWPN =
6178 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6179 phba->hba_debugfs_root,
6180 phba, &lpfc_debugfs_op_dif_err);
6181
6182 snprintf(name, sizeof(name), "writeGuardInjErr");
6183 phba->debug_writeGuard =
6184 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6185 phba->hba_debugfs_root,
6186 phba, &lpfc_debugfs_op_dif_err);
6187
6188 snprintf(name, sizeof(name), "writeAppInjErr");
6189 phba->debug_writeApp =
6190 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6191 phba->hba_debugfs_root,
6192 phba, &lpfc_debugfs_op_dif_err);
6193
6194 snprintf(name, sizeof(name), "writeRefInjErr");
6195 phba->debug_writeRef =
6196 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6197 phba->hba_debugfs_root,
6198 phba, &lpfc_debugfs_op_dif_err);
6199
6200 snprintf(name, sizeof(name), "readGuardInjErr");
6201 phba->debug_readGuard =
6202 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6203 phba->hba_debugfs_root,
6204 phba, &lpfc_debugfs_op_dif_err);
6205
6206 snprintf(name, sizeof(name), "readAppInjErr");
6207 phba->debug_readApp =
6208 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6209 phba->hba_debugfs_root,
6210 phba, &lpfc_debugfs_op_dif_err);
6211
6212 snprintf(name, sizeof(name), "readRefInjErr");
6213 phba->debug_readRef =
6214 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6215 phba->hba_debugfs_root,
6216 phba, &lpfc_debugfs_op_dif_err);
6217
6218 /* Setup slow ring trace */
6219 if (lpfc_debugfs_max_slow_ring_trc) {
6220 num = lpfc_debugfs_max_slow_ring_trc - 1;
6221 if (num & lpfc_debugfs_max_slow_ring_trc) {
6222 /* Change to be a power of 2 */
6223 num = lpfc_debugfs_max_slow_ring_trc;
6224 i = 0;
6225 while (num > 1) {
6226 num = num >> 1;
6227 i++;
6228 }
6229 lpfc_debugfs_max_slow_ring_trc = (1 << i);
6230 pr_err("lpfc_debugfs_max_disc_trc changed to "
6231 "%d\n", lpfc_debugfs_max_disc_trc);
6232 }
6233 }
6234
6235 snprintf(name, sizeof(name), "slow_ring_trace");
6236 phba->debug_slow_ring_trc =
6237 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6238 phba->hba_debugfs_root,
6239 phba, &lpfc_debugfs_op_slow_ring_trc);
6240 if (!phba->slow_ring_trc) {
6241 phba->slow_ring_trc = kcalloc(
6242 lpfc_debugfs_max_slow_ring_trc,
6243 sizeof(struct lpfc_debugfs_trc),
6244 GFP_KERNEL);
6245 if (!phba->slow_ring_trc) {
6246 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6247 "0416 Cannot create debugfs "
6248 "slow_ring buffer\n");
6249 goto debug_failed;
6250 }
6251 atomic_set(&phba->slow_ring_trc_cnt, 0);
6252 }
6253
6254 snprintf(name, sizeof(name), "nvmeio_trc");
6255 phba->debug_nvmeio_trc =
6256 debugfs_create_file(name, 0644,
6257 phba->hba_debugfs_root,
6258 phba, &lpfc_debugfs_op_nvmeio_trc);
6259
6260 atomic_set(&phba->nvmeio_trc_cnt, 0);
6261 if (lpfc_debugfs_max_nvmeio_trc) {
6262 num = lpfc_debugfs_max_nvmeio_trc - 1;
6263 if (num & lpfc_debugfs_max_disc_trc) {
6264 /* Change to be a power of 2 */
6265 num = lpfc_debugfs_max_nvmeio_trc;
6266 i = 0;
6267 while (num > 1) {
6268 num = num >> 1;
6269 i++;
6270 }
6271 lpfc_debugfs_max_nvmeio_trc = (1 << i);
6272 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6273 "0575 lpfc_debugfs_max_nvmeio_trc "
6274 "changed to %d\n",
6275 lpfc_debugfs_max_nvmeio_trc);
6276 }
6277 phba->nvmeio_trc_size = lpfc_debugfs_max_nvmeio_trc;
6278
6279 /* Allocate trace buffer and initialize */
6280 phba->nvmeio_trc = kzalloc(
6281 (sizeof(struct lpfc_debugfs_nvmeio_trc) *
6282 phba->nvmeio_trc_size), GFP_KERNEL);
6283
6284 if (!phba->nvmeio_trc) {
6285 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6286 "0576 Cannot create debugfs "
6287 "nvmeio_trc buffer\n");
6288 goto nvmeio_off;
6289 }
6290 phba->nvmeio_trc_on = 1;
6291 phba->nvmeio_trc_output_idx = 0;
6292 phba->nvmeio_trc = NULL;
6293 } else {
6294 nvmeio_off:
6295 phba->nvmeio_trc_size = 0;
6296 phba->nvmeio_trc_on = 0;
6297 phba->nvmeio_trc_output_idx = 0;
6298 phba->nvmeio_trc = NULL;
6299 }
6300 }
6301
6302 snprintf(name, sizeof(name), "vport%d", vport->vpi);
6303 if (!vport->vport_debugfs_root) {
6304 vport->vport_debugfs_root =
6305 debugfs_create_dir(name, phba->hba_debugfs_root);
6306 atomic_inc(&phba->debugfs_vport_count);
6307 }
6308
6309 if (lpfc_debugfs_max_disc_trc) {
6310 num = lpfc_debugfs_max_disc_trc - 1;
6311 if (num & lpfc_debugfs_max_disc_trc) {
6312 /* Change to be a power of 2 */
6313 num = lpfc_debugfs_max_disc_trc;
6314 i = 0;
6315 while (num > 1) {
6316 num = num >> 1;
6317 i++;
6318 }
6319 lpfc_debugfs_max_disc_trc = (1 << i);
6320 pr_err("lpfc_debugfs_max_disc_trc changed to %d\n",
6321 lpfc_debugfs_max_disc_trc);
6322 }
6323 }
6324
6325 vport->disc_trc = kzalloc(
6326 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
6327 GFP_KERNEL);
6328
6329 if (!vport->disc_trc) {
6330 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6331 "0418 Cannot create debugfs disc trace "
6332 "buffer\n");
6333 goto debug_failed;
6334 }
6335 atomic_set(&vport->disc_trc_cnt, 0);
6336
6337 snprintf(name, sizeof(name), "discovery_trace");
6338 vport->debug_disc_trc =
6339 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6340 vport->vport_debugfs_root,
6341 vport, &lpfc_debugfs_op_disc_trc);
6342 snprintf(name, sizeof(name), "nodelist");
6343 vport->debug_nodelist =
6344 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6345 vport->vport_debugfs_root,
6346 vport, &lpfc_debugfs_op_nodelist);
6347
6348 snprintf(name, sizeof(name), "nvmestat");
6349 vport->debug_nvmestat =
6350 debugfs_create_file(name, 0644,
6351 vport->vport_debugfs_root,
6352 vport, &lpfc_debugfs_op_nvmestat);
6353
6354 snprintf(name, sizeof(name), "scsistat");
6355 vport->debug_scsistat =
6356 debugfs_create_file(name, 0644,
6357 vport->vport_debugfs_root,
6358 vport, &lpfc_debugfs_op_scsistat);
6359 if (IS_ERR(vport->debug_scsistat)) {
6360 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6361 "4611 Cannot create debugfs scsistat\n");
6362 goto debug_failed;
6363 }
6364
6365 snprintf(name, sizeof(name), "ioktime");
6366 vport->debug_ioktime =
6367 debugfs_create_file(name, 0644,
6368 vport->vport_debugfs_root,
6369 vport, &lpfc_debugfs_op_ioktime);
6370 if (IS_ERR(vport->debug_ioktime)) {
6371 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
6372 "0815 Cannot create debugfs ioktime\n");
6373 goto debug_failed;
6374 }
6375
6376 snprintf(name, sizeof(name), "hdwqstat");
6377 vport->debug_hdwqstat =
6378 debugfs_create_file(name, 0644,
6379 vport->vport_debugfs_root,
6380 vport, &lpfc_debugfs_op_hdwqstat);
6381
6382 /*
6383 * The following section is for additional directories/files for the
6384 * physical port.
6385 */
6386
6387 if (!pport_setup)
6388 goto debug_failed;
6389
6390 /*
6391 * iDiag debugfs root entry points for SLI4 device only
6392 */
6393 if (phba->sli_rev < LPFC_SLI_REV4)
6394 goto debug_failed;
6395
6396 snprintf(name, sizeof(name), "iDiag");
6397 if (!phba->idiag_root) {
6398 phba->idiag_root =
6399 debugfs_create_dir(name, phba->hba_debugfs_root);
6400 /* Initialize iDiag data structure */
6401 memset(&idiag, 0, sizeof(idiag));
6402 }
6403
6404 /* iDiag read PCI config space */
6405 snprintf(name, sizeof(name), "pciCfg");
6406 if (!phba->idiag_pci_cfg) {
6407 phba->idiag_pci_cfg =
6408 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6409 phba->idiag_root, phba, &lpfc_idiag_op_pciCfg);
6410 idiag.offset.last_rd = 0;
6411 }
6412
6413 /* iDiag PCI BAR access */
6414 snprintf(name, sizeof(name), "barAcc");
6415 if (!phba->idiag_bar_acc) {
6416 phba->idiag_bar_acc =
6417 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6418 phba->idiag_root, phba, &lpfc_idiag_op_barAcc);
6419 idiag.offset.last_rd = 0;
6420 }
6421
6422 /* iDiag get PCI function queue information */
6423 snprintf(name, sizeof(name), "queInfo");
6424 if (!phba->idiag_que_info) {
6425 phba->idiag_que_info =
6426 debugfs_create_file(name, S_IFREG|S_IRUGO,
6427 phba->idiag_root, phba, &lpfc_idiag_op_queInfo);
6428 }
6429
6430 /* iDiag access PCI function queue */
6431 snprintf(name, sizeof(name), "queAcc");
6432 if (!phba->idiag_que_acc) {
6433 phba->idiag_que_acc =
6434 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6435 phba->idiag_root, phba, &lpfc_idiag_op_queAcc);
6436 }
6437
6438 /* iDiag access PCI function doorbell registers */
6439 snprintf(name, sizeof(name), "drbAcc");
6440 if (!phba->idiag_drb_acc) {
6441 phba->idiag_drb_acc =
6442 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6443 phba->idiag_root, phba, &lpfc_idiag_op_drbAcc);
6444 }
6445
6446 /* iDiag access PCI function control registers */
6447 snprintf(name, sizeof(name), "ctlAcc");
6448 if (!phba->idiag_ctl_acc) {
6449 phba->idiag_ctl_acc =
6450 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6451 phba->idiag_root, phba, &lpfc_idiag_op_ctlAcc);
6452 }
6453
6454 /* iDiag access mbox commands */
6455 snprintf(name, sizeof(name), "mbxAcc");
6456 if (!phba->idiag_mbx_acc) {
6457 phba->idiag_mbx_acc =
6458 debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
6459 phba->idiag_root, phba, &lpfc_idiag_op_mbxAcc);
6460 }
6461
6462 /* iDiag extents access commands */
6463 if (phba->sli4_hba.extents_in_use) {
6464 snprintf(name, sizeof(name), "extAcc");
6465 if (!phba->idiag_ext_acc) {
6466 phba->idiag_ext_acc =
6467 debugfs_create_file(name,
6468 S_IFREG|S_IRUGO|S_IWUSR,
6469 phba->idiag_root, phba,
6470 &lpfc_idiag_op_extAcc);
6471 }
6472 }
6473
6474 debug_failed:
6475 return;
6476 #endif
6477 }
6478
6479 /**
6480 * lpfc_debugfs_terminate - Tear down debugfs infrastructure for this vport
6481 * @vport: The vport pointer to remove from debugfs.
6482 *
6483 * Description:
6484 * When Debugfs is configured this routine removes debugfs file system elements
6485 * that are specific to this vport. It also checks to see if there are any
6486 * users left for the debugfs directories associated with the HBA and driver. If
6487 * this is the last user of the HBA directory or driver directory then it will
6488 * remove those from the debugfs infrastructure as well.
6489 **/
6490 inline void
6491 lpfc_debugfs_terminate(struct lpfc_vport *vport)
6492 {
6493 #ifdef CONFIG_SCSI_LPFC_DEBUG_FS
6494 struct lpfc_hba *phba = vport->phba;
6495
6496 kfree(vport->disc_trc);
6497 vport->disc_trc = NULL;
6498
6499 debugfs_remove(vport->debug_disc_trc); /* discovery_trace */
6500 vport->debug_disc_trc = NULL;
6501
6502 debugfs_remove(vport->debug_nodelist); /* nodelist */
6503 vport->debug_nodelist = NULL;
6504
6505 debugfs_remove(vport->debug_nvmestat); /* nvmestat */
6506 vport->debug_nvmestat = NULL;
6507
6508 debugfs_remove(vport->debug_scsistat); /* scsistat */
6509 vport->debug_scsistat = NULL;
6510
6511 debugfs_remove(vport->debug_ioktime); /* ioktime */
6512 vport->debug_ioktime = NULL;
6513
6514 debugfs_remove(vport->debug_hdwqstat); /* hdwqstat */
6515 vport->debug_hdwqstat = NULL;
6516
6517 if (vport->vport_debugfs_root) {
6518 debugfs_remove(vport->vport_debugfs_root); /* vportX */
6519 vport->vport_debugfs_root = NULL;
6520 atomic_dec(&phba->debugfs_vport_count);
6521 }
6522
6523 if (atomic_read(&phba->debugfs_vport_count) == 0) {
6524
6525 debugfs_remove(phba->debug_multixri_pools); /* multixripools*/
6526 phba->debug_multixri_pools = NULL;
6527
6528 debugfs_remove(phba->debug_hbqinfo); /* hbqinfo */
6529 phba->debug_hbqinfo = NULL;
6530
6531 debugfs_remove(phba->debug_cgn_buffer);
6532 phba->debug_cgn_buffer = NULL;
6533
6534 debugfs_remove(phba->debug_rx_monitor);
6535 phba->debug_rx_monitor = NULL;
6536
6537 debugfs_remove(phba->debug_ras_log);
6538 phba->debug_ras_log = NULL;
6539
6540 #ifdef LPFC_HDWQ_LOCK_STAT
6541 debugfs_remove(phba->debug_lockstat); /* lockstat */
6542 phba->debug_lockstat = NULL;
6543 #endif
6544 debugfs_remove(phba->debug_dumpHBASlim); /* HBASlim */
6545 phba->debug_dumpHBASlim = NULL;
6546
6547 debugfs_remove(phba->debug_dumpHostSlim); /* HostSlim */
6548 phba->debug_dumpHostSlim = NULL;
6549
6550 debugfs_remove(phba->debug_InjErrLBA); /* InjErrLBA */
6551 phba->debug_InjErrLBA = NULL;
6552
6553 debugfs_remove(phba->debug_InjErrNPortID);
6554 phba->debug_InjErrNPortID = NULL;
6555
6556 debugfs_remove(phba->debug_InjErrWWPN); /* InjErrWWPN */
6557 phba->debug_InjErrWWPN = NULL;
6558
6559 debugfs_remove(phba->debug_writeGuard); /* writeGuard */
6560 phba->debug_writeGuard = NULL;
6561
6562 debugfs_remove(phba->debug_writeApp); /* writeApp */
6563 phba->debug_writeApp = NULL;
6564
6565 debugfs_remove(phba->debug_writeRef); /* writeRef */
6566 phba->debug_writeRef = NULL;
6567
6568 debugfs_remove(phba->debug_readGuard); /* readGuard */
6569 phba->debug_readGuard = NULL;
6570
6571 debugfs_remove(phba->debug_readApp); /* readApp */
6572 phba->debug_readApp = NULL;
6573
6574 debugfs_remove(phba->debug_readRef); /* readRef */
6575 phba->debug_readRef = NULL;
6576
6577 kfree(phba->slow_ring_trc);
6578 phba->slow_ring_trc = NULL;
6579
6580 /* slow_ring_trace */
6581 debugfs_remove(phba->debug_slow_ring_trc);
6582 phba->debug_slow_ring_trc = NULL;
6583
6584 debugfs_remove(phba->debug_nvmeio_trc);
6585 phba->debug_nvmeio_trc = NULL;
6586
6587 kfree(phba->nvmeio_trc);
6588 phba->nvmeio_trc = NULL;
6589
6590 /*
6591 * iDiag release
6592 */
6593 if (phba->sli_rev == LPFC_SLI_REV4) {
6594 /* iDiag extAcc */
6595 debugfs_remove(phba->idiag_ext_acc);
6596 phba->idiag_ext_acc = NULL;
6597
6598 /* iDiag mbxAcc */
6599 debugfs_remove(phba->idiag_mbx_acc);
6600 phba->idiag_mbx_acc = NULL;
6601
6602 /* iDiag ctlAcc */
6603 debugfs_remove(phba->idiag_ctl_acc);
6604 phba->idiag_ctl_acc = NULL;
6605
6606 /* iDiag drbAcc */
6607 debugfs_remove(phba->idiag_drb_acc);
6608 phba->idiag_drb_acc = NULL;
6609
6610 /* iDiag queAcc */
6611 debugfs_remove(phba->idiag_que_acc);
6612 phba->idiag_que_acc = NULL;
6613
6614 /* iDiag queInfo */
6615 debugfs_remove(phba->idiag_que_info);
6616 phba->idiag_que_info = NULL;
6617
6618 /* iDiag barAcc */
6619 debugfs_remove(phba->idiag_bar_acc);
6620 phba->idiag_bar_acc = NULL;
6621
6622 /* iDiag pciCfg */
6623 debugfs_remove(phba->idiag_pci_cfg);
6624 phba->idiag_pci_cfg = NULL;
6625
6626 /* Finally remove the iDiag debugfs root */
6627 debugfs_remove(phba->idiag_root);
6628 phba->idiag_root = NULL;
6629 }
6630
6631 if (phba->hba_debugfs_root) {
6632 debugfs_remove(phba->hba_debugfs_root); /* fnX */
6633 phba->hba_debugfs_root = NULL;
6634 atomic_dec(&lpfc_debugfs_hba_count);
6635 }
6636
6637 if (atomic_read(&lpfc_debugfs_hba_count) == 0) {
6638 debugfs_remove(lpfc_debugfs_root); /* lpfc */
6639 lpfc_debugfs_root = NULL;
6640 }
6641 }
6642 #endif
6643 return;
6644 }
6645
6646 /*
6647 * Driver debug utility routines outside of debugfs. The debug utility
6648 * routines implemented here is intended to be used in the instrumented
6649 * debug driver for debugging host or port issues.
6650 */
6651
6652 /**
6653 * lpfc_debug_dump_all_queues - dump all the queues with a hba
6654 * @phba: Pointer to HBA context object.
6655 *
6656 * This function dumps entries of all the queues asociated with the @phba.
6657 **/
6658 void
6659 lpfc_debug_dump_all_queues(struct lpfc_hba *phba)
6660 {
6661 int idx;
6662
6663 /*
6664 * Dump Work Queues (WQs)
6665 */
6666 lpfc_debug_dump_wq(phba, DUMP_MBX, 0);
6667 lpfc_debug_dump_wq(phba, DUMP_ELS, 0);
6668 lpfc_debug_dump_wq(phba, DUMP_NVMELS, 0);
6669
6670 for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6671 lpfc_debug_dump_wq(phba, DUMP_IO, idx);
6672
6673 lpfc_debug_dump_hdr_rq(phba);
6674 lpfc_debug_dump_dat_rq(phba);
6675 /*
6676 * Dump Complete Queues (CQs)
6677 */
6678 lpfc_debug_dump_cq(phba, DUMP_MBX, 0);
6679 lpfc_debug_dump_cq(phba, DUMP_ELS, 0);
6680 lpfc_debug_dump_cq(phba, DUMP_NVMELS, 0);
6681
6682 for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6683 lpfc_debug_dump_cq(phba, DUMP_IO, idx);
6684
6685 /*
6686 * Dump Event Queues (EQs)
6687 */
6688 for (idx = 0; idx < phba->cfg_hdw_queue; idx++)
6689 lpfc_debug_dump_hba_eq(phba, idx);
6690 }
Kernel DRM miscellaneous fixes and cross-tree changes