drivers/net/ethernet/netronome/nfp/bpf/jit.c

3313

if (nfp_prog->subprog[meta->jmp_dst->subprog_idx].needs_reg_push) {

drivers/net/ethernet/netronome/nfp/bpf/jit.c

3389

if (nfp_prog->subprog[meta->subprog_idx].needs_reg_push) {

drivers/net/ethernet/netronome/nfp/bpf/jit.c

3609

nfp_prog->subprog[jmp_dst->subprog_idx].needs_reg_push) {

drivers/net/ethernet/netronome/nfp/bpf/jit.c

3647

unsigned int depth = nfp_prog->subprog[meta->subprog_idx].stack_depth;

drivers/net/ethernet/netronome/nfp/bpf/jit.c

3753

if (nfp_prog->subprog[idx].needs_reg_push)

drivers/net/ethernet/netronome/nfp/bpf/jit.c

3835

depth = nfp_prog->subprog[0].stack_depth;

drivers/net/ethernet/netronome/nfp/bpf/main.h

541

struct nfp_bpf_subprog_info *subprog;

drivers/net/ethernet/netronome/nfp/bpf/offload.c

180

kfree(nfp_prog->subprog);

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

686

nfp_prog->subprog[index].needs_reg_push = 1;

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

714

frame_depths[frame] = nfp_prog->subprog[idx].stack_depth;

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

773

nfp_prog->subprog = kzalloc_objs(nfp_prog->subprog[0],

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

775

if (!nfp_prog->subprog)

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

782

nfp_prog->subprog[i].stack_depth = info[i].stack_depth;

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

788

nfp_prog->subprog[i].stack_depth += REG_WIDTH;

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

790

if (nfp_prog->subprog[i].needs_reg_push)

drivers/net/ethernet/netronome/nfp/bpf/verifier.c

791

nfp_prog->subprog[i].stack_depth += BPF_REG_SIZE * 4;

include/linux/bpf.h

3158

int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog);

include/linux/bpf_verifier.h

1021

static inline struct bpf_func_info_aux *subprog_aux(struct bpf_verifier_env *env, int subprog)

include/linux/bpf_verifier.h

1023

return &env->prog->aux->func_info_aux[subprog];

include/linux/bpf_verifier.h

1026

static inline struct bpf_subprog_info *subprog_info(struct bpf_verifier_env *env, int subprog)

include/linux/bpf_verifier.h

1028

return &env->subprog_info[subprog];

include/linux/bpf_verifier.h

1407

bool bpf_subprog_is_global(const struct bpf_verifier_env *env, int subprog);

include/linux/bpf_verifier.h

1588

void bpf_mark_subprog_exc_cb(struct bpf_verifier_env *env, int subprog);

kernel/bpf/backtrack.c

411

int subprog_insn_idx, subprog;

kernel/bpf/backtrack.c

414

subprog = bpf_find_subprog(env, subprog_insn_idx);

kernel/bpf/backtrack.c

415

if (subprog < 0)

kernel/bpf/backtrack.c

418

if (bpf_subprog_is_global(env, subprog)) {

kernel/bpf/btf.c

7943

const struct btf_type *t, int subprog)

kernel/bpf/btf.c

7959

if (subprog && (tags & ARG_TAG_ARENA) && btf_type_is_ptr(t))

kernel/bpf/btf.c

7977

int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)

kernel/bpf/btf.c

7979

bool is_global = subprog_aux(env, subprog)->linkage == BTF_FUNC_GLOBAL;

kernel/bpf/btf.c

7980

struct bpf_subprog_info *sub = subprog_info(env, subprog);

kernel/bpf/btf.c

7999

btf_id = prog->aux->func_info[subprog].type_id;

kernel/bpf/btf.c

8013

subprog);

kernel/bpf/btf.c

8018

