tock/tock
Tock
Tock is a secure embedded operating system and microcontroller kernel designed to isolate untrusted applications and drivers. It functions as a memory-safe process isolator that uses a combination of hardware memory protection and language-level type safety to execute mutually distrustful applications on bare metal.
The system distinguishes itself through a hardware abstraction layer that decouples high-level components from specific microcontroller implementations using standardized traits. It further employs a virtualization layer to allow multiple independent software components to share a single piece of physical hardware.
The kernel covers a broad range of capabilities, including capability-based API access, grant-based memory management to prevent global heap exhaustion, and an event-based scheduler for managing process execution. It also provides mechanisms for runtime application updates by flashing new binaries to non-volatile storage while the system remains running.
Features
- Hardware-Based Memory Protection - Uses hardware Memory Protection Units to enforce memory access boundaries and isolate mutually distrustful application processes.
- Embedded Operating Systems - Provides a modular operating system distribution specifically tailored for secure execution on resource-constrained embedded hardware.
- Task Schedulers - Implements a kernel-level mechanism for managing the execution order and context switching of concurrent tasks.
- Kernel Event Schedulers - Manages hardware interrupts and application process execution via a kernel-level scheduler based on pending callbacks.
- Hardware Abstraction Layers - Decouples high-level kernel components from specific microcontroller hardware using standardized traits.
- Secure Embedded Operating Systems - Runs multiple distrustful applications on microcontrollers using memory protection to ensure system stability and security.
- MPU-Based Application Isolation - Executes untrusted applications in separate threads with reduced privileges using a hardware memory protection unit.
- Hardware Abstraction Layers - Provides a standardized interface that decouples high-level system components from specific microcontroller hardware implementations.
- Grant-Based Allocators - Allocates memory from application heaps to the kernel via grants to prevent global heap exhaustion.
- Process Isolation - Employs security techniques to restrict process access to system resources by running applications in isolated execution environments.
- System Call Interfaces - Defines the secure software interrupt mechanism used by user-space applications to request kernel services.
- Microcontroller Kernels - Implements a core kernel for embedded devices that manages hardware abstraction and process scheduling on bare metal.
- Capability-Based Access Controls - Employs a security model that requires specific delegatable authorization objects to permit the execution of sensitive kernel functions.
- Execution Schedulers - Provides a scheduler that controls the execution order and timing of concurrent processes.
- Embedded Binary Updates - Provides a mechanism to update device functionality by flashing new binaries to non-volatile storage during runtime.
- Runtime Binary Flashing - Allows loading and flashing of application binaries to non-volatile storage for updates while the system is running.
- Peripheral Resource Virtualization - Shares a single piece of physical hardware among multiple independent software components through a controlled virtualization layer.
- Hardware Driver Virtualization - Provides virtualization layers that wrap physical hardware drivers to allow multiple components to share a single resource.
- System Call and Driver Callback Routings - Implements a system for routing kernel control through registered driver callbacks and system call tables.
- Hardware Resource Virtualization - Wraps physical hardware drivers in software layers to allow multiple system components to share a single resource.
- User-Space Upcalls - Signals user processes by executing registered callback functions through a controlled system call interface.
- Process and Memory Management - Manages the allocation of memory from application heaps to the kernel via grants for safe data exchange.
- Managed Memory Allocators - Uses specialized allocators and fixed-size buffers to ensure predictable memory consumption and prevent global heap exhaustion.
- Process Lifecycle Managers - Controls application execution by blocking processes via yield calls and waking them during driver events.
- Inter-Process Communication - Provides communication protocols and interfaces that allow separate application processes to exchange data and synchronize actions.
- Kernel-to-User Bridges - Implements a mechanism to route asynchronous notifications and callbacks from the kernel back to user-space processes.
- Type-Safe Component Isolation - Leverages Rust type and module systems to isolate trusted kernel drivers without requiring hardware memory protection.
- Language-Level Driver Isolation - Uses a language sandbox to protect internal modules and drivers from each other without incurring hardware overhead.
- Real-Time Operating Systems - Secure embedded operating system for Cortex-M.
- Operating Systems - Secure embedded OS for Cortex-M microcontrollers.
