treewide: Introduce kthread_run_worker[_on_cpu]()

kthread_create() creates a kthread without running it yet. kthread_run()
creates a kthread and runs it.

On the other hand, kthread_create_worker() creates a kthread worker and
runs it.

This difference in behaviours is confusing. Also there is no way to
create a kthread worker and affine it using kthread_bind_mask() or
kthread_affine_preferred() before starting it.

Consolidate the behaviours and introduce kthread_run_worker[_on_cpu]()
that behaves just like kthread_run(). kthread_create_worker[_on_cpu]()
will now only create a kthread worker without starting it.

Signed-off-by: Frederic Weisbecker <frederic@kernel.org>
Signed-off-by: Dan Carpenter <dan.carpenter@linaro.org>

diff --git a/arch/x86/kvm/i8254.c b/arch/x86/kvm/i8254.c
index cd57a517d04a736df10bae69f8423504750251b2..d7ab8780ab9e123650b51c68319dfbd41d914048 100644 (file)
--- a/arch/x86/kvm/i8254.c
+++ b/arch/x86/kvm/i8254.c
@@ -681,7 +681,7 @@ struct kvm_pit *kvm_create_pit(struct kvm *kvm, u32 flags)
        pid_nr = pid_vnr(pid);
        put_pid(pid);
 
-       pit->worker = kthread_create_worker(0, "kvm-pit/%d", pid_nr);
+       pit->worker = kthread_run_worker(0, "kvm-pit/%d", pid_nr);
        if (IS_ERR(pit->worker))
                goto fail_kthread;
 