if (prog->aux->func_info_aux[subprog].unreliable) {

kernel/bpf/btf.c

8053

err = btf_validate_return_type(env, btf, t, subprog);

kernel/bpf/cfg.c

329

struct bpf_subprog_info *subprog;

kernel/bpf/cfg.c

334

subprog = bpf_find_containing_subprog(env, t);

kernel/bpf/cfg.c

335

subprog_start = subprog->start;

kernel/bpf/cfg.c

336

subprog_end = (subprog + 1)->start;

kernel/bpf/cfg.c

404

struct bpf_subprog_info *subprog;

kernel/bpf/cfg.c

414

subprog = bpf_find_containing_subprog(env, t);

kernel/bpf/cfg.c

416

jt->items[1] = subprog->exit_idx;

kernel/bpf/cfg.c

53

struct bpf_subprog_info *subprog;

kernel/bpf/cfg.c

55

subprog = bpf_find_containing_subprog(env, off);

kernel/bpf/cfg.c

56

subprog->changes_pkt_data = true;

kernel/bpf/cfg.c

61

struct bpf_subprog_info *subprog;

kernel/bpf/cfg.c

63

subprog = bpf_find_containing_subprog(env, off);

kernel/bpf/cfg.c

64

subprog->might_sleep = true;

kernel/bpf/cfg.c

69

struct bpf_subprog_info *subprog;

kernel/bpf/cfg.c

71

subprog = bpf_find_containing_subprog(env, off);

kernel/bpf/cfg.c

72

subprog->might_throw = true;

kernel/bpf/const_fold.c

149

int subprog = bpf_find_subprog(env, idx + insn->imm + 1);

kernel/bpf/const_fold.c

151

if (subprog >= 0) {

kernel/bpf/const_fold.c

153

dst->val = subprog;

kernel/bpf/fixups.c

1031

int i, j, subprog_start, subprog_end = 0, len, subprog;

kernel/bpf/fixups.c

1045

subprog = bpf_find_subprog(env, i + insn->imm + 1);

kernel/bpf/fixups.c

1046

if (verifier_bug_if(subprog < 0, env, "No program to jit at insn %d",

kernel/bpf/fixups.c

1052

insn->off = subprog;

kernel/bpf/fixups.c

1181

subprog = insn->off;

kernel/bpf/fixups.c

1182

insn[0].imm = (u32)(long)func[subprog]->bpf_func;

kernel/bpf/fixups.c

1183

insn[1].imm = ((u64)(long)func[subprog]->bpf_func) >> 32;

kernel/bpf/fixups.c

1188

subprog = insn->off;

kernel/bpf/fixups.c

1189

insn->imm = BPF_CALL_IMM(func[subprog]->bpf_func);

kernel/bpf/fixups.c

1254

subprog = bpf_find_subprog(env, i + insn->imm + 1);

kernel/bpf/fixups.c

1255

insn->off = subprog;

kernel/bpf/fixups.c

1387

struct bpf_subprog_info *subprog = &env->subprog_info[i];

kernel/bpf/fixups.c

1388

u16 outgoing = subprog->stack_arg_cnt - bpf_in_stack_arg_cnt(subprog);

kernel/bpf/fixups.c

1390

if (subprog->max_out_stack_arg_cnt > outgoing) {

kernel/bpf/fixups.c

1393

i, subprog->max_out_stack_arg_cnt, outgoing);

kernel/bpf/fixups.c

146

int start = idx + insn->imm + 1, subprog;

kernel/bpf/fixups.c

148

subprog = bpf_find_subprog(env, start);

kernel/bpf/fixups.c

149

if (verifier_bug_if(subprog < 0, env, "get stack depth: no program at insn %d", start))

kernel/bpf/fixups.c

151

return env->subprog_info[subprog].stack_depth;

kernel/bpf/fixups.c

2568

struct bpf_subprog_info *subprog = env->subprog_info;

kernel/bpf/fixups.c

2586

if ((subprog + 1)->start == i + 1) {

kernel/bpf/fixups.c

2587

if (modified && !subprog->keep_fastcall_stack)

kernel/bpf/fixups.c

2588

subprog->stack_depth = -subprog->fastcall_stack_off;

kernel/bpf/fixups.c

2589

subprog++;

kernel/bpf/liveness.c

1526

int subprog,

kernel/bpf/liveness.c

1531

int start = env->subprog_info[subprog].start;

kernel/bpf/liveness.c

1538

verbose(env, "%s:\n", fmt_subprog(env, subprog));

kernel/bpf/liveness.c

1620

int subprog = instance->subprog;

kernel/bpf/liveness.c

1623

int start = env->subprog_info[subprog].start;

kernel/bpf/liveness.c

1624

int po_start = env->subprog_info[subprog].postorder_start;

kernel/bpf/liveness.c

1625

int end = env->subprog_info[subprog + 1].start;

kernel/bpf/liveness.c

1626

int po_end = env->subprog_info[subprog + 1].postorder_start;

kernel/bpf/liveness.c

1678

verbose(env, "subprog#%d: analyzing (depth %d)...\n", subprog, depth);

kernel/bpf/liveness.c

1755

print_subprog_arg_access(env, subprog, info, at_stack_in);

kernel/bpf/liveness.c

1823

f->subprog = src->subprog;

kernel/bpf/liveness.c

1853

int subprog = instance->subprog;

kernel/bpf/liveness.c

1856

int start = env->subprog_info[subprog].start;

kernel/bpf/liveness.c

1857

int po_start = env->subprog_info[subprog].postorder_start;

kernel/bpf/liveness.c

1858

int po_end = env->subprog_info[subprog + 1].postorder_start;

kernel/bpf/liveness.c

1887

kvfree(info[subprog].at_in);

kernel/bpf/liveness.c

1888

info[subprog].at_in = NULL;

kernel/bpf/liveness.c

1890

err = compute_subprog_args(env, &info[subprog], entry_args, instance, callsites);

kernel/bpf/liveness.c

1914

callee_args[r] = info[subprog].at_in[j][r];

kernel/bpf/liveness.c

1916

callee_args[MAX_BPF_REG + r] = info[subprog].at_in[j][MAX_BPF_REG + r];

kernel/bpf/liveness.c

1924

if (info[subprog].at_in[j][caller_reg].frame == ARG_NONE)

kernel/bpf/liveness.c

1940

callee_args[cb_callee_reg] = info[subprog].at_in[j][caller_reg];

kernel/bpf/liveness.c

28

u32 subprog; /* subprog index */

kernel/bpf/liveness.c

311

struct bpf_subprog_info *subprog;

kernel/bpf/liveness.c

315

subprog = &env->subprog_info[instance->subprog];

kernel/bpf/liveness.c

316

po_start = subprog->postorder_start;

kernel/bpf/liveness.c

317

po_end = (subprog + 1)->postorder_start;

kernel/bpf/liveness.c

408

static char *fmt_subprog(struct bpf_verifier_env *env, int subprog)

kernel/bpf/liveness.c

410

const char *name = env->subprog_info[subprog].name;

kernel/bpf/liveness.c

413

"subprog#%d%s%s", subprog, name ? " " : "", name ? name : "");

kernel/bpf/liveness.c

480

int start = env->subprog_info[instance->subprog].start;

kernel/bpf/liveness.c

491

verbose(env, "stack use/def %s ", fmt_subprog(env, instance->subprog));

kernel/bpf/liveness.c

76

u32 callsite, int subprog)

kernel/bpf/liveness.c

79

u32 subprog_start = env->subprog_info[subprog].start;

kernel/bpf/liveness.c

93

f->subprog = subprog;

kernel/bpf/liveness.c

95

f->insn_cnt = (env->subprog_info + subprog + 1)->start - subprog_start;

kernel/bpf/verifier.c

16789

struct bpf_subprog_info *subprog,

kernel/bpf/verifier.c

16871

subprog->keep_fastcall_stack = 1;

kernel/bpf/verifier.c

16872

subprog->fastcall_stack_off = min(subprog->fastcall_stack_off, off);

kernel/bpf/verifier.c

16877

struct bpf_subprog_info *subprog = env->subprog_info;

kernel/bpf/verifier.c

16882

for (s = 0; s < env->subprog_cnt; ++s, ++subprog) {

kernel/bpf/verifier.c

16885

for (i = subprog->start; i < (subprog + 1)->start; ++i) {

kernel/bpf/verifier.c

16893

for (i = subprog->start; i < (subprog + 1)->start; ++i) {

kernel/bpf/verifier.c

16897

mark_fastcall_pattern_for_call(env, subprog, i, lowest_off);

kernel/bpf/verifier.c

18355

static int do_check_common(struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

18358

struct bpf_subprog_info *sub = subprog_info(env, subprog);

kernel/bpf/verifier.c

18383

subprog);

kernel/bpf/verifier.c

18384

state->first_insn_idx = env->subprog_info[subprog].start;

kernel/bpf/verifier.c

18388

if (subprog || env->prog->type == BPF_PROG_TYPE_EXT) {

kernel/bpf/verifier.c

18389

const char *sub_name = subprog_name(env, subprog);

kernel/bpf/verifier.c

18394

verbose(env, "Validating %s() func#%d...\n", sub_name, subprog);

kernel/bpf/verifier.c

18395

ret = btf_prepare_func_args(env, subprog);

kernel/bpf/verifier.c

18399

if (subprog_is_exc_cb(env, subprog)) {

kernel/bpf/verifier.c

18406

if (subprog_returns_void(env, subprog)) {

kernel/bpf/verifier.c

18488

if (!subprog && env->prog->type == BPF_PROG_TYPE_STRUCT_OPS) {

kernel/bpf/verifier.c

18937

int ret = 0, subprog = -1, i;

kernel/bpf/verifier.c

18978

subprog = i;

kernel/bpf/verifier.c

18981

if (subprog == -1) {

kernel/bpf/verifier.c

18985

if (aux->func && aux->func[subprog]->aux->exception_cb) {

kernel/bpf/verifier.c

18991

conservative = aux->func_info_aux[subprog].unreliable;

kernel/bpf/verifier.c

19004

? aux->func[subprog]->aux->changes_pkt_data

kernel/bpf/verifier.c

19013

? aux->func[subprog]->aux->might_sleep

kernel/bpf/verifier.c

19202

if (subprog == 0)

kernel/bpf/verifier.c

19205

addr = (long) tgt_prog->aux->func[subprog]->bpf_func;

kernel/bpf/verifier.c

2273

int subprog, bool is_sleepable)

kernel/bpf/verifier.c

2307

subprog /* subprog number within this prog */);

kernel/bpf/verifier.c

2779

struct bpf_subprog_info *subprog = env->subprog_info;

kernel/bpf/verifier.c

2831

subprog[env->subprog_cnt].start = insn_cnt;

kernel/bpf/verifier.c

2835

verbose(env, "func#%d @%d\n", i, subprog[i].start);

kernel/bpf/verifier.c

2843

struct bpf_subprog_info *subprog = env->subprog_info;

kernel/bpf/verifier.c

2848

subprog_start = subprog[cur_subprog].start;

kernel/bpf/verifier.c

2849

subprog_end = subprog[cur_subprog + 1].start;

kernel/bpf/verifier.c

2856

subprog[cur_subprog].has_tail_call = true;

kernel/bpf/verifier.c

2857

subprog[cur_subprog].tail_call_reachable = true;

kernel/bpf/verifier.c

2861

subprog[cur_subprog].has_ld_abs = true;

kernel/bpf/verifier.c

2867

subprog[cur_subprog].exit_idx = i;

kernel/bpf/verifier.c

2890

subprog_end = subprog[cur_subprog + 1].start;

kernel/bpf/verifier.c

3416

struct bpf_subprog_info *subprog = &env->subprog_info[state->subprogno];

kernel/bpf/verifier.c

3420

if (subprog->fastcall_stack_off <= off || aux[insn_idx].fastcall_pattern)

kernel/bpf/verifier.c

3427

subprog->fastcall_stack_off = S16_MIN;

kernel/bpf/verifier.c

3431

for (i = subprog->start; i < (subprog + 1)->start; ++i) {

kernel/bpf/verifier.c

395

bool bpf_subprog_is_global(const struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

399

return aux && aux[subprog].linkage == BTF_FUNC_GLOBAL;

kernel/bpf/verifier.c

402

static bool subprog_returns_void(struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

4038

struct bpf_subprog_info *subprog = &env->subprog_info[state->subprogno];

kernel/bpf/verifier.c

4054

if (spi + 1 > subprog->max_out_stack_arg_cnt)

kernel/bpf/verifier.c

4055

subprog->max_out_stack_arg_cnt = spi + 1;

kernel/bpf/verifier.c

4077

struct bpf_subprog_info *subprog = &env->subprog_info[state->subprogno];

kernel/bpf/verifier.c

408

btf_id = env->prog->aux->func_info[subprog].type_id;

kernel/bpf/verifier.c

4088

if (spi + 1 > bpf_in_stack_arg_cnt(subprog)) {

kernel/bpf/verifier.c

4090

off, bpf_in_stack_arg_cnt(subprog) * BPF_REG_SIZE);

kernel/bpf/verifier.c

425

static const char *subprog_name(const struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

432

info = &env->prog->aux->func_info[subprog];

kernel/bpf/verifier.c

436

void bpf_mark_subprog_exc_cb(struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

438

struct bpf_subprog_info *info = subprog_info(env, subprog);

kernel/bpf/verifier.c

445

static bool subprog_is_exc_cb(struct bpf_verifier_env *env, int subprog)

kernel/bpf/verifier.c

447

return subprog_info(env, subprog)->is_exception_cb;

kernel/bpf/verifier.c

5080

struct bpf_subprog_info *subprog = env->subprog_info;

kernel/bpf/verifier.c

5090

i = subprog[idx].start;

kernel/bpf/verifier.c

5092

subprog[idx].priv_stack_mode = NO_PRIV_STACK;

kernel/bpf/verifier.c

5113

if (idx && subprog[idx].has_tail_call && depth >= 256) {

kernel/bpf/verifier.c

5120

subprog_depth = round_up_stack_depth(env, subprog[idx].stack_depth);

kernel/bpf/verifier.c

5121

if (IS_ENABLED(CONFIG_X86_64) && subprog[idx].stack_arg_cnt) {

kernel/bpf/verifier.c

5123

subprog[idx].priv_stack_mode = NO_PRIV_STACK;

kernel/bpf/verifier.c

5129

if (subprog[idx].priv_stack_mode == PRIV_STACK_UNKNOWN &&

kernel/bpf/verifier.c

5131

subprog[idx].priv_stack_mode = PRIV_STACK_ADAPTIVE;

kernel/bpf/verifier.c

5134

if (subprog[idx].priv_stack_mode == PRIV_STACK_ADAPTIVE) {

kernel/bpf/verifier.c

5157

subprog_end = subprog[idx + 1].start;

kernel/bpf/verifier.c

5167

if (subprog[tmp].is_cb) {

kernel/bpf/verifier.c

5189

if (subprog[sidx].is_async_cb) {

kernel/bpf/verifier.c

5190

if (subprog[sidx].has_tail_call) {

kernel/bpf/verifier.c

5197

if (subprog[sidx].is_exception_cb) {

kernel/bpf/verifier.c

5214

subprog[idx].priv_stack_mode = NO_PRIV_STACK;

kernel/bpf/verifier.c

5216

if (subprog[idx].has_tail_call)

kernel/bpf/verifier.c

5234

if (subprog[tmp].is_exception_cb) {

kernel/bpf/verifier.c

5238

if (subprog[tmp].stack_arg_cnt) {

kernel/bpf/verifier.c

5242

subprog[tmp].tail_call_reachable = true;

kernel/bpf/verifier.c

5244

} else if (!idx && subprog[0].has_tail_call && subprog[0].stack_arg_cnt) {

kernel/bpf/verifier.c

5249

if (subprog[0].tail_call_reachable)

kernel/bpf/verifier.c

5257

if (subprog[idx].priv_stack_mode != PRIV_STACK_ADAPTIVE)

kernel/bpf/verifier.c

5258

depth -= round_up_stack_depth(env, subprog[idx].stack_depth);

kernel/bpf/verifier.c

5268

tail_call_reachable = subprog[idx].tail_call_reachable;

kernel/bpf/verifier.c

9082

static int setup_func_entry(struct bpf_verifier_env *env, int subprog, int callsite,

kernel/bpf/verifier.c

9114

subprog /* subprog number within this prog */);

kernel/bpf/verifier.c

9130

static int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog,

kernel/bpf/verifier.c

9134

struct bpf_subprog_info *sub = subprog_info(env, subprog);

kernel/bpf/verifier.c

9141

ret = btf_prepare_func_args(env, subprog);

kernel/bpf/verifier.c

9248

static int btf_check_subprog_call(struct bpf_verifier_env *env, int subprog,

kernel/bpf/verifier.c

9259

btf_id = prog->aux->func_info[subprog].type_id;

kernel/bpf/verifier.c

9263

if (prog->aux->func_info_aux[subprog].unreliable)

kernel/bpf/verifier.c

9266

err = btf_check_func_arg_match(env, subprog, btf, regs);

kernel/bpf/verifier.c

9272

prog->aux->func_info_aux[subprog].unreliable = true;

kernel/bpf/verifier.c

9277

int insn_idx, int subprog,

kernel/bpf/verifier.c

9285

err = btf_check_subprog_call(env, subprog, caller->regs);

kernel/bpf/verifier.c

9293

env->subprog_info[subprog].is_cb = true;

kernel/bpf/verifier.c

9310

env->subprog_info[subprog].is_async_cb = true;

kernel/bpf/verifier.c

9311

async_cb = push_async_cb(env, env->subprog_info[subprog].start,

kernel/bpf/verifier.c

9312

insn_idx, subprog,

kernel/bpf/verifier.c

9330

callback_state = push_stack(env, env->subprog_info[subprog].start, insn_idx, false);

kernel/bpf/verifier.c

9334

err = setup_func_entry(env, subprog, insn_idx, set_callee_state_cb,

kernel/bpf/verifier.c

9355

int err, subprog, target_insn;

kernel/bpf/verifier.c

9358

subprog = bpf_find_subprog(env, target_insn);

kernel/bpf/verifier.c

9359

if (verifier_bug_if(subprog < 0, env, "target of func call at insn %d is not a program",

kernel/bpf/verifier.c

9364

err = btf_check_subprog_call(env, subprog, caller->regs);

kernel/bpf/verifier.c

9367

if (bpf_subprog_is_global(env, subprog)) {

kernel/bpf/verifier.c

9368

const char *sub_name = subprog_name(env, subprog);

kernel/bpf/verifier.c

9376

if (env->subprog_info[subprog].might_sleep && !in_sleepable_context(env)) {

kernel/bpf/verifier.c

9384

subprog, sub_name);

kernel/bpf/verifier.c

9390

subprog, sub_name);

kernel/bpf/verifier.c

9391

if (env->subprog_info[subprog].changes_pkt_data)

kernel/bpf/verifier.c

9394

subprog_aux(env, subprog)->called = true;

kernel/bpf/verifier.c

9399

if (!subprog_returns_void(env, subprog)) {

kernel/bpf/verifier.c

9404

if (env->subprog_info[subprog].might_throw) {

kernel/bpf/verifier.c

9424

callee_incoming = bpf_in_stack_arg_cnt(&env->subprog_info[subprog]);

kernel/bpf/verifier.c

9432

err = setup_func_entry(env, subprog, *insn_idx, set_callee_state, state);

kernel/bpf/verifier.c

9439

*insn_idx = env->subprog_info[subprog].start - 1;

kernel/events/core.c

10335

struct bpf_prog *subprog = prog->aux->func[i];

kernel/events/core.c

10339

(u64)(unsigned long)subprog->bpf_func,

kernel/events/core.c

10340

subprog->jited_len, unregister,

kernel/events/core.c

10341

subprog->aux->ksym.name);

tools/lib/bpf/libbpf.c

6687

static int append_subprog_relos(struct bpf_program *main_prog, struct bpf_program *subprog)

tools/lib/bpf/libbpf.c

6689

int new_cnt = main_prog->nr_reloc + subprog->nr_reloc;

tools/lib/bpf/libbpf.c

6693

if (main_prog == subprog)

tools/lib/bpf/libbpf.c

6702

if (subprog->nr_reloc)

tools/lib/bpf/libbpf.c

6703

memcpy(relos + main_prog->nr_reloc, subprog->reloc_desc,

tools/lib/bpf/libbpf.c

6704

sizeof(*relos) * subprog->nr_reloc);

tools/lib/bpf/libbpf.c

6707

relos[i].insn_idx += subprog->sub_insn_off;

tools/lib/bpf/libbpf.c

6716

static int save_subprog_offsets(struct bpf_program *main_prog, struct bpf_program *subprog)

tools/lib/bpf/libbpf.c

6727

main_prog->subprogs[cnt].sec_insn_off = subprog->sec_insn_off;

tools/lib/bpf/libbpf.c

6728

main_prog->subprogs[cnt].sub_insn_off = subprog->sub_insn_off;

tools/lib/bpf/libbpf.c

6736

struct bpf_program *subprog)

tools/lib/bpf/libbpf.c

6742

subprog->sub_insn_off = main_prog->insns_cnt;

tools/lib/bpf/libbpf.c

6744

new_cnt = main_prog->insns_cnt + subprog->insns_cnt;

tools/lib/bpf/libbpf.c

6753

memcpy(main_prog->insns + subprog->sub_insn_off, subprog->insns,

tools/lib/bpf/libbpf.c

6754

subprog->insns_cnt * sizeof(*insns));

tools/lib/bpf/libbpf.c

6757

main_prog->name, subprog->insns_cnt, subprog->name);

tools/lib/bpf/libbpf.c

6760

err = append_subprog_relos(main_prog, subprog);

tools/lib/bpf/libbpf.c

6764

err = save_subprog_offsets(main_prog, subprog);

tools/lib/bpf/libbpf.c

6779

struct bpf_program *subprog;

tools/lib/bpf/libbpf.c

6838

subprog = find_prog_by_sec_insn(obj, obj->efile.text_shndx, sub_insn_idx);

tools/lib/bpf/libbpf.c

6839

if (!subprog) {

tools/lib/bpf/libbpf.c

6855

if (subprog->sub_insn_off == 0) {

tools/lib/bpf/libbpf.c

6856

err = bpf_object__append_subprog_code(obj, main_prog, subprog);

tools/lib/bpf/libbpf.c

6859

err = bpf_object__reloc_code(obj, main_prog, subprog);

tools/lib/bpf/libbpf.c

6874

insn->imm = subprog->sub_insn_off - (prog->sub_insn_off + insn_idx) - 1;

tools/lib/bpf/libbpf.c

6877

prog->name, insn_idx, insn->imm, subprog->name, subprog->sub_insn_off);

tools/lib/bpf/libbpf.c

6967

struct bpf_program *subprog;

tools/lib/bpf/libbpf.c

6974

subprog = &obj->programs[i];

tools/lib/bpf/libbpf.c

6975

if (!prog_is_subprog(obj, subprog))

tools/lib/bpf/libbpf.c

6978

subprog->sub_insn_off = 0;

tools/lib/bpf/libbpf.c

7078

struct bpf_program *subprog = &obj->programs[j];

tools/lib/bpf/libbpf.c

7080

if (!prog_is_subprog(obj, subprog))

tools/lib/bpf/libbpf.c

7082

if (strcmp(name, subprog->name) != 0)

tools/lib/bpf/libbpf.c

7088

if (!subprog->sym_global || subprog->mark_btf_static) {

tools/lib/bpf/libbpf.c

7090

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7096

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7504

struct bpf_program *subprog = &obj->programs[prog->exception_cb_idx];

tools/lib/bpf/libbpf.c

7511

if (subprog->sub_insn_off == 0) {

tools/lib/bpf/libbpf.c

7512

err = bpf_object__append_subprog_code(obj, prog, subprog);

tools/lib/bpf/libbpf.c

7515

err = bpf_object__reloc_code(obj, prog, subprog);

tools/testing/selftests/bpf/progs/epilogue_tailcall.c

21

subprog(args);

tools/testing/selftests/bpf/progs/exceptions.c

201

return subprog(ctx);

tools/testing/selftests/bpf/progs/linked_funcs1.c

28

output_val1 = x + subprog(x);

tools/testing/selftests/bpf/progs/linked_funcs2.c

28

output_val2 = 2 * x + 2 * subprog(x);

tools/testing/selftests/bpf/progs/stream.c

206

subprog();

tools/testing/selftests/bpf/progs/test_static_linked1.c

24

var1 = subprog(rovar1) + static_var1 + static_var2;

tools/testing/selftests/bpf/progs/test_static_linked2.c

24

var2 = subprog(rovar2) + static_var1 + static_var2;