chore(format): format all code

Author: GZTimeWalker

src/0x01/crates/boot/src/allocator.rs

@@ -1,5 +1,5 @@
 use uefi::boot::{AllocateType, MemoryType};
-use x86_64::{structures::paging::*, PhysAddr};
+use x86_64::{PhysAddr, structures::paging::*};
 
 /// Use `BootServices::allocate_pages()` as frame allocator
 pub struct UEFIFrameAllocator;

src/0x01/crates/boot/src/config.rs

@@ -9,7 +9,8 @@ pub struct Config<'a> {
     pub kernel_stack_auto_grow: u64,
     /// The size of the kernel stack, given in number of 4KiB pages
     pub kernel_stack_size: u64,
-    /// The offset into the virtual address space where the physical memory is mapped
+    /// The offset into the virtual address space where the physical memory is
+    /// mapped
     pub physical_memory_offset: u64,
     /// The path of kernel ELF
     pub kernel_path: &'a str,

src/0x01/crates/boot/src/fs.rs

@@ -1,7 +1,9 @@
 use core::ptr::NonNull;
-use uefi::boot::*;
-use uefi::proto::media::file::*;
-use uefi::proto::media::fs::SimpleFileSystem;
+
+use uefi::{
+    boot::*,
+    proto::media::{file::*, fs::SimpleFileSystem},
+};
 use xmas_elf::ElfFile;
 
 /// Open root directory

src/0x01/crates/boot/src/lib.rs

@@ -1,16 +1,19 @@
 #![no_std]
 
-pub use uefi::boot::{MemoryAttribute, MemoryDescriptor, MemoryType};
-pub use uefi::data_types::chars::*;
-pub use uefi::data_types::*;
-pub use uefi::proto::console::gop::{GraphicsOutput, ModeInfo};
-pub use uefi::Status;
+use core::ptr::NonNull;
 
 use arrayvec::ArrayVec;
-use core::ptr::NonNull;
-use x86_64::registers::control::Cr3;
-use x86_64::structures::paging::{OffsetPageTable, PageTable};
-use x86_64::VirtAddr;
+pub use uefi::{
+    Status,
+    boot::{MemoryAttribute, MemoryDescriptor, MemoryType},
+    data_types::{chars::*, *},
+    proto::console::gop::{GraphicsOutput, ModeInfo},
+};
+use x86_64::{
+    VirtAddr,
+    registers::control::Cr3,
+    structures::paging::{OffsetPageTable, PageTable},
+};
 
 pub mod allocator;
 pub mod config;
@@ -22,12 +25,14 @@ pub use fs::*;
 #[macro_use]
 extern crate log;
 
