]> 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.8 : Add kernel-doc function headers
[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;
495a714c 219 int size;
92d7f7b0
JS		 220
221 if ((phba->sli_rev < 3) ||
222 !(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
223 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 224 "1808 Create VPORT failed: "
92d7f7b0 225 "NPIV is not enabled: SLImode:%d\n",
e8b62011 226 phba->sli_rev);
92d7f7b0
JS		 227 rc = VPORT_INVAL;
228 goto error_out;
229 }
230
231 vpi = lpfc_alloc_vpi(phba);
232 if (vpi == 0) {
233 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 234 "1809 Create VPORT failed: "
92d7f7b0 235 "Max VPORTs (%d) exceeded\n",
e8b62011 236 phba->max_vpi);
92d7f7b0
JS		 237 rc = VPORT_NORESOURCES;
238 goto error_out;
239 }
240
241
242 /* Assign an unused board number */
243 if ((instance = lpfc_get_instance()) < 0) {
244 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011
JS		 245 "1810 Create VPORT failed: Cannot get "
246 "instance number\n");
92d7f7b0
JS		 247 lpfc_free_vpi(phba, vpi);
248 rc = VPORT_NORESOURCES;
249 goto error_out;
250 }
251
3de2a653 252 vport = lpfc_create_port(phba, instance, &fc_vport->dev);
92d7f7b0
JS		 253 if (!vport) {
254 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
e8b62011 255 "1811 Create VPORT failed: vpi x%x\n", vpi);
92d7f7b0
JS		 256 lpfc_free_vpi(phba, vpi);
257 rc = VPORT_NORESOURCES;
258 goto error_out;
259 }
260
261 vport->vpi = vpi;
858c9f6c
JS		 262 lpfc_debugfs_initialize(vport);
263
98c9ea5c
JS		 264 if ((status = lpfc_vport_sparm(phba, vport))) {
265 if (status == -EINTR) {
266 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
267 "1831 Create VPORT Interrupted.\n");
268 rc = VPORT_ERROR;
269 } else {
270 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
271 "1813 Create VPORT failed. "
272 "Cannot get sparam\n");
273 rc = VPORT_NORESOURCES;
274 }
92d7f7b0
JS		 275 lpfc_free_vpi(phba, vpi);
276 destroy_port(vport);
92d7f7b0
JS		 277 goto error_out;
278 }
279
280 memcpy(vport->fc_portname.u.wwn, vport->fc_sparam.portName.u.wwn, 8);
281 memcpy(vport->fc_nodename.u.wwn, vport->fc_sparam.nodeName.u.wwn, 8);
495a714c
JS		 282 size = strnlen(fc_vport->symbolic_name, LPFC_VNAME_LEN);
283 if (size) {
284 vport->vname = kzalloc(size+1, GFP_KERNEL);
285 if (!vport->vname) {
286 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
287 "1814 Create VPORT failed. "
288 "vname allocation failed.\n");
289 rc = VPORT_ERROR;
290 lpfc_free_vpi(phba, vpi);
291 destroy_port(vport);
292 goto error_out;
293 }
294 memcpy(vport->vname, fc_vport->symbolic_name, size+1);
295 }
92d7f7b0
JS		 296 if (fc_vport->node_name != 0)
297 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
298 if (fc_vport->port_name != 0)
299 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
300
301 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
302 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
303
304 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
305 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
e8b62011
JS		 306 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
307 "1821 Create VPORT failed. "
308 "Invalid WWN format\n");
92d7f7b0
JS		 309 lpfc_free_vpi(phba, vpi);
310 destroy_port(vport);
311 rc = VPORT_INVAL;
312 goto error_out;
313 }
314
315 if (!lpfc_unique_wwpn(phba, vport)) {
e8b62011
JS		 316 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
317 "1823 Create VPORT failed. "
318 "Duplicate WWN on HBA\n");
92d7f7b0
JS		 319 lpfc_free_vpi(phba, vpi);
320 destroy_port(vport);
321 rc = VPORT_INVAL;
322 goto error_out;
323 }
324
325 *(struct lpfc_vport **)fc_vport->dd_data = vport;
326 vport->fc_vport = fc_vport;
327
328 if ((phba->link_state < LPFC_LINK_UP) ||
329 (phba->fc_topology == TOPOLOGY_LOOP)) {
330 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
331 rc = VPORT_OK;
332 goto out;
333 }
334
335 if (disable) {
336 rc = VPORT_OK;
337 goto out;
338 }
339
340 /* Use the Physical nodes Fabric NDLP to determine if the link is
341 * up and ready to FDISC.
342 */
343 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 344 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
345 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
858c9f6c
JS		 346 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
347 lpfc_set_disctmo(vport);
348 lpfc_initial_fdisc(vport);
349 } else {
350 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
e8b62011
JS		 351 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
352 "0262 No NPIV Fabric support\n");
858c9f6c 353 }
92d7f7b0
JS		 354 } else {
355 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
356 }
357 rc = VPORT_OK;
358
359out:
a58cbd52
JS		 360 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
361 "1825 Vport Created.\n");
92d7f7b0
JS		 362 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
363error_out:
364 return rc;
365}
366
311464ec 367static int
92d7f7b0
JS		 368disable_vport(struct fc_vport *fc_vport)
369{
370 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
371 struct lpfc_hba *phba = vport->phba;
372 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
373 long timeout;
374
375 ndlp = lpfc_findnode_did(vport, Fabric_DID);
e47c9093
JS		 376 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
377 && phba->link_state >= LPFC_LINK_UP) {
92d7f7b0
JS		 378 vport->unreg_vpi_cmpl = VPORT_INVAL;
379 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
380 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
381 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
382 timeout = schedule_timeout(timeout);
383 }
384
385 lpfc_sli_host_down(vport);
386
387 /* Mark all nodes for discovery so we can remove them by
388 * calling lpfc_cleanup_rpis(vport, 1)
389 */
390 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
e47c9093
JS		 391 if (!NLP_CHK_NODE_ACT(ndlp))
392 continue;
92d7f7b0
JS		 393 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
394 continue;
395 lpfc_disc_state_machine(vport, ndlp, NULL,
396 NLP_EVT_DEVICE_RECOVERY);
397 }
398 lpfc_cleanup_rpis(vport, 1);
399
400 lpfc_stop_vport_timers(vport);
401 lpfc_unreg_all_rpis(vport);
402 lpfc_unreg_default_rpis(vport);
403 /*
404 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
405 * scsi_host_put() to release the vport.
406 */
407 lpfc_mbx_unreg_vpi(vport);
408
409 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
a58cbd52
JS		 410 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
411 "1826 Vport Disabled.\n");
92d7f7b0
JS		 412 return VPORT_OK;
413}
414
311464ec 415static int
92d7f7b0
JS		 416enable_vport(struct fc_vport *fc_vport)
417{
418 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
419 struct lpfc_hba *phba = vport->phba;
420 struct lpfc_nodelist *ndlp = NULL;
421
422 if ((phba->link_state < LPFC_LINK_UP) ||
423 (phba->fc_topology == TOPOLOGY_LOOP)) {
424 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
425 return VPORT_OK;
426 }
427
428 vport->load_flag |= FC_LOADING;
429 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
430
431 /* Use the Physical nodes Fabric NDLP to determine if the link is
432 * up and ready to FDISC.
433 */
434 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 435 if (ndlp && NLP_CHK_NODE_ACT(ndlp)
436 && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
858c9f6c
JS		 437 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
438 lpfc_set_disctmo(vport);
439 lpfc_initial_fdisc(vport);
440 } else {
441 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
e8b62011
JS		 442 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
443 "0264 No NPIV Fabric support\n");
858c9f6c 444 }
92d7f7b0
JS		 445 } else {
446 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
447 }
a58cbd52
JS		 448 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
449 "1827 Vport Enabled.\n");
92d7f7b0
JS		 450 return VPORT_OK;
451}
452
453int
454lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
455{
456 if (disable)
457 return disable_vport(fc_vport);
458 else
459 return enable_vport(fc_vport);
460}
461
462
463int
464lpfc_vport_delete(struct fc_vport *fc_vport)
465{
466 struct lpfc_nodelist *ndlp = NULL;
92d7f7b0
JS		 467 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost;
468 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
469 struct lpfc_hba *phba = vport->phba;
470 long timeout;
92d7f7b0 471
51ef4c26
JS		 472 if (vport->port_type == LPFC_PHYSICAL_PORT) {
473 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
474 "1812 vport_delete failed: Cannot delete "
475 "physical host\n");
476 return VPORT_ERROR;
477 }
478 /*
479 * If we are not unloading the driver then prevent the vport_delete
480 * from happening until after this vport's discovery is finished.
481 */
482 if (!(phba->pport->load_flag & FC_UNLOADING)) {
483 int check_count = 0;
484 while (check_count < ((phba->fc_ratov * 3) + 3) &&
485 vport->port_state > LPFC_VPORT_FAILED &&
486 vport->port_state < LPFC_VPORT_READY) {
487 check_count++;
488 msleep(1000);
489 }
490 if (vport->port_state > LPFC_VPORT_FAILED &&
491 vport->port_state < LPFC_VPORT_READY)
492 return -EAGAIN;
493 }
92d7f7b0
JS		 494 /*
495 * This is a bit of a mess. We want to ensure the shost doesn't get
496 * torn down until we're done with the embedded lpfc_vport structure.
497 *
498 * Beyond holding a reference for this function, we also need a
499 * reference for outstanding I/O requests we schedule during delete
500 * processing. But once we scsi_remove_host() we can no longer obtain
501 * a reference through scsi_host_get().
502 *
503 * So we take two references here. We release one reference at the
504 * bottom of the function -- after delinking the vport. And we
505 * release the other at the completion of the unreg_vpi that get's
506 * initiated after we've disposed of all other resources associated
507 * with the port.
508 */
509 if (!scsi_host_get(shost) || !scsi_host_get(shost))
510 return VPORT_INVAL;
51ef4c26 511 spin_lock_irq(&phba->hbalock);
92d7f7b0 512 vport->load_flag |= FC_UNLOADING;
51ef4c26 513 spin_unlock_irq(&phba->hbalock);
92d7f7b0 514 kfree(vport->vname);
858c9f6c 515 lpfc_debugfs_terminate(vport);
92d7f7b0
JS		 516 fc_remove_host(lpfc_shost_from_vport(vport));
517 scsi_remove_host(lpfc_shost_from_vport(vport));
518
519 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
e47c9093
JS		 520
521 /* In case of driver unload, we shall not perform fabric logo as the
522 * worker thread already stopped at this stage and, in this case, we
523 * can safely skip the fabric logo.
524 */
525 if (phba->pport->load_flag & FC_UNLOADING) {
526 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
527 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
528 phba->link_state >= LPFC_LINK_UP) {
529 /* First look for the Fabric ndlp */
530 ndlp = lpfc_findnode_did(vport, Fabric_DID);
531 if (!ndlp)
532 goto skip_logo;
533 else if (!NLP_CHK_NODE_ACT(ndlp)) {
534 ndlp = lpfc_enable_node(vport, ndlp,
535 NLP_STE_UNUSED_NODE);
536 if (!ndlp)
537 goto skip_logo;
538 }
539 /* Remove ndlp from vport npld list */
540 lpfc_dequeue_node(vport, ndlp);
541
542 /* Indicate free memory when release */
543 spin_lock_irq(&phba->ndlp_lock);
544 NLP_SET_FREE_REQ(ndlp);
545 spin_unlock_irq(&phba->ndlp_lock);
546 /* Kick off release ndlp when it can be safely done */
547 lpfc_nlp_put(ndlp);
548 }
549 goto skip_logo;
550 }
551
552 /* Otherwise, we will perform fabric logo as needed */
553 if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
554 ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
58da1ffb
JS		 555 phba->link_state >= LPFC_LINK_UP &&
556 phba->fc_topology != TOPOLOGY_LOOP) {
7ee5d43e
JS		 557 if (vport->cfg_enable_da_id) {
558 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
559 if (!lpfc_ns_cmd(vport, SLI_CTNS_DA_ID, 0, 0))
560 while (vport->ct_flags && timeout)
561 timeout = schedule_timeout(timeout);
562 else
563 lpfc_printf_log(vport->phba, KERN_WARNING,
564 LOG_VPORT,
565 "1829 CT command failed to "
566 "delete objects on fabric. \n");
567 }
92d7f7b0
JS		 568 /* First look for the Fabric ndlp */
569 ndlp = lpfc_findnode_did(vport, Fabric_DID);
570 if (!ndlp) {
571 /* Cannot find existing Fabric ndlp, allocate one */
572 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
573 if (!ndlp)
574 goto skip_logo;
575 lpfc_nlp_init(vport, ndlp, Fabric_DID);
e47c9093
JS		 576 /* Indicate free memory when release */
577 NLP_SET_FREE_REQ(ndlp);
92d7f7b0 578 } else {
e47c9093
JS		 579 if (!NLP_CHK_NODE_ACT(ndlp))
580 ndlp = lpfc_enable_node(vport, ndlp,
581 NLP_STE_UNUSED_NODE);
582 if (!ndlp)
583 goto skip_logo;
584
585 /* Remove ndlp from vport npld list */
92d7f7b0 586 lpfc_dequeue_node(vport, ndlp);
e47c9093
JS		 587 spin_lock_irq(&phba->ndlp_lock);
588 if (!NLP_CHK_FREE_REQ(ndlp))
589 /* Indicate free memory when release */
590 NLP_SET_FREE_REQ(ndlp);
591 else {
592 /* Skip this if ndlp is already in free mode */
593 spin_unlock_irq(&phba->ndlp_lock);
594 goto skip_logo;
595 }
596 spin_unlock_irq(&phba->ndlp_lock);
92d7f7b0
JS		 597 }
598 vport->unreg_vpi_cmpl = VPORT_INVAL;
599 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
600 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
601 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
602 timeout = schedule_timeout(timeout);
603 }
604
605skip_logo:
87af33fe 606 lpfc_cleanup(vport);
92d7f7b0
JS		 607 lpfc_sli_host_down(vport);
608
92d7f7b0 609 lpfc_stop_vport_timers(vport);
87af33fe
JS		 610
611 if (!(phba->pport->load_flag & FC_UNLOADING)) {
e47c9093 612 lpfc_unreg_all_rpis(vport);
87af33fe
JS		 613 lpfc_unreg_default_rpis(vport);
614 /*
615 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi)
616 * does the scsi_host_put() to release the vport.
617 */
618 lpfc_mbx_unreg_vpi(vport);
619 }
92d7f7b0
JS		 620
621 lpfc_free_vpi(phba, vport->vpi);
622 vport->work_port_events = 0;
623 spin_lock_irq(&phba->hbalock);
624 list_del_init(&vport->listentry);
625 spin_unlock_irq(&phba->hbalock);
a58cbd52
JS		 626 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
627 "1828 Vport Deleted.\n");
92d7f7b0 628 scsi_host_put(shost);
51ef4c26 629 return VPORT_OK;
92d7f7b0
JS		 630}
631
549e55cd
JS		 632struct lpfc_vport **
633lpfc_create_vport_work_array(struct lpfc_hba *phba)
634{
635 struct lpfc_vport *port_iterator;
636 struct lpfc_vport **vports;
637 int index = 0;
09372820 638 vports = kzalloc((phba->max_vpi + 1) * sizeof(struct lpfc_vport *),
549e55cd
JS		 639 GFP_KERNEL);
640 if (vports == NULL)
641 return NULL;
642 spin_lock_irq(&phba->hbalock);
643 list_for_each_entry(port_iterator, &phba->port_list, listentry) {
e8b62011 644 if (!scsi_host_get(lpfc_shost_from_vport(port_iterator))) {
51ef4c26 645 lpfc_printf_vlog(port_iterator, KERN_WARNING, LOG_VPORT,
e8b62011
JS		 646 "1801 Create vport work array FAILED: "
647 "cannot do scsi_host_get\n");
549e55cd 648 continue;
e8b62011 649 }
549e55cd
JS		 650 vports[index++] = port_iterator;
651 }
652 spin_unlock_irq(&phba->hbalock);
653 return vports;
654}
655
656void
09372820 657lpfc_destroy_vport_work_array(struct lpfc_hba *phba, struct lpfc_vport **vports)
549e55cd
JS		 658{
659 int i;
660 if (vports == NULL)
661 return;
09372820 662 for (i=0; vports[i] != NULL && i <= phba->max_vpi; i++)
549e55cd
JS		 663 scsi_host_put(lpfc_shost_from_vport(vports[i]));
664 kfree(vports);
665}
Ubuntu Artful kernel mirror