Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275// SPDX-License-Identifier: GPL-2.0/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
#include <vmlinux.h>#include <stdbool.h>#include <bpf/bpf_helpers.h>#include "bpf_kfuncs.h"
#define CLOCK_MONOTONIC 1
struct timer_elem { struct bpf_timer timer;};
struct { __uint(type, BPF_MAP_TYPE_ARRAY); __uint(max_entries, 1); __type(key, int); __type(value, struct timer_elem);} timer_map SEC(".maps");
int timer_result;
#if (defined(__TARGET_ARCH_x86) || defined(__TARGET_ARCH_arm64) || \ (defined(__TARGET_ARCH_riscv) && __riscv_xlen == 64)) && \ defined(__BPF_FEATURE_STACK_ARGUMENT)
const volatile bool has_stack_arg = true;
__noinline static int static_func_many_args(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j){ return a + b + c + d + e + f + g + h + i + j;}
__noinline int global_calls_many_args(int a, int b, int c){ return static_func_many_args(a, b, c, a + 3, a + 4, a + 5, a + 6, a + 7, a + 8, a + 9);}
SEC("tc")int test_global_many_args(void){ return global_calls_many_args(1, 2, 3);}
struct test_data { long x; long y;};
/* 1+2+3+4+5+6+7+8+9+10+20 = 75 */__noinline static long func_with_ptr_stack_arg(long a, long b, long c, long d, long e, long f, long g, long h, long i, struct test_data *p){ return a + b + c + d + e + f + g + h + i + p->x + p->y;}
__noinline long global_ptr_stack_arg(long a, long b, long c, long d, long e){ struct test_data data = { .x = 10, .y = 20 };
return func_with_ptr_stack_arg(a, b, c, d, e, a + 5, a + 6, a + 7, a + 8, &data);}
SEC("tc")int test_bpf2bpf_ptr_stack_arg(void){ return global_ptr_stack_arg(1, 2, 3, 4, 5);}
/* 1+2+3+4+5+6+7+10+8+20 = 66 */__noinline static long func_with_mix_stack_args(long a, long b, long c, long d, long e, long f, long g, struct test_data *p, long h, struct test_data *q){ return a + b + c + d + e + f + g + p->x + h + q->y;}
__noinline long global_mix_stack_args(long a, long b, long c, long d, long e){ struct test_data p = { .x = 10 }; struct test_data q = { .y = 20 };
return func_with_mix_stack_args(a, b, c, d, e, e + 1, e + 2, &p, e + 3, &q);}
SEC("tc")int test_bpf2bpf_mix_stack_args(void){ return global_mix_stack_args(1, 2, 3, 4, 5);}
/* * Nesting test: func_outer calls func_inner, both with struct pointer * as stack arg. * * func_inner: (a+1)+...+(i+1) + p->x + p->y * = 2+3+4+5+6+7+8+9+10+10+20 = 84 */__noinline static long func_inner_ptr(long a, long b, long c, long d, long e, long f, long g, long h, long i, struct test_data *p){ return a + b + c + d + e + f + g + h + i + p->x + p->y;}
__noinline static long func_outer_ptr(long a, long b, long c, long d, long e, long f, long g, long h, long i, struct test_data *p){ return func_inner_ptr(a + 1, b + 1, c + 1, d + 1, e + 1, f + 1, g + 1, h + 1, i + 1, p);}
__noinline long global_nesting_ptr(long a, long b, long c, long d, long e){ struct test_data data = { .x = 10, .y = 20 };
return func_outer_ptr(a, b, c, d, e, a + 5, a + 6, a + 7, a + 8, &data);}
SEC("tc")int test_bpf2bpf_nesting_stack_arg(void){ return global_nesting_ptr(1, 2, 3, 4, 5);}
/* 1+2+3+4+5+6+7+8+9+sizeof(pkt_v4) = 45+54 = 99 */__noinline static long func_with_dynptr(long a, long b, long c, long d, long e, long f, long g, long h, long i, struct bpf_dynptr *ptr){ return a + b + c + d + e + f + g + h + i + bpf_dynptr_size(ptr);}
__noinline long global_dynptr_stack_arg(void *ctx __arg_ctx, long a, long b, long c, long d){ struct bpf_dynptr ptr;
bpf_dynptr_from_skb(ctx, 0, &ptr); return func_with_dynptr(a, b, c, d, d + 1, d + 2, d + 3, d + 4, d + 5, &ptr);}
SEC("tc")int test_bpf2bpf_dynptr_stack_arg(struct __sk_buff *skb){ return global_dynptr_stack_arg(skb, 1, 2, 3, 4);}
/* foo1: a+b+c+d+e+f+g+h+i+j */__noinline static int foo1(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j){ return a + b + c + d + e + f + g + h + i + j;}
/* foo2: a+b+c+d+e+f+g+h+i+j+k+l */__noinline static int foo2(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l){ return a + b + c + d + e + f + g + h + i + j + k + l;}
/* global_two_callees calls foo1 (5 stack args) and foo2 (7 stack args). * The outgoing stack arg area is sized for foo2 (the larger callee). * Stores for foo1 are a subset of the area used by foo2. * Result: foo1(1..10) + foo2(1..12) = 55 + 78 = 133 * * Pass a-e through so the compiler can't constant-fold the stack args away. */__noinline int global_two_callees(int a, int b, int c, int d, int e){ int ret;
ret = foo1(a, b, c, d, e, a + 5, a + 6, a + 7, a + 8, a + 9); ret += foo2(a, b, c, d, e, a + 5, a + 6, a + 7, a + 8, a + 9, a + 10, a + 11); return ret;}
SEC("tc")int test_two_callees(void){ return global_two_callees(1, 2, 3, 4, 5);}
const volatile int timer_base = 10;
static int timer_cb_many_args(void *map, int *key, struct bpf_timer *timer){ int v = timer_base;
timer_result = static_func_many_args(v, v * 2, v * 3, v * 4, v * 5, v * 6, v * 7, v * 8, v * 9, v * 10); return 0;}
SEC("tc")int test_async_cb_many_args(void){ struct timer_elem *elem; int key = 0;
elem = bpf_map_lookup_elem(&timer_map, &key); if (!elem) return -1;
bpf_timer_init(&elem->timer, &timer_map, CLOCK_MONOTONIC); bpf_timer_set_callback(&elem->timer, timer_cb_many_args); bpf_timer_start(&elem->timer, 1, 0); return 0;}
#else
const volatile bool has_stack_arg = false;
SEC("tc")int test_global_many_args(void){ return 0;}
SEC("tc")int test_bpf2bpf_ptr_stack_arg(void){ return 0;}
SEC("tc")int test_bpf2bpf_mix_stack_args(void){ return 0;}
SEC("tc")int test_bpf2bpf_nesting_stack_arg(void){ return 0;}
SEC("tc")int test_bpf2bpf_dynptr_stack_arg(struct __sk_buff *skb){ return 0;}
SEC("tc")int test_two_callees(void){ return 0;}
SEC("tc")int test_async_cb_many_args(void){ return 0;}
#endif
char _license[] SEC("license") = "GPL";