[SCSI] zfcp: Use SCSI device data zfcp_scsi_dev instead of zfcp_unit

This is the large change to switch from using the data in
zfcp_unit to zfcp_scsi_dev. Keeping everything working requires doing
the switch in one piece. To ensure that no code keeps using the data
in zfcp_unit, this patch also removes the data from zfcp_unit that is
now being replaced with zfcp_scsi_dev.

For zfcp, the scsi_device together with zfcp_scsi_dev exist from the
call of slave_alloc to the call of slave_destroy. The data in
zfcp_scsi_dev is initialized in zfcp_scsi_slave_alloc and the LUN is
opened; the final shutdown for the LUN is run from slave_destroy.

Where the scsi_device or zfcp_scsi_dev is needed, the pointer to the
scsi_device is passed as function argument and inside the function
converted to the pointer to zfcp_scsi_dev; this avoids back and forth
conversion betweeen scsi_device and zfcp_scsi_dev.

While changing the function arguments from zfcp_unit to scsi_device,
the functions names are renamed form "unit" to "lun". This is to have
a seperation between zfcp_scsi_dev/LUN and the zfcp_unit; only code
referring to the remaining configuration information in zfcp_unit
struct uses "unit".

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

1 files changed, 140 insertions, 139 deletions

diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index 9d1d7d1842ce..2fbd80257bca 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -86,17 +86,19 @@ static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req,
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
-static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req,
-                                        struct zfcp_unit *unit)
+static void zfcp_fsf_access_denied_lun(struct zfcp_fsf_req *req,
+                                       struct scsi_device *sdev)
 {
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+
         struct fsf_qtcb_header *header = &req->qtcb->header;
         dev_warn(&req->adapter->ccw_device->dev,
-                 "Access denied to unit 0x%016Lx on port 0x%016Lx\n",
-                 (unsigned long long)unit->fcp_lun,
-                 (unsigned long long)unit->port->wwpn);
+                 "Access denied to LUN 0x%016Lx on port 0x%016Lx\n",
+                 (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                 (unsigned long long)zfcp_sdev->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, "fsuad_1", req);
+        zfcp_erp_lun_access_denied(sdev, "fsadl_1", req);
         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
 }
 
@@ -811,7 +813,8 @@ out:
 
 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
@@ -820,14 +823,15 @@ 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,
+                        zfcp_erp_adapter_reopen(zfcp_sdev->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, "fsafch2", req);
+                        zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fsafch2",
+                                             req);
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 }
                 break;
@@ -835,17 +839,17 @@ 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, "fsafch3", req);
+                zfcp_erp_port_boxed(zfcp_sdev->port, "fsafch3", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, "fsafch4", req);
+                zfcp_erp_lun_boxed(sdev, "fsafch4", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (fsq->word[0]) {
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -859,17 +863,18 @@ static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req)
 }
 
 /**
- * zfcp_fsf_abort_fcp_command - abort running SCSI command
- * @old_req_id: unsigned long
- * @unit: pointer to struct zfcp_unit
+ * zfcp_fsf_abort_fcp_cmnd - abort running SCSI command
+ * @scmnd: The SCSI command to abort
  * Returns: pointer to struct zfcp_fsf_req
  */
 
-struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
-                                                struct zfcp_unit *unit)
+struct zfcp_fsf_req *zfcp_fsf_abort_fcp_cmnd(struct scsi_cmnd *scmnd)
 {
         struct zfcp_fsf_req *req = NULL;
-        struct zfcp_qdio *qdio = unit->port->adapter->qdio;
+        struct scsi_device *sdev = scmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
+        unsigned long old_req_id = (unsigned long) scmnd->host_scribble;
 
         spin_lock_bh(&qdio->req_q_lock);
         if (zfcp_qdio_sbal_get(qdio))
@@ -882,16 +887,16 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
                 goto out;
         }
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 goto out_error_free;
 
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
-        req->data = unit;
+        req->data = zfcp_sdev;
         req->handler = zfcp_fsf_abort_fcp_command_handler;
-        req->qtcb->header.lun_handle = unit->handle;
-        req->qtcb->header.port_handle = unit->port->handle;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->port->handle;
         req->qtcb->bottom.support.req_handle = (u64) old_req_id;
 
         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
@@ -1666,7 +1671,7 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_port *port = req->data;
         struct fsf_qtcb_header *header = &req->qtcb->header;
-        struct zfcp_unit *unit;
+        struct scsi_device *sdev;
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 return;
@@ -1683,11 +1688,10 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
                 /* can't use generic zfcp_erp_modify_port_status because
                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */
                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
