Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 86f8a1b4b472e4b2b58df5826709d4797d84d46f

Authored by Christof Schmitt 2009-03-02 20:08:55 +0800

Committed by James Bottomley 2009-03-13 01:58:18 +0800

Exists in master and in 7 other branches

[SCSI] zfcp: Remove UNIT_REGISTERED status flag

Use the device pointer in zfcp_unit for tracking if we have a
registered SCSI device. With this approach, the flag
ZFCP_STATUS_UNIT_REGISTERED is only redundant and can be removed.

Acked-by: Swen Schillig <swen@vnet.ibm.com>
Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

Showing 4 changed files with 2 additions and 8 deletions Inline Diff

drivers/s390/scsi/zfcp_ccw.c
drivers/s390/scsi/zfcp_def.h
drivers/s390/scsi/zfcp_erp.c
drivers/s390/scsi/zfcp_scsi.c

drivers/s390/scsi/zfcp_ccw.c

Diff comments View file @ 86f8a1b

 /*
  * zfcp device driver
  *
  * Registration and callback for the s390 common I/O layer.
  *
  * Copyright IBM Corporation 2002, 2008
  */
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include "zfcp_ext.h"
 /**
  * zfcp_ccw_probe - probe function of zfcp driver
  * @ccw_device: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and sets up the initial
  * data structures for each fcp adapter, which was detected by the system.
  * Also the sysfs files for this adapter will be created by this function.
  * In addition the nameserver port will be added to the ports of the adapter
  * and its sysfs representation will be created too.
  */
 static int zfcp_ccw_probe(struct ccw_device *ccw_device)
 {
 	int retval = 0;
 	down(&zfcp_data.config_sema);
 	if (zfcp_adapter_enqueue(ccw_device)) {
 		dev_err(&ccw_device->dev,
 			"Setting up data structures for the "
 			"FCP adapter failed\n");
 		retval = -EINVAL;
 	}
 	up(&zfcp_data.config_sema);
 	return retval;
 }
 /**
  * zfcp_ccw_remove - remove function of zfcp driver
  * @ccw_device: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and removes an adapter
  * from the system. Task of this function is to get rid of all units and
  * ports that belong to this adapter. And in addition all resources of this
  * adapter will be freed too.
  */
 static void zfcp_ccw_remove(struct ccw_device *ccw_device)
 {
 	struct zfcp_adapter *adapter;
 	struct zfcp_port *port, *p;
 	struct zfcp_unit *unit, *u;
 	LIST_HEAD(unit_remove_lh);
 	LIST_HEAD(port_remove_lh);
 	ccw_device_set_offline(ccw_device);
 	down(&zfcp_data.config_sema);
 	adapter = dev_get_drvdata(&ccw_device->dev);
 	write_lock_irq(&zfcp_data.config_lock);
 	list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
 		list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
 			list_move(&unit->list, &unit_remove_lh);
 			atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
 					&unit->status);
 		}
 		list_move(&port->list, &port_remove_lh);
 		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
 	}
 	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
 	write_unlock_irq(&zfcp_data.config_lock);
 	list_for_each_entry_safe(port, p, &port_remove_lh, list) {
 		list_for_each_entry_safe(unit, u, &unit_remove_lh, list) {
-			if (atomic_read(&unit->status) &
+			if (unit->device)
-			    ZFCP_STATUS_UNIT_REGISTERED)
 				scsi_remove_device(unit->device);
 			zfcp_unit_dequeue(unit);
 		}
 		zfcp_port_dequeue(port);
 	}
 	wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
 	zfcp_adapter_dequeue(adapter);
 	up(&zfcp_data.config_sema);
 }
 /**
  * zfcp_ccw_set_online - set_online function of zfcp driver
  * @ccw_device: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and sets an adapter
  * into state online. Setting an fcp device online means that it will be
  * registered with the SCSI stack, that the QDIO queues will be set up
  * and that the adapter will be opened (asynchronously).
  */
 static int zfcp_ccw_set_online(struct ccw_device *ccw_device)
 {
 	struct zfcp_adapter *adapter;
 	int retval;
 	down(&zfcp_data.config_sema);
 	adapter = dev_get_drvdata(&ccw_device->dev);
 	retval = zfcp_erp_thread_setup(adapter);
 	if (retval)
 		goto out;
 	/* initialize request counter */
 	BUG_ON(!zfcp_reqlist_isempty(adapter));
 	adapter->req_no = 0;
 	zfcp_erp_modify_adapter_status(adapter, 10, NULL,
 				       ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
 	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 85,
 				NULL);
 	zfcp_erp_wait(adapter);
 	up(&zfcp_data.config_sema);
 	flush_work(&adapter->scan_work);
 	return 0;
  out:
 	up(&zfcp_data.config_sema);
 	return retval;
 }
 /**
  * zfcp_ccw_set_offline - set_offline function of zfcp driver
  * @ccw_device: pointer to belonging ccw device
  *
  * This function gets called by the common i/o layer and sets an adapter
  * into state offline.
  */
 static int zfcp_ccw_set_offline(struct ccw_device *ccw_device)
 {
 	struct zfcp_adapter *adapter;
 	down(&zfcp_data.config_sema);
 	adapter = dev_get_drvdata(&ccw_device->dev);
 	zfcp_erp_adapter_shutdown(adapter, 0, 86, NULL);
 	zfcp_erp_wait(adapter);
 	zfcp_erp_thread_kill(adapter);
 	up(&zfcp_data.config_sema);
 	return 0;
 }
 /**
  * zfcp_ccw_notify - ccw notify function
  * @ccw_device: pointer to belonging ccw device
  * @event: indicates if adapter was detached or attached
  *
  * This function gets called by the common i/o layer if an adapter has gone
  * or reappeared.
  */
 static int zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
 {
 	struct zfcp_adapter *adapter = dev_get_drvdata(&ccw_device->dev);
 	switch (event) {
 	case CIO_GONE:
 		dev_warn(&adapter->ccw_device->dev,
 			 "The FCP device has been detached\n");
 		zfcp_erp_adapter_shutdown(adapter, 0, 87, NULL);
 		break;
 	case CIO_NO_PATH:
 		dev_warn(&adapter->ccw_device->dev,
 			 "The CHPID for the FCP device is offline\n");
 		zfcp_erp_adapter_shutdown(adapter, 0, 88, NULL);
 		break;
 	case CIO_OPER:
 		dev_info(&adapter->ccw_device->dev,
 			 "The FCP device is operational again\n");
 		zfcp_erp_modify_adapter_status(adapter, 11, NULL,
 					       ZFCP_STATUS_COMMON_RUNNING,
 					       ZFCP_SET);
 		zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
 					89, NULL);
 		break;
 	}
 	return 1;
 }
 /**
  * zfcp_ccw_shutdown - handle shutdown from cio
  * @cdev: device for adapter to shutdown.
  */
 static void zfcp_ccw_shutdown(struct ccw_device *cdev)
 {
 	struct zfcp_adapter *adapter;
 	down(&zfcp_data.config_sema);
 	adapter = dev_get_drvdata(&cdev->dev);
 	zfcp_erp_adapter_shutdown(adapter, 0, 90, NULL);
 	zfcp_erp_wait(adapter);
 	up(&zfcp_data.config_sema);
 }
 static struct ccw_device_id zfcp_ccw_device_id[] = {
 	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x3) },
 	{ CCW_DEVICE_DEVTYPE(0x1731, 0x3, 0x1732, 0x4) }, /* priv. */
 	{},
 };
 MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
 static struct ccw_driver zfcp_ccw_driver = {
 	.owner       = THIS_MODULE,
 	.name        = "zfcp",
 	.ids         = zfcp_ccw_device_id,
 	.probe       = zfcp_ccw_probe,
 	.remove      = zfcp_ccw_remove,
 	.set_online  = zfcp_ccw_set_online,
 	.set_offline = zfcp_ccw_set_offline,
 	.notify      = zfcp_ccw_notify,
 	.shutdown    = zfcp_ccw_shutdown,
 };
 /**
  * zfcp_ccw_register - ccw register function
  *
  * Registers the driver at the common i/o layer. This function will be called
  * at module load time/system start.
  */
 int __init zfcp_ccw_register(void)
 {
 	return ccw_driver_register(&zfcp_ccw_driver);
 }
 /**
  * zfcp_get_adapter_by_busid - find zfcp_adapter struct
  * @busid: bus id string of zfcp adapter to find
  */
 struct zfcp_adapter *zfcp_get_adapter_by_busid(char *busid)
 {
 	struct ccw_device *ccw_device;
 	struct zfcp_adapter *adapter = NULL;
 	ccw_device = get_ccwdev_by_busid(&zfcp_ccw_driver, busid);
 	if (ccw_device) {
 		adapter = dev_get_drvdata(&ccw_device->dev);
 		put_device(&ccw_device->dev);
 	}
 	return adapter;
 }

drivers/s390/scsi/zfcp_def.h

