7 files changed, 101 insertions, 66 deletions

diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index aac3c1d2b2a2..9df4f71e58ca 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -376,6 +376,15 @@ static void nvme_put_ns(struct nvme_ns *ns)
         kref_put(&ns->kref, nvme_free_ns);
 }
 
+static inline void nvme_clear_nvme_request(struct request *req)
+{
+        if (!(req->rq_flags & RQF_DONTPREP)) {
+                nvme_req(req)->retries = 0;
+                nvme_req(req)->flags = 0;
+                req->rq_flags |= RQF_DONTPREP;
+        }
+}
+
 struct request *nvme_alloc_request(struct request_queue *q,
                 struct nvme_command *cmd, blk_mq_req_flags_t flags, int qid)
 {
@@ -392,6 +401,7 @@ struct request *nvme_alloc_request(struct request_queue *q,
                 return req;
 
         req->cmd_flags |= REQ_FAILFAST_DRIVER;
+        nvme_clear_nvme_request(req);
         nvme_req(req)->cmd = cmd;
 
         return req;
@@ -608,11 +618,7 @@ blk_status_t nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
 {
         blk_status_t ret = BLK_STS_OK;
 
-        if (!(req->rq_flags & RQF_DONTPREP)) {
-                nvme_req(req)->retries = 0;
-                nvme_req(req)->flags = 0;
-                req->rq_flags |= RQF_DONTPREP;
-        }
+        nvme_clear_nvme_request(req);
 
         switch (req_op(req)) {
         case REQ_OP_DRV_IN:
@@ -742,6 +748,7 @@ static int nvme_submit_user_cmd(struct request_queue *q,
                 return PTR_ERR(req);
 
         req->timeout = timeout ? timeout : ADMIN_TIMEOUT;
+        nvme_req(req)->flags |= NVME_REQ_USERCMD;
 
         if (ubuffer && bufflen) {
                 ret = blk_rq_map_user(q, req, NULL, ubuffer, bufflen,
diff --git a/drivers/nvme/host/fabrics.c b/drivers/nvme/host/fabrics.c
index 3583f9492a45..124c458806df 100644
--- a/drivers/nvme/host/fabrics.c
+++ b/drivers/nvme/host/fabrics.c
@@ -536,6 +536,85 @@ static struct nvmf_transport_ops *nvmf_lookup_transport(
         return NULL;
 }
 
+blk_status_t nvmf_check_if_ready(struct nvme_ctrl *ctrl, struct request *rq,
+                bool queue_live, bool is_connected)
+{
+        struct nvme_command *cmd = nvme_req(rq)->cmd;
+
+        if (likely(ctrl->state == NVME_CTRL_LIVE && is_connected))
+                return BLK_STS_OK;
+
+        switch (ctrl->state) {
+        case NVME_CTRL_DELETING:
+                goto reject_io;
+
+        case NVME_CTRL_NEW:
+        case NVME_CTRL_CONNECTING:
+                if (!is_connected)
+                        /*
+                         * This is the case of starting a new
+                         * association but connectivity was lost
+                         * before it was fully created. We need to
+                         * error the commands used to initialize the
+                         * controller so the reconnect can go into a
+                         * retry attempt. The commands should all be
+                         * marked REQ_FAILFAST_DRIVER, which will hit
+                         * the reject path below. Anything else will
+                         * be queued while the state settles.
+                         */
+                        goto reject_or_queue_io;
+
+                if ((queue_live &&
+                     !(nvme_req(rq)->flags & NVME_REQ_USERCMD)) ||
+                    (!queue_live && blk_rq_is_passthrough(rq) &&
+                     cmd->common.opcode == nvme_fabrics_command &&
+                     cmd->fabrics.fctype == nvme_fabrics_type_connect))
+                        /*
+                         * If queue is live, allow only commands that
+                         * are internally generated pass through. These
+                         * are commands on the admin queue to initialize
+                         * the controller. This will reject any ioctl
+                         * admin cmds received while initializing.
+                         *
+                         * If the queue is not live, allow only a
+                         * connect command. This will reject any ioctl
+                         * admin cmd as well as initialization commands
+                         * if the controller reverted the queue to non-live.
+                         */
+                        return BLK_STS_OK;
+
+                /*
+                 * fall-thru to the reject_or_queue_io clause
+                 */
+                break;
+
+        /* these cases fall-thru
+         * case NVME_CTRL_LIVE:
+         * case NVME_CTRL_RESETTING:
+         */
+        default:
+                break;
+        }
+
+reject_or_queue_io:
+        /*
+         * Any other new io is something we're not in a state to send
+         * to the device. Default action is to busy it and retry it
+         * after the controller state is recovered. However, anything
+         * marked for failfast or nvme multipath is immediately failed.
+         * Note: commands used to initialize the controller will be
+         *  marked for failfast.
+         * Note: nvme cli/ioctl commands are marked for failfast.
+         */
+        if (!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
+                return BLK_STS_RESOURCE;
+
+reject_io:
+        nvme_req(rq)->status = NVME_SC_ABORT_REQ;
+        return BLK_STS_IOERR;
+}
+EXPORT_SYMBOL_GPL(nvmf_check_if_ready);
+
 static const match_table_t opt_tokens = {
         { NVMF_OPT_TRANSPORT,           "transport=%s"          },
         { NVMF_OPT_TRADDR,              "traddr=%s"             },
diff --git a/drivers/nvme/host/fabrics.h b/drivers/nvme/host/fabrics.h
index a3145d90c1d2..ef46c915b7b5 100644
--- a/drivers/nvme/host/fabrics.h
+++ b/drivers/nvme/host/fabrics.h
@@ -157,36 +157,7 @@ void nvmf_unregister_transport(struct nvmf_transport_ops *ops);
 void nvmf_free_options(struct nvmf_ctrl_options *opts);
 int nvmf_get_address(struct nvme_ctrl *ctrl, char *buf, int size);
 bool nvmf_should_reconnect(struct nvme_ctrl *ctrl);
-
-static inline blk_status_t nvmf_check_init_req(struct nvme_ctrl *ctrl,
-                struct request *rq)
-{
-        struct nvme_command *cmd = nvme_req(rq)->cmd;
-
-        /*
-         * We cannot accept any other command until the connect command has
-         * completed, so only allow connect to pass.
-         */
-        if (!blk_rq_is_passthrough(rq) ||
-            cmd->common.opcode != nvme_fabrics_command ||
-            cmd->fabrics.fctype != nvme_fabrics_type_connect) {
-                /*
-                 * Connecting state means transport disruption or initial
-                 * establishment, which can take a long time and even might
-                 * fail permanently, fail fast to give upper layers a chance
-                 * to failover.
-                 * Deleting state means that the ctrl will never accept commands
-                 * again, fail it permanently.
-                 */
-                if (ctrl->state == NVME_CTRL_CONNECTING ||
-                    ctrl->state == NVME_CTRL_DELETING) {
-                        nvme_req(rq)->status = NVME_SC_ABORT_REQ;
-                        return BLK_STS_IOERR;
-                }
-                return BLK_STS_RESOURCE; /* try again later */
-        }
-
-        return BLK_STS_OK;
-}
+blk_status_t nvmf_check_if_ready(struct nvme_ctrl *ctrl,
+        struct request *rq, bool queue_live, bool is_connected);
 
 #endif /* _NVME_FABRICS_H */
diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c
index c6e719b2f3ca..6cb26bcf6ec0 100644
--- a/drivers/nvme/host/fc.c
+++ b/drivers/nvme/host/fc.c
@@ -2277,14 +2277,6 @@ nvme_fc_start_fcp_op(struct nvme_fc_ctrl *ctrl, struct nvme_fc_queue *queue,
         return BLK_STS_OK;
 }
 
-static inline blk_status_t nvme_fc_is_ready(struct nvme_fc_queue *queue,
-                struct request *rq)
-{
-        if (unlikely(!test_bit(NVME_FC_Q_LIVE, &queue->flags)))
-                return nvmf_check_init_req(&queue->ctrl->ctrl, rq);
-        return BLK_STS_OK;
-}
-
 static blk_status_t
 nvme_fc_queue_rq(struct blk_mq_hw_ctx *hctx,
                         const struct blk_mq_queue_data *bd)
@@ -2300,7 +2292,9 @@ nvme_fc_queue_rq(struct blk_mq_hw_ctx *hctx,
         u32 data_len;
         blk_status_t ret;
 
-        ret = nvme_fc_is_ready(queue, rq);
+        ret = nvmf_check_if_ready(&queue->ctrl->ctrl, rq,
+                test_bit(NVME_FC_Q_LIVE, &queue->flags),
+                ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE);
         if (unlikely(ret))
                 return ret;
 
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index 08c4cff79cde..061fecfd44f5 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -105,6 +105,7 @@ struct nvme_request {
 
 enum {
         NVME_REQ_CANCELLED              = (1 << 0),
+        NVME_REQ_USERCMD                = (1 << 1),
 };
 
 static inline struct nvme_request *nvme_req(struct request *req)
diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c
index 758537e9ba07..1eb4438a8763 100644
--- a/drivers/nvme/host/rdma.c
+++ b/drivers/nvme/host/rdma.c
@@ -1601,17 +1601,6 @@ nvme_rdma_timeout(struct request *rq, bool reserved)
         return BLK_EH_HANDLED;
 }
 
-/*
- * We cannot accept any other command until the Connect command has completed.
- */
-static inline blk_status_t
-nvme_rdma_is_ready(struct nvme_rdma_queue *queue, struct request *rq)
-{
-        if (unlikely(!test_bit(NVME_RDMA_Q_LIVE, &queue->flags)))
-                return nvmf_check_init_req(&queue->ctrl->ctrl, rq);
-        return BLK_STS_OK;
-}
-
 static blk_status_t nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
                 const struct blk_mq_queue_data *bd)
 {
@@ -1627,7 +1616,8 @@ static blk_status_t nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
 
         WARN_ON_ONCE(rq->tag < 0);
 
-        ret = nvme_rdma_is_ready(queue, rq);
+        ret = nvmf_check_if_ready(&queue->ctrl->ctrl, rq,
+                test_bit(NVME_RDMA_Q_LIVE, &queue->flags), true);
         if (unlikely(ret))
                 return ret;
 
diff --git a/drivers/nvme/target/loop.c b/drivers/nvme/target/loop.c
index b9d5b69d8548..31fdfba556a8 100644
--- a/drivers/nvme/target/loop.c
+++ b/drivers/nvme/target/loop.c
@@ -149,14 +149,6 @@ nvme_loop_timeout(struct request *rq, bool reserved)
         return BLK_EH_HANDLED;
 }
 
-static inline blk_status_t nvme_loop_is_ready(struct nvme_loop_queue *queue,
-                struct request *rq)
-{
-        if (unlikely(!test_bit(NVME_LOOP_Q_LIVE, &queue->flags)))
-                return nvmf_check_init_req(&queue->ctrl->ctrl, rq);
-        return BLK_STS_OK;
-}
-
 static blk_status_t nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx,
                 const struct blk_mq_queue_data *bd)
 {
@@ -166,7 +158,8 @@ static blk_status_t nvme_loop_queue_rq(struct blk_mq_hw_ctx *hctx,
         struct nvme_loop_iod *iod = blk_mq_rq_to_pdu(req);
         blk_status_t ret;
 
-        ret = nvme_loop_is_ready(queue, req);
+        ret = nvmf_check_if_ready(&queue->ctrl->ctrl, req,
+                test_bit(NVME_LOOP_Q_LIVE, &queue->flags), true);
         if (unlikely(ret))
                 return ret;