Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5ab944f9 authored by Swen Schillig's avatar Swen Schillig Committed by James Bottomley
Browse files

[SCSI] zfcp: attach and release SAN nameserver port on demand 



Changing the zfcp behaviour from always having the nameserver port
open to an on-demand strategy.  This strategy reduces the use of
limited resources like port connections. The patch provides a common
infrastructure which could be used for all WKA ports in future.

Also reduce the number of nameserver lookups by changing the zfcp
behaviour of always querying the nameserver for the corresponding
destination ID of the remote port.  If the destination ID has changed
during the reopen process we will be informed and then trigger a
nameserver query on demand.

Signed-off-by: default avatarSwen Schillig <swen@vnet.ibm.com>
Signed-off-by: default avatarChristof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@HansenPartnership.com>
parent 44cc76f2

drivers/s390/scsi/zfcp_aux.c

+7 −58
Original line number Diff line number Diff line
@@ -450,19 +450,6 @@ static void _zfcp_status_read_scheduler(struct work_struct *work) 
					     stat_work));

}



static int zfcp_nameserver_enqueue(struct zfcp_adapter *adapter)

{

	struct zfcp_port *port;



	port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA,

				 ZFCP_DID_DIRECTORY_SERVICE);

	if (IS_ERR(port))

		return PTR_ERR(port);

	zfcp_port_put(port);



	return 0;

}



