[PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Bradley Morgan]

kthread_worker_fn() has carried a FIXME for a decade: it assigns
worker->task = current because the old kthread_run(kthread_worker_fn)
callers never told the worker what task it was. The new
kthread_create_worker*() API sets worker->task before the worker
starts, so the self assignment is dead code.

This series converts the four remaining users of the old pattern
(ivtv, encx24j600, sc16is7xx, cpufreq_schedutil) to the new API,
then removes the self assignment from kthread_worker_fn() while
keeping a WARN_ON() as a sanity check for any out-of-tree users.

v1 -> v2:
- Keep WARN_ON() as a bare sanity check (Frederic, Peter)
- Add comment explaining why the WARN_ON() is there
- Fix subject and changelog wording

Bradley Morgan (5):
  media: ivtv: convert to kthread_run_worker
  net: encx24j600: convert to kthread_run_worker
  tty: sc16is7xx: convert to kthread_run_worker
  cpufreq: schedutil: convert to kthread_create_worker
  kthread: remove worker->task self assignment

 drivers/media/pci/ivtv/ivtv-driver.c        | 14 ++++----
 drivers/media/pci/ivtv/ivtv-driver.h        |  3 +-
 drivers/net/ethernet/microchip/encx24j600.c | 20 +++++------
 drivers/tty/serial/sc16is7xx.c              | 39 ++++++++++-----------
 kernel/kthread.c                            |  8 ++---
 kernel/sched/cpufreq_schedutil.c            | 33 ++++++++---------
 6 files changed, 50 insertions(+), 67 deletions(-)

-- 
2.47.3

[PATCH v2 1/5] media: ivtv: convert to kthread_run_worker

[Bradley Morgan]

Convert ivtv to use kthread_run_worker() instead of the deprecated
kthread_run(kthread_worker_fn) pattern. The new API sets worker->task
before the worker starts.

Signed-off-by: Bradley Morgan <brads@mainlining.org>
---
 drivers/media/pci/ivtv/ivtv-driver.c | 14 ++++++--------
 drivers/media/pci/ivtv/ivtv-driver.h |  3 +--
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/drivers/media/pci/ivtv/ivtv-driver.c b/drivers/media/pci/ivtv/ivtv-driver.c
index b9ea56ec9593..6f0e0e46deb5 100644
--- a/drivers/media/pci/ivtv/ivtv-driver.c
+++ b/drivers/media/pci/ivtv/ivtv-driver.c
@@ -703,15 +703,13 @@ static int ivtv_init_struct1(struct ivtv *itv)
 	spin_lock_init(&itv->lock);
 	spin_lock_init(&itv->dma_reg_lock);
 
