bpf_devel_QA.rst 27 KB

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