[SCSI] zfcp: replace current ERP logging with a more convenient version

The current number based id ERP logging is replaced by a string
based tag version. The benefit is an easier location of the code in
question and the removal of the lengthy array referencing the
individual messages.
The string (7 bytes) based version does not use more space since those
bytes were "used" anyway due to the alignment of the structure.
The encoding of the 7 byte string is as follows
        [0-1] = filename
        [2-5] = task/function
        [6]   = section
Due to the character of this string (fixed length) a string
termination is not required here.

Signed-off-by: Swen Schillig <swen@vnet.ibm.com>
Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>

1 files changed, 68 insertions, 63 deletions

diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 698e42214a3..b4c9ba08509 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -18,8 +18,8 @@
 static void zfcp_fsf_request_timeout_handler(unsigned long data)
 {
         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
-        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62,
-                                NULL);
+        zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
+                                "fsrth_1", NULL);
 }
 
 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req,
@@ -78,7 +78,7 @@ static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
                  (unsigned long long)port->wwpn);
         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
-        zfcp_erp_port_access_denied(port, 55, req);
+        zfcp_erp_port_access_denied(port, "fspad_1", req);
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -92,7 +92,7 @@ static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
                  (unsigned long long)unit->port->wwpn);
         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]);
         zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]);
-        zfcp_erp_unit_access_denied(unit, 59, req);
+        zfcp_erp_unit_access_denied(unit, "fsuad_1", req);
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -100,7 +100,7 @@ static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req)
 {
         dev_err(&req->adapter->ccw_device->dev, "FCP device not "
                 "operational because of an unsupported FC class\n");
-        zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req);
+        zfcp_erp_adapter_shutdown(req->adapter, 0, "fscns_1", req);
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -162,13 +162,13 @@ static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req)
         list_for_each_entry(port, &adapter->port_list_head, list)
                 if (port->d_id == d_id) {
                         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
-                        zfcp_erp_port_reopen(port, 0, 101, req);
+                        zfcp_erp_port_reopen(port, 0, "fssrpc1", req);
                         return;
                 }
         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
 }
 
-static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id,
+static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, char *id,
                                          struct fsf_link_down_info *link_down)
 {
         struct zfcp_adapter *adapter = req->adapter;
@@ -257,13 +257,13 @@ static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req)
 
         switch (sr_buf->status_subtype) {
         case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK:
-                zfcp_fsf_link_down_info_eval(req, 38, ldi);
+                zfcp_fsf_link_down_info_eval(req, "fssrld1", ldi);
                 break;
         case FSF_STATUS_READ_SUB_FDISC_FAILED:
-                zfcp_fsf_link_down_info_eval(req, 39, ldi);
+                zfcp_fsf_link_down_info_eval(req, "fssrld2", ldi);
                 break;
         case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE:
-                zfcp_fsf_link_down_info_eval(req, 40, NULL);
+                zfcp_fsf_link_down_info_eval(req, "fssrld3", NULL);
         };
 }
 
@@ -303,22 +303,23 @@ static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req)
                 dev_info(&adapter->ccw_device->dev,
                          "The local link has been restored\n");
                 /* All ports should be marked as ready to run again */
-                zfcp_erp_modify_adapter_status(adapter, 30, NULL,
+                zfcp_erp_modify_adapter_status(adapter, "fssrh_1", NULL,
                                                ZFCP_STATUS_COMMON_RUNNING,
                                                ZFCP_SET);
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
                                         ZFCP_STATUS_COMMON_ERP_FAILED,
-                                        102, req);
+                                        "fssrh_2", req);
                 break;
         case FSF_STATUS_READ_NOTIFICATION_LOST:
                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED)
-                        zfcp_erp_adapter_access_changed(adapter, 135, req);
+                        zfcp_erp_adapter_access_changed(adapter, "fssrh_3",
+                                                        req);
                 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS)
                         schedule_work(&adapter->scan_work);
                 break;
         case FSF_STATUS_READ_CFDC_UPDATED:
