Lines Matching defs:dst

684     static int copy_##NAME##_state(struct bpf_func_state *dst, const struct bpf_func_state *src)                       \

688         if (WARN_ON_ONCE(dst->COUNT < src->COUNT)) {                                                                   \

690             memset(dst, 0, sizeof(*dst));                                                                              \

693         memcpy(dst->FIELD, src->FIELD, sizeof(*src->FIELD) * (src->COUNT / (SIZE)));                                   \

795 static int transfer_reference_state(struct bpf_func_state *dst, struct bpf_func_state *src)

797     int err = realloc_reference_state(dst, src->acquired_refs, false);

801     err = copy_reference_state(dst, src);

839 /* copy verifier state from src to dst growing dst stack space

842 static int copy_func_state(struct bpf_func_state *dst, const struct bpf_func_state *src)

846     err = realloc_func_state(dst, src->allocated_stack, src->acquired_refs, false);

850     memcpy(dst, src, offsetof(struct bpf_func_state, acquired_refs));

851     err = copy_reference_state(dst, src);

855     return copy_stack_state(dst, src);

860     struct bpf_func_state *dst;

874     /* if dst has more stack frames then src frame, free them */

887         dst = dst_state->frame[i];

888         if (!dst) {

889             dst = kzalloc(sizeof(*dst), GFP_KERNEL);

890             if (!dst) {

893             dst_state->frame[i] = dst;

895         err = copy_func_state(dst, src->frame[i]);

1707     /* The dst will be zero extended, so won't be sub-register anymore. */

3794                  * insn. When the dst is PTR, it is for sure not

5809      * sits in dst, then we temporarily need to move ptr there

5810      * to simulate dst (== 0) +/-= ptr. Needed, for example,

5845     u32 dst = insn->dst_reg, src = insn->src_reg;

5849             verbose(env, "R%d has unknown scalar with mixed signed bounds, %s\n", off_reg == dst_reg ? dst : src, err);

5852             verbose(env, "R%d has pointer with unsupported alu operation, %s\n", off_reg == dst_reg ? src : dst, err);

5855             verbose(env, "R%d tried to %s from different maps, paths or scalars, %s\n", dst, op, err);

5858             verbose(env, "R%d tried to %s beyond pointer bounds, %s\n", dst, op, err);

5861             verbose(env, "R%d could not be pushed for speculative verification, %s\n", dst, err);

5906     u32 dst = insn->dst_reg;

5917             if (check_stack_access_for_ptr_arithmetic(env, dst, dst_reg, dst_reg->off + dst_reg->var_off.value)) {

5922             if (check_map_access(env, dst, dst_reg->off, 1, false)) {

5926                         dst);

5955     u32 dst = insn->dst_reg;

5958     dst_reg = &regs[dst];

5961         /* Taint dst register if offset had invalid bounds derived from

5975         verbose(env, "R%d 32-bit pointer arithmetic prohibited\n", dst);

5980         verbose(env, "R%d pointer arithmetic on %s prohibited, null-check it first\n", dst,

5998             verbose(env, "R%d pointer arithmetic on %s prohibited\n", dst, reg_type_str(env, ptr_reg->type));

6078                 verbose(env, "R%d tried to subtract pointer from scalar\n", dst);

6086                 verbose(env, "R%d subtraction from stack pointer prohibited\n", dst);

6136             verbose(env, "R%d bitwise operator %s on pointer prohibited\n", dst, bpf_alu_string[opcode >> 0x4]);

6140             verbose(env, "R%d pointer arithmetic with %s operator prohibited\n", dst, bpf_alu_string[opcode >> 0x4]);

6740             /* Taint dst register if offset had invalid bounds

6750             /* Taint dst register if offset had invalid bounds

7024                     /* Assign src and dst registers the same ID

7167      * pkt_data in dst register:

7923      * our min/max values for our dst register.