diff --git a/crypto/crypto_engine.c b/crypto/crypto_engine.c
index e60a0eb628e8a03a49c389d142f8f4394f9f5c1c..c7c16da5e6496c82f59d9ba9bf0c3aeda4612def 100644 (file)
--- a/crypto/crypto_engine.c
+++ b/crypto/crypto_engine.c
@@ -517,7 +517,7 @@ struct crypto_engine *crypto_engine_alloc_init_and_set(struct device *dev,
        crypto_init_queue(&engine->queue, qlen);
        spin_lock_init(&engine->queue_lock);
 
-       engine->kworker = kthread_create_worker(0, "%s", engine->name);
+       engine->kworker = kthread_run_worker(0, "%s", engine->name);
        if (IS_ERR(engine->kworker)) {
                dev_err(dev, "failed to create crypto request pump task\n");
                return NULL;

diff --git a/drivers/cpufreq/cppc_cpufreq.c b/drivers/cpufreq/cppc_cpufreq.c
index bd8f75accfa01e705417cc4bc3f737db206acf7a..2486a6c5256ae93044d5e8e4c735b78fdd4f8c00 100644 (file)
--- a/drivers/cpufreq/cppc_cpufreq.c
+++ b/drivers/cpufreq/cppc_cpufreq.c
@@ -225,7 +225,7 @@ static void __init cppc_freq_invariance_init(void)
        if (fie_disabled)
                return;
 
-       kworker_fie = kthread_create_worker(0, "cppc_fie");
+       kworker_fie = kthread_run_worker(0, "cppc_fie");
        if (IS_ERR(kworker_fie)) {
                pr_warn("%s: failed to create kworker_fie: %ld\n", __func__,
                        PTR_ERR(kworker_fie));

diff --git a/drivers/gpu/drm/drm_vblank_work.c b/drivers/gpu/drm/drm_vblank_work.c
index 1752ffb44e1db7d8fd21e6f1e2c68123461747a9..9cc71120246ff200599c2ac99b9b50645bb78c1f 100644 (file)
--- a/drivers/gpu/drm/drm_vblank_work.c
+++ b/drivers/gpu/drm/drm_vblank_work.c
@@ -277,7 +277,7 @@ int drm_vblank_worker_init(struct drm_vblank_crtc *vblank)
 
        INIT_LIST_HEAD(&vblank->pending_work);
        init_waitqueue_head(&vblank->work_wait_queue);
-       worker = kthread_create_worker(0, "card%d-crtc%d",
+       worker = kthread_run_worker(0, "card%d-crtc%d",
                                       vblank->dev->primary->index,
                                       vblank->pipe);
        if (IS_ERR(worker))

diff --git a/drivers/gpu/drm/i915/gem/selftests/i915_gem_context.c b/drivers/gpu/drm/i915/gem/selftests/i915_gem_context.c
index 89d4dc8b60c6a28fc82c8ce0e2554c0a0e537e81..eb0158e434178259dc6884b2f4bf23e415156ac4 100644 (file)
--- a/drivers/gpu/drm/i915/gem/selftests/i915_gem_context.c
+++ b/drivers/gpu/drm/i915/gem/selftests/i915_gem_context.c
@@ -369,7 +369,7 @@ static int live_parallel_switch(void *arg)
                if (!data[n].ce[0])
                        continue;
 
-               worker = kthread_create_worker(0, "igt/parallel:%s",
+               worker = kthread_run_worker(0, "igt/parallel:%s",
                                               data[n].ce[0]->engine->name);
                if (IS_ERR(worker)) {
                        err = PTR_ERR(worker);

diff --git a/drivers/gpu/drm/i915/gt/selftest_execlists.c b/drivers/gpu/drm/i915/gt/selftest_execlists.c
index 222ca7c44951966bd85e948a073d5ebe3fbc74df..81c31396ecebc9aaaffd0207cb6e5d1d4c3dfebf 100644 (file)
--- a/drivers/gpu/drm/i915/gt/selftest_execlists.c
+++ b/drivers/gpu/drm/i915/gt/selftest_execlists.c
@@ -3574,7 +3574,7 @@ static int smoke_crescendo(struct preempt_smoke *smoke, unsigned int flags)
                        arg[id].batch = NULL;
                arg[id].count = 0;
 
-               worker[id] = kthread_create_worker(0, "igt/smoke:%d", id);
+               worker[id] = kthread_run_worker(0, "igt/smoke:%d", id);
                if (IS_ERR(worker[id])) {
                        err = PTR_ERR(worker[id]);
                        break;

diff --git a/drivers/gpu/drm/i915/gt/selftest_hangcheck.c b/drivers/gpu/drm/i915/gt/selftest_hangcheck.c
index 9ce8ff1c04fe5edbb2bd2736da19298f83ccb982..9d3aeb237295633114c8c1f94c31c81ab448d5f3 100644 (file)
--- a/drivers/gpu/drm/i915/gt/selftest_hangcheck.c
+++ b/drivers/gpu/drm/i915/gt/selftest_hangcheck.c
@@ -1025,7 +1025,7 @@ static int __igt_reset_engines(struct intel_gt *gt,
                        threads[tmp].engine = other;
                        threads[tmp].flags = flags;
 
-                       worker = kthread_create_worker(0, "igt/%s",
+                       worker = kthread_run_worker(0, "igt/%s",
                                                       other->name);
                        if (IS_ERR(worker)) {
                                err = PTR_ERR(worker);

diff --git a/drivers/gpu/drm/i915/gt/selftest_slpc.c b/drivers/gpu/drm/i915/gt/selftest_slpc.c
index 4ecc4ae74a54c4b2e1f4a32954fea8e582a082cc..e218b229681ff995caf2cc4f561babdab952667b 100644 (file)
--- a/drivers/gpu/drm/i915/gt/selftest_slpc.c
+++ b/drivers/gpu/drm/i915/gt/selftest_slpc.c
@@ -489,7 +489,7 @@ static int live_slpc_tile_interaction(void *arg)
                return -ENOMEM;
 
        for_each_gt(gt, i915, i) {
-               threads[i].worker = kthread_create_worker(0, "igt/slpc_parallel:%d", gt->info.id);
+               threads[i].worker = kthread_run_worker(0, "igt/slpc_parallel:%d", gt->info.id);
 
                if (IS_ERR(threads[i].worker)) {
                        ret = PTR_ERR(threads[i].worker);

diff --git a/drivers/gpu/drm/i915/selftests/i915_request.c b/drivers/gpu/drm/i915/selftests/i915_request.c
index acae30a04a947cea0eeb0abc775bf779c11e4d95..88870844b5bd9045fdc05e105df798e5e7d38d6e 100644 (file)
--- a/drivers/gpu/drm/i915/selftests/i915_request.c
+++ b/drivers/gpu/drm/i915/selftests/i915_request.c
@@ -492,7 +492,7 @@ static int mock_breadcrumbs_smoketest(void *arg)
        for (n = 0; n < ncpus; n++) {
                struct kthread_worker *worker;
 
-               worker = kthread_create_worker(0, "igt/%d", n);
+               worker = kthread_run_worker(0, "igt/%d", n);
                if (IS_ERR(worker)) {
                        ret = PTR_ERR(worker);
                        ncpus = n;
@@ -1645,7 +1645,7 @@ static int live_parallel_engines(void *arg)
                for_each_uabi_engine(engine, i915) {
                        struct kthread_worker *worker;
 
-                       worker = kthread_create_worker(0, "igt/parallel:%s",
+                       worker = kthread_run_worker(0, "igt/parallel:%s",
                                                       engine->name);
                        if (IS_ERR(worker)) {
                                err = PTR_ERR(worker);
@@ -1806,7 +1806,7 @@ static int live_breadcrumbs_smoketest(void *arg)
                        unsigned int i = idx * ncpus + n;
                        struct kthread_worker *worker;
 
-                       worker = kthread_create_worker(0, "igt/%d.%d", idx, n);
+                       worker = kthread_run_worker(0, "igt/%d.%d", idx, n);
                        if (IS_ERR(worker)) {
                                ret = PTR_ERR(worker);
                                goto out_flush;
@@ -3219,7 +3219,7 @@ static int perf_parallel_engines(void *arg)
 
                        memset(&engines[idx].p, 0, sizeof(engines[idx].p));
 
-                       worker = kthread_create_worker(0, "igt:%s",
+                       worker = kthread_run_worker(0, "igt:%s",
                                                       engine->name);
                        if (IS_ERR(worker)) {
                                err = PTR_ERR(worker);

diff --git a/drivers/gpu/drm/msm/disp/msm_disp_snapshot.c b/drivers/gpu/drm/msm/disp/msm_disp_snapshot.c
index e75b97127c0d18b2cbb9ee34c00d981eb73e6e3f..2be00b11e5573a5f728a32f75acc591eccae50f9 100644 (file)
--- a/drivers/gpu/drm/msm/disp/msm_disp_snapshot.c
+++ b/drivers/gpu/drm/msm/disp/msm_disp_snapshot.c
@@ -109,7 +109,7 @@ int msm_disp_snapshot_init(struct drm_device *drm_dev)
 
        mutex_init(&kms->dump_mutex);
 
-       kms->dump_worker = kthread_create_worker(0, "%s", "disp_snapshot");
+       kms->dump_worker = kthread_run_worker(0, "%s", "disp_snapshot");
        if (IS_ERR(kms->dump_worker))
                DRM_ERROR("failed to create disp state task\n");
 

diff --git a/drivers/gpu/drm/msm/msm_atomic.c b/drivers/gpu/drm/msm/msm_atomic.c
index 9c45d641b5212c11078ab38c13a519663d85e10a..a7a2384044ffdb13579cc9a10f56f8de9beca761 100644 (file)
--- a/drivers/gpu/drm/msm/msm_atomic.c
+++ b/drivers/gpu/drm/msm/msm_atomic.c
@@ -115,7 +115,7 @@ int msm_atomic_init_pending_timer(struct msm_pending_timer *timer,
        timer->kms = kms;
        timer->crtc_idx = crtc_idx;
 
-       timer->worker = kthread_create_worker(0, "atomic-worker-%d", crtc_idx);
+       timer->worker = kthread_run_worker(0, "atomic-worker-%d", crtc_idx);
        if (IS_ERR(timer->worker)) {
                int ret = PTR_ERR(timer->worker);
                timer->worker = NULL;

diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c
index 0d4a3744cfcbd2662d27f9929ff691581707325b..8557998e0c92ffde6a5206f67f93a4cb86763329 100644 (file)
--- a/drivers/gpu/drm/msm/msm_gpu.c
+++ b/drivers/gpu/drm/msm/msm_gpu.c
@@ -859,7 +859,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev,
        gpu->funcs = funcs;
        gpu->name = name;
 
-       gpu->worker = kthread_create_worker(0, "gpu-worker");
+       gpu->worker = kthread_run_worker(0, "gpu-worker");
        if (IS_ERR(gpu->worker)) {
                ret = PTR_ERR(gpu->worker);
                gpu->worker = NULL;

diff --git a/drivers/gpu/drm/msm/msm_kms.c b/drivers/gpu/drm/msm/msm_kms.c
index f3326d09bdbce19d40d0b48549c330c2b836476f..dac831ba6219d11613e165b6a2054c2305f1a1bf 100644 (file)
--- a/drivers/gpu/drm/msm/msm_kms.c
+++ b/drivers/gpu/drm/msm/msm_kms.c
@@ -269,7 +269,7 @@ int msm_drm_kms_init(struct device *dev, const struct drm_driver *drv)
                /* initialize event thread */
                ev_thread = &priv->event_thread[drm_crtc_index(crtc)];
                ev_thread->dev = ddev;
-               ev_thread->worker = kthread_create_worker(0, "crtc_event:%d", crtc->base.id);
+               ev_thread->worker = kthread_run_worker(0, "crtc_event:%d", crtc->base.id);
                if (IS_ERR(ev_thread->worker)) {
                        ret = PTR_ERR(ev_thread->worker);
                        DRM_DEV_ERROR(dev, "failed to create crtc_event kthread\n");

diff --git a/drivers/media/platform/chips-media/wave5/wave5-vpu.c b/drivers/media/platform/chips-media/wave5/wave5-vpu.c
index 6b294a2d671781cc192cb39a9ae7a3ba59d52a63..d1320298a0f7670ebf3978047ada32f8ffb7ce46 100644 (file)
--- a/drivers/media/platform/chips-media/wave5/wave5-vpu.c
+++ b/drivers/media/platform/chips-media/wave5/wave5-vpu.c
@@ -271,7 +271,7 @@ static int wave5_vpu_probe(struct platform_device *pdev)
                dev_err(&pdev->dev, "failed to get irq resource, falling back to polling\n");
                hrtimer_init(&dev->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_PINNED);
                dev->hrtimer.function = &wave5_vpu_timer_callback;
-               dev->worker = kthread_create_worker(0, "vpu_irq_thread");
+               dev->worker = kthread_run_worker(0, "vpu_irq_thread");
                if (IS_ERR(dev->worker)) {
                        dev_err(&pdev->dev, "failed to create vpu irq worker\n");
                        ret = PTR_ERR(dev->worker);

diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c
index 3a792f79270d9970a759f54635dc920fafed354d..377e66cf7a482467f0a51d902dd4867f8d5daeae 100644 (file)
--- a/drivers/net/dsa/mv88e6xxx/chip.c
+++ b/drivers/net/dsa/mv88e6xxx/chip.c
@@ -394,7 +394,7 @@ static int mv88e6xxx_irq_poll_setup(struct mv88e6xxx_chip *chip)
        kthread_init_delayed_work(&chip->irq_poll_work,
                                  mv88e6xxx_irq_poll);
 
-       chip->kworker = kthread_create_worker(0, "%s", dev_name(chip->dev));
+       chip->kworker = kthread_run_worker(0, "%s", dev_name(chip->dev));
        if (IS_ERR(chip->kworker))
                return PTR_ERR(chip->kworker);
 

diff --git a/drivers/net/ethernet/intel/ice/ice_dpll.c b/drivers/net/ethernet/intel/ice/ice_dpll.c
index d5ad6d84007c21551d0a18a66bfea06b8922769d..75570be61fef2bcc6cdcd6c99e6197338902ab46 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_dpll.c
+++ b/drivers/net/ethernet/intel/ice/ice_dpll.c
@@ -2053,7 +2053,7 @@ static int ice_dpll_init_worker(struct ice_pf *pf)
        struct kthread_worker *kworker;
 
        kthread_init_delayed_work(&d->work, ice_dpll_periodic_work);
-       kworker = kthread_create_worker(0, "ice-dplls-%s",
+       kworker = kthread_run_worker(0, "ice-dplls-%s",
                                        dev_name(ice_pf_to_dev(pf)));
        if (IS_ERR(kworker))
                return PTR_ERR(kworker);

diff --git a/drivers/net/ethernet/intel/ice/ice_gnss.c b/drivers/net/ethernet/intel/ice/ice_gnss.c
index f02e8ca5537507b631d39d727efebfeab1e272a8..b2148dbe49b28403ae7eb9e98475402798944b41 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_gnss.c
+++ b/drivers/net/ethernet/intel/ice/ice_gnss.c
@@ -182,7 +182,7 @@ static struct gnss_serial *ice_gnss_struct_init(struct ice_pf *pf)
        pf->gnss_serial = gnss;
 
        kthread_init_delayed_work(&gnss->read_work, ice_gnss_read);
-       kworker = kthread_create_worker(0, "ice-gnss-%s", dev_name(dev));
+       kworker = kthread_run_worker(0, "ice-gnss-%s", dev_name(dev));
        if (IS_ERR(kworker)) {
                kfree(gnss);
                return NULL;

diff --git a/drivers/net/ethernet/intel/ice/ice_ptp.c b/drivers/net/ethernet/intel/ice/ice_ptp.c
index a999fface2728184bbf16f846cacee582757d06c..3154bb674dd3dda97cec4d4afe53e47e6abb1c84 100644 (file)
--- a/drivers/net/ethernet/intel/ice/ice_ptp.c
+++ b/drivers/net/ethernet/intel/ice/ice_ptp.c
@@ -3080,7 +3080,7 @@ static int ice_ptp_init_work(struct ice_pf *pf, struct ice_ptp *ptp)
        /* Allocate a kworker for handling work required for the ports
         * connected to the PTP hardware clock.
         */
-       kworker = kthread_create_worker(0, "ice-ptp-%s",
+       kworker = kthread_run_worker(0, "ice-ptp-%s",
                                        dev_name(ice_pf_to_dev(pf)));
        if (IS_ERR(kworker))
                return PTR_ERR(kworker);

diff --git a/drivers/platform/chrome/cros_ec_spi.c b/drivers/platform/chrome/cros_ec_spi.c
index 86a3d32a7763227620e64346f2a014ef64e7feb2..08f566cc14800595d8dab8fa498d67f2d075541e 100644 (file)
--- a/drivers/platform/chrome/cros_ec_spi.c
+++ b/drivers/platform/chrome/cros_ec_spi.c
@@ -715,7 +715,7 @@ static int cros_ec_spi_devm_high_pri_alloc(struct device *dev,
        int err;
 
        ec_spi->high_pri_worker =
-               kthread_create_worker(0, "cros_ec_spi_high_pri");
+               kthread_run_worker(0, "cros_ec_spi_high_pri");
 
        if (IS_ERR(ec_spi->high_pri_worker)) {
                err = PTR_ERR(ec_spi->high_pri_worker);

diff --git a/drivers/ptp/ptp_clock.c b/drivers/ptp/ptp_clock.c
index 77a36e7bddd54e8f45eab317e687f033f57cc5bc..b932425ddc6a3789504164a69d1b8eba47da462c 100644 (file)
--- a/drivers/ptp/ptp_clock.c
+++ b/drivers/ptp/ptp_clock.c
@@ -296,7 +296,7 @@ struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info,
 
        if (ptp->info->do_aux_work) {
                kthread_init_delayed_work(&ptp->aux_work, ptp_aux_kworker);
-               ptp->kworker = kthread_create_worker(0, "ptp%d", ptp->index);
+               ptp->kworker = kthread_run_worker(0, "ptp%d", ptp->index);
                if (IS_ERR(ptp->kworker)) {
                        err = PTR_ERR(ptp->kworker);
                        pr_err("failed to create ptp aux_worker %d\n", err);

diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index ff1add2ecb91f18cf82e6f1e9595584c11adf9d8..e4aa8f8389344b33b153a68b8621dddaa56b295e 100644 (file)
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -2060,7 +2060,7 @@ static int spi_init_queue(struct spi_controller *ctlr)
        ctlr->busy = false;
        ctlr->queue_empty = true;
 
-       ctlr->kworker = kthread_create_worker(0, dev_name(&ctlr->dev));
+       ctlr->kworker = kthread_run_worker(0, dev_name(&ctlr->dev));
        if (IS_ERR(ctlr->kworker)) {
                dev_err(&ctlr->dev, "failed to create message pump kworker\n");
                return PTR_ERR(ctlr->kworker);

diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index 6021eeb903fec53316dfa2d6b825c334d55b7cab..95c0c63119ac236e044c79007efba1d819f67c9e 100644 (file)
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -7635,7 +7635,7 @@ struct tcpm_port *tcpm_register_port(struct device *dev, struct tcpc_dev *tcpc)
        mutex_init(&port->lock);
        mutex_init(&port->swap_lock);
 
-       port->wq = kthread_create_worker(0, dev_name(dev));
+       port->wq = kthread_run_worker(0, dev_name(dev));
        if (IS_ERR(port->wq))
                return ERR_CAST(port->wq);
        sched_set_fifo(port->wq->task);

diff --git a/drivers/vdpa/vdpa_sim/vdpa_sim.c b/drivers/vdpa/vdpa_sim/vdpa_sim.c
index 8ffea8430f95fec128759fbcca2698dbdabf4179..c204fc8e471a74c7b37c57b8c39ae70caf4a627d 100644 (file)
--- a/drivers/vdpa/vdpa_sim/vdpa_sim.c
+++ b/drivers/vdpa/vdpa_sim/vdpa_sim.c
@@ -229,7 +229,7 @@ struct vdpasim *vdpasim_create(struct vdpasim_dev_attr *dev_attr,
        dev = &vdpasim->vdpa.dev;
 
        kthread_init_work(&vdpasim->work, vdpasim_work_fn);
-       vdpasim->worker = kthread_create_worker(0, "vDPA sim worker: %s",
+       vdpasim->worker = kthread_run_worker(0, "vDPA sim worker: %s",
                                                dev_attr->name);
        if (IS_ERR(vdpasim->worker))
                goto err_iommu;

diff --git a/drivers/watchdog/watchdog_dev.c b/drivers/watchdog/watchdog_dev.c
index 4190cb800cc45df48ab0a188f7e592d9b17c77ed..19698d87dc5728003d5aa29d2efb1b4dac9fdf09 100644 (file)
--- a/drivers/watchdog/watchdog_dev.c
+++ b/drivers/watchdog/watchdog_dev.c
@@ -1229,7 +1229,7 @@ int __init watchdog_dev_init(void)
 {
        int err;
 
-       watchdog_kworker = kthread_create_worker(0, "watchdogd");
+       watchdog_kworker = kthread_run_worker(0, "watchdogd");
        if (IS_ERR(watchdog_kworker)) {
                pr_err("Failed to create watchdog kworker\n");
                return PTR_ERR(watchdog_kworker);

diff --git a/fs/erofs/zdata.c b/fs/erofs/zdata.c
index a23392327ce2b7437b3ce2f0b70418592f49ee89..35381c00ee09984d62c858e3f4145b26dea1a3b4 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");
+               kthread_run_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 0c66e7c1092a929870cd2884f86feb55ac3e961b..8d27403888ce93fd655e631f6d5ebbdf6e520e2b 100644 (file)
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -193,19 +193,53 @@ struct kthread_worker *kthread_create_worker_on_node(unsigned int flags,
                                                     const char namefmt[], ...);
 
 #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;                                                              \
+       kthread_create_worker_on_node(flags, NUMA_NO_NODE, namefmt, ## __VA_ARGS__);
+
+/**
+ * kthread_run_worker - create and wake a kthread worker.
+ * @flags: flags modifying the default behavior of the worker
+ * @namefmt: printf-style name for the thread.
+ *
+ * Description: Convenient wrapper for kthread_create_worker() followed by
+ * wake_up_process().  Returns the kthread_worker or ERR_PTR(-ENOMEM).
+ */
+#define kthread_run_worker(flags, namefmt, ...)                                        \
+({                                                                             \
+       struct kthread_worker *__kw                                             \
+               = kthread_create_worker(flags, 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[]);
 
+/**
+ * kthread_run_worker_on_cpu - create and wake a cpu bound kthread worker.
+ * @cpu: CPU number
+ * @flags: flags modifying the default behavior of the worker
+ * @namefmt: printf-style name for the thread. Format is restricted
+ *          to "name.*%u". Code fills in cpu number.
+ *
+ * Description: Convenient wrapper for kthread_create_worker_on_cpu()
+ * followed by wake_up_process().  Returns the kthread_worker or
+ * ERR_PTR(-ENOMEM).
+ */
+static inline struct kthread_worker *
+kthread_run_worker_on_cpu(int cpu, unsigned int flags,
+                         const char namefmt[])
+{
+       struct kthread_worker *kw;
+
+       kw = kthread_create_worker_on_cpu(cpu, flags, namefmt);
+       if (!IS_ERR(kw))
+               wake_up_process(kw->task);
+
+       return kw;
+}
+
 bool kthread_queue_work(struct kthread_worker *worker,
                        struct kthread_work *work);
 

diff --git a/kernel/kthread.c b/kernel/kthread.c
index 2d52126d5da0a860617b20b8426aa5c9169744ac..922f15762ec3d20e857a0aebd6defef9e1a55879 100644 (file)
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -1077,33 +1077,10 @@ kthread_create_worker_on_node(unsigned int flags, int node, const char 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_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;
-}
-
 /**
  * kthread_create_worker_on_cpu - create a kthread worker and bind it
  *     to a given CPU and the associated NUMA node.
@@ -1144,7 +1121,13 @@ struct kthread_worker *
 kthread_create_worker_on_cpu(int cpu, unsigned int flags,
                             const char namefmt[])
 {
-       return __kthread_create_worker_on_cpu(cpu, flags, namefmt, cpu);
+       struct kthread_worker *worker;
+
+       worker = kthread_create_worker_on_node(flags, cpu_to_node(cpu), namefmt, cpu);
+       if (!IS_ERR(worker))
+               kthread_bind(worker->task, cpu);
+
+       return worker;
 }
 EXPORT_SYMBOL(kthread_create_worker_on_cpu);
 

diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
index 4a4c498210588b03428ef176d2b52c7e2fc3f972..d4b8e87a473b809d8a7527a043bc1221eb6c0b01 100644 (file)
--- a/kernel/rcu/tree.c
+++ b/kernel/rcu/tree.c
@@ -4906,7 +4906,7 @@ static void rcu_spawn_exp_par_gp_kworker(struct rcu_node *rnp)
        if (rnp->exp_kworker)
                return;
 
-       kworker = kthread_create_worker(0, name, rnp_index);
+       kworker = kthread_run_worker(0, name, rnp_index);
        if (IS_ERR_OR_NULL(kworker)) {
                pr_err("Failed to create par gp kworker on %d/%d\n",
                       rnp->grplo, rnp->grphi);
@@ -4933,7 +4933,7 @@ static void __init rcu_start_exp_gp_kworker(void)
        const char *name = "rcu_exp_gp_kthread_worker";
        struct sched_param param = { .sched_priority = kthread_prio };
 
-       rcu_exp_gp_kworker = kthread_create_worker(0, name);
+       rcu_exp_gp_kworker = kthread_run_worker(0, name);
        if (IS_ERR_OR_NULL(rcu_exp_gp_kworker)) {
                pr_err("Failed to create %s!\n", name);
                rcu_exp_gp_kworker = NULL;

diff --git a/kernel/sched/ext.c b/kernel/sched/ext.c
index 7fff1d0454770f5fab3e13708816d56653637ee9..ab8962d2e9d3158eb520d14925329317bbaf7d29 100644 (file)
--- a/kernel/sched/ext.c
+++ b/kernel/sched/ext.c
@@ -5352,7 +5352,7 @@ static struct kthread_worker *scx_create_rt_helper(const char *name)
 {
        struct kthread_worker *helper;
 
-       helper = kthread_create_worker(0, name);
+       helper = kthread_run_worker(0, name);
        if (helper)
                sched_set_fifo(helper->task);
        return helper;

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 8b07576814a58d984de79e32791030db877c4e7c..fe01c1f8095cd922b83bd67c6294fed41c1a5792 100644 (file)
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -7828,7 +7828,7 @@ static void __init wq_cpu_intensive_thresh_init(void)
        unsigned long thresh;
        unsigned long bogo;
 
-       pwq_release_worker = kthread_create_worker(0, "pool_workqueue_release");
+       pwq_release_worker = kthread_run_worker(0, "pool_workqueue_release");
        BUG_ON(IS_ERR(pwq_release_worker));
 
        /* if the user set it to a specific value, keep it */

diff --git a/net/dsa/tag_ksz.c b/net/dsa/tag_ksz.c
index 281bbac5539d107a13cdadf5ee7f22bb3123b915..c33d4bf179297c4296ca0ec309e203773d93f673 100644 (file)
--- a/net/dsa/tag_ksz.c
+++ b/net/dsa/tag_ksz.c
@@ -66,7 +66,7 @@ static int ksz_connect(struct dsa_switch *ds)
        if (!priv)
                return -ENOMEM;
 
-       xmit_worker = kthread_create_worker(0, "dsa%d:%d_xmit",
+       xmit_worker = kthread_run_worker(0, "dsa%d:%d_xmit",
                                            ds->dst->index, ds->index);
        if (IS_ERR(xmit_worker)) {
                ret = PTR_ERR(xmit_worker);

diff --git a/net/dsa/tag_ocelot_8021q.c b/net/dsa/tag_ocelot_8021q.c
index 8e8b1bef6af69d726cdf63f71dc7dfaaef238b30..6ce0bc16679207555b2555a3d4ec716862c3f07a 100644 (file)
--- a/net/dsa/tag_ocelot_8021q.c
+++ b/net/dsa/tag_ocelot_8021q.c
@@ -110,7 +110,7 @@ static int ocelot_connect(struct dsa_switch *ds)
        if (!priv)
                return -ENOMEM;
 
-       priv->xmit_worker = kthread_create_worker(0, "felix_xmit");
+       priv->xmit_worker = kthread_run_worker(0, "felix_xmit");
        if (IS_ERR(priv->xmit_worker)) {
                err = PTR_ERR(priv->xmit_worker);
                kfree(priv);

diff --git a/net/dsa/tag_sja1105.c b/net/dsa/tag_sja1105.c
index 3e902af7eea645c4992b11957c95930690bd915a..02adec6938110c557fa5740293a3032b8cac424c 100644 (file)
--- a/net/dsa/tag_sja1105.c
+++ b/net/dsa/tag_sja1105.c
@@ -707,7 +707,7 @@ static int sja1105_connect(struct dsa_switch *ds)
 
        spin_lock_init(&priv->meta_lock);
 
-       xmit_worker = kthread_create_worker(0, "dsa%d:%d_xmit",
+       xmit_worker = kthread_run_worker(0, "dsa%d:%d_xmit",
                                            ds->dst->index, ds->index);
        if (IS_ERR(xmit_worker)) {
                err = PTR_ERR(xmit_worker);