1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
#include "bpf_misc.h"
#define MIX_A 0xdeadbeefcafef00dULL
#define MIX_B 0x0123456789abcdefULL
struct pair {
__u64 lo;
__u64 hi;
};
struct small {
__u32 a;
__u32 b;
};
union upair {
__u64 halves[2];
struct {
__u64 lo;
__u64 hi;
} parts;
};
struct with_ptr {
void *p;
__u64 x;
};
static __noinline __u64 take_pair(int a, struct pair p, int c)
{
return (__u64)a + p.lo + p.hi + c;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_static_struct_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
struct pair p = { .lo = a, .hi = b };
if (take_pair(1, p, 2) != a + b + 3)
return 1;
return 0;
}
#if defined(__clang__)
__noinline __u64 take_pair_global(int a, struct pair p, int c)
{
return (__u64)a + p.lo + p.hi + c;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_global_struct_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
struct pair p = { .lo = a, .hi = b };
if (take_pair_global(1, p, 2) != a + b + 3)
return 1;
return 0;
}
__noinline __u64 take_two_pairs_global(struct pair p, struct pair q, int d)
{
return p.lo + p.hi + q.lo + q.hi + d;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_two_structs_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
struct pair p = { .lo = a, .hi = b };
struct pair q = { .lo = a + 1, .hi = b + 2 };
if (take_two_pairs_global(p, q, 3) != 2 * a + 2 * b + 6)
return 1;
return 0;
}
__noinline __u64 take_small_global(int a, struct small s, int c)
{
return (__u64)a + s.a + s.b + c;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_small_struct_c_test(struct __sk_buff *skb)
{
__u32 a = skb->len ^ (__u32)MIX_A;
__u32 b = skb->len ^ (__u32)MIX_B;
struct small s = { .a = a, .b = b };
if (take_small_global(1, s, 2) != (__u64)a + b + 3)
return 1;
return 0;
}
__noinline __u64 take_upair_global(int a, union upair u, int c)
{
return (__u64)a + u.parts.lo + u.parts.hi + c;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_union_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
union upair u;
u.halves[0] = a;
u.halves[1] = b;
if (take_upair_global(1, u, 2) != a + b + 3)
return 1;
return 0;
}
#endif
#ifdef __SIZEOF_INT128__
typedef unsigned __int128 u128;
__noinline __u64 take_i128_global(int a, u128 v, int c)
{
return (__u64)a + (__u64)(v >> 64) + (__u64)v + c;
}
SEC("tc")
__success __retval(0)
int aggregate_arg_int128_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
u128 v = ((u128)a << 64) | b;
if (take_i128_global(1, v, 2) != a + b + 3)
return 1;
return 0;
}
#endif /* __SIZEOF_INT128__ */
#if defined(__BPF_FEATURE_STACK_ARGUMENT)
static __noinline __u64 take_spilled_pair(int a, int b, int c, int d, struct pair p)
{
return (__u64)a + b + c + d + p.lo + p.hi;
}
SEC("tc")
__arch_x86_64 __arch_arm64
__load_if_JITed()
__success __retval(0)
int aggregate_arg_spilled_struct_c_test(struct __sk_buff *skb)
{
__u64 a = skb->len ^ MIX_A;
__u64 b = skb->len ^ MIX_B;
struct pair p = { .lo = a, .hi = b };
int n = skb->len;
if (take_spilled_pair(n, n + 1, n + 2, n + 3, p) != a + b + 4 * n + 6)
return 1;
return 0;
}
#endif
__noinline __u64 take_with_ptr_global(struct with_ptr s)
{
return s.x;
}
SEC("tc")
__failure __msg("type STRUCT in take_with_ptr_global() is not composed of scalars")
int aggregate_arg_ptr_member_fail(struct __sk_buff *skb)
{
struct with_ptr s = { .p = skb, .x = skb->len };
return take_with_ptr_global(s);
}
char _license[] SEC("license") = "GPL";
|
