🖥️ FOS - FCIS Operating System

🎓 A Comprehensive Educational Operating System Kernel

Developed for Teaching OS Concepts at FCIS - Ain Shams University

Based on MIT Exokernel Architecture with Extensive Modifications

🚀 Quick Start • 📖 Documentation • 👥 Team • 🧪 Testing

📋 Table of Contents

📚 Click to expand full table of contents

🌟 Introduction
✨ Features
🏗️ System Architecture
- Memory Layout
- Key Constants
📁 Project Structure
💾 Memory Management
🔄 Process Management
⏰ CPU Scheduling
📄 Page Replacement
📞 System Calls
🚀 Quick Start
💻 Commands Reference
🧪 Testing Framework
🐛 Debugging
👨‍🏫 Course Instructor
👥 Development Team
📜 License
🙏 Acknowledgments

🌟 Introduction

What is FOS?

FOS (FCIS Operating System) is a state-of-the-art educational operating system kernel that bridges the gap between theoretical OS concepts and practical implementation. Born from the legendary MIT Exokernel project, FOS has evolved into a comprehensive learning platform that empowers students with hands-on experience in systems programming.

💡 Fun Fact: FOS contains over 15,000+ lines of C code and 100+ user programs for testing and learning!

🎯 Educational Goals

🧠

Memory Management

Learn virtual memory, paging, heap allocation, and page replacement strategies

⚡

Process Scheduling

Master multiple scheduling algorithms with real-time process management

🔒

System Protection

Understand kernel/user mode separation, trap handling, and interrupts

💻

Systems Programming

Get hands-on with low-level C and x86 Assembly programming

🏆 Why FOS?

Advantage	Description
🎓 Educational Focus	Designed specifically for learning, not just running
📚 Well Documented	Extensive comments and documentation throughout
🔧 Modular Design	Easy to understand and modify individual components
🧪 Comprehensive Tests	50+ test cases covering all major features
🌍 Real-World Concepts	Implements actual OS algorithms used in production systems

✨ Features

🔥 Core Kernel Features

💾 Memory Management

Feature	Description	Status
Virtual Memory	Full paging support with 4KB pages	✅
Two-Level Page Tables	Efficient address translation	✅
Memory Protection	Kernel/User space separation	✅
Frame Allocator	Physical frame management	✅
Page Table Management	Dynamic creation and manipulation	✅

⚡ Process Management

Feature	Description	Status
Multi-tasking	Pre-emptive multitasking	✅
Context Switching	Fast assembly-based switching	✅
Process Isolation	Separate address spaces	✅
ELF Loading	Load executable programs	✅
Process Priority	Priority-based scheduling	✅

📄 Page Replacement

Algorithm	Type	Status
FIFO	Simple	✅
Clock	Second Chance	✅
Modified Clock	Dirty Bit Aware	✅
LRU (Time)	Timestamp Based	✅
LRU (Lists)	Active/Second Lists	✅
N-Chance	Configurable	✅
Optimal	For Testing	✅

⏰ CPU Scheduling

Algorithm	Description	Status
Round Robin	Equal time quantum	✅
MLFQ	Multi-level feedback	✅
BSD	FreeBSD-based	✅
Priority RR	Priority with RR	✅

🔗 Inter-Process Communication

Feature	Description	Status
Shared Memory	Share memory regions	✅
Kernel Semaphores	Synchronization	✅
User Semaphores	User-level sync	✅
Sleep/Wakeup	Process blocking	✅

📊 Feature Statistics

Category	Count
📄 Scheduling Algorithms	4
🔄 Page Replacement Algorithms	7
💾 Memory Allocation Strategies	6
📞 System Calls	30+
👤 User Programs	100+
🧪 Test Cases	50+
💻 Kernel Commands	40+

🏗️ System Architecture

🗺️ Memory Layout

The FOS kernel uses a well-defined memory layout that separates kernel and user space:

