Tuna Kılıç
All posts

Narc Devlog: Process'ler ve her process'e kendi page table'ı

Narc'ta user programları process yapıyoruz, her birine kendi adres alanını veriyoruz ve hata yapan programı kernel'i bozmadan öldürüyoruz.

November 2026PublishedOSDev · Narc
İçindekiler

Selam ben Tuna, userspace yazısının sonunda iki büyük eksik vardı:

  1. user programı hata yapınca bütün kernel duruyodu
  2. user programı kernel'in page table'ını kullanıyodu, ikinci bi program gelse ikisi aynı adreslere yazardı

bu yazıda ikisini birden çözüyoruz. sonunda üç tane program sırayla çalışıcak, ikisi kernel'e saldırıp ölücek biri hello world yazıcak ve kernel hiç etkilenmiyecek

Ders 1: Process nedir

Şu ana kadar "user programı" diyoduk ama aslında bi programın çalışan haline process deniyo. bi process'in kendine ait şeyleri var:

  • numarası (pid)
  • durumu (çalışıyo mu sırada mı)
  • kendi adres alanı yani kendi page table'ı

son madde önemli. iki process ikisi de 0x400000'da çalışabilmeli ama farklı fiziksel sayfalarda. A process'i 0x400000'a yazınca B'ninki değişmemeli. bunu sağlamanın yolu her process'e ayrı PML4 vermek ve process değişince CR3'ü değiştirmek

1. struct process

#define MAX_PROCESSES 16

#define PROC_UNUSED  0
#define PROC_READY   1
#define PROC_RUNNING 2

struct process {
    int pid;
    int state;
    const char *name;
    uint64_t pml4;
};

şimdilik bu kadar yeter. 16 tane process'lik sabit bi dizi tutuyorum:

static struct process processes[MAX_PROCESSES];
static struct process *current = NULL;
static int next_pid = 1;

Ders 2: Her process'e kendi page table'ı

1. Yeni adres alanı

VMM yazısında üst yarının (256-511) bütün PDPT'lerini baştan açmıştık "ilerde process'ler bunu paylaşıcak" diye. işte o zaman geldi:

uint64_t vmm_new_address_space(void) {
    uint64_t pml4 = pmm_alloc_page();
    if (pml4 == 0)
        return 0;

    uint64_t *new_table = phys_to_table(pml4);
    uint64_t *kernel_table = phys_to_table(kernel_pml4);

    for (int i = 0; i < 256; i++)
        new_table[i] = 0;
    for (int i = 256; i < 512; i++)
        new_table[i] = kernel_table[i];

    return pml4;
}
  • alt yarı (user) boş
  • üst yarı (kernel) kernel'in PML4'ünden aynen kopya. aynı PDPT'leri gösteriyolar yani kernel her process'te aynı yerde duruyo

bu neden şart? process çalışırken interrupt gelince CPU kernel kodunu çalıştırıcak ama CR3 hala process'inki. kernel o page table'da yoksa direkt patlar

ve üst yarının PDPT'lerini baştan açtığımız için sonradan kernel'e bişey map edersek (mesela heap büyürse) bütün process'ler otomatik görüyo, kimseyi güncellemek gerekmiyo. VMM yazısındaki o 1 MiB'ın karşılığı bu

2. Başka bi page table'a map etmek

vmm_map_page hep kernel'in PML4'üne map ediyodu. process'in PML4'üne map edebilmek için PML4'ü parametre alan bi versiyon yazdım, eskisi de onu çağırıyo:

bool vmm_map_page(uint64_t virt, uint64_t phys, uint64_t flags) {
    return vmm_map_page_in(kernel_pml4, virt, phys, flags);
}

