Commit 30bfec4f authored by Marc Kleine-Budde's avatar Marc Kleine-Budde
Browse files

can: rx-offload: can_rx_offload_threaded_irq_finish(): add new function to be... 

can: rx-offload: can_rx_offload_threaded_irq_finish(): add new function to be called from threaded interrupt

After reading all CAN frames from the controller in the IRQ handler
and storing them into a skb_queue, the driver calls napi_schedule().
In the napi poll function the skb from the skb_queue are then pushed
into the networking stack.

However if napi_schedule() is called from a threaded IRQ handler this
triggers the following error:

| NOHZ tick-stop error: Non-RCU local softirq work is pending, handler #08!!!

To avoid this, create a new rx-offload
function (can_rx_offload_threaded_irq_finish()) with a call to
local_bh_disable()/local_bh_enable() around the napi_schedule() call.

Convert all drivers that call can_rx_offload_irq_finish() from
threaded IRQ context to can_rx_offload_threaded_irq_finish().

Link: https://lore.kernel.org/r/20210724204745.736053-4-mkl@pengutronix.de


Suggested-by: default avatarDaniel Glöckner <dg@emlix.com>
Tested-by: default avatarOleksij Rempel <o.rempel@pengutronix.de>
Signed-off-by: default avatarMarc Kleine-Budde <mkl@pengutronix.de>
parent 1e0d8e50

drivers/net/can/dev/rx-offload.c

+23 −0
Original line number Diff line number Diff line
@@ -299,6 +299,29 @@ void can_rx_offload_irq_finish(struct can_rx_offload *offload) 
}

EXPORT_SYMBOL_GPL(can_rx_offload_irq_finish);



void can_rx_offload_threaded_irq_finish(struct can_rx_offload *offload)

{

	unsigned long flags;

	int queue_len;



	if (skb_queue_empty_lockless(&offload->skb_irq_queue))

		return;



	spin_lock_irqsave(&offload->skb_queue.lock, flags);

	skb_queue_splice_tail_init(&offload->skb_irq_queue, &offload->skb_queue);

	spin_unlock_irqrestore(&offload->skb_queue.lock, flags);



	queue_len = skb_queue_len(&offload->skb_queue);

	if (queue_len > offload->skb_queue_len_max / 8)

		netdev_dbg(offload->dev, "%s: queue_len=%d\n",

			   __func__, queue_len);



	local_bh_disable();

	napi_schedule(&offload->napi);

	local_bh_enable();

}

EXPORT_SYMBOL_GPL(can_rx_offload_threaded_irq_finish);



static int can_rx_offload_init_queue(struct net_device *dev,

				     struct can_rx_offload *offload,

				     unsigned int weight)

drivers/net/can/m_can/m_can.c

+1 −1
Original line number Diff line number Diff line
@@ -1059,7 +1059,7 @@ static irqreturn_t m_can_isr(int irq, void *dev_id) 
	}



	if (cdev->is_peripheral)

		can_rx_offload_irq_finish(&cdev->offload);

		can_rx_offload_threaded_irq_finish(&cdev->offload);



	return IRQ_HANDLED;

}

drivers/net/can/spi/mcp251xfd/mcp251xfd-core.c

+2 −2
Original line number Diff line number Diff line
@@ -2196,7 +2196,7 @@ static irqreturn_t mcp251xfd_irq(int irq, void *dev_id) 
				  priv->regs_status.intf);



		if (!(intf_pending)) {

			can_rx_offload_irq_finish(&priv->offload);

			can_rx_offload_threaded_irq_finish(&priv->offload);

			return handled;

		}
@@ -2298,7 +2298,7 @@ static irqreturn_t mcp251xfd_irq(int irq, void *dev_id) 
	} while (1);



 out_fail:

	can_rx_offload_irq_finish(&priv->offload);

	can_rx_offload_threaded_irq_finish(&priv->offload);



	netdev_err(priv->ndev, "IRQ handler returned %d (intf=0x%08x).\n",

		   err, priv->regs_status.intf);

include/linux/can/rx-offload.h

+1 −0
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ unsigned int can_rx_offload_get_echo_skb(struct can_rx_offload *offload, 
int can_rx_offload_queue_tail(struct can_rx_offload *offload,

			      struct sk_buff *skb);

void can_rx_offload_irq_finish(struct can_rx_offload *offload);

void can_rx_offload_threaded_irq_finish(struct can_rx_offload *offload);

void can_rx_offload_del(struct can_rx_offload *offload);

void can_rx_offload_enable(struct can_rx_offload *offload);