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

Commit 00bab910 authored by Swen Schillig's avatar Swen Schillig Committed by James Bottomley
Browse files

[SCSI] zfcp: Cleanup qdio code 



Cleanup the interface code from zfcp to qdio. Also move code that
belongs to the qdio interface from the erp to the qdio file.

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

drivers/s390/scsi/zfcp_aux.c

+7 −38
Original line number Diff line number Diff line
@@ -606,7 +606,6 @@ static void _zfcp_status_read_scheduler(struct work_struct *work) 
struct zfcp_adapter *

zfcp_adapter_enqueue(struct ccw_device *ccw_device)

{

	int retval = 0;

	struct zfcp_adapter *adapter;



	/*
@@ -627,19 +626,11 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	/* save ccw_device pointer */

	adapter->ccw_device = ccw_device;



	retval = zfcp_qdio_allocate_queues(adapter);

	if (retval)

		goto queues_alloc_failed;



	retval = zfcp_qdio_allocate(adapter);

	if (retval)

	if (zfcp_qdio_allocate(adapter))

		goto qdio_allocate_failed;



	retval = zfcp_allocate_low_mem_buffers(adapter);

	if (retval) {

		ZFCP_LOG_INFO("error: pool allocation failed\n");

	if (zfcp_allocate_low_mem_buffers(adapter))

		goto failed_low_mem_buffers;

	}



	/* initialise reference count stuff */

	atomic_set(&adapter->refcount, 0);
@@ -653,11 +644,8 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 


	/* initialize list of fsf requests */

	spin_lock_init(&adapter->req_list_lock);

	retval = zfcp_reqlist_alloc(adapter);

	if (retval) {

		ZFCP_LOG_INFO("request list initialization failed\n");

	if (zfcp_reqlist_alloc(adapter))

		goto failed_low_mem_buffers;

	}



	/* initialize debug locks */
@@ -666,8 +654,7 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	spin_lock_init(&adapter->scsi_dbf_lock);

	spin_lock_init(&adapter->rec_dbf_lock);



	retval = zfcp_adapter_debug_register(adapter);

	if (retval)

	if (zfcp_adapter_debug_register(adapter))

		goto debug_register_failed;



	/* initialize error recovery stuff */
@@ -685,7 +672,7 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	init_waitqueue_head(&adapter->erp_done_wqh);



	/* initialize lock of associated request queue */

	rwlock_init(&adapter->request_queue.queue_lock);

	rwlock_init(&adapter->req_q.lock);

	INIT_WORK(&adapter->stat_work, _zfcp_status_read_scheduler);



	/* mark adapter unusable as long as sysfs registration is not complete */
@@ -723,12 +710,8 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	zfcp_reqlist_free(adapter);

 failed_low_mem_buffers:

	zfcp_free_low_mem_buffers(adapter);

	if (qdio_free(ccw_device) != 0)

		ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n",

				zfcp_get_busid_by_adapter(adapter));

 qdio_allocate_failed:

	zfcp_qdio_free_queues(adapter);

 queues_alloc_failed:

	zfcp_qdio_free(adapter);

	kfree(adapter);

	adapter = NULL;

 out:
@@ -757,10 +740,6 @@ zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 
	retval = zfcp_reqlist_isempty(adapter);

	spin_unlock_irqrestore(&adapter->req_list_lock, flags);

	if (!retval) {

		ZFCP_LOG_NORMAL("bug: adapter %s (%p) still in use, "

				"%i requests outstanding\n",

				zfcp_get_busid_by_adapter(adapter), adapter,

				atomic_read(&adapter->reqs_active));

		retval = -EBUSY;

		goto out;

	}
@@ -775,19 +754,9 @@ zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 
	/* decrease number of adapters in list */

	zfcp_data.adapters--;



	ZFCP_LOG_TRACE("adapter %s (%p) removed from list, "

		       "%i adapters still in list\n",

		       zfcp_get_busid_by_adapter(adapter),

		       adapter, zfcp_data.adapters);



	retval = qdio_free(adapter->ccw_device);

	if (retval)

		ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n",

				zfcp_get_busid_by_adapter(adapter));

	zfcp_qdio_free(adapter);



	zfcp_free_low_mem_buffers(adapter);

	/* free memory of adapter data structure and queues */

	zfcp_qdio_free_queues(adapter);

	zfcp_reqlist_free(adapter);

	kfree(adapter->fc_stats);

	kfree(adapter->stats_reset_data);

drivers/s390/scsi/zfcp_dbf.c

