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