1 ================================= 2 HOWTO interact with BPF subsystem 3 ================================= 4 5 This document provides information for the BPF subsystem about various 6 workflows related to reporting bugs, submitting patches, and queueing 7 patches for stable kernels. 8 9 For general information about submitting patches, please refer to 10 Documentation/process/submitting-patches.rst. This document only describes 11 additional specifics related to BPF. 12 13 .. contents:: 14 :local: 15 :depth: 2 16 17 Reporting bugs 18 ============== 19 20 Q: How do I report bugs for BPF kernel code? 21 -------------------------------------------- 22 A: Since all BPF kernel development as well as bpftool and iproute2 BPF 23 loader development happens through the bpf kernel mailing list, 24 please report any found issues around BPF to the following mailing 25 list: 26 27 bpf@vger.kernel.org 28 29 This may also include issues related to XDP, BPF tracing, etc. 30 31 Given netdev has a high volume of traffic, please also add the BPF 32 maintainers to Cc (from kernel ``MAINTAINERS`` file): 33 34 * Alexei Starovoitov <ast@kernel.org> 35 * Daniel Borkmann <daniel@iogearbox.net> 36 37 In case a buggy commit has already been identified, make sure to keep 38 the actual commit authors in Cc as well for the report. They can 39 typically be identified through the kernel's git tree. 40 41 **Please do NOT report BPF issues to bugzilla.kernel.org since it 42 is a guarantee that the reported issue will be overlooked.** 43 44 Submitting patches 45 ================== 46 47 Q: How do I run BPF CI on my changes before sending them out for review? 48 ------------------------------------------------------------------------ 49 A: BPF CI is GitHub based and hosted at https://github.com/kernel-patches/bpf. 50 While GitHub also provides a CLI that can be used to accomplish the same 51 results, here we focus on the UI based workflow. 52 53 The following steps lay out how to start a CI run for your patches: 54 55 - Create a fork of the aforementioned repository in your own account (one time 56 action) 57 58 - Clone the fork locally, check out a new branch tracking either the bpf-next 59 or bpf branch, and apply your to-be-tested patches on top of it 60 61 - Push the local branch to your fork and create a pull request against 62 kernel-patches/bpf's bpf-next_base or bpf_base branch, respectively 63 64 Shortly after the pull request has been created, the CI workflow will run. Note 65 that capacity is shared with patches submitted upstream being checked and so 66 depending on utilization the run can take a while to finish. 67 68 Note furthermore that both base branches (bpf-next_base and bpf_base) will be 69 updated as patches are pushed to the respective upstream branches they track. As 70 such, your patch set will automatically (be attempted to) be rebased as well. 71 This behavior can result in a CI run being aborted and restarted with the new 72 base line. 73 74 Q: To which mailing list do I need to submit my BPF patches? 75 ------------------------------------------------------------ 76 A: Please submit your BPF patches to the bpf kernel mailing list: 77 78 bpf@vger.kernel.org 79 80 In case your patch has changes in various different subsystems (e.g. 81 networking, tracing, security, etc), make sure to Cc the related kernel mailing 82 lists and maintainers from there as well, so they are able to review 83 the changes and provide their Acked-by's to the patches. 84 85 Q: Where can I find patches currently under discussion for BPF subsystem? 86 ------------------------------------------------------------------------- 87 A: All patches that are Cc'ed to netdev are queued for review under netdev 88 patchwork project: 89 90 https://patchwork.kernel.org/project/netdevbpf/list/ 91 92 Those patches which target BPF, are assigned to a 'bpf' delegate for 93 further processing from BPF maintainers. The current queue with 94 patches under review can be found at: 95 96 https://patchwork.kernel.org/project/netdevbpf/list/?delegate=121173 97 98 Once the patches have been reviewed by the BPF community as a whole 99 and approved by the BPF maintainers, their status in patchwork will be 100 changed to 'Accepted' and the submitter will be notified by mail. This 101 means that the patches look good from a BPF perspective and have been 102 applied to one of the two BPF kernel trees. 103 104 In case feedback from the community requires a respin of the patches, 105 their status in patchwork will be set to 'Changes Requested', and purged 106 from the current review queue. Likewise for cases where patches would 107 get rejected or are not applicable to the BPF trees (but assigned to 108 the 'bpf' delegate). 109 110 Q: How do the changes make their way into Linux? 111 ------------------------------------------------ 112 A: There are two BPF kernel trees (git repositories). Once patches have 113 been accepted by the BPF maintainers, they will be applied to one 114 of the two BPF trees: 115 116 * https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git/ 117 * https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git/ 118 119 The bpf tree itself is for fixes only, whereas bpf-next for features, 120 cleanups or other kind of improvements ("next-like" content). This is 121 analogous to net and net-next trees for networking. Both bpf and 122 bpf-next will only have a master branch in order to simplify against 123 which branch patches should get rebased to. 124 125 Accumulated BPF patches in the bpf tree will regularly get pulled 126 into the net kernel tree. Likewise, accumulated BPF patches accepted 127 into the bpf-next tree will make their way into net-next tree. net and 128 net-next are both run by David S. Miller. From there, they will go 129 into the kernel mainline tree run by Linus Torvalds. To read up on the 130 process of net and net-next being merged into the mainline tree, see 131 the documentation on netdev subsystem at 132 Documentation/process/maintainer-netdev.rst. 133 134 135 136 Occasionally, to prevent merge conflicts, we might send pull requests 137 to other trees (e.g. tracing) with a small subset of the patches, but 138 net and net-next are always the main trees targeted for integration. 139 140 The pull requests will contain a high-level summary of the accumulated 141 patches and can be searched on netdev kernel mailing list through the 142 following subject lines (``yyyy-mm-dd`` is the date of the pull 143 request):: 144 145 pull-request: bpf yyyy-mm-dd 146 pull-request: bpf-next yyyy-mm-dd 147 148 Q: How do I indicate which tree (bpf vs. bpf-next) my patch should be applied to? 149 --------------------------------------------------------------------------------- 150 151 A: The process is the very same as described in the netdev subsystem 152 documentation at Documentation/process/maintainer-netdev.rst, 153 so please read up on it. The subject line must indicate whether the 154 patch is a fix or rather "next-like" content in order to let the 155 maintainers know whether it is targeted at bpf or bpf-next. 156 157 For fixes eventually landing in bpf -> net tree, the subject must 158 look like:: 159 160 git format-patch --subject-prefix='PATCH bpf' start..finish 161 162 For features/improvements/etc that should eventually land in 163 bpf-next -> net-next, the subject must look like:: 164 165 git format-patch --subject-prefix='PATCH bpf-next' start..finish 166 167 If unsure whether the patch or patch series should go into bpf 168 or net directly, or bpf-next or net-next directly, it is not a 169 problem either if the subject line says net or net-next as target. 170 It is eventually up to the maintainers to do the delegation of 171 the patches. 172 173 If it is clear that patches should go into bpf or bpf-next tree, 174 please make sure to rebase the patches against those trees in 175 order to reduce potential conflicts. 176 177 In case the patch or patch series has to be reworked and sent out 178 again in a second or later revision, it is also required to add a 179 version number (``v2``, ``v3``, ...) into the subject prefix:: 180 181 git format-patch --subject-prefix='PATCH bpf-next v2' start..finish 182 183 When changes have been requested to the patch series, always send the 184 whole patch series again with the feedback incorporated (never send 185 individual diffs on top of the old series). 186 187 Q: What does it mean when a patch gets applied to bpf or bpf-next tree? 188 ----------------------------------------------------------------------- 189 A: It means that the patch looks good for mainline inclusion from 190 a BPF point of view. 191 192 Be aware that this is not a final verdict that the patch will 193 automatically get accepted into net or net-next trees eventually: 194 195 On the bpf kernel mailing list reviews can come in at any point 196 in time. If discussions around a patch conclude that they cannot 197 get included as-is, we will either apply a follow-up fix or drop 198 them from the trees entirely. Therefore, we also reserve to rebase 199 the trees when deemed necessary. After all, the purpose of the tree 200 is to: 201 202 i) accumulate and stage BPF patches for integration into trees 203 like net and net-next, and 204 205 ii) run extensive BPF test suite and 206 workloads on the patches before they make their way any further. 207 208 Once the BPF pull request was accepted by David S. Miller, then 209 the patches end up in net or net-next tree, respectively, and 210 make their way from there further into mainline. Again, see the 211 documentation for netdev subsystem at 212 Documentation/process/maintainer-netdev.rst for additional information 213 e.g. on how often they are merged to mainline. 214 215 Q: How long do I need to wait for feedback on my BPF patches? 216 ------------------------------------------------------------- 217 A: We try to keep the latency low. The usual time to feedback will 218 be around 2 or 3 business days. It may vary depending on the 219 complexity of changes and current patch load. 220 221 Q: How often do you send pull requests to major kernel trees like net or net-next? 222 ---------------------------------------------------------------------------------- 223 224 A: Pull requests will be sent out rather often in order to not 225 accumulate too many patches in bpf or bpf-next. 226 227 As a rule of thumb, expect pull requests for each tree regularly 228 at the end of the week. In some cases pull requests could additionally 229 come also in the middle of the week depending on the current patch 230 load or urgency. 231 232 Q: Are patches applied to bpf-next when the merge window is open? 233 ----------------------------------------------------------------- 234 A: For the time when the merge window is open, bpf-next will not be 235 processed. This is roughly analogous to net-next patch processing, 236 so feel free to read up on the netdev docs at 237 Documentation/process/maintainer-netdev.rst about further details. 238 239 During those two weeks of merge window, we might ask you to resend 240 your patch series once bpf-next is open again. Once Linus released 241 a ``v*-rc1`` after the merge window, we continue processing of bpf-next. 242 243 For non-subscribers to kernel mailing lists, there is also a status 244 page run by David S. Miller on net-next that provides guidance: 245 246 http://vger.kernel.org/~davem/net-next.html 247 248 Q: Verifier changes and test cases 249 ---------------------------------- 250 Q: I made a BPF verifier change, do I need to add test cases for 251 BPF kernel selftests_? 252 253 A: If the patch has changes to the behavior of the verifier, then yes, 254 it is absolutely necessary to add test cases to the BPF kernel 255 selftests_ suite. If they are not present and we think they are 256 needed, then we might ask for them before accepting any changes. 257 258 In particular, test_verifier.c is tracking a high number of BPF test 259 cases, including a lot of corner cases that LLVM BPF back end may 260 generate out of the restricted C code. Thus, adding test cases is 261 absolutely crucial to make sure future changes do not accidentally 262 affect prior use-cases. Thus, treat those test cases as: verifier 263 behavior that is not tracked in test_verifier.c could potentially 264 be subject to change. 265 266 Q: samples/bpf preference vs selftests? 267 --------------------------------------- 268 Q: When should I add code to ``samples/bpf/`` and when to BPF kernel 269 selftests_? 270 271 A: In general, we prefer additions to BPF kernel selftests_ rather than 272 ``samples/bpf/``. The rationale is very simple: kernel selftests are 273 regularly run by various bots to test for kernel regressions. 274 275 The more test cases we add to BPF selftests, the better the coverage 276 and the less likely it is that those could accidentally break. It is 277 not that BPF kernel selftests cannot demo how a specific feature can 278 be used. 279 280 That said, ``samples/bpf/`` may be a good place for people to get started, 281 so it might be advisable that simple demos of features could go into 282 ``samples/bpf/``, but advanced functional and corner-case testing rather 283 into kernel selftests. 284 285 If your sample looks like a test case, then go for BPF kernel selftests 286 instead! 287 288 Q: When should I add code to the bpftool? 289 ----------------------------------------- 290 A: The main purpose of bpftool (under tools/bpf/bpftool/) is to provide 291 a central user space tool for debugging and introspection of BPF programs 292 and maps that are active in the kernel. If UAPI changes related to BPF 293 enable for dumping additional information of programs or maps, then 294 bpftool should be extended as well to support dumping them. 295 296 Q: When should I add code to iproute2's BPF loader? 297 --------------------------------------------------- 298 A: For UAPI changes related to the XDP or tc layer (e.g. ``cls_bpf``), 299 the convention is that those control-path related changes are added to 300 iproute2's BPF loader as well from user space side. This is not only 301 useful to have UAPI changes properly designed to be usable, but also 302 to make those changes available to a wider user base of major 303 downstream distributions. 304 305 Q: Do you accept patches as well for iproute2's BPF loader? 306 ----------------------------------------------------------- 307 A: Patches for the iproute2's BPF loader have to be sent to: 308 309 netdev@vger.kernel.org 310 311 While those patches are not processed by the BPF kernel maintainers, 312 please keep them in Cc as well, so they can be reviewed. 313 314 The official git repository for iproute2 is run by Stephen Hemminger 315 and can be found at: 316 317 https://git.kernel.org/pub/scm/linux/kernel/git/shemminger/iproute2.git/ 318 319 The patches need to have a subject prefix of '``[PATCH iproute2 320 master]``' or '``[PATCH iproute2 net-next]``'. '``master``' or 321 '``net-next``' describes the target branch where the patch should be 322 applied to. Meaning, if kernel changes went into the net-next kernel 323 tree, then the related iproute2 changes need to go into the iproute2 324 net-next branch, otherwise they can be targeted at master branch. The 325 iproute2 net-next branch will get merged into the master branch after 326 the current iproute2 version from master has been released. 327 328 Like BPF, the patches end up in patchwork under the netdev project and 329 are delegated to 'shemminger' for further processing: 330 331 http://patchwork.ozlabs.org/project/netdev/list/?delegate=389 332 333 Q: What is the minimum requirement before I submit my BPF patches? 334 ------------------------------------------------------------------ 335 A: When submitting patches, always take the time and properly test your 336 patches *prior* to submission. Never rush them! If maintainers find 337 that your patches have not been properly tested, it is a good way to 338 get them grumpy. Testing patch submissions is a hard requirement! 339 340 Note, fixes that go to bpf tree *must* have a ``Fixes:`` tag included. 341 The same applies to fixes that target bpf-next, where the affected 342 commit is in net-next (or in some cases bpf-next). The ``Fixes:`` tag is 343 crucial in order to identify follow-up commits and tremendously helps 344 for people having to do backporting, so it is a must have! 345 346 We also don't accept patches with an empty commit message. Take your 347 time and properly write up a high quality commit message, it is 348 essential! 349 350 Think about it this way: other developers looking at your code a month 351 from now need to understand *why* a certain change has been done that 352 way, and whether there have been flaws in the analysis or assumptions 353 that the original author did. Thus providing a proper rationale and 354 describing the use-case for the changes is a must. 355 356 Patch submissions with >1 patch must have a cover letter which includes 357 a high level description of the series. This high level summary will 358 then be placed into the merge commit by the BPF maintainers such that 359 it is also accessible from the git log for future reference. 360 361 Q: Features changing BPF JIT and/or LLVM 362 ---------------------------------------- 363 Q: What do I need to consider when adding a new instruction or feature 364 that would require BPF JIT and/or LLVM integration as well? 365 366 A: We try hard to keep all BPF JITs up to date such that the same user 367 experience can be guaranteed when running BPF programs on different 368 architectures without having the program punt to the less efficient 369 interpreter in case the in-kernel BPF JIT is enabled. 370 371 If you are unable to implement or test the required JIT changes for 372 certain architectures, please work together with the related BPF JIT 373 developers in order to get the feature implemented in a timely manner. 374 Please refer to the git log (``arch/*/net/``) to locate the necessary 375 people for helping out. 376 377 Also always make sure to add BPF test cases (e.g. test_bpf.c and 378 test_verifier.c) for new instructions, so that they can receive 379 broad test coverage and help run-time testing the various BPF JITs. 380 381 In case of new BPF instructions, once the changes have been accepted 382 into the Linux kernel, please implement support into LLVM's BPF back 383 end. See LLVM_ section below for further information. 384 385 Stable submission 386 ================= 387 388 Q: I need a specific BPF commit in stable kernels. What should I do? 389 -------------------------------------------------------------------- 390 A: In case you need a specific fix in stable kernels, first check whether 391 the commit has already been applied in the related ``linux-*.y`` branches: 392 393 https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git/ 394 395 If not the case, then drop an email to the BPF maintainers with the 396 netdev kernel mailing list in Cc and ask for the fix to be queued up: 397 398 netdev@vger.kernel.org 399 400 The process in general is the same as on netdev itself, see also the 401 the documentation on networking subsystem at 402 Documentation/process/maintainer-netdev.rst. 403 404 Q: Do you also backport to kernels not currently maintained as stable? 405 ---------------------------------------------------------------------- 406 A: No. If you need a specific BPF commit in kernels that are currently not 407 maintained by the stable maintainers, then you are on your own. 408 409 The current stable and longterm stable kernels are all listed here: 410 411 https://www.kernel.org/ 412 413 Q: The BPF patch I am about to submit needs to go to stable as well 414 ------------------------------------------------------------------- 415 What should I do? 416 417 A: The same rules apply as with netdev patch submissions in general, see 418 the netdev docs at Documentation/process/maintainer-netdev.rst. 419 420 Never add "``Cc: stable@vger.kernel.org``" to the patch description, but 421 ask the BPF maintainers to queue the patches instead. This can be done 422 with a note, for example, under the ``---`` part of the patch which does 423 not go into the git log. Alternatively, this can be done as a simple 424 request by mail instead. 425 426 Q: Queue stable patches 427 ----------------------- 428 Q: Where do I find currently queued BPF patches that will be submitted 429 to stable? 430 431 A: Once patches that fix critical bugs got applied into the bpf tree, they 432 are queued up for stable submission under: 433 434 http://patchwork.ozlabs.org/bundle/bpf/stable/?state=* 435 436 They will be on hold there at minimum until the related commit made its 437 way into the mainline kernel tree. 438 439 After having been under broader exposure, the queued patches will be 440 submitted by the BPF maintainers to the stable maintainers. 441 442 Testing patches 443 =============== 444 445 Q: How to run BPF selftests 446 --------------------------- 447 A: After you have booted into the newly compiled kernel, navigate to 448 the BPF selftests_ suite in order to test BPF functionality (current 449 working directory points to the root of the cloned git tree):: 450 451 $ cd tools/testing/selftests/bpf/ 452 $ make 453 454 To run the verifier tests:: 455 456 $ sudo ./test_verifier 457 458 The verifier tests print out all the current checks being 459 performed. The summary at the end of running all tests will dump 460 information of test successes and failures:: 461 462 Summary: 418 PASSED, 0 FAILED 463 464 In order to run through all BPF selftests, the following command is 465 needed:: 466 467 $ sudo make run_tests 468 469 See :doc:`kernel selftest documentation </dev-tools/kselftest>` 470 for details. 471 472 To maximize the number of tests passing, the .config of the kernel 473 under test should match the config file fragment in 474 tools/testing/selftests/bpf as closely as possible. 475 476 Finally to ensure support for latest BPF Type Format features - 477 discussed in Documentation/bpf/btf.rst - pahole version 1.16 478 is required for kernels built with CONFIG_DEBUG_INFO_BTF=y. 479 pahole is delivered in the dwarves package or can be built 480 from source at 481 482 https://github.com/acmel/dwarves 483 484 pahole starts to use libbpf definitions and APIs since v1.13 after the 485 commit 21507cd3e97b ("pahole: add libbpf as submodule under lib/bpf"). 486 It works well with the git repository because the libbpf submodule will 487 use "git submodule update --init --recursive" to update. 488 489 Unfortunately, the default github release source code does not contain 490 libbpf submodule source code and this will cause build issues, the tarball 491 from https://git.kernel.org/pub/scm/devel/pahole/pahole.git/ is same with 492 github, you can get the source tarball with corresponding libbpf submodule 493 codes from 494 495 https://fedorapeople.org/~acme/dwarves 496 497 Some distros have pahole version 1.16 packaged already, e.g. 498 Fedora, Gentoo. 499 500 Q: Which BPF kernel selftests version should I run my kernel against? 501 --------------------------------------------------------------------- 502 A: If you run a kernel ``xyz``, then always run the BPF kernel selftests 503 from that kernel ``xyz`` as well. Do not expect that the BPF selftest 504 from the latest mainline tree will pass all the time. 505 506 In particular, test_bpf.c and test_verifier.c have a large number of 507 test cases and are constantly updated with new BPF test sequences, or 508 existing ones are adapted to verifier changes e.g. due to verifier 509 becoming smarter and being able to better track certain things. 510 511 LLVM 512 ==== 513 514 Q: Where do I find LLVM with BPF support? 515 ----------------------------------------- 516 A: The BPF back end for LLVM is upstream in LLVM since version 3.7.1. 517 518 All major distributions these days ship LLVM with BPF back end enabled, 519 so for the majority of use-cases it is not required to compile LLVM by 520 hand anymore, just install the distribution provided package. 521 522 LLVM's static compiler lists the supported targets through 523 ``llc --version``, make sure BPF targets are listed. Example:: 524 525 $ llc --version 526 LLVM (http://llvm.org/): 527 LLVM version 10.0.0 528 Optimized build. 529 Default target: x86_64-unknown-linux-gnu 530 Host CPU: skylake 531 532 Registered Targets: 533 aarch64 - AArch64 (little endian) 534 bpf - BPF (host endian) 535 bpfeb - BPF (big endian) 536 bpfel - BPF (little endian) 537 x86 - 32-bit X86: Pentium-Pro and above 538 x86-64 - 64-bit X86: EM64T and AMD64 539 540 For developers in order to utilize the latest features added to LLVM's 541 BPF back end, it is advisable to run the latest LLVM releases. Support 542 for new BPF kernel features such as additions to the BPF instruction 543 set are often developed together. 544 545 All LLVM releases can be found at: http://releases.llvm.org/ 546 547 Q: Got it, so how do I build LLVM manually anyway? 548 -------------------------------------------------- 549 A: We recommend that developers who want the fastest incremental builds 550 use the Ninja build system, you can find it in your system's package 551 manager, usually the package is ninja or ninja-build. 552 553 You need ninja, cmake and gcc-c++ as build requisites for LLVM. Once you 554 have that set up, proceed with building the latest LLVM and clang version 555 from the git repositories:: 556 557 $ git clone https://github.com/llvm/llvm-project.git 558 $ mkdir -p llvm-project/llvm/build 559 $ cd llvm-project/llvm/build 560 $ cmake .. -G "Ninja" -DLLVM_TARGETS_TO_BUILD="BPF;X86" \ 561 -DLLVM_ENABLE_PROJECTS="clang" \ 562 -DCMAKE_BUILD_TYPE=Release \ 563 -DLLVM_BUILD_RUNTIME=OFF 564 $ ninja 565 566 The built binaries can then be found in the build/bin/ directory, where 567 you can point the PATH variable to. 568 569 Set ``-DLLVM_TARGETS_TO_BUILD`` equal to the target you wish to build, you 570 will find a full list of targets within the llvm-project/llvm/lib/Target 571 directory. 572 573 Q: Reporting LLVM BPF issues 574 ---------------------------- 575 Q: Should I notify BPF kernel maintainers about issues in LLVM's BPF code 576 generation back end or about LLVM generated code that the verifier 577 refuses to accept? 578 579 A: Yes, please do! 580 581 LLVM's BPF back end is a key piece of the whole BPF 582 infrastructure and it ties deeply into verification of programs from the 583 kernel side. Therefore, any issues on either side need to be investigated 584 and fixed whenever necessary. 585 586 Therefore, please make sure to bring them up at netdev kernel mailing 587 list and Cc BPF maintainers for LLVM and kernel bits: 588 589 * Yonghong Song <yhs@fb.com> 590 * Alexei Starovoitov <ast@kernel.org> 591 * Daniel Borkmann <daniel@iogearbox.net> 592 593 LLVM also has an issue tracker where BPF related bugs can be found: 594 595 https://bugs.llvm.org/buglist.cgi?quicksearch=bpf 596 597 However, it is better to reach out through mailing lists with having 598 maintainers in Cc. 599 600 Q: New BPF instruction for kernel and LLVM 601 ------------------------------------------ 602 Q: I have added a new BPF instruction to the kernel, how can I integrate 603 it into LLVM? 604 605 A: LLVM has a ``-mcpu`` selector for the BPF back end in order to allow 606 the selection of BPF instruction set extensions. By default the 607 ``generic`` processor target is used, which is the base instruction set 608 (v1) of BPF. 609 610 LLVM has an option to select ``-mcpu=probe`` where it will probe the host 611 kernel for supported BPF instruction set extensions and selects the 612 optimal set automatically. 613 614 For cross-compilation, a specific version can be select manually as well :: 615 616 $ llc -march bpf -mcpu=help 617 Available CPUs for this target: 618 619 generic - Select the generic processor. 620 probe - Select the probe processor. 621 v1 - Select the v1 processor. 622 v2 - Select the v2 processor. 623 [...] 624 625 Newly added BPF instructions to the Linux kernel need to follow the same 626 scheme, bump the instruction set version and implement probing for the 627 extensions such that ``-mcpu=probe`` users can benefit from the 628 optimization transparently when upgrading their kernels. 629 630 If you are unable to implement support for the newly added BPF instruction 631 please reach out to BPF developers for help. 632 633 By the way, the BPF kernel selftests run with ``-mcpu=probe`` for better 634 test coverage. 635 636 Q: clang flag for target bpf? 637 ----------------------------- 638 Q: In some cases clang flag ``--target=bpf`` is used but in other cases the 639 default clang target, which matches the underlying architecture, is used. 640 What is the difference and when I should use which? 641 642 A: Although LLVM IR generation and optimization try to stay architecture 643 independent, ``--target=<arch>`` still has some impact on generated code: 644 645 - BPF program may recursively include header file(s) with file scope 646 inline assembly codes. The default target can handle this well, 647 while ``bpf`` target may fail if bpf backend assembler does not 648 understand these assembly codes, which is true in most cases. 649 650 - When compiled without ``-g``, additional elf sections, e.g., 651 .eh_frame and .rela.eh_frame, may be present in the object file 652 with default target, but not with ``bpf`` target. 653 654 - The default target may turn a C switch statement into a switch table 655 lookup and jump operation. Since the switch table is placed 656 in the global readonly section, the bpf program will fail to load. 657 The bpf target does not support switch table optimization. 658 The clang option ``-fno-jump-tables`` can be used to disable 659 switch table generation. 660 661 - For clang ``--target=bpf``, it is guaranteed that pointer or long / 662 unsigned long types will always have a width of 64 bit, no matter 663 whether underlying clang binary or default target (or kernel) is 664 32 bit. However, when native clang target is used, then it will 665 compile these types based on the underlying architecture's conventions, 666 meaning in case of 32 bit architecture, pointer or long / unsigned 667 long types e.g. in BPF context structure will have width of 32 bit 668 while the BPF LLVM back end still operates in 64 bit. The native 669 target is mostly needed in tracing for the case of walking ``pt_regs`` 670 or other kernel structures where CPU's register width matters. 671 Otherwise, ``clang --target=bpf`` is generally recommended. 672 673 You should use default target when: 674 675 - Your program includes a header file, e.g., ptrace.h, which eventually 676 pulls in some header files containing file scope host assembly codes. 677 678 - You can add ``-fno-jump-tables`` to work around the switch table issue. 679 680 Otherwise, you can use ``bpf`` target. Additionally, you *must* use bpf target 681 when: 682 683 - Your program uses data structures with pointer or long / unsigned long 684 types that interface with BPF helpers or context data structures. Access 685 into these structures is verified by the BPF verifier and may result 686 in verification failures if the native architecture is not aligned with 687 the BPF architecture, e.g. 64-bit. An example of this is 688 BPF_PROG_TYPE_SK_MSG require ``--target=bpf`` 689 690 691 .. Links 692 .. _selftests: 693 https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/testing/selftests/bpf/ 694 695 Happy BPF hacking!
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.