8 files changed, 339 insertions, 296 deletions

diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 9cd789b8acd4..adc9d8f2c28f 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -112,6 +112,105 @@ _zfcp_hex_dump(char *addr, int count)
                 printk("\n");
 }
 
+
+/****************************************************************/
+/****** Functions to handle the request ID hash table    ********/
+/****************************************************************/
+
+#define ZFCP_LOG_AREA                   ZFCP_LOG_AREA_FSF
+
+static int zfcp_reqlist_init(struct zfcp_adapter *adapter)
+{
+        int i;
+
+        adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
+                                    GFP_KERNEL);
+
+        if (!adapter->req_list)
+                return -ENOMEM;
+
+        for (i=0; i<REQUEST_LIST_SIZE; i++)
+                INIT_LIST_HEAD(&adapter->req_list[i]);
+
+        return 0;
+}
+
+static void zfcp_reqlist_free(struct zfcp_adapter *adapter)
+{
+        struct zfcp_fsf_req *request, *tmp;
+        unsigned int i;
+
+        for (i=0; i<REQUEST_LIST_SIZE; i++) {
+                if (list_empty(&adapter->req_list[i]))
+                        continue;
+
+                list_for_each_entry_safe(request, tmp,
+                                         &adapter->req_list[i], list)
+                        list_del(&request->list);
+        }
+
+        kfree(adapter->req_list);
+}
+
+void zfcp_reqlist_add(struct zfcp_adapter *adapter,
+                      struct zfcp_fsf_req *fsf_req)
+{
+        unsigned int i;
+
+        i = fsf_req->req_id % REQUEST_LIST_SIZE;
+        list_add_tail(&fsf_req->list, &adapter->req_list[i]);
+}
+
+void zfcp_reqlist_remove(struct zfcp_adapter *adapter, unsigned long req_id)
+{
+        struct zfcp_fsf_req *request, *tmp;
+        unsigned int i, counter;
+        u64 dbg_tmp[2];
+
+        i = req_id % REQUEST_LIST_SIZE;
+        BUG_ON(list_empty(&adapter->req_list[i]));
+
+        counter = 0;
+        list_for_each_entry_safe(request, tmp, &adapter->req_list[i], list) {
+                if (request->req_id == req_id) {
+                        dbg_tmp[0] = (u64) atomic_read(&adapter->reqs_active);
+                        dbg_tmp[1] = (u64) counter;
+                        debug_event(adapter->erp_dbf, 4, (void *) dbg_tmp, 16);
+                        list_del(&request->list);
+                        break;
+                }
+                counter++;
+        }
+}
+
+struct zfcp_fsf_req *zfcp_reqlist_ismember(struct zfcp_adapter *adapter,
+                                           unsigned long req_id)
+{
+        struct zfcp_fsf_req *request, *tmp;
+        unsigned int i;
+
+        i = req_id % REQUEST_LIST_SIZE;
+
+        list_for_each_entry_safe(request, tmp, &adapter->req_list[i], list)
+                if (request->req_id == req_id)
+                        return request;
+
+        return NULL;
+}
+
+int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
+{
+        unsigned int i;
+
+        for (i=0; i<REQUEST_LIST_SIZE; i++)
+                if (!list_empty(&adapter->req_list[i]))
+                        return 0;
+
+        return 1;
+}
+
+#undef ZFCP_LOG_AREA
+
 /****************************************************************/
 /************** Uncategorised Functions *************************/
 /****************************************************************/
@@ -961,8 +1060,12 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         INIT_LIST_HEAD(&adapter->port_remove_lh);
 
         /* initialize list of fsf requests */
-        spin_lock_init(&adapter->fsf_req_list_lock);
-        INIT_LIST_HEAD(&adapter->fsf_req_list_head);
+        spin_lock_init(&adapter->req_list_lock);
+        retval = zfcp_reqlist_init(adapter);
+        if (retval) {
+                ZFCP_LOG_INFO("request list initialization failed\n");
+                goto failed_low_mem_buffers;
+        }
 
         /* initialize debug locks */
 
@@ -1041,8 +1144,6 @@ zfcp_adapter_enqueue(struct ccw_device *ccw_device)
  *              !0 - struct zfcp_adapter  data structure could not be removed
  *                      (e.g. still used)
  * locks:       adapter list write lock is assumed to be held by caller
- *              adapter->fsf_req_list_lock is taken and released within this 
- *              function and must not be held on entry
  */
 void
 zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
@@ -1054,14 +1155,14 @@ zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
         zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
         dev_set_drvdata(&adapter->ccw_device->dev, NULL);
         /* sanity check: no pending FSF requests */
