1.. SPDX-License-Identifier: GPL-2.0 2 3.. _networking-filter: 4 5======================================================= 6Linux Socket Filtering aka Berkeley Packet Filter (BPF) 7======================================================= 8 9Notice 10------ 11 12This file used to document the eBPF format and mechanisms even when not 13related to socket filtering. The ../bpf/index.rst has more details 14on eBPF. 15 16Introduction 17------------ 18 19Linux Socket Filtering (LSF) is derived from the Berkeley Packet Filter. 20Though there are some distinct differences between the BSD and Linux 21Kernel filtering, but when we speak of BPF or LSF in Linux context, we 22mean the very same mechanism of filtering in the Linux kernel. 23 24BPF allows a user-space program to attach a filter onto any socket and 25allow or disallow certain types of data to come through the socket. LSF 26follows exactly the same filter code structure as BSD's BPF, so referring 27to the BSD bpf.4 manpage is very helpful in creating filters. 28 29On Linux, BPF is much simpler than on BSD. One does not have to worry 30about devices or anything like that. You simply create your filter code, 31send it to the kernel via the SO_ATTACH_FILTER option and if your filter 32code passes the kernel check on it, you then immediately begin filtering 33data on that socket. 34 35You can also detach filters from your socket via the SO_DETACH_FILTER 36option. This will probably not be used much since when you close a socket 37that has a filter on it the filter is automagically removed. The other 38less common case may be adding a different filter on the same socket where 39you had another filter that is still running: the kernel takes care of 40removing the old one and placing your new one in its place, assuming your 41filter has passed the checks, otherwise if it fails the old filter will 42remain on that socket. 43 44SO_LOCK_FILTER option allows to lock the filter attached to a socket. Once 45set, a filter cannot be removed or changed. This allows one process to 46setup a socket, attach a filter, lock it then drop privileges and be 47assured that the filter will be kept until the socket is closed. 48 49The biggest user of this construct might be libpcap. Issuing a high-level 50filter command like `tcpdump -i em1 port 22` passes through the libpcap 51internal compiler that generates a structure that can eventually be loaded 52via SO_ATTACH_FILTER to the kernel. `tcpdump -i em1 port 22 -ddd` 53displays what is being placed into this structure. 54 55Although we were only speaking about sockets here, BPF in Linux is used 56in many more places. There's xt_bpf for netfilter, cls_bpf in the kernel 57qdisc layer, SECCOMP-BPF (SECure COMPuting [1]_), and lots of other places 58such as team driver, PTP code, etc where BPF is being used. 59 60.. [1] Documentation/userspace-api/seccomp_filter.rst 61 62Original BPF paper: 63 64Steven McCanne and Van Jacobson. 1993. The BSD packet filter: a new 65architecture for user-level packet capture. In Proceedings of the 66USENIX Winter 1993 Conference Proceedings on USENIX Winter 1993 67Conference Proceedings (USENIX'93). USENIX Association, Berkeley, 68CA, USA, 2-2. [http://www.tcpdump.org/papers/bpf-usenix93.pdf] 69 70Structure 71--------- 72 73User space applications include <linux/filter.h> which contains the 74following relevant structures:: 75 76 struct sock_filter { /* Filter block */ 77 __u16 code; /* Actual filter code */ 78 __u8 jt; /* Jump true */ 79 __u8 jf; /* Jump false */ 80 __u32 k; /* Generic multiuse field */ 81 }; 82 83Such a structure is assembled as an array of 4-tuples, that contains 84a code, jt, jf and k value. jt and jf are jump offsets and k a generic 85value to be used for a provided code:: 86 87 struct sock_fprog { /* Required for SO_ATTACH_FILTER. */ 88 unsigned short len; /* Number of filter blocks */ 89 struct sock_filter __user *filter; 90 }; 91 92For socket filtering, a pointer to this structure (as shown in 93follow-up example) is being passed to the kernel through setsockopt(2). 94 95Example 96------- 97 98:: 99 100 #include <sys/socket.h> 101 #include <sys/types.h> 102 #include <arpa/inet.h> 103 #include <linux/if_ether.h> 104 /* ... */ 105 106 /* From the example above: tcpdump -i em1 port 22 -dd */ 107 struct sock_filter code[] = { 108 { 0x28, 0, 0, 0x0000000c }, 109 { 0x15, 0, 8, 0x000086dd }, 110 { 0x30, 0, 0, 0x00000014 }, 111 { 0x15, 2, 0, 0x00000084 }, 112 { 0x15, 1, 0, 0x00000006 }, 113 { 0x15, 0, 17, 0x00000011 }, 114 { 0x28, 0, 0, 0x00000036 }, 115 { 0x15, 14, 0, 0x00000016 }, 116 { 0x28, 0, 0, 0x00000038 }, 117 { 0x15, 12, 13, 0x00000016 }, 118 { 0x15, 0, 12, 0x00000800 }, 119 { 0x30, 0, 0, 0x00000017 }, 120 { 0x15, 2, 0, 0x00000084 }, 121 { 0x15, 1, 0, 0x00000006 }, 122 { 0x15, 0, 8, 0x00000011 }, 123 { 0x28, 0, 0, 0x00000014 }, 124 { 0x45, 6, 0, 0x00001fff }, 125 { 0xb1, 0, 0, 0x0000000e }, 126 { 0x48, 0, 0, 0x0000000e }, 127 { 0x15, 2, 0, 0x00000016 }, 128 { 0x48, 0, 0, 0x00000010 }, 129 { 0x15, 0, 1, 0x00000016 }, 130 { 0x06, 0, 0, 0x0000ffff }, 131 { 0x06, 0, 0, 0x00000000 }, 132 }; 133 134 struct sock_fprog bpf = { 135 .len = ARRAY_SIZE(code), 136 .filter = code, 137 }; 138 139 sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); 140 if (sock < 0) 141 /* ... bail out ... */ 142 143 ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf)); 144 if (ret < 0) 145 /* ... bail out ... */ 146 147 /* ... */ 148 close(sock); 149 150The above example code attaches a socket filter for a PF_PACKET socket 151in order to let all IPv4/IPv6 packets with port 22 pass. The rest will 152be dropped for this socket. 153 154The setsockopt(2) call to SO_DETACH_FILTER doesn't need any arguments 155and SO_LOCK_FILTER for preventing the filter to be detached, takes an 156integer value with 0 or 1. 157 158Note that socket filters are not restricted to PF_PACKET sockets only, 159but can also be used on other socket families. 160 161Summary of system calls: 162 163 * setsockopt(sockfd, SOL_SOCKET, SO_ATTACH_FILTER, &val, sizeof(val)); 164 * setsockopt(sockfd, SOL_SOCKET, SO_DETACH_FILTER, &val, sizeof(val)); 165 * setsockopt(sockfd, SOL_SOCKET, SO_LOCK_FILTER, &val, sizeof(val)); 166 167Normally, most use cases for socket filtering on packet sockets will be 168covered by libpcap in high-level syntax, so as an application developer 169you should stick to that. libpcap wraps its own layer around all that. 170 171Unless i) using/linking to libpcap is not an option, ii) the required BPF 172filters use Linux extensions that are not supported by libpcap's compiler, 173iii) a filter might be more complex and not cleanly implementable with 174libpcap's compiler, or iv) particular filter codes should be optimized 175differently than libpcap's internal compiler does; then in such cases 176writing such a filter "by hand" can be of an alternative. For example, 177xt_bpf and cls_bpf users might have requirements that could result in 178more complex filter code, or one that cannot be expressed with libpcap 179(e.g. different return codes for various code paths). Moreover, BPF JIT 180implementors may wish to manually write test cases and thus need low-level 181access to BPF code as well. 182 183BPF engine and instruction set 184------------------------------ 185 186Under tools/bpf/ there's a small helper tool called bpf_asm which can 187be used to write low-level filters for example scenarios mentioned in the 188previous section. Asm-like syntax mentioned here has been implemented in 189bpf_asm and will be used for further explanations (instead of dealing with 190less readable opcodes directly, principles are the same). The syntax is 191closely modelled after Steven McCanne's and Van Jacobson's BPF paper. 192 193The BPF architecture consists of the following basic elements: 194 195 ======= ==================================================== 196 Element Description 197 ======= ==================================================== 198 A 32 bit wide accumulator 199 X 32 bit wide X register 200 M[] 16 x 32 bit wide misc registers aka "scratch memory 201 store", addressable from 0 to 15 202 ======= ==================================================== 203 204A program, that is translated by bpf_asm into "opcodes" is an array that 205consists of the following elements (as already mentioned):: 206 207 op:16, jt:8, jf:8, k:32 208 209The element op is a 16 bit wide opcode that has a particular instruction 210encoded. jt and jf are two 8 bit wide jump targets, one for condition 211"jump if true", the other one "jump if false". Eventually, element k 212contains a miscellaneous argument that can be interpreted in different 213ways depending on the given instruction in op. 214 215The instruction set consists of load, store, branch, alu, miscellaneous 216and return instructions that are also represented in bpf_asm syntax. This 217table lists all bpf_asm instructions available resp. what their underlying 218opcodes as defined in linux/filter.h stand for: 219 220 =========== =================== ===================== 221 Instruction Addressing mode Description 222 =========== =================== ===================== 223 ld 1, 2, 3, 4, 12 Load word into A 224 ldi 4 Load word into A 225 ldh 1, 2 Load half-word into A 226 ldb 1, 2 Load byte into A 227 ldx 3, 4, 5, 12 Load word into X 228 ldxi 4 Load word into X 229 ldxb 5 Load byte into X 230 231 st 3 Store A into M[] 232 stx 3 Store X into M[] 233 234 jmp 6 Jump to label 235 ja 6 Jump to label 236 jeq 7, 8, 9, 10 Jump on A == <x> 237 jneq 9, 10 Jump on A != <x> 238 jne 9, 10 Jump on A != <x> 239 jlt 9, 10 Jump on A < <x> 240 jle 9, 10 Jump on A <= <x> 241 jgt 7, 8, 9, 10 Jump on A > <x> 242 jge 7, 8, 9, 10 Jump on A >= <x> 243 jset 7, 8, 9, 10 Jump on A & <x> 244 245 add 0, 4 A + <x> 246 sub 0, 4 A - <x> 247 mul 0, 4 A * <x> 248 div 0, 4 A / <x> 249 mod 0, 4 A % <x> 250 neg !A 251 and 0, 4 A & <x> 252 or 0, 4 A | <x> 253 xor 0, 4 A ^ <x> 254 lsh 0, 4 A << <x> 255 rsh 0, 4 A >> <x> 256 257 tax Copy A into X 258 txa Copy X into A 259 260 ret 4, 11 Return 261 =========== =================== ===================== 262 263The next table shows addressing formats from the 2nd column: 264 265 =============== =================== =============================================== 266 Addressing mode Syntax Description 267 =============== =================== =============================================== 268 0 x/%x Register X 269 1 [k] BHW at byte offset k in the packet 270 2 [x + k] BHW at the offset X + k in the packet 271 3 M[k] Word at offset k in M[] 272 4 #k Literal value stored in k 273 5 4*([k]&0xf) Lower nibble * 4 at byte offset k in the packet 274 6 L Jump label L 275 7 #k,Lt,Lf Jump to Lt if true, otherwise jump to Lf 276 8 x/%x,Lt,Lf Jump to Lt if true, otherwise jump to Lf 277 9 #k,Lt Jump to Lt if predicate is true 278 10 x/%x,Lt Jump to Lt if predicate is true 279 11 a/%a Accumulator A 280 12 extension BPF extension 281 =============== =================== =============================================== 282 283The Linux kernel also has a couple of BPF extensions that are used along 284with the class of load instructions by "overloading" the k argument with 285a negative offset + a particular extension offset. The result of such BPF 286extensions are loaded into A. 287 288Possible BPF extensions are shown in the following table: 289 290 =================================== ================================================= 291 Extension Description 292 =================================== ================================================= 293 len skb->len 294 proto skb->protocol 295 type skb->pkt_type 296 poff Payload start offset 297 ifidx skb->dev->ifindex 298 nla Netlink attribute of type X with offset A 299 nlan Nested Netlink attribute of type X with offset A 300 mark skb->mark 301 queue skb->queue_mapping 302 hatype skb->dev->type 303 rxhash skb->hash 304 cpu raw_smp_processor_id() 305 vlan_tci skb_vlan_tag_get(skb) 306 vlan_avail skb_vlan_tag_present(skb) 307 vlan_tpid skb->vlan_proto 308 rand get_random_u32() 309 =================================== ================================================= 310 311These extensions can also be prefixed with '#'. 312Examples for low-level BPF: 313 314**ARP packets**:: 315 316 ldh [12] 317 jne #0x806, drop 318 ret #-1 319 drop: ret #0 320 321**IPv4 TCP packets**:: 322 323 ldh [12] 324 jne #0x800, drop 325 ldb [23] 326 jneq #6, drop 327 ret #-1 328 drop: ret #0 329 330**icmp random packet sampling, 1 in 4**:: 331 332 ldh [12] 333 jne #0x800, drop 334 ldb [23] 335 jneq #1, drop 336 # get a random uint32 number 337 ld rand 338 mod #4 339 jneq #1, drop 340 ret #-1 341 drop: ret #0 342 343**SECCOMP filter example**:: 344 345 ld [4] /* offsetof(struct seccomp_data, arch) */ 346 jne #0xc000003e, bad /* AUDIT_ARCH_X86_64 */ 347 ld [0] /* offsetof(struct seccomp_data, nr) */ 348 jeq #15, good /* __NR_rt_sigreturn */ 349 jeq #231, good /* __NR_exit_group */ 350 jeq #60, good /* __NR_exit */ 351 jeq #0, good /* __NR_read */ 352 jeq #1, good /* __NR_write */ 353 jeq #5, good /* __NR_fstat */ 354 jeq #9, good /* __NR_mmap */ 355 jeq #14, good /* __NR_rt_sigprocmask */ 356 jeq #13, good /* __NR_rt_sigaction */ 357 jeq #35, good /* __NR_nanosleep */ 358 bad: ret #0 /* SECCOMP_RET_KILL_THREAD */ 359 good: ret #0x7fff0000 /* SECCOMP_RET_ALLOW */ 360 361Examples for low-level BPF extension: 362 363**Packet for interface index 13**:: 364 365 ld ifidx 366 jneq #13, drop 367 ret #-1 368 drop: ret #0 369 370**(Accelerated) VLAN w/ id 10**:: 371 372 ld vlan_tci 373 jneq #10, drop 374 ret #-1 375 drop: ret #0 376 377The above example code can be placed into a file (here called "foo"), and 378then be passed to the bpf_asm tool for generating opcodes, output that xt_bpf 379and cls_bpf understands and can directly be loaded with. Example with above 380ARP code:: 381 382 $ ./bpf_asm foo 383 4,40 0 0 12,21 0 1 2054,6 0 0 4294967295,6 0 0 0, 384 385In copy and paste C-like output:: 386 387 $ ./bpf_asm -c foo 388 { 0x28, 0, 0, 0x0000000c }, 389 { 0x15, 0, 1, 0x00000806 }, 390 { 0x06, 0, 0, 0xffffffff }, 391 { 0x06, 0, 0, 0000000000 }, 392 393In particular, as usage with xt_bpf or cls_bpf can result in more complex BPF 394filters that might not be obvious at first, it's good to test filters before 395attaching to a live system. For that purpose, there's a small tool called 396bpf_dbg under tools/bpf/ in the kernel source directory. This debugger allows 397for testing BPF filters against given pcap files, single stepping through the 398BPF code on the pcap's packets and to do BPF machine register dumps. 399 400Starting bpf_dbg is trivial and just requires issuing:: 401 402 # ./bpf_dbg 403 404In case input and output do not equal stdin/stdout, bpf_dbg takes an 405alternative stdin source as a first argument, and an alternative stdout 406sink as a second one, e.g. `./bpf_dbg test_in.txt test_out.txt`. 407 408Other than that, a particular libreadline configuration can be set via 409file "~/.bpf_dbg_init" and the command history is stored in the file 410"~/.bpf_dbg_history". 411 412Interaction in bpf_dbg happens through a shell that also has auto-completion 413support (follow-up example commands starting with '>' denote bpf_dbg shell). 414The usual workflow would be to ... 415 416* load bpf 6,40 0 0 12,21 0 3 2048,48 0 0 23,21 0 1 1,6 0 0 65535,6 0 0 0 417 Loads a BPF filter from standard output of bpf_asm, or transformed via 418 e.g. ``tcpdump -iem1 -ddd port 22 | tr '\n' ','``. Note that for JIT 419 debugging (next section), this command creates a temporary socket and 420 loads the BPF code into the kernel. Thus, this will also be useful for 421 JIT developers. 422 423* load pcap foo.pcap 424 425 Loads standard tcpdump pcap file. 426 427* run [<n>] 428 429bpf passes:1 fails:9 430 Runs through all packets from a pcap to account how many passes and fails 431 the filter will generate. A limit of packets to traverse can be given. 432 433* disassemble:: 434 435 l0: ldh [12] 436 l1: jeq #0x800, l2, l5 437 l2: ldb [23] 438 l3: jeq #0x1, l4, l5 439 l4: ret #0xffff 440 l5: ret #0 441 442 Prints out BPF code disassembly. 443 444* dump:: 445 446 /* { op, jt, jf, k }, */ 447 { 0x28, 0, 0, 0x0000000c }, 448 { 0x15, 0, 3, 0x00000800 }, 449 { 0x30, 0, 0, 0x00000017 }, 450 { 0x15, 0, 1, 0x00000001 }, 451 { 0x06, 0, 0, 0x0000ffff }, 452 { 0x06, 0, 0, 0000000000 }, 453 454 Prints out C-style BPF code dump. 455 456* breakpoint 0:: 457 458 breakpoint at: l0: ldh [12] 459 460* breakpoint 1:: 461 462 breakpoint at: l1: jeq #0x800, l2, l5 463 464 ... 465 466 Sets breakpoints at particular BPF instructions. Issuing a `run` command 467 will walk through the pcap file continuing from the current packet and 468 break when a breakpoint is being hit (another `run` will continue from 469 the currently active breakpoint executing next instructions): 470 471 * run:: 472 473 -- register dump -- 474 pc: [0] <-- program counter 475 code: [40] jt[0] jf[0] k[12] <-- plain BPF code of current instruction 476 curr: l0: ldh [12] <-- disassembly of current instruction 477 A: [00000000][0] <-- content of A (hex, decimal) 478 X: [00000000][0] <-- content of X (hex, decimal) 479 M[0,15]: [00000000][0] <-- folded content of M (hex, decimal) 480 -- packet dump -- <-- Current packet from pcap (hex) 481 len: 42 482 0: 00 19 cb 55 55 a4 00 14 a4 43 78 69 08 06 00 01 483 16: 08 00 06 04 00 01 00 14 a4 43 78 69 0a 3b 01 26 484 32: 00 00 00 00 00 00 0a 3b 01 01 485 (breakpoint) 486 > 487 488 * breakpoint:: 489 490 breakpoints: 0 1 491 492 Prints currently set breakpoints. 493 494* step [-<n>, +<n>] 495 496 Performs single stepping through the BPF program from the current pc 497 offset. Thus, on each step invocation, above register dump is issued. 498 This can go forwards and backwards in time, a plain `step` will break 499 on the next BPF instruction, thus +1. (No `run` needs to be issued here.) 500 501* select <n> 502 503 Selects a given packet from the pcap file to continue from. Thus, on 504 the next `run` or `step`, the BPF program is being evaluated against 505 the user pre-selected packet. Numbering starts just as in Wireshark 506 with index 1. 507 508* quit 509 510 Exits bpf_dbg. 511 512JIT compiler 513------------ 514 515The Linux kernel has a built-in BPF JIT compiler for x86_64, SPARC, 516PowerPC, ARM, ARM64, MIPS, RISC-V and s390 and can be enabled through 517CONFIG_BPF_JIT. The JIT compiler is transparently invoked for each 518attached filter from user space or for internal kernel users if it has 519been previously enabled by root:: 520 521 echo 1 > /proc/sys/net/core/bpf_jit_enable 522 523For JIT developers, doing audits etc, each compile run can output the generated 524opcode image into the kernel log via:: 525 526 echo 2 > /proc/sys/net/core/bpf_jit_enable 527 528Example output from dmesg:: 529 530 [ 3389.935842] flen=6 proglen=70 pass=3 image=ffffffffa0069c8f 531 [ 3389.935847] JIT code: 00000000: 55 48 89 e5 48 83 ec 60 48 89 5d f8 44 8b 4f 68 532 [ 3389.935849] JIT code: 00000010: 44 2b 4f 6c 4c 8b 87 d8 00 00 00 be 0c 00 00 00 533 [ 3389.935850] JIT code: 00000020: e8 1d 94 ff e0 3d 00 08 00 00 75 16 be 17 00 00 534 [ 3389.935851] JIT code: 00000030: 00 e8 28 94 ff e0 83 f8 01 75 07 b8 ff ff 00 00 535 [ 3389.935852] JIT code: 00000040: eb 02 31 c0 c9 c3 536 537When CONFIG_BPF_JIT_ALWAYS_ON is enabled, bpf_jit_enable is permanently set to 1 and 538setting any other value than that will return in failure. This is even the case for 539setting bpf_jit_enable to 2, since dumping the final JIT image into the kernel log 540is discouraged and introspection through bpftool (under tools/bpf/bpftool/) is the 541generally recommended approach instead. 542 543In the kernel source tree under tools/bpf/, there's bpf_jit_disasm for 544generating disassembly out of the kernel log's hexdump:: 545 546 # ./bpf_jit_disasm 547 70 bytes emitted from JIT compiler (pass:3, flen:6) 548 ffffffffa0069c8f + <x>: 549 0: push %rbp 550 1: mov %rsp,%rbp 551 4: sub $0x60,%rsp 552 8: mov %rbx,-0x8(%rbp) 553 c: mov 0x68(%rdi),%r9d 554 10: sub 0x6c(%rdi),%r9d 555 14: mov 0xd8(%rdi),%r8 556 1b: mov $0xc,%esi 557 20: callq 0xffffffffe0ff9442 558 25: cmp $0x800,%eax 559 2a: jne 0x0000000000000042 560 2c: mov $0x17,%esi 561 31: callq 0xffffffffe0ff945e 562 36: cmp $0x1,%eax 563 39: jne 0x0000000000000042 564 3b: mov $0xffff,%eax 565 40: jmp 0x0000000000000044 566 42: xor %eax,%eax 567 44: leaveq 568 45: retq 569 570 Issuing option `-o` will "annotate" opcodes to resulting assembler 571 instructions, which can be very useful for JIT developers: 572 573 # ./bpf_jit_disasm -o 574 70 bytes emitted from JIT compiler (pass:3, flen:6) 575 ffffffffa0069c8f + <x>: 576 0: push %rbp 577 55 578 1: mov %rsp,%rbp 579 48 89 e5 580 4: sub $0x60,%rsp 581 48 83 ec 60 582 8: mov %rbx,-0x8(%rbp) 583 48 89 5d f8 584 c: mov 0x68(%rdi),%r9d 585 44 8b 4f 68 586 10: sub 0x6c(%rdi),%r9d 587 44 2b 4f 6c 588 14: mov 0xd8(%rdi),%r8 589 4c 8b 87 d8 00 00 00 590 1b: mov $0xc,%esi 591 be 0c 00 00 00 592 20: callq 0xffffffffe0ff9442 593 e8 1d 94 ff e0 594 25: cmp $0x800,%eax 595 3d 00 08 00 00 596 2a: jne 0x0000000000000042 597 75 16 598 2c: mov $0x17,%esi 599 be 17 00 00 00 600 31: callq 0xffffffffe0ff945e 601 e8 28 94 ff e0 602 36: cmp $0x1,%eax 603 83 f8 01 604 39: jne 0x0000000000000042 605 75 07 606 3b: mov $0xffff,%eax 607 b8 ff ff 00 00 608 40: jmp 0x0000000000000044 609 eb 02 610 42: xor %eax,%eax 611 31 c0 612 44: leaveq 613 c9 614 45: retq 615 c3 616 617For BPF JIT developers, bpf_jit_disasm, bpf_asm and bpf_dbg provides a useful 618toolchain for developing and testing the kernel's JIT compiler. 619 620BPF kernel internals 621-------------------- 622Internally, for the kernel interpreter, a different instruction set 623format with similar underlying principles from BPF described in previous 624paragraphs is being used. However, the instruction set format is modelled 625closer to the underlying architecture to mimic native instruction sets, so 626that a better performance can be achieved (more details later). This new 627ISA is called eBPF. See the ../bpf/index.rst for details. (Note: eBPF which 628originates from [e]xtended BPF is not the same as BPF extensions! While 629eBPF is an ISA, BPF extensions date back to classic BPF's 'overloading' 630of BPF_LD | BPF_{B,H,W} | BPF_ABS instruction.) 631 632The new instruction set was originally designed with the possible goal in 633mind to write programs in "restricted C" and compile into eBPF with a optional 634GCC/LLVM backend, so that it can just-in-time map to modern 64-bit CPUs with 635minimal performance overhead over two steps, that is, C -> eBPF -> native code. 636 637Currently, the new format is being used for running user BPF programs, which 638includes seccomp BPF, classic socket filters, cls_bpf traffic classifier, 639team driver's classifier for its load-balancing mode, netfilter's xt_bpf 640extension, PTP dissector/classifier, and much more. They are all internally 641converted by the kernel into the new instruction set representation and run 642in the eBPF interpreter. For in-kernel handlers, this all works transparently 643by using bpf_prog_create() for setting up the filter, resp. 644bpf_prog_destroy() for destroying it. The function 645bpf_prog_run(filter, ctx) transparently invokes eBPF interpreter or JITed 646code to run the filter. 'filter' is a pointer to struct bpf_prog that we 647got from bpf_prog_create(), and 'ctx' the given context (e.g. 648skb pointer). All constraints and restrictions from bpf_check_classic() apply 649before a conversion to the new layout is being done behind the scenes! 650 651Currently, the classic BPF format is being used for JITing on most 65232-bit architectures, whereas x86-64, aarch64, s390x, powerpc64, 653sparc64, arm32, riscv64, riscv32, loongarch64 perform JIT compilation 654from eBPF instruction set. 655 656Testing 657------- 658 659Next to the BPF toolchain, the kernel also ships a test module that contains 660various test cases for classic and eBPF that can be executed against 661the BPF interpreter and JIT compiler. It can be found in lib/test_bpf.c and 662enabled via Kconfig:: 663 664 CONFIG_TEST_BPF=m 665 666After the module has been built and installed, the test suite can be executed 667via insmod or modprobe against 'test_bpf' module. Results of the test cases 668including timings in nsec can be found in the kernel log (dmesg). 669 670Misc 671---- 672 673Also trinity, the Linux syscall fuzzer, has built-in support for BPF and 674SECCOMP-BPF kernel fuzzing. 675 676Written by 677---------- 678 679The document was written in the hope that it is found useful and in order 680to give potential BPF hackers or security auditors a better overview of 681the underlying architecture. 682 683- Jay Schulist <jschlst@samba.org> 684- Daniel Borkmann <daniel@iogearbox.net> 685- Alexei Starovoitov <ast@kernel.org> 686