-	kthread_init_worker(&itv->irq_worker);
-	itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
-					   "%s", itv->v4l2_dev.name);
-	if (IS_ERR(itv->irq_worker_task)) {
+	itv->irq_worker = kthread_run_worker(0, "%s", itv->v4l2_dev.name);
+	if (IS_ERR(itv->irq_worker)) {
 		IVTV_ERR("Could not create ivtv task\n");
 		return -1;
 	}
 	/* must use the FIFO scheduler as it is realtime sensitive */
-	sched_set_fifo(itv->irq_worker_task);
+	sched_set_fifo(itv->irq_worker->task);
 
 	kthread_init_work(&itv->irq_work, ivtv_irq_work_handler);
 
@@ -1232,7 +1230,7 @@ static int ivtv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
 	v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
 	exit_ivtv_i2c(itv);
 free_worker:
-	kthread_stop(itv->irq_worker_task);
+	kthread_destroy_worker(itv->irq_worker);
 err:
 	if (retval == 0)
 		retval = -ENODEV;
@@ -1372,8 +1370,8 @@ static void ivtv_remove(struct pci_dev *pdev)
 	timer_shutdown_sync(&itv->dma_timer);
 
 	/* Kill irq worker */
-	kthread_flush_worker(&itv->irq_worker);
-	kthread_stop(itv->irq_worker_task);
+	kthread_flush_worker(itv->irq_worker);
+	kthread_destroy_worker(itv->irq_worker);
 
 	ivtv_streams_cleanup(itv);
 	ivtv_udma_free(itv);
diff --git a/drivers/media/pci/ivtv/ivtv-driver.h b/drivers/media/pci/ivtv/ivtv-driver.h
index 000e8beecc7c..091bc44f13bc 100644
--- a/drivers/media/pci/ivtv/ivtv-driver.h
+++ b/drivers/media/pci/ivtv/ivtv-driver.h
@@ -668,8 +668,7 @@ struct ivtv {
 	/* Interrupts & DMA */
 	u32 irqmask;                    /* active interrupts */
 	u32 irq_rr_idx;                 /* round-robin stream index */
-	struct kthread_worker irq_worker;		/* kthread worker for PIO/YUV/VBI actions */
-	struct task_struct *irq_worker_task;		/* task for irq_worker */
+	struct kthread_worker *irq_worker;		/* kthread worker for PIO/YUV/VBI actions */
 	struct kthread_work irq_work;	/* kthread work entry */
 	spinlock_t dma_reg_lock;        /* lock access to DMA engine registers */
 	int cur_dma_stream;		/* index of current stream doing DMA (-1 if none) */
-- 
2.47.3

[PATCH v2 2/5] net: encx24j600: convert to kthread_run_worker

[Bradley Morgan]

Convert encx24j600 to use kthread_run_worker() instead of the
deprecated kthread_run(kthread_worker_fn) pattern. The new API sets
worker->task before the worker starts.

Signed-off-by: Bradley Morgan <brads@mainlining.org>
---
 drivers/net/ethernet/microchip/encx24j600.c | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/drivers/net/ethernet/microchip/encx24j600.c b/drivers/net/ethernet/microchip/encx24j600.c
index b011bf5c2305..460189064332 100644
--- a/drivers/net/ethernet/microchip/encx24j600.c
+++ b/drivers/net/ethernet/microchip/encx24j600.c
@@ -49,8 +49,7 @@ struct encx24j600_priv {
 	struct mutex              lock; /* device access lock */
 	struct encx24j600_context ctx;
 	struct sk_buff           *tx_skb;
-	struct task_struct       *kworker_task;
-	struct kthread_worker     kworker;
+	struct kthread_worker    *kworker;
 	struct kthread_work       tx_work;
 	struct kthread_work       setrx_work;
 	u16                       next_packet;
@@ -823,7 +822,7 @@ static void encx24j600_set_multicast_list(struct net_device *dev)
 	}
 
 	if (oldfilter != priv->rxfilter)
-		kthread_queue_work(&priv->kworker, &priv->setrx_work);
+		kthread_queue_work(priv->kworker, &priv->setrx_work);
 }
 
 static void encx24j600_hw_tx(struct encx24j600_priv *priv)
@@ -884,7 +883,7 @@ static netdev_tx_t encx24j600_tx(struct sk_buff *skb, struct net_device *dev)
 	/* Remember the skb for deferred processing */
 	priv->tx_skb = skb;
 
-	kthread_queue_work(&priv->kworker, &priv->tx_work);
+	kthread_queue_work(priv->kworker, &priv->tx_work);
 
 	return NETDEV_TX_OK;
 }
@@ -1046,15 +1045,12 @@ static int encx24j600_spi_probe(struct spi_device *spi)
 	/* Initialize the device HW to the consistent state */
 	encx24j600_hw_init(priv);
 
-	kthread_init_worker(&priv->kworker);
 	kthread_init_work(&priv->tx_work, encx24j600_tx_proc);
 	kthread_init_work(&priv->setrx_work, encx24j600_setrx_proc);
 
-	priv->kworker_task = kthread_run(kthread_worker_fn, &priv->kworker,
-					 "encx24j600");
-
-	if (IS_ERR(priv->kworker_task)) {
-		ret = PTR_ERR(priv->kworker_task);
+	priv->kworker = kthread_run_worker(0, "encx24j600");
+	if (IS_ERR(priv->kworker)) {
+		ret = PTR_ERR(priv->kworker);
 		goto out_free;
 	}
 
@@ -1087,7 +1083,7 @@ static int encx24j600_spi_probe(struct spi_device *spi)
 out_unregister:
 	unregister_netdev(priv->ndev);
 out_stop:
-	kthread_stop(priv->kworker_task);
+	kthread_destroy_worker(priv->kworker);
 out_free:
 	free_netdev(ndev);
 
@@ -1100,7 +1096,7 @@ static void encx24j600_spi_remove(struct spi_device *spi)
 	struct encx24j600_priv *priv = dev_get_drvdata(&spi->dev);
 
 	unregister_netdev(priv->ndev);
-	kthread_stop(priv->kworker_task);
+	kthread_destroy_worker(priv->kworker);
 
 	free_netdev(priv->ndev);
 }
