Lines Matching defs:data
465 void *data;
470 * struct tcp_congestion_ops data;
474 * from "data".
480 #define DATA_SEC ".data"
508 * .data*, .bss, .kconfig) and preserves their original ELF section
606 Elf_Data *data;
698 static Elf64_Rel *elf_rel_by_idx(Elf_Data *data, size_t idx);
813 void *data = sec_data->d_buf;
871 sec_off, data + sec_off, prog_sz);
961 * struct tcp_congestion_ops data;
970 pr_warn("struct_ops init_kern: struct %s data is not found in struct %s%s\n",
998 void *data, *kern_data;
1022 data = st_ops->data;
1055 mdata = data + moff;
1095 pr_debug("struct_ops init_kern %s: func ptr %s is set to prog %s from data(+%u) to kern_data(+%u)\n",
1111 pr_debug("struct_ops init_kern %s: copy %s %u bytes from data(+%u) to kern_data(+%u)\n",
1142 int shndx, Elf_Data *data, __u32 map_flags)
1209 st_ops->data = malloc(type->size);
1213 if (!st_ops->data || !st_ops->progs || !st_ops->kern_func_off)
1216 if (vsi->offset + type->size > data->d_size) {
1222 memcpy(st_ops->data,
1223 data->d_buf + vsi->offset,
1277 * bpf_object__elf_finish() after data collection to return
1411 bpf_object__init_license(struct bpf_object *obj, void *data, size_t size)
1413 if (!data) {
1418 * go over allowed ELF data section buffer
1420 libbpf_strlcpy(obj->license, data, min(size + 1, sizeof(obj->license)));
1426 bpf_object__init_kversion(struct bpf_object *obj, void *data, size_t size)
1430 if (!data || size != sizeof(kver)) {
1434 memcpy(&kver, data, sizeof(kver));
1450 Elf_Data *data;
1457 data = elf_sec_data(obj, scn);
1458 if (data) {
1459 *size = data->d_size;
1569 * and .data.* data sections, it's possible that ELF section name is
1574 * We need to keep this convoluted logic intact for .data, .bss and
1575 * .rodata maps, but for new custom .data.custom and .rodata.custom
1637 const char *real_name, int sec_idx, void *data, size_t data_sz)
1673 pr_debug("map '%s' (global data): at sec_idx %d, offset %zu, flags %x.\n",
1689 if (data)
1690 memcpy(map->mmaped, data, data_sz);
1709 if (!sec_desc->data || sec_desc->data->d_size == 0)
1717 sec_desc->data->d_buf,
1718 sec_desc->data->d_size);
1725 sec_desc->data->d_buf,
1726 sec_desc->data->d_size);
1733 sec_desc->data->d_size);
1909 char *buf, void *data)
1942 ext_val = data + ext->kcfg.data_off;
1972 static int bpf_object__read_kconfig_file(struct bpf_object *obj, void *data)
1997 err = bpf_object__process_kconfig_line(obj, buf, data);
2011 const char *config, void *data)
2025 err = bpf_object__process_kconfig_line(obj, buf, data);
2132 * type definition, while using only sizeof(void *) space in ELF data section.
2518 const Elf_Data *data, bool strict,
2538 if ((__u64)vi->offset + vi->size > data->d_size) {
2539 pr_warn("map '%s' BTF data is corrupted.\n", map_name);
2622 Elf_Data *data;
2629 data = elf_sec_data(obj, scn);
2630 if (!scn || !data) {
2658 data, strict,
2991 * whether to make global data BPF array maps as
3302 Elf_Data *data;
3307 data = elf_getdata(scn, 0);
3308 if (!data) {
3309 pr_warn("elf: failed to get section(%zu) %s data from %s: %s\n",
3315 return data;
3326 static Elf64_Rel *elf_rel_by_idx(Elf_Data *data, size_t idx)
3328 if (idx >= data->d_size / sizeof(Elf64_Rel))
3331 return (Elf64_Rel *)data->d_buf + idx;
3394 Elf_Data *data;
3427 data = elf_sec_data(obj, scn);
3428 if (!data)
3433 obj->efile.symbols = data;
3461 data = elf_sec_data(obj, scn);
3462 if (!data)
3466 idx, name, (unsigned long)data->d_size,
3471 err = bpf_object__init_license(obj, data->d_buf, data->d_size);
3475 err = bpf_object__init_kversion(obj, data->d_buf, data->d_size);
3486 btf_data = data;
3490 btf_ext_data = data;
3493 } else if (sh->sh_type == SHT_PROGBITS && data->d_size > 0) {
3497 err = bpf_object__add_programs(obj, data, name, idx);
3504 sec_desc->data = data;
3509 sec_desc->data = data;
3511 obj->efile.st_ops_data = data;
3514 obj->efile.st_ops_link_data = data;
3517 pr_info("elf: skipping unrecognized data section(%d) %s\n",
3540 sec_desc->data = data;
3545 sec_desc->data = data;
4173 /* global data map relocation */
4175 pr_warn("prog '%s': bad data relo against section '%s'\n",
4183 pr_debug("prog '%s': found data map %zd (%s, sec %d, off %zu) for insn %u\n",
4189 pr_warn("prog '%s': data relo failed to find map for section '%s'\n",
4236 bpf_object__collect_prog_relos(struct bpf_object *obj, Elf64_Shdr *shdr, Elf_Data *data)
4268 rel = elf_rel_by_idx(data, i);
4350 * LLVM annotates global data differently in BTF, that is,
4351 * only as '.data', '.bss' or '.rodata'.
4645 static const char strs[] = "\0x\0.data";
4924 "BTF data section and variable", probe_kern_btf_datasec,
5325 /* To support old kernels, we skip creating global data maps
5326 * (.rodata, .data, .kconfig, etc); later on, during program
5328 * programs is referencing any global data map, we'll error
5955 /* Relocate data references within program code:
6558 * Append subprog relos to main programs to allow data relos to be
6578 /* Process data relos for main programs */
6587 pr_warn("prog '%s': failed to relocate data references: %d\n",
6597 Elf64_Shdr *shdr, Elf_Data *data);
6600 Elf64_Shdr *shdr, Elf_Data *data)
6624 rel = elf_rel_by_idx(data, i);
6743 Elf_Data *data;
6750 data = sec_desc->data;
6759 err = bpf_object__collect_st_ops_relos(obj, shdr, data);
6761 err = bpf_object__collect_map_relos(obj, shdr, data);
6763 err = bpf_object__collect_prog_relos(obj, shdr, data);
8419 zfree(&map->st_ops->data);
9126 Elf64_Shdr *shdr, Elf_Data *data)
9144 rel = elf_rel_by_idx(data, i);
9469 /* Since libbpf started to support custom .data.* and .rodata.* maps,
9472 * This check distinguishes .data/.rodata from .data.* and .rodata.*
9675 const void *data, size_t size)
9681 memcpy(map->mmaped, data, size);
10691 struct avail_kallsyms_data *data = ctx;
10692 struct kprobe_multi_resolve *res = data->res;
10695 if (!bsearch(&sym_name, data->syms, data->cnt, sizeof(*data->syms), avail_func_cmp))
10709 struct avail_kallsyms_data data;
10761 data.syms = syms;
10762 data.res = res;
10763 data.cnt = cnt;
10764 libbpf_kallsyms_parse(avail_kallsyms_cb, &data);
11150 elf = elf_memory((void *)entry.data, entry.data_length);
12314 void *buf; /* for reconstructing segmented data */
12611 pb->events[j].data.ptr = cpu_buf;
12637 char data[];
12652 void *data = e;
12660 struct perf_sample_raw *s = data;
12663 pb->sample_cb(pb->ctx, cpu_buf->cpu, s->data, s->size);
12667 struct perf_sample_lost *s = data;
12708 struct perf_cpu_buf *cpu_buf = pb->events[i].data.ptr;
12729 * PERF_EVENT_ARRAY BPF map. This FD can be polled for new data using
12763 * Consume data from perf ring buffer corresponding to slot *buf_idx* in
12764 * PERF_EVENT_ARRAY BPF map without waiting/polling. If there is no data to
13006 * as it breaks global data maps, because they contain object name
13016 obj = bpf_object__open_mem(s->data, s->data_sz, &skel_opts);