From d1ece2c811a689a2671bcd54fb3c30a506822152 Mon Sep 17 00:00:00 2001 From: 4lDO2 <4lDO2@protonmail.com> Date: Sun, 12 Apr 2020 00:50:47 +0200 Subject: [PATCH] Add a basic acpi: scheme, currently only for MCFG. --- src/acpi/mod.rs | 6 +- src/scheme/acpi.rs | 362 +++++++++++++++++++++++++++++++++++++++++++++ src/scheme/mod.rs | 10 ++ 3 files changed, 375 insertions(+), 3 deletions(-) create mode 100644 src/scheme/acpi.rs diff --git a/src/acpi/mod.rs b/src/acpi/mod.rs index 96f50a1..5f507b2 100644 --- a/src/acpi/mod.rs +++ b/src/acpi/mod.rs @@ -33,7 +33,7 @@ mod dmar; mod fadt; pub mod madt; mod rsdt; -mod sdt; +pub mod sdt; mod xsdt; pub mod aml; mod rxsdt; @@ -42,7 +42,7 @@ mod rsdp; const TRAMPOLINE: usize = 0x7E00; const AP_STARTUP: usize = TRAMPOLINE + 512; -fn get_sdt(sdt_address: usize, active_table: &mut ActivePageTable) -> &'static Sdt { +pub fn get_sdt(sdt_address: usize, active_table: &mut ActivePageTable) -> &'static Sdt { { let page = Page::containing_address(VirtualAddress::new(sdt_address)); if active_table.translate_page(page).is_none() { @@ -193,7 +193,7 @@ pub fn set_global_s_state(state: u8) { } } -type SdtSignature = (String, [u8; 6], [u8; 8]); +pub type SdtSignature = (String, [u8; 6], [u8; 8]); pub static SDT_POINTERS: RwLock>> = RwLock::new(None); pub static SDT_ORDER: RwLock>> = RwLock::new(None); diff --git a/src/scheme/acpi.rs b/src/scheme/acpi.rs new file mode 100644 index 0000000..93a9a19 --- /dev/null +++ b/src/scheme/acpi.rs @@ -0,0 +1,362 @@ +use core::convert::{TryFrom, TryInto}; +use core::sync::atomic::{self, AtomicUsize}; +use core::fmt::Write; +use core::str; + +use alloc::vec::Vec; +use alloc::collections::BTreeMap; + +use syscall::scheme::Scheme; +use syscall::data::Stat; +use syscall::flag::{O_DIRECTORY, O_STAT, O_ACCMODE, O_WRONLY, O_RDWR}; +use syscall::error::{EACCES, EBADF, EBADFD, EISDIR, EINVAL, EIO, ENOENT, ENOTDIR}; +use syscall::{MODE_DIR, MODE_FILE, SEEK_CUR, SEEK_END, SEEK_SET}; +use syscall::{Error, Result}; + +use spin::{Mutex, RwLock}; + +use crate::acpi::SdtSignature; +use crate::acpi::sdt::Sdt; +use crate::paging::ActivePageTable; + +#[derive(Clone, Copy)] +struct PhysSlice { + phys_ptr: usize, + len: usize, + /// These appear to be identity mapped, so this is technically not needed. + virt: usize, +} + +/// A scheme used to access ACPI tables needed for some drivers to function (e.g. pcid with the +/// PCIe "MCFG" table). +/// +/// # Layout +/// * `/tables` +/// * _can be listed to retrieve the available tables_ +/// * e.g. MCFG-- +/// * _maybe_ the MADT, in case some userspace driver takes care of the I/O APIC. +/// * _perhaps_ some interface for e.g. power management. +pub struct AcpiScheme { + handles: RwLock>>, + tables: Vec<(SdtSignature, PhysSlice)>, + next_fd: AtomicUsize, +} + +const TOPLEVEL_DIR_CONTENTS: &[u8] = b"tables\n"; +const ALLOWED_TABLES: &[[u8; 4]] = &[*b"MCFG"]; + +// XXX: Why can't core also have something like std::io::Take? It's not even real I/O! +/// An internal wrapper struct that limits the number of bytes that can be fmt-written, in order to +/// properly return the length when reading directories etc. The bytes that cannot be written will +/// be discarded. +struct Take<'a> { + buf: &'a mut [u8], + offset: usize, +} + +impl Take<'_> { + pub fn write_to_buf<'a>(buf: &'a mut [u8]) -> Take<'a> { + Take { + offset: 0, + buf, + } + } + pub fn bytes_currently_written(&self) -> usize { + self.offset + } +} + +impl<'a> core::fmt::Write for Take<'a> +{ + fn write_str(&mut self, string: &str) -> core::fmt::Result { + if self.offset > self.buf.len() { return Ok(()) } + + let string_bytes = string.as_bytes(); + let max = core::cmp::min(string_bytes.len() + self.offset, self.buf.len()) - self.offset; + self.buf[self.offset..self.offset + max].copy_from_slice(&string_bytes[..max]); + self.offset += max; + Ok(()) + } +} + +enum Handle { + TopLevel(usize), // seek offset + Tables(usize), // seek offset + + Table { + name: [u8; 4], + oem_id: [u8; 6], + oem_table_id: [u8; 8], + + offset: usize, // seek offset + }, +} + +impl AcpiScheme { + fn get_tables() -> Vec<(SdtSignature, PhysSlice)> { + let mut active_table = unsafe { ActivePageTable::new() }; + + let mut tables = Vec::new(); + + for allowed_tbl_name in ALLOWED_TABLES.iter() { + use crate::acpi::{find_sdt, get_sdt, get_sdt_signature}; + + // it appears that the SDTs are identity mapped, in which case we can just call get_sdt + // whenever we need to and use the slice as if it was physical. + + let table_name_str = str::from_utf8(allowed_tbl_name).expect("ACPI table name wasn't correct UTF-8"); + + for sdt in find_sdt(table_name_str) { + let virt = get_sdt(sdt as *const Sdt as usize, &mut active_table) as *const Sdt as usize; + let signature = get_sdt_signature(sdt); + let sdt_pointer = sdt as *const Sdt as usize; + let len = sdt.length as usize; + assert_eq!(virt, sdt_pointer); + tables.push((signature, PhysSlice { phys_ptr: sdt_pointer, len, virt })); + } + } + tables + } + pub fn new() -> Self { + Self { + handles: RwLock::new(BTreeMap::new()), + tables: Self::get_tables(), + next_fd: AtomicUsize::new(0), + } + } + fn lookup_signature_index(&self, name: [u8; 4], oem_id: [u8; 6], oem_table_id: [u8; 8]) -> Option { + self.tables.iter().position(|((sig_name, sig_oem_id, sig_oem_table_id), _)| sig_name.as_bytes() == &name && sig_oem_id == &oem_id && sig_oem_table_id == &oem_table_id) + } + fn lookup_signature(&self, name: [u8; 4], oem_id: [u8; 6], oem_table_id: [u8; 8]) -> Option { + Some(self.tables[self.lookup_signature_index(name, oem_id, oem_table_id)?].1) + } +} + +fn parse_table_filename(filename: &[u8]) -> Option<([u8; 4], [u8; 6], [u8; 8])> { + // the table identifier takes the form: + // 1. a four byte table name, like 'APIC' (MADT) or 'MCFG'. + // 2. a dash followed by 12 hexadecimal digits (6 bytes when decoded) composing the OEM ID. + // 3. another dash followed by 16 hex digits (8 bytes), composing the OEM Table ID. + // hence, the table is 4 + 1 + 12 + 1 + 16 = 34 bytes long. + if filename.len() != 34 { return None } + let mut table_identifier = [0u8; 34]; + table_identifier.copy_from_slice(filename); + + let table_name = &table_identifier[..4]; + if table_identifier[4] != b'-' { return None } + let oem_id_hex = &table_identifier[5..17]; + if table_identifier[17] != b'-' { return None } + let oem_table_id_hex = &table_identifier[18..34]; + + let oem_id_hex_str = str::from_utf8(oem_id_hex).ok()?; + let oem_table_id_hex_str = str::from_utf8(oem_table_id_hex).ok()?; + + let mut oem_id = [0u8; 6]; + + for index in 0..oem_id.len() { + oem_id[index] = u8::from_str_radix(&oem_id_hex_str[index * 2..(index + 1) * 2], 16).ok()?; + } + + let mut oem_table_id = [0u8; 8]; + + for index in 0..oem_table_id.len() { + oem_table_id[index] = u8::from_str_radix(&oem_table_id_hex_str[index * 2..(index + 1) * 2], 16).ok()?; + } + + Some((table_name.try_into().unwrap(), oem_id, oem_table_id)) +} +fn serialize_table_filename(buffer: &mut [u8], (table_name, oem_id, oem_table_id): ([u8; 4], [u8; 6], [u8; 8])) -> usize { + let mut wrapper = Take::write_to_buf(buffer); + write!(wrapper, "{}-", str::from_utf8(&table_name).expect("Acpi table id wasn't valid UTF-8")).unwrap(); + for b in &oem_id { + write!(wrapper, "{:2x}", b).unwrap(); + } + write!(wrapper, "-").unwrap(); + for b in &oem_table_id { + write!(wrapper, "{:2x}", b).unwrap(); + } + wrapper.bytes_currently_written() +} + +impl Scheme for AcpiScheme { + fn open(&self, path: &[u8], flags: usize, opener_uid: u32, _opener_gid: u32) -> Result { + if opener_uid != 0 { return Err(Error::new(EACCES)) } + + let path_str = str::from_utf8(path).or(Err(Error::new(ENOENT)))?; + let path_str = path_str.trim_start_matches('/'); + + // TODO: Use some kind of component iterator. + + let new_handle = if path_str.starts_with("tables") { + let subpath = (&path_str[6..]).trim_start_matches('/'); + + if subpath.is_empty() { + // List of ACPI tables + if (flags & O_DIRECTORY == 0 && flags & O_STAT == 0) || (flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR) { + return Err(Error::new(EISDIR)); + } + Handle::Tables(0) + } else { + if (flags & O_DIRECTORY != 0 && flags & O_STAT == 0) { + return Err(Error::new(ENOTDIR)); + } + if flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR { + return Err(Error::new(EINVAL)); + } + let (name, oem_id, oem_table_id) = parse_table_filename(subpath.as_bytes()).ok_or(Error::new(ENOENT))?; + + if self.lookup_signature_index(name, oem_id, oem_table_id).is_none() { + return Err(Error::new(ENOENT)); + } + Handle::Table { + name, + oem_id, + oem_table_id, + offset: 0, + } + } + } else if path.is_empty() { + // Top-level + if (flags & O_DIRECTORY == 0 && flags & O_STAT == 0) || (flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR) { + return Err(Error::new(EISDIR)); + } + Handle::TopLevel(0) + } else { + return Err(Error::new(ENOENT)); + }; + let new_fd = self.next_fd.fetch_add(1, atomic::Ordering::SeqCst); + self.handles.write().insert(new_fd, Mutex::new(new_handle)); + Ok(new_fd) + } + fn fpath(&self, id: usize, buf: &mut [u8]) -> Result { + let handles_guard = self.handles.read(); + let handle = handles_guard.get(&id).ok_or(Error::new(EBADF))?.lock(); + + Ok(match &*handle { + &Handle::TopLevel(_) => { + let path = b"acpi:"; + let max = core::cmp::min(buf.len(), path.len()); + buf[..max].copy_from_slice(&path[..]); + max + } + &Handle::Tables(_) => { + let path = b"acpi:tables"; + let max = core::cmp::min(buf.len(), path.len()); + buf[..max].copy_from_slice(&path[..]); + max + } + &Handle::Table { name, oem_id, oem_table_id, .. } => { + let base_path = b"acpi:tables/"; + let base_max = core::cmp::min(buf.len(), base_path.len()); + buf[..base_max].copy_from_slice(&base_path[..]); + serialize_table_filename(&mut buf[base_max..], (name, oem_id, oem_table_id)) + } + }) + } + fn fstat(&self, id: usize, stat: &mut Stat) -> Result { + let handles_guard = self.handles.read(); + let handle = handles_guard.get(&id).ok_or(Error::new(EBADF))?.lock(); + + match &*handle { + &Handle::TopLevel(_) => { + stat.st_mode = MODE_DIR; + stat.st_size = TOPLEVEL_DIR_CONTENTS.len() as u64; + } + &Handle::Tables(_) => { + stat.st_mode = MODE_DIR; + stat.st_size = (self.tables.len() * 35) as u64; // fixed size of 34 bytes for the file names, plus a newline + } + &Handle::Table { name, oem_id, oem_table_id, .. } => { + let len = self.lookup_signature(name, oem_id, oem_table_id).ok_or(Error::new(EBADFD))?.len; + + stat.st_mode = MODE_FILE; + stat.st_size = len as u64; + } + } + Ok(0) + } + fn seek(&self, id: usize, pos: usize, whence: usize) -> Result { + let handles_guard = self.handles.read(); + let mut handle = handles_guard.get(&id).ok_or(Error::new(EBADF))?.lock(); + + let (cur_offset, length) = match &*handle { + &Handle::TopLevel(offset) => (offset, TOPLEVEL_DIR_CONTENTS.len()), + &Handle::Tables(offset) => (offset, self.tables.len() * 35), + &Handle::Table { name, oem_id, oem_table_id, offset } => (offset, self.lookup_signature(name, oem_id, oem_table_id).ok_or(Error::new(EBADFD))?.len), + }; + let new_offset = match whence { + SEEK_CUR => core::cmp::min(cur_offset + pos, length), + SEEK_END => core::cmp::min(length + pos, length), + SEEK_SET => core::cmp::min(length, pos), + _ => return Err(Error::new(EINVAL)), + }; + match &mut *handle { + &mut Handle::Table { ref mut offset, .. } | &mut Handle::Tables(ref mut offset) | &mut Handle::TopLevel(ref mut offset) => *offset = new_offset, + } + Ok(new_offset) + } + fn read(&self, id: usize, mut buf: &mut [u8]) -> Result { + let handles_guard = self.handles.read(); + let mut handle = handles_guard.get(&id).ok_or(Error::new(EBADF))?.lock(); + + match &mut *handle { + &mut Handle::TopLevel(ref mut offset) => { + let max_bytes_to_read = core::cmp::min(buf.len(), TOPLEVEL_DIR_CONTENTS.len()); + let bytes_to_read = core::cmp::max(max_bytes_to_read, *offset) - *offset; + buf[..bytes_to_read].copy_from_slice(&TOPLEVEL_DIR_CONTENTS[*offset..*offset + bytes_to_read]); + *offset += bytes_to_read; + Ok(bytes_to_read) + } + &mut Handle::Tables(ref mut offset) => { + if *offset >= self.tables.len() * 35 { + return Ok(0); + } + // one really good thing with fixed size filenames, is that no index has to be + // stored anywhere! + let base_table_index = *offset / 35; + let mut bytes_to_skip = *offset % 35; + let mut bytes_read = 0; + + for index in base_table_index..self.tables.len() { + let &(ref name_string, oem_id, oem_table_id) = &self.tables[index].0; + let signature = (name_string.as_bytes().try_into().or(Err(Error::new(EIO)))?, oem_id, oem_table_id); + + let mut src_buf = [0u8; 35]; + serialize_table_filename(&mut src_buf[..34], signature); + src_buf[34] = b'\n'; + + let max_bytes_to_read = core::cmp::min(buf.len(), src_buf.len()); + let bytes_to_read = core::cmp::max(max_bytes_to_read, bytes_to_skip) - bytes_to_skip; + buf[..bytes_to_read].copy_from_slice(&src_buf[..bytes_to_read]); + bytes_read += bytes_to_read; + bytes_to_skip = 0; + buf = &mut buf[..bytes_to_read]; + } + *offset += bytes_read; + Ok(bytes_read) + } + &mut Handle::Table { + name, + oem_id, + oem_table_id, + ref mut offset, + } => { + let index = self.lookup_signature_index(name, oem_id, oem_table_id).ok_or(Error::new(EBADFD))?; + let (_, PhysSlice { phys_ptr, len, virt: old_virt }) = self.tables[index]; + assert_eq!(phys_ptr, old_virt); + let new_virt = crate::acpi::get_sdt(phys_ptr, unsafe { &mut ActivePageTable::new() }) as *const Sdt as usize; + + let table_contents = unsafe { core::slice::from_raw_parts(new_virt as *const u8, len) }; + + let max_bytes_to_read = core::cmp::min(buf.len(), table_contents.len()); + let bytes_to_read = core::cmp::max(max_bytes_to_read, *offset) - *offset; + buf[..bytes_to_read].copy_from_slice(&table_contents[*offset..*offset + bytes_to_read]); + *offset += bytes_to_read; + Ok(bytes_to_read) + } + } + } + fn write(&self, id: usize, buf: &[u8]) -> Result { + Err(Error::new(EBADF)) + } +} diff --git a/src/scheme/mod.rs b/src/scheme/mod.rs index e539de9..5f92107 100644 --- a/src/scheme/mod.rs +++ b/src/scheme/mod.rs @@ -16,6 +16,9 @@ use spin::{Once, RwLock, RwLockReadGuard, RwLockWriteGuard}; use crate::syscall::error::*; use crate::syscall::scheme::Scheme; +#[cfg(feature = "acpi")] +use self::acpi::AcpiScheme; + use self::debug::DebugScheme; use self::event::EventScheme; use self::initfs::InitFsScheme; @@ -28,6 +31,10 @@ use self::root::RootScheme; use self::sys::SysScheme; use self::time::TimeScheme; +/// When compiled with the "acpi" feature - `acpi:` - allows drivers to read a limited set of ACPI tables. +#[cfg(feature = "acpi")] +pub mod acpi; + /// `debug:` - provides access to serial console pub mod debug; @@ -136,6 +143,9 @@ impl SchemeList { let ns = self.new_ns(); // These schemes should only be available on the root + #[cfg(feature = "acpi")] { + self.insert(ns, Box::new(*b"acpi"), |_| Arc::new(AcpiScheme::new())).unwrap(); + } self.insert(ns, Box::new(*b"debug"), |scheme_id| Arc::new(DebugScheme::new(scheme_id))).unwrap(); self.insert(ns, Box::new(*b"initfs"), |_| Arc::new(InitFsScheme::new())).unwrap(); self.insert(ns, Box::new(*b"irq"), |scheme_id| Arc::new(IrqScheme::new(scheme_id))).unwrap();