Diff comments View file @ 86f8a1b

 /*
  * zfcp device driver
  *
  * Global definitions for the zfcp device driver.
  *
  * Copyright IBM Corporation 2002, 2008
  */
 #ifndef ZFCP_DEF_H
 #define ZFCP_DEF_H
 /*************************** INCLUDES *****************************************/
 #include <linux/init.h>
 #include <linux/moduleparam.h>
 #include <linux/major.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
 #include <linux/mempool.h>
 #include <linux/syscalls.h>
 #include <linux/scatterlist.h>
 #include <linux/ioctl.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_fc.h>
 #include <asm/ccwdev.h>
 #include <asm/qdio.h>
 #include <asm/debug.h>
 #include <asm/ebcdic.h>
 #include <asm/sysinfo.h>
 #include "zfcp_dbf.h"
 #include "zfcp_fsf.h"
 /********************* GENERAL DEFINES *********************************/
 #define REQUEST_LIST_SIZE 128
 /********************* SCSI SPECIFIC DEFINES *********************************/
 #define ZFCP_SCSI_ER_TIMEOUT                    (10*HZ)
 /********************* CIO/QDIO SPECIFIC DEFINES *****************************/
 /* Adapter Identification Parameters */
 #define ZFCP_CONTROL_UNIT_TYPE  0x1731
 #define ZFCP_CONTROL_UNIT_MODEL 0x03
 #define ZFCP_DEVICE_TYPE        0x1732
 #define ZFCP_DEVICE_MODEL       0x03
 #define ZFCP_DEVICE_MODEL_PRIV	0x04
 /* DMQ bug workaround: don't use last SBALE */
 #define ZFCP_MAX_SBALES_PER_SBAL	(QDIO_MAX_ELEMENTS_PER_BUFFER - 1)
 /* index of last SBALE (with respect to DMQ bug workaround) */
 #define ZFCP_LAST_SBALE_PER_SBAL	(ZFCP_MAX_SBALES_PER_SBAL - 1)
 /* max. number of (data buffer) SBALEs in largest SBAL chain */
 #define ZFCP_MAX_SBALES_PER_REQ		\
 	(FSF_MAX_SBALS_PER_REQ * ZFCP_MAX_SBALES_PER_SBAL - 2)
         /* request ID + QTCB in SBALE 0 + 1 of first SBAL in chain */
 #define ZFCP_MAX_SECTORS (ZFCP_MAX_SBALES_PER_REQ * 8)
         /* max. number of (data buffer) SBALEs in largest SBAL chain
            multiplied with number of sectors per 4k block */
 /********************* FSF SPECIFIC DEFINES *********************************/
 /* ATTENTION: value must not be used by hardware */
 #define FSF_QTCB_UNSOLICITED_STATUS		0x6305
 /* timeout value for "default timer" for fsf requests */
 #define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ)
 /*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/
 /* timeout for name-server lookup (in seconds) */
 #define ZFCP_NS_GID_PN_TIMEOUT		10
 /* task attribute values in FCP-2 FCP_CMND IU */
 #define SIMPLE_Q	0
 #define HEAD_OF_Q	1
 #define ORDERED_Q	2
 #define ACA_Q		4
 #define UNTAGGED	5
 /* task management flags in FCP-2 FCP_CMND IU */
 #define FCP_CLEAR_ACA		0x40
 #define FCP_TARGET_RESET	0x20
 #define FCP_LOGICAL_UNIT_RESET	0x10
 #define FCP_CLEAR_TASK_SET	0x04
 #define FCP_ABORT_TASK_SET	0x02
 #define FCP_CDB_LENGTH		16
 #define ZFCP_DID_MASK           0x00FFFFFF
 /* FCP(-2) FCP_CMND IU */
 struct fcp_cmnd_iu {
 	u64 fcp_lun;	   /* FCP logical unit number */
 	u8  crn;	           /* command reference number */
 	u8  reserved0:5;	   /* reserved */
 	u8  task_attribute:3;	   /* task attribute */
 	u8  task_management_flags; /* task management flags */
 	u8  add_fcp_cdb_length:6;  /* additional FCP_CDB length */
 	u8  rddata:1;              /* read data */
 	u8  wddata:1;              /* write data */
 	u8  fcp_cdb[FCP_CDB_LENGTH];
 } __attribute__((packed));
 /* FCP(-2) FCP_RSP IU */
 struct fcp_rsp_iu {
 	u8  reserved0[10];
 	union {
 		struct {
 			u8 reserved1:3;
 			u8 fcp_conf_req:1;
 			u8 fcp_resid_under:1;
 			u8 fcp_resid_over:1;
 			u8 fcp_sns_len_valid:1;
 			u8 fcp_rsp_len_valid:1;
 		} bits;
 		u8 value;
 	} validity;
 	u8  scsi_status;
 	u32 fcp_resid;
 	u32 fcp_sns_len;
 	u32 fcp_rsp_len;
 } __attribute__((packed));
 #define RSP_CODE_GOOD		 0
 #define RSP_CODE_LENGTH_MISMATCH 1
 #define RSP_CODE_FIELD_INVALID	 2
 #define RSP_CODE_RO_MISMATCH	 3
 #define RSP_CODE_TASKMAN_UNSUPP	 4
 #define RSP_CODE_TASKMAN_FAILED	 5
 /* see fc-fs */
 #define LS_RSCN  0x61
 #define LS_LOGO  0x05
 #define LS_PLOGI 0x03
 struct fcp_rscn_head {
         u8  command;
         u8  page_length; /* always 0x04 */
         u16 payload_len;
 } __attribute__((packed));
 struct fcp_rscn_element {
         u8  reserved:2;
         u8  event_qual:4;
         u8  addr_format:2;
         u32 nport_did:24;
 } __attribute__((packed));
 /* see fc-ph */
 struct fcp_logo {
         u32 command;
         u32 nport_did;
 	u64 nport_wwpn;
 } __attribute__((packed));
 /*
  * FC-FS stuff
  */
 #define R_A_TOV				10 /* seconds */
 #define ZFCP_LS_RLS			0x0f
 #define ZFCP_LS_ADISC			0x52
 #define ZFCP_LS_RPS			0x56
 #define ZFCP_LS_RSCN			0x61
 #define ZFCP_LS_RNID			0x78
 struct zfcp_ls_adisc {
 	u8		code;
 	u8		field[3];
 	u32		hard_nport_id;
 	u64		wwpn;
 	u64		wwnn;
 	u32		nport_id;
 } __attribute__ ((packed));
 /*
  * FC-GS-2 stuff
  */
 #define ZFCP_CT_REVISION		0x01
 #define ZFCP_CT_DIRECTORY_SERVICE	0xFC
 #define ZFCP_CT_NAME_SERVER		0x02
 #define ZFCP_CT_SYNCHRONOUS		0x00
 #define ZFCP_CT_SCSI_FCP		0x08
 #define ZFCP_CT_UNABLE_TO_PERFORM_CMD	0x09
 #define ZFCP_CT_GID_PN			0x0121
 #define ZFCP_CT_GPN_FT			0x0172
 #define ZFCP_CT_ACCEPT			0x8002
 #define ZFCP_CT_REJECT			0x8001
 /*
  * FC-GS-4 stuff
  */
 #define ZFCP_CT_TIMEOUT			(3 * R_A_TOV)
 /*************** ADAPTER/PORT/UNIT AND FSF_REQ STATUS FLAGS ******************/
 /*
  * Note, the leftmost status byte is common among adapter, port
  * and unit
  */
 #define ZFCP_COMMON_FLAGS			0xfff00000
 /* common status bits */
 #define ZFCP_STATUS_COMMON_REMOVE		0x80000000
 #define ZFCP_STATUS_COMMON_RUNNING		0x40000000
 #define ZFCP_STATUS_COMMON_ERP_FAILED		0x20000000
 #define ZFCP_STATUS_COMMON_UNBLOCKED		0x10000000
 #define ZFCP_STATUS_COMMON_OPEN                 0x04000000
 #define ZFCP_STATUS_COMMON_ERP_INUSE		0x01000000
 #define ZFCP_STATUS_COMMON_ACCESS_DENIED	0x00800000
 #define ZFCP_STATUS_COMMON_ACCESS_BOXED		0x00400000
 #define ZFCP_STATUS_COMMON_NOESC		0x00200000
 /* adapter status */
 #define ZFCP_STATUS_ADAPTER_QDIOUP		0x00000002
 #define ZFCP_STATUS_ADAPTER_XCONFIG_OK		0x00000008
 #define ZFCP_STATUS_ADAPTER_HOST_CON_INIT	0x00000010
 #define ZFCP_STATUS_ADAPTER_ERP_THREAD_UP	0x00000020
 #define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL	0x00000080
 #define ZFCP_STATUS_ADAPTER_ERP_PENDING		0x00000100
 #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
 #define ZFCP_DID_ALIAS_SERVICE			0xFFFFF8
 #define ZFCP_DID_KEY_DISTRIBUTION_SERVICE	0xFFFFF7
 /* remote port status */
 #define ZFCP_STATUS_PORT_PHYS_OPEN		0x00000001
 /* 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
 #define ZFCP_STATUS_UNIT_READONLY		0x00000008
-#define ZFCP_STATUS_UNIT_REGISTERED		0x00000010
 #define ZFCP_STATUS_UNIT_SCSI_WORK_PENDING	0x00000020
 /* FSF request status (this does not have a common part) */
 #define ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT	0x00000002
 #define ZFCP_STATUS_FSFREQ_COMPLETED		0x00000004
 #define ZFCP_STATUS_FSFREQ_ERROR		0x00000008
 #define ZFCP_STATUS_FSFREQ_CLEANUP		0x00000010
 #define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED	0x00000040
 #define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED       0x00000080
 #define ZFCP_STATUS_FSFREQ_ABORTED              0x00000100
 #define ZFCP_STATUS_FSFREQ_TMFUNCFAILED         0x00000200
 #define ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP        0x00000400
 #define ZFCP_STATUS_FSFREQ_RETRY                0x00000800
 #define ZFCP_STATUS_FSFREQ_DISMISSED            0x00001000
 /************************* STRUCTURE DEFINITIONS *****************************/
 struct zfcp_fsf_req;
 /* holds various memory pools of an adapter */
 struct zfcp_adapter_mempool {
 	mempool_t *fsf_req_erp;
 	mempool_t *fsf_req_scsi;
 	mempool_t *fsf_req_abort;
 	mempool_t *fsf_req_status_read;
 	mempool_t *data_status_read;
 	mempool_t *data_gid_pn;
 };
 /*
  * header for CT_IU
  */
 struct ct_hdr {
 	u8 revision;		// 0x01
 	u8 in_id[3];		// 0x00
 	u8 gs_type;		// 0xFC	Directory Service
 	u8 gs_subtype;		// 0x02	Name Server
 	u8 options;		// 0x00 single bidirectional exchange
 	u8 reserved0;
 	u16 cmd_rsp_code;	// 0x0121 GID_PN, or 0x0100 GA_NXT
 	u16 max_res_size;	// <= (4096 - 16) / 4
 	u8 reserved1;
 	u8 reason_code;
 	u8 reason_code_expl;
 	u8 vendor_unique;
 } __attribute__ ((packed));
 /* nameserver request CT_IU -- for requests where
  * a port name is required */
 struct ct_iu_gid_pn_req {
 	struct ct_hdr header;
 	u64 wwpn;
 } __attribute__ ((packed));
 /* FS_ACC IU and data unit for GID_PN nameserver request */
 struct ct_iu_gid_pn_resp {
 	struct ct_hdr header;
 	u32 d_id;
 } __attribute__ ((packed));
 /**
  * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct
  * @wka_port: port where the request is sent to
  * @req: scatter-gather list for request
  * @resp: scatter-gather list for response
  * @handler: handler function (called for response to the request)
  * @handler_data: data passed to handler function
  * @timeout: FSF timeout for this request
  * @completion: completion for synchronization purposes
  * @status: used to pass error status to calling function
  */
 struct zfcp_send_ct {
 	struct zfcp_wka_port *wka_port;
 	struct scatterlist *req;
 	struct scatterlist *resp;
 	void (*handler)(unsigned long);
 	unsigned long handler_data;
 	int timeout;
 	struct completion *completion;
 	int status;
 };
 /* used for name server requests in error recovery */
 struct zfcp_gid_pn_data {
 	struct zfcp_send_ct ct;
 	struct scatterlist req;
 	struct scatterlist resp;
 	struct ct_iu_gid_pn_req ct_iu_req;
 	struct ct_iu_gid_pn_resp ct_iu_resp;
         struct zfcp_port *port;
 };
 /**
  * struct zfcp_send_els - used to pass parameters to function zfcp_fsf_send_els
  * @adapter: adapter where request is sent from
  * @port: port where ELS is destinated (port reference count has to be increased)
  * @d_id: destiniation id of port where request is sent to
  * @req: scatter-gather list for request
  * @resp: scatter-gather list for response
  * @handler: handler function (called for response to the request)
  * @handler_data: data passed to handler function
  * @completion: completion for synchronization purposes
  * @ls_code: hex code of ELS command
  * @status: used to pass error status to calling function
  */
 struct zfcp_send_els {
 	struct zfcp_adapter *adapter;
 	struct zfcp_port *port;
 	u32 d_id;
 	struct scatterlist *req;
 	struct scatterlist *resp;
 	void (*handler)(unsigned long);
 	unsigned long handler_data;
 	struct completion *completion;
 	int ls_code;
 	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];
 	u8		   first;	/* index of next free bfr in queue */
 	atomic_t           count;	/* number of free buffers in queue */
 };
 struct zfcp_erp_action {
 	struct list_head list;
 	int action;	              /* requested action code */
 	struct zfcp_adapter *adapter; /* device which should be recovered */
 	struct zfcp_port *port;
 	struct zfcp_unit *unit;
 	u32		status;	      /* recovery status */
 	u32 step;	              /* active step of this erp action */
 	struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
 					 for this action */
 	struct timer_list timer;
 };
 struct fsf_latency_record {
 	u32 min;
 	u32 max;
 	u64 sum;
 };
 struct latency_cont {
 	struct fsf_latency_record channel;
 	struct fsf_latency_record fabric;
 	u64 counter;
 };
 struct zfcp_latencies {
 	struct latency_cont read;
 	struct latency_cont write;
 	struct latency_cont cmd;
 	spinlock_t lock;
 };
 struct zfcp_adapter {
 	atomic_t                refcount;          /* reference count */
 	wait_queue_head_t	remove_wq;         /* can be used to wait for
 						      refcount drop to zero */
 	u64			peer_wwnn;	   /* P2P peer WWNN */
 	u64			peer_wwpn;	   /* P2P peer WWPN */
 	u32			peer_d_id;	   /* P2P peer D_ID */
 	struct ccw_device       *ccw_device;	   /* S/390 ccw device */
 	u32			hydra_version;	   /* Hydra version */
 	u32			fsf_lic_version;
 	u32			adapter_features;  /* FCP channel features */
 	u32			connection_features; /* host connection features */
         u32			hardware_version;  /* of FCP channel */
 	u16			timer_ticks;       /* time int for a tick */
 	struct Scsi_Host	*scsi_host;	   /* Pointer to mid-layer */
 	struct list_head	port_list_head;	   /* remote port list */
 	unsigned long		req_no;		   /* unique FSF req number */
 	struct list_head	*req_list;	   /* list of pending reqs */
 	spinlock_t		req_list_lock;	   /* request list lock */
 	struct zfcp_qdio_queue	req_q;		   /* request queue */
 	spinlock_t		req_q_lock;	   /* for operations on queue */
 	int			req_q_pci_batch;   /* SBALs since PCI indication
 						      was last set */
 	u32			fsf_req_seq_no;	   /* FSF cmnd seq number */
 	wait_queue_head_t	request_wq;	   /* can be used to wait for
 						      more avaliable SBALs */
 	struct zfcp_qdio_queue	resp_q;	   /* response queue */
 	rwlock_t		abort_lock;        /* Protects against SCSI
 						      stack abort/command
 						      completion races */
 	atomic_t		stat_miss;	   /* # missing status reads*/
 	struct work_struct	stat_work;
 	atomic_t		status;	           /* status of this adapter */
 	struct list_head	erp_ready_head;	   /* error recovery for this
 						      adapter/devices */
 	struct list_head	erp_running_head;
 	rwlock_t		erp_lock;
 	struct semaphore	erp_ready_sem;
 	wait_queue_head_t	erp_thread_wqh;
 	wait_queue_head_t	erp_done_wqh;
 	struct zfcp_erp_action	erp_action;	   /* pending error recovery */
         atomic_t                erp_counter;
 	u32			erp_total_count;   /* total nr of enqueued erp
 						      actions */
 	u32			erp_low_mem_count; /* nr of erp actions waiting
 						      for memory */
 	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 */
 	debug_info_t		*scsi_dbf;
 	spinlock_t		rec_dbf_lock;
 	spinlock_t		hba_dbf_lock;
 	spinlock_t		san_dbf_lock;
 	spinlock_t		scsi_dbf_lock;
 	struct zfcp_rec_dbf_record	rec_dbf_buf;
 	struct zfcp_hba_dbf_record	hba_dbf_buf;
 	struct zfcp_san_dbf_record	san_dbf_buf;
 	struct zfcp_scsi_dbf_record	scsi_dbf_buf;
 	struct zfcp_adapter_mempool	pool;      /* Adapter memory pools */
 	struct qdio_initialize  qdio_init_data;    /* for qdio_establish */
 	struct fc_host_statistics *fc_stats;
 	struct fsf_qtcb_bottom_port *stats_reset_data;
 	unsigned long		stats_reset;
 	struct work_struct	scan_work;
 	struct service_level	service_level;
 	atomic_t		qdio_outb_full;	   /* queue full incidents */
 };
 struct zfcp_port {
 	struct device          sysfs_device;   /* sysfs device */
 	struct fc_rport        *rport;         /* rport of fc transport class */
 	struct list_head       list;	       /* list of remote ports */
 	atomic_t               refcount;       /* reference count */
 	wait_queue_head_t      remove_wq;      /* can be used to wait for
 						  refcount drop to zero */
 	struct zfcp_adapter    *adapter;       /* adapter used to access port */
 	struct list_head       unit_list_head; /* head of logical unit list */
 	atomic_t	       status;	       /* status of this remote port */
 	u64		       wwnn;	       /* WWNN if known */
 	u64		       wwpn;	       /* WWPN */
 	u32		       d_id;	       /* D_ID */
 	u32		       handle;	       /* handle assigned by FSF */
 	struct zfcp_erp_action erp_action;     /* pending error recovery */
         atomic_t               erp_counter;
 	u32                    maxframe_size;
 	u32                    supported_classes;
 	struct work_struct     gid_pn_work;
 };
 struct zfcp_unit {
 	struct device          sysfs_device;   /* sysfs device */
 	struct list_head       list;	       /* list of logical units */
 	atomic_t               refcount;       /* reference count */
 	wait_queue_head_t      remove_wq;      /* can be used to wait for
 						  refcount drop to zero */
 	struct zfcp_port       *port;	       /* remote port of unit */
 	atomic_t	       status;	       /* status of this logical unit */
 	u64		       fcp_lun;	       /* own FCP_LUN */
 	u32		       handle;	       /* handle assigned by FSF */
         struct scsi_device     *device;        /* scsi device struct pointer */
 	struct zfcp_erp_action erp_action;     /* pending error recovery */
         atomic_t               erp_counter;
 	struct zfcp_latencies	latencies;
 };
 /* FSF request */
 struct zfcp_fsf_req {
 	struct list_head       list;	       /* list of FSF requests */
 	unsigned long	       req_id;	       /* unique request ID */
 	struct zfcp_adapter    *adapter;       /* adapter request belongs to */
 	u8		       sbal_number;    /* nr of SBALs free for use */
 	u8		       sbal_first;     /* first SBAL for this request */
 	u8		       sbal_last;      /* last SBAL for this request */
 	u8		       sbal_limit;      /* last possible SBAL for
 						  this reuest */
 	u8		       sbale_curr;     /* current SBALE during creation
 						  of request */
 	u8			sbal_response;	/* SBAL used in interrupt */
 	wait_queue_head_t      completion_wq;  /* can be used by a routine
 						  to wait for completion */
 	u32			status;	       /* status of this request */
 	u32		       fsf_command;    /* FSF Command copy */
 	struct fsf_qtcb	       *qtcb;	       /* address of associated QTCB */
 	u32		       seq_no;         /* Sequence number of request */
 	void			*data;           /* private data of request */
 	struct timer_list     timer;	       /* used for erp or scsi er */
 	struct zfcp_erp_action *erp_action;    /* used if this request is
 						  issued on behalf of erp */
 	mempool_t	       *pool;	       /* used if request was alloacted
 						  from emergency pool */
 	unsigned long long     issued;         /* request sent time (STCK) */
 	struct zfcp_unit       *unit;
 	void			(*handler)(struct zfcp_fsf_req *);
 	u16			qdio_outb_usage;/* usage of outbound queue */
 	u16			qdio_inb_usage;	/* usage of inbound queue */
 };
 /* driver data */
 struct zfcp_data {
 	struct scsi_host_template scsi_host_template;
 	struct scsi_transport_template *scsi_transport_template;
 	rwlock_t                config_lock;        /* serialises changes
 						       to adapter/port/unit
 						       lists */
 	struct semaphore        config_sema;        /* serialises configuration
 						       changes */
 	struct kmem_cache	*fsf_req_qtcb_cache;
 	struct kmem_cache	*sr_buffer_cache;
 	struct kmem_cache	*gid_pn_cache;
 	struct workqueue_struct	*work_queue;
 };
 /* struct used by memory pools for fsf_requests */
 struct zfcp_fsf_req_qtcb {
 	struct zfcp_fsf_req fsf_req;
 	struct fsf_qtcb qtcb;
 };
 /********************** ZFCP SPECIFIC DEFINES ********************************/
 #define ZFCP_REQ_AUTO_CLEANUP	0x00000002
 #define ZFCP_REQ_NO_QTCB	0x00000008
 #define ZFCP_SET                0x00000100
 #define ZFCP_CLEAR              0x00000200
 /*
  * Helper functions for request ID management.
  */
 static inline int zfcp_reqlist_hash(unsigned long req_id)
 {
 	return req_id % REQUEST_LIST_SIZE;
 }
 static inline void zfcp_reqlist_remove(struct zfcp_adapter *adapter,
 				       struct zfcp_fsf_req *fsf_req)
 {
 	list_del(&fsf_req->list);
 }
 static inline struct zfcp_fsf_req *
 zfcp_reqlist_find(struct zfcp_adapter *adapter, unsigned long req_id)
 {
 	struct zfcp_fsf_req *request;
 	unsigned int idx;
 	idx = zfcp_reqlist_hash(req_id);
 	list_for_each_entry(request, &adapter->req_list[idx], list)
 		if (request->req_id == req_id)
 			return request;
 	return NULL;
 }
 static inline struct zfcp_fsf_req *
 zfcp_reqlist_find_safe(struct zfcp_adapter *adapter, struct zfcp_fsf_req *req)
 {
 	struct zfcp_fsf_req *request;
 	unsigned int idx;
 	for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) {
 		list_for_each_entry(request, &adapter->req_list[idx], list)
 			if (request == req)
 				return request;
 	}
 	return NULL;
 }
 /*
  *  functions needed for reference/usage counting
  */
 static inline void
 zfcp_unit_get(struct zfcp_unit *unit)
 {
 	atomic_inc(&unit->refcount);
 }
 static inline void
 zfcp_unit_put(struct zfcp_unit *unit)
 {
 	if (atomic_dec_return(&unit->refcount) == 0)
 		wake_up(&unit->remove_wq);
 }
 static inline void
 zfcp_port_get(struct zfcp_port *port)
 {
 	atomic_inc(&port->refcount);
 }
 static inline void
 zfcp_port_put(struct zfcp_port *port)
 {
 	if (atomic_dec_return(&port->refcount) == 0)
 		wake_up(&port->remove_wq);
 }
 static inline void
 zfcp_adapter_get(struct zfcp_adapter *adapter)
 {
 	atomic_inc(&adapter->refcount);
 }
 static inline void
 zfcp_adapter_put(struct zfcp_adapter *adapter)
 {
 	if (atomic_dec_return(&adapter->refcount) == 0)
 		wake_up(&adapter->remove_wq);
 }
 #endif /* ZFCP_DEF_H */

