arch/arc/net/bpf_jit_core.c

1016

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

arch/arc/net/bpf_jit_core.c

1045

const struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1057

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

arch/arc/net/bpf_jit_core.c

1104

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

arch/arc/net/bpf_jit_core.c

121

static void vm_dump(const struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1212

struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1218

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

arch/arc/net/bpf_jit_core.c

1231

prog->aux->jit_data = NULL;

arch/arc/net/bpf_jit_core.c

1232

bpf_prog_fill_jited_linfo(prog, ctx->bpf2insn);

arch/arc/net/bpf_jit_core.c

1236

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

arch/arc/net/bpf_jit_core.c

1237

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

arch/arc/net/bpf_jit_core.c

1238

prog->jited = 1;

arch/arc/net/bpf_jit_core.c

125

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

arch/arc/net/bpf_jit_core.c

1251

static inline int check_jit_context(const struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1253

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

arch/arc/net/bpf_jit_core.c

1265

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

arch/arc/net/bpf_jit_core.c

1272

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

arch/arc/net/bpf_jit_core.c

1273

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

arch/arc/net/bpf_jit_core.c

1298

const struct bpf_prog *prog = ctx->prog;

arch/arc/net/bpf_jit_core.c

1302

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

arch/arc/net/bpf_jit_core.c

1303

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

arch/arc/net/bpf_jit_core.c

1327

static struct bpf_prog *do_normal_pass(struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1332

if (!prog->jit_requested)

arch/arc/net/bpf_jit_core.c

1333

return prog;

arch/arc/net/bpf_jit_core.c

1335

if (jit_ctx_init(&ctx, prog)) {

arch/arc/net/bpf_jit_core.c

1337

return prog;

arch/arc/net/bpf_jit_core.c

1343

return prog;

arch/arc/net/bpf_jit_core.c

1348

return prog;

arch/arc/net/bpf_jit_core.c

1353

return prog;

arch/arc/net/bpf_jit_core.c

1356

return ctx.prog;

arch/arc/net/bpf_jit_core.c

1366

static struct bpf_prog *do_extra_pass(struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1371

if (check_jit_context(prog))

arch/arc/net/bpf_jit_core.c

1372

return prog;

arch/arc/net/bpf_jit_core.c

1374

if (jit_ctx_init(&ctx, prog)) {

arch/arc/net/bpf_jit_core.c

1376

return prog;

arch/arc/net/bpf_jit_core.c

1381

return prog;

arch/arc/net/bpf_jit_core.c

1386

return prog;

arch/arc/net/bpf_jit_core.c

1391

return prog;

arch/arc/net/bpf_jit_core.c

1394

return ctx.prog;

arch/arc/net/bpf_jit_core.c

1403

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/arc/net/bpf_jit_core.c

1405

vm_dump(prog);

arch/arc/net/bpf_jit_core.c

1408

if (!prog->jited)

arch/arc/net/bpf_jit_core.c

1409

return do_normal_pass(prog);

arch/arc/net/bpf_jit_core.c

1411

return do_extra_pass(prog);

arch/arc/net/bpf_jit_core.c

1413

return prog;

arch/arc/net/bpf_jit_core.c

143

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

arch/arc/net/bpf_jit_core.c

151

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

arch/arc/net/bpf_jit_core.c

156

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

arch/arc/net/bpf_jit_core.c

160

ctx->prog = prog;

arch/arc/net/bpf_jit_core.c

163

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

arch/arc/net/bpf_jit_core.c

165

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

arch/arc/net/bpf_jit_core.c

166

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

arch/arc/net/bpf_jit_core.c

223

ctx->prog->bpf_func = NULL;

arch/arc/net/bpf_jit_core.c

224

ctx->prog->jited = 0;

arch/arc/net/bpf_jit_core.c

225

ctx->prog->jited_len = 0;

arch/arc/net/bpf_jit_core.c

241

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

arch/arc/net/bpf_jit_core.c

243

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

arch/arc/net/bpf_jit_core.c

253

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

arch/arc/net/bpf_jit_core.c

322

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

arch/arc/net/bpf_jit_core.c

370

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

arch/arc/net/bpf_jit_core.c

372

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

arch/arc/net/bpf_jit_core.c

415

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

arch/arc/net/bpf_jit_core.c

664

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

arch/arc/net/bpf_jit_core.c

700

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

arch/arc/net/bpf_jit_core.c

727

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

arch/arc/net/bpf_jit_core.c

99

struct bpf_prog *prog;

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

2081

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

arch/arm/net/bpf_jit_32.c

2107

const struct bpf_prog *prog = ctx->prog;

arch/arm/net/bpf_jit_32.c

2110

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

arch/arm/net/bpf_jit_32.c

2111

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

arch/arm/net/bpf_jit_32.c

2151

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/arm/net/bpf_jit_32.c

2162

if (!prog->jit_requested)

arch/arm/net/bpf_jit_32.c

2163

return prog;

arch/arm/net/bpf_jit_32.c

2166

ctx.prog = prog;

arch/arm/net/bpf_jit_32.c

2172

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

arch/arm/net/bpf_jit_32.c

2174

return prog;

arch/arm/net/bpf_jit_32.c

2249

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

arch/arm/net/bpf_jit_32.c

2253

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

arch/arm/net/bpf_jit_32.c

2254

prog->jited = 1;

arch/arm/net/bpf_jit_32.c

2255

prog->jited_len = image_size;

arch/arm/net/bpf_jit_32.c

2265

return 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

1155

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

arch/arm64/net/bpf_jit_comp.c

1156

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

arch/arm64/net/bpf_jit_comp.c

1159

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

arch/arm64/net/bpf_jit_comp.c

1267

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

arch/arm64/net/bpf_jit_comp.c

1279

if (bpf_insn_is_indirect_target(env, ctx->prog, i))

arch/arm64/net/bpf_jit_comp.c

1652

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

arch/arm64/net/bpf_jit_comp.c

1675

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

arch/arm64/net/bpf_jit_comp.c

1980

const struct bpf_prog *prog = ctx->prog;

arch/arm64/net/bpf_jit_comp.c

1992

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

arch/arm64/net/bpf_jit_comp.c

1993

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

arch/arm64/net/bpf_jit_comp.c

2034

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

arch/arm64/net/bpf_jit_comp.c

2055

struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

2067

bpf_jit_get_prog_name(prog));

arch/arm64/net/bpf_jit_comp.c

2080

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

2087

bool was_classic = bpf_prog_was_classic(prog);

arch/arm64/net/bpf_jit_comp.c

2097

if (!prog->jit_requested)

arch/arm64/net/bpf_jit_comp.c

2098

return prog;

arch/arm64/net/bpf_jit_comp.c

2100

jit_data = prog->aux->jit_data;

arch/arm64/net/bpf_jit_comp.c

2104

return prog;

arch/arm64/net/bpf_jit_comp.c

2105

prog->aux->jit_data = jit_data;

arch/arm64/net/bpf_jit_comp.c

2107

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

2108

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

arch/arm64/net/bpf_jit_comp.c

2113

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

arch/arm64/net/bpf_jit_comp.c

2120

prog->aux->priv_stack_ptr = priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

2134

ctx.prog = prog;

arch/arm64/net/bpf_jit_comp.c

2136

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

arch/arm64/net/bpf_jit_comp.c

2140

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

arch/arm64/net/bpf_jit_comp.c

2141

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

arch/arm64/net/bpf_jit_comp.c

2143

out_cnt = bpf_out_stack_arg_cnt(env, prog);

arch/arm64/net/bpf_jit_comp.c

2170

extable_size = prog->aux->num_exentries *

arch/arm64/net/bpf_jit_comp.c

2196

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

arch/arm64/net/bpf_jit_comp.c

2235

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

arch/arm64/net/bpf_jit_comp.c

2237

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

arch/arm64/net/bpf_jit_comp.c

2260

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

arch/arm64/net/bpf_jit_comp.c

2261

prog->jited = 1;

arch/arm64/net/bpf_jit_comp.c

2262

prog->jited_len = prog_size - cfi_get_offset();

arch/arm64/net/bpf_jit_comp.c

2264

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

arch/arm64/net/bpf_jit_comp.c

2268

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

arch/arm64/net/bpf_jit_comp.c

2270

bpf_prog_fill_jited_linfo(prog, ctx.offset + 1);

arch/arm64/net/bpf_jit_comp.c

2277

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

arch/arm64/net/bpf_jit_comp.c

2281

prog->aux->priv_stack_ptr = NULL;

arch/arm64/net/bpf_jit_comp.c

2286

prog->aux->jit_data = NULL;

arch/arm64/net/bpf_jit_comp.c

2289

return prog;

arch/arm64/net/bpf_jit_comp.c

2293

prog->bpf_func = NULL;

arch/arm64/net/bpf_jit_comp.c

2294

prog->jited = 0;

arch/arm64/net/bpf_jit_comp.c

2295

prog->jited_len = 0;

arch/arm64/net/bpf_jit_comp.c

2345

struct bpf_prog *p = node->link->prog;

arch/arm64/net/bpf_jit_comp.c

3218

void bpf_jit_free(struct bpf_prog *prog)

arch/arm64/net/bpf_jit_comp.c

3220

if (prog->jited) {

arch/arm64/net/bpf_jit_comp.c

3221

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

arch/arm64/net/bpf_jit_comp.c

3235

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

arch/arm64/net/bpf_jit_comp.c

3236

hdr = bpf_jit_binary_pack_hdr(prog);

arch/arm64/net/bpf_jit_comp.c

3238

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/arm64/net/bpf_jit_comp.c

3240

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

arch/arm64/net/bpf_jit_comp.c

3242

priv_stack_check_guard(priv_stack_ptr, priv_stack_alloc_sz, prog);

arch/arm64/net/bpf_jit_comp.c

3243

free_percpu(prog->aux->priv_stack_ptr);

arch/arm64/net/bpf_jit_comp.c

3245

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/arm64/net/bpf_jit_comp.c

3248

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

567

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

arch/arm64/net/bpf_jit_comp.c

606

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

arch/arm64/net/bpf_jit_comp.c

611

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

arch/arm64/net/bpf_jit_comp.c

79

const struct bpf_prog *prog;

arch/arm64/net/bpf_jit_comp.c

867

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

arch/loongarch/net/bpf_jit.c

1178

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

arch/loongarch/net/bpf_jit.c

1192

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

arch/loongarch/net/bpf_jit.c

1220

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

arch/loongarch/net/bpf_jit.c

136

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

137

const bool is_main_prog = !bpf_is_subprog(prog);

arch/loongarch/net/bpf_jit.c

139

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

arch/loongarch/net/bpf_jit.c

1477

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

1479

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

arch/loongarch/net/bpf_jit.c

1480

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

arch/loongarch/net/bpf_jit.c

1533

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

arch/loongarch/net/bpf_jit.c

1710

struct bpf_prog *p = n->link->prog;

arch/loongarch/net/bpf_jit.c

2197

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/loongarch/net/bpf_jit.c

2211

if (!prog->jit_requested)

arch/loongarch/net/bpf_jit.c

2212

return prog;

arch/loongarch/net/bpf_jit.c

2214

jit_data = prog->aux->jit_data;

arch/loongarch/net/bpf_jit.c

2218

return prog;

arch/loongarch/net/bpf_jit.c

2219

prog->aux->jit_data = jit_data;

arch/loongarch/net/bpf_jit.c

2233

ctx.prog = prog;

arch/loongarch/net/bpf_jit.c

2234

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

arch/loongarch/net/bpf_jit.c

2235

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

arch/loongarch/net/bpf_jit.c

2237

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

arch/loongarch/net/bpf_jit.c

2248

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

arch/loongarch/net/bpf_jit.c

2260

bpf_prog_was_classic(prog));

arch/loongarch/net/bpf_jit.c

2275

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

arch/loongarch/net/bpf_jit.c

2292

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

arch/loongarch/net/bpf_jit.c

2294

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

arch/loongarch/net/bpf_jit.c

2317

prog->jited = 1;

arch/loongarch/net/bpf_jit.c

2318

prog->jited_len = prog_size;

arch/loongarch/net/bpf_jit.c

2319

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

arch/loongarch/net/bpf_jit.c

2321

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

arch/loongarch/net/bpf_jit.c

2325

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

arch/loongarch/net/bpf_jit.c

2327

bpf_prog_fill_jited_linfo(prog, ctx.offset + 1);

arch/loongarch/net/bpf_jit.c

2332

prog->aux->jit_data = NULL;

arch/loongarch/net/bpf_jit.c

2335

return prog;

arch/loongarch/net/bpf_jit.c

2339

prog->bpf_func = NULL;

arch/loongarch/net/bpf_jit.c

2340

prog->jited = 0;

arch/loongarch/net/bpf_jit.c

2341

prog->jited_len = 0;

arch/loongarch/net/bpf_jit.c

2351

void bpf_jit_free(struct bpf_prog *prog)

arch/loongarch/net/bpf_jit.c

2353

if (prog->jited) {

arch/loongarch/net/bpf_jit.c

2354

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

arch/loongarch/net/bpf_jit.c

2367

hdr = bpf_jit_binary_pack_hdr(prog);

arch/loongarch/net/bpf_jit.c

2369

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/loongarch/net/bpf_jit.c

2372

bpf_prog_unlock_free(prog);

arch/loongarch/net/bpf_jit.c

52

const struct bpf_prog *prog = ctx->prog;

arch/loongarch/net/bpf_jit.c

53

const bool is_main_prog = !bpf_is_subprog(prog);

arch/loongarch/net/bpf_jit.c

661

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

arch/loongarch/net/bpf_jit.c

669

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

arch/loongarch/net/bpf_jit.c

672

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

arch/loongarch/net/bpf_jit.c

720

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

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

1007

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

arch/mips/net/bpf_jit_comp.c

1009

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

arch/mips/net/bpf_jit_comp.c

1010

prog->jited = 1;

arch/mips/net/bpf_jit_comp.c

1011

prog->jited_len = image_size;

arch/mips/net/bpf_jit_comp.c

1015

return 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_verifier_env *env, struct bpf_prog *prog)

arch/mips/net/bpf_jit_comp.c

925

if (!prog->jit_requested)

arch/mips/net/bpf_jit_comp.c

926

return prog;

arch/mips/net/bpf_jit_comp.c

929

ctx.program = prog;

arch/mips/net/bpf_jit_comp.c

935

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

arch/mips/net/bpf_jit_comp.c

998

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

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

124

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

arch/parisc/net/bpf_jit_core.c

139

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

arch/parisc/net/bpf_jit_core.c

144

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

arch/parisc/net/bpf_jit_core.c

152

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

arch/parisc/net/bpf_jit_core.c

153

prog->jited = 1;

arch/parisc/net/bpf_jit_core.c

154

prog->jited_len = prog_size;

arch/parisc/net/bpf_jit_core.c

156

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

arch/parisc/net/bpf_jit_core.c

158

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

arch/parisc/net/bpf_jit_core.c

160

bpf_prog_fill_jited_linfo(prog, ctx->offset);

arch/parisc/net/bpf_jit_core.c

164

prog->aux->jit_data = NULL;

arch/parisc/net/bpf_jit_core.c

170

return prog;

arch/parisc/net/bpf_jit_core.c

174

prog->bpf_func = NULL;

arch/parisc/net/bpf_jit_core.c

175

prog->jited = 0;

arch/parisc/net/bpf_jit_core.c

176

prog->jited_len = 0;

arch/parisc/net/bpf_jit_core.c

18

const struct bpf_prog *prog = ctx->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_verifier_env *env, struct bpf_prog *prog)

arch/parisc/net/bpf_jit_core.c

52

if (!prog->jit_requested)

arch/parisc/net/bpf_jit_core.c

53

return prog;

arch/parisc/net/bpf_jit_core.c

55

jit_data = prog->aux->jit_data;

arch/parisc/net/bpf_jit_core.c

59

return prog;

arch/parisc/net/bpf_jit_core.c

60

prog->aux->jit_data = jit_data;

arch/parisc/net/bpf_jit_core.c

71

ctx->prog = prog;

arch/parisc/net/bpf_jit_core.c

72

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

arch/parisc/net/bpf_jit_core.c

75

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

arch/parisc/net/bpf_jit_core.c

95

extable_size = prog->aux->num_exentries *

arch/powerpc/net/bpf_jit_comp.c

608

struct bpf_prog *p = n->link->prog;

arch/riscv/net/bpf_jit.h

72

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

1819

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

arch/riscv/net/bpf_jit_comp64.c

1828

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

arch/riscv/net/bpf_jit_comp64.c

1856

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

arch/riscv/net/bpf_jit_comp64.c

2006

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 = node->link->prog;

arch/riscv/net/bpf_jit_core.c

104

extable_size = prog->aux->num_exentries *

arch/riscv/net/bpf_jit_core.c

113

bpf_prog_was_classic(prog));

arch/riscv/net/bpf_jit_core.c

140

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

arch/riscv/net/bpf_jit_core.c

147

bpf_jit_build_prologue(ctx, bpf_is_subprog(prog));

arch/riscv/net/bpf_jit_core.c

153

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

arch/riscv/net/bpf_jit_core.c

155

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

arch/riscv/net/bpf_jit_core.c

164

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

arch/riscv/net/bpf_jit_core.c

165

prog->jited = 1;

arch/riscv/net/bpf_jit_core.c

166

prog->jited_len = prog_size - cfi_get_offset();

arch/riscv/net/bpf_jit_core.c

168

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

arch/riscv/net/bpf_jit_core.c

169

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

arch/riscv/net/bpf_jit_core.c

171

bpf_prog_fill_jited_linfo(prog, ctx->offset);

arch/riscv/net/bpf_jit_core.c

175

prog->aux->jit_data = NULL;

arch/riscv/net/bpf_jit_core.c

178

return prog;

arch/riscv/net/bpf_jit_core.c

182

prog->bpf_func = NULL;

arch/riscv/net/bpf_jit_core.c

183

prog->jited = 0;

arch/riscv/net/bpf_jit_core.c

184

prog->jited_len = 0;

arch/riscv/net/bpf_jit_core.c

21

const struct bpf_prog *prog = ctx->prog;

arch/riscv/net/bpf_jit_core.c

224

void bpf_jit_free(struct bpf_prog *prog)

arch/riscv/net/bpf_jit_core.c

226

if (prog->jited) {

arch/riscv/net/bpf_jit_core.c

227

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

arch/riscv/net/bpf_jit_core.c

239

hdr = bpf_jit_binary_pack_hdr(prog);

arch/riscv/net/bpf_jit_core.c

24

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

arch/riscv/net/bpf_jit_core.c

241

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/riscv/net/bpf_jit_core.c

244

bpf_prog_unlock_free(prog);

arch/riscv/net/bpf_jit_core.c

25

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

arch/riscv/net/bpf_jit_core.c

44

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/riscv/net/bpf_jit_core.c

52

if (!prog->jit_requested)

arch/riscv/net/bpf_jit_core.c

53

return prog;

arch/riscv/net/bpf_jit_core.c

55

jit_data = prog->aux->jit_data;

arch/riscv/net/bpf_jit_core.c

59

return prog;

arch/riscv/net/bpf_jit_core.c

61

prog->aux->jit_data = jit_data;

arch/riscv/net/bpf_jit_core.c

72

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

arch/riscv/net/bpf_jit_core.c

73

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

arch/riscv/net/bpf_jit_core.c

74

ctx->prog = prog;

arch/riscv/net/bpf_jit_core.c

75

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

arch/riscv/net/bpf_jit_core.c

82

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

arch/riscv/net/bpf_jit_core.c

91

bpf_jit_build_prologue(ctx, bpf_is_subprog(prog));

arch/s390/net/bpf_jit_comp.c

2545

struct bpf_prog *p = node->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_verifier_env *env, struct bpf_prog *prog)

arch/sparc/net/bpf_jit_comp_64.c

1490

if (!prog->jit_requested)

arch/sparc/net/bpf_jit_comp_64.c

1491

return prog;

arch/sparc/net/bpf_jit_comp_64.c

1493

jit_data = prog->aux->jit_data;

arch/sparc/net/bpf_jit_comp_64.c

1497

return prog;

arch/sparc/net/bpf_jit_comp_64.c

1498

prog->aux->jit_data = jit_data;

arch/sparc/net/bpf_jit_comp_64.c

1512

ctx.prog = prog;

arch/sparc/net/bpf_jit_comp_64.c

1514

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

arch/sparc/net/bpf_jit_comp_64.c

1521

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

arch/sparc/net/bpf_jit_comp_64.c

1577

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

arch/sparc/net/bpf_jit_comp_64.c

1581

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

arch/sparc/net/bpf_jit_comp_64.c

1592

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

arch/sparc/net/bpf_jit_comp_64.c

1593

prog->jited = 1;

arch/sparc/net/bpf_jit_comp_64.c

1594

prog->jited_len = image_size;

arch/sparc/net/bpf_jit_comp_64.c

1596

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

arch/sparc/net/bpf_jit_comp_64.c

1597

bpf_prog_fill_jited_linfo(prog, ctx.offset);

arch/sparc/net/bpf_jit_comp_64.c

1601

prog->aux->jit_data = NULL;

arch/sparc/net/bpf_jit_comp_64.c

1604

return prog;

arch/sparc/net/bpf_jit_comp_64.c

1608

prog->bpf_func = NULL;

arch/sparc/net/bpf_jit_comp_64.c

1609

prog->jited = 0;

arch/sparc/net/bpf_jit_comp_64.c

1610

prog->jited_len = 0;

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

1001

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1006

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1018

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1024

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1050

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1056

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1070

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1075

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1082

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1090

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1096

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1104

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1110

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1116

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1139

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

arch/x86/net/bpf_jit_comp.c

1140

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1146

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1162

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

arch/x86/net/bpf_jit_comp.c

1163

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1168

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1188

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

arch/x86/net/bpf_jit_comp.c

1189

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1194

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1210

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

arch/x86/net/bpf_jit_comp.c

1211

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1219

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

arch/x86/net/bpf_jit_comp.c

1221

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

arch/x86/net/bpf_jit_comp.c

1227

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1254

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

arch/x86/net/bpf_jit_comp.c

1255

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1261

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1281

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

arch/x86/net/bpf_jit_comp.c

1282

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1293

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1313

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

arch/x86/net/bpf_jit_comp.c

1315

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1336

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1341

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

arch/x86/net/bpf_jit_comp.c

1369

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

arch/x86/net/bpf_jit_comp.c

1371

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1379

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1421

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

arch/x86/net/bpf_jit_comp.c

1422

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1564

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1594

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1600

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1604

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

arch/x86/net/bpf_jit_comp.c

1606

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1611

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1614

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

arch/x86/net/bpf_jit_comp.c

1624

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1627

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

arch/x86/net/bpf_jit_comp.c

1642

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

1652

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

arch/x86/net/bpf_jit_comp.c

1654

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

arch/x86/net/bpf_jit_comp.c

1677

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

1696

u8 *ip, *prog = temp;

arch/x86/net/bpf_jit_comp.c

1737

emit_prologue(&prog, image, stack_depth,

arch/x86/net/bpf_jit_comp.c

1741

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

arch/x86/net/bpf_jit_comp.c

1751

push_r12(&prog);

arch/x86/net/bpf_jit_comp.c

1752

push_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

1755

push_r12(&prog);

arch/x86/net/bpf_jit_comp.c

1756

push_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

1794

emit_sub_rsp(&prog, outgoing_rsp);

arch/x86/net/bpf_jit_comp.c

1797

emit_mov_imm64(&prog, X86_REG_R12,

arch/x86/net/bpf_jit_comp.c

1801

emit_priv_frame_ptr(&prog, priv_frame_ptr);

arch/x86/net/bpf_jit_comp.c

1803

ilen = prog - temp;

arch/x86/net/bpf_jit_comp.c

1808

prog = temp;

arch/x86/net/bpf_jit_comp.c

1833

ip = image + addrs[i - 1] + (prog - temp);

arch/x86/net/bpf_jit_comp.c

1847

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

1857

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

arch/x86/net/bpf_jit_comp.c

1859

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1863

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1870

maybe_emit_1mod(&prog, dst_reg, true);

arch/x86/net/bpf_jit_comp.c

1877

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

arch/x86/net/bpf_jit_comp.c

1882

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

arch/x86/net/bpf_jit_comp.c

1899

emit_mov_reg(&prog,

arch/x86/net/bpf_jit_comp.c

1903

emit_movsx_reg(&prog, insn->off,

arch/x86/net/bpf_jit_comp.c

1911

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

1926

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

1966

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

arch/x86/net/bpf_jit_comp.c

1971

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

arch/x86/net/bpf_jit_comp.c

2007

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

arch/x86/net/bpf_jit_comp.c

2017

maybe_emit_1mod(&prog, src_reg, is64);

arch/x86/net/bpf_jit_comp.c

2026

maybe_emit_1mod(&prog, src_reg, is64);

arch/x86/net/bpf_jit_comp.c

2033

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

arch/x86/net/bpf_jit_comp.c

2037

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

arch/x86/net/bpf_jit_comp.c

2048

maybe_emit_mod(&prog, dst_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

2064

maybe_emit_mod(&prog, src_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

2078

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2112

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

arch/x86/net/bpf_jit_comp.c

2131

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2232

emit_mov_imm64(&prog, X86_REG_R9, imm32 >> 31, (u32)imm32);

arch/x86/net/bpf_jit_comp.c

2270

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

arch/x86/net/bpf_jit_comp.c

2277

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2278

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

arch/x86/net/bpf_jit_comp.c

2293

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2296

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

arch/x86/net/bpf_jit_comp.c

2298

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

arch/x86/net/bpf_jit_comp.c

2300

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

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

2395

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

arch/x86/net/bpf_jit_comp.c

2403

maybe_emit_1mod(&prog, AUX_REG, true);

arch/x86/net/bpf_jit_comp.c

2408

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

arch/x86/net/bpf_jit_comp.c

2412

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

arch/x86/net/bpf_jit_comp.c

2416

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

arch/x86/net/bpf_jit_comp.c

2421

end_of_jmp = prog;

arch/x86/net/bpf_jit_comp.c

2424

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

arch/x86/net/bpf_jit_comp.c

2429

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2434

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

arch/x86/net/bpf_jit_comp.c

2436

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

arch/x86/net/bpf_jit_comp.c

2444

start_of_ldx[-1] = prog - start_of_ldx;

arch/x86/net/bpf_jit_comp.c

2479

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

arch/x86/net/bpf_jit_comp.c

2507

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

arch/x86/net/bpf_jit_comp.c

2513

branch_target = prog;

arch/x86/net/bpf_jit_comp.c

2515

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

arch/x86/net/bpf_jit_comp.c

2521

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

arch/x86/net/bpf_jit_comp.c

2522

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

arch/x86/net/bpf_jit_comp.c

2526

err = emit_atomic_rmw(&prog, BPF_CMPXCHG,

arch/x86/net/bpf_jit_comp.c

2536

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

arch/x86/net/bpf_jit_comp.c

2538

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

arch/x86/net/bpf_jit_comp.c

2540

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

arch/x86/net/bpf_jit_comp.c

2545

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

arch/x86/net/bpf_jit_comp.c

2548

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

arch/x86/net/bpf_jit_comp.c

2563

start_of_ldx = prog;

arch/x86/net/bpf_jit_comp.c

2566

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

arch/x86/net/bpf_jit_comp.c

2570

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

arch/x86/net/bpf_jit_comp.c

2587

push_r9(&prog);

arch/x86/net/bpf_jit_comp.c

2590

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

arch/x86/net/bpf_jit_comp.c

2591

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

arch/x86/net/bpf_jit_comp.c

2594

pop_r9(&prog);

arch/x86/net/bpf_jit_comp.c

2602

&prog,

arch/x86/net/bpf_jit_comp.c

2609

&prog,

arch/x86/net/bpf_jit_comp.c

2638

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2646

maybe_emit_mod(&prog, dst_reg, src_reg,

arch/x86/net/bpf_jit_comp.c

2654

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2681

maybe_emit_mod(&prog, dst_reg, dst_reg,

arch/x86/net/bpf_jit_comp.c

2688

maybe_emit_1mod(&prog, dst_reg,

arch/x86/net/bpf_jit_comp.c

2764

emit_nops(&prog, nops);

arch/x86/net/bpf_jit_comp.c

2777

emit_indirect_jump(&prog, insn->dst_reg, ip);

arch/x86/net/bpf_jit_comp.c

2821

emit_nops(&prog, nops);

arch/x86/net/bpf_jit_comp.c

2846

emit_nops(&prog, INSN_SZ_DIFF - 2);

arch/x86/net/bpf_jit_comp.c

2867

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

arch/x86/net/bpf_jit_comp.c

2871

emit_add_rsp(&prog, outgoing_rsp);

arch/x86/net/bpf_jit_comp.c

2873

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

2874

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

2876

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

2878

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

2881

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

arch/x86/net/bpf_jit_comp.c

2883

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

arch/x86/net/bpf_jit_comp.c

2897

ilen = prog - temp;

arch/x86/net/bpf_jit_comp.c

2921

prog = temp;

arch/x86/net/bpf_jit_comp.c

2936

u8 *prog;

arch/x86/net/bpf_jit_comp.c

2968

prog = *pprog;

arch/x86/net/bpf_jit_comp.c

2975

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

2996

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

arch/x86/net/bpf_jit_comp.c

3040

emit_ldx(prog, BPF_DW, BPF_REG_0, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

3042

emit_stx(prog, BPF_DW, BPF_REG_FP, BPF_REG_0,

arch/x86/net/bpf_jit_comp.c

3062

emit_stx(prog, BPF_DW, BPF_REG_FP,

arch/x86/net/bpf_jit_comp.c

3071

clean_stack_garbage(m, prog, nr_stack_slots, first_off);

arch/x86/net/bpf_jit_comp.c

3074

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

arch/x86/net/bpf_jit_comp.c

3090

emit_ldx(prog, BPF_DW,

arch/x86/net/bpf_jit_comp.c

3111

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3114

struct bpf_prog *p = node->link->prog;

arch/x86/net/bpf_jit_comp.c

3118

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

arch/x86/net/bpf_jit_comp.c

3127

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

arch/x86/net/bpf_jit_comp.c

3130

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

arch/x86/net/bpf_jit_comp.c

3137

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

arch/x86/net/bpf_jit_comp.c

3140

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

arch/x86/net/bpf_jit_comp.c

3147

jmp_insn = prog;

arch/x86/net/bpf_jit_comp.c

3148

emit_nops(&prog, 2);

arch/x86/net/bpf_jit_comp.c

3157

emit_mov_imm64(&prog, BPF_REG_2,

arch/x86/net/bpf_jit_comp.c

3161

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

arch/x86/net/bpf_jit_comp.c

3173

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

arch/x86/net/bpf_jit_comp.c

3177

jmp_insn[1] = prog - jmp_insn - 2;

arch/x86/net/bpf_jit_comp.c

3180

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

arch/x86/net/bpf_jit_comp.c

3182

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

arch/x86/net/bpf_jit_comp.c

3188

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

arch/x86/net/bpf_jit_comp.c

3191

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3197

u8 *target, *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3199

target = PTR_ALIGN(prog, align);

arch/x86/net/bpf_jit_comp.c

3200

if (target != prog)

arch/x86/net/bpf_jit_comp.c

3201

emit_nops(&prog, target - prog);

arch/x86/net/bpf_jit_comp.c

3203

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3208

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3217

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3228

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3231

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

arch/x86/net/bpf_jit_comp.c

3232

emit_store_stack_imm64(&prog, BPF_REG_0, -func_meta_off,

arch/x86/net/bpf_jit_comp.c

3236

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

arch/x86/net/bpf_jit_comp.c

3240

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3249

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3255

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

arch/x86/net/bpf_jit_comp.c

3256

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

arch/x86/net/bpf_jit_comp.c

3258

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

arch/x86/net/bpf_jit_comp.c

3274

branches[i] = prog;

arch/x86/net/bpf_jit_comp.c

3275

emit_nops(&prog, 4 + 2);

arch/x86/net/bpf_jit_comp.c

3278

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

334

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3361

u8 *prog;

arch/x86/net/bpf_jit_comp.c

337

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

342

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

345

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3467

prog = rw_image;

arch/x86/net/bpf_jit_comp.c

3473

emit_cfi(&prog, image,

arch/x86/net/bpf_jit_comp.c

3481

x86_call_depth_emit_accounting(&prog, NULL, image);

arch/x86/net/bpf_jit_comp.c

3486

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

arch/x86/net/bpf_jit_comp.c

3498

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

arch/x86/net/bpf_jit_comp.c

350

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3502

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

arch/x86/net/bpf_jit_comp.c

3506

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

arch/x86/net/bpf_jit_comp.c

3509

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

arch/x86/net/bpf_jit_comp.c

3513

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

arch/x86/net/bpf_jit_comp.c

3514

if (emit_rsb_call(&prog, __bpf_tramp_enter,

arch/x86/net/bpf_jit_comp.c

3515

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

arch/x86/net/bpf_jit_comp.c

3524

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

arch/x86/net/bpf_jit_comp.c

3526

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

arch/x86/net/bpf_jit_comp.c

353

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3530

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

arch/x86/net/bpf_jit_comp.c

3542

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

arch/x86/net/bpf_jit_comp.c

3550

restore_regs(m, &prog, regs_off);

arch/x86/net/bpf_jit_comp.c

3551

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

arch/x86/net/bpf_jit_comp.c

3561

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

arch/x86/net/bpf_jit_comp.c

3565

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

arch/x86/net/bpf_jit_comp.c

3571

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

arch/x86/net/bpf_jit_comp.c

3572

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

arch/x86/net/bpf_jit_comp.c

3573

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

358

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3582

emit_align(&prog, 16);

arch/x86/net/bpf_jit_comp.c

3587

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

arch/x86/net/bpf_jit_comp.c

3595

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

arch/x86/net/bpf_jit_comp.c

3598

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

arch/x86/net/bpf_jit_comp.c

3606

restore_regs(m, &prog, regs_off);

arch/x86/net/bpf_jit_comp.c

3613

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

arch/x86/net/bpf_jit_comp.c

3615

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

arch/x86/net/bpf_jit_comp.c

3616

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

arch/x86/net/bpf_jit_comp.c

3629

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

arch/x86/net/bpf_jit_comp.c

3631

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

arch/x86/net/bpf_jit_comp.c

3635

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

arch/x86/net/bpf_jit_comp.c

3641

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

arch/x86/net/bpf_jit_comp.c

3643

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

arch/x86/net/bpf_jit_comp.c

3647

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

arch/x86/net/bpf_jit_comp.c

368

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3724

u8 *jg_reloc, *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

373

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3737

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

arch/x86/net/bpf_jit_comp.c

3738

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

arch/x86/net/bpf_jit_comp.c

3743

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

arch/x86/net/bpf_jit_comp.c

3745

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

376

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3765

jg_reloc = prog;

arch/x86/net/bpf_jit_comp.c

3767

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

arch/x86/net/bpf_jit_comp.c

3777

emit_align(&prog, 16);

arch/x86/net/bpf_jit_comp.c

3778

jg_offset = prog - jg_reloc;

arch/x86/net/bpf_jit_comp.c

3781

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

arch/x86/net/bpf_jit_comp.c

3786

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3804

u8 *prog = buf;

arch/x86/net/bpf_jit_comp.c

3807

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

arch/x86/net/bpf_jit_comp.c

381

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3823

struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

3833

bpf_jit_get_prog_name(prog));

arch/x86/net/bpf_jit_comp.c

3851

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

3868

if (!prog->jit_requested)

arch/x86/net/bpf_jit_comp.c

3869

return prog;

arch/x86/net/bpf_jit_comp.c

3871

jit_data = prog->aux->jit_data;

arch/x86/net/bpf_jit_comp.c

3875

return prog;

arch/x86/net/bpf_jit_comp.c

3876

prog->aux->jit_data = jit_data;

arch/x86/net/bpf_jit_comp.c

3878

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

3879

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

arch/x86/net/bpf_jit_comp.c

3884

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

arch/x86/net/bpf_jit_comp.c

3891

prog->aux->priv_stack_ptr = priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

3905

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

arch/x86/net/bpf_jit_comp.c

391

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

3913

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

arch/x86/net/bpf_jit_comp.c

3929

proglen = do_jit(env, prog, addrs, image, rw_image, oldproglen,

arch/x86/net/bpf_jit_comp.c

3940

prog->bpf_func = NULL;

arch/x86/net/bpf_jit_comp.c

3941

prog->jited = 0;

arch/x86/net/bpf_jit_comp.c

3942

prog->jited_len = 0;

arch/x86/net/bpf_jit_comp.c

3962

u32 extable_size = prog->aux->num_exentries *

arch/x86/net/bpf_jit_comp.c

3969

bpf_prog_was_classic(prog));

arch/x86/net/bpf_jit_comp.c

397

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

3972

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

arch/x86/net/bpf_jit_comp.c

3979

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

arch/x86/net/bpf_jit_comp.c

3982

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

arch/x86/net/bpf_jit_comp.c

3996

bpf_tail_call_direct_fixup(prog);

arch/x86/net/bpf_jit_comp.c

40

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

arch/x86/net/bpf_jit_comp.c

4012

bpf_prog_update_insn_ptrs(prog, addrs, image);

arch/x86/net/bpf_jit_comp.c

4021

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

arch/x86/net/bpf_jit_comp.c

4022

prog->jited = 1;

arch/x86/net/bpf_jit_comp.c

4023

prog->jited_len = proglen - cfi_get_offset();

arch/x86/net/bpf_jit_comp.c

4026

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

arch/x86/net/bpf_jit_comp.c

4028

bpf_prog_fill_jited_linfo(prog, addrs + 1);

arch/x86/net/bpf_jit_comp.c

4033

prog->aux->priv_stack_ptr = NULL;

arch/x86/net/bpf_jit_comp.c

4037

prog->aux->jit_data = NULL;

arch/x86/net/bpf_jit_comp.c

4040

return prog;

arch/x86/net/bpf_jit_comp.c

405

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

4071

void bpf_jit_free(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

4073

if (prog->jited) {

arch/x86/net/bpf_jit_comp.c

4074

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

arch/x86/net/bpf_jit_comp.c

4090

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

arch/x86/net/bpf_jit_comp.c

4091

hdr = bpf_jit_binary_pack_hdr(prog);

arch/x86/net/bpf_jit_comp.c

4093

priv_stack_ptr = prog->aux->priv_stack_ptr;

arch/x86/net/bpf_jit_comp.c

4095

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

arch/x86/net/bpf_jit_comp.c

4097

priv_stack_check_guard(priv_stack_ptr, priv_stack_alloc_sz, prog);

arch/x86/net/bpf_jit_comp.c

4098

free_percpu(prog->aux->priv_stack_ptr);

arch/x86/net/bpf_jit_comp.c

4100

WARN_ON_ONCE(!bpf_prog_kallsyms_verify_off(prog));

arch/x86/net/bpf_jit_comp.c

4103

bpf_prog_unlock_free(prog);

arch/x86/net/bpf_jit_comp.c

411

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

419

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

424

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

438

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

445

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

arch/x86/net/bpf_jit_comp.c

449

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

455

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

arch/x86/net/bpf_jit_comp.c

461

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

466

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

475

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

480

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

484

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

arch/x86/net/bpf_jit_comp.c

488

emit_kcfi(&prog, hash);

arch/x86/net/bpf_jit_comp.c

496

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

501

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

527

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

539

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

542

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

arch/x86/net/bpf_jit_comp.c

544

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

arch/x86/net/bpf_jit_comp.c

549

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

558

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

arch/x86/net/bpf_jit_comp.c

568

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

569

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

584

emit_prologue_tail_call(&prog, is_subprog);

arch/x86/net/bpf_jit_comp.c

585

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

590

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

599

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

627

u8 *prog;

arch/x86/net/bpf_jit_comp.c

632

prog = old_insn;

arch/x86/net/bpf_jit_comp.c

634

emit_call(&prog, old_addr, ip) :

arch/x86/net/bpf_jit_comp.c

635

emit_jump(&prog, old_addr, ip);

arch/x86/net/bpf_jit_comp.c

642

prog = new_insn;

arch/x86/net/bpf_jit_comp.c

644

emit_call(&prog, new_addr, ip) :

arch/x86/net/bpf_jit_comp.c

645

emit_jump(&prog, new_addr, ip);

arch/x86/net/bpf_jit_comp.c

687

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

694

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

699

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

705

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

arch/x86/net/bpf_jit_comp.c

708

__emit_indirect_jump(&prog, reg, ereg);

arch/x86/net/bpf_jit_comp.c

712

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

arch/x86/net/bpf_jit_comp.c

714

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

arch/x86/net/bpf_jit_comp.c

716

__emit_indirect_jump(&prog, reg, ereg);

arch/x86/net/bpf_jit_comp.c

721

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

726

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

729

emit_jump(&prog, x86_return_thunk, ip);

arch/x86/net/bpf_jit_comp.c

736

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

761

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

arch/x86/net/bpf_jit_comp.c

778

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

arch/x86/net/bpf_jit_comp.c

788

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

arch/x86/net/bpf_jit_comp.c

801

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

arch/x86/net/bpf_jit_comp.c

808

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

809

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

811

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

813

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

836

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

arch/x86/net/bpf_jit_comp.c

839

ctx->tail_call_indirect_label = prog - start;

arch/x86/net/bpf_jit_comp.c

840

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

850

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

arch/x86/net/bpf_jit_comp.c

860

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

arch/x86/net/bpf_jit_comp.c

863

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

arch/x86/net/bpf_jit_comp.c

868

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

arch/x86/net/bpf_jit_comp.c

875

pop_callee_regs(&prog, all_callee_regs_used);

arch/x86/net/bpf_jit_comp.c

876

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

878

pop_callee_regs(&prog, callee_regs_used);

arch/x86/net/bpf_jit_comp.c

880

pop_r12(&prog);

arch/x86/net/bpf_jit_comp.c

892

emit_nops(&prog, X86_PATCH_SIZE);

arch/x86/net/bpf_jit_comp.c

895

ctx->tail_call_direct_label = prog - start;

arch/x86/net/bpf_jit_comp.c

897

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

900

static void bpf_tail_call_direct_fixup(struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp.c

907

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

arch/x86/net/bpf_jit_comp.c

908

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

arch/x86/net/bpf_jit_comp.c

909

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

arch/x86/net/bpf_jit_comp.c

941

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

975

*pprog = prog;

arch/x86/net/bpf_jit_comp.c

982

u8 *prog = *pprog;

arch/x86/net/bpf_jit_comp.c

991

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

arch/x86/net/bpf_jit_comp.c

993

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

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_verifier_env *env, struct bpf_prog *prog)

arch/x86/net/bpf_jit_comp32.c

2531

if (!prog->jit_requested)

arch/x86/net/bpf_jit_comp32.c

2532

return prog;

arch/x86/net/bpf_jit_comp32.c

2534

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

arch/x86/net/bpf_jit_comp32.c

2536

return prog;

arch/x86/net/bpf_jit_comp32.c

2542

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

arch/x86/net/bpf_jit_comp32.c

2555

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

arch/x86/net/bpf_jit_comp32.c

2582

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

arch/x86/net/bpf_jit_comp32.c

2585

prog->bpf_func = (void *)image;

arch/x86/net/bpf_jit_comp32.c

2586

prog->jited = 1;

arch/x86/net/bpf_jit_comp32.c

2587

prog->jited_len = proglen;

arch/x86/net/bpf_jit_comp32.c

2592

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

1532

unsigned int len, bool prog)

drivers/mtd/nand/raw/nand_base.c

1567

if (!prog) {

drivers/net/bonding/bond_main.c

2314

.prog = bond->xdp_prog,

drivers/net/bonding/bond_main.c

2463

.prog = NULL,

drivers/net/bonding/bond_main.c

5689

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

drivers/net/bonding/bond_main.c

5699

.prog = prog,

drivers/net/bonding/bond_main.c

5713

bond->xdp_prog = prog;

drivers/net/bonding/bond_main.c

5739

if (prog)

drivers/net/bonding/bond_main.c

5740

bpf_prog_inc(prog);

drivers/net/bonding/bond_main.c

5743

if (prog) {

drivers/net/bonding/bond_main.c

5755

xdp.prog = old_prog;

drivers/net/bonding/bond_main.c

5769

else if (xdp.prog)

drivers/net/bonding/bond_main.c

5770

bpf_prog_inc(xdp.prog);

drivers/net/bonding/bond_main.c

5779

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

135

struct bpf_prog *prog;

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

138

prog = READ_ONCE(aq_nic->xdp_prog);

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

139

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

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

225

struct bpf_prog *prog;

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

230

prog = READ_ONCE(aq_nic->xdp_prog);

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

231

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

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

409

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

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

416

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

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

423

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

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

430

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

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

434

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

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

438

if (!old_prog && prog)

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

440

else if (old_prog && !prog)

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

453

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

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

437

struct bpf_prog *prog;

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

446

prog = READ_ONCE(rx_ring->xdp_prog);

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

447

if (!prog)

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

453

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

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

456

act = bpf_prog_run_xdp(prog, xdp);

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

480

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

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

495

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

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

496

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

3033

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

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

3043

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

1959

struct bpf_prog *prog)

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

2008

xdp_act = bpf_prog_run_xdp(prog, &xdp_buff);

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

2012

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

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

2015

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

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

2076

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

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

2120

struct bpf_prog *prog;

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

2132

prog = rx_ring->xdp.prog;

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

2133

if (prog)

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

2134

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

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

2647

if (rx_ring->xdp.prog)

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

3244

struct bpf_prog *old_prog, *prog = ctx;

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

3248

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

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

3263

rx_ring->xdp.prog = prog;

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

3265

if (prog)

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

3274

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

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

3277

int num_xdp_tx_queues = prog ? num_possible_cpus() : 0;

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

3296

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

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

3303

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

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

124

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

1579

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

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

1588

WRITE_ONCE(priv->xdp_prog, prog);

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

1598

if (!old_prog && prog)

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

1600

else if (old_prog && !prog)

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

1606

WRITE_ONCE(priv->xdp_prog, prog);

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

1814

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

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

13247

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

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

13250

int frame_size = i40e_max_vsi_frame_size(vsi, prog);

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

13257

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

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

13267

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

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

13271

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

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

13274

if (!prog) {

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

13282

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

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

13285

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

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

13299

if (need_reset && prog) {

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

13582

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

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

997

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

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

2585

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

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

2590

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

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

2681

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

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

2749

ice_vsi_assign_bpf_prog(vsi, prog);

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

2899

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

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

2906

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

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

2915

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

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

2917

ice_vsi_assign_bpf_prog(vsi, prog);

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

2933

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

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

2939

xdp_ring_err = ice_prepare_xdp_rings(vsi, prog,

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

2947

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

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

2958

if (!ret && prog)

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

2998

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

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

7847

struct bpf_prog *prog;

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

7856

prog = vsi->xdp_prog;

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

7857

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

2893

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

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

2910

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

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

2911

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

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

2929

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

6861

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

10914

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

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

10945

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

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

10946

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

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

10952

if (!prog)

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

10959

if (!prog)

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

10974

if (need_reset && prog) {

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

10993

return ixgbe_xdp_setup(dev, xdp->prog);

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4494

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

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4508

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

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4511

if (!!prog != !!old_prog) {

drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c

4539

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

5347

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

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

5349

bool reset = !prog != !port->xdp_prog;

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c

5370

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

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2843

static int otx2_xdp_setup(struct otx2_nic *pf, struct bpf_prog *prog)

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2849

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

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2857

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

drivers/net/ethernet/marvell/octeontx2/nic/otx2_pf.c

2888

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

1908

pp_params.dma_dir = rcu_access_pointer(eth->prog) ? DMA_BIDIRECTIONAL

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2143

struct bpf_prog *prog;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2148

prog = rcu_dereference(eth->prog);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2149

if (!prog)

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2152

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2158

if (unlikely(xdp_do_redirect(dev, xdp, prog))) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2178

bpf_warn_invalid_xdp_action(dev, prog, act);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

2181

trace_xdp_exception(dev, prog, act);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3673

if (mtk_uses_dsa(dev) && !eth->prog) {

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3765

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

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3783

need_update = !!eth->prog != !!prog;

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3787

old_prog = rcu_replace_pointer(eth->prog, prog, lockdep_rtnl_is_held());

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3794

rcu_assign_pointer(eth->prog, old_prog);

drivers/net/ethernet/mediatek/mtk_eth_soc.c

3810

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

drivers/net/ethernet/mediatek/mtk_eth_soc.c

4353

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

319

struct bpf_prog *prog, struct mlx5e_xdp_buff *mxbuf)

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

325

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

336

err = xdp_do_redirect(rq->netdev, xdp, prog);

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

344

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

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.c

348

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

drivers/net/ethernet/mellanox/mlx5/core/en/xdp.h

102

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

5193

static void mlx5e_rq_replace_xdp_prog(struct mlx5e_rq *rq, struct bpf_prog *prog)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5197

old_prog = rcu_replace_pointer(rq->xdp_prog, prog,

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5203

static int mlx5e_xdp_set(struct net_device *netdev, struct bpf_prog *prog)

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5215

new_params.xdp_prog = prog;

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5217

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5224

reset = (!priv->channels.params.xdp_prog || !prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5241

bpf_prog_add(prog, priv->channels.num);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5245

mlx5e_rq_replace_xdp_prog(&c->rq, prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5247

bpf_prog_inc(prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5248

mlx5e_rq_replace_xdp_prog(&c->xskrq, prog);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

5266

return mlx5e_xdp_set(dev, xdp->prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1581

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1597

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1598

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1604

if (mlx5e_xdp_handle(rq, prog, mxbuf))

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1634

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1676

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1677

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1680

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1924

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1941

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1945

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2016

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2021

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2104

struct bpf_prog *prog;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2126

prog = rcu_dereference(rq->xdp_prog);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2127

if (prog) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2133

if (mlx5e_xdp_handle(rq, prog, mxbuf)) {

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

525

bool fbnic_check_split_frames(struct bpf_prog *prog, unsigned int mtu,

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

528

if (!prog)

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

531

if (prog->aux->xdp_has_frags)

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

539

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

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

545

if (fbnic_check_split_frames(prog, netdev->mtu,

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

552

prev_prog = xchg(&fbn->xdp_prog, prog);

drivers/net/ethernet/meta/fbnic/fbnic_netdev.h

117

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

260

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

3542

if (immed_get_value(nfp_prog->prog[br_idx + 1])) {

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

3547

immed_set_value(&nfp_prog->prog[br_idx + 1], jmp_dst->off);

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

3582

if (!nfp_is_br(nfp_prog->prog[br_idx])) {

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

3584

br_idx, meta->insn.code, nfp_prog->prog[br_idx]);

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

3592

if (FIELD_GET(OP_RELO_TYPE, nfp_prog->prog[br_idx]) !=

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

3616

if (FIELD_GET(OP_RELO_TYPE, nfp_prog->prog[br_idx]) !=

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

3621

if (!nfp_is_br(nfp_prog->prog[idx]))

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

3623

br_set_offset(&nfp_prog->prog[idx], jmp_dst->off);

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

4433

static int nfp_bpf_ustore_calc(u64 *prog, unsigned int len)

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

4435

__le64 *ustore = (__force __le64 *)prog;

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

4441

err = nfp_ustore_check_valid_no_ecc(prog[i]);

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

4445

ustore[i] = cpu_to_le64(nfp_ustore_calc_ecc_insn(prog[i]));

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

4453

void *prog;

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

4455

prog = kvmalloc_array(nfp_prog->prog_len, sizeof(u64), GFP_KERNEL);

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

4456

if (!prog)

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

4460

memcpy(prog, nfp_prog->prog, nfp_prog->__prog_alloc_len);

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

4461

kvfree(nfp_prog->prog);

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

4462

nfp_prog->prog = prog;

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

4535

u64 *prog;

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

4538

prog = kmemdup_array(nfp_prog->prog, nfp_prog->prog_len, sizeof(u64),

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

4540

if (!prog)

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

4548

special = FIELD_GET(OP_RELO_TYPE, prog[i]);

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

4553

br_add_offset(&prog[i], bv->start_off);

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

4556

br_set_offset(&prog[i],

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

4560

br_set_offset(&prog[i],

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

4570

br_set_offset(&prog[i], off);

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

4579

br_set_offset(&prog[i], off);

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

4582

br_set_offset(&prog[i], bv->tgt_done);

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

4585

val = br_get_offset(prog[i]);

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

4606

br_set_offset(&prog[i], val);

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

4609

immed_add_value(&prog[i], bv->start_off);

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

4613

prog[i] &= ~OP_RELO_TYPE;

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

4616

err = nfp_bpf_ustore_calc(prog, nfp_prog->prog_len);

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

4620

return prog;

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

4623

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

2761

if (!ionic_xdp_is_valid_mtu(lif, netdev->mtu, bpf->prog)) {

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2769

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

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

2775

} else if (lif->xdp_prog && bpf->prog) {

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2776

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

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2782

qparams.xdp_prog = bpf->prog;

drivers/net/ethernet/pensando/ionic/ionic_lif.c

2785

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

1088

struct bpf_prog *prog,

drivers/net/ethernet/qlogic/qede/qede_fp.c

1100

act = bpf_prog_run_xdp(prog, &xdp);

drivers/net/ethernet/qlogic/qede/qede_fp.c

1118

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

drivers/net/ethernet/qlogic/qede/qede_fp.c

1132

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

drivers/net/ethernet/qlogic/qede/qede_fp.c

1148

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

drivers/net/ethernet/qlogic/qede/qede_fp.c

1155

if (unlikely(xdp_do_redirect(edev->ndev, &xdp, prog)))

drivers/net/ethernet/qlogic/qede/qede_fp.c

1163

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

drivers/net/ethernet/qlogic/qede/qede_fp.c

1166

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

5285

struct bpf_prog *prog,

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5291

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5300

if (xdp_do_redirect(priv->dev, xdp, prog) < 0)

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5306

bpf_warn_invalid_xdp_action(priv->dev, prog, act);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5309

trace_xdp_exception(priv->dev, prog, act);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5322

struct bpf_prog *prog;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5325

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5326

if (!prog) {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5331

res = __stmmac_xdp_run_prog(priv, prog, xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5487

struct bpf_prog *prog;

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5603

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

5604

res = __stmmac_xdp_run_prog(priv, prog, buf->xdp);

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c

6932

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

1177

struct bpf_prog *prog;

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1183

prog = READ_ONCE(port->xdp_prog);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1184

if (!prog)

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1187

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1214

if (unlikely(xdp_do_redirect(ndev, xdp, prog)))

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1220

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1224

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1919

struct bpf_prog *prog)

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1928

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

drivers/net/ethernet/ti/am65-cpsw-nuss.c

1942

return am65_cpsw_xdp_prog_setup(ndev, bpf->prog);

drivers/net/ethernet/ti/cpsw_priv.c

1276

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/ti/cpsw_priv.c

1278

if (!priv->xdpi.prog && !prog)

drivers/net/ethernet/ti/cpsw_priv.c

1281

WRITE_ONCE(priv->xdp_prog, prog);

drivers/net/ethernet/ti/cpsw_priv.c

1343

struct bpf_prog *prog;

drivers/net/ethernet/ti/cpsw_priv.c

1346

prog = READ_ONCE(priv->xdp_prog);

drivers/net/ethernet/ti/cpsw_priv.c

1347

if (!prog)

drivers/net/ethernet/ti/cpsw_priv.c

1350

act = bpf_prog_run_xdp(prog, xdp);

drivers/net/ethernet/ti/cpsw_priv.c

1367

if (xdp_do_redirect(ndev, xdp, prog))

drivers/net/ethernet/ti/cpsw_priv.c

1378

bpf_warn_invalid_xdp_action(ndev, prog, act);

drivers/net/ethernet/ti/cpsw_priv.c

1381

trace_xdp_exception(ndev, prog, act);

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1455

struct bpf_prog *prog = bpf->prog;

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1457

if (!emac->xdpi.prog && !prog)

drivers/net/ethernet/ti/icssg/icssg_prueth.c

1460

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

141

if (prog && !prog->aux->offload && !ns->bpf_tc_non_bound_accept) {

drivers/net/netdevsim/bpf.c

155

if (!cls_bpf->prog)

drivers/net/netdevsim/bpf.c

164

return nsim_bpf_offload(ns, cls_bpf->prog, oldprog);

drivers/net/netdevsim/bpf.c

176

if (!nsim_xdp_offload_active(ns) && !bpf->prog)

drivers/net/netdevsim/bpf.c

178

if (!nsim_xdp_offload_active(ns) && bpf->prog && ns->bpf_offloaded) {

drivers/net/netdevsim/bpf.c

183

return nsim_bpf_offload(ns, bpf->prog, nsim_xdp_offload_active(ns));

drivers/net/netdevsim/bpf.c

213

struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

224

state->prog = prog;

drivers/net/netdevsim/bpf.c

236

debugfs_create_u32("id", 0400, state->ddir, &prog->aux->id);

drivers/net/netdevsim/bpf.c

245

prog->aux->offload->dev_priv = state;

drivers/net/netdevsim/bpf.c

250

static int nsim_bpf_verifier_prep(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

253

bpf_offload_dev_priv(prog->aux->offload->offdev);

drivers/net/netdevsim/bpf.c

258

return nsim_bpf_create_prog(nsim_dev, prog);

drivers/net/netdevsim/bpf.c

261

static int nsim_bpf_translate(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

263

struct nsim_bpf_bound_prog *state = prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

269

static void nsim_bpf_destroy_prog(struct bpf_prog *prog)

drivers/net/netdevsim/bpf.c

274

state = prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

295

if (bpf->prog && bpf->prog->aux->offload) {

drivers/net/netdevsim/bpf.c

299

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

drivers/net/netdevsim/bpf.c

31

struct bpf_prog *prog;

drivers/net/netdevsim/bpf.c

312

if (!bpf->prog)

drivers/net/netdevsim/bpf.c

315

if (!bpf_prog_is_offloaded(bpf->prog->aux)) {

drivers/net/netdevsim/bpf.c

320

state = bpf->prog->aux->offload->dev_priv;

drivers/net/netdevsim/bpf.c

650

WARN_ON(ns->xdp.prog);

drivers/net/netdevsim/bpf.c

651

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

199

if (ns->xdp.prog && !ns->xdp.prog->aux->xdp_has_frags &&

drivers/net/netdevsim/netdev.c

375

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

drivers/net/netkit.c

1000

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

drivers/net/netkit.c

1020

ret = netkit_link_init(nkl, &link_primer, attr, dev, prog);

drivers/net/netkit.c

1056

bpf_prog_put(tuple.prog);

drivers/net/netkit.c

57

const struct bpf_prog *prog;

drivers/net/netkit.c

59

bpf_mprog_foreach_prog(entry, fp, prog) {

drivers/net/netkit.c

61

ret = bpf_prog_run(prog, skb);

drivers/net/netkit.c

745

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

drivers/net/netkit.c

762

prog->type);

drivers/net/netkit.c

769

ret = bpf_mprog_attach(entry, &entry_new, prog, NULL, replace_prog,

drivers/net/netkit.c

786

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

drivers/net/netkit.c

804

ret = bpf_mprog_detach(entry, &entry_new, prog, NULL, attr->attach_flags,

drivers/net/netkit.c

852

ret = bpf_mprog_attach(entry, &entry_new, link->prog, link, NULL, flags,

drivers/net/netkit.c

880

ret = bpf_mprog_detach(entry, &entry_new, link->prog, link, 0, 0, 0);

drivers/net/netkit.c

908

if (oprog && link->prog != oprog) {

drivers/net/netkit.c

912

oprog = link->prog;

drivers/net/netkit.c

924

link->prog->aux->id, 0);

drivers/net/netkit.c

927

oprog = xchg(&link->prog, nprog);

drivers/net/netkit.c

992

struct bpf_prog *prog)

drivers/net/netkit.c

995

&netkit_link_lops, prog, attr->link_create.attach_type);

drivers/net/tun.c

1128

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

drivers/net/tun.c

1137

rcu_assign_pointer(tun->xdp_prog, prog);

drivers/net/tun.c

1143

if (prog)

drivers/net/tun.c

1149

if (prog)

drivers/net/tun.c

1162

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

drivers/net/tun.c

172

struct bpf_prog *prog;

drivers/net/tun.c

2221

struct tun_prog *prog = container_of(rcu, struct tun_prog, rcu);

drivers/net/tun.c

2223

bpf_prog_destroy(prog->prog);

drivers/net/tun.c

2224

kfree(prog);

drivers/net/tun.c

2229

struct bpf_prog *prog)

drivers/net/tun.c

2233

if (prog) {

drivers/net/tun.c

2237

new->prog = prog;

drivers/net/tun.c

2990

struct bpf_prog *prog;

drivers/net/tun.c

2997

prog = NULL;

drivers/net/tun.c

2999

prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_SOCKET_FILTER);

drivers/net/tun.c

3000

if (IS_ERR(prog))

drivers/net/tun.c

3001

return PTR_ERR(prog);

drivers/net/tun.c

3004

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

1567

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

drivers/net/veth.c

1577

priv->_xdp_prog = prog;

drivers/net/veth.c

1580

if (prog) {

drivers/net/veth.c

1592

if (prog->aux->xdp_has_frags)

drivers/net/veth.c

1624

if (!prog) {

drivers/net/veth.c

1639

if ((!!old_prog ^ !!prog) && peer)

drivers/net/veth.c

1653

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

drivers/net/virtio_net.c

1122

struct bpf_prog *prog;

drivers/net/virtio_net.c

1127

prog = rcu_dereference(rq->xdp_prog);

drivers/net/virtio_net.c

1128

if (prog)

drivers/net/virtio_net.c

1129

ret = virtnet_xdp_handler(prog, xdp, dev, xdp_xmit, stats);

drivers/net/virtio_net.c

1236

struct bpf_prog *prog;

drivers/net/virtio_net.c

1245

prog = rcu_dereference(rq->xdp_prog);

drivers/net/virtio_net.c

1246

if (prog) {

drivers/net/virtio_net.c

1249

ret = virtnet_xdp_handler(prog, xdp, dev, xdp_xmit,

drivers/net/virtio_net.c

6006

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

drivers/net/virtio_net.c

6034

if (prog && !prog->aux->xdp_has_frags && dev->mtu > max_sz) {

drivers/net/virtio_net.c

6041

if (prog)

drivers/net/virtio_net.c

6052

if (!prog && !old_prog)

drivers/net/virtio_net.c

6055

if (prog)

drivers/net/virtio_net.c

6056

bpf_prog_add(prog, vi->max_queue_pairs - 1);

drivers/net/virtio_net.c

6066

if (!prog) {

drivers/net/virtio_net.c

6068

rcu_assign_pointer(vi->rq[i].xdp_prog, prog);

drivers/net/virtio_net.c

6081

if (prog) {

drivers/net/virtio_net.c

6084

rcu_assign_pointer(vi->rq[i].xdp_prog, prog);

drivers/net/virtio_net.c

6106

if (!prog) {

drivers/net/virtio_net.c

6117

if (prog)

drivers/net/virtio_net.c

6118

bpf_prog_sub(prog, vi->max_queue_pairs - 1);

drivers/net/virtio_net.c

6126

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

1429

u8 prog;

drivers/pci/quirks.c

1430

pci_read_config_byte(pdev, PCI_CLASS_PROG, &prog);

drivers/pci/quirks.c

1431

if (prog & 5) {

drivers/pci/quirks.c

1432

prog &= ~5;

drivers/pci/quirks.c

1434

pci_write_config_byte(pdev, PCI_CLASS_PROG, prog);

drivers/pci/quirks.c

1443

u8 prog;

drivers/pci/quirks.c

1445

pci_read_config_byte(pdev, PCI_CLASS_PROG, &prog);

drivers/pci/quirks.c

1447

if (((prog & 1) && !(prog & 4)) || ((prog & 4) && !(prog & 1))) {

drivers/pci/quirks.c

1449

prog &= ~5;

drivers/pci/quirks.c

1451

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

395

static int bpf_fs_kfuncs_filter(const struct bpf_prog *prog, u32 kfunc_id)

fs/bpf_fs_kfuncs.c

398

prog->type == BPF_PROG_TYPE_LSM)

fs/bpf_fs_kfuncs.c

428

bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog)

fs/bpf_fs_kfuncs.c

430

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

1532

__field(u32, prog)

fs/nfsd/trace.h

1539

__entry->prog = conn->cb_prog;

fs/nfsd/trace.h

1545

__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

462

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

include/linux/bpf-cgroup.h

470

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

1009

bool (*allowed)(const struct bpf_prog *prog);

include/linux/bpf.h

1137

int (*test_run)(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

1146

const struct bpf_prog *prog);

include/linux/bpf.h

1152

const struct bpf_prog *prog,

include/linux/bpf.h

1155

const struct bpf_prog *prog);

include/linux/bpf.h

1156

int (*gen_epilogue)(struct bpf_insn *insn, const struct bpf_prog *prog,

include/linux/bpf.h

1163

struct bpf_prog *prog, u32 *target_size);

include/linux/bpf.h

1179

int (*prepare)(struct bpf_prog *prog);

include/linux/bpf.h

1180

int (*translate)(struct bpf_prog *prog);

include/linux/bpf.h

1181

void (*destroy)(struct bpf_prog *prog);

include/linux/bpf.h

1185

struct bpf_prog *prog;

include/linux/bpf.h

1323

u64 notrace __bpf_prog_enter_sleepable_recur(struct bpf_prog *prog,

include/linux/bpf.h

1325

void notrace __bpf_prog_exit_sleepable_recur(struct bpf_prog *prog, u64 start,

include/linux/bpf.h

1329

typedef u64 (*bpf_trampoline_enter_t)(struct bpf_prog *prog,

include/linux/bpf.h

1331

typedef void (*bpf_trampoline_exit_t)(struct bpf_prog *prog, u64 start,

include/linux/bpf.h

1333

bpf_trampoline_enter_t bpf_trampoline_enter(const struct bpf_prog *prog);

include/linux/bpf.h

1334

bpf_trampoline_exit_t bpf_trampoline_exit(const struct bpf_prog *prog);

include/linux/bpf.h

1354

bool prog;

include/linux/bpf.h

1425

struct bpf_prog *prog;

include/linux/bpf.h

1523

int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids,

include/linux/bpf.h

1525

int bpf_trampoline_multi_detach(struct bpf_prog *prog,

include/linux/bpf.h

1602

bool bpf_prog_has_trampoline(const struct bpf_prog *prog);

include/linux/bpf.h

1603

bool bpf_insn_is_indirect_target(const struct bpf_verifier_env *env, const struct bpf_prog *prog,

include/linux/bpf.h

1605

u16 bpf_out_stack_arg_cnt(const struct bpf_verifier_env *env, const struct bpf_prog *prog);

include/linux/bpf.h

1636

static inline bool bpf_prog_has_trampoline(const struct bpf_prog *prog)

include/linux/bpf.h

1640

static inline int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids,

include/linux/bpf.h

1645

static inline int bpf_trampoline_multi_detach(struct bpf_prog *prog,

include/linux/bpf.h

1792

void (*recursion_detected)(struct bpf_prog *prog); /* callback if recursion is detected */

include/linux/bpf.h

1813

struct bpf_prog *prog;

include/linux/bpf.h

1918

struct bpf_prog *prog;

include/linux/bpf.h

2108

const struct bpf_prog *prog);

include/linux/bpf.h

2159

static inline bool bpf_prog_get_recursion_context(struct bpf_prog *prog)

include/linux/bpf.h

2163

u8 *active = this_cpu_ptr(prog->active);

include/linux/bpf.h

2175

return this_cpu_inc_return(*(int __percpu *)(prog->active)) == 1;

include/linux/bpf.h

2179

static inline void bpf_prog_put_recursion_context(struct bpf_prog *prog)

include/linux/bpf.h

2183

u8 *active = this_cpu_ptr(prog->active);

include/linux/bpf.h

2189

this_cpu_dec(*(int __percpu *)(prog->active));

include/linux/bpf.h

2241

int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map);

include/linux/bpf.h

2242

void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog);

include/linux/bpf.h

2246

int (*cb)(struct bpf_prog *prog, void *data),

include/linux/bpf.h

2262

int bpf_struct_ops_test_run(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

2294

static inline int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map)

include/linux/bpf.h

2298

static inline void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog)

include/linux/bpf.h

2321

if (fentries.nodes[i]->link->prog->expected_attach_type == BPF_TRACE_FSESSION)

include/linux/bpf.h

2323

if (fentries.nodes[i]->link->prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI)

include/linux/bpf.h

2332

return node->link->prog->call_session_cookie;

include/linux/bpf.h

2348

int bpf_prog_ctx_arg_info_init(struct bpf_prog *prog,

include/linux/bpf.h

2352

int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

include/linux/bpf.h

2355

void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog);

include/linux/bpf.h

2357

static inline int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

include/linux/bpf.h

2363

static inline void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog)

include/linux/bpf.h

2468

struct bpf_prog *prog,

include/linux/bpf.h

2487

struct bpf_prog *prog;

include/linux/bpf.h

2520

struct bpf_prog *prog);

include/linux/bpf.h

2573

typedef u32 (*bpf_prog_run_fn)(const struct bpf_prog *prog, const void *ctx);

include/linux/bpf.h

2580

const struct bpf_prog *prog;

include/linux/bpf.h

2595

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

2597

ret &= run_prog(prog, ctx);

include/linux/bpf.h

2620

const struct bpf_prog *prog;

include/linux/bpf.h

2637

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

2638

if (!prog->sleepable)

include/linux/bpf.h

2642

ret &= run_prog(prog, ctx);

include/linux/bpf.h

2645

if (!prog->sleepable)

include/linux/bpf.h

2705

void bpf_prog_add(struct bpf_prog *prog, int i);

include/linux/bpf.h

2706

void bpf_prog_sub(struct bpf_prog *prog, int i);

include/linux/bpf.h

2707

void bpf_prog_inc(struct bpf_prog *prog);

include/linux/bpf.h

2708

struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);

include/linux/bpf.h

2709

void bpf_prog_put(struct bpf_prog *prog);

include/linux/bpf.h

2711

void bpf_prog_free_id(struct bpf_prog *prog);

include/linux/bpf.h

2882

int bpf_prog_new_fd(struct bpf_prog *prog);

include/linux/bpf.h

2885

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

2888

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

2891

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

2963

typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog,

include/linux/bpf.h

3008

int bpf_iter_prog_supported(struct bpf_prog *prog);

include/linux/bpf.h

3010

bpf_iter_get_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf.h

3011

int bpf_iter_link_attach(const union bpf_attr *attr, bpfptr_t uattr, struct bpf_prog *prog);

include/linux/bpf.h

3015

int bpf_iter_run_prog(struct bpf_prog *prog, void *ctx);

include/linux/bpf.h

3097

int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

3099

int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,

include/linux/bpf.h

3101

int bpf_prog_test_run_tracing(struct bpf_prog *prog,

include/linux/bpf.h

3104

int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

include/linux/bpf.h

3107

int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,

include/linux/bpf.h

3110

int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,

include/linux/bpf.h

3113

int bpf_prog_test_run_nf(struct bpf_prog *prog,

include/linux/bpf.h

3117

const struct bpf_prog *prog,

include/linux/bpf.h

3134

const struct bpf_prog *prog,

include/linux/bpf.h

3139

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

include/linux/bpf.h

3159

int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,

include/linux/bpf.h

3170

const struct bpf_prog *prog);

include/linux/bpf.h

3173

bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog);

include/linux/bpf.h

3175

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

include/linux/bpf.h

3177

int bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

include/linux/bpf.h

3211

void notrace bpf_prog_inc_misses_counter(struct bpf_prog *prog);

include/linux/bpf.h

3224

struct bpf_prog *prog;

include/linux/bpf.h

3238

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

3240

if (unlikely(!prog->len)) {

include/linux/bpf.h

3245

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

include/linux/bpf.h

3246

bpf_prog_inc_misses_counter(prog);

include/linux/bpf.h

3247

bpf_prog_put_recursion_context(prog);

include/linux/bpf.h

3254

if (!prog->sleepable) {

include/linux/bpf.h

3256

ret &= run_prog(prog, ctx);

include/linux/bpf.h

3258

ret &= run_prog(prog, ctx);

include/linux/bpf.h

3261

bpf_prog_put_recursion_context(prog);

include/linux/bpf.h

3282

static inline void bpf_prog_add(struct bpf_prog *prog, int i)

include/linux/bpf.h

3286

static inline void bpf_prog_sub(struct bpf_prog *prog, int i)

include/linux/bpf.h

3290

static inline void bpf_prog_put(struct bpf_prog *prog)

include/linux/bpf.h

3294

static inline void bpf_prog_inc(struct bpf_prog *prog)

include/linux/bpf.h

3299

bpf_prog_inc_not_zero(struct bpf_prog *prog)

include/linux/bpf.h

3306

struct bpf_prog *prog, enum bpf_attach_type attach_type)

include/linux/bpf.h

3311

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

3317

const struct bpf_link_ops *ops, struct bpf_prog *prog,

include/linux/bpf.h

3449

static inline int bpf_prog_test_run_xdp(struct bpf_prog *prog,

include/linux/bpf.h

3456

static inline int bpf_prog_test_run_skb(struct bpf_prog *prog,

include/linux/bpf.h

3463

static inline int bpf_prog_test_run_tracing(struct bpf_prog *prog,

include/linux/bpf.h

3470

static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

include/linux/bpf.h

3477

static inline int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,

include/linux/bpf.h

3503

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

include/linux/bpf.h

3512

static inline bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog)

include/linux/bpf.h

3518

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

include/linux/bpf.h

3525

bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

include/linux/bpf.h

3541

static inline void bpf_prog_inc_misses_counter(struct bpf_prog *prog)

include/linux/bpf.h

3598

int bpf_prog_offload_compile(struct bpf_prog *prog);

include/linux/bpf.h

3599

void bpf_prog_dev_bound_destroy(struct bpf_prog *prog);

include/linux/bpf.h

3601

struct bpf_prog *prog);

include/linux/bpf.h

3612

bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map);

include/linux/bpf.h

3622

bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev);

include/linux/bpf.h

3629

void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog, u32 func_id);

include/linux/bpf.h

3630

int bpf_prog_dev_bound_init(struct bpf_prog *prog, union bpf_attr *attr);

include/linux/bpf.h

3654

int bpf_prog_test_run_syscall(struct bpf_prog *prog,

include/linux/bpf.h

3658

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

include/linux/bpf.h

3663

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

include/linux/bpf.h

3675

static inline void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog,

include/linux/bpf.h

3681

static inline int bpf_prog_dev_bound_init(struct bpf_prog *prog,

include/linux/bpf.h

3731

static inline int bpf_prog_test_run_syscall(struct bpf_prog *prog,

include/linux/bpf.h

3740

struct bpf_prog *prog)

include/linux/bpf.h

3763

static inline int sock_map_link_create(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/bpf.h

3774

struct bpf_prog *prog;

include/linux/bpf.h

3780

while ((prog = READ_ONCE(item->prog))) {

include/linux/bpf.h

3781

bpf_prog_inc_misses_counter(prog);

include/linux/bpf.h

3949

enum bpf_func_id func_id, const struct bpf_prog *prog);

include/linux/bpf.h

3965

struct bpf_prog *prog,

include/linux/bpf.h

3985

struct bpf_prog *prog,

include/linux/bpf.h

4014

struct bpf_prog *prog,

include/linux/bpf.h

4023

struct bpf_prog *prog,

include/linux/bpf.h

4036

struct bpf_prog *prog,

include/linux/bpf.h

4051

struct bpf_prog *prog,

include/linux/bpf.h

4103

void bpf_prog_stream_init(struct bpf_prog *prog);

include/linux/bpf.h

4104

void bpf_prog_stream_free(struct bpf_prog *prog);

include/linux/bpf.h

4105

int bpf_prog_stream_read(struct bpf_prog *prog, enum bpf_stream_id stream_id, void __user *buf, int len);

include/linux/bpf.h

4110

int bpf_stream_stage_commit(struct bpf_stream_stage *ss, struct bpf_prog *prog,

include/linux/bpf.h

4117

#define bpf_stream_stage(ss, prog, stream_id, expr) \

include/linux/bpf.h

4121

bpf_stream_stage_commit(&ss, prog, stream_id); \

include/linux/bpf.h

4145

static inline bool bpf_is_subprog(const struct bpf_prog *prog)

include/linux/bpf.h

4147

return prog->aux->func_idx != 0;

include/linux/bpf.h

4150

const struct bpf_line_info *bpf_find_linfo(const struct bpf_prog *prog, u32 insn_off);

include/linux/bpf.h

4153

int bpf_prog_get_file_line(struct bpf_prog *prog, unsigned long ip, const char **filep,

include/linux/bpf.h

4157

int bpf_insn_array_init(struct bpf_map *map, const struct bpf_prog *prog);

include/linux/bpf.h

4164

void bpf_prog_update_insn_ptrs(struct bpf_prog *prog, u32 *offsets, void *image);

include/linux/bpf.h

4167

bpf_prog_update_insn_ptrs(struct bpf_prog *prog, u32 *offsets, void *image)

include/linux/bpf.h

655

struct bpf_map *bpf_prog_arena(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

108

static inline bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog)

include/linux/bpf_lsm.h

31

const struct bpf_prog *prog);

include/linux/bpf_lsm.h

34

bool bpf_lsm_is_trusted(const struct bpf_prog *prog);

include/linux/bpf_lsm.h

49

void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog, bpf_func_t *bpf_func);

include/linux/bpf_lsm.h

51

int bpf_lsm_get_retval_range(const struct bpf_prog *prog,

include/linux/bpf_lsm.h

56

bool bpf_lsm_has_d_inode_locked(const struct bpf_prog *prog);

include/linux/bpf_lsm.h

68

static inline bool bpf_lsm_is_trusted(const struct bpf_prog *prog)

include/linux/bpf_lsm.h

74

const struct bpf_prog *prog)

include/linux/bpf_lsm.h

89

static inline void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,

include/linux/bpf_lsm.h

94

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

1023

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

include/linux/bpf_verifier.h

1130

int bpf_prog_offload_verifier_prep(struct bpf_prog *prog);

include/linux/bpf_verifier.h

1165

const struct bpf_prog *prog,

include/linux/bpf_verifier.h

1280

static inline enum bpf_prog_type resolve_prog_type(const struct bpf_prog *prog)

include/linux/bpf_verifier.h

1282

return (prog->type == BPF_PROG_TYPE_EXT && prog->aux->saved_dst_prog_type) ?

include/linux/bpf_verifier.h

1283

prog->aux->saved_dst_prog_type : prog->type;

include/linux/bpf_verifier.h

1286

static inline bool bpf_prog_check_recur(const struct bpf_prog *prog)

include/linux/bpf_verifier.h

1288

switch (resolve_prog_type(prog)) {

include/linux/bpf_verifier.h

1290

return prog->expected_attach_type != BPF_TRACE_ITER;

include/linux/bpf_verifier.h

1292

return prog->aux->jits_use_priv_stack;

include/linux/bpf_verifier.h

1596

int bpf_check_attach_btf_id_multi(struct btf *btf, struct bpf_prog *prog, u32 btf_id,

include/linux/bpf_verifier.h

907

struct bpf_prog *prog; /* eBPF program being verified */

include/linux/btf.h

119

typedef int (*btf_kfunc_filter_t)(const struct bpf_prog *prog, u32 kfunc_id);

include/linux/btf.h

579

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog);

include/linux/btf.h

580

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

582

bool btf_kfunc_is_allowed(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog);

include/linux/btf.h

584

const struct bpf_prog *prog);

include/linux/btf.h

645

struct bpf_prog *prog)

include/linux/filter.h

1002

res = bpf_prog_run(prog, skb);

include/linux/filter.h

1004

if (unlikely(prog->cb_access))

include/linux/filter.h

1010

static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog,

include/linux/filter.h

1016

res = __bpf_prog_run_save_cb(prog, skb);

include/linux/filter.h

1021

static inline u32 bpf_prog_run_clear_cb(const struct bpf_prog *prog,

include/linux/filter.h

1027

if (unlikely(prog->cb_access))

include/linux/filter.h

1030

res = bpf_prog_run_pin_on_cpu(prog, skb);

include/linux/filter.h

1040

void bpf_prog_change_xdp(struct bpf_prog *prev_prog, struct bpf_prog *prog);

include/linux/filter.h

1042

static inline u32 bpf_prog_insn_size(const struct bpf_prog *prog)

include/linux/filter.h

1044

return prog->len * sizeof(struct bpf_insn);

include/linux/filter.h

1053

static inline bool bpf_prog_was_classic(const struct bpf_prog *prog)

include/linux/filter.h

1060

return prog->type == BPF_PROG_TYPE_UNSPEC;

include/linux/filter.h

1141

void bpf_prog_fill_jited_linfo(struct bpf_prog *prog,

include/linux/filter.h

1143

int bpf_prog_alloc_jited_linfo(struct bpf_prog *prog);

include/linux/filter.h

1144

void bpf_prog_jit_attempt_done(struct bpf_prog *prog);

include/linux/filter.h

1169

void sk_reuseport_prog_free(struct bpf_prog *prog);

include/linux/filter.h

1178

struct bpf_prog *bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog);

include/linux/filter.h

1179

void bpf_jit_compile(struct bpf_prog *prog);

include/linux/filter.h

1208

struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,

include/linux/filter.h

1235

int bpf_remove_insns(struct bpf_prog *prog, u32 off, u32 cnt);

include/linux/filter.h

1280

struct xdp_buff *xdp, const struct bpf_prog *prog);

include/linux/filter.h

1283

const struct bpf_prog *prog);

include/linux/filter.h

1287

const struct bpf_prog *prog);

include/linux/filter.h

1291

const struct bpf_prog *prog, u32 act);

include/linux/filter.h

1295

struct bpf_prog *prog, struct sk_buff *skb,

include/linux/filter.h

1301

struct bpf_prog *prog, struct sk_buff *skb,

include/linux/filter.h

1362

int bpf_jit_add_poke_descriptor(struct bpf_prog *prog,

include/linux/filter.h

1365

int bpf_jit_get_func_addr(const struct bpf_prog *prog,

include/linux/filter.h

1369

const char *bpf_jit_get_prog_name(struct bpf_prog *prog);

include/linux/filter.h

1371

struct bpf_prog *bpf_jit_blind_constants(struct bpf_verifier_env *env, struct bpf_prog *prog);

include/linux/filter.h

1374

static inline bool bpf_prog_need_blind(const struct bpf_prog *prog)

include/linux/filter.h

1376

return prog->blinding_requested && !prog->blinded;

include/linux/filter.h

1409

static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)

include/linux/filter.h

1417

if (!prog->jit_requested)

include/linux/filter.h

1421

if (bpf_jit_harden == 1 && bpf_token_capable(prog->aux->token, CAP_BPF))

include/linux/filter.h

1459

static inline bool bpf_jit_blinding_enabled(struct bpf_prog *prog)

include/linux/filter.h

1470

bpf_jit_add_poke_descriptor(struct bpf_prog *prog,

include/linux/filter.h

1517

static inline bool bpf_prog_need_blind(const struct bpf_prog *prog)

include/linux/filter.h

1523

struct bpf_prog *bpf_jit_blind_constants(struct bpf_verifier_env *env, struct bpf_prog *prog)

include/linux/filter.h

1525

return prog;

include/linux/filter.h

1722

while ((_prog = READ_ONCE(_item->prog))) { \

include/linux/filter.h

686

struct bpf_prog *prog;

include/linux/filter.h

701

static __always_inline u32 __bpf_prog_run(const struct bpf_prog *prog,

include/linux/filter.h

713

ret = dfunc(ctx, prog->insnsi, prog->bpf_func);

include/linux/filter.h

716

if (likely(prog->stats)) {

include/linux/filter.h

717

stats = this_cpu_ptr(prog->stats);

include/linux/filter.h

724

ret = dfunc(ctx, prog->insnsi, prog->bpf_func);

include/linux/filter.h

729

static __always_inline u32 bpf_prog_run(const struct bpf_prog *prog, const void *ctx)

include/linux/filter.h

731

return __bpf_prog_run(prog, ctx, bpf_dispatcher_nop_func);

include/linux/filter.h

742

static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,

include/linux/filter.h

748

ret = bpf_prog_run(prog, ctx);

include/linux/filter.h

929

const struct bpf_prog *prog,

include/linux/filter.h

940

res = bpf_prog_run(prog, skb);

include/linux/filter.h

989

static inline u32 __bpf_prog_run_save_cb(const struct bpf_prog *prog,

include/linux/filter.h

997

if (unlikely(prog->cb_access)) {

include/linux/lsm_hook_defs.h

443

LSM_HOOK(int, 0, bpf_prog, struct bpf_prog *prog)

include/linux/lsm_hook_defs.h

447

LSM_HOOK(int, 0, bpf_prog_load, struct bpf_prog *prog, union bpf_attr *attr,

include/linux/lsm_hook_defs.h

449

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

4388

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

2303

extern int security_bpf_prog(struct bpf_prog *prog);

include/linux/security.h

2307

extern int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

include/linux/security.h

2309

extern void security_bpf_prog_free(struct bpf_prog *prog);

include/linux/security.h

2327

static inline int security_bpf_prog(struct bpf_prog *prog)

include/linux/security.h

2341

static inline int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

include/linux/security.h

2347

static inline void security_bpf_prog_free(struct bpf_prog *prog)

include/linux/skbuff.h

1591

u32 bpf_flow_dissect(struct bpf_prog *prog, struct bpf_flow_dissector *ctx,

include/linux/skbuff.h

3728

const struct bpf_prog *prog);

include/linux/skmsg.h

526

struct bpf_prog *prog)

include/linux/skmsg.h

528

prog = xchg(pprog, prog);

include/linux/skmsg.h

529

if (prog)

include/linux/skmsg.h

530

bpf_prog_put(prog);

include/linux/skmsg.h

534

struct bpf_prog *prog,

include/linux/skmsg.h

537

if (cmpxchg(pprog, old, prog) != old)

include/linux/sunrpc/svc.h

463

struct svc_serv * svc_create_pooled(struct svc_program *prog,

include/linux/trace_events.h

774

int perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog, u64 bpf_cookie);

include/linux/trace_events.h

788

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

include/linux/trace_events.h

789

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

include/linux/trace_events.h

790

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

include/linux/trace_events.h

803

perf_event_attach_bpf_prog(struct perf_event *event, struct bpf_prog *prog, u64 bpf_cookie)

include/linux/trace_events.h

839

bpf_kprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/trace_events.h

844

bpf_uprobe_multi_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)

include/linux/trace_events.h

849

bpf_tracing_multi_attach(struct bpf_prog *prog, const union bpf_attr *attr)

include/linux/trace_events.h

914

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

621

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

821

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-ops.c

141

const struct bpf_prog *prog)

io_uring/bpf-ops.c

76

const struct bpf_prog *prog,

io_uring/bpf-ops.c

86

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

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

108

struct bpf_map *bpf_prog_arena(struct bpf_prog *prog)

kernel/bpf/arena.c

110

struct bpf_arena *arena = prog->aux->arena;

kernel/bpf/arena.c

1126

static void __bpf_prog_report_arena_violation(struct bpf_prog *prog, bool write,

kernel/bpf/arena.c

1133

prog = prog->aux->main_prog_aux->prog;

kernel/bpf/arena.c

1135

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

kernel/bpf/arena.c

1138

bpf_stream_stage(ss, prog, BPF_STDERR, ({

kernel/bpf/arena.c

1148

struct bpf_prog *prog;

kernel/bpf/arena.c

1152

prog = bpf_prog_find_from_stack();

kernel/bpf/arena.c

1153

if (!prog)

kernel/bpf/arena.c

1156

arena = prog->aux->arena;

kernel/bpf/arena.c

1174

__bpf_prog_report_arena_violation(prog, is_write, page_addr - kbase, fault_ip);

kernel/bpf/arena.c

1180

struct bpf_prog *prog;

kernel/bpf/arena.c

1188

prog = bpf_prog_ksym_find(fault_ip);

kernel/bpf/arena.c

1190

if (!prog)

kernel/bpf/arena.c

1192

__bpf_prog_report_arena_violation(prog, write, addr, fault_ip);

kernel/bpf/arraymap.c

1000

mutex_unlock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

1002

bpf_prog_put(prog);

kernel/bpf/arraymap.c

652

struct bpf_prog *prog;

kernel/bpf/arraymap.c

658

prog = bpf_iter_get_info(&meta, v == NULL);

kernel/bpf/arraymap.c

659

if (!prog)

kernel/bpf/arraymap.c

682

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/arraymap.c

964

struct bpf_prog *prog = bpf_prog_get(fd);

kernel/bpf/arraymap.c

967

if (IS_ERR(prog))

kernel/bpf/arraymap.c

968

return prog;

kernel/bpf/arraymap.c

970

if (prog->type == BPF_PROG_TYPE_EXT ||

kernel/bpf/arraymap.c

971

!bpf_prog_map_compatible(map, prog)) {

kernel/bpf/arraymap.c

972

bpf_prog_put(prog);

kernel/bpf/arraymap.c

976

mutex_lock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

977

is_extended = prog->aux->is_extended;

kernel/bpf/arraymap.c

979

prog->aux->prog_array_member_cnt++;

kernel/bpf/arraymap.c

980

mutex_unlock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

987

bpf_prog_put(prog);

kernel/bpf/arraymap.c

991

return prog;

kernel/bpf/arraymap.c

996

struct bpf_prog *prog = ptr;

kernel/bpf/arraymap.c

998

mutex_lock(&prog->aux->ext_mutex);

kernel/bpf/arraymap.c

999

prog->aux->prog_array_member_cnt--;

kernel/bpf/backtrack.c

270

struct bpf_insn *insn = env->prog->insnsi + idx;

kernel/bpf/backtrack.c

552

bpf_pseudo_call(&env->prog->insnsi[subseq_idx - 1]) &&

kernel/bpf/backtrack.c

892

if (i >= env->prog->len) {

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

101

prog->aux->attach_btf_id)) {

kernel/bpf/bpf_lsm.c

107

args = btf_params(prog->aux->attach_func_proto);

kernel/bpf/bpf_lsm.c

120

const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

122

u32 btf_id = prog->aux->attach_btf_id;

kernel/bpf/bpf_lsm.c

123

const char *func_name = prog->aux->attach_func_name;

kernel/bpf/bpf_lsm.c

125

if (!prog->gpl_compatible) {

kernel/bpf/bpf_lsm.c

174

static bool bpf_ima_inode_hash_allowed(const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

176

return bpf_lsm_is_sleepable_hook(prog->aux->attach_btf_id);

kernel/bpf/bpf_lsm.c

228

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

kernel/bpf/bpf_lsm.c

232

if (prog->expected_attach_type == BPF_LSM_CGROUP) {

kernel/bpf/bpf_lsm.c

233

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/bpf_lsm.c

260

return bpf_prog_has_trampoline(prog) ? &bpf_get_attach_cookie_proto : NULL;

kernel/bpf/bpf_lsm.c

263

if (prog->expected_attach_type != BPF_LSM_CGROUP)

kernel/bpf/bpf_lsm.c

266

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

269

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

273

if (prog->expected_attach_type != BPF_LSM_CGROUP)

kernel/bpf/bpf_lsm.c

276

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

279

prog->aux->attach_btf_id))

kernel/bpf/bpf_lsm.c

284

return tracing_prog_func_proto(func_id, prog);

kernel/bpf/bpf_lsm.c

409

bool bpf_lsm_is_trusted(const struct bpf_prog *prog)

kernel/bpf/bpf_lsm.c

411

return !btf_id_set_contains(&untrusted_lsm_hooks, prog->aux->attach_btf_id);

kernel/bpf/bpf_lsm.c

453

int bpf_lsm_get_retval_range(const struct bpf_prog *prog,

kernel/bpf/bpf_lsm.c

457

if (!prog->aux->attach_func_proto->type)

kernel/bpf/bpf_lsm.c

460

if (btf_id_set_contains(&bool_lsm_hooks, prog->aux->attach_btf_id)) {

kernel/bpf/bpf_lsm.c

94

void bpf_lsm_find_cgroup_shim(const struct bpf_prog *prog,

kernel/bpf/bpf_lsm.c

99

if (btf_type_vlen(prog->aux->attach_func_proto) < 1 ||

kernel/bpf/bpf_struct_ops.c

1222

int (*cb)(struct bpf_prog *prog, void *data),

kernel/bpf/bpf_struct_ops.c

1236

ret = cb(st_map->links[i]->prog, data);

kernel/bpf/bpf_struct_ops.c

1452

int bpf_prog_assoc_struct_ops(struct bpf_prog *prog, struct bpf_map *map)

kernel/bpf/bpf_struct_ops.c

1456

guard(mutex)(&prog->aux->st_ops_assoc_mutex);

kernel/bpf/bpf_struct_ops.c

1458

st_ops_assoc = rcu_dereference_protected(prog->aux->st_ops_assoc,

kernel/bpf/bpf_struct_ops.c

1459

lockdep_is_held(&prog->aux->st_ops_assoc_mutex));

kernel/bpf/bpf_struct_ops.c

1464

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1467

rcu_assign_pointer(prog->aux->st_ops_assoc, BPF_PTR_POISON);

kernel/bpf/bpf_struct_ops.c

1473

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1476

rcu_assign_pointer(prog->aux->st_ops_assoc, map);

kernel/bpf/bpf_struct_ops.c

1482

void bpf_prog_disassoc_struct_ops(struct bpf_prog *prog)

kernel/bpf/bpf_struct_ops.c

1486

guard(mutex)(&prog->aux->st_ops_assoc_mutex);

kernel/bpf/bpf_struct_ops.c

1488

st_ops_assoc = rcu_dereference_protected(prog->aux->st_ops_assoc,

kernel/bpf/bpf_struct_ops.c

1489

lockdep_is_held(&prog->aux->st_ops_assoc_mutex));

kernel/bpf/bpf_struct_ops.c

1493

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/bpf_struct_ops.c

1496

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

816

bpf_prog_put(prog);

kernel/bpf/bpf_struct_ops.c

821

&bpf_struct_ops_link_lops, prog, prog->expected_attach_type, 0);

kernel/bpf/bpf_struct_ops.c

826

bpf_prog_assoc_struct_ops(prog, &st_map->map);

kernel/bpf/bpf_struct_ops.c

853

*(unsigned long *)(udata + moff) = prog->aux->id;

kernel/bpf/btf.c

6577

struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog)

kernel/bpf/btf.c

6579

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/btf.c

6584

return prog->aux->attach_btf;

kernel/bpf/btf.c

6615

static bool prog_args_trusted(const struct bpf_prog *prog)

kernel/bpf/btf.c

6617

enum bpf_attach_type atype = prog->expected_attach_type;

kernel/bpf/btf.c

6619

switch (prog->type) {

kernel/bpf/btf.c

6623

return bpf_lsm_is_trusted(prog);

kernel/bpf/btf.c

6849

const struct bpf_prog *prog,

kernel/bpf/btf.c

6856

const struct btf_type *t = prog->aux->attach_func_proto;

kernel/bpf/btf.c

6857

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/btf.c

6858

struct btf *btf = bpf_prog_get_target_btf(prog);

kernel/bpf/btf.c

6859

const char *tname = prog->aux->attach_func_name;

kernel/bpf/btf.c

6878

if (prog->aux->attach_btf_trace) {

kernel/bpf/btf.c

6891

switch (prog->expected_attach_type) {

kernel/bpf/btf.c

6965

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

kernel/bpf/btf.c

6966

const struct bpf_ctx_arg_aux *ctx_arg_info = &prog->aux->ctx_arg_info[i];

kernel/bpf/btf.c

6990

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

kernel/bpf/btf.c

6991

const struct bpf_ctx_arg_aux *ctx_arg_info = &prog->aux->ctx_arg_info[i];

kernel/bpf/btf.c

7008

if (prog_args_trusted(prog))

kernel/bpf/btf.c

7014

if (prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/btf.c

7015

struct btf *btf = prog->aux->attach_btf;

kernel/bpf/btf.c

7020

t = btf_type_by_id(btf, prog->aux->attach_btf_id);

kernel/bpf/btf.c

7727

int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,

kernel/bpf/btf.c

7730

struct btf *btf1 = prog->aux->btf;

kernel/bpf/btf.c

7734

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

kernel/bpf/btf.c

7739

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

kernel/bpf/btf.c

7982

struct bpf_prog *prog = env->prog;

kernel/bpf/btf.c

7983

enum bpf_prog_type prog_type = prog->type;

kernel/bpf/btf.c

7984

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

kernel/bpf/btf.c

7994

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

kernel/bpf/btf.c

7999

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

kernel/bpf/btf.c

8018

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

kernel/bpf/btf.c

8023

prog_type = prog->aux->dst_prog->type;

kernel/bpf/btf.c

8090

prog->expected_attach_type))

kernel/bpf/btf.c

9010

const struct bpf_prog *prog)

kernel/bpf/btf.c

9022

if (hook_filter->filters[i](prog, kfunc_btf_id))

kernel/bpf/btf.c

9078

const struct bpf_prog *prog)

kernel/bpf/btf.c

9080

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/btf.c

9085

if (kfunc_flags && __btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_COMMON, kfunc_btf_id, prog))

kernel/bpf/btf.c

9090

if (kfunc_flags && __btf_kfunc_is_allowed(btf, hook, kfunc_btf_id, prog))

kernel/bpf/btf.c

9103

u32 *btf_kfunc_flags(const struct btf *btf, u32 kfunc_btf_id, const struct bpf_prog *prog)

kernel/bpf/btf.c

9105

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/btf.c

9147

const struct bpf_prog *prog)

kernel/bpf/btf.c

9149

if (!__btf_kfunc_is_allowed(btf, BTF_KFUNC_HOOK_FMODRET, kfunc_btf_id, prog))

kernel/bpf/cfg.c

113

if (w < 0 || w >= env->prog->len) {

kernel/bpf/cfg.c

129

if (env->cfg.cur_stack >= env->prog->len)

kernel/bpf/cfg.c

375

if (w < 0 || w >= env->prog->len) {

kernel/bpf/cfg.c

386

if (env->cfg.cur_stack >= env->prog->len)

kernel/bpf/cfg.c

428

struct bpf_insn *insns = env->prog->insnsi, *insn = &insns[t];

kernel/bpf/cfg.c

564

int insn_cnt = env->prog->len;

kernel/bpf/cfg.c

623

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

kernel/bpf/cfg.c

640

env->prog->aux->changes_pkt_data = env->subprog_info[0].changes_pkt_data;

kernel/bpf/cfg.c

641

env->prog->aux->might_sleep = env->subprog_info[0].might_sleep;

kernel/bpf/cfg.c

661

postorder = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

662

state = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

663

stack = kvzalloc_objs(int, env->prog->len, GFP_KERNEL_ACCOUNT);

kernel/bpf/cfg.c

713

const u32 insn_cnt = env->prog->len;

kernel/bpf/cgroup.c

101

while ((prog = READ_ONCE(item->prog))) {

kernel/bpf/cgroup.c

1017

WRITE_ONCE(item->prog, pl->link->link.prog);

kernel/bpf/cgroup.c

103

func_ret = run_prog(prog, ctx);

kernel/bpf/cgroup.c

1047

if (link->link.prog->type != new_prog->type)

kernel/bpf/cgroup.c

1060

old_prog = xchg(&link->link.prog, new_prog);

kernel/bpf/cgroup.c

1080

if (old_prog && link->prog != old_prog) {

kernel/bpf/cgroup.c

1091

struct bpf_prog *prog,

kernel/bpf/cgroup.c

1108

if (!prog && !link)

kernel/bpf/cgroup.c

1116

if (pl->prog == prog && pl->link == link)

kernel/bpf/cgroup.c

1172

static int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,

kernel/bpf/cgroup.c

1183

if (prog)

kernel/bpf/cgroup.c

1184

attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/cgroup.c

1186

attach_btf_id = link->link.prog->aux->attach_btf_id;

kernel/bpf/cgroup.c

1198

if (prog && link)

kernel/bpf/cgroup.c

1202

pl = find_detach_entry(progs, prog, link, flags & BPF_F_ALLOW_MULTI);

kernel/bpf/cgroup.c

1207

old_prog = pl->prog;

kernel/bpf/cgroup.c

1208

pl->prog = NULL;

kernel/bpf/cgroup.c

1213

pl->prog = old_prog;

kernel/bpf/cgroup.c

1235

static int cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,

kernel/bpf/cgroup.c

1241

ret = __cgroup_bpf_detach(cgrp, prog, NULL, type, revision);

kernel/bpf/cgroup.c

1320

struct bpf_prog *prog;

kernel/bpf/cgroup.c

1327

prog = prog_list_prog(pl);

kernel/bpf/cgroup.c

1328

id = prog->aux->id;

kernel/bpf/cgroup.c

1364

enum bpf_prog_type ptype, struct bpf_prog *prog)

kernel/bpf/cgroup.c

1383

ret = cgroup_bpf_attach(cgrp, prog, replace_prog, NULL,

kernel/bpf/cgroup.c

1395

struct bpf_prog *prog;

kernel/bpf/cgroup.c

1403

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/cgroup.c

1404

if (IS_ERR(prog))

kernel/bpf/cgroup.c

1405

prog = NULL;

kernel/bpf/cgroup.c

1407

ret = cgroup_bpf_detach(cgrp, prog, attr->attach_type, attr->expected_revision);

kernel/bpf/cgroup.c

1408

if (prog)

kernel/bpf/cgroup.c

1409

bpf_prog_put(prog);

kernel/bpf/cgroup.c

1438

bpf_trampoline_unlink_cgroup_shim(cg_link->link.prog);

kernel/bpf/cgroup.c

1515

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

kernel/bpf/cgroup.c

1535

prog, attr->link_create.attach_type);

kernel/bpf/cgroup.c

1852

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

kernel/bpf/cgroup.c

1856

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

1864

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

1870

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

2400

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

kernel/bpf/cgroup.c

2404

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2422

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2427

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

2456

struct bpf_prog *prog, u32 *target_size)

kernel/bpf/cgroup.c

2543

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

kernel/bpf/cgroup.c

2547

func_proto = cgroup_common_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2560

if (prog->expected_attach_type == BPF_CGROUP_SETSOCKOPT)

kernel/bpf/cgroup.c

2564

if (prog->expected_attach_type == BPF_CGROUP_SETSOCKOPT)

kernel/bpf/cgroup.c

2575

return bpf_base_func_proto(func_id, prog);

kernel/bpf/cgroup.c

2581

const struct bpf_prog *prog,

kernel/bpf/cgroup.c

259

struct bpf_prog *prog,

kernel/bpf/cgroup.c

2597

return prog->expected_attach_type ==

kernel/bpf/cgroup.c

2604

return prog->expected_attach_type ==

kernel/bpf/cgroup.c

2632

return prog->expected_attach_type == BPF_CGROUP_GETSOCKOPT;

kernel/bpf/cgroup.c

2656

struct bpf_prog *prog,

kernel/bpf/cgroup.c

270

map = prog->aux->cgroup_storage[stype];

kernel/bpf/cgroup.c

2733

const struct bpf_prog *prog)

kernel/bpf/cgroup.c

2752

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

kernel/bpf/cgroup.c

2758

switch (prog->expected_attach_type) {

kernel/bpf/cgroup.c

2776

switch (prog->expected_attach_type) {

kernel/bpf/cgroup.c

278

storages[stype] = bpf_cgroup_storage_alloc(prog, stype);

kernel/bpf/cgroup.c

344

if (pl->prog) {

kernel/bpf/cgroup.c

345

if (pl->prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/cgroup.c

346

bpf_trampoline_unlink_cgroup_shim(pl->prog);

kernel/bpf/cgroup.c

347

bpf_prog_put(pl->prog);

kernel/bpf/cgroup.c

350

if (pl->link->link.prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/cgroup.c

351

bpf_trampoline_unlink_cgroup_shim(pl->link->link.prog);

kernel/bpf/cgroup.c

395

if (pl->prog)

kernel/bpf/cgroup.c

396

return pl->prog;

kernel/bpf/cgroup.c

398

return pl->link->link.prog;

kernel/bpf/cgroup.c

495

item->prog = prog_list_prog(pl);

kernel/bpf/cgroup.c

644

struct bpf_prog *prog,

kernel/bpf/cgroup.c

659

if (prog && pl->prog == prog && prog != replace_prog)

kernel/bpf/cgroup.c

670

if (pl->prog == replace_prog)

kernel/bpf/cgroup.c

694

struct bpf_prog *prog = ERR_PTR(-EINVAL);

kernel/bpf/cgroup.c

697

prog = bpf_prog_by_id(id_or_fd);

kernel/bpf/cgroup.c

699

prog = bpf_prog_get(id_or_fd);

kernel/bpf/cgroup.c

700

return prog;

kernel/bpf/cgroup.c

703

static struct bpf_prog_list *get_prog_list(struct hlist_head *progs, struct bpf_prog *prog,

kernel/bpf/cgroup.c

719

if ((is_link && !link) || (!is_link && !prog))

kernel/bpf/cgroup.c

753

if ((anchor_prog && anchor_prog == pltmp->prog) ||

kernel/bpf/cgroup.c

772

struct bpf_prog *prog, struct bpf_cgroup_link *link,

kernel/bpf/cgroup.c

777

pltmp = get_prog_list(progs, prog, link, flags, id_or_fd);

kernel/bpf/cgroup.c

807

struct bpf_prog *prog, struct bpf_prog *replace_prog,

kernel/bpf/cgroup.c

816

struct bpf_prog *new_prog = prog ? : link->link.prog;

kernel/bpf/cgroup.c

829

if (link && (prog || replace_prog))

kernel/bpf/cgroup.c

857

pl = find_attach_entry(progs, prog, link, replace_prog,

kernel/bpf/cgroup.c

863

prog ? : link->link.prog, cgrp))

kernel/bpf/cgroup.c

867

old_prog = pl->prog;

kernel/bpf/cgroup.c

875

err = insert_pl_to_hlist(pl, progs, prog, link, flags, id_or_fd);

kernel/bpf/cgroup.c

883

pl->prog = prog;

kernel/bpf/cgroup.c

90

const struct bpf_prog *prog;

kernel/bpf/cgroup.c

916

pl->prog = old_prog;

kernel/bpf/cgroup.c

928

struct bpf_prog *prog, struct bpf_prog *replace_prog,

kernel/bpf/cgroup.c

936

ret = __cgroup_bpf_attach(cgrp, prog, replace_prog, link, type, flags,

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/check_btf.c

124

prog->aux->func_info = krecord;

kernel/bpf/check_btf.c

125

prog->aux->func_info_cnt = nfuncs;

kernel/bpf/check_btf.c

141

struct bpf_prog *prog;

kernel/bpf/check_btf.c

160

prog = env->prog;

kernel/bpf/check_btf.c

161

btf = prog->aux->btf;

kernel/bpf/check_btf.c

165

krecord = prog->aux->func_info;

kernel/bpf/check_btf.c

202

prog->aux->func_info_aux = info_aux;

kernel/bpf/check_btf.c

220

struct bpf_prog *prog;

kernel/bpf/check_btf.c

245

prog = env->prog;

kernel/bpf/check_btf.c

246

btf = prog->aux->btf;

kernel/bpf/check_btf.c

283

linfo[i].insn_off >= prog->len) {

kernel/bpf/check_btf.c

286

prog->len);

kernel/bpf/check_btf.c

291

if (!prog->insnsi[linfo[i].insn_off].code) {

kernel/bpf/check_btf.c

328

prog->aux->linfo = linfo;

kernel/bpf/check_btf.c

329

prog->aux->nr_linfo = nr_linfo;

kernel/bpf/check_btf.c

347

struct bpf_prog *prog = env->prog;

kernel/bpf/check_btf.c

348

const struct btf *btf = prog->aux->btf;

kernel/bpf/check_btf.c

39

struct bpf_prog *prog;

kernel/bpf/check_btf.c

394

if (core_relo.insn_off % 8 || core_relo.insn_off / 8 >= prog->len) {

kernel/bpf/check_btf.c

396

i, core_relo.insn_off, prog->len);

kernel/bpf/check_btf.c

402

&prog->insnsi[core_relo.insn_off / 8]);

kernel/bpf/check_btf.c

430

env->prog->aux->btf = btf;

kernel/bpf/check_btf.c

60

prog = env->prog;

kernel/bpf/check_btf.c

61

btf = prog->aux->btf;

kernel/bpf/const_fold.c

242

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/const_fold.c

243

int insn_cnt = env->prog->len;

kernel/bpf/const_fold.c

348

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/const_fold.c

349

int insn_cnt = env->prog->len;

kernel/bpf/core.c

127

fp->aux->prog = fp;

kernel/bpf/core.c

1302

int bpf_jit_get_func_addr(const struct bpf_prog *prog,

kernel/bpf/core.c

1319

else if (prog->aux->func &&

kernel/bpf/core.c

1320

off >= 0 && off < prog->aux->real_func_cnt)

kernel/bpf/core.c

1321

addr = (u8 *)prog->aux->func[off]->bpf_func;

kernel/bpf/core.c

1326

err = bpf_get_kfunc_addr(prog, insn->imm, insn->off, &addr);

kernel/bpf/core.c

1342

const char *bpf_jit_get_prog_name(struct bpf_prog *prog)

kernel/bpf/core.c

1344

if (prog->aux->ksym.prog)

kernel/bpf/core.c

1345

return prog->aux->ksym.name;

kernel/bpf/core.c

1346

return prog->aux->name;

kernel/bpf/core.c

153

struct bpf_prog *prog;

kernel/bpf/core.c

1544

fp->aux->prog = fp;

kernel/bpf/core.c

1546

fp->aux->offload->prog = fp;

kernel/bpf/core.c

1554

struct bpf_prog *bpf_jit_blind_constants(struct bpf_verifier_env *env, struct bpf_prog *prog)

kernel/bpf/core.c

156

prog = bpf_prog_alloc_no_stats(size, gfp_extra_flags);

kernel/bpf/core.c

1562

if (WARN_ON_ONCE(env && env->prog != prog))

kernel/bpf/core.c

1565

clone = bpf_prog_clone_create(prog, GFP_USER);

kernel/bpf/core.c

157

if (!prog)

kernel/bpf/core.c

1571

env->prog = clone;

kernel/bpf/core.c

160

prog->stats = alloc_percpu_gfp(struct bpf_prog_stats, gfp_flags);

kernel/bpf/core.c

1608

env->prog = prog;

kernel/bpf/core.c

161

if (!prog->stats) {

kernel/bpf/core.c

1613

bpf_jit_prog_release_other(prog, clone);

kernel/bpf/core.c

162

free_percpu(prog->active);

kernel/bpf/core.c

1621

env->prog = clone;

kernel/bpf/core.c

163

kfree(prog->aux);

kernel/bpf/core.c

1633

bool bpf_insn_is_indirect_target(const struct bpf_verifier_env *env, const struct bpf_prog *prog,

kernel/bpf/core.c

1638

insn_idx += prog->aux->subprog_start;

kernel/bpf/core.c

164

vfree(prog);

kernel/bpf/core.c

1642

u16 bpf_out_stack_arg_cnt(const struct bpf_verifier_env *env, const struct bpf_prog *prog)

kernel/bpf/core.c

1648

sub = &env->subprog_info[prog->aux->func_idx];

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

2157

struct bpf_prog *prog;

kernel/bpf/core.c

2166

prog = READ_ONCE(array->ptrs[index]);

kernel/bpf/core.c

2167

if (!prog)

kernel/bpf/core.c

2177

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

2620

static struct bpf_prog *bpf_prog_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

kernel/bpf/core.c

2626

if (!bpf_prog_need_blind(prog))

kernel/bpf/core.c

2627

return bpf_int_jit_compile(env, prog);

kernel/bpf/core.c

2637

return prog;

kernel/bpf/core.c

2640

orig_prog = prog;

kernel/bpf/core.c

2641

prog = bpf_jit_blind_constants(env, prog);

kernel/bpf/core.c

2646

if (IS_ERR(prog))

kernel/bpf/core.c

2649

prog = bpf_int_jit_compile(env, prog);

kernel/bpf/core.c

2650

if (prog->jited) {

kernel/bpf/core.c

2651

bpf_jit_prog_release_other(prog, orig_prog);

kernel/bpf/core.c

2654

return prog;

kernel/bpf/core.c

2657

bpf_jit_prog_release_other(orig_prog, prog);

kernel/bpf/core.c

2660

prog = orig_prog;

kernel/bpf/core.c

2664

return prog;

kernel/bpf/core.c

273

fp->aux->prog = fp;

kernel/bpf/core.c

2747

struct bpf_prog prog;

kernel/bpf/core.c

2749

.prog = {

kernel/bpf/core.c

2756

{ .prog = NULL },

kernel/bpf/core.c

2804

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

kernel/bpf/core.c

2805

if (item->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2814

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

kernel/bpf/core.c

2815

if (item->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2827

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

kernel/bpf/core.c

2828

if (item->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2830

prog_ids[i] = item->prog->aux->id;

kernel/bpf/core.c

2837

return !!(item->prog);

kernel/bpf/core.c

2871

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

kernel/bpf/core.c

2872

if (item->prog == old_prog) {

kernel/bpf/core.c

2873

WRITE_ONCE(item->prog, &dummy_bpf_prog.prog);

kernel/bpf/core.c

2895

return bpf_prog_array_update_at(array, index, &dummy_bpf_prog.prog);

kernel/bpf/core.c

2914

struct bpf_prog *prog)

kernel/bpf/core.c

2921

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

kernel/bpf/core.c

2922

if (item->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2925

WRITE_ONCE(item->prog, prog);

kernel/bpf/core.c

2949

for (; existing->prog; existing++) {

kernel/bpf/core.c

2950

if (existing->prog == exclude_prog) {

kernel/bpf/core.c

2954

if (existing->prog != &dummy_bpf_prog.prog)

kernel/bpf/core.c

2956

if (existing->prog == include_prog)

kernel/bpf/core.c

2984

for (; existing->prog; existing++) {

kernel/bpf/core.c

2985

if (existing->prog == exclude_prog ||

kernel/bpf/core.c

2986

existing->prog == &dummy_bpf_prog.prog)

kernel/bpf/core.c

2989

new->prog = existing->prog;

kernel/bpf/core.c

2995

new->prog = include_prog;

kernel/bpf/core.c

2999

new->prog = NULL;

kernel/bpf/core.c

3031

sleepable = aux->prog->sleepable;

kernel/bpf/core.c

3077

bpf_prog_stream_free(aux->prog);

kernel/bpf/core.c

3085

bpf_prog_disassoc_struct_ops(aux->prog);

kernel/bpf/core.c

3087

bpf_prog_dev_bound_destroy(aux->prog);

kernel/bpf/core.c

3089

if (aux->prog->has_callchain_buf)

kernel/bpf/core.c

3104

bpf_prog_unlock_free(aux->prog);

kernel/bpf/core.c

3106

bpf_jit_free(aux->prog);

kernel/bpf/core.c

3225

struct bpf_prog * __weak bpf_int_jit_compile(struct bpf_verifier_env *env, struct bpf_prog *prog)

kernel/bpf/core.c

3227

return prog;

kernel/bpf/core.c

3233

void __weak bpf_jit_compile(struct bpf_prog *prog)

kernel/bpf/core.c

3395

struct bpf_prog *prog;

kernel/bpf/core.c

3397

prog = bpf_prog_find_from_stack();

kernel/bpf/core.c

3398

if (!prog)

kernel/bpf/core.c

3400

bpf_stream_stage(ss, prog, BPF_STDERR, ({

kernel/bpf/core.c

3486

const struct bpf_line_info *bpf_find_linfo(const struct bpf_prog *prog, u32 insn_off)

kernel/bpf/core.c

3492

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/core.c

3493

if (!nr_linfo || insn_off >= prog->len)

kernel/bpf/core.c

3496

linfo = prog->aux->linfo;

kernel/bpf/core.c

3523

int bpf_prog_get_file_line(struct bpf_prog *prog, unsigned long ip, const char **filep,

kernel/bpf/core.c

3532

btf = prog->aux->btf;

kernel/bpf/core.c

3533

linfo = prog->aux->linfo;

kernel/bpf/core.c

3534

jited_linfo = prog->aux->jited_linfo;

kernel/bpf/core.c

3538

len = prog->aux->func ? prog->aux->func[prog->aux->func_idx]->len : prog->len;

kernel/bpf/core.c

3540

linfo = &prog->aux->linfo[prog->aux->linfo_idx];

kernel/bpf/core.c

3541

jited_linfo = &prog->aux->jited_linfo[prog->aux->linfo_idx];

kernel/bpf/core.c

3545

nr_linfo = prog->aux->nr_linfo - prog->aux->linfo_idx;

kernel/bpf/core.c

3562

struct bpf_prog *prog;

kernel/bpf/core.c

3568

struct bpf_prog *prog;

kernel/bpf/core.c

3576

prog = bpf_prog_ksym_find(ip);

kernel/bpf/core.c

3578

if (!prog)

kernel/bpf/core.c

3581

ctxp->prog = prog->aux->main_prog_aux->prog;

kernel/bpf/core.c

3590

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(xdpf->dev_rx, rcpu->prog, act);

kernel/bpf/cpumap.c

229

trace_xdp_exception(xdpf->dev_rx, rcpu->prog, act);

kernel/bpf/cpumap.c

256

if (!rcpu->prog)

kernel/bpf/cpumap.c

416

struct bpf_prog *prog;

kernel/bpf/cpumap.c

418

prog = bpf_prog_get_type(fd, BPF_PROG_TYPE_XDP);

kernel/bpf/cpumap.c

419

if (IS_ERR(prog))

kernel/bpf/cpumap.c

420

return PTR_ERR(prog);

kernel/bpf/cpumap.c

422

if (prog->expected_attach_type != BPF_XDP_CPUMAP ||

kernel/bpf/cpumap.c

423

!bpf_prog_map_compatible(map, prog)) {

kernel/bpf/cpumap.c

424

bpf_prog_put(prog);

kernel/bpf/cpumap.c

428

rcpu->value.bpf_prog.id = prog->aux->id;

kernel/bpf/cpumap.c

429

rcpu->prog = prog;

kernel/bpf/cpumap.c

506

if (rcpu->prog)

kernel/bpf/cpumap.c

507

bpf_prog_put(rcpu->prog);

kernel/bpf/cpumap.c

537

if (rcpu->prog)

kernel/bpf/cpumap.c

538

bpf_prog_put(rcpu->prog);

kernel/bpf/cpumap.c

72

struct bpf_prog *prog;

kernel/bpf/devmap.c

906

struct bpf_prog *prog = NULL;

kernel/bpf/devmap.c

920

prog = bpf_prog_get_type_dev(val->bpf_prog.fd,

kernel/bpf/devmap.c

922

if (IS_ERR(prog))

kernel/bpf/devmap.c

924

if (prog->expected_attach_type != BPF_XDP_DEVMAP ||

kernel/bpf/devmap.c

925

!bpf_prog_map_compatible(&dtab->map, prog))

kernel/bpf/devmap.c

930

if (prog) {

kernel/bpf/devmap.c

931

dev->xdp_prog = prog;

kernel/bpf/devmap.c

932

dev->val.bpf_prog.id = prog->aux->id;

kernel/bpf/devmap.c

941

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/fixups.c

1005

env->subprog_info[env->subprog_cnt].start = env->prog->len;

kernel/bpf/fixups.c

1013

size = array_size(sizeof(struct bpf_insn_aux_data), env->prog->len);

kernel/bpf/fixups.c

1030

struct bpf_prog *prog = env->prog, **func, *tmp;

kernel/bpf/fixups.c

1037

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

kernel/bpf/fixups.c

1074

err = bpf_prog_alloc_jited_linfo(prog);

kernel/bpf/fixups.c

1079

func = kzalloc_objs(prog, env->subprog_cnt);

kernel/bpf/fixups.c

1096

memcpy(func[i]->insnsi, &prog->insnsi[subprog_start],

kernel/bpf/fixups.c

1098

func[i]->type = prog->type;

kernel/bpf/fixups.c

1103

func[i]->sleepable = prog->sleepable;

kernel/bpf/fixups.c

1104

func[i]->blinded = prog->blinded;

kernel/bpf/fixups.c

1107

func[i]->aux->btf = prog->aux->btf;

kernel/bpf/fixups.c

1109

func[i]->aux->func_info = prog->aux->func_info;

kernel/bpf/fixups.c

1110

func[i]->aux->func_info_cnt = prog->aux->func_info_cnt;

kernel/bpf/fixups.c

1111

func[i]->aux->poke_tab = prog->aux->poke_tab;

kernel/bpf/fixups.c

1112

func[i]->aux->size_poke_tab = prog->aux->size_poke_tab;

kernel/bpf/fixups.c

1113

func[i]->aux->main_prog_aux = prog->aux;

kernel/bpf/fixups.c

1115

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

kernel/bpf/fixups.c

1118

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

kernel/bpf/fixups.c

112

tab = env->prog->aux->kfunc_tab;

kernel/bpf/fixups.c

1130

func[i]->blinding_requested = prog->blinding_requested;

kernel/bpf/fixups.c

1131

func[i]->aux->kfunc_tab = prog->aux->kfunc_tab;

kernel/bpf/fixups.c

1132

func[i]->aux->kfunc_btf_tab = prog->aux->kfunc_btf_tab;

kernel/bpf/fixups.c

1133

func[i]->aux->linfo = prog->aux->linfo;

kernel/bpf/fixups.c

1134

func[i]->aux->nr_linfo = prog->aux->nr_linfo;

kernel/bpf/fixups.c

1135

func[i]->aux->jited_linfo = prog->aux->jited_linfo;

kernel/bpf/fixups.c

1137

func[i]->aux->arena = prog->aux->arena;

kernel/bpf/fixups.c

1162

func[i]->aux->token = prog->aux->token;

kernel/bpf/fixups.c

1244

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

kernel/bpf/fixups.c

1258

prog->jited = 1;

kernel/bpf/fixups.c

1259

prog->bpf_func = func[0]->bpf_func;

kernel/bpf/fixups.c

1260

prog->jited_len = func[0]->jited_len;

kernel/bpf/fixups.c

1261

prog->aux->extable = func[0]->aux->extable;

kernel/bpf/fixups.c

1262

prog->aux->num_exentries = func[0]->aux->num_exentries;

kernel/bpf/fixups.c

1263

prog->aux->func = func;

kernel/bpf/fixups.c

1264

prog->aux->func_cnt = env->subprog_cnt - env->hidden_subprog_cnt;

kernel/bpf/fixups.c

1265

prog->aux->real_func_cnt = env->subprog_cnt;

kernel/bpf/fixups.c

1266

prog->aux->bpf_exception_cb = (void *)func[env->exception_callback_subprog]->bpf_func;

kernel/bpf/fixups.c

1267

prog->aux->exception_boundary = func[0]->aux->exception_boundary;

kernel/bpf/fixups.c

1268

prog->aux->stack_arg_sp_adjust = func[0]->aux->stack_arg_sp_adjust;

kernel/bpf/fixups.c

1269

bpf_prog_jit_attempt_done(prog);

kernel/bpf/fixups.c

1276

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

kernel/bpf/fixups.c

1277

map_ptr = prog->aux->poke_tab[i].tail_call.map;

kernel/bpf/fixups.c

1278

map_ptr->ops->map_poke_untrack(map_ptr, prog->aux);

kernel/bpf/fixups.c

1292

bpf_prog_jit_attempt_done(prog);

kernel/bpf/fixups.c

1301

struct bpf_prog *prog, *orig_prog;

kernel/bpf/fixups.c

1308

prog = orig_prog = env->prog;

kernel/bpf/fixups.c

1309

if (bpf_prog_need_blind(prog)) {

kernel/bpf/fixups.c

1321

prog = bpf_jit_blind_constants(env, prog);

kernel/bpf/fixups.c

1322

if (IS_ERR(prog)) {

kernel/bpf/fixups.c

1324

prog = orig_prog;

kernel/bpf/fixups.c

1335

bpf_jit_prog_release_other(prog, orig_prog);

kernel/bpf/fixups.c

1344

bpf_jit_prog_release_other(orig_prog, prog);

kernel/bpf/fixups.c

1346

prog = env->prog = orig_prog;

kernel/bpf/fixups.c

1355

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

kernel/bpf/fixups.c

1371

prog->jit_requested = 0;

kernel/bpf/fixups.c

1372

prog->blinding_requested = 0;

kernel/bpf/fixups.c

1379

struct bpf_prog *prog = env->prog;

kernel/bpf/fixups.c

1380

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/fixups.c

1381

bool has_kfunc_call = bpf_prog_has_kfunc_call(prog);

kernel/bpf/fixups.c

1398

if (env->prog->jit_requested &&

kernel/bpf/fixups.c

1399

!bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/fixups.c

1417

if (env->subprog_cnt > 1 && env->prog->aux->tail_call_reachable) {

kernel/bpf/fixups.c

1424

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

kernel/bpf/fixups.c

1456

struct bpf_prog *prog;

kernel/bpf/fixups.c

1467

prog = bpf_patch_insn_data(env, env->prog->len - 1, patch, len);

kernel/bpf/fixups.c

1468

if (!prog)

kernel/bpf/fixups.c

1470

env->prog = prog;

kernel/bpf/fixups.c

1472

info[cnt].start = prog->len - len + 1;

kernel/bpf/fixups.c

1483

struct bpf_prog *prog = env->prog;

kernel/bpf/fixups.c

1484

enum bpf_attach_type eatype = prog->expected_attach_type;

kernel/bpf/fixups.c

1485

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/fixups.c

1486

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/fixups.c

1488

const int insn_cnt = prog->len;

kernel/bpf/fixups.c

1502

*patch++ = env->prog->insnsi[insn_cnt - 1];

kernel/bpf/fixups.c

1508

prog = env->prog;

kernel/bpf/fixups.c

1509

insn = prog->insnsi;

kernel/bpf/fixups.c

1519

(((struct bpf_map *)env->prog->aux->arena)->map_flags & BPF_F_NO_USER_CONV)) {

kernel/bpf/fixups.c

1557

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1648

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1678

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1698

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1751

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1796

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1817

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1838

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1848

prog->dst_needed = 1;

kernel/bpf/fixups.c

1852

prog->kprobe_override = 1;

kernel/bpf/fixups.c

1859

prog->cb_access = 1;

kernel/bpf/fixups.c

1861

prog->aux->stack_depth = MAX_BPF_STACK;

kernel/bpf/fixups.c

1862

prog->aux->max_pkt_offset = MAX_PACKET_OFF;

kernel/bpf/fixups.c

1873

if (env->bpf_capable && !prog->blinding_requested &&

kernel/bpf/fixups.c

1874

prog->jit_requested &&

kernel/bpf/fixups.c

1885

ret = bpf_jit_add_poke_descriptor(prog, &desc);

kernel/bpf/fixups.c

1923

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1943

BPF_LD_IMM64(BPF_REG_3, (long)prog->aux),

kernel/bpf/fixups.c

1956

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1975

env->prog = prog = new_prog;

kernel/bpf/fixups.c

1984

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/fixups.c

2016

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2080

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/fixups.c

2099

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2127

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2145

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2154

int nr_args = btf_type_vlen(prog->aux->attach_func_proto);

kernel/bpf/fixups.c

2179

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2211

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2220

int nr_args = btf_type_vlen(prog->aux->attach_func_proto);

kernel/bpf/fixups.c

2237

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2252

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2259

prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/fixups.c

2308

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2314

if (prog->jit_requested && BITS_PER_LONG == 64 &&

kernel/bpf/fixups.c

2326

env->prog = prog = new_prog;

kernel/bpf/fixups.c

233

static void adjust_poke_descs(struct bpf_prog *prog, u32 off, u32 len)

kernel/bpf/fixups.c

2331

fn = env->ops->get_func_proto(insn->imm, env->prog);

kernel/bpf/fixups.c

2348

if (stack_depth > MAX_BPF_STACK && !prog->jit_requested) {

kernel/bpf/fixups.c

235

struct bpf_jit_poke_descriptor *tab = prog->aux->poke_tab;

kernel/bpf/fixups.c

236

int i, sz = prog->aux->size_poke_tab;

kernel/bpf/fixups.c

2361

env->prog->aux->stack_depth = subprogs[0].stack_depth;

kernel/bpf/fixups.c

2387

insn_buf[cnt++] = env->prog->insnsi[subprog_start];

kernel/bpf/fixups.c

2392

env->prog = prog = new_prog;

kernel/bpf/fixups.c

2399

WARN_ON(adjust_jmp_off(env->prog, subprog_start, delta));

kernel/bpf/fixups.c

2403

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

kernel/bpf/fixups.c

2404

map_ptr = prog->aux->poke_tab[i].tail_call.map;

kernel/bpf/fixups.c

2412

ret = map_ptr->ops->map_poke_track(map_ptr, prog->aux);

kernel/bpf/fixups.c

2522

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/fixups.c

2523

int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

2545

env->prog = new_prog;

kernel/bpf/fixups.c

255

array_size(env->prog->len + len - 1,

kernel/bpf/fixups.c

2558

env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;

kernel/bpf/fixups.c

2570

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/fixups.c

2571

int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

264

new_prog = bpf_patch_insn_single(env->prog, off, patch, len);

kernel/bpf/fixups.c

283

static int adjust_jmp_off(struct bpf_prog *prog, u32 tgt_idx, u32 delta)

kernel/bpf/fixups.c

285

struct bpf_insn *insn = prog->insnsi;

kernel/bpf/fixups.c

286

u32 insn_cnt = prog->len, i;

kernel/bpf/fixups.c

337

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

kernel/bpf/fixups.c

376

struct bpf_prog *prog = env->prog;

kernel/bpf/fixups.c

380

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/fixups.c

384

linfo = prog->aux->linfo;

kernel/bpf/fixups.c

403

if (prog->len != off && l_cnt &&

kernel/bpf/fixups.c

414

prog->aux->nr_linfo -= l_cnt;

kernel/bpf/fixups.c

415

nr_linfo = prog->aux->nr_linfo;

kernel/bpf/fixups.c

443

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/fixups.c

461

unsigned int orig_prog_len = env->prog->len;

kernel/bpf/fixups.c

464

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/fixups.c

470

err = bpf_remove_insns(env->prog, off, cnt);

kernel/bpf/fixups.c

511

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/fixups.c

512

const int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

526

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/fixups.c

536

int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

551

insn_cnt = env->prog->len;

kernel/bpf/fixups.c

559

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/fixups.c

560

int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

590

int i, patch_len, delta = 0, len = env->prog->len;

kernel/bpf/fixups.c

591

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/fixups.c

674

env->prog = new_prog;

kernel/bpf/fixups.c

693

const int insn_cnt = env->prog->len;

kernel/bpf/fixups.c

704

epilogue_cnt = ops->gen_epilogue(epilogue_buf, env->prog,

kernel/bpf/fixups.c

71

bpf_jit_find_kfunc_model(const struct bpf_prog *prog,

kernel/bpf/fixups.c

715

insn_buf[cnt++] = env->prog->insnsi[0];

kernel/bpf/fixups.c

719

env->prog = new_prog;

kernel/bpf/fixups.c

734

env->prog);

kernel/bpf/fixups.c

743

env->prog = new_prog;

kernel/bpf/fixups.c

753

WARN_ON(adjust_jmp_off(env->prog, 0, delta));

kernel/bpf/fixups.c

755

if (bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/fixups.c

758

insn = env->prog->insnsi + delta;

kernel/bpf/fixups.c

776

env->prog = new_prog;

kernel/bpf/fixups.c

809

env->prog->aux->num_exentries++;

kernel/bpf/fixups.c

81

tab = prog->aux->kfunc_tab;

kernel/bpf/fixups.c

849

env->prog = new_prog;

kernel/bpf/fixups.c

887

env->prog->aux->num_exentries++;

kernel/bpf/fixups.c

900

env->prog->aux->num_exentries++;

kernel/bpf/fixups.c

937

cnt = convert_ctx_access(type, insn, insn_buf, env->prog,

kernel/bpf/fixups.c

981

env->prog = new_prog;

kernel/bpf/hashtab.c

2177

struct bpf_prog *prog;

kernel/bpf/hashtab.c

2181

prog = bpf_iter_get_info(&meta, elem == NULL);

kernel/bpf/hashtab.c

2182

if (prog) {

kernel/bpf/hashtab.c

2201

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/hashtab.c

3446

struct bpf_prog *prog;

kernel/bpf/hashtab.c

3450

prog = bpf_iter_get_info(&meta, elem == NULL);

kernel/bpf/hashtab.c

3451

if (prog) {

kernel/bpf/hashtab.c

3458

ret = bpf_iter_run_prog(prog, &ctx);

kernel/bpf/helpers.c

1132

struct bpf_prog *prog;

kernel/bpf/helpers.c

1250

if (cb->prog)

kernel/bpf/helpers.c

1251

bpf_prog_put(cb->prog);

kernel/bpf/helpers.c

1362

cb->prog = NULL;

kernel/bpf/helpers.c

1422

struct bpf_prog *prog,

kernel/bpf/helpers.c

1428

if (prog) {

kernel/bpf/helpers.c

1429

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/helpers.c

1430

if (IS_ERR(prog))

kernel/bpf/helpers.c

1431

return PTR_ERR(prog);

kernel/bpf/helpers.c

1435

if (prog)

kernel/bpf/helpers.c

1436

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/helpers.c

1437

prev = xchg(&cb->prog, prog);

kernel/bpf/helpers.c

1448

} while (READ_ONCE(cb->prog) != prog ||

kernel/bpf/helpers.c

1451

if (prog)

kernel/bpf/helpers.c

1452

bpf_prog_put(prog);

kernel/bpf/helpers.c

1490

struct bpf_prog *prog)

kernel/bpf/helpers.c

1498

return bpf_async_update_prog_callback(cb, prog, callback_fn);

kernel/bpf/helpers.c

1504

return __bpf_async_set_callback(timer, callback_fn, aux->prog);

kernel/bpf/helpers.c

1529

if (!t || !READ_ONCE(t->cb.prog))

kernel/bpf/helpers.c

2067

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

kernel/bpf/helpers.c

2124

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

kernel/bpf/helpers.c

2192

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

kernel/bpf/helpers.c

2235

return prog->sleepable ? &bpf_get_task_stack_sleepable_proto

kernel/bpf/helpers.c

3367

struct bpf_prog *prog;

kernel/bpf/helpers.c

3375

prog = bpf_prog_ksym_find(ip);

kernel/bpf/helpers.c

3377

if (!prog)

kernel/bpf/helpers.c

3380

if (bpf_is_subprog(prog))

kernel/bpf/helpers.c

3382

ctx->aux = prog->aux;

kernel/bpf/helpers.c

3430

if (!w || !READ_ONCE(w->cb.prog))

kernel/bpf/helpers.c

3455

return __bpf_async_set_callback(async, callback_fn, aux->prog);

kernel/bpf/helpers.c

4384

struct bpf_prog *prog;

kernel/bpf/helpers.c

4402

if (ctx->prog) {

kernel/bpf/helpers.c

4403

bpf_prog_put(ctx->prog);

kernel/bpf/helpers.c

4404

ctx->prog = NULL;

kernel/bpf/helpers.c

4600

struct bpf_prog *prog;

kernel/bpf/helpers.c

4606

prog = bpf_prog_inc_not_zero(aux->prog);

kernel/bpf/helpers.c

4607

if (IS_ERR(prog))

kernel/bpf/helpers.c

4623

ctx->prog = prog;

kernel/bpf/helpers.c

4636

bpf_prog_put(prog);

kernel/bpf/inode.c

613

struct bpf_prog *prog;

kernel/bpf/inode.c

625

prog = inode->i_private;

kernel/bpf/inode.c

627

ret = security_bpf_prog(prog);

kernel/bpf/inode.c

631

if (!bpf_prog_get_ok(prog, &type, false))

kernel/bpf/inode.c

634

bpf_prog_inc(prog);

kernel/bpf/inode.c

635

return prog;

kernel/bpf/inode.c

640

struct bpf_prog *prog;

kernel/bpf/inode.c

645

prog = __get_prog_inode(d_backing_inode(path.dentry), type);

kernel/bpf/inode.c

646

if (!IS_ERR(prog))

kernel/bpf/inode.c

649

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

1338

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/liveness.c

1443

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/liveness.c

1530

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/liveness.c

1621

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/liveness.c

1855

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/liveness.c

1996

int insn_cnt = env->prog->len;

kernel/bpf/liveness.c

2209

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/liveness.c

2211

int insn_cnt = env->prog->len;

kernel/bpf/liveness.c

245

struct bpf_prog *prog = env->prog;

kernel/bpf/liveness.c

246

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

kernel/bpf/liveness.c

481

struct bpf_insn *insns = env->prog->insnsi;

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

352

linfo = bpf_find_linfo(env->prog, insn_off);

kernel/bpf/log.c

376

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

130

key_acc_size = prog->aux->max_rdonly_access;

kernel/bpf/map_iter.c

131

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

452

struct bpf_prog *prog)

kernel/bpf/offload.c

455

.prog = prog,

kernel/bpf/offload.c

458

struct bpf_prog_aux *aux = prog->aux;

kernel/bpf/offload.c

687

static bool __bpf_offload_dev_match(struct bpf_prog *prog,

kernel/bpf/offload.c

693

if (!bpf_prog_is_dev_bound(prog->aux))

kernel/bpf/offload.c

696

offload = prog->aux->offload;

kernel/bpf/offload.c

708

bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev)

kernel/bpf/offload.c

713

ret = __bpf_offload_dev_match(prog, netdev);

kernel/bpf/offload.c

736

bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map)

kernel/bpf/offload.c

746

ret = __bpf_offload_dev_match(prog, offmap->netdev);

kernel/bpf/offload.c

832

void *bpf_dev_bound_resolve_kfunc(struct bpf_prog *prog, u32 func_id)

kernel/bpf/offload.c

843

if (!prog->aux->offload)

kernel/bpf/offload.c

846

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/states.c

14

return bpf_is_may_goto_insn(&env->prog->insnsi[insn_idx]);

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

2351

static int find_prog_type(enum bpf_prog_type type, struct bpf_prog *prog)

kernel/bpf/syscall.c

2362

if (!bpf_prog_is_offloaded(prog->aux))

kernel/bpf/syscall.c

2363

prog->aux->ops = ops;

kernel/bpf/syscall.c

2365

prog->aux->ops = &bpf_offload_prog_ops;

kernel/bpf/syscall.c

2366

prog->type = type;

kernel/bpf/syscall.c

2381

static void bpf_audit_prog(const struct bpf_prog *prog, unsigned int op)

kernel/bpf/syscall.c

2396

prog->aux->id, bpf_audit_str[op]);

kernel/bpf/syscall.c

2400

static int bpf_prog_alloc_id(struct bpf_prog *prog)

kernel/bpf/syscall.c

2406

id = idr_alloc_cyclic(&prog_idr, prog, 1, INT_MAX, GFP_ATOMIC);

kernel/bpf/syscall.c

2408

prog->aux->id = id;

kernel/bpf/syscall.c

2419

void bpf_prog_free_id(struct bpf_prog *prog)

kernel/bpf/syscall.c

2428

if (!prog->aux->id)

kernel/bpf/syscall.c

2432

idr_remove(&prog_idr, prog->aux->id);

kernel/bpf/syscall.c

2433

prog->aux->id = 0;

kernel/bpf/syscall.c

2444

security_bpf_prog_free(aux->prog);

kernel/bpf/syscall.c

2445

bpf_prog_free(aux->prog);

kernel/bpf/syscall.c

2448

static void __bpf_prog_put_noref(struct bpf_prog *prog, bool deferred)

kernel/bpf/syscall.c

2450

bpf_prog_kallsyms_del_all(prog);

kernel/bpf/syscall.c

2451

btf_put(prog->aux->btf);

kernel/bpf/syscall.c

2452

module_put(prog->aux->mod);

kernel/bpf/syscall.c

2453

kvfree(prog->aux->jited_linfo);

kernel/bpf/syscall.c

2454

kvfree(prog->aux->linfo);

kernel/bpf/syscall.c

2455

kfree(prog->aux->kfunc_tab);

kernel/bpf/syscall.c

2456

kfree(prog->aux->ctx_arg_info);

kernel/bpf/syscall.c

2457

if (prog->aux->attach_btf)

kernel/bpf/syscall.c

2458

btf_put(prog->aux->attach_btf);

kernel/bpf/syscall.c

2461

if (prog->sleepable)

kernel/bpf/syscall.c

2462

call_rcu_tasks_trace(&prog->aux->rcu, __bpf_prog_put_rcu);

kernel/bpf/syscall.c

2464

call_rcu(&prog->aux->rcu, __bpf_prog_put_rcu);

kernel/bpf/syscall.c

2466

__bpf_prog_put_rcu(&prog->aux->rcu);

kernel/bpf/syscall.c

2473

struct bpf_prog *prog;

kernel/bpf/syscall.c

2476

prog = aux->prog;

kernel/bpf/syscall.c

2477

perf_event_bpf_event(prog, PERF_BPF_EVENT_PROG_UNLOAD, 0);

kernel/bpf/syscall.c

2478

bpf_audit_prog(prog, BPF_AUDIT_UNLOAD);

kernel/bpf/syscall.c

2479

bpf_prog_free_id(prog);

kernel/bpf/syscall.c

2480

__bpf_prog_put_noref(prog, true);

kernel/bpf/syscall.c

2483

static void __bpf_prog_put(struct bpf_prog *prog)

kernel/bpf/syscall.c

2485

struct bpf_prog_aux *aux = prog->aux;

kernel/bpf/syscall.c

2497

void bpf_prog_put(struct bpf_prog *prog)

kernel/bpf/syscall.c

2499

__bpf_prog_put(prog);

kernel/bpf/syscall.c

2505

struct bpf_prog *prog = filp->private_data;

kernel/bpf/syscall.c

2507

bpf_prog_put(prog);

kernel/bpf/syscall.c

2517

void notrace bpf_prog_inc_misses_counter(struct bpf_prog *prog)

kernel/bpf/syscall.c

2522

if (unlikely(!prog->stats))

kernel/bpf/syscall.c

2525

stats = this_cpu_ptr(prog->stats);

kernel/bpf/syscall.c

2531

static void bpf_prog_get_stats(const struct bpf_prog *prog,

kernel/bpf/syscall.c

2542

st = per_cpu_ptr(prog->stats, cpu);

kernel/bpf/syscall.c

2561

const struct bpf_prog *prog = filp->private_data;

kernel/bpf/syscall.c

2562

char prog_tag[sizeof(prog->tag) * 2 + 1] = { };

kernel/bpf/syscall.c

2565

bpf_prog_get_stats(prog, &stats);

kernel/bpf/syscall.c

2566

bin2hex(prog_tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

2577

prog->type,

kernel/bpf/syscall.c

2578

prog->jited,

kernel/bpf/syscall.c

2580

prog->pages * 1ULL << PAGE_SHIFT,

kernel/bpf/syscall.c

2581

prog->aux->id,

kernel/bpf/syscall.c

2585

prog->aux->verified_insns);

kernel/bpf/syscall.c

2598

int bpf_prog_new_fd(struct bpf_prog *prog)

kernel/bpf/syscall.c

2602

ret = security_bpf_prog(prog);

kernel/bpf/syscall.c

2606

return anon_inode_getfd("bpf-prog", &bpf_prog_fops, prog,

kernel/bpf/syscall.c

2610

void bpf_prog_add(struct bpf_prog *prog, int i)

kernel/bpf/syscall.c

2612

atomic64_add(i, &prog->aux->refcnt);

kernel/bpf/syscall.c

2616

void bpf_prog_sub(struct bpf_prog *prog, int i)

kernel/bpf/syscall.c

2623

WARN_ON(atomic64_sub_return(i, &prog->aux->refcnt) == 0);

kernel/bpf/syscall.c

2627

void bpf_prog_inc(struct bpf_prog *prog)

kernel/bpf/syscall.c

2629

atomic64_inc(&prog->aux->refcnt);

kernel/bpf/syscall.c

2634

struct bpf_prog *bpf_prog_inc_not_zero(struct bpf_prog *prog)

kernel/bpf/syscall.c

2638

refold = atomic64_fetch_add_unless(&prog->aux->refcnt, 1, 0);

kernel/bpf/syscall.c

2643

return prog;

kernel/bpf/syscall.c

2647

bool bpf_prog_get_ok(struct bpf_prog *prog,

kernel/bpf/syscall.c

2654

if (prog->type != *attach_type)

kernel/bpf/syscall.c

2656

if (bpf_prog_is_offloaded(prog->aux) && !attach_drv)

kernel/bpf/syscall.c

2666

struct bpf_prog *prog;

kernel/bpf/syscall.c

2673

prog = fd_file(f)->private_data;

kernel/bpf/syscall.c

2674

if (!bpf_prog_get_ok(prog, attach_type, attach_drv))

kernel/bpf/syscall.c

2677

bpf_prog_inc(prog);

kernel/bpf/syscall.c

2678

return prog;

kernel/bpf/syscall.c

2903

static int bpf_prog_verify_signature(struct bpf_prog *prog, union bpf_attr *attr,

kernel/bpf/syscall.c

2935

bpf_dynptr_init(&insns_ptr, prog->insnsi, BPF_DYNPTR_TYPE_LOCAL, 0,

kernel/bpf/syscall.c

2936

prog->len * sizeof(struct bpf_insn));

kernel/bpf/syscall.c

2947

static int bpf_prog_mark_insn_arrays_ready(struct bpf_prog *prog)

kernel/bpf/syscall.c

2952

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

kernel/bpf/syscall.c

2953

if (prog->aux->used_maps[i]->map_type != BPF_MAP_TYPE_INSN_ARRAY)

kernel/bpf/syscall.c

2956

err = bpf_insn_array_ready(prog->aux->used_maps[i]);

kernel/bpf/syscall.c

2975

struct bpf_prog *prog, *dst_prog = NULL;

kernel/bpf/syscall.c

3097

prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER);

kernel/bpf/syscall.c

3098

if (!prog) {

kernel/bpf/syscall.c

3107

prog->expected_attach_type = attr->expected_attach_type;

kernel/bpf/syscall.c

3108

prog->sleepable = !!(attr->prog_flags & BPF_F_SLEEPABLE);

kernel/bpf/syscall.c

3109

prog->aux->attach_btf = attach_btf;

kernel/bpf/syscall.c

3110

prog->aux->attach_btf_id = multi_func ? bpf_multi_func_btf_id[0] : attr->attach_btf_id;

kernel/bpf/syscall.c

3111

prog->aux->dst_prog = dst_prog;

kernel/bpf/syscall.c

3112

prog->aux->dev_bound = !!attr->prog_ifindex;

kernel/bpf/syscall.c

3113

prog->aux->xdp_has_frags = attr->prog_flags & BPF_F_XDP_HAS_FRAGS;

kernel/bpf/syscall.c

3116

prog->aux->token = token;

kernel/bpf/syscall.c

3119

prog->aux->user = get_current_user();

kernel/bpf/syscall.c

3120

prog->len = attr->insn_cnt;

kernel/bpf/syscall.c

3123

if (copy_from_bpfptr(prog->insns,

kernel/bpf/syscall.c

3125

bpf_prog_insn_size(prog)) != 0)

kernel/bpf/syscall.c

3135

prog->gpl_compatible = license_is_gpl_compatible(license) ? 1 : 0;

kernel/bpf/syscall.c

3137

err = bpf_prog_verify_signature(prog, attr, uattr.is_kernel,

kernel/bpf/syscall.c

3138

&prog->aux->sig.keyring_serial);

kernel/bpf/syscall.c

3141

prog->aux->sig.keyring_type = bpf_classify_keyring(attr->keyring_id);

kernel/bpf/syscall.c

3142

prog->aux->sig.verdict = BPF_SIG_VERIFIED;

kernel/bpf/syscall.c

3144

prog->aux->sig.keyring_type = BPF_SIG_KEYRING_NONE;

kernel/bpf/syscall.c

3145

prog->aux->sig.verdict = BPF_SIG_UNSIGNED;

kernel/bpf/syscall.c

3147

prog->orig_prog = NULL;

kernel/bpf/syscall.c

3148

prog->jited = 0;

kernel/bpf/syscall.c

3150

atomic64_set(&prog->aux->refcnt, 1);

kernel/bpf/syscall.c

3152

if (bpf_prog_is_dev_bound(prog->aux)) {

kernel/bpf/syscall.c

3153

err = bpf_prog_dev_bound_init(prog, attr);

kernel/bpf/syscall.c

3160

err = bpf_prog_dev_bound_inherit(prog, dst_prog);

kernel/bpf/syscall.c

3178

prog->aux->attach_tracing_prog = true;

kernel/bpf/syscall.c

3182

err = find_prog_type(type, prog);

kernel/bpf/syscall.c

3186

prog->aux->load_time = ktime_get_boottime_ns();

kernel/bpf/syscall.c

3187

err = bpf_obj_name_cpy(prog->aux->name, attr->prog_name,

kernel/bpf/syscall.c

3192

err = security_bpf_prog_load(prog, attr, token, uattr.is_kernel);

kernel/bpf/syscall.c

3197

err = bpf_check(&prog, attr, uattr, attr_log);

kernel/bpf/syscall.c

3201

err = bpf_prog_mark_insn_arrays_ready(prog);

kernel/bpf/syscall.c

3205

err = bpf_prog_alloc_id(prog);

kernel/bpf/syscall.c

3223

bpf_prog_kallsyms_add(prog);

kernel/bpf/syscall.c

3224

perf_event_bpf_event(prog, PERF_BPF_EVENT_PROG_LOAD, 0);

kernel/bpf/syscall.c

3225

bpf_audit_prog(prog, BPF_AUDIT_LOAD);

kernel/bpf/syscall.c

3227

err = bpf_prog_new_fd(prog);

kernel/bpf/syscall.c

3229

bpf_prog_put(prog);

kernel/bpf/syscall.c

3237

__bpf_prog_put_noref(prog, prog->aux->real_func_cnt);

kernel/bpf/syscall.c

3241

free_uid(prog->aux->user);

kernel/bpf/syscall.c

3242

if (prog->aux->attach_btf)

kernel/bpf/syscall.c

3243

btf_put(prog->aux->attach_btf);

kernel/bpf/syscall.c

3244

bpf_prog_free(prog);

kernel/bpf/syscall.c

3294

const struct bpf_link_ops *ops, struct bpf_prog *prog,

kernel/bpf/syscall.c

3303

link->prog = prog;

kernel/bpf/syscall.c

3308

const struct bpf_link_ops *ops, struct bpf_prog *prog,

kernel/bpf/syscall.c

3311

bpf_link_init_sleepable(link, type, ops, prog, attach_type, false);

kernel/bpf/syscall.c

3315

const struct bpf_link_ops *ops, struct bpf_prog *prog,

kernel/bpf/syscall.c

3318

bpf_link_init(&link->link, type, ops, prog, attach_type);

kernel/bpf/syscall.c

3344

primer->link->prog = NULL;

kernel/bpf/syscall.c

3358

if (link->prog)

kernel/bpf/syscall.c

3359

bpf_prog_put(link->prog);

kernel/bpf/syscall.c

3394

if (link->prog)

kernel/bpf/syscall.c

3411

if (link->sleepable || (link->prog && link->prog->sleepable))

kernel/bpf/syscall.c

3474

const struct bpf_prog *prog = link->prog;

kernel/bpf/syscall.c

3476

char prog_tag[sizeof(prog->tag) * 2 + 1] = { };

kernel/bpf/syscall.c

3493

if (prog) {

kernel/bpf/syscall.c

3494

bin2hex(prog_tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

3499

prog->aux->id);

kernel/bpf/syscall.c

3689

static int bpf_tracing_prog_attach(struct bpf_prog *prog,

kernel/bpf/syscall.c

3702

switch (prog->type) {

kernel/bpf/syscall.c

3704

if (prog->expected_attach_type != BPF_TRACE_FENTRY &&

kernel/bpf/syscall.c

3705

prog->expected_attach_type != BPF_TRACE_FEXIT &&

kernel/bpf/syscall.c

3706

prog->expected_attach_type != BPF_TRACE_FSESSION &&

kernel/bpf/syscall.c

3707

prog->expected_attach_type != BPF_MODIFY_RETURN) {

kernel/bpf/syscall.c

3713

if (prog->expected_attach_type != 0) {

kernel/bpf/syscall.c

3719

if (prog->expected_attach_type != BPF_LSM_MAC) {

kernel/bpf/syscall.c

3741

if (prog->type != BPF_PROG_TYPE_EXT) {

kernel/bpf/syscall.c

3762

&bpf_tracing_link_lops, prog, attach_type, bpf_cookie);

kernel/bpf/syscall.c

3764

if (prog->expected_attach_type == BPF_TRACE_FSESSION) {

kernel/bpf/syscall.c

3769

mutex_lock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

3793

if (!prog->aux->dst_trampoline && !tgt_prog) {

kernel/bpf/syscall.c

3800

if (prog->type != BPF_PROG_TYPE_TRACING &&

kernel/bpf/syscall.c

3801

prog->type != BPF_PROG_TYPE_LSM) {

kernel/bpf/syscall.c

3806

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

kernel/bpf/syscall.c

3810

btf_id = prog->aux->attach_btf_id;

kernel/bpf/syscall.c

3811

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf, btf_id);

kernel/bpf/syscall.c

3814

if (!prog->aux->dst_trampoline ||

kernel/bpf/syscall.c

3815

(key && key != prog->aux->dst_trampoline->key)) {

kernel/bpf/syscall.c

3822

err = bpf_check_attach_target(NULL, prog, tgt_prog, btf_id,

kernel/bpf/syscall.c

3828

module_put(prog->aux->mod);

kernel/bpf/syscall.c

3829

prog->aux->mod = tgt_info.tgt_mod;

kernel/bpf/syscall.c

3845

tr = prog->aux->dst_trampoline;

kernel/bpf/syscall.c

3846

tgt_prog = prog->aux->dst_prog;

kernel/bpf/syscall.c

3860

if (prog->type == BPF_PROG_TYPE_EXT &&

kernel/bpf/syscall.c

3861

prog->aux->kprobe_write_ctx != tgt_prog->aux->kprobe_write_ctx) {

kernel/bpf/syscall.c

3884

if (prog->aux->dst_prog &&

kernel/bpf/syscall.c

3885

(tgt_prog_fd || tr != prog->aux->dst_trampoline))

kernel/bpf/syscall.c

3887

bpf_prog_put(prog->aux->dst_prog);

kernel/bpf/syscall.c

3888

if (prog->aux->dst_trampoline && tr != prog->aux->dst_trampoline)

kernel/bpf/syscall.c

3890

bpf_trampoline_put(prog->aux->dst_trampoline);

kernel/bpf/syscall.c

3892

prog->aux->dst_prog = NULL;

kernel/bpf/syscall.c

3893

prog->aux->dst_trampoline = NULL;

kernel/bpf/syscall.c

3894

mutex_unlock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

3898

if (tr && tr != prog->aux->dst_trampoline)

kernel/bpf/syscall.c

3900

mutex_unlock(&prog->aux->dst_mutex);

kernel/bpf/syscall.c

4213

switch (event->prog->type) {

kernel/bpf/syscall.c

4281

switch (event->prog->type) {

kernel/bpf/syscall.c

4300

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

kernel/bpf/syscall.c

4320

bpf_link_init(&link->link, BPF_LINK_TYPE_PERF_EVENT, &bpf_perf_link_lops, prog,

kernel/bpf/syscall.c

4331

err = perf_event_set_bpf_prog(event, prog, attr->link_create.perf_event.bpf_cookie);

kernel/bpf/syscall.c

4337

bpf_prog_inc(prog);

kernel/bpf/syscall.c

4346

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

kernel/bpf/syscall.c

4352

static int bpf_raw_tp_link_attach(struct bpf_prog *prog,

kernel/bpf/syscall.c

4363

switch (prog->type) {

kernel/bpf/syscall.c

4372

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/bpf/syscall.c

4373

prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/syscall.c

4374

tp_name = prog->aux->attach_func_name;

kernel/bpf/syscall.c

4377

return bpf_tracing_prog_attach(prog, 0, 0, 0, attach_type);

kernel/bpf/syscall.c

4393

if (prog->sleepable && !tracepoint_is_faultable(btp->tp)) {

kernel/bpf/syscall.c

4404

&bpf_raw_tp_link_lops, prog, attach_type,

kernel/bpf/syscall.c

4432

struct bpf_prog *prog;

kernel/bpf/syscall.c

4440

prog = bpf_prog_get(attr->raw_tracepoint.prog_fd);

kernel/bpf/syscall.c

4441

if (IS_ERR(prog))

kernel/bpf/syscall.c

4442

return PTR_ERR(prog);

kernel/bpf/syscall.c

4446

fd = bpf_raw_tp_link_attach(prog, tp_name, cookie, prog->expected_attach_type);

kernel/bpf/syscall.c

4448

bpf_prog_put(prog);

kernel/bpf/syscall.c

4529

static int bpf_prog_attach_check_attach_type(const struct bpf_prog *prog,

kernel/bpf/syscall.c

4534

switch (prog->type) {

kernel/bpf/syscall.c

4539

return attach_type == prog->expected_attach_type ? 0 : -EINVAL;

kernel/bpf/syscall.c

4541

if (!bpf_token_capable(prog->aux->token, CAP_NET_ADMIN))

kernel/bpf/syscall.c

4548

if (prog->type != ptype)

kernel/bpf/syscall.c

4551

return prog->enforce_expected_attach_type &&

kernel/bpf/syscall.c

4552

prog->expected_attach_type != attach_type ?

kernel/bpf/syscall.c

4566

if (prog->expected_attach_type == BPF_TRACE_KPROBE_MULTI &&

kernel/bpf/syscall.c

4569

if (prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION &&

kernel/bpf/syscall.c

4572

if (prog->expected_attach_type == BPF_TRACE_UPROBE_MULTI &&

kernel/bpf/syscall.c

4575

if (prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION &&

kernel/bpf/syscall.c

4594

if (ptype == BPF_PROG_TYPE_UNSPEC || ptype != prog->type)

kernel/bpf/syscall.c

4637

struct bpf_prog *prog;

kernel/bpf/syscall.c

4660

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/syscall.c

4661

if (IS_ERR(prog))

kernel/bpf/syscall.c

4662

return PTR_ERR(prog);

kernel/bpf/syscall.c

4664

if (bpf_prog_attach_check_attach_type(prog, attr->attach_type)) {

kernel/bpf/syscall.c

4665

bpf_prog_put(prog);

kernel/bpf/syscall.c

4669

if (is_cgroup_prog_type(ptype, prog->expected_attach_type, true)) {

kernel/bpf/syscall.c

4670

ret = cgroup_bpf_prog_attach(attr, ptype, prog);

kernel/bpf/syscall.c

4677

ret = sock_map_get_from_fd(attr, prog);

kernel/bpf/syscall.c

4680

ret = lirc_prog_attach(attr, prog);

kernel/bpf/syscall.c

4683

ret = netns_bpf_prog_attach(attr, prog);

kernel/bpf/syscall.c

4688

ret = tcx_prog_attach(attr, prog);

kernel/bpf/syscall.c

4690

ret = netkit_prog_attach(attr, prog);

kernel/bpf/syscall.c

4697

bpf_prog_put(prog);

kernel/bpf/syscall.c

4705

struct bpf_prog *prog = NULL;

kernel/bpf/syscall.c

4719

prog = bpf_prog_get_type(attr->attach_bpf_fd, ptype);

kernel/bpf/syscall.c

4720

if (IS_ERR(prog))

kernel/bpf/syscall.c

4721

return PTR_ERR(prog);

kernel/bpf/syscall.c

4758

ret = tcx_prog_detach(attr, prog);

kernel/bpf/syscall.c

4760

ret = netkit_prog_detach(attr, prog);

kernel/bpf/syscall.c

4766

if (prog)

kernel/bpf/syscall.c

4767

bpf_prog_put(prog);

kernel/bpf/syscall.c

4840

struct bpf_prog *prog;

kernel/bpf/syscall.c

4854

prog = bpf_prog_get(attr->test.prog_fd);

kernel/bpf/syscall.c

4855

if (IS_ERR(prog))

kernel/bpf/syscall.c

4856

return PTR_ERR(prog);

kernel/bpf/syscall.c

4858

if (prog->aux->ops->test_run)

kernel/bpf/syscall.c

4859

ret = prog->aux->ops->test_run(prog, attr, uattr);

kernel/bpf/syscall.c

4861

bpf_prog_put(prog);

kernel/bpf/syscall.c

4914

struct bpf_prog *prog;

kernel/bpf/syscall.c

4918

prog = idr_get_next(&prog_idr, id);

kernel/bpf/syscall.c

4919

if (prog) {

kernel/bpf/syscall.c

4920

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/syscall.c

4921

if (IS_ERR(prog)) {

kernel/bpf/syscall.c

4928

return prog;

kernel/bpf/syscall.c

4935

struct bpf_prog *prog;

kernel/bpf/syscall.c

4941

prog = idr_find(&prog_idr, id);

kernel/bpf/syscall.c

4942

if (prog)

kernel/bpf/syscall.c

4943

prog = bpf_prog_inc_not_zero(prog);

kernel/bpf/syscall.c

4945

prog = ERR_PTR(-ENOENT);

kernel/bpf/syscall.c

4947

return prog;

kernel/bpf/syscall.c

4952

struct bpf_prog *prog;

kernel/bpf/syscall.c

4962

prog = bpf_prog_by_id(id);

kernel/bpf/syscall.c

4963

if (IS_ERR(prog))

kernel/bpf/syscall.c

4964

return PTR_ERR(prog);

kernel/bpf/syscall.c

4966

fd = bpf_prog_new_fd(prog);

kernel/bpf/syscall.c

4968

bpf_prog_put(prog);

kernel/bpf/syscall.c

5011

static const struct bpf_map *bpf_map_from_imm(const struct bpf_prog *prog,

kernel/bpf/syscall.c

5018

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5019

for (i = 0, *off = 0; i < prog->aux->used_map_cnt; i++) {

kernel/bpf/syscall.c

5020

map = prog->aux->used_maps[i];

kernel/bpf/syscall.c

5035

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5062

static struct bpf_insn *bpf_insn_prepare_dump(const struct bpf_prog *prog,

kernel/bpf/syscall.c

5072

insns = kmemdup(prog->insnsi, bpf_prog_insn_size(prog),

kernel/bpf/syscall.c

5077

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

kernel/bpf/syscall.c

5111

map = bpf_map_from_imm(prog, imm, &off, &type);

kernel/bpf/syscall.c

5155

struct bpf_prog *prog,

kernel/bpf/syscall.c

5160

struct btf *attach_btf = bpf_prog_get_target_btf(prog);

kernel/bpf/syscall.c

5178

info.type = prog->type;

kernel/bpf/syscall.c

5179

info.id = prog->aux->id;

kernel/bpf/syscall.c

5180

info.load_time = prog->aux->load_time;

kernel/bpf/syscall.c

5182

prog->aux->user->uid);

kernel/bpf/syscall.c

5183

info.gpl_compatible = prog->gpl_compatible;

kernel/bpf/syscall.c

5185

memcpy(info.tag, prog->tag, sizeof(prog->tag));

kernel/bpf/syscall.c

5186

memcpy(info.name, prog->aux->name, sizeof(prog->aux->name));

kernel/bpf/syscall.c

5188

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5190

info.nr_map_ids = prog->aux->used_map_cnt;

kernel/bpf/syscall.c

5197

if (put_user(prog->aux->used_maps[i]->id,

kernel/bpf/syscall.c

5199

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5203

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

5209

bpf_prog_get_stats(prog, &stats);

kernel/bpf/syscall.c

5214

info.verified_insns = prog->aux->verified_insns;

kernel/bpf/syscall.c

5215

if (prog->aux->btf)

kernel/bpf/syscall.c

5216

info.btf_id = btf_obj_id(prog->aux->btf);

kernel/bpf/syscall.c

5230

info.xlated_prog_len = bpf_prog_insn_size(prog);

kernel/bpf/syscall.c

5235

if (!prog->blinded || bpf_dump_raw_ok(file->f_cred)) {

kernel/bpf/syscall.c

5236

insns_sanitized = bpf_insn_prepare_dump(prog, file->f_cred);

kernel/bpf/syscall.c

5250

if (bpf_prog_is_offloaded(prog->aux)) {

kernel/bpf/syscall.c

5251

err = bpf_prog_offload_info_fill(&info, prog);

kernel/bpf/syscall.c

5262

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5266

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

kernel/bpf/syscall.c

5267

info.jited_prog_len += prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5269

info.jited_prog_len = prog->jited_len;

kernel/bpf/syscall.c

5280

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5285

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

kernel/bpf/syscall.c

5286

len = prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5288

img = (u8 *) prog->aux->func[i]->bpf_func;

kernel/bpf/syscall.c

5297

if (copy_to_user(uinsns, prog->bpf_func, ulen))

kernel/bpf/syscall.c

5306

info.nr_jited_ksyms = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5318

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5321

prog->aux->func[i]->bpf_func;

kernel/bpf/syscall.c

5327

ksym_addr = (unsigned long) prog->bpf_func;

kernel/bpf/syscall.c

5337

info.nr_jited_func_lens = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5346

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5349

prog->aux->func[i]->jited_len;

kernel/bpf/syscall.c

5354

func_len = prog->jited_len;

kernel/bpf/syscall.c

5363

info.attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/syscall.c

5368

info.nr_func_info = prog->aux->func_info_cnt;

kernel/bpf/syscall.c

5374

if (copy_to_user(user_finfo, prog->aux->func_info,

kernel/bpf/syscall.c

5380

info.nr_line_info = prog->aux->nr_linfo;

kernel/bpf/syscall.c

5386

if (copy_to_user(user_linfo, prog->aux->linfo,

kernel/bpf/syscall.c

5392

if (prog->aux->jited_linfo)

kernel/bpf/syscall.c

5393

info.nr_jited_line_info = prog->aux->nr_linfo;

kernel/bpf/syscall.c

5405

line_addr = (unsigned long)prog->aux->jited_linfo[i];

kernel/bpf/syscall.c

5415

info.nr_prog_tags = prog->aux->func_cnt ? : 1;

kernel/bpf/syscall.c

5422

if (prog->aux->func_cnt) {

kernel/bpf/syscall.c

5425

prog->aux->func[i]->tag,

kernel/bpf/syscall.c

5431

prog->tag, BPF_TAG_SIZE))

kernel/bpf/syscall.c

5552

if (link->prog)

kernel/bpf/syscall.c

5553

info.prog_id = link->prog->aux->id;

kernel/bpf/syscall.c

5755

raw_tp->link.prog->aux->id,

kernel/bpf/syscall.c

5846

struct bpf_prog *prog;

kernel/bpf/syscall.c

5855

prog = bpf_prog_get(attr->link_create.prog_fd);

kernel/bpf/syscall.c

5856

if (IS_ERR(prog))

kernel/bpf/syscall.c

5857

return PTR_ERR(prog);

kernel/bpf/syscall.c

5859

ret = bpf_prog_attach_check_attach_type(prog,

kernel/bpf/syscall.c

5864

switch (prog->type) {

kernel/bpf/syscall.c

5872

ret = cgroup_bpf_link_attach(attr, prog);

kernel/bpf/syscall.c

5875

ret = bpf_tracing_prog_attach(prog,

kernel/bpf/syscall.c

5883

if (attr->link_create.attach_type != prog->expected_attach_type) {

kernel/bpf/syscall.c

5887

if (prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/bpf/syscall.c

5888

ret = bpf_raw_tp_link_attach(prog, NULL, attr->link_create.tracing.cookie,

kernel/bpf/syscall.c

5890

else if (prog->expected_attach_type == BPF_TRACE_ITER)

kernel/bpf/syscall.c

5891

ret = bpf_iter_link_attach(attr, uattr, prog);

kernel/bpf/syscall.c

5892

else if (prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/syscall.c

5893

ret = cgroup_bpf_link_attach(attr, prog);

kernel/bpf/syscall.c

5894

else if (is_tracing_multi(prog->expected_attach_type))

kernel/bpf/syscall.c

5895

ret = bpf_tracing_multi_attach(prog, attr);

kernel/bpf/syscall.c

5897

ret = bpf_tracing_prog_attach(prog,

kernel/bpf/syscall.c

5905

ret = netns_bpf_link_create(attr, prog);

kernel/bpf/syscall.c

5909

ret = sock_map_link_create(attr, prog);

kernel/bpf/syscall.c

5913

ret = bpf_xdp_link_attach(attr, prog);

kernel/bpf/syscall.c

5918

ret = tcx_link_attach(attr, prog);

kernel/bpf/syscall.c

5920

ret = netkit_link_attach(attr, prog);

kernel/bpf/syscall.c

5923

ret = bpf_nf_link_attach(attr, prog);

kernel/bpf/syscall.c

5928

ret = bpf_perf_link_attach(attr, prog);

kernel/bpf/syscall.c

5932

ret = bpf_perf_link_attach(attr, prog);

kernel/bpf/syscall.c

5935

ret = bpf_kprobe_multi_link_attach(attr, prog);

kernel/bpf/syscall.c

5938

ret = bpf_uprobe_multi_link_attach(attr, prog);

kernel/bpf/syscall.c

5946

bpf_prog_put(prog);

kernel/bpf/syscall.c

6213

struct bpf_prog *prog;

kernel/bpf/syscall.c

6224

prog = bpf_prog_get(attr->prog_bind_map.prog_fd);

kernel/bpf/syscall.c

6225

if (IS_ERR(prog))

kernel/bpf/syscall.c

6226

return PTR_ERR(prog);

kernel/bpf/syscall.c

6234

mutex_lock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

6236

used_maps_old = prog->aux->used_maps;

kernel/bpf/syscall.c

6238

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

kernel/bpf/syscall.c

6245

prog->aux->used_map_cnt + 1);

kernel/bpf/syscall.c

6254

if (prog->sleepable)

kernel/bpf/syscall.c

6257

sizeof(used_maps_old[0]) * prog->aux->used_map_cnt);

kernel/bpf/syscall.c

6258

used_maps_new[prog->aux->used_map_cnt] = map;

kernel/bpf/syscall.c

6260

prog->aux->used_map_cnt++;

kernel/bpf/syscall.c

6261

prog->aux->used_maps = used_maps_new;

kernel/bpf/syscall.c

6266

mutex_unlock(&prog->aux->used_maps_mutex);

kernel/bpf/syscall.c

6271

bpf_prog_put(prog);

kernel/bpf/syscall.c

6295

struct bpf_prog *prog;

kernel/bpf/syscall.c

6301

prog = bpf_prog_get(attr->prog_stream_read.prog_fd);

kernel/bpf/syscall.c

6302

if (IS_ERR(prog))

kernel/bpf/syscall.c

6303

return PTR_ERR(prog);

kernel/bpf/syscall.c

6305

ret = bpf_prog_stream_read(prog, attr->prog_stream_read.stream_id, buf, len);

kernel/bpf/syscall.c

6306

bpf_prog_put(prog);

kernel/bpf/syscall.c

6315

struct bpf_prog *prog;

kernel/bpf/syscall.c

6325

prog = bpf_prog_get(attr->prog_assoc_struct_ops.prog_fd);

kernel/bpf/syscall.c

6326

if (IS_ERR(prog))

kernel/bpf/syscall.c

6327

return PTR_ERR(prog);

kernel/bpf/syscall.c

6329

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS) {

kernel/bpf/syscall.c

6345

ret = bpf_prog_assoc_struct_ops(prog, map);

kernel/bpf/syscall.c

6350

bpf_prog_put(prog);

kernel/bpf/syscall.c

6542

const struct bpf_prog *prog,

kernel/bpf/syscall.c

6580

struct bpf_prog * __maybe_unused prog;

kernel/bpf/syscall.c

6591

prog = bpf_prog_get_type(attr->test.prog_fd, BPF_PROG_TYPE_SYSCALL);

kernel/bpf/syscall.c

6592

if (IS_ERR(prog))

kernel/bpf/syscall.c

6593

return PTR_ERR(prog);

kernel/bpf/syscall.c

6595

if (attr->test.ctx_size_in < prog->aux->max_ctx_offset ||

kernel/bpf/syscall.c

6597

bpf_prog_put(prog);

kernel/bpf/syscall.c

6602

if (!__bpf_prog_enter_sleepable_recur(prog, &run_ctx)) {

kernel/bpf/syscall.c

6604

__bpf_prog_exit_sleepable_recur(prog, 0, &run_ctx);

kernel/bpf/syscall.c

6605

bpf_prog_put(prog);

kernel/bpf/syscall.c

6608

attr->test.retval = bpf_prog_run(prog, (void *) (long) attr->test.ctx_in);

kernel/bpf/syscall.c

6609

__bpf_prog_exit_sleepable_recur(prog, 0 /* bpf_prog_run does runtime stats */,

kernel/bpf/syscall.c

6611

bpf_prog_put(prog);

kernel/bpf/syscall.c

6630

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

kernel/bpf/syscall.c

6632

return bpf_base_func_proto(func_id, prog);

kernel/bpf/syscall.c

6680

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

kernel/bpf/syscall.c

6684

return !bpf_token_capable(prog->aux->token, CAP_PERFMON)

kernel/bpf/syscall.c

6693

return tracing_prog_func_proto(func_id, prog);

kernel/bpf/task_iter.c

182

struct bpf_prog *prog;

kernel/bpf/task_iter.c

185

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

186

if (!prog)

kernel/bpf/task_iter.c

191

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/task_iter.c

207

static int bpf_iter_attach_task(struct bpf_prog *prog,

kernel/bpf/task_iter.c

351

struct bpf_prog *prog;

kernel/bpf/task_iter.c

354

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

355

if (!prog)

kernel/bpf/task_iter.c

362

return bpf_iter_run_prog(prog, &ctx);

kernel/bpf/task_iter.c

613

struct bpf_prog *prog;

kernel/bpf/task_iter.c

616

prog = bpf_iter_get_info(&meta, in_stop);

kernel/bpf/task_iter.c

617

if (!prog)

kernel/bpf/task_iter.c

623

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

1022

static struct bpf_shim_tramp_link *cgroup_shim_alloc(const struct bpf_prog *prog,

kernel/bpf/trampoline.c

1044

p->aux->attach_func_proto = prog->aux->attach_func_proto;

kernel/bpf/trampoline.c

1045

p->aux->attach_btf_id = prog->aux->attach_btf_id;

kernel/bpf/trampoline.c

1046

p->aux->attach_btf = prog->aux->attach_btf;

kernel/bpf/trampoline.c

1066

struct bpf_prog *p = node->link->prog;

kernel/bpf/trampoline.c

1076

int bpf_trampoline_link_cgroup_shim(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1087

err = bpf_check_attach_target(NULL, prog, NULL,

kernel/bpf/trampoline.c

1088

prog->aux->attach_btf_id,

kernel/bpf/trampoline.c

1093

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf,

kernel/bpf/trampoline.c

1094

prog->aux->attach_btf_id);

kernel/bpf/trampoline.c

1096

bpf_lsm_find_cgroup_shim(prog, &bpf_func);

kernel/bpf/trampoline.c

1113

shim_link = cgroup_shim_alloc(prog, bpf_func, cgroup_atype, attach_type);

kernel/bpf/trampoline.c

1141

void bpf_trampoline_unlink_cgroup_shim(struct bpf_prog *prog)

kernel/bpf/trampoline.c

1148

key = bpf_trampoline_compute_key(NULL, prog->aux->attach_btf,

kernel/bpf/trampoline.c

1149

prog->aux->attach_btf_id);

kernel/bpf/trampoline.c

1151

bpf_lsm_find_cgroup_shim(prog, &bpf_func);

kernel/bpf/trampoline.c

1241

static u64 notrace __bpf_prog_enter_recur(struct bpf_prog *prog, struct bpf_tramp_run_ctx *run_ctx)

kernel/bpf/trampoline.c

1248

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/bpf/trampoline.c

1249

bpf_prog_inc_misses_counter(prog);

kernel/bpf/trampoline.c

1250

if (prog->aux->recursion_detected)

kernel/bpf/trampoline.c

1251

prog->aux->recursion_detected(prog);

kernel/bpf/trampoline.c

1257

static void notrace __update_prog_stats(struct bpf_prog *prog, u64 start)

kernel/bpf/trampoline.c

1271

stats = this_cpu_ptr(prog->stats);

kernel/bpf/trampoline.c

1278

static __always_inline void notrace update_prog_stats(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1282

__update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1285

static void notrace __bpf_prog_exit_recur(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1291

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1292

bpf_prog_put_recursion_context(prog);

kernel/bpf/trampoline.c

1296

static u64 notrace __bpf_prog_enter_lsm_cgroup(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1310

static void notrace __bpf_prog_exit_lsm_cgroup(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1319

u64 notrace __bpf_prog_enter_sleepable_recur(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1328

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/bpf/trampoline.c

1329

bpf_prog_inc_misses_counter(prog);

kernel/bpf/trampoline.c

1330

if (prog->aux->recursion_detected)

kernel/bpf/trampoline.c

1331

prog->aux->recursion_detected(prog);

kernel/bpf/trampoline.c

1337

void notrace __bpf_prog_exit_sleepable_recur(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1342

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1343

bpf_prog_put_recursion_context(prog);

kernel/bpf/trampoline.c

1348

static u64 notrace __bpf_prog_enter_sleepable(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1360

static void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1365

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1370

static u64 notrace __bpf_prog_enter(struct bpf_prog *prog,

kernel/bpf/trampoline.c

1381

static void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start,

kernel/bpf/trampoline.c

1387

update_prog_stats(prog, start);

kernel/bpf/trampoline.c

1401

bpf_trampoline_enter_t bpf_trampoline_enter(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

1403

bool sleepable = prog->sleepable;

kernel/bpf/trampoline.c

1405

if (bpf_prog_check_recur(prog))

kernel/bpf/trampoline.c

1409

if (resolve_prog_type(prog) == BPF_PROG_TYPE_LSM &&

kernel/bpf/trampoline.c

1410

prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/trampoline.c

1416

bpf_trampoline_exit_t bpf_trampoline_exit(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

1418

bool sleepable = prog->sleepable;

kernel/bpf/trampoline.c

1420

if (bpf_prog_check_recur(prog))

kernel/bpf/trampoline.c

1424

if (resolve_prog_type(prog) == BPF_PROG_TYPE_LSM &&

kernel/bpf/trampoline.c

1425

prog->expected_attach_type == BPF_LSM_CGROUP)

kernel/bpf/trampoline.c

1611

int bpf_trampoline_multi_attach(struct bpf_prog *prog, u32 *ids,

kernel/bpf/trampoline.c

1616

struct btf *btf = prog->aux->attach_btf;

kernel/bpf/trampoline.c

1625

err = bpf_check_attach_btf_id_multi(btf, prog, ids[i], &tgt_info);

kernel/bpf/trampoline.c

1641

if (prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI) {

kernel/bpf/trampoline.c

1711

int bpf_trampoline_multi_detach(struct bpf_prog *prog, struct bpf_tracing_multi_link *link)

kernel/bpf/trampoline.c

177

bool bpf_prog_has_trampoline(const struct bpf_prog *prog)

kernel/bpf/trampoline.c

179

enum bpf_attach_type eatype = prog->expected_attach_type;

kernel/bpf/trampoline.c

180

enum bpf_prog_type ptype = prog->type;

kernel/bpf/trampoline.c

525

*ip_arg |= node->link->prog->call_get_func_ip;

kernel/bpf/trampoline.c

782

static enum bpf_tramp_prog_type bpf_attach_type_to_tramp(struct bpf_prog *prog)

kernel/bpf/trampoline.c

784

switch (prog->expected_attach_type) {

kernel/bpf/trampoline.c

797

if (!prog->aux->attach_func_proto->type)

kernel/bpf/trampoline.c

853

kind = bpf_attach_type_to_tramp(node->link->prog);

kernel/bpf/trampoline.c

866

if (node_existing->link->prog != node->link->prog)

kernel/bpf/trampoline.c

892

kind = bpf_attach_type_to_tramp(node->link->prog);

kernel/bpf/trampoline.c

915

kind = bpf_attach_type_to_tramp(node->link->prog);

kernel/bpf/trampoline.c

932

tr->extension_prog = node->link->prog;

kernel/bpf/trampoline.c

935

node->link->prog->bpf_func);

kernel/bpf/trampoline.c

967

kind = bpf_attach_type_to_tramp(node->link->prog);

kernel/bpf/verifier.c

10046

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

10050

if (!bpf_prog_has_trampoline(env->prog)) {

kernel/bpf/verifier.c

10126

*ptr = env->ops->get_func_proto(func_id, env->prog);

kernel/bpf/verifier.c

10174

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

10200

if (!env->prog->gpl_compatible && fn->gpl_only) {

kernel/bpf/verifier.c

10205

if (fn->allowed && !fn->allowed(env->prog)) {

kernel/bpf/verifier.c

10345

env->prog->expected_attach_type == BPF_CGROUP_GETSOCKOPT)

kernel/bpf/verifier.c

10349

env->prog->expected_attach_type == BPF_LSM_CGROUP) {

kernel/bpf/verifier.c

10350

if (!env->prog->aux->attach_func_proto->type) {

kernel/bpf/verifier.c

10357

bpf_lsm_get_retval_range(env->prog, &range);

kernel/bpf/verifier.c

10609

!env->prog->has_callchain_buf) {

kernel/bpf/verifier.c

10624

env->prog->has_callchain_buf = true;

kernel/bpf/verifier.c

10628

env->prog->call_get_stack = true;

kernel/bpf/verifier.c

10633

env->prog->call_get_func_ip = true;

kernel/bpf/verifier.c

11281

if (btf_is_prog_ctx_type(&env->log, meta->btf, t, resolve_prog_type(env->prog), arg))

kernel/bpf/verifier.c

11914

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

11920

if (env->prog->expected_attach_type == BPF_TRACE_ITER)

kernel/bpf/verifier.c

12178

ret = get_kern_ctx_btf_id(&env->log, resolve_prog_type(env->prog));

kernel/bpf/verifier.c

12537

if (!kfunc.flags || !btf_kfunc_is_allowed(kfunc.btf, kfunc.id, env->prog))

kernel/bpf/verifier.c

12765

ret_btf = env->prog->aux->btf;

kernel/bpf/verifier.c

12917

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

12997

(prog_type == BPF_PROG_TYPE_TRACING && env->prog->expected_attach_type != BPF_TRACE_ITER

kernel/bpf/verifier.c

12998

&& !env->prog->sleepable))) {

kernel/bpf/verifier.c

13288

env->prog->call_session_cookie = true;

kernel/bpf/verifier.c

14952

if (!env->prog->aux->arena) {

kernel/bpf/verifier.c

16235

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

kernel/bpf/verifier.c

16314

if (!may_access_skb(resolve_prog_type(env->prog))) {

kernel/bpf/verifier.c

16390

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

16397

switch (env->prog->expected_attach_type) {

kernel/bpf/verifier.c

16418

if (env->prog->expected_attach_type == BPF_CGROUP_INET_EGRESS)

kernel/bpf/verifier.c

16428

if (!env->prog->aux->attach_btf_id)

kernel/bpf/verifier.c

16433

switch (env->prog->expected_attach_type) {

kernel/bpf/verifier.c

16451

switch (env->prog->expected_attach_type) {

kernel/bpf/verifier.c

16464

if (env->prog->expected_attach_type != BPF_LSM_CGROUP) {

kernel/bpf/verifier.c

16466

if (!get_func_retval_range(env->prog, range))

kernel/bpf/verifier.c

16472

} else if (!env->prog->aux->attach_func_proto->type) {

kernel/bpf/verifier.c

16501

const struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

16502

enum bpf_prog_type prog_type = prog->type;

kernel/bpf/verifier.c

16507

if (prog->expected_attach_type != BPF_LSM_CGROUP &&

kernel/bpf/verifier.c

16508

!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

16512

if (!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

16535

const struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

16538

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

16553

ret_type = btf_type_resolve_ptr(prog->aux->attach_btf,

kernel/bpf/verifier.c

16554

prog->aux->attach_func_proto->type,

kernel/bpf/verifier.c

16584

if (prog_type == BPF_PROG_TYPE_CGROUP_SKB && (env->prog->expected_attach_type == BPF_CGROUP_INET_EGRESS))

kernel/bpf/verifier.c

16603

if (prog->expected_attach_type == BPF_LSM_CGROUP &&

kernel/bpf/verifier.c

16605

!prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

16612

env->prog->enforce_expected_attach_type = 1;

kernel/bpf/verifier.c

16663

return env->prog->jit_requested && bpf_jit_supports_percpu_insn();

kernel/bpf/verifier.c

1667

return env->prog->len;

kernel/bpf/verifier.c

16792

struct bpf_insn *insns = env->prog->insnsi, *stx, *ldx;

kernel/bpf/verifier.c

16793

struct bpf_insn *call = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

16823

if (insn_idx - i < 0 || insn_idx + i >= env->prog->len)

kernel/bpf/verifier.c

16886

insn = env->prog->insnsi + i;

kernel/bpf/verifier.c

16894

insn = env->prog->insnsi + i;

kernel/bpf/verifier.c

16905

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

kernel/bpf/verifier.c

17238

struct bpf_insn *insn = &env->prog->insnsi[env->insn_idx];

kernel/bpf/verifier.c

17345

struct bpf_insn *insns = env->prog->insnsi;

kernel/bpf/verifier.c

17346

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

17430

if (bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

17738

struct bpf_prog *prog)

kernel/bpf/verifier.c

17741

enum bpf_prog_type prog_type = resolve_prog_type(prog);

kernel/bpf/verifier.c

17744

memcmp(map->excl_prog_sha, prog->digest, SHA256_DIGEST_SIZE)) {

kernel/bpf/verifier.c

17769

if ((bpf_prog_is_offloaded(prog->aux) || bpf_map_is_offloaded(map)) &&

kernel/bpf/verifier.c

17770

!bpf_offload_prog_map_match(prog, map)) {

kernel/bpf/verifier.c

17780

if (prog->sleepable)

kernel/bpf/verifier.c

17811

bpf_cgroup_storage_assign(env->prog->aux, map)) {

kernel/bpf/verifier.c

17817

if (env->prog->aux->arena) {

kernel/bpf/verifier.c

17825

if (!env->prog->jit_requested) {

kernel/bpf/verifier.c

17833

env->prog->aux->arena = (void *)map;

kernel/bpf/verifier.c

17834

if (!bpf_arena_get_user_vm_start(env->prog->aux->arena)) {

kernel/bpf/verifier.c

17858

err = check_map_prog_compatibility(env, map, env->prog);

kernel/bpf/verifier.c

17862

if (env->prog->sleepable)

kernel/bpf/verifier.c

17875

err = bpf_insn_array_init(map, env->prog);

kernel/bpf/verifier.c

18098

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

18099

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

18102

err = bpf_prog_calc_tag(env->prog);

kernel/bpf/verifier.c

18247

__bpf_free_used_maps(env->prog->aux, env->used_maps,

kernel/bpf/verifier.c

18260

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

18261

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

18298

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

18299

const int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

18359

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

kernel/bpf/verifier.c

18373

state->in_sleepable = env->prog->sleepable;

kernel/bpf/verifier.c

18388

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

kernel/bpf/verifier.c

18462

if (env->prog->type == BPF_PROG_TYPE_EXT && sub->arg_cnt > MAX_BPF_FUNC_REG_ARGS) {

kernel/bpf/verifier.c

18473

if (env->prog->aux->func_info_aux) {

kernel/bpf/verifier.c

18476

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

kernel/bpf/verifier.c

18488

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

kernel/bpf/verifier.c

18528

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

kernel/bpf/verifier.c

18589

env->prog->aux->stack_depth = env->subprog_info[0].stack_depth;

kernel/bpf/verifier.c

18619

int bpf_prog_ctx_arg_info_init(struct bpf_prog *prog,

kernel/bpf/verifier.c

18622

prog->aux->ctx_arg_info = kmemdup_array(info, cnt, sizeof(*info), GFP_KERNEL_ACCOUNT);

kernel/bpf/verifier.c

18623

prog->aux->ctx_arg_info_size = cnt;

kernel/bpf/verifier.c

18625

return prog->aux->ctx_arg_info ? 0 : -ENOMEM;

kernel/bpf/verifier.c

18634

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

18641

if (!prog->gpl_compatible) {

kernel/bpf/verifier.c

18646

if (!prog->aux->attach_btf_id)

kernel/bpf/verifier.c

18649

btf = prog->aux->attach_btf;

kernel/bpf/verifier.c

18660

btf_id = prog->aux->attach_btf_id;

kernel/bpf/verifier.c

18670

member_idx = prog->expected_attach_type;

kernel/bpf/verifier.c

18696

err = st_ops->check_member(t, member, prog);

kernel/bpf/verifier.c

18705

if (prog->aux->priv_stack_requested && !bpf_jit_supports_private_stack()) {

kernel/bpf/verifier.c

18727

prog->aux->st_ops = st_ops;

kernel/bpf/verifier.c

18728

prog->aux->attach_st_ops_member_off = member_off;

kernel/bpf/verifier.c

18730

prog->aux->attach_func_proto = func_proto;

kernel/bpf/verifier.c

18731

prog->aux->attach_func_name = mname;

kernel/bpf/verifier.c

18734

return bpf_prog_ctx_arg_info_init(prog, st_ops_desc->arg_info[member_idx].info,

kernel/bpf/verifier.c

18831

static bool is_tracing_multi_id(const struct bpf_prog *prog, u32 btf_id)

kernel/bpf/verifier.c

18833

return is_tracing_multi(prog->expected_attach_type) && bpf_multi_func_btf_id[0] == btf_id;

kernel/bpf/verifier.c

18836

static int btf_id_allow_sleepable(u32 btf_id, unsigned long addr, const struct bpf_prog *prog,

kernel/bpf/verifier.c

18842

switch (prog->type) {

kernel/bpf/verifier.c

18856

if (is_tracing_multi_id(prog, btf_id))

kernel/bpf/verifier.c

18865

u32 *flags = btf_kfunc_is_modify_return(btf, btf_id, prog);

kernel/bpf/verifier.c

18927

const struct bpf_prog *prog,

kernel/bpf/verifier.c

18932

bool prog_extension = prog->type == BPF_PROG_TYPE_EXT;

kernel/bpf/verifier.c

18933

bool prog_tracing = prog->type == BPF_PROG_TYPE_TRACING;

kernel/bpf/verifier.c

18949

btf = tgt_prog ? tgt_prog->aux->btf : prog->aux->attach_btf;

kernel/bpf/verifier.c

18970

if (bpf_prog_is_dev_bound(prog->aux) &&

kernel/bpf/verifier.c

18971

!bpf_prog_dev_bound_match(prog, tgt_prog)) {

kernel/bpf/verifier.c

18998

if (!prog->jit_requested) {

kernel/bpf/verifier.c

19006

if (prog->aux->changes_pkt_data && !tgt_changes_pkt_data) {

kernel/bpf/verifier.c

19015

if (prog->aux->might_sleep && !tgt_might_sleep) {

kernel/bpf/verifier.c

19035

} else if (tgt_prog->type == prog->type) {

kernel/bpf/verifier.c

19076

switch (prog->expected_attach_type) {

kernel/bpf/verifier.c

19101

if (prog->sleepable && !tracepoint_is_faultable(btp->tp)) {

kernel/bpf/verifier.c

19160

if ((prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/bpf/verifier.c

19161

prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI) &&

kernel/bpf/verifier.c

19172

btf_check_type_match(log, prog, btf, t))

kernel/bpf/verifier.c

19178

if ((prog->aux->saved_dst_prog_type || prog->aux->saved_dst_attach_type) &&

kernel/bpf/verifier.c

19179

(!tgt_prog || prog->aux->saved_dst_prog_type != tgt_prog->type ||

kernel/bpf/verifier.c

19180

prog->aux->saved_dst_attach_type != tgt_prog->expected_attach_type))

kernel/bpf/verifier.c

19194

if (is_tracing_multi_id(prog, btf_id)) {

kernel/bpf/verifier.c

19225

if (prog->sleepable) {

kernel/bpf/verifier.c

19226

ret = btf_id_allow_sleepable(btf_id, addr, prog, btf);

kernel/bpf/verifier.c

19232

} else if (prog->expected_attach_type == BPF_MODIFY_RETURN) {

kernel/bpf/verifier.c

19239

if (btf_kfunc_is_modify_return(btf, btf_id, prog) ||

kernel/bpf/verifier.c

19304

static bool can_be_sleepable(struct bpf_prog *prog)

kernel/bpf/verifier.c

19306

if (prog->type == BPF_PROG_TYPE_TRACING) {

kernel/bpf/verifier.c

19307

switch (prog->expected_attach_type) {

kernel/bpf/verifier.c

19322

if (prog->type == BPF_PROG_TYPE_LSM)

kernel/bpf/verifier.c

19323

return prog->expected_attach_type != BPF_LSM_CGROUP;

kernel/bpf/verifier.c

19325

return prog->type == BPF_PROG_TYPE_KPROBE /* only for uprobes */ ||

kernel/bpf/verifier.c

19326

prog->type == BPF_PROG_TYPE_STRUCT_OPS ||

kernel/bpf/verifier.c

19327

prog->type == BPF_PROG_TYPE_RAW_TRACEPOINT ||

kernel/bpf/verifier.c

19328

prog->type == BPF_PROG_TYPE_TRACEPOINT;

kernel/bpf/verifier.c

19333

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

19334

struct bpf_prog *tgt_prog = prog->aux->dst_prog;

kernel/bpf/verifier.c

19336

u32 btf_id = prog->aux->attach_btf_id;

kernel/bpf/verifier.c

19341

if (prog->type == BPF_PROG_TYPE_SYSCALL) {

kernel/bpf/verifier.c

19342

if (prog->sleepable)

kernel/bpf/verifier.c

19349

if (prog->sleepable && !can_be_sleepable(prog)) {

kernel/bpf/verifier.c

19354

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS)

kernel/bpf/verifier.c

19357

if (prog->type != BPF_PROG_TYPE_TRACING &&

kernel/bpf/verifier.c

19358

prog->type != BPF_PROG_TYPE_LSM &&

kernel/bpf/verifier.c

19359

prog->type != BPF_PROG_TYPE_EXT)

kernel/bpf/verifier.c

19362

ret = bpf_check_attach_target(&env->log, prog, tgt_prog, btf_id, &tgt_info);

kernel/bpf/verifier.c

19366

if (tgt_prog && prog->type == BPF_PROG_TYPE_EXT) {

kernel/bpf/verifier.c

19372

prog->expected_attach_type = tgt_prog->expected_attach_type;

kernel/bpf/verifier.c

19376

prog->aux->attach_func_proto = tgt_info.tgt_type;

kernel/bpf/verifier.c

19377

prog->aux->attach_func_name = tgt_info.tgt_name;

kernel/bpf/verifier.c

19378

prog->aux->mod = tgt_info.tgt_mod;

kernel/bpf/verifier.c

19381

prog->aux->saved_dst_prog_type = tgt_prog->type;

kernel/bpf/verifier.c

19382

prog->aux->saved_dst_attach_type = tgt_prog->expected_attach_type;

kernel/bpf/verifier.c

19385

if (prog->expected_attach_type == BPF_TRACE_RAW_TP) {

kernel/bpf/verifier.c

19386

prog->aux->attach_btf_trace = true;

kernel/bpf/verifier.c

19388

} else if (prog->expected_attach_type == BPF_TRACE_ITER) {

kernel/bpf/verifier.c

19389

return bpf_iter_prog_supported(prog);

kernel/bpf/verifier.c

19392

if (prog->type == BPF_PROG_TYPE_LSM) {

kernel/bpf/verifier.c

19393

ret = bpf_lsm_verify_prog(&env->log, prog);

kernel/bpf/verifier.c

19396

} else if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/bpf/verifier.c

19401

} else if ((prog->expected_attach_type == BPF_TRACE_FEXIT ||

kernel/bpf/verifier.c

19402

prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/bpf/verifier.c

19403

prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI ||

kernel/bpf/verifier.c

19404

prog->expected_attach_type == BPF_MODIFY_RETURN) &&

kernel/bpf/verifier.c

19415

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/bpf/verifier.c

19416

is_tracing_multi(prog->expected_attach_type))

kernel/bpf/verifier.c

19419

key = bpf_trampoline_compute_key(tgt_prog, prog->aux->attach_btf, btf_id);

kernel/bpf/verifier.c

19427

prog->aux->dst_trampoline = tr;

kernel/bpf/verifier.c

19431

int bpf_check_attach_btf_id_multi(struct btf *btf, struct bpf_prog *prog, u32 btf_id,

kernel/bpf/verifier.c

19443

if ((prog->expected_attach_type == BPF_TRACE_FEXIT_MULTI ||

kernel/bpf/verifier.c

19444

prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI) &&

kernel/bpf/verifier.c

19466

if (WARN_ON_ONCE(!prog->aux->mod))

kernel/bpf/verifier.c

19468

addr = find_kallsyms_symbol_value(prog->aux->mod, tname);

kernel/bpf/verifier.c

19476

if (prog->sleepable) {

kernel/bpf/verifier.c

19477

err = btf_id_allow_sleepable(btf_id, addr, prog, btf);

kernel/bpf/verifier.c

19564

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

19576

xdp_kfunc = bpf_dev_bound_resolve_kfunc(prog, func_id);

kernel/bpf/verifier.c

19592

if (bpf_lsm_has_d_inode_locked(prog))

kernel/bpf/verifier.c

19595

if (bpf_lsm_has_d_inode_locked(prog))

kernel/bpf/verifier.c

19645

desc = find_kfunc_desc(env->prog, insn->imm, insn->off);

kernel/bpf/verifier.c

19725

(env->prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/bpf/verifier.c

19726

env->prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI)) {

kernel/bpf/verifier.c

19740

(env->prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/bpf/verifier.c

19741

env->prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI)) {

kernel/bpf/verifier.c

19761

struct bpf_insn ld_addrs[2] = { BPF_LD_IMM64(regno, (long)env->prog->aux) };

kernel/bpf/verifier.c

19772

int bpf_check(struct bpf_prog **prog, union bpf_attr *attr, bpfptr_t uattr,

kernel/bpf/verifier.c

19795

len = (*prog)->len;

kernel/bpf/verifier.c

19806

env->prog = *prog;

kernel/bpf/verifier.c

19807

env->ops = bpf_verifier_ops[env->prog->type];

kernel/bpf/verifier.c

19809

env->allow_ptr_leaks = bpf_allow_ptr_leaks(env->prog->aux->token);

kernel/bpf/verifier.c

19810

env->allow_uninit_stack = bpf_allow_uninit_stack(env->prog->aux->token);

kernel/bpf/verifier.c

19811

env->bypass_spec_v1 = bpf_bypass_spec_v1(env->prog->aux->token);

kernel/bpf/verifier.c

19812

env->bypass_spec_v4 = bpf_bypass_spec_v4(env->prog->aux->token);

kernel/bpf/verifier.c

19813

env->bpf_capable = is_priv = bpf_token_capable(env->prog->aux->token, CAP_BPF);

kernel/bpf/verifier.c

19882

if (bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

19883

ret = bpf_prog_offload_verifier_prep(env->prog);

kernel/bpf/verifier.c

19931

if (ret == 0 && bpf_prog_is_offloaded(env->prog->aux))

kernel/bpf/verifier.c

19972

if (ret == 0 && !bpf_prog_is_offloaded(env->prog->aux)) {

kernel/bpf/verifier.c

19974

env->prog->aux->verifier_zext = bpf_jit_needs_zext() ? !ret

kernel/bpf/verifier.c

19983

env->prog->aux->verified_insns = env->insn_processed;

kernel/bpf/verifier.c

19995

env->prog->aux->used_maps = kmalloc_objs(env->used_maps[0],

kernel/bpf/verifier.c

19999

if (!env->prog->aux->used_maps) {

kernel/bpf/verifier.c

20004

memcpy(env->prog->aux->used_maps, env->used_maps,

kernel/bpf/verifier.c

20006

env->prog->aux->used_map_cnt = env->used_map_cnt;

kernel/bpf/verifier.c

20010

env->prog->aux->used_btfs = kmalloc_objs(env->used_btfs[0],

kernel/bpf/verifier.c

20013

if (!env->prog->aux->used_btfs) {

kernel/bpf/verifier.c

20018

memcpy(env->prog->aux->used_btfs, env->used_btfs,

kernel/bpf/verifier.c

20020

env->prog->aux->used_btf_cnt = env->used_btf_cnt;

kernel/bpf/verifier.c

20034

if (env->prog->type == BPF_PROG_TYPE_EXT)

kernel/bpf/verifier.c

20035

env->prog->expected_attach_type = 0;

kernel/bpf/verifier.c

20037

env->prog = __bpf_prog_select_runtime(env, env->prog, &ret);

kernel/bpf/verifier.c

20042

if (!env->prog->aux->used_maps)

kernel/bpf/verifier.c

20047

if (!env->prog->aux->used_btfs)

kernel/bpf/verifier.c

20050

*prog = env->prog;

kernel/bpf/verifier.c

20056

bpf_clear_insn_aux_data(env, 0, env->prog->len);

kernel/bpf/verifier.c

2325

if (off >= env->prog->len || off < 0 || env->subprog_cnt == 0)

kernel/bpf/verifier.c

2353

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

2376

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

kernel/bpf/verifier.c

2467

find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset)

kernel/bpf/verifier.c

2475

tab = prog->aux->kfunc_tab;

kernel/bpf/verifier.c

2480

int bpf_get_kfunc_addr(const struct bpf_prog *prog, u32 func_id,

kernel/bpf/verifier.c

2485

desc = find_kfunc_desc(prog, func_id, btf_fd_idx);

kernel/bpf/verifier.c

2503

tab = env->prog->aux->kfunc_btf_tab;

kernel/bpf/verifier.c

2642

kfunc_flags = btf_kfunc_flags(btf, func_id, env->prog);

kernel/bpf/verifier.c

2688

prog_aux = env->prog->aux;

kernel/bpf/verifier.c

2697

if (!env->prog->jit_requested) {

kernel/bpf/verifier.c

2707

if (!env->prog->gpl_compatible) {

kernel/bpf/verifier.c

2734

if (find_kfunc_desc(env->prog, func_id, offset))

kernel/bpf/verifier.c

2772

bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog)

kernel/bpf/verifier.c

2774

return !!prog->aux->kfunc_tab;

kernel/bpf/verifier.c

2780

int i, ret, insn_cnt = env->prog->len, ex_cb_insn;

kernel/bpf/verifier.c

2781

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

2844

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

2845

int insn_cnt = env->prog->len;

kernel/bpf/verifier.c

2907

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

3099

struct bpf_insn *insn = env->prog->insnsi + env->insn_idx;

kernel/bpf/verifier.c

3460

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

3593

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

397

struct bpf_func_info_aux *aux = env->prog->aux->func_info_aux;

kernel/bpf/verifier.c

405

const struct btf *btf = env->prog->aux->btf;

kernel/bpf/verifier.c

4063

__mark_reg_known(arg, env->prog->insnsi[env->insn_idx].imm);

kernel/bpf/verifier.c

408

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

kernel/bpf/verifier.c

429

if (!env->prog->aux->func_info)

kernel/bpf/verifier.c

432

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

kernel/bpf/verifier.c

433

return btf_type_name(env->prog->aux->btf, info->type_id);

kernel/bpf/verifier.c

4470

struct bpf_insn *insn = &env->prog->insnsi[insn_idx];

kernel/bpf/verifier.c

4610

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

4668

env->prog->aux->max_pkt_offset =

kernel/bpf/verifier.c

4669

max_t(u32, env->prog->aux->max_pkt_offset,

kernel/bpf/verifier.c

4675

static bool is_var_ctx_off_allowed(struct bpf_prog *prog)

kernel/bpf/verifier.c

4677

return resolve_prog_type(prog) == BPF_PROG_TYPE_SYSCALL;

kernel/bpf/verifier.c

4685

env->ops->is_valid_access(off, size, t, env->prog, info)) {

kernel/bpf/verifier.c

4704

if (env->prog->aux->max_ctx_offset < off + size)

kernel/bpf/verifier.c

4705

env->prog->aux->max_ctx_offset = off + size;

kernel/bpf/verifier.c

4721

bool var_off_ok = is_var_ctx_off_allowed(env->prog);

kernel/bpf/verifier.c

5026

static enum priv_stack_mode bpf_enable_priv_stack(struct bpf_prog *prog)

kernel/bpf/verifier.c

5035

switch (prog->type) {

kernel/bpf/verifier.c

5044

if (prog->aux->priv_stack_requested || bpf_prog_check_recur(prog))

kernel/bpf/verifier.c

5056

if (env->prog->jit_requested)

kernel/bpf/verifier.c

5081

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

5250

env->prog->aux->tail_call_reachable = true;

kernel/bpf/verifier.c

5293

priv_stack_mode = bpf_enable_priv_stack(env->prog);

kernel/bpf/verifier.c

5317

env->prog->aux->jits_use_priv_stack = true;

kernel/bpf/verifier.c

5368

env->prog->aux->max_tp_access = max(access_end, env->prog->aux->max_tp_access);

kernel/bpf/verifier.c

5752

if (!env->prog->gpl_compatible && btf_is_kernel(reg->btf)) {

kernel/bpf/verifier.c

6044

static bool get_func_retval_range(struct bpf_prog *prog,

kernel/bpf/verifier.c

6047

if (prog->type == BPF_PROG_TYPE_LSM &&

kernel/bpf/verifier.c

6048

prog->expected_attach_type == BPF_LSM_MAC &&

kernel/bpf/verifier.c

6049

!bpf_lsm_get_retval_range(prog, range)) {

kernel/bpf/verifier.c

6211

if (info.is_retval && get_func_retval_range(env->prog, &range)) {

kernel/bpf/verifier.c

6308

max_access = &env->prog->aux->max_rdonly_access;

kernel/bpf/verifier.c

6310

max_access = &env->prog->aux->max_rdwr_access;

kernel/bpf/verifier.c

6786

max_access = &env->prog->aux->max_rdonly_access;

kernel/bpf/verifier.c

6788

max_access = &env->prog->aux->max_rdwr_access;

kernel/bpf/verifier.c

6803

if (is_var_ctx_off_allowed(env->prog)) {

kernel/bpf/verifier.c

6808

if (env->prog->aux->max_ctx_offset < reg_umax(reg) + access_size)

kernel/bpf/verifier.c

6809

env->prog->aux->max_ctx_offset = reg_umax(reg) + access_size;

kernel/bpf/verifier.c

8079

if (arg_type != ARG_PTR_TO_CTX && is_var_ctx_off_allowed(env->prog))

kernel/bpf/verifier.c

8455

enum bpf_attach_type eatype = env->prog->expected_attach_type;

kernel/bpf/verifier.c

8456

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

8493

return env->prog->jit_requested &&

kernel/bpf/verifier.c

9251

struct bpf_prog *prog = env->prog;

kernel/bpf/verifier.c

9252

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

kernel/bpf/verifier.c

9256

if (!prog->aux->func_info)

kernel/bpf/verifier.c

9259

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

kernel/bpf/verifier.c

9263

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

kernel/bpf/verifier.c

9272

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

kernel/bpf/verifier.c

9693

struct bpf_insn *insn = env->prog->insnsi;

kernel/bpf/verifier.c

9815

enum bpf_prog_type prog_type = resolve_prog_type(env->prog);

kernel/bpf/verifier.c

9841

env->prog->expected_attach_type == BPF_CGROUP_GETSOCKOPT)

kernel/bpf/verifier.c

9845

env->prog->expected_attach_type == BPF_LSM_CGROUP) {

kernel/bpf/verifier.c

9846

if (!env->prog->aux->attach_func_proto->type)

kernel/bpf/verifier.c

9848

bpf_lsm_get_retval_range(env->prog, &range);

kernel/bpf/verifier.c

9949

enum bpf_prog_type type = resolve_prog_type(env->prog);

kernel/events/core.c

10285

struct bpf_prog *prog;

kernel/events/core.c

10323

static void perf_event_bpf_emit_ksymbols(struct bpf_prog *prog,

kernel/events/core.c

10330

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

kernel/events/core.c

10331

prog->jited_len, unregister,

kernel/events/core.c

10332

prog->aux->ksym.name);

kernel/events/core.c

10334

for (i = 1; i < prog->aux->func_cnt; i++) {

kernel/events/core.c

10335

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

kernel/events/core.c

10345

void perf_event_bpf_event(struct bpf_prog *prog,

kernel/events/core.c

10355

perf_event_bpf_emit_ksymbols(prog, type);

kernel/events/core.c

10365

.prog = prog,

kernel/events/core.c

10373

.id = prog->aux->id,

kernel/events/core.c

10379

memcpy(bpf_event.event_id.tag, prog->tag, BPF_TAG_SIZE);

kernel/events/core.c

10661

struct bpf_prog *prog;

kernel/events/core.c

10668

prog = READ_ONCE(event->prog);

kernel/events/core.c

10669

if (prog) {

kernel/events/core.c

10671

ret = bpf_prog_run(prog, &ctx);

kernel/events/core.c

10681

struct bpf_prog *prog,

kernel/events/core.c

10688

if (event->prog)

kernel/events/core.c

10691

if (prog->type != BPF_PROG_TYPE_PERF_EVENT)

kernel/events/core.c

10695

prog->call_get_stack &&

kernel/events/core.c

10711

event->prog = prog;

kernel/events/core.c

10718

struct bpf_prog *prog = event->prog;

kernel/events/core.c

10720

if (!prog)

kernel/events/core.c

10723

event->prog = NULL;

kernel/events/core.c

10724

bpf_prog_put(prog);

kernel/events/core.c

10735

struct bpf_prog *prog,

kernel/events/core.c

10769

if (event->prog && event->prog->type == BPF_PROG_TYPE_PERF_EVENT &&

kernel/events/core.c

11688

struct bpf_prog *prog,

kernel/events/core.c

11697

return perf_event_set_bpf_handler(event, prog, bpf_cookie);

kernel/events/core.c

11707

if (((is_kprobe || is_uprobe) && prog->type != BPF_PROG_TYPE_KPROBE) ||

kernel/events/core.c

11708

(is_tracepoint && prog->type != BPF_PROG_TYPE_TRACEPOINT) ||

kernel/events/core.c

11709

(is_syscall_tp && prog->type != BPF_PROG_TYPE_TRACEPOINT))

kernel/events/core.c

11712

if (prog->type == BPF_PROG_TYPE_KPROBE && prog->sleepable && !is_uprobe)

kernel/events/core.c

11716

if (prog->type == BPF_PROG_TYPE_TRACEPOINT && prog->sleepable) {

kernel/events/core.c

11726

if (prog->kprobe_override && !is_kprobe)

kernel/events/core.c

11730

if (prog->aux->kprobe_write_ctx && !is_uprobe)

kernel/events/core.c

11736

if (prog->aux->max_ctx_offset > off)

kernel/events/core.c

11740

return perf_event_attach_bpf_prog(event, prog, bpf_cookie);

kernel/events/core.c

11744

struct bpf_prog *prog,

kernel/events/core.c

11751

ret = __perf_event_set_bpf_prog(event, prog, bpf_cookie);

kernel/events/core.c

11759

if (!event->prog)

kernel/events/core.c

11780

struct bpf_prog *prog,

kernel/events/core.c

11787

struct bpf_prog *prog,

kernel/events/core.c

13436

if (parent_event->prog) {

kernel/events/core.c

13437

struct bpf_prog *prog = parent_event->prog;

kernel/events/core.c

13439

bpf_prog_inc(prog);

kernel/events/core.c

13440

event->prog = prog;

kernel/events/core.c

6595

struct bpf_prog *prog,

kernel/events/core.c

6655

struct bpf_prog *prog;

kernel/events/core.c

6658

prog = bpf_prog_get(arg);

kernel/events/core.c

6659

if (IS_ERR(prog))

kernel/events/core.c

6660

return PTR_ERR(prog);

kernel/events/core.c

6662

err = __perf_event_set_bpf_prog(event, prog, 0);

kernel/events/core.c

6664

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/ext.c

10606

int scx_kfunc_context_filter(const struct bpf_prog *prog, u32 kfunc_id)

kernel/sched/ext/ext.c

10625

if (prog->type == BPF_PROG_TYPE_SYSCALL)

kernel/sched/ext/ext.c

10628

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

kernel/sched/ext/ext.c

10638

if (!prog->aux->st_ops)

kernel/sched/ext/ext.c

10650

if (prog->aux->st_ops != &bpf_sched_ext_ops &&

kernel/sched/ext/ext.c

10651

prog->aux->st_ops != &bpf_sched_ext_ops_cid)

kernel/sched/ext/ext.c

10660

if (prog->aux->st_ops == &bpf_sched_ext_ops_cid && in_cpu_only)

kernel/sched/ext/ext.c

10667

moff = prog->aux->attach_st_ops_member_off;

kernel/sched/ext/ext.c

7864

const struct bpf_prog *prog,

kernel/sched/ext/ext.c

7874

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

kernel/sched/ext/ext.c

7962

static void scx_pstack_recursion_on_dispatch(struct bpf_prog *prog)

kernel/sched/ext/ext.c

7967

sch = scx_prog_sched(prog->aux);

kernel/sched/ext/ext.c

7977

const struct bpf_prog *prog)

kernel/sched/ext/ext.c

7996

if (prog->sleepable)

kernel/sched/ext/ext.c

8011

prog->aux->priv_stack_requested = true;

kernel/sched/ext/ext.c

8012

prog->aux->recursion_detected = scx_pstack_recursion_on_dispatch;

kernel/sched/ext/ext.c

8036

static int scx_arena_scan_prog(struct bpf_prog *prog, void *data)

kernel/sched/ext/ext.c

8043

arena = bpf_prog_arena(prog);

kernel/sched/ext/internal.h

1533

int scx_kfunc_context_filter(const struct bpf_prog *prog, u32 kfunc_id);

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

1274

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

kernel/trace/bpf_trace.c

1295

func_proto = bpf_base_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1299

if (!bpf_token_capable(prog->aux->token, CAP_SYS_ADMIN))

kernel/trace/bpf_trace.c

1311

static bool is_kprobe_multi(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1313

return prog->expected_attach_type == BPF_TRACE_KPROBE_MULTI ||

kernel/trace/bpf_trace.c

1314

prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION;

kernel/trace/bpf_trace.c

1317

static inline bool is_kprobe_session(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1319

return prog->type == BPF_PROG_TYPE_KPROBE &&

kernel/trace/bpf_trace.c

1320

prog->expected_attach_type == BPF_TRACE_KPROBE_SESSION;

kernel/trace/bpf_trace.c

1323

static inline bool is_uprobe_multi(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1325

return prog->expected_attach_type == BPF_TRACE_UPROBE_MULTI ||

kernel/trace/bpf_trace.c

1326

prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION;

kernel/trace/bpf_trace.c

1329

static inline bool is_uprobe_session(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1331

return prog->type == BPF_PROG_TYPE_KPROBE &&

kernel/trace/bpf_trace.c

1332

prog->expected_attach_type == BPF_TRACE_UPROBE_SESSION;

kernel/trace/bpf_trace.c

1335

static inline bool is_trace_fsession(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

1337

return prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

1338

(prog->expected_attach_type == BPF_TRACE_FSESSION ||

kernel/trace/bpf_trace.c

1339

prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI);

kernel/trace/bpf_trace.c

1343

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

kernel/trace/bpf_trace.c

1351

return prog->sleepable ? &bpf_get_stack_sleepable_proto : &bpf_get_stack_proto;

kernel/trace/bpf_trace.c

1357

if (is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

1359

if (is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

1363

if (is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

1365

if (is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

1369

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1375

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1390

prog->aux->kprobe_write_ctx = true;

kernel/trace/bpf_trace.c

1470

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

kernel/trace/bpf_trace.c

1482

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1487

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1574

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

kernel/trace/bpf_trace.c

1590

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1709

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

kernel/trace/bpf_trace.c

1721

return bpf_tracing_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1726

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

kernel/trace/bpf_trace.c

1762

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1766

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1770

return prog->expected_attach_type == BPF_TRACE_ITER ?

kernel/trace/bpf_trace.c

1776

if (bpf_prog_has_trampoline(prog) ||

kernel/trace/bpf_trace.c

1777

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1781

return bpf_prog_has_trampoline(prog) ? &bpf_get_func_ret_proto : NULL;

kernel/trace/bpf_trace.c

1783

if (bpf_prog_has_trampoline(prog) ||

kernel/trace/bpf_trace.c

1784

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1788

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

1789

prog->expected_attach_type == BPF_TRACE_RAW_TP)

kernel/trace/bpf_trace.c

1791

return bpf_prog_has_trampoline(prog) ? &bpf_get_attach_cookie_proto_tracing : NULL;

kernel/trace/bpf_trace.c

1793

fn = raw_tp_prog_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1794

if (!fn && prog->expected_attach_type == BPF_TRACE_ITER)

kernel/trace/bpf_trace.c

1795

fn = bpf_iter_get_func_proto(func_id, prog);

kernel/trace/bpf_trace.c

1802

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1810

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1813

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

kernel/trace/bpf_trace.c

1816

int __weak bpf_prog_test_run_tracing(struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1845

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1853

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

kernel/trace/bpf_trace.c

1865

const struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1905

struct bpf_prog *prog, u32 *target_size)

kernel/trace/bpf_trace.c

1952

struct bpf_prog *prog,

kernel/trace/bpf_trace.c

1963

if (prog->kprobe_override &&

kernel/trace/bpf_trace.c

1970

if (event->prog)

kernel/trace/bpf_trace.c

1980

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

kernel/trace/bpf_trace.c

1985

event->prog = prog;

kernel/trace/bpf_trace.c

1999

struct bpf_prog *prog = NULL;

kernel/trace/bpf_trace.c

2004

if (!event->prog)

kernel/trace/bpf_trace.c

2011

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

kernel/trace/bpf_trace.c

2013

bpf_prog_array_delete_safe(old_array, event->prog);

kernel/trace/bpf_trace.c

2020

prog = event->prog;

kernel/trace/bpf_trace.c

2021

event->prog = NULL;

kernel/trace/bpf_trace.c

2026

if (prog) {

kernel/trace/bpf_trace.c

2034

bpf_prog_put(prog);

kernel/trace/bpf_trace.c

2107

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

kernel/trace/bpf_trace.c

2108

bool sleepable = prog->sleepable;

kernel/trace/bpf_trace.c

2119

if (unlikely(!bpf_prog_get_recursion_context(prog))) {

kernel/trace/bpf_trace.c

2120

bpf_prog_inc_misses_counter(prog);

kernel/trace/bpf_trace.c

2127

(void)bpf_prog_run(prog, args);

kernel/trace/bpf_trace.c

2131

bpf_prog_put_recursion_context(prog);

kernel/trace/bpf_trace.c

2189

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

kernel/trace/bpf_trace.c

2195

if (prog->aux->max_ctx_offset > btp->num_args * sizeof(u64))

kernel/trace/bpf_trace.c

2198

if (prog->aux->max_tp_access > btp->writable_size)

kernel/trace/bpf_trace.c

2215

struct bpf_prog *prog;

kernel/trace/bpf_trace.c

2218

prog = event->prog;

kernel/trace/bpf_trace.c

2219

if (!prog)

kernel/trace/bpf_trace.c

2223

if (prog->type == BPF_PROG_TYPE_PERF_EVENT)

kernel/trace/bpf_trace.c

2226

*prog_id = prog->aux->id;

kernel/trace/bpf_trace.c

2619

bpf_prog_inc_misses_counter(link->link.prog);

kernel/trace/bpf_trace.c

2627

err = bpf_prog_run(link->link.prog, regs);

kernel/trace/bpf_trace.c

2648

return is_kprobe_session(link->link.prog) ? err : 0;

kernel/trace/bpf_trace.c

2780

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

kernel/trace/bpf_trace.c

2799

if (!is_kprobe_multi(prog))

kernel/trace/bpf_trace.c

2803

if (prog->sleepable)

kernel/trace/bpf_trace.c

2807

if (prog->aux->kprobe_write_ctx)

kernel/trace/bpf_trace.c

2870

if (prog->kprobe_override && addrs_check_error_injection_list(addrs, cnt)) {

kernel/trace/bpf_trace.c

2882

&bpf_kprobe_multi_link_lops, prog, attr->link_create.attach_type);

kernel/trace/bpf_trace.c

2890

if ((flags & BPF_F_KPROBE_MULTI_RETURN) || is_kprobe_session(prog))

kernel/trace/bpf_trace.c

2892

if (is_kprobe_session(prog))

kernel/trace/bpf_trace.c

2936

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

kernel/trace/bpf_trace.c

3139

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

kernel/trace/bpf_trace.c

3140

bool sleepable = prog->sleepable;

kernel/trace/bpf_trace.c

3155

err = bpf_prog_run(link->link.prog, regs);

kernel/trace/bpf_trace.c

3251

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

kernel/trace/bpf_trace.c

3273

if (!is_uprobe_multi(prog))

kernel/trace/bpf_trace.c

3355

if (flags & BPF_F_UPROBE_MULTI_RETURN || is_uprobe_session(prog))

kernel/trace/bpf_trace.c

3357

if (is_uprobe_session(prog))

kernel/trace/bpf_trace.c

3370

&bpf_uprobe_multi_link_lops, prog, attr->link_create.attach_type);

kernel/trace/bpf_trace.c

3403

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

kernel/trace/bpf_trace.c

3442

static int bpf_session_filter(const struct bpf_prog *prog, u32 kfunc_id)

kernel/trace/bpf_trace.c

3447

if (!is_kprobe_session(prog) && !is_uprobe_session(prog) && !is_trace_fsession(prog))

kernel/trace/bpf_trace.c

3690

WARN_ON_ONCE(bpf_trampoline_multi_detach(link->prog, tr_link));

kernel/trace/bpf_trace.c

3785

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

kernel/trace/bpf_trace.c

3832

if (prog->expected_attach_type == BPF_TRACE_FSESSION_MULTI) {

kernel/trace/bpf_trace.c

3847

&bpf_tracing_multi_link_lops, prog, prog->expected_attach_type);

kernel/trace/bpf_trace.c

3857

err = bpf_trampoline_multi_attach(prog, ids, link);

kernel/trace/bpf_trace.c

3875

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

kernel/trace/bpf_trace.c

977

static bool bpf_d_path_allowed(const struct bpf_prog *prog)

kernel/trace/bpf_trace.c

979

if (prog->type == BPF_PROG_TYPE_TRACING &&

kernel/trace/bpf_trace.c

980

prog->expected_attach_type == BPF_TRACE_ITER)

kernel/trace/bpf_trace.c

983

if (prog->type == BPF_PROG_TYPE_LSM)

kernel/trace/bpf_trace.c

984

return bpf_lsm_is_sleepable_hook(prog->aux->attach_btf_id);

kernel/trace/bpf_trace.c

987

prog->aux->attach_btf_id);

kernel/trace/trace.h

1591

struct prog_entry __rcu *prog;

kernel/trace/trace_events_filter.c

1171

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

1179

prog = rcu_dereference_raw(filter->prog);

kernel/trace/trace_events_filter.c

1180

if (!prog)

kernel/trace/trace_events_filter.c

1183

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

1184

struct filter_pred *pred = prog[i].pred;

kernel/trace/trace_events_filter.c

1186

if (match == prog[i].when_to_branch)

kernel/trace/trace_events_filter.c

1187

i = prog[i].target;

kernel/trace/trace_events_filter.c

1189

return prog[i].target;

kernel/trace/trace_events_filter.c

1283

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

1286

prog = rcu_access_pointer(filter->prog);

kernel/trace/trace_events_filter.c

1287

if (!prog)

kernel/trace/trace_events_filter.c

1290

for (i = 0; prog[i].pred; i++)

kernel/trace/trace_events_filter.c

1291

free_predicate(prog[i].pred);

kernel/trace/trace_events_filter.c

1292

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

2207

struct prog_entry *prog;

kernel/trace/trace_events_filter.c

2231

prog = predicate_parse(filter_string, nr_parens, nr_preds,

kernel/trace/trace_events_filter.c

2233

if (IS_ERR(prog))

kernel/trace/trace_events_filter.c

2234

return PTR_ERR(prog);

kernel/trace/trace_events_filter.c

2236

rcu_assign_pointer(filter->prog, prog);

kernel/trace/trace_events_filter.c

2655

static bool is_or(struct prog_entry *prog, int i)

kernel/trace/trace_events_filter.c

2664

target = prog[i].target + 1;

kernel/trace/trace_events_filter.c

2666

if (prog[target].pred)

kernel/trace/trace_events_filter.c

2670

return prog[i].when_to_branch == prog[target].target;

kernel/trace/trace_events_filter.c

2676

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2685

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

2686

struct filter_pred *pred = prog[i].pred;

kernel/trace/trace_events_filter.c

2688

if (!is_or(prog, i))

kernel/trace/trace_events_filter.c

2834

struct prog_entry *prog = rcu_dereference_protected(filter->prog,

kernel/trace/trace_events_filter.c

2838

for (i = 0; prog[i].pred; i++) {

kernel/trace/trace_events_filter.c

2839

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

175

prog, prog->expected_attach_type, 0);

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

1035

int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/test_run.c

1060

switch (prog->type) {

net/bpf/test_run.c

1213

if (prog->type == BPF_PROG_TYPE_LWT_XMIT) {

net/bpf/test_run.c

1225

ret = bpf_test_run(prog, skb, repeat, &retval, &duration, false);

net/bpf/test_run.c

1332

int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/test_run.c

1349

if (prog->expected_attach_type == BPF_XDP_DEVMAP ||

net/bpf/test_run.c

1350

prog->expected_attach_type == BPF_XDP_CPUMAP)

net/bpf/test_run.c

1356

if (bpf_prog_is_dev_bound(prog->aux))

net/bpf/test_run.c

1460

bpf_prog_change_xdp(NULL, prog);

net/bpf/test_run.c

1463

ret = bpf_test_run_xdp_live(prog, &xdp, repeat, batch_size, &duration);

net/bpf/test_run.c

1465

ret = bpf_test_run(prog, &xdp, repeat, &retval, &duration, true);

net/bpf/test_run.c

1484

bpf_prog_change_xdp(prog, NULL);

net/bpf/test_run.c

1509

int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,

net/bpf/test_run.c

1558

retval = bpf_flow_dissect(prog, &ctx, eth->h_proto, ETH_HLEN,

net/bpf/test_run.c

1578

int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog, const union bpf_attr *kattr,

net/bpf/test_run.c

1646

progs->items[0].prog = prog;

net/bpf/test_run.c

1678

int bpf_prog_test_run_syscall(struct bpf_prog *prog,

net/bpf/test_run.c

1695

if (ctx_size_in < prog->aux->max_ctx_offset ||

net/bpf/test_run.c

1706

retval = bpf_prog_run_pin_on_cpu(prog, ctx);

net/bpf/test_run.c

1776

int bpf_prog_test_run_nf(struct bpf_prog *prog,

net/bpf/test_run.c

1864

ret = bpf_test_run(prog, &ctx, repeat, &retval, &duration, false);

net/bpf/test_run.c

273

static int xdp_test_run_batch(struct xdp_test_data *xdp, struct bpf_prog *prog,

net/bpf/test_run.c

306

act = bpf_prog_run_xdp(prog, ctx);

net/bpf/test_run.c

329

ret = xdp_do_redirect_frame(xdp->dev, ctx, frm, prog);

net/bpf/test_run.c

337

bpf_warn_invalid_xdp_action(NULL, prog, act);

net/bpf/test_run.c

360

static int bpf_test_run_xdp_live(struct bpf_prog *prog, struct xdp_buff *ctx,

net/bpf/test_run.c

378

ret = xdp_test_run_batch(&xdp, prog, repeat - t.i);

net/bpf/test_run.c

388

static int bpf_test_run(struct bpf_prog *prog, void *ctx, u32 repeat,

net/bpf/test_run.c

392

struct bpf_prog_array_item item = {.prog = prog};

net/bpf/test_run.c

400

item.cgroup_storage[stype] = bpf_cgroup_storage_alloc(prog, stype);

net/bpf/test_run.c

420

*retval = bpf_prog_run_xdp(prog, ctx);

net/bpf/test_run.c

422

*retval = bpf_prog_run(prog, ctx);

net/bpf/test_run.c

685

int bpf_prog_test_run_tracing(struct bpf_prog *prog,

net/bpf/test_run.c

697

switch (prog->expected_attach_type) {

net/bpf/test_run.c

740

struct bpf_prog *prog;

net/bpf/test_run.c

755

if (info->prog->sleepable) {

net/bpf/test_run.c

762

if (unlikely(!bpf_prog_get_recursion_context(info->prog))) {

net/bpf/test_run.c

763

bpf_prog_inc_misses_counter(info->prog);

net/bpf/test_run.c

767

info->retval = bpf_prog_run(info->prog, info->ctx);

net/bpf/test_run.c

770

bpf_prog_put_recursion_context(info->prog);

net/bpf/test_run.c

772

if (info->prog->sleepable) {

net/bpf/test_run.c

782

int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,

net/bpf/test_run.c

798

if (ctx_size_in < prog->aux->max_ctx_offset ||

net/bpf/test_run.c

809

if (prog->sleepable && (kattr->test.flags & BPF_F_TEST_RUN_ON_CPU))

net/bpf/test_run.c

821

info.prog = prog;

net/bpf/test_run.c

823

if (prog->sleepable) {

net/core/bpf_sk_storage.c

357

static bool bpf_sk_storage_tracing_allowed(const struct bpf_prog *prog)

net/core/bpf_sk_storage.c

359

if (prog->aux->dst_prog)

net/core/bpf_sk_storage.c

366

switch (prog->expected_attach_type) {

net/core/bpf_sk_storage.c

374

return !!strncmp(prog->aux->attach_func_name, "bpf_sk_storage",

net/core/bpf_sk_storage.c

799

struct bpf_prog *prog;

net/core/bpf_sk_storage.c

803

prog = bpf_iter_get_info(&meta, selem == NULL);

net/core/bpf_sk_storage.c

804

if (prog) {

net/core/bpf_sk_storage.c

812

ret = bpf_iter_run_prog(prog, &ctx);

net/core/bpf_sk_storage.c

849

static int bpf_iter_attach_map(struct bpf_prog *prog,

net/core/bpf_sk_storage.c

866

if (prog->aux->max_rdwr_access > map->value_size) {

net/core/dev.c

10252

return link->link.prog;

net/core/dev.c

10253

return dev->xdp_state[mode].prog;

net/core/dev.c

10262

if (dev->xdp_state[i].prog || dev->xdp_state[i].link)

net/core/dev.c

10274

if (dev->xdp_state[i].prog &&

net/core/dev.c

10275

!dev->xdp_state[i].prog->aux->xdp_has_frags)

net/core/dev.c

10287

bpf->prog && !bpf->prog->aux->xdp_has_frags) {

net/core/dev.c

10304

struct bpf_prog *prog = dev_xdp_prog(dev, mode);

net/core/dev.c

10306

return prog ? prog->aux->id : 0;

net/core/dev.c

10313

dev->xdp_state[mode].prog = NULL;

net/core/dev.c

10317

struct bpf_prog *prog)

net/core/dev.c

10320

dev->xdp_state[mode].prog = prog;

net/core/dev.c

10325

u32 flags, struct bpf_prog *prog)

net/core/dev.c

10333

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

net/core/dev.c

10347

xdp.prog = prog;

net/core/dev.c

10355

if (prog)

net/core/dev.c

10356

bpf_prog_inc(prog);

net/core/dev.c

10359

if (prog)

net/core/dev.c

10360

bpf_prog_put(prog);

net/core/dev.c

10365

bpf_prog_change_xdp(dev_xdp_prog(dev, mode), prog);

net/core/dev.c

10373

struct bpf_prog *prog;

net/core/dev.c

10380

prog = dev_xdp_prog(dev, mode);

net/core/dev.c

10381

if (!prog)

net/core/dev.c

10395

bpf_prog_put(prog);

net/core/dev.c

10468

new_prog = link->link.prog;

net/core/dev.c

10631

if (old_prog && link->prog != old_prog) {

net/core/dev.c

10635

old_prog = link->prog;

net/core/dev.c

10657

old_prog = xchg(&link->prog, new_prog);

net/core/dev.c

10674

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

net/core/dev.c

10696

bpf_link_init(&link->link, BPF_LINK_TYPE_XDP, &bpf_xdp_link_lops, prog,

net/core/dev.c

4448

const struct bpf_prog *prog;

net/core/dev.c

4453

bpf_mprog_foreach_prog(entry, fp, prog) {

net/core/dev.c

4455

ret = bpf_prog_run(prog, skb);

net/core/dev.c

5561

netif_skb_check_for_xdp(struct sk_buff **pskb, const struct bpf_prog *prog)

net/core/dev.c

5567

err = skb_cow_data_for_xdp(this_cpu_read(system_page_pool.pool), pskb, prog);

net/core/dev.c

6363

struct bpf_prog *new = xdp->prog;

net/core/filter.c

10001

prog->cb_access = 1;

net/core/filter.c

10188

insn = bpf_convert_tstamp_write(prog, si, insn);

net/core/filter.c

10190

insn = bpf_convert_tstamp_read(prog, si, insn);

net/core/filter.c

10248

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10423

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10437

return bpf_convert_ctx_access(type, si, insn_buf, prog,

net/core/filter.c

10447

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10571

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

10660

struct bpf_prog *prog,

net/core/filter.c

11155

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

11171

prog->cb_access = 1;

net/core/filter.c

11185

return bpf_convert_ctx_access(type, si, insn_buf, prog,

net/core/filter.c

11195

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

11514

fprog = filter->prog->orig_prog;

net/core/filter.c

11558

struct bpf_prog *prog, struct sk_buff *skb,

net/core/filter.c

11566

action = bpf_prog_run(prog, &reuse_kern);

net/core/filter.c

11672

const struct bpf_prog *prog)

net/core/filter.c

11686

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

11693

const struct bpf_prog *prog,

net/core/filter.c

11761

struct bpf_prog *prog,

net/core/filter.c

11858

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

net/core/filter.c

1186

static void __bpf_prog_release(struct bpf_prog *prog)

net/core/filter.c

11868

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

11874

const struct bpf_prog *prog,

net/core/filter.c

1188

if (prog->type == BPF_PROG_TYPE_SOCKET_FILTER) {

net/core/filter.c

1189

bpf_prog_put(prog);

net/core/filter.c

1191

bpf_release_orig_filter(prog);

net/core/filter.c

1192

bpf_prog_free(prog);

net/core/filter.c

11921

struct bpf_prog *prog,

net/core/filter.c

1198

__bpf_prog_release(fp->prog);

net/core/filter.c

12029

void bpf_prog_change_xdp(struct bpf_prog *prev_prog, struct bpf_prog *prog)

net/core/filter.c

12031

bpf_dispatcher_change_prog(BPF_DISPATCHER_PTR(xdp), prev_prog, prog);

net/core/filter.c

12202

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

net/core/filter.c

12231

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

12234

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

net/core/filter.c

1227

u32 filter_size = bpf_prog_size(fp->prog->len);

net/core/filter.c

1239

u32 filter_size = bpf_prog_size(fp->prog->len);

net/core/filter.c

12691

static int tracing_iter_filter(const struct bpf_prog *prog, u32 kfunc_id)

net/core/filter.c

12694

prog->expected_attach_type != BPF_TRACE_ITER)

net/core/filter.c

1475

static int __sk_attach_prog(struct bpf_prog *prog, struct sock *sk)

net/core/filter.c

1483

fp->prog = prog;

net/core/filter.c

1505

struct bpf_prog *prog;

net/core/filter.c

1515

prog = bpf_prog_alloc(bpf_prog_size(fprog->len), 0);

net/core/filter.c

1516

if (!prog)

net/core/filter.c

1519

if (copy_from_user(prog->insns, fprog->filter, fsize)) {

net/core/filter.c

1520

__bpf_prog_free(prog);

net/core/filter.c

1524

prog->len = fprog->len;

net/core/filter.c

1526

err = bpf_prog_store_orig_filter(prog, fprog);

net/core/filter.c

1528

__bpf_prog_free(prog);

net/core/filter.c

1535

return bpf_prepare_filter(prog, NULL);

net/core/filter.c

1550

struct bpf_prog *prog = __get_filter(fprog, sk);

net/core/filter.c

1553

if (IS_ERR(prog))

net/core/filter.c

1554

return PTR_ERR(prog);

net/core/filter.c

1556

err = __sk_attach_prog(prog, sk);

net/core/filter.c

1558

__bpf_prog_release(prog);

net/core/filter.c

1568

struct bpf_prog *prog = __get_filter(fprog, sk);

net/core/filter.c

1571

if (IS_ERR(prog))

net/core/filter.c

1572

return PTR_ERR(prog);

net/core/filter.c

1575

if (bpf_prog_size(prog->len) > optmem_max)

net/core/filter.c

1578

err = reuseport_attach_prog(sk, prog);

net/core/filter.c

1581

__bpf_prog_release(prog);

net/core/filter.c

1596

struct bpf_prog *prog = __get_bpf(ufd, sk);

net/core/filter.c

1599

if (IS_ERR(prog))

net/core/filter.c

1600

return PTR_ERR(prog);

net/core/filter.c

1602

err = __sk_attach_prog(prog, sk);

net/core/filter.c

1604

bpf_prog_put(prog);

net/core/filter.c

1613

struct bpf_prog *prog;

net/core/filter.c

1619

prog = bpf_prog_get_type(ufd, BPF_PROG_TYPE_SOCKET_FILTER);

net/core/filter.c

1620

if (PTR_ERR(prog) == -EINVAL)

net/core/filter.c

1621

prog = bpf_prog_get_type(ufd, BPF_PROG_TYPE_SK_REUSEPORT);

net/core/filter.c

1622

if (IS_ERR(prog))

net/core/filter.c

1623

return PTR_ERR(prog);

net/core/filter.c

1625

if (prog->type == BPF_PROG_TYPE_SK_REUSEPORT) {

net/core/filter.c

164

pkt_len = bpf_prog_run_save_cb(filter->prog, skb);

net/core/filter.c

1643

if (bpf_prog_size(prog->len) > optmem_max) {

net/core/filter.c

1649

err = reuseport_attach_prog(sk, prog);

net/core/filter.c

1652

bpf_prog_put(prog);

net/core/filter.c

1660

struct bpf_prog *prog = aux->prog;

net/core/filter.c

1662

bpf_release_orig_filter(prog);

net/core/filter.c

1663

bpf_prog_free(prog);

net/core/filter.c

1666

void sk_reuseport_prog_free(struct bpf_prog *prog)

net/core/filter.c

1668

if (!prog)

net/core/filter.c

1671

if (bpf_prog_was_classic(prog))

net/core/filter.c

1672

call_rcu(&prog->aux->rcu, sk_reuseport_prog_free_rcu);

net/core/filter.c

1674

bpf_prog_put(prog);

net/core/filter.c

580

static int bpf_convert_filter(struct sock_filter *prog, int len,

net/core/filter.c

605

fp = prog;

net/core/filter.c

7452

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

7646

struct bpf_prog *prog, u32 *target_size)

net/core/filter.c

8262

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

net/core/filter.c

8266

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8282

switch (prog->expected_attach_type) {

net/core/filter.c

8289

switch (prog->expected_attach_type) {

net/core/filter.c

8296

return bpf_base_func_proto(func_id, prog);

net/core/filter.c

8301

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

net/core/filter.c

8305

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8311

switch (prog->expected_attach_type) {

net/core/filter.c

8339

switch (prog->expected_attach_type) {

net/core/filter.c

8362

switch (prog->expected_attach_type) {

net/core/filter.c

8385

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8390

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

net/core/filter.c

8406

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8414

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

net/core/filter.c

8418

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8458

return sk_filter_func_proto(func_id, prog);

net/core/filter.c

8463

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

net/core/filter.c

8595

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8600

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

net/core/filter.c

8654

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8675

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

net/core/filter.c

8679

func_proto = cgroup_common_func_proto(func_id, prog);

net/core/filter.c

8715

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8723

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

net/core/filter.c

8749

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8757

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

net/core/filter.c

8793

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8798

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

net/core/filter.c

8804

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8809

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

net/core/filter.c

8831

return bpf_sk_base_func_proto(func_id, prog);

net/core/filter.c

8836

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

net/core/filter.c

8842

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8847

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

net/core/filter.c

8881

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8886

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

net/core/filter.c

8898

return lwt_out_func_proto(func_id, prog);

net/core/filter.c

8903

const struct bpf_prog *prog,

net/core/filter.c

8970

const struct bpf_prog *prog,

net/core/filter.c

8994

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

net/core/filter.c

8999

const struct bpf_prog *prog,

net/core/filter.c

9009

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

net/core/filter.c

9021

if (!bpf_token_capable(prog->aux->token, CAP_BPF))

net/core/filter.c

9038

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

net/core/filter.c

9043

const struct bpf_prog *prog,

net/core/filter.c

9076

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

net/core/filter.c

9175

const struct bpf_prog *prog,

net/core/filter.c

9181

prog->expected_attach_type);

net/core/filter.c

9185

const struct bpf_prog *prog)

net/core/filter.c

9194

const struct bpf_prog *prog, int drop_verdict)

net/core/filter.c

9227

*insn++ = prog->insnsi[0];

net/core/filter.c

9268

const struct bpf_prog *prog)

net/core/filter.c

9270

return bpf_unclone_prologue(insn_buf, direct_write, prog, TC_ACT_SHOT);

net/core/filter.c

9275

const struct bpf_prog *prog,

net/core/filter.c

9312

((struct bpf_prog *)prog)->tstamp_type_access = 1;

net/core/filter.c

9316

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

net/core/filter.c

9355

const struct bpf_prog *prog,

net/core/filter.c

9358

if (prog->expected_attach_type != BPF_XDP_DEVMAP) {

net/core/filter.c

9366

if (bpf_prog_is_offloaded(prog->aux)) {

net/core/filter.c

9399

const struct bpf_prog *prog, u32 act)

net/core/filter.c

94

bpf_sk_base_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);

net/core/filter.c

9405

act, prog->aux->name, prog->aux->id, dev ? dev->name : "N/A");

net/core/filter.c

9425

const struct bpf_prog *prog,

net/core/filter.c

9440

switch (prog->expected_attach_type) {

net/core/filter.c

9453

switch (prog->expected_attach_type) {

net/core/filter.c

9466

switch (prog->expected_attach_type) {

net/core/filter.c

9475

switch (prog->expected_attach_type) {

net/core/filter.c

9546

const struct bpf_prog *prog,

net/core/filter.c

9609

const struct bpf_prog *prog)

net/core/filter.c

9611

return bpf_unclone_prologue(insn_buf, direct_write, prog, SK_DROP);

net/core/filter.c

9616

const struct bpf_prog *prog,

net/core/filter.c

9649

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

net/core/filter.c

9654

const struct bpf_prog *prog,

net/core/filter.c

9698

const struct bpf_prog *prog,

net/core/filter.c

9736

struct bpf_prog *prog,

net/core/filter.c

9806

static struct bpf_insn *bpf_convert_tstamp_read(const struct bpf_prog *prog,

net/core/filter.c

9818

if (!prog->tstamp_type_access) {

net/core/filter.c

9841

static struct bpf_insn *bpf_convert_tstamp_write(const struct bpf_prog *prog,

net/core/filter.c

9855

if (!prog->tstamp_type_access) {

net/core/filter.c

9882

struct bpf_prog *prog, u32 *target_size)

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

131

if (bpf->in.prog) {

net/core/lwt_bpf.c

154

if (bpf->out.prog) {

net/core/lwt_bpf.c

18

struct bpf_prog *prog;

net/core/lwt_bpf.c

284

if (bpf->xmit.prog) {

net/core/lwt_bpf.c

320

static void bpf_lwt_prog_destroy(struct bpf_lwt_prog *prog)

net/core/lwt_bpf.c

322

if (prog->prog)

net/core/lwt_bpf.c

323

bpf_prog_put(prog->prog);

net/core/lwt_bpf.c

325

kfree(prog->name);

net/core/lwt_bpf.c

343

static int bpf_parse_prog(struct nlattr *attr, struct bpf_lwt_prog *prog,

net/core/lwt_bpf.c

359

prog->name = nla_memdup(tb[LWT_BPF_PROG_NAME], GFP_ATOMIC);

net/core/lwt_bpf.c

360

if (!prog->name)

net/core/lwt_bpf.c

368

prog->prog = p;

net/core/lwt_bpf.c

455

struct bpf_lwt_prog *prog)

net/core/lwt_bpf.c

459

if (!prog->prog)

net/core/lwt_bpf.c

466

if (prog->name &&

net/core/lwt_bpf.c

467

nla_put_string(skb, LWT_BPF_PROG_NAME, prog->name))

net/core/lwt_bpf.c

51

ret = bpf_prog_run_save_cb(lwt->prog, skb);

net/core/skbuff.c

1019

const struct bpf_prog *prog)

net/core/skbuff.c

1021

if (!prog->aux->xdp_has_frags)

net/core/skmsg.c

1078

struct bpf_prog *prog;

net/core/skmsg.c

1089

prog = READ_ONCE(psock->progs.stream_verdict);

net/core/skmsg.c

1090

if (likely(prog)) {

net/core/skmsg.c

1094

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

1112

struct bpf_prog *prog;

net/core/skmsg.c

1116

prog = READ_ONCE(psock->progs.stream_parser);

net/core/skmsg.c

1117

if (likely(prog)) {

net/core/skmsg.c

1119

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

1201

struct bpf_prog *prog;

net/core/skmsg.c

1213

prog = READ_ONCE(psock->progs.stream_verdict);

net/core/skmsg.c

1214

if (!prog)

net/core/skmsg.c

1215

prog = READ_ONCE(psock->progs.skb_verdict);

net/core/skmsg.c

1216

if (likely(prog)) {

net/core/skmsg.c

1219

ret = bpf_prog_run_pin_on_cpu(prog, skb);

net/core/skmsg.c

923

struct bpf_prog *prog;

net/core/skmsg.c

927

prog = READ_ONCE(psock->progs.msg_parser);

net/core/skmsg.c

928

if (unlikely(!prog)) {

net/core/skmsg.c

935

ret = bpf_prog_run_pin_on_cpu(prog, msg);

net/core/sock_diag.c

94

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

1377

struct bpf_prog *prog;

net/core/sock_map.c

1380

prog = bpf_iter_get_info(&meta, !elem);

net/core/sock_map.c

1381

if (!prog)

net/core/sock_map.c

1391

return bpf_iter_run_prog(prog, &ctx);

net/core/sock_map.c

1521

struct bpf_prog *prog)

net/core/sock_map.c

1524

if (prog && attach_type == BPF_SK_SKB_STREAM_PARSER &&

net/core/sock_map.c

1525

prog->aux->changes_pkt_data)

net/core/sock_map.c

1537

static int sock_map_prog_update(struct bpf_map *map, struct bpf_prog *prog,

net/core/sock_map.c

1549

ret = sock_map_prog_attach_check(which, prog);

net/core/sock_map.c

1556

if ((!link || prog) && *plink)

net/core/sock_map.c

1560

ret = psock_replace_prog(pprog, prog, old);

net/core/sock_map.c

1564

psock_set_prog(pprog, prog);

net/core/sock_map.c

1578

struct bpf_prog *prog;

net/core/sock_map.c

1597

prog = *pprog;

net/core/sock_map.c

1598

prog_cnt = !prog ? 0 : 1;

net/core/sock_map.c

1606

id = data_race(prog->aux->id);

net/core/sock_map.c

1750

WARN_ON_ONCE(sock_map_prog_update(sockmap_link->map, NULL, link->prog, link,

net/core/sock_map.c

1775

struct bpf_prog *prog,

net/core/sock_map.c

1786

if (old && link->prog != old) {

net/core/sock_map.c

1791

if (link->prog->type != prog->type ||

net/core/sock_map.c

1792

link->prog->expected_attach_type != prog->expected_attach_type) {

net/core/sock_map.c

1797

ret = sock_map_prog_attach_check(link->attach_type, prog);

net/core/sock_map.c

1818

ret = psock_replace_prog(pprog, prog, old);

net/core/sock_map.c

1822

psock_set_prog(pprog, prog);

net/core/sock_map.c

1825

bpf_prog_inc(prog);

net/core/sock_map.c

1826

old_link_prog = xchg(&link->prog, prog);

net/core/sock_map.c

1875

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

net/core/sock_map.c

1901

bpf_link_init(&sockmap_link->link, BPF_LINK_TYPE_SOCKMAP, &sock_map_link_ops, prog,

net/core/sock_map.c

1912

ret = sock_map_prog_update(map, prog, NULL, &sockmap_link->link, attach_type);

net/core/sock_map.c

1926

bpf_prog_inc(prog);

net/core/sock_map.c

1935

static int sock_map_iter_attach_target(struct bpf_prog *prog,

net/core/sock_map.c

1953

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

764

struct bpf_prog *prog;

net/core/sock_map.c

767

prog = bpf_iter_get_info(&meta, !v);

net/core/sock_map.c

768

if (!prog)

net/core/sock_map.c

778

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

2900

static int tcp_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/ipv4/tcp_ipv4.c

2909

return bpf_iter_run_prog(prog, &ctx);

net/ipv4/tcp_ipv4.c

3226

struct bpf_prog *prog;

net/ipv4/tcp_ipv4.c

3254

prog = bpf_iter_get_info(&meta, false);

net/ipv4/tcp_ipv4.c

3255

ret = tcp_prog_seq_show(prog, &meta, v, uid);

net/ipv4/tcp_ipv4.c

3268

struct bpf_prog *prog;

net/ipv4/tcp_ipv4.c

3272

prog = bpf_iter_get_info(&meta, true);

net/ipv4/tcp_ipv4.c

3273

if (prog)

net/ipv4/tcp_ipv4.c

3274

(void)tcp_prog_seq_show(prog, &meta, v, 0);

net/ipv4/tcp_ipv4.c

3613

const struct bpf_prog *prog)

net/ipv4/udp.c

3480

static int udp_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/ipv4/udp.c

3490

return bpf_iter_run_prog(prog, &ctx);

net/ipv4/udp.c

3497

struct bpf_prog *prog;

net/ipv4/udp.c

3514

prog = bpf_iter_get_info(&meta, false);

net/ipv4/udp.c

3515

ret = udp_prog_seq_show(prog, &meta, v, uid, state->bucket);

net/ipv4/udp.c

3543

struct bpf_prog *prog;

net/ipv4/udp.c

3547

prog = bpf_iter_get_info(&meta, true);

net/ipv4/udp.c

3548

if (prog)

net/ipv4/udp.c

3549

(void)udp_prog_seq_show(prog, &meta, v, 0, 0);

net/ipv6/ip6_fib.c

2777

static int ipv6_route_prog_seq_show(struct bpf_prog *prog,

net/ipv6/ip6_fib.c

2785

return bpf_iter_run_prog(prog, &ctx);

net/ipv6/ip6_fib.c

2792

struct bpf_prog *prog;

net/ipv6/ip6_fib.c

2796

prog = bpf_iter_get_info(&meta, false);

net/ipv6/ip6_fib.c

2797

if (!prog)

net/ipv6/ip6_fib.c

2800

ret = ipv6_route_prog_seq_show(prog, &meta, v);

net/ipv6/ip6_fib.c

2809

struct bpf_prog *prog;

net/ipv6/ip6_fib.c

2813

prog = bpf_iter_get_info(&meta, true);

net/ipv6/ip6_fib.c

2814

if (prog)

net/ipv6/ip6_fib.c

2815

(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

1238

struct bpf_prog *prog)

net/kcm/kcmsock.c

1280

psock->bpf_prog = prog;

net/kcm/kcmsock.c

1343

struct bpf_prog *prog;

net/kcm/kcmsock.c

1350

prog = bpf_prog_get_type(info->bpf_fd, BPF_PROG_TYPE_SOCKET_FILTER);

net/kcm/kcmsock.c

1351

if (IS_ERR(prog)) {

net/kcm/kcmsock.c

1352

err = PTR_ERR(prog);

net/kcm/kcmsock.c

1356

err = kcm_attach(sock, csock, prog);

net/kcm/kcmsock.c

1358

bpf_prog_put(prog);

net/kcm/kcmsock.c

391

struct bpf_prog *prog = psock->bpf_prog;

net/kcm/kcmsock.c

394

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

2734

static int netlink_prog_seq_show(struct bpf_prog *prog,

net/netlink/af_netlink.c

2743

return bpf_iter_run_prog(prog, &ctx);

net/netlink/af_netlink.c

2749

struct bpf_prog *prog;

net/netlink/af_netlink.c

2752

prog = bpf_iter_get_info(&meta, false);

net/netlink/af_netlink.c

2753

if (!prog)

net/netlink/af_netlink.c

2757

return netlink_prog_seq_show(prog, &meta, v);

net/netlink/af_netlink.c

2765

struct bpf_prog *prog;

net/netlink/af_netlink.c

2769

prog = bpf_iter_get_info(&meta, true);

net/netlink/af_netlink.c

2770

if (prog)

net/netlink/af_netlink.c

2771

(void)netlink_prog_seq_show(prog, &meta, v);

net/packet/af_packet.c

1439

struct bpf_prog *prog;

net/packet/af_packet.c

1443

prog = rcu_dereference(f->bpf_prog);

net/packet/af_packet.c

1444

if (prog)

net/packet/af_packet.c

1445

ret = bpf_prog_run_clear_cb(prog, skb) % num;

net/packet/af_packet.c

2082

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_bh(prog->filter);

net/sched/act_bpf.c

79

qstats_cpu_drop_inc(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

154

skip_sw = prog && tc_skip_sw(prog->gen_flags);

net/sched/cls_bpf.c

155

obj = prog ?: oldprog;

net/sched/cls_bpf.c

160

cls_bpf.prog = prog ? prog->filter : NULL;

net/sched/cls_bpf.c

165

if (oldprog && prog)

net/sched/cls_bpf.c

169

&prog->gen_flags, &prog->in_hw_count,

net/sched/cls_bpf.c

171

else if (prog)

net/sched/cls_bpf.c

173

skip_sw, &prog->gen_flags,

net/sched/cls_bpf.c

174

&prog->in_hw_count, true);

net/sched/cls_bpf.c

180

if (prog && err) {

net/sched/cls_bpf.c

182

cls_bpf_offload_cmd(tp, oldprog, prog, extack, true);

net/sched/cls_bpf.c

186

if (prog && skip_sw && !(prog->gen_flags & TCA_CLS_FLAGS_IN_HW))

net/sched/cls_bpf.c

197

static int cls_bpf_offload(struct tcf_proto *tp, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

201

if (prog && oldprog &&

net/sched/cls_bpf.c

202

cls_bpf_flags(prog->gen_flags) !=

net/sched/cls_bpf.c

206

if (prog && tc_skip_hw(prog->gen_flags))

net/sched/cls_bpf.c

207

prog = NULL;

net/sched/cls_bpf.c

210

if (!prog && !oldprog)

net/sched/cls_bpf.c

213

return cls_bpf_offload_cmd(tp, prog, oldprog, extack, false);

net/sched/cls_bpf.c

217

struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

222

err = cls_bpf_offload_cmd(tp, NULL, prog, extack, false);

net/sched/cls_bpf.c

228

struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

233

tc_cls_common_offload_init(&cls_bpf.common, tp, prog->gen_flags, NULL);

net/sched/cls_bpf.c

235

cls_bpf.exts = &prog->exts;

net/sched/cls_bpf.c

236

cls_bpf.prog = prog->filter;

net/sched/cls_bpf.c

237

cls_bpf.name = prog->bpf_name;

net/sched/cls_bpf.c

238

cls_bpf.exts_integrated = prog->exts_integrated;

net/sched/cls_bpf.c

258

static void cls_bpf_free_parms(struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

260

if (cls_bpf_is_ebpf(prog))

net/sched/cls_bpf.c

261

bpf_prog_put(prog->filter);

net/sched/cls_bpf.c

263

bpf_prog_destroy(prog->filter);

net/sched/cls_bpf.c

265

kfree(prog->bpf_name);

net/sched/cls_bpf.c

266

kfree(prog->bpf_ops);

net/sched/cls_bpf.c

269

static void __cls_bpf_delete_prog(struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

271

tcf_exts_destroy(&prog->exts);

net/sched/cls_bpf.c

272

tcf_exts_put_net(&prog->exts);

net/sched/cls_bpf.c

274

cls_bpf_free_parms(prog);

net/sched/cls_bpf.c

275

kfree(prog);

net/sched/cls_bpf.c

280

struct cls_bpf_prog *prog = container_of(to_rcu_work(work),

net/sched/cls_bpf.c

284

__cls_bpf_delete_prog(prog);

net/sched/cls_bpf.c

288

static void __cls_bpf_delete(struct tcf_proto *tp, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

293

idr_remove(&head->handle_idr, prog->handle);

net/sched/cls_bpf.c

294

cls_bpf_stop_offload(tp, prog, extack);

net/sched/cls_bpf.c

295

list_del_rcu(&prog->link);

net/sched/cls_bpf.c

296

tcf_unbind_filter(tp, &prog->res);

net/sched/cls_bpf.c

297

if (tcf_exts_get_net(&prog->exts))

net/sched/cls_bpf.c

298

tcf_queue_work(&prog->rwork, cls_bpf_delete_prog_work);

net/sched/cls_bpf.c

300

__cls_bpf_delete_prog(prog);

net/sched/cls_bpf.c

317

struct cls_bpf_prog *prog, *tmp;

net/sched/cls_bpf.c

319

list_for_each_entry_safe(prog, tmp, &head->plist, link)

net/sched/cls_bpf.c

320

__cls_bpf_delete(tp, prog, extack);

net/sched/cls_bpf.c

329

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

331

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

332

if (prog->handle == handle)

net/sched/cls_bpf.c

333

return prog;

net/sched/cls_bpf.c

339

static int cls_bpf_prog_from_ops(struct nlattr **tb, struct cls_bpf_prog *prog)

net/sched/cls_bpf.c

368

prog->bpf_ops = bpf_ops;

net/sched/cls_bpf.c

369

prog->bpf_num_ops = bpf_num_ops;

net/sched/cls_bpf.c

370

prog->bpf_name = NULL;

net/sched/cls_bpf.c

371

prog->filter = fp;

net/sched/cls_bpf.c

376

static int cls_bpf_prog_from_efd(struct nlattr **tb, struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

399

prog->bpf_ops = NULL;

net/sched/cls_bpf.c

400

prog->bpf_name = name;

net/sched/cls_bpf.c

401

prog->filter = fp;

net/sched/cls_bpf.c

420

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

432

prog = kzalloc_obj(*prog);

net/sched/cls_bpf.c

433

if (!prog)

net/sched/cls_bpf.c

436

ret = tcf_exts_init(&prog->exts, net, TCA_BPF_ACT, TCA_BPF_POLICE);

net/sched/cls_bpf.c

449

ret = idr_alloc_u32(&head->handle_idr, prog, &handle,

net/sched/cls_bpf.c

452

ret = idr_alloc_u32(&head->handle_idr, prog, &handle,

net/sched/cls_bpf.c

458

prog->handle = handle;

net/sched/cls_bpf.c

467

ret = tcf_exts_validate(net, tp, tb, tca[TCA_RATE], &prog->exts,

net/sched/cls_bpf.c

491

prog->exts_integrated = have_exts;

net/sched/cls_bpf.c

492

prog->gen_flags = gen_flags;

net/sched/cls_bpf.c

494

ret = is_bpf ? cls_bpf_prog_from_ops(tb, prog) :

net/sched/cls_bpf.c

495

cls_bpf_prog_from_efd(tb, prog, gen_flags, tp);

net/sched/cls_bpf.c

500

prog->res.classid = nla_get_u32(tb[TCA_BPF_CLASSID]);

net/sched/cls_bpf.c

501

tcf_bind_filter(tp, &prog->res, base);

net/sched/cls_bpf.c

505

ret = cls_bpf_offload(tp, prog, oldprog, extack);

net/sched/cls_bpf.c

509

if (!tc_in_hw(prog->gen_flags))

net/sched/cls_bpf.c

510

prog->gen_flags |= TCA_CLS_FLAGS_NOT_IN_HW;

net/sched/cls_bpf.c

512

tcf_proto_update_usesw(tp, prog->gen_flags);

net/sched/cls_bpf.c

515

idr_replace(&head->handle_idr, prog, handle);

net/sched/cls_bpf.c

516

list_replace_rcu(&oldprog->link, &prog->link);

net/sched/cls_bpf.c

521

list_add_rcu(&prog->link, &head->plist);

net/sched/cls_bpf.c

524

*arg = prog;

net/sched/cls_bpf.c

529

tcf_unbind_filter(tp, &prog->res);

net/sched/cls_bpf.c

530

cls_bpf_free_parms(prog);

net/sched/cls_bpf.c

533

idr_remove(&head->handle_idr, prog->handle);

net/sched/cls_bpf.c

535

tcf_exts_destroy(&prog->exts);

net/sched/cls_bpf.c

536

kfree(prog);

net/sched/cls_bpf.c

540

static int cls_bpf_dump_bpf_info(const struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

545

if (nla_put_u16(skb, TCA_BPF_OPS_LEN, prog->bpf_num_ops))

net/sched/cls_bpf.c

548

nla = nla_reserve(skb, TCA_BPF_OPS, prog->bpf_num_ops *

net/sched/cls_bpf.c

553

memcpy(nla_data(nla), prog->bpf_ops, nla_len(nla));

net/sched/cls_bpf.c

558

static int cls_bpf_dump_ebpf_info(const struct cls_bpf_prog *prog,

net/sched/cls_bpf.c

563

if (prog->bpf_name &&

net/sched/cls_bpf.c

564

nla_put_string(skb, TCA_BPF_NAME, prog->bpf_name))

net/sched/cls_bpf.c

567

if (nla_put_u32(skb, TCA_BPF_ID, prog->filter->aux->id))

net/sched/cls_bpf.c

570

nla = nla_reserve(skb, TCA_BPF_TAG, sizeof(prog->filter->tag));

net/sched/cls_bpf.c

574

memcpy(nla_data(nla), prog->filter->tag, nla_len(nla));

net/sched/cls_bpf.c

582

struct cls_bpf_prog *prog = fh;

net/sched/cls_bpf.c

587

if (prog == NULL)

net/sched/cls_bpf.c

590

tm->tcm_handle = prog->handle;

net/sched/cls_bpf.c

592

cls_bpf_offload_update_stats(tp, prog);

net/sched/cls_bpf.c

598

if (prog->res.classid &&

net/sched/cls_bpf.c

599

nla_put_u32(skb, TCA_BPF_CLASSID, prog->res.classid))

net/sched/cls_bpf.c

602

if (cls_bpf_is_ebpf(prog))

net/sched/cls_bpf.c

603

ret = cls_bpf_dump_ebpf_info(prog, skb);

net/sched/cls_bpf.c

605

ret = cls_bpf_dump_bpf_info(prog, skb);

net/sched/cls_bpf.c

609

if (tcf_exts_dump(skb, &prog->exts) < 0)

net/sched/cls_bpf.c

612

if (prog->exts_integrated)

net/sched/cls_bpf.c

616

if (prog->gen_flags &&

net/sched/cls_bpf.c

617

nla_put_u32(skb, TCA_BPF_FLAGS_GEN, prog->gen_flags))

net/sched/cls_bpf.c

622

if (tcf_exts_dump_stats(skb, &prog->exts) < 0)

net/sched/cls_bpf.c

635

struct cls_bpf_prog *prog = fh;

net/sched/cls_bpf.c

637

tc_cls_bind_class(classid, cl, q, &prog->res, base);

net/sched/cls_bpf.c

644

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

646

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

647

if (!tc_cls_stats_dump(tp, arg, prog))

net/sched/cls_bpf.c

658

struct cls_bpf_prog *prog;

net/sched/cls_bpf.c

661

list_for_each_entry(prog, &head->plist, link) {

net/sched/cls_bpf.c

662

if (tc_skip_hw(prog->gen_flags))

net/sched/cls_bpf.c

665

tc_cls_common_offload_init(&cls_bpf.common, tp, prog->gen_flags,

net/sched/cls_bpf.c

668

cls_bpf.exts = &prog->exts;

net/sched/cls_bpf.c

669

cls_bpf.prog = add ? prog->filter : NULL;

net/sched/cls_bpf.c

670

cls_bpf.oldprog = add ? NULL : prog->filter;

net/sched/cls_bpf.c

671

cls_bpf.name = prog->bpf_name;

net/sched/cls_bpf.c

672

cls_bpf.exts_integrated = prog->exts_integrated;

net/sched/cls_bpf.c

675

&cls_bpf, cb_priv, &prog->gen_flags,

net/sched/cls_bpf.c

676

&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

3616

static int unix_prog_seq_show(struct bpf_prog *prog, struct bpf_iter_meta *meta,

net/unix/af_unix.c

3625

return bpf_iter_run_prog(prog, &ctx);

net/unix/af_unix.c

3747

struct bpf_prog *prog;

net/unix/af_unix.c

3765

prog = bpf_iter_get_info(&meta, false);

net/unix/af_unix.c

3766

ret = unix_prog_seq_show(prog, &meta, v, uid);

net/unix/af_unix.c

3777

struct bpf_prog *prog;

net/unix/af_unix.c

3781

prog = bpf_iter_get_info(&meta, true);

net/unix/af_unix.c

3782

if (prog)

net/unix/af_unix.c

3783

(void)unix_prog_seq_show(prog, &meta, v, 0);

net/unix/af_unix.c

3903

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

351

static int lsm_bpf_prog_alloc(struct bpf_prog *prog)

security/security.c

353

return lsm_blob_alloc(&prog->aux->security, blob_sizes.lbs_bpf_prog, GFP_KERNEL);

security/security.c

5326

int security_bpf_prog(struct bpf_prog *prog)

security/security.c

5328

return call_int_hook(bpf_prog, prog);

security/security.c

5371

int security_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

security/security.c

5376

rc = lsm_bpf_prog_alloc(prog);

security/security.c

5380

rc = call_int_hook(bpf_prog_load, prog, attr, token, kernel);

security/security.c

5382

security_bpf_prog_free(prog);

security/security.c

5463

void security_bpf_prog_free(struct bpf_prog *prog)

security/security.c

5465

call_void_hook(bpf_prog_free, prog);

security/security.c

5466

kfree(prog->aux->security);

security/security.c

5467

prog->aux->security = NULL;

security/selinux/hooks.c

7221

struct bpf_prog *prog;

security/selinux/hooks.c

7233

prog = file->private_data;

security/selinux/hooks.c

7234

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/hooks.c

7253

static int selinux_bpf_prog(struct bpf_prog *prog)

security/selinux/hooks.c

7258

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/hooks.c

7299

static int selinux_bpf_prog_load(struct bpf_prog *prog, union bpf_attr *attr,

security/selinux/hooks.c

7305

bpfsec = selinux_bpf_prog_security(prog);

security/selinux/include/objsec.h

279

selinux_bpf_prog_security(struct bpf_prog *prog)

security/selinux/include/objsec.h

281

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

10006

prog->name);

tools/lib/bpf/libbpf.c

10009

attr.line_info = info ?: prog->line_info;

tools/lib/bpf/libbpf.c

10010

attr.line_info_cnt = info ? info_cnt : prog->line_info_cnt;

tools/lib/bpf/libbpf.c

10011

attr.line_info_rec_size = info ? info_rec_size : prog->line_info_rec_size;

tools/lib/bpf/libbpf.c

10024

attr.expected_attach_type = prog->expected_attach_type;

tools/lib/bpf/libbpf.c

10025

attr.attach_btf_id = prog->attach_btf_id;

tools/lib/bpf/libbpf.c

10026

attr.attach_btf_obj_fd = prog->attach_btf_obj_fd;

tools/lib/bpf/libbpf.c

10028

if (prog->sec_def && prog->sec_def->prog_prepare_load_fn) {

tools/lib/bpf/libbpf.c

10029

err = prog->sec_def->prog_prepare_load_fn(prog, &attr, prog->sec_def->cookie);

tools/lib/bpf/libbpf.c

10047

fd = bpf_prog_load(prog->type, prog->name, obj->license, prog->insns, prog->insns_cnt,

tools/lib/bpf/libbpf.c

10062

static int attach_kprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10063

static int attach_uprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10064

static int attach_ksyscall(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10065

static int attach_usdt(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10066

static int attach_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10067

static int attach_raw_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10068

static int attach_trace(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10069

static int attach_kprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10070

static int attach_kprobe_session(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10071

static int attach_uprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10072

static int attach_lsm(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10073

static int attach_iter(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10074

static int attach_tracing_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link);

tools/lib/bpf/libbpf.c

10459

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

10532

prog = find_prog_by_sec_insn(obj, shdr_idx, insn_idx);

tools/lib/bpf/libbpf.c

10533

if (!prog) {

tools/lib/bpf/libbpf.c

10540

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS) {

tools/lib/bpf/libbpf.c

10542

map->name, prog->name);

tools/lib/bpf/libbpf.c

10546

st_ops->progs[member_idx] = prog;

tools/lib/bpf/libbpf.c

10554

*((struct bpf_program **)(st_ops->data + moff)) = prog;

tools/lib/bpf/libbpf.c

10726

static int libbpf_find_attach_btf_id(struct bpf_program *prog, const char *attach_name,

tools/lib/bpf/libbpf.c

10729

enum bpf_attach_type attach_type = prog->expected_attach_type;

tools/lib/bpf/libbpf.c

10730

__u32 attach_prog_fd = prog->attach_prog_fd;

tools/lib/bpf/libbpf.c

10734

if (prog->type == BPF_PROG_TYPE_EXT || attach_prog_fd) {

tools/lib/bpf/libbpf.c

10736

pr_warn("prog '%s': attach program FD is not set\n", prog->name);

tools/lib/bpf/libbpf.c

10739

err = libbpf_find_prog_btf_id(attach_name, attach_prog_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

10742

prog->name, attach_prog_fd, attach_name, errstr(err));

tools/lib/bpf/libbpf.c

10751

if (prog->obj->gen_loader) {

tools/lib/bpf/libbpf.c

10752

bpf_gen__record_attach_target(prog->obj->gen_loader, attach_name, attach_type);

tools/lib/bpf/libbpf.c

10756

err = find_kernel_btf_id(prog->obj, attach_name,

tools/lib/bpf/libbpf.c

10762

prog->name, attach_name, errstr(err));

tools/lib/bpf/libbpf.c

11094

int bpf_map__set_exclusive_program(struct bpf_map *map, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

11101

if (map->obj != prog->obj) {

tools/lib/bpf/libbpf.c

11106

map->excl_prog = prog;

tools/lib/bpf/libbpf.c

1112

const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

1117

if (&obj->programs[i] == prog)

tools/lib/bpf/libbpf.c

1118

return prog->type == BPF_PROG_TYPE_STRUCT_OPS;

tools/lib/bpf/libbpf.c

1131

struct bpf_program *prog, *slot_prog;

tools/lib/bpf/libbpf.c

11333

int bpf_link__update_program(struct bpf_link *link, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

11336

int prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

11340

prog->name);

tools/lib/bpf/libbpf.c

1139

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

1140

if (prog->type != BPF_PROG_TYPE_STRUCT_OPS)

tools/lib/bpf/libbpf.c

11520

struct bpf_link *bpf_program__attach_perf_event_opts(const struct bpf_program *prog, int pfd,

tools/lib/bpf/libbpf.c

11532

prog->name, pfd);

tools/lib/bpf/libbpf.c

11535

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

11538

prog->name);

tools/lib/bpf/libbpf.c

1154

if (prog != slot_prog)

tools/lib/bpf/libbpf.c

11550

if (kernel_supports(prog->obj, FEAT_PERF_LINK) && !force_ioctl_attach) {

tools/lib/bpf/libbpf.c

11558

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11564

pr_warn("prog '%s': user context value is not supported\n", prog->name);

tools/lib/bpf/libbpf.c

11572

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11575

prog->name, pfd);

tools/lib/bpf/libbpf.c

11585

prog->name, pfd, errstr(err));

tools/lib/bpf/libbpf.c

11598

struct bpf_link *bpf_program__attach_perf_event(const struct bpf_program *prog, int pfd)

tools/lib/bpf/libbpf.c

11600

return bpf_program__attach_perf_event_opts(prog, pfd, NULL);

tools/lib/bpf/libbpf.c

1163

prog->autoload = should_load;

tools/lib/bpf/libbpf.c

11915

bpf_program__attach_kprobe_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

11947

if (legacy || !kernel_supports(prog->obj, FEAT_PERF_LINK))

tools/lib/bpf/libbpf.c

11978

prog->name, retprobe ? "kretprobe" : "kprobe",

tools/lib/bpf/libbpf.c

11983

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

11988

prog->name, retprobe ? "kretprobe" : "kprobe",

tools/lib/bpf/libbpf.c

12011

struct bpf_link *bpf_program__attach_kprobe(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12019

return bpf_program__attach_kprobe_opts(prog, func_name, &opts);

tools/lib/bpf/libbpf.c

12022

struct bpf_link *bpf_program__attach_ksyscall(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12032

if (kernel_supports(prog->obj, FEAT_SYSCALL_WRAPPER)) {

tools/lib/bpf/libbpf.c

12047

return bpf_program__attach_kprobe_opts(prog, func_name, &kprobe_opts);

tools/lib/bpf/libbpf.c

1216

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

12262

bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

12282

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

12285

prog->name);

tools/lib/bpf/libbpf.c

12325

prog->name, pattern, res.cnt);

tools/lib/bpf/libbpf.c

12367

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

12380

static int attach_kprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12391

if (strcmp(prog->sec_name, "kprobe") == 0 || strcmp(prog->sec_name, "kretprobe") == 0)

tools/lib/bpf/libbpf.c

12394

opts.retprobe = str_has_pfx(prog->sec_name, "kretprobe/");

tools/lib/bpf/libbpf.c

12396

func_name = prog->sec_name + sizeof("kretprobe/") - 1;

tools/lib/bpf/libbpf.c

12398

func_name = prog->sec_name + sizeof("kprobe/") - 1;

tools/lib/bpf/libbpf.c

12419

*link = bpf_program__attach_kprobe_opts(prog, func, &opts);

tools/lib/bpf/libbpf.c

12424

static int attach_ksyscall(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12432

if (strcmp(prog->sec_name, "ksyscall") == 0 || strcmp(prog->sec_name, "kretsyscall") == 0)

tools/lib/bpf/libbpf.c

12435

opts.retprobe = str_has_pfx(prog->sec_name, "kretsyscall/");

tools/lib/bpf/libbpf.c

12437

syscall_name = prog->sec_name + sizeof("kretsyscall/") - 1;

tools/lib/bpf/libbpf.c

12439

syscall_name = prog->sec_name + sizeof("ksyscall/") - 1;

tools/lib/bpf/libbpf.c

12441

*link = bpf_program__attach_ksyscall(prog, syscall_name, &opts);

tools/lib/bpf/libbpf.c

12445

static int attach_kprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12455

if (strcmp(prog->sec_name, "kprobe.multi") == 0 ||

tools/lib/bpf/libbpf.c

12456

strcmp(prog->sec_name, "kretprobe.multi") == 0)

tools/lib/bpf/libbpf.c

12459

opts.retprobe = str_has_pfx(prog->sec_name, "kretprobe.multi/");

tools/lib/bpf/libbpf.c

12461

spec = prog->sec_name + sizeof("kretprobe.multi/") - 1;

tools/lib/bpf/libbpf.c

12463

spec = prog->sec_name + sizeof("kprobe.multi/") - 1;

tools/lib/bpf/libbpf.c

12471

*link = bpf_program__attach_kprobe_multi_opts(prog, pattern, &opts);

tools/lib/bpf/libbpf.c

12476

static int attach_kprobe_session(const struct bpf_program *prog, long cookie,

tools/lib/bpf/libbpf.c

12487

if (strcmp(prog->sec_name, "kprobe.session") == 0)

tools/lib/bpf/libbpf.c

12490

spec = prog->sec_name + sizeof("kprobe.session/") - 1;

tools/lib/bpf/libbpf.c

12497

*link = bpf_program__attach_kprobe_multi_opts(prog, pattern, &opts);

tools/lib/bpf/libbpf.c

12502

static int attach_uprobe_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12510

n = sscanf(prog->sec_name, "%m[^/]/%m[^:]:%m[^\n]",

tools/lib/bpf/libbpf.c

12521

*link = bpf_program__attach_uprobe_multi(prog, -1, binary_path, func_name, &opts);

tools/lib/bpf/libbpf.c

12525

pr_warn("prog '%s': invalid format of section definition '%s'\n", prog->name,

tools/lib/bpf/libbpf.c

12526

prog->sec_name);

tools/lib/bpf/libbpf.c

12650

static int collect_func_ids_by_glob(const struct bpf_program *prog, const char *pattern, __u32 **ids)

tools/lib/bpf/libbpf.c

12652

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

12674

if (prog->attach_btf_obj_fd) {

tools/lib/bpf/libbpf.c

12689

bpf_program__attach_tracing_multi(const struct bpf_program *prog, const char *pattern,

tools/lib/bpf/libbpf.c

12702

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

12705

prog->name);

tools/lib/bpf/libbpf.c

12721

cnt = collect_func_ids_by_glob(prog, pattern, &free_ids);

tools/lib/bpf/libbpf.c

12740

link_fd = bpf_link_create(prog_fd, 0, prog->expected_attach_type, &lopts);

tools/lib/bpf/libbpf.c

12743

pr_warn("prog '%s': failed to attach: %s\n", prog->name, errstr(err));

tools/lib/bpf/libbpf.c

12756

static int attach_tracing_multi(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

12776

if (!str_has_pfx(prog->sec_name, prefixes[i]))

tools/lib/bpf/libbpf.c

12781

if (prog->sec_name[pfx_len] == '\0')

tools/lib/bpf/libbpf.c

12784

if (prog->sec_name[pfx_len] != '/')

tools/lib/bpf/libbpf.c

12787

spec = prog->sec_name + pfx_len + 1;

tools/lib/bpf/libbpf.c

12793

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

12803

*link = bpf_program__attach_tracing_multi(prog, pattern, NULL);

tools/lib/bpf/libbpf.c

1281

prog = *(void **)mdata;

tools/lib/bpf/libbpf.c

1286

if (st_ops->progs[i] && st_ops->progs[i] != prog)

tools/lib/bpf/libbpf.c

1290

st_ops->progs[i] = prog;

tools/lib/bpf/libbpf.c

1291

if (!prog)

tools/lib/bpf/libbpf.c

1294

if (!is_valid_st_ops_program(obj, prog)) {

tools/lib/bpf/libbpf.c

13017

bpf_program__attach_uprobe_multi(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13038

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13041

prog->name);

tools/lib/bpf/libbpf.c

13088

prog->name, path, errstr(err));

tools/lib/bpf/libbpf.c

13131

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

13145

bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,

tools/lib/bpf/libbpf.c

1315

prog->attach_btf_obj_fd = mod_btf->fd;

tools/lib/bpf/libbpf.c

13183

prog->name, binary_path, errstr(err));

tools/lib/bpf/libbpf.c

1320

if (!prog->attach_btf_id) {

tools/lib/bpf/libbpf.c

1321

prog->attach_btf_id = kern_type_id;

tools/lib/bpf/libbpf.c

13216

if (legacy || !kernel_supports(prog->obj, FEAT_PERF_LINK))

tools/lib/bpf/libbpf.c

1322

prog->expected_attach_type = kern_member_idx;

tools/lib/bpf/libbpf.c

13248

prog->name, retprobe ? "uretprobe" : "uprobe",

tools/lib/bpf/libbpf.c

13254

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

13259

prog->name, retprobe ? "uretprobe" : "uprobe",

tools/lib/bpf/libbpf.c

13291

static int attach_uprobe(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

1330

if (prog->attach_btf_id != kern_type_id) {

tools/lib/bpf/libbpf.c

13300

n = sscanf(prog->sec_name, "%m[^/]/%m[^:]:%m[^\n]",

tools/lib/bpf/libbpf.c

13309

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

1332

map->name, mname, prog->name, prog->sec_name, prog->type,

tools/lib/bpf/libbpf.c

13327

prog->name);

tools/lib/bpf/libbpf.c

1333

prog->attach_btf_id, kern_type_id);

tools/lib/bpf/libbpf.c

13331

*link = bpf_program__attach_uprobe_opts(prog, -1, binary_path, offset, &opts);

tools/lib/bpf/libbpf.c

13335

pr_warn("prog '%s': invalid format of section definition '%s'\n", prog->name,

tools/lib/bpf/libbpf.c

13336

prog->sec_name);

tools/lib/bpf/libbpf.c

13346

struct bpf_link *bpf_program__attach_uprobe(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13353

return bpf_program__attach_uprobe_opts(prog, pid, binary_path, func_offset, &opts);

tools/lib/bpf/libbpf.c

13356

struct bpf_link *bpf_program__attach_usdt(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

1336

if (prog->expected_attach_type != kern_member_idx) {

tools/lib/bpf/libbpf.c

13362

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

13370

if (bpf_program__fd(prog) < 0) {

tools/lib/bpf/libbpf.c

13372

prog->name);

tools/lib/bpf/libbpf.c

1338

map->name, mname, prog->name, prog->sec_name, prog->type,

tools/lib/bpf/libbpf.c

13383

prog->name, binary_path, errstr(err));

tools/lib/bpf/libbpf.c

1339

prog->expected_attach_type, kern_member_idx);

tools/lib/bpf/libbpf.c

13401

link = usdt_manager_attach_usdt(obj->usdt_man, prog, pid, binary_path,

tools/lib/bpf/libbpf.c

13409

static int attach_usdt(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13415

sec_name = bpf_program__section_name(prog);

tools/lib/bpf/libbpf.c

13428

*link = bpf_program__attach_usdt(prog, -1 /* any process */, path,

tools/lib/bpf/libbpf.c

1346

map->name, mname, prog->name, moff,

tools/lib/bpf/libbpf.c

13488

struct bpf_link *bpf_program__attach_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13505

prog->name, tp_category, tp_name,

tools/lib/bpf/libbpf.c

13509

link = bpf_program__attach_perf_event_opts(prog, pfd, &pe_opts);

tools/lib/bpf/libbpf.c

13514

prog->name, tp_category, tp_name,

tools/lib/bpf/libbpf.c

13521

struct bpf_link *bpf_program__attach_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13525

return bpf_program__attach_tracepoint_opts(prog, tp_category, tp_name, NULL);

tools/lib/bpf/libbpf.c

13557

static int attach_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13570

match = sec_name_match_prefix(prog->sec_name, prefixes, ARRAY_SIZE(prefixes));

tools/lib/bpf/libbpf.c

13572

pr_warn("prog '%s': invalid section name '%s'\n", prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

13578

sec_name = strdup(prog->sec_name);

tools/lib/bpf/libbpf.c

13582

tp_cat = sec_name + (match - prog->sec_name);

tools/lib/bpf/libbpf.c

13591

*link = bpf_program__attach_tracepoint(prog, tp_cat, tp_name);

tools/lib/bpf/libbpf.c

13597

bpf_program__attach_raw_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13608

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13610

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13626

prog->name, tp_name, errstr(pfd));

tools/lib/bpf/libbpf.c

13633

struct bpf_link *bpf_program__attach_raw_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13636

return bpf_program__attach_raw_tracepoint_opts(prog, tp_name, NULL);

tools/lib/bpf/libbpf.c

13639

static int attach_raw_tp(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13653

match = sec_name_match_prefix(prog->sec_name, prefixes, ARRAY_SIZE(prefixes));

tools/lib/bpf/libbpf.c

13655

pr_warn("prog '%s': invalid section name '%s'\n", prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

13661

*link = bpf_program__attach_raw_tracepoint(prog, match);

tools/lib/bpf/libbpf.c

13666

static struct bpf_link *bpf_program__attach_btf_id(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13676

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13678

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13689

pfd = bpf_link_create(prog_fd, 0, bpf_program__expected_attach_type(prog), &link_opts);

tools/lib/bpf/libbpf.c

13694

prog->name, errstr(pfd));

tools/lib/bpf/libbpf.c

13701

struct bpf_link *bpf_program__attach_trace(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

13703

return bpf_program__attach_btf_id(prog, NULL);

tools/lib/bpf/libbpf.c

13706

struct bpf_link *bpf_program__attach_trace_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13709

return bpf_program__attach_btf_id(prog, opts);

tools/lib/bpf/libbpf.c

13712

struct bpf_link *bpf_program__attach_lsm(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

13714

return bpf_program__attach_btf_id(prog, NULL);

tools/lib/bpf/libbpf.c

13717

static int attach_trace(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13719

*link = bpf_program__attach_trace(prog);

tools/lib/bpf/libbpf.c

13723

static int attach_lsm(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13725

*link = bpf_program__attach_lsm(prog);

tools/lib/bpf/libbpf.c

13730

bpf_program_attach_fd(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13738

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13740

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13749

attach_type = bpf_program__expected_attach_type(prog);

tools/lib/bpf/libbpf.c

13755

prog->name, target_name,

tools/lib/bpf/libbpf.c

13764

bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd)

tools/lib/bpf/libbpf.c

13766

return bpf_program_attach_fd(prog, cgroup_fd, "cgroup", NULL);

tools/lib/bpf/libbpf.c

13770

bpf_program__attach_netns(const struct bpf_program *prog, int netns_fd)

tools/lib/bpf/libbpf.c

13772

return bpf_program_attach_fd(prog, netns_fd, "netns", NULL);

tools/lib/bpf/libbpf.c

13776

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd)

tools/lib/bpf/libbpf.c

13778

return bpf_program_attach_fd(prog, map_fd, "sockmap", NULL);

tools/lib/bpf/libbpf.c

13781

struct bpf_link *bpf_program__attach_xdp(const struct bpf_program *prog, int ifindex)

tools/lib/bpf/libbpf.c

13784

return bpf_program_attach_fd(prog, ifindex, "xdp", NULL);

tools/lib/bpf/libbpf.c

13788

bpf_program__attach_cgroup_opts(const struct bpf_program *prog, int cgroup_fd,

tools/lib/bpf/libbpf.c

13803

prog->name);

tools/lib/bpf/libbpf.c

13812

return bpf_program_attach_fd(prog, cgroup_fd, "cgroup", &link_create_opts);

tools/lib/bpf/libbpf.c

13816

bpf_program__attach_tcx(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.c

13832

prog->name);

tools/lib/bpf/libbpf.c

13837

prog->name);

tools/lib/bpf/libbpf.c

13847

return bpf_program_attach_fd(prog, ifindex, "tcx", &link_create_opts);

tools/lib/bpf/libbpf.c

13851

bpf_program__attach_netkit(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.c

13867

prog->name);

tools/lib/bpf/libbpf.c

13872

prog->name);

tools/lib/bpf/libbpf.c

13881

return bpf_program_attach_fd(prog, ifindex, "netkit", &link_create_opts);

tools/lib/bpf/libbpf.c

13884

struct bpf_link *bpf_program__attach_freplace(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13892

prog->name);

tools/lib/bpf/libbpf.c

13896

if (prog->type != BPF_PROG_TYPE_EXT) {

tools/lib/bpf/libbpf.c

13898

prog->name);

tools/lib/bpf/libbpf.c

13905

btf_id = libbpf_find_prog_btf_id(attach_func_name, target_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

13911

return bpf_program_attach_fd(prog, target_fd, "freplace",

tools/lib/bpf/libbpf.c

13917

return bpf_program__attach_trace(prog);

tools/lib/bpf/libbpf.c

13922

bpf_program__attach_iter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13936

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13938

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13953

prog->name, errstr(link_fd));

tools/lib/bpf/libbpf.c

13960

static int attach_iter(const struct bpf_program *prog, long cookie, struct bpf_link **link)

tools/lib/bpf/libbpf.c

13962

*link = bpf_program__attach_iter(prog, NULL);

tools/lib/bpf/libbpf.c

13966

struct bpf_link *bpf_program__attach_netfilter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

13976

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

13978

pr_warn("prog '%s': can't attach before loaded\n", prog->name);

tools/lib/bpf/libbpf.c

13998

prog->name, errstr(link_fd));

tools/lib/bpf/libbpf.c

14006

struct bpf_link *bpf_program__attach(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

14011

if (!prog->sec_def || !prog->sec_def->prog_attach_fn)

tools/lib/bpf/libbpf.c

14014

if (bpf_program__fd(prog) < 0) {

tools/lib/bpf/libbpf.c

14016

prog->name);

tools/lib/bpf/libbpf.c

14020

err = prog->sec_def->prog_attach_fn(prog, prog->sec_def->cookie, &link);

tools/lib/bpf/libbpf.c

14703

int bpf_program__set_attach_target(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

14709

if (!prog || attach_prog_fd < 0)

tools/lib/bpf/libbpf.c

14712

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

14719

prog->attach_prog_fd = attach_prog_fd;

tools/lib/bpf/libbpf.c

14725

attach_prog_fd, prog->obj->token_fd);

tools/lib/bpf/libbpf.c

14733

err = bpf_object__load_vmlinux_btf(prog->obj, true);

tools/lib/bpf/libbpf.c

14736

err = find_kernel_btf_id(prog->obj, attach_func_name,

tools/lib/bpf/libbpf.c

14737

prog->expected_attach_type,

tools/lib/bpf/libbpf.c

14743

prog->attach_btf_id = btf_id;

tools/lib/bpf/libbpf.c

14744

prog->attach_btf_obj_fd = btf_obj_fd;

tools/lib/bpf/libbpf.c

14745

prog->attach_prog_fd = attach_prog_fd;

tools/lib/bpf/libbpf.c

14749

int bpf_program__assoc_struct_ops(struct bpf_program *prog, struct bpf_map *map,

tools/lib/bpf/libbpf.c

14754

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

14757

prog->name);

tools/lib/bpf/libbpf.c

14761

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS) {

tools/lib/bpf/libbpf.c

14762

pr_warn("prog '%s': can't associate struct_ops program\n", prog->name);

tools/lib/bpf/libbpf.c

14916

struct bpf_program **prog = prog_skel->prog;

tools/lib/bpf/libbpf.c

14919

*prog = bpf_object__find_program_by_name(obj, name);

tools/lib/bpf/libbpf.c

14920

if (!*prog) {

tools/lib/bpf/libbpf.c

15060

struct bpf_program *prog = *prog_skel->prog;

tools/lib/bpf/libbpf.c

15063

if (!prog->autoload || !prog->autoattach)

tools/lib/bpf/libbpf.c

15067

if (!prog->sec_def || !prog->sec_def->prog_attach_fn)

tools/lib/bpf/libbpf.c

15074

err = prog->sec_def->prog_attach_fn(prog, prog->sec_def->cookie, link);

tools/lib/bpf/libbpf.c

15077

bpf_program__name(prog), errstr(err));

tools/lib/bpf/libbpf.c

3537

static bool prog_needs_vmlinux_btf(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

3539

if (prog->type == BPF_PROG_TYPE_STRUCT_OPS ||

tools/lib/bpf/libbpf.c

3540

prog->type == BPF_PROG_TYPE_LSM)

tools/lib/bpf/libbpf.c

3546

if (prog->type == BPF_PROG_TYPE_TRACING && !prog->attach_prog_fd)

tools/lib/bpf/libbpf.c

3559

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

3578

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

3579

if (!prog->autoload)

tools/lib/bpf/libbpf.c

3581

if (prog_needs_vmlinux_btf(prog))

tools/lib/bpf/libbpf.c

3641

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

tools/lib/bpf/libbpf.c

3646

if (!prog->mark_btf_static || !prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

3656

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

tools/lib/bpf/libbpf.c

4520

static bool prog_is_subprog(const struct bpf_object *obj, const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

4522

return prog->sec_idx == obj->efile.text_shndx;

tools/lib/bpf/libbpf.c

4529

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4531

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

4532

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

4534

if (!strcmp(prog->name, name))

tools/lib/bpf/libbpf.c

4535

return prog;

tools/lib/bpf/libbpf.c

4577

static int bpf_prog_compute_hash(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

4582

purged = calloc(prog->insns_cnt, BPF_INSN_SZ);

tools/lib/bpf/libbpf.c

4589

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

tools/lib/bpf/libbpf.c

4590

purged[i] = prog->insns[i];

tools/lib/bpf/libbpf.c

4596

if (i >= prog->insns_cnt ||

tools/lib/bpf/libbpf.c

4597

prog->insns[i].code != 0 ||

tools/lib/bpf/libbpf.c

4598

prog->insns[i].dst_reg != 0 ||

tools/lib/bpf/libbpf.c

4599

prog->insns[i].src_reg != 0 ||

tools/lib/bpf/libbpf.c

4600

prog->insns[i].off != 0) {

tools/lib/bpf/libbpf.c

4604

purged[i] = prog->insns[i];

tools/lib/bpf/libbpf.c

4608

libbpf_sha256(purged, prog->insns_cnt * sizeof(struct bpf_insn),

tools/lib/bpf/libbpf.c

4609

prog->hash);

tools/lib/bpf/libbpf.c

4615

static int bpf_program__record_reloc(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

4620

struct bpf_insn *insn = &prog->insns[insn_idx];

tools/lib/bpf/libbpf.c

4621

size_t map_idx, nr_maps = prog->obj->nr_maps;

tools/lib/bpf/libbpf.c

4622

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

4630

prog->name, sym_name, insn_idx, insn->code);

tools/lib/bpf/libbpf.c

4646

prog->name, sym_name, sym_idx);

tools/lib/bpf/libbpf.c

4650

prog->name, i, ext->name, ext->sym_idx, insn_idx);

tools/lib/bpf/libbpf.c

4663

pr_warn("prog '%s': incorrect bpf_call opcode\n", prog->name);

tools/lib/bpf/libbpf.c

4670

prog->name, sym_name, sym_sec_name);

tools/lib/bpf/libbpf.c

4675

prog->name, sym_name, (size_t)sym->st_value);

tools/lib/bpf/libbpf.c

4686

prog->name, sym_name, shdr_idx);

tools/lib/bpf/libbpf.c

4697

prog->name, sym_name, (size_t)sym->st_value, insn->imm);

tools/lib/bpf/libbpf.c

4714

prog->name, insn_idx);

tools/lib/bpf/libbpf.c

4724

prog->name, obj->arena_map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4743

prog->name, sym_name, sym_sec_name);

tools/lib/bpf/libbpf.c

4753

prog->name, map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4759

prog->name, sym_sec_name, (size_t)sym->st_value);

tools/lib/bpf/libbpf.c

4772

prog->name, sym_sec_name);

tools/lib/bpf/libbpf.c

4780

prog->name, map_idx, map->name, map->sec_idx,

tools/lib/bpf/libbpf.c

4786

prog->name, sym_sec_name);

tools/lib/bpf/libbpf.c

4797

static bool prog_contains_insn(const struct bpf_program *prog, size_t insn_idx)

tools/lib/bpf/libbpf.c

4799

return insn_idx >= prog->sec_insn_off &&

tools/lib/bpf/libbpf.c

4800

insn_idx < prog->sec_insn_off + prog->sec_insn_cnt;

tools/lib/bpf/libbpf.c

4807

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4814

prog = &obj->programs[m];

tools/lib/bpf/libbpf.c

4816

if (prog->sec_idx < sec_idx ||

tools/lib/bpf/libbpf.c

4817

(prog->sec_idx == sec_idx && prog->sec_insn_off <= insn_idx))

tools/lib/bpf/libbpf.c

4825

prog = &obj->programs[l];

tools/lib/bpf/libbpf.c

4826

if (prog->sec_idx == sec_idx && prog_contains_insn(prog, insn_idx))

tools/lib/bpf/libbpf.c

4827

return prog;

tools/lib/bpf/libbpf.c

4836

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

4906

prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);

tools/lib/bpf/libbpf.c

4907

if (!prog) {

tools/lib/bpf/libbpf.c

4913

relos = libbpf_reallocarray(prog->reloc_desc,

tools/lib/bpf/libbpf.c

4914

prog->nr_reloc + 1, sizeof(*relos));

tools/lib/bpf/libbpf.c

4917

prog->reloc_desc = relos;

tools/lib/bpf/libbpf.c

4920

insn_idx -= prog->sec_insn_off;

tools/lib/bpf/libbpf.c

4921

err = bpf_program__record_reloc(prog, &relos[prog->nr_reloc],

tools/lib/bpf/libbpf.c

4926

prog->nr_reloc++;

tools/lib/bpf/libbpf.c

6009

static int record_relo_core(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

6014

relos = libbpf_reallocarray(prog->reloc_desc,

tools/lib/bpf/libbpf.c

6015

prog->nr_reloc + 1, sizeof(*relos));

tools/lib/bpf/libbpf.c

6018

relo = &relos[prog->nr_reloc];

tools/lib/bpf/libbpf.c

6022

prog->reloc_desc = relos;

tools/lib/bpf/libbpf.c

6023

prog->nr_reloc++;

tools/lib/bpf/libbpf.c

6027

static const struct bpf_core_relo *find_relo_core(struct bpf_program *prog, int insn_idx)

tools/lib/bpf/libbpf.c

6032

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

tools/lib/bpf/libbpf.c

6033

relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

6043

static int bpf_core_resolve_relo(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

6052

const char *prog_name = prog->name;

tools/lib/bpf/libbpf.c

6068

cands = bpf_core_find_cands(prog->obj, local_btf, local_id);

tools/lib/bpf/libbpf.c

6095

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

6136

prog = find_prog_by_sec_insn(obj, sec_idx, insn_idx);

tools/lib/bpf/libbpf.c

6137

if (!prog) {

tools/lib/bpf/libbpf.c

6153

if (!prog->autoload)

tools/lib/bpf/libbpf.c

6160

insn_idx = insn_idx - prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6161

if (insn_idx >= prog->insns_cnt)

tools/lib/bpf/libbpf.c

6163

insn = &prog->insns[insn_idx];

tools/lib/bpf/libbpf.c

6165

err = record_relo_core(prog, rec, insn_idx);

tools/lib/bpf/libbpf.c

6168

prog->name, i, errstr(err));

tools/lib/bpf/libbpf.c

6172

if (prog->obj->gen_loader)

tools/lib/bpf/libbpf.c

6175

err = bpf_core_resolve_relo(prog, rec, i, obj->btf, cand_cache, &targ_res);

tools/lib/bpf/libbpf.c

6178

prog->name, i, errstr(err));

tools/lib/bpf/libbpf.c

6182

err = bpf_core_patch_insn(prog->name, insn, insn_idx, rec, i, &targ_res);

tools/lib/bpf/libbpf.c

6185

prog->name, i, insn_idx, errstr(err));

tools/lib/bpf/libbpf.c

6209

static void poison_map_ldimm64(struct bpf_program *prog, int relo_idx,

tools/lib/bpf/libbpf.c

6216

prog->name, relo_idx, insn_idx, map_idx, map->name);

tools/lib/bpf/libbpf.c

6239

static void poison_kfunc_call(struct bpf_program *prog, int relo_idx,

tools/lib/bpf/libbpf.c

6244

prog->name, relo_idx, insn_idx, ext->name);

tools/lib/bpf/libbpf.c

6259

static int find_jt_map(struct bpf_object *obj, struct bpf_program *prog, unsigned int sym_off)

tools/lib/bpf/libbpf.c

6270

obj->jumptable_maps[i].prog == prog)

tools/lib/bpf/libbpf.c

6277

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

6288

obj->jumptable_maps[cnt].prog = prog;

tools/lib/bpf/libbpf.c

6296

static int find_subprog_idx(struct bpf_program *prog, int insn_idx)

tools/lib/bpf/libbpf.c

6300

for (i = prog->subprog_cnt - 1; i >= 0; i--) {

tools/lib/bpf/libbpf.c

6301

if (insn_idx >= prog->subprogs[i].sub_insn_off)

tools/lib/bpf/libbpf.c

6308

static int create_jt_map(struct bpf_object *obj, struct bpf_program *prog, struct reloc_desc *relo)

tools/lib/bpf/libbpf.c

6322

map_fd = find_jt_map(obj, prog, sym_off);

tools/lib/bpf/libbpf.c

6356

if (relo->insn_idx < 0 || relo->insn_idx >= prog->insns_cnt) {

tools/lib/bpf/libbpf.c

6361

if (prog->subprogs)

tools/lib/bpf/libbpf.c

6362

subprog_idx = find_subprog_idx(prog, relo->insn_idx);

tools/lib/bpf/libbpf.c

6372

insn_off -= prog->subprogs[subprog_idx].sec_insn_off;

tools/lib/bpf/libbpf.c

6373

insn_off += prog->subprogs[subprog_idx].sub_insn_off;

tools/lib/bpf/libbpf.c

6375

insn_off -= prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6399

err = add_jt_map(obj, prog, sym_off, map_fd);

tools/lib/bpf/libbpf.c

6416

bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6420

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

tools/lib/bpf/libbpf.c

6421

struct reloc_desc *relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

6422

struct bpf_insn *insn = &prog->insns[relo->insn_idx];

tools/lib/bpf/libbpf.c

6436

poison_map_ldimm64(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6454

poison_map_ldimm64(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6487

poison_kfunc_call(prog, i, relo->insn_idx, insn,

tools/lib/bpf/libbpf.c

6494

prog->name, i);

tools/lib/bpf/libbpf.c

6508

map_fd = create_jt_map(obj, prog, relo);

tools/lib/bpf/libbpf.c

6511

prog->name, i, relo->sym_off);

tools/lib/bpf/libbpf.c

6521

prog->name, i, relo->type);

tools/lib/bpf/libbpf.c

6530

const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

6545

if (prog->sec_idx != sec_idx)

tools/lib/bpf/libbpf.c

6551

if (insn_off < prog->sec_insn_off)

tools/lib/bpf/libbpf.c

6553

if (insn_off >= prog->sec_insn_off + prog->sec_insn_cnt)

tools/lib/bpf/libbpf.c

6582

off_adj = prog->sub_insn_off - prog->sec_insn_off;

tools/lib/bpf/libbpf.c

6600

const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6613

if (main_prog != prog && !main_prog->func_info)

tools/lib/bpf/libbpf.c

6616

err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->func_info,

tools/lib/bpf/libbpf.c

6623

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

6631

pr_warn("prog '%s': missing .BTF.ext function info.\n", prog->name);

tools/lib/bpf/libbpf.c

6636

prog->name);

tools/lib/bpf/libbpf.c

6641

if (main_prog != prog && !main_prog->line_info)

tools/lib/bpf/libbpf.c

6644

err = adjust_prog_btf_ext_info(obj, prog, &obj->btf_ext->line_info,

tools/lib/bpf/libbpf.c

6651

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

6659

pr_warn("prog '%s': missing .BTF.ext line info.\n", prog->name);

tools/lib/bpf/libbpf.c

6664

prog->name);

tools/lib/bpf/libbpf.c

6679

static struct reloc_desc *find_prog_insn_relo(const struct bpf_program *prog, size_t insn_idx)

tools/lib/bpf/libbpf.c

6681

if (!prog->nr_reloc)

tools/lib/bpf/libbpf.c

6683

return bsearch(&insn_idx, prog->reloc_desc, prog->nr_reloc,

tools/lib/bpf/libbpf.c

6684

sizeof(*prog->reloc_desc), cmp_relo_by_insn_idx);

tools/lib/bpf/libbpf.c

6776

struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6784

err = reloc_prog_func_and_line_info(obj, main_prog, prog);

tools/lib/bpf/libbpf.c

6788

for (insn_idx = 0; insn_idx < prog->sec_insn_cnt; insn_idx++) {

tools/lib/bpf/libbpf.c

6789

insn = &main_prog->insns[prog->sub_insn_off + insn_idx];

tools/lib/bpf/libbpf.c

6793

relo = find_prog_insn_relo(prog, insn_idx);

tools/lib/bpf/libbpf.c

6801

prog->name, insn_idx, relo->type);

tools/lib/bpf/libbpf.c

6825

prog->name, insn_idx);

tools/lib/bpf/libbpf.c

6834

sub_insn_idx = prog->sec_insn_off + insn_idx + insn->imm + 1;

tools/lib/bpf/libbpf.c

6841

prog->name);

tools/lib/bpf/libbpf.c

6867

insn = &main_prog->insns[prog->sub_insn_off + insn_idx];

tools/lib/bpf/libbpf.c

6874

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

tools/lib/bpf/libbpf.c

6877

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

tools/lib/bpf/libbpf.c

6965

bpf_object__relocate_calls(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

6981

err = bpf_object__reloc_code(obj, prog, prog);

tools/lib/bpf/libbpf.c

6991

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

6996

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

6997

zfree(&prog->reloc_desc);

tools/lib/bpf/libbpf.c

6998

prog->nr_reloc = 0;

tools/lib/bpf/libbpf.c

7031

static int bpf_prog_assign_exc_cb(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7056

prog->name);

tools/lib/bpf/libbpf.c

7059

if (strcmp(prog->name, btf__str_by_offset(obj->btf, t->name_off)) != 0)

tools/lib/bpf/libbpf.c

7065

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7066

prog->exception_cb_idx = -1;

tools/lib/bpf/libbpf.c

7073

prog->name);

tools/lib/bpf/libbpf.c

7090

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7094

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7096

prog->name, subprog->name);

tools/lib/bpf/libbpf.c

7099

prog->exception_cb_idx = j;

tools/lib/bpf/libbpf.c

7103

if (prog->exception_cb_idx >= 0)

tools/lib/bpf/libbpf.c

7106

pr_warn("prog '%s': cannot find exception callback '%s'\n", prog->name, name);

tools/lib/bpf/libbpf.c

7153

static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7172

(prog->type == BPF_PROG_TYPE_KPROBE || prog->type == BPF_PROG_TYPE_PERF_EVENT)) {

tools/lib/bpf/libbpf.c

7191

switch (prog->type) {

tools/lib/bpf/libbpf.c

7220

prog->name, subprog_name, arg_idx, ctx_name);

tools/lib/bpf/libbpf.c

7224

static int clone_func_btf_info(struct btf *btf, int orig_fn_id, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7276

fn_id = btf__add_func(btf, prog->name, linkage, fn_proto_id);

tools/lib/bpf/libbpf.c

7293

static int bpf_program_fixup_func_info(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7306

if (!obj->btf_ext || !prog->func_info)

tools/lib/bpf/libbpf.c

7317

if (global_ctx_map[i].prog_type != prog->type)

tools/lib/bpf/libbpf.c

7326

orig_ids = calloc(prog->func_info_cnt, sizeof(*orig_ids));

tools/lib/bpf/libbpf.c

7329

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

tools/lib/bpf/libbpf.c

7330

func_rec = prog->func_info + prog->func_info_rec_size * i;

tools/lib/bpf/libbpf.c

7359

for (rec_idx = 0; rec_idx < prog->func_info_cnt; rec_idx++) {

tools/lib/bpf/libbpf.c

7361

func_rec = prog->func_info + prog->func_info_rec_size * rec_idx;

tools/lib/bpf/libbpf.c

7378

if (!need_func_arg_type_fixup(btf, prog, fn_name, arg_idx, p->type, ctx_name))

tools/lib/bpf/libbpf.c

7385

fn_id = clone_func_btf_info(btf, orig_fn_id, prog);

tools/lib/bpf/libbpf.c

7434

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

7464

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7465

for (j = 0; j < prog->nr_reloc; j++) {

tools/lib/bpf/libbpf.c

7466

struct reloc_desc *relo = &prog->reloc_desc[j];

tools/lib/bpf/libbpf.c

7467

struct bpf_insn *insn = &prog->insns[relo->insn_idx];

tools/lib/bpf/libbpf.c

7483

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7487

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

7489

if (!prog->autoload)

tools/lib/bpf/libbpf.c

7492

err = bpf_object__relocate_calls(obj, prog);

tools/lib/bpf/libbpf.c

7495

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7499

err = bpf_prog_assign_exc_cb(obj, prog);

tools/lib/bpf/libbpf.c

7503

if (prog->exception_cb_idx >= 0) {

tools/lib/bpf/libbpf.c

7504

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

tools/lib/bpf/libbpf.c

7512

err = bpf_object__append_subprog_code(obj, prog, subprog);

tools/lib/bpf/libbpf.c

7515

err = bpf_object__reloc_code(obj, prog, subprog);

tools/lib/bpf/libbpf.c

7522

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

7523

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

7525

if (!prog->autoload)

tools/lib/bpf/libbpf.c

7529

err = bpf_object__relocate_data(obj, prog);

tools/lib/bpf/libbpf.c

7532

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7537

err = bpf_program_fixup_func_info(obj, prog);

tools/lib/bpf/libbpf.c

7540

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

772

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

7737

static int bpf_object__sanitize_prog(struct bpf_object *obj, struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7739

struct bpf_insn *insn = prog->insns;

tools/lib/bpf/libbpf.c

7746

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

tools/lib/bpf/libbpf.c

7772

static int libbpf_find_attach_btf_id(struct bpf_program *prog, const char *attach_name,

tools/lib/bpf/libbpf.c

7812

static int tracing_multi_mod_fd(struct bpf_program *prog, int *btf_obj_fd)

tools/lib/bpf/libbpf.c

7818

attach_name = strchr(prog->sec_name, '/');

tools/lib/bpf/libbpf.c

7830

mod = find_attach_module(prog->obj, attach_name);

tools/lib/bpf/libbpf.c

7839

static int libbpf_prepare_prog_load(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7845

if ((def & SEC_EXP_ATTACH_OPT) && !kernel_supports(prog->obj, FEAT_EXP_ATTACH_TYPE))

tools/lib/bpf/libbpf.c

7851

if (prog->type == BPF_PROG_TYPE_XDP && (def & SEC_XDP_FRAGS))

tools/lib/bpf/libbpf.c

7855

if ((def & SEC_USDT) && kernel_supports(prog->obj, FEAT_UPROBE_MULTI_LINK)) {

tools/lib/bpf/libbpf.c

7860

prog->expected_attach_type = BPF_TRACE_UPROBE_MULTI;

tools/lib/bpf/libbpf.c

7864

if ((def & SEC_ATTACH_BTF) && !prog->attach_btf_id) {

tools/lib/bpf/libbpf.c

7868

attach_name = strchr(prog->sec_name, '/');

tools/lib/bpf/libbpf.c

7880

prog->name);

tools/lib/bpf/libbpf.c

7885

err = libbpf_find_attach_btf_id(prog, attach_name, &btf_obj_fd, &btf_type_id);

tools/lib/bpf/libbpf.c

7890

prog->attach_btf_obj_fd = btf_obj_fd;

tools/lib/bpf/libbpf.c

7891

prog->attach_btf_id = btf_type_id;

tools/lib/bpf/libbpf.c

7902

if (is_tracing_multi(prog->expected_attach_type)) {

tools/lib/bpf/libbpf.c

7905

err = tracing_multi_mod_fd(prog, &btf_obj_fd);

tools/lib/bpf/libbpf.c

7909

prog->attach_btf_obj_fd = btf_obj_fd;

tools/lib/bpf/libbpf.c

7916

static void fixup_verifier_log(struct bpf_program *prog, char *buf, size_t buf_sz);

tools/lib/bpf/libbpf.c

7918

static int bpf_object_load_prog(struct bpf_object *obj, struct bpf_program *prog,

tools/lib/bpf/libbpf.c

7927

__u32 log_level = prog->log_level;

tools/lib/bpf/libbpf.c

7933

switch (prog->type) {

tools/lib/bpf/libbpf.c

7940

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

7943

if (prog->attach_btf_id == 0) {

tools/lib/bpf/libbpf.c

7945

prog->name);

tools/lib/bpf/libbpf.c

795

void bpf_program__unload(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

7957

prog_name = prog->name;

tools/lib/bpf/libbpf.c

7958

load_attr.attach_prog_fd = prog->attach_prog_fd;

tools/lib/bpf/libbpf.c

7959

load_attr.attach_btf_obj_fd = prog->attach_btf_obj_fd;

tools/lib/bpf/libbpf.c

7960

load_attr.attach_btf_id = prog->attach_btf_id;

tools/lib/bpf/libbpf.c

7962

load_attr.prog_ifindex = prog->prog_ifindex;

tools/lib/bpf/libbpf.c

7963

load_attr.expected_attach_type = prog->expected_attach_type;

tools/lib/bpf/libbpf.c

7968

load_attr.func_info = prog->func_info;

tools/lib/bpf/libbpf.c

7969

load_attr.func_info_rec_size = prog->func_info_rec_size;

tools/lib/bpf/libbpf.c

797

if (!prog)

tools/lib/bpf/libbpf.c

7970

load_attr.func_info_cnt = prog->func_info_cnt;

tools/lib/bpf/libbpf.c

7971

load_attr.line_info = prog->line_info;

tools/lib/bpf/libbpf.c

7972

load_attr.line_info_rec_size = prog->line_info_rec_size;

tools/lib/bpf/libbpf.c

7973

load_attr.line_info_cnt = prog->line_info_cnt;

tools/lib/bpf/libbpf.c

7976

load_attr.prog_flags = prog->prog_flags;

tools/lib/bpf/libbpf.c

7984

if (prog->sec_def && prog->sec_def->prog_prepare_load_fn) {

tools/lib/bpf/libbpf.c

7985

err = prog->sec_def->prog_prepare_load_fn(prog, &load_attr, prog->sec_def->cookie);

tools/lib/bpf/libbpf.c

7988

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

7991

insns = prog->insns;

tools/lib/bpf/libbpf.c

7992

insns_cnt = prog->insns_cnt;

tools/lib/bpf/libbpf.c

7996

bpf_gen__prog_load(obj->gen_loader, prog->type, prog->name,

tools/lib/bpf/libbpf.c

7998

prog - obj->programs);

tools/lib/bpf/libbpf.c

800

zclose(prog->fd);

tools/lib/bpf/libbpf.c

8010

if (prog->log_buf) {

tools/lib/bpf/libbpf.c

8011

log_buf = prog->log_buf;

tools/lib/bpf/libbpf.c

8012

log_buf_size = prog->log_size;

tools/lib/bpf/libbpf.c

802

zfree(&prog->func_info);

tools/lib/bpf/libbpf.c

803

zfree(&prog->line_info);

tools/lib/bpf/libbpf.c

8035

ret = bpf_prog_load(prog->type, prog_name, license, insns, insns_cnt, &load_attr);

tools/lib/bpf/libbpf.c

8039

prog->name, log_buf);

tools/lib/bpf/libbpf.c

804

zfree(&prog->subprogs);

tools/lib/bpf/libbpf.c

8047

map = &prog->obj->maps[i];

tools/lib/bpf/libbpf.c

8053

prog->name, map->real_name, errstr(errno));

tools/lib/bpf/libbpf.c

807

static void bpf_program__exit(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

8081

fixup_verifier_log(prog, log_buf, log_buf_size);

tools/lib/bpf/libbpf.c

8083

pr_warn("prog '%s': BPF program load failed: %s\n", prog->name, errstr(errno));

tools/lib/bpf/libbpf.c

8088

prog->name, log_buf);

tools/lib/bpf/libbpf.c

809

if (!prog)

tools/lib/bpf/libbpf.c

812

bpf_program__unload(prog);

tools/lib/bpf/libbpf.c

813

zfree(&prog->name);

tools/lib/bpf/libbpf.c

814

zfree(&prog->sec_name);

tools/lib/bpf/libbpf.c

8148

static void fixup_log_failed_core_relo(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

815

zfree(&prog->insns);

tools/lib/bpf/libbpf.c

816

zfree(&prog->reloc_desc);

tools/lib/bpf/libbpf.c

8170

relo = find_relo_core(prog, insn_idx);

tools/lib/bpf/libbpf.c

8174

err = bpf_core_parse_spec(prog->name, prog->obj->btf, relo, &spec);

tools/lib/bpf/libbpf.c

818

prog->nr_reloc = 0;

tools/lib/bpf/libbpf.c

8187

static void fixup_log_missing_map_load(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

819

prog->insns_cnt = 0;

tools/lib/bpf/libbpf.c

8199

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

820

prog->sec_idx = -1;

tools/lib/bpf/libbpf.c

8220

static void fixup_log_missing_kfunc_call(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

8232

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

8253

static void fixup_verifier_log(struct bpf_program *prog, char *buf, size_t buf_sz)

tools/lib/bpf/libbpf.c

8278

fixup_log_failed_core_relo(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

8287

fixup_log_missing_map_load(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

8296

fixup_log_missing_kfunc_call(prog, buf, buf_sz, log_sz,

tools/lib/bpf/libbpf.c

8303

static int bpf_program_record_relos(struct bpf_program *prog)

tools/lib/bpf/libbpf.c

8305

struct bpf_object *obj = prog->obj;

tools/lib/bpf/libbpf.c

8308

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

tools/lib/bpf/libbpf.c

8309

struct reloc_desc *relo = &prog->reloc_desc[i];

tools/lib/bpf/libbpf.c

8349

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8354

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

8355

if (prog_is_subprog(obj, prog))

tools/lib/bpf/libbpf.c

8357

if (!prog->autoload) {

tools/lib/bpf/libbpf.c

8358

pr_debug("prog '%s': skipped loading\n", prog->name);

tools/lib/bpf/libbpf.c

8361

prog->log_level |= log_level;

tools/lib/bpf/libbpf.c

8364

bpf_program_record_relos(prog);

tools/lib/bpf/libbpf.c

8366

err = bpf_object_load_prog(obj, prog, prog->insns, prog->insns_cnt,

tools/lib/bpf/libbpf.c

8367

obj->license, obj->kern_version, &prog->fd);

tools/lib/bpf/libbpf.c

8369

pr_warn("prog '%s': failed to load: %s\n", prog->name, errstr(err));

tools/lib/bpf/libbpf.c

8380

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8385

prog = &obj->programs[i];

tools/lib/bpf/libbpf.c

8386

err = bpf_object__sanitize_prog(obj, prog);

tools/lib/bpf/libbpf.c

8397

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

8400

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

8401

prog->sec_def = find_sec_def(prog->sec_name);

tools/lib/bpf/libbpf.c

8402

if (!prog->sec_def) {

tools/lib/bpf/libbpf.c

8405

prog->name, prog->sec_name);

tools/lib/bpf/libbpf.c

8409

prog->type = prog->sec_def->prog_type;

tools/lib/bpf/libbpf.c

8410

prog->expected_attach_type = prog->sec_def->expected_attach_type;

tools/lib/bpf/libbpf.c

8415

if (prog->sec_def->prog_setup_fn) {

tools/lib/bpf/libbpf.c

8416

err = prog->sec_def->prog_setup_fn(prog, prog->sec_def->cookie);

tools/lib/bpf/libbpf.c

8419

prog->name, errstr(err));

tools/lib/bpf/libbpf.c

844

bpf_object__init_prog(struct bpf_object *obj, struct bpf_program *prog,

tools/lib/bpf/libbpf.c

854

memset(prog, 0, sizeof(*prog));

tools/lib/bpf/libbpf.c

855

prog->obj = obj;

tools/lib/bpf/libbpf.c

857

prog->sec_idx = sec_idx;

tools/lib/bpf/libbpf.c

858

prog->sec_insn_off = sec_off / BPF_INSN_SZ;

tools/lib/bpf/libbpf.c

859

prog->sec_insn_cnt = insn_data_sz / BPF_INSN_SZ;

tools/lib/bpf/libbpf.c

861

prog->insns_cnt = prog->sec_insn_cnt;

tools/lib/bpf/libbpf.c

863

prog->type = BPF_PROG_TYPE_UNSPEC;

tools/lib/bpf/libbpf.c

864

prog->fd = -1;

tools/lib/bpf/libbpf.c

865

prog->exception_cb_idx = -1;

tools/lib/bpf/libbpf.c

872

prog->autoload = false;

tools/lib/bpf/libbpf.c

876

prog->autoload = true;

tools/lib/bpf/libbpf.c

879

prog->autoattach = true;

tools/lib/bpf/libbpf.c

882

prog->log_level = obj->log_level;

tools/lib/bpf/libbpf.c

884

prog->sec_name = strdup(sec_name);

tools/lib/bpf/libbpf.c

885

if (!prog->sec_name)

tools/lib/bpf/libbpf.c

888

prog->name = strdup(name);

tools/lib/bpf/libbpf.c

889

if (!prog->name)

tools/lib/bpf/libbpf.c

892

prog->insns = malloc(insn_data_sz);

tools/lib/bpf/libbpf.c

893

if (!prog->insns)

tools/lib/bpf/libbpf.c

895

memcpy(prog->insns, insn_data, insn_data_sz);

tools/lib/bpf/libbpf.c

8976

struct bpf_program *prog = st_ops->progs[i];

tools/lib/bpf/libbpf.c

8980

if (!prog)

tools/lib/bpf/libbpf.c

8983

prog_fd = bpf_program__fd(prog);

tools/lib/bpf/libbpf.c

900

bpf_program__exit(prog);

tools/lib/bpf/libbpf.c

909

struct bpf_program *prog, *progs;

tools/lib/bpf/libbpf.c

9190

int bpf_program__pin(struct bpf_program *prog, const char *path)

tools/lib/bpf/libbpf.c

9194

if (prog->fd < 0) {

tools/lib/bpf/libbpf.c

9195

pr_warn("prog '%s': can't pin program that wasn't loaded\n", prog->name);

tools/lib/bpf/libbpf.c

9207

if (bpf_obj_pin(prog->fd, path)) {

tools/lib/bpf/libbpf.c

9209

pr_warn("prog '%s': failed to pin at '%s': %s\n", prog->name, path, errstr(err));

tools/lib/bpf/libbpf.c

9213

pr_debug("prog '%s': pinned at '%s'\n", prog->name, path);

tools/lib/bpf/libbpf.c

9217

int bpf_program__unpin(struct bpf_program *prog, const char *path)

tools/lib/bpf/libbpf.c

9221

if (prog->fd < 0) {

tools/lib/bpf/libbpf.c

9222

pr_warn("prog '%s': can't unpin program that wasn't loaded\n", prog->name);

tools/lib/bpf/libbpf.c

9234

pr_debug("prog '%s': unpinned from '%s'\n", prog->name, path);

tools/lib/bpf/libbpf.c

9456

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

9468

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

9469

err = pathname_concat(buf, sizeof(buf), path, prog->name);

tools/lib/bpf/libbpf.c

9473

err = bpf_program__pin(prog, buf);

tools/lib/bpf/libbpf.c

9481

while ((prog = bpf_object__prev_program(obj, prog))) {

tools/lib/bpf/libbpf.c

9482

if (pathname_concat(buf, sizeof(buf), path, prog->name))

tools/lib/bpf/libbpf.c

9485

bpf_program__unpin(prog, buf);

tools/lib/bpf/libbpf.c

9493

struct bpf_program *prog;

tools/lib/bpf/libbpf.c

9499

bpf_object__for_each_program(prog, obj) {

tools/lib/bpf/libbpf.c

9502

err = pathname_concat(buf, sizeof(buf), path, prog->name);

tools/lib/bpf/libbpf.c

9506

err = bpf_program__unpin(prog, buf);

tools/lib/bpf/libbpf.c

965

prog = &progs[nr_progs];

tools/lib/bpf/libbpf.c

967

err = bpf_object__init_prog(obj, prog, name, sec_idx, sec_name,

tools/lib/bpf/libbpf.c

9720

struct bpf_program *prog = prev;

tools/lib/bpf/libbpf.c

9723

prog = __bpf_program__iter(prog, obj, true);

tools/lib/bpf/libbpf.c

9724

} while (prog && prog_is_subprog(obj, prog));

tools/lib/bpf/libbpf.c

9726

return prog;

tools/lib/bpf/libbpf.c

973

prog->sym_global = true;

tools/lib/bpf/libbpf.c

9732

struct bpf_program *prog = next;

tools/lib/bpf/libbpf.c

9735

prog = __bpf_program__iter(prog, obj, false);

tools/lib/bpf/libbpf.c

9736

} while (prog && prog_is_subprog(obj, prog));

tools/lib/bpf/libbpf.c

9738

return prog;

tools/lib/bpf/libbpf.c

9741

void bpf_program__set_ifindex(struct bpf_program *prog, __u32 ifindex)

tools/lib/bpf/libbpf.c

9743

prog->prog_ifindex = ifindex;

tools/lib/bpf/libbpf.c

9746

const char *bpf_program__name(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9748

return prog->name;

tools/lib/bpf/libbpf.c

9751

const char *bpf_program__section_name(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9753

return prog->sec_name;

tools/lib/bpf/libbpf.c

9756

bool bpf_program__autoload(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9758

return prog->autoload;

tools/lib/bpf/libbpf.c

9761

int bpf_program__set_autoload(struct bpf_program *prog, bool autoload)

tools/lib/bpf/libbpf.c

9763

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9766

prog->autoload = autoload;

tools/lib/bpf/libbpf.c

9770

bool bpf_program__autoattach(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9772

return prog->autoattach;

tools/lib/bpf/libbpf.c

9775

void bpf_program__set_autoattach(struct bpf_program *prog, bool autoattach)

tools/lib/bpf/libbpf.c

9777

prog->autoattach = autoattach;

tools/lib/bpf/libbpf.c

9780

const struct bpf_insn *bpf_program__insns(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9782

return prog->insns;

tools/lib/bpf/libbpf.c

9785

size_t bpf_program__insn_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9787

return prog->insns_cnt;

tools/lib/bpf/libbpf.c

9790

int bpf_program__set_insns(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

9795

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9798

insns = libbpf_reallocarray(prog->insns, new_insn_cnt, sizeof(*insns));

tools/lib/bpf/libbpf.c

980

if (prog->sym_global && (ELF64_ST_VISIBILITY(sym->st_other) == STV_HIDDEN

tools/lib/bpf/libbpf.c

9801

pr_warn("prog '%s': failed to realloc prog code\n", prog->name);

tools/lib/bpf/libbpf.c

9806

prog->insns = insns;

tools/lib/bpf/libbpf.c

9807

prog->insns_cnt = new_insn_cnt;

tools/lib/bpf/libbpf.c

9811

int bpf_program__fd(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9813

if (!prog)

tools/lib/bpf/libbpf.c

9816

if (prog->fd < 0)

tools/lib/bpf/libbpf.c

9819

return prog->fd;

tools/lib/bpf/libbpf.c

982

prog->mark_btf_static = true;

tools/lib/bpf/libbpf.c

9823

enum bpf_prog_type bpf_program__get_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.c

9825

enum bpf_prog_type bpf_program__type(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9827

return prog->type;

tools/lib/bpf/libbpf.c

9836

int bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type)

tools/lib/bpf/libbpf.c

9838

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9842

if (prog->type == type)

tools/lib/bpf/libbpf.c

9845

prog->type = type;

tools/lib/bpf/libbpf.c

9853

if (prog->sec_def != &custom_fallback_def)

tools/lib/bpf/libbpf.c

9854

prog->sec_def = NULL;

tools/lib/bpf/libbpf.c

9859

enum bpf_attach_type bpf_program__get_expected_attach_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.c

9861

enum bpf_attach_type bpf_program__expected_attach_type(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9863

return prog->expected_attach_type;

tools/lib/bpf/libbpf.c

9866

int bpf_program__set_expected_attach_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.c

9869

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9872

prog->expected_attach_type = type;

tools/lib/bpf/libbpf.c

9876

__u32 bpf_program__flags(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9878

return prog->prog_flags;

tools/lib/bpf/libbpf.c

9881

int bpf_program__set_flags(struct bpf_program *prog, __u32 flags)

tools/lib/bpf/libbpf.c

9883

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9886

prog->prog_flags = flags;

tools/lib/bpf/libbpf.c

9890

__u32 bpf_program__log_level(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9892

return prog->log_level;

tools/lib/bpf/libbpf.c

9895

int bpf_program__set_log_level(struct bpf_program *prog, __u32 log_level)

tools/lib/bpf/libbpf.c

9897

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9900

prog->log_level = log_level;

tools/lib/bpf/libbpf.c

9904

const char *bpf_program__log_buf(const struct bpf_program *prog, size_t *log_size)

tools/lib/bpf/libbpf.c

9906

*log_size = prog->log_size;

tools/lib/bpf/libbpf.c

9907

return prog->log_buf;

tools/lib/bpf/libbpf.c

9910

int bpf_program__set_log_buf(struct bpf_program *prog, char *log_buf, size_t log_size)

tools/lib/bpf/libbpf.c

9914

if (prog->log_size > UINT_MAX)

tools/lib/bpf/libbpf.c

9916

if (prog->obj->state >= OBJ_LOADED)

tools/lib/bpf/libbpf.c

9919

prog->log_buf = log_buf;

tools/lib/bpf/libbpf.c

9920

prog->log_size = log_size;

tools/lib/bpf/libbpf.c

9924

struct bpf_func_info *bpf_program__func_info(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9926

if (prog->func_info_rec_size != sizeof(struct bpf_func_info))

tools/lib/bpf/libbpf.c

9928

return prog->func_info;

tools/lib/bpf/libbpf.c

993

struct bpf_program *prog = obj->programs;

tools/lib/bpf/libbpf.c

9931

__u32 bpf_program__func_info_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9933

return prog->func_info_cnt;

tools/lib/bpf/libbpf.c

9936

struct bpf_line_info *bpf_program__line_info(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9938

if (prog->line_info_rec_size != sizeof(struct bpf_line_info))

tools/lib/bpf/libbpf.c

9940

return prog->line_info;

tools/lib/bpf/libbpf.c

9943

__u32 bpf_program__line_info_cnt(const struct bpf_program *prog)

tools/lib/bpf/libbpf.c

9945

return prog->line_info_cnt;

tools/lib/bpf/libbpf.c

9948

int bpf_program__clone(struct bpf_program *prog, const struct bpf_prog_load_opts *opts)

tools/lib/bpf/libbpf.c

9956

if (!prog)

tools/lib/bpf/libbpf.c

9962

obj = prog->obj;

tools/lib/bpf/libbpf.c

997

for (p = 0; p < obj->nr_programs; p++, prog++) {

tools/lib/bpf/libbpf.c

9970

attr.attach_prog_fd = OPTS_GET(opts, attach_prog_fd, 0) ?: prog->attach_prog_fd;

tools/lib/bpf/libbpf.c

9971

attr.prog_flags = OPTS_GET(opts, prog_flags, 0) ?: prog->prog_flags;

tools/lib/bpf/libbpf.c

9972

attr.prog_ifindex = OPTS_GET(opts, prog_ifindex, 0) ?: prog->prog_ifindex;

tools/lib/bpf/libbpf.c

998

insn = prog->insns;

tools/lib/bpf/libbpf.c

999

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

tools/lib/bpf/libbpf.c

9994

prog->name);

tools/lib/bpf/libbpf.c

9997

attr.func_info = info ?: prog->func_info;

tools/lib/bpf/libbpf.c

9998

attr.func_info_cnt = info ? info_cnt : prog->func_info_cnt;

tools/lib/bpf/libbpf.c

9999

attr.func_info_rec_size = info ? info_rec_size : prog->func_info_rec_size;

tools/lib/bpf/libbpf.h

1008

bpf_program__set_expected_attach_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

1011

LIBBPF_API __u32 bpf_program__flags(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1012

LIBBPF_API int bpf_program__set_flags(struct bpf_program *prog, __u32 flags);

tools/lib/bpf/libbpf.h

1018

LIBBPF_API __u32 bpf_program__log_level(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1019

LIBBPF_API int bpf_program__set_log_level(struct bpf_program *prog, __u32 log_level);

tools/lib/bpf/libbpf.h

1020

LIBBPF_API const char *bpf_program__log_buf(const struct bpf_program *prog, size_t *log_size);

tools/lib/bpf/libbpf.h

1021

LIBBPF_API int bpf_program__set_log_buf(struct bpf_program *prog, char *log_buf, size_t log_size);

tools/lib/bpf/libbpf.h

1023

LIBBPF_API struct bpf_func_info *bpf_program__func_info(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1024

LIBBPF_API __u32 bpf_program__func_info_cnt(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1026

LIBBPF_API struct bpf_line_info *bpf_program__line_info(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1027

LIBBPF_API __u32 bpf_program__line_info_cnt(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

1046

bpf_program__set_attach_target(struct bpf_program *prog, int attach_prog_fd,

tools/lib/bpf/libbpf.h

1062

bpf_program__assoc_struct_ops(struct bpf_program *prog, struct bpf_map *map,

tools/lib/bpf/libbpf.h

1362

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

582

bpf_program__attach_kprobe(const struct bpf_program *prog, bool retprobe,

tools/lib/bpf/libbpf.h

599

bpf_program__attach_kprobe_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

626

bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

677

bpf_program__attach_uprobe_multi(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

725

bpf_program__attach_ksyscall(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

741

bpf_program__attach_tracing_multi(const struct bpf_program *prog, const char *pattern,

tools/lib/bpf/libbpf.h

786

bpf_program__attach_uprobe(const struct bpf_program *prog, bool retprobe,

tools/lib/bpf/libbpf.h

805

bpf_program__attach_uprobe_opts(const struct bpf_program *prog, pid_t pid,

tools/lib/bpf/libbpf.h

835

bpf_program__attach_usdt(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

849

bpf_program__attach_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

853

bpf_program__attach_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

866

bpf_program__attach_raw_tracepoint(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

869

bpf_program__attach_raw_tracepoint_opts(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

882

bpf_program__attach_trace(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

884

bpf_program__attach_trace_opts(const struct bpf_program *prog, const struct bpf_trace_opts *opts);

tools/lib/bpf/libbpf.h

887

bpf_program__attach_lsm(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

889

bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd);

tools/lib/bpf/libbpf.h

891

bpf_program__attach_netns(const struct bpf_program *prog, int netns_fd);

tools/lib/bpf/libbpf.h

893

bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd);

tools/lib/bpf/libbpf.h

895

bpf_program__attach_xdp(const struct bpf_program *prog, int ifindex);

tools/lib/bpf/libbpf.h

897

bpf_program__attach_freplace(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

912

bpf_program__attach_netfilter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

927

bpf_program__attach_tcx(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.h

942

bpf_program__attach_netkit(const struct bpf_program *prog, int ifindex,

tools/lib/bpf/libbpf.h

957

bpf_program__attach_cgroup_opts(const struct bpf_program *prog, int cgroup_fd,

tools/lib/bpf/libbpf.h

973

bpf_program__attach_iter(const struct bpf_program *prog,

tools/lib/bpf/libbpf.h

976

LIBBPF_API enum bpf_prog_type bpf_program__type(const struct bpf_program *prog);

tools/lib/bpf/libbpf.h

989

LIBBPF_API int bpf_program__set_type(struct bpf_program *prog,

tools/lib/bpf/libbpf.h

993

bpf_program__expected_attach_type(const struct bpf_program *prog);

tools/lib/bpf/libbpf_internal.h

731

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

1013

struct bpf_link *usdt_manager_attach_usdt(struct usdt_manager *man, const struct bpf_program *prog,

tools/lib/bpf/usdt.c

1133

uprobe_link = bpf_program__attach_uprobe_opts(prog, pid, path,

tools/lib/bpf/usdt.c

1156

link->multi_link = bpf_program__attach_uprobe_multi(prog, pid, path,

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

584

struct ui_progress prog;

tools/perf/builtin-annotate.c

589

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

591

hists__collapse_resort(hists, &prog);

tools/perf/builtin-annotate.c

597

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

599

evsel__output_resort(pos, &prog);

tools/perf/builtin-annotate.c

630

struct ui_progress prog;

tools/perf/builtin-annotate.c

642

ui_progress__init(&prog, nr_samples,

tools/perf/builtin-annotate.c

644

evsel__output_resort(pos, &prog);

tools/perf/builtin-c2c.c

3110

struct ui_progress prog;

tools/perf/builtin-c2c.c

3361

ui_progress__init(&prog, c2c.hists.hists.nr_entries, "Sorting...");

tools/perf/builtin-c2c.c

3364

hists__output_resort_cb(&c2c.hists.hists, &prog, resort_shared_cl_cb);

tools/perf/builtin-kvm.c

1006

struct ui_progress prog;

tools/perf/builtin-kvm.c

1011

ui_progress__init(&prog, kvm_hists.hists.nr_entries, "Sorting...");

tools/perf/builtin-report.c

707

struct ui_progress prog;

tools/perf/builtin-report.c

724

ui_progress__init(&prog, rep->nr_entries, "Merging related events...");

tools/perf/builtin-report.c

734

ret = hists__collapse_resort(hists, &prog);

tools/perf/builtin-report.c

767

struct ui_progress prog;

tools/perf/builtin-report.c

770

ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");

tools/perf/builtin-report.c

773

evsel__output_resort_cb(pos, &prog, hists__resort_cb, rep);

tools/perf/builtin-trace.c

3807

struct bpf_program *prog;

tools/perf/builtin-trace.c

3812

prog = augmented_syscalls__find_by_title(default_prog_name);

tools/perf/builtin-trace.c

3813

if (prog != NULL)

tools/perf/builtin-trace.c

3817

prog = augmented_syscalls__find_by_title(default_prog_name);

tools/perf/builtin-trace.c

3818

if (prog != NULL)

tools/perf/builtin-trace.c

3824

prog = augmented_syscalls__find_by_title(prog_name);

tools/perf/builtin-trace.c

3826

if (prog != NULL) {

tools/perf/builtin-trace.c

3828

return prog;

tools/perf/tests/dlfilter-test.c

213

static const char *prog = "int bar(){};int foo(){bar();};int main(){foo();return 0;}";

tools/perf/tests/dlfilter-test.c

218

ssize_t n = strlen(prog);

tools/perf/tests/dlfilter-test.c

219

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

206

struct bpf_program *prog;

tools/perf/util/bpf_kwork.c

221

bpf_object__for_each_program(prog, skel->obj)

tools/perf/util/bpf_kwork.c

222

bpf_program__set_autoload(prog, false);

tools/perf/util/bpf_kwork_top.c

162

struct bpf_program *prog;

tools/perf/util/bpf_kwork_top.c

177

bpf_object__for_each_program(prog, skel->obj)

tools/perf/util/bpf_kwork_top.c

178

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

1829

int hists__collapse_resort(struct hists *hists, struct ui_progress *prog)

tools/perf/util/hist.c

1864

if (prog)

tools/perf/util/hist.c

1865

ui_progress__update(prog, 1);

tools/perf/util/hist.c

1965

struct ui_progress *prog,

tools/perf/util/hist.c

1983

if (prog)

tools/perf/util/hist.c

1984

ui_progress__update(prog, 1);

tools/perf/util/hist.c

1993

hists__hierarchy_output_resort(hists, prog,

tools/perf/util/hist.c

2064

static void output_resort(struct hists *hists, struct ui_progress *prog,

tools/perf/util/hist.c

2084

hists__hierarchy_output_resort(hists, prog,

tools/perf/util/hist.c

2114

if (prog)

tools/perf/util/hist.c

2115

ui_progress__update(prog, 1);

tools/perf/util/hist.c

2119

void evsel__output_resort_cb(struct evsel *evsel, struct ui_progress *prog,

tools/perf/util/hist.c

2131

output_resort(evsel__hists(evsel), prog, use_callchain, cb, cb_arg);

tools/perf/util/hist.c

2134

void evsel__output_resort(struct evsel *evsel, struct ui_progress *prog)

tools/perf/util/hist.c

2136

return evsel__output_resort_cb(evsel, prog, NULL, NULL);

tools/perf/util/hist.c

2139

void hists__output_resort(struct hists *hists, struct ui_progress *prog)

tools/perf/util/hist.c

2141

output_resort(hists, prog, symbol_conf.use_callchain, NULL, NULL);

tools/perf/util/hist.c

2144

void hists__output_resort_cb(struct hists *hists, struct ui_progress *prog,

tools/perf/util/hist.c

2147

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

3109

struct ui_progress prog;

tools/perf/util/session.c

3125

ui_progress__init_size(&prog, session->data->file.size,

tools/perf/util/session.c

3204

ui_progress__update(&prog, size);

tools/perf/util/session.c

3459

struct ui_progress *prog)

tools/perf/util/session.c

3500

ui_progress__update(prog, size);

tools/perf/util/session.c

3514

struct ui_progress *prog)

tools/perf/util/session.c

3530

err = reader__read_event(rd, session, prog);

tools/perf/util/session.c

3567

struct ui_progress prog;

tools/perf/util/session.c

3573

ui_progress__init_size(&prog, rd.data_size, "Processing events...");

tools/perf/util/session.c

3575

err = reader__process_events(&rd, session, &prog);

tools/perf/util/session.c

3621

struct ui_progress prog;

tools/perf/util/session.c

3625

ui_progress__init_size(&prog, total_size, "Processing events...");

tools/perf/util/session.c

3689

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/sched_ext/include/scx/compat.h

224

static inline void __scx_ops_assoc_prog(struct bpf_program *prog,

tools/sched_ext/include/scx/compat.h

228

s32 err = bpf_program__assoc_struct_ops(prog, map, NULL);

tools/sched_ext/include/scx/compat.h

232

bpf_program__name(prog), ops_name, err);

tools/sched_ext/include/scx/compat.h

235

static inline void __scx_ops_assoc_prog(struct bpf_program *prog,

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

190

struct bpf_program *prog;

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

192

prog = bpf_object__find_program_by_name(ctx.skel->obj, *names);

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

193

if (!prog) {

tools/testing/selftests/bpf/benchs/bench_htab_mem.c

197

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/arena_spin_lock.c

74

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

169

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

176

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

177

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/bpf_nf.c

180

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

4865

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/btf.c

4898

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/btf.c

4899

if (CHECK(!prog, "Cannot find bpf_prog")) {

tools/testing/selftests/bpf/prog_tests/btf.c

4904

bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);

tools/testing/selftests/bpf/prog_tests/btf.c

4908

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

104

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

107

if (CHECK(!prog, "find_prog", "getpeername prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

112

err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

120

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

123

if (CHECK(!prog, "find_prog", "getsockname prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

128

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

88

prog = bpf_object__find_program_by_name(obj, v4 ?

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

91

if (CHECK(!prog, "find_prog", "connect prog not found\n")) {

tools/testing/selftests/bpf/prog_tests/connect_force_port.c

96

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

637

struct bpf_insn *prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

668

pinfo->prog, pinfo->prog_len, &opts);

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

748

pinfo.prog = ldx_prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

781

pinfo.prog = stx_prog;

tools/testing/selftests/bpf/prog_tests/ctx_rewrite.c

790

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

12

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/empty_skb.c

146

bpf_object__for_each_program(prog, bpf_obj->obj) {

tools/testing/selftests/bpf/prog_tests/empty_skb.c

147

bool at_egress = strstr(bpf_program__name(prog), "egress") != NULL;

tools/testing/selftests/bpf/prog_tests/empty_skb.c

148

bool at_tc = !strncmp(bpf_program__section_name(prog), "tc", 2);

tools/testing/selftests/bpf/prog_tests/empty_skb.c

149

bool is_adjust_room = !strcmp(bpf_program__name(prog), "tc_adjust_room");

tools/testing/selftests/bpf/prog_tests/empty_skb.c

164

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &tattr);

tools/testing/selftests/bpf/prog_tests/empty_skb.c

165

sprintf(buf, "err: %s [%s]", tests[i].msg, bpf_program__name(prog));

tools/testing/selftests/bpf/prog_tests/empty_skb.c

171

sprintf(buf, "ret: %s [%s]", tests[i].msg, bpf_program__name(prog));

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

102

struct bpf_program *prog = NULL; \

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

107

ASSERT_OK_PTR(bpf_program__name(prog), bpf_program__name(prog)); \

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

120

if (!ASSERT_ERR_PTR(link = bpf_program__attach(prog), "attach err")) \

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

123

if (!ASSERT_OK_PTR(link = bpf_program__attach(prog), "attach ok")) \

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

132

prog = eskel->progs.pfentry;

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

133

bpf_program__set_autoload(prog, true);

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

134

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

142

prog = eskel->progs.throwing_fentry;

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

143

bpf_program__set_autoload(prog, true);

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

144

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

152

prog = eskel->progs.pfexit;

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

153

bpf_program__set_autoload(prog, true);

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

154

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

162

prog = eskel->progs.throwing_fexit;

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

163

bpf_program__set_autoload(prog, true);

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

164

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

172

prog = eskel->progs.throwing_exception_cb_extension;

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

173

bpf_program__set_autoload(prog, true);

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

174

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

182

prog = eskel->progs.throwing_exception_cb_extension;

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

183

bpf_program__set_autoload(prog, true);

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

184

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

192

prog = eskel->progs.throwing_extension;

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

193

bpf_program__set_autoload(prog, true);

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

194

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

203

prog = eskel->progs.pfentry;

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

204

bpf_program__set_autoload(prog, true);

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

205

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

214

prog = eskel->progs.throwing_fentry;

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

215

bpf_program__set_autoload(prog, true);

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

216

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

225

prog = eskel->progs.pfentry;

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

226

bpf_program__set_autoload(prog, true);

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

227

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

236

prog = eskel->progs.throwing_fentry;

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

237

bpf_program__set_autoload(prog, true);

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

238

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

247

prog = eskel->progs.pfexit;

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

248

bpf_program__set_autoload(prog, true);

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

249

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

258

prog = eskel->progs.throwing_fexit;

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

259

bpf_program__set_autoload(prog, true);

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

260

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

269

prog = eskel->progs.pfexit;

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

270

bpf_program__set_autoload(prog, true);

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

271

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

280

prog = eskel->progs.throwing_fexit;

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

281

bpf_program__set_autoload(prog, true);

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

282

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

293

prog = eskel->progs.pfmod_ret;

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

294

bpf_program__set_autoload(prog, true);

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

295

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

306

prog = eskel->progs.pfmod_ret;

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

307

bpf_program__set_autoload(prog, true);

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

308

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

317

prog = eskel->progs.extension;

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

318

bpf_program__set_autoload(prog, true);

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

319

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

328

prog = eskel->progs.extension;

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

329

bpf_program__set_autoload(prog, true);

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

330

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

339

prog = eskel->progs.extension;

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

340

bpf_program__set_autoload(prog, true);

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

341

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

350

prog = eskel->progs.extension;

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

351

bpf_program__set_autoload(prog, true);

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

352

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

361

prog = eskel->progs.throwing_extension;

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

362

bpf_program__set_autoload(prog, true);

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

363

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

372

prog = eskel->progs.throwing_extension;

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

373

bpf_program__set_autoload(prog, true);

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

374

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

383

prog = eskel->progs.extension;

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

384

bpf_program__set_autoload(prog, true);

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

385

if (!ASSERT_OK(bpf_program__set_attach_target(prog,

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

394

prog = eskel->progs.throwing_extension;

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

395

bpf_program__set_autoload(prog, true);

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

396

if (!ASSERT_OK(bpf_program__set_attach_target(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

370

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

386

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

387

err = bpf_program__set_attach_target(prog, pkt_fd, NULL);

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

392

bpf_program__set_log_buf(prog, log_buf, sizeof(log_buf));

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c

394

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

61

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/file_reader.c

72

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/file_reader.c

73

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

123

prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

124

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

127

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

159

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

188

prog = bpf_object__find_program_by_name(skel->obj, param->prog_name);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

189

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

192

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

205

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/kfunc_call.c

98

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/libarena.c

129

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/libarena.c

13

static void run_libarena_test(struct libarena *skel, struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/libarena.c

138

prog = bpf_object__find_program_by_name(skel->obj, progname);

tools/testing/selftests/bpf/prog_tests/libarena.c

139

if (!prog)

tools/testing/selftests/bpf/prog_tests/libarena.c

142

ret = libarena_run_prog(bpf_program__fd(prog));

tools/testing/selftests/bpf/prog_tests/libarena.c

150

static void run_libarena_parallel_test(struct libarena *skel, struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/libarena.c

190

ret = libarena_run_prog(bpf_program__fd(prog));

tools/testing/selftests/bpf/prog_tests/libarena.c

205

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/libarena.c

223

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/libarena.c

224

const char *name = bpf_program__name(prog);

tools/testing/selftests/bpf/prog_tests/libarena.c

238

run_libarena_parallel_test(skel, prog, name);

tools/testing/selftests/bpf/prog_tests/libarena.c

24

ret = libarena_run_prog(bpf_program__fd(prog));

tools/testing/selftests/bpf/prog_tests/libarena.c

248

run_libarena_test(skel, prog, name);

tools/testing/selftests/bpf/prog_tests/libarena.c

32

struct bpf_program *prog = arg;

tools/testing/selftests/bpf/prog_tests/libarena.c

34

return (void *)(long)libarena_run_prog(bpf_program__fd(prog));

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

16

struct bpf_program *prog, const char *name)

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

26

ret = libarena_run_prog(bpf_program__fd(prog));

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

29

verify_test_stderr(skel->obj, prog);

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

36

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

61

bpf_object__for_each_program(prog, skel->obj) {

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

62

const char *name = bpf_program__name(prog);

tools/testing/selftests/bpf/prog_tests/libarena_asan.c

70

run_libarena_asan_test(skel, prog, name);

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/linked_list.c

134

static void clear_fields(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/linked_list.c

139

ret = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

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/map_kptr.c

171

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/map_kptr.c

178

prog = map_update_kptr_prog(skel, test);

tools/testing/selftests/bpf/prog_tests/map_kptr.c

179

if (!ASSERT_OK_PTR(prog, "map_update_kptr_prog"))

tools/testing/selftests/bpf/prog_tests/map_kptr.c

182

ret = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

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/module_attach.c

132

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/module_attach.c

140

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/module_attach.c

141

if (!ASSERT_OK_PTR(prog, "module_attach find_program"))

tools/testing/selftests/bpf/prog_tests/module_attach.c

143

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/module_attach.c

150

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/module_attach.c

55

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/module_attach.c

62

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/module_attach.c

63

if (!ASSERT_OK_PTR(prog, "module_attach find_program"))

tools/testing/selftests/bpf/prog_tests/module_attach.c

65

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/module_attach.c

68

err = bpf_program__set_attach_target(prog, 0, attach_target);

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/rhash.c

15

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/rhash.c

23

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/rhash.c

24

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/rhash.c

26

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/rhash.c

32

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

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/sleepable_tracepoints.c

25

static void run_auto_attach_test(struct bpf_program *prog,

tools/testing/selftests/bpf/prog_tests/sleepable_tracepoints.c

30

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/sleepable_tracepoints.c

38

static void test_attach_only(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/sleepable_tracepoints.c

42

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/sleepable_tracepoints.c

47

static void test_attach_reject(struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/sleepable_tracepoints.c

51

link = bpf_program__attach(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

1044

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1056

prog = skel->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1058

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1121

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1130

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1133

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1193

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1202

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1205

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1210

prog = skel->progs.prog_skb_verdict_ingress_strp;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1211

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_PARSER, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1302

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1312

prog = skel->progs.prog_skb_verdict_ingress;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

1315

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

181

struct bpf_program *prog, *prog_clone, *prog_clone2;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

191

prog = skel->progs.prog_msg_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

196

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

201

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_MSG_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

224

err = bpf_link_update(bpf_link__fd(link), bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

230

err = bpf_link_update(bpf_link__fd(link), bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

240

int err, prog, src;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

260

prog = bpf_program__fd(skel->progs.copy_sock_map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

271

err = bpf_prog_test_run_opts(prog, &topts);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

408

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

415

prog = skel->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

417

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

423

err = bpf_prog_attach(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT, 0);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

428

link = bpf_program__attach_sockmap(prog, map);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

432

err = bpf_prog_detach2(bpf_program__fd(prog), map, BPF_SK_SKB_STREAM_VERDICT);

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

771

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

778

prog = pass->progs.prog_skb_verdict;

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c

780

link = bpf_program__attach_sockmap(prog, map);

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

83

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/spin_lock.c

90

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/spin_lock.c

91

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/spin_lock.c

94

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/prog_tests/stack_arg.c

18

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/stack_arg.c

9

static void run_subtest(struct bpf_program *prog, int expected)

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

1023

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1046

prog = bpf_object__find_program_by_name(tgt_obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1047

if (!ASSERT_OK_PTR(prog, "find classifier_0 prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1050

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1064

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1065

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1068

err = bpf_program__set_attach_target(prog, prog_fd, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1076

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

109

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

110

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

113

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1205

struct bpf_program *prog, *fentry_prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1221

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1222

if (!ASSERT_OK_PTR(prog, "find entry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1225

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1237

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1301

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1302

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1305

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1314

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1325

prog = bpf_object__find_program_by_name(fexit_obj, "fexit");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1326

if (!ASSERT_OK_PTR(prog, "find fexit prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1329

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

1338

fexit_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

160

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

175

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

176

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

179

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

194

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

195

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

198

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

239

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

24

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

252

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

253

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

256

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

268

prog = bpf_object__find_program_by_name(obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

269

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

272

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

287

prog = bpf_object__find_program_by_name(fentry_obj, "fentry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

288

if (!ASSERT_OK_PTR(prog, "find fentry prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

291

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

300

fentry_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

311

prog = bpf_object__find_program_by_name(fexit_obj, "fexit");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

312

if (!ASSERT_OK_PTR(prog, "find fexit prog"))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

315

err = bpf_program__set_attach_target(prog, prog_fd,

tools/testing/selftests/bpf/prog_tests/tailcalls.c

324

fexit_link = bpf_program__attach_trace(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

39

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

40

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

420

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

43

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

436

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

437

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

440

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

463

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

464

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

467

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

510

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

526

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

527

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

530

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

553

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

554

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

557

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

58

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

59

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

600

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

614

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

615

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

618

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

62

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

634

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

635

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

638

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

684

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

698

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

699

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

702

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

714

prog = bpf_object__find_program_by_name(obj, "classifier_0");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

715

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

718

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

764

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

778

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

779

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

782

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

797

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

798

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

801

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

859

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/tailcalls.c

873

prog = bpf_object__find_program_by_name(obj, "entry");

tools/testing/selftests/bpf/prog_tests/tailcalls.c

874

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

877

main_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

88

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

89

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

892

prog = bpf_object__find_program_by_name(obj, prog_name);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

893

if (CHECK_FAIL(!prog))

tools/testing/selftests/bpf/prog_tests/tailcalls.c

896

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/tailcalls.c

92

prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

104

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

119

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

120

if (!prog) {

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

125

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

75

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

85

prog = bpf_object__find_program_by_name(skel->obj, prog_name);

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

86

if (!ASSERT_OK_PTR(prog, "bpf_object__find_program_by_name"))

tools/testing/selftests/bpf/prog_tests/task_kfunc.c

89

err = bpf_prog_test_run_opts(bpf_program__fd(prog), &opts);

tools/testing/selftests/bpf/prog_tests/tc_qevent.c

44

static void run_qevent_redirect(struct bpf_program *prog, __u64 *counter)

tools/testing/selftests/bpf/prog_tests/tc_qevent.c

53

err = bpf_program__pin(prog, PIN_PATH);

tools/testing/selftests/bpf/prog_tests/tc_qevent.c

94

bpf_program__unpin(prog, PIN_PATH);

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

38

struct bpf_program *prog;

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

51

prog = load_prog(file, progs[i % ARRAY_SIZE(progs)], &inst[i]);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

52

if (!prog)

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

55

link = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

63

prog = load_prog(file, "fmod_ret_test", &inst[i]);

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

64

if (!prog)

tools/testing/selftests/bpf/prog_tests/trampoline_count.c

68

link = bpf_program__attach(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

851

get_program(struct uprobe_multi_consumers *skel, int prog)

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

853

switch (prog) {

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

888

struct bpf_program *prog = get_program(skel, idx);

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

892

if (!prog || !link)

tools/testing/selftests/bpf/prog_tests/uprobe_multi_test.c

907

*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

231

static void dump_err_stream(const struct bpf_program *prog)

tools/testing/selftests/bpf/prog_tests/xdp_context_test_run.c

238

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

34

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/progs/test_signed_loader_lsm.c

17

int BPF_PROG(inspect_prog_load, struct bpf_prog *prog, union bpf_attr *attr,

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

26

sig_keyring_serial = prog->aux->sig.keyring_serial;

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

27

sig_keyring_type = prog->aux->sig.keyring_type;

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

28

sig_verdict = prog->aux->sig.verdict;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1419

const struct bpf_prog *prog,

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1422

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

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1580

static void test_1_recursion_detected(struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1584

stats = this_cpu_ptr(prog->stats);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1591

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1597

prog->aux->priv_stack_requested = true;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1598

prog->aux->recursion_detected = test_1_recursion_detected;

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1637

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1666

*insn++ = prog->insnsi[0];

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1671

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

1713

const struct bpf_prog *prog)

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1717

if (strcmp(prog->aux->attach_func_name, "test_prologue") &&

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1718

strcmp(prog->aux->attach_func_name, "test_pro_epilogue"))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1721

if (!strncmp(prog->aux->name, KFUNC_PRO_EPI_PREFIX, strlen(KFUNC_PRO_EPI_PREFIX)))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1722

return st_ops_gen_prologue_with_kfunc(insn_buf, direct_write, prog);

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1733

*insn++ = prog->insnsi[0];

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1738

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

1743

if (strcmp(prog->aux->attach_func_name, "test_epilogue") &&

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1744

strcmp(prog->aux->attach_func_name, "test_pro_epilogue"))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1747

if (!strncmp(prog->aux->name, KFUNC_PRO_EPI_PREFIX, strlen(KFUNC_PRO_EPI_PREFIX)))

tools/testing/selftests/bpf/test_kmods/bpf_testmod.c

1748

return st_ops_gen_epilogue_with_kfunc(insn_buf, prog, ctx_stack_off);

tools/testing/selftests/bpf/test_loader.c

1528

struct bpf_program *prog;

tools/testing/selftests/bpf/test_loader.c

1542

bpf_object__for_each_program(prog, obj)

tools/testing/selftests/bpf/test_loader.c

1550

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_loader.c

1552

err = parse_test_spec(tester, obj, prog, &specs[i++]);

tools/testing/selftests/bpf/test_loader.c

1555

bpf_program__name(prog));

tools/testing/selftests/bpf/test_loader.c

1559

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_loader.c

405

struct bpf_program *prog,

tools/testing/selftests/bpf/test_loader.c

430

spec->prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/test_loader.c

637

switch (bpf_program__type(prog)) {

tools/testing/selftests/bpf/test_loader.c

746

struct bpf_program *prog)

tools/testing/selftests/bpf/test_loader.c

755

bpf_program__set_log_buf(prog, tester->log_buf, tester->log_buf_sz);

tools/testing/selftests/bpf/test_loader.c

762

bpf_program__set_log_level(prog, (spec->log_level & 4) | min_log_level);

tools/testing/selftests/bpf/test_loader.c

764

bpf_program__set_log_level(prog, spec->log_level);

tools/testing/selftests/bpf/test_loader.c

766

prog_flags = bpf_program__flags(prog);

tools/testing/selftests/bpf/test_loader.c

767

bpf_program__set_flags(prog, prog_flags | spec->prog_flags);

tools/testing/selftests/bpf/test_loader.c

826

void verify_test_stderr(struct bpf_object *obj, struct bpf_program *prog)

tools/testing/selftests/bpf/test_loader.c

830

if (parse_test_spec(NULL, obj, prog, &spec))

tools/testing/selftests/bpf/test_loader.c

833

verify_stderr(bpf_program__fd(prog), &spec.priv.stderr);

tools/testing/selftests/bpf/test_progs.h

568

void verify_test_stderr(struct bpf_object *obj, struct bpf_program *prog);

tools/testing/selftests/bpf/test_sockmap.c

1731

struct bpf_program *prog;

tools/testing/selftests/bpf/test_sockmap.c

1749

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/test_sockmap.c

1750

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

294

struct bpf_program *prog;

tools/testing/selftests/bpf/testing_helpers.c

302

prog = bpf_object__next_program(obj, NULL);

tools/testing/selftests/bpf/testing_helpers.c

303

if (!prog) {

tools/testing/selftests/bpf/testing_helpers.c

308

if (type != BPF_PROG_TYPE_UNSPEC && bpf_program__type(prog) != type)

tools/testing/selftests/bpf/testing_helpers.c

309

bpf_program__set_type(prog, type);

tools/testing/selftests/bpf/testing_helpers.c

311

flags = bpf_program__flags(prog) | testing_prog_flags();

tools/testing/selftests/bpf/testing_helpers.c

312

bpf_program__set_flags(prog, flags);

tools/testing/selftests/bpf/testing_helpers.c

319

*prog_fd = bpf_program__fd(prog);

tools/testing/selftests/bpf/veristat.c

1213

struct bpf_program *prog)

tools/testing/selftests/bpf/veristat.c

1235

if (memcmp(data + moff, &prog, ptr_sz) == 0)

tools/testing/selftests/bpf/veristat.c

1265

static void fixup_obj(struct bpf_object *obj, struct bpf_program *prog, const char *filename)

tools/testing/selftests/bpf/veristat.c

1271

mask_unrelated_struct_ops_progs(obj, map, prog);

tools/testing/selftests/bpf/veristat.c

1279

if (bpf_program__type(prog) == BPF_PROG_TYPE_EXT) {

tools/testing/selftests/bpf/veristat.c

1281

const char *prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/veristat.c

1312

bpf_program__set_type(prog, prog_type);

tools/testing/selftests/bpf/veristat.c

1313

bpf_program__set_expected_attach_type(prog, attach_type);

tools/testing/selftests/bpf/veristat.c

1616

static int process_prog(const char *filename, struct bpf_object *obj, struct bpf_program *prog)

tools/testing/selftests/bpf/veristat.c

1619

const char *prog_name = bpf_program__name(prog);

tools/testing/selftests/bpf/veristat.c

1631

if (!should_process_file_prog(base_filename, bpf_program__name(prog))) {

tools/testing/selftests/bpf/veristat.c

1662

fixup_obj(obj, prog, base_filename);

tools/testing/selftests/bpf/veristat.c

1665

bpf_program__set_flags(prog, bpf_program__flags(prog) | BPF_F_TEST_STATE_FREQ);

tools/testing/selftests/bpf/veristat.c

1667

bpf_program__set_flags(prog, bpf_program__flags(prog) | BPF_F_TEST_REG_INVARIANTS);

tools/testing/selftests/bpf/veristat.c

1675

fd = bpf_program__clone(prog, &opts);

tools/testing/selftests/bpf/veristat.c

1688

stats->prog_name = strdup(bpf_program__name(prog));

tools/testing/selftests/bpf/veristat.c

1690

stats->stats[SIZE] = bpf_program__insn_cnt(prog);

tools/testing/selftests/bpf/veristat.c

1691

stats->stats[PROG_TYPE] = bpf_program__type(prog);

tools/testing/selftests/bpf/veristat.c

1692

stats->stats[ATTACH_TYPE] = bpf_program__expected_attach_type(prog);

tools/testing/selftests/bpf/veristat.c

2201

struct bpf_program *prog;

tools/testing/selftests/bpf/veristat.c

2239

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/veristat.c

2240

bpf_program__set_autoload(prog, true);

tools/testing/selftests/bpf/veristat.c

2256

bpf_object__for_each_program(prog, obj) {

tools/testing/selftests/bpf/veristat.c

2257

process_prog(filename, obj, 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/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

104

struct bpf_program *prog;

tools/testing/selftests/hid/hid_bpf.c

108

prog = bpf_object__find_program_by_name(*self->skel->skeleton->obj,

tools/testing/selftests/hid/hid_bpf.c

110

ASSERT_OK_PTR(prog) TH_LOG("can not find program by name '%s'", programs[i].name);

tools/testing/selftests/hid/hid_bpf.c

112

bpf_program__set_autoload(prog, true);

tools/testing/selftests/mm/uffd-unit-tests.c

1672

static void usage(const char *prog)

tools/testing/selftests/mm/uffd-unit-tests.c

1674

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

113

attr.insn_cnt = ARRAY_SIZE(prog);

tools/testing/selftests/net/reuseport_bpf.c

114

attr.insns = (unsigned long) &prog;

tools/testing/selftests/net/reuseport_bpf.c

99

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/pipe/pipe_bench.c

489

static void usage(const char *prog)

tools/testing/selftests/pipe/pipe_bench.c

495

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

1075

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

1088

memset(&self->prog, 0, sizeof(self->prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

1089

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1090

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1091

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1092

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1097

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1098

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1108

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1123

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1159

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

1680

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

1697

memset(&self->prog, 0, sizeof(self->prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

1698

self->prog.filter = malloc(sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1699

ASSERT_NE(NULL, self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1700

memcpy(self->prog.filter, filter, sizeof(filter));

tools/testing/selftests/seccomp/seccomp_bpf.c

1701

self->prog.len = (unsigned short)ARRAY_SIZE(filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1714

if (self->prog.filter)

tools/testing/selftests/seccomp/seccomp_bpf.c

1715

free(self->prog.filter);

tools/testing/selftests/seccomp/seccomp_bpf.c

1725

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

1741

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2057

struct sock_fprog prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2164

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2198

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2265

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2272

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2288

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2295

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2313

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2320

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2332

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2344

ret = seccomp(-1, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2357

ret = seccomp(SECCOMP_SET_MODE_STRICT, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2363

ret = seccomp(SECCOMP_SET_MODE_FILTER, -1, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2372

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2384

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2395

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2511

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2523

&prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

2541

struct sock_fprog *prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2607

self->sibling[0].prog = &self->root_prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2614

self->sibling[1].prog = &self->root_prog;

tools/testing/selftests/seccomp/seccomp_bpf.c

2655

me->prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

2692

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

2702

ret = seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

3057

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3084

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3319

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3326

SECCOMP_FILTER_FLAG_LOG, &prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

3327

EXPECT_EQ(0, seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

3376

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3381

return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

3397

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

3423

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3424

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3425

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

3426

EXPECT_EQ(seccomp(SECCOMP_SET_MODE_FILTER, 0, &prog), 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

422

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

435

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

456

struct sock_fprog prog = { };

tools/testing/selftests/seccomp/seccomp_bpf.c

468

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

469

prog.len = count;

tools/testing/selftests/seccomp/seccomp_bpf.c

472

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

474

TH_LOG("Installing %d insn filter was allowed", prog.len);

tools/testing/selftests/seccomp/seccomp_bpf.c

478

prog.len -= 1;

tools/testing/selftests/seccomp/seccomp_bpf.c

479

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

481

TH_LOG("Installing %d insn filter wasn't allowed", prog.len);

tools/testing/selftests/seccomp/seccomp_bpf.c

493

struct sock_fprog prog = { };

tools/testing/selftests/seccomp/seccomp_bpf.c

505

prog.filter = filter;

tools/testing/selftests/seccomp/seccomp_bpf.c

506

prog.len = 1;

tools/testing/selftests/seccomp/seccomp_bpf.c

508

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

511

prog.len = count;

tools/testing/selftests/seccomp/seccomp_bpf.c

515

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

5204

static int run_probed_with_filter(struct sock_fprog *prog)

tools/testing/selftests/seccomp/seccomp_bpf.c

5207

seccomp(SECCOMP_SET_MODE_FILTER, 0, prog)) {

tools/testing/selftests/seccomp/seccomp_bpf.c

5226

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5231

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5243

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5248

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5265

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5270

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

5288

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

5293

ASSERT_EQ(0, run_probed_with_filter(&prog));

tools/testing/selftests/seccomp/seccomp_bpf.c

530

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

539

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

553

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

565

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

578

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

587

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

595

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

604

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

614

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

624

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

636

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

645

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

658

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

667

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

679

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

688

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

701

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

711

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

734

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

746

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

773

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

788

ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);

tools/testing/selftests/seccomp/seccomp_bpf.c

958

struct sock_fprog prog = {

tools/testing/selftests/seccomp/seccomp_bpf.c

967

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

219

prog = bpf_object__find_program_by_name(obj, "action_handler");

tools/tracing/rtla/src/timerlat_bpf.c

220

if (!prog) {

tools/tracing/rtla/src/timerlat_bpf.c

226

err = timerlat_bpf_set_action(prog);

tools/tracing/rtla/src/timerlat_bpf.c

235

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);