-        spin_lock_irqsave(&adapter->fsf_req_list_lock, flags);
-        retval = !list_empty(&adapter->fsf_req_list_head);
-        spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
-        if (retval) {
+        spin_lock_irqsave(&adapter->req_list_lock, flags);
+        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->fsf_reqs_active));
+                                atomic_read(&adapter->reqs_active));
                 retval = -EBUSY;
                 goto out;
         }
@@ -1087,6 +1188,7 @@ zfcp_adapter_dequeue(struct zfcp_adapter *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);
         ZFCP_LOG_TRACE("freeing adapter structure\n");
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index 57d8e4bfb8d9..fdabadeaa9ee 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -164,6 +164,11 @@ zfcp_ccw_set_online(struct ccw_device *ccw_device)
         retval = zfcp_adapter_scsi_register(adapter);
         if (retval)
                 goto out_scsi_register;
+
+        /* initialize request counter */
+        BUG_ON(!zfcp_reqlist_isempty(adapter));
+        adapter->req_no = 0;
+
         zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
                                        ZFCP_SET);
         zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index 2df512a18e2c..94d1b74db356 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -52,7 +52,7 @@
 /********************* GENERAL DEFINES *********************************/
 
 /* zfcp version number, it consists of major, minor, and patch-level number */
-#define ZFCP_VERSION            "4.7.0"
+#define ZFCP_VERSION            "4.8.0"
 
 /**
  * zfcp_sg_to_address - determine kernel address from struct scatterlist
@@ -80,7 +80,7 @@ zfcp_address_to_sg(void *address, struct scatterlist *list)
 #define REQUEST_LIST_SIZE 128
 
 /********************* SCSI SPECIFIC DEFINES *********************************/
-#define ZFCP_SCSI_ER_TIMEOUT                    (100*HZ)
+#define ZFCP_SCSI_ER_TIMEOUT                    (10*HZ)
 
 /********************* CIO/QDIO SPECIFIC DEFINES *****************************/
 
@@ -886,11 +886,11 @@ 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 */
-        struct list_head        fsf_req_list_head; /* head of FSF req list */
-        spinlock_t              fsf_req_list_lock; /* lock for ops on list of
-                                                      FSF requests */
-        atomic_t                fsf_reqs_active;   /* # active FSF reqs */
+        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 */
+        spinlock_t              req_list_lock;     /* request list lock */
         struct zfcp_qdio_queue  request_queue;     /* request queue */
         u32                     fsf_req_seq_no;    /* FSF cmnd seq number */
         wait_queue_head_t       request_wq;        /* can be used to wait for
@@ -986,6 +986,7 @@ struct zfcp_unit {
 /* 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 */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index 8ec8da0beaa8..7f60b6fdf724 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -64,8 +64,8 @@ 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 int zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *);
-static int zfcp_erp_adapter_strategy_close_fsf(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 *);
@@ -93,10 +93,9 @@ static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *);
 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *);
 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *);
 
-static int zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *);
-static int zfcp_erp_action_dismiss_port(struct zfcp_port *);
-static int zfcp_erp_action_dismiss_unit(struct zfcp_unit *);
-static int zfcp_erp_action_dismiss(struct zfcp_erp_action *);
+static void zfcp_erp_action_dismiss_port(struct zfcp_port *);
+static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *);
+static void zfcp_erp_action_dismiss(struct zfcp_erp_action *);
 
 static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *,
                                    struct zfcp_port *, struct zfcp_unit *);
@@ -135,29 +134,39 @@ zfcp_fsf_request_timeout_handler(unsigned long data)
         zfcp_erp_adapter_reopen(adapter, 0);
 }
 
-/*
- * function:    zfcp_fsf_scsi_er_timeout_handler
- *
- * purpose:     This function needs to be called whenever a SCSI error recovery
- *              action (abort/reset) does not return.
- *              Re-opening the adapter means that the command can be returned
- *              by zfcp (it is guarranteed that it does not return via the
- *              adapter anymore). The buffer can then be used again.
- *    
- * returns:     sod all
+/**
+ * zfcp_fsf_scsi_er_timeout_handler - timeout handler for scsi eh tasks
+ *
+ * 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.
  */
-void
-zfcp_fsf_scsi_er_timeout_handler(unsigned long data)
+void zfcp_fsf_scsi_er_timeout_handler(unsigned long data)
 {
         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");
-        zfcp_erp_adapter_reopen(adapter, 0);
 
-        return;
+        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_erp_adapter_reopen(adapter, 0);
 }
 
 /*
@@ -670,17 +679,10 @@ zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask)
         return retval;
 }
 
-/*
- * function:    
- *
- * purpose:     disable I/O,
- *              return any open requests and clean them up,
- *              aim: no pending and incoming I/O
- *
- * returns:
+/**
+ * zfcp_erp_adapter_block - mark adapter as blocked, block scsi requests
  */
