[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: Andreas Herrmann <aherrman@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 72 insertions, 156 deletions

diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 7f60b6fdf724..af42a0eadf03 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -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");
+        /* 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;
+        /* all ports and units are closed */
+        zfcp_erp_modify_adapter_status(adapter,
+                                       ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
+}
 
-        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);
-                adapter->fsf_req_seq_no = 0;
-        } else
-                write_unlock_irqrestore(&adapter->erp_lock, flags);
+/**
+ * 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);
 }
 
 /*