[PATCH] tty: Convert from tasklet to BH workqueue

From: Allen Pais
Date: Wed Apr 03 2024 - 12:16:09 EST

The only generic interface to execute asynchronously in the BH context is
tasklet; however, it's marked deprecated and has some design flaws. To
replace tasklets, BH workqueue support was recently added. A BH workqueue
behaves similarly to regular workqueues except that the queued work items
are executed in the BH context.

This patch converts drivers/tty/* from tasklet to BH workqueue.

Based on the work done by Tejun Heo <tj@xxxxxxxxxx>
Branch: https://git.kernel.org/pub/scm/linux/kernel/git/tj/wq.git for-6.10

Signed-off-by: Allen Pais <allen.lkml@xxxxxxxxx>
---
drivers/tty/ipwireless/hardware.c | 15 +++---
drivers/tty/serial/atmel_serial.c | 79 ++++++++++++++++---------------
drivers/tty/serial/timbuart.c | 19 ++++----
drivers/tty/vt/keyboard.c | 34 ++++++-------
4 files changed, 76 insertions(+), 71 deletions(-)

diff --git a/drivers/tty/ipwireless/hardware.c b/drivers/tty/ipwireless/hardware.c
index 001ec318a918..a8bf3bd8f23a 100644
--- a/drivers/tty/ipwireless/hardware.c
+++ b/drivers/tty/ipwireless/hardware.c
@@ -22,6 +22,7 @@
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/slab.h>
+#include <linux/workqueue.h>

#include "hardware.h"
#include "setup_protocol.h"
@@ -275,7 +276,7 @@ struct ipw_hardware {
unsigned int control_lines[NL_NUM_OF_ADDRESSES];
struct ipw_rx_packet *packet_assembler[NL_NUM_OF_ADDRESSES];

- struct tasklet_struct tasklet;
+ struct work_struct work;

/* The handle for the network layer, for the sending of events to it. */
struct ipw_network *network;
@@ -1006,9 +1007,9 @@ static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
/*
* Send and receive all queued packets.
*/
-static void ipwireless_do_tasklet(struct tasklet_struct *t)
+static void ipwireless_do_work(struct work_struct *t)
{
- struct ipw_hardware *hw = from_tasklet(hw, t, tasklet);
+ struct ipw_hardware *hw = from_work(hw, t, work);
unsigned long flags;

spin_lock_irqsave(&hw->lock, flags);
@@ -1084,7 +1085,7 @@ static irqreturn_t ipwireless_handle_v1_interrupt(int irq,
}
if (ack != 0) {
outw(ack, hw->base_port + IOIR);
- tasklet_schedule(&hw->tasklet);
+ queue_work(system_bh_wq, &hw->work);
}
return IRQ_HANDLED;
}
@@ -1189,7 +1190,7 @@ static irqreturn_t ipwireless_handle_v2_v3_interrupt(int irq,
acknowledge_pcmcia_interrupt(hw);

if (tx || rx)
- tasklet_schedule(&hw->tasklet);
+ queue_work(system_bh_wq, &hw->work);
else if (!rx_repeat) {
if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
if (hw->serial_number_detected)
@@ -1635,7 +1636,7 @@ struct ipw_hardware *ipwireless_hardware_create(void)
INIT_LIST_HEAD(&hw->rx_queue);
INIT_LIST_HEAD(&hw->rx_pool);
spin_lock_init(&hw->lock);
- tasklet_setup(&hw->tasklet, ipwireless_do_tasklet);
+ INIT_WORK(&hw->work, ipwireless_do_work);
INIT_WORK(&hw->work_rx, ipw_receive_data_work);
timer_setup(&hw->setup_timer, ipwireless_setup_timer, 0);

@@ -1703,7 +1704,7 @@ static void ipwireless_setup_timer(struct timer_list *t)
hw->to_setup = 1;
hw->tx_ready = 1;
spin_unlock_irqrestore(&hw->lock, flags);
- tasklet_schedule(&hw->tasklet);
+ queue_work(system_bh_wq, &hw->work);
}

mod_timer(&hw->setup_timer,
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index 85667f709515..09e5fa1c56b6 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -50,6 +50,7 @@
#define ATMEL_RTS_LOW_OFFSET 20

#include <linux/serial_core.h>
+#include <linux/workqueue.h>

#include "serial_mctrl_gpio.h"
#include "atmel_serial.h"
@@ -134,8 +135,8 @@ struct atmel_uart_port {
dma_cookie_t cookie_rx;
struct scatterlist sg_tx;
struct scatterlist sg_rx;
- struct tasklet_struct tasklet_rx;
- struct tasklet_struct tasklet_tx;
+ struct work_struct work_rx;
+ struct work_struct work_tx;
atomic_t tasklet_shutdown;
unsigned int irq_status_prev;
unsigned int tx_len;
@@ -282,11 +283,11 @@ static bool atmel_use_fifo(struct uart_port *port)
return atmel_port->fifo_size;
}

-static void atmel_tasklet_schedule(struct atmel_uart_port *atmel_port,
- struct tasklet_struct *t)
+static void atmel_queue_work(struct atmel_uart_port *atmel_port,
+ struct work_struct *t)
{
- if (!atomic_read(&atmel_port->tasklet_shutdown))
- tasklet_schedule(t);
+ if (!atomic_read(&atmel_port->work_shutdown))
+ queue_work(system_bh_wq, t);
}

/* Enable or disable the rs485 support */
@@ -821,11 +822,11 @@ static void atmel_rx_chars(struct uart_port *port)
status = atmel_uart_readl(port, ATMEL_US_CSR);
}

- atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_rx);
+ atmel_queue_work(atmel_port, &atmel_port->work_rx);
}