-                read_lock(&port->unit_list_lock);
-                list_for_each_entry(unit, &port->unit_list, list)
-                        atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
-                                          &unit->status);
-                read_unlock(&port->unit_list_lock);
+                shost_for_each_device(sdev, port->adapter->scsi_host)
+                        if (sdev_to_zfcp(sdev)->port == port)
+                                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
+                                                  &sdev_to_zfcp(sdev)->status);
                 zfcp_erp_port_boxed(port, "fscpph2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
@@ -1705,11 +1709,10 @@ static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req)
                  * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
                  */
                 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
-                read_lock(&port->unit_list_lock);
-                list_for_each_entry(unit, &port->unit_list, list)
-                        atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
-                                          &unit->status);
-                read_unlock(&port->unit_list_lock);
+                shost_for_each_device(sdev, port->adapter->scsi_host)
+                        if (sdev_to_zfcp(sdev)->port == port)
+                                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
+                                                  &sdev_to_zfcp(sdev)->status);
                 break;
         }
 }
@@ -1758,10 +1761,11 @@ out:
         return retval;
 }
 
-static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
+static void zfcp_fsf_open_lun_handler(struct zfcp_fsf_req *req)
 {
         struct zfcp_adapter *adapter = req->adapter;
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct fsf_qtcb_header *header = &req->qtcb->header;
         struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support;
         struct fsf_queue_designator *queue_designator =
@@ -1773,24 +1777,24 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
 
         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
                           ZFCP_STATUS_COMMON_ACCESS_BOXED |
-                          ZFCP_STATUS_UNIT_SHARED |
-                          ZFCP_STATUS_UNIT_READONLY,
-                          &unit->status);
+                          ZFCP_STATUS_LUN_SHARED |
+                          ZFCP_STATUS_LUN_READONLY,
+                          &zfcp_sdev->status);
 
         switch (header->fsf_status) {
 
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fsouh_1", req);
+                zfcp_erp_adapter_reopen(adapter, 0, "fsouh_1", req);
                 /* fall through */
         case FSF_LUN_ALREADY_OPEN:
                 break;
         case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_unit(req, unit);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
-                atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
+                zfcp_fsf_access_denied_lun(req, sdev);
+                atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
+                atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fsouh_2", req);
+                zfcp_erp_port_boxed(zfcp_sdev->port, "fsouh_2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_SHARING_VIOLATION:
@@ -1798,25 +1802,25 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                         dev_warn(&adapter->ccw_device->dev,
                                  "LUN 0x%Lx on port 0x%Lx is already in "
                                  "use by CSS%d, MIF Image ID %x\n",
-                                 (unsigned long long)unit->fcp_lun,
-                                 (unsigned long long)unit->port->wwpn,
+                                 (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                                 (unsigned long long)zfcp_sdev->port->wwpn,
                                  queue_designator->cssid,
                                  queue_designator->hla);
                 else
                         zfcp_act_eval_err(adapter,
                                           header->fsf_status_qual.word[2]);
-                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);
+                zfcp_erp_lun_access_denied(sdev, "fsolh_3", req);
+                atomic_clear_mask(ZFCP_STATUS_LUN_SHARED, &zfcp_sdev->status);
+                atomic_clear_mask(ZFCP_STATUS_LUN_READONLY, &zfcp_sdev->status);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
                 dev_warn(&adapter->ccw_device->dev,
                          "No handle is available for LUN "
                          "0x%016Lx on port 0x%016Lx\n",
-                         (unsigned long long)unit->fcp_lun,
-                         (unsigned long long)unit->port->wwpn);
-                zfcp_erp_unit_failed(unit, "fsouh_4", req);
+                         (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                         (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_lun_failed(sdev, "fsolh_4", req);
                 /* fall through */
         case FSF_INVALID_COMMAND_OPTION:
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1824,7 +1828,7 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (header->fsf_status_qual.word[0]) {
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1833,8 +1837,8 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                 break;
 
         case FSF_GOOD:
-                unit->handle = header->lun_handle;
-                atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+                zfcp_sdev->lun_handle = header->lun_handle;
+                atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
 
                 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) &&
                     (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) &&
@@ -1845,39 +1849,39 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
                                         FSF_UNIT_ACCESS_OUTBOUND_TRANSFER);
 
                         if (!exclusive)
-                                atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
-                                                &unit->status);
+                                atomic_set_mask(ZFCP_STATUS_LUN_SHARED,
+                                                &zfcp_sdev->status);
 
                         if (!readwrite) {
-                                atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
-                                                &unit->status);
+                                atomic_set_mask(ZFCP_STATUS_LUN_READONLY,
+                                                &zfcp_sdev->status);
                                 dev_info(&adapter->ccw_device->dev,
                                          "SCSI device at LUN 0x%016Lx on port "
                                          "0x%016Lx opened read-only\n",
-                                         (unsigned long long)unit->fcp_lun,
-                                         (unsigned long long)unit->port->wwpn);
+                                    (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                                    (unsigned long long)zfcp_sdev->port->wwpn);
                         }
 
                         if (exclusive && !readwrite) {
                                 dev_err(&adapter->ccw_device->dev,
                                         "Exclusive read-only access not "
-                                        "supported (unit 0x%016Lx, "
+                                        "supported (LUN 0x%016Lx, "
                                         "port 0x%016Lx)\n",
-                                        (unsigned long long)unit->fcp_lun,
-                                        (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, "fsouh_5", req);
+                                    (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                                    (unsigned long long)zfcp_sdev->port->wwpn);
+                                zfcp_erp_lun_failed(sdev, "fsolh_5", req);
                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_6", req);
+                                zfcp_erp_lun_shutdown(sdev, 0, "fsolh_6", req);
                         } else if (!exclusive && readwrite) {
                                 dev_err(&adapter->ccw_device->dev,
                                         "Shared read-write access not "
-                                        "supported (unit 0x%016Lx, port "
+                                        "supported (LUN 0x%016Lx, port "
                                         "0x%016Lx)\n",
-                                        (unsigned long long)unit->fcp_lun,
-                                        (unsigned long long)unit->port->wwpn);
-                                zfcp_erp_unit_failed(unit, "fsouh_7", req);
+                                    (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                                    (unsigned long long)zfcp_sdev->port->wwpn);
+                                zfcp_erp_lun_failed(sdev, "fsolh_7", req);
                                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
-                                zfcp_erp_unit_shutdown(unit, 0, "fsouh_8", req);
+                                zfcp_erp_lun_shutdown(sdev, 0, "fsolh_8", req);
                         }
                 }
                 break;
@@ -1885,11 +1889,11 @@ static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req)
 }
 
 /**
- * zfcp_fsf_open_unit - open unit
+ * zfcp_fsf_open_lun - open LUN
  * @erp_action: pointer to struct zfcp_erp_action
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
+int zfcp_fsf_open_lun(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_adapter *adapter = erp_action->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
@@ -1913,9 +1917,9 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         req->qtcb->header.port_handle = erp_action->port->handle;
-        req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun;
-        req->handler = zfcp_fsf_open_unit_handler;
-        req->data = erp_action->unit;
+        req->qtcb->bottom.support.fcp_lun = zfcp_scsi_dev_lun(erp_action->sdev);
+        req->handler = zfcp_fsf_open_lun_handler;
+        req->data = erp_action->sdev;
         req->erp_action = erp_action;
         erp_action->fsf_req_id = req->req_id;
 
@@ -1933,30 +1937,32 @@ out:
         return retval;
 }
 
-static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
+static void zfcp_fsf_close_lun_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_unit *unit = req->data;
+        struct scsi_device *sdev = req->data;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
 
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 return;
 
         switch (req->qtcb->header.fsf_status) {
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fscuh_1", req);
+                zfcp_erp_adapter_reopen(zfcp_sdev->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, "fscuh_2", req);
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fscuh_2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fscuh_3", req);
+                zfcp_erp_port_boxed(zfcp_sdev->port, "fscuh_3", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 switch (req->qtcb->header.fsf_status_qual.word[0]) {
                 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                         /* fall through */
                 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
                         req->status |= ZFCP_STATUS_FSFREQ_ERROR;
