net: introduce QUIC infrastructure and core subcomponents

This patch adds IPPROTO_QUIC and SOL_QUIC constants to the networking subsystem. These definitions are essential for applications to set socket options and protocol identifiers related to the QUIC protocol.

QUIC does not possess a protocol number allocated from IANA, and like IPPROTO_MPTCP, IPPROTO_QUIC is merely a value used when opening a QUIC socket with:

  socket(AF_INET, SOCK_STREAM, IPPROTO_QUIC);

Note we did not opt for UDP ULP for QUIC implementation due to several considerations:

- QUIC's connection Migration requires at least 2 UDP sockets for one QUIC connection at the same time, not to mention the multipath feature in one of its draft RFCs.

- In-Kernel QUIC, as a Transport Protocol, wants to provide users with the TCP or SCTP like Socket APIs, like connect()/listen()/accept()... Note that a single UDP socket might even be used for multiple QUIC connections.

The use of IPPROTO_QUIC type sockets over UDP tunnel will effectively address these challenges and provides a more flexible and scalable solution.

Signed-off-by Xin Long <[email protected]>

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

Hi Xin,

Quoted 12 lines

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

...

net/quic/protocol.c line 373

Quoted 5 lines

net/quic/protocol.c new file +5 -0

+module_init(quic_init);
+module_exit(quic_exit);
+
+MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-261");
+MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-261");

Shouldn't this use MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_QUIC) instead?

Quoted 18 lines

Hi Xin,

Quoted 12 lines

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

...

Quoted 9 lines

net/quic/protocol.c line 373

Quoted 5 lines

net/quic/protocol.c new file +5 -0

+module_init(quic_init);
+module_exit(quic_exit);
+
+MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-261");
+MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-261");

Shouldn't this use MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_QUIC) instead?

Hi, Stefan,

If we switch to using MODULE_ALIAS_NET_PF_PROTO(), we still need to keep using the numeric value 261:

   MODULE_ALIAS_NET_PF_PROTO(PF_INET, 261);
   MODULE_ALIAS_NET_PF_PROTO(PF_INET6, 261);

IPPROTO_QUIC is defined as an enum, not a macro. Since MODULE_ALIAS_NET_PF_PROTO() relies on __stringify(proto), it can’t stringify enum values correctly, and it would generate:

alias: net-pf-10-proto-IPPROTO_QUIC
alias: net-pf-2-proto-IPPROTO_QUIC

Am 29.10.25 um 20:57 schrieb Xin Long:

Quoted 36 lines · Stefan Metzmacher

Quoted 18 lines

Hi Xin,

Quoted 12 lines

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

...

Quoted 9 lines

net/quic/protocol.c line 373

Quoted 5 lines

net/quic/protocol.c new file +5 -0

+module_init(quic_init);
+module_exit(quic_exit);
+
+MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-261");
+MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-261");

Shouldn't this use MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_QUIC) instead?

Hi, Stefan,

If we switch to using MODULE_ALIAS_NET_PF_PROTO(), we still need to keep using the numeric value 261:

   MODULE_ALIAS_NET_PF_PROTO(PF_INET, 261);
   MODULE_ALIAS_NET_PF_PROTO(PF_INET6, 261);

Quoted 6 lines

IPPROTO_QUIC is defined as an enum, not a macro. Since MODULE_ALIAS_NET_PF_PROTO() relies on __stringify(proto), it can’t stringify enum values correctly, and it would generate:

alias: net-pf-10-proto-IPPROTO_QUIC
alias: net-pf-2-proto-IPPROTO_QUIC

Yes, now I remember...

Maybe we can use something like this:

(quoted diff) +2 -1

-  IPPROTO_QUIC = 261,          /* A UDP-Based Multiplexed and Secure Transport */
+#define __IPPROTO_QUIC 261     /* A UDP-Based Multiplexed and Secure Transport */
+  IPPROTO_QUIC = __IPPROTO_QUIC,

and then

MODULE_ALIAS_NET_PF_PROTO(PF_INET, __IPPROTO_QUIC)

In order to make things clearer.

What do you think?

Quoted 59 lines

Am 29.10.25 um 20:57 schrieb Xin Long:

Quoted 36 lines · Stefan Metzmacher

Quoted 18 lines

Hi Xin,

Quoted 12 lines

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

...

Quoted 9 lines

net/quic/protocol.c line 373

Quoted 5 lines

net/quic/protocol.c new file +5 -0

+module_init(quic_init);
+module_exit(quic_exit);
+
+MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-261");
+MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-261");

Shouldn't this use MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_QUIC) instead?

Hi, Stefan,

If we switch to using MODULE_ALIAS_NET_PF_PROTO(), we still need to keep using the numeric value 261:

    MODULE_ALIAS_NET_PF_PROTO(PF_INET, 261);
    MODULE_ALIAS_NET_PF_PROTO(PF_INET6, 261);

Quoted 6 lines

IPPROTO_QUIC is defined as an enum, not a macro. Since MODULE_ALIAS_NET_PF_PROTO() relies on __stringify(proto), it can’t stringify enum values correctly, and it would generate:

alias: net-pf-10-proto-IPPROTO_QUIC
alias: net-pf-2-proto-IPPROTO_QUIC

Yes, now I remember...

Maybe we can use something like this:

(quoted diff) +2 -1

-  IPPROTO_QUIC = 261,          /* A UDP-Based Multiplexed and Secure Transport */
+#define __IPPROTO_QUIC 261     /* A UDP-Based Multiplexed and Secure Transport */
+  IPPROTO_QUIC = __IPPROTO_QUIC,

and then

MODULE_ALIAS_NET_PF_PROTO(PF_INET, __IPPROTO_QUIC)

In order to make things clearer.

Quoted 2 lines

What do you think?

That might be a good idea to make things clearer later on.

But for now, I’d prefer not to add something special just for QUIC in include/uapi/linux/in.h. We can revisit it later together with SCTP, L2TP, and SMC to keep things consistent.

Am 30.10.25 um 15:13 schrieb Xin Long:

Quoted 64 lines · Stefan Metzmacher

Quoted 53 lines

Am 29.10.25 um 20:57 schrieb Xin Long:

Quoted 36 lines · Stefan Metzmacher

Quoted 18 lines

Hi Xin,

Quoted 12 lines

This patch lays the groundwork for QUIC socket support in the kernel. It defines the core structures and protocol hooks needed to create QUIC sockets, without implementing any protocol behavior at this stage.

Basic integration is included to allow building the module via CONFIG_IP_QUIC=m.

This provides the scaffolding necessary for adding actual QUIC socket behavior in follow-up patches.

Signed-off-by Pengtao He <[email protected]>

Signed-off-by Xin Long <[email protected]>

...

Quoted 9 lines

net/quic/protocol.c line 373

Quoted 5 lines

