DragonOS-Community/DragonOS
1
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-08 18:26:48 +00:00
Code Issues Releases Wiki Activity

feat(log): 将内核日志统一为新的logger (#814)

Browse Source
This commit is contained in:
曾俊 2024-05-16 17:25:23 +08:00 committed by GitHub
parent 92deae638b
commit 2eab6dd743
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
181 changed files with 1321 additions and 1261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/kernel/locking/mutex.md
View File

@ -59,10 +59,10 @@ let x :Mutex<Vec<i32>>= Mutex::new(Vec::new());
g.push(2); g.push(2);
assert!(g.as_slice() == [1, 2, 2] || g.as_slice() == [2, 2, 1]); assert!(g.as_slice() == [1, 2, 2] || g.as_slice() == [2, 2, 1]);
// 在此处，Mutex是加锁的状态 // 在此处，Mutex是加锁的状态
kdebug!("x={:?}", x); debug!("x={:?}", x);
} }
// 由于上方的变量`g`，也就是Mutex守卫的生命周期结束，自动释放了Mutex。因此，在此处，Mutex是放锁的状态 // 由于上方的变量`g`，也就是Mutex守卫的生命周期结束，自动释放了Mutex。因此，在此处，Mutex是放锁的状态
kdebug!("x={:?}", x); debug!("x={:?}", x);
``` ```
&emsp;&emsp;对于结构体内部的变量，我们可以使用Mutex进行细粒度的加锁，也就是使用Mutex包裹需要细致加锁的成员变量，比如这样： &emsp;&emsp;对于结构体内部的变量，我们可以使用Mutex进行细粒度的加锁，也就是使用Mutex包裹需要细致加锁的成员变量，比如这样：

4
docs/kernel/locking/spinlock.md
View File

@ -65,10 +65,10 @@ let x :SpinLock<Vec<i32>>= SpinLock::new(Vec::new());
g.push(2); g.push(2);
assert!(g.as_slice() == [1, 2, 2] || g.as_slice() == [2, 2, 1]); assert!(g.as_slice() == [1, 2, 2] || g.as_slice() == [2, 2, 1]);
// 在此处，SpinLock是加锁的状态 // 在此处，SpinLock是加锁的状态
kdebug!("x={:?}", x); debug!("x={:?}", x);
} }
// 由于上方的变量`g`，也就是SpinLock守卫的生命周期结束，自动释放了SpinLock。因此，在此处，SpinLock是放锁的状态 // 由于上方的变量`g`，也就是SpinLock守卫的生命周期结束，自动释放了SpinLock。因此，在此处，SpinLock是放锁的状态
kdebug!("x={:?}", x); debug!("x={:?}", x);
``` ```
&emsp;&emsp;对于结构体内部的变量，我们可以使用SpinLock进行细粒度的加锁，也就是使用SpinLock包裹需要细致加锁的成员变量，比如这样： &emsp;&emsp;对于结构体内部的变量，我们可以使用SpinLock进行细粒度的加锁，也就是使用SpinLock包裹需要细致加锁的成员变量，比如这样：

6
kernel/crates/unified-init/src/lib.rs
View File

