I try to implement my own OS, and now I try to implement paging mechanism.
I created a page directory, and created identity mapping of the kernel code.
However, after storing the physical address of the first page table and enabling paging, my code seems lost - meaning, the virtual address not mapped to a physical address, or mapped to a wrong one.
I can see this behaviour in GDB: my code opcodes turn to add [eax], al.
My structs are:
#define MAX_PAGES_PER_TABLE 1024
#define MAX_TABLES_PER_DIR 1024
typedef struct {
uint32_t present : 1; // Page present in memory
uint32_t rw : 1; // Read-only if clear, readwrite if set
uint32_t user : 1; // Supervisor level only if clear
uint32_t accessed : 1; // Has the page been accessed since last refresh?
uint32_t dirty : 1; // Has the page been written to since last refresh?
uint32_t unused : 7; // Amalgamation of unused and reserved bits
uint32_t frame : 20; // Frame address (shifted right 12 bits)
} page_t;
typedef struct {
page_t pages[MAX_PAGES_PER_TABLE];
} page_table_t;
typedef struct {
page_table_t* page_tables[MAX_TABLES_PER_DIR]; // Array of pointers to pagetables.
/*
Array of pointers to the pagetables above, but gives their *physical*
location, for loading into the CR3 register.
*/
uint32_t page_tables_physical[MAX_TABLES_PER_DIR];
/*
The physical address of page_tables_physical. This comes into play
when we get our kernel heap allocated and the directory
may be in a different location in virtual memory.
*/
uint32_t physical_address;
} page_directory_t;
Here is my enabling paging code:
page_directory_t* current_page_dir;
void switch_page_directory(page_directory_t* new_page_directory)
{
current_page_dir = new_page_directory;
// let the cpu know the physical address of the page tables
asm volatile("mov %0, %%cr3" : : "r"(&new_page_directory->page_tables_physical));
uint32_t cr0;
asm volatile("mov %%cr0, %0" : "=r"(cr0));
cr0 |= 0x80000000; // set the PG flag of cr0 - enable paging
asm volatile("mov %0, %%cr0" : : "r" (cr0));
}
I double checked that the page directory looks ok, but maybe I am wrong so here is the identity mapping code:
void alloc_frame(page_t *page, int is_kernel, int is_writeable)
{
if (page->frame != 0) {
// there is already a frame associated with the page
return;
}
uint32_t first_free_frame_address = first_not_set(frames);
if (first_free_frame_address == frames.len + 1) {
panic("no free pages");
}
set_bit(first_free_frame_address, frames);
page->frame = first_free_frame_address * ALIGNMENT;
page->present = 1;
page->rw = is_writeable ? 1: 0;
page->user = is_kernel ? 0 : 1;
}
page_t* get_page(uint32_t address, int create, page_directory_t* dir)
{
// when dividing the address by alignment, the index of the page is received
uint32_t address_index = address / ALIGNMENT;
// according to the index of the address,
// the index of the table, and the index of the page in the table are calculated
uint32_t table_index = address_index / MAX_PAGES_PER_TABLE;
uint32_t page_index = address_index % MAX_PAGES_PER_TABLE;
if (dir->page_tables[table_index]) {
// page table exists
return &dir->page_tables[table_index]->pages[page_index];
} else if (create) {
// page table doesn't exist - creating it
uint32_t physical_address;
dir->page_tables[table_index] = (page_table_t*) kmalloc_internal(sizeof(page_table_t), 1, &physical_address);
// set a first entry in the table
memory_set((uint8_t*)dir->page_tables[table_index], 0, ALIGNMENT);
// give the first page, the attributes: Present, Read/Write, Kernel page
physical_address |= 0x3;
// save the physical address of the table
dir->page_tables_physical[table_index] = physical_address;
return &dir->page_tables[table_index]->pages[page_index];
} else {
//page table doesn't exist - page cannot be retrieved
return 0;
}
}
void initialize_paging()
{
initialize_frames();
page_directory_t* page_dir = (page_directory_t*) kmalloc(sizeof(page_directory_t));
memory_set((uint8_t*) page_dir, 0, sizeof(page_directory_t));
// set the physical addresses of the page tables to 0 with attributes:
// kernel tables, rw, not present
int j;
uint8_t* tmp = (uint8_t*) page_dir->page_tables_physical;
for (j = 0; j < 1024; j++) {
memory_set(tmp, 2, 1);
tmp++;
memory_set(tmp, 0, 3);
tmp += 3;
}
current_page_dir = page_dir;
// We need to identity map (phys addr = virt addr) from
// 0x0 to the end of used memory, so we can access this
// transparently, as if paging wasn't enabled.
// NOTE that we use a while loop here deliberately.
// inside the loop body we actually change free_physical_address
// by calling kmalloc(). A while loop causes this to be
// computed on-the-fly rather than once at the start.
uint32_t free_physical_address = get_current_physicall_address();
uint32_t i = 0;
while (i <= free_physical_address)
{
// Kernel code is readable but not writeable from userspace.
alloc_frame(get_page(i, 1, page_dir), 1, 1);
i += ALIGNMENT;
// get_page() may allocate more space for new tables
free_physical_address = get_current_physicall_address();
}
That's a lot of code so I will sum up:
alloc_frame() finds the next free frame - using a bitset (I don't put the bitset code here because it works correctly.
get_page(), returns the page entry corresponding to the given address, and creates the page table if it doesn't exist.
initialize_paging() creates the page directory and does the identity mapping.
The following functions are not here but that's their summary:
kmalloc() allocates memory aligned to 4096.
get_current_physicall_address() returns the address which kmalloc will allocate on the next run.
memory_set() is my implementation of memset().
Any help will be appreciated!
Thanks in advance!