bool vmm_map_page_in(uint64_t pml4_phys, uint64_t virt, uint64_t phys, uint64_t flags) {
    if ((virt & 0xFFF) || (phys & 0xFFF))
        return false;

    uint64_t *pml4 = phys_to_table(pml4_phys);
    ...

geri kalanı aynı

3. Adres alanını silmek

process bitince onun bütün sayfalarını ve tablolarını PMM'e geri vermemiz lazım:

static void free_table(uint64_t phys, int level) {
    uint64_t *t = phys_to_table(phys);

    for (int i = 0; i < 512; i++) {
        if (!(t[i] & PTE_PRESENT))
            continue;
        if (level == 1)
            pmm_free_page(t[i] & PTE_ADDR_MASK);
        else
            free_table(t[i] & PTE_ADDR_MASK, level - 1);
    }

    pmm_free_page(phys);
}

void vmm_free_address_space(uint64_t pml4) {
    uint64_t *t = phys_to_table(pml4);

    for (int i = 0; i < 256; i++) {
        if (t[i] & PTE_PRESENT)
            free_table(t[i] & PTE_ADDR_MASK, 3);
    }

    pmm_free_page(pml4);
}

recursive. level 3 PDPT 2 PD 1 PT. PT'deki entry'ler direkt process'in sayfaları onları free ediyoruz, üst seviyelerde bi alt tabloya iniyoruz, en son tablonun kendisini de free ediyoruz

sadece alt yarıyı siliyoruz. üst yarı kernel'in, onu silersek bütün sistem gider

4. process_create

static uint64_t map_new_page(uint64_t pml4, uint64_t virt, uint64_t flags) {
    uint64_t phys = pmm_alloc_page();
    if (phys == 0)
        return 0;

    memset(vmm_phys_to_virt(phys), 0, PAGE_SIZE);

    if (!vmm_map_page_in(pml4, virt, phys, flags | PTE_USER)) {
        pmm_free_page(phys);
        return 0;
    }
    return phys;
}

vmm_phys_to_virt = phys + hhdm. process'in sayfası kernel'in CR3'ünde map'li değil o yüzden sayfaya HHDM'den yazıyoruz

struct process *process_create(const char *name, const uint8_t *code, uint64_t size) {
    struct process *p = NULL;
    for (int i = 0; i < MAX_PROCESSES; i++) {
        if (processes[i].state == PROC_UNUSED) {
            p = &processes[i];
            break;
        }
    }
    if (p == NULL)
        return NULL;

    uint64_t pml4 = vmm_new_address_space();
    if (pml4 == 0)
        return NULL;

    uint64_t first_phys = 0;

    for (uint64_t off = 0; off < size; off += PAGE_SIZE) {
        uint64_t phys = map_new_page(pml4, USER_CODE_ADDR + off, PTE_WRITE);
        if (phys == 0) {
            vmm_free_address_space(pml4);
            return NULL;
        }
        if (off == 0)
            first_phys = phys;

        uint64_t n = size - off < PAGE_SIZE ? size - off : PAGE_SIZE;
        memcpy(vmm_phys_to_virt(phys), code + off, n);
    }

    for (uint64_t i = 1; i <= USER_STACK_PAGES; i++) {
        if (map_new_page(pml4, USER_STACK_TOP - i * PAGE_SIZE, PTE_WRITE | PTE_NX) == 0) {
            vmm_free_address_space(pml4);
            return NULL;
        }
    }

    p->pid = next_pid++;
    p->name = name;
    p->pml4 = pml4;
    p->state = PROC_READY;
    ...
  1. boş slot bul
  2. yeni adres alanı
  3. programı sayfa sayfa kopyala (eskiden usermode.c'de yaptığımızın aynısı ama process'in PML4'üne)
  4. stack
  5. READY yap

yarıda patlarsa açtığımız adres alanını silip NULL dönüyoruz

sonunda pid'i CR3'ü ve kodun ilk sayfasının fiziksel adresini basıyorum, test için

Ders 3: Process'leri çalıştırmak

Henüz scheduler yok (o sonraki yazı). şimdilik process'ler sırayla çalışıcak, biri bitince öbürü:

void process_start_next(void) {
    for (int i = 0; i < MAX_PROCESSES; i++) {
        if (processes[i].state == PROC_READY) {
            current = &processes[i];
            current->state = PROC_RUNNING;
            vmm_write_cr3(current->pml4);
            jump_to_usermode(USER_CODE_ADDR, USER_STACK_TOP - 8);
        }
    }

    current = NULL;
    kprint("PROC: no processes left, free pages ");
    kprint_dec(pmm_get_free_pages());
    kprint("\n");
    kernel_idle();
}

READY olan ilk process'i bul, CR3'ü onun PML4'ü yap, ring 3'e zıpla. kalmadıysa kernel_idle'a git

jump_to_usermode userspace yazısındakinin aynısı sadece usermode.c'yi sildim ve process.c'ye taşıdım

CR3'ü değiştirdiğimiz an kernel kodu hala çalışmaya devam ediyo çünkü üst yarı her process'te aynı

process_exit

void process_exit(int64_t code) {
    struct process *p = current;

    kprint("PROC: pid ");
    kprint_dec(p->pid);
    kprint(" (");
    kprint(p->name);
    kprint(") exited with code ");
    print_signed(code);
    kprint("\n");

    vmm_write_cr3(vmm_kernel_space());
    vmm_free_address_space(p->pml4);
    p->state = PROC_UNUSED;
    current = NULL;

    process_start_next();
}

ÖNEMLİ: adres alanını silmeden önce CR3'ü kernel'inkine çeviriyoruz. CPU o an process'in page table'ını kullanırken onu silersek ayağımızın altındaki halıyı çekmiş oluruz

sonra bi sonraki process'i başlatıyoruz. bu fonksiyon hiç geri dönmüyo, syscall handler'ın stack'inde kalan her şeyi öylece bırakıyoruz zaten bi sonraki interrupt'ta CPU TSS'den rsp0'ı yeniden alıyo stack sıfırlanmış gibi oluyo

exit syscall'ı artık bunu çağırıyo:

} else if (regs->rax == SYS_EXIT) {
    process_exit((int)regs->rdi);
}

print_signed exit kodları negatif olabildiği için yazdığım küçük bi yardımcı, başına - koyup kprint_dec çağırıyo

Ders 4: Hata yapan process'i öldürmek

page fault handler'a bakıyoruz hata user'dan mı geldi:

if ((frame->cs & 3) == 3) {
    kprint("PROC: page fault at ");
    kprint_hex(cr2);
    kprint(" error ");
    kprint_hex(error_code);
    kprint(", killing it\n");
    process_exit(-11);
}

interrupt frame'deki CS'nin alt 2 biti hata olduğu andaki ring. 3 ise user'ın hatası programı öldürüp sıradakine geçiyoruz. 0 ise kernel'in hatası eskisi gibi her şeyi durduruyoruz

cli gibi yasak komutlar general protection fault (vektör 13) atıyo. onun handler'ı yoktu yazdım aynı mantıkla:

__attribute__((interrupt))
static void gp_fault_handler(
    interrupt_frame_t *frame,
    uint64_t error_code
) {
    if ((frame->cs & 3) == 3) {
        kprint("PROC: general protection fault at rip ");
        kprint_hex(frame->rip);
        kprint(", killing it\n");
        process_exit(-13);
    }

    kprint("\nGeneral Protection Fault!\n");
    ...
}
idt_set_gate(13, (void *)gp_fault_handler);

-11 ve -13 rastgele değil vektör numaraları, linux'taki SIGSEGV de 11 :D

Ders 5: Birden fazla program

Makefile tek program derliyodu. her user/*.c için ayrı binary çıksın diye pattern rule yaptım:

USER_PROGS := hello crash cli
USER_BINS := $(patsubst %,$(BUILD)/user/%.bin,$(USER_PROGS))
$(BUILD)/user/%.elf: $(BUILD)/user/%.o $(BUILD)/user/libc.o user/linker.ld
	$(LD) -m elf_x86_64 -nostdlib -static -T user/linker.ld -o $@ $(BUILD)/user/libc.o $<

$(BUILD)/user/%.bin: $(BUILD)/user/%.elf
	objcopy -O binary $< $@

$(BUILD)/kernel/proc/programs.o: $(USER_BINS)

bi de .SECONDARY: ekledim yoksa make ara dosyaları (.elf .bin) build bitince siliyo ve her seferinde baştan derliyo

iki tane kötü program yazdım:

int main(void) {
    print("crash: reading kernel memory...\n");
    volatile char *kernel = (volatile char *)0xFFFFFFFF80000000;
    char c = *kernel;
    print("crash: I read the kernel lol\n");
    return c;
}
int main(void) {
    print("cli: turning off interrupts...\n");
    __asm__ volatile ("cli");
    print("cli: interrupts are off lol\n");
    return 0;
}

hepsini programs.c'de incbin ile gömüyorum (ELF yükleyici yazana kadar):

__asm__(
    ".section .rodata\n"
    ".global prog_hello, prog_hello_end\n"
    "prog_hello:\n"
    ".incbin \"build/user/hello.bin\"\n"
    "prog_hello_end:\n"
    ...
);

kernel.c'de en sonda:

kprint("PROC: free pages before ");
kprint_dec(pmm_get_free_pages());
kprint("\n");

process_create("crash", prog_crash, prog_crash_end - prog_crash);
process_create("cli", prog_cli, prog_cli_end - prog_cli);
process_create("hello", prog_hello, prog_hello_end - prog_hello);

process_start_next();

Ders 6: Test

önce oluşturulma:

alt text

ÜÇ PROCESS ÜÇ AYRI CR3 AHAHAHAH

üçü de kodunu 0x400000'da sanıyo ama code phys'e bak hepsi başka fiziksel sayfada. yani aynı sanal adres, üç farklı RAM. her process kendi dünyasında

ve çalıştırınca:

alt text

İKİSİ ÖLDÜ KERNEL YAŞIYOOOOO AHAHAHAHAHA

  • crash kernel'i okumaya çalıştı page fault error 0x5 (sayfa var + user'dan) → öldü -11. "I read the kernel lol" hiç yazılmadı
  • cli interrupt'ları kapatmaya çalıştı general protection → öldü -13. "interrupts are off lol" yazılmadı
  • hello sorunsuz "Hello from Userspace!" yazdı 0 ile çıktı
  • en sonda free pages 54120, başta da 54120. üç process'in bütün sayfaları ve tabloları geri verilmiş TEK SAYFA LEAK YOK

eskiden crash çalışsaydı bütün kernel dururdu hello hiç çalışamazdı

Son

Narc'ta artık:

  • process'ler var
  • her process'in kendi page table'ı var, kernel üst yarıda hepsinde ortak
  • process bitince bütün belleği geri veriliyo
  • hata yapan process ölüyo, diğerleri devam ediyo

ama hala process'ler sırayla çalışıyo. biri sonsuz döngüye girerse diğerleri hiç çalışamaz. sıradaki yazı scheduler