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