-static void
-zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
+static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
 {
         debug_text_event(adapter->erp_dbf, 6, "a_bl");
         zfcp_erp_modify_adapter_status(adapter,
@@ -688,15 +690,10 @@ zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
                                        clear_mask, ZFCP_CLEAR);
 }
 
-/*
- * function:    
- *
- * purpose:     enable I/O
- *
- * returns:
+/**
+ * zfcp_erp_adapter_unblock - mark adapter as unblocked, allow scsi requests
  */
-static void
-zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
+static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
 {
         debug_text_event(adapter->erp_dbf, 6, "a_ubl");
         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
@@ -848,18 +845,16 @@ zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
         struct zfcp_adapter *adapter = erp_action->adapter;
 
         if (erp_action->fsf_req) {
-                /* take lock to ensure that request is not being deleted meanwhile */
-                spin_lock(&adapter->fsf_req_list_lock);
-                /* check whether fsf req does still exist */
-                list_for_each_entry(fsf_req, &adapter->fsf_req_list_head, list)
-                    if (fsf_req == erp_action->fsf_req)
-                        break;
-                if (fsf_req && (fsf_req->erp_action == erp_action)) {
+                /* take lock to ensure that request is not deleted meanwhile */
+                spin_lock(&adapter->req_list_lock);
+                if ((!zfcp_reqlist_ismember(adapter,
+                                            erp_action->fsf_req->req_id)) &&
+                    (fsf_req->erp_action == erp_action)) {
                         /* fsf_req still exists */
                         debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
                         debug_event(adapter->erp_dbf, 3, &fsf_req,
                                     sizeof (unsigned long));
-                        /* dismiss fsf_req of timed out or dismissed erp_action */
+                        /* dismiss fsf_req of timed out/dismissed erp_action */
                         if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED |
                                                   ZFCP_STATUS_ERP_TIMEDOUT)) {
                                 debug_text_event(adapter->erp_dbf, 3,
@@ -892,30 +887,22 @@ zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
                          */
                         erp_action->fsf_req = NULL;
                 }
-                spin_unlock(&adapter->fsf_req_list_lock);
+                spin_unlock(&adapter->req_list_lock);
         } else
                 debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq");
 
         return retval;
 }
 
-/*
- * purpose:     generic handler for asynchronous events related to erp_action events
- *              (normal completion, time-out, dismissing, retry after
- *              low memory condition)
- *
- * note:        deletion of timer is not required (e.g. in case of a time-out),
- *              but a second try does no harm,
- *              we leave it in here to allow for greater simplification
+/**
+ * zfcp_erp_async_handler_nolock - complete erp_action
  *
- * returns:     0 - there was an action to handle
- *              !0 - otherwise
+ * Used for normal completion, time-out, dismissal and failure after
+ * low memory condition.
  */
-static int
-zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
-                              unsigned long set_mask)
+static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
+                                          unsigned long set_mask)
 {
-        int retval;
         struct zfcp_adapter *adapter = erp_action->adapter;
 
         if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
@@ -926,43 +913,26 @@ zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
                         del_timer(&erp_action->timer);
                 erp_action->status |= set_mask;
                 zfcp_erp_action_ready(erp_action);
-                retval = 0;
         } else {
                 /* action is ready or gone - nothing to do */
                 debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone");
                 debug_event(adapter->erp_dbf, 3, &erp_action->action,
                             sizeof (int));
-                retval = 1;
         }
-
-        return retval;
 }
 
-/*
- * purpose:     generic handler for asynchronous events related to erp_action
- *               events (normal completion, time-out, dismissing, retry after
- *              low memory condition)
- *
- * note:        deletion of timer is not required (e.g. in case of a time-out),
- *              but a second try does no harm,
- *              we leave it in here to allow for greater simplification
- *
- * returns:     0 - there was an action to handle
- *              !0 - otherwise
+/**
+ * zfcp_erp_async_handler - wrapper for erp_async_handler_nolock w/ locking
  */
-int
-zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
-                       unsigned long set_mask)
+void zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
+                            unsigned long set_mask)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
         unsigned long flags;
-        int retval;
 
         write_lock_irqsave(&adapter->erp_lock, flags);
-        retval = zfcp_erp_async_handler_nolock(erp_action, set_mask);
+        zfcp_erp_async_handler_nolock(erp_action, set_mask);
         write_unlock_irqrestore(&adapter->erp_lock, flags);