-- 
2.47.3

[PATCH v2 4/5] cpufreq: schedutil: convert to kthread_create_worker

[Bradley Morgan]

Convert cpufreq_schedutil to use kthread_create_worker() instead of
the deprecated kthread_run(kthread_worker_fn) pattern. The new API
sets worker->task before the worker starts.

Signed-off-by: Bradley Morgan <brads@mainlining.org>
---
 kernel/sched/cpufreq_schedutil.c | 33 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index 49ccd6f1c185..5023c24d8a21 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -31,8 +31,7 @@ struct sugov_policy {
 	struct			irq_work irq_work;
 	struct			kthread_work work;
 	struct			mutex work_lock;
-	struct			kthread_worker worker;
-	struct task_struct	*thread;
+	struct			kthread_worker *worker;
 	bool			work_in_progress;
 
 	bool			limits_changed;
@@ -586,7 +585,7 @@ static void sugov_irq_work(struct irq_work *irq_work)
 
 	sg_policy = container_of(irq_work, struct sugov_policy, irq_work);
 
-	kthread_queue_work(&sg_policy->worker, &sg_policy->work);
+	kthread_queue_work(sg_policy->worker, &sg_policy->work);
 }
 
 /************************** sysfs interface ************************/
@@ -669,7 +668,6 @@ static void sugov_policy_free(struct sugov_policy *sg_policy)
 
 static int sugov_kthread_create(struct sugov_policy *sg_policy)
 {
-	struct task_struct *thread;
 	struct sched_attr attr = {
 		.size		= sizeof(struct sched_attr),
 		.sched_policy	= SCHED_DEADLINE,
@@ -692,32 +690,29 @@ static int sugov_kthread_create(struct sugov_policy *sg_policy)
 		return 0;
 
 	kthread_init_work(&sg_policy->work, sugov_work);
-	kthread_init_worker(&sg_policy->worker);
-	thread = kthread_create(kthread_worker_fn, &sg_policy->worker,
-				"sugov:%d",
-				cpumask_first(policy->related_cpus));
-	if (IS_ERR(thread)) {
-		pr_err("failed to create sugov thread: %pe\n", thread);
-		return PTR_ERR(thread);
+	sg_policy->worker = kthread_create_worker(0, "sugov:%d",
+						cpumask_first(policy->related_cpus));
+	if (IS_ERR(sg_policy->worker)) {
+		pr_err("failed to create sugov thread: %pe\n", sg_policy->worker);
+		return PTR_ERR(sg_policy->worker);
 	}
 
-	ret = sched_setattr_nocheck(thread, &attr);
+	ret = sched_setattr_nocheck(sg_policy->worker->task, &attr);
 	if (ret) {
-		kthread_stop(thread);
+		kthread_destroy_worker(sg_policy->worker);
 		pr_warn("%s: failed to set SCHED_DEADLINE\n", __func__);
 		return ret;
 	}
 
-	sg_policy->thread = thread;
 	if (policy->dvfs_possible_from_any_cpu)
-		set_cpus_allowed_ptr(thread, policy->related_cpus);
+		set_cpus_allowed_ptr(sg_policy->worker->task, policy->related_cpus);
 	else
-		kthread_bind_mask(thread, policy->related_cpus);
+		kthread_bind_mask(sg_policy->worker->task, policy->related_cpus);
 
 	init_irq_work(&sg_policy->irq_work, sugov_irq_work);
 	mutex_init(&sg_policy->work_lock);
 
-	wake_up_process(thread);
+	wake_up_process(sg_policy->worker->task);
 
 	return 0;
 }
@@ -728,8 +723,8 @@ static void sugov_kthread_stop(struct sugov_policy *sg_policy)
 	if (sg_policy->policy->fast_switch_enabled)
 		return;
 
-	kthread_flush_worker(&sg_policy->worker);
-	kthread_stop(sg_policy->thread);
+	kthread_flush_worker(sg_policy->worker);
+	kthread_destroy_worker(sg_policy->worker);
 	mutex_destroy(&sg_policy->work_lock);
 }
 
-- 
2.47.3

[PATCH v2 3/5] tty: sc16is7xx: convert to kthread_run_worker

[Bradley Morgan]

Convert sc16is7xx to use kthread_run_worker() instead of the
deprecated kthread_run(kthread_worker_fn) pattern. The new API sets
worker->task before the worker starts.

Signed-off-by: Bradley Morgan <brads@mainlining.org>
---
 drivers/tty/serial/sc16is7xx.c | 39 ++++++++++++++++------------------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/drivers/tty/serial/sc16is7xx.c b/drivers/tty/serial/sc16is7xx.c
index 7107a0fb1e7b..2cfc1f290009 100644
--- a/drivers/tty/serial/sc16is7xx.c
+++ b/drivers/tty/serial/sc16is7xx.c
@@ -306,8 +306,7 @@ struct sc16is7xx_port {
 	unsigned long			gpio_valid_mask;
 #endif
 	u8				mctrl_mask;
-	struct kthread_worker		kworker;
-	struct task_struct		*kworker_task;
+	struct kthread_worker		*kworker;
 	struct kthread_delayed_work	poll_work;
 	bool				polling;
 	struct sc16is7xx_one		p[];
@@ -434,7 +433,7 @@ static void sc16is7xx_ier_clear(struct uart_port *port, u8 bit)
 	one->config.flags |= SC16IS7XX_RECONF_IER;
 	one->config.ier_mask |= bit;
 	one->config.ier_val &= ~bit;
-	kthread_queue_work(&s->kworker, &one->reg_work);
+	kthread_queue_work(s->kworker, &one->reg_work);
 }
 
 static void sc16is7xx_ier_set(struct uart_port *port, u8 bit)
@@ -447,7 +446,7 @@ static void sc16is7xx_ier_set(struct uart_port *port, u8 bit)
 	one->config.flags |= SC16IS7XX_RECONF_IER;
 	one->config.ier_mask |= bit;
 	one->config.ier_val |= bit;
-	kthread_queue_work(&s->kworker, &one->reg_work);
+	kthread_queue_work(s->kworker, &one->reg_work);
 }
 
 static void sc16is7xx_stop_tx(struct uart_port *port)