/**

 * zfcp_adapter_enqueue - enqueue a new adapter to the list

 * @ccw_device: pointer to the struct cc_device
@@ -552,7 +539,7 @@ int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 


	zfcp_data.adapters++;



	zfcp_nameserver_enqueue(adapter);

	zfcp_fc_nameserver_init(adapter);



	return 0;
@@ -638,7 +625,6 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
{

	struct zfcp_port *port;

	int retval;

	char *bus_id;



	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);

	if (!port)
@@ -648,6 +634,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 


	INIT_LIST_HEAD(&port->unit_list_head);

	INIT_LIST_HEAD(&port->unit_remove_lh);

	INIT_WORK(&port->gid_pn_work, zfcp_erp_port_strategy_open_lookup);



	port->adapter = adapter;

	port->d_id = d_id;
@@ -657,34 +644,8 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
	atomic_set_mask(status | ZFCP_STATUS_COMMON_REMOVE, &port->status);

	atomic_set(&port->refcount, 0);



	if (status & ZFCP_STATUS_PORT_WKA) {

		switch (d_id) {

		case ZFCP_DID_DIRECTORY_SERVICE:

			bus_id = "directory";

			break;

		case ZFCP_DID_MANAGEMENT_SERVICE:

			bus_id = "management";

			break;

		case ZFCP_DID_KEY_DISTRIBUTION_SERVICE:

			bus_id = "key_distribution";

			break;

		case ZFCP_DID_ALIAS_SERVICE:

			bus_id = "alias";

			break;

		case ZFCP_DID_TIME_SERVICE:

			bus_id = "time";

			break;

		default:

			kfree(port);

			return ERR_PTR(-EINVAL);

		}

		snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "%s", bus_id);

		port->sysfs_device.parent = &adapter->generic_services;

	} else {

		snprintf(port->sysfs_device.bus_id,

			 BUS_ID_SIZE, "0x%016llx", wwpn);

	snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", wwpn);

	port->sysfs_device.parent = &adapter->ccw_device->dev;

	}



	port->sysfs_device.release = zfcp_sysfs_port_release;

	dev_set_drvdata(&port->sysfs_device, port);
@@ -700,10 +661,6 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
	if (device_register(&port->sysfs_device))

		goto err_out_free;



	if (status & ZFCP_STATUS_PORT_WKA)

		retval = sysfs_create_group(&port->sysfs_device.kobj,

					    &zfcp_sysfs_ns_port_attrs);

	else

	retval = sysfs_create_group(&port->sysfs_device.kobj,

				    &zfcp_sysfs_port_attrs);
@@ -718,9 +675,6 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
	list_add_tail(&port->list, &adapter->port_list_head);

	atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);

	atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);

	if (d_id == ZFCP_DID_DIRECTORY_SERVICE)

		if (!adapter->nameserver_port)

			adapter->nameserver_port = port;

	adapter->ports++;



	write_unlock_irq(&zfcp_data.config_lock);
@@ -749,12 +703,7 @@ void zfcp_port_dequeue(struct zfcp_port *port) 
		fc_remote_port_delete(port->rport);

	port->rport = NULL;

	zfcp_adapter_put(port->adapter);

	if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA)

		sysfs_remove_group(&port->sysfs_device.kobj,

				   &zfcp_sysfs_ns_port_attrs);

	else

		sysfs_remove_group(&port->sysfs_device.kobj,

				   &zfcp_sysfs_port_attrs);

	sysfs_remove_group(&port->sysfs_device.kobj, &zfcp_sysfs_port_attrs);

	device_unregister(&port->sysfs_device);

}

drivers/s390/scsi/zfcp_dbf.c

+7 −7
Original line number Diff line number Diff line
@@ -519,7 +519,7 @@ static const char *zfcp_rec_dbf_ids[] = { 
	[75]	= "physical port recovery escalation after failed port "

		  "recovery",

	[76]	= "port recovery escalation after failed unit recovery",

	[77]	= "recovery opening nameserver port",

	[77]	= "",

	[78]	= "duplicate request id",

	[79]	= "link down",

	[80]	= "exclusive read-only unit access unsupported",
@@ -829,8 +829,8 @@ void zfcp_rec_dbf_event_action(u8 id2, struct zfcp_erp_action *erp_action) 
void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req)

{

	struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;

	struct zfcp_port *port = ct->port;

	struct zfcp_adapter *adapter = port->adapter;

	struct zfcp_wka_port *wka_port = ct->wka_port;

	struct zfcp_adapter *adapter = wka_port->adapter;

	struct ct_hdr *hdr = sg_virt(ct->req);

	struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;

	struct zfcp_san_dbf_record_ct_request *oct = &r->u.ct_req;
@@ -842,7 +842,7 @@ void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) 
	r->fsf_reqid = (unsigned long)fsf_req;

	r->fsf_seqno = fsf_req->seq_no;

	r->s_id = fc_host_port_id(adapter->scsi_host);

	r->d_id = port->d_id;

	r->d_id = wka_port->d_id;

	oct->cmd_req_code = hdr->cmd_rsp_code;

	oct->revision = hdr->revision;

	oct->gs_type = hdr->gs_type;
@@ -863,8 +863,8 @@ void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *fsf_req) 
void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req)

{

	struct zfcp_send_ct *ct = (struct zfcp_send_ct *)fsf_req->data;

	struct zfcp_port *port = ct->port;

	struct zfcp_adapter *adapter = port->adapter;

	struct zfcp_wka_port *wka_port = ct->wka_port;

	struct zfcp_adapter *adapter = wka_port->adapter;

	struct ct_hdr *hdr = sg_virt(ct->resp);

	struct zfcp_san_dbf_record *r = &adapter->san_dbf_buf;

	struct zfcp_san_dbf_record_ct_response *rct = &r->u.ct_resp;
@@ -875,7 +875,7 @@ void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *fsf_req) 
	strncpy(r->tag, "rctc", ZFCP_DBF_TAG_SIZE);

	r->fsf_reqid = (unsigned long)fsf_req;

	r->fsf_seqno = fsf_req->seq_no;

	r->s_id = port->d_id;

	r->s_id = wka_port->d_id;

	r->d_id = fc_host_port_id(adapter->scsi_host);

	rct->cmd_rsp_code = hdr->cmd_rsp_code;

	rct->revision = hdr->revision;

drivers/s390/scsi/zfcp_def.h

+23 −8
Original line number Diff line number Diff line
@@ -253,6 +253,7 @@ struct zfcp_ls_adisc { 
#define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED	0x00000200



/* FC-PH/FC-GS well-known address identifiers for generic services */

#define ZFCP_DID_WKA				0xFFFFF0

#define ZFCP_DID_MANAGEMENT_SERVICE		0xFFFFFA

#define ZFCP_DID_TIME_SERVICE			0xFFFFFB

