OSDev.org

Code: Select all

void switch_page_directory(page_directory_t *dir)
{
    current_directory = dir;
    asm volatile("mov %0, %%cr3":: "r"(dir->physicalAddr));
    u32int cr0;
    asm volatile("mov %%cr0, %0": "=r"(cr0));
    cr0 |= 0x80000000; // Enable paging!
    asm volatile("mov %0, %%cr0":: "r"(cr0));
}

Code: Select all

void page_fault(registers_t *regs)
{
    // A page fault has occurred.
    // The faulting address is stored in the CR2 register.
    u32int faulting_address;
   asm volatile("mov %%cr2, %0" : "=r" (faulting_address));

Code: Select all

void switch_to_user_mode()
{
    // Set up our kernel stack.
    set_kernel_stack(current_task->kernel_stack+KERNEL_STACK_SIZE);
    
    // Set up a stack structure for switching to user mode.
    asm volatile("  \
      cli; \
      mov $0x23, %ax; \
      mov %ax, %ds; \
      mov %ax, %es; \
      mov %ax, %fs; \
      mov %ax, %gs; \
                    \
       \
      mov %esp, %eax; \
      pushl $0x23; \
      pushl %esp; \
      pushf; \
      pushl $0x1B; \
      push $1f; \
      iret; \
    1: \
      "); 
      
}

Code: Select all

void page_fault(registers_t *regs)
{
    // A page fault has occurred.
    // The faulting address is stored in the CR2 register.
    u32int faulting_address;
    asm volatile("mov %%cr2, %0" : "=r" (faulting_address));
    
    // The error code gives us details of what happened.
    int present   = !(regs->err_code & 0x1); // Page not present
    int rw = regs->err_code & 0x2;           // Write operation?
    int us = regs->err_code & 0x4;           // Processor was in user-mode?
    int reserved = regs->err_code & 0x8;     // Overwritten CPU-reserved bits of page entry?
    int id = regs->err_code & 0x10;          // Caused by an instruction fetch?

    // Output an error message.
    monitor_write("Page fault! ( ");
    if (present) {monitor_write("present ");}
    if (rw) {monitor_write("read-only ");}
    if (us) {monitor_write("user-mode ");}
    if (reserved) {monitor_write("reserved ");}
    monitor_write(") at 0x");
    monitor_write_hex(faulting_address);
    monitor_write(" - EIP: ");
    monitor_write_hex(regs->eip);
    monitor_write("\n");
    PANIC("Page fault");
}

Code: Select all

    monitor_write("switching to usermode\n");
    switch_to_user_mode();

   // syscall_monitor_write("Hello, user world!\n");
    return 0;

Code: Select all

 .text          
 		0x0010219a      0x478 bin/monitor.o
                0x001022af                monitor_put
                0x001023d7                monitor_clear
                0x0010242e                monitor_write
                0x00102472                monitor_write_hex
                0x00102538                monitor_write_dec

Code: Select all

  syscall_monitor_write("Hello, user world!\n");
  102198:	83 ec 0c             	sub    $0xc,%esp
  10219b:	68 4e 42 10 00       	push   $0x10424e
  1021a0:	e8 59 0f 00 00       	call   1030fe <syscall_monitor_write>
  1021a5:	83 c4 10             	add    $0x10,%esp
    return 0;
  1021a8:	b8 00 00 00 00       	mov    $0x0,%eax

Code: Select all

syscall_monitor_write

Code: Select all

SECTION .text

set_up_stack:
    
    MOV  ESP, stack_end  ; Set the stack pointer

SECTION .bss

stack_begin:
    RESB 4096  ; Reserve 4 KiB stack space
stack_end:

Code: Select all

ENTRY(start)

STACK_SIZE = 0x100;

SECTIONS
{
    .mbheader 0x100000 :
    {
        *(.mbheader)
    }
    .text :
    {
        code = .; _code = .; __code = .;
        *(.text)
        . = ALIGN(4096);
    }

    .data :
    {
        data = .; _data = .; __data = .;
        *(.data)
        *(.rodata)
        . = ALIGN(4096);
    }

    .stack (NOLOAD):
    {
        . = ALIGN(8);
        stack_bottom = .;
        . = . + STACK_SIZE;
        stack_top = .;
        . = ALIGN(8);
    } 

    .bss :
    {
        bss = .; _bss = .; __bss = .;
        *(.bss)
        . = ALIGN(4096);
    }


    end = .; _end = .; __end = .;
}

Code: Select all

extern u32int stack_bottom;
extern u32int stack_top;
extern u32int placement_address;
u32int initial_esp;

int main(struct multiboot *mboot_ptr, u32int initial_stack)
{
    // find the stack defined in the linker script
    u32int kernel_stack_bottom = (u32int) &stack_bottom;
    u32int kernel_stack_top = (u32int) &stack_top;
    
    // save the initial stack pointer (task.c::move_stack needs this)
    initial_esp = kernel_stack_bottom;

    // set the stack up
    asm volatile("mov %0, %%esp" : : "r" (kernel_stack_bottom));