Patched in Tegra support.

1 files changed, 163 insertions, 76 deletions

diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index b406f178ff3..80fbcde00cb 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -19,6 +19,8 @@
 
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
 #include <linux/utsname.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -38,8 +40,12 @@
 #include <scsi/fc_encode.h>
 
 #include <target/target_core_base.h>
-#include <target/target_core_fabric.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
 #include <target/target_core_configfs.h>
+#include <target/target_core_tmr.h>
 #include <target/configfs_macros.h>
 
 #include "tcm_fc.h"
@@ -47,7 +53,7 @@
 /*
  * Dump cmd state for debugging.
  */
-static void _ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
+void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
 {
         struct fc_exch *ep;
         struct fc_seq *sp;
@@ -58,6 +64,9 @@ static void _ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
         se_cmd = &cmd->se_cmd;
         pr_debug("%s: cmd %p sess %p seq %p se_cmd %p\n",
                 caller, cmd, cmd->sess, cmd->seq, se_cmd);
+        pr_debug("%s: cmd %p cdb %p\n",
+                caller, cmd, cmd->cdb);
+        pr_debug("%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
 
         pr_debug("%s: cmd %p data_nents %u len %u se_cmd_flags <0x%x>\n",
                 caller, cmd, se_cmd->t_data_nents,
@@ -77,12 +86,8 @@ static void _ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
                         caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid,
                         sp->id, ep->esb_stat);
         }
-}
-
-void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
-{
-        if (unlikely(ft_debug_logging))
-                _ft_dump_cmd(cmd, caller);
+        print_hex_dump(KERN_INFO, "ft_dump_cmd ", DUMP_PREFIX_NONE,
+                16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0);
 }
 
 static void ft_free_cmd(struct ft_cmd *cmd)
@@ -108,10 +113,9 @@ void ft_release_cmd(struct se_cmd *se_cmd)
         ft_free_cmd(cmd);
 }
 
-int ft_check_stop_free(struct se_cmd *se_cmd)
+void ft_check_stop_free(struct se_cmd *se_cmd)
 {
-        transport_generic_free_cmd(se_cmd, 0);
-        return 1;
+        transport_generic_free_cmd(se_cmd, 0, 0);
 }
 
 /*
@@ -126,8 +130,6 @@ int ft_queue_status(struct se_cmd *se_cmd)
         struct fc_exch *ep;
         size_t len;
 
-        if (cmd->aborted)
-                return 0;
         ft_dump_cmd(cmd, __func__);
         ep = fc_seq_exch(cmd->seq);
         lport = ep->lp;
@@ -194,13 +196,11 @@ int ft_write_pending(struct se_cmd *se_cmd)
 
         ft_dump_cmd(cmd, __func__);
 
-        if (cmd->aborted)
-                return 0;
         ep = fc_seq_exch(cmd->seq);
         lport = ep->lp;
         fp = fc_frame_alloc(lport, sizeof(*txrdy));
         if (!fp)
-                return -ENOMEM; /* Signal QUEUE_FULL */
+                return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
 
         txrdy = fc_frame_payload_get(fp, sizeof(*txrdy));
         memset(txrdy, 0, sizeof(*txrdy));
@@ -220,10 +220,20 @@ int ft_write_pending(struct se_cmd *se_cmd)
                  */
                 if ((ep->xid <= lport->lro_xid) &&
                     (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) {
-                        if ((se_cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) &&
-                            lport->tt.ddp_target(lport, ep->xid,
-                                                 se_cmd->t_data_sg,
-                                                 se_cmd->t_data_nents))
+                        if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
+                                /*
+                                 * cmd may have been broken up into multiple
+                                 * tasks. Link their sgs together so we can
+                                 * operate on them all at once.
+                                 */
+                                transport_do_task_sg_chain(se_cmd);
+                                cmd->sg = se_cmd->t_tasks_sg_chained;
+                                cmd->sg_cnt =
+                                        se_cmd->t_tasks_sg_chained_no;
+                        }
+                        if (cmd->sg && lport->tt.ddp_target(lport, ep->xid,
+                                                            cmd->sg,
+                                                            cmd->sg_cnt))
                                 cmd->was_ddp_setup = 1;
                 }
         }
@@ -235,8 +245,6 @@ u32 ft_get_task_tag(struct se_cmd *se_cmd)
 {
         struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
 
-        if (cmd->aborted)
-                return ~0;
         return fc_seq_exch(cmd->seq)->rxid;
 }
 
@@ -245,6 +253,11 @@ int ft_get_cmd_state(struct se_cmd *se_cmd)
         return 0;
 }
 
+int ft_is_state_remove(struct se_cmd *se_cmd)
+{
+        return 0;       /* XXX TBD */
+}
+
 /*
  * FC sequence response handler for follow-on sequences (data) and aborts.
  */