/*
- * Transmit characters (called from tasklet with TXRDY interrupt
+ * Transmit characters (called from workqueue with TXRDY interrupt
* disabled)
*/
static void atmel_tx_chars(struct uart_port *port)
@@ -882,7 +883,7 @@ static void atmel_complete_tx_dma(void *arg)
* remaining data from the beginning of xmit->buf to xmit->head.
*/
if (!uart_circ_empty(xmit))
- atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_tx);
+ atmel_queue_work(atmel_port, &atmel_port->work_tx);
else if (atmel_uart_is_half_duplex(port)) {
/*
* DMA done, re-enable TXEMPTY and signal that we can stop
@@ -914,7 +915,7 @@ static void atmel_release_tx_dma(struct uart_port *port)
}

/*
- * Called from tasklet with TXRDY interrupt is disabled.
+ * Called from workqueue with TXRDY interrupt is disabled.
*/
static void atmel_tx_dma(struct uart_port *port)
{
@@ -1082,7 +1083,7 @@ static void atmel_complete_rx_dma(void *arg)
struct uart_port *port = arg;
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);

- atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_rx);
+ atmel_queue_work(atmel_port, &atmel_port->work_rx);
}

static void atmel_release_rx_dma(struct uart_port *port)
@@ -1118,11 +1119,11 @@ static void atmel_rx_from_dma(struct uart_port *port)
dmastat = dmaengine_tx_status(chan,
atmel_port->cookie_rx,
&state);
- /* Restart a new tasklet if DMA status is error */
+ /* Queue a new work if DMA status is error */
if (dmastat == DMA_ERROR) {
- dev_dbg(port->dev, "Get residue error, restart tasklet\n");
+ dev_dbg(port->dev, "Get residue error, restart work\n");
atmel_uart_writel(port, ATMEL_US_IER, ATMEL_US_TIMEOUT);
- atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_rx);
+ atmel_queue_work(atmel_port, &atmel_port->work_rx);
return;
}

@@ -1288,7 +1289,7 @@ static void atmel_uart_timer_callback(struct timer_list *t)
struct uart_port *port = &atmel_port->uart;

if (!atomic_read(&atmel_port->tasklet_shutdown)) {
- tasklet_schedule(&atmel_port->tasklet_rx);
+ queue_work(system_bh_wq, &atmel_port->tasklet_rx);
mod_timer(&atmel_port->uart_timer,
jiffies + uart_poll_timeout(port));
}
@@ -1304,7 +1305,7 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)

