Merge branch 'libbpf-stringify-error-codes-in-log-messages'

+14 -12

tools/lib/bpf/btf.c

··· 22 22 #include "libbpf_internal.h" 23 23 #include "hashmap.h" 24 24 #include "strset.h" 25 + #include "str_error.h" 25 26 26 27 #define BTF_MAX_NR_TYPES 0x7fffffffU 27 28 #define BTF_MAX_STR_OFFSET 0x7fffffffU ··· 1180 1179 fd = open(path, O_RDONLY | O_CLOEXEC); 1181 1180 if (fd < 0) { 1182 1181 err = -errno; 1183 - pr_warn("failed to open %s: %s\n", path, strerror(errno)); 1182 + pr_warn("failed to open %s: %s\n", path, errstr(err)); 1184 1183 return ERR_PTR(err); 1185 1184 } 1186 1185 ··· 1446 1445 goto retry_load; 1447 1446 1448 1447 err = -errno; 1449 - pr_warn("BTF loading error: %d\n", err); 1448 + pr_warn("BTF loading error: %s\n", errstr(err)); 1450 1449 /* don't print out contents of custom log_buf */ 1451 1450 if (!log_buf && buf[0]) 1452 1451 pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf); ··· 3465 3464 3466 3465 err = btf_dedup_prep(d); 3467 3466 if (err) { 3468 - pr_debug("btf_dedup_prep failed:%d\n", err); 3467 + pr_debug("btf_dedup_prep failed: %s\n", errstr(err)); 3469 3468 goto done; 3470 3469 } 3471 3470 err = btf_dedup_strings(d); 3472 3471 if (err < 0) { 3473 - pr_debug("btf_dedup_strings failed:%d\n", err); 3472 + pr_debug("btf_dedup_strings failed: %s\n", errstr(err)); 3474 3473 goto done; 3475 3474 } 3476 3475 err = btf_dedup_prim_types(d); 3477 3476 if (err < 0) { 3478 - pr_debug("btf_dedup_prim_types failed:%d\n", err); 3477 + pr_debug("btf_dedup_prim_types failed: %s\n", errstr(err)); 3479 3478 goto done; 3480 3479 } 3481 3480 err = btf_dedup_struct_types(d); 3482 3481 if (err < 0) { 3483 - pr_debug("btf_dedup_struct_types failed:%d\n", err); 3482 + pr_debug("btf_dedup_struct_types failed: %s\n", errstr(err)); 3484 3483 goto done; 3485 3484 } 3486 3485 err = btf_dedup_resolve_fwds(d); 3487 3486 if (err < 0) { 3488 - pr_debug("btf_dedup_resolve_fwds failed:%d\n", err); 3487 + pr_debug("btf_dedup_resolve_fwds failed: %s\n", errstr(err)); 3489 3488 goto done; 3490 3489 } 3491 3490 err = btf_dedup_ref_types(d); 3492 3491 if (err < 0) { 3493 - pr_debug("btf_dedup_ref_types failed:%d\n", err); 3492 + pr_debug("btf_dedup_ref_types failed: %s\n", errstr(err)); 3494 3493 goto done; 3495 3494 } 3496 3495 err = btf_dedup_compact_types(d); 3497 3496 if (err < 0) { 3498 - pr_debug("btf_dedup_compact_types failed:%d\n", err); 3497 + pr_debug("btf_dedup_compact_types failed: %s\n", errstr(err)); 3499 3498 goto done; 3500 3499 } 3501 3500 err = btf_dedup_remap_types(d); 3502 3501 if (err < 0) { 3503 - pr_debug("btf_dedup_remap_types failed:%d\n", err); 3502 + pr_debug("btf_dedup_remap_types failed: %s\n", errstr(err)); 3504 3503 goto done; 3505 3504 } 3506 3505 ··· 5219 5218 btf = btf__parse(sysfs_btf_path, NULL); 5220 5219 if (!btf) { 5221 5220 err = -errno; 5222 - pr_warn("failed to read kernel BTF from '%s': %d\n", sysfs_btf_path, err); 5221 + pr_warn("failed to read kernel BTF from '%s': %s\n", 5222 + sysfs_btf_path, errstr(err)); 5223 5223 return libbpf_err_ptr(err); 5224 5224 } 5225 5225 pr_debug("loaded kernel BTF from '%s'\n", sysfs_btf_path); ··· 5237 5235 5238 5236 btf = btf__parse(path, NULL); 5239 5237 err = libbpf_get_error(btf); 5240 - pr_debug("loading kernel BTF '%s': %d\n", path, err); 5238 + pr_debug("loading kernel BTF '%s': %s\n", path, errstr(err)); 5241 5239 if (err) 5242 5240 continue; 5243 5241

+2 -1

tools/lib/bpf/btf_dump.c

··· 21 21 #include "hashmap.h" 22 22 #include "libbpf.h" 23 23 #include "libbpf_internal.h" 24 + #include "str_error.h" 24 25 25 26 static const char PREFIXES[] = "\t\t\t\t\t\t\t\t\t\t\t\t\t"; 26 27 static const size_t PREFIX_CNT = sizeof(PREFIXES) - 1; ··· 1305 1304 * chain, restore stack, emit warning, and try to 1306 1305 * proceed nevertheless 1307 1306 */ 1308 - pr_warn("not enough memory for decl stack: %d\n", err); 1307 + pr_warn("not enough memory for decl stack: %s\n", errstr(err)); 1309 1308 d->decl_stack_cnt = stack_start; 1310 1309 return; 1311 1310 }

+1 -3

tools/lib/bpf/elf.c

··· 24 24 25 25 int elf_open(const char *binary_path, struct elf_fd *elf_fd) 26 26 { 27 - char errmsg[STRERR_BUFSIZE]; 28 27 int fd, ret; 29 28 Elf *elf; 30 29 ··· 37 38 fd = open(binary_path, O_RDONLY | O_CLOEXEC); 38 39 if (fd < 0) { 39 40 ret = -errno; 40 - pr_warn("elf: failed to open %s: %s\n", binary_path, 41 - libbpf_strerror_r(ret, errmsg, sizeof(errmsg))); 41 + pr_warn("elf: failed to open %s: %s\n", binary_path, errstr(ret)); 42 42 return ret; 43 43 } 44 44 elf = elf_begin(fd, ELF_C_READ_MMAP, NULL);

+6 -9

tools/lib/bpf/features.c

··· 47 47 48 48 static int probe_kern_global_data(int token_fd) 49 49 { 50 - char *cp, errmsg[STRERR_BUFSIZE]; 51 50 struct bpf_insn insns[] = { 52 51 BPF_LD_MAP_VALUE(BPF_REG_1, 0, 16), 53 52 BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 42), ··· 66 67 map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_global", sizeof(int), 32, 1, &map_opts); 67 68 if (map < 0) { 68 69 ret = -errno; 69 - cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg)); 70 - pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n", 71 - __func__, cp, -ret); 70 + pr_warn("Error in %s(): %s. Couldn't create simple array map.\n", 71 + __func__, errstr(ret)); 72 72 return ret; 73 73 } 74 74 ··· 265 267 266 268 static int probe_prog_bind_map(int token_fd) 267 269 { 268 - char *cp, errmsg[STRERR_BUFSIZE]; 269 270 struct bpf_insn insns[] = { 270 271 BPF_MOV64_IMM(BPF_REG_0, 0), 271 272 BPF_EXIT_INSN(), ··· 282 285 map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_det_bind", sizeof(int), 32, 1, &map_opts); 283 286 if (map < 0) { 284 287 ret = -errno; 285 - cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg)); 286 - pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n", 287 - __func__, cp, -ret); 288 + pr_warn("Error in %s(): %s. Couldn't create simple array map.\n", 289 + __func__, errstr(ret)); 288 290 return ret; 289 291 } 290 292 ··· 600 604 } else if (ret == 0) { 601 605 WRITE_ONCE(cache->res[feat_id], FEAT_MISSING); 602 606 } else { 603 - pr_warn("Detection of kernel %s support failed: %d\n", feat->desc, ret); 607 + pr_warn("Detection of kernel %s support failed: %s\n", 608 + feat->desc, errstr(ret)); 604 609 WRITE_ONCE(cache->res[feat_id], FEAT_MISSING); 605 610 } 606 611 }

+2 -1

tools/lib/bpf/gen_loader.c

··· 14 14 #include "bpf_gen_internal.h" 15 15 #include "skel_internal.h" 16 16 #include <asm/byteorder.h> 17 + #include "str_error.h" 17 18 18 19 #define MAX_USED_MAPS 64 19 20 #define MAX_USED_PROGS 32 ··· 394 393 blob_fd_array_off(gen, i)); 395 394 emit(gen, BPF_MOV64_IMM(BPF_REG_0, 0)); 396 395 emit(gen, BPF_EXIT_INSN()); 397 - pr_debug("gen: finish %d\n", gen->error); 396 + pr_debug("gen: finish %s\n", errstr(gen->error)); 398 397 if (!gen->error) { 399 398 struct gen_loader_opts *opts = gen->opts; 400 399

+156 -200

tools/lib/bpf/libbpf.c