-
-        return retval;
 }
 
 /*
@@ -999,17 +969,15 @@ zfcp_erp_timeout_handler(unsigned long data)
         zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT);
 }
 
-/*
- * purpose:     is called for an erp_action which needs to be ended
- *              though not being done,
- *              this is usually required if an higher is generated,
- *              action gets an appropriate flag and will be processed
- *              accordingly
+/**
+ * zfcp_erp_action_dismiss - dismiss an erp_action
  *
- * locks:       erp_lock held (thus we need to call another handler variant)
+ * adapter->erp_lock must be held
+ * 
+ * Dismissal of an erp_action is usually required if an erp_action of
+ * higher priority is generated.
  */
-static int
-zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
+static void zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
 
@@ -1017,8 +985,6 @@ zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
         debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
 
         zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED);
-
-        return 0;
 }
 
 int
@@ -2074,18 +2040,12 @@ zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
         return retval;
 }
 
-/*
- * function:    zfcp_qdio_cleanup
- *
- * purpose:     cleans up QDIO operation for the specified adapter
- *
- * returns:     0 - successful cleanup
- *              !0 - failed cleanup
+/**
+ * zfcp_erp_adapter_strategy_close_qdio - close qdio queues for an adapter
  */
-int
+static void
 zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
 {
-        int retval = ZFCP_ERP_SUCCEEDED;
         int first_used;
         int used_count;
         struct zfcp_adapter *adapter = erp_action->adapter;
@@ -2094,15 +2054,13 @@ zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
                 ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO "
                                "queues on adapter %s\n",
                                zfcp_get_busid_by_adapter(adapter));
-                retval = ZFCP_ERP_FAILED;
-                goto out;
+                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);
@@ -2134,8 +2092,6 @@ zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
         adapter->request_queue.free_index = 0;
         atomic_set(&adapter->request_queue.free_count, 0);
         adapter->request_queue.distance_from_int = 0;
- out:
-        return retval;
 }
 
 static int
@@ -2258,11 +2214,11 @@ zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
                               "%s)\n", zfcp_get_busid_by_adapter(adapter));
                 ret = ZFCP_ERP_FAILED;
         }
-        if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status)) {
-                ZFCP_LOG_INFO("error: exchange port data failed (adapter "
+
+        /* don't treat as error for the sake of compatibility */
+        if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status))
+                ZFCP_LOG_INFO("warning: exchange port data failed (adapter "
                               "%s\n", zfcp_get_busid_by_adapter(adapter));
-                ret = ZFCP_ERP_FAILED;
-        }
 
         return ret;
 }
@@ -2292,18 +2248,12 @@ zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
         return retval;
 }
 
-/*
- * function:    zfcp_fsf_cleanup
- *
- * purpose:     cleanup FSF operation for specified adapter
- *
- * returns:     0 - FSF operation successfully cleaned up
- *              !0 - failed to cleanup FSF operation for this adapter
+/**
+ * zfcp_erp_adapter_strategy_close_fsf - stop FSF operations for an adapter
  */
