Lines Matching defs:data
478 void *data;
483 * struct tcp_congestion_ops data;
487 * from "data".
493 #define DATA_SEC ".data"
521 * .data*, .bss, .kconfig) and preserves their original ELF section
624 Elf_Data *data;
736 static Elf_Data *elf_sec_data_by_name(const struct bpf_object *obj, const char *name, Elf_Data *data);
737 static Elf_Data *elf_sec_data_by_idx(const struct bpf_object *obj, size_t idx, Elf_Data *data);
740 static Elf64_Rel *elf_rel_by_idx(Elf_Data *data, size_t idx);
856 void *data = sec_data->d_buf;
914 sec_off, data + sec_off, prog_sz);
1006 * struct tcp_congestion_ops data;
1015 pr_warn("struct_ops init_kern: struct %s data is not found in struct %s%s\n",
1043 void *data, *kern_data;
1067 data = st_ops->data;
1100 mdata = data + moff;
1140 pr_debug("struct_ops init_kern %s: func ptr %s is set to prog %s from data(+%u) to kern_data(+%u)\n",
1156 pr_debug("struct_ops init_kern %s: copy %s %u bytes from data(+%u) to kern_data(+%u)\n",
1187 int shndx, Elf_Data *data, __u32 map_flags)
1254 st_ops->data = malloc(type->size);
1258 if (!st_ops->data || !st_ops->progs || !st_ops->kern_func_off)
1261 if (vsi->offset + type->size > data->d_size) {
1267 memcpy(st_ops->data,
1268 data->d_buf + vsi->offset,
1322 * bpf_object__elf_finish() after data collection to return
1489 bpf_object__init_license(struct bpf_object *obj, void *data, size_t size)
1491 if (!data) {
1496 * go over allowed ELF data section buffer
1498 libbpf_strlcpy(obj->license, data, min(size + 1, sizeof(obj->license)));
1504 bpf_object__init_kversion(struct bpf_object *obj, void *data, size_t size)
1508 if (!data || size != sizeof(kver)) {
1512 memcpy(&kver, data, sizeof(kver));
1528 Elf_Data *data;
1537 data = elf_sec_data(obj, scn);
1540 data = &realdata;
1541 data = elf_sec_data_by_name(obj, name, data);
1543 if (data) {
1544 *size = data->d_size;
1654 * and .data.* data sections, it's possible that ELF section name is
1659 * We need to keep this convoluted logic intact for .data, .bss and
1660 * .rodata maps, but for new custom .data.custom and .rodata.custom
1722 const char *real_name, int sec_idx, void *data, size_t data_sz)
1758 pr_debug("map '%s' (global data): at sec_idx %d, offset %zu, flags %x.\n",
1774 if (data)
1775 memcpy(map->mmaped, data, data_sz);
1794 if (!sec_desc->data || sec_desc->data->d_size == 0)
1806 sec_desc->data->d_buf,
1807 sec_desc->data->d_size);
1818 sec_desc->data->d_buf,
1819 sec_desc->data->d_size);
1830 sec_desc->data->d_size);
2006 char *buf, void *data)
2039 ext_val = data + ext->kcfg.data_off;
2069 static int bpf_object__read_kconfig_file(struct bpf_object *obj, void *data)
2094 err = bpf_object__process_kconfig_line(obj, buf, data);
2108 const char *config, void *data)
2122 err = bpf_object__process_kconfig_line(obj, buf, data);
2229 * type definition, while using only sizeof(void *) space in ELF data section.
2615 const Elf_Data *data, bool strict,
2635 if ((__u64)vi->offset + vi->size > data->d_size) {
2636 pr_warn("map '%s' BTF data is corrupted.\n", map_name);
2719 Elf_Data *data;
2728 data = elf_sec_data(obj, scn);
2729 if (!scn || !data) {
2732 data = elf_sec_data_by_idx(obj, obj->efile.btf_maps_shndx, &realdata);
2733 if (!data) {
2762 data, strict,
3113 * whether to make global data BPF array maps as
3549 Elf_Data *data;
3554 data = elf_getdata(scn, 0);
3555 if (!data) {
3556 pr_warn("elf: failed to get section(%zu) %s data from %s: %s\n",
3562 return data;
3565 static Elf_Data *elf_sec_data_by_name(const struct bpf_object *obj, const char *name, Elf_Data *data)
3569 data->d_buf = (void*)elfio_section_get_data(psection_name);
3570 data->d_size = elfio_section_get_size(psection_name);
3572 return data;
3575 static Elf_Data *elf_sec_data_by_idx(const struct bpf_object *obj, size_t idx, Elf_Data *data)
3579 data->d_buf = (void*)elfio_section_get_data(psection_index);
3580 data->d_size = elfio_section_get_size(psection_index);
3582 return data;
3594 static Elf64_Rel *elf_rel_by_idx(Elf_Data *data, size_t idx)
3596 if (idx >= data->d_size / sizeof(Elf64_Rel))
3599 return (Elf64_Rel *)data->d_buf + idx;
3666 Elf_Data *data;
3716 data = elf_sec_data(obj, scn);
3718 data = elf_sec_data_by_idx(obj, i, &realdata);
3720 if (!data)
3727 obj->efile.symbols = data;
3729 obj->efile.realsymbols.d_buf = data->d_buf;
3730 obj->efile.realsymbols.d_size = data->d_size;
3802 data = elf_sec_data(obj, scn);
3804 data = elf_sec_data_by_idx(obj, i, &sec_desc->realdata);
3806 if (!data)
3810 idx, name, (unsigned long)data->d_size,
3815 err = bpf_object__init_license(obj, data->d_buf, data->d_size);
3819 err = bpf_object__init_kversion(obj, data->d_buf, data->d_size);
3830 btf_data = data;
3834 btf_ext_data = data;
3837 } else if (sh->sh_type == SHT_PROGBITS && data->d_size > 0) {
3841 err = bpf_object__add_programs(obj, data, name, idx);
3849 sec_desc->data = data;
3852 sec_desc->realdata.d_buf = data->d_buf;
3853 sec_desc->realdata.d_size = data->d_size;
3854 sec_desc->data = &(sec_desc->realdata);
3861 sec_desc->data = data;
3864 sec_desc->realdata.d_buf = data->d_buf;
3865 sec_desc->realdata.d_size = data->d_size;
3866 sec_desc->data = &(sec_desc->realdata);
3871 obj->efile.st_ops_data = data;
3873 obj->efile.realst_ops_data.d_buf = data->d_buf;
3874 obj->efile.realst_ops_data.d_size = data->d_size;
3879 pr_info("elf: skipping unrecognized data section(%d) %s\n",
3911 sec_desc->data = data;
3920 sec_desc->data = data;
4564 /* global data map relocation */
4566 pr_warn("prog '%s': bad data relo against section '%s'\n",
4574 pr_debug("prog '%s': found data map %zd (%s, sec %d, off %zu) for insn %u\n",
4580 pr_warn("prog '%s': data relo failed to find map for section '%s'\n",
4627 bpf_object__collect_prog_relos(struct bpf_object *obj, Elf64_Shdr *shdr, Elf_Data *data)
4669 rel = elf_rel_by_idx(data, i);
4755 * LLVM annotates global data differently in BTF, that is,
4756 * only as '.data', '.bss' or '.rodata'.
5050 static const char strs[] = "\0x\0.data";
5329 "BTF data section and variable", probe_kern_btf_datasec,
5728 /* To support old kernels, we skip creating global data maps
5729 * (.rodata, .data, .kconfig, etc); later on, during program
5731 * programs is referencing any global data map, we'll error
6360 /* Relocate data references within program code:
6977 * Append subprog relos to main programs to allow data relos to be
7016 /* Process data relos for main programs */
7025 pr_warn("prog '%s': failed to relocate data references: %d\n",
7035 Elf64_Shdr *shdr, Elf_Data *data);
7038 Elf64_Shdr *shdr, Elf_Data *data)
7062 rel = elf_rel_by_idx(data, i);
7181 Elf_Data *data;
7193 data = sec_desc->data;
7202 err = bpf_object__collect_st_ops_relos(obj, shdr, data);
7204 err = bpf_object__collect_map_relos(obj, shdr, data);
7206 err = bpf_object__collect_prog_relos(obj, shdr, data);
8864 zfree(&map->st_ops->data);
9582 Elf64_Shdr *shdr, Elf_Data *data)
9600 rel = elf_rel_by_idx(data, i);
9925 /* Since libbpf started to support custom .data.* and .rodata.* maps,
9928 * This check distinguishes .data/.rodata from .data.* and .rodata.*
10131 const void *data, size_t size)
10137 memcpy(map->mmaped, data, size);
11147 struct avail_kallsyms_data *data = ctx;
11148 struct kprobe_multi_resolve *res = data->res;
11151 if (!bsearch(&sym_name, data->syms, data->cnt, sizeof(*data->syms), avail_func_cmp))
11165 struct avail_kallsyms_data data;
11217 data.syms = syms;
11218 data.res = res;
11219 data.cnt = cnt;
11220 libbpf_kallsyms_parse(avail_kallsyms_cb, &data);
11604 elf = elf_memory((void *)entry.data, entry.data_length);
11610 write(fdm, (char *)entry.data, entry.data_length);
12828 void *buf; /* for reconstructing segmented data */
13125 pb->events[j].data.ptr = cpu_buf;
13151 char data[];
13166 void *data = e;
13174 struct perf_sample_raw *s = data;
13177 pb->sample_cb(pb->ctx, cpu_buf->cpu, s->data, s->size);
13181 struct perf_sample_lost *s = data;
13222 struct perf_cpu_buf *cpu_buf = pb->events[i].data.ptr;
13243 * PERF_EVENT_ARRAY BPF map. This FD can be polled for new data using
13277 * Consume data from perf ring buffer corresponding to slot *buf_idx* in
13278 * PERF_EVENT_ARRAY BPF map without waiting/polling. If there is no data to
13520 * as it breaks global data maps, because they contain object name
13530 obj = bpf_object__open_mem(s->data, s->data_sz, &skel_opts);