-                zfcp_erp_adapter_access_changed(adapter, 136, req);
+                zfcp_erp_adapter_access_changed(adapter, "fssrh_4", req);
                 break;
         case FSF_STATUS_READ_FEATURE_UPDATE_ALERT:
                 adapter->adapter_features = sr_buf->payload.word[0];
@@ -347,7 +348,7 @@ static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req)
                 dev_err(&req->adapter->ccw_device->dev,
                         "The FCP adapter reported a problem "
                         "that cannot be recovered\n");
-                zfcp_erp_adapter_shutdown(req->adapter, 0, 121, req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfsqe1", req);
                 break;
         }
         /* all non-return stats set FSFREQ_ERROR*/
@@ -364,7 +365,7 @@ static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&req->adapter->ccw_device->dev,
                         "The FCP adapter does not recognize the command 0x%x\n",
                         req->qtcb->header.fsf_command);
-                zfcp_erp_adapter_shutdown(req->adapter, 0, 120, req);
+                zfcp_erp_adapter_shutdown(req->adapter, 0, "fsfse_1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -396,17 +397,17 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                         "QTCB version 0x%x not supported by FCP adapter "
                         "(0x%x to 0x%x)\n", FSF_QTCB_CURRENT_VERSION,
                         psq->word[0], psq->word[1]);
-                zfcp_erp_adapter_shutdown(adapter, 0, 117, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_1", req);
                 break;
         case FSF_PROT_ERROR_STATE:
         case FSF_PROT_SEQ_NUMB_ERROR:
-                zfcp_erp_adapter_reopen(adapter, 0, 98, req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_RETRY;
                 break;
         case FSF_PROT_UNSUPP_QTCB_TYPE:
                 dev_err(&adapter->ccw_device->dev,
                         "The QTCB type is not supported by the FCP adapter\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, 118, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_3", req);
                 break;
         case FSF_PROT_HOST_CONNECTION_INITIALIZING:
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
@@ -416,27 +417,29 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "0x%Lx is an ambiguous request identifier\n",
                         (unsigned long long)qtcb->bottom.support.req_handle);
-                zfcp_erp_adapter_shutdown(adapter, 0, 78, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_4", req);
                 break;
         case FSF_PROT_LINK_DOWN:
-                zfcp_fsf_link_down_info_eval(req, 37, &psq->link_down_info);
+                zfcp_fsf_link_down_info_eval(req, "fspse_5",
+                                             &psq->link_down_info);
                 /* FIXME: reopening adapter now? better wait for link up */
-                zfcp_erp_adapter_reopen(adapter, 0, 79, req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
                 break;
         case FSF_PROT_REEST_QUEUE:
                 /* All ports should be marked as ready to run again */
-                zfcp_erp_modify_adapter_status(adapter, 28, NULL,
+                zfcp_erp_modify_adapter_status(adapter, "fspse_7", NULL,
                                                ZFCP_STATUS_COMMON_RUNNING,
                                                ZFCP_SET);
                 zfcp_erp_adapter_reopen(adapter,
                                         ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
-                                        ZFCP_STATUS_COMMON_ERP_FAILED, 99, req);
+                                        ZFCP_STATUS_COMMON_ERP_FAILED,
+                                        "fspse_8", req);
                 break;
         default:
                 dev_err(&adapter->ccw_device->dev,
                         "0x%x is not a valid transfer protocol status\n",
                         qtcb->prefix.prot_status);
-                zfcp_erp_adapter_shutdown(adapter, 0, 119, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fspse_9", req);
         }
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
@@ -522,7 +525,7 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "Unknown or unsupported arbitrated loop "
                         "fibre channel topology detected\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, 127, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsece_1", req);
                 return -EIO;
         }
 
@@ -556,7 +559,7 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                                 "FCP adapter maximum QTCB size (%d bytes) "
                                 "is too small\n",
                                 bottom->max_qtcb_size);
