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

source code of linux/drivers/scsi/lpfc/lpfc_debugfs.c