@@ -253,10 +266,11 @@ static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
         struct ft_cmd *cmd = arg;
         struct fc_frame_header *fh;
 
-        if (unlikely(IS_ERR(fp))) {
+        if (IS_ERR(fp)) {
                 /* XXX need to find cmd if queued */
+                cmd->se_cmd.t_state = TRANSPORT_REMOVE;
                 cmd->seq = NULL;
-                cmd->aborted = true;
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 0);
                 return;
         }
 
@@ -274,7 +288,7 @@ static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
                        __func__, fh->fh_r_ctl);
                 ft_invl_hw_context(cmd);
                 fc_frame_free(fp);
-                transport_generic_free_cmd(&cmd->se_cmd, 0);
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 0);
                 break;
         }
 }
@@ -316,12 +330,10 @@ static void ft_send_resp_status(struct fc_lport *lport,
 
         fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0);
         sp = fr_seq(fp);
-        if (sp) {
+        if (sp)
                 lport->tt.seq_send(lport, sp, fp);
-                lport->tt.exch_done(sp);
-        } else {
+        else
                 lport->tt.frame_send(lport, fp);
-        }
 }
 
 /*
@@ -351,8 +363,9 @@ static void ft_send_resp_code_and_free(struct ft_cmd *cmd,
  */
 static void ft_send_tm(struct ft_cmd *cmd)
 {
+        struct se_tmr_req *tmr;
         struct fcp_cmnd *fcp;
-        int rc;
+        struct ft_sess *sess;
         u8 tm_func;
 
         fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
@@ -383,12 +396,45 @@ static void ft_send_tm(struct ft_cmd *cmd)
                 return;
         }
 
-        /* FIXME: Add referenced task tag for ABORT_TASK */
-        rc = target_submit_tmr(&cmd->se_cmd, cmd->sess->se_sess,
-                &cmd->ft_sense_buffer[0], scsilun_to_int(&fcp->fc_lun),
-                cmd, tm_func, GFP_KERNEL, 0, 0);
-        if (rc < 0)
+        pr_debug("alloc tm cmd fn %d\n", tm_func);
+        tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func);
+        if (!tmr) {
+                pr_debug("alloc failed\n");
                 ft_send_resp_code_and_free(cmd, FCP_TMF_FAILED);
+                return;
+        }
+        cmd->se_cmd.se_tmr_req = tmr;
+
+        switch (fcp->fc_tm_flags) {
+        case FCP_TMF_LUN_RESET:
+                cmd->lun = scsilun_to_int((struct scsi_lun *)fcp->fc_lun);
+                if (transport_lookup_tmr_lun(&cmd->se_cmd, cmd->lun) < 0) {
+                        /*
+                         * Make sure to clean up newly allocated TMR request
+                         * since "unable to  handle TMR request because failed
+                         * to get to LUN"
+                         */
+                        pr_debug("Failed to get LUN for TMR func %d, "
+                                  "se_cmd %p, unpacked_lun %d\n",
+                                  tm_func, &cmd->se_cmd, cmd->lun);
+                        ft_dump_cmd(cmd, __func__);
+                        sess = cmd->sess;
+                        transport_send_check_condition_and_sense(&cmd->se_cmd,
+                                cmd->se_cmd.scsi_sense_reason, 0);
+                        transport_generic_free_cmd(&cmd->se_cmd, 0, 0);
+                        ft_sess_put(sess);
+                        return;
+                }
+                break;
+        case FCP_TMF_TGT_RESET:
+        case FCP_TMF_CLR_TASK_SET:
+        case FCP_TMF_ABT_TASK_SET:
+        case FCP_TMF_CLR_ACA:
+                break;
+        default:
+                return;
+        }
+        transport_generic_handle_tmr(&cmd->se_cmd);
 }
 
 /*
@@ -400,8 +446,6 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
         struct se_tmr_req *tmr = se_cmd->se_tmr_req;
         enum fcp_resp_rsp_codes code;
 
-        if (cmd->aborted)
-                return 0;
         switch (tmr->response) {
         case TMR_FUNCTION_COMPLETE:
                 code = FCP_TMF_CMPL;
@@ -493,9 +537,12 @@ static void ft_send_work(struct work_struct *work)
 {
         struct ft_cmd *cmd = container_of(work, struct ft_cmd, work);
         struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame);
+        struct se_cmd *se_cmd;
         struct fcp_cmnd *fcp;
         int data_dir = 0;
+        u32 data_len;
         int task_attr;
+        int ret;
 
         fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
         if (!fcp)
@@ -504,6 +551,56 @@ static void ft_send_work(struct work_struct *work)
         if (fcp->fc_flags & FCP_CFL_LEN_MASK)
                 goto err;               /* not handling longer CDBs yet */
 
