arch/arc/net/bpf_jit_core.c

101

struct bpf_prog *prog;

arch/arc/net/bpf_jit_core.c

1027

if (is_last_insn(ctx->prog, idx))

arch/arc/net/bpf_jit_core.c

1056

const struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1068

for (u32 i = 0; i < prog->len; i++) {

arch/arc/net/bpf_jit_core.c

1115

ctx->bpf2insn = kcalloc(ctx->prog->len, sizeof(ctx->jit.len),

arch/arc/net/bpf_jit_core.c

1223

struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1229

prog->aux->jit_data = (void *)ctx->jit_data;

arch/arc/net/bpf_jit_core.c

1242

prog->aux->jit_data = NULL;

arch/arc/net/bpf_jit_core.c

1243

bpf_prog_fill_jited_linfo(prog, ctx->bpf2insn);

arch/arc/net/bpf_jit_core.c

1247

prog->bpf_func = (void *)ctx->jit.buf;

arch/arc/net/bpf_jit_core.c

1248

prog->jited_len = ctx->jit.len;

arch/arc/net/bpf_jit_core.c

1249

prog->jited = 1;

arch/arc/net/bpf_jit_core.c

125

static void vm_dump(const struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1262

static inline int check_jit_context(const struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1264

if (!prog->aux->jit_data) {

arch/arc/net/bpf_jit_core.c

1276

(struct arc_jit_data *)ctx->prog->aux->jit_data;

arch/arc/net/bpf_jit_core.c

1283

ctx->jit.buf = (u8 *)ctx->prog->bpf_func;

arch/arc/net/bpf_jit_core.c

1284

ctx->jit.len = ctx->prog->jited_len;

arch/arc/net/bpf_jit_core.c

129

dump_bytes((u8 *)prog->insns, 8 * prog->len, " VM ");

arch/arc/net/bpf_jit_core.c

1309

const struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1313

for (u32 i = 0; i < prog->len; i++) {

arch/arc/net/bpf_jit_core.c

1314

const struct bpf_insn *insn = &prog->insnsi[i];

arch/arc/net/bpf_jit_core.c

1338

static struct bpf_prog *do_normal_pass(struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1343

if (!prog->jit_requested)

arch/arc/net/bpf_jit_core.c

1344

return prog;

arch/arc/net/bpf_jit_core.c

1346

if (jit_ctx_init(&ctx, prog)) {

arch/arc/net/bpf_jit_core.c

1348

return prog;

arch/arc/net/bpf_jit_core.c

1354

return prog;

arch/arc/net/bpf_jit_core.c

1359

return prog;

arch/arc/net/bpf_jit_core.c

1364

return prog;

arch/arc/net/bpf_jit_core.c

1367

return ctx.prog;

arch/arc/net/bpf_jit_core.c

1377

static struct bpf_prog *do_extra_pass(struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1382

if (check_jit_context(prog))

arch/arc/net/bpf_jit_core.c

1383

return prog;

arch/arc/net/bpf_jit_core.c

1385

if (jit_ctx_init(&ctx, prog)) {

arch/arc/net/bpf_jit_core.c

1387

return prog;

arch/arc/net/bpf_jit_core.c

1392

return prog;

arch/arc/net/bpf_jit_core.c

1397

return prog;

arch/arc/net/bpf_jit_core.c

1402

return prog;

arch/arc/net/bpf_jit_core.c

1405

return ctx.prog;

arch/arc/net/bpf_jit_core.c

1414

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1416

vm_dump(prog);

arch/arc/net/bpf_jit_core.c

1419

if (!prog->jited)

arch/arc/net/bpf_jit_core.c

1420

return do_normal_pass(prog);

arch/arc/net/bpf_jit_core.c

1422

return do_extra_pass(prog);

arch/arc/net/bpf_jit_core.c

1424

return prog;

arch/arc/net/bpf_jit_core.c

147

if (bpf_jit_enable <= 1 || !ctx->prog->jited)

arch/arc/net/bpf_jit_core.c

155

bpf_jit_dump(ctx->prog->len, ctx->jit.len, pass, ctx->jit.buf);

arch/arc/net/bpf_jit_core.c

160

static int jit_ctx_init(struct jit_context *ctx, struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

164

ctx->orig_prog = prog;

arch/arc/net/bpf_jit_core.c

167

ctx->prog = bpf_jit_blind_constants(prog);

arch/arc/net/bpf_jit_core.c

168

if (IS_ERR(ctx->prog))

arch/arc/net/bpf_jit_core.c

169

return PTR_ERR(ctx->prog);

arch/arc/net/bpf_jit_core.c

170

ctx->blinded = (ctx->prog != ctx->orig_prog);

arch/arc/net/bpf_jit_core.c

173

ctx->do_zext = !ctx->prog->aux->verifier_zext;

arch/arc/net/bpf_jit_core.c

175

ctx->is_extra_pass = ctx->prog->jited;

arch/arc/net/bpf_jit_core.c

176

ctx->user_bpf_prog = ctx->prog->is_func;

arch/arc/net/bpf_jit_core.c

220

bpf_jit_prog_release_other(ctx->prog, ctx->orig_prog);

arch/arc/net/bpf_jit_core.c

222

bpf_jit_prog_release_other(ctx->orig_prog, ctx->prog);

arch/arc/net/bpf_jit_core.c

252

const struct bpf_insn *insn = ctx->prog->insnsi;

arch/arc/net/bpf_jit_core.c

254

for (i = 0; i < ctx->prog->len; i++) {

arch/arc/net/bpf_jit_core.c

264

ctx->frame_size = ctx->prog->aux->stack_depth;

arch/arc/net/bpf_jit_core.c

333

return (insn - ctx->prog->insnsi);

arch/arc/net/bpf_jit_core.c

381

static inline bool is_last_insn(const struct bpf_prog *prog, u32 idx)

arch/arc/net/bpf_jit_core.c

383

return idx == (prog->len - 1);

arch/arc/net/bpf_jit_core.c

426

return (idx >= 0 && idx < ctx->prog->len);

arch/arc/net/bpf_jit_core.c

675

ret = bpf_jit_get_func_addr(ctx->prog, insn, ctx->is_extra_pass,

arch/arc/net/bpf_jit_core.c

711

if (is_last_insn(ctx->prog, idx)) {

arch/arc/net/bpf_jit_core.c

738

const struct bpf_insn *insn = &ctx->prog->insnsi[idx];

arch/arm/net/bpf_jit_32.c

1281

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1287

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1293

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1598

const int i = insn - ctx->prog->insnsi;

arch/arm/net/bpf_jit_32.c

1710

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1740

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1776

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1835

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

1840

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

203

const struct bpf_prog *prog;

arch/arm/net/bpf_jit_32.c

2075

if (i == ctx->prog->len - 1)

arch/arm/net/bpf_jit_32.c

2101

const struct bpf_prog *prog = ctx->prog;

arch/arm/net/bpf_jit_32.c

2104

for (i = 0; i < prog->len; i++) {

arch/arm/net/bpf_jit_32.c

2105

const struct bpf_insn *insn = &(prog->insnsi[i]);

arch/arm/net/bpf_jit_32.c

2145

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/arm/net/bpf_jit_32.c

2147

struct bpf_prog *tmp, *orig_prog = prog;

arch/arm/net/bpf_jit_32.c

2158

if (!prog->jit_requested)

arch/arm/net/bpf_jit_32.c

2165

tmp = bpf_jit_blind_constants(prog);

arch/arm/net/bpf_jit_32.c

2169

if (tmp != prog) {

arch/arm/net/bpf_jit_32.c

2171

prog = tmp;

arch/arm/net/bpf_jit_32.c

2175

ctx.prog = prog;

arch/arm/net/bpf_jit_32.c

2181

ctx.offsets = kcalloc(prog->len, sizeof(int), GFP_KERNEL);

arch/arm/net/bpf_jit_32.c

2183

prog = orig_prog;

arch/arm/net/bpf_jit_32.c

2198

prog = orig_prog;

arch/arm/net/bpf_jit_32.c

2217

prog = orig_prog;

arch/arm/net/bpf_jit_32.c

2242

prog = orig_prog;

arch/arm/net/bpf_jit_32.c

2266

bpf_jit_dump(prog->len, image_size, 2, ctx.target);

arch/arm/net/bpf_jit_32.c

2270

prog->bpf_func = (void *)ctx.target;

arch/arm/net/bpf_jit_32.c

2271

prog->jited = 1;

arch/arm/net/bpf_jit_32.c

2272

prog->jited_len = image_size;

arch/arm/net/bpf_jit_32.c

2283

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/arm/net/bpf_jit_32.c

2285

return prog;

arch/arm/net/bpf_jit_32.c

2290

prog = orig_prog;

arch/arm/net/bpf_jit_32.c

404

#define _STACK_SIZE (ctx->prog->aux->stack_depth + SCRATCH_SIZE)

arch/arm/net/bpf_jit_32.c

430

offset = ctx->offsets[ctx->prog->len - 1] * 4;

arch/arm/net/bpf_jit_32.c

866

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

888

if (!ctx->prog->aux->verifier_zext)

arch/arm/net/bpf_jit_32.c

951

if (!ctx->prog->aux->verifier_zext)

arch/arm64/net/bpf_jit_comp.c

1139

if (!ctx->prog->aux->extable ||

arch/arm64/net/bpf_jit_comp.c

1140

WARN_ON_ONCE(ctx->exentry_idx >= ctx->prog->aux->num_exentries))

arch/arm64/net/bpf_jit_comp.c

1143

ex = &ctx->prog->aux->extable[ctx->exentry_idx];

arch/arm64/net/bpf_jit_comp.c

1215

const int i = insn - ctx->prog->insnsi;

arch/arm64/net/bpf_jit_comp.c

1597

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass,

arch/arm64/net/bpf_jit_comp.c

1620

if (i == ctx->prog->len - 1)

arch/arm64/net/bpf_jit_comp.c

1904

const struct bpf_prog *prog = ctx->prog;

arch/arm64/net/bpf_jit_comp.c

1916

for (i = 0; i < prog->len; i++) {

arch/arm64/net/bpf_jit_comp.c

1917

const struct bpf_insn *insn = &prog->insnsi[i];

arch/arm64/net/bpf_jit_comp.c

1958

if (WARN_ON_ONCE(ctx->exentry_idx != ctx->prog->aux->num_exentries))

arch/arm64/net/bpf_jit_comp.c

1984

struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

1996

bpf_jit_get_prog_name(prog));

arch/arm64/net/bpf_jit_comp.c

2009

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

2012

struct bpf_prog *tmp, *orig_prog = prog;

arch/arm64/net/bpf_jit_comp.c

2017

bool was_classic = bpf_prog_was_classic(prog);

arch/arm64/net/bpf_jit_comp.c

2027

if (!prog->jit_requested)

arch/arm64/net/bpf_jit_comp.c

2030

tmp = bpf_jit_blind_constants(prog);

arch/arm64/net/bpf_jit_comp.c

2036

if (tmp != prog) {

arch/arm64/net/bpf_jit_comp.c

2038

prog = tmp;

arch/arm64/net/bpf_jit_comp.c

2041

jit_data = prog->aux->jit_data;

arch/arm64/net/bpf_jit_comp.c

2045

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2048

prog->aux->jit_data = jit_data;

arch/arm64/net/bpf_jit_comp.c

2050

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

2051

if (!priv_stack_ptr && prog->aux->jits_use_priv_stack) {

arch/arm64/net/bpf_jit_comp.c

2056

priv_stack_alloc_sz = round_up(prog->aux->stack_depth, 16) +

arch/arm64/net/bpf_jit_comp.c

2060

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2065

prog->aux->priv_stack_ptr = priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

2079

ctx.prog = prog;

arch/arm64/net/bpf_jit_comp.c

2081

ctx.offset = kvzalloc_objs(int, prog->len + 1);

arch/arm64/net/bpf_jit_comp.c

2083

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2087

ctx.user_vm_start = bpf_arena_get_user_vm_start(prog->aux->arena);

arch/arm64/net/bpf_jit_comp.c

2088

ctx.arena_vm_start = bpf_arena_get_kern_vm_start(prog->aux->arena);

arch/arm64/net/bpf_jit_comp.c

2099

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2104

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2113

extable_size = prog->aux->num_exentries *

arch/arm64/net/bpf_jit_comp.c

2125

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2141

prog->aux->extable = (void *)ro_image_ptr + extable_offset;

arch/arm64/net/bpf_jit_comp.c

2156

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2168

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2177

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2186

bpf_jit_dump(prog->len, prog_size, 2, ctx.image);

arch/arm64/net/bpf_jit_comp.c

2188

if (!prog->is_func || extra_pass) {

arch/arm64/net/bpf_jit_comp.c

2196

prog->bpf_func = NULL;

arch/arm64/net/bpf_jit_comp.c

2197

prog->jited = 0;

arch/arm64/net/bpf_jit_comp.c

2198

prog->jited_len = 0;

arch/arm64/net/bpf_jit_comp.c

2204

prog = orig_prog;

arch/arm64/net/bpf_jit_comp.c

2220

prog->bpf_func = (void *)ctx.ro_image + cfi_get_offset();

arch/arm64/net/bpf_jit_comp.c

2221

prog->jited = 1;

arch/arm64/net/bpf_jit_comp.c

2222

prog->jited_len = prog_size - cfi_get_offset();

arch/arm64/net/bpf_jit_comp.c

2224

if (!prog->is_func || extra_pass) {

arch/arm64/net/bpf_jit_comp.c

2228

for (i = 0; i <= prog->len; i++)

arch/arm64/net/bpf_jit_comp.c

2230

bpf_prog_fill_jited_linfo(prog, ctx.offset + 1);

arch/arm64/net/bpf_jit_comp.c

2237

bpf_prog_update_insn_ptrs(prog, ctx.offset, ctx.ro_image);

arch/arm64/net/bpf_jit_comp.c

2241

prog->aux->priv_stack_ptr = NULL;

arch/arm64/net/bpf_jit_comp.c

2246

prog->aux->jit_data = NULL;

arch/arm64/net/bpf_jit_comp.c

2250

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/arm64/net/bpf_jit_comp.c

2252

return prog;

arch/arm64/net/bpf_jit_comp.c

2298

struct bpf_prog *p = l->link.prog;

arch/arm64/net/bpf_jit_comp.c

3171

void bpf_jit_free(struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

3173

if (prog->jited) {

arch/arm64/net/bpf_jit_comp.c

3174

struct arm64_jit_data *jit_data = prog->aux->jit_data;

arch/arm64/net/bpf_jit_comp.c

3188

prog->bpf_func = (void *)prog->bpf_func - cfi_get_offset();

arch/arm64/net/bpf_jit_comp.c

3189

hdr = bpf_jit_binary_pack_hdr(prog);

arch/arm64/net/bpf_jit_comp.c

3191

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

3193

priv_stack_alloc_sz = round_up(prog->aux->stack_depth, 16) +

arch/arm64/net/bpf_jit_comp.c

3195

priv_stack_check_guard(priv_stack_ptr, priv_stack_alloc_sz, prog);

arch/arm64/net/bpf_jit_comp.c

3196

free_percpu(prog->aux->priv_stack_ptr);

arch/arm64/net/bpf_jit_comp.c

3198

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/arm64/net/bpf_jit_comp.c

3201

bpf_prog_unlock_free(prog);

arch/arm64/net/bpf_jit_comp.c

363

const bool is_main_prog = !bpf_is_subprog(ctx->prog);

arch/arm64/net/bpf_jit_comp.c

377

const struct bpf_prog *prog = ctx->prog;

arch/arm64/net/bpf_jit_comp.c

378

const struct bpf_insn *insn = &prog->insnsi[0];

arch/arm64/net/bpf_jit_comp.c

381

for (i = 0; i < prog->len; i++, insn++) {

arch/arm64/net/bpf_jit_comp.c

435

if (ctx->prog->aux->exception_boundary) {

arch/arm64/net/bpf_jit_comp.c

460

struct bpf_prog_aux *aux = ctx->prog->aux;

arch/arm64/net/bpf_jit_comp.c

515

const struct bpf_prog *prog = ctx->prog;

arch/arm64/net/bpf_jit_comp.c

516

const bool is_main_prog = !bpf_is_subprog(prog);

arch/arm64/net/bpf_jit_comp.c

560

if (!prog->aux->exception_cb) {

arch/arm64/net/bpf_jit_comp.c

599

ctx->stack_size = round_up(prog->aux->stack_depth, 16);

arch/arm64/net/bpf_jit_comp.c

604

priv_stack_ptr = prog->aux->priv_stack_ptr + PRIV_STACK_GUARD_SZ;

arch/arm64/net/bpf_jit_comp.c

80

const struct bpf_prog *prog;

arch/arm64/net/bpf_jit_comp.c

854

const int i = insn - ctx->prog->insnsi;

arch/loongarch/net/bpf_jit.c

1004

m = bpf_jit_find_kfunc_model(ctx->prog, insn);

arch/loongarch/net/bpf_jit.c

1032

if (i == ctx->prog->len - 1)

arch/loongarch/net/bpf_jit.c

1281

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

1283

for (i = 0; i < prog->len; i++) {

arch/loongarch/net/bpf_jit.c

1284

const struct bpf_insn *insn = &prog->insnsi[i];

arch/loongarch/net/bpf_jit.c

129

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

130

const bool is_main_prog = !bpf_is_subprog(prog);

arch/loongarch/net/bpf_jit.c

132

bpf_stack_adjust = round_up(ctx->prog->aux->stack_depth, 16);

arch/loongarch/net/bpf_jit.c

1337

if (WARN_ON_ONCE(ctx->num_exentries != ctx->prog->aux->num_exentries))

arch/loongarch/net/bpf_jit.c

1494

struct bpf_prog *p = l->link.prog;

arch/loongarch/net/bpf_jit.c

1923

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/loongarch/net/bpf_jit.c

1932

struct bpf_prog *tmp, *orig_prog = prog;

arch/loongarch/net/bpf_jit.c

1938

if (!prog->jit_requested)

arch/loongarch/net/bpf_jit.c

1941

tmp = bpf_jit_blind_constants(prog);

arch/loongarch/net/bpf_jit.c

1950

if (tmp != prog) {

arch/loongarch/net/bpf_jit.c

1952

prog = tmp;

arch/loongarch/net/bpf_jit.c

1955

jit_data = prog->aux->jit_data;

arch/loongarch/net/bpf_jit.c

1959

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

1962

prog->aux->jit_data = jit_data;

arch/loongarch/net/bpf_jit.c

1976

ctx.prog = prog;

arch/loongarch/net/bpf_jit.c

1977

ctx.arena_vm_start = bpf_arena_get_kern_vm_start(prog->aux->arena);

arch/loongarch/net/bpf_jit.c

1978

ctx.user_vm_start = bpf_arena_get_user_vm_start(prog->aux->arena);

arch/loongarch/net/bpf_jit.c

1980

ctx.offset = kvcalloc(prog->len + 1, sizeof(u32), GFP_KERNEL);

arch/loongarch/net/bpf_jit.c

1982

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

1989

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

1995

extable_size = prog->aux->num_exentries * sizeof(struct exception_table_entry);

arch/loongarch/net/bpf_jit.c

2008

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

2023

prog->aux->extable = (void *)ro_image_ptr + prog_size;

arch/loongarch/net/bpf_jit.c

2031

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

2038

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

2044

bpf_jit_dump(prog->len, prog_size, 2, ctx.image);

arch/loongarch/net/bpf_jit.c

2046

if (!prog->is_func || extra_pass) {

arch/loongarch/net/bpf_jit.c

2055

prog = orig_prog;

arch/loongarch/net/bpf_jit.c

2069

prog->jited = 1;

arch/loongarch/net/bpf_jit.c

2070

prog->jited_len = prog_size;

arch/loongarch/net/bpf_jit.c

2071

prog->bpf_func = (void *)ctx.ro_image;

arch/loongarch/net/bpf_jit.c

2073

if (!prog->is_func || extra_pass) {

arch/loongarch/net/bpf_jit.c

2077

for (i = 0; i <= prog->len; i++)

arch/loongarch/net/bpf_jit.c

2079

bpf_prog_fill_jited_linfo(prog, ctx.offset + 1);

arch/loongarch/net/bpf_jit.c

2084

prog->aux->jit_data = NULL;

arch/loongarch/net/bpf_jit.c

2089

bpf_jit_prog_release_other(prog, prog == orig_prog ? tmp : orig_prog);

arch/loongarch/net/bpf_jit.c

2091

return prog;

arch/loongarch/net/bpf_jit.c

2101

void bpf_jit_free(struct bpf_prog *prog)

arch/loongarch/net/bpf_jit.c

2103

if (prog->jited) {

arch/loongarch/net/bpf_jit.c

2104

struct jit_data *jit_data = prog->aux->jit_data;

arch/loongarch/net/bpf_jit.c

2116

hdr = bpf_jit_binary_pack_hdr(prog);

arch/loongarch/net/bpf_jit.c

2118

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/loongarch/net/bpf_jit.c

2121

bpf_prog_unlock_free(prog);

arch/loongarch/net/bpf_jit.c

45

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

46

const bool is_main_prog = !bpf_is_subprog(prog);

arch/loongarch/net/bpf_jit.c

486

if (!ctx->image || !ctx->ro_image || !ctx->prog->aux->extable)

arch/loongarch/net/bpf_jit.c

494

if (WARN_ON_ONCE(ctx->num_exentries >= ctx->prog->aux->num_exentries))

arch/loongarch/net/bpf_jit.c

497

ex = &ctx->prog->aux->extable[ctx->num_exentries];

arch/loongarch/net/bpf_jit.c

545

int i = insn - ctx->prog->insnsi;

arch/loongarch/net/bpf_jit.c

990

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass,

arch/loongarch/net/bpf_jit.h

14

const struct bpf_prog *prog;

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

245

uint64_t prog:8;

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

249

uint64_t prog:8;

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

262

uint64_t prog:8;

arch/mips/include/asm/octeon/cvmx-lmcx-defs.h

266

uint64_t prog:8;

arch/mips/include/asm/octeon/cvmx-mio-defs.h

2194

uint64_t prog:1;

arch/mips/include/asm/octeon/cvmx-mio-defs.h

2196

uint64_t prog:1;

arch/mips/include/asm/octeon/cvmx-mio-defs.h

2204

uint64_t prog:1;

arch/mips/include/asm/octeon/cvmx-mio-defs.h

2206

uint64_t prog:1;

arch/mips/net/bpf_jit_comp.c

1012

bpf_prog_fill_jited_linfo(prog, &ctx.descriptors[1]);

arch/mips/net/bpf_jit_comp.c

1021

bpf_jit_dump(prog->len, image_size, 2, ctx.target);

arch/mips/net/bpf_jit_comp.c

1023

prog->bpf_func = (void *)ctx.target;

arch/mips/net/bpf_jit_comp.c

1024

prog->jited = 1;

arch/mips/net/bpf_jit_comp.c

1025

prog->jited_len = image_size;

arch/mips/net/bpf_jit_comp.c

1029

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/mips/net/bpf_jit_comp.c

1032

return prog;

arch/mips/net/bpf_jit_comp.c

1035

prog = orig_prog;

arch/mips/net/bpf_jit_comp.c

852

const struct bpf_prog *prog = ctx->program;

arch/mips/net/bpf_jit_comp.c

856

for (i = 0; i < prog->len; i++) {

arch/mips/net/bpf_jit_comp.c

857

const struct bpf_insn *insn = &prog->insnsi[i];

arch/mips/net/bpf_jit_comp.c

883

ctx->descriptors[prog->len] = ctx->jit_index;

arch/mips/net/bpf_jit_comp.c

890

const struct bpf_prog *prog = ctx->program;

arch/mips/net/bpf_jit_comp.c

894

for (i = 0; i <= prog->len; i++)

arch/mips/net/bpf_jit_comp.c

912

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/mips/net/bpf_jit_comp.c

914

struct bpf_prog *tmp, *orig_prog = prog;

arch/mips/net/bpf_jit_comp.c

927

if (!prog->jit_requested)

arch/mips/net/bpf_jit_comp.c

934

tmp = bpf_jit_blind_constants(prog);

arch/mips/net/bpf_jit_comp.c

937

if (tmp != prog) {

arch/mips/net/bpf_jit_comp.c

939

prog = tmp;

arch/mips/net/bpf_jit_comp.c

943

ctx.program = prog;

arch/mips/net/bpf_jit_comp.c

949

ctx.descriptors = kcalloc(prog->len + 1, sizeof(*ctx.descriptors),

arch/parisc/net/bpf_jit.h

66

struct bpf_prog *prog;

arch/parisc/net/bpf_jit_comp32.c

1011

const s8 *rd = bpf_get_reg64_ref(dst, tmp1, ctx->prog->aux->verifier_zext, ctx);

arch/parisc/net/bpf_jit_comp32.c

1029

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1034

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1039

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1121

int s, e, paoff, i = insn - ctx->prog->insnsi;

arch/parisc/net/bpf_jit_comp32.c

1254

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1276

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1281

if (!ctx->prog->aux->verifier_zext)

arch/parisc/net/bpf_jit_comp32.c

1310

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass, &addr,

arch/parisc/net/bpf_jit_comp32.c

1393

if (i == ctx->prog->len - 1)

arch/parisc/net/bpf_jit_comp32.c

1483

bpf_stack_adjust = ctx->prog->aux->stack_depth;

arch/parisc/net/bpf_jit_comp32.c

310

if (1 && !ctx->prog->aux->verifier_zext) {

arch/parisc/net/bpf_jit_comp32.c

314

} else if (1 && !ctx->prog->aux->verifier_zext) {

arch/parisc/net/bpf_jit_comp64.c

1113

bpf_stack_adjust = ctx->prog->aux->stack_depth;

arch/parisc/net/bpf_jit_comp64.c

597

int s, e, ret, i = insn - ctx->prog->insnsi;

arch/parisc/net/bpf_jit_comp64.c

599

struct bpf_prog_aux *aux = ctx->prog->aux;

arch/parisc/net/bpf_jit_comp64.c

973

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass,

arch/parisc/net/bpf_jit_comp64.c

989

if (i == ctx->prog->len - 1)

arch/parisc/net/bpf_jit_core.c

110

extable_size = prog->aux->num_exentries *

arch/parisc/net/bpf_jit_core.c

120

prog = orig_prog;

arch/parisc/net/bpf_jit_core.c

137

prog = orig_prog;

arch/parisc/net/bpf_jit_core.c

142

prog->aux->extable = (void *)ctx->insns + prog_size;

arch/parisc/net/bpf_jit_core.c

151

prog = orig_prog;

arch/parisc/net/bpf_jit_core.c

158

bpf_jit_dump(prog->len, prog_size, pass, ctx->insns);

arch/parisc/net/bpf_jit_core.c

163

prog->bpf_func = (void *)ctx->insns;

arch/parisc/net/bpf_jit_core.c

164

prog->jited = 1;

arch/parisc/net/bpf_jit_core.c

165

prog->jited_len = prog_size;

arch/parisc/net/bpf_jit_core.c

169

if (!prog->is_func || extra_pass) {

arch/parisc/net/bpf_jit_core.c

172

prog->bpf_func = NULL;

arch/parisc/net/bpf_jit_core.c

173

prog->jited = 0;

arch/parisc/net/bpf_jit_core.c

174

prog->jited_len = 0;

arch/parisc/net/bpf_jit_core.c

178

for (i = 0; i < prog->len; i++)

arch/parisc/net/bpf_jit_core.c

18

const struct bpf_prog *prog = ctx->prog;

arch/parisc/net/bpf_jit_core.c

180

bpf_prog_fill_jited_linfo(prog, ctx->offset);

arch/parisc/net/bpf_jit_core.c

184

prog->aux->jit_data = NULL;

arch/parisc/net/bpf_jit_core.c

191

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/parisc/net/bpf_jit_core.c

193

return prog;

arch/parisc/net/bpf_jit_core.c

22

for (i = 0; i < prog->len; i++) {

arch/parisc/net/bpf_jit_core.c

23

const struct bpf_insn *insn = &prog->insnsi[i];

arch/parisc/net/bpf_jit_core.c

44

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/parisc/net/bpf_jit_core.c

48

struct bpf_prog *tmp, *orig_prog = prog;

arch/parisc/net/bpf_jit_core.c

53

if (!prog->jit_requested)

arch/parisc/net/bpf_jit_core.c

56

tmp = bpf_jit_blind_constants(prog);

arch/parisc/net/bpf_jit_core.c

59

if (tmp != prog) {

arch/parisc/net/bpf_jit_core.c

61

prog = tmp;

arch/parisc/net/bpf_jit_core.c

64

jit_data = prog->aux->jit_data;

arch/parisc/net/bpf_jit_core.c

68

prog = orig_prog;

arch/parisc/net/bpf_jit_core.c

71

prog->aux->jit_data = jit_data;

arch/parisc/net/bpf_jit_core.c

82

ctx->prog = prog;

arch/parisc/net/bpf_jit_core.c

83

ctx->offset = kzalloc_objs(int, prog->len);

arch/parisc/net/bpf_jit_core.c

85

prog = orig_prog;

arch/parisc/net/bpf_jit_core.c

88

for (i = 0; i < prog->len; i++) {

arch/parisc/net/bpf_jit_core.c

97

prog = orig_prog;

arch/powerpc/net/bpf_jit_comp.c

518

struct bpf_prog *p = l->link.prog;

arch/riscv/net/bpf_jit.h

73

struct bpf_prog *prog;

arch/riscv/net/bpf_jit_comp32.c

1081

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

1103

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

1108

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

1141

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass, &addr,

arch/riscv/net/bpf_jit_comp32.c

1224

if (i == ctx->prog->len - 1)

arch/riscv/net/bpf_jit_comp32.c

1309

round_up(ctx->prog->aux->stack_depth, STACK_ALIGN);

arch/riscv/net/bpf_jit_comp32.c

220

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

222

} else if (!ctx->prog->aux->verifier_zext) {

arch/riscv/net/bpf_jit_comp32.c

849

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

854

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

859

if (!ctx->prog->aux->verifier_zext)

arch/riscv/net/bpf_jit_comp32.c

958

int s, e, rvoff, i = insn - ctx->prog->insnsi;

arch/riscv/net/bpf_jit_comp64.c

1374

int s, e, rvoff, ret, i = insn - ctx->prog->insnsi;

arch/riscv/net/bpf_jit_comp64.c

1375

struct bpf_prog_aux *aux = ctx->prog->aux;

arch/riscv/net/bpf_jit_comp64.c

1812

ret = bpf_jit_get_func_addr(ctx->prog, insn, extra_pass,

arch/riscv/net/bpf_jit_comp64.c

1821

fm = bpf_jit_find_kfunc_model(ctx->prog, insn);

arch/riscv/net/bpf_jit_comp64.c

1849

if (i == ctx->prog->len - 1)

arch/riscv/net/bpf_jit_comp64.c

1999

bpf_stack_adjust = round_up(ctx->prog->aux->stack_depth, STACK_ALIGN);

arch/riscv/net/bpf_jit_comp64.c

773

if (!ctx->insns || !ctx->ro_insns || !ctx->prog->aux->extable ||

arch/riscv/net/bpf_jit_comp64.c

783

if (WARN_ON_ONCE(ctx->nexentries >= ctx->prog->aux->num_exentries))

arch/riscv/net/bpf_jit_comp64.c

789

ex = &ctx->prog->aux->extable[ctx->nexentries];

arch/riscv/net/bpf_jit_comp64.c

941

struct bpf_prog *p = l->link.prog;

arch/riscv/net/bpf_jit_core.c

105

bpf_jit_build_prologue(ctx, bpf_is_subprog(prog));

arch/riscv/net/bpf_jit_core.c

109

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

120

extable_size = prog->aux->num_exentries *

arch/riscv/net/bpf_jit_core.c

130

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

153

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

158

prog->aux->extable = (void *)ctx->ro_insns + prog_size;

arch/riscv/net/bpf_jit_core.c

165

bpf_jit_build_prologue(ctx, bpf_is_subprog(prog));

arch/riscv/net/bpf_jit_core.c

167

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

173

bpf_jit_dump(prog->len, prog_size, pass, ctx->insns);

arch/riscv/net/bpf_jit_core.c

175

prog->bpf_func = (void *)ctx->ro_insns + cfi_get_offset();

arch/riscv/net/bpf_jit_core.c

176

prog->jited = 1;

arch/riscv/net/bpf_jit_core.c

177

prog->jited_len = prog_size - cfi_get_offset();

arch/riscv/net/bpf_jit_core.c

179

if (!prog->is_func || extra_pass) {

arch/riscv/net/bpf_jit_core.c

183

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

193

for (i = 0; i < prog->len; i++)

arch/riscv/net/bpf_jit_core.c

195

bpf_prog_fill_jited_linfo(prog, ctx->offset);

arch/riscv/net/bpf_jit_core.c

199

prog->aux->jit_data = NULL;

arch/riscv/net/bpf_jit_core.c

204

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/riscv/net/bpf_jit_core.c

206

return prog;

arch/riscv/net/bpf_jit_core.c

21

const struct bpf_prog *prog = ctx->prog;

arch/riscv/net/bpf_jit_core.c

24

for (i = 0; i < prog->len; i++) {

arch/riscv/net/bpf_jit_core.c

247

void bpf_jit_free(struct bpf_prog *prog)

arch/riscv/net/bpf_jit_core.c

249

if (prog->jited) {

arch/riscv/net/bpf_jit_core.c

25

const struct bpf_insn *insn = &prog->insnsi[i];

arch/riscv/net/bpf_jit_core.c

250

struct rv_jit_data *jit_data = prog->aux->jit_data;

arch/riscv/net/bpf_jit_core.c

262

hdr = bpf_jit_binary_pack_hdr(prog);

arch/riscv/net/bpf_jit_core.c

264

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/riscv/net/bpf_jit_core.c

267

bpf_prog_unlock_free(prog);

arch/riscv/net/bpf_jit_core.c

44

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/riscv/net/bpf_jit_core.c

48

struct bpf_prog *tmp, *orig_prog = prog;

arch/riscv/net/bpf_jit_core.c

53

if (!prog->jit_requested)

arch/riscv/net/bpf_jit_core.c

56

tmp = bpf_jit_blind_constants(prog);

arch/riscv/net/bpf_jit_core.c

59

if (tmp != prog) {

arch/riscv/net/bpf_jit_core.c

61

prog = tmp;

arch/riscv/net/bpf_jit_core.c

64

jit_data = prog->aux->jit_data;

arch/riscv/net/bpf_jit_core.c

68

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

71

prog->aux->jit_data = jit_data;

arch/riscv/net/bpf_jit_core.c

82

ctx->arena_vm_start = bpf_arena_get_kern_vm_start(prog->aux->arena);

arch/riscv/net/bpf_jit_core.c

83

ctx->user_vm_start = bpf_arena_get_user_vm_start(prog->aux->arena);

arch/riscv/net/bpf_jit_core.c

84

ctx->prog = prog;

arch/riscv/net/bpf_jit_core.c

85

ctx->offset = kzalloc_objs(int, prog->len);

arch/riscv/net/bpf_jit_core.c

87

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

92

prog = orig_prog;

arch/riscv/net/bpf_jit_core.c

96

for (i = 0; i < prog->len; i++) {

arch/s390/net/bpf_jit_comp.c

2516

struct bpf_prog *p = tlink->link.prog;

arch/sparc/net/bpf_jit_comp_32.c

108

*prog++ = SETHI(0, G0); \

arch/sparc/net/bpf_jit_comp_32.c

113

*prog++ = SUB | RS1(G0) | RS2(r_A) | RD(r_A); \

arch/sparc/net/bpf_jit_comp_32.c

118

*prog++ = OR | RS1(G0) | RS2(FROM) | RD(TO); \

arch/sparc/net/bpf_jit_comp_32.c

123

*prog++ = OR | RS1(G0) | RS2(G0) | RD(REG); \

arch/sparc/net/bpf_jit_comp_32.c

128

*prog++ = SETHI(K, REG); \

arch/sparc/net/bpf_jit_comp_32.c

130

*prog++ = OR_LO(K, REG); \

arch/sparc/net/bpf_jit_comp_32.c

140

*prog++ = OPCODE | RS1(r_A) | RS2(r_X) | RD(r_A); \

arch/sparc/net/bpf_jit_comp_32.c

163

*prog++ = _insn | IMMED | S13(K); \

arch/sparc/net/bpf_jit_comp_32.c

166

*prog++ = _insn | RS2(r_TMP); \

arch/sparc/net/bpf_jit_comp_32.c

175

*prog++ = OR | IMMED | RS1(G0) | S13(K) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

184

*prog++ = LDPTRI | RS1(BASE) | S13(_off) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

190

*prog++ = LD32I | RS1(BASE) | S13(_off) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

196

*prog++ = LD16I | RS1(BASE) | S13(_off) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

201

*prog++ = LD8I | RS1(BASE) | S13(_off) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

212

do { *prog++ = LD32I | RS1(SP) | S13(BIAS - (OFF)) | RD(DEST); \

arch/sparc/net/bpf_jit_comp_32.c

216

do { *prog++ = ST32I | RS1(SP) | S13(BIAS - (OFF)) | RD(SRC); \

arch/sparc/net/bpf_jit_comp_32.c

238

*prog++ = (JMPL | IMMED | RS1(BASE) | S13(IMM_OFF) | RD(LREG))

arch/sparc/net/bpf_jit_comp_32.c

243

*prog++ = CALL | (((_off) >> 2) & 0x3fffffff); \

arch/sparc/net/bpf_jit_comp_32.c

249

*prog++ = BR_OPC | WDISP22((DEST) - _here); \

arch/sparc/net/bpf_jit_comp_32.c

253

do { *prog++ = BR_OPC | WDISP22(OFF); \

arch/sparc/net/bpf_jit_comp_32.c

258

#define emit_read_y(REG) *prog++ = RD_Y | RD(REG)

arch/sparc/net/bpf_jit_comp_32.c

259

#define emit_write_y(REG) *prog++ = WR_Y | IMMED | RS1(REG) | S13(0)

arch/sparc/net/bpf_jit_comp_32.c

262

*prog++ = (SUBCC | RS1(R1) | RS2(R2) | RD(G0))

arch/sparc/net/bpf_jit_comp_32.c

265

*prog++ = (SUBCC | IMMED | RS1(R1) | S13(IMM) | RD(G0));

arch/sparc/net/bpf_jit_comp_32.c

268

*prog++ = (ANDCC | RS1(R1) | RS2(R2) | RD(G0))

arch/sparc/net/bpf_jit_comp_32.c

271

*prog++ = (ANDCC | IMMED | RS1(R1) | S13(IMM) | RD(G0));

arch/sparc/net/bpf_jit_comp_32.c

274

*prog++ = (SUB | RS1(R1) | RS2(R2) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

277

*prog++ = (SUB | IMMED | RS1(R1) | S13(IMM) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

280

*prog++ = (ADD | RS1(R1) | RS2(R2) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

283

*prog++ = (ADD | IMMED | RS1(R1) | S13(IMM) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

286

*prog++ = (AND | RS1(R1) | RS2(R2) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

289

*prog++ = (AND | IMMED | RS1(R1) | S13(IMM) | RD(R3))

arch/sparc/net/bpf_jit_comp_32.c

292

*prog++ = (SUB | IMMED | RS1(SP) | S13(SZ) | RD(SP))

arch/sparc/net/bpf_jit_comp_32.c

295

*prog++ = (ADD | IMMED | RS1(SP) | S13(SZ) | RD(SP))

arch/sparc/net/bpf_jit_comp_32.c

329

u32 temp[8], *prog, *func, seen = 0, pass;

arch/sparc/net/bpf_jit_comp_32.c

356

prog = temp;

arch/sparc/net/bpf_jit_comp_32.c

711

ilen = (void *) prog - (void *) temp;

arch/sparc/net/bpf_jit_comp_32.c

723

prog = temp;

arch/sparc/net/bpf_jit_comp_64.c

1010

if (!ctx->prog->aux->verifier_zext)

arch/sparc/net/bpf_jit_comp_64.c

1165

!ctx->prog->aux->verifier_zext)

arch/sparc/net/bpf_jit_comp_64.c

1236

if (i == ctx->prog->len - 1)

arch/sparc/net/bpf_jit_comp_64.c

1440

const struct bpf_prog *prog = ctx->prog;

arch/sparc/net/bpf_jit_comp_64.c

1443

for (i = 0; i < prog->len; i++) {

arch/sparc/net/bpf_jit_comp_64.c

1444

const struct bpf_insn *insn = &prog->insnsi[i];

arch/sparc/net/bpf_jit_comp_64.c

1480

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/sparc/net/bpf_jit_comp_64.c

1482

struct bpf_prog *tmp, *orig_prog = prog;

arch/sparc/net/bpf_jit_comp_64.c

1492

if (!prog->jit_requested)

arch/sparc/net/bpf_jit_comp_64.c

1495

tmp = bpf_jit_blind_constants(prog);

arch/sparc/net/bpf_jit_comp_64.c

1501

if (tmp != prog) {

arch/sparc/net/bpf_jit_comp_64.c

1503

prog = tmp;

arch/sparc/net/bpf_jit_comp_64.c

1506

jit_data = prog->aux->jit_data;

arch/sparc/net/bpf_jit_comp_64.c

1510

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1513

prog->aux->jit_data = jit_data;

arch/sparc/net/bpf_jit_comp_64.c

1527

ctx.prog = prog;

arch/sparc/net/bpf_jit_comp_64.c

1529

ctx.offset = kmalloc_array(prog->len, sizeof(unsigned int), GFP_KERNEL);

arch/sparc/net/bpf_jit_comp_64.c

1531

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1538

for (i = 0; i < prog->len; i++)

arch/sparc/net/bpf_jit_comp_64.c

1547

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1573

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1585

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1595

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1600

bpf_jit_dump(prog->len, image_size, pass, ctx.image);

arch/sparc/net/bpf_jit_comp_64.c

1604

if (!prog->is_func || extra_pass) {

arch/sparc/net/bpf_jit_comp_64.c

1607

prog = orig_prog;

arch/sparc/net/bpf_jit_comp_64.c

1616

prog->bpf_func = (void *)ctx.image;

arch/sparc/net/bpf_jit_comp_64.c

1617

prog->jited = 1;

arch/sparc/net/bpf_jit_comp_64.c

1618

prog->jited_len = image_size;

arch/sparc/net/bpf_jit_comp_64.c

1620

if (!prog->is_func || extra_pass) {

arch/sparc/net/bpf_jit_comp_64.c

1621

bpf_prog_fill_jited_linfo(prog, ctx.offset);

arch/sparc/net/bpf_jit_comp_64.c

1625

prog->aux->jit_data = NULL;

arch/sparc/net/bpf_jit_comp_64.c

1629

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/sparc/net/bpf_jit_comp_64.c

1631

return prog;

arch/sparc/net/bpf_jit_comp_64.c

190

struct bpf_prog *prog;

arch/sparc/net/bpf_jit_comp_64.c

802

struct bpf_prog *prog = ctx->prog;

arch/sparc/net/bpf_jit_comp_64.c

805

stack_depth = prog->aux->stack_depth;

arch/sparc/net/bpf_jit_comp_64.c

900

const int i = insn - ctx->prog->insnsi;

arch/um/drivers/vector_user.c

839

struct sock_fprog *prog = bpf;

arch/um/drivers/vector_user.c

844

printk(KERN_ERR BPF_ATTACH_FAIL, prog->len, prog->filter, fd, -errno);

arch/um/drivers/vector_user.c

850

struct sock_fprog *prog = bpf;

arch/um/drivers/vector_user.c

854

printk(KERN_ERR BPF_DETACH_FAIL, prog->len, prog->filter, fd, -errno);

arch/um/kernel/skas/stub_exe.c

195

struct sock_fprog prog = {

arch/um/kernel/skas/stub_exe.c

202

(unsigned long)&prog) != 0)

arch/um/os-Linux/start_up.c

263

static struct sock_fprog prog = {

arch/um/os-Linux/start_up.c

284

SECCOMP_FILTER_FLAG_TSYNC, &prog) != 0)

arch/x86/net/bpf_jit_comp.c

1021

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1027

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1041

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1046

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1053

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1061

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1067

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1075

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1081

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1087

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1110

emit_insn_suffix(&prog, src_reg, dst_reg, off);

arch/x86/net/bpf_jit_comp.c

1111

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1117

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1133

emit_insn_suffix(&prog, src_reg, dst_reg, off);

arch/x86/net/bpf_jit_comp.c

1134

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1139

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1159

emit_insn_suffix_SIB(&prog, src_reg, dst_reg, index_reg, off);

arch/x86/net/bpf_jit_comp.c

1160

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1165

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1181

emit_insn_suffix_SIB(&prog, src_reg, dst_reg, index_reg, off);

arch/x86/net/bpf_jit_comp.c

1182

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1190

static void emit_ldsx_r12(u8 **prog, u32 size, u32 dst_reg, u32 src_reg, int off)

arch/x86/net/bpf_jit_comp.c

1192

emit_ldsx_index(prog, size, dst_reg, src_reg, X86_REG_R12, off);

arch/x86/net/bpf_jit_comp.c

1198

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1225

emit_insn_suffix(&prog, dst_reg, src_reg, off);

arch/x86/net/bpf_jit_comp.c

1226

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1232

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1252

emit_insn_suffix_SIB(&prog, dst_reg, src_reg, index_reg, off);

arch/x86/net/bpf_jit_comp.c

1253

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1264

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1284

emit_insn_suffix_SIB(&prog, dst_reg, 0, index_reg, off);

arch/x86/net/bpf_jit_comp.c

1286

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1307

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1312

maybe_emit_mod(&prog, dst_reg, src_reg, bpf_size == BPF_DW);

arch/x86/net/bpf_jit_comp.c

1340

emit_insn_suffix(&prog, dst_reg, src_reg, off);

arch/x86/net/bpf_jit_comp.c

1342

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1350

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1392

emit_insn_suffix_SIB(&prog, dst_reg, src_reg, index_reg, off);

arch/x86/net/bpf_jit_comp.c

1393

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1535

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1565

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1571

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1575

emit_3vex(&prog, r, false, r, m, is64, src_reg, false, op);

arch/x86/net/bpf_jit_comp.c

1577

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1582

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1585

emit_mov_imm64(&prog, X86_REG_R9, (__force long) priv_frame_ptr >> 32,

arch/x86/net/bpf_jit_comp.c

1595

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1598

#define INSN_SZ_DIFF (((addrs[i] - addrs[i - 1]) - (prog - temp)))

arch/x86/net/bpf_jit_comp.c

1613

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1623

ip += x86_call_depth_emit_accounting(&prog, func, ip);

arch/x86/net/bpf_jit_comp.c

1625

if (emit_call(&prog, func, ip))

arch/x86/net/bpf_jit_comp.c

1648

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1666

u8 *prog = temp;

arch/x86/net/bpf_jit_comp.c

1682

emit_prologue(&prog, image, stack_depth,

arch/x86/net/bpf_jit_comp.c

1686

bpf_prog->aux->ksym.fp_start = prog - temp;

arch/x86/net/bpf_jit_comp.c

1696

push_r12(&prog);

arch/x86/net/bpf_jit_comp.c

1697

push_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

1700

push_r12(&prog);

arch/x86/net/bpf_jit_comp.c

1701

push_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

1704

emit_mov_imm64(&prog, X86_REG_R12,

arch/x86/net/bpf_jit_comp.c

1708

emit_priv_frame_ptr(&prog, priv_frame_ptr);

arch/x86/net/bpf_jit_comp.c

1710

ilen = prog - temp;

arch/x86/net/bpf_jit_comp.c

1715

prog = temp;

arch/x86/net/bpf_jit_comp.c

1749

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

1759

emit_mov_reg(&prog, false, dst_reg, src_reg);

arch/x86/net/bpf_jit_comp.c

1761

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1765

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1772

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1779

maybe_emit_mod(&prog, dst_reg, dst_reg, false);

arch/x86/net/bpf_jit_comp.c

1784

maybe_emit_mod(&prog, AUX_REG, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1801

emit_mov_reg(&prog,

arch/x86/net/bpf_jit_comp.c

1805

emit_movsx_reg(&prog, insn->off,

arch/x86/net/bpf_jit_comp.c

1813

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

1828

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

1868

emit_mov_imm32(&prog, BPF_CLASS(insn->code) == BPF_ALU64,

arch/x86/net/bpf_jit_comp.c

1873

emit_mov_imm64(&prog, dst_reg, insn[1].imm, insn[0].imm);

arch/x86/net/bpf_jit_comp.c

1909

emit_mov_reg(&prog, is64, BPF_REG_0, dst_reg);

arch/x86/net/bpf_jit_comp.c

1919

maybe_emit_1mod(&prog, src_reg, is64);

arch/x86/net/bpf_jit_comp.c

1928

maybe_emit_1mod(&prog, src_reg, is64);

arch/x86/net/bpf_jit_comp.c

1935

emit_mov_reg(&prog, is64, dst_reg, BPF_REG_3);

arch/x86/net/bpf_jit_comp.c

1939

emit_mov_reg(&prog, is64, dst_reg, BPF_REG_0);

arch/x86/net/bpf_jit_comp.c

1950

maybe_emit_mod(&prog, dst_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

1966

maybe_emit_mod(&prog, src_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

1980

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2014

emit_shiftx(&prog, dst_reg, src_reg, w, op);

arch/x86/net/bpf_jit_comp.c

2033

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2147

emit_stx(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);

arch/x86/net/bpf_jit_comp.c

2154

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2155

emit_st_r12(&prog, BPF_SIZE(insn->code), dst_reg, insn->off, insn->imm);

arch/x86/net/bpf_jit_comp.c

2170

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2173

emit_ldsx_r12(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);

arch/x86/net/bpf_jit_comp.c

2175

emit_ldx_r12(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);

arch/x86/net/bpf_jit_comp.c

2177

emit_stx_r12(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn->off);

arch/x86/net/bpf_jit_comp.c

2220

ex->fixup = FIELD_PREP(FIXUP_INSN_LEN_MASK, prog - start_of_ldx) |

arch/x86/net/bpf_jit_comp.c

2259

emit_mov_imm64(&prog, BPF_REG_AX, (long)VSYSCALL_ADDR >> 32,

arch/x86/net/bpf_jit_comp.c

2267

maybe_emit_1mod(&prog, AUX_REG, true);

arch/x86/net/bpf_jit_comp.c

2272

maybe_emit_mod(&prog, AUX_REG, BPF_REG_AX, true);

arch/x86/net/bpf_jit_comp.c

2276

emit_mov_imm64(&prog, BPF_REG_AX, (long)limit >> 32,

arch/x86/net/bpf_jit_comp.c

2280

maybe_emit_mod(&prog, AUX_REG, BPF_REG_AX, true);

arch/x86/net/bpf_jit_comp.c

2285

end_of_jmp = prog;

arch/x86/net/bpf_jit_comp.c

2288

emit_mov_imm32(&prog, false, dst_reg, 0);

arch/x86/net/bpf_jit_comp.c

2293

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2298

emit_ldsx(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn_off);

arch/x86/net/bpf_jit_comp.c

2300

emit_ldx(&prog, BPF_SIZE(insn->code), dst_reg, src_reg, insn_off);

arch/x86/net/bpf_jit_comp.c

2308

start_of_ldx[-1] = prog - start_of_ldx;

arch/x86/net/bpf_jit_comp.c

2343

ex->fixup = FIELD_PREP(FIXUP_INSN_LEN_MASK, prog - start_of_ldx) |

arch/x86/net/bpf_jit_comp.c

2371

emit_mov_reg(&prog, true, BPF_REG_AX, BPF_REG_0);

arch/x86/net/bpf_jit_comp.c

2377

branch_target = prog;

arch/x86/net/bpf_jit_comp.c

2379

emit_ldx(&prog, BPF_SIZE(insn->code),

arch/x86/net/bpf_jit_comp.c

2385

emit_mov_reg(&prog, is64, AUX_REG, BPF_REG_0);

arch/x86/net/bpf_jit_comp.c

2386

maybe_emit_mod(&prog, AUX_REG, real_src_reg, is64);

arch/x86/net/bpf_jit_comp.c

2390

err = emit_atomic_rmw(&prog, BPF_CMPXCHG,

arch/x86/net/bpf_jit_comp.c

2400

EMIT2(X86_JNE, -(prog - branch_target) - 2);

arch/x86/net/bpf_jit_comp.c

2402

emit_mov_reg(&prog, is64, real_src_reg, BPF_REG_0);

arch/x86/net/bpf_jit_comp.c

2404

emit_mov_reg(&prog, true, BPF_REG_0, BPF_REG_AX);

arch/x86/net/bpf_jit_comp.c

2409

err = emit_atomic_ld_st(&prog, insn->imm, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2412

err = emit_atomic_rmw(&prog, insn->imm, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2427

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2430

err = emit_atomic_ld_st_index(&prog, insn->imm,

arch/x86/net/bpf_jit_comp.c

2434

err = emit_atomic_rmw_index(&prog, insn->imm, BPF_SIZE(insn->code),

arch/x86/net/bpf_jit_comp.c

2453

push_r9(&prog);

arch/x86/net/bpf_jit_comp.c

2456

ip += x86_call_depth_emit_accounting(&prog, func, ip);

arch/x86/net/bpf_jit_comp.c

2457

if (emit_call(&prog, func, ip))

arch/x86/net/bpf_jit_comp.c

2460

pop_r9(&prog);

arch/x86/net/bpf_jit_comp.c

2468

&prog, image + addrs[i - 1],

arch/x86/net/bpf_jit_comp.c

2474

&prog,

arch/x86/net/bpf_jit_comp.c

2503

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2511

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2519

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2546

maybe_emit_mod(&prog, dst_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

2553

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2629

emit_nops(&prog, nops);

arch/x86/net/bpf_jit_comp.c

2642

emit_indirect_jump(&prog, insn->dst_reg, image + addrs[i - 1]);

arch/x86/net/bpf_jit_comp.c

2686

emit_nops(&prog, nops);

arch/x86/net/bpf_jit_comp.c

2711

emit_nops(&prog, INSN_SZ_DIFF - 2);

arch/x86/net/bpf_jit_comp.c

2734

if (emit_spectre_bhb_barrier(&prog, ip, bpf_prog))

arch/x86/net/bpf_jit_comp.c

2738

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

2739

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

2741

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

2743

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

2746

bpf_prog->aux->ksym.fp_end = prog - temp;

arch/x86/net/bpf_jit_comp.c

2748

emit_return(&prog, image + addrs[i - 1] + (prog - temp));

arch/x86/net/bpf_jit_comp.c

2762

ilen = prog - temp;

arch/x86/net/bpf_jit_comp.c

2786

prog = temp;

arch/x86/net/bpf_jit_comp.c

2801

u8 *prog;

arch/x86/net/bpf_jit_comp.c

2833

prog = *pprog;

arch/x86/net/bpf_jit_comp.c

2840

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

2861

static void save_args(const struct btf_func_model *m, u8 **prog,

arch/x86/net/bpf_jit_comp.c

2905

emit_ldx(prog, BPF_DW, BPF_REG_0, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

2907

emit_stx(prog, BPF_DW, BPF_REG_FP, BPF_REG_0,

arch/x86/net/bpf_jit_comp.c

2927

emit_stx(prog, BPF_DW, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

2936

clean_stack_garbage(m, prog, nr_stack_slots, first_off);

arch/x86/net/bpf_jit_comp.c

2939

static void restore_regs(const struct btf_func_model *m, u8 **prog,

arch/x86/net/bpf_jit_comp.c

2955

emit_ldx(prog, BPF_DW,

arch/x86/net/bpf_jit_comp.c

2976

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

2979

struct bpf_prog *p = l->link.prog;

arch/x86/net/bpf_jit_comp.c

2983

emit_mov_imm64(&prog, BPF_REG_1, (long) cookie >> 32, (u32) (long) cookie);

arch/x86/net/bpf_jit_comp.c

2992

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_1, -run_ctx_off + ctx_cookie_off);

arch/x86/net/bpf_jit_comp.c

2995

emit_mov_imm64(&prog, BPF_REG_1, (long) p >> 32, (u32) (long) p);

arch/x86/net/bpf_jit_comp.c

3002

if (emit_rsb_call(&prog, bpf_trampoline_enter(p), image + (prog - (u8 *)rw_image)))

arch/x86/net/bpf_jit_comp.c

3005

emit_mov_reg(&prog, true, BPF_REG_6, BPF_REG_0);

arch/x86/net/bpf_jit_comp.c

3012

jmp_insn = prog;

arch/x86/net/bpf_jit_comp.c

3013

emit_nops(&prog, 2);

arch/x86/net/bpf_jit_comp.c

3022

emit_mov_imm64(&prog, BPF_REG_2,

arch/x86/net/bpf_jit_comp.c

3026

if (emit_rsb_call(&prog, p->bpf_func, image + (prog - (u8 *)rw_image)))

arch/x86/net/bpf_jit_comp.c

3038

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3042

jmp_insn[1] = prog - jmp_insn - 2;

arch/x86/net/bpf_jit_comp.c

3045

emit_mov_imm64(&prog, BPF_REG_1, (long) p >> 32, (u32) (long) p);

arch/x86/net/bpf_jit_comp.c

3047

emit_mov_reg(&prog, true, BPF_REG_2, BPF_REG_6);

arch/x86/net/bpf_jit_comp.c

3053

if (emit_rsb_call(&prog, bpf_trampoline_exit(p), image + (prog - (u8 *)rw_image)))

arch/x86/net/bpf_jit_comp.c

3056

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3062

u8 *target, *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3064

target = PTR_ALIGN(prog, align);

arch/x86/net/bpf_jit_comp.c

3065

if (target != prog)

arch/x86/net/bpf_jit_comp.c

3066

emit_nops(&prog, target - prog);

arch/x86/net/bpf_jit_comp.c

3068

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3073

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3082

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3093

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3096

if (tl->links[i]->link.prog->call_session_cookie) {

arch/x86/net/bpf_jit_comp.c

3097

emit_store_stack_imm64(&prog, BPF_REG_0, -func_meta_off,

arch/x86/net/bpf_jit_comp.c

3101

if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size,

arch/x86/net/bpf_jit_comp.c

3105

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3114

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3120

emit_mov_imm32(&prog, false, BPF_REG_0, 0);

arch/x86/net/bpf_jit_comp.c

3121

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3123

if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size, run_ctx_off, true,

arch/x86/net/bpf_jit_comp.c

3139

branches[i] = prog;

arch/x86/net/bpf_jit_comp.c

3140

emit_nops(&prog, 4 + 2);

arch/x86/net/bpf_jit_comp.c

3143

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3226

u8 *prog;

arch/x86/net/bpf_jit_comp.c

333

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3332

prog = rw_image;

arch/x86/net/bpf_jit_comp.c

3338

emit_cfi(&prog, image,

arch/x86/net/bpf_jit_comp.c

3346

x86_call_depth_emit_accounting(&prog, NULL, image);

arch/x86/net/bpf_jit_comp.c

3351

im->ksym.fp_start = prog - (u8 *)rw_image;

arch/x86/net/bpf_jit_comp.c

336

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3363

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_6, -rbx_off);

arch/x86/net/bpf_jit_comp.c

3367

emit_store_stack_imm64(&prog, BPF_REG_0, -func_meta_off, func_meta);

arch/x86/net/bpf_jit_comp.c

3371

emit_store_stack_imm64(&prog, BPF_REG_0, -ip_off, (long)func_addr);

arch/x86/net/bpf_jit_comp.c

3374

save_args(m, &prog, regs_off, false, flags);

arch/x86/net/bpf_jit_comp.c

3378

emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);

arch/x86/net/bpf_jit_comp.c

3379

if (emit_rsb_call(&prog, __bpf_tramp_enter,

arch/x86/net/bpf_jit_comp.c

3380

image + (prog - (u8 *)rw_image))) {

arch/x86/net/bpf_jit_comp.c

3389

emit_store_stack_imm64(&prog, BPF_REG_0, -cookie_off + 8 * i, 0);

arch/x86/net/bpf_jit_comp.c

3391

emit_store_stack_imm64(&prog, BPF_REG_0, -8, 0);

arch/x86/net/bpf_jit_comp.c

3395

if (invoke_bpf(m, &prog, fentry, regs_off, run_ctx_off, func_meta_off,

arch/x86/net/bpf_jit_comp.c

3407

if (invoke_bpf_mod_ret(m, &prog, fmod_ret, regs_off,

arch/x86/net/bpf_jit_comp.c

341

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3415

restore_regs(m, &prog, regs_off);

arch/x86/net/bpf_jit_comp.c

3416

save_args(m, &prog, arg_stack_off, true, flags);

arch/x86/net/bpf_jit_comp.c

3426

emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, 8);

arch/x86/net/bpf_jit_comp.c

3430

if (emit_rsb_call(&prog, orig_call, image + (prog - (u8 *)rw_image))) {

arch/x86/net/bpf_jit_comp.c

3436

emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8);

arch/x86/net/bpf_jit_comp.c

3437

im->ip_after_call = image + (prog - (u8 *)rw_image);

arch/x86/net/bpf_jit_comp.c

3438

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

344

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3447

emit_align(&prog, 16);

arch/x86/net/bpf_jit_comp.c

3452

emit_cond_near_jump(&branches[i], image + (prog - (u8 *)rw_image),

arch/x86/net/bpf_jit_comp.c

3460

emit_store_stack_imm64(&prog, BPF_REG_0, -func_meta_off, func_meta);

arch/x86/net/bpf_jit_comp.c

3463

if (invoke_bpf(m, &prog, fexit, regs_off, run_ctx_off, func_meta_off,

arch/x86/net/bpf_jit_comp.c

3471

restore_regs(m, &prog, regs_off);

arch/x86/net/bpf_jit_comp.c

3478

im->ip_epilogue = image + (prog - (u8 *)rw_image);

arch/x86/net/bpf_jit_comp.c

3480

emit_mov_imm64(&prog, BPF_REG_1, (long) im >> 32, (u32) (long) im);

arch/x86/net/bpf_jit_comp.c

3481

if (emit_rsb_call(&prog, __bpf_tramp_exit, image + (prog - (u8 *)rw_image))) {

arch/x86/net/bpf_jit_comp.c

349

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3494

emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8);

arch/x86/net/bpf_jit_comp.c

3496

emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, -rbx_off);

arch/x86/net/bpf_jit_comp.c

3500

im->ksym.fp_end = prog - (u8 *)rw_image;

arch/x86/net/bpf_jit_comp.c

3506

emit_return(&prog, image + (prog - (u8 *)rw_image));

arch/x86/net/bpf_jit_comp.c

3508

if (WARN_ON_ONCE(prog > (u8 *)rw_image_end - BPF_INSN_SAFETY)) {

arch/x86/net/bpf_jit_comp.c

3512

ret = prog - (u8 *)rw_image + BPF_INSN_SAFETY;

arch/x86/net/bpf_jit_comp.c

352

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

357

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3589

u8 *jg_reloc, *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3602

err = emit_cond_near_jump(&prog, /* je func */

arch/x86/net/bpf_jit_comp.c

3603

(void *)progs[a], image + (prog - buf),

arch/x86/net/bpf_jit_comp.c

3608

emit_indirect_jump(&prog, BPF_REG_3 /* R3 -> rdx */, image + (prog - buf));

arch/x86/net/bpf_jit_comp.c

3610

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3630

jg_reloc = prog;

arch/x86/net/bpf_jit_comp.c

3632

err = emit_bpf_dispatcher(&prog, a, a + pivot, /* emit lower_part */

arch/x86/net/bpf_jit_comp.c

3642

emit_align(&prog, 16);

arch/x86/net/bpf_jit_comp.c

3643

jg_offset = prog - jg_reloc;

arch/x86/net/bpf_jit_comp.c

3646

err = emit_bpf_dispatcher(&prog, a + pivot + 1, /* emit upper_part */

arch/x86/net/bpf_jit_comp.c

3651

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3669

u8 *prog = buf;

arch/x86/net/bpf_jit_comp.c

367

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3672

return emit_bpf_dispatcher(&prog, 0, num_funcs - 1, funcs, image, buf);

arch/x86/net/bpf_jit_comp.c

3688

struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

3698

bpf_jit_get_prog_name(prog));

arch/x86/net/bpf_jit_comp.c

3716

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

372

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3720

struct bpf_prog *tmp, *orig_prog = prog;

arch/x86/net/bpf_jit_comp.c

3735

if (!prog->jit_requested)

arch/x86/net/bpf_jit_comp.c

3738

tmp = bpf_jit_blind_constants(prog);

arch/x86/net/bpf_jit_comp.c

3745

if (tmp != prog) {

arch/x86/net/bpf_jit_comp.c

3747

prog = tmp;

arch/x86/net/bpf_jit_comp.c

375

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3750

jit_data = prog->aux->jit_data;

arch/x86/net/bpf_jit_comp.c

3754

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3757

prog->aux->jit_data = jit_data;

arch/x86/net/bpf_jit_comp.c

3759

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

3760

if (!priv_stack_ptr && prog->aux->jits_use_priv_stack) {

arch/x86/net/bpf_jit_comp.c

3765

priv_stack_alloc_sz = round_up(prog->aux->stack_depth, 8) +

arch/x86/net/bpf_jit_comp.c

3769

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3774

prog->aux->priv_stack_ptr = priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

3788

addrs = kvmalloc_objs(*addrs, prog->len + 1);

arch/x86/net/bpf_jit_comp.c

3790

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3798

for (proglen = 0, i = 0; i <= prog->len; i++) {

arch/x86/net/bpf_jit_comp.c

380

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3814

proglen = do_jit(prog, addrs, image, rw_image, oldproglen, &ctx, padding);

arch/x86/net/bpf_jit_comp.c

3824

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3826

prog->bpf_func = NULL;

arch/x86/net/bpf_jit_comp.c

3827

prog->jited = 0;

arch/x86/net/bpf_jit_comp.c

3828

prog->jited_len = 0;

arch/x86/net/bpf_jit_comp.c

3848

u32 extable_size = prog->aux->num_exentries *

arch/x86/net/bpf_jit_comp.c

3856

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3859

prog->aux->extable = (void *) image + roundup(proglen, align);

arch/x86/net/bpf_jit_comp.c

3866

bpf_jit_dump(prog->len, proglen, pass + 1, rw_image);

arch/x86/net/bpf_jit_comp.c

3869

if (!prog->is_func || extra_pass) {

arch/x86/net/bpf_jit_comp.c

3883

bpf_tail_call_direct_fixup(prog);

arch/x86/net/bpf_jit_comp.c

3899

bpf_prog_update_insn_ptrs(prog, addrs, image);

arch/x86/net/bpf_jit_comp.c

39

do { prog = emit_code(prog, bytes, len); } while (0)

arch/x86/net/bpf_jit_comp.c

390

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3908

prog->bpf_func = (void *)image + cfi_get_offset();

arch/x86/net/bpf_jit_comp.c

3909

prog->jited = 1;

arch/x86/net/bpf_jit_comp.c

3910

prog->jited_len = proglen - cfi_get_offset();

arch/x86/net/bpf_jit_comp.c

3912

prog = orig_prog;

arch/x86/net/bpf_jit_comp.c

3915

if (!image || !prog->is_func || extra_pass) {

arch/x86/net/bpf_jit_comp.c

3917

bpf_prog_fill_jited_linfo(prog, addrs + 1);

arch/x86/net/bpf_jit_comp.c

3922

prog->aux->priv_stack_ptr = NULL;

arch/x86/net/bpf_jit_comp.c

3926

prog->aux->jit_data = NULL;

arch/x86/net/bpf_jit_comp.c

3930

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/x86/net/bpf_jit_comp.c

3932

return prog;

arch/x86/net/bpf_jit_comp.c

395

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3958

void bpf_jit_free(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

3960

if (prog->jited) {

arch/x86/net/bpf_jit_comp.c

3961

struct x64_jit_data *jit_data = prog->aux->jit_data;

arch/x86/net/bpf_jit_comp.c

3977

prog->bpf_func = (void *)prog->bpf_func - cfi_get_offset();

arch/x86/net/bpf_jit_comp.c

3978

hdr = bpf_jit_binary_pack_hdr(prog);

arch/x86/net/bpf_jit_comp.c

3980

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

3982

priv_stack_alloc_sz = round_up(prog->aux->stack_depth, 8) +

arch/x86/net/bpf_jit_comp.c

3984

priv_stack_check_guard(priv_stack_ptr, priv_stack_alloc_sz, prog);

arch/x86/net/bpf_jit_comp.c

3985

free_percpu(prog->aux->priv_stack_ptr);

arch/x86/net/bpf_jit_comp.c

3987

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/x86/net/bpf_jit_comp.c

3990

bpf_prog_unlock_free(prog);

arch/x86/net/bpf_jit_comp.c

409

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

416

static int emit_call(u8 **prog, void *func, void *ip);

arch/x86/net/bpf_jit_comp.c

420

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

426

emit_call(&prog, __bhi_args[arity], ip + 11);

arch/x86/net/bpf_jit_comp.c

432

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

437

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

446

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

451

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

455

emit_fineibt(&prog, ip, hash, arity);

arch/x86/net/bpf_jit_comp.c

459

emit_kcfi(&prog, hash);

arch/x86/net/bpf_jit_comp.c

467

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

472

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

498

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

510

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

513

emit_cfi(&prog, ip, cfi_bpf_subprog_hash, 5);

arch/x86/net/bpf_jit_comp.c

515

emit_cfi(&prog, ip, cfi_bpf_hash, 1);

arch/x86/net/bpf_jit_comp.c

520

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

529

emit_nops(&prog, 3); /* nop3 */

arch/x86/net/bpf_jit_comp.c

539

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

540

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

555

emit_prologue_tail_call(&prog, is_subprog);

arch/x86/net/bpf_jit_comp.c

556

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

561

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

570

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

598

u8 *prog;

arch/x86/net/bpf_jit_comp.c

603

prog = old_insn;

arch/x86/net/bpf_jit_comp.c

605

emit_call(&prog, old_addr, ip) :

arch/x86/net/bpf_jit_comp.c

606

emit_jump(&prog, old_addr, ip);

arch/x86/net/bpf_jit_comp.c

613

prog = new_insn;

arch/x86/net/bpf_jit_comp.c

615

emit_call(&prog, new_addr, ip) :

arch/x86/net/bpf_jit_comp.c

616

emit_jump(&prog, new_addr, ip);

arch/x86/net/bpf_jit_comp.c

658

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

665

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

670

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

676

emit_jump(&prog, its_static_thunk(reg + 8*ereg), ip);

arch/x86/net/bpf_jit_comp.c

679

__emit_indirect_jump(&prog, reg, ereg);

arch/x86/net/bpf_jit_comp.c

683

emit_jump(&prog, &__x86_indirect_jump_thunk_array[reg + 8*ereg], ip);

arch/x86/net/bpf_jit_comp.c

685

emit_jump(&prog, &__x86_indirect_thunk_array[reg + 8*ereg], ip);

arch/x86/net/bpf_jit_comp.c

687

__emit_indirect_jump(&prog, reg, ereg);

arch/x86/net/bpf_jit_comp.c

692

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

697

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

700

emit_jump(&prog, x86_return_thunk, ip);

arch/x86/net/bpf_jit_comp.c

707

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

732

u8 *prog = *pprog, *start = *pprog;

arch/x86/net/bpf_jit_comp.c

749

offset = ctx->tail_call_indirect_label - (prog + 2 - start);

arch/x86/net/bpf_jit_comp.c

759

offset = ctx->tail_call_indirect_label - (prog + 2 - start);

arch/x86/net/bpf_jit_comp.c

772

offset = ctx->tail_call_indirect_label - (prog + 2 - start);

arch/x86/net/bpf_jit_comp.c

779

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

780

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

782

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

784

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

807

emit_indirect_jump(&prog, BPF_REG_4 /* R4 -> rcx */, ip + (prog - start));

arch/x86/net/bpf_jit_comp.c

810

ctx->tail_call_indirect_label = prog - start;

arch/x86/net/bpf_jit_comp.c

811

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

821

u8 *prog = *pprog, *start = *pprog;

arch/x86/net/bpf_jit_comp.c

831

offset = ctx->tail_call_direct_label - (prog + 2 - start);

arch/x86/net/bpf_jit_comp.c

834

poke->tailcall_bypass = ip + (prog - start);

arch/x86/net/bpf_jit_comp.c

839

emit_jump(&prog, (u8 *)poke->tailcall_target + X86_PATCH_SIZE,

arch/x86/net/bpf_jit_comp.c

846

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

847

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

849

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

851

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

863

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

866

ctx->tail_call_direct_label = prog - start;

arch/x86/net/bpf_jit_comp.c

868

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

871

static void bpf_tail_call_direct_fixup(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

878

for (i = 0; i < prog->aux->size_poke_tab; i++) {

arch/x86/net/bpf_jit_comp.c

879

poke = &prog->aux->poke_tab[i];

arch/x86/net/bpf_jit_comp.c

880

if (poke->aux && poke->aux != prog->aux)

arch/x86/net/bpf_jit_comp.c

912

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

946

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

953

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

962

emit_mov_imm32(&prog, false, dst_reg, imm32_lo);

arch/x86/net/bpf_jit_comp.c

964

emit_mov_imm32(&prog, true, dst_reg, imm32_lo);

arch/x86/net/bpf_jit_comp.c

972

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

977

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

989

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

995

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1032

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1038

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1109

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1115

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1169

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1202

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1241

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1247

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1268

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1273

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1281

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1301

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1381

cnt += emit_jmp_edx(&prog, ip + cnt);

arch/x86/net/bpf_jit_comp32.c

1387

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1393

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1406

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1411

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1419

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1578

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

1600

emit_push_r64(bpf2ia32[i], &prog);

arch/x86/net/bpf_jit_comp32.c

1603

emit_push_r32(bpf2ia32[i], &prog);

arch/x86/net/bpf_jit_comp32.c

1654

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

1668

u8 *prog = temp;

arch/x86/net/bpf_jit_comp32.c

1670

emit_prologue(&prog, bpf_prog->aux->stack_depth);

arch/x86/net/bpf_jit_comp32.c

1697

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1701

&prog, bpf_prog->aux);

arch/x86/net/bpf_jit_comp32.c

1706

dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1741

src, dstk, sstk, &prog,

arch/x86/net/bpf_jit_comp32.c

1746

imm32, dstk, &prog,

arch/x86/net/bpf_jit_comp32.c

1756

sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1763

false, &prog);

arch/x86/net/bpf_jit_comp32.c

1767

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1776

dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1784

&prog);

arch/x86/net/bpf_jit_comp32.c

1788

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1799

src_lo, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1807

&prog);

arch/x86/net/bpf_jit_comp32.c

1811

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1827

false, &prog);

arch/x86/net/bpf_jit_comp32.c

1829

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1835

emit_ia32_lsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1841

emit_ia32_rsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1845

emit_ia32_lsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1849

emit_ia32_rsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1853

emit_ia32_arsh_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1859

emit_ia32_arsh_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1864

dst_lo, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1866

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1870

emit_ia32_neg64(dst, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1877

emit_ia32_mul_r64(dst, src, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1880

emit_ia32_mul_i64(dst, imm32, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1886

emit_ia32_to_le_r64(dst, imm32, dstk, &prog,

arch/x86/net/bpf_jit_comp32.c

1891

emit_ia32_to_be_r64(dst, imm32, dstk, &prog,

arch/x86/net/bpf_jit_comp32.c

1899

emit_ia32_mov_i(dst_lo, lo, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

1900

emit_ia32_mov_i(dst_hi, hi, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

209

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

2099

insn, &prog);

arch/x86/net/bpf_jit_comp32.c

2122

emit_push_r64(r5, &prog);

arch/x86/net/bpf_jit_comp32.c

2123

emit_push_r64(r4, &prog);

arch/x86/net/bpf_jit_comp32.c

2124

emit_push_r64(r3, &prog);

arch/x86/net/bpf_jit_comp32.c

2125

emit_push_r64(r2, &prog);

arch/x86/net/bpf_jit_comp32.c

2141

emit_bpf_tail_call(&prog, image + addrs[i - 1]);

arch/x86/net/bpf_jit_comp32.c

230

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

237

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

2472

emit_epilogue(&prog, bpf_prog->aux->stack_depth);

arch/x86/net/bpf_jit_comp32.c

2487

ilen = prog - temp;

arch/x86/net/bpf_jit_comp32.c

251

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

2511

prog = temp;

arch/x86/net/bpf_jit_comp32.c

2521

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp32.c

2524

struct bpf_prog *tmp, *orig_prog = prog;

arch/x86/net/bpf_jit_comp32.c

2533

if (!prog->jit_requested)

arch/x86/net/bpf_jit_comp32.c

2536

tmp = bpf_jit_blind_constants(prog);

arch/x86/net/bpf_jit_comp32.c

2543

if (tmp != prog) {

arch/x86/net/bpf_jit_comp32.c

2545

prog = tmp;

arch/x86/net/bpf_jit_comp32.c

2548

addrs = kmalloc_objs(*addrs, prog->len);

arch/x86/net/bpf_jit_comp32.c

2550

prog = orig_prog;

arch/x86/net/bpf_jit_comp32.c

2558

for (proglen = 0, i = 0; i < prog->len; i++) {

arch/x86/net/bpf_jit_comp32.c

2571

proglen = do_jit(prog, addrs, image, oldproglen, &ctx);

arch/x86/net/bpf_jit_comp32.c

2577

prog = orig_prog;

arch/x86/net/bpf_jit_comp32.c

2592

prog = orig_prog;

arch/x86/net/bpf_jit_comp32.c

2601

bpf_jit_dump(prog->len, proglen, pass + 1, image);

arch/x86/net/bpf_jit_comp32.c

2604

prog->bpf_func = (void *)image;

arch/x86/net/bpf_jit_comp32.c

2605

prog->jited = 1;

arch/x86/net/bpf_jit_comp32.c

2606

prog->jited_len = proglen;

arch/x86/net/bpf_jit_comp32.c

2608

prog = orig_prog;

arch/x86/net/bpf_jit_comp32.c

2615

bpf_jit_prog_release_other(prog, prog == orig_prog ?

arch/x86/net/bpf_jit_comp32.c

2617

return prog;

arch/x86/net/bpf_jit_comp32.c

288

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

314

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

321

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

362

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

369

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

428

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

438

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

475

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

485

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

516

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

527

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

573

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

582

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

584

emit_ia32_alu_r(is64, false, op, dst_lo, src_lo, dstk, sstk, &prog);

arch/x86/net/bpf_jit_comp32.c

587

&prog);

arch/x86/net/bpf_jit_comp32.c

589

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

590

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

601

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

65

do { prog = emit_code(prog, bytes, len); cnt += len; } while (0)

arch/x86/net/bpf_jit_comp32.c

673

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

682

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

688

emit_ia32_alu_i(is64, false, op, dst_lo, val, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

690

emit_ia32_alu_i(is64, true, op, dst_hi, hi, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

692

emit_ia32_mov_i(dst_hi, 0, dstk, &prog);

arch/x86/net/bpf_jit_comp32.c

694

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

700

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

727

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

734

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

780

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

787

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

833

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

840

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

886

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

893

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

934

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

941

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp32.c

983

*pprog = prog;

arch/x86/net/bpf_jit_comp32.c

990

u8 *prog = *pprog;

arch/x86/tools/insn_decoder_test.c

171

" instructions\n", prog, insns);

arch/x86/tools/insn_decoder_test.c

27

const char *prog;

arch/x86/tools/insn_decoder_test.c

34

" | %s [-y|-n] [-v]\n", prog);

arch/x86/tools/insn_decoder_test.c

44

prog, line_nr, line);

arch/x86/tools/insn_decoder_test.c

52

fprintf(stderr, "%s: warning: ", prog);

arch/x86/tools/insn_decoder_test.c

90

prog = argv[0];

arch/x86/tools/insn_sanity.c

101

fprintf(fp, " $ %s -s 0x%x,%lu\n", prog, seed, nr_iter);

arch/x86/tools/insn_sanity.c

164

prog = argv[0];

arch/x86/tools/insn_sanity.c

257

prog,

arch/x86/tools/insn_sanity.c

30

static const char *prog; /* Program name */

arch/x86/tools/insn_sanity.c

41

fprintf(stderr, "%s: Error: %s\n\n", prog, err);

arch/x86/tools/insn_sanity.c

42

fprintf(stderr, "Usage: %s [-y|-n|-v] [-s seed[,no]] [-m max] [-i input]\n", prog);

arch/x86/tools/insn_sanity.c

96

fprintf(fp, " | %s -i -\n", prog);

drivers/base/firmware_loader/sysfs_upload.c

34

enum fw_upload_prog prog)

drivers/base/firmware_loader/sysfs_upload.c

38

if (prog < FW_UPLOAD_PROG_MAX)

drivers/base/firmware_loader/sysfs_upload.c

39

status = fw_upload_prog_str[prog];

drivers/base/firmware_loader/sysfs_upload.c

41

dev_err(dev, "Invalid status during secure update: %d\n", prog);

drivers/clk/at91/clk-programmable.c

105

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

106

const struct clk_programmable_layout *layout = prog->layout;

drivers/clk/at91/clk-programmable.c

113

if (prog->mux_table)

drivers/clk/at91/clk-programmable.c

114

pckr = clk_mux_index_to_val(prog->mux_table, 0, index);

drivers/clk/at91/clk-programmable.c

123

regmap_update_bits(prog->regmap, AT91_PMC_PCKR(prog->id), mask, pckr);

drivers/clk/at91/clk-programmable.c

130

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

131

const struct clk_programmable_layout *layout = prog->layout;

drivers/clk/at91/clk-programmable.c

135

regmap_read(prog->regmap, AT91_PMC_PCKR(prog->id), &pckr);

drivers/clk/at91/clk-programmable.c

142

if (prog->mux_table)

drivers/clk/at91/clk-programmable.c

143

ret = clk_mux_val_to_index(&prog->hw, prog->mux_table, 0, ret);

drivers/clk/at91/clk-programmable.c

151

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

152

const struct clk_programmable_layout *layout = prog->layout;

drivers/clk/at91/clk-programmable.c

174

regmap_update_bits(prog->regmap, AT91_PMC_PCKR(prog->id),

drivers/clk/at91/clk-programmable.c

183

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

186

prog->pms.parent = clk_programmable_get_parent(hw);

drivers/clk/at91/clk-programmable.c

187

prog->pms.parent_rate = clk_hw_get_rate(parent_hw);

drivers/clk/at91/clk-programmable.c

188

prog->pms.rate = clk_programmable_recalc_rate(hw, prog->pms.parent_rate);

drivers/clk/at91/clk-programmable.c

195

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

198

ret = clk_programmable_set_parent(hw, prog->pms.parent);

drivers/clk/at91/clk-programmable.c

202

clk_programmable_set_rate(hw, prog->pms.rate, prog->pms.parent_rate);

drivers/clk/at91/clk-programmable.c

222

struct clk_programmable *prog;

drivers/clk/at91/clk-programmable.c

230

prog = kzalloc_obj(*prog);

drivers/clk/at91/clk-programmable.c

231

if (!prog)

drivers/clk/at91/clk-programmable.c

243

prog->id = id;

drivers/clk/at91/clk-programmable.c

244

prog->layout = layout;

drivers/clk/at91/clk-programmable.c

245

prog->hw.init = &init;

drivers/clk/at91/clk-programmable.c

246

prog->regmap = regmap;

drivers/clk/at91/clk-programmable.c

247

prog->mux_table = mux_table;

drivers/clk/at91/clk-programmable.c

249

hw = &prog->hw;

drivers/clk/at91/clk-programmable.c

250

ret = clk_hw_register(NULL, &prog->hw);

drivers/clk/at91/clk-programmable.c

252

kfree(prog);

drivers/clk/at91/clk-programmable.c

35

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

36

const struct clk_programmable_layout *layout = prog->layout;

drivers/clk/at91/clk-programmable.c

40

regmap_read(prog->regmap, AT91_PMC_PCKR(prog->id), &pckr);

drivers/clk/at91/clk-programmable.c

53

struct clk_programmable *prog = to_clk_programmable(hw);

drivers/clk/at91/clk-programmable.c

54

const struct clk_programmable_layout *layout = prog->layout;

drivers/gpu/drm/nouveau/include/nvkm/subdev/fb.h

179

int (*prog)(struct nvkm_ram *);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/base.c

197

ret = clk->func->prog(clk);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/base.c

291

ret = ram->func->prog(ram);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/g84.c

30

.prog = nv50_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gf100.c

452

.prog = gf100_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gk104.c

489

.prog = gk104_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gk20a.c

587

ret = base->func->prog(&clk->base);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gk20a.c

606

.prog = gk20a_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

581

goto prog;

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

630

prog:

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

867

ret = base->func->prog(base);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

886

.prog = gk20a_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gm20b.c

904

.prog = gm20b_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gp10b.c

149

.prog = gp10b_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gp10b.c

21

ret = base->func->prog(base);

drivers/gpu/drm/nouveau/nvkm/subdev/clk/gt215.c

524

.prog = gt215_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/mcp77.c

399

.prog = mcp77_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/nv40.c

208

.prog = nv40_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/nv50.c

546

.prog = nv50_clk_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/clk/priv.h

12

int (*prog)(struct nvkm_clk *);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/base.c

202

fb->func->tile.prog(fb, i, &fb->tile.region[i]);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/base.c

51

if (fb->func->tile.prog) {

drivers/gpu/drm/nouveau/nvkm/subdev/fb/base.c

52

fb->func->tile.prog(fb, region, tile);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv10.c

62

.tile.prog = nv10_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c

34

.tile.prog = nv10_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv20.c

94

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv25.c

52

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv30.c

125

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv35.c

54

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv36.c

54

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv40.c

60

.tile.prog = nv20_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv41.c

54

.tile.prog = nv41_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv44.c

63

.tile.prog = nv44_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv46.c

49

.tile.prog = nv44_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv47.c

37

.tile.prog = nv41_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv49.c

37

.tile.prog = nv41_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv4e.c

35

.tile.prog = nv44_fb_tile_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/priv.h

42

void (*prog)(struct nvkm_fb *, int i, struct nvkm_fb_tile *);

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgf100.c

664

.prog = gf100_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgf108.c

52

.prog = gf100_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgk104.c

1708

.prog = gk104_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgm107.c

43

.prog = gk104_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgm200.c

58

.prog = gk104_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramgt215.c

935

.prog = gt215_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv40.c

186

.prog = nv40_ram_prog,

drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv50.c

498

.prog = nv50_ram_prog,

drivers/hid/bpf/hid_bpf_struct_ops.c

33

const struct bpf_prog *prog,

drivers/hid/bpf/hid_bpf_struct_ops.c

36

return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

drivers/hid/bpf/hid_bpf_struct_ops.c

41

const struct bpf_prog *prog)

drivers/hid/bpf/hid_bpf_struct_ops.c

51

if (prog->sleepable)

drivers/hwmon/thmc50.c

102

prog ? THMC50_REG_TEMP_CRITICAL[i]

drivers/hwmon/thmc50.c

89

int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF);

drivers/hwmon/thmc50.c

91

prog &= THMC50_REG_CONF_PROGRAMMED;

drivers/media/pci/intel/ipu6/ipu6.c

237

struct ipu6_cell_program *prog;

drivers/media/pci/intel/ipu6/ipu6.c

250

prog = (struct ipu6_cell_program *)((uintptr_t)isp->cpd_fw->data +

drivers/media/pci/intel/ipu6/ipu6.c

252

spc_base = base + prog->regs_addr;

drivers/media/pci/intel/ipu6/ipu6.c

257

writel(server_fw_addr + prog->blob_offset +

drivers/media/pci/intel/ipu6/ipu6.c

258

prog->icache_source, spc_base + IPU6_PSYS_REG_SPC_ICACHE_BASE);

drivers/media/pci/intel/ipu6/ipu6.c

261

writel(prog->start[1], spc_base + IPU6_PSYS_REG_SPC_START_PC);

drivers/media/rc/bpf-lirc.c

113

if (bpf_token_capable(prog->aux->token, CAP_PERFMON))

drivers/media/rc/bpf-lirc.c

123

const struct bpf_prog *prog,

drivers/media/rc/bpf-lirc.c

137

static int lirc_bpf_attach(struct rc_dev *rcdev, struct bpf_prog *prog)

drivers/media/rc/bpf-lirc.c

163

ret = bpf_prog_array_copy(old_array, NULL, prog, 0, &new_array);

drivers/media/rc/bpf-lirc.c

175

static int lirc_bpf_detach(struct rc_dev *rcdev, struct bpf_prog *prog)

drivers/media/rc/bpf-lirc.c

196

ret = bpf_prog_array_copy(old_array, prog, NULL, 0, &new_array);

drivers/media/rc/bpf-lirc.c

207

bpf_prog_put(prog);

drivers/media/rc/bpf-lirc.c

242

for (item = array->items; item->prog; item++)

drivers/media/rc/bpf-lirc.c

243

bpf_prog_put(item->prog);

drivers/media/rc/bpf-lirc.c

248

int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)

drivers/media/rc/bpf-lirc.c

260

ret = lirc_bpf_attach(rcdev, prog);

drivers/media/rc/bpf-lirc.c

269

struct bpf_prog *prog;

drivers/media/rc/bpf-lirc.c

276

prog = bpf_prog_get_type(attr->attach_bpf_fd,

drivers/media/rc/bpf-lirc.c

278

if (IS_ERR(prog))

drivers/media/rc/bpf-lirc.c

279

return PTR_ERR(prog);

drivers/media/rc/bpf-lirc.c

283

bpf_prog_put(prog);

drivers/media/rc/bpf-lirc.c

287

ret = lirc_bpf_detach(rcdev, prog);

drivers/media/rc/bpf-lirc.c

289

bpf_prog_put(prog);

drivers/media/rc/bpf-lirc.c

83

lirc_mode2_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

drivers/media/usb/as102/as10x_cmd.c

379

pcmd->header.prog = cpu_to_le16(SERVICE_PROG_ID);

drivers/media/usb/as102/as10x_cmd.h

364

__le16 prog;

drivers/mtd/nand/raw/nand_base.c

1531

unsigned int len, bool prog)

drivers/mtd/nand/raw/nand_base.c

1566

if (!prog) {

drivers/net/bonding/bond_main.c

2304

.prog = bond->xdp_prog,

drivers/net/bonding/bond_main.c

2453

.prog = NULL,

drivers/net/bonding/bond_main.c

5673

static int bond_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/bonding/bond_main.c

5683

.prog = prog,

drivers/net/bonding/bond_main.c

5697

bond->xdp_prog = prog;

drivers/net/bonding/bond_main.c

5723

if (prog)

drivers/net/bonding/bond_main.c

5724

bpf_prog_inc(prog);

drivers/net/bonding/bond_main.c

5727

if (prog) {

drivers/net/bonding/bond_main.c

5739

xdp.prog = old_prog;

drivers/net/bonding/bond_main.c

5753

else if (xdp.prog)

drivers/net/bonding/bond_main.c

5754

bpf_prog_inc(xdp.prog);

drivers/net/bonding/bond_main.c

5763

return bond_xdp_set(dev, xdp->prog, xdp->extack);

drivers/net/ethernet/amazon/ena/ena_xdp.c

234

struct bpf_prog *prog,

drivers/net/ethernet/amazon/ena/ena_xdp.c

243

old_bpf_prog = xchg(&rx_ring->xdp_bpf_prog, prog);

drivers/net/ethernet/amazon/ena/ena_xdp.c

245

if (!old_bpf_prog && prog) {

drivers/net/ethernet/amazon/ena/ena_xdp.c

247

} else if (old_bpf_prog && !prog) {

drivers/net/ethernet/amazon/ena/ena_xdp.c

254

struct bpf_prog *prog)

drivers/net/ethernet/amazon/ena/ena_xdp.c

256

struct bpf_prog *old_bpf_prog = xchg(&adapter->xdp_bpf_prog, prog);

drivers/net/ethernet/amazon/ena/ena_xdp.c

259

prog,

drivers/net/ethernet/amazon/ena/ena_xdp.c

291

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/amazon/ena/ena_xdp.c

300

if (prog) {

drivers/net/ethernet/amazon/ena/ena_xdp.c

307

ena_xdp_exchange_program(adapter, prog);

drivers/net/ethernet/amazon/ena/ena_xdp.c

327

netdev->max_mtu = prog ? ENA_XDP_MAX_MTU : adapter->max_mtu;

drivers/net/ethernet/amazon/ena/ena_xdp.h

35

struct bpf_prog *prog,

drivers/net/ethernet/aquantia/atlantic/aq_main.c

133

struct bpf_prog *prog;

drivers/net/ethernet/aquantia/atlantic/aq_main.c

136

prog = READ_ONCE(aq_nic->xdp_prog);

drivers/net/ethernet/aquantia/atlantic/aq_main.c

137

if (prog && !prog->aux->xdp_has_frags &&

drivers/net/ethernet/aquantia/atlantic/aq_main.c

223

struct bpf_prog *prog;

drivers/net/ethernet/aquantia/atlantic/aq_main.c

228

prog = READ_ONCE(aq_nic->xdp_prog);

drivers/net/ethernet/aquantia/atlantic/aq_main.c

229

if (prog && !prog->aux->xdp_has_frags &&

drivers/net/ethernet/aquantia/atlantic/aq_main.c

407

static int aq_xdp_setup(struct net_device *ndev, struct bpf_prog *prog,

drivers/net/ethernet/aquantia/atlantic/aq_main.c

414

if (prog && !prog->aux->xdp_has_frags) {

drivers/net/ethernet/aquantia/atlantic/aq_main.c

421

if (prog && ndev->features & NETIF_F_LRO) {

drivers/net/ethernet/aquantia/atlantic/aq_main.c

428

need_update = !!aq_nic->xdp_prog != !!prog;

drivers/net/ethernet/aquantia/atlantic/aq_main.c

432

old_prog = xchg(&aq_nic->xdp_prog, prog);

drivers/net/ethernet/aquantia/atlantic/aq_main.c

436

if (!old_prog && prog)

drivers/net/ethernet/aquantia/atlantic/aq_main.c

438

else if (old_prog && !prog)

drivers/net/ethernet/aquantia/atlantic/aq_main.c

451

return aq_xdp_setup(dev, xdp->prog, xdp->extack);

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

413

struct bpf_prog *prog;

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

422

prog = READ_ONCE(rx_ring->xdp_prog);

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

423

if (!prog)

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

429

if (xdp_buff_has_frags(xdp) && !prog->aux->xdp_has_frags)

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

432

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

456

if (xdp_do_redirect(aq_nic->ndev, xdp, prog) < 0)

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

471

trace_xdp_exception(aq_nic->ndev, prog, act);

drivers/net/ethernet/aquantia/atlantic/aq_ring.c

472

bpf_warn_invalid_xdp_action(aq_nic->ndev, prog, act);

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

384

static int bnxt_xdp_set(struct bnxt *bp, struct bpf_prog *prog)

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

392

if (prog && !prog->aux->xdp_has_frags &&

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

398

if (prog && bp->flags & BNXT_FLAG_HDS) {

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

406

if (prog)

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

421

old = xchg(&bp->xdp_prog, prog);

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

425

if (prog) {

drivers/net/ethernet/broadcom/bnxt/bnxt_xdp.c

451

rc = bnxt_xdp_set(bp, xdp->prog);

drivers/net/ethernet/cavium/thunder/nicvf_main.c

1826

static int nicvf_xdp_setup(struct nicvf *nic, struct bpf_prog *prog)

drivers/net/ethernet/cavium/thunder/nicvf_main.c

1837

if (prog && dev->mtu > MAX_XDP_MTU) {

drivers/net/ethernet/cavium/thunder/nicvf_main.c

1860

old_prog = xchg(&nic->xdp_prog, prog);

drivers/net/ethernet/cavium/thunder/nicvf_main.c

1896

return nicvf_xdp_setup(nic, xdp->prog);

drivers/net/ethernet/cavium/thunder/nicvf_main.c

528

static inline bool nicvf_xdp_rx(struct nicvf *nic, struct bpf_prog *prog,

drivers/net/ethernet/cavium/thunder/nicvf_main.c

557

action = bpf_prog_run_xdp(prog, &xdp);

drivers/net/ethernet/cavium/thunder/nicvf_main.c

593

bpf_warn_invalid_xdp_action(nic->netdev, prog, action);

drivers/net/ethernet/cavium/thunder/nicvf_main.c

596

trace_xdp_exception(nic->netdev, prog, action);

drivers/net/ethernet/engleder/tsnep.h

229

int tsnep_xdp_setup_prog(struct tsnep_adapter *adapter, struct bpf_prog *prog,

drivers/net/ethernet/engleder/tsnep_main.c

1286

static bool tsnep_xdp_run_prog(struct tsnep_rx *rx, struct bpf_prog *prog,

drivers/net/ethernet/engleder/tsnep_main.c

1296

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/engleder/tsnep_main.c

1306

if (xdp_do_redirect(rx->adapter->netdev, xdp, prog) < 0)

drivers/net/ethernet/engleder/tsnep_main.c

1311

bpf_warn_invalid_xdp_action(rx->adapter->netdev, prog, act);

drivers/net/ethernet/engleder/tsnep_main.c

1315

trace_xdp_exception(rx->adapter->netdev, prog, act);

drivers/net/ethernet/engleder/tsnep_main.c

1330

static bool tsnep_xdp_run_prog_zc(struct tsnep_rx *rx, struct bpf_prog *prog,

drivers/net/ethernet/engleder/tsnep_main.c

1337

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/engleder/tsnep_main.c

1341

if (xdp_do_redirect(rx->adapter->netdev, xdp, prog) < 0)

drivers/net/ethernet/engleder/tsnep_main.c

1356

bpf_warn_invalid_xdp_action(rx->adapter->netdev, prog, act);

drivers/net/ethernet/engleder/tsnep_main.c

1360

trace_xdp_exception(rx->adapter->netdev, prog, act);

drivers/net/ethernet/engleder/tsnep_main.c

1441

struct bpf_prog *prog;

drivers/net/ethernet/engleder/tsnep_main.c

1451

prog = READ_ONCE(rx->adapter->xdp_prog);

drivers/net/ethernet/engleder/tsnep_main.c

1452

if (prog) {

drivers/net/ethernet/engleder/tsnep_main.c

1508

if (prog) {

drivers/net/ethernet/engleder/tsnep_main.c

1515

consume = tsnep_xdp_run_prog(rx, prog, &xdp,

drivers/net/ethernet/engleder/tsnep_main.c

1545

struct bpf_prog *prog;

drivers/net/ethernet/engleder/tsnep_main.c

1554

prog = READ_ONCE(rx->adapter->xdp_prog);

drivers/net/ethernet/engleder/tsnep_main.c

1555

if (prog) {

drivers/net/ethernet/engleder/tsnep_main.c

1609

if (prog) {

drivers/net/ethernet/engleder/tsnep_main.c

1615

consume = tsnep_xdp_run_prog_zc(rx, prog, entry->xdp,

drivers/net/ethernet/engleder/tsnep_main.c

2295

return tsnep_xdp_setup_prog(adapter, bpf->prog, bpf->extack);

drivers/net/ethernet/engleder/tsnep_xdp.c

14

old_prog = xchg(&adapter->xdp_prog, prog);

drivers/net/ethernet/engleder/tsnep_xdp.c

9

int tsnep_xdp_setup_prog(struct tsnep_adapter *adapter, struct bpf_prog *prog,

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c

3034

if (bpf->prog && !xdp_validate_mtu(priv, net_dev->mtu)) {

drivers/net/ethernet/freescale/dpaa/dpaa_eth.c

3044

old_prog = xchg(&priv->xdp_prog, bpf->prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2739

static int dpaa2_eth_setup_xdp(struct net_device *dev, struct bpf_prog *prog)

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2747

if (prog && !xdp_mtu_valid(priv, dev->mtu))

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2750

if (prog)

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2751

bpf_prog_add(prog, priv->num_channels);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2754

need_update = (!!priv->xdp_prog != !!prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2765

err = dpaa2_eth_set_rx_mfl(priv, dev->mtu, !!prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2768

err = dpaa2_eth_update_rx_buffer_headroom(priv, !!prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2773

old = xchg(&priv->xdp_prog, prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2779

old = xchg(&ch->xdp.prog, prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2793

if (prog)

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2794

bpf_prog_sub(prog, priv->num_channels);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

2805

return dpaa2_eth_setup_xdp(dev, xdp->prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

436

xdp_prog = READ_ONCE(ch->xdp.prog);

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.h

477

struct bpf_prog *prog;

drivers/net/ethernet/freescale/dpaa2/dpaa2-xsk.c

44

xdp_prog = READ_ONCE(ch->xdp.prog);

drivers/net/ethernet/freescale/enetc/enetc.c

1322

bool xdp = !!(rx_ring->xdp.prog);

drivers/net/ethernet/freescale/enetc/enetc.c

1952

struct bpf_prog *prog)

drivers/net/ethernet/freescale/enetc/enetc.c

2001

xdp_act = bpf_prog_run_xdp(prog, &xdp_buff);

drivers/net/ethernet/freescale/enetc/enetc.c

2005

bpf_warn_invalid_xdp_action(rx_ring->ndev, prog, xdp_act);

drivers/net/ethernet/freescale/enetc/enetc.c

2008

trace_xdp_exception(rx_ring->ndev, prog, xdp_act);

drivers/net/ethernet/freescale/enetc/enetc.c

2069

err = xdp_do_redirect(rx_ring->ndev, &xdp_buff, prog);

drivers/net/ethernet/freescale/enetc/enetc.c

2113

struct bpf_prog *prog;

drivers/net/ethernet/freescale/enetc/enetc.c

2125

prog = rx_ring->xdp.prog;

drivers/net/ethernet/freescale/enetc/enetc.c

2126

if (prog)

drivers/net/ethernet/freescale/enetc/enetc.c

2127

work_done = enetc_clean_rx_ring_xdp(rx_ring, napi, budget, prog);

drivers/net/ethernet/freescale/enetc/enetc.c

2640

if (rx_ring->xdp.prog)

drivers/net/ethernet/freescale/enetc/enetc.c

3237

struct bpf_prog *old_prog, *prog = ctx;

drivers/net/ethernet/freescale/enetc/enetc.c

3241

old_prog = xchg(&priv->xdp_prog, prog);

drivers/net/ethernet/freescale/enetc/enetc.c

3256

rx_ring->xdp.prog = prog;

drivers/net/ethernet/freescale/enetc/enetc.c

3258

if (prog)

drivers/net/ethernet/freescale/enetc/enetc.c

3267

static int enetc_setup_xdp_prog(struct net_device *ndev, struct bpf_prog *prog,

drivers/net/ethernet/freescale/enetc/enetc.c

3270

int num_xdp_tx_queues = prog ? num_possible_cpus() : 0;

drivers/net/ethernet/freescale/enetc/enetc.c

3289

return enetc_reconfigure(priv, extended, enetc_reconfigure_xdp_cb, prog);

drivers/net/ethernet/freescale/enetc/enetc.c

3296

return enetc_setup_xdp_prog(ndev, bpf->prog, bpf->extack);

drivers/net/ethernet/freescale/enetc/enetc.h

123

struct bpf_prog *prog;

drivers/net/ethernet/freescale/fec_main.c

2019

int budget, struct bpf_prog *prog)

drivers/net/ethernet/freescale/fec_main.c

2087

act = bpf_prog_run_xdp(prog, &xdp);

drivers/net/ethernet/freescale/fec_main.c

2103

trace_xdp_exception(ndev, prog, XDP_PASS);

drivers/net/ethernet/freescale/fec_main.c

2110

err = xdp_do_redirect(ndev, &xdp, prog);

drivers/net/ethernet/freescale/fec_main.c

2113

trace_xdp_exception(ndev, prog, XDP_REDIRECT);

drivers/net/ethernet/freescale/fec_main.c

2124

trace_xdp_exception(ndev, prog, XDP_TX);

drivers/net/ethernet/freescale/fec_main.c

2130

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/freescale/fec_main.c

2133

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/freescale/fec_main.c

2270

int budget, struct bpf_prog *prog)

drivers/net/ethernet/freescale/fec_main.c

2350

if (unlikely(!prog))

drivers/net/ethernet/freescale/fec_main.c

2353

act = bpf_prog_run_xdp(prog, xsk);

drivers/net/ethernet/freescale/fec_main.c

2361

trace_xdp_exception(ndev, prog, XDP_PASS);

drivers/net/ethernet/freescale/fec_main.c

2373

trace_xdp_exception(ndev, prog, XDP_TX);

drivers/net/ethernet/freescale/fec_main.c

2380

err = xdp_do_redirect(ndev, xsk, prog);

drivers/net/ethernet/freescale/fec_main.c

2387

trace_xdp_exception(ndev, prog, XDP_REDIRECT);

drivers/net/ethernet/freescale/fec_main.c

2393

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/freescale/fec_main.c

2396

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/freescale/fec_main.c

2455

struct bpf_prog *prog = READ_ONCE(fep->xdp_prog);

drivers/net/ethernet/freescale/fec_main.c

2464

done += fec_enet_rx_queue_xsk(fep, i, batch, prog);

drivers/net/ethernet/freescale/fec_main.c

2465

else if (prog)

drivers/net/ethernet/freescale/fec_main.c

2466

done += fec_enet_rx_queue_xdp(fep, i, batch, prog);

drivers/net/ethernet/freescale/fec_main.c

4643

if (!bpf->prog)

drivers/net/ethernet/freescale/fec_main.c

4651

old_prog = xchg(&fep->xdp_prog, bpf->prog);

drivers/net/ethernet/freescale/fec_main.c

4662

if (bpf->prog)

drivers/net/ethernet/fungible/funeth/funeth_main.c

1064

static int fun_enter_xdp(struct net_device *dev, struct bpf_prog *prog)

drivers/net/ethernet/fungible/funeth/funeth_main.c

1078

err = fun_rxq_set_bpf(rxqs[i], prog);

drivers/net/ethernet/fungible/funeth/funeth_main.c

1120

struct bpf_prog *old_prog, *prog = xdp->prog;

drivers/net/ethernet/fungible/funeth/funeth_main.c

1125

if (prog && dev->mtu > XDP_MAX_MTU) {

drivers/net/ethernet/fungible/funeth/funeth_main.c

1133

fp->num_xdpqs = prog ? num_online_cpus() : 0;

drivers/net/ethernet/fungible/funeth/funeth_main.c

1134

} else if (prog && !fp->xdp_prog) {

drivers/net/ethernet/fungible/funeth/funeth_main.c

1135

err = fun_enter_xdp(dev, prog);

drivers/net/ethernet/fungible/funeth/funeth_main.c

1141

} else if (!prog && fp->xdp_prog) {

drivers/net/ethernet/fungible/funeth/funeth_main.c

1147

WRITE_ONCE(rxqs[i]->xdp_prog, prog);

drivers/net/ethernet/fungible/funeth/funeth_main.c

1150

if (prog)

drivers/net/ethernet/fungible/funeth/funeth_main.c

1155

dev->max_mtu = prog ? XDP_MAX_MTU : FUN_MAX_MTU;

drivers/net/ethernet/fungible/funeth/funeth_main.c

1156

old_prog = xchg(&fp->xdp_prog, prog);

drivers/net/ethernet/fungible/funeth/funeth_rx.c

587

int fun_rxq_set_bpf(struct funeth_rxq *q, struct bpf_prog *prog)

drivers/net/ethernet/fungible/funeth/funeth_rx.c

594

headroom = prog ? FUN_XDP_HEADROOM : FUN_RX_HEADROOM;

drivers/net/ethernet/fungible/funeth/funeth_rx.c

608

WRITE_ONCE(q->xdp_prog, prog);

drivers/net/ethernet/fungible/funeth/funeth_txrx.h

264

int fun_rxq_set_bpf(struct funeth_rxq *q, struct bpf_prog *prog);

drivers/net/ethernet/google/gve/gve_main.c

1538

static int gve_set_xdp(struct gve_priv *priv, struct bpf_prog *prog,

drivers/net/ethernet/google/gve/gve_main.c

1547

WRITE_ONCE(priv->xdp_prog, prog);

drivers/net/ethernet/google/gve/gve_main.c

1557

if (!old_prog && prog)

drivers/net/ethernet/google/gve/gve_main.c

1559

else if (old_prog && !prog)

drivers/net/ethernet/google/gve/gve_main.c

1565

WRITE_ONCE(priv->xdp_prog, prog);

drivers/net/ethernet/google/gve/gve_main.c

1773

return gve_set_xdp(priv, xdp->prog, xdp->extack);

drivers/net/ethernet/intel/i40e/i40e_main.c

13244

static int i40e_xdp_setup(struct i40e_vsi *vsi, struct bpf_prog *prog,

drivers/net/ethernet/intel/i40e/i40e_main.c

13247

int frame_size = i40e_max_vsi_frame_size(vsi, prog);

drivers/net/ethernet/intel/i40e/i40e_main.c

13254

if (prog && test_bit(__I40E_IN_REMOVE, pf->state))

drivers/net/ethernet/intel/i40e/i40e_main.c

13264

need_reset = (i40e_enabled_xdp_vsi(vsi) != !!prog);

drivers/net/ethernet/intel/i40e/i40e_main.c

13268

old_prog = xchg(&vsi->xdp_prog, prog);

drivers/net/ethernet/intel/i40e/i40e_main.c

13271

if (!prog) {

drivers/net/ethernet/intel/i40e/i40e_main.c

13279

if (!i40e_enabled_xdp_vsi(vsi) && prog) {

drivers/net/ethernet/intel/i40e/i40e_main.c

13282

} else if (i40e_enabled_xdp_vsi(vsi) && !prog) {

drivers/net/ethernet/intel/i40e/i40e_main.c

13296

if (need_reset && prog) {

drivers/net/ethernet/intel/i40e/i40e_main.c

13579

return i40e_xdp_setup(vsi, xdp->prog, xdp->extack);

drivers/net/ethernet/intel/ice/ice.h

994

int ice_prepare_xdp_rings(struct ice_vsi *vsi, struct bpf_prog *prog,

drivers/net/ethernet/intel/ice/ice_main.c

2658

static void ice_vsi_assign_bpf_prog(struct ice_vsi *vsi, struct bpf_prog *prog)

drivers/net/ethernet/intel/ice/ice_main.c

2663

old_prog = xchg(&vsi->xdp_prog, prog);

drivers/net/ethernet/intel/ice/ice_main.c

2754

int ice_prepare_xdp_rings(struct ice_vsi *vsi, struct bpf_prog *prog,

drivers/net/ethernet/intel/ice/ice_main.c

2822

ice_vsi_assign_bpf_prog(vsi, prog);

drivers/net/ethernet/intel/ice/ice_main.c

2972

ice_xdp_setup_prog(struct ice_vsi *vsi, struct bpf_prog *prog,

drivers/net/ethernet/intel/ice/ice_main.c

2979

if (prog && !prog->aux->xdp_has_frags) {

drivers/net/ethernet/intel/ice/ice_main.c

2988

if (ice_is_xdp_ena_vsi(vsi) == !!prog ||

drivers/net/ethernet/intel/ice/ice_main.c

2990

ice_vsi_assign_bpf_prog(vsi, prog);

drivers/net/ethernet/intel/ice/ice_main.c

3006

if (!ice_is_xdp_ena_vsi(vsi) && prog) {

drivers/net/ethernet/intel/ice/ice_main.c

3012

xdp_ring_err = ice_prepare_xdp_rings(vsi, prog,

drivers/net/ethernet/intel/ice/ice_main.c

3020

} else if (ice_is_xdp_ena_vsi(vsi) && !prog) {

drivers/net/ethernet/intel/ice/ice_main.c

3031

if (!ret && prog)

drivers/net/ethernet/intel/ice/ice_main.c

3071

ret = ice_xdp_setup_prog(vsi, xdp->prog, xdp->extack);

drivers/net/ethernet/intel/ice/ice_main.c

7902

struct bpf_prog *prog;

drivers/net/ethernet/intel/ice/ice_main.c

7911

prog = vsi->xdp_prog;

drivers/net/ethernet/intel/ice/ice_main.c

7912

if (prog && !prog->aux->xdp_has_frags) {

drivers/net/ethernet/intel/idpf/xdp.c

131

struct bpf_prog *prog = arg;

drivers/net/ethernet/intel/idpf/xdp.c

134

if (prog)

drivers/net/ethernet/intel/idpf/xdp.c

135

bpf_prog_inc(prog);

drivers/net/ethernet/intel/idpf/xdp.c

137

old = rcu_replace_pointer(rxq->xdp_prog, prog, lockdep_rtnl_is_held());

drivers/net/ethernet/intel/idpf/xdp.c

455

struct bpf_prog *old, *prog = xdp->prog;

drivers/net/ethernet/intel/idpf/xdp.c

463

!!vport->xdp_prog == !!prog) {

drivers/net/ethernet/intel/idpf/xdp.c

465

idpf_xdp_copy_prog_to_rqs(rsrc, prog);

drivers/net/ethernet/intel/idpf/xdp.c

467

old = xchg(&vport->xdp_prog, prog);

drivers/net/ethernet/intel/idpf/xdp.c

471

cfg->user_config.xdp_prog = prog;

drivers/net/ethernet/intel/idpf/xdp.c

483

cfg->user_config.xdp_prog = prog;

drivers/net/ethernet/intel/idpf/xdp.c

491

old = prog;

drivers/net/ethernet/intel/igb/igb_main.c

2894

struct bpf_prog *prog = bpf->prog, *old_prog;

drivers/net/ethernet/intel/igb/igb_main.c

2911

old_prog = xchg(&adapter->xdp_prog, prog);

drivers/net/ethernet/intel/igb/igb_main.c

2912

need_reset = (!!prog != !!old_prog);

drivers/net/ethernet/intel/igb/igb_main.c

2930

if (prog)

drivers/net/ethernet/intel/igc/igc_main.c

2515

struct bpf_prog *prog,

drivers/net/ethernet/intel/igc/igc_main.c

2518

u32 act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/intel/igc/igc_main.c

2528

if (xdp_do_redirect(adapter->netdev, xdp, prog) < 0)

drivers/net/ethernet/intel/igc/igc_main.c

2533

bpf_warn_invalid_xdp_action(adapter->netdev, prog, act);

drivers/net/ethernet/intel/igc/igc_main.c

2537

trace_xdp_exception(adapter->netdev, prog, act);

drivers/net/ethernet/intel/igc/igc_main.c

2546

struct bpf_prog *prog;

drivers/net/ethernet/intel/igc/igc_main.c

2549

prog = READ_ONCE(adapter->xdp_prog);

drivers/net/ethernet/intel/igc/igc_main.c

2550

if (!prog) {

drivers/net/ethernet/intel/igc/igc_main.c

2555

res = __igc_xdp_run_prog(adapter, prog, xdp);

drivers/net/ethernet/intel/igc/igc_main.c

2808

struct bpf_prog *prog;

drivers/net/ethernet/intel/igc/igc_main.c

2814

prog = READ_ONCE(adapter->xdp_prog);

drivers/net/ethernet/intel/igc/igc_main.c

2856

res = __igc_xdp_run_prog(adapter, prog, bi->xdp);

drivers/net/ethernet/intel/igc/igc_main.c

6862

return igc_xdp_set_prog(adapter, bpf->prog, bpf->extack);

drivers/net/ethernet/intel/igc/igc_xdp.c

10

int igc_xdp_set_prog(struct igc_adapter *adapter, struct bpf_prog *prog,

drivers/net/ethernet/intel/igc/igc_xdp.c

27

need_update = !!adapter->xdp_prog != !!prog;

drivers/net/ethernet/intel/igc/igc_xdp.c

36

old_prog = xchg(&adapter->xdp_prog, prog);

drivers/net/ethernet/intel/igc/igc_xdp.c

40

if (prog)

drivers/net/ethernet/intel/igc/igc_xdp.h

7

int igc_xdp_set_prog(struct igc_adapter *adapter, struct bpf_prog *prog,

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10884

static int ixgbe_xdp_setup(struct net_device *dev, struct bpf_prog *prog)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10915

old_prog = xchg(&adapter->xdp_prog, prog);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10916

need_reset = (!!prog != !!old_prog);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10922

if (!prog)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10929

if (!prog)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10944

if (need_reset && prog) {

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10963

return ixgbe_xdp_setup(dev, xdp->prog);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4470

static int ixgbevf_xdp_setup(struct net_device *dev, struct bpf_prog *prog)

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4484

old_prog = xchg(&adapter->xdp_prog, prog);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4487

if (!!prog != !!old_prog) {

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4515

return ixgbevf_xdp_setup(dev, xdp->prog);

drivers/net/ethernet/intel/libeth/xdp.c

107

const struct bpf_prog *prog,

drivers/net/ethernet/intel/libeth/xdp.c

110

trace_xdp_exception(dev, prog, act);

drivers/net/ethernet/intel/libeth/xdp.c

130

libeth_trace_xdp_exception(bq->dev, bq->prog, XDP_TX);

drivers/net/ethernet/intel/libeth/xdp.c

300

bpf_warn_invalid_xdp_action(bq->dev, bq->prog, act);

drivers/net/ethernet/intel/libeth/xdp.c

302

libeth_trace_xdp_exception(bq->dev, bq->prog, act);

drivers/net/ethernet/marvell/mvneta.c

2258

struct bpf_prog *prog, struct xdp_buff *xdp,

drivers/net/ethernet/marvell/mvneta.c

2266

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/marvell/mvneta.c

2279

err = xdp_do_redirect(pp->dev, xdp, prog);

drivers/net/ethernet/marvell/mvneta.c

2295

bpf_warn_invalid_xdp_action(pp->dev, prog, act);

drivers/net/ethernet/marvell/mvneta.c

2298

trace_xdp_exception(pp->dev, prog, act);

drivers/net/ethernet/marvell/mvneta.c

3856

struct bpf_prog *prog = pp->xdp_prog;

drivers/net/ethernet/marvell/mvneta.c

3865

if (prog && !prog->aux->xdp_has_frags &&

drivers/net/ethernet/marvell/mvneta.c

4653

static int mvneta_xdp_setup(struct net_device *dev, struct bpf_prog *prog,

drivers/net/ethernet/marvell/mvneta.c

4660

if (prog && !prog->aux->xdp_has_frags &&

drivers/net/ethernet/marvell/mvneta.c

4672

need_update = !!pp->xdp_prog != !!prog;

drivers/net/ethernet/marvell/mvneta.c

4676

old_prog = xchg(&pp->xdp_prog, prog);

drivers/net/ethernet/marvell/mvneta.c

4690

return mvneta_xdp_setup(dev, xdp->prog, xdp->extack);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

3810

mvpp2_run_xdp(struct mvpp2_port *port, struct bpf_prog *prog,

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

3819

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

3831

err = xdp_do_redirect(port->dev, xdp, prog);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

3849

bpf_warn_invalid_xdp_action(port->dev, prog, act);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

3852

trace_xdp_exception(port->dev, prog, act);

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

5332

struct bpf_prog *prog = bpf->prog, *old_prog;

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

5334

bool reset = !prog != !port->xdp_prog;

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

5355

old_prog = xchg(&port->xdp_prog, prog);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2816

static int otx2_xdp_setup(struct otx2_nic *pf, struct bpf_prog *prog)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2822

if (prog && dev->mtu > MAX_XDP_MTU) {

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2830

old_prog = xchg(&pf->xdp_prog, prog);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2861

return otx2_xdp_setup(pf, xdp->prog);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1489

struct bpf_prog *prog,

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1512

act = bpf_prog_run_xdp(prog, xsk_buff);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1526

act = bpf_prog_run_xdp(prog, &xdp);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1544

err = xdp_do_redirect(pfvf->netdev, xsk_buff, prog);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1552

err = xdp_do_redirect(pfvf->netdev, &xdp, prog);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1564

bpf_warn_invalid_xdp_action(pfvf->netdev, prog, act);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

1568

trace_xdp_exception(pfvf->netdev, prog, act);

drivers/net/ethernet/marvell/octeontx2/nic/otx2_txrx.c

41

struct bpf_prog *prog,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

1886

pp_params.dma_dir = rcu_access_pointer(eth->prog) ? DMA_BIDIRECTIONAL

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2121

struct bpf_prog *prog;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2126

prog = rcu_dereference(eth->prog);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2127

if (!prog)

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2130

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2136

if (unlikely(xdp_do_redirect(dev, xdp, prog))) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2156

bpf_warn_invalid_xdp_action(dev, prog, act);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2159

trace_xdp_exception(dev, prog, act);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3636

if (mtk_uses_dsa(dev) && !eth->prog) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3728

static int mtk_xdp_setup(struct net_device *dev, struct bpf_prog *prog,

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3746

need_update = !!eth->prog != !!prog;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3750

old_prog = rcu_replace_pointer(eth->prog, prog, lockdep_rtnl_is_held());

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3757

rcu_assign_pointer(eth->prog, old_prog);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3773

return mtk_xdp_setup(dev, xdp->prog, xdp->extack);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

4315

if (rcu_access_pointer(eth->prog) &&

drivers/net/ethernet/mediatek/mtk_eth_soc.h

1348

struct bpf_prog __rcu *prog;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2716

static int mlx4_xdp_set(struct net_device *dev, struct bpf_prog *prog)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2729

xdp_ring_num = prog ? priv->rx_ring_num : 0;

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2735

if (prog)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2736

bpf_prog_add(prog, priv->rx_ring_num - 1);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2743

rcu_assign_pointer(priv->rx_ring[i]->xdp_prog, prog);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2758

if (prog)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2759

bpf_prog_add(prog, priv->rx_ring_num - 1);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2774

if (prog)

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2775

bpf_prog_sub(prog, priv->rx_ring_num - 1);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2792

rcu_assign_pointer(priv->rx_ring[i]->xdp_prog, prog);

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

2817

return mlx4_xdp_set(dev, xdp->prog);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

312

struct bpf_prog *prog, struct mlx5e_xdp_buff *mxbuf)

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

318

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

329

err = xdp_do_redirect(rq->netdev, xdp, prog);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

337

bpf_warn_invalid_xdp_action(rq->netdev, prog, act);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

341

trace_xdp_exception(rq->netdev, prog, act);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h

101

struct bpf_prog *prog, struct mlx5e_xdp_buff *mlctx);

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

258

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

294

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

295

if (likely(prog && mlx5e_xdp_handle(rq, prog, mxbuf))) {

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

313

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

328

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/rx.c

329

if (likely(prog && mlx5e_xdp_handle(rq, prog, mxbuf))) {

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5129

static void mlx5e_rq_replace_xdp_prog(struct mlx5e_rq *rq, struct bpf_prog *prog)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5133

old_prog = rcu_replace_pointer(rq->xdp_prog, prog,

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5139

static int mlx5e_xdp_set(struct net_device *netdev, struct bpf_prog *prog)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5151

new_params.xdp_prog = prog;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5153

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5160

reset = (!priv->channels.params.xdp_prog || !prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5177

bpf_prog_add(prog, priv->channels.num);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5181

mlx5e_rq_replace_xdp_prog(&c->rq, prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5183

bpf_prog_inc(prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5184

mlx5e_rq_replace_xdp_prog(&c->xskrq, prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5202

return mlx5e_xdp_set(dev, xdp->prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1538

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1554

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1555

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1561

if (mlx5e_xdp_handle(rq, prog, mxbuf))

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1591

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1633

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1634

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1637

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1877

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1893

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1895

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1955

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1960

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2050

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2072

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2073

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2079

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

512

bool fbnic_check_split_frames(struct bpf_prog *prog, unsigned int mtu,

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

515

if (!prog)

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

518

if (prog->aux->xdp_has_frags)

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

526

struct bpf_prog *prog = bpf->prog, *prev_prog;

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

532

if (fbnic_check_split_frames(prog, netdev->mtu,

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

539

prev_prog = xchg(&fbn->xdp_prog, prog);

drivers/net/ethernet/meta/fbnic/fbnic_netdev.h

115

bool fbnic_check_split_frames(struct bpf_prog *prog,

drivers/net/ethernet/microchip/lan966x/lan966x_xdp.c

24

old_prog = xchg(&port->xdp_prog, xdp->prog);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

107

rxq->xdp_rc = xdp_do_redirect(ndev, xdp, prog);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

123

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

127

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

149

void mana_chn_setxdp(struct mana_port_context *apc, struct bpf_prog *prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

157

if (old_prog == prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

160

if (prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

161

bpf_prog_add(prog, num_queues);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

164

rcu_assign_pointer(apc->rxqs[i]->bpf_prog, prog);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

171

static int mana_xdp_set(struct net_device *ndev, struct bpf_prog *prog,

drivers/net/ethernet/microsoft/mana/mana_bpf.c

183

if (!old_prog && !prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

186

if (prog && ndev->mtu > MANA_XDP_MTU_MAX) {

drivers/net/ethernet/microsoft/mana/mana_bpf.c

197

apc->bpf_prog = prog;

drivers/net/ethernet/microsoft/mana/mana_bpf.c

232

mana_chn_setxdp(apc, prog);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

239

if (prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

259

return mana_xdp_set(ndev, bpf->prog, extack);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

84

struct bpf_prog *prog;

drivers/net/ethernet/microsoft/mana/mana_bpf.c

88

prog = rcu_dereference(rxq->bpf_prog);

drivers/net/ethernet/microsoft/mana/mana_bpf.c

90

if (!prog)

drivers/net/ethernet/microsoft/mana/mana_bpf.c

96

act = bpf_prog_run_xdp(prog, xdp);

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

175

nfp_prog->prog[nfp_prog->prog_len - 1] |=

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

229

nfp_prog->prog[nfp_prog->prog_len - 1] |=

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

3544

if (immed_get_value(nfp_prog->prog[br_idx + 1])) {

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

3549

immed_set_value(&nfp_prog->prog[br_idx + 1], jmp_dst->off);

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

3584

if (!nfp_is_br(nfp_prog->prog[br_idx])) {

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

3586

br_idx, meta->insn.code, nfp_prog->prog[br_idx]);

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

3594

if (FIELD_GET(OP_RELO_TYPE, nfp_prog->prog[br_idx]) !=

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

3618

if (FIELD_GET(OP_RELO_TYPE, nfp_prog->prog[br_idx]) !=

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

3623

if (!nfp_is_br(nfp_prog->prog[idx]))

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

3625

br_set_offset(&nfp_prog->prog[idx], jmp_dst->off);

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

4435

static int nfp_bpf_ustore_calc(u64 *prog, unsigned int len)

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

4437

__le64 *ustore = (__force __le64 *)prog;

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

4443

err = nfp_ustore_check_valid_no_ecc(prog[i]);

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

4447

ustore[i] = cpu_to_le64(nfp_ustore_calc_ecc_insn(prog[i]));

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

4455

void *prog;

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

4457

prog = kvmalloc_array(nfp_prog->prog_len, sizeof(u64), GFP_KERNEL);

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

4458

if (!prog)

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

4462

memcpy(prog, nfp_prog->prog, nfp_prog->__prog_alloc_len);

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

4463

kvfree(nfp_prog->prog);

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

4464

nfp_prog->prog = prog;

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

4537

u64 *prog;

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

4540

prog = kmemdup_array(nfp_prog->prog, nfp_prog->prog_len, sizeof(u64),

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

4542

if (!prog)

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

4550

special = FIELD_GET(OP_RELO_TYPE, prog[i]);

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

4555

br_add_offset(&prog[i], bv->start_off);

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

4558

br_set_offset(&prog[i],

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

4562

br_set_offset(&prog[i],

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

4572

br_set_offset(&prog[i], off);

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

4581

br_set_offset(&prog[i], off);

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

4584

br_set_offset(&prog[i], bv->tgt_done);

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

4587

val = br_get_offset(prog[i]);

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

4608

br_set_offset(&prog[i], val);

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

4611

immed_add_value(&prog[i], bv->start_off);

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

4615

prog[i] &= ~OP_RELO_TYPE;

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

4618

err = nfp_bpf_ustore_calc(prog, nfp_prog->prog_len);

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

4622

return prog;

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

4625

kfree(prog);

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

56

nfp_prog->prog[nfp_prog->prog_len] = insn;

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

643

nfp_prog->prog[nfp_prog->prog_len - 1] |=

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

149

if (!cls_bpf->prog)

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

153

err = nfp_net_bpf_offload(nn, cls_bpf->prog, oldprog,

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

158

bv->tc_prog = cls_bpf->prog;

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

186

struct bpf_prog *prog;

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

191

if (nn->xdp_hw.prog) {

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

192

prog = nn->xdp_hw.prog;

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

195

prog = bv->tc_prog;

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

198

if (nfp_bpf_offload_check_mtu(nn, prog, new_mtu)) {

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

39

struct bpf_prog *prog, struct netlink_ext_ack *extack)

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

47

xdp_running = running && nn->xdp_hw.prog;

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

49

if (!prog && !xdp_running)

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

51

if (prog && running && !xdp_running)

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

54

return nfp_net_bpf_offload(nn, prog, running, extack);

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

516

u64 *prog;

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

561

int nfp_bpf_jit(struct nfp_prog *prog);

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

563

bool nfp_bpf_offload_check_mtu(struct nfp_net *nn, struct bpf_prog *prog,

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

582

int nfp_net_bpf_offload(struct nfp_net *nn, struct bpf_prog *prog,

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

112

struct bpf_prog *prog)

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

116

mutex_lock(&prog->aux->used_maps_mutex);

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

120

for (i = 0; i < prog->aux->used_map_cnt; i++)

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

121

if (bpf_map_offload_neutral(prog->aux->used_maps[i]))

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

132

for (i = 0; i < prog->aux->used_map_cnt; i++)

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

133

if (bpf_map_offload_neutral(prog->aux->used_maps[i])) {

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

135

prog->aux->used_maps[i]);

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

144

mutex_unlock(&prog->aux->used_maps_mutex);

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

149

nfp_prog_prepare(struct nfp_prog *nfp_prog, const struct bpf_insn *prog,

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

160

meta->insn = prog[i];

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

189

static int nfp_bpf_verifier_prep(struct bpf_prog *prog)

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

197

prog->aux->offload->dev_priv = nfp_prog;

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

200

nfp_prog->type = prog->type;

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

201

nfp_prog->bpf = bpf_offload_dev_priv(prog->aux->offload->offdev);

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

203

ret = nfp_prog_prepare(nfp_prog, prog->insnsi, prog->len);

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

217

static int nfp_bpf_translate(struct bpf_prog *prog)

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

219

struct nfp_net *nn = netdev_priv(prog->aux->offload->netdev);

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

220

struct nfp_prog *nfp_prog = prog->aux->offload->dev_priv;

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

225

if (prog->aux->offload->opt_failed)

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

231

nfp_prog->prog = kvmalloc(nfp_prog->__prog_alloc_len, GFP_KERNEL);

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

232

if (!nfp_prog->prog)

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

239

prog->aux->offload->jited_len = nfp_prog->prog_len * sizeof(u64);

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

240

prog->aux->offload->jited_image = nfp_prog->prog;

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

242

return nfp_map_ptrs_record(nfp_prog->bpf, nfp_prog, prog);

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

245

static void nfp_bpf_destroy(struct bpf_prog *prog)

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

247

struct nfp_prog *nfp_prog = prog->aux->offload->dev_priv;

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

249

kvfree(nfp_prog->prog);

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

483

bool nfp_bpf_offload_check_mtu(struct nfp_net *nn, struct bpf_prog *prog,

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

489

pkt_off = min(prog->aux->max_pkt_offset, mtu);

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

495

nfp_net_bpf_load(struct nfp_net *nn, struct bpf_prog *prog,

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

498

struct nfp_prog *nfp_prog = prog->aux->offload->dev_priv;

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

504

if (nfp_bpf_offload_check_mtu(nn, prog, nn->dp.netdev->mtu)) {

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

574

int nfp_net_bpf_offload(struct nfp_net *nn, struct bpf_prog *prog,

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

579

if (prog && !bpf_offload_dev_match(prog, nn->dp.netdev))

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

582

if (prog && old_prog) {

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

597

if (old_prog && !prog)

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

600

err = nfp_net_bpf_load(nn, prog, extack);

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

634

struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv;

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

771

nfp_prog = env->prog->aux->offload->dev_priv;

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

794

nn = netdev_priv(env->prog->aux->offload->netdev);

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

810

struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv;

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

843

struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv;

drivers/net/ethernet/netronome/nfp/nfp_app.h

137

struct bpf_prog *prog,

drivers/net/ethernet/netronome/nfp/nfp_app.h

338

struct bpf_prog *prog,

drivers/net/ethernet/netronome/nfp/nfp_app.h

343

return app->type->xdp_offload(app, nn, prog, extack);

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2180

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2184

if (!prog == !nn->dp.xdp_prog) {

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2185

WRITE_ONCE(nn->dp.xdp_prog, prog);

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2194

dp->xdp_prog = prog;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2195

dp->num_tx_rings += prog ? nn->dp.num_rx_rings : -nn->dp.num_rx_rings;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2196

dp->rx_dma_dir = prog ? DMA_BIDIRECTIONAL : DMA_FROM_DEVICE;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2197

dp->rx_dma_off = prog ? XDP_PACKET_HEADROOM - nn->dp.rx_offset : 0;

drivers/net/ethernet/netronome/nfp/nfp_net_common.c

2212

err = nfp_app_xdp_offload(nn->app, nn, bpf->prog, bpf->extack);

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2759

if (!ionic_xdp_is_valid_mtu(lif, netdev->mtu, bpf->prog)) {

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2767

if (bpf->prog && !(bpf->prog->aux && bpf->prog->aux->xdp_has_frags))

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2772

old_prog = xchg(&lif->xdp_prog, bpf->prog);

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2773

} else if (lif->xdp_prog && bpf->prog) {

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2774

old_prog = xchg(&lif->xdp_prog, bpf->prog);

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2780

qparams.xdp_prog = bpf->prog;

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2783

old_prog = xchg(&lif->xdp_prog, bpf->prog);

drivers/net/ethernet/qlogic/qede/qede_filter.c

1027

static int qede_xdp_set(struct qede_dev *edev, struct bpf_prog *prog)

drivers/net/ethernet/qlogic/qede/qede_filter.c

1033

args.u.new_prog = prog;

drivers/net/ethernet/qlogic/qede/qede_filter.c

1045

return qede_xdp_set(edev, xdp->prog);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1083

struct bpf_prog *prog,

drivers/net/ethernet/qlogic/qede/qede_fp.c

1095

act = bpf_prog_run_xdp(prog, &xdp);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1113

trace_xdp_exception(edev->ndev, prog, act);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1127

trace_xdp_exception(edev->ndev, prog, act);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1143

trace_xdp_exception(edev->ndev, prog, act);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1150

if (unlikely(xdp_do_redirect(edev->ndev, &xdp, prog)))

drivers/net/ethernet/qlogic/qede/qede_fp.c

1158

bpf_warn_invalid_xdp_action(edev->ndev, prog, act);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1161

trace_xdp_exception(edev->ndev, prog, act);

drivers/net/ethernet/sfc/efx.c

105

static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog);

drivers/net/ethernet/sfc/efx.c

706

static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog)

drivers/net/ethernet/sfc/efx.c

716

if (prog && efx->net_dev->mtu > efx_xdp_max_mtu(efx)) {

drivers/net/ethernet/sfc/efx.c

724

rcu_assign_pointer(efx->xdp_prog, prog);

drivers/net/ethernet/sfc/efx.c

739

return efx_xdp_setup_prog(efx, xdp->prog);

drivers/net/ethernet/sfc/siena/efx.c

106

static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog);

drivers/net/ethernet/sfc/siena/efx.c

628

static int efx_xdp_setup_prog(struct efx_nic *efx, struct bpf_prog *prog)

drivers/net/ethernet/sfc/siena/efx.c

638

if (prog && efx->net_dev->mtu > efx_siena_xdp_max_mtu(efx)) {

drivers/net/ethernet/sfc/siena/efx.c

646

rcu_assign_pointer(efx->xdp_prog, prog);

drivers/net/ethernet/sfc/siena/efx.c

661

return efx_xdp_setup_prog(efx, xdp->prog);

drivers/net/ethernet/socionext/netsec.c

1796

static int netsec_xdp_setup(struct netsec_priv *priv, struct bpf_prog *prog,

drivers/net/ethernet/socionext/netsec.c

1803

if (prog && dev->mtu > 1500) {

drivers/net/ethernet/socionext/netsec.c

1812

old_prog = xchg(&priv->xdp_prog, prog);

drivers/net/ethernet/socionext/netsec.c

1828

return netsec_xdp_setup(priv, xdp->prog, xdp->extack);

drivers/net/ethernet/socionext/netsec.c

898

static u32 netsec_run_xdp(struct netsec_priv *priv, struct bpf_prog *prog,

drivers/net/ethernet/socionext/netsec.c

908

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/socionext/netsec.c

926

err = xdp_do_redirect(priv->ndev, xdp, prog);

drivers/net/ethernet/socionext/netsec.c

936

bpf_warn_invalid_xdp_action(priv->ndev, prog, act);

drivers/net/ethernet/socionext/netsec.c

939

trace_xdp_exception(priv->ndev, prog, act);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5202

struct bpf_prog *prog,

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5208

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5217

if (xdp_do_redirect(priv->dev, xdp, prog) < 0)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5223

bpf_warn_invalid_xdp_action(priv->dev, prog, act);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5226

trace_xdp_exception(priv->dev, prog, act);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5239

struct bpf_prog *prog;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5242

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5243

if (!prog) {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5248

res = __stmmac_xdp_run_prog(priv, prog, xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5409

struct bpf_prog *prog;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5534

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5535

res = __stmmac_xdp_run_prog(priv, prog, buf->xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

6879

return stmmac_xdp_set_prog(priv, bpf->prog, bpf->extack);

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

102

int stmmac_xdp_set_prog(struct stmmac_priv *priv, struct bpf_prog *prog,

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

112

if (prog && dev->mtu > ETH_DATA_LEN) {

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

120

if (!prog)

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

123

need_update = !!priv->xdp_prog != !!prog;

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

127

old_prog = xchg(&priv->xdp_prog, prog);

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.c

137

if (prog)

drivers/net/ethernet/stmicro/stmmac/stmmac_xdp.h

11

int stmmac_xdp_set_prog(struct stmmac_priv *priv, struct bpf_prog *prog,

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1179

struct bpf_prog *prog;

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1185

prog = READ_ONCE(port->xdp_prog);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1186

if (!prog)

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1189

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1216

if (unlikely(xdp_do_redirect(ndev, xdp, prog)))

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1222

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1226

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1921

struct bpf_prog *prog)

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1930

old_prog = xchg(&port->xdp_prog, prog);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1944

return am65_cpsw_xdp_prog_setup(ndev, bpf->prog);

drivers/net/ethernet/ti/cpsw_priv.c

1246

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/ti/cpsw_priv.c

1248

if (!priv->xdpi.prog && !prog)

drivers/net/ethernet/ti/cpsw_priv.c

1251

WRITE_ONCE(priv->xdp_prog, prog);

drivers/net/ethernet/ti/cpsw_priv.c

1311

struct bpf_prog *prog;

drivers/net/ethernet/ti/cpsw_priv.c

1314

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/ti/cpsw_priv.c

1315

if (!prog)

drivers/net/ethernet/ti/cpsw_priv.c

1318

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/ti/cpsw_priv.c

1335

if (xdp_do_redirect(ndev, xdp, prog))

drivers/net/ethernet/ti/cpsw_priv.c

1346

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/ti/cpsw_priv.c

1349

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1232

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1234

if (!emac->xdpi.prog && !prog)

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1237

WRITE_ONCE(emac->xdp_prog, prog);

drivers/net/hyperv/hyperv_net.h

247

int netvsc_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/hyperv/hyperv_net.h

250

int netvsc_vf_setxdp(struct net_device *vf_netdev, struct bpf_prog *prog);

drivers/net/hyperv/netvsc_bpf.c

124

int netvsc_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/hyperv/netvsc_bpf.c

133

if (!old_prog && !prog)

drivers/net/hyperv/netvsc_bpf.c

137

if (prog && buf_max > PAGE_SIZE) {

drivers/net/hyperv/netvsc_bpf.c

145

if (prog && (dev->features & NETIF_F_LRO)) {

drivers/net/hyperv/netvsc_bpf.c

152

if (prog)

drivers/net/hyperv/netvsc_bpf.c

153

bpf_prog_add(prog, nvdev->num_chn - 1);

drivers/net/hyperv/netvsc_bpf.c

156

rcu_assign_pointer(nvdev->chan_table[i].bpf_prog, prog);

drivers/net/hyperv/netvsc_bpf.c

165

int netvsc_vf_setxdp(struct net_device *vf_netdev, struct bpf_prog *prog)

drivers/net/hyperv/netvsc_bpf.c

180

if (prog)

drivers/net/hyperv/netvsc_bpf.c

181

bpf_prog_inc(prog);

drivers/net/hyperv/netvsc_bpf.c

184

xdp.prog = prog;

drivers/net/hyperv/netvsc_bpf.c

188

if (ret && prog)

drivers/net/hyperv/netvsc_bpf.c

189

bpf_prog_put(prog);

drivers/net/hyperv/netvsc_bpf.c

208

ret = netvsc_xdp_set(dev, bpf->prog, extack, nvdev);

drivers/net/hyperv/netvsc_bpf.c

213

ret = netvsc_vf_setxdp(vf_netdev, bpf->prog);

drivers/net/hyperv/netvsc_bpf.c

31

struct bpf_prog *prog;

drivers/net/hyperv/netvsc_bpf.c

38

prog = rcu_dereference(nvchan->bpf_prog);

drivers/net/hyperv/netvsc_bpf.c

40

if (!prog)

drivers/net/hyperv/netvsc_bpf.c

61

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/hyperv/netvsc_bpf.c

73

if (!xdp_do_redirect(ndev, xdp, prog)) {

drivers/net/hyperv/netvsc_bpf.c

95

trace_xdp_exception(ndev, prog, act);

drivers/net/hyperv/netvsc_bpf.c

99

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/hyperv/netvsc_drv.c

1025

struct bpf_prog *prog;

drivers/net/hyperv/netvsc_drv.c

1042

prog = dev_info->bprog;

drivers/net/hyperv/netvsc_drv.c

1043

if (prog) {

drivers/net/hyperv/netvsc_drv.c

1044

bpf_prog_inc(prog);

drivers/net/hyperv/netvsc_drv.c

1045

ret = netvsc_xdp_set(ndev, prog, NULL, nvdev);

drivers/net/hyperv/netvsc_drv.c

1047

bpf_prog_put(prog);

drivers/net/hyperv/netvsc_drv.c

2318

struct bpf_prog *prog;

drivers/net/hyperv/netvsc_drv.c

2366

prog = netvsc_xdp_get(netvsc_dev);

drivers/net/hyperv/netvsc_drv.c

2367

netvsc_vf_setxdp(vf_netdev, prog);

drivers/net/hyperv/netvsc_drv.c

932

struct bpf_prog *prog;

drivers/net/hyperv/netvsc_drv.c

951

prog = netvsc_xdp_get(nvdev);

drivers/net/hyperv/netvsc_drv.c

952

if (prog) {

drivers/net/hyperv/netvsc_drv.c

953

bpf_prog_inc(prog);

drivers/net/hyperv/netvsc_drv.c

954

dev_info->bprog = prog;

drivers/net/netdevsim/bpf.c

104

nsim_bpf_offload(struct netdevsim *ns, struct bpf_prog *prog, bool oldprog)

drivers/net/netdevsim/bpf.c

111

ns->bpf_offloaded = prog;

drivers/net/netdevsim/bpf.c

112

ns->bpf_offloaded_id = prog ? prog->aux->id : 0;

drivers/net/netdevsim/bpf.c

113

nsim_prog_set_loaded(prog, true);

drivers/net/netdevsim/bpf.c

122

struct bpf_prog *prog = cls_bpf->prog;

drivers/net/netdevsim/bpf.c

147

if (prog && !prog->aux->offload && !ns->bpf_tc_non_bound_accept) {

drivers/net/netdevsim/bpf.c

161

if (!cls_bpf->prog)

drivers/net/netdevsim/bpf.c

170

return nsim_bpf_offload(ns, cls_bpf->prog, oldprog);

drivers/net/netdevsim/bpf.c

182

if (!nsim_xdp_offload_active(ns) && !bpf->prog)

drivers/net/netdevsim/bpf.c

184

if (!nsim_xdp_offload_active(ns) && bpf->prog && ns->bpf_offloaded) {

drivers/net/netdevsim/bpf.c

189

return nsim_bpf_offload(ns, bpf->prog, nsim_xdp_offload_active(ns));

drivers/net/netdevsim/bpf.c

219

struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

230

state->prog = prog;

drivers/net/netdevsim/bpf.c

242

debugfs_create_u32("id", 0400, state->ddir, &prog->aux->id);

drivers/net/netdevsim/bpf.c

251

prog->aux->offload->dev_priv = state;

drivers/net/netdevsim/bpf.c

256

static int nsim_bpf_verifier_prep(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

259

bpf_offload_dev_priv(prog->aux->offload->offdev);

drivers/net/netdevsim/bpf.c

264

return nsim_bpf_create_prog(nsim_dev, prog);

drivers/net/netdevsim/bpf.c

267

static int nsim_bpf_translate(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

269

struct nsim_bpf_bound_prog *state = prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

275

static void nsim_bpf_destroy_prog(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

280

state = prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

301

if (bpf->prog && bpf->prog->aux->offload) {

drivers/net/netdevsim/bpf.c

305

if (bpf->prog && !bpf->prog->aux->xdp_has_frags &&

drivers/net/netdevsim/bpf.c

31

struct bpf_prog *prog;

drivers/net/netdevsim/bpf.c

318

if (!bpf->prog)

drivers/net/netdevsim/bpf.c

321

if (!bpf_prog_is_offloaded(bpf->prog->aux)) {

drivers/net/netdevsim/bpf.c

326

state = bpf->prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

656

WARN_ON(ns->xdp.prog);

drivers/net/netdevsim/bpf.c

657

WARN_ON(ns->xdp_hw.prog);

drivers/net/netdevsim/bpf.c

68

state = env->prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

72

if (insn_idx == env->prog->len - 1) {

drivers/net/netdevsim/bpf.c

89

return ns->xdp_hw.prog;

drivers/net/netdevsim/bpf.c

92

static void nsim_prog_set_loaded(struct bpf_prog *prog, bool loaded)

drivers/net/netdevsim/bpf.c

96

if (!prog || !bpf_prog_is_offloaded(prog->aux))

drivers/net/netdevsim/bpf.c

99

state = prog->aux->offload->dev_priv;

drivers/net/netdevsim/netdev.c

196

if (ns->xdp.prog && !ns->xdp.prog->aux->xdp_has_frags &&

drivers/net/netdevsim/netdev.c

423

xdp_prog = READ_ONCE(ns->xdp.prog);

drivers/net/netkit.c

44

const struct bpf_prog *prog;

drivers/net/netkit.c

46

bpf_mprog_foreach_prog(entry, fp, prog) {

drivers/net/netkit.c

48

ret = bpf_prog_run(prog, skb);

drivers/net/netkit.c

529

int netkit_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)

drivers/net/netkit.c

546

prog->type);

drivers/net/netkit.c

553

ret = bpf_mprog_attach(entry, &entry_new, prog, NULL, replace_prog,

drivers/net/netkit.c

570

int netkit_prog_detach(const union bpf_attr *attr, struct bpf_prog *prog)

drivers/net/netkit.c

588

ret = bpf_mprog_detach(entry, &entry_new, prog, NULL, attr->attach_flags,

drivers/net/netkit.c

636

ret = bpf_mprog_attach(entry, &entry_new, link->prog, link, NULL, flags,

drivers/net/netkit.c

664

ret = bpf_mprog_detach(entry, &entry_new, link->prog, link, 0, 0, 0);

drivers/net/netkit.c

692

if (oprog && link->prog != oprog) {

drivers/net/netkit.c

696

oprog = link->prog;

drivers/net/netkit.c

708

link->prog->aux->id, 0);

drivers/net/netkit.c

711

oprog = xchg(&link->prog, nprog);

drivers/net/netkit.c

776

struct bpf_prog *prog)

drivers/net/netkit.c

779

&netkit_link_lops, prog, attr->link_create.attach_type);

drivers/net/netkit.c

784

int netkit_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

drivers/net/netkit.c

804

ret = netkit_link_init(nkl, &link_primer, attr, dev, prog);

drivers/net/netkit.c

840

bpf_prog_put(tuple.prog);

drivers/net/tun.c

1126

static int tun_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/tun.c

1135

rcu_assign_pointer(tun->xdp_prog, prog);

drivers/net/tun.c

1141

if (prog)

drivers/net/tun.c

1147

if (prog)

drivers/net/tun.c

1160

return tun_xdp_set(dev, xdp->prog, xdp->extack);

drivers/net/tun.c

172

struct bpf_prog *prog;

drivers/net/tun.c

2218

struct tun_prog *prog = container_of(rcu, struct tun_prog, rcu);

drivers/net/tun.c

2220

bpf_prog_destroy(prog->prog);

drivers/net/tun.c

2221

kfree(prog);

drivers/net/tun.c

2226

struct bpf_prog *prog)

drivers/net/tun.c

2230

if (prog) {

drivers/net/tun.c

2234

new->prog = prog;

drivers/net/tun.c

2984

struct bpf_prog *prog;

drivers/net/tun.c

2991

prog = NULL;

drivers/net/tun.c

2993

prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_SOCKET_FILTER);

drivers/net/tun.c

2994

if (IS_ERR(prog))

drivers/net/tun.c

2995

return PTR_ERR(prog);

drivers/net/tun.c

2998

return __tun_set_ebpf(tun, prog_p, prog);

drivers/net/tun.c

482

struct tun_prog *prog;

drivers/net/tun.c

490

prog = rcu_dereference(tun->steering_prog);

drivers/net/tun.c

491

if (prog)

drivers/net/tun.c

492

ret = bpf_prog_run_clear_cb(prog->prog, skb);

drivers/net/tun.c

994

struct tun_prog *prog = rcu_dereference(tun->filter_prog);

drivers/net/tun.c

996

if (prog)

drivers/net/tun.c

997

len = bpf_prog_run_clear_cb(prog->prog, skb);

drivers/net/veth.c

1564

static int veth_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/veth.c

1574

priv->_xdp_prog = prog;

drivers/net/veth.c

1577

if (prog) {

drivers/net/veth.c

1589

if (prog->aux->xdp_has_frags)

drivers/net/veth.c

1621

if (!prog) {

drivers/net/veth.c

1636

if ((!!old_prog ^ !!prog) && peer)

drivers/net/veth.c

1650

return veth_xdp_set(dev, xdp->prog, xdp->extack);

drivers/net/virtio_net.c

1243

struct bpf_prog *prog;

drivers/net/virtio_net.c

1248

prog = rcu_dereference(rq->xdp_prog);

drivers/net/virtio_net.c

1249

if (prog)

drivers/net/virtio_net.c

1250

ret = virtnet_xdp_handler(prog, xdp, dev, xdp_xmit, stats);

drivers/net/virtio_net.c

1357

struct bpf_prog *prog;

drivers/net/virtio_net.c

1366

prog = rcu_dereference(rq->xdp_prog);

drivers/net/virtio_net.c

1367

if (prog) {

drivers/net/virtio_net.c

1370

ret = virtnet_xdp_handler(prog, xdp, dev, xdp_xmit,

drivers/net/virtio_net.c

5967

static int virtnet_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/virtio_net.c

5995

if (prog && !prog->aux->xdp_has_frags && dev->mtu > max_sz) {

drivers/net/virtio_net.c

6002

if (prog)

drivers/net/virtio_net.c

6013

if (!prog && !old_prog)

drivers/net/virtio_net.c

6016

if (prog)

drivers/net/virtio_net.c

6017

bpf_prog_add(prog, vi->max_queue_pairs - 1);

drivers/net/virtio_net.c

6027

if (!prog) {

drivers/net/virtio_net.c

6029

rcu_assign_pointer(vi->rq[i].xdp_prog, prog);

drivers/net/virtio_net.c

6042

if (prog) {

drivers/net/virtio_net.c

6045

rcu_assign_pointer(vi->rq[i].xdp_prog, prog);

drivers/net/virtio_net.c

6067

if (!prog) {

drivers/net/virtio_net.c

6078

if (prog)

drivers/net/virtio_net.c

6079

bpf_prog_sub(prog, vi->max_queue_pairs - 1);

drivers/net/virtio_net.c

6087

return virtnet_xdp_set(dev, xdp->prog, xdp->extack);

drivers/net/vmxnet3/vmxnet3_xdp.c

14

struct bpf_prog *prog)

drivers/net/vmxnet3/vmxnet3_xdp.c

16

rcu_assign_pointer(adapter->xdp_bpf_prog, prog);

drivers/net/vmxnet3/vmxnet3_xdp.c

262

struct bpf_prog *prog)

drivers/net/vmxnet3/vmxnet3_xdp.c

270

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/vmxnet3/vmxnet3_xdp.c

277

err = xdp_do_redirect(rq->adapter->netdev, xdp, prog);

drivers/net/vmxnet3/vmxnet3_xdp.c

296

bpf_warn_invalid_xdp_action(rq->adapter->netdev, prog, act);

drivers/net/vmxnet3/vmxnet3_xdp.c

299

trace_xdp_exception(rq->adapter->netdev, prog, act);

drivers/net/vmxnet3/vmxnet3_xdp.c

41

struct bpf_prog *new_bpf_prog = bpf->prog;

drivers/net/xen-netfront.c

1002

trace_xdp_exception(queue->info->netdev, prog, act);

drivers/net/xen-netfront.c

1011

trace_xdp_exception(queue->info->netdev, prog, act);

drivers/net/xen-netfront.c

1015

bpf_warn_invalid_xdp_action(queue->info->netdev, prog, act);

drivers/net/xen-netfront.c

1624

static int xennet_xdp_set(struct net_device *dev, struct bpf_prog *prog,

drivers/net/xen-netfront.c

1642

err = talk_to_netback_xdp(np, prog ? NETBACK_XDP_HEADROOM_ENABLE :

drivers/net/xen-netfront.c

1655

if (prog)

drivers/net/xen-netfront.c

1656

bpf_prog_add(prog, dev->real_num_tx_queues);

drivers/net/xen-netfront.c

1659

rcu_assign_pointer(np->queues[i].xdp_prog, prog);

drivers/net/xen-netfront.c

1679

return xennet_xdp_set(dev, xdp->prog, xdp->extack);

drivers/net/xen-netfront.c

968

struct xen_netif_rx_response *rx, struct bpf_prog *prog,

drivers/net/xen-netfront.c

981

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/xen-netfront.c

986

trace_xdp_exception(queue->info->netdev, prog, act);

drivers/net/xen-netfront.c

993

trace_xdp_exception(queue->info->netdev, prog, act);

drivers/net/xen-netfront.c

999

err = xdp_do_redirect(queue->info->netdev, xdp, prog);

drivers/parisc/superio.c

435

u8 prog;

drivers/parisc/superio.c

440

pci_read_config_byte(pdev, PCI_CLASS_PROG, &prog);

drivers/parisc/superio.c

441

printk("PCI: Enabled native mode for NS87415 (pif=0x%x)\n", prog);

drivers/pci/quirks.c

1444

u8 prog;

drivers/pci/quirks.c

1445

pci_read_config_byte(pdev, PCI_CLASS_PROG, &prog);

drivers/pci/quirks.c

1446

if (prog & 5) {

drivers/pci/quirks.c

1447

prog &= ~5;

drivers/pci/quirks.c

1449

pci_write_config_byte(pdev, PCI_CLASS_PROG, prog);

drivers/pci/quirks.c

1458

u8 prog;

drivers/pci/quirks.c

1460

pci_read_config_byte(pdev, PCI_CLASS_PROG, &prog);

drivers/pci/quirks.c

1462

if (((prog & 1) && !(prog & 4)) || ((prog & 4) && !(prog & 1))) {

drivers/pci/quirks.c

1464

prog &= ~5;

drivers/pci/quirks.c

1466

pci_write_config_byte(pdev, PCI_CLASS_PROG, prog);

drivers/rtc/rtc-mpfs.c

101

u32 ctrl, prog;

drivers/rtc/rtc-mpfs.c

115

ret = read_poll_timeout(readl, prog, prog & CONTROL_UPLOAD_BIT, 0, UPLOAD_TIMEOUT_US,

drivers/scsi/aic94xx/aic94xx_seq.c

178

const u32 *prog = (u32 *) _prog;

drivers/scsi/aic94xx/aic94xx_seq.c

181

for (i = 0; i < size; i += 4, prog++, addr += 4) {

drivers/scsi/aic94xx/aic94xx_seq.c

184

if (le32_to_cpu(*prog) != val) {

drivers/scsi/aic94xx/aic94xx_seq.c

188

i, val, le32_to_cpu(*prog));

drivers/scsi/aic94xx/aic94xx_seq.c

214

const u32 *prog = (u32 *) _prog;

drivers/scsi/aic94xx/aic94xx_seq.c

222

i += 4, prog++, size-=4) {

drivers/scsi/aic94xx/aic94xx_seq.c

226

if (le32_to_cpu(*prog) != val) {

drivers/scsi/aic94xx/aic94xx_seq.c

236

(int)((u8 *)prog-_prog));

drivers/scsi/aic94xx/aic94xx_seq.c

249

static int asd_verify_seq(struct asd_ha_struct *asd_ha, const u8 *prog,

drivers/scsi/aic94xx/aic94xx_seq.c

253

return asd_verify_cseq(asd_ha, prog, size);

drivers/scsi/aic94xx/aic94xx_seq.c

258

err = asd_verify_lseq(asd_ha, prog, size, lseq);

drivers/scsi/aic94xx/aic94xx_seq.c

271

const u8 * const prog, u32 size, u8 lseq_mask)

drivers/scsi/aic94xx/aic94xx_seq.c

309

memcpy(token->vaddr, prog + page*MAX_DMA_OVLY_COUNT, left);

drivers/scsi/aic94xx/aic94xx_seq.c

338

return err ? : asd_verify_seq(asd_ha, prog, size, lseq_mask);

drivers/scsi/aic94xx/aic94xx_seq.c

346

const u32 *prog = (u32 *) _prog;

drivers/scsi/aic94xx/aic94xx_seq.c

365

for (i = 0; i < size; i += 4, prog++)

drivers/scsi/aic94xx/aic94xx_seq.c

366

asd_write_reg_dword(asd_ha, SPIODATA, *prog);

drivers/scsi/megaraid/megaraid_sas.h

2134

struct megasas_progress prog;

drivers/scsi/megaraid/megaraid_sas.h

2168

struct megasas_progress prog;

fs/bpf_fs_kfuncs.c

368

static int bpf_fs_kfuncs_filter(const struct bpf_prog *prog, u32 kfunc_id)

fs/bpf_fs_kfuncs.c

371

prog->type == BPF_PROG_TYPE_LSM)

fs/bpf_fs_kfuncs.c

401

bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog)

fs/bpf_fs_kfuncs.c

403

return btf_id_set_contains(&d_inode_locked_hooks, prog->aux->attach_btf_id);

fs/lockd/mon.c

41

u32 prog; /* RPC callback info */

fs/lockd/mon.c

456

*p++ = cpu_to_be32(argp->prog);

fs/lockd/mon.c

98

.prog = NLM_PROGRAM,

fs/nfsd/trace.h

1531

__field(u32, prog)

fs/nfsd/trace.h

1538

__entry->prog = conn->cb_prog;

fs/nfsd/trace.h

1544

__entry->prog, __entry->ident)

fs/verity/measure.c

168

static int bpf_get_fsverity_digest_filter(const struct bpf_prog *prog, u32 kfunc_id)

fs/verity/measure.c

174

return prog->type != BPF_PROG_TYPE_LSM ? -EACCES : 0;

include/linux/bpf-cgroup.h

107

struct bpf_prog *prog;

include/linux/bpf-cgroup.h

166

struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog,

include/linux/bpf-cgroup.h

419

enum bpf_prog_type ptype, struct bpf_prog *prog);

include/linux/bpf-cgroup.h

422

int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/bpf-cgroup.h

427

cgroup_common_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf-cgroup.h

437

struct bpf_prog *prog)

include/linux/bpf-cgroup.h

449

struct bpf_prog *prog)

include/linux/bpf-cgroup.h

461

cgroup_common_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

include/linux/bpf-cgroup.h

469

struct bpf_prog *prog, enum bpf_cgroup_storage_type stype) { return NULL; }

include/linux/bpf-netns.h

32

struct bpf_prog *prog);

include/linux/bpf-netns.h

35

struct bpf_prog *prog);

include/linux/bpf-netns.h

44

struct bpf_prog *prog)

include/linux/bpf-netns.h

56

struct bpf_prog *prog)

include/linux/bpf.h

1093

int (*test_run)(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

1102

const struct bpf_prog *prog);

include/linux/bpf.h

1108

const struct bpf_prog *prog,

include/linux/bpf.h

1111

const struct bpf_prog *prog);

include/linux/bpf.h

1112

int (*gen_epilogue)(struct bpf_insn *insn, const struct bpf_prog *prog,

include/linux/bpf.h

1119

struct bpf_prog *prog, u32 *target_size);

include/linux/bpf.h

1135

int (*prepare)(struct bpf_prog *prog);

include/linux/bpf.h

1136

int (*translate)(struct bpf_prog *prog);

include/linux/bpf.h

1137

void (*destroy)(struct bpf_prog *prog);

include/linux/bpf.h

1141

struct bpf_prog *prog;

include/linux/bpf.h

1274

u64 notrace __bpf_prog_enter_sleepable_recur(struct bpf_prog *prog,

include/linux/bpf.h

1276

void notrace __bpf_prog_exit_sleepable_recur(struct bpf_prog *prog, u64 start,

include/linux/bpf.h

1280

typedef u64 (*bpf_trampoline_enter_t)(struct bpf_prog *prog,

include/linux/bpf.h

1282

typedef void (*bpf_trampoline_exit_t)(struct bpf_prog *prog, u64 start,

include/linux/bpf.h

1284

bpf_trampoline_enter_t bpf_trampoline_enter(const struct bpf_prog *prog);

include/linux/bpf.h

1285

bpf_trampoline_exit_t bpf_trampoline_exit(const struct bpf_prog *prog);

include/linux/bpf.h

1305

bool prog;

include/linux/bpf.h

1373

struct bpf_prog *prog;

include/linux/bpf.h

1543

bool bpf_prog_has_trampoline(const struct bpf_prog *prog);

include/linux/bpf.h

1574

static inline bool bpf_prog_has_trampoline(const struct bpf_prog *prog)

include/linux/bpf.h

1702

void (*recursion_detected)(struct bpf_prog *prog); /* callback if recursion is detected */

include/linux/bpf.h

1723

struct bpf_prog *prog;

include/linux/bpf.h

1827

struct bpf_prog *prog;

include/linux/bpf.h

1992

const struct bpf_prog *prog);

include/linux/bpf.h

2043

static inline bool bpf_prog_get_recursion_context(struct bpf_prog *prog)

include/linux/bpf.h

2047

u8 *active = this_cpu_ptr(prog->active);

include/linux/bpf.h

2059

return this_cpu_inc_return(*(int __percpu *)(prog->active)) == 1;

include/linux/bpf.h

2063

static inline void bpf_prog_put_recursion_context(struct bpf_prog *prog)

include/linux/bpf.h

2067

u8 *active = this_cpu_ptr(prog->active);

include/linux/bpf.h

2073

this_cpu_dec(*(int __percpu *)(prog->active));

include/linux/bpf.h

2119

int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map);

include/linux/bpf.h

2120

void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog);

include/linux/bpf.h

2137

int bpf_struct_ops_test_run(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

2169

static inline int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map)

include/linux/bpf.h

2173

static inline void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog)

include/linux/bpf.h

2196

if (fentries.links[i]->link.prog->expected_attach_type == BPF_TRACE_FSESSION)

include/linux/bpf.h

2205

return link->link.prog->call_session_cookie;

include/linux/bpf.h

2221

int bpf_prog_ctx_arg_info_init(struct bpf_prog *prog,

include/linux/bpf.h

2225

int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

include/linux/bpf.h

2228

void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog);

include/linux/bpf.h

2230

static inline int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

include/linux/bpf.h

2236

static inline void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog)

include/linux/bpf.h

2341

struct bpf_prog *prog,

include/linux/bpf.h

2360

struct bpf_prog *prog;

include/linux/bpf.h

2398

struct bpf_prog *prog);

include/linux/bpf.h

2451

typedef u32 (*bpf_prog_run_fn)(const struct bpf_prog *prog, const void *ctx);

include/linux/bpf.h

2458

const struct bpf_prog *prog;

include/linux/bpf.h

2473

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

2475

ret &= run_prog(prog, ctx);

include/linux/bpf.h

2498

const struct bpf_prog *prog;

include/linux/bpf.h

2515

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

2516

if (!prog->sleepable)

include/linux/bpf.h

2520

ret &= run_prog(prog, ctx);

include/linux/bpf.h

2523

if (!prog->sleepable)

include/linux/bpf.h

2583

void bpf_prog_add(struct bpf_prog *prog, int i);

include/linux/bpf.h

2584

void bpf_prog_sub(struct bpf_prog *prog, int i);

include/linux/bpf.h

2585

void bpf_prog_inc(struct bpf_prog *prog);

include/linux/bpf.h

2586

struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);

include/linux/bpf.h

2587

void bpf_prog_put(struct bpf_prog *prog);

include/linux/bpf.h

2589

void bpf_prog_free_id(struct bpf_prog *prog);

include/linux/bpf.h

2759

int bpf_prog_new_fd(struct bpf_prog *prog);

include/linux/bpf.h

2762

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

2765

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

2837

typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog,

include/linux/bpf.h

2882

int bpf_iter_prog_supported(struct bpf_prog *prog);

include/linux/bpf.h

2884

bpf_iter_get_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf.h

2885

int bpf_iter_link_attach(const union bpf_attr *attr, bpfptr_t uattr, struct bpf_prog *prog);

include/linux/bpf.h

2889

int bpf_iter_run_prog(struct bpf_prog *prog, void *ctx);

include/linux/bpf.h

2963

int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

2965

int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

2967

int bpf_prog_test_run_tracing(struct bpf_prog *prog,

include/linux/bpf.h

2970

int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

include/linux/bpf.h

2973

int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,

include/linux/bpf.h

2976

int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,

include/linux/bpf.h

2979

int bpf_prog_test_run_nf(struct bpf_prog *prog,

include/linux/bpf.h

2983

const struct bpf_prog *prog,

include/linux/bpf.h

3000

const struct bpf_prog *prog,

include/linux/bpf.h

3005

return btf_ctx_access(off, size, type, prog, info);

include/linux/bpf.h

3025

int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,

include/linux/bpf.h

3036

const struct bpf_prog *prog);

include/linux/bpf.h

3039

bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog);

include/linux/bpf.h

3041

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

include/linux/bpf.h

3043

int bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

include/linux/bpf.h

3077

void notrace bpf_prog_inc_misses_counter(struct bpf_prog *prog);

include/linux/bpf.h

3098

static inline void bpf_prog_add(struct bpf_prog *prog, int i)

include/linux/bpf.h

3102

static inline void bpf_prog_sub(struct bpf_prog *prog, int i)

include/linux/bpf.h

3106

static inline void bpf_prog_put(struct bpf_prog *prog)

include/linux/bpf.h

3110

static inline void bpf_prog_inc(struct bpf_prog *prog)

include/linux/bpf.h

3115

bpf_prog_inc_not_zero(struct bpf_prog *prog)

include/linux/bpf.h

3122

struct bpf_prog *prog, enum bpf_attach_type attach_type)

include/linux/bpf.h

3127

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

3259

static inline int bpf_prog_test_run_xdp(struct bpf_prog *prog,

include/linux/bpf.h

3266

static inline int bpf_prog_test_run_skb(struct bpf_prog *prog,

include/linux/bpf.h

3273

static inline int bpf_prog_test_run_tracing(struct bpf_prog *prog,

include/linux/bpf.h

3280

static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

include/linux/bpf.h

3287

static inline int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,

include/linux/bpf.h

3313

bpf_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

include/linux/bpf.h

3322

static inline bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog)

include/linux/bpf.h

3328

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

include/linux/bpf.h

3335

bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

include/linux/bpf.h

3351

static inline void bpf_prog_inc_misses_counter(struct bpf_prog *prog)

include/linux/bpf.h

3408

int bpf_prog_offload_compile(struct bpf_prog *prog);

include/linux/bpf.h

3409

void bpf_prog_dev_bound_destroy(struct bpf_prog *prog);

include/linux/bpf.h

3411

struct bpf_prog *prog);

include/linux/bpf.h

3422

bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map);

include/linux/bpf.h

3432

bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev);

include/linux/bpf.h

3439

void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog, u32 func_id);

include/linux/bpf.h

3440

int bpf_prog_dev_bound_init(struct bpf_prog *prog, union bpf_attr *attr);

include/linux/bpf.h

3464

int bpf_prog_test_run_syscall(struct bpf_prog *prog,

include/linux/bpf.h

3468

int sock_map_get_from_fd(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/bpf.h

3473

int sock_map_link_create(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/bpf.h

3485

static inline void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog,

include/linux/bpf.h

3491

static inline int bpf_prog_dev_bound_init(struct bpf_prog *prog,

include/linux/bpf.h

3541

static inline int bpf_prog_test_run_syscall(struct bpf_prog *prog,

include/linux/bpf.h

3550

struct bpf_prog *prog)

include/linux/bpf.h

3573

static inline int sock_map_link_create(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/bpf.h

3584

struct bpf_prog *prog;

include/linux/bpf.h

3590

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

3591

bpf_prog_inc_misses_counter(prog);

include/linux/bpf.h

3743

enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf.h

3759

struct bpf_prog *prog,

include/linux/bpf.h

3779

struct bpf_prog *prog,

include/linux/bpf.h

3808

struct bpf_prog *prog,

include/linux/bpf.h

3817

struct bpf_prog *prog,

include/linux/bpf.h

3830

struct bpf_prog *prog,

include/linux/bpf.h

3845

struct bpf_prog *prog,

include/linux/bpf.h

3897

void bpf_prog_stream_init(struct bpf_prog *prog);

include/linux/bpf.h

3898

void bpf_prog_stream_free(struct bpf_prog *prog);

include/linux/bpf.h

3899

int bpf_prog_stream_read(struct bpf_prog *prog, enum bpf_stream_id stream_id, void __user *buf, int len);

include/linux/bpf.h

3904

int bpf_stream_stage_commit(struct bpf_stream_stage *ss, struct bpf_prog *prog,

include/linux/bpf.h

3911

#define bpf_stream_stage(ss, prog, stream_id, expr) \

include/linux/bpf.h

3915

bpf_stream_stage_commit(&ss, prog, stream_id); \

include/linux/bpf.h

3948

static inline bool bpf_is_subprog(const struct bpf_prog *prog)

include/linux/bpf.h

3950

return prog->aux->func_idx != 0;

include/linux/bpf.h

3953

int bpf_prog_get_file_line(struct bpf_prog *prog, unsigned long ip, const char **filep,

include/linux/bpf.h

3957

int bpf_insn_array_init(struct bpf_map *map, const struct bpf_prog *prog);

include/linux/bpf.h

3964

void bpf_prog_update_insn_ptrs(struct bpf_prog *prog, u32 *offsets, void *image);

include/linux/bpf.h

3967

bpf_prog_update_insn_ptrs(struct bpf_prog *prog, u32 *offsets, void *image)

include/linux/bpf.h

965

bool (*allowed)(const struct bpf_prog *prog);

include/linux/bpf_lirc.h

13

struct bpf_prog *prog)

include/linux/bpf_lirc.h

8

int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/bpf_lsm.h

103

static inline bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog)

include/linux/bpf_lsm.h

29

const struct bpf_prog *prog);

include/linux/bpf_lsm.h

32

bool bpf_lsm_is_trusted(const struct bpf_prog *prog);

include/linux/bpf_lsm.h

47

void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, bpf_func_t *bpf_func);

include/linux/bpf_lsm.h

49

int bpf_lsm_get_retval_range(const struct bpf_prog *prog,

include/linux/bpf_lsm.h

54

bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog);

include/linux/bpf_lsm.h

63

static inline bool bpf_lsm_is_trusted(const struct bpf_prog *prog)

include/linux/bpf_lsm.h

69

const struct bpf_prog *prog)

include/linux/bpf_lsm.h

84

static inline void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,

include/linux/bpf_lsm.h

89

static inline int bpf_lsm_get_retval_range(const struct bpf_prog *prog,

include/linux/bpf_mprog.h

118

t.prog = READ_ONCE(fp->prog); \

include/linux/bpf_mprog.h

120

t.prog; \

include/linux/bpf_mprog.h

126

(p = READ_ONCE(fp->prog)); \

include/linux/bpf_mprog.h

132

struct bpf_prog *prog;

include/linux/bpf_mprog.h

154

struct bpf_prog *prog;

include/linux/bpf_mprog.h

203

struct bpf_prog *prog)

include/linux/bpf_mprog.h

209

if (tmp == prog)

include/linux/bpf_mprog.h

220

entry->parent->ref = tuple->prog;

include/linux/bpf_mprog.h

316

WRITE_ONCE(fp->prog, tuple->prog);

include/linux/bpf_mprog.h

328

struct bpf_prog *prog, struct bpf_link *link,

include/linux/bpf_verifier.h

751

struct bpf_prog *prog; /* eBPF program being verified */

include/linux/bpf_verifier.h

858

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

include/linux/bpf_verifier.h

906

int bpf_prog_offload_verifier_prep(struct bpf_prog *prog);

include/linux/bpf_verifier.h

936

const struct bpf_prog *prog,

include/linux/bpf_verifier.h

959

static inline enum bpf_prog_type resolve_prog_type(const struct bpf_prog *prog)

include/linux/bpf_verifier.h

961

return (prog->type == BPF_PROG_TYPE_EXT && prog->aux->saved_dst_prog_type) ?

include/linux/bpf_verifier.h

962

prog->aux->saved_dst_prog_type : prog->type;

include/linux/bpf_verifier.h

965

static inline bool bpf_prog_check_recur(const struct bpf_prog *prog)

include/linux/bpf_verifier.h

967

switch (resolve_prog_type(prog)) {

include/linux/bpf_verifier.h

969

return prog->expected_attach_type != BPF_TRACE_ITER;

include/linux/bpf_verifier.h

971

return prog->aux->jits_use_priv_stack;

include/linux/btf.h

119

typedef int (*btf_kfunc_filter_t)(const struct bpf_prog *prog, u32 kfunc_id);

include/linux/btf.h

578

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog);

include/linux/btf.h

579

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

580

bool btf_kfunc_is_allowed(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

582

const struct bpf_prog *prog);

include/linux/btf.h

643

struct bpf_prog *prog)

include/linux/filter.h

1005

if (unlikely(prog->cb_access))

include/linux/filter.h

1008

res = bpf_prog_run_pin_on_cpu(prog, skb);

include/linux/filter.h

1018

void bpf_prog_change_xdp(struct bpf_prog *prev_prog, struct bpf_prog *prog);

include/linux/filter.h

1020

static inline u32 bpf_prog_insn_size(const struct bpf_prog *prog)

include/linux/filter.h

1022

return prog->len * sizeof(struct bpf_insn);

include/linux/filter.h

1031

static inline bool bpf_prog_was_classic(const struct bpf_prog *prog)

include/linux/filter.h

1038

return prog->type == BPF_PROG_TYPE_UNSPEC;

include/linux/filter.h

1116

void bpf_prog_fill_jited_linfo(struct bpf_prog *prog,

include/linux/filter.h

1118

int bpf_prog_alloc_jited_linfo(struct bpf_prog *prog);

include/linux/filter.h

1119

void bpf_prog_jit_attempt_done(struct bpf_prog *prog);

include/linux/filter.h

1144

void sk_reuseport_prog_free(struct bpf_prog *prog);

include/linux/filter.h

1156

struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog);

include/linux/filter.h

1157

void bpf_jit_compile(struct bpf_prog *prog);

include/linux/filter.h

1185

struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,

include/linux/filter.h

1187

int bpf_remove_insns(struct bpf_prog *prog, u32 off, u32 cnt);

include/linux/filter.h

1232

struct xdp_buff *xdp, const struct bpf_prog *prog);

include/linux/filter.h

1235

const struct bpf_prog *prog);

include/linux/filter.h

1239

const struct bpf_prog *prog);

include/linux/filter.h

1243

const struct bpf_prog *prog, u32 act);

include/linux/filter.h

1247

struct bpf_prog *prog, struct sk_buff *skb,

include/linux/filter.h

1253

struct bpf_prog *prog, struct sk_buff *skb,

include/linux/filter.h

1304

int bpf_jit_add_poke_descriptor(struct bpf_prog *prog,

include/linux/filter.h

1307

int bpf_jit_get_func_addr(const struct bpf_prog *prog,

include/linux/filter.h

1311

const char *bpf_jit_get_prog_name(struct bpf_prog *prog);

include/linux/filter.h

1346

static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)

include/linux/filter.h

1354

if (!prog->jit_requested)

include/linux/filter.h

1358

if (bpf_jit_harden == 1 && bpf_token_capable(prog->aux->token, CAP_BPF))

include/linux/filter.h

1396

static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)

include/linux/filter.h

1407

bpf_jit_add_poke_descriptor(struct bpf_prog *prog,

include/linux/filter.h

1645

while ((_prog = READ_ONCE(_item->prog))) { \

include/linux/filter.h

685

struct bpf_prog *prog;

include/linux/filter.h

700

static __always_inline u32 __bpf_prog_run(const struct bpf_prog *prog,

include/linux/filter.h

712

ret = dfunc(ctx, prog->insnsi, prog->bpf_func);

include/linux/filter.h

715

if (likely(prog->stats)) {

include/linux/filter.h

716

stats = this_cpu_ptr(prog->stats);

include/linux/filter.h

723

ret = dfunc(ctx, prog->insnsi, prog->bpf_func);

include/linux/filter.h

728

static __always_inline u32 bpf_prog_run(const struct bpf_prog *prog, const void *ctx)

include/linux/filter.h

730

return __bpf_prog_run(prog, ctx, bpf_dispatcher_nop_func);

include/linux/filter.h

741

static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,

include/linux/filter.h

747

ret = bpf_prog_run(prog, ctx);

include/linux/filter.h

907

const struct bpf_prog *prog,

include/linux/filter.h

918

res = bpf_prog_run(prog, skb);

include/linux/filter.h

967

static inline u32 __bpf_prog_run_save_cb(const struct bpf_prog *prog,

include/linux/filter.h

975

if (unlikely(prog->cb_access)) {

include/linux/filter.h

980

res = bpf_prog_run(prog, skb);

include/linux/filter.h

982

if (unlikely(prog->cb_access))

include/linux/filter.h

988

static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,

include/linux/filter.h

994

res = __bpf_prog_run_save_cb(prog, skb);

include/linux/filter.h

999

static inline u32 bpf_prog_run_clear_cb(const struct bpf_prog *prog,

include/linux/lsm_hook_defs.h

433

LSM_HOOK(int, 0, bpf_prog, struct bpf_prog *prog)

include/linux/lsm_hook_defs.h

437

LSM_HOOK(int, 0, bpf_prog_load, struct bpf_prog *prog, union bpf_attr *attr,

include/linux/lsm_hook_defs.h

439

LSM_HOOK(void, LSM_RET_VOID, bpf_prog_free, struct bpf_prog *prog)

include/linux/netdevice.h

1006

struct bpf_prog *prog;

include/linux/netdevice.h

1016

struct bpf_prog *prog;

include/linux/netdevice.h

4325

int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/perf_event.h

1669

extern void perf_event_bpf_event(struct bpf_prog *prog,

include/linux/perf_event.h

1998

static inline void perf_event_bpf_event(struct bpf_prog *prog,

include/linux/perf_event.h

906

struct bpf_prog *prog;

include/linux/security.h

2269

extern int security_bpf_prog(struct bpf_prog *prog);

include/linux/security.h

2273

extern int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

include/linux/security.h

2275

extern void security_bpf_prog_free(struct bpf_prog *prog);

include/linux/security.h

2293

static inline int security_bpf_prog(struct bpf_prog *prog)

include/linux/security.h

2307

static inline int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

include/linux/security.h

2313

static inline void security_bpf_prog_free(struct bpf_prog *prog)

include/linux/skbuff.h

1590

u32 bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx,

include/linux/skbuff.h

3713

const struct bpf_prog *prog);

include/linux/skmsg.h

519

struct bpf_prog *prog)

include/linux/skmsg.h

521

prog = xchg(pprog, prog);

include/linux/skmsg.h

522

if (prog)

include/linux/skmsg.h

523

bpf_prog_put(prog);

include/linux/skmsg.h

527

struct bpf_prog *prog,

include/linux/skmsg.h

530

if (cmpxchg(pprog, old, prog) != old)

include/linux/sunrpc/svc.h

448

struct svc_serv * svc_create_pooled(struct svc_program *prog,

include/linux/trace_events.h

770

int perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog, u64 bpf_cookie);

include/linux/trace_events.h

784

int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/trace_events.h

785

int bpf_uprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/linux/trace_events.h

793

perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog, u64 bpf_cookie)

include/linux/trace_events.h

829

bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/trace_events.h

834

bpf_uprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/trace_events.h

899

int perf_event_set_bpf_prog(struct perf_event *event, struct bpf_prog *prog, u64 bpf_cookie);

include/net/flow_dissector.h

485

struct bpf_prog *prog);

include/net/libeth/xdp.h

1141

#define libeth_xdp_tx_init_bulk(bq, prog, dev, xdpsqs, num) \

include/net/libeth/xdp.h

1142

__libeth_xdp_tx_init_bulk(bq, prog, dev, xdpsqs, num, false, \

include/net/libeth/xdp.h

1152

ub->prog = rcu_dereference(pr); \

include/net/libeth/xdp.h

1156

ub->prog = NULL; \

include/net/libeth/xdp.h

1360

act = bpf_prog_run_xdp(bq->prog, &xdp->base);

include/net/libeth/xdp.h

1374

if (unlikely(xdp_do_redirect(bq->dev, &xdp->base, bq->prog)))

include/net/libeth/xdp.h

1491

if (!bq || !run || !bq->prog)

include/net/libeth/xdp.h

385

const struct bpf_prog *prog;

include/net/libeth/xsk.h

329

#define libeth_xsk_tx_init_bulk(bq, prog, dev, xdpsqs, num) \

include/net/libeth/xsk.h

330

__libeth_xdp_tx_init_bulk(bq, prog, dev, xdpsqs, num, true, \

include/net/libeth/xsk.h

396

act = bpf_prog_run_xdp(bq->prog, &xdp->base);

include/net/libeth/xsk.h

401

ret = xdp_do_redirect(bq->dev, &xdp->base, bq->prog);

include/net/mana/mana.h

588

void mana_chn_setxdp(struct mana_port_context *apc, struct bpf_prog *prog);

include/net/netfilter/nf_bpf_link.h

11

static inline int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

include/net/netfilter/nf_bpf_link.h

9

int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/netkit.h

10

int netkit_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/netkit.h

11

int netkit_prog_detach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/netkit.h

16

struct bpf_prog *prog)

include/net/netkit.h

22

struct bpf_prog *prog)

include/net/netkit.h

28

struct bpf_prog *prog)

include/net/netkit.h

9

int netkit_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/pkt_cls.h

809

struct bpf_prog *prog;

include/net/sock_reuseport.h

28

struct bpf_prog __rcu *prog; /* optional BPF sock selector */

include/net/sock_reuseport.h

44

extern int reuseport_attach_prog(struct sock *sk, struct bpf_prog *prog);

include/net/tcx.h

163

int tcx_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/tcx.h

164

int tcx_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/tcx.h

165

int tcx_prog_detach(const union bpf_attr *attr, struct bpf_prog *prog);

include/net/tcx.h

179

struct bpf_prog *prog)

include/net/tcx.h

185

struct bpf_prog *prog)

include/net/tcx.h

191

struct bpf_prog *prog)

include/net/xdp.h

559

struct bpf_prog *prog;

include/net/xdp.h

689

static __always_inline u32 bpf_prog_run_xdp(const struct bpf_prog *prog,

include/net/xdp.h

696

u32 act = __bpf_prog_run(prog, xdp, BPF_DISPATCHER_FUNC(xdp));

include/sound/opl3.h

253

unsigned char prog;

include/sound/opl3.h

363

int prog, int bank, int type,

include/sound/opl3.h

367

struct fm_patch *snd_opl3_find_patch(struct snd_opl3 *opl3, int prog, int bank,

include/uapi/sound/asound_fm.h

112

unsigned char prog;

io_uring/bpf_filter.c

129

bpf_prog_destroy(f->prog);

io_uring/bpf_filter.c

19

struct bpf_prog *prog;

io_uring/bpf_filter.c

365

struct bpf_prog *prog;

io_uring/bpf_filter.c

376

ret = bpf_prog_create_from_user(&prog, &fprog,

io_uring/bpf_filter.c

410

filter->prog = prog;

io_uring/bpf_filter.c

455

bpf_prog_destroy(prog);

io_uring/bpf_filter.c

88

ret = bpf_prog_run_pin_on_cpu(filter->prog, &bpf_ctx);

kernel/bpf/arena.c

935

struct bpf_prog *prog;

kernel/bpf/arena.c

944

prog = bpf_prog_ksym_find(fault_ip);

kernel/bpf/arena.c

946

if (!prog)

kernel/bpf/arena.c

950

prog = prog->aux->main_prog_aux->prog;

kernel/bpf/arena.c

952

user_vm_start = bpf_arena_get_user_vm_start(prog->aux->arena);

kernel/bpf/arena.c

955

bpf_stream_stage(ss, prog, BPF_STDERR, ({

kernel/bpf/arraymap.c

1000

mutex_lock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

1001

prog->aux->prog_array_member_cnt--;

kernel/bpf/arraymap.c

1002

mutex_unlock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

1004

bpf_prog_put(prog);

kernel/bpf/arraymap.c

654

struct bpf_prog *prog;

kernel/bpf/arraymap.c

660

prog = bpf_iter_get_info(&meta, v == NULL);

kernel/bpf/arraymap.c

661

if (!prog)

kernel/bpf/arraymap.c

684

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/arraymap.c

966

struct bpf_prog *prog = bpf_prog_get(fd);

kernel/bpf/arraymap.c

969

if (IS_ERR(prog))

kernel/bpf/arraymap.c

970

return prog;

kernel/bpf/arraymap.c

972

if (prog->type == BPF_PROG_TYPE_EXT ||

kernel/bpf/arraymap.c

973

!bpf_prog_map_compatible(map, prog)) {

kernel/bpf/arraymap.c

974

bpf_prog_put(prog);

kernel/bpf/arraymap.c

978

mutex_lock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

979

is_extended = prog->aux->is_extended;

kernel/bpf/arraymap.c

981

prog->aux->prog_array_member_cnt++;

kernel/bpf/arraymap.c

982

mutex_unlock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

989

bpf_prog_put(prog);

kernel/bpf/arraymap.c

993

return prog;

kernel/bpf/arraymap.c

998

struct bpf_prog *prog = ptr;

kernel/bpf/bpf_insn_array.c

163

const struct bpf_prog *prog)

kernel/bpf/bpf_insn_array.c

171

if (off >= prog->len)

kernel/bpf/bpf_insn_array.c

175

if (prog->insnsi[off-1].code == (BPF_LD | BPF_DW | BPF_IMM))

kernel/bpf/bpf_insn_array.c

183

int bpf_insn_array_init(struct bpf_map *map, const struct bpf_prog *prog)

kernel/bpf/bpf_insn_array.c

192

if (!valid_offsets(insn_array, prog))

kernel/bpf/bpf_insn_array.c

274

void bpf_prog_update_insn_ptrs(struct bpf_prog *prog, u32 *offsets, void *image)

kernel/bpf/bpf_insn_array.c

284

for (i = 0; i < prog->aux->used_map_cnt; i++) {

kernel/bpf/bpf_insn_array.c

285

map = prog->aux->used_maps[i];

kernel/bpf/bpf_insn_array.c

294

if (xlated_off < prog->aux->subprog_start)

kernel/bpf/bpf_insn_array.c

296

xlated_off -= prog->aux->subprog_start;

kernel/bpf/bpf_insn_array.c

297

if (xlated_off >= prog->len)

kernel/bpf/bpf_iter.c

25

struct bpf_prog *prog;

kernel/bpf/bpf_iter.c

277

bpf_prog_put(iter_priv->prog);

kernel/bpf/bpf_iter.c

332

struct bpf_prog *prog)

kernel/bpf/bpf_iter.c

334

tinfo->btf_id = prog->aux->attach_btf_id;

kernel/bpf/bpf_iter.c

337

int bpf_iter_prog_supported(struct bpf_prog *prog)

kernel/bpf/bpf_iter.c

339

const char *attach_fname = prog->aux->attach_func_name;

kernel/bpf/bpf_iter.c

341

u32 prog_btf_id = prog->aux->attach_btf_id;

kernel/bpf/bpf_iter.c

355

cache_btf_id(iter, prog);

kernel/bpf/bpf_iter.c

365

return bpf_prog_ctx_arg_info_init(prog, tinfo->reg_info->ctx_arg_info,

kernel/bpf/bpf_iter.c

370

bpf_iter_get_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/bpf_iter.c

377

if (tinfo->btf_id == prog->aux->attach_btf_id) {

kernel/bpf/bpf_iter.c

382

fn = reg_info->get_func_proto(func_id, prog);

kernel/bpf/bpf_iter.c

415

if (old_prog && link->prog != old_prog) {

kernel/bpf/bpf_iter.c

420

if (link->prog->type != new_prog->type ||

kernel/bpf/bpf_iter.c

421

link->prog->expected_attach_type != new_prog->expected_attach_type ||

kernel/bpf/bpf_iter.c

422

link->prog->aux->attach_btf_id != new_prog->aux->attach_btf_id) {

kernel/bpf/bpf_iter.c

427

old_prog = xchg(&link->prog, new_prog);

kernel/bpf/bpf_iter.c

505

struct bpf_prog *prog)

kernel/bpf/bpf_iter.c

535

prog_btf_id = prog->aux->attach_btf_id;

kernel/bpf/bpf_iter.c

548

if (prog->sleepable && !bpf_iter_target_support_resched(tinfo))

kernel/bpf/bpf_iter.c

555

bpf_link_init(&link->link, BPF_LINK_TYPE_ITER, &bpf_iter_link_lops, prog,

kernel/bpf/bpf_iter.c

566

err = tinfo->reg_info->attach_target(prog, &linfo, &link->aux);

kernel/bpf/bpf_iter.c

579

struct bpf_prog *prog)

kernel/bpf/bpf_iter.c

583

priv_data->prog = prog;

kernel/bpf/bpf_iter.c

594

struct bpf_prog *prog;

kernel/bpf/bpf_iter.c

600

prog = link->link.prog;

kernel/bpf/bpf_iter.c

601

bpf_prog_inc(prog);

kernel/bpf/bpf_iter.c

620

init_seq_meta(priv_data, tinfo, seq_info, prog);

kernel/bpf/bpf_iter.c

630

bpf_prog_put(prog);

kernel/bpf/bpf_iter.c

677

return iter_priv->prog;

kernel/bpf/bpf_iter.c

680

int bpf_iter_run_prog(struct bpf_prog *prog, void *ctx)

kernel/bpf/bpf_iter.c

685

if (prog->sleepable) {

kernel/bpf/bpf_iter.c

690

ret = bpf_prog_run(prog, ctx);

kernel/bpf/bpf_iter.c

697

ret = bpf_prog_run(prog, ctx);

kernel/bpf/bpf_lsm.c

104

args = btf_params(prog->aux->attach_func_proto);

kernel/bpf/bpf_lsm.c

117

const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

119

u32 btf_id = prog->aux->attach_btf_id;

kernel/bpf/bpf_lsm.c

120

const char *func_name = prog->aux->attach_func_name;

kernel/bpf/bpf_lsm.c

122

if (!prog->gpl_compatible) {

kernel/bpf/bpf_lsm.c

171

static bool bpf_ima_inode_hash_allowed(const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

173

return bpf_lsm_is_sleepable_hook(prog->aux->attach_btf_id);

kernel/bpf/bpf_lsm.c

225

bpf_lsm_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

229

if (prog->expected_attach_type == BPF_LSM_CGROUP) {

kernel/bpf/bpf_lsm.c

230

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/bpf_lsm.c

257

return bpf_prog_has_trampoline(prog) ? &bpf_get_attach_cookie_proto : NULL;

kernel/bpf/bpf_lsm.c

260

if (prog->expected_attach_type != BPF_LSM_CGROUP)

kernel/bpf/bpf_lsm.c

263

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

266

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

270

if (prog->expected_attach_type != BPF_LSM_CGROUP)

kernel/bpf/bpf_lsm.c

273

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

276

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

281

return tracing_prog_func_proto(func_id, prog);

kernel/bpf/bpf_lsm.c

405

bool bpf_lsm_is_trusted(const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

407

return !btf_id_set_contains(&untrusted_lsm_hooks, prog->aux->attach_btf_id);

kernel/bpf/bpf_lsm.c

429

int bpf_lsm_get_retval_range(const struct bpf_prog *prog,

kernel/bpf/bpf_lsm.c

433

if (!prog->aux->attach_func_proto->type)

kernel/bpf/bpf_lsm.c

436

if (btf_id_set_contains(&bool_lsm_hooks, prog->aux->attach_btf_id)) {

kernel/bpf/bpf_lsm.c

91

void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,

kernel/bpf/bpf_lsm.c

96

if (btf_type_vlen(prog->aux->attach_func_proto) < 1 ||

kernel/bpf/bpf_lsm.c

98

prog->aux->attach_btf_id)) {

kernel/bpf/bpf_struct_ops.c

1414

int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map)

kernel/bpf/bpf_struct_ops.c

1418

guard(mutex)(&prog->aux->st_ops_assoc_mutex);

kernel/bpf/bpf_struct_ops.c

1420

st_ops_assoc = rcu_dereference_protected(prog->aux->st_ops_assoc,

kernel/bpf/bpf_struct_ops.c

1421

lockdep_is_held(&prog->aux->st_ops_assoc_mutex));

kernel/bpf/bpf_struct_ops.c

1426

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1429

rcu_assign_pointer(prog->aux->st_ops_assoc, BPF_PTR_POISON);

kernel/bpf/bpf_struct_ops.c

1435

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1438

rcu_assign_pointer(prog->aux->st_ops_assoc, map);

kernel/bpf/bpf_struct_ops.c

1444

void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog)

kernel/bpf/bpf_struct_ops.c

1448

guard(mutex)(&prog->aux->st_ops_assoc_mutex);

kernel/bpf/bpf_struct_ops.c

1450

st_ops_assoc = rcu_dereference_protected(prog->aux->st_ops_assoc,

kernel/bpf/bpf_struct_ops.c

1451

lockdep_is_held(&prog->aux->st_ops_assoc_mutex));

kernel/bpf/bpf_struct_ops.c

1455

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1458

RCU_INIT_POINTER(prog->aux->st_ops_assoc, NULL);

kernel/bpf/bpf_struct_ops.c

542

bpf_prog_disassoc_struct_ops(st_map->links[i]->prog);

kernel/bpf/bpf_struct_ops.c

748

struct bpf_prog *prog;

kernel/bpf/bpf_struct_ops.c

800

prog = bpf_prog_get(prog_fd);

kernel/bpf/bpf_struct_ops.c

801

if (IS_ERR(prog)) {

kernel/bpf/bpf_struct_ops.c

802

err = PTR_ERR(prog);

kernel/bpf/bpf_struct_ops.c

806

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS ||

kernel/bpf/bpf_struct_ops.c

807

prog->aux->attach_btf_id != st_ops_desc->type_id ||

kernel/bpf/bpf_struct_ops.c

808

prog->expected_attach_type != i) {

kernel/bpf/bpf_struct_ops.c

809

bpf_prog_put(prog);

kernel/bpf/bpf_struct_ops.c

815

bpf_prog_assoc_struct_ops(prog, &st_map->map);

kernel/bpf/bpf_struct_ops.c

819

bpf_prog_put(prog);

kernel/bpf/bpf_struct_ops.c

824

&bpf_struct_ops_link_lops, prog, prog->expected_attach_type);

kernel/bpf/bpf_struct_ops.c

852

*(unsigned long *)(udata + moff) = prog->aux->id;

kernel/bpf/btf.c

6510

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog)

kernel/bpf/btf.c

6512

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/btf.c

6517

return prog->aux->attach_btf;

kernel/bpf/btf.c

6555

static bool prog_args_trusted(const struct bpf_prog *prog)

kernel/bpf/btf.c

6557

enum bpf_attach_type atype = prog->expected_attach_type;

kernel/bpf/btf.c

6559

switch (prog->type) {

kernel/bpf/btf.c

6563

return bpf_lsm_is_trusted(prog);

kernel/bpf/btf.c

6789

const struct bpf_prog *prog,

kernel/bpf/btf.c

6792

const struct btf_type *t = prog->aux->attach_func_proto;

kernel/bpf/btf.c

6793

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/btf.c

6794

struct btf *btf = bpf_prog_get_target_btf(prog);

kernel/bpf/btf.c

6795

const char *tname = prog->aux->attach_func_name;

kernel/bpf/btf.c

6814

if (prog->aux->attach_btf_trace) {

kernel/bpf/btf.c

6827

switch (prog->expected_attach_type) {

kernel/bpf/btf.c

6901

for (i = 0; i < prog->aux->ctx_arg_info_size; i++) {

kernel/bpf/btf.c

6902

const struct bpf_ctx_arg_aux *ctx_arg_info = &prog->aux->ctx_arg_info[i];

kernel/bpf/btf.c

6922

for (i = 0; i < prog->aux->ctx_arg_info_size; i++) {

kernel/bpf/btf.c

6923

const struct bpf_ctx_arg_aux *ctx_arg_info = &prog->aux->ctx_arg_info[i];

kernel/bpf/btf.c

6940

if (prog_args_trusted(prog))

kernel/bpf/btf.c

6946

if (prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/btf.c

6947

struct btf *btf = prog->aux->attach_btf;

kernel/bpf/btf.c

6952

t = btf_type_by_id(btf, prog->aux->attach_btf_id);

kernel/bpf/btf.c

7661

int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,

kernel/bpf/btf.c

7664

struct btf *btf1 = prog->aux->btf;

kernel/bpf/btf.c

7668

if (!prog->aux->func_info) {

kernel/bpf/btf.c

7673

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

kernel/bpf/btf.c

7792

struct bpf_prog *prog = env->prog;

kernel/bpf/btf.c

7793

enum bpf_prog_type prog_type = prog->type;

kernel/bpf/btf.c

7794

struct btf *btf = prog->aux->btf;

kernel/bpf/btf.c

7803

if (!prog->aux->func_info) {

kernel/bpf/btf.c

7808

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

kernel/bpf/btf.c

7827

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

kernel/bpf/btf.c

7832

prog_type = prog->aux->dst_prog->type;

kernel/bpf/btf.c

7916

prog->expected_attach_type))

kernel/bpf/btf.c

8803

const struct bpf_prog *prog)

kernel/bpf/btf.c

8815

if (hook_filter->filters[i](prog, kfunc_btf_id))

kernel/bpf/btf.c

8871

const struct bpf_prog *prog)

kernel/bpf/btf.c

8873

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/btf.c

8878

if (kfunc_flags && __btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_COMMON, kfunc_btf_id, prog))

kernel/bpf/btf.c

8883

if (kfunc_flags && __btf_kfunc_is_allowed(btf, hook, kfunc_btf_id, prog))

kernel/bpf/btf.c

8896

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog)

kernel/bpf/btf.c

8898

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/btf.c

8911

const struct bpf_prog *prog)

kernel/bpf/btf.c

8913

if (!__btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_FMODRET, kfunc_btf_id, prog))

kernel/bpf/cgroup.c

1005

old_prog = xchg(&link->link.prog, new_prog);

kernel/bpf/cgroup.c

1025

if (old_prog && link->prog != old_prog) {

kernel/bpf/cgroup.c

1036

struct bpf_prog *prog,

kernel/bpf/cgroup.c

1053

if (!prog && !link)

kernel/bpf/cgroup.c

1061

if (pl->prog == prog && pl->link == link)

kernel/bpf/cgroup.c

1077

static void purge_effective_progs(struct cgroup *cgrp, struct bpf_prog *prog,

kernel/bpf/cgroup.c

1104

if (pl->prog == prog && pl->link == link)

kernel/bpf/cgroup.c

1135

static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,

kernel/bpf/cgroup.c

1146

if (prog)

kernel/bpf/cgroup.c

1147

attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/cgroup.c

1149

attach_btf_id = link->link.prog->aux->attach_btf_id;

kernel/bpf/cgroup.c

1161

if (prog && link)

kernel/bpf/cgroup.c

1165

pl = find_detach_entry(progs, prog, link, flags & BPF_F_ALLOW_MULTI);

kernel/bpf/cgroup.c

1170

old_prog = pl->prog;

kernel/bpf/cgroup.c

1171

pl->prog = NULL;

kernel/bpf/cgroup.c

1176

pl->prog = old_prog;

kernel/bpf/cgroup.c

1198

static int cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,

kernel/bpf/cgroup.c

1204

ret = __cgroup_bpf_detach(cgrp, prog, NULL, type, revision);

kernel/bpf/cgroup.c

1282

struct bpf_prog *prog;

kernel/bpf/cgroup.c

1289

prog = prog_list_prog(pl);

kernel/bpf/cgroup.c

1290

id = prog->aux->id;

kernel/bpf/cgroup.c

1326

enum bpf_prog_type ptype, struct bpf_prog *prog)

kernel/bpf/cgroup.c

1345

ret = cgroup_bpf_attach(cgrp, prog, replace_prog, NULL,

kernel/bpf/cgroup.c

1357

struct bpf_prog *prog;

kernel/bpf/cgroup.c

1365

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/cgroup.c

1366

if (IS_ERR(prog))

kernel/bpf/cgroup.c

1367

prog = NULL;

kernel/bpf/cgroup.c

1369

ret = cgroup_bpf_detach(cgrp, prog, attr->attach_type, attr->expected_revision);

kernel/bpf/cgroup.c

1370

if (prog)

kernel/bpf/cgroup.c

1371

bpf_prog_put(prog);

kernel/bpf/cgroup.c

1400

bpf_trampoline_unlink_cgroup_shim(cg_link->link.prog);

kernel/bpf/cgroup.c

1477

int cgroup_bpf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/cgroup.c

1497

prog, attr->link_create.attach_type);

kernel/bpf/cgroup.c

1814

cgroup_dev_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/cgroup.c

1818

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

1826

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

1832

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

2361

sysctl_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/cgroup.c

2365

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

238

struct bpf_prog *prog,

kernel/bpf/cgroup.c

2383

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2388

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

2417

struct bpf_prog *prog, u32 *target_size)

kernel/bpf/cgroup.c

249

map = prog->aux->cgroup_storage[stype];

kernel/bpf/cgroup.c

2504

cg_sockopt_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/cgroup.c

2508

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2521

if (prog->expected_attach_type == BPF_CGROUP_SETSOCKOPT)

kernel/bpf/cgroup.c

2525

if (prog->expected_attach_type == BPF_CGROUP_SETSOCKOPT)

kernel/bpf/cgroup.c

2536

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2542

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

2558

return prog->expected_attach_type ==

kernel/bpf/cgroup.c

2565

return prog->expected_attach_type ==

kernel/bpf/cgroup.c

257

storages[stype] = bpf_cgroup_storage_alloc(prog, stype);

kernel/bpf/cgroup.c

2593

return prog->expected_attach_type == BPF_CGROUP_GETSOCKOPT;

kernel/bpf/cgroup.c

2617

struct bpf_prog *prog,

kernel/bpf/cgroup.c

2694

const struct bpf_prog *prog)

kernel/bpf/cgroup.c

2713

cgroup_common_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/cgroup.c

2719

switch (prog->expected_attach_type) {

kernel/bpf/cgroup.c

2737

switch (prog->expected_attach_type) {

kernel/bpf/cgroup.c

323

if (pl->prog) {

kernel/bpf/cgroup.c

324

if (pl->prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/cgroup.c

325

bpf_trampoline_unlink_cgroup_shim(pl->prog);

kernel/bpf/cgroup.c

326

bpf_prog_put(pl->prog);

kernel/bpf/cgroup.c

329

if (pl->link->link.prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/cgroup.c

330

bpf_trampoline_unlink_cgroup_shim(pl->link->link.prog);

kernel/bpf/cgroup.c

374

if (pl->prog)

kernel/bpf/cgroup.c

375

return pl->prog;

kernel/bpf/cgroup.c

377

return pl->link->link.prog;

kernel/bpf/cgroup.c

474

item->prog = prog_list_prog(pl);

kernel/bpf/cgroup.c

623

struct bpf_prog *prog,

kernel/bpf/cgroup.c

638

if (prog && pl->prog == prog && prog != replace_prog)

kernel/bpf/cgroup.c

649

if (pl->prog == replace_prog)

kernel/bpf/cgroup.c

673

struct bpf_prog *prog = ERR_PTR(-EINVAL);

kernel/bpf/cgroup.c

676

prog = bpf_prog_by_id(id_or_fd);

kernel/bpf/cgroup.c

678

prog = bpf_prog_get(id_or_fd);

kernel/bpf/cgroup.c

679

return prog;

kernel/bpf/cgroup.c

68

const struct bpf_prog *prog;

kernel/bpf/cgroup.c

682

static struct bpf_prog_list *get_prog_list(struct hlist_head *progs, struct bpf_prog *prog,

kernel/bpf/cgroup.c

698

if ((is_link && !link) || (!is_link && !prog))

kernel/bpf/cgroup.c

732

if ((anchor_prog && anchor_prog == pltmp->prog) ||

kernel/bpf/cgroup.c

751

struct bpf_prog *prog, struct bpf_cgroup_link *link,

kernel/bpf/cgroup.c

756

pltmp = get_prog_list(progs, prog, link, flags, id_or_fd);

kernel/bpf/cgroup.c

786

struct bpf_prog *prog, struct bpf_prog *replace_prog,

kernel/bpf/cgroup.c

79

while ((prog = READ_ONCE(item->prog))) {

kernel/bpf/cgroup.c

795

struct bpf_prog *new_prog = prog ? : link->link.prog;

kernel/bpf/cgroup.c

808

if (link && (prog || replace_prog))

kernel/bpf/cgroup.c

81

func_ret = run_prog(prog, ctx);

kernel/bpf/cgroup.c

836

pl = find_attach_entry(progs, prog, link, replace_prog,

kernel/bpf/cgroup.c

842

prog ? : link->link.prog, cgrp))

kernel/bpf/cgroup.c

846

old_prog = pl->prog;

kernel/bpf/cgroup.c

854

err = insert_pl_to_hlist(pl, progs, prog, link, flags, id_or_fd);

kernel/bpf/cgroup.c

862

pl->prog = prog;

kernel/bpf/cgroup.c

895

pl->prog = old_prog;

kernel/bpf/cgroup.c

907

struct bpf_prog *prog, struct bpf_prog *replace_prog,

kernel/bpf/cgroup.c

915

ret = __cgroup_bpf_attach(cgrp, prog, replace_prog, link, type, flags,

kernel/bpf/cgroup.c

962

WRITE_ONCE(item->prog, link->link.prog);

kernel/bpf/cgroup.c

992

if (link->link.prog->type != new_prog->type)

kernel/bpf/cgroup_iter.c

131

struct bpf_prog *prog;

kernel/bpf/cgroup_iter.c

141

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/cgroup_iter.c

142

if (prog)

kernel/bpf/cgroup_iter.c

143

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/cgroup_iter.c

199

static int bpf_iter_attach_cgroup(struct bpf_prog *prog,

kernel/bpf/core.c

1247

int bpf_jit_get_func_addr(const struct bpf_prog *prog,

kernel/bpf/core.c

1264

else if (prog->aux->func &&

kernel/bpf/core.c

1265

off >= 0 && off < prog->aux->real_func_cnt)

kernel/bpf/core.c

1266

addr = (u8 *)prog->aux->func[off]->bpf_func;

kernel/bpf/core.c

127

fp->aux->prog = fp;

kernel/bpf/core.c

1271

err = bpf_get_kfunc_addr(prog, insn->imm, insn->off, &addr);

kernel/bpf/core.c

1287

const char *bpf_jit_get_prog_name(struct bpf_prog *prog)

kernel/bpf/core.c

1289

if (prog->aux->ksym.prog)

kernel/bpf/core.c

1290

return prog->aux->ksym.name;

kernel/bpf/core.c

1291

return prog->aux->name;

kernel/bpf/core.c

1489

fp->aux->prog = fp;

kernel/bpf/core.c

1493

static void adjust_insn_arrays(struct bpf_prog *prog, u32 off, u32 len)

kernel/bpf/core.c

1502

for (i = 0; i < prog->aux->used_map_cnt; i++) {

kernel/bpf/core.c

1503

map = prog->aux->used_maps[i];

kernel/bpf/core.c

1510

struct bpf_prog *bpf_jit_blind_constants(struct bpf_prog *prog)

kernel/bpf/core.c

1518

if (!prog->blinding_requested || prog->blinded)

kernel/bpf/core.c

1519

return prog;

kernel/bpf/core.c

1521

clone = bpf_prog_clone_create(prog, GFP_USER);

kernel/bpf/core.c

153

struct bpf_prog *prog;

kernel/bpf/core.c

1558

bpf_jit_prog_release_other(prog, clone);

kernel/bpf/core.c

156

prog = bpf_prog_alloc_no_stats(size, gfp_extra_flags);

kernel/bpf/core.c

1566

adjust_insn_arrays(clone, prog->aux->subprog_start + i, rewritten);

kernel/bpf/core.c

157

if (!prog)

kernel/bpf/core.c

160

prog->stats = alloc_percpu_gfp(struct bpf_prog_stats, gfp_flags);

kernel/bpf/core.c

161

if (!prog->stats) {

kernel/bpf/core.c

162

free_percpu(prog->active);

kernel/bpf/core.c

163

kfree(prog->aux);

kernel/bpf/core.c

164

vfree(prog);

kernel/bpf/core.c

171

pstats = per_cpu_ptr(prog->stats, cpu);

kernel/bpf/core.c

174

return prog;

kernel/bpf/core.c

178

int bpf_prog_alloc_jited_linfo(struct bpf_prog *prog)

kernel/bpf/core.c

180

if (!prog->aux->nr_linfo || !prog->jit_requested)

kernel/bpf/core.c

183

prog->aux->jited_linfo = kvzalloc_objs(*prog->aux->jited_linfo,

kernel/bpf/core.c

184

prog->aux->nr_linfo,

kernel/bpf/core.c

186

if (!prog->aux->jited_linfo)

kernel/bpf/core.c

192

void bpf_prog_jit_attempt_done(struct bpf_prog *prog)

kernel/bpf/core.c

194

if (prog->aux->jited_linfo &&

kernel/bpf/core.c

195

(!prog->jited || !prog->aux->jited_linfo[0])) {

kernel/bpf/core.c

196

kvfree(prog->aux->jited_linfo);

kernel/bpf/core.c

197

prog->aux->jited_linfo = NULL;

kernel/bpf/core.c

200

kfree(prog->aux->kfunc_tab);

kernel/bpf/core.c

201

prog->aux->kfunc_tab = NULL;

kernel/bpf/core.c

2081

struct bpf_prog *prog;

kernel/bpf/core.c

2092

prog = READ_ONCE(array->ptrs[index]);

kernel/bpf/core.c

2093

if (!prog)

kernel/bpf/core.c

2101

insn = prog->insnsi;

kernel/bpf/core.c

228

void bpf_prog_fill_jited_linfo(struct bpf_prog *prog,

kernel/bpf/core.c

235

if (!prog->aux->jited_linfo || prog->aux->func_idx > prog->aux->func_cnt)

kernel/bpf/core.c

239

linfo_idx = prog->aux->linfo_idx;

kernel/bpf/core.c

240

linfo = &prog->aux->linfo[linfo_idx];

kernel/bpf/core.c

242

insn_end = insn_start + prog->len;

kernel/bpf/core.c

244

jited_linfo = &prog->aux->jited_linfo[linfo_idx];

kernel/bpf/core.c

245

jited_linfo[0] = prog->bpf_func;

kernel/bpf/core.c

247

nr_linfo = prog->aux->nr_linfo - linfo_idx;

kernel/bpf/core.c

253

jited_linfo[i] = prog->bpf_func +

kernel/bpf/core.c

2609

struct bpf_prog prog;

kernel/bpf/core.c

2611

.prog = {

kernel/bpf/core.c

2666

for (item = array->items; item->prog; item++)

kernel/bpf/core.c

2667

if (item->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2676

for (item = array->items; item->prog; item++)

kernel/bpf/core.c

2677

if (item->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2689

for (item = array->items; item->prog; item++) {

kernel/bpf/core.c

2690

if (item->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2692

prog_ids[i] = item->prog->aux->id;

kernel/bpf/core.c

2699

return !!(item->prog);

kernel/bpf/core.c

273

fp->aux->prog = fp;

kernel/bpf/core.c

2733

for (item = array->items; item->prog; item++)

kernel/bpf/core.c

2734

if (item->prog == old_prog) {

kernel/bpf/core.c

2735

WRITE_ONCE(item->prog, &dummy_bpf_prog.prog);

kernel/bpf/core.c

2757

return bpf_prog_array_update_at(array, index, &dummy_bpf_prog.prog);

kernel/bpf/core.c

2776

struct bpf_prog *prog)

kernel/bpf/core.c

2783

for (item = array->items; item->prog; item++) {

kernel/bpf/core.c

2784

if (item->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2787

WRITE_ONCE(item->prog, prog);

kernel/bpf/core.c

2811

for (; existing->prog; existing++) {

kernel/bpf/core.c

2812

if (existing->prog == exclude_prog) {

kernel/bpf/core.c

2816

if (existing->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2818

if (existing->prog == include_prog)

kernel/bpf/core.c

2846

for (; existing->prog; existing++) {

kernel/bpf/core.c

2847

if (existing->prog == exclude_prog ||

kernel/bpf/core.c

2848

existing->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2851

new->prog = existing->prog;

kernel/bpf/core.c

2857

new->prog = include_prog;

kernel/bpf/core.c

2861

new->prog = NULL;

kernel/bpf/core.c

2893

sleepable = aux->prog->sleepable;

kernel/bpf/core.c

2939

bpf_prog_stream_free(aux->prog);

kernel/bpf/core.c

2947

bpf_prog_disassoc_struct_ops(aux->prog);

kernel/bpf/core.c

2949

bpf_prog_dev_bound_destroy(aux->prog);

kernel/bpf/core.c

2951

if (aux->prog->has_callchain_buf)

kernel/bpf/core.c

2966

bpf_prog_unlock_free(aux->prog);

kernel/bpf/core.c

2968

bpf_jit_free(aux->prog);

kernel/bpf/core.c

3087

struct bpf_prog * __weak bpf_int_jit_compile(struct bpf_prog *prog)

kernel/bpf/core.c

3089

return prog;

kernel/bpf/core.c

3095

void __weak bpf_jit_compile(struct bpf_prog *prog)

kernel/bpf/core.c

3252

struct bpf_prog *prog;

kernel/bpf/core.c

3254

prog = bpf_prog_find_from_stack();

kernel/bpf/core.c

3255

if (!prog)

kernel/bpf/core.c

3257

bpf_stream_stage(ss, prog, BPF_STDERR, ({

kernel/bpf/core.c

3317

int bpf_prog_get_file_line(struct bpf_prog *prog, unsigned long ip, const char **filep,

kernel/bpf/core.c

3326

btf = prog->aux->btf;

kernel/bpf/core.c

3327

linfo = prog->aux->linfo;

kernel/bpf/core.c

3328

jited_linfo = prog->aux->jited_linfo;

kernel/bpf/core.c

3332

len = prog->aux->func ? prog->aux->func[prog->aux->func_idx]->len : prog->len;

kernel/bpf/core.c

3334

linfo = &prog->aux->linfo[prog->aux->linfo_idx];

kernel/bpf/core.c

3335

jited_linfo = &prog->aux->jited_linfo[prog->aux->linfo_idx];

kernel/bpf/core.c

3339

nr_linfo = prog->aux->nr_linfo - prog->aux->linfo_idx;

kernel/bpf/core.c

3363

struct bpf_prog *prog;

kernel/bpf/core.c

3369

struct bpf_prog *prog;

kernel/bpf/core.c

3377

prog = bpf_prog_ksym_find(ip);

kernel/bpf/core.c

3379

if (!prog)

kernel/bpf/core.c

3382

ctxp->prog = prog->aux->main_prog_aux->prog;

kernel/bpf/core.c

3391

return ctx.prog;

kernel/bpf/core.c

388

static int bpf_adj_branches(struct bpf_prog *prog, u32 pos, s32 end_old,

kernel/bpf/core.c

391

u32 i, insn_cnt = prog->len + (probe_pass ? end_new - end_old : 0);

kernel/bpf/core.c

392

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/core.c

404

insn = prog->insnsi + end_old;

kernel/bpf/core.c

435

static void bpf_adj_linfo(struct bpf_prog *prog, u32 off, u32 delta)

kernel/bpf/core.c

440

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/core.c

444

linfo = prog->aux->linfo;

kernel/bpf/core.c

455

struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,

kernel/bpf/core.c

465

memcpy(prog->insnsi + off, patch, sizeof(*patch));

kernel/bpf/core.c

466

return prog;

kernel/bpf/core.c

469

insn_adj_cnt = prog->len + insn_delta;

kernel/bpf/core.c

477

(err = bpf_adj_branches(prog, off, off + 1, off + len, true)))

kernel/bpf/core.c

484

prog_adj = bpf_prog_realloc(prog, bpf_prog_size(insn_adj_cnt),

kernel/bpf/core.c

516

int bpf_remove_insns(struct bpf_prog *prog, u32 off, u32 cnt)

kernel/bpf/core.c

523

memmove(prog->insnsi + off, prog->insnsi + off + cnt,

kernel/bpf/core.c

524

sizeof(struct bpf_insn) * (prog->len - off - cnt));

kernel/bpf/core.c

525

prog->len -= cnt;

kernel/bpf/core.c

527

err = bpf_adj_branches(prog, off, off + cnt, off, false);

kernel/bpf/core.c

555

bpf_prog_ksym_set_addr(struct bpf_prog *prog)

kernel/bpf/core.c

557

WARN_ON_ONCE(!bpf_prog_ebpf_jited(prog));

kernel/bpf/core.c

559

prog->aux->ksym.start = (unsigned long) prog->bpf_func;

kernel/bpf/core.c

560

prog->aux->ksym.end = prog->aux->ksym.start + prog->jited_len;

kernel/bpf/core.c

564

bpf_prog_ksym_set_name(struct bpf_prog *prog)

kernel/bpf/core.c

566

char *sym = prog->aux->ksym.name;

kernel/bpf/core.c

572

sizeof(prog->tag) * 2 +

kernel/bpf/core.c

580

sizeof(prog->aux->name) > KSYM_NAME_LEN);

kernel/bpf/core.c

583

sym = bin2hex(sym, prog->tag, sizeof(prog->tag));

kernel/bpf/core.c

586

if (prog->aux->func_info_cnt && prog->aux->func_idx < prog->aux->func_info_cnt) {

kernel/bpf/core.c

587

type = btf_type_by_id(prog->aux->btf,

kernel/bpf/core.c

588

prog->aux->func_info[prog->aux->func_idx].type_id);

kernel/bpf/core.c

589

func_name = btf_name_by_offset(prog->aux->btf, type->name_off);

kernel/bpf/core.c

594

if (prog->aux->name[0])

kernel/bpf/core.c

595

snprintf(sym, (size_t)(end - sym), "_%s", prog->aux->name);

kernel/bpf/core.c

677

fp->aux->ksym.prog = true;

kernel/bpf/core.c

762

return ksym && ksym->prog ?

kernel/bpf/core.c

763

container_of(ksym, struct bpf_prog_aux, ksym)->prog :

kernel/bpf/core.c

786

struct bpf_prog *prog;

kernel/bpf/core.c

789

prog = bpf_prog_ksym_find(addr);

kernel/bpf/core.c

790

if (!prog)

kernel/bpf/core.c

792

if (!prog->aux->num_exentries)

kernel/bpf/core.c

795

e = search_extable(prog->aux->extable, prog->aux->num_exentries, addr);

kernel/bpf/core.c

829

int bpf_jit_add_poke_descriptor(struct bpf_prog *prog,

kernel/bpf/core.c

832

struct bpf_jit_poke_descriptor *tab = prog->aux->poke_tab;

kernel/bpf/core.c

834

u32 slot = prog->aux->size_poke_tab;

kernel/bpf/core.c

857

prog->aux->size_poke_tab = size;

kernel/bpf/core.c

858

prog->aux->poke_tab = tab;

kernel/bpf/cpumap.c

150

act = bpf_prog_run_generic_xdp(skb, &xdp, rcpu->prog);

kernel/bpf/cpumap.c

157

rcpu->prog);

kernel/bpf/cpumap.c

166

bpf_warn_invalid_xdp_action(NULL, rcpu->prog, act);

kernel/bpf/cpumap.c

169

trace_xdp_exception(skb->dev, rcpu->prog, act);

kernel/bpf/cpumap.c

204

act = bpf_prog_run_xdp(rcpu->prog, &xdp);

kernel/bpf/cpumap.c

217

rcpu->prog);

kernel/bpf/cpumap.c

226

bpf_warn_invalid_xdp_action(NULL, rcpu->prog, act);

kernel/bpf/cpumap.c

253

if (!rcpu->prog)

kernel/bpf/cpumap.c

413

struct bpf_prog *prog;

kernel/bpf/cpumap.c

415

prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_XDP);

kernel/bpf/cpumap.c

416

if (IS_ERR(prog))

kernel/bpf/cpumap.c

417

return PTR_ERR(prog);

kernel/bpf/cpumap.c

419

if (prog->expected_attach_type != BPF_XDP_CPUMAP ||

kernel/bpf/cpumap.c

420

!bpf_prog_map_compatible(map, prog)) {

kernel/bpf/cpumap.c

421

bpf_prog_put(prog);

kernel/bpf/cpumap.c

425

rcpu->value.bpf_prog.id = prog->aux->id;

kernel/bpf/cpumap.c

426

rcpu->prog = prog;

kernel/bpf/cpumap.c

503

if (rcpu->prog)

kernel/bpf/cpumap.c

504

bpf_prog_put(rcpu->prog);

kernel/bpf/cpumap.c

534

if (rcpu->prog)

kernel/bpf/cpumap.c

535

bpf_prog_put(rcpu->prog);

kernel/bpf/cpumap.c

72

struct bpf_prog *prog;

kernel/bpf/devmap.c

888

struct bpf_prog *prog = NULL;

kernel/bpf/devmap.c

902

prog = bpf_prog_get_type_dev(val->bpf_prog.fd,

kernel/bpf/devmap.c

904

if (IS_ERR(prog))

kernel/bpf/devmap.c

906

if (prog->expected_attach_type != BPF_XDP_DEVMAP ||

kernel/bpf/devmap.c

907

!bpf_prog_map_compatible(&dtab->map, prog))

kernel/bpf/devmap.c

912

if (prog) {

kernel/bpf/devmap.c

913

dev->xdp_prog = prog;

kernel/bpf/devmap.c

914

dev->val.bpf_prog.id = prog->aux->id;

kernel/bpf/devmap.c

923

bpf_prog_put(prog);

kernel/bpf/dispatcher.c

100

if (d->progs[i].prog)

kernel/bpf/dispatcher.c

101

*ipsp++ = (s64)(uintptr_t)d->progs[i].prog->bpf_func;

kernel/bpf/dispatcher.c

26

struct bpf_dispatcher *d, struct bpf_prog *prog)

kernel/bpf/dispatcher.c

31

if (prog == d->progs[i].prog)

kernel/bpf/dispatcher.c

44

struct bpf_prog *prog)

kernel/bpf/dispatcher.c

48

if (!prog)

kernel/bpf/dispatcher.c

51

entry = bpf_dispatcher_find_prog(d, prog);

kernel/bpf/dispatcher.c

61

bpf_prog_inc(prog);

kernel/bpf/dispatcher.c

62

entry->prog = prog;

kernel/bpf/dispatcher.c

69

struct bpf_prog *prog)

kernel/bpf/dispatcher.c

73

if (!prog)

kernel/bpf/dispatcher.c

76

entry = bpf_dispatcher_find_prog(d, prog);

kernel/bpf/dispatcher.c

81

entry->prog = NULL;

kernel/bpf/dispatcher.c

82

bpf_prog_put(prog);

kernel/bpf/dmabuf_iter.c

63

struct bpf_prog *prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/dmabuf_iter.c

65

if (prog)

kernel/bpf/dmabuf_iter.c

66

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/hashtab.c

2170

struct bpf_prog *prog;

kernel/bpf/hashtab.c

2174

prog = bpf_iter_get_info(&meta, elem == NULL);

kernel/bpf/hashtab.c

2175

if (prog) {

kernel/bpf/hashtab.c

2194

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/helpers.c

1117

struct bpf_prog *prog;

kernel/bpf/helpers.c

1235

if (cb->prog)

kernel/bpf/helpers.c

1236

bpf_prog_put(cb->prog);

kernel/bpf/helpers.c

1347

cb->prog = NULL;

kernel/bpf/helpers.c

1407

struct bpf_prog *prog,

kernel/bpf/helpers.c

1413

if (prog) {

kernel/bpf/helpers.c

1414

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/helpers.c

1415

if (IS_ERR(prog))

kernel/bpf/helpers.c

1416

return PTR_ERR(prog);

kernel/bpf/helpers.c

1420

if (prog)

kernel/bpf/helpers.c

1421

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/helpers.c

1422

prev = xchg(&cb->prog, prog);

kernel/bpf/helpers.c

1433

} while (READ_ONCE(cb->prog) != prog ||

kernel/bpf/helpers.c

1436

if (prog)

kernel/bpf/helpers.c

1437

bpf_prog_put(prog);

kernel/bpf/helpers.c

1475

struct bpf_prog *prog)

kernel/bpf/helpers.c

1483

return bpf_async_update_prog_callback(cb, prog, callback_fn);

kernel/bpf/helpers.c

1489

return __bpf_async_set_callback(timer, callback_fn, aux->prog);

kernel/bpf/helpers.c

1514

if (!t || !READ_ONCE(t->cb.prog))

kernel/bpf/helpers.c

2052

bpf_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/helpers.c

2109

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

kernel/bpf/helpers.c

2177

if (!bpf_token_capable(prog->aux->token, CAP_PERFMON))

kernel/bpf/helpers.c

2220

return prog->sleepable ? &bpf_get_task_stack_sleepable_proto

kernel/bpf/helpers.c

3123

struct bpf_prog *prog;

kernel/bpf/helpers.c

3131

prog = bpf_prog_ksym_find(ip);

kernel/bpf/helpers.c

3133

if (!prog)

kernel/bpf/helpers.c

3136

if (bpf_is_subprog(prog))

kernel/bpf/helpers.c

3138

ctx->aux = prog->aux;

kernel/bpf/helpers.c

3186

if (!w || !READ_ONCE(w->cb.prog))

kernel/bpf/helpers.c

3211

return __bpf_async_set_callback(async, callback_fn, aux->prog);

kernel/bpf/helpers.c

4135

struct bpf_prog *prog;

kernel/bpf/helpers.c

4153

if (ctx->prog) {

kernel/bpf/helpers.c

4154

bpf_prog_put(ctx->prog);

kernel/bpf/helpers.c

4155

ctx->prog = NULL;

kernel/bpf/helpers.c

4333

struct bpf_prog *prog;

kernel/bpf/helpers.c

4339

prog = bpf_prog_inc_not_zero(aux->prog);

kernel/bpf/helpers.c

4340

if (IS_ERR(prog))

kernel/bpf/helpers.c

4356

ctx->prog = prog;

kernel/bpf/helpers.c

4369

bpf_prog_put(prog);

kernel/bpf/inode.c

553

struct bpf_prog *prog;

kernel/bpf/inode.c

565

prog = inode->i_private;

kernel/bpf/inode.c

567

ret = security_bpf_prog(prog);

kernel/bpf/inode.c

571

if (!bpf_prog_get_ok(prog, &type, false))

kernel/bpf/inode.c

574

bpf_prog_inc(prog);

kernel/bpf/inode.c

575

return prog;

kernel/bpf/inode.c

580

struct bpf_prog *prog;

kernel/bpf/inode.c

585

prog = __get_prog_inode(d_backing_inode(path.dentry), type);

kernel/bpf/inode.c

586

if (!IS_ERR(prog))

kernel/bpf/inode.c

589

return prog;

kernel/bpf/kmem_cache_iter.c

160

struct bpf_prog *prog;

kernel/bpf/kmem_cache_iter.c

163

prog = bpf_iter_get_info(&meta, true);

kernel/bpf/kmem_cache_iter.c

164

if (prog && !ctx.s)

kernel/bpf/kmem_cache_iter.c

165

bpf_iter_run_prog(prog, &ctx);

kernel/bpf/kmem_cache_iter.c

186

struct bpf_prog *prog;

kernel/bpf/kmem_cache_iter.c

190

prog = bpf_iter_get_info(&meta, false);

kernel/bpf/kmem_cache_iter.c

191

if (prog)

kernel/bpf/kmem_cache_iter.c

192

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/link_iter.c

48

struct bpf_prog *prog;

kernel/bpf/link_iter.c

54

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/link_iter.c

55

if (prog)

kernel/bpf/link_iter.c

56

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/liveness.c

483

struct bpf_prog *prog = env->prog;

kernel/bpf/liveness.c

484

struct bpf_insn *insn = &prog->insnsi[idx];

kernel/bpf/local_storage.c

503

struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog,

kernel/bpf/local_storage.c

512

map = prog->aux->cgroup_storage[stype];

kernel/bpf/log.c

336

const struct bpf_prog *prog;

kernel/bpf/log.c

340

prog = env->prog;

kernel/bpf/log.c

341

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/log.c

343

if (!nr_linfo || insn_off >= prog->len)

kernel/bpf/log.c

346

linfo = prog->aux->linfo;

kernel/bpf/log.c

417

btf = env->prog->aux->btf;

kernel/bpf/map_iter.c

100

static int bpf_iter_attach_map(struct bpf_prog *prog,

kernel/bpf/map_iter.c

125

key_acc_size = prog->aux->max_rdonly_access;

kernel/bpf/map_iter.c

126

value_acc_size = prog->aux->max_rdwr_access;

kernel/bpf/map_iter.c

48

struct bpf_prog *prog;

kernel/bpf/map_iter.c

54

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/map_iter.c

55

if (prog)

kernel/bpf/map_iter.c

56

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/mprog.c

117

oprog = READ_ONCE(fp->prog);

kernel/bpf/mprog.c

187

if (tuple->prog == READ_ONCE(fp->prog))

kernel/bpf/mprog.c

20

if (type && link->prog->type != type) {

kernel/bpf/mprog.c

202

if (tuple->prog == READ_ONCE(fp->prog) &&

kernel/bpf/mprog.c

206

return tuple->prog ? -ENOENT : -1;

kernel/bpf/mprog.c

218

if (tuple->prog == READ_ONCE(fp->prog) &&

kernel/bpf/mprog.c

222

return tuple->prog ? -ENOENT : bpf_mprog_total(entry);

kernel/bpf/mprog.c

232

.prog = prog_new,

kernel/bpf/mprog.c

235

.prog = prog_old,

kernel/bpf/mprog.c

26

tuple->prog = link->prog;

kernel/bpf/mprog.c

277

if (rtuple.prog || flags) {

kernel/bpf/mprog.c

303

struct bpf_prog *prog;

kernel/bpf/mprog.c

311

prog = READ_ONCE(fp->prog);

kernel/bpf/mprog.c

321

WARN_ON_ONCE(tuple->prog && tuple->prog != prog);

kernel/bpf/mprog.c

323

tuple->prog = prog;

kernel/bpf/mprog.c

330

struct bpf_prog *prog, struct bpf_link *link,

kernel/bpf/mprog.c

334

.prog = prog,

kernel/bpf/mprog.c

34

struct bpf_prog *prog = ERR_PTR(-EINVAL);

kernel/bpf/mprog.c

346

prog ? prog->type :

kernel/bpf/mprog.c

350

if (dtuple.prog) {

kernel/bpf/mprog.c

375

if (rtuple.prog || flags) {

kernel/bpf/mprog.c

38

prog = bpf_prog_by_id(id_or_fd);

kernel/bpf/mprog.c

40

prog = bpf_prog_get(id_or_fd);

kernel/bpf/mprog.c

402

struct bpf_prog *prog;

kernel/bpf/mprog.c

41

if (IS_ERR(prog))

kernel/bpf/mprog.c

42

return PTR_ERR(prog);

kernel/bpf/mprog.c

43

if (type && prog->type != type) {

kernel/bpf/mprog.c

432

prog = READ_ONCE(fp->prog);

kernel/bpf/mprog.c

433

if (!prog)

kernel/bpf/mprog.c

435

id = prog->aux->id;

kernel/bpf/mprog.c

44

bpf_prog_put(prog);

kernel/bpf/mprog.c

49

tuple->prog = prog;

kernel/bpf/mprog.c

76

else if (tuple->prog)

kernel/bpf/mprog.c

77

bpf_prog_put(tuple->prog);

kernel/bpf/net_namespace.c

174

if (old_prog && old_prog != link->prog)

kernel/bpf/net_namespace.c

176

if (new_prog->type != link->prog->type)

kernel/bpf/net_namespace.c

195

old_prog = xchg(&link->prog, new_prog);

kernel/bpf/net_namespace.c

296

int netns_bpf_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/net_namespace.c

322

ret = flow_dissector_bpf_prog_attach_check(net, prog);

kernel/bpf/net_namespace.c

332

if (attached == prog) {

kernel/bpf/net_namespace.c

341

WRITE_ONCE(run_array->items[0].prog, prog);

kernel/bpf/net_namespace.c

348

run_array->items[0].prog = prog;

kernel/bpf/net_namespace.c

352

net->bpf.progs[type] = prog;

kernel/bpf/net_namespace.c

385

struct bpf_prog *prog;

kernel/bpf/net_namespace.c

395

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/net_namespace.c

396

if (IS_ERR(prog))

kernel/bpf/net_namespace.c

397

return PTR_ERR(prog);

kernel/bpf/net_namespace.c

400

ret = __netns_bpf_prog_detach(current->nsproxy->net_ns, type, prog);

kernel/bpf/net_namespace.c

403

bpf_prog_put(prog);

kernel/bpf/net_namespace.c

443

err = flow_dissector_bpf_prog_attach_check(net, link->prog);

kernel/bpf/net_namespace.c

476

int netns_bpf_link_create(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/net_namespace.c

503

&bpf_netns_link_ops, prog, type);

kernel/bpf/net_namespace.c

96

prog_array->items[i].prog = pos->link.prog;

kernel/bpf/offload.c

101

struct bpf_prog_offload *offload = prog->aux->offload;

kernel/bpf/offload.c

104

offload->offdev->ops->destroy(prog);

kernel/bpf/offload.c

108

prog->aux->offload = NULL;

kernel/bpf/offload.c

169

__bpf_prog_offload_destroy(offload->prog);

kernel/bpf/offload.c

179

static int __bpf_prog_dev_bound_init(struct bpf_prog *prog, struct net_device *netdev)

kernel/bpf/offload.c

189

offload->prog = prog;

kernel/bpf/offload.c

196

if (bpf_prog_is_offloaded(prog->aux) && (!ondev || !ondev->offdev)) {

kernel/bpf/offload.c

210

prog->aux->offload = offload;

kernel/bpf/offload.c

219

int bpf_prog_dev_bound_init(struct bpf_prog *prog, union bpf_attr *attr)

kernel/bpf/offload.c

250

prog->aux->offload_requested = !(attr->prog_flags & BPF_F_XDP_DEV_BOUND_ONLY);

kernel/bpf/offload.c

253

err = __bpf_prog_dev_bound_init(prog, netdev);

kernel/bpf/offload.c

287

int bpf_prog_offload_verifier_prep(struct bpf_prog *prog)

kernel/bpf/offload.c

293

offload = prog->aux->offload;

kernel/bpf/offload.c

295

ret = offload->offdev->ops->prepare(prog);

kernel/bpf/offload.c

310

offload = env->prog->aux->offload;

kernel/bpf/offload.c

325

offload = env->prog->aux->offload;

kernel/bpf/offload.c

346

offload = env->prog->aux->offload;

kernel/bpf/offload.c

363

offload = env->prog->aux->offload;

kernel/bpf/offload.c

372

void bpf_prog_dev_bound_destroy(struct bpf_prog *prog)

kernel/bpf/offload.c

379

if (prog->aux->offload) {

kernel/bpf/offload.c

380

list_del_init(&prog->aux->offload->offloads);

kernel/bpf/offload.c

382

netdev = prog->aux->offload->netdev;

kernel/bpf/offload.c

383

__bpf_prog_offload_destroy(prog);

kernel/bpf/offload.c

393

static int bpf_prog_offload_translate(struct bpf_prog *prog)

kernel/bpf/offload.c

399

offload = prog->aux->offload;

kernel/bpf/offload.c

401

ret = offload->offdev->ops->translate(prog);

kernel/bpf/offload.c

414

int bpf_prog_offload_compile(struct bpf_prog *prog)

kernel/bpf/offload.c

416

prog->bpf_func = bpf_prog_warn_on_exec;

kernel/bpf/offload.c

418

return bpf_prog_offload_translate(prog);

kernel/bpf/offload.c

422

struct bpf_prog *prog;

kernel/bpf/offload.c

429

struct bpf_prog_aux *aux = args->prog->aux;

kernel/bpf/offload.c

453

struct bpf_prog *prog)

kernel/bpf/offload.c

456

.prog = prog,

kernel/bpf/offload.c

459

struct bpf_prog_aux *aux = prog->aux;

kernel/bpf/offload.c

689

static bool __bpf_offload_dev_match(struct bpf_prog *prog,

kernel/bpf/offload.c

695

if (!bpf_prog_is_dev_bound(prog->aux))

kernel/bpf/offload.c

698

offload = prog->aux->offload;

kernel/bpf/offload.c

710

bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev)

kernel/bpf/offload.c

715

ret = __bpf_offload_dev_match(prog, netdev);

kernel/bpf/offload.c

738

bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map)

kernel/bpf/offload.c

748

ret = __bpf_offload_dev_match(prog, offmap->netdev);

kernel/bpf/offload.c

834

void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog, u32 func_id)

kernel/bpf/offload.c

845

if (!prog->aux->offload)

kernel/bpf/offload.c

848

ops = prog->aux->offload->netdev->xdp_metadata_ops;

kernel/bpf/offload.c

99

static void __bpf_prog_offload_destroy(struct bpf_prog *prog)

kernel/bpf/preload/iterators/iterators.bpf.c

103

struct bpf_prog *prog = ctx->prog;

kernel/bpf/preload/iterators/iterators.bpf.c

106

if (!prog)

kernel/bpf/preload/iterators/iterators.bpf.c

109

aux = prog->aux;

kernel/bpf/preload/iterators/iterators.bpf.c

55

struct bpf_prog *prog;

kernel/bpf/prog_iter.c

16

struct bpf_prog *prog;

kernel/bpf/prog_iter.c

18

prog = bpf_prog_get_curr_or_next(&info->prog_id);

kernel/bpf/prog_iter.c

19

if (!prog)

kernel/bpf/prog_iter.c

24

return prog;

kernel/bpf/prog_iter.c

39

__bpf_md_ptr(struct bpf_prog *, prog);

kernel/bpf/prog_iter.c

42

DEFINE_BPF_ITER_FUNC(bpf_prog, struct bpf_iter_meta *meta, struct bpf_prog *prog)

kernel/bpf/prog_iter.c

48

struct bpf_prog *prog;

kernel/bpf/prog_iter.c

52

ctx.prog = v;

kernel/bpf/prog_iter.c

54

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/prog_iter.c

55

if (prog)

kernel/bpf/prog_iter.c

56

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/prog_iter.c

94

{ offsetof(struct bpf_iter__bpf_prog, prog),

kernel/bpf/rqspinlock.c

676

struct bpf_prog *prog;

kernel/bpf/rqspinlock.c

678

prog = bpf_prog_find_from_stack();

kernel/bpf/rqspinlock.c

679

if (!prog)

kernel/bpf/rqspinlock.c

681

bpf_stream_stage(ss, prog, BPF_STDERR, ({

kernel/bpf/stream.c

199

int bpf_prog_stream_read(struct bpf_prog *prog, enum bpf_stream_id stream_id, void __user *buf, int len)

kernel/bpf/stream.c

203

stream = bpf_stream_get(stream_id, prog->aux);

kernel/bpf/stream.c

252

struct bpf_prog *prog;

kernel/bpf/stream.c

258

prog = aux->main_prog_aux->prog;

kernel/bpf/stream.c

260

bpf_stream_stage(ss, prog, stream_id, ({

kernel/bpf/stream.c

271

void bpf_prog_stream_init(struct bpf_prog *prog)

kernel/bpf/stream.c

275

for (i = 0; i < ARRAY_SIZE(prog->aux->stream); i++) {

kernel/bpf/stream.c

276

atomic_set(&prog->aux->stream[i].capacity, 0);

kernel/bpf/stream.c

277

init_llist_head(&prog->aux->stream[i].log);

kernel/bpf/stream.c

278

mutex_init(&prog->aux->stream[i].lock);

kernel/bpf/stream.c

279

prog->aux->stream[i].backlog_head = NULL;

kernel/bpf/stream.c

280

prog->aux->stream[i].backlog_tail = NULL;

kernel/bpf/stream.c

284

void bpf_prog_stream_free(struct bpf_prog *prog)

kernel/bpf/stream.c

289

for (i = 0; i < ARRAY_SIZE(prog->aux->stream); i++) {

kernel/bpf/stream.c

290

list = llist_del_all(&prog->aux->stream[i].log);

kernel/bpf/stream.c

292

bpf_stream_free_list(prog->aux->stream[i].backlog_head);

kernel/bpf/stream.c

329

int bpf_stream_stage_commit(struct bpf_stream_stage *ss, struct bpf_prog *prog,

kernel/bpf/stream.c

336

stream = bpf_stream_get(stream_id, prog->aux);

kernel/bpf/stream.c

366

struct bpf_prog *prog;

kernel/bpf/stream.c

370

prog = bpf_prog_ksym_find(ip);

kernel/bpf/stream.c

372

if (prog) {

kernel/bpf/stream.c

373

ret = bpf_prog_get_file_line(prog, ip, &file, &line, &num);

kernel/bpf/syscall.c

2279

static int find_prog_type(enum bpf_prog_type type, struct bpf_prog *prog)

kernel/bpf/syscall.c

2290

if (!bpf_prog_is_offloaded(prog->aux))

kernel/bpf/syscall.c

2291

prog->aux->ops = ops;

kernel/bpf/syscall.c

2293

prog->aux->ops = &bpf_offload_prog_ops;

kernel/bpf/syscall.c

2294

prog->type = type;

kernel/bpf/syscall.c

2309

static void bpf_audit_prog(const struct bpf_prog *prog, unsigned int op)

kernel/bpf/syscall.c

2324

prog->aux->id, bpf_audit_str[op]);

kernel/bpf/syscall.c

2328

static int bpf_prog_alloc_id(struct bpf_prog *prog)

kernel/bpf/syscall.c

2334

id = idr_alloc_cyclic(&prog_idr, prog, 1, INT_MAX, GFP_ATOMIC);

kernel/bpf/syscall.c

2336

prog->aux->id = id;

kernel/bpf/syscall.c

2347

void bpf_prog_free_id(struct bpf_prog *prog)

kernel/bpf/syscall.c

2356

if (!prog->aux->id)

kernel/bpf/syscall.c

2360

idr_remove(&prog_idr, prog->aux->id);

kernel/bpf/syscall.c

2361

prog->aux->id = 0;

kernel/bpf/syscall.c

2372

security_bpf_prog_free(aux->prog);

kernel/bpf/syscall.c

2373

bpf_prog_free(aux->prog);

kernel/bpf/syscall.c

2376

static void __bpf_prog_put_noref(struct bpf_prog *prog, bool deferred)

kernel/bpf/syscall.c

2378

bpf_prog_kallsyms_del_all(prog);

kernel/bpf/syscall.c

2379

btf_put(prog->aux->btf);

kernel/bpf/syscall.c

2380

module_put(prog->aux->mod);

kernel/bpf/syscall.c

2381

kvfree(prog->aux->jited_linfo);

kernel/bpf/syscall.c

2382

kvfree(prog->aux->linfo);

kernel/bpf/syscall.c

2383

kfree(prog->aux->kfunc_tab);

kernel/bpf/syscall.c

2384

kfree(prog->aux->ctx_arg_info);

kernel/bpf/syscall.c

2385

if (prog->aux->attach_btf)

kernel/bpf/syscall.c

2386

btf_put(prog->aux->attach_btf);

kernel/bpf/syscall.c

2389

if (prog->sleepable)

kernel/bpf/syscall.c

2390

call_rcu_tasks_trace(&prog->aux->rcu, __bpf_prog_put_rcu);

kernel/bpf/syscall.c

2392

call_rcu(&prog->aux->rcu, __bpf_prog_put_rcu);

kernel/bpf/syscall.c

2394

__bpf_prog_put_rcu(&prog->aux->rcu);

kernel/bpf/syscall.c

2401

struct bpf_prog *prog;

kernel/bpf/syscall.c

2404

prog = aux->prog;

kernel/bpf/syscall.c

2405

perf_event_bpf_event(prog, PERF_BPF_EVENT_PROG_UNLOAD, 0);

kernel/bpf/syscall.c

2406

bpf_audit_prog(prog, BPF_AUDIT_UNLOAD);

kernel/bpf/syscall.c

2407

bpf_prog_free_id(prog);

kernel/bpf/syscall.c

2408

__bpf_prog_put_noref(prog, true);

kernel/bpf/syscall.c

2411

static void __bpf_prog_put(struct bpf_prog *prog)

kernel/bpf/syscall.c

2413

struct bpf_prog_aux *aux = prog->aux;

kernel/bpf/syscall.c

2425

void bpf_prog_put(struct bpf_prog *prog)

kernel/bpf/syscall.c

2427

__bpf_prog_put(prog);

kernel/bpf/syscall.c

2433

struct bpf_prog *prog = filp->private_data;

kernel/bpf/syscall.c

2435

bpf_prog_put(prog);

kernel/bpf/syscall.c

2445

void notrace bpf_prog_inc_misses_counter(struct bpf_prog *prog)

kernel/bpf/syscall.c

2450

if (unlikely(!prog->stats))

kernel/bpf/syscall.c

2453

stats = this_cpu_ptr(prog->stats);

kernel/bpf/syscall.c

2459

static void bpf_prog_get_stats(const struct bpf_prog *prog,

kernel/bpf/syscall.c

2470

st = per_cpu_ptr(prog->stats, cpu);

kernel/bpf/syscall.c

2489

const struct bpf_prog *prog = filp->private_data;

kernel/bpf/syscall.c

2490

char prog_tag[sizeof(prog->tag) * 2 + 1] = { };

kernel/bpf/syscall.c

2493

bpf_prog_get_stats(prog, &stats);

kernel/bpf/syscall.c

2494

bin2hex(prog_tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

2505

prog->type,

kernel/bpf/syscall.c

2506

prog->jited,

kernel/bpf/syscall.c

2508

prog->pages * 1ULL << PAGE_SHIFT,

kernel/bpf/syscall.c

2509

prog->aux->id,

kernel/bpf/syscall.c

2513

prog->aux->verified_insns);

kernel/bpf/syscall.c

2526

int bpf_prog_new_fd(struct bpf_prog *prog)

kernel/bpf/syscall.c

2530

ret = security_bpf_prog(prog);

kernel/bpf/syscall.c

2534

return anon_inode_getfd("bpf-prog", &bpf_prog_fops, prog,

kernel/bpf/syscall.c

2538

void bpf_prog_add(struct bpf_prog *prog, int i)

kernel/bpf/syscall.c

2540

atomic64_add(i, &prog->aux->refcnt);

kernel/bpf/syscall.c

2544

void bpf_prog_sub(struct bpf_prog *prog, int i)

kernel/bpf/syscall.c

2551

WARN_ON(atomic64_sub_return(i, &prog->aux->refcnt) == 0);

kernel/bpf/syscall.c

2555

void bpf_prog_inc(struct bpf_prog *prog)

kernel/bpf/syscall.c

2557

atomic64_inc(&prog->aux->refcnt);

kernel/bpf/syscall.c

2562

struct bpf_prog *bpf_prog_inc_not_zero(struct bpf_prog *prog)

kernel/bpf/syscall.c

2566

refold = atomic64_fetch_add_unless(&prog->aux->refcnt, 1, 0);

kernel/bpf/syscall.c

2571

return prog;

kernel/bpf/syscall.c

2575

bool bpf_prog_get_ok(struct bpf_prog *prog,

kernel/bpf/syscall.c

2582

if (prog->type != *attach_type)

kernel/bpf/syscall.c

2584

if (bpf_prog_is_offloaded(prog->aux) && !attach_drv)

kernel/bpf/syscall.c

2594

struct bpf_prog *prog;

kernel/bpf/syscall.c

2601

prog = fd_file(f)->private_data;

kernel/bpf/syscall.c

2602

if (!bpf_prog_get_ok(prog, attach_type, attach_drv))

kernel/bpf/syscall.c

2605

bpf_prog_inc(prog);

kernel/bpf/syscall.c

2606

return prog;

kernel/bpf/syscall.c

2808

static int bpf_prog_verify_signature(struct bpf_prog *prog, union bpf_attr *attr,

kernel/bpf/syscall.c

2840

bpf_dynptr_init(&insns_ptr, prog->insnsi, BPF_DYNPTR_TYPE_LOCAL, 0,

kernel/bpf/syscall.c

2841

prog->len * sizeof(struct bpf_insn));

kernel/bpf/syscall.c

2851

static int bpf_prog_mark_insn_arrays_ready(struct bpf_prog *prog)

kernel/bpf/syscall.c

2856

for (i = 0; i < prog->aux->used_map_cnt; i++) {

kernel/bpf/syscall.c

2857

if (prog->aux->used_maps[i]->map_type != BPF_MAP_TYPE_INSN_ARRAY)

kernel/bpf/syscall.c

2860

err = bpf_insn_array_ready(prog->aux->used_maps[i]);

kernel/bpf/syscall.c

2874

struct bpf_prog *prog, *dst_prog = NULL;

kernel/bpf/syscall.c

2993

prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);

kernel/bpf/syscall.c

2994

if (!prog) {

kernel/bpf/syscall.c

3003

prog->expected_attach_type = attr->expected_attach_type;

kernel/bpf/syscall.c

3004

prog->sleepable = !!(attr->prog_flags & BPF_F_SLEEPABLE);

kernel/bpf/syscall.c

3005

prog->aux->attach_btf = attach_btf;

kernel/bpf/syscall.c

3006

prog->aux->attach_btf_id = attr->attach_btf_id;

kernel/bpf/syscall.c

3007

prog->aux->dst_prog = dst_prog;

kernel/bpf/syscall.c

3008

prog->aux->dev_bound = !!attr->prog_ifindex;

kernel/bpf/syscall.c

3009

prog->aux->xdp_has_frags = attr->prog_flags & BPF_F_XDP_HAS_FRAGS;

kernel/bpf/syscall.c

3012

prog->aux->token = token;

kernel/bpf/syscall.c

3015

prog->aux->user = get_current_user();

kernel/bpf/syscall.c

3016

prog->len = attr->insn_cnt;

kernel/bpf/syscall.c

3019

if (copy_from_bpfptr(prog->insns,

kernel/bpf/syscall.c

3021

bpf_prog_insn_size(prog)) != 0)

kernel/bpf/syscall.c

3031

prog->gpl_compatible = license_is_gpl_compatible(license) ? 1 : 0;

kernel/bpf/syscall.c

3034

err = bpf_prog_verify_signature(prog, attr, uattr.is_kernel);

kernel/bpf/syscall.c

3039

prog->orig_prog = NULL;

kernel/bpf/syscall.c

3040

prog->jited = 0;

kernel/bpf/syscall.c

3042

atomic64_set(&prog->aux->refcnt, 1);

kernel/bpf/syscall.c

3044

if (bpf_prog_is_dev_bound(prog->aux)) {

kernel/bpf/syscall.c

3045

err = bpf_prog_dev_bound_init(prog, attr);

kernel/bpf/syscall.c

3052

err = bpf_prog_dev_bound_inherit(prog, dst_prog);

kernel/bpf/syscall.c

3070

prog->aux->attach_tracing_prog = true;

kernel/bpf/syscall.c

3074

err = find_prog_type(type, prog);

kernel/bpf/syscall.c

3078

prog->aux->load_time = ktime_get_boottime_ns();

kernel/bpf/syscall.c

3079

err = bpf_obj_name_cpy(prog->aux->name, attr->prog_name,

kernel/bpf/syscall.c

3084

err = security_bpf_prog_load(prog, attr, token, uattr.is_kernel);

kernel/bpf/syscall.c

3089

err = bpf_check(&prog, attr, uattr, uattr_size);

kernel/bpf/syscall.c

3093

prog = bpf_prog_select_runtime(prog, &err);

kernel/bpf/syscall.c

3097

err = bpf_prog_mark_insn_arrays_ready(prog);

kernel/bpf/syscall.c

3101

err = bpf_prog_alloc_id(prog);

kernel/bpf/syscall.c

3119

bpf_prog_kallsyms_add(prog);

kernel/bpf/syscall.c

3120

perf_event_bpf_event(prog, PERF_BPF_EVENT_PROG_LOAD, 0);

kernel/bpf/syscall.c

3121

bpf_audit_prog(prog, BPF_AUDIT_LOAD);

kernel/bpf/syscall.c

3123

err = bpf_prog_new_fd(prog);

kernel/bpf/syscall.c

3125

bpf_prog_put(prog);

kernel/bpf/syscall.c

3133

__bpf_prog_put_noref(prog, prog->aux->real_func_cnt);

kernel/bpf/syscall.c

3137

security_bpf_prog_free(prog);

kernel/bpf/syscall.c

3139

free_uid(prog->aux->user);

kernel/bpf/syscall.c

3140

if (prog->aux->attach_btf)

kernel/bpf/syscall.c

3141

btf_put(prog->aux->attach_btf);

kernel/bpf/syscall.c

3142

bpf_prog_free(prog);

kernel/bpf/syscall.c

3192

const struct bpf_link_ops *ops, struct bpf_prog *prog,

kernel/bpf/syscall.c

3201

link->prog = prog;

kernel/bpf/syscall.c

3206

const struct bpf_link_ops *ops, struct bpf_prog *prog,

kernel/bpf/syscall.c

3209

bpf_link_init_sleepable(link, type, ops, prog, attach_type, false);

kernel/bpf/syscall.c

3233

primer->link->prog = NULL;

kernel/bpf/syscall.c

3247

if (link->prog)

kernel/bpf/syscall.c

3248

bpf_prog_put(link->prog);

kernel/bpf/syscall.c

3291

if (link->prog)

kernel/bpf/syscall.c

3308

if (link->sleepable || (link->prog && link->prog->sleepable))

kernel/bpf/syscall.c

3370

const struct bpf_prog *prog = link->prog;

kernel/bpf/syscall.c

3372

char prog_tag[sizeof(prog->tag) * 2 + 1] = { };

kernel/bpf/syscall.c

3389

if (prog) {

kernel/bpf/syscall.c

3390

bin2hex(prog_tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

3395

prog->aux->id);

kernel/bpf/syscall.c

3587

static int bpf_tracing_prog_attach(struct bpf_prog *prog,

kernel/bpf/syscall.c

3600

switch (prog->type) {

kernel/bpf/syscall.c

3602

if (prog->expected_attach_type != BPF_TRACE_FENTRY &&

kernel/bpf/syscall.c

3603

prog->expected_attach_type != BPF_TRACE_FEXIT &&

kernel/bpf/syscall.c

3604

prog->expected_attach_type != BPF_TRACE_FSESSION &&

kernel/bpf/syscall.c

3605

prog->expected_attach_type != BPF_MODIFY_RETURN) {

kernel/bpf/syscall.c

3611

if (prog->expected_attach_type != 0) {

kernel/bpf/syscall.c

3617

if (prog->expected_attach_type != BPF_LSM_MAC) {

kernel/bpf/syscall.c

3639

if (prog->type != BPF_PROG_TYPE_EXT) {

kernel/bpf/syscall.c

3654

if (prog->expected_attach_type == BPF_TRACE_FSESSION) {

kernel/bpf/syscall.c

3660

&bpf_tracing_link_lops, prog, attach_type);

kernel/bpf/syscall.c

3674

&bpf_tracing_link_lops, prog, attach_type);

kernel/bpf/syscall.c

3678

mutex_lock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

3702

if (!prog->aux->dst_trampoline && !tgt_prog) {

kernel/bpf/syscall.c

3709

if (prog->type != BPF_PROG_TYPE_TRACING &&

kernel/bpf/syscall.c

3710

prog->type != BPF_PROG_TYPE_LSM) {

kernel/bpf/syscall.c

3715

if (!prog->aux->attach_btf) {

kernel/bpf/syscall.c

3719

btf_id = prog->aux->attach_btf_id;

kernel/bpf/syscall.c

3720

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf, btf_id);

kernel/bpf/syscall.c

3723

if (!prog->aux->dst_trampoline ||

kernel/bpf/syscall.c

3724

(key && key != prog->aux->dst_trampoline->key)) {

kernel/bpf/syscall.c

3731

err = bpf_check_attach_target(NULL, prog, tgt_prog, btf_id,

kernel/bpf/syscall.c

3737

module_put(prog->aux->mod);

kernel/bpf/syscall.c

3738

prog->aux->mod = tgt_info.tgt_mod;

kernel/bpf/syscall.c

3754

tr = prog->aux->dst_trampoline;

kernel/bpf/syscall.c

3755

tgt_prog = prog->aux->dst_prog;

kernel/bpf/syscall.c

3776

if (prog->aux->dst_prog &&

kernel/bpf/syscall.c

3777

(tgt_prog_fd || tr != prog->aux->dst_trampoline))

kernel/bpf/syscall.c

3779

bpf_prog_put(prog->aux->dst_prog);

kernel/bpf/syscall.c

3780

if (prog->aux->dst_trampoline && tr != prog->aux->dst_trampoline)

kernel/bpf/syscall.c

3782

bpf_trampoline_put(prog->aux->dst_trampoline);

kernel/bpf/syscall.c

3784

prog->aux->dst_prog = NULL;

kernel/bpf/syscall.c

3785

prog->aux->dst_trampoline = NULL;

kernel/bpf/syscall.c

3786

mutex_unlock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

3790

if (tr && tr != prog->aux->dst_trampoline)

kernel/bpf/syscall.c

3792

mutex_unlock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

4105

switch (event->prog->type) {

kernel/bpf/syscall.c

4173

switch (event->prog->type) {

kernel/bpf/syscall.c

4192

static int bpf_perf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/syscall.c

4212

bpf_link_init(&link->link, BPF_LINK_TYPE_PERF_EVENT, &bpf_perf_link_lops, prog,

kernel/bpf/syscall.c

4223

err = perf_event_set_bpf_prog(event, prog, attr->link_create.perf_event.bpf_cookie);

kernel/bpf/syscall.c

4229

bpf_prog_inc(prog);

kernel/bpf/syscall.c

4238

static int bpf_perf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/syscall.c

4244

static int bpf_raw_tp_link_attach(struct bpf_prog *prog,

kernel/bpf/syscall.c

4255

switch (prog->type) {

kernel/bpf/syscall.c

4264

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/bpf/syscall.c

4265

prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/syscall.c

4266

tp_name = prog->aux->attach_func_name;

kernel/bpf/syscall.c

4269

return bpf_tracing_prog_attach(prog, 0, 0, 0, attach_type);

kernel/bpf/syscall.c

4291

&bpf_raw_tp_link_lops, prog, attach_type,

kernel/bpf/syscall.c

4319

struct bpf_prog *prog;

kernel/bpf/syscall.c

4327

prog = bpf_prog_get(attr->raw_tracepoint.prog_fd);

kernel/bpf/syscall.c

4328

if (IS_ERR(prog))

kernel/bpf/syscall.c

4329

return PTR_ERR(prog);

kernel/bpf/syscall.c

4333

fd = bpf_raw_tp_link_attach(prog, tp_name, cookie, prog->expected_attach_type);

kernel/bpf/syscall.c

4335

bpf_prog_put(prog);

kernel/bpf/syscall.c

4413

static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,

kernel/bpf/syscall.c

4418

switch (prog->type) {

kernel/bpf/syscall.c

4423

return attach_type == prog->expected_attach_type ? 0 : -EINVAL;

kernel/bpf/syscall.c

4425

if (!bpf_token_capable(prog->aux->token, CAP_NET_ADMIN))

kernel/bpf/syscall.c

4432

if (prog->type != ptype)

kernel/bpf/syscall.c

4435

return prog->enforce_expected_attach_type &&

kernel/bpf/syscall.c

4436

prog->expected_attach_type != attach_type ?

kernel/bpf/syscall.c

4450

if (prog->expected_attach_type == BPF_TRACE_KPROBE_MULTI &&

kernel/bpf/syscall.c

4453

if (prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION &&

kernel/bpf/syscall.c

4456

if (prog->expected_attach_type == BPF_TRACE_UPROBE_MULTI &&

kernel/bpf/syscall.c

4459

if (prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION &&

kernel/bpf/syscall.c

4478

if (ptype == BPF_PROG_TYPE_UNSPEC || ptype != prog->type)

kernel/bpf/syscall.c

4521

struct bpf_prog *prog;

kernel/bpf/syscall.c

4544

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/syscall.c

4545

if (IS_ERR(prog))

kernel/bpf/syscall.c

4546

return PTR_ERR(prog);

kernel/bpf/syscall.c

4548

if (bpf_prog_attach_check_attach_type(prog, attr->attach_type)) {

kernel/bpf/syscall.c

4549

bpf_prog_put(prog);

kernel/bpf/syscall.c

4553

if (is_cgroup_prog_type(ptype, prog->expected_attach_type, true)) {

kernel/bpf/syscall.c

4554

ret = cgroup_bpf_prog_attach(attr, ptype, prog);

kernel/bpf/syscall.c

4561

ret = sock_map_get_from_fd(attr, prog);

kernel/bpf/syscall.c

4564

ret = lirc_prog_attach(attr, prog);

kernel/bpf/syscall.c

4567

ret = netns_bpf_prog_attach(attr, prog);

kernel/bpf/syscall.c

4572

ret = tcx_prog_attach(attr, prog);

kernel/bpf/syscall.c

4574

ret = netkit_prog_attach(attr, prog);

kernel/bpf/syscall.c

4581

bpf_prog_put(prog);

kernel/bpf/syscall.c

4589

struct bpf_prog *prog = NULL;

kernel/bpf/syscall.c

4603

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/syscall.c

4604

if (IS_ERR(prog))

kernel/bpf/syscall.c

4605

return PTR_ERR(prog);

kernel/bpf/syscall.c

4642

ret = tcx_prog_detach(attr, prog);

kernel/bpf/syscall.c

4644

ret = netkit_prog_detach(attr, prog);

kernel/bpf/syscall.c

4650

if (prog)

kernel/bpf/syscall.c

4651

bpf_prog_put(prog);

kernel/bpf/syscall.c

4724

struct bpf_prog *prog;

kernel/bpf/syscall.c

4738

prog = bpf_prog_get(attr->test.prog_fd);

kernel/bpf/syscall.c

4739

if (IS_ERR(prog))

kernel/bpf/syscall.c

4740

return PTR_ERR(prog);

kernel/bpf/syscall.c

4742

if (prog->aux->ops->test_run)

kernel/bpf/syscall.c

4743

ret = prog->aux->ops->test_run(prog, attr, uattr);

kernel/bpf/syscall.c

4745

bpf_prog_put(prog);

kernel/bpf/syscall.c

4798

struct bpf_prog *prog;

kernel/bpf/syscall.c

4802

prog = idr_get_next(&prog_idr, id);

kernel/bpf/syscall.c

4803

if (prog) {

kernel/bpf/syscall.c

4804

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/syscall.c

4805

if (IS_ERR(prog)) {

kernel/bpf/syscall.c

4812

return prog;

kernel/bpf/syscall.c

4819

struct bpf_prog *prog;

kernel/bpf/syscall.c

4825

prog = idr_find(&prog_idr, id);

kernel/bpf/syscall.c

4826

if (prog)

kernel/bpf/syscall.c

4827

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/syscall.c

4829

prog = ERR_PTR(-ENOENT);

kernel/bpf/syscall.c

4831

return prog;

kernel/bpf/syscall.c

4836

struct bpf_prog *prog;

kernel/bpf/syscall.c

4846

prog = bpf_prog_by_id(id);

kernel/bpf/syscall.c

4847

if (IS_ERR(prog))

kernel/bpf/syscall.c

4848

return PTR_ERR(prog);

kernel/bpf/syscall.c

4850

fd = bpf_prog_new_fd(prog);

kernel/bpf/syscall.c

4852

bpf_prog_put(prog);

kernel/bpf/syscall.c

4895

static const struct bpf_map *bpf_map_from_imm(const struct bpf_prog *prog,

kernel/bpf/syscall.c

4902

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

4903

for (i = 0, *off = 0; i < prog->aux->used_map_cnt; i++) {

kernel/bpf/syscall.c

4904

map = prog->aux->used_maps[i];

kernel/bpf/syscall.c

4919

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

4923

static struct bpf_insn *bpf_insn_prepare_dump(const struct bpf_prog *prog,

kernel/bpf/syscall.c

4933

insns = kmemdup(prog->insnsi, bpf_prog_insn_size(prog),

kernel/bpf/syscall.c

4938

for (i = 0; i < prog->len; i++) {

kernel/bpf/syscall.c

4969

map = bpf_map_from_imm(prog, imm, &off, &type);

kernel/bpf/syscall.c

5013

struct bpf_prog *prog,

kernel/bpf/syscall.c

5018

struct btf *attach_btf = bpf_prog_get_target_btf(prog);

kernel/bpf/syscall.c

5035

info.type = prog->type;

kernel/bpf/syscall.c

5036

info.id = prog->aux->id;

kernel/bpf/syscall.c

5037

info.load_time = prog->aux->load_time;

kernel/bpf/syscall.c

5039

prog->aux->user->uid);

kernel/bpf/syscall.c

5040

info.gpl_compatible = prog->gpl_compatible;

kernel/bpf/syscall.c

5042

memcpy(info.tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

5043

memcpy(info.name, prog->aux->name, sizeof(prog->aux->name));

kernel/bpf/syscall.c

5045

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5047

info.nr_map_ids = prog->aux->used_map_cnt;

kernel/bpf/syscall.c

5054

if (put_user(prog->aux->used_maps[i]->id,

kernel/bpf/syscall.c

5056

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5060

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5066

bpf_prog_get_stats(prog, &stats);

kernel/bpf/syscall.c

5071

info.verified_insns = prog->aux->verified_insns;

kernel/bpf/syscall.c

5072

if (prog->aux->btf)

kernel/bpf/syscall.c

5073

info.btf_id = btf_obj_id(prog->aux->btf);

kernel/bpf/syscall.c

5087

info.xlated_prog_len = bpf_prog_insn_size(prog);

kernel/bpf/syscall.c

5092

if (!prog->blinded || bpf_dump_raw_ok(file->f_cred)) {

kernel/bpf/syscall.c

5093

insns_sanitized = bpf_insn_prepare_dump(prog, file->f_cred);

kernel/bpf/syscall.c

5107

if (bpf_prog_is_offloaded(prog->aux)) {

kernel/bpf/syscall.c

5108

err = bpf_prog_offload_info_fill(&info, prog);

kernel/bpf/syscall.c

5119

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5123

for (i = 0; i < prog->aux->func_cnt; i++)

kernel/bpf/syscall.c

5124

info.jited_prog_len += prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5126

info.jited_prog_len = prog->jited_len;

kernel/bpf/syscall.c

5137

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5142

for (i = 0; i < prog->aux->func_cnt; i++) {

kernel/bpf/syscall.c

5143

len = prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5145

img = (u8 *) prog->aux->func[i]->bpf_func;

kernel/bpf/syscall.c

5154

if (copy_to_user(uinsns, prog->bpf_func, ulen))

kernel/bpf/syscall.c

5163

info.nr_jited_ksyms = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5175

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5178

prog->aux->func[i]->bpf_func;

kernel/bpf/syscall.c

5184

ksym_addr = (unsigned long) prog->bpf_func;

kernel/bpf/syscall.c

5194

info.nr_jited_func_lens = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5203

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5206

prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5211

func_len = prog->jited_len;

kernel/bpf/syscall.c

5220

info.attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/syscall.c

5225

info.nr_func_info = prog->aux->func_info_cnt;

kernel/bpf/syscall.c

5231

if (copy_to_user(user_finfo, prog->aux->func_info,

kernel/bpf/syscall.c

5237

info.nr_line_info = prog->aux->nr_linfo;

kernel/bpf/syscall.c

5243

if (copy_to_user(user_linfo, prog->aux->linfo,

kernel/bpf/syscall.c

5249

if (prog->aux->jited_linfo)

kernel/bpf/syscall.c

5250

info.nr_jited_line_info = prog->aux->nr_linfo;

kernel/bpf/syscall.c

5262

line_addr = (unsigned long)prog->aux->jited_linfo[i];

kernel/bpf/syscall.c

5272

info.nr_prog_tags = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5279

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5282

prog->aux->func[i]->tag,

kernel/bpf/syscall.c

5288

prog->tag, BPF_TAG_SIZE))

kernel/bpf/syscall.c

5410

if (link->prog)

kernel/bpf/syscall.c

5411

info.prog_id = link->prog->aux->id;

kernel/bpf/syscall.c

5613

raw_tp->link.prog->aux->id,

kernel/bpf/syscall.c

5704

struct bpf_prog *prog;

kernel/bpf/syscall.c

5713

prog = bpf_prog_get(attr->link_create.prog_fd);

kernel/bpf/syscall.c

5714

if (IS_ERR(prog))

kernel/bpf/syscall.c

5715

return PTR_ERR(prog);

kernel/bpf/syscall.c

5717

ret = bpf_prog_attach_check_attach_type(prog,

kernel/bpf/syscall.c

5722

switch (prog->type) {

kernel/bpf/syscall.c

5730

ret = cgroup_bpf_link_attach(attr, prog);

kernel/bpf/syscall.c

5733

ret = bpf_tracing_prog_attach(prog,

kernel/bpf/syscall.c

5741

if (attr->link_create.attach_type != prog->expected_attach_type) {

kernel/bpf/syscall.c

5745

if (prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/bpf/syscall.c

5746

ret = bpf_raw_tp_link_attach(prog, NULL, attr->link_create.tracing.cookie,

kernel/bpf/syscall.c

5748

else if (prog->expected_attach_type == BPF_TRACE_ITER)

kernel/bpf/syscall.c

5749

ret = bpf_iter_link_attach(attr, uattr, prog);

kernel/bpf/syscall.c

5750

else if (prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/syscall.c

5751

ret = cgroup_bpf_link_attach(attr, prog);

kernel/bpf/syscall.c

5753

ret = bpf_tracing_prog_attach(prog,

kernel/bpf/syscall.c

5761

ret = netns_bpf_link_create(attr, prog);

kernel/bpf/syscall.c

5765

ret = sock_map_link_create(attr, prog);

kernel/bpf/syscall.c

5769

ret = bpf_xdp_link_attach(attr, prog);

kernel/bpf/syscall.c

5774

ret = tcx_link_attach(attr, prog);

kernel/bpf/syscall.c

5776

ret = netkit_link_attach(attr, prog);

kernel/bpf/syscall.c

5779

ret = bpf_nf_link_attach(attr, prog);

kernel/bpf/syscall.c

5784

ret = bpf_perf_link_attach(attr, prog);

kernel/bpf/syscall.c

5788

ret = bpf_perf_link_attach(attr, prog);

kernel/bpf/syscall.c

5791

ret = bpf_kprobe_multi_link_attach(attr, prog);

kernel/bpf/syscall.c

5794

ret = bpf_uprobe_multi_link_attach(attr, prog);

kernel/bpf/syscall.c

5802

bpf_prog_put(prog);

kernel/bpf/syscall.c

6069

struct bpf_prog *prog;

kernel/bpf/syscall.c

6080

prog = bpf_prog_get(attr->prog_bind_map.prog_fd);

kernel/bpf/syscall.c

6081

if (IS_ERR(prog))

kernel/bpf/syscall.c

6082

return PTR_ERR(prog);

kernel/bpf/syscall.c

6090

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

6092

used_maps_old = prog->aux->used_maps;

kernel/bpf/syscall.c

6094

for (i = 0; i < prog->aux->used_map_cnt; i++)

kernel/bpf/syscall.c

6101

prog->aux->used_map_cnt + 1);

kernel/bpf/syscall.c

6110

if (prog->sleepable)

kernel/bpf/syscall.c

6113

sizeof(used_maps_old[0]) * prog->aux->used_map_cnt);

kernel/bpf/syscall.c

6114

used_maps_new[prog->aux->used_map_cnt] = map;

kernel/bpf/syscall.c

6116

prog->aux->used_map_cnt++;

kernel/bpf/syscall.c

6117

prog->aux->used_maps = used_maps_new;

kernel/bpf/syscall.c

6122

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

6127

bpf_prog_put(prog);

kernel/bpf/syscall.c

6151

struct bpf_prog *prog;

kernel/bpf/syscall.c

6157

prog = bpf_prog_get(attr->prog_stream_read.prog_fd);

kernel/bpf/syscall.c

6158

if (IS_ERR(prog))

kernel/bpf/syscall.c

6159

return PTR_ERR(prog);

kernel/bpf/syscall.c

6161

ret = bpf_prog_stream_read(prog, attr->prog_stream_read.stream_id, buf, len);

kernel/bpf/syscall.c

6162

bpf_prog_put(prog);

kernel/bpf/syscall.c

6171

struct bpf_prog *prog;

kernel/bpf/syscall.c

6181

prog = bpf_prog_get(attr->prog_assoc_struct_ops.prog_fd);

kernel/bpf/syscall.c

6182

if (IS_ERR(prog))

kernel/bpf/syscall.c

6183

return PTR_ERR(prog);

kernel/bpf/syscall.c

6185

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS) {

kernel/bpf/syscall.c

6201

ret = bpf_prog_assoc_struct_ops(prog, map);

kernel/bpf/syscall.c

6206

bpf_prog_put(prog);

kernel/bpf/syscall.c

6367

const struct bpf_prog *prog,

kernel/bpf/syscall.c

6406

struct bpf_prog * __maybe_unused prog;

kernel/bpf/syscall.c

6417

prog = bpf_prog_get_type(attr->test.prog_fd, BPF_PROG_TYPE_SYSCALL);

kernel/bpf/syscall.c

6418

if (IS_ERR(prog))

kernel/bpf/syscall.c

6419

return PTR_ERR(prog);

kernel/bpf/syscall.c

6421

if (attr->test.ctx_size_in < prog->aux->max_ctx_offset ||

kernel/bpf/syscall.c

6423

bpf_prog_put(prog);

kernel/bpf/syscall.c

6428

if (!__bpf_prog_enter_sleepable_recur(prog, &run_ctx)) {

kernel/bpf/syscall.c

6430

__bpf_prog_exit_sleepable_recur(prog, 0, &run_ctx);

kernel/bpf/syscall.c

6431

bpf_prog_put(prog);

kernel/bpf/syscall.c

6434

attr->test.retval = bpf_prog_run(prog, (void *) (long) attr->test.ctx_in);

kernel/bpf/syscall.c

6435

__bpf_prog_exit_sleepable_recur(prog, 0 /* bpf_prog_run does runtime stats */,

kernel/bpf/syscall.c

6437

bpf_prog_put(prog);

kernel/bpf/syscall.c

6456

tracing_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/syscall.c

6458

return bpf_base_func_proto(func_id, prog);

kernel/bpf/syscall.c

6506

syscall_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/bpf/syscall.c

6510

return !bpf_token_capable(prog->aux->token, CAP_PERFMON)

kernel/bpf/syscall.c

6519

return tracing_prog_func_proto(func_id, prog);

kernel/bpf/task_iter.c

180

struct bpf_prog *prog;

kernel/bpf/task_iter.c

183

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

184

if (!prog)

kernel/bpf/task_iter.c

189

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/task_iter.c

205

static int bpf_iter_attach_task(struct bpf_prog *prog,

kernel/bpf/task_iter.c

349

struct bpf_prog *prog;

kernel/bpf/task_iter.c

352

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

353

if (!prog)

kernel/bpf/task_iter.c

360

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/task_iter.c

611

struct bpf_prog *prog;

kernel/bpf/task_iter.c

614

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

615

if (!prog)

kernel/bpf/task_iter.c

621

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/tcx.c

10

int tcx_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/tcx.c

115

bpf_prog_put(tuple.prog);

kernel/bpf/tcx.c

154

ret = bpf_mprog_attach(entry, &entry_new, link->prog, link, NULL, flags,

kernel/bpf/tcx.c

186

ret = bpf_mprog_detach(entry, &entry_new, link->prog, link, 0, 0, 0);

kernel/bpf/tcx.c

218

if (oprog && link->prog != oprog) {

kernel/bpf/tcx.c

222

oprog = link->prog;

kernel/bpf/tcx.c

234

link->prog->aux->id, 0);

kernel/bpf/tcx.c

237

oprog = xchg(&link->prog, nprog);

kernel/bpf/tcx.c

27

prog->type);

kernel/bpf/tcx.c

302

struct bpf_prog *prog)

kernel/bpf/tcx.c

304

bpf_link_init(&tcx->link, BPF_LINK_TYPE_TCX, &tcx_link_lops, prog,

kernel/bpf/tcx.c

310

int tcx_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/tcx.c

329

ret = tcx_link_init(tcx, &link_primer, attr, dev, prog);

kernel/bpf/tcx.c

39

ret = bpf_mprog_attach(entry, &entry_new, prog, NULL, replace_prog,

kernel/bpf/tcx.c

59

int tcx_prog_detach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/bpf/tcx.c

78

ret = bpf_mprog_detach(entry, &entry_new, prog, NULL, attr->attach_flags,

kernel/bpf/trampoline.c

1014

shim_link = cgroup_shim_alloc(prog, bpf_func, cgroup_atype, attach_type);

kernel/bpf/trampoline.c

1042

void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog)

kernel/bpf/trampoline.c

1049

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf,

kernel/bpf/trampoline.c

1050

prog->aux->attach_btf_id);

kernel/bpf/trampoline.c

1052

bpf_lsm_find_cgroup_shim(prog, &bpf_func);

kernel/bpf/trampoline.c

1143

static u64 notrace __bpf_prog_enter_recur(struct bpf_prog *prog, struct bpf_tramp_run_ctx *run_ctx)

kernel/bpf/trampoline.c

1150

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/bpf/trampoline.c

1151

bpf_prog_inc_misses_counter(prog);

kernel/bpf/trampoline.c

1152

if (prog->aux->recursion_detected)

kernel/bpf/trampoline.c

1153

prog->aux->recursion_detected(prog);

kernel/bpf/trampoline.c

1159

static void notrace __update_prog_stats(struct bpf_prog *prog, u64 start)

kernel/bpf/trampoline.c

1173

stats = this_cpu_ptr(prog->stats);

kernel/bpf/trampoline.c

1180

static __always_inline void notrace update_prog_stats(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1184

__update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1187

static void notrace __bpf_prog_exit_recur(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1193

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1194

bpf_prog_put_recursion_context(prog);

kernel/bpf/trampoline.c

1198

static u64 notrace __bpf_prog_enter_lsm_cgroup(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1212

static void notrace __bpf_prog_exit_lsm_cgroup(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1221

u64 notrace __bpf_prog_enter_sleepable_recur(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1230

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/bpf/trampoline.c

1231

bpf_prog_inc_misses_counter(prog);

kernel/bpf/trampoline.c

1232

if (prog->aux->recursion_detected)

kernel/bpf/trampoline.c

1233

prog->aux->recursion_detected(prog);

kernel/bpf/trampoline.c

1239

void notrace __bpf_prog_exit_sleepable_recur(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1244

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1245

bpf_prog_put_recursion_context(prog);

kernel/bpf/trampoline.c

1250

static u64 notrace __bpf_prog_enter_sleepable(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1262

static void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1267

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1272

static u64 notrace __bpf_prog_enter(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1283

static void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1289

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1303

bpf_trampoline_enter_t bpf_trampoline_enter(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

1305

bool sleepable = prog->sleepable;

kernel/bpf/trampoline.c

1307

if (bpf_prog_check_recur(prog))

kernel/bpf/trampoline.c

1311

if (resolve_prog_type(prog) == BPF_PROG_TYPE_LSM &&

kernel/bpf/trampoline.c

1312

prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/trampoline.c

1318

bpf_trampoline_exit_t bpf_trampoline_exit(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

1320

bool sleepable = prog->sleepable;

kernel/bpf/trampoline.c

1322

if (bpf_prog_check_recur(prog))

kernel/bpf/trampoline.c

1326

if (resolve_prog_type(prog) == BPF_PROG_TYPE_LSM &&

kernel/bpf/trampoline.c

1327

prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/trampoline.c

137

bool bpf_prog_has_trampoline(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

139

enum bpf_attach_type eatype = prog->expected_attach_type;

kernel/bpf/trampoline.c

140

enum bpf_prog_type ptype = prog->type;

kernel/bpf/trampoline.c

459

*ip_arg |= link->link.prog->call_get_func_ip;

kernel/bpf/trampoline.c

725

static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog)

kernel/bpf/trampoline.c

727

switch (prog->expected_attach_type) {

kernel/bpf/trampoline.c

737

if (!prog->aux->attach_func_proto->type)

kernel/bpf/trampoline.c

778

kind = bpf_attach_type_to_tramp(link->link.prog);

kernel/bpf/trampoline.c

795

tr->extension_prog = link->link.prog;

kernel/bpf/trampoline.c

798

link->link.prog->bpf_func);

kernel/bpf/trampoline.c

812

if (link_exiting->link.prog != link->link.prog)

kernel/bpf/trampoline.c

860

kind = bpf_attach_type_to_tramp(link->link.prog);

kernel/bpf/trampoline.c

923

static struct bpf_shim_tramp_link *cgroup_shim_alloc(const struct bpf_prog *prog,

kernel/bpf/trampoline.c

945

p->aux->attach_func_proto = prog->aux->attach_func_proto;

kernel/bpf/trampoline.c

946

p->aux->attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/trampoline.c

947

p->aux->attach_btf = prog->aux->attach_btf;

kernel/bpf/trampoline.c

967

struct bpf_prog *p = link->link.prog;

kernel/bpf/trampoline.c

977

int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

kernel/bpf/trampoline.c

988

err = bpf_check_attach_target(NULL, prog, NULL,

kernel/bpf/trampoline.c

989

prog->aux->attach_btf_id,

kernel/bpf/trampoline.c

994

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf,

kernel/bpf/trampoline.c

995

prog->aux->attach_btf_id);

kernel/bpf/trampoline.c

997

bpf_lsm_find_cgroup_shim(prog, &bpf_func);

kernel/bpf/verifier.c

10133

enum bpf_attach_type eatype = env->prog->expected_attach_type;

kernel/bpf/verifier.c

10134

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

10171

return env->prog->jit_requested &&

kernel/bpf/verifier.c

10792

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

10793

struct btf *btf = prog->aux->btf;

kernel/bpf/verifier.c

10797

if (!prog->aux->func_info)

kernel/bpf/verifier.c

10800

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

kernel/bpf/verifier.c

10804

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

kernel/bpf/verifier.c

10813

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

kernel/bpf/verifier.c

11209

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

11452

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

11549

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

11553

if (!bpf_prog_has_trampoline(env->prog)) {

kernel/bpf/verifier.c

11626

*ptr = env->ops->get_func_proto(func_id, env->prog);

kernel/bpf/verifier.c

11643

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

11669

if (!env->prog->gpl_compatible && fn->gpl_only) {

kernel/bpf/verifier.c

11674

if (fn->allowed && !fn->allowed(env->prog)) {

kernel/bpf/verifier.c

11852

env->prog->expected_attach_type == BPF_LSM_CGROUP) {

kernel/bpf/verifier.c

11853

if (!env->prog->aux->attach_func_proto->type) {

kernel/bpf/verifier.c

12125

!env->prog->has_callchain_buf) {

kernel/bpf/verifier.c

12140

env->prog->has_callchain_buf = true;

kernel/bpf/verifier.c

12144

env->prog->call_get_stack = true;

kernel/bpf/verifier.c

12149

env->prog->call_get_func_ip = true;

kernel/bpf/verifier.c

12705

if (btf_is_prog_ctx_type(&env->log, meta->btf, t, resolve_prog_type(env->prog), argno))

kernel/bpf/verifier.c

13341

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

13347

if (env->prog->expected_attach_type == BPF_TRACE_ITER)

kernel/bpf/verifier.c

13566

ret = get_kern_ctx_btf_id(&env->log, resolve_prog_type(env->prog));

kernel/bpf/verifier.c

13920

if (!kfunc.flags || !btf_kfunc_is_allowed(kfunc.btf, kfunc.id, env->prog))

kernel/bpf/verifier.c

13957

ret_btf = env->prog->aux->btf;

kernel/bpf/verifier.c

14500

env->prog->call_session_cookie = true;

kernel/bpf/verifier.c

16423

if (!env->prog->aux->arena) {

kernel/bpf/verifier.c

17796

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

17873

if (!may_access_skb(resolve_prog_type(env->prog))) {

kernel/bpf/verifier.c

17940

const struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

17943

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

17954

if (prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/verifier.c

17957

if (!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

17961

if (!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

17972

ret_type = btf_type_resolve_ptr(prog->aux->attach_btf,

kernel/bpf/verifier.c

17973

prog->aux->attach_func_proto->type,

kernel/bpf/verifier.c

18015

if (env->prog->expected_attach_type == BPF_CGROUP_UDP4_RECVMSG ||

kernel/bpf/verifier.c

18016

env->prog->expected_attach_type == BPF_CGROUP_UDP6_RECVMSG ||

kernel/bpf/verifier.c

18017

env->prog->expected_attach_type == BPF_CGROUP_UNIX_RECVMSG ||

kernel/bpf/verifier.c

18018

env->prog->expected_attach_type == BPF_CGROUP_INET4_GETPEERNAME ||

kernel/bpf/verifier.c

18019

env->prog->expected_attach_type == BPF_CGROUP_INET6_GETPEERNAME ||

kernel/bpf/verifier.c

18020

env->prog->expected_attach_type == BPF_CGROUP_UNIX_GETPEERNAME ||

kernel/bpf/verifier.c

18021

env->prog->expected_attach_type == BPF_CGROUP_INET4_GETSOCKNAME ||

kernel/bpf/verifier.c

18022

env->prog->expected_attach_type == BPF_CGROUP_INET6_GETSOCKNAME ||

kernel/bpf/verifier.c

18023

env->prog->expected_attach_type == BPF_CGROUP_UNIX_GETSOCKNAME)

kernel/bpf/verifier.c

18025

if (env->prog->expected_attach_type == BPF_CGROUP_INET4_BIND ||

kernel/bpf/verifier.c

18026

env->prog->expected_attach_type == BPF_CGROUP_INET6_BIND)

kernel/bpf/verifier.c

1803

return env->prog->len;

kernel/bpf/verifier.c

18030

if (env->prog->expected_attach_type == BPF_CGROUP_INET_EGRESS) {

kernel/bpf/verifier.c

18042

if (!env->prog->aux->attach_btf_id)

kernel/bpf/verifier.c

18047

switch (env->prog->expected_attach_type) {

kernel/bpf/verifier.c

18063

switch (env->prog->expected_attach_type) {

kernel/bpf/verifier.c

18077

if (env->prog->expected_attach_type != BPF_LSM_CGROUP) {

kernel/bpf/verifier.c

18079

if (!get_func_retval_range(env->prog, &range))

kernel/bpf/verifier.c

18085

} else if (!env->prog->aux->attach_func_proto->type) {

kernel/bpf/verifier.c

18123

prog->expected_attach_type == BPF_LSM_CGROUP &&

kernel/bpf/verifier.c

18125

!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

18132

env->prog->enforce_expected_attach_type = 1;

kernel/bpf/verifier.c

18259

if (w < 0 || w >= env->prog->len) {

kernel/bpf/verifier.c

18275

if (env->cfg.cur_stack >= env->prog->len)

kernel/bpf/verifier.c

18337

return env->prog->jit_requested && bpf_jit_supports_percpu_insn();

kernel/bpf/verifier.c

18472

struct bpf_insn *insns = env->prog->insnsi, *stx, *ldx;

kernel/bpf/verifier.c

18473

struct bpf_insn *call = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

18503

if (insn_idx - i < 0 || insn_idx + i >= env->prog->len)

kernel/bpf/verifier.c

18566

insn = env->prog->insnsi + i;

kernel/bpf/verifier.c

18574

insn = env->prog->insnsi + i;

kernel/bpf/verifier.c

18783

if (w < 0 || w >= env->prog->len) {

kernel/bpf/verifier.c

18794

if (env->cfg.cur_stack >= env->prog->len)

kernel/bpf/verifier.c

18831

struct bpf_insn *insns = env->prog->insnsi, *insn = &insns[t];

kernel/bpf/verifier.c

18955

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

19014

struct bpf_insn *insn = &env->prog->insnsi[i];

kernel/bpf/verifier.c

19031

env->prog->aux->changes_pkt_data = env->subprog_info[0].changes_pkt_data;

kernel/bpf/verifier.c

19032

env->prog->aux->might_sleep = env->subprog_info[0].might_sleep;

kernel/bpf/verifier.c

19052

postorder = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19053

state = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19054

stack = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

19121

struct bpf_prog *prog;

kernel/bpf/verifier.c

19142

prog = env->prog;

kernel/bpf/verifier.c

19143

btf = prog->aux->btf;

kernel/bpf/verifier.c

19206

prog->aux->func_info = krecord;

kernel/bpf/verifier.c

19207

prog->aux->func_info_cnt = nfuncs;

kernel/bpf/verifier.c

19223

struct bpf_prog *prog;

kernel/bpf/verifier.c

19242

prog = env->prog;

kernel/bpf/verifier.c

19243

btf = prog->aux->btf;

kernel/bpf/verifier.c

19247

krecord = prog->aux->func_info;

kernel/bpf/verifier.c

19283

prog->aux->func_info_aux = info_aux;

kernel/bpf/verifier.c

19293

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

19314

struct bpf_prog *prog;

kernel/bpf/verifier.c

19339

prog = env->prog;

kernel/bpf/verifier.c

19340

btf = prog->aux->btf;

kernel/bpf/verifier.c

19377

linfo[i].insn_off >= prog->len) {

kernel/bpf/verifier.c

19380

prog->len);

kernel/bpf/verifier.c

19385

if (!prog->insnsi[linfo[i].insn_off].code) {

kernel/bpf/verifier.c

19422

prog->aux->linfo = linfo;

kernel/bpf/verifier.c

19423

prog->aux->nr_linfo = nr_linfo;

kernel/bpf/verifier.c

19441

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

19442

const struct btf *btf = prog->aux->btf;

kernel/bpf/verifier.c

19488

if (core_relo.insn_off % 8 || core_relo.insn_off / 8 >= prog->len) {

kernel/bpf/verifier.c

19490

i, core_relo.insn_off, prog->len);

kernel/bpf/verifier.c

19496

&prog->insnsi[core_relo.insn_off / 8]);

kernel/bpf/verifier.c

19524

env->prog->aux->btf = btf;

kernel/bpf/verifier.c

21079

struct bpf_insn *insn = &env->prog->insnsi[env->insn_idx];

kernel/bpf/verifier.c

21248

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/verifier.c

21249

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

21333

if (bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

21629

struct bpf_prog *prog)

kernel/bpf/verifier.c

21632

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/verifier.c

21635

memcmp(map->excl_prog_sha, prog->digest, SHA256_DIGEST_SIZE)) {

kernel/bpf/verifier.c

21660

if ((bpf_prog_is_offloaded(prog->aux) || bpf_map_is_offloaded(map)) &&

kernel/bpf/verifier.c

21661

!bpf_offload_prog_map_match(prog, map)) {

kernel/bpf/verifier.c

21671

if (prog->sleepable)

kernel/bpf/verifier.c

21700

bpf_cgroup_storage_assign(env->prog->aux, map)) {

kernel/bpf/verifier.c

21706

if (env->prog->aux->arena) {

kernel/bpf/verifier.c

21714

if (!env->prog->jit_requested) {

kernel/bpf/verifier.c

21722

env->prog->aux->arena = (void *)map;

kernel/bpf/verifier.c

21723

if (!bpf_arena_get_user_vm_start(env->prog->aux->arena)) {

kernel/bpf/verifier.c

21747

err = check_map_prog_compatibility(env, map, env->prog);

kernel/bpf/verifier.c

21751

if (env->prog->sleepable)

kernel/bpf/verifier.c

21764

err = bpf_insn_array_init(map, env->prog);

kernel/bpf/verifier.c

21802

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

21803

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

21806

err = bpf_prog_calc_tag(env->prog);

kernel/bpf/verifier.c

21940

__bpf_free_used_maps(env->prog->aux, env->used_maps,

kernel/bpf/verifier.c

21953

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

21954

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22040

static void adjust_poke_descs(struct bpf_prog *prog, u32 off, u32 len)

kernel/bpf/verifier.c

22042

struct bpf_jit_poke_descriptor *tab = prog->aux->poke_tab;

kernel/bpf/verifier.c

22043

int i, sz = prog->aux->size_poke_tab;

kernel/bpf/verifier.c

22062

array_size(env->prog->len + len - 1,

kernel/bpf/verifier.c

22071

new_prog = bpf_patch_insn_single(env->prog, off, patch, len);

kernel/bpf/verifier.c

22090

static int adjust_jmp_off(struct bpf_prog *prog, u32 tgt_idx, u32 delta)

kernel/bpf/verifier.c

22092

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/verifier.c

22093

u32 insn_cnt = prog->len, i;

kernel/bpf/verifier.c

22144

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

22183

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

22187

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/verifier.c

22191

linfo = prog->aux->linfo;

kernel/bpf/verifier.c

22210

if (prog->len != off && l_cnt &&

kernel/bpf/verifier.c

22221

prog->aux->nr_linfo -= l_cnt;

kernel/bpf/verifier.c

22222

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/verifier.c

22250

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/verifier.c

22268

unsigned int orig_prog_len = env->prog->len;

kernel/bpf/verifier.c

22271

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/verifier.c

22277

err = bpf_remove_insns(env->prog, off, cnt);

kernel/bpf/verifier.c

22312

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

22313

const int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22342

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

22343

const int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22357

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/verifier.c

22367

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22382

insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22393

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

22394

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22424

int i, patch_len, delta = 0, len = env->prog->len;

kernel/bpf/verifier.c

22425

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/verifier.c

22508

env->prog = new_prog;

kernel/bpf/verifier.c

22527

const int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

22538

epilogue_cnt = ops->gen_epilogue(epilogue_buf, env->prog,

kernel/bpf/verifier.c

22549

insn_buf[cnt++] = env->prog->insnsi[0];

kernel/bpf/verifier.c

22553

env->prog = new_prog;

kernel/bpf/verifier.c

22568

env->prog);

kernel/bpf/verifier.c

22577

env->prog = new_prog;

kernel/bpf/verifier.c

22587

WARN_ON(adjust_jmp_off(env->prog, 0, delta));

kernel/bpf/verifier.c

22589

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/verifier.c

22592

insn = env->prog->insnsi + delta;

kernel/bpf/verifier.c

22610

env->prog = new_prog;

kernel/bpf/verifier.c

22643

env->prog->aux->num_exentries++;

kernel/bpf/verifier.c

22683

env->prog = new_prog;

kernel/bpf/verifier.c

22721

env->prog->aux->num_exentries++;

kernel/bpf/verifier.c

22734

env->prog->aux->num_exentries++;

kernel/bpf/verifier.c

22771

cnt = convert_ctx_access(type, insn, insn_buf, env->prog,

kernel/bpf/verifier.c

22815

env->prog = new_prog;

kernel/bpf/verifier.c

22824

struct bpf_prog *prog = env->prog, **func, *tmp;

kernel/bpf/verifier.c

22835

for (i = 0, insn = prog->insnsi; i < prog->len; i++, insn++) {

kernel/bpf/verifier.c

22872

err = bpf_prog_alloc_jited_linfo(prog);

kernel/bpf/verifier.c

22877

func = kzalloc_objs(prog, env->subprog_cnt);

kernel/bpf/verifier.c

22894

memcpy(func[i]->insnsi, &prog->insnsi[subprog_start],

kernel/bpf/verifier.c

22896

func[i]->type = prog->type;

kernel/bpf/verifier.c

22901

func[i]->sleepable = prog->sleepable;

kernel/bpf/verifier.c

22904

func[i]->aux->btf = prog->aux->btf;

kernel/bpf/verifier.c

22906

func[i]->aux->func_info = prog->aux->func_info;

kernel/bpf/verifier.c

22907

func[i]->aux->func_info_cnt = prog->aux->func_info_cnt;

kernel/bpf/verifier.c

22908

func[i]->aux->poke_tab = prog->aux->poke_tab;

kernel/bpf/verifier.c

22909

func[i]->aux->size_poke_tab = prog->aux->size_poke_tab;

kernel/bpf/verifier.c

22910

func[i]->aux->main_prog_aux = prog->aux;

kernel/bpf/verifier.c

22912

for (j = 0; j < prog->aux->size_poke_tab; j++) {

kernel/bpf/verifier.c

22915

poke = &prog->aux->poke_tab[j];

kernel/bpf/verifier.c

22927

func[i]->blinding_requested = prog->blinding_requested;

kernel/bpf/verifier.c

22928

func[i]->aux->kfunc_tab = prog->aux->kfunc_tab;

kernel/bpf/verifier.c

22929

func[i]->aux->kfunc_btf_tab = prog->aux->kfunc_btf_tab;

kernel/bpf/verifier.c

22930

func[i]->aux->linfo = prog->aux->linfo;

kernel/bpf/verifier.c

22931

func[i]->aux->nr_linfo = prog->aux->nr_linfo;

kernel/bpf/verifier.c

22932

func[i]->aux->jited_linfo = prog->aux->jited_linfo;

kernel/bpf/verifier.c

22934

func[i]->aux->arena = prog->aux->arena;

kernel/bpf/verifier.c

23048

for (i = 0, insn = prog->insnsi; i < prog->len; i++, insn++) {

kernel/bpf/verifier.c

23062

prog->jited = 1;

kernel/bpf/verifier.c

23063

prog->bpf_func = func[0]->bpf_func;

kernel/bpf/verifier.c

23064

prog->jited_len = func[0]->jited_len;

kernel/bpf/verifier.c

23065

prog->aux->extable = func[0]->aux->extable;

kernel/bpf/verifier.c

23066

prog->aux->num_exentries = func[0]->aux->num_exentries;

kernel/bpf/verifier.c

23067

prog->aux->func = func;

kernel/bpf/verifier.c

23068

prog->aux->func_cnt = env->subprog_cnt - env->hidden_subprog_cnt;

kernel/bpf/verifier.c

23069

prog->aux->real_func_cnt = env->subprog_cnt;

kernel/bpf/verifier.c

23070

prog->aux->bpf_exception_cb = (void *)func[env->exception_callback_subprog]->bpf_func;

kernel/bpf/verifier.c

23071

prog->aux->exception_boundary = func[0]->aux->exception_boundary;

kernel/bpf/verifier.c

23072

bpf_prog_jit_attempt_done(prog);

kernel/bpf/verifier.c

23079

for (i = 0; i < prog->aux->size_poke_tab; i++) {

kernel/bpf/verifier.c

23080

map_ptr = prog->aux->poke_tab[i].tail_call.map;

kernel/bpf/verifier.c

23081

map_ptr->ops->map_poke_untrack(map_ptr, prog->aux);

kernel/bpf/verifier.c

23096

prog->jit_requested = 0;

kernel/bpf/verifier.c

23097

prog->blinding_requested = 0;

kernel/bpf/verifier.c

23098

for (i = 0, insn = prog->insnsi; i < prog->len; i++, insn++) {

kernel/bpf/verifier.c

23104

bpf_prog_jit_attempt_done(prog);

kernel/bpf/verifier.c

23111

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

23112

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/verifier.c

23113

bool has_kfunc_call = bpf_prog_has_kfunc_call(prog);

kernel/bpf/verifier.c

23118

if (env->prog->jit_requested &&

kernel/bpf/verifier.c

23119

!bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

23131

if (env->subprog_cnt > 1 && env->prog->aux->tail_call_reachable) {

kernel/bpf/verifier.c

23138

for (i = 0; i < prog->len; i++, insn++) {

kernel/bpf/verifier.c

23162

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

23174

xdp_kfunc = bpf_dev_bound_resolve_kfunc(prog, func_id);

kernel/bpf/verifier.c

23190

if (bpf_lsm_has_d_inode_locked(prog))

kernel/bpf/verifier.c

23193

if (bpf_lsm_has_d_inode_locked(prog))

kernel/bpf/verifier.c

23243

desc = find_kfunc_desc(env->prog, insn->imm, insn->off);

kernel/bpf/verifier.c

23323

env->prog->expected_attach_type == BPF_TRACE_FSESSION) {

kernel/bpf/verifier.c

23336

env->prog->expected_attach_type == BPF_TRACE_FSESSION) {

kernel/bpf/verifier.c

23356

struct bpf_insn ld_addrs[2] = { BPF_LD_IMM64(regno, (long)env->prog->aux) };

kernel/bpf/verifier.c

23372

struct bpf_prog *prog;

kernel/bpf/verifier.c

23383

prog = bpf_patch_insn_data(env, env->prog->len - 1, patch, len);

kernel/bpf/verifier.c

23384

if (!prog)

kernel/bpf/verifier.c

23386

env->prog = prog;

kernel/bpf/verifier.c

23388

info[cnt].start = prog->len - len + 1;

kernel/bpf/verifier.c

23399

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

23400

enum bpf_attach_type eatype = prog->expected_attach_type;

kernel/bpf/verifier.c

23401

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/verifier.c

23402

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/verifier.c

23404

const int insn_cnt = prog->len;

kernel/bpf/verifier.c

23418

*patch++ = env->prog->insnsi[insn_cnt - 1];

kernel/bpf/verifier.c

23424

prog = env->prog;

kernel/bpf/verifier.c

23425

insn = prog->insnsi;

kernel/bpf/verifier.c

23435

(((struct bpf_map *)env->prog->aux->arena)->map_flags & BPF_F_NO_USER_CONV)) {

kernel/bpf/verifier.c

23473

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23564

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23594

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23614

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23667

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23712

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23733

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23754

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23764

prog->dst_needed = 1;

kernel/bpf/verifier.c

23768

prog->kprobe_override = 1;

kernel/bpf/verifier.c

23775

prog->cb_access = 1;

kernel/bpf/verifier.c

23777

prog->aux->stack_depth = MAX_BPF_STACK;

kernel/bpf/verifier.c

23778

prog->aux->max_pkt_offset = MAX_PACKET_OFF;

kernel/bpf/verifier.c

23789

if (env->bpf_capable && !prog->blinding_requested &&

kernel/bpf/verifier.c

23790

prog->jit_requested &&

kernel/bpf/verifier.c

23801

ret = bpf_jit_add_poke_descriptor(prog, &desc);

kernel/bpf/verifier.c

23839

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23859

BPF_LD_IMM64(BPF_REG_3, (long)prog->aux),

kernel/bpf/verifier.c

23872

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23890

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23909

env->prog = prog = new_prog;

kernel/bpf/verifier.c

23918

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

23950

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24014

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24033

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24061

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24079

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24088

int nr_args = btf_type_vlen(prog->aux->attach_func_proto);

kernel/bpf/verifier.c

24113

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24143

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24152

int nr_args = btf_type_vlen(prog->aux->attach_func_proto);

kernel/bpf/verifier.c

24169

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24184

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24191

prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24240

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24246

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/verifier.c

24258

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24263

fn = env->ops->get_func_proto(insn->imm, env->prog);

kernel/bpf/verifier.c

24280

if (stack_depth > MAX_BPF_STACK && !prog->jit_requested) {

kernel/bpf/verifier.c

24293

env->prog->aux->stack_depth = subprogs[0].stack_depth;

kernel/bpf/verifier.c

24319

insn_buf[cnt++] = env->prog->insnsi[subprog_start];

kernel/bpf/verifier.c

24324

env->prog = prog = new_prog;

kernel/bpf/verifier.c

24331

WARN_ON(adjust_jmp_off(env->prog, subprog_start, delta));

kernel/bpf/verifier.c

24335

for (i = 0; i < prog->aux->size_poke_tab; i++) {

kernel/bpf/verifier.c

24336

map_ptr = prog->aux->poke_tab[i].tail_call.map;

kernel/bpf/verifier.c

24344

ret = map_ptr->ops->map_poke_track(map_ptr, prog->aux);

kernel/bpf/verifier.c

24454

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

24455

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

24477

env->prog = new_prog;

kernel/bpf/verifier.c

24490

env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;

kernel/bpf/verifier.c

24502

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

24503

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

24576

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

24590

state->in_sleepable = env->prog->sleepable;

kernel/bpf/verifier.c

24605

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

kernel/bpf/verifier.c

24676

if (env->prog->aux->func_info_aux) {

kernel/bpf/verifier.c

24679

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

kernel/bpf/verifier.c

24688

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

kernel/bpf/verifier.c

24724

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

24779

env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;

kernel/bpf/verifier.c

24808

int bpf_prog_ctx_arg_info_init(struct bpf_prog *prog,

kernel/bpf/verifier.c

24811

prog->aux->ctx_arg_info = kmemdup_array(info, cnt, sizeof(*info), GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

24812

prog->aux->ctx_arg_info_size = cnt;

kernel/bpf/verifier.c

24814

return prog->aux->ctx_arg_info ? 0 : -ENOMEM;

kernel/bpf/verifier.c

24823

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

24830

if (!prog->gpl_compatible) {

kernel/bpf/verifier.c

24835

if (!prog->aux->attach_btf_id)

kernel/bpf/verifier.c

24838

btf = prog->aux->attach_btf;

kernel/bpf/verifier.c

24849

btf_id = prog->aux->attach_btf_id;

kernel/bpf/verifier.c

24859

member_idx = prog->expected_attach_type;

kernel/bpf/verifier.c

24885

err = st_ops->check_member(t, member, prog);

kernel/bpf/verifier.c

24894

if (prog->aux->priv_stack_requested && !bpf_jit_supports_private_stack()) {

kernel/bpf/verifier.c

24916

prog->aux->st_ops = st_ops;

kernel/bpf/verifier.c

24917

prog->aux->attach_st_ops_member_off = member_off;

kernel/bpf/verifier.c

24919

prog->aux->attach_func_proto = func_proto;

kernel/bpf/verifier.c

24920

prog->aux->attach_func_name = mname;

kernel/bpf/verifier.c

24923

return bpf_prog_ctx_arg_info_init(prog, st_ops_desc->arg_info[member_idx].info,

kernel/bpf/verifier.c

24959

const struct bpf_prog *prog,

kernel/bpf/verifier.c

24964

bool prog_extension = prog->type == BPF_PROG_TYPE_EXT;

kernel/bpf/verifier.c

24965

bool prog_tracing = prog->type == BPF_PROG_TYPE_TRACING;

kernel/bpf/verifier.c

24981

btf = tgt_prog ? tgt_prog->aux->btf : prog->aux->attach_btf;

kernel/bpf/verifier.c

25002

if (bpf_prog_is_dev_bound(prog->aux) &&

kernel/bpf/verifier.c

25003

!bpf_prog_dev_bound_match(prog, tgt_prog)) {

kernel/bpf/verifier.c

25030

if (!prog->jit_requested) {

kernel/bpf/verifier.c

25038

if (prog->aux->changes_pkt_data && !tgt_changes_pkt_data) {

kernel/bpf/verifier.c

25047

if (prog->aux->might_sleep && !tgt_might_sleep) {

kernel/bpf/verifier.c

25067

} else if (tgt_prog->type == prog->type) {

kernel/bpf/verifier.c

25105

switch (prog->expected_attach_type) {

kernel/bpf/verifier.c

25180

if (prog->expected_attach_type == BPF_TRACE_FSESSION &&

kernel/bpf/verifier.c

25191

btf_check_type_match(log, prog, btf, t))

kernel/bpf/verifier.c

25197

if ((prog->aux->saved_dst_prog_type || prog->aux->saved_dst_attach_type) &&

kernel/bpf/verifier.c

25198

(!tgt_prog || prog->aux->saved_dst_prog_type != tgt_prog->type ||

kernel/bpf/verifier.c

25199

prog->aux->saved_dst_attach_type != tgt_prog->expected_attach_type))

kernel/bpf/verifier.c

25233

if (prog->sleepable) {

kernel/bpf/verifier.c

25235

switch (prog->type) {

kernel/bpf/verifier.c

25249

prog);

kernel/bpf/verifier.c

25270

} else if (prog->expected_attach_type == BPF_MODIFY_RETURN) {

kernel/bpf/verifier.c

25277

if (btf_kfunc_is_modify_return(btf, btf_id, prog) ||

kernel/bpf/verifier.c

25342

static bool can_be_sleepable(struct bpf_prog *prog)

kernel/bpf/verifier.c

25344

if (prog->type == BPF_PROG_TYPE_TRACING) {

kernel/bpf/verifier.c

25345

switch (prog->expected_attach_type) {

kernel/bpf/verifier.c

25356

return prog->type == BPF_PROG_TYPE_LSM ||

kernel/bpf/verifier.c

25357

prog->type == BPF_PROG_TYPE_KPROBE /* only for uprobes */ ||

kernel/bpf/verifier.c

25358

prog->type == BPF_PROG_TYPE_STRUCT_OPS;

kernel/bpf/verifier.c

25363

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

25364

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/verifier.c

25366

u32 btf_id = prog->aux->attach_btf_id;

kernel/bpf/verifier.c

25371

if (prog->type == BPF_PROG_TYPE_SYSCALL) {

kernel/bpf/verifier.c

25372

if (prog->sleepable)

kernel/bpf/verifier.c

25379

if (prog->sleepable && !can_be_sleepable(prog)) {

kernel/bpf/verifier.c

25384

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/verifier.c

25387

if (prog->type != BPF_PROG_TYPE_TRACING &&

kernel/bpf/verifier.c

25388

prog->type != BPF_PROG_TYPE_LSM &&

kernel/bpf/verifier.c

25389

prog->type != BPF_PROG_TYPE_EXT)

kernel/bpf/verifier.c

25392

ret = bpf_check_attach_target(&env->log, prog, tgt_prog, btf_id, &tgt_info);

kernel/bpf/verifier.c

25396

if (tgt_prog && prog->type == BPF_PROG_TYPE_EXT) {

kernel/bpf/verifier.c

25402

prog->expected_attach_type = tgt_prog->expected_attach_type;

kernel/bpf/verifier.c

25406

prog->aux->attach_func_proto = tgt_info.tgt_type;

kernel/bpf/verifier.c

25407

prog->aux->attach_func_name = tgt_info.tgt_name;

kernel/bpf/verifier.c

25408

prog->aux->mod = tgt_info.tgt_mod;

kernel/bpf/verifier.c

25411

prog->aux->saved_dst_prog_type = tgt_prog->type;

kernel/bpf/verifier.c

25412

prog->aux->saved_dst_attach_type = tgt_prog->expected_attach_type;

kernel/bpf/verifier.c

25415

if (prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/verifier.c

25416

prog->aux->attach_btf_trace = true;

kernel/bpf/verifier.c

25418

} else if (prog->expected_attach_type == BPF_TRACE_ITER) {

kernel/bpf/verifier.c

25419

return bpf_iter_prog_supported(prog);

kernel/bpf/verifier.c

25422

if (prog->type == BPF_PROG_TYPE_LSM) {

kernel/bpf/verifier.c

25423

ret = bpf_lsm_verify_prog(&env->log, prog);

kernel/bpf/verifier.c

25426

} else if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/bpf/verifier.c

25431

} else if ((prog->expected_attach_type == BPF_TRACE_FEXIT ||

kernel/bpf/verifier.c

25432

prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/bpf/verifier.c

25433

prog->expected_attach_type == BPF_MODIFY_RETURN) &&

kernel/bpf/verifier.c

25440

key = bpf_trampoline_compute_key(tgt_prog, prog->aux->attach_btf, btf_id);

kernel/bpf/verifier.c

25448

prog->aux->dst_trampoline = tr;

kernel/bpf/verifier.c

25686

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/verifier.c

25688

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

25782

const u32 insn_cnt = env->prog->len;

kernel/bpf/verifier.c

25954

int bpf_check(struct bpf_prog **prog, union bpf_attr *attr, bpfptr_t uattr, __u32 uattr_size)

kernel/bpf/verifier.c

25977

len = (*prog)->len;

kernel/bpf/verifier.c

25988

env->prog = *prog;

kernel/bpf/verifier.c

25989

env->ops = bpf_verifier_ops[env->prog->type];

kernel/bpf/verifier.c

25991

env->allow_ptr_leaks = bpf_allow_ptr_leaks(env->prog->aux->token);

kernel/bpf/verifier.c

25992

env->allow_uninit_stack = bpf_allow_uninit_stack(env->prog->aux->token);

kernel/bpf/verifier.c

25993

env->bypass_spec_v1 = bpf_bypass_spec_v1(env->prog->aux->token);

kernel/bpf/verifier.c

25994

env->bypass_spec_v4 = bpf_bypass_spec_v4(env->prog->aux->token);

kernel/bpf/verifier.c

25995

env->bpf_capable = is_priv = bpf_token_capable(env->prog->aux->token, CAP_BPF);

kernel/bpf/verifier.c

26066

if (bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

26067

ret = bpf_prog_offload_verifier_prep(env->prog);

kernel/bpf/verifier.c

26103

if (ret == 0 && bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/verifier.c

26144

if (ret == 0 && !bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

26146

env->prog->aux->verifier_zext = bpf_jit_needs_zext() ? !ret

kernel/bpf/verifier.c

26155

env->prog->aux->verified_insns = env->insn_processed;

kernel/bpf/verifier.c

26174

env->prog->aux->used_maps = kmalloc_objs(env->used_maps[0],

kernel/bpf/verifier.c

26178

if (!env->prog->aux->used_maps) {

kernel/bpf/verifier.c

26183

memcpy(env->prog->aux->used_maps, env->used_maps,

kernel/bpf/verifier.c

26185

env->prog->aux->used_map_cnt = env->used_map_cnt;

kernel/bpf/verifier.c

26189

env->prog->aux->used_btfs = kmalloc_objs(env->used_btfs[0],

kernel/bpf/verifier.c

26192

if (!env->prog->aux->used_btfs) {

kernel/bpf/verifier.c

26197

memcpy(env->prog->aux->used_btfs, env->used_btfs,

kernel/bpf/verifier.c

26199

env->prog->aux->used_btf_cnt = env->used_btf_cnt;

kernel/bpf/verifier.c

26213

if (!env->prog->aux->used_maps)

kernel/bpf/verifier.c

26218

if (!env->prog->aux->used_btfs)

kernel/bpf/verifier.c

26224

if (env->prog->type == BPF_PROG_TYPE_EXT)

kernel/bpf/verifier.c

26225

env->prog->expected_attach_type = 0;

kernel/bpf/verifier.c

26227

*prog = env->prog;

kernel/bpf/verifier.c

26233

clear_insn_aux_data(env, 0, env->prog->len);

kernel/bpf/verifier.c

3066

if (off >= env->prog->len || off < 0 || env->subprog_cnt == 0)

kernel/bpf/verifier.c

3094

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

3117

struct bpf_prog_aux *aux = env->prog->aux;

kernel/bpf/verifier.c

3230

find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset)

kernel/bpf/verifier.c

3238

tab = prog->aux->kfunc_tab;

kernel/bpf/verifier.c

3243

int bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

kernel/bpf/verifier.c

3248

desc = find_kfunc_desc(prog, func_id, btf_fd_idx);

kernel/bpf/verifier.c

3266

tab = env->prog->aux->kfunc_btf_tab;

kernel/bpf/verifier.c

3404

kfunc_flags = btf_kfunc_flags(btf, func_id, env->prog);

kernel/bpf/verifier.c

3450

prog_aux = env->prog->aux;

kernel/bpf/verifier.c

3459

if (!env->prog->jit_requested) {

kernel/bpf/verifier.c

3469

if (!env->prog->gpl_compatible) {

kernel/bpf/verifier.c

3496

if (find_kfunc_desc(env->prog, func_id, offset))

kernel/bpf/verifier.c

3570

tab = env->prog->aux->kfunc_tab;

kernel/bpf/verifier.c

3585

bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog)

kernel/bpf/verifier.c

3587

return !!prog->aux->kfunc_tab;

kernel/bpf/verifier.c

3591

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

kernel/bpf/verifier.c

3601

tab = prog->aux->kfunc_tab;

kernel/bpf/verifier.c

3626

int i, ret, insn_cnt = env->prog->len, ex_cb_insn;

kernel/bpf/verifier.c

3627

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

3690

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

3691

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

3933

struct bpf_insn *insn = env->prog->insnsi + env->insn_idx;

kernel/bpf/verifier.c

4393

struct bpf_insn *insn = env->prog->insnsi + idx;

kernel/bpf/verifier.c

442

struct bpf_func_info_aux *aux = env->prog->aux->func_info_aux;

kernel/bpf/verifier.c

451

if (!env->prog->aux->func_info)

kernel/bpf/verifier.c

454

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

kernel/bpf/verifier.c

455

return btf_type_name(env->prog->aux->btf, info->type_id);

kernel/bpf/verifier.c

4645

bpf_pseudo_call(&env->prog->insnsi[subseq_idx - 1]) &&

kernel/bpf/verifier.c

5010

if (i >= env->prog->len) {

kernel/bpf/verifier.c

5255

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

5403

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

580

return is_may_goto_insn(&env->prog->insnsi[insn_idx]);

kernel/bpf/verifier.c

6162

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

6307

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

6379

env->prog->aux->max_pkt_offset =

kernel/bpf/verifier.c

6380

max_t(u32, env->prog->aux->max_pkt_offset,

kernel/bpf/verifier.c

6391

env->ops->is_valid_access(off, size, t, env->prog, info)) {

kernel/bpf/verifier.c

6410

if (env->prog->aux->max_ctx_offset < off + size)

kernel/bpf/verifier.c

6411

env->prog->aux->max_ctx_offset = off + size;

kernel/bpf/verifier.c

6695

static enum priv_stack_mode bpf_enable_priv_stack(struct bpf_prog *prog)

kernel/bpf/verifier.c

6704

switch (prog->type) {

kernel/bpf/verifier.c

6713

if (prog->aux->priv_stack_requested || bpf_prog_check_recur(prog))

kernel/bpf/verifier.c

6725

if (env->prog->jit_requested)

kernel/bpf/verifier.c

6744

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

6886

env->prog->aux->tail_call_reachable = true;

kernel/bpf/verifier.c

6916

priv_stack_mode = bpf_enable_priv_stack(env->prog);

kernel/bpf/verifier.c

6937

env->prog->aux->jits_use_priv_stack = true;

kernel/bpf/verifier.c

6992

if (off + size > env->prog->aux->max_tp_access)

kernel/bpf/verifier.c

6993

env->prog->aux->max_tp_access = off + size;

kernel/bpf/verifier.c

7399

if (!env->prog->gpl_compatible && btf_is_kernel(reg->btf)) {

kernel/bpf/verifier.c

7685

static bool get_func_retval_range(struct bpf_prog *prog,

kernel/bpf/verifier.c

7688

if (prog->type == BPF_PROG_TYPE_LSM &&

kernel/bpf/verifier.c

7689

prog->expected_attach_type == BPF_LSM_MAC &&

kernel/bpf/verifier.c

7690

!bpf_lsm_get_retval_range(prog, range)) {

kernel/bpf/verifier.c

7844

if (info.is_retval && get_func_retval_range(env->prog, &range)) {

kernel/bpf/verifier.c

7940

max_access = &env->prog->aux->max_rdonly_access;

kernel/bpf/verifier.c

7942

max_access = &env->prog->aux->max_rdwr_access;

kernel/bpf/verifier.c

8397

max_access = &env->prog->aux->max_rdonly_access;

kernel/bpf/verifier.c

8399

max_access = &env->prog->aux->max_rdwr_access;

kernel/events/core.c

10216

struct bpf_prog *prog;

kernel/events/core.c

10254

static void perf_event_bpf_emit_ksymbols(struct bpf_prog *prog,

kernel/events/core.c

10261

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

kernel/events/core.c

10262

prog->jited_len, unregister,

kernel/events/core.c

10263

prog->aux->ksym.name);

kernel/events/core.c

10265

for (i = 1; i < prog->aux->func_cnt; i++) {

kernel/events/core.c

10266

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

kernel/events/core.c

10276

void perf_event_bpf_event(struct bpf_prog *prog,

kernel/events/core.c

10286

perf_event_bpf_emit_ksymbols(prog, type);

kernel/events/core.c

10296

.prog = prog,

kernel/events/core.c

10304

.id = prog->aux->id,

kernel/events/core.c

10310

memcpy(bpf_event.event_id.tag, prog->tag, BPF_TAG_SIZE);

kernel/events/core.c

10592

struct bpf_prog *prog;

kernel/events/core.c

10599

prog = READ_ONCE(event->prog);

kernel/events/core.c

10600

if (prog) {

kernel/events/core.c

10602

ret = bpf_prog_run(prog, &ctx);

kernel/events/core.c

10612

struct bpf_prog *prog,

kernel/events/core.c

10619

if (event->prog)

kernel/events/core.c

10622

if (prog->type != BPF_PROG_TYPE_PERF_EVENT)

kernel/events/core.c

10626

prog->call_get_stack &&

kernel/events/core.c

10642

event->prog = prog;

kernel/events/core.c

10649

struct bpf_prog *prog = event->prog;

kernel/events/core.c

10651

if (!prog)

kernel/events/core.c

10654

event->prog = NULL;

kernel/events/core.c

10655

bpf_prog_put(prog);

kernel/events/core.c

10666

struct bpf_prog *prog,

kernel/events/core.c

10700

if (event->prog && event->prog->type == BPF_PROG_TYPE_PERF_EVENT &&

kernel/events/core.c

11619

struct bpf_prog *prog,

kernel/events/core.c

11628

return perf_event_set_bpf_handler(event, prog, bpf_cookie);

kernel/events/core.c

11638

if (((is_kprobe || is_uprobe) && prog->type != BPF_PROG_TYPE_KPROBE) ||

kernel/events/core.c

11639

(is_tracepoint && prog->type != BPF_PROG_TYPE_TRACEPOINT) ||

kernel/events/core.c

11640

(is_syscall_tp && prog->type != BPF_PROG_TYPE_TRACEPOINT))

kernel/events/core.c

11643

if (prog->type == BPF_PROG_TYPE_KPROBE && prog->sleepable && !is_uprobe)

kernel/events/core.c

11648

if (prog->kprobe_override && !is_kprobe)

kernel/events/core.c

11652

if (prog->aux->kprobe_write_ctx && !is_uprobe)

kernel/events/core.c

11658

if (prog->aux->max_ctx_offset > off)

kernel/events/core.c

11662

return perf_event_attach_bpf_prog(event, prog, bpf_cookie);

kernel/events/core.c

11666

struct bpf_prog *prog,

kernel/events/core.c

11673

ret = __perf_event_set_bpf_prog(event, prog, bpf_cookie);

kernel/events/core.c

11681

if (!event->prog)

kernel/events/core.c

11702

struct bpf_prog *prog,

kernel/events/core.c

11709

struct bpf_prog *prog,

kernel/events/core.c

13358

if (parent_event->prog) {

kernel/events/core.c

13359

struct bpf_prog *prog = parent_event->prog;

kernel/events/core.c

13361

bpf_prog_inc(prog);

kernel/events/core.c

13362

event->prog = prog;

kernel/events/core.c

6596

struct bpf_prog *prog,

kernel/events/core.c

6656

struct bpf_prog *prog;

kernel/events/core.c

6659

prog = bpf_prog_get(arg);

kernel/events/core.c

6660

if (IS_ERR(prog))

kernel/events/core.c

6661

return PTR_ERR(prog);

kernel/events/core.c

6663

err = __perf_event_set_bpf_prog(event, prog, 0);

kernel/events/core.c

6665

bpf_prog_put(prog);

kernel/kallsyms.c

806

struct bpf_prog *prog;

kernel/kallsyms.c

809

prog = bpf_iter_get_info(&meta, in_stop);

kernel/kallsyms.c

810

if (!prog)

kernel/kallsyms.c

815

return bpf_iter_run_prog(prog, &ctx);

kernel/sched/ext.c

5370

const struct bpf_prog *prog,

kernel/sched/ext.c

5380

return btf_ctx_access(off, size, type, prog, info);

kernel/sched/ext.c

5459

const struct bpf_prog *prog)

kernel/sched/ext.c

5476

if (prog->sleepable)

kernel/seccomp.c

2229

fprog = filter->prog->orig_prog;

kernel/seccomp.c

231

struct bpf_prog *prog;

kernel/seccomp.c

424

u32 cur_ret = bpf_prog_run_pin_on_cpu(f->prog, sd);

kernel/seccomp.c

527

bpf_prog_destroy(filter->prog);

kernel/seccomp.c

701

ret = bpf_prog_create_from_user(&sfilter->prog, fprog,

kernel/seccomp.c

851

struct sock_fprog_kern *fprog = sfilter->prog->orig_prog;

kernel/seccomp.c

930

total_insns = filter->prog->len;

kernel/seccomp.c

932

total_insns += walker->prog->len + 4; /* 4 instr penalty */

kernel/trace/bpf_trace.c

1244

bpf_tracing_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1265

func_proto = bpf_base_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1269

if (!bpf_token_capable(prog->aux->token, CAP_SYS_ADMIN))

kernel/trace/bpf_trace.c

1281

static bool is_kprobe_multi(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1283

return prog->expected_attach_type == BPF_TRACE_KPROBE_MULTI ||

kernel/trace/bpf_trace.c

1284

prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION;

kernel/trace/bpf_trace.c

1287

static inline bool is_kprobe_session(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1289

return prog->type == BPF_PROG_TYPE_KPROBE &&

kernel/trace/bpf_trace.c

1290

prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION;

kernel/trace/bpf_trace.c

1293

static inline bool is_uprobe_multi(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1295

return prog->expected_attach_type == BPF_TRACE_UPROBE_MULTI ||

kernel/trace/bpf_trace.c

1296

prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION;

kernel/trace/bpf_trace.c

1299

static inline bool is_uprobe_session(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1301

return prog->type == BPF_PROG_TYPE_KPROBE &&

kernel/trace/bpf_trace.c

1302

prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION;

kernel/trace/bpf_trace.c

1305

static inline bool is_trace_fsession(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1307

return prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

1308

prog->expected_attach_type == BPF_TRACE_FSESSION;

kernel/trace/bpf_trace.c

1312

kprobe_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1320

return prog->sleepable ? &bpf_get_stack_sleepable_proto : &bpf_get_stack_proto;

kernel/trace/bpf_trace.c

1326

if (is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

1328

if (is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

1332

if (is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

1334

if (is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

1338

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1344

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1359

prog->aux->kprobe_write_ctx = true;

kernel/trace/bpf_trace.c

1439

tp_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1451

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1456

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1543

pe_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1559

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1678

raw_tp_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1690

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1695

tracing_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1731

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1735

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1739

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1745

if (bpf_prog_has_trampoline(prog) ||

kernel/trace/bpf_trace.c

1746

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1750

return bpf_prog_has_trampoline(prog) ? &bpf_get_func_ret_proto : NULL;

kernel/trace/bpf_trace.c

1752

if (bpf_prog_has_trampoline(prog) ||

kernel/trace/bpf_trace.c

1753

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1757

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

1758

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1760

return bpf_prog_has_trampoline(prog) ? &bpf_get_attach_cookie_proto_tracing : NULL;

kernel/trace/bpf_trace.c

1762

fn = raw_tp_prog_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1763

if (!fn && prog->expected_attach_type == BPF_TRACE_ITER)

kernel/trace/bpf_trace.c

1764

fn = bpf_iter_get_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1771

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1779

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1782

return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

kernel/trace/bpf_trace.c

1785

int __weak bpf_prog_test_run_tracing(struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1814

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1822

return raw_tp_prog_is_valid_access(off, size, type, prog, info);

kernel/trace/bpf_trace.c

1834

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1874

struct bpf_prog *prog, u32 *target_size)

kernel/trace/bpf_trace.c

1921

struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1932

if (prog->kprobe_override &&

kernel/trace/bpf_trace.c

1939

if (event->prog)

kernel/trace/bpf_trace.c

1949

ret = bpf_prog_array_copy(old_array, NULL, prog, bpf_cookie, &new_array);

kernel/trace/bpf_trace.c

1954

event->prog = prog;

kernel/trace/bpf_trace.c

1968

struct bpf_prog *prog = NULL;

kernel/trace/bpf_trace.c

1973

if (!event->prog)

kernel/trace/bpf_trace.c

1980

ret = bpf_prog_array_copy(old_array, event->prog, NULL, 0, &new_array);

kernel/trace/bpf_trace.c

1982

bpf_prog_array_delete_safe(old_array, event->prog);

kernel/trace/bpf_trace.c

1989

prog = event->prog;

kernel/trace/bpf_trace.c

1990

event->prog = NULL;

kernel/trace/bpf_trace.c

1995

if (prog) {

kernel/trace/bpf_trace.c

2003

bpf_prog_put(prog);

kernel/trace/bpf_trace.c

2075

struct bpf_prog *prog = link->link.prog;

kernel/trace/bpf_trace.c

2080

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/trace/bpf_trace.c

2081

bpf_prog_inc_misses_counter(prog);

kernel/trace/bpf_trace.c

2088

(void) bpf_prog_run(prog, args);

kernel/trace/bpf_trace.c

2092

bpf_prog_put_recursion_context(prog);

kernel/trace/bpf_trace.c

2144

struct bpf_prog *prog = link->link.prog;

kernel/trace/bpf_trace.c

2150

if (prog->aux->max_ctx_offset > btp->num_args * sizeof(u64))

kernel/trace/bpf_trace.c

2153

if (prog->aux->max_tp_access > btp->writable_size)

kernel/trace/bpf_trace.c

2170

struct bpf_prog *prog;

kernel/trace/bpf_trace.c

2173

prog = event->prog;

kernel/trace/bpf_trace.c

2174

if (!prog)

kernel/trace/bpf_trace.c

2178

if (prog->type == BPF_PROG_TYPE_PERF_EVENT)

kernel/trace/bpf_trace.c

2181

*prog_id = prog->aux->id;

kernel/trace/bpf_trace.c

2572

bpf_prog_inc_misses_counter(link->link.prog);

kernel/trace/bpf_trace.c

2580

err = bpf_prog_run(link->link.prog, regs);

kernel/trace/bpf_trace.c

2601

return is_kprobe_session(link->link.prog) ? err : 0;

kernel/trace/bpf_trace.c

2733

int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/trace/bpf_trace.c

2752

if (!is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

2756

if (prog->sleepable)

kernel/trace/bpf_trace.c

2760

if (prog->aux->kprobe_write_ctx)

kernel/trace/bpf_trace.c

2823

if (prog->kprobe_override && addrs_check_error_injection_list(addrs, cnt)) {

kernel/trace/bpf_trace.c

2835

&bpf_kprobe_multi_link_lops, prog, attr->link_create.attach_type);

kernel/trace/bpf_trace.c

2843

if ((flags & BPF_F_KPROBE_MULTI_RETURN) || is_kprobe_session(prog))

kernel/trace/bpf_trace.c

2845

if (is_kprobe_session(prog))

kernel/trace/bpf_trace.c

2889

int bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/trace/bpf_trace.c

3092

struct bpf_prog *prog = link->link.prog;

kernel/trace/bpf_trace.c

3093

bool sleepable = prog->sleepable;

kernel/trace/bpf_trace.c

3108

err = bpf_prog_run(link->link.prog, regs);

kernel/trace/bpf_trace.c

3172

int bpf_uprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/trace/bpf_trace.c

3195

if (!is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

3275

if (flags & BPF_F_UPROBE_MULTI_RETURN || is_uprobe_session(prog))

kernel/trace/bpf_trace.c

3277

if (is_uprobe_session(prog))

kernel/trace/bpf_trace.c

3290

&bpf_uprobe_multi_link_lops, prog, attr->link_create.attach_type);

kernel/trace/bpf_trace.c

3323

int bpf_uprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

kernel/trace/bpf_trace.c

3362

static int bpf_session_filter(const struct bpf_prog *prog, u32 kfunc_id)

kernel/trace/bpf_trace.c

3367

if (!is_kprobe_session(prog) && !is_uprobe_session(prog) && !is_trace_fsession(prog))

kernel/trace/bpf_trace.c

947

static bool bpf_d_path_allowed(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

949

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

950

prog->expected_attach_type == BPF_TRACE_ITER)

kernel/trace/bpf_trace.c

953

if (prog->type == BPF_PROG_TYPE_LSM)

kernel/trace/bpf_trace.c

954

return bpf_lsm_is_sleepable_hook(prog->aux->attach_btf_id);

kernel/trace/bpf_trace.c

957

prog->aux->attach_btf_id);

kernel/trace/trace.h

1524

struct prog_entry __rcu *prog;

kernel/trace/trace_events_filter.c

1173

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

1181

prog = rcu_dereference_raw(filter->prog);

kernel/trace/trace_events_filter.c

1182

if (!prog)

kernel/trace/trace_events_filter.c

1185

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

1186

struct filter_pred *pred = prog[i].pred;

kernel/trace/trace_events_filter.c

1188

if (match == prog[i].when_to_branch)

kernel/trace/trace_events_filter.c

1189

i = prog[i].target;

kernel/trace/trace_events_filter.c

1191

return prog[i].target;

kernel/trace/trace_events_filter.c

1285

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

1288

prog = rcu_access_pointer(filter->prog);

kernel/trace/trace_events_filter.c

1289

if (!prog)

kernel/trace/trace_events_filter.c

1292

for (i = 0; prog[i].pred; i++)

kernel/trace/trace_events_filter.c

1293

free_predicate(prog[i].pred);

kernel/trace/trace_events_filter.c

1294

kfree(prog);

kernel/trace/trace_events_filter.c

168

static void update_preds(struct prog_entry *prog, int N, int invert)

kernel/trace/trace_events_filter.c

172

t = prog[N].target;

kernel/trace/trace_events_filter.c

173

s = prog[t].target;

kernel/trace/trace_events_filter.c

174

prog[t].when_to_branch = invert;

kernel/trace/trace_events_filter.c

175

prog[t].target = N;

kernel/trace/trace_events_filter.c

176

prog[N].target = s;

kernel/trace/trace_events_filter.c

2209

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

2233

prog = predicate_parse(filter_string, nr_parens, nr_preds,

kernel/trace/trace_events_filter.c

2235

if (IS_ERR(prog))

kernel/trace/trace_events_filter.c

2236

return PTR_ERR(prog);

kernel/trace/trace_events_filter.c

2238

rcu_assign_pointer(filter->prog, prog);

kernel/trace/trace_events_filter.c

2657

static bool is_or(struct prog_entry *prog, int i)

kernel/trace/trace_events_filter.c

2666

target = prog[i].target + 1;

kernel/trace/trace_events_filter.c

2668

if (prog[target].pred)

kernel/trace/trace_events_filter.c

2672

return prog[i].when_to_branch == prog[target].target;

kernel/trace/trace_events_filter.c

2678

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2687

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

2688

struct filter_pred *pred = prog[i].pred;

kernel/trace/trace_events_filter.c

2690

if (!is_or(prog, i))

kernel/trace/trace_events_filter.c

2836

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2840

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

2841

struct filter_pred *pred = prog[i].pred;

kernel/trace/trace_events_filter.c

475

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

503

prog = prog_stack;

kernel/trace/trace_events_filter.c

534

prog[N].target = N-1;

kernel/trace/trace_events_filter.c

536

len = parse_pred(next, data, ptr - str, pe, &prog[N].pred);

kernel/trace/trace_events_filter.c

572

update_preds(prog, N - 1, invert);

kernel/trace/trace_events_filter.c

580

update_preds(prog, N - 1, !invert);

kernel/trace/trace_events_filter.c

613

prog[N].pred = NULL; /* #13 */

kernel/trace/trace_events_filter.c

614

prog[N].target = 1; /* TRUE */

kernel/trace/trace_events_filter.c

615

prog[N+1].pred = NULL;

kernel/trace/trace_events_filter.c

616

prog[N+1].target = 0; /* FALSE */

kernel/trace/trace_events_filter.c

617

prog[N-1].target = N;

kernel/trace/trace_events_filter.c

618

prog[N-1].when_to_branch = false;

kernel/trace/trace_events_filter.c

622

int target = prog[i].target;

kernel/trace/trace_events_filter.c

623

if (prog[i].when_to_branch == prog[target].when_to_branch)

kernel/trace/trace_events_filter.c

624

prog[i].target = prog[target].target;

kernel/trace/trace_events_filter.c

629

invert = inverts[i] ^ prog[i].when_to_branch;

kernel/trace/trace_events_filter.c

630

prog[i].when_to_branch = invert;

kernel/trace/trace_events_filter.c

632

if (WARN_ON(prog[i].target <= i)) {

kernel/trace/trace_events_filter.c

640

return prog;

lib/test_firmware.c

1140

const u8 *p, const char *prog)

lib/test_firmware.c

1147

tst->inject.prog = prog;

lib/test_firmware.c

1206

strncmp(tst->inject.prog, progress, strlen(progress)) != 0)

lib/test_firmware.c

1220

tst->inject.prog = NULL;

lib/test_firmware.c

124

const char *prog;

lib/test_firmware.c

1242

strncmp(tst->inject.prog, progress, strlen(progress)) != 0)

lib/test_firmware.c

1260

strncmp(tst->inject.prog, progress, strlen(progress)) != 0)

lib/test_firmware.c

1281

tst->inject.prog = NULL;

net/bpf/bpf_dummy_struct_ops.c

117

info = find_ctx_arg_info(prog->aux, offset);

net/bpf/bpf_dummy_struct_ops.c

129

int bpf_struct_ops_test_run(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/bpf_dummy_struct_ops.c

149

if (prog->aux->attach_btf_id != type_id)

net/bpf/bpf_dummy_struct_ops.c

152

func_proto = prog->aux->attach_func_proto;

net/bpf/bpf_dummy_struct_ops.c

157

err = check_test_run_args(prog, args);

net/bpf/bpf_dummy_struct_ops.c

173

bpf_prog_inc(prog);

net/bpf/bpf_dummy_struct_ops.c

174

bpf_link_init(&link->link, BPF_LINK_TYPE_STRUCT_OPS, &bpf_struct_ops_link_lops, prog,

net/bpf/bpf_dummy_struct_ops.c

175

prog->expected_attach_type);

net/bpf/bpf_dummy_struct_ops.c

177

op_idx = prog->expected_attach_type;

net/bpf/bpf_dummy_struct_ops.c

213

const struct bpf_prog *prog,

net/bpf/bpf_dummy_struct_ops.c

216

return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

net/bpf/bpf_dummy_struct_ops.c

221

const struct bpf_prog *prog)

net/bpf/bpf_dummy_struct_ops.c

229

if (prog->sleepable)

net/bpf/bpf_dummy_struct_ops.c

96

static int check_test_run_args(struct bpf_prog *prog, struct bpf_dummy_ops_test_args *args)

net/bpf/bpf_dummy_struct_ops.c

98

const struct btf_type *func_proto = prog->aux->attach_func_proto;

net/bpf/test_run.c

1010

switch (prog->type) {

net/bpf/test_run.c

1159

ret = bpf_test_run(prog, skb, repeat, &retval, &duration, false);

net/bpf/test_run.c

1266

int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/test_run.c

1283

if (prog->expected_attach_type == BPF_XDP_DEVMAP ||

net/bpf/test_run.c

1284

prog->expected_attach_type == BPF_XDP_CPUMAP)

net/bpf/test_run.c

1290

if (bpf_prog_is_dev_bound(prog->aux))

net/bpf/test_run.c

1394

bpf_prog_change_xdp(NULL, prog);

net/bpf/test_run.c

1397

ret = bpf_test_run_xdp_live(prog, &xdp, repeat, batch_size, &duration);

net/bpf/test_run.c

1399

ret = bpf_test_run(prog, &xdp, repeat, &retval, &duration, true);

net/bpf/test_run.c

1418

bpf_prog_change_xdp(prog, NULL);

net/bpf/test_run.c

1443

int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

net/bpf/test_run.c

1492

retval = bpf_flow_dissect(prog, &ctx, eth->h_proto, ETH_HLEN,

net/bpf/test_run.c

1512

int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/test_run.c

1580

progs->items[0].prog = prog;

net/bpf/test_run.c

1612

int bpf_prog_test_run_syscall(struct bpf_prog *prog,

net/bpf/test_run.c

1629

if (ctx_size_in < prog->aux->max_ctx_offset ||

net/bpf/test_run.c

1640

retval = bpf_prog_run_pin_on_cpu(prog, ctx);

net/bpf/test_run.c

1710

int bpf_prog_test_run_nf(struct bpf_prog *prog,

net/bpf/test_run.c

1798

ret = bpf_test_run(prog, &ctx, repeat, &retval, &duration, false);

net/bpf/test_run.c

274

static int xdp_test_run_batch(struct xdp_test_data *xdp, struct bpf_prog *prog,

net/bpf/test_run.c

307

act = bpf_prog_run_xdp(prog, ctx);

net/bpf/test_run.c

330

ret = xdp_do_redirect_frame(xdp->dev, ctx, frm, prog);

net/bpf/test_run.c

338

bpf_warn_invalid_xdp_action(NULL, prog, act);

net/bpf/test_run.c

361

static int bpf_test_run_xdp_live(struct bpf_prog *prog, struct xdp_buff *ctx,

net/bpf/test_run.c

379

ret = xdp_test_run_batch(&xdp, prog, repeat - t.i);

net/bpf/test_run.c

389

static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat,

net/bpf/test_run.c

393

struct bpf_prog_array_item item = {.prog = prog};

net/bpf/test_run.c

401

item.cgroup_storage[stype] = bpf_cgroup_storage_alloc(prog, stype);

net/bpf/test_run.c

421

*retval = bpf_prog_run_xdp(prog, ctx);

net/bpf/test_run.c

423

*retval = bpf_prog_run(prog, ctx);

net/bpf/test_run.c

673

int bpf_prog_test_run_tracing(struct bpf_prog *prog,

net/bpf/test_run.c

685

switch (prog->expected_attach_type) {

net/bpf/test_run.c

725

struct bpf_prog *prog;

net/bpf/test_run.c

740

info->retval = bpf_prog_run(info->prog, info->ctx);

net/bpf/test_run.c

746

int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,

net/bpf/test_run.c

762

if (ctx_size_in < prog->aux->max_ctx_offset ||

net/bpf/test_run.c

777

info.prog = prog;

net/bpf/test_run.c

985

int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,

net/core/bpf_sk_storage.c

360

static bool bpf_sk_storage_tracing_allowed(const struct bpf_prog *prog)

net/core/bpf_sk_storage.c

362

if (prog->aux->dst_prog)

net/core/bpf_sk_storage.c

369

switch (prog->expected_attach_type) {

net/core/bpf_sk_storage.c

377

return !!strncmp(prog->aux->attach_func_name, "bpf_sk_storage",

net/core/bpf_sk_storage.c

802

struct bpf_prog *prog;

net/core/bpf_sk_storage.c

806

prog = bpf_iter_get_info(&meta, selem == NULL);

net/core/bpf_sk_storage.c

807

if (prog) {

net/core/bpf_sk_storage.c

815

ret = bpf_iter_run_prog(prog, &ctx);

net/core/bpf_sk_storage.c

852

static int bpf_iter_attach_map(struct bpf_prog *prog,

net/core/bpf_sk_storage.c

869

if (prog->aux->max_rdwr_access > map->value_size) {

net/core/dev.c

10253

return link->link.prog;

net/core/dev.c

10254

return dev->xdp_state[mode].prog;

net/core/dev.c

10263

if (dev->xdp_state[i].prog || dev->xdp_state[i].link)

net/core/dev.c

10275

if (dev->xdp_state[i].prog &&

net/core/dev.c

10276

!dev->xdp_state[i].prog->aux->xdp_has_frags)

net/core/dev.c

10288

bpf->prog && !bpf->prog->aux->xdp_has_frags) {

net/core/dev.c

10305

struct bpf_prog *prog = dev_xdp_prog(dev, mode);

net/core/dev.c

10307

return prog ? prog->aux->id : 0;

net/core/dev.c

10314

dev->xdp_state[mode].prog = NULL;

net/core/dev.c

10318

struct bpf_prog *prog)

net/core/dev.c

10321

dev->xdp_state[mode].prog = prog;

net/core/dev.c

10326

u32 flags, struct bpf_prog *prog)

net/core/dev.c

10334

prog && !prog->aux->xdp_has_frags) {

net/core/dev.c

10348

xdp.prog = prog;

net/core/dev.c

10356

if (prog)

net/core/dev.c

10357

bpf_prog_inc(prog);

net/core/dev.c

10360

if (prog)

net/core/dev.c

10361

bpf_prog_put(prog);

net/core/dev.c

10366

bpf_prog_change_xdp(dev_xdp_prog(dev, mode), prog);

net/core/dev.c

10374

struct bpf_prog *prog;

net/core/dev.c

10381

prog = dev_xdp_prog(dev, mode);

net/core/dev.c

10382

if (!prog)

net/core/dev.c

10396

bpf_prog_put(prog);

net/core/dev.c

10469

new_prog = link->link.prog;

net/core/dev.c

10632

if (old_prog && link->prog != old_prog) {

net/core/dev.c

10636

old_prog = link->prog;

net/core/dev.c

10658

old_prog = xchg(&link->prog, new_prog);

net/core/dev.c

10675

int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

net/core/dev.c

10697

bpf_link_init(&link->link, BPF_LINK_TYPE_XDP, &bpf_xdp_link_lops, prog,

net/core/dev.c

4437

const struct bpf_prog *prog;

net/core/dev.c

4442

bpf_mprog_foreach_prog(entry, fp, prog) {

net/core/dev.c

4444

ret = bpf_prog_run(prog, skb);

net/core/dev.c

5523

netif_skb_check_for_xdp(struct sk_buff **pskb, const struct bpf_prog *prog)

net/core/dev.c

5529

err = skb_cow_data_for_xdp(this_cpu_read(system_page_pool.pool), pskb, prog);

net/core/dev.c

6332

struct bpf_prog *new = xdp->prog;

net/core/filter.c

10069

insn = bpf_convert_tstamp_write(prog, si, insn);

net/core/filter.c

10071

insn = bpf_convert_tstamp_read(prog, si, insn);

net/core/filter.c

10129

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10304

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10318

return bpf_convert_ctx_access(type, si, insn_buf, prog,

net/core/filter.c

10328

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10452

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10541

struct bpf_prog *prog,

net/core/filter.c

11034

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

11050

prog->cb_access = 1;

net/core/filter.c

11064

return bpf_convert_ctx_access(type, si, insn_buf, prog,

net/core/filter.c

11074

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

11393

fprog = filter->prog->orig_prog;

net/core/filter.c

11437

struct bpf_prog *prog, struct sk_buff *skb,

net/core/filter.c

11445

action = bpf_prog_run(prog, &reuse_kern);

net/core/filter.c

11551

const struct bpf_prog *prog)

net/core/filter.c

11565

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

11572

const struct bpf_prog *prog,

net/core/filter.c

11640

struct bpf_prog *prog,

net/core/filter.c

11737

sk_lookup_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

11747

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

11753

const struct bpf_prog *prog,

net/core/filter.c

11800

struct bpf_prog *prog,

net/core/filter.c

11908

void bpf_prog_change_xdp(struct bpf_prog *prev_prog, struct bpf_prog *prog)

net/core/filter.c

1191

static void __bpf_prog_release(struct bpf_prog *prog)

net/core/filter.c

11910

bpf_dispatcher_change_prog(BPF_DISPATCHER_PTR(xdp), prev_prog, prog);

net/core/filter.c

1193

if (prog->type == BPF_PROG_TYPE_SOCKET_FILTER) {

net/core/filter.c

1194

bpf_prog_put(prog);

net/core/filter.c

1196

bpf_release_orig_filter(prog);

net/core/filter.c

1197

bpf_prog_free(prog);

net/core/filter.c

1203

__bpf_prog_release(fp->prog);

net/core/filter.c

12081

bpf_sk_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

12110

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

12113

if (!bpf_token_capable(prog->aux->token, CAP_PERFMON))

net/core/filter.c

1232

u32 filter_size = bpf_prog_size(fp->prog->len);

net/core/filter.c

1244

u32 filter_size = bpf_prog_size(fp->prog->len);

net/core/filter.c

12570

static int tracing_iter_filter(const struct bpf_prog *prog, u32 kfunc_id)

net/core/filter.c

12573

prog->expected_attach_type != BPF_TRACE_ITER)

net/core/filter.c

1480

static int __sk_attach_prog(struct bpf_prog *prog, struct sock *sk)

net/core/filter.c

1488

fp->prog = prog;

net/core/filter.c

1510

struct bpf_prog *prog;

net/core/filter.c

1520

prog = bpf_prog_alloc(bpf_prog_size(fprog->len), 0);

net/core/filter.c

1521

if (!prog)

net/core/filter.c

1524

if (copy_from_user(prog->insns, fprog->filter, fsize)) {

net/core/filter.c

1525

__bpf_prog_free(prog);

net/core/filter.c

1529

prog->len = fprog->len;

net/core/filter.c

1531

err = bpf_prog_store_orig_filter(prog, fprog);

net/core/filter.c

1533

__bpf_prog_free(prog);

net/core/filter.c

1540

return bpf_prepare_filter(prog, NULL);

net/core/filter.c

1555

struct bpf_prog *prog = __get_filter(fprog, sk);

net/core/filter.c

1558

if (IS_ERR(prog))

net/core/filter.c

1559

return PTR_ERR(prog);

net/core/filter.c

1561

err = __sk_attach_prog(prog, sk);

net/core/filter.c

1563

__bpf_prog_release(prog);

net/core/filter.c

1573

struct bpf_prog *prog = __get_filter(fprog, sk);

net/core/filter.c

1576

if (IS_ERR(prog))

net/core/filter.c

1577

return PTR_ERR(prog);

net/core/filter.c

1580

if (bpf_prog_size(prog->len) > optmem_max)

net/core/filter.c

1583

err = reuseport_attach_prog(sk, prog);

net/core/filter.c

1586

__bpf_prog_release(prog);

net/core/filter.c

1601

struct bpf_prog *prog = __get_bpf(ufd, sk);

net/core/filter.c

1604

if (IS_ERR(prog))

net/core/filter.c

1605

return PTR_ERR(prog);

net/core/filter.c

1607

err = __sk_attach_prog(prog, sk);

net/core/filter.c

1609

bpf_prog_put(prog);

net/core/filter.c

1618

struct bpf_prog *prog;

net/core/filter.c

1624

prog = bpf_prog_get_type(ufd, BPF_PROG_TYPE_SOCKET_FILTER);

net/core/filter.c

1625

if (PTR_ERR(prog) == -EINVAL)

net/core/filter.c

1626

prog = bpf_prog_get_type(ufd, BPF_PROG_TYPE_SK_REUSEPORT);

net/core/filter.c

1627

if (IS_ERR(prog))

net/core/filter.c

1628

return PTR_ERR(prog);

net/core/filter.c

1630

if (prog->type == BPF_PROG_TYPE_SK_REUSEPORT) {

net/core/filter.c

1648

if (bpf_prog_size(prog->len) > optmem_max) {

net/core/filter.c

1654

err = reuseport_attach_prog(sk, prog);

net/core/filter.c

1657

bpf_prog_put(prog);

net/core/filter.c

1662

void sk_reuseport_prog_free(struct bpf_prog *prog)

net/core/filter.c

1664

if (!prog)

net/core/filter.c

1667

if (prog->type == BPF_PROG_TYPE_SK_REUSEPORT)

net/core/filter.c

1668

bpf_prog_put(prog);

net/core/filter.c

1670

bpf_prog_destroy(prog);

net/core/filter.c

169

pkt_len = bpf_prog_run_save_cb(filter->prog, skb);

net/core/filter.c

585

static int bpf_convert_filter(struct sock_filter *prog, int len,

net/core/filter.c

610

fp = prog;

net/core/filter.c

7333

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

7527

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

8143

sock_filter_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8147

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8163

switch (prog->expected_attach_type) {

net/core/filter.c

8170

switch (prog->expected_attach_type) {

net/core/filter.c

8177

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

8182

sock_addr_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8186

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8192

switch (prog->expected_attach_type) {

net/core/filter.c

8220

switch (prog->expected_attach_type) {

net/core/filter.c

8243

switch (prog->expected_attach_type) {

net/core/filter.c

8266

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8271

sk_filter_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8287

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8295

cg_skb_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8299

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8339

return sk_filter_func_proto(func_id, prog);

net/core/filter.c

8344

tc_cls_act_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8476

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8481

xdp_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8535

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8556

sock_ops_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8560

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8596

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8604

sk_msg_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8630

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8638

sk_skb_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8674

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8679

flow_dissector_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8685

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8690

lwt_out_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8712

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8717

lwt_in_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8723

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8728

lwt_xmit_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8762

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8767

lwt_seg6local_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/core/filter.c

8779

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8784

const struct bpf_prog *prog,

net/core/filter.c

8851

const struct bpf_prog *prog,

net/core/filter.c

8875

return bpf_skb_is_valid_access(off, size, type, prog, info);

net/core/filter.c

8880

const struct bpf_prog *prog,

net/core/filter.c

8890

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

net/core/filter.c

8902

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

net/core/filter.c

8919

return bpf_skb_is_valid_access(off, size, type, prog, info);

net/core/filter.c

8924

const struct bpf_prog *prog,

net/core/filter.c

8957

return bpf_skb_is_valid_access(off, size, type, prog, info);

net/core/filter.c

9056

const struct bpf_prog *prog,

net/core/filter.c

9062

prog->expected_attach_type);

net/core/filter.c

9066

const struct bpf_prog *prog)

net/core/filter.c

9075

const struct bpf_prog *prog, int drop_verdict)

net/core/filter.c

9108

*insn++ = prog->insnsi[0];

net/core/filter.c

9149

const struct bpf_prog *prog)

net/core/filter.c

9151

return bpf_unclone_prologue(insn_buf, direct_write, prog, TC_ACT_SHOT);

net/core/filter.c

9156

const struct bpf_prog *prog,

net/core/filter.c

9193

((struct bpf_prog *)prog)->tstamp_type_access = 1;

net/core/filter.c

9197

return bpf_skb_is_valid_access(off, size, type, prog, info);

net/core/filter.c

9236

const struct bpf_prog *prog,

net/core/filter.c

9239

if (prog->expected_attach_type != BPF_XDP_DEVMAP) {

net/core/filter.c

9247

if (bpf_prog_is_offloaded(prog->aux)) {

net/core/filter.c

9280

const struct bpf_prog *prog, u32 act)

net/core/filter.c

9286

act, prog->aux->name, prog->aux->id, dev ? dev->name : "N/A");

net/core/filter.c

9306

const struct bpf_prog *prog,

net/core/filter.c

9321

switch (prog->expected_attach_type) {

net/core/filter.c

9334

switch (prog->expected_attach_type) {

net/core/filter.c

9347

switch (prog->expected_attach_type) {

net/core/filter.c

9356

switch (prog->expected_attach_type) {

net/core/filter.c

9427

const struct bpf_prog *prog,

net/core/filter.c

9490

const struct bpf_prog *prog)

net/core/filter.c

9492

return bpf_unclone_prologue(insn_buf, direct_write, prog, SK_DROP);

net/core/filter.c

9497

const struct bpf_prog *prog,

net/core/filter.c

95

bpf_sk_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);

net/core/filter.c

9530

return bpf_skb_is_valid_access(off, size, type, prog, info);

net/core/filter.c

9535

const struct bpf_prog *prog,

net/core/filter.c

9579

const struct bpf_prog *prog,

net/core/filter.c

9617

struct bpf_prog *prog,

net/core/filter.c

9687

static struct bpf_insn *bpf_convert_tstamp_read(const struct bpf_prog *prog,

net/core/filter.c

9699

if (!prog->tstamp_type_access) {

net/core/filter.c

9722

static struct bpf_insn *bpf_convert_tstamp_write(const struct bpf_prog *prog,

net/core/filter.c

9736

if (!prog->tstamp_type_access) {

net/core/filter.c

9763

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

9882

prog->cb_access = 1;

net/core/flow_dissector.c

1004

u32 bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx,

net/core/flow_dissector.c

1024

result = bpf_prog_run_pin_on_cpu(prog, ctx);

net/core/flow_dissector.c

1148

struct bpf_prog *prog;

net/core/flow_dissector.c

1160

prog = READ_ONCE(run_array->items[0].prog);

net/core/flow_dissector.c

1161

result = bpf_flow_dissect(prog, &ctx, n_proto, nhoff,

net/core/flow_dissector.c

78

struct bpf_prog *prog)

net/core/lwt_bpf.c

127

if (bpf->in.prog) {

net/core/lwt_bpf.c

150

if (bpf->out.prog) {

net/core/lwt_bpf.c

19

struct bpf_prog *prog;

net/core/lwt_bpf.c

278

if (bpf->xmit.prog) {

net/core/lwt_bpf.c

314

static void bpf_lwt_prog_destroy(struct bpf_lwt_prog *prog)

net/core/lwt_bpf.c

316

if (prog->prog)

net/core/lwt_bpf.c

317

bpf_prog_put(prog->prog);

net/core/lwt_bpf.c

319

kfree(prog->name);

net/core/lwt_bpf.c

337

static int bpf_parse_prog(struct nlattr *attr, struct bpf_lwt_prog *prog,

net/core/lwt_bpf.c

353

prog->name = nla_memdup(tb[LWT_BPF_PROG_NAME], GFP_ATOMIC);

net/core/lwt_bpf.c

354

if (!prog->name)

net/core/lwt_bpf.c

362

prog->prog = p;

net/core/lwt_bpf.c

449

struct bpf_lwt_prog *prog)

net/core/lwt_bpf.c

453

if (!prog->prog)

net/core/lwt_bpf.c

460

if (prog->name &&

net/core/lwt_bpf.c

461

nla_put_string(skb, LWT_BPF_PROG_NAME, prog->name))

net/core/lwt_bpf.c

52

ret = bpf_prog_run_save_cb(lwt->prog, skb);

net/core/skbuff.c

1022

const struct bpf_prog *prog)

net/core/skbuff.c

1024

if (!prog->aux->xdp_has_frags)

net/core/skmsg.c

1011

struct bpf_prog *prog;

net/core/skmsg.c

1015

prog = READ_ONCE(psock->progs.stream_verdict);

net/core/skmsg.c

1016

if (likely(prog)) {

net/core/skmsg.c

1020

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

1112

struct bpf_prog *prog;

net/core/skmsg.c

1123

prog = READ_ONCE(psock->progs.stream_verdict);

net/core/skmsg.c

1124

if (likely(prog)) {

net/core/skmsg.c

1128

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

1146

struct bpf_prog *prog;

net/core/skmsg.c

1150

prog = READ_ONCE(psock->progs.stream_parser);

net/core/skmsg.c

1151

if (likely(prog)) {

net/core/skmsg.c

1153

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

1239

struct bpf_prog *prog;

net/core/skmsg.c

1251

prog = READ_ONCE(psock->progs.stream_verdict);

net/core/skmsg.c

1252

if (!prog)

net/core/skmsg.c

1253

prog = READ_ONCE(psock->progs.skb_verdict);

net/core/skmsg.c

1254

if (likely(prog)) {

net/core/skmsg.c

1257

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

922

struct bpf_prog *prog;

net/core/skmsg.c

926

prog = READ_ONCE(psock->progs.msg_parser);

net/core/skmsg.c

927

if (unlikely(!prog)) {

net/core/skmsg.c

934

ret = bpf_prog_run_pin_on_cpu(prog, msg);

net/core/sock_diag.c

95

fprog = filter->prog->orig_prog;

net/core/sock_map.c

100

prog = bpf_prog_get(attr->attach_bpf_fd);

net/core/sock_map.c

101

if (IS_ERR(prog))

net/core/sock_map.c

102

return PTR_ERR(prog);

net/core/sock_map.c

104

if (prog->type != ptype) {

net/core/sock_map.c

110

ret = sock_map_prog_update(map, NULL, prog, NULL, attr->attach_type);

net/core/sock_map.c

113

bpf_prog_put(prog);

net/core/sock_map.c

1375

struct bpf_prog *prog;

net/core/sock_map.c

1378

prog = bpf_iter_get_info(&meta, !elem);

net/core/sock_map.c

1379

if (!prog)

net/core/sock_map.c

1389

return bpf_iter_run_prog(prog, &ctx);

net/core/sock_map.c

1524

static int sock_map_prog_update(struct bpf_map *map, struct bpf_prog *prog,

net/core/sock_map.c

1539

if ((!link || prog) && *plink)

net/core/sock_map.c

1543

ret = psock_replace_prog(pprog, prog, old);

net/core/sock_map.c

1547

psock_set_prog(pprog, prog);

net/core/sock_map.c

1561

struct bpf_prog *prog;

net/core/sock_map.c

1580

prog = *pprog;

net/core/sock_map.c

1581

prog_cnt = !prog ? 0 : 1;

net/core/sock_map.c

1589

id = data_race(prog->aux->id);

net/core/sock_map.c

1722

WARN_ON_ONCE(sock_map_prog_update(sockmap_link->map, NULL, link->prog, link,

net/core/sock_map.c

1747

struct bpf_prog *prog,

net/core/sock_map.c

1758

if (old && link->prog != old) {

net/core/sock_map.c

1763

if (link->prog->type != prog->type ||

net/core/sock_map.c

1764

link->prog->expected_attach_type != prog->expected_attach_type) {

net/core/sock_map.c

1785

ret = psock_replace_prog(pprog, prog, old);

net/core/sock_map.c

1789

psock_set_prog(pprog, prog);

net/core/sock_map.c

1792

bpf_prog_inc(prog);

net/core/sock_map.c

1793

old_link_prog = xchg(&link->prog, prog);

net/core/sock_map.c

1842

int sock_map_link_create(const union bpf_attr *attr, struct bpf_prog *prog)

net/core/sock_map.c

1868

bpf_link_init(&sockmap_link->link, BPF_LINK_TYPE_SOCKMAP, &sock_map_link_ops, prog,

net/core/sock_map.c

1879

ret = sock_map_prog_update(map, prog, NULL, &sockmap_link->link, attach_type);

net/core/sock_map.c

1893

bpf_prog_inc(prog);

net/core/sock_map.c

1902

static int sock_map_iter_attach_target(struct bpf_prog *prog,

net/core/sock_map.c

1920

if (prog->aux->max_rdonly_access > map->key_size) {

net/core/sock_map.c

34

static int sock_map_prog_update(struct bpf_map *map, struct bpf_prog *prog,

net/core/sock_map.c

68

int sock_map_get_from_fd(const union bpf_attr *attr, struct bpf_prog *prog)

net/core/sock_map.c

762

struct bpf_prog *prog;

net/core/sock_map.c

765

prog = bpf_iter_get_info(&meta, !v);

net/core/sock_map.c

766

if (!prog)

net/core/sock_map.c

776

return bpf_iter_run_prog(prog, &ctx);

net/core/sock_map.c

81

ret = sock_map_prog_update(map, prog, NULL, NULL, attr->attach_type);

net/core/sock_map.c

88

struct bpf_prog *prog;

net/core/sock_reuseport.c

184

RCU_INIT_POINTER(reuse->prog, NULL);

net/core/sock_reuseport.c

276

more_reuse->prog = reuse->prog;

net/core/sock_reuseport.c

307

sk_reuseport_prog_free(rcu_dereference_protected(reuse->prog, 1));

net/core/sock_reuseport.c

466

struct bpf_prog *prog;

net/core/sock_reuseport.c

472

prog = rcu_dereference_protected(reuse->prog,

net/core/sock_reuseport.c

476

(prog && prog->expected_attach_type == BPF_SK_REUSEPORT_SELECT_OR_MIGRATE)) {

net/core/sock_reuseport.c

498

struct bpf_prog *prog, struct sk_buff *skb,

net/core/sock_reuseport.c

516

index = bpf_prog_run_save_cb(prog, skb);

net/core/sock_reuseport.c

574

struct bpf_prog *prog;

net/core/sock_reuseport.c

585

prog = rcu_dereference(reuse->prog);

net/core/sock_reuseport.c

591

if (!prog || !skb)

net/core/sock_reuseport.c

594

if (prog->type == BPF_PROG_TYPE_SK_REUSEPORT)

net/core/sock_reuseport.c

595

sk2 = bpf_run_sk_reuseport(reuse, sk, prog, skb, NULL, hash);

net/core/sock_reuseport.c

597

sk2 = run_bpf_filter(reuse, socks, prog, skb, hdr_len);

net/core/sock_reuseport.c

627

struct bpf_prog *prog;

net/core/sock_reuseport.c

645

prog = rcu_dereference(reuse->prog);

net/core/sock_reuseport.c

646

if (!prog || prog->expected_attach_type != BPF_SK_REUSEPORT_SELECT_OR_MIGRATE) {

net/core/sock_reuseport.c

659

nsk = bpf_run_sk_reuseport(reuse, sk, prog, skb, migrating_sk, hash);

net/core/sock_reuseport.c

683

int reuseport_attach_prog(struct sock *sk, struct bpf_prog *prog)

net/core/sock_reuseport.c

705

old_prog = rcu_dereference_protected(reuse->prog,

net/core/sock_reuseport.c

707

rcu_assign_pointer(reuse->prog, prog);

net/core/sock_reuseport.c

738

old_prog = rcu_replace_pointer(reuse->prog, old_prog,

net/core/xdp.c

569

if (info->prog)

net/core/xdp.c

570

bpf_prog_put(info->prog);

net/core/xdp.c

571

info->prog = bpf->prog;

net/ipv4/bpf_tcp_ca.c

138

static u32 prog_ops_moff(const struct bpf_prog *prog)

net/ipv4/bpf_tcp_ca.c

144

midx = prog->expected_attach_type;

net/ipv4/bpf_tcp_ca.c

153

const struct bpf_prog *prog)

net/ipv4/bpf_tcp_ca.c

169

if (prog_ops_moff(prog) !=

net/ipv4/bpf_tcp_ca.c

180

if (prog_ops_moff(prog) !=

net/ipv4/bpf_tcp_ca.c

187

return bpf_base_func_proto(func_id, prog);

net/ipv4/bpf_tcp_ca.c

46

const struct bpf_prog *prog,

net/ipv4/bpf_tcp_ca.c

49

if (!bpf_tracing_btf_ctx_access(off, size, type, prog, info))

net/ipv4/tcp_ipv4.c

2976

static int tcp_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/ipv4/tcp_ipv4.c

2985

return bpf_iter_run_prog(prog, &ctx);

net/ipv4/tcp_ipv4.c

3299

struct bpf_prog *prog;

net/ipv4/tcp_ipv4.c

3327

prog = bpf_iter_get_info(&meta, false);

net/ipv4/tcp_ipv4.c

3328

ret = tcp_prog_seq_show(prog, &meta, v, uid);

net/ipv4/tcp_ipv4.c

3341

struct bpf_prog *prog;

net/ipv4/tcp_ipv4.c

3345

prog = bpf_iter_get_info(&meta, true);

net/ipv4/tcp_ipv4.c

3346

if (prog)

net/ipv4/tcp_ipv4.c

3347

(void)tcp_prog_seq_show(prog, &meta, v, 0);

net/ipv4/tcp_ipv4.c

3686

const struct bpf_prog *prog)

net/ipv4/udp.c

3652

static int udp_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/ipv4/udp.c

3662

return bpf_iter_run_prog(prog, &ctx);

net/ipv4/udp.c

3669

struct bpf_prog *prog;

net/ipv4/udp.c

3686

prog = bpf_iter_get_info(&meta, false);

net/ipv4/udp.c

3687

ret = udp_prog_seq_show(prog, &meta, v, uid, state->bucket);

net/ipv4/udp.c

3715

struct bpf_prog *prog;

net/ipv4/udp.c

3719

prog = bpf_iter_get_info(&meta, true);

net/ipv4/udp.c

3720

if (prog)

net/ipv4/udp.c

3721

(void)udp_prog_seq_show(prog, &meta, v, 0, 0);

net/ipv6/ip6_fib.c

2783

static int ipv6_route_prog_seq_show(struct bpf_prog *prog,

net/ipv6/ip6_fib.c

2791

return bpf_iter_run_prog(prog, &ctx);

net/ipv6/ip6_fib.c

2798

struct bpf_prog *prog;

net/ipv6/ip6_fib.c

2802

prog = bpf_iter_get_info(&meta, false);

net/ipv6/ip6_fib.c

2803

if (!prog)

net/ipv6/ip6_fib.c

2806

ret = ipv6_route_prog_seq_show(prog, &meta, v);

net/ipv6/ip6_fib.c

2815

struct bpf_prog *prog;

net/ipv6/ip6_fib.c

2819

prog = bpf_iter_get_info(&meta, true);

net/ipv6/ip6_fib.c

2820

if (prog)

net/ipv6/ip6_fib.c

2821

(void)ipv6_route_prog_seq_show(prog, &meta, v);

net/ipv6/seg6_local.c

1442

ret = bpf_prog_run_save_cb(slwt->bpf.prog, skb);

net/ipv6/seg6_local.c

1927

slwt->bpf.prog = p;

net/ipv6/seg6_local.c

1935

if (!slwt->bpf.prog)

net/ipv6/seg6_local.c

1942

if (nla_put_u32(skb, SEG6_LOCAL_BPF_PROG, slwt->bpf.prog->aux->id))

net/ipv6/seg6_local.c

1966

if (slwt->bpf.prog)

net/ipv6/seg6_local.c

1967

bpf_prog_put(slwt->bpf.prog);

net/ipv6/seg6_local.c

72

struct bpf_prog *prog;

net/kcm/kcmsock.c

1240

struct bpf_prog *prog)

net/kcm/kcmsock.c

1282

psock->bpf_prog = prog;

net/kcm/kcmsock.c

1345

struct bpf_prog *prog;

net/kcm/kcmsock.c

1352

prog = bpf_prog_get_type(info->bpf_fd, BPF_PROG_TYPE_SOCKET_FILTER);

net/kcm/kcmsock.c

1353

if (IS_ERR(prog)) {

net/kcm/kcmsock.c

1354

err = PTR_ERR(prog);

net/kcm/kcmsock.c

1358

err = kcm_attach(sock, csock, prog);

net/kcm/kcmsock.c

1360

bpf_prog_put(prog);

net/kcm/kcmsock.c

390

struct bpf_prog *prog = psock->bpf_prog;

net/kcm/kcmsock.c

393

res = bpf_prog_run_pin_on_cpu(prog, skb);

net/netfilter/nf_bpf_link.c

14

const struct bpf_prog *prog = bpf_prog;

net/netfilter/nf_bpf_link.c

20

return bpf_prog_run_pin_on_cpu(prog, &ctx);

net/netfilter/nf_bpf_link.c

210

int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

net/netfilter/nf_bpf_link.c

228

bpf_link_init(&link->link, BPF_LINK_TYPE_NETFILTER, &bpf_nf_link_lops, prog,

net/netfilter/nf_bpf_link.c

233

link->hook_ops.priv = prog;

net/netfilter/nf_bpf_link.c

293

const struct bpf_prog *prog,

net/netfilter/nf_bpf_link.c

324

bpf_nf_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/netfilter/nf_bpf_link.c

326

return bpf_base_func_proto(func_id, prog);

net/netfilter/nfnetlink_hook.c

80

const struct bpf_prog *prog)

net/netfilter/nfnetlink_hook.c

88

if (WARN_ON_ONCE(!prog))

net/netfilter/nfnetlink_hook.c

99

ret = nla_put_be32(nlskb, NFNLA_HOOK_BPF_ID, htonl(prog->aux->id));

net/netfilter/xt_bpf.c

45

struct bpf_prog *prog;

net/netfilter/xt_bpf.c

47

prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_SOCKET_FILTER);

net/netfilter/xt_bpf.c

48

if (IS_ERR(prog))

net/netfilter/xt_bpf.c

49

return PTR_ERR(prog);

net/netfilter/xt_bpf.c

51

*ret = prog;

net/netlink/af_netlink.c

2728

static int netlink_prog_seq_show(struct bpf_prog *prog,

net/netlink/af_netlink.c

2737

return bpf_iter_run_prog(prog, &ctx);

net/netlink/af_netlink.c

2743

struct bpf_prog *prog;

net/netlink/af_netlink.c

2746

prog = bpf_iter_get_info(&meta, false);

net/netlink/af_netlink.c

2747

if (!prog)

net/netlink/af_netlink.c

2751

return netlink_prog_seq_show(prog, &meta, v);

net/netlink/af_netlink.c

2759

struct bpf_prog *prog;

net/netlink/af_netlink.c

2763

prog = bpf_iter_get_info(&meta, true);

net/netlink/af_netlink.c

2764

if (prog)

net/netlink/af_netlink.c

2765

(void)netlink_prog_seq_show(prog, &meta, v);

net/packet/af_packet.c

1438

struct bpf_prog *prog;

net/packet/af_packet.c

1442

prog = rcu_dereference(f->bpf_prog);

net/packet/af_packet.c

1443

if (prog)

net/packet/af_packet.c

1444

ret = bpf_prog_run_clear_cb(prog, skb) % num;

net/packet/af_packet.c

2081

res = bpf_prog_run_clear_cb(filter->prog, skb);

net/sched/act_bpf.c

102

if (nla_put_u16(skb, TCA_ACT_BPF_OPS_LEN, prog->bpf_num_ops))

net/sched/act_bpf.c

105

nla = nla_reserve(skb, TCA_ACT_BPF_OPS, prog->bpf_num_ops *

net/sched/act_bpf.c

110

memcpy(nla_data(nla), prog->bpf_ops, nla_len(nla));

net/sched/act_bpf.c

115

static int tcf_bpf_dump_ebpf_info(const struct tcf_bpf *prog,

net/sched/act_bpf.c

120

if (prog->bpf_name &&

net/sched/act_bpf.c

121

nla_put_string(skb, TCA_ACT_BPF_NAME, prog->bpf_name))

net/sched/act_bpf.c

124

if (nla_put_u32(skb, TCA_ACT_BPF_ID, prog->filter->aux->id))

net/sched/act_bpf.c

127

nla = nla_reserve(skb, TCA_ACT_BPF_TAG, sizeof(prog->filter->tag));

net/sched/act_bpf.c

131

memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));

net/sched/act_bpf.c

140

struct tcf_bpf *prog = to_bpf(act);

net/sched/act_bpf.c

142

.index = prog->tcf_index,

net/sched/act_bpf.c

143

.refcnt = refcount_read(&prog->tcf_refcnt) - ref,

net/sched/act_bpf.c

144

.bindcnt = atomic_read(&prog->tcf_bindcnt) - bind,

net/sched/act_bpf.c

149

spin_lock_bh(&prog->tcf_lock);

net/sched/act_bpf.c

150

opt.action = prog->tcf_action;

net/sched/act_bpf.c

154

if (tcf_bpf_is_ebpf(prog))

net/sched/act_bpf.c

155

ret = tcf_bpf_dump_ebpf_info(prog, skb);

net/sched/act_bpf.c

157

ret = tcf_bpf_dump_bpf_info(prog, skb);

net/sched/act_bpf.c

161

tcf_tm_dump(&tm, &prog->tcf_tm);

net/sched/act_bpf.c

166

spin_unlock_bh(&prog->tcf_lock);

net/sched/act_bpf.c

170

spin_unlock_bh(&prog->tcf_lock);

net/sched/act_bpf.c

264

static void tcf_bpf_prog_fill_cfg(const struct tcf_bpf *prog,

net/sched/act_bpf.c

267

cfg->is_ebpf = tcf_bpf_is_ebpf(prog);

net/sched/act_bpf.c

271

cfg->filter = rcu_dereference_protected(prog->filter, 1);

net/sched/act_bpf.c

273

cfg->bpf_ops = prog->bpf_ops;

net/sched/act_bpf.c

274

cfg->bpf_name = prog->bpf_name;

net/sched/act_bpf.c

288

struct tcf_bpf *prog;

net/sched/act_bpf.c

348

prog = to_bpf(*act);

net/sched/act_bpf.c

350

spin_lock_bh(&prog->tcf_lock);

net/sched/act_bpf.c

352

tcf_bpf_prog_fill_cfg(prog, &old);

net/sched/act_bpf.c

354

prog->bpf_ops = cfg.bpf_ops;

net/sched/act_bpf.c

355

prog->bpf_name = cfg.bpf_name;

net/sched/act_bpf.c

358

prog->bpf_num_ops = cfg.bpf_num_ops;

net/sched/act_bpf.c

361

rcu_assign_pointer(prog->filter, cfg.filter);

net/sched/act_bpf.c

362

spin_unlock_bh(&prog->tcf_lock);

net/sched/act_bpf.c

40

struct tcf_bpf *prog = to_bpf(act);

net/sched/act_bpf.c

44

tcf_lastuse_update(&prog->tcf_tm);

net/sched/act_bpf.c

45

bstats_update(this_cpu_ptr(prog->common.cpu_bstats), skb);

net/sched/act_bpf.c

47

filter = rcu_dereference(prog->filter);

net/sched/act_bpf.c

79

qstats_drop_inc(this_cpu_ptr(prog->common.cpu_qstats));

net/sched/act_bpf.c

82

action = prog->tcf_action;

net/sched/act_bpf.c

92

static bool tcf_bpf_is_ebpf(const struct tcf_bpf *prog)

net/sched/act_bpf.c

94

return !prog->bpf_ops;

net/sched/act_bpf.c

97

static int tcf_bpf_dump_bpf_info(const struct tcf_bpf *prog,

net/sched/bpf_qdisc.c

136

const struct bpf_prog *prog)

net/sched/bpf_qdisc.c

140

if (prog->aux->attach_st_ops_member_off != offsetof(struct Qdisc_ops, init))

net/sched/bpf_qdisc.c

158

*insn++ = prog->insnsi[0];

net/sched/bpf_qdisc.c

165

static int bpf_qdisc_gen_epilogue(struct bpf_insn *insn_buf, const struct bpf_prog *prog,

net/sched/bpf_qdisc.c

170

if (prog->aux->attach_st_ops_member_off != offsetof(struct Qdisc_ops, reset) &&

net/sched/bpf_qdisc.c

171

prog->aux->attach_st_ops_member_off != offsetof(struct Qdisc_ops, destroy))

net/sched/bpf_qdisc.c

320

static int bpf_qdisc_kfunc_filter(const struct bpf_prog *prog, u32 kfunc_id)

net/sched/bpf_qdisc.c

327

if (prog->aux->st_ops != &bpf_Qdisc_ops)

net/sched/bpf_qdisc.c

330

moff = prog->aux->attach_st_ops_member_off;

net/sched/bpf_qdisc.c

35

const struct bpf_prog *prog,

net/sched/bpf_qdisc.c

38

struct btf *btf = prog->aux->attach_btf;

net/sched/bpf_qdisc.c

41

arg = btf_ctx_arg_idx(btf, prog->aux->attach_func_proto, off);

net/sched/bpf_qdisc.c

42

if (prog->aux->attach_st_ops_member_off == offsetof(struct Qdisc_ops, enqueue)) {

net/sched/bpf_qdisc.c

51

return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

net/sched/cls_bpf.c

100

filter_res = bpf_prog_run_data_pointers(prog->filter, skb);

net/sched/cls_bpf.c

103

filter_res = bpf_prog_run_data_pointers(prog->filter, skb);

net/sched/cls_bpf.c

108

if (prog->exts_integrated) {

net/sched/cls_bpf.c

110

res->classid = TC_H_MAJ(prog->res.classid) |

net/sched/cls_bpf.c

125

*res = prog->res;

net/sched/cls_bpf.c

128

ret = tcf_exts_exec(skb, &prog->exts, res);

net/sched/cls_bpf.c

138

static bool cls_bpf_is_ebpf(const struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

140

return !prog->bpf_ops;

net/sched/cls_bpf.c

143

static int cls_bpf_offload_cmd(struct tcf_proto *tp, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

153

skip_sw = prog && tc_skip_sw(prog->gen_flags);

net/sched/cls_bpf.c

154

obj = prog ?: oldprog;

net/sched/cls_bpf.c

159

cls_bpf.prog = prog ? prog->filter : NULL;

net/sched/cls_bpf.c

164

if (oldprog && prog)

net/sched/cls_bpf.c

168

&prog->gen_flags, &prog->in_hw_count,

net/sched/cls_bpf.c

170

else if (prog)

net/sched/cls_bpf.c

172

skip_sw, &prog->gen_flags,

net/sched/cls_bpf.c

173

&prog->in_hw_count, true);

net/sched/cls_bpf.c

179

if (prog && err) {

net/sched/cls_bpf.c

180

cls_bpf_offload_cmd(tp, oldprog, prog, extack);

net/sched/cls_bpf.c

184

if (prog && skip_sw && !(prog->gen_flags & TCA_CLS_FLAGS_IN_HW))

net/sched/cls_bpf.c

195

static int cls_bpf_offload(struct tcf_proto *tp, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

199

if (prog && oldprog &&

net/sched/cls_bpf.c

200

cls_bpf_flags(prog->gen_flags) !=

net/sched/cls_bpf.c

204

if (prog && tc_skip_hw(prog->gen_flags))

net/sched/cls_bpf.c

205

prog = NULL;

net/sched/cls_bpf.c

208

if (!prog && !oldprog)

net/sched/cls_bpf.c

211

return cls_bpf_offload_cmd(tp, prog, oldprog, extack);

net/sched/cls_bpf.c

215

struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

220

err = cls_bpf_offload_cmd(tp, NULL, prog, extack);

net/sched/cls_bpf.c

226

struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

231

tc_cls_common_offload_init(&cls_bpf.common, tp, prog->gen_flags, NULL);

net/sched/cls_bpf.c

233

cls_bpf.exts = &prog->exts;

net/sched/cls_bpf.c

234

cls_bpf.prog = prog->filter;

net/sched/cls_bpf.c

235

cls_bpf.name = prog->bpf_name;

net/sched/cls_bpf.c

236

cls_bpf.exts_integrated = prog->exts_integrated;

net/sched/cls_bpf.c

256

static void cls_bpf_free_parms(struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

258

if (cls_bpf_is_ebpf(prog))

net/sched/cls_bpf.c

259

bpf_prog_put(prog->filter);

net/sched/cls_bpf.c

261

bpf_prog_destroy(prog->filter);

net/sched/cls_bpf.c

263

kfree(prog->bpf_name);

net/sched/cls_bpf.c

264

kfree(prog->bpf_ops);

net/sched/cls_bpf.c

267

static void __cls_bpf_delete_prog(struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

269

tcf_exts_destroy(&prog->exts);

net/sched/cls_bpf.c

270

tcf_exts_put_net(&prog->exts);

net/sched/cls_bpf.c

272

cls_bpf_free_parms(prog);

net/sched/cls_bpf.c

273

kfree(prog);

net/sched/cls_bpf.c

278

struct cls_bpf_prog *prog = container_of(to_rcu_work(work),

net/sched/cls_bpf.c

282

__cls_bpf_delete_prog(prog);

net/sched/cls_bpf.c

286

static void __cls_bpf_delete(struct tcf_proto *tp, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

291

idr_remove(&head->handle_idr, prog->handle);

net/sched/cls_bpf.c

292

cls_bpf_stop_offload(tp, prog, extack);

net/sched/cls_bpf.c

293

list_del_rcu(&prog->link);

net/sched/cls_bpf.c

294

tcf_unbind_filter(tp, &prog->res);

net/sched/cls_bpf.c

295

if (tcf_exts_get_net(&prog->exts))

net/sched/cls_bpf.c

296

tcf_queue_work(&prog->rwork, cls_bpf_delete_prog_work);

net/sched/cls_bpf.c

298

__cls_bpf_delete_prog(prog);

net/sched/cls_bpf.c

315

struct cls_bpf_prog *prog, *tmp;

net/sched/cls_bpf.c

317

list_for_each_entry_safe(prog, tmp, &head->plist, link)

net/sched/cls_bpf.c

318

__cls_bpf_delete(tp, prog, extack);

net/sched/cls_bpf.c

327

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

329

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

330

if (prog->handle == handle)

net/sched/cls_bpf.c

331

return prog;

net/sched/cls_bpf.c

337

static int cls_bpf_prog_from_ops(struct nlattr **tb, struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

366

prog->bpf_ops = bpf_ops;

net/sched/cls_bpf.c

367

prog->bpf_num_ops = bpf_num_ops;

net/sched/cls_bpf.c

368

prog->bpf_name = NULL;

net/sched/cls_bpf.c

369

prog->filter = fp;

net/sched/cls_bpf.c

374

static int cls_bpf_prog_from_efd(struct nlattr **tb, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

397

prog->bpf_ops = NULL;

net/sched/cls_bpf.c

398

prog->bpf_name = name;

net/sched/cls_bpf.c

399

prog->filter = fp;

net/sched/cls_bpf.c

418

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

430

prog = kzalloc_obj(*prog);

net/sched/cls_bpf.c

431

if (!prog)

net/sched/cls_bpf.c

434

ret = tcf_exts_init(&prog->exts, net, TCA_BPF_ACT, TCA_BPF_POLICE);

net/sched/cls_bpf.c

447

ret = idr_alloc_u32(&head->handle_idr, prog, &handle,

net/sched/cls_bpf.c

450

ret = idr_alloc_u32(&head->handle_idr, prog, &handle,

net/sched/cls_bpf.c

456

prog->handle = handle;

net/sched/cls_bpf.c

465

ret = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &prog->exts,

net/sched/cls_bpf.c

489

prog->exts_integrated = have_exts;

net/sched/cls_bpf.c

490

prog->gen_flags = gen_flags;

net/sched/cls_bpf.c

492

ret = is_bpf ? cls_bpf_prog_from_ops(tb, prog) :

net/sched/cls_bpf.c

493

cls_bpf_prog_from_efd(tb, prog, gen_flags, tp);

net/sched/cls_bpf.c

498

prog->res.classid = nla_get_u32(tb[TCA_BPF_CLASSID]);

net/sched/cls_bpf.c

499

tcf_bind_filter(tp, &prog->res, base);

net/sched/cls_bpf.c

503

ret = cls_bpf_offload(tp, prog, oldprog, extack);

net/sched/cls_bpf.c

507

if (!tc_in_hw(prog->gen_flags))

net/sched/cls_bpf.c

508

prog->gen_flags |= TCA_CLS_FLAGS_NOT_IN_HW;

net/sched/cls_bpf.c

510

tcf_proto_update_usesw(tp, prog->gen_flags);

net/sched/cls_bpf.c

513

idr_replace(&head->handle_idr, prog, handle);

net/sched/cls_bpf.c

514

list_replace_rcu(&oldprog->link, &prog->link);

net/sched/cls_bpf.c

519

list_add_rcu(&prog->link, &head->plist);

net/sched/cls_bpf.c

522

*arg = prog;

net/sched/cls_bpf.c

527

tcf_unbind_filter(tp, &prog->res);

net/sched/cls_bpf.c

528

cls_bpf_free_parms(prog);

net/sched/cls_bpf.c

531

idr_remove(&head->handle_idr, prog->handle);

net/sched/cls_bpf.c

533

tcf_exts_destroy(&prog->exts);

net/sched/cls_bpf.c

534

kfree(prog);

net/sched/cls_bpf.c

538

static int cls_bpf_dump_bpf_info(const struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

543

if (nla_put_u16(skb, TCA_BPF_OPS_LEN, prog->bpf_num_ops))

net/sched/cls_bpf.c

546

nla = nla_reserve(skb, TCA_BPF_OPS, prog->bpf_num_ops *

net/sched/cls_bpf.c

551

memcpy(nla_data(nla), prog->bpf_ops, nla_len(nla));

net/sched/cls_bpf.c

556

static int cls_bpf_dump_ebpf_info(const struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

561

if (prog->bpf_name &&

net/sched/cls_bpf.c

562

nla_put_string(skb, TCA_BPF_NAME, prog->bpf_name))

net/sched/cls_bpf.c

565

if (nla_put_u32(skb, TCA_BPF_ID, prog->filter->aux->id))

net/sched/cls_bpf.c

568

nla = nla_reserve(skb, TCA_BPF_TAG, sizeof(prog->filter->tag));

net/sched/cls_bpf.c

572

memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));

net/sched/cls_bpf.c

580

struct cls_bpf_prog *prog = fh;

net/sched/cls_bpf.c

585

if (prog == NULL)

net/sched/cls_bpf.c

588

tm->tcm_handle = prog->handle;

net/sched/cls_bpf.c

590

cls_bpf_offload_update_stats(tp, prog);

net/sched/cls_bpf.c

596

if (prog->res.classid &&

net/sched/cls_bpf.c

597

nla_put_u32(skb, TCA_BPF_CLASSID, prog->res.classid))

net/sched/cls_bpf.c

600

if (cls_bpf_is_ebpf(prog))

net/sched/cls_bpf.c

601

ret = cls_bpf_dump_ebpf_info(prog, skb);

net/sched/cls_bpf.c

603

ret = cls_bpf_dump_bpf_info(prog, skb);

net/sched/cls_bpf.c

607

if (tcf_exts_dump(skb, &prog->exts) < 0)

net/sched/cls_bpf.c

610

if (prog->exts_integrated)

net/sched/cls_bpf.c

614

if (prog->gen_flags &&

net/sched/cls_bpf.c

615

nla_put_u32(skb, TCA_BPF_FLAGS_GEN, prog->gen_flags))

net/sched/cls_bpf.c

620

if (tcf_exts_dump_stats(skb, &prog->exts) < 0)

net/sched/cls_bpf.c

633

struct cls_bpf_prog *prog = fh;

net/sched/cls_bpf.c

635

tc_cls_bind_class(classid, cl, q, &prog->res, base);

net/sched/cls_bpf.c

642

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

644

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

645

if (!tc_cls_stats_dump(tp, arg, prog))

net/sched/cls_bpf.c

656

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

659

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

660

if (tc_skip_hw(prog->gen_flags))

net/sched/cls_bpf.c

663

tc_cls_common_offload_init(&cls_bpf.common, tp, prog->gen_flags,

net/sched/cls_bpf.c

666

cls_bpf.exts = &prog->exts;

net/sched/cls_bpf.c

667

cls_bpf.prog = add ? prog->filter : NULL;

net/sched/cls_bpf.c

668

cls_bpf.oldprog = add ? NULL : prog->filter;

net/sched/cls_bpf.c

669

cls_bpf.name = prog->bpf_name;

net/sched/cls_bpf.c

670

cls_bpf.exts_integrated = prog->exts_integrated;

net/sched/cls_bpf.c

673

&cls_bpf, cb_priv, &prog->gen_flags,

net/sched/cls_bpf.c

674

&prog->in_hw_count);

net/sched/cls_bpf.c

87

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

90

list_for_each_entry_rcu(prog, &head->plist, link) {

net/sched/cls_bpf.c

93

qdisc_skb_cb(skb)->tc_classid = prog->res.classid;

net/sched/cls_bpf.c

95

if (tc_skip_sw(prog->gen_flags)) {

net/sched/cls_bpf.c

96

filter_res = prog->exts_integrated ? TC_ACT_UNSPEC : 0;

net/smc/smc_hs_bpf.c

116

bpf_smc_hs_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)

net/smc/smc_hs_bpf.c

118

return bpf_base_func_proto(func_id, prog);

net/sunrpc/rpcb_clnt.c

454

int rpcb_register(struct net *net, u32 prog, u32 vers, int prot, unsigned short port)

net/sunrpc/rpcb_clnt.c

457

.r_prog = prog,

net/sunrpc/rpcb_clnt.c

468

trace_pmap_register(prog, vers, prot, port);

net/sunrpc/stats.c

103

for (i = 0; i < prog->pg_nvers; i++) {

net/sunrpc/stats.c

104

vers = prog->pg_vers[i];

net/sunrpc/stats.c

39

const struct rpc_program *prog = statp->program;

net/sunrpc/stats.c

54

for (i = 0; i < prog->nrvers; i++) {

net/sunrpc/stats.c

55

const struct rpc_version *vers = prog->version[i];

net/sunrpc/stats.c

84

const struct svc_program *prog = statp->program;

net/sunrpc/svc.c

483

__svc_create(struct svc_program *prog, int nprogs, struct svc_stat *stats,

net/sunrpc/svc.c

493

serv->sv_name = prog->pg_name;

net/sunrpc/svc.c

494

serv->sv_programs = prog;

net/sunrpc/svc.c

504

struct svc_program *progp = &prog[i];

net/sunrpc/svc.c

559

struct svc_serv *svc_create(struct svc_program *prog, unsigned int bufsize,

net/sunrpc/svc.c

562

return __svc_create(prog, 1, NULL, bufsize, 1, threadfn);

net/sunrpc/svc.c

576

struct svc_serv *svc_create_pooled(struct svc_program *prog,

net/sunrpc/svc.c

585

serv = __svc_create(prog, nprogs, stats, bufsize, npools, threadfn);

net/unix/af_unix.c

3600

static int unix_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/unix/af_unix.c

3609

return bpf_iter_run_prog(prog, &ctx);

net/unix/af_unix.c

3731

struct bpf_prog *prog;

net/unix/af_unix.c

3749

prog = bpf_iter_get_info(&meta, false);

net/unix/af_unix.c

3750

ret = unix_prog_seq_show(prog, &meta, v, uid);

net/unix/af_unix.c

3760

struct bpf_prog *prog;

net/unix/af_unix.c

3764

prog = bpf_iter_get_info(&meta, true);

net/unix/af_unix.c

3765

if (prog)

net/unix/af_unix.c

3766

(void)unix_prog_seq_show(prog, &meta, v, 0);

net/unix/af_unix.c

3886

const struct bpf_prog *prog)

samples/bpf/cookie_uid_helper_example.c

166

prog, ARRAY_SIZE(prog), &opts);

samples/bpf/cookie_uid_helper_example.c

80

struct bpf_insn prog[] = {

samples/bpf/cpustat_user.c

192

struct bpf_program *prog;

samples/bpf/cpustat_user.c

204

prog = bpf_object__find_program_by_name(obj, "bpf_prog1");

samples/bpf/cpustat_user.c

205

if (!prog) {

samples/bpf/cpustat_user.c

223

link = bpf_program__attach(prog);

samples/bpf/hbm.c

119

static int prog_load(char *prog)

samples/bpf/hbm.c

124

obj = bpf_object__open_file(prog, NULL);

samples/bpf/hbm.c

161

static int run_bpf_prog(char *prog, int cg_id)

samples/bpf/hbm.c

171

rc = prog_load(prog);

samples/bpf/hbm.c

452

char *prog = "hbm_out_kern.o";

samples/bpf/hbm.c

468

prog = "hbm_edt_kern.o";

samples/bpf/hbm.c

508

prog = argv[optind];

samples/bpf/hbm.c

509

printf("HBM prog: %s\n", prog != NULL ? prog : "NULL");

samples/bpf/hbm.c

514

return run_bpf_prog(prog, cg_id);

samples/bpf/ibumad_user.c

135

bpf_object__for_each_program(prog, obj) {

samples/bpf/ibumad_user.c

136

tp_links[tp_cnt] = bpf_program__attach(prog);

samples/bpf/ibumad_user.c

85

struct bpf_program *prog;

samples/bpf/lathist_user.c

108

bpf_object__for_each_program(prog, obj) {

samples/bpf/lathist_user.c

109

links[i] = bpf_program__attach(prog);

samples/bpf/lathist_user.c

84

struct bpf_program *prog;

samples/bpf/map_perf_test_user.c

428

struct bpf_program *prog;

samples/bpf/map_perf_test_user.c

483

bpf_object__for_each_program(prog, obj) {

samples/bpf/map_perf_test_user.c

484

links[i] = bpf_program__attach(prog);

samples/bpf/offwaketime_user.c

132

bpf_object__for_each_program(prog, obj) {

samples/bpf/offwaketime_user.c

133

links[i] = bpf_program__attach(prog);

samples/bpf/offwaketime_user.c

99

struct bpf_program *prog;

samples/bpf/sampleip_user.c

143

struct bpf_program *prog;

samples/bpf/sampleip_user.c

195

prog = bpf_object__find_program_by_name(obj, "do_sample");

samples/bpf/sampleip_user.c

196

if (!prog) {

samples/bpf/sampleip_user.c

219

if (sampling_start(freq, prog, links) != 0)

samples/bpf/sampleip_user.c

36

static int sampling_start(int freq, struct bpf_program *prog,

samples/bpf/sampleip_user.c

56

links[i] = bpf_program__attach_perf_event(prog, pmu_fd);

samples/bpf/sock_example.c

48

struct bpf_insn prog[] = {

samples/bpf/sock_example.c

62

size_t insns_cnt = ARRAY_SIZE(prog);

samples/bpf/sock_example.c

69

prog, insns_cnt, &opts);

samples/bpf/sockex1_user.c

14

struct bpf_program *prog;

samples/bpf/sockex1_user.c

26

prog = bpf_object__next_program(obj, NULL);

samples/bpf/sockex1_user.c

27

bpf_program__set_type(prog, BPF_PROG_TYPE_SOCKET_FILTER);

samples/bpf/sockex1_user.c

33

prog_fd = bpf_program__fd(prog);

samples/bpf/sockex2_user.c

18

struct bpf_program *prog;

samples/bpf/sockex2_user.c

30

prog = bpf_object__next_program(obj, NULL);

samples/bpf/sockex2_user.c

31

bpf_program__set_type(prog, BPF_PROG_TYPE_SOCKET_FILTER);

samples/bpf/sockex2_user.c

37

prog_fd = bpf_program__fd(prog);

samples/bpf/sockex3_user.c

28

struct bpf_program *prog;

samples/bpf/sockex3_user.c

55

bpf_object__for_each_program(prog, obj) {

samples/bpf/sockex3_user.c

56

fd = bpf_program__fd(prog);

samples/bpf/sockex3_user.c

58

if (!strcmp(bpf_program__name(prog), "main_prog"))

samples/bpf/spintest_user.c

15

struct bpf_program *prog;

samples/bpf/spintest_user.c

45

bpf_object__for_each_program(prog, obj) {

samples/bpf/spintest_user.c

46

links[j] = bpf_program__attach(prog);

samples/bpf/syscall_tp_user.c

53

struct bpf_program *prog;

samples/bpf/syscall_tp_user.c

67

bpf_object__for_each_program(prog, objs[i])

samples/bpf/syscall_tp_user.c

91

bpf_object__for_each_program(prog, objs[i]) {

samples/bpf/syscall_tp_user.c

92

links[j] = bpf_program__attach(prog);

samples/bpf/task_fd_query_user.c

315

struct bpf_program *prog;

samples/bpf/task_fd_query_user.c

337

bpf_object__for_each_program(prog, obj) {

samples/bpf/task_fd_query_user.c

338

progs[i] = prog;

samples/bpf/test_map_in_map_user.c

119

struct bpf_program *prog;

samples/bpf/test_map_in_map_user.c

130

prog = bpf_object__find_program_by_name(obj, "trace_sys_connect");

samples/bpf/test_map_in_map_user.c

131

if (!prog) {

samples/bpf/test_map_in_map_user.c

155

link = bpf_program__attach(prog);

samples/bpf/trace_event_user.c

158

links[i] = bpf_program__attach_perf_event(prog, pmu_fd);

samples/bpf/trace_event_user.c

197

link = bpf_program__attach_perf_event(prog, pmu_fd);

samples/bpf/trace_event_user.c

24

struct bpf_program *prog;

samples/bpf/trace_event_user.c

318

prog = bpf_object__find_program_by_name(obj, "bpf_prog1");

samples/bpf/trace_event_user.c

319

if (!prog) {

samples/bpf/trace_output_user.c

47

struct bpf_program *prog;

samples/bpf/trace_output_user.c

73

prog = bpf_object__find_program_by_name(obj, "bpf_prog1");

samples/bpf/trace_output_user.c

74

if (libbpf_get_error(prog)) {

samples/bpf/trace_output_user.c

79

link = bpf_program__attach(prog);

samples/bpf/tracex1_user.c

10

struct bpf_program *prog;

samples/bpf/tracex1_user.c

22

prog = bpf_object__find_program_by_name(obj, "bpf_prog1");

samples/bpf/tracex1_user.c

23

if (!prog) {

samples/bpf/tracex1_user.c

34

link = bpf_program__attach(prog);

samples/bpf/tracex3_user.c

110

struct bpf_program *prog;

samples/bpf/tracex3_user.c

147

bpf_object__for_each_program(prog, obj) {

samples/bpf/tracex3_user.c

148

links[j] = bpf_program__attach(prog);

samples/bpf/tracex4_user.c

51

struct bpf_program *prog;

samples/bpf/tracex4_user.c

75

bpf_object__for_each_program(prog, obj) {

samples/bpf/tracex4_user.c

76

links[j] = bpf_program__attach(prog);

samples/bpf/tracex5_user.c

27

struct sock_fprog prog = {

samples/bpf/tracex5_user.c

31

if (prctl(PR_SET_SECCOMP, 2, &prog))

samples/bpf/tracex5_user.c

38

struct bpf_program *prog;

samples/bpf/tracex5_user.c

52

prog = bpf_object__find_program_by_name(obj, "bpf_prog1");

samples/bpf/tracex5_user.c

53

if (!prog) {

samples/bpf/tracex5_user.c

64

link = bpf_program__attach(prog);

samples/bpf/tracex5_user.c

77

bpf_object__for_each_program(prog, obj) {

samples/bpf/tracex5_user.c

78

section = bpf_program__section_name(prog);

samples/bpf/tracex5_user.c

83

fd = bpf_program__fd(prog);

samples/bpf/tracex6_user.c

178

struct bpf_program *prog;

samples/bpf/tracex6_user.c

204

bpf_object__for_each_program(prog, obj) {

samples/bpf/tracex6_user.c

205

links[i] = bpf_program__attach(prog);

samples/bpf/xdp_adjust_tail_user.c

153

prog = bpf_object__next_program(obj, NULL);

samples/bpf/xdp_adjust_tail_user.c

154

bpf_program__set_type(prog, BPF_PROG_TYPE_XDP);

samples/bpf/xdp_adjust_tail_user.c

160

prog_fd = bpf_program__fd(prog);

samples/bpf/xdp_adjust_tail_user.c

90

struct bpf_program *prog;

samples/bpf/xdp_fwd_user.c

107

static void usage(const char *prog)

samples/bpf/xdp_fwd_user.c

116

prog);

samples/bpf/xdp_fwd_user.c

122

struct bpf_program *prog = NULL;

samples/bpf/xdp_fwd_user.c

173

prog = bpf_object__next_program(obj, NULL);

samples/bpf/xdp_fwd_user.c

174

bpf_program__set_type(prog, BPF_PROG_TYPE_XDP);

samples/bpf/xdp_fwd_user.c

188

prog = pos;

samples/bpf/xdp_fwd_user.c

192

prog_fd = bpf_program__fd(prog);

samples/bpf/xdp_tx_iptunnel_user.c

161

struct bpf_program *prog;

samples/bpf/xdp_tx_iptunnel_user.c

264

prog = bpf_object__next_program(obj, NULL);

samples/bpf/xdp_tx_iptunnel_user.c

265

bpf_program__set_type(prog, BPF_PROG_TYPE_XDP);

samples/bpf/xdp_tx_iptunnel_user.c

272

prog_fd = bpf_program__fd(prog);

samples/hid/hid_mouse.c

41

static void usage(const char *prog)

samples/hid/hid_mouse.c

45

__func__, prog);

samples/hid/hid_surface_dial.c

48

static void usage(const char *prog)

samples/hid/hid_surface_dial.c

54

__func__, prog);

samples/seccomp/bpf-direct.c

145

struct sock_fprog prog = {

samples/seccomp/bpf-direct.c

156

if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {

samples/seccomp/bpf-fancy.c

81

struct sock_fprog prog = {

samples/seccomp/bpf-fancy.c

93

if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog)) {

samples/seccomp/dropper.c

41

struct sock_fprog prog = {

samples/seccomp/dropper.c

53

if (prctl(PR_SET_SECCOMP, 2, &prog)) {

samples/seccomp/user-trap.c

100

struct sock_fprog prog = {

samples/seccomp/user-trap.c

105

return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);

samples/vfs/mountinfo.c

201

static void usage(const char * const prog)

samples/vfs/mountinfo.c

204

printf("%s [-e] [-p pid] [-r] [-h]\n", prog);

security/security.c

326

static int lsm_bpf_prog_alloc(struct bpf_prog *prog)

security/security.c

328

return lsm_blob_alloc(&prog->aux->security, blob_sizes.lbs_bpf_prog, GFP_KERNEL);

security/security.c

5204

int security_bpf_prog(struct bpf_prog *prog)

security/security.c

5206

return call_int_hook(bpf_prog, prog);

security/security.c

5249

int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

security/security.c

5254

rc = lsm_bpf_prog_alloc(prog);

security/security.c

5258

rc = call_int_hook(bpf_prog_load, prog, attr, token, kernel);

security/security.c

5260

security_bpf_prog_free(prog);

security/security.c

5341

void security_bpf_prog_free(struct bpf_prog *prog)

security/security.c

5343

call_void_hook(bpf_prog_free, prog);

security/security.c

5344

kfree(prog->aux->security);

security/security.c

5345

prog->aux->security = NULL;

security/selinux/hooks.c

7093

struct bpf_prog *prog;

security/selinux/hooks.c

7105

prog = file->private_data;

security/selinux/hooks.c

7106

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/hooks.c

7125

static int selinux_bpf_prog(struct bpf_prog *prog)

security/selinux/hooks.c

7130

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/hooks.c

7171

static int selinux_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

security/selinux/hooks.c

7177

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/include/objsec.h

270

selinux_bpf_prog_security(struct bpf_prog *prog)

security/selinux/include/objsec.h

272

return prog->aux->security + selinux_blob_sizes.lbs_bpf_prog;

sound/drivers/opl3/opl3_synth.c

201

err = snd_opl3_load_patch(opl3, inst.prog, inst.bank, type,

sound/drivers/opl3/opl3_synth.c

240

int prog, int bank, int type,

sound/drivers/opl3/opl3_synth.c

248

patch = snd_opl3_find_patch(opl3, prog, bank, 1);

sound/drivers/opl3/opl3_synth.c

302

struct fm_patch *snd_opl3_find_patch(struct snd_opl3 *opl3, int prog, int bank,

sound/drivers/opl3/opl3_synth.c

306

unsigned int key = (prog + bank) % OPL3_PATCH_HASH_SIZE;

sound/drivers/opl3/opl3_synth.c

310

if (patch->prog == prog && patch->bank == bank)

sound/drivers/opl3/opl3_synth.c

319

patch->prog = prog;

sound/isa/wavefront/wavefront_synth.c

739

wavefront_program prog;

sound/isa/wavefront/wavefront_synth.c

752

demunge_buf (progbuf, (unsigned char *) &prog,

sound/isa/wavefront/wavefront_synth.c

756

if (prog.layer[l].mute) {

sound/isa/wavefront/wavefront_synth.c

758

[prog.layer[l].patch_number] |=

sound/soc/codecs/tas2781-comlib.c

133

static void tasdev_dsp_prog_blk_remove(struct tasdevice_prog *prog)

sound/soc/codecs/tas2781-comlib.c

139

if (!prog)

sound/soc/codecs/tas2781-comlib.c

142

tas_dt = &(prog->dev_data);

sound/soc/codecs/tas2781-comlib.c

154

static void tasdev_dsp_prog_remove(struct tasdevice_prog *prog,

sound/soc/codecs/tas2781-comlib.c

160

tasdev_dsp_prog_blk_remove(&prog[i]);

sound/soc/codecs/tas2781-comlib.c

161

kfree(prog);

tools/arch/x86/intel_sdsi/intel_sdsi.c

742

static void usage(char *prog)

tools/arch/x86/intel_sdsi/intel_sdsi.c

744

printf("Usage: %s [-l] [-d DEVNO [-i] [-s] [-m | -C] [-a FILE] [-c FILE]\n", prog);

tools/bpf/bpf_exp.y

71

prog

tools/bpf/bpf_exp.y

73

| prog line

tools/bpf/bpftool/gen.c

1002

i, bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1009

i, bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1226

struct bpf_program *prog;

tools/bpf/bpftool/gen.c

1310

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

1373

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

1376

bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1379

bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1386

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

1389

bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1392

bpf_program__name(prog));

tools/bpf/bpftool/gen.c

1641

struct bpf_program *prog;

tools/bpf/bpftool/gen.c

1726

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

1797

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

1799

bpf_program__name(prog));

tools/bpf/bpftool/gen.c

564

struct bpf_program *prog;

tools/bpf/bpftool/gen.c

566

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

576

", obj_name, bpf_program__name(prog));

tools/bpf/bpftool/gen.c

578

switch (bpf_program__type(prog)) {

tools/bpf/bpftool/gen.c

580

tp_name = strchr(bpf_program__section_name(prog), '/') + 1;

tools/bpf/bpftool/gen.c

585

if (bpf_program__expected_attach_type(prog) == BPF_TRACE_ITER)

tools/bpf/bpftool/gen.c

601

", bpf_program__name(prog));

tools/bpf/bpftool/gen.c

614

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

618

", obj_name, bpf_program__name(prog));

tools/bpf/bpftool/gen.c

631

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

635

", bpf_program__name(prog));

tools/bpf/bpftool/gen.c

646

struct bpf_program *prog;

tools/bpf/bpftool/gen.c

661

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/gen.c

665

", bpf_program__name(prog));

tools/bpf/bpftool/gen.c

974

struct bpf_program *prog;

tools/bpf/bpftool/gen.c

995

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/iter.c

19

struct bpf_program *prog;

tools/bpf/bpftool/iter.c

64

prog = bpf_object__next_program(obj, NULL);

tools/bpf/bpftool/iter.c

65

if (!prog) {

tools/bpf/bpftool/iter.c

71

link = bpf_program__attach_iter(prog, &iter_opts);

tools/bpf/bpftool/iter.c

75

bpf_program__name(prog));

tools/bpf/bpftool/iter.c

86

bpf_program__name(prog), path);

tools/bpf/bpftool/prog.c

1520

auto_attach_program(struct bpf_program *prog, const char *path)

tools/bpf/bpftool/prog.c

1525

link = bpf_program__attach(prog);

tools/bpf/bpftool/prog.c

1528

bpf_program__name(prog));

tools/bpf/bpftool/prog.c

1529

return bpf_obj_pin(bpf_program__fd(prog), path);

tools/bpf/bpftool/prog.c

1540

struct bpf_program *prog;

tools/bpf/bpftool/prog.c

1544

bpf_object__for_each_program(prog, obj) {

tools/bpf/bpftool/prog.c

1545

err = pathname_concat(buf, sizeof(buf), path, bpf_program__name(prog));

tools/bpf/bpftool/prog.c

1549

err = auto_attach_program(prog, buf);

tools/bpf/bpftool/prog.c

1557

while ((prog = bpf_object__prev_program(obj, prog))) {

tools/bpf/bpftool/prog.c

1558

if (pathname_concat(buf, sizeof(buf), path, bpf_program__name(prog)))

tools/bpf/bpftool/prog.c

1561

bpf_program__unpin(prog, buf);

tools/bpf/bpftool/prog.c

1575

struct bpf_program *prog = NULL, *pos;

tools/bpf/bpftool/prog.c

1852

prog = bpf_object__next_program(obj, NULL);

tools/bpf/bpftool/prog.c

1853

if (!prog) {

tools/bpf/bpftool/prog.c

1859

err = auto_attach_program(prog, pinfile);

tools/bpf/bpftool/prog.c

1861

err = bpf_obj_pin(bpf_program__fd(prog), pinfile);

tools/bpf/bpftool/prog.c

1864

bpf_program__section_name(prog));

tools/bpf/bpftool/prog.c

2444

struct bpf_program *prog;

tools/bpf/bpftool/prog.c

2500

bpf_object__for_each_program(prog, profile_obj->obj) {

tools/bpf/bpftool/prog.c

2501

err = bpf_program__set_attach_target(prog, profile_tgt_fd,

tools/lib/bpf/features.c

279

int ret, map, prog, insn_cnt = ARRAY_SIZE(insns);

tools/lib/bpf/features.c

289

prog = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &prog_opts);

tools/lib/bpf/features.c

290

if (prog < 0) {

tools/lib/bpf/features.c

295

ret = bpf_prog_bind_map(prog, map, NULL);

tools/lib/bpf/features.c

298

close(prog);

tools/lib/bpf/libbpf.c

10199

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

10272

prog = find_prog_by_sec_insn(obj, shdr_idx, insn_idx);

tools/lib/bpf/libbpf.c

10273

if (!prog) {

tools/lib/bpf/libbpf.c

10280

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS) {

tools/lib/bpf/libbpf.c

10282

map->name, prog->name);

tools/lib/bpf/libbpf.c

10286

st_ops->progs[member_idx] = prog;

tools/lib/bpf/libbpf.c

10294

*((struct bpf_program **)(st_ops->data + moff)) = prog;

tools/lib/bpf/libbpf.c

10466

static int libbpf_find_attach_btf_id(struct bpf_program *prog, const char *attach_name,

tools/lib/bpf/libbpf.c

10469

enum bpf_attach_type attach_type = prog->expected_attach_type;

tools/lib/bpf/libbpf.c

10470

__u32 attach_prog_fd = prog->attach_prog_fd;

tools/lib/bpf/libbpf.c

10474

if (prog->type == BPF_PROG_TYPE_EXT || attach_prog_fd) {

tools/lib/bpf/libbpf.c

10476

pr_warn("prog '%s': attach program FD is not set\n", prog->name);

tools/lib/bpf/libbpf.c

10479

err = libbpf_find_prog_btf_id(attach_name, attach_prog_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

10482

prog->name, attach_prog_fd, attach_name, errstr(err));

tools/lib/bpf/libbpf.c

10491

if (prog->obj->gen_loader) {

tools/lib/bpf/libbpf.c

10492

bpf_gen__record_attach_target(prog->obj->gen_loader, attach_name, attach_type);

tools/lib/bpf/libbpf.c

10496

err = find_kernel_btf_id(prog->obj, attach_name,

tools/lib/bpf/libbpf.c

10502

prog->name, attach_name, errstr(err));

tools/lib/bpf/libbpf.c

10834

int bpf_map__set_exclusive_program(struct bpf_map *map, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

10841

if (map->obj != prog->obj) {

tools/lib/bpf/libbpf.c

10846

map->excl_prog = prog;

tools/lib/bpf/libbpf.c

1107

const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

11073

int bpf_link__update_program(struct bpf_link *link, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

11076

int prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

11080

prog->name);

tools/lib/bpf/libbpf.c

1112

if (&obj->programs[i] == prog)

tools/lib/bpf/libbpf.c

1113

return prog->type == BPF_PROG_TYPE_STRUCT_OPS;

tools/lib/bpf/libbpf.c

1126

struct bpf_program *prog, *slot_prog;

tools/lib/bpf/libbpf.c

11260

struct bpf_link *bpf_program__attach_perf_event_opts(const struct bpf_program *prog, int pfd,

tools/lib/bpf/libbpf.c

11272

prog->name, pfd);

tools/lib/bpf/libbpf.c

11275

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

11278

prog->name);

tools/lib/bpf/libbpf.c

11290

if (kernel_supports(prog->obj, FEAT_PERF_LINK) && !force_ioctl_attach) {

tools/lib/bpf/libbpf.c

11298

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11304

pr_warn("prog '%s': user context value is not supported\n", prog->name);

tools/lib/bpf/libbpf.c

11312

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11315

prog->name, pfd);

tools/lib/bpf/libbpf.c

11325

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11338

struct bpf_link *bpf_program__attach_perf_event(const struct bpf_program *prog, int pfd)

tools/lib/bpf/libbpf.c

1134

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

11340

return bpf_program__attach_perf_event_opts(prog, pfd, NULL);

tools/lib/bpf/libbpf.c

1135

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

tools/lib/bpf/libbpf.c

1149

if (prog != slot_prog)

tools/lib/bpf/libbpf.c

1158

prog->autoload = should_load;

tools/lib/bpf/libbpf.c

11655

bpf_program__attach_kprobe_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

11687

if (legacy || !kernel_supports(prog->obj, FEAT_PERF_LINK))

tools/lib/bpf/libbpf.c

11716

prog->name, retprobe ? "kretprobe" : "kprobe",

tools/lib/bpf/libbpf.c

11721

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

11726

prog->name, retprobe ? "kretprobe" : "kprobe",

tools/lib/bpf/libbpf.c

11749

struct bpf_link *bpf_program__attach_kprobe(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

11757

return bpf_program__attach_kprobe_opts(prog, func_name, &opts);

tools/lib/bpf/libbpf.c

11760

struct bpf_link *bpf_program__attach_ksyscall(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

11770

if (kernel_supports(prog->obj, FEAT_SYSCALL_WRAPPER)) {

tools/lib/bpf/libbpf.c

11785

return bpf_program__attach_kprobe_opts(prog, func_name, &kprobe_opts);

tools/lib/bpf/libbpf.c

12000

bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12020

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

12023

prog->name);

tools/lib/bpf/libbpf.c

12054

prog->name, pattern, res.cnt);

tools/lib/bpf/libbpf.c

12088

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

12101

static int attach_kprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

1211

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

12112

if (strcmp(prog->sec_name, "kprobe") == 0 || strcmp(prog->sec_name, "kretprobe") == 0)

tools/lib/bpf/libbpf.c

12115

opts.retprobe = str_has_pfx(prog->sec_name, "kretprobe/");

tools/lib/bpf/libbpf.c

12117

func_name = prog->sec_name + sizeof("kretprobe/") - 1;

tools/lib/bpf/libbpf.c

12119

func_name = prog->sec_name + sizeof("kprobe/") - 1;

tools/lib/bpf/libbpf.c

12133

*link = bpf_program__attach_kprobe_opts(prog, func, &opts);

tools/lib/bpf/libbpf.c

12138

static int attach_ksyscall(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12146

if (strcmp(prog->sec_name, "ksyscall") == 0 || strcmp(prog->sec_name, "kretsyscall") == 0)

tools/lib/bpf/libbpf.c

12149

opts.retprobe = str_has_pfx(prog->sec_name, "kretsyscall/");

tools/lib/bpf/libbpf.c

12151

syscall_name = prog->sec_name + sizeof("kretsyscall/") - 1;

tools/lib/bpf/libbpf.c

12153

syscall_name = prog->sec_name + sizeof("ksyscall/") - 1;

tools/lib/bpf/libbpf.c

12155

*link = bpf_program__attach_ksyscall(prog, syscall_name, &opts);

tools/lib/bpf/libbpf.c

12159

static int attach_kprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12169

if (strcmp(prog->sec_name, "kprobe.multi") == 0 ||

tools/lib/bpf/libbpf.c

12170

strcmp(prog->sec_name, "kretprobe.multi") == 0)

tools/lib/bpf/libbpf.c

12173

opts.retprobe = str_has_pfx(prog->sec_name, "kretprobe.multi/");

tools/lib/bpf/libbpf.c

12175

spec = prog->sec_name + sizeof("kretprobe.multi/") - 1;

tools/lib/bpf/libbpf.c

12177

spec = prog->sec_name + sizeof("kprobe.multi/") - 1;

tools/lib/bpf/libbpf.c

12185

*link = bpf_program__attach_kprobe_multi_opts(prog, pattern, &opts);

tools/lib/bpf/libbpf.c

12190

static int attach_kprobe_session(const struct bpf_program *prog, long cookie,

tools/lib/bpf/libbpf.c

12201

if (strcmp(prog->sec_name, "kprobe.session") == 0)

tools/lib/bpf/libbpf.c

12204

spec = prog->sec_name + sizeof("kprobe.session/") - 1;

tools/lib/bpf/libbpf.c

12211

*link = bpf_program__attach_kprobe_multi_opts(prog, pattern, &opts);

tools/lib/bpf/libbpf.c

12216

static int attach_uprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12224

n = sscanf(prog->sec_name, "%m[^/]/%m[^:]:%m[^\n]",

tools/lib/bpf/libbpf.c

12235

*link = bpf_program__attach_uprobe_multi(prog, -1, binary_path, func_name, &opts);

tools/lib/bpf/libbpf.c

12239

pr_warn("prog '%s': invalid format of section definition '%s'\n", prog->name,

tools/lib/bpf/libbpf.c

12240

prog->sec_name);

tools/lib/bpf/libbpf.c

12458

bpf_program__attach_uprobe_multi(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12479

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

12482

prog->name);

tools/lib/bpf/libbpf.c

12529

prog->name, path, errstr(err));

tools/lib/bpf/libbpf.c

12572

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

12586

bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,

tools/lib/bpf/libbpf.c

12624

prog->name, binary_path, errstr(err));

tools/lib/bpf/libbpf.c

12657

if (legacy || !kernel_supports(prog->obj, FEAT_PERF_LINK))

tools/lib/bpf/libbpf.c

12689

prog->name, retprobe ? "uretprobe" : "uprobe",

tools/lib/bpf/libbpf.c

12695

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

12700

prog->name, retprobe ? "uretprobe" : "uprobe",

tools/lib/bpf/libbpf.c

12732

static int attach_uprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12741

n = sscanf(prog->sec_name, "%m[^/]/%m[^:]:%m[^\n]",

tools/lib/bpf/libbpf.c

12750

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

1276

prog = *(void **)mdata;

tools/lib/bpf/libbpf.c

12768

prog->name);

tools/lib/bpf/libbpf.c

12772

*link = bpf_program__attach_uprobe_opts(prog, -1, binary_path, offset, &opts);

tools/lib/bpf/libbpf.c

12776

pr_warn("prog '%s': invalid format of section definition '%s'\n", prog->name,

tools/lib/bpf/libbpf.c

12777

prog->sec_name);

tools/lib/bpf/libbpf.c

12787

struct bpf_link *bpf_program__attach_uprobe(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12794

return bpf_program__attach_uprobe_opts(prog, pid, binary_path, func_offset, &opts);

tools/lib/bpf/libbpf.c

12797

struct bpf_link *bpf_program__attach_usdt(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12803

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

1281

if (st_ops->progs[i] && st_ops->progs[i] != prog)

tools/lib/bpf/libbpf.c

12811

if (bpf_program__fd(prog) < 0) {

tools/lib/bpf/libbpf.c

12813

prog->name);

tools/lib/bpf/libbpf.c

12824

prog->name, binary_path, errstr(err));

tools/lib/bpf/libbpf.c

12842

link = usdt_manager_attach_usdt(obj->usdt_man, prog, pid, binary_path,

tools/lib/bpf/libbpf.c

1285

st_ops->progs[i] = prog;

tools/lib/bpf/libbpf.c

12850

static int attach_usdt(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12856

sec_name = bpf_program__section_name(prog);

tools/lib/bpf/libbpf.c

1286

if (!prog)

tools/lib/bpf/libbpf.c

12869

*link = bpf_program__attach_usdt(prog, -1 /* any process */, path,

tools/lib/bpf/libbpf.c

1289

if (!is_valid_st_ops_program(obj, prog)) {

tools/lib/bpf/libbpf.c

12929

struct bpf_link *bpf_program__attach_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12946

prog->name, tp_category, tp_name,

tools/lib/bpf/libbpf.c

12950

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

12955

prog->name, tp_category, tp_name,

tools/lib/bpf/libbpf.c

12962

struct bpf_link *bpf_program__attach_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12966

return bpf_program__attach_tracepoint_opts(prog, tp_category, tp_name, NULL);

tools/lib/bpf/libbpf.c

12969

static int attach_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12976

if (strcmp(prog->sec_name, "tp") == 0 || strcmp(prog->sec_name, "tracepoint") == 0)

tools/lib/bpf/libbpf.c

12979

sec_name = strdup(prog->sec_name);

tools/lib/bpf/libbpf.c

12984

if (str_has_pfx(prog->sec_name, "tp/"))

tools/lib/bpf/libbpf.c

12996

*link = bpf_program__attach_tracepoint(prog, tp_cat, tp_name);

tools/lib/bpf/libbpf.c

13002

bpf_program__attach_raw_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13013

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13015

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13031

prog->name, tp_name, errstr(pfd));

tools/lib/bpf/libbpf.c

13038

struct bpf_link *bpf_program__attach_raw_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13041

return bpf_program__attach_raw_tracepoint_opts(prog, tp_name, NULL);

tools/lib/bpf/libbpf.c

13044

static int attach_raw_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13060

if (!str_has_pfx(prog->sec_name, prefixes[i]))

tools/lib/bpf/libbpf.c

13065

if (prog->sec_name[pfx_len] == '\0')

tools/lib/bpf/libbpf.c

13068

if (prog->sec_name[pfx_len] != '/')

tools/lib/bpf/libbpf.c

13071

tp_name = prog->sec_name + pfx_len + 1;

tools/lib/bpf/libbpf.c

13077

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

13081

*link = bpf_program__attach_raw_tracepoint(prog, tp_name);

tools/lib/bpf/libbpf.c

13086

static struct bpf_link *bpf_program__attach_btf_id(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13096

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13098

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

1310

prog->attach_btf_obj_fd = mod_btf->fd;

tools/lib/bpf/libbpf.c

13109

pfd = bpf_link_create(prog_fd, 0, bpf_program__expected_attach_type(prog), &link_opts);

tools/lib/bpf/libbpf.c

13114

prog->name, errstr(pfd));

tools/lib/bpf/libbpf.c

13121

struct bpf_link *bpf_program__attach_trace(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

13123

return bpf_program__attach_btf_id(prog, NULL);

tools/lib/bpf/libbpf.c

13126

struct bpf_link *bpf_program__attach_trace_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13129

return bpf_program__attach_btf_id(prog, opts);

tools/lib/bpf/libbpf.c

13132

struct bpf_link *bpf_program__attach_lsm(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

13134

return bpf_program__attach_btf_id(prog, NULL);

tools/lib/bpf/libbpf.c

13137

static int attach_trace(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13139

*link = bpf_program__attach_trace(prog);

tools/lib/bpf/libbpf.c

13143

static int attach_lsm(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13145

*link = bpf_program__attach_lsm(prog);

tools/lib/bpf/libbpf.c

1315

if (!prog->attach_btf_id) {

tools/lib/bpf/libbpf.c

13150

bpf_program_attach_fd(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13158

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

1316

prog->attach_btf_id = kern_type_id;

tools/lib/bpf/libbpf.c

13160

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13169

attach_type = bpf_program__expected_attach_type(prog);

tools/lib/bpf/libbpf.c

1317

prog->expected_attach_type = kern_member_idx;

tools/lib/bpf/libbpf.c

13175

prog->name, target_name,

tools/lib/bpf/libbpf.c

13184

bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd)

tools/lib/bpf/libbpf.c

13186

return bpf_program_attach_fd(prog, cgroup_fd, "cgroup", NULL);

tools/lib/bpf/libbpf.c

13190

bpf_program__attach_netns(const struct bpf_program *prog, int netns_fd)

tools/lib/bpf/libbpf.c

13192

return bpf_program_attach_fd(prog, netns_fd, "netns", NULL);

tools/lib/bpf/libbpf.c

13196

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd)

tools/lib/bpf/libbpf.c

13198

return bpf_program_attach_fd(prog, map_fd, "sockmap", NULL);

tools/lib/bpf/libbpf.c

13201

struct bpf_link *bpf_program__attach_xdp(const struct bpf_program *prog, int ifindex)

tools/lib/bpf/libbpf.c

13204

return bpf_program_attach_fd(prog, ifindex, "xdp", NULL);

tools/lib/bpf/libbpf.c

13208

bpf_program__attach_cgroup_opts(const struct bpf_program *prog, int cgroup_fd,

tools/lib/bpf/libbpf.c

13223

prog->name);

tools/lib/bpf/libbpf.c

13232

return bpf_program_attach_fd(prog, cgroup_fd, "cgroup", &link_create_opts);

tools/lib/bpf/libbpf.c

13236

bpf_program__attach_tcx(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.c

1325

if (prog->attach_btf_id != kern_type_id) {

tools/lib/bpf/libbpf.c

13252

prog->name);

tools/lib/bpf/libbpf.c

13257

prog->name);

tools/lib/bpf/libbpf.c

13267

return bpf_program_attach_fd(prog, ifindex, "tcx", &link_create_opts);

tools/lib/bpf/libbpf.c

1327

map->name, mname, prog->name, prog->sec_name, prog->type,

tools/lib/bpf/libbpf.c

13271

bpf_program__attach_netkit(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.c

1328

prog->attach_btf_id, kern_type_id);

tools/lib/bpf/libbpf.c

13287

prog->name);

tools/lib/bpf/libbpf.c

13292

prog->name);

tools/lib/bpf/libbpf.c

13301

return bpf_program_attach_fd(prog, ifindex, "netkit", &link_create_opts);

tools/lib/bpf/libbpf.c

13304

struct bpf_link *bpf_program__attach_freplace(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

1331

if (prog->expected_attach_type != kern_member_idx) {

tools/lib/bpf/libbpf.c

13312

prog->name);

tools/lib/bpf/libbpf.c

13316

if (prog->type != BPF_PROG_TYPE_EXT) {

tools/lib/bpf/libbpf.c

13318

prog->name);

tools/lib/bpf/libbpf.c

13325

btf_id = libbpf_find_prog_btf_id(attach_func_name, target_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

1333

map->name, mname, prog->name, prog->sec_name, prog->type,

tools/lib/bpf/libbpf.c

13331

return bpf_program_attach_fd(prog, target_fd, "freplace",

tools/lib/bpf/libbpf.c

13337

return bpf_program__attach_trace(prog);

tools/lib/bpf/libbpf.c

1334

prog->expected_attach_type, kern_member_idx);

tools/lib/bpf/libbpf.c

13342

bpf_program__attach_iter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13356

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13358

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13373

prog->name, errstr(link_fd));

tools/lib/bpf/libbpf.c

13380

static int attach_iter(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13382

*link = bpf_program__attach_iter(prog, NULL);

tools/lib/bpf/libbpf.c

13386

struct bpf_link *bpf_program__attach_netfilter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13396

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13398

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

1341

map->name, mname, prog->name, moff,

tools/lib/bpf/libbpf.c

13418

prog->name, errstr(link_fd));

tools/lib/bpf/libbpf.c

13426

struct bpf_link *bpf_program__attach(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

13431

if (!prog->sec_def || !prog->sec_def->prog_attach_fn)

tools/lib/bpf/libbpf.c

13434

if (bpf_program__fd(prog) < 0) {

tools/lib/bpf/libbpf.c

13436

prog->name);

tools/lib/bpf/libbpf.c

13440

err = prog->sec_def->prog_attach_fn(prog, prog->sec_def->cookie, &link);

tools/lib/bpf/libbpf.c

14123

int bpf_program__set_attach_target(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

14129

if (!prog || attach_prog_fd < 0)

tools/lib/bpf/libbpf.c

14132

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

14139

prog->attach_prog_fd = attach_prog_fd;

tools/lib/bpf/libbpf.c

14145

attach_prog_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

14153

err = bpf_object__load_vmlinux_btf(prog->obj, true);

tools/lib/bpf/libbpf.c

14156

err = find_kernel_btf_id(prog->obj, attach_func_name,

tools/lib/bpf/libbpf.c

14157

prog->expected_attach_type,

tools/lib/bpf/libbpf.c

14163

prog->attach_btf_id = btf_id;

tools/lib/bpf/libbpf.c

14164

prog->attach_btf_obj_fd = btf_obj_fd;

tools/lib/bpf/libbpf.c

14165

prog->attach_prog_fd = attach_prog_fd;

tools/lib/bpf/libbpf.c

14169

int bpf_program__assoc_struct_ops(struct bpf_program *prog, struct bpf_map *map,

tools/lib/bpf/libbpf.c

14174

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

14177

prog->name);

tools/lib/bpf/libbpf.c

14181

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS) {

tools/lib/bpf/libbpf.c

14182

pr_warn("prog '%s': can't associate struct_ops program\n", prog->name);

tools/lib/bpf/libbpf.c

14336

struct bpf_program **prog = prog_skel->prog;

tools/lib/bpf/libbpf.c

14339

*prog = bpf_object__find_program_by_name(obj, name);

tools/lib/bpf/libbpf.c

14340

if (!*prog) {

tools/lib/bpf/libbpf.c

14480

struct bpf_program *prog = *prog_skel->prog;

tools/lib/bpf/libbpf.c

14483

if (!prog->autoload || !prog->autoattach)

tools/lib/bpf/libbpf.c

14487

if (!prog->sec_def || !prog->sec_def->prog_attach_fn)

tools/lib/bpf/libbpf.c

14494

err = prog->sec_def->prog_attach_fn(prog, prog->sec_def->cookie, link);

tools/lib/bpf/libbpf.c

14497

bpf_program__name(prog), errstr(err));

tools/lib/bpf/libbpf.c

3474

static bool prog_needs_vmlinux_btf(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

3476

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS ||

tools/lib/bpf/libbpf.c

3477

prog->type == BPF_PROG_TYPE_LSM)

tools/lib/bpf/libbpf.c

3483

if (prog->type == BPF_PROG_TYPE_TRACING && !prog->attach_prog_fd)

tools/lib/bpf/libbpf.c

3496

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

3515

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

3516

if (!prog->autoload)

tools/lib/bpf/libbpf.c

3518

if (prog_needs_vmlinux_btf(prog))

tools/lib/bpf/libbpf.c

3578

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

tools/lib/bpf/libbpf.c

3583

if (!prog->mark_btf_static || !prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

3593

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

tools/lib/bpf/libbpf.c

4469

static bool prog_is_subprog(const struct bpf_object *obj, const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

4471

return prog->sec_idx == obj->efile.text_shndx;

tools/lib/bpf/libbpf.c

4478

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4480

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

4481

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

4483

if (!strcmp(prog->name, name))

tools/lib/bpf/libbpf.c

4484

return prog;

tools/lib/bpf/libbpf.c

4526

static int bpf_prog_compute_hash(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

4531

purged = calloc(prog->insns_cnt, BPF_INSN_SZ);

tools/lib/bpf/libbpf.c

4538

for (i = 0; i < prog->insns_cnt; i++) {

tools/lib/bpf/libbpf.c

4539

purged[i] = prog->insns[i];

tools/lib/bpf/libbpf.c

4545

if (i >= prog->insns_cnt ||

tools/lib/bpf/libbpf.c

4546

prog->insns[i].code != 0 ||

tools/lib/bpf/libbpf.c

4547

prog->insns[i].dst_reg != 0 ||

tools/lib/bpf/libbpf.c

4548

prog->insns[i].src_reg != 0 ||

tools/lib/bpf/libbpf.c

4549

prog->insns[i].off != 0) {

tools/lib/bpf/libbpf.c

4553

purged[i] = prog->insns[i];

tools/lib/bpf/libbpf.c

4557

libbpf_sha256(purged, prog->insns_cnt * sizeof(struct bpf_insn),

tools/lib/bpf/libbpf.c

4558

prog->hash);

tools/lib/bpf/libbpf.c

4564

static int bpf_program__record_reloc(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

4569

struct bpf_insn *insn = &prog->insns[insn_idx];

tools/lib/bpf/libbpf.c

4570

size_t map_idx, nr_maps = prog->obj->nr_maps;

tools/lib/bpf/libbpf.c

4571

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

4579

prog->name, sym_name, insn_idx, insn->code);

tools/lib/bpf/libbpf.c

4595

prog->name, sym_name, sym_idx);

tools/lib/bpf/libbpf.c

4599

prog->name, i, ext->name, ext->sym_idx, insn_idx);

tools/lib/bpf/libbpf.c

4612

pr_warn("prog '%s': incorrect bpf_call opcode\n", prog->name);

tools/lib/bpf/libbpf.c

4619

prog->name, sym_name, sym_sec_name);

tools/lib/bpf/libbpf.c

4624

prog->name, sym_name, (size_t)sym->st_value);

tools/lib/bpf/libbpf.c

4635

prog->name, sym_name, shdr_idx);

tools/lib/bpf/libbpf.c

4646

prog->name, sym_name, (size_t)sym->st_value, insn->imm);

tools/lib/bpf/libbpf.c

4663

prog->name, insn_idx);

tools/lib/bpf/libbpf.c

4673

prog->name, obj->arena_map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4692

prog->name, sym_name, sym_sec_name);

tools/lib/bpf/libbpf.c

4702

prog->name, map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4708

prog->name, sym_sec_name, (size_t)sym->st_value);

tools/lib/bpf/libbpf.c

4721

prog->name, sym_sec_name);

tools/lib/bpf/libbpf.c

4729

prog->name, map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4735

prog->name, sym_sec_name);

tools/lib/bpf/libbpf.c

4746

static bool prog_contains_insn(const struct bpf_program *prog, size_t insn_idx)

tools/lib/bpf/libbpf.c

4748

return insn_idx >= prog->sec_insn_off &&

tools/lib/bpf/libbpf.c

4749

insn_idx < prog->sec_insn_off + prog->sec_insn_cnt;

tools/lib/bpf/libbpf.c

4756

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4763

prog = &obj->programs[m];

tools/lib/bpf/libbpf.c

4765

if (prog->sec_idx < sec_idx ||

tools/lib/bpf/libbpf.c

4766

(prog->sec_idx == sec_idx && prog->sec_insn_off <= insn_idx))

tools/lib/bpf/libbpf.c

4774

prog = &obj->programs[l];

tools/lib/bpf/libbpf.c

4775

if (prog->sec_idx == sec_idx && prog_contains_insn(prog, insn_idx))

tools/lib/bpf/libbpf.c

4776

return prog;

tools/lib/bpf/libbpf.c

4785

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4855

prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);

tools/lib/bpf/libbpf.c

4856

if (!prog) {

tools/lib/bpf/libbpf.c

4862

relos = libbpf_reallocarray(prog->reloc_desc,

tools/lib/bpf/libbpf.c

4863

prog->nr_reloc + 1, sizeof(*relos));

tools/lib/bpf/libbpf.c

4866

prog->reloc_desc = relos;

tools/lib/bpf/libbpf.c

4869

insn_idx -= prog->sec_insn_off;

tools/lib/bpf/libbpf.c

4870

err = bpf_program__record_reloc(prog, &relos[prog->nr_reloc],

tools/lib/bpf/libbpf.c

4875

prog->nr_reloc++;

tools/lib/bpf/libbpf.c

5949

static int record_relo_core(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

5954

relos = libbpf_reallocarray(prog->reloc_desc,

tools/lib/bpf/libbpf.c

5955

prog->nr_reloc + 1, sizeof(*relos));

tools/lib/bpf/libbpf.c

5958

relo = &relos[prog->nr_reloc];

tools/lib/bpf/libbpf.c

5962

prog->reloc_desc = relos;

tools/lib/bpf/libbpf.c

5963

prog->nr_reloc++;

tools/lib/bpf/libbpf.c

5967

static const struct bpf_core_relo *find_relo_core(struct bpf_program *prog, int insn_idx)

tools/lib/bpf/libbpf.c

5972

for (i = 0; i < prog->nr_reloc; i++) {

tools/lib/bpf/libbpf.c

5973

relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

5983

static int bpf_core_resolve_relo(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

5992

const char *prog_name = prog->name;

tools/lib/bpf/libbpf.c

6008

cands = bpf_core_find_cands(prog->obj, local_btf, local_id);

tools/lib/bpf/libbpf.c

6035

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

6076

prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);

tools/lib/bpf/libbpf.c

6077

if (!prog) {

tools/lib/bpf/libbpf.c

6093

if (!prog->autoload)

tools/lib/bpf/libbpf.c

6100

insn_idx = insn_idx - prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6101

if (insn_idx >= prog->insns_cnt)

tools/lib/bpf/libbpf.c

6103

insn = &prog->insns[insn_idx];

tools/lib/bpf/libbpf.c

6105

err = record_relo_core(prog, rec, insn_idx);

tools/lib/bpf/libbpf.c

6108

prog->name, i, errstr(err));

tools/lib/bpf/libbpf.c

6112

if (prog->obj->gen_loader)

tools/lib/bpf/libbpf.c

6115

err = bpf_core_resolve_relo(prog, rec, i, obj->btf, cand_cache, &targ_res);

tools/lib/bpf/libbpf.c

6118

prog->name, i, errstr(err));

tools/lib/bpf/libbpf.c

6122

err = bpf_core_patch_insn(prog->name, insn, insn_idx, rec, i, &targ_res);

tools/lib/bpf/libbpf.c

6125

prog->name, i, insn_idx, errstr(err));

tools/lib/bpf/libbpf.c

6149

static void poison_map_ldimm64(struct bpf_program *prog, int relo_idx,

tools/lib/bpf/libbpf.c

6156

prog->name, relo_idx, insn_idx, map_idx, map->name);

tools/lib/bpf/libbpf.c

6179

static void poison_kfunc_call(struct bpf_program *prog, int relo_idx,

tools/lib/bpf/libbpf.c

6184

prog->name, relo_idx, insn_idx, ext->name);

tools/lib/bpf/libbpf.c

6199

static int find_jt_map(struct bpf_object *obj, struct bpf_program *prog, unsigned int sym_off)

tools/lib/bpf/libbpf.c

6210

obj->jumptable_maps[i].prog == prog)

tools/lib/bpf/libbpf.c

6217

static int add_jt_map(struct bpf_object *obj, struct bpf_program *prog, unsigned int sym_off, int map_fd)

tools/lib/bpf/libbpf.c

6228

obj->jumptable_maps[cnt].prog = prog;

tools/lib/bpf/libbpf.c

6236

static int find_subprog_idx(struct bpf_program *prog, int insn_idx)

tools/lib/bpf/libbpf.c

6240

for (i = prog->subprog_cnt - 1; i >= 0; i--) {

tools/lib/bpf/libbpf.c

6241

if (insn_idx >= prog->subprogs[i].sub_insn_off)

tools/lib/bpf/libbpf.c

6248

static int create_jt_map(struct bpf_object *obj, struct bpf_program *prog, struct reloc_desc *relo)

tools/lib/bpf/libbpf.c

6262

map_fd = find_jt_map(obj, prog, sym_off);

tools/lib/bpf/libbpf.c

6296

if (relo->insn_idx < 0 || relo->insn_idx >= prog->insns_cnt) {

tools/lib/bpf/libbpf.c

6301

if (prog->subprogs)

tools/lib/bpf/libbpf.c

6302

subprog_idx = find_subprog_idx(prog, relo->insn_idx);

tools/lib/bpf/libbpf.c

6312

insn_off -= prog->subprogs[subprog_idx].sec_insn_off;

tools/lib/bpf/libbpf.c

6313

insn_off += prog->subprogs[subprog_idx].sub_insn_off;

tools/lib/bpf/libbpf.c

6315

insn_off -= prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6339

err = add_jt_map(obj, prog, sym_off, map_fd);

tools/lib/bpf/libbpf.c

6356

bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6360

for (i = 0; i < prog->nr_reloc; i++) {

tools/lib/bpf/libbpf.c

6361

struct reloc_desc *relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

6362

struct bpf_insn *insn = &prog->insns[relo->insn_idx];

tools/lib/bpf/libbpf.c

6376

poison_map_ldimm64(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6394

poison_map_ldimm64(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6427

poison_kfunc_call(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6434

prog->name, i);

tools/lib/bpf/libbpf.c

6448

map_fd = create_jt_map(obj, prog, relo);

tools/lib/bpf/libbpf.c

6451

prog->name, i, relo->sym_off);

tools/lib/bpf/libbpf.c

6461

prog->name, i, relo->type);

tools/lib/bpf/libbpf.c

6470

const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

6485

if (prog->sec_idx != sec_idx)

tools/lib/bpf/libbpf.c

6491

if (insn_off < prog->sec_insn_off)

tools/lib/bpf/libbpf.c

6493

if (insn_off >= prog->sec_insn_off + prog->sec_insn_cnt)

tools/lib/bpf/libbpf.c

6522

off_adj = prog->sub_insn_off - prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6540

const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6553

if (main_prog != prog && !main_prog->func_info)

tools/lib/bpf/libbpf.c

6556

err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->func_info,

tools/lib/bpf/libbpf.c

6563

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

6571

pr_warn("prog '%s': missing .BTF.ext function info.\n", prog->name);

tools/lib/bpf/libbpf.c

6576

prog->name);

tools/lib/bpf/libbpf.c

6581

if (main_prog != prog && !main_prog->line_info)

tools/lib/bpf/libbpf.c

6584

err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->line_info,

tools/lib/bpf/libbpf.c

6591

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

6599

pr_warn("prog '%s': missing .BTF.ext line info.\n", prog->name);

tools/lib/bpf/libbpf.c

6604

prog->name);

tools/lib/bpf/libbpf.c

6619

static struct reloc_desc *find_prog_insn_relo(const struct bpf_program *prog, size_t insn_idx)

tools/lib/bpf/libbpf.c

6621

if (!prog->nr_reloc)

tools/lib/bpf/libbpf.c

6623

return bsearch(&insn_idx, prog->reloc_desc, prog->nr_reloc,

tools/lib/bpf/libbpf.c

6624

sizeof(*prog->reloc_desc), cmp_relo_by_insn_idx);

tools/lib/bpf/libbpf.c

6716

struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6724

err = reloc_prog_func_and_line_info(obj, main_prog, prog);

tools/lib/bpf/libbpf.c

6728

for (insn_idx = 0; insn_idx < prog->sec_insn_cnt; insn_idx++) {

tools/lib/bpf/libbpf.c

6729

insn = &main_prog->insns[prog->sub_insn_off + insn_idx];

tools/lib/bpf/libbpf.c

6733

relo = find_prog_insn_relo(prog, insn_idx);

tools/lib/bpf/libbpf.c

6741

prog->name, insn_idx, relo->type);

tools/lib/bpf/libbpf.c

6765

prog->name, insn_idx);

tools/lib/bpf/libbpf.c

6774

sub_insn_idx = prog->sec_insn_off + insn_idx + insn->imm + 1;

tools/lib/bpf/libbpf.c

6781

prog->name);

tools/lib/bpf/libbpf.c

6807

insn = &main_prog->insns[prog->sub_insn_off + insn_idx];

tools/lib/bpf/libbpf.c

6814

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

tools/lib/bpf/libbpf.c

6817

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

tools/lib/bpf/libbpf.c

6905

bpf_object__relocate_calls(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6921

err = bpf_object__reloc_code(obj, prog, prog);

tools/lib/bpf/libbpf.c

6931

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

6936

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

6937

zfree(&prog->reloc_desc);

tools/lib/bpf/libbpf.c

6938

prog->nr_reloc = 0;

tools/lib/bpf/libbpf.c

6971

static int bpf_prog_assign_exc_cb(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6996

prog->name);

tools/lib/bpf/libbpf.c

6999

if (strcmp(prog->name, btf__str_by_offset(obj->btf, t->name_off)) != 0)

tools/lib/bpf/libbpf.c

7005

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7006

prog->exception_cb_idx = -1;

tools/lib/bpf/libbpf.c

7013

prog->name);

tools/lib/bpf/libbpf.c

7030

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7034

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7036

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7039

prog->exception_cb_idx = j;

tools/lib/bpf/libbpf.c

7043

if (prog->exception_cb_idx >= 0)

tools/lib/bpf/libbpf.c

7046

pr_warn("prog '%s': cannot find exception callback '%s'\n", prog->name, name);

tools/lib/bpf/libbpf.c

7093

static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7112

(prog->type == BPF_PROG_TYPE_KPROBE || prog->type == BPF_PROG_TYPE_PERF_EVENT)) {

tools/lib/bpf/libbpf.c

7131

switch (prog->type) {

tools/lib/bpf/libbpf.c

7160

prog->name, subprog_name, arg_idx, ctx_name);

tools/lib/bpf/libbpf.c

7164

static int clone_func_btf_info(struct btf *btf, int orig_fn_id, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7216

fn_id = btf__add_func(btf, prog->name, linkage, fn_proto_id);

tools/lib/bpf/libbpf.c

7233

static int bpf_program_fixup_func_info(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7246

if (!obj->btf_ext || !prog->func_info)

tools/lib/bpf/libbpf.c

7257

if (global_ctx_map[i].prog_type != prog->type)

tools/lib/bpf/libbpf.c

7266

orig_ids = calloc(prog->func_info_cnt, sizeof(*orig_ids));

tools/lib/bpf/libbpf.c

7269

for (i = 0; i < prog->func_info_cnt; i++) {

tools/lib/bpf/libbpf.c

7270

func_rec = prog->func_info + prog->func_info_rec_size * i;

tools/lib/bpf/libbpf.c

7299

for (rec_idx = 0; rec_idx < prog->func_info_cnt; rec_idx++) {

tools/lib/bpf/libbpf.c

7301

func_rec = prog->func_info + prog->func_info_rec_size * rec_idx;

tools/lib/bpf/libbpf.c

7318

if (!need_func_arg_type_fixup(btf, prog, fn_name, arg_idx, p->type, ctx_name))

tools/lib/bpf/libbpf.c

7325

fn_id = clone_func_btf_info(btf, orig_fn_id, prog);

tools/lib/bpf/libbpf.c

7374

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

7404

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7405

for (j = 0; j < prog->nr_reloc; j++) {

tools/lib/bpf/libbpf.c

7406

struct reloc_desc *relo = &prog->reloc_desc[j];

tools/lib/bpf/libbpf.c

7407

struct bpf_insn *insn = &prog->insns[relo->insn_idx];

tools/lib/bpf/libbpf.c

7423

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7427

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

7429

if (!prog->autoload)

tools/lib/bpf/libbpf.c

7432

err = bpf_object__relocate_calls(obj, prog);

tools/lib/bpf/libbpf.c

7435

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7439

err = bpf_prog_assign_exc_cb(obj, prog);

tools/lib/bpf/libbpf.c

7443

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7444

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

tools/lib/bpf/libbpf.c

7452

err = bpf_object__append_subprog_code(obj, prog, subprog);

tools/lib/bpf/libbpf.c

7455

err = bpf_object__reloc_code(obj, prog, subprog);

tools/lib/bpf/libbpf.c

7462

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7463

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

7465

if (!prog->autoload)

tools/lib/bpf/libbpf.c

7469

err = bpf_object__relocate_data(obj, prog);

tools/lib/bpf/libbpf.c

7472

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7477

err = bpf_program_fixup_func_info(obj, prog);

tools/lib/bpf/libbpf.c

7480

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

76

static bool prog_is_subprog(const struct bpf_object *obj, const struct bpf_program *prog);

tools/lib/bpf/libbpf.c

767

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

7677

static int bpf_object__sanitize_prog(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7679

struct bpf_insn *insn = prog->insns;

tools/lib/bpf/libbpf.c

7686

for (i = 0; i < prog->insns_cnt; i++, insn++) {

tools/lib/bpf/libbpf.c

7712

static int libbpf_find_attach_btf_id(struct bpf_program *prog, const char *attach_name,

tools/lib/bpf/libbpf.c

7716

static int libbpf_prepare_prog_load(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7722

if ((def & SEC_EXP_ATTACH_OPT) && !kernel_supports(prog->obj, FEAT_EXP_ATTACH_TYPE))

tools/lib/bpf/libbpf.c

7728

if (prog->type == BPF_PROG_TYPE_XDP && (def & SEC_XDP_FRAGS))

tools/lib/bpf/libbpf.c

7732

if ((def & SEC_USDT) && kernel_supports(prog->obj, FEAT_UPROBE_MULTI_LINK)) {

tools/lib/bpf/libbpf.c

7737

prog->expected_attach_type = BPF_TRACE_UPROBE_MULTI;

tools/lib/bpf/libbpf.c

7741

if ((def & SEC_ATTACH_BTF) && !prog->attach_btf_id) {

tools/lib/bpf/libbpf.c

7745

attach_name = strchr(prog->sec_name, '/');

tools/lib/bpf/libbpf.c

7757

prog->name);

tools/lib/bpf/libbpf.c

7762

err = libbpf_find_attach_btf_id(prog, attach_name, &btf_obj_fd, &btf_type_id);

tools/lib/bpf/libbpf.c

7767

prog->attach_btf_obj_fd = btf_obj_fd;

tools/lib/bpf/libbpf.c

7768

prog->attach_btf_id = btf_type_id;

tools/lib/bpf/libbpf.c

7781

static void fixup_verifier_log(struct bpf_program *prog, char *buf, size_t buf_sz);

tools/lib/bpf/libbpf.c

7783

static int bpf_object_load_prog(struct bpf_object *obj, struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7792

__u32 log_level = prog->log_level;

tools/lib/bpf/libbpf.c

7798

switch (prog->type) {

tools/lib/bpf/libbpf.c

7805

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

7808

if (prog->attach_btf_id == 0) {

tools/lib/bpf/libbpf.c

7810

prog->name);

tools/lib/bpf/libbpf.c

7822

prog_name = prog->name;

tools/lib/bpf/libbpf.c

7823

load_attr.attach_prog_fd = prog->attach_prog_fd;

tools/lib/bpf/libbpf.c

7824

load_attr.attach_btf_obj_fd = prog->attach_btf_obj_fd;

tools/lib/bpf/libbpf.c

7825

load_attr.attach_btf_id = prog->attach_btf_id;

tools/lib/bpf/libbpf.c

7827

load_attr.prog_ifindex = prog->prog_ifindex;

tools/lib/bpf/libbpf.c

7828

load_attr.expected_attach_type = prog->expected_attach_type;

tools/lib/bpf/libbpf.c

7833

load_attr.func_info = prog->func_info;

tools/lib/bpf/libbpf.c

7834

load_attr.func_info_rec_size = prog->func_info_rec_size;

tools/lib/bpf/libbpf.c

7835

load_attr.func_info_cnt = prog->func_info_cnt;

tools/lib/bpf/libbpf.c

7836

load_attr.line_info = prog->line_info;

tools/lib/bpf/libbpf.c

7837

load_attr.line_info_rec_size = prog->line_info_rec_size;

tools/lib/bpf/libbpf.c

7838

load_attr.line_info_cnt = prog->line_info_cnt;

tools/lib/bpf/libbpf.c

7841

load_attr.prog_flags = prog->prog_flags;

tools/lib/bpf/libbpf.c

7849

if (prog->sec_def && prog->sec_def->prog_prepare_load_fn) {

tools/lib/bpf/libbpf.c

7850

err = prog->sec_def->prog_prepare_load_fn(prog, &load_attr, prog->sec_def->cookie);

tools/lib/bpf/libbpf.c

7853

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7856

insns = prog->insns;

tools/lib/bpf/libbpf.c

7857

insns_cnt = prog->insns_cnt;

tools/lib/bpf/libbpf.c

7861

bpf_gen__prog_load(obj->gen_loader, prog->type, prog->name,

tools/lib/bpf/libbpf.c

7863

prog - obj->programs);

tools/lib/bpf/libbpf.c

7875

if (prog->log_buf) {

tools/lib/bpf/libbpf.c

7876

log_buf = prog->log_buf;

tools/lib/bpf/libbpf.c

7877

log_buf_size = prog->log_size;

tools/lib/bpf/libbpf.c

790

void bpf_program__unload(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7900

ret = bpf_prog_load(prog->type, prog_name, license, insns, insns_cnt, &load_attr);

tools/lib/bpf/libbpf.c

7904

prog->name, log_buf);

tools/lib/bpf/libbpf.c

7912

map = &prog->obj->maps[i];

tools/lib/bpf/libbpf.c

7918

prog->name, map->real_name, errstr(errno));

tools/lib/bpf/libbpf.c

792

if (!prog)

tools/lib/bpf/libbpf.c

7946

fixup_verifier_log(prog, log_buf, log_buf_size);

tools/lib/bpf/libbpf.c

7948

pr_warn("prog '%s': BPF program load failed: %s\n", prog->name, errstr(errno));

tools/lib/bpf/libbpf.c

795

zclose(prog->fd);

tools/lib/bpf/libbpf.c

7953

prog->name, log_buf);

tools/lib/bpf/libbpf.c

797

zfree(&prog->func_info);

tools/lib/bpf/libbpf.c

798

zfree(&prog->line_info);

tools/lib/bpf/libbpf.c

799

zfree(&prog->subprogs);

tools/lib/bpf/libbpf.c

8013

static void fixup_log_failed_core_relo(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

802

static void bpf_program__exit(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

8035

relo = find_relo_core(prog, insn_idx);

tools/lib/bpf/libbpf.c

8039

err = bpf_core_parse_spec(prog->name, prog->obj->btf, relo, &spec);

tools/lib/bpf/libbpf.c

804

if (!prog)

tools/lib/bpf/libbpf.c

8052

static void fixup_log_missing_map_load(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

8064

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

807

bpf_program__unload(prog);

tools/lib/bpf/libbpf.c

808

zfree(&prog->name);

tools/lib/bpf/libbpf.c

8085

static void fixup_log_missing_kfunc_call(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

809

zfree(&prog->sec_name);

tools/lib/bpf/libbpf.c

8097

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

810

zfree(&prog->insns);

tools/lib/bpf/libbpf.c

811

zfree(&prog->reloc_desc);

tools/lib/bpf/libbpf.c

8118

static void fixup_verifier_log(struct bpf_program *prog, char *buf, size_t buf_sz)

tools/lib/bpf/libbpf.c

813

prog->nr_reloc = 0;

tools/lib/bpf/libbpf.c

814

prog->insns_cnt = 0;

tools/lib/bpf/libbpf.c

8143

fixup_log_failed_core_relo(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

815

prog->sec_idx = -1;

tools/lib/bpf/libbpf.c

8152

fixup_log_missing_map_load(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

8161

fixup_log_missing_kfunc_call(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

8168

static int bpf_program_record_relos(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

8170

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

8173

for (i = 0; i < prog->nr_reloc; i++) {

tools/lib/bpf/libbpf.c

8174

struct reloc_desc *relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

8214

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8219

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

8220

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

8222

if (!prog->autoload) {

tools/lib/bpf/libbpf.c

8223

pr_debug("prog '%s': skipped loading\n", prog->name);

tools/lib/bpf/libbpf.c

8226

prog->log_level |= log_level;

tools/lib/bpf/libbpf.c

8229

bpf_program_record_relos(prog);

tools/lib/bpf/libbpf.c

8231

err = bpf_object_load_prog(obj, prog, prog->insns, prog->insns_cnt,

tools/lib/bpf/libbpf.c

8232

obj->license, obj->kern_version, &prog->fd);

tools/lib/bpf/libbpf.c

8234

pr_warn("prog '%s': failed to load: %s\n", prog->name, errstr(err));

tools/lib/bpf/libbpf.c

8245

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8250

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

8251

err = bpf_object__sanitize_prog(obj, prog);

tools/lib/bpf/libbpf.c

8262

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8265

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

8266

prog->sec_def = find_sec_def(prog->sec_name);

tools/lib/bpf/libbpf.c

8267

if (!prog->sec_def) {

tools/lib/bpf/libbpf.c

8270

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

8274

prog->type = prog->sec_def->prog_type;

tools/lib/bpf/libbpf.c

8275

prog->expected_attach_type = prog->sec_def->expected_attach_type;

tools/lib/bpf/libbpf.c

8280

if (prog->sec_def->prog_setup_fn) {

tools/lib/bpf/libbpf.c

8281

err = prog->sec_def->prog_setup_fn(prog, prog->sec_def->cookie);

tools/lib/bpf/libbpf.c

8284

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

839

bpf_object__init_prog(struct bpf_object *obj, struct bpf_program *prog,

tools/lib/bpf/libbpf.c

849

memset(prog, 0, sizeof(*prog));

tools/lib/bpf/libbpf.c

850

prog->obj = obj;

tools/lib/bpf/libbpf.c

852

prog->sec_idx = sec_idx;

tools/lib/bpf/libbpf.c

853

prog->sec_insn_off = sec_off / BPF_INSN_SZ;

tools/lib/bpf/libbpf.c

854

prog->sec_insn_cnt = insn_data_sz / BPF_INSN_SZ;

tools/lib/bpf/libbpf.c

856

prog->insns_cnt = prog->sec_insn_cnt;

tools/lib/bpf/libbpf.c

858

prog->type = BPF_PROG_TYPE_UNSPEC;

tools/lib/bpf/libbpf.c

859

prog->fd = -1;

tools/lib/bpf/libbpf.c

860

prog->exception_cb_idx = -1;

tools/lib/bpf/libbpf.c

867

prog->autoload = false;

tools/lib/bpf/libbpf.c

871

prog->autoload = true;

tools/lib/bpf/libbpf.c

874

prog->autoattach = true;

tools/lib/bpf/libbpf.c

877

prog->log_level = obj->log_level;

tools/lib/bpf/libbpf.c

879

prog->sec_name = strdup(sec_name);

tools/lib/bpf/libbpf.c

880

if (!prog->sec_name)

tools/lib/bpf/libbpf.c

883

prog->name = strdup(name);

tools/lib/bpf/libbpf.c

884

if (!prog->name)

tools/lib/bpf/libbpf.c

8841

struct bpf_program *prog = st_ops->progs[i];

tools/lib/bpf/libbpf.c

8845

if (!prog)

tools/lib/bpf/libbpf.c

8848

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

887

prog->insns = malloc(insn_data_sz);

tools/lib/bpf/libbpf.c

888

if (!prog->insns)

tools/lib/bpf/libbpf.c

890

memcpy(prog->insns, insn_data, insn_data_sz);

tools/lib/bpf/libbpf.c

895

bpf_program__exit(prog);

tools/lib/bpf/libbpf.c

904

struct bpf_program *prog, *progs;

tools/lib/bpf/libbpf.c

9047

int bpf_program__pin(struct bpf_program *prog, const char *path)

tools/lib/bpf/libbpf.c

9051

if (prog->fd < 0) {

tools/lib/bpf/libbpf.c

9052

pr_warn("prog '%s': can't pin program that wasn't loaded\n", prog->name);

tools/lib/bpf/libbpf.c

9064

if (bpf_obj_pin(prog->fd, path)) {

tools/lib/bpf/libbpf.c

9066

pr_warn("prog '%s': failed to pin at '%s': %s\n", prog->name, path, errstr(err));

tools/lib/bpf/libbpf.c

9070

pr_debug("prog '%s': pinned at '%s'\n", prog->name, path);

tools/lib/bpf/libbpf.c

9074

int bpf_program__unpin(struct bpf_program *prog, const char *path)

tools/lib/bpf/libbpf.c

9078

if (prog->fd < 0) {

tools/lib/bpf/libbpf.c

9079

pr_warn("prog '%s': can't unpin program that wasn't loaded\n", prog->name);

tools/lib/bpf/libbpf.c

9091

pr_debug("prog '%s': unpinned from '%s'\n", prog->name, path);

tools/lib/bpf/libbpf.c

9313

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

9325

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

9326

err = pathname_concat(buf, sizeof(buf), path, prog->name);

tools/lib/bpf/libbpf.c

9330

err = bpf_program__pin(prog, buf);

tools/lib/bpf/libbpf.c

9338

while ((prog = bpf_object__prev_program(obj, prog))) {

tools/lib/bpf/libbpf.c

9339

if (pathname_concat(buf, sizeof(buf), path, prog->name))

tools/lib/bpf/libbpf.c

9342

bpf_program__unpin(prog, buf);

tools/lib/bpf/libbpf.c

9350

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

9356

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

9359

err = pathname_concat(buf, sizeof(buf), path, prog->name);

tools/lib/bpf/libbpf.c

9363

err = bpf_program__unpin(prog, buf);

tools/lib/bpf/libbpf.c

9577

struct bpf_program *prog = prev;

tools/lib/bpf/libbpf.c

9580

prog = __bpf_program__iter(prog, obj, true);

tools/lib/bpf/libbpf.c

9581

} while (prog && prog_is_subprog(obj, prog));

tools/lib/bpf/libbpf.c

9583

return prog;

tools/lib/bpf/libbpf.c

9589

struct bpf_program *prog = next;

tools/lib/bpf/libbpf.c

9592

prog = __bpf_program__iter(prog, obj, false);

tools/lib/bpf/libbpf.c

9593

} while (prog && prog_is_subprog(obj, prog));

tools/lib/bpf/libbpf.c

9595

return prog;

tools/lib/bpf/libbpf.c

9598

void bpf_program__set_ifindex(struct bpf_program *prog, __u32 ifindex)

tools/lib/bpf/libbpf.c

960

prog = &progs[nr_progs];

tools/lib/bpf/libbpf.c

9600

prog->prog_ifindex = ifindex;

tools/lib/bpf/libbpf.c

9603

const char *bpf_program__name(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9605

return prog->name;

tools/lib/bpf/libbpf.c

9608

const char *bpf_program__section_name(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9610

return prog->sec_name;

tools/lib/bpf/libbpf.c

9613

bool bpf_program__autoload(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9615

return prog->autoload;

tools/lib/bpf/libbpf.c

9618

int bpf_program__set_autoload(struct bpf_program *prog, bool autoload)

tools/lib/bpf/libbpf.c

962

err = bpf_object__init_prog(obj, prog, name, sec_idx, sec_name,

tools/lib/bpf/libbpf.c

9620

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9623

prog->autoload = autoload;

tools/lib/bpf/libbpf.c

9627

bool bpf_program__autoattach(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9629

return prog->autoattach;

tools/lib/bpf/libbpf.c

9632

void bpf_program__set_autoattach(struct bpf_program *prog, bool autoattach)

tools/lib/bpf/libbpf.c

9634

prog->autoattach = autoattach;

tools/lib/bpf/libbpf.c

9637

const struct bpf_insn *bpf_program__insns(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9639

return prog->insns;

tools/lib/bpf/libbpf.c

9642

size_t bpf_program__insn_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9644

return prog->insns_cnt;

tools/lib/bpf/libbpf.c

9647

int bpf_program__set_insns(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

9652

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9655

insns = libbpf_reallocarray(prog->insns, new_insn_cnt, sizeof(*insns));

tools/lib/bpf/libbpf.c

9658

pr_warn("prog '%s': failed to realloc prog code\n", prog->name);

tools/lib/bpf/libbpf.c

9663

prog->insns = insns;

tools/lib/bpf/libbpf.c

9664

prog->insns_cnt = new_insn_cnt;

tools/lib/bpf/libbpf.c

9668

int bpf_program__fd(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9670

if (!prog)

tools/lib/bpf/libbpf.c

9673

if (prog->fd < 0)

tools/lib/bpf/libbpf.c

9676

return prog->fd;

tools/lib/bpf/libbpf.c

968

prog->sym_global = true;

tools/lib/bpf/libbpf.c

9680

enum bpf_prog_type bpf_program__get_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.c

9682

enum bpf_prog_type bpf_program__type(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9684

return prog->type;

tools/lib/bpf/libbpf.c

9693

int bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type)

tools/lib/bpf/libbpf.c

9695

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9699

if (prog->type == type)

tools/lib/bpf/libbpf.c

9702

prog->type = type;

tools/lib/bpf/libbpf.c

9710

if (prog->sec_def != &custom_fallback_def)

tools/lib/bpf/libbpf.c

9711

prog->sec_def = NULL;

tools/lib/bpf/libbpf.c

9716

enum bpf_attach_type bpf_program__get_expected_attach_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.c

9718

enum bpf_attach_type bpf_program__expected_attach_type(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9720

return prog->expected_attach_type;

tools/lib/bpf/libbpf.c

9723

int bpf_program__set_expected_attach_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

9726

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9729

prog->expected_attach_type = type;

tools/lib/bpf/libbpf.c

9733

__u32 bpf_program__flags(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9735

return prog->prog_flags;

tools/lib/bpf/libbpf.c

9738

int bpf_program__set_flags(struct bpf_program *prog, __u32 flags)

tools/lib/bpf/libbpf.c

9740

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9743

prog->prog_flags = flags;

tools/lib/bpf/libbpf.c

9747

__u32 bpf_program__log_level(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9749

return prog->log_level;

tools/lib/bpf/libbpf.c

975

if (prog->sym_global && (ELF64_ST_VISIBILITY(sym->st_other) == STV_HIDDEN

tools/lib/bpf/libbpf.c

9752

int bpf_program__set_log_level(struct bpf_program *prog, __u32 log_level)

tools/lib/bpf/libbpf.c

9754

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9757

prog->log_level = log_level;

tools/lib/bpf/libbpf.c

9761

const char *bpf_program__log_buf(const struct bpf_program *prog, size_t *log_size)

tools/lib/bpf/libbpf.c

9763

*log_size = prog->log_size;

tools/lib/bpf/libbpf.c

9764

return prog->log_buf;

tools/lib/bpf/libbpf.c

9767

int bpf_program__set_log_buf(struct bpf_program *prog, char *log_buf, size_t log_size)

tools/lib/bpf/libbpf.c

977

prog->mark_btf_static = true;

tools/lib/bpf/libbpf.c

9771

if (prog->log_size > UINT_MAX)

tools/lib/bpf/libbpf.c

9773

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9776

prog->log_buf = log_buf;

tools/lib/bpf/libbpf.c

9777

prog->log_size = log_size;

tools/lib/bpf/libbpf.c

9781

struct bpf_func_info *bpf_program__func_info(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9783

if (prog->func_info_rec_size != sizeof(struct bpf_func_info))

tools/lib/bpf/libbpf.c

9785

return prog->func_info;

tools/lib/bpf/libbpf.c

9788

__u32 bpf_program__func_info_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9790

return prog->func_info_cnt;

tools/lib/bpf/libbpf.c

9793

struct bpf_line_info *bpf_program__line_info(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9795

if (prog->line_info_rec_size != sizeof(struct bpf_line_info))

tools/lib/bpf/libbpf.c

9797

return prog->line_info;

tools/lib/bpf/libbpf.c

9800

__u32 bpf_program__line_info_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9802

return prog->line_info_cnt;

tools/lib/bpf/libbpf.c

9814

static int attach_kprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9815

static int attach_uprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9816

static int attach_ksyscall(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9817

static int attach_usdt(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9818

static int attach_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9819

static int attach_raw_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9820

static int attach_trace(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9821

static int attach_kprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9822

static int attach_kprobe_session(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9823

static int attach_uprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9824

static int attach_lsm(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

9825

static int attach_iter(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

988

struct bpf_program *prog = obj->programs;

tools/lib/bpf/libbpf.c

992

for (p = 0; p < obj->nr_programs; p++, prog++) {

tools/lib/bpf/libbpf.c

993

insn = prog->insns;

tools/lib/bpf/libbpf.c

994

for (i = 0; i < prog->insns_cnt; i++, insn++)

tools/lib/bpf/libbpf.h

1006

bpf_program__set_attach_target(struct bpf_program *prog, int attach_prog_fd,

tools/lib/bpf/libbpf.h

1022

bpf_program__assoc_struct_ops(struct bpf_program *prog, struct bpf_map *map,

tools/lib/bpf/libbpf.h

1322

LIBBPF_API int bpf_map__set_exclusive_program(struct bpf_map *map, struct bpf_program *prog);

tools/lib/bpf/libbpf.h

363

bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prog);

tools/lib/bpf/libbpf.h

371

bpf_object__prev_program(const struct bpf_object *obj, struct bpf_program *prog);

tools/lib/bpf/libbpf.h

373

LIBBPF_API void bpf_program__set_ifindex(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

376

LIBBPF_API const char *bpf_program__name(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

377

LIBBPF_API const char *bpf_program__section_name(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

378

LIBBPF_API bool bpf_program__autoload(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

379

LIBBPF_API int bpf_program__set_autoload(struct bpf_program *prog, bool autoload);

tools/lib/bpf/libbpf.h

380

LIBBPF_API bool bpf_program__autoattach(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

381

LIBBPF_API void bpf_program__set_autoattach(struct bpf_program *prog, bool autoattach);

tools/lib/bpf/libbpf.h

405

LIBBPF_API const struct bpf_insn *bpf_program__insns(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

421

LIBBPF_API int bpf_program__set_insns(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

433

LIBBPF_API size_t bpf_program__insn_cnt(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

435

LIBBPF_API int bpf_program__fd(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

447

LIBBPF_API int bpf_program__pin(struct bpf_program *prog, const char *path);

tools/lib/bpf/libbpf.h

461

LIBBPF_API int bpf_program__unpin(struct bpf_program *prog, const char *path);

tools/lib/bpf/libbpf.h

462

LIBBPF_API void bpf_program__unload(struct bpf_program *prog);

tools/lib/bpf/libbpf.h

494

struct bpf_program *prog);

tools/lib/bpf/libbpf.h

516

bpf_program__attach(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

532

bpf_program__attach_perf_event(const struct bpf_program *prog, int pfd);

tools/lib/bpf/libbpf.h

535

bpf_program__attach_perf_event_opts(const struct bpf_program *prog, int pfd,

tools/lib/bpf/libbpf.h

571

bpf_program__attach_kprobe(const struct bpf_program *prog, bool retprobe,

tools/lib/bpf/libbpf.h

574

bpf_program__attach_kprobe_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

601

bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

652

bpf_program__attach_uprobe_multi(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

700

bpf_program__attach_ksyscall(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

746

bpf_program__attach_uprobe(const struct bpf_program *prog, bool retprobe,

tools/lib/bpf/libbpf.h

765

bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,

tools/lib/bpf/libbpf.h

795

bpf_program__attach_usdt(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

809

bpf_program__attach_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

813

bpf_program__attach_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

826

bpf_program__attach_raw_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

829

bpf_program__attach_raw_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

842

bpf_program__attach_trace(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

844

bpf_program__attach_trace_opts(const struct bpf_program *prog, const struct bpf_trace_opts *opts);

tools/lib/bpf/libbpf.h

847

bpf_program__attach_lsm(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

849

bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd);

tools/lib/bpf/libbpf.h

851

bpf_program__attach_netns(const struct bpf_program *prog, int netns_fd);

tools/lib/bpf/libbpf.h

853

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd);

tools/lib/bpf/libbpf.h

855

bpf_program__attach_xdp(const struct bpf_program *prog, int ifindex);

tools/lib/bpf/libbpf.h

857

bpf_program__attach_freplace(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

872

bpf_program__attach_netfilter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

887

bpf_program__attach_tcx(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.h

902

bpf_program__attach_netkit(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.h

917

bpf_program__attach_cgroup_opts(const struct bpf_program *prog, int cgroup_fd,

tools/lib/bpf/libbpf.h

933

bpf_program__attach_iter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

936

LIBBPF_API enum bpf_prog_type bpf_program__type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

949

LIBBPF_API int bpf_program__set_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

953

bpf_program__expected_attach_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

968

bpf_program__set_expected_attach_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

971

LIBBPF_API __u32 bpf_program__flags(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

972

LIBBPF_API int bpf_program__set_flags(struct bpf_program *prog, __u32 flags);

tools/lib/bpf/libbpf.h

978

LIBBPF_API __u32 bpf_program__log_level(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

979

LIBBPF_API int bpf_program__set_log_level(struct bpf_program *prog, __u32 log_level);

tools/lib/bpf/libbpf.h

980

LIBBPF_API const char *bpf_program__log_buf(const struct bpf_program *prog, size_t *log_size);

tools/lib/bpf/libbpf.h

981

LIBBPF_API int bpf_program__set_log_buf(struct bpf_program *prog, char *log_buf, size_t log_size);

tools/lib/bpf/libbpf.h

983

LIBBPF_API struct bpf_func_info *bpf_program__func_info(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

984

LIBBPF_API __u32 bpf_program__func_info_cnt(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

986

LIBBPF_API struct bpf_line_info *bpf_program__line_info(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

987

LIBBPF_API __u32 bpf_program__line_info_cnt(const struct bpf_program *prog);

tools/lib/bpf/libbpf_internal.h

719

const struct bpf_program *prog,

tools/lib/bpf/libbpf_legacy.h

130

LIBBPF_API enum bpf_prog_type bpf_program__get_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf_legacy.h

131

LIBBPF_API enum bpf_attach_type bpf_program__get_expected_attach_type(const struct bpf_program *prog);

tools/lib/bpf/usdt.c

1086

uprobe_link = bpf_program__attach_uprobe_opts(prog, pid, path,

tools/lib/bpf/usdt.c

1109

link->multi_link = bpf_program__attach_uprobe_multi(prog, pid, path,

tools/lib/bpf/usdt.c

966

struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct bpf_program *prog,

tools/perf/bench/sched-seccomp-notify.c

59

struct sock_fprog prog = {

tools/perf/bench/sched-seccomp-notify.c

64

return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);

tools/perf/bench/uprobe.c

49

#define bench_uprobe__attach_uprobe(prog) \

tools/perf/bench/uprobe.c

50

skel->links.prog = bpf_program__attach_uprobe_opts(/*prog=*/skel->progs.prog, \

tools/perf/bench/uprobe.c

55

if (!skel->links.prog) { \

tools/perf/bench/uprobe.c

57

fprintf(stderr, "Failed to attach bench uprobe \"%s\": %m\n", #prog); \

tools/perf/builtin-annotate.c

592

struct ui_progress prog;

tools/perf/builtin-annotate.c

597

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

599

hists__collapse_resort(hists, &prog);

tools/perf/builtin-annotate.c

605

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

607

evsel__output_resort(pos, &prog);

tools/perf/builtin-annotate.c

638

struct ui_progress prog;

tools/perf/builtin-annotate.c

650

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

652

evsel__output_resort(pos, &prog);

tools/perf/builtin-c2c.c

3082

struct ui_progress prog;

tools/perf/builtin-c2c.c

3333

ui_progress__init(&prog, c2c.hists.hists.nr_entries, "Sorting...");

tools/perf/builtin-c2c.c

3336

hists__output_resort_cb(&c2c.hists.hists, &prog, resort_shared_cl_cb);

tools/perf/builtin-kvm.c

1008

struct ui_progress prog;

tools/perf/builtin-kvm.c

1013

ui_progress__init(&prog, kvm_hists.hists.nr_entries, "Sorting...");

tools/perf/builtin-report.c

712

struct ui_progress prog;

tools/perf/builtin-report.c

729

ui_progress__init(&prog, rep->nr_entries, "Merging related events...");

tools/perf/builtin-report.c

739

ret = hists__collapse_resort(hists, &prog);

tools/perf/builtin-report.c

772

struct ui_progress prog;

tools/perf/builtin-report.c

775

ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");

tools/perf/builtin-report.c

778

evsel__output_resort_cb(pos, &prog, hists__resort_cb, rep);

tools/perf/builtin-trace.c

3753

struct bpf_program *prog;

tools/perf/builtin-trace.c

3758

prog = augmented_syscalls__find_by_title(default_prog_name);

tools/perf/builtin-trace.c

3759

if (prog != NULL)

tools/perf/builtin-trace.c

3763

prog = augmented_syscalls__find_by_title(default_prog_name);

tools/perf/builtin-trace.c

3764

if (prog != NULL)

tools/perf/builtin-trace.c

3770

prog = augmented_syscalls__find_by_title(prog_name);

tools/perf/builtin-trace.c

3772

if (prog != NULL) {

tools/perf/builtin-trace.c

3774

return prog;

tools/perf/tests/dlfilter-test.c

209

static const char *prog = "int bar(){};int foo(){bar();};int main(){foo();return 0;}";

tools/perf/tests/dlfilter-test.c

214

ssize_t n = strlen(prog);

tools/perf/tests/dlfilter-test.c

215

bool err = fd < 0 || writen(fd, prog, n) != n;

tools/perf/util/bpf-filter.c

451

struct bpf_program *prog;

tools/perf/util/bpf-filter.c

529

prog = skel->progs.perf_sample_filter;

tools/perf/util/bpf-filter.c

532

link = bpf_program__attach_perf_event_opts(prog, FD(evsel, x, y),

tools/perf/util/bpf_counter.c

164

struct bpf_program *prog;

tools/perf/util/bpf_counter.c

198

bpf_object__for_each_program(prog, skel->obj) {

tools/perf/util/bpf_counter.c

199

err = bpf_program__set_attach_target(prog, prog_fd, prog_name);

tools/perf/util/bpf_kwork.c

205

struct bpf_program *prog;

tools/perf/util/bpf_kwork.c

220

bpf_object__for_each_program(prog, skel->obj)

tools/perf/util/bpf_kwork.c

221

bpf_program__set_autoload(prog, false);

tools/perf/util/bpf_kwork_top.c

161

struct bpf_program *prog;

tools/perf/util/bpf_kwork_top.c

176

bpf_object__for_each_program(prog, skel->obj)

tools/perf/util/bpf_kwork_top.c

177

bpf_program__set_autoload(prog, false);

tools/perf/util/bpf_trace_augment.c

15

struct bpf_program *prog;

tools/perf/util/bpf_trace_augment.c

29

bpf_object__for_each_program(prog, skel->obj) {

tools/perf/util/bpf_trace_augment.c

30

if (prog != skel->progs.sys_enter && prog != skel->progs.sys_exit)

tools/perf/util/bpf_trace_augment.c

31

bpf_program__set_autoattach(prog, /*autoattach=*/false);

tools/perf/util/hist.c

1826

int hists__collapse_resort(struct hists *hists, struct ui_progress *prog)

tools/perf/util/hist.c

1861

if (prog)

tools/perf/util/hist.c

1862

ui_progress__update(prog, 1);

tools/perf/util/hist.c

1962

struct ui_progress *prog,

tools/perf/util/hist.c

1980

if (prog)

tools/perf/util/hist.c

1981

ui_progress__update(prog, 1);

tools/perf/util/hist.c

1990

hists__hierarchy_output_resort(hists, prog,

tools/perf/util/hist.c

2061

static void output_resort(struct hists *hists, struct ui_progress *prog,

tools/perf/util/hist.c

2081

hists__hierarchy_output_resort(hists, prog,

tools/perf/util/hist.c

2111

if (prog)

tools/perf/util/hist.c

2112

ui_progress__update(prog, 1);

tools/perf/util/hist.c

2116

void evsel__output_resort_cb(struct evsel *evsel, struct ui_progress *prog,

tools/perf/util/hist.c

2128

output_resort(evsel__hists(evsel), prog, use_callchain, cb, cb_arg);

tools/perf/util/hist.c

2131

void evsel__output_resort(struct evsel *evsel, struct ui_progress *prog)

tools/perf/util/hist.c

2133

return evsel__output_resort_cb(evsel, prog, NULL, NULL);

tools/perf/util/hist.c

2136

void hists__output_resort(struct hists *hists, struct ui_progress *prog)

tools/perf/util/hist.c

2138

output_resort(hists, prog, symbol_conf.use_callchain, NULL, NULL);

tools/perf/util/hist.c

2141

void hists__output_resort_cb(struct hists *hists, struct ui_progress *prog,

tools/perf/util/hist.c

2144

output_resort(hists, prog, symbol_conf.use_callchain, cb, NULL);

tools/perf/util/hist.h

384

void evsel__output_resort_cb(struct evsel *evsel, struct ui_progress *prog,

tools/perf/util/hist.h

386

void evsel__output_resort(struct evsel *evsel, struct ui_progress *prog);

tools/perf/util/hist.h

387

void hists__output_resort(struct hists *hists, struct ui_progress *prog);

tools/perf/util/hist.h

388

void hists__output_resort_cb(struct hists *hists, struct ui_progress *prog,

tools/perf/util/hist.h

390

int hists__collapse_resort(struct hists *hists, struct ui_progress *prog);

tools/perf/util/ordered-events.c

230

struct ui_progress prog;

tools/perf/util/ordered-events.c

237

ui_progress__init(&prog, oe->nr_events, "Processing time ordered events...");

tools/perf/util/ordered-events.c

253

ui_progress__update(&prog, 1);

tools/perf/util/session.c

2036

struct ui_progress prog;

tools/perf/util/session.c

2052

ui_progress__init_size(&prog, session->data->file.size,

tools/perf/util/session.c

2129

ui_progress__update(&prog, size);

tools/perf/util/session.c

2363

struct ui_progress *prog)

tools/perf/util/session.c

2403

ui_progress__update(prog, size);

tools/perf/util/session.c

2417

struct ui_progress *prog)

tools/perf/util/session.c

2433

err = reader__read_event(rd, session, prog);

tools/perf/util/session.c

2470

struct ui_progress prog;

tools/perf/util/session.c

2476

ui_progress__init_size(&prog, rd.data_size, "Processing events...");

tools/perf/util/session.c

2478

err = reader__process_events(&rd, session, &prog);

tools/perf/util/session.c

2524

struct ui_progress prog;

tools/perf/util/session.c

2528

ui_progress__init_size(&prog, total_size, "Processing events...");

tools/perf/util/session.c

2592

ret = reader__read_event(&rd[i], session, &prog);

tools/perf/util/vdso.c

191

static int vdso__copy_compat(const char *prog, int fd)

tools/perf/util/vdso.c

196

f = popen(prog, "r");

tools/perf/util/vdso.c

208

static int vdso__create_compat_file(const char *prog, char *temp_name)

tools/perf/util/vdso.c

216

err = vdso__copy_compat(prog, fd);

tools/spi/spidev_test.c

175

static void print_usage(const char *prog)

tools/spi/spidev_test.c

177

printf("Usage: %s [-2348CDFHILMNORSZbdilopsvw]\n", prog);

tools/testing/memblock/tests/common.c

121

static void usage(const char *prog)

tools/testing/memblock/tests/common.c

125

printf("Usage: %s [-%s]\n", prog, short_opts);

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

189

struct bpf_program *prog;

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

191

prog = bpf_object__find_program_by_name(ctx.skel->obj, *names);

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

192

if (!prog) {

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

196

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/benchs/bench_local_storage.c

115

static void __setup(struct bpf_program *prog, bool hashmap)

tools/testing/selftests/bpf/benchs/bench_local_storage.c

167

if (!bpf_program__attach(prog)) {

tools/testing/selftests/bpf/benchs/bench_rename.c

63

static void attach_bpf(struct bpf_program *prog)

tools/testing/selftests/bpf/benchs/bench_rename.c

67

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/benchs/bench_sockmap.c

294

int prog, map;

tools/testing/selftests/bpf/benchs/bench_sockmap.c

298

prog = TXMODE_BPF_PASS() ?

tools/testing/selftests/bpf/benchs/bench_sockmap.c

302

err = bpf_prog_attach(prog, map, BPF_SK_MSG_VERDICT, 0);

tools/testing/selftests/bpf/benchs/bench_strncmp.c

101

static void strncmp_attach_prog(struct bpf_program *prog)

tools/testing/selftests/bpf/benchs/bench_strncmp.c

105

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/benchs/bench_trigger.c

163

static void attach_bpf(struct bpf_program *prog)

tools/testing/selftests/bpf/benchs/bench_trigger.c

167

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/benchs/bench_trigger.c

263

struct bpf_program *prog, *empty;

tools/testing/selftests/bpf/benchs/bench_trigger.c

267

prog = ctx.skel->progs.bench_trigger_kprobe_multi;

tools/testing/selftests/bpf/benchs/bench_trigger.c

269

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/benchs/bench_trigger.c

273

attach_bpf(prog);

tools/testing/selftests/bpf/benchs/bench_trigger.c

278

struct bpf_program *prog, *empty;

tools/testing/selftests/bpf/benchs/bench_trigger.c

282

prog = ctx.skel->progs.bench_trigger_kretprobe_multi;

tools/testing/selftests/bpf/benchs/bench_trigger.c

284

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/benchs/bench_trigger.c

288

attach_bpf(prog);

tools/testing/selftests/bpf/flow_dissector_load.h

17

struct bpf_program *prog, *main_prog;

tools/testing/selftests/bpf/flow_dissector_load.h

54

bpf_object__for_each_program(prog, *obj) {

tools/testing/selftests/bpf/flow_dissector_load.h

55

fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/align.c

604

struct bpf_insn *prog = test->insns;

tools/testing/selftests/bpf/prog_tests/align.c

621

prog_len = probe_filter_length(prog);

tools/testing/selftests/bpf/prog_tests/align.c

623

prog, prog_len, &opts);

tools/testing/selftests/bpf/prog_tests/arena_spin_lock.c

81

prog_fd = bpf_program__fd(skel->progs.prog);

tools/testing/selftests/bpf/prog_tests/bpf_gotox.c

18

static void __test_run(struct bpf_program *prog, void *ctx_in, size_t ctx_size_in)

tools/testing/selftests/bpf/prog_tests/bpf_gotox.c

26

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/bpf_gotox.c

40

struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/bpf_gotox.c

46

__test_run(prog, &ctx_in, sizeof(ctx_in));

tools/testing/selftests/bpf/prog_tests/bpf_gotox.c

53

struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

177

static void check_bpf_link_info(const struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

191

link = bpf_program__attach_iter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

477

struct bpf_program *prog = skel->progs.dump_task_struct;

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

48

static void do_dummy_read_opts(struct bpf_program *prog, struct bpf_iter_attach_opts *opts)

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

484

link = bpf_program__attach_iter(prog, NULL);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

54

link = bpf_program__attach_iter(prog, opts);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

73

static void do_dummy_read(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

75

do_dummy_read_opts(prog, NULL);

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

78

static void do_read_map_iter_fd(struct bpf_object_skeleton **skel, struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/bpf_iter.c

91

link = bpf_program__attach_iter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

163

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

170

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

171

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

174

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

17

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

69

prog = bpf_object__find_program_by_name(objs[i], "test_obj_id");

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

70

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c

73

links[i] = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

23

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

31

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

32

if (!prog) {

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

37

bpf_program__set_type(prog, type);

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

38

bpf_program__set_flags(prog, testing_prog_flags());

tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c

39

bpf_program__set_log_level(prog, 4 | extra_prog_load_log_flags);

tools/testing/selftests/bpf/prog_tests/btf.c

4836

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/btf.c

4869

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/btf.c

4870

if (CHECK(!prog, "Cannot find bpf_prog")) {

tools/testing/selftests/bpf/prog_tests/btf.c

4875

bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);

tools/testing/selftests/bpf/prog_tests/btf.c

4879

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cb_refs.c

25

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cb_refs.c

38

prog = bpf_object__find_program_by_name(skel->obj, cb_refs_tests[i].prog_name);

tools/testing/selftests/bpf/prog_tests/cb_refs.c

39

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/cb_refs.c

41

bpf_prog_test_run_opts(bpf_program__fd(prog), &run_opts);

tools/testing/selftests/bpf/prog_tests/cgroup_attach_autodetach.c

13

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/cgroup_attach_autodetach.c

17

size_t insns_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_attach_autodetach.c

20

prog, insns_cnt, "GPL", 0,

tools/testing/selftests/bpf/prog_tests/cgroup_attach_multi.c

39

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/cgroup_attach_multi.c

66

size_t insns_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_attach_multi.c

70

prog, insns_cnt, "GPL", 0,

tools/testing/selftests/bpf/prog_tests/cgroup_attach_override.c

15

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/cgroup_attach_override.c

19

size_t insns_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_attach_override.c

22

prog, insns_cnt, "GPL", 0,

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

476

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

485

prog = bpf_object__find_program_by_name(skel->obj, exposed_hooks[i].name);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

486

if (!ASSERT_NEQ(prog, NULL, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

489

err = bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/cgroup_iter.c

51

static void read_from_cgroup_iter(struct bpf_program *prog, int cgroup_fd,

tools/testing/selftests/bpf/prog_tests/cgroup_iter.c

68

link = bpf_program__attach_iter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

13

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

24

prog = skel->progs.parent;

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

25

prog_p_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

26

prog_p_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

34

prog = skel->progs.parent_2;

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

35

prog_p2_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_mprog_ordering.c

36

prog_p2_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

13

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

30

prog = skel->progs.child;

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

31

prog_c_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

32

prog_c_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

38

prog = skel->progs.child_2;

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

39

prog_c2_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

40

prog_c2_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

62

prog = skel->progs.parent;

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

63

prog_p_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

64

prog_p_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

70

prog = skel->progs.parent_2;

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

71

prog_p2_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cgroup_preorder.c

72

prog_p2_atype = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

106

prog = skel->progs.test_cgrp_from_id_ns;

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

129

ret = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

53

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

63

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

64

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

67

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c

96

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/check_mtu.c

132

struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/check_mtu.c

138

int err, prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/check_mtu.c

44

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/check_mtu.c

53

prog = skel->progs.xdp_use_helper_basic;

tools/testing/selftests/bpf/prog_tests/check_mtu.c

55

link = bpf_program__attach_xdp(prog, IFINDEX_LO);

tools/testing/selftests/bpf/prog_tests/check_mtu.c

79

struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/check_mtu.c

85

int err, prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

301

static void test_cls_redirect_common(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/cls_redirect.c

329

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

102

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

105

if (CHECK(!prog, "find_prog", "getsockname prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

110

err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

54

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

70

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

73

if (CHECK(!prog, "find_prog", "connect prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

78

err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

86

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

89

if (CHECK(!prog, "find_prog", "getpeername prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

94

err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd, v4 ?

tools/testing/selftests/bpf/prog_tests/core_autosize.c

134

prog = bpf_object__find_program_by_name(skel->obj, "handle_signed");

tools/testing/selftests/bpf/prog_tests/core_autosize.c

135

if (!ASSERT_OK_PTR(prog, "prog_find"))

tools/testing/selftests/bpf/prog_tests/core_autosize.c

137

bpf_program__set_autoload(prog, false);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

143

prog = bpf_object__find_program_by_name(skel->obj, "handle_samesize");

tools/testing/selftests/bpf/prog_tests/core_autosize.c

144

if (!ASSERT_OK_PTR(prog, "prog_find"))

tools/testing/selftests/bpf/prog_tests/core_autosize.c

146

skel->links.handle_samesize = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

150

prog = bpf_object__find_program_by_name(skel->obj, "handle_downsize");

tools/testing/selftests/bpf/prog_tests/core_autosize.c

151

if (!ASSERT_OK_PTR(prog, "prog_find"))

tools/testing/selftests/bpf/prog_tests/core_autosize.c

153

skel->links.handle_downsize = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

157

prog = bpf_object__find_program_by_name(skel->obj, "handle_probed");

tools/testing/selftests/bpf/prog_tests/core_autosize.c

158

if (!ASSERT_OK_PTR(prog, "prog_find"))

tools/testing/selftests/bpf/prog_tests/core_autosize.c

160

skel->links.handle_probed = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/core_autosize.c

58

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/core_reloc.c

1009

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/core_reloc.c

1070

prog = bpf_object__find_program_by_name(obj, probe_name);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

1071

if (CHECK(!prog, "find_probe",

tools/testing/selftests/bpf/prog_tests/core_reloc.c

1100

link = bpf_program__attach_raw_tracepoint(prog, tp_name);

tools/testing/selftests/bpf/prog_tests/cpumask.c

37

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/cpumask.c

53

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/cpumask.c

54

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/cpumask.c

57

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

638

struct bpf_insn *prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

669

pinfo->prog, pinfo->prog_len, &opts);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

749

pinfo.prog = ldx_prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

782

pinfo.prog = stx_prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

791

pinfo.prog = st_prog;

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

13

static int custom_setup_prog(struct bpf_program *prog, long cookie)

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

16

bpf_program__set_autoload(prog, false);

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

21

static int custom_prepare_load_prog(struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

32

static int custom_attach_prog(const struct bpf_program *prog, long cookie,

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

37

*link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");

tools/testing/selftests/bpf/prog_tests/custom_sec_handlers.c

40

*link = bpf_program__attach_tracepoint(prog, "syscalls", "sys_enter_nanosleep");

tools/testing/selftests/bpf/prog_tests/dynptr.c

109

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/dynptr.c

139

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/dynptr.c

168

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/dynptr.c

62

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/dynptr.c

72

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/dynptr.c

73

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/dynptr.c

76

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/dynptr.c

88

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/empty_skb.c

116

bpf_object__for_each_program(prog, bpf_obj->obj) {

tools/testing/selftests/bpf/prog_tests/empty_skb.c

117

bool at_egress = strstr(bpf_program__name(prog), "egress") != NULL;

tools/testing/selftests/bpf/prog_tests/empty_skb.c

118

bool at_tc = !strncmp(bpf_program__section_name(prog), "tc", 2);

tools/testing/selftests/bpf/prog_tests/empty_skb.c

12

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/empty_skb.c

130

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &tattr);

tools/testing/selftests/bpf/prog_tests/empty_skb.c

131

sprintf(buf, "err: %s [%s]", tests[i].msg, bpf_program__name(prog));

tools/testing/selftests/bpf/prog_tests/empty_skb.c

137

sprintf(buf, "ret: %s [%s]", tests[i].msg, bpf_program__name(prog));

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

112

if (!ASSERT_ERR_PTR(link = bpf_program__attach(prog), "attach err")) \

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

115

if (!ASSERT_OK_PTR(link = bpf_program__attach(prog), "attach ok")) \

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

124

prog = eskel->progs.pfentry;

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

125

bpf_program__set_autoload(prog, true);

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

126

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

134

prog = eskel->progs.throwing_fentry;

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

135

bpf_program__set_autoload(prog, true);

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

136

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

144

prog = eskel->progs.pfexit;

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

145

bpf_program__set_autoload(prog, true);

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

146

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

154

prog = eskel->progs.throwing_fexit;

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

155

bpf_program__set_autoload(prog, true);

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

156

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

164

prog = eskel->progs.throwing_exception_cb_extension;

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

165

bpf_program__set_autoload(prog, true);

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

166

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

174

prog = eskel->progs.throwing_exception_cb_extension;

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

175

bpf_program__set_autoload(prog, true);

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

176

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

184

prog = eskel->progs.throwing_extension;

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

185

bpf_program__set_autoload(prog, true);

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

186

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

195

prog = eskel->progs.pfentry;

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

196

bpf_program__set_autoload(prog, true);

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

197

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

206

prog = eskel->progs.throwing_fentry;

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

207

bpf_program__set_autoload(prog, true);

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

208

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

217

prog = eskel->progs.pfentry;

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

218

bpf_program__set_autoload(prog, true);

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

219

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

228

prog = eskel->progs.throwing_fentry;

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

229

bpf_program__set_autoload(prog, true);

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

230

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

239

prog = eskel->progs.pfexit;

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

240

bpf_program__set_autoload(prog, true);

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

241

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

250

prog = eskel->progs.throwing_fexit;

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

251

bpf_program__set_autoload(prog, true);

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

252

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

261

prog = eskel->progs.pfexit;

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

262

bpf_program__set_autoload(prog, true);

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

263

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

272

prog = eskel->progs.throwing_fexit;

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

273

bpf_program__set_autoload(prog, true);

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

274

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

285

prog = eskel->progs.pfmod_ret;

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

286

bpf_program__set_autoload(prog, true);

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

287

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

298

prog = eskel->progs.pfmod_ret;

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

299

bpf_program__set_autoload(prog, true);

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

300

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

309

prog = eskel->progs.extension;

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

310

bpf_program__set_autoload(prog, true);

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

311

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

320

prog = eskel->progs.extension;

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

321

bpf_program__set_autoload(prog, true);

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

322

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

331

prog = eskel->progs.extension;

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

332

bpf_program__set_autoload(prog, true);

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

333

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

342

prog = eskel->progs.extension;

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

343

bpf_program__set_autoload(prog, true);

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

344

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

353

prog = eskel->progs.throwing_extension;

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

354

bpf_program__set_autoload(prog, true);

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

355

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

364

prog = eskel->progs.throwing_extension;

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

365

bpf_program__set_autoload(prog, true);

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

366

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

375

prog = eskel->progs.extension;

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

376

bpf_program__set_autoload(prog, true);

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

377

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

386

prog = eskel->progs.throwing_extension;

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

387

bpf_program__set_autoload(prog, true);

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

388

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

94

struct bpf_program *prog = NULL; \

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

99

ASSERT_OK_PTR(bpf_program__name(prog), bpf_program__name(prog)); \

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

122

prog[i] = NULL;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

126

prog[i] = pos;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

130

if (!ASSERT_OK_PTR(prog[i], prog_name[i]))

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

133

link[i] = bpf_program__attach_trace(prog[i]);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

143

bpf_program__expected_attach_type(prog[i]),

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

171

free(prog);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

233

struct bpf_program *prog = NULL;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

243

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

244

if (!ASSERT_OK_PTR(prog, "find_prog"))

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

252

link = bpf_program__attach_freplace(prog, tgt_fd, tgt_name);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

291

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

306

prog = bpf_object__next_program(freplace_obj, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

307

err = bpf_program__set_attach_target(prog, pkt_fd, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

314

freplace_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

322

attach_prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

323

prog = bpf_object__next_program(fmod_obj, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

324

err = bpf_program__set_attach_target(prog, attach_prog_fd, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

359

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

375

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

376

err = bpf_program__set_attach_target(prog, pkt_fd, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

381

bpf_program__set_log_buf(prog, log_buf, sizeof(log_buf));

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

383

bpf_program__set_log_level(prog, 2);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

66

struct bpf_program **prog = NULL, *p;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

93

prog = calloc(sizeof(struct bpf_program *), prog_cnt);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

94

if (!ASSERT_OK_PTR(prog, "prog_ptr"))

tools/testing/selftests/bpf/prog_tests/file_reader.c

71

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/file_reader.c

82

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/file_reader.c

83

bpf_program__set_autoload(prog, strcmp(bpf_program__name(prog), prog_name) == 0);

tools/testing/selftests/bpf/prog_tests/flow_dissector.c

628

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/flow_dissector.c

638

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/flow_dissector.c

639

if (!prog)

tools/testing/selftests/bpf/prog_tests/flow_dissector.c

642

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

504

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

522

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

523

if (!prog)

tools/testing/selftests/bpf/prog_tests/flow_dissector_classification.c

526

sub_prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/flow_dissector_load_bytes.c

39

fd = bpf_test_load_program(BPF_PROG_TYPE_FLOW_DISSECTOR, prog,

tools/testing/selftests/bpf/prog_tests/flow_dissector_load_bytes.c

40

ARRAY_SIZE(prog), "GPL", 0, NULL, 0);

tools/testing/selftests/bpf/prog_tests/flow_dissector_load_bytes.c

8

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c

44

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c

50

fd = bpf_test_load_program(type, prog, ARRAY_SIZE(prog), "GPL", 0, NULL, 0);

tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c

57

static __u32 query_prog_id(int prog)

tools/testing/selftests/bpf/prog_tests/flow_dissector_reattach.c

63

err = bpf_prog_get_info_by_fd(prog, &info, &info_len);

tools/testing/selftests/bpf/prog_tests/free_timer.c

120

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/free_timer.c

136

prog = bpf_object__find_program_by_name(skel->obj, "start_timer");

tools/testing/selftests/bpf/prog_tests/free_timer.c

137

if (!ASSERT_OK_PTR(prog, "find start prog"))

tools/testing/selftests/bpf/prog_tests/free_timer.c

139

ctx.start_prog = prog;

tools/testing/selftests/bpf/prog_tests/free_timer.c

141

prog = bpf_object__find_program_by_name(skel->obj, "overwrite_timer");

tools/testing/selftests/bpf/prog_tests/free_timer.c

142

if (!ASSERT_OK_PTR(prog, "find overwrite prog"))

tools/testing/selftests/bpf/prog_tests/free_timer.c

144

ctx.overwrite_prog = prog;

tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c

107

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c

108

if (CHECK(!prog, "find_probe", "prog '%s' not found\n", prog_name))

tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c

125

link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");

tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c

94

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/helper_restricted.c

21

struct bpf_program *prog = *test->skeleton->progs[j].prog;

tools/testing/selftests/bpf/prog_tests/helper_restricted.c

23

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

121

prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

122

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

125

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

157

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

186

prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

187

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

190

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

203

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

96

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/kfunc_dynptr_param.c

67

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/kfunc_dynptr_param.c

83

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/kfunc_dynptr_param.c

84

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/kfunc_dynptr_param.c

87

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/kfunc_module_order.c

12

err = bpf_prog_test_run_opts(bpf_program__fd(prog), opts);

tools/testing/selftests/bpf/prog_tests/kfunc_module_order.c

16

if (!ASSERT_EQ((int)opts->retval, 0, bpf_program__name(prog)))

tools/testing/selftests/bpf/prog_tests/kfunc_module_order.c

7

static int test_run_prog(const struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

89

#define CASE(prog, helper, supp) { \

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

90

.prog_type_name = "BPF_PROG_TYPE_" # prog, \

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c

92

.prog_type = BPF_PROG_TYPE_ ## prog, \

tools/testing/selftests/bpf/prog_tests/link_pinning.c

11

void test_link_pinning_subtest(struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/link_pinning.c

19

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/linked_list.c

108

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/linked_list.c

115

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/linked_list.c

116

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/linked_list.c

119

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c

15

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c

43

prog = bpf_object__find_program_by_name(obj, "load_bytes_relative");

tools/testing/selftests/bpf/prog_tests/load_bytes_relative.c

44

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/map_in_map.c

79

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/map_in_map.c

88

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/map_in_map.c

89

if (!ASSERT_OK_PTR(prog, "find program"))

tools/testing/selftests/bpf/prog_tests/map_in_map.c

91

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/metadata.c

109

err = prog_holds_map(bpf_program__fd(obj->progs.prog),

tools/testing/selftests/bpf/prog_tests/metadata.c

126

err = bpf_prog_bind_map(bpf_program__fd(obj->progs.prog),

tools/testing/selftests/bpf/prog_tests/metadata.c

75

err = prog_holds_map(bpf_program__fd(obj->progs.prog),

tools/testing/selftests/bpf/prog_tests/metadata.c

92

err = bpf_prog_bind_map(bpf_program__fd(obj->progs.prog),

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

102

link2 = bpf_program__attach_netfilter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

108

link2 = bpf_program__attach_netfilter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

69

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

77

prog = skel->progs.nf_link_attach_test;

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

78

if (!ASSERT_OK_PTR(prog, "attach program"))

tools/testing/selftests/bpf/prog_tests/netfilter_link_attach.c

93

link = bpf_program__attach_netfilter(prog, &opts);

tools/testing/selftests/bpf/prog_tests/obj_name.c

16

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/prog_tests/obj_name.c

35

attr.insns = ptr_to_u64(prog);

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

31

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

48

prog = skel->progs.xdp_ingress_v6;

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

50

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &topts);

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

61

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

78

prog = skel->progs.xdp_ingress_v6;

tools/testing/selftests/bpf/prog_tests/parse_tcp_hdr_opt.c

80

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &topts);

tools/testing/selftests/bpf/prog_tests/pe_preserve_elems.c

30

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/pe_preserve_elems.c

40

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/pe_preserve_elems.c

9

static void test_one_map(struct bpf_map *map, struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/preempted_bpf_ma_op.c

59

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/preempted_bpf_ma_op.c

63

prog = bpf_object__find_program_by_name(skel->obj, name);

tools/testing/selftests/bpf/prog_tests/preempted_bpf_ma_op.c

64

if (!ASSERT_OK_PTR(prog, "no test prog"))

tools/testing/selftests/bpf/prog_tests/preempted_bpf_ma_op.c

68

ctx[i].fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

102

prog = bpf_object__find_program_by_name(skel->obj, inproper_region_tests[i]);

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

103

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

105

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

121

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

129

prog = bpf_object__find_program_by_name(skel->obj, rcuptr_misuse_tests[i]);

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

130

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

132

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/rcu_read_lock.c

94

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/rdonly_maps.c

27

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/rdonly_maps.c

50

prog = bpf_object__find_program_by_name(obj, t->prog_name);

tools/testing/selftests/bpf/prog_tests/rdonly_maps.c

51

if (CHECK(!prog, "find_prog", "prog '%s' not found\n",

tools/testing/selftests/bpf/prog_tests/rdonly_maps.c

60

link = bpf_program__attach_raw_tracepoint(prog, "sys_enter");

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

117

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

128

prog = tracing_skel->progs.recursive_attach;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

130

err = bpf_program__set_attach_target(prog, tgt_prog_fd, "fentry_target");

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

174

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

193

prog = tracing_skel->progs.recursive_attach;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

194

err = bpf_program__set_attach_target(prog, tgt_prog_fd,

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

40

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

56

prog = tracing_chain[i]->progs.recursive_attach;

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

59

err = bpf_program__set_attach_target(prog, prev_fd, "test1");

tools/testing/selftests/bpf/prog_tests/recursive_attach.c

62

err = bpf_program__set_attach_target(prog, prev_fd, "recursive_attach");

tools/testing/selftests/bpf/prog_tests/reference_tracking.c

13

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/reference_tracking.c

26

bpf_object__for_each_program(prog, obj_iter) {

tools/testing/selftests/bpf/prog_tests/reference_tracking.c

30

name = bpf_program__name(prog);

tools/testing/selftests/bpf/prog_tests/select_reuseport.c

101

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/select_reuseport.c

102

RET_ERR(!prog, "get first bpf_program", "!prog\n");

tools/testing/selftests/bpf/prog_tests/select_reuseport.c

103

select_by_skb_data_prog = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/select_reuseport.c

84

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/signal_pending.c

12

struct bpf_insn prog[4096];

tools/testing/selftests/bpf/prog_tests/signal_pending.c

25

for (i = 0; i < ARRAY_SIZE(prog); i++)

tools/testing/selftests/bpf/prog_tests/signal_pending.c

26

prog[i] = BPF_ALU64_IMM(BPF_MOV, BPF_REG_0, 0);

tools/testing/selftests/bpf/prog_tests/signal_pending.c

27

prog[ARRAY_SIZE(prog) - 1] = BPF_EXIT_INSN();

tools/testing/selftests/bpf/prog_tests/signal_pending.c

29

prog_fd = bpf_test_load_program(prog_type, prog, ARRAY_SIZE(prog),

tools/testing/selftests/bpf/prog_tests/sk_assign.c

33

char *prog;

tools/testing/selftests/bpf/prog_tests/sk_assign.c

45

prog = "test_sk_assign_libbpf.bpf.o";

tools/testing/selftests/bpf/prog_tests/sk_assign.c

47

prog = "test_sk_assign.bpf.o";

tools/testing/selftests/bpf/prog_tests/sk_assign.c

67

"direct-action object-file", prog,

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

410

static struct bpf_link *attach_lookup_prog(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

421

link = bpf_program__attach_netns(prog, net_fd);

tools/testing/selftests/bpf/prog_tests/sk_lookup.c

425

bpf_program__name(prog));

tools/testing/selftests/bpf/prog_tests/sock_addr.c

102

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/sock_addr.c

92

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sock_addr.c

98

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/sock_addr.c

99

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/sock_destroy.c

11

static void start_iter_sockets(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/sock_destroy.c

17

link = bpf_program__attach_iter(prog, NULL);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1010

prog = skel->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1012

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1075

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1084

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1087

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1147

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1156

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1159

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1164

prog = skel->progs.prog_skb_verdict_ingress_strp;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1165

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_PARSER, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1256

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1266

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1269

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

180

struct bpf_program *prog, *prog_clone, *prog_clone2;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

190

prog = skel->progs.prog_msg_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

195

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

200

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_MSG_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

223

err = bpf_link_update(bpf_link__fd(link), bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

229

err = bpf_link_update(bpf_link__fd(link), bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

239

int err, prog, src;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

259

prog = bpf_program__fd(skel->progs.copy_sock_map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

270

err = bpf_prog_test_run_opts(prog, &topts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

407

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

414

prog = skel->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

416

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

422

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

427

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

431

err = bpf_prog_detach2(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

725

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

732

prog = pass->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

734

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

998

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_helpers.h

37

#define xbpf_prog_attach(prog, target, type, flags) \

tools/testing/selftests/bpf/prog_tests/sockmap_helpers.h

40

bpf_prog_attach((prog), (target), (type), (flags)); \

tools/testing/selftests/bpf/prog_tests/sockmap_helpers.h

46

#define xbpf_prog_detach2(prog, target, type) \

tools/testing/selftests/bpf/prog_tests/sockmap_helpers.h

48

int __ret = bpf_prog_detach2((prog), (target), (type)); \

tools/testing/selftests/bpf/prog_tests/sockmap_redir.c

132

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_redir.c

136

prog = sk_msg ? skel->progs.prog_msg_verdict : skel->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_redir.c

138

*prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/spin_lock.c

82

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/spin_lock.c

89

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/spin_lock.c

90

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/spin_lock.c

93

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c

11

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c

19

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c

20

if (CHECK(!prog, "find_prog", "prog '%s' not found\n", prog_name))

tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c

23

link = bpf_program__attach_raw_tracepoint(prog, "sched_switch");

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

61

static void test_address(struct bpf_program *prog, unsigned long *fault_addr_p)

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

69

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/string_kfuncs.c

32

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/string_kfuncs.c

47

prog = bpf_object__find_program_by_name(skel->obj, test_name);

tools/testing/selftests/bpf/prog_tests/string_kfuncs.c

48

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/string_kfuncs.c

52

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &topts);

tools/testing/selftests/bpf/prog_tests/subskeleton.c

118

prog = bpf_object__find_program_by_name(obj, "handler1");

tools/testing/selftests/bpf/prog_tests/subskeleton.c

119

if (!ASSERT_OK_PTR(prog, "prog_by_name"))

tools/testing/selftests/bpf/prog_tests/subskeleton.c

122

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/subskeleton.c

89

const struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1020

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1043

prog = bpf_object__find_program_by_name(tgt_obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1044

if (!ASSERT_OK_PTR(prog, "find classifier_0 prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1047

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

106

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1061

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1062

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1065

err = bpf_program__set_attach_target(prog, prog_fd, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

107

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1073

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

110

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1202

struct bpf_program *prog, *fentry_prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1218

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1219

if (!ASSERT_OK_PTR(prog, "find entry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1222

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1234

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1298

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1299

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1302

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1311

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1322

prog = bpf_object__find_program_by_name(fexit_obj, "fexit");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1323

if (!ASSERT_OK_PTR(prog, "find fexit prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1326

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1335

fexit_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

157

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

172

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

173

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

176

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

191

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

192

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

195

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

21

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

236

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

249

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

250

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

253

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

265

prog = bpf_object__find_program_by_name(obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

266

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

269

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

284

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

285

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

288

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

297

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

308

prog = bpf_object__find_program_by_name(fexit_obj, "fexit");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

309

if (!ASSERT_OK_PTR(prog, "find fexit prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

312

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

321

fexit_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

36

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

37

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

40

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

417

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

433

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

434

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

437

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

460

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

461

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

464

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

507

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

523

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

524

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

527

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

55

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

550

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

551

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

554

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

56

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

59

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

597

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

611

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

612

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

615

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

631

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

632

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

635

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

681

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

695

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

696

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

699

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

711

prog = bpf_object__find_program_by_name(obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

712

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

715

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

761

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

775

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

776

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

779

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

794

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

795

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

798

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

85

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

856

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

86

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

870

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

871

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

874

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

889

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

89

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

890

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

893

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

39

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

49

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

50

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

53

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

74

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

89

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

90

if (!prog) {

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

95

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tc_redirect.c

349

const struct bpf_program *prog, int priority)

tools/testing/selftests/bpf/prog_tests/tc_redirect.c

356

tc_attach.prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tc_redirect.c

363

priority, bpf_program__name(prog));

tools/testing/selftests/bpf/prog_tests/tc_redirect.c

375

#define XGRESS_FILTER_ADD(qdisc_hook, xgress, prog, priority) ({ \

tools/testing/selftests/bpf/prog_tests/tc_redirect.c

376

if ((err = xgress_filter_add(qdisc_hook, xgress, prog, priority))) \

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

15

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

44

prog = bpf_object__find_program_by_name(skel->obj, name);

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

45

if (!ASSERT_OK_PTR(prog, "invalid prog name"))

tools/testing/selftests/bpf/prog_tests/test_bpf_ma.c

47

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/test_overhead.c

18

static int test_task_rename(const char *prog)

tools/testing/selftests/bpf/prog_tests/test_overhead.c

36

printf("task_rename %s\t%lluK events per sec\n", prog,

tools/testing/selftests/bpf/prog_tests/test_overhead.c

42

static void test_run(const char *prog)

tools/testing/selftests/bpf/prog_tests/test_overhead.c

44

test_task_rename(prog);

tools/testing/selftests/bpf/prog_tests/test_profiler.c

15

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/test_profiler.c

9

static int sanity_run(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/test_skb_pkt_end.c

17

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/test_skb_pkt_end.c

7

static int sanity_run(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1398

struct bpf_insn *prog, size_t insn_num)

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1409

if (prog[insn_num].code != (BPF_LD | BPF_DW | BPF_IMM)) {

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1415

prog[insn_num].imm = (uint32_t)value.num;

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1416

prog[insn_num + 1].imm = (uint32_t)(value.num >> 32);

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1424

struct bpf_insn *prog = test->insns;

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1428

insn_cnt = probe_prog_length(prog);

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1447

if (fixup_sysctl_value(buf, len, prog, test->fixup_value_insn))

tools/testing/selftests/bpf/prog_tests/test_sysctl.c

1454

ret = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SYSCTL, NULL, "GPL", prog, insn_cnt, &opts);

tools/testing/selftests/bpf/prog_tests/test_task_work.c

115

link = bpf_program__attach_perf_event(prog, pe_fd);

tools/testing/selftests/bpf/prog_tests/test_task_work.c

56

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/test_task_work.c

90

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/test_task_work.c

91

bpf_program__set_autoload(prog, false);

tools/testing/selftests/bpf/prog_tests/test_task_work.c

94

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/test_task_work.c

95

if (!ASSERT_OK_PTR(prog, "prog_name"))

tools/testing/selftests/bpf/prog_tests/test_task_work.c

97

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

102

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

103

if (!prog)

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

106

cfg->client_egress_prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/test_tc_tunnel.c

93

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/test_xdp_veth.c

120

struct prog_configuration *prog, int index)

tools/testing/selftests/bpf/prog_tests/test_xdp_veth.c

127

local_prog = bpf_object__find_program_by_name(objs[i], prog[index].local_name);

tools/testing/selftests/bpf/prog_tests/test_xdp_veth.c

135

remote_prog = bpf_object__find_program_by_name(objs[i], prog[index].remote_name);

tools/testing/selftests/bpf/prog_tests/test_xdp_veth.c

147

prog[index].local_flags, NULL);

tools/testing/selftests/bpf/prog_tests/test_xdp_veth.c

162

prog[index].remote_flags, NULL);

tools/testing/selftests/bpf/prog_tests/timer.c

133

link = bpf_program__attach_perf_event(prog, pe_fd);

tools/testing/selftests/bpf/prog_tests/timer.c

87

static int run_nmi_test(struct timer *timer_skel, struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/trace_ext.c

24

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

42

prog = skel_pkt->progs.test_pkt_md_access;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

43

pkt_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/trace_ext.c

51

prog = skel_ext->progs.test_pkt_md_access_new;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

52

bpf_program__set_attach_target(prog, pkt_fd, "test_pkt_md_access");

tools/testing/selftests/bpf/prog_tests/trace_ext.c

66

prog = skel_ext->progs.test_pkt_md_access_new;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

67

ext_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/trace_ext.c

75

prog = skel_trace->progs.fentry;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

76

bpf_program__set_attach_target(prog, ext_fd, "test_pkt_md_access_new");

tools/testing/selftests/bpf/prog_tests/trace_ext.c

79

prog = skel_trace->progs.fexit;

tools/testing/selftests/bpf/prog_tests/trace_ext.c

80

bpf_program__set_attach_target(prog, ext_fd, "test_pkt_md_access_new");

tools/testing/selftests/bpf/prog_tests/tracing_failure.c

34

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tracing_failure.c

42

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tracing_failure.c

43

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/tracing_failure.c

46

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/tracing_failure.c

47

bpf_program__set_log_buf(prog, log_buf, sizeof(log_buf));

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

13

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

26

prog = bpf_object__find_program_by_name(obj, name);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

27

if (!ASSERT_OK_PTR(prog, "obj_find_prog"))

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

30

return prog;

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

39

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

53

prog = load_prog(file, progs[i % ARRAY_SIZE(progs)], &inst[i]);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

54

if (!prog)

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

57

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

65

prog = load_prog(file, "fmod_ret_test", &inst[i]);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

66

if (!prog)

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

70

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

83

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/type_cast.c

86

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/type_cast.c

95

prog = bpf_object__find_program_by_name(skel->obj, negative_tests[i]);

tools/testing/selftests/bpf/prog_tests/type_cast.c

96

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/type_cast.c

98

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

761

get_program(struct uprobe_multi_consumers *skel, int prog)

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

763

switch (prog) {

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

798

struct bpf_program *prog = get_program(skel, idx);

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

802

if (!prog || !link)

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

817

*link = bpf_program__attach_uprobe_multi(prog, 0, "/proc/self/exe", NULL, &opts);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

52

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/verifier_log.c

61

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/verifier_log.c

62

if (strcmp(bpf_program__name(prog), name) == 0)

tools/testing/selftests/bpf/prog_tests/verifier_log.c

63

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/verifier_log.c

65

bpf_program__set_autoload(prog, false);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_frags.c

20

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_frags.c

24

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_frags.c

9

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

153

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

166

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

170

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

220

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

230

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

234

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

291

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

301

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

305

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

111

link = bpf_program__attach_xdp(prog, ifindex);

tools/testing/selftests/bpf/prog_tests/xdp_bonding.c

99

static int xdp_attach(struct skeletons *skeletons, struct bpf_program *prog, char *iface)

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

111

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

132

prog = ftrace_skel->progs.trace_on_entry;

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

133

bpf_program__set_expected_attach_type(prog, BPF_TRACE_FENTRY);

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

134

bpf_program__set_attach_target(prog, pkt_fd, "_xdp_tx_iptunnel");

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

136

prog = ftrace_skel->progs.trace_on_exit;

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

137

bpf_program__set_expected_attach_type(prog, BPF_TRACE_FEXIT);

tools/testing/selftests/bpf/prog_tests/xdp_bpf2bpf.c

138

bpf_program__set_attach_target(prog, pkt_fd, "_xdp_tx_iptunnel");

tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c

190

static void dump_err_stream(const struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c

197

ret = bpf_prog_stream_read(bpf_program__fd(prog),

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

353

struct bpf_program *new_prog, *prog;

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

409

prog = bpf_object__find_program_by_name(bpf_obj->obj, "rx");

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

410

bpf_program__set_ifindex(prog, rx_ifindex);

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

411

bpf_program__set_flags(prog, BPF_F_XDP_DEV_BOUND_ONLY);

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

428

val = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/xdp_metadata.c

508

bpf_program__set_attach_target(new_prog, bpf_program__fd(prog), "rx");

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

33

int prog(void *ctx)

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

10

int prog(struct xdp_md *ctx)

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

10

int prog(struct xdp_md *ctx)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1281

const struct bpf_prog *prog,

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1284

return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1435

static void test_1_recursion_detected(struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1439

stats = this_cpu_ptr(prog->stats);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1446

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1452

prog->aux->priv_stack_requested = true;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1453

prog->aux->recursion_detected = test_1_recursion_detected;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1492

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1521

*insn++ = prog->insnsi[0];

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1526

static int st_ops_gen_epilogue_with_kfunc(struct bpf_insn *insn_buf, const struct bpf_prog *prog,

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1568

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1572

if (strcmp(prog->aux->attach_func_name, "test_prologue") &&

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1573

strcmp(prog->aux->attach_func_name, "test_pro_epilogue"))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1576

if (!strncmp(prog->aux->name, KFUNC_PRO_EPI_PREFIX, strlen(KFUNC_PRO_EPI_PREFIX)))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1577

return st_ops_gen_prologue_with_kfunc(insn_buf, direct_write, prog);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1588

*insn++ = prog->insnsi[0];

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1593

static int st_ops_gen_epilogue(struct bpf_insn *insn_buf, const struct bpf_prog *prog,

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1598

if (strcmp(prog->aux->attach_func_name, "test_epilogue") &&

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1599

strcmp(prog->aux->attach_func_name, "test_pro_epilogue"))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1602

if (!strncmp(prog->aux->name, KFUNC_PRO_EPI_PREFIX, strlen(KFUNC_PRO_EPI_PREFIX)))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1603

return st_ops_gen_epilogue_with_kfunc(insn_buf, prog, ctx_stack_off);

tools/testing/selftests/bpf/test_loader.c

1348

struct bpf_program *prog;

tools/testing/selftests/bpf/test_loader.c

1362

bpf_object__for_each_program(prog, obj)

tools/testing/selftests/bpf/test_loader.c

1370

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_loader.c

1372

err = parse_test_spec(tester, obj, prog, &specs[i++]);

tools/testing/selftests/bpf/test_loader.c

1375

bpf_program__name(prog));

tools/testing/selftests/bpf/test_loader.c

1379

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_loader.c

403

struct bpf_program *prog,

tools/testing/selftests/bpf/test_loader.c

426

spec->prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/test_loader.c

639

switch (bpf_program__type(prog)) {

tools/testing/selftests/bpf/test_loader.c

724

struct bpf_program *prog)

tools/testing/selftests/bpf/test_loader.c

733

bpf_program__set_log_buf(prog, tester->log_buf, tester->log_buf_sz);

tools/testing/selftests/bpf/test_loader.c

740

bpf_program__set_log_level(prog, (spec->log_level & 4) | min_log_level);

tools/testing/selftests/bpf/test_loader.c

742

bpf_program__set_log_level(prog, spec->log_level);

tools/testing/selftests/bpf/test_loader.c

744

prog_flags = bpf_program__flags(prog);

tools/testing/selftests/bpf/test_loader.c

745

bpf_program__set_flags(prog, prog_flags | spec->prog_flags);

tools/testing/selftests/bpf/test_sockmap.c

1946

struct bpf_program *prog;

tools/testing/selftests/bpf/test_sockmap.c

1964

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_sockmap.c

1965

progs[i] = prog;

tools/testing/selftests/bpf/test_tag.c

134

size = write(fd_alg, prog, insns);

tools/testing/selftests/bpf/test_tag.c

25

static struct bpf_insn prog[BPF_MAXINSNS];

tools/testing/selftests/bpf/test_tag.c

33

prog[i] = BPF_ALU64_IMM(BPF_MOV, i % BPF_REG_10, rand());

tools/testing/selftests/bpf/test_tag.c

34

prog[i - 1] = BPF_EXIT_INSN();

tools/testing/selftests/bpf/test_tag.c

46

memcpy(&prog[i], tmp, sizeof(tmp));

tools/testing/selftests/bpf/test_tag.c

49

prog[insns - 2] = BPF_ALU64_IMM(BPF_MOV, i % BPF_REG_10, 42);

tools/testing/selftests/bpf/test_tag.c

50

prog[insns - 1] = BPF_EXIT_INSN();

tools/testing/selftests/bpf/test_tag.c

60

fd_prog = bpf_test_load_program(BPF_PROG_TYPE_SCHED_CLS, prog, insns, "", 0,

tools/testing/selftests/bpf/test_verifier.c

1002

prog[fixup_kfunc_btf_id->insn_idx].imm = btf_id;

tools/testing/selftests/bpf/test_verifier.c

1008

struct bpf_insn *prog, int *map_fds, int *fd_array)

tools/testing/selftests/bpf/test_verifier.c

1047

prog[*fixup_map_hash_8b].imm = map_fds[0];

tools/testing/selftests/bpf/test_verifier.c

1056

prog[*fixup_map_hash_48b].imm = map_fds[1];

tools/testing/selftests/bpf/test_verifier.c

1065

prog[*fixup_map_hash_16b].imm = map_fds[2];

tools/testing/selftests/bpf/test_verifier.c

1075

prog[*fixup_map_array_48b].imm = map_fds[3];

tools/testing/selftests/bpf/test_verifier.c

1083

prog[*fixup_prog1].imm = map_fds[4];

tools/testing/selftests/bpf/test_verifier.c

1091

prog[*fixup_prog2].imm = map_fds[5];

tools/testing/selftests/bpf/test_verifier.c

1099

prog[*fixup_map_in_map].imm = map_fds[6];

tools/testing/selftests/bpf/test_verifier.c

1107

prog[*fixup_cgroup_storage].imm = map_fds[7];

tools/testing/selftests/bpf/test_verifier.c

1115

prog[*fixup_percpu_cgroup_storage].imm = map_fds[8];

tools/testing/selftests/bpf/test_verifier.c

1123

prog[*fixup_map_sockmap].imm = map_fds[9];

tools/testing/selftests/bpf/test_verifier.c

1131

prog[*fixup_map_sockhash].imm = map_fds[10];

tools/testing/selftests/bpf/test_verifier.c

1139

prog[*fixup_map_xskmap].imm = map_fds[11];

tools/testing/selftests/bpf/test_verifier.c

1147

prog[*fixup_map_stacktrace].imm = map_fds[12];

tools/testing/selftests/bpf/test_verifier.c

1154

prog[*fixup_map_spin_lock].imm = map_fds[13];

tools/testing/selftests/bpf/test_verifier.c

1164

prog[*fixup_map_array_ro].imm = map_fds[14];

tools/testing/selftests/bpf/test_verifier.c

1174

prog[*fixup_map_array_wo].imm = map_fds[15];

tools/testing/selftests/bpf/test_verifier.c

1183

prog[*fixup_map_array_small].imm = map_fds[16];

tools/testing/selftests/bpf/test_verifier.c

1190

prog[*fixup_sk_storage_map].imm = map_fds[17];

tools/testing/selftests/bpf/test_verifier.c

1198

prog[*fixup_map_event_output].imm = map_fds[18];

tools/testing/selftests/bpf/test_verifier.c

1206

prog[*fixup_map_reuseport_array].imm = map_fds[19];

tools/testing/selftests/bpf/test_verifier.c

1214

prog[*fixup_map_ringbuf].imm = map_fds[20];

tools/testing/selftests/bpf/test_verifier.c

1221

prog[*fixup_map_timer].imm = map_fds[21];

tools/testing/selftests/bpf/test_verifier.c

1228

prog[*fixup_map_kptr].imm = map_fds[22];

tools/testing/selftests/bpf/test_verifier.c

1233

fixup_prog_kfuncs(prog, fd_array, test->fixup_kfunc_btf_id);

tools/testing/selftests/bpf/test_verifier.c

1509

struct bpf_insn *prog = test->insns;

tools/testing/selftests/bpf/test_verifier.c

1535

do_test_fixup(test, prog_type, prog, map_fds, &fd_array[1]);

tools/testing/selftests/bpf/test_verifier.c

1537

prog = test->fill_insns;

tools/testing/selftests/bpf/test_verifier.c

1540

prog_len = probe_filter_length(prog);

tools/testing/selftests/bpf/test_verifier.c

1603

fd_prog = bpf_prog_load(prog_type, NULL, "GPL", prog, prog_len, &opts);

tools/testing/selftests/bpf/test_verifier.c

577

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/test_verifier.c

582

return bpf_prog_load(prog_type, NULL, "GPL", prog, ARRAY_SIZE(prog), NULL);

tools/testing/selftests/bpf/test_verifier.c

588

struct bpf_insn prog[] = {

tools/testing/selftests/bpf/test_verifier.c

597

return bpf_prog_load(prog_type, NULL, "GPL", prog, ARRAY_SIZE(prog), NULL);

tools/testing/selftests/bpf/test_verifier.c

968

static void fixup_prog_kfuncs(struct bpf_insn *prog, int *fd_array,

tools/testing/selftests/bpf/test_verifier.c

997

prog[fixup_kfunc_btf_id->insn_idx].off = 1;

tools/testing/selftests/bpf/testing_helpers.c

292

struct bpf_program *prog;

tools/testing/selftests/bpf/testing_helpers.c

300

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/testing_helpers.c

301

if (!prog) {

tools/testing/selftests/bpf/testing_helpers.c

306

if (type != BPF_PROG_TYPE_UNSPEC && bpf_program__type(prog) != type)

tools/testing/selftests/bpf/testing_helpers.c

307

bpf_program__set_type(prog, type);

tools/testing/selftests/bpf/testing_helpers.c

309

flags = bpf_program__flags(prog) | testing_prog_flags();

tools/testing/selftests/bpf/testing_helpers.c

310

bpf_program__set_flags(prog, flags);

tools/testing/selftests/bpf/testing_helpers.c

317

*prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/veristat.c

1211

struct bpf_program *prog)

tools/testing/selftests/bpf/veristat.c

1233

if (memcmp(data + moff, &prog, ptr_sz) == 0)

tools/testing/selftests/bpf/veristat.c

1239

static void fixup_obj(struct bpf_object *obj, struct bpf_program *prog, const char *filename)

tools/testing/selftests/bpf/veristat.c

1256

mask_unrelated_struct_ops_progs(obj, map, prog);

tools/testing/selftests/bpf/veristat.c

1269

if (bpf_program__type(prog) == BPF_PROG_TYPE_EXT) {

tools/testing/selftests/bpf/veristat.c

1271

const char *prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/veristat.c

1302

bpf_program__set_type(prog, prog_type);

tools/testing/selftests/bpf/veristat.c

1303

bpf_program__set_expected_attach_type(prog, attach_type);

tools/testing/selftests/bpf/veristat.c

1606

static int process_prog(const char *filename, struct bpf_object *obj, struct bpf_program *prog)

tools/testing/selftests/bpf/veristat.c

1609

const char *prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/veristat.c

1620

if (!should_process_file_prog(base_filename, bpf_program__name(prog))) {

tools/testing/selftests/bpf/veristat.c

1650

bpf_program__set_log_buf(prog, buf, buf_sz);

tools/testing/selftests/bpf/veristat.c

1651

bpf_program__set_log_level(prog, log_level);

tools/testing/selftests/bpf/veristat.c

1654

fixup_obj(obj, prog, base_filename);

tools/testing/selftests/bpf/veristat.c

1657

bpf_program__set_flags(prog, bpf_program__flags(prog) | BPF_F_TEST_STATE_FREQ);

tools/testing/selftests/bpf/veristat.c

1659

bpf_program__set_flags(prog, bpf_program__flags(prog) | BPF_F_TEST_REG_INVARIANTS);

tools/testing/selftests/bpf/veristat.c

1673

stats->prog_name = strdup(bpf_program__name(prog));

tools/testing/selftests/bpf/veristat.c

1675

stats->stats[SIZE] = bpf_program__insn_cnt(prog);

tools/testing/selftests/bpf/veristat.c

1676

stats->stats[PROG_TYPE] = bpf_program__type(prog);

tools/testing/selftests/bpf/veristat.c

1677

stats->stats[ATTACH_TYPE] = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/veristat.c

1681

fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/veristat.c

2186

struct bpf_program *prog, *tprog, *lprog;

tools/testing/selftests/bpf/veristat.c

2224

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/veristat.c

2229

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/veristat.c

2230

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/veristat.c

2236

process_prog(filename, obj, prog);

tools/testing/selftests/bpf/veristat.c

2240

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/veristat.c

2241

const char *prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/xdp_features.c

282

struct bpf_program *prog;

tools/testing/selftests/bpf/xdp_features.c

303

prog = skel->progs.xdp_do_tx;

tools/testing/selftests/bpf/xdp_features.c

306

prog = skel->progs.xdp_do_drop;

tools/testing/selftests/bpf/xdp_features.c

309

prog = skel->progs.xdp_do_aborted;

tools/testing/selftests/bpf/xdp_features.c

312

prog = skel->progs.xdp_do_pass;

tools/testing/selftests/bpf/xdp_features.c

326

prog = skel->progs.xdp_do_redirect;

tools/testing/selftests/bpf/xdp_features.c

333

err = bpf_xdp_attach(env.ifindex, bpf_program__fd(prog), flags, NULL);

tools/testing/selftests/bpf/xdp_features.c

578

struct bpf_program *prog;

tools/testing/selftests/bpf/xdp_features.c

612

prog = skel->progs.xdp_tester_check_tx;

tools/testing/selftests/bpf/xdp_features.c

614

prog = skel->progs.xdp_tester_check_rx;

tools/testing/selftests/bpf/xdp_features.c

616

err = bpf_xdp_attach(env.ifindex, bpf_program__fd(prog), flags, NULL);

tools/testing/selftests/bpf/xdp_hw_metadata.c

738

struct bpf_program *prog;

tools/testing/selftests/bpf/xdp_hw_metadata.c

846

prog = bpf_object__find_program_by_name(bpf_obj->obj, "rx");

tools/testing/selftests/bpf/xdp_hw_metadata.c

847

bpf_program__set_ifindex(prog, ifindex);

tools/testing/selftests/bpf/xdp_hw_metadata.c

848

bpf_program__set_flags(prog, BPF_F_XDP_DEV_BOUND_ONLY);

tools/testing/selftests/bpf/xdp_synproxy.c

193

struct bpf_program *prog;

tools/testing/selftests/bpf/xdp_synproxy.c

212

prog = bpf_object__find_program_by_name(obj, tc ? "syncookie_tc" : "syncookie_xdp");

tools/testing/selftests/bpf/xdp_synproxy.c

213

if (!prog) {

tools/testing/selftests/bpf/xdp_synproxy.c

218

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/xdping.c

73

static void show_usage(const char *prog)

tools/testing/selftests/bpf/xdping.c

84

prog, XDPING_DEFAULT_COUNT, XDPING_MAX_COUNT);

tools/testing/selftests/bpf/xsk.c

426

int xsk_attach_xdp_program(struct bpf_program *prog, int ifindex, u32 xdp_flags)

tools/testing/selftests/bpf/xsk.c

430

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/xsk.h

206

int xsk_attach_xdp_program(struct bpf_program *prog, int ifindex, u32 xdp_flags);

tools/testing/selftests/drivers/net/hw/toeplitz.c

329

struct sock_fprog prog = {};

tools/testing/selftests/drivers/net/hw/toeplitz.c

331

prog.filter = filter;

tools/testing/selftests/drivers/net/hw/toeplitz.c

332

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/drivers/net/hw/toeplitz.c

333

if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))

tools/testing/selftests/drivers/net/hw/toeplitz.c

358

struct sock_fprog prog = {};

tools/testing/selftests/drivers/net/hw/toeplitz.c

360

prog.filter = filter;

tools/testing/selftests/drivers/net/hw/toeplitz.c

361

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/drivers/net/hw/toeplitz.c

362

if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))

tools/testing/selftests/gpio/gpio-mockup-cdev.c

91

static void usage(char *prog)

tools/testing/selftests/gpio/gpio-mockup-cdev.c

93

printf("Usage: %s [-l] [-b <bias>] [-s <value>] [-u <uAPI>] <gpiochip> <offset>\n", prog);

tools/testing/selftests/hid/hid_bpf.c

90

struct bpf_program *prog;

tools/testing/selftests/hid/hid_bpf.c

94

prog = bpf_object__find_program_by_name(*self->skel->skeleton->obj,

tools/testing/selftests/hid/hid_bpf.c

96

ASSERT_OK_PTR(prog) TH_LOG("can not find program by name '%s'", programs[i].name);

tools/testing/selftests/hid/hid_bpf.c

98

bpf_program__set_autoload(prog, true);

tools/testing/selftests/mm/uffd-unit-tests.c

1693

static void usage(const char *prog)

tools/testing/selftests/mm/uffd-unit-tests.c

1695

printf("usage: %s [-f TESTNAME]\n", prog);

tools/testing/selftests/net/lib/csum.c

507

struct sock_fprog prog = {};

tools/testing/selftests/net/lib/csum.c

509

prog.filter = filter;

tools/testing/selftests/net/lib/csum.c

510

prog.len = ARRAY_SIZE(filter);

tools/testing/selftests/net/lib/csum.c

511

if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog)))

tools/testing/selftests/net/nettest.c

1948

static void print_usage(char *prog)

tools/testing/selftests/net/nettest.c

2007

, prog, DEFAULT_PORT);

tools/testing/selftests/net/psock_fanout.c

177

struct bpf_insn prog[] = {

tools/testing/selftests/net/psock_fanout.c

193

attr.insns = (unsigned long) prog;

tools/testing/selftests/net/psock_fanout.c

194

attr.insn_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/net/reuseport_bpf.c

112

attr.insn_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/net/reuseport_bpf.c

113

attr.insns = (unsigned long) &prog;

tools/testing/selftests/net/reuseport_bpf.c

98

const struct bpf_insn prog[] = {

tools/testing/selftests/net/reuseport_bpf_numa.c

79

const struct bpf_insn prog[] = {

tools/testing/selftests/net/reuseport_bpf_numa.c

89

attr.insn_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/net/reuseport_bpf_numa.c

90

attr.insns = (unsigned long) &prog;

tools/testing/selftests/powerpc/alignment/alignment_handler.c

605

void usage(char *prog)

tools/testing/selftests/powerpc/alignment/alignment_handler.c

607

printf("Usage: %s [options] [path [offset]]\n", prog);

tools/testing/selftests/powerpc/dscr/dscr_inherit_exec_test.c

106

prog = argv[0];

tools/testing/selftests/powerpc/dscr/dscr_inherit_exec_test.c

19

static char *prog;

tools/testing/selftests/powerpc/dscr/dscr_inherit_exec_test.c

87

execlp(prog, prog, "exec", dscr_str, NULL);

tools/testing/selftests/seccomp/seccomp_benchmark.c

180

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_benchmark.c

238

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1069

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

1082

memset(&self->prog, 0, sizeof(self->prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

1083

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1084

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1085

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1086

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1091

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1092

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1102

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1117

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1153

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1674

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

1691

memset(&self->prog, 0, sizeof(self->prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

1692

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1693

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1694

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1695

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1708

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1709

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1719

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

1735

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2051

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2158

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2192

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2259

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2266

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2282

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2289

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2307

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2314

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2326

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2338

ret = seccomp(-1, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2351

ret = seccomp(SECCOMP_SET_MODE_STRICT, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2357

ret = seccomp(SECCOMP_SET_MODE_FILTER, -1, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2366

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2378

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2389

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2505

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2517

&prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2535

struct sock_fprog *prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2601

self->sibling[0].prog = &self->root_prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2608

self->sibling[1].prog = &self->root_prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2649

me->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2686

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2696

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

3051

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3078

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3313

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3320

SECCOMP_FILTER_FLAG_LOG, &prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

3321

EXPECT_EQ(0, seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

3370

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3375

return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

3391

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3417

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3418

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3419

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3420

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

416

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

429

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

450

struct sock_fprog prog = { };

tools/testing/selftests/seccomp/seccomp_bpf.c

462

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

463

prog.len = count;

tools/testing/selftests/seccomp/seccomp_bpf.c

466

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

468

TH_LOG("Installing %d insn filter was allowed", prog.len);

tools/testing/selftests/seccomp/seccomp_bpf.c

472

prog.len -= 1;

tools/testing/selftests/seccomp/seccomp_bpf.c

473

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

475

TH_LOG("Installing %d insn filter wasn't allowed", prog.len);

tools/testing/selftests/seccomp/seccomp_bpf.c

487

struct sock_fprog prog = { };

tools/testing/selftests/seccomp/seccomp_bpf.c

499

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

500

prog.len = 1;

tools/testing/selftests/seccomp/seccomp_bpf.c

502

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

505

prog.len = count;

tools/testing/selftests/seccomp/seccomp_bpf.c

509

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

5197

static int run_probed_with_filter(struct sock_fprog *prog)

tools/testing/selftests/seccomp/seccomp_bpf.c

5200

seccomp(SECCOMP_SET_MODE_FILTER, 0, prog)) {

tools/testing/selftests/seccomp/seccomp_bpf.c

5219

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5224

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5236

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

524

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5241

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5258

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5263

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5281

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5286

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

533

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

547

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

559

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

572

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

581

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

589

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

598

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

608

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

618

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

630

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

639

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

652

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

661

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

673

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

682

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

695

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

705

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

728

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

740

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

767

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

782

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

952

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

961

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/tracing/rtla/src/timerlat_bpf.c

107

prog = NULL;

tools/tracing/rtla/src/timerlat_bpf.c

12

static struct bpf_program *prog;

tools/tracing/rtla/src/timerlat_bpf.c

222

prog = bpf_object__find_program_by_name(obj, "action_handler");

tools/tracing/rtla/src/timerlat_bpf.c

223

if (!prog) {

tools/tracing/rtla/src/timerlat_bpf.c

229

err = timerlat_bpf_set_action(prog);

tools/tracing/rtla/src/timerlat_bpf.c

238

prog = NULL;

tools/tracing/rtla/src/timerlat_bpf.c

69

static int timerlat_bpf_set_action(struct bpf_program *prog)

tools/tracing/rtla/src/timerlat_bpf.c

71

unsigned int key = 0, value = bpf_program__fd(prog);

usr/gen_init_cpio.c

570

static void usage(const char *prog)

usr/gen_init_cpio.c

615

prog);