LWN: Comments on "BPF in GCC"

BPF in GCC

evanovan — Mon, 08 Nov 2021 23:37:55 +0000

What are the requirements to debug BPF code as far as gdb / clang / llvm / gcc versions ?

I tried and these are the results.

getting latest GDB :
$ git clone git://sourceware.org/git/binutils-gdb.git
$ cd binutils-gdb
$ ./configure bpf
$ make

-----------------------------------

using gcc/g++ version (gcc version 11.1.0 (Ubuntu 11.1.0-1ubuntu1~18.04.1) )
command : gcc -ggdb -O2 -Wall -c hello_world.c -o hello_world.o ( debug symbols GETS generated )

./gdb/gdb <hello_world.o>
(gdb) target sim
(gdb) sim memory-size 4Mb
(gdb) load
(gdb) run

setting breakpoints and hitting them work
you CAN'T step
you CAN'T print "info registers" or print variables

continue or step crashes gdb and core dump

----------------------------------------------

using clang / llvm ( clang version 10.0.0-4ubuntu1~18.04.2)
command : clang -g -O2 -target bpf -c hello_world.c ( no debug symbols gets generated )

no debugging with no symbols

Please advise and share your experience

The trials of the systems programmer

mathstuf — Thu, 17 Sep 2020 22:33:56 +0000

I'd be fine with calling it Mickensian.

His talks (at least those I've seen) are also done with similar turns of phrase.

The trials of the systems programmer

pebolle — Thu, 17 Sep 2020 17:23:00 +0000

Is there a name for this style of writing?

It's bizarre hyperbole from the get-go. The few articles I've read by Mickens suggests he can get away with it. Quite a feat!

The trials of the systems programmer

sdalley — Thu, 17 Sep 2020 16:13:23 +0000

I'll say. There are months worth of QOTWs in it. E.g:

You might ask, “Why would someone write code in a grotesque language that exposes raw memory addresses? Why not use a modern language with garbage collection and functional programming and free massages after lunch?” Here’s the answer: Pointers are real. They’re what the hardware understands. Somebody has to deal with them. You can’t just place a LISP book on top of an x86 chip and hope that the hardware learns about lambda calculus by osmosis.

BPF in GCC

matthias — Thu, 17 Sep 2020 07:16:17 +0000

Many thanks for the link. This is really great.

BPF in GCC

ibukanov — Wed, 16 Sep 2020 18:58:53 +0000

WebAssembly! Seriously it was designed to run in browsers and supports memory constrains and interrupting long-running code while the performance is about 50% of the native code with a good jit or 5% with a small interpreter.

BPF in GCC

NYKevin — Wed, 16 Sep 2020 16:56:38 +0000

> static __u32 (* bpf_get_prandom_u32)( void ) = ( void *) 7;

This reminds me of something James Mickens wrote in 2013:

> What is despair? I have known it—hear my song. Despair is when you’re debugging a kernel driver and you look at a memory dump and you see that a pointer has a value of 7. THERE IS NO HARDWARE ARCHITECTURE THAT IS ALIGNED ON 7. Furthermore, 7 IS TOO SMALL AND ONLY EVIL CODE WOULD TRY TO ACCESS SMALL NUMBER MEMORY.

See https://scholar.harvard.edu/files/mickens/files/thenightw...

BPF in GCC

nix — Wed, 16 Sep 2020 15:59:51 +0000

FYI: people might be wondering what "functions that need to do their own save and restore of the register values" might be. The answer is varargs functions. GCC's testsuite calls a *lot* of these: it has many thousands of calls to printf alone. Obviously you won't want to use these in the kernel, but since the tests are not testing printf itself, it would be nice to be able to run them regardless.

BPF in GCC

wahern — Wed, 16 Sep 2020 06:50:19 +0000

Classic BPF has fixed-width 64-bit instructions with a 16-bit opcode field: http://www.tcpdump.org/papers/bpf-usenix93.pdf (see also https://www.kernel.org/doc/html/latest/networking/filter....).

Linux eBPF instructions have only an 8-bit opcode field: https://www.kernel.org/doc/html/latest/networking/filter.... (see end of section, just before https://www.kernel.org/doc/html/latest/networking/filter....). IIUC, eBPF is mostly fixed-width 64-bit, excepting a 128-bit double-word (64-bit) load immediate instruction. Judging by the source code at include/linux/filter.h:BPF_LD_IMM64_RAW the bottom 64 bits would have an opcode of 0 (top 32 bits cleared) if decoded alone, so would have to be consumed as part of the whole. As opposed to two well-formed instructions that implicitly fuse, e.g. left shift of and bitwise OR into a 64-bit register of a 32-bit immediate that could be executed serially to load a 64-bit value. (I don't do assembly programming so probably not using correct jargon.)

BPF in GCC

Cyberax — Wed, 16 Sep 2020 05:14:54 +0000

Hmm... BPF is getting more and more complicated.

Perhaps they should just switch to 16-bit x86 machine code? After all, the kernel already has an instruction emulator for it.

BPF in GCC

dxin — Wed, 16 Sep 2020 04:49:11 +0000

I wonder how BPF is already running out of op codes. What's the instruction size and opcode space size?

BPF in GCC

ncm — Wed, 16 Sep 2020 04:01:54 +0000

I have liked that with LLVM you can generate eBPF from C++ or even niche things like Rust or D as easily as from C, given a Makefile.

Here is hoping Gcc's version has similar talents. eBPF from Ada?

BPF in GCC

alison — Wed, 16 Sep 2020 04:01:23 +0000

"The GDB support is basic; it only handles loading a BPF program, single stepping, setting breakpoints, examining BPF registers, and listing the assembler code. Similarly, the simulator support is basic; it is integrated with GDB and most of the BPF instructions are supported so programs can run on it. There are plans to add various kinds of kernel contexts to the simulator so that different BPF program types can be run; for example, a program to be attached to a kprobe would be provided with a kprobe context in the simulator."

Presumably all the code in "BPF programs" here is userspace code. AFAIK, one must use kgdb to single-step, set breakpoints, etc. in the kernel itself. Is the intent to simulate the actual execution of the kernel in the simulator, or just to mock the returned contents from the bpf() syscall? Can the in-kernel execution of the BPF opcodes in the embedded VM can be single-stepped without kgdb? I looked at the slides, but they are much shorter than this excellent article.