1 /******************************************************************* 2 * This file is part of the Emulex Linux Device Driver for * 3 * Fibre Channel Host Bus Adapters. * 4 * Copyright (C) 2004-2006 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_hw.h" 36 #include "lpfc_sli.h" 37 #include "lpfc_disc.h" 38 #include "lpfc_scsi.h" 39 #include "lpfc.h" 40 #include "lpfc_logmsg.h" 41 #include "lpfc_crtn.h" 42 #include "lpfc_version.h" 43 #include "lpfc_vport.h" 44 45 inline void lpfc_vport_set_state(struct lpfc_vport *vport, 46 enum fc_vport_state new_state) 47 { 48 struct fc_vport *fc_vport = vport->fc_vport; 49 50 if (fc_vport) { 51 /* 52 * When the transport defines fc_vport_set state we will replace 53 * this code with the following line 54 */ 55 /* fc_vport_set_state(fc_vport, new_state); */ 56 if (new_state != FC_VPORT_INITIALIZING) 57 fc_vport->vport_last_state = fc_vport->vport_state; 58 fc_vport->vport_state = new_state; 59 } 60 61 /* for all the error states we will set the invternal state to FAILED */ 62 switch (new_state) { 63 case FC_VPORT_NO_FABRIC_SUPP: 64 case FC_VPORT_NO_FABRIC_RSCS: 65 case FC_VPORT_FABRIC_LOGOUT: 66 case FC_VPORT_FABRIC_REJ_WWN: 67 case FC_VPORT_FAILED: 68 vport->port_state = LPFC_VPORT_FAILED; 69 break; 70 case FC_VPORT_LINKDOWN: 71 vport->port_state = LPFC_VPORT_UNKNOWN; 72 break; 73 default: 74 /* do nothing */ 75 break; 76 } 77 } 78 79 static int 80 lpfc_alloc_vpi(struct lpfc_hba *phba) 81 { 82 int vpi; 83 84 spin_lock_irq(&phba->hbalock); 85 /* Start at bit 1 because vpi zero is reserved for the physical port */ 86 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1); 87 if (vpi > phba->max_vpi) 88 vpi = 0; 89 else 90 set_bit(vpi, phba->vpi_bmask); 91 spin_unlock_irq(&phba->hbalock); 92 return vpi; 93 } 94 95 static void 96 lpfc_free_vpi(struct lpfc_hba *phba, int vpi) 97 { 98 spin_lock_irq(&phba->hbalock); 99 clear_bit(vpi, phba->vpi_bmask); 100 spin_unlock_irq(&phba->hbalock); 101 } 102 103 static int 104 lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport) 105 { 106 LPFC_MBOXQ_t *pmb; 107 MAILBOX_t *mb; 108 struct lpfc_dmabuf *mp; 109 int rc; 110 111 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 112 if (!pmb) { 113 return -ENOMEM; 114 } 115 mb = &pmb->mb; 116 117 lpfc_read_sparam(phba, pmb, vport->vpi); 118 /* 119 * Grab buffer pointer and clear context1 so we can use 120 * lpfc_sli_issue_box_wait 121 */ 122 mp = (struct lpfc_dmabuf *) pmb->context1; 123 pmb->context1 = NULL; 124 125 pmb->vport = vport; 126 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2); 127 if (rc != MBX_SUCCESS) { 128 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT, 129 "%d (%d):1818 VPort failed init, mbxCmd x%x " 130 "READ_SPARM mbxStatus x%x, rc = x%x\n", 131 phba->brd_no, vport->vpi, 132 mb->mbxCommand, mb->mbxStatus, rc); 133 lpfc_mbuf_free(phba, mp->virt, mp->phys); 134 kfree(mp); 135 if (rc != MBX_TIMEOUT) 136 mempool_free(pmb, phba->mbox_mem_pool); 137 return -EIO; 138 } 139 140 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm)); 141 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName, 142 sizeof (struct lpfc_name)); 143 memcpy(&vport->fc_portname, &vport->fc_sparam.portName, 144 sizeof (struct lpfc_name)); 145 146 lpfc_mbuf_free(phba, mp->virt, mp->phys); 147 kfree(mp); 148 mempool_free(pmb, phba->mbox_mem_pool); 149 150 return 0; 151 } 152 153 static int 154 lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn, 155 const char *name_type) 156 { 157 /* ensure that IEEE format 1 addresses 158 * contain zeros in bits 59-48 159 */ 160 if (!((wwn->u.wwn[0] >> 4) == 1 && 161 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0))) 162 return 1; 163 164 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 165 "%d:1822 Invalid %s: %02x:%02x:%02x:%02x:" 166 "%02x:%02x:%02x:%02x\n", 167 phba->brd_no, name_type, 168 wwn->u.wwn[0], wwn->u.wwn[1], 169 wwn->u.wwn[2], wwn->u.wwn[3], 170 wwn->u.wwn[4], wwn->u.wwn[5], 171 wwn->u.wwn[6], wwn->u.wwn[7]); 172 return 0; 173 } 174 175 static int 176 lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport) 177 { 178 struct lpfc_vport *vport; 179 180 list_for_each_entry(vport, &phba->port_list, listentry) { 181 if (vport == new_vport) 182 continue; 183 /* If they match, return not unique */ 184 if (memcmp(&vport->fc_sparam.portName, 185 &new_vport->fc_sparam.portName, 186 sizeof(struct lpfc_name)) == 0) 187 return 0; 188 } 189 return 1; 190 } 191 192 int 193 lpfc_vport_create(struct fc_vport *fc_vport, bool disable) 194 { 195 struct lpfc_nodelist *ndlp; 196 struct lpfc_vport *pport = 197 (struct lpfc_vport *) fc_vport->shost->hostdata; 198 struct lpfc_hba *phba = pport->phba; 199 struct lpfc_vport *vport = NULL; 200 int instance; 201 int vpi; 202 int rc = VPORT_ERROR; 203 204 if ((phba->sli_rev < 3) || 205 !(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) { 206 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 207 "%d:1808 Create VPORT failed: " 208 "NPIV is not enabled: SLImode:%d\n", 209 phba->brd_no, phba->sli_rev); 210 rc = VPORT_INVAL; 211 goto error_out; 212 } 213 214 vpi = lpfc_alloc_vpi(phba); 215 if (vpi == 0) { 216 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 217 "%d:1809 Create VPORT failed: " 218 "Max VPORTs (%d) exceeded\n", 219 phba->brd_no, phba->max_vpi); 220 rc = VPORT_NORESOURCES; 221 goto error_out; 222 } 223 224 225 /* Assign an unused board number */ 226 if ((instance = lpfc_get_instance()) < 0) { 227 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 228 "%d:1810 Create VPORT failed: Cannot get " 229 "instance number\n", phba->brd_no); 230 lpfc_free_vpi(phba, vpi); 231 rc = VPORT_NORESOURCES; 232 goto error_out; 233 } 234 235 vport = lpfc_create_port(phba, instance, fc_vport); 236 if (!vport) { 237 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 238 "%d:1811 Create VPORT failed: vpi x%x\n", 239 phba->brd_no, vpi); 240 lpfc_free_vpi(phba, vpi); 241 rc = VPORT_NORESOURCES; 242 goto error_out; 243 } 244 245 vport->vpi = vpi; 246 lpfc_debugfs_initialize(vport); 247 248 if (lpfc_vport_sparm(phba, vport)) { 249 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 250 "%d:1813 Create VPORT failed: vpi:%d " 251 "Cannot get sparam\n", 252 phba->brd_no, vpi); 253 lpfc_free_vpi(phba, vpi); 254 destroy_port(vport); 255 rc = VPORT_NORESOURCES; 256 goto error_out; 257 } 258 259 memcpy(vport->fc_portname.u.wwn, vport->fc_sparam.portName.u.wwn, 8); 260 memcpy(vport->fc_nodename.u.wwn, vport->fc_sparam.nodeName.u.wwn, 8); 261 262 if (fc_vport->node_name != 0) 263 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn); 264 if (fc_vport->port_name != 0) 265 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn); 266 267 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8); 268 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8); 269 270 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") || 271 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) { 272 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 273 "%d:1821 Create VPORT failed: vpi:%d " 274 "Invalid WWN format\n", 275 phba->brd_no, vpi); 276 lpfc_free_vpi(phba, vpi); 277 destroy_port(vport); 278 rc = VPORT_INVAL; 279 goto error_out; 280 } 281 282 if (!lpfc_unique_wwpn(phba, vport)) { 283 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 284 "%d:1823 Create VPORT failed: vpi:%d " 285 "Duplicate WWN on HBA\n", 286 phba->brd_no, vpi); 287 lpfc_free_vpi(phba, vpi); 288 destroy_port(vport); 289 rc = VPORT_INVAL; 290 goto error_out; 291 } 292 293 *(struct lpfc_vport **)fc_vport->dd_data = vport; 294 vport->fc_vport = fc_vport; 295 296 if ((phba->link_state < LPFC_LINK_UP) || 297 (phba->fc_topology == TOPOLOGY_LOOP)) { 298 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN); 299 rc = VPORT_OK; 300 goto out; 301 } 302 303 if (disable) { 304 rc = VPORT_OK; 305 goto out; 306 } 307 308 /* Use the Physical nodes Fabric NDLP to determine if the link is 309 * up and ready to FDISC. 310 */ 311 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 312 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) { 313 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) { 314 lpfc_set_disctmo(vport); 315 lpfc_initial_fdisc(vport); 316 } else { 317 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP); 318 lpfc_printf_log(phba, KERN_ERR, LOG_ELS, 319 "%d (%d):0262 No NPIV Fabric " 320 "support\n", 321 phba->brd_no, vport->vpi); 322 } 323 } else { 324 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 325 } 326 rc = VPORT_OK; 327 328 out: 329 lpfc_host_attrib_init(lpfc_shost_from_vport(vport)); 330 error_out: 331 return rc; 332 } 333 334 int 335 disable_vport(struct fc_vport *fc_vport) 336 { 337 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 338 struct lpfc_hba *phba = vport->phba; 339 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL; 340 long timeout; 341 342 ndlp = lpfc_findnode_did(vport, Fabric_DID); 343 if (ndlp && phba->link_state >= LPFC_LINK_UP) { 344 vport->unreg_vpi_cmpl = VPORT_INVAL; 345 timeout = msecs_to_jiffies(phba->fc_ratov * 2000); 346 if (!lpfc_issue_els_npiv_logo(vport, ndlp)) 347 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout) 348 timeout = schedule_timeout(timeout); 349 } 350 351 lpfc_sli_host_down(vport); 352 353 /* Mark all nodes for discovery so we can remove them by 354 * calling lpfc_cleanup_rpis(vport, 1) 355 */ 356 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 357 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 358 continue; 359 lpfc_disc_state_machine(vport, ndlp, NULL, 360 NLP_EVT_DEVICE_RECOVERY); 361 } 362 lpfc_cleanup_rpis(vport, 1); 363 364 lpfc_stop_vport_timers(vport); 365 lpfc_unreg_all_rpis(vport); 366 lpfc_unreg_default_rpis(vport); 367 /* 368 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the 369 * scsi_host_put() to release the vport. 370 */ 371 lpfc_mbx_unreg_vpi(vport); 372 373 lpfc_vport_set_state(vport, FC_VPORT_DISABLED); 374 return VPORT_OK; 375 } 376 377 int 378 enable_vport(struct fc_vport *fc_vport) 379 { 380 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 381 struct lpfc_hba *phba = vport->phba; 382 struct lpfc_nodelist *ndlp = NULL; 383 384 if ((phba->link_state < LPFC_LINK_UP) || 385 (phba->fc_topology == TOPOLOGY_LOOP)) { 386 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN); 387 return VPORT_OK; 388 } 389 390 vport->load_flag |= FC_LOADING; 391 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 392 393 /* Use the Physical nodes Fabric NDLP to determine if the link is 394 * up and ready to FDISC. 395 */ 396 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 397 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) { 398 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) { 399 lpfc_set_disctmo(vport); 400 lpfc_initial_fdisc(vport); 401 } else { 402 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP); 403 lpfc_printf_log(phba, KERN_ERR, LOG_ELS, 404 "%d (%d):0264 No NPIV Fabric " 405 "support\n", 406 phba->brd_no, vport->vpi); 407 } 408 } else { 409 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 410 } 411 412 return VPORT_OK; 413 } 414 415 int 416 lpfc_vport_disable(struct fc_vport *fc_vport, bool disable) 417 { 418 if (disable) 419 return disable_vport(fc_vport); 420 else 421 return enable_vport(fc_vport); 422 } 423 424 425 int 426 lpfc_vport_delete(struct fc_vport *fc_vport) 427 { 428 struct lpfc_nodelist *ndlp = NULL; 429 struct lpfc_nodelist *next_ndlp; 430 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost; 431 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data; 432 struct lpfc_hba *phba = vport->phba; 433 long timeout; 434 int rc = VPORT_ERROR; 435 436 /* 437 * This is a bit of a mess. We want to ensure the shost doesn't get 438 * torn down until we're done with the embedded lpfc_vport structure. 439 * 440 * Beyond holding a reference for this function, we also need a 441 * reference for outstanding I/O requests we schedule during delete 442 * processing. But once we scsi_remove_host() we can no longer obtain 443 * a reference through scsi_host_get(). 444 * 445 * So we take two references here. We release one reference at the 446 * bottom of the function -- after delinking the vport. And we 447 * release the other at the completion of the unreg_vpi that get's 448 * initiated after we've disposed of all other resources associated 449 * with the port. 450 */ 451 if (!scsi_host_get(shost) || !scsi_host_get(shost)) 452 return VPORT_INVAL; 453 454 if (vport->port_type == LPFC_PHYSICAL_PORT) { 455 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT, 456 "%d:1812 vport_delete failed: Cannot delete " 457 "physical host\n", phba->brd_no); 458 goto out; 459 } 460 461 vport->load_flag |= FC_UNLOADING; 462 463 kfree(vport->vname); 464 lpfc_debugfs_terminate(vport); 465 fc_remove_host(lpfc_shost_from_vport(vport)); 466 scsi_remove_host(lpfc_shost_from_vport(vport)); 467 468 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID); 469 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE && 470 phba->link_state >= LPFC_LINK_UP) { 471 472 /* First look for the Fabric ndlp */ 473 ndlp = lpfc_findnode_did(vport, Fabric_DID); 474 if (!ndlp) { 475 /* Cannot find existing Fabric ndlp, allocate one */ 476 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL); 477 if (!ndlp) 478 goto skip_logo; 479 lpfc_nlp_init(vport, ndlp, Fabric_DID); 480 } else { 481 lpfc_dequeue_node(vport, ndlp); 482 } 483 vport->unreg_vpi_cmpl = VPORT_INVAL; 484 timeout = msecs_to_jiffies(phba->fc_ratov * 2000); 485 if (!lpfc_issue_els_npiv_logo(vport, ndlp)) 486 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout) 487 timeout = schedule_timeout(timeout); 488 } 489 490 skip_logo: 491 lpfc_sli_host_down(vport); 492 493 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 494 lpfc_disc_state_machine(vport, ndlp, NULL, 495 NLP_EVT_DEVICE_RECOVERY); 496 lpfc_disc_state_machine(vport, ndlp, NULL, 497 NLP_EVT_DEVICE_RM); 498 } 499 500 lpfc_stop_vport_timers(vport); 501 lpfc_unreg_all_rpis(vport); 502 lpfc_unreg_default_rpis(vport); 503 /* 504 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the 505 * scsi_host_put() to release the vport. 506 */ 507 lpfc_mbx_unreg_vpi(vport); 508 509 lpfc_free_vpi(phba, vport->vpi); 510 vport->work_port_events = 0; 511 spin_lock_irq(&phba->hbalock); 512 list_del_init(&vport->listentry); 513 spin_unlock_irq(&phba->hbalock); 514 515 rc = VPORT_OK; 516 out: 517 scsi_host_put(shost); 518 return rc; 519 } 520 521 522 EXPORT_SYMBOL(lpfc_vport_create); 523 EXPORT_SYMBOL(lpfc_vport_delete); 524