diff --git a/patches.suse/bpf-Clear-skb-tstamp-in-bpf_redirect-when-necessary.patch b/patches.suse/bpf-Clear-skb-tstamp-in-bpf_redirect-when-necessary.patch new file mode 100644 index 0000000..4e2e4c0 --- /dev/null +++ b/patches.suse/bpf-Clear-skb-tstamp-in-bpf_redirect-when-necessary.patch @@ -0,0 +1,34 @@ +From: Lorenz Bauer +Date: Fri, 13 Dec 2019 18:08:17 +0000 +Subject: bpf: Clear skb->tstamp in bpf_redirect when necessary +Patch-mainline: v5.5-rc3 +Git-commit: 5133498f4ad1123a5ffd4c08df6431dab882cc32 +References: bsc#1155518 + +Redirecting a packet from ingress to egress by using bpf_redirect +breaks if the egress interface has an fq qdisc installed. This is the same +problem as fixed in 'commit 8203e2d844d3 ("net: clear skb->tstamp in forwarding paths") + +Clear skb->tstamp when redirecting into the egress path. + +Fixes: 80b14dee2bea ("net: Add a new socket option for a future transmit time.") +Fixes: fb420d5d91c1 ("tcp/fq: move back to CLOCK_MONOTONIC") +Signed-off-by: Lorenz Bauer +Signed-off-by: Alexei Starovoitov +Reviewed-by: Eric Dumazet +Link: https://lore.kernel.org/bpf/20191213180817.2510-1-lmb@cloudflare.com +Acked-by: Gary Lin +--- + net/core/filter.c | 1 + + 1 file changed, 1 insertion(+) + +--- a/net/core/filter.c ++++ b/net/core/filter.c +@@ -2055,6 +2055,7 @@ static inline int __bpf_tx_skb(struct ne + } + + skb->dev = dev; ++ skb->tstamp = 0; + + dev_xmit_recursion_inc(); + ret = dev_queue_xmit(skb); diff --git a/patches.suse/bpf-Compare-BTF-types-of-functions-arguments-with-ac.patch b/patches.suse/bpf-Compare-BTF-types-of-functions-arguments-with-ac.patch index 1130b04..2e7a4d5 100644 --- a/patches.suse/bpf-Compare-BTF-types-of-functions-arguments-with-ac.patch +++ b/patches.suse/bpf-Compare-BTF-types-of-functions-arguments-with-ac.patch @@ -75,8 +75,8 @@ Acked-by: Thomas Bogendoerfer u16 stack_depth; /* max. stack depth used by this function */ --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c -@@ -3985,6 +3985,88 @@ int btf_resolve_helper_id(struct bpf_ver - return ret; +@@ -3985,6 +3985,88 @@ int btf_distill_func_proto(struct bpf_ve + return 0; } +int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog) diff --git a/patches.suse/bpf-Fix-race-in-btf_resolve_helper_id.patch b/patches.suse/bpf-Fix-race-in-btf_resolve_helper_id.patch index 22b2e4b..48e2616 100644 --- a/patches.suse/bpf-Fix-race-in-btf_resolve_helper_id.patch +++ b/patches.suse/bpf-Fix-race-in-btf_resolve_helper_id.patch @@ -57,8 +57,8 @@ Acked-by: Gary Lin { char fnname[KSYM_SYMBOL_LEN + 4] = "btf_"; const struct btf_param *args; -@@ -3853,6 +3854,29 @@ int btf_distill_func_proto(struct bpf_ve - return 0; +@@ -3789,6 +3790,29 @@ u32 btf_resolve_helper_id(struct bpf_ver + return btf_id; } +int btf_resolve_helper_id(struct bpf_verifier_log *log, @@ -84,8 +84,8 @@ Acked-by: Gary Lin + return ret; +} + - void btf_type_seq_show(const struct btf *btf, u32 type_id, void *obj, - struct seq_file *m) + static int __get_type_size(struct btf *btf, u32 btf_id, + const struct btf_type **bad_type) { --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c diff --git a/patches.suse/bpf-riscv-Limit-to-33-tail-calls.patch b/patches.suse/bpf-riscv-Limit-to-33-tail-calls.patch new file mode 100644 index 0000000..a4c0576 --- /dev/null +++ b/patches.suse/bpf-riscv-Limit-to-33-tail-calls.patch @@ -0,0 +1,49 @@ +From: Paul Chaignon +Date: Mon, 9 Dec 2019 19:52:07 +0100 +Subject: bpf, riscv: Limit to 33 tail calls +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit +Patch-mainline: v5.5-rc3 +Git-commit: 96bc4432f5ade1045521f3b247f516b1478166bd +References: bsc#1155518 + +All BPF JIT compilers except RISC-V's and MIPS' enforce a 33-tail calls +limit at runtime. In addition, a test was recently added, in tailcalls2, +to check this limit. + +This patch updates the tail call limit in RISC-V's JIT compiler to allow +33 tail calls. I tested it using the above selftest on an emulated +RISCV64. + +Fixes: 2353ecc6f91f ("bpf, riscv: add BPF JIT for RV64G") +Reported-by: Mahshid Khezri +Signed-off-by: Paul Chaignon +Signed-off-by: Daniel Borkmann +Acked-by: Björn Töpel +Acked-by: Martin KaFai Lau +Link: https://lore.kernel.org/bpf/966fe384383bf23a0ee1efe8d7291c78a3fb832b.1575916815.git.paul.chaignon@gmail.com +Acked-by: Gary Lin +--- + arch/riscv/net/bpf_jit_comp.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/arch/riscv/net/bpf_jit_comp.c ++++ b/arch/riscv/net/bpf_jit_comp.c +@@ -631,14 +631,14 @@ static int emit_bpf_tail_call(int insn, + return -1; + emit(rv_bgeu(RV_REG_A2, RV_REG_T1, off >> 1), ctx); + +- /* if (--TCC < 0) ++ /* if (TCC-- < 0) + * goto out; + */ + emit(rv_addi(RV_REG_T1, tcc, -1), ctx); + off = (tc_ninsn - (ctx->ninsns - start_insn)) << 2; + if (is_13b_check(off, insn)) + return -1; +- emit(rv_blt(RV_REG_T1, RV_REG_ZERO, off >> 1), ctx); ++ emit(rv_blt(tcc, RV_REG_ZERO, off >> 1), ctx); + + /* prog = array->ptrs[index]; + * if (!prog) diff --git a/patches.suse/bpftool-Don-t-crash-on-missing-jited-insns-or-ksyms.patch b/patches.suse/bpftool-Don-t-crash-on-missing-jited-insns-or-ksyms.patch new file mode 100644 index 0000000..961a6f6 --- /dev/null +++ b/patches.suse/bpftool-Don-t-crash-on-missing-jited-insns-or-ksyms.patch @@ -0,0 +1,52 @@ +From: =?UTF-8?q?Toke=20H=C3=B8iland-J=C3=B8rgensen?= +Date: Tue, 10 Dec 2019 19:14:12 +0100 +Subject: bpftool: Don't crash on missing jited insns or ksyms +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit +Patch-mainline: v5.5-rc3 +Git-commit: 5b79bcdf03628a3a9ee04d9cd5fabcf61a8e20be +References: bsc#1155518 + +When the kptr_restrict sysctl is set, the kernel can fail to return +jited_ksyms or jited_prog_insns, but still have positive values in +nr_jited_ksyms and jited_prog_len. This causes bpftool to crash when +trying to dump the program because it only checks the len fields not +the actual pointers to the instructions and ksyms. + +Fix this by adding the missing checks. + +Fixes: 71bb428fe2c1 ("tools: bpf: add bpftool") +Fixes: f84192ee00b7 ("tools: bpftool: resolve calls without using imm field") +Signed-off-by: Toke Høiland-Jørgensen +Signed-off-by: Daniel Borkmann +Acked-by: Martin KaFai Lau +Link: https://lore.kernel.org/bpf/20191210181412.151226-1-toke@redhat.com +Acked-by: Gary Lin +--- + tools/bpf/bpftool/prog.c | 2 +- + tools/bpf/bpftool/xlated_dumper.c | 2 +- + 2 files changed, 2 insertions(+), 2 deletions(-) + +--- a/tools/bpf/bpftool/prog.c ++++ b/tools/bpf/bpftool/prog.c +@@ -493,7 +493,7 @@ static int do_dump(int argc, char **argv + + info = &info_linear->info; + if (mode == DUMP_JITED) { +- if (info->jited_prog_len == 0) { ++ if (info->jited_prog_len == 0 || !info->jited_prog_insns) { + p_info("no instructions returned"); + goto err_free; + } +--- a/tools/bpf/bpftool/xlated_dumper.c ++++ b/tools/bpf/bpftool/xlated_dumper.c +@@ -174,7 +174,7 @@ static const char *print_call(void *priv + struct kernel_sym *sym; + + if (insn->src_reg == BPF_PSEUDO_CALL && +- (__u32) insn->imm < dd->nr_jited_ksyms) ++ (__u32) insn->imm < dd->nr_jited_ksyms && dd->jited_ksyms) + address = dd->jited_ksyms[insn->imm]; + + sym = kernel_syms_search(dd, address); diff --git a/patches.suse/libbpf-Make-global-data-internal-arrays-mmap-able-if.patch b/patches.suse/libbpf-Make-global-data-internal-arrays-mmap-able-if.patch new file mode 100644 index 0000000..9118aa1 --- /dev/null +++ b/patches.suse/libbpf-Make-global-data-internal-arrays-mmap-able-if.patch @@ -0,0 +1,91 @@ +From: Andrii Nakryiko +Date: Sun, 17 Nov 2019 09:28:05 -0800 +Subject: libbpf: Make global data internal arrays mmap()-able, if possible +Patch-mainline: v5.5-rc1 +Git-commit: 7fe74b436236b17ac57e46527166d22bcc230175 +References: bsc#1155518 + +Add detection of BPF_F_MMAPABLE flag support for arrays and add it as an extra +flag to internal global data maps, if supported by kernel. This allows users +to memory-map global data and use it without BPF map operations, greatly +simplifying user experience. + +Signed-off-by: Andrii Nakryiko +Signed-off-by: Daniel Borkmann +Acked-by: Song Liu +Acked-by: John Fastabend +Link: https://lore.kernel.org/bpf/20191117172806.2195367-5-andriin@fb.com +Acked-by: Gary Lin +--- + tools/lib/bpf/libbpf.c | 32 ++++++++++++++++++++++++++++++-- + 1 file changed, 30 insertions(+), 2 deletions(-) + +--- a/tools/lib/bpf/libbpf.c ++++ b/tools/lib/bpf/libbpf.c +@@ -142,6 +142,8 @@ struct bpf_capabilities { + __u32 btf_func:1; + /* BTF_KIND_VAR and BTF_KIND_DATASEC support */ + __u32 btf_datasec:1; ++ /* BPF_F_MMAPABLE is supported for arrays */ ++ __u32 array_mmap:1; + }; + + /* +@@ -857,8 +859,6 @@ bpf_object__init_internal_map(struct bpf + pr_warning("failed to alloc map name\n"); + return -ENOMEM; + } +- pr_debug("map '%s' (global data): at sec_idx %d, offset %zu.\n", +- map_name, map->sec_idx, map->sec_offset); + + def = &map->def; + def->type = BPF_MAP_TYPE_ARRAY; +@@ -866,6 +866,12 @@ bpf_object__init_internal_map(struct bpf + def->value_size = data->d_size; + def->max_entries = 1; + def->map_flags = type == LIBBPF_MAP_RODATA ? BPF_F_RDONLY_PROG : 0; ++ if (obj->caps.array_mmap) ++ def->map_flags |= BPF_F_MMAPABLE; ++ ++ pr_debug("map '%s' (global data): at sec_idx %d, offset %zu, flags %x.\n", ++ map_name, map->sec_idx, map->sec_offset, def->map_flags); ++ + if (data_buff) { + *data_buff = malloc(data->d_size); + if (!*data_buff) { +@@ -2163,6 +2169,27 @@ static int bpf_object__probe_btf_datasec + return 0; + } + ++static int bpf_object__probe_array_mmap(struct bpf_object *obj) ++{ ++ struct bpf_create_map_attr attr = { ++ .map_type = BPF_MAP_TYPE_ARRAY, ++ .map_flags = BPF_F_MMAPABLE, ++ .key_size = sizeof(int), ++ .value_size = sizeof(int), ++ .max_entries = 1, ++ }; ++ int fd; ++ ++ fd = bpf_create_map_xattr(&attr); ++ if (fd >= 0) { ++ obj->caps.array_mmap = 1; ++ close(fd); ++ return 1; ++ } ++ ++ return 0; ++} ++ + static int + bpf_object__probe_caps(struct bpf_object *obj) + { +@@ -2171,6 +2198,7 @@ bpf_object__probe_caps(struct bpf_object + bpf_object__probe_global_data, + bpf_object__probe_btf_func, + bpf_object__probe_btf_datasec, ++ bpf_object__probe_array_mmap, + }; + int i, ret; + diff --git a/patches.suse/samples-bpf-Replace-symbol-compare-of-trace_event.patch b/patches.suse/samples-bpf-Replace-symbol-compare-of-trace_event.patch new file mode 100644 index 0000000..1eaff13 --- /dev/null +++ b/patches.suse/samples-bpf-Replace-symbol-compare-of-trace_event.patch @@ -0,0 +1,38 @@ +From: "Daniel T. Lee" +Date: Thu, 5 Dec 2019 17:01:13 +0900 +Subject: samples: bpf: Replace symbol compare of trace_event +Patch-mainline: v5.5-rc3 +Git-commit: bba1b2a890253528c45aa66cf856f289a215bfbc +References: bsc#1155518 + +Previously, when this sample is added, commit 1c47910ef8013 +("samples/bpf: add perf_event+bpf example"), a symbol 'sys_read' and +'sys_write' has been used without no prefixes. But currently there are +no exact symbols with these under kallsyms and this leads to failure. + +This commit changes exact compare to substring compare to keep compatible +with exact symbol or prefixed symbol. + +Fixes: 1c47910ef8013 ("samples/bpf: add perf_event+bpf example") +Signed-off-by: Daniel T. Lee +Signed-off-by: Alexei Starovoitov +Link: https://lore.kernel.org/bpf/20191205080114.19766-2-danieltimlee@gmail.com +Acked-by: Gary Lin +--- + samples/bpf/trace_event_user.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/samples/bpf/trace_event_user.c ++++ b/samples/bpf/trace_event_user.c +@@ -37,9 +37,9 @@ static void print_ksym(__u64 addr) + } + + printf("%s;", sym->name); +- if (!strcmp(sym->name, "sys_read")) ++ if (!strstr(sym->name, "sys_read")) + sys_read_seen = true; +- else if (!strcmp(sym->name, "sys_write")) ++ else if (!strstr(sym->name, "sys_write")) + sys_write_seen = true; + } + diff --git a/patches.suse/samples-bpf-fix-syscall_tp-due-to-unused-syscall.patch b/patches.suse/samples-bpf-fix-syscall_tp-due-to-unused-syscall.patch new file mode 100644 index 0000000..8788a0f --- /dev/null +++ b/patches.suse/samples-bpf-fix-syscall_tp-due-to-unused-syscall.patch @@ -0,0 +1,55 @@ +From: "Daniel T. Lee" +Date: Thu, 5 Dec 2019 17:01:14 +0900 +Subject: samples: bpf: fix syscall_tp due to unused syscall +Patch-mainline: v5.5-rc3 +Git-commit: fe3300897cbfd76c6cb825776e5ac0ca50a91ca4 +References: bsc#1155518 + +Currently, open() is called from the user program and it calls the syscall +'sys_openat', not the 'sys_open'. This leads to an error of the program +of user side, due to the fact that the counter maps are zero since no +function such 'sys_open' is called. + +This commit adds the kernel bpf program which are attached to the +tracepoint 'sys_enter_openat' and 'sys_enter_openat'. + +Fixes: 1da236b6be963 ("bpf: add a test case for syscalls/sys_{enter|exit}_* tracepoints") +Signed-off-by: Daniel T. Lee +Signed-off-by: Alexei Starovoitov +Acked-by: Gary Lin +--- + samples/bpf/syscall_tp_kern.c | 18 ++++++++++++++++-- + 1 file changed, 16 insertions(+), 2 deletions(-) + +--- a/samples/bpf/syscall_tp_kern.c ++++ b/samples/bpf/syscall_tp_kern.c +@@ -47,13 +47,27 @@ static __always_inline void count(void * + SEC("tracepoint/syscalls/sys_enter_open") + int trace_enter_open(struct syscalls_enter_open_args *ctx) + { +- count((void *)&enter_open_map); ++ count(&enter_open_map); ++ return 0; ++} ++ ++SEC("tracepoint/syscalls/sys_enter_openat") ++int trace_enter_open_at(struct syscalls_enter_open_args *ctx) ++{ ++ count(&enter_open_map); + return 0; + } + + SEC("tracepoint/syscalls/sys_exit_open") + int trace_enter_exit(struct syscalls_exit_open_args *ctx) + { +- count((void *)&exit_open_map); ++ count(&exit_open_map); ++ return 0; ++} ++ ++SEC("tracepoint/syscalls/sys_exit_openat") ++int trace_enter_exit_at(struct syscalls_exit_open_args *ctx) ++{ ++ count(&exit_open_map); + return 0; + } diff --git a/patches.suse/vfs-Convert-bpf-to-use-the-new-mount-API.patch b/patches.suse/vfs-Convert-bpf-to-use-the-new-mount-API.patch new file mode 100644 index 0000000..df15860 --- /dev/null +++ b/patches.suse/vfs-Convert-bpf-to-use-the-new-mount-API.patch @@ -0,0 +1,178 @@ +From: David Howells +Date: Fri, 22 Mar 2019 14:58:36 +0000 +Subject: vfs: Convert bpf to use the new mount API +Patch-mainline: v5.4-rc1 +Git-commit: d2935de7e4fd3f873976f1872b505584b727574c +References: bsc#1155518 + +Convert the bpf filesystem to the new internal mount API as the old +one will be obsoleted and removed. This allows greater flexibility in +communication of mount parameters between userspace, the VFS and the +filesystem. + +See Documentation/filesystems/mount_api.txt for more information. + +Signed-off-by: David Howells +cc: Alexei Starovoitov +cc: Daniel Borkmann +cc: Martin KaFai Lau +cc: Song Liu +cc: Yonghong Song +cc: netdev@vger.kernel.org +cc: bpf@vger.kernel.org +Signed-off-by: Al Viro +Acked-by: Gary Lin +--- + kernel/bpf/inode.c | 92 +++++++++++++++++++++++++++++++++-------------------- + 1 file changed, 58 insertions(+), 34 deletions(-) + +--- a/kernel/bpf/inode.c ++++ b/kernel/bpf/inode.c +@@ -14,8 +14,9 @@ + #include + #include + #include ++#include ++#include + #include +-#include + #include + #include + #include +@@ -583,58 +584,52 @@ static const struct super_operations bpf + + enum { + OPT_MODE, +- OPT_ERR, + }; + +-static const match_table_t bpf_mount_tokens = { +- { OPT_MODE, "mode=%o" }, +- { OPT_ERR, NULL }, ++static const struct fs_parameter_spec bpf_param_specs[] = { ++ fsparam_u32oct ("mode", OPT_MODE), ++ {} ++}; ++ ++static const struct fs_parameter_description bpf_fs_parameters = { ++ .name = "bpf", ++ .specs = bpf_param_specs, + }; + + struct bpf_mount_opts { + umode_t mode; + }; + +-static int bpf_parse_options(char *data, struct bpf_mount_opts *opts) ++static int bpf_parse_param(struct fs_context *fc, struct fs_parameter *param) + { +- substring_t args[MAX_OPT_ARGS]; +- int option, token; +- char *ptr; ++ struct bpf_mount_opts *opts = fc->fs_private; ++ struct fs_parse_result result; ++ int opt; + +- opts->mode = S_IRWXUGO; +- +- while ((ptr = strsep(&data, ",")) != NULL) { +- if (!*ptr) +- continue; +- +- token = match_token(ptr, bpf_mount_tokens, args); +- switch (token) { +- case OPT_MODE: +- if (match_octal(&args[0], &option)) +- return -EINVAL; +- opts->mode = option & S_IALLUGO; +- break; ++ opt = fs_parse(fc, &bpf_fs_parameters, param, &result); ++ if (opt < 0) + /* We might like to report bad mount options here, but + * traditionally we've ignored all mount options, so we'd + * better continue to ignore non-existing options for bpf. + */ +- } ++ return opt == -ENOPARAM ? 0 : opt; ++ ++ switch (opt) { ++ case OPT_MODE: ++ opts->mode = result.uint_32 & S_IALLUGO; ++ break; + } + + return 0; + } + +-static int bpf_fill_super(struct super_block *sb, void *data, int silent) ++static int bpf_fill_super(struct super_block *sb, struct fs_context *fc) + { + static const struct tree_descr bpf_rfiles[] = { { "" } }; +- struct bpf_mount_opts opts; ++ struct bpf_mount_opts *opts = fc->fs_private; + struct inode *inode; + int ret; + +- ret = bpf_parse_options(data, &opts); +- if (ret) +- return ret; +- + ret = simple_fill_super(sb, BPF_FS_MAGIC, bpf_rfiles); + if (ret) + return ret; +@@ -644,21 +639,50 @@ static int bpf_fill_super(struct super_b + inode = sb->s_root->d_inode; + inode->i_op = &bpf_dir_iops; + inode->i_mode &= ~S_IALLUGO; +- inode->i_mode |= S_ISVTX | opts.mode; ++ inode->i_mode |= S_ISVTX | opts->mode; + + return 0; + } + +-static struct dentry *bpf_mount(struct file_system_type *type, int flags, +- const char *dev_name, void *data) ++static int bpf_get_tree(struct fs_context *fc) ++{ ++ return get_tree_nodev(fc, bpf_fill_super); ++} ++ ++static void bpf_free_fc(struct fs_context *fc) + { +- return mount_nodev(type, flags, data, bpf_fill_super); ++ kfree(fc->fs_private); ++} ++ ++static const struct fs_context_operations bpf_context_ops = { ++ .free = bpf_free_fc, ++ .parse_param = bpf_parse_param, ++ .get_tree = bpf_get_tree, ++}; ++ ++/* ++ * Set up the filesystem mount context. ++ */ ++static int bpf_init_fs_context(struct fs_context *fc) ++{ ++ struct bpf_mount_opts *opts; ++ ++ opts = kzalloc(sizeof(struct bpf_mount_opts), GFP_KERNEL); ++ if (!opts) ++ return -ENOMEM; ++ ++ opts->mode = S_IRWXUGO; ++ ++ fc->fs_private = opts; ++ fc->ops = &bpf_context_ops; ++ return 0; + } + + static struct file_system_type bpf_fs_type = { + .owner = THIS_MODULE, + .name = "bpf", +- .mount = bpf_mount, ++ .init_fs_context = bpf_init_fs_context, ++ .parameters = &bpf_fs_parameters, + .kill_sb = kill_litter_super, + }; + diff --git a/series.conf b/series.conf index 47fbb30..5ae61d4 100644 --- a/series.conf +++ b/series.conf @@ -2995,6 +2995,7 @@ patches.suse/PCI-vmd-Fix-shadow-offsets-to-reflect-spec-changes.patch patches.suse/0001-video-backlight-Drop-default-m-for-LCD-BACKLIGHT_CLA.patch patches.suse/mfd-intel-lpss-Remove-D3cold-delay.patch + patches.suse/vfs-Convert-bpf-to-use-the-new-mount-API.patch patches.suse/hypfs-Fix-error-number-left-in-struct-pointer-member.patch patches.suse/msft-hv-1907-hv_balloon-Use-a-static-page-for-the-balloon_up-send.patch patches.suse/msft-hv-1908-hv_balloon-Reorganize-the-probe-function.patch @@ -5505,6 +5506,7 @@ patches.suse/bpf-Switch-bpf_map-ref-counter-to-atomic64_t-so-bpf_.patch patches.suse/bpf-Convert-bpf_prog-refcnt-to-atomic64_t.patch patches.suse/bpf-Add-mmap-support-for-BPF_MAP_TYPE_ARRAY.patch + patches.suse/libbpf-Make-global-data-internal-arrays-mmap-able-if.patch patches.suse/selftests-bpf-Add-BPF_TYPE_MAP_ARRAY-mmap-tests.patch patches.suse/selftests-bpf-xdping-is-not-meant-to-be-run-standalo.patch patches.suse/selftests-bpf-Fix-test_tc_tunnel-hanging.patch @@ -6774,8 +6776,13 @@ patches.suse/tpm-fix-invalid-locking-in-NONBLOCKING-mode.patch patches.suse/x86-mce-amd-allow-reserved-types-to-be-overwritten-in-smca_banks.patch patches.suse/x86-mce-fix-possibly-incorrect-severity-calculation-on-amd.patch + patches.suse/bpf-riscv-Limit-to-33-tail-calls.patch patches.suse/bpf-Fix-build-in-minimal-configurations-again.patch + patches.suse/bpftool-Don-t-crash-on-missing-jited-insns-or-ksyms.patch + patches.suse/samples-bpf-Replace-symbol-compare-of-trace_event.patch + patches.suse/samples-bpf-fix-syscall_tp-due-to-unused-syscall.patch patches.suse/net-ibmvnic-Fix-typo-in-retry-check.patch + patches.suse/bpf-Clear-skb-tstamp-in-bpf_redirect-when-necessary.patch patches.suse/bpf-Fix-missing-prog-untrack-in-release_maps.patch patches.suse/bpf-Fix-cgroup-local-storage-prog-tracking.patch patches.suse/bpf-Fix-record_func_key-to-perform-backtracking-on-r.patch