Netdev List
 help / color / mirror / Atom feed
From: netdev-bot+sashiko@kernel.org
To: antonio@mandelbit.com
Cc: willemdebruijn.kernel@gmail.com, jasowangio@gmail.com,
	andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@kernel.org,
	kuba@kernel.org, pabeni@redhat.com, horms@kernel.org,
	mst@redhat.com, eperezma@redhat.com, shuah@kernel.org,
	ast@kernel.org, daniel@iogearbox.net, hawk@kernel.org,
	john.fastabend@gmail.com, sdf@fomichev.me, maheshb@google.com,
	peterpenkov96@gmail.com, netdev@vger.kernel.org,
	virtualization@lists.linux.dev, linux-kselftest@vger.kernel.org,
	bpf@vger.kernel.org
Subject: Re: [PATCH net v6 1/2] tun: bound the NAPI receive queue
Date: Tue, 17 Nov 2026 22:17:08 +0000	[thread overview]
Message-ID: <179495382870.3136.12445611217339402319@kernel.org> (raw)
In-Reply-To: <20261113212237.1742984-2-antonio@mandelbit.com>

Thank you for your contribution! Sashiko AI review found 3 potential
issue(s) to consider.

Critical: 0 · High: 1 · Medium: 1 · Low: 1

If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).

- [High] The new bound does not close the OOM it is meant to fix.
- [Medium] The queue-full drop is checked before the code decides whether
  the packet will be queued at all, so it also drops traffic that never…
- [Low] The new comment in tun_napi_receive() (drivers/net/tun.c:251-253)
  says the poll takes 'at most budget skbs, so that the queue never…

--

tun: bound the NAPI receive queue

This patch puts a limit on the IFF_NAPI sk_write_queue in tun. Once more
than netdev_max_backlog packets are queued, tun_get_user() and
tun_xdp_one() drop new packets and schedule NAPI. The poll now takes at
most budget skbs at a time, instead of splicing out the whole queue.

> diff --git a/drivers/net/tun.c b/drivers/net/tun.c
> index 86fd44e107550..73f13684722ea 100644
> --- a/drivers/net/tun.c
> +++ b/drivers/net/tun.c

[ ... ]