#define ZFCP_DID_DIRECTORY_SERVICE		0xFFFFFC
@@ -264,13 +265,15 @@ struct zfcp_ls_adisc { 
#define ZFCP_STATUS_PORT_DID_DID		0x00000002

#define ZFCP_STATUS_PORT_PHYS_CLOSING		0x00000004

#define ZFCP_STATUS_PORT_NO_WWPN		0x00000008

#define ZFCP_STATUS_PORT_NO_SCSI_ID		0x00000010

#define ZFCP_STATUS_PORT_INVALID_WWPN		0x00000020



/* for ports with well known addresses */

#define ZFCP_STATUS_PORT_WKA \

		(ZFCP_STATUS_PORT_NO_WWPN | \

		 ZFCP_STATUS_PORT_NO_SCSI_ID)

/* well known address (WKA) port status*/

enum zfcp_wka_status {

	ZFCP_WKA_PORT_OFFLINE,

	ZFCP_WKA_PORT_CLOSING,

	ZFCP_WKA_PORT_OPENING,

	ZFCP_WKA_PORT_ONLINE,

};



/* logical unit status */

#define ZFCP_STATUS_UNIT_SHARED			0x00000004
@@ -340,7 +343,7 @@ typedef void (*zfcp_send_ct_handler_t)(unsigned long); 


/**

 * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct

 * @port: port where the request is sent to

 * @wka_port: port where the request is sent to

 * @req: scatter-gather list for request

 * @resp: scatter-gather list for response

 * @req_count: number of elements in request scatter-gather list
@@ -352,7 +355,7 @@ typedef void (*zfcp_send_ct_handler_t)(unsigned long); 
 * @status: used to pass error status to calling function

 */

struct zfcp_send_ct {

	struct zfcp_port *port;

	struct zfcp_wka_port *wka_port;

	struct scatterlist *req;

	struct scatterlist *resp;

	unsigned int req_count;
@@ -406,6 +409,17 @@ struct zfcp_send_els { 
	int status;

};



struct zfcp_wka_port {

	struct zfcp_adapter	*adapter;

	wait_queue_head_t	completion_wq;

	enum zfcp_wka_status	status;

	atomic_t		refcount;

	u32			d_id;

	u32			handle;

	struct mutex		mutex;

	struct delayed_work	work;

};



struct zfcp_qdio_queue {

	struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q]; /* SBALs */

	u8		   first;	      /* index of next free bfr
@@ -496,7 +510,7 @@ struct zfcp_adapter { 
						      actions */

	u32			erp_low_mem_count; /* nr of erp actions waiting

						      for memory */

	struct zfcp_port	*nameserver_port;  /* adapter's nameserver */

	struct zfcp_wka_port	nsp;		   /* adapter's nameserver */

	debug_info_t		*rec_dbf;

	debug_info_t		*hba_dbf;

	debug_info_t		*san_dbf;          /* debug feature areas */
@@ -540,6 +554,7 @@ struct zfcp_port { 
        atomic_t               erp_counter;

	u32                    maxframe_size;

	u32                    supported_classes;

	struct work_struct     gid_pn_work;

};



struct zfcp_unit {

drivers/s390/scsi/zfcp_erp.c

+40 −109
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ enum zfcp_erp_steps { 
	ZFCP_ERP_STEP_FSF_XCONFIG	= 0x0001,

	ZFCP_ERP_STEP_PHYS_PORT_CLOSING	= 0x0010,

	ZFCP_ERP_STEP_PORT_CLOSING	= 0x0100,

	ZFCP_ERP_STEP_NAMESERVER_OPEN	= 0x0200,

	ZFCP_ERP_STEP_NAMESERVER_LOOKUP	= 0x0400,

	ZFCP_ERP_STEP_PORT_OPENING	= 0x0800,

	ZFCP_ERP_STEP_UNIT_CLOSING	= 0x1000,
@@ -532,7 +531,6 @@ static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, 
	struct zfcp_port *port;



	list_for_each_entry(port, &adapter->port_list_head, list)

		if (!(atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA))

		_zfcp_erp_port_reopen(port, clear, id, ref);

}
@@ -777,7 +775,6 @@ static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act) 
static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)

{

	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |

			  ZFCP_STATUS_PORT_DID_DID |

			  ZFCP_STATUS_PORT_PHYS_CLOSING |

			  ZFCP_STATUS_PORT_INVALID_WWPN,

			  &port->status);
@@ -830,62 +827,6 @@ static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 
	return ZFCP_ERP_CONTINUES;

}



static void zfcp_erp_port_strategy_open_ns_wake(struct zfcp_erp_action *ns_act)

