fix(kernel): fix warnings about any intermediate references created

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/arch/x86_64/cpu_local.rs

@@ -18,16 +18,11 @@
 use core::alloc::Layout;
 use core::ops::{Deref, DerefMut};
 
+use crate::extern_sym;
 use crate::mem::paging::VirtAddr;
-use crate::utils::LinkerSymbol;
 
 use super::io;
 
-extern "C" {
-    static __cpu_local_start: LinkerSymbol<u8>;
-    static __cpu_local_end: LinkerSymbol<u8>;
-}
-
 #[repr(C)]
 pub struct CpuLocal<T>(T);
 
@@ -49,7 +44,7 @@ impl<T> CpuLocal<T> {
         }
 
         let self_addr = VirtAddr::new(self as *const _ as u64);
-        let section_addr = VirtAddr::new(unsafe { &__cpu_local_start as *const _ as u64 });
+        let section_addr = VirtAddr::new(extern_sym!(__cpu_local_start) as u64);
 
         let offset = self_addr - section_addr;
         VirtAddr::new(val) + offset
@@ -81,9 +76,10 @@ static SELF_PTR: u64 = 0;
 static mut CPUID: usize = 0;
 
 pub fn init(cpu_id: usize) {
+    let start = VirtAddr::new(extern_sym!(__cpu_local_start).addr() as u64);
+    let end = VirtAddr::new(extern_sym!(__cpu_local_end).addr() as u64);
+
     unsafe {
-        let start = VirtAddr::new(&__cpu_local_start as *const _ as u64);
-        let end = VirtAddr::new(&__cpu_local_end as *const _ as u64);
         let size = end - start;
 
         let layout = Layout::from_size_align_unchecked(size as _, 64);

src/aero_kernel/src/arch/x86_64/gdt.rs

@@ -26,6 +26,7 @@
 
 use core::alloc::Layout;
 use core::mem;
+use core::ptr::addr_of;
 
 use alloc::alloc::alloc_zeroed;
 
@@ -302,7 +303,7 @@ pub fn init_boot() {
     unsafe {
         let gdt_descriptor = GdtDescriptor::new(
             (mem::size_of::<[GdtEntry; BOOT_GDT_ENTRY_COUNT]>() - 1) as u16,
-            (&BOOT_GDT as *const _) as u64,
+            addr_of!(BOOT_GDT).addr() as u64,
         );
 
         load_gdt(&gdt_descriptor);

src/aero_kernel/src/arch/x86_64/interrupts/idt.rs

@@ -24,6 +24,7 @@ const IDT_ENTRIES: usize = 256;
 pub(super) static mut IDT: [IdtEntry; IDT_ENTRIES] = [IdtEntry::NULL; IDT_ENTRIES];
 
 use core::mem::size_of;
+use core::ptr::addr_of;
 
 use crate::arch::gdt::SegmentSelector;
 use crate::utils::sync::Mutex;
@@ -216,7 +217,7 @@ pub fn init() {
     unsafe {
         let idt_descriptor = IdtDescriptor::new(
             ((IDT.len() * size_of::<IdtEntry>()) - 1) as u16,
-            (&IDT as *const _) as u64,
+            addr_of!(IDT).addr() as u64,
         );
 
         load_idt(&idt_descriptor);

src/aero_kernel/src/modules.rs

@@ -29,20 +29,22 @@
 //! aero_kernel::module_exit!(hello_exit);
 //! ```
 
-use crate::{drivers, fs};
+use core::mem::size_of;
+
+use crate::{drivers, extern_sym, fs};
 
 /// Inner helper function to make sure the function provided to the [module_init] macro
 /// has a valid function signature. This function returns the passed module init function as
 /// a const void pointer.
 
-#[derive(Debug, PartialEq, PartialOrd, Eq, Ord)]
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord)]
 #[repr(C)]
 pub enum ModuleType {
     Block = 0,
     Other = 1,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[repr(C)]
 pub struct Module {
     pub init: *const (),
@@ -69,20 +71,15 @@ macro_rules! module_init {
 /// we cannot read the ext2 root filesystem, we link all of the kernel modules into the kernel
 /// itself (this is temporary and modules will be loaded from the filesystem in the future).
 pub(crate) fn init() {
-    extern "C" {
-        static mut __kernel_modules_start: u8;
-        static mut __kernel_modules_end: u8;
-    }
+    let modules_start = extern_sym!(__kernel_modules_start).cast::<Module>();
+    let modules_end = extern_sym!(__kernel_modules_end).cast::<Module>();
 
-    unsafe {
-        let size = &__kernel_modules_end as *const u8 as usize
-            - &__kernel_modules_start as *const u8 as usize;
-
-        let modules = core::slice::from_raw_parts_mut(
-            &mut __kernel_modules_start as *mut u8 as *mut Module,
-            size / core::mem::size_of::<Module>(),
-        );
+    let size = (modules_end.addr() - modules_start.addr()) / size_of::<Module>();
+    let modules = unsafe { core::slice::from_raw_parts(modules_start, size) };
 
+    unsafe {
+        // TODO: refactor this out
+        let mut modules = modules.to_vec();
         modules.sort_by(|e, a| e.ty.cmp(&a.ty));
 
         let mut launched_fs = false;

src/aero_kernel/src/utils/mod.rs

@@ -223,5 +223,15 @@ impl<'a> StackHelper<'a> {
     }
 }
 
-#[repr(transparent)]
-pub struct LinkerSymbol<T: Copy>(core::cell::UnsafeCell<T>);
+#[macro_export]
+macro_rules! extern_sym {
+    ($sym:ident) => {{
+        extern "C" {
+            static $sym: ::core::ffi::c_void;
+        }
+
+        // SAFETY: The value is not accessed, we only take its address. The `addr_of!()` ensures
+        // that no intermediate references is created.
+        unsafe { ::core::ptr::addr_of!($sym) }
+    }};
+}