Kernel

typedef struct {
 uint16_t limit_low; // limit bawah
 uint16_t base_low; // base bawah
 uint8_t base_mid; // base tengah
 uint8_t access; // access byte (present, dpl, type)
 uint8_t granularity; // granularity + limit atas
 uint8_t base_high; // base atas
} __attribute__((packed)) gdt_entry_t;

static uint32_t TSS[32] = {0}; // , enough for 26 uint32_t

gdt_set_entry(5, (uint32_t)&TSS, sizeof(TSS) - 1, 0x89, 0x40);
// 0x89 = present | ring0 | TSS (0x9 = available TSS)
// 0x40 = byte granularity, 32-bit

typedef struct {
 uint16_t offset_lo; // handler address bawah
 uint16_t selector; // code segment selector (0x08)
 uint8_t reserved; // always 0
 uint8_t type_attr; // type and attributes
 uint16_t offset_hi; // handler address atas
} __attribute__((packed)) IDTEntry;

void interrupt_handler(int int_num, int err_code) {
 uint32_t cr2_val = 0;
 if (int_num == 14) { // page fault
 asm volatile("mov %%cr2, %0" : "=r"(cr2_val));
 }
 // ambil eip (kurang akurat, tapi buat debugging cukup)
 uint32_t eip_val = 0;
 asm volatile("mov 4(%%ebp), %0" : "=r"(eip_val));

 log_exception(int_num, err_code, cr2_val, eip_val);

 // display on screen
 vga_print("=== EXCEPTION ===\n");
 // print int_num, err_code, cr2 (kalo page fault)

 // eoi buat irq
 if (int_num >= 32 && int_num < 48) {
 outb(0x20, 0x20);
 if (int_num >= 40) outb(0xA0, 0x20);
 }

 vga_print("=== UNRECOVERABLE EXCEPTION ===\n");
 while (1) { asm volatile("cli; hlt"); }
}

uint32_t syscall_dispatch(uint32_t num, uint32_t a1, uint32_t a2, uint32_t a3) {
 switch (num) {
 case SYSCALL_WRITE: return syscall_write(...);
 case SYSCALL_OPEN: return syscall_open(...);
 case SYSCALL_READ: return syscall_read(...);
 // ... 23 cases total
 case SYSCALL_USER_EXIT: return syscall_user_exit();
 case SYSCALL_BRK: return syscall_brk(a1);
 default: return 0xFFFFFFFF; // invalid
 }
}

uint32_t syscall_open(const char *path, int flags) {
 fd_table_t *table = fd_get_current_table();
 return fd_open(table, path, flags);
}

# Define USER_HEAP_BASE 0x01000000
# Define USER_HEAP_MAX 0x02000000
static uint32_t user_brk = USER_HEAP_BASE;

static uint32_t syscall_brk(uint32_t addr) {
 if (addr == 0) return user_brk; // query current
 if (addr < USER_HEAP_BASE || addr > USER_HEAP_MAX) return user_brk;

 addr = (addr + 0xFFF) & ~0xFFF; // align to a page

 // expand upward
 while (user_brk < addr) {
 uint32_t phys = PMM_alloc_page();
 page_map(user_brk, phys, PTE_PRESENT | PTE_WRITE | PTE_USER);
 user_brk += 0x1000;
 }
 // shrink (physical pages are not freed yet)
 while (user_brk > addr) { user_brk -= 0x1000; }

 return user_brk;
}

static uint32_t syscall_user_exit(void) {
 user_exit_flag = 1;
 return 0;
}

# Define BITMAP_SIZE 1024 * 1024 // 1mb
static uint8_t page_bitmap[BITMAP_SIZE];
static uint32_t total_pages = 0;
static uint32_t free_pages = 0;

for (i = 0; i < total_pages; i++) {
 if (!bitmap_test(i)) { // free bit
 bitmap_set(i);
 free_pages--;
 return i * PAGE_SIZE; // physical address
 }
}
return 0; // no free pages

uint32_t page = phys / PAGE_SIZE;
bitmap_clear(page);
free_pages++;

