| User: | Jiri Slaby |
| Error type: | Invalid Pointer Dereference |
| Error type description: | A pointer which is invalid is being dereferenced |
| File location: | drivers/scsi/lpfc/lpfc_hbadisc.c |
| Line in file: | 300 |
| Project: | Linux Kernel |
| Project version: | 2.6.28 |
| Tools: |
Stanse
(1.2)
Smatch (1.59) |
| Entered: | 2011-11-07 22:22:22 UTC |
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/pci.h> 24#include <linux/kthread.h> 25#include <linux/interrupt.h> 26 27#include <scsi/scsi.h> 28#include <scsi/scsi_device.h> 29#include <scsi/scsi_host.h> 30#include <scsi/scsi_transport_fc.h> 31 32#include "lpfc_hw.h" 33#include "lpfc_nl.h" 34#include "lpfc_disc.h" 35#include "lpfc_sli.h" 36#include "lpfc_scsi.h" 37#include "lpfc.h" 38#include "lpfc_logmsg.h" 39#include "lpfc_crtn.h" 40#include "lpfc_vport.h" 41#include "lpfc_debugfs.h" 42 43/* AlpaArray for assignment of scsid for scan-down and bind_method */ 44static uint8_t lpfcAlpaArray[] = { 45 0xEF, 0xE8, 0xE4, 0xE2, 0xE1, 0xE0, 0xDC, 0xDA, 0xD9, 0xD6, 46 0xD5, 0xD4, 0xD3, 0xD2, 0xD1, 0xCE, 0xCD, 0xCC, 0xCB, 0xCA, 47 0xC9, 0xC7, 0xC6, 0xC5, 0xC3, 0xBC, 0xBA, 0xB9, 0xB6, 0xB5, 48 0xB4, 0xB3, 0xB2, 0xB1, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 49 0xA7, 0xA6, 0xA5, 0xA3, 0x9F, 0x9E, 0x9D, 0x9B, 0x98, 0x97, 50 0x90, 0x8F, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7C, 0x7A, 0x79, 51 0x76, 0x75, 0x74, 0x73, 0x72, 0x71, 0x6E, 0x6D, 0x6C, 0x6B, 52 0x6A, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5C, 0x5A, 0x59, 0x56, 53 0x55, 0x54, 0x53, 0x52, 0x51, 0x4E, 0x4D, 0x4C, 0x4B, 0x4A, 54 0x49, 0x47, 0x46, 0x45, 0x43, 0x3C, 0x3A, 0x39, 0x36, 0x35, 55 0x34, 0x33, 0x32, 0x31, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 56 0x27, 0x26, 0x25, 0x23, 0x1F, 0x1E, 0x1D, 0x1B, 0x18, 0x17, 57 0x10, 0x0F, 0x08, 0x04, 0x02, 0x01 58}; 59 60static void lpfc_disc_timeout_handler(struct lpfc_vport *); 61static void lpfc_disc_flush_list(struct lpfc_vport *vport); 62 63void 64lpfc_terminate_rport_io(struct fc_rport *rport) 65{ 66 struct lpfc_rport_data *rdata; 67 struct lpfc_nodelist * ndlp; 68 struct lpfc_hba *phba; 69 70 rdata = rport->dd_data; 71 ndlp = rdata->pnode; 72 73 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) { 74 if (rport->roles & FC_RPORT_ROLE_FCP_TARGET) 75 printk(KERN_ERR "Cannot find remote node" 76 " to terminate I/O Data x%x\n", 77 rport->port_id); 78 return; 79 } 80 81 phba = ndlp->vport->phba; 82 83 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT, 84 "rport terminate: sid:x%x did:x%x flg:x%x", 85 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag); 86 87 if (ndlp->nlp_sid != NLP_NO_SID) { 88 lpfc_sli_abort_iocb(ndlp->vport, 89 &phba->sli.ring[phba->sli.fcp_ring], 90 ndlp->nlp_sid, 0, LPFC_CTX_TGT); 91 } 92} 93 94/* 95 * This function will be called when dev_loss_tmo fire. 96 */ 97void 98lpfc_dev_loss_tmo_callbk(struct fc_rport *rport) 99{ 100 struct lpfc_rport_data *rdata; 101 struct lpfc_nodelist * ndlp; 102 struct lpfc_vport *vport; 103 struct lpfc_hba *phba; 104 struct lpfc_work_evt *evtp; 105 int put_node; 106 int put_rport; 107 108 rdata = rport->dd_data; 109 ndlp = rdata->pnode; 110 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) 111 return; 112 113 vport = ndlp->vport; 114 phba = vport->phba; 115 116 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT, 117 "rport devlosscb: sid:x%x did:x%x flg:x%x", 118 ndlp->nlp_sid, ndlp->nlp_DID, ndlp->nlp_flag); 119 120 /* Don't defer this if we are in the process of deleting the vport 121 * or unloading the driver. The unload will cleanup the node 122 * appropriately we just need to cleanup the ndlp rport info here. 123 */ 124 if (vport->load_flag & FC_UNLOADING) { 125 put_node = rdata->pnode != NULL; 126 put_rport = ndlp->rport != NULL; 127 rdata->pnode = NULL; 128 ndlp->rport = NULL; 129 if (put_node) 130 lpfc_nlp_put(ndlp); 131 if (put_rport) 132 put_device(&rport->dev); 133 return; 134 } 135 136 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) 137 return; 138 139 evtp = &ndlp->dev_loss_evt; 140 141 if (!list_empty(&evtp->evt_listp)) 142 return; 143 144 spin_lock_irq(&phba->hbalock); 145 /* We need to hold the node by incrementing the reference 146 * count until this queued work is done 147 */ 148 evtp->evt_arg1 = lpfc_nlp_get(ndlp); 149 if (evtp->evt_arg1) { 150 evtp->evt = LPFC_EVT_DEV_LOSS; 151 list_add_tail(&evtp->evt_listp, &phba->work_list); 152 lpfc_worker_wake_up(phba); 153 } 154 spin_unlock_irq(&phba->hbalock); 155 156 return; 157} 158 159/* 160 * This function is called from the worker thread when dev_loss_tmo 161 * expire. 162 */ 163static void 164lpfc_dev_loss_tmo_handler(struct lpfc_nodelist *ndlp) 165{ 166 struct lpfc_rport_data *rdata; 167 struct fc_rport *rport; 168 struct lpfc_vport *vport; 169 struct lpfc_hba *phba; 170 uint8_t *name; 171 int put_node; 172 int put_rport; 173 int warn_on = 0; 174 175 rport = ndlp->rport; 176 177 if (!rport) 178 return; 179 180 rdata = rport->dd_data; 181 name = (uint8_t *) &ndlp->nlp_portname; 182 vport = ndlp->vport; 183 phba = vport->phba; 184 185 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT, 186 "rport devlosstmo:did:x%x type:x%x id:x%x", 187 ndlp->nlp_DID, ndlp->nlp_type, rport->scsi_target_id); 188 189 /* Don't defer this if we are in the process of deleting the vport 190 * or unloading the driver. The unload will cleanup the node 191 * appropriately we just need to cleanup the ndlp rport info here. 192 */ 193 if (vport->load_flag & FC_UNLOADING) { 194 if (ndlp->nlp_sid != NLP_NO_SID) { 195 /* flush the target */ 196 lpfc_sli_abort_iocb(vport, 197 &phba->sli.ring[phba->sli.fcp_ring], 198 ndlp->nlp_sid, 0, LPFC_CTX_TGT); 199 } 200 put_node = rdata->pnode != NULL; 201 put_rport = ndlp->rport != NULL; 202 rdata->pnode = NULL; 203 ndlp->rport = NULL; 204 if (put_node) 205 lpfc_nlp_put(ndlp); 206 if (put_rport) 207 put_device(&rport->dev); 208 return; 209 } 210 211 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) { 212 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 213 "0284 Devloss timeout Ignored on " 214 "WWPN %x:%x:%x:%x:%x:%x:%x:%x " 215 "NPort x%x\n", 216 *name, *(name+1), *(name+2), *(name+3), 217 *(name+4), *(name+5), *(name+6), *(name+7), 218 ndlp->nlp_DID); 219 return; 220 } 221 222 if (ndlp->nlp_type & NLP_FABRIC) { 223 /* We will clean up these Nodes in linkup */ 224 put_node = rdata->pnode != NULL; 225 put_rport = ndlp->rport != NULL; 226 rdata->pnode = NULL; 227 ndlp->rport = NULL; 228 if (put_node) 229 lpfc_nlp_put(ndlp); 230 if (put_rport) 231 put_device(&rport->dev); 232 return; 233 } 234 235 if (ndlp->nlp_sid != NLP_NO_SID) { 236 warn_on = 1; 237 /* flush the target */ 238 lpfc_sli_abort_iocb(vport, &phba->sli.ring[phba->sli.fcp_ring], 239 ndlp->nlp_sid, 0, LPFC_CTX_TGT); 240 } 241 242 if (warn_on) { 243 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 244 "0203 Devloss timeout on " 245 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x " 246 "NPort x%06x Data: x%x x%x x%x\n", 247 *name, *(name+1), *(name+2), *(name+3), 248 *(name+4), *(name+5), *(name+6), *(name+7), 249 ndlp->nlp_DID, ndlp->nlp_flag, 250 ndlp->nlp_state, ndlp->nlp_rpi); 251 } else { 252 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 253 "0204 Devloss timeout on " 254 "WWPN %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x " 255 "NPort x%06x Data: x%x x%x x%x\n", 256 *name, *(name+1), *(name+2), *(name+3), 257 *(name+4), *(name+5), *(name+6), *(name+7), 258 ndlp->nlp_DID, ndlp->nlp_flag, 259 ndlp->nlp_state, ndlp->nlp_rpi); 260 } 261 262 put_node = rdata->pnode != NULL; 263 put_rport = ndlp->rport != NULL; 264 rdata->pnode = NULL; 265 ndlp->rport = NULL; 266 if (put_node) 267 lpfc_nlp_put(ndlp); 268 if (put_rport) 269 put_device(&rport->dev); 270 271 if (!(vport->load_flag & FC_UNLOADING) && 272 !(ndlp->nlp_flag & NLP_DELAY_TMO) && 273 !(ndlp->nlp_flag & NLP_NPR_2B_DISC) && 274 (ndlp->nlp_state != NLP_STE_UNMAPPED_NODE)) 275 lpfc_disc_state_machine(vport, ndlp, NULL, NLP_EVT_DEVICE_RM); 276} 277 278/** 279 * lpfc_alloc_fast_evt: Allocates data structure for posting event. 280 * @phba: Pointer to hba context object. 281 * 282 * This function is called from the functions which need to post 283 * events from interrupt context. This function allocates data 284 * structure required for posting event. It also keeps track of 285 * number of events pending and prevent event storm when there are 286 * too many events. 287 **/ 288struct lpfc_fast_path_event * 289lpfc_alloc_fast_evt(struct lpfc_hba *phba) { 290 struct lpfc_fast_path_event *ret; 291 292 /* If there are lot of fast event do not exhaust memory due to this */ 293 if (atomic_read(&phba->fast_event_count) > LPFC_MAX_EVT_COUNT) 294 return NULL; 295 296 ret = kzalloc(sizeof(struct lpfc_fast_path_event), 297 GFP_ATOMIC); 298 if (ret) 299 atomic_inc(&phba->fast_event_count); 300 INIT_LIST_HEAD(&ret->work_evt.evt_listp); 301 ret->work_evt.evt = LPFC_EVT_FASTPATH_MGMT_EVT; 302 return ret; 303} 304 305/** 306 * lpfc_free_fast_evt: Frees event data structure. 307 * @phba: Pointer to hba context object. 308 * @evt: Event object which need to be freed. 309 * 310 * This function frees the data structure required for posting 311 * events. 312 **/ 313void 314lpfc_free_fast_evt(struct lpfc_hba *phba, 315 struct lpfc_fast_path_event *evt) { 316 317 atomic_dec(&phba->fast_event_count); 318 kfree(evt); 319} 320 321/** 322 * lpfc_send_fastpath_evt: Posts events generated from fast path. 323 * @phba: Pointer to hba context object. 324 * @evtp: Event data structure. 325 * 326 * This function is called from worker thread, when the interrupt 327 * context need to post an event. This function posts the event 328 * to fc transport netlink interface. 329 **/ 330static void 331lpfc_send_fastpath_evt(struct lpfc_hba *phba, 332 struct lpfc_work_evt *evtp) 333{ 334 unsigned long evt_category, evt_sub_category; 335 struct lpfc_fast_path_event *fast_evt_data; 336 char *evt_data; 337 uint32_t evt_data_size; 338 struct Scsi_Host *shost; 339 340 fast_evt_data = container_of(evtp, struct lpfc_fast_path_event, 341 work_evt); 342 343 evt_category = (unsigned long) fast_evt_data->un.fabric_evt.event_type; 344 evt_sub_category = (unsigned long) fast_evt_data->un. 345 fabric_evt.subcategory; 346 shost = lpfc_shost_from_vport(fast_evt_data->vport); 347 if (evt_category == FC_REG_FABRIC_EVENT) { 348 if (evt_sub_category == LPFC_EVENT_FCPRDCHKERR) { 349 evt_data = (char *) &fast_evt_data->un.read_check_error; 350 evt_data_size = sizeof(fast_evt_data->un. 351 read_check_error); 352 } else if ((evt_sub_category == LPFC_EVENT_FABRIC_BUSY) || 353 (evt_sub_category == IOSTAT_NPORT_BSY)) { 354 evt_data = (char *) &fast_evt_data->un.fabric_evt; 355 evt_data_size = sizeof(fast_evt_data->un.fabric_evt); 356 } else { 357 lpfc_free_fast_evt(phba, fast_evt_data); 358 return; 359 } 360 } else if (evt_category == FC_REG_SCSI_EVENT) { 361 switch (evt_sub_category) { 362 case LPFC_EVENT_QFULL: 363 case LPFC_EVENT_DEVBSY: 364 evt_data = (char *) &fast_evt_data->un.scsi_evt; 365 evt_data_size = sizeof(fast_evt_data->un.scsi_evt); 366 break; 367 case LPFC_EVENT_CHECK_COND: 368 evt_data = (char *) &fast_evt_data->un.check_cond_evt; 369 evt_data_size = sizeof(fast_evt_data->un. 370 check_cond_evt); 371 break; 372 case LPFC_EVENT_VARQUEDEPTH: 373 evt_data = (char *) &fast_evt_data->un.queue_depth_evt; 374 evt_data_size = sizeof(fast_evt_data->un. 375 queue_depth_evt); 376 break; 377 default: 378 lpfc_free_fast_evt(phba, fast_evt_data); 379 return; 380 } 381 } else { 382 lpfc_free_fast_evt(phba, fast_evt_data); 383 return; 384 } 385 386 fc_host_post_vendor_event(shost, 387 fc_get_event_number(), 388 evt_data_size, 389 evt_data, 390 SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX); 391 392 lpfc_free_fast_evt(phba, fast_evt_data); 393 return; 394} 395 396static void 397lpfc_work_list_done(struct lpfc_hba *phba) 398{ 399 struct lpfc_work_evt *evtp = NULL; 400 struct lpfc_nodelist *ndlp; 401 int free_evt; 402 403 spin_lock_irq(&phba->hbalock); 404 while (!list_empty(&phba->work_list)) { 405 list_remove_head((&phba->work_list), evtp, typeof(*evtp), 406 evt_listp); 407 spin_unlock_irq(&phba->hbalock); 408 free_evt = 1; 409 switch (evtp->evt) { 410 case LPFC_EVT_ELS_RETRY: 411 ndlp = (struct lpfc_nodelist *) (evtp->evt_arg1); 412 lpfc_els_retry_delay_handler(ndlp); 413 free_evt = 0; /* evt is part of ndlp */ 414 /* decrement the node reference count held 415 * for this queued work 416 */ 417 lpfc_nlp_put(ndlp); 418 break; 419 case LPFC_EVT_DEV_LOSS: 420 ndlp = (struct lpfc_nodelist *)(evtp->evt_arg1); 421 lpfc_dev_loss_tmo_handler(ndlp); 422 free_evt = 0; 423 /* decrement the node reference count held for 424 * this queued work 425 */ 426 lpfc_nlp_put(ndlp); 427 break; 428 case LPFC_EVT_ONLINE: 429 if (phba->link_state < LPFC_LINK_DOWN) 430 *(int *) (evtp->evt_arg1) = lpfc_online(phba); 431 else 432 *(int *) (evtp->evt_arg1) = 0; 433 complete((struct completion *)(evtp->evt_arg2)); 434 break; 435 case LPFC_EVT_OFFLINE_PREP: 436 if (phba->link_state >= LPFC_LINK_DOWN) 437 lpfc_offline_prep(phba); 438 *(int *)(evtp->evt_arg1) = 0; 439 complete((struct completion *)(evtp->evt_arg2)); 440 break; 441 case LPFC_EVT_OFFLINE: 442 lpfc_offline(phba); 443 lpfc_sli_brdrestart(phba); 444 *(int *)(evtp->evt_arg1) = 445 lpfc_sli_brdready(phba, HS_FFRDY | HS_MBRDY); 446 lpfc_unblock_mgmt_io(phba); 447 complete((struct completion *)(evtp->evt_arg2)); 448 break; 449 case LPFC_EVT_WARM_START: 450 lpfc_offline(phba); 451 lpfc_reset_barrier(phba); 452 lpfc_sli_brdreset(phba); 453 lpfc_hba_down_post(phba); 454 *(int *)(evtp->evt_arg1) = 455 lpfc_sli_brdready(phba, HS_MBRDY); 456 lpfc_unblock_mgmt_io(phba); 457 complete((struct completion *)(evtp->evt_arg2)); 458 break; 459 case LPFC_EVT_KILL: 460 lpfc_offline(phba); 461 *(int *)(evtp->evt_arg1) 462 = (phba->pport->stopped) 463 ? 0 : lpfc_sli_brdkill(phba); 464 lpfc_unblock_mgmt_io(phba); 465 complete((struct completion *)(evtp->evt_arg2)); 466 break; 467 case LPFC_EVT_FASTPATH_MGMT_EVT: 468 lpfc_send_fastpath_evt(phba, evtp); 469 free_evt = 0; 470 break; 471 } 472 if (free_evt) 473 kfree(evtp); 474 spin_lock_irq(&phba->hbalock); 475 } 476 spin_unlock_irq(&phba->hbalock); 477 478} 479 480static void 481lpfc_work_done(struct lpfc_hba *phba) 482{ 483 struct lpfc_sli_ring *pring; 484 uint32_t ha_copy, status, control, work_port_events; 485 struct lpfc_vport **vports; 486 struct lpfc_vport *vport; 487 int i; 488 489 spin_lock_irq(&phba->hbalock); 490 ha_copy = phba->work_ha; 491 phba->work_ha = 0; 492 spin_unlock_irq(&phba->hbalock); 493 494 if (ha_copy & HA_ERATT) 495 /* Handle the error attention event */ 496 lpfc_handle_eratt(phba); 497 498 if (ha_copy & HA_MBATT) 499 lpfc_sli_handle_mb_event(phba); 500 501 if (ha_copy & HA_LATT) 502 lpfc_handle_latt(phba); 503 504 vports = lpfc_create_vport_work_array(phba); 505 if (vports != NULL) 506 for(i = 0; i <= phba->max_vpi; i++) { 507 /* 508 * We could have no vports in array if unloading, so if 509 * this happens then just use the pport 510 */ 511 if (vports[i] == NULL && i == 0) 512 vport = phba->pport; 513 else 514 vport = vports[i]; 515 if (vport == NULL) 516 break; 517 spin_lock_irq(&vport->work_port_lock); 518 work_port_events = vport->work_port_events; 519 vport->work_port_events &= ~work_port_events; 520 spin_unlock_irq(&vport->work_port_lock); 521 if (work_port_events & WORKER_DISC_TMO) 522 lpfc_disc_timeout_handler(vport); 523 if (work_port_events & WORKER_ELS_TMO) 524 lpfc_els_timeout_handler(vport); 525 if (work_port_events & WORKER_HB_TMO) 526 lpfc_hb_timeout_handler(phba); 527 if (work_port_events & WORKER_MBOX_TMO) 528 lpfc_mbox_timeout_handler(phba); 529 if (work_port_events & WORKER_FABRIC_BLOCK_TMO) 530 lpfc_unblock_fabric_iocbs(phba); 531 if (work_port_events & WORKER_FDMI_TMO) 532 lpfc_fdmi_timeout_handler(vport); 533 if (work_port_events & WORKER_RAMP_DOWN_QUEUE) 534 lpfc_ramp_down_queue_handler(phba); 535 if (work_port_events & WORKER_RAMP_UP_QUEUE) 536 lpfc_ramp_up_queue_handler(phba); 537 } 538 lpfc_destroy_vport_work_array(phba, vports); 539 540 pring = &phba->sli.ring[LPFC_ELS_RING]; 541 status = (ha_copy & (HA_RXMASK << (4*LPFC_ELS_RING))); 542 status >>= (4*LPFC_ELS_RING); 543 if ((status & HA_RXMASK) 544 || (pring->flag & LPFC_DEFERRED_RING_EVENT)) { 545 if (pring->flag & LPFC_STOP_IOCB_EVENT) { 546 pring->flag |= LPFC_DEFERRED_RING_EVENT; 547 /* Set the lpfc data pending flag */ 548 set_bit(LPFC_DATA_READY, &phba->data_flags); 549 } else { 550 pring->flag &= ~LPFC_DEFERRED_RING_EVENT; 551 lpfc_sli_handle_slow_ring_event(phba, pring, 552 (status & 553 HA_RXMASK)); 554 } 555 /* 556 * Turn on Ring interrupts 557 */ 558 spin_lock_irq(&phba->hbalock); 559 control = readl(phba->HCregaddr); 560 if (!(control & (HC_R0INT_ENA << LPFC_ELS_RING))) { 561 lpfc_debugfs_slow_ring_trc(phba, 562 "WRK Enable ring: cntl:x%x hacopy:x%x", 563 control, ha_copy, 0); 564 565 control |= (HC_R0INT_ENA << LPFC_ELS_RING); 566 writel(control, phba->HCregaddr); 567 readl(phba->HCregaddr); /* flush */ 568 } 569 else { 570 lpfc_debugfs_slow_ring_trc(phba, 571 "WRK Ring ok: cntl:x%x hacopy:x%x", 572 control, ha_copy, 0); 573 } 574 spin_unlock_irq(&phba->hbalock); 575 } 576 lpfc_work_list_done(phba); 577} 578 579int 580lpfc_do_work(void *p) 581{ 582 struct lpfc_hba *phba = p; 583 int rc; 584 585 set_user_nice(current, -20); 586 phba->data_flags = 0; 587 588 while (1) { 589 /* wait and check worker queue activities */ 590 rc = wait_event_interruptible(phba->work_waitq, 591 (test_and_clear_bit(LPFC_DATA_READY, 592 &phba->data_flags) 593 || kthread_should_stop())); 594 BUG_ON(rc); 595 596 if (kthread_should_stop()) 597 break; 598 599 /* Attend pending lpfc data processing */ 600 lpfc_work_done(phba); 601 } 602 return 0; 603} 604 605/* 606 * This is only called to handle FC worker events. Since this a rare 607 * occurance, we allocate a struct lpfc_work_evt structure here instead of 608 * embedding it in the IOCB. 609 */ 610int 611lpfc_workq_post_event(struct lpfc_hba *phba, void *arg1, void *arg2, 612 uint32_t evt) 613{ 614 struct lpfc_work_evt *evtp; 615 unsigned long flags; 616 617 /* 618 * All Mailbox completions and LPFC_ELS_RING rcv ring IOCB events will 619 * be queued to worker thread for processing 620 */ 621 evtp = kmalloc(sizeof(struct lpfc_work_evt), GFP_ATOMIC); 622 if (!evtp) 623 return 0; 624 625 evtp->evt_arg1 = arg1; 626 evtp->evt_arg2 = arg2; 627 evtp->evt = evt; 628 629 spin_lock_irqsave(&phba->hbalock, flags); 630 list_add_tail(&evtp->evt_listp, &phba->work_list); 631 spin_unlock_irqrestore(&phba->hbalock, flags); 632 633 lpfc_worker_wake_up(phba); 634 635 return 1; 636} 637 638void 639lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove) 640{ 641 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 642 struct lpfc_hba *phba = vport->phba; 643 struct lpfc_nodelist *ndlp, *next_ndlp; 644 int rc; 645 646 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) { 647 if (!NLP_CHK_NODE_ACT(ndlp)) 648 continue; 649 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 650 continue; 651 if ((phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) || 652 ((vport->port_type == LPFC_NPIV_PORT) && 653 (ndlp->nlp_DID == NameServer_DID))) 654 lpfc_unreg_rpi(vport, ndlp); 655 656 /* Leave Fabric nodes alone on link down */ 657 if (!remove && ndlp->nlp_type & NLP_FABRIC) 658 continue; 659 rc = lpfc_disc_state_machine(vport, ndlp, NULL, 660 remove 661 ? NLP_EVT_DEVICE_RM 662 : NLP_EVT_DEVICE_RECOVERY); 663 } 664 if (phba->sli3_options & LPFC_SLI3_VPORT_TEARDOWN) { 665 lpfc_mbx_unreg_vpi(vport); 666 spin_lock_irq(shost->host_lock); 667 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI; 668 spin_unlock_irq(shost->host_lock); 669 } 670} 671 672void 673lpfc_port_link_failure(struct lpfc_vport *vport) 674{ 675 /* Cleanup any outstanding RSCN activity */ 676 lpfc_els_flush_rscn(vport); 677 678 /* Cleanup any outstanding ELS commands */ 679 lpfc_els_flush_cmd(vport); 680 681 lpfc_cleanup_rpis(vport, 0); 682 683 /* Turn off discovery timer if its running */ 684 lpfc_can_disctmo(vport); 685} 686 687static void 688lpfc_linkdown_port(struct lpfc_vport *vport) 689{ 690 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 691 692 fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKDOWN, 0); 693 694 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, 695 "Link Down: state:x%x rtry:x%x flg:x%x", 696 vport->port_state, vport->fc_ns_retry, vport->fc_flag); 697 698 lpfc_port_link_failure(vport); 699 700} 701 702int 703lpfc_linkdown(struct lpfc_hba *phba) 704{ 705 struct lpfc_vport *vport = phba->pport; 706 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 707 struct lpfc_vport **vports; 708 LPFC_MBOXQ_t *mb; 709 int i; 710 711 if (phba->link_state == LPFC_LINK_DOWN) 712 return 0; 713 spin_lock_irq(&phba->hbalock); 714 if (phba->link_state > LPFC_LINK_DOWN) { 715 phba->link_state = LPFC_LINK_DOWN; 716 phba->pport->fc_flag &= ~FC_LBIT; 717 } 718 spin_unlock_irq(&phba->hbalock); 719 vports = lpfc_create_vport_work_array(phba); 720 if (vports != NULL) 721 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) { 722 /* Issue a LINK DOWN event to all nodes */ 723 lpfc_linkdown_port(vports[i]); 724 } 725 lpfc_destroy_vport_work_array(phba, vports); 726 /* Clean up any firmware default rpi's */ 727 mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 728 if (mb) { 729 lpfc_unreg_did(phba, 0xffff, 0xffffffff, mb); 730 mb->vport = vport; 731 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 732 if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT) 733 == MBX_NOT_FINISHED) { 734 mempool_free(mb, phba->mbox_mem_pool); 735 } 736 } 737 738 /* Setup myDID for link up if we are in pt2pt mode */ 739 if (phba->pport->fc_flag & FC_PT2PT) { 740 phba->pport->fc_myDID = 0; 741 mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 742 if (mb) { 743 lpfc_config_link(phba, mb); 744 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 745 mb->vport = vport; 746 if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT) 747 == MBX_NOT_FINISHED) { 748 mempool_free(mb, phba->mbox_mem_pool); 749 } 750 } 751 spin_lock_irq(shost->host_lock); 752 phba->pport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI); 753 spin_unlock_irq(shost->host_lock); 754 } 755 756 return 0; 757} 758 759static void 760lpfc_linkup_cleanup_nodes(struct lpfc_vport *vport) 761{ 762 struct lpfc_nodelist *ndlp; 763 764 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 765 if (!NLP_CHK_NODE_ACT(ndlp)) 766 continue; 767 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 768 continue; 769 if (ndlp->nlp_type & NLP_FABRIC) { 770 /* On Linkup its safe to clean up the ndlp 771 * from Fabric connections. 772 */ 773 if (ndlp->nlp_DID != Fabric_DID) 774 lpfc_unreg_rpi(vport, ndlp); 775 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 776 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) { 777 /* Fail outstanding IO now since device is 778 * marked for PLOGI. 779 */ 780 lpfc_unreg_rpi(vport, ndlp); 781 } 782 } 783} 784 785static void 786lpfc_linkup_port(struct lpfc_vport *vport) 787{ 788 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 789 struct lpfc_hba *phba = vport->phba; 790 791 if ((vport->load_flag & FC_UNLOADING) != 0) 792 return; 793 794 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, 795 "Link Up: top:x%x speed:x%x flg:x%x", 796 phba->fc_topology, phba->fc_linkspeed, phba->link_flag); 797 798 /* If NPIV is not enabled, only bring the physical port up */ 799 if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) && 800 (vport != phba->pport)) 801 return; 802 803 fc_host_post_event(shost, fc_get_event_number(), FCH_EVT_LINKUP, 0); 804 805 spin_lock_irq(shost->host_lock); 806 vport->fc_flag &= ~(FC_PT2PT | FC_PT2PT_PLOGI | FC_ABORT_DISCOVERY | 807 FC_RSCN_MODE | FC_NLP_MORE | FC_RSCN_DISCOVERY); 808 vport->fc_flag |= FC_NDISC_ACTIVE; 809 vport->fc_ns_retry = 0; 810 spin_unlock_irq(shost->host_lock); 811 812 if (vport->fc_flag & FC_LBIT) 813 lpfc_linkup_cleanup_nodes(vport); 814 815} 816 817static int 818lpfc_linkup(struct lpfc_hba *phba) 819{ 820 struct lpfc_vport **vports; 821 int i; 822 823 phba->link_state = LPFC_LINK_UP; 824 825 /* Unblock fabric iocbs if they are blocked */ 826 clear_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags); 827 del_timer_sync(&phba->fabric_block_timer); 828 829 vports = lpfc_create_vport_work_array(phba); 830 if (vports != NULL) 831 for(i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) 832 lpfc_linkup_port(vports[i]); 833 lpfc_destroy_vport_work_array(phba, vports); 834 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 835 lpfc_issue_clear_la(phba, phba->pport); 836 837 return 0; 838} 839 840/* 841 * This routine handles processing a CLEAR_LA mailbox 842 * command upon completion. It is setup in the LPFC_MBOXQ 843 * as the completion routine when the command is 844 * handed off to the SLI layer. 845 */ 846static void 847lpfc_mbx_cmpl_clear_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 848{ 849 struct lpfc_vport *vport = pmb->vport; 850 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 851 struct lpfc_sli *psli = &phba->sli; 852 MAILBOX_t *mb = &pmb->mb; 853 uint32_t control; 854 855 /* Since we don't do discovery right now, turn these off here */ 856 psli->ring[psli->extra_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 857 psli->ring[psli->fcp_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 858 psli->ring[psli->next_ring].flag &= ~LPFC_STOP_IOCB_EVENT; 859 860 /* Check for error */ 861 if ((mb->mbxStatus) && (mb->mbxStatus != 0x1601)) { 862 /* CLEAR_LA mbox error <mbxStatus> state <hba_state> */ 863 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 864 "0320 CLEAR_LA mbxStatus error x%x hba " 865 "state x%x\n", 866 mb->mbxStatus, vport->port_state); 867 phba->link_state = LPFC_HBA_ERROR; 868 goto out; 869 } 870 871 if (vport->port_type == LPFC_PHYSICAL_PORT) 872 phba->link_state = LPFC_HBA_READY; 873 874 spin_lock_irq(&phba->hbalock); 875 psli->sli_flag |= LPFC_PROCESS_LA; 876 control = readl(phba->HCregaddr); 877 control |= HC_LAINT_ENA; 878 writel(control, phba->HCregaddr); 879 readl(phba->HCregaddr); /* flush */ 880 spin_unlock_irq(&phba->hbalock); 881 mempool_free(pmb, phba->mbox_mem_pool); 882 return; 883 884out: 885 /* Device Discovery completes */ 886 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 887 "0225 Device Discovery completes\n"); 888 mempool_free(pmb, phba->mbox_mem_pool); 889 890 spin_lock_irq(shost->host_lock); 891 vport->fc_flag &= ~FC_ABORT_DISCOVERY; 892 spin_unlock_irq(shost->host_lock); 893 894 lpfc_can_disctmo(vport); 895 896 /* turn on Link Attention interrupts */ 897 898 spin_lock_irq(&phba->hbalock); 899 psli->sli_flag |= LPFC_PROCESS_LA; 900 control = readl(phba->HCregaddr); 901 control |= HC_LAINT_ENA; 902 writel(control, phba->HCregaddr); 903 readl(phba->HCregaddr); /* flush */ 904 spin_unlock_irq(&phba->hbalock); 905 906 return; 907} 908 909 910static void 911lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 912{ 913 struct lpfc_vport *vport = pmb->vport; 914 915 if (pmb->mb.mbxStatus) 916 goto out; 917 918 mempool_free(pmb, phba->mbox_mem_pool); 919 920 if (phba->fc_topology == TOPOLOGY_LOOP && 921 vport->fc_flag & FC_PUBLIC_LOOP && 922 !(vport->fc_flag & FC_LBIT)) { 923 /* Need to wait for FAN - use discovery timer 924 * for timeout. port_state is identically 925 * LPFC_LOCAL_CFG_LINK while waiting for FAN 926 */ 927 lpfc_set_disctmo(vport); 928 return; 929 } 930 931 /* Start discovery by sending a FLOGI. port_state is identically 932 * LPFC_FLOGI while waiting for FLOGI cmpl 933 */ 934 if (vport->port_state != LPFC_FLOGI) { 935 lpfc_initial_flogi(vport); 936 } 937 return; 938 939out: 940 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 941 "0306 CONFIG_LINK mbxStatus error x%x " 942 "HBA state x%x\n", 943 pmb->mb.mbxStatus, vport->port_state); 944 mempool_free(pmb, phba->mbox_mem_pool); 945 946 lpfc_linkdown(phba); 947 948 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 949 "0200 CONFIG_LINK bad hba state x%x\n", 950 vport->port_state); 951 952 lpfc_issue_clear_la(phba, vport); 953 return; 954} 955 956static void 957lpfc_mbx_cmpl_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 958{ 959 MAILBOX_t *mb = &pmb->mb; 960 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) pmb->context1; 961 struct lpfc_vport *vport = pmb->vport; 962 963 964 /* Check for error */ 965 if (mb->mbxStatus) { 966 /* READ_SPARAM mbox error <mbxStatus> state <hba_state> */ 967 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 968 "0319 READ_SPARAM mbxStatus error x%x " 969 "hba state x%x>\n", 970 mb->mbxStatus, vport->port_state); 971 lpfc_linkdown(phba); 972 goto out; 973 } 974 975 memcpy((uint8_t *) &vport->fc_sparam, (uint8_t *) mp->virt, 976 sizeof (struct serv_parm)); 977 if (phba->cfg_soft_wwnn) 978 u64_to_wwn(phba->cfg_soft_wwnn, 979 vport->fc_sparam.nodeName.u.wwn); 980 if (phba->cfg_soft_wwpn) 981 u64_to_wwn(phba->cfg_soft_wwpn, 982 vport->fc_sparam.portName.u.wwn); 983 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName, 984 sizeof(vport->fc_nodename)); 985 memcpy(&vport->fc_portname, &vport->fc_sparam.portName, 986 sizeof(vport->fc_portname)); 987 if (vport->port_type == LPFC_PHYSICAL_PORT) { 988 memcpy(&phba->wwnn, &vport->fc_nodename, sizeof(phba->wwnn)); 989 memcpy(&phba->wwpn, &vport->fc_portname, sizeof(phba->wwnn)); 990 } 991 992 lpfc_mbuf_free(phba, mp->virt, mp->phys); 993 kfree(mp); 994 mempool_free(pmb, phba->mbox_mem_pool); 995 return; 996 997out: 998 pmb->context1 = NULL; 999 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1000 kfree(mp); 1001 lpfc_issue_clear_la(phba, vport); 1002 mempool_free(pmb, phba->mbox_mem_pool); 1003 return; 1004} 1005 1006static void 1007lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la) 1008{ 1009 struct lpfc_vport *vport = phba->pport; 1010 LPFC_MBOXQ_t *sparam_mbox, *cfglink_mbox; 1011 int i; 1012 struct lpfc_dmabuf *mp; 1013 int rc; 1014 1015 sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1016 cfglink_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1017 1018 spin_lock_irq(&phba->hbalock); 1019 switch (la->UlnkSpeed) { 1020 case LA_1GHZ_LINK: 1021 phba->fc_linkspeed = LA_1GHZ_LINK; 1022 break; 1023 case LA_2GHZ_LINK: 1024 phba->fc_linkspeed = LA_2GHZ_LINK; 1025 break; 1026 case LA_4GHZ_LINK: 1027 phba->fc_linkspeed = LA_4GHZ_LINK; 1028 break; 1029 case LA_8GHZ_LINK: 1030 phba->fc_linkspeed = LA_8GHZ_LINK; 1031 break; 1032 default: 1033 phba->fc_linkspeed = LA_UNKNW_LINK; 1034 break; 1035 } 1036 1037 phba->fc_topology = la->topology; 1038 phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED; 1039 1040 if (phba->fc_topology == TOPOLOGY_LOOP) { 1041 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED; 1042 1043 if (phba->cfg_enable_npiv) 1044 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1045 "1309 Link Up Event npiv not supported in loop " 1046 "topology\n"); 1047 /* Get Loop Map information */ 1048 if (la->il) 1049 vport->fc_flag |= FC_LBIT; 1050 1051 vport->fc_myDID = la->granted_AL_PA; 1052 i = la->un.lilpBde64.tus.f.bdeSize; 1053 1054 if (i == 0) { 1055 phba->alpa_map[0] = 0; 1056 } else { 1057 if (vport->cfg_log_verbose & LOG_LINK_EVENT) { 1058 int numalpa, j, k; 1059 union { 1060 uint8_t pamap[16]; 1061 struct { 1062 uint32_t wd1; 1063 uint32_t wd2; 1064 uint32_t wd3; 1065 uint32_t wd4; 1066 } pa; 1067 } un; 1068 numalpa = phba->alpa_map[0]; 1069 j = 0; 1070 while (j < numalpa) { 1071 memset(un.pamap, 0, 16); 1072 for (k = 1; j < numalpa; k++) { 1073 un.pamap[k - 1] = 1074 phba->alpa_map[j + 1]; 1075 j++; 1076 if (k == 16) 1077 break; 1078 } 1079 /* Link Up Event ALPA map */ 1080 lpfc_printf_log(phba, 1081 KERN_WARNING, 1082 LOG_LINK_EVENT, 1083 "1304 Link Up Event " 1084 "ALPA map Data: x%x " 1085 "x%x x%x x%x\n", 1086 un.pa.wd1, un.pa.wd2, 1087 un.pa.wd3, un.pa.wd4); 1088 } 1089 } 1090 } 1091 } else { 1092 if (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) { 1093 if (phba->max_vpi && phba->cfg_enable_npiv && 1094 (phba->sli_rev == 3)) 1095 phba->sli3_options |= LPFC_SLI3_NPIV_ENABLED; 1096 } 1097 vport->fc_myDID = phba->fc_pref_DID; 1098 vport->fc_flag |= FC_LBIT; 1099 } 1100 spin_unlock_irq(&phba->hbalock); 1101 1102 lpfc_linkup(phba); 1103 if (sparam_mbox) { 1104 lpfc_read_sparam(phba, sparam_mbox, 0); 1105 sparam_mbox->vport = vport; 1106 sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam; 1107 rc = lpfc_sli_issue_mbox(phba, sparam_mbox, MBX_NOWAIT); 1108 if (rc == MBX_NOT_FINISHED) { 1109 mp = (struct lpfc_dmabuf *) sparam_mbox->context1; 1110 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1111 kfree(mp); 1112 mempool_free(sparam_mbox, phba->mbox_mem_pool); 1113 if (cfglink_mbox) 1114 mempool_free(cfglink_mbox, phba->mbox_mem_pool); 1115 goto out; 1116 } 1117 } 1118 1119 if (cfglink_mbox) { 1120 vport->port_state = LPFC_LOCAL_CFG_LINK; 1121 lpfc_config_link(phba, cfglink_mbox); 1122 cfglink_mbox->vport = vport; 1123 cfglink_mbox->mbox_cmpl = lpfc_mbx_cmpl_local_config_link; 1124 rc = lpfc_sli_issue_mbox(phba, cfglink_mbox, MBX_NOWAIT); 1125 if (rc != MBX_NOT_FINISHED) 1126 return; 1127 mempool_free(cfglink_mbox, phba->mbox_mem_pool); 1128 } 1129out: 1130 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1131 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 1132 "0263 Discovery Mailbox error: state: 0x%x : %p %p\n", 1133 vport->port_state, sparam_mbox, cfglink_mbox); 1134 lpfc_issue_clear_la(phba, vport); 1135 return; 1136} 1137 1138static void 1139lpfc_enable_la(struct lpfc_hba *phba) 1140{ 1141 uint32_t control; 1142 struct lpfc_sli *psli = &phba->sli; 1143 spin_lock_irq(&phba->hbalock); 1144 psli->sli_flag |= LPFC_PROCESS_LA; 1145 control = readl(phba->HCregaddr); 1146 control |= HC_LAINT_ENA; 1147 writel(control, phba->HCregaddr); 1148 readl(phba->HCregaddr); /* flush */ 1149 spin_unlock_irq(&phba->hbalock); 1150} 1151 1152static void 1153lpfc_mbx_issue_link_down(struct lpfc_hba *phba) 1154{ 1155 lpfc_linkdown(phba); 1156 lpfc_enable_la(phba); 1157 /* turn on Link Attention interrupts - no CLEAR_LA needed */ 1158} 1159 1160 1161/* 1162 * This routine handles processing a READ_LA mailbox 1163 * command upon completion. It is setup in the LPFC_MBOXQ 1164 * as the completion routine when the command is 1165 * handed off to the SLI layer. 1166 */ 1167void 1168lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1169{ 1170 struct lpfc_vport *vport = pmb->vport; 1171 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1172 READ_LA_VAR *la; 1173 MAILBOX_t *mb = &pmb->mb; 1174 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 1175 1176 /* Unblock ELS traffic */ 1177 phba->sli.ring[LPFC_ELS_RING].flag &= ~LPFC_STOP_IOCB_EVENT; 1178 /* Check for error */ 1179 if (mb->mbxStatus) { 1180 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT, 1181 "1307 READ_LA mbox error x%x state x%x\n", 1182 mb->mbxStatus, vport->port_state); 1183 lpfc_mbx_issue_link_down(phba); 1184 phba->link_state = LPFC_HBA_ERROR; 1185 goto lpfc_mbx_cmpl_read_la_free_mbuf; 1186 } 1187 1188 la = (READ_LA_VAR *) & pmb->mb.un.varReadLA; 1189 1190 memcpy(&phba->alpa_map[0], mp->virt, 128); 1191 1192 spin_lock_irq(shost->host_lock); 1193 if (la->pb) 1194 vport->fc_flag |= FC_BYPASSED_MODE; 1195 else 1196 vport->fc_flag &= ~FC_BYPASSED_MODE; 1197 spin_unlock_irq(shost->host_lock); 1198 1199 if (((phba->fc_eventTag + 1) < la->eventTag) || 1200 (phba->fc_eventTag == la->eventTag)) { 1201 phba->fc_stat.LinkMultiEvent++; 1202 if (la->attType == AT_LINK_UP) 1203 if (phba->fc_eventTag != 0) 1204 lpfc_linkdown(phba); 1205 } 1206 1207 phba->fc_eventTag = la->eventTag; 1208 if (la->mm) 1209 phba->sli.sli_flag |= LPFC_MENLO_MAINT; 1210 else 1211 phba->sli.sli_flag &= ~LPFC_MENLO_MAINT; 1212 1213 if (la->attType == AT_LINK_UP && (!la->mm)) { 1214 phba->fc_stat.LinkUp++; 1215 if (phba->link_flag & LS_LOOPBACK_MODE) { 1216 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1217 "1306 Link Up Event in loop back mode " 1218 "x%x received Data: x%x x%x x%x x%x\n", 1219 la->eventTag, phba->fc_eventTag, 1220 la->granted_AL_PA, la->UlnkSpeed, 1221 phba->alpa_map[0]); 1222 } else { 1223 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1224 "1303 Link Up Event x%x received " 1225 "Data: x%x x%x x%x x%x x%x x%x %d\n", 1226 la->eventTag, phba->fc_eventTag, 1227 la->granted_AL_PA, la->UlnkSpeed, 1228 phba->alpa_map[0], 1229 la->mm, la->fa, 1230 phba->wait_4_mlo_maint_flg); 1231 } 1232 lpfc_mbx_process_link_up(phba, la); 1233 } else if (la->attType == AT_LINK_DOWN) { 1234 phba->fc_stat.LinkDown++; 1235 if (phba->link_flag & LS_LOOPBACK_MODE) { 1236 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1237 "1308 Link Down Event in loop back mode " 1238 "x%x received " 1239 "Data: x%x x%x x%x\n", 1240 la->eventTag, phba->fc_eventTag, 1241 phba->pport->port_state, vport->fc_flag); 1242 } 1243 else { 1244 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1245 "1305 Link Down Event x%x received " 1246 "Data: x%x x%x x%x x%x x%x\n", 1247 la->eventTag, phba->fc_eventTag, 1248 phba->pport->port_state, vport->fc_flag, 1249 la->mm, la->fa); 1250 } 1251 lpfc_mbx_issue_link_down(phba); 1252 } 1253 if (la->mm && la->attType == AT_LINK_UP) { 1254 if (phba->link_state != LPFC_LINK_DOWN) { 1255 phba->fc_stat.LinkDown++; 1256 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1257 "1312 Link Down Event x%x received " 1258 "Data: x%x x%x x%x\n", 1259 la->eventTag, phba->fc_eventTag, 1260 phba->pport->port_state, vport->fc_flag); 1261 lpfc_mbx_issue_link_down(phba); 1262 } else 1263 lpfc_enable_la(phba); 1264 1265 lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT, 1266 "1310 Menlo Maint Mode Link up Event x%x rcvd " 1267 "Data: x%x x%x x%x\n", 1268 la->eventTag, phba->fc_eventTag, 1269 phba->pport->port_state, vport->fc_flag); 1270 /* 1271 * The cmnd that triggered this will be waiting for this 1272 * signal. 1273 */ 1274 /* WAKEUP for MENLO_SET_MODE or MENLO_RESET command. */ 1275 if (phba->wait_4_mlo_maint_flg) { 1276 phba->wait_4_mlo_maint_flg = 0; 1277 wake_up_interruptible(&phba->wait_4_mlo_m_q); 1278 } 1279 } 1280 1281 if (la->fa) { 1282 if (la->mm) 1283 lpfc_issue_clear_la(phba, vport); 1284 lpfc_printf_log(phba, KERN_INFO, LOG_LINK_EVENT, 1285 "1311 fa %d\n", la->fa); 1286 } 1287 1288lpfc_mbx_cmpl_read_la_free_mbuf: 1289 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1290 kfree(mp); 1291 mempool_free(pmb, phba->mbox_mem_pool); 1292 return; 1293} 1294 1295/* 1296 * This routine handles processing a REG_LOGIN mailbox 1297 * command upon completion. It is setup in the LPFC_MBOXQ 1298 * as the completion routine when the command is 1299 * handed off to the SLI layer. 1300 */ 1301void 1302lpfc_mbx_cmpl_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1303{ 1304 struct lpfc_vport *vport = pmb->vport; 1305 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 1306 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2; 1307 1308 pmb->context1 = NULL; 1309 1310 /* Good status, call state machine */ 1311 lpfc_disc_state_machine(vport, ndlp, pmb, NLP_EVT_CMPL_REG_LOGIN); 1312 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1313 kfree(mp); 1314 mempool_free(pmb, phba->mbox_mem_pool); 1315 /* decrement the node reference count held for this callback 1316 * function. 1317 */ 1318 lpfc_nlp_put(ndlp); 1319 1320 return; 1321} 1322 1323static void 1324lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1325{ 1326 MAILBOX_t *mb = &pmb->mb; 1327 struct lpfc_vport *vport = pmb->vport; 1328 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1329 1330 switch (mb->mbxStatus) { 1331 case 0x0011: 1332 case 0x0020: 1333 case 0x9700: 1334 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 1335 "0911 cmpl_unreg_vpi, mb status = 0x%x\n", 1336 mb->mbxStatus); 1337 break; 1338 } 1339 vport->unreg_vpi_cmpl = VPORT_OK; 1340 mempool_free(pmb, phba->mbox_mem_pool); 1341 /* 1342 * This shost reference might have been taken at the beginning of 1343 * lpfc_vport_delete() 1344 */ 1345 if (vport->load_flag & FC_UNLOADING) 1346 scsi_host_put(shost); 1347} 1348 1349int 1350lpfc_mbx_unreg_vpi(struct lpfc_vport *vport) 1351{ 1352 struct lpfc_hba *phba = vport->phba; 1353 LPFC_MBOXQ_t *mbox; 1354 int rc; 1355 1356 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 1357 if (!mbox) 1358 return 1; 1359 1360 lpfc_unreg_vpi(phba, vport->vpi, mbox); 1361 mbox->vport = vport; 1362 mbox->mbox_cmpl = lpfc_mbx_cmpl_unreg_vpi; 1363 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT); 1364 if (rc == MBX_NOT_FINISHED) { 1365 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT, 1366 "1800 Could not issue unreg_vpi\n"); 1367 mempool_free(mbox, phba->mbox_mem_pool); 1368 vport->unreg_vpi_cmpl = VPORT_ERROR; 1369 return rc; 1370 } 1371 return 0; 1372} 1373 1374static void 1375lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1376{ 1377 struct lpfc_vport *vport = pmb->vport; 1378 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1379 MAILBOX_t *mb = &pmb->mb; 1380 1381 switch (mb->mbxStatus) { 1382 case 0x0011: 1383 case 0x9601: 1384 case 0x9602: 1385 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 1386 "0912 cmpl_reg_vpi, mb status = 0x%x\n", 1387 mb->mbxStatus); 1388 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1389 spin_lock_irq(shost->host_lock); 1390 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP); 1391 spin_unlock_irq(shost->host_lock); 1392 vport->fc_myDID = 0; 1393 goto out; 1394 } 1395 1396 vport->num_disc_nodes = 0; 1397 /* go thru NPR list and issue ELS PLOGIs */ 1398 if (vport->fc_npr_cnt) 1399 lpfc_els_disc_plogi(vport); 1400 1401 if (!vport->num_disc_nodes) { 1402 spin_lock_irq(shost->host_lock); 1403 vport->fc_flag &= ~FC_NDISC_ACTIVE; 1404 spin_unlock_irq(shost->host_lock); 1405 lpfc_can_disctmo(vport); 1406 } 1407 vport->port_state = LPFC_VPORT_READY; 1408 1409out: 1410 mempool_free(pmb, phba->mbox_mem_pool); 1411 return; 1412} 1413 1414/* 1415 * This routine handles processing a Fabric REG_LOGIN mailbox 1416 * command upon completion. It is setup in the LPFC_MBOXQ 1417 * as the completion routine when the command is 1418 * handed off to the SLI layer. 1419 */ 1420void 1421lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1422{ 1423 struct lpfc_vport *vport = pmb->vport; 1424 MAILBOX_t *mb = &pmb->mb; 1425 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 1426 struct lpfc_nodelist *ndlp; 1427 struct lpfc_vport **vports; 1428 int i; 1429 1430 ndlp = (struct lpfc_nodelist *) pmb->context2; 1431 pmb->context1 = NULL; 1432 pmb->context2 = NULL; 1433 if (mb->mbxStatus) { 1434 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1435 kfree(mp); 1436 mempool_free(pmb, phba->mbox_mem_pool); 1437 1438 if (phba->fc_topology == TOPOLOGY_LOOP) { 1439 /* FLOGI failed, use loop map to make discovery list */ 1440 lpfc_disc_list_loopmap(vport); 1441 1442 /* Start discovery */ 1443 lpfc_disc_start(vport); 1444 /* Decrement the reference count to ndlp after the 1445 * reference to the ndlp are done. 1446 */ 1447 lpfc_nlp_put(ndlp); 1448 return; 1449 } 1450 1451 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1452 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX, 1453 "0258 Register Fabric login error: 0x%x\n", 1454 mb->mbxStatus); 1455 /* Decrement the reference count to ndlp after the reference 1456 * to the ndlp are done. 1457 */ 1458 lpfc_nlp_put(ndlp); 1459 return; 1460 } 1461 1462 ndlp->nlp_rpi = mb->un.varWords[0]; 1463 ndlp->nlp_type |= NLP_FABRIC; 1464 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1465 1466 if (vport->port_state == LPFC_FABRIC_CFG_LINK) { 1467 vports = lpfc_create_vport_work_array(phba); 1468 if (vports != NULL) 1469 for(i = 0; 1470 i <= phba->max_vpi && vports[i] != NULL; 1471 i++) { 1472 if (vports[i]->port_type == LPFC_PHYSICAL_PORT) 1473 continue; 1474 if (phba->fc_topology == TOPOLOGY_LOOP) { 1475 lpfc_vport_set_state(vports[i], 1476 FC_VPORT_LINKDOWN); 1477 continue; 1478 } 1479 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) 1480 lpfc_initial_fdisc(vports[i]); 1481 else { 1482 lpfc_vport_set_state(vports[i], 1483 FC_VPORT_NO_FABRIC_SUPP); 1484 lpfc_printf_vlog(vport, KERN_ERR, 1485 LOG_ELS, 1486 "0259 No NPIV " 1487 "Fabric support\n"); 1488 } 1489 } 1490 lpfc_destroy_vport_work_array(phba, vports); 1491 lpfc_do_scr_ns_plogi(phba, vport); 1492 } 1493 1494 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1495 kfree(mp); 1496 mempool_free(pmb, phba->mbox_mem_pool); 1497 1498 /* Drop the reference count from the mbox at the end after 1499 * all the current reference to the ndlp have been done. 1500 */ 1501 lpfc_nlp_put(ndlp); 1502 return; 1503} 1504 1505/* 1506 * This routine handles processing a NameServer REG_LOGIN mailbox 1507 * command upon completion. It is setup in the LPFC_MBOXQ 1508 * as the completion routine when the command is 1509 * handed off to the SLI layer. 1510 */ 1511void 1512lpfc_mbx_cmpl_ns_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 1513{ 1514 MAILBOX_t *mb = &pmb->mb; 1515 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 1516 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2; 1517 struct lpfc_vport *vport = pmb->vport; 1518 1519 if (mb->mbxStatus) { 1520out: 1521 /* decrement the node reference count held for this 1522 * callback function. 1523 */ 1524 lpfc_nlp_put(ndlp); 1525 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1526 kfree(mp); 1527 mempool_free(pmb, phba->mbox_mem_pool); 1528 1529 /* If no other thread is using the ndlp, free it */ 1530 lpfc_nlp_not_used(ndlp); 1531 1532 if (phba->fc_topology == TOPOLOGY_LOOP) { 1533 /* 1534 * RegLogin failed, use loop map to make discovery 1535 * list 1536 */ 1537 lpfc_disc_list_loopmap(vport); 1538 1539 /* Start discovery */ 1540 lpfc_disc_start(vport); 1541 return; 1542 } 1543 lpfc_vport_set_state(vport, FC_VPORT_FAILED); 1544 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS, 1545 "0260 Register NameServer error: 0x%x\n", 1546 mb->mbxStatus); 1547 return; 1548 } 1549 1550 pmb->context1 = NULL; 1551 1552 ndlp->nlp_rpi = mb->un.varWords[0]; 1553 ndlp->nlp_type |= NLP_FABRIC; 1554 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1555 1556 if (vport->port_state < LPFC_VPORT_READY) { 1557 /* Link up discovery requires Fabric registration. */ 1558 lpfc_ns_cmd(vport, SLI_CTNS_RFF_ID, 0, 0); /* Do this first! */ 1559 lpfc_ns_cmd(vport, SLI_CTNS_RNN_ID, 0, 0); 1560 lpfc_ns_cmd(vport, SLI_CTNS_RSNN_NN, 0, 0); 1561 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0); 1562 lpfc_ns_cmd(vport, SLI_CTNS_RFT_ID, 0, 0); 1563 1564 /* Issue SCR just before NameServer GID_FT Query */ 1565 lpfc_issue_els_scr(vport, SCR_DID, 0); 1566 } 1567 1568 vport->fc_ns_retry = 0; 1569 /* Good status, issue CT Request to NameServer */ 1570 if (lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 0, 0)) { 1571 /* Cannot issue NameServer Query, so finish up discovery */ 1572 goto out; 1573 } 1574 1575 /* decrement the node reference count held for this 1576 * callback function. 1577 */ 1578 lpfc_nlp_put(ndlp); 1579 lpfc_mbuf_free(phba, mp->virt, mp->phys); 1580 kfree(mp); 1581 mempool_free(pmb, phba->mbox_mem_pool); 1582 1583 return; 1584} 1585 1586static void 1587lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 1588{ 1589 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1590 struct fc_rport *rport; 1591 struct lpfc_rport_data *rdata; 1592 struct fc_rport_identifiers rport_ids; 1593 struct lpfc_hba *phba = vport->phba; 1594 1595 /* Remote port has reappeared. Re-register w/ FC transport */ 1596 rport_ids.node_name = wwn_to_u64(ndlp->nlp_nodename.u.wwn); 1597 rport_ids.port_name = wwn_to_u64(ndlp->nlp_portname.u.wwn); 1598 rport_ids.port_id = ndlp->nlp_DID; 1599 rport_ids.roles = FC_RPORT_ROLE_UNKNOWN; 1600 1601 /* 1602 * We leave our node pointer in rport->dd_data when we unregister a 1603 * FCP target port. But fc_remote_port_add zeros the space to which 1604 * rport->dd_data points. So, if we're reusing a previously 1605 * registered port, drop the reference that we took the last time we 1606 * registered the port. 1607 */ 1608 if (ndlp->rport && ndlp->rport->dd_data && 1609 ((struct lpfc_rport_data *) ndlp->rport->dd_data)->pnode == ndlp) 1610 lpfc_nlp_put(ndlp); 1611 1612 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_RPORT, 1613 "rport add: did:x%x flg:x%x type x%x", 1614 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type); 1615 1616 ndlp->rport = rport = fc_remote_port_add(shost, 0, &rport_ids); 1617 if (!rport || !get_device(&rport->dev)) { 1618 dev_printk(KERN_WARNING, &phba->pcidev->dev, 1619 "Warning: fc_remote_port_add failed\n"); 1620 return; 1621 } 1622 1623 /* initialize static port data */ 1624 rport->maxframe_size = ndlp->nlp_maxframe; 1625 rport->supported_classes = ndlp->nlp_class_sup; 1626 rdata = rport->dd_data; 1627 rdata->pnode = lpfc_nlp_get(ndlp); 1628 1629 if (ndlp->nlp_type & NLP_FCP_TARGET) 1630 rport_ids.roles |= FC_RPORT_ROLE_FCP_TARGET; 1631 if (ndlp->nlp_type & NLP_FCP_INITIATOR) 1632 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR; 1633 1634 1635 if (rport_ids.roles != FC_RPORT_ROLE_UNKNOWN) 1636 fc_remote_port_rolechg(rport, rport_ids.roles); 1637 1638 if ((rport->scsi_target_id != -1) && 1639 (rport->scsi_target_id < LPFC_MAX_TARGET)) { 1640 ndlp->nlp_sid = rport->scsi_target_id; 1641 } 1642 return; 1643} 1644 1645static void 1646lpfc_unregister_remote_port(struct lpfc_nodelist *ndlp) 1647{ 1648 struct fc_rport *rport = ndlp->rport; 1649 1650 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_RPORT, 1651 "rport delete: did:x%x flg:x%x type x%x", 1652 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type); 1653 1654 fc_remote_port_delete(rport); 1655 1656 return; 1657} 1658 1659static void 1660lpfc_nlp_counters(struct lpfc_vport *vport, int state, int count) 1661{ 1662 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1663 1664 spin_lock_irq(shost->host_lock); 1665 switch (state) { 1666 case NLP_STE_UNUSED_NODE: 1667 vport->fc_unused_cnt += count; 1668 break; 1669 case NLP_STE_PLOGI_ISSUE: 1670 vport->fc_plogi_cnt += count; 1671 break; 1672 case NLP_STE_ADISC_ISSUE: 1673 vport->fc_adisc_cnt += count; 1674 break; 1675 case NLP_STE_REG_LOGIN_ISSUE: 1676 vport->fc_reglogin_cnt += count; 1677 break; 1678 case NLP_STE_PRLI_ISSUE: 1679 vport->fc_prli_cnt += count; 1680 break; 1681 case NLP_STE_UNMAPPED_NODE: 1682 vport->fc_unmap_cnt += count; 1683 break; 1684 case NLP_STE_MAPPED_NODE: 1685 vport->fc_map_cnt += count; 1686 break; 1687 case NLP_STE_NPR_NODE: 1688 vport->fc_npr_cnt += count; 1689 break; 1690 } 1691 spin_unlock_irq(shost->host_lock); 1692} 1693 1694static void 1695lpfc_nlp_state_cleanup(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1696 int old_state, int new_state) 1697{ 1698 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1699 1700 if (new_state == NLP_STE_UNMAPPED_NODE) { 1701 ndlp->nlp_type &= ~(NLP_FCP_TARGET | NLP_FCP_INITIATOR); 1702 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE; 1703 ndlp->nlp_type |= NLP_FC_NODE; 1704 } 1705 if (new_state == NLP_STE_MAPPED_NODE) 1706 ndlp->nlp_flag &= ~NLP_NODEV_REMOVE; 1707 if (new_state == NLP_STE_NPR_NODE) 1708 ndlp->nlp_flag &= ~NLP_RCV_PLOGI; 1709 1710 /* Transport interface */ 1711 if (ndlp->rport && (old_state == NLP_STE_MAPPED_NODE || 1712 old_state == NLP_STE_UNMAPPED_NODE)) { 1713 vport->phba->nport_event_cnt++; 1714 lpfc_unregister_remote_port(ndlp); 1715 } 1716 1717 if (new_state == NLP_STE_MAPPED_NODE || 1718 new_state == NLP_STE_UNMAPPED_NODE) { 1719 vport->phba->nport_event_cnt++; 1720 /* 1721 * Tell the fc transport about the port, if we haven't 1722 * already. If we have, and it's a scsi entity, be 1723 * sure to unblock any attached scsi devices 1724 */ 1725 lpfc_register_remote_port(vport, ndlp); 1726 } 1727 if ((new_state == NLP_STE_MAPPED_NODE) && 1728 (vport->stat_data_enabled)) { 1729 /* 1730 * A new target is discovered, if there is no buffer for 1731 * statistical data collection allocate buffer. 1732 */ 1733 ndlp->lat_data = kcalloc(LPFC_MAX_BUCKET_COUNT, 1734 sizeof(struct lpfc_scsicmd_bkt), 1735 GFP_KERNEL); 1736 1737 if (!ndlp->lat_data) 1738 lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE, 1739 "0286 lpfc_nlp_state_cleanup failed to " 1740 "allocate statistical data buffer DID " 1741 "0x%x\n", ndlp->nlp_DID); 1742 } 1743 /* 1744 * if we added to Mapped list, but the remote port 1745 * registration failed or assigned a target id outside 1746 * our presentable range - move the node to the 1747 * Unmapped List 1748 */ 1749 if (new_state == NLP_STE_MAPPED_NODE && 1750 (!ndlp->rport || 1751 ndlp->rport->scsi_target_id == -1 || 1752 ndlp->rport->scsi_target_id >= LPFC_MAX_TARGET)) { 1753 spin_lock_irq(shost->host_lock); 1754 ndlp->nlp_flag |= NLP_TGT_NO_SCSIID; 1755 spin_unlock_irq(shost->host_lock); 1756 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 1757 } 1758} 1759 1760static char * 1761lpfc_nlp_state_name(char *buffer, size_t size, int state) 1762{ 1763 static char *states[] = { 1764 [NLP_STE_UNUSED_NODE] = "UNUSED", 1765 [NLP_STE_PLOGI_ISSUE] = "PLOGI", 1766 [NLP_STE_ADISC_ISSUE] = "ADISC", 1767 [NLP_STE_REG_LOGIN_ISSUE] = "REGLOGIN", 1768 [NLP_STE_PRLI_ISSUE] = "PRLI", 1769 [NLP_STE_UNMAPPED_NODE] = "UNMAPPED", 1770 [NLP_STE_MAPPED_NODE] = "MAPPED", 1771 [NLP_STE_NPR_NODE] = "NPR", 1772 }; 1773 1774 if (state < NLP_STE_MAX_STATE && states[state]) 1775 strlcpy(buffer, states[state], size); 1776 else 1777 snprintf(buffer, size, "unknown (%d)", state); 1778 return buffer; 1779} 1780 1781void 1782lpfc_nlp_set_state(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1783 int state) 1784{ 1785 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1786 int old_state = ndlp->nlp_state; 1787 char name1[16], name2[16]; 1788 1789 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 1790 "0904 NPort state transition x%06x, %s -> %s\n", 1791 ndlp->nlp_DID, 1792 lpfc_nlp_state_name(name1, sizeof(name1), old_state), 1793 lpfc_nlp_state_name(name2, sizeof(name2), state)); 1794 1795 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE, 1796 "node statechg did:x%x old:%d ste:%d", 1797 ndlp->nlp_DID, old_state, state); 1798 1799 if (old_state == NLP_STE_NPR_NODE && 1800 state != NLP_STE_NPR_NODE) 1801 lpfc_cancel_retry_delay_tmo(vport, ndlp); 1802 if (old_state == NLP_STE_UNMAPPED_NODE) { 1803 ndlp->nlp_flag &= ~NLP_TGT_NO_SCSIID; 1804 ndlp->nlp_type &= ~NLP_FC_NODE; 1805 } 1806 1807 if (list_empty(&ndlp->nlp_listp)) { 1808 spin_lock_irq(shost->host_lock); 1809 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes); 1810 spin_unlock_irq(shost->host_lock); 1811 } else if (old_state) 1812 lpfc_nlp_counters(vport, old_state, -1); 1813 1814 ndlp->nlp_state = state; 1815 lpfc_nlp_counters(vport, state, 1); 1816 lpfc_nlp_state_cleanup(vport, ndlp, old_state, state); 1817} 1818 1819void 1820lpfc_enqueue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 1821{ 1822 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1823 1824 if (list_empty(&ndlp->nlp_listp)) { 1825 spin_lock_irq(shost->host_lock); 1826 list_add_tail(&ndlp->nlp_listp, &vport->fc_nodes); 1827 spin_unlock_irq(shost->host_lock); 1828 } 1829} 1830 1831void 1832lpfc_dequeue_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 1833{ 1834 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1835 1836 lpfc_cancel_retry_delay_tmo(vport, ndlp); 1837 if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp)) 1838 lpfc_nlp_counters(vport, ndlp->nlp_state, -1); 1839 spin_lock_irq(shost->host_lock); 1840 list_del_init(&ndlp->nlp_listp); 1841 spin_unlock_irq(shost->host_lock); 1842 lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state, 1843 NLP_STE_UNUSED_NODE); 1844} 1845 1846static void 1847lpfc_disable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 1848{ 1849 lpfc_cancel_retry_delay_tmo(vport, ndlp); 1850 if (ndlp->nlp_state && !list_empty(&ndlp->nlp_listp)) 1851 lpfc_nlp_counters(vport, ndlp->nlp_state, -1); 1852 lpfc_nlp_state_cleanup(vport, ndlp, ndlp->nlp_state, 1853 NLP_STE_UNUSED_NODE); 1854} 1855 1856struct lpfc_nodelist * 1857lpfc_enable_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 1858 int state) 1859{ 1860 struct lpfc_hba *phba = vport->phba; 1861 uint32_t did; 1862 unsigned long flags; 1863 1864 if (!ndlp) 1865 return NULL; 1866 1867 spin_lock_irqsave(&phba->ndlp_lock, flags); 1868 /* The ndlp should not be in memory free mode */ 1869 if (NLP_CHK_FREE_REQ(ndlp)) { 1870 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 1871 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE, 1872 "0277 lpfc_enable_node: ndlp:x%p " 1873 "usgmap:x%x refcnt:%d\n", 1874 (void *)ndlp, ndlp->nlp_usg_map, 1875 atomic_read(&ndlp->kref.refcount)); 1876 return NULL; 1877 } 1878 /* The ndlp should not already be in active mode */ 1879 if (NLP_CHK_NODE_ACT(ndlp)) { 1880 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 1881 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE, 1882 "0278 lpfc_enable_node: ndlp:x%p " 1883 "usgmap:x%x refcnt:%d\n", 1884 (void *)ndlp, ndlp->nlp_usg_map, 1885 atomic_read(&ndlp->kref.refcount)); 1886 return NULL; 1887 } 1888 1889 /* Keep the original DID */ 1890 did = ndlp->nlp_DID; 1891 1892 /* re-initialize ndlp except of ndlp linked list pointer */ 1893 memset((((char *)ndlp) + sizeof (struct list_head)), 0, 1894 sizeof (struct lpfc_nodelist) - sizeof (struct list_head)); 1895 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp); 1896 INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp); 1897 init_timer(&ndlp->nlp_delayfunc); 1898 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay; 1899 ndlp->nlp_delayfunc.data = (unsigned long)ndlp; 1900 ndlp->nlp_DID = did; 1901 ndlp->vport = vport; 1902 ndlp->nlp_sid = NLP_NO_SID; 1903 /* ndlp management re-initialize */ 1904 kref_init(&ndlp->kref); 1905 NLP_INT_NODE_ACT(ndlp); 1906 1907 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 1908 1909 if (state != NLP_STE_UNUSED_NODE) 1910 lpfc_nlp_set_state(vport, ndlp, state); 1911 1912 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE, 1913 "node enable: did:x%x", 1914 ndlp->nlp_DID, 0, 0); 1915 return ndlp; 1916} 1917 1918void 1919lpfc_drop_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 1920{ 1921 /* 1922 * Use of lpfc_drop_node and UNUSED list: lpfc_drop_node should 1923 * be used if we wish to issue the "last" lpfc_nlp_put() to remove 1924 * the ndlp from the vport. The ndlp marked as UNUSED on the list 1925 * until ALL other outstanding threads have completed. We check 1926 * that the ndlp not already in the UNUSED state before we proceed. 1927 */ 1928 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE) 1929 return; 1930 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNUSED_NODE); 1931 lpfc_nlp_put(ndlp); 1932 return; 1933} 1934 1935/* 1936 * Start / ReStart rescue timer for Discovery / RSCN handling 1937 */ 1938void 1939lpfc_set_disctmo(struct lpfc_vport *vport) 1940{ 1941 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1942 struct lpfc_hba *phba = vport->phba; 1943 uint32_t tmo; 1944 1945 if (vport->port_state == LPFC_LOCAL_CFG_LINK) { 1946 /* For FAN, timeout should be greater then edtov */ 1947 tmo = (((phba->fc_edtov + 999) / 1000) + 1); 1948 } else { 1949 /* Normal discovery timeout should be > then ELS/CT timeout 1950 * FC spec states we need 3 * ratov for CT requests 1951 */ 1952 tmo = ((phba->fc_ratov * 3) + 3); 1953 } 1954 1955 1956 if (!timer_pending(&vport->fc_disctmo)) { 1957 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, 1958 "set disc timer: tmo:x%x state:x%x flg:x%x", 1959 tmo, vport->port_state, vport->fc_flag); 1960 } 1961 1962 mod_timer(&vport->fc_disctmo, jiffies + HZ * tmo); 1963 spin_lock_irq(shost->host_lock); 1964 vport->fc_flag |= FC_DISC_TMO; 1965 spin_unlock_irq(shost->host_lock); 1966 1967 /* Start Discovery Timer state <hba_state> */ 1968 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 1969 "0247 Start Discovery Timer state x%x " 1970 "Data: x%x x%lx x%x x%x\n", 1971 vport->port_state, tmo, 1972 (unsigned long)&vport->fc_disctmo, vport->fc_plogi_cnt, 1973 vport->fc_adisc_cnt); 1974 1975 return; 1976} 1977 1978/* 1979 * Cancel rescue timer for Discovery / RSCN handling 1980 */ 1981int 1982lpfc_can_disctmo(struct lpfc_vport *vport) 1983{ 1984 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 1985 unsigned long iflags; 1986 1987 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, 1988 "can disc timer: state:x%x rtry:x%x flg:x%x", 1989 vport->port_state, vport->fc_ns_retry, vport->fc_flag); 1990 1991 /* Turn off discovery timer if its running */ 1992 if (vport->fc_flag & FC_DISC_TMO) { 1993 spin_lock_irqsave(shost->host_lock, iflags); 1994 vport->fc_flag &= ~FC_DISC_TMO; 1995 spin_unlock_irqrestore(shost->host_lock, iflags); 1996 del_timer_sync(&vport->fc_disctmo); 1997 spin_lock_irqsave(&vport->work_port_lock, iflags); 1998 vport->work_port_events &= ~WORKER_DISC_TMO; 1999 spin_unlock_irqrestore(&vport->work_port_lock, iflags); 2000 } 2001 2002 /* Cancel Discovery Timer state <hba_state> */ 2003 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2004 "0248 Cancel Discovery Timer state x%x " 2005 "Data: x%x x%x x%x\n", 2006 vport->port_state, vport->fc_flag, 2007 vport->fc_plogi_cnt, vport->fc_adisc_cnt); 2008 return 0; 2009} 2010 2011/* 2012 * Check specified ring for outstanding IOCB on the SLI queue 2013 * Return true if iocb matches the specified nport 2014 */ 2015int 2016lpfc_check_sli_ndlp(struct lpfc_hba *phba, 2017 struct lpfc_sli_ring *pring, 2018 struct lpfc_iocbq *iocb, 2019 struct lpfc_nodelist *ndlp) 2020{ 2021 struct lpfc_sli *psli = &phba->sli; 2022 IOCB_t *icmd = &iocb->iocb; 2023 struct lpfc_vport *vport = ndlp->vport; 2024 2025 if (iocb->vport != vport) 2026 return 0; 2027 2028 if (pring->ringno == LPFC_ELS_RING) { 2029 switch (icmd->ulpCommand) { 2030 case CMD_GEN_REQUEST64_CR: 2031 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) 2032 return 1; 2033 case CMD_ELS_REQUEST64_CR: 2034 if (icmd->un.elsreq64.remoteID == ndlp->nlp_DID) 2035 return 1; 2036 case CMD_XMIT_ELS_RSP64_CX: 2037 if (iocb->context1 == (uint8_t *) ndlp) 2038 return 1; 2039 } 2040 } else if (pring->ringno == psli->extra_ring) { 2041 2042 } else if (pring->ringno == psli->fcp_ring) { 2043 /* Skip match check if waiting to relogin to FCP target */ 2044 if ((ndlp->nlp_type & NLP_FCP_TARGET) && 2045 (ndlp->nlp_flag & NLP_DELAY_TMO)) { 2046 return 0; 2047 } 2048 if (icmd->ulpContext == (volatile ushort)ndlp->nlp_rpi) { 2049 return 1; 2050 } 2051 } else if (pring->ringno == psli->next_ring) { 2052 2053 } 2054 return 0; 2055} 2056 2057/* 2058 * Free resources / clean up outstanding I/Os 2059 * associated with nlp_rpi in the LPFC_NODELIST entry. 2060 */ 2061static int 2062lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 2063{ 2064 LIST_HEAD(completions); 2065 struct lpfc_sli *psli; 2066 struct lpfc_sli_ring *pring; 2067 struct lpfc_iocbq *iocb, *next_iocb; 2068 IOCB_t *icmd; 2069 uint32_t rpi, i; 2070 2071 lpfc_fabric_abort_nport(ndlp); 2072 2073 /* 2074 * Everything that matches on txcmplq will be returned 2075 * by firmware with a no rpi error. 2076 */ 2077 psli = &phba->sli; 2078 rpi = ndlp->nlp_rpi; 2079 if (rpi) { 2080 /* Now process each ring */ 2081 for (i = 0; i < psli->num_rings; i++) { 2082 pring = &psli->ring[i]; 2083 2084 spin_lock_irq(&phba->hbalock); 2085 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, 2086 list) { 2087 /* 2088 * Check to see if iocb matches the nport we are 2089 * looking for 2090 */ 2091 if ((lpfc_check_sli_ndlp(phba, pring, iocb, 2092 ndlp))) { 2093 /* It matches, so deque and call compl 2094 with an error */ 2095 list_move_tail(&iocb->list, 2096 &completions); 2097 pring->txq_cnt--; 2098 } 2099 } 2100 spin_unlock_irq(&phba->hbalock); 2101 } 2102 } 2103 2104 while (!list_empty(&completions)) { 2105 iocb = list_get_first(&completions, struct lpfc_iocbq, list); 2106 list_del_init(&iocb->list); 2107 2108 if (!iocb->iocb_cmpl) 2109 lpfc_sli_release_iocbq(phba, iocb); 2110 else { 2111 icmd = &iocb->iocb; 2112 icmd->ulpStatus = IOSTAT_LOCAL_REJECT; 2113 icmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 2114 (iocb->iocb_cmpl)(phba, iocb, iocb); 2115 } 2116 } 2117 2118 return 0; 2119} 2120 2121/* 2122 * Free rpi associated with LPFC_NODELIST entry. 2123 * This routine is called from lpfc_freenode(), when we are removing 2124 * a LPFC_NODELIST entry. It is also called if the driver initiates a 2125 * LOGO that completes successfully, and we are waiting to PLOGI back 2126 * to the remote NPort. In addition, it is called after we receive 2127 * and unsolicated ELS cmd, send back a rsp, the rsp completes and 2128 * we are waiting to PLOGI back to the remote NPort. 2129 */ 2130int 2131lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 2132{ 2133 struct lpfc_hba *phba = vport->phba; 2134 LPFC_MBOXQ_t *mbox; 2135 int rc; 2136 2137 if (ndlp->nlp_rpi) { 2138 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2139 if (mbox) { 2140 lpfc_unreg_login(phba, vport->vpi, ndlp->nlp_rpi, mbox); 2141 mbox->vport = vport; 2142 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2143 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT); 2144 if (rc == MBX_NOT_FINISHED) 2145 mempool_free(mbox, phba->mbox_mem_pool); 2146 } 2147 lpfc_no_rpi(phba, ndlp); 2148 ndlp->nlp_rpi = 0; 2149 return 1; 2150 } 2151 return 0; 2152} 2153 2154void 2155lpfc_unreg_all_rpis(struct lpfc_vport *vport) 2156{ 2157 struct lpfc_hba *phba = vport->phba; 2158 LPFC_MBOXQ_t *mbox; 2159 int rc; 2160 2161 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2162 if (mbox) { 2163 lpfc_unreg_login(phba, vport->vpi, 0xffff, mbox); 2164 mbox->vport = vport; 2165 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2166 mbox->context1 = NULL; 2167 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO); 2168 if (rc == MBX_NOT_FINISHED) { 2169 mempool_free(mbox, phba->mbox_mem_pool); 2170 } 2171 } 2172} 2173 2174void 2175lpfc_unreg_default_rpis(struct lpfc_vport *vport) 2176{ 2177 struct lpfc_hba *phba = vport->phba; 2178 LPFC_MBOXQ_t *mbox; 2179 int rc; 2180 2181 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2182 if (mbox) { 2183 lpfc_unreg_did(phba, vport->vpi, 0xffffffff, mbox); 2184 mbox->vport = vport; 2185 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2186 mbox->context1 = NULL; 2187 rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO); 2188 if (rc == MBX_NOT_FINISHED) { 2189 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX | LOG_VPORT, 2190 "1815 Could not issue " 2191 "unreg_did (default rpis)\n"); 2192 mempool_free(mbox, phba->mbox_mem_pool); 2193 } 2194 } 2195} 2196 2197/* 2198 * Free resources associated with LPFC_NODELIST entry 2199 * so it can be freed. 2200 */ 2201static int 2202lpfc_cleanup_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 2203{ 2204 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2205 struct lpfc_hba *phba = vport->phba; 2206 LPFC_MBOXQ_t *mb, *nextmb; 2207 struct lpfc_dmabuf *mp; 2208 2209 /* Cleanup node for NPort <nlp_DID> */ 2210 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 2211 "0900 Cleanup node for NPort x%x " 2212 "Data: x%x x%x x%x\n", 2213 ndlp->nlp_DID, ndlp->nlp_flag, 2214 ndlp->nlp_state, ndlp->nlp_rpi); 2215 if (NLP_CHK_FREE_REQ(ndlp)) { 2216 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE, 2217 "0280 lpfc_cleanup_node: ndlp:x%p " 2218 "usgmap:x%x refcnt:%d\n", 2219 (void *)ndlp, ndlp->nlp_usg_map, 2220 atomic_read(&ndlp->kref.refcount)); 2221 lpfc_dequeue_node(vport, ndlp); 2222 } else { 2223 lpfc_printf_vlog(vport, KERN_WARNING, LOG_NODE, 2224 "0281 lpfc_cleanup_node: ndlp:x%p " 2225 "usgmap:x%x refcnt:%d\n", 2226 (void *)ndlp, ndlp->nlp_usg_map, 2227 atomic_read(&ndlp->kref.refcount)); 2228 lpfc_disable_node(vport, ndlp); 2229 } 2230 2231 /* cleanup any ndlp on mbox q waiting for reglogin cmpl */ 2232 if ((mb = phba->sli.mbox_active)) { 2233 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 2234 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 2235 mb->context2 = NULL; 2236 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2237 } 2238 } 2239 2240 spin_lock_irq(&phba->hbalock); 2241 list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) { 2242 if ((mb->mb.mbxCommand == MBX_REG_LOGIN64) && 2243 (ndlp == (struct lpfc_nodelist *) mb->context2)) { 2244 mp = (struct lpfc_dmabuf *) (mb->context1); 2245 if (mp) { 2246 __lpfc_mbuf_free(phba, mp->virt, mp->phys); 2247 kfree(mp); 2248 } 2249 list_del(&mb->list); 2250 mempool_free(mb, phba->mbox_mem_pool); 2251 /* We shall not invoke the lpfc_nlp_put to decrement 2252 * the ndlp reference count as we are in the process 2253 * of lpfc_nlp_release. 2254 */ 2255 } 2256 } 2257 spin_unlock_irq(&phba->hbalock); 2258 2259 lpfc_els_abort(phba, ndlp); 2260 2261 spin_lock_irq(shost->host_lock); 2262 ndlp->nlp_flag &= ~NLP_DELAY_TMO; 2263 spin_unlock_irq(shost->host_lock); 2264 2265 ndlp->nlp_last_elscmd = 0; 2266 del_timer_sync(&ndlp->nlp_delayfunc); 2267 2268 list_del_init(&ndlp->els_retry_evt.evt_listp); 2269 list_del_init(&ndlp->dev_loss_evt.evt_listp); 2270 2271 lpfc_unreg_rpi(vport, ndlp); 2272 2273 return 0; 2274} 2275 2276/* 2277 * Check to see if we can free the nlp back to the freelist. 2278 * If we are in the middle of using the nlp in the discovery state 2279 * machine, defer the free till we reach the end of the state machine. 2280 */ 2281static void 2282lpfc_nlp_remove(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp) 2283{ 2284 struct lpfc_hba *phba = vport->phba; 2285 struct lpfc_rport_data *rdata; 2286 LPFC_MBOXQ_t *mbox; 2287 int rc; 2288 2289 lpfc_cancel_retry_delay_tmo(vport, ndlp); 2290 if (ndlp->nlp_flag & NLP_DEFER_RM && !ndlp->nlp_rpi) { 2291 /* For this case we need to cleanup the default rpi 2292 * allocated by the firmware. 2293 */ 2294 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL)) 2295 != NULL) { 2296 rc = lpfc_reg_login(phba, vport->vpi, ndlp->nlp_DID, 2297 (uint8_t *) &vport->fc_sparam, mbox, 0); 2298 if (rc) { 2299 mempool_free(mbox, phba->mbox_mem_pool); 2300 } 2301 else { 2302 mbox->mbox_flag |= LPFC_MBX_IMED_UNREG; 2303 mbox->mbox_cmpl = lpfc_mbx_cmpl_dflt_rpi; 2304 mbox->vport = vport; 2305 mbox->context2 = NULL; 2306 rc =lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT); 2307 if (rc == MBX_NOT_FINISHED) { 2308 mempool_free(mbox, phba->mbox_mem_pool); 2309 } 2310 } 2311 } 2312 } 2313 lpfc_cleanup_node(vport, ndlp); 2314 2315 /* 2316 * We can get here with a non-NULL ndlp->rport because when we 2317 * unregister a rport we don't break the rport/node linkage. So if we 2318 * do, make sure we don't leaving any dangling pointers behind. 2319 */ 2320 if (ndlp->rport) { 2321 rdata = ndlp->rport->dd_data; 2322 rdata->pnode = NULL; 2323 ndlp->rport = NULL; 2324 } 2325} 2326 2327static int 2328lpfc_matchdid(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 2329 uint32_t did) 2330{ 2331 D_ID mydid, ndlpdid, matchdid; 2332 2333 if (did == Bcast_DID) 2334 return 0; 2335 2336 /* First check for Direct match */ 2337 if (ndlp->nlp_DID == did) 2338 return 1; 2339 2340 /* Next check for area/domain identically equals 0 match */ 2341 mydid.un.word = vport->fc_myDID; 2342 if ((mydid.un.b.domain == 0) && (mydid.un.b.area == 0)) { 2343 return 0; 2344 } 2345 2346 matchdid.un.word = did; 2347 ndlpdid.un.word = ndlp->nlp_DID; 2348 if (matchdid.un.b.id == ndlpdid.un.b.id) { 2349 if ((mydid.un.b.domain == matchdid.un.b.domain) && 2350 (mydid.un.b.area == matchdid.un.b.area)) { 2351 if ((ndlpdid.un.b.domain == 0) && 2352 (ndlpdid.un.b.area == 0)) { 2353 if (ndlpdid.un.b.id) 2354 return 1; 2355 } 2356 return 0; 2357 } 2358 2359 matchdid.un.word = ndlp->nlp_DID; 2360 if ((mydid.un.b.domain == ndlpdid.un.b.domain) && 2361 (mydid.un.b.area == ndlpdid.un.b.area)) { 2362 if ((matchdid.un.b.domain == 0) && 2363 (matchdid.un.b.area == 0)) { 2364 if (matchdid.un.b.id) 2365 return 1; 2366 } 2367 } 2368 } 2369 return 0; 2370} 2371 2372/* Search for a nodelist entry */ 2373static struct lpfc_nodelist * 2374__lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did) 2375{ 2376 struct lpfc_nodelist *ndlp; 2377 uint32_t data1; 2378 2379 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 2380 if (lpfc_matchdid(vport, ndlp, did)) { 2381 data1 = (((uint32_t) ndlp->nlp_state << 24) | 2382 ((uint32_t) ndlp->nlp_xri << 16) | 2383 ((uint32_t) ndlp->nlp_type << 8) | 2384 ((uint32_t) ndlp->nlp_rpi & 0xff)); 2385 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 2386 "0929 FIND node DID " 2387 "Data: x%p x%x x%x x%x\n", 2388 ndlp, ndlp->nlp_DID, 2389 ndlp->nlp_flag, data1); 2390 return ndlp; 2391 } 2392 } 2393 2394 /* FIND node did <did> NOT FOUND */ 2395 lpfc_printf_vlog(vport, KERN_INFO, LOG_NODE, 2396 "0932 FIND node did x%x NOT FOUND.\n", did); 2397 return NULL; 2398} 2399 2400struct lpfc_nodelist * 2401lpfc_findnode_did(struct lpfc_vport *vport, uint32_t did) 2402{ 2403 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2404 struct lpfc_nodelist *ndlp; 2405 2406 spin_lock_irq(shost->host_lock); 2407 ndlp = __lpfc_findnode_did(vport, did); 2408 spin_unlock_irq(shost->host_lock); 2409 return ndlp; 2410} 2411 2412struct lpfc_nodelist * 2413lpfc_setup_disc_node(struct lpfc_vport *vport, uint32_t did) 2414{ 2415 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2416 struct lpfc_nodelist *ndlp; 2417 2418 ndlp = lpfc_findnode_did(vport, did); 2419 if (!ndlp) { 2420 if ((vport->fc_flag & FC_RSCN_MODE) != 0 && 2421 lpfc_rscn_payload_check(vport, did) == 0) 2422 return NULL; 2423 ndlp = (struct lpfc_nodelist *) 2424 mempool_alloc(vport->phba->nlp_mem_pool, GFP_KERNEL); 2425 if (!ndlp) 2426 return NULL; 2427 lpfc_nlp_init(vport, ndlp, did); 2428 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 2429 spin_lock_irq(shost->host_lock); 2430 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 2431 spin_unlock_irq(shost->host_lock); 2432 return ndlp; 2433 } else if (!NLP_CHK_NODE_ACT(ndlp)) { 2434 ndlp = lpfc_enable_node(vport, ndlp, NLP_STE_NPR_NODE); 2435 if (!ndlp) 2436 return NULL; 2437 spin_lock_irq(shost->host_lock); 2438 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 2439 spin_unlock_irq(shost->host_lock); 2440 return ndlp; 2441 } 2442 2443 if ((vport->fc_flag & FC_RSCN_MODE) && 2444 !(vport->fc_flag & FC_NDISC_ACTIVE)) { 2445 if (lpfc_rscn_payload_check(vport, did)) { 2446 /* If we've already recieved a PLOGI from this NPort 2447 * we don't need to try to discover it again. 2448 */ 2449 if (ndlp->nlp_flag & NLP_RCV_PLOGI) 2450 return NULL; 2451 2452 spin_lock_irq(shost->host_lock); 2453 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 2454 spin_unlock_irq(shost->host_lock); 2455 2456 /* Since this node is marked for discovery, 2457 * delay timeout is not needed. 2458 */ 2459 lpfc_cancel_retry_delay_tmo(vport, ndlp); 2460 } else 2461 ndlp = NULL; 2462 } else { 2463 /* If we've already recieved a PLOGI from this NPort, 2464 * or we are already in the process of discovery on it, 2465 * we don't need to try to discover it again. 2466 */ 2467 if (ndlp->nlp_state == NLP_STE_ADISC_ISSUE || 2468 ndlp->nlp_state == NLP_STE_PLOGI_ISSUE || 2469 ndlp->nlp_flag & NLP_RCV_PLOGI) 2470 return NULL; 2471 lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE); 2472 spin_lock_irq(shost->host_lock); 2473 ndlp->nlp_flag |= NLP_NPR_2B_DISC; 2474 spin_unlock_irq(shost->host_lock); 2475 } 2476 return ndlp; 2477} 2478 2479/* Build a list of nodes to discover based on the loopmap */ 2480void 2481lpfc_disc_list_loopmap(struct lpfc_vport *vport) 2482{ 2483 struct lpfc_hba *phba = vport->phba; 2484 int j; 2485 uint32_t alpa, index; 2486 2487 if (!lpfc_is_link_up(phba)) 2488 return; 2489 2490 if (phba->fc_topology != TOPOLOGY_LOOP) 2491 return; 2492 2493 /* Check for loop map present or not */ 2494 if (phba->alpa_map[0]) { 2495 for (j = 1; j <= phba->alpa_map[0]; j++) { 2496 alpa = phba->alpa_map[j]; 2497 if (((vport->fc_myDID & 0xff) == alpa) || (alpa == 0)) 2498 continue; 2499 lpfc_setup_disc_node(vport, alpa); 2500 } 2501 } else { 2502 /* No alpamap, so try all alpa's */ 2503 for (j = 0; j < FC_MAXLOOP; j++) { 2504 /* If cfg_scan_down is set, start from highest 2505 * ALPA (0xef) to lowest (0x1). 2506 */ 2507 if (vport->cfg_scan_down) 2508 index = j; 2509 else 2510 index = FC_MAXLOOP - j - 1; 2511 alpa = lpfcAlpaArray[index]; 2512 if ((vport->fc_myDID & 0xff) == alpa) 2513 continue; 2514 lpfc_setup_disc_node(vport, alpa); 2515 } 2516 } 2517 return; 2518} 2519 2520void 2521lpfc_issue_clear_la(struct lpfc_hba *phba, struct lpfc_vport *vport) 2522{ 2523 LPFC_MBOXQ_t *mbox; 2524 struct lpfc_sli *psli = &phba->sli; 2525 struct lpfc_sli_ring *extra_ring = &psli->ring[psli->extra_ring]; 2526 struct lpfc_sli_ring *fcp_ring = &psli->ring[psli->fcp_ring]; 2527 struct lpfc_sli_ring *next_ring = &psli->ring[psli->next_ring]; 2528 int rc; 2529 2530 /* 2531 * if it's not a physical port or if we already send 2532 * clear_la then don't send it. 2533 */ 2534 if ((phba->link_state >= LPFC_CLEAR_LA) || 2535 (vport->port_type != LPFC_PHYSICAL_PORT)) 2536 return; 2537 2538 /* Link up discovery */ 2539 if ((mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL)) != NULL) { 2540 phba->link_state = LPFC_CLEAR_LA; 2541 lpfc_clear_la(phba, mbox); 2542 mbox->mbox_cmpl = lpfc_mbx_cmpl_clear_la; 2543 mbox->vport = vport; 2544 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT); 2545 if (rc == MBX_NOT_FINISHED) { 2546 mempool_free(mbox, phba->mbox_mem_pool); 2547 lpfc_disc_flush_list(vport); 2548 extra_ring->flag &= ~LPFC_STOP_IOCB_EVENT; 2549 fcp_ring->flag &= ~LPFC_STOP_IOCB_EVENT; 2550 next_ring->flag &= ~LPFC_STOP_IOCB_EVENT; 2551 phba->link_state = LPFC_HBA_ERROR; 2552 } 2553 } 2554} 2555 2556/* Reg_vpi to tell firmware to resume normal operations */ 2557void 2558lpfc_issue_reg_vpi(struct lpfc_hba *phba, struct lpfc_vport *vport) 2559{ 2560 LPFC_MBOXQ_t *regvpimbox; 2561 2562 regvpimbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2563 if (regvpimbox) { 2564 lpfc_reg_vpi(phba, vport->vpi, vport->fc_myDID, regvpimbox); 2565 regvpimbox->mbox_cmpl = lpfc_mbx_cmpl_reg_vpi; 2566 regvpimbox->vport = vport; 2567 if (lpfc_sli_issue_mbox(phba, regvpimbox, MBX_NOWAIT) 2568 == MBX_NOT_FINISHED) { 2569 mempool_free(regvpimbox, phba->mbox_mem_pool); 2570 } 2571 } 2572} 2573 2574/* Start Link up / RSCN discovery on NPR nodes */ 2575void 2576lpfc_disc_start(struct lpfc_vport *vport) 2577{ 2578 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2579 struct lpfc_hba *phba = vport->phba; 2580 uint32_t num_sent; 2581 uint32_t clear_la_pending; 2582 int did_changed; 2583 2584 if (!lpfc_is_link_up(phba)) 2585 return; 2586 2587 if (phba->link_state == LPFC_CLEAR_LA) 2588 clear_la_pending = 1; 2589 else 2590 clear_la_pending = 0; 2591 2592 if (vport->port_state < LPFC_VPORT_READY) 2593 vport->port_state = LPFC_DISC_AUTH; 2594 2595 lpfc_set_disctmo(vport); 2596 2597 if (vport->fc_prevDID == vport->fc_myDID) 2598 did_changed = 0; 2599 else 2600 did_changed = 1; 2601 2602 vport->fc_prevDID = vport->fc_myDID; 2603 vport->num_disc_nodes = 0; 2604 2605 /* Start Discovery state <hba_state> */ 2606 lpfc_printf_vlog(vport, KERN_INFO, LOG_DISCOVERY, 2607 "0202 Start Discovery hba state x%x " 2608 "Data: x%x x%x x%x\n", 2609 vport->port_state, vport->fc_flag, vport->fc_plogi_cnt, 2610 vport->fc_adisc_cnt); 2611 2612 /* First do ADISCs - if any */ 2613 num_sent = lpfc_els_disc_adisc(vport); 2614 2615 if (num_sent) 2616 return; 2617 2618 /* 2619 * For SLI3, cmpl_reg_vpi will set port_state to READY, and 2620 * continue discovery. 2621 */ 2622 if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) && 2623 !(vport->fc_flag & FC_PT2PT) && 2624 !(vport->fc_flag & FC_RSCN_MODE)) { 2625 lpfc_issue_reg_vpi(phba, vport); 2626 return; 2627 } 2628 2629 /* 2630 * For SLI2, we need to set port_state to READY and continue 2631 * discovery. 2632 */ 2633 if (vport->port_state < LPFC_VPORT_READY && !clear_la_pending) { 2634 /* If we get here, there is nothing to ADISC */ 2635 if (vport->port_type == LPFC_PHYSICAL_PORT) 2636 lpfc_issue_clear_la(phba, vport); 2637 2638 if (!(vport->fc_flag & FC_ABORT_DISCOVERY)) { 2639 vport->num_disc_nodes = 0; 2640 /* go thru NPR nodes and issue ELS PLOGIs */ 2641 if (vport->fc_npr_cnt) 2642 lpfc_els_disc_plogi(vport); 2643 2644 if (!vport->num_disc_nodes) { 2645 spin_lock_irq(shost->host_lock); 2646 vport->fc_flag &= ~FC_NDISC_ACTIVE; 2647 spin_unlock_irq(shost->host_lock); 2648 lpfc_can_disctmo(vport); 2649 } 2650 } 2651 vport->port_state = LPFC_VPORT_READY; 2652 } else { 2653 /* Next do PLOGIs - if any */ 2654 num_sent = lpfc_els_disc_plogi(vport); 2655 2656 if (num_sent) 2657 return; 2658 2659 if (vport->fc_flag & FC_RSCN_MODE) { 2660 /* Check to see if more RSCNs came in while we 2661 * were processing this one. 2662 */ 2663 if ((vport->fc_rscn_id_cnt == 0) && 2664 (!(vport->fc_flag & FC_RSCN_DISCOVERY))) { 2665 spin_lock_irq(shost->host_lock); 2666 vport->fc_flag &= ~FC_RSCN_MODE; 2667 spin_unlock_irq(shost->host_lock); 2668 lpfc_can_disctmo(vport); 2669 } else 2670 lpfc_els_handle_rscn(vport); 2671 } 2672 } 2673 return; 2674} 2675 2676/* 2677 * Ignore completion for all IOCBs on tx and txcmpl queue for ELS 2678 * ring the match the sppecified nodelist. 2679 */ 2680static void 2681lpfc_free_tx(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp) 2682{ 2683 LIST_HEAD(completions); 2684 struct lpfc_sli *psli; 2685 IOCB_t *icmd; 2686 struct lpfc_iocbq *iocb, *next_iocb; 2687 struct lpfc_sli_ring *pring; 2688 2689 psli = &phba->sli; 2690 pring = &psli->ring[LPFC_ELS_RING]; 2691 2692 /* Error matching iocb on txq or txcmplq 2693 * First check the txq. 2694 */ 2695 spin_lock_irq(&phba->hbalock); 2696 list_for_each_entry_safe(iocb, next_iocb, &pring->txq, list) { 2697 if (iocb->context1 != ndlp) { 2698 continue; 2699 } 2700 icmd = &iocb->iocb; 2701 if ((icmd->ulpCommand == CMD_ELS_REQUEST64_CR) || 2702 (icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX)) { 2703 2704 list_move_tail(&iocb->list, &completions); 2705 pring->txq_cnt--; 2706 } 2707 } 2708 2709 /* Next check the txcmplq */ 2710 list_for_each_entry_safe(iocb, next_iocb, &pring->txcmplq, list) { 2711 if (iocb->context1 != ndlp) { 2712 continue; 2713 } 2714 icmd = &iocb->iocb; 2715 if (icmd->ulpCommand == CMD_ELS_REQUEST64_CR || 2716 icmd->ulpCommand == CMD_XMIT_ELS_RSP64_CX) { 2717 lpfc_sli_issue_abort_iotag(phba, pring, iocb); 2718 } 2719 } 2720 spin_unlock_irq(&phba->hbalock); 2721 2722 while (!list_empty(&completions)) { 2723 iocb = list_get_first(&completions, struct lpfc_iocbq, list); 2724 list_del_init(&iocb->list); 2725 2726 if (!iocb->iocb_cmpl) 2727 lpfc_sli_release_iocbq(phba, iocb); 2728 else { 2729 icmd = &iocb->iocb; 2730 icmd->ulpStatus = IOSTAT_LOCAL_REJECT; 2731 icmd->un.ulpWord[4] = IOERR_SLI_ABORTED; 2732 (iocb->iocb_cmpl) (phba, iocb, iocb); 2733 } 2734 } 2735} 2736 2737static void 2738lpfc_disc_flush_list(struct lpfc_vport *vport) 2739{ 2740 struct lpfc_nodelist *ndlp, *next_ndlp; 2741 struct lpfc_hba *phba = vport->phba; 2742 2743 if (vport->fc_plogi_cnt || vport->fc_adisc_cnt) { 2744 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, 2745 nlp_listp) { 2746 if (!NLP_CHK_NODE_ACT(ndlp)) 2747 continue; 2748 if (ndlp->nlp_state == NLP_STE_PLOGI_ISSUE || 2749 ndlp->nlp_state == NLP_STE_ADISC_ISSUE) { 2750 lpfc_free_tx(phba, ndlp); 2751 } 2752 } 2753 } 2754} 2755 2756void 2757lpfc_cleanup_discovery_resources(struct lpfc_vport *vport) 2758{ 2759 lpfc_els_flush_rscn(vport); 2760 lpfc_els_flush_cmd(vport); 2761 lpfc_disc_flush_list(vport); 2762} 2763 2764/*****************************************************************************/ 2765/* 2766 * NAME: lpfc_disc_timeout 2767 * 2768 * FUNCTION: Fibre Channel driver discovery timeout routine. 2769 * 2770 * EXECUTION ENVIRONMENT: interrupt only 2771 * 2772 * CALLED FROM: 2773 * Timer function 2774 * 2775 * RETURNS: 2776 * none 2777 */ 2778/*****************************************************************************/ 2779void 2780lpfc_disc_timeout(unsigned long ptr) 2781{ 2782 struct lpfc_vport *vport = (struct lpfc_vport *) ptr; 2783 struct lpfc_hba *phba = vport->phba; 2784 uint32_t tmo_posted; 2785 unsigned long flags = 0; 2786 2787 if (unlikely(!phba)) 2788 return; 2789 2790 spin_lock_irqsave(&vport->work_port_lock, flags); 2791 tmo_posted = vport->work_port_events & WORKER_DISC_TMO; 2792 if (!tmo_posted) 2793 vport->work_port_events |= WORKER_DISC_TMO; 2794 spin_unlock_irqrestore(&vport->work_port_lock, flags); 2795 2796 if (!tmo_posted) 2797 lpfc_worker_wake_up(phba); 2798 return; 2799} 2800 2801static void 2802lpfc_disc_timeout_handler(struct lpfc_vport *vport) 2803{ 2804 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 2805 struct lpfc_hba *phba = vport->phba; 2806 struct lpfc_sli *psli = &phba->sli; 2807 struct lpfc_nodelist *ndlp, *next_ndlp; 2808 LPFC_MBOXQ_t *initlinkmbox; 2809 int rc, clrlaerr = 0; 2810 2811 if (!(vport->fc_flag & FC_DISC_TMO)) 2812 return; 2813 2814 spin_lock_irq(shost->host_lock); 2815 vport->fc_flag &= ~FC_DISC_TMO; 2816 spin_unlock_irq(shost->host_lock); 2817 2818 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD, 2819 "disc timeout: state:x%x rtry:x%x flg:x%x", 2820 vport->port_state, vport->fc_ns_retry, vport->fc_flag); 2821 2822 switch (vport->port_state) { 2823 2824 case LPFC_LOCAL_CFG_LINK: 2825 /* port_state is identically LPFC_LOCAL_CFG_LINK while waiting for 2826 * FAN 2827 */ 2828 /* FAN timeout */ 2829 lpfc_printf_vlog(vport, KERN_WARNING, LOG_DISCOVERY, 2830 "0221 FAN timeout\n"); 2831 /* Start discovery by sending FLOGI, clean up old rpis */ 2832 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, 2833 nlp_listp) { 2834 if (!NLP_CHK_NODE_ACT(ndlp)) 2835 continue; 2836 if (ndlp->nlp_state != NLP_STE_NPR_NODE) 2837 continue; 2838 if (ndlp->nlp_type & NLP_FABRIC) { 2839 /* Clean up the ndlp on Fabric connections */ 2840 lpfc_drop_node(vport, ndlp); 2841 2842 } else if (!(ndlp->nlp_flag & NLP_NPR_ADISC)) { 2843 /* Fail outstanding IO now since device 2844 * is marked for PLOGI. 2845 */ 2846 lpfc_unreg_rpi(vport, ndlp); 2847 } 2848 } 2849 if (vport->port_state != LPFC_FLOGI) { 2850 lpfc_initial_flogi(vport); 2851 return; 2852 } 2853 break; 2854 2855 case LPFC_FDISC: 2856 case LPFC_FLOGI: 2857 /* port_state is identically LPFC_FLOGI while waiting for FLOGI cmpl */ 2858 /* Initial FLOGI timeout */ 2859 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2860 "0222 Initial %s timeout\n", 2861 vport->vpi ? "FDISC" : "FLOGI"); 2862 2863 /* Assume no Fabric and go on with discovery. 2864 * Check for outstanding ELS FLOGI to abort. 2865 */ 2866 2867 /* FLOGI failed, so just use loop map to make discovery list */ 2868 lpfc_disc_list_loopmap(vport); 2869 2870 /* Start discovery */ 2871 lpfc_disc_start(vport); 2872 break; 2873 2874 case LPFC_FABRIC_CFG_LINK: 2875 /* hba_state is identically LPFC_FABRIC_CFG_LINK while waiting for 2876 NameServer login */ 2877 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2878 "0223 Timeout while waiting for " 2879 "NameServer login\n"); 2880 /* Next look for NameServer ndlp */ 2881 ndlp = lpfc_findnode_did(vport, NameServer_DID); 2882 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) 2883 lpfc_els_abort(phba, ndlp); 2884 2885 /* ReStart discovery */ 2886 goto restart_disc; 2887 2888 case LPFC_NS_QRY: 2889 /* Check for wait for NameServer Rsp timeout */ 2890 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2891 "0224 NameServer Query timeout " 2892 "Data: x%x x%x\n", 2893 vport->fc_ns_retry, LPFC_MAX_NS_RETRY); 2894 2895 if (vport->fc_ns_retry < LPFC_MAX_NS_RETRY) { 2896 /* Try it one more time */ 2897 vport->fc_ns_retry++; 2898 rc = lpfc_ns_cmd(vport, SLI_CTNS_GID_FT, 2899 vport->fc_ns_retry, 0); 2900 if (rc == 0) 2901 break; 2902 } 2903 vport->fc_ns_retry = 0; 2904 2905restart_disc: 2906 /* 2907 * Discovery is over. 2908 * set port_state to PORT_READY if SLI2. 2909 * cmpl_reg_vpi will set port_state to READY for SLI3. 2910 */ 2911 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 2912 lpfc_issue_reg_vpi(phba, vport); 2913 else { /* NPIV Not enabled */ 2914 lpfc_issue_clear_la(phba, vport); 2915 vport->port_state = LPFC_VPORT_READY; 2916 } 2917 2918 /* Setup and issue mailbox INITIALIZE LINK command */ 2919 initlinkmbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL); 2920 if (!initlinkmbox) { 2921 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2922 "0206 Device Discovery " 2923 "completion error\n"); 2924 phba->link_state = LPFC_HBA_ERROR; 2925 break; 2926 } 2927 2928 lpfc_linkdown(phba); 2929 lpfc_init_link(phba, initlinkmbox, phba->cfg_topology, 2930 phba->cfg_link_speed); 2931 initlinkmbox->mb.un.varInitLnk.lipsr_AL_PA = 0; 2932 initlinkmbox->vport = vport; 2933 initlinkmbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl; 2934 rc = lpfc_sli_issue_mbox(phba, initlinkmbox, MBX_NOWAIT); 2935 lpfc_set_loopback_flag(phba); 2936 if (rc == MBX_NOT_FINISHED) 2937 mempool_free(initlinkmbox, phba->mbox_mem_pool); 2938 2939 break; 2940 2941 case LPFC_DISC_AUTH: 2942 /* Node Authentication timeout */ 2943 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2944 "0227 Node Authentication timeout\n"); 2945 lpfc_disc_flush_list(vport); 2946 2947 /* 2948 * set port_state to PORT_READY if SLI2. 2949 * cmpl_reg_vpi will set port_state to READY for SLI3. 2950 */ 2951 if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) 2952 lpfc_issue_reg_vpi(phba, vport); 2953 else { /* NPIV Not enabled */ 2954 lpfc_issue_clear_la(phba, vport); 2955 vport->port_state = LPFC_VPORT_READY; 2956 } 2957 break; 2958 2959 case LPFC_VPORT_READY: 2960 if (vport->fc_flag & FC_RSCN_MODE) { 2961 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2962 "0231 RSCN timeout Data: x%x " 2963 "x%x\n", 2964 vport->fc_ns_retry, LPFC_MAX_NS_RETRY); 2965 2966 /* Cleanup any outstanding ELS commands */ 2967 lpfc_els_flush_cmd(vport); 2968 2969 lpfc_els_flush_rscn(vport); 2970 lpfc_disc_flush_list(vport); 2971 } 2972 break; 2973 2974 default: 2975 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2976 "0273 Unexpected discovery timeout, " 2977 "vport State x%x\n", vport->port_state); 2978 break; 2979 } 2980 2981 switch (phba->link_state) { 2982 case LPFC_CLEAR_LA: 2983 /* CLEAR LA timeout */ 2984 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2985 "0228 CLEAR LA timeout\n"); 2986 clrlaerr = 1; 2987 break; 2988 2989 case LPFC_LINK_UP: 2990 lpfc_issue_clear_la(phba, vport); 2991 /* Drop thru */ 2992 case LPFC_LINK_UNKNOWN: 2993 case LPFC_WARM_START: 2994 case LPFC_INIT_START: 2995 case LPFC_INIT_MBX_CMDS: 2996 case LPFC_LINK_DOWN: 2997 case LPFC_HBA_ERROR: 2998 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY, 2999 "0230 Unexpected timeout, hba link " 3000 "state x%x\n", phba->link_state); 3001 clrlaerr = 1; 3002 break; 3003 3004 case LPFC_HBA_READY: 3005 break; 3006 } 3007 3008 if (clrlaerr) { 3009 lpfc_disc_flush_list(vport); 3010 psli->ring[(psli->extra_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 3011 psli->ring[(psli->fcp_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 3012 psli->ring[(psli->next_ring)].flag &= ~LPFC_STOP_IOCB_EVENT; 3013 vport->port_state = LPFC_VPORT_READY; 3014 } 3015 3016 return; 3017} 3018 3019/* 3020 * This routine handles processing a NameServer REG_LOGIN mailbox 3021 * command upon completion. It is setup in the LPFC_MBOXQ 3022 * as the completion routine when the command is 3023 * handed off to the SLI layer. 3024 */ 3025void 3026lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb) 3027{ 3028 MAILBOX_t *mb = &pmb->mb; 3029 struct lpfc_dmabuf *mp = (struct lpfc_dmabuf *) (pmb->context1); 3030 struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2; 3031 struct lpfc_vport *vport = pmb->vport; 3032 3033 pmb->context1 = NULL; 3034 3035 ndlp->nlp_rpi = mb->un.varWords[0]; 3036 ndlp->nlp_type |= NLP_FABRIC; 3037 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE); 3038 3039 /* 3040 * Start issuing Fabric-Device Management Interface (FDMI) command to 3041 * 0xfffffa (FDMI well known port) or Delay issuing FDMI command if 3042 * fdmi-on=2 (supporting RPA/hostnmae) 3043 */ 3044 3045 if (vport->cfg_fdmi_on == 1) 3046 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA); 3047 else 3048 mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60); 3049 3050 /* decrement the node reference count held for this callback 3051 * function. 3052 */ 3053 lpfc_nlp_put(ndlp); 3054 lpfc_mbuf_free(phba, mp->virt, mp->phys); 3055 kfree(mp); 3056 mempool_free(pmb, phba->mbox_mem_pool); 3057 3058 return; 3059} 3060 3061static int 3062lpfc_filter_by_rpi(struct lpfc_nodelist *ndlp, void *param) 3063{ 3064 uint16_t *rpi = param; 3065 3066 return ndlp->nlp_rpi == *rpi; 3067} 3068 3069static int 3070lpfc_filter_by_wwpn(struct lpfc_nodelist *ndlp, void *param) 3071{ 3072 return memcmp(&ndlp->nlp_portname, param, 3073 sizeof(ndlp->nlp_portname)) == 0; 3074} 3075 3076static struct lpfc_nodelist * 3077__lpfc_find_node(struct lpfc_vport *vport, node_filter filter, void *param) 3078{ 3079 struct lpfc_nodelist *ndlp; 3080 3081 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) { 3082 if (filter(ndlp, param)) 3083 return ndlp; 3084 } 3085 return NULL; 3086} 3087 3088/* 3089 * This routine looks up the ndlp lists for the given RPI. If rpi found it 3090 * returns the node list element pointer else return NULL. 3091 */ 3092struct lpfc_nodelist * 3093__lpfc_findnode_rpi(struct lpfc_vport *vport, uint16_t rpi) 3094{ 3095 return __lpfc_find_node(vport, lpfc_filter_by_rpi, &rpi); 3096} 3097 3098/* 3099 * This routine looks up the ndlp lists for the given WWPN. If WWPN found it 3100 * returns the node element list pointer else return NULL. 3101 */ 3102struct lpfc_nodelist * 3103lpfc_findnode_wwpn(struct lpfc_vport *vport, struct lpfc_name *wwpn) 3104{ 3105 struct Scsi_Host *shost = lpfc_shost_from_vport(vport); 3106 struct lpfc_nodelist *ndlp; 3107 3108 spin_lock_irq(shost->host_lock); 3109 ndlp = __lpfc_find_node(vport, lpfc_filter_by_wwpn, wwpn); 3110 spin_unlock_irq(shost->host_lock); 3111 return ndlp; 3112} 3113 3114void 3115lpfc_nlp_init(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp, 3116 uint32_t did) 3117{ 3118 memset(ndlp, 0, sizeof (struct lpfc_nodelist)); 3119 INIT_LIST_HEAD(&ndlp->els_retry_evt.evt_listp); 3120 INIT_LIST_HEAD(&ndlp->dev_loss_evt.evt_listp); 3121 init_timer(&ndlp->nlp_delayfunc); 3122 ndlp->nlp_delayfunc.function = lpfc_els_retry_delay; 3123 ndlp->nlp_delayfunc.data = (unsigned long)ndlp; 3124 ndlp->nlp_DID = did; 3125 ndlp->vport = vport; 3126 ndlp->nlp_sid = NLP_NO_SID; 3127 INIT_LIST_HEAD(&ndlp->nlp_listp); 3128 kref_init(&ndlp->kref); 3129 NLP_INT_NODE_ACT(ndlp); 3130 atomic_set(&ndlp->cmd_pending, 0); 3131 ndlp->cmd_qdepth = LPFC_MAX_TGT_QDEPTH; 3132 3133 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_NODE, 3134 "node init: did:x%x", 3135 ndlp->nlp_DID, 0, 0); 3136 3137 return; 3138} 3139 3140/* This routine releases all resources associated with a specifc NPort's ndlp 3141 * and mempool_free's the nodelist. 3142 */ 3143static void 3144lpfc_nlp_release(struct kref *kref) 3145{ 3146 struct lpfc_hba *phba; 3147 unsigned long flags; 3148 struct lpfc_nodelist *ndlp = container_of(kref, struct lpfc_nodelist, 3149 kref); 3150 3151 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE, 3152 "node release: did:x%x flg:x%x type:x%x", 3153 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type); 3154 3155 lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE, 3156 "0279 lpfc_nlp_release: ndlp:x%p " 3157 "usgmap:x%x refcnt:%d\n", 3158 (void *)ndlp, ndlp->nlp_usg_map, 3159 atomic_read(&ndlp->kref.refcount)); 3160 3161 /* remove ndlp from action. */ 3162 lpfc_nlp_remove(ndlp->vport, ndlp); 3163 3164 /* clear the ndlp active flag for all release cases */ 3165 phba = ndlp->vport->phba; 3166 spin_lock_irqsave(&phba->ndlp_lock, flags); 3167 NLP_CLR_NODE_ACT(ndlp); 3168 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3169 3170 /* free ndlp memory for final ndlp release */ 3171 if (NLP_CHK_FREE_REQ(ndlp)) { 3172 kfree(ndlp->lat_data); 3173 mempool_free(ndlp, ndlp->vport->phba->nlp_mem_pool); 3174 } 3175} 3176 3177/* This routine bumps the reference count for a ndlp structure to ensure 3178 * that one discovery thread won't free a ndlp while another discovery thread 3179 * is using it. 3180 */ 3181struct lpfc_nodelist * 3182lpfc_nlp_get(struct lpfc_nodelist *ndlp) 3183{ 3184 struct lpfc_hba *phba; 3185 unsigned long flags; 3186 3187 if (ndlp) { 3188 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE, 3189 "node get: did:x%x flg:x%x refcnt:x%x", 3190 ndlp->nlp_DID, ndlp->nlp_flag, 3191 atomic_read(&ndlp->kref.refcount)); 3192 /* The check of ndlp usage to prevent incrementing the 3193 * ndlp reference count that is in the process of being 3194 * released. 3195 */ 3196 phba = ndlp->vport->phba; 3197 spin_lock_irqsave(&phba->ndlp_lock, flags); 3198 if (!NLP_CHK_NODE_ACT(ndlp) || NLP_CHK_FREE_ACK(ndlp)) { 3199 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3200 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE, 3201 "0276 lpfc_nlp_get: ndlp:x%p " 3202 "usgmap:x%x refcnt:%d\n", 3203 (void *)ndlp, ndlp->nlp_usg_map, 3204 atomic_read(&ndlp->kref.refcount)); 3205 return NULL; 3206 } else 3207 kref_get(&ndlp->kref); 3208 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3209 } 3210 return ndlp; 3211} 3212 3213/* This routine decrements the reference count for a ndlp structure. If the 3214 * count goes to 0, this indicates the the associated nodelist should be 3215 * freed. Returning 1 indicates the ndlp resource has been released; on the 3216 * other hand, returning 0 indicates the ndlp resource has not been released 3217 * yet. 3218 */ 3219int 3220lpfc_nlp_put(struct lpfc_nodelist *ndlp) 3221{ 3222 struct lpfc_hba *phba; 3223 unsigned long flags; 3224 3225 if (!ndlp) 3226 return 1; 3227 3228 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE, 3229 "node put: did:x%x flg:x%x refcnt:x%x", 3230 ndlp->nlp_DID, ndlp->nlp_flag, 3231 atomic_read(&ndlp->kref.refcount)); 3232 phba = ndlp->vport->phba; 3233 spin_lock_irqsave(&phba->ndlp_lock, flags); 3234 /* Check the ndlp memory free acknowledge flag to avoid the 3235 * possible race condition that kref_put got invoked again 3236 * after previous one has done ndlp memory free. 3237 */ 3238 if (NLP_CHK_FREE_ACK(ndlp)) { 3239 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3240 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE, 3241 "0274 lpfc_nlp_put: ndlp:x%p " 3242 "usgmap:x%x refcnt:%d\n", 3243 (void *)ndlp, ndlp->nlp_usg_map, 3244 atomic_read(&ndlp->kref.refcount)); 3245 return 1; 3246 } 3247 /* Check the ndlp inactivate log flag to avoid the possible 3248 * race condition that kref_put got invoked again after ndlp 3249 * is already in inactivating state. 3250 */ 3251 if (NLP_CHK_IACT_REQ(ndlp)) { 3252 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3253 lpfc_printf_vlog(ndlp->vport, KERN_WARNING, LOG_NODE, 3254 "0275 lpfc_nlp_put: ndlp:x%p " 3255 "usgmap:x%x refcnt:%d\n", 3256 (void *)ndlp, ndlp->nlp_usg_map, 3257 atomic_read(&ndlp->kref.refcount)); 3258 return 1; 3259 } 3260 /* For last put, mark the ndlp usage flags to make sure no 3261 * other kref_get and kref_put on the same ndlp shall get 3262 * in between the process when the final kref_put has been 3263 * invoked on this ndlp. 3264 */ 3265 if (atomic_read(&ndlp->kref.refcount) == 1) { 3266 /* Indicate ndlp is put to inactive state. */ 3267 NLP_SET_IACT_REQ(ndlp); 3268 /* Acknowledge ndlp memory free has been seen. */ 3269 if (NLP_CHK_FREE_REQ(ndlp)) 3270 NLP_SET_FREE_ACK(ndlp); 3271 } 3272 spin_unlock_irqrestore(&phba->ndlp_lock, flags); 3273 /* Note, the kref_put returns 1 when decrementing a reference 3274 * count that was 1, it invokes the release callback function, 3275 * but it still left the reference count as 1 (not actually 3276 * performs the last decrementation). Otherwise, it actually 3277 * decrements the reference count and returns 0. 3278 */ 3279 return kref_put(&ndlp->kref, lpfc_nlp_release); 3280} 3281 3282/* This routine free's the specified nodelist if it is not in use 3283 * by any other discovery thread. This routine returns 1 if the 3284 * ndlp has been freed. A return value of 0 indicates the ndlp is 3285 * not yet been released. 3286 */ 3287int 3288lpfc_nlp_not_used(struct lpfc_nodelist *ndlp) 3289{ 3290 lpfc_debugfs_disc_trc(ndlp->vport, LPFC_DISC_TRC_NODE, 3291 "node not used: did:x%x flg:x%x refcnt:x%x", 3292 ndlp->nlp_DID, ndlp->nlp_flag, 3293 atomic_read(&ndlp->kref.refcount)); 3294 if (atomic_read(&ndlp->kref.refcount) == 1) 3295 if (lpfc_nlp_put(ndlp)) 3296 return 1; 3297 return 0; 3298}