Dynptr convenience helpers
Subsystems (4)
cover Dynptr convenience helpers
This patchset is the 3rd in the dynptr series. The 1st can be found here [0] and the 2nd can be found here [1].
In this patchset, the following convenience helpers are added for interacting with bpf dynamic pointers:
* bpf_dynptr_data_rdonly
* bpf_dynptr_trim
* bpf_dynptr_advance
* bpf_dynptr_is_null
* bpf_dynptr_is_rdonly
* bpf_dynptr_get_size
* bpf_dynptr_get_offset
* bpf_dynptr_clone
* bpf_dynptr_iterator
[0] https://lore.kernel.org/bpf/[email protected]/
[1] https://lore.kernel.org/bpf/[email protected]/
Joanne Koong (8):
bpf: Add bpf_dynptr_data_rdonly
bpf: Add bpf_dynptr_trim and bpf_dynptr_advance
bpf: Add bpf_dynptr_is_null and bpf_dynptr_is_rdonly
bpf: Add bpf_dynptr_get_size and bpf_dynptr_get_offset
bpf: Add bpf_dynptr_clone
bpf: Add verifier support for custom callback return range
bpf: Add bpf_dynptr_iterator
selftests/bpf: Tests for dynptr convenience helpers
include/linux/bpf_verifier.h | 1 + include/uapi/linux/bpf.h | 120 ++++ kernel/bpf/helpers.c | 231 +++++++- kernel/bpf/verifier.c | 155 +++-- scripts/bpf_doc.py | 3 + tools/include/uapi/linux/bpf.h | 120 ++++ .../testing/selftests/bpf/prog_tests/dynptr.c | 30 + .../testing/selftests/bpf/progs/dynptr_fail.c | 462 +++++++++++++++ .../selftests/bpf/progs/dynptr_success.c | 551 +++++++++++++++++- 9 files changed, 1617 insertions(+), 56 deletions(-)
Signature · 1 line
2.30.2
PATCH 1/8 bpf: Add bpf_dynptr_data_rdonly
Add a new helper bpf_dynptr_data_rdonly
void *bpf_dynptr_data_rdonly(struct bpf_dynptr *ptr, u32 offset, u32 len);
which gets a read-only pointer to the underlying dynptr data.
This is equivalent to bpf_dynptr_data(), except the pointer returned is read-only, which allows this to support both read-write and read-only dynptrs.
One example where this will be useful is for skb dynptrs where the program type only allows read-only access to packet data. This API will provide a way to obtain a data slice that can be used for direct reads.
--- include/uapi/linux/bpf.h | 15 +++++++++++++++ kernel/bpf/helpers.c | 32 ++++++++++++++++++++++++++------ kernel/bpf/verifier.c | 7 +++++-- tools/include/uapi/linux/bpf.h | 15 +++++++++++++++ 4 files changed, 61 insertions(+), 8 deletions(-)
include/uapi/linux/bpf.h +15 -0
@@ -5439,6 +5439,20 @@ union bpf_attr {* *flags* is currently unused, it must be 0 for now. * Return * 0 on success, -EINVAL if flags is not 0. +* +* void *bpf_dynptr_data_rdonly(struct bpf_dynptr *ptr, u32 offset, u32 len) +* Description +* Get a read-only pointer to the underlying dynptr data. +* +* This is equivalent to **bpf_dynptr_data**\ () except the +* pointer returned is read-only, which allows this to support +* both read-write and read-only dynptrs. For more details on using +* the API, please refer to **bpf_dynptr_data**\ (). +* Return +* Read-only pointer to the underlying dynptr data, NULL if the +* dynptr is invalid or if the offset and length is out of bounds +* or in a paged buffer for skb-type dynptrs or across fragments +* for xdp-type dynptrs. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5652,6 +5666,7 @@ union bpf_attr {FN (ktime_get_tai_ns), \FN (dynptr_from_skb), \FN (dynptr_from_xdp), \ +FN (dynptr_data_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +26 -6
@@ -1572,7 +1572,7 @@ static const struct bpf_func_proto bpf_dynptr_write_proto = { .arg5_type = ARG_ANYTHING, }; -BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len) +void *__bpf_dynptr_data (struct bpf_dynptr_kern *ptr,u32 offset,u32 len,bool writable) {enum bpf_dynptr_type type;void *data;
@@ -1585,7 +1585,7 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, lenif (err)return 0 ; -if (bpf_dynptr_is_rdonly (ptr)) +if (writable &&bpf_dynptr_is_rdonly (ptr))return 0 ; type =bpf_dynptr_get_type (ptr);
@@ -1610,13 +1610,31 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len/* if the requested data in across fragments, then it cannot * be accessed directly - bpf_xdp_pointer will return NULL */ -return (unsigned long )bpf_xdp_pointer (ptr->data, - ptr->offset + offset, len); +return bpf_xdp_pointer (ptr->data, ptr->offset + offset, len);default : -WARN_ONCE (true,"bpf_dynptr_data: unknown dynptr type %d\n" , type); +WARN_ONCE (true,"__bpf_dynptr_data: unknown dynptr type %d\n" , type);return 0 ; } -return (unsigned long )(data + ptr->offset + offset); +return data + ptr->offset + offset; +} + +BPF_CALL_3(bpf_dynptr_data_rdonly, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len) +{ +return (unsigned long )__bpf_dynptr_data (ptr, offset, len, false); +} + +static const struct bpf_func_proto bpf_dynptr_data_rdonly_proto = { + .func = bpf_dynptr_data_rdonly, + .gpl_only = false, + .ret_type =RET_PTR_TO_DYNPTR_MEM_OR_NULL |MEM_RDONLY , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_ANYTHING , + .arg3_type =ARG_CONST_ALLOC_SIZE_OR_ZERO , +}; + +BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len) +{ +return (unsigned long )__bpf_dynptr_data (ptr, offset, len, true); }static const struct bpf_func_proto bpf_dynptr_data_proto = {
@@ -1698,6 +1716,8 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_write_proto;case BPF_FUNC_dynptr_data:return &bpf_dynptr_data_proto; +case BPF_FUNC_dynptr_data_rdonly: +return &bpf_dynptr_data_rdonly_proto;default :break ; }
kernel/bpf/verifier.c +5 -2
@@ -506,7 +506,8 @@ static bool is_ptr_cast_function(enum bpf_func_id func_id)static bool is_dynptr_ref_function (enum bpf_func_id func_id) { -return func_id == BPF_FUNC_dynptr_data; +return func_id == BPF_FUNC_dynptr_data || + func_id == BPF_FUNC_dynptr_data_rdonly; } static bool helper_multiple_ref_obj_use(enum bpf_func_id func_id,
@@ -7398,6 +7399,7 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insn }break ;case BPF_FUNC_dynptr_data: +case BPF_FUNC_dynptr_data_rdonly: {struct bpf_reg_state *reg;
@@ -7495,7 +7497,8 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnmark_reg_known_zero (env, regs,BPF_REG_0 ); regs[BPF_REG_0 ].type =PTR_TO_MEM | ret_flag; regs[BPF_REG_0 ].mem_size = meta.mem_size; -if (func_id == BPF_FUNC_dynptr_data) { +if (func_id == BPF_FUNC_dynptr_data || + func_id == BPF_FUNC_dynptr_data_rdonly) {if (dynptr_type ==BPF_DYNPTR_TYPE_SKB ) regs[BPF_REG_0 ].type |=DYNPTR_TYPE_SKB ;else if (dynptr_type ==BPF_DYNPTR_TYPE_XDP )
tools/include/uapi/linux/bpf.h +15 -0
@@ -5439,6 +5439,20 @@ union bpf_attr {* *flags* is currently unused, it must be 0 for now. * Return * 0 on success, -EINVAL if flags is not 0. +* +* void *bpf_dynptr_data_rdonly(struct bpf_dynptr *ptr, u32 offset, u32 len) +* Description +* Get a read-only pointer to the underlying dynptr data. +* +* This is equivalent to **bpf_dynptr_data**\ () except the +* pointer returned is read-only, which allows this to support +* both read-write and read-only dynptrs. For more details on using +* the API, please refer to **bpf_dynptr_data**\ (). +* Return +* Read-only pointer to the underlying dynptr data, NULL if the +* dynptr is invalid or if the offset and length is out of bounds +* or in a paged buffer for skb-type dynptrs or across fragments +* for xdp-type dynptrs. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5652,6 +5666,7 @@ union bpf_attr {FN (ktime_get_tai_ns), \FN (dynptr_from_skb), \FN (dynptr_from_xdp), \ +FN (dynptr_data_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Song Liu
reviewerRe: [PATCH bpf-next v1 1/8] bpf: Add bpf_dynptr_data_rdonly
Quoted 70 lines · Joanne Koong
Add a new helper
bpf_dynptr_data_rdonlyvoid *bpf_dynptr_data_rdonly(struct
bpf_dynptr*ptr, u32 offset, u32 len);which gets a read-only pointer to the underlying dynptr data.
This is equivalent to
bpf_dynptr_data(), except the pointer returned is read-only, which allows this to support both read-write and read-only dynptrs.One example where this will be useful is for skb dynptrs where the program type only allows read-only access to packet data. This API will provide a way to obtain a data slice that can be used for direct reads.
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 15 +++++++++++++++ kernel/bpf/helpers.c | 32 ++++++++++++++++++++++++++------ kernel/bpf/verifier.c | 7 +++++-- tools/include/uapi/linux/bpf.h | 15 +++++++++++++++ 4 files changed, 61 insertions(+), 8 deletions(-)include/uapi/linux/bpf.h +15
-0@@ -5439,6 +5439,20 @@ union bpf_attr {* *flags* is currently unused, it must be 0 for now. * Return * 0 on success, -EINVAL if flags is not 0. +* +* void *bpf_dynptr_data_rdonly(struct bpf_dynptr *ptr, u32 offset, u32 len) +* Description +* Get a read-only pointer to the underlying dynptr data. +* +* This is equivalent to **bpf_dynptr_data**\ () except the +* pointer returned is read-only, which allows this to support +* both read-write and read-only dynptrs. For more details on using +* the API, please refer to **bpf_dynptr_data**\ (). +* Return +* Read-only pointer to the underlying dynptr data, NULL if the +* dynptr is invalid or if the offset and length is out of bounds +* or in a paged buffer for skb-type dynptrs or across fragments +* for xdp-type dynptrs. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5652,6 +5666,7 @@ union bpf_attr {FN (ktime_get_tai_ns), \FN (dynptr_from_skb), \FN (dynptr_from_xdp), \ +FN (dynptr_data_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +1
-1@@ -1572,7 +1572,7 @@ static const struct bpf_func_proto bpf_dynptr_write_proto = { .arg5_type = ARG_ANYTHING, }; -BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len) +void *__bpf_dynptr_data (struct bpf_dynptr_kern *ptr,u32 offset,u32 len,bool writable) {enum bpf_dynptr_type type;void *data;
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1586
Quoted 2 lines
kernel/bpf/helpers.c +0
-0@@ -1585,7 +1585,7 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, lenif (err)return 0 ;
Let's return NULL for void* type.
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1589
Quoted 4 lines
kernel/bpf/helpers.c +1
-1-if (bpf_dynptr_is_rdonly (ptr)) +if (writable &&bpf_dynptr_is_rdonly (ptr))return 0 ;
ditto
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1615
Quoted 12 lines
kernel/bpf/helpers.c +2
-3type =bpf_dynptr_get_type (ptr);@@ -1610,13 +1610,31 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len/* if the requested data in across fragments, then it cannot * be accessed directly - bpf_xdp_pointer will return NULL */ -return (unsigned long )bpf_xdp_pointer (ptr->data, - ptr->offset + offset, len); +return bpf_xdp_pointer (ptr->data, ptr->offset + offset, len);default : -WARN_ONCE (true,"bpf_dynptr_data: unknown dynptr type %d\n" , type); +WARN_ONCE (true,"__bpf_dynptr_data: unknown dynptr type %d\n" , type);
Let's use __func__ so we don't have to change this again.
WARN_ONCE(true, "%s: unknown dynptr type %d\n", __func__, type);
Thanks,
Song
[...]
Re: [PATCH bpf-next v1 1/8] bpf: Add bpf_dynptr_data_rdonly
Quoted 97 lines · Song Liu
Quoted 70 lines · Joanne Koong
Add a new helper
bpf_dynptr_data_rdonlyvoid *bpf_dynptr_data_rdonly(struct
bpf_dynptr*ptr, u32 offset, u32 len);which gets a read-only pointer to the underlying dynptr data.
This is equivalent to
bpf_dynptr_data(), except the pointer returned is read-only, which allows this to support both read-write and read-only dynptrs.One example where this will be useful is for skb dynptrs where the program type only allows read-only access to packet data. This API will provide a way to obtain a data slice that can be used for direct reads.
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 15 +++++++++++++++ kernel/bpf/helpers.c | 32 ++++++++++++++++++++++++++------ kernel/bpf/verifier.c | 7 +++++-- tools/include/uapi/linux/bpf.h | 15 +++++++++++++++ 4 files changed, 61 insertions(+), 8 deletions(-)include/uapi/linux/bpf.h +15
-0@@ -5439,6 +5439,20 @@ union bpf_attr {* *flags* is currently unused, it must be 0 for now. * Return * 0 on success, -EINVAL if flags is not 0. +* +* void *bpf_dynptr_data_rdonly(struct bpf_dynptr *ptr, u32 offset, u32 len) +* Description +* Get a read-only pointer to the underlying dynptr data. +* +* This is equivalent to **bpf_dynptr_data**\ () except the +* pointer returned is read-only, which allows this to support +* both read-write and read-only dynptrs. For more details on using +* the API, please refer to **bpf_dynptr_data**\ (). +* Return +* Read-only pointer to the underlying dynptr data, NULL if the +* dynptr is invalid or if the offset and length is out of bounds +* or in a paged buffer for skb-type dynptrs or across fragments +* for xdp-type dynptrs. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5652,6 +5666,7 @@ union bpf_attr {FN (ktime_get_tai_ns), \FN (dynptr_from_skb), \FN (dynptr_from_xdp), \ +FN (dynptr_data_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +1
-1@@ -1572,7 +1572,7 @@ static const struct bpf_func_proto bpf_dynptr_write_proto = { .arg5_type = ARG_ANYTHING, }; -BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len) +void *__bpf_dynptr_data (struct bpf_dynptr_kern *ptr,u32 offset,u32 len,bool writable) {enum bpf_dynptr_type type;void *data;kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1586
Quoted 2 lines
kernel/bpf/helpers.c +0
-0@@ -1585,7 +1585,7 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, lenif (err)return 0 ;Let's return NULL for void* type.
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1589
Quoted 4 lines
kernel/bpf/helpers.c +1
-1-if (bpf_dynptr_is_rdonly (ptr)) +if (writable &&bpf_dynptr_is_rdonly (ptr))return 0 ;ditto
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1615
Quoted 12 lines
kernel/bpf/helpers.c +2
-3type =bpf_dynptr_get_type (ptr);@@ -1610,13 +1610,31 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len/* if the requested data in across fragments, then it cannot * be accessed directly - bpf_xdp_pointer will return NULL */ -return (unsigned long )bpf_xdp_pointer (ptr->data, - ptr->offset + offset, len); +return bpf_xdp_pointer (ptr->data, ptr->offset + offset, len);default : -WARN_ONCE (true,"bpf_dynptr_data: unknown dynptr type %d\n" , type); +WARN_ONCE (true,"__bpf_dynptr_data: unknown dynptr type %d\n" , type);Let's use
__func__so we don't have to change this again.
Quoted 1 line
WARN_ONCE(true, "%s: unknown dynptr type %d\n", __func__, type);
WARN includes file and line automatically.
Do we really need func here too?
Song Liu
reviewerRe: [PATCH bpf-next v1 1/8] bpf: Add bpf_dynptr_data_rdonly
Quoted 5 lines · Alexei Starovoitov
Quoted 3 lines · Song Liu
Quoted 1 line · Joanne Koong
[...]
Quoted 23 lines
Quoted 23 lines
Let's return NULL for void* type.
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1589
Quoted 4 lines
kernel/bpf/helpers.c +1
-1-if (bpf_dynptr_is_rdonly (ptr)) +if (writable &&bpf_dynptr_is_rdonly (ptr))return 0 ;ditto
kernel/bpf/helpers.c BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len · line 1615
Quoted 12 lines
type = bpf_dynptr_get_type(ptr);kernel/bpf/helpers.c +2
-3@@ -1610,13 +1610,31 @@ BPF_CALL_3(bpf_dynptr_data, struct bpf_dynptr_kern *, ptr, u32, offset, u32, len/* if the requested data in across fragments, then it cannot * be accessed directly - bpf_xdp_pointer will return NULL */ -return (unsigned long )bpf_xdp_pointer (ptr->data, - ptr->offset + offset, len); +return bpf_xdp_pointer (ptr->data, ptr->offset + offset, len);default : -WARN_ONCE (true,"bpf_dynptr_data: unknown dynptr type %d\n" , type); +WARN_ONCE (true,"__bpf_dynptr_data: unknown dynptr type %d\n" , type);Let's use
__func__so we don't have to change this again.
Quoted 4 lines
Quoted 1 line
WARN_ONCE(true, "%s: unknown dynptr type %d\n", __func__, type);WARN includes file and line automatically.
Do we really need func here too?
I think func is helpful when I read a slightly different version of the code and line number changes. (Well, maybe I shouldn't do this.)
I won't mind if we remove it. We just shouldn't hard code it manually.
Thanks,
Song
Re: [PATCH bpf-next v1 1/8] bpf: Add bpf_dynptr_data_rdonly
In reply to Joanne KoongQuoted 10 lines · On Wed, 7 Sep 2022 17:02:47 -0700 Joanne Koong <[email protected]> wrote:
Add a new helper
bpf_dynptr_data_rdonlyvoid *bpf_dynptr_data_rdonly(struct
bpf_dynptr*ptr, u32 offset, u32 len);which gets a read-only pointer to the underlying dynptr data.
This is equivalent to
bpf_dynptr_data(), except the pointer returned is read-only, which allows this to support both read-write and read-only dynptrs.
Quoted 5 lines
One example where this will be useful is for skb dynptrs where the program type only allows read-only access to packet data. This API will provide a way to obtain a data slice that can be used for direct reads.
Signed-off-by Joanne Koong <[email protected]>
PATCH 2/8 bpf: Add bpf_dynptr_trim and bpf_dynptr_advance
In reply to Joanne KoongAdd two new helper functions: bpf_dynptr_trim and bpf_dynptr_advance.
bpf_dynptr_trim decreases the size of a dynptr by the specified number of bytes (offset remains the same). bpf_dynptr_advance advances the offset of the dynptr by the specified number of bytes (size decreases correspondingly).
One example where trimming / advancing the dynptr may useful is for hashing. If the dynptr points to a larger struct, it is possible to hash an individual field within the struct through dynptrs by using bpf_dynptr_advance+trim.
--- include/uapi/linux/bpf.h | 16 +++++++++ kernel/bpf/helpers.c | 63 ++++++++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 16 +++++++++ 3 files changed, 95 insertions(+)
include/uapi/linux/bpf.h +16 -0
@@ -5453,6 +5453,20 @@ union bpf_attr {* dynptr is invalid or if the offset and length is out of bounds * or in a paged buffer for skb-type dynptrs or across fragments * for xdp-type dynptrs. +* +* long bpf_dynptr_advance(struct bpf_dynptr *ptr, u32 len) +* Description +* Advance a dynptr by *len*. +* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if *len* +* exceeds the bounds of the dynptr. +* +* long bpf_dynptr_trim(struct bpf_dynptr *ptr, u32 len) +* Description +* Trim a dynptr by *len*. +* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if +* trying to trim more bytes than the size of the dynptr. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5667,6 +5681,8 @@ union bpf_attr {FN (dynptr_from_skb), \FN (dynptr_from_xdp), \FN (dynptr_data_rdonly), \ +FN (dynptr_advance), \ +FN (dynptr_trim), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +63 -0
81 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +16 -0
@@ -5453,6 +5453,20 @@ union bpf_attr {* dynptr is invalid or if the offset and length is out of bounds * or in a paged buffer for skb-type dynptrs or across fragments * for xdp-type dynptrs. +* +* long bpf_dynptr_advance(struct bpf_dynptr *ptr, u32 len) +* Description +* Advance a dynptr by *len*. +* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if *len* +* exceeds the bounds of the dynptr. +* +* long bpf_dynptr_trim(struct bpf_dynptr *ptr, u32 len) +* Description +* Trim a dynptr by *len*. +* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if +* trying to trim more bytes than the size of the dynptr. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5667,6 +5681,8 @@ union bpf_attr {FN (dynptr_from_skb), \FN (dynptr_from_xdp), \FN (dynptr_data_rdonly), \ +FN (dynptr_advance), \ +FN (dynptr_trim), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v1 2/8] bpf: Add bpf_dynptr_trim and bpf_dynptr_advance
Quoted 8 lines · Joanne Koong
Add two new helper functions:
bpf_dynptr_trimandbpf_dynptr_advance.
bpf_dynptr_trimdecreases the size of a dynptr by the specified number of bytes (offset remains the same).bpf_dynptr_advanceadvances the offset of the dynptr by the specified number of bytes (size decreases correspondingly).
Quoted 6 lines
One example where trimming / advancing the dynptr may useful is for hashing. If the dynptr points to a larger struct, it is possible to hash an individual field within the struct through dynptrs by using bpf_dynptr_advance+trim.
Signed-off-by Joanne Koong <[email protected]>
Re: [PATCH bpf-next v1 2/8] bpf: Add bpf_dynptr_trim and bpf_dynptr_advance
In reply to Joanne KoongQuoted 7 lines · On Wed, 7 Sep 2022 17:02:48 -0700 Joanne Koong <[email protected]> wrote:
Add two new helper functions:
bpf_dynptr_trimandbpf_dynptr_advance.
bpf_dynptr_trimdecreases the size of a dynptr by the specified number of bytes (offset remains the same).bpf_dynptr_advanceadvances the offset of the dynptr by the specified number of bytes (size decreases correspondingly).
Quoted 6 lines
One example where trimming / advancing the dynptr may useful is for hashing. If the dynptr points to a larger struct, it is possible to hash an individual field within the struct through dynptrs by using bpf_dynptr_advance+trim.
Signed-off-by Joanne Koong <[email protected]>
Re: [PATCH bpf-next v1 2/8] bpf: Add bpf_dynptr_trim and bpf_dynptr_advance
In reply to Joanne KoongQuoted 25 lines · Joanne Koong
Add two new helper functions:
bpf_dynptr_trimandbpf_dynptr_advance.
bpf_dynptr_trimdecreases the size of a dynptr by the specified number of bytes (offset remains the same).bpf_dynptr_advanceadvances the offset of the dynptr by the specified number of bytes (size decreases correspondingly).One example where trimming / advancing the dynptr may useful is for hashing. If the dynptr points to a larger struct, it is possible to hash an individual field within the struct through dynptrs by using bpf_dynptr_advance+trim.
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 16 +++++++++ kernel/bpf/helpers.c | 63 ++++++++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 16 +++++++++ 3 files changed, 95 insertions(+)include/uapi/linux/bpf.h +0
-0
include/uapi/linux/bpf.h union bpf_attr { · line 5459
Quoted 7 lines
include/uapi/linux/bpf.h +4
-0@@ -5453,6 +5453,20 @@ union bpf_attr {* dynptr is invalid or if the offset and length is out of bounds * or in a paged buffer for skb-type dynptrs or across fragments * for xdp-type dynptrs. +* +* long bpf_dynptr_advance(struct bpf_dynptr *ptr, u32 len) +* Description +* Advance a dynptr by *len*.
This might be a bit to succinct a description. "Advance dynptr's internal offset by *len* bytes."?
include/uapi/linux/bpf.h union bpf_attr { · line 5466
Quoted 7 lines
include/uapi/linux/bpf.h +7
-0+* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if *len* +* exceeds the bounds of the dynptr. +* +* long bpf_dynptr_trim(struct bpf_dynptr *ptr, u32 len) +* Description +* Trim a dynptr by *len*.
Similar as above, something like "Reduce the size of memory pointed to by dynptr by *len* without changing offset"?
Quoted 42 lines
include/uapi/linux/bpf.h +5
-0+* Return +* 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if +* trying to trim more bytes than the size of the dynptr. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5667,6 +5681,8 @@ union bpf_attr {FN (dynptr_from_skb), \FN (dynptr_from_xdp), \FN (dynptr_data_rdonly), \ +FN (dynptr_advance), \ +FN (dynptr_trim), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +12
-0@@ -1423,6 +1423,13 @@ static u32 bpf_dynptr_get_size(struct bpf_dynptr_kern *ptr)return ptr->size &DYNPTR_SIZE_MASK ; } +static void bpf_dynptr_set_size (struct bpf_dynptr_kern *ptr,u32 new_size) +{ +u32 metadata = ptr->size & ~DYNPTR_SIZE_MASK ; + + ptr->size = new_size | metadata; +} +int bpf_dynptr_check_size (u32 size) {return size >DYNPTR_MAX_SIZE ? -E2BIG :0 ;@@ -1646,6 +1653,58 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +u32 size; + +if (!ptr->data)
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_data_proto = { · line 1670
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+return -EINVAL ; + + size =bpf_dynptr_get_size (ptr); + +if (len > size) +return -ERANGE ; + + ptr->offset += len; + +bpf_dynptr_set_size (ptr, size - len);
Kind of weird that offset is adjusted directly through field, but size is set through helper.
One idea is to have (internal) helper that *increments* offset and *decrements* size as one step. You can move all the error checking inside it, instead of duplicating. E.g., something like this signature
static int bpf_dynptr_adjust(struct btf_dynptr_kern *ptr, u32 off_inc, u32 sz_dec);
This increment/decrement is a bit surprising, but we don't allow size to grow and offset to decrement, so this makes sense from that point of view.
With that, we'll just do
return bpf_dynptr_adjust(ptr, len, len);
Quoted 15 lines
kernel/bpf/helpers.c +15
-0+ +return 0 ; +} + +static const struct bpf_func_proto bpf_dynptr_advance_proto = { + .func = bpf_dynptr_advance, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_ANYTHING , +}; + +BPF_CALL_2(bpf_dynptr_trim, struct bpf_dynptr_kern *, ptr, u32, len) +{ +u32 size;
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_data_proto = { · line 1695
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+ +if (!ptr->data) +return -EINVAL ; + + size =bpf_dynptr_get_size (ptr); + +if (len > size) +return -ERANGE ; + +bpf_dynptr_set_size (ptr, size - len);
and here we can just do
return bpf_dynptr_adjust(ptr, 0, len);
Quoted 11 lines
kernel/bpf/helpers.c +11
-0+ +return 0 ; +} + +static const struct bpf_func_proto bpf_dynptr_trim_proto = { + .func = bpf_dynptr_trim, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_ANYTHING , +};
[...]
PATCH 3/8 bpf: Add bpf_dynptr_is_null and bpf_dynptr_is_rdonly
In reply to Joanne KoongAdd two new helper functions: bpf_dynptr_is_null and bpf_dynptr_is_rdonly.
bpf_dynptr_is_null returns true if the dynptr is null / invalid (determined by whether ptr->data is NULL), else false if the dynptr is a valid dynptr.
bpf_dynptr_is_rdonly returns true if the dynptr is read-only, else false if the dynptr is read-writable.
--- include/uapi/linux/bpf.h | 20 ++++++++++++++++++ kernel/bpf/helpers.c | 37 +++++++++++++++++++++++++++++++--- scripts/bpf_doc.py | 3 +++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++++++ 4 files changed, 77 insertions(+), 3 deletions(-)
include/uapi/linux/bpf.h +20 -0
@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +34 -3
@@ -1398,7 +1398,7 @@ static const struct bpf_func_proto bpf_kptr_xchg_proto = {#define DYNPTR_SIZE_MASK 0xFFFFFF#define DYNPTR_RDONLY_BIT BIT(31) -static bool bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) +static bool __bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) {return ptr->size &DYNPTR_RDONLY_BIT ; }
@@ -1539,7 +1539,7 @@ BPF_CALL_5(bpf_dynptr_write, struct bpf_dynptr_kern *, dst, u32, offset, void *,enum bpf_dynptr_type type;int err; -if (!dst->data ||bpf_dynptr_is_rdonly (dst)) +if (!dst->data ||__bpf_dynptr_is_rdonly (dst))return -EINVAL ; err =bpf_dynptr_check_off_len (dst, offset, len);
@@ -1592,7 +1592,7 @@ void *__bpf_dynptr_data(struct bpf_dynptr_kern *ptr, u32 offset, u32 len, bool wif (err)return 0 ; -if (writable &&bpf_dynptr_is_rdonly (ptr)) +if (writable &&__bpf_dynptr_is_rdonly (ptr))return 0 ; type =bpf_dynptr_get_type (ptr);
@@ -1705,6 +1705,33 @@ static const struct bpf_func_proto bpf_dynptr_trim_proto = { .arg2_type = ARG_ANYTHING, }; +BPF_CALL_1(bpf_dynptr_is_null, struct bpf_dynptr_kern *, ptr) +{ +return !ptr->data; +} + +static const struct bpf_func_proto bpf_dynptr_is_null_proto = { + .func = bpf_dynptr_is_null, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; + +BPF_CALL_1(bpf_dynptr_is_rdonly, struct bpf_dynptr_kern *, ptr) +{ +if (!ptr->data) +return 0 ; + +return __bpf_dynptr_is_rdonly (ptr); +} + +static const struct bpf_func_proto bpf_dynptr_is_rdonly_proto = { + .func = bpf_dynptr_is_rdonly, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;
@@ -1781,6 +1808,10 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_advance_proto;case BPF_FUNC_dynptr_trim:return &bpf_dynptr_trim_proto; +case BPF_FUNC_dynptr_is_null: +return &bpf_dynptr_is_null_proto; +case BPF_FUNC_dynptr_is_rdonly: +return &bpf_dynptr_is_rdonly_proto;default :break ; }
scripts/bpf_doc.py +3 -0
@@ -691,6 +691,7 @@ class PrinterHelpers(Printer): 'int', 'long', 'unsigned long', + 'bool', '__be16', '__be32',
@@ -761,6 +762,8 @@ class PrinterHelpers(Printer): header = '''\ /* This is auto-generated file. See bpf_doc.py for details. */ +#include <stdbool.h> + /* Forward declarations of BPF structs */''' print(header)
tools/include/uapi/linux/bpf.h +20 -0
@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Song Liu
reviewerRe: [PATCH bpf-next v1 3/8] bpf: Add bpf_dynptr_is_null and bpf_dynptr_is_rdonly
Quoted 10 lines · Joanne Koong
Add two new helper functions:
bpf_dynptr_is_nullandbpf_dynptr_is_rdonly.
bpf_dynptr_is_nullreturns true if the dynptr is null / invalid (determined by whetherptr->datais NULL), else false if the dynptr is a valid dynptr.
bpf_dynptr_is_rdonlyreturns true if the dynptr is read-only, else false if the dynptr is read-writable.
Might be a dump question.. Can we just let the bpf program to access struct bpf_dynptr? Using a helper for this feel like an overkill.
Thanks,
Song
Quoted 185 lines
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++++++ kernel/bpf/helpers.c | 37 +++++++++++++++++++++++++++++++--- scripts/bpf_doc.py | 3 +++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++++++ 4 files changed, 77 insertions(+), 3 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +34
-3@@ -1398,7 +1398,7 @@ static const struct bpf_func_proto bpf_kptr_xchg_proto = {#define DYNPTR_SIZE_MASK 0xFFFFFF#define DYNPTR_RDONLY_BIT BIT(31) -static bool bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) +static bool __bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) {return ptr->size &DYNPTR_RDONLY_BIT ; }@@ -1539,7 +1539,7 @@ BPF_CALL_5(bpf_dynptr_write, struct bpf_dynptr_kern *, dst, u32, offset, void *,enum bpf_dynptr_type type;int err; -if (!dst->data ||bpf_dynptr_is_rdonly (dst)) +if (!dst->data ||__bpf_dynptr_is_rdonly (dst))return -EINVAL ; err =bpf_dynptr_check_off_len (dst, offset, len);@@ -1592,7 +1592,7 @@ void *__bpf_dynptr_data(struct bpf_dynptr_kern *ptr, u32 offset, u32 len, bool wif (err)return 0 ; -if (writable &&bpf_dynptr_is_rdonly (ptr)) +if (writable &&__bpf_dynptr_is_rdonly (ptr))return 0 ; type =bpf_dynptr_get_type (ptr);@@ -1705,6 +1705,33 @@ static const struct bpf_func_proto bpf_dynptr_trim_proto = { .arg2_type = ARG_ANYTHING, }; +BPF_CALL_1(bpf_dynptr_is_null, struct bpf_dynptr_kern *, ptr) +{ +return !ptr->data; +} + +static const struct bpf_func_proto bpf_dynptr_is_null_proto = { + .func = bpf_dynptr_is_null, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; + +BPF_CALL_1(bpf_dynptr_is_rdonly, struct bpf_dynptr_kern *, ptr) +{ +if (!ptr->data) +return 0 ; + +return __bpf_dynptr_is_rdonly (ptr); +} + +static const struct bpf_func_proto bpf_dynptr_is_rdonly_proto = { + .func = bpf_dynptr_is_rdonly, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;@@ -1781,6 +1808,10 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_advance_proto;case BPF_FUNC_dynptr_trim:return &bpf_dynptr_trim_proto; +case BPF_FUNC_dynptr_is_null: +return &bpf_dynptr_is_null_proto; +case BPF_FUNC_dynptr_is_rdonly: +return &bpf_dynptr_is_rdonly_proto;default :break ; }scripts/bpf_doc.py +3
-0@@ -691,6 +691,7 @@ class PrinterHelpers(Printer): 'int', 'long', 'unsigned long', + 'bool', '__be16', '__be32',@@ -761,6 +762,8 @@ class PrinterHelpers(Printer): header = '''\ /* This is auto-generated file. See bpf_doc.py for details. */ +#include <stdbool.h> + /* Forward declarations of BPF structs */''' print(header)tools/include/uapi/linux/bpf.h +20
-1@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper -- 2.30.2
Re: [PATCH bpf-next v1 3/8] bpf: Add bpf_dynptr_is_null and bpf_dynptr_is_rdonly
Quoted 13 lines · Song Liu
Quoted 10 lines · Joanne Koong
Add two new helper functions:
bpf_dynptr_is_nullandbpf_dynptr_is_rdonly.
bpf_dynptr_is_nullreturns true if the dynptr is null / invalid (determined by whetherptr->datais NULL), else false if the dynptr is a valid dynptr.
bpf_dynptr_is_rdonlyreturns true if the dynptr is read-only, else false if the dynptr is read-writable.
Quoted 7 lines
Might be a dump question.. Can we just let the bpf program to access struct
bpf_dynptr? Using a helper for this feel like an overkill.Thanks,
Song
Not a dumb question at all, this is an interesting idea :) Right now the struct bpf_dynptr is opaque from the bpf program side but if we were to expose it (it'd still be read-only in the program), the program could directly get offset and whether it's null, but would need to do some manipulation to determine the size (since the last few bits of 'size' stores the dynptr type and rd-only) and rd-only. I see the advantages of either approach - personally I think it's cleaner if the struct is completely opaque from the program side but I don't feel strongly about it. If the worry is the overhead of needing a helper for each, maybe another idea is to conflate them into 1 general bpf_dynptr_get_info helper that returns offset, size, is_null, and rd-only status?
Quoted 185 lines
Quoted 185 lines
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++++++ kernel/bpf/helpers.c | 37 +++++++++++++++++++++++++++++++--- scripts/bpf_doc.py | 3 +++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++++++ 4 files changed, 77 insertions(+), 3 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +34
-3@@ -1398,7 +1398,7 @@ static const struct bpf_func_proto bpf_kptr_xchg_proto = {#define DYNPTR_SIZE_MASK 0xFFFFFF#define DYNPTR_RDONLY_BIT BIT(31) -static bool bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) +static bool __bpf_dynptr_is_rdonly (struct bpf_dynptr_kern *ptr) {return ptr->size &DYNPTR_RDONLY_BIT ; }@@ -1539,7 +1539,7 @@ BPF_CALL_5(bpf_dynptr_write, struct bpf_dynptr_kern *, dst, u32, offset, void *,enum bpf_dynptr_type type;int err; -if (!dst->data ||bpf_dynptr_is_rdonly (dst)) +if (!dst->data ||__bpf_dynptr_is_rdonly (dst))return -EINVAL ; err =bpf_dynptr_check_off_len (dst, offset, len);@@ -1592,7 +1592,7 @@ void *__bpf_dynptr_data(struct bpf_dynptr_kern *ptr, u32 offset, u32 len, bool wif (err)return 0 ; -if (writable &&bpf_dynptr_is_rdonly (ptr)) +if (writable &&__bpf_dynptr_is_rdonly (ptr))return 0 ; type =bpf_dynptr_get_type (ptr);@@ -1705,6 +1705,33 @@ static const struct bpf_func_proto bpf_dynptr_trim_proto = { .arg2_type = ARG_ANYTHING, }; +BPF_CALL_1(bpf_dynptr_is_null, struct bpf_dynptr_kern *, ptr) +{ +return !ptr->data; +} + +static const struct bpf_func_proto bpf_dynptr_is_null_proto = { + .func = bpf_dynptr_is_null, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; + +BPF_CALL_1(bpf_dynptr_is_rdonly, struct bpf_dynptr_kern *, ptr) +{ +if (!ptr->data) +return 0 ; + +return __bpf_dynptr_is_rdonly (ptr); +} + +static const struct bpf_func_proto bpf_dynptr_is_rdonly_proto = { + .func = bpf_dynptr_is_rdonly, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;@@ -1781,6 +1808,10 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_advance_proto;case BPF_FUNC_dynptr_trim:return &bpf_dynptr_trim_proto; +case BPF_FUNC_dynptr_is_null: +return &bpf_dynptr_is_null_proto; +case BPF_FUNC_dynptr_is_rdonly: +return &bpf_dynptr_is_rdonly_proto;default :break ; }scripts/bpf_doc.py +3
-0@@ -691,6 +691,7 @@ class PrinterHelpers(Printer): 'int', 'long', 'unsigned long', + 'bool', '__be16', '__be32',@@ -761,6 +762,8 @@ class PrinterHelpers(Printer): header = '''\ /* This is auto-generated file. See bpf_doc.py for details. */ +#include <stdbool.h> + /* Forward declarations of BPF structs */''' print(header)tools/include/uapi/linux/bpf.h +20
-1@@ -5467,6 +5467,24 @@ union bpf_attr {* Return * 0 on success, -EINVAL if the dynptr is invalid, -ERANGE if * trying to trim more bytes than the size of the dynptr. +* +* bool bpf_dynptr_is_null(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is null / invalid. +* +* *ptr* must be an initialized dynptr. +* Return +* True if the dynptr is null, else false. +* +* bool bpf_dynptr_is_rdonly(struct bpf_dynptr *ptr) +* Description +* Determine whether a dynptr is read-only. +* +* *ptr* must be an initialized dynptr. If *ptr* +* is a null dynptr, this will return false. +* Return +* True if the dynptr is read-only and a valid dynptr, +* else false. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5683,6 +5701,8 @@ union bpf_attr {FN (dynptr_data_rdonly), \FN (dynptr_advance), \FN (dynptr_trim), \ +FN (dynptr_is_null), \ +FN (dynptr_is_rdonly), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper -- 2.30.2
Song Liu
reviewerRe: [PATCH bpf-next v1 3/8] bpf: Add bpf_dynptr_is_null and bpf_dynptr_is_rdonly
Quoted 23 lines · Joanne Koong
Quoted 13 lines · Song Liu
Quoted 10 lines · Joanne Koong
Add two new helper functions:
bpf_dynptr_is_nullandbpf_dynptr_is_rdonly.
bpf_dynptr_is_nullreturns true if the dynptr is null / invalid (determined by whetherptr->datais NULL), else false if the dynptr is a valid dynptr.
bpf_dynptr_is_rdonlyreturns true if the dynptr is read-only, else false if the dynptr is read-writable.Quoted 7 lines
Might be a dump question.. Can we just let the bpf program to access struct
bpf_dynptr? Using a helper for this feel like an overkill.Thanks,
Song
Quoted 12 lines
Not a dumb question at all, this is an interesting idea :) Right now the struct
bpf_dynptris opaque from the bpf program side but if we were to expose it (it'd still be read-only in the program), the program could directly get offset and whether it's null, but would need to do some manipulation to determine the size (since the last few bits of 'size' stores the dynptr type and rd-only) and rd-only. I see the advantages of either approach - personally I think it's cleaner if the struct is completely opaque from the program side but I don't feel strongly about it. If the worry is the overhead of needing a helper for each, maybe another idea is to conflate them into 1 generalbpf_dynptr_get_infohelper that returns offset, size,is_null, and rd-only status?
While all the helpers are fast direct calls, I think they are still slower than simple memory accesses. It is probably a good idea to benchmark the difference. While we can inline the helper functions in the verifier, it is cleaner if we simply expose the data?
Thanks,
Song
PATCH 4/8 bpf: Add bpf_dynptr_get_size and bpf_dynptr_get_offset
In reply to Joanne KoongAdd two new helper functions: bpf_dynptr_get_size and bpf_dynptr_get_offset.
bpf_dynptr_get_size returns the number of usable bytes in a dynptr and bpf_dynptr_get_offset returns the current offset into the dynptr.
--- include/uapi/linux/bpf.h | 25 ++++++++++++++++++++ kernel/bpf/helpers.c | 42 ++++++++++++++++++++++++++++++---- tools/include/uapi/linux/bpf.h | 25 ++++++++++++++++++++ 3 files changed, 88 insertions(+), 4 deletions(-)
include/uapi/linux/bpf.h +25 -0
@@ -5485,6 +5485,29 @@ union bpf_attr {* Return * True if the dynptr is read-only and a valid dynptr, * else false. +* +* long bpf_dynptr_get_size(struct bpf_dynptr *ptr) +* Description +* Get the size of *ptr*. +* +* Size refers to the number of usable bytes. For example, +* if *ptr* was initialized with 100 bytes and its +* offset was advanced by 40 bytes, then the size will be +* 60 bytes. +* +* *ptr* must be an initialized dynptr. +* Return +* The size of the dynptr on success, -EINVAL if the dynptr is +* invalid. +* +* long bpf_dynptr_get_offset(struct bpf_dynptr *ptr) +* Description +* Get the offset of the dynptr. +* +* *ptr* must be an initialized dynptr. +* Return +* The offset of the dynptr on success, -EINVAL if the dynptr is +* invalid. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5703,6 +5726,8 @@ union bpf_attr {FN (dynptr_trim), \FN (dynptr_is_null), \FN (dynptr_is_rdonly), \ +FN (dynptr_get_size), \ +FN (dynptr_get_offset), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +38 -4
78 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +25 -0
@@ -5485,6 +5485,29 @@ union bpf_attr {* Return * True if the dynptr is read-only and a valid dynptr, * else false. +* +* long bpf_dynptr_get_size(struct bpf_dynptr *ptr) +* Description +* Get the size of *ptr*. +* +* Size refers to the number of usable bytes. For example, +* if *ptr* was initialized with 100 bytes and its +* offset was advanced by 40 bytes, then the size will be +* 60 bytes. +* +* *ptr* must be an initialized dynptr. +* Return +* The size of the dynptr on success, -EINVAL if the dynptr is +* invalid. +* +* long bpf_dynptr_get_offset(struct bpf_dynptr *ptr) +* Description +* Get the offset of the dynptr. +* +* *ptr* must be an initialized dynptr. +* Return +* The offset of the dynptr on success, -EINVAL if the dynptr is +* invalid. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5703,6 +5726,8 @@ union bpf_attr {FN (dynptr_trim), \FN (dynptr_is_null), \FN (dynptr_is_rdonly), \ +FN (dynptr_get_size), \ +FN (dynptr_get_offset), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v1 4/8] bpf: Add bpf_dynptr_get_size and bpf_dynptr_get_offset
Quoted 4 lines · On Wed, 7 Sep 2022 17:02:50 -0700 Joanne Koong <[email protected]> wrote:
+ * long
bpf_dynptr_get_offset(struct bpf_dynptr *ptr)
+ * Description
+ * Get the offset of the dynptr.
+ *
The offset is an internal thing of the dynptr.
The user may initialize the dynptr and "advance" it using APIs.
Why do we need to expose the internal offset to the ebpf user?
Re: [PATCH bpf-next v1 4/8] bpf: Add bpf_dynptr_get_size and bpf_dynptr_get_offset
Quoted 8 lines · Shmulik Ladkani
Quoted 4 lines · On Wed, 7 Sep 2022 17:02:50 -0700 Joanne Koong <[email protected]> wrote:
+ * long
bpf_dynptr_get_offset(struct bpf_dynptr *ptr)
+ * Description
+ * Get the offset of the dynptr.
+ *
Quoted 5 lines
The offset is an internal thing of the dynptr.
The user may initialize the dynptr and "advance" it using APIs.
Why do we need to expose the internal offset to the ebpf user?
There might be use cases where knowing the offset is helpful (for example, when packet parsing, a user may want to know how far they are from the start of the packet)
PATCH 5/8 bpf: Add bpf_dynptr_clone
In reply to Joanne KoongAdd a new helper, bpf_dynptr_clone, which clones a dynptr.
The cloned dynptr will point to the same data as its parent dynptr, with the same type, offset, size and read-only properties.
Any writes to a dynptr will be reflected across all instances (by 'instance', this means any dynptrs that point to the same underlying data).
Please note that data slice and dynptr invalidations will affect all instances as well. For example, if bpf_dynptr_write() is called on an skb-type dynptr, all data slices of dynptr instances to that skb will be invalidated as well (eg data slices of any clones, parents, grandparents, ...). Another example is if a ringbuf dynptr is submitted, any instance of that dynptr will be invalidated.
Changing the view of the dynptr (eg advancing the offset or trimming the size) will only affect that dynptr and not affect any other instances.
One example use case where cloning may be helpful is for hashing or iterating through dynptr data. Cloning will allow the user to maintain the original view of the dynptr for future use, while also allowing views to smaller subsets of the data after the offset is advanced or the size is trimmed.
--- include/uapi/linux/bpf.h | 24 +++++++ kernel/bpf/helpers.c | 23 +++++++ kernel/bpf/verifier.c | 116 +++++++++++++++++++++------------ tools/include/uapi/linux/bpf.h | 24 +++++++ 4 files changed, 147 insertions(+), 40 deletions(-)
include/uapi/linux/bpf.h +24 -0
@@ -5508,6 +5508,29 @@ union bpf_attr {* Return * The offset of the dynptr on success, -EINVAL if the dynptr is * invalid. +* +* long bpf_dynptr_clone(struct bpf_dynptr *ptr, struct bpf_dynptr *clone) +* Description +* Clone an initialized dynptr *ptr*. After this call, both *ptr* +* and *clone* will point to the same underlying data. +* +* *clone* must be an uninitialized dynptr. +* +* Any data slice or dynptr invalidations will apply equally for +* both dynptrs after this call. For example, if ptr1 is a +* ringbuf-type dynptr with multiple data slices that is cloned to +* ptr2, if ptr2 discards the ringbuf sample, then ptr2, ptr2's +* data slices, ptr1, and ptr1's data slices will all be +* invalidated. +* +* This is convenient for getting different "views" to the same +* data. For instance, if one wishes to hash only a particular +* section of data, one can clone the dynptr, advance it to a +* specified offset and trim it to a specified size, pass it +* to the hash function, and discard it after hashing, without +* losing access to the original view of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr to clone is invalid. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5728,6 +5751,7 @@ union bpf_attr {FN (dynptr_is_rdonly), \FN (dynptr_get_size), \FN (dynptr_get_offset), \ +FN (dynptr_clone), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +23 -0
@@ -1762,6 +1762,27 @@ static const struct bpf_func_proto bpf_dynptr_get_offset_proto = { .arg1_type = ARG_PTR_TO_DYNPTR, }; +BPF_CALL_2(bpf_dynptr_clone, struct bpf_dynptr_kern *, ptr, + struct bpf_dynptr_kern *, clone) +{ +if (!ptr->data) { +bpf_dynptr_set_null (clone); +return -EINVAL ; + } + +memcpy (clone, ptr,sizeof (*clone)); + +return 0 ; +} + +static const struct bpf_func_proto bpf_dynptr_clone_proto = { + .func = bpf_dynptr_clone, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_PTR_TO_DYNPTR |MEM_UNINIT , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;
@@ -1846,6 +1867,8 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_get_size_proto;case BPF_FUNC_dynptr_get_offset:return &bpf_dynptr_get_offset_proto; +case BPF_FUNC_dynptr_clone: +return &bpf_dynptr_clone_proto;default :break ; }
kernel/bpf/verifier.c +76 -40
176 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +24 -0
@@ -5508,6 +5508,29 @@ union bpf_attr {* Return * The offset of the dynptr on success, -EINVAL if the dynptr is * invalid. +* +* long bpf_dynptr_clone(struct bpf_dynptr *ptr, struct bpf_dynptr *clone) +* Description +* Clone an initialized dynptr *ptr*. After this call, both *ptr* +* and *clone* will point to the same underlying data. +* +* *clone* must be an uninitialized dynptr. +* +* Any data slice or dynptr invalidations will apply equally for +* both dynptrs after this call. For example, if ptr1 is a +* ringbuf-type dynptr with multiple data slices that is cloned to +* ptr2, if ptr2 discards the ringbuf sample, then ptr2, ptr2's +* data slices, ptr1, and ptr1's data slices will all be +* invalidated. +* +* This is convenient for getting different "views" to the same +* data. For instance, if one wishes to hash only a particular +* section of data, one can clone the dynptr, advance it to a +* specified offset and trim it to a specified size, pass it +* to the hash function, and discard it after hashing, without +* losing access to the original view of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr to clone is invalid. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5728,6 +5751,7 @@ union bpf_attr {FN (dynptr_is_rdonly), \FN (dynptr_get_size), \FN (dynptr_get_offset), \ +FN (dynptr_clone), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Re: [PATCH bpf-next v1 5/8] bpf: Add bpf_dynptr_clone
Quoted 4 lines · On Wed, 7 Sep 2022 17:02:51 -0700 Joanne Koong <[email protected]> wrote:
Add a new helper,
bpf_dynptr_clone, which clones a dynptr.The cloned dynptr will point to the same data as its parent dynptr, with the same type, offset, size and read-only properties.
[...]
Quoted 5 lines
include/uapi/linux/bpf.h +0
-0
include/uapi/linux/bpf.h union bpf_attr { · line 5516
Quoted 9 lines
include/uapi/linux/bpf.h +6
-0@@ -5508,6 +5508,29 @@ union bpf_attr {* Return * The offset of the dynptr on success, -EINVAL if the dynptr is * invalid. +* +* long bpf_dynptr_clone(struct bpf_dynptr *ptr, struct bpf_dynptr *clone) +* Description +* Clone an initialized dynptr *ptr*. After this call, both *ptr* +* and *clone* will point to the same underlying data. +*
How about adding 'off' and 'len' parameters so that a view ("slice") of the dynptr can be created in a single call?
Otherwise, for a simple slice creation, ebpf user needs to:
bpf_dynptr_clone(orig, clone) bpf_dynptr_advance(clone, off)
trim_len = bpf_dynptr_get_size(clone) - len bpf_dynptr_trim(clone, trim_len)
This fits the usecase described here:
https://lore.kernel.org/bpf/20220830231349.46c49c50@blondie/
Re: [PATCH bpf-next v1 5/8] bpf: Add bpf_dynptr_clone
Quoted 28 lines · Shmulik Ladkani
Quoted 4 lines · On Wed, 7 Sep 2022 17:02:51 -0700 Joanne Koong <[email protected]> wrote:
Add a new helper,
bpf_dynptr_clone, which clones a dynptr.The cloned dynptr will point to the same data as its parent dynptr, with the same type, offset, size and read-only properties.
[...]
Quoted 5 lines
include/uapi/linux/bpf.h +0
-0include/uapi/linux/bpf.h union bpf_attr { · line 5516
Quoted 9 lines
include/uapi/linux/bpf.h +6
-0@@ -5508,6 +5508,29 @@ union bpf_attr {* Return * The offset of the dynptr on success, -EINVAL if the dynptr is * invalid. +* +* long bpf_dynptr_clone(struct bpf_dynptr *ptr, struct bpf_dynptr *clone) +* Description +* Clone an initialized dynptr *ptr*. After this call, both *ptr* +* and *clone* will point to the same underlying data. +* How about adding 'off' and 'len' parameters so that a view ("slice") of the dynptr can be created in a single call?
Quoted 5 lines
Otherwise, for a simple slice creation, ebpf user needs to:
bpf_dynptr_clone(orig, clone)bpf_dynptr_advance(clone, off)
trim_len=bpf_dynptr_get_size(clone)- lenbpf_dynptr_trim(clone, trim_len)
I like the idea, where 'off' is an offset from ptr's offset and 'len' is the number of bytes to trim.
Btw, I will be traveling for the next ~6 weeks and won't have access to a computer, so v2 will be sometime after that.
Quoted 3 lines
This fits the usecase described here:
https://lore.kernel.org/bpf/20220830231349.46c49c50@blondie/
Re: [PATCH bpf-next v1 5/8] bpf: Add bpf_dynptr_clone
Quoted 2 lines · On Fri, 9 Sep 2022 15:18:57 -0700 Joanne Koong <[email protected]> wrote:
I like the idea, where 'off' is an offset from ptr's offset and 'len' is the number of bytes to trim.
Actually parameters better be 'from' (inclusive) and 'to' (exclusive), similar to slicing in most languages. Specifying a negative 'to' provides the trimming functionality.
Quoted 2 lines
Btw, I will be traveling for the next ~6 weeks and won't have access to a computer, so v2 will be sometime after that.
Enjoy
Re: [PATCH bpf-next v1 5/8] bpf: Add bpf_dynptr_clone
Quoted 9 lines · Shmulik Ladkani
Quoted 2 lines · On Fri, 9 Sep 2022 15:18:57 -0700 Joanne Koong <[email protected]> wrote:
I like the idea, where 'off' is an offset from ptr's offset and 'len' is the number of bytes to trim.
Actually parameters better be 'from' (inclusive) and 'to' (exclusive), similar to slicing in most languages. Specifying a negative 'to' provides the trimming functionality.
If we do [from, to) then user will have to make sure that they always provide correct to, which might be quite cumbersome (you'll be calling bpf_dynptr_get_size() - 1). Ideally this adjustment is optional, so that user can pass 0, 0 and create exact copy.
So in that regard off_inc and sz_dec (just like I proposed for internal bpf_dynptr_adjust()) makes most sense, but to be honest it's quite confusing as they have "opposite directions". So it feels like just simple bpf_dynptr_clone() followed by bpf_dynptr_{trim/advance} might be best in terms of principle of least surprise in UAPI design.
Quoted 5 lines
Quoted 3 lines
Btw, I will be traveling for the next ~6 weeks and won't have access to a computer, so v2 will be sometime after that.
Enjoy
Re: [PATCH bpf-next v1 5/8] bpf: Add bpf_dynptr_clone
In reply to Joanne KoongQuoted 27 lines · Joanne Koong
Add a new helper,
bpf_dynptr_clone, which clones a dynptr.The cloned dynptr will point to the same data as its parent dynptr, with the same type, offset, size and read-only properties.
Any writes to a dynptr will be reflected across all instances (by 'instance', this means any dynptrs that point to the same underlying data).
Please note that data slice and dynptr invalidations will affect all instances as well. For example, if
bpf_dynptr_write()is called on an skb-type dynptr, all data slices of dynptr instances to that skb will be invalidated as well (eg data slices of any clones, parents, grandparents, ...). Another example is if a ringbuf dynptr is submitted, any instance of that dynptr will be invalidated.Changing the view of the dynptr (eg advancing the offset or trimming the size) will only affect that dynptr and not affect any other instances.
One example use case where cloning may be helpful is for hashing or iterating through dynptr data. Cloning will allow the user to maintain the original view of the dynptr for future use, while also allowing views to smaller subsets of the data after the offset is advanced or the size is trimmed.
Quoted 8 lines
Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 24 +++++++ kernel/bpf/helpers.c | 23 +++++++ kernel/bpf/verifier.c | 116 +++++++++++++++++++++------------ tools/include/uapi/linux/bpf.h | 24 +++++++ 4 files changed, 147 insertions(+), 40 deletions(-)
This is a very important helper in practice, looking forward to have it as part of dynptr API family!
include/uapi/linux/bpf.h union bpf_attr { · line 5512
Quoted 10 lines
include/uapi/linux/bpf.h +2
-0@@ -5508,6 +5508,29 @@ union bpf_attr {* Return * The offset of the dynptr on success, -EINVAL if the dynptr is * invalid. +* +* long bpf_dynptr_clone(struct bpf_dynptr *ptr, struct bpf_dynptr *clone)
const struct bpf_dynptr *ptr to make it clear that ptr is not modified. We can also use src and dst terminology here for less ambiguity.
Quoted 37 lines
include/uapi/linux/bpf.h +22
-0+* Description +* Clone an initialized dynptr *ptr*. After this call, both *ptr* +* and *clone* will point to the same underlying data. +* +* *clone* must be an uninitialized dynptr. +* +* Any data slice or dynptr invalidations will apply equally for +* both dynptrs after this call. For example, if ptr1 is a +* ringbuf-type dynptr with multiple data slices that is cloned to +* ptr2, if ptr2 discards the ringbuf sample, then ptr2, ptr2's +* data slices, ptr1, and ptr1's data slices will all be +* invalidated. +* +* This is convenient for getting different "views" to the same +* data. For instance, if one wishes to hash only a particular +* section of data, one can clone the dynptr, advance it to a +* specified offset and trim it to a specified size, pass it +* to the hash function, and discard it after hashing, without +* losing access to the original view of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr to clone is invalid. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5728,6 +5751,7 @@ union bpf_attr {FN (dynptr_is_rdonly), \FN (dynptr_get_size), \FN (dynptr_get_offset), \ +FN (dynptr_clone), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +0
-0
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_get_offset_proto = { · line 1771
Quoted 10 lines
kernel/bpf/helpers.c +7
-0@@ -1762,6 +1762,27 @@ static const struct bpf_func_proto bpf_dynptr_get_offset_proto = { .arg1_type = ARG_PTR_TO_DYNPTR, }; +BPF_CALL_2(bpf_dynptr_clone, struct bpf_dynptr_kern *, ptr, + struct bpf_dynptr_kern *, clone) +{ +if (!ptr->data) { +bpf_dynptr_set_null (clone); +return -EINVAL ; + }
once we have MALLOC dynptr this will break without appropriate refcnt bump. Let's have an explicit switch over all types of DYNPTR and error out on "unknown" (really, forgotten) types of dynptr. Better safe than having to debug corruptions in production.
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_get_offset_proto = { · line 1773
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ +memcpy (clone, ptr,sizeof (*clone));
*clone = *ptr?
Quoted 29 lines
kernel/bpf/helpers.c +14
-0+ +return 0 ; +} + +static const struct bpf_func_proto bpf_dynptr_clone_proto = { + .func = bpf_dynptr_clone, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_PTR_TO_DYNPTR |MEM_UNINIT , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;@@ -1846,6 +1867,8 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_get_size_proto;case BPF_FUNC_dynptr_get_offset:return &bpf_dynptr_get_offset_proto; +case BPF_FUNC_dynptr_clone: +return &bpf_dynptr_clone_proto;default :break ; }kernel/bpf/verifier.c +0
-0
kernel/bpf/verifier.c static enum bpf_dynptr_type arg_to_dynptr_type(enum bpf_arg_type arg_type) · line 702
Quoted 9 lines
kernel/bpf/verifier.c +5
-0@@ -694,17 +694,38 @@ static enum bpf_dynptr_type arg_to_dynptr_type(enum bpf_arg_type arg_type) } } +static bool arg_type_is_dynptr (enum bpf_arg_type type) +{ +return base_type (type) ==ARG_PTR_TO_DYNPTR ; +} +static bool dynptr_type_refcounted (enum bpf_dynptr_type type)
just noticed this name, I think it's quite confusing and will get even more so with MALLOC dynptr. It's not really reference *counted*, more like verifier *tracks references*, right? Consider renaming this to avoid this confusion. MALLOC dynptr will be both reference tracked (internally for verifier) and reference counted (at runtime to keep it alive).
Quoted 38 lines
kernel/bpf/verifier.c +20
-5{return type ==BPF_DYNPTR_TYPE_RINGBUF ; } -static int mark_stack_slots_dynptr (struct bpf_verifier_env *env,struct bpf_reg_state *reg, -enum bpf_arg_type arg_type,int insn_idx) +static enum bpf_dynptr_type stack_slot_get_dynptr_info (struct bpf_verifier_env *env, +struct bpf_reg_state *reg, +int *ref_obj_id) {struct bpf_func_state *state =func (env, reg); -enum bpf_dynptr_type type; -int spi, i, id; +int spi =get_spi (reg->off); + +if (ref_obj_id) + *ref_obj_id = state->stack[spi].spilled_ptr.id; + +return state->stack[spi].spilled_ptr.dynptr.type; +} + +static int mark_stack_slots_dynptr (struct bpf_verifier_env *env, +const struct bpf_func_proto *fn, +struct bpf_reg_state *reg, +enum bpf_arg_type arg_type, +int insn_idx,int func_id) +{ +enum bpf_dynptr_type type =BPF_DYNPTR_TYPE_INVALID ; +struct bpf_func_state *state =func (env, reg); +int spi, i, id =0 ; spi =get_spi (reg->off);@@ -716,7 +737,24 @@ static int mark_stack_slots_dynptr(struct bpf_verifier_env *env, struct bpf_reg_ state->stack[spi -1 ].slot_type[i] =STACK_DYNPTR ; } - type =arg_to_dynptr_type (arg_type);
kernel/bpf/verifier.c static int mark_stack_slots_dynptr(struct bpf_verifier_env *env, struct bpf_reg_ · line 749
Quoted 10 lines
kernel/bpf/verifier.c +10
-0+if (func_id == BPF_FUNC_dynptr_clone) { +/* find the type and id of the dynptr we're cloning and +* assign it to the clone +*/ +for (i =0 ; i <MAX_BPF_FUNC_REG_ARGS ; i++) { +enum bpf_arg_type t = fn->arg_type[i]; + +if (arg_type_is_dynptr (t) && !(t &MEM_UNINIT )) { + type = stack_slot_get_dynptr_info(env, + &state->regs[BPF_REG_1 + i],
so given we hard-coded BPF_FUNC_dynptr_clone func ID, we know that we need first argument, so no need for this loop?
Quoted 11 lines
kernel/bpf/verifier.c +8
-0+ &id); +break ; + } + } + }else { + type =arg_to_dynptr_type (arg_type); + } +if (type ==BPF_DYNPTR_TYPE_INVALID )return -EINVAL ;
[...]
PATCH 6/8 bpf: Add verifier support for custom callback return range
In reply to Joanne KoongThis is ported from Dave Marchevsky's patch [0], which is needed for the bpf iterators callback to return values beyond the 0, 1 range.
For comments, please refer to Dave's patch.
[0] https://lore.kernel.org/bpf/[email protected]/
--- include/linux/bpf_verifier.h | 1 + kernel/bpf/verifier.c | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-)
include/linux/bpf_verifier.h +1 -0
@@ -248,6 +248,7 @@ struct bpf_func_state {*/ u32 async_entry_cnt;bool in_callback_fn; +struct tnum callback_ret_range;bool in_async_callback_fn;/* The following fields should be last. See copy_func_state() */
kernel/bpf/verifier.c +3 -2
@@ -1814,6 +1814,7 @@ static void init_func_state(struct bpf_verifier_env *env, state->callsite = callsite; state->frameno = frameno; state->subprogno = subprogno; + state->callback_ret_range =tnum_range (0 ,1 );init_reg_state (env, state);mark_verifier_state_scratched (env); }
@@ -6974,6 +6975,7 @@ static int set_find_vma_callback_state(struct bpf_verifier_env *env,__mark_reg_not_init (env, &callee->regs[BPF_REG_4 ]);__mark_reg_not_init (env, &callee->regs[BPF_REG_5 ]); callee->in_callback_fn = true; + callee->callback_ret_range =tnum_range (0 ,1 );return 0 ; }
@@ -7000,8 +7002,7 @@ static int prepare_func_exit(struct bpf_verifier_env *env, int *insn_idx) state->curframe--; caller = state->frame[state->curframe];if (callee->in_callback_fn) { -/* enforce R0 return value range [0, 1]. */ -struct tnum range =tnum_range (0 ,1 ); +struct tnum range = callee->callback_ret_range;if (r0->type !=SCALAR_VALUE ) {verbose (env,"R0 not a scalar value\n" );
Signature · 1 line
2.30.2
PATCH 7/8 bpf: Add bpf_dynptr_iterator
In reply to Joanne KoongAdd a new helper function, bpf_dynptr_iterator:
long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn,
void *callback_ctx, u64 flags)
where callback_fn is defined as:
long (*callback_fn)(struct bpf_dynptr *ptr, void *ctx)
and callback_fn returns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if the callback_fn returns 0 or an error or tries to advance by more bytes than available.
--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)
include/uapi/linux/bpf.h +20 -0
@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
kernel/bpf/helpers.c +44 -4
75 lines not on this page · raw message
kernel/bpf/verifier.c +27 -0
@@ -6901,6 +6901,29 @@ static int set_map_elem_callback_state(struct bpf_verifier_env *env,return 0 ; } +static int set_dynptr_iterator_callback_state (struct bpf_verifier_env *env, +struct bpf_func_state *caller, +struct bpf_func_state *callee, +int insn_idx) +{ +/* bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, +* void *callback_ctx, u64 flags); +* +* callback_fn(struct bpf_dynptr *ptr, void *callback_ctx); +*/ + callee->regs[BPF_REG_1 ] = caller->regs[BPF_REG_1 ]; + callee->regs[BPF_REG_2 ] = caller->regs[BPF_REG_3 ]; + callee->callback_ret_range =tnum_range (0 ,U64_MAX ); + +/* unused */ +__mark_reg_not_init (env, &callee->regs[BPF_REG_3 ]); +__mark_reg_not_init (env, &callee->regs[BPF_REG_4 ]); +__mark_reg_not_init (env, &callee->regs[BPF_REG_5 ]); + + callee->in_callback_fn = true; +return 0 ; +} + static int set_loop_callback_state(struct bpf_verifier_env *env, struct bpf_func_state *caller, struct bpf_func_state *callee,
@@ -7472,6 +7495,10 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnbreak ; } +case BPF_FUNC_dynptr_iterator: + err =__check_func_call (env, insn, insn_idx_p, meta.subprogno, + set_dynptr_iterator_callback_state); +break ; }if (err)
tools/include/uapi/linux/bpf.h +20 -0
@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \
@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper
Signature · 1 line
2.30.2
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 10 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)
Quoted 7 lines
and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>---
This is buggy as is.
A user can just reinitialize the dynptr from inside the callback, and then you will never stop advancing it inside your helper, therefore an infinite loop can be constructed. The stack frame of the caller is accessible using callback_ctx.
For example (modifying your selftest)
(quoted diff) +0 -0
b/tools/testing/selftests/bpf/progs/dynptr_success.c index 22164ad6df9d..a9e78316c508 100644
tools/testing/selftests/bpf/progs/dynptr_success.c +13 -0
@@ -540,6 +540,19 @@ struct iter_ctx {static int iter_callback (struct bpf_dynptr *ptr,struct iter_ctx *ctx) { +struct map_value *map_val; +int key =0 ; + + map_val =bpf_map_lookup_elem (&array_map2, &key); +if (!map_val) { +return 0 ; + } + + *(void **)ptr =0 ; + *((void **)ptr +1 ) =0 ; +bpf_dynptr_from_mem (map_val,2 ,0 , ptr); +return 1 ; +if (ctx->trigger_err_erange)return bpf_dynptr_get_size (ptr) +1 ;
... leads to a lockup.
It doesn't have to be ringbuf_reserver_dynptr, it can just be dynptr_from_mem, which also gets around reference state restrictions inside callbacks.
You cannot prevent overwriting dynptr stack slots in general. Some of them don't have to be released. It would be prohibitive for stack reuse.
So it seems like you need to temporarily mark both the slots as immutable for the caller stack state during exploration of the callback.
Setting some flag in r1 for callback is not enough (as it can reload PTR_TO_STACK of caller stack frame pointing at dynptr from callback_ctx). It needs to be set in spilled_ptr.
Then certain operations modifying the view of the dynptr do not accept dynptr with that type flag set (e.g. trim, advance, init functions). While for others which only operate on the underlying view, you fold the flag (e.g. read/write/dynptr_data).
It is the difference between struct bpf_dynptr *, vs const struct bpf_dynptr *, we need to give the callback access to the latter. I.e. it should still allow accessing the dynptr's view, but not modifying it.
And at the risk of sounding like a broken record (and same suggestion as Martin in skb/xdp v6 set), the view's mutability should ideally also be part of the verifier's state. That doesn't preclude runtime tracking later, but there seems to be no strong motivation for that right now.
Quoted 213 lines
include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +44
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{ +bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes; + + err =__bpf_dynptr_advance (ptr, nr_bytes); +if (err) +return err; + } + +return 0 ; +} + +static const struct bpf_func_proto bpf_dynptr_iterator_proto = { + .func = bpf_dynptr_iterator, + .gpl_only = false, + .ret_type =RET_INTEGER , + .arg1_type =ARG_PTR_TO_DYNPTR , + .arg2_type =ARG_PTR_TO_FUNC , + .arg3_type =ARG_PTR_TO_STACK_OR_NULL , + .arg4_type =ARG_ANYTHING , +}; +const struct bpf_func_proto bpf_get_current_task_proto__weak ;const struct bpf_func_proto bpf_get_current_task_btf_proto__weak ;const struct bpf_func_proto bpf_probe_read_user_proto__weak ;@@ -1869,6 +1907,8 @@ bpf_base_func_proto(enum bpf_func_id func_id)return &bpf_dynptr_get_offset_proto;case BPF_FUNC_dynptr_clone:return &bpf_dynptr_clone_proto; +case BPF_FUNC_dynptr_iterator: +return &bpf_dynptr_iterator_proto;default :break ; }kernel/bpf/verifier.c +27
-0@@ -6901,6 +6901,29 @@ static int set_map_elem_callback_state(struct bpf_verifier_env *env,return 0 ; } +static int set_dynptr_iterator_callback_state (struct bpf_verifier_env *env, +struct bpf_func_state *caller, +struct bpf_func_state *callee, +int insn_idx) +{ +/* bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, +* void *callback_ctx, u64 flags); +* +* callback_fn(struct bpf_dynptr *ptr, void *callback_ctx); +*/ + callee->regs[BPF_REG_1 ] = caller->regs[BPF_REG_1 ]; + callee->regs[BPF_REG_2 ] = caller->regs[BPF_REG_3 ]; + callee->callback_ret_range =tnum_range (0 ,U64_MAX ); + +/* unused */ +__mark_reg_not_init (env, &callee->regs[BPF_REG_3 ]); +__mark_reg_not_init (env, &callee->regs[BPF_REG_4 ]); +__mark_reg_not_init (env, &callee->regs[BPF_REG_5 ]); + + callee->in_callback_fn = true; +return 0 ; +} + static int set_loop_callback_state(struct bpf_verifier_env *env, struct bpf_func_state *caller, struct bpf_func_state *callee,@@ -7472,6 +7495,10 @@ static int check_helper_call(struct bpf_verifier_env *env, struct bpf_insn *insnbreak ; } +case BPF_FUNC_dynptr_iterator: + err =__check_func_call (env, insn, insn_idx_p, meta.subprogno, + set_dynptr_iterator_callback_state); +break ; }if (err)tools/include/uapi/linux/bpf.h +20
-1@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper -- 2.30.2
Re: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 64 lines · Kumar Kartikeya Dwivedi
Quoted 10 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)Quoted 7 lines
and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>---
This is buggy as is.
A user can just reinitialize the dynptr from inside the callback, and then you will never stop advancing it inside your helper, therefore an infinite loop can be constructed. The stack frame of the caller is accessible using
callback_ctx.For example (modifying your selftest)
tools/testing/selftests/bpf/progs/dynptr_success.c +13
-0@@ -540,6 +540,19 @@ struct iter_ctx {static int iter_callback (struct bpf_dynptr *ptr,struct iter_ctx *ctx) { +struct map_value *map_val; +int key =0 ; + + map_val =bpf_map_lookup_elem (&array_map2, &key); +if (!map_val) { +return 0 ; + } + + *(void **)ptr =0 ; + *((void **)ptr +1 ) =0 ; +bpf_dynptr_from_mem (map_val,2 ,0 , ptr); +return 1 ; +if (ctx->trigger_err_erange)return bpf_dynptr_get_size (ptr) +1 ;... leads to a lockup.
It doesn't have to be
ringbuf_reserver_dynptr, it can just bedynptr_from_mem, which also gets around reference state restrictions inside callbacks.You cannot prevent overwriting dynptr stack slots in general. Some of them don't have to be released. It would be prohibitive for stack reuse.
Quoted 6 lines
So it seems like you need to temporarily mark both the slots as immutable for the caller stack state during exploration of the callback.
Setting some flag in r1 for callback is not enough (as it can reloadPTR_TO_STACKof caller stack frame pointing at dynptr fromcallback_ctx). It needs to be set inspilled_ptr.
This sounds overcomplicated. We need a local copy of dynptr for the duration of iteration and work with it. Basically internal bpf_dynptr_clone(). See my other reply in this thread.
Quoted 10 lines
Then certain operations modifying the view of the dynptr do not accept dynptr with that type flag set (e.g. trim, advance, init functions). While for others which only operate on the underlying view, you fold the flag (e.g. read/write/dynptr_data).
It is the difference between struct
bpf_dynptr*, vs const structbpf_dynptr*, we need to give the callback access to the latter. I.e. it should still allow accessing the dynptr's view, but not modifying it.
Quoted 5 lines
And at the risk of sounding like a broken record (and same suggestion as Martin in skb/xdp v6 set), the view's mutability should ideally also be part of the verifier's state. That doesn't preclude runtime tracking later, but there seems to be no strong motivation for that right now.
The unexpected NULL for bpf_dynptr_data() vs bpf_dynptr_data_rdonly() argument from Martin is pretty convincing, I agree. So I guess I don't mind tracking it statically at this point.
Quoted 7 lines
Quoted 7 lines
include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)
please trim irrelevant parts
[...]
Re: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
In reply to Joanne KoongQuoted 103 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +13
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1804
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes;
callback is defined as returning long but here you are silently truncating it to int. Let's either stick to longs or to ints.
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1806
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ + err =__bpf_dynptr_advance (ptr, nr_bytes);
as Kumar pointed out, you can't modify ptr in place, you have to create a local copy and bpf_dynptr_clone() it (so that for MALLOC you'll bump refcnt). Then advance and pass it to callback. David has such local dynptr use case in bpf_user_ringbuf_drain() helper.
Quoted 7 lines
kernel/bpf/helpers.c +7
-0+if (err) +return err; + } + +return 0 ; +} +
[...]
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 119 lines · Andrii Nakryiko
Quoted 103 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +13
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1804
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes;callback is defined as returning long but here you are silently truncating it to int. Let's either stick to longs or to ints.
Quoted 8 lines
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1806
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ + err =__bpf_dynptr_advance (ptr, nr_bytes);as Kumar pointed out, you can't modify ptr in place, you have to create a local copy and
bpf_dynptr_clone()it (so that for MALLOC you'll bump refcnt). Then advance and pass it to callback. David has such local dynptr use case inbpf_user_ringbuf_drain()helper.
My solution was a bit overcomplicated because just creating a local copy doesn't fix this completely, there's still the hole of writing through arg#0 (which now does not reflect runtime state, as writes at runtime go to clone while verifier thinks you touched stack slots), and still allows constructing the infinite loop (because well, you can overwrite dynptr through it). The 'side channel' of writing to dynptr slots through callback_ctx is still there as well.
Maybe the infinite loop _can_ be avoided if you clone inside each iteration, that part isn't very clear.
My reasoning was that when you iterate, the container is always immutable (to prevent iterator invalidation) while mutability of elements remains unaffected from that. Setting it in spilled_ptr covers all bases (PTR_TO_STACK arg#0, access to it through callback_ctx, etc.).
But I totally agree with you that we should be working on a local copy inside the helper and leave the original dynptr untouched. I think then the first arg should not be PTR_TO_STACK but some other pointer type. Maybe it should be its own register type, and spilled_ptr should reflect the same register, which allows the dynptr state that we track to be copied into the callback arg#0 easily.
For the case of writes to the original dynptr that is already broken right now, we can't track the state of the stack across iterations correctly anyway so I think that has to be left as is until your N callbacks rework happens.
wdyt?
Re: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 148 lines · Kumar Kartikeya Dwivedi
Quoted 119 lines · Andrii Nakryiko
Quoted 103 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +13
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1804
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes;callback is defined as returning long but here you are silently truncating it to int. Let's either stick to longs or to ints.
Quoted 8 lines
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1806
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ + err =__bpf_dynptr_advance (ptr, nr_bytes);as Kumar pointed out, you can't modify ptr in place, you have to create a local copy and
bpf_dynptr_clone()it (so that for MALLOC you'll bump refcnt). Then advance and pass it to callback. David has such local dynptr use case inbpf_user_ringbuf_drain()helper.My solution was a bit overcomplicated because just creating a local copy doesn't fix this completely, there's still the hole of writing through arg#0 (which now does not reflect runtime state, as writes at runtime go to clone while verifier thinks you touched stack slots), and still allows constructing the infinite loop (because well, you can overwrite dynptr through it). The 'side channel' of writing to dynptr slots through
callback_ctxis still there as well.Maybe the infinite loop _can_ be avoided if you clone inside each iteration, that part isn't very clear.
My reasoning was that when you iterate, the container is always immutable (to prevent iterator invalidation) while mutability of elements remains unaffected from that. Setting it in
spilled_ptrcovers all bases (PTR_TO_STACKarg#0, access to it throughcallback_ctx, etc.).
Quoted 6 lines
But I totally agree with you that we should be working on a local copy inside the helper and leave the original dynptr untouched. I think then the first arg should not be
PTR_TO_STACKbut some other pointer type. Maybe it should be its own register type, andspilled_ptrshould reflect the same register, which allows the dynptr state that we track to be copied into the callback arg#0 easily.
Right, something like what David Vernet did with his bpf_user_ringbuf_drain() helper that passes kernel-only (not PTR_TO_STACK) dynptr into callback. If that implementation has the same hole (being able to be modified), we should fix it the same way in both cases, by not allowing this for PTR_TO_DYNPTR (or whatever the new reg type is called).
Quoted 5 lines
For the case of writes to the original dynptr that is already broken right now, we can't track the state of the stack across iterations correctly anyway so I think that has to be left as is until your N callbacks rework happens.
Right, that's a separate issue.
Quoted 2 lines
wdyt?
Kumar Kartikeya Dwivedi
maintainerRe: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 158 lines · Andrii Nakryiko
Quoted 148 lines · Kumar Kartikeya Dwivedi
Quoted 119 lines · Andrii Nakryiko
Quoted 103 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +13
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1804
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes;callback is defined as returning long but here you are silently truncating it to int. Let's either stick to longs or to ints.
Quoted 8 lines
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1806
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ + err =__bpf_dynptr_advance (ptr, nr_bytes);as Kumar pointed out, you can't modify ptr in place, you have to create a local copy and
bpf_dynptr_clone()it (so that for MALLOC you'll bump refcnt). Then advance and pass it to callback. David has such local dynptr use case inbpf_user_ringbuf_drain()helper.My solution was a bit overcomplicated because just creating a local copy doesn't fix this completely, there's still the hole of writing through arg#0 (which now does not reflect runtime state, as writes at runtime go to clone while verifier thinks you touched stack slots), and still allows constructing the infinite loop (because well, you can overwrite dynptr through it). The 'side channel' of writing to dynptr slots through
callback_ctxis still there as well.Maybe the infinite loop _can_ be avoided if you clone inside each iteration, that part isn't very clear.
My reasoning was that when you iterate, the container is always immutable (to prevent iterator invalidation) while mutability of elements remains unaffected from that. Setting it in
spilled_ptrcovers all bases (PTR_TO_STACKarg#0, access to it throughcallback_ctx, etc.).Quoted 6 lines
But I totally agree with you that we should be working on a local copy inside the helper and leave the original dynptr untouched. I think then the first arg should not be
PTR_TO_STACKbut some other pointer type. Maybe it should be its own register type, andspilled_ptrshould reflect the same register, which allows the dynptr state that we track to be copied into the callback arg#0 easily.
Quoted 7 lines
Right, something like what David Vernet did with his
bpf_user_ringbuf_drain()helper that passes kernel-only (notPTR_TO_STACK) dynptr into callback. If that implementation has the same hole (being able to be modified), we should fix it the same way in both cases, by not allowing this forPTR_TO_DYNPTR(or whatever the new reg type is called).
Sorry for the late response.
Somehow I missed that series entirely. Yes, we should reuse that register type, and it does seem like it needs to check for MEM_UNINIT to prevent reinitialization. I'm rolling that fix into
my dynptr series that I'm sending next week, since it would lead to lots of conflicts otherwise.
Then this set can use the same approach.
Re: [PATCH bpf-next v1 7/8] bpf: Add bpf_dynptr_iterator
Quoted 169 lines · Kumar Kartikeya Dwivedi
Quoted 158 lines · Andrii Nakryiko
Quoted 148 lines · Kumar Kartikeya Dwivedi
Quoted 119 lines · Andrii Nakryiko
Quoted 103 lines · Joanne Koong
Add a new helper function,
bpf_dynptr_iterator:long bpf_dynptr_iterator(struct
bpf_dynptr*ptr, void*callback_fn,
void*callback_ctx, u64 flags)where
callback_fnis defined as:long (*callback_fn)(struct
bpf_dynptr*ptr, void *ctx)and
callback_fnreturns the number of bytes to advance the dynptr by (or an error code in the case of error). The iteration will stop if thecallback_fnreturns 0 or an error or tries to advance by more bytes than available.Signed-off-by Joanne Koong <[email protected]>--- include/uapi/linux/bpf.h | 20 ++++++++++++++ kernel/bpf/helpers.c | 48 +++++++++++++++++++++++++++++++--- kernel/bpf/verifier.c | 27 +++++++++++++++++++ tools/include/uapi/linux/bpf.h | 20 ++++++++++++++ 4 files changed, 111 insertions(+), 4 deletions(-)include/uapi/linux/bpf.h +20
-0@@ -5531,6 +5531,25 @@ union bpf_attr {* losing access to the original view of the dynptr. * Return * 0 on success, -EINVAL if the dynptr to clone is invalid. +* +* long bpf_dynptr_iterator(struct bpf_dynptr *ptr, void *callback_fn, void *callback_ctx, u64 flags) +* Description +* Iterate through the dynptr data, calling **callback_fn** on each +* iteration with **callback_ctx** as the context parameter. +* The **callback_fn** should be a static function and +* the **callback_ctx** should be a pointer to the stack. +* Currently **flags** is unused and must be 0. +* +* long (\*callback_fn)(struct bpf_dynptr \*ptr, void \*ctx); +* +* where **callback_fn** returns the number of bytes to advance +* the dynptr by or an error. The iteration will stop if **callback_fn** +* returns 0 or an error or tries to advance by more bytes than the +* size of the dynptr. +* Return +* 0 on success, -EINVAL if the dynptr is invalid or **flags** is not 0, +* -ERANGE if attempting to iterate more bytes than available, or other +* negative error if **callback_fn** returns an error. */ #define __BPF_FUNC_MAPPER (FN ) \ FN(unspec), \@@ -5752,6 +5771,7 @@ union bpf_attr {FN (dynptr_get_size), \FN (dynptr_get_offset), \FN (dynptr_clone), \ +FN (dynptr_iterator), \/* */ /* integer value in 'imm' field of BPF_CALL instruction selects which helper kernel/bpf/helpers.c +13
-4@@ -1653,13 +1653,11 @@ static const struct bpf_func_proto bpf_dynptr_data_proto = { .arg3_type = ARG_CONST_ALLOC_SIZE_OR_ZERO, }; -BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +/* *ptr* should always be a valid dynptr */ +static int __bpf_dynptr_advance (struct bpf_dynptr_kern *ptr,u32 len) {u32 size; -if (!ptr->data) -return -EINVAL ; - size =__bpf_dynptr_get_size (ptr);if (len > size)@@ -1672,6 +1670,14 @@ BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len)return 0 ; } +BPF_CALL_2(bpf_dynptr_advance, struct bpf_dynptr_kern *, ptr, u32, len) +{ +if (!ptr->data) +return -EINVAL ; + +return __bpf_dynptr_advance (ptr, len); +} +static const struct bpf_func_proto bpf_dynptr_advance_proto = { .func = bpf_dynptr_advance, .gpl_only = false,@@ -1783,6 +1789,38 @@ static const struct bpf_func_proto bpf_dynptr_clone_proto = { .arg2_type = ARG_PTR_TO_DYNPTR | MEM_UNINIT, }; +BPF_CALL_4(bpf_dynptr_iterator, struct bpf_dynptr_kern *, ptr, void *, callback_fn, + void *, callback_ctx, u64, flags) +{kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1804
Quoted 10 lines
kernel/bpf/helpers.c +10
-0+bpf_callback_t callback = (bpf_callback_t )callback_fn; +int nr_bytes, err; + +if (!ptr->data || flags) +return -EINVAL ; + +while (ptr->size >0 ) { + nr_bytes =callback ((u64 )(long )ptr, (u64 )(long )callback_ctx,0 ,0 ,0 ); +if (nr_bytes <=0 ) +return nr_bytes;callback is defined as returning long but here you are silently truncating it to int. Let's either stick to longs or to ints.
Quoted 8 lines
kernel/bpf/helpers.c static const struct bpf_func_proto bpf_dynptr_clone_proto = { · line 1806
Quoted 2 lines
kernel/bpf/helpers.c +2
-0+ + err =__bpf_dynptr_advance (ptr, nr_bytes);as Kumar pointed out, you can't modify ptr in place, you have to create a local copy and
bpf_dynptr_clone()it (so that for MALLOC you'll bump refcnt). Then advance and pass it to callback. David has such local dynptr use case inbpf_user_ringbuf_drain()helper.My solution was a bit overcomplicated because just creating a local copy doesn't fix this completely, there's still the hole of writing through arg#0 (which now does not reflect runtime state, as writes at runtime go to clone while verifier thinks you touched stack slots), and still allows constructing the infinite loop (because well, you can overwrite dynptr through it). The 'side channel' of writing to dynptr slots through
callback_ctxis still there as well.Maybe the infinite loop _can_ be avoided if you clone inside each iteration, that part isn't very clear.
My reasoning was that when you iterate, the container is always immutable (to prevent iterator invalidation) while mutability of elements remains unaffected from that. Setting it in
spilled_ptrcovers all bases (PTR_TO_STACKarg#0, access to it throughcallback_ctx, etc.).Quoted 6 lines
But I totally agree with you that we should be working on a local copy inside the helper and leave the original dynptr untouched. I think then the first arg should not be
PTR_TO_STACKbut some other pointer type. Maybe it should be its own register type, andspilled_ptrshould reflect the same register, which allows the dynptr state that we track to be copied into the callback arg#0 easily.Quoted 7 lines
Right, something like what David Vernet did with his
bpf_user_ringbuf_drain()helper that passes kernel-only (notPTR_TO_STACK) dynptr into callback. If that implementation has the same hole (being able to be modified), we should fix it the same way in both cases, by not allowing this forPTR_TO_DYNPTR(or whatever the new reg type is called).
Quoted 8 lines
Sorry for the late response.
Somehow I missed that series entirely. Yes, we should reuse that register type, and it does seem like it needs to check for
MEM_UNINITto prevent reinitialization. I'm rolling that fix into
my dynptr series that I'm sending next week, since it would lead to lots of conflicts otherwise.
Then this set can use the same approach.
Sounds good, thanks!
PATCH 8/8 selftests/bpf: Tests for dynptr convenience helpers
In reply to Joanne KoongTest dynptr convenience helpers in the following way:
1) bpf_dynptr_data_rdonly
* "data_slice_rdonly" tests that writes into read-only slices are rejected.
* "skb_invalid_data_slice_rdonly{1,2}" tests that read-only slices for skb-type dynptrs get invalidated whenever packet data may change.
2) bpf_dynptr_trim and bpf_dynptr_advance
* "test_advance_trim" tests that dynptr offset and size get adjusted correctly.
* "test_advance_trim_err" tests that advances beyond dynptr size and trims larger than dynptr size are rejected.
* "test_zero_size_dynptr" tests that a zero-size dynptr (after advancing or trimming) can only read and write 0 bytes.
3) bpf_dynptr_is_null
* "dynptr_is_null_invalid" tests that only initialized dynptrs can be passed in.
* "test_dynptr_is_null" tests that null dynptrs return true and non-null dynptrs return false.
4) bpf_dynptr_is_rdonly
* "dynptr_is_rdonly_invalid" tests that only initialized dynptrs can be passed in.
* "test_dynptr_is_rdonly" tests that rdonly dynptrs return true and non-rdonly or invalid dynptrs return false.
5) bpf_dynptr_get_size
* "dynptr_get_size_invalid" tests that only initialized dynptrs can be passed in.
* Additional functionality is tested as a by-product in "test_advance_trim"
6) bpf_dynptr_get_offset
* "dynptr_get_offset_invalid" tests that only initialized dynptrs can be passed in.
* Additional functionality is tested as a by-product in "test_advance_trim"
7) bpf_dynptr_clone
* "clone_invalidate_{1..6}" tests that invalidating a dynptr invalidates all instances and invalidating a dynptr's data slices invalidates all data slices for all instances.
* "clone_skb_packet_data" tests that data slices of skb dynptr instances are invalidated when packet data changes.
* "clone_xdp_packet_data" tests that data slices of xdp dynptr instances are invalidated when packet data changes.
* "clone_invalid1" tests that only initialized dynptrs can be cloned.
* "clone_invalid2" tests that only uninitialized dynptrs can be a clone.
* "test_dynptr_clone" tests that the views from the same dynptr instances are independent (advancing or trimming a dynptr doesn't affect other instances), and that a clone will return a dynptr with the same type, offset, size, and rd-only property.
8) bpf_dynptr_iterator
* "iterator_invalid1" tests that any dynptr requiring a release that gets acquired in an iterator callback must also be released within the callback
* "iterator_invalid2" tests that bpf_dynptr_iterator can't be called on an uninitialized dynptr
* "iterator_invalid3" tests that an already-initialized dynptr can't be initialized again in the iterator callback function
* "iterator_invalid4" tests that the dynptr that's iterating can't be released in the callback function
* "iterator_invalid5" tests that the dynptr can't be passed as a callback ctx and released within the callback
* "test_dynptr_iterator" tests basic functionality of the iterator
* "iterator_parse_strings" tests parsing strings as values
--- .../testing/selftests/bpf/prog_tests/dynptr.c | 30 + .../testing/selftests/bpf/progs/dynptr_fail.c | 462 +++++++++++++++ .../selftests/bpf/progs/dynptr_success.c | 551 +++++++++++++++++- 3 files changed, 1041 insertions(+), 2 deletions(-)
tools/testing/selftests/bpf/prog_tests/dynptr.c +30 -0
@@ -53,15 +53,45 @@ static struct { "Unsupported reg type fp for bpf_dynptr_from_mem data"}, {"skb_invalid_data_slice1", "invalid mem access 'scalar'"}, {"skb_invalid_data_slice2", "invalid mem access 'scalar'"}, + {"skb_invalid_data_slice_rdonly1", "invalid mem access 'scalar'"}, + {"skb_invalid_data_slice_rdonly2", "invalid mem access 'scalar'"}, {"xdp_invalid_data_slice", "invalid mem access 'scalar'"}, {"skb_invalid_ctx", "unknown func bpf_dynptr_from_skb"}, {"xdp_invalid_ctx", "unknown func bpf_dynptr_from_xdp"}, + {"data_slice_rdonly", "cannot write into rdonly_mem"}, + {"dynptr_is_null_invalid", "Expected an initialized dynptr as arg #1"}, + {"dynptr_is_rdonly_invalid", "Expected an initialized dynptr as arg #1"}, + {"dynptr_get_size_invalid", "Expected an initialized dynptr as arg #1"}, + {"dynptr_get_offset_invalid", "Expected an initialized dynptr as arg #1"}, + {"clone_invalid1", "Expected an initialized dynptr as arg #1"}, + {"clone_invalid2", "Dynptr has to be an uninitialized dynptr"}, + {"clone_invalidate1", "Expected an initialized dynptr"}, + {"clone_invalidate2", "Expected an initialized dynptr"}, + {"clone_invalidate3", "Expected an initialized dynptr"}, + {"clone_invalidate4", "invalid mem access 'scalar'"}, + {"clone_invalidate5", "invalid mem access 'scalar'"}, + {"clone_invalidate6", "invalid mem access 'scalar'"}, + {"clone_skb_packet_data", "invalid mem access 'scalar'"}, + {"clone_xdp_packet_data", "invalid mem access 'scalar'"}, + {"iterator_invalid1", "Unreleased reference id=1"}, + {"iterator_invalid2", "Expected an initialized dynptr as arg #1"}, + {"iterator_invalid3", "Dynptr has to be an uninitialized dynptr"}, + {"iterator_invalid4", "Unreleased reference"}, + {"iterator_invalid5", "Unreleased reference"},/* these tests should be run and should succeed */ {"test_read_write", NULL, SETUP_SYSCALL_SLEEP}, {"test_data_slice", NULL, SETUP_SYSCALL_SLEEP}, {"test_ringbuf", NULL, SETUP_SYSCALL_SLEEP}, {"test_skb_readonly", NULL, SETUP_SKB_PROG}, + {"test_advance_trim", NULL, SETUP_SYSCALL_SLEEP}, + {"test_advance_trim_err", NULL, SETUP_SYSCALL_SLEEP}, + {"test_zero_size_dynptr", NULL, SETUP_SYSCALL_SLEEP}, + {"test_dynptr_is_null", NULL, SETUP_SYSCALL_SLEEP}, + {"test_dynptr_is_rdonly", NULL, SETUP_SKB_PROG}, + {"test_dynptr_clone", NULL, SETUP_SKB_PROG}, + {"test_dynptr_iterator", NULL, SETUP_SKB_PROG}, + {"iterator_parse_strings", NULL, SETUP_SYSCALL_SLEEP}, };static void verify_fail (const char *prog_name,const char *expected_err_msg)
tools/testing/selftests/bpf/progs/dynptr_fail.c +462 -0
471 lines not on this page · raw message
tools/testing/selftests/bpf/progs/dynptr_success.c +549 -2
569 lines not on this page · raw message
Signature · 1 line
2.30.2