-/// This structure represents the information that the bootloader passes to the kernel.
+/// This structure represents the information that the bootloader passes to the
+/// kernel.
 pub struct BootInfo {
     /// The memory map
     pub memory_map: ArrayVec<MemoryDescriptor, 256>,
 
-    /// The offset into the virtual address space where the physical memory is mapped.
+    /// The offset into the virtual address space where the physical memory is
+    /// mapped.
     pub physical_memory_offset: u64,
 
     /// The system table virtual address
@@ -49,7 +54,8 @@ static mut ENTRY: usize = 0;
 ///
 /// # Safety
 ///
-/// This function is unsafe because the caller must ensure that the kernel entry point is valid.
+/// This function is unsafe because the caller must ensure that the kernel entry
+/// point is valid.
 #[cfg(feature = "boot")]
 pub fn jump_to_entry(bootinfo: *const BootInfo, stacktop: u64) -> ! {
     unsafe {
@@ -63,7 +69,8 @@ pub fn jump_to_entry(bootinfo: *const BootInfo, stacktop: u64) -> ! {
 ///
 /// # Safety
 ///
-/// This function is unsafe because the caller must ensure that the kernel entry point is valid.
+/// This function is unsafe because the caller must ensure that the kernel entry
+/// point is valid.
 #[inline(always)]
 #[cfg(feature = "boot")]
 pub fn set_entry(entry: usize) {
@@ -77,9 +84,10 @@ pub fn set_entry(entry: usize) {
 ///
 /// The function must have the signature `fn(&'static BootInfo) -> !`.
 ///
-/// This macro just creates a function named `_start`, which the linker will use as the entry
-/// point. The advantage of using this macro instead of providing an own `_start` function is
-/// that the macro ensures that the function and argument types are correct.
+/// This macro just creates a function named `_start`, which the linker will use
+/// as the entry point. The advantage of using this macro instead of providing
+/// an own `_start` function is that the macro ensures that the function and
+/// argument types are correct.
 #[macro_export]
 macro_rules! entry_point {
     ($path:path) => {

src/0x01/crates/boot/src/main.rs

@@ -6,9 +6,9 @@
 extern crate log;
 extern crate alloc;
 
-use alloc::boxed::Box;
-use alloc::vec;
-use uefi::{entry, Status};
+use alloc::{boxed::Box, vec};
+
+use uefi::{Status, entry};
 use x86_64::registers::control::*;
 use ysos_boot::*;
 
@@ -64,7 +64,6 @@ fn efi_main() -> Status {
     let ptr = uefi::table::system_table_raw().expect("Failed to get system table");
     let system_table = ptr.cast::<core::ffi::c_void>();
 
-
     // 6. Exit boot and jump to ELF entry
     info!("Exiting boot services...");
 

src/0x01/crates/elf/src/lib.rs

@@ -5,10 +5,11 @@ extern crate log;
 
 use core::ptr::{copy_nonoverlapping, write_bytes};
 
-use x86_64::structures::paging::page::PageRange;
-use x86_64::structures::paging::{mapper::*, *};
-use x86_64::{align_up, PhysAddr, VirtAddr};
-use xmas_elf::{program, ElfFile};
+use x86_64::{
+    PhysAddr, VirtAddr, align_up,
+    structures::paging::{mapper::*, page::PageRange, *},
+};
+use xmas_elf::{ElfFile, program};
 
 /// Map physical memory
 ///
@@ -95,13 +96,7 @@ pub fn load_elf(
             continue;
         }
 
-        load_segment(
-            elf,
-            physical_offset,
-            &segment,
-            page_table,
-            frame_allocator,
-        )?
+        load_segment(elf, physical_offset, &segment, page_table, frame_allocator)?
     }
 
     Ok(())

src/0x01/crates/kernel/src/drivers/mod.rs

@@ -1,2 +1,2 @@
-mod uart16550;
 pub mod serial;
+mod uart16550;

src/0x01/crates/kernel/src/lib.rs

@@ -16,7 +16,7 @@ mod drivers;
 pub use alloc::format;
 
 use boot::BootInfo;
-use uefi::{runtime::ResetType, Status};
+use uefi::{Status, runtime::ResetType};
 
 pub fn init(boot_info: &'static BootInfo) {
     unsafe {

src/0x01/crates/kernel/src/main.rs

@@ -5,6 +5,7 @@
 extern crate log;
 
 use core::arch::asm;
+
 use ysos_kernel as ysos;
 
 boot::entry_point!(kernel_main);

src/0x01/crates/kernel/src/utils/macros.rs

@@ -1,8 +1,10 @@
 use alloc::string::ToString;
-use crate::drivers::serial::{SERIAL, get_serial};
 use core::{arch::asm, fmt::*};
+
 use x86_64::instructions::interrupts;
 
+use crate::drivers::serial::{SERIAL, get_serial};
+
 /// Use spin mutex to control variable access
 #[macro_export]
 macro_rules! guard_access_fn {
@@ -175,4 +177,3 @@ fn is_canonical(addr: usize) -> bool {
     let upper = addr >> 47;
     upper == 0 || upper == 0x1ffff
 }
-