Use the new cpu.h functions in the new memory manager.
authorcoderain <coderain@sdf.org>
Sat, 14 Jul 2018 22:04:18 +0000 (00:04 +0200)
committercoderain <coderain@sdf.org>
Sat, 14 Jul 2018 22:04:18 +0000 (00:04 +0200)
kernel/include/new_memory.h
kernel/src/memory/map.c
kernel/src/memory/physical.c

index dabfe1be4773513b4b74d92895e7851a6588376f..d379b6aefb8a80160505fd6b3cb35c915e8d1622 100644 (file)
@@ -70,11 +70,6 @@ typedef struct
     page_num_t count;
 } area_t;
 
-static inline void memory_invalidate_tlb(void *addr)
-{
-    asm volatile ("invlpg %0" :: "m"(*(dword_t*)addr));
-}
-
 extern page_table_t memory_default_table;
 
 page_t *memory_acquire_page(byte_t min_bits, byte_t max_bits, size_t alignment);
index c56d5dae4b7811bdd34688fb29aa7ab1972eb151..737c28b1885d3de0dfc5c358ea902c2424e4a5fe 100644 (file)
@@ -18,6 +18,7 @@
  */
 
 #include <new_memory.h>
+#include <cpu.h>
 
 #define PAGE_PRESENT      (1ULL << 0)
 #define PAGE_WRITABLE     (1ULL << 1)
@@ -91,24 +92,6 @@ static inline bool_t cmpxchg_pte(page_table_entry_t *pte, page_table_entry_t old
     }
 }
 
-static inline uintptr_t read_cr3(void)
-{
-    uintptr_t value;
-    asm volatile ("movl %%cr3, %0"
-                  : "=r"(value) /* output */
-                  : /* input */
-                  : /* clobber */);
-    return value;
-}
-
-static inline void write_cr3(uintptr_t value)
-{
-    asm volatile ("movl %0, %%cr3"
-                  : /* output */
-                  :"r"(value) /* input */
-                  : /* clobber */);
-}
-
 static page_table_entry_t *memory_get_table_entry(page_table_t table, void *address, bool_t hypothetical)
 {
     uintptr_t numeric_address = (uintptr_t)address;
@@ -170,7 +153,7 @@ sysret_t memory_map_page(page_table_t table, page_t *page, void *address, memory
 
     if (cmpxchg_pte(pte, 0, page->address | to_cpu_specific_flags(access_flags)))
     {
-        memory_invalidate_tlb(address);
+        cpu_invalidate_tlb(address);
         return ERR_SUCCESS;
     }
     else
@@ -201,7 +184,7 @@ sysret_t memory_adjust_page_flags(page_table_t table, void *address, memory_flag
     page_table_entry_t new_entry = (old_entry & PHYSICAL_ADDRESS_MASK) | to_cpu_specific_flags(access_flags);
     if (!cmpxchg_pte(pte, old_entry, new_entry)) return ERR_BUSY;
 
-    memory_invalidate_tlb(address);
+    cpu_invalidate_tlb(address);
     return ERR_SUCCESS;
 }
 
@@ -215,7 +198,7 @@ sysret_t memory_unmap_page(page_table_t table, void *address)
     if (page == NULL) return ERR_NOTFOUND;
     if (!cmpxchg_pte(pte, entry, 0)) return ERR_NOTFOUND;
 
-    memory_invalidate_tlb(address);
+    cpu_invalidate_tlb(address);
     __atomic_sub_fetch(&page->map_count, 1, __ATOMIC_RELEASE);
 
     return ERR_SUCCESS;
@@ -224,7 +207,7 @@ sysret_t memory_unmap_page(page_table_t table, void *address)
 sysret_t memory_load_default_table(page_t *new_default_table)
 {
     if (new_default_table->status < PAGE_STATUS_ALLOCATED) return ERR_INVALID;
-    write_cr3(new_default_table->address);
+    cpu_write_page_table_register(new_default_table->address);
     return ERR_SUCCESS;
 }
 
@@ -239,5 +222,5 @@ void memory_init_mapping_hack(void)
         self_referencing_pte = memory_get_table_entry(boot_table, self_referencing_pte, TRUE);
     }
 
-    cmpxchg_pte(self_referencing_pte, 0, PAGE_ALIGN(read_cr3()) | PAGE_PRESENT | PAGE_WRITABLE);
+    cmpxchg_pte(self_referencing_pte, 0, PAGE_ALIGN(cpu_read_page_table_register()) | PAGE_PRESENT | PAGE_WRITABLE);
 }