-static int
+static void
 zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action)
 {
-        int retval = ZFCP_ERP_SUCCEEDED;
         struct zfcp_adapter *adapter = erp_action->adapter;
 
         /*
@@ -2317,8 +2267,6 @@ zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action)
         /* all ports and units are closed */
         zfcp_erp_modify_adapter_status(adapter,
                                        ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
-
-        return retval;
 }
 
 /*
@@ -3293,10 +3241,8 @@ zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
 }
 
 
-static int
-zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
+void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
 {
-        int retval = 0;
         struct zfcp_port *port;
 
         debug_text_event(adapter->erp_dbf, 5, "a_actab");
@@ -3305,14 +3251,10 @@ zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
         else
                 list_for_each_entry(port, &adapter->port_list_head, list)
                     zfcp_erp_action_dismiss_port(port);
-
-        return retval;
 }
 
-static int
-zfcp_erp_action_dismiss_port(struct zfcp_port *port)
+static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
 {
-        int retval = 0;
         struct zfcp_unit *unit;
         struct zfcp_adapter *adapter = port->adapter;
 
@@ -3323,22 +3265,16 @@ zfcp_erp_action_dismiss_port(struct zfcp_port *port)
         else
                 list_for_each_entry(unit, &port->unit_list_head, list)
                     zfcp_erp_action_dismiss_unit(unit);
-
-        return retval;
 }
 
-static int
-zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
+static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
 {
-        int retval = 0;
         struct zfcp_adapter *adapter = unit->port->adapter;
 
         debug_text_event(adapter->erp_dbf, 5, "u_actab");
         debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
         if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
                 zfcp_erp_action_dismiss(&unit->erp_action);
-
-        return retval;
 }
 
 static inline void
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index d02366004cdd..146d7a2b4c4a 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -63,7 +63,6 @@ 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 int  zfcp_qdio_reqid_check(struct zfcp_adapter *, void *);
 
 extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_req
         (struct zfcp_fsf_req *, int, int);
@@ -140,6 +139,7 @@ extern void zfcp_erp_modify_adapter_status(struct zfcp_adapter *, u32, int);
 extern int  zfcp_erp_adapter_reopen(struct zfcp_adapter *, int);
 extern int  zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int);
 extern void zfcp_erp_adapter_failed(struct zfcp_adapter *);
+extern void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *);
 
 extern void zfcp_erp_modify_port_status(struct zfcp_port *, u32, int);
 extern int  zfcp_erp_port_reopen(struct zfcp_port *, int);
@@ -156,7 +156,7 @@ extern void zfcp_erp_unit_failed(struct zfcp_unit *);
 extern int  zfcp_erp_thread_setup(struct zfcp_adapter *);
 extern int  zfcp_erp_thread_kill(struct zfcp_adapter *);
 extern int  zfcp_erp_wait(struct zfcp_adapter *);
-extern int  zfcp_erp_async_handler(struct zfcp_erp_action *, unsigned long);
+extern void zfcp_erp_async_handler(struct zfcp_erp_action *, unsigned long);
 
 extern int  zfcp_test_link(struct zfcp_port *);
 
@@ -190,5 +190,10 @@ extern void zfcp_scsi_dbf_event_abort(const char *, struct zfcp_adapter *,
                                       struct zfcp_fsf_req *);
 extern void zfcp_scsi_dbf_event_devreset(const char *, u8, struct zfcp_unit *,
                                          struct scsi_cmnd *);
+extern void zfcp_reqlist_add(struct zfcp_adapter *, struct zfcp_fsf_req *);
+extern void zfcp_reqlist_remove(struct zfcp_adapter *, unsigned long);
+extern struct zfcp_fsf_req *zfcp_reqlist_ismember(struct zfcp_adapter *,
+                                                  unsigned long);
+extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
 
 #endif  /* ZFCP_EXT_H */
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 31db2b06faba..ff2eacf5ec8c 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -49,7 +49,6 @@ static int zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *);
 static void zfcp_fsf_link_down_info_eval(struct zfcp_adapter *,
         struct fsf_link_down_info *);
 static int zfcp_fsf_req_dispatch(struct zfcp_fsf_req *);
-static void zfcp_fsf_req_dismiss(struct zfcp_fsf_req *);
 
 /* association between FSF command and FSF QTCB type */
 static u32 fsf_qtcb_type[] = {
@@ -146,47 +145,48 @@ zfcp_fsf_req_free(struct zfcp_fsf_req *fsf_req)
                 kfree(fsf_req);
 }
 
-/*
- * function:    
- *
- * purpose:     
- *
- * returns:
- *
- * note: qdio queues shall be down (no ongoing inbound processing)
+/**
+ * zfcp_fsf_req_dismiss - dismiss a single fsf request
  */
-int
-zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
+static void zfcp_fsf_req_dismiss(struct zfcp_adapter *adapter,
+                                 struct zfcp_fsf_req *fsf_req,
+                                 unsigned int counter)
 {
-        struct zfcp_fsf_req *fsf_req, *tmp;
-        unsigned long flags;
-        LIST_HEAD(remove_queue);
+        u64 dbg_tmp[2];
 
-        spin_lock_irqsave(&adapter->fsf_req_list_lock, flags);
-        list_splice_init(&adapter->fsf_req_list_head, &remove_queue);
-        atomic_set(&adapter->fsf_reqs_active, 0);
-        spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
-
-        list_for_each_entry_safe(fsf_req, tmp, &remove_queue, list) {
-                list_del(&fsf_req->list);
-                zfcp_fsf_req_dismiss(fsf_req);
-        }
-
-        return 0;
+        dbg_tmp[0] = (u64) atomic_read(&adapter->reqs_active);
+        dbg_tmp[1] = (u64) counter;
+        debug_event(adapter->erp_dbf, 4, (void *) dbg_tmp, 16);
+        list_del(&fsf_req->list);
+        fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+        zfcp_fsf_req_complete(fsf_req);
 }
 
-/*
- * function:    
- *
- * purpose:     
- *
- * returns:
+/**
+ * zfcp_fsf_req_dismiss_all - dismiss all remaining fsf requests
  */
