Lines Matching defs:map
73 static int map_set_def_max_entries(struct bpf_map *map);
984 static bool bpf_map__is_struct_ops(const struct bpf_map *map)
986 return map->def.type == BPF_MAP_TYPE_STRUCT_OPS;
989 /* Init the map's fields that depend on kern_btf */
990 static int bpf_map__init_kern_struct_ops(struct bpf_map *map,
1002 st_ops = map->st_ops;
1013 map->name, st_ops->type_id, kern_type_id, kern_vtype_id);
1015 map->def.value_size = kern_vtype->size;
1016 map->btf_vmlinux_value_type_id = kern_vtype_id;
1040 map->name, mname);
1048 map->name, mname);
1064 map->name, mname, BTF_INFO_KIND(mtype->info),
1086 map->name, mname);
1096 map->name, mname, prog->name, moff,
1106 map->name, mname, (ssize_t)msize,
1112 map->name, mname, (unsigned int)msize,
1122 struct bpf_map *map;
1127 map = &obj->maps[i];
1129 if (!bpf_map__is_struct_ops(map))
1132 err = bpf_map__init_kern_struct_ops(map, obj->btf,
1150 struct bpf_map *map;
1189 map = bpf_object__add_map(obj);
1190 if (IS_ERR(map))
1191 return PTR_ERR(map);
1193 map->sec_idx = shndx;
1194 map->sec_offset = vsi->offset;
1195 map->name = strdup(var_name);
1196 if (!map->name)
1199 map->def.type = BPF_MAP_TYPE_STRUCT_OPS;
1200 map->def.key_size = sizeof(int);
1201 map->def.value_size = type->size;
1202 map->def.max_entries = 1;
1203 map->def.map_flags = map_flags;
1205 map->st_ops = calloc(1, sizeof(*map->st_ops));
1206 if (!map->st_ops)
1208 st_ops = map->st_ops;
1496 struct bpf_map *map;
1504 map = &obj->maps[obj->nr_maps++];
1505 map->obj = obj;
1506 map->fd = -1;
1507 map->inner_map_fd = -1;
1508 map->autocreate = true;
1510 return map;
1523 static int bpf_map_mmap_resize(struct bpf_map *map, size_t old_sz, size_t new_sz)
1527 if (!map->mmaped)
1537 memcpy(mmaped, map->mmaped, min(old_sz, new_sz));
1538 munmap(map->mmaped, old_sz);
1539 map->mmaped = mmaped;
1554 * and internal map corresponding to '.rodata' ELF section. The final
1555 * map name advertised to user and to the kernel will be
1558 * Somewhat confusingly, if internal map ELF section name is shorter
1561 * resulting map will be called 'my_objec.bss', not even using all 15
1563 * object name is somewhat consistent in this case. But if the map
1566 * object name ('my_obje'). Happy guessing, user, that the final map
1579 * BTF type associated with such map's value type, though.
1584 /* if there are two or more dots in map name, it's a custom dot map */
1593 /* sanitise map name to characters allowed by kernel */
1602 map_fill_btf_type_info(struct bpf_object *obj, struct bpf_map *map);
1604 /* Internal BPF map is mmap()'able only if at least one of corresponding
1609 static bool map_is_mmapable(struct bpf_object *obj, struct bpf_map *map)
1615 if (!map->btf_value_type_id)
1618 t = btf__type_by_id(obj->btf, map->btf_value_type_id);
1640 struct bpf_map *map;
1644 map = bpf_object__add_map(obj);
1645 if (IS_ERR(map))
1646 return PTR_ERR(map);
1648 map->libbpf_type = type;
1649 map->sec_idx = sec_idx;
1650 map->sec_offset = 0;
1651 map->real_name = strdup(real_name);
1652 map->name = internal_map_name(obj, real_name);
1653 if (!map->real_name || !map->name) {
1654 zfree(&map->real_name);
1655 zfree(&map->name);
1659 def = &map->def;
1668 (void) map_fill_btf_type_info(obj, map);
1670 if (map_is_mmapable(obj, map))
1673 pr_debug("map '%s' (global data): at sec_idx %d, offset %zu, flags %x.\n",
1674 map->name, map->sec_idx, map->sec_offset, def->map_flags);
1676 mmap_sz = bpf_map_mmap_sz(map->def.value_size, map->def.max_entries);
1677 map->mmaped = mmap(NULL, mmap_sz, PROT_READ | PROT_WRITE,
1679 if (map->mmaped == MAP_FAILED) {
1681 map->mmaped = NULL;
1682 pr_warn("failed to alloc map '%s' content buffer: %d\n",
1683 map->name, err);
1684 zfree(&map->real_name);
1685 zfree(&map->name);
1690 memcpy(map->mmaped, data, data_sz);
1692 pr_debug("map %td is \"%s\"\n", map - obj->maps, map->name);
2128 * Fetch integer attribute of BTF map definition. Such attributes are
2143 pr_warn("map '%s': attr '%s': expected PTR, got %s.\n",
2150 pr_warn("map '%s': attr '%s': type [%u] not found.\n",
2155 pr_warn("map '%s': attr '%s': expected ARRAY, got %s.\n",
2177 static int build_map_pin_path(struct bpf_map *map, const char *path)
2185 err = pathname_concat(buf, sizeof(buf), path, bpf_map__name(map));
2189 return bpf_map__set_pin_path(map, buf);
2214 pr_warn("map '%s': invalid field #%d.\n", map_name, i);
2239 pr_warn("map '%s': conflicting key size %u != %u.\n",
2250 pr_warn("map '%s': key type [%d] not found.\n",
2255 pr_warn("map '%s': key spec is not PTR: %s.\n",
2261 pr_warn("map '%s': can't determine key size for type [%u]: %zd.\n",
2266 pr_warn("map '%s': conflicting key size %u != %zd.\n",
2279 pr_warn("map '%s': conflicting value size %u != %u.\n",
2290 pr_warn("map '%s': value type [%d] not found.\n",
2295 pr_warn("map '%s': value spec is not PTR: %s.\n",
2301 pr_warn("map '%s': can't determine value size for type [%u]: %zd.\n",
2306 pr_warn("map '%s': conflicting value size %u != %zd.\n",
2317 const char *desc = is_map_in_map ? "map-in-map inner" : "prog-array value";
2322 pr_warn("map '%s': multi-level inner maps not supported.\n",
2327 pr_warn("map '%s': '%s' member should be last.\n",
2332 pr_warn("map '%s': should be map-in-map or prog-array.\n",
2337 pr_warn("map '%s': conflicting value size %u != 4.\n",
2344 pr_warn("map '%s': %s type [%d] not found.\n",
2349 pr_warn("map '%s': %s spec is not a zero-sized array.\n",
2355 pr_warn("map '%s': %s def is of unexpected kind %s.\n",
2362 pr_warn("map '%s': prog-array value def is of unexpected kind %s.\n",
2369 pr_warn("map '%s': map-in-map inner def is of unexpected kind %s.\n",
2384 pr_warn("map '%s': inner def can't be pinned.\n", map_name);
2390 pr_warn("map '%s': invalid pinning value %u.\n",
2405 pr_warn("map '%s': unknown field '%s'.\n", map_name, name);
2408 pr_debug("map '%s': ignoring unknown field '%s'.\n", map_name, name);
2413 pr_warn("map '%s': map type isn't specified.\n", map_name);
2437 * requirements and substitute correct max_entries for map creation.
2451 static bool map_is_ringbuf(const struct bpf_map *map)
2453 return map->def.type == BPF_MAP_TYPE_RINGBUF ||
2454 map->def.type == BPF_MAP_TYPE_USER_RINGBUF;
2457 static void fill_map_from_def(struct bpf_map *map, const struct btf_map_def *def)
2459 map->def.type = def->map_type;
2460 map->def.key_size = def->key_size;
2461 map->def.value_size = def->value_size;
2462 map->def.max_entries = def->max_entries;
2463 map->def.map_flags = def->map_flags;
2464 map->map_extra = def->map_extra;
2466 map->numa_node = def->numa_node;
2467 map->btf_key_type_id = def->key_type_id;
2468 map->btf_value_type_id = def->value_type_id;
2470 /* auto-adjust BPF ringbuf map max_entries to be a multiple of page size */
2471 if (map_is_ringbuf(map))
2472 map->def.max_entries = adjust_ringbuf_sz(map->def.max_entries);
2475 pr_debug("map '%s': found type = %u.\n", map->name, def->map_type);
2478 pr_debug("map '%s': found key [%u], sz = %u.\n",
2479 map->name, def->key_type_id, def->key_size);
2481 pr_debug("map '%s': found key_size = %u.\n", map->name, def->key_size);
2484 pr_debug("map '%s': found value [%u], sz = %u.\n",
2485 map->name, def->value_type_id, def->value_size);
2487 pr_debug("map '%s': found value_size = %u.\n", map->name, def->value_size);
2490 pr_debug("map '%s': found max_entries = %u.\n", map->name, def->max_entries);
2492 pr_debug("map '%s': found map_flags = 0x%x.\n", map->name, def->map_flags);
2494 pr_debug("map '%s': found map_extra = 0x%llx.\n", map->name,
2497 pr_debug("map '%s': found pinning = %u.\n", map->name, def->pinning);
2499 pr_debug("map '%s': found numa_node = %u.\n", map->name, def->numa_node);
2502 pr_debug("map '%s': found inner map definition.\n", map->name);
2526 struct bpf_map *map;
2535 pr_warn("map #%d: empty name.\n", var_idx);
2539 pr_warn("map '%s' BTF data is corrupted.\n", map_name);
2543 pr_warn("map '%s': unexpected var kind %s.\n",
2548 pr_warn("map '%s': unsupported map linkage %s.\n",
2555 pr_warn("map '%s': unexpected def kind %s.\n",
2560 pr_warn("map '%s': invalid def size.\n", map_name);
2564 map = bpf_object__add_map(obj);
2565 if (IS_ERR(map))
2566 return PTR_ERR(map);
2567 map->name = strdup(map_name);
2568 if (!map->name) {
2569 pr_warn("map '%s': failed to alloc map name.\n", map_name);
2572 map->libbpf_type = LIBBPF_MAP_UNSPEC;
2573 map->def.type = BPF_MAP_TYPE_UNSPEC;
2574 map->sec_idx = sec_idx;
2575 map->sec_offset = vi->offset;
2576 map->btf_var_idx = var_idx;
2577 pr_debug("map '%s': at sec_idx %d, offset %zu.\n",
2578 map_name, map->sec_idx, map->sec_offset);
2580 err = parse_btf_map_def(map->name, obj->btf, def, strict, &map_def, &inner_def);
2584 fill_map_from_def(map, &map_def);
2587 err = build_map_pin_path(map, pin_root_path);
2589 pr_warn("map '%s': couldn't build pin path.\n", map->name);
2595 map->inner_map = calloc(1, sizeof(*map->inner_map));
2596 if (!map->inner_map)
2598 map->inner_map->fd = -1;
2599 map->inner_map->sec_idx = sec_idx;
2600 map->inner_map->name = malloc(strlen(map_name) + sizeof(".inner") + 1);
2601 if (!map->inner_map->name)
2603 sprintf(map->inner_map->name, "%s.inner", map_name);
2605 fill_map_from_def(map->inner_map, &inner_def);
2608 err = map_fill_btf_type_info(obj, map);
2631 pr_warn("elf: failed to get %s map definitions for %s\n",
3479 pr_warn("elf: legacy map definitions in 'maps' section are not supported by libbpf v1.0+\n");
3959 /* for kcfg externs calculate their offsets within a .kconfig map */
4059 struct bpf_map *map;
4143 /* generic map reference relocation */
4146 pr_warn("prog '%s': bad map relo against '%s' in section '%s'\n",
4151 map = &obj->maps[map_idx];
4152 if (map->libbpf_type != type ||
4153 map->sec_idx != sym->st_shndx ||
4154 map->sec_offset != sym->st_value)
4156 pr_debug("prog '%s': found map %zd (%s, sec %d, off %zu) for insn #%u\n",
4157 prog->name, map_idx, map->name, map->sec_idx,
4158 map->sec_offset, insn_idx);
4162 pr_warn("prog '%s': map relo failed to find map for section '%s', off %zu\n",
4173 /* global data map relocation */
4180 map = &obj->maps[map_idx];
4181 if (map->libbpf_type != type || map->sec_idx != sym->st_shndx)
4183 pr_debug("prog '%s': found data map %zd (%s, sec %d, off %zu) for insn %u\n",
4184 prog->name, map_idx, map->name, map->sec_idx,
4185 map->sec_offset, insn_idx);
4189 pr_warn("prog '%s': data relo failed to find map for section '%s'\n",
4335 static int map_fill_btf_type_info(struct bpf_object *obj, struct bpf_map *map)
4342 /* if it's BTF-defined map, we don't need to search for type IDs.
4343 * For struct_ops map, it does not need btf_key_type_id and
4346 if (map->sec_idx == obj->efile.btf_maps_shndx || bpf_map__is_struct_ops(map))
4353 if (!bpf_map__is_internal(map))
4356 id = btf__find_by_name(obj->btf, map->real_name);
4360 map->btf_key_type_id = 0;
4361 map->btf_value_type_id = id;
4401 bool bpf_map__autocreate(const struct bpf_map *map)
4403 return map->autocreate;
4406 int bpf_map__set_autocreate(struct bpf_map *map, bool autocreate)
4408 if (map->obj->loaded)
4411 map->autocreate = autocreate;
4415 int bpf_map__reuse_fd(struct bpf_map *map, int fd)
4430 if (name_len == BPF_OBJ_NAME_LEN - 1 && strncmp(map->name, info.name, name_len) == 0)
4431 new_name = strdup(map->name);
4449 err = zclose(map->fd);
4454 free(map->name);
4456 map->fd = new_fd;
4457 map->name = new_name;
4458 map->def.type = info.type;
4459 map->def.key_size = info.key_size;
4460 map->def.value_size = info.value_size;
4461 map->def.max_entries = info.max_entries;
4462 map->def.map_flags = info.map_flags;
4463 map->btf_key_type_id = info.btf_key_type_id;
4464 map->btf_value_type_id = info.btf_value_type_id;
4465 map->reused = true;
4466 map->map_extra = info.map_extra;
4477 __u32 bpf_map__max_entries(const struct bpf_map *map)
4479 return map->def.max_entries;
4482 struct bpf_map *bpf_map__inner_map(struct bpf_map *map)
4484 if (!bpf_map_type__is_map_in_map(map->def.type))
4487 return map->inner_map;
4490 int bpf_map__set_max_entries(struct bpf_map *map, __u32 max_entries)
4492 if (map->obj->loaded)
4495 map->def.max_entries = max_entries;
4497 /* auto-adjust BPF ringbuf map max_entries to be a multiple of page size */
4498 if (map_is_ringbuf(map))
4499 map->def.max_entries = adjust_ringbuf_sz(map->def.max_entries);
4577 int ret, map, insn_cnt = ARRAY_SIZE(insns);
4579 map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_global", sizeof(int), 32, 1, NULL);
4580 if (map < 0) {
4583 pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
4588 insns[0].imm = map;
4591 close(map);
4757 int ret, map, prog, insn_cnt = ARRAY_SIZE(insns);
4759 map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_det_bind", sizeof(int), 32, 1, NULL);
4760 if (map < 0) {
4763 pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
4770 close(map);
4774 ret = bpf_prog_bind_map(prog, map, NULL);
4776 close(map);
4927 "ARRAY map mmap()", probe_kern_array_mmap,
4997 static bool map_is_reuse_compat(const struct bpf_map *map, int map_fd)
5009 pr_warn("failed to get map info for map FD %d: %s\n", map_fd,
5014 return (map_info.type == map->def.type &&
5015 map_info.key_size == map->def.key_size &&
5016 map_info.value_size == map->def.value_size &&
5017 map_info.max_entries == map->def.max_entries &&
5018 map_info.map_flags == map->def.map_flags &&
5019 map_info.map_extra == map->map_extra);
5023 bpf_object__reuse_map(struct bpf_map *map)
5028 pin_fd = bpf_obj_get(map->pin_path);
5032 pr_debug("found no pinned map to reuse at '%s'\n",
5033 map->pin_path);
5038 pr_warn("couldn't retrieve pinned map '%s': %s\n",
5039 map->pin_path, cp);
5043 if (!map_is_reuse_compat(map, pin_fd)) {
5044 pr_warn("couldn't reuse pinned map at '%s': parameter mismatch\n",
5045 map->pin_path);
5050 err = bpf_map__reuse_fd(map, pin_fd);
5055 map->pinned = true;
5056 pr_debug("reused pinned map at '%s'\n", map->pin_path);
5062 bpf_object__populate_internal_map(struct bpf_object *obj, struct bpf_map *map)
5064 enum libbpf_map_type map_type = map->libbpf_type;
5069 bpf_gen__map_update_elem(obj->gen_loader, map - obj->maps,
5070 map->mmaped, map->def.value_size);
5072 bpf_gen__map_freeze(obj->gen_loader, map - obj->maps);
5075 err = bpf_map_update_elem(map->fd, &zero, map->mmaped, 0);
5079 pr_warn("Error setting initial map(%s) contents: %s\n",
5080 map->name, cp);
5084 /* Freeze .rodata and .kconfig map as read-only from syscall side. */
5086 err = bpf_map_freeze(map->fd);
5090 pr_warn("Error freezing map(%s) as read-only: %s\n",
5091 map->name, cp);
5098 static void bpf_map__destroy(struct bpf_map *map);
5100 static int bpf_object__create_map(struct bpf_object *obj, struct bpf_map *map, bool is_inner)
5103 struct bpf_map_def *def = &map->def;
5108 map_name = map->name;
5109 create_attr.map_ifindex = map->map_ifindex;
5111 create_attr.numa_node = map->numa_node;
5112 create_attr.map_extra = map->map_extra;
5114 if (bpf_map__is_struct_ops(map))
5115 create_attr.btf_vmlinux_value_type_id = map->btf_vmlinux_value_type_id;
5119 create_attr.btf_key_type_id = map->btf_key_type_id;
5120 create_attr.btf_value_type_id = map->btf_value_type_id;
5124 if (map->inner_map) {
5125 err = map_set_def_max_entries(map->inner_map);
5128 err = bpf_object__create_map(obj, map->inner_map, true);
5130 pr_warn("map '%s': failed to create inner map: %d\n",
5131 map->name, err);
5134 map->inner_map_fd = bpf_map__fd(map->inner_map);
5136 if (map->inner_map_fd >= 0)
5137 create_attr.inner_map_fd = map->inner_map_fd;
5157 map->btf_key_type_id = 0;
5158 map->btf_value_type_id = 0;
5166 &create_attr, is_inner ? -1 : map - obj->maps);
5170 map->fd = 0;
5172 map->fd = bpf_map_create(def->type, map_name,
5176 if (map->fd < 0 && (create_attr.btf_key_type_id ||
5183 map->name, cp, err);
5187 map->btf_key_type_id = 0;
5188 map->btf_value_type_id = 0;
5189 map->fd = bpf_map_create(def->type, map_name,
5194 err = map->fd < 0 ? -errno : 0;
5196 if (bpf_map_type__is_map_in_map(def->type) && map->inner_map) {
5198 map->inner_map->fd = -1;
5199 bpf_map__destroy(map->inner_map);
5200 zfree(&map->inner_map);
5206 static int init_map_in_map_slots(struct bpf_object *obj, struct bpf_map *map)
5212 for (i = 0; i < map->init_slots_sz; i++) {
5213 if (!map->init_slots[i])
5216 targ_map = map->init_slots[i];
5221 map - obj->maps, i,
5224 err = bpf_map_update_elem(map->fd, &i, &fd, 0);
5228 pr_warn("map '%s': failed to initialize slot [%d] to map '%s' fd=%d: %d\n",
5229 map->name, i, targ_map->name, fd, err);
5232 pr_debug("map '%s': slot [%d] set to map '%s' fd=%d\n",
5233 map->name, i, targ_map->name, fd);
5236 zfree(&map->init_slots);
5237 map->init_slots_sz = 0;
5242 static int init_prog_array_slots(struct bpf_object *obj, struct bpf_map *map)
5251 for (i = 0; i < map->init_slots_sz; i++) {
5252 if (!map->init_slots[i])
5255 targ_prog = map->init_slots[i];
5258 err = bpf_map_update_elem(map->fd, &i, &fd, 0);
5261 pr_warn("map '%s': failed to initialize slot [%d] to prog '%s' fd=%d: %d\n",
5262 map->name, i, targ_prog->name, fd, err);
5265 pr_debug("map '%s': slot [%d] set to prog '%s' fd=%d\n",
5266 map->name, i, targ_prog->name, fd);
5269 zfree(&map->init_slots);
5270 map->init_slots_sz = 0;
5277 struct bpf_map *map;
5281 map = &obj->maps[i];
5283 if (!map->init_slots_sz || map->def.type != BPF_MAP_TYPE_PROG_ARRAY)
5286 err = init_prog_array_slots(obj, map);
5288 zclose(map->fd);
5295 static int map_set_def_max_entries(struct bpf_map *map)
5297 if (map->def.type == BPF_MAP_TYPE_PERF_EVENT_ARRAY && !map->def.max_entries) {
5302 pr_warn("map '%s': failed to determine number of system CPUs: %d\n",
5303 map->name, nr_cpus);
5306 pr_debug("map '%s': setting size to %d\n", map->name, nr_cpus);
5307 map->def.max_entries = nr_cpus;
5316 struct bpf_map *map;
5323 map = &obj->maps[i];
5328 * programs is referencing any global data map, we'll error
5339 if (bpf_map__is_internal(map) && !kernel_supports(obj, FEAT_GLOBAL_DATA))
5340 map->autocreate = false;
5342 if (!map->autocreate) {
5343 pr_debug("map '%s': skipped auto-creating...\n", map->name);
5347 err = map_set_def_max_entries(map);
5353 if (map->pin_path) {
5354 err = bpf_object__reuse_map(map);
5356 pr_warn("map '%s': error reusing pinned map\n",
5357 map->name);
5360 if (retried && map->fd < 0) {
5361 pr_warn("map '%s': cannot find pinned map\n",
5362 map->name);
5368 if (map->fd >= 0) {
5369 pr_debug("map '%s': skipping creation (preset fd=%d)\n",
5370 map->name, map->fd);
5372 err = bpf_object__create_map(obj, map, false);
5376 pr_debug("map '%s': created successfully, fd=%d\n",
5377 map->name, map->fd);
5379 if (bpf_map__is_internal(map)) {
5380 err = bpf_object__populate_internal_map(obj, map);
5382 zclose(map->fd);
5387 if (map->init_slots_sz && map->def.type != BPF_MAP_TYPE_PROG_ARRAY) {
5388 err = init_map_in_map_slots(obj, map);
5390 zclose(map->fd);
5396 if (map->pin_path && !map->pinned) {
5397 err = bpf_map__pin(map, NULL);
5399 zclose(map->fd);
5404 pr_warn("map '%s': failed to auto-pin at '%s': %d\n",
5405 map->name, map->pin_path, err);
5415 pr_warn("map '%s': failed to create: %s(%d)\n", map->name, cp, err);
5901 /* base map load ldimm64 special constant, used also for log fixup logic */
5907 int map_idx, const struct bpf_map *map)
5911 pr_debug("prog '%s': relo #%d: poisoning insn #%d that loads map #%d '%s'\n",
5912 prog->name, relo_idx, insn_idx, map_idx, map->name);
5923 * where lower 123 is map index into obj->maps[] array
5956 * - map references;
5968 const struct bpf_map *map;
5973 map = &obj->maps[relo->map_idx];
5977 } else if (map->autocreate) {
5979 insn[0].imm = map->fd;
5982 relo->map_idx, map);
5986 map = &obj->maps[relo->map_idx];
5991 } else if (map->autocreate) {
5993 insn[0].imm = map->fd;
5996 relo->map_idx, map);
6606 struct bpf_map *map = NULL, *targ_map = NULL;
6643 map = &obj->maps[j];
6644 if (map->sec_idx != obj->efile.btf_maps_shndx)
6647 vi = btf_var_secinfos(sec) + map->btf_var_idx;
6653 pr_warn(".maps relo #%d: cannot find map '%s' at rel->r_offset %zu\n",
6658 is_map_in_map = bpf_map_type__is_map_in_map(map->def.type);
6659 is_prog_array = map->def.type == BPF_MAP_TYPE_PROG_ARRAY;
6660 type = is_map_in_map ? "map" : "prog";
6663 pr_warn(".maps relo #%d: '%s' isn't a BTF-defined map\n",
6667 if (map->def.type == BPF_MAP_TYPE_HASH_OF_MAPS &&
6668 map->def.key_size != sizeof(int)) {
6670 i, map->name, sizeof(int));
6675 pr_warn(".maps relo #%d: '%s' isn't a valid map reference\n",
6717 if (moff >= map->init_slots_sz) {
6719 tmp = libbpf_reallocarray(map->init_slots, new_sz, host_ptr_sz);
6722 map->init_slots = tmp;
6723 memset(map->init_slots + map->init_slots_sz, 0,
6724 (new_sz - map->init_slots_sz) * host_ptr_sz);
6725 map->init_slots_sz = new_sz;
6727 map->init_slots[moff] = is_map_in_map ? (void *)targ_map : (void *)targ_prog;
6729 pr_debug(".maps relo #%d: map '%s' slot [%d] points to %s '%s'\n",
6730 i, map->name, moff, type, name);
6997 struct bpf_map *map;
7001 map = &prog->obj->maps[i];
7002 if (map->libbpf_type != LIBBPF_MAP_RODATA)
7005 if (bpf_prog_bind_map(ret, bpf_map__fd(map), NULL)) {
7007 pr_warn("prog '%s': failed to bind map '%s': %s\n",
7008 prog->name, map->real_name, cp);
7147 /* Expected log for failed and not properly guarded map reference:
7153 * "345" in "2001000345" is a map index in obj->maps to fetch map name.
7156 const struct bpf_map *map;
7166 map = &obj->maps[map_idx];
7169 "%d: <invalid BPF map reference>\n"
7170 "BPF map '%s' is referenced but wasn't created\n",
7171 insn_idx, map->name);
7242 /* reference to uncreated BPF map */
7888 static void bpf_map_prepare_vdata(const struct bpf_map *map)
7893 st_ops = map->st_ops;
8095 int bpf_map__pin(struct bpf_map *map, const char *path)
8100 if (map == NULL) {
8101 pr_warn("invalid map pointer\n");
8105 if (map->pin_path) {
8106 if (path && strcmp(path, map->pin_path)) {
8107 pr_warn("map '%s' already has pin path '%s' different from '%s'\n",
8108 bpf_map__name(map), map->pin_path, path);
8110 } else if (map->pinned) {
8111 pr_debug("map '%s' already pinned at '%s'; not re-pinning\n",
8112 bpf_map__name(map), map->pin_path);
8117 pr_warn("missing a path to pin map '%s' at\n",
8118 bpf_map__name(map));
8120 } else if (map->pinned) {
8121 pr_warn("map '%s' already pinned\n", bpf_map__name(map));
8125 map->pin_path = strdup(path);
8126 if (!map->pin_path) {
8132 err = make_parent_dir(map->pin_path);
8136 err = check_path(map->pin_path);
8140 if (bpf_obj_pin(map->fd, map->pin_path)) {
8145 map->pinned = true;
8146 pr_debug("pinned map '%s'\n", map->pin_path);
8152 pr_warn("failed to pin map: %s\n", cp);
8156 int bpf_map__unpin(struct bpf_map *map, const char *path)
8160 if (map == NULL) {
8161 pr_warn("invalid map pointer\n");
8165 if (map->pin_path) {
8166 if (path && strcmp(path, map->pin_path)) {
8167 pr_warn("map '%s' already has pin path '%s' different from '%s'\n",
8168 bpf_map__name(map), map->pin_path, path);
8171 path = map->pin_path;
8173 pr_warn("no path to unpin map '%s' from\n",
8174 bpf_map__name(map));
8186 map->pinned = false;
8187 pr_debug("unpinned map '%s' from '%s'\n", bpf_map__name(map), path);
8192 int bpf_map__set_pin_path(struct bpf_map *map, const char *path)
8202 free(map->pin_path);
8203 map->pin_path = new;
8208 const char *bpf_map__get_pin_path(const struct bpf_map *map);
8210 const char *bpf_map__pin_path(const struct bpf_map *map)
8212 return map->pin_path;
8215 bool bpf_map__is_pinned(const struct bpf_map *map)
8217 return map->pinned;
8232 struct bpf_map *map;
8243 bpf_object__for_each_map(map, obj) {
8247 if (!map->autocreate)
8251 err = pathname_concat(buf, sizeof(buf), path, bpf_map__name(map));
8256 } else if (!map->pin_path) {
8260 err = bpf_map__pin(map, pin_path);
8268 while ((map = bpf_object__prev_map(obj, map))) {
8269 if (!map->pin_path)
8272 bpf_map__unpin(map, NULL);
8280 struct bpf_map *map;
8286 bpf_object__for_each_map(map, obj) {
8291 err = pathname_concat(buf, sizeof(buf), path, bpf_map__name(map));
8296 } else if (!map->pin_path) {
8300 err = bpf_map__unpin(map, pin_path);
8400 static void bpf_map__destroy(struct bpf_map *map)
8402 if (map->inner_map) {
8403 bpf_map__destroy(map->inner_map);
8404 zfree(&map->inner_map);
8407 zfree(&map->init_slots);
8408 map->init_slots_sz = 0;
8410 if (map->mmaped) {
8413 mmap_sz = bpf_map_mmap_sz(map->def.value_size, map->def.max_entries);
8414 munmap(map->mmaped, mmap_sz);
8415 map->mmaped = NULL;
8418 if (map->st_ops) {
8419 zfree(&map->st_ops->data);
8420 zfree(&map->st_ops->progs);
8421 zfree(&map->st_ops->kern_func_off);
8422 zfree(&map->st_ops);
8425 zfree(&map->name);
8426 zfree(&map->real_name);
8427 zfree(&map->pin_path);
8429 if (map->fd >= 0)
8430 zclose(map->fd);
9108 struct bpf_map *map;
9112 map = &obj->maps[i];
9113 if (!bpf_map__is_struct_ops(map))
9115 if (map->sec_idx == sec_idx &&
9116 map->sec_offset <= offset &&
9117 offset - map->sec_offset < map->def.value_size)
9118 return map;
9133 struct bpf_map *map;
9158 map = find_struct_ops_map_by_offset(obj, shdr->sh_info, rel->r_offset);
9159 if (!map) {
9160 pr_warn("struct_ops reloc: cannot find map at rel->r_offset %zu\n",
9165 moff = rel->r_offset - map->sec_offset;
9167 st_ops = map->st_ops;
9168 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",
9169 map->name,
9173 map->sec_offset, sym->st_name, name);
9177 map->name, (size_t)rel->r_offset, shdr_idx);
9182 map->name, (unsigned long long)sym->st_value);
9190 map->name, moff);
9198 map->name, name);
9205 map->name, shdr_idx, name);
9212 map->name, prog->name);
9232 map->name, prog->name, prog->sec_name, prog->type,
9462 int bpf_map__fd(const struct bpf_map *map)
9464 return map ? map->fd : libbpf_err(-EINVAL);
9467 static bool map_uses_real_name(const struct bpf_map *map)
9471 * such map's corresponding ELF section name as a map name.
9475 if (map->libbpf_type == LIBBPF_MAP_DATA && strcmp(map->real_name, DATA_SEC) != 0)
9477 if (map->libbpf_type == LIBBPF_MAP_RODATA && strcmp(map->real_name, RODATA_SEC) != 0)
9482 const char *bpf_map__name(const struct bpf_map *map)
9484 if (!map)
9487 if (map_uses_real_name(map))
9488 return map->real_name;
9490 return map->name;
9493 enum bpf_map_type bpf_map__type(const struct bpf_map *map)
9495 return map->def.type;
9498 int bpf_map__set_type(struct bpf_map *map, enum bpf_map_type type)
9500 if (map->fd >= 0)
9502 map->def.type = type;
9506 __u32 bpf_map__map_flags(const struct bpf_map *map)
9508 return map->def.map_flags;
9511 int bpf_map__set_map_flags(struct bpf_map *map, __u32 flags)
9513 if (map->fd >= 0)
9515 map->def.map_flags = flags;
9519 __u64 bpf_map__map_extra(const struct bpf_map *map)
9521 return map->map_extra;
9524 int bpf_map__set_map_extra(struct bpf_map *map, __u64 map_extra)
9526 if (map->fd >= 0)
9528 map->map_extra = map_extra;
9532 __u32 bpf_map__numa_node(const struct bpf_map *map)
9534 return map->numa_node;
9537 int bpf_map__set_numa_node(struct bpf_map *map, __u32 numa_node)
9539 if (map->fd >= 0)
9541 map->numa_node = numa_node;
9545 __u32 bpf_map__key_size(const struct bpf_map *map)
9547 return map->def.key_size;
9550 int bpf_map__set_key_size(struct bpf_map *map, __u32 size)
9552 if (map->fd >= 0)
9554 map->def.key_size = size;
9558 __u32 bpf_map__value_size(const struct bpf_map *map)
9560 return map->def.value_size;
9563 static int map_btf_datasec_resize(struct bpf_map *map, __u32 size)
9574 btf = bpf_object__btf(map->obj);
9578 /* verify map is datasec */
9579 datasec_type = btf_type_by_id(btf, bpf_map__btf_value_type_id(map));
9581 pr_warn("map '%s': cannot be resized, map value type is not a datasec\n",
9582 bpf_map__name(map));
9589 pr_warn("map '%s': cannot be resized, map value datasec is empty\n",
9590 bpf_map__name(map));
9599 pr_warn("map '%s': cannot be resized, last var must be an array\n",
9600 bpf_map__name(map));
9608 pr_warn("map '%s': cannot be resized, element size (%d) doesn't align with new total size (%u)\n",
9609 bpf_map__name(map), element_sz, size);
9622 datasec_type = btf_type_by_id(btf, map->btf_value_type_id);
9634 int bpf_map__set_value_size(struct bpf_map *map, __u32 size)
9636 if (map->fd >= 0)
9639 if (map->mmaped) {
9643 mmap_old_sz = bpf_map_mmap_sz(map->def.value_size, map->def.max_entries);
9644 mmap_new_sz = bpf_map_mmap_sz(size, map->def.max_entries);
9645 err = bpf_map_mmap_resize(map, mmap_old_sz, mmap_new_sz);
9647 pr_warn("map '%s': failed to resize memory-mapped region: %d\n",
9648 bpf_map__name(map), err);
9651 err = map_btf_datasec_resize(map, size);
9653 pr_warn("map '%s': failed to adjust resized BTF, clearing BTF key/value info: %d\n",
9654 bpf_map__name(map), err);
9655 map->btf_value_type_id = 0;
9656 map->btf_key_type_id = 0;
9660 map->def.value_size = size;
9664 __u32 bpf_map__btf_key_type_id(const struct bpf_map *map)
9666 return map ? map->btf_key_type_id : 0;
9669 __u32 bpf_map__btf_value_type_id(const struct bpf_map *map)
9671 return map ? map->btf_value_type_id : 0;
9674 int bpf_map__set_initial_value(struct bpf_map *map,
9677 if (!map->mmaped || map->libbpf_type == LIBBPF_MAP_KCONFIG ||
9678 size != map->def.value_size || map->fd >= 0)
9681 memcpy(map->mmaped, data, size);
9685 void *bpf_map__initial_value(struct bpf_map *map, size_t *psize)
9687 if (!map->mmaped)
9689 *psize = map->def.value_size;
9690 return map->mmaped;
9693 bool bpf_map__is_internal(const struct bpf_map *map)
9695 return map->libbpf_type != LIBBPF_MAP_UNSPEC;
9698 __u32 bpf_map__ifindex(const struct bpf_map *map)
9700 return map->map_ifindex;
9703 int bpf_map__set_ifindex(struct bpf_map *map, __u32 ifindex)
9705 if (map->fd >= 0)
9707 map->map_ifindex = ifindex;
9711 int bpf_map__set_inner_map_fd(struct bpf_map *map, int fd)
9713 if (!bpf_map_type__is_map_in_map(map->def.type)) {
9714 pr_warn("error: unsupported map type\n");
9717 if (map->inner_map_fd != -1) {
9721 if (map->inner_map) {
9722 bpf_map__destroy(map->inner_map);
9723 zfree(&map->inner_map);
9725 map->inner_map_fd = fd;
9742 pr_warn("error in %s: map handler doesn't belong to object\n",
9780 /* if it's a special internal map name (which always starts
9782 * real map name (ELF section name)
9789 /* otherwise map name has to be an exact match */
9807 static int validate_map_op(const struct bpf_map *map, size_t key_sz,
9810 if (map->fd <= 0)
9813 if (map->def.key_size != key_sz) {
9814 pr_warn("map '%s': unexpected key size %zu provided, expected %u\n",
9815 map->name, key_sz, map->def.key_size);
9822 switch (map->def.type) {
9828 size_t elem_sz = roundup(map->def.value_size, 8);
9831 pr_warn("map '%s': unexpected value size %zu provided for per-CPU map, expected %d * %zu = %zd\n",
9832 map->name, value_sz, num_cpu, elem_sz, num_cpu * elem_sz);
9838 if (map->def.value_size != value_sz) {
9839 pr_warn("map '%s': unexpected value size %zu provided, expected %u\n",
9840 map->name, value_sz, map->def.value_size);
9848 int bpf_map__lookup_elem(const struct bpf_map *map,
9854 err = validate_map_op(map, key_sz, value_sz, true);
9858 return bpf_map_lookup_elem_flags(map->fd, key, value, flags);
9861 int bpf_map__update_elem(const struct bpf_map *map,
9867 err = validate_map_op(map, key_sz, value_sz, true);
9871 return bpf_map_update_elem(map->fd, key, value, flags);
9874 int bpf_map__delete_elem(const struct bpf_map *map,
9879 err = validate_map_op(map, key_sz, 0, false /* check_value_sz */);
9883 return bpf_map_delete_elem_flags(map->fd, key, flags);
9886 int bpf_map__lookup_and_delete_elem(const struct bpf_map *map,
9892 err = validate_map_op(map, key_sz, value_sz, true);
9896 return bpf_map_lookup_and_delete_elem_flags(map->fd, key, value, flags);
9899 int bpf_map__get_next_key(const struct bpf_map *map,
9904 err = validate_map_op(map, key_sz, 0, false /* check_value_sz */);
9908 return bpf_map_get_next_key(map->fd, cur_key, next_key);
12164 struct bpf_link *bpf_map__attach_struct_ops(const struct bpf_map *map)
12170 if (!bpf_map__is_struct_ops(map) || map->fd == -1)
12178 err = bpf_map_update_elem(map->fd, &zero, map->st_ops->kern_vdata, 0);
12179 /* It can be EBUSY if the map has been used to create or
12184 if (err && (!(map->def.map_flags & BPF_F_LINK) || err != -EBUSY)) {
12191 if (!(map->def.map_flags & BPF_F_LINK)) {
12193 link->link.fd = map->fd;
12198 fd = bpf_link_create(map->fd, 0, BPF_STRUCT_OPS, NULL);
12205 link->map_fd = map->fd;
12211 * Swap the back struct_ops of a link with a new struct_ops map.
12213 int bpf_link__update_map(struct bpf_link *link, const struct bpf_map *map)
12219 if (!bpf_map__is_struct_ops(map) || map->fd < 0)
12227 err = bpf_map_update_elem(map->fd, &zero, map->st_ops->kern_vdata, 0);
12228 /* It can be EBUSY if the map has been used to create or
12236 err = bpf_link_update(link->fd, map->fd, NULL);
12240 st_ops_link->map_fd = map->fd;
12333 int map_fd; /* BPF_MAP_TYPE_PERF_EVENT_ARRAY BPF map FD */
12490 struct bpf_map_info map;
12504 memset(&map, 0, sizeof(map));
12505 map_info_len = sizeof(map);
12506 err = bpf_map_get_info_by_fd(map_fd, &map, &map_info_len);
12513 pr_warn("failed to get map info for map FD %d: %s\n",
12517 pr_debug("failed to get map info for FD %d; API not supported? Ignoring...\n",
12520 if (map.type != BPF_MAP_TYPE_PERF_EVENT_ARRAY) {
12521 pr_warn("map '%s' should be BPF_MAP_TYPE_PERF_EVENT_ARRAY\n",
12522 map.name);
12556 if (map.max_entries && map.max_entries < pb->cpu_cnt)
12557 pb->cpu_cnt = map.max_entries;
12719 /* Return number of PERF_EVENT_ARRAY map slots set up by this perf_buffer
12729 * PERF_EVENT_ARRAY BPF map. This FD can be polled for new data using
12764 * PERF_EVENT_ARRAY BPF map without waiting/polling. If there is no data to
12959 struct bpf_map **map = maps[i].map;
12963 *map = bpf_object__find_map_by_name(obj, name);
12964 if (!*map) {
12965 pr_warn("failed to find skeleton map '%s'\n", name);
12970 if (mmaped && (*map)->libbpf_type != LIBBPF_MAP_KCONFIG)
12971 *mmaped = (*map)->mmaped;
13007 * prefix as their own map name prefix. When skeleton is generated,
13044 const struct bpf_map *map;
13075 map = *var_skel->map;
13076 map_type_id = bpf_map__btf_value_type_id(map);
13080 pr_warn("type for map '%1$s' is not a datasec: %2$s",
13081 bpf_map__name(map),
13092 *var_skel->addr = map->mmaped + var->offset;
13121 struct bpf_map *map = *s->maps[i].map;
13122 size_t mmap_sz = bpf_map_mmap_sz(map->def.value_size, map->def.max_entries);
13123 int prot, map_fd = bpf_map__fd(map);
13129 if (!(map->def.map_flags & BPF_F_MMAPABLE)) {
13134 if (map->def.map_flags & BPF_F_RDONLY_PROG)
13139 /* Remap anonymous mmap()-ed "map initialization image" as
13140 * a BPF map-backed mmap()-ed memory, but preserving the same
13149 *mmaped = mmap(map->mmaped, mmap_sz, prot, MAP_SHARED | MAP_FIXED, map_fd, 0);
13153 pr_warn("failed to re-mmap() map '%s': %d\n",
13154 bpf_map__name(map), err);