net/quic/protocol.c new file +5 -0

+module_init(quic_init);
+module_exit(quic_exit);
+
+MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-261");
+MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-261");

Shouldn't this use MODULE_ALIAS_NET_PF_PROTO(PF_INET, IPPROTO_QUIC) instead?

Hi, Stefan,

If we switch to using MODULE_ALIAS_NET_PF_PROTO(), we still need to keep using the numeric value 261:

    MODULE_ALIAS_NET_PF_PROTO(PF_INET, 261);
    MODULE_ALIAS_NET_PF_PROTO(PF_INET6, 261);

Quoted 6 lines

IPPROTO_QUIC is defined as an enum, not a macro. Since MODULE_ALIAS_NET_PF_PROTO() relies on __stringify(proto), it can’t stringify enum values correctly, and it would generate:

alias: net-pf-10-proto-IPPROTO_QUIC
alias: net-pf-2-proto-IPPROTO_QUIC

Yes, now I remember...

Maybe we can use something like this:

(quoted diff) +2 -1

-  IPPROTO_QUIC = 261,          /* A UDP-Based Multiplexed and Secure Transport */
+#define __IPPROTO_QUIC 261     /* A UDP-Based Multiplexed and Secure Transport */
+  IPPROTO_QUIC = __IPPROTO_QUIC,

Quoted 8 lines

and then

MODULE_ALIAS_NET_PF_PROTO(PF_INET, __IPPROTO_QUIC)

In order to make things clearer.

What do you think?

That might be a good idea to make things clearer later on.

Quoted 3 lines

But for now, I’d prefer not to add something special just for QUIC in include/uapi/linux/in.h. We can revisit it later together with SCTP, L2TP, and SMC to keep things consistent.

Ok, maybe this would do it for now?

MODULE_ALIAS_NET_PF_PROTO(PF_INET, 261); /* IPPROTO_QUIC == 261 */

I'll do the same for IPPROTO_SMBDIRECT...

metze

net/quic/protocol.c new file +21 -0