Region	Start Address	End Address	Permissions	Description
Invalid Memory	`0xFFFFF000`	`0xFFFFFFFF`	`--/--`	Guard page at top
Kernel Heap	`0xF6000000`	`0xFFFFF000`	`RW/--`	Dynamic kernel memory
Remapped Physical	`0xF0000000`	`0xF6000000`	`RW/--`	Physical memory access
Kernel Base	`0xF0000000`	-	-	Kernel/User boundary
Virtual Page Table	`0xEFC00000`	`0xF0000000`	`RW/--`	Kernel page table access
Scheduler Stack	Below VPT	-	`RW/--`	Per-CPU kernel stacks
User Limit	`0xEF800000`	-	-	Top of user memory
User Page Table	`0xEF400000`	`0xEF800000`	`R-/R-`	User-readable page table
Read-Only ENVs	`0xEEC00000`	`0xEF000000`	`R-/R-`	Process info
User Exception Stack	`0xEEBFF000`	`0xEEC00000`	`RW/RW`	Exception handling
User Stack	Below USTACKTOP	-	`RW/RW`	Normal stack (grows up)
User Heap	`0x80000000`	`0xA0000000`	`RW/RW`	Dynamic user memory
Program Code	`0x00800000`	-	`R-/R-`	.text and .data

🔑 Key Memory Constants

// Kernel Memory
#define KERNEL_BASE         0xF0000000   // Kernel virtual address start
#define KERNEL_HEAP_START   0xF6000000   // Kernel heap begins here
#define KERNEL_HEAP_MAX     0xFFFFF000   // Kernel heap maximum
#define KERNEL_STACK_SIZE   (8*PAGE_SIZE) // 32 KB per kernel stack

// User Memory
#define USER_HEAP_START     0x80000000   // User heap begins here
#define USER_HEAP_MAX       0xA0000000   // User heap maximum (512 MB heap)
#define USER_TOP            0xEEC00000   // Top of user-accessible memory
#define USTACKTOP           0xEEBFE000   // Top of user stack

// Common
#define PAGE_SIZE           4096         // 4 KB pages
#define PTSIZE              (1024*PAGE_SIZE) // 4 MB per page table

📁 Project Structure

🚀 boot/ - Boot Loader

The boot loader is the first code to execute when the system starts.

File	Description
`boot.S`	Assembly boot sector (512 bytes), enables A20, switches to protected mode
`main.c`	Loads kernel ELF from disk, validates headers, jumps to kernel
`sign.pl`	Perl script to add boot sector signature
`Makefrag`	Build configuration for boot loader

🧠 kern/ - Kernel Source Code

The heart of the operating system.

Directory	Files	Description
`kern/`	`init.c`, `entry.S`	Kernel entry and initialization
`kern/cmd/`	`commands.c`, `command_prompt.c`	40+ kernel commands
`kern/cons/`	`console.c`	VGA text mode console driver
`kern/cpu/`	`sched.c`, `context_switch.S`, `kclock.c`	CPU and scheduling
`kern/mem/`	`memory_manager.c`, `kheap.c`, `working_set_manager.c`	Memory management
`kern/proc/`	`user_environment.c`, `user_programs.c`	Process management
`kern/trap/`	`trap.c`, `fault_handler.c`, `syscall.c`	Trap and interrupt handling
`kern/disk/`	`pagefile_manager.c`	Page file operations
`kern/tests/`	Various test files	Kernel test suite

📚 inc/ - Header Files

Shared definitions used by kernel and user programs.

File	Description
`memlayout.h`	Memory layout constants and definitions
`mmu.h`	MMU and paging definitions
`environment_definitions.h`	Process (Env) structure
`trap.h`	Trap frame definitions
`queue.h`	List/Queue macros
`syscall.h`	System call numbers
`types.h`	Basic type definitions
`dynamic_allocator.h`	Heap allocator interface

📖 lib/ - User Library

Runtime library for user programs.