@@ -813,7 +812,7 @@ static void sc16is7xx_poll_proc(struct kthread_work *ws)
 	sc16is7xx_irq(0, s);
 
 	/* Setup delay based on SC16IS7XX_POLL_PERIOD_MS */
-	kthread_queue_delayed_work(&s->kworker, &s->poll_work,
+	kthread_queue_delayed_work(s->kworker, &s->poll_work,
 				   msecs_to_jiffies(SC16IS7XX_POLL_PERIOD_MS));
 }
 
@@ -900,7 +899,7 @@ static void sc16is7xx_ms_proc(struct kthread_work *ws)
 		scoped_guard(mutex, &one->lock)
 			sc16is7xx_update_mlines(one);
 
-		kthread_queue_delayed_work(&s->kworker, &one->ms_work, HZ);
+		kthread_queue_delayed_work(s->kworker, &one->ms_work, HZ);
 	}
 }
 
@@ -911,7 +910,7 @@ static void sc16is7xx_enable_ms(struct uart_port *port)
 
 	lockdep_assert_held_once(&port->lock);
 
-	kthread_queue_delayed_work(&s->kworker, &one->ms_work, 0);
+	kthread_queue_delayed_work(s->kworker, &one->ms_work, 0);
 }
 
 static void sc16is7xx_start_tx(struct uart_port *port)
@@ -919,7 +918,7 @@ static void sc16is7xx_start_tx(struct uart_port *port)
 	struct sc16is7xx_port *s = dev_get_drvdata(port->dev);
 	struct sc16is7xx_one *one = to_sc16is7xx_one(port);
 
-	kthread_queue_work(&s->kworker, &one->tx_work);
+	kthread_queue_work(s->kworker, &one->tx_work);
 }
 
 static void sc16is7xx_throttle(struct uart_port *port)