index 76d5d29dd4a4dce7073f901e6d6bcb32a70e1cf8..9c4fa3c698049cae47b5202417473f80f8cfba94 100644 (file)
@@ -20,6 +20,7 @@
 #include <new_memory.h>
 #include <log.h>
 #include <exception.h>
+#include <cpu.h>
 
 typedef struct
 {
@@ -30,13 +31,12 @@ typedef struct
     lock_t lock;
 } page_list_t;
 
-static byte_t max_usable_phys_addr_bits = MAX_PHYS_ADDR_BITS;
 static page_list_t page_list[MAX_PHYS_ADDR_BITS - MIN_PHYS_ADDR_BITS + 1];
 
 static inline byte_t count_bits(physical_t address)
 {
     byte_t number = 64 - __builtin_clzll(address);
-    ASSERT(number <= max_usable_phys_addr_bits);
+    ASSERT(number <= cpu_max_physical_bits);
     return number >= MIN_PHYS_ADDR_BITS ? number : MIN_PHYS_ADDR_BITS;
 }
 
@@ -47,7 +47,7 @@ page_t *memory_acquire_page(byte_t min_bits, byte_t max_bits, size_t alignment)
     ASSERT(alignment != 0);
 
     if (min_bits < MIN_PHYS_ADDR_BITS) min_bits = MIN_PHYS_ADDR_BITS;
-    if (max_bits > max_usable_phys_addr_bits) max_bits = max_usable_phys_addr_bits;
+    if (max_bits > cpu_max_physical_bits) max_bits = cpu_max_physical_bits;
 
     byte_t bits;
     for (bits = max_bits; bits >= min_bits && result == NULL; bits--)
@@ -81,7 +81,7 @@ void memory_acquire_area(byte_t min_bits, byte_t max_bits, size_t size, size_t a
     ASSERT(min_bits <= max_bits);
 
     if (min_bits < MIN_PHYS_ADDR_BITS) min_bits = MIN_PHYS_ADDR_BITS;
-    if (max_bits > max_usable_phys_addr_bits) max_bits = max_usable_phys_addr_bits;
+    if (max_bits > cpu_max_physical_bits) max_bits = cpu_max_physical_bits;
 
     if (size == 1)
     {
@@ -150,7 +150,7 @@ void memory_acquire_area(byte_t min_bits, byte_t max_bits, size_t size, size_t a
 void memory_release_page(page_t *page)
 {
     byte_t bits = count_bits(page->address);
-    ASSERT(bits >= MIN_PHYS_ADDR_BITS && bits <= max_usable_phys_addr_bits);
+    ASSERT(bits >= MIN_PHYS_ADDR_BITS && bits <= cpu_max_physical_bits);
 
     page_list_t *list = &page_list[bits - MIN_PHYS_ADDR_BITS];
     lock_acquire_smart(&list->lock);
@@ -171,7 +171,7 @@ void memory_release_area(area_t *area)
 page_t *memory_find_page_by_address(physical_t address)
 {
     byte_t bits = count_bits(address);
-    ASSERT(bits >= MIN_PHYS_ADDR_BITS && bits <= max_usable_phys_addr_bits);
+    ASSERT(bits >= MIN_PHYS_ADDR_BITS && bits <= cpu_max_physical_bits);
 
     page_list_t *list = &page_list[bits - MIN_PHYS_ADDR_BITS];
     page_t *page = &list->all[PAGE_NUMBER(address) - list->first_page_num];
@@ -267,13 +267,13 @@ void memory_abandon_physical_region(physical_t address, qword_t size)
 
 static void memory_init_page_lists(void)
 {
-    max_usable_phys_addr_bits = 32; // TODO: This should be detected.
-
     page_num_t pages_covered = 0;
     page_t *master_page_list = (page_t*)MEMORY_METADATA_BASE;
 
+    ASSERT(cpu_max_physical_bits <= MAX_PHYS_ADDR_BITS);
+
     byte_t bits;
-    for (bits = MIN_PHYS_ADDR_BITS; bits <= max_usable_phys_addr_bits; bits++)
+    for (bits = MIN_PHYS_ADDR_BITS; bits <= cpu_max_physical_bits; bits++)
     {
         page_list_t *list = &page_list[bits - MIN_PHYS_ADDR_BITS];