File	Description
`libmain.c`	User program entry point
`syscall.c`	System call wrappers
`uheap.c`	User heap (malloc/free)
`dynamic_allocator.c`	Block-based allocator
`string.c`	String manipulation
`printf.c`	Formatted output

👤 user/ - User Programs (100+)

Sample user programs for testing and learning.

Category	Examples
Basic	`fos_helloWorld.c`, `fos_factorial.c`, `fos_fibonacci.c`
Sorting	`quicksort_.c`, `mergesort_.c`
Memory Tests	`tst_malloc_.c`, `tst_free_.c`, `heap_program.c`
Page Replacement	`tst_page_replacement_*.c`
Shared Memory	`tst_sharing_*.c`
Semaphores	`tst_semaphore_.c`, `tst_ksemaphore_.c`
Scheduling	`priRR_*.c`

💾 Memory Management

🔷 Physical Memory Management

FOS uses a frame allocator to manage physical memory pages.

// Allocate a physical frame
int allocate_frame(struct FrameInfo **ptr_frame_info);

// Free a physical frame
void free_frame(struct FrameInfo *ptr_frame_info);

// Decrement reference count
void decrement_references(struct FrameInfo* ptr_frame_info);

📊 Frame Info Structure

struct FrameInfo {
    Page_LIST_entry_t prev_next_info;  // Free list links
    uint16 references;                  // Reference count (for sharing)
    struct Env *proc;                   // Owning process
    unsigned char isBuffered;           // In modified buffer?
};

🔷 Virtual Memory Management

FOS implements two-level paging with 4KB pages.

// Get page table for a virtual address
int get_page_table(uint32 *ptr_page_directory, 
                   const uint32 virtual_address, 
                   uint32 **ptr_page_table);

// Create a new page table
void create_page_table(uint32 *ptr_directory, 
                       const uint32 virtual_address);

// Map a frame to a virtual address
int map_frame(uint32 *ptr_page_directory, 
              struct FrameInfo *ptr_frame_info, 
              uint32 virtual_address, int perm);

// Unmap a virtual address
void unmap_frame(uint32 *ptr_page_directory, 
                 uint32 virtual_address);

// Invalidate TLB entry
void tlb_invalidate(uint32 *ptr_page_directory, void *virtual_address);

🔷 Kernel Heap (KHEAP)

Dynamic memory allocation within the kernel.

// Allocate kernel memory
void* kmalloc(unsigned int size);

// Free kernel memory
void kfree(void* virtual_address);

// Reallocate kernel memory
void* krealloc(void* virtual_address, uint32 new_size);

// Address conversion
unsigned int kheap_virtual_address(unsigned int physical_address);
unsigned int kheap_physical_address(unsigned int virtual_address);

Allocation Strategies:

Strategy	Command	Description	Best For
🎯 First Fit	`khfirstfit`	First block that fits	General purpose
🔍 Best Fit	`khbestfit`	Smallest fitting block	Minimize fragmentation
➡️ Next Fit	`khnextfit`	Continue from last	Faster allocation
📏 Worst Fit	`khworstfit`	Largest block	Large allocations
⚙️ Custom Fit	`khcustomfit`	Optimized hybrid	Best performance

🔷 User Heap

Each process has its own heap for dynamic memory.

// User-level allocator (in lib/)
void* malloc(uint32 size);
void free(void* virtual_address);
void* realloc(void* virtual_address, uint32 new_size);

// System calls for heap management
void* sys_sbrk(int increment);
void allocate_user_mem(uint32 va, uint32 size);
void free_user_mem(uint32 va, uint32 size);

🔄 Process Management

📦 Environment Structure

Each process is represented by an Env structure:

View Complete Env Structure

struct Env {
    // ═══════════════════════════════════════
    // MAIN INFORMATION
    // ═══════════════════════════════════════
    struct Trapframe *env_tf;        // Saved registers during trap
    struct Context *context;          // Context switch registers
    LIST_ENTRY(Env) prev_next_info;  // Queue links
    int32 env_id;                    // Unique process identifier
    int32 env_parent_id;             // Parent process ID
    unsigned env_status;             // Current state
    int priority;                    // Scheduling priority
    char prog_name[PROGNAMELEN];     // Program name (64 chars)
    void* channel;                   // Sleep channel (blocking)
    