-static void
-zfcp_fsf_req_dismiss(struct zfcp_fsf_req *fsf_req)
+int zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 {
-        fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
-        zfcp_fsf_req_complete(fsf_req);
+        struct zfcp_fsf_req *request, *tmp;
+        unsigned long flags;
+        unsigned int i, counter;
+
+        spin_lock_irqsave(&adapter->req_list_lock, flags);
+        atomic_set(&adapter->reqs_active, 0);
+        for (i=0; i<REQUEST_LIST_SIZE; i++) {
+                if (list_empty(&adapter->req_list[i]))
+                        continue;
+
+                counter = 0;
+                list_for_each_entry_safe(request, tmp,
+                                         &adapter->req_list[i], list) {
+                        zfcp_fsf_req_dismiss(adapter, request, counter);
+                        counter++;
+                }
+        }
+        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+
+        return 0;
 }
 
 /*
@@ -4592,12 +4592,14 @@ static inline void
 zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req *fsf_req)
 {
         if (likely(fsf_req->qtcb != NULL)) {
-                fsf_req->qtcb->prefix.req_seq_no = fsf_req->adapter->fsf_req_seq_no;
-                fsf_req->qtcb->prefix.req_id = (unsigned long)fsf_req;
+                fsf_req->qtcb->prefix.req_seq_no =
+                        fsf_req->adapter->fsf_req_seq_no;
+                fsf_req->qtcb->prefix.req_id = fsf_req->req_id;
                 fsf_req->qtcb->prefix.ulp_info = ZFCP_ULP_INFO_VERSION;
-                fsf_req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_req->fsf_command];
+                fsf_req->qtcb->prefix.qtcb_type =
+                        fsf_qtcb_type[fsf_req->fsf_command];
                 fsf_req->qtcb->prefix.qtcb_version = ZFCP_QTCB_VERSION;
-                fsf_req->qtcb->header.req_handle = (unsigned long)fsf_req;
+                fsf_req->qtcb->header.req_handle = fsf_req->req_id;
                 fsf_req->qtcb->header.fsf_command = fsf_req->fsf_command;
         }
 }
@@ -4654,6 +4656,7 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags,
 {
         volatile struct qdio_buffer_element *sbale;
         struct zfcp_fsf_req *fsf_req = NULL;
+        unsigned long flags;
         int ret = 0;
         struct zfcp_qdio_queue *req_queue = &adapter->request_queue;
 
@@ -4668,6 +4671,12 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags,
 
         fsf_req->adapter = adapter;
         fsf_req->fsf_command = fsf_cmd;
+        INIT_LIST_HEAD(&fsf_req->list);
+        
+        /* unique request id */
+        spin_lock_irqsave(&adapter->req_list_lock, flags);
+        fsf_req->req_id = adapter->req_no++;
+        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
 
         zfcp_fsf_req_qtcb_init(fsf_req);
 
@@ -4707,7 +4716,7 @@ zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags,
         sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
 
         /* setup common SBALE fields */
-        sbale[0].addr = fsf_req;
+        sbale[0].addr = (void *) fsf_req->req_id;
         sbale[0].flags |= SBAL_FLAGS0_COMMAND;
         if (likely(fsf_req->qtcb != NULL)) {
                 sbale[1].addr = (void *) fsf_req->qtcb;
@@ -4747,7 +4756,7 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
         volatile struct qdio_buffer_element *sbale;
         int inc_seq_no;
         int new_distance_from_int;
-        unsigned long flags;
+        u64 dbg_tmp[2];
         int retval = 0;
 
         adapter = fsf_req->adapter;
@@ -4761,10 +4770,10 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
         ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) sbale[1].addr,
                       sbale[1].length);
 
-        /* put allocated FSF request at list tail */
-        spin_lock_irqsave(&adapter->fsf_req_list_lock, flags);
-        list_add_tail(&fsf_req->list, &adapter->fsf_req_list_head);
-        spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
+        /* put allocated FSF request into hash table */
+        spin_lock(&adapter->req_list_lock);
+        zfcp_reqlist_add(adapter, fsf_req);
+        spin_unlock(&adapter->req_list_lock);
 
         inc_seq_no = (fsf_req->qtcb != NULL);
 
@@ -4803,6 +4812,10 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
                          QDIO_FLAG_SYNC_OUTPUT,
                          0, fsf_req->sbal_first, fsf_req->sbal_number, NULL);
 