@@ -968,7 +967,7 @@ static void sc16is7xx_set_mctrl(struct uart_port *port, unsigned int mctrl)
 	struct sc16is7xx_one *one = to_sc16is7xx_one(port);
 
 	one->config.flags |= SC16IS7XX_RECONF_MD;
-	kthread_queue_work(&s->kworker, &one->reg_work);
+	kthread_queue_work(s->kworker, &one->reg_work);
 }
 
 static void sc16is7xx_break_ctl(struct uart_port *port, int break_state)
@@ -1098,7 +1097,7 @@ static int sc16is7xx_config_rs485(struct uart_port *port, struct ktermios *termi
 	}
 
 	one->config.flags |= SC16IS7XX_RECONF_RS485;
-	kthread_queue_work(&s->kworker, &one->reg_work);
+	kthread_queue_work(s->kworker, &one->reg_work);
 
 	return 0;
 }
@@ -1159,7 +1158,7 @@ static int sc16is7xx_startup(struct uart_port *port)
 	uart_port_unlock_irqrestore(port, flags);
 
 	if (s->polling)
-		kthread_queue_delayed_work(&s->kworker, &s->poll_work,
+		kthread_queue_delayed_work(s->kworker, &s->poll_work,
 					   msecs_to_jiffies(SC16IS7XX_POLL_PERIOD_MS));
 
 	return 0;
@@ -1186,7 +1185,7 @@ static void sc16is7xx_shutdown(struct uart_port *port)
 	if (s->polling)
 		kthread_cancel_delayed_work_sync(&s->poll_work);
 
-	kthread_flush_worker(&s->kworker);
+	kthread_flush_worker(s->kworker);
 }
 
 static const char *sc16is7xx_type(struct uart_port *port)
@@ -1595,14 +1594,12 @@ int sc16is7xx_probe(struct device *dev, const struct sc16is7xx_devtype *devtype,
 	s->devtype = devtype;
 	dev_set_drvdata(dev, s);
 
-	kthread_init_worker(&s->kworker);
-	s->kworker_task = kthread_run(kthread_worker_fn, &s->kworker,
-				      "sc16is7xx");
-	if (IS_ERR(s->kworker_task)) {
-		ret = PTR_ERR(s->kworker_task);
+	s->kworker = kthread_run_worker(0, "sc16is7xx");
+	if (IS_ERR(s->kworker)) {
+		ret = PTR_ERR(s->kworker);
 		goto out_clk;
 	}
-	sched_set_fifo(s->kworker_task);
+	sched_set_fifo(s->kworker->task);
 
 	ret = sc16is7xx_reset(dev, regmaps[0]);
 	if (ret)
@@ -1676,7 +1673,7 @@ int sc16is7xx_probe(struct device *dev, const struct sc16is7xx_devtype *devtype,
 	}
 
 out_kthread:
-	kthread_stop(s->kworker_task);
+	kthread_destroy_worker(s->kworker);
 
 out_clk:
 	clk_disable_unprepare(s->clk);
@@ -1705,8 +1702,8 @@ void sc16is7xx_remove(struct device *dev)
 	if (s->polling)
 		kthread_cancel_delayed_work_sync(&s->poll_work);
 
-	kthread_flush_worker(&s->kworker);
-	kthread_stop(s->kworker_task);
+	kthread_flush_worker(s->kworker);
+	kthread_destroy_worker(s->kworker);
 
 	clk_disable_unprepare(s->clk);
 }
-- 
2.47.3

[PATCH v2 5/5] kthread: remove worker->task self assignment

[Bradley Morgan]

All kthread worker users now create their workers with
kthread_create_worker*(), which sets worker->task before the worker
starts. The self assignment in kthread_worker_fn() is dead code now.

Remove the assignment but keep the WARN_ON() as a sanity check for
any OOT users still using the old API.

Suggested-by: Frederic Weisbecker <frederic@kernel.org>
Signed-off-by: Bradley Morgan <brads@mainlining.org>
---
 kernel/kthread.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/kernel/kthread.c b/kernel/kthread.c
index 63beb59b7a3d..643407647e79 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -987,12 +987,10 @@ int kthread_worker_fn(void *worker_ptr)
 	struct kthread_worker *worker = worker_ptr;
 	struct kthread_work *work;
 
-	/*
-	 * FIXME: Update the check and remove the assignment when all kthread
-	 * worker users are created using kthread_create_worker*() functions.
+	/* All workers are created with worker->task set. If this fires,
+	 * the caller is broken.
 	 */
-	WARN_ON(worker->task && worker->task != current);
-	worker->task = current;
+	WARN_ON(worker->task != current);
 
 	if (worker->flags & KTW_FREEZABLE)
 		set_freezable();
-- 
2.47.3

Re: [PATCH v2 1/5] media: ivtv: convert to kthread_run_worker

[Bradley Morgan]

On 4 September 2026 10:37:53 BST, Bradley Morgan <brads@mainlining.org>
wrote:
>Convert ivtv to use kthread_run_worker() instead of the deprecated
>kthread_run(kthread_worker_fn) pattern. The new API sets worker->task
>before the worker starts.

This doesn't compile, I'm aware. Fixing in V3, everything else should
compile.

Received a off list mail from the CI.


>
>Signed-off-by: Bradley Morgan <brads@mainlining.org>
>---
> drivers/media/pci/ivtv/ivtv-driver.c | 14 ++++++--------
> drivers/media/pci/ivtv/ivtv-driver.h |  3 +--
> 2 files changed, 7 insertions(+), 10 deletions(-)
>
>diff --git a/drivers/media/pci/ivtv/ivtv-driver.c b/drivers/media/pci/ivtv/ivtv-driver.c
>index b9ea56ec9593..6f0e0e46deb5 100644
>--- a/drivers/media/pci/ivtv/ivtv-driver.c
>+++ b/drivers/media/pci/ivtv/ivtv-driver.c
>@@ -703,15 +703,13 @@ static int ivtv_init_struct1(struct ivtv *itv)
> 	spin_lock_init(&itv->lock);
> 	spin_lock_init(&itv->dma_reg_lock);
> 
>-	kthread_init_worker(&itv->irq_worker);
>-	itv->irq_worker_task = kthread_run(kthread_worker_fn, &itv->irq_worker,
>-					   "%s", itv->v4l2_dev.name);
>-	if (IS_ERR(itv->irq_worker_task)) {
>+	itv->irq_worker = kthread_run_worker(0, "%s", itv->v4l2_dev.name);
>+	if (IS_ERR(itv->irq_worker)) {
> 		IVTV_ERR("Could not create ivtv task\n");
> 		return -1;
> 	}
> 	/* must use the FIFO scheduler as it is realtime sensitive */
>-	sched_set_fifo(itv->irq_worker_task);
>+	sched_set_fifo(itv->irq_worker->task);
> 
> 	kthread_init_work(&itv->irq_work, ivtv_irq_work_handler);
> 
>@@ -1232,7 +1230,7 @@ static int ivtv_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
> 	v4l2_ctrl_handler_free(&itv->cxhdl.hdl);
> 	exit_ivtv_i2c(itv);
> free_worker:
>-	kthread_stop(itv->irq_worker_task);
>+	kthread_destroy_worker(itv->irq_worker);
> err:
> 	if (retval == 0)
> 		retval = -ENODEV;
>@@ -1372,8 +1370,8 @@ static void ivtv_remove(struct pci_dev *pdev)
> 	timer_shutdown_sync(&itv->dma_timer);
> 
> 	/* Kill irq worker */
>-	kthread_flush_worker(&itv->irq_worker);
>-	kthread_stop(itv->irq_worker_task);
>+	kthread_flush_worker(itv->irq_worker);
>+	kthread_destroy_worker(itv->irq_worker);
> 
> 	ivtv_streams_cleanup(itv);
> 	ivtv_udma_free(itv);
>diff --git a/drivers/media/pci/ivtv/ivtv-driver.h b/drivers/media/pci/ivtv/ivtv-driver.h
>index 000e8beecc7c..091bc44f13bc 100644
>--- a/drivers/media/pci/ivtv/ivtv-driver.h
>+++ b/drivers/media/pci/ivtv/ivtv-driver.h
>@@ -668,8 +668,7 @@ struct ivtv {
> 	/* Interrupts & DMA */
> 	u32 irqmask;                    /* active interrupts */
> 	u32 irq_rr_idx;                 /* round-robin stream index */
>-	struct kthread_worker irq_worker;		/* kthread worker for PIO/YUV/VBI actions */
>-	struct task_struct *irq_worker_task;		/* task for irq_worker */
>+	struct kthread_worker *irq_worker;		/* kthread worker for PIO/YUV/VBI actions */
> 	struct kthread_work irq_work;	/* kthread work entry */
> 	spinlock_t dma_reg_lock;        /* lock access to DMA engine registers */
> 	int cur_dma_stream;		/* index of current stream doing DMA (-1 if none) */
>

--- Thanks!
https://lore.kernel.org/all/EE579805-42F2-4C58-B752-F28779EEB717@grrlz.net/

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Jakub Kicinski]

On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:
>   media: ivtv: convert to kthread_run_worker
>   net: encx24j600: convert to kthread_run_worker
>   tty: sc16is7xx: convert to kthread_run_worker
>   cpufreq: schedutil: convert to kthread_create_worker

Please send these 4 to appropriate subsystems

>   kthread: remove worker->task self assignment

Then after the next merge window when trees converge send this one out

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Bradley Morgan]

On 4 September 2026 16:54:18 BST, Jakub Kicinski <kuba@kernel.org> wrote:
>On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:
>>   media: ivtv: convert to kthread_run_worker
>>   net: encx24j600: convert to kthread_run_worker
>>   tty: sc16is7xx: convert to kthread_run_worker
>>   cpufreq: schedutil: convert to kthread_create_worker
>
>Please send these 4 to appropriate subsystems
>
>>   kthread: remove worker->task self assignment
>
>Then after the next merge window when trees converge send this one out

hi, I was hoping one person could merge it with acks from all subsystems

--- Thanks!
https://lore.kernel.org/all/EE579805-42F2-4C58-B752-F28779EEB717@grrlz.net/

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Jakub Kicinski]