@@ -1964,19 +1970,20 @@ static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req)
                 }
                 break;
         case FSF_GOOD:
-                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+                atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &zfcp_sdev->status);
                 break;
         }
 }
 
 /**
- * zfcp_fsf_close_unit - close zfcp unit
- * @erp_action: pointer to struct zfcp_unit
+ * zfcp_fsf_close_LUN - close LUN
+ * @erp_action: pointer to erp_action triggering the "close LUN"
  * Returns: 0 on success, error otherwise
  */
-int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
+int zfcp_fsf_close_lun(struct zfcp_erp_action *erp_action)
 {
         struct zfcp_qdio *qdio = erp_action->adapter->qdio;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
         struct zfcp_fsf_req *req;
         int retval = -EIO;
 
@@ -1997,9 +2004,9 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         req->qtcb->header.port_handle = erp_action->port->handle;
-        req->qtcb->header.lun_handle = erp_action->unit->handle;
-        req->handler = zfcp_fsf_close_unit_handler;
-        req->data = erp_action->unit;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->handler = zfcp_fsf_close_lun_handler;
+        req->data = erp_action->sdev;
         req->erp_action = erp_action;
         erp_action->fsf_req_id = req->req_id;
 
@@ -2025,7 +2032,7 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
 {
         struct fsf_qual_latency_info *lat_in;
         struct latency_cont *lat = NULL;
-        struct zfcp_unit *unit = req->unit;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scsi->device);
         struct zfcp_blk_drv_data blktrc;
         int ticks = req->adapter->timer_ticks;
 
@@ -2048,24 +2055,24 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
                 case FSF_DATADIR_DIF_READ_STRIP:
                 case FSF_DATADIR_DIF_READ_CONVERT:
                 case FSF_DATADIR_READ:
-                        lat = &unit->latencies.read;
+                        lat = &zfcp_sdev->latencies.read;
                         break;
                 case FSF_DATADIR_DIF_WRITE_INSERT:
                 case FSF_DATADIR_DIF_WRITE_CONVERT:
                 case FSF_DATADIR_WRITE:
-                        lat = &unit->latencies.write;
+                        lat = &zfcp_sdev->latencies.write;
                         break;
                 case FSF_DATADIR_CMND:
-                        lat = &unit->latencies.cmd;
+                        lat = &zfcp_sdev->latencies.cmd;
                         break;
                 }
 
                 if (lat) {
-                        spin_lock(&unit->latencies.lock);
+                        spin_lock(&zfcp_sdev->latencies.lock);
                         zfcp_fsf_update_lat(&lat->channel, lat_in->channel_lat);
                         zfcp_fsf_update_lat(&lat->fabric, lat_in->fabric_lat);
                         lat->counter++;
-                        spin_unlock(&unit->latencies.lock);
+                        spin_unlock(&zfcp_sdev->latencies.lock);
                 }
         }
 