if (atmel_use_pdc_rx(port)) {
/*
- * PDC receive. Just schedule the tasklet and let it
+ * PDC receive. Just schedule the task and let it
* figure out the details.
*
* TODO: We're not handling error flags correctly at
@@ -1313,8 +1314,8 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)
if (pending & (ATMEL_US_ENDRX | ATMEL_US_TIMEOUT)) {
atmel_uart_writel(port, ATMEL_US_IDR,
(ATMEL_US_ENDRX | ATMEL_US_TIMEOUT));
- atmel_tasklet_schedule(atmel_port,
- &atmel_port->tasklet_rx);
+ atmel_queue_work(atmel_port,
+ &atmel_port->work_rx);
}

if (pending & (ATMEL_US_RXBRK | ATMEL_US_OVRE |
@@ -1326,8 +1327,8 @@ atmel_handle_receive(struct uart_port *port, unsigned int pending)
if (pending & ATMEL_US_TIMEOUT) {
atmel_uart_writel(port, ATMEL_US_IDR,
ATMEL_US_TIMEOUT);
- atmel_tasklet_schedule(atmel_port,
- &atmel_port->tasklet_rx);
+ atmel_queue_work(atmel_port,
+ &atmel_port->work_rx);
}
}

@@ -1367,7 +1368,7 @@ atmel_handle_transmit(struct uart_port *port, unsigned int pending)
atmel_start_rx(port);
}

- atmel_tasklet_schedule(atmel_port, &atmel_port->tasklet_tx);
+ atmel_queue_work(atmel_port, &atmel_port->work_tx);
}
}

@@ -1454,7 +1455,7 @@ static void atmel_release_tx_pdc(struct uart_port *port)
}

/*
- * Called from tasklet with ENDTX and TXBUFE interrupts disabled.
+ * Called from workqueue with ENDTX and TXBUFE interrupts disabled.
*/
static void atmel_tx_pdc(struct uart_port *port)
{
@@ -1710,12 +1711,12 @@ static int atmel_prepare_rx_pdc(struct uart_port *port)
}

/*
- * tasklet handling tty stuff outside the interrupt handler.
+ * task handling tty stuff outside the interrupt handler.
*/
-static void atmel_tasklet_rx_func(struct tasklet_struct *t)
+static void atmel_work_rx_func(struct work_struct *t)
{
- struct atmel_uart_port *atmel_port = from_tasklet(atmel_port, t,
- tasklet_rx);
+ struct atmel_uart_port *atmel_port = from_work(atmel_port, t,
+ work_rx);
struct uart_port *port = &atmel_port->uart;

/* The interrupt handler does not take the lock */
@@ -1724,10 +1725,10 @@ static void atmel_tasklet_rx_func(struct tasklet_struct *t)
uart_port_unlock(port);
}

-static void atmel_tasklet_tx_func(struct tasklet_struct *t)
+static void atmel_work_tx_func(struct work_struct *t)
{
- struct atmel_uart_port *atmel_port = from_tasklet(atmel_port, t,
- tasklet_tx);
+ struct atmel_uart_port *atmel_port = from_work(atmel_port, t,
+ work_tx);
struct uart_port *port = &atmel_port->uart;

/* The interrupt handler does not take the lock */
@@ -1906,8 +1907,8 @@ static int atmel_startup(struct uart_port *port)
}

atomic_set(&atmel_port->tasklet_shutdown, 0);
- tasklet_setup(&atmel_port->tasklet_rx, atmel_tasklet_rx_func);
- tasklet_setup(&atmel_port->tasklet_tx, atmel_tasklet_tx_func);
+ INIT_WORK(&atmel_port->tasklet_rx, atmel_work_rx_func);
+ INIT_WORK(&atmel_port->tasklet_tx, atmel_work_tx_func);

/*
* Initialize DMA (if necessary)
@@ -1953,7 +1954,7 @@ static int atmel_startup(struct uart_port *port)
atmel_uart_writel(port, ATMEL_US_FMR, fmr);
}

- /* Save current CSR for comparison in atmel_tasklet_func() */
+ /* Save current CSR for comparison in atmel_work_func() */
atmel_port->irq_status_prev = atmel_uart_readl(port, ATMEL_US_CSR);

/*
@@ -2036,11 +2037,11 @@ static void atmel_shutdown(struct uart_port *port)
/* Disable interrupts at device level */
atmel_uart_writel(port, ATMEL_US_IDR, -1);

- /* Prevent spurious interrupts from scheduling the tasklet */
+ /* Prevent spurious interrupts from scheduling the task */
atomic_inc(&atmel_port->tasklet_shutdown);

/*
- * Prevent any tasklets being scheduled during
+ * Prevent any tasks being scheduled during
* cleanup
*/
del_timer_sync(&atmel_port->uart_timer);
@@ -2049,11 +2050,11 @@ static void atmel_shutdown(struct uart_port *port)
synchronize_irq(port->irq);

/*
- * Clear out any scheduled tasklets before
+ * Clear out any scheduled tasks before
* we destroy the buffers
*/
- tasklet_kill(&atmel_port->tasklet_rx);
- tasklet_kill(&atmel_port->tasklet_tx);
+ cancel_work_sync(&atmel_port->work_rx);
+ cancel_work_sync(&atmel_port->work_tx);

/*
* Ensure everything is stopped and
@@ -3014,8 +3015,8 @@ static void atmel_serial_remove(struct platform_device *pdev)
struct uart_port *port = platform_get_drvdata(pdev);
struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);

- tasklet_kill(&atmel_port->tasklet_rx);
- tasklet_kill(&atmel_port->tasklet_tx);
+ cancel_work_sync(&atmel_port->tasklet_rx);
+ cancel_work_sync(&atmel_port->tasklet_tx);

device_init_wakeup(&pdev->dev, 0);

diff --git a/drivers/tty/serial/timbuart.c b/drivers/tty/serial/timbuart.c
index 4bc89a9b380a..7ac55e35e061 100644
--- a/drivers/tty/serial/timbuart.c
+++ b/drivers/tty/serial/timbuart.c
@@ -18,12 +18,13 @@
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/module.h>
+#include <linux/workqueue.h>

#include "timbuart.h"

struct timbuart_port {
struct uart_port port;
- struct tasklet_struct tasklet;
+ struct work_struct work;
int usedma;
u32 last_ier;
struct platform_device *dev;
@@ -55,8 +56,8 @@ static void timbuart_start_tx(struct uart_port *port)
struct timbuart_port *uart =
container_of(port, struct timbuart_port, port);

- /* do not transfer anything here -> fire off the tasklet */
- tasklet_schedule(&uart->tasklet);
+ /* do not transfer anything here -> fire off the task */
+ queue_work(system_bh_wq, &uart->work);
}