{

	unsigned long flags;

	struct zfcp_adapter *adapter = ns_act->adapter;

	struct zfcp_erp_action *act, *tmp;

	int status;



	read_lock_irqsave(&adapter->erp_lock, flags);

	list_for_each_entry_safe(act, tmp, &adapter->erp_running_head, list) {

		if (act->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {

			status = atomic_read(&adapter->nameserver_port->status);

			if (status & ZFCP_STATUS_COMMON_ERP_FAILED)

				zfcp_erp_port_failed(act->port, 27, NULL);

			zfcp_erp_action_ready(act);

		}

	}

	read_unlock_irqrestore(&adapter->erp_lock, flags);

}



static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *act)

{

	int retval;



	switch (act->step) {

	case ZFCP_ERP_STEP_UNINITIALIZED:

	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:

	case ZFCP_ERP_STEP_PORT_CLOSING:

		return zfcp_erp_port_strategy_open_port(act);



	case ZFCP_ERP_STEP_PORT_OPENING:

		if (atomic_read(&act->port->status) & ZFCP_STATUS_COMMON_OPEN)

			retval = ZFCP_ERP_SUCCEEDED;

		else

			retval = ZFCP_ERP_FAILED;

		/* this is needed anyway  */

		zfcp_erp_port_strategy_open_ns_wake(act);

		return retval;



	default:

		return ZFCP_ERP_FAILED;

	}

}



static int zfcp_erp_port_strategy_open_lookup(struct zfcp_erp_action *act)

{

	int retval;



	retval = zfcp_fc_ns_gid_pn_request(act);

	if (retval == -ENOMEM)

		return ZFCP_ERP_NOMEM;

	act->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;

	if (retval)

		return ZFCP_ERP_FAILED;

	return ZFCP_ERP_CONTINUES;

}



static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)

{

	struct zfcp_adapter *adapter = act->adapter;
@@ -900,11 +841,25 @@ static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act) 
	return zfcp_erp_port_strategy_open_port(act);

}



void zfcp_erp_port_strategy_open_lookup(struct work_struct *work)

{

	int retval;

	struct zfcp_port *port = container_of(work, struct zfcp_port,

					      gid_pn_work);



	retval = zfcp_fc_ns_gid_pn(&port->erp_action);

	if (retval == -ENOMEM)

		zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM);

	port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;

	if (retval)

		zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED);



}



static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)

{

	struct zfcp_adapter *adapter = act->adapter;

	struct zfcp_port *port = act->port;

	struct zfcp_port *ns_port = adapter->nameserver_port;

	int p_status = atomic_read(&port->status);



	switch (act->step) {
@@ -913,29 +868,10 @@ static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act) 
	case ZFCP_ERP_STEP_PORT_CLOSING:

		if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)

			return zfcp_erp_open_ptp_port(act);

		if (!ns_port) {

			dev_err(&adapter->ccw_device->dev,

				"Attaching the name server port to the "

				"FCP device failed\n");

			return ZFCP_ERP_FAILED;

		}

		if (!(atomic_read(&ns_port->status) &

		      ZFCP_STATUS_COMMON_UNBLOCKED)) {

			/* nameserver port may live again */

			atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,

					&ns_port->status);

			if (zfcp_erp_port_reopen(ns_port, 0, 77, act) >= 0) {

				act->step = ZFCP_ERP_STEP_NAMESERVER_OPEN;

		if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {

			schedule_work(&port->gid_pn_work);

			return ZFCP_ERP_CONTINUES;

		}

			return ZFCP_ERP_FAILED;

		}

		/* else nameserver port is already open, fall through */

	case ZFCP_ERP_STEP_NAMESERVER_OPEN:

		if (!(atomic_read(&ns_port->status) & ZFCP_STATUS_COMMON_OPEN))

			return ZFCP_ERP_FAILED;

		return zfcp_erp_port_strategy_open_lookup(act);



	case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:

		if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {

			if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) {
@@ -948,25 +884,26 @@ static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act) 


	case ZFCP_ERP_STEP_PORT_OPENING:

		/* D_ID might have changed during open */

		if ((p_status & ZFCP_STATUS_COMMON_OPEN) &&

		    (p_status & ZFCP_STATUS_PORT_DID_DID))

		if (p_status & ZFCP_STATUS_COMMON_OPEN) {

			if (p_status & ZFCP_STATUS_PORT_DID_DID)

				return ZFCP_ERP_SUCCEEDED;

			else {

				act->step = ZFCP_ERP_STEP_PORT_CLOSING;

				return ZFCP_ERP_CONTINUES;

			}

		/* fall through otherwise */

		}

	return ZFCP_ERP_FAILED;

	}



static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *act)