+        dbg_tmp[0] = (unsigned long) sbale[0].addr;
+        dbg_tmp[1] = (u64) retval;
+        debug_event(adapter->erp_dbf, 4, (void *) dbg_tmp, 16);
+
         if (unlikely(retval)) {
                 /* Queues are down..... */
                 retval = -EIO;
@@ -4812,22 +4825,17 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
                  */
                 if (timer)
                         del_timer(timer);
-                spin_lock_irqsave(&adapter->fsf_req_list_lock, flags);
-                list_del(&fsf_req->list);
-                spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
-                /*
-                 * adjust the number of free SBALs in request queue as well as
-                 * position of first one
-                 */
+                spin_lock(&adapter->req_list_lock);
+                zfcp_reqlist_remove(adapter, fsf_req->req_id);
+                spin_unlock(&adapter->req_list_lock);
+                /* undo changes in request queue made for this request */
                 zfcp_qdio_zero_sbals(req_queue->buffer,
                                      fsf_req->sbal_first, fsf_req->sbal_number);
                 atomic_add(fsf_req->sbal_number, &req_queue->free_count);
-                req_queue->free_index -= fsf_req->sbal_number;   /* increase */
+                req_queue->free_index -= fsf_req->sbal_number;
                 req_queue->free_index += QDIO_MAX_BUFFERS_PER_Q;
                 req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
-                ZFCP_LOG_DEBUG
-                        ("error: do_QDIO failed. Buffers could not be enqueued "
-                         "to request queue.\n");
+                zfcp_erp_adapter_reopen(adapter, 0);
         } else {
                 req_queue->distance_from_int = new_distance_from_int;
                 /*
@@ -4843,7 +4851,7 @@ zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
                         adapter->fsf_req_seq_no++;
 
                 /* count FSF requests pending */
-                atomic_inc(&adapter->fsf_reqs_active);
+                atomic_inc(&adapter->reqs_active);
         }
         return retval;
 }
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index 49ea5add4abc..dbd9f48e863e 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -282,6 +282,37 @@ zfcp_qdio_request_handler(struct ccw_device *ccw_device,
         return;
 }
 
+/**
+ * zfcp_qdio_reqid_check - checks for valid reqids or unsolicited status
+ */
+static int zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, 
+                                 unsigned long req_id)
+{
+        struct zfcp_fsf_req *fsf_req;
+        unsigned long flags;
+
+        debug_long_event(adapter->erp_dbf, 4, req_id);
+
+        spin_lock_irqsave(&adapter->req_list_lock, flags);
+        fsf_req = zfcp_reqlist_ismember(adapter, req_id);
+
+        if (!fsf_req) {
+                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+                ZFCP_LOG_NORMAL("error: unknown request id (%ld).\n", req_id);
+                zfcp_erp_adapter_reopen(adapter, 0);
+                return -EINVAL;
+        }
+
+        zfcp_reqlist_remove(adapter, req_id);
+        atomic_dec(&adapter->reqs_active);
+        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+
+        /* finish the FSF request */
+        zfcp_fsf_req_complete(fsf_req);
+
+        return 0;
+}
+
 /*
  * function:    zfcp_qdio_response_handler
  *
@@ -344,7 +375,7 @@ zfcp_qdio_response_handler(struct ccw_device *ccw_device,
                         /* look for QDIO request identifiers in SB */
                         buffere = &buffer->element[buffere_index];
                         retval = zfcp_qdio_reqid_check(adapter,
-                                                       (void *) buffere->addr);
+                                        (unsigned long) buffere->addr);
 
                         if (retval) {
                                 ZFCP_LOG_NORMAL("bug: unexpected inbound "
@@ -415,52 +446,6 @@ zfcp_qdio_response_handler(struct ccw_device *ccw_device,
         return;
 }
 
-/*
- * function:    zfcp_qdio_reqid_check
- *
- * purpose:     checks for valid reqids or unsolicited status
- *
- * returns:     0 - valid request id or unsolicited status
- *              !0 - otherwise
- */
-int
-zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, void *sbale_addr)
-{
-        struct zfcp_fsf_req *fsf_req;
-        unsigned long flags;
-
-        /* invalid (per convention used in this driver) */
-        if (unlikely(!sbale_addr)) {
-                ZFCP_LOG_NORMAL("bug: invalid reqid\n");
-                return -EINVAL;
-        }
-
-        /* valid request id and thus (hopefully :) valid fsf_req address */
-        fsf_req = (struct zfcp_fsf_req *) sbale_addr;
-
-        /* serialize with zfcp_fsf_req_dismiss_all */
-        spin_lock_irqsave(&adapter->fsf_req_list_lock, flags);
-        if (list_empty(&adapter->fsf_req_list_head)) {
-                spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
-                return 0;
-        }
-        list_del(&fsf_req->list);
-        atomic_dec(&adapter->fsf_reqs_active);
-        spin_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
-
-        if (unlikely(adapter != fsf_req->adapter)) {
-                ZFCP_LOG_NORMAL("bug: invalid reqid (fsf_req=%p, "
-                                "fsf_req->adapter=%p, adapter=%p)\n",
-                                fsf_req, fsf_req->adapter, adapter);
-                return -EINVAL;
-        }
-
-        /* finish the FSF request */
-        zfcp_fsf_req_complete(fsf_req);
-
-        return 0;
-}
-
 /**
  * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue
  * @queue: queue from which SBALE should be returned
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 671f4a6a5d18..1bb55086db9f 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -30,7 +30,6 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *,
                                   void (*done) (struct scsi_cmnd *));
 static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *);
 static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *);
-static int zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *);
 static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *);
 static int zfcp_task_management_function(struct zfcp_unit *, u8,
                                          struct scsi_cmnd *);
@@ -46,30 +45,22 @@ struct zfcp_data zfcp_data = {
         .scsi_host_template = {
                 .name                   = ZFCP_NAME,
                 .proc_name              = "zfcp",
-                .proc_info              = NULL,
-                .detect                 = NULL,
                 .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_bus_reset_handler   = zfcp_scsi_eh_bus_reset_handler,
+                .eh_bus_reset_handler   = zfcp_scsi_eh_host_reset_handler,
                 .eh_host_reset_handler  = zfcp_scsi_eh_host_reset_handler,
                 .can_queue              = 4096,
                 .this_id                = -1,
-                /*
-                 * FIXME:
-                 * one less? can zfcp_create_sbale cope with it?
-                 */
                 .sg_tablesize           = ZFCP_MAX_SBALES_PER_REQ,
                 .cmd_per_lun            = 1,
-                .unchecked_isa_dma      = 0,
                 .use_clustering         = 1,
                 .sdev_attrs             = zfcp_sysfs_sdev_attrs,
         },
         .driver_version = ZFCP_VERSION,