drivers/s390/scsi/zfcp_erp.c

Diff comments View file @ 86f8a1b

 /*
  * zfcp device driver
  *
  * Error Recovery Procedures (ERP).
  *
  * Copyright IBM Corporation 2002, 2008
  */
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include "zfcp_ext.h"
 #define ZFCP_MAX_ERPS                   3
 enum zfcp_erp_act_flags {
 	ZFCP_STATUS_ERP_TIMEDOUT	= 0x10000000,
 	ZFCP_STATUS_ERP_CLOSE_ONLY	= 0x01000000,
 	ZFCP_STATUS_ERP_DISMISSING	= 0x00100000,
 	ZFCP_STATUS_ERP_DISMISSED	= 0x00200000,
 	ZFCP_STATUS_ERP_LOWMEM		= 0x00400000,
 };
 enum zfcp_erp_steps {
 	ZFCP_ERP_STEP_UNINITIALIZED	= 0x0000,
 	ZFCP_ERP_STEP_FSF_XCONFIG	= 0x0001,
 	ZFCP_ERP_STEP_PHYS_PORT_CLOSING	= 0x0010,
 	ZFCP_ERP_STEP_PORT_CLOSING	= 0x0100,
 	ZFCP_ERP_STEP_NAMESERVER_LOOKUP	= 0x0400,
 	ZFCP_ERP_STEP_PORT_OPENING	= 0x0800,
 	ZFCP_ERP_STEP_UNIT_CLOSING	= 0x1000,
 	ZFCP_ERP_STEP_UNIT_OPENING	= 0x2000,
 };
 enum zfcp_erp_act_type {
 	ZFCP_ERP_ACTION_REOPEN_UNIT        = 1,
 	ZFCP_ERP_ACTION_REOPEN_PORT	   = 2,
 	ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
 	ZFCP_ERP_ACTION_REOPEN_ADAPTER     = 4,
 };
 enum zfcp_erp_act_state {
 	ZFCP_ERP_ACTION_RUNNING = 1,
 	ZFCP_ERP_ACTION_READY   = 2,
 };
 enum zfcp_erp_act_result {
 	ZFCP_ERP_SUCCEEDED = 0,
 	ZFCP_ERP_FAILED    = 1,
 	ZFCP_ERP_CONTINUES = 2,
 	ZFCP_ERP_EXIT      = 3,
 	ZFCP_ERP_DISMISSED = 4,
 	ZFCP_ERP_NOMEM     = 5,
 };
 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
 {
 	zfcp_erp_modify_adapter_status(adapter, 15, NULL,
 				       ZFCP_STATUS_COMMON_UNBLOCKED | mask,
 				       ZFCP_CLEAR);
 }
 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
 {
 	struct zfcp_erp_action *curr_act;
 	list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
 		if (act == curr_act)
 			return ZFCP_ERP_ACTION_RUNNING;
 	return 0;
 }
 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
 {
 	struct zfcp_adapter *adapter = act->adapter;
 	list_move(&act->list, &act->adapter->erp_ready_head);
 	zfcp_rec_dbf_event_action(146, act);
 	up(&adapter->erp_ready_sem);
 	zfcp_rec_dbf_event_thread(2, adapter);
 }
 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
 {
 	act->status |= ZFCP_STATUS_ERP_DISMISSED;
 	if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
 		zfcp_erp_action_ready(act);
 }
 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
 {
 	if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 		zfcp_erp_action_dismiss(&unit->erp_action);
 }
 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
 {
 	struct zfcp_unit *unit;
 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 		zfcp_erp_action_dismiss(&port->erp_action);
 	else
 		list_for_each_entry(unit, &port->unit_list_head, list)
 		    zfcp_erp_action_dismiss_unit(unit);
 }
 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 {
 	struct zfcp_port *port;
 	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
 		zfcp_erp_action_dismiss(&adapter->erp_action);
 	else
 		list_for_each_entry(port, &adapter->port_list_head, list)
 		    zfcp_erp_action_dismiss_port(port);
 }
 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
 				 struct zfcp_port *port,
 				 struct zfcp_unit *unit)
 {
 	int need = want;
 	int u_status, p_status, a_status;
 	switch (want) {
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		u_status = atomic_read(&unit->status);
 		if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 			return 0;
 		p_status = atomic_read(&port->status);
 		if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
 		      p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
 			return 0;
 		if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
 			need = ZFCP_ERP_ACTION_REOPEN_PORT;
 		/* fall through */
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 		p_status = atomic_read(&port->status);
 		if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 			return 0;
 		a_status = atomic_read(&adapter->status);
 		if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
 		      a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
 			return 0;
 		if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
 			need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
 		/* fall through */
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		a_status = atomic_read(&adapter->status);
 		if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
 			return 0;
 	}
 	return need;
 }
 static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 						  struct zfcp_adapter *adapter,
 						  struct zfcp_port *port,
 						  struct zfcp_unit *unit)
 {
 	struct zfcp_erp_action *erp_action;
 	u32 status = 0;
 	switch (need) {
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		zfcp_unit_get(unit);
 		atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
 		erp_action = &unit->erp_action;
 		if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING))
 			status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 		zfcp_port_get(port);
 		zfcp_erp_action_dismiss_port(port);
 		atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
 		erp_action = &port->erp_action;
 		if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
 			status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		zfcp_adapter_get(adapter);
 		zfcp_erp_action_dismiss_adapter(adapter);
 		atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
 		erp_action = &adapter->erp_action;
 		if (!(atomic_read(&adapter->status) &
 		      ZFCP_STATUS_COMMON_RUNNING))
 			status = ZFCP_STATUS_ERP_CLOSE_ONLY;
 		break;
 	default:
 		return NULL;
 	}
 	memset(erp_action, 0, sizeof(struct zfcp_erp_action));
 	erp_action->adapter = adapter;
 	erp_action->port = port;
 	erp_action->unit = unit;
 	erp_action->action = need;
 	erp_action->status = status;
 	return erp_action;
 }
 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
 				   struct zfcp_port *port,
 				   struct zfcp_unit *unit, u8 id, void *ref)
 {
 	int retval = 1, need;
 	struct zfcp_erp_action *act = NULL;
 	if (!(atomic_read(&adapter->status) &
 	      ZFCP_STATUS_ADAPTER_ERP_THREAD_UP))
 		return -EIO;
 	need = zfcp_erp_required_act(want, adapter, port, unit);
 	if (!need)
 		goto out;
 	atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
 	act = zfcp_erp_setup_act(need, adapter, port, unit);
 	if (!act)
 		goto out;
 	++adapter->erp_total_count;
 	list_add_tail(&act->list, &adapter->erp_ready_head);
 	up(&adapter->erp_ready_sem);
 	zfcp_rec_dbf_event_thread(1, adapter);
 	retval = 0;
  out:
 	zfcp_rec_dbf_event_trigger(id, ref, want, need, act,
 				   adapter, port, unit);
 	return retval;
 }
 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
 				    int clear_mask, u8 id, void *ref)
 {
 	zfcp_erp_adapter_block(adapter, clear_mask);
 	/* ensure propagation of failed status to new devices */
 	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 		zfcp_erp_adapter_failed(adapter, 13, NULL);
 		return -EIO;
 	}
 	return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
 				       adapter, NULL, NULL, id, ref);
 }
 /**
  * zfcp_erp_adapter_reopen - Reopen adapter.
  * @adapter: Adapter to reopen.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
  * @ref: Reference for debug trace event.
  */
 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
 			     u8 id, void *ref)
 {
 	unsigned long flags;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	_zfcp_erp_adapter_reopen(adapter, clear, id, ref);
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 /**
  * zfcp_erp_adapter_shutdown - Shutdown adapter.
  * @adapter: Adapter to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
  * @ref: Reference for debug trace event.
  */
 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
 			       u8 id, void *ref)
 {
 	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 	zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
 }
 /**
  * zfcp_erp_port_shutdown - Shutdown port
  * @port: Port to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
  * @ref: Reference for debug trace event.
  */
 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, u8 id, void *ref)
 {
 	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 	zfcp_erp_port_reopen(port, clear | flags, id, ref);
 }
 /**
  * zfcp_erp_unit_shutdown - Shutdown unit
  * @unit: Unit to shut down.
  * @clear: Status flags to clear.
  * @id: Id for debug trace event.
  * @ref: Reference for debug trace event.
  */
 void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear, u8 id, void *ref)
 {
 	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
 	zfcp_erp_unit_reopen(unit, clear | flags, id, ref);
 }
 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
 {
 	zfcp_erp_modify_port_status(port, 17, NULL,
 				    ZFCP_STATUS_COMMON_UNBLOCKED | clear,
 				    ZFCP_CLEAR);
 }
 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
 					 int clear, u8 id, void *ref)
 {
 	zfcp_erp_port_block(port, clear);
 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
 		return;
 	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
 				port->adapter, port, NULL, id, ref);
 }
 /**
  * zfcp_erp_port_forced_reopen - Forced close of port and open again
  * @port: Port to force close and to reopen.
  * @id: Id for debug trace event.
  * @ref: Reference for debug trace event.
  */
 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, u8 id,
 				 void *ref)
 {
 	unsigned long flags;
 	struct zfcp_adapter *adapter = port->adapter;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	_zfcp_erp_port_forced_reopen(port, clear, id, ref);
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id,
 				 void *ref)
 {
 	zfcp_erp_port_block(port, clear);
 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 		/* ensure propagation of failed status to new devices */
 		zfcp_erp_port_failed(port, 14, NULL);
 		return -EIO;
 	}
 	return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
 				       port->adapter, port, NULL, id, ref);
 }
 /**
  * zfcp_erp_port_reopen - trigger remote port recovery
  * @port: port to recover
  * @clear_mask: flags in port status to be cleared
  *
  * Returns 0 if recovery has been triggered, < 0 if not.
  */
 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id, void *ref)
 {
 	unsigned long flags;
 	int retval;
 	struct zfcp_adapter *adapter = port->adapter;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	retval = _zfcp_erp_port_reopen(port, clear, id, ref);
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 	return retval;
 }
 static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
 {
 	zfcp_erp_modify_unit_status(unit, 19, NULL,
 				    ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
 				    ZFCP_CLEAR);
 }
 static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id,
 				  void *ref)
 {
 	struct zfcp_adapter *adapter = unit->port->adapter;
 	zfcp_erp_unit_block(unit, clear);
 	if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
 		return;
 	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
 				adapter, unit->port, unit, id, ref);
 }
 /**
  * zfcp_erp_unit_reopen - initiate reopen of a unit
  * @unit: unit to be reopened
  * @clear_mask: specifies flags in unit status to be cleared
  * Return: 0 on success, < 0 on error
  */
 void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id, void *ref)
 {
 	unsigned long flags;
 	struct zfcp_port *port = unit->port;
 	struct zfcp_adapter *adapter = port->adapter;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	_zfcp_erp_unit_reopen(unit, clear, id, ref);
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 static int status_change_set(unsigned long mask, atomic_t *status)
 {
 	return (atomic_read(status) ^ mask) & mask;
 }
 static int status_change_clear(unsigned long mask, atomic_t *status)
 {
 	return atomic_read(status) & mask;
 }
 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 {
 	if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
 		zfcp_rec_dbf_event_adapter(16, NULL, adapter);
 	atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
 }
 static void zfcp_erp_port_unblock(struct zfcp_port *port)
 {
 	if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
 		zfcp_rec_dbf_event_port(18, NULL, port);
 	atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
 }
 static void zfcp_erp_unit_unblock(struct zfcp_unit *unit)
 {
 	if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status))
 		zfcp_rec_dbf_event_unit(20, NULL, unit);
 	atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
 }
 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 {
 	list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
 	zfcp_rec_dbf_event_action(145, erp_action);
 }
 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
 {
 	struct zfcp_adapter *adapter = act->adapter;
 	if (!act->fsf_req)
 		return;
 	spin_lock(&adapter->req_list_lock);
 	if (zfcp_reqlist_find_safe(adapter, act->fsf_req) &&
 	    act->fsf_req->erp_action == act) {
 		if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
 				   ZFCP_STATUS_ERP_TIMEDOUT)) {
 			act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
 			zfcp_rec_dbf_event_action(142, act);
 			act->fsf_req->erp_action = NULL;
 		}
 		if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
 			zfcp_rec_dbf_event_action(143, act);
 		if (act->fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED |
 					    ZFCP_STATUS_FSFREQ_DISMISSED))
 			act->fsf_req = NULL;
 	} else
 		act->fsf_req = NULL;
 	spin_unlock(&adapter->req_list_lock);
 }
 /**
  * zfcp_erp_notify - Trigger ERP action.
  * @erp_action: ERP action to continue.
  * @set_mask: ERP action status flags to set.
  */
 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
 {
 	struct zfcp_adapter *adapter = erp_action->adapter;
 	unsigned long flags;
 	write_lock_irqsave(&adapter->erp_lock, flags);
 	if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
 		erp_action->status |= set_mask;
 		zfcp_erp_action_ready(erp_action);
 	}
 	write_unlock_irqrestore(&adapter->erp_lock, flags);
 }
 /**
  * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
  * @data: ERP action (from timer data)
  */
 void zfcp_erp_timeout_handler(unsigned long data)
 {
 	struct zfcp_erp_action *act = (struct zfcp_erp_action *) data;
 	zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
 }
 static void zfcp_erp_memwait_handler(unsigned long data)
 {
 	zfcp_erp_notify((struct zfcp_erp_action *)data, 0);
 }
 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
 {
 	init_timer(&erp_action->timer);
 	erp_action->timer.function = zfcp_erp_memwait_handler;
 	erp_action->timer.data = (unsigned long) erp_action;
 	erp_action->timer.expires = jiffies + HZ;
 	add_timer(&erp_action->timer);
 }
 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
 				      int clear, u8 id, void *ref)
 {
 	struct zfcp_port *port;
 	list_for_each_entry(port, &adapter->port_list_head, list)
 		_zfcp_erp_port_reopen(port, clear, id, ref);
 }
 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id,
 				      void *ref)
 {
 	struct zfcp_unit *unit;
 	list_for_each_entry(unit, &port->unit_list_head, list)
 		_zfcp_erp_unit_reopen(unit, clear, id, ref);
 }
 static void zfcp_erp_strategy_followup_actions(struct zfcp_erp_action *act)
 {
 	struct zfcp_adapter *adapter = act->adapter;
 	struct zfcp_port *port = act->port;
 	struct zfcp_unit *unit = act->unit;
 	u32 status = act->status;
 	/* initiate follow-up actions depending on success of finished action */
 	switch (act->action) {
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		if (status == ZFCP_ERP_SUCCEEDED)
 			_zfcp_erp_port_reopen_all(adapter, 0, 70, NULL);
 		else
 			_zfcp_erp_adapter_reopen(adapter, 0, 71, NULL);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 		if (status == ZFCP_ERP_SUCCEEDED)
 			_zfcp_erp_port_reopen(port, 0, 72, NULL);
 		else
 			_zfcp_erp_adapter_reopen(adapter, 0, 73, NULL);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		if (status == ZFCP_ERP_SUCCEEDED)
 			_zfcp_erp_unit_reopen_all(port, 0, 74, NULL);
 		else
 			_zfcp_erp_port_forced_reopen(port, 0, 75, NULL);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		if (status != ZFCP_ERP_SUCCEEDED)
 			_zfcp_erp_port_reopen(unit->port, 0, 76, NULL);
 		break;
 	}
 }
 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
 {
 	unsigned long flags;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	read_lock(&adapter->erp_lock);
 	if (list_empty(&adapter->erp_ready_head) &&
 	    list_empty(&adapter->erp_running_head)) {
 			atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
 					  &adapter->status);
 			wake_up(&adapter->erp_done_wqh);
 	}
 	read_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
 {
 	if (zfcp_qdio_open(act->adapter))
 		return ZFCP_ERP_FAILED;
 	init_waitqueue_head(&act->adapter->request_wq);
 	atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
 	return ZFCP_ERP_SUCCEEDED;
 }
 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
 {
 	struct zfcp_port *port;
 	port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
 				 adapter->peer_d_id);
 	if (IS_ERR(port)) /* error or port already attached */
 		return;
 	_zfcp_erp_port_reopen(port, 0, 150, NULL);
 }
 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
 {
 	int retries;
 	int sleep = 1;
 	struct zfcp_adapter *adapter = erp_action->adapter;
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
 	for (retries = 7; retries; retries--) {
 		atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 				  &adapter->status);
 		write_lock_irq(&adapter->erp_lock);
 		zfcp_erp_action_to_running(erp_action);
 		write_unlock_irq(&adapter->erp_lock);
 		if (zfcp_fsf_exchange_config_data(erp_action)) {
 			atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 					  &adapter->status);
 			return ZFCP_ERP_FAILED;
 		}
 		zfcp_rec_dbf_event_thread_lock(6, adapter);
 		down(&adapter->erp_ready_sem);
 		zfcp_rec_dbf_event_thread_lock(7, adapter);
 		if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
 			break;
 		if (!(atomic_read(&adapter->status) &
 		      ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
 			break;
 		ssleep(sleep);
 		sleep *= 2;
 	}
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
 			  &adapter->status);
 	if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
 		return ZFCP_ERP_FAILED;
 	if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
 		zfcp_erp_enqueue_ptp_port(adapter);
 	return ZFCP_ERP_SUCCEEDED;
 }
 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
 {
 	int ret;
 	struct zfcp_adapter *adapter = act->adapter;
 	write_lock_irq(&adapter->erp_lock);
 	zfcp_erp_action_to_running(act);
 	write_unlock_irq(&adapter->erp_lock);
 	ret = zfcp_fsf_exchange_port_data(act);
 	if (ret == -EOPNOTSUPP)
 		return ZFCP_ERP_SUCCEEDED;
 	if (ret)
 		return ZFCP_ERP_FAILED;
 	zfcp_rec_dbf_event_thread_lock(8, adapter);
 	down(&adapter->erp_ready_sem);
 	zfcp_rec_dbf_event_thread_lock(9, adapter);
 	if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
 		return ZFCP_ERP_FAILED;
 	return ZFCP_ERP_SUCCEEDED;
 }
 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
 {
 	if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
 		return ZFCP_ERP_FAILED;
 	if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
 		return ZFCP_ERP_FAILED;
 	atomic_set(&act->adapter->stat_miss, 16);
 	if (zfcp_status_read_refill(act->adapter))
 		return ZFCP_ERP_FAILED;
 	return ZFCP_ERP_SUCCEEDED;
 }
 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *act,
 					     int close)
 {
 	int retval = ZFCP_ERP_SUCCEEDED;
 	struct zfcp_adapter *adapter = act->adapter;
 	if (close)
 		goto close_only;
 	retval = zfcp_erp_adapter_strategy_open_qdio(act);
 	if (retval != ZFCP_ERP_SUCCEEDED)
 		goto failed_qdio;
 	retval = zfcp_erp_adapter_strategy_open_fsf(act);
 	if (retval != ZFCP_ERP_SUCCEEDED)
 		goto failed_openfcp;
 	atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &act->adapter->status);
 	return ZFCP_ERP_SUCCEEDED;
  close_only:
 	atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
 			  &act->adapter->status);
  failed_openfcp:
 	/* close queues to ensure that buffers are not accessed by adapter */
 	zfcp_qdio_close(adapter);
 	zfcp_fsf_req_dismiss_all(adapter);
 	adapter->fsf_req_seq_no = 0;
 	/* all ports and units are closed */
 	zfcp_erp_modify_adapter_status(adapter, 24, NULL,
 				       ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
  failed_qdio:
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
 			  ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
 			  &act->adapter->status);
 	return retval;
 }
 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
 {
 	int retval;
 	zfcp_erp_adapter_strategy_generic(act, 1); /* close */
 	if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 		return ZFCP_ERP_EXIT;
 	retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */
 	if (retval == ZFCP_ERP_FAILED)
 		ssleep(8);
 	return retval;
 }
 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
 {
 	int retval;
 	retval = zfcp_fsf_close_physical_port(act);
 	if (retval == -ENOMEM)
 		return ZFCP_ERP_NOMEM;
 	act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
 	if (retval)
 		return ZFCP_ERP_FAILED;
 	return ZFCP_ERP_CONTINUES;
 }
 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
 {
 	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status);
 }
 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
 {
 	struct zfcp_port *port = erp_action->port;
 	int status = atomic_read(&port->status);
 	switch (erp_action->step) {
 	case ZFCP_ERP_STEP_UNINITIALIZED:
 		zfcp_erp_port_strategy_clearstati(port);
 		if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
 		    (status & ZFCP_STATUS_COMMON_OPEN))
 			return zfcp_erp_port_forced_strategy_close(erp_action);
 		else
 			return ZFCP_ERP_FAILED;
 	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 		if (status & ZFCP_STATUS_PORT_PHYS_OPEN)
 			return ZFCP_ERP_SUCCEEDED;
 	}
 	return ZFCP_ERP_FAILED;
 }
 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
 {
 	int retval;
 	retval = zfcp_fsf_close_port(erp_action);
 	if (retval == -ENOMEM)
 		return ZFCP_ERP_NOMEM;
 	erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
 	if (retval)
 		return ZFCP_ERP_FAILED;
 	return ZFCP_ERP_CONTINUES;
 }
 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
 {
 	int retval;
 	retval = zfcp_fsf_open_port(erp_action);
 	if (retval == -ENOMEM)
 		return ZFCP_ERP_NOMEM;
 	erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
 	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;
 	struct zfcp_port *port = act->port;
 	if (port->wwpn != adapter->peer_wwpn) {
 		zfcp_erp_port_failed(port, 25, NULL);
 		return ZFCP_ERP_FAILED;
 	}
 	port->d_id = adapter->peer_d_id;
 	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;
 	int p_status = atomic_read(&port->status);
 	switch (act->step) {
 	case ZFCP_ERP_STEP_UNINITIALIZED:
 	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
 	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 (!port->d_id) {
 			queue_work(zfcp_data.work_queue, &port->gid_pn_work);
 			return ZFCP_ERP_CONTINUES;
 		}
 	case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
 		if (!port->d_id)
 			return ZFCP_ERP_FAILED;
 		return zfcp_erp_port_strategy_open_port(act);
 	case ZFCP_ERP_STEP_PORT_OPENING:
 		/* D_ID might have changed during open */
 		if (p_status & ZFCP_STATUS_COMMON_OPEN) {
 			if (port->d_id)
 				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(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);
 		if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
 			return zfcp_erp_port_strategy_close(erp_action);
 		break;
 	case ZFCP_ERP_STEP_PORT_CLOSING:
 		if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
 			return ZFCP_ERP_FAILED;
 		break;
 	}
 close_init_done:
 	if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 		return ZFCP_ERP_EXIT;
 	return zfcp_erp_port_strategy_open_common(erp_action);
 }
 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
 {
 	atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
 			  ZFCP_STATUS_UNIT_SHARED |
 			  ZFCP_STATUS_UNIT_READONLY,
 			  &unit->status);
 }
 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
 {
 	int retval = zfcp_fsf_close_unit(erp_action);
 	if (retval == -ENOMEM)
 		return ZFCP_ERP_NOMEM;
 	erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
 	if (retval)
 		return ZFCP_ERP_FAILED;
 	return ZFCP_ERP_CONTINUES;
 }
 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
 {
 	int retval = zfcp_fsf_open_unit(erp_action);
 	if (retval == -ENOMEM)
 		return ZFCP_ERP_NOMEM;
 	erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
 	if (retval)
 		return  ZFCP_ERP_FAILED;
 	return ZFCP_ERP_CONTINUES;
 }
 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
 {
 	struct zfcp_unit *unit = erp_action->unit;
 	switch (erp_action->step) {
 	case ZFCP_ERP_STEP_UNINITIALIZED:
 		zfcp_erp_unit_strategy_clearstati(unit);
 		if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 			return zfcp_erp_unit_strategy_close(erp_action);
 		/* already closed, fall through */
 	case ZFCP_ERP_STEP_UNIT_CLOSING:
 		if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 			return ZFCP_ERP_FAILED;
 		if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
 			return ZFCP_ERP_EXIT;
 		return zfcp_erp_unit_strategy_open(erp_action);
 	case ZFCP_ERP_STEP_UNIT_OPENING:
 		if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
 			return ZFCP_ERP_SUCCEEDED;
 	}
 	return ZFCP_ERP_FAILED;
 }
 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
 {
 	switch (result) {
 	case ZFCP_ERP_SUCCEEDED :
 		atomic_set(&unit->erp_counter, 0);
 		zfcp_erp_unit_unblock(unit);
 		break;
 	case ZFCP_ERP_FAILED :
 		atomic_inc(&unit->erp_counter);
 		if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
 			dev_err(&unit->port->adapter->ccw_device->dev,
 				"ERP failed for unit 0x%016Lx on "
 				"port 0x%016Lx\n",
 				(unsigned long long)unit->fcp_lun,
 				(unsigned long long)unit->port->wwpn);
 			zfcp_erp_unit_failed(unit, 21, NULL);
 		}
 		break;
 	}
 	if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 		zfcp_erp_unit_block(unit, 0);
 		result = ZFCP_ERP_EXIT;
 	}
 	return result;
 }
 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
 {
 	switch (result) {
 	case ZFCP_ERP_SUCCEEDED :
 		atomic_set(&port->erp_counter, 0);
 		zfcp_erp_port_unblock(port);
 		break;
 	case ZFCP_ERP_FAILED :
 		if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
 			zfcp_erp_port_block(port, 0);
 			result = ZFCP_ERP_EXIT;
 		}
 		atomic_inc(&port->erp_counter);
 		if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
 			dev_err(&port->adapter->ccw_device->dev,
 				"ERP failed for remote port 0x%016Lx\n",
 				(unsigned long long)port->wwpn);
 			zfcp_erp_port_failed(port, 22, NULL);
 		}
 		break;
 	}
 	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 		zfcp_erp_port_block(port, 0);
 		result = ZFCP_ERP_EXIT;
 	}
 	return result;
 }
 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
 					   int result)
 {
 	switch (result) {
 	case ZFCP_ERP_SUCCEEDED :
 		atomic_set(&adapter->erp_counter, 0);
 		zfcp_erp_adapter_unblock(adapter);
 		break;
 	case ZFCP_ERP_FAILED :
 		atomic_inc(&adapter->erp_counter);
 		if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
 			dev_err(&adapter->ccw_device->dev,
 				"ERP cannot recover an error "
 				"on the FCP device\n");
 			zfcp_erp_adapter_failed(adapter, 23, NULL);
 		}
 		break;
 	}
 	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
 		zfcp_erp_adapter_block(adapter, 0);
 		result = ZFCP_ERP_EXIT;
 	}
 	return result;
 }
 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
 					  int result)
 {
 	struct zfcp_adapter *adapter = erp_action->adapter;
 	struct zfcp_port *port = erp_action->port;
 	struct zfcp_unit *unit = erp_action->unit;
 	switch (erp_action->action) {
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		result = zfcp_erp_strategy_check_unit(unit, result);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		result = zfcp_erp_strategy_check_port(port, result);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		result = zfcp_erp_strategy_check_adapter(adapter, result);
 		break;
 	}
 	return result;
 }
 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
 {
 	int status = atomic_read(target_status);
 	if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
 	    (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
 		return 1; /* take it online */
 	if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
 	    !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
 		return 1; /* take it offline */
 	return 0;
 }
 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
 {
 	int action = act->action;
 	struct zfcp_adapter *adapter = act->adapter;
 	struct zfcp_port *port = act->port;
 	struct zfcp_unit *unit = act->unit;
 	u32 erp_status = act->status;
 	switch (action) {
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
 			_zfcp_erp_adapter_reopen(adapter,
 						 ZFCP_STATUS_COMMON_ERP_FAILED,
 						 67, NULL);
 			return ZFCP_ERP_EXIT;
 		}
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
 			_zfcp_erp_port_reopen(port,
 					      ZFCP_STATUS_COMMON_ERP_FAILED,
 					      68, NULL);
 			return ZFCP_ERP_EXIT;
 		}
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		if (zfcp_erp_strat_change_det(&unit->status, erp_status)) {
 			_zfcp_erp_unit_reopen(unit,
 					      ZFCP_STATUS_COMMON_ERP_FAILED,
 					      69, NULL);
 			return ZFCP_ERP_EXIT;
 		}
 		break;
 	}
 	return ret;
 }
 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
 {
 	struct zfcp_adapter *adapter = erp_action->adapter;
 	adapter->erp_total_count--;
 	if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
 		adapter->erp_low_mem_count--;
 		erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
 	}
 	list_del(&erp_action->list);
 	zfcp_rec_dbf_event_action(144, erp_action);
 	switch (erp_action->action) {
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
 				  &erp_action->unit->status);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
 				  &erp_action->port->status);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
 				  &erp_action->adapter->status);
 		break;
 	}
 }
 struct zfcp_erp_add_work {
 	struct zfcp_unit  *unit;
 	struct work_struct work;
 };
 static void zfcp_erp_scsi_scan(struct work_struct *work)
 {
 	struct zfcp_erp_add_work *p =
 		container_of(work, struct zfcp_erp_add_work, work);
 	struct zfcp_unit *unit = p->unit;
 	struct fc_rport *rport = unit->port->rport;
 	if (rport && rport->port_state == FC_PORTSTATE_ONLINE)
 		scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
 			 scsilun_to_int((struct scsi_lun *)&unit->fcp_lun), 0);
 	atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
 	zfcp_unit_put(unit);
 	wake_up(&unit->port->adapter->erp_done_wqh);
 	kfree(p);
 }
 static void zfcp_erp_schedule_work(struct zfcp_unit *unit)
 {
 	struct zfcp_erp_add_work *p;
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (!p) {
 		dev_err(&unit->port->adapter->ccw_device->dev,
 			"Registering unit 0x%016Lx on port 0x%016Lx failed\n",
 			(unsigned long long)unit->fcp_lun,
 			(unsigned long long)unit->port->wwpn);
 		return;
 	}
 	zfcp_unit_get(unit);
 	atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
 	INIT_WORK(&p->work, zfcp_erp_scsi_scan);
 	p->unit = unit;
 	queue_work(zfcp_data.work_queue, &p->work);
 }
 static void zfcp_erp_rport_register(struct zfcp_port *port)
 {
 	struct fc_rport_identifiers ids;
 	ids.node_name = port->wwnn;
 	ids.port_name = port->wwpn;
 	ids.port_id = port->d_id;
 	ids.roles = FC_RPORT_ROLE_FCP_TARGET;
 	port->rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
 	if (!port->rport) {
 		dev_err(&port->adapter->ccw_device->dev,
 			"Registering port 0x%016Lx failed\n",
 			(unsigned long long)port->wwpn);
 		return;
 	}
 	scsi_target_unblock(&port->rport->dev);
 	port->rport->maxframe_size = port->maxframe_size;
 	port->rport->supported_classes = port->supported_classes;
 }
 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)
 			continue;
 		fc_remote_port_delete(port->rport);
 		port->rport = NULL;
 	}
 }
 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
 {
 	struct zfcp_adapter *adapter = act->adapter;
 	struct zfcp_port *port = act->port;
 	struct zfcp_unit *unit = act->unit;
 	switch (act->action) {
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		if ((result == ZFCP_ERP_SUCCEEDED) &&
 		    !unit->device && port->rport) {
-			atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
-					&unit->status);
 			if (!(atomic_read(&unit->status) &
 			      ZFCP_STATUS_UNIT_SCSI_WORK_PENDING))
 				zfcp_erp_schedule_work(unit);
 		}
 		zfcp_unit_put(unit);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		if ((result == ZFCP_ERP_SUCCEEDED) && !port->rport)
 			zfcp_erp_rport_register(port);
 		if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
 			fc_remote_port_delete(port->rport);
 			port->rport = NULL;
 		}
 		zfcp_port_put(port);
 		break;
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		if (result != ZFCP_ERP_SUCCEEDED) {
 			unregister_service_level(&adapter->service_level);
 			zfcp_erp_rports_del(adapter);
 		} else {
 			register_service_level(&adapter->service_level);
 			schedule_work(&adapter->scan_work);
 		}
 		zfcp_adapter_put(adapter);
 		break;
 	}
 }
 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
 {
 	switch (erp_action->action) {
 	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
 		return zfcp_erp_adapter_strategy(erp_action);
 	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
 		return zfcp_erp_port_forced_strategy(erp_action);
 	case ZFCP_ERP_ACTION_REOPEN_PORT:
 		return zfcp_erp_port_strategy(erp_action);
 	case ZFCP_ERP_ACTION_REOPEN_UNIT:
 		return zfcp_erp_unit_strategy(erp_action);
 	}
 	return ZFCP_ERP_FAILED;
 }
 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
 {
 	int retval;
 	struct zfcp_adapter *adapter = erp_action->adapter;
 	unsigned long flags;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	zfcp_erp_strategy_check_fsfreq(erp_action);
 	if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
 		zfcp_erp_action_dequeue(erp_action);
 		retval = ZFCP_ERP_DISMISSED;
 		goto unlock;
 	}
 	zfcp_erp_action_to_running(erp_action);
 	/* no lock to allow for blocking operations */
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 	retval = zfcp_erp_strategy_do_action(erp_action);
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	write_lock(&adapter->erp_lock);
 	if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
 		retval = ZFCP_ERP_CONTINUES;
 	switch (retval) {
 	case ZFCP_ERP_NOMEM:
 		if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
 			++adapter->erp_low_mem_count;
 			erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
 		}
 		if (adapter->erp_total_count == adapter->erp_low_mem_count)
 			_zfcp_erp_adapter_reopen(adapter, 0, 66, NULL);
 		else {
 			zfcp_erp_strategy_memwait(erp_action);
 			retval = ZFCP_ERP_CONTINUES;
 		}
 		goto unlock;
 	case ZFCP_ERP_CONTINUES:
 		if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
 			--adapter->erp_low_mem_count;
 			erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
 		}
 		goto unlock;
 	}
 	retval = zfcp_erp_strategy_check_target(erp_action, retval);
 	zfcp_erp_action_dequeue(erp_action);
 	retval = zfcp_erp_strategy_statechange(erp_action, retval);
 	if (retval == ZFCP_ERP_EXIT)
 		goto unlock;
 	zfcp_erp_strategy_followup_actions(erp_action);
  unlock:
 	write_unlock(&adapter->erp_lock);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 	if (retval != ZFCP_ERP_CONTINUES)
 		zfcp_erp_action_cleanup(erp_action, retval);
 	return retval;
 }
 static int zfcp_erp_thread(void *data)
 {
 	struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
 	struct list_head *next;
 	struct zfcp_erp_action *act;
 	unsigned long flags;
 	int ignore;
 	daemonize("zfcperp%s", dev_name(&adapter->ccw_device->dev));
 	/* Block all signals */
 	siginitsetinv(&current->blocked, 0);
 	atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
 	wake_up(&adapter->erp_thread_wqh);
 	while (!(atomic_read(&adapter->status) &
 		 ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL)) {
 		write_lock_irqsave(&adapter->erp_lock, flags);
 		next = adapter->erp_ready_head.next;
 		write_unlock_irqrestore(&adapter->erp_lock, flags);
 		if (next != &adapter->erp_ready_head) {
 			act = list_entry(next, struct zfcp_erp_action, list);
 			/* there is more to come after dismission, no notify */
 			if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
 				zfcp_erp_wakeup(adapter);
 		}
 		zfcp_rec_dbf_event_thread_lock(4, adapter);
 		ignore = down_interruptible(&adapter->erp_ready_sem);
 		zfcp_rec_dbf_event_thread_lock(5, adapter);
 	}
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
 	wake_up(&adapter->erp_thread_wqh);
 	return 0;
 }
 /**
  * zfcp_erp_thread_setup - Start ERP thread for adapter
  * @adapter: Adapter to start the ERP thread for
  *
  * Returns 0 on success or error code from kernel_thread()
  */
 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
 {
 	int retval;
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
 	retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
 	if (retval < 0) {
 		dev_err(&adapter->ccw_device->dev,
 			"Creating an ERP thread for the FCP device failed.\n");
 		return retval;
 	}
 	wait_event(adapter->erp_thread_wqh,
 		   atomic_read(&adapter->status) &
 			ZFCP_STATUS_ADAPTER_ERP_THREAD_UP);
 	return 0;
 }
 /**
  * zfcp_erp_thread_kill - Stop ERP thread.
  * @adapter: Adapter where the ERP thread should be stopped.
  *
  * The caller of this routine ensures that the specified adapter has
  * been shut down and that this operation has been completed. Thus,
  * there are no pending erp_actions which would need to be handled
  * here.
  */
 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
 {
 	atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
 	up(&adapter->erp_ready_sem);
 	zfcp_rec_dbf_event_thread_lock(3, adapter);
 	wait_event(adapter->erp_thread_wqh,
 		   !(atomic_read(&adapter->status) &
 				ZFCP_STATUS_ADAPTER_ERP_THREAD_UP));
 	atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
 			  &adapter->status);
 }
 /**
  * zfcp_erp_adapter_failed - Set adapter status to failed.
  * @adapter: Failed adapter.
  * @id: Event id for debug trace.
  * @ref: Reference for debug trace.
  */
 void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, void *ref)
 {
 	zfcp_erp_modify_adapter_status(adapter, id, ref,
 				       ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
 }
 /**
  * zfcp_erp_port_failed - Set port status to failed.
  * @port: Failed port.
  * @id: Event id for debug trace.
  * @ref: Reference for debug trace.
  */
 void zfcp_erp_port_failed(struct zfcp_port *port, u8 id, void *ref)
 {
 	zfcp_erp_modify_port_status(port, id, ref,
 				    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
 }
 /**
  * zfcp_erp_unit_failed - Set unit status to failed.
  * @unit: Failed unit.
  * @id: Event id for debug trace.
  * @ref: Reference for debug trace.
  */
 void zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, void *ref)
 {
 	zfcp_erp_modify_unit_status(unit, id, ref,
 				    ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
 }
 /**
  * zfcp_erp_wait - wait for completion of error recovery on an adapter
  * @adapter: adapter for which to wait for completion of its error recovery
  */
 void zfcp_erp_wait(struct zfcp_adapter *adapter)
 {
 	wait_event(adapter->erp_done_wqh,
 		   !(atomic_read(&adapter->status) &
 			ZFCP_STATUS_ADAPTER_ERP_PENDING));
 }
 /**
  * zfcp_erp_modify_adapter_status - change adapter status bits
  * @adapter: adapter to change the status
  * @id: id for the debug trace
  * @ref: reference for the debug trace
  * @mask: status bits to change
  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
  *
  * Changes in common status bits are propagated to attached ports and units.
  */
 void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, u8 id,
 				    void *ref, u32 mask, int set_or_clear)
 {
 	struct zfcp_port *port;
 	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 	if (set_or_clear == ZFCP_SET) {
 		if (status_change_set(mask, &adapter->status))
 			zfcp_rec_dbf_event_adapter(id, ref, adapter);
 		atomic_set_mask(mask, &adapter->status);
 	} else {
 		if (status_change_clear(mask, &adapter->status))
 			zfcp_rec_dbf_event_adapter(id, ref, adapter);
 		atomic_clear_mask(mask, &adapter->status);
 		if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
 			atomic_set(&adapter->erp_counter, 0);
 	}
 	if (common_mask)
 		list_for_each_entry(port, &adapter->port_list_head, list)
 			zfcp_erp_modify_port_status(port, id, ref, common_mask,
 						    set_or_clear);
 }
 /**
  * zfcp_erp_modify_port_status - change port status bits
  * @port: port to change the status bits
  * @id: id for the debug trace
  * @ref: reference for the debug trace
  * @mask: status bits to change
  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
  *
  * Changes in common status bits are propagated to attached units.
  */
 void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, void *ref,
 				 u32 mask, int set_or_clear)
 {
 	struct zfcp_unit *unit;
 	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
 	if (set_or_clear == ZFCP_SET) {
 		if (status_change_set(mask, &port->status))
 			zfcp_rec_dbf_event_port(id, ref, port);
 		atomic_set_mask(mask, &port->status);
 	} else {
 		if (status_change_clear(mask, &port->status))
 			zfcp_rec_dbf_event_port(id, ref, port);
 		atomic_clear_mask(mask, &port->status);
 		if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
 			atomic_set(&port->erp_counter, 0);
 	}
 	if (common_mask)
 		list_for_each_entry(unit, &port->unit_list_head, list)
 			zfcp_erp_modify_unit_status(unit, id, ref, common_mask,
 						    set_or_clear);
 }
 /**
  * zfcp_erp_modify_unit_status - change unit status bits
  * @unit: unit to change the status bits
  * @id: id for the debug trace
  * @ref: reference for the debug trace
  * @mask: status bits to change
  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
  */
 void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, void *ref,
 				 u32 mask, int set_or_clear)
 {
 	if (set_or_clear == ZFCP_SET) {
 		if (status_change_set(mask, &unit->status))
 			zfcp_rec_dbf_event_unit(id, ref, unit);
 		atomic_set_mask(mask, &unit->status);
 	} else {
 		if (status_change_clear(mask, &unit->status))
 			zfcp_rec_dbf_event_unit(id, ref, unit);
 		atomic_clear_mask(mask, &unit->status);
 		if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
 			atomic_set(&unit->erp_counter, 0);
 		}
 	}
 }
 /**
  * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
  * @port: The "boxed" port.
  * @id: The debug trace id.
  * @id: Reference for the debug trace.
  */
 void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref)
 {
 	unsigned long flags;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	zfcp_erp_modify_port_status(port, id, ref,
 				    ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 	zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
 }
 /**
  * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
  * @port: The "boxed" unit.
  * @id: The debug trace id.
  * @id: Reference for the debug trace.
  */
 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref)
 {
 	zfcp_erp_modify_unit_status(unit, id, ref,
 				    ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
 	zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
 }
 /**
  * zfcp_erp_port_access_denied - Adapter denied access to port.
  * @port: port where access has been denied
  * @id: id for debug trace
  * @ref: reference for debug trace
  *
  * Since the adapter has denied access, stop using the port and the
  * attached units.
  */
 void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref)
 {
 	unsigned long flags;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	zfcp_erp_modify_port_status(port, id, ref,
 				    ZFCP_STATUS_COMMON_ERP_FAILED |
 				    ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 /**
  * zfcp_erp_unit_access_denied - Adapter denied access to unit.
  * @unit: unit where access has been denied
  * @id: id for debug trace
  * @ref: reference for debug trace
  *
  * Since the adapter has denied access, stop using the unit.
  */
 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref)
 {
 	zfcp_erp_modify_unit_status(unit, id, ref,
 				    ZFCP_STATUS_COMMON_ERP_FAILED |
 				    ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
 }
 static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id,
 					 void *ref)
 {
 	int status = atomic_read(&unit->status);
 	if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
 			ZFCP_STATUS_COMMON_ACCESS_BOXED)))
 		return;
 	zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
 }
 static void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id,
 					 void *ref)
 {
 	struct zfcp_unit *unit;
 	int status = atomic_read(&port->status);
 	if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
 			ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
 		list_for_each_entry(unit, &port->unit_list_head, list)
 				    zfcp_erp_unit_access_changed(unit, id, ref);
 		return;
 	}
 	zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
 }
 /**
  * zfcp_erp_adapter_access_changed - Process change in adapter ACT
  * @adapter: Adapter where the Access Control Table (ACT) changed
  * @id: Id for debug trace
  * @ref: Reference for debug trace
  */
 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id,
 				     void *ref)
 {
 	struct zfcp_port *port;
 	unsigned long flags;
 	if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
 		return;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	list_for_each_entry(port, &adapter->port_list_head, list)
 		zfcp_erp_port_access_changed(port, id, ref);
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }

