mit-pdos/xv6-public

Features

• Paging and Context Switching - Implements the fundamental kernel mechanism for saving and restoring CPU state to switch between processes.
• File Systems - Implements a complete Unix-style filesystem for organizing and retrieving data on a disk using buffers.
• Kernel - Implements a simplified instructional kernel for demonstrating system calls and process lifecycles.
• Block Storage - Manages the allocation and freeing of raw disk blocks using a bitmap for tracking availability.
• Data Persistence Management - Provides the system-level capabilities to create, open, read, write, and delete files for persistent data storage.
• File Descriptor Writing - Writes a specified number of bytes from a memory buffer to a file descriptor.
• Buffer Caches - Implements a buffer cache to store disk blocks in memory, reducing physical hardware access and synchronizing concurrent reads.
• Inode-Based Tracking - Tracks file properties and physical disk block addresses using a combination of inodes and a super block.
• File Status Retrieval - Fetches file metadata such as size and type into a status structure for process use.
• File Storage Systems - Provides the fundamental architecture for retrieving data from files within a hierarchical directory structure.
• Shell Command Execution - Provides a shell capable of parsing and executing operating system commands and binaries.
• Teaching Operating Systems - Provides a simplified re-implementation of Unix Version 6 designed specifically for academic instruction of kernel concepts.
• Device Driver Abstraction - Provides a uniform interface for hardware interaction by mapping device numbers to specific kernel read and write functions.
• Disk Block I/O - Performs synchronous data transfers between memory buffers and a disk controller using a request queue.
• ELF Binary Parsing - Parses ELF executable headers to identify entry points and memory segments for process loading.
• Executable Program Loading - Provides a mechanism for parsing ELF executable headers and loading program segments into process memory.
• File and Directory Deletion - Manages the removal of files and empty directories by updating directory entries and decrementing inode link counts.
• Inode-Based Systems - Implements an inode-based filesystem to track file metadata and disk block locations.
• Filesystem Crash Recovery - Ensures filesystem consistency and recovery after failures by recording updates in a redo log.
• Filesystem Path Resolution - Translates human-readable file paths into specific inodes by traversing the directory structure.
• Hardware Device Initializations - Configures the interrupt controller, console, serial ports, and disk interfaces during the system boot sequence.
• Inode-Based Directory Organization - Maps filenames to inode numbers using directory entries to enable efficient file lookups.
• Inode-Based Metadata Management - Tracks file types, sizes, and disk block locations using an inode system and an in-memory cache.
• Interrupt Handling - Configures the local interrupt controller to handle internal timer events and error signals.
• Process Schedulers - Sets up the process table and trap vectors required for the kernel to schedule user-level tasks.
• File Descriptor Managers - Implements a global table and reference counting to track and release system handles for open files.
• Process-Specific File Tables - Associates open file descriptors and the current working directory with each individual process.
• Physical Address Mapping - Manages the translation between virtual and physical memory addresses to define system boundaries.
• Memory Segmentation - Implements hardware-level memory segmentation using descriptor tables to enforce privilege levels and isolation.
• Child Process Management Helpers - Implements kernel helpers that synchronize parent and child processes, specifically for collecting exit statuses.
• Process Lifecycle Managers - Coordinates the entire process lifecycle, including creation, scheduling, and memory allocation.
• Process Isolation - Ensures process separation by assigning dedicated page tables and kernel stacks to each execution context.
• System Call Dispatching - Implements the internal routing logic to dispatch system call numbers to their respective kernel handler functions.
• Trap-Based Interfaces - Uses hardware traps and software interrupts to transfer execution from user-space to privileged kernel system call handlers.
• System Call Interfaces - Provides the interface for user-space programs to trigger kernel services via software interrupts.
• Inter-Process Communication - Implements low-level inter-process communication primitives within the kernel to allow separate processes to exchange data.
• Pipe-Based Communication - Provides unidirectional byte-stream channels for communication between processes.
• File System I/O - Implements high-performance read and write operations on the local filesystem using file descriptors and inodes.
• Interrupt Controllers - Manages the interrupt controller to route hardware signals from devices to specific kernel handlers.
• Interrupt Acknowledgments - Signals the interrupt controller that a request has been serviced to enable subsequent interrupt delivery.
• Interrupt Masking - Disables hardware interrupts to ensure atomicity during the execution of critical kernel code sections.
• Multiprocessor Interrupt Routing - Directs hardware interrupts to specific CPUs in a multiprocessor system using a redirection table.
• Kernel Loading Mechanisms - Implements kernel loading mechanisms to read the executable from disk and map program segments to physical memory.
• Kernel Memory Layouts - Defines the static memory addresses and sections for kernel code and data during system initialization.
• Kernel Process Internals - Implements core kernel mechanisms for process creation, scheduling, and memory management.
• Inter-CPU Memory Synchronization - Uses spinlocks to coordinate memory access across multiple processors to ensure data consistency.
• Mutexes and Locks - XV6 implements locks and mutexes to prevent race conditions and protect shared tables across CPUs.
• Operating System Emulation - Runs a full re-implementation of Unix Version 6 within an emulator for educational purposes.
• Paged Memory Management - Implements paged memory management to map virtual addresses to physical frames and isolate process address spaces.
• Page Table Entry Management - Creates page table entries to associate virtual addresses with physical locations and assign access permissions.
• Physical Page Allocators - Manages the allocation of fixed-size physical memory pages for kernel stacks and user processes.
• Process Preemption - Implements timer-interrupt driven preemption to ensure fair CPU distribution among processes.
• Process Signal Management - Provides mechanisms to end process execution and send termination signals using process IDs.
• Process Sleep Locks - Provides synchronization primitives that allow processes to wait for resources without wasting CPU cycles.
• Processor Mode Transitions - Transitions the processor from real mode to protected mode and initializes memory segments during kernel bootstrapping.
• Processor State Control - Manipulates CPU control registers to enable critical kernel features like paging and interrupt handling.
• Symmetric Multiprocessing Mechanisms - Implements kernel-level mechanisms to detect multiprocessing capabilities and configure the interrupt controller for SMP.
• Symmetric Multiprocessing Models - Implements a symmetric multiprocessing architecture to manage workloads across multiple cores using shared memory.
• Kernel Metadata Inspection - Retrieves essential file properties including device identifiers, inode numbers, and file sizes.
• Process and Task Orchestration - Implements the spawning of child processes for concurrent execution and manages their termination.
• System Call Interfaces - Provides a secure system call interface for user-level programs to request privileged kernel services.
• System Exception Handling - Captures and routes synchronous hardware exceptions and memory faults to terminate offending processes.
• System Boot Initializers - Implements routines that transition the system from the boot loader to the kernel by enabling paging and setting the stack pointer.
• User Process Bootstrapping - Handles the transition from kernel boot to the execution of the first user-space process.
• User Memory Validators - Verifies that user-requested memory pointers reside within the allocated address space before kernel access.
• Virtual Memory Management - Manages a virtual memory system using page tables to map addresses and isolate process memory.
• x86 Kernel Implementations - Provides a low-level kernel implementation targeting the x86 architecture, managing paging and interrupts.
• Mutual Exclusion Locks - Synchronizes access to shared resources by spinning and disabling interrupts to ensure mutual exclusion.
• Spinlocks - Provides spinlock-based mutual exclusion to synchronize access to shared kernel resources across multiple CPUs.
• Concurrency Synchronization Primitives - Implements spinlocks and sleep-locks to synchronize access to shared resources across multiple CPUs.
• File Descriptor Buffering - Reads a specified number of bytes from a file descriptor into a memory buffer.
• Directory Listing Utilities - Retrieves and displays names, types, inode numbers, and sizes of files within directories.
• Disk Caching Systems - Implements a buffer cache to store disk data in memory and minimize slow physical I/O.
• Transaction Recovery Logs - Uses a redo log to track multi-step filesystem updates and ensure consistency after system failures.
• Filesystem Redo Logs - Records filesystem updates in a redo log to ensure data consistency after an unexpected system failure.
• Command Piping - Implements command piping to connect the output of one process to the input of another for sequential processing.
• Shell Backgrounding - Implements the ability to run shell commands in the background to maintain console interactivity.
• Disk Image File System Management - Builds a virtual disk image containing a formatted filesystem populated with initial system files.
• I/O Redirections - Implements the ability to route command data streams to or from specified files instead of the console.
• In-Memory Disk Emulation - Simulates a physical disk by storing block data in system memory to enable execution without physical hardware.
• Inter-Processor Interrupt Signaling - Sends startup signals to remote cores to begin executing code at a specified memory address.
• Dynamic Memory Allocation - Implements mechanisms for dynamically allocating and reallocating memory blocks within the kernel.
• Dynamic Heap Allocators - Provides a mechanism to request and manage variable-sized memory blocks from the heap.
• Heap Expansion Mechanisms - Implements the ability to increase a process's heap size for additional data storage.
• System Memory Allocation - Implements the low-level mechanism to return allocated memory blocks to the system for future reuse.
• Interrupt Controller Initializations - Initializes and masks hardware interrupts on controllers during the kernel boot sequence.
• Kernel Panic Handlers - Provides a kernel panic mechanism that halts the CPU and prints a diagnostic call stack upon critical failure.
• Multiprocessor Hardware Identification - Reads configuration tables to discover processors and interrupt controllers for boot-time initialization.
• MMU Initialization - Initializes the Memory Management Unit and enables paging on application processors to start multi-core execution.
• Process Hierarchy Tracking - Tracks relationships between parent and child processes for resource inheritance and organization.
• Sleeping Locks - Suspends processes attempting to acquire locked resources until they are released to prevent CPU waste.
• Application Processor Bootstrapping - Activates secondary CPUs by loading entry code and assigning stacks for symmetric multiprocessing.
• SMP Bootstrapping - Initializes secondary CPUs by loading entry code and configuring interrupt controllers for parallel execution.
• Directory Operations - Provides functions for creating and managing directory structures within the file system.
• System Hardware Interfaces - Provides low-level utilities for accessing device identifiers and retrieving system-level metrics like uptime.
• System Time Management - Implements kernel-level time management to track system ticks and report current clock time.
• Standard Input/Output Streams - Provides interfaces for reading data from files or standard input and outputting it to the console.
• File System Access Controls - Specifies file access permissions for reading and writing during the file creation process.
• Process Sleeping - Provides the ability to suspend processes for specified clock ticks to yield CPU time.
• Memory Buffering - Implements memory buffering techniques to manage data movement and optimize disk I/O performance.
• System Resource Constraints - Enforces hard limits on the maximum number of processes, CPUs, and open files to prevent resource exhaustion.

Star history