Refactor helpers for creating RT threads

Split functionality to allow creation of arbitrary
thread tasks and kthread_worker_fn workers, while sharing
the promotion to RT scheduling policies for both.

Finally use this functionality to elevate "mali-gpuq-kthread"
to RT priority.

Bug: 290882327
Change-Id: Icf2c07849cdd0ca47bcfc06700853ac1856d0a87

7 files changed, 84 insertions, 44 deletions

diff --git a/mali_kbase/csf/mali_kbase_csf.c b/mali_kbase/csf/mali_kbase_csf.c
index 8eaedde..c64cc3e 100644
--- a/mali_kbase/csf/mali_kbase_csf.c
+++ b/mali_kbase/csf/mali_kbase_csf.c
@@ -1682,8 +1682,8 @@ int kbase_csf_ctx_init(struct kbase_context *kctx)
 					err = kbasep_ctx_user_reg_page_mapping_init(kctx);
 
 					if (likely(!err)) {
-						err = kbase_create_realtime_thread(kctx->kbdev, kthread_worker_fn,
-						                                   &kctx->csf.protm_event_worker, "mali_protm_event");
+						err = kbase_kthread_run_worker_rt(kctx->kbdev,
+						                                  &kctx->csf.protm_event_worker, "mali_protm_event");
 						if (unlikely(err)) {
 							dev_err(kctx->kbdev->dev, "error initializing protm event worker thread");
 							kbasep_ctx_user_reg_page_mapping_term(kctx);
diff --git a/mali_kbase/csf/mali_kbase_csf_kcpu.c b/mali_kbase/csf/mali_kbase_csf_kcpu.c
index 08d82d2..049b8eb 100644
--- a/mali_kbase/csf/mali_kbase_csf_kcpu.c
+++ b/mali_kbase/csf/mali_kbase_csf_kcpu.c
@@ -2826,8 +2826,7 @@ int kbase_csf_kcpu_queue_new(struct kbase_context *kctx,
 		goto out;
 	}
 
-	ret = kbase_create_realtime_thread(
-	    kctx->kbdev, kthread_worker_fn, &queue->csf_kcpu_worker, "csf_kcpu_%i", idx);
+	ret = kbase_kthread_run_worker_rt(kctx->kbdev, &queue->csf_kcpu_worker, "csf_kcpu_%i", idx);
 
 	if (ret) {
 		kfree(queue);
diff --git a/mali_kbase/csf/mali_kbase_csf_scheduler.c b/mali_kbase/csf/mali_kbase_csf_scheduler.c
index 2573e3f..8cbc301 100644
--- a/mali_kbase/csf/mali_kbase_csf_scheduler.c
+++ b/mali_kbase/csf/mali_kbase_csf_scheduler.c
@@ -7301,9 +7301,7 @@ int kbase_csf_scheduler_context_init(struct kbase_context *kctx)
 	kctx->csf.sched.num_idle_wait_grps = 0;
 	kctx->csf.sched.ngrp_to_schedule = 0;
 
-	err = kbase_create_realtime_thread(kctx->kbdev, kthread_worker_fn,
-					   &kctx->csf.sched.sync_update_worker,
-					   "csf_sync_update");
+	err = kbase_kthread_run_worker_rt(kctx->kbdev, &kctx->csf.sched.sync_update_worker, "csf_sync_update");
 	if (err) {
 		dev_err(kctx->kbdev->dev,
 			"Failed to initialize scheduler context workqueue");
@@ -7431,8 +7429,8 @@ int kbase_csf_scheduler_init(struct kbase_device *kbdev)
 	init_completion(&scheduler->kthread_signal);
 	scheduler->kthread_running = true;
 	scheduler->gpuq_kthread =
-		kthread_run(&kbase_csf_scheduler_kthread, kbdev, "mali-gpuq-kthread");
-	if (!scheduler->gpuq_kthread) {
+		kbase_kthread_run_rt(kbdev, &kbase_csf_scheduler_kthread, kbdev, "mali-gpuq-kthread");
+	if (IS_ERR(scheduler->gpuq_kthread)) {
 		kfree(scheduler->csg_slots);
 		scheduler->csg_slots = NULL;
 
diff --git a/mali_kbase/device/backend/mali_kbase_device_jm.c b/mali_kbase/device/backend/mali_kbase_device_jm.c
index 89635b5..0ce2bc8 100644
--- a/mali_kbase/device/backend/mali_kbase_device_jm.c
+++ b/mali_kbase/device/backend/mali_kbase_device_jm.c
@@ -330,8 +330,7 @@ int kbase_device_init(struct kbase_device *kbdev)
 	if (err)
 		return err;
 
-	err = kbase_create_realtime_thread(kbdev,
-		kthread_worker_fn, &kbdev->job_done_worker, "mali_jd_thread");
+	err = kbase_kthread_run_worker_rt(kbdev, &kbdev->job_done_worker, "mali_jd_thread");
 	if (err)
 		return err;
 
diff --git a/mali_kbase/mali_kbase.h b/mali_kbase/mali_kbase.h
index c39ba99..d9e632f 100644
--- a/mali_kbase/mali_kbase.h
+++ b/mali_kbase/mali_kbase.h
@@ -802,20 +802,39 @@ void kbase_device_pcm_dev_term(struct kbase_device *const kbdev);
 #define KBASE_DISJOINT_STATE_INTERLEAVED_CONTEXT_COUNT_THRESHOLD 2
 
 /**
- * kbase_create_realtime_thread - Create a realtime thread with an appropriate coremask
+ * kbase_kthread_run_rt - Create a realtime thread with an appropriate coremask
  *
- * @kbdev:    the kbase device
- * @threadfn: the function the realtime thread will execute
- * @worker:   pointer to the thread's kworker
- * @namefmt:  a name for the thread.
+ * @kbdev:        the kbase device
+ * @threadfn:     the function the realtime thread will execute
+ * @thread_param: data pointer to @threadfn
+ * @namefmt:      a name for the thread.
  *
  * Creates a realtime kthread with priority &KBASE_RT_THREAD_PRIO and restricted
  * to cores defined by &KBASE_RT_THREAD_CPUMASK_MIN and &KBASE_RT_THREAD_CPUMASK_MAX.
  *
+ * Wakes up the task.
+ *
+ * Return: IS_ERR() on failure, or a valid task pointer.
+ */
+struct task_struct *kbase_kthread_run_rt(struct kbase_device *kbdev,
+	int (*threadfn)(void *data), void *thread_param, const char namefmt[], ...);
+
+/**
+ * kbase_kthread_run_worker_rt - Create a realtime kthread_worker_fn with an appropriate coremask
+ *
+ * @kbdev:   the kbase device
+ * @worker:  pointer to the thread's parameters
+ * @namefmt: a name for the thread.
+ *
+ * Creates a realtime kthread_worker_fn thread with priority &KBASE_RT_THREAD_PRIO and restricted
+ * to cores defined by &KBASE_RT_THREAD_CPUMASK_MIN and &KBASE_RT_THREAD_CPUMASK_MAX.
+ *
+ * Wakes up the task.
+ *
  * Return: Zero on success, or an PTR_ERR on failure.
  */
-int kbase_create_realtime_thread(struct kbase_device *kbdev,
-	int (*threadfn)(void *data), struct kthread_worker *worker, const char namefmt[], ...);
+int kbase_kthread_run_worker_rt(struct kbase_device *kbdev,
+	struct kthread_worker *worker, const char namefmt[], ...);
 
 /**
  * kbase_destroy_kworker_stack - Destroy a kthread_worker and it's thread on the stack
diff --git a/mali_kbase/mali_kbase_core_linux.c b/mali_kbase/mali_kbase_core_linux.c
index 28cbcdb..dd8ba7f 100644
--- a/mali_kbase/mali_kbase_core_linux.c
+++ b/mali_kbase/mali_kbase_core_linux.c
@@ -200,22 +200,59 @@ bool mali_kbase_supports_cap(unsigned long api_version, enum mali_kbase_cap cap)
 	return supported;
 }
 
-int kbase_create_realtime_thread(struct kbase_device *kbdev,
-	int (*threadfn)(void *data), struct kthread_worker *worker, const char namefmt[], ...)
+static void kbase_set_sched_rt(struct kbase_device *kbdev, struct task_struct *task, char *thread_name)
 {
-	struct task_struct *task;
 	unsigned int i;
+	static const struct sched_param param = {
+		.sched_priority = KBASE_RT_THREAD_PRIO,
+	};
+
+	cpumask_t mask = { CPU_BITS_NONE };
+	for (i = KBASE_RT_THREAD_CPUMASK_MIN; i <= KBASE_RT_THREAD_CPUMASK_MAX ; i++)
+		cpumask_set_cpu(i, &mask);
+	kthread_bind_mask(task, &mask);
+
+	wake_up_process(task);
+
+	if (sched_setscheduler_nocheck(task, SCHED_FIFO, &param))
+		dev_warn(kbdev->dev, "%s not set to RT prio", thread_name);
+	else
+		dev_dbg(kbdev->dev, "%s set to RT prio: %i",
+			thread_name, param.sched_priority);
+}
+
+struct task_struct *kbase_kthread_run_rt(struct kbase_device *kbdev,
+	int (*threadfn)(void *data), void *thread_param, const char namefmt[], ...)
+{
+	struct task_struct *task;
 	va_list args;
 	char name_buf[128];
 	int len;
 
-	cpumask_t mask = { CPU_BITS_NONE };
+	/* Construct the thread name */
+	va_start(args, namefmt);
+	len = vsnprintf(name_buf, sizeof(name_buf), namefmt, args);
+	va_end(args);
+	if (len + 1 > sizeof(name_buf)) {
+		dev_warn(kbdev->dev, "RT thread name truncated to %s", name_buf);
+	}
 
-	static const struct sched_param param = {
-		.sched_priority = KBASE_RT_THREAD_PRIO,
-	};
+	task = kthread_create(threadfn, thread_param, name_buf);
 
-	kthread_init_worker(worker);
+	if (!IS_ERR(task)) {
+		kbase_set_sched_rt(kbdev, task, name_buf);
+	}
+
+	return task;
+}
+
+int kbase_kthread_run_worker_rt(struct kbase_device *kbdev,
+	struct kthread_worker *worker, const char namefmt[], ...)
+{
+	struct task_struct *task;
+	va_list args;
+	char name_buf[128];
+	int len;
 
 	/* Construct the thread name */
 	va_start(args, namefmt);
@@ -225,28 +262,17 @@ int kbase_create_realtime_thread(struct kbase_device *kbdev,
 		dev_warn(kbdev->dev, "RT thread name truncated to %s", name_buf);
 	}
 
+	kthread_init_worker(worker);
+
 	task = kthread_create(kthread_worker_fn, worker, name_buf);
 
 	if (!IS_ERR(task)) {
-		for (i = KBASE_RT_THREAD_CPUMASK_MIN; i <= KBASE_RT_THREAD_CPUMASK_MAX ; i++)
-			cpumask_set_cpu(i, &mask);
-
-		kthread_bind_mask(task, &mask);
-
-		/* Link the worker and the thread */
 		worker->task = task;
-		wake_up_process(task);
-
-		if (sched_setscheduler_nocheck(task, SCHED_FIFO, &param))
-			dev_warn(kbdev->dev, "%s not set to RT prio", name_buf);
-		else
-			dev_dbg(kbdev->dev, "%s set to RT prio: %i",
-				name_buf, param.sched_priority);
-	} else {
-		return PTR_ERR(task);
+		kbase_set_sched_rt(kbdev, task, name_buf);
+		return 0;
 	}
 
-	return 0;
+	return PTR_ERR(task);
 }
 
 void kbase_destroy_kworker_stack(struct kthread_worker *worker)
diff --git a/mali_kbase/mali_kbase_pm.c b/mali_kbase/mali_kbase_pm.c
index 40278a8..d6c559a 100644
--- a/mali_kbase/mali_kbase_pm.c
+++ b/mali_kbase/mali_kbase_pm.c
@@ -488,8 +488,7 @@ int kbase_pm_apc_init(struct kbase_device *kbdev)
 {
 	int ret;
 
-	ret = kbase_create_realtime_thread(kbdev,
-		kthread_worker_fn, &kbdev->apc.worker, "mali_apc_thread");
+	ret = kbase_kthread_run_worker_rt(kbdev, &kbdev->apc.worker, "mali_apc_thread");
 	if (ret)
 		return ret;