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

Merge branch 'updated_rustc_and_futex_fixes' into 'master'

Browse Source 
Fixes for futex and newer rustc

See merge request redox-os/kernel!209
This commit is contained in:
Jeremy Soller
2023-05-02 22:11:53 +00:00
parent 37ba7c63b4 50b877d1aa
commit 3a6732eaad
6 changed files with 78 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/arch/x86/idt.rs
+1 -1
View File
@@ -27,7 +27,7 @@ pub static mut IDTR: DescriptorTablePointer<X86IdtEntry> = DescriptorTablePointe
pub type IdtEntries = [IdtEntry; 256];
pub type IdtReservations = [AtomicU32; 8];
#[repr(packed)]
#[repr(C)]
pub struct Idt {
entries: IdtEntries,
reservations: IdtReservations,
src/arch/x86_64/idt.rs
+1 -1
View File
@@ -27,7 +27,7 @@ pub static mut IDTR: DescriptorTablePointer<X86IdtEntry> = DescriptorTablePointe
pub type IdtEntries = [IdtEntry; 256];
pub type IdtReservations = [AtomicU64; 4];
#[repr(packed)]
#[repr(C)]
pub struct Idt {
entries: IdtEntries,
reservations: IdtReservations,
src/devices/uart_16550.rs
+16 -12
View File
@@ -1,4 +1,5 @@
use core::convert::TryInto;
use core::ptr::{addr_of, addr_of_mut};
use crate::syscall::io::{Io, Mmio, ReadOnly};
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
@@ -70,20 +71,23 @@ where
T::Value: From<u8> + TryInto<u8>,
{
pub fn init(&mut self) {
//TODO: Cleanup
self.int_en.write(0x00.into());
self.line_ctrl.write(0x80.into());
self.data.write(0x01.into());
self.int_en.write(0x00.into());
self.line_ctrl.write(0x03.into());
self.fifo_ctrl.write(0xC7.into());
self.modem_ctrl.write(0x0B.into());
self.int_en.write(0x01.into());
unsafe {
//TODO: Cleanup
// FIXME: Fix UB if unaligned
(&mut *addr_of_mut!(self.int_en)).write(0x00.into());
(&mut *addr_of_mut!(self.line_ctrl)).write(0x80.into());
(&mut *addr_of_mut!(self.data)).write(0x01.into());
(&mut *addr_of_mut!(self.int_en)).write(0x00.into());
(&mut *addr_of_mut!(self.line_ctrl)).write(0x03.into());
(&mut *addr_of_mut!(self.fifo_ctrl)).write(0xC7.into());
(&mut *addr_of_mut!(self.modem_ctrl)).write(0x0B.into());
(&mut *addr_of_mut!(self.int_en)).write(0x01.into());
}
}
fn line_sts(&self) -> LineStsFlags {
LineStsFlags::from_bits_truncate(
(self.line_sts.read() & 0xFF.into())
(unsafe { &*addr_of!(self.line_sts) }.read() & 0xFF.into())
.try_into()
.unwrap_or(0),
)
@@ -92,7 +96,7 @@ where
pub fn receive(&mut self) -> Option<u8> {
if self.line_sts().contains(LineStsFlags::INPUT_FULL) {
Some(
(self.data.read() & 0xFF.into())
(unsafe { &*addr_of!(self.data) }.read() & 0xFF.into())
.try_into()
.unwrap_or(0),
)
@@ -103,7 +107,7 @@ where
pub fn send(&mut self, data: u8) {
while !self.line_sts().contains(LineStsFlags::OUTPUT_EMPTY) {}
self.data.write(data.into())
unsafe { &mut *addr_of_mut!(self.data) }.write(data.into())
}
pub fn write(&mut self, buf: &[u8]) {
src/lib.rs
-2
View File
@@ -3,8 +3,6 @@
//! The Redox OS Kernel is a microkernel that supports `x86_64` systems and
//! provides Unix-like syscalls for primarily Rust applications
//TODO: fix the need to generate references to packed fields
#![allow(unaligned_references)]
// Useful for adding comments about different branches
#![allow(clippy::if_same_then_else)]
// Useful in the syscall function
src/scheme/proc.rs
+9 -4
View File
@@ -1358,11 +1358,16 @@ impl KernelScheme for ProcScheme {
extern "C" fn clone_handler() {
let context_lock = Arc::clone(context::contexts().current().expect("expected the current context to be set in a spawn closure"));
unsafe {
let [ip, sp] = context_lock.read().clone_entry.expect("clone_entry must be set");
let [arg, is_singlestep] = [0; 2];
loop {
unsafe {
let Some([ip, sp]) = ({ context_lock.read().clone_entry }) else {
context_lock.write().status = Status::Stopped(SIGSTOP);
continue;
};
let [arg, is_singlestep] = [0; 2];
crate::start::usermode(ip, sp, arg, is_singlestep);
crate::start::usermode(ip, sp, arg, is_singlestep);
}
}
}
src/syscall/futex.rs
+51 -69
View File
@@ -2,20 +2,19 @@
//! Futex or Fast Userspace Mutex is "a method for waiting until a certain condition becomes true."
//!
//! For more information about futexes, please read [this](https://eli.thegreenplace.net/2018/basics-of-futexes/) blog post, and the [futex(2)](http://man7.org/linux/man-pages/man2/futex.2.html) man page
use alloc::sync::Arc;
use alloc::collections::VecDeque;
use alloc::sync::Arc;
use core::intrinsics;
use spin::{Once, RwLock, RwLockReadGuard, RwLockWriteGuard};
use spin::RwLock;
use rmm::Arch;
use crate::context::{self, Context};
use crate::time;
use crate::context::{self, memory::AddrSpace, Context};
use crate::memory::PhysicalAddress;
use crate::paging::VirtualAddress;
use crate::paging::{Page, VirtualAddress};
use crate::time;
use crate::syscall::data::TimeSpec;
use crate::syscall::error::{Error, Result, ESRCH, EAGAIN, EFAULT, EINVAL};
use crate::syscall::flag::{FUTEX_WAIT, FUTEX_WAIT64, FUTEX_WAKE, FUTEX_REQUEUE};
use crate::syscall::error::{Error, Result, EAGAIN, EFAULT, EINVAL, ESRCH};
use crate::syscall::flag::{FUTEX_REQUEUE, FUTEX_WAIT, FUTEX_WAIT64, FUTEX_WAKE};
use crate::syscall::validate::validate_array;
type FutexList = VecDeque<FutexEntry>;
@@ -25,42 +24,30 @@ pub struct FutexEntry {
context_lock: Arc<RwLock<Context>>,
}
/// Fast userspace mutex list
static FUTEXES: Once<RwLock<FutexList>> = Once::new();
// TODO: Process-private futexes? In that case, put the futex table in each AddrSpace.
// TODO: Hash table?
static FUTEXES: RwLock<FutexList> = RwLock::new(FutexList::new());
/// Initialize futexes, called if needed
fn init_futexes() -> RwLock<FutexList> {
RwLock::new(VecDeque::new())
}
fn validate_and_translate_virt(space: &AddrSpace, addr: VirtualAddress) -> Option<PhysicalAddress> {
// TODO: Move this elsewhere!
if addr.data().saturating_add(core::mem::size_of::<usize>()) >= crate::USER_END_OFFSET {
return None;
}
/// Get the global futexes list, const
pub fn futexes() -> RwLockReadGuard<'static, FutexList> {
FUTEXES.call_once(init_futexes).read()
}
let page = Page::containing_address(addr);
let off = addr.data() - page.start_address().data();
/// Get the global futexes list, mutable
pub fn futexes_mut() -> RwLockWriteGuard<'static, FutexList> {
FUTEXES.call_once(init_futexes).write()
let (frame, _) = space.table.utable.translate(page.start_address())?;
Some(frame.add(off))
}
pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> Result<usize> {
let addr_space = Arc::clone(context::current()?.read().addr_space()?);
let (target_physaddr, _) = {
let virtual_address = VirtualAddress::new(addr);
if !crate::CurrentRmmArch::virt_is_valid(virtual_address) {
return Err(Error::new(EFAULT));
}
// TODO: Use this all over the code, making sure that no user pointers that are higher half
// can get to the page table walking procedure.
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
if virtual_address.data() & (1 << 63) == (1 << 63) {
return Err(Error::new(EFAULT));
}
addr_space.read().table.utable.translate(virtual_address).ok_or(Error::new(EFAULT))?
};
let target_physaddr =
validate_and_translate_virt(&*addr_space.read(), VirtualAddress::new(addr))
.ok_or(Error::new(EFAULT))?;
match op {
// TODO: FUTEX_WAIT_MULTIPLE?
@@ -75,28 +62,31 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
};
{
let mut futexes = futexes_mut();
let mut futexes = FUTEXES.write();
let context_lock = {
let contexts = context::contexts();
let context_lock = contexts.current().ok_or(Error::new(ESRCH))?;
Arc::clone(context_lock)
};
let context_lock = context::current()?;
// TODO: Is the implicit SeqCst ordering too strong here?
let (fetched, expected) = if op == FUTEX_WAIT {
// Must be aligned, otherwise it could cross a page boundary and mess up the
// (simpler) validation we did in the first place.
if addr % 4 != 0 {
return Err(Error::new(EINVAL));
}
(u64::from(unsafe { intrinsics::atomic_load_seqcst::<u32>(addr as *const u32) }), u64::from(val as u32))
(
u64::from(unsafe {
intrinsics::atomic_load_seqcst::<u32>(addr as *const u32)
}),
u64::from(val as u32),
)
} else {
// op == FUTEX_WAIT64
if addr % 8 != 0 {
return Err(Error::new(EINVAL));
}
(unsafe { intrinsics::atomic_load_seqcst::<u64>(addr as *const u64) }, val as u64)
(
unsafe { intrinsics::atomic_load_seqcst::<u64>(addr as *const u64) },
val as u64,
)
};
if fetched != expected {
return Err(Error::new(EAGAIN));
@@ -107,7 +97,9 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
if let Some(timeout) = timeout_opt {
let start = time::monotonic();
let end = start + (timeout.tv_sec as u128 * time::NANOS_PER_SEC) + (timeout.tv_nsec as u128);
let end = start
+ (timeout.tv_sec as u128 * time::NANOS_PER_SEC)
+ (timeout.tv_nsec as u128);
context.wake = Some(end);
}
@@ -120,7 +112,9 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
});
}
unsafe { context::switch(); }
unsafe {
context::switch();
}
if timeout_opt.is_some() {
let context_lock = {
@@ -136,12 +130,12 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
}
Ok(0)
},
}
FUTEX_WAKE => {
let mut woken = 0;
{
let mut futexes = futexes_mut();
let mut futexes = FUTEXES.write();
let mut i = 0;
@@ -160,29 +154,17 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
}
Ok(woken)
},
}
FUTEX_REQUEUE => {
let (addr2_physaddr, _) = {
let addr2_virt = VirtualAddress::new(addr2);
if !crate::CurrentRmmArch::virt_is_valid(addr2_virt) {
return Err(Error::new(EFAULT));
}
// TODO
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
if addr2_virt.data() & (1 << 63) == (1 << 63) {
return Err(Error::new(EFAULT));
}
addr_space.read().table.utable.translate(addr2_virt).ok_or(Error::new(EFAULT))?
};
let addr2_physaddr =
validate_and_translate_virt(&*addr_space.read(), VirtualAddress::new(addr2))
.ok_or(Error::new(EFAULT))?;
let mut woken = 0;
let mut requeued = 0;
{
let mut futexes = futexes_mut();
let mut futexes = FUTEXES.write();
let mut i = 0;
while i < futexes.len() && woken < val {
@@ -204,7 +186,7 @@ pub fn futex(addr: usize, op: usize, val: usize, val2: usize, addr2: usize) -> R
}
Ok(woken)
},
_ => Err(Error::new(EINVAL))
}
_ => Err(Error::new(EINVAL)),
}
}