+2 −1
Original line number Diff line number Diff line
@@ -603,13 +603,14 @@ static const char *zfcp_rec_dbf_ids[] = { 
	[137]	= "hbaapi port open",

	[138]	= "hbaapi unit open",

	[139]	= "hbaapi unit shutdown",

	[140]	= "qdio error",

	[140]	= "qdio error outbound",

	[141]	= "scsi host reset",

	[142]	= "dismissing fsf request for recovery action",

	[143]	= "recovery action timed out",

	[144]	= "recovery action gone",

	[145]	= "recovery action being processed",

	[146]	= "recovery action ready for next step",

	[147]	= "qdio error inbound",

};



static int zfcp_rec_dbf_view_format(debug_info_t *id, struct debug_view *view,

drivers/s390/scsi/zfcp_def.h

+7 −19
Original line number Diff line number Diff line
@@ -112,21 +112,10 @@ zfcp_address_to_sg(void *address, struct scatterlist *list, unsigned int size) 
        /* max. number of (data buffer) SBALEs in largest SBAL chain

           multiplied with number of sectors per 4k block */



/* FIXME(tune): free space should be one max. SBAL chain plus what? */

#define ZFCP_QDIO_PCI_INTERVAL		(QDIO_MAX_BUFFERS_PER_Q \

                                         - (ZFCP_MAX_SBALS_PER_REQ + 4))



#define ZFCP_SBAL_TIMEOUT               (5*HZ)



#define ZFCP_TYPE2_RECOVERY_TIME        8	/* seconds */



/* queue polling (values in microseconds) */

#define ZFCP_MAX_INPUT_THRESHOLD 	5000	/* FIXME: tune */

#define ZFCP_MAX_OUTPUT_THRESHOLD 	1000	/* FIXME: tune */

#define ZFCP_MIN_INPUT_THRESHOLD 	1	/* ignored by QDIO layer */

#define ZFCP_MIN_OUTPUT_THRESHOLD 	1	/* ignored by QDIO layer */



#define QDIO_SCSI_QFMT			1	/* 1 for FSF */

#define QBUFF_PER_PAGE			(PAGE_SIZE / sizeof(struct qdio_buffer))



/********************* FSF SPECIFIC DEFINES *********************************/
@@ -649,13 +638,13 @@ struct zfcp_send_els { 
};



struct zfcp_qdio_queue {

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

	u8		   free_index;	      /* index of next free bfr

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

	u8		   first;	      /* index of next free bfr

						 in queue (free_count>0) */

	atomic_t           free_count;	      /* number of free buffers

	atomic_t           count;	      /* number of free buffers

						 in queue */

	rwlock_t	   queue_lock;	      /* lock for operations on queue */

        int                distance_from_int; /* SBALs used since PCI indication

	rwlock_t	   lock;	      /* lock for operations on queue */

	int                pci_batch;	      /* SBALs since PCI indication

						 was last set */

};
@@ -711,15 +700,14 @@ struct zfcp_adapter { 
	struct list_head        port_remove_lh;    /* head of ports to be

						      removed */

	u32			ports;	           /* number of remote ports */

	atomic_t		reqs_active;	   /* # active FSF reqs */

	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	request_queue;	   /* request queue */

	struct zfcp_qdio_queue	req_q;		   /* request queue */

	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	response_queue;	   /* response queue */

	struct zfcp_qdio_queue	resp_q;	   /* response queue */

	rwlock_t		abort_lock;        /* Protects against SCSI

						      stack abort/command

						      completion races */

drivers/s390/scsi/zfcp_erp.c

+4 −110
Original line number Diff line number Diff line
@@ -113,41 +113,6 @@ static void zfcp_erp_action_to_running(struct zfcp_erp_action *); 


static void zfcp_erp_memwait_handler(unsigned long);



/**

 * zfcp_close_qdio - close qdio queues for an adapter

 */

static void zfcp_close_qdio(struct zfcp_adapter *adapter)

{

	struct zfcp_qdio_queue *req_queue;

	int first, count;



	if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status))

		return;



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



	while (qdio_shutdown(adapter->ccw_device,

			     QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)

		ssleep(1);



	/* 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_close_fsf - stop FSF operations for an adapter

 *
@@ -158,7 +123,7 @@ static void zfcp_close_qdio(struct zfcp_adapter *adapter) 
static void zfcp_close_fsf(struct zfcp_adapter *adapter)

{

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

	zfcp_close_qdio(adapter);

	zfcp_qdio_close(adapter);

	zfcp_fsf_req_dismiss_all(adapter);

	/* reset FSF request sequence number */

	adapter->fsf_req_seq_no = 0;
@@ -1735,88 +1700,17 @@ zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close) 
static int

zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)