    // ═══════════════════════════════════════
    // ADDRESS SPACE
    // ═══════════════════════════════════════
    uint32 *env_page_directory;      // Page directory (virtual)
    uint32 env_cr3;                  // Page directory (physical)
    uint32 initNumStackPages;        // Initial stack pages
    char* kstack;                    // Kernel stack bottom
    
    // Page file management
    uint32* disk_env_pgdir;
    unsigned int disk_env_pgdir_PA;
    uint32* disk_env_tabledir;
    unsigned int disk_env_tabledir_PA;
    
    // ═══════════════════════════════════════
    // WORKING SET
    // ═══════════════════════════════════════
    unsigned int page_WS_max_size;   // Maximum working set size
    struct WS_List page_WS_list;     // Working set elements
    struct WorkingSetElement* page_last_WS_element;
    
    // LRU Lists
    struct WS_List ActiveList;       // Hot pages
    struct WS_List SecondList;       // Cold pages
    int ActiveListSize;              // Max active list size
    int SecondListSize;              // Max second list size
    
    // ═══════════════════════════════════════
    // STATISTICS
    // ═══════════════════════════════════════
    uint32 pageFaultsCounter;
    uint32 tableFaultsCounter;
    uint32 freeingFullWSCounter;
    uint32 freeingScarceMemCounter;
    uint32 nModifiedPages;
    uint32 nNotModifiedPages;
    uint32 env_runs;                 // Times this env has run
    uint32 nPageIn, nPageOut, nNewPageAdded;
    uint32 nClocks;
};

🔄 Process States

State	Value	Description	Next States
🆓 `ENV_FREE`	0	Available in free list	NEW
🆕 `ENV_NEW`	4	Newly created	READY
✅ `ENV_READY`	1	Ready to run	RUNNING
▶️ `ENV_RUNNING`	2	Currently executing	READY, BLOCKED, EXIT
⏸️ `ENV_BLOCKED`	3	Waiting for resource	READY
🚪 `ENV_EXIT`	5	Terminated normally	FREE
☠️ `ENV_KILLED`	6	Killed externally	FREE

🔄 Process Lifecycle

┌─────────────────────────────────────────────────────────────┐
│                    PROCESS LIFECYCLE                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   FREE ──create──► NEW ──schedule──► READY ◄───────┐       │
│     ▲                                   │           │       │
│     │                              dispatch         │       │
│     │                                   ▼           │       │
│     │                               RUNNING ────────┤       │
│     │                                   │           │       │
│   free                        ┌─────────┼─────────┐ │       │
│     │                         │         │         │ │       │
│     │                         ▼         ▼         ▼ │       │
│     └──────────────────── BLOCKED    EXIT    preempt        │
│                               │                             │
│                           wakeup ──► READY                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

📋 Process Functions

// Create a new process
struct Env* env_create(char* user_program_name, 
                       unsigned int page_WS_size,
                       unsigned int LRU_second_list_size,
                       unsigned int percent_WS_pages_to_remove);

// Free a process and its resources
void env_free(struct Env *e);

// Exit current process
void env_exit(void);

// Get current running process
struct Env* get_cpu_proc(void);

// Convert env ID to env pointer
int envid2env(int32 envid, struct Env **env_store, bool checkperm);

⏰ CPU Scheduling

FOS implements four different scheduling algorithms, each with unique characteristics.

1️⃣ Round Robin (RR)

The simplest fair scheduling algorithm.

Property	Value
Fairness	⭐⭐⭐⭐⭐ Equal time for all
Complexity	⭐ Very simple
Responsiveness	⭐⭐⭐ Depends on quantum
Overhead	⭐⭐ Context switches

