return bl;
 }
 
-/*     fd_get_cdb(): (Part of se_subsystem_api_t template)
- *
- *
- */
-static unsigned char *fd_get_cdb(struct se_task *task)
-{
-       struct fd_request *req = FILE_REQ(task);
-
-       return req->fd_scsi_cdb;
-}
-
 /*     fd_get_device_rev(): (Part of se_subsystem_api_t template)
  *
  *
        .check_configfs_dev_params = fd_check_configfs_dev_params,
        .set_configfs_dev_params = fd_set_configfs_dev_params,
        .show_configfs_dev_params = fd_show_configfs_dev_params,
-       .get_cdb                = fd_get_cdb,
        .get_device_rev         = fd_get_device_rev,
        .get_device_type        = fd_get_device_type,
        .get_blocks             = fd_get_blocks,
 
 
 struct fd_request {
        struct se_task  fd_task;
-       /* SCSI CDB from iSCSI Command PDU */
-       unsigned char   fd_scsi_cdb[TCM_MAX_COMMAND_SIZE];
-} ____cacheline_aligned;
+};
 
 #define FBDF_HAS_PATH          0x01
 #define FBDF_HAS_SIZE          0x02
 
        return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
 }
 
-static unsigned char *iblock_get_cdb(struct se_task *task)
-{
-       return IBLOCK_REQ(task)->ib_scsi_cdb;
-}
-
 static u32 iblock_get_device_rev(struct se_device *dev)
 {
        return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
        .check_configfs_dev_params = iblock_check_configfs_dev_params,
        .set_configfs_dev_params = iblock_set_configfs_dev_params,
        .show_configfs_dev_params = iblock_show_configfs_dev_params,
-       .get_cdb                = iblock_get_cdb,
        .get_device_rev         = iblock_get_device_rev,
        .get_device_type        = iblock_get_device_type,
        .get_blocks             = iblock_get_blocks,
 
 
 struct iblock_req {
        struct se_task ib_task;
-       unsigned char ib_scsi_cdb[TCM_MAX_COMMAND_SIZE];
        atomic_t ib_bio_cnt;
        atomic_t ib_bio_err_cnt;
 } ____cacheline_aligned;
 
        return bl;
 }
 
-/*     rd_get_cdb(): (Part of se_subsystem_api_t template)
- *
- *
- */
-static unsigned char *rd_get_cdb(struct se_task *task)
-{
-       struct rd_request *req = RD_REQ(task);
-
-       return req->rd_scsi_cdb;
-}
-
 static u32 rd_get_device_rev(struct se_device *dev)
 {
        return SCSI_SPC_2; /* Returns SPC-3 in Initiator Data */
        .check_configfs_dev_params = rd_check_configfs_dev_params,
        .set_configfs_dev_params = rd_set_configfs_dev_params,
        .show_configfs_dev_params = rd_show_configfs_dev_params,
-       .get_cdb                = rd_get_cdb,
        .get_device_rev         = rd_get_device_rev,
        .get_device_type        = rd_get_device_type,
        .get_blocks             = rd_get_blocks,
 
 struct rd_request {
        struct se_task  rd_task;
 
-       /* SCSI CDB from iSCSI Command PDU */
-       unsigned char   rd_scsi_cdb[TCM_MAX_COMMAND_SIZE];
        /* Offset from start of page */
        u32             rd_offset;
        /* Starting page in Ramdisk for request */
 
        struct scatterlist *sgl,
        unsigned int sgl_nents)
 {
-       unsigned char *cdb = NULL;
        struct se_task *task;
        struct se_device *dev = cmd->se_dev;
        unsigned long flags;
                task->task_sectors = min(sectors, dev_max_sectors);
                task->task_size = task->task_sectors * sector_size;
 
-               cdb = dev->transport->get_cdb(task);
-               BUG_ON(!cdb);
+               if (dev->transport->get_cdb) {
+                       unsigned char *cdb = dev->transport->get_cdb(task);
 
-               memcpy(cdb, cmd->t_task_cdb,
-                      scsi_command_size(cmd->t_task_cdb));
+                       memcpy(cdb, cmd->t_task_cdb,
+                              scsi_command_size(cmd->t_task_cdb));
+
+                       /* Update new cdb with updated lba/sectors */
+                       cmd->transport_split_cdb(task->task_lba,
+                                                task->task_sectors, cdb);
+               }
 
-               /* Update new cdb with updated lba/sectors */
-               cmd->transport_split_cdb(task->task_lba, task->task_sectors, cdb);
                /*
                 * This now assumes that passed sg_ents are in PAGE_SIZE chunks
                 * in order to calculate the number per task SGL entries
 transport_allocate_control_task(struct se_cmd *cmd)
 {
        struct se_device *dev = cmd->se_dev;
-       unsigned char *cdb;
        struct se_task *task;
        unsigned long flags;
 
        if (!task)
                return -ENOMEM;
 
-       cdb = dev->transport->get_cdb(task);
-       BUG_ON(!cdb);
-       memcpy(cdb, cmd->t_task_cdb,
-              scsi_command_size(cmd->t_task_cdb));
+       if (dev->transport->get_cdb) {
+               unsigned char *cdb = dev->transport->get_cdb(task);
+
+               memcpy(cdb, cmd->t_task_cdb, scsi_command_size(cmd->t_task_cdb));
+       }
 
        task->task_sg = kmalloc(sizeof(struct scatterlist) * cmd->t_data_nents,
                                GFP_KERNEL);