Skip to contentSkip to conversation

BPF local storage for every packet

LSF/MM/BPF TOPIC Jakub Sitnicki 3 participants 8 messages Feb 20 – Mar 16 BPF

lore
Share & tools
lore
#0 lore raw

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]

#1 lore raw
Quoted 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_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].

Quoted 7 lines

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.

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]

#2 lore raw
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 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

Quoted 8 lines

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.

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.

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 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.

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

#3 lore raw
Quoted 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 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

Quoted 8 lines

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.

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.

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 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.

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.

Quoted 5 lines

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.

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_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.

#4 lore raw
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 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

Quoted 8 lines

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.

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.

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 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 11 lines

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.

Quoted 4 lines

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].

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 embedding local_storage and/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.

#5 lore raw
In reply to Jakub Sitnicki
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_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.

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 down bpf_local_storage so 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_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]

#6 lore raw
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 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

Quoted 8 lines

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,

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]/

#7 lore raw
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 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

Quoted 8 lines

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,

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 optimize skb_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