[SCSI] zfcp: introduce struct timer_list in struct zfcp_fsf_req (2abbe866) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/s390/scsi/zfcp_aux.c

+0 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1135,9 +1135,6 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device)
	/* initialize lock of associated request queue */		/* initialize lock of associated request queue */
	rwlock_init(&adapter->request_queue.queue_lock);		rwlock_init(&adapter->request_queue.queue_lock);

	/* intitialise SCSI ER timer */
	init_timer(&adapter->scsi_er_timer);

	/* mark adapter unusable as long as sysfs registration is not complete */		/* mark adapter unusable as long as sysfs registration is not complete */
	atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);		atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);

	@@ -1653,7 +1650,6 @@ zfcp_ns_gid_pn_request(struct zfcp_erp_action *erp_action)
	gid_pn->ct.handler = zfcp_ns_gid_pn_handler;		gid_pn->ct.handler = zfcp_ns_gid_pn_handler;
	gid_pn->ct.handler_data = (unsigned long) gid_pn;		gid_pn->ct.handler_data = (unsigned long) gid_pn;
	gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;		gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;
	gid_pn->ct.timer = &erp_action->timer;
	gid_pn->port = erp_action->port;		gid_pn->port = erp_action->port;

	ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp,		ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp,

drivers/s390/scsi/zfcp_def.h

+2 −6