@ -40,7 +40,7 @@ macro_rules! define_unified_initializer_slice {
static $name: [::unified_init::UnifiedInitializer] = [..]; static $name: [::unified_init::UnifiedInitializer] = [..];
}; };
() => { () => {
compile_error!( compile_kerror!(
"define_unified_initializer_slice! requires at least one argument: slice_name" "define_unified_initializer_slice! requires at least one argument: slice_name"
); );
}; };
@ -54,7 +54,7 @@ macro_rules! define_public_unified_initializer_slice {
pub static $name: [::unified_init::UnifiedInitializer] = [..]; pub static $name: [::unified_init::UnifiedInitializer] = [..];
}; };
() => { () => {
compile_error!( compile_kerror!(
"define_unified_initializer_slice! requires at least one argument: slice_name" "define_unified_initializer_slice! requires at least one argument: slice_name"
); );
}; };
@ -66,7 +66,7 @@ macro_rules! unified_init {
($initializer_slice:ident) => { ($initializer_slice:ident) => {
for initializer in $initializer_slice.iter() { for initializer in $initializer_slice.iter() {
initializer.call().unwrap_or_else(|e| { initializer.call().unwrap_or_else(|e| {
kerror!("Failed to call initializer {}: {:?}", initializer.name(), e); log::error!("Failed to call initializer {}: {:?}", initializer.name(), e);
}); });
} }
}; };

4
kernel/src/arch/riscv64/driver/of.rs
View File

@ -17,7 +17,7 @@ impl OpenFirmwareFdtDriver {
let offset = fdt_paddr.data() & crate::arch::MMArch::PAGE_OFFSET_MASK; let offset = fdt_paddr.data() & crate::arch::MMArch::PAGE_OFFSET_MASK;
let map_size = page_align_up(fdt_size + offset); let map_size = page_align_up(fdt_size + offset);
let map_paddr = PhysAddr::new(fdt_paddr.data() & crate::arch::MMArch::PAGE_MASK); let map_paddr = PhysAddr::new(fdt_paddr.data() & crate::arch::MMArch::PAGE_MASK);
// kdebug!( // debug!(
// "map_fdt paddr: {:?}, map_pa: {:?},fdt_size: {}, size: {:?}", // "map_fdt paddr: {:?}, map_pa: {:?},fdt_size: {}, size: {:?}",
// fdt_paddr, // fdt_paddr,
// map_paddr, // map_paddr,
@ -28,7 +28,7 @@ impl OpenFirmwareFdtDriver {
// drop the boot params guard in order to avoid deadlock // drop the boot params guard in order to avoid deadlock
drop(bp_guard); drop(bp_guard);
// kdebug!("map_fdt: map fdt to {:?}, size: {}", map_paddr, map_size); // debug!("map_fdt: map fdt to {:?}, size: {}", map_paddr, map_size);
mmio_guard.map_phys(map_paddr, map_size)?; mmio_guard.map_phys(map_paddr, map_size)?;
let mut bp_guard = boot_params().write(); let mut bp_guard = boot_params().write();
let vaddr = mmio_guard.vaddr() + offset; let vaddr = mmio_guard.vaddr() + offset;

11
kernel/src/arch/riscv64/init/mod.rs
View File

@ -1,11 +1,11 @@
use fdt::node::FdtNode; use fdt::node::FdtNode;
use log::{debug, info};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
arch::{driver::sbi::SbiDriver, mm::init::mm_early_init}, arch::{driver::sbi::SbiDriver, mm::init::mm_early_init},
driver::{firmware::efi::init::efi_init, open_firmware::fdt::open_firmware_fdt_driver}, driver::{firmware::efi::init::efi_init, open_firmware::fdt::open_firmware_fdt_driver},
init::{boot_params, init::start_kernel}, init::{boot_params, init::start_kernel},
kdebug, kinfo,
mm::{memblock::mem_block_manager, PhysAddr, VirtAddr}, mm::{memblock::mem_block_manager, PhysAddr, VirtAddr},
print, println, print, println,
smp::cpu::ProcessorId, smp::cpu::ProcessorId,
@ -112,13 +112,12 @@ pub fn early_setup_arch() -> Result<(), SystemError> {
arch_boot_params_guard.arch.fdt_paddr = fdt_paddr; arch_boot_params_guard.arch.fdt_paddr = fdt_paddr;
arch_boot_params_guard.arch.fdt_size = fdt.total_size(); arch_boot_params_guard.arch.fdt_size = fdt.total_size();
arch_boot_params_guard.arch.boot_hartid = ProcessorId::new(hartid); arch_boot_params_guard.arch.boot_hartid = ProcessorId::new(hartid);
// kdebug!("fdt_paddr: {:?}, fdt_size: {}", fdt_paddr, fdt.total_size()); // debug!("fdt_paddr: {:?}, fdt_size: {}", fdt_paddr, fdt.total_size());
drop(arch_boot_params_guard); drop(arch_boot_params_guard);
kinfo!( info!(
"DragonOS kernel is running on hart {}, fdt address:{:?}", "DragonOS kernel is running on hart {}, fdt address:{:?}",
hartid, hartid, fdt_paddr
fdt_paddr
); );
mm_early_init(); mm_early_init();
@ -127,7 +126,7 @@ pub fn early_setup_arch() -> Result<(), SystemError> {
unsafe { parse_dtb() }; unsafe { parse_dtb() };
for x in mem_block_manager().to_iter() { for x in mem_block_manager().to_iter() {
kdebug!("before efi: {x:?}"); debug!("before efi: {x:?}");
} }
efi_init(); efi_init();

40
kernel/src/arch/riscv64/interrupt/handle.rs
View File

@ -3,9 +3,10 @@
//! 架构相关的处理逻辑参考： https://code.dragonos.org.cn/xref/linux-6.6.21/arch/riscv/kernel/traps.c //! 架构相关的处理逻辑参考： https://code.dragonos.org.cn/xref/linux-6.6.21/arch/riscv/kernel/traps.c
use core::hint::spin_loop; use core::hint::spin_loop;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{arch::syscall::syscall_handler, driver::irqchip::riscv_intc::riscv_intc_irq, kerror}; use crate::{arch::syscall::syscall_handler, driver::irqchip::riscv_intc::riscv_intc_irq};
use super::TrapFrame; use super::TrapFrame;
@ -52,7 +53,7 @@ fn riscv64_do_exception(trap_frame: &mut TrapFrame) {
let handler = EXCEPTION_HANDLERS[code]; let handler = EXCEPTION_HANDLERS[code];
handler(trap_frame).ok(); handler(trap_frame).ok();
} else { } else {
kerror!("riscv64_do_irq: exception code out of range"); error!("riscv64_do_irq: exception code out of range");
loop { loop {
// kernel die // kernel die
spin_loop(); spin_loop();
@ -61,7 +62,7 @@ fn riscv64_do_exception(trap_frame: &mut TrapFrame) {
} }
fn default_handler(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn default_handler(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: handler not found"); error!("riscv64_do_irq: handler not found");
loop { loop {
spin_loop(); spin_loop();
} }
@ -69,7 +70,7 @@ fn default_handler(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
/// 处理指令地址不对齐异常 #0 /// 处理指令地址不对齐异常 #0
fn do_trap_insn_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_insn_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_insn_misaligned"); error!("riscv64_do_irq: do_trap_insn_misaligned");
loop { loop {
spin_loop(); spin_loop();
} }
@ -77,7 +78,7 @@ fn do_trap_insn_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemErro
/// 处理指令访问异常 #1 /// 处理指令访问异常 #1
fn do_trap_insn_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_insn_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_insn_access_fault"); error!("riscv64_do_irq: do_trap_insn_access_fault");
loop { loop {
spin_loop(); spin_loop();
} }
@ -85,7 +86,7 @@ fn do_trap_insn_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemEr
/// 处理非法指令异常 #2 /// 处理非法指令异常 #2
fn do_trap_insn_illegal(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_insn_illegal(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_insn_illegal"); error!("riscv64_do_irq: do_trap_insn_illegal");
loop { loop {
spin_loop(); spin_loop();
} }
@ -93,7 +94,7 @@ fn do_trap_insn_illegal(_trap_frame: &mut TrapFrame) -> Result<(), SystemError>
/// 处理断点异常 #3 /// 处理断点异常 #3
fn do_trap_break(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_break(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_break"); error!("riscv64_do_irq: do_trap_break");
loop { loop {
spin_loop(); spin_loop();
} }
@ -101,7 +102,7 @@ fn do_trap_break(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
/// 处理加载地址不对齐异常 #4 /// 处理加载地址不对齐异常 #4
fn do_trap_load_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_load_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_load_misaligned"); error!("riscv64_do_irq: do_trap_load_misaligned");
loop { loop {
spin_loop(); spin_loop();
} }
@ -109,7 +110,7 @@ fn do_trap_load_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemErro
/// 处理加载访问异常 #5 /// 处理加载访问异常 #5
fn do_trap_load_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_load_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_load_access_fault"); error!("riscv64_do_irq: do_trap_load_access_fault");
loop { loop {
spin_loop(); spin_loop();
} }
@ -117,7 +118,7 @@ fn do_trap_load_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemEr
/// 处理存储地址不对齐异常 #6 /// 处理存储地址不对齐异常 #6
fn do_trap_store_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_store_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_store_misaligned"); error!("riscv64_do_irq: do_trap_store_misaligned");
loop { loop {
spin_loop(); spin_loop();
} }
@ -125,7 +126,7 @@ fn do_trap_store_misaligned(_trap_frame: &mut TrapFrame) -> Result<(), SystemErr
/// 处理存储访问异常 #7 /// 处理存储访问异常 #7
fn do_trap_store_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_store_access_fault(_trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!("riscv64_do_irq: do_trap_store_access_fault"); error!("riscv64_do_irq: do_trap_store_access_fault");
loop { loop {
spin_loop(); spin_loop();
} }
@ -151,11 +152,9 @@ fn do_trap_insn_page_fault(trap_frame: &mut TrapFrame) -> Result<(), SystemError
let vaddr = trap_frame.badaddr; let vaddr = trap_frame.badaddr;
let cause = trap_frame.cause; let cause = trap_frame.cause;
let epc = trap_frame.epc; let epc = trap_frame.epc;
kerror!( error!(
"riscv64_do_irq: do_insn_page_fault vaddr: {:#x}, cause: {:?} epc: {:#x}", "riscv64_do_irq: do_insn_page_fault vaddr: {:#x}, cause: {:?} epc: {:#x}",
vaddr, vaddr, cause, epc
cause,
epc
); );
loop { loop {
spin_loop(); spin_loop();
@ -167,10 +166,9 @@ fn do_trap_load_page_fault(trap_frame: &mut TrapFrame) -> Result<(), SystemError
let vaddr = trap_frame.badaddr; let vaddr = trap_frame.badaddr;
let cause = trap_frame.cause; let cause = trap_frame.cause;
let epc = trap_frame.epc; let epc = trap_frame.epc;
kerror!( error!(
"riscv64_do_irq: do_trap_load_page_fault: epc: {epc:#x}, vaddr={:#x}, cause={:?}", "riscv64_do_irq: do_trap_load_page_fault: epc: {epc:#x}, vaddr={:#x}, cause={:?}",
vaddr, vaddr, cause
cause
); );
loop { loop {
@ -182,11 +180,9 @@ fn do_trap_load_page_fault(trap_frame: &mut TrapFrame) -> Result<(), SystemError
/// 处理页存储错误异常 #15 /// 处理页存储错误异常 #15
fn do_trap_store_page_fault(trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn do_trap_store_page_fault(trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
kerror!( error!(
"riscv64_do_irq: do_trap_store_page_fault: epc: {:#x}, vaddr={:#x}, cause={:?}", "riscv64_do_irq: do_trap_store_page_fault: epc: {:#x}, vaddr={:#x}, cause={:?}",
trap_frame.epc, trap_frame.epc, trap_frame.badaddr, trap_frame.cause
trap_frame.badaddr,
trap_frame.cause
); );
loop { loop {
spin_loop(); spin_loop();

13
kernel/src/arch/riscv64/ipc/signal.rs
View File

@ -1,7 +1,8 @@
use log::error;
use crate::{ use crate::{
arch::{sched::sched, CurrentIrqArch}, arch::{sched::sched, CurrentIrqArch},
exception::InterruptArch, exception::InterruptArch,
kerror,
process::ProcessManager, process::ProcessManager,
}; };
@ -68,7 +69,7 @@ impl From<usize> for Signal {
let ret: Signal = unsafe { core::mem::transmute(value) }; let ret: Signal = unsafe { core::mem::transmute(value) };
return ret; return ret;
} else { } else {
kerror!("Try to convert an invalid number to Signal"); error!("Try to convert an invalid number to Signal");
return Signal::INVALID; return Signal::INVALID;
} }
} }
@ -83,7 +84,7 @@ impl Into<usize> for Signal {
impl From<i32> for Signal { impl From<i32> for Signal {
fn from(value: i32) -> Self { fn from(value: i32) -> Self {
if value < 0 { if value < 0 {
kerror!("Try to convert an invalid number to Signal"); error!("Try to convert an invalid number to Signal");
return Signal::INVALID; return Signal::INVALID;
} else { } else {
return Self::from(value as usize); return Self::from(value as usize);
@ -127,7 +128,7 @@ impl Signal {
pub fn handle_default(&self) { pub fn handle_default(&self) {
match self { match self {
Signal::INVALID => { Signal::INVALID => {
kerror!("attempting to handler an Invalid"); error!("attempting to handler an Invalid");
} }
Signal::SIGHUP => sig_terminate(self.clone()), Signal::SIGHUP => sig_terminate(self.clone()),
Signal::SIGINT => sig_terminate(self.clone()), Signal::SIGINT => sig_terminate(self.clone()),
@ -312,7 +313,7 @@ fn sig_terminate_dump(sig: Signal) {
fn sig_stop(sig: Signal) { fn sig_stop(sig: Signal) {
let guard = unsafe { CurrentIrqArch::save_and_disable_irq() }; let guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
ProcessManager::mark_stop().unwrap_or_else(|e| { ProcessManager::mark_stop().unwrap_or_else(|e| {
kerror!( error!(
"sleep error :{:?},failed to sleep process :{:?}, with signal :{:?}", "sleep error :{:?},failed to sleep process :{:?}, with signal :{:?}",
e, e,
ProcessManager::current_pcb(), ProcessManager::current_pcb(),
@ -327,7 +328,7 @@ fn sig_stop(sig: Signal) {
/// 信号默认处理函数——继续进程 /// 信号默认处理函数——继续进程
fn sig_continue(sig: Signal) { fn sig_continue(sig: Signal) {
ProcessManager::wakeup_stop(&ProcessManager::current_pcb()).unwrap_or_else(|_| { ProcessManager::wakeup_stop(&ProcessManager::current_pcb()).unwrap_or_else(|_| {
kerror!( error!(
"Failed to wake up process pid = {:?} with signal :{:?}", "Failed to wake up process pid = {:?} with signal :{:?}",
ProcessManager::current_pcb().pid(), ProcessManager::current_pcb().pid(),
sig sig

24
kernel/src/arch/riscv64/mm/init.rs
View File

@ -1,5 +1,6 @@
use core::sync::atomic::{compiler_fence, AtomicBool, Ordering}; use core::sync::atomic::{compiler_fence, AtomicBool, Ordering};
use log::{debug, info};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -11,7 +12,6 @@ use crate::{
MMArch, MMArch,
}, },
driver::firmware::efi::efi_manager, driver::firmware::efi::efi_manager,
kdebug, kinfo,
libs::lib_ui::screen_manager::scm_disable_put_to_window, libs::lib_ui::screen_manager::scm_disable_put_to_window,
mm::{ mm::{
allocator::{buddy::BuddyAllocator, bump::BumpAllocator, page_frame::FrameAllocator}, allocator::{buddy::BuddyAllocator, bump::BumpAllocator, page_frame::FrameAllocator},
@ -56,7 +56,7 @@ unsafe fn init_kernel_addr() {
KERNEL_BEGIN_VA = VirtAddr::new(boot_text_start_pa as usize); KERNEL_BEGIN_VA = VirtAddr::new(boot_text_start_pa as usize);
KERNEL_END_VA = VirtAddr::new(_end as usize); KERNEL_END_VA = VirtAddr::new(_end as usize);
kdebug!( debug!(
"init_kernel_addr: \n\tKERNEL_BEGIN_PA: {KERNEL_BEGIN_PA:?} "init_kernel_addr: \n\tKERNEL_BEGIN_PA: {KERNEL_BEGIN_PA:?}
\tKERNEL_END_PA: {KERNEL_END_PA:?} \tKERNEL_END_PA: {KERNEL_END_PA:?}
\tKERNEL_BEGIN_VA: {KERNEL_BEGIN_VA:?} \tKERNEL_BEGIN_VA: {KERNEL_BEGIN_VA:?}
@ -78,7 +78,7 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
// 使用bump分配器，把所有的内存页都映射到页表 // 使用bump分配器，把所有的内存页都映射到页表
{ {
// kdebug!("to create new page table"); // debug!("to create new page table");
// 用bump allocator创建新的页表 // 用bump allocator创建新的页表
let mut mapper: crate::mm::page::PageMapper<MMArch, &mut BumpAllocator<MMArch>> = let mut mapper: crate::mm::page::PageMapper<MMArch, &mut BumpAllocator<MMArch>> =
crate::mm::page::PageMapper::<MMArch, _>::create( crate::mm::page::PageMapper::<MMArch, _>::create(
@ -87,7 +87,7 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
) )
.expect("Failed to create page mapper"); .expect("Failed to create page mapper");
new_page_table = mapper.table().phys(); new_page_table = mapper.table().phys();
// kdebug!("PageMapper created"); // debug!("PageMapper created");
// 取消最开始时候，在head.S中指定的映射(暂时不刷新TLB) // 取消最开始时候，在head.S中指定的映射(暂时不刷新TLB)
{ {
@ -99,12 +99,12 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
.expect("Failed to empty page table entry"); .expect("Failed to empty page table entry");
} }
} }
kdebug!("Successfully emptied page table"); debug!("Successfully emptied page table");
let total_num = mem_block_manager().total_initial_memory_regions(); let total_num = mem_block_manager().total_initial_memory_regions();
for i in 0..total_num { for i in 0..total_num {
let area = mem_block_manager().get_initial_memory_region(i).unwrap(); let area = mem_block_manager().get_initial_memory_region(i).unwrap();
// kdebug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size); // debug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size);
for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) { for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) {
let paddr = area.base.add(i * MMArch::PAGE_SIZE); let paddr = area.base.add(i * MMArch::PAGE_SIZE);
let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap(); let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap();
@ -125,7 +125,7 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
unsafe { unsafe {
INITIAL_PGTABLE_VALUE = new_page_table; INITIAL_PGTABLE_VALUE = new_page_table;
} }
kdebug!( debug!(
"After mapping all physical memory, DragonOS used: {} KB", "After mapping all physical memory, DragonOS used: {} KB",
bump_allocator.usage().used().bytes() / 1024 bump_allocator.usage().used().bytes() / 1024
); );
@ -134,7 +134,7 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
let buddy_allocator = unsafe { BuddyAllocator::<MMArch>::new(bump_allocator).unwrap() }; let buddy_allocator = unsafe { BuddyAllocator::<MMArch>::new(bump_allocator).unwrap() };
// 设置全局的页帧分配器 // 设置全局的页帧分配器
unsafe { set_inner_allocator(buddy_allocator) }; unsafe { set_inner_allocator(buddy_allocator) };
kinfo!("Successfully initialized buddy allocator"); info!("Successfully initialized buddy allocator");
// 关闭显示输出 // 关闭显示输出
scm_disable_put_to_window(); scm_disable_put_to_window();
@ -142,7 +142,7 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
{ {
let mut binding = INNER_ALLOCATOR.lock(); let mut binding = INNER_ALLOCATOR.lock();
let mut allocator_guard = binding.as_mut().unwrap(); let mut allocator_guard = binding.as_mut().unwrap();
kdebug!("To enable new page table."); debug!("To enable new page table.");
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
let mapper = crate::mm::page::PageMapper::<MMArch, _>::new( let mapper = crate::mm::page::PageMapper::<MMArch, _>::new(
PageTableKind::Kernel, PageTableKind::Kernel,
@ -152,10 +152,10 @@ pub(super) unsafe fn riscv_mm_init() -> Result<(), SystemError> {
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
mapper.make_current(); mapper.make_current();
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
// kdebug!("New page table enabled"); // debug!("New page table enabled");
} }
kdebug!("Successfully enabled new page table"); debug!("Successfully enabled new page table");
kinfo!("riscv mm init done"); info!("riscv mm init done");
return Ok(()); return Ok(());
} }

9
kernel/src/arch/riscv64/pci/pci_host_ecam.rs
View File

@ -1,4 +1,5 @@
use fdt::{node::FdtNode, Fdt}; use fdt::{node::FdtNode, Fdt};
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -6,7 +7,6 @@ use crate::{
open_firmware::fdt::open_firmware_fdt_driver, open_firmware::fdt::open_firmware_fdt_driver,
pci::ecam::{pci_ecam_root_info_manager, EcamRootInfo}, pci::ecam::{pci_ecam_root_info_manager, EcamRootInfo},
}, },
kdebug,
mm::PhysAddr, mm::PhysAddr,
}; };
@ -39,7 +39,7 @@ pub(super) fn pci_host_ecam_driver_init(fdt: &Fdt<'_>) -> Result<(), SystemError
_ => panic!("Unexpected linux,pci-domain length"), _ => panic!("Unexpected linux,pci-domain length"),
}; };
kdebug!( debug!(
"pci_host_ecam_driver_init(): {} paddr: {:#x} size: {:#x} bus-range: {}-{} segement_group_number: {}", "pci_host_ecam_driver_init(): {} paddr: {:#x} size: {:#x} bus-range: {}-{} segement_group_number: {}",
node.name, node.name,
paddr, paddr,
@ -61,10 +61,9 @@ pub(super) fn pci_host_ecam_driver_init(fdt: &Fdt<'_>) -> Result<(), SystemError
for node in open_firmware_fdt_driver().find_node_by_compatible(&fdt, "pci-host-ecam-generic") { for node in open_firmware_fdt_driver().find_node_by_compatible(&fdt, "pci-host-ecam-generic") {
if let Err(err) = do_check(node) { if let Err(err) = do_check(node) {
kdebug!( debug!(
"pci_host_ecam_driver_init(): check {} error: {:?}", "pci_host_ecam_driver_init(): check {} error: {:?}",
node.name, node.name, err
err
); );
} }
} }

8
kernel/src/arch/riscv64/process/idle.rs
View File

@ -1,6 +1,8 @@
use core::hint::spin_loop; use core::hint::spin_loop;
use crate::{arch::CurrentIrqArch, exception::InterruptArch, kBUG, process::ProcessManager}; use log::error;
use crate::{arch::CurrentIrqArch, exception::InterruptArch, process::ProcessManager};
impl ProcessManager { impl ProcessManager {
/// 每个核的idle进程 /// 每个核的idle进程
@ -9,11 +11,11 @@ impl ProcessManager {
if CurrentIrqArch::is_irq_enabled() { if CurrentIrqArch::is_irq_enabled() {
riscv::asm::wfi(); riscv::asm::wfi();
} else { } else {
kBUG!("Idle process should not be scheduled with IRQs disabled."); error!("Idle process should not be scheduled with IRQs disabled.");
spin_loop(); spin_loop();
} }
// kdebug!("idle loop"); // debug!("idle loop");
} }
} }
} }

10
kernel/src/arch/riscv64/process/mod.rs
View File

@ -6,6 +6,7 @@ use core::{
sync::atomic::{compiler_fence, Ordering}, sync::atomic::{compiler_fence, Ordering},
}; };
use kdepends::memoffset::offset_of; use kdepends::memoffset::offset_of;
use log::error;
use riscv::register::sstatus::Sstatus; use riscv::register::sstatus::Sstatus;
use system_error::SystemError; use system_error::SystemError;
@ -15,7 +16,6 @@ use crate::{
CurrentIrqArch, CurrentIrqArch,
}, },
exception::InterruptArch, exception::InterruptArch,
kerror,
libs::spinlock::SpinLockGuard, libs::spinlock::SpinLockGuard,
mm::VirtAddr, mm::VirtAddr,
process::{ process::{
@ -166,7 +166,7 @@ impl ProcessManager {
/// 参考: https://code.dragonos.org.cn/xref/linux-6.6.21/arch/riscv/include/asm/switch_to.h#76 /// 参考: https://code.dragonos.org.cn/xref/linux-6.6.21/arch/riscv/include/asm/switch_to.h#76
pub unsafe fn switch_process(prev: Arc<ProcessControlBlock>, next: Arc<ProcessControlBlock>) { pub unsafe fn switch_process(prev: Arc<ProcessControlBlock>, next: Arc<ProcessControlBlock>) {
assert!(!CurrentIrqArch::is_irq_enabled()); assert!(!CurrentIrqArch::is_irq_enabled());
// kdebug!( // debug!(
// "riscv switch process: prev: {:?}, next: {:?}", // "riscv switch process: prev: {:?}, next: {:?}",
// prev.pid(), // prev.pid(),
// next.pid() // next.pid()
@ -182,7 +182,7 @@ impl ProcessManager {
drop(next_addr_space); drop(next_addr_space);
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
// kdebug!("current sum={}, prev sum={}, next_sum={}", riscv::register::sstatus::read().sum(), prev.arch_info_irqsave().sstatus.sum(), next.arch_info_irqsave().sstatus.sum()); // debug!("current sum={}, prev sum={}, next_sum={}", riscv::register::sstatus::read().sum(), prev.arch_info_irqsave().sstatus.sum(), next.arch_info_irqsave().sstatus.sum());
// 获取arch info的锁，并强制泄露其守卫（切换上下文后，在switch_finish_hook中会释放锁） // 获取arch info的锁，并强制泄露其守卫（切换上下文后，在switch_finish_hook中会释放锁）
let next_arch = SpinLockGuard::leak(next.arch_info_irqsave()) as *mut ArchPCBInfo; let next_arch = SpinLockGuard::leak(next.arch_info_irqsave()) as *mut ArchPCBInfo;
@ -193,7 +193,7 @@ impl ProcessManager {
ProcessManager::current_pcb().preempt_enable(); ProcessManager::current_pcb().preempt_enable();
PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().prev_pcb = Some(prev); PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().prev_pcb = Some(prev);
PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().next_pcb = Some(next); PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().next_pcb = Some(next);
// kdebug!("riscv switch process: before to inner"); // debug!("riscv switch process: before to inner");
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
// 正式切换上下文 // 正式切换上下文
switch_to_inner(prev_arch, next_arch); switch_to_inner(prev_arch, next_arch);
@ -326,7 +326,7 @@ impl ProcessControlBlock {
// 从内核栈的最低地址处取出pcb的地址 // 从内核栈的最低地址处取出pcb的地址
let p = stack_base.data() as *const *const ProcessControlBlock; let p = stack_base.data() as *const *const ProcessControlBlock;
if core::intrinsics::unlikely((unsafe { *p }).is_null()) { if core::intrinsics::unlikely((unsafe { *p }).is_null()) {
kerror!("p={:p}", p); error!("p={:p}", p);
panic!("current_pcb is null"); panic!("current_pcb is null");
} }
unsafe { unsafe {

12
kernel/src/arch/riscv64/process/syscall.rs
View File

@ -23,7 +23,7 @@ impl Syscall {
// 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。 // 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。
let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() }; let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
let pcb = ProcessManager::current_pcb(); let pcb = ProcessManager::current_pcb();
// crate::kdebug!( // crate::debug!(
// "pid: {:?} do_execve: path: {:?}, argv: {:?}, envp: {:?}\n", // "pid: {:?} do_execve: path: {:?}, argv: {:?}, envp: {:?}\n",
// pcb.pid(), // pcb.pid(),
// path, // path,
@ -52,20 +52,20 @@ impl Syscall {
AddressSpace::is_current(&address_space), AddressSpace::is_current(&address_space),
"Failed to set address space" "Failed to set address space"
); );
// kdebug!("Switch to new address space"); // debug!("Switch to new address space");
// 切换到新的用户地址空间 // 切换到新的用户地址空间
unsafe { address_space.read().user_mapper.utable.make_current() }; unsafe { address_space.read().user_mapper.utable.make_current() };
drop(old_address_space); drop(old_address_space);
drop(irq_guard); drop(irq_guard);
// kdebug!("to load binary file"); // debug!("to load binary file");
let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?; let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?;
// 加载可执行文件 // 加载可执行文件
let load_result = load_binary_file(&mut param)?; let load_result = load_binary_file(&mut param)?;
// kdebug!("load binary file done"); // debug!("load binary file done");
// kdebug!("argv: {:?}, envp: {:?}", argv, envp); // debug!("argv: {:?}, envp: {:?}", argv, envp);
param.init_info_mut().args = argv; param.init_info_mut().args = argv;
param.init_info_mut().envs = envp; param.init_info_mut().envs = envp;
@ -91,7 +91,7 @@ impl Syscall {
}; };
address_space.write().user_stack = Some(ustack_message); address_space.write().user_stack = Some(ustack_message);
// kdebug!("write proc_init_info to user stack done"); // debug!("write proc_init_info to user stack done");
regs.a0 = param.init_info().args.len(); regs.a0 = param.init_info().args.len();
regs.a1 = argv_ptr.data(); regs.a1 = argv_ptr.data();

14
kernel/src/arch/riscv64/smp/mod.rs
View File

@ -1,11 +1,9 @@
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::smp::{
kwarn, cpu::{CpuHpCpuState, ProcessorId},
smp::{ SMPArch,
cpu::{CpuHpCpuState, ProcessorId},
SMPArch,
},
}; };
pub struct RiscV64SMPArch; pub struct RiscV64SMPArch;
@ -13,12 +11,12 @@ pub struct RiscV64SMPArch;
impl SMPArch for RiscV64SMPArch { impl SMPArch for RiscV64SMPArch {
#[inline(never)] #[inline(never)]
fn prepare_cpus() -> Result<(), SystemError> { fn prepare_cpus() -> Result<(), SystemError> {
kwarn!("RiscV64SMPArch::prepare_cpus() is not implemented"); warn!("RiscV64SMPArch::prepare_cpus() is not implemented");
Ok(()) Ok(())
} }
fn start_cpu(_cpu_id: ProcessorId, _hp_state: &CpuHpCpuState) -> Result<(), SystemError> { fn start_cpu(_cpu_id: ProcessorId, _hp_state: &CpuHpCpuState) -> Result<(), SystemError> {
kwarn!("RiscV64SMPArch::start_cpu() is not implemented"); warn!("RiscV64SMPArch::start_cpu() is not implemented");
Ok(()) Ok(())
} }
} }

4
kernel/src/arch/riscv64/syscall/mod.rs
View File

@ -18,7 +18,7 @@ macro_rules! syscall_return {
if $show { if $show {
let pid = ProcessManager::current_pcb().pid(); let pid = ProcessManager::current_pcb().pid();
crate::kdebug!("syscall return:pid={:?},ret= {:?}\n", pid, ret as isize); log::debug!("syscall return:pid={:?},ret= {:?}\n", pid, ret as isize);
} }
unsafe { unsafe {
@ -29,7 +29,7 @@ macro_rules! syscall_return {
} }
pub(super) fn syscall_handler(syscall_num: usize, frame: &mut TrapFrame) -> () { pub(super) fn syscall_handler(syscall_num: usize, frame: &mut TrapFrame) -> () {
// kdebug!("syscall_handler: syscall_num: {}", syscall_num); // debug!("syscall_handler: syscall_num: {}", syscall_num);
unsafe { unsafe {
CurrentIrqArch::interrupt_enable(); CurrentIrqArch::interrupt_enable();
} }

9
kernel/src/arch/riscv64/time.rs
View File

@ -1,6 +1,7 @@
use log::{debug, info};
use crate::{ use crate::{
driver::open_firmware::fdt::open_firmware_fdt_driver, driver::open_firmware::fdt::open_firmware_fdt_driver,
kdebug, kinfo,
time::{clocksource::HZ, TimeArch}, time::{clocksource::HZ, TimeArch},
}; };
pub struct RiscV64TimeArch; pub struct RiscV64TimeArch;
@ -14,12 +15,12 @@ static mut TIME_FREQ: usize = 0;
/// ///
/// todo: 支持从acpi中获取 /// todo: 支持从acpi中获取
fn init_time_freq() { fn init_time_freq() {
kdebug!("init_time_freq: init"); debug!("init_time_freq: init");
let fdt = open_firmware_fdt_driver().fdt_ref(); let fdt = open_firmware_fdt_driver().fdt_ref();
if fdt.is_err() { if fdt.is_err() {
panic!("init_time_freq: failed to get fdt"); panic!("init_time_freq: failed to get fdt");
} }
kdebug!("init_time_freq: get fdt"); debug!("init_time_freq: get fdt");
let fdt = fdt.unwrap(); let fdt = fdt.unwrap();
let cpu_node = fdt.find_node("/cpus"); let cpu_node = fdt.find_node("/cpus");
if cpu_node.is_none() { if cpu_node.is_none() {
@ -36,7 +37,7 @@ fn init_time_freq() {
} }
let time_freq: usize = time_freq.unwrap(); let time_freq: usize = time_freq.unwrap();
kinfo!("init_time_freq: timebase-frequency: {}", time_freq); info!("init_time_freq: timebase-frequency: {}", time_freq);
unsafe { unsafe {
TIME_FREQ = time_freq; TIME_FREQ = time_freq;
} }

5
kernel/src/arch/x86_64/acpi.rs
View File

@ -1,5 +1,6 @@
use super::smp::SMP_BOOT_DATA; use super::smp::SMP_BOOT_DATA;
use crate::{driver::acpi::acpi_manager, kinfo, mm::percpu::PerCpu, smp::cpu::ProcessorId}; use crate::{driver::acpi::acpi_manager, mm::percpu::PerCpu, smp::cpu::ProcessorId};
use log::info;
use system_error::SystemError; use system_error::SystemError;
pub(super) fn early_acpi_boot_init() -> Result<(), SystemError> { pub(super) fn early_acpi_boot_init() -> Result<(), SystemError> {
@ -24,7 +25,7 @@ pub(super) fn early_acpi_boot_init() -> Result<(), SystemError> {
SMP_BOOT_DATA.set_cpu_count(cnt.data()); SMP_BOOT_DATA.set_cpu_count(cnt.data());
SMP_BOOT_DATA.mark_initialized(); SMP_BOOT_DATA.mark_initialized();
} }
kinfo!( info!(
"early_acpi_boot_init: cpu_count: {}\n", "early_acpi_boot_init: cpu_count: {}\n",
SMP_BOOT_DATA.cpu_count() SMP_BOOT_DATA.cpu_count()
); );

19
kernel/src/arch/x86_64/driver/apic/apic_timer.rs
View File

@ -11,7 +11,6 @@ use crate::exception::irqdesc::{
use crate::exception::manage::irq_manager; use crate::exception::manage::irq_manager;
use crate::exception::IrqNumber; use crate::exception::IrqNumber;
use crate::kdebug;
use crate::mm::percpu::PerCpu; use crate::mm::percpu::PerCpu;
use crate::process::ProcessManager; use crate::process::ProcessManager;
use crate::smp::core::smp_get_processor_id; use crate::smp::core::smp_get_processor_id;
@ -20,6 +19,7 @@ use crate::time::clocksource::HZ;
use alloc::string::ToString; use alloc::string::ToString;
use alloc::sync::Arc; use alloc::sync::Arc;
pub use drop; pub use drop;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use x86::cpuid::cpuid; use x86::cpuid::cpuid;
use x86::msr::{wrmsr, IA32_X2APIC_DIV_CONF, IA32_X2APIC_INIT_COUNT}; use x86::msr::{wrmsr, IA32_X2APIC_DIV_CONF, IA32_X2APIC_INIT_COUNT};
@ -105,7 +105,7 @@ pub(super) fn local_apic_timer_irq_desc_init() {
/// 初始化BSP的APIC定时器 /// 初始化BSP的APIC定时器
/// ///
fn init_bsp_apic_timer() { fn init_bsp_apic_timer() {
kdebug!("init_bsp_apic_timer"); debug!("init_bsp_apic_timer");
assert!(smp_get_processor_id().data() == 0); assert!(smp_get_processor_id().data() == 0);
let mut local_apic_timer = local_apic_timer_instance_mut(ProcessorId::new(0)); let mut local_apic_timer = local_apic_timer_instance_mut(ProcessorId::new(0));
local_apic_timer.init( local_apic_timer.init(
@ -113,11 +113,11 @@ fn init_bsp_apic_timer() {
LocalApicTimer::periodic_default_initial_count(), LocalApicTimer::periodic_default_initial_count(),
LocalApicTimer::DIVISOR as u32, LocalApicTimer::DIVISOR as u32,
); );
kdebug!("init_bsp_apic_timer done"); debug!("init_bsp_apic_timer done");
} }
fn init_ap_apic_timer() { fn init_ap_apic_timer() {
kdebug!("init_ap_apic_timer"); debug!("init_ap_apic_timer");
let cpu_id = smp_get_processor_id(); let cpu_id = smp_get_processor_id();
assert!(cpu_id.data() != 0); assert!(cpu_id.data() != 0);
@ -127,14 +127,14 @@ fn init_ap_apic_timer() {
LocalApicTimer::periodic_default_initial_count(), LocalApicTimer::periodic_default_initial_count(),
LocalApicTimer::DIVISOR as u32, LocalApicTimer::DIVISOR as u32,
); );
kdebug!("init_ap_apic_timer done"); debug!("init_ap_apic_timer done");
} }
pub(super) struct LocalApicTimerIntrController; pub(super) struct LocalApicTimerIntrController;
impl LocalApicTimerIntrController { impl LocalApicTimerIntrController {
pub(super) fn install(&self) { pub(super) fn install(&self) {
kdebug!("LocalApicTimerIntrController::install"); debug!("LocalApicTimerIntrController::install");
if smp_get_processor_id().data() == 0 { if smp_get_processor_id().data() == 0 {
init_bsp_apic_timer(); init_bsp_apic_timer();
} else { } else {
@ -150,7 +150,7 @@ impl LocalApicTimerIntrController {
} }
pub(super) fn enable(&self) { pub(super) fn enable(&self) {
kdebug!("LocalApicTimerIntrController::enable"); debug!("LocalApicTimerIntrController::enable");
let cpu_id = smp_get_processor_id(); let cpu_id = smp_get_processor_id();
let mut local_apic_timer = local_apic_timer_instance_mut(cpu_id); let mut local_apic_timer = local_apic_timer_instance_mut(cpu_id);
local_apic_timer.start_current(); local_apic_timer.start_current();
@ -221,10 +221,9 @@ impl LocalApicTimer {
} }
fn install_periodic_mode(&mut self, initial_count: u64, divisor: u32) { fn install_periodic_mode(&mut self, initial_count: u64, divisor: u32) {
kdebug!( debug!(
"install_periodic_mode: initial_count = {}, divisor = {}", "install_periodic_mode: initial_count = {}, divisor = {}",
initial_count, initial_count, divisor
divisor
); );
self.mode = LocalApicTimerMode::Periodic; self.mode = LocalApicTimerMode::Periodic;
self.set_divisor(divisor); self.set_divisor(divisor);

14
kernel/src/arch/x86_64/driver/apic/ioapic.rs
View File

@ -4,6 +4,7 @@ use acpi::madt::Madt;
use alloc::sync::Arc; use alloc::sync::Arc;
use bit_field::BitField; use bit_field::BitField;
use bitflags::bitflags; use bitflags::bitflags;
use log::{debug, info};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -16,7 +17,6 @@ use crate::{
manage::irq_manager, manage::irq_manager,
IrqNumber, IrqNumber,
}, },
kdebug, kinfo,
libs::{ libs::{
cpumask::CpuMask, cpumask::CpuMask,
once::Once, once::Once,
@ -68,7 +68,7 @@ impl IoApic {
let mut result: Option<IoApic> = None; let mut result: Option<IoApic> = None;
INIT_STATE.call_once(|| { INIT_STATE.call_once(|| {
kinfo!("Initializing ioapic..."); info!("Initializing ioapic...");
// get ioapic base from acpi // get ioapic base from acpi
@ -104,7 +104,7 @@ impl IoApic {
mmio_guard.map_phys(phys_base, 0x1000).is_ok(), mmio_guard.map_phys(phys_base, 0x1000).is_ok(),
"IoApic::new(): failed to map phys" "IoApic::new(): failed to map phys"
); );
kdebug!("Ioapic map ok"); debug!("Ioapic map ok");
let reg = mmio_guard.vaddr(); let reg = mmio_guard.vaddr();
result = Some(IoApic { result = Some(IoApic {
@ -114,13 +114,13 @@ impl IoApic {
phys_base, phys_base,
mmio_guard, mmio_guard,
}); });
kdebug!("IOAPIC: to mask all RTE"); debug!("IOAPIC: to mask all RTE");
// 屏蔽所有的RTE // 屏蔽所有的RTE
let res_mut = result.as_mut().unwrap(); let res_mut = result.as_mut().unwrap();
for i in 0..res_mut.supported_interrupts() { for i in 0..res_mut.supported_interrupts() {
res_mut.write_rte(i, 0x20 + i, RedirectionEntry::DISABLED, 0); res_mut.write_rte(i, 0x20 + i, RedirectionEntry::DISABLED, 0);
} }
kdebug!("Ioapic init done"); debug!("Ioapic init done");
}); });
assert!( assert!(
@ -393,7 +393,7 @@ impl InnerIoApicChipData {
#[inline(never)] #[inline(never)]
pub fn ioapic_init(ignore: &'static [IrqNumber]) { pub fn ioapic_init(ignore: &'static [IrqNumber]) {
kinfo!("Initializing ioapic..."); info!("Initializing ioapic...");
let ioapic = unsafe { IoApic::new() }; let ioapic = unsafe { IoApic::new() };
unsafe { unsafe {
__IOAPIC = Some(SpinLock::new(ioapic)); __IOAPIC = Some(SpinLock::new(ioapic));
@ -424,7 +424,7 @@ pub fn ioapic_init(ignore: &'static [IrqNumber]) {
register_handler(&desc, level); register_handler(&desc, level);
} }
kinfo!("IO Apic initialized."); info!("IO Apic initialized.");
} }
fn register_handler(desc: &Arc<IrqDesc>, level_triggered: bool) { fn register_handler(desc: &Arc<IrqDesc>, level_triggered: bool) {

6
kernel/src/arch/x86_64/driver/apic/lapic_vector.rs
View File

@ -2,6 +2,7 @@ use core::intrinsics::unlikely;
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use intertrait::CastFrom; use intertrait::CastFrom;
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -25,7 +26,6 @@ use crate::{
msi::MsiMsg, msi::MsiMsg,
HardwareIrqNumber, IrqNumber, HardwareIrqNumber, IrqNumber,
}, },
kwarn,
libs::spinlock::{SpinLock, SpinLockGuard}, libs::spinlock::{SpinLock, SpinLockGuard},
smp::{core::smp_get_processor_id, cpu::ProcessorId}, smp::{core::smp_get_processor_id, cpu::ProcessorId},
}; };
@ -206,7 +206,7 @@ pub(super) fn irq_msi_compose_msg(cfg: &HardwareIrqConfig, msg: &mut MsiMsg, dma
// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/apic/apic.c?fi=__irq_msi_compose_msg#2580 // 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/apic/apic.c?fi=__irq_msi_compose_msg#2580
address_lo.set_virt_destid_8_14(cfg.apic_id.data() >> 8); address_lo.set_virt_destid_8_14(cfg.apic_id.data() >> 8);
} else if unlikely(cfg.apic_id.data() > 0xff) { } else if unlikely(cfg.apic_id.data() > 0xff) {
kwarn!( warn!(
"irq_msi_compose_msg: Invalid APIC ID: {}", "irq_msi_compose_msg: Invalid APIC ID: {}",
cfg.apic_id.data() cfg.apic_id.data()
); );
@ -252,7 +252,7 @@ pub fn arch_early_irq_init() -> Result<(), SystemError> {
// todo: add vector matrix // todo: add vector matrix
// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/apic/vector.c#803 // 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/apic/vector.c#803
kwarn!("arch_early_irq_init: todo: add vector matrix"); warn!("arch_early_irq_init: todo: add vector matrix");
local_apic_timer_irq_desc_init(); local_apic_timer_irq_desc_init();
arch_ipi_handler_init(); arch_ipi_handler_init();

14
kernel/src/arch/x86_64/driver/apic/mod.rs
View File

@ -1,6 +1,7 @@
use core::sync::atomic::Ordering; use core::sync::atomic::Ordering;
use atomic_enum::atomic_enum; use atomic_enum::atomic_enum;
use log::{debug, info};
use system_error::SystemError; use system_error::SystemError;
use x86::{apic::Icr, msr::IA32_APIC_BASE}; use x86::{apic::Icr, msr::IA32_APIC_BASE};
@ -10,7 +11,6 @@ use crate::{
io::PortIOArch, io::PortIOArch,
CurrentPortIOArch, CurrentPortIOArch,
}, },
kdebug, kinfo,
mm::PhysAddr, mm::PhysAddr,
smp::core::smp_get_processor_id, smp::core::smp_get_processor_id,
}; };
@ -468,7 +468,7 @@ impl CurrentApic {
CurrentPortIOArch::out8(0x20, 0x20); CurrentPortIOArch::out8(0x20, 0x20);
CurrentPortIOArch::out8(0xa0, 0x20); CurrentPortIOArch::out8(0xa0, 0x20);
kdebug!("8259A Masked."); debug!("8259A Masked.");
// enable IMCR // enable IMCR
CurrentPortIOArch::out8(0x22, 0x70); CurrentPortIOArch::out8(0x22, 0x70);
@ -488,14 +488,14 @@ impl LocalAPIC for CurrentApic {
self.mask8259a(); self.mask8259a();
} }
} }
kinfo!("Initializing apic for cpu {:?}", cpu_id); info!("Initializing apic for cpu {:?}", cpu_id);
if X2Apic::support() && X2Apic.init_current_cpu() { if X2Apic::support() && X2Apic.init_current_cpu() {
if cpu_id.data() == 0 { if cpu_id.data() == 0 {
LOCAL_APIC_ENABLE_TYPE.store(LocalApicEnableType::X2Apic, Ordering::SeqCst); LOCAL_APIC_ENABLE_TYPE.store(LocalApicEnableType::X2Apic, Ordering::SeqCst);
} }
kinfo!("x2APIC initialized for cpu {:?}", cpu_id); info!("x2APIC initialized for cpu {:?}", cpu_id);
} else { } else {
kinfo!("x2APIC not supported or failed to initialize, fallback to xAPIC."); info!("x2APIC not supported or failed to initialize, fallback to xAPIC.");
if cpu_id.data() == 0 { if cpu_id.data() == 0 {
LOCAL_APIC_ENABLE_TYPE.store(LocalApicEnableType::XApic, Ordering::SeqCst); LOCAL_APIC_ENABLE_TYPE.store(LocalApicEnableType::XApic, Ordering::SeqCst);
} }
@ -514,10 +514,10 @@ impl LocalAPIC for CurrentApic {
xapic.init_current_cpu(); xapic.init_current_cpu();
} }
kinfo!("xAPIC initialized for cpu {:?}", cpu_id); info!("xAPIC initialized for cpu {:?}", cpu_id);
} }
kinfo!("Apic initialized."); info!("Apic initialized.");
return true; return true;
} }

11
kernel/src/arch/x86_64/driver/apic/x2apic.rs
View File

@ -1,12 +1,11 @@
use core::sync::atomic::{fence, Ordering}; use core::sync::atomic::{fence, Ordering};
use log::info;
use x86::msr::{ use x86::msr::{
rdmsr, wrmsr, IA32_APIC_BASE, IA32_X2APIC_APICID, IA32_X2APIC_EOI, IA32_X2APIC_SIVR, rdmsr, wrmsr, IA32_APIC_BASE, IA32_X2APIC_APICID, IA32_X2APIC_EOI, IA32_X2APIC_SIVR,
IA32_X2APIC_VERSION, IA32_X2APIC_VERSION,
}; };
use crate::kinfo;
use super::{hw_irq::ApicId, LVTRegister, LocalAPIC, LVT}; use super::{hw_irq::ApicId, LVTRegister, LocalAPIC, LVT};
#[derive(Debug)] #[derive(Debug)]
@ -45,19 +44,19 @@ impl LocalAPIC for X2Apic {
(rdmsr(IA32_X2APIC_SIVR) & 0x100) == 0x100, (rdmsr(IA32_X2APIC_SIVR) & 0x100) == 0x100,
"x2APIC software enable failed." "x2APIC software enable failed."
); );
kinfo!("x2APIC software enabled."); info!("x2APIC software enabled.");
if self.support_eoi_broadcast_suppression() { if self.support_eoi_broadcast_suppression() {
assert!( assert!(
(rdmsr(IA32_X2APIC_SIVR) & 0x1000) == 0x1000, (rdmsr(IA32_X2APIC_SIVR) & 0x1000) == 0x1000,
"x2APIC EOI broadcast suppression enable failed." "x2APIC EOI broadcast suppression enable failed."
); );
kinfo!("x2APIC EOI broadcast suppression enabled."); info!("x2APIC EOI broadcast suppression enabled.");
} }
} }
// kdebug!("x2apic: to mask all lvt"); // debug!("x2apic: to mask all lvt");
self.mask_all_lvt(); self.mask_all_lvt();
// kdebug!("x2apic: all lvt masked"); // debug!("x2apic: all lvt masked");
} }
true true
} }

13
kernel/src/arch/x86_64/driver/apic/xapic.rs
View File

@ -4,8 +4,9 @@ use core::{
ptr::{read_volatile, write_volatile}, ptr::{read_volatile, write_volatile},
}; };
use log::{debug, error, info};
use crate::{ use crate::{
kdebug, kerror, kinfo,
mm::{ mm::{
mmio_buddy::{mmio_pool, MMIOSpaceGuard}, mmio_buddy::{mmio_pool, MMIOSpaceGuard},
percpu::PerCpu, percpu::PerCpu,
@ -157,7 +158,7 @@ impl XApic {
g.map_phys(paddr, 4096).expect("Fail to map MMIO for XAPIC"); g.map_phys(paddr, 4096).expect("Fail to map MMIO for XAPIC");
let addr = g.vaddr() + offset; let addr = g.vaddr() + offset;
kdebug!( debug!(
"XAPIC: {:#x} -> {:#x}, offset={offset}", "XAPIC: {:#x} -> {:#x}, offset={offset}",
xapic_base.data(), xapic_base.data(),
addr.data() addr.data()
@ -219,7 +220,7 @@ impl LocalAPIC for XApic {
x86::msr::wrmsr(x86::msr::APIC_BASE, (self.xapic_base.data() | 0x800) as u64); x86::msr::wrmsr(x86::msr::APIC_BASE, (self.xapic_base.data() | 0x800) as u64);
let val = x86::msr::rdmsr(x86::msr::APIC_BASE); let val = x86::msr::rdmsr(x86::msr::APIC_BASE);
if val & 0x800 != 0x800 { if val & 0x800 != 0x800 {
kerror!("xAPIC enable failed: APIC_BASE & 0x800 != 0x800"); error!("xAPIC enable failed: APIC_BASE & 0x800 != 0x800");
return false; return false;
} }
// 设置 Spurious Interrupt Vector Register // 设置 Spurious Interrupt Vector Register
@ -229,15 +230,15 @@ impl LocalAPIC for XApic {
let val = self.read(XApicOffset::LOCAL_APIC_OFFSET_Local_APIC_SVR); let val = self.read(XApicOffset::LOCAL_APIC_OFFSET_Local_APIC_SVR);
if val & ENABLE == 0 { if val & ENABLE == 0 {
kerror!("xAPIC software enable failed."); error!("xAPIC software enable failed.");
return false; return false;
} else { } else {
kinfo!("xAPIC software enabled."); info!("xAPIC software enabled.");
} }
if val & 0x1000 != 0 { if val & 0x1000 != 0 {
kinfo!("xAPIC EOI broadcast suppression enabled."); info!("xAPIC EOI broadcast suppression enabled.");
} }
self.mask_all_lvt(); self.mask_all_lvt();

14
kernel/src/arch/x86_64/driver/hpet.rs
View File

@ -7,6 +7,7 @@ use core::{
use acpi::HpetInfo; use acpi::HpetInfo;
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use log::{debug, error, info};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -21,7 +22,6 @@ use crate::{
manage::irq_manager, manage::irq_manager,
InterruptArch, IrqNumber, InterruptArch, IrqNumber,
}, },
kdebug, kerror, kinfo,
libs::{ libs::{
rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard}, rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
volatile::volwrite, volatile::volwrite,
@ -80,8 +80,8 @@ impl Hpet {
.unwrap() .unwrap()
}; };
let tm_num = hpet.timers_num(); let tm_num = hpet.timers_num();
kdebug!("HPET0_INTERVAL_USEC: {}", Self::HPET0_INTERVAL_USEC); debug!("HPET0_INTERVAL_USEC: {}", Self::HPET0_INTERVAL_USEC);
kinfo!("HPET has {} timers", tm_num); info!("HPET has {} timers", tm_num);
hpet_info.hpet_number = tm_num as u8; hpet_info.hpet_number = tm_num as u8;
drop(mmio); drop(mmio);
@ -124,10 +124,10 @@ impl Hpet {
// ！！！这里是临时糊代码的，需要在apic重构的时候修改！！！ // ！！！这里是临时糊代码的，需要在apic重构的时候修改！！！
let (inner_guard, regs) = unsafe { self.hpet_regs_mut() }; let (inner_guard, regs) = unsafe { self.hpet_regs_mut() };
let freq = regs.frequency(); let freq = regs.frequency();
kdebug!("HPET frequency: {} Hz", freq); debug!("HPET frequency: {} Hz", freq);
let ticks = Self::HPET0_INTERVAL_USEC * freq / 1000000; let ticks = Self::HPET0_INTERVAL_USEC * freq / 1000000;
if ticks == 0 || ticks > freq * 8 { if ticks == 0 || ticks > freq * 8 {
kerror!("HPET enable: ticks '{ticks}' is invalid"); error!("HPET enable: ticks '{ticks}' is invalid");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
if unlikely(regs.timers_num() == 0) { if unlikely(regs.timers_num() == 0) {
@ -166,7 +166,7 @@ impl Hpet {
drop(inner_guard); drop(inner_guard);
kinfo!("HPET enabled"); info!("HPET enabled");
drop(irq_guard); drop(irq_guard);
return Ok(()); return Ok(());
@ -239,7 +239,7 @@ impl Hpet {
pub fn period(&self) -> u64 { pub fn period(&self) -> u64 {
let (inner_guard, regs) = unsafe { self.hpet_regs() }; let (inner_guard, regs) = unsafe { self.hpet_regs() };
let period = regs.counter_clock_period(); let period = regs.counter_clock_period();
kdebug!("HPET period: {}", period); debug!("HPET period: {}", period);
drop(inner_guard); drop(inner_guard);
return period; return period;

4
kernel/src/arch/x86_64/driver/rtc.rs
View File

@ -4,6 +4,7 @@ use alloc::{
string::{String, ToString}, string::{String, ToString},
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use log::error;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -25,7 +26,6 @@ use crate::{
exception::InterruptArch, exception::InterruptArch,
filesystem::kernfs::KernFSInode, filesystem::kernfs::KernFSInode,
init::initcall::INITCALL_DEVICE, init::initcall::INITCALL_DEVICE,
kerror,
libs::{ libs::{
mutex::Mutex, mutex::Mutex,
rwlock::{RwLockReadGuard, RwLockWriteGuard}, rwlock::{RwLockReadGuard, RwLockWriteGuard},
@ -286,7 +286,7 @@ impl RtcClassOps for CmosRtcClassOps {
} }
fn set_time(&self, _dev: &Arc<dyn RtcDevice>, _time: &RtcTime) -> Result<(), SystemError> { fn set_time(&self, _dev: &Arc<dyn RtcDevice>, _time: &RtcTime) -> Result<(), SystemError> {
kerror!("set_time is not implemented for CmosRtcClassOps"); error!("set_time is not implemented for CmosRtcClassOps");
Err(SystemError::ENOSYS) Err(SystemError::ENOSYS)
} }
} }

38
kernel/src/arch/x86_64/driver/tsc.rs
View File

@ -2,13 +2,13 @@ use crate::{
arch::{io::PortIOArch, CurrentIrqArch, CurrentPortIOArch, CurrentTimeArch}, arch::{io::PortIOArch, CurrentIrqArch, CurrentPortIOArch, CurrentTimeArch},
driver::acpi::pmtmr::{acpi_pm_read_early, ACPI_PM_OVERRUN, PMTMR_TICKS_PER_SEC}, driver::acpi::pmtmr::{acpi_pm_read_early, ACPI_PM_OVERRUN, PMTMR_TICKS_PER_SEC},
exception::InterruptArch, exception::InterruptArch,
kdebug, kerror, kinfo, kwarn,
time::{TimeArch, PIT_TICK_RATE}, time::{TimeArch, PIT_TICK_RATE},
}; };
use core::{ use core::{
cmp::{max, min}, cmp::{max, min},
intrinsics::unlikely, intrinsics::unlikely,
}; };
use log::{debug, error, info, warn};
use system_error::SystemError; use system_error::SystemError;
use super::hpet::{hpet_instance, is_hpet_enabled}; use super::hpet::{hpet_instance, is_hpet_enabled};
@ -31,13 +31,13 @@ impl TSCManager {
let cpuid = x86::cpuid::CpuId::new(); let cpuid = x86::cpuid::CpuId::new();
let feat = cpuid.get_feature_info().ok_or(SystemError::ENODEV)?; let feat = cpuid.get_feature_info().ok_or(SystemError::ENODEV)?;
if !feat.has_tsc() { if !feat.has_tsc() {
kerror!("TSC is not available"); error!("TSC is not available");
return Err(SystemError::ENODEV); return Err(SystemError::ENODEV);
} }
if unsafe { TSC_KHZ == 0 } { if unsafe { TSC_KHZ == 0 } {
if let Err(e) = Self::determine_cpu_tsc_frequency(false) { if let Err(e) = Self::determine_cpu_tsc_frequency(false) {
kerror!("Failed to determine CPU TSC frequency: {:?}", e); error!("Failed to determine CPU TSC frequency: {:?}", e);
// todo: mark TSC as unstable clock source // todo: mark TSC as unstable clock source
return Err(e); return Err(e);
} }
@ -57,7 +57,7 @@ impl TSCManager {
/// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/tsc.c#1438 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/arch/x86/kernel/tsc.c#1438
fn determine_cpu_tsc_frequency(early: bool) -> Result<(), SystemError> { fn determine_cpu_tsc_frequency(early: bool) -> Result<(), SystemError> {
if unlikely(Self::cpu_khz() != 0 || Self::tsc_khz() != 0) { if unlikely(Self::cpu_khz() != 0 || Self::tsc_khz() != 0) {
kwarn!("TSC and CPU frequency already determined"); warn!("TSC and CPU frequency already determined");
} }
if early { if early {
@ -79,16 +79,16 @@ impl TSCManager {
} }
if Self::cpu_khz() == 0 { if Self::cpu_khz() == 0 {
kerror!("Failed to determine CPU frequency"); error!("Failed to determine CPU frequency");
return Err(SystemError::ENODEV); return Err(SystemError::ENODEV);
} }
kinfo!( info!(
"Detected {}.{} MHz processor", "Detected {}.{} MHz processor",
Self::cpu_khz() / 1000, Self::cpu_khz() / 1000,
Self::cpu_khz() % 1000 Self::cpu_khz() % 1000
); );
kinfo!( info!(
"Detected {}.{} MHz TSC", "Detected {}.{} MHz TSC",
Self::tsc_khz() / 1000, Self::tsc_khz() / 1000,
Self::tsc_khz() % 1000 Self::tsc_khz() % 1000
@ -102,7 +102,7 @@ impl TSCManager {
/// 使用pit、hpet、ptimer来测量CPU总线的频率 /// 使用pit、hpet、ptimer来测量CPU总线的频率
fn calibrate_cpu_by_pit_hpet_ptimer() -> Result<u64, SystemError> { fn calibrate_cpu_by_pit_hpet_ptimer() -> Result<u64, SystemError> {
let hpet = is_hpet_enabled(); let hpet = is_hpet_enabled();
kdebug!( debug!(
"Calibrating TSC with {}", "Calibrating TSC with {}",
if hpet { "HPET" } else { "PMTIMER" } if hpet { "HPET" } else { "PMTIMER" }
); );
@ -143,7 +143,7 @@ impl TSCManager {
// HPET或者PTIMER可能是不可用的 // HPET或者PTIMER可能是不可用的
if ref1 == ref2 { if ref1 == ref2 {
kdebug!("HPET/PMTIMER not available"); debug!("HPET/PMTIMER not available");
continue; continue;
} }
@ -169,7 +169,7 @@ impl TSCManager {
// 如果误差在10%以内，那么认为测量成功 // 如果误差在10%以内，那么认为测量成功
// 返回参考值，因为它是更精确的 // 返回参考值，因为它是更精确的
if (90..=110).contains(&delta) { if (90..=110).contains(&delta) {
kinfo!( info!(
"PIT calibration matches {}. {} loops", "PIT calibration matches {}. {} loops",
if hpet { "HPET" } else { "PMTIMER" }, if hpet { "HPET" } else { "PMTIMER" },
i + 1 i + 1
@ -185,20 +185,20 @@ impl TSCManager {
} }
if tsc_pit_min == u64::MAX { if tsc_pit_min == u64::MAX {
kwarn!("Unable to calibrate against PIT"); warn!("Unable to calibrate against PIT");
// 如果没有参考值，那么禁用tsc // 如果没有参考值，那么禁用tsc
if (!hpet) && (global_ref1 == 0) && (global_ref2 == 0) { if (!hpet) && (global_ref1 == 0) && (global_ref2 == 0) {
kwarn!("No reference (HPET/PMTIMER) available"); warn!("No reference (HPET/PMTIMER) available");
return Err(SystemError::ENODEV); return Err(SystemError::ENODEV);
} }
if tsc_ref_min == u64::MAX { if tsc_ref_min == u64::MAX {
kwarn!("Unable to calibrate against HPET/PMTIMER"); warn!("Unable to calibrate against HPET/PMTIMER");
return Err(SystemError::ENODEV); return Err(SystemError::ENODEV);
} }
kinfo!( info!(
"Using {} reference calibration", "Using {} reference calibration",
if hpet { "HPET" } else { "PMTIMER" } if hpet { "HPET" } else { "PMTIMER" }
); );
@ -207,27 +207,27 @@ impl TSCManager {
// We don't have an alternative source, use the PIT calibration value // We don't have an alternative source, use the PIT calibration value
if (!hpet) && (global_ref1 == 0) && (global_ref2 == 0) { if (!hpet) && (global_ref1 == 0) && (global_ref2 == 0) {
kinfo!("Using PIT calibration value"); info!("Using PIT calibration value");
return Ok(tsc_pit_min); return Ok(tsc_pit_min);
} }
// The alternative source failed, use the PIT calibration value // The alternative source failed, use the PIT calibration value
if tsc_ref_min == u64::MAX { if tsc_ref_min == u64::MAX {
kwarn!("Unable to calibrate against HPET/PMTIMER, using PIT calibration value"); warn!("Unable to calibrate against HPET/PMTIMER, using PIT calibration value");
return Ok(tsc_pit_min); return Ok(tsc_pit_min);
} }
// The calibration values differ too much. In doubt, we use // The calibration values differ too much. In doubt, we use
// the PIT value as we know that there are PMTIMERs around // the PIT value as we know that there are PMTIMERs around
// running at double speed. At least we let the user know: // running at double speed. At least we let the user know:
kwarn!( warn!(
"PIT calibration deviates from {}: tsc_pit_min={}, tsc_ref_min={}", "PIT calibration deviates from {}: tsc_pit_min={}, tsc_ref_min={}",
if hpet { "HPET" } else { "PMTIMER" }, if hpet { "HPET" } else { "PMTIMER" },
tsc_pit_min, tsc_pit_min,
tsc_ref_min tsc_ref_min
); );
kinfo!("Using PIT calibration value"); info!("Using PIT calibration value");
return Ok(tsc_pit_min); return Ok(tsc_pit_min);
} }
@ -326,7 +326,7 @@ impl TSCManager {
} }
} }
kwarn!("TSCManager: Failed to read reference value, tsc delta too high"); warn!("TSCManager: Failed to read reference value, tsc delta too high");
return (u64::MAX, ref_ret); return (u64::MAX, ref_ret);
} }

11
kernel/src/arch/x86_64/init/mod.rs
View File

@ -1,5 +1,6 @@
use core::sync::atomic::{compiler_fence, Ordering}; use core::sync::atomic::{compiler_fence, Ordering};
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use x86::dtables::DescriptorTablePointer; use x86::dtables::DescriptorTablePointer;
@ -7,7 +8,6 @@ use crate::{
arch::{interrupt::trap::arch_trap_init, process::table::TSSManager}, arch::{interrupt::trap::arch_trap_init, process::table::TSSManager},
driver::clocksource::acpi_pm::init_acpi_pm_clocksource, driver::clocksource::acpi_pm::init_acpi_pm_clocksource,
init::init::start_kernel, init::init::start_kernel,
kdebug,
mm::{MemoryManagementArch, PhysAddr}, mm::{MemoryManagementArch, PhysAddr},
}; };
@ -68,14 +68,14 @@ unsafe extern "C" fn kernel_main(
#[inline(never)] #[inline(never)]
pub fn early_setup_arch() -> Result<(), SystemError> { pub fn early_setup_arch() -> Result<(), SystemError> {
let stack_start = unsafe { *(head_stack_start as *const u64) } as usize; let stack_start = unsafe { *(head_stack_start as *const u64) } as usize;
kdebug!("head_stack_start={:#x}\n", stack_start); debug!("head_stack_start={:#x}\n", stack_start);
unsafe { unsafe {
let gdt_vaddr = let gdt_vaddr =
MMArch::phys_2_virt(PhysAddr::new(&GDT_Table as *const usize as usize)).unwrap(); MMArch::phys_2_virt(PhysAddr::new(&GDT_Table as *const usize as usize)).unwrap();
let idt_vaddr = let idt_vaddr =
MMArch::phys_2_virt(PhysAddr::new(&IDT_Table as *const usize as usize)).unwrap(); MMArch::phys_2_virt(PhysAddr::new(&IDT_Table as *const usize as usize)).unwrap();
kdebug!("GDT_Table={:?}, IDT_Table={:?}\n", gdt_vaddr, idt_vaddr); debug!("GDT_Table={:?}, IDT_Table={:?}\n", gdt_vaddr, idt_vaddr);
} }
set_current_core_tss(stack_start, 0); set_current_core_tss(stack_start, 0);
@ -107,10 +107,9 @@ pub fn setup_arch_post() -> Result<(), SystemError> {
fn set_current_core_tss(stack_start: usize, ist0: usize) { fn set_current_core_tss(stack_start: usize, ist0: usize) {
let current_tss = unsafe { TSSManager::current_tss() }; let current_tss = unsafe { TSSManager::current_tss() };
kdebug!( debug!(
"set_current_core_tss: stack_start={:#x}, ist0={:#x}\n", "set_current_core_tss: stack_start={:#x}, ist0={:#x}\n",
stack_start, stack_start, ist0
ist0
); );
current_tss.set_rsp(x86::Ring::Ring0, stack_start as u64); current_tss.set_rsp(x86::Ring::Ring0, stack_start as u64);
current_tss.set_ist(0, ist0 as u64); current_tss.set_ist(0, ist0 as u64);

10
kernel/src/arch/x86_64/interrupt/ipi.rs
View File

@ -1,4 +1,5 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use x86::apic::ApicId; use x86::apic::ApicId;
@ -13,7 +14,6 @@ use crate::{
irqdesc::{irq_desc_manager, IrqDesc, IrqFlowHandler, IrqHandler}, irqdesc::{irq_desc_manager, IrqDesc, IrqFlowHandler, IrqHandler},
HardwareIrqNumber, IrqNumber, HardwareIrqNumber, IrqNumber,
}, },
kerror,
smp::cpu::ProcessorId, smp::cpu::ProcessorId,
}; };
@ -122,14 +122,14 @@ impl From<ArchIpiTarget> for x86::apic::DestinationShorthand {
#[inline(always)] #[inline(always)]
pub fn send_ipi(kind: IpiKind, target: IpiTarget) { pub fn send_ipi(kind: IpiKind, target: IpiTarget) {
// kdebug!("send_ipi: {:?} {:?}", kind, target); // debug!("send_ipi: {:?} {:?}", kind, target);
let ipi_vec = ArchIpiKind::from(kind).into(); let ipi_vec = ArchIpiKind::from(kind).into();
let target = ArchIpiTarget::from(target); let target = ArchIpiTarget::from(target);
let shorthand: x86::apic::DestinationShorthand = target.into(); let shorthand: x86::apic::DestinationShorthand = target.into();
let destination: x86::apic::ApicId = target.into(); let destination: x86::apic::ApicId = target.into();
let icr = if CurrentApic.x2apic_enabled() { let icr = if CurrentApic.x2apic_enabled() {
// kdebug!("send_ipi: x2apic"); // debug!("send_ipi: x2apic");
x86::apic::Icr::for_x2apic( x86::apic::Icr::for_x2apic(
ipi_vec, ipi_vec,
destination, destination,
@ -141,7 +141,7 @@ pub fn send_ipi(kind: IpiKind, target: IpiTarget) {
x86::apic::TriggerMode::Edge, x86::apic::TriggerMode::Edge,
) )
} else { } else {
// kdebug!("send_ipi: xapic"); // debug!("send_ipi: xapic");
x86::apic::Icr::for_xapic( x86::apic::Icr::for_xapic(
ipi_vec, ipi_vec,
destination, destination,
@ -257,7 +257,7 @@ impl IrqFlowHandler for X86_64IpiIrqFlowHandler {
CurrentApic.send_eoi(); CurrentApic.send_eoi();
} }
_ => { _ => {
kerror!("Unknown IPI: {}", irq.data()); error!("Unknown IPI: {}", irq.data());
CurrentApic.send_eoi(); CurrentApic.send_eoi();
} }
} }

4
kernel/src/arch/x86_64/interrupt/mod.rs
View File

@ -9,12 +9,12 @@ use core::{
sync::atomic::{compiler_fence, Ordering}, sync::atomic::{compiler_fence, Ordering},
}; };
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
arch::CurrentIrqArch, arch::CurrentIrqArch,
exception::{InterruptArch, IrqFlags, IrqFlagsGuard, IrqNumber}, exception::{InterruptArch, IrqFlags, IrqFlagsGuard, IrqNumber},
kerror,
}; };
use super::{ use super::{
@ -85,7 +85,7 @@ impl InterruptArch for X86_64InterruptArch {
} }
fn ack_bad_irq(irq: IrqNumber) { fn ack_bad_irq(irq: IrqNumber) {
kerror!("Unexpected IRQ trap at vector {}", irq.data()); error!("Unexpected IRQ trap at vector {}", irq.data());
CurrentApic.send_eoi(); CurrentApic.send_eoi();
} }

46
kernel/src/arch/x86_64/interrupt/trap.rs
View File

@ -1,9 +1,9 @@
use log::{error, warn};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
arch::{CurrentIrqArch, MMArch}, arch::{CurrentIrqArch, MMArch},
exception::InterruptArch, exception::InterruptArch,
kerror, kwarn,
mm::VirtAddr, mm::VirtAddr,
process::ProcessManager, process::ProcessManager,
smp::core::smp_get_processor_id, smp::core::smp_get_processor_id,
@ -112,7 +112,7 @@ pub fn arch_trap_init() -> Result<(), SystemError> {
/// 处理除法错误 0 #DE /// 处理除法错误 0 #DE
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_divide_error(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_divide_error(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_divide_error(0), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_divide_error(0), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -126,7 +126,7 @@ unsafe extern "C" fn do_divide_error(regs: &'static TrapFrame, error_code: u64)
/// 处理调试异常 1 #DB /// 处理调试异常 1 #DB
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_debug(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_debug(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_debug(1), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_debug(1), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -140,7 +140,7 @@ unsafe extern "C" fn do_debug(regs: &'static TrapFrame, error_code: u64) {
/// 处理NMI中断 2 NMI /// 处理NMI中断 2 NMI
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_nmi(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_nmi(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_nmi(2), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_nmi(2), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -154,7 +154,7 @@ unsafe extern "C" fn do_nmi(regs: &'static TrapFrame, error_code: u64) {
/// 处理断点异常 3 #BP /// 处理断点异常 3 #BP
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_int3(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_int3(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_int3(3), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_int3(3), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -168,7 +168,7 @@ unsafe extern "C" fn do_int3(regs: &'static TrapFrame, error_code: u64) {
/// 处理溢出异常 4 #OF /// 处理溢出异常 4 #OF
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_overflow(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_overflow(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_overflow(4), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_overflow(4), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -182,7 +182,7 @@ unsafe extern "C" fn do_overflow(regs: &'static TrapFrame, error_code: u64) {
/// 处理BOUND指令检查异常 5 #BR /// 处理BOUND指令检查异常 5 #BR
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_bounds(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_bounds(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_bounds(5), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_bounds(5), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -196,7 +196,7 @@ unsafe extern "C" fn do_bounds(regs: &'static TrapFrame, error_code: u64) {
/// 处理未定义操作码异常 6 #UD /// 处理未定义操作码异常 6 #UD
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_undefined_opcode(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_undefined_opcode(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_undefined_opcode(6), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_undefined_opcode(6), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -210,7 +210,7 @@ unsafe extern "C" fn do_undefined_opcode(regs: &'static TrapFrame, error_code: u
/// 处理设备不可用异常(FPU不存在) 7 #NM /// 处理设备不可用异常(FPU不存在) 7 #NM
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_dev_not_avaliable(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_dev_not_avaliable(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_dev_not_avaliable(7), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_dev_not_avaliable(7), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -224,7 +224,7 @@ unsafe extern "C" fn do_dev_not_avaliable(regs: &'static TrapFrame, error_code:
/// 处理双重错误 8 #DF /// 处理双重错误 8 #DF
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_double_fault(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_double_fault(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_double_fault(8), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_double_fault(8), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -238,7 +238,7 @@ unsafe extern "C" fn do_double_fault(regs: &'static TrapFrame, error_code: u64)
/// 处理协处理器段越界 9 #MF /// 处理协处理器段越界 9 #MF
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_coprocessor_segment_overrun(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_coprocessor_segment_overrun(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_coprocessor_segment_overrun(9), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_coprocessor_segment_overrun(9), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -272,7 +272,7 @@ unsafe extern "C" fn do_invalid_TSS(regs: &'static TrapFrame, error_code: u64) {
ERR_MSG_4 ERR_MSG_4
}; };
kerror!( error!(
"do_invalid_TSS(10), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}\n{}{}", "do_invalid_TSS(10), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}\n{}{}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -288,7 +288,7 @@ unsafe extern "C" fn do_invalid_TSS(regs: &'static TrapFrame, error_code: u64) {
/// 处理段不存在 11 #NP /// 处理段不存在 11 #NP
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_segment_not_exists(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_segment_not_exists(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_segment_not_exists(11), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_segment_not_exists(11), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -302,7 +302,7 @@ unsafe extern "C" fn do_segment_not_exists(regs: &'static TrapFrame, error_code:
/// 处理栈段错误 12 #SS /// 处理栈段错误 12 #SS
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_stack_segment_fault(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_stack_segment_fault(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_stack_segment_fault(12), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_stack_segment_fault(12), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -343,7 +343,7 @@ unsafe extern "C" fn do_general_protection(regs: &'static TrapFrame, error_code:
} else { } else {
"" ""
}; };
kerror!( error!(
"do_general_protection(13), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t rflags: {:#x}\t CPU: {}, \tpid: {:?} "do_general_protection(13), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t rflags: {:#x}\t CPU: {}, \tpid: {:?}
{}{}{} {}{}{}
Segment Selector Index: {:#x}\n Segment Selector Index: {:#x}\n
@ -363,7 +363,7 @@ Segment Selector Index: {:#x}\n
/// 处理页错误 14 #PF /// 处理页错误 14 #PF
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_page_fault(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_page_fault(regs: &'static TrapFrame, error_code: u64) {
// kerror!( // error!(
// "do_page_fault(14), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}, \nFault Address: {:#x}", // "do_page_fault(14), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}, \nFault Address: {:#x}",
// error_code, // error_code,
// regs.rsp, // regs.rsp,
@ -401,7 +401,7 @@ unsafe extern "C" fn do_page_fault(regs: &'static TrapFrame, error_code: u64) {
// panic!("Page Fault"); // panic!("Page Fault");
CurrentIrqArch::interrupt_disable(); CurrentIrqArch::interrupt_disable();
let address = x86::controlregs::cr2(); let address = x86::controlregs::cr2();
// crate::kinfo!( // crate::info!(
// "fault address: {:#x}, error_code: {:#b}, pid: {}\n", // "fault address: {:#x}, error_code: {:#b}, pid: {}\n",
// address, // address,
// error_code, // error_code,
@ -421,7 +421,7 @@ unsafe extern "C" fn do_page_fault(regs: &'static TrapFrame, error_code: u64) {
/// 处理x87 FPU错误 16 #MF /// 处理x87 FPU错误 16 #MF
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_x87_FPU_error(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_x87_FPU_error(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_x87_FPU_error(16), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_x87_FPU_error(16), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -435,7 +435,7 @@ unsafe extern "C" fn do_x87_FPU_error(regs: &'static TrapFrame, error_code: u64)
/// 处理对齐检查 17 #AC /// 处理对齐检查 17 #AC
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_alignment_check(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_alignment_check(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_alignment_check(17), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_alignment_check(17), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -449,7 +449,7 @@ unsafe extern "C" fn do_alignment_check(regs: &'static TrapFrame, error_code: u6
/// 处理机器检查 18 #MC /// 处理机器检查 18 #MC
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_machine_check(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_machine_check(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_machine_check(18), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_machine_check(18), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -463,7 +463,7 @@ unsafe extern "C" fn do_machine_check(regs: &'static TrapFrame, error_code: u64)
/// 处理SIMD异常 19 #XM /// 处理SIMD异常 19 #XM
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_SIMD_exception(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_SIMD_exception(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_SIMD_exception(19), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_SIMD_exception(19), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -477,7 +477,7 @@ unsafe extern "C" fn do_SIMD_exception(regs: &'static TrapFrame, error_code: u64
/// 处理虚拟化异常 20 #VE /// 处理虚拟化异常 20 #VE
#[no_mangle] #[no_mangle]
unsafe extern "C" fn do_virtualization_exception(regs: &'static TrapFrame, error_code: u64) { unsafe extern "C" fn do_virtualization_exception(regs: &'static TrapFrame, error_code: u64) {
kerror!( error!(
"do_virtualization_exception(20), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}", "do_virtualization_exception(20), \tError code: {:#x},\trsp: {:#x},\trip: {:#x},\t CPU: {}, \tpid: {:?}",
error_code, error_code,
regs.rsp, regs.rsp,
@ -490,5 +490,5 @@ unsafe extern "C" fn do_virtualization_exception(regs: &'static TrapFrame, error
#[no_mangle] #[no_mangle]
unsafe extern "C" fn ignore_int_handler(_regs: &'static TrapFrame, _error_code: u64) { unsafe extern "C" fn ignore_int_handler(_regs: &'static TrapFrame, _error_code: u64) {
kwarn!("Unknown interrupt."); warn!("Unknown interrupt.");
} }

40
kernel/src/arch/x86_64/ipc/signal.rs
View File

@ -1,5 +1,6 @@
use core::{ffi::c_void, intrinsics::unlikely, mem::size_of}; use core::{ffi::c_void, intrinsics::unlikely, mem::size_of};
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -14,7 +15,6 @@ use crate::{
signal::set_current_sig_blocked, signal::set_current_sig_blocked,
signal_types::{SaHandlerType, SigInfo, Sigaction, SigactionType, SignalArch}, signal_types::{SaHandlerType, SigInfo, Sigaction, SigactionType, SignalArch},
}, },
kerror,
mm::MemoryManagementArch, mm::MemoryManagementArch,
process::ProcessManager, process::ProcessManager,
sched::{schedule, SchedMode}, sched::{schedule, SchedMode},
@ -86,7 +86,7 @@ impl From<usize> for Signal {
let ret: Signal = unsafe { core::mem::transmute(value) }; let ret: Signal = unsafe { core::mem::transmute(value) };
return ret; return ret;
} else { } else {
kerror!("Try to convert an invalid number to Signal"); error!("Try to convert an invalid number to Signal");
return Signal::INVALID; return Signal::INVALID;
} }
} }
@ -101,7 +101,7 @@ impl From<Signal> for usize {
impl From<i32> for Signal { impl From<i32> for Signal {
fn from(value: i32) -> Self { fn from(value: i32) -> Self {
if value < 0 { if value < 0 {
kerror!("Try to convert an invalid number to Signal"); error!("Try to convert an invalid number to Signal");
return Signal::INVALID; return Signal::INVALID;
} else { } else {
return Self::from(value as usize); return Self::from(value as usize);
@ -145,7 +145,7 @@ impl Signal {
pub fn handle_default(&self) { pub fn handle_default(&self) {
match self { match self {
Signal::INVALID => { Signal::INVALID => {
kerror!("attempting to handler an Invalid"); error!("attempting to handler an Invalid");
} }
Signal::SIGHUP => sig_terminate(*self), Signal::SIGHUP => sig_terminate(*self),
Signal::SIGINT => sig_terminate(*self), Signal::SIGINT => sig_terminate(*self),
@ -461,7 +461,7 @@ impl SignalArch for X86_64SignalArch {
match sigaction.action() { match sigaction.action() {
SigactionType::SaHandler(action_type) => match action_type { SigactionType::SaHandler(action_type) => match action_type {
SaHandlerType::Error => { SaHandlerType::Error => {
kerror!("Trying to handle a Sigerror on Process:{:?}", pcb.pid()); error!("Trying to handle a Sigerror on Process:{:?}", pcb.pid());
return; return;
} }
SaHandlerType::Default => { SaHandlerType::Default => {
@ -488,7 +488,7 @@ impl SignalArch for X86_64SignalArch {
let res: Result<i32, SystemError> = let res: Result<i32, SystemError> =
handle_signal(sig_number, &mut sigaction, &info.unwrap(), &oldset, frame); handle_signal(sig_number, &mut sigaction, &info.unwrap(), &oldset, frame);
if res.is_err() { if res.is_err() {
kerror!( error!(
"Error occurred when handling signal: {}, pid={:?}, errcode={:?}", "Error occurred when handling signal: {}, pid={:?}, errcode={:?}",
sig_number as i32, sig_number as i32,
ProcessManager::current_pcb().pid(), ProcessManager::current_pcb().pid(),
@ -502,7 +502,7 @@ impl SignalArch for X86_64SignalArch {
// 如果当前的rsp不来自用户态，则认为产生了错误（或被SROP攻击） // 如果当前的rsp不来自用户态，则认为产生了错误（或被SROP攻击）
if UserBufferWriter::new(frame, size_of::<SigFrame>(), true).is_err() { if UserBufferWriter::new(frame, size_of::<SigFrame>(), true).is_err() {
kerror!("rsp doesn't from user level"); error!("rsp doesn't from user level");
let _r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32) let _r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32)
.map_err(|e| e.to_posix_errno()); .map_err(|e| e.to_posix_errno());
return trap_frame.rax; return trap_frame.rax;
@ -511,7 +511,7 @@ impl SignalArch for X86_64SignalArch {
set_current_sig_blocked(&mut sigmask); set_current_sig_blocked(&mut sigmask);
// 从用户栈恢复sigcontext // 从用户栈恢复sigcontext
if !unsafe { &mut (*frame).context }.restore_sigcontext(trap_frame) { if !unsafe { &mut (*frame).context }.restore_sigcontext(trap_frame) {
kerror!("unable to restore sigcontext"); error!("unable to restore sigcontext");
let _r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32) let _r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32)
.map_err(|e| e.to_posix_errno()); .map_err(|e| e.to_posix_errno());
// 如果这里返回 err 值的话会丢失上一个系统调用的返回值 // 如果这里返回 err 值的话会丢失上一个系统调用的返回值
@ -569,7 +569,7 @@ fn setup_frame(
sig.handle_default(); sig.handle_default();
return Ok(0); return Ok(0);
} else { } else {
kerror!("attempting to execute a signal handler from kernel"); error!("attempting to execute a signal handler from kernel");
sig.handle_default(); sig.handle_default();
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
@ -578,7 +578,7 @@ fn setup_frame(
if sigaction.flags().contains(SigFlags::SA_RESTORER) { if sigaction.flags().contains(SigFlags::SA_RESTORER) {
ret_code_ptr = sigaction.restorer().unwrap().data() as *mut c_void; ret_code_ptr = sigaction.restorer().unwrap().data() as *mut c_void;
} else { } else {
kerror!( error!(
"pid-{:?} forgot to set SA_FLAG_RESTORER for signal {:?}", "pid-{:?} forgot to set SA_FLAG_RESTORER for signal {:?}",
ProcessManager::current_pcb().pid(), ProcessManager::current_pcb().pid(),
sig as i32 sig as i32
@ -588,12 +588,12 @@ fn setup_frame(
Signal::SIGSEGV as i32, Signal::SIGSEGV as i32,
); );
if r.is_err() { if r.is_err() {
kerror!("In setup_sigcontext: generate SIGSEGV signal failed"); error!("In setup_sigcontext: generate SIGSEGV signal failed");
} }
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
if sigaction.restorer().is_none() { if sigaction.restorer().is_none() {
kerror!( error!(
"restorer in process:{:?} is not defined", "restorer in process:{:?} is not defined",
ProcessManager::current_pcb().pid() ProcessManager::current_pcb().pid()
); );
@ -611,12 +611,12 @@ fn setup_frame(
}, },
SigactionType::SaSigaction(_) => { SigactionType::SaSigaction(_) => {
//TODO 这里应该是可以恢复栈的，等后续来做 //TODO 这里应该是可以恢复栈的，等后续来做
kerror!("trying to recover from sigaction type instead of handler"); error!("trying to recover from sigaction type instead of handler");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
} }
let frame: *mut SigFrame = get_stack(trap_frame, size_of::<SigFrame>()); let frame: *mut SigFrame = get_stack(trap_frame, size_of::<SigFrame>());
// kdebug!("frame=0x{:016x}", frame as usize); // debug!("frame=0x{:016x}", frame as usize);
// 要求这个frame的地址位于用户空间，因此进行校验 // 要求这个frame的地址位于用户空间，因此进行校验
let r: Result<UserBufferWriter<'_>, SystemError> = let r: Result<UserBufferWriter<'_>, SystemError> =
UserBufferWriter::new(frame, size_of::<SigFrame>(), true); UserBufferWriter::new(frame, size_of::<SigFrame>(), true);
@ -625,9 +625,9 @@ fn setup_frame(
// todo: 生成一个sigsegv // todo: 生成一个sigsegv
let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32); let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32);
if r.is_err() { if r.is_err() {
kerror!("In setup frame: generate SIGSEGV signal failed"); error!("In setup frame: generate SIGSEGV signal failed");
} }
kerror!("In setup frame: access check failed"); error!("In setup frame: access check failed");
return Err(SystemError::EFAULT); return Err(SystemError::EFAULT);
} }
@ -636,7 +636,7 @@ fn setup_frame(
.map_err(|e| -> SystemError { .map_err(|e| -> SystemError {
let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32); let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32);
if r.is_err() { if r.is_err() {
kerror!("In copy_siginfo_to_user: generate SIGSEGV signal failed"); error!("In copy_siginfo_to_user: generate SIGSEGV signal failed");
} }
return e; return e;
})?; })?;
@ -650,7 +650,7 @@ fn setup_frame(
.map_err(|e: SystemError| -> SystemError { .map_err(|e: SystemError| -> SystemError {
let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32); let r = Syscall::kill(ProcessManager::current_pcb().pid(), Signal::SIGSEGV as i32);
if r.is_err() { if r.is_err() {
kerror!("In setup_sigcontext: generate SIGSEGV signal failed"); error!("In setup_sigcontext: generate SIGSEGV signal failed");
} }
return e; return e;
})? })?
@ -707,7 +707,7 @@ fn sig_terminate_dump(sig: Signal) {
fn sig_stop(sig: Signal) { fn sig_stop(sig: Signal) {
let guard = unsafe { CurrentIrqArch::save_and_disable_irq() }; let guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
ProcessManager::mark_stop().unwrap_or_else(|e| { ProcessManager::mark_stop().unwrap_or_else(|e| {
kerror!( error!(
"sleep error :{:?},failed to sleep process :{:?}, with signal :{:?}", "sleep error :{:?},failed to sleep process :{:?}, with signal :{:?}",
e, e,
ProcessManager::current_pcb(), ProcessManager::current_pcb(),
@ -721,7 +721,7 @@ fn sig_stop(sig: Signal) {
/// 信号默认处理函数——继续进程 /// 信号默认处理函数——继续进程
fn sig_continue(sig: Signal) { fn sig_continue(sig: Signal) {
ProcessManager::wakeup_stop(&ProcessManager::current_pcb()).unwrap_or_else(|_| { ProcessManager::wakeup_stop(&ProcessManager::current_pcb()).unwrap_or_else(|_| {
kerror!( error!(
"Failed to wake up process pid = {:?} with signal :{:?}", "Failed to wake up process pid = {:?} with signal :{:?}",
ProcessManager::current_pcb().pid(), ProcessManager::current_pcb().pid(),
sig sig

15
kernel/src/arch/x86_64/kvm/mod.rs
View File

@ -2,13 +2,10 @@ use crate::arch::kvm::vmx::vmcs::VmcsFields;
use crate::arch::kvm::vmx::vmx_asm_wrapper::{vmx_vmlaunch, vmx_vmread}; use crate::arch::kvm::vmx::vmx_asm_wrapper::{vmx_vmlaunch, vmx_vmread};
use crate::libs::mutex::Mutex; use crate::libs::mutex::Mutex;
use crate::virt::kvm::vm; use crate::virt::kvm::vm;
use crate::{
kdebug,
kerror,
// libs::spinlock::{SpinLock, SpinLockGuard},
};
use alloc::sync::Arc; use alloc::sync::Arc;
use core::arch::asm; use core::arch::asm;
use log::{debug, error};
use raw_cpuid::CpuId; use raw_cpuid::CpuId;
use system_error::SystemError; use system_error::SystemError;
// use crate::virt::kvm::guest_code; // use crate::virt::kvm::guest_code;
@ -54,7 +51,7 @@ impl X86_64KVMArch {
#[deny(clippy::match_single_binding)] #[deny(clippy::match_single_binding)]
pub fn kvm_arch_dev_ioctl(cmd: u32, _arg: usize) -> Result<usize, SystemError> { pub fn kvm_arch_dev_ioctl(cmd: u32, _arg: usize) -> Result<usize, SystemError> {
kerror!("unknown kvm ioctl cmd: {}", cmd); error!("unknown kvm ioctl cmd: {}", cmd);
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
@ -74,7 +71,7 @@ impl X86_64KVMArch {
Ok(_) => {} Ok(_) => {}
Err(e) => { Err(e) => {
let vmx_err = vmx_vmread(VmcsFields::VMEXIT_INSTR_ERR as u32).unwrap(); let vmx_err = vmx_vmread(VmcsFields::VMEXIT_INSTR_ERR as u32).unwrap();
kdebug!("vmlaunch failed: {:?}", vmx_err); debug!("vmlaunch failed: {:?}", vmx_err);
return Err(e); return Err(e);
} }
} }
@ -103,12 +100,12 @@ impl X86_64KVMArch {
#[no_mangle] #[no_mangle]
pub extern "C" fn guest_code() { pub extern "C" fn guest_code() {
kdebug!("guest_code"); debug!("guest_code");
loop { loop {
unsafe { unsafe {
asm!("mov rax, 0", "mov rcx, 0", "cpuid"); asm!("mov rax, 0", "mov rcx, 0", "cpuid");
} }
unsafe { asm!("nop") }; unsafe { asm!("nop") };
kdebug!("guest_code"); debug!("guest_code");
} }
} }

6
kernel/src/arch/x86_64/kvm/vmx/mmu.rs
View File

@ -1,11 +1,11 @@
use crate::{ use crate::{
arch::kvm::vmx::ept::EptMapper, arch::kvm::vmx::ept::EptMapper,
kdebug,
libs::mutex::Mutex, libs::mutex::Mutex,
mm::{page::PageFlags, syscall::ProtFlags}, mm::{page::PageFlags, syscall::ProtFlags},
virt::kvm::host_mem::{__gfn_to_pfn, kvm_vcpu_gfn_to_memslot, PAGE_MASK, PAGE_SHIFT}, virt::kvm::host_mem::{__gfn_to_pfn, kvm_vcpu_gfn_to_memslot, PAGE_MASK, PAGE_SHIFT},
}; };
use bitfield_struct::bitfield; use bitfield_struct::bitfield;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use super::{ use super::{
@ -105,7 +105,7 @@ fn tdp_page_fault(
error_code: u32, error_code: u32,
prefault: bool, prefault: bool,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
kdebug!("tdp_page_fault"); debug!("tdp_page_fault");
let gfn = gpa >> PAGE_SHIFT; // 物理地址右移12位得到物理页框号(相对于虚拟机而言) let gfn = gpa >> PAGE_SHIFT; // 物理地址右移12位得到物理页框号(相对于虚拟机而言)
// 分配缓存池，为了避免在运行时分配空间失败，这里提前分配/填充足额的空间 // 分配缓存池，为了避免在运行时分配空间失败，这里提前分配/填充足额的空间
mmu_topup_memory_caches(vcpu)?; mmu_topup_memory_caches(vcpu)?;
@ -211,7 +211,7 @@ pub fn __direct_map(
pfn: u64, pfn: u64,
_prefault: bool, _prefault: bool,
) -> Result<u32, SystemError> { ) -> Result<u32, SystemError> {
kdebug!("gpa={}, pfn={}, root_hpa={:x}", gpa, pfn, vcpu.mmu.root_hpa); debug!("gpa={}, pfn={}, root_hpa={:x}", gpa, pfn, vcpu.mmu.root_hpa);
// 判断vcpu.mmu.root_hpa是否有效 // 判断vcpu.mmu.root_hpa是否有效
if vcpu.mmu.root_hpa == 0 { if vcpu.mmu.root_hpa == 0 {
return Err(SystemError::KVM_HVA_ERR_BAD); return Err(SystemError::KVM_HVA_ERR_BAD);

51
kernel/src/arch/x86_64/kvm/vmx/vcpu.rs
View File

@ -9,7 +9,7 @@ use crate::arch::kvm::vmx::{VcpuRegIndex, X86_CR0};
use crate::arch::mm::{LockedFrameAllocator, PageMapper}; use crate::arch::mm::{LockedFrameAllocator, PageMapper};
use crate::arch::x86_64::mm::X86_64MMArch; use crate::arch::x86_64::mm::X86_64MMArch;
use crate::arch::MMArch; use crate::arch::MMArch;
use crate::kdebug;
use crate::mm::{phys_2_virt, VirtAddr}; use crate::mm::{phys_2_virt, VirtAddr};
use crate::mm::{MemoryManagementArch, PageTableKind}; use crate::mm::{MemoryManagementArch, PageTableKind};
use crate::virt::kvm::vcpu::Vcpu; use crate::virt::kvm::vcpu::Vcpu;
@ -17,6 +17,7 @@ use crate::virt::kvm::vm::Vm;
use alloc::alloc::Global; use alloc::alloc::Global;
use alloc::boxed::Box; use alloc::boxed::Box;
use core::slice; use core::slice;
use log::debug;
use raw_cpuid::CpuId; use raw_cpuid::CpuId;
use system_error::SystemError; use system_error::SystemError;
use x86; use x86;
@ -132,13 +133,13 @@ impl VcpuData {
// Get the Virtual Machine Control Structure revision identifier (VMCS revision ID) // Get the Virtual Machine Control Structure revision identifier (VMCS revision ID)
// (Intel Manual: 25.11.5 VMXON Region) // (Intel Manual: 25.11.5 VMXON Region)
let revision_id = unsafe { (msr::rdmsr(msr::IA32_VMX_BASIC) as u32) & 0x7FFF_FFFF }; let revision_id = unsafe { (msr::rdmsr(msr::IA32_VMX_BASIC) as u32) & 0x7FFF_FFFF };
kdebug!("[+] VMXON Region Virtual Address: {:p}", self.vmxon_region); debug!("[+] VMXON Region Virtual Address: {:p}", self.vmxon_region);
kdebug!( debug!(
"[+] VMXON Region Physical Addresss: 0x{:x}", "[+] VMXON Region Physical Addresss: 0x{:x}",
self.vmxon_region_physical_address self.vmxon_region_physical_address
); );
kdebug!("[+] VMCS Region Virtual Address: {:p}", self.vmcs_region); debug!("[+] VMCS Region Virtual Address: {:p}", self.vmcs_region);
kdebug!( debug!(
"[+] VMCS Region Physical Address1: 0x{:x}", "[+] VMCS Region Physical Address1: 0x{:x}",
self.vmcs_region_physical_address self.vmcs_region_physical_address
); );
@ -150,7 +151,7 @@ impl VcpuData {
impl VmxVcpu { impl VmxVcpu {
pub fn new(vcpu_id: u32, parent_vm: Vm) -> Result<Self, SystemError> { pub fn new(vcpu_id: u32, parent_vm: Vm) -> Result<Self, SystemError> {
kdebug!("Creating processor {}", vcpu_id); debug!("Creating processor {}", vcpu_id);
let instance = Self { let instance = Self {
vcpu_id, vcpu_id,
vcpu_ctx: VcpuContextFrame { vcpu_ctx: VcpuContextFrame {
@ -251,8 +252,8 @@ impl VmxVcpu {
self.vcpu_ctx.regs[VcpuRegIndex::Rsp as usize] as u64, self.vcpu_ctx.regs[VcpuRegIndex::Rsp as usize] as u64,
)?; )?;
vmx_vmwrite(VmcsFields::GUEST_RIP as u32, self.vcpu_ctx.rip as u64)?; vmx_vmwrite(VmcsFields::GUEST_RIP as u32, self.vcpu_ctx.rip as u64)?;
kdebug!("vmcs init guest rip: {:#x}", self.vcpu_ctx.rip as u64); debug!("vmcs init guest rip: {:#x}", self.vcpu_ctx.rip as u64);
kdebug!( debug!(
"vmcs init guest rsp: {:#x}", "vmcs init guest rsp: {:#x}",
self.vcpu_ctx.regs[VcpuRegIndex::Rsp as usize] as u64 self.vcpu_ctx.regs[VcpuRegIndex::Rsp as usize] as u64
); );
@ -338,7 +339,7 @@ impl VmxVcpu {
})?; })?;
// vmx_vmwrite(VmcsFields::HOST_RIP as u32, vmx_return as *const () as u64)?; // vmx_vmwrite(VmcsFields::HOST_RIP as u32, vmx_return as *const () as u64)?;
// kdebug!("vmcs init host rip: {:#x}", vmx_return as *const () as u64); // debug!("vmcs init host rip: {:#x}", vmx_return as *const () as u64);
Ok(()) Ok(())
} }
@ -388,7 +389,7 @@ impl VmxVcpu {
} }
fn kvm_mmu_load(&mut self) -> Result<(), SystemError> { fn kvm_mmu_load(&mut self) -> Result<(), SystemError> {
kdebug!("kvm_mmu_load!"); debug!("kvm_mmu_load!");
// 申请并创建新的页表 // 申请并创建新的页表
let mapper: crate::mm::page::PageMapper<X86_64MMArch, LockedFrameAllocator> = unsafe { let mapper: crate::mm::page::PageMapper<X86_64MMArch, LockedFrameAllocator> = unsafe {
PageMapper::create(PageTableKind::EPT, LockedFrameAllocator) PageMapper::create(PageTableKind::EPT, LockedFrameAllocator)
@ -399,7 +400,7 @@ impl VmxVcpu {
let set_eptp_fn = self.mmu.set_eptp.unwrap(); let set_eptp_fn = self.mmu.set_eptp.unwrap();
set_eptp_fn(ept_root_hpa.data() as u64)?; set_eptp_fn(ept_root_hpa.data() as u64)?;
self.mmu.root_hpa = ept_root_hpa.data() as u64; self.mmu.root_hpa = ept_root_hpa.data() as u64;
kdebug!("ept_root_hpa:{:x}!", ept_root_hpa.data() as u64); debug!("ept_root_hpa:{:x}!", ept_root_hpa.data() as u64);
return Ok(()); return Ok(());
} }
@ -415,33 +416,33 @@ impl Vcpu for VmxVcpu {
fn virtualize_cpu(&mut self) -> Result<(), SystemError> { fn virtualize_cpu(&mut self) -> Result<(), SystemError> {
match has_intel_vmx_support() { match has_intel_vmx_support() {
Ok(_) => { Ok(_) => {
kdebug!("[+] CPU supports Intel VMX"); debug!("[+] CPU supports Intel VMX");
} }
Err(e) => { Err(e) => {
kdebug!("[-] CPU does not support Intel VMX: {:?}", e); debug!("[-] CPU does not support Intel VMX: {:?}", e);
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
}; };
match enable_vmx_operation() { match enable_vmx_operation() {
Ok(_) => { Ok(_) => {
kdebug!("[+] Enabling Virtual Machine Extensions (VMX)"); debug!("[+] Enabling Virtual Machine Extensions (VMX)");
} }
Err(_) => { Err(_) => {
kdebug!("[-] VMX operation is not supported on this processor."); debug!("[-] VMX operation is not supported on this processor.");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
} }
vmxon(self.data.vmxon_region_physical_address)?; vmxon(self.data.vmxon_region_physical_address)?;
kdebug!("[+] VMXON successful!"); debug!("[+] VMXON successful!");
vmx_vmclear(self.data.vmcs_region_physical_address)?; vmx_vmclear(self.data.vmcs_region_physical_address)?;
vmx_vmptrld(self.data.vmcs_region_physical_address)?; vmx_vmptrld(self.data.vmcs_region_physical_address)?;
kdebug!("[+] VMPTRLD successful!"); debug!("[+] VMPTRLD successful!");
self.vmcs_init().expect("vncs_init fail"); self.vmcs_init().expect("vncs_init fail");
kdebug!("[+] VMCS init!"); debug!("[+] VMCS init!");
// kdebug!("vmcs init host rip: {:#x}", vmx_return as *const () as u64); // debug!("vmcs init host rip: {:#x}", vmx_return as *const () as u64);
// kdebug!("vmcs init host rsp: {:#x}", x86::bits64::registers::rsp()); // debug!("vmcs init host rsp: {:#x}", x86::bits64::registers::rsp());
// vmx_vmwrite(VmcsFields::HOST_RSP as u32, x86::bits64::registers::rsp())?; // vmx_vmwrite(VmcsFields::HOST_RSP as u32, x86::bits64::registers::rsp())?;
// vmx_vmwrite(VmcsFields::HOST_RIP as u32, vmx_return as *const () as u64)?; // vmx_vmwrite(VmcsFields::HOST_RIP as u32, vmx_return as *const () as u64)?;
// vmx_vmwrite(VmcsFields::HOST_RSP as u32, x86::bits64::registers::rsp())?; // vmx_vmwrite(VmcsFields::HOST_RSP as u32, x86::bits64::registers::rsp())?;
@ -476,7 +477,7 @@ pub fn get_segment_base(gdt_base: *const u64, gdt_size: u16, segment_selector: u
let virtaddr = phys_2_virt(segment_base.try_into().unwrap()) let virtaddr = phys_2_virt(segment_base.try_into().unwrap())
.try_into() .try_into()
.unwrap(); .unwrap();
kdebug!( debug!(
"segment_base={:x}", "segment_base={:x}",
phys_2_virt(segment_base.try_into().unwrap()) phys_2_virt(segment_base.try_into().unwrap())
); );
@ -536,7 +537,7 @@ pub fn adjust_vmx_exit_controls() -> u32 {
pub fn adjust_vmx_pinbased_controls() -> u32 { pub fn adjust_vmx_pinbased_controls() -> u32 {
let mut controls: u32 = 16; let mut controls: u32 = 16;
adjust_vmx_controls(0, 0, msr::IA32_VMX_TRUE_PINBASED_CTLS, &mut controls); adjust_vmx_controls(0, 0, msr::IA32_VMX_TRUE_PINBASED_CTLS, &mut controls);
// kdebug!("adjust_vmx_pinbased_controls: {:x}", controls); // debug!("adjust_vmx_pinbased_controls: {:x}", controls);
return controls; return controls;
} }
@ -593,11 +594,11 @@ pub fn enable_vmx_operation() -> Result<(), SystemError> {
unsafe { controlregs::cr4_write(cr4) }; unsafe { controlregs::cr4_write(cr4) };
set_lock_bit()?; set_lock_bit()?;
kdebug!("[+] Lock bit set via IA32_FEATURE_CONTROL"); debug!("[+] Lock bit set via IA32_FEATURE_CONTROL");
set_cr0_bits(); set_cr0_bits();
kdebug!("[+] Mandatory bits in CR0 set/cleared"); debug!("[+] Mandatory bits in CR0 set/cleared");
set_cr4_bits(); set_cr4_bits();
kdebug!("[+] Mandatory bits in CR4 set/cleared"); debug!("[+] Mandatory bits in CR4 set/cleared");
Ok(()) Ok(())
} }

31
kernel/src/arch/x86_64/kvm/vmx/vmexit.rs
View File

@ -1,8 +1,9 @@
use super::vmcs::{VmcsFields, VmxExitReason}; use super::vmcs::{VmcsFields, VmxExitReason};
use super::vmx_asm_wrapper::{vmx_vmread, vmx_vmwrite}; use super::vmx_asm_wrapper::{vmx_vmread, vmx_vmwrite};
use crate::kdebug;
use crate::virt::kvm::vm; use crate::virt::kvm::vm;
use core::arch::asm; use core::arch::asm;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use x86::vmx::vmcs::ro::GUEST_PHYSICAL_ADDR_FULL; use x86::vmx::vmcs::ro::GUEST_PHYSICAL_ADDR_FULL;
@ -147,7 +148,7 @@ pub struct GuestCpuContext {
#[no_mangle] #[no_mangle]
pub extern "C" fn vmx_return() { pub extern "C" fn vmx_return() {
kdebug!("vmx_return!"); debug!("vmx_return!");
unsafe { save_rpg() }; unsafe { save_rpg() };
vmexit_handler(); vmexit_handler();
// XMM registers are vector registers. They're renamed onto the FP/SIMD register file // XMM registers are vector registers. They're renamed onto the FP/SIMD register file
@ -181,14 +182,14 @@ pub extern "C" fn vmx_return() {
#[no_mangle] #[no_mangle]
extern "C" fn vmexit_handler() { extern "C" fn vmexit_handler() {
// let guest_cpu_context = unsafe { guest_cpu_context_ptr.as_mut().unwrap() }; // let guest_cpu_context = unsafe { guest_cpu_context_ptr.as_mut().unwrap() };
// kdebug!("guest_cpu_context_ptr={:p}",guest_cpu_context_ptr); // debug!("guest_cpu_context_ptr={:p}",guest_cpu_context_ptr);
kdebug!("vmexit handler!"); debug!("vmexit handler!");
let exit_reason = vmx_vmread(VmcsFields::VMEXIT_EXIT_REASON as u32).unwrap() as u32; let exit_reason = vmx_vmread(VmcsFields::VMEXIT_EXIT_REASON as u32).unwrap() as u32;
let exit_basic_reason = exit_reason & 0x0000_ffff; let exit_basic_reason = exit_reason & 0x0000_ffff;
let guest_rip = vmx_vmread(VmcsFields::GUEST_RIP as u32).unwrap(); let guest_rip = vmx_vmread(VmcsFields::GUEST_RIP as u32).unwrap();
// let guest_rsp = vmx_vmread(VmcsFields::GUEST_RSP as u32).unwrap(); // let guest_rsp = vmx_vmread(VmcsFields::GUEST_RSP as u32).unwrap();
kdebug!("guest_rip={:x}", guest_rip); debug!("guest_rip={:x}", guest_rip);
let _guest_rflags = vmx_vmread(VmcsFields::GUEST_RFLAGS as u32).unwrap(); let _guest_rflags = vmx_vmread(VmcsFields::GUEST_RFLAGS as u32).unwrap();
match VmxExitReason::from(exit_basic_reason as i32) { match VmxExitReason::from(exit_basic_reason as i32) {
@ -205,28 +206,28 @@ extern "C" fn vmexit_handler() {
| VmxExitReason::VMFUNC | VmxExitReason::VMFUNC
| VmxExitReason::INVEPT | VmxExitReason::INVEPT
| VmxExitReason::INVVPID => { | VmxExitReason::INVVPID => {
kdebug!("vmexit handler: vmx instruction!"); debug!("vmexit handler: vmx instruction!");
vmexit_vmx_instruction_executed().expect("previledge instruction handle error"); vmexit_vmx_instruction_executed().expect("previledge instruction handle error");
} }
VmxExitReason::CPUID => { VmxExitReason::CPUID => {
kdebug!("vmexit handler: cpuid instruction!"); debug!("vmexit handler: cpuid instruction!");
// vmexit_cpuid_handler(guest_cpu_context); // vmexit_cpuid_handler(guest_cpu_context);
adjust_rip(guest_rip).unwrap(); adjust_rip(guest_rip).unwrap();
} }
VmxExitReason::RDMSR => { VmxExitReason::RDMSR => {
kdebug!("vmexit handler: rdmsr instruction!"); debug!("vmexit handler: rdmsr instruction!");
adjust_rip(guest_rip).unwrap(); adjust_rip(guest_rip).unwrap();
} }
VmxExitReason::WRMSR => { VmxExitReason::WRMSR => {
kdebug!("vmexit handler: wrmsr instruction!"); debug!("vmexit handler: wrmsr instruction!");
adjust_rip(guest_rip).unwrap(); adjust_rip(guest_rip).unwrap();
} }
VmxExitReason::TRIPLE_FAULT => { VmxExitReason::TRIPLE_FAULT => {
kdebug!("vmexit handler: triple fault!"); debug!("vmexit handler: triple fault!");
adjust_rip(guest_rip).unwrap(); adjust_rip(guest_rip).unwrap();
} }
VmxExitReason::EPT_VIOLATION => { VmxExitReason::EPT_VIOLATION => {
kdebug!("vmexit handler: ept violation!"); debug!("vmexit handler: ept violation!");
let gpa = vmx_vmread(GUEST_PHYSICAL_ADDR_FULL).unwrap(); let gpa = vmx_vmread(GUEST_PHYSICAL_ADDR_FULL).unwrap();
let exit_qualification = vmx_vmread(VmcsFields::VMEXIT_QUALIFICATION as u32).unwrap(); let exit_qualification = vmx_vmread(VmcsFields::VMEXIT_QUALIFICATION as u32).unwrap();
/* It is a write fault? */ /* It is a write fault? */
@ -244,17 +245,17 @@ extern "C" fn vmexit_handler() {
.expect("ept page fault error"); .expect("ept page fault error");
} }
_ => { _ => {
kdebug!( debug!(
"vmexit handler: unhandled vmexit reason: {}!", "vmexit handler: unhandled vmexit reason: {}!",
exit_basic_reason exit_basic_reason
); );
let info = vmx_vmread(VmcsFields::VMEXIT_INSTR_LEN as u32).unwrap() as u32; let info = vmx_vmread(VmcsFields::VMEXIT_INSTR_LEN as u32).unwrap() as u32;
kdebug!("vmexit handler: VMEXIT_INSTR_LEN: {}!", info); debug!("vmexit handler: VMEXIT_INSTR_LEN: {}!", info);
let info = vmx_vmread(VmcsFields::VMEXIT_INSTR_INFO as u32).unwrap() as u32; let info = vmx_vmread(VmcsFields::VMEXIT_INSTR_INFO as u32).unwrap() as u32;
kdebug!("vmexit handler: VMEXIT_INSTR_INFO: {}!", info); debug!("vmexit handler: VMEXIT_INSTR_INFO: {}!", info);
let info = vmx_vmread(VmcsFields::CTRL_EXPECTION_BITMAP as u32).unwrap() as u32; let info = vmx_vmread(VmcsFields::CTRL_EXPECTION_BITMAP as u32).unwrap() as u32;
kdebug!("vmexit handler: CTRL_EXPECTION_BITMAP: {}!", info); debug!("vmexit handler: CTRL_EXPECTION_BITMAP: {}!", info);
adjust_rip(guest_rip).unwrap(); adjust_rip(guest_rip).unwrap();
// panic!(); // panic!();

13
kernel/src/arch/x86_64/kvm/vmx/vmx_asm_wrapper.rs
View File

@ -1,6 +1,7 @@
use super::vmcs::VmcsFields; use super::vmcs::VmcsFields;
use crate::kdebug;
use core::arch::asm; use core::arch::asm;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use x86; use x86;
/// Enable VMX operation. /// Enable VMX operation.
@ -8,7 +9,7 @@ pub fn vmxon(vmxon_pa: u64) -> Result<(), SystemError> {
match unsafe { x86::bits64::vmx::vmxon(vmxon_pa) } { match unsafe { x86::bits64::vmx::vmxon(vmxon_pa) } {
Ok(_) => Ok(()), Ok(_) => Ok(()),
Err(e) => { Err(e) => {
kdebug!("vmxon fail: {:?}", e); debug!("vmxon fail: {:?}", e);
Err(SystemError::EVMXONFailed) Err(SystemError::EVMXONFailed)
} }
} }
@ -27,8 +28,8 @@ pub fn vmx_vmwrite(vmcs_field: u32, value: u64) -> Result<(), SystemError> {
match unsafe { x86::bits64::vmx::vmwrite(vmcs_field, value) } { match unsafe { x86::bits64::vmx::vmwrite(vmcs_field, value) } {
Ok(_) => Ok(()), Ok(_) => Ok(()),
Err(e) => { Err(e) => {
kdebug!("vmx_write fail: {:?}", e); debug!("vmx_write fail: {:?}", e);
kdebug!("vmcs_field: {:x}", vmcs_field); debug!("vmcs_field: {:x}", vmcs_field);
Err(SystemError::EVMWRITEFailed) Err(SystemError::EVMWRITEFailed)
} }
} }
@ -39,7 +40,7 @@ pub fn vmx_vmread(vmcs_field: u32) -> Result<u64, SystemError> {
match unsafe { x86::bits64::vmx::vmread(vmcs_field) } { match unsafe { x86::bits64::vmx::vmread(vmcs_field) } {
Ok(value) => Ok(value), Ok(value) => Ok(value),
Err(e) => { Err(e) => {
kdebug!("vmx_read fail: {:?}", e); debug!("vmx_read fail: {:?}", e);
Err(SystemError::EVMREADFailed) Err(SystemError::EVMREADFailed)
} }
} }
@ -82,7 +83,7 @@ pub fn vmx_vmlaunch() -> Result<(), SystemError> {
// match unsafe { x86::bits64::vmx::vmlaunch() } { // match unsafe { x86::bits64::vmx::vmlaunch() } {
// Ok(_) => Ok(()), // Ok(_) => Ok(()),
// Err(e) => { // Err(e) => {
// kdebug!("vmx_launch fail: {:?}", e); // debug!("vmx_launch fail: {:?}", e);
// Err(SystemError::EVMLAUNCHFailed) // Err(SystemError::EVMLAUNCHFailed)
// }, // },
// } // }

14
kernel/src/arch/x86_64/mm/fault.rs
View File

@ -4,6 +4,7 @@ use core::{
}; };
use alloc::sync::Arc; use alloc::sync::Arc;
use log::error;
use x86::{bits64::rflags::RFlags, controlregs::Cr4}; use x86::{bits64::rflags::RFlags, controlregs::Cr4};
use crate::{ use crate::{
@ -13,7 +14,6 @@ use crate::{
CurrentIrqArch, MMArch, CurrentIrqArch, MMArch,
}, },
exception::InterruptArch, exception::InterruptArch,
kerror,
mm::{ mm::{
fault::{FaultFlags, PageFaultHandler, PageFaultMessage}, fault::{FaultFlags, PageFaultHandler, PageFaultMessage},
ucontext::{AddressSpace, LockedVMA}, ucontext::{AddressSpace, LockedVMA},
@ -74,27 +74,27 @@ impl X86_64MMArch {
if let Some(entry) = mapper.get_entry(address, 0) { if let Some(entry) = mapper.get_entry(address, 0) {
if entry.present() { if entry.present() {
if !entry.flags().has_execute() { if !entry.flags().has_execute() {
kerror!("kernel tried to execute NX-protected page - exploit attempt?"); error!("kernel tried to execute NX-protected page - exploit attempt?");
} else if mapper.table().phys().data() & MMArch::ENTRY_FLAG_USER != 0 } else if mapper.table().phys().data() & MMArch::ENTRY_FLAG_USER != 0
&& unsafe { x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_SMEP) } && unsafe { x86::controlregs::cr4().contains(Cr4::CR4_ENABLE_SMEP) }
{ {
kerror!("unable to execute userspace code (SMEP?)"); error!("unable to execute userspace code (SMEP?)");
} }
} }
} }
if address.data() < X86_64MMArch::PAGE_SIZE && !regs.is_from_user() { if address.data() < X86_64MMArch::PAGE_SIZE && !regs.is_from_user() {
kerror!( error!(
"BUG: kernel NULL pointer dereference, address: {:#x}", "BUG: kernel NULL pointer dereference, address: {:#x}",
address.data() address.data()
); );
} else { } else {
kerror!( error!(
"BUG: unable to handle page fault for address: {:#x}", "BUG: unable to handle page fault for address: {:#x}",
address.data() address.data()
); );
} }
kerror!( error!(
"#PF: {} {} in {} mode\n", "#PF: {} {} in {} mode\n",
if error_code.contains(X86PfErrorCode::X86_PF_USER) { if error_code.contains(X86PfErrorCode::X86_PF_USER) {
"user" "user"
@ -114,7 +114,7 @@ impl X86_64MMArch {
"kernel" "kernel"
} }
); );
kerror!( error!(
"#PF: error_code({:#04x}) - {}\n", "#PF: error_code({:#04x}) - {}\n",
error_code, error_code,
if !error_code.contains(X86PfErrorCode::X86_PF_PROT) { if !error_code.contains(X86PfErrorCode::X86_PF_PROT) {

43
kernel/src/arch/x86_64/mm/mod.rs
View File

@ -6,6 +6,7 @@ pub mod pkru;
use alloc::sync::Arc; use alloc::sync::Arc;
use alloc::vec::Vec; use alloc::vec::Vec;
use hashbrown::HashSet; use hashbrown::HashSet;
use log::{debug, info, warn};
use x86::time::rdtsc; use x86::time::rdtsc;
use x86_64::registers::model_specific::EferFlags; use x86_64::registers::model_specific::EferFlags;
@ -29,7 +30,7 @@ use crate::{
use crate::mm::kernel_mapper::KernelMapper; use crate::mm::kernel_mapper::KernelMapper;
use crate::mm::page::{PageEntry, PageFlags, PAGE_1G_SHIFT}; use crate::mm::page::{PageEntry, PageFlags, PAGE_1G_SHIFT};
use crate::mm::{MemoryManagementArch, PageTableKind, PhysAddr, VirtAddr}; use crate::mm::{MemoryManagementArch, PageTableKind, PhysAddr, VirtAddr};
use crate::{kdebug, kinfo, kwarn};
use system_error::SystemError; use system_error::SystemError;
use core::arch::asm; use core::arch::asm;
@ -159,8 +160,8 @@ impl MemoryManagementArch for X86_64MMArch {
// 初始化物理内存区域(从multiboot2中获取) // 初始化物理内存区域(从multiboot2中获取)
Self::init_memory_area_from_multiboot2().expect("init memory area failed"); Self::init_memory_area_from_multiboot2().expect("init memory area failed");
kdebug!("bootstrap info: {:?}", unsafe { BOOTSTRAP_MM_INFO }); debug!("bootstrap info: {:?}", unsafe { BOOTSTRAP_MM_INFO });
kdebug!("phys[0]=virt[0x{:x}]", unsafe { debug!("phys[0]=virt[0x{:x}]", unsafe {
MMArch::phys_2_virt(PhysAddr::new(0)).unwrap().data() MMArch::phys_2_virt(PhysAddr::new(0)).unwrap().data()
}); });
@ -382,18 +383,16 @@ impl X86_64MMArch {
info_entry.len as usize, info_entry.len as usize,
) )
.unwrap_or_else(|e| { .unwrap_or_else(|e| {
kwarn!( warn!(
"Failed to add memory block: base={:#x}, size={:#x}, error={:?}", "Failed to add memory block: base={:#x}, size={:#x}, error={:?}",
info_entry.addr, info_entry.addr, info_entry.len, e
info_entry.len,
e
); );
}); });
areas_count += 1; areas_count += 1;
} }
} }
send_to_default_serial8250_port("init_memory_area_from_multiboot2 end\n\0".as_bytes()); send_to_default_serial8250_port("init_memory_area_from_multiboot2 end\n\0".as_bytes());
kinfo!("Total memory size: {} MB, total areas from multiboot2: {mb2_count}, valid areas: {areas_count}", total_mem_size / 1024 / 1024); info!("Total memory size: {} MB, total areas from multiboot2: {mb2_count}, valid areas: {areas_count}", total_mem_size / 1024 / 1024);
return Ok(areas_count); return Ok(areas_count);
} }
@ -402,7 +401,7 @@ impl X86_64MMArch {
let efer: EferFlags = x86_64::registers::model_specific::Efer::read(); let efer: EferFlags = x86_64::registers::model_specific::Efer::read();
if !efer.contains(EferFlags::NO_EXECUTE_ENABLE) { if !efer.contains(EferFlags::NO_EXECUTE_ENABLE) {
// NO_EXECUTE_ENABLE是false，那么就设置xd_reserved为true // NO_EXECUTE_ENABLE是false，那么就设置xd_reserved为true
kdebug!("NO_EXECUTE_ENABLE is false, set XD_RESERVED to true"); debug!("NO_EXECUTE_ENABLE is false, set XD_RESERVED to true");
XD_RESERVED.store(true, Ordering::Relaxed); XD_RESERVED.store(true, Ordering::Relaxed);
} }
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
@ -438,7 +437,7 @@ unsafe fn allocator_init() {
.reserve_block(PhysAddr::new(0), phy_offset.data()) .reserve_block(PhysAddr::new(0), phy_offset.data())
.expect("Failed to reserve block"); .expect("Failed to reserve block");
let mut bump_allocator = BumpAllocator::<X86_64MMArch>::new(phy_offset.data()); let mut bump_allocator = BumpAllocator::<X86_64MMArch>::new(phy_offset.data());
kdebug!( debug!(
"BumpAllocator created, offset={:?}", "BumpAllocator created, offset={:?}",
bump_allocator.offset() bump_allocator.offset()
); );
@ -459,7 +458,7 @@ unsafe fn allocator_init() {
) )
.expect("Failed to create page mapper"); .expect("Failed to create page mapper");
new_page_table = mapper.table().phys(); new_page_table = mapper.table().phys();
kdebug!("PageMapper created"); debug!("PageMapper created");
// 取消最开始时候，在head.S中指定的映射(暂时不刷新TLB) // 取消最开始时候，在head.S中指定的映射(暂时不刷新TLB)
{ {
@ -471,12 +470,12 @@ unsafe fn allocator_init() {
.expect("Failed to empty page table entry"); .expect("Failed to empty page table entry");
} }
} }
kdebug!("Successfully emptied page table"); debug!("Successfully emptied page table");
let total_num = mem_block_manager().total_initial_memory_regions(); let total_num = mem_block_manager().total_initial_memory_regions();
for i in 0..total_num { for i in 0..total_num {
let area = mem_block_manager().get_initial_memory_region(i).unwrap(); let area = mem_block_manager().get_initial_memory_region(i).unwrap();
// kdebug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size); // debug!("area: base={:?}, size={:#x}, end={:?}", area.base, area.size, area.base + area.size);
for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) { for i in 0..((area.size + MMArch::PAGE_SIZE - 1) / MMArch::PAGE_SIZE) {
let paddr = area.base.add(i * MMArch::PAGE_SIZE); let paddr = area.base.add(i * MMArch::PAGE_SIZE);
let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap(); let vaddr = unsafe { MMArch::phys_2_virt(paddr) }.unwrap();
@ -494,7 +493,7 @@ unsafe fn allocator_init() {
unsafe { unsafe {
INITIAL_CR3_VALUE = new_page_table; INITIAL_CR3_VALUE = new_page_table;
} }
kdebug!( debug!(
"After mapping all physical memory, DragonOS used: {} KB", "After mapping all physical memory, DragonOS used: {} KB",
bump_allocator.offset() / 1024 bump_allocator.offset() / 1024
); );
@ -503,7 +502,7 @@ unsafe fn allocator_init() {
let buddy_allocator = unsafe { BuddyAllocator::<X86_64MMArch>::new(bump_allocator).unwrap() }; let buddy_allocator = unsafe { BuddyAllocator::<X86_64MMArch>::new(bump_allocator).unwrap() };
// 设置全局的页帧分配器 // 设置全局的页帧分配器
unsafe { set_inner_allocator(buddy_allocator) }; unsafe { set_inner_allocator(buddy_allocator) };
kinfo!("Successfully initialized buddy allocator"); info!("Successfully initialized buddy allocator");
// 关闭显示输出 // 关闭显示输出
scm_disable_put_to_window(); scm_disable_put_to_window();
@ -511,7 +510,7 @@ unsafe fn allocator_init() {
{ {
let mut binding = INNER_ALLOCATOR.lock(); let mut binding = INNER_ALLOCATOR.lock();
let mut allocator_guard = binding.as_mut().unwrap(); let mut allocator_guard = binding.as_mut().unwrap();
kdebug!("To enable new page table."); debug!("To enable new page table.");
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
let mapper = crate::mm::page::PageMapper::<MMArch, _>::new( let mapper = crate::mm::page::PageMapper::<MMArch, _>::new(
PageTableKind::Kernel, PageTableKind::Kernel,
@ -521,9 +520,9 @@ unsafe fn allocator_init() {
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
mapper.make_current(); mapper.make_current();
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
kdebug!("New page table enabled"); debug!("New page table enabled");
} }
kdebug!("Successfully enabled new page table"); debug!("Successfully enabled new page table");
} }
#[no_mangle] #[no_mangle]
@ -536,7 +535,7 @@ pub fn test_buddy() {
const TOTAL_SIZE: usize = 200 * 1024 * 1024; const TOTAL_SIZE: usize = 200 * 1024 * 1024;
for i in 0..10 { for i in 0..10 {
kdebug!("Test buddy, round: {i}"); debug!("Test buddy, round: {i}");
// 存放申请的内存块 // 存放申请的内存块
let mut v: Vec<(PhysAddr, PageFrameCount)> = Vec::with_capacity(60 * 1024); let mut v: Vec<(PhysAddr, PageFrameCount)> = Vec::with_capacity(60 * 1024);
// 存放已经申请的内存块的地址（用于检查重复） // 存放已经申请的内存块的地址（用于检查重复）
@ -601,14 +600,14 @@ pub fn test_buddy() {
} }
} }
kdebug!( debug!(
"Allocated {} MB memory, release: {} MB, no release: {} bytes", "Allocated {} MB memory, release: {} MB, no release: {} bytes",
allocated / 1024 / 1024, allocated / 1024 / 1024,
free_count / 1024 / 1024, free_count / 1024 / 1024,
(allocated - free_count) (allocated - free_count)
); );
kdebug!("Now, to release buddy memory"); debug!("Now, to release buddy memory");
// 释放所有的内存 // 释放所有的内存
for (paddr, allocated_frame_count) in v { for (paddr, allocated_frame_count) in v {
unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) }; unsafe { LockedFrameAllocator.free(paddr, allocated_frame_count) };
@ -616,7 +615,7 @@ pub fn test_buddy() {
free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE; free_count += allocated_frame_count.data() * MMArch::PAGE_SIZE;
} }
kdebug!("release done!, allocated: {allocated}, free_count: {free_count}"); debug!("release done!, allocated: {allocated}, free_count: {free_count}");
} }
} }

5
kernel/src/arch/x86_64/pci/pci.rs
View File

@ -6,10 +6,11 @@ use crate::driver::pci::pci::{
}; };
use crate::include::bindings::bindings::{io_in32, io_out32}; use crate::include::bindings::bindings::{io_in32, io_out32};
use crate::init::initcall::INITCALL_SUBSYS; use crate::init::initcall::INITCALL_SUBSYS;
use crate::kerror;
use crate::mm::PhysAddr; use crate::mm::PhysAddr;
use acpi::mcfg::Mcfg; use acpi::mcfg::Mcfg;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -51,7 +52,7 @@ impl TraitPciArch for X86_64PciArch {
#[unified_init(INITCALL_SUBSYS)] #[unified_init(INITCALL_SUBSYS)]
fn x86_64_pci_init() -> Result<(), SystemError> { fn x86_64_pci_init() -> Result<(), SystemError> {
if let Err(e) = discover_ecam_root() { if let Err(e) = discover_ecam_root() {
kerror!("x86_64_pci_init(): discover_ecam_root error: {:?}", e); error!("x86_64_pci_init(): discover_ecam_root error: {:?}", e);
} }
pci_init(); pci_init();

5
kernel/src/arch/x86_64/process/idle.rs
View File

@ -1,9 +1,10 @@
use core::hint::spin_loop; use core::hint::spin_loop;
use log::error;
use crate::{ use crate::{
arch::CurrentIrqArch, arch::CurrentIrqArch,
exception::InterruptArch, exception::InterruptArch,
kBUG,
process::{ProcessFlags, ProcessManager}, process::{ProcessFlags, ProcessManager},
sched::{SchedMode, __schedule}, sched::{SchedMode, __schedule},
}; };
@ -21,7 +22,7 @@ impl ProcessManager {
x86::halt(); x86::halt();
} }
} else { } else {
kBUG!("Idle process should not be scheduled with IRQs disabled."); error!("Idle process should not be scheduled with IRQs disabled.");
spin_loop(); spin_loop();
} }
} }

10
kernel/src/arch/x86_64/process/mod.rs
View File

@ -8,13 +8,13 @@ use core::{
use alloc::sync::{Arc, Weak}; use alloc::sync::{Arc, Weak};
use kdepends::memoffset::offset_of; use kdepends::memoffset::offset_of;
use log::{error, warn};
use system_error::SystemError; use system_error::SystemError;
use x86::{controlregs::Cr4, segmentation::SegmentSelector}; use x86::{controlregs::Cr4, segmentation::SegmentSelector};
use crate::{ use crate::{
arch::process::table::TSSManager, arch::process::table::TSSManager,
exception::InterruptArch, exception::InterruptArch,
kerror, kwarn,
libs::spinlock::SpinLockGuard, libs::spinlock::SpinLockGuard,
mm::VirtAddr, mm::VirtAddr,
process::{ process::{
@ -167,7 +167,7 @@ impl ArchPCBInfo {
// 清空浮点寄存器 // 清空浮点寄存器
pub fn clear_fp_state(&mut self) { pub fn clear_fp_state(&mut self) {
if unlikely(self.fp_state.is_none()) { if unlikely(self.fp_state.is_none()) {
kwarn!("fp_state is none"); warn!("fp_state is none");
return; return;
} }
@ -275,7 +275,7 @@ impl ProcessControlBlock {
// 从内核栈的最低地址处取出pcb的地址 // 从内核栈的最低地址处取出pcb的地址
let p = stack_base.data() as *const *const ProcessControlBlock; let p = stack_base.data() as *const *const ProcessControlBlock;
if unlikely((unsafe { *p }).is_null()) { if unlikely((unsafe { *p }).is_null()) {
kerror!("p={:p}", p); error!("p={:p}", p);
panic!("current_pcb is null"); panic!("current_pcb is null");
} }
unsafe { unsafe {
@ -406,7 +406,7 @@ impl ProcessManager {
); );
PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().prev_pcb = Some(prev); PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().prev_pcb = Some(prev);
PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().next_pcb = Some(next); PROCESS_SWITCH_RESULT.as_mut().unwrap().get_mut().next_pcb = Some(next);
// kdebug!("switch tss ok"); // debug!("switch tss ok");
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
// 正式切换上下文 // 正式切换上下文
switch_to_inner(prev_arch, next_arch); switch_to_inner(prev_arch, next_arch);
@ -515,7 +515,7 @@ pub unsafe fn arch_switch_to_user(trap_frame: TrapFrame) -> ! {
let trap_frame_vaddr = VirtAddr::new( let trap_frame_vaddr = VirtAddr::new(
current_pcb.kernel_stack().stack_max_address().data() - core::mem::size_of::<TrapFrame>(), current_pcb.kernel_stack().stack_max_address().data() - core::mem::size_of::<TrapFrame>(),
); );
// kdebug!("trap_frame_vaddr: {:?}", trap_frame_vaddr); // debug!("trap_frame_vaddr: {:?}", trap_frame_vaddr);
assert!( assert!(
(x86::current::registers::rsp() as usize) < trap_frame_vaddr.data(), (x86::current::registers::rsp() as usize) < trap_frame_vaddr.data(),

16
kernel/src/arch/x86_64/process/syscall.rs
View File

@ -26,7 +26,7 @@ impl Syscall {
// 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。 // 关中断，防止在设置地址空间的时候，发生中断，然后进调度器，出现错误。
let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() }; let irq_guard = unsafe { CurrentIrqArch::save_and_disable_irq() };
let pcb = ProcessManager::current_pcb(); let pcb = ProcessManager::current_pcb();
// crate::kdebug!( // crate::debug!(
// "pid: {:?} do_execve: path: {:?}, argv: {:?}, envp: {:?}\n", // "pid: {:?} do_execve: path: {:?}, argv: {:?}, envp: {:?}\n",
// pcb.pid(), // pcb.pid(),
// path, // path,
@ -55,20 +55,20 @@ impl Syscall {
AddressSpace::is_current(&address_space), AddressSpace::is_current(&address_space),
"Failed to set address space" "Failed to set address space"
); );
// kdebug!("Switch to new address space"); // debug!("Switch to new address space");
// 切换到新的用户地址空间 // 切换到新的用户地址空间
unsafe { address_space.read().user_mapper.utable.make_current() }; unsafe { address_space.read().user_mapper.utable.make_current() };
drop(old_address_space); drop(old_address_space);
drop(irq_guard); drop(irq_guard);
// kdebug!("to load binary file"); // debug!("to load binary file");
let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?; let mut param = ExecParam::new(path.as_str(), address_space.clone(), ExecParamFlags::EXEC)?;
// 加载可执行文件 // 加载可执行文件
let load_result = load_binary_file(&mut param)?; let load_result = load_binary_file(&mut param)?;
// kdebug!("load binary file done"); // debug!("load binary file done");
// kdebug!("argv: {:?}, envp: {:?}", argv, envp); // debug!("argv: {:?}, envp: {:?}", argv, envp);
param.init_info_mut().args = argv; param.init_info_mut().args = argv;
param.init_info_mut().envs = envp; param.init_info_mut().envs = envp;
@ -94,7 +94,7 @@ impl Syscall {
}; };
address_space.write().user_stack = Some(ustack_message); address_space.write().user_stack = Some(ustack_message);
// kdebug!("write proc_init_info to user stack done"); // debug!("write proc_init_info to user stack done");
// （兼容旧版libc）把argv的指针写到寄存器内 // （兼容旧版libc）把argv的指针写到寄存器内
// TODO: 改写旧版libc，不再需要这个兼容 // TODO: 改写旧版libc，不再需要这个兼容
@ -116,9 +116,9 @@ impl Syscall {
drop(param); drop(param);
// kdebug!("regs: {:?}\n", regs); // debug!("regs: {:?}\n", regs);
// crate::kdebug!( // crate::debug!(
// "tmp_rs_execve: done, load_result.entry_point()={:?}", // "tmp_rs_execve: done, load_result.entry_point()={:?}",
// load_result.entry_point() // load_result.entry_point()
// ); // );

6
kernel/src/arch/x86_64/smp/mod.rs
View File

@ -5,12 +5,12 @@ use core::{
}; };
use kdepends::memoffset::offset_of; use kdepends::memoffset::offset_of;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
arch::{mm::LowAddressRemapping, process::table::TSSManager, MMArch}, arch::{mm::LowAddressRemapping, process::table::TSSManager, MMArch},
exception::InterruptArch, exception::InterruptArch,
kdebug,
libs::{cpumask::CpuMask, rwlock::RwLock}, libs::{cpumask::CpuMask, rwlock::RwLock},
mm::{percpu::PerCpu, MemoryManagementArch, PhysAddr, VirtAddr, IDLE_PROCESS_ADDRESS_SPACE}, mm::{percpu::PerCpu, MemoryManagementArch, PhysAddr, VirtAddr, IDLE_PROCESS_ADDRESS_SPACE},
process::ProcessManager, process::ProcessManager,
@ -77,7 +77,7 @@ unsafe extern "sysv64" fn smp_init_switch_stack(st: &ApStartStackInfo) -> ! {
unsafe extern "C" fn smp_ap_start_stage1() -> ! { unsafe extern "C" fn smp_ap_start_stage1() -> ! {
let id = smp_get_processor_id(); let id = smp_get_processor_id();
kdebug!("smp_ap_start_stage1: id: {}\n", id.data()); debug!("smp_ap_start_stage1: id: {}\n", id.data());
let current_idle = ProcessManager::idle_pcb()[smp_get_processor_id().data() as usize].clone(); let current_idle = ProcessManager::idle_pcb()[smp_get_processor_id().data() as usize].clone();
let tss = TSSManager::current_tss(); let tss = TSSManager::current_tss();
@ -187,7 +187,7 @@ fn print_cpus(s: &str, mask: &CpuMask) {
v.push(cpu.data()); v.push(cpu.data());
} }
kdebug!("{s}: cpus: {v:?}\n"); debug!("{s}: cpus: {v:?}\n");
} }
pub struct X86_64SMPArch; pub struct X86_64SMPArch;

7
kernel/src/arch/x86_64/syscall/mod.rs
View File

@ -11,6 +11,7 @@ use crate::{
process::ProcessManager, process::ProcessManager,
syscall::{Syscall, SYS_SCHED}, syscall::{Syscall, SYS_SCHED},
}; };
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use super::{ use super::{
@ -52,7 +53,7 @@ macro_rules! syscall_return {
if $show { if $show {
let pid = ProcessManager::current_pcb().pid(); let pid = ProcessManager::current_pcb().pid();
crate::kdebug!("syscall return:pid={:?},ret= {:?}\n", pid, ret as isize); debug!("syscall return:pid={:?},ret= {:?}\n", pid, ret as isize);
} }
unsafe { unsafe {
@ -94,7 +95,7 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
// }; // };
if show { if show {
crate::kdebug!("syscall: pid: {:?}, num={:?}\n", pid, syscall_num); debug!("syscall: pid: {:?}, num={:?}\n", pid, syscall_num);
} }
// Arch specific syscall // Arch specific syscall
@ -126,7 +127,7 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
/// 系统调用初始化 /// 系统调用初始化
pub fn arch_syscall_init() -> Result<(), SystemError> { pub fn arch_syscall_init() -> Result<(), SystemError> {
// kinfo!("arch_syscall_init\n"); // info!("arch_syscall_init\n");
unsafe { set_system_trap_gate(0x80, 0, VirtAddr::new(syscall_int as usize)) }; // 系统调用门 unsafe { set_system_trap_gate(0x80, 0, VirtAddr::new(syscall_int as usize)) }; // 系统调用门
unsafe { init_syscall_64() }; unsafe { init_syscall_64() };
return Ok(()); return Ok(());

10
kernel/src/driver/acpi/mod.rs
View File

@ -2,11 +2,11 @@ use core::{fmt::Debug, hint::spin_loop, ptr::NonNull};
use acpi::{AcpiHandler, AcpiTables, PlatformInfo}; use acpi::{AcpiHandler, AcpiTables, PlatformInfo};
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use log::{error, info};
use crate::{ use crate::{
arch::MMArch, arch::MMArch,
driver::base::firmware::sys_firmware_kset, driver::base::firmware::sys_firmware_kset,
kinfo,
libs::align::{page_align_down, page_align_up, AlignedBox}, libs::align::{page_align_down, page_align_up, AlignedBox},
mm::{ mm::{
mmio_buddy::{mmio_pool, MMIOSpaceGuard}, mmio_buddy::{mmio_pool, MMIOSpaceGuard},
@ -57,7 +57,7 @@ impl AcpiManager {
/// ///
/// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/acpi/bus.c#1390 /// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/acpi/bus.c#1390
pub fn init(&self, rsdp_vaddr1: u64, rsdp_vaddr2: u64) -> Result<(), SystemError> { pub fn init(&self, rsdp_vaddr1: u64, rsdp_vaddr2: u64) -> Result<(), SystemError> {
kinfo!("Initializing Acpi Manager..."); info!("Initializing Acpi Manager...");
// 初始化`/sys/firmware/acpi`的kset // 初始化`/sys/firmware/acpi`的kset
let kset = KSet::new("acpi".to_string()); let kset = KSet::new("acpi".to_string());
@ -67,7 +67,7 @@ impl AcpiManager {
} }
self.map_tables(rsdp_vaddr1, rsdp_vaddr2)?; self.map_tables(rsdp_vaddr1, rsdp_vaddr2)?;
self.bus_init()?; self.bus_init()?;
kinfo!("Acpi Manager initialized."); info!("Acpi Manager initialized.");
return Ok(()); return Ok(());
} }
@ -95,7 +95,7 @@ impl AcpiManager {
} }
// 如果rsdpv1和rsdpv2都无法获取到acpi_table，说明有问题，打印报错信息后进入死循环 // 如果rsdpv1和rsdpv2都无法获取到acpi_table，说明有问题，打印报错信息后进入死循环
Err(e2) => { Err(e2) => {
kerror!("acpi_init(): failed to parse acpi tables, error: (rsdpv1: {:?}) or (rsdpv2: {:?})", e1, e2); error!("acpi_init(): failed to parse acpi tables, error: (rsdpv1: {:?}) or (rsdpv2: {:?})", e1, e2);
Self::drop_rsdp_tmp_box(); Self::drop_rsdp_tmp_box();
loop { loop {
spin_loop(); spin_loop();
@ -161,7 +161,7 @@ impl AcpiManager {
pub fn platform_info(&self) -> Option<PlatformInfo<'_, alloc::alloc::Global>> { pub fn platform_info(&self) -> Option<PlatformInfo<'_, alloc::alloc::Global>> {
let r = self.tables()?.platform_info(); let r = self.tables()?.platform_info();
if let Err(ref e) = r { if let Err(ref e) = r {
kerror!( error!(
"AcpiManager::platform_info(): failed to get platform info, error: {:?}", "AcpiManager::platform_info(): failed to get platform info, error: {:?}",
e e
); );

12
kernel/src/driver/acpi/sysfs.rs
View File

@ -18,6 +18,7 @@ use alloc::{
sync::Arc, sync::Arc,
vec::Vec, vec::Vec,
}; };
use log::{debug, error, warn};
use system_error::SystemError; use system_error::SystemError;
use super::{acpi_kset, AcpiManager}; use super::{acpi_kset, AcpiManager};
@ -109,7 +110,7 @@ impl AcpiManager {
let tables = self.tables().unwrap(); let tables = self.tables().unwrap();
let headers = tables.headers(); let headers = tables.headers();
for header in headers { for header in headers {
kdebug!("ACPI header: {:?}", header); debug!("ACPI header: {:?}", header);
let attr = AttrAcpiTable::new(&header)?; let attr = AttrAcpiTable::new(&header)?;
acpi_table_attr_list().write().push(attr); acpi_table_attr_list().write().push(attr);
self.acpi_table_data_init(&header)?; self.acpi_table_data_init(&header)?;
@ -172,7 +173,7 @@ impl AttrAcpiTable {
// 将当前实例的序号加1 // 将当前实例的序号加1
r.instance += 1; r.instance += 1;
if r.instance > ACPI_MAX_TABLE_INSTANCES as isize { if r.instance > ACPI_MAX_TABLE_INSTANCES as isize {
kwarn!("too many table instances. name: {}", r.name); warn!("too many table instances. name: {}", r.name);
return Err(SystemError::ERANGE); return Err(SystemError::ERANGE);
} }
@ -289,10 +290,9 @@ impl BinAttribute for AttrAcpiTable {
($name: ident, $tables: expr) => { ($name: ident, $tables: expr) => {
define_struct!($name); define_struct!($name);
let table = $tables.find_entire_table::<$name>().map_err(|e| { let table = $tables.find_entire_table::<$name>().map_err(|e| {
kwarn!( warn!(
"AttrAcpiTable::read(): failed to find table. name: {}, error: {:?}", "AttrAcpiTable::read(): failed to find table. name: {}, error: {:?}",
self.name, self.name, e
e
); );
SystemError::ENODEV SystemError::ENODEV
})?; })?;
@ -500,7 +500,7 @@ impl BinAttribute for AttrAcpiTable {
} }
_ => { _ => {
kerror!("AttrAcpiTable::read(): unknown table. name: {}", self.name); error!("AttrAcpiTable::read(): unknown table. name: {}", self.name);
return Err(SystemError::ENODEV); return Err(SystemError::ENODEV);
} }
}; };

30
kernel/src/driver/base/block/block_device.rs
View File

@ -1,23 +1,21 @@
/// 引入Module /// 引入Module
use crate::{ use crate::driver::{
driver::{ base::{
base::{ device::{
device::{ device_number::{DeviceNumber, Major},
device_number::{DeviceNumber, Major}, Device, DeviceError, IdTable, BLOCKDEVS,
Device, DeviceError, IdTable, BLOCKDEVS, },
}, map::{
map::{ DeviceStruct, DEV_MAJOR_DYN_END, DEV_MAJOR_DYN_EXT_END, DEV_MAJOR_DYN_EXT_START,
DeviceStruct, DEV_MAJOR_DYN_END, DEV_MAJOR_DYN_EXT_END, DEV_MAJOR_DYN_EXT_START, DEV_MAJOR_HASH_SIZE, DEV_MAJOR_MAX,
DEV_MAJOR_HASH_SIZE, DEV_MAJOR_MAX,
},
}, },
block::cache::{cached_block_device::BlockCache, BlockCacheError, BLOCK_SIZE},
}, },
kerror, block::cache::{cached_block_device::BlockCache, BlockCacheError, BLOCK_SIZE},
}; };
use alloc::{sync::Arc, vec::Vec}; use alloc::{sync::Arc, vec::Vec};
use core::any::Any; use core::any::Any;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use super::disk_info::Partition; use super::disk_info::Partition;
@ -475,7 +473,7 @@ impl BlockDeviceOps {
let mut major = device_number.major(); let mut major = device_number.major();
let baseminor = device_number.minor(); let baseminor = device_number.minor();
if major >= DEV_MAJOR_MAX { if major >= DEV_MAJOR_MAX {
kerror!( error!(
"DEV {} major requested {:?} is greater than the maximum {}\n", "DEV {} major requested {:?} is greater than the maximum {}\n",
name, name,
major, major,
@ -483,7 +481,7 @@ impl BlockDeviceOps {
); );
} }
if minorct > DeviceNumber::MINOR_MASK + 1 - baseminor { if minorct > DeviceNumber::MINOR_MASK + 1 - baseminor {
kerror!("DEV {} minor range requested ({}-{}) is out of range of maximum range ({}-{}) for a single major\n", error!("DEV {} minor range requested ({}-{}) is out of range of maximum range ({}-{}) for a single major\n",
name, baseminor, baseminor + minorct - 1, 0, DeviceNumber::MINOR_MASK); name, baseminor, baseminor + minorct - 1, 0, DeviceNumber::MINOR_MASK);
} }
let blockdev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name); let blockdev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name);
@ -549,7 +547,7 @@ impl BlockDeviceOps {
#[allow(dead_code)] #[allow(dead_code)]
pub fn bdev_add(_bdev: Arc<dyn BlockDevice>, id_table: IdTable) -> Result<(), DeviceError> { pub fn bdev_add(_bdev: Arc<dyn BlockDevice>, id_table: IdTable) -> Result<(), DeviceError> {
if id_table.device_number().data() == 0 { if id_table.device_number().data() == 0 {
kerror!("Device number can't be 0!\n"); error!("Device number can't be 0!\n");
} }
todo!("bdev_add") todo!("bdev_add")
// return device_manager().add_device(bdev.id_table(), bdev.device()); // return device_manager().add_device(bdev.id_table(), bdev.device());

8
kernel/src/driver/base/char/mod.rs
View File

@ -1,6 +1,6 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use log::error;
use crate::kerror;
use system_error::SystemError; use system_error::SystemError;
use super::{ use super::{
@ -129,7 +129,7 @@ impl CharDevOps {
let mut major = device_number.major(); let mut major = device_number.major();
let baseminor = device_number.minor(); let baseminor = device_number.minor();
if major >= DEV_MAJOR_MAX { if major >= DEV_MAJOR_MAX {
kerror!( error!(
"DEV {} major requested {:?} is greater than the maximum {}\n", "DEV {} major requested {:?} is greater than the maximum {}\n",
name, name,
major, major,
@ -137,7 +137,7 @@ impl CharDevOps {
); );
} }
if minorct > DeviceNumber::MINOR_MASK + 1 - baseminor { if minorct > DeviceNumber::MINOR_MASK + 1 - baseminor {
kerror!("DEV {} minor range requested ({}-{}) is out of range of maximum range ({}-{}) for a single major\n", error!("DEV {} minor range requested ({}-{}) is out of range of maximum range ({}-{}) for a single major\n",
name, baseminor, baseminor + minorct - 1, 0, DeviceNumber::MINOR_MASK); name, baseminor, baseminor + minorct - 1, 0, DeviceNumber::MINOR_MASK);
} }
let chardev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name); let chardev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name);
@ -207,7 +207,7 @@ impl CharDevOps {
range: usize, range: usize,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
if id_table.device_number().data() == 0 { if id_table.device_number().data() == 0 {
kerror!("Device number can't be 0!\n"); error!("Device number can't be 0!\n");
} }
device_manager().add_device(cdev.clone())?; device_manager().add_device(cdev.clone())?;
kobj_map( kobj_map(

13
kernel/src/driver/base/device/bus.rs
View File

@ -25,6 +25,7 @@ use alloc::{
use core::{ffi::CStr, fmt::Debug, intrinsics::unlikely}; use core::{ffi::CStr, fmt::Debug, intrinsics::unlikely};
use hashbrown::HashMap; use hashbrown::HashMap;
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::{debug, error, info};
use system_error::SystemError; use system_error::SystemError;
/// `/sys/bus`的kset /// `/sys/bus`的kset
@ -296,7 +297,7 @@ impl BusManager {
.bus() .bus()
.and_then(|bus| bus.upgrade()) .and_then(|bus| bus.upgrade())
.ok_or(SystemError::EINVAL)?; .ok_or(SystemError::EINVAL)?;
kdebug!("bus '{}' add driver '{}'", bus.name(), driver.name()); debug!("bus '{}' add driver '{}'", bus.name(), driver.name());
driver.set_kobj_type(Some(&BusDriverKType)); driver.set_kobj_type(Some(&BusDriverKType));
let kobj = driver.clone() as Arc<dyn KObject>; let kobj = driver.clone() as Arc<dyn KObject>;
@ -314,7 +315,7 @@ impl BusManager {
driver_manager() driver_manager()
.add_groups(driver, bus.drv_groups()) .add_groups(driver, bus.drv_groups())
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"BusManager::add_driver: driver '{:?}' add_groups failed, err: '{:?}", "BusManager::add_driver: driver '{:?}' add_groups failed, err: '{:?}",
driver.name(), driver.name(),
e e
@ -326,7 +327,7 @@ impl BusManager {
if !driver.suppress_bind_attrs() { if !driver.suppress_bind_attrs() {
self.add_bind_files(driver) self.add_bind_files(driver)
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"BusManager::add_driver: driver '{:?}' add_bind_files failed, err: '{:?}", "BusManager::add_driver: driver '{:?}' add_bind_files failed, err: '{:?}",
driver.name(), driver.name(),
e e
@ -580,7 +581,7 @@ pub fn bus_add_device(dev: &Arc<dyn Device>) -> Result<(), SystemError> {
/// ///
/// 参考： https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_probe_device#478 /// 参考： https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/bus.c?fi=bus_probe_device#478
pub fn bus_probe_device(dev: &Arc<dyn Device>) { pub fn bus_probe_device(dev: &Arc<dyn Device>) {
kinfo!("bus_probe_device: dev: {:?}", dev.name()); info!("bus_probe_device: dev: {:?}", dev.name());
bus_manager().probe_device(dev); bus_manager().probe_device(dev);
} }
@ -746,7 +747,7 @@ impl Attribute for DriverAttrUnbind {
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let driver = kobj.cast::<dyn Driver>().map_err(|kobj| { let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
kerror!( error!(
"Intertrait casting not implemented for kobj: {}", "Intertrait casting not implemented for kobj: {}",
kobj.name() kobj.name()
); );
@ -795,7 +796,7 @@ impl Attribute for DriverAttrBind {
*/ */
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let driver = kobj.cast::<dyn Driver>().map_err(|kobj| { let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
kerror!( error!(
"Intertrait casting not implemented for kobj: {}", "Intertrait casting not implemented for kobj: {}",
kobj.name() kobj.name()
); );

35
kernel/src/driver/base/device/dd.rs
View File

@ -2,6 +2,7 @@ use core::intrinsics::unlikely;
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::{debug, error, warn};
use crate::{ use crate::{
driver::base::kobject::KObject, driver::base::kobject::KObject,
@ -59,20 +60,20 @@ impl DeviceManager {
) -> Result<bool, SystemError> { ) -> Result<bool, SystemError> {
if unlikely(allow_async) { if unlikely(allow_async) {
// todo!("do_device_attach: allow_async") // todo!("do_device_attach: allow_async")
kwarn!("do_device_attach: allow_async is true, but currently not supported"); warn!("do_device_attach: allow_async is true, but currently not supported");
} }
if dev.is_dead() { if dev.is_dead() {
return Ok(false); return Ok(false);
} }
kwarn!("do_device_attach: dev: '{}'", dev.name()); warn!("do_device_attach: dev: '{}'", dev.name());
let mut do_async = false; let mut do_async = false;
let mut r = Ok(false); let mut r = Ok(false);
if dev.driver().is_some() { if dev.driver().is_some() {
if self.device_is_bound(dev) { if self.device_is_bound(dev) {
kdebug!( debug!(
"do_device_attach: device '{}' is already bound.", "do_device_attach: device '{}' is already bound.",
dev.name() dev.name()
); );
@ -86,7 +87,7 @@ impl DeviceManager {
return Ok(false); return Ok(false);
} }
} else { } else {
kdebug!("do_device_attach: device '{}' is not bound.", dev.name()); debug!("do_device_attach: device '{}' is not bound.", dev.name());
let bus = dev let bus = dev
.bus() .bus()
.and_then(|bus| bus.upgrade()) .and_then(|bus| bus.upgrade())
@ -116,7 +117,7 @@ impl DeviceManager {
// try them. // try them.
do_async = true; do_async = true;
kdebug!( debug!(
"do_device_attach: try scheduling asynchronous probe for device: {}", "do_device_attach: try scheduling asynchronous probe for device: {}",
dev.name() dev.name()
); );
@ -153,7 +154,7 @@ impl DeviceManager {
if let Err(e) = r { if let Err(e) = r {
// 如果不是ENOSYS，则总线出错 // 如果不是ENOSYS，则总线出错
if e != SystemError::ENOSYS { if e != SystemError::ENOSYS {
kdebug!( debug!(
"do_device_attach_driver: bus.match_device() failed, dev: '{}', err: {:?}", "do_device_attach_driver: bus.match_device() failed, dev: '{}', err: {:?}",
data.dev.name(), data.dev.name(),
e e
@ -215,7 +216,7 @@ impl DeviceManager {
} }
if let Err(e) = r.as_ref() { if let Err(e) = r.as_ref() {
kerror!( error!(
"device_bind_driver: driver_sysfs_add failed, dev: '{}', err: {:?}", "device_bind_driver: driver_sysfs_add failed, dev: '{}', err: {:?}",
dev.name(), dev.name(),
e e
@ -401,7 +402,7 @@ impl DriverManager {
device.set_driver(Some(Arc::downgrade(driver))); device.set_driver(Some(Arc::downgrade(driver)));
self.add_to_sysfs(device).map_err(|e| { self.add_to_sysfs(device).map_err(|e| {
kerror!( error!(
"really_probe: add_to_sysfs failed, dev: '{}', err: {:?}", "really_probe: add_to_sysfs failed, dev: '{}', err: {:?}",
device.name(), device.name(),
e e
@ -412,7 +413,7 @@ impl DriverManager {
})?; })?;
self.call_driver_probe(device, driver).map_err(|e| { self.call_driver_probe(device, driver).map_err(|e| {
kerror!( error!(
"really_probe: call_driver_probe failed, dev: '{}', err: {:?}", "really_probe: call_driver_probe failed, dev: '{}', err: {:?}",
device.name(), device.name(),
e e
@ -427,7 +428,7 @@ impl DriverManager {
device_manager() device_manager()
.add_groups(device, driver.dev_groups()) .add_groups(device, driver.dev_groups())
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"really_probe: add_groups failed, dev: '{}', err: {:?}", "really_probe: add_groups failed, dev: '{}', err: {:?}",
device.name(), device.name(),
e e
@ -443,7 +444,7 @@ impl DriverManager {
device_manager() device_manager()
.create_file(device, &DeviceAttrStateSynced) .create_file(device, &DeviceAttrStateSynced)
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"really_probe: create_file failed, dev: '{}', err: {:?}", "really_probe: create_file failed, dev: '{}', err: {:?}",
device.name(), device.name(),
e e
@ -515,7 +516,7 @@ impl DriverManager {
.ok_or(SystemError::EINVAL)?; .ok_or(SystemError::EINVAL)?;
let r = bus.probe(device); let r = bus.probe(device);
if r == Err(SystemError::ENOSYS) { if r == Err(SystemError::ENOSYS) {
kerror!( error!(
"call_driver_probe: bus.probe() failed, dev: '{}', err: {:?}", "call_driver_probe: bus.probe() failed, dev: '{}', err: {:?}",
device.name(), device.name(),
r r
@ -530,7 +531,7 @@ impl DriverManager {
let err = r.unwrap_err(); let err = r.unwrap_err();
match err { match err {
SystemError::ENODEV | SystemError::ENXIO => { SystemError::ENODEV | SystemError::ENXIO => {
kdebug!( debug!(
"driver'{}': probe of {} rejects match {:?}", "driver'{}': probe of {} rejects match {:?}",
driver.name(), driver.name(),
device.name(), device.name(),
@ -539,7 +540,7 @@ impl DriverManager {
} }
_ => { _ => {
kwarn!( warn!(
"driver'{}': probe of {} failed with error {:?}", "driver'{}': probe of {} failed with error {:?}",
driver.name(), driver.name(),
device.name(), device.name(),
@ -555,7 +556,7 @@ impl DriverManager {
/// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/dd.c#393 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/dd.c#393
fn driver_bound(&self, device: &Arc<dyn Device>) { fn driver_bound(&self, device: &Arc<dyn Device>) {
if self.driver_is_bound(device) { if self.driver_is_bound(device) {
kwarn!("driver_bound: device '{}' is already bound.", device.name()); warn!("driver_bound: device '{}' is already bound.", device.name());
return; return;
} }
@ -600,7 +601,7 @@ impl Attribute for DeviceAttrStateSynced {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| { let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!( error!(
"Intertrait casting not implemented for kobj: {}", "Intertrait casting not implemented for kobj: {}",
kobj.name() kobj.name()
); );
@ -635,7 +636,7 @@ impl Attribute for DeviceAttrCoredump {
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| { let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!( error!(
"Intertrait casting not implemented for kobj: {}", "Intertrait casting not implemented for kobj: {}",
kobj.name() kobj.name()
); );

5
kernel/src/driver/base/device/driver.rs
View File

@ -15,6 +15,7 @@ use alloc::{
vec::Vec, vec::Vec,
}; };
use core::fmt::Debug; use core::fmt::Debug;
use log::error;
use system_error::SystemError; use system_error::SystemError;
/// @brief: Driver error /// @brief: Driver error
@ -193,7 +194,7 @@ impl DriverManager {
/// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/driver.c#222 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/driver.c#222
pub fn register(&self, driver: Arc<dyn Driver>) -> Result<(), SystemError> { pub fn register(&self, driver: Arc<dyn Driver>) -> Result<(), SystemError> {
let bus = driver.bus().and_then(|bus| bus.upgrade()).ok_or_else(|| { let bus = driver.bus().and_then(|bus| bus.upgrade()).ok_or_else(|| {
kerror!( error!(
"DriverManager::register() failed: driver.bus() is None. Driver: '{:?}'", "DriverManager::register() failed: driver.bus() is None. Driver: '{:?}'",
driver.name() driver.name()
); );
@ -203,7 +204,7 @@ impl DriverManager {
let drv_name = driver.name(); let drv_name = driver.name();
let other = bus.find_driver_by_name(&drv_name); let other = bus.find_driver_by_name(&drv_name);
if other.is_some() { if other.is_some() {
kerror!( error!(
"DriverManager::register() failed: driver '{}' already registered", "DriverManager::register() failed: driver '{}' already registered",
drv_name drv_name
); );

23
kernel/src/driver/base/device/init.rs
View File

@ -1,16 +1,13 @@
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use log::info;
use crate::{ use crate::driver::base::{
driver::base::{ device::{
device::{ set_sys_dev_block_kset, set_sys_dev_char_kset, set_sys_devices_virtual_kset, sys_dev_kset,
set_sys_dev_block_kset, set_sys_dev_char_kset, set_sys_devices_virtual_kset, sys_devices_kset, DeviceManager, DEVICES_KSET_INSTANCE, DEVICE_MANAGER, DEV_KSET_INSTANCE,
sys_dev_kset, sys_devices_kset, DeviceManager, DEVICES_KSET_INSTANCE, DEVICE_MANAGER,
DEV_KSET_INSTANCE,
},
kobject::KObject,
kset::KSet,
}, },
kinfo, kobject::KObject,
kset::KSet,
}; };
use system_error::SystemError; use system_error::SystemError;
@ -54,7 +51,7 @@ pub fn devices_init() -> Result<(), SystemError> {
// 创建 `/sys/dev/block` 目录 // 创建 `/sys/dev/block` 目录
{ {
// kdebug!("create /sys/dev/block"); // debug!("create /sys/dev/block");
let dev_kset = sys_dev_kset(); let dev_kset = sys_dev_kset();
let dev_block_kset = KSet::new("block".to_string()); let dev_block_kset = KSet::new("block".to_string());
let parent = dev_kset.clone() as Arc<dyn KObject>; let parent = dev_kset.clone() as Arc<dyn KObject>;
@ -69,7 +66,7 @@ pub fn devices_init() -> Result<(), SystemError> {
// 创建 `/sys/dev/char` 目录 // 创建 `/sys/dev/char` 目录
{ {
// kdebug!("create /sys/dev/char"); // debug!("create /sys/dev/char");
let dev_kset = sys_dev_kset(); let dev_kset = sys_dev_kset();
let dev_char_kset = KSet::new("char".to_string()); let dev_char_kset = KSet::new("char".to_string());
let parent = dev_kset.clone() as Arc<dyn KObject>; let parent = dev_kset.clone() as Arc<dyn KObject>;
@ -82,7 +79,7 @@ pub fn devices_init() -> Result<(), SystemError> {
unsafe { set_sys_dev_char_kset(dev_char_kset) }; unsafe { set_sys_dev_char_kset(dev_char_kset) };
} }
kinfo!("devices init success"); info!("devices init success");
return Ok(()); return Ok(());
} }

19
kernel/src/driver/base/device/mod.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::{error, warn};
use crate::{ use crate::{
driver::{ driver::{
@ -139,7 +140,7 @@ pub trait Device: KObject {
/// 设备释放时的回调函数 /// 设备释放时的回调函数
fn release(&self) { fn release(&self) {
let name = self.name(); let name = self.name();
kwarn!( warn!(
"device {} does not have a release() function, it is broken and must be fixed.", "device {} does not have a release() function, it is broken and must be fixed.",
name name
); );
@ -482,7 +483,7 @@ impl DeviceManager {
let actual_parent = self.get_device_parent(&device, current_parent)?; let actual_parent = self.get_device_parent(&device, current_parent)?;
if let Some(actual_parent) = actual_parent { if let Some(actual_parent) = actual_parent {
// kdebug!( // debug!(
// "device '{}' parent is '{}', strong_count: {}", // "device '{}' parent is '{}', strong_count: {}",
// device.name().to_string(), // device.name().to_string(),
// actual_parent.name(), // actual_parent.name(),
@ -492,7 +493,7 @@ impl DeviceManager {
} }
KObjectManager::add_kobj(device.clone() as Arc<dyn KObject>, None).map_err(|e| { KObjectManager::add_kobj(device.clone() as Arc<dyn KObject>, None).map_err(|e| {
kerror!("add device '{:?}' failed: {:?}", device.name(), e); error!("add device '{:?}' failed: {:?}", device.name(), e);
e e
})?; })?;
@ -552,10 +553,10 @@ impl DeviceManager {
device: &Arc<dyn Device>, device: &Arc<dyn Device>,
current_parent: Option<Arc<dyn Device>>, current_parent: Option<Arc<dyn Device>>,
) -> Result<Option<Arc<dyn KObject>>, SystemError> { ) -> Result<Option<Arc<dyn KObject>>, SystemError> {
// kdebug!("get_device_parent() device:{:?}", device.name()); // debug!("get_device_parent() device:{:?}", device.name());
if device.class().is_some() { if device.class().is_some() {
let parent_kobj: Arc<dyn KObject>; let parent_kobj: Arc<dyn KObject>;
// kdebug!("current_parent:{:?}", current_parent); // debug!("current_parent:{:?}", current_parent);
if let Some(cp) = current_parent { if let Some(cp) = current_parent {
if cp.class().is_some() { if cp.class().is_some() {
return Ok(Some(cp.clone() as Arc<dyn KObject>)); return Ok(Some(cp.clone() as Arc<dyn KObject>));
@ -756,7 +757,7 @@ impl DeviceManager {
attr.mode().contains(ModeType::S_IRUGO) attr.mode().contains(ModeType::S_IRUGO)
&& (!attr.support().contains(SysFSOpsSupport::ATTR_SHOW)), && (!attr.support().contains(SysFSOpsSupport::ATTR_SHOW)),
) { ) {
kwarn!( warn!(
"Attribute '{}': read permission without 'show'", "Attribute '{}': read permission without 'show'",
attr.name() attr.name()
); );
@ -765,7 +766,7 @@ impl DeviceManager {
attr.mode().contains(ModeType::S_IWUGO) attr.mode().contains(ModeType::S_IWUGO)
&& (!attr.support().contains(SysFSOpsSupport::ATTR_STORE)), && (!attr.support().contains(SysFSOpsSupport::ATTR_STORE)),
) { ) {
kwarn!( warn!(
"Attribute '{}': write permission without 'store'", "Attribute '{}': write permission without 'store'",
attr.name() attr.name()
); );
@ -807,7 +808,7 @@ impl DeviceManager {
/// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/core.c?fi=device_links_force_bind#1226 /// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/core.c?fi=device_links_force_bind#1226
pub fn device_links_force_bind(&self, _dev: &Arc<dyn Device>) { pub fn device_links_force_bind(&self, _dev: &Arc<dyn Device>) {
kwarn!("device_links_force_bind not implemented"); warn!("device_links_force_bind not implemented");
} }
/// 把device对象的一些结构进行默认初始化 /// 把device对象的一些结构进行默认初始化
@ -872,7 +873,7 @@ impl Attribute for DeviceAttrDev {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| { let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!( error!(
"Intertrait casting not implemented for kobj: {}", "Intertrait casting not implemented for kobj: {}",
kobj.name() kobj.name()
); );

6
kernel/src/driver/base/kobject.rs
View File

@ -6,13 +6,13 @@ use alloc::{
}; };
use driver_base_macros::get_weak_or_clear; use driver_base_macros::get_weak_or_clear;
use intertrait::CastFromSync; use intertrait::CastFromSync;
use log::{debug, error};
use crate::{ use crate::{
filesystem::{ filesystem::{
kernfs::KernFSInode, kernfs::KernFSInode,
sysfs::{sysfs_instance, Attribute, AttributeGroup, SysFSOps, SysFSOpsSupport}, sysfs::{sysfs_instance, Attribute, AttributeGroup, SysFSOps, SysFSOpsSupport},
}, },
kerror,
libs::{ libs::{
casting::DowncastArc, casting::DowncastArc,
rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard}, rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
@ -213,7 +213,7 @@ impl KObjectManager {
} }
kobj.set_parent(None); kobj.set_parent(None);
if e == SystemError::EEXIST { if e == SystemError::EEXIST {
kerror!("KObjectManager::add_kobj() failed with error: {e:?}, kobj:{kobj:?}"); error!("KObjectManager::add_kobj() failed with error: {e:?}, kobj:{kobj:?}");
} }
return Err(e); return Err(e);
@ -269,7 +269,7 @@ pub struct DynamicKObjKType;
impl KObjType for DynamicKObjKType { impl KObjType for DynamicKObjKType {
fn release(&self, kobj: Arc<dyn KObject>) { fn release(&self, kobj: Arc<dyn KObject>) {
kdebug!("DynamicKObjKType::release() kobj:{:?}", kobj.name()); debug!("DynamicKObjKType::release() kobj:{:?}", kobj.name());
} }
fn sysfs_ops(&self) -> Option<&dyn SysFSOps> { fn sysfs_ops(&self) -> Option<&dyn SysFSOps> {

5
kernel/src/driver/base/platform/subsys.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::error;
use super::{platform_device::PlatformDevice, platform_driver::PlatformDriver}; use super::{platform_device::PlatformDevice, platform_driver::PlatformDriver};
use crate::{ use crate::{
@ -58,12 +59,12 @@ impl Bus for PlatformBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> { fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?; let drv = device.driver().ok_or(SystemError::EINVAL)?;
let pdrv = drv.cast::<dyn PlatformDriver>().map_err(|_|{ let pdrv = drv.cast::<dyn PlatformDriver>().map_err(|_|{
kerror!("PlatformBus::probe() failed: device.driver() is not a PlatformDriver. Device: '{:?}'", device.name()); error!("PlatformBus::probe() failed: device.driver() is not a PlatformDriver. Device: '{:?}'", device.name());
SystemError::EINVAL SystemError::EINVAL
})?; })?;
let pdev = device.clone().cast::<dyn PlatformDevice>().map_err(|_| { let pdev = device.clone().cast::<dyn PlatformDevice>().map_err(|_| {
kerror!( error!(
"PlatformBus::probe() failed: device is not a PlatformDevice. Device: '{:?}'", "PlatformBus::probe() failed: device is not a PlatformDevice. Device: '{:?}'",
device.name() device.name()
); );

3
kernel/src/driver/block/cache/cached_block_device.rs vendored
View File

@ -1,5 +1,6 @@
use alloc::{boxed::Box, vec::Vec}; use alloc::{boxed::Box, vec::Vec};
use hashbrown::HashMap; use hashbrown::HashMap;
use log::debug;
use crate::{driver::base::block::block_device::BlockId, libs::rwlock::RwLock}; use crate::{driver::base::block::block_device::BlockId, libs::rwlock::RwLock};
@ -41,7 +42,7 @@ impl BlockCache {
CSPACE = Some(LockedCacheSpace::new(CacheSpace::new())); CSPACE = Some(LockedCacheSpace::new(CacheSpace::new()));
CMAPPER = Some(LockedCacheMapper::new(CacheMapper::new())); CMAPPER = Some(LockedCacheMapper::new(CacheMapper::new()));
} }
kdebug!("BlockCache Initialized!"); debug!("BlockCache Initialized!");
} }
/// # 函数的功能 /// # 函数的功能
/// 使用blockcache进行对块设备进行连续块的读操作 /// 使用blockcache进行对块设备进行连续块的读操作

12
kernel/src/driver/block/virtio_blk.rs
View File

@ -5,6 +5,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::{debug, error};
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
use virtio_drivers::device::blk::VirtIOBlk; use virtio_drivers::device::blk::VirtIOBlk;
@ -63,7 +64,7 @@ pub fn virtio_blk_0() -> Option<Arc<VirtIOBlkDevice>> {
pub fn virtio_blk(transport: VirtIOTransport, dev_id: Arc<DeviceId>) { pub fn virtio_blk(transport: VirtIOTransport, dev_id: Arc<DeviceId>) {
let device = VirtIOBlkDevice::new(transport, dev_id); let device = VirtIOBlkDevice::new(transport, dev_id);
if let Some(device) = device { if let Some(device) = device {
kdebug!("VirtIOBlkDevice '{:?}' created", device.dev_id); debug!("VirtIOBlkDevice '{:?}' created", device.dev_id);
virtio_device_manager() virtio_device_manager()
.device_add(device.clone() as Arc<dyn VirtIODevice>) .device_add(device.clone() as Arc<dyn VirtIODevice>)
.expect("Add virtio blk failed"); .expect("Add virtio blk failed");
@ -89,7 +90,7 @@ impl VirtIOBlkDevice {
let irq = transport.irq().map(|irq| IrqNumber::new(irq.data())); let irq = transport.irq().map(|irq| IrqNumber::new(irq.data()));
let device_inner = VirtIOBlk::<HalImpl, VirtIOTransport>::new(transport); let device_inner = VirtIOBlk::<HalImpl, VirtIOTransport>::new(transport);
if let Err(e) = device_inner { if let Err(e) = device_inner {
kerror!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e); error!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e);
return None; return None;
} }
@ -134,10 +135,9 @@ impl BlockDevice for VirtIOBlkDevice {
.device_inner .device_inner
.read_blocks(lba_id_start, &mut buf[..count * LBA_SIZE]) .read_blocks(lba_id_start, &mut buf[..count * LBA_SIZE])
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"VirtIOBlkDevice '{:?}' read_at_sync failed: {:?}", "VirtIOBlkDevice '{:?}' read_at_sync failed: {:?}",
self.dev_id, self.dev_id, e
e
); );
SystemError::EIO SystemError::EIO
})?; })?;
@ -416,7 +416,7 @@ impl VirtIODriver for VirtIOBlkDriver {
.arc_any() .arc_any()
.downcast::<VirtIOBlkDevice>() .downcast::<VirtIOBlkDevice>()
.map_err(|_| { .map_err(|_| {
kerror!( error!(
"VirtIOBlkDriver::probe() failed: device is not a VirtIO block device. Device: '{:?}'", "VirtIOBlkDriver::probe() failed: device is not a VirtIO block device. Device: '{:?}'",
device.name() device.name()
); );

15
kernel/src/driver/clocksource/acpi_pm.rs
View File

@ -15,6 +15,7 @@ use acpi::fadt::Fadt;
use alloc::sync::{Arc, Weak}; use alloc::sync::{Arc, Weak};
use core::intrinsics::unlikely; use core::intrinsics::unlikely;
use core::sync::atomic::{AtomicU32, Ordering}; use core::sync::atomic::{AtomicU32, Ordering};
use log::info;
use system_error::SystemError; use system_error::SystemError;
// 参考：https://code.dragonos.org.cn/xref/linux-6.6.21/drivers/clocksource/acpi_pm.c // 参考：https://code.dragonos.org.cn/xref/linux-6.6.21/drivers/clocksource/acpi_pm.c
@ -170,6 +171,8 @@ const PMTMR_EXPECTED_RATE: u64 =
#[cfg(not(target_arch = "x86_64"))] #[cfg(not(target_arch = "x86_64"))]
#[allow(dead_code)] #[allow(dead_code)]
fn verify_pmtmr_rate() -> bool { fn verify_pmtmr_rate() -> bool {
use log::info;
let mut count: u32 = 0; let mut count: u32 = 0;
mach_prepare_counter(); mach_prepare_counter();
@ -179,7 +182,7 @@ fn verify_pmtmr_rate() -> bool {
let delta = (value2 - value1) & ACPI_PM_MASK; let delta = (value2 - value1) & ACPI_PM_MASK;
if (delta < (PMTMR_EXPECTED_RATE * 19) / 20) || (delta > (PMTMR_EXPECTED_RATE * 21) / 20) { if (delta < (PMTMR_EXPECTED_RATE * 19) / 20) || (delta > (PMTMR_EXPECTED_RATE * 21) / 20) {
kinfo!( info!(
"PM Timer running at invalid rate: {}", "PM Timer running at invalid rate: {}",
100 * delta / PMTMR_EXPECTED_RATE 100 * delta / PMTMR_EXPECTED_RATE
); );
@ -209,7 +212,7 @@ fn find_acpi_pm_clock() -> Result<(), SystemError> {
PMTMR_IO_PORT.store(pmtmr_addr as u32, Ordering::SeqCst); PMTMR_IO_PORT.store(pmtmr_addr as u32, Ordering::SeqCst);
kinfo!( info!(
"apic_pmtmr I/O port: {}", "apic_pmtmr I/O port: {}",
PMTMR_IO_PORT.load(Ordering::SeqCst) PMTMR_IO_PORT.load(Ordering::SeqCst)
); );
@ -257,14 +260,14 @@ pub fn init_acpi_pm_clocksource() -> Result<(), SystemError> {
if (value2 < value1) && (value2 < 0xfff) { if (value2 < value1) && (value2 < 0xfff) {
break; break;
} }
kinfo!("PM Timer had inconsistens results: {} {}", value1, value2); info!("PM Timer had inconsistens results: {} {}", value1, value2);
PMTMR_IO_PORT.store(0, Ordering::SeqCst); PMTMR_IO_PORT.store(0, Ordering::SeqCst);
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
if i == ACPI_PM_READ_CHECKS { if i == ACPI_PM_READ_CHECKS {
kinfo!("PM Timer failed consistency check: {}", value1); info!("PM Timer failed consistency check: {}", value1);
PMTMR_IO_PORT.store(0, Ordering::SeqCst); PMTMR_IO_PORT.store(0, Ordering::SeqCst);
@ -289,11 +292,11 @@ pub fn init_acpi_pm_clocksource() -> Result<(), SystemError> {
let acpi_pmtmr = clocksource_acpi_pm() as Arc<dyn Clocksource>; let acpi_pmtmr = clocksource_acpi_pm() as Arc<dyn Clocksource>;
match acpi_pmtmr.register(100, PMTMR_TICKS_PER_SEC as u32) { match acpi_pmtmr.register(100, PMTMR_TICKS_PER_SEC as u32) {
Ok(_) => { Ok(_) => {
kinfo!("ACPI PM Timer registered as clocksource sccessfully"); info!("ACPI PM Timer registered as clocksource sccessfully");
return Ok(()); return Ok(());
} }
Err(_) => { Err(_) => {
kinfo!("ACPI PM Timer init registered failed"); info!("ACPI PM Timer init registered failed");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
}; };

2
kernel/src/driver/clocksource/timer_riscv.rs
View File

@ -49,7 +49,7 @@ impl RiscVSbiTimer {
fn handle_irq(trap_frame: &mut TrapFrame) -> Result<(), SystemError> { fn handle_irq(trap_frame: &mut TrapFrame) -> Result<(), SystemError> {
// 更新下一次中断时间 // 更新下一次中断时间
// kdebug!( // debug!(
// "riscv_sbi_timer: handle_irq: cpu_id: {}, time: {}", // "riscv_sbi_timer: handle_irq: cpu_id: {}, time: {}",
// smp_get_processor_id().data(), // smp_get_processor_id().data(),
// CurrentTimeArch::get_cycles() as u64 // CurrentTimeArch::get_cycles() as u64

24
kernel/src/driver/disk/ahci/ahcidisk.rs
View File

@ -13,16 +13,14 @@ use crate::driver::disk::ahci::HBA_PxIS_TFES;
use crate::filesystem::kernfs::KernFSInode; use crate::filesystem::kernfs::KernFSInode;
use crate::filesystem::mbr::MbrDiskPartionTable; use crate::filesystem::mbr::MbrDiskPartionTable;
use crate::driver::disk::ahci::hba::{
FisRegH2D, FisType, HbaCmdHeader, ATA_CMD_READ_DMA_EXT, ATA_CMD_WRITE_DMA_EXT, ATA_DEV_BUSY,
ATA_DEV_DRQ,
};
use crate::libs::rwlock::{RwLockReadGuard, RwLockWriteGuard}; use crate::libs::rwlock::{RwLockReadGuard, RwLockWriteGuard};
use crate::libs::spinlock::SpinLock; use crate::libs::spinlock::SpinLock;
use crate::mm::{phys_2_virt, verify_area, VirtAddr}; use crate::mm::{phys_2_virt, verify_area, VirtAddr};
use crate::{ use log::error;
driver::disk::ahci::hba::{
FisRegH2D, FisType, HbaCmdHeader, ATA_CMD_READ_DMA_EXT, ATA_CMD_WRITE_DMA_EXT,
ATA_DEV_BUSY, ATA_DEV_DRQ,
},
kerror,
};
use system_error::SystemError; use system_error::SystemError;
use alloc::sync::Weak; use alloc::sync::Weak;
@ -70,7 +68,7 @@ impl AhciDisk {
compiler_fence(Ordering::SeqCst); compiler_fence(Ordering::SeqCst);
let check_length = ((count - 1) >> 4) + 1; // prdt length let check_length = ((count - 1) >> 4) + 1; // prdt length
if count * 512 > buf.len() || check_length > 8_usize { if count * 512 > buf.len() || check_length > 8_usize {
kerror!("ahci read: e2big"); error!("ahci read: e2big");
// 不可能的操作 // 不可能的操作
return Err(SystemError::E2BIG); return Err(SystemError::E2BIG);
} else if count == 0 { } else if count == 0 {
@ -130,7 +128,7 @@ impl AhciDisk {
// 清空整个table的旧数据 // 清空整个table的旧数据
write_bytes(cmdtbl, 0, 1); write_bytes(cmdtbl, 0, 1);
} }
// kdebug!("cmdheader.prdtl={}", volatile_read!(cmdheader.prdtl)); // debug!("cmdheader.prdtl={}", volatile_read!(cmdheader.prdtl));
// 8K bytes (16 sectors) per PRDT // 8K bytes (16 sectors) per PRDT
for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) { for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) {
@ -181,19 +179,19 @@ impl AhciDisk {
} }
if spin_count == SPIN_LIMIT { if spin_count == SPIN_LIMIT {
kerror!("Port is hung"); error!("Port is hung");
return Err(SystemError::EIO); return Err(SystemError::EIO);
} }
volatile_set_bit!(port.ci, 1 << slot, true); // Issue command volatile_set_bit!(port.ci, 1 << slot, true); // Issue command
// kdebug!("To wait ahci read complete."); // debug!("To wait ahci read complete.");
// 等待操作完成 // 等待操作完成
loop { loop {
if (volatile_read!(port.ci) & (1 << slot)) == 0 { if (volatile_read!(port.ci) & (1 << slot)) == 0 {
break; break;
} }
if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
kerror!("Read disk error"); error!("Read disk error");
return Err(SystemError::EIO); return Err(SystemError::EIO);
} }
} }
@ -336,7 +334,7 @@ impl AhciDisk {
break; break;
} }
if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 { if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
kerror!("Write disk error"); error!("Write disk error");
return Err(SystemError::EIO); return Err(SystemError::EIO);
} }
} }

26
kernel/src/driver/disk/ahci/mod.rs
View File

@ -10,21 +10,19 @@ use crate::driver::pci::pci::{
get_pci_device_structure_mut, PciDeviceStructure, PCI_DEVICE_LINKEDLIST, get_pci_device_structure_mut, PciDeviceStructure, PCI_DEVICE_LINKEDLIST,
}; };
use crate::filesystem::devfs::devfs_register; use crate::filesystem::devfs::devfs_register;
use crate::kerror;
use crate::driver::disk::ahci::{
ahcidisk::LockedAhciDisk,
hba::HbaMem,
hba::{HbaPort, HbaPortType},
};
use crate::libs::rwlock::RwLockWriteGuard; use crate::libs::rwlock::RwLockWriteGuard;
use crate::libs::spinlock::{SpinLock, SpinLockGuard}; use crate::libs::spinlock::{SpinLock, SpinLockGuard};
use crate::mm::virt_2_phys; use crate::mm::virt_2_phys;
use crate::{
driver::disk::ahci::{
ahcidisk::LockedAhciDisk,
hba::HbaMem,
hba::{HbaPort, HbaPortType},
},
kdebug,
};
use ahci_inode::LockedAhciInode; use ahci_inode::LockedAhciInode;
use alloc::{boxed::Box, collections::LinkedList, format, string::String, sync::Arc, vec::Vec}; use alloc::{boxed::Box, collections::LinkedList, format, string::String, sync::Arc, vec::Vec};
use core::sync::atomic::compiler_fence; use core::sync::atomic::compiler_fence;
use log::{debug, error};
use system_error::SystemError; use system_error::SystemError;
// 仅module内可见 全局数据区 hbr_port, disks // 仅module内可见 全局数据区 hbr_port, disks
@ -90,13 +88,13 @@ pub fn ahci_init() -> Result<(), SystemError> {
let tp = hba_mem_port.check_type(); let tp = hba_mem_port.check_type();
match tp { match tp {
HbaPortType::None => { HbaPortType::None => {
kdebug!("<ahci_rust_init> Find a None type Disk."); debug!("<ahci_rust_init> Find a None type Disk.");
} }
HbaPortType::Unknown(err) => { HbaPortType::Unknown(err) => {
kdebug!("<ahci_rust_init> Find a Unknown({:?}) type Disk.", err); debug!("<ahci_rust_init> Find a Unknown({:?}) type Disk.", err);
} }
_ => { _ => {
kdebug!("<ahci_rust_init> Find a {:?} type Disk.", tp); debug!("<ahci_rust_init> Find a {:?} type Disk.", tp);
// 计算地址 // 计算地址
let fb = virt_2_phys(ahci_port_base_vaddr + (32 << 10) + (j << 8)); let fb = virt_2_phys(ahci_port_base_vaddr + (32 << 10) + (j << 8));
@ -122,7 +120,7 @@ pub fn ahci_init() -> Result<(), SystemError> {
)?); )?);
id += 1; // ID 从0开始 id += 1; // ID 从0开始
kdebug!("start register ahci device"); debug!("start register ahci device");
// 挂载到devfs上面去 // 挂载到devfs上面去
let ret = devfs_register( let ret = devfs_register(
@ -130,7 +128,7 @@ pub fn ahci_init() -> Result<(), SystemError> {
LockedAhciInode::new(disks_list.last().unwrap().clone()), LockedAhciInode::new(disks_list.last().unwrap().clone()),
); );
if let Err(err) = ret { if let Err(err) = ret {
kerror!( error!(
"Ahci_{} ctrl = {}, port = {} failed to register, error code = {:?}", "Ahci_{} ctrl = {}, port = {} failed to register, error code = {:?}",
id, id,
hba_mem_index as u8, hba_mem_index as u8,

5
kernel/src/driver/firmware/efi/fdt.rs
View File

@ -3,6 +3,7 @@
use core::fmt::Debug; use core::fmt::Debug;
use fdt::Fdt; use fdt::Fdt;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::init::boot_params; use crate::init::boot_params;
@ -117,7 +118,7 @@ impl EFIManager {
) )
} }
.map_err(|e| { .map_err(|e| {
kerror!("failed to parse fdt, err={:?}", e); error!("failed to parse fdt, err={:?}", e);
SystemError::EINVAL SystemError::EINVAL
})?; })?;
@ -145,7 +146,7 @@ impl EFIManager {
self.do_get_fdt_prop(prop_type, &prop, &mut ret) self.do_get_fdt_prop(prop_type, &prop, &mut ret)
.unwrap_or_else(|e| { .unwrap_or_else(|e| {
kerror!("Failed to get fdt prop: {prop_type:?}, error: {e:?}"); error!("Failed to get fdt prop: {prop_type:?}, error: {e:?}");
}) })
} }
} }

31
kernel/src/driver/firmware/efi/init.rs
View File

@ -1,5 +1,6 @@
use core::{hint::spin_loop, intrinsics::unlikely, mem::size_of}; use core::{hint::spin_loop, intrinsics::unlikely, mem::size_of};
use log::{error, info, warn};
use system_error::SystemError; use system_error::SystemError;
use uefi_raw::table::boot::{MemoryAttribute, MemoryType}; use uefi_raw::table::boot::{MemoryAttribute, MemoryType};
@ -21,17 +22,17 @@ use super::efi_manager;
#[allow(dead_code)] #[allow(dead_code)]
#[inline(never)] #[inline(never)]
pub fn efi_init() { pub fn efi_init() {
kinfo!("Initializing efi..."); info!("Initializing efi...");
let data_from_fdt = efi_manager() let data_from_fdt = efi_manager()
.get_fdt_params() .get_fdt_params()
.expect("Failed to get fdt params"); .expect("Failed to get fdt params");
if data_from_fdt.systable.is_none() { if data_from_fdt.systable.is_none() {
kerror!("Failed to get systable from fdt"); error!("Failed to get systable from fdt");
return; return;
} }
// kdebug!("to map memory table"); // debug!("to map memory table");
// 映射mmap table // 映射mmap table
if efi_manager().memmap_init_early(&data_from_fdt).is_err() { if efi_manager().memmap_init_early(&data_from_fdt).is_err() {
@ -39,23 +40,23 @@ pub fn efi_init() {
// 那么 UEFI memory map 就是我们拥有的关于内存的唯一描述， // 那么 UEFI memory map 就是我们拥有的关于内存的唯一描述，
// 所以如果我们无法访问它，那么继续进行下去就没有什么意义了 // 所以如果我们无法访问它，那么继续进行下去就没有什么意义了
kerror!("Failed to initialize early memory map"); error!("Failed to initialize early memory map");
loop { loop {
spin_loop(); spin_loop();
} }
} }
// kdebug!("NNNN"); // debug!("NNNN");
// kwarn!("BBBB, e:{:?}", SystemError::EINVAL); // warn!("BBBB, e:{:?}", SystemError::EINVAL);
let desc_version = efi_manager().desc_version(); let desc_version = efi_manager().desc_version();
if unlikely(desc_version != 1) { if unlikely(desc_version != 1) {
kwarn!("Unexpected EFI memory map version: {}", desc_version); warn!("Unexpected EFI memory map version: {}", desc_version);
} }
let r = uefi_init(PhysAddr::new(data_from_fdt.systable.unwrap() as usize)); let r = uefi_init(PhysAddr::new(data_from_fdt.systable.unwrap() as usize));
if let Err(e) = r { if let Err(e) = r {
kerror!("Failed to initialize UEFI: {:?}", e); error!("Failed to initialize UEFI: {:?}", e);
efi_manager().efi_memmap_unmap(); efi_manager().efi_memmap_unmap();
return; return;
} }
@ -97,7 +98,7 @@ pub fn efi_init() {
// todo: Initialize screen info // todo: Initialize screen info
kinfo!("UEFI init done!"); info!("UEFI init done!");
} }
fn efi_find_mirror() { fn efi_find_mirror() {
@ -117,7 +118,7 @@ fn efi_find_mirror() {
} }
if mirror_size > 0 { if mirror_size > 0 {
kinfo!( info!(
"Memory: {}M/{}M mirrored memory", "Memory: {}M/{}M mirrored memory",
mirror_size >> 20, mirror_size >> 20,
total_size >> 20 total_size >> 20
@ -133,7 +134,7 @@ fn uefi_init(system_table: PhysAddr) -> Result<(), SystemError> {
let err_unmap_systable = |st_vaddr: VirtAddr| { let err_unmap_systable = |st_vaddr: VirtAddr| {
EarlyIoRemap::unmap(st_vaddr) EarlyIoRemap::unmap(st_vaddr)
.map_err(|e| { .map_err(|e| {
kerror!("Failed to unmap system table: {e:?}"); error!("Failed to unmap system table: {e:?}");
}) })
.ok(); .ok();
}; };
@ -143,7 +144,7 @@ fn uefi_init(system_table: PhysAddr) -> Result<(), SystemError> {
let st_size = size_of::<uefi_raw::table::system::SystemTable>(); let st_size = size_of::<uefi_raw::table::system::SystemTable>();
let st_vaddr = EarlyIoRemap::map_not_aligned(system_table, st_size, true).map_err(|e| { let st_vaddr = EarlyIoRemap::map_not_aligned(system_table, st_size, true).map_err(|e| {
kwarn!("Unable to map EFI system table, e:{e:?}"); warn!("Unable to map EFI system table, e:{e:?}");
e e
})?; })?;
@ -195,7 +196,7 @@ fn uefi_init(system_table: PhysAddr) -> Result<(), SystemError> {
true, true,
) )
.map_err(|e| { .map_err(|e| {
kwarn!("Unable to map EFI configuration table, e:{e:?}"); warn!("Unable to map EFI configuration table, e:{e:?}");
err_unmap_systable(st_vaddr); err_unmap_systable(st_vaddr);
e e
})?; })?;
@ -265,11 +266,11 @@ fn reserve_memory_regions() {
let phys_start = page_align_down(md.phys_start as usize); let phys_start = page_align_down(md.phys_start as usize);
let size = (page_count << (MMArch::PAGE_SHIFT as u64)) as usize; let size = (page_count << (MMArch::PAGE_SHIFT as u64)) as usize;
// kdebug!("Reserve memory region: {:#x}-{:#x}({:#x}), is_memory: {}, is_usable_memory:{}, type: {:?}, att: {:?}", phys_start, phys_start + size, page_count, md.is_memory(), md.is_usable_memory(), md.ty, md.att); // debug!("Reserve memory region: {:#x}-{:#x}({:#x}), is_memory: {}, is_usable_memory:{}, type: {:?}, att: {:?}", phys_start, phys_start + size, page_count, md.is_memory(), md.is_usable_memory(), md.ty, md.att);
if md.is_memory() { if md.is_memory() {
open_firmware_fdt_driver().early_init_dt_add_memory(phys_start as u64, size as u64); open_firmware_fdt_driver().early_init_dt_add_memory(phys_start as u64, size as u64);
if !md.is_usable_memory() { if !md.is_usable_memory() {
// kdebug!( // debug!(
// "Marking non-usable memory as nomap: {:#x}-{:#x}", // "Marking non-usable memory as nomap: {:#x}-{:#x}",
// phys_start, // phys_start,
// phys_start + size // phys_start + size

5
kernel/src/driver/firmware/efi/memmap.rs
View File

@ -1,5 +1,6 @@
use core::{intrinsics::unlikely, mem::size_of}; use core::{intrinsics::unlikely, mem::size_of};
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -110,7 +111,7 @@ impl EFIManager {
let offset = paddr.data() - page_align_down(paddr.data()); let offset = paddr.data() - page_align_down(paddr.data());
let map_size = data.mmap_size.unwrap() as usize + offset; let map_size = data.mmap_size.unwrap() as usize + offset;
// kdebug!("do_efi_memmap_init: map_size={map_size:#x}"); // debug!("do_efi_memmap_init: map_size={map_size:#x}");
// 映射内存 // 映射内存
let mut vaddr = EarlyIoRemap::map( let mut vaddr = EarlyIoRemap::map(
@ -130,7 +131,7 @@ impl EFIManager {
} }
if inner_guard.mmap.vaddr.is_none() { if inner_guard.mmap.vaddr.is_none() {
kerror!("Cannot map the EFI memory map!"); error!("Cannot map the EFI memory map!");
return Err(SystemError::ENOMEM); return Err(SystemError::ENOMEM);
} }

8
kernel/src/driver/firmware/efi/mod.rs
View File

@ -1,3 +1,4 @@
use log::{error, warn};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -90,15 +91,14 @@ impl EFIManager {
min_major: u16, min_major: u16,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
if header.signature != uefi_raw::table::system::SystemTable::SIGNATURE { if header.signature != uefi_raw::table::system::SystemTable::SIGNATURE {
kerror!("System table signature mismatch!"); error!("System table signature mismatch!");
return Err(SystemError::EINVAL); return Err(SystemError::EINVAL);
} }
if header.revision.major() < min_major { if header.revision.major() < min_major {
kwarn!( warn!(
"System table version: {:?}, expected {}.00 or greater!", "System table version: {:?}, expected {}.00 or greater!",
header.revision, header.revision, min_major
min_major
); );
} }

21
kernel/src/driver/firmware/efi/tables.rs
View File

@ -1,6 +1,7 @@
use core::{ffi::CStr, mem::size_of}; use core::{ffi::CStr, mem::size_of};
use hashbrown::Equivalent; use hashbrown::Equivalent;
use log::{debug, error, info, warn};
use system_error::SystemError; use system_error::SystemError;
use uefi_raw::table::{ use uefi_raw::table::{
boot::{MemoryAttribute, MemoryType}, boot::{MemoryAttribute, MemoryType},
@ -66,16 +67,16 @@ impl EFIManager {
} }
EarlyIoRemap::unmap(fw_ptr).map_err(|e|{ EarlyIoRemap::unmap(fw_ptr).map_err(|e|{
kerror!("report systable header: failed to unmap systable header, fw_ptr: {fw_ptr:?}, err: {e:?}"); error!("report systable header: failed to unmap systable header, fw_ptr: {fw_ptr:?}, err: {e:?}");
e e
}).ok(); }).ok();
} else { } else {
kwarn!("report systable header: failed to map systable header, err: {fw_ptr:?}"); warn!("report systable header: failed to map systable header, err: {fw_ptr:?}");
} }
let s = CStr::from_bytes_with_nul(&tmp_buf) let s = CStr::from_bytes_with_nul(&tmp_buf)
.unwrap_or_else(|_| CStr::from_bytes_with_nul(b"Unknown\0").unwrap()); .unwrap_or_else(|_| CStr::from_bytes_with_nul(b"Unknown\0").unwrap());
kinfo!("EFI version: {:?}, vendor: {:?}", header.revision, s); info!("EFI version: {:?}, vendor: {:?}", header.revision, s);
} }
/// 解析EFI config table /// 解析EFI config table
@ -86,7 +87,7 @@ impl EFIManager {
if let Some(r) = parser.match_table(table) { if let Some(r) = parser.match_table(table) {
// 有匹配结果 // 有匹配结果
if let Err(e) = r { if let Err(e) = r {
kwarn!( warn!(
"Failed to parse cfg table: '{}', err: {e:?}", "Failed to parse cfg table: '{}', err: {e:?}",
parser.table.name() parser.table.name()
); );
@ -97,7 +98,7 @@ impl EFIManager {
} }
if !flag { if !flag {
kwarn!("Cannot find parser for guid: {:?}", table.vendor_guid); warn!("Cannot find parser for guid: {:?}", table.vendor_guid);
} }
} }
@ -107,7 +108,7 @@ impl EFIManager {
while !prev_paddr.is_null() { while !prev_paddr.is_null() {
let vaddr = EarlyIoRemap::map_not_aligned(prev_paddr, MMArch::PAGE_SIZE, true) let vaddr = EarlyIoRemap::map_not_aligned(prev_paddr, MMArch::PAGE_SIZE, true)
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"Failed to map UEFI memreserve table, paddr: {prev_paddr:?}, err: {e:?}" "Failed to map UEFI memreserve table, paddr: {prev_paddr:?}, err: {e:?}"
); );
@ -129,7 +130,7 @@ impl EFIManager {
+ size_of::<LinuxEFIMemReserveEntry>() * psize, + size_of::<LinuxEFIMemReserveEntry>() * psize,
) )
.map_err(|e| { .map_err(|e| {
kerror!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}"); error!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}");
EarlyIoRemap::unmap(vaddr).unwrap(); EarlyIoRemap::unmap(vaddr).unwrap();
e e
})?; })?;
@ -146,7 +147,7 @@ impl EFIManager {
mem_block_manager() mem_block_manager()
.reserve_block(PhysAddr::new(entry.base), entry.size) .reserve_block(PhysAddr::new(entry.base), entry.size)
.map_err(|e| { .map_err(|e| {
kerror!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}"); error!("Failed to reserve block, paddr: {prev_paddr:?}, err: {e:?}");
EarlyIoRemap::unmap(vaddr).unwrap(); EarlyIoRemap::unmap(vaddr).unwrap();
e e
})?; })?;
@ -344,7 +345,7 @@ impl MatchTable for MatchTableMemReserve {
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
efi_manager().inner.write_irqsave().memreserve_table_paddr = efi_manager().inner.write_irqsave().memreserve_table_paddr =
Some(PhysAddr::new(table_raw.vendor_table as usize)); Some(PhysAddr::new(table_raw.vendor_table as usize));
kdebug!( debug!(
"memreserve_table_paddr: {:#x}", "memreserve_table_paddr: {:#x}",
table_raw.vendor_table as usize table_raw.vendor_table as usize
); );
@ -374,7 +375,7 @@ impl MatchTable for MatchTableEsrt {
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
efi_manager().inner.write_irqsave().esrt_table_paddr = efi_manager().inner.write_irqsave().esrt_table_paddr =
Some(PhysAddr::new(table_raw.vendor_table as usize)); Some(PhysAddr::new(table_raw.vendor_table as usize));
kdebug!("esrt_table_paddr: {:#x}", table_raw.vendor_table as usize); debug!("esrt_table_paddr: {:#x}", table_raw.vendor_table as usize);
return Ok(()); return Ok(());
} }
} }

9
kernel/src/driver/input/ps2_mouse/ps_mouse_device.rs
View File

@ -6,6 +6,7 @@ use alloc::{
vec::Vec, vec::Vec,
}; };
use kdepends::ringbuffer::{AllocRingBuffer, RingBuffer}; use kdepends::ringbuffer::{AllocRingBuffer, RingBuffer};
use log::{debug, error};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -229,7 +230,7 @@ impl Ps2MouseDevice {
self.send_command_to_ps2mouse(PsMouseCommand::EnablePacketStreaming) self.send_command_to_ps2mouse(PsMouseCommand::EnablePacketStreaming)
.map_err(|e| { .map_err(|e| {
kerror!("ps2 mouse init error: {:?}", e); error!("ps2 mouse init error: {:?}", e);
e e
})?; })?;
self.read_data_port().ok(); self.read_data_port().ok();
@ -313,7 +314,7 @@ impl Ps2MouseDevice {
guard.current_state.y = self.get_y_movement(packet, flags); guard.current_state.y = self.get_y_movement(packet, flags);
} }
// kdebug!( // debug!(
// "Ps2MouseDevice packet : flags:{}, x:{}, y:{}\n", // "Ps2MouseDevice packet : flags:{}, x:{}, y:{}\n",
// guard.current_state.flags.bits, // guard.current_state.flags.bits,
// guard.current_state.x, // guard.current_state.x,
@ -664,7 +665,7 @@ impl IndexNode for Ps2MouseDevice {
impl Ps2Device for Ps2MouseDevice {} impl Ps2Device for Ps2MouseDevice {}
pub fn rs_ps2_mouse_device_init(parent: Arc<dyn KObject>) -> Result<(), SystemError> { pub fn rs_ps2_mouse_device_init(parent: Arc<dyn KObject>) -> Result<(), SystemError> {
kdebug!("ps2_mouse_device initializing..."); debug!("ps2_mouse_device initializing...");
let psmouse = Arc::new(Ps2MouseDevice::new()); let psmouse = Arc::new(Ps2MouseDevice::new());
device_manager().device_default_initialize(&(psmouse.clone() as Arc<dyn Device>)); device_manager().device_default_initialize(&(psmouse.clone() as Arc<dyn Device>));
@ -672,7 +673,7 @@ pub fn rs_ps2_mouse_device_init(parent: Arc<dyn KObject>) -> Result<(), SystemEr
serio_device_manager().register_port(psmouse.clone() as Arc<dyn SerioDevice>)?; serio_device_manager().register_port(psmouse.clone() as Arc<dyn SerioDevice>)?;
devfs_register(&psmouse.name(), psmouse.clone()).map_err(|e| { devfs_register(&psmouse.name(), psmouse.clone()).map_err(|e| {
kerror!( error!(
"register psmouse device '{}' to devfs failed: {:?}", "register psmouse device '{}' to devfs failed: {:?}",
psmouse.name(), psmouse.name(),
e e

5
kernel/src/driver/input/ps2_mouse/ps_mouse_driver.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -276,10 +277,10 @@ impl SerioDriver for Ps2MouseDriver {
#[unified_init(INITCALL_DEVICE)] #[unified_init(INITCALL_DEVICE)]
fn ps2_mouse_driver_init() -> Result<(), SystemError> { fn ps2_mouse_driver_init() -> Result<(), SystemError> {
kdebug!("Ps2_mouse_drive initializing..."); debug!("Ps2_mouse_drive initializing...");
let driver = Ps2MouseDriver::new(); let driver = Ps2MouseDriver::new();
serio_driver_manager().register(driver.clone())?; serio_driver_manager().register(driver.clone())?;
unsafe { PS2_MOUSE_DRIVER = Some(driver) }; unsafe { PS2_MOUSE_DRIVER = Some(driver) };
kdebug!("Ps2_mouse_drive initialized!"); debug!("Ps2_mouse_drive initialized!");
return Ok(()); return Ok(());
} }

3
kernel/src/driver/input/serio/i8042/mod.rs
View File

@ -1,4 +1,5 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use log::debug;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -33,7 +34,7 @@ pub fn i8042_platform_device() -> Arc<I8042PlatformDevice> {
// TODO: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/input/serio/i8042.c#1612 // TODO: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/input/serio/i8042.c#1612
#[unified_init(INITCALL_DEVICE)] #[unified_init(INITCALL_DEVICE)]
pub fn i8042_init() -> Result<(), SystemError> { pub fn i8042_init() -> Result<(), SystemError> {
kdebug!("i8042 initializing..."); debug!("i8042 initializing...");
let i8042_device = Arc::new(I8042PlatformDevice::new()); let i8042_device = Arc::new(I8042PlatformDevice::new());
device_manager().device_default_initialize(&(i8042_device.clone() as Arc<dyn Device>)); device_manager().device_default_initialize(&(i8042_device.clone() as Arc<dyn Device>));
platform_device_manager().device_add(i8042_device.clone() as Arc<dyn PlatformDevice>)?; platform_device_manager().device_add(i8042_device.clone() as Arc<dyn PlatformDevice>)?;

5
kernel/src/driver/input/serio/subsys.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -59,7 +60,7 @@ impl Bus for SerioBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> { fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?; let drv = device.driver().ok_or(SystemError::EINVAL)?;
let pdrv = drv.cast::<dyn SerioDriver>().map_err(|_| { let pdrv = drv.cast::<dyn SerioDriver>().map_err(|_| {
kerror!( error!(
"SerioBus::probe() failed: device.driver() is not a SerioDriver. Device: '{:?}'", "SerioBus::probe() failed: device.driver() is not a SerioDriver. Device: '{:?}'",
device.name() device.name()
); );
@ -67,7 +68,7 @@ impl Bus for SerioBus {
})?; })?;
let pdev = device.clone().cast::<dyn SerioDevice>().map_err(|_| { let pdev = device.clone().cast::<dyn SerioDevice>().map_err(|_| {
kerror!( error!(
"SerioBus::probe() failed: device is not a SerioDevice. Device: '{:?}'", "SerioBus::probe() failed: device is not a SerioDevice. Device: '{:?}'",
device.name() device.name()
); );

5
kernel/src/driver/irqchip/riscv_intc.rs
View File

@ -1,4 +1,5 @@
use alloc::{string::ToString, sync::Arc}; use alloc::{string::ToString, sync::Arc};
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -155,7 +156,7 @@ pub unsafe fn riscv_intc_init() -> Result<(), SystemError> {
RiscvIntcChip::IRQ_SIZE, RiscvIntcChip::IRQ_SIZE,
) )
.ok_or_else(|| { .ok_or_else(|| {
kerror!("Failed to create riscv-intc domain"); error!("Failed to create riscv-intc domain");
SystemError::ENXIO SystemError::ENXIO
})?; })?;
@ -197,7 +198,7 @@ pub fn riscv_intc_assicate_irq(hwirq: HardwareIrqNumber) -> Option<IrqNumber> {
irq_domain_manager() irq_domain_manager()
.domain_associate( .domain_associate(
riscv_intc_domain().as_ref().or_else(|| { riscv_intc_domain().as_ref().or_else(|| {
kerror!("riscv_intc_domain is None"); error!("riscv_intc_domain is None");
None None
})?, })?,
virq, virq,

35
kernel/src/driver/irqchip/riscv_sifive_plic.rs
View File

@ -25,6 +25,7 @@ use alloc::{
}; };
use bitmap::AllocBitmap; use bitmap::AllocBitmap;
use fdt::node::FdtNode; use fdt::node::FdtNode;
use log::{debug, warn};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -187,7 +188,7 @@ impl PlicHandler {
fn plic_irq_toggle(cpumask: &CpuMask, irq_data: &Arc<IrqData>, enable: bool) { fn plic_irq_toggle(cpumask: &CpuMask, irq_data: &Arc<IrqData>, enable: bool) {
cpumask.iter_cpu().for_each(|cpu| { cpumask.iter_cpu().for_each(|cpu| {
kdebug!("plic: irq_toggle: cpu: {cpu:?}"); debug!("plic: irq_toggle: cpu: {cpu:?}");
let handler = unsafe { plic_handlers().force_get(cpu) }; let handler = unsafe { plic_handlers().force_get(cpu) };
handler.toggle(irq_data.hardware_irq(), enable); handler.toggle(irq_data.hardware_irq(), enable);
}); });
@ -240,7 +241,7 @@ impl IrqChip for PlicIrqChip {
"SiFive PLIC" "SiFive PLIC"
} }
fn irq_enable(&self, irq_data: &Arc<IrqData>) -> Result<(), SystemError> { fn irq_enable(&self, irq_data: &Arc<IrqData>) -> Result<(), SystemError> {
// kwarn!("plic: irq_enable"); // warn!("plic: irq_enable");
let common_data = irq_data.common_data(); let common_data = irq_data.common_data();
let inner_guard = common_data.inner(); let inner_guard = common_data.inner();
let mask = inner_guard.effective_affinity(); let mask = inner_guard.effective_affinity();
@ -252,7 +253,7 @@ impl IrqChip for PlicIrqChip {
} }
fn irq_unmask(&self, irq_data: &Arc<IrqData>) -> Result<(), SystemError> { fn irq_unmask(&self, irq_data: &Arc<IrqData>) -> Result<(), SystemError> {
// kwarn!("plic: irq_unmask"); // warn!("plic: irq_unmask");
let chip_data = irq_data let chip_data = irq_data
.chip_info_read_irqsave() .chip_info_read_irqsave()
@ -300,7 +301,7 @@ impl IrqChip for PlicIrqChip {
} }
fn irq_disable(&self, irq_data: &Arc<IrqData>) { fn irq_disable(&self, irq_data: &Arc<IrqData>) {
kdebug!("plic: irq_disable"); debug!("plic: irq_disable");
let common_data = irq_data.common_data(); let common_data = irq_data.common_data();
let inner_guard = common_data.inner(); let inner_guard = common_data.inner();
let mask = inner_guard.effective_affinity(); let mask = inner_guard.effective_affinity();
@ -321,7 +322,7 @@ impl IrqChip for PlicIrqChip {
handler.toggle(irq_data.hardware_irq(), false); handler.toggle(irq_data.hardware_irq(), false);
} else { } else {
// kdebug!("plic: irq_eoi: hwirq: {:?}", irq_data.hardware_irq()); // debug!("plic: irq_eoi: hwirq: {:?}", irq_data.hardware_irq());
unsafe { unsafe {
write_volatile( write_volatile(
(handler.inner().hart_base + PlicIrqChip::CONTEXT_CLAIM).data() as *mut u32, (handler.inner().hart_base + PlicIrqChip::CONTEXT_CLAIM).data() as *mut u32,
@ -423,7 +424,7 @@ pub fn riscv_sifive_plic_init() -> Result<(), SystemError> {
}); });
for node in all_plics { for node in all_plics {
if let Err(e) = do_riscv_sifive_plic_init(&node) { if let Err(e) = do_riscv_sifive_plic_init(&node) {
kwarn!("Failed to init SiFive PLIC: node: {node:?} {e:?}"); warn!("Failed to init SiFive PLIC: node: {node:?} {e:?}");
} }
} }
@ -457,7 +458,7 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
.ok_or(SystemError::EINVAL)? .ok_or(SystemError::EINVAL)?
.as_usize() .as_usize()
.ok_or(SystemError::EINVAL)?; .ok_or(SystemError::EINVAL)?;
kdebug!( debug!(
"plic: node: {}, irq_num: {irq_num}, paddr: {paddr:?}, size: {size}", "plic: node: {}, irq_num: {irq_num}, paddr: {paddr:?}, size: {size}",
fdt_node.name fdt_node.name
); );
@ -465,7 +466,7 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
.interrupts_extended() .interrupts_extended()
.ok_or(SystemError::EINVAL)? .ok_or(SystemError::EINVAL)?
.count(); .count();
kdebug!("plic: nr_contexts: {nr_contexts}"); debug!("plic: nr_contexts: {nr_contexts}");
let irq_domain = irq_domain_manager() let irq_domain = irq_domain_manager()
.create_and_add_linear( .create_and_add_linear(
@ -474,7 +475,7 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
(irq_num + 1) as u32, (irq_num + 1) as u32,
) )
.ok_or(SystemError::EINVAL)?; .ok_or(SystemError::EINVAL)?;
// kdebug!("plic: irq_domain: {irq_domain:?}"); // debug!("plic: irq_domain: {irq_domain:?}");
let priv_data = PlicChipData::new( let priv_data = PlicChipData::new(
Arc::downgrade(&irq_domain), Arc::downgrade(&irq_domain),
@ -506,13 +507,13 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
let cpu = ProcessorId::new(i as u32); let cpu = ProcessorId::new(i as u32);
let handler = unsafe { plic_handlers().force_get(cpu) }; let handler = unsafe { plic_handlers().force_get(cpu) };
if handler.present() { if handler.present() {
kwarn!("plic: handler {i} already present."); warn!("plic: handler {i} already present.");
handler.set_threshold(PlicIrqChip::PLIC_ENABLE_THRESHOLD); handler.set_threshold(PlicIrqChip::PLIC_ENABLE_THRESHOLD);
loop_done_setup(handler); loop_done_setup(handler);
continue; continue;
} }
kdebug!("plic: setup lmask {cpu:?}."); debug!("plic: setup lmask {cpu:?}.");
priv_data.lmask().set(cpu, true); priv_data.lmask().set(cpu, true);
let mut handler_inner = handler.inner(); let mut handler_inner = handler.inner();
handler_inner.hart_base = handler_inner.hart_base =
@ -560,7 +561,7 @@ fn associate_irq_with_plic_domain(
let irq = irq as u32; let irq = irq as u32;
let virq = IrqNumber::new(irq); let virq = IrqNumber::new(irq);
let hwirq = HardwareIrqNumber::new(irq); let hwirq = HardwareIrqNumber::new(irq);
kdebug!("plic: associate irq: {irq}, virq: {virq:?}, hwirq: {hwirq:?}"); debug!("plic: associate irq: {irq}, virq: {virq:?}, hwirq: {hwirq:?}");
irq_domain_manager() irq_domain_manager()
.domain_associate(irq_domain, virq, hwirq) .domain_associate(irq_domain, virq, hwirq)
.ok(); .ok();
@ -583,7 +584,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
hwirq: HardwareIrqNumber, hwirq: HardwareIrqNumber,
virq: IrqNumber, virq: IrqNumber,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
// kdebug!("plic: map: virq: {virq:?}, hwirq: {hwirq:?}"); // debug!("plic: map: virq: {virq:?}, hwirq: {hwirq:?}");
let chip_data = irq_domain.host_data().ok_or(SystemError::EINVAL)?; let chip_data = irq_domain.host_data().ok_or(SystemError::EINVAL)?;
let plic_chip_data = chip_data let plic_chip_data = chip_data
@ -613,7 +614,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
_irq_data: &Arc<IrqData>, _irq_data: &Arc<IrqData>,
_reserve: bool, _reserve: bool,
) -> Result<(), SystemError> { ) -> Result<(), SystemError> {
kwarn!("plic: activate"); warn!("plic: activate");
loop {} loop {}
} }
@ -622,7 +623,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
/// 处理PLIC中断 /// 处理PLIC中断
pub(super) fn do_plic_irq(trap_frame: &mut TrapFrame) { pub(super) fn do_plic_irq(trap_frame: &mut TrapFrame) {
// kdebug!("plic: do_plic_irq"); // debug!("plic: do_plic_irq");
let handler = plic_handlers().get(); let handler = plic_handlers().get();
let priv_data = handler.priv_data(); let priv_data = handler.priv_data();
@ -648,11 +649,11 @@ pub(super) fn do_plic_irq(trap_frame: &mut TrapFrame) {
if claim == 0 { if claim == 0 {
break; break;
} }
kdebug!("plic: claim: {claim:?}"); debug!("plic: claim: {claim:?}");
let hwirq = HardwareIrqNumber::new(claim); let hwirq = HardwareIrqNumber::new(claim);
if let Err(e) = GenericIrqHandler::handle_domain_irq(domain.clone(), hwirq, trap_frame) { if let Err(e) = GenericIrqHandler::handle_domain_irq(domain.clone(), hwirq, trap_frame) {
kwarn!("plic: can't find mapping for hwirq {hwirq:?}, {e:?}"); warn!("plic: can't find mapping for hwirq {hwirq:?}, {e:?}");
} }
} }
} }

15
kernel/src/driver/net/e1000e/e1000e.rs
View File

@ -9,6 +9,7 @@ use core::mem::size_of;
use core::ptr::NonNull; use core::ptr::NonNull;
use core::slice::{from_raw_parts, from_raw_parts_mut}; use core::slice::{from_raw_parts, from_raw_parts_mut};
use core::sync::atomic::{compiler_fence, Ordering}; use core::sync::atomic::{compiler_fence, Ordering};
use log::{debug, info};
use super::e1000e_driver::e1000e_driver_init; use super::e1000e_driver::e1000e_driver_init;
use crate::driver::base::device::DeviceId; use crate::driver::base::device::DeviceId;
@ -23,8 +24,6 @@ use crate::exception::IrqNumber;
use crate::libs::volatile::{ReadOnly, Volatile, WriteOnly}; use crate::libs::volatile::{ReadOnly, Volatile, WriteOnly};
use crate::{kdebug, kinfo};
const PAGE_SIZE: usize = 4096; const PAGE_SIZE: usize = 4096;
const NETWORK_CLASS: u8 = 0x2; const NETWORK_CLASS: u8 = 0x2;
const ETHERNET_SUBCLASS: u8 = 0x0; const ETHERNET_SUBCLASS: u8 = 0x0;
@ -284,7 +283,7 @@ impl E1000EDevice {
volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_SLU); volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_SLU);
} }
let status = unsafe { volread!(general_regs, status) }; let status = unsafe { volread!(general_regs, status) };
kdebug!("Status: {status:#X}"); debug!("Status: {status:#X}");
// 读取设备的mac地址 // 读取设备的mac地址
// Read mac address // Read mac address
@ -442,7 +441,7 @@ impl E1000EDevice {
buffer.set_length(desc.len as usize); buffer.set_length(desc.len as usize);
rdt = index; rdt = index;
unsafe { volwrite!(self.receive_regs, rdt0, rdt as u32) }; unsafe { volwrite!(self.receive_regs, rdt0, rdt as u32) };
// kdebug!("e1000e: receive packet"); // debug!("e1000e: receive packet");
return Some(buffer); return Some(buffer);
} }
@ -559,7 +558,7 @@ impl Drop for E1000EDevice {
fn drop(&mut self) { fn drop(&mut self) {
// 释放已分配的所有dma页 // 释放已分配的所有dma页
// free all dma pages we have allocated // free all dma pages we have allocated
kdebug!("droping..."); debug!("droping...");
let recv_ring_length = PAGE_SIZE / size_of::<E1000ERecvDesc>(); let recv_ring_length = PAGE_SIZE / size_of::<E1000ERecvDesc>();
let trans_ring_length = PAGE_SIZE / size_of::<E1000ETransDesc>(); let trans_ring_length = PAGE_SIZE / size_of::<E1000ETransDesc>();
unsafe { unsafe {
@ -590,10 +589,10 @@ impl Drop for E1000EDevice {
pub fn e1000e_init() { pub fn e1000e_init() {
match e1000e_probe() { match e1000e_probe() {
Ok(_code) => { Ok(_code) => {
kinfo!("Successfully init e1000e device!"); info!("Successfully init e1000e device!");
} }
Err(_error) => { Err(_error) => {
kinfo!("Error occurred!"); info!("Error occurred!");
} }
} }
} }
@ -610,7 +609,7 @@ pub fn e1000e_probe() -> Result<u64, E1000EPciError> {
if header.vendor_id == 0x8086 { if header.vendor_id == 0x8086 {
// intel // intel
if E1000E_DEVICE_ID.contains(&header.device_id) { if E1000E_DEVICE_ID.contains(&header.device_id) {
kdebug!( debug!(
"Detected e1000e PCI device with device id {:#x}", "Detected e1000e PCI device with device id {:#x}",
header.device_id header.device_id
); );

4
kernel/src/driver/net/e1000e/e1000e_driver.rs
View File

@ -10,7 +10,6 @@ use crate::{
}, },
net::NetDevice, net::NetDevice,
}, },
kinfo,
libs::spinlock::SpinLock, libs::spinlock::SpinLock,
net::{generate_iface_id, NET_DEVICES}, net::{generate_iface_id, NET_DEVICES},
time::Instant, time::Instant,
@ -24,6 +23,7 @@ use core::{
fmt::Debug, fmt::Debug,
ops::{Deref, DerefMut}, ops::{Deref, DerefMut},
}; };
use log::info;
use smoltcp::{ use smoltcp::{
phy, phy,
wire::{self, HardwareAddress}, wire::{self, HardwareAddress},
@ -367,5 +367,5 @@ pub fn e1000e_driver_init(device: E1000EDevice) {
NET_DEVICES NET_DEVICES
.write_irqsave() .write_irqsave()
.insert(iface.nic_id(), iface.clone()); .insert(iface.nic_id(), iface.clone());
kinfo!("e1000e driver init successfully!\tMAC: [{}]", mac); info!("e1000e driver init successfully!\tMAC: [{}]", mac);
} }

16
kernel/src/driver/net/virtio_net.rs
View File

@ -10,6 +10,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::{debug, error};
use smoltcp::{iface, phy, wire}; use smoltcp::{iface, phy, wire};
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
use virtio_drivers::device::net::VirtIONet; use virtio_drivers::device::net::VirtIONet;
@ -39,7 +40,6 @@ use crate::{
exception::{irqdesc::IrqReturn, IrqNumber}, exception::{irqdesc::IrqReturn, IrqNumber},
filesystem::kernfs::KernFSInode, filesystem::kernfs::KernFSInode,
init::initcall::INITCALL_POSTCORE, init::initcall::INITCALL_POSTCORE,
kerror,
libs::{ libs::{
rwlock::{RwLockReadGuard, RwLockWriteGuard}, rwlock::{RwLockReadGuard, RwLockWriteGuard},
spinlock::{SpinLock, SpinLockGuard}, spinlock::{SpinLock, SpinLockGuard},
@ -357,12 +357,12 @@ impl phy::Device for VirtIONicDeviceInner {
} }
fn transmit(&mut self, _timestamp: smoltcp::time::Instant) -> Option<Self::TxToken<'_>> { fn transmit(&mut self, _timestamp: smoltcp::time::Instant) -> Option<Self::TxToken<'_>> {
// kdebug!("VirtioNet: transmit"); // debug!("VirtioNet: transmit");
if self.inner.lock_irqsave().can_send() { if self.inner.lock_irqsave().can_send() {
// kdebug!("VirtioNet: can send"); // debug!("VirtioNet: can send");
return Some(VirtioNetToken::new(self.clone(), None)); return Some(VirtioNetToken::new(self.clone(), None));
} else { } else {
// kdebug!("VirtioNet: can not send"); // debug!("VirtioNet: can not send");
return None; return None;
} }
} }
@ -418,14 +418,14 @@ pub fn virtio_net(transport: VirtIOTransport, dev_id: Arc<DeviceId>) {
match VirtIONet::<HalImpl, VirtIOTransport, 2>::new(transport, 4096) { match VirtIONet::<HalImpl, VirtIOTransport, 2>::new(transport, 4096) {
Ok(net) => net, Ok(net) => net,
Err(_) => { Err(_) => {
kerror!("VirtIONet init failed"); error!("VirtIONet init failed");
return; return;
} }
}; };
let mac = wire::EthernetAddress::from_bytes(&driver_net.mac_address()); let mac = wire::EthernetAddress::from_bytes(&driver_net.mac_address());
let dev_inner = VirtIONicDeviceInner::new(driver_net); let dev_inner = VirtIONicDeviceInner::new(driver_net);
let iface = VirtioInterface::new(dev_inner, dev_id); let iface = VirtioInterface::new(dev_inner, dev_id);
kdebug!("To add virtio net: {}, mac: {}", iface.device_name(), mac); debug!("To add virtio net: {}, mac: {}", iface.device_name(), mac);
virtio_device_manager() virtio_device_manager()
.device_add(iface.clone() as Arc<dyn VirtIODevice>) .device_add(iface.clone() as Arc<dyn VirtIODevice>)
.expect("Add virtio net failed"); .expect("Add virtio net failed");
@ -471,7 +471,7 @@ impl NetDevice for VirtioInterface {
let mut guard = self.iface.lock(); let mut guard = self.iface.lock();
let poll_res = guard.poll(timestamp, self.device_inner.force_get_mut(), sockets); let poll_res = guard.poll(timestamp, self.device_inner.force_get_mut(), sockets);
// todo: notify!!! // todo: notify!!!
// kdebug!("Virtio Interface poll:{poll_res}"); // debug!("Virtio Interface poll:{poll_res}");
if poll_res { if poll_res {
return Ok(()); return Ok(());
} }
@ -596,7 +596,7 @@ impl VirtIODriver for VirtIONetDriver {
.arc_any() .arc_any()
.downcast::<VirtioInterface>() .downcast::<VirtioInterface>()
.map_err(|_| { .map_err(|_| {
kerror!( error!(
"VirtIONetDriver::probe() failed: device is not a VirtioInterface. Device: '{:?}'", "VirtIONetDriver::probe() failed: device is not a VirtioInterface. Device: '{:?}'",
device.name() device.name()
); );

41
kernel/src/driver/open_firmware/fdt.rs
View File

@ -4,6 +4,7 @@ use fdt::{
node::{FdtNode, NodeProperty}, node::{FdtNode, NodeProperty},
Fdt, Fdt,
}; };
use log::{debug, error, warn};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -79,7 +80,7 @@ impl OpenFirmwareFdtDriver {
let fdt_vaddr = boot_params().read().fdt().ok_or(SystemError::ENODEV)?; let fdt_vaddr = boot_params().read().fdt().ok_or(SystemError::ENODEV)?;
let fdt: Fdt<'_> = unsafe { let fdt: Fdt<'_> = unsafe {
fdt::Fdt::from_ptr(fdt_vaddr.as_ptr()).map_err(|e| { fdt::Fdt::from_ptr(fdt_vaddr.as_ptr()).map_err(|e| {
kerror!("failed to parse fdt, err={:?}", e); error!("failed to parse fdt, err={:?}", e);
SystemError::EINVAL SystemError::EINVAL
}) })
}?; }?;
@ -91,7 +92,7 @@ impl OpenFirmwareFdtDriver {
.expect("Failed to scan fdt root node."); .expect("Failed to scan fdt root node.");
self.early_init_scan_chosen(fdt).unwrap_or_else(|_| { self.early_init_scan_chosen(fdt).unwrap_or_else(|_| {
kwarn!("No `chosen` node found"); warn!("No `chosen` node found");
}); });
self.early_init_scan_memory(fdt); self.early_init_scan_memory(fdt);
@ -106,13 +107,13 @@ impl OpenFirmwareFdtDriver {
if let Some(prop) = node.property("#size-cells") { if let Some(prop) = node.property("#size-cells") {
guard.root_size_cells = prop.as_usize().unwrap() as u32; guard.root_size_cells = prop.as_usize().unwrap() as u32;
// kdebug!("fdt_root_size_cells={}", guard.root_size_cells); // debug!("fdt_root_size_cells={}", guard.root_size_cells);
} }
if let Some(prop) = node.property("#address-cells") { if let Some(prop) = node.property("#address-cells") {
guard.root_addr_cells = prop.as_usize().unwrap() as u32; guard.root_addr_cells = prop.as_usize().unwrap() as u32;
// kdebug!("fdt_root_addr_cells={}", guard.root_addr_cells); // debug!("fdt_root_addr_cells={}", guard.root_addr_cells);
} }
return Ok(()); return Ok(());
@ -144,7 +145,7 @@ impl OpenFirmwareFdtDriver {
// TODO: 拼接内核自定义的command line参数 // TODO: 拼接内核自定义的command line参数
kdebug!("Command line: {}", boot_params().read().boot_cmdline_str()); debug!("Command line: {}", boot_params().read().boot_cmdline_str());
return Ok(()); return Ok(());
} }
@ -194,7 +195,7 @@ impl OpenFirmwareFdtDriver {
continue; continue;
} }
kdebug!("Found memory: base={:#x}, size={:#x}", base, size); debug!("Found memory: base={:#x}, size={:#x}", base, size);
self.early_init_dt_add_memory(base, size); self.early_init_dt_add_memory(base, size);
found_memory = true; found_memory = true;
} }
@ -205,7 +206,7 @@ impl OpenFirmwareFdtDriver {
#[cfg(target_arch = "x86_64")] #[cfg(target_arch = "x86_64")]
pub fn early_init_dt_add_memory(&self, _base: u64, _size: u64) { pub fn early_init_dt_add_memory(&self, _base: u64, _size: u64) {
kBUG!("x86_64 should not call early_init_dt_add_memory"); panic!("x86_64 should not call early_init_dt_add_memory");
} }
#[cfg(not(target_arch = "x86_64"))] #[cfg(not(target_arch = "x86_64"))]
@ -220,7 +221,7 @@ impl OpenFirmwareFdtDriver {
let mut size = size as usize; let mut size = size as usize;
if size < (MMArch::PAGE_SIZE - (base & (!MMArch::PAGE_MASK))) { if size < (MMArch::PAGE_SIZE - (base & (!MMArch::PAGE_MASK))) {
kwarn!("Ignoring memory block {:#x}-{:#x}", base, base + size); warn!("Ignoring memory block {:#x}-{:#x}", base, base + size);
} }
if PhysAddr::new(base).check_aligned(MMArch::PAGE_SIZE) == false { if PhysAddr::new(base).check_aligned(MMArch::PAGE_SIZE) == false {
@ -231,11 +232,11 @@ impl OpenFirmwareFdtDriver {
size = page_align_down(size); size = page_align_down(size);
if base > MemBlockManager::MAX_MEMBLOCK_ADDR.data() { if base > MemBlockManager::MAX_MEMBLOCK_ADDR.data() {
kwarn!("Ignoring memory block {:#x}-{:#x}", base, base + size); warn!("Ignoring memory block {:#x}-{:#x}", base, base + size);
} }
if base + size - 1 > MemBlockManager::MAX_MEMBLOCK_ADDR.data() { if base + size - 1 > MemBlockManager::MAX_MEMBLOCK_ADDR.data() {
kwarn!( warn!(
"Ignoring memory range {:#x}-{:#x}", "Ignoring memory range {:#x}-{:#x}",
MemBlockManager::MAX_MEMBLOCK_ADDR.data() + 1, MemBlockManager::MAX_MEMBLOCK_ADDR.data() + 1,
base + size base + size
@ -244,13 +245,13 @@ impl OpenFirmwareFdtDriver {
} }
if base + size < MemBlockManager::MIN_MEMBLOCK_ADDR.data() { if base + size < MemBlockManager::MIN_MEMBLOCK_ADDR.data() {
kwarn!("Ignoring memory range {:#x}-{:#x}", base, base + size); warn!("Ignoring memory range {:#x}-{:#x}", base, base + size);
return; return;
} }
if base < MemBlockManager::MIN_MEMBLOCK_ADDR.data() { if base < MemBlockManager::MIN_MEMBLOCK_ADDR.data() {
{ {
kwarn!( warn!(
"Ignoring memory range {:#x}-{:#x}", "Ignoring memory range {:#x}-{:#x}",
base, base,
MemBlockManager::MIN_MEMBLOCK_ADDR.data() MemBlockManager::MIN_MEMBLOCK_ADDR.data()
@ -312,7 +313,7 @@ impl OpenFirmwareFdtDriver {
if node.size() != 0 { if node.size() != 0 {
let address = PhysAddr::new(node.address() as usize); let address = PhysAddr::new(node.address() as usize);
let size = node.size(); let size = node.size();
kdebug!("Reserve memory: {:?}-{:?}", address, address + size); debug!("Reserve memory: {:?}-{:?}", address, address + size);
mem_block_manager().reserve_block(address, size).unwrap(); mem_block_manager().reserve_block(address, size).unwrap();
} }
} }
@ -406,7 +407,7 @@ fn reserved_mem_reserve_reg(node: &FdtNode<'_, '_>) -> Result<(), SystemError> {
let mut reg_size = reg.value.len(); let mut reg_size = reg.value.len();
if reg_size > 0 && reg_size % t_len != 0 { if reg_size > 0 && reg_size % t_len != 0 {
kerror!( error!(
"Reserved memory: invalid reg property in '{}', skipping node.", "Reserved memory: invalid reg property in '{}', skipping node.",
node.name node.name
); );
@ -431,18 +432,14 @@ fn reserved_mem_reserve_reg(node: &FdtNode<'_, '_>) -> Result<(), SystemError> {
.early_init_dt_reserve_memory(PhysAddr::new(base as usize), size as usize, nomap) .early_init_dt_reserve_memory(PhysAddr::new(base as usize), size as usize, nomap)
.is_ok() .is_ok()
{ {
kdebug!( debug!(
"Reserved memory: base={:#x}, size={:#x}, nomap={}", "Reserved memory: base={:#x}, size={:#x}, nomap={}",
base, base, size, nomap
size,
nomap
); );
} else { } else {
kerror!( error!(
"Failed to reserve memory: base={:#x}, size={:#x}, nomap={}", "Failed to reserve memory: base={:#x}, size={:#x}, nomap={}",
base, base, size, nomap
size,
nomap
); );
} }

9
kernel/src/driver/pci/attr.rs
View File

@ -1,5 +1,6 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -50,7 +51,7 @@ impl Attribute for Vendor {
let dev = _kobj let dev = _kobj
.cast::<dyn PciDevice>() .cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| { .map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e); warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL SystemError::EINVAL
})?; })?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.vendor())); return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.vendor()));
@ -81,7 +82,7 @@ impl Attribute for DeviceID {
let dev = _kobj let dev = _kobj
.cast::<dyn PciDevice>() .cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| { .map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e); warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL SystemError::EINVAL
})?; })?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.device_id())); return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.device_id()));
@ -112,7 +113,7 @@ impl Attribute for SubsystemVendor {
let dev = _kobj let dev = _kobj
.cast::<dyn PciDevice>() .cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| { .map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e); warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL SystemError::EINVAL
})?; })?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.subsystem_vendor())); return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.subsystem_vendor()));
@ -143,7 +144,7 @@ impl Attribute for SubsystemDevice {
let dev = _kobj let dev = _kobj
.cast::<dyn PciDevice>() .cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| { .map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e); warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL SystemError::EINVAL
})?; })?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.subsystem_device())); return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.subsystem_device()));

6
kernel/src/driver/pci/ecam.rs
View File

@ -1,3 +1,5 @@
use log::{error, warn};
use crate::mm::PhysAddr; use crate::mm::PhysAddr;
use super::{ use super::{
@ -56,13 +58,13 @@ impl EcamRootInfoManager {
); );
if let Err(err) = root { if let Err(err) = root {
kerror!("add_ecam_root_info(): failed to create PciRoot: {:?}", err); error!("add_ecam_root_info(): failed to create PciRoot: {:?}", err);
return; return;
} }
pci_root_manager().add_pci_root(root.unwrap()); pci_root_manager().add_pci_root(root.unwrap());
} else { } else {
kwarn!( warn!(
"add_ecam_root_info(): root {} already exists", "add_ecam_root_info(): root {} already exists",
ecam_root_info.segement_group_number ecam_root_info.segement_group_number
); );

56
kernel/src/driver/pci/pci.rs
View File

@ -14,12 +14,13 @@ use crate::libs::rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard};
use crate::mm::mmio_buddy::{mmio_pool, MMIOSpaceGuard}; use crate::mm::mmio_buddy::{mmio_pool, MMIOSpaceGuard};
use crate::mm::VirtAddr; use crate::mm::VirtAddr;
use crate::{kdebug, kerror, kinfo, kwarn};
use alloc::string::String; use alloc::string::String;
use alloc::sync::Arc; use alloc::sync::Arc;
use alloc::vec::Vec; use alloc::vec::Vec;
use alloc::{boxed::Box, collections::LinkedList}; use alloc::{boxed::Box, collections::LinkedList};
use bitflags::bitflags; use bitflags::bitflags;
use log::{debug, error, info, warn};
use core::{ use core::{
convert::TryFrom, convert::TryFrom,
@ -962,7 +963,7 @@ fn pci_read_pci_to_cardbus_bridge_header(
/// @brief 检查所有bus上的设备并将其加入链表 /// @brief 检查所有bus上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因 /// @return 成功返回ok(),失败返回失败原因
fn pci_check_all_buses() -> Result<u8, PciError> { fn pci_check_all_buses() -> Result<u8, PciError> {
kinfo!("Checking all devices in PCI bus..."); info!("Checking all devices in PCI bus...");
let busdevicefunction = BusDeviceFunction { let busdevicefunction = BusDeviceFunction {
bus: 0, bus: 0,
device: 0, device: 0,
@ -981,7 +982,7 @@ fn pci_check_all_buses() -> Result<u8, PciError> {
/// @brief 检查特定设备并将其加入链表 /// @brief 检查特定设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因 /// @return 成功返回ok(),失败返回失败原因
fn pci_check_function(busdevicefunction: BusDeviceFunction) -> Result<u8, PciError> { fn pci_check_function(busdevicefunction: BusDeviceFunction) -> Result<u8, PciError> {
//kdebug!("PCI check function {}", busdevicefunction.function); //debug!("PCI check function {}", busdevicefunction.function);
let header = match pci_read_header(busdevicefunction, true) { let header = match pci_read_header(busdevicefunction, true) {
Ok(header) => header, Ok(header) => header,
Err(PciError::GetWrongHeader) => { Err(PciError::GetWrongHeader) => {
@ -1007,7 +1008,7 @@ fn pci_check_function(busdevicefunction: BusDeviceFunction) -> Result<u8, PciErr
/// @brief 检查device上的设备并将其加入链表 /// @brief 检查device上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因 /// @return 成功返回ok(),失败返回失败原因
fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> { fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
//kdebug!("PCI check device {}", device); //debug!("PCI check device {}", device);
let busdevicefunction = BusDeviceFunction { let busdevicefunction = BusDeviceFunction {
bus, bus,
device, device,
@ -1026,10 +1027,9 @@ fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
pci_check_function(busdevicefunction)?; pci_check_function(busdevicefunction)?;
let common_header = header.common_header(); let common_header = header.common_header();
if common_header.header_type & 0x80 != 0 { if common_header.header_type & 0x80 != 0 {
kdebug!( debug!(
"Detected multi func device in bus{},device{}", "Detected multi func device in bus{},device{}",
busdevicefunction.bus, busdevicefunction.bus, busdevicefunction.device
busdevicefunction.device
); );
// 这是一个多function的设备，因此查询剩余的function // 这是一个多function的设备，因此查询剩余的function
for function in 1..8 { for function in 1..8 {
@ -1046,7 +1046,7 @@ fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
/// @brief 检查该bus上的设备并将其加入链表 /// @brief 检查该bus上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因 /// @return 成功返回ok(),失败返回失败原因
fn pci_check_bus(bus: u8) -> Result<u8, PciError> { fn pci_check_bus(bus: u8) -> Result<u8, PciError> {
//kdebug!("PCI check bus {}", bus); //debug!("PCI check bus {}", bus);
for device in 0..32 { for device in 0..32 {
pci_check_device(bus, device)?; pci_check_device(bus, device)?;
} }
@ -1056,13 +1056,13 @@ fn pci_check_bus(bus: u8) -> Result<u8, PciError> {
/// pci初始化函数 /// pci初始化函数
#[inline(never)] #[inline(never)]
pub fn pci_init() { pub fn pci_init() {
kinfo!("Initializing PCI bus..."); info!("Initializing PCI bus...");
pci_bus_subsys_init().expect("Failed to init pci bus subsystem"); pci_bus_subsys_init().expect("Failed to init pci bus subsystem");
if let Err(e) = pci_check_all_buses() { if let Err(e) = pci_check_all_buses() {
kerror!("pci init failed when checking bus because of error: {}", e); error!("pci init failed when checking bus because of error: {}", e);
return; return;
} }
kinfo!( info!(
"Total pci device and function num = {}", "Total pci device and function num = {}",
PCI_DEVICE_LINKEDLIST.num() PCI_DEVICE_LINKEDLIST.num()
); );
@ -1071,40 +1071,34 @@ pub fn pci_init() {
let common_header = box_pci_device.common_header(); let common_header = box_pci_device.common_header();
match box_pci_device.header_type() { match box_pci_device.header_type() {
HeaderType::Standard if common_header.status & 0x10 != 0 => { HeaderType::Standard if common_header.status & 0x10 != 0 => {
kinfo!("Found pci standard device with class code ={} subclass={} status={:#x} cap_pointer={:#x} vendor={:#x}, device id={:#x},bdf={}", common_header.class_code, common_header.subclass, common_header.status, box_pci_device.as_standard_device().unwrap().capabilities_pointer,common_header.vendor_id, common_header.device_id,common_header.bus_device_function); info!("Found pci standard device with class code ={} subclass={} status={:#x} cap_pointer={:#x} vendor={:#x}, device id={:#x},bdf={}", common_header.class_code, common_header.subclass, common_header.status, box_pci_device.as_standard_device().unwrap().capabilities_pointer,common_header.vendor_id, common_header.device_id,common_header.bus_device_function);
} }
HeaderType::Standard => { HeaderType::Standard => {
kinfo!( info!(
"Found pci standard device with class code ={} subclass={} status={:#x} ", "Found pci standard device with class code ={} subclass={} status={:#x} ",
common_header.class_code, common_header.class_code, common_header.subclass, common_header.status
common_header.subclass,
common_header.status
); );
} }
HeaderType::PciPciBridge if common_header.status & 0x10 != 0 => { HeaderType::PciPciBridge if common_header.status & 0x10 != 0 => {
kinfo!("Found pci-to-pci bridge device with class code ={} subclass={} status={:#x} cap_pointer={:#x}", common_header.class_code, common_header.subclass, common_header.status, box_pci_device.as_pci_to_pci_bridge_device().unwrap().capability_pointer); info!("Found pci-to-pci bridge device with class code ={} subclass={} status={:#x} cap_pointer={:#x}", common_header.class_code, common_header.subclass, common_header.status, box_pci_device.as_pci_to_pci_bridge_device().unwrap().capability_pointer);
} }
HeaderType::PciPciBridge => { HeaderType::PciPciBridge => {
kinfo!( info!(
"Found pci-to-pci bridge device with class code ={} subclass={} status={:#x} ", "Found pci-to-pci bridge device with class code ={} subclass={} status={:#x} ",
common_header.class_code, common_header.class_code, common_header.subclass, common_header.status
common_header.subclass,
common_header.status
); );
} }
HeaderType::PciCardbusBridge => { HeaderType::PciCardbusBridge => {
kinfo!( info!(
"Found pcicardbus bridge device with class code ={} subclass={} status={:#x} ", "Found pcicardbus bridge device with class code ={} subclass={} status={:#x} ",
common_header.class_code, common_header.class_code, common_header.subclass, common_header.status
common_header.subclass,
common_header.status
); );
} }
HeaderType::Unrecognised(_) => {} HeaderType::Unrecognised(_) => {}
} }
} }
kinfo!("PCI bus initialized."); info!("PCI bus initialized.");
} }
/// An identifier for a PCI bus, device and function. /// An identifier for a PCI bus, device and function.
@ -1340,7 +1334,7 @@ pub fn pci_bar_init(
// A wrapping add is necessary to correctly handle the case of unused BARs, which read back // A wrapping add is necessary to correctly handle the case of unused BARs, which read back
// as 0, and should be treated as size 0. // as 0, and should be treated as size 0.
let size = (!(size_mask & 0xfffffff0)).wrapping_add(1); let size = (!(size_mask & 0xfffffff0)).wrapping_add(1);
//kdebug!("bar_orig:{:#x},size: {:#x}", bar_orig,size); //debug!("bar_orig:{:#x},size: {:#x}", bar_orig,size);
// Restore the original value. // Restore the original value.
pci_root_0().write_config( pci_root_0().write_config(
bus_device_function, bus_device_function,
@ -1380,7 +1374,7 @@ pub fn pci_bar_init(
.create_mmio(size_want) .create_mmio(size_want)
.map_err(|_| PciError::CreateMmioError)?; .map_err(|_| PciError::CreateMmioError)?;
space_guard = Arc::new(tmp); space_guard = Arc::new(tmp);
//kdebug!("Pci bar init: mmio space: {space_guard:?}, paddr={paddr:?}, size_want={size_want}"); //debug!("Pci bar init: mmio space: {space_guard:?}, paddr={paddr:?}, size_want={size_want}");
assert!( assert!(
space_guard.map_phys(paddr, size_want).is_ok(), space_guard.map_phys(paddr, size_want).is_ok(),
"pci_bar_init: map_phys failed" "pci_bar_init: map_phys failed"
@ -1416,7 +1410,7 @@ pub fn pci_bar_init(
_ => {} _ => {}
} }
} }
//kdebug!("pci_device_bar:{}", device_bar); //debug!("pci_device_bar:{}", device_bar);
return Ok(device_bar); return Ok(device_bar);
} }
@ -1454,7 +1448,7 @@ impl Iterator for CapabilityIterator {
self.next_capability_offset = if next_offset == 0 { self.next_capability_offset = if next_offset == 0 {
None None
} else if next_offset < 64 || next_offset & 0x3 != 0 { } else if next_offset < 64 || next_offset & 0x3 != 0 {
kwarn!("Invalid next capability offset {:#04x}", next_offset); warn!("Invalid next capability offset {:#04x}", next_offset);
None None
} else { } else {
Some(next_offset) Some(next_offset)
@ -1502,7 +1496,7 @@ impl<'a> Iterator for ExternalCapabilityIterator<'a> {
self.next_capability_offset = if next_offset == 0 { self.next_capability_offset = if next_offset == 0 {
None None
} else if next_offset < 0x100 || next_offset & 0x3 != 0 { } else if next_offset < 0x100 || next_offset & 0x3 != 0 {
kwarn!("Invalid next capability offset {:#04x}", next_offset); warn!("Invalid next capability offset {:#04x}", next_offset);
None None
} else { } else {
Some(next_offset) Some(next_offset)

5
kernel/src/driver/pci/pci_irq.rs
View File

@ -6,6 +6,7 @@ use core::ptr::NonNull;
use alloc::string::String; use alloc::string::String;
use alloc::sync::Arc; use alloc::sync::Arc;
use alloc::vec::Vec; use alloc::vec::Vec;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use super::pci::{PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError}; use super::pci::{PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError};
@ -385,7 +386,7 @@ pub trait PciInterrupt: PciDeviceStructure {
} }
Err(_) => { Err(_) => {
kerror!( error!(
"Failed to request pci irq {} for device {}", "Failed to request pci irq {} for device {}",
irq_num.data(), irq_num.data(),
&common_msg.irq_name &common_msg.irq_name
@ -548,7 +549,7 @@ pub trait PciInterrupt: PciDeviceStructure {
} }
Err(_) => { Err(_) => {
kerror!( error!(
"Failed to request pci irq {} for device {}", "Failed to request pci irq {} for device {}",
irq_num.data(), irq_num.data(),
&common_msg.irq_name &common_msg.irq_name

2
kernel/src/driver/pci/root.rs
View File

@ -91,7 +91,7 @@ impl PciRoot {
/// @brief 完成物理地址到虚拟地址的映射，并将虚拟地址加入mmio_base变量 /// @brief 完成物理地址到虚拟地址的映射，并将虚拟地址加入mmio_base变量
/// @return 返回错误或Ok(0) /// @return 返回错误或Ok(0)
fn map(&mut self) -> Result<u8, PciError> { fn map(&mut self) -> Result<u8, PciError> {
//kdebug!("bus_begin={},bus_end={}", self.bus_begin,self.bus_end); //debug!("bus_begin={},bus_end={}", self.bus_begin,self.bus_end);
let bus_number = (self.bus_end - self.bus_begin) as u32 + 1; let bus_number = (self.bus_end - self.bus_begin) as u32 + 1;
let bus_number_double = (bus_number - 1) / 2 + 1; //一个bus占据1MB空间，计算全部bus占据空间相对于2MB空间的个数 let bus_number_double = (bus_number - 1) / 2 + 1; //一个bus占据1MB空间，计算全部bus占据空间相对于2MB空间的个数

5
kernel/src/driver/pci/subsys.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -89,14 +90,14 @@ impl Bus for PciBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> { fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?; let drv = device.driver().ok_or(SystemError::EINVAL)?;
let pci_drv = drv.cast::<dyn PciDriver>().map_err(|_| { let pci_drv = drv.cast::<dyn PciDriver>().map_err(|_| {
kerror!( error!(
"PciBus::probe() failed: device.driver() is not a PciDriver. Device: '{:?}'", "PciBus::probe() failed: device.driver() is not a PciDriver. Device: '{:?}'",
device.name() device.name()
); );
SystemError::EINVAL SystemError::EINVAL
})?; })?;
let pci_dev = device.clone().cast::<dyn PciDevice>().map_err(|_| { let pci_dev = device.clone().cast::<dyn PciDevice>().map_err(|_| {
kerror!( error!(
"PciBus::probe() failed: device is not a PciDevice. Device: '{:?}'", "PciBus::probe() failed: device is not a PciDevice. Device: '{:?}'",
device.name() device.name()
); );

3
kernel/src/driver/rtc/class.rs
View File

@ -2,6 +2,7 @@ use alloc::{
string::ToString, string::ToString,
sync::{Arc, Weak}, sync::{Arc, Weak},
}; };
use log::info;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -100,7 +101,7 @@ fn rtc_hctosys(dev: &Arc<RtcGeneralDevice>) {
let r = do_settimeofday64(timespec64); let r = do_settimeofday64(timespec64);
dev.set_hc2sys_result(r); dev.set_hc2sys_result(r);
kinfo!( info!(
"Setting system clock to {} {} UTC ({})", "Setting system clock to {} {} UTC ({})",
time.date_string(), time.date_string(),
time.time_string(), time.time_string(),

3
kernel/src/driver/serial/serial8250/mod.rs
View File

@ -8,6 +8,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -410,7 +411,7 @@ impl PlatformDriver for Serial8250ISADriver {
.arc_any() .arc_any()
.downcast::<Serial8250ISADevices>() .downcast::<Serial8250ISADevices>()
.map_err(|_| { .map_err(|_| {
kerror!("Serial8250ISADriver::probe: device is not a Serial8250ISADevices"); error!("Serial8250ISADriver::probe: device is not a Serial8250ISADevices");
SystemError::EINVAL SystemError::EINVAL
})?; })?;
isa_dev.set_driver(Some(self.self_ref.clone())); isa_dev.set_driver(Some(self.self_ref.clone()));

3
kernel/src/driver/tty/tty_driver.rs
View File

@ -6,6 +6,7 @@ use alloc::{
vec::Vec, vec::Vec,
}; };
use hashbrown::HashMap; use hashbrown::HashMap;
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -284,7 +285,7 @@ impl TtyDriver {
Some(tty) => { Some(tty) => {
// TODO: 暂时这么写，因为还没写TtyPort // TODO: 暂时这么写，因为还没写TtyPort
if tty.core().port().is_none() { if tty.core().port().is_none() {
kwarn!("{} port is None", tty.core().name()); warn!("{} port is None", tty.core().name());
} else if tty.core().port().unwrap().state() == TtyPortState::KOPENED { } else if tty.core().port().unwrap().state() == TtyPortState::KOPENED {
return Err(SystemError::EBUSY); return Err(SystemError::EBUSY);
} }

5
kernel/src/driver/tty/virtual_terminal/virtual_console.rs
View File

@ -5,6 +5,7 @@ use alloc::{
vec::Vec, vec::Vec,
}; };
use bitmap::{traits::BitMapOps, StaticBitmap}; use bitmap::{traits::BitMapOps, StaticBitmap};
use log::warn;
use crate::{ use crate::{
driver::{ driver::{
@ -936,7 +937,7 @@ impl VirtualConsoleData {
'c' => { 'c' => {
if self.par[0] == 0 { if self.par[0] == 0 {
kwarn!("respone ID todo"); warn!("respone ID todo");
} }
return; return;
} }
@ -1612,7 +1613,7 @@ impl VirtualConsoleData {
tc |= ((attr as u32) << 8) & (!himask as u32); tc |= ((attr as u32) << 8) & (!himask as u32);
// kwarn!( // warn!(
// "ch {} pos {} x {} y {} cols {}", // "ch {} pos {} x {} y {} cols {}",
// c as u8 as char, // c as u8 as char,
// self.pos, // self.pos,

3
kernel/src/driver/video/fbdev/base/fbcon/framebuffer_console.rs
View File

@ -1,4 +1,5 @@
use alloc::{sync::Arc, vec::Vec}; use alloc::{sync::Arc, vec::Vec};
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -200,7 +201,7 @@ impl ConsoleSwitch for BlittingFbConsole {
vc_data.font.height = font.height; vc_data.font.height = font.height;
vc_data.font.count = font.char_count; vc_data.font.count = font.char_count;
} else { } else {
kwarn!("The frontend Framebuffer is not implemented"); warn!("The frontend Framebuffer is not implemented");
} }
vc_data.color_mode = fb.color_depth() != 1; vc_data.color_mode = fb.color_depth() != 1;

11
kernel/src/driver/video/fbdev/base/fbcon/mod.rs
View File

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -165,7 +166,7 @@ impl KObject for FbConsoleDevice {
fn set_name(&self, _name: String) { fn set_name(&self, _name: String) {
// 不允许修改 // 不允许修改
kwarn!("fbcon name can not be changed"); warn!("fbcon name can not be changed");
} }
fn kobj_state(&self) -> RwLockReadGuard<KObjectState> { fn kobj_state(&self) -> RwLockReadGuard<KObjectState> {
@ -199,7 +200,7 @@ impl Device for FbConsoleDevice {
fn set_class(&self, _class: Option<Weak<dyn Class>>) { fn set_class(&self, _class: Option<Weak<dyn Class>>) {
// 不允许修改 // 不允许修改
kwarn!("fbcon's class can not be changed"); warn!("fbcon's class can not be changed");
} }
fn class(&self) -> Option<Arc<dyn Class>> { fn class(&self) -> Option<Arc<dyn Class>> {
@ -279,13 +280,13 @@ impl Attribute for AttrRotate {
/// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3226 /// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3226
fn show(&self, _kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { fn show(&self, _kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
kwarn!("fbcon rotate show not implemented"); warn!("fbcon rotate show not implemented");
return sysfs_emit_str(buf, "0\n"); return sysfs_emit_str(buf, "0\n");
} }
/// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3182 /// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3182
fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
kwarn!("fbcon rotate store not implemented"); warn!("fbcon rotate store not implemented");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
} }
@ -308,7 +309,7 @@ impl Attribute for AttrRotateAll {
/// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3204 /// https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbcon.c#3204
fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
kwarn!("fbcon rotate_all store not implemented"); warn!("fbcon rotate_all store not implemented");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
} }

3
kernel/src/driver/video/fbdev/base/fbmem.rs
View File

@ -6,6 +6,7 @@ use alloc::{
vec::Vec, vec::Vec,
}; };
use log::error;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -152,7 +153,7 @@ impl FrameBufferManager {
device_manager().add_device(fb_device.clone() as Arc<dyn Device>)?; device_manager().add_device(fb_device.clone() as Arc<dyn Device>)?;
// 添加到devfs // 添加到devfs
devfs_register(&fb_device.name(), fb_device.clone()).map_err(|e| { devfs_register(&fb_device.name(), fb_device.clone()).map_err(|e| {
kerror!( error!(
"register fb device '{}' to devfs failed: {:?}", "register fb device '{}' to devfs failed: {:?}",
fb_device.name(), fb_device.name(),
e e

5
kernel/src/driver/video/fbdev/base/fbsysfs.rs
View File

@ -1,4 +1,5 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -85,7 +86,7 @@ impl Attribute for AttrBitsPerPixel {
} }
fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
kwarn!("attr bits_per_pixel store not implemented"); warn!("attr bits_per_pixel store not implemented");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
@ -116,7 +117,7 @@ impl Attribute for AttrBlank {
// todo: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbsysfs.c#309 // todo: https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/video/fbdev/core/fbsysfs.c#309
fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> { fn store(&self, _kobj: Arc<dyn KObject>, _buf: &[u8]) -> Result<usize, SystemError> {
kwarn!("attr blank store not implemented"); warn!("attr blank store not implemented");
return Err(SystemError::ENOSYS); return Err(SystemError::ENOSYS);
} }
} }

2
kernel/src/driver/video/fbdev/base/mod.rs
View File

@ -341,7 +341,7 @@ pub trait FrameBufferInfo: FrameBufferOps {
// && var.green.offset == var.blue.offset // && var.green.offset == var.blue.offset
// && var.green.offset == var.red.offset // && var.green.offset == var.red.offset
// { // {
// kerror!("return {}", var.green.length); // error!("return {}", var.green.length);
// return var.green.length; // return var.green.length;
// } else { // } else {
// return var.green.length + var.blue.length + var.red.length; // return var.green.length + var.blue.length + var.red.length;

7
kernel/src/driver/video/fbdev/vesafb.rs
View File

@ -9,6 +9,7 @@ use alloc::{
sync::{Arc, Weak}, sync::{Arc, Weak},
vec::Vec, vec::Vec,
}; };
use log::{info, warn};
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -390,7 +391,7 @@ impl FrameBufferOps for VesaFb {
/// ## 填充矩形 /// ## 填充矩形
fn fb_fillrect(&self, rect: super::base::FillRectData) -> Result<(), SystemError> { fn fb_fillrect(&self, rect: super::base::FillRectData) -> Result<(), SystemError> {
// kwarn!("rect {rect:?}"); // warn!("rect {rect:?}");
let boot_param = boot_params().read(); let boot_param = boot_params().read();
let screen_base = boot_param let screen_base = boot_param
@ -1006,7 +1007,7 @@ fn vesa_fb_device_init() -> Result<(), SystemError> {
static INIT: Once = Once::new(); static INIT: Once = Once::new();
INIT.call_once(|| { INIT.call_once(|| {
kinfo!("vesa fb device init"); info!("vesa fb device init");
let device = Arc::new(VesaFb::new()); let device = Arc::new(VesaFb::new());
let mut fb_fix = VESAFB_FIX_INFO.write_irqsave(); let mut fb_fix = VESAFB_FIX_INFO.write_irqsave();
@ -1068,7 +1069,7 @@ fn vesa_fb_device_init() -> Result<(), SystemError> {
// 加入全局fb表 // 加入全局fb表
let mut guard = FRAME_BUFFER_SET.write(); let mut guard = FRAME_BUFFER_SET.write();
if guard.get(device.fb_id().data() as usize).unwrap().is_some() { if guard.get(device.fb_id().data() as usize).unwrap().is_some() {
kwarn!( warn!(
"vesa_fb_device_init: There is already an element {:?} in the FRAME_BUFFER_SET", "vesa_fb_device_init: There is already an element {:?} in the FRAME_BUFFER_SET",
device.fb_id() device.fb_id()
); );

6
kernel/src/driver/video/mod.rs
View File

@ -3,7 +3,6 @@ use core::sync::atomic::{AtomicBool, Ordering};
use crate::{ use crate::{
arch::MMArch, arch::MMArch,
init::boot_params, init::boot_params,
kinfo,
libs::{ libs::{
align::page_align_up, align::page_align_up,
lib_ui::screen_manager::{ScmBuffer, ScmBufferFlag, ScmBufferInfo}, lib_ui::screen_manager::{ScmBuffer, ScmBufferFlag, ScmBufferInfo},
@ -17,6 +16,7 @@ use crate::{
time::timer::{Timer, TimerFunction}, time::timer::{Timer, TimerFunction},
}; };
use alloc::{boxed::Box, sync::Arc}; use alloc::{boxed::Box, sync::Arc};
use log::info;
use system_error::SystemError; use system_error::SystemError;
pub mod console; pub mod console;
@ -78,7 +78,7 @@ impl VideoRefreshManager {
* 将帧缓存区映射到地址SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE处 * 将帧缓存区映射到地址SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE处
*/ */
fn init_frame_buffer(&self) { fn init_frame_buffer(&self) {
kinfo!("Re-mapping VBE frame buffer..."); info!("Re-mapping VBE frame buffer...");
let buf_vaddr = boot_params() let buf_vaddr = boot_params()
.read_irqsave() .read_irqsave()
.screen_info .screen_info
@ -115,7 +115,7 @@ impl VideoRefreshManager {
} }
} }
kinfo!("VBE frame buffer successfully Re-mapped!"); info!("VBE frame buffer successfully Re-mapped!");
} }
/** /**

3
kernel/src/driver/virtio/irq.rs
View File

@ -1,5 +1,6 @@
use alloc::sync::Arc; use alloc::sync::Arc;
use hashbrown::HashMap; use hashbrown::HashMap;
use log::warn;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -120,7 +121,7 @@ impl IrqHandler for DefaultVirtioIrqHandler {
return dev.handle_irq(irq); return dev.handle_irq(irq);
} else { } else {
// 未绑定具体设备，因此无法处理中断 // 未绑定具体设备，因此无法处理中断
kwarn!("No device found for IRQ: {:?}", irq); warn!("No device found for IRQ: {:?}", irq);
return Ok(IrqReturn::NotHandled); return Ok(IrqReturn::NotHandled);
} }
} }

3
kernel/src/driver/virtio/mmio.rs
View File

@ -1,4 +1,5 @@
use fdt::node::FdtNode; use fdt::node::FdtNode;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use crate::driver::{ use crate::driver::{
@ -9,7 +10,7 @@ use super::{transport::VirtIOTransport, virtio::virtio_device_init};
pub(super) fn virtio_probe_mmio() { pub(super) fn virtio_probe_mmio() {
if let Err(e) = do_probe_virtio_mmio() { if let Err(e) = do_probe_virtio_mmio() {
kerror!("virtio_probe_mmio failed: {:?}", e); error!("virtio_probe_mmio failed: {:?}", e);
} }
} }

15
kernel/src/driver/virtio/sysfs.rs
View File

@ -4,6 +4,7 @@ use alloc::{
}; };
use ida::IdAllocator; use ida::IdAllocator;
use intertrait::cast::CastArc; use intertrait::cast::CastArc;
use log::error;
use system_error::SystemError; use system_error::SystemError;
use unified_init::macros::unified_init; use unified_init::macros::unified_init;
@ -78,7 +79,7 @@ impl Bus for VirtIOBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> { fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?; let drv = device.driver().ok_or(SystemError::EINVAL)?;
let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| { let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| {
kerror!( error!(
"VirtIOBus::probe() failed: device.driver() is not a VirtioDriver. Device: '{:?}'", "VirtIOBus::probe() failed: device.driver() is not a VirtioDriver. Device: '{:?}'",
device.name() device.name()
); );
@ -86,7 +87,7 @@ impl Bus for VirtIOBus {
})?; })?;
let virtio_dev = device.clone().cast::<dyn VirtIODevice>().map_err(|_| { let virtio_dev = device.clone().cast::<dyn VirtIODevice>().map_err(|_| {
kerror!( error!(
"VirtIOBus::probe() failed: device is not a VirtIODevice. Device: '{:?}'", "VirtIOBus::probe() failed: device is not a VirtIODevice. Device: '{:?}'",
device.name() device.name()
); );
@ -167,7 +168,7 @@ impl VirtIODeviceManager {
let drv = dev.driver().ok_or(SystemError::EINVAL)?; let drv = dev.driver().ok_or(SystemError::EINVAL)?;
let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| { let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| {
kerror!( error!(
"VirtIODeviceManager::device_add() failed: device.driver() is not a VirtioDriver. Device: '{:?}'", "VirtIODeviceManager::device_add() failed: device.driver() is not a VirtioDriver. Device: '{:?}'",
dev.name() dev.name()
); );
@ -199,7 +200,7 @@ impl VirtIODeviceManager {
IrqHandleFlags::IRQF_SHARED, IrqHandleFlags::IRQF_SHARED,
Some(dev.dev_id().clone()), Some(dev.dev_id().clone()),
) { ) {
kerror!( error!(
"Failed to request irq for virtio device '{}': irq: {:?}, error {:?}", "Failed to request irq for virtio device '{}': irq: {:?}, error {:?}",
dev.device_name(), dev.device_name(),
irq, irq,
@ -211,7 +212,7 @@ impl VirtIODeviceManager {
virtio_irq_manager() virtio_irq_manager()
.register_device(dev.clone()) .register_device(dev.clone())
.map_err(|e| { .map_err(|e| {
kerror!( error!(
"Failed to register virtio device's irq, dev: '{}', irq: {:?}, error {:?}", "Failed to register virtio device's irq, dev: '{}', irq: {:?}, error {:?}",
dev.device_name(), dev.device_name(),
irq, irq,
@ -302,7 +303,7 @@ impl Attribute for AttrDevice {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn VirtIODevice>().map_err(|_| { let dev = kobj.cast::<dyn VirtIODevice>().map_err(|_| {
kerror!("AttrDevice::show() failed: kobj is not a VirtIODevice"); error!("AttrDevice::show() failed: kobj is not a VirtIODevice");
SystemError::EINVAL SystemError::EINVAL
})?; })?;
let device_type_id = dev.device_type_id(); let device_type_id = dev.device_type_id();
@ -329,7 +330,7 @@ impl Attribute for AttrVendor {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> { fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn VirtIODevice>().map_err(|_| { let dev = kobj.cast::<dyn VirtIODevice>().map_err(|_| {
kerror!("AttrVendor::show() failed: kobj is not a VirtIODevice"); error!("AttrVendor::show() failed: kobj is not a VirtIODevice");
SystemError::EINVAL SystemError::EINVAL
})?; })?;
let vendor = dev.vendor(); let vendor = dev.vendor();

5
kernel/src/driver/virtio/transport_mmio.rs
View File

@ -2,6 +2,7 @@ use core::ptr::NonNull;
use alloc::sync::Arc; use alloc::sync::Arc;
use fdt::node::FdtNode; use fdt::node::FdtNode;
use log::info;
use system_error::SystemError; use system_error::SystemError;
use virtio_drivers::transport::{ use virtio_drivers::transport::{
mmio::{MmioTransport, VirtIOHeader}, mmio::{MmioTransport, VirtIOHeader},
@ -54,7 +55,7 @@ impl VirtIOMmioTransport {
match unsafe { MmioTransport::new(header) } { match unsafe { MmioTransport::new(header) } {
Ok(mmio_transport) => { Ok(mmio_transport) => {
kinfo!( "Detected virtio MMIO device with vendor id {:#X}, device type {:?}, version {:?}, hw irq: {}", info!( "Detected virtio MMIO device with vendor id {:#X}, device type {:?}, version {:?}, hw irq: {}",
mmio_transport.vendor_id(), mmio_transport.vendor_id(),
mmio_transport.device_type(), mmio_transport.device_type(),
mmio_transport.version(), mmio_transport.version(),
@ -69,7 +70,7 @@ impl VirtIOMmioTransport {
}) })
} }
Err(_) => { Err(_) => {
// kwarn!("MmioTransport::new failed: {:?}", e); // warn!("MmioTransport::new failed: {:?}", e);
Err(SystemError::EINVAL) Err(SystemError::EINVAL)
} }
} }

4
kernel/src/driver/virtio/transport_pci.rs
View File

@ -211,7 +211,7 @@ impl PciTransport {
notify_off_multiplier, notify_off_multiplier,
)); ));
} }
//kdebug!("notify.offset={},notify.length={}",notify_cfg.offset,notify_cfg.length); //debug!("notify.offset={},notify.length={}",notify_cfg.offset,notify_cfg.length);
let notify_region = get_bar_region_slice::<_>(&device.standard_device_bar, &notify_cfg)?; let notify_region = get_bar_region_slice::<_>(&device.standard_device_bar, &notify_cfg)?;
let isr_status = get_bar_region::<_>( let isr_status = get_bar_region::<_>(
&device.standard_device_bar, &device.standard_device_bar,
@ -532,7 +532,7 @@ fn get_bar_region<T>(
{ {
return Err(VirtioPciError::BarOffsetOutOfRange); return Err(VirtioPciError::BarOffsetOutOfRange);
} }
//kdebug!("Chossed bar ={},used={}",struct_info.bar,struct_info.offset + struct_info.length); //debug!("Chossed bar ={},used={}",struct_info.bar,struct_info.offset + struct_info.length);
let vaddr = (bar_info let vaddr = (bar_info
.virtual_address() .virtual_address()
.ok_or(VirtioPciError::BarGetVaddrFailed)?) .ok_or(VirtioPciError::BarGetVaddrFailed)?)

13
kernel/src/driver/virtio/virtio.rs
View File

@ -10,10 +10,11 @@ use crate::driver::pci::pci::{
}; };
use crate::driver::virtio::transport::VirtIOTransport; use crate::driver::virtio::transport::VirtIOTransport;
use crate::libs::rwlock::RwLockWriteGuard; use crate::libs::rwlock::RwLockWriteGuard;
use crate::{kdebug, kerror, kwarn};
use alloc::sync::Arc; use alloc::sync::Arc;
use alloc::vec::Vec; use alloc::vec::Vec;
use alloc::{boxed::Box, collections::LinkedList}; use alloc::{boxed::Box, collections::LinkedList};
use log::{debug, error, warn};
use virtio_drivers::transport::{DeviceType, Transport}; use virtio_drivers::transport::{DeviceType, Transport};
///@brief 寻找并加载所有virtio设备的驱动（目前只有virtio-net，但其他virtio设备也可添加） ///@brief 寻找并加载所有virtio设备的驱动（目前只有virtio-net，但其他virtio设备也可添加）
@ -32,7 +33,7 @@ fn virtio_probe_pci() {
let dev_id = DeviceId::new(None, Some(format!("{dev_id}"))).unwrap(); let dev_id = DeviceId::new(None, Some(format!("{dev_id}"))).unwrap();
match PciTransport::new::<HalImpl>(virtio_device, dev_id.clone()) { match PciTransport::new::<HalImpl>(virtio_device, dev_id.clone()) {
Ok(mut transport) => { Ok(mut transport) => {
kdebug!( debug!(
"Detected virtio PCI device with device type {:?}, features {:#018x}", "Detected virtio PCI device with device type {:?}, features {:#018x}",
transport.device_type(), transport.device_type(),
transport.read_device_features(), transport.read_device_features(),
@ -41,7 +42,7 @@ fn virtio_probe_pci() {
virtio_device_init(transport, dev_id); virtio_device_init(transport, dev_id);
} }
Err(err) => { Err(err) => {
kerror!("Pci transport create failed because of error: {}", err); error!("Pci transport create failed because of error: {}", err);
} }
} }
} }
@ -52,14 +53,14 @@ pub(super) fn virtio_device_init(transport: VirtIOTransport, dev_id: Arc<DeviceI
match transport.device_type() { match transport.device_type() {
DeviceType::Block => virtio_blk(transport, dev_id), DeviceType::Block => virtio_blk(transport, dev_id),
DeviceType::GPU => { DeviceType::GPU => {
kwarn!("Not support virtio_gpu device for now"); warn!("Not support virtio_gpu device for now");
} }
DeviceType::Input => { DeviceType::Input => {
kwarn!("Not support virtio_input device for now"); warn!("Not support virtio_input device for now");
} }
DeviceType::Network => virtio_net(transport, dev_id), DeviceType::Network => virtio_net(transport, dev_id),
t => { t => {
kwarn!("Unrecognized virtio device: {:?}", t); warn!("Unrecognized virtio device: {:?}", t);
} }
} }
} }

2
kernel/src/driver/virtio/virtio_impl.rs
View File

@ -90,7 +90,7 @@ unsafe impl Hal for HalImpl {
_direction: BufferDirection, _direction: BufferDirection,
) -> virtio_drivers::PhysAddr { ) -> virtio_drivers::PhysAddr {
let vaddr = VirtAddr::new(buffer.as_ptr() as *mut u8 as usize); let vaddr = VirtAddr::new(buffer.as_ptr() as *mut u8 as usize);
//kdebug!("virt:{:x}", vaddr); //debug!("virt:{:x}", vaddr);
// Nothing to do, as the host already has access to all memory. // Nothing to do, as the host already has access to all memory.
return MMArch::virt_2_phys(vaddr).unwrap().data(); return MMArch::virt_2_phys(vaddr).unwrap().data();
} }

23
kernel/src/exception/handle.rs
View File

@ -1,6 +1,7 @@
use core::{intrinsics::unlikely, ops::BitAnd}; use core::{intrinsics::unlikely, ops::BitAnd};
use alloc::sync::Arc; use alloc::sync::Arc;
use log::{debug, error, warn};
use system_error::SystemError; use system_error::SystemError;
use crate::{ use crate::{
@ -100,7 +101,7 @@ impl IrqFlowHandler for EdgeIrqHandler {
fn handle(&self, irq_desc: &Arc<IrqDesc>, _trap_frame: &mut TrapFrame) { fn handle(&self, irq_desc: &Arc<IrqDesc>, _trap_frame: &mut TrapFrame) {
let mut desc_inner_guard: SpinLockGuard<'_, InnerIrqDesc> = irq_desc.inner(); let mut desc_inner_guard: SpinLockGuard<'_, InnerIrqDesc> = irq_desc.inner();
if !irq_may_run(&desc_inner_guard) { if !irq_may_run(&desc_inner_guard) {
// kdebug!("!irq_may_run"); // debug!("!irq_may_run");
desc_inner_guard desc_inner_guard
.internal_state_mut() .internal_state_mut()
.insert(IrqDescState::IRQS_PENDING); .insert(IrqDescState::IRQS_PENDING);
@ -109,7 +110,7 @@ impl IrqFlowHandler for EdgeIrqHandler {
} }
if desc_inner_guard.common_data().disabled() { if desc_inner_guard.common_data().disabled() {
// kdebug!("desc_inner_guard.common_data().disabled()"); // debug!("desc_inner_guard.common_data().disabled()");
desc_inner_guard desc_inner_guard
.internal_state_mut() .internal_state_mut()
.insert(IrqDescState::IRQS_PENDING); .insert(IrqDescState::IRQS_PENDING);
@ -123,7 +124,7 @@ impl IrqFlowHandler for EdgeIrqHandler {
loop { loop {
if unlikely(desc_inner_guard.actions().is_empty()) { if unlikely(desc_inner_guard.actions().is_empty()) {
kdebug!("no action for irq {}", irq_data.irq().data()); debug!("no action for irq {}", irq_data.irq().data());
irq_manager().mask_irq(&irq_data); irq_manager().mask_irq(&irq_data);
return; return;
} }
@ -136,12 +137,12 @@ impl IrqFlowHandler for EdgeIrqHandler {
{ {
let status = desc_inner_guard.common_data().status(); let status = desc_inner_guard.common_data().status();
if !status.disabled() && status.masked() { if !status.disabled() && status.masked() {
// kdebug!("re-enable irq"); // debug!("re-enable irq");
irq_manager().unmask_irq(&desc_inner_guard); irq_manager().unmask_irq(&desc_inner_guard);
} }
} }
// kdebug!("handle_irq_event"); // debug!("handle_irq_event");
desc_inner_guard = handle_irq_event(irq_desc, desc_inner_guard); desc_inner_guard = handle_irq_event(irq_desc, desc_inner_guard);
@ -268,7 +269,7 @@ fn do_handle_irq_event(desc: &Arc<IrqDesc>) -> Result<(), SystemError> {
for action in actions { for action in actions {
let mut action_inner: SpinLockGuard<'_, InnerIrqAction> = action.inner(); let mut action_inner: SpinLockGuard<'_, InnerIrqAction> = action.inner();
// kdebug!("do_handle_irq_event: action: {:?}", action_inner.name()); // debug!("do_handle_irq_event: action: {:?}", action_inner.name());
let dynamic_data = action_inner let dynamic_data = action_inner
.dev_id() .dev_id()
.clone() .clone()
@ -314,17 +315,17 @@ fn cond_unmask_eoi_irq(
&& desc_inner_guard.common_data().masked() && desc_inner_guard.common_data().masked()
&& desc_inner_guard.threads_oneshot() == 0 && desc_inner_guard.threads_oneshot() == 0
{ {
kdebug!( debug!(
"eoi unmask irq {}", "eoi unmask irq {}",
desc_inner_guard.irq_data().irq().data() desc_inner_guard.irq_data().irq().data()
); );
chip.irq_eoi(desc_inner_guard.irq_data()); chip.irq_eoi(desc_inner_guard.irq_data());
unmask_irq(desc_inner_guard.irq_data()); unmask_irq(desc_inner_guard.irq_data());
} else if !chip.flags().contains(IrqChipFlags::IRQCHIP_EOI_THREADED) { } else if !chip.flags().contains(IrqChipFlags::IRQCHIP_EOI_THREADED) {
kdebug!("eoi irq {}", desc_inner_guard.irq_data().irq().data()); debug!("eoi irq {}", desc_inner_guard.irq_data().irq().data());
chip.irq_eoi(desc_inner_guard.irq_data()); chip.irq_eoi(desc_inner_guard.irq_data());
} else { } else {
kwarn!( warn!(
"irq {} eoi failed", "irq {} eoi failed",
desc_inner_guard.irq_data().irq().data() desc_inner_guard.irq_data().irq().data()
); );
@ -340,7 +341,7 @@ fn warn_no_thread(irq: IrqNumber, action_inner: &mut SpinLockGuard<'_, InnerIrqA
return; return;
} }
kwarn!( warn!(
"irq {}, device {} returned IRQ_WAKE_THREAD, but no threaded handler", "irq {}, device {} returned IRQ_WAKE_THREAD, but no threaded handler",
irq.data(), irq.data(),
action_inner.name() action_inner.name()
@ -402,7 +403,7 @@ impl IrqFlowHandler for PerCpuDevIdIrqHandler {
static ONCE: Once = Once::new(); static ONCE: Once = Once::new();
ONCE.call_once(|| { ONCE.call_once(|| {
kerror!( error!(
"Spurious percpu irq {} on cpu {:?}, enabled: {}", "Spurious percpu irq {} on cpu {:?}, enabled: {}",
irq.data(), irq.data(),
cpu, cpu,

Some files were not shown because too many files have changed in this diff Show More