BPF local storage for every packet
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps with BPF_F_CLONE set can survive packet cloning. Other flags could allow map contents to survive sk_buff scrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one for bpf_local_storage_elem, and one for bpf_local_storage itself.
We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overhead has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming down bpf_local_storage so it can be embedded as an skb extension chunk,
- making the bpf_local_storage cache size configurable,
- allowing bpf_local_storage to be pre-allocated,
- co-allocating bpf_local_storage and bpf_local_storage_elem for the single-map case.
Thanks,
-jkbs
[1] https://fosdem.org/2026/schedule/event/DSC9L3-rich-packet-metadata/
[2] Assuming sufficient free headroom in the skb linear buffer.
[3] http://msgid.link/[email protected]
Martin KaFai Lau
reviewerQuoted 34 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps with
BPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself.We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overhead has been a concern as well [2].
Quoted 7 lines
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
- making thebpf_local_storagecache size configurable,
- allowingbpf_local_storageto be pre-allocated,
- co-allocatingbpf_local_storageandbpf_local_storage_elemfor the single-map case.
The sk/cgroup/task storage has a much longer lifetime. Meaning once allocation is done, the storage stays in the sk until the sk is closed. The length of lifetime is quite different from the skb. I am afraid we are re-purposing bpf_local_storage for a very different use case where skb lifecycle is much shorter.
We are planning to increase the 'sizeof(struct sock)' for perf reason. Saving an allocation is an upside but not the major one we are looking (or care) for sk. We are more looking for cacheline efficiency and probably remove the need for bpf_local_storage[_elem] if the user chooses to use the in-place spaces of a sk.
If 'sizeof(struct sk_buff)' can be increased, this should align on where sk local storage is going. If skb will solely depend on the existing bpf_local_storage and has no plan to raise sizeof(struct sk_buff) for perf purpose, the existing bpf_local_storage may be the wrong place to repurpose/optimize because the lifecycle of skb is very different.
Quoted 4 lines
[1] https://fosdem.org/2026/schedule/event/DSC9L3-rich-packet-metadata/
[2] Assuming sufficient free headroom in the skb linear buffer.
[3] http://msgid.link/[email protected]
Quoted 47 lines · Martin KaFai Lau
Quoted 25 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps withBPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself. We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overheadQuoted 8 lines
has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
- making thebpf_local_storagecache size configurable,
- allowingbpf_local_storageto be pre-allocated,
- co-allocatingbpf_local_storageandbpf_local_storage_elemfor the single-map case.The sk/cgroup/task storage has a much longer lifetime. Meaning once allocation is done, the storage stays in the sk until the sk is closed. The length of lifetime is quite different from the skb. I am afraid we are re-purposing
bpf_local_storagefor a very different use case where skb lifecycle is much shorter.We are planning to increase the 'sizeof(struct sock)' for perf reason. Saving an allocation is an upside but not the major one we are looking (or care) for sk. We are more looking for cacheline efficiency and probably remove the need for bpf_local_storage[_elem] if the user chooses to use the in-place spaces of a sk.
Quoted 5 lines
If '
sizeof(struct sk_buff)' can be increased, this should align on where sk local storage is going. If skb will solely depend on the existingbpf_local_storageand has no plan to raisesizeof(struct sk_buff)for perf purpose, the existingbpf_local_storagemay be the wrong place to repurpose/optimize because the lifecycle of skb is very different.
The lifetime difference is undeniable, but I still see common ground. To make it more concrete:
1. IIRC you've mentioned wanting more bpf_local_storage->cache entries for socks in some scenarios, while for skbs I'd expect we need fewer. We could make the cache size configurable via a flexible array.
2. Embedding bpf_local_storage is another overlap I had in mind. For socks that in within the same memory blob as struct sock, while for skbs we'd want to embed it in skb_ext (once it's small enough). This depends on whether you end up dropping bpf_local_storage for sk_local_storage entirely, which I didn't know about until now.
3. I've heard the idea of allocating skb_ext memory together with sk_buff was floated in the past. While trimming skb_ext at build-time is hard today — say I need XFRM but don't care about crypto offloads keeping state in skb_ext — the idea is similar to what you're proposing for struct sock.
Thanks,
-jkbs
Martin KaFai Lau
reviewerQuoted 62 lines · Jakub Sitnicki
Quoted 47 lines · Martin KaFai Lau
Quoted 25 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps withBPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself. We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overheadQuoted 8 lines
has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
- making thebpf_local_storagecache size configurable,
- allowingbpf_local_storageto be pre-allocated,
- co-allocatingbpf_local_storageandbpf_local_storage_elemfor the single-map case.The sk/cgroup/task storage has a much longer lifetime. Meaning once allocation is done, the storage stays in the sk until the sk is closed. The length of lifetime is quite different from the skb. I am afraid we are re-purposing
bpf_local_storagefor a very different use case where skb lifecycle is much shorter.We are planning to increase the 'sizeof(struct sock)' for perf reason. Saving an allocation is an upside but not the major one we are looking (or care) for sk. We are more looking for cacheline efficiency and probably remove the need for bpf_local_storage[_elem] if the user chooses to use the in-place spaces of a sk.
Quoted 5 lines
If '
sizeof(struct sk_buff)' can be increased, this should align on where sk local storage is going. If skb will solely depend on the existingbpf_local_storageand has no plan to raisesizeof(struct sk_buff)for perf purpose, the existingbpf_local_storagemay be the wrong place to repurpose/optimize because the lifecycle of skb is very different.The lifetime difference is undeniable, but I still see common ground. To make it more concrete:
1. IIRC you've mentioned wanting more
bpf_local_storage->cacheentries for socks in some scenarios, while for skbs I'd expect we need fewer. We could make the cache size configurable via a flexible array.
Quoted 5 lines
2. Embedding
bpf_local_storageis another overlap I had in mind. For socks that in within the same memory blob as struct sock, while for skbs we'd want to embed it inskb_ext(once it's small enough). This depends on whether you end up droppingbpf_local_storageforsk_local_storageentirely, which I didn't know about until now.
For the in-place sk storage, it should not need the bpf_local_storage and the bpf_local_storage_elem. A stable map_xyz->sk_offset should be enough. If a storage is needed for all sk, the bpf prog should use the in-place sk storage instead of going through the bpf_local_storage[_elem].
imo, if we manage to pull out a new solution (whatever that is) for skb but does not perform close to the skb->data_meta, it is probably hard to use in production. I could be wrong but I don't see how embedding local_storage and/or shrink the cache can get there. I think we need another solution/design.
Quoted 6 lines
3. I've heard the idea of allocating
skb_extmemory together withsk_buffwas floated in the past. While trimmingskb_extat build-time is hard today — say I need XFRM but don't care about crypto offloads keeping state inskb_ext— the idea is similar to what you're proposing for struct sock.
Quoted 66 lines · Martin KaFai Lau
Quoted 53 lines · Jakub Sitnicki
Quoted 47 lines · Martin KaFai Lau
Quoted 25 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps withBPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself. We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overheadQuoted 8 lines
has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
- making thebpf_local_storagecache size configurable,
- allowingbpf_local_storageto be pre-allocated,
- co-allocatingbpf_local_storageandbpf_local_storage_elemfor the single-map case.The sk/cgroup/task storage has a much longer lifetime. Meaning once allocation is done, the storage stays in the sk until the sk is closed. The length of lifetime is quite different from the skb. I am afraid we are re-purposing
bpf_local_storagefor a very different use case where skb lifecycle is much shorter.We are planning to increase the 'sizeof(struct sock)' for perf reason. Saving an allocation is an upside but not the major one we are looking (or care) for sk. We are more looking for cacheline efficiency and probably remove the need for bpf_local_storage[_elem] if the user chooses to use the in-place spaces of a sk.
Quoted 5 lines
If '
sizeof(struct sk_buff)' can be increased, this should align on where sk local storage is going. If skb will solely depend on the existingbpf_local_storageand has no plan to raisesizeof(struct sk_buff)for perf purpose, the existingbpf_local_storagemay be the wrong place to repurpose/optimize because the lifecycle of skb is very different.Quoted 11 lines
The lifetime difference is undeniable, but I still see common ground. To make it more concrete:
1. IIRC you've mentioned wanting morebpf_local_storage->cacheentries for socks in some scenarios, while for skbs I'd expect we need fewer. We could make the cache size configurable via a flexible array.
2. Embeddingbpf_local_storageis another overlap I had in mind. For socks that in within the same memory blob as struct sock, while for skbs we'd want to embed it inskb_ext(once it's small enough). This depends on whether you end up droppingbpf_local_storageforsk_local_storageentirely, which I didn't know about until now.
Quoted 4 lines
For the in-place sk storage, it should not need the
bpf_local_storageand thebpf_local_storage_elem. A stablemap_xyz->sk_offsetshould be enough. If a storage is needed for all sk, the bpf prog should use the in-place sk storage instead of going through the bpf_local_storage[_elem].
Call me overly optimistic, but if we can pull it off for sk storage, then what stops us from transplanting this pattern to skb_ext and skb storage?
Quoted 4 lines
imo, if we manage to pull out a new solution (whatever that is) for skb but does not perform close to the
skb->data_meta, it is probably hard to use in production. I could be wrong but I don't see how embeddinglocal_storageand/or shrink the cache can get there. I think we need another solution/design.
skb->data_meta is allocation free. That would be the ultimate goal.
I could see that happening is if we allocate space for skb_ext together with sk_buff and embed map storage within the skb_ext chunk.
Apart from the long term goal, I still see value in a naive BPF local storage implementation, like we have in sock/task/..., today because:
1. skb local storage would be available only after GRO, so we're dealing lower pps rate than XDP.
2. If you have use cases, like we do, when you want to attach metadata only to the first packet of the L4 connection, then the skb local storage allocation rate is the same as your established socket allocation rate. And we know BPF local storage is good enough for that.
3. There's feature gap. skb->data_meta doesn't survive past TC. Paying an allocation cost - user decides if its worth the price - is better than nothing.
Quoted 30 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps with
BPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requires no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself.
Quoted 7 lines
We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overhead has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
Interested in this topic. I hope to join this meeting.
Zhu Yanjun
Quoted 11 lines
- making the
bpf_local_storagecache size configurable,
- allowingbpf_local_storageto be pre-allocated,
- co-allocatingbpf_local_storageandbpf_local_storage_elemfor the single-map case.Thanks,
-jkbs[1] https://fosdem.org/2026/schedule/event/DSC9L3-rich-packet-metadata/
[2] Assuming sufficient free headroom in the skb linear buffer.
[3] http://msgid.link/[email protected]
Quoted 31 lines · Zhu Yanjun
Quoted 21 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps withBPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requiresQuoted 8 lines
no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself. We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overhead has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,
Quoted 1 line
Interested in this topic. I hope to join this meeting.
Thanks for the interest. I've since posted the RFC for that [1] and the topic is, at least partially, no longer relevant. We won't be adding new users of BPF local storage [2].
I've proposed to the PC that we can change it to:
1) How to make regular BPF maps work as a stash-away storage for skb metadata. I've highlighted my initial concerns [3] and will give it a try to get hands-on experience with this approach.
2) Or if we decide to go with a secondary skb metadata embedded in the skb_ext - which is another direction I wanted to explore, then we could discuss how to optimize skb_ext (this overlaps with the original proposal).
Thanks,
-jkbs
[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CAADnVQKVfyh3_OZshvYf7GJUF-ph2eMfmaQsxNgwBJd1AJgXTQ@mail.gmail.com/
[3] https://lore.kernel.org/all/[email protected]/
Quoted 38 lines · Jakub Sitnicki
Quoted 30 lines · Zhu Yanjun
Quoted 21 lines · Jakub Sitnicki
In the upcoming days we are going to post an RFC which proposes to extend the concept of BPF local storage to socket buffers (
sk_buff, skb) as means to attach arbitrary metadata to packets from BPF programs [1] (slides 41-55).
Design wise, BPF local storage is a great fit for a packet metadata container, as it that avoids some of the shortcoming of the the XDP metadata interface:
1. Users interact with storage through BPF maps and can take advantage of existing built-in BPF map types, while still being able to implement a custom data format,
2. Maps within local storage can have different properties controlled by map flags. For example, maps withBPF_F_CLONEset can survive packet cloning. Other flags could allow map contents to survivesk_buffscrubbing during encapsulation/decapsulation or pass across network namespace boundaries.
3. Local storage supports multiple users out of the box - each user creates their own map, eliminating the need to coordinate data layout,
4. Local storage has its own backing memory, so persisting it across network stack layers requires no changes to the network stack.
However, this flexibility comes at a cost. While XDP metadata requiresQuoted 8 lines
no allocations [2], an initial write to BPF local storage requires two:
one forbpf_local_storage_elem, and one forbpf_local_storageitself. We would like to align this work with the needs of other BPF local storage users (socks, cgroups, tasks, inodes), where allocation overhead has been a concern as well [2].
Optimization ideas we would like to put up for discussion:
- slimming downbpf_local_storageso it can be embedded as an skb extension chunk,Quoted 1 line
Interested in this topic. I hope to join this meeting.
Thanks for the interest. I've since posted the RFC for that [1] and the topic is, at least partially, no longer relevant. We won't be adding new users of BPF local storage [2].
I've proposed to the PC that we can change it to:
Quoted 8 lines
1) How to make regular BPF maps work as a stash-away storage for skb metadata. I've highlighted my initial concerns [3] and will give it a try to get hands-on experience with this approach.
2) Or if we decide to go with a secondary skb metadata embedded in the
skb_ext- which is another direction I wanted to explore, then we could discuss how to optimizeskb_ext(this overlaps with the original proposal).
Thanks a lot. I’m very interested in this topic and was wondering whether it is on the agenda for the LSF meeting.
Zhu Yanjun
Quoted 7 lines
Thanks,
-jkbs[1] https://lore.kernel.org/all/[email protected]/
[2] https://lore.kernel.org/all/CAADnVQKVfyh3_OZshvYf7GJUF-ph2eMfmaQsxNgwBJd1AJgXTQ@mail.gmail.com/
[3] https://lore.kernel.org/all/[email protected]/
Signature · 2 lines
Best Regards, Yanjun.Zhu