nvmet-tcp: enable optional queue idle period tracking

Add 'idle_poll_period_usecs' option used by io_work() to support
network devices enabled with advanced interrupt moderation
supporting a relaxed interrupt model. It was discovered that
such a NIC used on the target was unable to support initiator
connection establishment, caused by the existing io_work()
flow that immediately exits after a loop with no activity and
does not re-queue itself.

With this new option a queue is assigned a period of time
that no activity must occur in order to become 'idle'.  Until
the queue is idle the work item is requeued.

The new module option is defined as changeable making it
flexible for testing purposes.

The pre-existing legacy behavior is preserved when no module option
for idle_poll_period_usecs is specified.

Signed-off-by: Mark Wunderlich <mark.wunderlich@intel.com>
Reviewed-by: Sagi Grimberg <sagi@grimberg.me>
Signed-off-by: Christoph Hellwig <hch@lst.de>

diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c
index 2696364..558a973 100644 (file)
--- a/drivers/nvme/target/tcp.c
+++ b/drivers/nvme/target/tcp.c
@@ -29,6 +29,16 @@ static int so_priority;
 module_param(so_priority, int, 0644);
 MODULE_PARM_DESC(so_priority, "nvmet tcp socket optimize priority");
 
+/* Define a time period (in usecs) that io_work() shall sample an activated
+ * queue before determining it to be idle.  This optional module behavior
+ * can enable NIC solutions that support socket optimized packet processing
+ * using advanced interrupt moderation techniques.
+ */
+static int idle_poll_period_usecs;
+module_param(idle_poll_period_usecs, int, 0644);
+MODULE_PARM_DESC(idle_poll_period_usecs,
+               "nvmet tcp io_work poll till idle time period in usecs");
+
 #define NVMET_TCP_RECV_BUDGET          8
 #define NVMET_TCP_SEND_BUDGET          8
 #define NVMET_TCP_IO_WORK_BUDGET       64
@@ -119,6 +129,8 @@ struct nvmet_tcp_queue {
        struct ahash_request    *snd_hash;
        struct ahash_request    *rcv_hash;
 
+       unsigned long           poll_end;
+
        spinlock_t              state_lock;
        enum nvmet_tcp_queue_state state;
 
@@ -1216,6 +1228,23 @@ static void nvmet_tcp_schedule_release_queue(struct nvmet_tcp_queue *queue)
        spin_unlock(&queue->state_lock);
 }
 
+static inline void nvmet_tcp_arm_queue_deadline(struct nvmet_tcp_queue *queue)
+{
+       queue->poll_end = jiffies + usecs_to_jiffies(idle_poll_period_usecs);
+}
+
+static bool nvmet_tcp_check_queue_deadline(struct nvmet_tcp_queue *queue,
+               int ops)
+{
+       if (!idle_poll_period_usecs)
+               return false;
+
+       if (ops)
+               nvmet_tcp_arm_queue_deadline(queue);
+
+       return !time_after(jiffies, queue->poll_end);
+}
+
 static void nvmet_tcp_io_work(struct work_struct *w)
 {
        struct nvmet_tcp_queue *queue =
@@ -1241,9 +1270,10 @@ static void nvmet_tcp_io_work(struct work_struct *w)
        } while (pending && ops < NVMET_TCP_IO_WORK_BUDGET);
 
        /*
-        * We exahusted our budget, requeue our selves
+        * Requeue the worker if idle deadline period is in progress or any
+        * ops activity was recorded during the do-while loop above.
         */
-       if (pending)
+       if (nvmet_tcp_check_queue_deadline(queue, ops) || pending)
                queue_work_on(queue_cpu(queue), nvmet_tcp_wq, &queue->io_work);
 }
 
@@ -1501,6 +1531,8 @@ static int nvmet_tcp_set_queue_sock(struct nvmet_tcp_queue *queue)
                sock->sk->sk_state_change = nvmet_tcp_state_change;
                queue->write_space = sock->sk->sk_write_space;
                sock->sk->sk_write_space = nvmet_tcp_write_space;
+               if (idle_poll_period_usecs)
+                       nvmet_tcp_arm_queue_deadline(queue);
                queue_work_on(queue_cpu(queue), nvmet_tcp_wq, &queue->io_work);
        }
        write_unlock_bh(&sock->sk->sk_callback_lock);