tools/testing/selftests/bpf/progs/kfunc_call_test.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2021 Facebook */
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
#include "bpf_misc.h"
#include "../test_kmods/bpf_testmod_kfunc.h"

static struct bpf_spin_lock kfunc_call_lock SEC(".data.A");

SEC("tc")
int kfunc_call_test_spin_lock_safe(struct __sk_buff *skb)
{
	bpf_spin_lock(&kfunc_call_lock);
	bpf_testmod_test_mod_kfunc(42);
	bpf_spin_unlock(&kfunc_call_lock);

	return 0;
}

SEC("tc")
int kfunc_call_test5(struct __sk_buff *skb)
{
	struct bpf_sock *sk = skb->sk;
	int ret;
	u32 val32;
	u16 val16;
	u8 val8;

	if (!sk)
		return -1;

	sk = bpf_sk_fullsock(sk);
	if (!sk)
		return -1;

	/*
	 * Test with constant values to verify zero-extension.
	 * ISA-dependent BPF asm:
	 *   With ALU32:    w1 = 0xFF; w2 = 0xFFFF; w3 = 0xFFFFffff
	 *   Without ALU32: r1 = 0xFF; r2 = 0xFFFF; r3 = 0xFFFFffff
	 * Both zero-extend to 64-bit before the kfunc call.
	 */
	ret = bpf_kfunc_call_test5(0xFF, 0xFFFF, 0xFFFFffffULL);
	if (ret)
		return ret;

	val32 = bpf_get_prandom_u32();
	val16 = val32 & 0xFFFF;
	val8 = val32 & 0xFF;
	ret = bpf_kfunc_call_test5(val8, val16, val32);
	if (ret)
		return ret;

	/*
	 * Test multiplication with different operand sizes:
	 *
	 * val8 * 0xFF:
	 *   - Both operands promote to int (32-bit signed)
	 *   - Result: 32-bit multiplication, truncated to u8, then zero-extended
	 *
	 * val16 * 0xFFFF:
	 *   - Both operands promote to int (32-bit signed)
	 *   - Result: 32-bit multiplication, truncated to u16, then zero-extended
	 *
	 * val32 * 0xFFFFffffULL:
	 *   - val32 (u32) promotes to unsigned long long (due to ULL suffix)
	 *   - Result: 64-bit unsigned multiplication, truncated to u32, then zero-extended
	 */
	ret = bpf_kfunc_call_test5(val8 * 0xFF, val16 * 0xFFFF, val32 * 0xFFFFffffULL);
	if (ret)
		return ret;

	return 0;
}

/*
 * Assembly version testing the multiplication edge case explicitly.
 * This ensures consistent testing across different ISA versions.
 */
SEC("tc")
__naked int kfunc_call_test5_asm(void)
{
	asm volatile (
		/* Get a random u32 value */
		"call %[bpf_get_prandom_u32];"
		"r6 = r0;"              /* Save val32 in r6 */

		/* Prepare first argument: val8 * 0xFF */
		"r1 = r6;"
		"r1 &= 0xFF;"           /* val8 = val32 & 0xFF */
		"r7 = 0xFF;"
		"r1 *= r7;"             /* 64-bit mult: r1 = r1 * r7 */

		/* Prepare second argument: val16 * 0xFFFF */
		"r2 = r6;"
		"r2 &= 0xFFFF;"         /* val16 = val32 & 0xFFFF */
		"r7 = 0xFFFF;"
		"r2 *= r7;"             /* 64-bit mult: r2 = r2 * r7 */

		/* Prepare third argument: val32 * 0xFFFFffff */
		"r3 = r6;"              /* val32 */
		"r7 = 0xFFFFffff;"
		"r3 *= r7;"             /* 64-bit mult: r3 = r3 * r7 */

		/* Call kfunc with multiplication results */
		"call bpf_kfunc_call_test5;"

		/* Check return value */
		"if r0 != 0 goto exit_%=;"
		"r0 = 0;"
		"exit_%=: exit;"
		:
		: __imm(bpf_get_prandom_u32)
		: __clobber_all);
}

SEC("tc")
int kfunc_call_test4(struct __sk_buff *skb)
{
	struct bpf_sock *sk = skb->sk;
	long tmp;

	if (!sk)
		return -1;

	sk = bpf_sk_fullsock(sk);
	if (!sk)
		return -1;

	tmp = bpf_kfunc_call_test4(-3, -30, -200, -1000);
	return (tmp >> 32) + tmp;
}

SEC("tc")
int kfunc_call_test2(struct __sk_buff *skb)
{
	struct bpf_sock *sk = skb->sk;

	if (!sk)
		return -1;

	sk = bpf_sk_fullsock(sk);
	if (!sk)
		return -1;

	return bpf_kfunc_call_test2((struct sock *)sk, 1, 2);
}

