]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/scsi/lpfc/lpfc_vport.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] lpfc 8.2.7 : Rework the worker thread
[mirror_ubuntu-artful-kernel.git] / drivers / scsi / lpfc / lpfc_vport.c
CommitLineData
92d7f7b0
JS		 1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
e47c9093 4 * Copyright (C) 2004-2008 Emulex. All rights reserved. *
92d7f7b0
JS		 5 * EMULEX and SLI are trademarks of Emulex. *
6 * www.emulex.com *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
8 * *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
21
22#include <linux/blkdev.h>
23#include <linux/delay.h>
24#include <linux/dma-mapping.h>
25#include <linux/idr.h>
26#include <linux/interrupt.h>
27#include <linux/kthread.h>
28#include <linux/pci.h>
29#include <linux/spinlock.h>
30
31#include <scsi/scsi.h>
32#include <scsi/scsi_device.h>
33#include <scsi/scsi_host.h>
34#include <scsi/scsi_transport_fc.h>
35#include "lpfc_hw.h"
36#include "lpfc_sli.h"
37#include "lpfc_disc.h"
38#include "lpfc_scsi.h"
39#include "lpfc.h"
40#include "lpfc_logmsg.h"
41#include "lpfc_crtn.h"
42#include "lpfc_version.h"
43#include "lpfc_vport.h"
44
45inline void lpfc_vport_set_state(struct lpfc_vport *vport,
46 enum fc_vport_state new_state)
47{
48 struct fc_vport *fc_vport = vport->fc_vport;
49
50 if (fc_vport) {
51 /*
52 * When the transport defines fc_vport_set state we will replace
53 * this code with the following line
54 */
55 /* fc_vport_set_state(fc_vport, new_state); */
56 if (new_state != FC_VPORT_INITIALIZING)
57 fc_vport->vport_last_state = fc_vport->vport_state;
58 fc_vport->vport_state = new_state;
59 }
60
61 /* for all the error states we will set the invternal state to FAILED */
62 switch (new_state) {
63 case FC_VPORT_NO_FABRIC_SUPP:
64 case FC_VPORT_NO_FABRIC_RSCS:
65 case FC_VPORT_FABRIC_LOGOUT:
66 case FC_VPORT_FABRIC_REJ_WWN:
67 case FC_VPORT_FAILED:
68 vport->port_state = LPFC_VPORT_FAILED;
69 break;
70 case FC_VPORT_LINKDOWN:
71 vport->port_state = LPFC_VPORT_UNKNOWN;
72 break;
73 default:
74 /* do nothing */
75 break;
76 }
77}
78
79static int
80lpfc_alloc_vpi(struct lpfc_hba *phba)
81{
82 int vpi;
83
84 spin_lock_irq(&phba->hbalock);
858c9f6c
JS		 85 /* Start at bit 1 because vpi zero is reserved for the physical port */
86 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1);
92d7f7b0
JS		 87 if (vpi > phba->max_vpi)
88 vpi = 0;
89 else
90 set_bit(vpi, phba->vpi_bmask);
91 spin_unlock_irq(&phba->hbalock);
92 return vpi;
93}
94
95static void
96lpfc_free_vpi(struct lpfc_hba *phba, int vpi)
97{
98 spin_lock_irq(&phba->hbalock);
99 clear_bit(vpi, phba->vpi_bmask);
100 spin_unlock_irq(&phba->hbalock);
101}
102
103static int
104lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport)
105{
106 LPFC_MBOXQ_t *pmb;
107 MAILBOX_t *mb;
108 struct lpfc_dmabuf *mp;
109 int rc;
110
111 pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
112 if (!pmb) {
113 return -ENOMEM;
114 }
115 mb = &pmb->mb;
116
117 lpfc_read_sparam(phba, pmb, vport->vpi);
118 /*
119 * Grab buffer pointer and clear context1 so we can use
120 * lpfc_sli_issue_box_wait
121 */
122 mp = (struct lpfc_dmabuf *) pmb->context1;
123 pmb->context1 = NULL;
124
125 pmb->vport = vport;
126 rc = lpfc_sli_issue_mbox_wait(phba, pmb, phba->fc_ratov * 2);
127 if (rc != MBX_SUCCESS) {
98c9ea5c
JS		 128 if (signal_pending(current)) {
129 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
130 "1830 Signal aborted mbxCmd x%x\n",
131 mb->mbxCommand);
132 lpfc_mbuf_free(phba, mp->virt, mp->phys);
133 kfree(mp);
134 if (rc != MBX_TIMEOUT)
135 mempool_free(pmb, phba->mbox_mem_pool);
136 return -EINTR;
137 } else {
138 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT | LOG_VPORT,
139 "1818 VPort failed init, mbxCmd x%x "
140 "READ_SPARM mbxStatus x%x, rc = x%x\n",
141 mb->mbxCommand, mb->mbxStatus, rc);
142 lpfc_mbuf_free(phba, mp->virt, mp->phys);
143 kfree(mp);
144 if (rc != MBX_TIMEOUT)
145 mempool_free(pmb, phba->mbox_mem_pool);
146 return -EIO;
147 }
92d7f7b0
JS		 148 }
149
150 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
151 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
152 sizeof (struct lpfc_name));
153 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
154 sizeof (struct lpfc_name));
155
156 lpfc_mbuf_free(phba, mp->virt, mp->phys);
157 kfree(mp);
158 mempool_free(pmb, phba->mbox_mem_pool);
159
160 return 0;
161}
162
163static int
164lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn,
165 const char *name_type)
166{
167 /* ensure that IEEE format 1 addresses
168 * contain zeros in bits 59-48
169 */
170 if (!((wwn->u.wwn[0] >> 4) == 1 &&
171 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0)))
172 return 1;
173
174 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 175 "1822 Invalid %s: %02x:%02x:%02x:%02x:"
92d7f7b0 176 "%02x:%02x:%02x:%02x\n",
e8b62011 177 name_type,
92d7f7b0
JS		 178 wwn->u.wwn[0], wwn->u.wwn[1],
179 wwn->u.wwn[2], wwn->u.wwn[3],
180 wwn->u.wwn[4], wwn->u.wwn[5],
181 wwn->u.wwn[6], wwn->u.wwn[7]);
182 return 0;
183}
184
185static int
186lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport)
187{
188 struct lpfc_vport *vport;
549e55cd 189 unsigned long flags;
92d7f7b0 190
549e55cd 191 spin_lock_irqsave(&phba->hbalock, flags);
92d7f7b0
JS		 192 list_for_each_entry(vport, &phba->port_list, listentry) {
193 if (vport == new_vport)
194 continue;
195 /* If they match, return not unique */
196 if (memcmp(&vport->fc_sparam.portName,
549e55cd
JS		 197 &new_vport->fc_sparam.portName,
198 sizeof(struct lpfc_name)) == 0) {
199 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0 200 return 0;
549e55cd 201 }
92d7f7b0 202 }
549e55cd 203 spin_unlock_irqrestore(&phba->hbalock, flags);
92d7f7b0
JS		 204 return 1;
205}
206
207int
208lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
209{
210 struct lpfc_nodelist *ndlp;
3de2a653
JS		 211 struct Scsi_Host *shost = fc_vport->shost;
212 struct lpfc_vport *pport = (struct lpfc_vport *) shost->hostdata;
92d7f7b0
JS		 213 struct lpfc_hba *phba = pport->phba;
214 struct lpfc_vport *vport = NULL;
215 int instance;
216 int vpi;
217 int rc = VPORT_ERROR;
98c9ea5c 218 int status;
92d7f7b0
JS		 219
220 if ((phba->sli_rev < 3) ||
221 !(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
222 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 223 "1808 Create VPORT failed: "
92d7f7b0 224 "NPIV is not enabled: SLImode:%d\n",
e8b62011 225 phba->sli_rev);
92d7f7b0
JS		 226 rc = VPORT_INVAL;
227 goto error_out;
228 }
229
230 vpi = lpfc_alloc_vpi(phba);
231 if (vpi == 0) {
232 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 233 "1809 Create VPORT failed: "
92d7f7b0 234 "Max VPORTs (%d) exceeded\n",
e8b62011 235 phba->max_vpi);
92d7f7b0
JS		 236 rc = VPORT_NORESOURCES;
237 goto error_out;
238 }
239
240
241 /* Assign an unused board number */
242 if ((instance = lpfc_get_instance()) < 0) {
243 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011
JS		 244 "1810 Create VPORT failed: Cannot get "
245 "instance number\n");
92d7f7b0
JS		 246 lpfc_free_vpi(phba, vpi);
247 rc = VPORT_NORESOURCES;
248 goto error_out;
249 }
250
3de2a653 251 vport = lpfc_create_port(phba, instance, &fc_vport->dev);
92d7f7b0
JS		 252 if (!vport) {
253 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 254 "1811 Create VPORT failed: vpi x%x\n", vpi);
92d7f7b0
JS		 255 lpfc_free_vpi(phba, vpi);
256 rc = VPORT_NORESOURCES;
257 goto error_out;
258 }
259
260 vport->vpi = vpi;
858c9f6c
JS		 261 lpfc_debugfs_initialize(vport);
262
98c9ea5c
JS		 263 if ((status = lpfc_vport_sparm(phba, vport))) {
264 if (status == -EINTR) {
265 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
266 "1831 Create VPORT Interrupted.\n");
267 rc = VPORT_ERROR;
268 } else {
269 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
270 "1813 Create VPORT failed. "
271 "Cannot get sparam\n");
272 rc = VPORT_NORESOURCES;
273 }
92d7f7b0
JS		 274 lpfc_free_vpi(phba, vpi);
275 destroy_port(vport);
92d7f7b0
JS		 276 goto error_out;
277 }
278
279 memcpy(vport->fc_portname.u.wwn, vport->fc_sparam.portName.u.wwn, 8);
280 memcpy(vport->fc_nodename.u.wwn, vport->fc_sparam.nodeName.u.wwn, 8);
281
282 if (fc_vport->node_name != 0)
283 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
284 if (fc_vport->port_name != 0)
285 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
286
287 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
288 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
289
290 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
291 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
e8b62011
JS		 292 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
293 "1821 Create VPORT failed. "
294 "Invalid WWN format\n");
92d7f7b0
JS		 295 lpfc_free_vpi(phba, vpi);
296 destroy_port(vport);
297 rc = VPORT_INVAL;
298 goto error_out;
299 }
300
301 if (!lpfc_unique_wwpn(phba, vport)) {
e8b62011
JS		 302 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
303 "1823 Create VPORT failed. "
304 "Duplicate WWN on HBA\n");
92d7f7b0
JS		 305 lpfc_free_vpi(phba, vpi);
306 destroy_port(vport);
307 rc = VPORT_INVAL;
308 goto error_out;
309 }
310
311 *(struct lpfc_vport **)fc_vport->dd_data = vport;
312 vport->fc_vport = fc_vport;
313
314 if ((phba->link_state < LPFC_LINK_UP) ||
315 (phba->fc_topology == TOPOLOGY_LOOP)) {
316 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
317 rc = VPORT_OK;
318 goto out;
319 }
320
321 if (disable) {
322 rc = VPORT_OK;
323 goto out;
324 }
325
326 /* Use the Physical nodes Fabric NDLP to determine if the link is
327 * up and ready to FDISC.
328 */
329 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 330 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
331 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
858c9f6c
JS		 332 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
333 lpfc_set_disctmo(vport);
334 lpfc_initial_fdisc(vport);
335 } else {
336 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
e8b62011
JS		 337 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
338 "0262 No NPIV Fabric support\n");
858c9f6c 339 }
92d7f7b0
JS		 340 } else {
341 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
342 }
343 rc = VPORT_OK;
344
345out:
a58cbd52
JS		 346 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
347 "1825 Vport Created.\n");
92d7f7b0
JS		 348 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
349error_out:
350 return rc;
351}
352
311464ec 353static int
92d7f7b0
JS		 354disable_vport(struct fc_vport *fc_vport)
355{
356 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
357 struct lpfc_hba *phba = vport->phba;
358 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
359 long timeout;
360
361 ndlp = lpfc_findnode_did(vport, Fabric_DID);
e47c9093
JS		 362 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
363 && phba->link_state >= LPFC_LINK_UP) {
92d7f7b0
JS		 364 vport->unreg_vpi_cmpl = VPORT_INVAL;
365 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
366 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
367 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
368 timeout = schedule_timeout(timeout);
369 }
370
371 lpfc_sli_host_down(vport);
372
373 /* Mark all nodes for discovery so we can remove them by
374 * calling lpfc_cleanup_rpis(vport, 1)
375 */
376 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
e47c9093
JS		 377 if (!NLP_CHK_NODE_ACT(ndlp))
378 continue;
92d7f7b0
JS		 379 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
380 continue;
381 lpfc_disc_state_machine(vport, ndlp, NULL,
382 NLP_EVT_DEVICE_RECOVERY);
383 }
384 lpfc_cleanup_rpis(vport, 1);
385
386 lpfc_stop_vport_timers(vport);
387 lpfc_unreg_all_rpis(vport);
388 lpfc_unreg_default_rpis(vport);
389 /*
390 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
391 * scsi_host_put() to release the vport.
392 */
393 lpfc_mbx_unreg_vpi(vport);
394
395 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
a58cbd52
JS		 396 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
397 "1826 Vport Disabled.\n");
92d7f7b0
JS		 398 return VPORT_OK;
399}
400
311464ec 401static int
92d7f7b0
JS		 402enable_vport(struct fc_vport *fc_vport)
403{
404 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
405 struct lpfc_hba *phba = vport->phba;
406 struct lpfc_nodelist *ndlp = NULL;
407
408 if ((phba->link_state < LPFC_LINK_UP) ||
409 (phba->fc_topology == TOPOLOGY_LOOP)) {
410 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
411 return VPORT_OK;
412 }
413
414 vport->load_flag |= FC_LOADING;
415 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
416
417 /* Use the Physical nodes Fabric NDLP to determine if the link is
418 * up and ready to FDISC.
419 */
420 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 421 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
422 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
858c9f6c
JS		 423 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
424 lpfc_set_disctmo(vport);
425 lpfc_initial_fdisc(vport);
426 } else {
427 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
e8b62011
JS		 428 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
429 "0264 No NPIV Fabric support\n");
858c9f6c 430 }
92d7f7b0
JS		 431 } else {
432 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
433 }
a58cbd52
JS		 434 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
435 "1827 Vport Enabled.\n");
92d7f7b0
JS		 436 return VPORT_OK;
437}
438
439int
440lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
441{
442 if (disable)
443 return disable_vport(fc_vport);
444 else
445 return enable_vport(fc_vport);
446}
447
448
449int
450lpfc_vport_delete(struct fc_vport *fc_vport)
451{
452 struct lpfc_nodelist *ndlp = NULL;
92d7f7b0
JS		 453 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost;
454 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
455 struct lpfc_hba *phba = vport->phba;
456 long timeout;
92d7f7b0 457
51ef4c26
JS		 458 if (vport->port_type == LPFC_PHYSICAL_PORT) {
459 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
460 "1812 vport_delete failed: Cannot delete "
461 "physical host\n");
462 return VPORT_ERROR;
463 }
464 /*
465 * If we are not unloading the driver then prevent the vport_delete
466 * from happening until after this vport's discovery is finished.
467 */
468 if (!(phba->pport->load_flag & FC_UNLOADING)) {
469 int check_count = 0;
470 while (check_count < ((phba->fc_ratov * 3) + 3) &&
471 vport->port_state > LPFC_VPORT_FAILED &&
472 vport->port_state < LPFC_VPORT_READY) {
473 check_count++;
474 msleep(1000);
475 }
476 if (vport->port_state > LPFC_VPORT_FAILED &&
477 vport->port_state < LPFC_VPORT_READY)
478 return -EAGAIN;
479 }
92d7f7b0
JS		 480 /*
481 * This is a bit of a mess. We want to ensure the shost doesn't get
482 * torn down until we're done with the embedded lpfc_vport structure.
483 *
484 * Beyond holding a reference for this function, we also need a
485 * reference for outstanding I/O requests we schedule during delete
486 * processing. But once we scsi_remove_host() we can no longer obtain
487 * a reference through scsi_host_get().
488 *
489 * So we take two references here. We release one reference at the
490 * bottom of the function -- after delinking the vport. And we
491 * release the other at the completion of the unreg_vpi that get's
492 * initiated after we've disposed of all other resources associated
493 * with the port.
494 */
495 if (!scsi_host_get(shost) || !scsi_host_get(shost))
496 return VPORT_INVAL;
51ef4c26 497 spin_lock_irq(&phba->hbalock);
92d7f7b0 498 vport->load_flag |= FC_UNLOADING;
51ef4c26 499 spin_unlock_irq(&phba->hbalock);
92d7f7b0 500 kfree(vport->vname);
858c9f6c 501 lpfc_debugfs_terminate(vport);
92d7f7b0
JS		 502 fc_remove_host(lpfc_shost_from_vport(vport));
503 scsi_remove_host(lpfc_shost_from_vport(vport));
504
505 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 506
507 /* In case of driver unload, we shall not perform fabric logo as the
508 * worker thread already stopped at this stage and, in this case, we
509 * can safely skip the fabric logo.
510 */
511 if (phba->pport->load_flag & FC_UNLOADING) {
512 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
513 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
514 phba->link_state >= LPFC_LINK_UP) {
515 /* First look for the Fabric ndlp */
516 ndlp = lpfc_findnode_did(vport, Fabric_DID);
517 if (!ndlp)
518 goto skip_logo;
519 else if (!NLP_CHK_NODE_ACT(ndlp)) {
520 ndlp = lpfc_enable_node(vport, ndlp,
521 NLP_STE_UNUSED_NODE);
522 if (!ndlp)
523 goto skip_logo;
524 }
525 /* Remove ndlp from vport npld list */
526 lpfc_dequeue_node(vport, ndlp);
527
528 /* Indicate free memory when release */
529 spin_lock_irq(&phba->ndlp_lock);
530 NLP_SET_FREE_REQ(ndlp);
531 spin_unlock_irq(&phba->ndlp_lock);
532 /* Kick off release ndlp when it can be safely done */
533 lpfc_nlp_put(ndlp);
534 }
535 goto skip_logo;
536 }
537
538 /* Otherwise, we will perform fabric logo as needed */
539 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
540 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
58da1ffb
JS		 541 phba->link_state >= LPFC_LINK_UP &&
542 phba->fc_topology != TOPOLOGY_LOOP) {
7ee5d43e
JS		 543 if (vport->cfg_enable_da_id) {
544 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
545 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
546 while (vport->ct_flags && timeout)
547 timeout = schedule_timeout(timeout);
548 else
549 lpfc_printf_log(vport->phba, KERN_WARNING,
550 LOG_VPORT,
551 "1829 CT command failed to "
552 "delete objects on fabric. \n");
553 }
92d7f7b0
JS		 554 /* First look for the Fabric ndlp */
555 ndlp = lpfc_findnode_did(vport, Fabric_DID);
556 if (!ndlp) {
557 /* Cannot find existing Fabric ndlp, allocate one */
558 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
559 if (!ndlp)
560 goto skip_logo;
561 lpfc_nlp_init(vport, ndlp, Fabric_DID);
e47c9093
JS		 562 /* Indicate free memory when release */
563 NLP_SET_FREE_REQ(ndlp);
92d7f7b0 564 } else {
e47c9093
JS		 565 if (!NLP_CHK_NODE_ACT(ndlp))
566 ndlp = lpfc_enable_node(vport, ndlp,
567 NLP_STE_UNUSED_NODE);
568 if (!ndlp)
569 goto skip_logo;
570
571 /* Remove ndlp from vport npld list */
92d7f7b0 572 lpfc_dequeue_node(vport, ndlp);
e47c9093
JS		 573 spin_lock_irq(&phba->ndlp_lock);
574 if (!NLP_CHK_FREE_REQ(ndlp))
575 /* Indicate free memory when release */
576 NLP_SET_FREE_REQ(ndlp);
577 else {
578 /* Skip this if ndlp is already in free mode */
579 spin_unlock_irq(&phba->ndlp_lock);
580 goto skip_logo;
581 }
582 spin_unlock_irq(&phba->ndlp_lock);
92d7f7b0
JS		 583 }
584 vport->unreg_vpi_cmpl = VPORT_INVAL;
585 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
586 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
587 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
588 timeout = schedule_timeout(timeout);
589 }
590
591skip_logo:
87af33fe 592 lpfc_cleanup(vport);
92d7f7b0
JS		 593 lpfc_sli_host_down(vport);
594
92d7f7b0 595 lpfc_stop_vport_timers(vport);
87af33fe
JS		 596
597 if (!(phba->pport->load_flag & FC_UNLOADING)) {
e47c9093 598 lpfc_unreg_all_rpis(vport);
87af33fe
JS		 599 lpfc_unreg_default_rpis(vport);
600 /*
601 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi)
602 * does the scsi_host_put() to release the vport.
603 */
604 lpfc_mbx_unreg_vpi(vport);
605 }
92d7f7b0
JS		 606
607 lpfc_free_vpi(phba, vport->vpi);
608 vport->work_port_events = 0;
609 spin_lock_irq(&phba->hbalock);
610 list_del_init(&vport->listentry);
611 spin_unlock_irq(&phba->hbalock);
a58cbd52
JS		 612 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
613 "1828 Vport Deleted.\n");
92d7f7b0 614 scsi_host_put(shost);
51ef4c26 615 return VPORT_OK;
92d7f7b0
JS		 616}
617
549e55cd
JS		 618struct lpfc_vport **
619lpfc_create_vport_work_array(struct lpfc_hba *phba)
620{
621 struct lpfc_vport *port_iterator;
622 struct lpfc_vport **vports;
623 int index = 0;
09372820 624 vports = kzalloc((phba->max_vpi + 1) * sizeof(struct lpfc_vport *),
549e55cd
JS		 625 GFP_KERNEL);
626 if (vports == NULL)
627 return NULL;
628 spin_lock_irq(&phba->hbalock);
629 list_for_each_entry(port_iterator, &phba->port_list, listentry) {
e8b62011 630 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
51ef4c26 631 lpfc_printf_vlog(port_iterator, KERN_WARNING, LOG_VPORT,
e8b62011
JS		 632 "1801 Create vport work array FAILED: "
633 "cannot do scsi_host_get\n");
549e55cd 634 continue;
e8b62011 635 }
549e55cd
JS		 636 vports[index++] = port_iterator;
637 }
638 spin_unlock_irq(&phba->hbalock);
639 return vports;
640}
641
642void
09372820 643lpfc_destroy_vport_work_array(struct lpfc_hba *phba, struct lpfc_vport **vports)
549e55cd
JS		 644{
645 int i;
646 if (vports == NULL)
647 return;
09372820 648 for (i=0; vports[i] != NULL && i <= phba->max_vpi; i++)
549e55cd
JS		 649 scsi_host_put(lpfc_shost_from_vport(vports[i]));
650 kfree(vports);
651}
Ubuntu Artful kernel mirror