kthread: Unify kthread_create_on_cpu() and kthread_create_worker_on_cpu() automatic...

kthread_create_on_cpu() uses the CPU argument as an implicit and unique
printf argument to add to the format whereas
kthread_create_worker_on_cpu() still relies on explicitly passing the
printf arguments. This difference in behaviour is error prone and
doesn't help standardizing per-CPU kthread names.

Unify the behaviours and convert kthread_create_worker_on_cpu() to
use the printf behaviour of kthread_create_on_cpu().

Signed-off-by: Frederic Weisbecker <frederic@kernel.org>

diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c
index 01f14750548745803e7357c765ea9e1ee18ebae1..a23392327ce2b7437b3ce2f0b70418592f49ee89 100644 (file)
--- a/fs/erofs/zdata.c
+++ b/fs/erofs/zdata.c
@@ -320,7 +320,7 @@ static void erofs_destroy_percpu_workers(void)
 static struct kthread_worker *erofs_init_percpu_worker(int cpu)
 {
        struct kthread_worker *worker =
-               kthread_create_worker_on_cpu(cpu, 0, "erofs_worker/%u", cpu);
+               kthread_create_worker_on_cpu(cpu, 0, "erofs_worker/%u");
 
        if (IS_ERR(worker))
                return worker;

diff --git a/include/linux/kthread.h b/include/linux/kthread.h
index 30209bdf83a2287ee018dafc2e9a04255ee44d03..0c66e7c1092a929870cd2884f86feb55ac3e961b 100644 (file)
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -187,13 +187,24 @@ extern void __kthread_init_worker(struct kthread_worker *worker,
 
 int kthread_worker_fn(void *worker_ptr);
 
-__printf(2, 3)
-struct kthread_worker *
-kthread_create_worker(unsigned int flags, const char namefmt[], ...);
+__printf(3, 4)
+struct kthread_worker *kthread_create_worker_on_node(unsigned int flags,
+                                                    int node,
+                                                    const char namefmt[], ...);
 
-__printf(3, 4) struct kthread_worker *
+#define kthread_create_worker(flags, namefmt, ...) \
+({                                                                        \
+       struct kthread_worker *__kw                                        \
+               = kthread_create_worker_on_node(flags, NUMA_NO_NODE,       \
+                                               namefmt, ## __VA_ARGS__);  \
+       if (!IS_ERR(__kw))                                                 \
+               wake_up_process(__kw->task);                               \
+       __kw;                                                              \
+})
+
+struct kthread_worker *
 kthread_create_worker_on_cpu(int cpu, unsigned int flags,
-                            const char namefmt[], ...);
+                            const char namefmt[]);
 
 bool kthread_queue_work(struct kthread_worker *worker,
                        struct kthread_work *work);

diff --git a/kernel/kthread.c b/kernel/kthread.c
index 32d620a99f11ad5a5104414646d593ecad49ffc6..2d52126d5da0a860617b20b8426aa5c9169744ac 100644 (file)
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -1030,12 +1030,11 @@ repeat:
 EXPORT_SYMBOL_GPL(kthread_worker_fn);
 
 static __printf(3, 0) struct kthread_worker *
-__kthread_create_worker(int cpu, unsigned int flags,
-                       const char namefmt[], va_list args)
+__kthread_create_worker_on_node(unsigned int flags, int node,
+                               const char namefmt[], va_list args)
 {
        struct kthread_worker *worker;
        struct task_struct *task;
-       int node = NUMA_NO_NODE;
 
        worker = kzalloc(sizeof(*worker), GFP_KERNEL);
        if (!worker)
@@ -1043,20 +1042,14 @@ __kthread_create_worker(int cpu, unsigned int flags,
 
        kthread_init_worker(worker);
 
-       if (cpu >= 0)
-               node = cpu_to_node(cpu);
-
        task = __kthread_create_on_node(kthread_worker_fn, worker,
-                                               node, namefmt, args);
+                                       node, namefmt, args);
        if (IS_ERR(task))
                goto fail_task;
 
-       if (cpu >= 0)
-               kthread_bind(task, cpu);
-
        worker->flags = flags;
        worker->task = task;
-       wake_up_process(task);
+
        return worker;
 
 fail_task:
@@ -1067,6 +1060,7 @@ fail_task:
 /**
  * kthread_create_worker - create a kthread worker
  * @flags: flags modifying the default behavior of the worker
+ * @node: task structure for the thread is allocated on this node
  * @namefmt: printf-style name for the kthread worker (task).
  *
  * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
@@ -1074,25 +1068,49 @@ fail_task:
  * when the caller was killed by a fatal signal.
  */
 struct kthread_worker *
-kthread_create_worker(unsigned int flags, const char namefmt[], ...)
+kthread_create_worker_on_node(unsigned int flags, int node, const char namefmt[], ...)
+{
+       struct kthread_worker *worker;
+       va_list args;
+
+       va_start(args, namefmt);
+       worker = __kthread_create_worker_on_node(flags, node, namefmt, args);
+       va_end(args);
+
+       if (worker)
+               wake_up_process(worker->task);
+
+       return worker;
+}
+EXPORT_SYMBOL(kthread_create_worker_on_node);
+
+static __printf(3, 4) struct kthread_worker *
+__kthread_create_worker_on_cpu(int cpu, unsigned int flags,
+                              const char namefmt[], ...)
 {
        struct kthread_worker *worker;
        va_list args;
 
        va_start(args, namefmt);
-       worker = __kthread_create_worker(-1, flags, namefmt, args);
+       worker = __kthread_create_worker_on_node(flags, cpu_to_node(cpu),
+                                                namefmt, args);
        va_end(args);
 
+       if (worker) {
+               kthread_bind(worker->task, cpu);
+               wake_up_process(worker->task);
+       }
+
        return worker;
 }
-EXPORT_SYMBOL(kthread_create_worker);
 
 /**
  * kthread_create_worker_on_cpu - create a kthread worker and bind it
  *     to a given CPU and the associated NUMA node.
  * @cpu: CPU number
  * @flags: flags modifying the default behavior of the worker
- * @namefmt: printf-style name for the kthread worker (task).
+ * @namefmt: printf-style name for the thread. Format is restricted
+ *          to "name.*%u". Code fills in cpu number.
  *
  * Use a valid CPU number if you want to bind the kthread worker
  * to the given CPU and the associated NUMA node.
@@ -1124,16 +1142,9 @@ EXPORT_SYMBOL(kthread_create_worker);
  */
 struct kthread_worker *
 kthread_create_worker_on_cpu(int cpu, unsigned int flags,
-                            const char namefmt[], ...)
+                            const char namefmt[])
 {
-       struct kthread_worker *worker;
-       va_list args;
-
-       va_start(args, namefmt);
-       worker = __kthread_create_worker(cpu, flags, namefmt, args);
-       va_end(args);
-
-       return worker;
+       return __kthread_create_worker_on_cpu(cpu, flags, namefmt, cpu);
 }
 EXPORT_SYMBOL(kthread_create_worker_on_cpu);