Commit 2abbe866 authored by Andreas Herrmann's avatar Andreas Herrmann Committed by James Bottomley
Browse files

[SCSI] zfcp: introduce struct timer_list in struct zfcp_fsf_req 



This instance will be used whenever a timer is needed for
a request by zfcp.

Signed-off-by: default avatarAndreas Herrmann <aherrman@de.ibm.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent 4eff4a36

drivers/s390/scsi/zfcp_aux.c

+0 −4
Original line number Diff line number Diff line
@@ -1135,9 +1135,6 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	/* initialize lock of associated request queue */

	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 */

	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_data = (unsigned long) gid_pn;

        gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;

        gid_pn->ct.timer = &erp_action->timer;

	gid_pn->port = erp_action->port;



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

drivers/s390/scsi/zfcp_def.h

+2 −6
Original line number 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



/* 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 ********************/
@@ -779,7 +779,6 @@ typedef void (*zfcp_send_ct_handler_t)(unsigned long); 
 * @handler_data: data passed to handler function

 * @pool: pointer to memory pool for ct request structure

 * @timeout: FSF timeout for this request

 * @timer: timer (e.g. for request initiated by erp)

 * @completion: completion for synchronization purposes

 * @status: used to pass error status to calling function

 */
@@ -793,7 +792,6 @@ struct zfcp_send_ct { 
	unsigned long handler_data;

	mempool_t *pool;

	int timeout;

	struct timer_list *timer;

	struct completion *completion;

	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

 * @handler: handler function (called for response to the request)

 * @handler_data: data passed to handler function

 * @timer: timer (e.g. for request initiated by erp)

 * @completion: completion for synchronization purposes

 * @ls_code: hex code of ELS command

 * @status: used to pass error status to calling function
@@ -836,7 +833,6 @@ struct zfcp_send_els { 
	unsigned int resp_count;

	zfcp_send_els_handler_t handler;

	unsigned long handler_data;

	struct timer_list *timer;

	struct completion *completion;

	int ls_code;

	int status;
@@ -886,7 +882,6 @@ struct zfcp_adapter { 
	struct list_head        port_remove_lh;    /* head of ports to be

						      removed */

	u32			ports;	           /* number of remote ports */

	struct timer_list	scsi_er_timer;     /* SCSI err recovery watch */

	atomic_t		reqs_active;	   /* # active FSF reqs */

	unsigned long		req_no;		   /* unique FSF req number */

	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 */

	u32		       seq_no;         /* Sequence number 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

						  issued on behalf of erp */

	mempool_t	       *pool;	       /* used if request was alloacted

drivers/s390/scsi/zfcp_erp.c

+72 −156
Original line number 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_generic(struct zfcp_erp_action *, int);

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_qdio(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 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

 * @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.

 * zfcp_close_qdio - close qdio queues for an adapter

 */

void

zfcp_fsf_request_timeout_handler(unsigned long data)

static void zfcp_close_qdio(struct zfcp_adapter *adapter)

{

	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

 * action (abort/reset) does not return.  Re-opening the adapter means

 * that the abort/reset command can be returned by zfcp. It won't complete

 * via the adapter anymore (because qdio queues are closed). If ERP is

 * already running on this adapter it will be stopped.

 * Dismiss and cleanup all pending fsf_reqs (this wakes up all initiators of

 * requests waiting for completion; especially this returns SCSI commands

 * with error state).

 */

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;

	unsigned long flags;



	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 */

	/* close queues to ensure that buffers are not accessed by adapter */

	zfcp_close_qdio(adapter);

	zfcp_fsf_req_dismiss_all(adapter);

	/* reset FSF request sequence number */

	adapter->fsf_req_seq_no = 0;

	} else

		write_unlock_irqrestore(&adapter->erp_lock, flags);

	/* all ports and units are closed */

	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);

}



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:	

 *
@@ -282,7 +302,6 @@ zfcp_erp_adisc(struct zfcp_port *port) 
	struct zfcp_ls_adisc *adisc;

	void *address = NULL;

	int retval = 0;

	struct timer_list *timer;



	send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);

	if (send_els == NULL)
@@ -329,22 +348,11 @@ zfcp_erp_adisc(struct zfcp_port *port) 
		      (wwn_t) adisc->wwnn, adisc->hard_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);

	if (retval != 0) {

		ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "

				"0x%08x on adapter %s\n", send_els->d_id,

				zfcp_get_busid_by_adapter(adapter));

		del_timer(send_els->timer);

		goto freemem;

	}