> @@ -227,6 +228,16 @@ struct veth {
>  static void tun_flow_init(struct tun_struct *tun);
>  static void tun_flow_uninit(struct tun_struct *tun);
>  
> +/* In IFF_NAPI mode written packets wait in the tfile's sk_write_queue for the
> + * NAPI poll, which may run later in a kthread or ksoftirqd. Bound that queue
> + * like the per-CPU backlog of netif_rx().
> + */
> +static bool tun_napi_queue_full(const struct sk_buff_head *queue)
> +{
> +	return skb_queue_len_lockless(queue) >
> +	       READ_ONCE(net_hotdata.max_backlog);
> +}

[Severity: High]

Does this limit prevent the global OOM described in the commit message?
The only limit is a per-tfile packet count against the global
net_hotdata.max_backlog. The queued skbs are still not charged to the
writer's memcg.

An unprivileged user in its own user and network namespace can multiply
this cap. tun_set_iff() only needs CAP_NET_ADMIN in the user namespace to
create a multi-queue device:

drivers/net/tun.c:tun_set_iff() {
    ...
		int queues = ifr->ifr_flags & IFF_MULTI_QUEUE ?
			     MAX_TAP_QUEUES : 1;

		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
			return -EPERM;
    ...
}

That allows up to 256 queues per device, plus more devices and more
namespaces. netdev_max_backlog itself can only be changed from init_net.

Each queue can hold about max_backlog + budget + one skb per concurrent
writer. The reproducer sends 1400-byte TUN packets, with a truesize of
about 2.3 KB. That works out to about 2.3 MB per queue and about 600 MB
for one 256-queue device. A few such devices would reach several GB of
uncharged memory, whatever the memcg limit is.

The commit message says:

  "This is hard to reach in practice: with large packets the writer's
  copy is slower than the NAPI poll, so the queue does not fill."

That covers large packets on a single queue. Does it also cover small
packets spread over many queues, which is the reproducer's own traffic
pattern?

The writer also controls the per-packet poll cost through the number of
iptables rules. So larger packets can fill each queue too, at about
64 MB per queue with 64 KB packets.

Would this need byte or memcg accounting of the queued skbs, or a
per-owner limit, instead of a per-queue packet count?

>  static int tun_napi_receive(struct napi_struct *napi, int budget)
>  {
>  	struct tun_file *tfile = container_of(napi, struct tun_file, napi);
> @@ -237,21 +248,24 @@ static int tun_napi_receive(struct napi_struct *napi, int budget)
>  
>  	__skb_queue_head_init(&process_queue);
>  
> +	/* Take at most budget skbs, so that the queue never looks emptier to
> +	 * writers than it is.
> +	 */
> +	spin_lock(&queue->lock);
> -	skb_queue_splice_tail_init(queue, &process_queue);
> +	if (skb_queue_len(queue) <= budget) {
> +		skb_queue_splice_tail_init(queue, &process_queue);
> +	} else {
> +		while (skb_queue_len(&process_queue) < budget &&
> +		       (skb = __skb_dequeue(queue)))
> +			__skb_queue_tail(&process_queue, skb);
> +	}
>  	spin_unlock(&queue->lock);

[Severity: Low]

This isn't a bug, but is this comment accurate? The poll still moves up
to budget skbs from sk_write_queue into the local process_queue. It then
drops the lock and calls napi_gro_receive() on them.

tun_napi_queue_full() only reads the qlen of sk_write_queue. So while
the poll runs, writers can see a queue up to budget skbs shorter than
the real backlog.

Would "at most budget emptier" be a better description? The effective
limit would then be about max_backlog + budget + one skb per concurrent
writer.

[ ... ]

> @@ -1862,6 +1876,20 @@ static ssize_t tun_get_user(struct tun_struct *tun, struct tun_file *tfile,
>  			zerocopy = true;
>  	}
>  
> +	/* NAPI queue full: drop before allocating, and schedule NAPI, which a
> +	 * MSG_MORE sender may not have done yet. Lockless: concurrent writers
> +	 * can each still add one.
> +	 */
> +	if (tfile->napi_enabled &&
> +	    unlikely(tun_napi_queue_full(&tfile->sk.sk_write_queue))) {
> +		local_bh_disable();
> +		napi_schedule(&tfile->napi);
> +		local_bh_enable();
> +		net_zcopy_put(msg_control);
> +		dev_core_stats_rx_dropped_inc(tun->dev);
> +		return total_len;
> +	}
> +
>  	if (!frags && tun_can_build_skb(tun, tfile, len, noblock, zerocopy)) {

[ ... ]

> @@ -2568,6 +2596,17 @@ static int tun_xdp_one(struct tun_struct *tun,
>  		return -EIO;
>  	}
>  
> +	/* NAPI queue full: drop, and schedule NAPI so that it drains even if
> +	 * nothing in this batch gets queued
> +	 */
> +	if (tfile->napi_enabled &&
> +	    unlikely(tun_napi_queue_full(&tfile->sk.sk_write_queue))) {
> +		napi_schedule(&tfile->napi);
> +		put_page(virt_to_head_page(xdp->data));
> +		dev_core_stats_rx_dropped_inc(tun->dev);
> +		return 0;
> +	}
> +
>  	xdp_prog = rcu_dereference(tun->xdp_prog);

[Severity: Medium]

Could these checks drop traffic that would never be queued on
sk_write_queue?

In tun_xdp_one() the check runs before the attached XDP program. Frames
the program would XDP_REDIRECT or XDP_TX return early and never reach
__skb_queue_tail(). They are now dropped and counted as rx_dropped
whenever the NAPI queue is over the limit.

The check in tun_get_user() runs before tun_build_skb(). That is where
native XDP runs for the TAP build_skb path, and non-PASS verdicts return
there without building or queueing an skb:

drivers/net/tun.c:tun_build_skb() {
    ...
		if (err == XDP_REDIRECT)
			xdp_do_flush();
		if (err != XDP_PASS)
			goto out;
    ...
}

It also runs before the generic do_xdp_generic() call.

With IFF_NAPI_FRAGS, tun_get_user() passes the skb directly to
napi_gro_frags() and never touches sk_write_queue. The check is gated
only on tfile->napi_enabled, which is also set in frags mode.

tun_xdp_one() still queues into sk_write_queue whenever napi_enabled is
set. So small packets batched by vhost-net can fill the queue, and then
the larger packets that go through tun_get_user() and the frags path are
dropped as well.

Take a vhost-net/XDP setup where most traffic is redirected and only
some goes to the local stack. Would the redirected traffic start
dropping as soon as the local stack path backs up?

The commit message says this works "like enqueue_to_backlog()", but
enqueue_to_backlog() only drops skbs it would actually enqueue. Could
the check move to the places where the skb is actually queued? If not,
could the commit message mention this side effect?

-- 
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261113212237.1742984-1-antonio%40mandelbit.com

  reply	other threads:[~2026-11-17 22:17 UTC|newest]

Thread overview: 6+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-13 21:22 [PATCH net v6 0/2] tun: bound the NAPI receive queue Antonio Quartulli
2026-11-13 21:22 ` [PATCH net v6 1/2] " Antonio Quartulli
2026-11-17 22:17   ` netdev-bot+sashiko [this message]
2026-11-13 21:22 ` [PATCH net v6 2/2] selftests: net: add a vhost-net test for the tun NAPI queue bound Antonio Quartulli
2026-11-17 22:17   ` netdev-bot+sashiko
2026-11-13 21:28 ` [PATCH net v6 0/2] tun: bound the NAPI receive queue netdev-bot+sinfo

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=179495382870.3136.12445611217339402319@kernel.org \
    --to=netdev-bot+sashiko@kernel.org \
    --cc=andrew+netdev@lunn.ch \
    --cc=antonio@mandelbit.com \
    --cc=ast@kernel.org \
    --cc=bpf@vger.kernel.org \
    --cc=daniel@iogearbox.net \
    --cc=davem@davemloft.net \
    --cc=edumazet@kernel.org \
    --cc=eperezma@redhat.com \
    --cc=hawk@kernel.org \
    --cc=horms@kernel.org \
    --cc=jasowangio@gmail.com \
    --cc=john.fastabend@gmail.com \
    --cc=kuba@kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=maheshb@google.com \
    --cc=mst@redhat.com \
    --cc=netdev@vger.kernel.org \
    --cc=pabeni@redhat.com \
    --cc=peterpenkov96@gmail.com \
    --cc=sdf@fomichev.me \
    --cc=shuah@kernel.org \
    --cc=virtualization@lists.linux.dev \
    --cc=willemdebruijn.kernel@gmail.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox