logger: log! macro now appends newline

This makes it harder to forget to append "\n" to log statments.
efi::console is also modified to take the lock outside of the loop.

Signed-off-by: Joe Richey <joerichey@google.com>

Author: josephlr

src/efi/console.rs

@@ -49,6 +49,8 @@ pub extern "win64" fn stdout_output_string(
     _: *mut SimpleTextOutputProtocol,
     message: *mut Char16,
 ) -> Status {
+    use core::fmt::Write;
+    let mut logger = crate::logger::LOGGER.lock();
     let mut string_end = false;
 
     loop {
@@ -62,7 +64,8 @@ pub extern "win64" fn stdout_output_string(
             }
             i += 1;
         }
-        crate::log!("{}", unsafe { core::str::from_utf8_unchecked(&output) });
+        let s = unsafe { core::str::from_utf8_unchecked(&output) };
+        logger.write_str(s).unwrap();
         if string_end {
             break;
         }

src/efi/file.rs

@@ -53,7 +53,7 @@ pub extern "win64" fn open(
     let wrapper = unsafe { &*wrapper };
 
     if !wrapper.root {
-        log!("Attempt to open file from non-root file is unsupported\n");
+        log!("Attempt to open file from non-root file is unsupported");
         return Status::UNSUPPORTED;
     }
 

src/logger.rs

@@ -22,12 +22,12 @@ use spin::Mutex;
 use cpuio::Port;
 
 lazy_static! {
-    static ref LOGGER: Mutex<Logger> = Mutex::new(Logger {
+    pub static ref LOGGER: Mutex<Logger> = Mutex::new(Logger {
         port: unsafe { Port::new(0x3f8) }
     });
 }
 
-struct Logger {
+pub struct Logger {
     port: Port<u8>,
 }
 
@@ -52,17 +52,11 @@ impl fmt::Write for Logger {
 
 #[macro_export]
 macro_rules! log {
-    ($($arg:tt)*) => ($crate::logger::_log(format_args!($($arg)*)));
-}
-
-#[cfg(not(test))]
-pub fn _log(args: fmt::Arguments) {
-    use core::fmt::Write;
-    LOGGER.lock().write_fmt(args).unwrap();
-}
-
-#[cfg(test)]
-pub fn _log(args: fmt::Arguments) {
-    use std::io::{self, Write};
-    write!(&mut std::io::stdout(), "{}", args).expect("stdout logging failed");
+    ($($arg:tt)*) => {{
+        use core::fmt::Write;
+        #[cfg(not(test))]
+        writeln!(&mut crate::logger::LOGGER.lock(), $($arg)*).unwrap();
+        #[cfg(test)]
+        println!($($arg)*);
+    }};
 }

src/main.rs

@@ -68,7 +68,7 @@ fn setup_pagetables() {
         pde.io_write_u64(i * 8, (0xb000u64 + (0x1000u64 * i)) | 0x03);
     }
 
-    log!("Page tables setup\n");
+    log!("Page tables setup");
 }
 
 const VIRTIO_PCI_VENDOR_ID: u16 = 0x1af4;
@@ -77,11 +77,11 @@ const VIRTIO_PCI_BLOCK_DEVICE_ID: u16 = 0x1042;
 fn boot_from_device(device: &mut block::VirtioBlockDevice) -> bool {
     match device.init() {
         Err(_) => {
-            log!("Error configuring block device\n");
+            log!("Error configuring block device");
             return false;
         }
         Ok(_) => log!(
-            "Virtio block device configured. Capacity: {} sectors\n",
+            "Virtio block device configured. Capacity: {} sectors",
             device.get_capacity()
         ),
     }
@@ -90,20 +90,20 @@ fn boot_from_device(device: &mut block::VirtioBlockDevice) -> bool {
 
     match part::find_efi_partition(device) {
         Ok((start, end)) => {
-            log!("Found EFI partition\n");
+            log!("Found EFI partition");
             f = fat::Filesystem::new(device, start, end);
             if f.init().is_err() {
-                log!("Failed to create filesystem\n");
+                log!("Failed to create filesystem");
                 return false;
             }
         }
         Err(_) => {
-            log!("Failed to find EFI partition\n");
+            log!("Failed to find EFI partition");
             return false;
         }
     }
 
-    log!("Filesystem ready\n");
+    log!("Filesystem ready");
 
     let jump_address;
 
@@ -112,28 +112,28 @@ fn boot_from_device(device: &mut block::VirtioBlockDevice) -> bool {
             jump_address = addr;
         }
         Err(_) => {
-            log!("Error loading default entry. Using EFI boot.\n");
+            log!("Error loading default entry. Using EFI boot.");
             match f.open("/EFI/BOOT/BOOTX64 EFI") {
                 Ok(mut file) => {
-                    log!("Found bootloader (BOOTX64.EFI)\n");
+                    log!("Found bootloader (BOOTX64.EFI)");
                     let mut l = pe::Loader::new(&mut file);
                     match l.load(0x20_0000) {
                         Ok((a, size)) => {
-                            log!("Executable loaded\n");
+                            log!("Executable loaded");
                             efi::efi_exec(a, 0x20_0000, size, &f, device);
                             return true;
                         }
                         Err(e) => {
                             match e {
-                                pe::Error::FileError => log!("File error\n"),
-                                pe::Error::InvalidExecutable => log!("Invalid executable\n"),
+                                pe::Error::FileError => log!("File error"),
+                                pe::Error::InvalidExecutable => log!("Invalid executable"),
                             }
                             return false;
                         }
                     }
                 }
                 Err(_) => {
-                    log!("Failed to find bootloader\n");
+                    log!("Failed to find bootloader");
                     return false;
                 }
             }
@@ -142,7 +142,7 @@ fn boot_from_device(device: &mut block::VirtioBlockDevice) -> bool {
 
     device.reset();
 
-    log!("Jumping to kernel\n");
+    log!("Jumping to kernel");
 
     // Rely on x86 C calling convention where second argument is put into %rsi register
     let ptr = jump_address as *const ();
@@ -157,7 +157,7 @@ pub extern "C" fn _start() -> ! {
         asm!("movq $$0x180000, %rsp");
     }
 
-    log!("Starting..\n");
+    log!("Starting..");
 
     enable_sse2();
     setup_pagetables();

src/pci.rs

@@ -69,7 +69,7 @@ pub fn print_bus() {
             continue;
         }
         log!(
-            "Found PCI device vendor={:x} device={:x} in slot={}\n",
+            "Found PCI device vendor={:x} device={:x} in slot={}",
             vendor_id,
             device_id,
             device
@@ -151,7 +151,7 @@ impl PciDevice {
         self.device_id = device_id;
 
         log!(
-            "PCI Device: {}:{}.{} {:x}:{:x}\n",
+            "PCI Device: {}:{}.{} {:x}:{:x}",
             self.bus,
             self.device,
             self.func,
@@ -197,7 +197,7 @@ impl PciDevice {
 
         #[allow(clippy::blacklisted_name)]
         for bar in &self.bars {
-            log!("Bar: type={:?} address={:x}\n", bar.bar_type, bar.address);
+            log!("Bar: type={:?} address={:x}", bar.bar_type, bar.address);
         }
     }
 }
@@ -258,7 +258,7 @@ impl VirtioTransport for VirtioPciTransport {
 
         // bit 4 of status is capability bit
         if status & 1 << 4 == 0 {
-            log!("No capabilities detected\n");
+            log!("No capabilities detected");
             return Err(VirtioError::VirtioUnsupportedDevice);
         }