How to print panic backtraces?

[ChocolateLoverRaj]

Idk how panic backtraces work, but it seems like part of printing a nice looking backtrace is resolving symbols. I can do that because I have a user space program in an elf and I can parse the elf to look up symbols with https://github.com/cole14/rust-elf/. What would be the steps to actually printing a nice error message on panic?

Also would this be possible in the kernel itself by parsing the elf of the kernel itself inside the kernel's code?

[bjorn3]

To get a backtrace, you can either compile with frame pointers enabled (-Cforce-frame-pointers) and then walk the stack using frame pointers. Or you can compile with unwind tables enabled (-Cforce-unwind-tables) and then use the unwinding crate to handle unwinding the stack based on the unwind tables for you. The unwinding crate supports no_std, but you will need to disable the default features and enable one of the fde-* features to tell it how it should find the unwind tables.

Also would this be possible in the kernel itself by parsing the elf of the kernel itself inside the kernel's code?

Yes. Basically you did have to parse the entire kernel image as ELF file, look up it's symbol table and then for each address you got from the previous step to get a backtrace you have to find the symbol with the highest address lower than or equal to this address in the backtrace. The name of the symbol should then match the name of the function that corresponds to the stack frame. If your kernel can be relocated (PIC/PIE) then you will have to add the actual offset by which the kernel is relocated to the addresses you get from the symbol table.

[tsatke]

The unwinding crate

https://github.com/nbdd0121/unwinding

You'll need your own linker file.

[ChocolateLoverRaj]

How do you get the line and column number after getting the function from the symbol table?

[bjorn3]

For that you need to preserve the .debug_* sections in your kernel image and then parse the DWARF line tables using eg gimli. The addr2line crate may be useful for this.

[tsatke]

Seems like unwinding is overkill after all. If you just want to print backtraces, look at https://github.com/tsatke/devos/blob/935889f66944201bb70986bb753b96cac99ad66d/kernel/src/main.rs#L79 . Basically jump base-pointers until that's 0 and resolve the addresses to symbols (like @bjorn3 said). You'll need a mapping of your elf file in virtual memory, which limine conveniently provides.

This will give you something like

If you want filenames and line numbers, you'll have to dive into DWARF parsing. You could look at the addr2line crate together with gimli for that.

[ChocolateLoverRaj]

Btw since reading the pointers while getting the backtrace is unsafe, it sometimes causes page faults. The call stack can have random stuff in a syscall handler. So I checked the pointer first - https://github.com/ChocolateLoverRaj/code-runner/blob/2a94d1c642068bdc4a261dd018a82605a60a3d49/kernel/src/check_pointer.rs.

[tsatke]

Hmm, it seems to work just fine for me. If one of the base pointers or the instruction pointers is not null and not mapped, I think there's a different problem.

[ChocolateLoverRaj]

There were not mapped pointers when a panic happened in a syscall handler in my os.

[tsatke]

Want to try to find out why exactly?

Do you use any interruption gates that may change the stack or ring or whatever?

[ChocolateLoverRaj]

I don't really care why. My kernel does manually switch stacks in multiple places into uninitialized stack data which might be the cause.