GKaszewski/k-os
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: cargo fmt kernel crates

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-10-26 19:07:54 +01:00
parent 818eaecadd
commit 1c04ddf909
50 changed files with 995 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
crates/kernel/src/interrupt.rs
View File

@@ -26,15 +26,26 @@ impl<P: Platform> Kernel<P> {
self.scheduler.add(current_tid, priority, core);
match self.scheduler.next(core) {
Some(next) => {
if self.threads.get_mut(next).and_then(|t| t.set_running(core)).is_ok() {
if self
.threads
.get_mut(next)
.and_then(|t| t.set_running(core))
.is_ok()
{
SchedulerDecision::Preempt(next)
} else {
let _ = self.threads.get_mut(current_tid).map(|t| t.set_running(core));
let _ = self
.threads
.get_mut(current_tid)
.map(|t| t.set_running(core));
SchedulerDecision::Continue
}
}
None => {
let _ = self.threads.get_mut(current_tid).map(|t| t.set_running(core));
let _ = self
.threads
.get_mut(current_tid)
.map(|t| t.set_running(core));
SchedulerDecision::Continue
}
}

64
crates/kernel/src/lib.rs
View File

@@ -16,17 +16,13 @@ use domain::{
endpoint::EndpointTable,
error::KernelError,
irq::IrqRoutingTable,
memory::{
page_pool::PagePool,
process_memory::ProcessMemory,
RegionTable,
},
memory::{RegionTable, page_pool::PagePool, process_memory::ProcessMemory},
message::Message,
process::{ProcessTable, MAX_PROCESSES},
process::{MAX_PROCESSES, ProcessTable},
resource::Resource,
scheduler::{multi_core::MultiCoreScheduler, Scheduler},
scheduler::{Scheduler, multi_core::MultiCoreScheduler},
syscall::WaitSet,
thread::{ThreadTable, ThreadState, MAX_THREADS},
thread::{MAX_THREADS, ThreadState, ThreadTable},
};
use platform::Platform;
use types::{
@@ -88,7 +84,10 @@ impl<P: Platform> Kernel<P> {
PermissionSet::empty().with(Permission::Execute),
Generation::initial(),
);
self.processes.get_mut(pid)?.capabilities_mut().insert(cap)?;
self.processes
.get_mut(pid)?
.capabilities_mut()
.insert(cap)?;
let core = self.platform.core_id();
self.scheduler.add(tid, priority, core);
@@ -109,7 +108,11 @@ impl<P: Platform> Kernel<P> {
self.pending_results[thread.raw() as usize].take()
}
pub fn set_thread_running(&mut self, tid: ThreadId, core: types::id::CoreId) -> Result<(), domain::error::KernelError> {
pub fn set_thread_running(
&mut self,
tid: ThreadId,
core: types::id::CoreId,
) -> Result<(), domain::error::KernelError> {
self.threads.get_mut(tid)?.set_running(core)
}
@@ -125,8 +128,14 @@ impl<P: Platform> Kernel<P> {
self.threads.get(tid).ok().map(|t| t.saved_context())
}
pub fn thread_context_mut(&mut self, tid: ThreadId) -> Option<&mut domain::thread::SavedContext> {
self.threads.get_mut(tid).ok().map(|t| t.saved_context_mut())
pub fn thread_context_mut(
&mut self,
tid: ThreadId,
) -> Option<&mut domain::thread::SavedContext> {
self.threads
.get_mut(tid)
.ok()
.map(|t| t.saved_context_mut())
}
pub fn thread_process(&self, tid: ThreadId) -> Option<ProcessId> {
@@ -147,21 +156,19 @@ impl<P: Platform> Kernel<P> {
pub fn create_process_internal(&mut self) -> Option<ProcessId> {
let pid = self.processes.create(CapabilityTable::new(), None).ok()?;
self.process_memory[pid.raw() as usize] =
Some(domain::memory::process_memory::ProcessMemory::new(pid, ProcessMemory::DEFAULT_PAGE_LIMIT));
Some(domain::memory::process_memory::ProcessMemory::new(
pid,
ProcessMemory::DEFAULT_PAGE_LIMIT,
));
Some(pid)
}
pub fn spawn_thread_internal(
&mut self,
pid: ProcessId,
) -> Option<ThreadId> {
pub fn spawn_thread_internal(&mut self, pid: ProcessId) -> Option<ThreadId> {
use domain::scheduler::Scheduler;
let tid = self.threads.spawn(
pid,
Priority::DEFAULT,
TimeSlice::DEFAULT,
None,
).ok()?;
let tid = self
.threads
.spawn(pid, Priority::DEFAULT, TimeSlice::DEFAULT, None)
.ok()?;
let _ = self.processes.get_mut(pid).map(|p| p.add_thread(tid));
let core = self.platform.core_id();
self.scheduler.add(tid, Priority::DEFAULT, core);
@@ -208,7 +215,9 @@ impl<P: Platform> Kernel<P> {
fn caller(&self) -> Result<(ThreadId, ProcessId), KernelError> {
let core = self.platform.core_id();
let tid = self.scheduler.current(core)
let tid = self
.scheduler
.current(core)
.ok_or(KernelError::WouldBlock)?;
let thread = self.threads.get(tid)?;
match thread.state() {
@@ -220,11 +229,14 @@ impl<P: Platform> Kernel<P> {
pub(crate) fn destroy_process(&mut self, pid: ProcessId) {
use domain::process::MAX_THREADS_PER_PROCESS;
let thread_ids: [Option<ThreadId>; MAX_THREADS_PER_PROCESS] = match self.processes.get(pid) {
let thread_ids: [Option<ThreadId>; MAX_THREADS_PER_PROCESS] = match self.processes.get(pid)
{
Ok(p) => {
let mut ids = [None; MAX_THREADS_PER_PROCESS];
for (i, tid) in p.thread_ids().enumerate() {
if i < MAX_THREADS_PER_PROCESS { ids[i] = Some(tid); }
if i < MAX_THREADS_PER_PROCESS {
ids[i] = Some(tid);
}
}
ids
}

41
crates/kernel/src/proofs/delegation.rs
View File

@@ -1,6 +1,6 @@
use super::{arbitrary_endpoint_cap, insert_cap};
use domain::capability::{Capability, CapabilityTable};
use domain::resource::Resource;
use super::{arbitrary_endpoint_cap, insert_cap};
use types::generation::Generation;
use types::id::EndpointId;
use types::permission::{Permission, PermissionSet};
@@ -16,17 +16,16 @@ fn kernel_delegate_path_never_escalates() {
kani::assume(source_perms.allows(Permission::Delegate));
let mut source_table = CapabilityTable::new();
let slot = insert_cap(&mut source_table, arbitrary_endpoint_cap(source_bits, ep_id));
let slot = insert_cap(
&mut source_table,
arbitrary_endpoint_cap(source_bits, ep_id),
);
let cap = source_table.get(slot).unwrap();
let original_perms = *cap.permissions();
let restricted = original_perms.restrict_to(&PermissionSet::from_bits(restrict_bits));
let delegated = Capability::new(
cap.resource().clone(),
restricted,
Generation::initial(),
);
let delegated = Capability::new(cap.resource().clone(), restricted, Generation::initial());
let mut target_table = CapabilityTable::new();
let target_slot = insert_cap(&mut target_table, delegated);
@@ -34,11 +33,21 @@ fn kernel_delegate_path_never_escalates() {
let result = target_table.get(target_slot).unwrap();
assert!(result.permissions().is_subset_of(&original_perms));
if !original_perms.allows(Permission::Read) { assert!(!result.permissions().allows(Permission::Read)); }
if !original_perms.allows(Permission::Write) { assert!(!result.permissions().allows(Permission::Write)); }
if !original_perms.allows(Permission::Execute) { assert!(!result.permissions().allows(Permission::Execute)); }
if !original_perms.allows(Permission::Delegate) { assert!(!result.permissions().allows(Permission::Delegate)); }
if !original_perms.allows(Permission::Revoke) { assert!(!result.permissions().allows(Permission::Revoke)); }
if !original_perms.allows(Permission::Read) {
assert!(!result.permissions().allows(Permission::Read));
}
if !original_perms.allows(Permission::Write) {
assert!(!result.permissions().allows(Permission::Write));
}
if !original_perms.allows(Permission::Execute) {
assert!(!result.permissions().allows(Permission::Execute));
}
if !original_perms.allows(Permission::Delegate) {
assert!(!result.permissions().allows(Permission::Delegate));
}
if !original_perms.allows(Permission::Revoke) {
assert!(!result.permissions().allows(Permission::Revoke));
}
}
#[kani::proof]
@@ -58,7 +67,9 @@ fn kernel_chained_delegate_never_escalates() {
let slot_a = insert_cap(&mut table_a, arbitrary_endpoint_cap(original_bits, ep_id));
let cap = table_a.get(slot_a).unwrap();
let perms_for_b = cap.permissions().restrict_to(&PermissionSet::from_bits(restrict1_bits));
let perms_for_b = cap
.permissions()
.restrict_to(&PermissionSet::from_bits(restrict1_bits));
let mut table_b = CapabilityTable::new();
let cap_b = Capability::new(resource.clone(), perms_for_b, Generation::initial());
@@ -66,7 +77,9 @@ fn kernel_chained_delegate_never_escalates() {
let cap_in_b = table_b.get(slot_b).unwrap();
if cap_in_b.permissions().allows(Permission::Delegate) {
let perms_for_c = cap_in_b.permissions().restrict_to(&PermissionSet::from_bits(restrict2_bits));
let perms_for_c = cap_in_b
.permissions()
.restrict_to(&PermissionSet::from_bits(restrict2_bits));
let mut table_c = CapabilityTable::new();
let cap_c = Capability::new(resource, perms_for_c, Generation::initial());

10
crates/kernel/src/proofs/mediation.rs
View File

@@ -1,5 +1,5 @@
use domain::capability::CapabilityTable;
use super::{arbitrary_endpoint_cap, insert_cap};
use domain::capability::CapabilityTable;
use types::bounded::CapSlot;
use types::permission::{Permission, PermissionSet};
@@ -60,7 +60,11 @@ fn check_cap_faithfully_reflects_stored_permissions() {
assert!(retrieved.permissions().allows(Permission::Read) == perms.allows(Permission::Read));
assert!(retrieved.permissions().allows(Permission::Write) == perms.allows(Permission::Write));
assert!(retrieved.permissions().allows(Permission::Execute) == perms.allows(Permission::Execute));
assert!(retrieved.permissions().allows(Permission::Delegate) == perms.allows(Permission::Delegate));
assert!(
retrieved.permissions().allows(Permission::Execute) == perms.allows(Permission::Execute)
);
assert!(
retrieved.permissions().allows(Permission::Delegate) == perms.allows(Permission::Delegate)
);
assert!(retrieved.permissions().allows(Permission::Revoke) == perms.allows(Permission::Revoke));
}

18
crates/kernel/src/proofs/revocation.rs
View File

@@ -1,7 +1,7 @@
use super::{arbitrary_endpoint_cap, insert_cap};
use domain::capability::{Capability, CapabilityTable};
use domain::endpoint::Endpoint;
use domain::resource::Resource;
use super::{arbitrary_endpoint_cap, insert_cap};
use types::generation::Generation;
use types::id::EndpointId;
use types::permission::{Permission, PermissionSet};
@@ -81,12 +81,24 @@ fn generation_revocation_invalidates_all_caps() {
let mut table = CapabilityTable::new();
let slot = insert_cap(&mut table, cap);
assert!(table.get(slot).unwrap().generation().is_valid_against(&original_gen));
assert!(
table
.get(slot)
.unwrap()
.generation()
.is_valid_against(&original_gen)
);
endpoint.revoke();
let new_gen = *endpoint.generation();
assert!(!table.get(slot).unwrap().generation().is_valid_against(&new_gen));
assert!(
!table
.get(slot)
.unwrap()
.generation()
.is_valid_against(&new_gen)
);
}
#[kani::proof]

42
crates/kernel/src/syscall/capability.rs
View File

@@ -11,14 +11,11 @@ impl<P: Platform> Kernel<P> {
to_endpoint: types::bounded::CapSlot,
restrict: types::permission::PermissionSet,
) -> SyscallOutcome {
let (resource, permissions) = match self.check_cap(
caller_pid,
slot,
types::permission::Permission::Delegate,
) {
Ok(cap) => (cap.resource().clone(), *cap.permissions()),
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let (resource, permissions) =
match self.check_cap(caller_pid, slot, types::permission::Permission::Delegate) {
Ok(cap) => (cap.resource().clone(), *cap.permissions()),
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let restricted = permissions.restrict_to(&restrict);
@@ -29,12 +26,14 @@ impl<P: Platform> Kernel<P> {
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: to_endpoint,
needed: types::permission::Permission::Execute,
},
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: to_endpoint,
needed: types::permission::Permission::Execute,
},
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
@@ -45,12 +44,8 @@ impl<P: Platform> Kernel<P> {
if let domain::resource::Resource::Memory(region_id) = &resource {
if let Some(region) = self.regions.get(*region_id) {
self.platform.map_shared(
target_pid,
region.base(),
region.size(),
restricted,
);
self.platform
.map_shared(target_pid, region.base(), region.size(), restricted);
}
}
@@ -62,11 +57,8 @@ impl<P: Platform> Kernel<P> {
caller_pid: types::id::ProcessId,
slot: types::bounded::CapSlot,
) -> SyscallOutcome {
let resource = match self.check_cap(
caller_pid,
slot,
types::permission::Permission::Revoke,
) {
let resource = match self.check_cap(caller_pid, slot, types::permission::Permission::Revoke)
{
Ok(cap) => cap.resource().clone(),
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};

144
crates/kernel/src/syscall/ipc.rs
View File

@@ -48,26 +48,34 @@ impl<P: Platform> Kernel<P> {
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Endpoint(id) => *id,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(types::id::EndpointId::from_raw(0)),
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(
types::id::EndpointId::from_raw(0),
),
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let endpoint = match self.endpoints.get_mut(ep_id) {
Some(ep) => ep,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
));
}
};
if endpoint.has_waiting_receiver() {
let receiver_tid = match endpoint.dequeue_receiver() {
Some(t) => t,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::WouldBlock,
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::WouldBlock,
));
}
};
self.pending_results[receiver_tid.raw() as usize] =
@@ -98,9 +106,11 @@ impl<P: Platform> Kernel<P> {
let endpoint = match self.endpoints.get_mut(ep_id) {
Some(ep) => ep,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
));
}
};
if endpoint.enqueue_sender(caller_tid).is_none() {
self.pending_messages[caller_tid.raw() as usize] = None;
@@ -135,30 +145,41 @@ impl<P: Platform> Kernel<P> {
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Endpoint(id) => *id,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(types::id::EndpointId::from_raw(0)),
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(
types::id::EndpointId::from_raw(0),
),
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let endpoint = match self.endpoints.get_mut(ep_id) {
Some(ep) => ep,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
));
}
};
if endpoint.has_waiting_sender() {
let sender_tid = match endpoint.dequeue_sender() {
Some(t) => t,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::WouldBlock,
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::WouldBlock,
));
}
};
let message = self.pending_messages[sender_tid.raw() as usize].take();
debug_assert!(message.is_some(), "sender in wait queue had no pending message");
debug_assert!(
message.is_some(),
"sender in wait queue had no pending message"
);
let message = message.unwrap_or_else(|| domain::message::Message::empty());
self.pending_results[sender_tid.raw() as usize] = Some(SyscallResult::Ok);
@@ -176,9 +197,11 @@ impl<P: Platform> Kernel<P> {
} else {
let endpoint = match self.endpoints.get_mut(ep_id) {
Some(ep) => ep,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidEndpoint(ep_id),
));
}
};
if endpoint.enqueue_receiver(caller_tid).is_none() {
return SyscallOutcome::Complete(SyscallResult::Error(
@@ -205,16 +228,15 @@ impl<P: Platform> Kernel<P> {
) -> SyscallOutcome {
use domain::scheduler::Scheduler;
let irq_id = match self.check_cap(
caller_pid,
irq_slot,
types::permission::Permission::Read,
) {
let irq_id = match self.check_cap(caller_pid, irq_slot, types::permission::Permission::Read)
{
Ok(cap) => match cap.resource() {
domain::resource::Resource::Interrupt(id) => *id,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidIrq(types::id::IrqId::from_raw(0)),
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidIrq(types::id::IrqId::from_raw(0)),
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
@@ -236,19 +258,18 @@ impl<P: Platform> Kernel<P> {
caller_pid: types::id::ProcessId,
irq_slot: types::bounded::CapSlot,
) -> SyscallOutcome {
let irq_id = match self.check_cap(
caller_pid,
irq_slot,
types::permission::Permission::Write,
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Interrupt(id) => *id,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidIrq(types::id::IrqId::from_raw(0)),
)),
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let irq_id =
match self.check_cap(caller_pid, irq_slot, types::permission::Permission::Write) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Interrupt(id) => *id,
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidIrq(types::id::IrqId::from_raw(0)),
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
self.platform.unmask_irq(irq_id);
SyscallOutcome::Complete(SyscallResult::Ok)
@@ -270,17 +291,14 @@ impl<P: Platform> Kernel<P> {
for ep_slot in sources.endpoints() {
if let Some(slot) = ep_slot {
let ep_id = match self.check_cap(
caller_pid,
*slot,
types::permission::Permission::Read,
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Endpoint(id) => *id,
_ => continue,
},
Err(_) => continue,
};
let ep_id =
match self.check_cap(caller_pid, *slot, types::permission::Permission::Read) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Endpoint(id) => *id,
_ => continue,
},
Err(_) => continue,
};
if let Some(ep) = self.endpoints.get_mut(ep_id) {
if ep.has_waiting_sender() {
@@ -294,11 +312,9 @@ impl<P: Platform> Kernel<P> {
for irq_slot in sources.interrupts() {
if let Some(slot) = irq_slot {
if let Ok(cap) = self.check_cap(
caller_pid,
*slot,
types::permission::Permission::Read,
) {
if let Ok(cap) =
self.check_cap(caller_pid, *slot, types::permission::Permission::Read)
{
if let domain::resource::Resource::Interrupt(irq_id) = cap.resource() {
if self.irqs.owner(*irq_id).is_some() {
return SyscallOutcome::Complete(SyscallResult::WakeReason(
@@ -312,7 +328,9 @@ impl<P: Platform> Kernel<P> {
for ep_slot in sources.endpoints() {
if let Some(slot) = ep_slot {
if let Ok(cap) = self.check_cap(caller_pid, *slot, types::permission::Permission::Read) {
if let Ok(cap) =
self.check_cap(caller_pid, *slot, types::permission::Permission::Read)
{
if let domain::resource::Resource::Endpoint(id) = cap.resource() {
if let Some(ep) = self.endpoints.get_mut(*id) {
let _ = ep.enqueue_receiver(caller_tid);

69
crates/kernel/src/syscall/lifecycle.rs
View File

@@ -18,7 +18,10 @@ impl<P: Platform> Kernel<P> {
let time_slice = types::time::TimeSlice::DEFAULT;
let context = SavedContext::with_entry_and_stack(entry, stack);
let tid = match self.threads.spawn_with_context(pid, priority, time_slice, None, context) {
let tid = match self
.threads
.spawn_with_context(pid, priority, time_slice, None, context)
{
Ok(t) => t,
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
@@ -39,20 +42,27 @@ impl<P: Platform> Kernel<P> {
create_cap: types::bounded::CapSlot,
_image: types::address::DataRef,
) -> SyscallOutcome {
if let Err(e) = self.check_cap(caller_pid, create_cap, types::permission::Permission::Execute) {
if let Err(e) = self.check_cap(
caller_pid,
create_cap,
types::permission::Permission::Execute,
) {
return SyscallOutcome::Complete(SyscallResult::Error(e));
}
let new_pid = match self.processes.create(
domain::capability::CapabilityTable::new(),
None,
) {
let new_pid = match self
.processes
.create(domain::capability::CapabilityTable::new(), None)
{
Ok(p) => p,
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
self.process_memory[new_pid.raw() as usize] =
Some(domain::memory::process_memory::ProcessMemory::new(new_pid, domain::memory::process_memory::ProcessMemory::DEFAULT_PAGE_LIMIT));
Some(domain::memory::process_memory::ProcessMemory::new(
new_pid,
domain::memory::process_memory::ProcessMemory::DEFAULT_PAGE_LIMIT,
));
match self.grant_cap(
caller_pid,
@@ -88,12 +98,14 @@ impl<P: Platform> Kernel<P> {
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
@@ -102,12 +114,19 @@ impl<P: Platform> Kernel<P> {
let time_slice = types::time::TimeSlice::DEFAULT;
let context = SavedContext::with_entry_and_stack(entry, stack);
let tid = match self.threads.spawn_with_context(target_pid, priority, time_slice, None, context) {
let tid = match self
.threads
.spawn_with_context(target_pid, priority, time_slice, None, context)
{
Ok(t) => t,
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
if let Err(e) = self.processes.get_mut(target_pid).and_then(|p| p.add_thread(tid)) {
if let Err(e) = self
.processes
.get_mut(target_pid)
.and_then(|p| p.add_thread(tid))
{
let _ = self.threads.destroy(tid);
return SyscallOutcome::Complete(SyscallResult::Error(e));
}
@@ -122,15 +141,21 @@ impl<P: Platform> Kernel<P> {
caller_pid: types::id::ProcessId,
process_cap: types::bounded::CapSlot,
) -> SyscallOutcome {
let target_pid = match self.check_cap(caller_pid, process_cap, types::permission::Permission::Execute) {
let target_pid = match self.check_cap(
caller_pid,
process_cap,
types::permission::Permission::Execute,
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};

52
crates/kernel/src/syscall/memory.rs
View File

@@ -22,9 +22,11 @@ impl<P: Platform> Kernel<P> {
));
}
}
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidProcess(pid),
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidProcess(pid),
));
}
}
let phys_addr = match self.page_pool.allocate(pages) {
@@ -56,7 +58,8 @@ impl<P: Platform> Kernel<P> {
for i in 0..pages {
let page_va = VirtualAddress::from_raw(user_va.raw() + i * 4096);
let page_pa = PhysicalAddress::from_raw(phys_addr.raw() + i * 4096);
self.platform.map_user_page(pid, page_va, page_pa, true, false);
self.platform
.map_user_page(pid, page_va, page_pa, true, false);
}
let region = domain::memory::MemoryRegion::new(
@@ -96,24 +99,29 @@ impl<P: Platform> Kernel<P> {
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
)),
_ => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
));
}
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let pa = match self.platform.translate_va(caller_pid, src_va) {
Some(pa) => pa,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
};
self.platform.map_user_page(target_pid, dst_va, pa, !executable, executable);
self.platform
.map_user_page(target_pid, dst_va, pa, !executable, executable);
SyscallOutcome::Complete(SyscallResult::Ok)
}
@@ -127,16 +135,20 @@ impl<P: Platform> Kernel<P> {
let pages = count.value() as usize;
let phys = match self.platform.translate_va(pid, addr) {
Some(pa) => pa,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
};
let region_id = match self.regions.find_by_base(pid, phys) {
Some((rid, _)) => rid,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
)),
None => {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
};
if !self.page_pool.free(phys, pages) {

29
crates/kernel/src/syscall/mod.rs
View File

@@ -43,12 +43,16 @@ impl<P: Platform> Kernel<P> {
Syscall::RequestPages { count } => self.handle_request_pages(pid, count),
Syscall::ReleasePages { addr, count } => self.handle_release_pages(pid, addr, count),
Syscall::SpawnThread { entry, stack } => self.handle_spawn_thread(pid, entry, stack),
Syscall::CreateProcess { create_cap, image } => self.handle_create_process(pid, create_cap, image),
Syscall::CreateProcess { create_cap, image } => {
self.handle_create_process(pid, create_cap, image)
}
Syscall::Kill { process } => self.handle_kill(pid, process),
Syscall::Revoke { slot } => self.handle_revoke(pid, slot),
Syscall::Delegate { slot, to_endpoint, permissions } => {
self.handle_delegate(pid, slot, to_endpoint, permissions)
}
Syscall::Delegate {
slot,
to_endpoint,
permissions,
} => self.handle_delegate(pid, slot, to_endpoint, permissions),
Syscall::Send { endpoint, message } => self.handle_send(tid, pid, endpoint, message),
Syscall::Receive { endpoint } => self.handle_receive(tid, pid, endpoint),
Syscall::WaitForInterrupt { irq } => self.handle_wait_for_interrupt(tid, pid, irq),
@@ -57,12 +61,17 @@ impl<P: Platform> Kernel<P> {
Syscall::Halt => self.handle_halt(pid),
Syscall::CreateEndpoint => self.handle_create_endpoint(pid),
Syscall::DebugPutchar { byte } => self.handle_debug_putchar(byte),
Syscall::MapPage { process, src_va, dst_va, executable } => {
self.handle_map_page(pid, process, src_va, dst_va, executable)
}
Syscall::SpawnThreadIn { process, entry, stack } => {
self.handle_spawn_thread_in(pid, process, entry, stack)
}
Syscall::MapPage {
process,
src_va,
dst_va,
executable,
} => self.handle_map_page(pid, process, src_va, dst_va, executable),
Syscall::SpawnThreadIn {
process,
entry,
stack,
} => self.handle_spawn_thread_in(pid, process, entry, stack),
}
}
}

22
crates/kernel/src/syscall/simple.rs
View File

@@ -31,15 +31,26 @@ impl<P: Platform> Kernel<P> {
match self.scheduler.next(core) {
Some(next) if next != caller_tid => {
if self.threads.get_mut(next).and_then(|t| t.set_running(core)).is_ok() {
if self
.threads
.get_mut(next)
.and_then(|t| t.set_running(core))
.is_ok()
{
SyscallOutcome::SwitchTo(next)
} else {
let _ = self.threads.get_mut(caller_tid).map(|t| t.set_running(core));
let _ = self
.threads
.get_mut(caller_tid)
.map(|t| t.set_running(core));
SyscallOutcome::Complete(SyscallResult::Ok)
}
}
_ => {
let _ = self.threads.get_mut(caller_tid).map(|t| t.set_running(core));
let _ = self
.threads
.get_mut(caller_tid)
.map(|t| t.set_running(core));
SyscallOutcome::Complete(SyscallResult::Ok)
}
}
@@ -79,10 +90,7 @@ impl<P: Platform> Kernel<P> {
SyscallOutcome::Complete(SyscallResult::Ok)
}
pub(crate) fn handle_halt(
&mut self,
pid: types::id::ProcessId,
) -> SyscallOutcome {
pub(crate) fn handle_halt(&mut self, pid: types::id::ProcessId) -> SyscallOutcome {
if pid.raw() != 0 {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::ProcessCreateDenied,

23
crates/kernel/src/tests/capability.rs
View File

@@ -2,9 +2,9 @@ use super::*;
use crate::{SyscallOutcome, SyscallResult};
use domain::resource::Resource;
use domain::syscall::Syscall;
use types::address::DataRef;
use types::bounded::CapSlot;
use types::permission::{Permission, PermissionSet};
use types::address::DataRef;
#[test]
fn delegate_without_delegate_permission_fails() {
@@ -75,7 +75,9 @@ fn revoke_resource_invalidates_all_caps() {
let outcome = k.handle_syscall(Syscall::Receive { endpoint: cap_slot });
assert!(matches!(
outcome,
SyscallOutcome::Complete(SyscallResult::Error(domain::error::KernelError::RevokedCapability(_)))
SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::RevokedCapability(_)
))
));
}
@@ -97,7 +99,9 @@ fn new_cap_after_revoke_uses_current_generation() {
let outcome = k.handle_syscall(Syscall::Receive { endpoint: old_slot });
assert!(matches!(
outcome,
SyscallOutcome::Complete(SyscallResult::Error(domain::error::KernelError::RevokedCapability(_)))
SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::RevokedCapability(_)
))
));
// New cap with current generation works
@@ -136,7 +140,9 @@ fn revoke_does_not_affect_other_resources() {
let outcome = k.handle_syscall(Syscall::Receive { endpoint: slot1 });
assert!(matches!(
outcome,
SyscallOutcome::Complete(SyscallResult::Error(domain::error::KernelError::RevokedCapability(_)))
SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::RevokedCapability(_)
))
));
// ep2 cap still works
@@ -159,13 +165,18 @@ fn revoke_syscall_invalidates_via_generation() {
// Revoke via syscall
let outcome = k.handle_syscall(Syscall::Revoke { slot: cap_slot });
assert!(matches!(outcome, SyscallOutcome::Complete(SyscallResult::Ok)));
assert!(matches!(
outcome,
SyscallOutcome::Complete(SyscallResult::Ok)
));
// The cap itself is now revoked (generation mismatch)
let outcome = k.handle_syscall(Syscall::Receive { endpoint: cap_slot });
assert!(matches!(
outcome,
SyscallOutcome::Complete(SyscallResult::Error(domain::error::KernelError::RevokedCapability(_)))
SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::RevokedCapability(_)
))
));
}

20
crates/kernel/src/tests/helpers.rs
View File

@@ -11,8 +11,8 @@ use types::{
time::TimeSlice,
};
use crate::Kernel;
use super::mock_platform::MockPlatform;
use crate::Kernel;
pub fn test_kernel() -> Kernel<MockPlatform> {
let mock = MockPlatform::new(1);
@@ -22,9 +22,7 @@ pub fn test_kernel() -> Kernel<MockPlatform> {
pub fn kernel_with_process() -> (Kernel<MockPlatform>, ProcessId) {
let mut kernel = test_kernel();
let (pid, _tid) = kernel
.boot(Priority::DEFAULT, TimeSlice::DEFAULT)
.unwrap();
let (pid, _tid) = kernel.boot(Priority::DEFAULT, TimeSlice::DEFAULT).unwrap();
(kernel, pid)
}
@@ -35,7 +33,10 @@ impl Kernel<MockPlatform> {
priority: Priority,
time_slice: TimeSlice,
) -> ThreadId {
let tid = self.threads.spawn(pid, priority, time_slice, None).expect("spawn");
let tid = self
.threads
.spawn(pid, priority, time_slice, None)
.expect("spawn");
let _ = self.processes.get_mut(pid).map(|p| p.add_thread(tid));
let core = self.platform.core_id();
self.scheduler.add(tid, priority, core);
@@ -46,11 +47,7 @@ impl Kernel<MockPlatform> {
let _ = self.irqs.register(irq, thread);
}
pub fn block_thread_for_test(
&mut self,
tid: ThreadId,
reason: domain::thread::BlockReason,
) {
pub fn block_thread_for_test(&mut self, tid: ThreadId, reason: domain::thread::BlockReason) {
let core = self.platform.core_id();
if let Ok(t) = self.threads.get_mut(tid) {
if matches!(t.state(), ThreadState::Ready) {
@@ -95,6 +92,7 @@ impl Kernel<MockPlatform> {
resource: Resource,
permissions: PermissionSet,
) -> CapSlot {
self.grant_cap(pid, resource, permissions).expect("grant cap")
self.grant_cap(pid, resource, permissions)
.expect("grant cap")
}
}

45
crates/kernel/src/tests/ipc.rs
View File

@@ -9,11 +9,11 @@ use types::permission::{Permission, PermissionSet};
fn setup_ipc_kernel() -> (
crate::Kernel<MockPlatform>,
ProcessId, // process A
ProcessId, // process B
CapSlot, // endpoint cap for A (Execute perm)
CapSlot, // endpoint cap for B (Read perm)
ThreadId, // thread B id
ProcessId, // process A
ProcessId, // process B
CapSlot, // endpoint cap for A (Execute perm)
CapSlot, // endpoint cap for B (Read perm)
ThreadId, // thread B id
) {
let (mut k, pid_a) = kernel_with_process();
@@ -27,11 +27,7 @@ fn setup_ipc_kernel() -> (
};
let pid_b = ProcessId::from_raw(1);
let tid_b = k.spawn_thread_for_test(
pid_b,
Priority::DEFAULT,
TimeSlice::DEFAULT,
);
let tid_b = k.spawn_thread_for_test(pid_b, Priority::DEFAULT, TimeSlice::DEFAULT);
// Create an endpoint
let ep_id = k.create_endpoint_for_test();
@@ -65,7 +61,10 @@ fn send_without_receiver_blocks_caller() {
endpoint: cap_a,
message: msg,
});
assert!(matches!(outcome, SyscallOutcome::BlockCaller(BlockReason::Sending(_))));
assert!(matches!(
outcome,
SyscallOutcome::BlockCaller(BlockReason::Sending(_))
));
}
#[test]
@@ -75,10 +74,11 @@ fn receive_without_sender_blocks_caller() {
// Switch to thread B to call Receive
k.switch_to_thread_for_test(tid_b);
let outcome = k.handle_syscall(Syscall::Receive {
endpoint: cap_b,
});
assert!(matches!(outcome, SyscallOutcome::BlockCaller(BlockReason::Receiving(_))));
let outcome = k.handle_syscall(Syscall::Receive { endpoint: cap_b });
assert!(matches!(
outcome,
SyscallOutcome::BlockCaller(BlockReason::Receiving(_))
));
}
#[test]
@@ -196,10 +196,7 @@ fn wait_any_with_ready_source_returns_immediately() {
// Thread A does WaitAny on the endpoint
k.switch_to_thread_for_test(tid_a);
let wait_set = WaitSet::new(
[Some(cap_a), None, None, None],
[None, None, None, None],
);
let wait_set = WaitSet::new([Some(cap_a), None, None, None], [None, None, None, None]);
let outcome = k.handle_syscall(Syscall::WaitAny { sources: wait_set });
assert!(matches!(
outcome,
@@ -210,10 +207,7 @@ fn wait_any_with_ready_source_returns_immediately() {
#[test]
fn wait_any_with_no_ready_source_blocks() {
let (mut k, pid_a, _, cap_a, _, _) = setup_ipc_kernel();
let wait_set = WaitSet::new(
[Some(cap_a), None, None, None],
[None, None, None, None],
);
let wait_set = WaitSet::new([Some(cap_a), None, None, None], [None, None, None, None]);
let outcome = k.handle_syscall(Syscall::WaitAny { sources: wait_set });
assert!(matches!(
outcome,
@@ -224,10 +218,7 @@ fn wait_any_with_no_ready_source_blocks() {
#[test]
fn wait_any_empty_sources_returns_error() {
let (mut k, _, _, _, _, _) = setup_ipc_kernel();
let wait_set = WaitSet::new(
[None, None, None, None],
[None, None, None, None],
);
let wait_set = WaitSet::new([None, None, None, None], [None, None, None, None]);
let outcome = k.handle_syscall(Syscall::WaitAny { sources: wait_set });
assert!(matches!(
outcome,

2
crates/kernel/src/tests/memory.rs
View File

@@ -1,8 +1,8 @@
use super::*;
use crate::{SyscallOutcome, SyscallResult};
use domain::syscall::Syscall;
use types::bounded::PageCount;
use types::address::VirtualAddress;
use types::bounded::PageCount;
#[test]
fn request_pages_returns_user_va() {

40
crates/kernel/src/tests/mock_platform.rs
View File

@@ -44,14 +44,29 @@ impl Platform for MockPlatform {
loop {}
}
fn set_timer(&mut self, _duration: TimerDuration) {}
fn current_ticks(&self) -> Ticks { self.ticks }
fn current_ticks(&self) -> Ticks {
self.ticks
}
fn mask_irq(&mut self, _irq: IrqId) {}
fn unmask_irq(&mut self, _irq: IrqId) {}
fn send_ipi(&mut self, _target: CoreId) {}
fn core_id(&self) -> CoreId { self.core }
fn num_cores(&self) -> u8 { self.cores }
fn map_shared(&mut self, _process: ProcessId, _base: PhysicalAddress, _size: PageCount, _permissions: PermissionSet) {}
fn halt(&self) -> ! { loop {} }
fn core_id(&self) -> CoreId {
self.core
}
fn num_cores(&self) -> u8 {
self.cores
}
fn map_shared(
&mut self,
_process: ProcessId,
_base: PhysicalAddress,
_size: PageCount,
_permissions: PermissionSet,
) {
}
fn halt(&self) -> ! {
loop {}
}
fn debug_putchar(&self, _byte: u8) {}
fn translate_va(&self, process: ProcessId, va: VirtualAddress) -> Option<PhysicalAddress> {
@@ -65,10 +80,21 @@ impl Platform for MockPlatform {
None
}
fn map_user_page(&mut self, process: ProcessId, va: VirtualAddress, pa: PhysicalAddress, _writable: bool, _executable: bool) {
fn map_user_page(
&mut self,
process: ProcessId,
va: VirtualAddress,
pa: PhysicalAddress,
_writable: bool,
_executable: bool,
) {
for slot in &mut self.mappings {
if slot.is_none() {
*slot = Some(PageMapping { process, va: va.raw(), pa: pa.raw() });
*slot = Some(PageMapping {
process,
va: va.raw(),
pa: pa.raw(),
});
return;
}
}

6
crates/kernel/src/tests/mod.rs
View File

@@ -1,5 +1,5 @@
mod mock_platform;
mod helpers;
mod mock_platform;
mod capability;
mod exit;
@@ -9,12 +9,12 @@ mod memory;
mod simple;
mod tick;
pub use helpers::{kernel_with_process, test_kernel};
pub use mock_platform::MockPlatform;
pub use helpers::{test_kernel, kernel_with_process};
pub use crate::Kernel;
pub use domain::memory::page_pool::PagePool;
pub use types::address::PhysicalAddress;
pub use types::bounded::Priority;
pub use types::id::ProcessId;
pub use types::time::TimeSlice;
pub use domain::memory::page_pool::PagePool;

7
crates/kernel/src/tests/tick.rs
View File

@@ -46,9 +46,10 @@ fn interrupt_unblocks_registered_thread() {
// Register and block the thread on this IRQ
k.register_irq_for_test(irq, tid);
k.block_thread_for_test(tid, domain::thread::BlockReason::WaitingForInterrupt(
types::bounded::CapSlot::new(0).unwrap()
));
k.block_thread_for_test(
tid,
domain::thread::BlockReason::WaitingForInterrupt(types::bounded::CapSlot::new(0).unwrap()),
);
let result = k.handle_interrupt(irq);
assert_eq!(result, Some(tid));