{

	int retval;

	int i;

	volatile struct qdio_buffer_element *sbale;

	struct zfcp_adapter *adapter = erp_action->adapter;



	if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {

		ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "

				"adapter %s\n",

				zfcp_get_busid_by_adapter(adapter));

		goto failed_sanity;

	}



	if (qdio_establish(&adapter->qdio_init_data) != 0) {

		ZFCP_LOG_INFO("error: establishment of QDIO queues failed "

			      "on adapter %s\n",

			      zfcp_get_busid_by_adapter(adapter));

		goto failed_qdio_establish;

	}



	if (qdio_activate(adapter->ccw_device, 0) != 0) {

		ZFCP_LOG_INFO("error: activation of QDIO queues failed "

			      "on adapter %s\n",

			      zfcp_get_busid_by_adapter(adapter));

		goto failed_qdio_activate;

	}



	/*

	 * put buffers into response queue,

	 */

	for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {

		sbale = &(adapter->response_queue.buffer[i]->element[0]);

		sbale->length = 0;

		sbale->flags = SBAL_FLAGS_LAST_ENTRY;

		sbale->addr = NULL;

	}



	ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "

		       "queue_no=%i, index_in_queue=%i, count=%i)\n",

		       zfcp_get_busid_by_adapter(adapter),

		       QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);



	retval = do_QDIO(adapter->ccw_device,

			 QDIO_FLAG_SYNC_INPUT,

			 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);



	if (retval) {

		ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",

				retval);

		goto failed_do_qdio;

	} else {

		adapter->response_queue.free_index = 0;

		atomic_set(&adapter->response_queue.free_count, 0);

		ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "

			       "response queue\n", QDIO_MAX_BUFFERS_PER_Q);

	}

	/* set index of first avalable SBALS / number of available SBALS */

	adapter->request_queue.free_index = 0;

	atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);

	adapter->request_queue.distance_from_int = 0;

	if (zfcp_qdio_open(adapter))

		return ZFCP_ERP_FAILED;



	/* initialize waitqueue used to wait for free SBALs in requests queue */

	init_waitqueue_head(&adapter->request_wq);



	/* ok, we did it - skip all cleanups for different failures */

	atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);

	retval = ZFCP_ERP_SUCCEEDED;

	goto out;



 failed_do_qdio:

	/* NOP */



 failed_qdio_activate:

	while (qdio_shutdown(adapter->ccw_device,

			     QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)

		ssleep(1);



 failed_qdio_establish:

 failed_sanity:

	retval = ZFCP_ERP_FAILED;



 out:

	return retval;

	return ZFCP_ERP_SUCCEEDED;

}

drivers/s390/scsi/zfcp_ext.h

+7 −11
Original line number Diff line number Diff line
@@ -57,21 +57,17 @@ extern int zfcp_ccw_register(void); 


extern void zfcp_qdio_zero_sbals(struct qdio_buffer **, int, int);

extern int  zfcp_qdio_allocate(struct zfcp_adapter *);

extern int  zfcp_qdio_allocate_queues(struct zfcp_adapter *);

extern void zfcp_qdio_free_queues(struct zfcp_adapter *);

extern int  zfcp_qdio_determine_pci(struct zfcp_qdio_queue *,

				    struct zfcp_fsf_req *);

extern void zfcp_qdio_free(struct zfcp_adapter *);

extern int  zfcp_qdio_send(struct zfcp_fsf_req *fsf_req);



extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_req

	(struct zfcp_fsf_req *, int, int);

	(struct zfcp_fsf_req *);

extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_curr

	(struct zfcp_fsf_req *);

extern int zfcp_qdio_sbals_from_sg

	(struct zfcp_fsf_req *, unsigned long, struct scatterlist *, int, int);

extern int zfcp_qdio_sbals_from_scsicmnd

	(struct zfcp_fsf_req *, unsigned long, struct scsi_cmnd *);





	(struct zfcp_fsf_req *, unsigned long, struct scatterlist *, int);

extern int zfcp_qdio_open(struct zfcp_adapter *adapter);

extern void zfcp_qdio_close(struct zfcp_adapter *adapter);

/******************************** FSF ****************************************/

extern int  zfcp_fsf_open_port(struct zfcp_erp_action *);

extern int  zfcp_fsf_close_port(struct zfcp_erp_action *);
@@ -95,7 +91,7 @@ extern int zfcp_fsf_status_read(struct zfcp_adapter *, int); 
extern int zfcp_status_read_refill(struct zfcp_adapter *adapter);

extern int zfcp_fsf_req_create(struct zfcp_adapter *, u32, int, mempool_t *,

			       unsigned long *, struct zfcp_fsf_req **)

	__acquires(adapter->request_queue.queue_lock);

	__acquires(adapter->req_q.lock);

extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *,

			    struct zfcp_erp_action *);

extern int zfcp_fsf_send_els(struct zfcp_send_els *);