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

1197

return (-off - 1) / BPF_REG_SIZE;

include/linux/bpf_verifier.h

1223

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

include/linux/bpf_verifier.h

1382

return !(off % BPF_REG_SIZE);

include/linux/bpf_verifier.h

307

#define BPF_DYNPTR_NR_SLOTS (BPF_DYNPTR_SIZE / BPF_REG_SIZE)

include/linux/bpf_verifier.h

311

u8 slot_type[BPF_REG_SIZE];

include/linux/bpf_verifier.h

443

#define BPF_ID_MAP_SIZE ((MAX_BPF_REG + MAX_BPF_STACK / BPF_REG_SIZE + \

include/linux/bpf_verifier.h

533

if (slot < frame->allocated_stack / BPF_REG_SIZE &&

include/linux/bpf_verifier.h

534

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

include/linux/bpf_verifier.h

551

iter < frame->allocated_stack / BPF_REG_SIZE; \

kernel/bpf/backtrack.c

687

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

kernel/bpf/backtrack.c

926

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

kernel/bpf/backtrack.c

928

i, func->allocated_stack / BPF_REG_SIZE))

kernel/bpf/fixups.c

2432

s32 r6_offset = stack_base + 0 * BPF_REG_SIZE;

kernel/bpf/fixups.c

2433

s32 r7_offset = stack_base + 1 * BPF_REG_SIZE;

kernel/bpf/fixups.c

2434

s32 r8_offset = stack_base + 2 * BPF_REG_SIZE;

kernel/bpf/fixups.c

2535

stack_depth_extra = BPF_REG_SIZE * 3 + stack_depth_roundup;

kernel/bpf/liveness.c

426

return -(spi + 1) * BPF_REG_SIZE;

kernel/bpf/log.c

730

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

kernel/bpf/log.c

731

char types_buf[BPF_REG_SIZE + 1];

kernel/bpf/log.c

740

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

kernel/bpf/log.c

746

types_buf[BPF_REG_SIZE] = 0;

kernel/bpf/log.c

751

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

kernel/bpf/log.c

754

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

kernel/bpf/log.c

759

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

kernel/bpf/log.c

767

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

kernel/bpf/log.c

781

(-i - 1) * BPF_REG_SIZE,

kernel/bpf/log.c

789

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

kernel/bpf/states.c

1048

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

kernel/bpf/states.c

1058

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

kernel/bpf/states.c

1060

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

kernel/bpf/states.c

1197

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

kernel/bpf/states.c

1227

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

kernel/bpf/states.c

418

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

kernel/bpf/states.c

423

int start = !lo_live ? 0 : BPF_REG_SIZE / 2;

kernel/bpf/states.c

424

int end = !hi_live ? BPF_REG_SIZE : BPF_REG_SIZE / 2;

kernel/bpf/states.c

714

int im = i % BPF_REG_SIZE;

kernel/bpf/states.c

716

spi = i / BPF_REG_SIZE;

kernel/bpf/states.c

719

u8 old_type = old->stack[spi].slot_type[i % BPF_REG_SIZE];

kernel/bpf/states.c

721

cur->stack[spi].slot_type[i % BPF_REG_SIZE] : STACK_INVALID;

kernel/bpf/states.c

732

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

kernel/bpf/states.c

733

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

kernel/bpf/states.c

737

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

kernel/bpf/states.c

758

i += (im == 0 ? BPF_REG_SIZE - 1 : 3);

kernel/bpf/states.c

767

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

kernel/bpf/states.c

768

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

kernel/bpf/states.c

770

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

kernel/bpf/states.c

771

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

kernel/bpf/states.c

778

if (i % BPF_REG_SIZE != BPF_REG_SIZE - 1)

kernel/bpf/states.c

781

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

kernel/bpf/verifier.c

1022

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

kernel/bpf/verifier.c

1054

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

kernel/bpf/verifier.c

1091

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

kernel/bpf/verifier.c

1141

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

kernel/bpf/verifier.c

1166

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

kernel/bpf/verifier.c

1189

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

kernel/bpf/verifier.c

1203

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

kernel/bpf/verifier.c

1330

size_t n = src->allocated_stack / BPF_REG_SIZE;

kernel/bpf/verifier.c

1369

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

kernel/bpf/verifier.c

1372

size = round_up(size, BPF_REG_SIZE);

kernel/bpf/verifier.c

1373

n = size / BPF_REG_SIZE;

kernel/bpf/verifier.c

15874

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

kernel/bpf/verifier.c

16822

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

kernel/bpf/verifier.c

1798

snprintf(buf, len, "*(R11-%u)", (arg - MAX_BPF_FUNC_REG_ARGS) * BPF_REG_SIZE);

kernel/bpf/verifier.c

3394

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

kernel/bpf/verifier.c

3445

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

kernel/bpf/verifier.c

3459

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

kernel/bpf/verifier.c

3471

size != BPF_REG_SIZE) {

kernel/bpf/verifier.c

3484

BPF_REG_SIZE];

kernel/bpf/verifier.c

3502

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

kernel/bpf/verifier.c

3513

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

kernel/bpf/verifier.c

3523

if (size != BPF_REG_SIZE) {

kernel/bpf/verifier.c

3555

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

kernel/bpf/verifier.c

3625

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

3626

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

kernel/bpf/verifier.c

3720

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

3723

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

kernel/bpf/verifier.c

3754

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

kernel/bpf/verifier.c

3769

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

kernel/bpf/verifier.c

3772

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

kernel/bpf/verifier.c

3807

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

kernel/bpf/verifier.c

3868

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

kernel/bpf/verifier.c

4039

int spi = -off / BPF_REG_SIZE - 1;

kernel/bpf/verifier.c

4079

int spi = off / BPF_REG_SIZE - 1;

kernel/bpf/verifier.c

4090

off, bpf_in_stack_arg_cnt(subprog) * BPF_REG_SIZE);

kernel/bpf/verifier.c

552

int allocated_slots = state->allocated_stack / BPF_REG_SIZE;

kernel/bpf/verifier.c

575

if (off % BPF_REG_SIZE) {

kernel/bpf/verifier.c

6327

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

kernel/bpf/verifier.c

6676

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

kernel/bpf/verifier.c

6690

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

6696

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

kernel/bpf/verifier.c

6713

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

kernel/bpf/verifier.c

705

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

kernel/bpf/verifier.c

7385

nr_slots = t->size / BPF_REG_SIZE;

kernel/bpf/verifier.c

7395

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

kernel/bpf/verifier.c

750

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

kernel/bpf/verifier.c

7510

num_slots = min(fold->allocated_stack / BPF_REG_SIZE,

kernel/bpf/verifier.c

7511

fcur->allocated_stack / BPF_REG_SIZE);

kernel/bpf/verifier.c

8172

spi = slot / BPF_REG_SIZE;

kernel/bpf/verifier.c

8173

off = slot % BPF_REG_SIZE;

kernel/bpf/verifier.c

895

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

kernel/bpf/verifier.c

8995

if (!stack || stack->slot_type[BPF_REG_SIZE - 1] == STACK_SPILL)

kernel/bpf/verifier.c

8997

else if (stack->slot_type[BPF_REG_SIZE - 1] == STACK_DYNPTR)

kernel/bpf/verifier.c

966

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

kernel/bpf/verifier.c

994

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