+static struct ctl_table quic_table[] = {
+	{
+		.procname	= "quic_mem",
+		.data		= &sysctl_quic_mem,
+		.maxlen		= sizeof(sysctl_quic_mem),
+		.mode		= 0644,
+		.proc_handler	= proc_doulongvec_minmax
+	},
+	{
+		.procname	= "quic_rmem",
+		.data		= &sysctl_quic_rmem,
+		.maxlen		= sizeof(sysctl_quic_rmem),
+		.mode		= 0644,
+		.proc_handler	= proc_dointvec,
+	},
+	{
+		.procname	= "quic_wmem",
+		.data		= &sysctl_quic_wmem,
+		.maxlen		= sizeof(sysctl_quic_wmem),
+		.mode		= 0644,
+		.proc_handler	= proc_dointvec,

On 10/29/25 3:35 PM, Xin Long wrote:
[...]

Quoted 21 lines

net/quic/protocol.c new file +21 -0

+static struct ctl_table quic_table[] = {
+     {
+             .procname       = "quic_mem",
+             .data           = &sysctl_quic_mem,
+             .maxlen         = sizeof(sysctl_quic_mem),
+             .mode           = 0644,
+             .proc_handler   = proc_doulongvec_minmax
+     },
+     {
+             .procname       = "quic_rmem",
+             .data           = &sysctl_quic_rmem,
+             .maxlen         = sizeof(sysctl_quic_rmem),
+             .mode           = 0644,
+             .proc_handler   = proc_dointvec,
+     },
+     {
+             .procname       = "quic_wmem",
+             .data           = &sysctl_quic_wmem,
+             .maxlen         = sizeof(sysctl_quic_wmem),
+             .mode           = 0644,
+             .proc_handler   = proc_dointvec,

net/quic/protocol.c line 85

Quoted 10 lines

net/quic/protocol.c new file +10 -0

+     },
+     {
+             .procname       = "alpn_demux",
+             .data           = &sysctl_quic_alpn_demux,
+             .maxlen         = sizeof(sysctl_quic_alpn_demux),
+             .mode           = 0644,
+             .proc_handler   = proc_dointvec_minmax,
+             .extra1         = SYSCTL_ZERO,
+             .extra2         = SYSCTL_ONE,
+     },

I'm sorry for not nothing this before, but please add a Documentation entry for the above sysctl.

This patch provides foundational data structures and utilities used throughout the QUIC stack.

It introduces packet header types, connection ID support, and address handling. Hash tables are added to manage socket lookup and connection ID mapping.

A flexible binary data type is provided, along with helpers for parsing, matching, and memory management. Helpers for encoding and decoding transport parameters and frames are also included.

Signed-off-by Xin Long <[email protected]>

net/quic/family.c new file +16 -0

+static int quic_v4_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
+			      struct flowi *fl)
+{
+	struct flowi4 *fl4;
+	struct rtable *rt;
+
+	if (__sk_dst_check(sk, 0))
+		return 1;
+
+	memset(fl, 0x00, sizeof(*fl));
+	fl4 = &fl->u.ip4;
+	fl4->saddr = sa->v4.sin_addr.s_addr;
+	fl4->fl4_sport = sa->v4.sin_port;
+	fl4->daddr = da->v4.sin_addr.s_addr;
+	fl4->fl4_dport = da->v4.sin_port;
+	fl4->flowi4_proto = IPPROTO_UDP;

net/quic/family.c new file +32 -0

+		sa->v4.sin_family = AF_INET;
+		sa->v4.sin_addr.s_addr = fl4->saddr;
+	}
+	sk_setup_caps(sk, &rt->dst);
+	return 0;
+}
+
+static int quic_v6_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
+			      struct flowi *fl)
+{
+	struct ipv6_pinfo *np = inet6_sk(sk);
+	struct ip6_flowlabel *flowlabel;
+	struct dst_entry *dst;
+	struct flowi6 *fl6;
+
+	if (__sk_dst_check(sk, np->dst_cookie))
+		return 1;
+
+	memset(fl, 0x00, sizeof(*fl));
+	fl6 = &fl->u.ip6;
+	fl6->saddr = sa->v6.sin6_addr;
+	fl6->fl6_sport = sa->v6.sin6_port;
+	fl6->daddr = da->v6.sin6_addr;
+	fl6->fl6_dport = da->v6.sin6_port;
+	fl6->flowi6_proto = IPPROTO_UDP;
+	fl6->flowi6_oif = sk->sk_bound_dev_if;
+
+	if (inet6_test_bit(SNDFLOW, sk)) {
+		fl6->flowlabel = (da->v6.sin6_flowinfo & IPV6_FLOWINFO_MASK);
+		if (fl6->flowlabel & IPV6_FLOWLABEL_MASK) {
+			flowlabel = fl6_sock_lookup(sk, fl6->flowlabel);
+			if (IS_ERR(flowlabel))

net/quic/family.c new file +35 -0

+	if (hdr->type == ICMP_DEST_UNREACH && hdr->code == ICMP_FRAG_NEEDED) {
+		*info = ntohs(hdr->un.frag.mtu);
+		return 0;
+	}
+
+	/* Defer other types' processing to UDP error handler. */
+	return 1;
+}
+
+static int quic_v6_get_mtu_info(struct sk_buff *skb, u32 *info)
+{
+	struct icmp6hdr *hdr;
+
+	hdr = (struct icmp6hdr *)(skb_network_header(skb) - sizeof(struct icmp6hdr));
+	if (hdr->icmp6_type == ICMPV6_PKT_TOOBIG) {
+		*info = ntohl(hdr->icmp6_mtu);
+		return 0;
+	}
+
+	/* Defer other types' processing to UDP error handler. */
+	return 1;
+}
+
+static u8 quic_v4_get_msg_ecn(struct sk_buff *skb)
+{
+	return (ip_hdr(skb)->tos & INET_ECN_MASK);
+}
+
+static u8 quic_v6_get_msg_ecn(struct sk_buff *skb)
+{
+	return (ipv6_get_dsfield(ipv6_hdr(skb)) & INET_ECN_MASK);
+}
+
+static int quic_v4_get_user_addr(struct sock *sk, union quic_addr *a, struct sockaddr *addr,
+				 int addr_len)

net/quic/family.c new file +9 -0

+static void quic_v4_get_pref_addr(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen)
+{
+	u8 *p = *pp;
+
+	memcpy(&addr->v4.sin_addr, p, QUIC_ADDR4_LEN);
+	p += QUIC_ADDR4_LEN;
+	memcpy(&addr->v4.sin_port, p, QUIC_PORT_LEN);
+	p += QUIC_PORT_LEN;
+	addr->v4.sin_family = AF_INET;

net/quic/family.c new file +20 -0

+static bool quic_v4_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
+{
+	if (a->v4.sin_port != addr->v4.sin_port)
+		return false;
+	if (a->v4.sin_family != addr->v4.sin_family)
+		return false;
+	if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
+	    addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))
+		return true;
+	return a->v4.sin_addr.s_addr == addr->v4.sin_addr.s_addr;
+}
+
+static bool quic_v6_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
+{
+	if (a->v4.sin_port != addr->v4.sin_port)
+		return false;
+
+	if (a->sa.sa_family == AF_INET && addr->sa.sa_family == AF_INET) {
+		if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
+		    addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))

Quoted 21 lines · Xin Long

net/quic/family.c new file +21 -0

+static int quic_v4_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
+                           struct flowi *fl)
+{
+     struct flowi4 *fl4;
+     struct rtable *rt;
+
+     if (__sk_dst_check(sk, 0))
+             return 1;
+
+     memset(fl, 0x00, sizeof(*fl));
+     fl4 = &fl->u.ip4;
+     fl4->saddr = sa->v4.sin_addr.s_addr;
+     fl4->fl4_sport = sa->v4.sin_port;
+     fl4->daddr = da->v4.sin_addr.s_addr;
+     fl4->fl4_dport = da->v4.sin_port;
+     fl4->flowi4_proto = IPPROTO_UDP;
+     fl4->flowi4_oif = sk->sk_bound_dev_if;
+
+     fl4->flowi4_scope = ip_sock_rt_scope(sk);
+     fl4->flowi4_dscp = inet_sk_dscp(inet_sk(sk));
+

net/quic/family.c line 84

Quoted 5 lines

net/quic/family.c new file +5 -0

+     rt = ip_route_output_key(sock_net(sk), fl4);
+     if (IS_ERR(rt))
+             return PTR_ERR(rt);
+
+     if (!sa->v4.sin_family) {

The above check is strange. Any special reason to not use quic_v4_is_any_addr()?

Quoted 36 lines

net/quic/family.c new file +36 -0

+             sa->v4.sin_family = AF_INET;
+             sa->v4.sin_addr.s_addr = fl4->saddr;
+     }
+     sk_setup_caps(sk, &rt->dst);
+     return 0;
+}
+
+static int quic_v6_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
+                           struct flowi *fl)
+{
+     struct ipv6_pinfo *np = inet6_sk(sk);
+     struct ip6_flowlabel *flowlabel;
+     struct dst_entry *dst;
+     struct flowi6 *fl6;
+
+     if (__sk_dst_check(sk, np->dst_cookie))
+             return 1;
+
+     memset(fl, 0x00, sizeof(*fl));
+     fl6 = &fl->u.ip6;
+     fl6->saddr = sa->v6.sin6_addr;
+     fl6->fl6_sport = sa->v6.sin6_port;
+     fl6->daddr = da->v6.sin6_addr;
+     fl6->fl6_dport = da->v6.sin6_port;
+     fl6->flowi6_proto = IPPROTO_UDP;
+     fl6->flowi6_oif = sk->sk_bound_dev_if;
+
+     if (inet6_test_bit(SNDFLOW, sk)) {
+             fl6->flowlabel = (da->v6.sin6_flowinfo & IPV6_FLOWINFO_MASK);
+             if (fl6->flowlabel & IPV6_FLOWLABEL_MASK) {
+                     flowlabel = fl6_sock_lookup(sk, fl6->flowlabel);
+                     if (IS_ERR(flowlabel))
+                             return -EINVAL;
+                     fl6_sock_release(flowlabel);
+             }
+     }

net/quic/family.c line 126

Quoted 6 lines

net/quic/family.c new file +6 -0

+
+     dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, NULL);
+     if (IS_ERR(dst))
+             return PTR_ERR(dst);
+
+     if (!sa->v6.sin6_family) {

(similar question here)

[...]

net/quic/family.c line 213

Quoted 5 lines

net/quic/family.c new file +5 -0

+static int quic_v4_get_mtu_info(struct sk_buff *skb, u32 *info)
+{
+     struct icmphdr *hdr;
+
+     hdr = (struct icmphdr *)(skb_network_header(skb) - sizeof(struct icmphdr));

Noting the above relies on headers being already pulled in the linear part. Later patch will do skb_linarize(), but that looks overkill and should hit performance badly. Instead you should use pskb_may_pull() && friends.

Quoted 36 lines

net/quic/family.c new file +35 -0

+     if (hdr->type == ICMP_DEST_UNREACH && hdr->code == ICMP_FRAG_NEEDED) {
+             *info = ntohs(hdr->un.frag.mtu);
+             return 0;
+     }
+
+     /* Defer other types' processing to UDP error handler. */
+     return 1;
+}
+
+static int quic_v6_get_mtu_info(struct sk_buff *skb, u32 *info)
+{
+     struct icmp6hdr *hdr;
+
+     hdr = (struct icmp6hdr *)(skb_network_header(skb) - sizeof(struct icmp6hdr));
+     if (hdr->icmp6_type == ICMPV6_PKT_TOOBIG) {
+             *info = ntohl(hdr->icmp6_mtu);
+             return 0;
+     }
+
+     /* Defer other types' processing to UDP error handler. */
+     return 1;
+}
+
+static u8 quic_v4_get_msg_ecn(struct sk_buff *skb)
+{
+     return (ip_hdr(skb)->tos & INET_ECN_MASK);
+}
+
+static u8 quic_v6_get_msg_ecn(struct sk_buff *skb)
+{
+     return (ipv6_get_dsfield(ipv6_hdr(skb)) & INET_ECN_MASK);
+}
+
+static int quic_v4_get_user_addr(struct sock *sk, union quic_addr *a, struct sockaddr *addr,
+                              int addr_len)

net/quic/family.c line 258

Quoted 10 lines

net/quic/family.c new file +10 -0

+{
+     u32 len = sizeof(struct sockaddr_in);
+
+     if (addr_len < len || addr->sa_family != AF_INET)
+             return 1;
+     if (ipv4_is_multicast(quic_addr(addr)->v4.sin_addr.s_addr))
+             return 1;
+     memcpy(a, addr, len);
+     return 0;
+}

It looks like the above function is not used in this series?!? (well it's called by quic_get_user_addr() which in turn is unsed.

Perhaps drop from here and add later as needed?

Also the name sounds possibly misleading, I read it as it should copy data to user-space and return value could possibly be an errnum.

Quoted 9 lines

net/quic/family.c new file +9 -0

+static void quic_v4_get_pref_addr(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen)
+{
+     u8 *p = *pp;
+
+     memcpy(&addr->v4.sin_addr, p, QUIC_ADDR4_LEN);
+     p += QUIC_ADDR4_LEN;
+     memcpy(&addr->v4.sin_port, p, QUIC_PORT_LEN);
+     p += QUIC_PORT_LEN;
+     addr->v4.sin_family = AF_INET;

net/quic/family.c line 303

Quoted 10 lines

net/quic/family.c new file +10 -0

+     /* Skip over IPv6 address and port, not used for AF_INET sockets. */
+     p += QUIC_ADDR6_LEN;
+     p += QUIC_PORT_LEN;
+
+     if (!addr->v4.sin_port || quic_v4_is_any_addr(addr) ||
+         ipv4_is_multicast(addr->v4.sin_addr.s_addr))
+             memset(addr, 0, sizeof(*addr));
+     *plen -= (p - *pp);
+     *pp = p;
+}

Similarly unused?

Quoted 26 lines

net/quic/family.c new file +26 -0

+static bool quic_v4_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
+{
+     if (a->v4.sin_port != addr->v4.sin_port)
+             return false;
+     if (a->v4.sin_family != addr->v4.sin_family)
+             return false;
+     if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
+         addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))
+             return true;
+     return a->v4.sin_addr.s_addr == addr->v4.sin_addr.s_addr;
+}
+
+static bool quic_v6_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
+{
+     if (a->v4.sin_port != addr->v4.sin_port)
+             return false;
+
+     if (a->sa.sa_family == AF_INET && addr->sa.sa_family == AF_INET) {
+             if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
+                 addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))
+                     return true;
+             return a->v4.sin_addr.s_addr == addr->v4.sin_addr.s_addr;
+     }
+
+     if (a->sa.sa_family != addr->sa.sa_family) {
+             if (ipv6_only_sock(sk))

net/quic/family.c line 387

Quoted 4 lines

net/quic/family.c new file +4 -0

+                     return false;
+             if (a->sa.sa_family == AF_INET6 && ipv6_addr_any(&a->v6.sin6_addr))
+                     return true;
+             if (a->sa.sa_family == AF_INET && addr->sa.sa_family == AF_INET6 &&

Below this code assumes that sa_family is either AF_INET or AF_INET6. If such assumtion hold, you should use here, too. and drop the 'addr->sa.sa_family == AF_INET6' condition.

net/quic/family.c line 394

Quoted 8 lines

net/quic/family.c new file +7 -0

+                 ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
+                 addr->v6.sin6_addr.s6_addr32[3] == a->v4.sin_addr.s_addr)
+                     return true;
+             if (addr->sa.sa_family == AF_INET && a->sa.sa_family == AF_INET6 &&
+                 ipv6_addr_v4mapped(&a->v6.sin6_addr) &&
+                 a->v6.sin6_addr.s6_addr32[3] == addr->v4.sin_addr.s_addr)
+                     return true;

Nothing this branch does not handle the 'ipv6_addr_any(&addr->v6.sin6_addr)'

net/quic/stream.c new file +14 -0

+static struct quic_stream *quic_stream_send_create(struct quic_stream_table *streams,
+						   s64 max_stream_id, u8 is_serv)
+{
+	struct quic_stream *stream = NULL;
+	s64 stream_id;
+
+	stream_id = streams->send.next_bidi_stream_id;
+	if (quic_stream_id_uni(max_stream_id))
+		stream_id = streams->send.next_uni_stream_id;
+
+	/* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+	 * of that type with lower-numbered stream IDs also being opened.
+	 */
+	while (stream_id <= max_stream_id) {

net/quic/stream.c new file +67 -0

+			streams->send.streams_uni++;
+
+			quic_stream_add(streams, stream);
+			stream_id += QUIC_STREAM_ID_STEP;
+			continue;
+		}
+
+		if (streams->send.next_bidi_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+			streams->send.next_bidi_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+		streams->send.streams_bidi++;
+
+		if (quic_stream_id_local(stream_id, is_serv)) {
+			stream->send.max_bytes = streams->send.max_stream_data_bidi_remote;
+			stream->recv.max_bytes = streams->recv.max_stream_data_bidi_local;
+		} else {
+			stream->send.max_bytes = streams->send.max_stream_data_bidi_local;
+			stream->recv.max_bytes = streams->recv.max_stream_data_bidi_remote;
+		}
+		stream->recv.window = stream->recv.max_bytes;
+
+		quic_stream_add(streams, stream);
+		stream_id += QUIC_STREAM_ID_STEP;
+	}
+	return stream;
+}
+
+/* Create and register new streams for receiving. */
+static struct quic_stream *quic_stream_recv_create(struct quic_stream_table *streams,
+						   s64 max_stream_id, u8 is_serv)
+{
+	struct quic_stream *stream = NULL;
+	s64 stream_id;
+
+	stream_id = streams->recv.next_bidi_stream_id;
+	if (quic_stream_id_uni(max_stream_id))
+		stream_id = streams->recv.next_uni_stream_id;
+
+	/* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+	 * of that type with lower-numbered stream IDs also being opened.
+	 */
+	while (stream_id <= max_stream_id) {
+		stream = kzalloc(sizeof(*stream), GFP_ATOMIC | __GFP_ACCOUNT);
+		if (!stream)
+			return NULL;
+
+		stream->id = stream_id;
+		if (quic_stream_id_uni(stream_id)) {
+			stream->recv.window = streams->recv.max_stream_data_uni;
+			stream->recv.max_bytes = stream->recv.window;
+
+			if (streams->recv.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+				streams->recv.next_uni_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+			streams->recv.streams_uni++;
+
+			quic_stream_add(streams, stream);
+			stream_id += QUIC_STREAM_ID_STEP;
+			continue;
+		}
+
+		if (streams->recv.next_bidi_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+			streams->recv.next_bidi_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+		streams->recv.streams_bidi++;
+
+		if (quic_stream_id_local(stream_id, is_serv)) {
+			stream->send.max_bytes = streams->send.max_stream_data_bidi_remote;
+			stream->recv.max_bytes = streams->recv.max_stream_data_bidi_local;
+		} else {

net/quic/stream.c new file +41 -0

+
+/* Check if a send or receive stream ID is already closed. */
+static bool quic_stream_id_closed(struct quic_stream_table *streams, s64 stream_id, bool send)
+{
+	if (quic_stream_id_uni(stream_id)) {
+		if (send)
+			return stream_id < streams->send.next_uni_stream_id;
+		return stream_id < streams->recv.next_uni_stream_id;
+	}
+	if (send)
+		return stream_id < streams->send.next_bidi_stream_id;
+	return stream_id < streams->recv.next_bidi_stream_id;
+}
+
+/* Check if a stream ID would exceed local (recv) or peer (send) limits. */
+bool quic_stream_id_exceeds(struct quic_stream_table *streams, s64 stream_id, bool send)
+{
+	u64 nstreams;
+
+	if (!send) {
+		if (quic_stream_id_uni(stream_id))
+			return stream_id > streams->recv.max_uni_stream_id;
+		return stream_id > streams->recv.max_bidi_stream_id;
+	}
+
+	if (quic_stream_id_uni(stream_id)) {
+		if (stream_id > streams->send.max_uni_stream_id)
+			return true;
+		stream_id -= streams->send.next_uni_stream_id;
+		nstreams = quic_stream_id_to_streams(stream_id);
+		return nstreams + streams->send.streams_uni > streams->send.max_streams_uni;
+	}
+
+	if (stream_id > streams->send.max_bidi_stream_id)
+		return true;
+	stream_id -= streams->send.next_bidi_stream_id;
+	nstreams = quic_stream_id_to_streams(stream_id);
+	return nstreams + streams->send.streams_bidi > streams->send.max_streams_bidi;
+}
+
+/* Get or create a send stream by ID. */

On 10/29/25 3:35 PM, Xin Long wrote:
+/* Create and register new streams for sending. */

Quoted 14 lines

net/quic/stream.c new file +14 -0

+static struct quic_stream *quic_stream_send_create(struct quic_stream_table *streams,
+                                                s64 max_stream_id, u8 is_serv)
+{
+     struct quic_stream *stream = NULL;
+     s64 stream_id;
+
+     stream_id = streams->send.next_bidi_stream_id;
+     if (quic_stream_id_uni(max_stream_id))
+             stream_id = streams->send.next_uni_stream_id;
+
+     /* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+      * of that type with lower-numbered stream IDs also being opened.
+      */
+     while (stream_id <= max_stream_id) {

net/quic/stream.c line 102

Quoted 10 lines

net/quic/stream.c new file +10 -0

+             stream = kzalloc(sizeof(*stream), GFP_KERNEL_ACCOUNT);
+             if (!stream)
+                     return NULL;
+
+             stream->id = stream_id;
+             if (quic_stream_id_uni(stream_id)) {
+                     stream->send.max_bytes = streams->send.max_stream_data_uni;
+
+                     if (streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                             streams->send.next_uni_stream_id = stream_id + QUIC_STREAM_ID_STEP;

It's unclear to me the goal the above 2 statements. Dealing with id wrap-arounds? If 'streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP' is not true the next quic_stream_send_create() will reuse the same stream_id.

I moving the above in a separate helper with some comments would help.

Quoted 77 lines

net/quic/stream.c new file +76 -0

+                     streams->send.streams_uni++;
+
+                     quic_stream_add(streams, stream);
+                     stream_id += QUIC_STREAM_ID_STEP;
+                     continue;
+             }
+
+             if (streams->send.next_bidi_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                     streams->send.next_bidi_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+             streams->send.streams_bidi++;
+
+             if (quic_stream_id_local(stream_id, is_serv)) {
+                     stream->send.max_bytes = streams->send.max_stream_data_bidi_remote;
+                     stream->recv.max_bytes = streams->recv.max_stream_data_bidi_local;
+             } else {
+                     stream->send.max_bytes = streams->send.max_stream_data_bidi_local;
+                     stream->recv.max_bytes = streams->recv.max_stream_data_bidi_remote;
+             }
+             stream->recv.window = stream->recv.max_bytes;
+
+             quic_stream_add(streams, stream);
+             stream_id += QUIC_STREAM_ID_STEP;
+     }
+     return stream;
+}
+
+/* Create and register new streams for receiving. */
+static struct quic_stream *quic_stream_recv_create(struct quic_stream_table *streams,
+                                                s64 max_stream_id, u8 is_serv)
+{
+     struct quic_stream *stream = NULL;
+     s64 stream_id;
+
+     stream_id = streams->recv.next_bidi_stream_id;
+     if (quic_stream_id_uni(max_stream_id))
+             stream_id = streams->recv.next_uni_stream_id;
+
+     /* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+      * of that type with lower-numbered stream IDs also being opened.
+      */
+     while (stream_id <= max_stream_id) {
+             stream = kzalloc(sizeof(*stream), GFP_ATOMIC | __GFP_ACCOUNT);
+             if (!stream)
+                     return NULL;
+
+             stream->id = stream_id;
+             if (quic_stream_id_uni(stream_id)) {
+                     stream->recv.window = streams->recv.max_stream_data_uni;
+                     stream->recv.max_bytes = stream->recv.window;
+
+                     if (streams->recv.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                             streams->recv.next_uni_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+                     streams->recv.streams_uni++;
+
+                     quic_stream_add(streams, stream);
+                     stream_id += QUIC_STREAM_ID_STEP;
+                     continue;
+             }
+
+             if (streams->recv.next_bidi_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                     streams->recv.next_bidi_stream_id = stream_id + QUIC_STREAM_ID_STEP;
+             streams->recv.streams_bidi++;
+
+             if (quic_stream_id_local(stream_id, is_serv)) {
+                     stream->send.max_bytes = streams->send.max_stream_data_bidi_remote;
+                     stream->recv.max_bytes = streams->recv.max_stream_data_bidi_local;
+             } else {
+                     stream->send.max_bytes = streams->send.max_stream_data_bidi_local;
+                     stream->recv.max_bytes = streams->recv.max_stream_data_bidi_remote;
+             }
+             stream->recv.window = stream->recv.max_bytes;
+
+             quic_stream_add(streams, stream);
+             stream_id += QUIC_STREAM_ID_STEP;
+     }
+     return stream;

Quoted 1 line

+}

The above 2 functions has a lot of code in common. I think you could deduplicate it by:
- defining a named type for quic_stream_table.{send,recv}
- define a generic /() helper using an additonal
argument for the relevant table.{send,recv}
- replace the above 2 functions with a single invocation to such helper.

It looks like there are more de-dup opportunity below.

Quoted 46 lines

net/quic/stream.c new file +46 -0

+
+/* Check if a send or receive stream ID is already closed. */
+static bool quic_stream_id_closed(struct quic_stream_table *streams, s64 stream_id, bool send)
+{
+     if (quic_stream_id_uni(stream_id)) {
+             if (send)
+                     return stream_id < streams->send.next_uni_stream_id;
+             return stream_id < streams->recv.next_uni_stream_id;
+     }
+     if (send)
+             return stream_id < streams->send.next_bidi_stream_id;
+     return stream_id < streams->recv.next_bidi_stream_id;
+}
+
+/* Check if a stream ID would exceed local (recv) or peer (send) limits. */
+bool quic_stream_id_exceeds(struct quic_stream_table *streams, s64 stream_id, bool send)
+{
+     u64 nstreams;
+
+     if (!send) {
+             if (quic_stream_id_uni(stream_id))
+                     return stream_id > streams->recv.max_uni_stream_id;
+             return stream_id > streams->recv.max_bidi_stream_id;
+     }
+
+     if (quic_stream_id_uni(stream_id)) {
+             if (stream_id > streams->send.max_uni_stream_id)
+                     return true;
+             stream_id -= streams->send.next_uni_stream_id;
+             nstreams = quic_stream_id_to_streams(stream_id);
+             return nstreams + streams->send.streams_uni > streams->send.max_streams_uni;
+     }
+
+     if (stream_id > streams->send.max_bidi_stream_id)
+             return true;
+     stream_id -= streams->send.next_bidi_stream_id;
+     nstreams = quic_stream_id_to_streams(stream_id);
+     return nstreams + streams->send.streams_bidi > streams->send.max_streams_bidi;
+}
+
+/* Get or create a send stream by ID. */
+struct quic_stream *quic_stream_send_get(struct quic_stream_table *streams, s64 stream_id,
+                                      u32 flags, bool is_serv)
+{
+     struct quic_stream *stream;
+

net/quic/stream.c line 230

Quoted 5 lines

net/quic/stream.c new file +5 -0

+     if (!quic_stream_id_valid(stream_id, is_serv, true))
+             return ERR_PTR(-EINVAL);
+
+     stream = quic_stream_find(streams, stream_id);
+     if (stream) {

You should add some comments and possibly lockdep annotation/static check about the expected locking for the whole stream lifecycle.

Quoted 33 lines · Paolo Abeni

On 10/29/25 3:35 PM, Xin Long wrote:
+/* Create and register new streams for sending. */

Quoted 14 lines

net/quic/stream.c new file +14 -0

+static struct quic_stream *quic_stream_send_create(struct quic_stream_table *streams,
+                                                s64 max_stream_id, u8 is_serv)
+{
+     struct quic_stream *stream = NULL;
+     s64 stream_id;
+
+     stream_id = streams->send.next_bidi_stream_id;
+     if (quic_stream_id_uni(max_stream_id))
+             stream_id = streams->send.next_uni_stream_id;
+
+     /* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+      * of that type with lower-numbered stream IDs also being opened.
+      */
+     while (stream_id <= max_stream_id) {

net/quic/stream.c line 102

Quoted 10 lines

net/quic/stream.c new file +10 -0

+             stream = kzalloc(sizeof(*stream), GFP_KERNEL_ACCOUNT);
+             if (!stream)
+                     return NULL;
+
+             stream->id = stream_id;
+             if (quic_stream_id_uni(stream_id)) {
+                     stream->send.max_bytes = streams->send.max_stream_data_uni;
+
+                     if (streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                             streams->send.next_uni_stream_id = stream_id + QUIC_STREAM_ID_STEP;

It's unclear to me the goal the above 2 statements. Dealing with id wrap-arounds? If 'streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP' is not true the next quic_stream_send_create() will reuse the same stream_id.

Quoted 2 lines

I moving the above in a separate helper with some comments would help.

I will add a macro for this:

#define quic_stream_id_next_update(limits, type, id) \

do {                                                    \
        if ((limits)->next_##type##_stream_id < (id) +
QUIC_STREAM_ID_STEP)     \
                (limits)->next_##type##_stream_id = (id) +
QUIC_STREAM_ID_STEP; \
        (limits)->streams_##type++;
         \
} while (0)

So that we can use it to update both next_uni_stream_id and next_bidi_stream_id.

Quoted 6 lines

The above 2 functions has a lot of code in common. I think you could deduplicate it by:
- defining a named type for quic_stream_table.{send,recv}
- define a generic /() helper using an additonal
argument for the relevant table.{send,recv}
- replace the above 2 functions with a single invocation to such helper.

This is a very smart idea!

It will dedup not only quic_stream_recv_create(), but also quic_stream_get_param() and quic_stream_set_param().

I will define a type named 'struct quic_stream_limits'. Note that, since we must pass 'bool send' to quic_stream_create() for setting the fields in a single 'stream' .

        if (quic_stream_id_uni(stream_id)) {
                if (send) {
                        stream->send.max_bytes = limits->max_stream_data_uni;
                } else {
                        stream->recv.max_bytes = limits->max_stream_data_uni;
                        stream->recv.window = stream->recv.max_bytes;
                }

I'm planning not to pass additional argument of table.{send,recv}, but do this in quic_stream_create():

        struct quic_stream_limits *limits = &streams->send;
        gfp_t gfp = GFP_KERNEL_ACCOUNT;

        if (!send) {
                limits = &streams->recv;
                gfp = GFP_ATOMIC | __GFP_ACCOUNT;
        }

Quoted 3 lines

It looks like there are more de-dup opportunity below.

Yes, the difference is only the variable name _uni_ and _bidi_. I'm planning to de-dup them with macros like:

#define quic_stream_id_below_next(streams, type, id, send)        \
    ((send) ? ((id) < (streams)->send.next_##type##_stream_id) :    \
          ((id) < (streams)->recv.next_##type##_stream_id))

/* Check if a send or receive stream ID is already closed. */ static bool quic_stream_id_closed(struct quic_stream_table *streams, s64 stream_id, bool send)

{
    if (quic_stream_id_uni(stream_id))
        return quic_stream_id_below_next(streams, uni, stream_id, send);
    return quic_stream_id_below_next(streams, bidi, stream_id, send);
}

#define quic_stream_id_above_max(streams, type, id)            \
    (((id) > (streams)->send.max_##type##_stream_id) ? true :    \
        (quic_stream_id_to_streams((id) -
(streams)->send.next_##type##_stream_id) +    \
            (streams)->send.streams_##type >

(streams)->send.max_streams_##type))

Quoted 48 lines · Xin Long

Quoted 33 lines · Paolo Abeni

On 10/29/25 3:35 PM, Xin Long wrote:
+/* Create and register new streams for sending. */

Quoted 14 lines

net/quic/stream.c new file +14 -0

+static struct quic_stream *quic_stream_send_create(struct quic_stream_table *streams,
+                                                s64 max_stream_id, u8 is_serv)
+{
+     struct quic_stream *stream = NULL;
+     s64 stream_id;
+
+     stream_id = streams->send.next_bidi_stream_id;
+     if (quic_stream_id_uni(max_stream_id))
+             stream_id = streams->send.next_uni_stream_id;
+
+     /* rfc9000#section-2.1: A stream ID that is used out of order results in all streams
+      * of that type with lower-numbered stream IDs also being opened.
+      */
+     while (stream_id <= max_stream_id) {

net/quic/stream.c line 102

Quoted 10 lines

net/quic/stream.c new file +10 -0

+             stream = kzalloc(sizeof(*stream), GFP_KERNEL_ACCOUNT);
+             if (!stream)
+                     return NULL;
+
+             stream->id = stream_id;
+             if (quic_stream_id_uni(stream_id)) {
+                     stream->send.max_bytes = streams->send.max_stream_data_uni;
+
+                     if (streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP)
+                             streams->send.next_uni_stream_id = stream_id + QUIC_STREAM_ID_STEP;

It's unclear to me the goal the above 2 statements. Dealing with id wrap-arounds? If 'streams->send.next_uni_stream_id < stream_id + QUIC_STREAM_ID_STEP' is not true the next quic_stream_send_create() will reuse the same stream_id.

Quoted 2 lines

I moving the above in a separate helper with some comments would help.

I will add a macro for this:

#define quic_stream_id_next_update(limits, type, id) \

do {                                                    \
        if ((limits)->next_##type##_stream_id < (id) +
QUIC_STREAM_ID_STEP)     \
                (limits)->next_##type##_stream_id = (id) +
QUIC_STREAM_ID_STEP; \
        (limits)->streams_##type++;
         \
} while (0)

Quoted 1 line

So that we can use it to update both next_uni_stream_id and next_bidi_stream_id.

A function would be better tacking the next_id value as an argument. More importantly please document the goal here which is still unclear to me.

Quoted 52 lines

Quoted 6 lines

The above 2 functions has a lot of code in common. I think you could deduplicate it by:
- defining a named type for quic_stream_table.{send,recv}
- define a generic /() helper using an additonal
argument for the relevant table.{send,recv}
- replace the above 2 functions with a single invocation to such helper.

This is a very smart idea!

It will dedup not only quic_stream_recv_create(), but also quic_stream_get_param() and quic_stream_set_param().

I will define a type named 'struct quic_stream_limits'. Note that, since we must pass 'bool send' to quic_stream_create() for setting the fields in a single 'stream' .

        if (quic_stream_id_uni(stream_id)) {
                if (send) {
                        stream->send.max_bytes = limits->max_stream_data_uni;
                } else {
                        stream->recv.max_bytes = limits->max_stream_data_uni;
                        stream->recv.window = stream->recv.max_bytes;
                }

I'm planning not to pass additional argument of table.{send,recv}, but do this in quic_stream_create():

        struct quic_stream_limits *limits = &streams->send;
        gfp_t gfp = GFP_KERNEL_ACCOUNT;

        if (!send) {
                limits = &streams->recv;
                gfp = GFP_ATOMIC | __GFP_ACCOUNT;
        }

Quoted 3 lines

It looks like there are more de-dup opportunity below.

Yes, the difference is only the variable name _uni_ and _bidi_. I'm planning to de-dup them with macros like:

#define quic_stream_id_below_next(streams, type, id, send)        \
    ((send) ? ((id) < (streams)->send.next_##type##_stream_id) :    \
          ((id) < (streams)->recv.next_##type##_stream_id))

/* Check if a send or receive stream ID is already closed. */ static bool quic_stream_id_closed(struct quic_stream_table *streams, s64 stream_id, bool send)

{
    if (quic_stream_id_uni(stream_id))
        return quic_stream_id_below_next(streams, uni, stream_id, send);
    return quic_stream_id_below_next(streams, bidi, stream_id, send);
}

Quoted 6 lines

#define quic_stream_id_above_max(streams, type, id)            \
    (((id) > (streams)->send.max_##type##_stream_id) ? true :    \
        (quic_stream_id_to_streams((id) -
(streams)->send.next_##type##_stream_id) +    \
            (streams)->send.streams_##type >

(streams)->send.max_streams_##type))

Uhmm... with "more de-dup opportunity below" I intended quic_stream_get_param() and quic_stream_set_param(). I would refrain from adding macros. I think the above idea ('struct quic_stream_limits') would not need that?!?

This patch introduces 'quic_path_group' for managing paths, represented by 'struct quic_path'. A connection may use two paths simultaneously for connection migration.

Each path is associated with a UDP tunnel socket (sk), and a single UDP tunnel socket can be related to multiple paths from different sockets. These UDP tunnel sockets are wrapped in 'quic_udp_sock' structures and stored in a hash table.

It includes mechanisms to bind and unbind paths, detect alternative paths for migration, and swap paths to support seamless transition between networks.

- quic_path_bind(): Bind a path to a port and associate it with a UDP sk.

- quic_path_free(): Unbind a path from a port and disassociate it from a UDP sk.

Quoted 13 lines · Xin Long

This patch introduces 'quic_path_group' for managing paths, represented by 'struct quic_path'. A connection may use two paths simultaneously for connection migration.

Each path is associated with a UDP tunnel socket (sk), and a single UDP tunnel socket can be related to multiple paths from different sockets. These UDP tunnel sockets are wrapped in 'quic_udp_sock' structures and stored in a hash table.

It includes mechanisms to bind and unbind paths, detect alternative paths for migration, and swap paths to support seamless transition between networks.

Quoted 4 lines

- quic_path_bind(): Bind a path to a port and associate it with a UDP sk.

- quic_path_free(): Unbind a path from a port and disassociate it from a UDP sk.

I find the above name slightly misleading, as I expect such function to free the path argument. Possibly quic_path_unbind?

net/quic/cong.c new file +34 -0

+void quic_cong_rtt_update(struct quic_cong *cong, u32 time, u32 ack_delay)
+{
+	u32 adjusted_rtt, rttvar_sample;
+
+	/* Ignore RTT sample if ACK delay is suspiciously large. */
+	if (ack_delay > cong->max_ack_delay * 2)
+		return;
+
+	/* rfc9002#section-5.1: latest_rtt = ack_time - send_time_of_largest_acked */
+	cong->latest_rtt = cong->time - time;
+
+	/* rfc9002#section-5.2: Estimating min_rtt */
+	if (!cong->min_rtt_valid) {
+		cong->min_rtt = cong->latest_rtt;
+		cong->min_rtt_valid = 1;
+	}
+	if (cong->min_rtt > cong->latest_rtt)
+		cong->min_rtt = cong->latest_rtt;
+
+	if (!cong->is_rtt_set) {
+		/* rfc9002#section-5.3:
+		 *   smoothed_rtt = latest_rtt
+		 *   rttvar = latest_rtt / 2
+		 */
+		cong->smoothed_rtt = cong->latest_rtt;
+		cong->rttvar = cong->smoothed_rtt / 2;
+		quic_cong_pto_update(cong);
+		cong->is_rtt_set = 1;
+		return;
+	}
+
+	/* rfc9002#section-5.3:
+	 *   adjusted_rtt = latest_rtt
+	 *   if (latest_rtt >= min_rtt + ack_delay):

net/quic/cong.c line 201

Quoted 13 lines · Xin Long

net/quic/cong.c new file +13 -0

+/* Compute and update the pacing rate based on congestion window and smoothed RTT. */
+static void quic_cong_pace_update(struct quic_cong *cong, u32 bytes, u32 max_rate)
+{
+     u64 rate;
+
+     /* rate = N * congestion_window / smoothed_rtt */
+     rate = (u64)cong->window * USEC_PER_SEC * 2;
+     if (likely(cong->smoothed_rtt))
+             rate = div64_ul(rate, cong->smoothed_rtt);
+
+     WRITE_ONCE(cong->pacing_rate, min_t(u64, rate, max_rate));
+     pr_debug("%s: update pacing rate: %u, max rate: %u, srtt: %u\n",
+              __func__, cong->pacing_rate, max_rate, cong->smoothed_rtt);

I think you should skip entirely the pacing_rate update when smoothed_rtt == 0

[...]> +/* rfc9002#section-5: Estimating the Round-Trip Time */

Quoted 39 lines

net/quic/cong.c new file +39 -0

+void quic_cong_rtt_update(struct quic_cong *cong, u32 time, u32 ack_delay)
+{
+     u32 adjusted_rtt, rttvar_sample;
+
+     /* Ignore RTT sample if ACK delay is suspiciously large. */
+     if (ack_delay > cong->max_ack_delay * 2)
+             return;
+
+     /* rfc9002#section-5.1: latest_rtt = ack_time - send_time_of_largest_acked */
+     cong->latest_rtt = cong->time - time;
+
+     /* rfc9002#section-5.2: Estimating min_rtt */
+     if (!cong->min_rtt_valid) {
+             cong->min_rtt = cong->latest_rtt;
+             cong->min_rtt_valid = 1;
+     }
+     if (cong->min_rtt > cong->latest_rtt)
+             cong->min_rtt = cong->latest_rtt;
+
+     if (!cong->is_rtt_set) {
+             /* rfc9002#section-5.3:
+              *   smoothed_rtt = latest_rtt
+              *   rttvar = latest_rtt / 2
+              */
+             cong->smoothed_rtt = cong->latest_rtt;
+             cong->rttvar = cong->smoothed_rtt / 2;
+             quic_cong_pto_update(cong);
+             cong->is_rtt_set = 1;
+             return;
+     }
+
+     /* rfc9002#section-5.3:
+      *   adjusted_rtt = latest_rtt
+      *   if (latest_rtt >= min_rtt + ack_delay):
+      *     adjusted_rtt = latest_rtt - ack_delay
+      *   smoothed_rtt = 7/8 * smoothed_rtt + 1/8 * adjusted_rtt
+      *   rttvar_sample = abs(smoothed_rtt - adjusted_rtt)
+      *   rttvar = 3/4 * rttvar + 1/4 * rttvar_sample
+      */

net/quic/cong.c line 266

Quoted 5 lines

net/quic/cong.c new file +5 -0

+     adjusted_rtt = cong->latest_rtt;
+     if (cong->latest_rtt >= cong->min_rtt + ack_delay)
+             adjusted_rtt = cong->latest_rtt - ack_delay;
+
+     cong->smoothed_rtt = (cong->smoothed_rtt * 7 + adjusted_rtt) / 8;

Out of sheer curiosity, is the compiler smart enough to use a 'srl 3' for the above?

net/quic/pnspace.h new file +6 -0

+struct quic_pnspace {
+	/* ECN counters indexed by direction (TX/RX) and ECN codepoint (ECT1, ECT0, CE) */
+	u64 ecn_count[QUIC_ECN_DIR_MAX][QUIC_ECN_MAX];
+	unsigned long *pn_map;	/* Bit map tracking received packet numbers for ACK generation */
+	u16 pn_map_len;		/* Length of the packet number bit map (in bits) */
+	u8  need_sack:1;	/* Flag indicating a SACK frame should be sent for this space */

Quoted 10 lines · Xin Long

net/quic/pnspace.h new file +10 -0

+struct quic_pnspace {
+     /* ECN counters indexed by direction (TX/RX) and ECN codepoint (ECT1, ECT0, CE) */
+     u64 ecn_count[QUIC_ECN_DIR_MAX][QUIC_ECN_MAX];
+     unsigned long *pn_map;  /* Bit map tracking received packet numbers for ACK generation */
+     u16 pn_map_len;         /* Length of the packet number bit map (in bits) */
+     u8  need_sack:1;        /* Flag indicating a SACK frame should be sent for this space */
+     u8  sack_path:1;        /* Path used for sending the SACK frame */
+
+     s64 last_max_pn_seen;   /* Highest packet number seen before pn_map advanced */
+     u32 last_max_pn_time;   /* Timestamp when last_max_pn_seen was received */

net/quic/pnspace.h line 76

Quoted 6 lines

net/quic/pnspace.h new file +6 -0

+     u32 max_time_limit;     /* Time threshold to trigger pn_map advancement on packet receipt */
+     s64 min_pn_seen;        /* Smallest packet number received in this space */
+     s64 max_pn_seen;        /* Largest packet number received in this space */
+     u32 max_pn_time;        /* Time at which max_pn_seen was received */
+     s64 base_pn;            /* Packet number corresponding to the start of the pn_map */
+     u32 time;               /* Cached current time, or time accept a socket (listen socket) */

There are a few 32 bits holes above you could avoid reordering the fields.

Otherwise LGTM,

Acked-by Paolo Abeni <[email protected]>