lpfc_vport.c revision 9795724476860069ce183ead59d0a5958f882037
1/******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2008 Emulex. All rights reserved. * 5 * EMULEX and SLI are trademarks of Emulex. * 6 * www.emulex.com * 7 * Portions Copyright (C) 2004-2005 Christoph Hellwig * 8 * * 9 * This program is free software; you can redistribute it and/or * 10 * modify it under the terms of version 2 of the GNU General * 11 * Public License as published by the Free Software Foundation. * 12 * This program is distributed in the hope that it will be useful. * 13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND * 14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, * 15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE * 16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD * 17 * TO BE LEGALLY INVALID. See the GNU General Public License for * 18 * more details, a copy of which can be found in the file COPYING * 19 * included with this package. * 20 *******************************************************************/ 21 22#include <linux/blkdev.h> 23#include <linux/delay.h> 24#include <linux/dma-mapping.h> 25#include <linux/idr.h> 26#include <linux/interrupt.h> 27#include <linux/kthread.h> 28#include <linux/pci.h> 29#include <linux/spinlock.h> 30 31#include <scsi/scsi.h> 32#include <scsi/scsi_device.h> 33#include <scsi/scsi_host.h> 34#include <scsi/scsi_transport_fc.h> 35#include "lpfc_hw4.h" 36#include "lpfc_hw.h" 37#include "lpfc_sli.h" 38#include "lpfc_sli4.h" 39#include "lpfc_nl.h" 40#include "lpfc_disc.h" 41#include "lpfc_scsi.h" 42#include "lpfc.h" 43#include "lpfc_logmsg.h" 44#include "lpfc_crtn.h" 45#include "lpfc_version.h" 46#include "lpfc_vport.h" 47 48inline void lpfc_vport_set_state(struct lpfc_vport *vport, 49 enum fc_vport_state new_state) 50{ 51 struct fc_vport *fc_vport = vport->fc_vport; 52 53 if (fc_vport) { 54 /* 55 * When the transport defines fc_vport_set state we will replace 56 * this code with the following line 57 */ 58 /* fc_vport_set_state(fc_vport, new_state); */ 59 if (new_state != FC_VPORT_INITIALIZING) 60 fc_vport->vport_last_state = fc_vport->vport_state; 61 fc_vport->vport_state = new_state; 62 } 63 64 /* for all the error states we will set the invternal state to FAILED */ 65 switch (new_state) { 66 case FC_VPORT_NO_FABRIC_SUPP: 67 case FC_VPORT_NO_FABRIC_RSCS: 68 case FC_VPORT_FABRIC_LOGOUT: 69 case FC_VPORT_FABRIC_REJ_WWN: 70 case FC_VPORT_FAILED: 71 vport->port_state = LPFC_VPORT_FAILED; 72 break; 73 case FC_VPORT_LINKDOWN: 74 vport->port_state = LPFC_VPORT_UNKNOWN; 75 break; 76 default: 77 /* do nothing */ 78 break; 79 } 80} 81 82static int 83lpfc_alloc_vpi(struct lpfc_hba *phba) 84{ 85 int vpi; 86 87 spin_lock_irq(&phba->hbalock); 88 /* Start at bit 1 because vpi zero is reserved for the physical port */ 89 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1); 90 if (vpi > phba->max_vpi) 91 vpi = 0; 92 else 93 set_bit(vpi, phba->vpi_bmask); 94 if (phba->sli_rev == LPFC_SLI_REV4) 95 phba->sli4_hba.max_cfg_param.vpi_used++; 96 spin_unlock_irq(&phba->hbalock); 97 return vpi; 98} 99 100static void 101lpfc_free_vpi(struct lpfc_hba *phba, int vpi) 102{ 103 if (vpi == 0) 104 return; 105 spin_lock_irq(&phba->hbalock); 106 clear_bit(vpi, phba->vpi_bmask); 107 if (phba->sli_rev == LPFC_SLI_REV4) 108 phba->sli4_hba.max_cfg_param.vpi_used--; 109 spin_unlock_irq(&phba->hbalock); 110} 111 112static int 113lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport) 114{ 115 LPFC_MBOXQ_t *pmb; 116 MAILBOX_t *mb; 117 struct lpfc_dmabuf *mp; 118 int rc; 119 120 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 121 if (!pmb) { 122 return -ENOMEM; 123 } 124 mb = &pmb->u.mb; 125 126 lpfc_read_sparam(phba, pmb, vport->vpi); 127 /* 128 * Grab buffer pointer and clear context1 so we can use 129 * lpfc_sli_issue_box_wait 130 */ 131 mp = (struct lpfc_dmabuf *) pmb->context1; 132 pmb->context1 = NULL; 133 134 pmb->vport = vport; 135 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2); 136 if (rc != MBX_SUCCESS) { 137 if (signal_pending(current)) { 138 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT, 139 "1830 Signal aborted mbxCmd x%x\n", 140 mb->mbxCommand); 141 lpfc_mbuf_free(phba, mp->virt, mp->phys); 142 kfree(mp); 143 if (rc != MBX_TIMEOUT) 144 mempool_free(pmb, phba->mbox_mem_pool); 145 return -EINTR; 146 } else { 147 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT, 148 "1818 VPort failed init, mbxCmd x%x " 149 "READ_SPARM mbxStatus x%x, rc = x%x\n", 150 mb->mbxCommand, mb->mbxStatus, rc); 151 lpfc_mbuf_free(phba, mp->virt, mp->phys); 152 kfree(mp); 153 if (rc != MBX_TIMEOUT) 154 mempool_free(pmb, phba->mbox_mem_pool); 155 return -EIO; 156 } 157 } 158 159 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm)); 160 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName, 161 sizeof (struct lpfc_name)); 162 memcpy(&vport->fc_portname, &vport->fc_sparam.portName, 163 sizeof (struct lpfc_name)); 164 165 lpfc_mbuf_free(phba, mp->virt, mp->phys); 166 kfree(mp); 167 mempool_free(pmb, phba->mbox_mem_pool); 168 169 return 0; 170} 171 172static int 173lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn, 174 const char *name_type) 175{ 176 /* ensure that IEEE format 1 addresses 177 * contain zeros in bits 59-48 178 */ 179 if (!((wwn->u.wwn[0] >> 4) == 1 && 180 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0))) 181 return 1; 182 183 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 184 "1822 Invalid %s: %02x:%02x:%02x:%02x:" 185 "%02x:%02x:%02x:%02x\n", 186 name_type, 187 wwn->u.wwn[0], wwn->u.wwn[1], 188 wwn->u.wwn[2], wwn->u.wwn[3], 189 wwn->u.wwn[4], wwn->u.wwn[5], 190 wwn->u.wwn[6], wwn->u.wwn[7]); 191 return 0; 192} 193 194static int 195lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport) 196{ 197 struct lpfc_vport *vport; 198 unsigned long flags; 199 200 spin_lock_irqsave(&phba->hbalock, flags); 201 list_for_each_entry(vport, &phba->port_list, listentry) { 202 if (vport == new_vport) 203 continue; 204 /* If they match, return not unique */ 205 if (memcmp(&vport->fc_sparam.portName, 206 &new_vport->fc_sparam.portName, 207 sizeof(struct lpfc_name)) == 0) { 208 spin_unlock_irqrestore(&phba->hbalock, flags); 209 return 0; 210 } 211 } 212 spin_unlock_irqrestore(&phba->hbalock, flags); 213 return 1; 214} 215 216/** 217 * lpfc_discovery_wait - Wait for driver discovery to quiesce 218 * @vport: The virtual port for which this call is being executed. 219 * 220 * This driver calls this routine specifically from lpfc_vport_delete 221 * to enforce a synchronous execution of vport 222 * delete relative to discovery activities. The 223 * lpfc_vport_delete routine should not return until it 224 * can reasonably guarantee that discovery has quiesced. 225 * Post FDISC LOGO, the driver must wait until its SAN teardown is 226 * complete and all resources recovered before allowing 227 * cleanup. 228 * 229 * This routine does not require any locks held. 230 **/ 231static void lpfc_discovery_wait(struct lpfc_vport *vport) 232{ 233 struct lpfc_hba *phba = vport->phba; 234 uint32_t wait_flags = 0; 235 unsigned long wait_time_max; 236 unsigned long start_time; 237 238 wait_flags = FC_RSCN_MODE | FC_RSCN_DISCOVERY | FC_NLP_MORE | 239 FC_RSCN_DEFERRED | FC_NDISC_ACTIVE | FC_DISC_TMO; 240 241 /* 242 * The time constraint on this loop is a balance between the 243 * fabric RA_TOV value and dev_loss tmo. The driver's 244 * devloss_tmo is 10 giving this loop a 3x multiplier minimally. 245 */ 246 wait_time_max = msecs_to_jiffies(((phba->fc_ratov * 3) + 3) * 1000); 247 wait_time_max += jiffies; 248 start_time = jiffies; 249 while (time_before(jiffies, wait_time_max)) { 250 if ((vport->num_disc_nodes > 0) || 251 (vport->fc_flag & wait_flags) || 252 ((vport->port_state > LPFC_VPORT_FAILED) && 253 (vport->port_state < LPFC_VPORT_READY))) { 254 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT, 255 "1833 Vport discovery quiesce Wait:" 256 " state x%x fc_flags x%x" 257 " num_nodes x%x, waiting 1000 msecs" 258 " total wait msecs x%x\n", 259 vport->port_state, vport->fc_flag, 260 vport->num_disc_nodes, 261 jiffies_to_msecs(jiffies - start_time)); 262 msleep(1000); 263 } else { 264 /* Base case. Wait variants satisfied. Break out */ 265 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT, 266 "1834 Vport discovery quiesced:" 267 " state x%x fc_flags x%x" 268 " wait msecs x%x\n", 269 vport->port_state, vport->fc_flag, 270 jiffies_to_msecs(jiffies 271 - start_time)); 272 break; 273 } 274 } 275 276 if (time_after(jiffies, wait_time_max)) 277 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 278 "1835 Vport discovery quiesce failed:" 279 " state x%x fc_flags x%x wait msecs x%x\n", 280 vport->port_state, vport->fc_flag, 281 jiffies_to_msecs(jiffies - start_time)); 282} 283 284int 285lpfc_vport_create(struct fc_vport *fc_vport, bool disable) 286{ 287 struct lpfc_nodelist *ndlp; 288 struct Scsi_Host *shost = fc_vport->shost; 289 struct lpfc_vport *pport = (struct lpfc_vport *) shost->hostdata; 290 struct lpfc_hba *phba = pport->phba; 291 struct lpfc_vport *vport = NULL; 292 int instance; 293 int vpi; 294 int rc = VPORT_ERROR; 295 int status; 296 297 if ((phba->sli_rev < 3) || !(phba->cfg_enable_npiv)) { 298 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 299 "1808 Create VPORT failed: " 300 "NPIV is not enabled: SLImode:%d\n", 301 phba->sli_rev); 302 rc = VPORT_INVAL; 303 goto error_out; 304 } 305 306 vpi = lpfc_alloc_vpi(phba); 307 if (vpi == 0) { 308 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 309 "1809 Create VPORT failed: " 310 "Max VPORTs (%d) exceeded\n", 311 phba->max_vpi); 312 rc = VPORT_NORESOURCES; 313 goto error_out; 314 } 315 316 /* Assign an unused board number */ 317 if ((instance = lpfc_get_instance()) < 0) { 318 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 319 "1810 Create VPORT failed: Cannot get " 320 "instance number\n"); 321 lpfc_free_vpi(phba, vpi); 322 rc = VPORT_NORESOURCES; 323 goto error_out; 324 } 325 326 vport = lpfc_create_port(phba, instance, &fc_vport->dev); 327 if (!vport) { 328 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 329 "1811 Create VPORT failed: vpi x%x\n", vpi); 330 lpfc_free_vpi(phba, vpi); 331 rc = VPORT_NORESOURCES; 332 goto error_out; 333 } 334 335 vport->vpi = vpi; 336 lpfc_debugfs_initialize(vport); 337 338 if ((status = lpfc_vport_sparm(phba, vport))) { 339 if (status == -EINTR) { 340 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 341 "1831 Create VPORT Interrupted.\n"); 342 rc = VPORT_ERROR; 343 } else { 344 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 345 "1813 Create VPORT failed. " 346 "Cannot get sparam\n"); 347 rc = VPORT_NORESOURCES; 348 } 349 lpfc_free_vpi(phba, vpi); 350 destroy_port(vport); 351 goto error_out; 352 } 353 354 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn); 355 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn); 356 357 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8); 358 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8); 359 360 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") || 361 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) { 362 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 363 "1821 Create VPORT failed. " 364 "Invalid WWN format\n"); 365 lpfc_free_vpi(phba, vpi); 366 destroy_port(vport); 367 rc = VPORT_INVAL; 368 goto error_out; 369 } 370 371 if (!lpfc_unique_wwpn(phba, vport)) { 372 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 373 "1823 Create VPORT failed. " 374 "Duplicate WWN on HBA\n"); 375 lpfc_free_vpi(phba, vpi); 376 destroy_port(vport); 377 rc = VPORT_INVAL; 378 goto error_out; 379 } 380 381 /* Create binary sysfs attribute for vport */ 382 lpfc_alloc_sysfs_attr(vport); 383 384 *(struct lpfc_vport **)fc_vport->dd_data = vport; 385 vport->fc_vport = fc_vport; 386 387 /* 388 * In SLI4, the vpi must be activated before it can be used 389 * by the port. 390 */ 391 if ((phba->sli_rev == LPFC_SLI_REV4) && 392 (pport->vpi_state & LPFC_VPI_REGISTERED)) { 393 rc = lpfc_sli4_init_vpi(phba, vpi); 394 if (rc) { 395 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 396 "1838 Failed to INIT_VPI on vpi %d " 397 "status %d\n", vpi, rc); 398 rc = VPORT_NORESOURCES; 399 lpfc_free_vpi(phba, vpi); 400 goto error_out; 401 } 402 } else if (phba->sli_rev == LPFC_SLI_REV4) { 403 /* 404 * Driver cannot INIT_VPI now. Set the flags to 405 * init_vpi when reg_vfi complete. 406 */ 407 vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI; 408 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN); 409 rc = VPORT_OK; 410 goto out; 411 } 412 413 if ((phba->link_state < LPFC_LINK_UP) || 414 (pport->port_state < LPFC_FABRIC_CFG_LINK) || 415 (phba->fc_topology == TOPOLOGY_LOOP)) { 416 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN); 417 rc = VPORT_OK; 418 goto out; 419 } 420 421 if (disable) { 422 lpfc_vport_set_state(vport, FC_VPORT_DISABLED); 423 rc = VPORT_OK; 424 goto out; 425 } 426 427 /* Use the Physical nodes Fabric NDLP to determine if the link is 428 * up and ready to FDISC. 429 */ 430 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 431 if (ndlp && NLP_CHK_NODE_ACT(ndlp) && 432 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) { 433 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) { 434 lpfc_set_disctmo(vport); 435 lpfc_initial_fdisc(vport); 436 } else { 437 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP); 438 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 439 "0262 No NPIV Fabric support\n"); 440 } 441 } else { 442 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 443 } 444 rc = VPORT_OK; 445 446out: 447 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 448 "1825 Vport Created.\n"); 449 lpfc_host_attrib_init(lpfc_shost_from_vport(vport)); 450error_out: 451 return rc; 452} 453 454static int 455disable_vport(struct fc_vport *fc_vport) 456{ 457 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 458 struct lpfc_hba *phba = vport->phba; 459 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL; 460 long timeout; 461 462 ndlp = lpfc_findnode_did(vport, Fabric_DID); 463 if (ndlp && NLP_CHK_NODE_ACT(ndlp) 464 && phba->link_state >= LPFC_LINK_UP) { 465 vport->unreg_vpi_cmpl = VPORT_INVAL; 466 timeout = msecs_to_jiffies(phba->fc_ratov * 2000); 467 if (!lpfc_issue_els_npiv_logo(vport, ndlp)) 468 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout) 469 timeout = schedule_timeout(timeout); 470 } 471 472 lpfc_sli_host_down(vport); 473 474 /* Mark all nodes for discovery so we can remove them by 475 * calling lpfc_cleanup_rpis(vport, 1) 476 */ 477 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 478 if (!NLP_CHK_NODE_ACT(ndlp)) 479 continue; 480 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 481 continue; 482 lpfc_disc_state_machine(vport, ndlp, NULL, 483 NLP_EVT_DEVICE_RECOVERY); 484 } 485 lpfc_cleanup_rpis(vport, 1); 486 487 lpfc_stop_vport_timers(vport); 488 lpfc_unreg_all_rpis(vport); 489 lpfc_unreg_default_rpis(vport); 490 /* 491 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the 492 * scsi_host_put() to release the vport. 493 */ 494 lpfc_mbx_unreg_vpi(vport); 495 496 lpfc_vport_set_state(vport, FC_VPORT_DISABLED); 497 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 498 "1826 Vport Disabled.\n"); 499 return VPORT_OK; 500} 501 502static int 503enable_vport(struct fc_vport *fc_vport) 504{ 505 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 506 struct lpfc_hba *phba = vport->phba; 507 struct lpfc_nodelist *ndlp = NULL; 508 509 if ((phba->link_state < LPFC_LINK_UP) || 510 (phba->fc_topology == TOPOLOGY_LOOP)) { 511 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN); 512 return VPORT_OK; 513 } 514 515 spin_lock_irq(&phba->hbalock); 516 vport->load_flag |= FC_LOADING; 517 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 518 spin_unlock_irq(&phba->hbalock); 519 520 /* Use the Physical nodes Fabric NDLP to determine if the link is 521 * up and ready to FDISC. 522 */ 523 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 524 if (ndlp && NLP_CHK_NODE_ACT(ndlp) 525 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) { 526 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) { 527 lpfc_set_disctmo(vport); 528 lpfc_initial_fdisc(vport); 529 } else { 530 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP); 531 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 532 "0264 No NPIV Fabric support\n"); 533 } 534 } else { 535 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 536 } 537 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 538 "1827 Vport Enabled.\n"); 539 return VPORT_OK; 540} 541 542int 543lpfc_vport_disable(struct fc_vport *fc_vport, bool disable) 544{ 545 if (disable) 546 return disable_vport(fc_vport); 547 else 548 return enable_vport(fc_vport); 549} 550 551 552int 553lpfc_vport_delete(struct fc_vport *fc_vport) 554{ 555 struct lpfc_nodelist *ndlp = NULL; 556 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost; 557 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 558 struct lpfc_hba *phba = vport->phba; 559 long timeout; 560 561 if (vport->port_type == LPFC_PHYSICAL_PORT) { 562 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 563 "1812 vport_delete failed: Cannot delete " 564 "physical host\n"); 565 return VPORT_ERROR; 566 } 567 568 /* If the vport is a static vport fail the deletion. */ 569 if ((vport->vport_flag & STATIC_VPORT) && 570 !(phba->pport->load_flag & FC_UNLOADING)) { 571 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 572 "1837 vport_delete failed: Cannot delete " 573 "static vport.\n"); 574 return VPORT_ERROR; 575 } 576 577 /* 578 * If we are not unloading the driver then prevent the vport_delete 579 * from happening until after this vport's discovery is finished. 580 */ 581 if (!(phba->pport->load_flag & FC_UNLOADING)) { 582 int check_count = 0; 583 while (check_count < ((phba->fc_ratov * 3) + 3) && 584 vport->port_state > LPFC_VPORT_FAILED && 585 vport->port_state < LPFC_VPORT_READY) { 586 check_count++; 587 msleep(1000); 588 } 589 if (vport->port_state > LPFC_VPORT_FAILED && 590 vport->port_state < LPFC_VPORT_READY) 591 return -EAGAIN; 592 } 593 /* 594 * This is a bit of a mess. We want to ensure the shost doesn't get 595 * torn down until we're done with the embedded lpfc_vport structure. 596 * 597 * Beyond holding a reference for this function, we also need a 598 * reference for outstanding I/O requests we schedule during delete 599 * processing. But once we scsi_remove_host() we can no longer obtain 600 * a reference through scsi_host_get(). 601 * 602 * So we take two references here. We release one reference at the 603 * bottom of the function -- after delinking the vport. And we 604 * release the other at the completion of the unreg_vpi that get's 605 * initiated after we've disposed of all other resources associated 606 * with the port. 607 */ 608 if (!scsi_host_get(shost)) 609 return VPORT_INVAL; 610 if (!scsi_host_get(shost)) { 611 scsi_host_put(shost); 612 return VPORT_INVAL; 613 } 614 spin_lock_irq(&phba->hbalock); 615 vport->load_flag |= FC_UNLOADING; 616 spin_unlock_irq(&phba->hbalock); 617 618 lpfc_free_sysfs_attr(vport); 619 620 lpfc_debugfs_terminate(vport); 621 622 /* Remove FC host and then SCSI host with the vport */ 623 fc_remove_host(lpfc_shost_from_vport(vport)); 624 scsi_remove_host(lpfc_shost_from_vport(vport)); 625 626 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 627 628 /* In case of driver unload, we shall not perform fabric logo as the 629 * worker thread already stopped at this stage and, in this case, we 630 * can safely skip the fabric logo. 631 */ 632 if (phba->pport->load_flag & FC_UNLOADING) { 633 if (ndlp && NLP_CHK_NODE_ACT(ndlp) && 634 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE && 635 phba->link_state >= LPFC_LINK_UP) { 636 /* First look for the Fabric ndlp */ 637 ndlp = lpfc_findnode_did(vport, Fabric_DID); 638 if (!ndlp) 639 goto skip_logo; 640 else if (!NLP_CHK_NODE_ACT(ndlp)) { 641 ndlp = lpfc_enable_node(vport, ndlp, 642 NLP_STE_UNUSED_NODE); 643 if (!ndlp) 644 goto skip_logo; 645 } 646 /* Remove ndlp from vport npld list */ 647 lpfc_dequeue_node(vport, ndlp); 648 649 /* Indicate free memory when release */ 650 spin_lock_irq(&phba->ndlp_lock); 651 NLP_SET_FREE_REQ(ndlp); 652 spin_unlock_irq(&phba->ndlp_lock); 653 /* Kick off release ndlp when it can be safely done */ 654 lpfc_nlp_put(ndlp); 655 } 656 goto skip_logo; 657 } 658 659 /* Otherwise, we will perform fabric logo as needed */ 660 if (ndlp && NLP_CHK_NODE_ACT(ndlp) && 661 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE && 662 phba->link_state >= LPFC_LINK_UP && 663 phba->fc_topology != TOPOLOGY_LOOP) { 664 if (vport->cfg_enable_da_id) { 665 timeout = msecs_to_jiffies(phba->fc_ratov * 2000); 666 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0)) 667 while (vport->ct_flags && timeout) 668 timeout = schedule_timeout(timeout); 669 else 670 lpfc_printf_log(vport->phba, KERN_WARNING, 671 LOG_VPORT, 672 "1829 CT command failed to " 673 "delete objects on fabric\n"); 674 } 675 /* First look for the Fabric ndlp */ 676 ndlp = lpfc_findnode_did(vport, Fabric_DID); 677 if (!ndlp) { 678 /* Cannot find existing Fabric ndlp, allocate one */ 679 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 680 if (!ndlp) 681 goto skip_logo; 682 lpfc_nlp_init(vport, ndlp, Fabric_DID); 683 /* Indicate free memory when release */ 684 NLP_SET_FREE_REQ(ndlp); 685 } else { 686 if (!NLP_CHK_NODE_ACT(ndlp)) 687 ndlp = lpfc_enable_node(vport, ndlp, 688 NLP_STE_UNUSED_NODE); 689 if (!ndlp) 690 goto skip_logo; 691 692 /* Remove ndlp from vport npld list */ 693 lpfc_dequeue_node(vport, ndlp); 694 spin_lock_irq(&phba->ndlp_lock); 695 if (!NLP_CHK_FREE_REQ(ndlp)) 696 /* Indicate free memory when release */ 697 NLP_SET_FREE_REQ(ndlp); 698 else { 699 /* Skip this if ndlp is already in free mode */ 700 spin_unlock_irq(&phba->ndlp_lock); 701 goto skip_logo; 702 } 703 spin_unlock_irq(&phba->ndlp_lock); 704 } 705 if (!(vport->vpi_state & LPFC_VPI_REGISTERED)) 706 goto skip_logo; 707 vport->unreg_vpi_cmpl = VPORT_INVAL; 708 timeout = msecs_to_jiffies(phba->fc_ratov * 2000); 709 if (!lpfc_issue_els_npiv_logo(vport, ndlp)) 710 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout) 711 timeout = schedule_timeout(timeout); 712 } 713 714 if (!(phba->pport->load_flag & FC_UNLOADING)) 715 lpfc_discovery_wait(vport); 716 717skip_logo: 718 lpfc_cleanup(vport); 719 lpfc_sli_host_down(vport); 720 721 lpfc_stop_vport_timers(vport); 722 723 if (!(phba->pport->load_flag & FC_UNLOADING)) { 724 lpfc_unreg_all_rpis(vport); 725 lpfc_unreg_default_rpis(vport); 726 /* 727 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) 728 * does the scsi_host_put() to release the vport. 729 */ 730 if (lpfc_mbx_unreg_vpi(vport)) 731 scsi_host_put(shost); 732 } else 733 scsi_host_put(shost); 734 735 lpfc_free_vpi(phba, vport->vpi); 736 vport->work_port_events = 0; 737 spin_lock_irq(&phba->hbalock); 738 list_del_init(&vport->listentry); 739 spin_unlock_irq(&phba->hbalock); 740 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT, 741 "1828 Vport Deleted.\n"); 742 scsi_host_put(shost); 743 return VPORT_OK; 744} 745 746struct lpfc_vport ** 747lpfc_create_vport_work_array(struct lpfc_hba *phba) 748{ 749 struct lpfc_vport *port_iterator; 750 struct lpfc_vport **vports; 751 int index = 0; 752 vports = kzalloc((phba->max_vports + 1) * sizeof(struct lpfc_vport *), 753 GFP_KERNEL); 754 if (vports == NULL) 755 return NULL; 756 spin_lock_irq(&phba->hbalock); 757 list_for_each_entry(port_iterator, &phba->port_list, listentry) { 758 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) { 759 lpfc_printf_vlog(port_iterator, KERN_WARNING, LOG_VPORT, 760 "1801 Create vport work array FAILED: " 761 "cannot do scsi_host_get\n"); 762 continue; 763 } 764 vports[index++] = port_iterator; 765 } 766 spin_unlock_irq(&phba->hbalock); 767 return vports; 768} 769 770void 771lpfc_destroy_vport_work_array(struct lpfc_hba *phba, struct lpfc_vport **vports) 772{ 773 int i; 774 if (vports == NULL) 775 return; 776 for (i = 0; vports[i] != NULL && i <= phba->max_vports; i++) 777 scsi_host_put(lpfc_shost_from_vport(vports[i])); 778 kfree(vports); 779} 780 781 782/** 783 * lpfc_vport_reset_stat_data - Reset the statistical data for the vport 784 * @vport: Pointer to vport object. 785 * 786 * This function resets the statistical data for the vport. This function 787 * is called with the host_lock held 788 **/ 789void 790lpfc_vport_reset_stat_data(struct lpfc_vport *vport) 791{ 792 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL; 793 794 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 795 if (!NLP_CHK_NODE_ACT(ndlp)) 796 continue; 797 if (ndlp->lat_data) 798 memset(ndlp->lat_data, 0, LPFC_MAX_BUCKET_COUNT * 799 sizeof(struct lpfc_scsicmd_bkt)); 800 } 801} 802 803 804/** 805 * lpfc_alloc_bucket - Allocate data buffer required for statistical data 806 * @vport: Pointer to vport object. 807 * 808 * This function allocates data buffer required for all the FC 809 * nodes of the vport to collect statistical data. 810 **/ 811void 812lpfc_alloc_bucket(struct lpfc_vport *vport) 813{ 814 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL; 815 816 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 817 if (!NLP_CHK_NODE_ACT(ndlp)) 818 continue; 819 820 kfree(ndlp->lat_data); 821 ndlp->lat_data = NULL; 822 823 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) { 824 ndlp->lat_data = kcalloc(LPFC_MAX_BUCKET_COUNT, 825 sizeof(struct lpfc_scsicmd_bkt), 826 GFP_ATOMIC); 827 828 if (!ndlp->lat_data) 829 lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE, 830 "0287 lpfc_alloc_bucket failed to " 831 "allocate statistical data buffer DID " 832 "0x%x\n", ndlp->nlp_DID); 833 } 834 } 835} 836 837/** 838 * lpfc_free_bucket - Free data buffer required for statistical data 839 * @vport: Pointer to vport object. 840 * 841 * Th function frees statistical data buffer of all the FC 842 * nodes of the vport. 843 **/ 844void 845lpfc_free_bucket(struct lpfc_vport *vport) 846{ 847 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL; 848 849 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 850 if (!NLP_CHK_NODE_ACT(ndlp)) 851 continue; 852 853 kfree(ndlp->lat_data); 854 ndlp->lat_data = NULL; 855 } 856} 857