From 8901acf6aa4a36b5c30912346e00ef85ceea3b01 Mon Sep 17 00:00:00 2001
From: Joshua Phillips <jp.sittingduck@gmail.com>
Date: Thu, 5 Feb 2009 19:21:22 +0000
Subject: [PATCH] map_mem is working; reflexive mapping is disabled.

---
 kernel/kmain.c         |  1 -
 kernel/mm/allocation.c |  2 +-
 kernel/mm/kvmalloc.c   |  3 +--
 kernel/mm/paging.c     | 50 ++++++++++++++------------------------------------
 kernel/mm/paging.h     | 14 +++-----------
 5 files changed, 19 insertions(+), 51 deletions(-)

diff --git a/kernel/kmain.c b/kernel/kmain.c
index 3c0d3c5..25c6ef0 100644
--- a/kernel/kmain.c
+++ b/kernel/kmain.c
@@ -137,7 +137,6 @@ void kmain(uint32_t freemem_base, struct mb_info *mbi, unsigned int magic)
     read_multiboot_info(mbi);
     console_printf(&tty1, "Free memory: %d MiB\n", uldivru(pmem_get_size(), 1024 * 1024));
     mm_allocation_init();
-    set_up_reflexive_paging();
     create_init_pagedir(&init_pagedir);
     map_mem(&init_pagedir, 0xF0000000, 0x00000000, 4096, PTE_PRESENT | PTE_WRITABLE);
     TRACE("map_mem returned! Check the mapping!");
diff --git a/kernel/mm/allocation.c b/kernel/mm/allocation.c
index c83db46..60cbfa7 100644
--- a/kernel/mm/allocation.c
+++ b/kernel/mm/allocation.c
@@ -79,7 +79,7 @@ void mm_allocation_init(void)
 
     // create the virtual buddy allocator (for kernel address space)
 
-    n_chunks = (((intptr_t) PAGE_TAB) - KERNEL_VIRT_BASE) / PAGE_SIZE;
+    n_chunks = (0 - KERNEL_VIRT_BASE) / PAGE_SIZE;
     
     // calculate the size the buddy structures will take
     get_buddy_size(n_chunks, &height, &struct_size);
diff --git a/kernel/mm/kvmalloc.c b/kernel/mm/kvmalloc.c
index 9eae48f..b4dbffd 100644
--- a/kernel/mm/kvmalloc.c
+++ b/kernel/mm/kvmalloc.c
@@ -90,8 +90,7 @@ void kvfree(void *ptr, size_t n_allocated)
 
     for (i=0; i<n_allocated; i++){
         // fetch physical address and free it
-        // XXX: user higher-level functions
-        phys_addr = PAGE_TAB[virt_addr / PAGE_SIZE] & PTE_ADDRESS;
+        phys_addr = xlat_v2p(NULL, virt_addr);
         ppfree(phys_addr, 1);
         // next page
         virt_addr += PAGE_SIZE;
diff --git a/kernel/mm/paging.c b/kernel/mm/paging.c
index 83e4cac..1930499 100644
--- a/kernel/mm/paging.c
+++ b/kernel/mm/paging.c
@@ -40,25 +40,10 @@ static struct pagedir *pagedir_first = NULL, *pagedir_last = NULL;
 
 static struct vpde kvpd[PDE_N_KERNEL];
 
-void set_up_reflexive_paging(void)
-{
-    intptr_t pagedir_phys;
-    pde_t *pagedir_virt;
-
-    // Get the physical address of the page directory.
-    // The CPU knows where this is ;)
-    pagedir_phys = get_cr3();
-
-    // Since this was the initial page directory, it was
-    // allocated just after the kernel and modules, so we
-    // can easily find the virtual address for it.
-    pagedir_virt = (pde_t *) ((pagedir_phys - KERNEL_PHYS_BASE) + KERNEL_VIRT_BASE);
-
-    // Now we can enable the reflexive mapping
-    pagedir_virt[PDE_N - 1] = (pagedir_phys & PDE_ADDRESS) | (PDE_PRESENT | PDE_WRITABLE);
-
-    // No need to flush TLB now, because nothing was mapped there before.
-}
+// This points to any page directory. Since the kernel portions of each
+// page directory are kept synchronized, this can point to any valid
+// page directory.
+static pde_t *kernel_pagedir;
 
 void create_init_pagedir(struct pagedir *ipd)
 {
@@ -86,6 +71,8 @@ void create_init_pagedir(struct pagedir *ipd)
                       + KERNEL_VIRT_BASE) - KERNEL_PHYS_BASE
                     ) / PAGE_SIZE;
     TRACE("kernel page table is at %.8X virtual", kvpd[0].vaddr * PAGE_SIZE);