··· 1551 1551 } else { 1552 1552 obj->efile.fd = open(obj->path, O_RDONLY | O_CLOEXEC); 1553 1553 if (obj->efile.fd < 0) { 1554 - char errmsg[STRERR_BUFSIZE], *cp; 1555 - 1556 1554 err = -errno; 1557 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 1558 - pr_warn("elf: failed to open %s: %s\n", obj->path, cp); 1555 + pr_warn("elf: failed to open %s: %s\n", obj->path, errstr(err)); 1559 1556 return err; 1560 1557 } 1561 1558 ··· 1958 1961 if (map->mmaped == MAP_FAILED) { 1959 1962 err = -errno; 1960 1963 map->mmaped = NULL; 1961 - pr_warn("failed to alloc map '%s' content buffer: %d\n", 1962 - map->name, err); 1964 + pr_warn("failed to alloc map '%s' content buffer: %s\n", map->name, errstr(err)); 1963 1965 zfree(&map->real_name); 1964 1966 zfree(&map->name); 1965 1967 return err; ··· 2122 2126 *res = strtoull(value, &value_end, 0); 2123 2127 if (errno) { 2124 2128 err = -errno; 2125 - pr_warn("failed to parse '%s' as integer: %d\n", value, err); 2129 + pr_warn("failed to parse '%s': %s\n", value, errstr(err)); 2126 2130 return err; 2127 2131 } 2128 2132 if (*value_end) { ··· 2288 2292 while (gzgets(file, buf, sizeof(buf))) { 2289 2293 err = bpf_object__process_kconfig_line(obj, buf, data); 2290 2294 if (err) { 2291 - pr_warn("error parsing system Kconfig line '%s': %d\n", 2292 - buf, err); 2295 + pr_warn("error parsing system Kconfig line '%s': %s\n", 2296 + buf, errstr(err)); 2293 2297 goto out; 2294 2298 } 2295 2299 } ··· 2309 2313 file = fmemopen((void *)config, strlen(config), "r"); 2310 2314 if (!file) { 2311 2315 err = -errno; 2312 - pr_warn("failed to open in-memory Kconfig: %d\n", err); 2316 + pr_warn("failed to open in-memory Kconfig: %s\n", errstr(err)); 2313 2317 return err; 2314 2318 } 2315 2319 2316 2320 while (fgets(buf, sizeof(buf), file)) { 2317 2321 err = bpf_object__process_kconfig_line(obj, buf, data); 2318 2322 if (err) { 2319 - pr_warn("error parsing in-memory Kconfig line '%s': %d\n", 2320 - buf, err); 2323 + pr_warn("error parsing in-memory Kconfig line '%s': %s\n", 2324 + buf, errstr(err)); 2321 2325 break; 2322 2326 } 2323 2327 } ··· 3232 3236 err = libbpf_get_error(obj->btf); 3233 3237 if (err) { 3234 3238 obj->btf = NULL; 3235 - pr_warn("Error loading ELF section %s: %d.\n", BTF_ELF_SEC, err); 3239 + pr_warn("Error loading ELF section %s: %s.\n", BTF_ELF_SEC, errstr(err)); 3236 3240 goto out; 3237 3241 } 3238 3242 /* enforce 8-byte pointers for BPF-targeted BTFs */ ··· 3250 3254 obj->btf_ext = btf_ext__new(btf_ext_data->d_buf, btf_ext_data->d_size); 3251 3255 err = libbpf_get_error(obj->btf_ext); 3252 3256 if (err) { 3253 - pr_warn("Error loading ELF section %s: %d. Ignored and continue.\n", 3254 - BTF_EXT_ELF_SEC, err); 3257 + pr_warn("Error loading ELF section %s: %s. Ignored and continue.\n", 3258 + BTF_EXT_ELF_SEC, errstr(err)); 3255 3259 obj->btf_ext = NULL; 3256 3260 goto out; 3257 3261 } ··· 3343 3347 if (t->size == 0) { 3344 3348 err = find_elf_sec_sz(obj, sec_name, &size); 3345 3349 if (err || !size) { 3346 - pr_debug("sec '%s': failed to determine size from ELF: size %u, err %d\n", 3347 - sec_name, size, err); 3350 + pr_debug("sec '%s': failed to determine size from ELF: size %u, err %s\n", 3351 + sec_name, size, errstr(err)); 3348 3352 return -ENOENT; 3349 3353 } 3350 3354 ··· 3498 3502 obj->btf_vmlinux = btf__load_vmlinux_btf(); 3499 3503 err = libbpf_get_error(obj->btf_vmlinux); 3500 3504 if (err) { 3501 - pr_warn("Error loading vmlinux BTF: %d\n", err); 3505 + pr_warn("Error loading vmlinux BTF: %s\n", errstr(err)); 3502 3506 obj->btf_vmlinux = NULL; 3503 3507 return err; 3504 3508 } ··· 3602 3606 if (err) { 3603 3607 btf_mandatory = kernel_needs_btf(obj); 3604 3608 if (btf_mandatory) { 3605 - pr_warn("Error loading .BTF into kernel: %d. BTF is mandatory, can't proceed.\n", err); 3609 + pr_warn("Error loading .BTF into kernel: %s. BTF is mandatory, can't proceed.\n", 3610 + errstr(err)); 3606 3611 } else { 3607 - pr_info("Error loading .BTF into kernel: %d. BTF is optional, ignoring.\n", err); 3612 + pr_info("Error loading .BTF into kernel: %s. BTF is optional, ignoring.\n", 3613 + errstr(err)); 3608 3614 err = 0; 3609 3615 } 3610 3616 } ··· 4810 4812 fp = fopen(file, "re"); 4811 4813 if (!fp) { 4812 4814 err = -errno; 4813 - pr_warn("failed to open %s: %d. No procfs support?\n", file, 4814 - err); 4815 + pr_warn("failed to open %s: %s. No procfs support?\n", file, 4816 + errstr(err)); 4815 4817 return err; 4816 4818 } 4817 4819 ··· 4966 4968 bpffs_fd = open(bpffs_path, O_DIRECTORY, O_RDWR); 4967 4969 if (bpffs_fd < 0) { 4968 4970 err = -errno; 4969 - __pr(level, "object '%s': failed (%d) to open BPF FS mount at '%s'%s\n", 4970 - obj->name, err, bpffs_path, 4971 + __pr(level, "object '%s': failed (%s) to open BPF FS mount at '%s'%s\n", 4972 + obj->name, errstr(err), bpffs_path, 4971 4973 mandatory ? "" : ", skipping optional step..."); 4972 4974 return mandatory ? err : 0; 4973 4975 } ··· 5001 5003 static int 5002 5004 bpf_object__probe_loading(struct bpf_object *obj) 5003 5005 { 5004 - char *cp, errmsg[STRERR_BUFSIZE]; 5005 5006 struct bpf_insn insns[] = { 5006 5007 BPF_MOV64_IMM(BPF_REG_0, 0), 5007 5008 BPF_EXIT_INSN(), ··· 5016 5019 5017 5020 ret = bump_rlimit_memlock(); 5018 5021 if (ret) 5019 - pr_warn("Failed to bump RLIMIT_MEMLOCK (err = %d), you might need to do it explicitly!\n", ret); 5022 + pr_warn("Failed to bump RLIMIT_MEMLOCK (err = %s), you might need to do it explicitly!\n", 5023 + errstr(ret)); 5020 5024 5021 5025 /* make sure basic loading works */ 5022 5026 ret = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &opts); ··· 5025 5027 ret = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL", insns, insn_cnt, &opts); 5026 5028 if (ret < 0) { 5027 5029 ret = errno; 5028 - cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg)); 5029 - pr_warn("Error in %s():%s(%d). Couldn't load trivial BPF " 5030 - "program. Make sure your kernel supports BPF " 5031 - "(CONFIG_BPF_SYSCALL=y) and/or that RLIMIT_MEMLOCK is " 5032 - "set to big enough value.\n", __func__, cp, ret); 5030 + pr_warn("Error in %s(): %s. Couldn't load trivial BPF program. Make sure your kernel supports BPF (CONFIG_BPF_SYSCALL=y) and/or that RLIMIT_MEMLOCK is set to big enough value.\n", 5031 + __func__, errstr(ret)); 5033 5032 return -ret; 5034 5033 } 5035 5034 close(ret); ··· 5051 5056 static bool map_is_reuse_compat(const struct bpf_map *map, int map_fd) 5052 5057 { 5053 5058 struct bpf_map_info map_info; 5054 - char msg[STRERR_BUFSIZE]; 5055 5059 __u32 map_info_len = sizeof(map_info); 5056 5060 int err; 5057 5061 ··· 5060 5066 err = bpf_get_map_info_from_fdinfo(map_fd, &map_info); 5061 5067 if (err) { 5062 5068 pr_warn("failed to get map info for map FD %d: %s\n", map_fd, 5063 - libbpf_strerror_r(errno, msg, sizeof(msg))); 5069 + errstr(err)); 5064 5070 return false; 5065 5071 } 5066 5072 ··· 5075 5081 static int 5076 5082 bpf_object__reuse_map(struct bpf_map *map) 5077 5083 { 5078 - char *cp, errmsg[STRERR_BUFSIZE]; 5079 5084 int err, pin_fd; 5080 5085 5081 5086 pin_fd = bpf_obj_get(map->pin_path); ··· 5086 5093 return 0; 5087 5094 } 5088 5095 5089 - cp = libbpf_strerror_r(-err, errmsg, sizeof(errmsg)); 5090 5096 pr_warn("couldn't retrieve pinned map '%s': %s\n", 5091 - map->pin_path, cp); 5097 + map->pin_path, errstr(err)); 5092 5098 return err; 5093 5099 } 5094 5100 ··· 5113 5121 bpf_object__populate_internal_map(struct bpf_object *obj, struct bpf_map *map) 5114 5122 { 5115 5123 enum libbpf_map_type map_type = map->libbpf_type; 5116 - char *cp, errmsg[STRERR_BUFSIZE]; 5117 5124 int err, zero = 0; 5118 5125 size_t mmap_sz; 5119 5126 ··· 5127 5136 err = bpf_map_update_elem(map->fd, &zero, map->mmaped, 0); 5128 5137 if (err) { 5129 5138 err = -errno; 5130 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 5131 5139 pr_warn("map '%s': failed to set initial contents: %s\n", 5132 - bpf_map__name(map), cp); 5140 + bpf_map__name(map), errstr(err)); 5133 5141 return err; 5134 5142 } 5135 5143 ··· 5137 5147 err = bpf_map_freeze(map->fd); 5138 5148 if (err) { 5139 5149 err = -errno; 5140 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 5141 5150 pr_warn("map '%s': failed to freeze as read-only: %s\n", 5142 - bpf_map__name(map), cp); 5151 + bpf_map__name(map), errstr(err)); 5143 5152 return err; 5144 5153 } 5145 5154 } ··· 5164 5175 mmaped = mmap(map->mmaped, mmap_sz, prot, MAP_SHARED | MAP_FIXED, map->fd, 0); 5165 5176 if (mmaped == MAP_FAILED) { 5166 5177 err = -errno; 5167 - pr_warn("map '%s': failed to re-mmap() contents: %d\n", 5168 - bpf_map__name(map), err); 5178 + pr_warn("map '%s': failed to re-mmap() contents: %s\n", 5179 + bpf_map__name(map), errstr(err)); 5169 5180 return err; 5170 5181 } 5171 5182 map->mmaped = mmaped; ··· 5222 5233 return err; 5223 5234 err = bpf_object__create_map(obj, map->inner_map, true); 5224 5235 if (err) { 5225 - pr_warn("map '%s': failed to create inner map: %d\n", 5226 - map->name, err); 5236 + pr_warn("map '%s': failed to create inner map: %s\n", 5237 + map->name, errstr(err)); 5227 5238 return err; 5228 5239 } 5229 5240 map->inner_map_fd = map->inner_map->fd; ··· 5277 5288 def->max_entries, &create_attr); 5278 5289 } 5279 5290 if (map_fd < 0 && (create_attr.btf_key_type_id || create_attr.btf_value_type_id)) { 5280 - char *cp, errmsg[STRERR_BUFSIZE]; 5281 - 5282 5291 err = -errno; 5283 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 5284 - pr_warn("Error in bpf_create_map_xattr(%s):%s(%d). Retrying without BTF.\n", 5285 - map->name, cp, err); 5292 + pr_warn("Error in bpf_create_map_xattr(%s): %s. Retrying without BTF.\n", 5293 + map->name, errstr(err)); 5286 5294 create_attr.btf_fd = 0; 5287 5295 create_attr.btf_key_type_id = 0; 5288 5296 create_attr.btf_value_type_id = 0; ··· 5334 5348 } 5335 5349 if (err) { 5336 5350 err = -errno; 5337 - pr_warn("map '%s': failed to initialize slot [%d] to map '%s' fd=%d: %d\n", 5338 - map->name, i, targ_map->name, fd, err); 5351 + pr_warn("map '%s': failed to initialize slot [%d] to map '%s' fd=%d: %s\n", 5352 + map->name, i, targ_map->name, fd, errstr(err)); 5339 5353 return err; 5340 5354 } 5341 5355 pr_debug("map '%s': slot [%d] set to map '%s' fd=%d\n", ··· 5367 5381 err = bpf_map_update_elem(map->fd, &i, &fd, 0); 5368 5382 if (err) { 5369 5383 err = -errno; 5370 - pr_warn("map '%s': failed to initialize slot [%d] to prog '%s' fd=%d: %d\n", 5371 - map->name, i, targ_prog->name, fd, err); 5384 + pr_warn("map '%s': failed to initialize slot [%d] to prog '%s' fd=%d: %s\n", 5385 + map->name, i, targ_prog->name, fd, errstr(err)); 5372 5386 return err; 5373 5387 } 5374 5388 pr_debug("map '%s': slot [%d] set to prog '%s' fd=%d\n", ··· 5421 5435 bpf_object__create_maps(struct bpf_object *obj) 5422 5436 { 5423 5437 struct bpf_map *map; 5424 - char *cp, errmsg[STRERR_BUFSIZE]; 5425 5438 unsigned int i, j; 5426 5439 int err; 5427 5440 bool retried; ··· 5494 5509 if (map->mmaped == MAP_FAILED) { 5495 5510 err = -errno; 5496 5511 map->mmaped = NULL; 5497 - pr_warn("map '%s': failed to mmap arena: %d\n", 5498 - map->name, err); 5512 + pr_warn("map '%s': failed to mmap arena: %s\n", 5513 + map->name, errstr(err)); 5499 5514 return err; 5500 5515 } 5501 5516 if (obj->arena_data) { ··· 5517 5532 retried = true; 5518 5533 goto retry; 5519 5534 } 5520 - pr_warn("map '%s': failed to auto-pin at '%s': %d\n", 5521 - map->name, map->pin_path, err); 5535 + pr_warn("map '%s': failed to auto-pin at '%s': %s\n", 5536 + map->name, map->pin_path, errstr(err)); 5522 5537 goto err_out; 5523 5538 } 5524 5539 } ··· 5527 5542 return 0; 5528 5543 5529 5544 err_out: 5530 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 5531 - pr_warn("map '%s': failed to create: %s(%d)\n", map->name, cp, err); 5545 + pr_warn("map '%s': failed to create: %s\n", map->name, errstr(err)); 5532 5546 pr_perm_msg(err); 5533 5547 for (j = 0; j < i; j++) 5534 5548 zclose(obj->maps[j].fd); ··· 5651 5667 } 5652 5668 if (err) { 5653 5669 err = -errno; 5654 - pr_warn("failed to iterate BTF objects: %d\n", err); 5670 + pr_warn("failed to iterate BTF objects: %s\n", errstr(err)); 5655 5671 return err; 5656 5672 } 5657 5673 ··· 5660 5676 if (errno == ENOENT) 5661 5677 continue; /* expected race: BTF was unloaded */ 5662 5678 err = -errno; 5663 - pr_warn("failed to get BTF object #%d FD: %d\n", id, err); 5679 + pr_warn("failed to get BTF object #%d FD: %s\n", id, errstr(err)); 5664 5680 return err; 5665 5681 } 5666 5682 ··· 5672 5688 err = bpf_btf_get_info_by_fd(fd, &info, &len); 5673 5689 if (err) { 5674 5690 err = -errno; 5675 - pr_warn("failed to get BTF object #%d info: %d\n", id, err); 5691 + pr_warn("failed to get BTF object #%d info: %s\n", id, errstr(err)); 5676 5692 goto err_out; 5677 5693 } 5678 5694 ··· 5685 5701 btf = btf_get_from_fd(fd, obj->btf_vmlinux); 5686 5702 err = libbpf_get_error(btf); 5687 5703 if (err) { 5688 - pr_warn("failed to load module [%s]'s BTF object #%d: %d\n", 5689 - name, id, err); 5704 + pr_warn("failed to load module [%s]'s BTF object #%d: %s\n", 5705 + name, id, errstr(err)); 5690 5706 goto err_out; 5691 5707 } 5692 5708 ··· 5915 5931 obj->btf_vmlinux_override = btf__parse(targ_btf_path, NULL); 5916 5932 err = libbpf_get_error(obj->btf_vmlinux_override); 5917 5933 if (err) { 5918 - pr_warn("failed to parse target BTF: %d\n", err); 5934 + pr_warn("failed to parse target BTF: %s\n", errstr(err)); 5919 5935 return err; 5920 5936 } 5921 5937 } ··· 5975 5991 5976 5992 err = record_relo_core(prog, rec, insn_idx); 5977 5993 if (err) { 5978 - pr_warn("prog '%s': relo #%d: failed to record relocation: %d\n", 5979 - prog->name, i, err); 5994 + pr_warn("prog '%s': relo #%d: failed to record relocation: %s\n", 5995 + prog->name, i, errstr(err)); 5980 5996 goto out; 5981 5997 } 5982 5998 ··· 5985 6001 5986 6002 err = bpf_core_resolve_relo(prog, rec, i, obj->btf, cand_cache, &targ_res); 5987 6003 if (err) { 5988 - pr_warn("prog '%s': relo #%d: failed to relocate: %d\n", 5989 - prog->name, i, err); 6004 + pr_warn("prog '%s': relo #%d: failed to relocate: %s\n", 6005 + prog->name, i, errstr(err)); 5990 6006 goto out; 5991 6007 } 5992 6008 5993 6009 err = bpf_core_patch_insn(prog->name, insn, insn_idx, rec, i, &targ_res); 5994 6010 if (err) { 5995 - pr_warn("prog '%s': relo #%d: failed to patch insn #%u: %d\n", 5996 - prog->name, i, insn_idx, err); 6011 + pr_warn("prog '%s': relo #%d: failed to patch insn #%u: %s\n", 6012 + prog->name, i, insn_idx, errstr(err)); 5997 6013 goto out; 5998 6014 } 5999 6015 } ··· 6261 6277 &main_prog->func_info_rec_size); 6262 6278 if (err) { 6263 6279 if (err != -ENOENT) { 6264 - pr_warn("prog '%s': error relocating .BTF.ext function info: %d\n", 6265 - prog->name, err); 6280 + pr_warn("prog '%s': error relocating .BTF.ext function info: %s\n", 6281 + prog->name, errstr(err)); 6266 6282 return err; 6267 6283 } 6268 6284 if (main_prog->func_info) { ··· 6289 6305 &main_prog->line_info_rec_size); 6290 6306 if (err) { 6291 6307 if (err != -ENOENT) { 6292 - pr_warn("prog '%s': error relocating .BTF.ext line info: %d\n", 6293 - prog->name, err); 6308 + pr_warn("prog '%s': error relocating .BTF.ext line info: %s\n", 6309 + prog->name, errstr(err)); 6294 6310 return err; 6295 6311 } 6296 6312 if (main_prog->line_info) { ··· 7054 7070 if (obj->btf_ext) { 7055 7071 err = bpf_object__relocate_core(obj, targ_btf_path); 7056 7072 if (err) { 7057 - pr_warn("failed to perform CO-RE relocations: %d\n", 7058 - err); 7073 + pr_warn("failed to perform CO-RE relocations: %s\n", 7074 + errstr(err)); 7059 7075 return err; 7060 7076 } 7061 7077 bpf_object__sort_relos(obj); ··· 7099 7115 7100 7116 err = bpf_object__relocate_calls(obj, prog); 7101 7117 if (err) { 7102 - pr_warn("prog '%s': failed to relocate calls: %d\n", 7103 - prog->name, err); 7118 + pr_warn("prog '%s': failed to relocate calls: %s\n", 7119 + prog->name, errstr(err)); 7104 7120 return err; 7105 7121 } 7106 7122 ··· 7136 7152 /* Process data relos for main programs */ 7137 7153 err = bpf_object__relocate_data(obj, prog); 7138 7154 if (err) { 7139 - pr_warn("prog '%s': failed to relocate data references: %d\n", 7140 - prog->name, err); 7155 + pr_warn("prog '%s': failed to relocate data references: %s\n", 7156 + prog->name, errstr(err)); 7141 7157 return err; 7142 7158 } 7143 7159 7144 7160 /* Fix up .BTF.ext information, if necessary */ 7145 7161 err = bpf_program_fixup_func_info(obj, prog); 7146 7162 if (err) { 7147 - pr_warn("prog '%s': failed to perform .BTF.ext fix ups: %d\n", 7148 - prog->name, err); 7163 + pr_warn("prog '%s': failed to perform .BTF.ext fix ups: %s\n", 7164 + prog->name, errstr(err)); 7149 7165 return err; 7150 7166 } 7151 7167 } ··· 7454 7470 { 7455 7471 LIBBPF_OPTS(bpf_prog_load_opts, load_attr); 7456 7472 const char *prog_name = NULL; 7457 - char *cp, errmsg[STRERR_BUFSIZE]; 7458 7473 size_t log_buf_size = 0; 7459 7474 char *log_buf = NULL, *tmp; 7460 7475 bool own_log_buf = true; ··· 7517 7534 if (prog->sec_def && prog->sec_def->prog_prepare_load_fn) { 7518 7535 err = prog->sec_def->prog_prepare_load_fn(prog, &load_attr, prog->sec_def->cookie); 7519 7536 if (err < 0) { 7520 - pr_warn("prog '%s': failed to prepare load attributes: %d\n", 7521 - prog->name, err); 7537 + pr_warn("prog '%s': failed to prepare load attributes: %s\n", 7538 + prog->name, errstr(err)); 7522 7539 return err; 7523 7540 } 7524 7541 insns = prog->insns; ··· 7582 7599 continue; 7583 7600 7584 7601 if (bpf_prog_bind_map(ret, map->fd, NULL)) { 7585 - cp = libbpf_strerror_r(errno, errmsg, sizeof(errmsg)); 7586 7602 pr_warn("prog '%s': failed to bind map '%s': %s\n", 7587 - prog->name, map->real_name, cp); 7603 + prog->name, map->real_name, errstr(errno)); 7588 7604 /* Don't fail hard if can't bind rodata. */ 7589 7605 } 7590 7606 } ··· 7613 7631 /* post-process verifier log to improve error descriptions */ 7614 7632 fixup_verifier_log(prog, log_buf, log_buf_size); 7615 7633 7616 - cp = libbpf_strerror_r(errno, errmsg, sizeof(errmsg)); 7617 - pr_warn("prog '%s': BPF program load failed: %s\n", prog->name, cp); 7634 + pr_warn("prog '%s': BPF program load failed: %s\n", prog->name, errstr(errno)); 7618 7635 pr_perm_msg(ret); 7619 7636 7620 7637 if (own_log_buf && log_buf && log_buf[0] != '\0') { ··· 7906 7925 err = bpf_object_load_prog(obj, prog, prog->insns, prog->insns_cnt, 7907 7926 obj->license, obj->kern_version, &prog->fd); 7908 7927 if (err) { 7909 - pr_warn("prog '%s': failed to load: %d\n", prog->name, err); 7928 + pr_warn("prog '%s': failed to load: %s\n", prog->name, errstr(err)); 7910 7929 return err; 7911 7930 } 7912 7931 } ··· 7940 7959 if (prog->sec_def->prog_setup_fn) { 7941 7960 err = prog->sec_def->prog_setup_fn(prog, prog->sec_def->cookie); 7942 7961 if (err < 0) { 7943 - pr_warn("prog '%s': failed to initialize: %d\n", 7944 - prog->name, err); 7962 + pr_warn("prog '%s': failed to initialize: %s\n", 7963 + prog->name, errstr(err)); 7945 7964 return err; 7946 7965 } 7947 7966 } ··· 8130 8149 f = fopen("/proc/kallsyms", "re"); 8131 8150 if (!f) { 8132 8151 err = -errno; 8133 - pr_warn("failed to open /proc/kallsyms: %d\n", err); 8152 + pr_warn("failed to open /proc/kallsyms: %s\n", errstr(err)); 8134 8153 return err; 8135 8154 } 8136 8155 ··· 8614 8633 8615 8634 static int make_parent_dir(const char *path) 8616 8635 { 8617 - char *cp, errmsg[STRERR_BUFSIZE]; 8618 8636 char *dname, *dir; 8619 8637 int err = 0; 8620 8638 ··· 8627 8647 8628 8648 free(dname); 8629 8649 if (err) { 8630 - cp = libbpf_strerror_r(-err, errmsg, sizeof(errmsg)); 8631 - pr_warn("failed to mkdir %s: %s\n", path, cp); 8650 + pr_warn("failed to mkdir %s: %s\n", path, errstr(err)); 8632 8651 } 8633 8652 return err; 8634 8653 } 8635 8654 8636 8655 static int check_path(const char *path) 8637 8656 { 8638 - char *cp, errmsg[STRERR_BUFSIZE]; 8639 8657 struct statfs st_fs; 8640 8658 char *dname, *dir; 8641 8659 int err = 0; ··· 8647 8669 8648 8670 dir = dirname(dname); 8649 8671 if (statfs(dir, &st_fs)) { 8650 - cp = libbpf_strerror_r(errno, errmsg, sizeof(errmsg)); 8651 - pr_warn("failed to statfs %s: %s\n", dir, cp); 8672 + pr_warn("failed to statfs %s: %s\n", dir, errstr(errno)); 8652 8673 err = -errno; 8653 8674 } 8654 8675 free(dname); ··· 8662 8685 8663 8686 int bpf_program__pin(struct bpf_program *prog, const char *path) 8664 8687 { 8665 - char *cp, errmsg[STRERR_BUFSIZE]; 8666 8688 int err; 8667 8689 8668 8690 if (prog->fd < 0) { ··· 8679 8703 8680 8704 if (bpf_obj_pin(prog->fd, path)) { 8681 8705 err = -errno; 8682 - cp = libbpf_strerror_r(err, errmsg, sizeof(errmsg)); 8683 - pr_warn("prog '%s': failed to pin at '%s': %s\n", prog->name, path, cp); 8706 + pr_warn("prog '%s': failed to pin at '%s': %s\n", prog->name, path, errstr(err)); 8684 8707 return libbpf_err(err); 8685 8708 } 8686 8709 ··· 8710 8735 8711 8736 int bpf_map__pin(struct bpf_map *map, const char *path) 8712 8737 { 8713 - char *cp, errmsg[STRERR_BUFSIZE]; 8714 8738 int err; 8715 8739 8716 8740 if (map == NULL) { ··· 8768 8794 return 0; 8769 8795 8770 8796 out_err: 8771 - cp = libbpf_strerror_r(-err, errmsg, sizeof(errmsg)); 8772 - pr_warn("failed to pin map: %s\n", cp); 8797 + pr_warn("failed to pin map: %s\n", errstr(err)); 8773 8798 return libbpf_err(err); 8774 8799 } 8775 8800 ··· 9957 9984 memset(&info, 0, info_len); 9958 9985 err = bpf_prog_get_info_by_fd(attach_prog_fd, &info, &info_len); 9959 9986 if (err) { 9960 - pr_warn("failed bpf_prog_get_info_by_fd for FD %d: %d\n", 9961 - attach_prog_fd, err); 9987 + pr_warn("failed bpf_prog_get_info_by_fd for FD %d: %s\n", 9988 + attach_prog_fd, errstr(err)); 9962 9989 return err; 9963 9990 } 9964 9991 ··· 9970 9997 btf = btf__load_from_kernel_by_id(info.btf_id); 9971 9998 err = libbpf_get_error(btf); 9972 9999 if (err) { 9973 - pr_warn("Failed to get BTF %d of the program: %d\n", info.btf_id, err); 10000 + pr_warn("Failed to get BTF %d of the program: %s\n", info.btf_id, errstr(err)); 9974 10001 goto out; 9975 10002 } 9976 10003 err = btf__find_by_name_kind(btf, name, BTF_KIND_FUNC); ··· 10052 10079 } 10053 10080 err = libbpf_find_prog_btf_id(attach_name, attach_prog_fd); 10054 10081 if (err < 0) { 10055 - pr_warn("prog '%s': failed to find BPF program (FD %d) BTF ID for '%s': %d\n", 10056 - prog->name, attach_prog_fd, attach_name, err); 10082 + pr_warn("prog '%s': failed to find BPF program (FD %d) BTF ID for '%s': %s\n", 10083 + prog->name, attach_prog_fd, attach_name, errstr(err)); 10057 10084 return err; 10058 10085 } 10059 10086 *btf_obj_fd = 0; ··· 10072 10099 btf_type_id); 10073 10100 } 10074 10101 if (err) { 10075 - pr_warn("prog '%s': failed to find kernel BTF type ID of '%s': %d\n", 10076 - prog->name, attach_name, err); 10102 + pr_warn("prog '%s': failed to find kernel BTF type ID of '%s': %s\n", 10103 + prog->name, attach_name, errstr(err)); 10077 10104 return err; 10078 10105 } 10079 10106 return 0; ··· 10301 10328 mmap_new_sz = array_map_mmap_sz(size, map->def.max_entries); 10302 10329 err = bpf_map_mmap_resize(map, mmap_old_sz, mmap_new_sz); 10303 10330 if (err) { 10304 - pr_warn("map '%s': failed to resize memory-mapped region: %d\n", 10305 - bpf_map__name(map), err); 10331 + pr_warn("map '%s': failed to resize memory-mapped region: %s\n", 10332 + bpf_map__name(map), errstr(err)); 10306 10333 return err; 10307 10334 } 10308 10335 err = map_btf_datasec_resize(map, size); 10309 10336 if (err && err != -ENOENT) { 10310 - pr_warn("map '%s': failed to adjust resized BTF, clearing BTF key/value info: %d\n", 10311 - bpf_map__name(map), err); 10337 + pr_warn("map '%s': failed to adjust resized BTF, clearing BTF key/value info: %s\n", 10338 + bpf_map__name(map), errstr(err)); 10312 10339 map->btf_value_type_id = 0; 10313 10340 map->btf_key_type_id = 0; 10314 10341 } ··· 10799 10826 struct bpf_link *bpf_program__attach_perf_event_opts(const struct bpf_program *prog, int pfd, 10800 10827 const struct bpf_perf_event_opts *opts) 10801 10828 { 10802 - char errmsg[STRERR_BUFSIZE]; 10803 10829 struct bpf_link_perf *link; 10804 10830 int prog_fd, link_fd = -1, err; 10805 10831 bool force_ioctl_attach; ··· 10833 10861 link_fd = bpf_link_create(prog_fd, pfd, BPF_PERF_EVENT, &link_opts); 10834 10862 if (link_fd < 0) { 10835 10863 err = -errno; 10836 - pr_warn("prog '%s': failed to create BPF link for perf_event FD %d: %d (%s)\n", 10837 - prog->name, pfd, 10838 - err, libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 10864 + pr_warn("prog '%s': failed to create BPF link for perf_event FD %d: %s\n", 10865 + prog->name, pfd, errstr(err)); 10839 10866 goto err_out; 10840 10867 } 10841 10868 link->link.fd = link_fd; ··· 10848 10877 if (ioctl(pfd, PERF_EVENT_IOC_SET_BPF, prog_fd) < 0) { 10849 10878 err = -errno; 10850 10879 pr_warn("prog '%s': failed to attach to perf_event FD %d: %s\n", 10851 - prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 10880 + prog->name, pfd, errstr(err)); 10852 10881 if (err == -EPROTO) 10853 10882 pr_warn("prog '%s': try add PERF_SAMPLE_CALLCHAIN to or remove exclude_callchain_[kernel|user] from pfd %d\n", 10854 10883 prog->name, pfd); ··· 10859 10888 if (ioctl(pfd, PERF_EVENT_IOC_ENABLE, 0) < 0) { 10860 10889 err = -errno; 10861 10890 pr_warn("prog '%s': failed to enable perf_event FD %d: %s\n", 10862 - prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 10891 + prog->name, pfd, errstr(err)); 10863 10892 goto err_out; 10864 10893 } 10865 10894 ··· 10883 10912 */ 10884 10913 static int parse_uint_from_file(const char *file, const char *fmt) 10885 10914 { 10886 - char buf[STRERR_BUFSIZE]; 10887 10915 int err, ret; 10888 10916 FILE *f; 10889 10917 10890 10918 f = fopen(file, "re"); 10891 10919 if (!f) { 10892 10920 err = -errno; 10893 - pr_debug("failed to open '%s': %s\n", file, 10894 - libbpf_strerror_r(err, buf, sizeof(buf))); 10921 + pr_debug("failed to open '%s': %s\n", file, errstr(err)); 10895 10922 return err; 10896 10923 } 10897 10924 err = fscanf(f, fmt, &ret); 10898 10925 if (err != 1) { 10899 10926 err = err == EOF ? -EIO : -errno; 10900 - pr_debug("failed to parse '%s': %s\n", file, 10901 - libbpf_strerror_r(err, buf, sizeof(buf))); 10927 + pr_debug("failed to parse '%s': %s\n", file, errstr(err)); 10902 10928 fclose(f); 10903 10929 return err; 10904 10930 } ··· 10939 10971 { 10940 10972 const size_t attr_sz = sizeof(struct perf_event_attr); 10941 10973 struct perf_event_attr attr; 10942 - char errmsg[STRERR_BUFSIZE]; 10943 10974 int type, pfd; 10944 10975 10945 10976 if ((__u64)ref_ctr_off >= (1ULL << PERF_UPROBE_REF_CTR_OFFSET_BITS)) ··· 10951 10984 if (type < 0) { 10952 10985 pr_warn("failed to determine %s perf type: %s\n", 10953 10986 uprobe ? "uprobe" : "kprobe", 10954 - libbpf_strerror_r(type, errmsg, sizeof(errmsg))); 10987 + errstr(type)); 10955 10988 return type; 10956 10989 } 10957 10990 if (retprobe) { ··· 10961 10994 if (bit < 0) { 10962 10995 pr_warn("failed to determine %s retprobe bit: %s\n", 10963 10996 uprobe ? "uprobe" : "kprobe", 10964 - libbpf_strerror_r(bit, errmsg, sizeof(errmsg))); 10997 + errstr(bit)); 10965 10998 return bit; 10966 10999 } 10967 11000 attr.config |= 1 << bit; ··· 11090 11123 { 11091 11124 const size_t attr_sz = sizeof(struct perf_event_attr); 11092 11125 struct perf_event_attr attr; 11093 - char errmsg[STRERR_BUFSIZE]; 11094 11126 int type, pfd, err; 11095 11127 11096 11128 err = add_kprobe_event_legacy(probe_name, retprobe, kfunc_name, offset); 11097 11129 if (err < 0) { 11098 11130 pr_warn("failed to add legacy kprobe event for '%s+0x%zx': %s\n", 11099 11131 kfunc_name, offset, 11100 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11132 + errstr(err)); 11101 11133 return err; 11102 11134 } 11103 11135 type = determine_kprobe_perf_type_legacy(probe_name, retprobe); ··· 11104 11138 err = type; 11105 11139 pr_warn("failed to determine legacy kprobe event id for '%s+0x%zx': %s\n", 11106 11140 kfunc_name, offset, 11107 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11141 + errstr(err)); 11108 11142 goto err_clean_legacy; 11109 11143 } 11110 11144 ··· 11120 11154 if (pfd < 0) { 11121 11155 err = -errno; 11122 11156 pr_warn("legacy kprobe perf_event_open() failed: %s\n", 11123 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11157 + errstr(err)); 11124 11158 goto err_clean_legacy; 11125 11159 } 11126 11160 return pfd; ··· 11196 11230 { 11197 11231 DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, pe_opts); 11198 11232 enum probe_attach_mode attach_mode; 11199 - char errmsg[STRERR_BUFSIZE]; 11200 11233 char *legacy_probe = NULL; 11201 11234 struct bpf_link *link; 11202 11235 size_t offset; ··· 11253 11288 pr_warn("prog '%s': failed to create %s '%s+0x%zx' perf event: %s\n", 11254 11289 prog->name, retprobe ? "kretprobe" : "kprobe", 11255 11290 func_name, offset, 11256 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11291 + errstr(err)); 11257 11292 goto err_out; 11258 11293 } 11259 11294 link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts); ··· 11263 11298 pr_warn("prog '%s': failed to attach to %s '%s+0x%zx': %s\n", 11264 11299 prog->name, retprobe ? "kretprobe" : "kprobe", 11265 11300 func_name, offset, 11266 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11301 + errstr(err)); 11267 11302 goto err_clean_legacy; 11268 11303 } 11269 11304 if (legacy) { ··· 11399 11434 f = fopen(available_functions_file, "re"); 11400 11435 if (!f) { 11401 11436 err = -errno; 11402 - pr_warn("failed to open %s: %d\n", available_functions_file, err); 11437 + pr_warn("failed to open %s: %s\n", available_functions_file, errstr(err)); 11403 11438 return err; 11404 11439 } 11405 11440 ··· 11474 11509 f = fopen(available_path, "re"); 11475 11510 if (!f) { 11476 11511 err = -errno; 11477 - pr_warn("failed to open %s: %d\n", available_path, err); 11512 + pr_warn("failed to open %s: %s\n", available_path, errstr(err)); 11478 11513 return err; 11479 11514 } 11480 11515 ··· 11520 11555 }; 11521 11556 enum bpf_attach_type attach_type; 11522 11557 struct bpf_link *link = NULL; 11523 - char errmsg[STRERR_BUFSIZE]; 11524 11558 const unsigned long *addrs; 11525 11559 int err, link_fd, prog_fd; 11526 11560 bool retprobe, session; ··· 11587 11623 if (link_fd < 0) { 11588 11624 err = -errno; 11589 11625 pr_warn("prog '%s': failed to attach: %s\n", 11590 - prog->name, libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 11626 + prog->name, errstr(err)); 11591 11627 goto error; 11592 11628 } 11593 11629 link->fd = link_fd; ··· 11796 11832 11797 11833 err = add_uprobe_event_legacy(probe_name, retprobe, binary_path, offset); 11798 11834 if (err < 0) { 11799 - pr_warn("failed to add legacy uprobe event for %s:0x%zx: %d\n", 11800 - binary_path, (size_t)offset, err); 11835 + pr_warn("failed to add legacy uprobe event for %s:0x%zx: %s\n", 11836 + binary_path, (size_t)offset, errstr(err)); 11801 11837 return err; 11802 11838 } 11803 11839 type = determine_uprobe_perf_type_legacy(probe_name, retprobe); 11804 11840 if (type < 0) { 11805 11841 err = type; 11806 - pr_warn("failed to determine legacy uprobe event id for %s:0x%zx: %d\n", 11807 - binary_path, offset, err); 11842 + pr_warn("failed to determine legacy uprobe event id for %s:0x%zx: %s\n", 11843 + binary_path, offset, errstr(err)); 11808 11844 goto err_clean_legacy; 11809 11845 } 11810 11846 ··· 11819 11855 -1 /* group_fd */, PERF_FLAG_FD_CLOEXEC); 11820 11856 if (pfd < 0) { 11821 11857 err = -errno; 11822 - pr_warn("legacy uprobe perf_event_open() failed: %d\n", err); 11858 + pr_warn("legacy uprobe perf_event_open() failed: %s\n", errstr(err)); 11823 11859 goto err_clean_legacy; 11824 11860 } 11825 11861 return pfd; ··· 11985 12021 enum bpf_attach_type attach_type; 11986 12022 int err = 0, link_fd, prog_fd; 11987 12023 struct bpf_link *link = NULL; 11988 - char errmsg[STRERR_BUFSIZE]; 11989 12024 char full_path[PATH_MAX]; 11990 12025 bool retprobe, session; 11991 12026 const __u64 *cookies; ··· 12038 12075 if (!strchr(path, '/')) { 12039 12076 err = resolve_full_path(path, full_path, sizeof(full_path)); 12040 12077 if (err) { 12041 - pr_warn("prog '%s': failed to resolve full path for '%s': %d\n", 12042 - prog->name, path, err); 12078 + pr_warn("prog '%s': failed to resolve full path for '%s': %s\n", 12079 + prog->name, path, errstr(err)); 12043 12080 return libbpf_err_ptr(err); 12044 12081 } 12045 12082 path = full_path; ··· 12088 12125 if (link_fd < 0) { 12089 12126 err = -errno; 12090 12127 pr_warn("prog '%s': failed to attach multi-uprobe: %s\n", 12091 - prog->name, libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 12128 + prog->name, errstr(err)); 12092 12129 goto error; 12093 12130 } 12094 12131 link->fd = link_fd; ··· 12107 12144 const struct bpf_uprobe_opts *opts) 12108 12145 { 12109 12146 const char *archive_path = NULL, *archive_sep = NULL; 12110 - char errmsg[STRERR_BUFSIZE], *legacy_probe = NULL; 12147 + char *legacy_probe = NULL; 12111 12148 DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, pe_opts); 12112 12149 enum probe_attach_mode attach_mode; 12113 12150 char full_path[PATH_MAX]; ··· 12139 12176 } else if (!strchr(binary_path, '/')) { 12140 12177 err = resolve_full_path(binary_path, full_path, sizeof(full_path)); 12141 12178 if (err) { 12142 - pr_warn("prog '%s': failed to resolve full path for '%s': %d\n", 12143 - prog->name, binary_path, err); 12179 + pr_warn("prog '%s': failed to resolve full path for '%s': %s\n", 12180 + prog->name, binary_path, errstr(err)); 12144 12181 return libbpf_err_ptr(err); 12145 12182 } 12146 12183 binary_path = full_path; ··· 12206 12243 pr_warn("prog '%s': failed to create %s '%s:0x%zx' perf event: %s\n", 12207 12244 prog->name, retprobe ? "uretprobe" : "uprobe", 12208 12245 binary_path, func_offset, 12209 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 12246 + errstr(err)); 12210 12247 goto err_out; 12211 12248 } 12212 12249 ··· 12217 12254 pr_warn("prog '%s': failed to attach to %s '%s:0x%zx': %s\n", 12218 12255 prog->name, retprobe ? "uretprobe" : "uprobe", 12219 12256 binary_path, func_offset, 12220 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 12257 + errstr(err)); 12221 12258 goto err_clean_legacy; 12222 12259 } 12223 12260 if (legacy) { ··· 12338 12375 if (!strchr(binary_path, '/')) { 12339 12376 err = resolve_full_path(binary_path, resolved_path, sizeof(resolved_path)); 12340 12377 if (err) { 12341 - pr_warn("prog '%s': failed to resolve full path for '%s': %d\n", 12342 - prog->name, binary_path, err); 12378 + pr_warn("prog '%s': failed to resolve full path for '%s': %s\n", 12379 + prog->name, binary_path, errstr(err)); 12343 12380 return libbpf_err_ptr(err); 12344 12381 } 12345 12382 binary_path = resolved_path; ··· 12417 12454 { 12418 12455 const size_t attr_sz = sizeof(struct perf_event_attr); 12419 12456 struct perf_event_attr attr; 12420 - char errmsg[STRERR_BUFSIZE]; 12421 12457 int tp_id, pfd, err; 12422 12458 12423 12459 tp_id = determine_tracepoint_id(tp_category, tp_name); 12424 12460 if (tp_id < 0) { 12425 12461 pr_warn("failed to determine tracepoint '%s/%s' perf event ID: %s\n", 12426 12462 tp_category, tp_name, 12427 - libbpf_strerror_r(tp_id, errmsg, sizeof(errmsg))); 12463 + errstr(tp_id)); 12428 12464 return tp_id; 12429 12465 } 12430 12466 ··· 12438 12476 err = -errno; 12439 12477 pr_warn("tracepoint '%s/%s' perf_event_open() failed: %s\n", 12440 12478 tp_category, tp_name, 12441 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 12479 + errstr(err)); 12442 12480 return err; 12443 12481 } 12444 12482 return pfd; ··· 12450 12488 const struct bpf_tracepoint_opts *opts) 12451 12489 { 12452 12490 DECLARE_LIBBPF_OPTS(bpf_perf_event_opts, pe_opts); 12453 - char errmsg[STRERR_BUFSIZE]; 12454 12491 struct bpf_link *link; 12455 12492 int pfd, err; 12456 12493 ··· 12462 12501 if (pfd < 0) { 12463 12502 pr_warn("prog '%s': failed to create tracepoint '%s/%s' perf event: %s\n", 12464 12503 prog->name, tp_category, tp_name, 12465 - libbpf_strerror_r(pfd, errmsg, sizeof(errmsg))); 12504 + errstr(pfd)); 12466 12505 return libbpf_err_ptr(pfd); 12467 12506 } 12468 12507 link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts); ··· 12471 12510 close(pfd); 12472 12511 pr_warn("prog '%s': failed to attach to tracepoint '%s/%s': %s\n", 12473 12512 prog->name, tp_category, tp_name, 12474 - libbpf_strerror_r(err, errmsg, sizeof(errmsg))); 12513 + errstr(err)); 12475 12514 return libbpf_err_ptr(err); 12476 12515 } 12477 12516 return link; ··· 12522 12561 struct bpf_raw_tracepoint_opts *opts) 12523 12562 { 12524 12563 LIBBPF_OPTS(bpf_raw_tp_opts, raw_opts); 12525 - char errmsg[STRERR_BUFSIZE]; 12526 12564 struct bpf_link *link; 12527 12565 int prog_fd, pfd; 12528 12566 ··· 12546 12586 pfd = -errno; 12547 12587 free(link); 12548 12588 pr_warn("prog '%s': failed to attach to raw tracepoint '%s': %s\n", 12549 - prog->name, tp_name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg))); 12589 + prog->name, tp_name, errstr(pfd)); 12550 12590 return libbpf_err_ptr(pfd); 12551 12591 } 12552 12592 link->fd = pfd; ··· 12605 12645 const struct bpf_trace_opts *opts) 12606 12646 { 12607 12647 LIBBPF_OPTS(bpf_link_create_opts, link_opts); 12608 - char errmsg[STRERR_BUFSIZE]; 12609 12648 struct bpf_link *link; 12610 12649 int prog_fd, pfd; 12611 12650 ··· 12629 12670 pfd = -errno; 12630 12671 free(link); 12631 12672 pr_warn("prog '%s': failed to attach: %s\n", 12632 - prog->name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg))); 12673 + prog->name, errstr(pfd)); 12633 12674 return libbpf_err_ptr(pfd); 12634 12675 } 12635 12676 link->fd = pfd; ··· 12670 12711 const struct bpf_link_create_opts *opts) 12671 12712 { 12672 12713 enum bpf_attach_type attach_type; 12673 - char errmsg[STRERR_BUFSIZE]; 12674 12714 struct bpf_link *link; 12675 12715 int prog_fd, link_fd; 12676 12716 ··· 12691 12733 free(link); 12692 12734 pr_warn("prog '%s': failed to attach to %s: %s\n", 12693 12735 prog->name, target_name, 12694 - libbpf_strerror_r(link_fd, errmsg, sizeof(errmsg))); 12736 + errstr(link_fd)); 12695 12737 return libbpf_err_ptr(link_fd); 12696 12738 } 12697 12739 link->fd = link_fd; ··· 12833 12875 const struct bpf_iter_attach_opts *opts) 12834 12876 { 12835 12877 DECLARE_LIBBPF_OPTS(bpf_link_create_opts, link_create_opts); 12836 - char errmsg[STRERR_BUFSIZE]; 12837 12878 struct bpf_link *link; 12838 12879 int prog_fd, link_fd; 12839 12880 __u32 target_fd = 0; ··· 12860 12903 link_fd = -errno; 12861 12904 free(link); 12862 12905 pr_warn("prog '%s': failed to attach to iterator: %s\n", 12863 - prog->name, libbpf_strerror_r(link_fd, errmsg, sizeof(errmsg))); 12906 + prog->name, errstr(link_fd)); 12864 12907 return libbpf_err_ptr(link_fd); 12865 12908 } 12866 12909 link->fd = link_fd; ··· 12902 12945 12903 12946 link_fd = bpf_link_create(prog_fd, 0, BPF_NETFILTER, &lopts); 12904 12947 if (link_fd < 0) { 12905 - char errmsg[STRERR_BUFSIZE]; 12906 - 12907 12948 link_fd = -errno; 12908 12949 free(link); 12909 12950 pr_warn("prog '%s': failed to attach to netfilter: %s\n", 12910 - prog->name, libbpf_strerror_r(link_fd, errmsg, sizeof(errmsg))); 12951 + prog->name, errstr(link_fd)); 12911 12952 return libbpf_err_ptr(link_fd); 12912 12953 } 12913 12954 link->fd = link_fd; ··· 13190 13235 int cpu, int map_key) 13191 13236 { 13192 13237 struct perf_cpu_buf *cpu_buf; 13193 - char msg[STRERR_BUFSIZE]; 13194 13238 int err; 13195 13239 13196 13240 cpu_buf = calloc(1, sizeof(*cpu_buf)); ··· 13205 13251 if (cpu_buf->fd < 0) { 13206 13252 err = -errno; 13207 13253 pr_warn("failed to open perf buffer event on cpu #%d: %s\n", 13208 - cpu, libbpf_strerror_r(err, msg, sizeof(msg))); 13254 + cpu, errstr(err)); 13209 13255 goto error; 13210 13256 } 13211 13257 ··· 13216 13262 cpu_buf->base = NULL; 13217 13263 err = -errno; 13218 13264 pr_warn("failed to mmap perf buffer on cpu #%d: %s\n", 13219 - cpu, libbpf_strerror_r(err, msg, sizeof(msg))); 13265 + cpu, errstr(err)); 13220 13266 goto error; 13221 13267 } 13222 13268 13223 13269 if (ioctl(cpu_buf->fd, PERF_EVENT_IOC_ENABLE, 0) < 0) { 13224 13270 err = -errno; 13225 13271 pr_warn("failed to enable perf buffer event on cpu #%d: %s\n", 13226 - cpu, libbpf_strerror_r(err, msg, sizeof(msg))); 13272 + cpu, errstr(err)); 13227 13273 goto error; 13228 13274 } 13229 13275 ··· 13299 13345 { 13300 13346 const char *online_cpus_file = "/sys/devices/system/cpu/online"; 13301 13347 struct bpf_map_info map; 13302 - char msg[STRERR_BUFSIZE]; 13303 13348 struct perf_buffer *pb; 13304 13349 bool *online = NULL; 13305 13350 __u32 map_info_len; ··· 13321 13368 */ 13322 13369 if (err != -EINVAL) { 13323 13370 pr_warn("failed to get map info for map FD %d: %s\n", 13324 - map_fd, libbpf_strerror_r(err, msg, sizeof(msg))); 13371 + map_fd, errstr(err)); 13325 13372 return ERR_PTR(err); 13326 13373 } 13327 13374 pr_debug("failed to get map info for FD %d; API not supported? Ignoring...\n", ··· 13351 13398 if (pb->epoll_fd < 0) { 13352 13399 err = -errno; 13353 13400 pr_warn("failed to create epoll instance: %s\n", 13354 - libbpf_strerror_r(err, msg, sizeof(msg))); 13401 + errstr(err)); 13355 13402 goto error; 13356 13403 } 13357 13404 ··· 13382 13429 13383 13430 err = parse_cpu_mask_file(online_cpus_file, &online, &n); 13384 13431 if (err) { 13385 - pr_warn("failed to get online CPU mask: %d\n", err); 13432 + pr_warn("failed to get online CPU mask: %s\n", errstr(err)); 13386 13433 goto error; 13387 13434 } 13388 13435 ··· 13413 13460 err = -errno; 13414 13461 pr_warn("failed to set cpu #%d, key %d -> perf FD %d: %s\n", 13415 13462 cpu, map_key, cpu_buf->fd, 13416 - libbpf_strerror_r(err, msg, sizeof(msg))); 13463 + errstr(err)); 13417 13464 goto error; 13418 13465 } 13419 13466 ··· 13424 13471 err = -errno; 13425 13472 pr_warn("failed to epoll_ctl cpu #%d perf FD %d: %s\n", 13426 13473 cpu, cpu_buf->fd, 13427 - libbpf_strerror_r(err, msg, sizeof(msg))); 13474 + errstr(err)); 13428 13475 goto error; 13429 13476 } 13430 13477 j++; ··· 13519 13566 13520 13567 err = perf_buffer__process_records(pb, cpu_buf); 13521 13568 if (err) { 13522 - pr_warn("error while processing records: %d\n", err); 13569 + pr_warn("error while processing records: %s\n", errstr(err)); 13523 13570 return libbpf_err(err); 13524 13571 } 13525 13572 } ··· 13603 13650 13604 13651 err = perf_buffer__process_records(pb, cpu_buf); 13605 13652 if (err) { 13606 - pr_warn("perf_buffer: failed to process records in buffer #%d: %d\n", i, err); 13653 + pr_warn("perf_buffer: failed to process records in buffer #%d: %s\n", 13654 + i, errstr(err)); 13607 13655 return libbpf_err(err); 13608 13656 } 13609 13657 } ··· 13715 13761 fd = open(fcpu, O_RDONLY | O_CLOEXEC); 13716 13762 if (fd < 0) { 13717 13763 err = -errno; 13718 - pr_warn("Failed to open cpu mask file %s: %d\n", fcpu, err); 13764 + pr_warn("Failed to open cpu mask file %s: %s\n", fcpu, errstr(err)); 13719 13765 return err; 13720 13766 } 13721 13767 len = read(fd, buf, sizeof(buf)); 13722 13768 close(fd); 13723 13769 if (len <= 0) { 13724 13770 err = len ? -errno : -EINVAL; 13725 - pr_warn("Failed to read cpu mask from %s: %d\n", fcpu, err); 13771 + pr_warn("Failed to read cpu mask from %s: %s\n", fcpu, errstr(err)); 13726 13772 return err; 13727 13773 } 13728 13774 if (len >= sizeof(buf)) { ··· 13814 13860 obj = bpf_object_open(NULL, s->data, s->data_sz, s->name, opts); 13815 13861 if (IS_ERR(obj)) { 13816 13862 err = PTR_ERR(obj); 13817 - pr_warn("failed to initialize skeleton BPF object '%s': %d\n", s->name, err); 13863 + pr_warn("failed to initialize skeleton BPF object '%s': %s\n", 13864 + s->name, errstr(err)); 13818 13865 return libbpf_err(err); 13819 13866 } 13820 13867 13821 13868 *s->obj = obj; 13822 13869 err = populate_skeleton_maps(obj, s->maps, s->map_cnt, s->map_skel_sz); 13823 13870 if (err) { 13824 - pr_warn("failed to populate skeleton maps for '%s': %d\n", s->name, err); 13871 + pr_warn("failed to populate skeleton maps for '%s': %s\n", s->name, errstr(err)); 13825 13872 return libbpf_err(err); 13826 13873 } 13827 13874 13828 13875 err = populate_skeleton_progs(obj, s->progs, s->prog_cnt, s->prog_skel_sz); 13829 13876 if (err) { 13830 - pr_warn("failed to populate skeleton progs for '%s': %d\n", s->name, err); 13877 + pr_warn("failed to populate skeleton progs for '%s': %s\n", s->name, errstr(err)); 13831 13878 return libbpf_err(err); 13832 13879 } 13833 13880 ··· 13858 13903 13859 13904 err = populate_skeleton_maps(s->obj, s->maps, s->map_cnt, s->map_skel_sz); 13860 13905 if (err) { 13861 - pr_warn("failed to populate subskeleton maps: %d\n", err); 13906 + pr_warn("failed to populate subskeleton maps: %s\n", errstr(err)); 13862 13907 return libbpf_err(err); 13863 13908 } 13864 13909 13865 13910 err = populate_skeleton_progs(s->obj, s->progs, s->prog_cnt, s->prog_skel_sz); 13866 13911 if (err) { 13867 - pr_warn("failed to populate subskeleton maps: %d\n", err); 13912 + pr_warn("failed to populate subskeleton maps: %s\n", errstr(err)); 13868 13913 return libbpf_err(err); 13869 13914 } 13870 13915 ··· 13911 13956 13912 13957 err = bpf_object__load(*s->obj); 13913 13958 if (err) { 13914 - pr_warn("failed to load BPF skeleton '%s': %d\n", s->name, err); 13959 + pr_warn("failed to load BPF skeleton '%s': %s\n", s->name, errstr(err)); 13915 13960 return libbpf_err(err); 13916 13961 } 13917 13962 ··· 13950 13995 13951 13996 err = prog->sec_def->prog_attach_fn(prog, prog->sec_def->cookie, link); 13952 13997 if (err) { 13953 - pr_warn("prog '%s': failed to auto-attach: %d\n", 13954 - bpf_program__name(prog), err); 13998 + pr_warn("prog '%s': failed to auto-attach: %s\n", 13999 + bpf_program__name(prog), errstr(err)); 13955 14000 return libbpf_err(err); 13956 14001 } 13957 14002 ··· 13994 14039 *link = bpf_map__attach_struct_ops(map); 13995 14040 if (!*link) { 13996 14041 err = -errno; 13997 - pr_warn("map '%s': failed to auto-attach: %d\n", bpf_map__name(map), err); 14042 + pr_warn("map '%s': failed to auto-attach: %s\n", 14043 + bpf_map__name(map), errstr(err)); 13998 14044 return libbpf_err(err); 13999 14045 } 14000 14046 }

+12 -9

tools/lib/bpf/linker.c

··· 20 20 #include "btf.h" 21 21 #include "libbpf_internal.h" 22 22 #include "strset.h" 23 + #include "str_error.h" 23 24 24 25 #define BTF_EXTERN_SEC ".extern" 25 26 ··· 307 306 linker->fd = open(file, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644); 308 307 if (linker->fd < 0) { 309 308 err = -errno; 310 - pr_warn("failed to create '%s': %d\n", file, err); 309 + pr_warn("failed to create '%s': %s\n", file, errstr(err)); 311 310 return err; 312 311 } 313 312 ··· 561 560 obj->fd = open(filename, O_RDONLY | O_CLOEXEC); 562 561 if (obj->fd < 0) { 563 562 err = -errno; 564 - pr_warn("failed to open file '%s': %d\n", filename, err); 563 + pr_warn("failed to open file '%s': %s\n", filename, errstr(err)); 565 564 return err; 566 565 } 567 566 obj->elf = elf_begin(obj->fd, ELF_C_READ_MMAP, NULL); ··· 671 670 obj->btf = btf__new(data->d_buf, shdr->sh_size); 672 671 err = libbpf_get_error(obj->btf); 673 672 if (err) { 674 - pr_warn("failed to parse .BTF from %s: %d\n", filename, err); 673 + pr_warn("failed to parse .BTF from %s: %s\n", 674 + filename, errstr(err)); 675 675 return err; 676 676 } 677 677 sec->skipped = true; ··· 682 680 obj->btf_ext = btf_ext__new(data->d_buf, shdr->sh_size); 683 681 err = libbpf_get_error(obj->btf_ext); 684 682 if (err) { 685 - pr_warn("failed to parse .BTF.ext from '%s': %d\n", filename, err); 683 + pr_warn("failed to parse .BTF.ext from '%s': %s\n", 684 + filename, errstr(err)); 686 685 return err; 687 686 } 688 687 sec->skipped = true; ··· 2777 2774 2778 2775 err = finalize_btf_ext(linker); 2779 2776 if (err) { 2780 - pr_warn(".BTF.ext generation failed: %d\n", err); 2777 + pr_warn(".BTF.ext generation failed: %s\n", errstr(err)); 2781 2778 return err; 2782 2779 } 2783 2780 2784 2781 opts.btf_ext = linker->btf_ext; 2785 2782 err = btf__dedup(linker->btf, &opts); 2786 2783 if (err) { 2787 - pr_warn("BTF dedup failed: %d\n", err); 2784 + pr_warn("BTF dedup failed: %s\n", errstr(err)); 2788 2785 return err; 2789 2786 } 2790 2787 ··· 2802 2799 2803 2800 err = emit_elf_data_sec(linker, BTF_ELF_SEC, 8, raw_data, raw_sz); 2804 2801 if (err) { 2805 - pr_warn("failed to write out .BTF ELF section: %d\n", err); 2802 + pr_warn("failed to write out .BTF ELF section: %s\n", errstr(err)); 2806 2803 return err; 2807 2804 } 2808 2805 ··· 2814 2811 2815 2812 err = emit_elf_data_sec(linker, BTF_EXT_ELF_SEC, 8, raw_data, raw_sz); 2816 2813 if (err) { 2817 - pr_warn("failed to write out .BTF.ext ELF section: %d\n", err); 2814 + pr_warn("failed to write out .BTF.ext ELF section: %s\n", errstr(err)); 2818 2815 return err; 2819 2816 } 2820 2817 } ··· 2990 2987 err = libbpf_get_error(linker->btf_ext); 2991 2988 if (err) { 2992 2989 linker->btf_ext = NULL; 2993 - pr_warn("failed to parse final .BTF.ext data: %d\n", err); 2990 + pr_warn("failed to parse final .BTF.ext data: %s\n", errstr(err)); 2994 2991 goto out; 2995 2992 } 2996 2993

+18 -16

tools/lib/bpf/ringbuf.c

··· 21 21 #include "libbpf.h" 22 22 #include "libbpf_internal.h" 23 23 #include "bpf.h" 24 + #include "str_error.h" 24 25 25 26 struct ring { 26 27 ring_buffer_sample_fn sample_cb; ··· 89 88 err = bpf_map_get_info_by_fd(map_fd, &info, &len); 90 89 if (err) { 91 90 err = -errno; 92 - pr_warn("ringbuf: failed to get map info for fd=%d: %d\n", 93 - map_fd, err); 91 + pr_warn("ringbuf: failed to get map info for fd=%d: %s\n", 92 + map_fd, errstr(err)); 94 93 return libbpf_err(err); 95 94 } 96 95 ··· 124 123 tmp = mmap(NULL, rb->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0); 125 124 if (tmp == MAP_FAILED) { 126 125 err = -errno; 127 - pr_warn("ringbuf: failed to mmap consumer page for map fd=%d: %d\n", 128 - map_fd, err); 126 + pr_warn("ringbuf: failed to mmap consumer page for map fd=%d: %s\n", 127 + map_fd, errstr(err)); 129 128 goto err_out; 130 129 } 131 130 r->consumer_pos = tmp; ··· 143 142 tmp = mmap(NULL, (size_t)mmap_sz, PROT_READ, MAP_SHARED, map_fd, rb->page_size); 144 143 if (tmp == MAP_FAILED) { 145 144 err = -errno; 146 - pr_warn("ringbuf: failed to mmap data pages for map fd=%d: %d\n", 147 - map_fd, err); 145 + pr_warn("ringbuf: failed to mmap data pages for map fd=%d: %s\n", 146 + map_fd, errstr(err)); 148 147 goto err_out; 149 148 } 150 149 r->producer_pos = tmp; ··· 157 156 e->data.fd = rb->ring_cnt; 158 157 if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, e) < 0) { 159 158 err = -errno; 160 - pr_warn("ringbuf: failed to epoll add map fd=%d: %d\n", 161 - map_fd, err); 159 + pr_warn("ringbuf: failed to epoll add map fd=%d: %s\n", 160 + map_fd, errstr(err)); 162 161 goto err_out; 163 162 } 164 163 ··· 206 205 rb->epoll_fd = epoll_create1(EPOLL_CLOEXEC); 207 206 if (rb->epoll_fd < 0) { 208 207 err = -errno; 209 - pr_warn("ringbuf: failed to create epoll instance: %d\n", err); 208 + pr_warn("ringbuf: failed to create epoll instance: %s\n", errstr(err)); 210 209 goto err_out; 211 210 } 212 211 ··· 459 458 err = bpf_map_get_info_by_fd(map_fd, &info, &len); 460 459 if (err) { 461 460 err = -errno; 462 - pr_warn("user ringbuf: failed to get map info for fd=%d: %d\n", map_fd, err); 461 + pr_warn("user ringbuf: failed to get map info for fd=%d: %s\n", 462 + map_fd, errstr(err)); 463 463 return err; 464 464 } 465 465 ··· 476 474 tmp = mmap(NULL, rb->page_size, PROT_READ, MAP_SHARED, map_fd, 0); 477 475 if (tmp == MAP_FAILED) { 478 476 err = -errno; 479 - pr_warn("user ringbuf: failed to mmap consumer page for map fd=%d: %d\n", 480 - map_fd, err); 477 + pr_warn("user ringbuf: failed to mmap consumer page for map fd=%d: %s\n", 478 + map_fd, errstr(err)); 481 479 return err; 482 480 } 483 481 rb->consumer_pos = tmp; ··· 496 494 map_fd, rb->page_size); 497 495 if (tmp == MAP_FAILED) { 498 496 err = -errno; 499 - pr_warn("user ringbuf: failed to mmap data pages for map fd=%d: %d\n", 500 - map_fd, err); 497 + pr_warn("user ringbuf: failed to mmap data pages for map fd=%d: %s\n", 498 + map_fd, errstr(err)); 501 499 return err; 502 500 } 503 501 ··· 508 506 rb_epoll->events = EPOLLOUT; 509 507 if (epoll_ctl(rb->epoll_fd, EPOLL_CTL_ADD, map_fd, rb_epoll) < 0) { 510 508 err = -errno; 511 - pr_warn("user ringbuf: failed to epoll add map fd=%d: %d\n", map_fd, err); 509 + pr_warn("user ringbuf: failed to epoll add map fd=%d: %s\n", map_fd, errstr(err)); 512 510 return err; 513 511 } 514 512 ··· 533 531 rb->epoll_fd = epoll_create1(EPOLL_CLOEXEC); 534 532 if (rb->epoll_fd < 0) { 535 533 err = -errno; 536 - pr_warn("user ringbuf: failed to create epoll instance: %d\n", err); 534 + pr_warn("user ringbuf: failed to create epoll instance: %s\n", errstr(err)); 537 535 goto err_out; 538 536 } 539 537

+71

tools/lib/bpf/str_error.c

··· 5 5 #include <errno.h> 6 6 #include "str_error.h" 7 7 8 + #ifndef ENOTSUPP 9 + #define ENOTSUPP 524 10 + #endif 11 + 8 12 /* make sure libbpf doesn't use kernel-only integer typedefs */ 9 13 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64 10 14 ··· 34 30 snprintf(dst, len, "ERROR: strerror_r(%d)=%d", err, ret); 35 31 } 36 32 return dst; 33 + } 34 + 35 + const char *errstr(int err) 36 + { 37 + static __thread char buf[12]; 38 + 39 + if (err > 0) 40 + err = -err; 41 + 42 + switch (err) { 43 + case -E2BIG: return "-E2BIG"; 44 + case -EACCES: return "-EACCES"; 45 + case -EADDRINUSE: return "-EADDRINUSE"; 46 + case -EADDRNOTAVAIL: return "-EADDRNOTAVAIL"; 47 + case -EAGAIN: return "-EAGAIN"; 48 + case -EALREADY: return "-EALREADY"; 49 + case -EBADF: return "-EBADF"; 50 + case -EBADFD: return "-EBADFD"; 51 + case -EBUSY: return "-EBUSY"; 52 + case -ECANCELED: return "-ECANCELED"; 53 + case -ECHILD: return "-ECHILD"; 54 + case -EDEADLK: return "-EDEADLK"; 55 + case -EDOM: return "-EDOM"; 56 + case -EEXIST: return "-EEXIST"; 57 + case -EFAULT: return "-EFAULT"; 58 + case -EFBIG: return "-EFBIG"; 59 + case -EILSEQ: return "-EILSEQ"; 60 + case -EINPROGRESS: return "-EINPROGRESS"; 61 + case -EINTR: return "-EINTR"; 62 + case -EINVAL: return "-EINVAL"; 63 + case -EIO: return "-EIO"; 64 + case -EISDIR: return "-EISDIR"; 65 + case -ELOOP: return "-ELOOP"; 66 + case -EMFILE: return "-EMFILE"; 67 + case -EMLINK: return "-EMLINK"; 68 + case -EMSGSIZE: return "-EMSGSIZE"; 69 + case -ENAMETOOLONG: return "-ENAMETOOLONG"; 70 + case -ENFILE: return "-ENFILE"; 71 + case -ENODATA: return "-ENODATA"; 72 + case -ENODEV: return "-ENODEV"; 73 + case -ENOENT: return "-ENOENT"; 74 + case -ENOEXEC: return "-ENOEXEC"; 75 + case -ENOLINK: return "-ENOLINK"; 76 + case -ENOMEM: return "-ENOMEM"; 77 + case -ENOSPC: return "-ENOSPC"; 78 + case -ENOTBLK: return "-ENOTBLK"; 79 + case -ENOTDIR: return "-ENOTDIR"; 80 + case -ENOTSUPP: return "-ENOTSUPP"; 81 + case -ENOTTY: return "-ENOTTY"; 82 + case -ENXIO: return "-ENXIO"; 83 + case -EOPNOTSUPP: return "-EOPNOTSUPP"; 84 + case -EOVERFLOW: return "-EOVERFLOW"; 85 + case -EPERM: return "-EPERM"; 86 + case -EPIPE: return "-EPIPE"; 87 + case -EPROTO: return "-EPROTO"; 88 + case -EPROTONOSUPPORT: return "-EPROTONOSUPPORT"; 89 + case -ERANGE: return "-ERANGE"; 90 + case -EROFS: return "-EROFS"; 91 + case -ESPIPE: return "-ESPIPE"; 92 + case -ESRCH: return "-ESRCH"; 93 + case -ETXTBSY: return "-ETXTBSY"; 94 + case -EUCLEAN: return "-EUCLEAN"; 95 + case -EXDEV: return "-EXDEV"; 96 + default: 97 + snprintf(buf, sizeof(buf), "%d", err); 98 + return buf; 99 + } 37 100 }

+7

tools/lib/bpf/str_error.h

··· 6 6 7 7 char *libbpf_strerror_r(int err, char *dst, int len); 8 8 9 + /** 10 + * @brief **errstr()** returns string corresponding to numeric errno 11 + * @param err negative numeric errno 12 + * @return pointer to string representation of the errno, that is invalidated 13 + * upon the next call. 14 + */ 15 + const char *errstr(int err); 9 16 #endif /* __LIBBPF_STR_ERROR_H */

+17 -15

tools/lib/bpf/usdt.c

··· 20 20 #include "libbpf_common.h" 21 21 #include "libbpf_internal.h" 22 22 #include "hashmap.h" 23 + #include "str_error.h" 23 24 24 25 /* libbpf's USDT support consists of BPF-side state/code and user-space 25 26 * state/code working together in concert. BPF-side parts are defined in ··· 466 465 goto proceed; 467 466 468 467 if (!realpath(lib_path, path)) { 469 - pr_warn("usdt: failed to get absolute path of '%s' (err %d), using path as is...\n", 470 - lib_path, -errno); 468 + pr_warn("usdt: failed to get absolute path of '%s' (err %s), using path as is...\n", 469 + lib_path, errstr(-errno)); 471 470 libbpf_strlcpy(path, lib_path, sizeof(path)); 472 471 } 473 472 ··· 476 475 f = fopen(line, "re"); 477 476 if (!f) { 478 477 err = -errno; 479 - pr_warn("usdt: failed to open '%s' to get base addr of '%s': %d\n", 480 - line, lib_path, err); 478 + pr_warn("usdt: failed to open '%s' to get base addr of '%s': %s\n", 479 + line, lib_path, errstr(err)); 481 480 return err; 482 481 } 483 482 ··· 607 606 608 607 err = parse_elf_segs(elf, path, &segs, &seg_cnt); 609 608 if (err) { 610 - pr_warn("usdt: failed to process ELF program segments for '%s': %d\n", path, err); 609 + pr_warn("usdt: failed to process ELF program segments for '%s': %s\n", 610 + path, errstr(err)); 611 611 goto err_out; 612 612 } 613 613 ··· 710 708 if (vma_seg_cnt == 0) { 711 709 err = parse_vma_segs(pid, path, &vma_segs, &vma_seg_cnt); 712 710 if (err) { 713 - pr_warn("usdt: failed to get memory segments in PID %d for shared library '%s': %d\n", 714 - pid, path, err); 711 + pr_warn("usdt: failed to get memory segments in PID %d for shared library '%s': %s\n", 712 + pid, path, errstr(err)); 715 713 goto err_out; 716 714 } 717 715 } ··· 1049 1047 1050 1048 if (is_new && bpf_map_update_elem(spec_map_fd, &spec_id, &target->spec, BPF_ANY)) { 1051 1049 err = -errno; 1052 - pr_warn("usdt: failed to set USDT spec #%d for '%s:%s' in '%s': %d\n", 1053 - spec_id, usdt_provider, usdt_name, path, err); 1050 + pr_warn("usdt: failed to set USDT spec #%d for '%s:%s' in '%s': %s\n", 1051 + spec_id, usdt_provider, usdt_name, path, errstr(err)); 1054 1052 goto err_out; 1055 1053 } 1056 1054 if (!man->has_bpf_cookie && ··· 1060 1058 pr_warn("usdt: IP collision detected for spec #%d for '%s:%s' in '%s'\n", 1061 1059 spec_id, usdt_provider, usdt_name, path); 1062 1060 } else { 1063 - pr_warn("usdt: failed to map IP 0x%lx to spec #%d for '%s:%s' in '%s': %d\n", 1061 + pr_warn("usdt: failed to map IP 0x%lx to spec #%d for '%s:%s' in '%s': %s\n", 1064 1062 target->abs_ip, spec_id, usdt_provider, usdt_name, 1065 - path, err); 1063 + path, errstr(err)); 1066 1064 } 1067 1065 goto err_out; 1068 1066 } ··· 1078 1076 target->rel_ip, &opts); 1079 1077 err = libbpf_get_error(uprobe_link); 1080 1078 if (err) { 1081 - pr_warn("usdt: failed to attach uprobe #%d for '%s:%s' in '%s': %d\n", 1082 - i, usdt_provider, usdt_name, path, err); 1079 + pr_warn("usdt: failed to attach uprobe #%d for '%s:%s' in '%s': %s\n", 1080 + i, usdt_provider, usdt_name, path, errstr(err)); 1083 1081 goto err_out; 1084 1082 } 1085 1083 ··· 1101 1099 NULL, &opts_multi); 1102 1100 if (!link->multi_link) { 1103 1101 err = -errno; 1104 - pr_warn("usdt: failed to attach uprobe multi for '%s:%s' in '%s': %d\n", 1105 - usdt_provider, usdt_name, path, err); 1102 + pr_warn("usdt: failed to attach uprobe multi for '%s:%s' in '%s': %s\n", 1103 + usdt_provider, usdt_name, path, errstr(err)); 1106 1104 goto err_out; 1107 1105 } 1108 1106

Configure Feed

Configure Feed