aboutsummaryrefslogtreecommitdiff
path: root/kernel/mm
diff options
context:
space:
mode:
Diffstat (limited to 'kernel/mm')
-rw-r--r--kernel/mm/memory_map.cc9
-rw-r--r--kernel/mm/physical_mm/physical_mm.cc48
-rw-r--r--kernel/mm/virtual_mm/virtual_mm.cc46
3 files changed, 54 insertions, 49 deletions
diff --git a/kernel/mm/memory_map.cc b/kernel/mm/memory_map.cc
index 0d224ac..884f92f 100644
--- a/kernel/mm/memory_map.cc
+++ b/kernel/mm/memory_map.cc
@@ -26,7 +26,7 @@
namespace MemoryMap
{
-static free_memory_regions_t free_memory_regions = { 0 };
+static free_memory_regions_t l_free_memory_regions = { 0 };
ALWAYS_INLINE static char *
fetch_type(multiboot_memory_map_t *mmap)
@@ -76,8 +76,9 @@ load(multiboot_info_t *multiboot_info)
total_mem += mmap->len_low;
if (mmap->type == MULTIBOOT_MEMORY_AVAILABLE) {
- free_memory_regions.region_list[free_memory_regions.n_regions] = mmap;
- free_memory_regions.n_regions++;
+ l_free_memory_regions.region_list[l_free_memory_regions.n_regions]
+ = mmap;
+ l_free_memory_regions.n_regions++;
total_available_mem += mmap->len_low;
}
@@ -96,7 +97,7 @@ load(multiboot_info_t *multiboot_info)
free_memory_regions_t *
get_free_regions(void)
{
- return &free_memory_regions;
+ return &l_free_memory_regions;
}
}
diff --git a/kernel/mm/physical_mm/physical_mm.cc b/kernel/mm/physical_mm/physical_mm.cc
index a4cd894..fb0dd76 100644
--- a/kernel/mm/physical_mm/physical_mm.cc
+++ b/kernel/mm/physical_mm/physical_mm.cc
@@ -36,16 +36,16 @@ namespace PhysicalMM
extern "C" uint32_t kernel_start;
extern "C" uint32_t kernel_end;
-uint32_t block_count = 0;
-uint32_t total_free_blocks = 0;
-uint32_t memory_map[MAX_BLOCKS / BITMAP_ENTRY_SIZE];
+uint32_t l_block_count = 0;
+uint32_t l_total_free_blocks = 0;
+uint32_t l_memory_map[MAX_BLOCKS / BITMAP_ENTRY_SIZE];
-Spinlock lock;
+Spinlock l_lock;
ALWAYS_INLINE static void
log_memory_map(free_memory_regions_t *free_memory_regions)
{
- printk("\nphysical_mm", "memory_map is at 0x%x", memory_map);
+ printk("\nphysical_mm", "memory_map is at 0x%x", l_memory_map);
printk("\nphysical_mm", "Free Memory Regions:");
for (int i = 0; i < free_memory_regions->n_regions; i++)
printk("physical_mm",
@@ -69,12 +69,12 @@ initialize_region(uint32_t start, uint32_t length)
uint32_t n_blocks = length / BLOCK_SIZE;
for (; n_blocks > 0; n_blocks--)
- if (test_bit(bit, memory_map))
- set_usable(bit++, &total_free_blocks, memory_map);
+ if (test_bit(bit, l_memory_map))
+ set_usable(bit++, &l_total_free_blocks, l_memory_map);
/* First block is always used (first 64KiB) */
- if (!test_bit(0, memory_map))
- set_used(0, &total_free_blocks, memory_map);
+ if (!test_bit(0, l_memory_map))
+ set_used(0, &l_total_free_blocks, l_memory_map);
}
ALWAYS_INLINE static void
@@ -87,7 +87,7 @@ deinitialize_region(uint32_t start, uint32_t length)
n_blocks++;
for (; n_blocks > 0; n_blocks--)
- set_used(bit++, &total_free_blocks, memory_map);
+ set_used(bit++, &l_total_free_blocks, l_memory_map);
}
void
@@ -96,13 +96,13 @@ initialize(void)
free_memory_regions_t *free_memory_regions = MemoryMap::get_free_regions();
log_memory_map(free_memory_regions);
- lock.acquire();
+ l_lock.acquire();
/* All blocks are initially used */
/* TODO: Move this block to a place after block_count is set. This is why
* using block_count instead of MAX_BLOCKS wasn't working. */
for (uint32_t i = 0; i < MAX_BLOCKS / BITMAP_ENTRY_SIZE; i++)
- memory_map[i] = 0xffffffff;
+ l_memory_map[i] = 0xffffffff;
for (int i = 0; i < free_memory_regions->n_regions; i++) {
multiboot_memory_map_t *region = free_memory_regions->region_list[i];
@@ -115,18 +115,18 @@ initialize(void)
/* Deinitialize first 4MiB */
deinitialize_region(0, 4 * MiB);
- lock.release();
+ l_lock.release();
/* Manually loop through and calculate the number of free blocks. */
for (uint32_t i = 0; i < MAX_BLOCKS / BITMAP_ENTRY_SIZE; i++)
/* At least one block in the entry isn't in use */
- if (memory_map[i] != 0xffffffff)
+ if (l_memory_map[i] != 0xffffffff)
/* Test each bit to see if it's zero */
for (uint32_t j = 0; j < BITMAP_ENTRY_SIZE; j++)
- if (!test_bit(i * BITMAP_ENTRY_SIZE + j, memory_map))
- total_free_blocks++;
+ if (!test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
+ l_total_free_blocks++;
- printk("physical_mm", "Total free blocks: 0x%x", total_free_blocks);
+ printk("physical_mm", "Total free blocks: 0x%x", l_total_free_blocks);
}
uint32_t
@@ -135,10 +135,10 @@ find_free_block(void)
/* TODO: Why doesn't using block_count instead of MAX_BLOCKS work? */
for (uint32_t i = 0; i < MAX_BLOCKS / BITMAP_ENTRY_SIZE; i++)
/* At least one block in the entry isn't in use */
- if (memory_map[i] != 0xffffffff)
+ if (l_memory_map[i] != 0xffffffff)
/* Test each bit to see if it's zero */
for (uint32_t j = 0; j < BITMAP_ENTRY_SIZE; j++)
- if (!test_bit(i * BITMAP_ENTRY_SIZE + j, memory_map))
+ if (!test_bit(i * BITMAP_ENTRY_SIZE + j, l_memory_map))
return i * BITMAP_ENTRY_SIZE + j;
/* Shouldn't be reached, since we're keeping track of the number of free
@@ -150,17 +150,17 @@ find_free_block(void)
void *
allocate_block(void)
{
- if (total_free_blocks == 0) {
+ if (l_total_free_blocks == 0) {
printk("physical_mm", "No more free blocks!");
return NULL;
}
- lock.acquire();
+ l_lock.acquire();
uint32_t block = find_free_block();
- set_used(block, &total_free_blocks, memory_map);
+ set_used(block, &l_total_free_blocks, l_memory_map);
- lock.release();
+ l_lock.release();
uint32_t physical_address = block * BLOCK_SIZE;
return (void *) physical_address;
@@ -170,7 +170,7 @@ void
free_block(void *physical_address)
{
uint32_t block = ((uint32_t) physical_address) / BLOCK_SIZE;
- set_usable(block, &total_free_blocks, memory_map);
+ set_usable(block, &l_total_free_blocks, l_memory_map);
}
}
diff --git a/kernel/mm/virtual_mm/virtual_mm.cc b/kernel/mm/virtual_mm/virtual_mm.cc
index 041459f..30dabbc 100644
--- a/kernel/mm/virtual_mm/virtual_mm.cc
+++ b/kernel/mm/virtual_mm/virtual_mm.cc
@@ -30,14 +30,14 @@ namespace VirtualMM
extern uint32_t kernel_start;
extern uint32_t kernel_end;
-uint32_t *current_page_directory = 0;
+uint32_t *l_current_page_directory = 0;
/* Kernel's page directory */
-uint32_t page_directory[1024] ALIGNED(4096);
+uint32_t l_page_directory[1024] ALIGNED(4096);
/* Page table for the first 4 MiB */
-uint32_t fourMiB_page_table[1024] ALIGNED(4096);
+uint32_t l_fourMiB_page_table[1024] ALIGNED(4096);
/* Page table for the next 4 MiB */
-uint32_t eightMiB_page_table[1024] ALIGNED(4096);
+uint32_t l_eightMiB_page_table[1024] ALIGNED(4096);
ALWAYS_INLINE void
load_page_directory(uint32_t *page_directory)
@@ -50,7 +50,7 @@ switch_page_directory(uint32_t *page_directory)
{
if (!page_directory)
return false;
- current_page_directory = page_directory;
+ l_current_page_directory = page_directory;
load_page_directory(page_directory);
return true;
@@ -70,31 +70,31 @@ initialize(void)
{
/* Zero out the page tables and directories */
for (uint32_t i = 0; i < 1024; i++) {
- fourMiB_page_table[i] = 0;
- eightMiB_page_table[i] = 0;
- page_directory[i] = 0;
+ l_fourMiB_page_table[i] = 0;
+ l_eightMiB_page_table[i] = 0;
+ l_page_directory[i] = 0;
}
/* Identity map the first 4MiB, excluding the 4th MiB
* (maps 4KiB 1024 times) */
for (uint32_t i = 0; i < 1024; i++)
- fourMiB_page_table[i] = PTE_FRAME(i) | PTE_PRESENT(1) | PTE_WRITABLE(1);
+ l_fourMiB_page_table[i] = PTE_FRAME(i) | PTE_PRESENT(1) | PTE_WRITABLE(1);
/* Identity map the next 4MiB */
for (uint32_t i = 0; i < 1024; i++)
- eightMiB_page_table[i]
+ l_eightMiB_page_table[i]
= PTE_FRAME(i + 1024) | PTE_PRESENT(1) | PTE_WRITABLE(1);
/* Set up the page directory entries */
- uint32_t *fourMiB_pd_entry = &page_directory[0];
- *fourMiB_pd_entry = PDE_FRAME((uint32_t) fourMiB_page_table) | PDE_PRESENT(1)
- | PDE_WRITABLE(1);
+ uint32_t *fourMiB_pd_entry = &l_page_directory[0];
+ *fourMiB_pd_entry = PDE_FRAME((uint32_t) l_fourMiB_page_table)
+ | PDE_PRESENT(1) | PDE_WRITABLE(1);
- uint32_t *eightMiB_pd_entry = &page_directory[1];
- *eightMiB_pd_entry = PDE_FRAME((uint32_t) eightMiB_page_table)
+ uint32_t *eightMiB_pd_entry = &l_page_directory[1];
+ *eightMiB_pd_entry = PDE_FRAME((uint32_t) l_eightMiB_page_table)
| PDE_PRESENT(1) | PDE_WRITABLE(1);
- switch_page_directory(page_directory);
+ switch_page_directory(l_page_directory);
enable_paging();
}
@@ -110,7 +110,9 @@ make_table(uint32_t *pd_entry)
printk("virtual_mm",
"Using our hard coded table; this should happen only once.");
} else
- table = (uint32_t *) LibAlloc::kmalloc(sizeof(uint32_t) * 1024);
+ /* TODO: Uncomment this */
+ // table = (uint32_t *) LibAlloc::kmalloc(sizeof(uint32_t) * 1024);
+ ;
for (uint32_t i = 0; i < 1024; i++)
table[i] = 0x0;
@@ -135,7 +137,8 @@ get_or_make_table(uint32_t *pd_entry)
void
map_page(void *physical_address, void *virtual_address)
{
- uint32_t *pd_entry = &current_page_directory[GET_PD_INDEX(virtual_address)];
+ uint32_t *pd_entry
+ = &l_current_page_directory[GET_PD_INDEX(virtual_address)];
uint32_t *table = get_or_make_table(pd_entry);
uint32_t *pt_entry = &table[GET_PT_INDEX(virtual_address)];
@@ -151,7 +154,8 @@ map_page(void *physical_address, void *virtual_address)
void
unmap_page(void *virtual_address)
{
- uint32_t *pd_entry = &current_page_directory[GET_PD_INDEX(virtual_address)];
+ uint32_t *pd_entry
+ = &l_current_page_directory[GET_PD_INDEX(virtual_address)];
uint32_t *table = 0;
/* If the pd_entry isn't present, return */
@@ -172,7 +176,7 @@ find_free_addresses(uint32_t n)
* 8MiB. */
for (uint32_t pd_index = 2; pd_index < PAGE_DIRECTORY_SIZE; pd_index++) {
uint32_t starting_pd_index = pd_index;
- uint32_t *pd_entry = &current_page_directory[pd_index];
+ uint32_t *pd_entry = &l_current_page_directory[pd_index];
uint32_t *table = 0;
bool table_is_present = PDE_IS_PRESENT(pd_entry);
@@ -195,7 +199,7 @@ find_free_addresses(uint32_t n)
if (pd_index == PAGE_DIRECTORY_SIZE)
return 0; /* Ran out of pd_entries */
- pd_entry = &current_page_directory[pd_index];
+ pd_entry = &l_current_page_directory[pd_index];
table_is_present = PDE_IS_PRESENT(pd_entry);
pt_index = 0;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-22 16:04:45 +0000