On Fri, 04 Sep 2026 16:56:30 +0100 Bradley Morgan wrote:
> On 4 September 2026 16:54:18 BST, Jakub Kicinski <kuba@kernel.org> wrote:
> >On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:  
> >>   media: ivtv: convert to kthread_run_worker
> >>   net: encx24j600: convert to kthread_run_worker
> >>   tty: sc16is7xx: convert to kthread_run_worker
> >>   cpufreq: schedutil: convert to kthread_create_worker  
> >
> >Please send these 4 to appropriate subsystems
> >  
> >>   kthread: remove worker->task self assignment  
> >
> >Then after the next merge window when trees converge send this one out  
> 
> hi, I was hoping one person could merge it with acks from all subsystems

Not how this works.

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Bradley Morgan]

On 4 September 2026 22:10:32 BST, Jakub Kicinski <kuba@kernel.org> wrote:
>On Fri, 04 Sep 2026 16:56:30 +0100 Bradley Morgan wrote:
>> On 4 September 2026 16:54:18 BST, Jakub Kicinski <kuba@kernel.org>
>wrote:
>> >On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:  
>> >>   media: ivtv: convert to kthread_run_worker
>> >>   net: encx24j600: convert to kthread_run_worker
>> >>   tty: sc16is7xx: convert to kthread_run_worker
>> >>   cpufreq: schedutil: convert to kthread_create_worker  
>> >
>> >Please send these 4 to appropriate subsystems
>> >  
>> >>   kthread: remove worker->task self assignment  
>> >
>> >Then after the next merge window when trees converge send this one out 
>> 
>> hi, I was hoping one person could merge it with acks from all subsystems
>
>Not how this works.
Ugh, I've seen it before happen.

Look, fine, I'll do a V3 soon, WITH ONLY the subsystem changes, all
separate, all sent over to their respective maintainers, then when all
thathas been merged and there's the next merge window, then whatever, I'll
send then the kthread removal

IMHO this is a massive annoyance though.. because what if one of the
driverfolks doesn't wanna respond to me!?!
--- Thanks!
https://lore.kernel.org/all/EE579805-42F2-4C58-B752-F28779EEB717@grrlz.net/

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Greg Kroah-Hartman]