Command: schedRR <quantum>

How it works:

All processes are in a single FIFO queue
Each process runs for exactly quantum time units
After quantum expires, process moves to end of queue
Next process in queue starts executing

2️⃣ Multi-Level Feedback Queue (MLFQ)

Adaptive scheduling that learns process behavior.

Property	Value
Fairness	⭐⭐⭐ Based on behavior
Complexity	⭐⭐⭐⭐ Multiple queues
Responsiveness	⭐⭐⭐⭐⭐ Interactive friendly
Overhead	⭐⭐⭐ Queue management

Command: schedMLFQ <num_levels> <q1> <q2> ...

How it works:

Multiple priority queues with different time quantums
New processes start at highest priority (shortest quantum)
If process uses full quantum → move to lower priority
If process blocks for I/O → stay at current or move up
Periodic priority boost to prevent starvation

3️⃣ BSD Scheduler

Based on the FreeBSD scheduler with dynamic priority calculation.

Property	Value
Fairness	⭐⭐⭐⭐ Dynamic adjustment
Complexity	⭐⭐⭐⭐ Priority calculation
Responsiveness	⭐⭐⭐⭐ Good for mixed workloads
Overhead	⭐⭐⭐ Recalculation

Command: schedBSD <num_levels> <quantum>

Priority Formula:

priority = PRI_BASE + (recent_cpu / 4) + (nice × 2)

4️⃣ Priority Round Robin (PRIRR)

Combines priority scheduling with round-robin within each level.

Property	Value
Fairness	⭐⭐⭐ Within priority levels
Complexity	⭐⭐⭐ Multiple queues + RR
Responsiveness	⭐⭐⭐⭐ High priority = fast
Overhead	⭐⭐⭐ Anti-starvation

Command: schedPRIRR <num_priorities> <quantum> <starvation_threshold>

Priority Levels:

Level	Name	Value
5	HIGH	Highest priority
4	ABOVENORMAL	Above average
3	NORMAL	Default
2	BELOWNORMAL	Below average
1	LOW	Lowest priority

Anti-Starvation: After starvation_threshold ticks without running, low-priority processes get a priority boost.

📄 Page Replacement Algorithms

FOS implements 7 page replacement algorithms for virtual memory management.

📊 Algorithm Comparison

Algorithm	Command	Complexity	Accuracy	Best For
🔢 FIFO	`fifo`	O(1)	Low	Simple systems
⏰ Clock	`clock`	O(n)	Medium	General purpose
⏰ Modified Clock	`modclock`	O(n)	Good	Write-heavy
📈 LRU (Time)	`lru 1`	O(n)	High	Accuracy needed
📈 LRU (Lists)	`lru 2`	O(1)	Good	Fast approximation
🔄 N-Chance	`nthclk <n>`	O(n)	Configurable	Flexible
⭐ Optimal	`optimal`	O(n×m)	Perfect	Testing only

🔢 FIFO - First In First Out

The simplest replacement algorithm.

Idea: Replace the oldest page in memory
Pros: Very simple to implement
Cons: Doesn't consider page usage (Belady's anomaly possible)

⏰ Clock (Second Chance)

An approximation of LRU using a reference bit.

Idea: Give pages a "second chance" if recently used
Implementation: Circular buffer with clock hand
Reference bit: Set to 1 when page accessed, cleared by clock hand

⏰ Modified Clock

Clock algorithm that also considers the dirty bit.

Idea: Prefer replacing clean pages (no write-back needed)
Priority: (R=0, M=0) > (R=0, M=1) > (R=1, M=0) > (R=1, M=1)

📈 LRU - Least Recently Used

Replace the page that hasn't been used for the longest time.

Two implementations:

Time-based: Each page has a timestamp of last access
Lists-based: Active list (hot) and Second list (cold)

