gemOS — x86-64 Operating System & Systems Programming
A cumulative systems-programming and operating-systems project based on gemOS, an educational x86-64 operating-system kernel developed through the CS330 course.
The project progresses from low-level Linux/POSIX programming and process management to kernel development involving virtual memory, system calls, exception handling, scheduling, tracing, threading, synchronization, and copy-on-write memory management.
The repository contains two complementary parts:
gemOS/— the cumulative gemOS kernel and user-space environment, including the kernel subsystems and extensions developed throughout the course.labs/— selected implementations organized by laboratory and question, preserving the progression of the systems-programming work.
The labs/ directory contains the submitted implementation code rather than generated test outputs or course-provided testcase data.
.
├── gemOS/
│ ├── include/
│ ├── user/
│ ├── *.c
│ ├── *.h
│ ├── *.S
│ └── Makefile
│
├── labs/
│ ├── lab01/
│ ├── lab02/
│ ├── lab04/
│ ├── lab05/
│ ├── lab06/
│ ├── lab07/
│ ├── lab09/
│ └── lab11/
│
└── README.md
Labs 3, 8, and 10 are not included because no corresponding assignment source directories were present in the working course repository.
Implemented a wc-style utility using C/POSIX file and input APIs, supporting character, word, and line counting.
Concepts: file I/O, command-line parsing, strings, POSIX APIs.
Processed Linux perf_event ring-buffer records, handling sample and lost-event records and accounting for unknown record types.
Concepts: perf_event, memory-mapped ring buffers, binary record processing, low-level Linux instrumentation.
Parallelized prime counting using multiple processes created with fork() and collected partial results using process termination status.
Concepts: fork(), waitpid(), process parallelism, exit status communication.
Implemented recursive computation using repeated process replacement with execl().
Concepts: fork/exec model, process replacement, argument passing.
Implemented string searching over file contents using low-level file descriptors and read().
Concepts: open(), read(), file descriptors, buffered/unbuffered processing.
Parsed system-call trace data and counted occurrences of selected system calls.
Concepts: low-level file I/O, trace processing, string parsing.
Built a parent-child processing pipeline using pipes, process creation, descriptor redirection, and exec() to stream data through an encryption process.
Concepts: fork(), pipe(), dup()/dup2(), exec(), IPC, file I/O.
Generalized parallel prime counting to an arbitrary number of child processes, partitioning the search space and communicating partial results through pipes.
Concepts: multi-process parallelism, pipes, process synchronization, IPC.
Implemented compaction of dynamically allocated process memory and reduced the data-segment footprint using sbrk().
Concepts: process memory layout, heap management, sbrk(), memory compaction.
Implemented dynamic memory management using explicit virtual-memory mappings instead of conventional allocation routines.
Concepts: mmap(), munmap(), mremap(), virtual memory.
Determined the contiguous mapped memory span surrounding a given address by probing adjacent pages.
Concepts: page mappings, virtual-address space, page granularity.
Relocated executable code into a dynamically mapped region, computed relocated function addresses, and transferred execution to relocated code using x86-64 assembly.
Concepts: executable memory, code relocation, address arithmetic, x86-64 assembly, indirect control flow.
Extended gemOS with process-information interfaces exposing information about:
- process identity and parent relationships
- process/file-descriptor state
- memory segments
- virtual-memory areas
The implementation spans kernel-side process metadata and the user-space interface.
Concepts: system calls, process control blocks, file descriptors, memory segments, VMAs.
Implemented configurable divide-by-zero exception handling inside gemOS.
The implementation works with the saved execution context and supports different recovery behaviors, including modifying register state, skipping faulting instructions, redirecting execution to user handlers, and recovering at function boundaries.
Concepts: hardware exceptions, saved CPU context, instruction pointers, register state, user/kernel transitions.
Implemented a kernel trace-buffer facility with file-descriptor based access.
The implementation includes trace-buffer creation, circular-buffer reads/writes, file-operation dispatch, and validation of user-provided memory ranges.
Concepts: kernel buffers, circular buffers, file operations, address validation, synchronization and resource management.
Implemented and integrated Round-Robin scheduling with process queues and timer-driven scheduling behavior.
Concepts: scheduling queues, process states, timer interrupts, context switching.
Implemented traversal of the x86-64 four-level page-table hierarchy to resolve virtual-address mappings.
Concepts: PML4/PDPT/PD/PT hierarchy, virtual-to-physical translation, page-table entries.
Implemented kernel-level thread creation and execution contexts, including thread-specific stacks, register state, entry points, and lifecycle management.
Concepts: execution contexts, kernel stacks, user stacks, thread lifecycle.
Implemented synchronization mechanisms for coordinating concurrent execution, including blocking/wakeup behavior and kernel synchronization primitives.
Concepts: synchronization, wait queues, blocking, wakeup, concurrency.
Implemented cfork() using shared physical pages and copy-on-write semantics.
The implementation constructs child address spaces using four-level x86-64 page tables, tracks shared physical pages through PFN reference counts, write-protects shared mappings, and handles write faults by creating private page copies and invalidating stale TLB entries.
Concepts: copy-on-write, page tables, PFN reference counting, page faults, TLB invalidation, virtual-memory isolation.
The project covers:
-
Process Management
fork()cfork()- thread creation
- process/thread lifecycle
- parent-child relationships
-
Virtual Memory
mmap()/munmap()/mremap()- four-level x86-64 page tables
- virtual-to-physical translation
- VMAs and memory segments
- copy-on-write
-
Concurrency & IPC
- processes
- pipes
- descriptor duplication
- synchronization
- wait queues
- Round-Robin scheduling
-
Kernel Development
- system calls
- file descriptors
- exception handling
- trace buffers
- process information
- memory validation
-
Low-Level Systems Programming
- x86-64 assembly
- direct system-call interfaces
- page-table manipulation
- physical-page reference counting
- TLB invalidation
- executable code relocation
The gemOS/ directory is retained as the cumulative OS source tree used throughout the project. The labs/ directory provides a cleaner record of the individual submitted implementations.
Ge# gemOS — x86-64 Operating System & Systems Programming
A cumulative systems-programming and operating-systems project based on gemOS, an educational x86-64 operating-system kernel developed through the CS330 course.
The project progresses from low-level Linux/POSIX programming and process management to kernel development involving virtual memory, system calls, exception handling, scheduling, tracing, threading, synchronization, and copy-on-write memory management.