1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/blkdev.h>
25#include <linux/delay.h>
26#include <linux/dma-mapping.h>
27#include <linux/idr.h>
28#include <linux/interrupt.h>
29#include <linux/kthread.h>
30#include <linux/pci.h>
31#include <linux/slab.h>
32#include <linux/spinlock.h>
33#include <linux/sched/signal.h>
34
35#include <scsi/scsi.h>
36#include <scsi/scsi_device.h>
37#include <scsi/scsi_host.h>
38#include <scsi/scsi_transport_fc.h>
39
40#include "lpfc_hw4.h"
41#include "lpfc_hw.h"
42#include "lpfc_sli.h"
43#include "lpfc_sli4.h"
44#include "lpfc_nl.h"
45#include "lpfc_disc.h"
46#include "lpfc_scsi.h"
47#include "lpfc.h"
48#include "lpfc_logmsg.h"
49#include "lpfc_crtn.h"
50#include "lpfc_version.h"
51#include "lpfc_vport.h"
52
53inline void lpfc_vport_set_state(struct lpfc_vport *vport,
54 enum fc_vport_state new_state)
55{
56 struct fc_vport *fc_vport = vport->fc_vport;
57
58 if (fc_vport) {
59
60
61
62
63
64 if (new_state != FC_VPORT_INITIALIZING)
65 fc_vport->vport_last_state = fc_vport->vport_state;
66 fc_vport->vport_state = new_state;
67 }
68
69
70 switch (new_state) {
71 case FC_VPORT_NO_FABRIC_SUPP:
72 case FC_VPORT_NO_FABRIC_RSCS:
73 case FC_VPORT_FABRIC_LOGOUT:
74 case FC_VPORT_FABRIC_REJ_WWN:
75 case FC_VPORT_FAILED:
76 vport->port_state = LPFC_VPORT_FAILED;
77 break;
78 case FC_VPORT_LINKDOWN:
79 vport->port_state = LPFC_VPORT_UNKNOWN;
80 break;
81 default:
82
83 break;
84 }
85}
86
87int
88lpfc_alloc_vpi(struct lpfc_hba *phba)
89{
90 unsigned long vpi;
91
92 spin_lock_irq(&phba->hbalock);
93
94 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1);
95 if (vpi > phba->max_vpi)
96 vpi = 0;
97 else
98 set_bit(vpi, phba->vpi_bmask);
99 if (phba->sli_rev == LPFC_SLI_REV4)
100 phba->sli4_hba.max_cfg_param.vpi_used++;
101 spin_unlock_irq(&phba->hbalock);
102 return vpi;
103}
104
105static void
106lpfc_free_vpi(struct lpfc_hba *phba, int vpi)
107{
108 if (vpi == 0)
109 return;
110 spin_lock_irq(&phba->hbalock);
111 clear_bit(vpi, phba->vpi_bmask);
112 if (phba->sli_rev == LPFC_SLI_REV4)
113 phba->sli4_hba.max_cfg_param.vpi_used--;
114 spin_unlock_irq(&phba->hbalock);
115}
116
117static int
118lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport)
119{
120 LPFC_MBOXQ_t *pmb;
121 MAILBOX_t *mb;
122 struct lpfc_dmabuf *mp;
123 int rc;
124
125 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
126 if (!pmb) {
127 return -ENOMEM;
128 }
129 mb = &pmb->u.mb;
130
131 rc = lpfc_read_sparam(phba, pmb, vport->vpi);
132 if (rc) {
133 mempool_free(pmb, phba->mbox_mem_pool);
134 return -ENOMEM;
135 }
136
137
138
139
140
141 mp = (struct lpfc_dmabuf *) pmb->context1;
142 pmb->context1 = NULL;
143
144 pmb->vport = vport;
145 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);
146 if (rc != MBX_SUCCESS) {
147 if (signal_pending(current)) {
148 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
149 "1830 Signal aborted mbxCmd x%x\n",
150 mb->mbxCommand);
151 lpfc_mbuf_free(phba, mp->virt, mp->phys);
152 kfree(mp);
153 if (rc != MBX_TIMEOUT)
154 mempool_free(pmb, phba->mbox_mem_pool);
155 return -EINTR;
156 } else {
157 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
158 "1818 VPort failed init, mbxCmd x%x "
159 "READ_SPARM mbxStatus x%x, rc = x%x\n",
160 mb->mbxCommand, mb->mbxStatus, rc);
161 lpfc_mbuf_free(phba, mp->virt, mp->phys);
162 kfree(mp);
163 if (rc != MBX_TIMEOUT)
164 mempool_free(pmb, phba->mbox_mem_pool);
165 return -EIO;
166 }
167 }
168
169 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
170 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
171 sizeof (struct lpfc_name));
172 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
173 sizeof (struct lpfc_name));
174
175 lpfc_mbuf_free(phba, mp->virt, mp->phys);
176 kfree(mp);
177 mempool_free(pmb, phba->mbox_mem_pool);
178
179 return 0;
180}
181
182static int
183lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn,
184 const char *name_type)
185{
186
187
188
189 if (!((wwn->u.wwn[0] >> 4) == 1 &&
190 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0)))
191 return 1;
192
193 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
194 "1822 Invalid %s: %02x:%02x:%02x:%02x:"
195 "%02x:%02x:%02x:%02x\n",
196 name_type,
197 wwn->u.wwn[0], wwn->u.wwn[1],
198 wwn->u.wwn[2], wwn->u.wwn[3],
199 wwn->u.wwn[4], wwn->u.wwn[5],
200 wwn->u.wwn[6], wwn->u.wwn[7]);
201 return 0;
202}
203
204static int
205lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport)
206{
207 struct lpfc_vport *vport;
208 unsigned long flags;
209
210 spin_lock_irqsave(&phba->hbalock, flags);
211 list_for_each_entry(vport, &phba->port_list, listentry) {
212 if (vport == new_vport)
213 continue;
214
215 if (memcmp(&vport->fc_sparam.portName,
216 &new_vport->fc_sparam.portName,
217 sizeof(struct lpfc_name)) == 0) {
218 spin_unlock_irqrestore(&phba->hbalock, flags);
219 return 0;
220 }
221 }
222 spin_unlock_irqrestore(&phba->hbalock, flags);
223 return 1;
224}
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241static void lpfc_discovery_wait(struct lpfc_vport *vport)
242{
243 struct lpfc_hba *phba = vport->phba;
244 uint32_t wait_flags = 0;
245 unsigned long wait_time_max;
246 unsigned long start_time;
247
248 wait_flags = FC_RSCN_MODE | FC_RSCN_DISCOVERY | FC_NLP_MORE |
249 FC_RSCN_DEFERRED | FC_NDISC_ACTIVE | FC_DISC_TMO;
250
251
252
253
254
255
256 wait_time_max = msecs_to_jiffies(((phba->fc_ratov * 3) + 3) * 1000);
257 wait_time_max += jiffies;
258 start_time = jiffies;
259 while (time_before(jiffies, wait_time_max)) {
260 if ((vport->num_disc_nodes > 0) ||
261 (vport->fc_flag & wait_flags) ||
262 ((vport->port_state > LPFC_VPORT_FAILED) &&
263 (vport->port_state < LPFC_VPORT_READY))) {
264 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT,
265 "1833 Vport discovery quiesce Wait:"
266 " state x%x fc_flags x%x"
267 " num_nodes x%x, waiting 1000 msecs"
268 " total wait msecs x%x\n",
269 vport->port_state, vport->fc_flag,
270 vport->num_disc_nodes,
271 jiffies_to_msecs(jiffies - start_time));
272 msleep(1000);
273 } else {
274
275 lpfc_printf_vlog(vport, KERN_INFO, LOG_VPORT,
276 "1834 Vport discovery quiesced:"
277 " state x%x fc_flags x%x"
278 " wait msecs x%x\n",
279 vport->port_state, vport->fc_flag,
280 jiffies_to_msecs(jiffies
281 - start_time));
282 break;
283 }
284 }
285
286 if (time_after(jiffies, wait_time_max))
287 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
288 "1835 Vport discovery quiesce failed:"
289 " state x%x fc_flags x%x wait msecs x%x\n",
290 vport->port_state, vport->fc_flag,
291 jiffies_to_msecs(jiffies - start_time));
292}
293
294int
295lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
296{
297 struct lpfc_nodelist *ndlp;
298 struct Scsi_Host *shost = fc_vport->shost;
299 struct lpfc_vport *pport = (struct lpfc_vport *) shost->hostdata;
300 struct lpfc_hba *phba = pport->phba;
301 struct lpfc_vport *vport = NULL;
302 int instance;
303 int vpi;
304 int rc = VPORT_ERROR;
305 int status;
306
307 if ((phba->sli_rev < 3) || !(phba->cfg_enable_npiv)) {
308 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
309 "1808 Create VPORT failed: "
310 "NPIV is not enabled: SLImode:%d\n",
311 phba->sli_rev);
312 rc = VPORT_INVAL;
313 goto error_out;
314 }
315
316
317 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME) {
318 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
319 "3189 Create VPORT failed: "
320 "NPIV is not supported on NVME\n");
321 rc = VPORT_INVAL;
322 goto error_out;
323 }
324
325 vpi = lpfc_alloc_vpi(phba);
326 if (vpi == 0) {
327 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
328 "1809 Create VPORT failed: "
329 "Max VPORTs (%d) exceeded\n",
330 phba->max_vpi);
331 rc = VPORT_NORESOURCES;
332 goto error_out;
333 }
334
335
336 if ((instance = lpfc_get_instance()) < 0) {
337 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
338 "1810 Create VPORT failed: Cannot get "
339 "instance number\n");
340 lpfc_free_vpi(phba, vpi);
341 rc = VPORT_NORESOURCES;
342 goto error_out;
343 }
344
345 vport = lpfc_create_port(phba, instance, &fc_vport->dev);
346 if (!vport) {
347 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
348 "1811 Create VPORT failed: vpi x%x\n", vpi);
349 lpfc_free_vpi(phba, vpi);
350 rc = VPORT_NORESOURCES;
351 goto error_out;
352 }
353
354 vport->vpi = vpi;
355 lpfc_debugfs_initialize(vport);
356
357 if ((status = lpfc_vport_sparm(phba, vport))) {
358 if (status == -EINTR) {
359 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
360 "1831 Create VPORT Interrupted.\n");
361 rc = VPORT_ERROR;
362 } else {
363 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
364 "1813 Create VPORT failed. "
365 "Cannot get sparam\n");
366 rc = VPORT_NORESOURCES;
367 }
368 lpfc_free_vpi(phba, vpi);
369 destroy_port(vport);
370 goto error_out;
371 }
372
373 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
374 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
375
376 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
377 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
378
379 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
380 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
381 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
382 "1821 Create VPORT failed. "
383 "Invalid WWN format\n");
384 lpfc_free_vpi(phba, vpi);
385 destroy_port(vport);
386 rc = VPORT_INVAL;
387 goto error_out;
388 }
389
390 if (!lpfc_unique_wwpn(phba, vport)) {
391 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
392 "1823 Create VPORT failed. "
393 "Duplicate WWN on HBA\n");
394 lpfc_free_vpi(phba, vpi);
395 destroy_port(vport);
396 rc = VPORT_INVAL;
397 goto error_out;
398 }
399
400
401 lpfc_alloc_sysfs_attr(vport);
402
403
404 vport->cfg_lun_queue_depth = phba->pport->cfg_lun_queue_depth;
405
406 *(struct lpfc_vport **)fc_vport->dd_data = vport;
407 vport->fc_vport = fc_vport;
408
409
410 vport->load_flag |= FC_ALLOW_FDMI;
411 if (phba->cfg_enable_SmartSAN ||
412 (phba->cfg_fdmi_on == LPFC_FDMI_SUPPORT)) {
413
414 vport->fdmi_hba_mask = phba->pport->fdmi_hba_mask;
415 vport->fdmi_port_mask = phba->pport->fdmi_port_mask;
416 }
417
418 if ((phba->nvmet_support == 0) &&
419 ((phba->cfg_enable_fc4_type == LPFC_ENABLE_BOTH) ||
420 (phba->cfg_enable_fc4_type == LPFC_ENABLE_NVME))) {
421
422
423
424 rc = lpfc_nvme_create_localport(vport);
425 if (rc) {
426 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
427 "6003 %s status x%x\n",
428 "NVME registration failed, ",
429 rc);
430 goto error_out;
431 }
432 }
433
434
435
436
437
438 if ((phba->sli_rev == LPFC_SLI_REV4) &&
439 (pport->fc_flag & FC_VFI_REGISTERED)) {
440 rc = lpfc_sli4_init_vpi(vport);
441 if (rc) {
442 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
443 "1838 Failed to INIT_VPI on vpi %d "
444 "status %d\n", vpi, rc);
445 rc = VPORT_NORESOURCES;
446 lpfc_free_vpi(phba, vpi);
447 goto error_out;
448 }
449 } else if (phba->sli_rev == LPFC_SLI_REV4) {
450
451
452
453
454 vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
455 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
456 rc = VPORT_OK;
457 goto out;
458 }
459
460 if ((phba->link_state < LPFC_LINK_UP) ||
461 (pport->port_state < LPFC_FABRIC_CFG_LINK) ||
462 (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
463 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
464 rc = VPORT_OK;
465 goto out;
466 }
467
468 if (disable) {
469 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
470 rc = VPORT_OK;
471 goto out;
472 }
473
474
475
476
477 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
478 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
479 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
480 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
481 lpfc_set_disctmo(vport);
482 lpfc_initial_fdisc(vport);
483 } else {
484 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
485 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
486 "0262 No NPIV Fabric support\n");
487 }
488 } else {
489 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
490 }
491 rc = VPORT_OK;
492
493out:
494 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
495 "1825 Vport Created.\n");
496 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
497error_out:
498 return rc;
499}
500
501static int
502disable_vport(struct fc_vport *fc_vport)
503{
504 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
505 struct lpfc_hba *phba = vport->phba;
506 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
507 long timeout;
508 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
509
510 ndlp = lpfc_findnode_did(vport, Fabric_DID);
511 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
512 && phba->link_state >= LPFC_LINK_UP) {
513 vport->unreg_vpi_cmpl = VPORT_INVAL;
514 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
515 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
516 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
517 timeout = schedule_timeout(timeout);
518 }
519
520 lpfc_sli_host_down(vport);
521
522
523
524
525 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
526 if (!NLP_CHK_NODE_ACT(ndlp))
527 continue;
528 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
529 continue;
530 lpfc_disc_state_machine(vport, ndlp, NULL,
531 NLP_EVT_DEVICE_RECOVERY);
532 }
533 lpfc_cleanup_rpis(vport, 1);
534
535 lpfc_stop_vport_timers(vport);
536 lpfc_unreg_all_rpis(vport);
537 lpfc_unreg_default_rpis(vport);
538
539
540
541
542 lpfc_mbx_unreg_vpi(vport);
543 spin_lock_irq(shost->host_lock);
544 vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
545 spin_unlock_irq(shost->host_lock);
546
547 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
548 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
549 "1826 Vport Disabled.\n");
550 return VPORT_OK;
551}
552
553static int
554enable_vport(struct fc_vport *fc_vport)
555{
556 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
557 struct lpfc_hba *phba = vport->phba;
558 struct lpfc_nodelist *ndlp = NULL;
559 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
560
561 if ((phba->link_state < LPFC_LINK_UP) ||
562 (phba->fc_topology == LPFC_TOPOLOGY_LOOP)) {
563 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
564 return VPORT_OK;
565 }
566
567 spin_lock_irq(shost->host_lock);
568 vport->load_flag |= FC_LOADING;
569 if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI) {
570 spin_unlock_irq(shost->host_lock);
571 lpfc_issue_init_vpi(vport);
572 goto out;
573 }
574
575 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
576 spin_unlock_irq(shost->host_lock);
577
578
579
580
581 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
582 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
583 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
584 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
585 lpfc_set_disctmo(vport);
586 lpfc_initial_fdisc(vport);
587 } else {
588 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
589 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
590 "0264 No NPIV Fabric support\n");
591 }
592 } else {
593 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
594 }
595
596out:
597 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
598 "1827 Vport Enabled.\n");
599 return VPORT_OK;
600}
601
602int
603lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
604{
605 if (disable)
606 return disable_vport(fc_vport);
607 else
608 return enable_vport(fc_vport);
609}
610
611
612int
613lpfc_vport_delete(struct fc_vport *fc_vport)
614{
615 struct lpfc_nodelist *ndlp = NULL;
616 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
617 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
618 struct lpfc_hba *phba = vport->phba;
619 long timeout;
620 bool ns_ndlp_referenced = false;
621
622 if (vport->port_type == LPFC_PHYSICAL_PORT) {
623 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
624 "1812 vport_delete failed: Cannot delete "
625 "physical host\n");
626 return VPORT_ERROR;
627 }
628
629
630 if ((vport->vport_flag & STATIC_VPORT) &&
631 !(phba->pport->load_flag & FC_UNLOADING)) {
632 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
633 "1837 vport_delete failed: Cannot delete "
634 "static vport.\n");
635 return VPORT_ERROR;
636 }
637 spin_lock_irq(&phba->hbalock);
638 vport->load_flag |= FC_UNLOADING;
639 spin_unlock_irq(&phba->hbalock);
640
641
642
643
644 if (!(phba->pport->load_flag & FC_UNLOADING)) {
645 int check_count = 0;
646 while (check_count < ((phba->fc_ratov * 3) + 3) &&
647 vport->port_state > LPFC_VPORT_FAILED &&
648 vport->port_state < LPFC_VPORT_READY) {
649 check_count++;
650 msleep(1000);
651 }
652 if (vport->port_state > LPFC_VPORT_FAILED &&
653 vport->port_state < LPFC_VPORT_READY)
654 return -EAGAIN;
655 }
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671 if (!scsi_host_get(shost))
672 return VPORT_INVAL;
673 if (!scsi_host_get(shost)) {
674 scsi_host_put(shost);
675 return VPORT_INVAL;
676 }
677 lpfc_free_sysfs_attr(vport);
678
679 lpfc_debugfs_terminate(vport);
680
681
682
683
684
685
686
687 ndlp = lpfc_findnode_did(vport, NameServer_DID);
688 if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
689 lpfc_nlp_get(ndlp);
690 ns_ndlp_referenced = true;
691 }
692
693
694 fc_remove_host(shost);
695 scsi_remove_host(shost);
696
697 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
698
699
700
701
702
703 if (phba->pport->load_flag & FC_UNLOADING) {
704 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
705 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
706 phba->link_state >= LPFC_LINK_UP) {
707
708 ndlp = lpfc_findnode_did(vport, Fabric_DID);
709 if (!ndlp)
710 goto skip_logo;
711 else if (!NLP_CHK_NODE_ACT(ndlp)) {
712 ndlp = lpfc_enable_node(vport, ndlp,
713 NLP_STE_UNUSED_NODE);
714 if (!ndlp)
715 goto skip_logo;
716 }
717
718 lpfc_dequeue_node(vport, ndlp);
719
720
721 spin_lock_irq(&phba->ndlp_lock);
722 NLP_SET_FREE_REQ(ndlp);
723 spin_unlock_irq(&phba->ndlp_lock);
724
725 lpfc_nlp_put(ndlp);
726 }
727 goto skip_logo;
728 }
729
730
731 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
732 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
733 phba->link_state >= LPFC_LINK_UP &&
734 phba->fc_topology != LPFC_TOPOLOGY_LOOP) {
735 if (vport->cfg_enable_da_id) {
736 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
737 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
738 while (vport->ct_flags && timeout)
739 timeout = schedule_timeout(timeout);
740 else
741 lpfc_printf_log(vport->phba, KERN_WARNING,
742 LOG_VPORT,
743 "1829 CT command failed to "
744 "delete objects on fabric\n");
745 }
746
747 ndlp = lpfc_findnode_did(vport, Fabric_DID);
748 if (!ndlp) {
749
750 ndlp = lpfc_nlp_init(vport, Fabric_DID);
751 if (!ndlp)
752 goto skip_logo;
753
754 NLP_SET_FREE_REQ(ndlp);
755 } else {
756 if (!NLP_CHK_NODE_ACT(ndlp)) {
757 ndlp = lpfc_enable_node(vport, ndlp,
758 NLP_STE_UNUSED_NODE);
759 if (!ndlp)
760 goto skip_logo;
761 }
762
763
764 lpfc_dequeue_node(vport, ndlp);
765 spin_lock_irq(&phba->ndlp_lock);
766 if (!NLP_CHK_FREE_REQ(ndlp))
767
768 NLP_SET_FREE_REQ(ndlp);
769 else {
770
771 spin_unlock_irq(&phba->ndlp_lock);
772 goto skip_logo;
773 }
774 spin_unlock_irq(&phba->ndlp_lock);
775 }
776
777
778
779
780
781
782 if (!(vport->vpi_state & LPFC_VPI_REGISTERED)) {
783 lpfc_nlp_put(ndlp);
784 goto skip_logo;
785 }
786
787 vport->unreg_vpi_cmpl = VPORT_INVAL;
788 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
789 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
790 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
791 timeout = schedule_timeout(timeout);
792 }
793
794 if (!(phba->pport->load_flag & FC_UNLOADING))
795 lpfc_discovery_wait(vport);
796
797skip_logo:
798
799
800
801
802
803 if (ns_ndlp_referenced) {
804 ndlp = lpfc_findnode_did(vport, NameServer_DID);
805 lpfc_nlp_put(ndlp);
806 }
807
808 lpfc_cleanup(vport);
809 lpfc_sli_host_down(vport);
810
811 lpfc_stop_vport_timers(vport);
812
813 if (!(phba->pport->load_flag & FC_UNLOADING)) {
814 lpfc_unreg_all_rpis(vport);
815 lpfc_unreg_default_rpis(vport);
816
817
818
819
820 if (!(vport->vpi_state & LPFC_VPI_REGISTERED) ||
821 lpfc_mbx_unreg_vpi(vport))
822 scsi_host_put(shost);
823 } else
824 scsi_host_put(shost);
825
826 lpfc_free_vpi(phba, vport->vpi);
827 vport->work_port_events = 0;
828 spin_lock_irq(&phba->hbalock);
829 list_del_init(&vport->listentry);
830 spin_unlock_irq(&phba->hbalock);
831 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
832 "1828 Vport Deleted.\n");
833 scsi_host_put(shost);
834 return VPORT_OK;
835}
836
837struct lpfc_vport **
838lpfc_create_vport_work_array(struct lpfc_hba *phba)
839{
840 struct lpfc_vport *port_iterator;
841 struct lpfc_vport **vports;
842 int index = 0;
843 vports = kzalloc((phba->max_vports + 1) * sizeof(struct lpfc_vport *),
844 GFP_KERNEL);
845 if (vports == NULL)
846 return NULL;
847 spin_lock_irq(&phba->hbalock);
848 list_for_each_entry(port_iterator, &phba->port_list, listentry) {
849 if (port_iterator->load_flag & FC_UNLOADING)
850 continue;
851 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
852 lpfc_printf_vlog(port_iterator, KERN_ERR, LOG_VPORT,
853 "1801 Create vport work array FAILED: "
854 "cannot do scsi_host_get\n");
855 continue;
856 }
857 vports[index++] = port_iterator;
858 }
859 spin_unlock_irq(&phba->hbalock);
860 return vports;
861}
862
863void
864lpfc_destroy_vport_work_array(struct lpfc_hba *phba, struct lpfc_vport **vports)
865{
866 int i;
867 if (vports == NULL)
868 return;
869 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
870 scsi_host_put(lpfc_shost_from_vport(vports[i]));
871 kfree(vports);
872}
873
874
875
876
877
878
879
880
881
882void
883lpfc_vport_reset_stat_data(struct lpfc_vport *vport)
884{
885 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
886
887 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
888 if (!NLP_CHK_NODE_ACT(ndlp))
889 continue;
890 if (ndlp->lat_data)
891 memset(ndlp->lat_data, 0, LPFC_MAX_BUCKET_COUNT *
892 sizeof(struct lpfc_scsicmd_bkt));
893 }
894}
895
896
897
898
899
900
901
902
903
904void
905lpfc_alloc_bucket(struct lpfc_vport *vport)
906{
907 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
908
909 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
910 if (!NLP_CHK_NODE_ACT(ndlp))
911 continue;
912
913 kfree(ndlp->lat_data);
914 ndlp->lat_data = NULL;
915
916 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE) {
917 ndlp->lat_data = kcalloc(LPFC_MAX_BUCKET_COUNT,
918 sizeof(struct lpfc_scsicmd_bkt),
919 GFP_ATOMIC);
920
921 if (!ndlp->lat_data)
922 lpfc_printf_vlog(vport, KERN_ERR, LOG_NODE,
923 "0287 lpfc_alloc_bucket failed to "
924 "allocate statistical data buffer DID "
925 "0x%x\n", ndlp->nlp_DID);
926 }
927 }
928}
929
930
931
932
933
934
935
936
937void
938lpfc_free_bucket(struct lpfc_vport *vport)
939{
940 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
941
942 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
943 if (!NLP_CHK_NODE_ACT(ndlp))
944 continue;
945
946 kfree(ndlp->lat_data);
947 ndlp->lat_data = NULL;
948 }
949}
950