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

108

stack_entry = &state->stack[soff / BPF_REG_SIZE];

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

109

if (stack_entry->slot_type[soff % BPF_REG_SIZE] == STACK_ZERO)

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

791

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

include/linux/bpf_verifier.h

1061

return !(off % BPF_REG_SIZE);

include/linux/bpf_verifier.h

233

#define BPF_DYNPTR_NR_SLOTS (BPF_DYNPTR_SIZE / BPF_REG_SIZE)

include/linux/bpf_verifier.h

237

u8 slot_type[BPF_REG_SIZE];

include/linux/bpf_verifier.h

361

#define BPF_ID_MAP_SIZE ((MAX_BPF_REG + MAX_BPF_STACK / BPF_REG_SIZE) * MAX_CALL_FRAMES)

include/linux/bpf_verifier.h

449

(((slot < frame->allocated_stack / BPF_REG_SIZE) && \

include/linux/bpf_verifier.h

450

((1 << frame->stack[slot].slot_type[BPF_REG_SIZE - 1]) & (mask))) \

include/linux/bpf_verifier.h

456

iter < frame->allocated_stack / BPF_REG_SIZE; \

kernel/bpf/log.c

768

for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {

kernel/bpf/log.c

769

char types_buf[BPF_REG_SIZE + 1];

kernel/bpf/log.c

778

for (j = 0; j < BPF_REG_SIZE; j++) {

kernel/bpf/log.c

784

types_buf[BPF_REG_SIZE] = 0;

kernel/bpf/log.c

789

switch (state->stack[i].slot_type[BPF_REG_SIZE - 1]) {

kernel/bpf/log.c

792

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/log.c

797

verbose(env, " fp%d=%s", (-i - 1) * BPF_REG_SIZE, types_buf);

kernel/bpf/log.c

805

verbose(env, " fp%d", (-i - 1) * BPF_REG_SIZE);

kernel/bpf/log.c

821

(-i - 1) * BPF_REG_SIZE,

kernel/bpf/log.c

829

verbose(env, " fp%d=%s", (-i - 1) * BPF_REG_SIZE, types_buf);

kernel/bpf/verifier.c

1012

for (i = 0; i < BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

1083

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

1112

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

1141

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

1173

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

1211

for (i = 0; i < BPF_REG_SIZE; i++)

kernel/bpf/verifier.c

1263

for (i = 0; i < BPF_REG_SIZE; i++)

kernel/bpf/verifier.c

1288

for (i = 0; i < BPF_REG_SIZE; i++)

kernel/bpf/verifier.c

1311

for (i = 0; i < BPF_REG_SIZE; i++)

kernel/bpf/verifier.c

1325

enum bpf_stack_slot_type type = stack->slot_type[BPF_REG_SIZE - 1];

kernel/bpf/verifier.c

1348

return stack->slot_type[BPF_REG_SIZE - 1] == STACK_SPILL;

kernel/bpf/verifier.c

1353

return stack->slot_type[BPF_REG_SIZE - 1] == STACK_SPILL &&

kernel/bpf/verifier.c

1465

size_t n = src->allocated_stack / BPF_REG_SIZE;

kernel/bpf/verifier.c

1492

size_t old_n = state->allocated_stack / BPF_REG_SIZE, n;

kernel/bpf/verifier.c

1495

size = round_up(size, BPF_REG_SIZE);

kernel/bpf/verifier.c

1496

n = size / BPF_REG_SIZE;

kernel/bpf/verifier.c

17412

for (j = 0; j < func->allocated_stack / BPF_REG_SIZE; j++) {

kernel/bpf/verifier.c

18502

for (i = 1, off = lowest_off; i <= ARRAY_SIZE(caller_saved); ++i, off += BPF_REG_SIZE) {

kernel/bpf/verifier.c

19659

for (i = 0; i < st->allocated_stack / BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

19662

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

20023

spi = i / BPF_REG_SIZE;

kernel/bpf/verifier.c

20027

old->stack[spi].slot_type[i % BPF_REG_SIZE] !=

kernel/bpf/verifier.c

20028

cur->stack[spi].slot_type[i % BPF_REG_SIZE]))

kernel/bpf/verifier.c

20031

if (old->stack[spi].slot_type[i % BPF_REG_SIZE] == STACK_INVALID)

kernel/bpf/verifier.c

20035

old->stack[spi].slot_type[i % BPF_REG_SIZE] == STACK_MISC)

kernel/bpf/verifier.c

20054

i += BPF_REG_SIZE - 1;

kernel/bpf/verifier.c

20062

if (old->stack[spi].slot_type[i % BPF_REG_SIZE] == STACK_MISC &&

kernel/bpf/verifier.c

20063

cur->stack[spi].slot_type[i % BPF_REG_SIZE] == STACK_ZERO)

kernel/bpf/verifier.c

20065

if (old->stack[spi].slot_type[i % BPF_REG_SIZE] !=

kernel/bpf/verifier.c

20066

cur->stack[spi].slot_type[i % BPF_REG_SIZE])

kernel/bpf/verifier.c

20073

if (i % BPF_REG_SIZE != BPF_REG_SIZE - 1)

kernel/bpf/verifier.c

20076

switch (old->stack[spi].slot_type[BPF_REG_SIZE - 1]) {

kernel/bpf/verifier.c

20306

for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

20316

fr, (-i - 1) * BPF_REG_SIZE);

kernel/bpf/verifier.c

20318

verbose(env, ",fp%d", (-i - 1) * BPF_REG_SIZE);

kernel/bpf/verifier.c

20460

for (i = 0; i < state->allocated_stack / BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

24364

s32 r6_offset = stack_base + 0 * BPF_REG_SIZE;

kernel/bpf/verifier.c

24365

s32 r7_offset = stack_base + 1 * BPF_REG_SIZE;

kernel/bpf/verifier.c

24366

s32 r8_offset = stack_base + 2 * BPF_REG_SIZE;

kernel/bpf/verifier.c

24467

stack_depth_extra = BPF_REG_SIZE * 3 + stack_depth_roundup;

kernel/bpf/verifier.c

4780

for (j = 0; j < func->allocated_stack / BPF_REG_SIZE; j++) {

kernel/bpf/verifier.c

4810

for (j = 0; j < func->allocated_stack / BPF_REG_SIZE; j++) {

kernel/bpf/verifier.c

5044

if (verifier_bug_if(i >= func->allocated_stack / BPF_REG_SIZE,

kernel/bpf/verifier.c

5046

i, func->allocated_stack / BPF_REG_SIZE))

kernel/bpf/verifier.c

5201

for (i = BPF_REG_SIZE; i > BPF_REG_SIZE - size; i--)

kernel/bpf/verifier.c

5254

int i, slot = -off - 1, spi = slot / BPF_REG_SIZE, err;

kernel/bpf/verifier.c

5265

size != BPF_REG_SIZE) {

kernel/bpf/verifier.c

5293

if (!(off % BPF_REG_SIZE) && size == BPF_REG_SIZE) {

kernel/bpf/verifier.c

5307

if (reg && !(off % BPF_REG_SIZE) && reg->type == SCALAR_VALUE && env->bpf_capable) {

kernel/bpf/verifier.c

5318

} else if (!reg && !(off % BPF_REG_SIZE) && is_bpf_st_mem(insn) &&

kernel/bpf/verifier.c

5328

if (size != BPF_REG_SIZE) {

kernel/bpf/verifier.c

5345

for (i = 0; i < BPF_REG_SIZE; i++)

kernel/bpf/verifier.c

5365

state->stack[spi].slot_type[(slot - i) % BPF_REG_SIZE] = type;

kernel/bpf/verifier.c

5436

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

5437

stype = &state->stack[spi].slot_type[slot % BPF_REG_SIZE];

kernel/bpf/verifier.c

5524

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

5527

if (stype[slot % BPF_REG_SIZE] != STACK_ZERO)

kernel/bpf/verifier.c

5558

int i, slot = -off - 1, spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

5576

for (i = BPF_REG_SIZE - 1; i > 0 && stype[i - 1] == STACK_SPILL; i--)

kernel/bpf/verifier.c

5579

if (size != BPF_REG_SIZE || spill_size != BPF_REG_SIZE) {

kernel/bpf/verifier.c

5614

type = stype[(slot - i) % BPF_REG_SIZE];

kernel/bpf/verifier.c

5670

type = stype[(slot - i) % BPF_REG_SIZE];

kernel/bpf/verifier.c

629

return (-off - 1) / BPF_REG_SIZE;

kernel/bpf/verifier.c

642

int allocated_slots = state->allocated_stack / BPF_REG_SIZE;

kernel/bpf/verifier.c

665

if (off % BPF_REG_SIZE) {

kernel/bpf/verifier.c

7959

if (!err && size < BPF_REG_SIZE && value_regno >= 0 && t == BPF_READ &&

kernel/bpf/verifier.c

796

for (i = 0; i < BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

8282

if (state->stack[spi].slot_type[stack_off % BPF_REG_SIZE] == STACK_DYNPTR) {

kernel/bpf/verifier.c

8296

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

8302

stype = &state->stack[spi].slot_type[slot % BPF_REG_SIZE];

kernel/bpf/verifier.c

8319

for (j = 0; j < BPF_REG_SIZE; j++)

kernel/bpf/verifier.c

833

for (i = 0; i < BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

880

for (i = 1; i < state->allocated_stack / BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

8992

nr_slots = t->size / BPF_REG_SIZE;

kernel/bpf/verifier.c

9002

for (i = 0; i < nr_slots * 8; i += BPF_REG_SIZE) {

kernel/bpf/verifier.c

9124

num_slots = min(fold->allocated_stack / BPF_REG_SIZE,

kernel/bpf/verifier.c

9125

fcur->allocated_stack / BPF_REG_SIZE);

kernel/bpf/verifier.c

938

for (i = 0; i < BPF_REG_SIZE; i++) {

kernel/bpf/verifier.c

9822

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

9823

off = slot % BPF_REG_SIZE;