Lines Matching refs:name
217 * bpf_prog should be a better name but it has been used in
243 char *name;
335 char *name;
380 const char *name;
406 char name[BPF_OBJ_NAME_LEN];
440 size_t shstrndx; /* section index for section name strings */
481 static Elf_Scn *elf_sec_by_name(const struct bpf_object *obj, const char *name);
526 zfree(&prog->name);
539 char *name, *p;
541 name = p = strdup(prog->sec_name);
545 return name;
560 const char *name, size_t sec_idx, const char *sec_name,
565 sec_name, name, sec_off, insn_data_sz);
588 prog->name = strdup(name);
589 if (!prog->name)
603 pr_warn("sec '%s': failed to allocate memory for prog '%s'\n", sec_name, name);
616 const char *name;
632 name = elf_sym_str(obj, sym.st_name);
633 if (!name) {
634 pr_warn("sec '%s': failed to get symbol name for offset %zu\n",
646 sec_name, name, sec_off / BPF_INSN_SZ, sec_off, prog_sz / BPF_INSN_SZ, prog_sz);
656 sec_name, name);
663 err = bpf_object__init_prog(obj, prog, name, sec_idx, sec_name,
704 const char *name)
710 if (!strcmp(btf__name_by_offset(btf, m->name_off), name))
719 const char *name, __u32 kind);
809 map->name, st_ops->type_id, kern_type_id, kern_vtype_id);
836 map->name, mname);
844 map->name, mname);
860 map->name, mname, BTF_INFO_KIND(mtype->info),
882 map->name, mname);
892 map->name, mname, prog->name, moff,
902 map->name, mname, (ssize_t)msize,
908 map->name, mname, (unsigned int)msize,
990 map->name = strdup(var_name);
991 if (!map->name)
1046 strncpy(obj->name, obj_name, sizeof(obj->name) - 1);
1047 obj->name[sizeof(obj->name) - 1] = 0;
1050 strncpy(obj->name, basename((void *)path),
1051 sizeof(obj->name) - 1);
1052 end = strchr(obj->name, '.');
1229 int bpf_object__section_size(const struct bpf_object *obj, const char *name,
1235 if (!name) {
1237 } else if (!strcmp(name, DATA_SEC)) {
1240 } else if (!strcmp(name, BSS_SEC)) {
1243 } else if (!strcmp(name, RODATA_SEC)) {
1246 } else if (!strcmp(name, STRUCT_OPS_SEC)) {
1250 Elf_Scn *scn = elf_sec_by_name(obj, name);
1262 int bpf_object__variable_offset(const struct bpf_object *obj, const char *name,
1269 if (!name || !off)
1283 pr_warn("failed to get sym name string for var %s\n",
1284 name);
1287 if (strcmp(name, sname) == 0) {
1347 strlen(obj->name));
1349 snprintf(map_name, sizeof(map_name), "%.*s%.*s", pfx_len, obj->name,
1352 /* sanitise map name to characters allowed by kernel */
1375 map->name = internal_map_name(obj, type);
1376 if (!map->name) {
1377 pr_warn("failed to alloc map name\n");
1391 map->name, map->sec_idx, map->sec_offset, def->map_flags);
1399 map->name, err);
1400 zfree(&map->name);
1407 pr_debug("map %td is \"%s\"\n", map - obj->maps, map->name);
1449 const void *name)
1454 if (strcmp(obj->externs[i].name, name) == 0)
1467 ext->name, value);
1488 ext->name, value);
1501 pr_warn("extern (kcfg) %s=%s should be char array\n", ext->name, value);
1508 ext->name, value);
1516 ext->name, value, len, ext->kcfg.sz - 1);
1574 ext->name, (unsigned long long)value);
1579 ext->name, (unsigned long long)value, ext->kcfg.sz);
1643 ext->name, value);
1651 pr_debug("extern (kcfg) %s=%s\n", ext->name, value);
1770 * Count number of maps. Each map has a name.
1815 pr_warn("failed to get map #%d name sym string for obj %s\n",
1831 map->name = strdup(map_name);
1832 if (!map->name) {
1833 pr_warn("failed to alloc map name\n");
1836 pr_debug("map %d is \"%s\"\n", i, map->name);
1935 const char *name = btf__name_by_offset(btf, m->name_off);
1941 map_name, name, btf_kind_str(t));
1948 map_name, name, t->type);
1953 map_name, name, btf_kind_str(arr_t));
1992 const char *name = btf__name_by_offset(obj->btf, m->name_off);
1994 if (!name) {
1995 pr_warn("map '%s': invalid field #%d.\n", map->name, i);
1998 if (strcmp(name, "type") == 0) {
1999 if (!get_map_field_int(map->name, obj->btf, m,
2003 map->name, map->def.type);
2004 } else if (strcmp(name, "max_entries") == 0) {
2005 if (!get_map_field_int(map->name, obj->btf, m,
2009 map->name, map->def.max_entries);
2010 } else if (strcmp(name, "map_flags") == 0) {
2011 if (!get_map_field_int(map->name, obj->btf, m,
2015 map->name, map->def.map_flags);
2016 } else if (strcmp(name, "numa_node") == 0) {
2017 if (!get_map_field_int(map->name, obj->btf, m, &map->numa_node))
2019 pr_debug("map '%s': found numa_node = %u.\n", map->name, map->numa_node);
2020 } else if (strcmp(name, "key_size") == 0) {
2023 if (!get_map_field_int(map->name, obj->btf, m, &sz))
2026 map->name, sz);
2029 map->name, map->def.key_size, sz);
2033 } else if (strcmp(name, "key") == 0) {
2039 map->name, m->type);
2044 map->name, btf_kind_str(t));
2050 map->name, t->type, (ssize_t)sz);
2054 map->name, t->type, (ssize_t)sz);
2057 map->name, map->def.key_size, (ssize_t)sz);
2062 } else if (strcmp(name, "value_size") == 0) {
2065 if (!get_map_field_int(map->name, obj->btf, m, &sz))
2068 map->name, sz);
2071 map->name, map->def.value_size, sz);
2075 } else if (strcmp(name, "value") == 0) {
2081 map->name, m->type);
2086 map->name, btf_kind_str(t));
2092 map->name, t->type, (ssize_t)sz);
2096 map->name, t->type, (ssize_t)sz);
2099 map->name, map->def.value_size, (ssize_t)sz);
2105 else if (strcmp(name, "values") == 0) {
2110 map->name);
2115 map->name, name);
2120 map->name);
2125 map->name, map->def.value_size);
2132 map->name, m->type);
2137 map->name);
2144 map->name, btf_kind_str(t));
2150 map->name, btf_kind_str(t));
2158 map->inner_map->name = malloc(strlen(map->name) +
2160 if (!map->inner_map->name)
2162 sprintf(map->inner_map->name, "%s.inner", map->name);
2168 } else if (strcmp(name, "pinning") == 0) {
2174 map->name);
2177 if (!get_map_field_int(map->name, obj->btf, m, &val))
2180 map->name, val);
2185 map->name, val);
2192 map->name);
2199 map->name, name);
2203 map->name, name);
2208 pr_warn("map '%s': map type isn't specified.\n", map->name);
2233 pr_warn("map #%d: empty name.\n", var_idx);
2266 map->name = strdup(map_name);
2267 if (!map->name) {
2268 pr_warn("map '%s': failed to alloc map name.\n", map_name);
2288 const char *name;
2308 name = btf__name_by_offset(obj->btf, t->name_off);
2309 if (strcmp(name, MAPS_ELF_SEC) == 0) {
2400 char *name;
2402 name = (char *)btf__name_by_offset(btf, t->name_off);
2403 while (*name) {
2404 if (*name == '.')
2405 *name = '_';
2406 name++;
2415 /* preserve variable name as member name */
2619 const char *name;
2621 name = elf_strptr(obj->efile.elf, obj->efile.strtabidx, off);
2622 if (!name) {
2623 pr_warn("elf: failed to get section name string at offset %zu from %s: %s\n",
2628 return name;
2633 const char *name;
2635 name = elf_strptr(obj->efile.elf, obj->efile.shstrndx, off);
2636 if (!name) {
2637 pr_warn("elf: failed to get section name string at offset %zu from %s: %s\n",
2642 return name;
2658 static Elf_Scn *elf_sec_by_name(const struct bpf_object *obj, const char *name)
2669 if (strcmp(sec_name, name) != 0)
2693 const char *name;
2702 name = elf_sec_str(obj, sh.sh_name);
2703 if (!name) {
2704 pr_warn("elf: failed to get section(%zu) name from %s: %s\n",
2709 return name;
2750 static bool is_sec_name_dwarf(const char *name)
2753 return strncmp(name, ".debug_", sizeof(".debug_") - 1) == 0;
2756 static bool ignore_elf_section(GElf_Shdr *hdr, const char *name)
2768 strcmp(name, ".text") == 0)
2772 if (is_sec_name_dwarf(name))
2775 if (strncmp(name, ".rel", sizeof(".rel") - 1) == 0) {
2776 name += sizeof(".rel") - 1;
2778 if (is_sec_name_dwarf(name))
2782 if (strcmp(name, BTF_ELF_SEC) == 0 ||
2783 strcmp(name, BTF_EXT_ELF_SEC) == 0)
2808 const char *name;
2844 name = elf_sec_str(obj, sh.sh_name);
2845 if (!name)
2848 if (ignore_elf_section(&sh, name))
2856 idx, name, (unsigned long)data->d_size,
2860 if (strcmp(name, "license") == 0) {
2864 } else if (strcmp(name, "version") == 0) {
2868 } else if (strcmp(name, "maps") == 0) {
2870 } else if (strcmp(name, MAPS_ELF_SEC) == 0) {
2872 } else if (strcmp(name, BTF_ELF_SEC) == 0) {
2874 } else if (strcmp(name, BTF_EXT_ELF_SEC) == 0) {
2880 if (strcmp(name, ".text") == 0)
2882 err = bpf_object__add_programs(obj, data, name, idx);
2885 } else if (strcmp(name, DATA_SEC) == 0) {
2888 } else if (strcmp(name, RODATA_SEC) == 0) {
2891 } else if (strcmp(name, STRUCT_OPS_SEC) == 0) {
2896 idx, name);
2905 strcmp(name, ".rel" STRUCT_OPS_SEC) &&
2906 strcmp(name, ".rel" MAPS_ELF_SEC)) {
2908 idx, name, sec,
2923 } else if (sh.sh_type == SHT_NOBITS && strcmp(name, BSS_SEC) == 0) {
2927 pr_info("elf: skipping section(%d) %s (size %zu)\n", idx, name,
2937 /* sort BPF programs by section name and in-section instruction offset
3011 const char *name;
3014 name = btf__name_by_offset(btf, t->name_off);
3035 if (strcmp(name, "libbpf_tristate"))
3066 /* resolve ties by name */
3067 return strcmp(a->name, b->name);
3133 ext->name = btf__name_by_offset(obj->btf, t->name_off);
3182 /* sort externs by type, for kcfg ones also by (align, size, name) */
3199 pr_debug("extern (ksym) #%d: symbol %d, name %s\n",
3200 i, ext->sym_idx, ext->name);
3236 pr_debug("extern (kcfg) #%d: symbol %d, off %u, name %s\n",
3237 i, ext->sym_idx, ext->kcfg.data_off, ext->name);
3292 const char *name)
3299 if (!strcmp(prog->name, name))
3353 pr_warn("prog '%s': incorrect bpf_call opcode\n", prog->name);
3360 prog->name, sym_name, sym_sec_name);
3365 prog->name, sym_name, (size_t)sym->st_value);
3376 prog->name, sym_name, insn_idx, insn->code);
3392 prog->name, sym_name, sym_idx);
3396 prog->name, i, ext->name, ext->sym_idx, insn_idx);
3405 prog->name, sym_name, shdr_idx);
3416 prog->name, sym_name, sym_sec_name);
3426 prog->name, map_idx, map->name, map->sec_idx,
3432 prog->name, sym_sec_name, (size_t)sym->st_value);
3445 prog->name, sym_sec_name);
3453 prog->name, map_idx, map->name, map->sec_idx,
3459 prog->name, sym_sec_name);
3547 * will point to empty string (0), so fetch section name
3599 ret = btf__get_map_kv_tids(obj->btf, map->name, def->key_size,
3668 name_len = strlen(info.name);
3669 if (name_len == BPF_OBJ_NAME_LEN - 1 && strncmp(map->name, info.name, name_len) == 0)
3670 new_name = strdup(map->name);
3672 new_name = strdup(info.name);
3694 free(map->name);
3697 map->name = new_name;
3787 /* make sure loading with name works */
3794 attr.name = "test";
4024 "BPF program name", probe_kern_prog_name,
4152 map->name, cp);
4163 map->name, cp);
4181 create_attr.name = map->name;
4195 map->name, nr_cpus);
4198 pr_debug("map '%s': setting size to %d\n", map->name, nr_cpus);
4222 map->name, err);
4239 map->name, cp, err);
4274 map->name, i, targ_map->name,
4279 map->name, i, targ_map->name, fd);
4306 map->name);
4311 map->name);
4319 map->name, map->fd);
4326 map->name, map->fd);
4354 map->name, map->pin_path, err);
4364 pr_warn("map '%s': failed to create: %s(%d)\n", map->name, cp, err);
4377 const char *name; /* field name or NULL for array accessor */
4410 if (!acc->name || arr->nelems > 0)
4522 const char *name;
4570 /* record enumerator name in a first accessor */
4571 acc->name = btf__name_by_offset(btf, btf_enum(t)[access_idx].name_off);
4603 name = btf__name_by_offset(btf, m->name_off);
4604 if (str_is_empty(name))
4609 acc->name = name;
4646 /* check X___Y name pattern, where X and Y are not underscores */
4652 /* Given 'some_struct_name___with_flavor' return the length of a name prefix
4653 * before last triple underscore. Struct name part after last triple
4656 static size_t bpf_core_essential_name_len(const char *name)
4658 size_t n = strlen(name);
4662 if (bpf_core_is_flavor_sep(name + i))
4817 * desired name is found, check compatibility between local and target types,
4878 targ_acc->name = targ_name;
4899 * checked for name match. Beyond that initial root-level name check, names
5027 local_essent_len = bpf_core_essential_name_len(local_acc->name);
5034 if (strncmp(local_acc->name, targ_name, local_essent_len) == 0) {
5037 targ_acc->name = targ_name;
5056 if (local_acc->name) {
5090 targ_acc->name = NULL;
5133 if (!acc->name) {
5149 prog->name, relo->kind, relo->insn_off / 8);
5171 prog->name, relo->kind, relo->insn_off / 8);
5400 prog->name, relo_idx, core_relo_kind_str(relo->kind),
5415 prog->name, relo_idx, insn_idx);
5513 prog->name, relo_idx,
5520 prog->name, relo_idx, insn_idx,
5528 prog->name, relo_idx, insn_idx, insn->off, orig_val, new_val);
5533 prog->name, relo_idx, insn_idx, new_val);
5539 prog->name, relo_idx, insn_idx);
5546 prog->name, relo_idx, insn_idx, orig_val, new_val);
5554 prog->name, relo_idx, insn_idx, insn_bytes_sz, res->orig_sz);
5561 prog->name, relo_idx, insn_idx, res->new_sz);
5567 prog->name, relo_idx, insn_idx, res->orig_sz, res->new_sz);
5579 prog->name, relo_idx, insn_idx);
5586 prog->name, relo_idx,
5595 prog->name, relo_idx, insn_idx,
5601 prog->name, relo_idx, insn_idx, insn->code,
5610 * [<type-id>] (<type-name>) + <raw-spec> => <offset>@<spec>,
5641 if (spec->spec[i].name)
5642 libbpf_print(level, ".%s", spec->spec[i].name);
5680 * Candidate type is a type with the same "essential" name, ignoring
5691 * one different types with the same name. In that case, ___2, ___3, etc
5692 * are appended starting from second name conflict. But start flavors are
5696 * kernel versions, one can use two flavors of the struct name with the
5697 * same common name and use conditional relocations to extract that field,
5758 prog->name, relo_idx, local_id, btf_kind_str(local_type),
5764 pr_debug("prog '%s': relo #%d: kind <%s> (%d), spec is ", prog->name,
5781 prog->name, relo_idx, core_relo_kind_str(relo->kind), relo->kind);
5789 prog->name, relo_idx, local_id, btf_kind_str(local_type),
5805 prog->name, relo_idx, i);
5811 pr_debug("prog '%s': relo #%d: %s candidate #%d ", prog->name,
5831 prog->name, relo_idx, cand_spec.bit_offset,
5840 prog->name, relo_idx,
5873 prog->name, relo_idx);
5886 prog->name, relo_idx, relo->insn_off, err);
5932 * section index by section name, but we can find *any*
5933 * bpf_program within desired section name and use it's
5979 prog->name, i, err);
6047 prog->name, i, relo->type);
6150 prog->name, err);
6158 pr_warn("prog '%s': missing .BTF.ext function info.\n", prog->name);
6163 prog->name);
6178 prog->name, err);
6186 pr_warn("prog '%s': missing .BTF.ext line info.\n", prog->name);
6191 prog->name);
6234 prog->name, insn_idx, relo->type);
6260 prog->name);
6280 pr_warn("prog '%s': failed to realloc prog code\n", main_prog->name);
6290 main_prog->name, subprog->insns_cnt, subprog->name);
6312 prog->name, insn_idx, insn->imm, subprog->name, subprog->sub_insn_off);
6451 prog->name, err);
6471 prog->name, err);
6496 const char *name, *mname;
6521 name = elf_sym_str(obj, sym.st_name) ?: "<?>";
6524 i, name);
6528 pr_debug(".maps relo #%d: for %zd value %zd rel.r_offset %zu name %d ('%s')\n",
6530 (size_t)rel.r_offset, sym.st_name, name);
6544 i, name, (size_t)rel.r_offset);
6553 i, map->name, sizeof(int));
6557 targ_map = bpf_object__find_map_by_name(obj, name);
6594 i, map->name, moff, name);
6717 load_attr.name = prog->name;
6769 prog->name, cp);
6826 pr_warn("prog '%s': can't load after object was loaded\n", prog->name);
6842 prog->name);
6858 prog->name, prog->instances.nr);
6876 i, prog->name);
6882 i, prog->name);
6893 i, prog->name);
6903 pr_warn("failed to load program '%s'\n", prog->name);
6928 pr_debug("prog '%s': skipped loading\n", prog->name);
7072 const char *name)
7075 .object_name = name,
7187 id = btf__find_by_name_kind(obj->btf_vmlinux, ext->name,
7191 ext->name);
7219 ext->name, local_type_id,
7228 ext->name, id, btf_kind_str(targ_var), targ_var_name);
7252 strcmp(ext->name, "LINUX_KERNEL_VERSION") == 0) {
7263 pr_debug("extern (kcfg) %s=0x%x\n", ext->name, kver);
7265 strncmp(ext->name, "CONFIG_", 7) == 0) {
7273 pr_warn("unrecognized extern '%s'\n", ext->name);
7309 pr_warn("extern %s (strong) not resolved\n", ext->name);
7313 ext->name);
7332 pr_warn("object '%s': load can't be attempted twice\n", obj->name);
7448 instance, prog->name, prog->instances.nr);
7479 instance, prog->name, prog->instances.nr);
7509 pr_warn("no instances of prog %s to pin\n", prog->name);
7571 pr_warn("no instances of prog %s to pin\n", prog->name);
7945 zfree(&map->name);
8008 return obj ? obj->name : ERR_PTR(-EINVAL);
8115 return prog->name;
8200 n, prog->name, prog->instances.nr);
8207 n, prog->name);
8298 * name. Kept for backward compatibility.
8512 int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,
8518 if (!name)
8521 sec_def = find_sec_def(name);
8528 pr_debug("failed to guess program type from ELF section '%s'\n", name);
8568 const char *name;
8589 name = elf_sym_str(obj, sym.st_name) ?: "<?>";
8600 pr_debug("struct_ops reloc %s: for %lld value %lld shdr_idx %u rel.r_offset %zu map->sec_offset %zu name %d (\'%s\')\n",
8601 map->name,
8605 map->sec_offset, sym.st_name, name);
8609 map->name, (size_t)rel.r_offset, shdr_idx);
8614 map->name, (unsigned long long)sym.st_value);
8622 map->name, moff);
8626 name = btf__name_by_offset(btf, member->name_off);
8630 map->name, name);
8637 map->name, shdr_idx, name);
8667 map->name, prog->name, prog->sec_name, prog->type,
8668 prog->attach_btf_id, prog->expected_attach_type, name);
8678 const char *name, __u32 kind)
8684 "%s%s", prefix, name);
8694 static inline int __find_vmlinux_btf_id(struct btf *btf, const char *name,
8700 err = find_btf_by_prefix_kind(btf, BTF_TRACE_PREFIX, name,
8703 err = find_btf_by_prefix_kind(btf, BTF_LSM_PREFIX, name,
8706 err = find_btf_by_prefix_kind(btf, BTF_ITER_PREFIX, name,
8709 err = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC);
8712 pr_warn("%s is not found in vmlinux BTF\n", name);
8717 int libbpf_find_vmlinux_btf_id(const char *name,
8729 err = __find_vmlinux_btf_id(btf, name, attach_type);
8734 static int libbpf_find_prog_btf_id(const char *name, __u32 attach_prog_fd)
8756 err = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC);
8759 pr_warn("%s is not found in prog's BTF\n", name);
8771 const char *name = prog->sec_name;
8774 if (!name)
8780 if (strncmp(name, section_defs[i].sec, section_defs[i].len))
8783 err = libbpf_find_prog_btf_id(name + section_defs[i].len,
8787 name + section_defs[i].len,
8791 pr_warn("failed to identify btf_id based on ELF section name '%s'\n", name);
8795 int libbpf_attach_type_by_name(const char *name,
8801 if (!name)
8805 if (strncmp(name, section_defs[i].sec, section_defs[i].len))
8812 pr_debug("failed to guess attach type based on ELF section name '%s'\n", name);
8834 return map ? map->name : NULL;
9027 bpf_object__find_map_by_name(const struct bpf_object *obj, const char *name)
9032 if (pos->name && !strcmp(pos->name, name))
9039 bpf_object__find_map_fd_by_name(const struct bpf_object *obj, const char *name)
9041 return bpf_map__fd(bpf_object__find_map_by_name(obj, name));
9103 * we haven't guessed from section name and user
9299 prog->name, pfd);
9305 prog->name);
9319 prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg)));
9322 prog->name, pfd);
9329 prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg)));
9393 static int perf_event_open_probe(bool uprobe, bool retprobe, const char *name,
9422 attr.config1 = ptr_to_u64(name); /* kprobe_func or uprobe_path */
9452 prog->name, retprobe ? "kretprobe" : "kprobe", func_name,
9461 prog->name, retprobe ? "kretprobe" : "kprobe", func_name,
9493 prog->name, retprobe ? "uretprobe" : "uprobe",
9503 prog->name, retprobe ? "uretprobe" : "uprobe",
9572 prog->name, tp_category, tp_name,
9581 prog->name, tp_category, tp_name,
9598 /* extract "tp/<category>/<name>" */
9623 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9637 prog->name, tp_name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg)));
9661 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9675 prog->name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg)));
9723 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9738 prog->name, target_name,
9772 prog->name);
9778 prog->name);
9814 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9829 prog->name, libbpf_strerror_r(link_fd, errmsg, sizeof(errmsg)));
10151 map.name);
10792 .object_name = s->name,
10798 * explicitly. Overwriting object name for skeletons is discouraged,
10799 * as it breaks global data maps, because they contain object name
10800 * prefix as their own map name prefix. When skeleton is generated,
10801 * bpftool is making an assumption that this name will stay the same.
10806 skel_opts.object_name = s->name;
10812 s->name, PTR_ERR(obj));
10820 const char *name = s->maps[i].name;
10823 *map = bpf_object__find_map_by_name(obj, name);
10825 pr_warn("failed to find skeleton map '%s'\n", name);
10836 const char *name = s->progs[i].name;
10838 *prog = bpf_object__find_program_by_name(obj, name);
10840 pr_warn("failed to find skeleton program '%s'\n", name);
10854 pr_warn("failed to load BPF skeleton '%s': %d\n", s->name, err);