1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2023 Isovalent */
3 #include <uapi/linux/if_link.h>
4 #include <net/if.h>
5 #include <test_progs.h>
6
7 #define loopback 1
8 #define ping_cmd "ping -q -c1 -w1 127.0.0.1 > /dev/null"
9
10 #include "test_tc_link.skel.h"
11 #include "tc_helpers.h"
12
13 void serial_test_tc_opts_basic(void)
14 {
15 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
16 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
17 LIBBPF_OPTS(bpf_prog_query_opts, optq);
18 __u32 fd1, fd2, id1, id2;
19 struct test_tc_link *skel;
20 __u32 prog_ids[2];
21 int err;
22
23 skel = test_tc_link__open_and_load();
24 if (!ASSERT_OK_PTR(skel, "skel_load"))
25 goto cleanup;
26
27 fd1 = bpf_program__fd(skel->progs.tc1);
28 fd2 = bpf_program__fd(skel->progs.tc2);
29
30 id1 = id_from_prog_fd(fd1);
31 id2 = id_from_prog_fd(fd2);
32
33 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
34
35 assert_mprog_count(BPF_TCX_INGRESS, 0);
36 assert_mprog_count(BPF_TCX_EGRESS, 0);
37
38 ASSERT_EQ(skel->bss->seen_tc1, false, "seen_tc1");
39 ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
40
41 err = bpf_prog_attach_opts(fd1, loopback, BPF_TCX_INGRESS, &opta);
42 if (!ASSERT_EQ(err, 0, "prog_attach"))
43 goto cleanup;
44
45 assert_mprog_count(BPF_TCX_INGRESS, 1);
46 assert_mprog_count(BPF_TCX_EGRESS, 0);
47
48 optq.prog_ids = prog_ids;
49
50 memset(prog_ids, 0, sizeof(prog_ids));
51 optq.count = ARRAY_SIZE(prog_ids);
52
53 err = bpf_prog_query_opts(loopback, BPF_TCX_INGRESS, &optq);
54 if (!ASSERT_OK(err, "prog_query"))
55 goto cleanup_in;
56
57 ASSERT_EQ(optq.count, 1, "count");
58 ASSERT_EQ(optq.revision, 2, "revision");
59 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
60 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
61
62 tc_skel_reset_all_seen(skel);
63 ASSERT_OK(system(ping_cmd), ping_cmd);
64
65 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
66 ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
67
68 err = bpf_prog_attach_opts(fd2, loopback, BPF_TCX_EGRESS, &opta);
69 if (!ASSERT_EQ(err, 0, "prog_attach"))
70 goto cleanup_in;
71
72 assert_mprog_count(BPF_TCX_INGRESS, 1);
73 assert_mprog_count(BPF_TCX_EGRESS, 1);
74
75 memset(prog_ids, 0, sizeof(prog_ids));
76 optq.count = ARRAY_SIZE(prog_ids);
77
78 err = bpf_prog_query_opts(loopback, BPF_TCX_EGRESS, &optq);
79 if (!ASSERT_OK(err, "prog_query"))
80 goto cleanup_eg;
81
82 ASSERT_EQ(optq.count, 1, "count");
83 ASSERT_EQ(optq.revision, 2, "revision");
84 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
85 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
86
87 tc_skel_reset_all_seen(skel);
88 ASSERT_OK(system(ping_cmd), ping_cmd);
89
90 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
91 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
92
93 cleanup_eg:
94 err = bpf_prog_detach_opts(fd2, loopback, BPF_TCX_EGRESS, &optd);
95 ASSERT_OK(err, "prog_detach_eg");
96
97 assert_mprog_count(BPF_TCX_INGRESS, 1);
98 assert_mprog_count(BPF_TCX_EGRESS, 0);
99
100 cleanup_in:
101 err = bpf_prog_detach_opts(fd1, loopback, BPF_TCX_INGRESS, &optd);
102 ASSERT_OK(err, "prog_detach_in");
103
104 assert_mprog_count(BPF_TCX_INGRESS, 0);
105 assert_mprog_count(BPF_TCX_EGRESS, 0);
106
107 cleanup:
108 test_tc_link__destroy(skel);
109 }
110
111 static void test_tc_opts_before_target(int target)
112 {
113 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
114 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
115 LIBBPF_OPTS(bpf_prog_query_opts, optq);
116 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
117 struct test_tc_link *skel;
118 __u32 prog_ids[5];
119 int err;
120
121 skel = test_tc_link__open_and_load();
122 if (!ASSERT_OK_PTR(skel, "skel_load"))
123 goto cleanup;
124
125 fd1 = bpf_program__fd(skel->progs.tc1);
126 fd2 = bpf_program__fd(skel->progs.tc2);
127 fd3 = bpf_program__fd(skel->progs.tc3);
128 fd4 = bpf_program__fd(skel->progs.tc4);
129
130 id1 = id_from_prog_fd(fd1);
131 id2 = id_from_prog_fd(fd2);
132 id3 = id_from_prog_fd(fd3);
133 id4 = id_from_prog_fd(fd4);
134
135 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
136 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
137 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
138
139 assert_mprog_count(target, 0);
140
141 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
142 if (!ASSERT_EQ(err, 0, "prog_attach"))
143 goto cleanup;
144
145 assert_mprog_count(target, 1);
146
147 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
148 if (!ASSERT_EQ(err, 0, "prog_attach"))
149 goto cleanup_target;
150
151 assert_mprog_count(target, 2);
152
153 optq.prog_ids = prog_ids;
154
155 memset(prog_ids, 0, sizeof(prog_ids));
156 optq.count = ARRAY_SIZE(prog_ids);
157
158 err = bpf_prog_query_opts(loopback, target, &optq);
159 if (!ASSERT_OK(err, "prog_query"))
160 goto cleanup_target2;
161
162 ASSERT_EQ(optq.count, 2, "count");
163 ASSERT_EQ(optq.revision, 3, "revision");
164 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
165 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
166 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
167
168 tc_skel_reset_all_seen(skel);
169 ASSERT_OK(system(ping_cmd), ping_cmd);
170
171 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
172 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
173 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
174 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
175
176 LIBBPF_OPTS_RESET(opta,
177 .flags = BPF_F_BEFORE,
178 .relative_fd = fd2,
179 );
180
181 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
182 if (!ASSERT_EQ(err, 0, "prog_attach"))
183 goto cleanup_target2;
184
185 memset(prog_ids, 0, sizeof(prog_ids));
186 optq.count = ARRAY_SIZE(prog_ids);
187
188 err = bpf_prog_query_opts(loopback, target, &optq);
189 if (!ASSERT_OK(err, "prog_query"))
190 goto cleanup_target3;
191
192 ASSERT_EQ(optq.count, 3, "count");
193 ASSERT_EQ(optq.revision, 4, "revision");
194 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
195 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
196 ASSERT_EQ(optq.prog_ids[2], id2, "prog_ids[2]");
197 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
198
199 LIBBPF_OPTS_RESET(opta,
200 .flags = BPF_F_BEFORE,
201 .relative_id = id1,
202 );
203
204 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
205 if (!ASSERT_EQ(err, 0, "prog_attach"))
206 goto cleanup_target3;
207
208 assert_mprog_count(target, 4);
209
210 memset(prog_ids, 0, sizeof(prog_ids));
211 optq.count = ARRAY_SIZE(prog_ids);
212
213 err = bpf_prog_query_opts(loopback, target, &optq);
214 if (!ASSERT_OK(err, "prog_query"))
215 goto cleanup_target4;
216
217 ASSERT_EQ(optq.count, 4, "count");
218 ASSERT_EQ(optq.revision, 5, "revision");
219 ASSERT_EQ(optq.prog_ids[0], id4, "prog_ids[0]");
220 ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
221 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
222 ASSERT_EQ(optq.prog_ids[3], id2, "prog_ids[3]");
223 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
224
225 tc_skel_reset_all_seen(skel);
226 ASSERT_OK(system(ping_cmd), ping_cmd);
227
228 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
229 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
230 ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
231 ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
232
233 cleanup_target4:
234 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
235 ASSERT_OK(err, "prog_detach");
236 assert_mprog_count(target, 3);
237
238 cleanup_target3:
239 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
240 ASSERT_OK(err, "prog_detach");
241 assert_mprog_count(target, 2);
242
243 cleanup_target2:
244 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
245 ASSERT_OK(err, "prog_detach");
246 assert_mprog_count(target, 1);
247
248 cleanup_target:
249 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
250 ASSERT_OK(err, "prog_detach");
251 assert_mprog_count(target, 0);
252
253 cleanup:
254 test_tc_link__destroy(skel);
255 }
256
257 void serial_test_tc_opts_before(void)
258 {
259 test_tc_opts_before_target(BPF_TCX_INGRESS);
260 test_tc_opts_before_target(BPF_TCX_EGRESS);
261 }
262
263 static void test_tc_opts_after_target(int target)
264 {
265 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
266 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
267 LIBBPF_OPTS(bpf_prog_query_opts, optq);
268 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
269 struct test_tc_link *skel;
270 __u32 prog_ids[5];
271 int err;
272
273 skel = test_tc_link__open_and_load();
274 if (!ASSERT_OK_PTR(skel, "skel_load"))
275 goto cleanup;
276
277 fd1 = bpf_program__fd(skel->progs.tc1);
278 fd2 = bpf_program__fd(skel->progs.tc2);
279 fd3 = bpf_program__fd(skel->progs.tc3);
280 fd4 = bpf_program__fd(skel->progs.tc4);
281
282 id1 = id_from_prog_fd(fd1);
283 id2 = id_from_prog_fd(fd2);
284 id3 = id_from_prog_fd(fd3);
285 id4 = id_from_prog_fd(fd4);
286
287 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
288 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
289 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
290
291 assert_mprog_count(target, 0);
292
293 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
294 if (!ASSERT_EQ(err, 0, "prog_attach"))
295 goto cleanup;
296
297 assert_mprog_count(target, 1);
298
299 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
300 if (!ASSERT_EQ(err, 0, "prog_attach"))
301 goto cleanup_target;
302
303 assert_mprog_count(target, 2);
304
305 optq.prog_ids = prog_ids;
306
307 memset(prog_ids, 0, sizeof(prog_ids));
308 optq.count = ARRAY_SIZE(prog_ids);
309
310 err = bpf_prog_query_opts(loopback, target, &optq);
311 if (!ASSERT_OK(err, "prog_query"))
312 goto cleanup_target2;
313
314 ASSERT_EQ(optq.count, 2, "count");
315 ASSERT_EQ(optq.revision, 3, "revision");
316 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
317 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
318 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
319
320 tc_skel_reset_all_seen(skel);
321 ASSERT_OK(system(ping_cmd), ping_cmd);
322
323 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
324 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
325 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
326 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
327
328 LIBBPF_OPTS_RESET(opta,
329 .flags = BPF_F_AFTER,
330 .relative_fd = fd1,
331 );
332
333 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
334 if (!ASSERT_EQ(err, 0, "prog_attach"))
335 goto cleanup_target2;
336
337 memset(prog_ids, 0, sizeof(prog_ids));
338 optq.count = ARRAY_SIZE(prog_ids);
339
340 err = bpf_prog_query_opts(loopback, target, &optq);
341 if (!ASSERT_OK(err, "prog_query"))
342 goto cleanup_target3;
343
344 ASSERT_EQ(optq.count, 3, "count");
345 ASSERT_EQ(optq.revision, 4, "revision");
346 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
347 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
348 ASSERT_EQ(optq.prog_ids[2], id2, "prog_ids[2]");
349 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
350
351 LIBBPF_OPTS_RESET(opta,
352 .flags = BPF_F_AFTER,
353 .relative_id = id2,
354 );
355
356 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
357 if (!ASSERT_EQ(err, 0, "prog_attach"))
358 goto cleanup_target3;
359
360 assert_mprog_count(target, 4);
361
362 memset(prog_ids, 0, sizeof(prog_ids));
363 optq.count = ARRAY_SIZE(prog_ids);
364
365 err = bpf_prog_query_opts(loopback, target, &optq);
366 if (!ASSERT_OK(err, "prog_query"))
367 goto cleanup_target4;
368
369 ASSERT_EQ(optq.count, 4, "count");
370 ASSERT_EQ(optq.revision, 5, "revision");
371 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
372 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
373 ASSERT_EQ(optq.prog_ids[2], id2, "prog_ids[2]");
374 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
375 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
376
377 tc_skel_reset_all_seen(skel);
378 ASSERT_OK(system(ping_cmd), ping_cmd);
379
380 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
381 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
382 ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
383 ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
384
385 cleanup_target4:
386 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
387 ASSERT_OK(err, "prog_detach");
388 assert_mprog_count(target, 3);
389
390 memset(prog_ids, 0, sizeof(prog_ids));
391 optq.count = ARRAY_SIZE(prog_ids);
392
393 err = bpf_prog_query_opts(loopback, target, &optq);
394 if (!ASSERT_OK(err, "prog_query"))
395 goto cleanup_target3;
396
397 ASSERT_EQ(optq.count, 3, "count");
398 ASSERT_EQ(optq.revision, 6, "revision");
399 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
400 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
401 ASSERT_EQ(optq.prog_ids[2], id2, "prog_ids[2]");
402 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
403
404 cleanup_target3:
405 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
406 ASSERT_OK(err, "prog_detach");
407 assert_mprog_count(target, 2);
408
409 memset(prog_ids, 0, sizeof(prog_ids));
410 optq.count = ARRAY_SIZE(prog_ids);
411
412 err = bpf_prog_query_opts(loopback, target, &optq);
413 if (!ASSERT_OK(err, "prog_query"))
414 goto cleanup_target2;
415
416 ASSERT_EQ(optq.count, 2, "count");
417 ASSERT_EQ(optq.revision, 7, "revision");
418 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
419 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
420 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
421
422 cleanup_target2:
423 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
424 ASSERT_OK(err, "prog_detach");
425 assert_mprog_count(target, 1);
426
427 memset(prog_ids, 0, sizeof(prog_ids));
428 optq.count = ARRAY_SIZE(prog_ids);
429
430 err = bpf_prog_query_opts(loopback, target, &optq);
431 if (!ASSERT_OK(err, "prog_query"))
432 goto cleanup_target;
433
434 ASSERT_EQ(optq.count, 1, "count");
435 ASSERT_EQ(optq.revision, 8, "revision");
436 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
437 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
438
439 cleanup_target:
440 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
441 ASSERT_OK(err, "prog_detach");
442 assert_mprog_count(target, 0);
443
444 cleanup:
445 test_tc_link__destroy(skel);
446 }
447
448 void serial_test_tc_opts_after(void)
449 {
450 test_tc_opts_after_target(BPF_TCX_INGRESS);
451 test_tc_opts_after_target(BPF_TCX_EGRESS);
452 }
453
454 static void test_tc_opts_revision_target(int target)
455 {
456 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
457 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
458 LIBBPF_OPTS(bpf_prog_query_opts, optq);
459 __u32 fd1, fd2, id1, id2;
460 struct test_tc_link *skel;
461 __u32 prog_ids[3];
462 int err;
463
464 skel = test_tc_link__open_and_load();
465 if (!ASSERT_OK_PTR(skel, "skel_load"))
466 goto cleanup;
467
468 fd1 = bpf_program__fd(skel->progs.tc1);
469 fd2 = bpf_program__fd(skel->progs.tc2);
470
471 id1 = id_from_prog_fd(fd1);
472 id2 = id_from_prog_fd(fd2);
473
474 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
475
476 assert_mprog_count(target, 0);
477
478 LIBBPF_OPTS_RESET(opta,
479 .expected_revision = 1,
480 );
481
482 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
483 if (!ASSERT_EQ(err, 0, "prog_attach"))
484 goto cleanup;
485
486 assert_mprog_count(target, 1);
487
488 LIBBPF_OPTS_RESET(opta,
489 .expected_revision = 1,
490 );
491
492 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
493 if (!ASSERT_EQ(err, -ESTALE, "prog_attach"))
494 goto cleanup_target;
495
496 assert_mprog_count(target, 1);
497
498 LIBBPF_OPTS_RESET(opta,
499 .expected_revision = 2,
500 );
501
502 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
503 if (!ASSERT_EQ(err, 0, "prog_attach"))
504 goto cleanup_target;
505
506 assert_mprog_count(target, 2);
507
508 optq.prog_ids = prog_ids;
509
510 memset(prog_ids, 0, sizeof(prog_ids));
511 optq.count = ARRAY_SIZE(prog_ids);
512
513 err = bpf_prog_query_opts(loopback, target, &optq);
514 if (!ASSERT_OK(err, "prog_query"))
515 goto cleanup_target2;
516
517 ASSERT_EQ(optq.count, 2, "count");
518 ASSERT_EQ(optq.revision, 3, "revision");
519 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
520 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
521 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
522
523 tc_skel_reset_all_seen(skel);
524 ASSERT_OK(system(ping_cmd), ping_cmd);
525
526 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
527 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
528
529 LIBBPF_OPTS_RESET(optd,
530 .expected_revision = 2,
531 );
532
533 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
534 ASSERT_EQ(err, -ESTALE, "prog_detach");
535 assert_mprog_count(target, 2);
536
537 cleanup_target2:
538 LIBBPF_OPTS_RESET(optd,
539 .expected_revision = 3,
540 );
541
542 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
543 ASSERT_OK(err, "prog_detach");
544 assert_mprog_count(target, 1);
545
546 cleanup_target:
547 LIBBPF_OPTS_RESET(optd);
548
549 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
550 ASSERT_OK(err, "prog_detach");
551 assert_mprog_count(target, 0);
552
553 cleanup:
554 test_tc_link__destroy(skel);
555 }
556
557 void serial_test_tc_opts_revision(void)
558 {
559 test_tc_opts_revision_target(BPF_TCX_INGRESS);
560 test_tc_opts_revision_target(BPF_TCX_EGRESS);
561 }
562
563 static void test_tc_chain_classic(int target, bool chain_tc_old)
564 {
565 LIBBPF_OPTS(bpf_tc_opts, tc_opts, .handle = 1, .priority = 1);
566 LIBBPF_OPTS(bpf_tc_hook, tc_hook, .ifindex = loopback);
567 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
568 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
569 bool hook_created = false, tc_attached = false;
570 __u32 fd1, fd2, fd3, id1, id2, id3;
571 struct test_tc_link *skel;
572 int err;
573
574 skel = test_tc_link__open_and_load();
575 if (!ASSERT_OK_PTR(skel, "skel_load"))
576 goto cleanup;
577
578 fd1 = bpf_program__fd(skel->progs.tc1);
579 fd2 = bpf_program__fd(skel->progs.tc2);
580 fd3 = bpf_program__fd(skel->progs.tc3);
581
582 id1 = id_from_prog_fd(fd1);
583 id2 = id_from_prog_fd(fd2);
584 id3 = id_from_prog_fd(fd3);
585
586 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
587 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
588
589 assert_mprog_count(target, 0);
590
591 if (chain_tc_old) {
592 tc_hook.attach_point = target == BPF_TCX_INGRESS ?
593 BPF_TC_INGRESS : BPF_TC_EGRESS;
594 err = bpf_tc_hook_create(&tc_hook);
595 if (err == 0)
596 hook_created = true;
597 err = err == -EEXIST ? 0 : err;
598 if (!ASSERT_OK(err, "bpf_tc_hook_create"))
599 goto cleanup;
600
601 tc_opts.prog_fd = fd3;
602 err = bpf_tc_attach(&tc_hook, &tc_opts);
603 if (!ASSERT_OK(err, "bpf_tc_attach"))
604 goto cleanup;
605 tc_attached = true;
606 }
607
608 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
609 if (!ASSERT_EQ(err, 0, "prog_attach"))
610 goto cleanup;
611
612 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
613 if (!ASSERT_EQ(err, 0, "prog_attach"))
614 goto cleanup_detach;
615
616 assert_mprog_count(target, 2);
617
618 tc_skel_reset_all_seen(skel);
619 ASSERT_OK(system(ping_cmd), ping_cmd);
620
621 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
622 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
623 ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");
624
625 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
626 if (!ASSERT_OK(err, "prog_detach"))
627 goto cleanup_detach;
628
629 assert_mprog_count(target, 1);
630
631 tc_skel_reset_all_seen(skel);
632 ASSERT_OK(system(ping_cmd), ping_cmd);
633
634 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
635 ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
636 ASSERT_EQ(skel->bss->seen_tc3, chain_tc_old, "seen_tc3");
637
638 cleanup_detach:
639 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
640 if (!ASSERT_OK(err, "prog_detach"))
641 goto cleanup;
642
643 assert_mprog_count(target, 0);
644 cleanup:
645 if (tc_attached) {
646 tc_opts.flags = tc_opts.prog_fd = tc_opts.prog_id = 0;
647 err = bpf_tc_detach(&tc_hook, &tc_opts);
648 ASSERT_OK(err, "bpf_tc_detach");
649 }
650 if (hook_created) {
651 tc_hook.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS;
652 bpf_tc_hook_destroy(&tc_hook);
653 }
654 test_tc_link__destroy(skel);
655 assert_mprog_count(target, 0);
656 }
657
658 void serial_test_tc_opts_chain_classic(void)
659 {
660 test_tc_chain_classic(BPF_TCX_INGRESS, false);
661 test_tc_chain_classic(BPF_TCX_EGRESS, false);
662 test_tc_chain_classic(BPF_TCX_INGRESS, true);
663 test_tc_chain_classic(BPF_TCX_EGRESS, true);
664 }
665
666 static void test_tc_opts_replace_target(int target)
667 {
668 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
669 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
670 LIBBPF_OPTS(bpf_prog_query_opts, optq);
671 __u32 fd1, fd2, fd3, id1, id2, id3, detach_fd;
672 __u32 prog_ids[4], prog_flags[4];
673 struct test_tc_link *skel;
674 int err;
675
676 skel = test_tc_link__open_and_load();
677 if (!ASSERT_OK_PTR(skel, "skel_load"))
678 goto cleanup;
679
680 fd1 = bpf_program__fd(skel->progs.tc1);
681 fd2 = bpf_program__fd(skel->progs.tc2);
682 fd3 = bpf_program__fd(skel->progs.tc3);
683
684 id1 = id_from_prog_fd(fd1);
685 id2 = id_from_prog_fd(fd2);
686 id3 = id_from_prog_fd(fd3);
687
688 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
689 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
690
691 assert_mprog_count(target, 0);
692
693 LIBBPF_OPTS_RESET(opta,
694 .expected_revision = 1,
695 );
696
697 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
698 if (!ASSERT_EQ(err, 0, "prog_attach"))
699 goto cleanup;
700
701 assert_mprog_count(target, 1);
702
703 LIBBPF_OPTS_RESET(opta,
704 .flags = BPF_F_BEFORE,
705 .relative_id = id1,
706 .expected_revision = 2,
707 );
708
709 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
710 if (!ASSERT_EQ(err, 0, "prog_attach"))
711 goto cleanup_target;
712
713 detach_fd = fd2;
714
715 assert_mprog_count(target, 2);
716
717 optq.prog_attach_flags = prog_flags;
718 optq.prog_ids = prog_ids;
719
720 memset(prog_flags, 0, sizeof(prog_flags));
721 memset(prog_ids, 0, sizeof(prog_ids));
722 optq.count = ARRAY_SIZE(prog_ids);
723
724 err = bpf_prog_query_opts(loopback, target, &optq);
725 if (!ASSERT_OK(err, "prog_query"))
726 goto cleanup_target2;
727
728 ASSERT_EQ(optq.count, 2, "count");
729 ASSERT_EQ(optq.revision, 3, "revision");
730 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
731 ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
732 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
733
734 ASSERT_EQ(optq.prog_attach_flags[0], 0, "prog_flags[0]");
735 ASSERT_EQ(optq.prog_attach_flags[1], 0, "prog_flags[1]");
736 ASSERT_EQ(optq.prog_attach_flags[2], 0, "prog_flags[2]");
737
738 tc_skel_reset_all_seen(skel);
739 ASSERT_OK(system(ping_cmd), ping_cmd);
740
741 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
742 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
743 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
744
745 LIBBPF_OPTS_RESET(opta,
746 .flags = BPF_F_REPLACE,
747 .replace_prog_fd = fd2,
748 .expected_revision = 3,
749 );
750
751 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
752 if (!ASSERT_EQ(err, 0, "prog_attach"))
753 goto cleanup_target2;
754
755 detach_fd = fd3;
756
757 assert_mprog_count(target, 2);
758
759 memset(prog_ids, 0, sizeof(prog_ids));
760 optq.count = ARRAY_SIZE(prog_ids);
761
762 err = bpf_prog_query_opts(loopback, target, &optq);
763 if (!ASSERT_OK(err, "prog_query"))
764 goto cleanup_target2;
765
766 ASSERT_EQ(optq.count, 2, "count");
767 ASSERT_EQ(optq.revision, 4, "revision");
768 ASSERT_EQ(optq.prog_ids[0], id3, "prog_ids[0]");
769 ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
770 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
771
772 tc_skel_reset_all_seen(skel);
773 ASSERT_OK(system(ping_cmd), ping_cmd);
774
775 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
776 ASSERT_EQ(skel->bss->seen_tc2, false, "seen_tc2");
777 ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
778
779 LIBBPF_OPTS_RESET(opta,
780 .flags = BPF_F_REPLACE | BPF_F_BEFORE,
781 .replace_prog_fd = fd3,
782 .relative_fd = fd1,
783 .expected_revision = 4,
784 );
785
786 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
787 if (!ASSERT_EQ(err, 0, "prog_attach"))
788 goto cleanup_target2;
789
790 detach_fd = fd2;
791
792 assert_mprog_count(target, 2);
793
794 memset(prog_ids, 0, sizeof(prog_ids));
795 optq.count = ARRAY_SIZE(prog_ids);
796
797 err = bpf_prog_query_opts(loopback, target, &optq);
798 if (!ASSERT_OK(err, "prog_query"))
799 goto cleanup_target2;
800
801 ASSERT_EQ(optq.count, 2, "count");
802 ASSERT_EQ(optq.revision, 5, "revision");
803 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
804 ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
805 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
806
807 tc_skel_reset_all_seen(skel);
808 ASSERT_OK(system(ping_cmd), ping_cmd);
809
810 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
811 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
812 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
813
814 LIBBPF_OPTS_RESET(opta,
815 .flags = BPF_F_REPLACE,
816 .replace_prog_fd = fd2,
817 );
818
819 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
820 ASSERT_EQ(err, -EEXIST, "prog_attach");
821 assert_mprog_count(target, 2);
822
823 LIBBPF_OPTS_RESET(opta,
824 .flags = BPF_F_REPLACE | BPF_F_AFTER,
825 .replace_prog_fd = fd2,
826 .relative_fd = fd1,
827 .expected_revision = 5,
828 );
829
830 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
831 ASSERT_EQ(err, -ERANGE, "prog_attach");
832 assert_mprog_count(target, 2);
833
834 LIBBPF_OPTS_RESET(opta,
835 .flags = BPF_F_BEFORE | BPF_F_AFTER | BPF_F_REPLACE,
836 .replace_prog_fd = fd2,
837 .relative_fd = fd1,
838 .expected_revision = 5,
839 );
840
841 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
842 ASSERT_EQ(err, -ERANGE, "prog_attach");
843 assert_mprog_count(target, 2);
844
845 LIBBPF_OPTS_RESET(optd,
846 .flags = BPF_F_BEFORE,
847 .relative_id = id1,
848 .expected_revision = 5,
849 );
850
851 cleanup_target2:
852 err = bpf_prog_detach_opts(detach_fd, loopback, target, &optd);
853 ASSERT_OK(err, "prog_detach");
854 assert_mprog_count(target, 1);
855
856 cleanup_target:
857 LIBBPF_OPTS_RESET(optd);
858
859 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
860 ASSERT_OK(err, "prog_detach");
861 assert_mprog_count(target, 0);
862
863 cleanup:
864 test_tc_link__destroy(skel);
865 }
866
867 void serial_test_tc_opts_replace(void)
868 {
869 test_tc_opts_replace_target(BPF_TCX_INGRESS);
870 test_tc_opts_replace_target(BPF_TCX_EGRESS);
871 }
872
873 static void test_tc_opts_invalid_target(int target)
874 {
875 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
876 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
877 __u32 fd1, fd2, id1, id2;
878 struct test_tc_link *skel;
879 int err;
880
881 skel = test_tc_link__open_and_load();
882 if (!ASSERT_OK_PTR(skel, "skel_load"))
883 goto cleanup;
884
885 fd1 = bpf_program__fd(skel->progs.tc1);
886 fd2 = bpf_program__fd(skel->progs.tc2);
887
888 id1 = id_from_prog_fd(fd1);
889 id2 = id_from_prog_fd(fd2);
890
891 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
892
893 assert_mprog_count(target, 0);
894
895 LIBBPF_OPTS_RESET(opta,
896 .flags = BPF_F_BEFORE | BPF_F_AFTER,
897 );
898
899 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
900 ASSERT_EQ(err, -ERANGE, "prog_attach");
901 assert_mprog_count(target, 0);
902
903 LIBBPF_OPTS_RESET(opta,
904 .flags = BPF_F_BEFORE | BPF_F_ID,
905 );
906
907 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
908 ASSERT_EQ(err, -ENOENT, "prog_attach");
909 assert_mprog_count(target, 0);
910
911 LIBBPF_OPTS_RESET(opta,
912 .flags = BPF_F_AFTER | BPF_F_ID,
913 );
914
915 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
916 ASSERT_EQ(err, -ENOENT, "prog_attach");
917 assert_mprog_count(target, 0);
918
919 LIBBPF_OPTS_RESET(opta,
920 .relative_fd = fd2,
921 );
922
923 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
924 ASSERT_EQ(err, -EINVAL, "prog_attach");
925 assert_mprog_count(target, 0);
926
927 LIBBPF_OPTS_RESET(opta,
928 .flags = BPF_F_BEFORE | BPF_F_AFTER,
929 .relative_fd = fd2,
930 );
931
932 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
933 ASSERT_EQ(err, -ENOENT, "prog_attach");
934 assert_mprog_count(target, 0);
935
936 LIBBPF_OPTS_RESET(opta,
937 .flags = BPF_F_ID,
938 .relative_id = id2,
939 );
940
941 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
942 ASSERT_EQ(err, -EINVAL, "prog_attach");
943 assert_mprog_count(target, 0);
944
945 LIBBPF_OPTS_RESET(opta,
946 .flags = BPF_F_BEFORE,
947 .relative_fd = fd1,
948 );
949
950 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
951 ASSERT_EQ(err, -ENOENT, "prog_attach");
952 assert_mprog_count(target, 0);
953
954 LIBBPF_OPTS_RESET(opta,
955 .flags = BPF_F_AFTER,
956 .relative_fd = fd1,
957 );
958
959 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
960 ASSERT_EQ(err, -ENOENT, "prog_attach");
961 assert_mprog_count(target, 0);
962
963 LIBBPF_OPTS_RESET(opta);
964
965 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
966 if (!ASSERT_EQ(err, 0, "prog_attach"))
967 goto cleanup;
968
969 assert_mprog_count(target, 1);
970
971 LIBBPF_OPTS_RESET(opta);
972
973 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
974 ASSERT_EQ(err, -EEXIST, "prog_attach");
975 assert_mprog_count(target, 1);
976
977 LIBBPF_OPTS_RESET(opta,
978 .flags = BPF_F_BEFORE,
979 .relative_fd = fd1,
980 );
981
982 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
983 ASSERT_EQ(err, -EEXIST, "prog_attach");
984 assert_mprog_count(target, 1);
985
986 LIBBPF_OPTS_RESET(opta,
987 .flags = BPF_F_AFTER,
988 .relative_fd = fd1,
989 );
990
991 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
992 ASSERT_EQ(err, -EEXIST, "prog_attach");
993 assert_mprog_count(target, 1);
994
995 LIBBPF_OPTS_RESET(opta,
996 .flags = BPF_F_REPLACE,
997 .relative_fd = fd1,
998 );
999
1000 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1001 ASSERT_EQ(err, -EINVAL, "prog_attach_x1");
1002 assert_mprog_count(target, 1);
1003
1004 LIBBPF_OPTS_RESET(opta,
1005 .flags = BPF_F_REPLACE,
1006 .replace_prog_fd = fd1,
1007 );
1008
1009 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1010 ASSERT_EQ(err, -EEXIST, "prog_attach");
1011 assert_mprog_count(target, 1);
1012
1013 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1014 ASSERT_OK(err, "prog_detach");
1015 assert_mprog_count(target, 0);
1016 cleanup:
1017 test_tc_link__destroy(skel);
1018 }
1019
1020 void serial_test_tc_opts_invalid(void)
1021 {
1022 test_tc_opts_invalid_target(BPF_TCX_INGRESS);
1023 test_tc_opts_invalid_target(BPF_TCX_EGRESS);
1024 }
1025
1026 static void test_tc_opts_prepend_target(int target)
1027 {
1028 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1029 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1030 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1031 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
1032 struct test_tc_link *skel;
1033 __u32 prog_ids[5];
1034 int err;
1035
1036 skel = test_tc_link__open_and_load();
1037 if (!ASSERT_OK_PTR(skel, "skel_load"))
1038 goto cleanup;
1039
1040 fd1 = bpf_program__fd(skel->progs.tc1);
1041 fd2 = bpf_program__fd(skel->progs.tc2);
1042 fd3 = bpf_program__fd(skel->progs.tc3);
1043 fd4 = bpf_program__fd(skel->progs.tc4);
1044
1045 id1 = id_from_prog_fd(fd1);
1046 id2 = id_from_prog_fd(fd2);
1047 id3 = id_from_prog_fd(fd3);
1048 id4 = id_from_prog_fd(fd4);
1049
1050 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
1051 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
1052 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
1053
1054 assert_mprog_count(target, 0);
1055
1056 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1057 if (!ASSERT_EQ(err, 0, "prog_attach"))
1058 goto cleanup;
1059
1060 assert_mprog_count(target, 1);
1061
1062 LIBBPF_OPTS_RESET(opta,
1063 .flags = BPF_F_BEFORE,
1064 );
1065
1066 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
1067 if (!ASSERT_EQ(err, 0, "prog_attach"))
1068 goto cleanup_target;
1069
1070 assert_mprog_count(target, 2);
1071
1072 optq.prog_ids = prog_ids;
1073
1074 memset(prog_ids, 0, sizeof(prog_ids));
1075 optq.count = ARRAY_SIZE(prog_ids);
1076
1077 err = bpf_prog_query_opts(loopback, target, &optq);
1078 if (!ASSERT_OK(err, "prog_query"))
1079 goto cleanup_target2;
1080
1081 ASSERT_EQ(optq.count, 2, "count");
1082 ASSERT_EQ(optq.revision, 3, "revision");
1083 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
1084 ASSERT_EQ(optq.prog_ids[1], id1, "prog_ids[1]");
1085 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1086
1087 tc_skel_reset_all_seen(skel);
1088 ASSERT_OK(system(ping_cmd), ping_cmd);
1089
1090 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
1091 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
1092 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
1093 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
1094
1095 LIBBPF_OPTS_RESET(opta,
1096 .flags = BPF_F_BEFORE,
1097 );
1098
1099 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
1100 if (!ASSERT_EQ(err, 0, "prog_attach"))
1101 goto cleanup_target2;
1102
1103 LIBBPF_OPTS_RESET(opta,
1104 .flags = BPF_F_BEFORE,
1105 );
1106
1107 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
1108 if (!ASSERT_EQ(err, 0, "prog_attach"))
1109 goto cleanup_target3;
1110
1111 assert_mprog_count(target, 4);
1112
1113 memset(prog_ids, 0, sizeof(prog_ids));
1114 optq.count = ARRAY_SIZE(prog_ids);
1115
1116 err = bpf_prog_query_opts(loopback, target, &optq);
1117 if (!ASSERT_OK(err, "prog_query"))
1118 goto cleanup_target4;
1119
1120 ASSERT_EQ(optq.count, 4, "count");
1121 ASSERT_EQ(optq.revision, 5, "revision");
1122 ASSERT_EQ(optq.prog_ids[0], id4, "prog_ids[0]");
1123 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
1124 ASSERT_EQ(optq.prog_ids[2], id2, "prog_ids[2]");
1125 ASSERT_EQ(optq.prog_ids[3], id1, "prog_ids[3]");
1126 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1127
1128 tc_skel_reset_all_seen(skel);
1129 ASSERT_OK(system(ping_cmd), ping_cmd);
1130
1131 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
1132 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
1133 ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
1134 ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
1135
1136 cleanup_target4:
1137 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
1138 ASSERT_OK(err, "prog_detach");
1139 assert_mprog_count(target, 3);
1140
1141 cleanup_target3:
1142 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
1143 ASSERT_OK(err, "prog_detach");
1144 assert_mprog_count(target, 2);
1145
1146 cleanup_target2:
1147 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1148 ASSERT_OK(err, "prog_detach");
1149 assert_mprog_count(target, 1);
1150
1151 cleanup_target:
1152 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1153 ASSERT_OK(err, "prog_detach");
1154 assert_mprog_count(target, 0);
1155
1156 cleanup:
1157 test_tc_link__destroy(skel);
1158 }
1159
1160 void serial_test_tc_opts_prepend(void)
1161 {
1162 test_tc_opts_prepend_target(BPF_TCX_INGRESS);
1163 test_tc_opts_prepend_target(BPF_TCX_EGRESS);
1164 }
1165
1166 static void test_tc_opts_append_target(int target)
1167 {
1168 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1169 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1170 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1171 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
1172 struct test_tc_link *skel;
1173 __u32 prog_ids[5];
1174 int err;
1175
1176 skel = test_tc_link__open_and_load();
1177 if (!ASSERT_OK_PTR(skel, "skel_load"))
1178 goto cleanup;
1179
1180 fd1 = bpf_program__fd(skel->progs.tc1);
1181 fd2 = bpf_program__fd(skel->progs.tc2);
1182 fd3 = bpf_program__fd(skel->progs.tc3);
1183 fd4 = bpf_program__fd(skel->progs.tc4);
1184
1185 id1 = id_from_prog_fd(fd1);
1186 id2 = id_from_prog_fd(fd2);
1187 id3 = id_from_prog_fd(fd3);
1188 id4 = id_from_prog_fd(fd4);
1189
1190 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
1191 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
1192 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
1193
1194 assert_mprog_count(target, 0);
1195
1196 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1197 if (!ASSERT_EQ(err, 0, "prog_attach"))
1198 goto cleanup;
1199
1200 assert_mprog_count(target, 1);
1201
1202 LIBBPF_OPTS_RESET(opta,
1203 .flags = BPF_F_AFTER,
1204 );
1205
1206 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
1207 if (!ASSERT_EQ(err, 0, "prog_attach"))
1208 goto cleanup_target;
1209
1210 assert_mprog_count(target, 2);
1211
1212 optq.prog_ids = prog_ids;
1213
1214 memset(prog_ids, 0, sizeof(prog_ids));
1215 optq.count = ARRAY_SIZE(prog_ids);
1216
1217 err = bpf_prog_query_opts(loopback, target, &optq);
1218 if (!ASSERT_OK(err, "prog_query"))
1219 goto cleanup_target2;
1220
1221 ASSERT_EQ(optq.count, 2, "count");
1222 ASSERT_EQ(optq.revision, 3, "revision");
1223 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
1224 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
1225 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1226
1227 tc_skel_reset_all_seen(skel);
1228 ASSERT_OK(system(ping_cmd), ping_cmd);
1229
1230 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
1231 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
1232 ASSERT_EQ(skel->bss->seen_tc3, false, "seen_tc3");
1233 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
1234
1235 LIBBPF_OPTS_RESET(opta,
1236 .flags = BPF_F_AFTER,
1237 );
1238
1239 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
1240 if (!ASSERT_EQ(err, 0, "prog_attach"))
1241 goto cleanup_target2;
1242
1243 LIBBPF_OPTS_RESET(opta,
1244 .flags = BPF_F_AFTER,
1245 );
1246
1247 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
1248 if (!ASSERT_EQ(err, 0, "prog_attach"))
1249 goto cleanup_target3;
1250
1251 assert_mprog_count(target, 4);
1252
1253 memset(prog_ids, 0, sizeof(prog_ids));
1254 optq.count = ARRAY_SIZE(prog_ids);
1255
1256 err = bpf_prog_query_opts(loopback, target, &optq);
1257 if (!ASSERT_OK(err, "prog_query"))
1258 goto cleanup_target4;
1259
1260 ASSERT_EQ(optq.count, 4, "count");
1261 ASSERT_EQ(optq.revision, 5, "revision");
1262 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
1263 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
1264 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
1265 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
1266 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1267
1268 tc_skel_reset_all_seen(skel);
1269 ASSERT_OK(system(ping_cmd), ping_cmd);
1270
1271 ASSERT_EQ(skel->bss->seen_tc1, true, "seen_tc1");
1272 ASSERT_EQ(skel->bss->seen_tc2, true, "seen_tc2");
1273 ASSERT_EQ(skel->bss->seen_tc3, true, "seen_tc3");
1274 ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
1275
1276 cleanup_target4:
1277 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
1278 ASSERT_OK(err, "prog_detach");
1279 assert_mprog_count(target, 3);
1280
1281 cleanup_target3:
1282 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
1283 ASSERT_OK(err, "prog_detach");
1284 assert_mprog_count(target, 2);
1285
1286 cleanup_target2:
1287 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1288 ASSERT_OK(err, "prog_detach");
1289 assert_mprog_count(target, 1);
1290
1291 cleanup_target:
1292 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1293 ASSERT_OK(err, "prog_detach");
1294 assert_mprog_count(target, 0);
1295
1296 cleanup:
1297 test_tc_link__destroy(skel);
1298 }
1299
1300 void serial_test_tc_opts_append(void)
1301 {
1302 test_tc_opts_append_target(BPF_TCX_INGRESS);
1303 test_tc_opts_append_target(BPF_TCX_EGRESS);
1304 }
1305
1306 static void test_tc_opts_dev_cleanup_target(int target)
1307 {
1308 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1309 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1310 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1311 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
1312 struct test_tc_link *skel;
1313 int err, ifindex;
1314
1315 ASSERT_OK(system("ip link add dev tcx_opts1 type veth peer name tcx_opts2"), "add veth");
1316 ifindex = if_nametoindex("tcx_opts1");
1317 ASSERT_NEQ(ifindex, 0, "non_zero_ifindex");
1318
1319 skel = test_tc_link__open_and_load();
1320 if (!ASSERT_OK_PTR(skel, "skel_load"))
1321 goto cleanup;
1322
1323 fd1 = bpf_program__fd(skel->progs.tc1);
1324 fd2 = bpf_program__fd(skel->progs.tc2);
1325 fd3 = bpf_program__fd(skel->progs.tc3);
1326 fd4 = bpf_program__fd(skel->progs.tc4);
1327
1328 id1 = id_from_prog_fd(fd1);
1329 id2 = id_from_prog_fd(fd2);
1330 id3 = id_from_prog_fd(fd3);
1331 id4 = id_from_prog_fd(fd4);
1332
1333 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
1334 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
1335 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
1336
1337 assert_mprog_count_ifindex(ifindex, target, 0);
1338
1339 err = bpf_prog_attach_opts(fd1, ifindex, target, &opta);
1340 if (!ASSERT_EQ(err, 0, "prog_attach"))
1341 goto cleanup;
1342
1343 assert_mprog_count_ifindex(ifindex, target, 1);
1344
1345 err = bpf_prog_attach_opts(fd2, ifindex, target, &opta);
1346 if (!ASSERT_EQ(err, 0, "prog_attach"))
1347 goto cleanup1;
1348
1349 assert_mprog_count_ifindex(ifindex, target, 2);
1350
1351 err = bpf_prog_attach_opts(fd3, ifindex, target, &opta);
1352 if (!ASSERT_EQ(err, 0, "prog_attach"))
1353 goto cleanup2;
1354
1355 assert_mprog_count_ifindex(ifindex, target, 3);
1356
1357 err = bpf_prog_attach_opts(fd4, ifindex, target, &opta);
1358 if (!ASSERT_EQ(err, 0, "prog_attach"))
1359 goto cleanup3;
1360
1361 assert_mprog_count_ifindex(ifindex, target, 4);
1362
1363 ASSERT_OK(system("ip link del dev tcx_opts1"), "del veth");
1364 ASSERT_EQ(if_nametoindex("tcx_opts1"), 0, "dev1_removed");
1365 ASSERT_EQ(if_nametoindex("tcx_opts2"), 0, "dev2_removed");
1366 return;
1367 cleanup3:
1368 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
1369 ASSERT_OK(err, "prog_detach");
1370
1371 assert_mprog_count_ifindex(ifindex, target, 2);
1372 cleanup2:
1373 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1374 ASSERT_OK(err, "prog_detach");
1375
1376 assert_mprog_count_ifindex(ifindex, target, 1);
1377 cleanup1:
1378 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1379 ASSERT_OK(err, "prog_detach");
1380
1381 assert_mprog_count_ifindex(ifindex, target, 0);
1382 cleanup:
1383 test_tc_link__destroy(skel);
1384
1385 ASSERT_OK(system("ip link del dev tcx_opts1"), "del veth");
1386 ASSERT_EQ(if_nametoindex("tcx_opts1"), 0, "dev1_removed");
1387 ASSERT_EQ(if_nametoindex("tcx_opts2"), 0, "dev2_removed");
1388 }
1389
1390 void serial_test_tc_opts_dev_cleanup(void)
1391 {
1392 test_tc_opts_dev_cleanup_target(BPF_TCX_INGRESS);
1393 test_tc_opts_dev_cleanup_target(BPF_TCX_EGRESS);
1394 }
1395
1396 static void test_tc_opts_mixed_target(int target)
1397 {
1398 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1399 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1400 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1401 LIBBPF_OPTS(bpf_tcx_opts, optl);
1402 __u32 pid1, pid2, pid3, pid4, lid2, lid4;
1403 __u32 prog_flags[4], link_flags[4];
1404 __u32 prog_ids[4], link_ids[4];
1405 struct test_tc_link *skel;
1406 struct bpf_link *link;
1407 int err, detach_fd;
1408
1409 skel = test_tc_link__open();
1410 if (!ASSERT_OK_PTR(skel, "skel_open"))
1411 goto cleanup;
1412
1413 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc1, target),
1414 0, "tc1_attach_type");
1415 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc2, target),
1416 0, "tc2_attach_type");
1417 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc3, target),
1418 0, "tc3_attach_type");
1419 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc4, target),
1420 0, "tc4_attach_type");
1421
1422 err = test_tc_link__load(skel);
1423 if (!ASSERT_OK(err, "skel_load"))
1424 goto cleanup;
1425
1426 pid1 = id_from_prog_fd(bpf_program__fd(skel->progs.tc1));
1427 pid2 = id_from_prog_fd(bpf_program__fd(skel->progs.tc2));
1428 pid3 = id_from_prog_fd(bpf_program__fd(skel->progs.tc3));
1429 pid4 = id_from_prog_fd(bpf_program__fd(skel->progs.tc4));
1430
1431 ASSERT_NEQ(pid1, pid2, "prog_ids_1_2");
1432 ASSERT_NEQ(pid3, pid4, "prog_ids_3_4");
1433 ASSERT_NEQ(pid2, pid3, "prog_ids_2_3");
1434
1435 assert_mprog_count(target, 0);
1436
1437 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc1),
1438 loopback, target, &opta);
1439 if (!ASSERT_EQ(err, 0, "prog_attach"))
1440 goto cleanup;
1441
1442 detach_fd = bpf_program__fd(skel->progs.tc1);
1443
1444 assert_mprog_count(target, 1);
1445
1446 link = bpf_program__attach_tcx(skel->progs.tc2, loopback, &optl);
1447 if (!ASSERT_OK_PTR(link, "link_attach"))
1448 goto cleanup1;
1449 skel->links.tc2 = link;
1450
1451 lid2 = id_from_link_fd(bpf_link__fd(skel->links.tc2));
1452
1453 assert_mprog_count(target, 2);
1454
1455 LIBBPF_OPTS_RESET(opta,
1456 .flags = BPF_F_REPLACE,
1457 .replace_prog_fd = bpf_program__fd(skel->progs.tc1),
1458 );
1459
1460 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc2),
1461 loopback, target, &opta);
1462 ASSERT_EQ(err, -EEXIST, "prog_attach");
1463
1464 assert_mprog_count(target, 2);
1465
1466 LIBBPF_OPTS_RESET(opta,
1467 .flags = BPF_F_REPLACE,
1468 .replace_prog_fd = bpf_program__fd(skel->progs.tc2),
1469 );
1470
1471 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc1),
1472 loopback, target, &opta);
1473 ASSERT_EQ(err, -EEXIST, "prog_attach");
1474
1475 assert_mprog_count(target, 2);
1476
1477 LIBBPF_OPTS_RESET(opta,
1478 .flags = BPF_F_REPLACE,
1479 .replace_prog_fd = bpf_program__fd(skel->progs.tc2),
1480 );
1481
1482 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc3),
1483 loopback, target, &opta);
1484 ASSERT_EQ(err, -EBUSY, "prog_attach");
1485
1486 assert_mprog_count(target, 2);
1487
1488 LIBBPF_OPTS_RESET(opta,
1489 .flags = BPF_F_REPLACE,
1490 .replace_prog_fd = bpf_program__fd(skel->progs.tc1),
1491 );
1492
1493 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc3),
1494 loopback, target, &opta);
1495 if (!ASSERT_EQ(err, 0, "prog_attach"))
1496 goto cleanup1;
1497
1498 detach_fd = bpf_program__fd(skel->progs.tc3);
1499
1500 assert_mprog_count(target, 2);
1501
1502 link = bpf_program__attach_tcx(skel->progs.tc4, loopback, &optl);
1503 if (!ASSERT_OK_PTR(link, "link_attach"))
1504 goto cleanup1;
1505 skel->links.tc4 = link;
1506
1507 lid4 = id_from_link_fd(bpf_link__fd(skel->links.tc4));
1508
1509 assert_mprog_count(target, 3);
1510
1511 LIBBPF_OPTS_RESET(opta,
1512 .flags = BPF_F_REPLACE,
1513 .replace_prog_fd = bpf_program__fd(skel->progs.tc4),
1514 );
1515
1516 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc2),
1517 loopback, target, &opta);
1518 ASSERT_EQ(err, -EEXIST, "prog_attach");
1519
1520 optq.prog_ids = prog_ids;
1521 optq.prog_attach_flags = prog_flags;
1522 optq.link_ids = link_ids;
1523 optq.link_attach_flags = link_flags;
1524
1525 memset(prog_ids, 0, sizeof(prog_ids));
1526 memset(prog_flags, 0, sizeof(prog_flags));
1527 memset(link_ids, 0, sizeof(link_ids));
1528 memset(link_flags, 0, sizeof(link_flags));
1529 optq.count = ARRAY_SIZE(prog_ids);
1530
1531 err = bpf_prog_query_opts(loopback, target, &optq);
1532 if (!ASSERT_OK(err, "prog_query"))
1533 goto cleanup1;
1534
1535 ASSERT_EQ(optq.count, 3, "count");
1536 ASSERT_EQ(optq.revision, 5, "revision");
1537 ASSERT_EQ(optq.prog_ids[0], pid3, "prog_ids[0]");
1538 ASSERT_EQ(optq.prog_attach_flags[0], 0, "prog_flags[0]");
1539 ASSERT_EQ(optq.link_ids[0], 0, "link_ids[0]");
1540 ASSERT_EQ(optq.link_attach_flags[0], 0, "link_flags[0]");
1541 ASSERT_EQ(optq.prog_ids[1], pid2, "prog_ids[1]");
1542 ASSERT_EQ(optq.prog_attach_flags[1], 0, "prog_flags[1]");
1543 ASSERT_EQ(optq.link_ids[1], lid2, "link_ids[1]");
1544 ASSERT_EQ(optq.link_attach_flags[1], 0, "link_flags[1]");
1545 ASSERT_EQ(optq.prog_ids[2], pid4, "prog_ids[2]");
1546 ASSERT_EQ(optq.prog_attach_flags[2], 0, "prog_flags[2]");
1547 ASSERT_EQ(optq.link_ids[2], lid4, "link_ids[2]");
1548 ASSERT_EQ(optq.link_attach_flags[2], 0, "link_flags[2]");
1549 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
1550 ASSERT_EQ(optq.prog_attach_flags[3], 0, "prog_flags[3]");
1551 ASSERT_EQ(optq.link_ids[3], 0, "link_ids[3]");
1552 ASSERT_EQ(optq.link_attach_flags[3], 0, "link_flags[3]");
1553
1554 ASSERT_OK(system(ping_cmd), ping_cmd);
1555
1556 cleanup1:
1557 err = bpf_prog_detach_opts(detach_fd, loopback, target, &optd);
1558 ASSERT_OK(err, "prog_detach");
1559 assert_mprog_count(target, 2);
1560
1561 cleanup:
1562 test_tc_link__destroy(skel);
1563 assert_mprog_count(target, 0);
1564 }
1565
1566 void serial_test_tc_opts_mixed(void)
1567 {
1568 test_tc_opts_mixed_target(BPF_TCX_INGRESS);
1569 test_tc_opts_mixed_target(BPF_TCX_EGRESS);
1570 }
1571
1572 static void test_tc_opts_demixed_target(int target)
1573 {
1574 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1575 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1576 LIBBPF_OPTS(bpf_tcx_opts, optl);
1577 struct test_tc_link *skel;
1578 struct bpf_link *link;
1579 __u32 pid1, pid2;
1580 int err;
1581
1582 skel = test_tc_link__open();
1583 if (!ASSERT_OK_PTR(skel, "skel_open"))
1584 goto cleanup;
1585
1586 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc1, target),
1587 0, "tc1_attach_type");
1588 ASSERT_EQ(bpf_program__set_expected_attach_type(skel->progs.tc2, target),
1589 0, "tc2_attach_type");
1590
1591 err = test_tc_link__load(skel);
1592 if (!ASSERT_OK(err, "skel_load"))
1593 goto cleanup;
1594
1595 pid1 = id_from_prog_fd(bpf_program__fd(skel->progs.tc1));
1596 pid2 = id_from_prog_fd(bpf_program__fd(skel->progs.tc2));
1597 ASSERT_NEQ(pid1, pid2, "prog_ids_1_2");
1598
1599 assert_mprog_count(target, 0);
1600
1601 err = bpf_prog_attach_opts(bpf_program__fd(skel->progs.tc1),
1602 loopback, target, &opta);
1603 if (!ASSERT_EQ(err, 0, "prog_attach"))
1604 goto cleanup;
1605
1606 assert_mprog_count(target, 1);
1607
1608 link = bpf_program__attach_tcx(skel->progs.tc2, loopback, &optl);
1609 if (!ASSERT_OK_PTR(link, "link_attach"))
1610 goto cleanup1;
1611 skel->links.tc2 = link;
1612
1613 assert_mprog_count(target, 2);
1614
1615 LIBBPF_OPTS_RESET(optd,
1616 .flags = BPF_F_AFTER,
1617 );
1618
1619 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1620 ASSERT_EQ(err, -EBUSY, "prog_detach");
1621
1622 assert_mprog_count(target, 2);
1623
1624 LIBBPF_OPTS_RESET(optd,
1625 .flags = BPF_F_BEFORE,
1626 );
1627
1628 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1629 ASSERT_OK(err, "prog_detach");
1630
1631 assert_mprog_count(target, 1);
1632 goto cleanup;
1633
1634 cleanup1:
1635 err = bpf_prog_detach_opts(bpf_program__fd(skel->progs.tc1),
1636 loopback, target, &optd);
1637 ASSERT_OK(err, "prog_detach");
1638 assert_mprog_count(target, 2);
1639
1640 cleanup:
1641 test_tc_link__destroy(skel);
1642 assert_mprog_count(target, 0);
1643 }
1644
1645 void serial_test_tc_opts_demixed(void)
1646 {
1647 test_tc_opts_demixed_target(BPF_TCX_INGRESS);
1648 test_tc_opts_demixed_target(BPF_TCX_EGRESS);
1649 }
1650
1651 static void test_tc_opts_detach_target(int target)
1652 {
1653 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1654 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1655 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1656 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
1657 struct test_tc_link *skel;
1658 __u32 prog_ids[5];
1659 int err;
1660
1661 skel = test_tc_link__open_and_load();
1662 if (!ASSERT_OK_PTR(skel, "skel_load"))
1663 goto cleanup;
1664
1665 fd1 = bpf_program__fd(skel->progs.tc1);
1666 fd2 = bpf_program__fd(skel->progs.tc2);
1667 fd3 = bpf_program__fd(skel->progs.tc3);
1668 fd4 = bpf_program__fd(skel->progs.tc4);
1669
1670 id1 = id_from_prog_fd(fd1);
1671 id2 = id_from_prog_fd(fd2);
1672 id3 = id_from_prog_fd(fd3);
1673 id4 = id_from_prog_fd(fd4);
1674
1675 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
1676 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
1677 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
1678
1679 assert_mprog_count(target, 0);
1680
1681 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1682 if (!ASSERT_EQ(err, 0, "prog_attach"))
1683 goto cleanup;
1684
1685 assert_mprog_count(target, 1);
1686
1687 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
1688 if (!ASSERT_EQ(err, 0, "prog_attach"))
1689 goto cleanup1;
1690
1691 assert_mprog_count(target, 2);
1692
1693 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
1694 if (!ASSERT_EQ(err, 0, "prog_attach"))
1695 goto cleanup2;
1696
1697 assert_mprog_count(target, 3);
1698
1699 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
1700 if (!ASSERT_EQ(err, 0, "prog_attach"))
1701 goto cleanup3;
1702
1703 assert_mprog_count(target, 4);
1704
1705 optq.prog_ids = prog_ids;
1706
1707 memset(prog_ids, 0, sizeof(prog_ids));
1708 optq.count = ARRAY_SIZE(prog_ids);
1709
1710 err = bpf_prog_query_opts(loopback, target, &optq);
1711 if (!ASSERT_OK(err, "prog_query"))
1712 goto cleanup4;
1713
1714 ASSERT_EQ(optq.count, 4, "count");
1715 ASSERT_EQ(optq.revision, 5, "revision");
1716 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
1717 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
1718 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
1719 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
1720 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1721
1722 LIBBPF_OPTS_RESET(optd,
1723 .flags = BPF_F_BEFORE,
1724 );
1725
1726 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1727 ASSERT_OK(err, "prog_detach");
1728
1729 assert_mprog_count(target, 3);
1730
1731 memset(prog_ids, 0, sizeof(prog_ids));
1732 optq.count = ARRAY_SIZE(prog_ids);
1733
1734 err = bpf_prog_query_opts(loopback, target, &optq);
1735 if (!ASSERT_OK(err, "prog_query"))
1736 goto cleanup4;
1737
1738 ASSERT_EQ(optq.count, 3, "count");
1739 ASSERT_EQ(optq.revision, 6, "revision");
1740 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
1741 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
1742 ASSERT_EQ(optq.prog_ids[2], id4, "prog_ids[2]");
1743 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
1744
1745 LIBBPF_OPTS_RESET(optd,
1746 .flags = BPF_F_AFTER,
1747 );
1748
1749 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1750 ASSERT_OK(err, "prog_detach");
1751
1752 assert_mprog_count(target, 2);
1753
1754 memset(prog_ids, 0, sizeof(prog_ids));
1755 optq.count = ARRAY_SIZE(prog_ids);
1756
1757 err = bpf_prog_query_opts(loopback, target, &optq);
1758 if (!ASSERT_OK(err, "prog_query"))
1759 goto cleanup4;
1760
1761 ASSERT_EQ(optq.count, 2, "count");
1762 ASSERT_EQ(optq.revision, 7, "revision");
1763 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
1764 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
1765 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1766
1767 LIBBPF_OPTS_RESET(optd);
1768
1769 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
1770 ASSERT_OK(err, "prog_detach");
1771 assert_mprog_count(target, 1);
1772
1773 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1774 ASSERT_OK(err, "prog_detach");
1775 assert_mprog_count(target, 0);
1776
1777 LIBBPF_OPTS_RESET(optd,
1778 .flags = BPF_F_BEFORE,
1779 );
1780
1781 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1782 ASSERT_EQ(err, -ENOENT, "prog_detach");
1783
1784 LIBBPF_OPTS_RESET(optd,
1785 .flags = BPF_F_AFTER,
1786 );
1787
1788 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1789 ASSERT_EQ(err, -ENOENT, "prog_detach");
1790 goto cleanup;
1791
1792 cleanup4:
1793 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
1794 ASSERT_OK(err, "prog_detach");
1795 assert_mprog_count(target, 3);
1796
1797 cleanup3:
1798 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
1799 ASSERT_OK(err, "prog_detach");
1800 assert_mprog_count(target, 2);
1801
1802 cleanup2:
1803 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1804 ASSERT_OK(err, "prog_detach");
1805 assert_mprog_count(target, 1);
1806
1807 cleanup1:
1808 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1809 ASSERT_OK(err, "prog_detach");
1810 assert_mprog_count(target, 0);
1811
1812 cleanup:
1813 test_tc_link__destroy(skel);
1814 }
1815
1816 void serial_test_tc_opts_detach(void)
1817 {
1818 test_tc_opts_detach_target(BPF_TCX_INGRESS);
1819 test_tc_opts_detach_target(BPF_TCX_EGRESS);
1820 }
1821
1822 static void test_tc_opts_detach_before_target(int target)
1823 {
1824 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
1825 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
1826 LIBBPF_OPTS(bpf_prog_query_opts, optq);
1827 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
1828 struct test_tc_link *skel;
1829 __u32 prog_ids[5];
1830 int err;
1831
1832 skel = test_tc_link__open_and_load();
1833 if (!ASSERT_OK_PTR(skel, "skel_load"))
1834 goto cleanup;
1835
1836 fd1 = bpf_program__fd(skel->progs.tc1);
1837 fd2 = bpf_program__fd(skel->progs.tc2);
1838 fd3 = bpf_program__fd(skel->progs.tc3);
1839 fd4 = bpf_program__fd(skel->progs.tc4);
1840
1841 id1 = id_from_prog_fd(fd1);
1842 id2 = id_from_prog_fd(fd2);
1843 id3 = id_from_prog_fd(fd3);
1844 id4 = id_from_prog_fd(fd4);
1845
1846 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
1847 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
1848 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
1849
1850 assert_mprog_count(target, 0);
1851
1852 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
1853 if (!ASSERT_EQ(err, 0, "prog_attach"))
1854 goto cleanup;
1855
1856 assert_mprog_count(target, 1);
1857
1858 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
1859 if (!ASSERT_EQ(err, 0, "prog_attach"))
1860 goto cleanup1;
1861
1862 assert_mprog_count(target, 2);
1863
1864 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
1865 if (!ASSERT_EQ(err, 0, "prog_attach"))
1866 goto cleanup2;
1867
1868 assert_mprog_count(target, 3);
1869
1870 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
1871 if (!ASSERT_EQ(err, 0, "prog_attach"))
1872 goto cleanup3;
1873
1874 assert_mprog_count(target, 4);
1875
1876 optq.prog_ids = prog_ids;
1877
1878 memset(prog_ids, 0, sizeof(prog_ids));
1879 optq.count = ARRAY_SIZE(prog_ids);
1880
1881 err = bpf_prog_query_opts(loopback, target, &optq);
1882 if (!ASSERT_OK(err, "prog_query"))
1883 goto cleanup4;
1884
1885 ASSERT_EQ(optq.count, 4, "count");
1886 ASSERT_EQ(optq.revision, 5, "revision");
1887 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
1888 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
1889 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
1890 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
1891 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
1892
1893 LIBBPF_OPTS_RESET(optd,
1894 .flags = BPF_F_BEFORE,
1895 .relative_fd = fd2,
1896 );
1897
1898 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1899 ASSERT_OK(err, "prog_detach");
1900
1901 assert_mprog_count(target, 3);
1902
1903 memset(prog_ids, 0, sizeof(prog_ids));
1904 optq.count = ARRAY_SIZE(prog_ids);
1905
1906 err = bpf_prog_query_opts(loopback, target, &optq);
1907 if (!ASSERT_OK(err, "prog_query"))
1908 goto cleanup4;
1909
1910 ASSERT_EQ(optq.count, 3, "count");
1911 ASSERT_EQ(optq.revision, 6, "revision");
1912 ASSERT_EQ(optq.prog_ids[0], id2, "prog_ids[0]");
1913 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
1914 ASSERT_EQ(optq.prog_ids[2], id4, "prog_ids[2]");
1915 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
1916
1917 LIBBPF_OPTS_RESET(optd,
1918 .flags = BPF_F_BEFORE,
1919 .relative_fd = fd2,
1920 );
1921
1922 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
1923 ASSERT_EQ(err, -ENOENT, "prog_detach");
1924 assert_mprog_count(target, 3);
1925
1926 LIBBPF_OPTS_RESET(optd,
1927 .flags = BPF_F_BEFORE,
1928 .relative_fd = fd4,
1929 );
1930
1931 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1932 ASSERT_EQ(err, -ERANGE, "prog_detach");
1933 assert_mprog_count(target, 3);
1934
1935 LIBBPF_OPTS_RESET(optd,
1936 .flags = BPF_F_BEFORE,
1937 .relative_fd = fd1,
1938 );
1939
1940 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1941 ASSERT_EQ(err, -ENOENT, "prog_detach");
1942 assert_mprog_count(target, 3);
1943
1944 LIBBPF_OPTS_RESET(optd,
1945 .flags = BPF_F_BEFORE,
1946 .relative_fd = fd3,
1947 );
1948
1949 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
1950 ASSERT_OK(err, "prog_detach");
1951
1952 assert_mprog_count(target, 2);
1953
1954 memset(prog_ids, 0, sizeof(prog_ids));
1955 optq.count = ARRAY_SIZE(prog_ids);
1956
1957 err = bpf_prog_query_opts(loopback, target, &optq);
1958 if (!ASSERT_OK(err, "prog_query"))
1959 goto cleanup4;
1960
1961 ASSERT_EQ(optq.count, 2, "count");
1962 ASSERT_EQ(optq.revision, 7, "revision");
1963 ASSERT_EQ(optq.prog_ids[0], id3, "prog_ids[0]");
1964 ASSERT_EQ(optq.prog_ids[1], id4, "prog_ids[1]");
1965 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
1966
1967 LIBBPF_OPTS_RESET(optd,
1968 .flags = BPF_F_BEFORE,
1969 .relative_fd = fd4,
1970 );
1971
1972 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1973 ASSERT_OK(err, "prog_detach");
1974
1975 assert_mprog_count(target, 1);
1976
1977 memset(prog_ids, 0, sizeof(prog_ids));
1978 optq.count = ARRAY_SIZE(prog_ids);
1979
1980 err = bpf_prog_query_opts(loopback, target, &optq);
1981 if (!ASSERT_OK(err, "prog_query"))
1982 goto cleanup4;
1983
1984 ASSERT_EQ(optq.count, 1, "count");
1985 ASSERT_EQ(optq.revision, 8, "revision");
1986 ASSERT_EQ(optq.prog_ids[0], id4, "prog_ids[0]");
1987 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
1988
1989 LIBBPF_OPTS_RESET(optd,
1990 .flags = BPF_F_BEFORE,
1991 );
1992
1993 err = bpf_prog_detach_opts(0, loopback, target, &optd);
1994 ASSERT_OK(err, "prog_detach");
1995
1996 assert_mprog_count(target, 0);
1997 goto cleanup;
1998
1999 cleanup4:
2000 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
2001 ASSERT_OK(err, "prog_detach");
2002 assert_mprog_count(target, 3);
2003
2004 cleanup3:
2005 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
2006 ASSERT_OK(err, "prog_detach");
2007 assert_mprog_count(target, 2);
2008
2009 cleanup2:
2010 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
2011 ASSERT_OK(err, "prog_detach");
2012 assert_mprog_count(target, 1);
2013
2014 cleanup1:
2015 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2016 ASSERT_OK(err, "prog_detach");
2017 assert_mprog_count(target, 0);
2018
2019 cleanup:
2020 test_tc_link__destroy(skel);
2021 }
2022
2023 void serial_test_tc_opts_detach_before(void)
2024 {
2025 test_tc_opts_detach_before_target(BPF_TCX_INGRESS);
2026 test_tc_opts_detach_before_target(BPF_TCX_EGRESS);
2027 }
2028
2029 static void test_tc_opts_detach_after_target(int target)
2030 {
2031 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
2032 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
2033 LIBBPF_OPTS(bpf_prog_query_opts, optq);
2034 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
2035 struct test_tc_link *skel;
2036 __u32 prog_ids[5];
2037 int err;
2038
2039 skel = test_tc_link__open_and_load();
2040 if (!ASSERT_OK_PTR(skel, "skel_load"))
2041 goto cleanup;
2042
2043 fd1 = bpf_program__fd(skel->progs.tc1);
2044 fd2 = bpf_program__fd(skel->progs.tc2);
2045 fd3 = bpf_program__fd(skel->progs.tc3);
2046 fd4 = bpf_program__fd(skel->progs.tc4);
2047
2048 id1 = id_from_prog_fd(fd1);
2049 id2 = id_from_prog_fd(fd2);
2050 id3 = id_from_prog_fd(fd3);
2051 id4 = id_from_prog_fd(fd4);
2052
2053 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
2054 ASSERT_NEQ(id3, id4, "prog_ids_3_4");
2055 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
2056
2057 assert_mprog_count(target, 0);
2058
2059 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
2060 if (!ASSERT_EQ(err, 0, "prog_attach"))
2061 goto cleanup;
2062
2063 assert_mprog_count(target, 1);
2064
2065 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
2066 if (!ASSERT_EQ(err, 0, "prog_attach"))
2067 goto cleanup1;
2068
2069 assert_mprog_count(target, 2);
2070
2071 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
2072 if (!ASSERT_EQ(err, 0, "prog_attach"))
2073 goto cleanup2;
2074
2075 assert_mprog_count(target, 3);
2076
2077 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
2078 if (!ASSERT_EQ(err, 0, "prog_attach"))
2079 goto cleanup3;
2080
2081 assert_mprog_count(target, 4);
2082
2083 optq.prog_ids = prog_ids;
2084
2085 memset(prog_ids, 0, sizeof(prog_ids));
2086 optq.count = ARRAY_SIZE(prog_ids);
2087
2088 err = bpf_prog_query_opts(loopback, target, &optq);
2089 if (!ASSERT_OK(err, "prog_query"))
2090 goto cleanup4;
2091
2092 ASSERT_EQ(optq.count, 4, "count");
2093 ASSERT_EQ(optq.revision, 5, "revision");
2094 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2095 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
2096 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
2097 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
2098 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
2099
2100 LIBBPF_OPTS_RESET(optd,
2101 .flags = BPF_F_AFTER,
2102 .relative_fd = fd1,
2103 );
2104
2105 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
2106 ASSERT_OK(err, "prog_detach");
2107
2108 assert_mprog_count(target, 3);
2109
2110 memset(prog_ids, 0, sizeof(prog_ids));
2111 optq.count = ARRAY_SIZE(prog_ids);
2112
2113 err = bpf_prog_query_opts(loopback, target, &optq);
2114 if (!ASSERT_OK(err, "prog_query"))
2115 goto cleanup4;
2116
2117 ASSERT_EQ(optq.count, 3, "count");
2118 ASSERT_EQ(optq.revision, 6, "revision");
2119 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2120 ASSERT_EQ(optq.prog_ids[1], id3, "prog_ids[1]");
2121 ASSERT_EQ(optq.prog_ids[2], id4, "prog_ids[2]");
2122 ASSERT_EQ(optq.prog_ids[3], 0, "prog_ids[3]");
2123
2124 LIBBPF_OPTS_RESET(optd,
2125 .flags = BPF_F_AFTER,
2126 .relative_fd = fd1,
2127 );
2128
2129 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
2130 ASSERT_EQ(err, -ENOENT, "prog_detach");
2131 assert_mprog_count(target, 3);
2132
2133 LIBBPF_OPTS_RESET(optd,
2134 .flags = BPF_F_AFTER,
2135 .relative_fd = fd4,
2136 );
2137
2138 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2139 ASSERT_EQ(err, -ERANGE, "prog_detach");
2140 assert_mprog_count(target, 3);
2141
2142 LIBBPF_OPTS_RESET(optd,
2143 .flags = BPF_F_AFTER,
2144 .relative_fd = fd3,
2145 );
2146
2147 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2148 ASSERT_EQ(err, -ERANGE, "prog_detach");
2149 assert_mprog_count(target, 3);
2150
2151 LIBBPF_OPTS_RESET(optd,
2152 .flags = BPF_F_AFTER,
2153 .relative_fd = fd1,
2154 );
2155
2156 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2157 ASSERT_EQ(err, -ERANGE, "prog_detach");
2158 assert_mprog_count(target, 3);
2159
2160 LIBBPF_OPTS_RESET(optd,
2161 .flags = BPF_F_AFTER,
2162 .relative_fd = fd1,
2163 );
2164
2165 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
2166 ASSERT_OK(err, "prog_detach");
2167
2168 assert_mprog_count(target, 2);
2169
2170 memset(prog_ids, 0, sizeof(prog_ids));
2171 optq.count = ARRAY_SIZE(prog_ids);
2172
2173 err = bpf_prog_query_opts(loopback, target, &optq);
2174 if (!ASSERT_OK(err, "prog_query"))
2175 goto cleanup4;
2176
2177 ASSERT_EQ(optq.count, 2, "count");
2178 ASSERT_EQ(optq.revision, 7, "revision");
2179 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2180 ASSERT_EQ(optq.prog_ids[1], id4, "prog_ids[1]");
2181 ASSERT_EQ(optq.prog_ids[2], 0, "prog_ids[2]");
2182
2183 LIBBPF_OPTS_RESET(optd,
2184 .flags = BPF_F_AFTER,
2185 .relative_fd = fd1,
2186 );
2187
2188 err = bpf_prog_detach_opts(0, loopback, target, &optd);
2189 ASSERT_OK(err, "prog_detach");
2190
2191 assert_mprog_count(target, 1);
2192
2193 memset(prog_ids, 0, sizeof(prog_ids));
2194 optq.count = ARRAY_SIZE(prog_ids);
2195
2196 err = bpf_prog_query_opts(loopback, target, &optq);
2197 if (!ASSERT_OK(err, "prog_query"))
2198 goto cleanup4;
2199
2200 ASSERT_EQ(optq.count, 1, "count");
2201 ASSERT_EQ(optq.revision, 8, "revision");
2202 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2203 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
2204
2205 LIBBPF_OPTS_RESET(optd,
2206 .flags = BPF_F_AFTER,
2207 );
2208
2209 err = bpf_prog_detach_opts(0, loopback, target, &optd);
2210 ASSERT_OK(err, "prog_detach");
2211
2212 assert_mprog_count(target, 0);
2213 goto cleanup;
2214
2215 cleanup4:
2216 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
2217 ASSERT_OK(err, "prog_detach");
2218 assert_mprog_count(target, 3);
2219
2220 cleanup3:
2221 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
2222 ASSERT_OK(err, "prog_detach");
2223 assert_mprog_count(target, 2);
2224
2225 cleanup2:
2226 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
2227 ASSERT_OK(err, "prog_detach");
2228 assert_mprog_count(target, 1);
2229
2230 cleanup1:
2231 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2232 ASSERT_OK(err, "prog_detach");
2233 assert_mprog_count(target, 0);
2234
2235 cleanup:
2236 test_tc_link__destroy(skel);
2237 }
2238
2239 void serial_test_tc_opts_detach_after(void)
2240 {
2241 test_tc_opts_detach_after_target(BPF_TCX_INGRESS);
2242 test_tc_opts_detach_after_target(BPF_TCX_EGRESS);
2243 }
2244
2245 static void test_tc_opts_delete_empty(int target, bool chain_tc_old)
2246 {
2247 LIBBPF_OPTS(bpf_tc_hook, tc_hook, .ifindex = loopback);
2248 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
2249 int err;
2250
2251 assert_mprog_count(target, 0);
2252 if (chain_tc_old) {
2253 tc_hook.attach_point = target == BPF_TCX_INGRESS ?
2254 BPF_TC_INGRESS : BPF_TC_EGRESS;
2255 err = bpf_tc_hook_create(&tc_hook);
2256 ASSERT_OK(err, "bpf_tc_hook_create");
2257 assert_mprog_count(target, 0);
2258 }
2259 err = bpf_prog_detach_opts(0, loopback, target, &optd);
2260 ASSERT_EQ(err, -ENOENT, "prog_detach");
2261 if (chain_tc_old) {
2262 tc_hook.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS;
2263 bpf_tc_hook_destroy(&tc_hook);
2264 }
2265 assert_mprog_count(target, 0);
2266 }
2267
2268 void serial_test_tc_opts_delete_empty(void)
2269 {
2270 test_tc_opts_delete_empty(BPF_TCX_INGRESS, false);
2271 test_tc_opts_delete_empty(BPF_TCX_EGRESS, false);
2272 test_tc_opts_delete_empty(BPF_TCX_INGRESS, true);
2273 test_tc_opts_delete_empty(BPF_TCX_EGRESS, true);
2274 }
2275
2276 static void test_tc_chain_mixed(int target)
2277 {
2278 LIBBPF_OPTS(bpf_tc_opts, tc_opts, .handle = 1, .priority = 1);
2279 LIBBPF_OPTS(bpf_tc_hook, tc_hook, .ifindex = loopback);
2280 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
2281 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
2282 __u32 fd1, fd2, fd3, id1, id2, id3;
2283 struct test_tc_link *skel;
2284 int err, detach_fd;
2285
2286 skel = test_tc_link__open_and_load();
2287 if (!ASSERT_OK_PTR(skel, "skel_load"))
2288 goto cleanup;
2289
2290 fd1 = bpf_program__fd(skel->progs.tc4);
2291 fd2 = bpf_program__fd(skel->progs.tc5);
2292 fd3 = bpf_program__fd(skel->progs.tc6);
2293
2294 id1 = id_from_prog_fd(fd1);
2295 id2 = id_from_prog_fd(fd2);
2296 id3 = id_from_prog_fd(fd3);
2297
2298 ASSERT_NEQ(id1, id2, "prog_ids_1_2");
2299 ASSERT_NEQ(id2, id3, "prog_ids_2_3");
2300
2301 assert_mprog_count(target, 0);
2302
2303 tc_hook.attach_point = target == BPF_TCX_INGRESS ?
2304 BPF_TC_INGRESS : BPF_TC_EGRESS;
2305 err = bpf_tc_hook_create(&tc_hook);
2306 err = err == -EEXIST ? 0 : err;
2307 if (!ASSERT_OK(err, "bpf_tc_hook_create"))
2308 goto cleanup;
2309
2310 tc_opts.prog_fd = fd2;
2311 err = bpf_tc_attach(&tc_hook, &tc_opts);
2312 if (!ASSERT_OK(err, "bpf_tc_attach"))
2313 goto cleanup_hook;
2314
2315 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
2316 if (!ASSERT_EQ(err, 0, "prog_attach"))
2317 goto cleanup_filter;
2318
2319 detach_fd = fd3;
2320
2321 assert_mprog_count(target, 1);
2322
2323 tc_skel_reset_all_seen(skel);
2324 ASSERT_OK(system(ping_cmd), ping_cmd);
2325
2326 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
2327 ASSERT_EQ(skel->bss->seen_tc5, false, "seen_tc5");
2328 ASSERT_EQ(skel->bss->seen_tc6, true, "seen_tc6");
2329
2330 LIBBPF_OPTS_RESET(opta,
2331 .flags = BPF_F_REPLACE,
2332 .replace_prog_fd = fd3,
2333 );
2334
2335 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
2336 if (!ASSERT_EQ(err, 0, "prog_attach"))
2337 goto cleanup_opts;
2338
2339 detach_fd = fd1;
2340
2341 assert_mprog_count(target, 1);
2342
2343 tc_skel_reset_all_seen(skel);
2344 ASSERT_OK(system(ping_cmd), ping_cmd);
2345
2346 ASSERT_EQ(skel->bss->seen_tc4, true, "seen_tc4");
2347 ASSERT_EQ(skel->bss->seen_tc5, true, "seen_tc5");
2348 ASSERT_EQ(skel->bss->seen_tc6, false, "seen_tc6");
2349
2350 cleanup_opts:
2351 err = bpf_prog_detach_opts(detach_fd, loopback, target, &optd);
2352 ASSERT_OK(err, "prog_detach");
2353 assert_mprog_count(target, 0);
2354
2355 tc_skel_reset_all_seen(skel);
2356 ASSERT_OK(system(ping_cmd), ping_cmd);
2357
2358 ASSERT_EQ(skel->bss->seen_tc4, false, "seen_tc4");
2359 ASSERT_EQ(skel->bss->seen_tc5, true, "seen_tc5");
2360 ASSERT_EQ(skel->bss->seen_tc6, false, "seen_tc6");
2361
2362 cleanup_filter:
2363 tc_opts.flags = tc_opts.prog_fd = tc_opts.prog_id = 0;
2364 err = bpf_tc_detach(&tc_hook, &tc_opts);
2365 ASSERT_OK(err, "bpf_tc_detach");
2366
2367 cleanup_hook:
2368 tc_hook.attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS;
2369 bpf_tc_hook_destroy(&tc_hook);
2370
2371 cleanup:
2372 test_tc_link__destroy(skel);
2373 }
2374
2375 void serial_test_tc_opts_chain_mixed(void)
2376 {
2377 test_tc_chain_mixed(BPF_TCX_INGRESS);
2378 test_tc_chain_mixed(BPF_TCX_EGRESS);
2379 }
2380
2381 static int generate_dummy_prog(void)
2382 {
2383 const struct bpf_insn prog_insns[] = {
2384 BPF_MOV64_IMM(BPF_REG_0, 0),
2385 BPF_EXIT_INSN(),
2386 };
2387 const size_t prog_insn_cnt = sizeof(prog_insns) / sizeof(struct bpf_insn);
2388 LIBBPF_OPTS(bpf_prog_load_opts, opts);
2389 const size_t log_buf_sz = 256;
2390 char log_buf[log_buf_sz];
2391 int fd = -1;
2392
2393 opts.log_buf = log_buf;
2394 opts.log_size = log_buf_sz;
2395
2396 log_buf[0] = '\0';
2397 opts.log_level = 0;
2398 fd = bpf_prog_load(BPF_PROG_TYPE_SCHED_CLS, "tcx_prog", "GPL",
2399 prog_insns, prog_insn_cnt, &opts);
2400 ASSERT_STREQ(log_buf, "", "log_0");
2401 ASSERT_GE(fd, 0, "prog_fd");
2402 return fd;
2403 }
2404
2405 static void test_tc_opts_max_target(int target, int flags, bool relative)
2406 {
2407 int err, ifindex, i, prog_fd, last_fd = -1;
2408 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
2409 const int max_progs = 63;
2410
2411 ASSERT_OK(system("ip link add dev tcx_opts1 type veth peer name tcx_opts2"), "add veth");
2412 ifindex = if_nametoindex("tcx_opts1");
2413 ASSERT_NEQ(ifindex, 0, "non_zero_ifindex");
2414
2415 assert_mprog_count_ifindex(ifindex, target, 0);
2416
2417 for (i = 0; i < max_progs; i++) {
2418 prog_fd = generate_dummy_prog();
2419 if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
2420 goto cleanup;
2421 err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
2422 if (!ASSERT_EQ(err, 0, "prog_attach"))
2423 goto cleanup;
2424 assert_mprog_count_ifindex(ifindex, target, i + 1);
2425 if (i == max_progs - 1 && relative)
2426 last_fd = prog_fd;
2427 else
2428 close(prog_fd);
2429 }
2430
2431 prog_fd = generate_dummy_prog();
2432 if (!ASSERT_GE(prog_fd, 0, "dummy_prog"))
2433 goto cleanup;
2434 opta.flags = flags;
2435 if (last_fd > 0)
2436 opta.relative_fd = last_fd;
2437 err = bpf_prog_attach_opts(prog_fd, ifindex, target, &opta);
2438 ASSERT_EQ(err, -ERANGE, "prog_64_attach");
2439 assert_mprog_count_ifindex(ifindex, target, max_progs);
2440 close(prog_fd);
2441 cleanup:
2442 if (last_fd > 0)
2443 close(last_fd);
2444 ASSERT_OK(system("ip link del dev tcx_opts1"), "del veth");
2445 ASSERT_EQ(if_nametoindex("tcx_opts1"), 0, "dev1_removed");
2446 ASSERT_EQ(if_nametoindex("tcx_opts2"), 0, "dev2_removed");
2447 }
2448
2449 void serial_test_tc_opts_max(void)
2450 {
2451 test_tc_opts_max_target(BPF_TCX_INGRESS, 0, false);
2452 test_tc_opts_max_target(BPF_TCX_EGRESS, 0, false);
2453
2454 test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_BEFORE, false);
2455 test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_BEFORE, true);
2456
2457 test_tc_opts_max_target(BPF_TCX_INGRESS, BPF_F_AFTER, true);
2458 test_tc_opts_max_target(BPF_TCX_EGRESS, BPF_F_AFTER, false);
2459 }
2460
2461 static void test_tc_opts_query_target(int target)
2462 {
2463 const size_t attr_size = offsetofend(union bpf_attr, query);
2464 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
2465 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
2466 LIBBPF_OPTS(bpf_prog_query_opts, optq);
2467 __u32 fd1, fd2, fd3, fd4, id1, id2, id3, id4;
2468 struct test_tc_link *skel;
2469 union bpf_attr attr;
2470 __u32 prog_ids[10];
2471 int err;
2472
2473 skel = test_tc_link__open_and_load();
2474 if (!ASSERT_OK_PTR(skel, "skel_load"))
2475 goto cleanup;
2476
2477 fd1 = bpf_program__fd(skel->progs.tc1);
2478 fd2 = bpf_program__fd(skel->progs.tc2);
2479 fd3 = bpf_program__fd(skel->progs.tc3);
2480 fd4 = bpf_program__fd(skel->progs.tc4);
2481
2482 id1 = id_from_prog_fd(fd1);
2483 id2 = id_from_prog_fd(fd2);
2484 id3 = id_from_prog_fd(fd3);
2485 id4 = id_from_prog_fd(fd4);
2486
2487 assert_mprog_count(target, 0);
2488
2489 LIBBPF_OPTS_RESET(opta,
2490 .expected_revision = 1,
2491 );
2492
2493 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
2494 if (!ASSERT_EQ(err, 0, "prog_attach"))
2495 goto cleanup;
2496
2497 assert_mprog_count(target, 1);
2498
2499 LIBBPF_OPTS_RESET(opta,
2500 .expected_revision = 2,
2501 );
2502
2503 err = bpf_prog_attach_opts(fd2, loopback, target, &opta);
2504 if (!ASSERT_EQ(err, 0, "prog_attach"))
2505 goto cleanup1;
2506
2507 assert_mprog_count(target, 2);
2508
2509 LIBBPF_OPTS_RESET(opta,
2510 .expected_revision = 3,
2511 );
2512
2513 err = bpf_prog_attach_opts(fd3, loopback, target, &opta);
2514 if (!ASSERT_EQ(err, 0, "prog_attach"))
2515 goto cleanup2;
2516
2517 assert_mprog_count(target, 3);
2518
2519 LIBBPF_OPTS_RESET(opta,
2520 .expected_revision = 4,
2521 );
2522
2523 err = bpf_prog_attach_opts(fd4, loopback, target, &opta);
2524 if (!ASSERT_EQ(err, 0, "prog_attach"))
2525 goto cleanup3;
2526
2527 assert_mprog_count(target, 4);
2528
2529 /* Test 1: Double query via libbpf API */
2530 err = bpf_prog_query_opts(loopback, target, &optq);
2531 if (!ASSERT_OK(err, "prog_query"))
2532 goto cleanup4;
2533
2534 ASSERT_EQ(optq.count, 4, "count");
2535 ASSERT_EQ(optq.revision, 5, "revision");
2536 ASSERT_EQ(optq.prog_ids, NULL, "prog_ids");
2537 ASSERT_EQ(optq.link_ids, NULL, "link_ids");
2538
2539 memset(prog_ids, 0, sizeof(prog_ids));
2540 optq.prog_ids = prog_ids;
2541
2542 err = bpf_prog_query_opts(loopback, target, &optq);
2543 if (!ASSERT_OK(err, "prog_query"))
2544 goto cleanup4;
2545
2546 ASSERT_EQ(optq.count, 4, "count");
2547 ASSERT_EQ(optq.revision, 5, "revision");
2548 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2549 ASSERT_EQ(optq.prog_ids[1], id2, "prog_ids[1]");
2550 ASSERT_EQ(optq.prog_ids[2], id3, "prog_ids[2]");
2551 ASSERT_EQ(optq.prog_ids[3], id4, "prog_ids[3]");
2552 ASSERT_EQ(optq.prog_ids[4], 0, "prog_ids[4]");
2553 ASSERT_EQ(optq.link_ids, NULL, "link_ids");
2554
2555 /* Test 2: Double query via bpf_attr & bpf(2) directly */
2556 memset(&attr, 0, attr_size);
2557 attr.query.target_ifindex = loopback;
2558 attr.query.attach_type = target;
2559
2560 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2561 if (!ASSERT_OK(err, "prog_query"))
2562 goto cleanup4;
2563
2564 ASSERT_EQ(attr.query.count, 4, "count");
2565 ASSERT_EQ(attr.query.revision, 5, "revision");
2566 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2567 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2568 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2569 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2570 ASSERT_EQ(attr.query.prog_ids, 0, "prog_ids");
2571 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2572 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2573 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2574
2575 memset(prog_ids, 0, sizeof(prog_ids));
2576 attr.query.prog_ids = ptr_to_u64(prog_ids);
2577
2578 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2579 if (!ASSERT_OK(err, "prog_query"))
2580 goto cleanup4;
2581
2582 ASSERT_EQ(attr.query.count, 4, "count");
2583 ASSERT_EQ(attr.query.revision, 5, "revision");
2584 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2585 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2586 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2587 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2588 ASSERT_EQ(attr.query.prog_ids, ptr_to_u64(prog_ids), "prog_ids");
2589 ASSERT_EQ(prog_ids[0], id1, "prog_ids[0]");
2590 ASSERT_EQ(prog_ids[1], id2, "prog_ids[1]");
2591 ASSERT_EQ(prog_ids[2], id3, "prog_ids[2]");
2592 ASSERT_EQ(prog_ids[3], id4, "prog_ids[3]");
2593 ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
2594 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2595 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2596 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2597
2598 /* Test 3: Query with smaller prog_ids array */
2599 memset(&attr, 0, attr_size);
2600 attr.query.target_ifindex = loopback;
2601 attr.query.attach_type = target;
2602
2603 memset(prog_ids, 0, sizeof(prog_ids));
2604 attr.query.prog_ids = ptr_to_u64(prog_ids);
2605 attr.query.count = 2;
2606
2607 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2608 ASSERT_EQ(err, -1, "prog_query_should_fail");
2609 ASSERT_EQ(errno, ENOSPC, "prog_query_should_fail");
2610
2611 ASSERT_EQ(attr.query.count, 4, "count");
2612 ASSERT_EQ(attr.query.revision, 5, "revision");
2613 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2614 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2615 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2616 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2617 ASSERT_EQ(attr.query.prog_ids, ptr_to_u64(prog_ids), "prog_ids");
2618 ASSERT_EQ(prog_ids[0], id1, "prog_ids[0]");
2619 ASSERT_EQ(prog_ids[1], id2, "prog_ids[1]");
2620 ASSERT_EQ(prog_ids[2], 0, "prog_ids[2]");
2621 ASSERT_EQ(prog_ids[3], 0, "prog_ids[3]");
2622 ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
2623 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2624 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2625 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2626
2627 /* Test 4: Query with larger prog_ids array */
2628 memset(&attr, 0, attr_size);
2629 attr.query.target_ifindex = loopback;
2630 attr.query.attach_type = target;
2631
2632 memset(prog_ids, 0, sizeof(prog_ids));
2633 attr.query.prog_ids = ptr_to_u64(prog_ids);
2634 attr.query.count = 10;
2635
2636 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2637 if (!ASSERT_OK(err, "prog_query"))
2638 goto cleanup4;
2639
2640 ASSERT_EQ(attr.query.count, 4, "count");
2641 ASSERT_EQ(attr.query.revision, 5, "revision");
2642 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2643 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2644 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2645 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2646 ASSERT_EQ(attr.query.prog_ids, ptr_to_u64(prog_ids), "prog_ids");
2647 ASSERT_EQ(prog_ids[0], id1, "prog_ids[0]");
2648 ASSERT_EQ(prog_ids[1], id2, "prog_ids[1]");
2649 ASSERT_EQ(prog_ids[2], id3, "prog_ids[2]");
2650 ASSERT_EQ(prog_ids[3], id4, "prog_ids[3]");
2651 ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
2652 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2653 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2654 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2655
2656 /* Test 5: Query with NULL prog_ids array but with count > 0 */
2657 memset(&attr, 0, attr_size);
2658 attr.query.target_ifindex = loopback;
2659 attr.query.attach_type = target;
2660
2661 memset(prog_ids, 0, sizeof(prog_ids));
2662 attr.query.count = sizeof(prog_ids);
2663
2664 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2665 if (!ASSERT_OK(err, "prog_query"))
2666 goto cleanup4;
2667
2668 ASSERT_EQ(attr.query.count, 4, "count");
2669 ASSERT_EQ(attr.query.revision, 5, "revision");
2670 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2671 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2672 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2673 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2674 ASSERT_EQ(prog_ids[0], 0, "prog_ids[0]");
2675 ASSERT_EQ(prog_ids[1], 0, "prog_ids[1]");
2676 ASSERT_EQ(prog_ids[2], 0, "prog_ids[2]");
2677 ASSERT_EQ(prog_ids[3], 0, "prog_ids[3]");
2678 ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
2679 ASSERT_EQ(attr.query.prog_ids, 0, "prog_ids");
2680 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2681 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2682 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2683
2684 /* Test 6: Query with non-NULL prog_ids array but with count == 0 */
2685 memset(&attr, 0, attr_size);
2686 attr.query.target_ifindex = loopback;
2687 attr.query.attach_type = target;
2688
2689 memset(prog_ids, 0, sizeof(prog_ids));
2690 attr.query.prog_ids = ptr_to_u64(prog_ids);
2691
2692 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2693 if (!ASSERT_OK(err, "prog_query"))
2694 goto cleanup4;
2695
2696 ASSERT_EQ(attr.query.count, 4, "count");
2697 ASSERT_EQ(attr.query.revision, 5, "revision");
2698 ASSERT_EQ(attr.query.query_flags, 0, "query_flags");
2699 ASSERT_EQ(attr.query.attach_flags, 0, "attach_flags");
2700 ASSERT_EQ(attr.query.target_ifindex, loopback, "target_ifindex");
2701 ASSERT_EQ(attr.query.attach_type, target, "attach_type");
2702 ASSERT_EQ(prog_ids[0], 0, "prog_ids[0]");
2703 ASSERT_EQ(prog_ids[1], 0, "prog_ids[1]");
2704 ASSERT_EQ(prog_ids[2], 0, "prog_ids[2]");
2705 ASSERT_EQ(prog_ids[3], 0, "prog_ids[3]");
2706 ASSERT_EQ(prog_ids[4], 0, "prog_ids[4]");
2707 ASSERT_EQ(attr.query.prog_ids, ptr_to_u64(prog_ids), "prog_ids");
2708 ASSERT_EQ(attr.query.prog_attach_flags, 0, "prog_attach_flags");
2709 ASSERT_EQ(attr.query.link_ids, 0, "link_ids");
2710 ASSERT_EQ(attr.query.link_attach_flags, 0, "link_attach_flags");
2711
2712 /* Test 7: Query with invalid flags */
2713 attr.query.attach_flags = 0;
2714 attr.query.query_flags = 1;
2715
2716 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2717 ASSERT_EQ(err, -1, "prog_query_should_fail");
2718 ASSERT_EQ(errno, EINVAL, "prog_query_should_fail");
2719
2720 attr.query.attach_flags = 1;
2721 attr.query.query_flags = 0;
2722
2723 err = syscall(__NR_bpf, BPF_PROG_QUERY, &attr, attr_size);
2724 ASSERT_EQ(err, -1, "prog_query_should_fail");
2725 ASSERT_EQ(errno, EINVAL, "prog_query_should_fail");
2726
2727 cleanup4:
2728 err = bpf_prog_detach_opts(fd4, loopback, target, &optd);
2729 ASSERT_OK(err, "prog_detach");
2730 assert_mprog_count(target, 3);
2731
2732 cleanup3:
2733 err = bpf_prog_detach_opts(fd3, loopback, target, &optd);
2734 ASSERT_OK(err, "prog_detach");
2735 assert_mprog_count(target, 2);
2736
2737 cleanup2:
2738 err = bpf_prog_detach_opts(fd2, loopback, target, &optd);
2739 ASSERT_OK(err, "prog_detach");
2740 assert_mprog_count(target, 1);
2741
2742 cleanup1:
2743 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2744 ASSERT_OK(err, "prog_detach");
2745 assert_mprog_count(target, 0);
2746
2747 cleanup:
2748 test_tc_link__destroy(skel);
2749 }
2750
2751 void serial_test_tc_opts_query(void)
2752 {
2753 test_tc_opts_query_target(BPF_TCX_INGRESS);
2754 test_tc_opts_query_target(BPF_TCX_EGRESS);
2755 }
2756
2757 static void test_tc_opts_query_attach_target(int target)
2758 {
2759 LIBBPF_OPTS(bpf_prog_attach_opts, opta);
2760 LIBBPF_OPTS(bpf_prog_detach_opts, optd);
2761 LIBBPF_OPTS(bpf_prog_query_opts, optq);
2762 struct test_tc_link *skel;
2763 __u32 prog_ids[2];
2764 __u32 fd1, id1;
2765 int err;
2766
2767 skel = test_tc_link__open_and_load();
2768 if (!ASSERT_OK_PTR(skel, "skel_load"))
2769 goto cleanup;
2770
2771 fd1 = bpf_program__fd(skel->progs.tc1);
2772 id1 = id_from_prog_fd(fd1);
2773
2774 err = bpf_prog_query_opts(loopback, target, &optq);
2775 if (!ASSERT_OK(err, "prog_query"))
2776 goto cleanup;
2777
2778 ASSERT_EQ(optq.count, 0, "count");
2779 ASSERT_EQ(optq.revision, 1, "revision");
2780
2781 LIBBPF_OPTS_RESET(opta,
2782 .expected_revision = optq.revision,
2783 );
2784
2785 err = bpf_prog_attach_opts(fd1, loopback, target, &opta);
2786 if (!ASSERT_EQ(err, 0, "prog_attach"))
2787 goto cleanup;
2788
2789 memset(prog_ids, 0, sizeof(prog_ids));
2790 optq.prog_ids = prog_ids;
2791 optq.count = ARRAY_SIZE(prog_ids);
2792
2793 err = bpf_prog_query_opts(loopback, target, &optq);
2794 if (!ASSERT_OK(err, "prog_query"))
2795 goto cleanup1;
2796
2797 ASSERT_EQ(optq.count, 1, "count");
2798 ASSERT_EQ(optq.revision, 2, "revision");
2799 ASSERT_EQ(optq.prog_ids[0], id1, "prog_ids[0]");
2800 ASSERT_EQ(optq.prog_ids[1], 0, "prog_ids[1]");
2801
2802 cleanup1:
2803 err = bpf_prog_detach_opts(fd1, loopback, target, &optd);
2804 ASSERT_OK(err, "prog_detach");
2805 assert_mprog_count(target, 0);
2806 cleanup:
2807 test_tc_link__destroy(skel);
2808 }
2809
2810 void serial_test_tc_opts_query_attach(void)
2811 {
2812 test_tc_opts_query_attach_target(BPF_TCX_INGRESS);
2813 test_tc_opts_query_attach_target(BPF_TCX_EGRESS);
2814 }
2815
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.