From 00d0b8fb6bfc245ea00ffa347dcca00822bf73a9 Mon Sep 17 00:00:00 2001 From: bjorn3 <17426603+bjorn3@users.noreply.github.com> Date: Tue, 3 Oct 2023 12:26:46 +0200 Subject: [PATCH] Remove all pub from main.rs This will cause rustc to emit warnings for all unused items. --- src/main.rs | 90 ++++++++++++++++++++++++++--------------------------- 1 file changed, 45 insertions(+), 45 deletions(-) diff --git a/src/main.rs b/src/main.rs index 369c79031d..18f02ae7c9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -64,21 +64,21 @@ use core::sync::atomic::{AtomicU32, Ordering}; use crate::scheme::SchemeNamespace; -pub use crate::consts::*; +use crate::consts::*; #[macro_use] /// Shared data structures -pub mod common; +mod common; /// Architecture-dependent stuff #[macro_use] -pub mod arch; -pub use crate::arch::*; +mod arch; +use crate::arch::*; use crate::log::info; /// Heap allocators -pub mod allocator; +mod allocator; /// ACPI table parsing #[cfg(all(feature = "acpi", any(target_arch = "x86", target_arch = "x86_64")))] @@ -88,61 +88,61 @@ mod acpi; mod dtb; /// Context management -pub mod context; +mod context; /// Debugger -pub mod debugger; +mod debugger; /// Architecture-independent devices -pub mod devices; +mod devices; /// ELF file parsing #[cfg(not(feature="doc"))] -pub mod elf; +mod elf; /// Event handling -pub mod event; +mod event; /// External functions -pub mod externs; +mod externs; /// Logging -pub mod log; +mod log; /// Memory management -pub mod memory; +mod memory; /// Panic #[cfg(not(any(feature="doc", test)))] -pub mod panic; +mod panic; -pub mod percpu; +mod percpu; /// Process tracing -pub mod ptrace; +mod ptrace; /// Schemes, filesystem handlers -pub mod scheme; +mod scheme; /// Synchronization primitives -pub mod sync; +mod sync; /// Syscall handlers -pub mod syscall; +mod syscall; /// Time -pub mod time; +mod time; /// Tests #[cfg(test)] -pub mod tests; +mod tests; #[global_allocator] static ALLOCATOR: allocator::Allocator = allocator::Allocator; /// Get the current CPU's scheduling ID #[inline(always)] -pub fn cpu_id() -> LogicalCpuId { +fn cpu_id() -> LogicalCpuId { crate::percpu::PercpuBlock::current().cpu_id } @@ -151,29 +151,29 @@ static CPU_COUNT: AtomicU32 = AtomicU32::new(0); /// Get the number of CPUs currently active #[inline(always)] -pub fn cpu_count() -> u32 { +fn cpu_count() -> u32 { CPU_COUNT.load(Ordering::Relaxed) } -pub fn init_env() -> &'static [u8] { +fn init_env() -> &'static [u8] { crate::BOOTSTRAP.get().expect("BOOTSTRAP was not set").env } -pub extern "C" fn userspace_init() { +extern "C" fn userspace_init() { let bootstrap = crate::BOOTSTRAP.get().expect("BOOTSTRAP was not set"); unsafe { crate::syscall::process::usermode_bootstrap(bootstrap) } } -pub struct Bootstrap { - pub base: crate::memory::Frame, - pub page_count: usize, - pub entry: usize, - pub env: &'static [u8], +struct Bootstrap { + base: crate::memory::Frame, + page_count: usize, + entry: usize, + env: &'static [u8], } static BOOTSTRAP: spin::Once = spin::Once::new(); /// This is the kernel entry point for the primary CPU. The arch crate is responsible for calling this -pub fn kmain(cpu_count: u32, bootstrap: Bootstrap) -> ! { +fn kmain(cpu_count: u32, bootstrap: Bootstrap) -> ! { CPU_COUNT.store(cpu_count, Ordering::SeqCst); //Initialize the first context, stored in kernel/src/context/mod.rs @@ -213,7 +213,7 @@ pub fn kmain(cpu_count: u32, bootstrap: Bootstrap) -> ! { /// This is the main kernel entry point for secondary CPUs #[allow(unreachable_code, unused_variables)] -pub fn kmain_ap(cpu_id: LogicalCpuId) -> ! { +fn kmain_ap(cpu_id: LogicalCpuId) -> ! { if cfg!(feature = "multi_core") { context::init(); @@ -245,7 +245,7 @@ pub fn kmain_ap(cpu_id: LogicalCpuId) -> ! { /// Allow exception handlers to send signal to arch-independant kernel #[no_mangle] -pub extern fn ksignal(signal: usize) { +extern fn ksignal(signal: usize) { info!("SIGNAL {}, CPU {}, PID {:?}", signal, cpu_id(), context::context_id()); { let contexts = context::contexts(); @@ -279,7 +279,7 @@ macro_rules! linker_offsets( )* } ); -pub mod kernel_executable_offsets { +mod kernel_executable_offsets { linker_offsets!(__text_start, __text_end, __rodata_start, __rodata_end, __data_start, __data_end, __bss_start, __bss_end, __usercopy_start, __usercopy_end); #[cfg(target_arch = "x86_64")] @@ -294,13 +294,13 @@ pub mod kernel_executable_offsets { #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)] // TODO: NonMaxUsize? // TODO: Optimize away this type if not cfg!(feature = "multi_core") -pub struct LogicalCpuId(u32); +struct LogicalCpuId(u32); impl LogicalCpuId { - pub const BSP: Self = Self::new(0); + const BSP: Self = Self::new(0); - pub const fn new(inner: u32) -> Self { Self(inner) } - pub const fn get(self) -> u32 { self.0 } + const fn new(inner: u32) -> Self { Self(inner) } + const fn get(self) -> u32 { self.0 } } impl core::fmt::Debug for LogicalCpuId { @@ -319,16 +319,16 @@ impl core::fmt::Display for LogicalCpuId { // LogicalCpuId may be optimized accordingly. In that case, box the mask if it's larger than some // base size (probably 256 bytes). #[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub struct LogicalCpuSet(u128); +struct LogicalCpuSet(u128); impl LogicalCpuSet { - pub const fn new(inner: u128) -> Self { Self(inner) } - pub const fn get(self) -> u128 { self.0 } + const fn new(inner: u128) -> Self { Self(inner) } + const fn get(self) -> u128 { self.0 } - pub const fn empty() -> Self { Self::new(0) } - pub const fn all() -> Self { Self::new(!0) } - pub const fn single(id: LogicalCpuId) -> Self { Self::new(1 << id.get()) } - pub const fn contains(&self, id: LogicalCpuId) -> bool { + const fn empty() -> Self { Self::new(0) } + const fn all() -> Self { Self::new(!0) } + const fn single(id: LogicalCpuId) -> Self { Self::new(1 << id.get()) } + const fn contains(&self, id: LogicalCpuId) -> bool { self.0 & (1 << id.get()) != 0 } }