DragonOS-Community/DragonOS
4
1
Fork 0
mirror of https://github.com/DragonOS-Community/DragonOS.git synced 2025-06-19 17:26:31 +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
181 changed files with 1321 additions and 1261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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 alloc::{string::ToString, sync::Arc};
use log::{error, info};
use crate::{
arch::MMArch,
driver::base::firmware::sys_firmware_kset,
kinfo,
libs::align::{page_align_down, page_align_up, AlignedBox},
mm::{
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
pub fn init(&self, rsdp_vaddr1: u64, rsdp_vaddr2: u64) -> Result<(), SystemError> {
kinfo!("Initializing Acpi Manager...");
info!("Initializing Acpi Manager...");
// 初始化`/sys/firmware/acpi`的kset
let kset = KSet::new("acpi".to_string());
@ -67,7 +67,7 @@ impl AcpiManager {
}
self.map_tables(rsdp_vaddr1, rsdp_vaddr2)?;
self.bus_init()?;
kinfo!("Acpi Manager initialized.");
info!("Acpi Manager initialized.");
return Ok(());
}
@ -95,7 +95,7 @@ impl AcpiManager {
}
// 如果rsdpv1和rsdpv2都无法获取到acpi_table，说明有问题，打印报错信息后进入死循环
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();
loop {
spin_loop();
@ -161,7 +161,7 @@ impl AcpiManager {
pub fn platform_info(&self) -> Option<PlatformInfo<'_, alloc::alloc::Global>> {
let r = self.tables()?.platform_info();
if let Err(ref e) = r {
kerror!(
error!(
"AcpiManager::platform_info(): failed to get platform info, error: {:?}",
e
);

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

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

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

@ -1,23 +1,21 @@
/// 引入Module
use crate::{
driver::{
base::{
device::{
device_number::{DeviceNumber, Major},
Device, DeviceError, IdTable, BLOCKDEVS,
},
map::{
DeviceStruct, DEV_MAJOR_DYN_END, DEV_MAJOR_DYN_EXT_END, DEV_MAJOR_DYN_EXT_START,
DEV_MAJOR_HASH_SIZE, DEV_MAJOR_MAX,
},
use crate::driver::{
base::{
device::{
device_number::{DeviceNumber, Major},
Device, DeviceError, IdTable, BLOCKDEVS,
},
map::{
DeviceStruct, DEV_MAJOR_DYN_END, DEV_MAJOR_DYN_EXT_END, DEV_MAJOR_DYN_EXT_START,
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 core::any::Any;
use log::error;
use system_error::SystemError;
use super::disk_info::Partition;
@ -475,7 +473,7 @@ impl BlockDeviceOps {
let mut major = device_number.major();
let baseminor = device_number.minor();
if major >= DEV_MAJOR_MAX {
kerror!(
error!(
"DEV {} major requested {:?} is greater than the maximum {}\n",
name,
major,
@ -483,7 +481,7 @@ impl BlockDeviceOps {
);
}
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);
}
let blockdev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name);
@ -549,7 +547,7 @@ impl BlockDeviceOps {
#[allow(dead_code)]
pub fn bdev_add(_bdev: Arc<dyn BlockDevice>, id_table: IdTable) -> Result<(), DeviceError> {
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")
// 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 log::error;
use crate::kerror;
use system_error::SystemError;
use super::{
@ -129,7 +129,7 @@ impl CharDevOps {
let mut major = device_number.major();
let baseminor = device_number.minor();
if major >= DEV_MAJOR_MAX {
kerror!(
error!(
"DEV {} major requested {:?} is greater than the maximum {}\n",
name,
major,
@ -137,7 +137,7 @@ impl CharDevOps {
);
}
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);
}
let chardev = DeviceStruct::new(DeviceNumber::new(major, baseminor), minorct, name);
@ -207,7 +207,7 @@ impl CharDevOps {
range: usize,
) -> Result<(), SystemError> {
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())?;
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 hashbrown::HashMap;
use intertrait::cast::CastArc;
use log::{debug, error, info};
use system_error::SystemError;
/// `/sys/bus`的kset
@ -296,7 +297,7 @@ impl BusManager {
.bus()
.and_then(|bus| bus.upgrade())
.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));
let kobj = driver.clone() as Arc<dyn KObject>;
@ -314,7 +315,7 @@ impl BusManager {
driver_manager()
.add_groups(driver, bus.drv_groups())
.map_err(|e| {
kerror!(
error!(
"BusManager::add_driver: driver '{:?}' add_groups failed, err: '{:?}",
driver.name(),
e
@ -326,7 +327,7 @@ impl BusManager {
if !driver.suppress_bind_attrs() {
self.add_bind_files(driver)
.map_err(|e| {
kerror!(
error!(
"BusManager::add_driver: driver '{:?}' add_bind_files failed, err: '{:?}",
driver.name(),
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
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);
}
@ -746,7 +747,7 @@ impl Attribute for DriverAttrUnbind {
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
kerror!(
error!(
"Intertrait casting not implemented for kobj: {}",
kobj.name()
);
@ -795,7 +796,7 @@ impl Attribute for DriverAttrBind {
*/
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let driver = kobj.cast::<dyn Driver>().map_err(|kobj| {
kerror!(
error!(
"Intertrait casting not implemented for kobj: {}",
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 intertrait::cast::CastArc;
use log::{debug, error, warn};
use crate::{
driver::base::kobject::KObject,
@ -59,20 +60,20 @@ impl DeviceManager {
) -> Result<bool, SystemError> {
if unlikely(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() {
return Ok(false);
}
kwarn!("do_device_attach: dev: '{}'", dev.name());
warn!("do_device_attach: dev: '{}'", dev.name());
let mut do_async = false;
let mut r = Ok(false);
if dev.driver().is_some() {
if self.device_is_bound(dev) {
kdebug!(
debug!(
"do_device_attach: device '{}' is already bound.",
dev.name()
);
@ -86,7 +87,7 @@ impl DeviceManager {
return Ok(false);
}
} else {
kdebug!("do_device_attach: device '{}' is not bound.", dev.name());
debug!("do_device_attach: device '{}' is not bound.", dev.name());
let bus = dev
.bus()
.and_then(|bus| bus.upgrade())
@ -116,7 +117,7 @@ impl DeviceManager {
// try them.
do_async = true;
kdebug!(
debug!(
"do_device_attach: try scheduling asynchronous probe for device: {}",
dev.name()
);
@ -153,7 +154,7 @@ impl DeviceManager {
if let Err(e) = r {
// 如果不是ENOSYS，则总线出错
if e != SystemError::ENOSYS {
kdebug!(
debug!(
"do_device_attach_driver: bus.match_device() failed, dev: '{}', err: {:?}",
data.dev.name(),
e
@ -215,7 +216,7 @@ impl DeviceManager {
}
if let Err(e) = r.as_ref() {
kerror!(
error!(
"device_bind_driver: driver_sysfs_add failed, dev: '{}', err: {:?}",
dev.name(),
e
@ -401,7 +402,7 @@ impl DriverManager {
device.set_driver(Some(Arc::downgrade(driver)));
self.add_to_sysfs(device).map_err(|e| {
kerror!(
error!(
"really_probe: add_to_sysfs failed, dev: '{}', err: {:?}",
device.name(),
e
@ -412,7 +413,7 @@ impl DriverManager {
})?;
self.call_driver_probe(device, driver).map_err(|e| {
kerror!(
error!(
"really_probe: call_driver_probe failed, dev: '{}', err: {:?}",
device.name(),
e
@ -427,7 +428,7 @@ impl DriverManager {
device_manager()
.add_groups(device, driver.dev_groups())
.map_err(|e| {
kerror!(
error!(
"really_probe: add_groups failed, dev: '{}', err: {:?}",
device.name(),
e
@ -443,7 +444,7 @@ impl DriverManager {
device_manager()
.create_file(device, &DeviceAttrStateSynced)
.map_err(|e| {
kerror!(
error!(
"really_probe: create_file failed, dev: '{}', err: {:?}",
device.name(),
e
@ -515,7 +516,7 @@ impl DriverManager {
.ok_or(SystemError::EINVAL)?;
let r = bus.probe(device);
if r == Err(SystemError::ENOSYS) {
kerror!(
error!(
"call_driver_probe: bus.probe() failed, dev: '{}', err: {:?}",
device.name(),
r
@ -530,7 +531,7 @@ impl DriverManager {
let err = r.unwrap_err();
match err {
SystemError::ENODEV | SystemError::ENXIO => {
kdebug!(
debug!(
"driver'{}': probe of {} rejects match {:?}",
driver.name(),
device.name(),
@ -539,7 +540,7 @@ impl DriverManager {
}
_ => {
kwarn!(
warn!(
"driver'{}': probe of {} failed with error {:?}",
driver.name(),
device.name(),
@ -555,7 +556,7 @@ impl DriverManager {
/// 参考 https://code.dragonos.org.cn/xref/linux-6.1.9/drivers/base/dd.c#393
fn driver_bound(&self, device: &Arc<dyn 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;
}
@ -600,7 +601,7 @@ impl Attribute for DeviceAttrStateSynced {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!(
error!(
"Intertrait casting not implemented for kobj: {}",
kobj.name()
);
@ -635,7 +636,7 @@ impl Attribute for DeviceAttrCoredump {
fn store(&self, kobj: Arc<dyn KObject>, buf: &[u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!(
error!(
"Intertrait casting not implemented for kobj: {}",
kobj.name()
);

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

@ -15,6 +15,7 @@ use alloc::{
vec::Vec,
};
use core::fmt::Debug;
use log::error;
use system_error::SystemError;
/// @brief: Driver error
@ -193,7 +194,7 @@ impl DriverManager {
/// 参考 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> {
let bus = driver.bus().and_then(|bus| bus.upgrade()).ok_or_else(|| {
kerror!(
error!(
"DriverManager::register() failed: driver.bus() is None. Driver: '{:?}'",
driver.name()
);
@ -203,7 +204,7 @@ impl DriverManager {
let drv_name = driver.name();
let other = bus.find_driver_by_name(&drv_name);
if other.is_some() {
kerror!(
error!(
"DriverManager::register() failed: driver '{}' already registered",
drv_name
);

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

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

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

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak},
};
use intertrait::cast::CastArc;
use log::{error, warn};
use crate::{
driver::{
@ -139,7 +140,7 @@ pub trait Device: KObject {
/// 设备释放时的回调函数
fn release(&self) {
let name = self.name();
kwarn!(
warn!(
"device {} does not have a release() function, it is broken and must be fixed.",
name
);
@ -482,7 +483,7 @@ impl DeviceManager {
let actual_parent = self.get_device_parent(&device, current_parent)?;
if let Some(actual_parent) = actual_parent {
// kdebug!(
// debug!(
// "device '{}' parent is '{}', strong_count: {}",
// device.name().to_string(),
// actual_parent.name(),
@ -492,7 +493,7 @@ impl DeviceManager {
}
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
})?;
@ -552,10 +553,10 @@ impl DeviceManager {
device: &Arc<dyn Device>,
current_parent: Option<Arc<dyn Device>>,
) -> 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() {
let parent_kobj: Arc<dyn KObject>;
// kdebug!("current_parent:{:?}", current_parent);
// debug!("current_parent:{:?}", current_parent);
if let Some(cp) = current_parent {
if cp.class().is_some() {
return Ok(Some(cp.clone() as Arc<dyn KObject>));
@ -756,7 +757,7 @@ impl DeviceManager {
attr.mode().contains(ModeType::S_IRUGO)
&& (!attr.support().contains(SysFSOpsSupport::ATTR_SHOW)),
) {
kwarn!(
warn!(
"Attribute '{}': read permission without 'show'",
attr.name()
);
@ -765,7 +766,7 @@ impl DeviceManager {
attr.mode().contains(ModeType::S_IWUGO)
&& (!attr.support().contains(SysFSOpsSupport::ATTR_STORE)),
) {
kwarn!(
warn!(
"Attribute '{}': write permission without 'store'",
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
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对象的一些结构进行默认初始化
@ -872,7 +873,7 @@ impl Attribute for DeviceAttrDev {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
let dev = kobj.cast::<dyn Device>().map_err(|kobj| {
kerror!(
error!(
"Intertrait casting not implemented for kobj: {}",
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 intertrait::CastFromSync;
use log::{debug, error};
use crate::{
filesystem::{
kernfs::KernFSInode,
sysfs::{sysfs_instance, Attribute, AttributeGroup, SysFSOps, SysFSOpsSupport},
},
kerror,
libs::{
casting::DowncastArc,
rwlock::{RwLock, RwLockReadGuard, RwLockWriteGuard},
@ -213,7 +213,7 @@ impl KObjectManager {
}
kobj.set_parent(None);
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);
@ -269,7 +269,7 @@ pub struct DynamicKObjKType;
impl KObjType for DynamicKObjKType {
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> {

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

@ -3,6 +3,7 @@ use alloc::{
sync::{Arc, Weak},
};
use intertrait::cast::CastArc;
use log::error;
use super::{platform_device::PlatformDevice, platform_driver::PlatformDriver};
use crate::{
@ -58,12 +59,12 @@ impl Bus for PlatformBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?;
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
})?;
let pdev = device.clone().cast::<dyn PlatformDevice>().map_err(|_| {
kerror!(
error!(
"PlatformBus::probe() failed: device is not a PlatformDevice. Device: '{:?}'",
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 hashbrown::HashMap;
use log::debug;
use crate::{driver::base::block::block_device::BlockId, libs::rwlock::RwLock};
@ -41,7 +42,7 @@ impl BlockCache {
CSPACE = Some(LockedCacheSpace::new(CacheSpace::new()));
CMAPPER = Some(LockedCacheMapper::new(CacheMapper::new()));
}
kdebug!("BlockCache Initialized!");
debug!("BlockCache Initialized!");
}
/// # 函数的功能
/// 使用blockcache进行对块设备进行连续块的读操作

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

@ -5,6 +5,7 @@ use alloc::{
sync::{Arc, Weak},
vec::Vec,
};
use log::{debug, error};
use system_error::SystemError;
use unified_init::macros::unified_init;
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>) {
let device = VirtIOBlkDevice::new(transport, dev_id);
if let Some(device) = device {
kdebug!("VirtIOBlkDevice '{:?}' created", device.dev_id);
debug!("VirtIOBlkDevice '{:?}' created", device.dev_id);
virtio_device_manager()
.device_add(device.clone() as Arc<dyn VirtIODevice>)
.expect("Add virtio blk failed");
@ -89,7 +90,7 @@ impl VirtIOBlkDevice {
let irq = transport.irq().map(|irq| IrqNumber::new(irq.data()));
let device_inner = VirtIOBlk::<HalImpl, VirtIOTransport>::new(transport);
if let Err(e) = device_inner {
kerror!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e);
error!("VirtIOBlkDevice '{dev_id:?}' create failed: {:?}", e);
return None;
}
@ -134,10 +135,9 @@ impl BlockDevice for VirtIOBlkDevice {
.device_inner
.read_blocks(lba_id_start, &mut buf[..count * LBA_SIZE])
.map_err(|e| {
kerror!(
error!(
"VirtIOBlkDevice '{:?}' read_at_sync failed: {:?}",
self.dev_id,
e
self.dev_id, e
);
SystemError::EIO
})?;
@ -416,7 +416,7 @@ impl VirtIODriver for VirtIOBlkDriver {
.arc_any()
.downcast::<VirtIOBlkDevice>()
.map_err(|_| {
kerror!(
error!(
"VirtIOBlkDriver::probe() failed: device is not a VirtIO block device. Device: '{:?}'",
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 core::intrinsics::unlikely;
use core::sync::atomic::{AtomicU32, Ordering};
use log::info;
use system_error::SystemError;
// 参考：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"))]
#[allow(dead_code)]
fn verify_pmtmr_rate() -> bool {
use log::info;
let mut count: u32 = 0;
mach_prepare_counter();
@ -179,7 +182,7 @@ fn verify_pmtmr_rate() -> bool {
let delta = (value2 - value1) & ACPI_PM_MASK;
if (delta < (PMTMR_EXPECTED_RATE * 19) / 20) || (delta > (PMTMR_EXPECTED_RATE * 21) / 20) {
kinfo!(
info!(
"PM Timer running at invalid 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);
kinfo!(
info!(
"apic_pmtmr I/O port: {}",
PMTMR_IO_PORT.load(Ordering::SeqCst)
);
@ -257,14 +260,14 @@ pub fn init_acpi_pm_clocksource() -> Result<(), SystemError> {
if (value2 < value1) && (value2 < 0xfff) {
break;
}
kinfo!("PM Timer had inconsistens results: {} {}", value1, value2);
info!("PM Timer had inconsistens results: {} {}", value1, value2);
PMTMR_IO_PORT.store(0, Ordering::SeqCst);
return Err(SystemError::EINVAL);
}
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);
@ -289,11 +292,11 @@ pub fn init_acpi_pm_clocksource() -> Result<(), SystemError> {
let acpi_pmtmr = clocksource_acpi_pm() as Arc<dyn Clocksource>;
match acpi_pmtmr.register(100, PMTMR_TICKS_PER_SEC as u32) {
Ok(_) => {
kinfo!("ACPI PM Timer registered as clocksource sccessfully");
info!("ACPI PM Timer registered as clocksource sccessfully");
return Ok(());
}
Err(_) => {
kinfo!("ACPI PM Timer init registered failed");
info!("ACPI PM Timer init registered failed");
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> {
// 更新下一次中断时间
// kdebug!(
// debug!(
// "riscv_sbi_timer: handle_irq: cpu_id: {}, time: {}",
// smp_get_processor_id().data(),
// 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::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::spinlock::SpinLock;
use crate::mm::{phys_2_virt, verify_area, VirtAddr};
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,
},
kerror,
};
use log::error;
use system_error::SystemError;
use alloc::sync::Weak;
@ -70,7 +68,7 @@ impl AhciDisk {
compiler_fence(Ordering::SeqCst);
let check_length = ((count - 1) >> 4) + 1; // prdt length
if count * 512 > buf.len() || check_length > 8_usize {
kerror!("ahci read: e2big");
error!("ahci read: e2big");
// 不可能的操作
return Err(SystemError::E2BIG);
} else if count == 0 {
@ -130,7 +128,7 @@ impl AhciDisk {
// 清空整个table的旧数据
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
for i in 0..((volatile_read!(cmdheader.prdtl) - 1) as usize) {
@ -181,19 +179,19 @@ impl AhciDisk {
}
if spin_count == SPIN_LIMIT {
kerror!("Port is hung");
error!("Port is hung");
return Err(SystemError::EIO);
}
volatile_set_bit!(port.ci, 1 << slot, true); // Issue command
// kdebug!("To wait ahci read complete.");
// debug!("To wait ahci read complete.");
// 等待操作完成
loop {
if (volatile_read!(port.ci) & (1 << slot)) == 0 {
break;
}
if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
kerror!("Read disk error");
error!("Read disk error");
return Err(SystemError::EIO);
}
}
@ -336,7 +334,7 @@ impl AhciDisk {
break;
}
if (volatile_read!(port.is) & HBA_PxIS_TFES) > 0 {
kerror!("Write disk error");
error!("Write disk error");
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,
};
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::spinlock::{SpinLock, SpinLockGuard};
use crate::mm::virt_2_phys;
use crate::{
driver::disk::ahci::{
ahcidisk::LockedAhciDisk,
hba::HbaMem,
hba::{HbaPort, HbaPortType},
},
kdebug,
};
use ahci_inode::LockedAhciInode;
use alloc::{boxed::Box, collections::LinkedList, format, string::String, sync::Arc, vec::Vec};
use core::sync::atomic::compiler_fence;
use log::{debug, error};
use system_error::SystemError;
// 仅module内可见 全局数据区 hbr_port, disks
@ -90,13 +88,13 @@ pub fn ahci_init() -> Result<(), SystemError> {
let tp = hba_mem_port.check_type();
match tp {
HbaPortType::None => {
kdebug!("<ahci_rust_init> Find a None type Disk.");
debug!("<ahci_rust_init> Find a None type Disk.");
}
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));
@ -122,7 +120,7 @@ pub fn ahci_init() -> Result<(), SystemError> {
)?);
id += 1; // ID 从0开始
kdebug!("start register ahci device");
debug!("start register ahci device");
// 挂载到devfs上面去
let ret = devfs_register(
@ -130,7 +128,7 @@ pub fn ahci_init() -> Result<(), SystemError> {
LockedAhciInode::new(disks_list.last().unwrap().clone()),
);
if let Err(err) = ret {
kerror!(
error!(
"Ahci_{} ctrl = {}, port = {} failed to register, error code = {:?}",
id,
hba_mem_index as u8,

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

@ -3,6 +3,7 @@
use core::fmt::Debug;
use fdt::Fdt;
use log::error;
use system_error::SystemError;
use crate::init::boot_params;
@ -117,7 +118,7 @@ impl EFIManager {
)
}
.map_err(|e| {
kerror!("failed to parse fdt, err={:?}", e);
error!("failed to parse fdt, err={:?}", e);
SystemError::EINVAL
})?;
@ -145,7 +146,7 @@ impl EFIManager {
self.do_get_fdt_prop(prop_type, &prop, &mut ret)
.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 log::{error, info, warn};
use system_error::SystemError;
use uefi_raw::table::boot::{MemoryAttribute, MemoryType};
@ -21,17 +22,17 @@ use super::efi_manager;
#[allow(dead_code)]
#[inline(never)]
pub fn efi_init() {
kinfo!("Initializing efi...");
info!("Initializing efi...");
let data_from_fdt = efi_manager()
.get_fdt_params()
.expect("Failed to get fdt params");
if data_from_fdt.systable.is_none() {
kerror!("Failed to get systable from fdt");
error!("Failed to get systable from fdt");
return;
}
// kdebug!("to map memory table");
// debug!("to map memory table");
// 映射mmap table
if efi_manager().memmap_init_early(&data_from_fdt).is_err() {
@ -39,23 +40,23 @@ pub fn efi_init() {
// 那么 UEFI memory map 就是我们拥有的关于内存的唯一描述，
// 所以如果我们无法访问它，那么继续进行下去就没有什么意义了
kerror!("Failed to initialize early memory map");
error!("Failed to initialize early memory map");
loop {
spin_loop();
}
}
// kdebug!("NNNN");
// kwarn!("BBBB, e:{:?}", SystemError::EINVAL);
// debug!("NNNN");
// warn!("BBBB, e:{:?}", SystemError::EINVAL);
let desc_version = efi_manager().desc_version();
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));
if let Err(e) = r {
kerror!("Failed to initialize UEFI: {:?}", e);
error!("Failed to initialize UEFI: {:?}", e);
efi_manager().efi_memmap_unmap();
return;
}
@ -97,7 +98,7 @@ pub fn efi_init() {
// todo: Initialize screen info
kinfo!("UEFI init done!");
info!("UEFI init done!");
}
fn efi_find_mirror() {
@ -117,7 +118,7 @@ fn efi_find_mirror() {
}
if mirror_size > 0 {
kinfo!(
info!(
"Memory: {}M/{}M mirrored memory",
mirror_size >> 20,
total_size >> 20
@ -133,7 +134,7 @@ fn uefi_init(system_table: PhysAddr) -> Result<(), SystemError> {
let err_unmap_systable = |st_vaddr: VirtAddr| {
EarlyIoRemap::unmap(st_vaddr)
.map_err(|e| {
kerror!("Failed to unmap system table: {e:?}");
error!("Failed to unmap system table: {e:?}");
})
.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_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
})?;
@ -195,7 +196,7 @@ fn uefi_init(system_table: PhysAddr) -> Result<(), SystemError> {
true,
)
.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);
e
})?;
@ -265,11 +266,11 @@ fn reserve_memory_regions() {
let phys_start = page_align_down(md.phys_start 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() {
open_firmware_fdt_driver().early_init_dt_add_memory(phys_start as u64, size as u64);
if !md.is_usable_memory() {
// kdebug!(
// debug!(
// "Marking non-usable memory as nomap: {:#x}-{:#x}",
// phys_start,
// 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 log::error;
use system_error::SystemError;
use crate::{
@ -110,7 +111,7 @@ impl EFIManager {
let offset = paddr.data() - page_align_down(paddr.data());
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(
@ -130,7 +131,7 @@ impl EFIManager {
}
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);
}

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

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

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

@ -1,6 +1,7 @@
use core::{ffi::CStr, mem::size_of};
use hashbrown::Equivalent;
use log::{debug, error, info, warn};
use system_error::SystemError;
use uefi_raw::table::{
boot::{MemoryAttribute, MemoryType},
@ -66,16 +67,16 @@ impl EFIManager {
}
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
}).ok();
} 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)
.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
@ -86,7 +87,7 @@ impl EFIManager {
if let Some(r) = parser.match_table(table) {
// 有匹配结果
if let Err(e) = r {
kwarn!(
warn!(
"Failed to parse cfg table: '{}', err: {e:?}",
parser.table.name()
);
@ -97,7 +98,7 @@ impl EFIManager {
}
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() {
let vaddr = EarlyIoRemap::map_not_aligned(prev_paddr, MMArch::PAGE_SIZE, true)
.map_err(|e| {
kerror!(
error!(
"Failed to map UEFI memreserve table, paddr: {prev_paddr:?}, err: {e:?}"
);
@ -129,7 +130,7 @@ impl EFIManager {
+ size_of::<LinuxEFIMemReserveEntry>() * psize,
)
.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();
e
})?;
@ -146,7 +147,7 @@ impl EFIManager {
mem_block_manager()
.reserve_block(PhysAddr::new(entry.base), entry.size)
.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();
e
})?;
@ -344,7 +345,7 @@ impl MatchTable for MatchTableMemReserve {
) -> Result<(), SystemError> {
efi_manager().inner.write_irqsave().memreserve_table_paddr =
Some(PhysAddr::new(table_raw.vendor_table as usize));
kdebug!(
debug!(
"memreserve_table_paddr: {:#x}",
table_raw.vendor_table as usize
);
@ -374,7 +375,7 @@ impl MatchTable for MatchTableEsrt {
) -> Result<(), SystemError> {
efi_manager().inner.write_irqsave().esrt_table_paddr =
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(());
}
}

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

@ -6,6 +6,7 @@ use alloc::{
vec::Vec,
};
use kdepends::ringbuffer::{AllocRingBuffer, RingBuffer};
use log::{debug, error};
use system_error::SystemError;
use crate::{
@ -229,7 +230,7 @@ impl Ps2MouseDevice {
self.send_command_to_ps2mouse(PsMouseCommand::EnablePacketStreaming)
.map_err(|e| {
kerror!("ps2 mouse init error: {:?}", e);
error!("ps2 mouse init error: {:?}", e);
e
})?;
self.read_data_port().ok();
@ -313,7 +314,7 @@ impl Ps2MouseDevice {
guard.current_state.y = self.get_y_movement(packet, flags);
}
// kdebug!(
// debug!(
// "Ps2MouseDevice packet : flags:{}, x:{}, y:{}\n",
// guard.current_state.flags.bits,
// guard.current_state.x,
@ -664,7 +665,7 @@ impl IndexNode for Ps2MouseDevice {
impl Ps2Device for Ps2MouseDevice {}
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());
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>)?;
devfs_register(&psmouse.name(), psmouse.clone()).map_err(|e| {
kerror!(
error!(
"register psmouse device '{}' to devfs failed: {:?}",
psmouse.name(),
e

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

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

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

@ -1,4 +1,5 @@
use alloc::sync::Arc;
use log::debug;
use system_error::SystemError;
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
#[unified_init(INITCALL_DEVICE)]
pub fn i8042_init() -> Result<(), SystemError> {
kdebug!("i8042 initializing...");
debug!("i8042 initializing...");
let i8042_device = Arc::new(I8042PlatformDevice::new());
device_manager().device_default_initialize(&(i8042_device.clone() as Arc<dyn Device>));
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},
};
use intertrait::cast::CastArc;
use log::error;
use system_error::SystemError;
use crate::{
@ -59,7 +60,7 @@ impl Bus for SerioBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?;
let pdrv = drv.cast::<dyn SerioDriver>().map_err(|_| {
kerror!(
error!(
"SerioBus::probe() failed: device.driver() is not a SerioDriver. Device: '{:?}'",
device.name()
);
@ -67,7 +68,7 @@ impl Bus for SerioBus {
})?;
let pdev = device.clone().cast::<dyn SerioDevice>().map_err(|_| {
kerror!(
error!(
"SerioBus::probe() failed: device is not a SerioDevice. Device: '{:?}'",
device.name()
);

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

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

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

@ -25,6 +25,7 @@ use alloc::{
};
use bitmap::AllocBitmap;
use fdt::node::FdtNode;
use log::{debug, warn};
use system_error::SystemError;
use crate::{
@ -187,7 +188,7 @@ impl PlicHandler {
fn plic_irq_toggle(cpumask: &CpuMask, irq_data: &Arc<IrqData>, enable: bool) {
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) };
handler.toggle(irq_data.hardware_irq(), enable);
});
@ -240,7 +241,7 @@ impl IrqChip for PlicIrqChip {
"SiFive PLIC"
}
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 inner_guard = common_data.inner();
let mask = inner_guard.effective_affinity();
@ -252,7 +253,7 @@ impl IrqChip for PlicIrqChip {
}
fn irq_unmask(&self, irq_data: &Arc<IrqData>) -> Result<(), SystemError> {
// kwarn!("plic: irq_unmask");
// warn!("plic: irq_unmask");
let chip_data = irq_data
.chip_info_read_irqsave()
@ -300,7 +301,7 @@ impl IrqChip for PlicIrqChip {
}
fn irq_disable(&self, irq_data: &Arc<IrqData>) {
kdebug!("plic: irq_disable");
debug!("plic: irq_disable");
let common_data = irq_data.common_data();
let inner_guard = common_data.inner();
let mask = inner_guard.effective_affinity();
@ -321,7 +322,7 @@ impl IrqChip for PlicIrqChip {
handler.toggle(irq_data.hardware_irq(), false);
} else {
// kdebug!("plic: irq_eoi: hwirq: {:?}", irq_data.hardware_irq());
// debug!("plic: irq_eoi: hwirq: {:?}", irq_data.hardware_irq());
unsafe {
write_volatile(
(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 {
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)?
.as_usize()
.ok_or(SystemError::EINVAL)?;
kdebug!(
debug!(
"plic: node: {}, irq_num: {irq_num}, paddr: {paddr:?}, size: {size}",
fdt_node.name
);
@ -465,7 +466,7 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
.interrupts_extended()
.ok_or(SystemError::EINVAL)?
.count();
kdebug!("plic: nr_contexts: {nr_contexts}");
debug!("plic: nr_contexts: {nr_contexts}");
let irq_domain = irq_domain_manager()
.create_and_add_linear(
@ -474,7 +475,7 @@ fn do_riscv_sifive_plic_init(fdt_node: &FdtNode) -> Result<(), SystemError> {
(irq_num + 1) as u32,
)
.ok_or(SystemError::EINVAL)?;
// kdebug!("plic: irq_domain: {irq_domain:?}");
// debug!("plic: irq_domain: {irq_domain:?}");
let priv_data = PlicChipData::new(
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 handler = unsafe { plic_handlers().force_get(cpu) };
if handler.present() {
kwarn!("plic: handler {i} already present.");
warn!("plic: handler {i} already present.");
handler.set_threshold(PlicIrqChip::PLIC_ENABLE_THRESHOLD);
loop_done_setup(handler);
continue;
}
kdebug!("plic: setup lmask {cpu:?}.");
debug!("plic: setup lmask {cpu:?}.");
priv_data.lmask().set(cpu, true);
let mut handler_inner = handler.inner();
handler_inner.hart_base =
@ -560,7 +561,7 @@ fn associate_irq_with_plic_domain(
let irq = irq as u32;
let virq = IrqNumber::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()
.domain_associate(irq_domain, virq, hwirq)
.ok();
@ -583,7 +584,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
hwirq: HardwareIrqNumber,
virq: IrqNumber,
) -> 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 plic_chip_data = chip_data
@ -613,7 +614,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
_irq_data: &Arc<IrqData>,
_reserve: bool,
) -> Result<(), SystemError> {
kwarn!("plic: activate");
warn!("plic: activate");
loop {}
}
@ -622,7 +623,7 @@ impl IrqDomainOps for PlicIrqDomainOps {
/// 处理PLIC中断
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 priv_data = handler.priv_data();
@ -648,11 +649,11 @@ pub(super) fn do_plic_irq(trap_frame: &mut TrapFrame) {
if claim == 0 {
break;
}
kdebug!("plic: claim: {claim:?}");
debug!("plic: claim: {claim:?}");
let hwirq = HardwareIrqNumber::new(claim);
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::slice::{from_raw_parts, from_raw_parts_mut};
use core::sync::atomic::{compiler_fence, Ordering};
use log::{debug, info};
use super::e1000e_driver::e1000e_driver_init;
use crate::driver::base::device::DeviceId;
@ -23,8 +24,6 @@ use crate::exception::IrqNumber;
use crate::libs::volatile::{ReadOnly, Volatile, WriteOnly};
use crate::{kdebug, kinfo};
const PAGE_SIZE: usize = 4096;
const NETWORK_CLASS: u8 = 0x2;
const ETHERNET_SUBCLASS: u8 = 0x0;
@ -284,7 +283,7 @@ impl E1000EDevice {
volwrite!(general_regs, ctrl, ctrl | E1000E_CTRL_SLU);
}
let status = unsafe { volread!(general_regs, status) };
kdebug!("Status: {status:#X}");
debug!("Status: {status:#X}");
// 读取设备的mac地址
// Read mac address
@ -442,7 +441,7 @@ impl E1000EDevice {
buffer.set_length(desc.len as usize);
rdt = index;
unsafe { volwrite!(self.receive_regs, rdt0, rdt as u32) };
// kdebug!("e1000e: receive packet");
// debug!("e1000e: receive packet");
return Some(buffer);
}
@ -559,7 +558,7 @@ impl Drop for E1000EDevice {
fn drop(&mut self) {
// 释放已分配的所有dma页
// free all dma pages we have allocated
kdebug!("droping...");
debug!("droping...");
let recv_ring_length = PAGE_SIZE / size_of::<E1000ERecvDesc>();
let trans_ring_length = PAGE_SIZE / size_of::<E1000ETransDesc>();
unsafe {
@ -590,10 +589,10 @@ impl Drop for E1000EDevice {
pub fn e1000e_init() {
match e1000e_probe() {
Ok(_code) => {
kinfo!("Successfully init e1000e device!");
info!("Successfully init e1000e device!");
}
Err(_error) => {
kinfo!("Error occurred!");
info!("Error occurred!");
}
}
}
@ -610,7 +609,7 @@ pub fn e1000e_probe() -> Result<u64, E1000EPciError> {
if header.vendor_id == 0x8086 {
// intel
if E1000E_DEVICE_ID.contains(&header.device_id) {
kdebug!(
debug!(
"Detected e1000e PCI device with device id {:#x}",
header.device_id
);

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

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

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

@ -4,6 +4,7 @@ use fdt::{
node::{FdtNode, NodeProperty},
Fdt,
};
use log::{debug, error, warn};
use system_error::SystemError;
use crate::{
@ -79,7 +80,7 @@ impl OpenFirmwareFdtDriver {
let fdt_vaddr = boot_params().read().fdt().ok_or(SystemError::ENODEV)?;
let fdt: Fdt<'_> = unsafe {
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
})
}?;
@ -91,7 +92,7 @@ impl OpenFirmwareFdtDriver {
.expect("Failed to scan fdt root node.");
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);
@ -106,13 +107,13 @@ impl OpenFirmwareFdtDriver {
if let Some(prop) = node.property("#size-cells") {
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") {
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(());
@ -144,7 +145,7 @@ impl OpenFirmwareFdtDriver {
// TODO: 拼接内核自定义的command line参数
kdebug!("Command line: {}", boot_params().read().boot_cmdline_str());
debug!("Command line: {}", boot_params().read().boot_cmdline_str());
return Ok(());
}
@ -194,7 +195,7 @@ impl OpenFirmwareFdtDriver {
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);
found_memory = true;
}
@ -205,7 +206,7 @@ impl OpenFirmwareFdtDriver {
#[cfg(target_arch = "x86_64")]
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"))]
@ -220,7 +221,7 @@ impl OpenFirmwareFdtDriver {
let mut size = size as usize;
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 {
@ -231,11 +232,11 @@ impl OpenFirmwareFdtDriver {
size = page_align_down(size);
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() {
kwarn!(
warn!(
"Ignoring memory range {:#x}-{:#x}",
MemBlockManager::MAX_MEMBLOCK_ADDR.data() + 1,
base + size
@ -244,13 +245,13 @@ impl OpenFirmwareFdtDriver {
}
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;
}
if base < MemBlockManager::MIN_MEMBLOCK_ADDR.data() {
{
kwarn!(
warn!(
"Ignoring memory range {:#x}-{:#x}",
base,
MemBlockManager::MIN_MEMBLOCK_ADDR.data()
@ -312,7 +313,7 @@ impl OpenFirmwareFdtDriver {
if node.size() != 0 {
let address = PhysAddr::new(node.address() as usize);
let size = node.size();
kdebug!("Reserve memory: {:?}-{:?}", address, address + size);
debug!("Reserve memory: {:?}-{:?}", address, address + size);
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();
if reg_size > 0 && reg_size % t_len != 0 {
kerror!(
error!(
"Reserved memory: invalid reg property in '{}', skipping node.",
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)
.is_ok()
{
kdebug!(
debug!(
"Reserved memory: base={:#x}, size={:#x}, nomap={}",
base,
size,
nomap
base, size, nomap
);
} else {
kerror!(
error!(
"Failed to reserve memory: base={:#x}, size={:#x}, nomap={}",
base,
size,
nomap
base, size, nomap
);
}

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

@ -1,5 +1,6 @@
use alloc::sync::Arc;
use intertrait::cast::CastArc;
use log::warn;
use system_error::SystemError;
use crate::{
@ -50,7 +51,7 @@ impl Attribute for Vendor {
let dev = _kobj
.cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e);
warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL
})?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.vendor()));
@ -81,7 +82,7 @@ impl Attribute for DeviceID {
let dev = _kobj
.cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e);
warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL
})?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.device_id()));
@ -112,7 +113,7 @@ impl Attribute for SubsystemVendor {
let dev = _kobj
.cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e);
warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL
})?;
return sysfs_emit_str(_buf, &format!("0x{:04x}", dev.subsystem_vendor()));
@ -143,7 +144,7 @@ impl Attribute for SubsystemDevice {
let dev = _kobj
.cast::<dyn PciDevice>()
.map_err(|e: Arc<dyn KObject>| {
kwarn!("device:{:?} is not a pci device!", e);
warn!("device:{:?} is not a pci device!", e);
SystemError::EINVAL
})?;
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 super::{
@ -56,13 +58,13 @@ impl EcamRootInfoManager {
);
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;
}
pci_root_manager().add_pci_root(root.unwrap());
} else {
kwarn!(
warn!(
"add_ecam_root_info(): root {} already exists",
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::VirtAddr;
use crate::{kdebug, kerror, kinfo, kwarn};
use alloc::string::String;
use alloc::sync::Arc;
use alloc::vec::Vec;
use alloc::{boxed::Box, collections::LinkedList};
use bitflags::bitflags;
use log::{debug, error, info, warn};
use core::{
convert::TryFrom,
@ -962,7 +963,7 @@ fn pci_read_pci_to_cardbus_bridge_header(
/// @brief 检查所有bus上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因
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 {
bus: 0,
device: 0,
@ -981,7 +982,7 @@ fn pci_check_all_buses() -> Result<u8, PciError> {
/// @brief 检查特定设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因
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) {
Ok(header) => header,
Err(PciError::GetWrongHeader) => {
@ -1007,7 +1008,7 @@ fn pci_check_function(busdevicefunction: BusDeviceFunction) -> Result<u8, PciErr
/// @brief 检查device上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因
fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
//kdebug!("PCI check device {}", device);
//debug!("PCI check device {}", device);
let busdevicefunction = BusDeviceFunction {
bus,
device,
@ -1026,10 +1027,9 @@ fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
pci_check_function(busdevicefunction)?;
let common_header = header.common_header();
if common_header.header_type & 0x80 != 0 {
kdebug!(
debug!(
"Detected multi func device in bus{},device{}",
busdevicefunction.bus,
busdevicefunction.device
busdevicefunction.bus, busdevicefunction.device
);
// 这是一个多function的设备，因此查询剩余的function
for function in 1..8 {
@ -1046,7 +1046,7 @@ fn pci_check_device(bus: u8, device: u8) -> Result<u8, PciError> {
/// @brief 检查该bus上的设备并将其加入链表
/// @return 成功返回ok(),失败返回失败原因
fn pci_check_bus(bus: u8) -> Result<u8, PciError> {
//kdebug!("PCI check bus {}", bus);
//debug!("PCI check bus {}", bus);
for device in 0..32 {
pci_check_device(bus, device)?;
}
@ -1056,13 +1056,13 @@ fn pci_check_bus(bus: u8) -> Result<u8, PciError> {
/// pci初始化函数
#[inline(never)]
pub fn pci_init() {
kinfo!("Initializing PCI bus...");
info!("Initializing PCI bus...");
pci_bus_subsys_init().expect("Failed to init pci bus subsystem");
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;
}
kinfo!(
info!(
"Total pci device and function num = {}",
PCI_DEVICE_LINKEDLIST.num()
);
@ -1071,40 +1071,34 @@ pub fn pci_init() {
let common_header = box_pci_device.common_header();
match box_pci_device.header_type() {
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 => {
kinfo!(
info!(
"Found pci standard device with class code ={} subclass={} status={:#x} ",
common_header.class_code,
common_header.subclass,
common_header.status
common_header.class_code, common_header.subclass, common_header.status
);
}
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 => {
kinfo!(
info!(
"Found pci-to-pci bridge device with class code ={} subclass={} status={:#x} ",
common_header.class_code,
common_header.subclass,
common_header.status
common_header.class_code, common_header.subclass, common_header.status
);
}
HeaderType::PciCardbusBridge => {
kinfo!(
info!(
"Found pcicardbus bridge device with class code ={} subclass={} status={:#x} ",
common_header.class_code,
common_header.subclass,
common_header.status
common_header.class_code, common_header.subclass, common_header.status
);
}
HeaderType::Unrecognised(_) => {}
}
}
kinfo!("PCI bus initialized.");
info!("PCI bus initialized.");
}
/// 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
// as 0, and should be treated as size 0.
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.
pci_root_0().write_config(
bus_device_function,
@ -1380,7 +1374,7 @@ pub fn pci_bar_init(
.create_mmio(size_want)
.map_err(|_| PciError::CreateMmioError)?;
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!(
space_guard.map_phys(paddr, size_want).is_ok(),
"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);
}
@ -1454,7 +1448,7 @@ impl Iterator for CapabilityIterator {
self.next_capability_offset = if next_offset == 0 {
None
} 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
} else {
Some(next_offset)
@ -1502,7 +1496,7 @@ impl<'a> Iterator for ExternalCapabilityIterator<'a> {
self.next_capability_offset = if next_offset == 0 {
None
} 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
} else {
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::sync::Arc;
use alloc::vec::Vec;
use log::error;
use system_error::SystemError;
use super::pci::{PciDeviceStructure, PciDeviceStructureGeneralDevice, PciError};
@ -385,7 +386,7 @@ pub trait PciInterrupt: PciDeviceStructure {
}
Err(_) => {
kerror!(
error!(
"Failed to request pci irq {} for device {}",
irq_num.data(),
&common_msg.irq_name
@ -548,7 +549,7 @@ pub trait PciInterrupt: PciDeviceStructure {
}
Err(_) => {
kerror!(
error!(
"Failed to request pci irq {} for device {}",
irq_num.data(),
&common_msg.irq_name

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

@ -91,7 +91,7 @@ impl PciRoot {
/// @brief 完成物理地址到虚拟地址的映射，并将虚拟地址加入mmio_base变量
/// @return 返回错误或Ok(0)
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_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},
};
use intertrait::cast::CastArc;
use log::error;
use system_error::SystemError;
use crate::{
@ -89,14 +90,14 @@ impl Bus for PciBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?;
let pci_drv = drv.cast::<dyn PciDriver>().map_err(|_| {
kerror!(
error!(
"PciBus::probe() failed: device.driver() is not a PciDriver. Device: '{:?}'",
device.name()
);
SystemError::EINVAL
})?;
let pci_dev = device.clone().cast::<dyn PciDevice>().map_err(|_| {
kerror!(
error!(
"PciBus::probe() failed: device is not a PciDevice. Device: '{:?}'",
device.name()
);

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

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

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

@ -8,6 +8,7 @@ use alloc::{
sync::{Arc, Weak},
vec::Vec,
};
use log::error;
use system_error::SystemError;
use crate::{
@ -410,7 +411,7 @@ impl PlatformDriver for Serial8250ISADriver {
.arc_any()
.downcast::<Serial8250ISADevices>()
.map_err(|_| {
kerror!("Serial8250ISADriver::probe: device is not a Serial8250ISADevices");
error!("Serial8250ISADriver::probe: device is not a Serial8250ISADevices");
SystemError::EINVAL
})?;
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,
};
use hashbrown::HashMap;
use log::warn;
use system_error::SystemError;
use crate::{
@ -284,7 +285,7 @@ impl TtyDriver {
Some(tty) => {
// TODO: 暂时这么写，因为还没写TtyPort
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 {
return Err(SystemError::EBUSY);
}

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

@ -5,6 +5,7 @@ use alloc::{
vec::Vec,
};
use bitmap::{traits::BitMapOps, StaticBitmap};
use log::warn;
use crate::{
driver::{
@ -936,7 +937,7 @@ impl VirtualConsoleData {
'c' => {
if self.par[0] == 0 {
kwarn!("respone ID todo");
warn!("respone ID todo");
}
return;
}
@ -1612,7 +1613,7 @@ impl VirtualConsoleData {
tc |= ((attr as u32) << 8) & (!himask as u32);
// kwarn!(
// warn!(
// "ch {} pos {} x {} y {} cols {}",
// c as u8 as char,
// 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 log::warn;
use system_error::SystemError;
use crate::{
@ -200,7 +201,7 @@ impl ConsoleSwitch for BlittingFbConsole {
vc_data.font.height = font.height;
vc_data.font.count = font.char_count;
} else {
kwarn!("The frontend Framebuffer is not implemented");
warn!("The frontend Framebuffer is not implemented");
}
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},
vec::Vec,
};
use log::warn;
use system_error::SystemError;
use crate::{
@ -165,7 +166,7 @@ impl KObject for FbConsoleDevice {
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> {
@ -199,7 +200,7 @@ impl Device for FbConsoleDevice {
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>> {
@ -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
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");
}
/// 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> {
kwarn!("fbcon rotate store not implemented");
warn!("fbcon rotate store not implemented");
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
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);
}
}

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

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

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

@ -1,4 +1,5 @@
use alloc::sync::Arc;
use log::warn;
use system_error::SystemError;
use crate::{
@ -85,7 +86,7 @@ impl Attribute for AttrBitsPerPixel {
}
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);
}
@ -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
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);
}
}

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.red.offset
// {
// kerror!("return {}", var.green.length);
// error!("return {}", var.green.length);
// return var.green.length;
// } else {
// 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},
vec::Vec,
};
use log::{info, warn};
use system_error::SystemError;
use unified_init::macros::unified_init;
@ -390,7 +391,7 @@ impl FrameBufferOps for VesaFb {
/// ## 填充矩形
fn fb_fillrect(&self, rect: super::base::FillRectData) -> Result<(), SystemError> {
// kwarn!("rect {rect:?}");
// warn!("rect {rect:?}");
let boot_param = boot_params().read();
let screen_base = boot_param
@ -1006,7 +1007,7 @@ fn vesa_fb_device_init() -> Result<(), SystemError> {
static INIT: Once = Once::new();
INIT.call_once(|| {
kinfo!("vesa fb device init");
info!("vesa fb device init");
let device = Arc::new(VesaFb::new());
let mut fb_fix = VESAFB_FIX_INFO.write_irqsave();
@ -1068,7 +1069,7 @@ fn vesa_fb_device_init() -> Result<(), SystemError> {
// 加入全局fb表
let mut guard = FRAME_BUFFER_SET.write();
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",
device.fb_id()
);

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

@ -3,7 +3,6 @@ use core::sync::atomic::{AtomicBool, Ordering};
use crate::{
arch::MMArch,
init::boot_params,
kinfo,
libs::{
align::page_align_up,
lib_ui::screen_manager::{ScmBuffer, ScmBufferFlag, ScmBufferInfo},
@ -17,6 +16,7 @@ use crate::{
time::timer::{Timer, TimerFunction},
};
use alloc::{boxed::Box, sync::Arc};
use log::info;
use system_error::SystemError;
pub mod console;
@ -78,7 +78,7 @@ impl VideoRefreshManager {
* 将帧缓存区映射到地址SPECIAL_MEMOEY_MAPPING_VIRT_ADDR_BASE处
*/
fn init_frame_buffer(&self) {
kinfo!("Re-mapping VBE frame buffer...");
info!("Re-mapping VBE frame buffer...");
let buf_vaddr = boot_params()
.read_irqsave()
.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 hashbrown::HashMap;
use log::warn;
use system_error::SystemError;
use unified_init::macros::unified_init;
@ -120,7 +121,7 @@ impl IrqHandler for DefaultVirtioIrqHandler {
return dev.handle_irq(irq);
} else {
// 未绑定具体设备，因此无法处理中断
kwarn!("No device found for IRQ: {:?}", irq);
warn!("No device found for IRQ: {:?}", irq);
return Ok(IrqReturn::NotHandled);
}
}

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

@ -1,4 +1,5 @@
use fdt::node::FdtNode;
use log::error;
use system_error::SystemError;
use crate::driver::{
@ -9,7 +10,7 @@ use super::{transport::VirtIOTransport, virtio::virtio_device_init};
pub(super) fn virtio_probe_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 intertrait::cast::CastArc;
use log::error;
use system_error::SystemError;
use unified_init::macros::unified_init;
@ -78,7 +79,7 @@ impl Bus for VirtIOBus {
fn probe(&self, device: &Arc<dyn Device>) -> Result<(), SystemError> {
let drv = device.driver().ok_or(SystemError::EINVAL)?;
let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| {
kerror!(
error!(
"VirtIOBus::probe() failed: device.driver() is not a VirtioDriver. Device: '{:?}'",
device.name()
);
@ -86,7 +87,7 @@ impl Bus for VirtIOBus {
})?;
let virtio_dev = device.clone().cast::<dyn VirtIODevice>().map_err(|_| {
kerror!(
error!(
"VirtIOBus::probe() failed: device is not a VirtIODevice. Device: '{:?}'",
device.name()
);
@ -167,7 +168,7 @@ impl VirtIODeviceManager {
let drv = dev.driver().ok_or(SystemError::EINVAL)?;
let virtio_drv = drv.cast::<dyn VirtIODriver>().map_err(|_| {
kerror!(
error!(
"VirtIODeviceManager::device_add() failed: device.driver() is not a VirtioDriver. Device: '{:?}'",
dev.name()
);
@ -199,7 +200,7 @@ impl VirtIODeviceManager {
IrqHandleFlags::IRQF_SHARED,
Some(dev.dev_id().clone()),
) {
kerror!(
error!(
"Failed to request irq for virtio device '{}': irq: {:?}, error {:?}",
dev.device_name(),
irq,
@ -211,7 +212,7 @@ impl VirtIODeviceManager {
virtio_irq_manager()
.register_device(dev.clone())
.map_err(|e| {
kerror!(
error!(
"Failed to register virtio device's irq, dev: '{}', irq: {:?}, error {:?}",
dev.device_name(),
irq,
@ -302,7 +303,7 @@ impl Attribute for AttrDevice {
fn show(&self, kobj: Arc<dyn KObject>, buf: &mut [u8]) -> Result<usize, SystemError> {
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
})?;
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> {
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
})?;
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 fdt::node::FdtNode;
use log::info;
use system_error::SystemError;
use virtio_drivers::transport::{
mmio::{MmioTransport, VirtIOHeader},
@ -54,7 +55,7 @@ impl VirtIOMmioTransport {
match unsafe { MmioTransport::new(header) } {
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.device_type(),
mmio_transport.version(),
@ -69,7 +70,7 @@ impl VirtIOMmioTransport {
})
}
Err(_) => {
// kwarn!("MmioTransport::new failed: {:?}", e);
// warn!("MmioTransport::new failed: {:?}", e);
Err(SystemError::EINVAL)
}
}

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

@ -211,7 +211,7 @@ impl PciTransport {
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 isr_status = get_bar_region::<_>(
&device.standard_device_bar,
@ -532,7 +532,7 @@ fn get_bar_region<T>(
{
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
.virtual_address()
.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::libs::rwlock::RwLockWriteGuard;
use crate::{kdebug, kerror, kwarn};
use alloc::sync::Arc;
use alloc::vec::Vec;
use alloc::{boxed::Box, collections::LinkedList};
use log::{debug, error, warn};
use virtio_drivers::transport::{DeviceType, Transport};
///@brief 寻找并加载所有virtio设备的驱动（目前只有virtio-net，但其他virtio设备也可添加）
@ -32,7 +33,7 @@ fn virtio_probe_pci() {
let dev_id = DeviceId::new(None, Some(format!("{dev_id}"))).unwrap();
match PciTransport::new::<HalImpl>(virtio_device, dev_id.clone()) {
Ok(mut transport) => {
kdebug!(
debug!(
"Detected virtio PCI device with device type {:?}, features {:#018x}",
transport.device_type(),
transport.read_device_features(),
@ -41,7 +42,7 @@ fn virtio_probe_pci() {
virtio_device_init(transport, dev_id);
}
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() {
DeviceType::Block => virtio_blk(transport, dev_id),
DeviceType::GPU => {
kwarn!("Not support virtio_gpu device for now");
warn!("Not support virtio_gpu device for now");
}
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),
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,
) -> virtio_drivers::PhysAddr {
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.
return MMArch::virt_2_phys(vaddr).unwrap().data();
}