// SPDX-License-Identifier: GPL-2.0
/* Tests for callx: indirect calls of bpf subprogs */
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include "bpf_misc.h"
#include "../../../include/linux/filter.h"
/* gcc doesn't support indirect calls */
#if defined(__clang__) && (defined(__TARGET_ARCH_x86) || defined(__TARGET_ARCH_arm64) || \
(defined(__TARGET_ARCH_riscv) && __riscv_xlen == 64))
#define CALLX_INSN(DST, SRC, OFF, IMM) \
BPF_RAW_INSN(BPF_JMP | BPF_CALL | BPF_X, DST, SRC, OFF, IMM)
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
__uint(max_entries, 1);
__type(key, int);
__type(value, long long);
} map_array SEC(".maps");
struct val_with_lock {
struct bpf_spin_lock lock;
int cnt;
};
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
__uint(max_entries, 1);
__type(key, int);
__type(value, struct val_with_lock);
} map_lock SEC(".maps");
struct {
__uint(type, BPF_MAP_TYPE_PROG_ARRAY);
__uint(max_entries, 1);
__uint(key_size, sizeof(int));
__uint(value_size, sizeof(int));
} map_prog SEC(".maps");
__naked __noinline __used
static unsigned long add1(void)
{
asm volatile (
"r0 = r1;"
"r0 += 1;"
"exit;"
);
}
__naked __noinline __used
static unsigned long add2(void)
{
asm volatile (
"r0 = r1;"
"r0 += 2;"
"exit;"
);
}
/* apply(fn, x) { return fn(x); } */
__naked __noinline __used
static unsigned long apply(void)
{
asm volatile (
"r3 = r1;"
"r1 = r2;"
"callx r3;"
"exit;"
);
}
SEC("socket")
__success __retval(6)
__naked void callx_basic(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
/* callx is printed by the verifier log and xlated dump */
SEC("socket")
__success __log_level(2)
__msg("(8d) callx r2")
__xlated("callx r2")
__naked void callx_disasm(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
/* different callees are called by the same callx on different paths */
SEC("socket")
__success __retval(11)
__naked void callx_two_callees(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"r6 = r0;"
"r6 &= 1;"
"r2 = %[add1] ll;"
"if r6 == 0 goto +2;"
"r2 = %[add2] ll;"
"r1 = 10;"
"callx r2;"
/* add1(10) - 0 or add2(10) - 1 */
"r0 -= r6;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(add1),
__imm_addr(add2)
: __clobber_all);
}
/* pointer to a function is passed as an argument */
SEC("socket")
__success __retval(45)
__naked void callx_fn_as_arg(void)
{
asm volatile (
"r1 = %[add2] ll;"
"r2 = 40;"
"call apply;"
"r6 = r0;"
"r1 = %[add1] ll;"
"r2 = 2;"
"call apply;"
"r0 += r6;"
"exit;"
:
: __imm_addr(add1),
__imm_addr(add2)
: __clobber_all);
}
__naked __noinline __used
static unsigned long get_add1(void)
{
asm volatile (
"r0 = %[add1] ll;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
/* pointer to a function is returned from a subprog and called via r0 */
SEC("socket")
__success __retval(2)
__naked void callx_r0(void)
{
asm volatile (
"call get_add1;"
"r1 = 1;"
"callx r0;"
"exit;"
::: __clobber_all);
}
/* pointer to a function survives spill/fill */
SEC("socket")
__success __retval(9)
__naked void callx_spill_fill(void)
{
asm volatile (
"r2 = %[add2] ll;"
"*(u64 *)(r10 - 8) = r2;"
"call %[bpf_get_prandom_u32];"
"r1 = 7;"
"r9 = *(u64 *)(r10 - 8);"
"callx r9;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(add2)
: __clobber_all);
}
__naked __noinline __used
static unsigned long clobber_callee_saved(void)
{
asm volatile (
"r6 = 100;"
"r7 = 100;"
"r8 = 100;"
"r9 = 100;"
"r0 = r1;"
"exit;"
);
}
/* r6-r9 are preserved across callx */
SEC("socket")
__success __retval(11)
__naked void callx_callee_saved_regs(void)
{
asm volatile (
"r6 = 1;"
"r7 = 2;"
"r8 = 3;"
"r9 = 4;"
"r1 = 1;"
"r2 = %[clobber_callee_saved] ll;"
"callx r2;"
"r0 += r6;"
"r0 += r7;"
"r0 += r8;"
"r0 += r9;"
"exit;"
:
: __imm_addr(clobber_callee_saved)
: __clobber_all);
}
/* r1-r5 are scratched by callx */
SEC("socket")
__failure __msg("R1 !read_ok")
__naked void callx_scratches_args(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
"callx r2;"
"r0 = r1;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
/* return value of the callee is tracked */
SEC("socket")
__success __log_level(2)
__msg("to caller at 4:")
__msg("R0=6")
__naked void callx_retval_is_tracked(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
__naked __noinline __used
static unsigned long write42(void)
{
asm volatile (
"r2 = 42;"
"*(u64 *)(r1 + 0) = r2;"
"r0 = 0;"
"exit;"
);
}
/* callee writes into the stack of the caller */
SEC("socket")
__success __retval(42)
__naked void callx_callee_writes_caller_stack(void)
{
asm volatile (
"r1 = 0;"
"*(u64 *)(r10 - 8) = r1;"
"r1 = r10;"
"r1 += -8;"
"r2 = %[write42] ll;"
"callx r2;"
"r0 = *(u64 *)(r10 - 8);"
"exit;"
:
: __imm_addr(write42)
: __clobber_all);
}
/* callee can store a pointer that is not FP-derived over a pointer spilled by the caller */
SEC("socket")
__success __log_level(2)
__msg("r0 = *(u64 *)(r10 -16) // fp-16=fp0-8|fp0+0")
__naked void callx_callee_can_overwrite_spilled_fp(void)
{
asm volatile (
"r1 = r10;"
"r1 += -8;"
"*(u64 *)(r10 - 16) = r1;"
"r2 = %[write42] ll;"
"callx r2;"
"r0 = *(u64 *)(r10 - 16);"
"r0 = 0;"
"exit;"
:
: __imm_addr(write42)
: __clobber_all);
}
SEC("socket")
__failure __msg("R1 has type scalar, expected func")
__naked void callx_scalar(void)
{
asm volatile (
"r1 = 0;"
"callx r1;"
"exit;"
::: __clobber_all);
}
SEC("socket")
__failure __msg("R2 !read_ok")
__naked void callx_uninit_reg(void)
{
asm volatile (
"callx r2;"
"exit;"
::: __clobber_all);
}
SEC("socket")
__failure __msg("R10 has type fp, expected func")
__naked void callx_fp(void)
{
asm volatile (
"callx r10;"
"exit;"
::: __clobber_all);
}
SEC("socket")
__failure __msg("R1 has type map_value, expected func")
__naked void callx_map_value(void)
{
asm volatile (
"r1 = %[map_array] ll;"
"r2 = r10;"
"r2 += -4;"
"r3 = 0;"
"*(u32 *)(r2 + 0) = r3;"
"call %[bpf_map_lookup_elem];"
"if r0 == 0 goto 1f;"
"r1 = r0;"
"callx r1;"
"1:"
"r0 = 0;"
"exit;"
:
: __imm(bpf_map_lookup_elem),
__imm_addr(map_array)
: __clobber_all);
}
/* the address of a subprog can't be modified before the call */
SEC("socket")
__failure __msg("dereference of modified func ptr R2 off=8 disallowed")
__naked void callx_modified_ptr(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
"r2 += 8;"
"callx r2;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
SEC("socket")
__failure __msg("variable func access var_off=")
__naked void callx_variable_ptr(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"r0 &= 8;"
"r2 = %[add1] ll;"
"r2 += r0;"
"r1 = 5;"
"callx r2;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(add1)
: __clobber_all);
}
__noinline __used
int global_add3(int x)
{
return x + 3;
}
/* only static subprogs can be called via callx */
SEC("socket")
__failure __msg("callback function not static")
__naked void callx_global_func(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[global_add3] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(global_add3)
: __clobber_all);
}
#define DEFINE_CALLX_RESERVED_FIELDS_PROG(NAME, SRC_REG, OFF, IMM) \
SEC("socket") \
__failure __msg("BPF_CALL|BPF_X uses reserved fields") \
__naked void callx_reserved_field_ ## NAME(void) \
{ \
asm volatile ( \
"r1 = 5;" \
"r2 = %[add1] ll;" \
".8byte %[callx_r2];" \
"exit;" \
: \
: __imm_addr(add1), \
__imm_insn(callx_r2, CALLX_INSN(BPF_REG_2, (SRC_REG), (OFF), (IMM))) \
: __clobber_all); \
}
DEFINE_CALLX_RESERVED_FIELDS_PROG(src_reg, BPF_REG_1, 0, 0)
DEFINE_CALLX_RESERVED_FIELDS_PROG(off, BPF_REG_0, 1, 0)
DEFINE_CALLX_RESERVED_FIELDS_PROG(imm, BPF_REG_0, 0, 1)
SEC("socket")
__failure __msg("unknown opcode 8e")
__naked void callx_jmp32(void)
{
asm volatile (
"r1 = 5;"
"r2 = %[add1] ll;"
".8byte %[callx32_r2];"
"exit;"
:
: __imm_addr(add1),
__imm_insn(callx32_r2,
BPF_RAW_INSN(BPF_JMP32 | BPF_CALL | BPF_X, BPF_REG_2, 0, 0, 0))
: __clobber_all);
}
/* similar to calls of static subprogs callx is allowed under a lock */
SEC("tc")
__success __retval(3)
__naked void callx_under_lock(void)
{
asm volatile (
"r1 = 0;"
"*(u32 *)(r10 - 4) = r1;"
"r2 = r10;"
"r2 += -4;"
"r1 = %[map_lock] ll;"
"call %[bpf_map_lookup_elem];"
"if r0 != 0 goto 1f;"
"exit;"
"1:"
"r6 = r0;"
"r1 = r6;"
"call %[bpf_spin_lock];"
"r1 = 1;"
"r2 = %[add2] ll;"
"callx r2;"
"r7 = r0;"
"r1 = r6;"
"call %[bpf_spin_unlock];"
"r0 = r7;"
"exit;"
:
: __imm(bpf_map_lookup_elem),
__imm(bpf_spin_lock),
__imm(bpf_spin_unlock),
__imm_addr(map_lock),
__imm_addr(add2)
: __clobber_all);
}
/* helpers are still not allowed under a lock in the callee */
__naked __noinline __used
static unsigned long call_helper(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"exit;"
:
: __imm(bpf_get_prandom_u32)
: __clobber_all);
}
SEC("tc")
__failure __msg("function calls are not allowed while holding a lock")
__naked void callx_helper_under_lock(void)
{
asm volatile (
"r1 = 0;"
"*(u32 *)(r10 - 4) = r1;"
"r2 = r10;"
"r2 += -4;"
"r1 = %[map_lock] ll;"
"call %[bpf_map_lookup_elem];"
"if r0 != 0 goto 1f;"
"exit;"
"1:"
"r6 = r0;"
"r1 = r6;"
"call %[bpf_spin_lock];"
"r2 = %[call_helper] ll;"
"callx r2;"
"r1 = r6;"
"call %[bpf_spin_unlock];"
"r0 = 0;"
"exit;"
:
: __imm(bpf_map_lookup_elem),
__imm(bpf_spin_lock),
__imm(bpf_spin_unlock),
__imm_addr(map_lock),
__imm_addr(call_helper)
: __clobber_all);
}
/* self(fn) { return fn(fn); } */
__naked __noinline __used
static unsigned long self(void)
{
asm volatile (
"callx r1;"
"exit;"
);
}
/* unbounded recursion is caught by the main verification pass */
SEC("socket")
__failure __msg("frames is too deep")
__naked void callx_unbounded_recursion(void)
{
asm volatile (
"r1 = %[self] ll;"
"call self;"
"exit;"
:
: __imm_addr(self)
: __clobber_all);
}
/* countdown(fn, n) { return n ? fn(fn, n - 1) : 0; } */
__naked __noinline __used
static unsigned long countdown(void)
{
asm volatile (
"r0 = 0;"
"if r2 == 0 goto 1f;"
"r2 += -1;"
"callx r1;"
"1:"
"exit;"
);
}
/*
* The depth of the recursion is known to the main verification pass,
* but recursive calls are not allowed regardless.
*/
SEC("socket")
__failure __msg("recursive call from countdown() to countdown()")
__naked void callx_bounded_recursion(void)
{
asm volatile (
"r1 = %[countdown] ll;"
"r2 = 2;"
"call countdown;"
"exit;"
:
: __imm_addr(countdown)
: __clobber_all);
}
/* ping(fn1, fn2, n) { return n ? fn2(fn2, fn1, n - 1) : 0; } */
__naked __noinline __used
static unsigned long ping(void)
{
asm volatile (
"r0 = 0;"
"if r3 == 0 goto 1f;"
"r3 += -1;"
"r4 = r1;"
"r1 = r2;"
"r2 = r4;"
"callx r1;"
"1:"
"exit;"
);
}
__naked __noinline __used
static unsigned long pong(void)
{
asm volatile (
"r0 = 0;"
"if r3 == 0 goto 1f;"
"r3 += -1;"
"r4 = r1;"
"r1 = r2;"
"r2 = r4;"
"callx r1;"
"1:"
"exit;"
);
}
SEC("socket")
__failure __msg("recursive call from")
__naked void callx_mutual_recursion(void)
{
asm volatile (
"r1 = %[ping] ll;"
"r2 = %[pong] ll;"
"r3 = 3;"
"call ping;"
"exit;"
:
: __imm_addr(ping),
__imm_addr(pong)
: __clobber_all);
}
__naked __noinline __used
static unsigned long use_stack_304(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 304) = r0;"
"exit;"
);
}
/* Four 480-byte frames, deeper than any budget together with their caller */
__naked __noinline __used
static unsigned long use_stack_480_0(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 480) = r0;"
"exit;"
);
}
__naked __noinline __used
static unsigned long use_stack_480_1(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 480) = r0;"
"call use_stack_480_0;"
"exit;"
);
}
__naked __noinline __used
static unsigned long use_stack_480_2(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 480) = r0;"
"call use_stack_480_1;"
"exit;"
);
}
__naked __noinline __used
static unsigned long use_stack_480_3(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 480) = r0;"
"call use_stack_480_2;"
"exit;"
);
}
/* stack of the callee of callx is accounted */
SEC("socket")
__failure __msg("combined stack size of {{[0-9]+}} calls is")
__naked void callx_stack_depth(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 480) = r0;"
"r2 = %[use_stack_480_3] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(use_stack_480_3)
: __clobber_all);
}
/* apply_stack_304(fn) { char buf[304]; return fn(); } */
__naked __noinline __used
static unsigned long apply_stack_304(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 304) = r0;"
"callx r1;"
"exit;"
);
}
/*
* The address of use_stack_480_3() is taken by the main prog that doesn't
* use stack, but it is called from apply_stack_304().
*/
SEC("socket")
__failure __msg("combined stack size of {{[0-9]+}} calls is")
__naked void callx_stack_depth_nested(void)
{
asm volatile (
"r1 = %[use_stack_480_3] ll;"
"call apply_stack_304;"
"exit;"
:
: __imm_addr(use_stack_480_3)
: __clobber_all);
}
SEC("socket")
__success __retval(0)
__naked void callx_stack_depth_ok(void)
{
asm volatile (
"r0 = 0;"
"*(u64 *)(r10 - 200) = r0;"
"r2 = %[use_stack_304] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(use_stack_304)
: __clobber_all);
}
__naked __noinline __used
static unsigned long do_tail_call(void)
{
asm volatile (
"r2 = %[map_prog] ll;"
"r3 = 0;"
"call %[bpf_tail_call];"
"r0 = 0;"
"exit;"
:
: __imm(bpf_tail_call),
__imm_addr(map_prog)
: __clobber_all);
}
SEC("socket")
__failure __msg("tail_calls are not allowed in functions called via callx")
__naked void callx_tail_call_in_callee(void)
{
asm volatile (
"r2 = %[do_tail_call] ll;"
"callx r2;"
"exit;"
:
: __imm_addr(do_tail_call)
: __clobber_all);
}
/* tail call in the caller of callx is fine */
SEC("socket")
__success __retval(3)
__naked void callx_tail_call_in_caller(void)
{
asm volatile (
"r6 = r1;"
"r1 = 2;"
"r2 = %[add1] ll;"
"callx r2;"
"r7 = r0;"
"r1 = r6;"
"r2 = %[map_prog] ll;"
"r3 = 0;"
"call %[bpf_tail_call];"
"r0 = r7;"
"exit;"
:
: __imm(bpf_tail_call),
__imm_addr(map_prog),
__imm_addr(add1)
: __clobber_all);
}
/* read_idx(p) { return ((char *)map_value)[*p]; } */
__naked __noinline __used
static unsigned long read_idx(void)
{
asm volatile (
"r6 = *(u64 *)(r1 + 0);"
"r1 = 0;"
"*(u32 *)(r10 - 4) = r1;"
"r2 = r10;"
"r2 += -4;"
"r1 = %[map_array] ll;"
"call %[bpf_map_lookup_elem];"
"if r0 == 0 goto 1f;"
"r0 += r6;"
"r0 = *(u8 *)(r0 + 0);"
"1:"
"exit;"
:
: __imm(bpf_map_lookup_elem),
__imm_addr(map_array)
: __clobber_all);
}
/*
* Stack slots of the caller that might be read by the callee of callx
* have to be considered alive at the checkpoints before callx and
* inside of the callee. Otherwise the state with fp-8 == 1000 is pruned
* and out of bounds access in read_idx() goes unnoticed.
*/
SEC("socket")
__failure __msg("invalid access to map value, value_size=8 off=1000 size=1")
__flag(BPF_F_TEST_STATE_FREQ)
__naked void callx_callee_reads_caller_stack(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"r1 = 1000;"
"*(u64 *)(r10 - 8) = r1;"
"if r0 == 0 goto 1f;"
"r1 = 0;"
"*(u64 *)(r10 - 8) = r1;"
"1:"
"r1 = r10;"
"r1 += -8;"
"r2 = %[read_idx] ll;"
"callx r2;"
"r0 = 0;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(read_idx)
: __clobber_all);
}
/* in bounds access in read_idx() is fine */
SEC("socket")
__success __retval(0)
__flag(BPF_F_TEST_STATE_FREQ)
__naked void callx_callee_reads_caller_stack_ok(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"r1 = 7;"
"*(u64 *)(r10 - 8) = r1;"
"if r0 == 0 goto 1f;"
"r1 = 0;"
"*(u64 *)(r10 - 8) = r1;"
"1:"
"r1 = r10;"
"r1 += -8;"
"r2 = %[read_idx] ll;"
"callx r2;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(read_idx)
: __clobber_all);
}
/* same as above, but the pointer to the stack is passed through one more frame */
SEC("socket")
__failure __msg("invalid access to map value, value_size=8 off=1000 size=1")
__flag(BPF_F_TEST_STATE_FREQ)
__naked void callx_callee_reads_caller_stack_nested(void)
{
asm volatile (
"call %[bpf_get_prandom_u32];"
"r1 = 1000;"
"*(u64 *)(r10 - 8) = r1;"
"if r0 == 0 goto 1f;"
"r1 = 0;"
"*(u64 *)(r10 - 8) = r1;"
"1:"
"r1 = %[read_idx] ll;"
"r2 = r10;"
"r2 += -8;"
"call apply;"
"r0 = 0;"
"exit;"
:
: __imm(bpf_get_prandom_u32),
__imm_addr(read_idx)
: __clobber_all);
}
/* registers that are constant before callx are not constant after it */
SEC("socket")
__success __retval(1)
__naked void callx_clobbers_const_regs(void)
{
asm volatile (
"r0 = 0;"
"r1 = 0;"
"r2 = %[add1] ll;"
"callx r2;"
/* dead branch pruning must not assume that r0 is still 0 */
"if r0 == 0 goto 1f;"
"r0 = 1;"
"exit;"
"1:"
"r0 = 2;"
"exit;"
:
: __imm_addr(add1)
: __clobber_all);
}
/* scalar argument passed through callx is tracked precisely */
__naked __noinline __used
static unsigned long identity(void)
{
asm volatile (
"r0 = r1;"
"exit;"
);
}
long long vals[] SEC(".data.vals") = {1, 2, 3, 4};
SEC("socket")
__success __log_level(2)
__msg("mark_precise: frame0: regs=r0 stack= before 12: (95) exit")
__msg("mark_precise: frame1: regs=r0 stack= before 11: (bf) r0 = r1")
__msg("mark_precise: frame1: regs=r1 stack= before 4: (8d) callx r2")
__msg("mark_precise: frame0: regs=r1 stack= before 3: (bf) r1 = r6")
__msg("mark_precise: frame0: regs=r6 stack= before 2: (b7) r6 = 3")
__retval(4)
__naked void callx_precision(void)
{
asm volatile (
"r2 = %[identity] ll;"
"r6 = 3;"
"r1 = r6;"
"callx r2;"
"r0 *= 8;"
"r1 = %[vals] ll;"
"r1 += r0;"
"r0 = *(u64 *)(r1 + 0);"
"exit;"
:
: __imm_addr(identity),
__imm_addr(vals)
: __clobber_all);
}
/*
* The address of a function that is never called is valid. The function is
* the last one in the program.
*/
SEC("socket")
__success __retval(6)
__naked void callx_addr_of_dead_func(void)
{
asm volatile (
"r6 = %[add1] ll;"
"r7 = %[add2] ll;"
"r1 = 5;"
"callx r6;"
"if r7 != r6 goto +1;"
"r0 = 0;"
"exit;"
:
: __imm_addr(add1), __imm_addr(add2)
: __clobber_all);
}
/* and when it's followed by another function */
SEC("socket")
__success __retval(7)
__naked void callx_addr_of_dead_func_first(void)
{
asm volatile (
"r7 = %[add1] ll;"
"r6 = %[add2] ll;"
"r1 = 5;"
"callx r6;"
"if r7 != r6 goto +1;"
"r0 = 0;"
"exit;"
:
: __imm_addr(add1), __imm_addr(add2)
: __clobber_all);
}
/* the same without callx */
SEC("socket")
__success __retval(6)
__naked void call_addr_of_dead_func(void)
{
asm volatile (
"r1 = 5;"
"call add1;"
"r7 = %[add2] ll;"
"exit;"
:
: __imm_addr(add2)
: __clobber_all);
}
/* function pointers in C */
typedef int (*op_fn)(int);
static __noinline int mul3(int x)
{
return x * 3;
}
static __noinline int sub7(int x)
{
return x - 7;
}
static __noinline int apply_op(op_fn op, int x)
{
return op(x);
}
SEC("socket")
__success __retval(36)
int callx_c_fn_as_arg(void *ctx)
{
/* (5 * 3) + (28 - 7) */
return apply_op(mul3, 5) + apply_op(sub7, 28);
}
SEC("socket")
__success __retval(30)
int callx_c_select(void *ctx)
{
__u32 rnd = bpf_get_prandom_u32() & 1;
op_fn op = rnd ? mul3 : sub7;
int x = rnd ? 10 : 37;
/* 10 * 3 or 37 - 7 */
return op(x);
}
struct ops {
op_fn first;
op_fn second;
int bias;
};
static __noinline int run_ops(const struct ops *ops, int x)
{
return ops->second(ops->first(x)) + ops->bias;
}
SEC("socket")
__success __retval(100)
int callx_c_ops_on_stack(void *ctx)
{
struct ops a, b;
/* avoid an initializer with function pointers in .rodata */
a.first = mul3;
a.second = sub7;
a.bias = 10;
b.first = sub7;
b.second = mul3;
b.bias = 1;
/* ((7 * 3) - 7 + 10) + ((32 - 7) * 3 + 1) */
return run_ops(&a, 7) + run_ops(&b, 32);
}
#else
SEC("socket")
__success
int dummy(void *ctx)
{
return 0;
}
#endif
char _license[] SEC("license") = "GPL";