Original line number	Original line	Diff line number	Diff line
	@@ -137,7 +137,7 @@ zfcp_address_to_sg(void address, struct scatterlist list)
	#define ZFCP_EXCHANGE_CONFIG_DATA_RETRIES 7		#define ZFCP_EXCHANGE_CONFIG_DATA_RETRIES 7

	/* timeout value for "default timer" for fsf requests */		/* timeout value for "default timer" for fsf requests */
	#define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ);		#define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ)

	/************* FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ******************/		/************* FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ******************/

	@@ -779,7 +779,6 @@ typedef void (*zfcp_send_ct_handler_t)(unsigned long);
	* @handler_data: data passed to handler function		* @handler_data: data passed to handler function
	* @pool: pointer to memory pool for ct request structure		* @pool: pointer to memory pool for ct request structure
	* @timeout: FSF timeout for this request		* @timeout: FSF timeout for this request
	* @timer: timer (e.g. for request initiated by erp)
	* @completion: completion for synchronization purposes		* @completion: completion for synchronization purposes
	* @status: used to pass error status to calling function		* @status: used to pass error status to calling function
	*/		*/
	@@ -793,7 +792,6 @@ struct zfcp_send_ct {
	unsigned long handler_data;		unsigned long handler_data;
	mempool_t *pool;		mempool_t *pool;
	int timeout;		int timeout;
	struct timer_list *timer;
	struct completion *completion;		struct completion *completion;
	int status;		int status;
	};		};
	@@ -821,7 +819,6 @@ typedef void (*zfcp_send_els_handler_t)(unsigned long);
	* @resp_count: number of elements in response scatter-gather list		* @resp_count: number of elements in response scatter-gather list
	* @handler: handler function (called for response to the request)		* @handler: handler function (called for response to the request)
	* @handler_data: data passed to handler function		* @handler_data: data passed to handler function
	* @timer: timer (e.g. for request initiated by erp)
	* @completion: completion for synchronization purposes		* @completion: completion for synchronization purposes
	* @ls_code: hex code of ELS command		* @ls_code: hex code of ELS command
	* @status: used to pass error status to calling function		* @status: used to pass error status to calling function
	@@ -836,7 +833,6 @@ struct zfcp_send_els {
	unsigned int resp_count;		unsigned int resp_count;
	zfcp_send_els_handler_t handler;		zfcp_send_els_handler_t handler;
	unsigned long handler_data;		unsigned long handler_data;
	struct timer_list *timer;
	struct completion *completion;		struct completion *completion;
	int ls_code;		int ls_code;
	int status;		int status;
	@@ -886,7 +882,6 @@ struct zfcp_adapter {
	struct list_head port_remove_lh; /* head of ports to be		struct list_head port_remove_lh; /* head of ports to be
	removed */		removed */
	u32 ports; /* number of remote ports */		u32 ports; /* number of remote ports */
	struct timer_list scsi_er_timer; /* SCSI err recovery watch */
	atomic_t reqs_active; /* # active FSF reqs */		atomic_t reqs_active; /* # active FSF reqs */
	unsigned long req_no; /* unique FSF req number */		unsigned long req_no; /* unique FSF req number */
	struct list_head req_list; / list of pending reqs */		struct list_head req_list; / list of pending reqs */
	@@ -1003,6 +998,7 @@ struct zfcp_fsf_req {
	struct fsf_qtcb qtcb; / address of associated QTCB */		struct fsf_qtcb qtcb; / address of associated QTCB */
	u32 seq_no; /* Sequence number of request */		u32 seq_no; /* Sequence number of request */
	unsigned long data; /* private data of request */		unsigned long 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		struct zfcp_erp_action erp_action; / used if this request is
	issued on behalf of erp */		issued on behalf of erp */
	mempool_t pool; / used if request was alloacted		mempool_t pool; / used if request was alloacted

drivers/s390/scsi/zfcp_erp.c

+72 −156

Original line number	Original line	Diff line number	Diff line
	@@ -64,8 +64,6 @@ static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int);
	static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *);		static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *);
	static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int);		static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int);
	static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *);		static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *);
	static void zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *);
	static void zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *);
	static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *);		static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *);
	static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *);		static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *);
	static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *);		static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *);
	@@ -111,64 +109,86 @@ static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
	static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);		static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);

	static void zfcp_erp_memwait_handler(unsigned long);		static void zfcp_erp_memwait_handler(unsigned long);
	static void zfcp_erp_timeout_handler(unsigned long);
	static inline void zfcp_erp_timeout_init(struct zfcp_erp_action *);

	/**		/**
	* zfcp_fsf_request_timeout_handler - called if a request timed out		* zfcp_close_qdio - close qdio queues for an adapter
	* @data: pointer to adapter for handler function
	*
	* This function needs to be called if requests (ELS, Generic Service,
	* or SCSI commands) exceed a certain time limit. The assumption is
	* that after the time limit the adapter get stuck. So we trigger a reopen of
	* the adapter. This should not be used for error recovery, SCSI abort
	* commands and SCSI requests from SCSI mid-layer.
	*/		*/
	void		static void zfcp_close_qdio(struct zfcp_adapter *adapter)
	zfcp_fsf_request_timeout_handler(unsigned long data)
	{		{
	struct zfcp_adapter *adapter;		struct zfcp_qdio_queue *req_queue;
			int first, count;

	adapter = (struct zfcp_adapter *) data;		if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))
			return;

	zfcp_erp_adapter_reopen(adapter, 0);		/* clear QDIOUP flag, thus do_QDIO is not called during qdio_shutdown */
			req_queue = &adapter->request_queue;
			write_lock_irq(&req_queue->queue_lock);
			atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
			write_unlock_irq(&req_queue->queue_lock);

			debug_text_event(adapter->erp_dbf, 3, "qdio_down2a");
			while (qdio_shutdown(adapter->ccw_device,
			QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
			msleep(1000);
			debug_text_event(adapter->erp_dbf, 3, "qdio_down2b");

			/* cleanup used outbound sbals */
			count = atomic_read(&req_queue->free_count);
			if (count < QDIO_MAX_BUFFERS_PER_Q) {
			first = (req_queue->free_index+count) % QDIO_MAX_BUFFERS_PER_Q;
			count = QDIO_MAX_BUFFERS_PER_Q - count;
			zfcp_qdio_zero_sbals(req_queue->buffer, first, count);
			}
			req_queue->free_index = 0;
			atomic_set(&req_queue->free_count, 0);
			req_queue->distance_from_int = 0;
			adapter->response_queue.free_index = 0;
			atomic_set(&adapter->response_queue.free_count, 0);
	}		}

	/**		/**
	* zfcp_fsf_scsi_er_timeout_handler - timeout handler for scsi eh tasks		* zfcp_close_fsf - stop FSF operations for an adapter
	*		*
	* This function needs to be called whenever a SCSI error recovery		* Dismiss and cleanup all pending fsf_reqs (this wakes up all initiators of
	* action (abort/reset) does not return. Re-opening the adapter means		* requests waiting for completion; especially this returns SCSI commands
	* that the abort/reset command can be returned by zfcp. It won't complete		* with error state).
	* via the adapter anymore (because qdio queues are closed). If ERP is
	* already running on this adapter it will be stopped.
	*/		*/
	void zfcp_fsf_scsi_er_timeout_handler(unsigned long data)		static void zfcp_close_fsf(struct zfcp_adapter *adapter)
	{		{
	struct zfcp_adapter adapter = (struct zfcp_adapter ) data;		/* close queues to ensure that buffers are not accessed by adapter */
	unsigned long flags;		zfcp_close_qdio(adapter);

	ZFCP_LOG_NORMAL("warning: SCSI error recovery timed out. "
	"Restarting all operations on the adapter %s\n",
	zfcp_get_busid_by_adapter(adapter));
	debug_text_event(adapter->erp_dbf, 1, "eh_lmem_tout");

	write_lock_irqsave(&adapter->erp_lock, flags);
	if (atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
	&adapter->status)) {
	zfcp_erp_modify_adapter_status(adapter,
	ZFCP_STATUS_COMMON_UNBLOCKED\|ZFCP_STATUS_COMMON_OPEN,
	ZFCP_CLEAR);
	zfcp_erp_action_dismiss_adapter(adapter);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
	/* dismiss all pending requests including requests for ERP */
	zfcp_fsf_req_dismiss_all(adapter);		zfcp_fsf_req_dismiss_all(adapter);
			/* reset FSF request sequence number */
	adapter->fsf_req_seq_no = 0;		adapter->fsf_req_seq_no = 0;
	} else		/* all ports and units are closed */
	write_unlock_irqrestore(&adapter->erp_lock, flags);		zfcp_erp_modify_adapter_status(adapter,
			ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
			}

			/**
			* zfcp_fsf_request_timeout_handler - called if a request timed out
			* @data: pointer to adapter for handler function
			*
			* This function needs to be called if requests (ELS, Generic Service,
			* or SCSI commands) exceed a certain time limit. The assumption is
			* that after the time limit the adapter get stuck. So we trigger a reopen of
			* the adapter.
			*/
			static void zfcp_fsf_request_timeout_handler(unsigned long data)
			{
			struct zfcp_adapter adapter = (struct zfcp_adapter ) data;
	zfcp_erp_adapter_reopen(adapter, 0);		zfcp_erp_adapter_reopen(adapter, 0);
	}		}

			void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, unsigned long timeout)
			{
			fsf_req->timer.function = zfcp_fsf_request_timeout_handler;
			fsf_req->timer.data = (unsigned long) fsf_req->adapter;
			fsf_req->timer.expires = timeout;
			add_timer(&fsf_req->timer);
			}

	/*		/*
	* function:		* function:
	*		*
	@@ -282,7 +302,6 @@ zfcp_erp_adisc(struct zfcp_port *port)
	struct zfcp_ls_adisc *adisc;		struct zfcp_ls_adisc *adisc;
	void *address = NULL;		void *address = NULL;
	int retval = 0;		int retval = 0;
	struct timer_list *timer;

	send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);		send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);
	if (send_els == NULL)		if (send_els == NULL)
	@@ -329,22 +348,11 @@ zfcp_erp_adisc(struct zfcp_port *port)
	(wwn_t) adisc->wwnn, adisc->hard_nport_id,		(wwn_t) adisc->wwnn, adisc->hard_nport_id,
	adisc->nport_id);		adisc->nport_id);

	timer = kmalloc(sizeof(struct timer_list), GFP_ATOMIC);
	if (!timer)
	goto nomem;

	init_timer(timer);
	timer->function = zfcp_fsf_request_timeout_handler;
	timer->data = (unsigned long) adapter;
	timer->expires = ZFCP_FSF_REQUEST_TIMEOUT;
	send_els->timer = timer;

	retval = zfcp_fsf_send_els(send_els);		retval = zfcp_fsf_send_els(send_els);
	if (retval != 0) {		if (retval != 0) {
	ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "		ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
	"0x%08x on adapter %s\n", send_els->d_id,		"0x%08x on adapter %s\n", send_els->d_id,
	zfcp_get_busid_by_adapter(adapter));		zfcp_get_busid_by_adapter(adapter));
	del_timer(send_els->timer);
	goto freemem;		goto freemem;
	}		}

	@@ -356,7 +364,6 @@ zfcp_erp_adisc(struct zfcp_port *port)
	if (address != NULL)		if (address != NULL)
	__free_pages(send_els->req->page, 0);		__free_pages(send_els->req->page, 0);
	if (send_els != NULL) {		if (send_els != NULL) {
	kfree(send_els->timer);
	kfree(send_els->req);		kfree(send_els->req);
	kfree(send_els->resp);		kfree(send_els->resp);
	kfree(send_els);		kfree(send_els);
	@@ -382,9 +389,6 @@ zfcp_erp_adisc_handler(unsigned long data)
	struct zfcp_ls_adisc_acc *adisc;		struct zfcp_ls_adisc_acc *adisc;

	send_els = (struct zfcp_send_els *) data;		send_els = (struct zfcp_send_els *) data;

	del_timer(send_els->timer);

	adapter = send_els->adapter;		adapter = send_els->adapter;
	port = send_els->port;		port = send_els->port;
	d_id = send_els->d_id;		d_id = send_els->d_id;
	@@ -433,7 +437,6 @@ zfcp_erp_adisc_handler(unsigned long data)
	out:		out:
	zfcp_port_put(port);		zfcp_port_put(port);
	__free_pages(send_els->req->page, 0);		__free_pages(send_els->req->page, 0);
	kfree(send_els->timer);
	kfree(send_els->req);		kfree(send_els->req);
	kfree(send_els->resp);		kfree(send_els->resp);
	kfree(send_els);		kfree(send_els);
	@@ -909,8 +912,6 @@ static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
	debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");		debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");
	debug_event(adapter->erp_dbf, 2, &erp_action->action,		debug_event(adapter->erp_dbf, 2, &erp_action->action,
	sizeof (int));		sizeof (int));
	if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT))
	del_timer(&erp_action->timer);
	erp_action->status \|= set_mask;		erp_action->status \|= set_mask;
	zfcp_erp_action_ready(erp_action);		zfcp_erp_action_ready(erp_action);
	} else {		} else {
	@@ -957,8 +958,7 @@ zfcp_erp_memwait_handler(unsigned long data)
	* action gets an appropriate flag and will be processed		* action gets an appropriate flag and will be processed
	* accordingly		* accordingly
	*/		*/
	static void		void zfcp_erp_timeout_handler(unsigned long data)
	zfcp_erp_timeout_handler(unsigned long data)
	{		{
	struct zfcp_erp_action erp_action = (struct zfcp_erp_action ) data;		struct zfcp_erp_action erp_action = (struct zfcp_erp_action ) data;
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	@@ -1934,8 +1934,7 @@ zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
	&erp_action->adapter->status);		&erp_action->adapter->status);

	failed_openfcp:		failed_openfcp:
	zfcp_erp_adapter_strategy_close_qdio(erp_action);		zfcp_close_fsf(erp_action->adapter);
	zfcp_erp_adapter_strategy_close_fsf(erp_action);
	failed_qdio:		failed_qdio:
	out:		out:
	return retval;		return retval;
	@@ -2040,59 +2039,6 @@ zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
	return retval;		return retval;
	}		}

	/**
	* zfcp_erp_adapter_strategy_close_qdio - close qdio queues for an adapter
	*/
	static void
	zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
	{
	int first_used;
	int used_count;
	struct zfcp_adapter *adapter = erp_action->adapter;

	if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
	ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO "
	"queues on adapter %s\n",
	zfcp_get_busid_by_adapter(adapter));
	return;
	}

	/*
	* Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that
	* do_QDIO won't be called while qdio_shutdown is in progress.
	*/
	write_lock_irq(&adapter->request_queue.queue_lock);
	atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
	write_unlock_irq(&adapter->request_queue.queue_lock);

	debug_text_event(adapter->erp_dbf, 3, "qdio_down2a");
	while (qdio_shutdown(adapter->ccw_device,
	QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
	msleep(1000);
	debug_text_event(adapter->erp_dbf, 3, "qdio_down2b");

	/*
	* First we had to stop QDIO operation.
	* Now it is safe to take the following actions.
	*/

	/* Cleanup only necessary when there are unacknowledged buffers */
	if (atomic_read(&adapter->request_queue.free_count)
	< QDIO_MAX_BUFFERS_PER_Q) {
	first_used = (adapter->request_queue.free_index +
	atomic_read(&adapter->request_queue.free_count))
	% QDIO_MAX_BUFFERS_PER_Q;
	used_count = QDIO_MAX_BUFFERS_PER_Q -
	atomic_read(&adapter->request_queue.free_count);
	zfcp_qdio_zero_sbals(adapter->request_queue.buffer,
	first_used, used_count);
	}
	adapter->response_queue.free_index = 0;
	atomic_set(&adapter->response_queue.free_count, 0);
	adapter->request_queue.free_index = 0;
	atomic_set(&adapter->request_queue.free_count, 0);
	adapter->request_queue.distance_from_int = 0;
	}

	static int		static int
	zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)		zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
	@@ -2127,7 +2073,6 @@ zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
	write_lock_irq(&adapter->erp_lock);		write_lock_irq(&adapter->erp_lock);
	zfcp_erp_action_to_running(erp_action);		zfcp_erp_action_to_running(erp_action);
	write_unlock_irq(&adapter->erp_lock);		write_unlock_irq(&adapter->erp_lock);
	zfcp_erp_timeout_init(erp_action);
	if (zfcp_fsf_exchange_config_data(erp_action)) {		if (zfcp_fsf_exchange_config_data(erp_action)) {
	retval = ZFCP_ERP_FAILED;		retval = ZFCP_ERP_FAILED;
	debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");		debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
	@@ -2196,7 +2141,6 @@ zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
	zfcp_erp_action_to_running(erp_action);		zfcp_erp_action_to_running(erp_action);
	write_unlock_irq(&adapter->erp_lock);		write_unlock_irq(&adapter->erp_lock);

	zfcp_erp_timeout_init(erp_action);
	ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);		ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);
	if (ret == -EOPNOTSUPP) {		if (ret == -EOPNOTSUPP) {
	debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");		debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");
	@@ -2248,27 +2192,6 @@ zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
	return retval;		return retval;
	}		}

	/**
	* zfcp_erp_adapter_strategy_close_fsf - stop FSF operations for an adapter
	*/
	static void
	zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action)
	{
	struct zfcp_adapter *adapter = erp_action->adapter;

	/*
	* wake waiting initiators of requests,
	* return SCSI commands (with error status),
	* clean up all requests (synchronously)
	*/
	zfcp_fsf_req_dismiss_all(adapter);
	/* reset FSF request sequence number */
	adapter->fsf_req_seq_no = 0;
	/* all ports and units are closed */
	zfcp_erp_modify_adapter_status(adapter,
	ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
	}

	/*		/*
	* function:		* function:
	*		*
	@@ -2605,7 +2528,6 @@ zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_port *port = erp_action->port;		struct zfcp_port *port = erp_action->port;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_fsf_close_physical_port(erp_action);		retval = zfcp_fsf_close_physical_port(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");		debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
	@@ -2662,7 +2584,6 @@ zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_port *port = erp_action->port;		struct zfcp_port *port = erp_action->port;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_fsf_close_port(erp_action);		retval = zfcp_fsf_close_port(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");		debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
	@@ -2700,7 +2621,6 @@ zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_port *port = erp_action->port;		struct zfcp_port *port = erp_action->port;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_fsf_open_port(erp_action);		retval = zfcp_fsf_open_port(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");		debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
	@@ -2738,7 +2658,6 @@ zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_port *port = erp_action->port;		struct zfcp_port *port = erp_action->port;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_ns_gid_pn_request(erp_action);		retval = zfcp_ns_gid_pn_request(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");		debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
	@@ -2864,7 +2783,6 @@ zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_unit *unit = erp_action->unit;		struct zfcp_unit *unit = erp_action->unit;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_fsf_close_unit(erp_action);		retval = zfcp_fsf_close_unit(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");		debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
	@@ -2905,7 +2823,6 @@ zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
	struct zfcp_adapter *adapter = erp_action->adapter;		struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_unit *unit = erp_action->unit;		struct zfcp_unit *unit = erp_action->unit;

	zfcp_erp_timeout_init(erp_action);
	retval = zfcp_fsf_open_unit(erp_action);		retval = zfcp_fsf_open_unit(erp_action);
	if (retval == -ENOMEM) {		if (retval == -ENOMEM) {
	debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");		debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
	@@ -2930,14 +2847,13 @@ zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
	return retval;		return retval;
	}		}

	static inline void		void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)
	zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action)
	{		{
	init_timer(&erp_action->timer);		BUG_ON(!fsf_req->erp_action);
	erp_action->timer.function = zfcp_erp_timeout_handler;		fsf_req->timer.function = zfcp_erp_timeout_handler;
	erp_action->timer.data = (unsigned long) erp_action;		fsf_req->timer.data = (unsigned long) fsf_req->erp_action;
	/* jiffies will be added in zfcp_fsf_req_send */		fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;
	erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT;		add_timer(&fsf_req->timer);
	}		}

	/*		/*

drivers/s390/scsi/zfcp_ext.h

+5 −8

drivers/s390/scsi/zfcp_fsf.c

+105 −152

File changed.

Preview size limit exceeded, changes collapsed.