enable docker ppp

hc

2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87

 kernel/drivers/scsi/lpfc/lpfc_debugfs.h
..
..
@@ -1,7 +1,7 @@
1
1
 /*******************************************************************
2
2
  * This file is part of the Emulex Linux Device Driver for         *
3
3
  * Fibre Channel Host Bus Adapters.                                *
4
- * Copyright (C) 2017-2018 Broadcom. All Rights Reserved. The term *
4
+ * Copyright (C) 2017-2019 Broadcom. All Rights Reserved. The term *
5
5
  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.     *
6
6
  * Copyright (C) 2007-2011 Emulex.  All rights reserved.           *
7
7
  * EMULEX and SLI are trademarks of Emulex.                        *
..
..
@@ -46,9 +46,11 @@
46
46
 
47
47
 /* nvmestat output buffer size */
48
48
 #define LPFC_NVMESTAT_SIZE 8192
49
-#define LPFC_NVMEKTIME_SIZE 8192
50
-#define LPFC_CPUCHECK_SIZE 8192
49
+#define LPFC_IOKTIME_SIZE 8192
51
50
 #define LPFC_NVMEIO_TRC_SIZE 8192
51
+
52
+/* scsistat output buffer size */
53
+#define LPFC_SCSISTAT_SIZE 8192
52
54
 
53
55
 #define LPFC_DEBUG_OUT_LINE_SZ	80
54
56
 
..
..
@@ -284,9 +286,11 @@
284
286
 
285
287
 #endif
286
288
 
