2 files changed, 51 insertions, 6 deletions

diff --git a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
index ea69d7cb..a0494e31 100644
--- a/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
+++ b/drivers/gpu/nvgpu/gk20a/channel_gk20a.c
@@ -1878,34 +1878,70 @@ static int gk20a_channel_poll_worker(void *arg)
         return 0;
 }
 
+static int __nvgpu_channel_worker_start(struct gk20a *g)
+{
+        char thread_name[64];
+        int err = 0;
+
+        if (nvgpu_thread_is_running(&g->channel_worker.poll_task))
+                return err;
+
+        nvgpu_mutex_acquire(&g->channel_worker.start_lock);
+
+        /*
+         * We don't want to grab a mutex on every channel update so we check
+         * again if the worker has been initialized before creating a new thread
+         */
+
+        /*
+         * Mutexes have implicit barriers, so there is no risk of a thread
+         * having a stale copy of the poll_task variable as the call to
+         * thread_is_running is volatile
+         */
+
+        if (nvgpu_thread_is_running(&g->channel_worker.poll_task)) {
+                nvgpu_mutex_release(&g->channel_worker.start_lock);
+                return err;
+        }
+
+        snprintf(thread_name, sizeof(thread_name),
+                        "nvgpu_channel_poll_%s", g->name);
+
+        err = nvgpu_thread_create(&g->channel_worker.poll_task, g,
+                        gk20a_channel_poll_worker, thread_name);
+
+        nvgpu_mutex_release(&g->channel_worker.start_lock);
+        return err;
+}
 /**
  * Initialize the channel worker's metadata and start the background thread.
  */
 int nvgpu_channel_worker_init(struct gk20a *g)
 {
         int err;
-        char thread_name[64];
 
         nvgpu_atomic_set(&g->channel_worker.put, 0);
         nvgpu_cond_init(&g->channel_worker.wq);
         nvgpu_init_list_node(&g->channel_worker.items);
         nvgpu_spinlock_init(&g->channel_worker.items_lock);
-        snprintf(thread_name, sizeof(thread_name),
-                        "nvgpu_channel_poll_%s", g->name);
+        err = nvgpu_mutex_init(&g->channel_worker.start_lock);
+        if (err)
+                goto error_check;
 
-        err = nvgpu_thread_create(&g->channel_worker.poll_task, g,
-                        gk20a_channel_poll_worker, thread_name);
+        err = __nvgpu_channel_worker_start(g);
+error_check:
         if (err) {
                 nvgpu_err(g, "failed to start channel poller thread");
                 return err;
         }
-
         return 0;
 }
 
 void nvgpu_channel_worker_deinit(struct gk20a *g)
 {
+        nvgpu_mutex_acquire(&g->channel_worker.start_lock);
         nvgpu_thread_stop(&g->channel_worker.poll_task);
+        nvgpu_mutex_release(&g->channel_worker.start_lock);
 }
 
 /**
@@ -1924,6 +1960,14 @@ static void gk20a_channel_worker_enqueue(struct channel_gk20a *ch)
         gk20a_dbg_fn("");
 
         /*
+         * Warn if worker thread cannot run
+         */
+        if (WARN_ON(__nvgpu_channel_worker_start(g))) {
+                nvgpu_warn(g, "channel worker cannot run!");
+                return;
+        }
+
+        /*
          * Ref released when this item gets processed. The caller should hold
          * one ref already, so normally shouldn't fail, but the channel could
          * end up being freed between the time the caller got its reference and
diff --git a/drivers/gpu/nvgpu/gk20a/gk20a.h b/drivers/gpu/nvgpu/gk20a/gk20a.h
index 0cd77d1e..35d58ef1 100644
--- a/drivers/gpu/nvgpu/gk20a/gk20a.h
+++ b/drivers/gpu/nvgpu/gk20a/gk20a.h
@@ -1215,6 +1215,7 @@ struct gk20a {
                 struct nvgpu_cond wq;
                 struct nvgpu_list_node items;
                 struct nvgpu_spinlock items_lock;
+                struct nvgpu_mutex start_lock;
         } channel_worker;
 
         struct gk20a_scale_profile *scale_profile;