SEC("tc")
int kfunc_call_test1(struct __sk_buff *skb)
{
	struct bpf_sock *sk = skb->sk;
	__u64 a = 1ULL << 32;
	__u32 ret;

	if (!sk)
		return -1;

	sk = bpf_sk_fullsock(sk);
	if (!sk)
		return -1;

	a = bpf_kfunc_call_test1((struct sock *)sk, 1, a | 2, 3, a | 4);
	ret = a >> 32;   /* ret should be 2 */
	ret += (__u32)a; /* ret should be 12 */

	return ret;
}

SEC("tc")
int kfunc_call_test_ref_btf_id(struct __sk_buff *skb)
{
	struct prog_test_ref_kfunc *pt;
	unsigned long s = 0;
	int ret = 0;

	pt = bpf_kfunc_call_test_acquire(&s);
	if (pt) {
		if (pt->a != 42 || pt->b != 108)
			ret = -1;
		bpf_kfunc_call_test_release(pt);
	}
	return ret;
}

SEC("tc")
int kfunc_call_test_pass(struct __sk_buff *skb)
{
	struct prog_test_pass1 p1 = {};
	struct prog_test_pass2 p2 = {};
	short a = 0;
	__u64 b = 0;
	long c = 0;
	char d = 0;
	int e = 0;

	bpf_kfunc_call_test_pass_ctx(skb);
	bpf_kfunc_call_test_pass1(&p1);
	bpf_kfunc_call_test_pass2(&p2);

	bpf_kfunc_call_test_mem_len_pass1(&a, sizeof(a));
	bpf_kfunc_call_test_mem_len_pass1(&b, sizeof(b));
	bpf_kfunc_call_test_mem_len_pass1(&c, sizeof(c));
	bpf_kfunc_call_test_mem_len_pass1(&d, sizeof(d));
	bpf_kfunc_call_test_mem_len_pass1(&e, sizeof(e));
	bpf_kfunc_call_test_mem_len_fail2(&b, -1);

	return 0;
}

struct syscall_test_args {
	__u8 data[16];
	size_t size;
};

SEC("syscall")
int kfunc_syscall_test(struct syscall_test_args *args)
{
	const long size = args->size;

	if (size > sizeof(args->data))
		return -7; /* -E2BIG */

	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(args->data));
	bpf_kfunc_call_test_mem_len_pass1(&args->data, sizeof(*args));
	bpf_kfunc_call_test_mem_len_pass1(&args->data, size);

	return 0;
}

SEC("syscall")
int kfunc_syscall_test_null(struct syscall_test_args *args)
{
	/* Must be called with args as a NULL pointer
	 * we do not check for it to have the verifier consider that
	 * the pointer might not be null, and so we can load it.
	 *
	 * So the following can not be added:
	 *
	 * if (args)
	 *      return -22;
	 */

	bpf_kfunc_call_test_mem_len_pass1(args, 0);

	return 0;
}

SEC("tc")
int kfunc_call_test_get_mem(struct __sk_buff *skb)
{
	struct prog_test_ref_kfunc *pt;
	unsigned long s = 0;
	int *p = NULL;
	int ret = 0;

	pt = bpf_kfunc_call_test_acquire(&s);
	if (pt) {
		p = bpf_kfunc_call_test_get_rdwr_mem(pt, 2 * sizeof(int));
		if (p) {
			p[0] = 42;
			ret = p[1]; /* 108 */
		} else {
			ret = -1;
		}

		if (ret >= 0) {
			p = bpf_kfunc_call_test_get_rdonly_mem(pt, 2 * sizeof(int));
			if (p)
				ret = p[0]; /* 42 */
			else
				ret = -1;
		}

		bpf_kfunc_call_test_release(pt);
	}
	return ret;
}

SEC("tc")
int kfunc_call_test_static_unused_arg(struct __sk_buff *skb)
{

	u32 expected = 5, actual;

	actual = bpf_kfunc_call_test_static_unused_arg(expected, 0xdeadbeef);
	return actual != expected ? -1 : 0;
}

struct ctx_val {
	struct bpf_testmod_ctx __kptr *ctx;
};

struct {
	__uint(type, BPF_MAP_TYPE_ARRAY);
	__uint(max_entries, 1);
	__type(key, int);
	__type(value, struct ctx_val);
} ctx_map SEC(".maps");

SEC("tc")
int kfunc_call_ctx(struct __sk_buff *skb)
{
	struct bpf_testmod_ctx *ctx;
	int err = 0;

	ctx = bpf_testmod_ctx_create(&err);
	if (!ctx && !err)
		err = -1;
	if (ctx) {
		int key = 0;
		struct ctx_val *ctx_val = bpf_map_lookup_elem(&ctx_map, &key);

		/* Transfer ctx to map to be freed via implicit dtor call
		 * on cleanup.
		 */
		if (ctx_val)
			ctx = bpf_kptr_xchg(&ctx_val->ctx, ctx);
		if (ctx) {
			bpf_testmod_ctx_release(ctx);
			err = -1;
		}
	}
	return err;
}

char _license[] SEC("license") = "GPL";