lpfc_vport.c revision a58cbd5212fff2d4bba0bf58e778f02069597294 
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_printf_vlog(vport, KERN_ERR, LOG_VPORT,
330			"1825 Vport Created.\n");
331	lpfc_host_attrib_init(lpfc_shost_from_vport(vport));
332error_out:
333	return rc;
334}
335
336int
337disable_vport(struct fc_vport *fc_vport)
338{
339	struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
340	struct lpfc_hba   *phba = vport->phba;
341	struct lpfc_nodelist *ndlp = NULL, *next_ndlp = NULL;
342	long timeout;
343
344	ndlp = lpfc_findnode_did(vport, Fabric_DID);
345	if (ndlp && phba->link_state >= LPFC_LINK_UP) {
346		vport->unreg_vpi_cmpl = VPORT_INVAL;
347		timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
348		if (!lpfc_issue_els_npiv_logo(vport, ndlp))
349			while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
350				timeout = schedule_timeout(timeout);
351	}
352
353	lpfc_sli_host_down(vport);
354
355	/* Mark all nodes for discovery so we can remove them by
356	 * calling lpfc_cleanup_rpis(vport, 1)
357	 */
358	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
359		if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
360			continue;
361		lpfc_disc_state_machine(vport, ndlp, NULL,
362					NLP_EVT_DEVICE_RECOVERY);
363	}
364	lpfc_cleanup_rpis(vport, 1);
365
366	lpfc_stop_vport_timers(vport);
367	lpfc_unreg_all_rpis(vport);
368	lpfc_unreg_default_rpis(vport);
369	/*
370	 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
371	 * scsi_host_put() to release the vport.
372	 */
373	lpfc_mbx_unreg_vpi(vport);
374
375	lpfc_vport_set_state(vport, FC_VPORT_DISABLED);
376	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
377			 "1826 Vport Disabled.\n");
378	return VPORT_OK;
379}
380
381int
382enable_vport(struct fc_vport *fc_vport)
383{
384	struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
385	struct lpfc_hba   *phba = vport->phba;
386	struct lpfc_nodelist *ndlp = NULL;
387
388	if ((phba->link_state < LPFC_LINK_UP) ||
389	    (phba->fc_topology == TOPOLOGY_LOOP)) {
390		lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
391		return VPORT_OK;
392	}
393
394	vport->load_flag |= FC_LOADING;
395	vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
396
397	/* Use the Physical nodes Fabric NDLP to determine if the link is
398	 * up and ready to FDISC.
399	 */
400	ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
401	if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE) {
402		if (phba->link_flag & LS_NPIV_FAB_SUPPORTED) {
403			lpfc_set_disctmo(vport);
404			lpfc_initial_fdisc(vport);
405		} else {
406			lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
407			lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
408					"%d (%d):0264 No NPIV Fabric "
409					"support\n",
410					phba->brd_no, vport->vpi);
411		}
412	} else {
413		lpfc_vport_set_state(vport, FC_VPORT_FAILED);
414	}
415	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
416			 "1827 Vport Enabled.\n");
417	return VPORT_OK;
418}
419
420int
421lpfc_vport_disable(struct fc_vport *fc_vport, bool disable)
422{
423	if (disable)
424		return disable_vport(fc_vport);
425	else
426		return enable_vport(fc_vport);
427}
428
429
430int
431lpfc_vport_delete(struct fc_vport *fc_vport)
432{
433	struct lpfc_nodelist *ndlp = NULL;
434	struct lpfc_nodelist *next_ndlp;
435	struct Scsi_Host *shost = (struct Scsi_Host *) fc_vport->shost;
436	struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
437	struct lpfc_hba   *phba = vport->phba;
438	long timeout;
439	int rc = VPORT_ERROR;
440
441	/*
442	 * This is a bit of a mess.  We want to ensure the shost doesn't get
443	 * torn down until we're done with the embedded lpfc_vport structure.
444	 *
445	 * Beyond holding a reference for this function, we also need a
446	 * reference for outstanding I/O requests we schedule during delete
447	 * processing.  But once we scsi_remove_host() we can no longer obtain
448	 * a reference through scsi_host_get().
449	 *
450	 * So we take two references here.  We release one reference at the
451	 * bottom of the function -- after delinking the vport.  And we
452	 * release the other at the completion of the unreg_vpi that get's
453	 * initiated after we've disposed of all other resources associated
454	 * with the port.
455	 */
456	if (!scsi_host_get(shost) || !scsi_host_get(shost))
457		return VPORT_INVAL;
458
459	if (vport->port_type == LPFC_PHYSICAL_PORT) {
460		lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
461				"%d:1812 vport_delete failed: Cannot delete "
462				"physical host\n", phba->brd_no);
463		goto out;
464	}
465
466	vport->load_flag |= FC_UNLOADING;
467
468	kfree(vport->vname);
469	lpfc_debugfs_terminate(vport);
470	fc_remove_host(lpfc_shost_from_vport(vport));
471	scsi_remove_host(lpfc_shost_from_vport(vport));
472
473	ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
474	if (ndlp && ndlp->nlp_state == NLP_STE_UNMAPPED_NODE &&
475		phba->link_state >= LPFC_LINK_UP) {
476
477		/* First look for the Fabric ndlp */
478		ndlp = lpfc_findnode_did(vport, Fabric_DID);
479		if (!ndlp) {
480			/* Cannot find existing Fabric ndlp, allocate one */
481			ndlp = mempool_alloc(phba->nlp_mem_pool, GFP_KERNEL);
482			if (!ndlp)
483				goto skip_logo;
484			lpfc_nlp_init(vport, ndlp, Fabric_DID);
485		} else {
486			lpfc_dequeue_node(vport, ndlp);
487		}
488		vport->unreg_vpi_cmpl = VPORT_INVAL;
489		timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
490		if (!lpfc_issue_els_npiv_logo(vport, ndlp))
491			while (vport->unreg_vpi_cmpl == VPORT_INVAL && timeout)
492				timeout = schedule_timeout(timeout);
493	}
494
495skip_logo:
496	lpfc_sli_host_down(vport);
497
498	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
499		lpfc_disc_state_machine(vport, ndlp, NULL,
500					     NLP_EVT_DEVICE_RECOVERY);
501		lpfc_disc_state_machine(vport, ndlp, NULL,
502					     NLP_EVT_DEVICE_RM);
503	}
504
505	lpfc_stop_vport_timers(vport);
506	lpfc_unreg_all_rpis(vport);
507	lpfc_unreg_default_rpis(vport);
508	/*
509	 * Completion of unreg_vpi (lpfc_mbx_cmpl_unreg_vpi) does the
510	 * scsi_host_put() to release the vport.
511	 */
512	lpfc_mbx_unreg_vpi(vport);
513
514	lpfc_free_vpi(phba, vport->vpi);
515	vport->work_port_events = 0;
516	spin_lock_irq(&phba->hbalock);
517	list_del_init(&vport->listentry);
518	spin_unlock_irq(&phba->hbalock);
519	lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
520			 "1828 Vport Deleted.\n");
521	rc = VPORT_OK;
522out:
523	scsi_host_put(shost);
524	return rc;
525}
526
527
528EXPORT_SYMBOL(lpfc_vport_create);
529EXPORT_SYMBOL(lpfc_vport_delete);
530