I've been experimenting with kernel-level programming in Rust, and I'm running into a weird issue with printing output over a serial port. Using the RISC-V SBI, I implemented a writer for the SBI debug console as follows:
struct SbiDebugConsole;
impl fmt::Write for SbiDebugConsole {
fn write_str(&mut self, s: &str) -> fmt::Result {
// We need to convert the virtual address at which `s` is located into a physical address which we can pass to
// the SBI.
let executable_address_response = EXECUTABLE_ADDRESS_REQUEST.get_response().unwrap();
let s_addr = s.as_ptr().addr()
.wrapping_sub(executable_address_response.virtual_base() as usize)
.wrapping_add(executable_address_response.physical_base() as usize);
// Use assembly to directly call up to the SBI.
let (error, value): (usize, usize);
unsafe {
asm!(
"ecall",
in("a7") 0x4442434e,
in("a6") 0,
inlateout("a0") s.len() => error,
inlateout("a1") s_addr => value,
in("a2") 0,
);
}
if error != 0 || value != s.len() {
Err(fmt::Error)
} else {
Ok(())
}
}
}
Using this implementation, I can do things like writeln!(&mut SbiDebugConsole, "foo");. The problem, however, comes when I try to pass non-constant formatting arguments to writeln!. For instance, if I write
writeln!(&mut SbiDebugConsole, "foo");
writeln!(&mut SbiDebugConsole, "num: {}", 0xdeadbeef);
writeln!(&mut SbiDebugConsole, "bar");
everything works as expected, and all three lines are printed. If, however, I instead write
writeln!(&mut SbiDebugConsole, "foo");
let i = 0xdeadbeef;
writeln!(&mut SbiDebugConsole, "num: {}", i);
writeln!(&mut SbiDebugConsole, "bar");
my program appears to panic part-way through, and the output through the serial port reads only
foo
num:
with the number and the final string bar both absent. Here is a link to the project of which this code is a part, in case it's helpful. I have stepped through the code with GDB, and my Write implementation does not appear to be panicking, so I can only assume that some code in core is panicking somewhere.