Lines Matching defs:caller
2293 * by the caller when necessary.
2337 * The caller state doesn't matter.
2764 * and let the caller decide what to do with NULL kfunc->flags.
3388 /* mark_chain_precision_batch() assumes that env->bt is set in the caller to
3534 /* caller checked that off % size == 0 and -MAX_BPF_STACK <= off < 0,
3607 verbose(env, "cannot spill pointers to stack into stack frame of the caller\n");
3786 * SCALAR. This function does not deal with register filling; the caller must
3980 /* If dst_regno==-1, the caller is asking us whether
4078 * The caller must ensure that the offset falls within the allocated stack
4144 * The caller must ensure that the offset falls within the maximum stack size.
4221 struct bpf_func_state *caller, *cur;
4235 caller = vstate->frame[vstate->curframe - 1];
4236 arg = &caller->stack_arg_regs[spi];
4247 struct bpf_func_state *caller = cur_func(env);
4250 bt_set_frame_stack_arg_slot(&env->bt, caller->frameno, spi);
4263 static int check_outgoing_stack_args(struct bpf_verifier_env *env, struct bpf_func_state *caller,
4271 if (spi >= caller->out_stack_arg_cnt ||
4272 caller->stack_arg_regs[spi].type == NOT_INIT) {
4288 static struct bpf_reg_state *get_func_arg_reg(struct bpf_func_state *caller,
4294 return &caller->stack_arg_regs[arg - MAX_BPF_FUNC_REG_ARGS];
4686 /* Things we already checked for in check_map_access and caller:
5313 int ret_insn; /* caller instruction where we return to. */
5314 int caller; /* caller subprogram idx */
5333 /* no caller idx */
5334 dinfo[idx].caller = -1;
5341 for (tmp = idx; tmp >= 0; tmp = dinfo[tmp].caller) {
5350 * bpf2bpf calls get combined with tailcalls. Limit the caller's stack
5366 * of caller's stack as shown on the example above.
5403 for (tmp = idx; tmp >= 0; tmp = dinfo[tmp].caller)
5421 for (tmp = idx; tmp >= 0 && !err; tmp = dinfo[tmp].caller) {
5454 /* store caller info for after we return from callee */
5458 /* push caller idx into callee's dinfo */
5459 dinfo[sidx].caller = idx;
5484 for (tmp = idx; tmp >= 0; tmp = dinfo[tmp].caller) {
5506 if (frame == 0 && dinfo[idx].caller < 0)
5511 /* pop caller idx from callee */
5512 idx = dinfo[idx].caller;
5514 /* retrieve caller state from its frame */
8550 * can be non-zero unless the caller requires otherwise.
9626 struct bpf_func_state *caller,
9631 struct bpf_func_state *caller,
9638 struct bpf_func_state *caller, *callee;
9652 caller = state->frame[state->curframe];
9660 * callee can read/write into caller's stack
9667 err = set_callee_state_cb(env, caller, callee, callsite);
9687 struct bpf_func_state *caller = cur_func(env);
9698 err = check_outgoing_stack_args(env, caller, sub->arg_cnt,
9710 ret = check_outgoing_stack_args(env, caller, sub->arg_cnt,
9720 struct bpf_reg_state *reg = get_func_arg_reg(caller, regs, i);
9738 /* If function expects ctx type in BTF check that caller
9859 struct bpf_func_state *caller, *callee;
9862 caller = state->frame[state->curframe];
9863 err = btf_check_subprog_call(env, subprog, caller->regs);
9895 callee->async_entry_cnt = caller->async_entry_cnt + 1;
9898 err = set_callee_state_cb(env, caller, callee, insn_idx);
9919 caller->callback_depth = 0;
9932 struct bpf_func_state *caller;
9941 caller = state->frame[state->curframe];
9942 err = btf_check_subprog_call(env, subprog, caller->regs);
9983 bpf_diag_record_scrub(env, &caller->regs[BPF_REG_0], BPF_DIAG_MOD_CALLER_SAVED);
9985 bpf_diag_mod_begin(env, &caller->regs[BPF_REG_0], NULL, BPF_DIAG_MOD_WRITE);
9986 clear_caller_saved_regs(env, caller->regs);
9991 mark_reg_unknown(env, caller->regs, BPF_REG_0);
10011 * Track caller's total stack arg count (incoming + max outgoing).
10014 caller_info = &env->subprog_info[caller->subprogno];
10027 bpf_diag_record_scrub(env, &caller->regs[BPF_REG_0], BPF_DIAG_MOD_CALLER_SAVED);
10028 clear_caller_saved_regs(env, caller->regs);
10034 verbose(env, "caller:\n");
10035 print_verifier_state(env, state, caller->frameno, true);
10044 struct bpf_func_state *caller,
10052 callee->regs[BPF_REG_1] = caller->regs[BPF_REG_1];
10056 callee->regs[BPF_REG_2].map_ptr = caller->regs[BPF_REG_1].map_ptr;
10057 callee->regs[BPF_REG_2].map_uid = caller->regs[BPF_REG_1].map_uid;
10061 callee->regs[BPF_REG_3].map_ptr = caller->regs[BPF_REG_1].map_ptr;
10062 callee->regs[BPF_REG_3].map_uid = caller->regs[BPF_REG_1].map_uid;
10066 callee->regs[BPF_REG_4] = caller->regs[BPF_REG_3];
10074 struct bpf_func_state *caller,
10083 callee->regs[i] = caller->regs[i];
10088 struct bpf_func_state *caller,
10104 err = map->ops->map_set_for_each_callback_args(env, caller, callee);
10114 struct bpf_func_state *caller,
10123 callee->regs[BPF_REG_2] = caller->regs[BPF_REG_3];
10136 struct bpf_func_state *caller,
10140 struct bpf_map *map_ptr = caller->regs[BPF_REG_1].map_ptr;
10141 u32 map_uid = caller->regs[BPF_REG_1].map_uid;
10171 struct bpf_func_state *caller,
10180 callee->regs[BPF_REG_1] = caller->regs[BPF_REG_1];
10188 callee->regs[BPF_REG_3] = caller->regs[BPF_REG_4];
10199 struct bpf_func_state *caller,
10209 callee->regs[BPF_REG_2] = caller->regs[BPF_REG_3];
10222 struct bpf_func_state *caller,
10235 field = reg_find_field_offset(&caller->regs[BPF_REG_1],
10236 caller->regs[BPF_REG_1].var_off.value,
10255 struct bpf_func_state *caller,
10259 struct bpf_map *map_ptr = caller->regs[BPF_REG_3].map_ptr;
10260 u32 map_uid = caller->regs[BPF_REG_3].map_uid;
10302 struct bpf_func_state *caller)
10312 if (caller)
10313 caller->insns_subtotal += insns;
10364 struct bpf_func_state *caller, *callee;
10372 /* technically it's ok to return caller's stack pointer
10373 * (or caller's caller's pointer) back to the caller,
10378 verbose(env, "cannot return stack pointer to the caller\n");
10382 caller = state->frame[state->curframe - 1];
10406 /* return to the caller whatever r0 had in the callee */
10407 bpf_diag_mod_begin(env, &caller->regs[BPF_REG_0], r0, BPF_DIAG_MOD_WRITE);
10408 caller->regs[BPF_REG_0] = *r0;
10425 verbose(env, "to caller at %d:\n", *insn_idx);
10426 print_verifier_state(env, state, caller->frameno, true);
10428 account_processed_insns(env, callee, caller);
10433 invalidate_outgoing_stack_args(env, caller);
11103 /* reset caller saved regs */
11988 * type to our caller. When a set of conditions hold in the BTF type of
12185 * caller to pass in the underlying type.
12691 struct bpf_func_state *caller = cur_func(env);
12702 ret = check_outgoing_stack_args(env, caller, nargs, func_name, btf, args);
12710 struct bpf_reg_state *reg = get_func_arg_reg(caller, regs, i);
13207 struct bpf_reg_state *buff_reg = get_func_arg_reg(caller, regs, i - 1);
14179 struct bpf_func_state *caller = cur_func(env);
14180 struct bpf_subprog_info *caller_info = &env->subprog_info[caller->subprogno];
14574 * If we return -EACCES, caller may want to try again treating pointer as a
17402 /* reset caller saved regs to unreadable */
17695 /* Bitmask with 1s for all caller saved registers */
17763 * the caller saved registers defined by ABI.
17854 /* A bitmask specifying which caller saved registers are clobbered
18143 * for which reference_state must match caller reference
18635 * corresponding kernel module. To simplify caller's logic
19583 /* caller can pass either PTR_TO_ARENA or SCALAR */
20791 * New API: the caller passes fd_array_cnt and a continuous array that
20793 * the caller's array and resolve entries on the spot at each reference.