-        /* rest initialised with zeros */
 };
 
 /* Find start of Response Information in FCP response unit*/
@@ -176,8 +167,14 @@ zfcp_scsi_slave_alloc(struct scsi_device *sdp)
         return retval;
 }
 
-static void
-zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
+/**
+ * zfcp_scsi_slave_destroy - called when scsi device is removed
+ *
+ * Remove reference to associated scsi device for an zfcp_unit.
+ * Mark zfcp_unit as failed. The scsi device might be deleted via sysfs
+ * or a scan for this device might have failed.
+ */
+static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
 {
         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
 
@@ -185,6 +182,7 @@ zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
                 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status);
                 sdpnt->hostdata = NULL;
                 unit->device = NULL;
+                zfcp_erp_unit_failed(unit);
                 zfcp_unit_put(unit);
         } else {
                 ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
@@ -549,35 +547,38 @@ zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags,
 }
 
 /**
- * zfcp_scsi_eh_bus_reset_handler - reset bus (reopen adapter)
+ * zfcp_scsi_eh_host_reset_handler - handler for host and bus reset
+ *
+ * If ERP is already running it will be stopped.
  */
-int
-zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *scpnt)
+int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
 {
-        struct zfcp_unit *unit = (struct zfcp_unit*) scpnt->device->hostdata;
-        struct zfcp_adapter *adapter = unit->port->adapter;
-
-        ZFCP_LOG_NORMAL("bus reset because of problems with "
-                        "unit 0x%016Lx\n", unit->fcp_lun);
-        zfcp_erp_adapter_reopen(adapter, 0);
-        zfcp_erp_wait(adapter);
-
-        return SUCCESS;
-}
+        struct zfcp_unit *unit;
+        struct zfcp_adapter *adapter;
+        unsigned long flags;
 
-/**
- * zfcp_scsi_eh_host_reset_handler - reset host (reopen adapter)
- */
-int
-zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
-{
-        struct zfcp_unit *unit = (struct zfcp_unit*) scpnt->device->hostdata;
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        unit = (struct zfcp_unit*) scpnt->device->hostdata;
+        adapter = unit->port->adapter;
 
-        ZFCP_LOG_NORMAL("host reset because of problems with "
+        ZFCP_LOG_NORMAL("host/bus reset because of problems with "
                         "unit 0x%016Lx\n", unit->fcp_lun);
-        zfcp_erp_adapter_reopen(adapter, 0);
-        zfcp_erp_wait(adapter);
+
+        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);
+                zfcp_fsf_req_dismiss_all(adapter);
+                adapter->fsf_req_seq_no = 0;
+                zfcp_erp_adapter_reopen(adapter, 0);
+        } else {
+                write_unlock_irqrestore(&adapter->erp_lock, flags);
+                zfcp_erp_adapter_reopen(adapter, 0);
+                zfcp_erp_wait(adapter);
+        }
 
         return SUCCESS;
 }