FAILED: patch "[PATCH] NTB: ntb_netdev: Preserve RX queue depth on allocation" failed to apply to 6.18-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 6.18-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.18.y
git checkout FETCH_HEAD
git cherry-pick -x d2121faf133ac3bf9531b53a7e21273649a08517
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026081709-sulfate-hardwired-cf00@gregkh' --subject-prefix 'PATCH 6.18.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From d2121faf133ac3bf9531b53a7e21273649a08517 Mon Sep 17 00:00:00 2001
From: Koichiro Den <[email protected]>
Date: Thu, 6 Aug 2026 12:25:37 +0900
Subject: [PATCH] NTB: ntb_netdev: Preserve RX queue depth on allocation
failure
ntb_netdev_rx_handler() hands the received skb to the network stack before allocating its replacement. If the allocation fails, nothing is reposted. Every failure therefore takes one buffer out of the RX queue while the interface remains up, and enough failures eventually stall reception.
A retry path could refill the queue later, but ntb_netdev has none. Allocate the replacement first instead. If that fails, drop the packet and repost the same skb. This keeps the queue full and lets packet delivery resume as soon as memory is available again.
drivers/net/ntb_netdev.c +8 -7
@@ -127,8 +127,8 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, {struct ntb_netdev_queue *q = qp_data;struct ntb_netdev *dev = q->ntdev; +struct sk_buff *skb, *new_skb;struct net_device *ndev; -struct sk_buff *skb;int rc; ndev = dev->ndev;
@@ -144,6 +144,12 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, goto enqueue_again; } + new_skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); +if (!new_skb) { + ndev->stats.rx_dropped++; + goto enqueue_again; + } +skb_put (skb, len); skb->protocol =eth_type_trans (skb, ndev); skb->ip_summed =CHECKSUM_NONE ;
@@ -157,12 +163,7 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, ndev->stats.rx_bytes += len; } - skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); -if (!skb) { - ndev->stats.rx_errors++; - ndev->stats.rx_frame_errors++; -return ; - } + skb = new_skb; enqueue_again: rc =ntb_transport_rx_enqueue (qp, skb, skb->data, ndev->mtu +ETH_HLEN );
Sasha Levin
maintainerPATCH 1/2 net: ntb_netdev: Introduce per-queue context
From: Koichiro Den <[email protected]>
[ Upstream commit ee970634c7773f248a0a27d8a645500371ae5249 ]
Prepare ntb_netdev for multi-queue operation by moving queue-pair state out of struct ntb_netdev.
Introduce struct ntb_netdev_queue to carry the ntb_transport_qp pointer, the per-QP TX timer and queue id. Pass this object as the callback context and convert the RX/TX handlers and link event path accordingly.
The probe path allocates a fixed upper bound for netdev queues while instantiating only a single ntb_transport queue pair, preserving the previous behavior. Also store client_dev for future queue pair creation/removal via the ntb_transport API.
Stable-dep-of: d2121faf133a ("NTB: ntb_netdev: Preserve RX queue depth on allocation failure")
--- drivers/net/ntb_netdev.c | 277 ++++++++++++++++++++++++++------------- 1 file changed, 188 insertions(+), 89 deletions(-)
drivers/net/ntb_netdev.c +188 -89
@@ -53,6 +53,7 @@#include <linux/pci.h> #include <linux/ntb.h> #include <linux/ntb_transport.h> +#include <linux/slab.h> #define NTB_NETDEV_VER "0.7"
@@ -70,11 +71,24 @@ static unsigned int tx_start = 10;/* Number of descriptors still available before stop upper layer tx */ static unsigned int tx_stop =5 ; +#define NTB_NETDEV_MAX_QUEUES 64 +#define NTB_NETDEV_DEFAULT_QUEUES 1 + +struct ntb_netdev ; + +struct ntb_netdev_queue { +struct ntb_netdev *ntdev; +struct ntb_transport_qp *qp; +struct timer_list tx_timer; +u16 qid; +}; +struct ntb_netdev {struct pci_dev *pdev; +struct device *client_dev;struct net_device *ndev; -struct ntb_transport_qp *qp; -struct timer_list tx_timer; +unsigned int num_queues; +struct ntb_netdev_queue *queues; };#define NTB_TX_TIMEOUT_MS 1000
@@ -82,14 +96,17 @@ struct ntb_netdev {static void ntb_netdev_event_handler (void *data,int link_is_up) { -struct net_device *ndev = data; -struct ntb_netdev *dev =netdev_priv (ndev); +struct ntb_netdev_queue *q = data; +struct ntb_netdev *dev = q->ntdev; +struct net_device *ndev; + + ndev = dev->ndev; -netdev_dbg (ndev,"Event %x, Link %x\n" , link_is_up, -ntb_transport_link_query (dev->qp)); +netdev_dbg (ndev,"Event %x, Link %x, qp %u\n" , link_is_up, +ntb_transport_link_query (q->qp), q->qid);if (link_is_up) { -if (ntb_transport_link_query (dev->qp)) +if (ntb_transport_link_query (q->qp))netif_carrier_on (ndev); }else {netif_carrier_off (ndev);
@@ -99,10 +116,13 @@ static void ntb_netdev_event_handler(void *data, int link_is_up)static void ntb_netdev_rx_handler (struct ntb_transport_qp *qp,void *qp_data,void *data,int len) { -struct net_device *ndev = qp_data; +struct ntb_netdev_queue *q = qp_data; +struct ntb_netdev *dev = q->ntdev; +struct net_device *ndev;struct sk_buff *skb;int rc; + ndev = dev->ndev; skb = data;if (!skb)return ;
@@ -118,6 +138,7 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data,skb_put (skb, len); skb->protocol =eth_type_trans (skb, ndev); skb->ip_summed =CHECKSUM_NONE ; +skb_record_rx_queue (skb, q->qid);if (netif_rx (skb) ==NET_RX_DROP ) { ndev->stats.rx_errors++;
@@ -144,42 +165,43 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, }static int __ntb_netdev_maybe_stop_tx (struct net_device *netdev, -struct ntb_transport_qp *qp,int size) +struct ntb_netdev_queue *q,int size) { -struct ntb_netdev *dev =netdev_priv (netdev); +netif_stop_subqueue (netdev, q->qid); -netif_stop_queue (netdev);/* Make sure to see the latest value of ntb_transport_tx_free_entry() * since the queue was last started. */ smp_mb (); -if (likely (ntb_transport_tx_free_entry (qp) < size)) { -mod_timer (&dev->tx_timer, jiffies +usecs_to_jiffies (tx_time)); +if (likely (ntb_transport_tx_free_entry (q->qp) < size)) { +mod_timer (&q->tx_timer, jiffies +usecs_to_jiffies (tx_time));return -EBUSY ; } -netif_start_queue (netdev); +netif_start_subqueue (netdev, q->qid);return 0 ; }static int ntb_netdev_maybe_stop_tx (struct net_device *ndev, -struct ntb_transport_qp *qp,int size) +struct ntb_netdev_queue *q,int size) { -if (netif_queue_stopped (ndev) || - (ntb_transport_tx_free_entry (qp) >= size)) +if (__netif_subqueue_stopped (ndev, q->qid) || + (ntb_transport_tx_free_entry (q->qp) >= size))return 0 ; -return __ntb_netdev_maybe_stop_tx (ndev, qp, size); +return __ntb_netdev_maybe_stop_tx (ndev, q, size); }static void ntb_netdev_tx_handler (struct ntb_transport_qp *qp,void *qp_data,void *data,int len) { -struct net_device *ndev = qp_data; +struct ntb_netdev_queue *q = qp_data; +struct ntb_netdev *dev = q->ntdev; +struct net_device *ndev;struct sk_buff *skb; -struct ntb_netdev *dev =netdev_priv (ndev); + ndev = dev->ndev; skb = data;if (!skb || !ndev)return ;
@@ -194,13 +216,13 @@ static void ntb_netdev_tx_handler(struct ntb_transport_qp *qp, void *qp_data,dev_kfree_skb_any (skb); -if (ntb_transport_tx_free_entry (dev->qp) >= tx_start) { +if (ntb_transport_tx_free_entry (qp) >= tx_start) {/* Make sure anybody stopping the queue after this sees the new * value of ntb_transport_tx_free_entry() */ smp_mb (); -if (netif_queue_stopped (ndev)) -netif_wake_queue (ndev); +if (__netif_subqueue_stopped (ndev, q->qid)) +netif_wake_subqueue (ndev, q->qid); } }
@@ -208,16 +230,20 @@ static netdev_tx_t ntb_netdev_start_xmit(struct sk_buff *skb, struct net_device *ndev) {struct ntb_netdev *dev =netdev_priv (ndev); +u16 qid =skb_get_queue_mapping (skb); +struct ntb_netdev_queue *q;int rc; -ntb_netdev_maybe_stop_tx (ndev, dev->qp, tx_stop); + q = &dev->queues[qid]; + +ntb_netdev_maybe_stop_tx (ndev, q, tx_stop); - rc =ntb_transport_tx_enqueue (dev->qp, skb, skb->data, skb->len); + rc =ntb_transport_tx_enqueue (q->qp, skb, skb->data, skb->len);if (rc) goto err;/* check for next submit */ -ntb_netdev_maybe_stop_tx (ndev, dev->qp, tx_stop); +ntb_netdev_maybe_stop_tx (ndev, q, tx_stop);return NETDEV_TX_OK ;
@@ -229,80 +255,104 @@ static netdev_tx_t ntb_netdev_start_xmit(struct sk_buff *skb,static void ntb_netdev_tx_timer (struct timer_list *t) { -struct ntb_netdev *dev =timer_container_of (dev, t, tx_timer); -struct net_device *ndev = dev->ndev; +struct ntb_netdev_queue *q =timer_container_of (q, t, tx_timer); +struct ntb_netdev *dev = q->ntdev; +struct net_device *ndev; + + ndev = dev->ndev; -if (ntb_transport_tx_free_entry (dev->qp) < tx_stop) { -mod_timer (&dev->tx_timer, jiffies +usecs_to_jiffies (tx_time)); +if (ntb_transport_tx_free_entry (q->qp) < tx_stop) { +mod_timer (&q->tx_timer, jiffies +usecs_to_jiffies (tx_time)); }else {/* Make sure anybody stopping the queue after this sees the new * value of ntb_transport_tx_free_entry() */ smp_mb (); -if (netif_queue_stopped (ndev)) -netif_wake_queue (ndev); +if (__netif_subqueue_stopped (ndev, q->qid)) +netif_wake_subqueue (ndev, q->qid); } }static int ntb_netdev_open (struct net_device *ndev) {struct ntb_netdev *dev =netdev_priv (ndev); +struct ntb_netdev_queue *queue;struct sk_buff *skb; -int rc, i, len; - -/* Add some empty rx bufs */ -for (i =0 ; i <NTB_RXQ_SIZE ; i++) { - skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); -if (!skb) { - rc = -ENOMEM ; - goto err; - } +int rc =0 , i, len; +unsigned int q; - rc =ntb_transport_rx_enqueue (dev->qp, skb, skb->data, - ndev->mtu +ETH_HLEN ); -if (rc) { -dev_kfree_skb (skb); - goto err; +/* Add some empty rx bufs for each queue */ +for (q =0 ; q < dev->num_queues; q++) { + queue = &dev->queues[q]; + +for (i =0 ; i <NTB_RXQ_SIZE ; i++) { + skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); +if (!skb) { + rc = -ENOMEM ; + goto err; + } + + rc =ntb_transport_rx_enqueue (queue->qp, skb, skb->data, + ndev->mtu +ETH_HLEN ); +if (rc) { +dev_kfree_skb (skb); + goto err; + } } - } -timer_setup (&dev->tx_timer, ntb_netdev_tx_timer,0 ); +timer_setup (&queue->tx_timer, ntb_netdev_tx_timer,0 ); + }netif_carrier_off (ndev); -ntb_transport_link_up (dev->qp); + +for (q =0 ; q < dev->num_queues; q++) +ntb_transport_link_up (dev->queues[q].qp); +netif_start_queue (ndev);return 0 ; err: -while ((skb =ntb_transport_rx_remove (dev->qp, &len))) -dev_kfree_skb (skb); +for (q =0 ; q < dev->num_queues; q++) { + queue = &dev->queues[q]; + +while ((skb =ntb_transport_rx_remove (queue->qp, &len))) +dev_kfree_skb (skb); + }return rc; }static int ntb_netdev_close (struct net_device *ndev) {struct ntb_netdev *dev =netdev_priv (ndev); +struct ntb_netdev_queue *queue;struct sk_buff *skb; +unsigned int q;int len; -ntb_transport_link_down (dev->qp); -while ((skb =ntb_transport_rx_remove (dev->qp, &len))) -dev_kfree_skb (skb); +for (q =0 ; q < dev->num_queues; q++) { + queue = &dev->queues[q]; + +ntb_transport_link_down (queue->qp); -timer_delete_sync (&dev->tx_timer); +while ((skb =ntb_transport_rx_remove (queue->qp, &len))) +dev_kfree_skb (skb); +timer_delete_sync (&queue->tx_timer); + }return 0 ; }static int ntb_netdev_change_mtu (struct net_device *ndev,int new_mtu) {struct ntb_netdev *dev =netdev_priv (ndev); +struct ntb_netdev_queue *queue;struct sk_buff *skb; -int len, rc; +unsigned int q, i; +int len, rc =0 ; -if (new_mtu >ntb_transport_max_size (dev->qp) -ETH_HLEN ) +if (new_mtu >ntb_transport_max_size (dev->queues[0 ].qp) -ETH_HLEN )return -EINVAL ;if (!netif_running (ndev)) {
@@ -311,41 +361,54 @@ static int ntb_netdev_change_mtu(struct net_device *ndev, int new_mtu) }/* Bring down the link and dispose of posted rx entries */ -ntb_transport_link_down (dev->qp); +for (q =0 ; q < dev->num_queues; q++) +ntb_transport_link_down (dev->queues[q].qp);if (ndev->mtu < new_mtu) { -int i; - -for (i =0 ; (skb =ntb_transport_rx_remove (dev->qp, &len)); i++) -dev_kfree_skb (skb); +for (q =0 ; q < dev->num_queues; q++) { + queue = &dev->queues[q]; -for (; i; i--) { - skb =netdev_alloc_skb (ndev, new_mtu +ETH_HLEN ); -if (!skb) { - rc = -ENOMEM ; - goto err; - } - - rc =ntb_transport_rx_enqueue (dev->qp, skb, skb->data, - new_mtu +ETH_HLEN ); -if (rc) { +for (i =0 ; + (skb =ntb_transport_rx_remove (queue->qp, &len)); + i++)dev_kfree_skb (skb); - goto err; + +for (; i; i--) { + skb =netdev_alloc_skb (ndev, + new_mtu +ETH_HLEN ); +if (!skb) { + rc = -ENOMEM ; + goto err; + } + + rc =ntb_transport_rx_enqueue (queue->qp, skb, + skb->data, + new_mtu + +ETH_HLEN ); +if (rc) { +dev_kfree_skb (skb); + goto err; + } } } }WRITE_ONCE (ndev->mtu, new_mtu); -ntb_transport_link_up (dev->qp); +for (q =0 ; q < dev->num_queues; q++) +ntb_transport_link_up (dev->queues[q].qp);return 0 ; err: -ntb_transport_link_down (dev->qp); +for (q =0 ; q < dev->num_queues; q++) { +struct ntb_netdev_queue *queue = &dev->queues[q]; -while ((skb =ntb_transport_rx_remove (dev->qp, &len))) -dev_kfree_skb (skb); +ntb_transport_link_down (queue->qp); + +while ((skb =ntb_transport_rx_remove (queue->qp, &len))) +dev_kfree_skb (skb); + }netdev_err (ndev,"Error changing MTU, device inoperable\n" );return rc;
@@ -404,6 +467,7 @@ static int ntb_netdev_probe(struct device *client_dev)struct net_device *ndev;struct pci_dev *pdev;struct ntb_netdev *dev; +unsigned int q;int rc; ntb =dev_ntb (client_dev->parent);
@@ -411,7 +475,7 @@ static int ntb_netdev_probe(struct device *client_dev)if (!pdev)return -ENODEV ; - ndev =alloc_etherdev (sizeof (*dev)); + ndev =alloc_etherdev_mq (sizeof (*dev),NTB_NETDEV_MAX_QUEUES );if (!ndev)return -ENOMEM ;
@@ -420,6 +484,16 @@ static int ntb_netdev_probe(struct device *client_dev) dev =netdev_priv (ndev); dev->ndev = ndev; dev->pdev = pdev; + dev->client_dev = client_dev; + dev->num_queues =0 ; + + dev->queues =kzalloc_objs (*dev->queues,NTB_NETDEV_MAX_QUEUES , +GFP_KERNEL ); +if (!dev->queues) { + rc = -ENOMEM ; + goto err_free_netdev; + } + ndev->features =NETIF_F_HIGHDMA ; ndev->priv_flags |=IFF_LIVE_ADDR_CHANGE ;
@@ -436,26 +510,47 @@ static int ntb_netdev_probe(struct device *client_dev) ndev->min_mtu =0 ; ndev->max_mtu =ETH_MAX_MTU ; - dev->qp =ntb_transport_create_queue (ndev, client_dev, - &ntb_netdev_handlers); -if (!dev->qp) { +for (q =0 ; q <NTB_NETDEV_DEFAULT_QUEUES ; q++) { +struct ntb_netdev_queue *queue = &dev->queues[q]; + + queue->ntdev = dev; + queue->qid = q; + queue->qp =ntb_transport_create_queue (queue, client_dev, + &ntb_netdev_handlers); +if (!queue->qp) +break ; + + dev->num_queues++; + } + +if (!dev->num_queues) { rc = -EIO ; - goto err; + goto err_free_queues; } - ndev->mtu =ntb_transport_max_size (dev->qp) -ETH_HLEN ; + rc =netif_set_real_num_queues (ndev, dev->num_queues, dev->num_queues); +if (rc) + goto err_free_qps; + + ndev->mtu =ntb_transport_max_size (dev->queues[0 ].qp) -ETH_HLEN ; rc =register_netdev (ndev);if (rc) - goto err1; + goto err_free_qps;dev_set_drvdata (client_dev, ndev); -dev_info (&pdev->dev,"%s created\n" , ndev->name); +dev_info (&pdev->dev,"%s created with %u queue pairs\n" , + ndev->name, dev->num_queues);return 0 ; -err1: -ntb_transport_free_queue (dev->qp); -err: +err_free_qps: +for (q =0 ; q < dev->num_queues; q++) +ntb_transport_free_queue (dev->queues[q].qp); + +err_free_queues: +kfree (dev->queues); + +err_free_netdev:free_netdev (ndev);return rc; }
@@ -464,9 +559,13 @@ static void ntb_netdev_remove(struct device *client_dev) {struct net_device *ndev =dev_get_drvdata (client_dev);struct ntb_netdev *dev =netdev_priv (ndev); +unsigned int q;unregister_netdev (ndev); -ntb_transport_free_queue (dev->qp); +for (q =0 ; q < dev->num_queues; q++) +ntb_transport_free_queue (dev->queues[q].qp); + +kfree (dev->queues);free_netdev (ndev); }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/2 NTB: ntb_netdev: Preserve RX queue depth on allocation failure
From: Koichiro Den <[email protected]>
[ Upstream commit d2121faf133ac3bf9531b53a7e21273649a08517 ]
ntb_netdev_rx_handler() hands the received skb to the network stack before allocating its replacement. If the allocation fails, nothing is reposted. Every failure therefore takes one buffer out of the RX queue while the interface remains up, and enough failures eventually stall reception.
A retry path could refill the queue later, but ntb_netdev has none. Allocate the replacement first instead. If that fails, drop the packet and repost the same skb. This keeps the queue full and lets packet delivery resume as soon as memory is available again.
--- drivers/net/ntb_netdev.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)
drivers/net/ntb_netdev.c +8 -7
@@ -118,8 +118,8 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, {struct ntb_netdev_queue *q = qp_data;struct ntb_netdev *dev = q->ntdev; +struct sk_buff *skb, *new_skb;struct net_device *ndev; -struct sk_buff *skb;int rc; ndev = dev->ndev;
@@ -135,6 +135,12 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, goto enqueue_again; } + new_skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); +if (!new_skb) { + ndev->stats.rx_dropped++; + goto enqueue_again; + } +skb_put (skb, len); skb->protocol =eth_type_trans (skb, ndev); skb->ip_summed =CHECKSUM_NONE ;
@@ -148,12 +154,7 @@ static void ntb_netdev_rx_handler(struct ntb_transport_qp *qp, void *qp_data, ndev->stats.rx_bytes += len; } - skb =netdev_alloc_skb (ndev, ndev->mtu +ETH_HLEN ); -if (!skb) { - ndev->stats.rx_errors++; - ndev->stats.rx_frame_errors++; -return ; - } + skb = new_skb; enqueue_again: rc =ntb_transport_rx_enqueue (qp, skb, skb->data, ndev->mtu +ETH_HLEN );
Signature · 1 line
2.53.0