289
+/* multixripool output buffer size */
290
+#define LPFC_DUMP_MULTIXRIPOOL_SIZE 8192
291
+
287
292
 enum {
288
-	DUMP_FCP,
289
-	DUMP_NVME,
293
+	DUMP_IO,
290
294
 	DUMP_MBX,
291
295
 	DUMP_ELS,
292
296
 	DUMP_NVMELS,
..
..
@@ -324,7 +328,7 @@
324
328
  * This function dumps an entry indexed by @idx from a queue specified by the
325
329
  * queue descriptor @q.
326
330
  **/
327
-static inline void
331
+static void
328
332
 lpfc_debug_dump_qe(struct lpfc_queue *q, uint32_t idx)
329
333
 {
330
334
 	char line_buf[LPFC_LBUF_SZ];
..
..
@@ -339,7 +343,7 @@
339
343
 
340
344
 	esize = q->entry_size;
341
345
 	qe_word_cnt = esize / sizeof(uint32_t);
342
-	pword = q->qe[idx].address;
346
+	pword = lpfc_sli4_qe(q, idx);
343
347
 
344
348
 	len = 0;
345
349
 	len += scnprintf(line_buf+len, LPFC_LBUF_SZ-len, "QE[%04d]: ", idx);
..
..
@@ -409,12 +413,9 @@
409
413
 	struct lpfc_queue *wq;
410
414
 	char *qtypestr;
411
415
 
412
-	if (qtype == DUMP_FCP) {
413
-		wq = phba->sli4_hba.fcp_wq[wqidx];
414
-		qtypestr = "FCP";
415
-	} else if (qtype == DUMP_NVME) {
416
-		wq = phba->sli4_hba.nvme_wq[wqidx];
417
-		qtypestr = "NVME";
416
+	if (qtype == DUMP_IO) {
417
+		wq = phba->sli4_hba.hdwq[wqidx].io_wq;
418
+		qtypestr = "IO";
418
419
 	} else if (qtype == DUMP_MBX) {
419
420
 		wq = phba->sli4_hba.mbx_wq;
420
421
 		qtypestr = "MBX";
..
..
@@ -427,7 +428,7 @@
427
428
 	} else
428
429
 		return;
429
430
 
430
-	if (qtype == DUMP_FCP || qtype == DUMP_NVME)
431
+	if (qtype == DUMP_IO)
431
432
 		pr_err("%s WQ: WQ[Idx:%d|Qid:%d]\n",
432
433
 			qtypestr, wqidx, wq->queue_id);
433
434
 	else
..
..
@@ -453,16 +454,13 @@
453
454
 	char *qtypestr;
454
455
 	int eqidx;
455
456
 
456
-	/* fcp/nvme wq and cq are 1:1, thus same indexes */
457
+	/* io wq and cq are 1:1, thus same indexes */
458
+	eq = NULL;
457
459
 
458
-	if (qtype == DUMP_FCP) {
459
-		wq = phba->sli4_hba.fcp_wq[wqidx];
460
-		cq = phba->sli4_hba.fcp_cq[wqidx];
461
-		qtypestr = "FCP";
462
-	} else if (qtype == DUMP_NVME) {
463
-		wq = phba->sli4_hba.nvme_wq[wqidx];
464
-		cq = phba->sli4_hba.nvme_cq[wqidx];
465
-		qtypestr = "NVME";
460
+	if (qtype == DUMP_IO) {
461
+		wq = phba->sli4_hba.hdwq[wqidx].io_wq;
462
+		cq = phba->sli4_hba.hdwq[wqidx].io_cq;
463
+		qtypestr = "IO";
466
464
 	} else if (qtype == DUMP_MBX) {
467
465
 		wq = phba->sli4_hba.mbx_wq;
468
466
 		cq = phba->sli4_hba.mbx_cq;
..
..
@@ -478,18 +476,18 @@
478
476
 	} else
479
477
 		return;
480
478
 
481
-	for (eqidx = 0; eqidx < phba->io_channel_irqs; eqidx++) {
482
-		if (cq->assoc_qid == phba->sli4_hba.hba_eq[eqidx]->queue_id)
479
+	for (eqidx = 0; eqidx < phba->cfg_hdw_queue; eqidx++) {
480
+		eq = phba->sli4_hba.hdwq[eqidx].hba_eq;
481
+		if (cq->assoc_qid == eq->queue_id)
483
482
 			break;
484
483
 	}
485
-	if (eqidx == phba->io_channel_irqs) {
484
+	if (eqidx == phba->cfg_hdw_queue) {
486
485
 		pr_err("Couldn't find EQ for CQ. Using EQ[0]\n");
487
486
 		eqidx = 0;
487
+		eq = phba->sli4_hba.hdwq[0].hba_eq;
488
488
 	}
489
489
 
490
-	eq = phba->sli4_hba.hba_eq[eqidx];
491
-
492
-	if (qtype == DUMP_FCP || qtype == DUMP_NVME)
490
+	if (qtype == DUMP_IO)
493
491
 		pr_err("%s CQ: WQ[Idx:%d|Qid%d]->CQ[Idx%d|Qid%d]"
494
492
 			"->EQ[Idx:%d|Qid:%d]:\n",
495
493
 			qtypestr, wqidx, wq->queue_id, wqidx, cq->queue_id,
..
..
@@ -516,7 +514,7 @@
516
514
 {
517
515
 	struct lpfc_queue *qp;
518
516
 
519
-	qp = phba->sli4_hba.hba_eq[qidx];
517
+	qp = phba->sli4_hba.hdwq[qidx].hba_eq;
520
518
 
521
519
 	pr_err("EQ[Idx:%d|Qid:%d]\n", qidx, qp->queue_id);
522
520
 
..
..
@@ -564,21 +562,12 @@
564
562
 {
565
563
 	int wq_idx;
566
564
 
567
-	for (wq_idx = 0; wq_idx < phba->cfg_fcp_io_channel; wq_idx++)
568
-		if (phba->sli4_hba.fcp_wq[wq_idx]->queue_id == qid)
565
+	for (wq_idx = 0; wq_idx < phba->cfg_hdw_queue; wq_idx++)
566
+		if (phba->sli4_hba.hdwq[wq_idx].io_wq->queue_id == qid)
569
567
 			break;
570
-	if (wq_idx < phba->cfg_fcp_io_channel) {
571
-		pr_err("FCP WQ[Idx:%d|Qid:%d]\n", wq_idx, qid);
572
-		lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[wq_idx]);
573
-		return;
574
-	}
575
-
576
-	for (wq_idx = 0; wq_idx < phba->cfg_nvme_io_channel; wq_idx++)
577
-		if (phba->sli4_hba.nvme_wq[wq_idx]->queue_id == qid)
578
-			break;
579
-	if (wq_idx < phba->cfg_nvme_io_channel) {
580
-		pr_err("NVME WQ[Idx:%d|Qid:%d]\n", wq_idx, qid);
581
-		lpfc_debug_dump_q(phba->sli4_hba.nvme_wq[wq_idx]);
568
+	if (wq_idx < phba->cfg_hdw_queue) {
569
+		pr_err("IO WQ[Idx:%d|Qid:%d]\n", wq_idx, qid);
570
+		lpfc_debug_dump_q(phba->sli4_hba.hdwq[wq_idx].io_wq);
582
571
 		return;
583
572
 	}
584
573
 
..
..
@@ -646,23 +635,13 @@
646
635
 {
647
636
 	int cq_idx;
648
637
 
649
-	for (cq_idx = 0; cq_idx < phba->cfg_fcp_io_channel; cq_idx++)
650
-		if (phba->sli4_hba.fcp_cq[cq_idx]->queue_id == qid)
638
+	for (cq_idx = 0; cq_idx < phba->cfg_hdw_queue; cq_idx++)
639
+		if (phba->sli4_hba.hdwq[cq_idx].io_cq->queue_id == qid)
651
640
 			break;
652
641
 
653
-	if (cq_idx < phba->cfg_fcp_io_channel) {
654
-		pr_err("FCP CQ[Idx:%d|Qid:%d]\n", cq_idx, qid);
655
-		lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[cq_idx]);
656
-		return;
657
-	}
658
-
659
-	for (cq_idx = 0; cq_idx < phba->cfg_nvme_io_channel; cq_idx++)
660
-		if (phba->sli4_hba.nvme_cq[cq_idx]->queue_id == qid)
661
-			break;
662
-
663
-	if (cq_idx < phba->cfg_nvme_io_channel) {
664
-		pr_err("NVME CQ[Idx:%d|Qid:%d]\n", cq_idx, qid);
665
-		lpfc_debug_dump_q(phba->sli4_hba.nvme_cq[cq_idx]);
642
+	if (cq_idx < phba->cfg_hdw_queue) {
643
+		pr_err("IO CQ[Idx:%d|Qid:%d]\n", cq_idx, qid);
644
+		lpfc_debug_dump_q(phba->sli4_hba.hdwq[cq_idx].io_cq);
666
645
 		return;
667
646
 	}
668
647
 
..
..
@@ -697,13 +676,13 @@
697
676
 {
698
677
 	int eq_idx;
699
678
 
700
-	for (eq_idx = 0; eq_idx < phba->io_channel_irqs; eq_idx++)
701
-		if (phba->sli4_hba.hba_eq[eq_idx]->queue_id == qid)
679
+	for (eq_idx = 0; eq_idx < phba->cfg_hdw_queue; eq_idx++)
680
+		if (phba->sli4_hba.hdwq[eq_idx].hba_eq->queue_id == qid)
702
681
 			break;
703
682
 
704
-	if (eq_idx < phba->io_channel_irqs) {
683
+	if (eq_idx < phba->cfg_hdw_queue) {
705
684
 		printk(KERN_ERR "FCP EQ[Idx:%d|Qid:%d]\n", eq_idx, qid);
706
-		lpfc_debug_dump_q(phba->sli4_hba.hba_eq[eq_idx]);
685
+		lpfc_debug_dump_q(phba->sli4_hba.hdwq[eq_idx].hba_eq);
707
686
 		return;
708
687
 	}
709
688
 }