Daniel Borkmann says: ==================== pull-request: bpf-next 2024-09-11 We've added 12 non-merge commits during the last 16 day(s) which contain a total of 20 files changed, 228 insertions(+), 30 deletions(-). There's a minor merge conflict in drivers/net/netkit.c: 00d066a4d4ed ("netdev_features: convert NETIF_F_LLTX to dev->lltx") d96608794889 ("netkit: Disable netpoll support") The main changes are: 1) Enable bpf_dynptr_from_skb for tp_btf such that this can be used to easily parse skbs in BPF programs attached to tracepoints, from Philo Lu. 2) Add a cond_resched() point in BPF's sock_hash_free() as there have been several syzbot soft lockup reports recently, from Eric Dumazet. 3) Fix xsk_buff_can_alloc() to account for queue_empty_descs which got noticed when zero copy ice driver started to use it, from Maciej Fijalkowski. 4) Move the xdp:xdp_cpumap_kthread tracepoint before cpumap pushes skbs up via netif_receive_skb_list() to better measure latencies, from Daniel Xu. 5) Follow-up to disable netpoll support from netkit, from Daniel Borkmann. 6) Improve xsk selftests to not assume a fixed MAX_SKB_FRAGS of 17 but instead gather the actual value via /proc/sys/net/core/max_skb_frags, also from Maciej Fijalkowski. * tag 'for-netdev' of https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next: sock_map: Add a cond_resched() in sock_hash_free() selftests/bpf: Expand skb dynptr selftests for tp_btf bpf: Allow bpf_dynptr_from_skb() for tp_btf tcp: Use skb__nullable in trace_tcp_send_reset selftests/bpf: Add test for __nullable suffix in tp_btf bpf: Support __nullable argument suffix for tp_btf bpf, cpumap: Move xdp:xdp_cpumap_kthread tracepoint before rcv selftests/xsk: Read current MAX_SKB_FRAGS from sysctl knob xsk: Bump xsk_queue::queue_empty_descs in xp_can_alloc() tcp_bpf: Remove an unused parameter for bpf_tcp_ingress() bpf, sockmap: Correct spelling skmsg.c netkit: Disable netpoll support Signed-off-by: Jakub Kicinski <kuba@kernel.org> ====================
Unified · Split
| @@ -255,6 +255,7 @@ static void netkit_setup(struct net_device *dev) · 254 unmodified lines | ||
| 255 | 255 | dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; |
| 256 | 256 | dev->priv_flags |= IFF_PHONY_HEADROOM; |
| 257 | 257 | dev->priv_flags |= IFF_NO_QUEUE; |
| 258 | + dev->priv_flags |= IFF_DISABLE_NETPOLL; | |
| 258 | 259 | dev->lltx = true; |
| 259 | 260 | |
| 260 | 261 | dev->ethtool_ops = &netkit_ethtool_ops; |
| @@ -91,10 +91,10 @@ DEFINE_RST_REASON(FN, FN) · 90 unmodified lines | ||
| 91 | 91 | TRACE_EVENT(tcp_send_reset, |
| 92 | 92 | |
| 93 | 93 | TP_PROTO(const struct sock *sk, |
| 94 | − const struct sk_buff *skb, | |
| 94 | + const struct sk_buff *skb__nullable, | |
| 95 | 95 | const enum sk_rst_reason reason), |
| 96 | 96 | |
| 97 | − TP_ARGS(sk, skb, reason), | |
| 97 | + TP_ARGS(sk, skb__nullable, reason), | |
| 98 | 98 | |
| 99 | 99 | TP_STRUCT__entry( |
| 100 | 100 | __field(const void *, skbaddr) |
| @@ -106,7 +106,7 @@ TRACE_EVENT(tcp_send_reset, · 5 unmodified lines | ||
| 106 | 106 | ), |
| 107 | 107 | |
| 108 | 108 | TP_fast_assign( |
| 109 | − __entry->skbaddr = skb; | |
| 109 | + __entry->skbaddr = skb__nullable; | |
| 110 | 110 | __entry->skaddr = sk; |
| 111 | 111 | /* Zero means unknown state. */ |
| 112 | 112 | __entry->state = sk ? sk->sk_state : 0; |
| @@ -118,13 +118,13 @@ TRACE_EVENT(tcp_send_reset, · 5 unmodified lines | ||
| 118 | 118 | const struct inet_sock *inet = inet_sk(sk); |
| 119 | 119 | |
| 120 | 120 | TP_STORE_ADDR_PORTS(__entry, inet, sk); |
| 121 | − } else if (skb) { | |
| 122 | − const struct tcphdr *th = (const struct tcphdr *)skb->data; | |
| 121 | + } else if (skb__nullable) { | |
| 122 | + const struct tcphdr *th = (const struct tcphdr *)skb__nullable->data; | |
| 123 | 123 | /* |
| 124 | 124 | * We should reverse the 4-tuple of skb, so later |
| 125 | 125 | * it can print the right flow direction of rst. |
| 126 | 126 | */ |
| 127 | − TP_STORE_ADDR_PORTS_SKB(skb, th, entry->daddr, entry->saddr); | |
| 127 | + TP_STORE_ADDR_PORTS_SKB(skb__nullable, th, entry->daddr, entry->saddr); | |
| 128 | 128 | } |
| 129 | 129 | __entry->reason = reason; |
| 130 | 130 | ), |
| @@ -6525,6 +6525,9 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, · 6524 unmodified lines | ||
| 6525 | 6525 | if (prog_args_trusted(prog)) |
| 6526 | 6526 | info->reg_type |= PTR_TRUSTED; |
| 6527 | 6527 | |
| 6528 | + if (btf_param_match_suffix(btf, &args[arg], "__nullable")) | |
| 6529 | + info->reg_type |= PTR_MAYBE_NULL; | |
| 6530 | + | |
| 6528 | 6531 | if (tgt_prog) { |
| 6529 | 6532 | enum bpf_prog_type tgt_type; |
| 6530 | 6533 | |
| @@ -354,12 +354,14 @@ static int cpu_map_kthread_run(void *data) · 353 unmodified lines | ||
| 354 | 354 | |
| 355 | 355 | list_add_tail(&skb->list, &list); |
| 356 | 356 | } |
| 357 | − netif_receive_skb_list(&list); | |
| 358 | 357 | |
| 359 | − /* Feedback loop via tracepoint */ | |
| 358 | + /* Feedback loop via tracepoint. | |
| 359 | + * NB: keep before recv to allow measuring enqueue/dequeue latency. | |
| 360 | + */ | |
| 360 | 361 | trace_xdp_cpumap_kthread(rcpu->map_id, n, kmem_alloc_drops, |
| 361 | 362 | sched, &stats); |
| 362 | 363 | |
| 364 | + netif_receive_skb_list(&list); | |
| 363 | 365 | local_bh_enable(); /* resched point, may call do_softirq() */ |
| 364 | 366 | } |
| 365 | 367 | __set_current_state(TASK_RUNNING); |
| @@ -28,6 +28,8 @@ · 27 unmodified lines | ||
| 28 | 28 | #include <linux/cpumask.h> |
| 29 | 29 | #include <linux/bpf_mem_alloc.h> |
| 30 | 30 | #include <net/xdp.h> |
| 31 | +#include <linux/trace_events.h> | |
| 32 | +#include <linux/kallsyms.h> | |
| 31 | 33 | |
| 32 | 34 | #include "disasm.h" |
| 33 | 35 | |
| @@ -21154,11 +21156,13 @@ int bpf_check_attach_target(struct bpf_verifier_log *log, · 21120 unmodified lines | ||
| 21154 | 21156 | { |
| 21155 | 21157 | bool prog_extension = prog->type == BPF_PROG_TYPE_EXT; |
| 21156 | 21158 | bool prog_tracing = prog->type == BPF_PROG_TYPE_TRACING; |
| 21159 | + char trace_symbol[KSYM_SYMBOL_LEN]; | |
| 21157 | 21160 | const char prefix[] = "btf_trace_"; |
| 21161 | + struct bpf_raw_event_map *btp; | |
| 21158 | 21162 | int ret = 0, subprog = -1, i; |
| 21159 | 21163 | const struct btf_type *t; |
| 21160 | 21164 | bool conservative = true; |
| 21161 | − const char *tname; | |
| 21165 | + const char *tname, *fname; | |
| 21162 | 21166 | struct btf *btf; |
| 21163 | 21167 | long addr = 0; |
| 21164 | 21168 | struct module *mod = NULL; |
| @@ -21289,10 +21293,34 @@ int bpf_check_attach_target(struct bpf_verifier_log *log, · 124 unmodified lines | ||
| 21289 | 21293 | return -EINVAL; |
| 21290 | 21294 | } |
| 21291 | 21295 | tname += sizeof(prefix) - 1; |
| 21292 | − t = btf_type_by_id(btf, t->type); | |
| 21293 | − if (!btf_type_is_ptr(t)) | |
| 21294 | − /* should never happen in valid vmlinux build */ | |
| 21296 | + | |
| 21297 | + /* The func_proto of "btf_trace_##tname" is generated from typedef without argument | |
| 21298 | + * names. Thus using bpf_raw_event_map to get argument names. | |
| 21299 | + */ | |
| 21300 | + btp = bpf_get_raw_tracepoint(tname); | |
| 21301 | + if (!btp) | |
| 21295 | 21302 | return -EINVAL; |
| 21303 | + fname = kallsyms_lookup((unsigned long)btp->bpf_func, NULL, NULL, NULL, | |
| 21304 | + trace_symbol); | |
| 21305 | + bpf_put_raw_tracepoint(btp); | |
| 21306 | + | |
| 21307 | + if (fname) | |
| 21308 | + ret = btf_find_by_name_kind(btf, fname, BTF_KIND_FUNC); | |
| 21309 | + | |
| 21310 | + if (!fname || ret < 0) { | |
| 21311 | + bpf_log(log, "Cannot find btf of tracepoint template, fall back to %s%s.\n", | |
| 21312 | + prefix, tname); | |
| 21313 | + t = btf_type_by_id(btf, t->type); | |
| 21314 | + if (!btf_type_is_ptr(t)) | |
| 21315 | + /* should never happen in valid vmlinux build */ | |
| 21316 | + return -EINVAL; | |
| 21317 | + } else { | |
| 21318 | + t = btf_type_by_id(btf, ret); | |
| 21319 | + if (!btf_type_is_func(t)) | |
| 21320 | + /* should never happen in valid vmlinux build */ | |
| 21321 | + return -EINVAL; | |
| 21322 | + } | |
| 21323 | + | |
| 21296 | 21324 | t = btf_type_by_id(btf, t->type); |
| 21297 | 21325 | if (!btf_type_is_func_proto(t)) |
| 21298 | 21326 | /* should never happen in valid vmlinux build */ |
| @@ -12063,7 +12063,7 @@ int bpf_dynptr_from_skb_rdonly(struct __sk_buff *skb, u64 flags, · 12062 unmodified lines | ||
| 12063 | 12063 | } |
| 12064 | 12064 | |
| 12065 | 12065 | BTF_KFUNCS_START(bpf_kfunc_check_set_skb) |
| 12066 | −BTF_ID_FLAGS(func, bpf_dynptr_from_skb) | |
| 12066 | +BTF_ID_FLAGS(func, bpf_dynptr_from_skb, KF_TRUSTED_ARGS) | |
| 12067 | 12067 | BTF_KFUNCS_END(bpf_kfunc_check_set_skb) |
| 12068 | 12068 | |
| 12069 | 12069 | BTF_KFUNCS_START(bpf_kfunc_check_set_xdp) |
| @@ -12112,6 +12112,7 @@ static int __init bpf_kfunc_init(void) · 42 unmodified lines | ||
| 12112 | 12112 | ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_LWT_XMIT, &bpf_kfunc_set_skb); |
| 12113 | 12113 | ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_LWT_SEG6LOCAL, &bpf_kfunc_set_skb); |
| 12114 | 12114 | ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_NETFILTER, &bpf_kfunc_set_skb); |
| 12115 | + ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_TRACING, &bpf_kfunc_set_skb); | |
| 12115 | 12116 | ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_XDP, &bpf_kfunc_set_xdp); |
| 12116 | 12117 | ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_CGROUP_SOCK_ADDR, |
| 12117 | 12118 | &bpf_kfunc_set_sock_addr); |
| @@ -293,7 +293,7 @@ out: · 292 unmodified lines | ||
| 293 | 293 | /* If we trim data a full sg elem before curr pointer update |
| 294 | 294 | * copybreak and current so that any future copy operations |
| 295 | 295 | * start at new copy location. |
| 296 | − * However trimed data that has not yet been used in a copy op | |
| 296 | + * However trimmed data that has not yet been used in a copy op | |
| 297 | 297 | * does not require an update. |
| 298 | 298 | */ |
| 299 | 299 | if (!msg->sg.size) { |
| @@ -1183,6 +1183,7 @@ static void sock_hash_free(struct bpf_map *map) · 1182 unmodified lines | ||
| 1183 | 1183 | sock_put(elem->sk); |
| 1184 | 1184 | sock_hash_free_elem(htab, elem); |
| 1185 | 1185 | } |
| 1186 | + cond_resched(); | |
| 1186 | 1187 | } |
| 1187 | 1188 | |
| 1188 | 1189 | /* wait for psock readers accessing its map link */ |
| @@ -30,7 +30,7 @@ void tcp_eat_skb(struct sock *sk, struct sk_buff *skb) · 29 unmodified lines | ||
| 30 | 30 | } |
| 31 | 31 | |
| 32 | 32 | static int bpf_tcp_ingress(struct sock *sk, struct sk_psock *psock, |
| 33 | − struct sk_msg *msg, u32 apply_bytes, int flags) | |
| 33 | + struct sk_msg *msg, u32 apply_bytes) | |
| 34 | 34 | { |
| 35 | 35 | bool apply = apply_bytes; |
| 36 | 36 | struct scatterlist *sge; |
| @@ -167,7 +167,7 @@ int tcp_bpf_sendmsg_redir(struct sock *sk, bool ingress, · 130 unmodified lines | ||
| 167 | 167 | if (unlikely(!psock)) |
| 168 | 168 | return -EPIPE; |
| 169 | 169 | |
| 170 | − ret = ingress ? bpf_tcp_ingress(sk, psock, msg, bytes, flags) : | |
| 170 | + ret = ingress ? bpf_tcp_ingress(sk, psock, msg, bytes) : | |
| 171 | 171 | tcp_bpf_push_locked(sk, msg, bytes, flags, false); |
| 172 | 172 | sk_psock_put(sk, psock); |
| 173 | 173 | return ret; |
| @@ -661,9 +661,17 @@ EXPORT_SYMBOL(xp_alloc_batch); · 660 unmodified lines | ||
| 661 | 661 | |
| 662 | 662 | bool xp_can_alloc(struct xsk_buff_pool *pool, u32 count) |
| 663 | 663 | { |
| 664 | + u32 req_count, avail_count; | |
| 665 | + | |
| 664 | 666 | if (pool->free_list_cnt >= count) |
| 665 | 667 | return true; |
| 666 | − return xskq_cons_has_entries(pool->fq, count - pool->free_list_cnt); | |
| 668 | + | |
| 669 | + req_count = count - pool->free_list_cnt; | |
| 670 | + avail_count = xskq_cons_nb_entries(pool->fq, req_count); | |
| 671 | + if (!avail_count) | |
| 672 | + pool->fq->queue_empty_descs++; | |
| 673 | + | |
| 674 | + return avail_count >= req_count; | |
| 667 | 675 | } |
| 668 | 676 | EXPORT_SYMBOL(xp_can_alloc); |
| 669 | 677 | |
| @@ -306,11 +306,6 @@ static inline u32 xskq_cons_nb_entries(struct xsk_queue *q, u32 max) · 305 unmodified lines | ||
| 306 | 306 | return entries >= max ? max : entries; |
| 307 | 307 | } |
| 308 | 308 | |
| 309 | −static inline bool xskq_cons_has_entries(struct xsk_queue *q, u32 cnt) | |
| 310 | −{ | |
| 311 | − return xskq_cons_nb_entries(q, cnt) >= cnt; | |
| 312 | −} | |
| 313 | − | |
| 314 | 309 | static inline bool xskq_cons_peek_addr_unchecked(struct xsk_queue *q, u64 *addr) |
| 315 | 310 | { |
| 316 | 311 | if (q->cached_prod == q->cached_cons) |
| @@ -34,6 +34,12 @@ DECLARE_TRACE(bpf_testmod_test_write_bare, · 33 unmodified lines | ||
| 34 | 34 | TP_ARGS(task, ctx) |
| 35 | 35 | ); |
| 36 | 36 | |
| 37 | +/* Used in bpf_testmod_test_read() to test __nullable suffix */ | |
| 38 | +DECLARE_TRACE(bpf_testmod_test_nullable_bare, | |
| 39 | + TP_PROTO(struct bpf_testmod_test_read_ctx *ctx__nullable), | |
| 40 | + TP_ARGS(ctx__nullable) | |
| 41 | +); | |
| 42 | + | |
| 37 | 43 | #undef BPF_TESTMOD_DECLARE_TRACE |
| 38 | 44 | #ifdef DECLARE_TRACE_WRITABLE |
| 39 | 45 | #define BPF_TESTMOD_DECLARE_TRACE(call, proto, args, size) \ |
| @@ -356,6 +356,8 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj, · 355 unmodified lines | ||
| 356 | 356 | if (bpf_testmod_loop_test(101) > 100) |
| 357 | 357 | trace_bpf_testmod_test_read(current, &ctx); |
| 358 | 358 | |
| 359 | + trace_bpf_testmod_test_nullable_bare(NULL); | |
| 360 | + | |
| 359 | 361 | /* Magic number to enable writable tp */ |
| 360 | 362 | if (len == 64) { |
| 361 | 363 | struct bpf_testmod_test_writable_ctx writable = { |
| @@ -9,6 +9,7 @@ · 8 unmodified lines | ||
| 9 | 9 | enum test_setup_type { |
| 10 | 10 | SETUP_SYSCALL_SLEEP, |
| 11 | 11 | SETUP_SKB_PROG, |
| 12 | + SETUP_SKB_PROG_TP, | |
| 12 | 13 | }; |
| 13 | 14 | |
| 14 | 15 | static struct { |
| @@ -28,6 +29,7 @@ static struct { · 13 unmodified lines | ||
| 28 | 29 | {"test_dynptr_clone", SETUP_SKB_PROG}, |
| 29 | 30 | {"test_dynptr_skb_no_buff", SETUP_SKB_PROG}, |
| 30 | 31 | {"test_dynptr_skb_strcmp", SETUP_SKB_PROG}, |
| 32 | + {"test_dynptr_skb_tp_btf", SETUP_SKB_PROG_TP}, | |
| 31 | 33 | }; |
| 32 | 34 | |
| 33 | 35 | static void verify_success(const char *prog_name, enum test_setup_type setup_type) |
| @@ -35,7 +37,7 @@ static void verify_success(const char *prog_name, enum test_setup_type setup_typ · 1 unmodified line | ||
| 35 | 37 | struct dynptr_success *skel; |
| 36 | 38 | struct bpf_program *prog; |
| 37 | 39 | struct bpf_link *link; |
| 38 | − int err; | |
| 40 | + int err; | |
| 39 | 41 | |
| 40 | 42 | skel = dynptr_success__open(); |
| 41 | 43 | if (!ASSERT_OK_PTR(skel, "dynptr_success__open")) |
| @@ -47,7 +49,7 @@ static void verify_success(const char *prog_name, enum test_setup_type setup_typ · 5 unmodified lines | ||
| 47 | 49 | if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name")) |
| 48 | 50 | goto cleanup; |
| 49 | 51 | |
| 50 | − bpf_program__set_autoload(prog, true); | |
| 52 | + bpf_program__set_autoload(prog, true); | |
| 51 | 53 | |
| 52 | 54 | err = dynptr_success__load(skel); |
| 53 | 55 | if (!ASSERT_OK(err, "dynptr_success__load")) |
| @@ -87,6 +89,37 @@ static void verify_success(const char *prog_name, enum test_setup_type setup_typ · 33 unmodified lines | ||
| 87 | 89 | |
| 88 | 90 | break; |
| 89 | 91 | } |
| 92 | + case SETUP_SKB_PROG_TP: | |
| 93 | + { | |
| 94 | + struct __sk_buff skb = {}; | |
| 95 | + struct bpf_object *obj; | |
| 96 | + int aux_prog_fd; | |
| 97 | + | |
| 98 | + /* Just use its test_run to trigger kfree_skb tracepoint */ | |
| 99 | + err = bpf_prog_test_load("./test_pkt_access.bpf.o", BPF_PROG_TYPE_SCHED_CLS, | |
| 100 | + &obj, &aux_prog_fd); | |
| 101 | + if (!ASSERT_OK(err, "prog_load sched cls")) | |
| 102 | + goto cleanup; | |
| 103 | + | |
| 104 | + LIBBPF_OPTS(bpf_test_run_opts, topts, | |
| 105 | + .data_in = &pkt_v4, | |
| 106 | + .data_size_in = sizeof(pkt_v4), | |
| 107 | + .ctx_in = &skb, | |
| 108 | + .ctx_size_in = sizeof(skb), | |
| 109 | + ); | |
| 110 | + | |
| 111 | + link = bpf_program__attach(prog); | |
| 112 | + if (!ASSERT_OK_PTR(link, "bpf_program__attach")) | |
| 113 | + goto cleanup; | |
| 114 | + | |
| 115 | + err = bpf_prog_test_run_opts(aux_prog_fd, &topts); | |
| 116 | + bpf_link__destroy(link); | |
| 117 | + | |
| 118 | + if (!ASSERT_OK(err, "test_run")) | |
| 119 | + goto cleanup; | |
| 120 | + | |
| 121 | + break; | |
| 122 | + } | |
| 90 | 123 | } |
| 91 | 124 | |
| 92 | 125 | ASSERT_EQ(skel->bss->err, 0, "err"); |
| @@ -0,0 +1,14 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | + | |
| 3 | +#include <test_progs.h> | |
| 4 | +#include "test_tp_btf_nullable.skel.h" | |
| 5 | + | |
| 6 | +void test_tp_btf_nullable(void) | |
| 7 | +{ | |
| 8 | + if (!env.has_testmod) { | |
| 9 | + test__skip(); | |
| 10 | + return; | |
| 11 | + } | |
| 12 | + | |
| 13 | + RUN_TESTS(test_tp_btf_nullable); | |
| 14 | +} | |
| @@ -6,6 +6,7 @@ · 5 unmodified lines | ||
| 6 | 6 | #include <stdbool.h> |
| 7 | 7 | #include <linux/bpf.h> |
| 8 | 8 | #include <bpf/bpf_helpers.h> |
| 9 | +#include <bpf/bpf_tracing.h> | |
| 9 | 10 | #include <linux/if_ether.h> |
| 10 | 11 | #include "bpf_misc.h" |
| 11 | 12 | #include "bpf_kfuncs.h" |
| @@ -1254,6 +1255,30 @@ int skb_invalid_ctx(void *ctx) · 1242 unmodified lines | ||
| 1254 | 1255 | return 0; |
| 1255 | 1256 | } |
| 1256 | 1257 | |
| 1258 | +SEC("fentry/skb_tx_error") | |
| 1259 | +__failure __msg("must be referenced or trusted") | |
| 1260 | +int BPF_PROG(skb_invalid_ctx_fentry, void *skb) | |
| 1261 | +{ | |
| 1262 | + struct bpf_dynptr ptr; | |
| 1263 | + | |
| 1264 | + /* this should fail */ | |
| 1265 | + bpf_dynptr_from_skb(skb, 0, &ptr); | |
| 1266 | + | |
| 1267 | + return 0; | |
| 1268 | +} | |
| 1269 | + | |
| 1270 | +SEC("fexit/skb_tx_error") | |
| 1271 | +__failure __msg("must be referenced or trusted") | |
| 1272 | +int BPF_PROG(skb_invalid_ctx_fexit, void *skb) | |
| 1273 | +{ | |
| 1274 | + struct bpf_dynptr ptr; | |
| 1275 | + | |
| 1276 | + /* this should fail */ | |
| 1277 | + bpf_dynptr_from_skb(skb, 0, &ptr); | |
| 1278 | + | |
| 1279 | + return 0; | |
| 1280 | +} | |
| 1281 | + | |
| 1257 | 1282 | /* Reject writes to dynptr slot for uninit arg */ |
| 1258 | 1283 | SEC("?raw_tp") |
| 1259 | 1284 | __failure __msg("potential write to dynptr at off=-16") |
| @@ -5,6 +5,7 @@ · 4 unmodified lines | ||
| 5 | 5 | #include <stdbool.h> |
| 6 | 6 | #include <linux/bpf.h> |
| 7 | 7 | #include <bpf/bpf_helpers.h> |
| 8 | +#include <bpf/bpf_tracing.h> | |
| 8 | 9 | #include "bpf_misc.h" |
| 9 | 10 | #include "bpf_kfuncs.h" |
| 10 | 11 | #include "errno.h" |
| @@ -544,3 +545,25 @@ int test_dynptr_skb_strcmp(struct __sk_buff *skb) · 533 unmodified lines | ||
| 544 | 545 | |
| 545 | 546 | return 1; |
| 546 | 547 | } |
| 548 | + | |
| 549 | +SEC("tp_btf/kfree_skb") | |
| 550 | +int BPF_PROG(test_dynptr_skb_tp_btf, void *skb, void *location) | |
| 551 | +{ | |
| 552 | + __u8 write_data[2] = {1, 2}; | |
| 553 | + struct bpf_dynptr ptr; | |
| 554 | + int ret; | |
| 555 | + | |
| 556 | + if (bpf_dynptr_from_skb(skb, 0, &ptr)) { | |
| 557 | + err = 1; | |
| 558 | + return 1; | |
| 559 | + } | |
| 560 | + | |
| 561 | + /* since tp_btf skbs are read only, writes should fail */ | |
| 562 | + ret = bpf_dynptr_write(&ptr, 0, write_data, sizeof(write_data), 0); | |
| 563 | + if (ret != -EINVAL) { | |
| 564 | + err = 2; | |
| 565 | + return 1; | |
| 566 | + } | |
| 567 | + | |
| 568 | + return 1; | |
| 569 | +} | |
| @@ -0,0 +1,24 @@ | ||
| 1 | +// SPDX-License-Identifier: GPL-2.0 | |
| 2 | + | |
| 3 | +#include "vmlinux.h" | |
| 4 | +#include <bpf/bpf_helpers.h> | |
| 5 | +#include <bpf/bpf_tracing.h> | |
| 6 | +#include "../bpf_testmod/bpf_testmod.h" | |
| 7 | +#include "bpf_misc.h" | |
| 8 | + | |
| 9 | +SEC("tp_btf/bpf_testmod_test_nullable_bare") | |
| 10 | +__failure __msg("R1 invalid mem access 'trusted_ptr_or_null_'") | |
| 11 | +int BPF_PROG(handle_tp_btf_nullable_bare1, struct bpf_testmod_test_read_ctx *nullable_ctx) | |
| 12 | +{ | |
| 13 | + return nullable_ctx->len; | |
| 14 | +} | |
| 15 | + | |
| 16 | +SEC("tp_btf/bpf_testmod_test_nullable_bare") | |
| 17 | +int BPF_PROG(handle_tp_btf_nullable_bare2, struct bpf_testmod_test_read_ctx *nullable_ctx) | |
| 18 | +{ | |
| 19 | + if (nullable_ctx) | |
| 20 | + return nullable_ctx->len; | |
| 21 | + return 0; | |
| 22 | +} | |
| 23 | + | |
| 24 | +char _license[] SEC("license") = "GPL"; | |
| @@ -324,6 +324,25 @@ out: · 323 unmodified lines | ||
| 324 | 324 | return zc_avail; |
| 325 | 325 | } |
| 326 | 326 | |
| 327 | +#define MAX_SKB_FRAGS_PATH "/proc/sys/net/core/max_skb_frags" | |
| 328 | +static unsigned int get_max_skb_frags(void) | |
| 329 | +{ | |
| 330 | + unsigned int max_skb_frags = 0; | |
| 331 | + FILE *file; | |
| 332 | + | |
| 333 | + file = fopen(MAX_SKB_FRAGS_PATH, "r"); | |
| 334 | + if (!file) { | |
| 335 | + ksft_print_msg("Error opening %s\n", MAX_SKB_FRAGS_PATH); | |
| 336 | + return 0; | |
| 337 | + } | |
| 338 | + | |
| 339 | + if (fscanf(file, "%u", &max_skb_frags) != 1) | |
| 340 | + ksft_print_msg("Error reading %s\n", MAX_SKB_FRAGS_PATH); | |
| 341 | + | |
| 342 | + fclose(file); | |
| 343 | + return max_skb_frags; | |
| 344 | +} | |
| 345 | + | |
| 327 | 346 | static struct option long_options[] = { |
| 328 | 347 | {"interface", required_argument, 0, 'i'}, |
| 329 | 348 | {"busy-poll", no_argument, 0, 'b'}, |
| @@ -2244,13 +2263,24 @@ static int testapp_poll_rxq_tmout(struct test_spec *test) · 1914 unmodified lines | ||
| 2244 | 2263 | |
| 2245 | 2264 | static int testapp_too_many_frags(struct test_spec *test) |
| 2246 | 2265 | { |
| 2247 | − struct pkt pkts[2 * XSK_DESC__MAX_SKB_FRAGS + 2] = {}; | |
| 2266 | + struct pkt *pkts; | |
| 2248 | 2267 | u32 max_frags, i; |
| 2268 | + int ret; | |
| 2249 | 2269 | |
| 2250 | − if (test->mode == TEST_MODE_ZC) | |
| 2270 | + if (test->mode == TEST_MODE_ZC) { | |
| 2251 | 2271 | max_frags = test->ifobj_tx->xdp_zc_max_segs; |
| 2252 | − else | |
| 2253 | − max_frags = XSK_DESC__MAX_SKB_FRAGS; | |
| 2272 | + } else { | |
| 2273 | + max_frags = get_max_skb_frags(); | |
| 2274 | + if (!max_frags) { | |
| 2275 | + ksft_print_msg("Couldn't retrieve MAX_SKB_FRAGS from system, using default (17) value\n"); | |
| 2276 | + max_frags = 17; | |
| 2277 | + } | |
| 2278 | + max_frags += 1; | |
| 2279 | + } | |
| 2280 | + | |
| 2281 | + pkts = calloc(2 * max_frags + 2, sizeof(struct pkt)); | |
| 2282 | + if (!pkts) | |
| 2283 | + return TEST_FAILURE; | |
| 2254 | 2284 | |
| 2255 | 2285 | test->mtu = MAX_ETH_JUMBO_SIZE; |
| 2256 | 2286 | |
| @@ -2280,7 +2310,10 @@ static int testapp_too_many_frags(struct test_spec *test) · 23 unmodified lines | ||
| 2280 | 2310 | pkts[2 * max_frags + 1].valid = true; |
| 2281 | 2311 | |
| 2282 | 2312 | pkt_stream_generate_custom(test, pkts, 2 * max_frags + 2); |
| 2283 | − return testapp_validate_traffic(test); | |
| 2313 | + ret = testapp_validate_traffic(test); | |
| 2314 | + | |
| 2315 | + free(pkts); | |
| 2316 | + return ret; | |
| 2284 | 2317 | } |
| 2285 | 2318 | |
| 2286 | 2319 | static int xsk_load_xdp_programs(struct ifobject *ifobj) |
| @@ -55,7 +55,6 @@ · 54 unmodified lines | ||
| 55 | 55 | #define XSK_UMEM__LARGE_FRAME_SIZE (3 * 1024) |
| 56 | 56 | #define XSK_UMEM__MAX_FRAME_SIZE (4 * 1024) |
| 57 | 57 | #define XSK_DESC__INVALID_OPTION (0xffff) |
| 58 | −#define XSK_DESC__MAX_SKB_FRAGS 18 | |
| 59 | 58 | #define HUGEPAGE_SIZE (2 * 1024 * 1024) |
| 60 | 59 | #define PKT_DUMP_NB_TO_PRINT 16 |
| 61 | 60 | #define RUN_ALL_TESTS UINT_MAX |