static unsigned int timbuart_tx_empty(struct uart_port *port)
@@ -169,9 +170,9 @@ static void timbuart_handle_rx_port(struct uart_port *port, u32 isr, u32 *ier)
dev_dbg(port->dev, "%s - leaving\n", __func__);
}

-static void timbuart_tasklet(struct tasklet_struct *t)
+static void timbuart_work(struct work_struct *t)
{
- struct timbuart_port *uart = from_tasklet(uart, t, tasklet);
+ struct timbuart_port *uart = from_work(uart, t, work);
u32 isr, ier = 0;

uart_port_lock(&uart->port);
@@ -350,11 +351,11 @@ static irqreturn_t timbuart_handleinterrupt(int irq, void *devid)
if (ioread8(uart->port.membase + TIMBUART_IPR)) {
uart->last_ier = ioread32(uart->port.membase + TIMBUART_IER);

- /* disable interrupts, the tasklet enables them again */
+ /* disable interrupts, the task enables them again */
iowrite32(0, uart->port.membase + TIMBUART_IER);

/* fire off bottom half */
- tasklet_schedule(&uart->tasklet);
+ queue_work(system_bh_wq, &uart->work);

return IRQ_HANDLED;
} else
@@ -448,7 +449,7 @@ static int timbuart_probe(struct platform_device *dev)
}
uart->port.irq = irq;

- tasklet_setup(&uart->tasklet, timbuart_tasklet);
+ INIT_WORK(&uart->work, timbuart_work);