@@ -356,7 +364,6 @@ zfcp_erp_adisc(struct zfcp_port *port) 
	if (address != NULL)

		__free_pages(send_els->req->page, 0);

	if (send_els != NULL) {

		kfree(send_els->timer);

		kfree(send_els->req);

		kfree(send_els->resp);

		kfree(send_els);
@@ -382,9 +389,6 @@ zfcp_erp_adisc_handler(unsigned long data) 
	struct zfcp_ls_adisc_acc *adisc;



	send_els = (struct zfcp_send_els *) data;



	del_timer(send_els->timer);



	adapter = send_els->adapter;

	port = send_els->port;

	d_id = send_els->d_id;
@@ -433,7 +437,6 @@ zfcp_erp_adisc_handler(unsigned long data) 
 out:

	zfcp_port_put(port);

	__free_pages(send_els->req->page, 0);

	kfree(send_els->timer);

	kfree(send_els->req);

	kfree(send_els->resp);

	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_event(adapter->erp_dbf, 2, &erp_action->action,

			    sizeof (int));

		if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT))

			del_timer(&erp_action->timer);

		erp_action->status |= set_mask;

		zfcp_erp_action_ready(erp_action);

	} else {
@@ -957,8 +958,7 @@ zfcp_erp_memwait_handler(unsigned long data) 
 *		action gets an appropriate flag and will be processed

 *		accordingly

 */

static void

zfcp_erp_timeout_handler(unsigned long data)

void zfcp_erp_timeout_handler(unsigned long data)

{

	struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;

	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);



 failed_openfcp:

	zfcp_erp_adapter_strategy_close_qdio(erp_action);

	zfcp_erp_adapter_strategy_close_fsf(erp_action);

	zfcp_close_fsf(erp_action->adapter);

 failed_qdio:

 out:

	return retval;
@@ -2040,59 +2039,6 @@ zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action) 
	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

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);

		zfcp_erp_action_to_running(erp_action);

		write_unlock_irq(&adapter->erp_lock);

		zfcp_erp_timeout_init(erp_action);

		if (zfcp_fsf_exchange_config_data(erp_action)) {

			retval = ZFCP_ERP_FAILED;

			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);

	write_unlock_irq(&adapter->erp_lock);



	zfcp_erp_timeout_init(erp_action);

	ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);

	if (ret == -EOPNOTSUPP) {

		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;

}



/**

 * 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:	

 *
@@ -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_port *port = erp_action->port;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_fsf_close_physical_port(erp_action);

	if (retval == -ENOMEM) {

		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_port *port = erp_action->port;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_fsf_close_port(erp_action);

	if (retval == -ENOMEM) {

		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_port *port = erp_action->port;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_fsf_open_port(erp_action);

	if (retval == -ENOMEM) {

		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_port *port = erp_action->port;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_ns_gid_pn_request(erp_action);

	if (retval == -ENOMEM) {

		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_unit *unit = erp_action->unit;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_fsf_close_unit(erp_action);

	if (retval == -ENOMEM) {

		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_unit *unit = erp_action->unit;



	zfcp_erp_timeout_init(erp_action);

	retval = zfcp_fsf_open_unit(erp_action);

	if (retval == -ENOMEM) {

		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;

}



static inline void

zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action)

void zfcp_erp_start_timer(struct zfcp_fsf_req *fsf_req)

{

	init_timer(&erp_action->timer);

	erp_action->timer.function = zfcp_erp_timeout_handler;

	erp_action->timer.data = (unsigned long) erp_action;

	/* jiffies will be added in zfcp_fsf_req_send */

	erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT;

	BUG_ON(!fsf_req->erp_action);

	fsf_req->timer.function = zfcp_erp_timeout_handler;

	fsf_req->timer.data = (unsigned long) fsf_req->erp_action;

	fsf_req->timer.expires = jiffies + ZFCP_ERP_FSFREQ_TIMEOUT;

	add_timer(&fsf_req->timer);

}



/*

drivers/s390/scsi/zfcp_ext.h

+5 −8
Original line number Diff line number Diff line
@@ -87,8 +87,8 @@ extern int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *, 
					struct fsf_qtcb_bottom_port *);

extern int  zfcp_fsf_control_file(struct zfcp_adapter *, struct zfcp_fsf_req **,

				  u32, u32, struct zfcp_sg_list *);

extern void zfcp_fsf_request_timeout_handler(unsigned long);

extern void zfcp_fsf_scsi_er_timeout_handler(unsigned long);

extern void zfcp_fsf_start_timer(struct zfcp_fsf_req *, unsigned long);

extern void zfcp_erp_start_timer(struct zfcp_fsf_req *);

extern int  zfcp_fsf_req_dismiss_all(struct zfcp_adapter *);

extern int  zfcp_fsf_status_read(struct zfcp_adapter *, int);

extern int zfcp_fsf_req_create(struct zfcp_adapter *, u32, int, mempool_t *,
@@ -98,8 +98,7 @@ extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *, 
extern int zfcp_fsf_send_els(struct zfcp_send_els *);

extern int  zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *,

					   struct zfcp_unit *,

					   struct scsi_cmnd *,

					   struct timer_list*, int);

					   struct scsi_cmnd *, int, int);

extern int  zfcp_fsf_req_complete(struct zfcp_fsf_req *);

extern void zfcp_fsf_incoming_els(struct zfcp_fsf_req *);

extern void zfcp_fsf_req_free(struct zfcp_fsf_req *);
@@ -123,13 +122,11 @@ extern char *zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu *); 
extern void set_host_byte(u32 *, char);

extern void set_driver_byte(u32 *, char);

extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);

extern void zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter *);

extern fcp_dl_t zfcp_get_fcp_dl(struct fcp_cmnd_iu *);



extern int zfcp_scsi_command_async(struct zfcp_adapter *,struct zfcp_unit *,

				   struct scsi_cmnd *, struct timer_list *);

extern int zfcp_scsi_command_sync(struct zfcp_unit *, struct scsi_cmnd *,

				  struct timer_list *);

				   struct scsi_cmnd *, int);

extern int zfcp_scsi_command_sync(struct zfcp_unit *, struct scsi_cmnd *, int);

extern struct fc_function_template zfcp_transport_functions;



/******************************** ERP ****************************************/

drivers/s390/scsi/zfcp_fsf.c

+105 −152

File changed.

Preview size limit exceeded, changes collapsed.