⭐ Optimal (Belady's)

The theoretically optimal algorithm - replace the page that won't be used for the longest time.

Uses: Future knowledge (reference string)
Purpose: Benchmarking other algorithms
Reality: Cannot be implemented in real systems

📞 System Calls

FOS provides 30+ system calls for user programs.

🔄 Process Management

int32 sys_getenvid(void);              // Get current process ID
void sys_exit(void);                    // Terminate process
int sys_create_env(char* prog_name, 
                   unsigned int page_WS_size,
                   unsigned int lru_second_size,
                   unsigned int percent_WS_remove);
void sys_run_env(int32 envid);          // Start process execution
void sys_destroy_env(int envid);        // Destroy a process
void sys_yield(void);                   // Give up CPU

💾 Memory Management

int sys_allocate_page(void *va, int perm);
int sys_map_frame(int32 srcenvid, void *srcva,
                  int32 dstenvid, void *dstva, int perm);
int sys_unmap_frame(int32 envid, void *va);
void* sys_sbrk(int increment);
uint32 sys_get_brk();
void sys_free_user_mem(uint32 va, uint32 size);
uint32 sys_calculate_free_frames();
uint32 sys_calculate_modified_frames();

🔗 Shared Memory

int sys_createSharedObject(char* shareName, uint32 size, 
                           uint8 isWritable, void** returned_shared_address);
int sys_getSharedObject(int32 ownerEnvID, char* shareName, 
                        void** returned_shared_address);
int sys_freeSharedObject(int32 sharedObjectID, void* startVA);

🔒 Semaphores

// Kernel semaphores
int sys_createSemaphore(char* name, int value);
void sys_waitSemaphore(int id);
void sys_signalSemaphore(int id);

// User semaphores
void sys_acquire_lock(struct uspinlock* lock);
void sys_release_lock(struct uspinlock* lock);

🖥️ Console I/O

void sys_cputs(const char *s, uint32 len);
int sys_cgetc(void);
void sys_cputc(int c);

🚀 Quick Start

📋 Prerequisites

Tool	Version	Purpose
`i386-elf-gcc`	Latest	Cross-compiler for x86-32
`i386-elf-as`	Latest	Assembler
`i386-elf-ld`	Latest	Linker
`i386-elf-objcopy`	Latest	Binary manipulation
`bochs`	2.6+	x86 Emulator
`make`	GNU Make	Build system
`perl`	5.x	Build scripts

🔨 Build Commands

# Build the entire project
make all

# Clean build artifacts
make clean

# Full clean (including logs)
make realclean

# Build and run in Bochs (no GUI)
make bochs

▶️ Running FOS

# Start Bochs with GUI
bochs

# Start Bochs without GUI (console mode)
bochs 'display_library: nogui'

# Windows users
bochscon.bat

🎮 First Steps

Boot FOS - Watch the initialization messages
Type help - See all available commands
Run Hello World: run fos_helloWorld 10
Check memory: meminfo
Run more programs: run fos_factorial 15
Kill all processes: killall

💻 Commands Reference

🔄 Process Management

Command	Arguments	Description
`run`	`<program> <ws_size>`	Run a program with working set size
`kill`	`<env_id>`	Kill a specific process
`killall`	-	Kill all running processes
`runall`	-	Run all loaded programs
`printall`	-	Print info about all processes

💾 Memory Management

Command	Arguments	Description
`meminfo`	-	Display memory statistics
`allocuserpage`	`<va>`	Allocate a user page
`remove_table`	`<va>`	Remove a page table
`readmem_k`	`<va>`	Read kernel memory
`writemem_k`	`<va> <val>`	Write to kernel memory

📄 Page Replacement

Command	Description
`fifo`	Set FIFO replacement
`clock`	Set Clock (second chance)
`modclock`	Set Modified Clock
`lru 1`	Set LRU with timestamps
`lru 2`	Set LRU with lists
`nthclk <n>`	Set N-Chance Clock
`optimal`	Set Optimal (for testing)
`pagerep`	Print current algorithm

⏰ Scheduler

Command	Arguments	Description
`schedRR`	`<quantum>`	Set Round Robin
`schedMLFQ`	`<levels> <q1> <q2>...`	Set MLFQ
`schedBSD`	`<levels> <quantum>`	Set BSD
`schedPRIRR`	`<pri> <quantum> <thresh>`	Set Priority RR
`schedmethod`	-	Print current scheduler
`setpriority`	`<env_id> <priority>`	Set process priority

💾 Heap Strategies

Command	Description
`khfirstfit`	Kernel heap: First Fit
`khbestfit`	Kernel heap: Best Fit
`khnextfit`	Kernel heap: Next Fit
`khworstfit`	Kernel heap: Worst Fit
`khcustomfit`	Kernel heap: Custom Fit
`uhfirstfit`	User heap: First Fit
`uhbestfit`	User heap: Best Fit
`uhcustomfit`	User heap: Custom Fit

🧪 Testing Framework

FOS includes a comprehensive testing framework with 50+ test cases.

📊 Test Categories

Category	Command Prefix	Description
Dynamic Allocator	`tst dynalloc`	Block allocation and freeing
Kernel Heap	`tst kheap`	kmalloc, kfree, krealloc
Page Replacement	`run tpr`, `run tclock`	All replacement algorithms
User Heap	`run tm`, `run tf`	malloc and free tests
Custom Fit	`run tcf*`	Custom allocation tests
Shared Memory	`run tshr*`	Shared memory operations
Semaphores	`run tst_ksem*`	Synchronization tests
Scheduler	`tst priorityRR`	Priority scheduling
Environment Free	`run tef*`	Process cleanup tests

🔄 Running Tests

# Dynamic allocator tests
FOS> tst dynalloc init
FOS> tst dynalloc alloc
FOS> tst dynalloc free
FOS> tst dynalloc realloc

# Kernel heap tests
FOS> tst kheap CF kmalloc blk
FOS> tst kheap CF kfree both

# User program tests
FOS> run tm1 3000
FOS> run tm2 3000
FOS> run tshr1 3000

# Page replacement tests
FOS> clock
FOS> run tclock1 11
FOS> run tclock2 11

# Scheduler tests
FOS> schedPRIRR 10 40 1000
FOS> tst priorityRR 0

🐛 Debugging

🔧 GDB Debugging

# Start Bochs in debug mode
bochs -f .bochsrc-debug

# In another terminal, connect with GDB
gdb obj/kern/kernel
(gdb) target remote localhost:1234
(gdb) break FOS_initialize
(gdb) continue
(gdb) info registers
(gdb) x/10x $esp

🔍 Kernel Debug Functions

// Print debug information
void debug_printinfo(void);

// Print stack backtrace
void debug_backtrace(void);

// Kernel panic - halt system
void _panic(const char *file, int line, const char *fmt, ...);

// Panic and exit all environments
void _panic_all(const char *file, int line, const char *fmt, ...);

// Warning - continue execution
void _warn(const char *file, int line, const char *fmt, ...);

📝 Debug Macros

// Assert condition
assert(condition);

// Panic with message
panic("Something went wrong: %d", error_code);

// Warning message
warn("Unexpected value: %x", value);

👨‍🏫 Course Instructor

🎓 Dr. Ahmed Salah

Course Instructor

Faculty of Computers and Information Science
Ain Shams University

Operating Systems Course

👥 Development Team

🚀 Meet Our Amazing Team

Fady _@fady2024	Fady Rafat _@FadyRafat0	Kaldesh _@kaldesh
Omar Zamel _@0xZamel	Ammar Adel _{@ammar-adel222}	Fady _@Fady278

📜 License

This project is licensed under the GNU General Public License v3.0 - see the LICENSE file for details.

📋 License Summary

Permissions	Conditions	Limitations
✅ Commercial use	📋 License and copyright notice	❌ Liability
✅ Modification	📋 State changes	❌ Warranty
✅ Distribution	📋 Disclose source
✅ Patent use	📋 Same license
✅ Private use

🏛️ Original Components

FOS is derived from multiple open-source projects:

Component	Source	Original License
Core Kernel	MIT Exokernel	MIT License
Console Driver	NetBSD pccons	BSD License
Clock/Scheduler	Exotec, Inc.	Exotec License
Printf	UC Berkeley	BSD License
Process Management	xv6 (MIT)	MIT License

🙏 Acknowledgments

Contributor	Contribution
Dr. Ahmed Salah	Course instructor and guidance
MIT PDOS Group	Exokernel foundation
UC Berkeley	Console and printf code
xv6 Developers	Inspiration and reference

🎓 Developed at

Faculty of Computers and Information Science
Ain Shams University
Cairo, Egypt

📧 Contact

Fady Gerges
📧 Email: fadygerges2023@gmail.com
🔗 GitHub: @Fady2024
📂 Repository: OS_Project_2025

Name		Name	Last commit message	Last commit date
Latest commit History 60 Commits
.settings		.settings
boot		boot
conf		conf
inc		inc
kern		kern
lib		lib
user		user
.bochsrc		.bochsrc
.bochsrc-debug		.bochsrc-debug
.cproject		.cproject
.gdbinit		.gdbinit
.gitignore		.gitignore
.project		.project
BIOS-bochs-latest		BIOS-bochs-latest
BIOS-bochs-latest_2-3		BIOS-bochs-latest_2-3
FOS_Developer_Console.bat		FOS_Developer_Console.bat
GNUmakefile		GNUmakefile
LICENSE		LICENSE
README.md		README.md
Readme_Project_Port_To_ModernGCC.txt		Readme_Project_Port_To_ModernGCC.txt
VGABIOS-lgpl-latest		VGABIOS-lgpl-latest
bochscon.bat		bochscon.bat
coding		coding
mergedep.pl		mergedep.pl
stdout		stdout

License

Fady2024/OS_Project_2025

Folders and files

Latest commit

History

Repository files navigation

🖥️ FOS - FCIS Operating System

🎓 A Comprehensive Educational Operating System Kernel

📋 Table of Contents

🌟 Introduction

What is FOS?

🎯 Educational Goals

🧠

Memory Management

⚡

Process Scheduling

🔒

System Protection

💻

Systems Programming

🏆 Why FOS?

✨ Features

🔥 Core Kernel Features

📊 Feature Statistics

🏗️ System Architecture

🗺️ Memory Layout

🔑 Key Memory Constants

📁 Project Structure

💾 Memory Management

🔷 Physical Memory Management

🔷 Virtual Memory Management

🔷 Kernel Heap (KHEAP)

🔷 User Heap

🔄 Process Management

📦 Environment Structure

🔄 Process States

🔄 Process Lifecycle

📋 Process Functions

⏰ CPU Scheduling

1️⃣ Round Robin (RR)

2️⃣ Multi-Level Feedback Queue (MLFQ)

3️⃣ BSD Scheduler

4️⃣ Priority Round Robin (PRIRR)

📄 Page Replacement Algorithms

📊 Algorithm Comparison

📞 System Calls

🚀 Quick Start

📋 Prerequisites

🔨 Build Commands

▶️ Running FOS

🎮 First Steps

💻 Commands Reference

🔄 Process Management

💾 Memory Management

📄 Page Replacement

⏰ Scheduler

💾 Heap Strategies

🧪 Testing Framework

📊 Test Categories

🔄 Running Tests

🐛 Debugging

🔧 GDB Debugging

🔍 Kernel Debug Functions

📝 Debug Macros

👨‍🏫 Course Instructor

🎓 Dr. Ahmed Salah

👥 Development Team

🚀 Meet Our Amazing Team

📜 License

📋 License Summary

🏛️ Original Components

🙏 Acknowledgments

🎓 Developed at

📧 Contact

⭐ Star this repo if you found it helpful!

About

Topics

Resources

License

Uh oh!

Packages