{

	if (atomic_read(&act->port->status) & (ZFCP_STATUS_PORT_WKA))

		return zfcp_erp_port_strategy_open_nameserver(act);

	return zfcp_erp_port_strategy_open_common(act);

	return ZFCP_ERP_FAILED;

}



static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)

{

	struct zfcp_port *port = erp_action->port;



	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)

		goto close_init_done;



	switch (erp_action->step) {

	case ZFCP_ERP_STEP_UNINITIALIZED:

		zfcp_erp_port_strategy_clearstati(port);
@@ -979,12 +916,12 @@ static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 
			return ZFCP_ERP_FAILED;

		break;

	}



close_init_done:

	if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)

		return ZFCP_ERP_EXIT;

	else

		return zfcp_erp_port_strategy_open(erp_action);



	return ZFCP_ERP_FAILED;

	return zfcp_erp_port_strategy_open_common(erp_action);

}



static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
@@ -1296,9 +1233,7 @@ static void zfcp_erp_rport_register(struct zfcp_port *port) 
static void zfcp_erp_rports_del(struct zfcp_adapter *adapter)

{

	struct zfcp_port *port;

	list_for_each_entry(port, &adapter->port_list_head, list)

		if (port->rport && !(atomic_read(&port->status) &

					ZFCP_STATUS_PORT_WKA)) {

	list_for_each_entry(port, &adapter->port_list_head, list) {

		fc_remote_port_delete(port->rport);

		port->rport = NULL;

	}
@@ -1737,7 +1672,6 @@ static void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id, 


	if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |

			ZFCP_STATUS_COMMON_ACCESS_BOXED))) {

		if (!(status & ZFCP_STATUS_PORT_WKA))

		list_for_each_entry(unit, &port->unit_list_head, list)

				    zfcp_erp_unit_access_changed(unit, id, ref);

		return;
@@ -1762,10 +1696,7 @@ void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id, 
		return;



	read_lock_irqsave(&zfcp_data.config_lock, flags);

	if (adapter->nameserver_port)

		zfcp_erp_port_access_changed(adapter->nameserver_port, id, ref);

	list_for_each_entry(port, &adapter->port_list_head, list)

		if (port != adapter->nameserver_port)

		zfcp_erp_port_access_changed(port, id, ref);

	read_unlock_irqrestore(&zfcp_data.config_lock, flags);

}

drivers/s390/scsi/zfcp_ext.h

+5 −2
Original line number Diff line number Diff line
@@ -91,17 +91,21 @@ extern void zfcp_erp_port_access_denied(struct zfcp_port *, u8, void *); 
extern void zfcp_erp_unit_access_denied(struct zfcp_unit *, u8, void *);

extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *, u8, void *);

extern void zfcp_erp_timeout_handler(unsigned long);

extern void zfcp_erp_port_strategy_open_lookup(struct work_struct *);



/* zfcp_fc.c */

extern int zfcp_scan_ports(struct zfcp_adapter *);

extern void _zfcp_scan_ports_later(struct work_struct *);

extern void zfcp_fc_incoming_els(struct zfcp_fsf_req *);

extern int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *);

extern int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *);

extern void zfcp_fc_plogi_evaluate(struct zfcp_port *, struct fsf_plogi *);

extern void zfcp_test_link(struct zfcp_port *);

extern void zfcp_fc_nameserver_init(struct zfcp_adapter *);



/* zfcp_fsf.c */

extern int zfcp_fsf_open_port(struct zfcp_erp_action *);

extern int zfcp_fsf_open_wka_port(struct zfcp_wka_port *);

extern int zfcp_fsf_close_wka_port(struct zfcp_wka_port *);

extern int zfcp_fsf_close_port(struct zfcp_erp_action *);

extern int zfcp_fsf_close_physical_port(struct zfcp_erp_action *);

extern int zfcp_fsf_open_unit(struct zfcp_erp_action *);
@@ -153,7 +157,6 @@ extern struct fc_function_template zfcp_transport_functions; 
/* zfcp_sysfs.c */

extern struct attribute_group zfcp_sysfs_unit_attrs;

extern struct attribute_group zfcp_sysfs_adapter_attrs;

extern struct attribute_group zfcp_sysfs_ns_port_attrs;

extern struct attribute_group zfcp_sysfs_port_attrs;

extern struct device_attribute *zfcp_sysfs_sdev_attrs[];

extern struct device_attribute *zfcp_sysfs_shost_attrs[];