err = uart_register_driver(&timbuart_driver);
if (err)
@@ -477,7 +478,7 @@ static void timbuart_remove(struct platform_device *dev)
{
struct timbuart_port *uart = platform_get_drvdata(dev);

- tasklet_kill(&uart->tasklet);
+ cancel_work_sync(&uart->work);
uart_remove_one_port(&timbuart_driver, &uart->port);
uart_unregister_driver(&timbuart_driver);
kfree(uart);
diff --git a/drivers/tty/vt/keyboard.c b/drivers/tty/vt/keyboard.c
index a2116e135a82..81943bed2063 100644
--- a/drivers/tty/vt/keyboard.c
+++ b/drivers/tty/vt/keyboard.c
@@ -46,6 +46,7 @@
#include <linux/tty.h>
#include <linux/uaccess.h>
#include <linux/vt_kern.h>
+#include <linux/workqueue.h>

#include <asm/irq_regs.h>

@@ -131,8 +132,8 @@ static const unsigned char max_vals[] = {

static const int NR_TYPES = ARRAY_SIZE(max_vals);

-static void kbd_bh(struct tasklet_struct *unused);
-static DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh);
+static void kbd_bh(struct work_struct *unused);
+static DECLARE_WORK(keyboard_work, kbd_bh);

static struct input_handler kbd_handler;
static DEFINE_SPINLOCK(kbd_event_lock);
@@ -379,7 +380,7 @@ static void to_utf8(struct vc_data *vc, uint c)
/* FIXME: review locking for vt.c callers */
static void set_leds(void)
{
- tasklet_schedule(&keyboard_tasklet);
+ queue_work(system_bh_wq, &keyboard_work);
}

/*
@@ -1031,12 +1032,12 @@ static int kbd_led_trigger_activate(struct led_classdev *cdev)
struct kbd_led_trigger *trigger =
container_of(cdev->trigger, struct kbd_led_trigger, trigger);

- tasklet_disable(&keyboard_tasklet);
+ disable_work_sync(&keyboard_work);
if (ledstate != -1U)
led_trigger_event(&trigger->trigger,
ledstate & trigger->mask ?
LED_FULL : LED_OFF);
- tasklet_enable(&keyboard_tasklet);
+ enable_and_queue_work(system_bh_wq, &keyboard_work);

return 0;
}
@@ -1247,12 +1248,13 @@ void vt_kbd_con_stop(unsigned int console)
}

/*
- * This is the tasklet that updates LED state of LEDs using standard
- * keyboard triggers. The reason we use tasklet is that we need to
- * handle the scenario when keyboard handler is not registered yet
- * but we already getting updates from the VT to update led state.
+ * This is the task that updates LED state of LEDs using standard
+ * keyboard triggers. The reason we use workqueue is that we need
+ * to handle the scenario when keyboard handler is not registered
+ * yet but we already getting updates from the VT to update led
+ * state.
*/
-static void kbd_bh(struct tasklet_struct *unused)
+static void kbd_bh(struct work_struct *unused)
{
unsigned int leds;
unsigned long flags;
@@ -1544,7 +1546,7 @@ static void kbd_event(struct input_handle *handle, unsigned int event_type,

spin_unlock(&kbd_event_lock);

- tasklet_schedule(&keyboard_tasklet);
+ queue_work(system_bh_wq, &keyboard_work);
do_poke_blanked_console = 1;
schedule_console_callback();
}
@@ -1616,12 +1618,12 @@ static void kbd_disconnect(struct input_handle *handle)
*/
static void kbd_start(struct input_handle *handle)
{
- tasklet_disable(&keyboard_tasklet);
+ disable_work_sync(&keyboard_work);

if (ledstate != -1U)
kbd_update_leds_helper(handle, &ledstate);

- tasklet_enable(&keyboard_tasklet);
+ enable_and_queue_work(system_bh_wq, &keyboard_work);
}

static const struct input_device_id kbd_ids[] = {
@@ -1671,8 +1673,8 @@ int __init kbd_init(void)
if (error)
return error;

- tasklet_enable(&keyboard_tasklet);
- tasklet_schedule(&keyboard_tasklet);
+ enable_and_queue_work(system_bh_wq, &keyboard_work);
+ queue_work(system_bh_wq, &keyboard_work);

return 0;
}
@@ -2233,7 +2235,7 @@ void vt_reset_keyboard(unsigned int console)
kb->ledmode = LED_SHOW_FLAGS;
kb->ledflagstate = kb->default_ledflagstate;
spin_unlock(&led_lock);
- /* do not do set_leds here because this causes an endless tasklet loop
+ /* do not do set_leds here because this causes an endless loop
when the keyboard hasn't been initialized yet */
spin_unlock_irqrestore(&kbd_event_lock, flags);
}
--
2.17.1