+        if (fcp->fc_tm_flags) {
+                task_attr = FCP_PTA_SIMPLE;
+                data_dir = DMA_NONE;
+                data_len = 0;
+        } else {
+                switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) {
+                case 0:
+                        data_dir = DMA_NONE;
+                        break;
+                case FCP_CFL_RDDATA:
+                        data_dir = DMA_FROM_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA:
+                        data_dir = DMA_TO_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA | FCP_CFL_RDDATA:
+                        goto err;       /* TBD not supported by tcm_fc yet */
+                }
+                /*
+                 * Locate the SAM Task Attr from fc_pri_ta
+                 */
+                switch (fcp->fc_pri_ta & FCP_PTA_MASK) {
+                case FCP_PTA_HEADQ:
+                        task_attr = MSG_HEAD_TAG;
+                        break;
+                case FCP_PTA_ORDERED:
+                        task_attr = MSG_ORDERED_TAG;
+                        break;
+                case FCP_PTA_ACA:
+                        task_attr = MSG_ACA_TAG;
+                        break;
+                case FCP_PTA_SIMPLE: /* Fallthrough */
+                default:
+                        task_attr = MSG_SIMPLE_TAG;
+                }
+
+
+                task_attr = fcp->fc_pri_ta & FCP_PTA_MASK;
+                data_len = ntohl(fcp->fc_dl);
+                cmd->cdb = fcp->fc_cdb;
+        }
+
+        se_cmd = &cmd->se_cmd;
+        /*
+         * Initialize struct se_cmd descriptor from target_core_mod
+         * infrastructure
+         */
+        transport_init_se_cmd(se_cmd, &ft_configfs->tf_ops, cmd->sess->se_sess,
+                              data_len, data_dir, task_attr,
+                              &cmd->ft_sense_buffer[0]);
         /*
          * Check for FCP task management flags
          */
@@ -512,48 +609,38 @@ static void ft_send_work(struct work_struct *work)
                 return;
         }
 
-        switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) {
-        case 0:
-                data_dir = DMA_NONE;
-                break;
-        case FCP_CFL_RDDATA:
-                data_dir = DMA_FROM_DEVICE;
-                break;
-        case FCP_CFL_WRDATA:
-                data_dir = DMA_TO_DEVICE;
-                break;
-        case FCP_CFL_WRDATA | FCP_CFL_RDDATA:
-                goto err;       /* TBD not supported by tcm_fc yet */
-        }
-        /*
-         * Locate the SAM Task Attr from fc_pri_ta
-         */
-        switch (fcp->fc_pri_ta & FCP_PTA_MASK) {
-        case FCP_PTA_HEADQ:
-                task_attr = MSG_HEAD_TAG;
-                break;
-        case FCP_PTA_ORDERED:
-                task_attr = MSG_ORDERED_TAG;
-                break;
-        case FCP_PTA_ACA:
-                task_attr = MSG_ACA_TAG;
-                break;
-        case FCP_PTA_SIMPLE: /* Fallthrough */
-        default:
-                task_attr = MSG_SIMPLE_TAG;
+        fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);
+
+        cmd->lun = scsilun_to_int((struct scsi_lun *)fcp->fc_lun);
+        ret = transport_lookup_cmd_lun(&cmd->se_cmd, cmd->lun);
+        if (ret < 0) {
+                ft_dump_cmd(cmd, __func__);
+                transport_send_check_condition_and_sense(&cmd->se_cmd,
+                        cmd->se_cmd.scsi_sense_reason, 0);
+                return;
         }
 
-        fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);
-        /*
-         * Use a single se_cmd->cmd_kref as we expect to release se_cmd
-         * directly from ft_check_stop_free callback in response path.
-         */
-        if (target_submit_cmd(&cmd->se_cmd, cmd->sess->se_sess, fcp->fc_cdb,
-                              &cmd->ft_sense_buffer[0], scsilun_to_int(&fcp->fc_lun),
-                              ntohl(fcp->fc_dl), task_attr, data_dir, 0))
-                goto err;
+        ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb);
+
+        pr_debug("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret);
+        ft_dump_cmd(cmd, __func__);
 
-        pr_debug("r_ctl %x alloc target_submit_cmd\n", fh->fh_r_ctl);
+        if (ret == -ENOMEM) {
+                transport_send_check_condition_and_sense(se_cmd,
+                                TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
+                transport_generic_free_cmd(se_cmd, 0, 0);
+                return;
+        }
+        if (ret == -EINVAL) {
+                if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT)
+                        ft_queue_status(se_cmd);
+                else
+                        transport_send_check_condition_and_sense(se_cmd,
+                                        se_cmd->scsi_sense_reason, 0);
+                transport_generic_free_cmd(se_cmd, 0, 0);
+                return;
+        }
+        transport_generic_handle_cdb(se_cmd);
         return;
 
 err: