『MOS』 Boot And Memory Management

1
2
3
4
5
6
7
8
void mips_init() {
    mips_detect_memory();
    mips_vm_init();
    page_init();
    // ...
    trap_init();
    // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define PADDR(kva)                                                      \
    ({                                                                  \
        u_long a = (u_long)(kva);                                       \
        if (a < ULIM) /* ULIM = 0x80000000 */                           \
            panic("PADDR called with invalid kva %08lx", a);            \
        a - ULIM;                                                       \
    })
#define KADDR(pa)                                                       \
    ({                                                                  \
        u_long ppn = PPN(pa); /* PPN(a) <==> (((u_long)(a)) >> 12) */   \
        if (ppn >= npage) /* npage = 0x4000 */                          \
            panic("KADDR called with invalid pa %08lx", (u_long)(pa));  \
        (pa) + ULIM;                                                    \
    })

1
static struct Page_list page_free_list;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
extern struct Page *pages; // initialized in `mips_vm_init`

// convert `struct Page *` to physical page number
static inline u_long page2ppn(struct Page *page_ptr) {
    return page_ptr - pages;
}
// convert `struct Page *` to physical address
static inline u_long page2pa(struct Page *page_ptr) {
    return page2ppn(page_ptr) << PGSHIFT; // PGSHIFT <==> 12
}
// convert physical address to `struct Page *`
static inline struct Page *pa2page(u_long physical_addr) {
    if (PPN(physical_addr) >= npage)
        panic("pa2page called with invalid pa: %x", physical_addr);
    return &pages[PPN(physical_addr)];
}
// convert `struct Page *` to kernel virtual address
static inline u_long page2kva(struct Page *page_ptr) {
    return KADDR(page2pa(page_ptr));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int page_alloc(struct Page **dbl_ptr) {
    struct Page *tmp;
    if (/* I. `page_free_list` is empty */) return -E_NO_MEM;
    // negative return value indicates exception.

    tmp = /* II. the first item in `page_free_list` */;

    /* III. remove this page from the list */;

    bzero(/* IV. kernel virtual address of this page */, BY2PG);

    *dbl_ptr = tmp;
    return 0;
    // zero indicates success.
}

1
2
3
4
5
6
7
8
void page_free(struct Page *page_ptr) {
    if (page_ptr->pp_ref == 0) {
        /* I. insert this item into `page_free_list` */
        return;
    } else if (page_ptr->pp_ref > 0) return; // in use

    panic("pp_ref is less then 0");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
static Pte *boot_pgdir_walk(Pde *pgdir, u_long va, int create) {
    Pde *pgdir_entry = pgdir + PDX(va); // I

    // check whether the page table exists
    if ((*pgdir_entry & PTE_V) == 0) {
        if (create) {
            /**
             * use `alloc` to allocate a page for the page table
             * set permission: `PTE_V | PTE_R`
             * hint: `PTE_V` <==> valid ; `PTE_R` <==> writable
             */
        } else return 0; // exception
    }

    // return the address of entry of page table
    return ((Pte *)(/* II. Kernel Virtual Address of PTBase */)) + PTX(va);
}
void boot_map_segment(Pde *pgdir,
                      u_long va, u_long size,
                      u_long pa, int perm) {
    int i;
    Pte *pgtable_entry;
    for (i = 0, size = ROUND(size, BY2PG); i < size; i += BY2PG) {
        /* Step 1. use `boot_pgdir_walk` to "walk" the page directory */
        pgtable_entry = boot_pgdir_walk(
            pgdir,
            va + i,
            1 /* create if entry of page directory not exists yet */
        );
        /* Step 2. fill in the page table */
        *pgtable_entry = (/* III. Physical Frame Address of `pa + i` */)
                         | perm | PTE_V;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
int pgdir_walk(Pde *pgdir, u_long va, int create, Pte **ppte) {
    Pde *pgdir_entry = pgdir + PDX(va); // I
    struct Page *page;
    int ret;
    
    // check whether the page table exists
    if ((*pgdir_entry & PTE_V) == 0) {
        if (create) {
            if ((ret = page_alloc(&page)) < 0) return ret;
            *pgdir_entry = (/* Physical Address of `page` */)
                           | PTE_V | PTE_R;
        } else {
            *ppte = 0;
            return 0;
        }
    }
    *ppte = ((Pte *)(/* II. Kernel Virtual Address of PTBase */)) + PTX(va);
    return 0;
}
int page_insert(Pde *pgdir, struct Page *pp, u_long va, u_int perm) {
    Pte *pgtable_entry;
    int ret;

    perm = perm | PTE_V;

    // Step 0. check whether `va` is already mapping to `pa`
    pgdir_walk(pgdir, va, 0 /* for check */, &pgtable_entry);
    if (pgtable_entry != 0 && (*pgtable_entry & PTE_V) != 0) {
        // check whether `va` is mapping to another physical frame
        if (pa2page(*pgtable_entry) != pp) {
            page_remove(pgdir, va); // unmap it!
        } else {
            tlb_invalidate(pgdir, va);              // <~~
            *pgtable_entry = page2pa(pp) | perm;    // update the permission
            return 0;
        }
    }
    tlb_invalidate(pgdir, va);                      // <~~
    /* Step 1. use `pgdir_walk` to "walk" the page directory */
    if ((ret = pgdir_walk(pgdir, va, 1, &pgtable_entry)) < 0)
        return ret; // exception
    /* Step 2. fill in the page table */
    *pgtable_entry = (/* III. Physical Frame Address of `pp` */) | perm;
    pp->pp_ref++;
    return 0;
}

1
2
3
4
5
6
void tlb_invalidate(Pde *pgdir /* unused? */, u_long va) {
    if (curenv) // a process is running
        tlb_out(PTE_ADDR(va) | GET_ENV_ASID(curenv->env_id));
    else
        tlb_out(PTE_ADDR(va));
}