-                        zfcp_erp_adapter_shutdown(adapter, 0, 129, req);
+                        zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh1", req);
                         return;
                 }
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
@@ -573,11 +576,11 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
                                 &adapter->status);
 
-                zfcp_fsf_link_down_info_eval(req, 42,
+                zfcp_fsf_link_down_info_eval(req, "fsecdh2",
                         &qtcb->header.fsf_status_qual.link_down_info);
                 break;
         default:
-                zfcp_erp_adapter_shutdown(adapter, 0, 130, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh3", req);
                 return;
         }
 
@@ -593,14 +596,14 @@ static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req)
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports newer "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, 125, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh4", req);
                 return;
         }
         if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) {
                 dev_err(&adapter->ccw_device->dev,
                         "The FCP adapter only supports older "
                         "control block versions\n");
-                zfcp_erp_adapter_shutdown(adapter, 0, 126, req);
+                zfcp_erp_adapter_shutdown(adapter, 0, "fsecdh5", req);
         }
 }
 
@@ -634,7 +637,7 @@ static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
                 break;
         case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
                 zfcp_fsf_exchange_port_evaluate(req);
-                zfcp_fsf_link_down_info_eval(req, 43,
+                zfcp_fsf_link_down_info_eval(req, "fsepdh1",
                         &qtcb->header.fsf_status_qual.link_down_info);
                 break;
         }
@@ -779,7 +782,7 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
                 if (zfcp_reqlist_find_safe(adapter, req))
                         zfcp_reqlist_remove(adapter, req);
                 spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-                zfcp_erp_adapter_reopen(adapter, 0, 116, req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
                 return -EIO;
         }
 
@@ -859,14 +862,14 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
-                        zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104,
-                                                req);
+                        zfcp_erp_adapter_reopen(unit->port->adapter, 0,
+                                                "fsafch1", req);
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
                 if (fsq->word[0] == fsq->word[1]) {
-                        zfcp_erp_port_reopen(unit->port, 0, 105, req);
+                        zfcp_erp_port_reopen(unit->port, 0, "fsafch2", req);
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
@@ -874,12 +877,12 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
                 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, 47, req);
+                zfcp_erp_port_boxed(unit->port, "fsafch3", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
         case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, 48, req);
+                zfcp_erp_unit_boxed(unit, "fsafch4", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
@@ -982,7 +985,7 @@ static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req)
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(adapter, 0, 106, req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsscth1", req);
         case FSF_GENERIC_COMMAND_REJECTED:
         case FSF_PAYLOAD_SIZE_MISMATCH:
         case FSF_REQUEST_SIZE_TOO_LARGE:
@@ -1400,7 +1403,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
                          "Not enough FCP adapter resources to open "
                          "remote port 0x%016Lx\n",
                          (unsigned long long)port->wwpn);
-                zfcp_erp_port_failed(port, 31, req);
+                zfcp_erp_port_failed(port, "fsoph_1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
@@ -1506,13 +1509,13 @@ static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req)
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, 107, req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscph_1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 break;
         case FSF_GOOD:
-                zfcp_erp_modify_port_status(port, 33, req,
+                zfcp_erp_modify_port_status(port, "fscph_2", req,
                                             ZFCP_STATUS_COMMON_OPEN,
                                             ZFCP_CLEAR);
                 break;
@@ -1641,7 +1644,7 @@ static void zfcp_fsf_close_wka_port_handler(struct zfcp_fsf_req *req)
 
         if (req->qtcb->header.fsf_status == FSF_PORT_HANDLE_NOT_VALID) {
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                zfcp_erp_adapter_reopen(wka_port->adapter, 0, 84, req);
+                zfcp_erp_adapter_reopen(wka_port->adapter, 0, "fscwph1", req);
         }
 
         wka_port->status = ZFCP_WKA_PORT_OFFLINE;
@@ -1700,14 +1703,14 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
 
         switch (header->fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(port->adapter, 0, 108, req);
+                zfcp_erp_adapter_reopen(port->adapter, 0, "fscpph1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ACCESS_DENIED:
                 zfcp_fsf_access_denied_port(req, port);
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(port, 50, req);
+                zfcp_erp_port_boxed(port, "fscpph2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 /* can't use generic zfcp_erp_modify_port_status because
@@ -1805,7 +1808,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
         switch (header->fsf_status) {
 
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, req);
+                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fsouh_1", req);
                 /* fall through */
         case FSF_LUN_ALREADY_OPEN:
                 break;
@@ -1815,7 +1818,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, 51, req);
+                zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
@@ -1831,7 +1834,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                 else
                         zfcp_act_eval_err(adapter,
                                           header->fsf_status_qual.word[2]);
-                zfcp_erp_unit_access_denied(unit, 60, req);
+                zfcp_erp_unit_access_denied(unit, "fsouh_3", req);
                 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
                 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1842,7 +1845,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                          "0x%016Lx on port 0x%016Lx\n",
                          (unsigned long long)unit->fcp_lun,
                          (unsigned long long)unit->port->wwpn);
-                zfcp_erp_unit_failed(unit, 34, req);
+                zfcp_erp_unit_failed(unit, "fsouh_4", req);
                 /* fall through */
         case FSF_INVALID_COMMAND_OPTION:
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1891,9 +1894,9 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                                         "port 0x%016Lx)\n",
                                         (unsigned long long)unit->fcp_lun,
                                         (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, 35, req);
+                                zfcp_erp_unit_failed(unit, "fsouh_5", req);
                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, 80, req);
+                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_6", req);
                         } else if (!exclusive && readwrite) {
                                 dev_err(&adapter->ccw_device->dev,
                                         "Shared read-write access not "
@@ -1901,9 +1904,9 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                                         "0x%016Lx)\n",
                                         (unsigned long long)unit->fcp_lun,
                                         (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, 36, req);
+                                zfcp_erp_unit_failed(unit, "fsouh_7", req);
                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, 81, req);
+                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_8", req);
                         }
                 }
                 break;
@@ -1968,15 +1971,15 @@ static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, req);
+                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fscuh_1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(unit->port, 0, 111, req);
+                zfcp_erp_port_reopen(unit->port, 0, "fscuh_2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, 52, req);
+                zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
@@ -2215,12 +2218,12 @@ static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
         switch (header->fsf_status) {
         case FSF_HANDLE_MISMATCH:
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112, req);
+                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fssfch1", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_FCPLUN_NOT_VALID:
         case FSF_LUN_HANDLE_NOT_VALID:
-                zfcp_erp_port_reopen(unit->port, 0, 113, req);
+                zfcp_erp_port_reopen(unit->port, 0, "fssfch2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
@@ -2236,7 +2239,8 @@ static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
                         req->qtcb->bottom.io.data_direction,
                         (unsigned long long)unit->fcp_lun,
                         (unsigned long long)unit->port->wwpn);
-                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req);
+                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch3",
+                                          req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_CMND_LENGTH_NOT_VALID:
@@ -2246,16 +2250,17 @@ static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
                         req->qtcb->bottom.io.fcp_cmnd_length,
                         (unsigned long long)unit->fcp_lun,
                         (unsigned long long)unit->port->wwpn);
-                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req);
+                zfcp_erp_adapter_shutdown(unit->port->adapter, 0, "fssfch4",
+                                          req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, 53, req);
+                zfcp_erp_port_boxed(unit->port, "fssfch5", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
         case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, 54, req);
+                zfcp_erp_unit_boxed(unit, "fssfch6", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR |
                                ZFCP_STATUS_FSFREQ_RETRY;
                 break;
@@ -2388,7 +2393,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
                                 "on port 0x%016Lx closed\n",
                                 (unsigned long long)unit->fcp_lun,
                                 (unsigned long long)unit->port->wwpn);
-                        zfcp_erp_unit_shutdown(unit, 0, 131, req);
+                        zfcp_erp_unit_shutdown(unit, 0, "fssfct1", req);
                         retval = -EINVAL;
                 }
                 goto failed_scsi_cmnd;