+
+    kernel_pagedir = ipd->virt_addr;
 }
 
 int pagedir_create(struct pagedir *page_directory)
@@ -108,11 +95,8 @@ int pagedir_create(struct pagedir *page_directory)
     // page directory. Since the kernel part is kept consistent, it doesn't
     // really matter where we get this from.
     memcpy(page_directory->virt_addr + PDE_KERNEL_FIRST,
-      PAGE_DIR + PDE_KERNEL_FIRST, PDE_N_KERNEL * sizeof(pde_t));
+      kernel_pagedir + PDE_KERNEL_FIRST, PDE_N_KERNEL * sizeof(pde_t));
     
-    // set up reflexive mapping for this page directory (XXX: later, we won't need this!)
-    page_directory->virt_addr[PDE_N - 1] = page_directory->phys_addr | PDE_PRESENT | PDE_WRITABLE;
-
     // add this page directory to our list, so the kernel part of it gets update
     // in the future.
     page_directory->prev = NULL;
@@ -150,7 +134,7 @@ static inline bool pt_exists(const struct pagedir *restrict pd, int n)
 {
     if (n >= 768){
         ///// kernel region /////
-        return (PAGE_DIR[n] & PDE_PRESENT) == PDE_PRESENT;
+        return kvpd[n - PDE_KERNEL_FIRST].vaddr != 0;
     } else {
         ///// user region /////
         return pd->vpd[n].vaddr != 0;
@@ -311,19 +295,13 @@ int map_mem(struct pagedir *pd, intptr_t physical, intptr_t virtual, size_t n_pa
     return 0;
 }
 
-static struct pagedir init_pagedir;
-
-void paging_init(void)
+intptr_t xlat_v2p(struct pagedir *pd, intptr_t virtual)
 {
-    struct pagedir *pagedir;
-    pagedir = &init_pagedir;
-    pagedir->phys_addr = get_cr3();
-    pagedir->virt_addr = (pde_t *) (
-      (pagedir->phys_addr - KERNEL_PHYS_BASE) + KERNEL_VIRT_BASE);
-    // make sure no other paging functions have been called
-    // before paging_init
-    assert(pagedir_first == NULL && pagedir_last == NULL);
-    pagedir_first = pagedir_last = pagedir;
+    pte_t *pte = get_pte(pd, virtual);
+    if (!pte){
+        return 0;
+    }
+    return *pte & PTE_ADDRESS;
 }
 
 void pagedir_switch(struct pagedir *new_pagedir)
diff --git a/kernel/mm/paging.h b/kernel/mm/paging.h
index 5fa664d..4a9d35d 100644
--- a/kernel/mm/paging.h
+++ b/kernel/mm/paging.h
@@ -63,12 +63,6 @@ typedef uint32_t pte_t, pde_t;
 #define PDE_GLOBAL (1 << 8)
 #define PDE_ADDRESS 0xFFFFF000
 
-// get address of n-th current page table
-#define PAGE_TAB ((pte_t *) 0xFFC00000)
-
-// get address of current page directory
-#define PAGE_DIR ((pde_t *) 0xFFFFF000)
-
 // XXX: these values are set here, but if the
 // kernel base address changes, these will
 // change too!
@@ -91,11 +85,6 @@ struct pagedir {
     struct vpde vpd[768];
 };
 
-// Turn on reflexive paging, i.e. the page directory is treated as a page table
-// and we can gain access to all our current page tables and the page directory
-// at 0xFFC00000 - 0xFFFFFFFF pretty much for free.
-void set_up_reflexive_paging(void);
-
 // functions to get/set cr2 and cr3
 // cr2 contains the virtual address of the last page fault.
 // cr3 contains the address of the page directory.
@@ -133,6 +122,9 @@ int pagedir_create(struct pagedir *pagedir);
 // Destroy a page directory
 void pagedir_destroy(struct pagedir *pagedir);
 
+// Return the physical address pointed to by 'virtual'
+intptr_t xlat_v2p(struct pagedir *pd, intptr_t virtual);
+
 // Alter the current memory map: map a physical region to the
 // current virtual address space.
 // Flags are PTE_* constants
-- 
2.11.4.GIT