aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/lpfc/lpfc_vport.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/lpfc/lpfc_vport.c')
-rw-r--r--drivers/scsi/lpfc/lpfc_vport.c523
1 files changed, 523 insertions, 0 deletions
diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
new file mode 100644
index 000000000000..85797dbf5478
--- /dev/null
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -0,0 +1,523 @@
1/*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2006 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
6 * www.emulex.com *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
8 * *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
21
22#include <linux/blkdev.h>
23#include <linux/delay.h>
24#include <linux/dma-mapping.h>
25#include <linux/idr.h>
26#include <linux/interrupt.h>
27#include <linux/kthread.h>
28#include <linux/pci.h>
29#include <linux/spinlock.h>
30
31#include <scsi/scsi.h>
32#include <scsi/scsi_device.h>
33#include <scsi/scsi_host.h>
34#include <scsi/scsi_transport_fc.h>
35#include "lpfc_hw.h"
36#include "lpfc_sli.h"
37#include "lpfc_disc.h"
38#include "lpfc_scsi.h"
39#include "lpfc.h"
40#include "lpfc_logmsg.h"
41#include "lpfc_crtn.h"
42#include "lpfc_version.h"
43#include "lpfc_vport.h"
44
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);
85 /* Start at bit 1 because vpi zero is reserved for the physical port */
86 vpi = find_next_zero_bit(phba->vpi_bmask, (phba->max_vpi + 1), 1);
87 if (vpi > phba->max_vpi)
88 vpi = 0;
89 else
90 set_bit(vpi, phba->vpi_bmask);
91 spin_unlock_irq(&phba->hbalock);
92 return vpi;
93}
94
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) {
128 lpfc_printf_log(phba, KERN_ERR, LOG_INIT | LOG_VPORT,
129 "%d (%d):1818 VPort failed init, mbxCmd x%x "
130 "READ_SPARM mbxStatus x%x, rc = x%x\n",
131 phba->brd_no, vport->vpi,
132 mb->mbxCommand, mb->mbxStatus, rc);
133 lpfc_mbuf_free(phba, mp->virt, mp->phys);
134 kfree(mp);
135 if (rc != MBX_TIMEOUT)
136 mempool_free(pmb, phba->mbox_mem_pool);
137 return -EIO;
138 }
139
140 memcpy(&vport->fc_sparam, mp->virt, sizeof (struct serv_parm));
141 memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
142 sizeof (struct lpfc_name));
143 memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
144 sizeof (struct lpfc_name));
145
146 lpfc_mbuf_free(phba, mp->virt, mp->phys);
147 kfree(mp);
148 mempool_free(pmb, phba->mbox_mem_pool);
149
150 return 0;
151}
152
153static int
154lpfc_valid_wwn_format(struct lpfc_hba *phba, struct lpfc_name *wwn,
155 const char *name_type)
156{
157 /* ensure that IEEE format 1 addresses
158 * contain zeros in bits 59-48
159 */
160 if (!((wwn->u.wwn[0] >> 4) == 1 &&
161 ((wwn->u.wwn[0] & 0xf) != 0 || (wwn->u.wwn[1] & 0xf) != 0)))
162 return 1;
163
164 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
165 "%d:1822 Invalid %s: %02x:%02x:%02x:%02x:"
166 "%02x:%02x:%02x:%02x\n",
167 phba->brd_no, name_type,
168 wwn->u.wwn[0], wwn->u.wwn[1],
169 wwn->u.wwn[2], wwn->u.wwn[3],
170 wwn->u.wwn[4], wwn->u.wwn[5],
171 wwn->u.wwn[6], wwn->u.wwn[7]);
172 return 0;
173}
174
175static int
176lpfc_unique_wwpn(struct lpfc_hba *phba, struct lpfc_vport *new_vport)
177{
178 struct lpfc_vport *vport;
179
180 list_for_each_entry(vport, &phba->port_list, listentry) {
181 if (vport == new_vport)
182 continue;
183 /* If they match, return not unique */
184 if (memcmp(&vport->fc_sparam.portName,
185 &new_vport->fc_sparam.portName,
186 sizeof(struct lpfc_name)) == 0)
187 return 0;
188 }
189 return 1;
190}
191
192int
193lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
194{
195 struct lpfc_nodelist *ndlp;
196 struct lpfc_vport *pport =
197 (struct lpfc_vport *) fc_vport->shost->hostdata;
198 struct lpfc_hba *phba = pport->phba;
199 struct lpfc_vport *vport = NULL;
200 int instance;
201 int vpi;
202 int rc = VPORT_ERROR;
203
204 if ((phba->sli_rev < 3) ||
205 !(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)) {
206 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
207 "%d:1808 Create VPORT failed: "
208 "NPIV is not enabled: SLImode:%d\n",
209 phba->brd_no, phba->sli_rev);
210 rc = VPORT_INVAL;
211 goto error_out;
212 }
213
214 vpi = lpfc_alloc_vpi(phba);
215 if (vpi == 0) {
216 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
217 "%d:1809 Create VPORT failed: "
218 "Max VPORTs (%d) exceeded\n",
219 phba->brd_no, phba->max_vpi);
220 rc = VPORT_NORESOURCES;
221 goto error_out;
222 }
223
224
225 /* Assign an unused board number */
226 if ((instance = lpfc_get_instance()) < 0) {
227 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
228 "%d:1810 Create VPORT failed: Cannot get "
229 "instance number\n", phba->brd_no);
230 lpfc_free_vpi(phba, vpi);
231 rc = VPORT_NORESOURCES;
232 goto error_out;
233 }
234
235 vport = lpfc_create_port(phba, instance, fc_vport);
236 if (!vport) {
237 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
238 "%d:1811 Create VPORT failed: vpi x%x\n",
239 phba->brd_no, vpi);
240 lpfc_free_vpi(phba, vpi);
241 rc = VPORT_NORESOURCES;
242 goto error_out;
243 }
244
245 vport->vpi = vpi;
246 lpfc_debugfs_initialize(vport);
247
248 if (lpfc_vport_sparm(phba, vport)) {
249 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
250 "%d:1813 Create VPORT failed: vpi:%d "
251 "Cannot get sparam\n",
252 phba->brd_no, vpi);
253 lpfc_free_vpi(phba, vpi);
254 destroy_port(vport);
255 rc = VPORT_NORESOURCES;
256 goto error_out;
257 }
258
259 memcpy(vport->fc_portname.u.wwn, vport->fc_sparam.portName.u.wwn, 8);
260 memcpy(vport->fc_nodename.u.wwn, vport->fc_sparam.nodeName.u.wwn, 8);
261
262 if (fc_vport->node_name != 0)
263 u64_to_wwn(fc_vport->node_name, vport->fc_nodename.u.wwn);
264 if (fc_vport->port_name != 0)
265 u64_to_wwn(fc_vport->port_name, vport->fc_portname.u.wwn);
266
267 memcpy(&vport->fc_sparam.portName, vport->fc_portname.u.wwn, 8);
268 memcpy(&vport->fc_sparam.nodeName, vport->fc_nodename.u.wwn, 8);
269
270 if (!lpfc_valid_wwn_format(phba, &vport->fc_sparam.nodeName, "WWNN") ||
271 !lpfc_valid_wwn_format(phba, &vport->fc_sparam.portName, "WWPN")) {
272 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
273 "%d:1821 Create VPORT failed: vpi:%d "
274 "Invalid WWN format\n",
275 phba->brd_no, vpi);
276 lpfc_free_vpi(phba, vpi);
277 destroy_port(vport);
278 rc = VPORT_INVAL;
279 goto error_out;
280 }
281
282 if (!lpfc_unique_wwpn(phba, vport)) {
283 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
284 "%d:1823 Create VPORT failed: vpi:%d "
285 "Duplicate WWN on HBA\n",
286 phba->brd_no, vpi);
287 lpfc_free_vpi(phba, vpi);
288 destroy_port(vport);
289 rc = VPORT_INVAL;
290 goto error_out;
291 }
292
293 *(struct lpfc_vport **)fc_vport->dd_data = vport;
294 vport->fc_vport = fc_vport;
295
296 if ((phba->link_state < LPFC_LINK_UP) ||
297 (phba->fc_topology == TOPOLOGY_LOOP)) {
298 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
299 rc = VPORT_OK;
300 goto out;
301 }
302
303 if (disable) {
304 rc = VPORT_OK;
305 goto out;
306 }
307
308 /* Use the Physical nodes Fabric NDLP to determine if the link is
309 * up and ready to FDISC.
310 */
311 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
312 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
313 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
314 lpfc_set_disctmo(vport);
315 lpfc_initial_fdisc(vport);
316 } else {
317 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
318 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
319 "%d (%d):0262 No NPIV Fabric "
320 "support\n",
321 phba->brd_no, vport->vpi);
322 }
323 } else {
324 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
325 }
326 rc = VPORT_OK;
327
328out:
329 lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
330error_out:
331 return rc;
332}
333
334int
335disable_vport(struct fc_vport *fc_vport)
336{
337 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
338 struct lpfc_hba *phba = vport->phba;
339 struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
340 long timeout;
341
342 ndlp = lpfc_findnode_did(vport, Fabric_DID);
343 if (ndlp && phba->link_state >= LPFC_LINK_UP) {
344 vport->unreg_vpi_cmpl = VPORT_INVAL;
345 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
346 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
347 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
348 timeout = schedule_timeout(timeout);
349 }
350
351 lpfc_sli_host_down(vport);
352
353 /* Mark all nodes for discovery so we can remove them by
354 * calling lpfc_cleanup_rpis(vport, 1)
355 */
356 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
357 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
358 continue;
359 lpfc_disc_state_machine(vport, ndlp, NULL,
360 NLP_EVT_DEVICE_RECOVERY);
361 }
362 lpfc_cleanup_rpis(vport, 1);
363
364 lpfc_stop_vport_timers(vport);
365 lpfc_unreg_all_rpis(vport);
366 lpfc_unreg_default_rpis(vport);
367 /*
368 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
369 * scsi_host_put() to release the vport.
370 */
371 lpfc_mbx_unreg_vpi(vport);
372
373 lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
374 return VPORT_OK;
375}
376
377int
378enable_vport(struct fc_vport *fc_vport)
379{
380 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
381 struct lpfc_hba *phba = vport->phba;
382 struct lpfc_nodelist *ndlp = NULL;
383
384 if ((phba->link_state < LPFC_LINK_UP) ||
385 (phba->fc_topology == TOPOLOGY_LOOP)) {
386 lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
387 return VPORT_OK;
388 }
389
390 vport->load_flag |= FC_LOADING;
391 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
392
393 /* Use the Physical nodes Fabric NDLP to determine if the link is
394 * up and ready to FDISC.
395 */
396 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
397 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
398 if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
399 lpfc_set_disctmo(vport);
400 lpfc_initial_fdisc(vport);
401 } else {
402 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
403 lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
404 "%d (%d):0264 No NPIV Fabric "
405 "support\n",
406 phba->brd_no, vport->vpi);
407 }
408 } else {
409 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
410 }
411
412 return VPORT_OK;
413}
414
415int
416lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
417{
418 if (disable)
419 return disable_vport(fc_vport);
420 else
421 return enable_vport(fc_vport);
422}
423
424
425int
426lpfc_vport_delete(struct fc_vport *fc_vport)
427{
428 struct lpfc_nodelist *ndlp = NULL;
429 struct lpfc_nodelist *next_ndlp;
430 struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost;
431 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
432 struct lpfc_hba *phba = vport->phba;
433 long timeout;
434 int rc = VPORT_ERROR;
435
436 /*
437 * This is a bit of a mess. We want to ensure the shost doesn't get
438 * torn down until we're done with the embedded lpfc_vport structure.
439 *
440 * Beyond holding a reference for this function, we also need a
441 * reference for outstanding I/O requests we schedule during delete
442 * processing. But once we scsi_remove_host() we can no longer obtain
443 * a reference through scsi_host_get().
444 *
445 * So we take two references here. We release one reference at the
446 * bottom of the function -- after delinking the vport. And we
447 * release the other at the completion of the unreg_vpi that get's
448 * initiated after we've disposed of all other resources associated
449 * with the port.
450 */
451 if (!scsi_host_get(shost) || !scsi_host_get(shost))
452 return VPORT_INVAL;
453
454 if (vport->port_type == LPFC_PHYSICAL_PORT) {
455 lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
456 "%d:1812 vport_delete failed: Cannot delete "
457 "physical host\n", phba->brd_no);
458 goto out;
459 }
460
461 vport->load_flag |= FC_UNLOADING;
462
463 kfree(vport->vname);
464 lpfc_debugfs_terminate(vport);
465 fc_remove_host(lpfc_shost_from_vport(vport));
466 scsi_remove_host(lpfc_shost_from_vport(vport));
467
468 ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
469 if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
470 phba->link_state >= LPFC_LINK_UP) {
471
472 /* First look for the Fabric ndlp */
473 ndlp = lpfc_findnode_did(vport, Fabric_DID);
474 if (!ndlp) {
475 /* Cannot find existing Fabric ndlp, allocate one */
476 ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
477 if (!ndlp)
478 goto skip_logo;
479 lpfc_nlp_init(vport, ndlp, Fabric_DID);
480 } else {
481 lpfc_dequeue_node(vport, ndlp);
482 }
483 vport->unreg_vpi_cmpl = VPORT_INVAL;
484 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
485 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
486 while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
487 timeout = schedule_timeout(timeout);
488 }
489
490skip_logo:
491 lpfc_sli_host_down(vport);
492
493 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
494 lpfc_disc_state_machine(vport, ndlp, NULL,
495 NLP_EVT_DEVICE_RECOVERY);
496 lpfc_disc_state_machine(vport, ndlp, NULL,
497 NLP_EVT_DEVICE_RM);
498 }
499
500 lpfc_stop_vport_timers(vport);
501 lpfc_unreg_all_rpis(vport);
502 lpfc_unreg_default_rpis(vport);
503 /*
504 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
505 * scsi_host_put() to release the vport.
506 */
507 lpfc_mbx_unreg_vpi(vport);
508
509 lpfc_free_vpi(phba, vport->vpi);
510 vport->work_port_events = 0;
511 spin_lock_irq(&phba->hbalock);
512 list_del_init(&vport->listentry);
513 spin_unlock_irq(&phba->hbalock);
514
515 rc = VPORT_OK;
516out:
517 scsi_host_put(shost);
518 return rc;
519}
520
521
522EXPORT_SYMBOL(lpfc_vport_create);
523EXPORT_SYMBOL(lpfc_vport_delete);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-12 23:50:48 -0500