On Fri, Sep 04, 2026 at 10:13:32PM +0100, Bradley Morgan wrote:
> On 4 September 2026 22:10:32 BST, Jakub Kicinski <kuba@kernel.org> wrote:
> >On Fri, 04 Sep 2026 16:56:30 +0100 Bradley Morgan wrote:
> >> On 4 September 2026 16:54:18 BST, Jakub Kicinski <kuba@kernel.org>
> >wrote:
> >> >On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:  
> >> >>   media: ivtv: convert to kthread_run_worker
> >> >>   net: encx24j600: convert to kthread_run_worker
> >> >>   tty: sc16is7xx: convert to kthread_run_worker
> >> >>   cpufreq: schedutil: convert to kthread_create_worker  
> >> >
> >> >Please send these 4 to appropriate subsystems
> >> >  
> >> >>   kthread: remove worker->task self assignment  
> >> >
> >> >Then after the next merge window when trees converge send this one out 
> >> 
> >> hi, I was hoping one person could merge it with acks from all subsystems
> >
> >Not how this works.
> Ugh, I've seen it before happen.
> 
> Look, fine, I'll do a V3 soon, WITH ONLY the subsystem changes, all
> separate, all sent over to their respective maintainers, then when all
> thathas been merged and there's the next merge window, then whatever, I'll
> send then the kthread removal
> 
> IMHO this is a massive annoyance though.. because what if one of the
> driverfolks doesn't wanna respond to me!?!

Then, after trying for the normal way, you can make the driver change at
the same time.  But to circumvent the "normal way" thinking it might not
work, is not the best thing to do.

thanks,

greg k-h

Re: [PATCH v2 0/5] kthread: convert remaining users to kthread_create_worker

[Bradley Morgan]

On 5 September 2026 12:19:54 BST, Greg Kroah-Hartman
<gregkh@linuxfoundation.org> wrote:
>On Fri, Sep 04, 2026 at 10:13:32PM +0100, Bradley Morgan wrote:
>> On 4 September 2026 22:10:32 BST, Jakub Kicinski <kuba@kernel.org>
>wrote:
>> >On Fri, 04 Sep 2026 16:56:30 +0100 Bradley Morgan wrote:
>> >> On 4 September 2026 16:54:18 BST, Jakub Kicinski <kuba@kernel.org>
>> >wrote:
>> >> >On Fri,  4 Sep 2026 09:37:21 +0000 Bradley Morgan wrote:  
>> >> >>   media: ivtv: convert to kthread_run_worker
>> >> >>   net: encx24j600: convert to kthread_run_worker
>> >> >>   tty: sc16is7xx: convert to kthread_run_worker
>> >> >>   cpufreq: schedutil: convert to kthread_create_worker  
>> >> >
>> >> >Please send these 4 to appropriate subsystems
>> >> >  
>> >> >>   kthread: remove worker->task self assignment  
>> >> >
>> >> >Then after the next merge window when trees converge send this one
>out 
>> >> 
>> >> hi, I was hoping one person could merge it with acks from all
>subsystems
>> >
>> >Not how this works.
>> Ugh, I've seen it before happen.
>> 
>> Look, fine, I'll do a V3 soon, WITH ONLY the subsystem changes, all
>> separate, all sent over to their respective maintainers, then when all
>> thathas been merged and there's the next merge window, then whatever,
>I'll
>> send then the kthread removal
>> 
>> IMHO this is a massive annoyance though.. because what if one of the
>> driverfolks doesn't wanna respond to me!?!
>
>Then, after trying for the normal way, you can make the driver change at
>the same time.  But to circumvent the "normal way" thinking it might not
>work, is not the best thing to do.
>

Greg!

Right, okay, Ill tell you more.

For features being added, where many drivers from different subsystems get
covered at once, what they tend to do is:

A: send all patches, rely on all maintainers to merge their own crap, which is a mess

B: Have a designated merger, who merges all the changes at once, no chance of regression because it's all bundled up.


C: send drivers first, then send the feature. So then driver maintainers can merge their crap, then the main feature gets merged in merge window 

I prefer B, because it's easier that way, akpm is usually des merger hence
I CCed him.

Or tip tree?

Honestly, if I had to be honest, C is a very annoying way, because of what
I said above, if driver maintainer thinks I'm some newbie idiot or
something, then what will I do? He won't merge it!


>thanks,
>
>greg k-h

--- Thanks!
https://lore.kernel.org/all/EE579805-42F2-4C58-B752-F28779EEB717@grrlz.net/