Lines Matching defs:prog
202 struct bpf_program *prog);
488 void bpf_program__unload(struct bpf_program *prog)
492 if (!prog)
497 * it is possible that prog->instances.nr == -1.
499 if (prog->instances.nr > 0) {
500 for (i = 0; i < prog->instances.nr; i++)
501 zclose(prog->instances.fds[i]);
502 } else if (prog->instances.nr != -1) {
504 prog->instances.nr);
507 prog->instances.nr = -1;
508 zfree(&prog->instances.fds);
510 zfree(&prog->func_info);
511 zfree(&prog->line_info);
514 static void bpf_program__exit(struct bpf_program *prog)
516 if (!prog)
519 if (prog->clear_priv)
520 prog->clear_priv(prog, prog->priv);
522 prog->priv = NULL;
523 prog->clear_priv = NULL;
525 bpf_program__unload(prog);
526 zfree(&prog->name);
527 zfree(&prog->sec_name);
528 zfree(&prog->pin_name);
529 zfree(&prog->insns);
530 zfree(&prog->reloc_desc);
532 prog->nr_reloc = 0;
533 prog->insns_cnt = 0;
534 prog->sec_idx = -1;
537 static char *__bpf_program__pin_name(struct bpf_program *prog)
541 name = p = strdup(prog->sec_name);
559 bpf_object__init_prog(struct bpf_object *obj, struct bpf_program *prog,
569 memset(prog, 0, sizeof(*prog));
570 prog->obj = obj;
572 prog->sec_idx = sec_idx;
573 prog->sec_insn_off = sec_off / BPF_INSN_SZ;
574 prog->sec_insn_cnt = insn_data_sz / BPF_INSN_SZ;
576 prog->insns_cnt = prog->sec_insn_cnt;
578 prog->type = BPF_PROG_TYPE_UNSPEC;
579 prog->load = true;
581 prog->instances.fds = NULL;
582 prog->instances.nr = -1;
584 prog->sec_name = strdup(sec_name);
585 if (!prog->sec_name)
588 prog->name = strdup(name);
589 if (!prog->name)
592 prog->pin_name = __bpf_program__pin_name(prog);
593 if (!prog->pin_name)
596 prog->insns = malloc(insn_data_sz);
597 if (!prog->insns)
599 memcpy(prog->insns, insn_data, insn_data_sz);
603 pr_warn("sec '%s': failed to allocate memory for prog '%s'\n", sec_name, name);
604 bpf_program__exit(prog);
612 struct bpf_program *prog, *progs;
661 prog = &progs[nr_progs];
663 err = bpf_object__init_prog(obj, prog, name, sec_idx, sec_name,
866 struct bpf_program *prog;
868 prog = st_ops->progs[i];
869 if (!prog)
886 prog->attach_btf_id = kern_type_id;
887 prog->expected_attach_type = kern_member_idx;
891 pr_debug("struct_ops init_kern %s: func ptr %s is set to prog %s from data(+%u) to kern_data(+%u)\n",
892 map->name, mname, prog->name, moff,
2504 static inline bool libbpf_prog_needs_vmlinux_btf(struct bpf_program *prog)
2506 if (prog->type == BPF_PROG_TYPE_STRUCT_OPS ||
2507 prog->type == BPF_PROG_TYPE_LSM)
2513 if (prog->type == BPF_PROG_TYPE_TRACING && !prog->attach_prog_fd)
2522 struct bpf_program *prog;
2540 bpf_object__for_each_program(prog, obj) {
2541 if (!prog->load)
2543 if (libbpf_prog_needs_vmlinux_btf(prog)) {
3273 const struct bpf_program *prog)
3287 return prog->sec_idx == obj->efile.text_shndx && obj->nr_programs > 1;
3294 struct bpf_program *prog;
3296 bpf_object__for_each_program(prog, obj) {
3297 if (prog_is_subprog(obj, prog))
3299 if (!strcmp(prog->name, name))
3300 return prog;
3335 static int bpf_program__record_reloc(struct bpf_program *prog,
3340 struct bpf_insn *insn = &prog->insns[insn_idx];
3341 size_t map_idx, nr_maps = prog->obj->nr_maps;
3342 struct bpf_object *obj = prog->obj;
3353 pr_warn("prog '%s': incorrect bpf_call opcode\n", prog->name);
3359 pr_warn("prog '%s': bad call relo against '%s' in section '%s'\n",
3360 prog->name, sym_name, sym_sec_name);
3364 pr_warn("prog '%s': bad call relo against '%s' at offset %zu\n",
3365 prog->name, sym_name, (size_t)sym->st_value);
3375 pr_warn("prog '%s': invalid relo against '%s' for insns[%d].code 0x%x\n",
3376 prog->name, sym_name, insn_idx, insn->code);
3391 pr_warn("prog '%s': extern relo failed to find extern for '%s' (%d)\n",
3392 prog->name, sym_name, sym_idx);
3395 pr_debug("prog '%s': found extern #%d '%s' (sym %d) for insn #%u\n",
3396 prog->name, i, ext->name, ext->sym_idx, insn_idx);
3404 pr_warn("prog '%s': invalid relo against '%s' in special section 0x%x; forgot to initialize global var?..\n",
3405 prog->name, sym_name, shdr_idx);
3415 pr_warn("prog '%s': bad map relo against '%s' in section '%s'\n",
3416 prog->name, sym_name, sym_sec_name);
3425 pr_debug("prog '%s': found map %zd (%s, sec %d, off %zu) for insn #%u\n",
3426 prog->name, map_idx, map->name, map->sec_idx,
3431 pr_warn("prog '%s': map relo failed to find map for section '%s', off %zu\n",
3432 prog->name, sym_sec_name, (size_t)sym->st_value);
3444 pr_warn("prog '%s': bad data relo against section '%s'\n",
3445 prog->name, sym_sec_name);
3452 pr_debug("prog '%s': found data map %zd (%s, sec %d, off %zu) for insn %u\n",
3453 prog->name, map_idx, map->name, map->sec_idx,
3458 pr_warn("prog '%s': data relo failed to find map for section '%s'\n",
3459 prog->name, sym_sec_name);
3470 static bool prog_contains_insn(const struct bpf_program *prog, size_t insn_idx)
3472 return insn_idx >= prog->sec_insn_off &&
3473 insn_idx < prog->sec_insn_off + prog->sec_insn_cnt;
3480 struct bpf_program *prog;
3487 prog = &obj->programs[m];
3489 if (prog->sec_idx < sec_idx ||
3490 (prog->sec_idx == sec_idx && prog->sec_insn_off <= insn_idx))
3498 prog = &obj->programs[l];
3499 if (prog->sec_idx == sec_idx && prog_contains_insn(prog, insn_idx))
3500 return prog;
3510 struct bpf_program *prog;
3559 prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);
3560 if (!prog) {
3566 relos = libbpf_reallocarray(prog->reloc_desc,
3567 prog->nr_reloc + 1, sizeof(*relos));
3570 prog->reloc_desc = relos;
3573 insn_idx -= prog->sec_insn_off;
3574 err = bpf_program__record_reloc(prog, &relos[prog->nr_reloc],
3579 prog->nr_reloc++;
3973 int ret, map, prog;
3996 prog = bpf_load_program_xattr(&prg_attr, NULL, 0);
3997 if (prog < 0) {
4002 ret = bpf_prog_bind_map(prog, map, NULL);
4005 close(prog);
5105 static int bpf_core_calc_field_relo(const struct bpf_program *prog,
5148 pr_warn("prog '%s': relo %d at insn #%d can't be applied to array access\n",
5149 prog->name, relo->kind, relo->insn_off / 8);
5170 pr_warn("prog '%s': relo %d at insn #%d can't be satisfied for bitfield\n",
5171 prog->name, relo->kind, relo->insn_off / 8);
5321 static int bpf_core_calc_relo(const struct bpf_program *prog,
5339 err = bpf_core_calc_field_relo(prog, relo, local_spec,
5342 err = err ?: bpf_core_calc_field_relo(prog, relo, targ_spec,
5399 pr_warn("prog '%s': relo #%d: unrecognized CO-RE relocation %s (%d) at insn #%d\n",
5400 prog->name, relo_idx, core_relo_kind_str(relo->kind),
5411 static void bpf_core_poison_insn(struct bpf_program *prog, int relo_idx,
5414 pr_debug("prog '%s': relo #%d: substituting insn #%d w/ invalid insn\n",
5415 prog->name, relo_idx, insn_idx);
5471 static int bpf_core_patch_insn(struct bpf_program *prog,
5488 insn_idx = insn_idx - prog->sec_insn_off;
5489 insn = &prog->insns[insn_idx];
5498 bpf_core_poison_insn(prog, relo_idx, insn_idx + 1, insn + 1);
5499 bpf_core_poison_insn(prog, relo_idx, insn_idx, insn);
5512 pr_warn("prog '%s': relo #%d: unexpected insn #%d (ALU/ALU64) value: got %u, exp %u -> %u\n",
5513 prog->name, relo_idx,
5519 pr_debug("prog '%s': relo #%d: patched insn #%d (ALU/ALU64) imm %u -> %u\n",
5520 prog->name, relo_idx, insn_idx,
5527 pr_warn("prog '%s': relo #%d: unexpected insn #%d (LDX/ST/STX) value: got %u, exp %u -> %u\n",
5528 prog->name, relo_idx, insn_idx, insn->off, orig_val, new_val);
5532 pr_warn("prog '%s': relo #%d: insn #%d (LDX/ST/STX) value too big: %u\n",
5533 prog->name, relo_idx, insn_idx, new_val);
5537 pr_warn("prog '%s': relo #%d: insn #%d (LDX/ST/STX) accesses field incorrectly. "
5539 prog->name, relo_idx, insn_idx);
5545 pr_debug("prog '%s': relo #%d: patched insn #%d (LDX/ST/STX) off %u -> %u\n",
5546 prog->name, relo_idx, insn_idx, orig_val, new_val);
5553 pr_warn("prog '%s': relo #%d: insn #%d (LDX/ST/STX) unexpected mem size: got %d, exp %u\n",
5554 prog->name, relo_idx, insn_idx, insn_bytes_sz, res->orig_sz);
5560 pr_warn("prog '%s': relo #%d: insn #%d (LDX/ST/STX) invalid new mem size: %u\n",
5561 prog->name, relo_idx, insn_idx, res->new_sz);
5566 pr_debug("prog '%s': relo #%d: patched insn #%d (LDX/ST/STX) mem_sz %u -> %u\n",
5567 prog->name, relo_idx, insn_idx, res->orig_sz, res->new_sz);
5575 insn_idx + 1 >= prog->insns_cnt ||
5578 pr_warn("prog '%s': relo #%d: insn #%d (LDIMM64) has unexpected form\n",
5579 prog->name, relo_idx, insn_idx);
5585 pr_warn("prog '%s': relo #%d: unexpected insn #%d (LDIMM64) value: got %llu, exp %u -> %u\n",
5586 prog->name, relo_idx,
5594 pr_debug("prog '%s': relo #%d: patched insn #%d (LDIMM64) imm64 %llu -> %u\n",
5595 prog->name, relo_idx, insn_idx,
5600 pr_warn("prog '%s': relo #%d: trying to relocate unrecognized insn #%d, code:0x%x, src:0x%x, dst:0x%x, off:0x%x, imm:0x%x\n",
5601 prog->name, relo_idx, insn_idx, insn->code,
5725 static int bpf_core_apply_relo(struct bpf_program *prog,
5757 pr_warn("prog '%s': relo #%d: parsing [%d] %s %s + %s failed: %d\n",
5758 prog->name, relo_idx, local_id, btf_kind_str(local_type),
5764 pr_debug("prog '%s': relo #%d: kind <%s> (%d), spec is ", prog->name,
5780 pr_warn("prog '%s': relo #%d: <%s> (%d) relocation doesn't support anonymous types\n",
5781 prog->name, relo_idx, core_relo_kind_str(relo->kind), relo->kind);
5788 pr_warn("prog '%s': relo #%d: target candidate search failed for [%d] %s %s: %ld",
5789 prog->name, relo_idx, local_id, btf_kind_str(local_type),
5804 pr_warn("prog '%s': relo #%d: error matching candidate #%d ",
5805 prog->name, relo_idx, i);
5811 pr_debug("prog '%s': relo #%d: %s candidate #%d ", prog->name,
5819 err = bpf_core_calc_relo(prog, relo, relo_idx, &local_spec, &cand_spec, &cand_res);
5830 pr_warn("prog '%s': relo #%d: field offset ambiguity: %u != %u\n",
5831 prog->name, relo_idx, cand_spec.bit_offset,
5839 pr_warn("prog '%s': relo #%d: relocation decision ambiguity: %s %u != %s %u\n",
5840 prog->name, relo_idx,
5872 pr_debug("prog '%s': relo #%d: no matching targets found\n",
5873 prog->name, relo_idx);
5876 err = bpf_core_calc_relo(prog, relo, relo_idx, &local_spec, NULL, &targ_res);
5883 err = bpf_core_patch_insn(prog, relo, relo_idx, &targ_res);
5885 pr_warn("prog '%s': relo #%d: failed to patch insn at offset %d: %d\n",
5886 prog->name, relo_idx, relo->insn_off, err);
5901 struct bpf_program *prog;
5934 * prog->sec_idx to do a proper search by section index and
5937 prog = NULL;
5940 prog = &obj->programs[i];
5944 if (!prog) {
5948 sec_idx = prog->sec_idx;
5955 prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);
5956 if (!prog) {
5972 if (!prog->load)
5975 err = bpf_core_apply_relo(prog, rec, i, obj->btf,
5978 pr_warn("prog '%s': relo #%d: failed to relocate: %d\n",
5979 prog->name, i, err);
6004 bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog)
6008 for (i = 0; i < prog->nr_reloc; i++) {
6009 struct reloc_desc *relo = &prog->reloc_desc[i];
6010 struct bpf_insn *insn = &prog->insns[relo->insn_idx];
6046 pr_warn("prog '%s': relo #%d: bad relo type %d\n",
6047 prog->name, i, relo->type);
6056 const struct bpf_program *prog,
6072 if (strcmp(sec_name, prog->sec_name) != 0)
6078 if (insn_off < prog->sec_insn_off)
6080 if (insn_off >= prog->sec_insn_off + prog->sec_insn_cnt)
6109 off_adj = prog->sub_insn_off - prog->sec_insn_off;
6127 const struct bpf_program *prog)
6140 if (main_prog != prog && !main_prog->func_info)
6143 err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->func_info,
6149 pr_warn("prog '%s': error relocating .BTF.ext function info: %d\n",
6150 prog->name, err);
6158 pr_warn("prog '%s': missing .BTF.ext function info.\n", prog->name);
6162 pr_warn("prog '%s': missing .BTF.ext function info for the main program, skipping all of .BTF.ext func info.\n",
6163 prog->name);
6168 if (main_prog != prog && !main_prog->line_info)
6171 err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->line_info,
6177 pr_warn("prog '%s': error relocating .BTF.ext line info: %d\n",
6178 prog->name, err);
6186 pr_warn("prog '%s': missing .BTF.ext line info.\n", prog->name);
6190 pr_warn("prog '%s': missing .BTF.ext line info for the main program, skipping all of .BTF.ext line info.\n",
6191 prog->name);
6206 static struct reloc_desc *find_prog_insn_relo(const struct bpf_program *prog, size_t insn_idx)
6208 return bsearch(&insn_idx, prog->reloc_desc, prog->nr_reloc,
6209 sizeof(*prog->reloc_desc), cmp_relo_by_insn_idx);
6214 struct bpf_program *prog)
6222 err = reloc_prog_func_and_line_info(obj, main_prog, prog);
6226 for (insn_idx = 0; insn_idx < prog->sec_insn_cnt; insn_idx++) {
6227 insn = &main_prog->insns[prog->sub_insn_off + insn_idx];
6231 relo = find_prog_insn_relo(prog, insn_idx);
6233 pr_warn("prog '%s': unexpected relo for insn #%zu, type %d\n",
6234 prog->name, insn_idx, relo->type);
6253 sub_insn_idx = prog->sec_insn_off + insn_idx + insn->imm + 1;
6259 pr_warn("prog '%s': no .text section found yet sub-program call exists\n",
6260 prog->name);
6280 pr_warn("prog '%s': failed to realloc prog code\n", main_prog->name);
6289 pr_debug("prog '%s': added %zu insns from sub-prog '%s'\n",
6300 insn = &main_prog->insns[prog->sub_insn_off + insn_idx];
6302 * prog; each main prog can have a different set of
6306 insn->imm = subprog->sub_insn_off - (prog->sub_insn_off + insn_idx) - 1;
6311 pr_debug("prog '%s': insn #%zu relocated, imm %d points to subprog '%s' (now at %zu offset)\n",
6312 prog->name, insn_idx, insn->imm, subprog->name, subprog->sub_insn_off);
6322 * main prog) is processed separately. For each subprog (non-entry functions,
6325 * hasn't been yet appended and relocated within current main prog. Once its
6326 * relocated, sub_insn_off will point at the position within current main prog
6336 * the *main* prog's instructions (subprog's instructions are always left
6338 * and subprog instructions are always sent only as part of a main prog) and
6340 * prog or any of its subprogs are appended (and relocated), all their
6346 * main prog and any of its called/used subprogs. Those will keep their
6348 * main prog and won't be relocated within the context of current main prog.
6400 bpf_object__relocate_calls(struct bpf_object *obj, struct bpf_program *prog)
6419 err = bpf_object__reloc_code(obj, prog, prog);
6430 struct bpf_program *prog;
6447 prog = &obj->programs[i];
6448 err = bpf_object__relocate_data(obj, prog);
6450 pr_warn("prog '%s': failed to relocate data references: %d\n",
6451 prog->name, err);
6461 prog = &obj->programs[i];
6465 if (prog_is_subprog(obj, prog))
6468 err = bpf_object__relocate_calls(obj, prog);
6470 pr_warn("prog '%s': failed to relocate calls: %d\n",
6471 prog->name, err);
6477 prog = &obj->programs[i];
6478 zfree(&prog->reloc_desc);
6479 prog->nr_reloc = 0;
6663 static int bpf_object__sanitize_prog(struct bpf_object* obj, struct bpf_program *prog)
6665 struct bpf_insn *insn = prog->insns;
6669 for (i = 0; i < prog->insns_cnt; i++, insn++) {
6696 load_program(struct bpf_program *prog, struct bpf_insn *insns, int insns_cnt,
6709 load_attr.prog_type = prog->type;
6711 if (!kernel_supports(FEAT_EXP_ATTACH_TYPE) && prog->sec_def &&
6712 prog->sec_def->is_exp_attach_type_optional)
6715 load_attr.expected_attach_type = prog->expected_attach_type;
6717 load_attr.name = prog->name;
6721 if (prog->type == BPF_PROG_TYPE_STRUCT_OPS ||
6722 prog->type == BPF_PROG_TYPE_LSM) {
6723 load_attr.attach_btf_id = prog->attach_btf_id;
6724 } else if (prog->type == BPF_PROG_TYPE_TRACING ||
6725 prog->type == BPF_PROG_TYPE_EXT) {
6726 load_attr.attach_prog_fd = prog->attach_prog_fd;
6727 load_attr.attach_btf_id = prog->attach_btf_id;
6730 load_attr.prog_ifindex = prog->prog_ifindex;
6733 btf_fd = bpf_object__btf_fd(prog->obj);
6736 load_attr.func_info = prog->func_info;
6737 load_attr.func_info_rec_size = prog->func_info_rec_size;
6738 load_attr.func_info_cnt = prog->func_info_cnt;
6739 load_attr.line_info = prog->line_info;
6740 load_attr.line_info_rec_size = prog->line_info_rec_size;
6741 load_attr.line_info_cnt = prog->line_info_cnt;
6743 load_attr.log_level = prog->log_level;
6744 load_attr.prog_flags = prog->prog_flags;
6761 if (prog->obj->rodata_map_idx >= 0 &&
6764 &prog->obj->maps[prog->obj->rodata_map_idx];
6768 pr_warn("prog '%s': failed to bind .rodata map: %s\n",
6769 prog->name, cp);
6819 static int libbpf_find_attach_btf_id(struct bpf_program *prog);
6821 int bpf_program__load(struct bpf_program *prog, char *license, __u32 kern_ver)
6825 if (prog->obj->loaded) {
6826 pr_warn("prog '%s': can't load after object was loaded\n", prog->name);
6830 if ((prog->type == BPF_PROG_TYPE_TRACING ||
6831 prog->type == BPF_PROG_TYPE_LSM ||
6832 prog->type == BPF_PROG_TYPE_EXT) && !prog->attach_btf_id) {
6833 btf_id = libbpf_find_attach_btf_id(prog);
6836 prog->attach_btf_id = btf_id;
6839 if (prog->instances.nr < 0 || !prog->instances.fds) {
6840 if (prog->preprocessor) {
6842 prog->name);
6846 prog->instances.fds = malloc(sizeof(int));
6847 if (!prog->instances.fds) {
6851 prog->instances.nr = 1;
6852 prog->instances.fds[0] = -1;
6855 if (!prog->preprocessor) {
6856 if (prog->instances.nr != 1) {
6857 pr_warn("prog '%s': inconsistent nr(%d) != 1\n",
6858 prog->name, prog->instances.nr);
6860 err = load_program(prog, prog->insns, prog->insns_cnt,
6863 prog->instances.fds[0] = fd;
6867 for (i = 0; i < prog->instances.nr; i++) {
6869 bpf_program_prep_t preprocessor = prog->preprocessor;
6872 err = preprocessor(prog, i, prog->insns,
6873 prog->insns_cnt, &result);
6876 i, prog->name);
6882 i, prog->name);
6883 prog->instances.fds[i] = -1;
6889 err = load_program(prog, result.new_insn_ptr,
6893 i, prog->name);
6899 prog->instances.fds[i] = fd;
6903 pr_warn("failed to load program '%s'\n", prog->name);
6904 zfree(&prog->insns);
6905 prog->insns_cnt = 0;
6912 struct bpf_program *prog;
6917 prog = &obj->programs[i];
6918 err = bpf_object__sanitize_prog(obj, prog);
6924 prog = &obj->programs[i];
6925 if (prog_is_subprog(obj, prog))
6927 if (!prog->load) {
6928 pr_debug("prog '%s': skipped loading\n", prog->name);
6931 prog->log_level |= log_level;
6932 err = bpf_program__load(prog, obj->license, obj->kern_version);
6946 struct bpf_program *prog;
6996 bpf_object__for_each_program(prog, obj) {
6997 prog->sec_def = find_sec_def(prog->sec_name);
6998 if (!prog->sec_def)
7002 if (prog->sec_def->is_sleepable)
7003 prog->prog_flags |= BPF_F_SLEEPABLE;
7004 bpf_program__set_type(prog, prog->sec_def->prog_type);
7005 bpf_program__set_expected_attach_type(prog,
7006 prog->sec_def->expected_attach_type);
7008 if (prog->sec_def->prog_type == BPF_PROG_TYPE_TRACING ||
7009 prog->sec_def->prog_type == BPF_PROG_TYPE_EXT)
7010 prog->attach_prog_fd = OPTS_GET(opts, attach_prog_fd, 0);
7427 int bpf_program__pin_instance(struct bpf_program *prog, const char *path,
7441 if (prog == NULL) {
7446 if (instance < 0 || instance >= prog->instances.nr) {
7447 pr_warn("invalid prog instance %d of prog %s (max %d)\n",
7448 instance, prog->name, prog->instances.nr);
7452 if (bpf_obj_pin(prog->instances.fds[instance], path)) {
7463 int bpf_program__unpin_instance(struct bpf_program *prog, const char *path,
7472 if (prog == NULL) {
7477 if (instance < 0 || instance >= prog->instances.nr) {
7478 pr_warn("invalid prog instance %d of prog %s (max %d)\n",
7479 instance, prog->name, prog->instances.nr);
7491 int bpf_program__pin(struct bpf_program *prog, const char *path)
7503 if (prog == NULL) {
7508 if (prog->instances.nr <= 0) {
7509 pr_warn("no instances of prog %s to pin\n", prog->name);
7513 if (prog->instances.nr == 1) {
7515 return bpf_program__pin_instance(prog, path, 0);
7518 for (i = 0; i < prog->instances.nr; i++) {
7531 err = bpf_program__pin_instance(prog, buf, i);
7549 bpf_program__unpin_instance(prog, buf, i);
7557 int bpf_program__unpin(struct bpf_program *prog, const char *path)
7565 if (prog == NULL) {
7570 if (prog->instances.nr <= 0) {
7571 pr_warn("no instances of prog %s to pin\n", prog->name);
7575 if (prog->instances.nr == 1) {
7577 return bpf_program__unpin_instance(prog, path, 0);
7580 for (i = 0; i < prog->instances.nr; i++) {
7590 err = bpf_program__unpin_instance(prog, buf, i);
7824 struct bpf_program *prog;
7835 bpf_object__for_each_program(prog, obj) {
7840 prog->pin_name);
7849 err = bpf_program__pin(prog, buf);
7857 while ((prog = bpf_program__prev(prog, obj))) {
7862 prog->pin_name);
7868 bpf_program__unpin(prog, buf);
7876 struct bpf_program *prog;
7882 bpf_object__for_each_program(prog, obj) {
7887 prog->pin_name);
7893 err = bpf_program__unpin(prog, buf);
8071 struct bpf_program *prog = prev;
8074 prog = __bpf_program__iter(prog, obj, true);
8075 } while (prog && prog_is_subprog(obj, prog));
8077 return prog;
8083 struct bpf_program *prog = next;
8086 prog = __bpf_program__iter(prog, obj, false);
8087 } while (prog && prog_is_subprog(obj, prog));
8089 return prog;
8092 int bpf_program__set_priv(struct bpf_program *prog, void *priv,
8095 if (prog->priv && prog->clear_priv)
8096 prog->clear_priv(prog, prog->priv);
8098 prog->priv = priv;
8099 prog->clear_priv = clear_priv;
8103 void *bpf_program__priv(const struct bpf_program *prog)
8105 return prog ? prog->priv : ERR_PTR(-EINVAL);
8108 void bpf_program__set_ifindex(struct bpf_program *prog, __u32 ifindex)
8110 prog->prog_ifindex = ifindex;
8113 const char *bpf_program__name(const struct bpf_program *prog)
8115 return prog->name;
8118 const char *bpf_program__section_name(const struct bpf_program *prog)
8120 return prog->sec_name;
8123 const char *bpf_program__title(const struct bpf_program *prog, bool needs_copy)
8127 title = prog->sec_name;
8139 bool bpf_program__autoload(const struct bpf_program *prog)
8141 return prog->load;
8144 int bpf_program__set_autoload(struct bpf_program *prog, bool autoload)
8146 if (prog->obj->loaded)
8149 prog->load = autoload;
8153 int bpf_program__fd(const struct bpf_program *prog)
8155 return bpf_program__nth_fd(prog, 0);
8158 size_t bpf_program__size(const struct bpf_program *prog)
8160 return prog->insns_cnt * BPF_INSN_SZ;
8163 int bpf_program__set_prep(struct bpf_program *prog, int nr_instances,
8171 if (prog->instances.nr > 0 || prog->instances.fds) {
8185 prog->instances.nr = nr_instances;
8186 prog->instances.fds = instances_fds;
8187 prog->preprocessor = prep;
8191 int bpf_program__nth_fd(const struct bpf_program *prog, int n)
8195 if (!prog)
8198 if (n >= prog->instances.nr || n < 0) {
8200 n, prog->name, prog->instances.nr);
8204 fd = prog->instances.fds[n];
8207 n, prog->name);
8214 enum bpf_prog_type bpf_program__get_type(struct bpf_program *prog)
8216 return prog->type;
8219 void bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type)
8221 prog->type = type;
8224 static bool bpf_program__is_type(const struct bpf_program *prog,
8227 return prog ? (prog->type == type) : false;
8231 int bpf_program__set_##NAME(struct bpf_program *prog) \
8233 if (!prog) \
8235 bpf_program__set_type(prog, TYPE); \
8239 bool bpf_program__is_##NAME(const struct bpf_program *prog) \
8241 return bpf_program__is_type(prog, TYPE); \
8259 bpf_program__get_expected_attach_type(struct bpf_program *prog)
8261 return prog->expected_attach_type;
8264 void bpf_program__set_expected_attach_type(struct bpf_program *prog,
8267 prog->expected_attach_type = type;
8310 struct bpf_program *prog);
8312 struct bpf_program *prog);
8314 struct bpf_program *prog);
8316 struct bpf_program *prog);
8318 struct bpf_program *prog);
8320 struct bpf_program *prog);
8562 struct bpf_program *prog;
8634 prog = find_prog_by_sec_insn(obj, shdr_idx, insn_idx);
8635 if (!prog) {
8636 pr_warn("struct_ops reloc %s: cannot find prog at shdr_idx %u to relocate func ptr %s\n",
8641 if (prog->type == BPF_PROG_TYPE_UNSPEC) {
8644 sec_def = find_sec_def(prog->sec_name);
8648 prog->type = sec_def->prog_type;
8652 prog->type = BPF_PROG_TYPE_STRUCT_OPS;
8653 prog->attach_btf_id = st_ops->type_id;
8654 prog->expected_attach_type = member_idx;
8655 } else if (prog->type != BPF_PROG_TYPE_STRUCT_OPS ||
8656 prog->attach_btf_id != st_ops->type_id ||
8657 prog->expected_attach_type != member_idx) {
8660 st_ops->progs[member_idx] = prog;
8666 pr_warn("struct_ops reloc %s: cannot use prog %s in sec %s with type %u attach_btf_id %u expected_attach_type %u for func ptr %s\n",
8667 map->name, prog->name, prog->sec_name, prog->type,
8668 prog->attach_btf_id, prog->expected_attach_type, name);
8759 pr_warn("%s is not found in prog's BTF\n", name);
8767 static int libbpf_find_attach_btf_id(struct bpf_program *prog)
8769 enum bpf_attach_type attach_type = prog->expected_attach_type;
8770 __u32 attach_prog_fd = prog->attach_prog_fd;
8771 const char *name = prog->sec_name;
8786 err = __find_vmlinux_btf_id(prog->obj->btf_vmlinux,
9072 struct bpf_program *prog, *first_prog = NULL;
9089 bpf_object__for_each_program(prog, obj) {
9097 bpf_program__set_type(prog, attr->prog_type);
9098 bpf_program__set_expected_attach_type(prog,
9101 if (bpf_program__get_type(prog) == BPF_PROG_TYPE_UNSPEC) {
9110 prog->prog_ifindex = attr->ifindex;
9111 prog->log_level = attr->log_level;
9112 prog->prog_flags |= attr->prog_flags;
9114 first_prog = prog;
9148 int bpf_link__update_program(struct bpf_link *link, struct bpf_program *prog)
9150 return bpf_link_update(bpf_link__fd(link), bpf_program__fd(prog), NULL);
9290 struct bpf_link *bpf_program__attach_perf_event(struct bpf_program *prog,
9298 pr_warn("prog '%s': invalid perf event FD %d\n",
9299 prog->name, pfd);
9302 prog_fd = bpf_program__fd(prog);
9304 pr_warn("prog '%s': can't attach BPF program w/o FD (did you load it?)\n",
9305 prog->name);
9318 pr_warn("prog '%s': failed to attach to pfd %d: %s\n",
9319 prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg)));
9321 pr_warn("prog '%s': try add PERF_SAMPLE_CALLCHAIN to or remove exclude_callchain_[kernel|user] from pfd %d\n",
9322 prog->name, pfd);
9328 pr_warn("prog '%s': failed to enable pfd %d: %s\n",
9329 prog->name, pfd, libbpf_strerror_r(err, errmsg, sizeof(errmsg)));
9440 struct bpf_link *bpf_program__attach_kprobe(struct bpf_program *prog,
9451 pr_warn("prog '%s': failed to create %s '%s' perf event: %s\n",
9452 prog->name, retprobe ? "kretprobe" : "kprobe", func_name,
9456 link = bpf_program__attach_perf_event(prog, pfd);
9460 pr_warn("prog '%s': failed to attach to %s '%s': %s\n",
9461 prog->name, retprobe ? "kretprobe" : "kprobe", func_name,
9469 struct bpf_program *prog)
9474 func_name = prog->sec_name + sec->len;
9477 return bpf_program__attach_kprobe(prog, retprobe, func_name);
9480 struct bpf_link *bpf_program__attach_uprobe(struct bpf_program *prog,
9492 pr_warn("prog '%s': failed to create %s '%s:0x%zx' perf event: %s\n",
9493 prog->name, retprobe ? "uretprobe" : "uprobe",
9498 link = bpf_program__attach_perf_event(prog, pfd);
9502 pr_warn("prog '%s': failed to attach to %s '%s:0x%zx': %s\n",
9503 prog->name, retprobe ? "uretprobe" : "uprobe",
9561 struct bpf_link *bpf_program__attach_tracepoint(struct bpf_program *prog,
9571 pr_warn("prog '%s': failed to create tracepoint '%s/%s' perf event: %s\n",
9572 prog->name, tp_category, tp_name,
9576 link = bpf_program__attach_perf_event(prog, pfd);
9580 pr_warn("prog '%s': failed to attach to tracepoint '%s/%s': %s\n",
9581 prog->name, tp_category, tp_name,
9589 struct bpf_program *prog)
9594 sec_name = strdup(prog->sec_name);
9608 link = bpf_program__attach_tracepoint(prog, tp_cat, tp_name);
9614 struct bpf_link *bpf_program__attach_raw_tracepoint(struct bpf_program *prog,
9621 prog_fd = bpf_program__fd(prog);
9623 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9636 pr_warn("prog '%s': failed to attach to raw tracepoint '%s': %s\n",
9637 prog->name, tp_name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg)));
9645 struct bpf_program *prog)
9647 const char *tp_name = prog->sec_name + sec->len;
9649 return bpf_program__attach_raw_tracepoint(prog, tp_name);
9653 static struct bpf_link *bpf_program__attach_btf_id(struct bpf_program *prog)
9659 prog_fd = bpf_program__fd(prog);
9661 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9674 pr_warn("prog '%s': failed to attach: %s\n",
9675 prog->name, libbpf_strerror_r(pfd, errmsg, sizeof(errmsg)));
9682 struct bpf_link *bpf_program__attach_trace(struct bpf_program *prog)
9684 return bpf_program__attach_btf_id(prog);
9687 struct bpf_link *bpf_program__attach_lsm(struct bpf_program *prog)
9689 return bpf_program__attach_btf_id(prog);
9693 struct bpf_program *prog)
9695 return bpf_program__attach_trace(prog);
9699 struct bpf_program *prog)
9701 return bpf_program__attach_lsm(prog);
9705 struct bpf_program *prog)
9707 return bpf_program__attach_iter(prog, NULL);
9711 bpf_program__attach_fd(struct bpf_program *prog, int target_fd, int btf_id,
9721 prog_fd = bpf_program__fd(prog);
9723 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9732 attach_type = bpf_program__get_expected_attach_type(prog);
9737 pr_warn("prog '%s': failed to attach to %s: %s\n",
9738 prog->name, target_name,
9747 bpf_program__attach_cgroup(struct bpf_program *prog, int cgroup_fd)
9749 return bpf_program__attach_fd(prog, cgroup_fd, 0, "cgroup");
9753 bpf_program__attach_netns(struct bpf_program *prog, int netns_fd)
9755 return bpf_program__attach_fd(prog, netns_fd, 0, "netns");
9758 struct bpf_link *bpf_program__attach_xdp(struct bpf_program *prog, int ifindex)
9761 return bpf_program__attach_fd(prog, ifindex, 0, "xdp");
9764 struct bpf_link *bpf_program__attach_freplace(struct bpf_program *prog,
9771 pr_warn("prog '%s': supply none or both of target_fd and attach_func_name\n",
9772 prog->name);
9776 if (prog->type != BPF_PROG_TYPE_EXT) {
9777 pr_warn("prog '%s': only BPF_PROG_TYPE_EXT can attach as freplace",
9778 prog->name);
9787 return bpf_program__attach_fd(prog, target_fd, btf_id, "freplace");
9792 return bpf_program__attach_trace(prog);
9797 bpf_program__attach_iter(struct bpf_program *prog,
9812 prog_fd = bpf_program__fd(prog);
9814 pr_warn("prog '%s': can't attach before loaded\n", prog->name);
9828 pr_warn("prog '%s': failed to attach to iterator: %s\n",
9829 prog->name, libbpf_strerror_r(link_fd, errmsg, sizeof(errmsg)));
9836 struct bpf_link *bpf_program__attach(struct bpf_program *prog)
9840 sec_def = find_sec_def(prog->sec_name);
9844 return sec_def->attach_fn(sec_def, prog);
9873 struct bpf_program *prog = st_ops->progs[i];
9877 if (!prog)
9880 prog_fd = bpf_program__fd(prog);
10524 pr_debug("can't get prog info: %s", strerror(errno));
10587 pr_debug("can't get prog info: %s", strerror(errno));
10661 int bpf_program__set_attach_target(struct bpf_program *prog,
10667 if (!prog || attach_prog_fd < 0 || !attach_func_name)
10675 prog->expected_attach_type);
10680 prog->attach_btf_id = btf_id;
10681 prog->attach_prog_fd = attach_prog_fd;
10835 struct bpf_program **prog = s->progs[i].prog;
10838 *prog = bpf_object__find_program_by_name(obj, name);
10839 if (!*prog) {
10906 struct bpf_program *prog = *s->progs[i].prog;
10910 if (!prog->load)
10913 sec_def = find_sec_def(prog->sec_name);
10917 *link = sec_def->attach_fn(sec_def, prog);
10920 bpf_program__name(prog), PTR_ERR(*link));