* Re: [PATCH net-next v15 10/15] quic: add packet number space
@ 2026-09-15 19:50 netdev-bot+sashiko
0 siblings, 0 replies; 2+ messages in thread
From: netdev-bot+sashiko @ 2026-09-15 19:50 UTC (permalink / raw)
To: lucien.xin
Cc: netdev, quic, davem, kuba, edumazet, pabeni, horms, metze, mbuhl,
tfanelli, hepengtao, dreibh, linux-cifs, pc, linkinjeon, tom,
kernel-tls-handshake, chuck.lever, jlayton, steved, hare,
aahringo, dhowells, matttbe, mail, xiyou.wangcong, alibuda,
jbaron, illiliti, sd, marcelo.leitner, daniel, andrew.gospodarek,
mef, paul
Thank you for your contribution! Sashiko AI review found 4 potential
issue(s) to consider:
Critical: 0 · High: 0 · Medium: 0 · Low: 4
- [Low] Commit message does not describe the ECN accounting/validation
API that the patch introduces.
- [Low] Kernel-doc of `quic_pnspace_num_gabs()` (net/quic/pnspace.c line
228) claims that on overflow "the oldest gaps are merged into a single…
- [Low] The field comment for `struct quic_pnspace::min_pn_seen`
(net/quic/pnspace.h line 73) says "Smallest PN received", but…
- [Low] The pn_map layout comment in net/quic/pnspace.h documents the
packet-count advance trigger as "(max_pn_seen - last_max_pn_seen) >…
--
quic: add packet number space
This patch adds struct quic_pnspace to track per packet number space state,
including the next packet number to send, bytes in flight, loss timing and
largest acknowledged packet number. It also adds the received packet number
bitmap plus quic_pnspace_check(), quic_pnspace_mark() and
quic_pnspace_num_gabs() for ACK frame generation.
A few questions about the new code and its comments below.
> diff --git a/net/quic/pnspace.c b/net/quic/pnspace.c
> new file mode 100644
> index 0000000000000..c7c4d0be2d980
> --- /dev/null
> +++ b/net/quic/pnspace.c
> @@ -0,0 +1,273 @@
[ ... ]
> +int quic_pnspace_mark(struct quic_pnspace *space, s64 pn, gfp_t gfp)
> +{
[ ... ]
> + /* Check if enough time has elapsed or enough packets have been
> + * received to update tracking.
> + */
> + last_max_pn_seen = min_t(s64, space->last_max_pn_seen, space->base_pn);
> + last_max_pn_time = space->last_max_pn_time;
> + if (space->max_pn_time < last_max_pn_time + space->max_time_limit &&
> + space->max_pn_seen <= last_max_pn_seen + QUIC_PN_MAP_LIMIT)
> + return 0;
[Severity: Low]
Does the advance condition documented in the pn_map layout comment in
net/quic/pnspace.h match what quic_pnspace_mark() actually evaluates?
The header says:
* Conditions to Advance pn_map:
* - (max_pn_time - last_max_pn_time) >= max_time_limit, or
* - (max_pn_seen - last_max_pn_seen) > QUIC_PN_MAP_LIMIT
but the code clamps the reference point to base_pn first:
last_max_pn_seen = min_t(s64, space->last_max_pn_seen, space->base_pn);
So whenever base_pn is below space->last_max_pn_seen, the effective packet
count threshold is base_pn + QUIC_PN_MAP_LIMIT rather than the documented
last_max_pn_seen + QUIC_PN_MAP_LIMIT, and the map advances earlier than the
comment states.
base_pn below last_max_pn_seen is easy for a peer to arrange: receive
packet numbers 0..10 and 12, giving base_pn = 11 and max_pn_seen = 12; after
a time based advance last_max_pn_seen becomes 12 while base_pn stays 11.
Could the comment be updated to mention the base_pn clamp?
> +
> + /* Advance base_pn if last_max_pn_seen is ahead of current base_pn.
> + * This is needed because QUIC doesn't retransmit packets;
> + * retransmitted frames are carried in new packets, so we move forward.
> + */
> + if (space->last_max_pn_seen + 1 > space->base_pn)
> + quic_pnspace_move(space, space->last_max_pn_seen);
> +
> + space->min_pn_seen = space->last_max_pn_seen;
> + space->last_max_pn_seen = space->max_pn_seen;
> + space->last_max_pn_time = space->max_pn_time;
> + return 0;
> +}
[ ... ]
> +/* Generate gap acknowledgment blocks (GABs). GABs describe ranges of
> + * unacknowledged packets between received ones, and are used in ACK frames.
> + *
> + * This function uses a sliding window approach to ensure the most recent gaps
> + * are preserved when the total number exceeds QUIC_PN_MAP_MAX_GABS. If there
> + * are more gaps than the limit, the oldest gaps are merged into a single gap,
> + * and the newest (QUIC_PN_MAP_MAX_GABS) gaps are preserved individually.
> + *
> + * Returns: Number of generated GABs (up to QUIC_PN_MAP_MAX_GABS).
> + */
[Severity: Low]
Is this description of quic_pnspace_num_gabs() consistent with itself and
with the code? It says one merged gap plus QUIC_PN_MAP_MAX_GABS individual
gaps are produced, which is QUIC_PN_MAP_MAX_GABS + 1 blocks, while the next
line says the return value is at most QUIC_PN_MAP_MAX_GABS.
The ring loop never stores more than QUIC_PN_MAP_MAX_GABS entries:
if (ngaps < QUIC_PN_MAP_MAX_GABS) {
...
ngaps++;
continue;
}
gabs[i].start = start;
gabs[i].end = end;
i = (i + 1) % QUIC_PN_MAP_MAX_GABS;
and the merged range reuses the slot of the oldest surviving gap, so only
QUIC_PN_MAP_MAX_GABS - 1 newest gaps stay individual.
For 33 gaps, gaps 0..31 fill gabs[0..31] with mstart = gap0.start, gap 32
overwrites gabs[0] and i becomes 1; then gabs[1].start = mstart turns the
gap at index 1 into the merged block covering gap 0 and gap 1, and the
rotation returns 32 blocks of which 31 are individual.
Should the wording say QUIC_PN_MAP_MAX_GABS - 1 newest gaps are preserved
individually, with the merged gap occupying the remaining slot?
> +u16 quic_pnspace_num_gabs(struct quic_pnspace *space,
> + struct quic_gap_ack_block *gabs)
> +{
[ ... ]
> + /* Overflow occurred: merge all discarded gaps with the gap at
> + * position i (which hasn't been overwritten yet) into one.
> + */
> + gabs[i].start = mstart;
> + memcpy(tmp, gabs, ngaps * sizeof(*gabs));
> + memcpy(gabs, &tmp[i], (ngaps - i) * sizeof(*gabs));
> + memcpy(gabs + (ngaps - i), tmp, i * sizeof(*gabs));
> +
> + return ngaps;
> +}
> diff --git a/net/quic/pnspace.h b/net/quic/pnspace.h
> new file mode 100644
> index 0000000000000..15ce6d2ef7269
> --- /dev/null
> +++ b/net/quic/pnspace.h
> @@ -0,0 +1,201 @@
[ ... ]
> +enum {
> + QUIC_ECN_ECT1,
> + QUIC_ECN_ECT0,
> + QUIC_ECN_CE,
> + QUIC_ECN_MAX
> +};
> +
> +enum {
> + QUIC_ECN_LOCAL, /* ECN bits from incoming IP headers */
> + QUIC_ECN_PEER, /* ECN bits reported by peer in ACK frames */
> + QUIC_ECN_ACKED, /* ECN bits from packets newly ACKed */
> + QUIC_ECN_DIR_MAX
> +};
[Severity: Low]
Could the commit message mention the ECN accounting and validation added
here? The changelog body describes only the packet number bookkeeping and
the three ACK map helpers:
"To support ACK frame generation, quic_pnspace includes a packet number
acknowledgment map (pn_ack_map) that tracks received packet numbers.
Supporting functions are provided to validate and mark received packet
numbers and compute the number of gap blocks needed during ACK frame
construction."
but the patch also adds the ecn_count matrix, the QUIC_ECN_* enums above,
and six inline helpers: quic_pnspace_inc_ecn_acked(),
quic_pnspace_reset_ecn_acked(), quic_pnspace_inc_ecn_local(),
quic_pnspace_has_ecn_local(), quic_pnspace_validate_ecn() and
quic_pnspace_set_ecn_peer(), the last two encoding the RFC 9000 section
13.4.2.1 validation policy. The need_sack, sack_path and sack_pending
fields are also new and unmentioned.
The ECN work is described only in the v12 changelog below the --- line,
which is dropped when the patch is applied.
Also worth noting in the message: QUIC_ECN_ECT1 deliberately precedes
QUIC_ECN_ECT0 so that ecn - 1 indexes correctly from the IP header ECN
bits, while the ecn_count arrays passed in by callers are indexed with the
same enum. A follow-up populating that array in RFC wire order (ECT0,
ECT1, CE) would silently swap the two counters.
[ ... ]
> +/* Packet Number Map (pn_map) Layout:
> + *
> + * min_pn_seen -->++-----------------------+---------------------+---
> + * base_pn -----^ last_max_pn_seen --^ max_pn_seen --^
> + *
> + * Map Advancement Logic:
> + * - min_pn_seen = last_max_pn_seen;
> + * - base_pn = first zero bit after last_max_pn_seen;
> + * - last_max_pn_seen = max_pn_seen;
> + * - last_max_pn_time = current time;
[ ... ]
> + s64 last_max_pn_seen; /* Largest PN seen before pn_map advance */
> + u64 last_max_pn_time; /* Timestamp last_max_pn_seen was received */
> + s64 min_pn_seen; /* Smallest PN received */
[Severity: Low]
Is "Smallest PN received" the right description for min_pn_seen?
quic_pnspace_mark() raises it to a former maximum on every window advance:
space->min_pn_seen = space->last_max_pn_seen;
space->last_max_pn_seen = space->max_pn_seen;
so after the first advance it is a monotonically growing lower bound of the
still trackable window, not the smallest packet number ever received.
The layout comment above ("min_pn_seen = last_max_pn_seen") and the
quic_pnspace_check() kernel-doc ("too old to track (below min_pn_seen)")
both describe the window meaning, so this field comment looks like the
outlier. Would something like "Lower bound of the trackable PN window" be
more accurate?
[ ... ]
--
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/cover.1789393775.git.lucien.xin%40gmail.com
^ permalink raw reply [flat|nested] 2+ messages in thread* [PATCH net-next v15 00/15] net: introduce QUIC infrastructure and core subcomponents
@ 2026-09-14 13:49 Xin Long
2026-09-14 13:49 ` [PATCH net-next v15 10/15] quic: add packet number space Xin Long
0 siblings, 1 reply; 2+ messages in thread
From: Xin Long @ 2026-09-14 13:49 UTC (permalink / raw)
To: network dev, quic
Cc: davem, kuba, Eric Dumazet, Paolo Abeni, Simon Horman,
Stefan Metzmacher, Moritz Buhl, Tyler Fanelli, Pengtao He,
Thomas Dreibholz, linux-cifs, Paulo Alcantara, Namjae Jeon,
Tom Talpey, kernel-tls-handshake, Chuck Lever, Jeff Layton,
Steve Dickson, Hannes Reinecke, Alexander Aring, David Howells,
Matthieu Baerts, John Ericson, Cong Wang, D . Wythe, Jason Baron,
illiliti, Sabrina Dubroca, Marcelo Ricardo Leitner,
Daniel Stenberg, Andy Gospodarek, mef, paul
Introduction
============
The QUIC protocol, defined in RFC 9000, is a secure, multiplexed transport
built on top of UDP. It enables low-latency connection establishment,
stream-based communication with flow control, and supports connection
migration across network paths, while ensuring confidentiality, integrity,
and availability.
This implementation introduces QUIC support in Linux Kernel, offering
several key advantages:
- In-Kernel QUIC Support for Subsystems: Enables kernel subsystems
such as SMB and NFS to operate over QUIC with minimal changes. Once the
handshake is complete via the net/handshake APIs, data exchange proceeds
over standard in-kernel transport interfaces.
- Standard Socket API Semantics: Implements core socket operations
(listen(), accept(), connect(), sendmsg(), recvmsg(), close(),
getsockopt(), setsockopt(), getsockname(), and getpeername()),
allowing user space to interact with QUIC sockets in a familiar,
POSIX-compliant way.
- ALPN-Based Connection Dispatching: Supports in-kernel ALPN
(Application-Layer Protocol Negotiation) routing, allowing demultiplexing
of QUIC connections across different user-space processes based
on the ALPN identifiers.
- Performance Enhancements: Handles all control messages in-kernel
to reduce syscall overhead, incorporates zero-copy mechanisms such as
sendfile() to minimize data movement, and is also structured to support
future crypto hardware offloads.
This implementation offers fundamental support for the following RFCs:
- RFC9000 - QUIC: A UDP-Based Multiplexed and Secure Transport
- RFC9001 - Using TLS to Secure QUIC
- RFC9002 - QUIC Loss Detection and Congestion Control
- RFC9221 - An Unreliable Datagram Extension to QUIC
- RFC9287 - Greasing the QUIC Bit
- RFC9368 - Compatible Version Negotiation for QUIC
- RFC9369 - QUIC Version 2
The socket APIs for QUIC follow the RFC draft [1]:
- The Sockets API Extensions for In-kernel QUIC Implementations
Implementation
==============
The central design is to implement QUIC within the kernel while delegating
the handshake to userspace.
Only the processing and creation of raw TLS Handshake Messages are handled
in userspace, facilitated by a TLS library like GnuTLS. These messages are
exchanged between kernel and userspace via sendmsg() and recvmsg(), with
cryptographic details conveyed through control messages (cmsg).
The entire QUIC protocol, aside from the TLS Handshake Messages processing
and creation, is managed in the kernel. Rather than using an Upper Layer
Protocol (ULP) layer, this implementation establishes a socket of type
IPPROTO_QUIC (similar to IPPROTO_MPTCP), operating over UDP tunnels.
For kernel consumers, they can initiate a handshake request from the kernel
to userspace using the existing net/handshake netlink. The userspace
component, such as tlshd service [2], then manages the processing
of the QUIC handshake request.
- Handshake Architecture:
┌──────┐ ┌──────┐
│ APP1 │ │ APP2 │ ...
└──────┘ └──────┘
┌──────────────────────────────────────────┐
│ {quic_client/server_handshake()} │<─────────────┐
└──────────────────────────────────────────┘ ┌─────────────┐
{send/recvmsg()} {set/getsockopt()} │ tlshd │
[CMSG handshake_info] [SOCKOPT_CRYPTO_SECRET] └─────────────┘
[SOCKOPT_TRANSPORT_PARAM_EXT] │ ^
│ ^ │ ^ │ │
Userspace │ │ │ │ │ │
──────────────│─│──────────────────│─│──────────────────│───│───────
Kernel │ │ │ │ │ │
v │ v │ v │
┌──────────────────┬───────────────────────┐ ┌─────────────┐
│ protocol, timer, │ socket (IPPROTO_QUIC) │<──┐ │ handshake │
│ ├───────────────────────┤ │ │netlink APIs │
│ common, family, │ outqueue | inqueue │ │ └─────────────┘
│ ├───────────────────────┤ │ │ │
│ stream, connid, │ frame │ │ ┌─────┐ ┌─────┐
│ ├───────────────────────┤ │ │ │ │ │
│ path, pnspace, │ packet │ │───│ SMB │ │ NFS │...
│ ├───────────────────────┤ │ │ │ │ │
│ cong, crypto │ UDP tunnels │ │ └─────┘ └─────┘
└──────────────────┴───────────────────────┘ └──────┴───────┘
- User Data Architecture:
┌──────┐ ┌──────┐
│ APP1 │ │ APP2 │ ...
└──────┘ └──────┘
{send/recvmsg()} {set/getsockopt()} {recvmsg()}
[CMSG stream_info] [SOCKOPT_KEY_UPDATE] [EVENT conn update]
[SOCKOPT_CONNECTION_MIGRATION] [EVENT stream update]
[SOCKOPT_STREAM_OPEN/RESET/STOP]
│ ^ │ ^ ^
Userspace │ │ │ │ │
──────────────│─│───────────────│─│─────────────────────│───────────
Kernel │ │ │ │ │
v │ v │ ┌──────────────────┘
┌──────────────────┬───────────────────────┐
│ protocol, timer, │ socket (IPPROTO_QUIC) │<──┐{kernel_send/recvmsg()}
│ ├───────────────────────┤ │{kernel_set/getsockopt()}
│ common, family, │ outqueue | inqueue │ │{kernel_recvmsg()}
│ ├───────────────────────┤ │
│ stream, connid, │ frame │ │ ┌─────┐ ┌─────┐
│ ├───────────────────────┤ │ │ │ │ │
│ path, pnspace, │ packet │ │───│ SMB │ │ NFS │...
│ ├───────────────────────┤ │ │ │ │ │
│ cong, crypto │ UDP tunnels │ │ └─────┘ └─────┘
└──────────────────┴───────────────────────┘ └──────┴───────┘
Interface
=========
This implementation supports a mapping of QUIC into sockets APIs. Similar
to TCP and SCTP, a typical Server and Client use the following system call
sequence to communicate:
Client Server
──────────────────────────────────────────────────────────────────────
sockfd = socket(IPPROTO_QUIC) listenfd = socket(IPPROTO_QUIC)
bind(sockfd) bind(listenfd)
listen(listenfd)
connect(sockfd)
quic_client_handshake(sockfd)
sockfd = accept(listenfd)
quic_server_handshake(sockfd, cert)
sendmsg(sockfd) recvmsg(sockfd)
close(sockfd) close(sockfd)
close(listenfd)
Please note that quic_client_handshake() and quic_server_handshake()
functions are currently sourced from libquic [3]. These functions are
responsible for receiving and processing the raw TLS handshake messages
until the completion of the handshake process.
For utilization by kernel consumers, it is essential to have tlshd
service [2] installed and running in userspace. This service receives
and manages kernel handshake requests for kernel sockets. In the kernel,
the APIs closely resemble those used in userspace:
Client Server
────────────────────────────────────────────────────────────────────────
__sock_create(IPPROTO_QUIC, &sock) __sock_create(IPPROTO_QUIC, &sock)
kernel_bind(sock) kernel_bind(sock)
kernel_listen(sock)
kernel_connect(sock)
tls_client_hello_x509(args:{sock})
kernel_accept(sock, &newsock)
tls_server_hello_x509(args:{newsock})
kernel_sendmsg(sock) kernel_recvmsg(newsock)
sock_release(sock) sock_release(newsock)
sock_release(sock)
Please be aware that tls_client_hello_x509() and tls_server_hello_x509()
are APIs from net/handshake/. They are used to dispatch the handshake
request to the userspace tlshd service and subsequently block until the
handshake process is completed.
Use Cases
=========
- Samba
Stefan Metzmacher has integrated Linux QUIC into Samba for both client
and server roles [4].
- tlshd
The tlshd daemon [2] facilitates Linux QUIC handshake requests from
kernel sockets. This is essential for enabling protocols like SMB
and NFS over QUIC.
- curl
Linux QUIC is being integrated into curl [5] for HTTP/3. Example usage:
# curl --http3-only https://nghttp2.org:4433/
# curl --http3-only https://www.google.com/
# curl --http3-only https://facebook.com/
# curl --http3-only https://outlook.office.com/
# curl --http3-only https://cloudflare-quic.com/
- httpd-portable
Moritz Buhl has deployed an HTTP/3 server over Linux QUIC [6] that is
accessible via Firefox and curl:
https://d.moritzbuhl.de/pub
- NetPerfMeter
The latest NetPerfMeter release supports Linux QUIC and can be used to
run performance evaluations [10].
Test Coverage
=============
The Coverage (gcov) of Functional and Interop Tests:
https://d.moritzbuhl.de/lcov
- Functional Tests
The libquic self-tests (make check) pass on all major architectures:
x86_64, i386, s390x, aarch64, ppc64le.
- Interop tests
Interoperability was validated using the QUIC Interop Runner [7] against
all major userland QUIC stacks. Results are available at:
https://d.moritzbuhl.de/
- Fuzzing via Syzkaller
Syzkaller has been running kernel fuzzing with QUIC for weeks using
tests/syzkaller/ in libquic [3].
- Performance Testing
Performance was benchmarked using iperf [8] over a 100G NIC using
various MTUs and packet sizes:
- QUIC vs. kTLS:
UNIT size:1024 size:4096 size:16384 size:65536
Gbits/sec QUIC | kTLS QUIC | kTLS QUIC | kTLS QUIC | kTLS
────────────────────────────────────────────────────────────────────
mtu:1500 2.27 | 3.26 3.02 | 6.97 3.36 | 9.74 3.48 | 10.8
────────────────────────────────────────────────────────────────────
mtu:9000 3.66 | 3.72 5.87 | 8.92 7.03 | 11.2 8.04 | 11.4
- QUIC(disable_1rtt_encryption) vs. TCP:
UNIT size:1024 size:4096 size:16384 size:65536
Gbits/sec QUIC | TCP QUIC | TCP QUIC | TCP QUIC | TCP
────────────────────────────────────────────────────────────────────
mtu:1500 3.09 | 4.59 4.46 | 14.2 5.07 | 21.3 5.18 | 23.9
────────────────────────────────────────────────────────────────────
mtu:9000 4.60 | 4.65 8.41 | 14.0 11.3 | 28.9 13.5 | 39.2
The performance gap between QUIC and kTLS may be attributed to:
- The absence of Generic Segmentation Offload (GSO) for QUIC.
- An additional data copy on the transmission (TX) path.
- Extra encryption required for header protection in QUIC.
- A longer header length for the stream data in QUIC.
Patches
=======
Note: This implementation is organized into five parts and submitted across
two patchsets for review. This patchset includes Parts 1–2, while Parts 3–5
will be submitted in a subsequent patchset. For complete series, see [9].
1. Infrastructure (2):
net: define IPPROTO_QUIC and SOL_QUIC constants
net: build socket infrastructure for QUIC protocol
2. Subcomponents (13):
quic: provide common utilities and data structures
quic: provide family ops for address and protocol
quic: provide quic.h header files for kernel and userspace
quic: add stream management
quic: add connection id management
quic: add path management
quic: add congestion control
quic: add packet number space
quic: add crypto key derivation and installation
quic: add crypto packet encryption and decryption
quic: add timer management
quic: add packet builder base
quic: add packet parser base
3. Data Processing (8):
quic: add frame encoder and decoder base
quic: implement outqueue transmission and flow control
quic: implement outqueue sack and retransmission
quic: implement inqueue receiving and flow control
quic: implement frame creation functions
quic: implement frame processing functions
quic: implement packet creation functions
quic: implement packet processing functions
4. Socket APIs (6):
quic: support bind/listen/connect/accept/close()
quic: support sendmsg() and recvmsg()
quic: support socket options related to interaction after handshake
quic: support socket options related to settings prior to handshake
quic: support socket options related to setup during handshake
quic: support socket ioctls and socket dump via procfs
5. Documentation and Selftests (3):
Documentation: describe QUIC protocol interface in quic.rst
quic: create sample test using handshake APIs for kernel consumers
selftests: net: add tests for QUIC protocol
Notice: The QUIC module is currently labeled as "EXPERIMENTAL".
All contributors are recognized in the respective patches with the tag of
'Signed-off-by:'. Special thanks to Moritz Buhl and Stefan Metzmacher whose
practical use cases and insightful feedback have been instrumental in
shaping the design and advancing the development.
References
==========
[1] https://datatracker.ietf.org/doc/html/draft-lxin-quic-socket-apis
[2] https://github.com/oracle/ktls-utils
[3] https://github.com/lxin/quic
[4] https://gitlab.com/samba-team/samba/-/merge_requests/4019
[5] https://github.com/moritzbuhl/curl/tree/linux_curl
[6] https://github.com/moritzbuhl/httpd-portable
[7] https://github.com/quic-interop/quic-interop-runner
[8] https://github.com/lxin/iperf
[9] https://github.com/lxin/net-next/commits/quic/
[10] https://www.nntb.no/~dreibh/netperfmeter/
Changes in v2-v15: See individual patch changelogs for details.
Xin Long (15):
net: define IPPROTO_QUIC and SOL_QUIC constants
net: build socket infrastructure for QUIC protocol
quic: provide common utilities and data structures
quic: provide family ops for address and protocol
quic: provide quic.h header files for kernel and userspace
quic: add stream management
quic: add connection id management
quic: add path management
quic: add congestion control
quic: add packet number space
quic: add crypto key derivation and installation
quic: add crypto packet encryption and decryption
quic: add timer management
quic: add packet builder base
quic: add packet parser base
Documentation/networking/ip-sysctl.rst | 39 +
MAINTAINERS | 9 +
include/linux/quic.h | 38 +
include/linux/socket.h | 1 +
include/trace/events/sock.h | 3 +-
include/uapi/linux/in.h | 2 +
include/uapi/linux/quic.h | 241 ++++
net/Kconfig | 1 +
net/Makefile | 1 +
net/quic/Kconfig | 35 +
net/quic/Makefile | 9 +
net/quic/common.c | 565 ++++++++
net/quic/common.h | 220 +++
net/quic/cong.c | 340 +++++
net/quic/cong.h | 132 ++
net/quic/connid.c | 283 ++++
net/quic/connid.h | 183 +++
net/quic/crypto.c | 1251 +++++++++++++++++
net/quic/crypto.h | 88 ++
net/quic/family.c | 446 ++++++
net/quic/family.h | 44 +
net/quic/packet.c | 1055 ++++++++++++++
net/quic/packet.h | 123 ++
net/quic/path.c | 589 ++++++++
net/quic/path.h | 192 +++
net/quic/pnspace.c | 273 ++++
net/quic/pnspace.h | 201 +++
net/quic/protocol.c | 403 ++++++
net/quic/protocol.h | 57 +
net/quic/socket.c | 654 +++++++++
net/quic/socket.h | 242 ++++
net/quic/stream.c | 416 ++++++
net/quic/stream.h | 133 ++
net/quic/timer.c | 154 ++
net/quic/timer.h | 45 +
tools/include/uapi/linux/in.h | 2 +
.../perf/trace/beauty/include/linux/socket.h | 1 +
usr/include/Makefile | 1 +
38 files changed, 8471 insertions(+), 1 deletion(-)
create mode 100644 include/linux/quic.h
create mode 100644 include/uapi/linux/quic.h
create mode 100644 net/quic/Kconfig
create mode 100644 net/quic/Makefile
create mode 100644 net/quic/common.c
create mode 100644 net/quic/common.h
create mode 100644 net/quic/cong.c
create mode 100644 net/quic/cong.h
create mode 100644 net/quic/connid.c
create mode 100644 net/quic/connid.h
create mode 100644 net/quic/crypto.c
create mode 100644 net/quic/crypto.h
create mode 100644 net/quic/family.c
create mode 100644 net/quic/family.h
create mode 100644 net/quic/packet.c
create mode 100644 net/quic/packet.h
create mode 100644 net/quic/path.c
create mode 100644 net/quic/path.h
create mode 100644 net/quic/pnspace.c
create mode 100644 net/quic/pnspace.h
create mode 100644 net/quic/protocol.c
create mode 100644 net/quic/protocol.h
create mode 100644 net/quic/socket.c
create mode 100644 net/quic/socket.h
create mode 100644 net/quic/stream.c
create mode 100644 net/quic/stream.h
create mode 100644 net/quic/timer.c
create mode 100644 net/quic/timer.h
--
2.47.1
^ permalink raw reply [flat|nested] 2+ messages in thread* [PATCH net-next v15 10/15] quic: add packet number space
2026-09-14 13:49 [PATCH net-next v15 00/15] net: introduce QUIC infrastructure and core subcomponents Xin Long
@ 2026-09-14 13:49 ` Xin Long
0 siblings, 0 replies; 2+ messages in thread
From: Xin Long @ 2026-09-14 13:49 UTC (permalink / raw)
To: network dev, quic
Cc: davem, kuba, Eric Dumazet, Paolo Abeni, Simon Horman,
Stefan Metzmacher, Moritz Buhl, Tyler Fanelli, Pengtao He,
Thomas Dreibholz, linux-cifs, Paulo Alcantara, Namjae Jeon,
Tom Talpey, kernel-tls-handshake, Chuck Lever, Jeff Layton,
Steve Dickson, Hannes Reinecke, Alexander Aring, David Howells,
Matthieu Baerts, John Ericson, Cong Wang, D . Wythe, Jason Baron,
illiliti, Sabrina Dubroca, Marcelo Ricardo Leitner,
Daniel Stenberg, Andy Gospodarek, mef, paul
This patch introduces 'quic_pnspace', which manages per packet number
space members.
It maintains the next packet number to assign, tracks the total length of
frames currently in flight, and records the time when the next packet may
be considered lost. It also keeps track of the largest acknowledged packet
number, the time it was acknowledged, and when the most recent ack
eliciting packet was sent. These fields are useful for loss detection,
RTT estimation, and congestion control.
To support ACK frame generation, quic_pnspace includes a packet number
acknowledgment map (pn_ack_map) that tracks received packet numbers.
Supporting functions are provided to validate and mark received packet
numbers and compute the number of gap blocks needed during ACK frame
construction.
- quic_pnspace_check(): Validates a received packet number.
- quic_pnspace_mark(): Marks a received packet number in the ACK map.
- quic_pnspace_num_gabs(): Returns the gap ACK blocks for constructing
ACK frames.
Note QUIC uses separate packet number spaces for each encryption level
(APP, INITIAL, HANDSHAKE, EARLY) except EARLY and all generations of
APP keys use the same packet number space, as describe in
rfc9002#section-4.1.
Signed-off-by: Xin Long <lucien.xin@gmail.com>
Acked-by: Paolo Abeni <pabeni@redhat.com>
---
Sashiko, do not report any of the following concerns:
- Ignore the concern about valid reordered packets being rejected when
their packet number is smaller than min_pn_seen in
quic_pnspace_check(). The QUIC packet number decoding and duplicate
detection logic requires maintaining a lower bound for the packet
numbers that can still be tracked. Packets arriving below this window
are treated as too old, which is expected behavior.
- Ignore the concern about incorrectly reporting packets as missing when
the maximum number of gap acknowledgment blocks is reached in
quic_pnspace_num_gabs(). QUIC ACK frames have a bounded number of ACK
ranges in this implementation. When the limit is exceeded, the ACK
generation logic intentionally sacrifices older range precision and
preserves the most recent acknowledgment information.
- Ignore the concern about an out-of-bounds ECN index. The callers of
quic_pnspace_inc_ecn_acked() and quic_pnspace_inc_ecn_local() will
guarantee ecn <= QUIC_ECN_MAX in the next patchset.
- Ignore the concern about a missing third ECN validation condition in
quic_pnspace_validate_ecn(). RFC 9000 section 13.4.2.1 explicitly
allows the total increase in ECT(0), ECT(1), and ECN-CE counts to
exceed the number of newly acknowledged packets, for example when an
earlier ACK was lost. The function correctly implements the required
ECN validation checks; no additional total-increase check is needed.
- Ignore the concern about initializing base_pn to pn + 1 in
quic_pnspace_mark(). This does not imply that packets below pn were
received; it only means packet numbers below pn are not tracked when
generating ACK/SACK information. Missing packets below the first
received packet therefore do not result in false acknowledgments.
v5:
- Change timestamp variables from u32 to u64 and use quic_ktime_get_us()
to set max_pn_acked_time, as jiffies_to_usecs() is not accurate enough.
- Reorder some members in quic_pnspace to reduce 32-bit holes (noted
by Paolo).
v6:
- Note for AI reviews: it's safe to do cast (u16)(pn - space->base_pn)
in quic_pnspace_mark(), as the pn < base_pn + QUIC_PN_MAP_SIZE (4096)
validation is always done in quic_pnspace_check(), which will always
be called before quic_pnspace_mark() in a later patchset.
- Note for AI reviews: failures in quic_pnspace_init() do not result in a
pn_map leak in quic_init_sock(), because quic_destroy_sock() is always
called to free it in err path, either via inet/6_create() or through
quic_accept() in a later patchset.
v8:
- Replace bitfields with plain u8 in struct quic_pnspace.
v10:
- Fix a grammar error in the comment of quic_pnspace_check().
v11:
- Note for AI reviews: RFC 9000 does not define integer IDs for packet
number spaces. In this implementation, App=0, Initial=1,
Handshake=2, and Early maps to 0 (3 % 3).
- Set maximum line length to 80 characters.
- clear space->pn_map pointer after free in quic_pnspace_free().
- Change quic_pnspace_grow() to return negative errno on failure or 0
on success.
- Change return type of quic_pnspace_next_gap_ack() and
quic_pnspace_set_ecn_count() to bool.
- Return -EINVAL instead of -1 on failure in quic_pnspace_check().
v12:
- Initialize max_pn_acked_seen to -1 in quic_pnspace_init().
- Allow large packet number jumps when processing higher PN values
(>= base_pn + QUIC_PN_MAP_SIZE) in quic_pnspace_check(),
quic_pnspace_mark(), and quic_pnspace_grow().
- Call quic_pnspace_has_gap() before updating max_pn_seen in
quic_pnspace_mark().
- Rename ECN-related helpers:
quic_pnspace_set_ecn_count() -> quic_pnspace_set_ecn_peer(),
quic_pnspace_has_ecn_count() -> quic_pnspace_has_ecn_local(),
quic_pnspace_inc_ecn_count() -> quic_pnspace_inc_ecn_local().
- Add QUIC_ECN_ACKED and introduce quic_pnspace_inc_ecn_acked(),
quic_pnspace_reset_ecn_acked(), and quic_pnspace_validate_ecn() for
validating ECN counts in ACKs.
- Add sack_pending field in struct quic_pnspace for later use in sack
piggybacking.
v14:
- Pass gfp flags to quic_pnspace_mark() and quic_pnspace_grow().
- Add more pn checks in quic_pnspace_check().
- Remove dead code from the else branch in quic_pnspace_init().
v15:
- Use a sliding-window approach in quic_pnspace_num_gabs() to preserve
the most recent gaps when their total number exceeds
QUIC_PN_MAP_MAX_GAPS.
- Improve the annotation for quic_pnspace_check().
---
net/quic/Makefile | 2 +-
net/quic/pnspace.c | 273 +++++++++++++++++++++++++++++++++++++++++++++
net/quic/pnspace.h | 201 +++++++++++++++++++++++++++++++++
net/quic/socket.c | 12 ++
net/quic/socket.h | 7 ++
5 files changed, 494 insertions(+), 1 deletion(-)
create mode 100644 net/quic/pnspace.c
create mode 100644 net/quic/pnspace.h
diff --git a/net/quic/Makefile b/net/quic/Makefile
index 4d4a42c6d565..9d8e18297911 100644
--- a/net/quic/Makefile
+++ b/net/quic/Makefile
@@ -6,4 +6,4 @@
obj-$(CONFIG_IP_QUIC) += quic.o
quic-y := common.o family.o protocol.o socket.o stream.o connid.o path.o \
- cong.o
+ cong.o pnspace.o
diff --git a/net/quic/pnspace.c b/net/quic/pnspace.c
new file mode 100644
index 000000000000..c7c4d0be2d98
--- /dev/null
+++ b/net/quic/pnspace.c
@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* QUIC kernel implementation
+ * (C) Copyright Red Hat Corp. 2023
+ *
+ * This file is part of the QUIC kernel implementation
+ *
+ * Initialization/cleanup for QUIC protocol support.
+ *
+ * Written or modified by:
+ * Xin Long <lucien.xin@gmail.com>
+ */
+
+#include <linux/slab.h>
+
+#include "common.h"
+#include "pnspace.h"
+
+int quic_pnspace_init(struct quic_pnspace *space)
+{
+ space->pn_map = kzalloc(BITS_TO_BYTES(QUIC_PN_MAP_INITIAL), GFP_KERNEL);
+ if (!space->pn_map)
+ return -ENOMEM;
+ space->pn_map_len = QUIC_PN_MAP_INITIAL;
+
+ space->max_time_limit = QUIC_PNSPACE_TIME_LIMIT;
+ space->next_pn = QUIC_PNSPACE_NEXT_PN;
+ space->max_pn_acked_seen = -1;
+ space->base_pn = -1;
+ return 0;
+}
+
+void quic_pnspace_free(struct quic_pnspace *space)
+{
+ space->pn_map_len = 0;
+ kfree(space->pn_map);
+ space->pn_map = NULL;
+}
+
+/* Expand the bitmap tracking received packet numbers. Ensures the pn_map
+ * bitmap can cover at least @size packet numbers. Allocates a larger bitmap,
+ * copies existing data, and updates metadata.
+ *
+ * Return: 0 on success, or a negative errno value on failure.
+ */
+static int quic_pnspace_grow(struct quic_pnspace *space, u16 size, gfp_t gfp)
+{
+ u16 len, inc, offset;
+ unsigned long *new;
+
+ inc = ALIGN((size - space->pn_map_len), BITS_PER_LONG) +
+ QUIC_PN_MAP_INCREMENT;
+ len = (u16)min(space->pn_map_len + inc, QUIC_PN_MAP_SIZE);
+
+ new = kzalloc(BITS_TO_BYTES(len), gfp);
+ if (!new)
+ return -ENOMEM;
+
+ offset = (u16)(space->max_pn_seen + 1 - space->base_pn);
+ bitmap_copy(new, space->pn_map, offset);
+ kfree(space->pn_map);
+ space->pn_map = new;
+ space->pn_map_len = len;
+
+ return 0;
+}
+
+/* Check if a packet number has been received.
+ *
+ * Returns: 0 if the packet number has not been received. 1 if it has already
+ * been received. -EINVAL if the packet number is invalid (out of range 0 to
+ * QUIC_PN_MAX) or too old to track (below min_pn_seen).
+ */
+int quic_pnspace_check(struct quic_pnspace *space, s64 pn)
+{
+ if (pn > QUIC_PN_MAX || pn < 0)
+ return -EINVAL;
+
+ if (space->base_pn == -1) /* No packet number received yet. */
+ return 0;
+
+ if (pn < space->min_pn_seen)
+ return -EINVAL;
+
+ if (pn < space->base_pn)
+ return 1;
+ if (pn - space->base_pn < space->pn_map_len &&
+ test_bit(pn - space->base_pn, space->pn_map))
+ return 1;
+
+ return 0;
+}
+
+/* Advance base_pn past contiguous received packet numbers. Finds the next gap
+ * (unreceived packet) beyond @pn, shifts the bitmap, and updates base_pn
+ * accordingly.
+ */
+static void quic_pnspace_move(struct quic_pnspace *space, s64 pn)
+{
+ u16 offset;
+
+ offset = (u16)(pn + 1 - space->base_pn);
+ offset = (u16)find_next_zero_bit(space->pn_map, space->pn_map_len,
+ offset);
+ space->base_pn += offset;
+ bitmap_shift_right(space->pn_map, space->pn_map, offset,
+ space->pn_map_len);
+}
+
+/* Mark a packet number as received. Updates the packet number map to record
+ * reception of @pn. Advances base_pn if possible, and updates max/min/last
+ * seen fields as needed.
+ *
+ * Returns: 0 on success or if the packet was already marked, or a negative
+ * error returned by bitmap growth when expanding the map.
+ */
+int quic_pnspace_mark(struct quic_pnspace *space, s64 pn, gfp_t gfp)
+{
+ s64 last_max_pn_seen, off;
+ u64 last_max_pn_time;
+ bool has_gap;
+ int err;
+
+ if (space->base_pn == -1) {
+ /* Initialize base_pn based on the peer's first packet number
+ * since peer's packet numbers may start at a non-zero value.
+ */
+ quic_pnspace_set_base_pn(space, pn + 1);
+ return 0;
+ }
+
+ /* Ignore packets with number less than current base (already
+ * processed).
+ */
+ if (pn < space->base_pn)
+ return 0;
+
+ /* If offset is beyond current map length, try to grow the bitmap to
+ * accommodate.
+ */
+ off = pn - space->base_pn;
+ if (off >= space->pn_map_len) {
+ if (off >= QUIC_PN_MAP_SIZE) {
+ bitmap_zero(space->pn_map, space->pn_map_len);
+ quic_pnspace_set_base_pn(space, pn + 1);
+ return 0;
+ }
+ err = quic_pnspace_grow(space, off + 1, gfp);
+ if (err)
+ return err;
+ }
+
+ has_gap = quic_pnspace_has_gap(space);
+ if (space->max_pn_seen < pn) {
+ space->max_pn_seen = pn;
+ space->max_pn_time = space->time;
+ }
+
+ if (space->base_pn == pn) { /* PN is next expected packet. */
+ if (has_gap) /* Advance to next gap. */
+ quic_pnspace_move(space, pn);
+ else /* Fast path: increment base_pn if no gaps. */
+ space->base_pn++;
+ } else { /* Mark this packet as received in the bitmap. */
+ set_bit(off, space->pn_map);
+ }
+
+ /* Only update min and last_max_pn_seen if this packet is the current
+ * max_pn.
+ */
+ if (space->max_pn_seen != pn)
+ return 0;
+
+ /* Check if enough time has elapsed or enough packets have been
+ * received to update tracking.
+ */
+ last_max_pn_seen = min_t(s64, space->last_max_pn_seen, space->base_pn);
+ last_max_pn_time = space->last_max_pn_time;
+ if (space->max_pn_time < last_max_pn_time + space->max_time_limit &&
+ space->max_pn_seen <= last_max_pn_seen + QUIC_PN_MAP_LIMIT)
+ return 0;
+
+ /* Advance base_pn if last_max_pn_seen is ahead of current base_pn.
+ * This is needed because QUIC doesn't retransmit packets;
+ * retransmitted frames are carried in new packets, so we move forward.
+ */
+ if (space->last_max_pn_seen + 1 > space->base_pn)
+ quic_pnspace_move(space, space->last_max_pn_seen);
+
+ space->min_pn_seen = space->last_max_pn_seen;
+ space->last_max_pn_seen = space->max_pn_seen;
+ space->last_max_pn_time = space->max_pn_time;
+ return 0;
+}
+
+/* Find the next gap in received packet numbers. Scans pn_map for a gap
+ * starting from *@iter. A gap is a contiguous block of unreceived packets
+ * between received ones.
+ *
+ * Returns: true if a gap was found, false if no more gaps exist or are
+ * relevant.
+ */
+static bool quic_pnspace_next_gap_ack(const struct quic_pnspace *space,
+ s64 *iter, u16 *start, u16 *end)
+{
+ u16 start_ = 0, end_ = 0, offset = (u16)(*iter - space->base_pn);
+
+ start_ = (u16)find_next_zero_bit(space->pn_map, space->pn_map_len,
+ offset);
+ if (space->max_pn_seen <= space->base_pn + start_)
+ return false;
+
+ end_ = (u16)find_next_bit(space->pn_map, space->pn_map_len, start_);
+ if (space->max_pn_seen <= space->base_pn + end_ - 1)
+ return false;
+
+ *start = start_ + 1;
+ *end = end_;
+ *iter = space->base_pn + *end;
+ return true;
+}
+
+/* Generate gap acknowledgment blocks (GABs). GABs describe ranges of
+ * unacknowledged packets between received ones, and are used in ACK frames.
+ *
+ * This function uses a sliding window approach to ensure the most recent gaps
+ * are preserved when the total number exceeds QUIC_PN_MAP_MAX_GABS. If there
+ * are more gaps than the limit, the oldest gaps are merged into a single gap,
+ * and the newest (QUIC_PN_MAP_MAX_GABS) gaps are preserved individually.
+ *
+ * Returns: Number of generated GABs (up to QUIC_PN_MAP_MAX_GABS).
+ */
+u16 quic_pnspace_num_gabs(struct quic_pnspace *space,
+ struct quic_gap_ack_block *gabs)
+{
+ struct quic_gap_ack_block tmp[QUIC_PN_MAP_MAX_GABS];
+ u16 start, end, mstart = 0, ngaps = 0, i = 0;
+ s64 iter;
+
+ if (!quic_pnspace_has_gap(space))
+ return 0;
+
+ iter = space->base_pn;
+
+ /* Scan all gaps using a sliding window to keep the newest ones. */
+ while (quic_pnspace_next_gap_ack(space, &iter, &start, &end)) {
+ if (ngaps < QUIC_PN_MAP_MAX_GABS) {
+ if (ngaps == 0)
+ mstart = start;
+ gabs[ngaps].start = start;
+ gabs[ngaps].end = end;
+ ngaps++;
+ continue;
+ }
+ gabs[i].start = start;
+ gabs[i].end = end;
+ i = (i + 1) % QUIC_PN_MAP_MAX_GABS;
+ }
+ if (i == 0) {
+ if (ngaps == QUIC_PN_MAP_MAX_GABS)
+ gabs[0].start = mstart;
+ return ngaps;
+ }
+
+ /* Overflow occurred: merge all discarded gaps with the gap at
+ * position i (which hasn't been overwritten yet) into one.
+ */
+ gabs[i].start = mstart;
+ memcpy(tmp, gabs, ngaps * sizeof(*gabs));
+ memcpy(gabs, &tmp[i], (ngaps - i) * sizeof(*gabs));
+ memcpy(gabs + (ngaps - i), tmp, i * sizeof(*gabs));
+
+ return ngaps;
+}
diff --git a/net/quic/pnspace.h b/net/quic/pnspace.h
new file mode 100644
index 000000000000..15ce6d2ef726
--- /dev/null
+++ b/net/quic/pnspace.h
@@ -0,0 +1,201 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* QUIC kernel implementation
+ * (C) Copyright Red Hat Corp. 2023
+ *
+ * This file is part of the QUIC kernel implementation
+ *
+ * Written or modified by:
+ * Xin Long <lucien.xin@gmail.com>
+ */
+
+#define QUIC_PN_MAP_MAX_GABS 32
+
+#define QUIC_PN_MAP_INITIAL 64
+#define QUIC_PN_MAP_INCREMENT QUIC_PN_MAP_INITIAL
+#define QUIC_PN_MAP_SIZE 4096
+#define QUIC_PN_MAP_LIMIT (QUIC_PN_MAP_SIZE * 3 / 4)
+
+#define QUIC_PNSPACE_MAX (QUIC_CRYPTO_MAX - 1)
+#define QUIC_PNSPACE_NEXT_PN 0
+#define QUIC_PNSPACE_TIME_LIMIT (333000 * 3)
+
+enum {
+ QUIC_ECN_ECT1,
+ QUIC_ECN_ECT0,
+ QUIC_ECN_CE,
+ QUIC_ECN_MAX
+};
+
+enum {
+ QUIC_ECN_LOCAL, /* ECN bits from incoming IP headers */
+ QUIC_ECN_PEER, /* ECN bits reported by peer in ACK frames */
+ QUIC_ECN_ACKED, /* ECN bits from packets newly ACKed */
+ QUIC_ECN_DIR_MAX
+};
+
+/* Represents a gap (range of missing packets) in the ACK map. The values are
+ * offsets from base_pn, with both 'start' and 'end' being +1.
+ */
+struct quic_gap_ack_block {
+ u16 start;
+ u16 end;
+};
+
+/* Packet Number Map (pn_map) Layout:
+ *
+ * min_pn_seen -->++-----------------------+---------------------+---
+ * base_pn -----^ last_max_pn_seen --^ max_pn_seen --^
+ *
+ * Map Advancement Logic:
+ * - min_pn_seen = last_max_pn_seen;
+ * - base_pn = first zero bit after last_max_pn_seen;
+ * - last_max_pn_seen = max_pn_seen;
+ * - last_max_pn_time = current time;
+ *
+ * Conditions to Advance pn_map:
+ * - (max_pn_time - last_max_pn_time) >= max_time_limit, or
+ * - (max_pn_seen - last_max_pn_seen) > QUIC_PN_MAP_LIMIT
+ *
+ * Gap Search Range:
+ * - From (base_pn - 1) to max_pn_seen
+ */
+struct quic_pnspace {
+ /* ECN counters indexed by dir and ECN codepoint (ECT1, ECT0, CE) */
+ u64 ecn_count[QUIC_ECN_DIR_MAX][QUIC_ECN_MAX];
+ unsigned long *pn_map; /* Received PN bitmap for ACK generation */
+ u16 pn_map_len; /* Length of the PN bit map (in bits) */
+ u8 need_sack; /* Flag indicating a SACK frame should be sent */
+ u8 sack_path; /* Path used for sending the SACK frame */
+ u8 sack_pending; /* Delayed ACK pending */
+
+ s64 last_max_pn_seen; /* Largest PN seen before pn_map advance */
+ u64 last_max_pn_time; /* Timestamp last_max_pn_seen was received */
+ s64 min_pn_seen; /* Smallest PN received */
+ s64 max_pn_seen; /* Largest PN received */
+ u64 max_pn_time; /* Timestamp max_pn_seen was received */
+ s64 base_pn; /* PN corresponding to the start of the pn_map */
+ u64 time; /* Cached now, or latest socket accept timestamp */
+
+ s64 max_pn_acked_seen; /* Largest PN ACKed by peer */
+ u64 max_pn_acked_time; /* Timestamp max_pn_acked_seen was ACKed */
+ u64 last_sent_time; /* Timestamp last ack-eliciting packet sent */
+ u64 loss_time; /* Timestamp the packet can be declared lost */
+ s64 next_pn; /* Next PN to send */
+
+ u32 max_time_limit; /* Time threshold to trigger pn_map advance */
+ u32 inflight; /* Ack-eliciting bytes in flight */
+};
+
+static inline void
+quic_pnspace_set_max_pn_acked_seen(struct quic_pnspace *space,
+ s64 max_pn_acked_seen)
+{
+ if (space->max_pn_acked_seen >= max_pn_acked_seen)
+ return;
+ space->max_pn_acked_seen = max_pn_acked_seen;
+ space->max_pn_acked_time = quic_ktime_get_us();
+}
+
+static inline void quic_pnspace_set_base_pn(struct quic_pnspace *space, s64 pn)
+{
+ space->base_pn = pn;
+ space->max_pn_seen = space->base_pn - 1;
+ space->last_max_pn_seen = space->max_pn_seen;
+ space->min_pn_seen = space->max_pn_seen;
+
+ space->max_pn_time = space->time;
+ space->last_max_pn_time = space->max_pn_time;
+}
+
+static inline bool quic_pnspace_has_gap(const struct quic_pnspace *space)
+{
+ return space->base_pn != space->max_pn_seen + 1;
+}
+
+static inline void quic_pnspace_inc_ecn_acked(struct quic_pnspace *space,
+ u8 ecn)
+{
+ if (!ecn)
+ return;
+ space->ecn_count[QUIC_ECN_ACKED][ecn - 1]++;
+}
+
+static inline void quic_pnspace_reset_ecn_acked(struct quic_pnspace *space)
+{
+ space->ecn_count[QUIC_ECN_ACKED][QUIC_ECN_ECT0] = 0;
+ space->ecn_count[QUIC_ECN_ACKED][QUIC_ECN_ECT1] = 0;
+ space->ecn_count[QUIC_ECN_ACKED][QUIC_ECN_CE] = 0;
+}
+
+static inline void quic_pnspace_inc_ecn_local(struct quic_pnspace *space,
+ u8 ecn)
+{
+ if (!ecn)
+ return;
+ space->ecn_count[QUIC_ECN_LOCAL][ecn - 1]++;
+}
+
+/* Check if any ECN-marked packets were received. */
+static inline bool quic_pnspace_has_ecn_local(struct quic_pnspace *space)
+{
+ return space->ecn_count[QUIC_ECN_LOCAL][QUIC_ECN_ECT0] ||
+ space->ecn_count[QUIC_ECN_LOCAL][QUIC_ECN_ECT1] ||
+ space->ecn_count[QUIC_ECN_LOCAL][QUIC_ECN_CE];
+}
+
+/* Validate ECN counts received in an ACK. */
+static inline bool quic_pnspace_validate_ecn(struct quic_pnspace *space,
+ u64 *ecn_count)
+{
+ u64 *acked = space->ecn_count[QUIC_ECN_ACKED];
+ u64 *peer = space->ecn_count[QUIC_ECN_PEER];
+ u64 ect0, ect1, ce;
+
+ if (peer[QUIC_ECN_ECT0] > ecn_count[QUIC_ECN_ECT0] ||
+ peer[QUIC_ECN_ECT1] > ecn_count[QUIC_ECN_ECT1] ||
+ peer[QUIC_ECN_CE] > ecn_count[QUIC_ECN_CE])
+ return false;
+
+ /* rfc9000#section-13.4.2.1:
+ *
+ * ECN validation also fails if the sum of the increase in ECT(0) and
+ * ECN-CE counts is less than the number of newly acknowledged packets
+ * that were originally sent with an ECT(0) marking (Same for ECT(1)).
+ */
+ ect0 = ecn_count[QUIC_ECN_ECT0] - peer[QUIC_ECN_ECT0];
+ ect1 = ecn_count[QUIC_ECN_ECT1] - peer[QUIC_ECN_ECT1];
+ ce = ecn_count[QUIC_ECN_CE] - peer[QUIC_ECN_CE];
+
+ return ect0 + ce >= acked[QUIC_ECN_ECT0] &&
+ ect1 + ce >= acked[QUIC_ECN_ECT1];
+}
+
+/* Updates the stored ECN counters based on values received in the peer's ACK
+ * frame. Each counter is updated only if the new value is higher.
+ *
+ * Returns: true if CE count was increased (congestion indicated), false
+ * otherwise.
+ */
+static inline bool quic_pnspace_set_ecn_peer(struct quic_pnspace *space,
+ u64 *ecn_count)
+{
+ u64 *count = space->ecn_count[QUIC_ECN_PEER];
+
+ if (count[QUIC_ECN_ECT0] < ecn_count[QUIC_ECN_ECT0])
+ count[QUIC_ECN_ECT0] = ecn_count[QUIC_ECN_ECT0];
+ if (count[QUIC_ECN_ECT1] < ecn_count[QUIC_ECN_ECT1])
+ count[QUIC_ECN_ECT1] = ecn_count[QUIC_ECN_ECT1];
+ if (count[QUIC_ECN_CE] < ecn_count[QUIC_ECN_CE]) {
+ count[QUIC_ECN_CE] = ecn_count[QUIC_ECN_CE];
+ return true;
+ }
+ return false;
+}
+
+u16 quic_pnspace_num_gabs(struct quic_pnspace *space,
+ struct quic_gap_ack_block *gabs);
+int quic_pnspace_check(struct quic_pnspace *space, s64 pn);
+int quic_pnspace_mark(struct quic_pnspace *space, s64 pn, gfp_t gfp);
+
+void quic_pnspace_free(struct quic_pnspace *space);
+int quic_pnspace_init(struct quic_pnspace *space);
diff --git a/net/quic/socket.c b/net/quic/socket.c
index 0d4a1a4364c4..860491679f72 100644
--- a/net/quic/socket.c
+++ b/net/quic/socket.c
@@ -42,6 +42,8 @@ static void quic_write_space(struct sock *sk)
static int quic_init_sock(struct sock *sk)
{
+ u8 i;
+
sk->sk_write_space = quic_write_space;
sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
@@ -57,11 +59,21 @@ static int quic_init_sock(struct sock *sk)
if (quic_stream_init(quic_streams(sk)))
return -ENOMEM;
+ for (i = 0; i < QUIC_PNSPACE_MAX; i++) {
+ if (quic_pnspace_init(quic_pnspace(sk, i)))
+ return -ENOMEM;
+ }
+
return 0;
}
static void quic_destroy_sock(struct sock *sk)
{
+ u8 i;
+
+ for (i = 0; i < QUIC_PNSPACE_MAX; i++)
+ quic_pnspace_free(quic_pnspace(sk, i));
+
quic_path_unbind(sk, quic_paths(sk), 0);
quic_path_unbind(sk, quic_paths(sk), 1);
diff --git a/net/quic/socket.h b/net/quic/socket.h
index 9201ca3edad0..68c7b22d1e88 100644
--- a/net/quic/socket.h
+++ b/net/quic/socket.h
@@ -12,6 +12,7 @@
#include <linux/quic.h>
#include "common.h"
+#include "pnspace.h"
#include "family.h"
#include "stream.h"
#include "connid.h"
@@ -43,6 +44,7 @@ struct quic_sock {
struct quic_conn_id_set dest;
struct quic_path_group paths;
struct quic_cong cong;
+ struct quic_pnspace space[QUIC_PNSPACE_MAX];
};
struct quic6_sock {
@@ -105,6 +107,11 @@ static inline struct quic_cong *quic_cong(const struct sock *sk)
return &quic_sk(sk)->cong;
}
+static inline struct quic_pnspace *quic_pnspace(const struct sock *sk, u8 level)
+{
+ return &quic_sk(sk)->space[level % QUIC_CRYPTO_EARLY];
+}
+
static inline bool quic_is_establishing(struct sock *sk)
{
return sk->sk_state == QUIC_SS_ESTABLISHING;
--
2.47.1
^ permalink raw reply related [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-09-15 19:50 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-09-15 19:50 [PATCH net-next v15 10/15] quic: add packet number space netdev-bot+sashiko
-- strict thread matches above, loose matches on Subject: below --
2026-09-14 13:49 [PATCH net-next v15 00/15] net: introduce QUIC infrastructure and core subcomponents Xin Long
2026-09-14 13:49 ` [PATCH net-next v15 10/15] quic: add packet number space Xin Long
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.