drivers/s390/scsi/zfcp_scsi.c

Diff comments View file @ 86f8a1b

 /*
  * zfcp device driver
  *
  * Interface to Linux SCSI midlayer.
  *
  * Copyright IBM Corporation 2002, 2008
  */
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include "zfcp_ext.h"
 #include <asm/atomic.h>
 /* Find start of Sense Information in FCP response unit*/
 char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
 {
 	char *fcp_sns_info_ptr;
 	fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1];
 	if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
 		fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len;
 	return fcp_sns_info_ptr;
 }
 static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
 {
 	struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
-	atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
 	unit->device = NULL;
 	zfcp_erp_unit_failed(unit, 12, NULL);
 	zfcp_unit_put(unit);
 }
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
 {
 	if (sdp->tagged_supported)
 		scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32);
 	else
 		scsi_adjust_queue_depth(sdp, 0, 1);
 	return 0;
 }
 static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
 {
 	set_host_byte(scpnt, result);
 	if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
 		zfcp_scsi_dbf_event_result("fail", 4,
 			(struct zfcp_adapter*) scpnt->device->host->hostdata[0],
 			scpnt, NULL);
 	/* return directly */
 	scpnt->scsi_done(scpnt);
 }
 static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
 				  void (*done) (struct scsi_cmnd *))
 {
 	struct zfcp_unit *unit;
 	struct zfcp_adapter *adapter;
 	int    status;
 	int    ret;
 	/* reset the status for this request */
 	scpnt->result = 0;
 	scpnt->host_scribble = NULL;
 	scpnt->scsi_done = done;
 	/*
 	 * figure out adapter and target device
 	 * (stored there by zfcp_scsi_slave_alloc)
 	 */
 	adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
 	unit = scpnt->device->hostdata;
 	BUG_ON(!adapter || (adapter != unit->port->adapter));
 	BUG_ON(!scpnt->scsi_done);
 	if (unlikely(!unit)) {
 		zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
 		return 0;
 	}
 	status = atomic_read(&unit->status);
 	if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
 		     !(status & ZFCP_STATUS_COMMON_RUNNING))) {
 		zfcp_scsi_command_fail(scpnt, DID_ERROR);
 		return 0;;
 	}
 	ret = zfcp_fsf_send_fcp_command_task(adapter, unit, scpnt, 0,
 					     ZFCP_REQ_AUTO_CLEANUP);
 	if (unlikely(ret == -EBUSY))
 		return SCSI_MLQUEUE_DEVICE_BUSY;
 	else if (unlikely(ret < 0))
 		return SCSI_MLQUEUE_HOST_BUSY;
 	return ret;
 }
 static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter,
 					  int channel, unsigned int id,
 					  unsigned int lun)
 {
 	struct zfcp_port *port;
 	struct zfcp_unit *unit;
 	int scsi_lun;
 	list_for_each_entry(port, &adapter->port_list_head, list) {
 		if (!port->rport || (id != port->rport->scsi_target_id))
 			continue;
 		list_for_each_entry(unit, &port->unit_list_head, list) {
 			scsi_lun = scsilun_to_int(
 				(struct scsi_lun *)&unit->fcp_lun);
 			if (lun == scsi_lun)
 				return unit;
 		}
 	}
 	return NULL;
 }
 static int zfcp_scsi_slave_alloc(struct scsi_device *sdp)
 {
 	struct zfcp_adapter *adapter;
 	struct zfcp_unit *unit;
 	unsigned long flags;
 	int retval = -ENXIO;
 	adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
 	if (!adapter)
 		goto out;
 	read_lock_irqsave(&zfcp_data.config_lock, flags);
 	unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
-	if (unit &&
+	if (unit) {
-	    (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_REGISTERED)) {
 		sdp->hostdata = unit;
 		unit->device = sdp;
 		zfcp_unit_get(unit);
 		retval = 0;
 	}
 	read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 out:
 	return retval;
 }
 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
 {
  	struct Scsi_Host *scsi_host;
  	struct zfcp_adapter *adapter;
 	struct zfcp_unit *unit;
 	struct zfcp_fsf_req *fsf_req;
 	unsigned long flags;
 	unsigned long old_req_id = (unsigned long) scpnt->host_scribble;
 	int retval = SUCCESS;
 	scsi_host = scpnt->device->host;
 	adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
 	unit = scpnt->device->hostdata;
 	/* avoid race condition between late normal completion and abort */
 	write_lock_irqsave(&adapter->abort_lock, flags);
 	/* Check whether corresponding fsf_req is still pending */
 	spin_lock(&adapter->req_list_lock);
 	fsf_req = zfcp_reqlist_find(adapter, old_req_id);
 	spin_unlock(&adapter->req_list_lock);
 	if (!fsf_req) {
 		write_unlock_irqrestore(&adapter->abort_lock, flags);
 		zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL, 0);
 		return retval;
 	}
 	fsf_req->data = NULL;
 	/* don't access old fsf_req after releasing the abort_lock */
 	write_unlock_irqrestore(&adapter->abort_lock, flags);
 	fsf_req = zfcp_fsf_abort_fcp_command(old_req_id, adapter, unit, 0);
 	if (!fsf_req) {
 		zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL,
 					  old_req_id);
 		retval = FAILED;
 		return retval;
 	}
 	__wait_event(fsf_req->completion_wq,
 		     fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
 	if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) {
 		zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, fsf_req, 0);
 	} else if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) {
 		zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, fsf_req, 0);
 	} else {
 		zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, fsf_req, 0);
 		retval = FAILED;
 	}
 	zfcp_fsf_req_free(fsf_req);
 	return retval;
 }
 static int zfcp_task_mgmt_function(struct zfcp_unit *unit, u8 tm_flags,
 					 struct scsi_cmnd *scpnt)
 {
 	struct zfcp_adapter *adapter = unit->port->adapter;
 	struct zfcp_fsf_req *fsf_req;
 	int retval = SUCCESS;
 	/* issue task management function */
 	fsf_req = zfcp_fsf_send_fcp_ctm(adapter, unit, tm_flags, 0);
 	if (!fsf_req) {
 		zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit, scpnt);
 		return FAILED;
 	}
 	__wait_event(fsf_req->completion_wq,
 		     fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
 	/*
 	 * check completion status of task management function
 	 */
 	if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) {
 		zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt);
 		retval = FAILED;
 	} else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) {
 		zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt);
 		retval = FAILED;
 	} else
 		zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt);
 	zfcp_fsf_req_free(fsf_req);
 	return retval;
 }
 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
 {
 	struct zfcp_unit *unit = scpnt->device->hostdata;
 	if (!unit) {
 		WARN_ON(1);
 		return SUCCESS;
 	}
 	return zfcp_task_mgmt_function(unit, FCP_LOGICAL_UNIT_RESET, scpnt);
 }
 static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt)
 {
 	struct zfcp_unit *unit = scpnt->device->hostdata;
 	if (!unit) {
 		WARN_ON(1);
 		return SUCCESS;
 	}
 	return zfcp_task_mgmt_function(unit, FCP_TARGET_RESET, scpnt);
 }
 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
 {
 	struct zfcp_unit *unit;
 	struct zfcp_adapter *adapter;
 	unit = scpnt->device->hostdata;
 	adapter = unit->port->adapter;
 	zfcp_erp_adapter_reopen(adapter, 0, 141, scpnt);
 	zfcp_erp_wait(adapter);
 	return SUCCESS;
 }
 int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
 {
 	struct ccw_dev_id dev_id;
 	if (adapter->scsi_host)
 		return 0;
 	ccw_device_get_id(adapter->ccw_device, &dev_id);
 	/* register adapter as SCSI host with mid layer of SCSI stack */
 	adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
 					     sizeof (struct zfcp_adapter *));
 	if (!adapter->scsi_host) {
 		dev_err(&adapter->ccw_device->dev,
 			"Registering the FCP device with the "
 			"SCSI stack failed\n");
 		return -EIO;
 	}
 	/* tell the SCSI stack some characteristics of this adapter */
 	adapter->scsi_host->max_id = 1;
 	adapter->scsi_host->max_lun = 1;
 	adapter->scsi_host->max_channel = 0;
 	adapter->scsi_host->unique_id = dev_id.devno;
 	adapter->scsi_host->max_cmd_len = 255;
 	adapter->scsi_host->transportt = zfcp_data.scsi_transport_template;
 	adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
 	if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
 		scsi_host_put(adapter->scsi_host);
 		return -EIO;
 	}
 	return 0;
 }
 void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
 {
 	struct Scsi_Host *shost;
 	struct zfcp_port *port;
 	shost = adapter->scsi_host;
 	if (!shost)
 		return;
 	read_lock_irq(&zfcp_data.config_lock);
 	list_for_each_entry(port, &adapter->port_list_head, list)
 		if (port->rport)
 			port->rport = NULL;
 	read_unlock_irq(&zfcp_data.config_lock);
 	fc_remove_host(shost);
 	scsi_remove_host(shost);
 	scsi_host_put(shost);
 	adapter->scsi_host = NULL;
 	return;
 }
 static struct fc_host_statistics*
 zfcp_init_fc_host_stats(struct zfcp_adapter *adapter)
 {
 	struct fc_host_statistics *fc_stats;
 	if (!adapter->fc_stats) {
 		fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL);
 		if (!fc_stats)
 			return NULL;
 		adapter->fc_stats = fc_stats; /* freed in adater_dequeue */
 	}
 	memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats));
 	return adapter->fc_stats;
 }
 static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats,
 				      struct fsf_qtcb_bottom_port *data,
 				      struct fsf_qtcb_bottom_port *old)
 {
 	fc_stats->seconds_since_last_reset =
 		data->seconds_since_last_reset - old->seconds_since_last_reset;
 	fc_stats->tx_frames = data->tx_frames - old->tx_frames;
 	fc_stats->tx_words = data->tx_words - old->tx_words;
 	fc_stats->rx_frames = data->rx_frames - old->rx_frames;
 	fc_stats->rx_words = data->rx_words - old->rx_words;
 	fc_stats->lip_count = data->lip - old->lip;
 	fc_stats->nos_count = data->nos - old->nos;
 	fc_stats->error_frames = data->error_frames - old->error_frames;
 	fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames;
 	fc_stats->link_failure_count = data->link_failure - old->link_failure;
 	fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync;
 	fc_stats->loss_of_signal_count =
 		data->loss_of_signal - old->loss_of_signal;
 	fc_stats->prim_seq_protocol_err_count =
 		data->psp_error_counts - old->psp_error_counts;
 	fc_stats->invalid_tx_word_count =
 		data->invalid_tx_words - old->invalid_tx_words;
 	fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs;
 	fc_stats->fcp_input_requests =
 		data->input_requests - old->input_requests;
 	fc_stats->fcp_output_requests =
 		data->output_requests - old->output_requests;
 	fc_stats->fcp_control_requests =
 		data->control_requests - old->control_requests;
 	fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb;
 	fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb;
 }
 static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats,
 				   struct fsf_qtcb_bottom_port *data)
 {
 	fc_stats->seconds_since_last_reset = data->seconds_since_last_reset;
 	fc_stats->tx_frames = data->tx_frames;
 	fc_stats->tx_words = data->tx_words;
 	fc_stats->rx_frames = data->rx_frames;
 	fc_stats->rx_words = data->rx_words;
 	fc_stats->lip_count = data->lip;
 	fc_stats->nos_count = data->nos;
 	fc_stats->error_frames = data->error_frames;
 	fc_stats->dumped_frames = data->dumped_frames;
 	fc_stats->link_failure_count = data->link_failure;
 	fc_stats->loss_of_sync_count = data->loss_of_sync;
 	fc_stats->loss_of_signal_count = data->loss_of_signal;
 	fc_stats->prim_seq_protocol_err_count = data->psp_error_counts;
 	fc_stats->invalid_tx_word_count = data->invalid_tx_words;
 	fc_stats->invalid_crc_count = data->invalid_crcs;
 	fc_stats->fcp_input_requests = data->input_requests;
 	fc_stats->fcp_output_requests = data->output_requests;
 	fc_stats->fcp_control_requests = data->control_requests;
 	fc_stats->fcp_input_megabytes = data->input_mb;
 	fc_stats->fcp_output_megabytes = data->output_mb;
 }
 static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host)
 {
 	struct zfcp_adapter *adapter;
 	struct fc_host_statistics *fc_stats;
 	struct fsf_qtcb_bottom_port *data;
 	int ret;
 	adapter = (struct zfcp_adapter *)host->hostdata[0];
 	fc_stats = zfcp_init_fc_host_stats(adapter);
 	if (!fc_stats)
 		return NULL;
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return NULL;
 	ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
 	if (ret) {
 		kfree(data);
 		return NULL;
 	}
 	if (adapter->stats_reset &&
 	    ((jiffies/HZ - adapter->stats_reset) <
 	     data->seconds_since_last_reset))
 		zfcp_adjust_fc_host_stats(fc_stats, data,
 					  adapter->stats_reset_data);
 	else
 		zfcp_set_fc_host_stats(fc_stats, data);
 	kfree(data);
 	return fc_stats;
 }
 static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost)
 {
 	struct zfcp_adapter *adapter;
 	struct fsf_qtcb_bottom_port *data;
 	int ret;
 	adapter = (struct zfcp_adapter *)shost->hostdata[0];
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return;
 	ret = zfcp_fsf_exchange_port_data_sync(adapter, data);
 	if (ret)
 		kfree(data);
 	else {
 		adapter->stats_reset = jiffies/HZ;
 		kfree(adapter->stats_reset_data);
 		adapter->stats_reset_data = data; /* finally freed in
 						     adapter_dequeue */
 	}
 }
 static void zfcp_get_host_port_state(struct Scsi_Host *shost)
 {
 	struct zfcp_adapter *adapter =
 		(struct zfcp_adapter *)shost->hostdata[0];
 	int status = atomic_read(&adapter->status);
 	if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
 	    !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED))
 		fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
 	else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)
 		fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
 	else if (status & ZFCP_STATUS_COMMON_ERP_FAILED)
 		fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
 	else
 		fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
 }
 static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout)
 {
 	rport->dev_loss_tmo = timeout;
 }
 struct fc_function_template zfcp_transport_functions = {
 	.show_starget_port_id = 1,
 	.show_starget_port_name = 1,
 	.show_starget_node_name = 1,
 	.show_rport_supported_classes = 1,
 	.show_rport_maxframe_size = 1,
 	.show_rport_dev_loss_tmo = 1,
 	.show_host_node_name = 1,
 	.show_host_port_name = 1,
 	.show_host_permanent_port_name = 1,
 	.show_host_supported_classes = 1,
 	.show_host_supported_speeds = 1,
 	.show_host_maxframe_size = 1,
 	.show_host_serial_number = 1,
 	.get_fc_host_stats = zfcp_get_fc_host_stats,
 	.reset_fc_host_stats = zfcp_reset_fc_host_stats,
 	.set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo,
 	.get_host_port_state = zfcp_get_host_port_state,
 	.show_host_port_state = 1,
 	/* no functions registered for following dynamic attributes but
 	   directly set by LLDD */
 	.show_host_port_type = 1,
 	.show_host_speed = 1,
 	.show_host_port_id = 1,
 	.disable_target_scan = 1,
 };
 struct zfcp_data zfcp_data = {
 	.scsi_host_template = {
 		.name			 = "zfcp",
 		.module			 = THIS_MODULE,
 		.proc_name		 = "zfcp",
 		.slave_alloc		 = zfcp_scsi_slave_alloc,
 		.slave_configure	 = zfcp_scsi_slave_configure,
 		.slave_destroy		 = zfcp_scsi_slave_destroy,
 		.queuecommand		 = zfcp_scsi_queuecommand,
 		.eh_abort_handler	 = zfcp_scsi_eh_abort_handler,
 		.eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler,
 		.eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler,
 		.eh_host_reset_handler	 = zfcp_scsi_eh_host_reset_handler,
 		.can_queue		 = 4096,
 		.this_id		 = -1,
 		.sg_tablesize		 = ZFCP_MAX_SBALES_PER_REQ,
 		.cmd_per_lun		 = 1,
 		.use_clustering		 = 1,
 		.sdev_attrs		 = zfcp_sysfs_sdev_attrs,
 		.max_sectors		 = (ZFCP_MAX_SBALES_PER_REQ * 8),
 		.shost_attrs		 = zfcp_sysfs_shost_attrs,
 	},
 };