__attribute__((aligned(0x1000)))
pde_t kernel_page_dir[PAGE_DIR_SIZE]; // entry
static pte_t kernel_page_tables[128][PAGE_TABLE_SIZE]; // page table pool
static int page_table_index = 5; // 0-4 udah dipake init

uint32_t dir_index = virt >> 22;
uint32_t table_index = (virt >> 12) & 0x3FF;

if (!kernel_page_dir[dir_index] & PTE_PRESENT) {
 // allocate a new page table from the pool
 pte_t *pt = kernel_page_tables[page_table_index++];
 for (int i = 0; i < 1024; i++) pt[i] = 0;
 kernel_page_dir[dir_index] = (uint32_t)pt | PTE_PRESENT | PTE_WRITE;
 if (flags & PTE_USER) kernel_page_dir[dir_index] |= PTE_USER;
} else {
 if (flags & PTE_USER) kernel_page_dir[dir_index] |= PTE_USER;
}

pte_t *pt = (pte_t *)(kernel_page_dir[dir_index] & PAGE_MASK);
pt[table_index] = (phys & PAGE_MASK) | flags | PTE_PRESENT;

uint32_t pd_phys;
if (dir == NULL) pd_phys = (uint32_t)kernel_page_dir;
else pd_phys = (uint32_t)dir;
asm volatile("mov %0, %%cr3" : : "r"(pd_phys));

typedef struct heap_block {
 uint32_t size; /* total ukuran block (header + payload) */
 uint16_t magic; /* MAGIC_FREE (0xF4EE) or MAGIC_USED (0x1CED) */
 uint16_t flags; /* bit 0: free */
 struct heap_block *next; /* next free block */
 struct heap_block *prev; /* prev free block */
} heap_block_t;

int npages = expand_heap(0x10000); // 64kb initial
// allocate a physical page and map it at HEAP_BASE + old_committed * 0x1000
committed_pages += npages;

typedef struct task_t {
 uint32_t id;
 uint32_t ppid;
 task_state_t state; // READY=0, RUNNING=1, BLOCKED=2, DEAD=3
 int exit_code;
 task_context_t context; // registers + cs + eflags + cr3
 uint32_t *stack;
 uint32_t stack_base;
 struct task *parent;
 struct task *child_first;
 struct task *sibling_next;
 struct task_t *next;
 struct task_t *prev;
 fd_table_t *fd_table;
} task_t;

typedef struct {
 uint32_t eax, ebx, ecx, edx;
 uint32_t esi, edi, ebp, esp;
 uint32_t eip;
 uint32_t eflags;
 uint32_t cs;
 uint32_t cr3;
} task_context_t;

void task_switch(void) {
 if (task_count <= 1) return;

 task_t *prev = current_task;

 // round-robin
 current_task = current_task->next;
 if (!current_task) current_task = &tasks[0];
 current_task->state = TASK_RUNNING;

 // cr3 switching
 if (current_task->context.cr3 != 0)
 paging_switch_dir((pde_t *)current_task->context.cr3);
 else if (prev && prev->context.cr3 && !current_task->context.cr3)
 paging_switch_dir(NULL);
}

asm volatile(
 "pushl %2\n" /* ss = 0x23 */
 "pushl %1\n" /* esp */
 "pushl %3\n" /* eflags = 0x202 */
 "pushl %0\n" /* cs = 0x1B */
 "pushl %4\n" /* eip */
 "mov %2, %%eax\n"
 "mov %%eax, %%ds\n"
 "mov %%eax, %%es\n"
 "mov %%eax, %%fs\n"
 "mov %%eax, %%gs\n"
 "iret\n"
);

int klibc_printf(const char *fmt, ...) {
 va_list args;
 va_start(args, fmt);

 for (int i = 0; fmt[i]; i++) {
 if (fmt[i] != '%') { vga_putc(fmt[i]); count++; continue; }
 i++;
 switch (fmt[i]) {
 case 'd': count += print_int(va_arg(args, int)); break;
 case 's': count += print_padded_string(va_arg(args, char*), width, 0, left); break;
 case 'x': count += print_unsigned(va_arg(args, unsigned), 16, 0); break;
 case 'u': count += print_unsigned(va_arg(args, unsigned), 10, 0); break;
 case 'o': count += print_unsigned(va_arg(args, unsigned), 8, 0); break;
 case 'p': vga_print("0x"); count += print_unsigned((uint32_t)va_arg(args,void*),16,0); break;
 case 'c': vga_putc(va_arg(args, int)); count++; break;
 case '%': vga_putc('%'); count++; break;
 }
 }
 va_end(args);
}

int klibc_scanf(const char *fmt, ...) {
 gets(line); // read multiple lines from the keyboard
 for (int i = 0; fmt[i]; i++) {
 if (fmt[i] != '%') {
 if (fmt[i] == ' ' || fmt[i] == '\t') continue;
 if (line[lpos] == fmt[i]) lpos++;
 else break;
 continue;
 }
 i++;
 switch (fmt[i]) {
 case 'd': /* parse integer desimal */
 case 's': /* parse string sampe whitespace */
 case 'x': /* parse hex */
 case 'o': /* parse octal */
 }
 }
}

int klibc_sprintf(char *buf, const char *fmt, ...) {
 // like printf, but writes to a buffer instead of VGA
 va_start(args, fmt);
 for (int i = 0; fmt[i]; i++) {
 if (fmt[i] != '%') { buf[pos++] = fmt[i]; continue; }
 i++;
 switch (fmt[i]) {
 case 'd': itoa(val, tmp, 10); for(...) buf[pos++] = tmp[j]; break;
 case 's': while(*s) buf[pos++] = *s++; break;
 }
 }
 buf[pos] = '\0';
}

int klibc_atoi(const char *s) {
 int sign = 1, num = 0;
 while (*s == ' ' || *s == '\t') s++;
 if (*s == '-') { sign = -1; s++; }
 while (*s >= '0' && *s <= '9') { num = num * 10 + (*s - '0'); s++; }
 return num * sign;
}

static inline uint32_t sys3(uint32_t num, uint32_t a1, uint32_t a2, uint32_t a3) {
 register uint32_t eax asm("eax") = num;
 register uint32_t ebx asm("ebx") = a1;
 register uint32_t ecx asm("ecx") = a2;
 register uint32_t edx asm("edx") = a3;
 asm volatile("int $0x80" : "+r"(eax) : "r"(ebx), "r"(ecx), "r"(edx));
 return eax;
}

int usr_printf(const char *fmt, ...) {
 for (int i = 0; fmt[i]; i++) {
 if (fmt[i] != '%') { usr_putchar(fmt[i]); continue; }
 i++;
 switch (fmt[i]) {
 case 'd': /* convert int to string -> write via syscall */
 case 's': /* write string via syscall */
 case 'x': /* hex via syscall */
 }
 }
}

void *usr_malloc(uint32_t size) {
 uint32_t cur = sys1(SYSCALL_BRK, 0);
 if (cur == 0) return 0;
 uint32_t new = sys1(SYSCALL_BRK, cur + size + 4);
 if (new <= cur) return 0;
 return (void *)(cur + 4);
}

static char log_buf[LOG_BUF_SIZE]; // 
static volatile int write_pos = 0;
static volatile int read_pos = 0;

void log_printf(const char *fmt, ...) {
 // write timestamp
 log_putchar('[');
 log_int(timer_get_ticks(), 10);
 log_puts("] ");

 va_start(args, fmt);
 for (int i = 0; fmt[i]; i++) {
 if (fmt[i] != '%') { log_putchar(fmt[i]); continue; }
 i++;
 switch (fmt[i]) {
 case 's': log_puts(va_arg(args, char*)); break;
 case 'd': log_int(va_arg(args, int), 10); break;
 case 'x': log_hex(va_arg(args, uint32_t)); break;
 }
 }
 log_putchar('\n');
}

log_printf("[EXC] int=%d err=0x%x cr2=0x%x eip=0x%x", int_num, err_code, cr2_val, eip_val);