// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2021 Facebook */ #include #include #include "bpf_misc.h" #include "../test_kmods/bpf_testmod_kfunc.h" 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";