use rusty_rtos_core::config::Config;
use rusty_rtos_core::error::{Error, Result};
use rusty_rtos_core::handle::{QueueHandle, TaskHandle};
use rusty_rtos_core::hooks::NoTickHook;
use rusty_rtos_core::isr::Woken;
use rusty_rtos_core::port::Port;
use rusty_rtos_core::tick::Bits32;
use rusty_rtos_core::trace::{Event, Trace};
use crate::queue::{Position, Wait};
use crate::{Kernel, list_slots_for, lists_for};
#[derive(Debug, Clone, Copy, Default)]
pub struct ProofConfig;
impl Config for ProofConfig {
type Tick = Bits32;
const TICK_RATE_HZ: u32 = 100;
const MAX_PRIORITIES: u8 = 2;
const MINIMAL_STACK_SIZE: usize = 1;
const MAX_TASK_NAME_LEN: usize = 4;
const TIMER_TASK_PRIORITY: u8 = 1;
const TIMER_TASK_STACK_DEPTH: usize = 1;
const TIMER_QUEUE_LENGTH: usize = 1;
const NOTIFICATION_ARRAY_ENTRIES: usize = 1;
const USE_TIME_SLICING: bool = false;
}
const TASKS: usize = 3;
const QUEUES: usize = 2;
const SLOTS: usize = 4;
const BUFFERS: usize = 1;
const BYTES: usize = 8;
const TIMERS: usize = 1;
const GROUPS: usize = 1;
#[derive(Debug, Default)]
struct ProofPort {
nesting: core::cell::Cell<u32>,
in_isr: core::cell::Cell<bool>,
}
impl Port for ProofPort {
fn yield_now(&self) {}
fn yield_from_isr(&self, _woken: Woken) {}
fn enter_critical(&self) {
self.nesting.set(self.nesting.get().saturating_add(1));
}
fn exit_critical(&self) {
self.nesting.set(self.nesting.get().saturating_sub(1));
}
fn set_interrupt_mask_from_isr(&self) -> u32 {
0
}
fn clear_interrupt_mask_from_isr(&self, _saved: u32) {}
fn in_isr(&self) -> bool {
self.in_isr.get()
}
fn set_in_tick_entry(&self, yes: bool) {
self.in_isr.set(yes);
}
}
#[derive(Debug, Default)]
struct NoTrace;
impl Trace for NoTrace {
const WANTS_NAMES: bool = false;
fn event(&mut self, _tick: u64, _event: Event<'_>) {}
}
type K = Kernel<
ProofConfig,
ProofPort,
NoTrace,
NoTickHook,
TASKS,
{
list_slots_for(
TASKS,
TIMERS,
lists_for(ProofConfig::MAX_PRIORITIES, QUEUES, GROUPS),
)
},
{ lists_for(ProofConfig::MAX_PRIORITIES, QUEUES, GROUPS) },
QUEUES,
SLOTS,
BUFFERS,
BYTES,
TIMERS,
GROUPS,
{ <ProofConfig as ::rusty_rtos_core::config::Config>::TIMER_QUEUE_LENGTH },
>;
fn ready() -> K {
let mut k = match K::new(ProofPort::default(), NoTrace) {
Ok(k) => k,
Err(_) => unreachable!(),
};
let _ = k.create_task("p", 1);
k
}
fn started() -> K {
let mut k = ready();
let _ = k.start_scheduler();
k
}
fn any_queue() -> QueueHandle {
QueueHandle::from_raw(kani::any())
}
fn any_task() -> TaskHandle {
TaskHandle::from_raw(kani::any())
}
fn small_ticks() -> u64 {
let ticks: u64 = kani::any();
kani::assume(ticks <= 2);
ticks
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_generic_create() {
let mut k = ready();
let length: usize = kani::any();
kani::assume(length <= SLOTS + 1);
if let Ok(q) = k.queue_create(length) {
assert!(k.queue_messages_waiting(q) == Ok(0));
assert!(k.queue_spaces_available(q) == Ok(length));
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_generic_send() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let value: u64 = kani::any();
let ticks = small_ticks();
let before = k.queue_messages_waiting(q).unwrap_or(0);
match k.queue_send_generic(q, value, ticks, Position::Back) {
Ok(Wait::Ready(())) => {
assert!(k.queue_messages_waiting(q) == Ok(before + 1));
}
Ok(Wait::Blocked) | Err(_) => {
assert!(k.queue_messages_waiting(q) == Ok(before));
}
}
assert!(k.queue_messages_waiting(q).unwrap_or(0) <= 2);
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_generic_send_stale_handle() {
let mut k = ready();
let Ok(real) = k.queue_create(2) else {
return;
};
let q = any_queue();
kani::assume(q != real);
let before = k.queue_messages_waiting(real).unwrap_or(0);
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
assert!(k.queue_messages_waiting(real) == Ok(before));
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_generic_send_from_isr() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let before = k.queue_messages_waiting(q).unwrap_or(0);
match k.queue_send_from_isr(q, kani::any()) {
Ok(_) => assert!(k.queue_messages_waiting(q) == Ok(before + 1)),
Err(_) => assert!(k.queue_messages_waiting(q) == Ok(before)),
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_receive() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
let before = k.queue_messages_waiting(q).unwrap_or(0);
match k.queue_receive(q, small_ticks()) {
Ok(Wait::Ready(_)) => assert!(k.queue_messages_waiting(q) == Ok(before - 1)),
Ok(Wait::Blocked) | Err(_) => assert!(k.queue_messages_waiting(q) == Ok(before)),
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_receive_from_isr() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let before = k.queue_messages_waiting(q).unwrap_or(0);
match k.queue_receive_from_isr(q) {
Ok((_, _)) => assert!(k.queue_messages_waiting(q) == Ok(before.saturating_sub(1))),
Err(_) => assert!(k.queue_messages_waiting(q) == Ok(before)),
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_peek() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
let before = k.queue_messages_waiting(q).unwrap_or(0);
let _ = k.queue_peek(q, 0);
assert!(k.queue_messages_waiting(q) == Ok(before));
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_generic_reset() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
if k.queue_reset(q).is_ok() {
assert!(k.queue_messages_waiting(q) == Ok(0));
assert!(k.queue_spaces_available(q) == Ok(2));
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_messages_waiting_and_spaces_available() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let _ = k.queue_send_generic(q, kani::any(), 0, Position::Back);
let waiting = k.queue_messages_waiting(q);
let spaces = k.queue_spaces_available(q);
if let (Ok(waiting), Ok(spaces)) = (waiting, spaces) {
assert!(waiting + spaces == 2);
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_create_counting_semaphore() {
let mut k = ready();
let max: usize = kani::any();
let initial: usize = kani::any();
kani::assume(max <= SLOTS && initial <= max);
if let Ok(s) = k.semaphore_create_counting(max, initial) {
assert!(k.queue_messages_waiting(s) == Ok(initial));
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_create_mutex_and_get_holder() {
let mut k = ready();
let Ok(m) = k.mutex_create() else {
return;
};
assert!(k.mutex_holder(m) == Ok(TaskHandle::NULL));
assert!(k.queue_messages_waiting(m) == Ok(1));
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_semaphore_take_and_give_from_isr() {
let mut k = ready();
let Ok(s) = k.semaphore_create_counting(2, 1) else {
return;
};
let before = k.queue_messages_waiting(s).unwrap_or(0);
match k.semaphore_take(s, small_ticks()) {
Ok(Wait::Ready(())) => assert!(k.queue_messages_waiting(s) == Ok(before - 1)),
_ => assert!(k.queue_messages_waiting(s) == Ok(before)),
}
let middle = k.queue_messages_waiting(s).unwrap_or(0);
match k.semaphore_give_from_isr(s) {
Ok(_) => assert!(k.queue_messages_waiting(s) == Ok(middle + 1)),
Err(_) => assert!(k.queue_messages_waiting(s) == Ok(middle)),
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_take_and_give_mutex_recursive() {
let mut k = ready();
let Ok(m) = k.mutex_create_recursive() else {
return;
};
let before = k.queue_messages_waiting(m).unwrap_or(0);
if matches!(
k.mutex_take_recursive(m, small_ticks()),
Ok(Wait::Ready(()))
) {
let _ = k.mutex_give_recursive(m);
assert!(k.queue_messages_waiting(m) == Ok(before));
}
}
#[kani::proof]
#[kani::unwind(40)]
fn queue_unlock_leaves_the_queue_usable() {
let mut k = ready();
let Ok(q) = k.queue_create(2) else {
return;
};
let _ = k.queue_send_from_isr(q, kani::any());
let _ = k.queue_receive_from_isr(q);
let before = k.queue_messages_waiting(q).unwrap_or(0);
if matches!(
k.queue_send_generic(q, kani::any(), 0, Position::Back),
Ok(Wait::Ready(()))
) {
assert!(k.queue_messages_waiting(q) == Ok(before + 1));
}
}
#[kani::proof]
#[kani::unwind(40)]
fn task_create() {
let mut k = ready();
let priority: u8 = kani::any();
let before = k.task_count();
match k.create_task("t", priority) {
Ok(t) => {
assert!(k.task_count() == before + 1);
assert!(k.task_priority_get(Some(t)).unwrap_or(u8::MAX) < ProofConfig::MAX_PRIORITIES);
}
Err(_) => assert!(k.task_count() == before),
}
}
#[kani::proof]
#[kani::unwind(40)]
fn task_priority_set() {
let mut k = ready();
let priority: u8 = kani::any();
let _ = k.set_priority(None, priority);
let now = k.task_priority_get(None).unwrap_or(u8::MAX);
assert!(now < ProofConfig::MAX_PRIORITIES);
}
#[kani::proof]
#[kani::unwind(40)]
fn task_priority_set_stale_handle() {
let mut k = ready();
let before = k.task_priority_get(None).unwrap_or(0);
let t = any_task();
kani::assume(k.state_of(t) == Ok(crate::kernel::TaskState::Deleted));
let _ = k.set_priority(Some(t), kani::any());
assert!(k.task_priority_get(None) == Ok(before));
}
#[kani::proof]
#[kani::unwind(40)]
fn task_increment_tick() {
let mut k = started();
let before = k.tick_count();
k.tick_from_isr();
assert!(k.tick_count() == before + 1);
}
#[kani::proof]
#[kani::unwind(40)]
fn task_delay() {
let mut k = started();
let before = k.tick_count();
let _ = k.delay(small_ticks());
assert!(k.tick_count() == before);
}
#[kani::proof]
#[kani::unwind(40)]
fn task_suspend_all_and_resume_all() {
let mut k = ready();
k.suspend_all();
k.suspend_all();
let _ = k.resume_all();
assert!(k.scheduler_suspended() == 1);
let _ = k.resume_all();
assert!(k.scheduler_suspended() == 0);
}
#[kani::proof]
#[kani::unwind(40)]
fn task_get_scheduler_state() {
let k = started();
assert!(k.is_running());
}
#[kani::proof]
#[kani::unwind(40)]
fn task_get_current_task_handle() {
let k = started();
let current = k.current();
assert!(k.state_of(current) == Ok(crate::kernel::TaskState::Running));
}
#[kani::proof]
#[kani::unwind(40)]
fn task_switch_context() {
let mut k = started();
k.switch_context();
let current = k.current();
assert!(k.state_of(current) == Ok(crate::kernel::TaskState::Running));
}
#[kani::proof]
#[kani::unwind(40)]
fn task_start_scheduler() {
let k = started();
assert!(k.is_running());
assert!(k.task_count() == 3);
}
#[cfg(kani)]
struct SymbolicQueue {
held: usize,
length: usize,
last_sent: u64,
taken: bool,
}
#[cfg(kani)]
impl crate::typed::Raw for SymbolicQueue {
fn raw_queue_create(&mut self, length: usize) -> Result<QueueHandle> {
self.length = length;
self.held = 0;
Ok(QueueHandle::from_raw(1))
}
fn raw_queue_send(&mut self, _q: QueueHandle, value: u64, _ticks: u64) -> Result<Wait<()>> {
if self.held >= self.length {
return Err(Error::Full);
}
self.held = self.held.saturating_add(1);
self.last_sent = value;
Ok(Wait::Ready(()))
}
fn raw_queue_receive(&mut self, _q: QueueHandle, _ticks: u64) -> Result<Wait<u64>> {
if self.held == 0 {
return Ok(Wait::Blocked);
}
self.held = self.held.saturating_sub(1);
Ok(Wait::Ready(self.last_sent))
}
fn raw_queue_messages_waiting(&mut self, _q: QueueHandle) -> Result<usize> {
Ok(self.held)
}
fn raw_queue_has_room(&self, _q: QueueHandle) -> bool {
self.held < self.length
}
fn raw_in_isr(&self) -> bool {
false
}
fn raw_queue_send_from_isr(&mut self, q: QueueHandle, value: u64) -> Result<Woken> {
self.raw_queue_send(q, value, 0).map(|_| Woken::NO)
}
fn raw_mutex_create(&mut self) -> Result<QueueHandle> {
self.taken = false;
Ok(QueueHandle::from_raw(2))
}
fn raw_mutex_take(&mut self, _m: QueueHandle, _ticks: u64) -> Result<Wait<()>> {
if self.taken {
return Ok(Wait::Blocked);
}
self.taken = true;
Ok(Wait::Ready(()))
}
fn raw_mutex_give(&mut self, _m: QueueHandle) -> Result<()> {
if !self.taken {
return Err(Error::NotActive);
}
self.taken = false;
Ok(())
}
}
#[kani::proof]
#[kani::unwind(8)]
fn typed_send_never_loses_the_value() {
let held: usize = kani::any();
kani::assume(held <= 2);
let mut k = SymbolicQueue {
held,
length: 2,
last_sent: 0,
taken: false,
};
let Ok(mut q) = crate::typed::Queue::<u16, 2>::create(&mut k) else {
return;
};
k.held = held;
let value: u16 = kani::any();
let before = k.held;
match q.send(&mut k, value, 0) {
crate::typed::Sent::Ok => {
assert!(k.held == before + 1);
}
crate::typed::Sent::Full(back) | crate::typed::Sent::Blocked(back) => {
assert!(back == value);
assert!(k.held == before);
}
}
}
#[kani::proof]
#[kani::unwind(8)]
fn typed_receive_gives_back_what_was_sent() {
let mut k = SymbolicQueue {
held: 0,
length: 2,
last_sent: 0,
taken: false,
};
let Ok(mut q) = crate::typed::Queue::<u16, 2>::create(&mut k) else {
return;
};
let value: u16 = kani::any();
if !q.send(&mut k, value, 0).is_ok() {
return;
}
match q.receive(&mut k, 0) {
Ok(Wait::Ready(Some(out))) => assert!(out == value),
_ => assert!(false),
}
}
#[kani::proof]
#[kani::unwind(8)]
fn typed_a_refused_send_does_not_disturb_a_queued_value() {
let mut k = SymbolicQueue {
held: 0,
length: 1,
last_sent: 0,
taken: false,
};
let Ok(mut q) = crate::typed::Queue::<u16, 1>::create(&mut k) else {
return;
};
let first: u16 = kani::any();
let second: u16 = kani::any();
if !q.send(&mut k, first, 0).is_ok() {
return;
}
match q.send(&mut k, second, 0) {
crate::typed::Sent::Full(back) => assert!(back == second),
_ => assert!(false),
}
match q.receive(&mut k, 0) {
Ok(Wait::Ready(Some(out))) => assert!(out == first),
_ => assert!(false),
}
}
#[kani::proof]
#[kani::unwind(9)]
fn lists_take_any_argument() {
let mut lists: rusty_rtos_core::list::Lists<4, 3> = rusty_rtos_core::list::Lists::new();
let item: u16 = kani::any();
let list: u8 = kani::any();
let value: u64 = kani::any();
let inserted = lists.insert(list, item, value).is_ok();
assert!(lists.container(item).unwrap_or(None).is_some() == inserted);
if inserted {
assert!(lists.value(item) == Ok(value));
assert!(lists.is_empty(list) == Ok(false));
assert!(lists.remove(item).is_ok());
assert!(lists.container(item) == Ok(None));
}
}
#[kani::proof]
#[kani::unwind(9)]
fn insert_end_keeps_the_item_value() {
let mut lists: rusty_rtos_core::list::Lists<4, 3> = rusty_rtos_core::list::Lists::new();
let item: u16 = kani::any();
let list: u8 = kani::any();
let value: u64 = kani::any();
if lists.set_value(item, value).is_ok() && lists.insert_end(list, item).is_ok() {
assert!(lists.value(item) == Ok(value));
}
}
#[kani::proof]
#[kani::unwind(9)]
fn an_arena_only_resolves_its_own_handles() {
let mut arena: rusty_rtos_core::arena::Arena<rusty_rtos_core::handle::Task, u32, 3> =
rusty_rtos_core::arena::Arena::new();
let value: u32 = kani::any();
let Ok(handle) = arena.try_insert(value) else {
return;
};
assert!(arena.resolve(handle) == Ok(&value));
let other = TaskHandle::from_raw(kani::any());
kani::assume(other != handle);
assert!(arena.resolve(other).is_err());
let _ = arena.remove(handle);
assert!(arena.resolve(handle).is_err());
if let Ok(again) = arena.try_insert(value) {
assert!(again != handle);
assert!(arena.resolve(handle).is_err());
}
}
#[kani::proof]
#[kani::unwind(9)]
fn a_name_is_truncated_not_overrun() {
let limit: usize = kani::any();
kani::assume(limit <= crate::NAME_CAPACITY);
let bytes: [u8; 4] = kani::any();
kani::assume(bytes.iter().all(|b| b.is_ascii_graphic()));
let Ok(text) = core::str::from_utf8(&bytes) else {
return;
};
let name = crate::Name::new(text, limit);
assert!(name.as_str().len() <= limit);
assert!(name.as_str().len() <= text.len());
}
#[kani::proof]
#[kani::unwind(40)]
fn a_fresh_kernel_is_not_running() {
let k = match K::new(ProofPort::default(), NoTrace) {
Ok(k) => k,
Err(_) => return,
};
assert!(!k.is_running());
assert!(k.task_count() == 0);
}
#[kani::proof]
#[kani::unwind(40)]
fn a_created_task_is_counted() {
let mut k = match K::new(ProofPort::default(), NoTrace) {
Ok(k) => k,
Err(_) => return,
};
let Ok(t) = k.create_task("p", 1) else {
return;
};
assert!(k.task_count() == 1);
assert!(k.current() == t);
}
#[kani::proof]
#[kani::unwind(40)]
fn three_tasks_are_three() {
let mut k = match K::new(ProofPort::default(), NoTrace) {
Ok(k) => k,
Err(_) => return,
};
let _ = k.create_task("p", 1);
let _ = k.create_task("q", 1);
let _ = k.create_task("r", 0);
assert!(k.task_count() == 3);
assert!(k.task_priority_get(None) == Ok(1));
}
#[kani::proof]
#[kani::unwind(40)]
fn a_queue_starts_empty() {
let mut k = match K::new(ProofPort::default(), NoTrace) {
Ok(k) => k,
Err(_) => return,
};
let _ = k.create_task("p", 1);
let Ok(q) = k.queue_create(1) else {
return;
};
assert!(k.queue_messages_waiting(q) == Ok(0));
}