@@ -2141,68 +2148,66 @@ static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req)
 
 static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req)
 {
-        struct zfcp_unit *unit;
+        struct scsi_cmnd *scmnd = req->data;
+        struct scsi_device *sdev = scmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
         struct fsf_qtcb_header *header = &req->qtcb->header;
 
-        if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
-                unit = req->data;
-        else
-                unit = req->unit;
-
         if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR))
                 goto skip_fsfstatus;
 
         switch (header->fsf_status) {
         case FSF_HANDLE_MISMATCH:
         case FSF_PORT_HANDLE_NOT_VALID:
-                zfcp_erp_adapter_reopen(unit->port->adapter, 0, "fssfch1", req);
+                zfcp_erp_adapter_reopen(zfcp_sdev->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, "fssfch2", req);
+                zfcp_erp_port_reopen(zfcp_sdev->port, 0, "fssfch2", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_SERVICE_CLASS_NOT_SUPPORTED:
                 zfcp_fsf_class_not_supp(req);
                 break;
         case FSF_ACCESS_DENIED:
-                zfcp_fsf_access_denied_unit(req, unit);
+                zfcp_fsf_access_denied_lun(req, sdev);
                 break;
         case FSF_DIRECTION_INDICATOR_NOT_VALID:
                 dev_err(&req->adapter->ccw_device->dev,
-                        "Incorrect direction %d, unit 0x%016Lx on port "
+                        "Incorrect direction %d, LUN 0x%016Lx on port "
                         "0x%016Lx closed\n",
                         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, "fssfch3",
-                                          req);
+                        (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
+                                          "fssfch3", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_CMND_LENGTH_NOT_VALID:
                 dev_err(&req->adapter->ccw_device->dev,
-                        "Incorrect CDB length %d, unit 0x%016Lx on "
+                        "Incorrect CDB length %d, LUN 0x%016Lx on "
                         "port 0x%016Lx closed\n",
                         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, "fssfch4",
-                                          req);
+                        (unsigned long long)zfcp_scsi_dev_lun(sdev),
+                        (unsigned long long)zfcp_sdev->port->wwpn);
+                zfcp_erp_adapter_shutdown(zfcp_sdev->port->adapter, 0,
+                                          "fssfch4", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_PORT_BOXED:
-                zfcp_erp_port_boxed(unit->port, "fssfch5", req);
+                zfcp_erp_port_boxed(zfcp_sdev->port, "fssfch5", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_LUN_BOXED:
-                zfcp_erp_unit_boxed(unit, "fssfch6", req);
+                zfcp_erp_lun_boxed(sdev, "fssfch6", req);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         case FSF_ADAPTER_STATUS_AVAILABLE:
                 if (header->fsf_status_qual.word[0] ==
                     FSF_SQ_INVOKE_LINK_TEST_PROCEDURE)
-                        zfcp_fc_test_link(unit->port);
+                        zfcp_fc_test_link(zfcp_sdev->port);
                 req->status |= ZFCP_STATUS_FSFREQ_ERROR;
                 break;
         }
@@ -2211,8 +2216,6 @@ skip_fsfstatus:
                 zfcp_fsf_send_fcp_ctm_handler(req);
         else {
                 zfcp_fsf_send_fcp_command_task_handler(req);
-                req->unit = NULL;
-                put_device(&unit->dev);
         }
 }
 
@@ -2255,22 +2258,22 @@ static int zfcp_fsf_set_data_dir(struct scsi_cmnd *scsi_cmnd, u32 *data_dir)
 }
 
 /**
- * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
- * @unit: unit where command is sent to
+ * zfcp_fsf_fcp_cmnd - initiate an FCP command (for a SCSI command)
  * @scsi_cmnd: scsi command to be sent
  */
-int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
-                                   struct scsi_cmnd *scsi_cmnd)
+int zfcp_fsf_fcp_cmnd(struct scsi_cmnd *scsi_cmnd)
 {
         struct zfcp_fsf_req *req;
         struct fcp_cmnd *fcp_cmnd;
         unsigned int sbtype = SBAL_FLAGS0_TYPE_READ;
         int real_bytes, retval = -EIO, dix_bytes = 0;
-        struct zfcp_adapter *adapter = unit->port->adapter;
+        struct scsi_device *sdev = scsi_cmnd->device;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
+        struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
         struct fsf_qtcb_bottom_io *io;
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 return -EBUSY;
 
@@ -2295,11 +2298,10 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
 
         io = &req->qtcb->bottom.io;
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        req->unit = unit;
         req->data = scsi_cmnd;
         req->handler = zfcp_fsf_send_fcp_command_handler;
-        req->qtcb->header.lun_handle = unit->handle;
-        req->qtcb->header.port_handle = unit->port->handle;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->port->handle;
         io->service_class = FSF_CLASS_3;
         io->fcp_cmnd_length = FCP_CMND_LEN;
 
@@ -2310,8 +2312,6 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
 
         zfcp_fsf_set_data_dir(scsi_cmnd, &io->data_direction);
 
-        get_device(&unit->dev);
-
         fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
         zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
 
@@ -2338,7 +2338,6 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         goto out;
 
 failed_scsi_cmnd:
-        put_device(&unit->dev);
         zfcp_fsf_req_free(req);
         scsi_cmnd->host_scribble = NULL;
 out:
@@ -2347,18 +2346,20 @@ out:
 }
 
 /**
- * zfcp_fsf_send_fcp_ctm - send SCSI task management command
- * @unit: pointer to struct zfcp_unit
+ * zfcp_fsf_fcp_task_mgmt - send SCSI task management command
+ * @scmnd: SCSI command to send the task management command for
  * @tm_flags: unsigned byte for task management flags
  * Returns: on success pointer to struct fsf_req, NULL otherwise
  */
-struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
+struct zfcp_fsf_req *zfcp_fsf_fcp_task_mgmt(struct scsi_cmnd *scmnd,
+                                            u8 tm_flags)
 {
         struct zfcp_fsf_req *req = NULL;
         struct fcp_cmnd *fcp_cmnd;
-        struct zfcp_qdio *qdio = unit->port->adapter->qdio;
+        struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(scmnd->device);
+        struct zfcp_qdio *qdio = zfcp_sdev->port->adapter->qdio;
 
-        if (unlikely(!(atomic_read(&unit->status) &
+        if (unlikely(!(atomic_read(&zfcp_sdev->status) &
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 return NULL;
 
@@ -2376,10 +2377,10 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
-        req->data = unit;
+        req->data = scmnd;
         req->handler = zfcp_fsf_send_fcp_command_handler;
-        req->qtcb->header.lun_handle = unit->handle;
-        req->qtcb->header.port_handle = unit->port->handle;
+        req->qtcb->header.lun_handle = zfcp_sdev->lun_handle;
+        req->qtcb->header.port_handle = zfcp_sdev->port->handle;
         req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
         req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
@@ -2387,7 +2388,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         zfcp_qdio_set_sbale_last(qdio, &req->qdio_req);
 
         fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
-        zfcp_fc_fcp_tm(fcp_cmnd, unit->device, tm_flags);
+        zfcp_fc_fcp_tm(fcp_cmnd, scmnd->device, tm_flags);
 
         zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT);
         if (!zfcp_fsf_req_send(req))