Lines Matching defs:parent

741  * Note there is a non-zero 'parent' pointer inside bpf_verifier_state

883     dst_state->parent = src->parent;

915         st = st->parent;

979     if (elem->st.parent) {

980         ++elem->st.parent->branches;

987          * and cloned states will be pointing to a single parent state

1385         regs[i].parent = NULL;

1537 static int mark_reg_read(struct bpf_verifier_env *env, const struct bpf_reg_state *state, struct bpf_reg_state *parent,

1540     bool writes = parent == state->parent; /* Observe write marks */

1543     while (parent) {

1548         if (parent->live & REG_LIVE_DONE) {

1549             verbose(env, "verifier BUG type %s var_off %lld off %d\n", reg_type_str(env, parent->type),

1550                     parent->var_off.value, parent->off);

1556         if ((parent->live & REG_LIVE_READ) == flag || (parent->live & REG_LIVE_READ64)) {

1558              * this parent was already marked as LIVE_READ.

1563              * Also, if parent has the stronger REG_LIVE_READ64 set,

1568         /* ... then we depend on parent's value */

1569         parent->live |= flag;

1572             parent->live &= ~REG_LIVE_READ32;

1574         state = parent;

1575         parent = state->parent;

1741         return mark_reg_read(env, reg, reg->parent, rw64 ? REG_LIVE_READ64 : REG_LIVE_READ32);

1793  * stack slots that needs precision in the parent verifier state.

1835                  * No further markings in parent are necessary

1934          * into parent is necessary

1989  * Also if parent's curframe > frame where backtracking started,

2005     for (; st; st = st->parent) {

2109                  * Nothing to be tracked further in the parent state.

2129         st = st->parent;

2163                  * However the parent state may not have accessed

2187             verbose(env, "parent %s regs=%x stack=%llx marks\n", new_marks ? "didn't have" : "already had", reg_mask,

2581             mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64);

2609         mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64);

2624         mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64);

4068         mark_reg_read(env, &state->stack[spi].spilled_ptr, state->stack[spi].spilled_ptr.parent, REG_LIVE_READ64);

5136     /* copy r1 - r5 args that callee can access.  The copy includes parent

8948  * as REG_LIVE_DONE to indicate that 'parent' pointers of 'struct bpf_reg_state'

8992     equal = memcmp(rold, rcur, offsetof(struct bpf_reg_state, parent)) == 0;

9297  * straight-line code between a state and its parent.  When we arrive at an

9299  * code, so read marks in the state must propagate to the parent regardless

9300  * of the state's write marks. That's what 'parent == state->parent' comparison

9307     struct bpf_func_state *state, *parent;

9311         WARN(1, "propagate_live: parent frame %d current frame %d\n", vparent->curframe, vstate->curframe);

9317         parent = vparent->frame[frame];

9319         parent_reg = parent->regs;

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

9334             parent_reg = &parent->stack[i].spilled_ptr;

9400         if (memcmp(&fold->regs[i], &fcur->regs[i], offsetof(struct bpf_reg_state, parent))) {

9476              * from reaching our parent (an explored_state).  Our

9579     cur->parent = new;

9594      * their parent and current state never has children yet.  Only

9599             cur->frame[j]->regs[i].parent = &new->frame[j]->regs[i];

9613             frame->stack[i].spilled_ptr.parent = &newframe->stack[i].spilled_ptr;