11 months ago was the last time I touched firedrake, and last weekend the urge to mess with it caught me again. So I set up WSL, installed all necessary dependencies and opened firedrake. I fired up the last compiled version I had, just to remind myself of where I had left things, and I QEMU was happy to dump my debug
printf()'s via the virtual UART into stdout. All was good. Then I compiled firedrake from scratch and it stopped working, or rather, it stopped producing output via the UART. That's strange, I thought, messed with a couple of things and also stashed all my git changes but no avail; No more output via the UART.
Alright, debugger time, QEMU is nice enough to provide a gdbserver that can be connected to. I put a breakpoint in the
kputs() function and checked it's input:
0x0010718c. When looking at the memory at the address, I found a single lone null byte which explained why there was no output,
kputs() figured that it was passed a empty string. That didn't make any sense though, it was early in the boot process and firedrake doesn't do any relocation at that point yet. There is no virtual memory, everything is essentially as GRUB had set it up. Just to make sure I also put a breakpoint into the first instruction run after the kernel is loaded and the null byte was still there. Now, that was interesting!
I tried allocating a buffer on the stack and putting a short string in there, unfortunately Clang was smart enough to detect what it was and also put it into the
.rodata section (although separate from the strings). That turned out to be interesting, instead of printing 'Hello' it printed 'ìe°[^]├UëÕ]Ús UëÕâýj'. Wat?!
Obvious next step: Disassembler. I actually found out that my favourite disassembler, Hopper, runs on WSL and works quite well on Windows with a X-Server installed. A excited tweet followed:
However, Hopper revealed that the address was perfectly valid and pointed into the
.rodata section of the firedrake binary. I then compared the working binary from 11 months ago to the one I had now, but couldn't find any differences for the life of me. The sections all looked the same, the access was the same, just GRUB seemed to zero out my
.rodata section now? I ended up trying a couple of things and scratching my head some more, but eventually I decided to look at the binary itself and dump its content with
readelf. Here are the relevant parts:
Section Headers: [Nr] Name Type Addr Off Size ES Flg Lk Inf Al [ 0] NULL 00000000 000000 000000 00 0 0 0 [ 1] .text PROGBITS 00100000 001000 0054eb 00 AX 0 0 16 [...]  .rodata PROGBITS 00107000 008000 00018c 00 A 0 0 4  .rodata.str1.1 PROGBITS 0010718c 00818c 000235 01 AMS 0 0 1 [...] Program Headers: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align LOAD 0x001000 0x00100000 0x00100000 0x06780 0x06780 R E 0x1000 LOAD 0x008000 0x00107000 0x00108980 0x003f8 0x003f8 R 0x1000 LOAD 0x009000 0x00108000 0x00109980 0x24010 0x24010 RW 0x1000 GNU_STACK 0x000000 0x00000000 0x00000000 0x00000 0x00000 RWE 0x10 Section to Segment mapping: Segment Sections... 00 .text .text.startup [...] 01 .rodata .rodata.str1.1 [...] 02 .bss .init_array 03
And with that, the mystery became clear. 0x107000 is where the
rodata section was supposed to be. But the ELF program header put its physical address at
0x108980 and GRUB loads the kernel into there, instead of the virtual address (which kinda makes sense, it's bare metal, no virtual addressing). Looking at the known good version actually revealed that both .text and .rodata where in one contiguous segment that spanned the kernel space. Looks like the linker I ended up installing on my fresh WSL install honours the fact that .rodata should be readonly and put it in its own segment. Previously the linker used one segment that had the Read, Write and Execute bits set.
With that mystery cleared up, the solution became to just compile the kernel with the
-fPIC flag and it all started working again. Time to put firedrake down for another year and see what breaks afterwards.