* [PATCH net v11 0/2] tun: fix re-attaching the socket filter
@ 2026-11-19 3:22 Rongguang Wei
2026-11-19 3:22 ` [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit() Rongguang Wei
2026-11-19 3:22 ` [PATCH net v11 2/2] selftests: net: add TAP socket filter attach tests Rongguang Wei
0 siblings, 2 replies; 7+ messages in thread
From: Rongguang Wei @ 2026-11-19 3:22 UTC (permalink / raw)
To: netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem,
alexei.starovoitov, kuba, Rongguang Wei
From: Rongguang Wei <weirongguang@kylinos.cn>
This series fixes attaching a queue to a TAP device, which re-installs the
socket filter of a persistent device.
TUNATTACHFILTER keeps only the sock_fprog header, so the instructions are
read from user space again for every queue that is attached later. Keep
the program on the device instead, run it from tun_net_xmit(), and record
IFF_NOFILTER per queue.
Patch 1 does that, patch 2 adds selftests for the re-attach, for bad
programs with and without queues, and for the IFF_NOFILTER paths.
Thanks to Willem de Bruijn and Alexei Starovoitov for the reviews.
---
v11:
- keep one program on the device instead of a copy per queue, as Alexei
suggested; sk_attach_filter_kern() and bpf_prog_validate_classic() are
gone with it
- TUNDETACHFILTER now applies to queues detached with IFF_DETACH_QUEUE too
- selftests: cover the zero-queue and detached-queue paths
v10:
- add bpf@vger.kernel.org and the BPF maintainers to Cc
- selftests: fix the queue numbering and add a zero-queue case
- https://lore.kernel.org/netdev/20261030060043.94719-1-clementwei90@163.com/
v9:
- zero the whole sock_fprog header, so that the padding TUNGETFILTER
copies is not uninitialized stack
- https://lore.kernel.org/netdev/20261030060043.94719-1-clementwei90@163.com/
v8:
- narrow the bpf_prog_validate_classic() contract to the classic
verifier and note that it can also return -ENOMEM
- commit the new program only after every queue took it
- https://lore.kernel.org/netdev/20261028093235.148649-1-clementwei90@163.com/
v7:
- verify the instructions before anything is replaced
- fix the kernel-doc of sk_attach_filter_kern()
- reject a program whose length is out of range before allocating memory
- selftests: add a case for a rejected program with valid length and bad
instructions
- https://lore.kernel.org/netdev/20261023092239.186665-1-clementwei90@163.com/
v6:
- add description for return value of sk_attach_filter_kern()
- https://lore.kernel.org/netdev/20261016070654.170932-1-clementwei90@163.com/
v5:
- add kernel-doc for sk_attach_filter_kern()
- fix the wording of the mprotect() comment
- https://lore.kernel.org/netdev/20261012021113.45939-1-clementwei90@163.com/
v4:
- merge the kernel copy and the error check into one patch
- charge the kernel copy to the caller's memory cgroup
- https://lore.kernel.org/netdev/20261003063859.136895-1-clementwei90@163.com/
v3:
- reorder: the kernel copy of the program comes before the corrected
error check
- add sk_attach_filter_kern() in the patch that first uses it
- https://lore.kernel.org/netdev/20260930080746.135017-1-clementwei90@163.com/
v2:
- roll back the filter attach when a later step of tun_attach() fails
- keep a copy of the program in the kernel
- add selftests for the re-attach and for a rejected TUNATTACHFILTER
- https://lore.kernel.org/netdev/20260929093712.131096-1-clementwei90@163.com/
v1:
- https://lore.kernel.org/netdev/20260923025653.59348-1-clementwei90@163.com/
drivers/net/tun.c | 93 ++++-----
tools/testing/selftests/net/tun.c | 358 ++++++++++++++++++++++++++++++
2 files changed, 401 insertions(+), 50 deletions(-)
base-commit: 20eef29b7c8465ac98d7dd6d6f2ac07a8d8056ca
--
2.43.0
No virus found
Checked by Hillstone Network AntiVirus
^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit()
2026-11-19 3:22 [PATCH net v11 0/2] tun: fix re-attaching the socket filter Rongguang Wei
@ 2026-11-19 3:22 ` Rongguang Wei
2026-11-19 3:47 ` Alexei Starovoitov
2026-11-19 3:22 ` [PATCH net v11 2/2] selftests: net: add TAP socket filter attach tests Rongguang Wei
1 sibling, 1 reply; 7+ messages in thread
From: Rongguang Wei @ 2026-11-19 3:22 UTC (permalink / raw)
To: netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem,
alexei.starovoitov, kuba, Rongguang Wei
From: Rongguang Wei <weirongguang@kylinos.cn>
TUNATTACHFILTER copies only the sock_fprog header, so tun->fprog.filter
points into the address space of the process that issued the ioctl, and
tun_attach() reads it again whenever a queue is attached to a persistent
device. That read can fail, and with the inverted check below the
failure was not fatal either: the queue was attached without a filter,
while a successful read returned early and left the queue unpublished.
Keep the program on the device instead: TUNATTACHFILTER builds it once
with bpf_prog_create_from_user() and stores it in tun->cbpf_prog, and
tun_net_xmit() runs it from there. A per-queue flag records whether the
queue was attached with IFF_NOFILTER, so a queue attached later does not
depend on the caller's buffer at all.
The inverted check was discovered by manual code inspection first.
Fixes: 54f968d6efdb ("tuntap: move socket to tun_file")
Suggested-by: Alexei Starovoitov <alexei.starovoitov@gmail.com>
Signed-off-by: Rongguang Wei <weirongguang@kylinos.cn>
---
drivers/net/tun.c | 93 ++++++++++++++++++++++-------------------------
1 file changed, 43 insertions(+), 50 deletions(-)
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 86fd44e107550..b599a8932f027 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -135,6 +135,7 @@ struct tun_file {
struct fasync_struct *fasync;
/* only used for fasnyc */
unsigned int flags;
+ bool nofilter; /* attached with IFF_NOFILTER */
union {
u16 queue_index;
unsigned int ifindex;
@@ -176,8 +177,8 @@ struct tun_prog {
};
/* Since the socket were moved to tun_file, to preserve the behavior of persist
- * device, socket filter, sndbuf and vnet header size were restore when the
- * file were attached to a persist device.
+ * device, sndbuf and vnet header size were restore when the file were attached
+ * to a persist device.
*/
struct tun_struct {
struct tun_file __rcu *tfiles[MAX_TAP_QUEUES];
@@ -196,9 +197,7 @@ struct tun_struct {
int vnet_hdr_sz;
int sndbuf;
struct tap_filter txflt;
- struct sock_fprog fprog;
- /* protected by rtnl lock */
- bool filter_attached;
+ struct sock_fprog fprog; /* header, for TUNGETFILTER */
u32 msg_enable;
spinlock_t lock;
struct hlist_head flows[TUN_NUM_FLOW_ENTRIES];
@@ -213,6 +212,7 @@ struct tun_struct {
struct bpf_prog __rcu *xdp_prog;
struct tun_prog __rcu *steering_prog;
struct tun_prog __rcu *filter_prog;
+ struct tun_prog __rcu *cbpf_prog; /* from TUNATTACHFILTER */
struct ethtool_link_ksettings link_ksettings;
/* init args */
struct file *file;
@@ -731,7 +731,7 @@ static void tun_force_wake_queue(struct tun_struct *tun,
}
static int tun_attach(struct tun_struct *tun, struct file *file,
- bool skip_filter, bool napi, bool napi_frags,
+ bool nofilter, bool napi, bool napi_frags,
bool publish_tun)
{
struct tun_file *tfile = file->private_data;
@@ -757,15 +757,6 @@ static int tun_attach(struct tun_struct *tun, struct file *file,
err = 0;
- /* Re-attach the filter to persist device */
- if (!skip_filter && (tun->filter_attached == true)) {
- lock_sock(tfile->socket.sk);
- err = sk_attach_filter(&tun->fprog, tfile->socket.sk);
- release_sock(tfile->socket.sk);
- if (!err)
- goto out;
- }
-
if (!tfile->detached &&
ptr_ring_resize(&tfile->tx_ring, dev->tx_queue_len,
GFP_KERNEL, tun_ptr_free)) {
@@ -819,6 +810,7 @@ static int tun_attach(struct tun_struct *tun, struct file *file,
* initialized tfile; otherwise we risk using half-initialized
* object.
*/
+ WRITE_ONCE(tfile->nofilter, nofilter);
if (publish_tun)
rcu_assign_pointer(tfile->tun, tun);
rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile);
@@ -1071,6 +1063,7 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
int txq = skb->queue_mapping;
struct netdev_queue *queue;
struct tun_file *tfile;
+ struct tun_prog *prog;
int len = skb->len;
int ret;
@@ -1096,10 +1089,20 @@ static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev)
goto drop;
}
- if (tfile->socket.sk->sk_filter) {
- drop_reason = sk_filter_reason(tfile->socket.sk, skb);
- if (drop_reason)
+ /* Classic filter set with TUNATTACHFILTER. A queue attached with
+ * IFF_NOFILTER does not run it.
+ */
+ prog = rcu_dereference(tun->cbpf_prog);
+ if (prog && !READ_ONCE(tfile->nofilter)) {
+ /* A filter returning 0 drops the packet, any other value is
+ * the length to keep. pskb_trim() does nothing when that
+ * length is larger than the skb.
+ */
+ len = bpf_prog_run_clear_cb(prog->prog, skb);
+ if (!len || pskb_trim(skb, len)) {
+ drop_reason = SKB_DROP_REASON_SOCKET_FILTER;
goto drop;
+ }
}
len = run_ebpf_filter(tun, skb, len);
@@ -2417,6 +2420,7 @@ static void tun_free_netdev(struct net_device *dev)
security_tun_dev_free_security(tun->security);
__tun_set_ebpf(tun, &tun->steering_prog, NULL);
__tun_set_ebpf(tun, &tun->filter_prog, NULL);
+ __tun_set_ebpf(tun, &tun->cbpf_prog, NULL);
}
static void tun_setup(struct net_device *dev)
@@ -2975,7 +2979,6 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
tun->align = NET_SKB_PAD;
- tun->filter_attached = false;
tun->sndbuf = tfile->socket.sk->sk_sndbuf;
tun->rx_batched = 0;
RCU_INIT_POINTER(tun->steering_prog, NULL);
@@ -3079,39 +3082,34 @@ static int set_offload(struct tun_struct *tun, unsigned long arg)
return 0;
}
-static void tun_detach_filter(struct tun_struct *tun, int n)
+static int tun_attach_filter(struct tun_struct *tun, void __user *data)
{
- int i;
+ struct sock_fprog fprog;
struct tun_file *tfile;
+ struct bpf_prog *prog;
+ int i, ret;
- for (i = 0; i < n; i++) {
- tfile = rtnl_dereference(tun->tfiles[i]);
- lock_sock(tfile->socket.sk);
- sk_detach_filter(tfile->socket.sk);
- release_sock(tfile->socket.sk);
- }
+ if (copy_from_user(&fprog, data, sizeof(fprog)))
+ return -EFAULT;
- tun->filter_attached = false;
-}
+ ret = bpf_prog_create_from_user(&prog, &fprog, NULL, false);
+ if (ret)
+ return ret;
-static int tun_attach_filter(struct tun_struct *tun)
-{
- int i, ret = 0;
- struct tun_file *tfile;
+ ret = __tun_set_ebpf(tun, &tun->cbpf_prog, prog);
+ if (ret) {
+ bpf_prog_destroy(prog);
+ return ret;
+ }
for (i = 0; i < tun->numqueues; i++) {
tfile = rtnl_dereference(tun->tfiles[i]);
- lock_sock(tfile->socket.sk);
- ret = sk_attach_filter(&tun->fprog, tfile->socket.sk);
- release_sock(tfile->socket.sk);
- if (ret) {
- tun_detach_filter(tun, i);
- return ret;
- }
+ WRITE_ONCE(tfile->nofilter, false);
}
- tun->filter_attached = true;
- return ret;
+ /* Only TUNGETFILTER reads it */
+ tun->fprog = fprog;
+ return 0;
}
static void tun_set_sndbuf(struct tun_struct *tun)
@@ -3307,7 +3305,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
if (tfile->detached)
ifr.ifr_flags |= IFF_DETACH_QUEUE;
- if (!tfile->socket.sk->sk_filter)
+ if (tfile->nofilter || !rcu_access_pointer(tun->cbpf_prog))
ifr.ifr_flags |= IFF_NOFILTER;
if (copy_to_user(argp, &ifr, ifreq_len))
@@ -3454,11 +3452,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
ret = -EINVAL;
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
break;
- ret = -EFAULT;
- if (copy_from_user(&tun->fprog, argp, sizeof(tun->fprog)))
- break;
-
- ret = tun_attach_filter(tun);
+ ret = tun_attach_filter(tun, argp);
break;
case TUNDETACHFILTER:
@@ -3466,8 +3460,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
ret = -EINVAL;
if ((tun->flags & TUN_TYPE_MASK) != IFF_TAP)
break;
- ret = 0;
- tun_detach_filter(tun, tun->numqueues);
+ ret = __tun_set_ebpf(tun, &tun->cbpf_prog, NULL);
break;
case TUNGETFILTER:
--
2.43.0
No virus found
Checked by Hillstone Network AntiVirus
^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH net v11 2/2] selftests: net: add TAP socket filter attach tests
2026-11-19 3:22 [PATCH net v11 0/2] tun: fix re-attaching the socket filter Rongguang Wei
2026-11-19 3:22 ` [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit() Rongguang Wei
@ 2026-11-19 3:22 ` Rongguang Wei
1 sibling, 0 replies; 7+ messages in thread
From: Rongguang Wei @ 2026-11-19 3:22 UTC (permalink / raw)
To: netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem,
alexei.starovoitov, kuba, Rongguang Wei
From: Rongguang Wei <weirongguang@kylinos.cn>
Add tests for TUNATTACHFILTER and TUNDETACHFILTER: a queue re-attached
after the buffer the program came from was made unreadable, a bad program
and a bad length with queues attached and with none, a program configured
before any queue, and the IFF_NOFILTER paths.
Signed-off-by: Rongguang Wei <weirongguang@kylinos.cn>
---
tools/testing/selftests/net/tun.c | 358 ++++++++++++++++++++++++++++++
1 file changed, 358 insertions(+)
diff --git a/tools/testing/selftests/net/tun.c b/tools/testing/selftests/net/tun.c
index 34de2580e32ec..ac326193867b0 100644
--- a/tools/testing/selftests/net/tun.c
+++ b/tools/testing/selftests/net/tun.c
@@ -9,9 +9,11 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <linux/filter.h>
#include <linux/if_tun.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
+#include <sys/mman.h>
#include <sys/socket.h>
#include "kselftest_harness.h"
@@ -548,6 +550,362 @@ TEST_F(tun, reattach_close_delete)
EXPECT_EQ(tun_delete(self->ifname), 0);
}
+/* accept: return skb->len. Three instructions on purpose, so that the
+ * length read back through TUNGETFILTER tells it apart from a rejected
+ * program that is shorter.
+ */
+static const struct sock_filter filter_accept[] = {
+ BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0),
+ BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0),
+ BPF_STMT(BPF_RET | BPF_A, 0),
+};
+
+/* Put the instructions in an anonymous mapping, so that the test can make the
+ * address unreadable afterwards.
+ */
+static void *filter_alloc(const struct sock_filter *insns, unsigned int len)
+{
+ void *p;
+
+ p = mmap(NULL, getpagesize(), PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (p == MAP_FAILED)
+ return NULL;
+
+ memcpy(p, insns, len * sizeof(*insns));
+
+ return p;
+}
+
+static int filter_attach(int fd, const struct sock_filter *insns, unsigned int len)
+{
+ struct sock_fprog fp = {
+ .len = len,
+ .filter = (struct sock_filter *)insns,
+ };
+
+ return ioctl(fd, TUNATTACHFILTER, (void *)&fp);
+}
+
+static int filter_get(int fd, struct sock_fprog *fp)
+{
+ return ioctl(fd, TUNGETFILTER, (void *)fp);
+}
+
+static int tun_get_iff_flags(int fd)
+{
+ struct ifreq ifr = { 0 };
+
+ if (ioctl(fd, TUNGETIFF, (void *)&ifr) < 0)
+ return -1;
+
+ return ifr.ifr_flags;
+}
+
+/*
+ * The program is built when TUNATTACHFILTER is issued, so a queue attached
+ * later does not read the buffer it came from. Here the mapping is made
+ * unreadable before the queue is attached again, and another queue is then
+ * attached from a fresh socket, which starts without a filter of its own.
+ */
+TEST_F(tun, reattach_filter_without_user_buffer)
+{
+ struct sock_fprog gf = { 0 };
+ struct ifreq ifr = { 0 };
+ short flags = 0;
+ void *prog;
+ int fd, ret;
+
+ prog = filter_alloc(filter_accept, ARRAY_SIZE(filter_accept));
+ ASSERT_NE(prog, NULL);
+ ASSERT_EQ(filter_attach(self->fd, prog, ARRAY_SIZE(filter_accept)), 0);
+
+ EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
+
+ /* This memory is no longer readable */
+ ASSERT_EQ(mprotect(prog, getpagesize(), PROT_NONE), 0);
+
+ ret = tun_attach(self->fd, self->ifname);
+ EXPECT_EQ(ret, 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ /* The queue is attached again, not left disabled */
+ EXPECT_EQ(flags & IFF_DETACH_QUEUE, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ /* The two checks below document the expected state, they cannot
+ * tell an installed filter from no filter: tun_detach() leaves the
+ * device program alone, and TUNGETFILTER only returns the header.
+ */
+ EXPECT_EQ(filter_get(self->fd, &gf), 0);
+ EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept));
+
+ /* A new queue starts without a filter, so a clear IFF_NOFILTER shows
+ * that the filter configured on the device covers it as well.
+ */
+ fd = open("/dev/net/tun", O_RDWR);
+ ASSERT_GE(fd, 0);
+
+ strcpy(ifr.ifr_name, self->ifname);
+ ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE;
+ EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ close(fd);
+
+ ASSERT_EQ(mprotect(prog, getpagesize(), PROT_READ | PROT_WRITE), 0);
+ ASSERT_EQ(munmap(prog, getpagesize()), 0);
+}
+
+/* A new queue attached with IFF_NOFILTER must not get the filter that is
+ * configured on the device.
+ */
+TEST_F(tun, attach_filter_nofilter_flag)
+{
+ struct ifreq ifr = { 0 };
+ short flags = 0;
+ int fd;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0);
+
+ fd = open("/dev/net/tun", O_RDWR);
+ ASSERT_GE(fd, 0);
+
+ strcpy(ifr.ifr_name, self->ifname);
+ ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE | IFF_NOFILTER;
+ EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER);
+
+ close(fd);
+}
+
+/* A later TUNATTACHFILTER covers every queue of the device, including one that
+ * was attached with IFF_NOFILTER.
+ */
+TEST_F(tun, attach_filter_clears_nofilter_queue)
+{
+ struct ifreq ifr = { 0 };
+ short flags = 0;
+ int fd;
+
+ fd = open("/dev/net/tun", O_RDWR);
+ ASSERT_GE(fd, 0);
+
+ strcpy(ifr.ifr_name, self->ifname);
+ ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE | IFF_NOFILTER;
+ ASSERT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER);
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept,
+ ARRAY_SIZE(filter_accept)), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ close(fd);
+}
+
+/* After TUNDETACHFILTER a later attach must not install the filter again */
+TEST_F(tun, detach_filter_clears_reattach)
+{
+ short flags = 0;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0);
+ EXPECT_EQ(ioctl(self->fd, TUNDETACHFILTER, 0), 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER);
+
+ EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
+ EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER);
+}
+
+/* TUNDETACHFILTER must clear the filter of a queue that was detached with
+ * IFF_DETACH_QUEUE as well, not only that of the active queues.
+ */
+TEST_F(tun, detach_filter_clears_detached_queue)
+{
+ short flags = 0;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept,
+ ARRAY_SIZE(filter_accept)), 0);
+
+ EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
+ EXPECT_EQ(ioctl(self->fd, TUNDETACHFILTER, 0), 0);
+ EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, IFF_NOFILTER);
+}
+
+/* A TUNATTACHFILTER with a bad length must leave the installed program and the
+ * filter state that TUNGETIFF reports alone.
+ */
+TEST_F(tun, attach_filter_bad_len_keeps_program)
+{
+ struct sock_fprog gf = { 0 };
+ struct ifreq ifr = { 0 };
+ short flags = 0;
+ int fd;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept, ARRAY_SIZE(filter_accept)), 0);
+
+ errno = 0;
+ EXPECT_EQ(filter_attach(self->fd, filter_accept, 0), -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ EXPECT_EQ(filter_get(self->fd, &gf), 0);
+ EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept));
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ /* A queue attached afterwards still gets the filter, so the rejected
+ * ioctl left the program on the device alone.
+ */
+ fd = open("/dev/net/tun", O_RDWR);
+ ASSERT_GE(fd, 0);
+
+ strcpy(ifr.ifr_name, self->ifname);
+ ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE;
+ EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ close(fd);
+}
+
+/* A TUNATTACHFILTER with instructions that bpf_check_classic() rejects must
+ * be refused, and must leave the program that is installed in place.
+ */
+TEST_F(tun, attach_filter_bad_prog_keeps_program)
+{
+ struct sock_fprog gf = { 0 };
+ struct sock_filter bad[] = {
+ BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
+ };
+ struct ifreq ifr = { 0 };
+ short flags = 0;
+ int fd;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept,
+ ARRAY_SIZE(filter_accept)), 0);
+
+ errno = 0;
+ EXPECT_EQ(filter_attach(self->fd, bad, ARRAY_SIZE(bad)), -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ /* the program attached before is untouched */
+ EXPECT_EQ(filter_get(self->fd, &gf), 0);
+ EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept));
+
+ /* IFF_NOFILTER comes from the program kept on the device, not from
+ * the saved header, so a clear flag shows the filter is still there.
+ */
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ /* A queue attached afterwards still gets the filter, so the rejected
+ * program never replaced the one on the device.
+ */
+ fd = open("/dev/net/tun", O_RDWR);
+ ASSERT_GE(fd, 0);
+
+ strcpy(ifr.ifr_name, self->ifname);
+ ifr.ifr_flags = IFF_TAP | IFF_MULTI_QUEUE;
+ EXPECT_GE(ioctl(fd, TUNSETIFF, (void *)&ifr), 0);
+
+ flags = tun_get_iff_flags(fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+
+ close(fd);
+}
+
+/* The program is built by TUNATTACHFILTER itself, so a bad one has to be
+ * refused even when there is no queue attached. A program that is only
+ * refused when it is built would otherwise be saved and break every later
+ * attach. Detach all queues, check that a bad length and a bad program are
+ * still refused, and that a re-attached queue gets the program installed
+ * before.
+ */
+TEST_F(tun, attach_filter_bad_keeps_program_without_queues)
+{
+ struct sock_fprog gf = { 0 };
+ struct sock_filter bad[] = {
+ BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0),
+ BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
+ };
+ short flags = 0;
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept,
+ ARRAY_SIZE(filter_accept)), 0);
+
+ EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
+ EXPECT_EQ(tun_detach(self->fd2, self->ifname), 0);
+
+ errno = 0;
+ EXPECT_EQ(filter_attach(self->fd, filter_accept, 0), -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ errno = 0;
+ EXPECT_EQ(filter_attach(self->fd, bad, ARRAY_SIZE(bad)), -1);
+ EXPECT_EQ(errno, EINVAL);
+
+ /* The rejected ioctls did not replace the program on the device */
+ EXPECT_EQ(filter_get(self->fd, &gf), 0);
+ EXPECT_EQ(gf.len, ARRAY_SIZE(filter_accept));
+
+ /* The queue gets that program again, from the device */
+ EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+}
+
+/* A program configured while no queue is attached must cover the queues that
+ * are attached afterwards.
+ */
+TEST_F(tun, attach_filter_without_queues_then_attach)
+{
+ short flags = 0;
+
+ EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
+ EXPECT_EQ(tun_detach(self->fd2, self->ifname), 0);
+
+ ASSERT_EQ(filter_attach(self->fd, filter_accept,
+ ARRAY_SIZE(filter_accept)), 0);
+
+ EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
+
+ flags = tun_get_iff_flags(self->fd);
+ EXPECT_GE(flags, 0);
+ EXPECT_EQ(flags & IFF_NOFILTER, 0);
+}
+
FIXTURE(tun_vnet_gso)
{
char ifname[IFNAMSIZ];
--
2.43.0
No virus found
Checked by Hillstone Network AntiVirus
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit()
2026-11-19 3:22 ` [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit() Rongguang Wei
@ 2026-11-19 3:47 ` Alexei Starovoitov
2026-11-19 5:42 ` Rongguang Wei
0 siblings, 1 reply; 7+ messages in thread
From: Alexei Starovoitov @ 2026-11-19 3:47 UTC (permalink / raw)
To: Rongguang Wei, netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem, kuba,
Rongguang Wei
On Wed, Nov 18, 2026 at 07:22 PM Rongguang Wei <clementwei90@163.com> wrote:
> drivers/net/tun.c | 93 ++++++++++++++++++++++-------------------------
> 1 file changed, 43 insertions(+), 50 deletions(-)
Why did you lose removal of exports?
The changelog doesn't say why.
pw-bot: cr
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit()
2026-11-19 3:47 ` Alexei Starovoitov
@ 2026-11-19 5:42 ` Rongguang Wei
2026-11-19 6:18 ` Alexei Starovoitov
0 siblings, 1 reply; 7+ messages in thread
From: Rongguang Wei @ 2026-11-19 5:42 UTC (permalink / raw)
To: Alexei Starovoitov, netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem, kuba,
Rongguang Wei
Alexei Starovoitov wrote:
> On Wed, Nov 18, 2026 at 07:22 PM Rongguang Wei <clementwei90@163.com> wrote:
>> drivers/net/tun.c | 93 ++++++++++++++++++++++-------------------------
>> 1 file changed, 43 insertions(+), 50 deletions(-)
>
> Why did you lose removal of exports?
> The changelog doesn't say why.
>
> pw-bot: cr
Hi,
I see the export removal as a separate cleanup rather than part of this fix.
This series is a -net fix with a Fixes: tag, so I think it should send the removal
separately.
Sorry for lost in changelog.
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit()
2026-11-19 5:42 ` Rongguang Wei
@ 2026-11-19 6:18 ` Alexei Starovoitov
2026-11-19 6:51 ` Rongguang Wei
0 siblings, 1 reply; 7+ messages in thread
From: Alexei Starovoitov @ 2026-11-19 6:18 UTC (permalink / raw)
To: Rongguang Wei, netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem, kuba,
Rongguang Wei
On Wed, Nov 18, 2026 at 09:42 PM Rongguang Wei <clementwei90@163.com> wrote:
> I see the export removal as a separate cleanup rather than part of this fix.
> This series is a -net fix with a Fixes: tag, so I think it should send the removal
> separately.
Disagree.
The two exports exist for tun only.
This patch removes the last caller in a module.
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit()
2026-11-19 6:18 ` Alexei Starovoitov
@ 2026-11-19 6:51 ` Rongguang Wei
0 siblings, 0 replies; 7+ messages in thread
From: Rongguang Wei @ 2026-11-19 6:51 UTC (permalink / raw)
To: Alexei Starovoitov, netdev
Cc: willemdebruijn.kernel, jasowangio, andrew+netdev, davem, kuba,
Rongguang Wei
Alexei Starovoitov wrote:
> On Wed, Nov 18, 2026 at 09:42 PM Rongguang Wei <clementwei90@163.com> wrote:
>> I see the export removal as a separate cleanup rather than part of this fix.
>> This series is a -net fix with a Fixes: tag, so I think it should send the removal
>> separately.
>
> Disagree.
> The two exports exist for tun only.
> This patch removes the last caller in a module.
OK.
I'll add it back and fold it into patch 1.
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2026-11-19 6:51 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 3:22 [PATCH net v11 0/2] tun: fix re-attaching the socket filter Rongguang Wei
2026-11-19 3:22 ` [PATCH net v11 1/2] tun: run the socket filter from tun_net_xmit() Rongguang Wei
2026-11-19 3:47 ` Alexei Starovoitov
2026-11-19 5:42 ` Rongguang Wei
2026-11-19 6:18 ` Alexei Starovoitov
2026-11-19 6:51 ` Rongguang Wei
2026-11-19 3:22 ` [PATCH net v11 2/2] selftests: net: add TAP socket filter attach tests Rongguang Wei
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.