vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

baseline

Browse Source
This commit is contained in:
Admin Pupkin
2026-05-20 19:58:12 +03:00
parent 80c9bccc09
commit 5f0c54ebfe
6 changed files with 508 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
recipes/core/kernel/source/src/arch/x86_shared/cpuidle.rs
+186
View File
@@ -0,0 +1,186 @@
use core::cell::SyncUnsafeCell;
use core::sync::atomic::{AtomicUsize, Ordering};
use crate::arch::cpuid::cpuid;
use crate::syscall::error::{Error, Result, EINVAL};
#[repr(align(64))]
struct MonitorTarget {
value: AtomicUsize,
}
static MONITOR_TARGET: MonitorTarget = MonitorTarget {
value: AtomicUsize::new(0),
};
bitflags::bitflags! {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CStateFlags: u32 {
const NEEDS_MONITOR = 1;
const NEEDS_WBINVD = 2;
}
}
#[derive(Clone, Copy, Debug)]
pub struct CState {
pub name: &'static str,
pub typ: u32,
pub latency: u32,
pub power: u32,
pub mwait_hint: u32,
pub flags: CStateFlags,
}
const MAX_CSTATES: usize = 8;
static CPUIDLE_STATES: SyncUnsafeCell<[Option<CState>; MAX_CSTATES]> =
SyncUnsafeCell::new([None; MAX_CSTATES]);
static NUM_CPUIDLE_STATES: AtomicUsize = AtomicUsize::new(0);
static CSTATE_POLICY_MAX: AtomicUsize = AtomicUsize::new(0);
fn has_mwait() -> bool {
cpuid().get_feature_info().map_or(false, |info| info.has_monitor_mwait())
}
fn add_state(index: usize, state: CState) {
unsafe {
(*CPUIDLE_STATES.get())[index] = Some(state);
}
}
pub fn init() {
add_state(0, CState {
name: "C1",
typ: 1,
latency: 1,
power: 1000,
mwait_hint: 0x00,
flags: CStateFlags::empty(),
});
let mut count = 1;
if has_mwait() {
add_state(count, CState {
name: "C1E",
typ: 1,
latency: 2,
power: 800,
mwait_hint: 0x01,
flags: CStateFlags::NEEDS_MONITOR,
});
count += 1;
add_state(count, CState {
name: "C2",
typ: 2,
latency: 10,
power: 500,
mwait_hint: 0x10,
flags: CStateFlags::NEEDS_MONITOR,
});
count += 1;
add_state(count, CState {
name: "C3",
typ: 3,
latency: 50,
power: 100,
mwait_hint: 0x20,
flags: CStateFlags::NEEDS_MONITOR | CStateFlags::NEEDS_WBINVD,
});
count += 1;
add_state(count, CState {
name: "C6",
typ: 6,
latency: 100,
power: 50,
mwait_hint: 0x50,
flags: CStateFlags::NEEDS_MONITOR | CStateFlags::NEEDS_WBINVD,
});
count += 1;
add_state(count, CState {
name: "C7",
typ: 7,
latency: 200,
power: 30,
mwait_hint: 0x60,
flags: CStateFlags::NEEDS_MONITOR | CStateFlags::NEEDS_WBINVD,
});
count += 1;
}
NUM_CPUIDLE_STATES.store(count, Ordering::SeqCst);
log::info!("cpuidle: initialized {} states (mwait={})", count, has_mwait());
}
pub fn policy_read() -> usize {
CSTATE_POLICY_MAX.load(Ordering::Relaxed)
}
pub fn policy_write(buf: &[u8]) -> Result<usize> {
let s = core::str::from_utf8(buf).map_err(|_| Error::new(EINVAL))?;
let s = s.trim();
let val: usize = s.parse().map_err(|_| Error::new(EINVAL))?;
let num_states = NUM_CPUIDLE_STATES.load(Ordering::Relaxed);
if val >= num_states {
return Err(Error::new(EINVAL));
}
CSTATE_POLICY_MAX.store(val, Ordering::Relaxed);
log::info!("cpuidle: policy set to max state {}", val);
Ok(s.len())
}
pub fn resource() -> Result<alloc::vec::Vec<u8>> {
let mut output = alloc::string::String::new();
let num_states = NUM_CPUIDLE_STATES.load(Ordering::Relaxed);
let policy = CSTATE_POLICY_MAX.load(Ordering::Relaxed);
output.push_str(&format!("policy_max: {}\n", policy));
output.push_str(&format!("num_states: {}\n", num_states));
for i in 0..num_states {
if let Some(state) = unsafe { (*CPUIDLE_STATES.get())[i] } {
output.push_str(&format!(
"state{}: name={} type={} latency={}us power={} hint={:#x} flags={:?}\n",
i, state.name, state.typ, state.latency, state.power, state.mwait_hint, state.flags
));
}
}
Ok(output.into_bytes())
}
pub unsafe fn enter_idle() {
let policy_max = CSTATE_POLICY_MAX.load(Ordering::Relaxed);
let num_states = NUM_CPUIDLE_STATES.load(Ordering::Relaxed);
let target_index = if num_states == 0 {
0
} else {
core::cmp::min(policy_max, num_states - 1)
};
if target_index == 0 {
unsafe { crate::arch::interrupt::enable_and_halt(); }
return;
}
let state = match unsafe { (*CPUIDLE_STATES.get())[target_index] } {
Some(s) => s,
None => {
unsafe { crate::arch::interrupt::enable_and_halt(); }
return;
}
};
if state.flags.contains(CStateFlags::NEEDS_MONITOR) {
let addr = &MONITOR_TARGET.value as *const AtomicUsize as *const u8;
unsafe { crate::arch::interrupt::monitor(addr, 0, 0); }
}
if state.flags.contains(CStateFlags::NEEDS_WBINVD) {
unsafe { core::arch::asm!("wbinvd", options(nostack)); }
}
unsafe {
crate::arch::interrupt::enable_and_mwait(state.mwait_hint, 0);
}
}
recipes/core/kernel/source/src/scheme/sys/cstate.rs
+15
View File
@@ -0,0 +1,15 @@
use alloc::vec::Vec;
use crate::{
arch::cpuidle,
sync::CleanLockToken,
syscall::error::{Error, Result, EINVAL},
};
pub fn resource(_token: &mut CleanLockToken) -> Result<Vec<u8>> {
cpuidle::resource()
}
pub fn policy_write(buf: &[u8], _token: &mut CleanLockToken) -> Result<usize> {
cpuidle::policy_write(buf)
}
recipes/core/kernel/source/src/scheme/sys/mod.rs
+74 -1
View File
@@ -45,6 +45,11 @@ enum Handle {
data: Arc<RwLock<L1, Option<Vec<u8>>>>,
},
SchemeRoot,
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Msr {
cpu: usize,
msr: u32,
},
}
#[derive(Clone, Copy)]
@@ -133,6 +138,28 @@ impl KernelScheme for SysScheme {
let id = HANDLES.write(token.token()).insert(Handle::TopLevel);
Ok(OpenResult::SchemeLocal(id, InternalFlags::POSITIONED))
} else if path.starts_with("msr/") {
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
{
if ctx.uid != 0 {
return Err(Error::new(EPERM));
}
let rest = &path[4..];
let mut parts = rest.split('/');
let cpu_str = parts.next().ok_or(Error::new(EINVAL))?;
let msr_str = parts.next().ok_or(Error::new(EINVAL))?;
if parts.next().is_some() {
return Err(Error::new(EINVAL));
}
let cpu: usize = cpu_str.parse().map_err(|_| Error::new(EINVAL))?;
let msr: u32 = u32::from_str_radix(msr_str, 16).map_err(|_| Error::new(EINVAL))?;
let id = HANDLES.write(token.token()).insert(Handle::Msr { cpu, msr });
Ok(OpenResult::SchemeLocal(id, InternalFlags::POSITIONED))
}
#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
{
Err(Error::new(ENOENT))
}
} else {
//Have to iterate to get the path without allocation
let entry = FILES
@@ -160,6 +187,8 @@ impl KernelScheme for SysScheme {
Handle::TopLevel => return Ok(0),
Handle::Resource { kind, data, .. } => (*kind, data.clone()),
Handle::SchemeRoot => return Err(Error::new(EBADF)),
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Handle::Msr { .. } => return Ok(0),
}
};
if matches!(kind, Kind::Wr(_)) {
@@ -188,6 +217,16 @@ impl KernelScheme for SysScheme {
Handle::TopLevel => "",
Handle::Resource { path, .. } => path,
Handle::SchemeRoot => return Err(Error::new(EBADF)),
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Handle::Msr { cpu, msr } => {
const FIRST: &[u8] = b"sys:msr/";
let mut bytes_read = buf.copy_common_bytes_from_slice(FIRST)?;
let suffix = format!("{}/{:x}", cpu, msr);
if let Some(remaining) = buf.advance(FIRST.len()) {
bytes_read += remaining.copy_common_bytes_from_slice(suffix.as_bytes())?;
}
return Ok(bytes_read);
}
};
const FIRST: &[u8] = b"sys:";
@@ -215,6 +254,15 @@ impl KernelScheme for SysScheme {
let (kind, data_lock) = {
match HANDLES.read(token.token()).get(id)? {
Handle::Resource { kind, data, .. } => (*kind, data.clone()),
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Handle::Msr { cpu, msr } => {
if *cpu != crate::cpu_id().get() as usize {
return Err(Error::new(EINVAL));
}
let val = unsafe { x86::msr::rdmsr(*msr) };
let data = format!("{:016x}\n", val).into_bytes();
return buffer.copy_common_bytes_from_slice(&data[pos..]);
}
_ => return Err(Error::new(EBADF)),
}
};
@@ -253,6 +301,18 @@ impl KernelScheme for SysScheme {
let len = buffer.copy_common_bytes_to_slice(&mut intermediate)?;
(*handler, intermediate, len)
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Handle::Msr { cpu, msr } => {
if *cpu != crate::cpu_id().get() as usize {
return Err(Error::new(EINVAL));
}
let mut intermediate = [0_u8; 32];
let len = buffer.copy_common_bytes_to_slice(&mut intermediate)?;
let val_str = core::str::from_utf8(&intermediate[..len]).map_err(|_| Error::new(EINVAL))?;
let val = u64::from_str_radix(val_str.trim(), 16).map_err(|_| Error::new(EINVAL))?;
unsafe { x86::msr::wrmsr(*msr, val); }
return Ok(len);
}
Handle::SchemeRoot => return Err(Error::new(EBADF)),
};
handler(&intermediate[..len], token)
@@ -269,7 +329,8 @@ impl KernelScheme for SysScheme {
return Ok(0);
};
match HANDLES.read(token.token()).get(id)? {
Handle::Resource { .. } => Err(Error::new(ENOTDIR)),
Handle::Resource { .. }
| Handle::Msr { .. } => Err(Error::new(ENOTDIR)),
Handle::TopLevel => {
let mut buf = DirentBuf::new(buf, header_size).ok_or(Error::new(EIO))?;
for (this_idx, (name, _)) in FILES.iter().enumerate().skip(first_index) {
@@ -293,6 +354,18 @@ impl KernelScheme for SysScheme {
Handle::Resource { kind, data, .. } => Some((*kind, data.clone())),
Handle::TopLevel => None,
Handle::SchemeRoot => return Err(Error::new(EBADF)),
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
Handle::Msr { .. } => {
let stat = Stat {
st_mode: 0o600 | MODE_FILE,
st_uid: 0,
st_gid: 0,
st_size: 0,
..Default::default()
};
buf.copy_exactly(&stat)?;
return Ok(());
}
}
};
let stat = if let Some((kind, data_lock)) = stat_base {