Again, my example/actual bootstrap code, maybe it helps?
Code:
.set ALIGN, 1<<0 # align loaded modules on page boundaries
.set MEMINFO, 1<<1 # provide memory map
.set FLAGS, ALIGN | MEMINFO # this is the Multiboot 'flag' field
.set MAGIC, 0x1BADB002 # 'magic number' lets bootloader find the header
.set CHECKSUM, -(MAGIC + FLAGS) # checksum of above, to prove we are multiboot
.section .multiboot
.long MAGIC
.long FLAGS
.long CHECKSUM
.section .stack, "aw", @nobits
stackBottom:
.skip 16384
stackTop:
.set KVIRT_BASE, 0xC0000000
.set KPAGE_NUM, (KVIRT_BASE >> 12)
.section .bss
.align 0x1000
pageDirectory:
.skip 0x1000 # Page directory
pageTables:
.skip 0x1000 # First identity-mapped 4MiB
.skip 0x1000 * 256 # 3GiB to 4GiB area
gdtPtr:
.skip 6 # GDT Pointer
gdt:
.skip 8 * 3 # Actual GDT
idtPtr:
.skip 6 # IDT Pointer
idt:
.skip 8 * 256 # Actual IDT
.section .boot
.global __start__
__start__:
# A Multiboot-compliant bootloader just yielded
# execution to the OS here. At this moment,
# everything is loaded at 1MiB, but the code
# thinks it's on 3GiB! The solution? Subtract
# 3GiB from *each* address used, so it resolves
# to the correct physical address. That's the job
# of the 'subl $KVIRT_BASE, %edx' stuff all around
# this function. Once the paging structures are fully
# calculated and loaded, __start__() can work with virtual
# addresses. It then passes control to realStart(), the
# routine responsible for parsing the Multiboot information (TODO),
# setting up the descriptor tables (GDT and IDT), and
# finally calling KernelInit. If something fails,
# criticalError() is a minimalistic asm version of KTPipe
# that writes some string in red/white to VGA memory and halts.
# Load the stack (I can't live up from the registers!)
movl $stackTop, %esp
subl $KVIRT_BASE, %esp
# Save Multiboot Information (%ebx) and Bootloader Magic (%eax)
push %eax
push %ebx
# Map the first 4MiB to the first page table
movl $pageDirectory, %edx
subl $KVIRT_BASE, %edx
movl $pageTables, %eax
subl $KVIRT_BASE, %eax
orl $0x00000003, %eax
movl %eax, (%edx)
# Identity map the first page table
movl $pageTables, %edi
subl $KVIRT_BASE, %edi
movl $1024, %ecx
movl %ecx, %ebx
.identmap:
movl %ebx, %eax
subl %ecx, %eax
movl %eax, %esi
shll $12, %esi
orl $0x00000003, %esi
movl $4, %edx
mull %edx
movl %edi, %edx
addl %eax, %edx
movl %esi, (%edx)
loop .identmap
# Map the first Gigabyte to 3GiB upwards
movl $pageTables, %edi
subl $KVIRT_BASE, %edi
addl $0x1000, %edi
movl $256, %ecx
movl $0, %edx
.highmap:
movl %ecx, %ebx
movl $1024, %ecx
.highmap2:
movl %edx, %eax
shll $12, %eax
orl $0x00000003, %eax
movl %eax, (%edi)
incl %edx
addl $4, %edi
loop .highmap2
movl %ebx, %ecx
loop .highmap
# Load the higher-half tables
movl $pageDirectory, %edx
subl $KVIRT_BASE, %edx
addl $3072, %edx
movl $256, %ecx
movl %ecx, %ebx
.filltop:
movl %ebx, %esi
subl %ecx, %esi
movl %edx, %edi
movl $0x1000, %eax
mull %esi
movl %edi, %edx
movl $pageTables, %edi
subl $KVIRT_BASE, %edi
addl $0x1000, %edi
addl %eax, %edi
orl $0x00000003, %edi
movl %edx, %ebp
movl $4, %eax
mull %esi
movl %ebp, %edx
addl %edx, %eax
movl %edi, (%eax)
loop .filltop
# Load the page directory
movl $pageDirectory, %edx
subl $KVIRT_BASE, %edx
movl %edx, %cr3
# Enable paging
movl %cr0, %edx
orl $0x80000000, %edx
movl %edx, %cr0
# Jump to some code that *really* assumes it's on $KVIRT_BASE
movl $realStart, %edx
jmp *%edx
.text
realStart:
# Load the virtual value of $stackTop
# And, to comply with the ABI, load %esp into %ebp
addl $KVIRT_BASE, %esp
movl %esp, %ebp
# Setup the Global Descriptor Table (GDT) Pointer
movl $gdtPtr, %edx
movl $gdt, %eax
movw $23, (%edx)
movl %eax, 2(%edx)
# Load the Null GDT Entry
push $0
push $0
push $0
push $0
push $0
call setGDTEntry
addl $20, %esp
# Load the Kernel Code GDT Entry
push $0xCF
push $0x9A
push $0xFFFFFFFF
push $0
push $1
call setGDTEntry
addl $20, %esp
# Load the Kernel Data GDT Entry
push $0xCF
push $0x92
push $0xFFFFFFFF
push $0
push $2
call setGDTEntry
addl $20, %esp
# Actually load the full GDT
movl $gdtPtr, %eax
lgdt (%eax) # Do it!
movw $0x10, %ax # Load the data segment registers
movw %ax, %ds
movw %ax, %es
movw %ax, %fs
movw %ax, %gs
ljmp $0x08, $.gdtReady # Some black magic to load %cs
.gdtReady:
# Do the same as above, but with the Interrupt Descriptor Table (IDT) Pointer
movl $idtPtr, %edx
movl $idt, %eax
movw $384, (%edx)
movl %eax, 2(%edx)
# We'll load *all* the ISRs, so we need to use as less code as possible,
# but stack memory is infinite, as far as the processor is concerned :)
subl $192, %esp
#define ISR(no, who) \
movl $__inthand_ ## who ## __, %eax; \
movl %eax, no(%esp);
ISR(0, exc0)
ISR(4, exc1)
ISR(8, exc2)
ISR(12, exc3)
ISR(16, exc4)
ISR(20, exc5)
ISR(24, exc6)
ISR(28, exc7)
ISR(32, exc8)
ISR(36, exc9)
ISR(40, exc10)
ISR(44, exc11)
ISR(48, exc12)
ISR(52, exc13)
ISR(56, exc14)
ISR(60, exc15)
ISR(64, exc16)
ISR(68, exc17)
ISR(72, exc18)
ISR(76, exc19)
ISR(80, exc20)
ISR(84, exc21)
ISR(88, exc22)
ISR(92, exc23)
ISR(96, exc24)
ISR(100, exc25)
ISR(104, exc26)
ISR(108, exc27)
ISR(112, exc28)
ISR(116, exc29)
ISR(120, exc30)
ISR(124, exc31)
ISR(128, irq0)
ISR(132, irq1)
ISR(136, irq2)
ISR(140, irq3)
ISR(144, irq4)
ISR(148, irq5)
ISR(152, irq6)
ISR(156, irq7)
ISR(160, irq8)
ISR(164, irq9)
ISR(168, irq10)
ISR(172, irq11)
ISR(176, irq12)
ISR(180, irq13)
ISR(184, irq14)
ISR(188, irq15)
#undef ISR
# Actually set the IDT entries
movl $48, %ecx
.idtLoop:
movl %ecx, %ebx
movl $48, %esi
subl %ebx, %esi
movl (%esp, %esi, 4), %eax
push $0x8E
push $0x08
push %eax
push %esi
call setIDTEntry
addl $16, %esp
movl %ebx, %ecx
loop .idtLoop
addl $192, %esp # Free up that stack space
# Load the IDT and we'll be done
movl $idtPtr, %eax
lidt (%eax) # Do it!
# Reconfigure the PICs, so stupid stuff doesn't happens
inb $0x21, %al
movb %al, %bl
inb $0xA1, %al
movb %al, %cl
movb $0x11, %al
outb %al, $0x20
outb %al, $0xA0
movb $0x20, %al
outb %al, $0x21
movb $0x28, %al
outb %al, $0xA1
movb $0x04, %al
outb %al, $0x21
movb $0x02, %al
outb %al, $0xA1
movb $0x01, %al
outb %al, $0x21
outb %al, $0xA1
movb %bl, %al
outb %al, $0x21
movb %cl, %al
outb %al, $0xA1
# Get Multiboot Information (%ebx) and Bootloader Magic (%eax)
pop %ebx
pop %eax
# Check the Bootloader magic. If it's invalid, panic!
cmp $0x2BADB002, %eax
je .noerror
# Error! **** it up!
push $.ENOTMULTIBOOT # "Not using a Multiboot-compliant bootloader"
push $0x01 # Error Code
call criticalError
.noerror:
# Parse the first-level Multiboot Structure (TODO)
addl $KVIRT_BASE, %ebx # Physical to Virtual
# Call trivial global constructors
call _init
# Pass it to KernelInit()...
push %ebx
# Should I put a comment here? Anyway, I did it.
call KernelInit
# If KernelInit() somehow returns, halt the machine.
# Non-maskable interrupt? Don't worry! Just loop forever.
.hang:
cli
hlt
jmp .hang
setGDTEntry:
push %ebp
movl %esp, %ebp
push %esi # We need some extra memory
movl 8(%ebp), %eax # GDT Index
movl $gdt, %ecx
movl 12(%ebp), %edx # The base
movw %dx, 2(%ecx, %eax, 8) # Set low base
shrl $16, %edx
movb %dl, 4(%ecx, %eax, 8) # Set middle base
movb %dh, 7(%ecx, %eax, 8) # Set high base
movl 16(%ebp), %edx # The limit
movw %dx, (%ecx, %eax, 8) # Set low limit
movl 24(%ebp), %esi # Granularity
shrl $16, %edx
andl $0x0F, %edx
andl $0xF0, %esi
orl %esi, %edx
movb %dl, 6(%ecx, %eax, 8) # Set granularity
movl 20(%ebp), %edx # Access
movb %dl, 5(%ecx, %eax, 8) # Set access
pop %esi
movl %ebp, %esp
pop %ebp
ret
setIDTEntry:
push %ebp
movl %esp, %ebp
movl 8(%ebp), %eax # IDT Index
movl $idt, %ecx
movl 12(%ebp), %edx # The base
movw %dx, (%ecx, %eax, 8) # Set low base
shrl $16, %edx
movw %dx, 6(%ecx, %eax, 8) # Set high base
movl 16(%ebp), %edx # The selector
movw %dx, 2(%ecx, %eax, 8) # Set selector
movl 20(%ebp), %edx # Flags
movb %dl, 5(%ecx, %eax, 8) # Set flags
movb $0, 4(%ecx, %eax, 8) # Always 0
movl %ebp, %esp
pop %ebp
ret
criticalError:
# %ebx is the offset over VGA memory used
# by the criticalPrint* functions.
movl $0, %ebx
# "Fatal Error Code "
movl $.EERROR, %eax
call criticalPrintString
pop %eax # Error Code
call criticalPrintHex
movb $0x3A, %al # ':' Character
call criticalPrintChar
movb $0x20, %al # ' ' Character
call criticalPrintChar
pop %eax # Error Message
call criticalPrintString
movl $.EHALT, %eax
call criticalPrintString
# Halt
cli
hlt
criticalPrintString:
# Parameters:
# %eax: Address of null-terminated string to print
.strloop:
movb (%eax), %al
cmp $0x00, %al
je .strloopend
call criticalPrintChar
incl %eax
incl %ebx
jmp .strloop
.strloopend:
ret
criticalPrintHex:
# Parameters:
# %eax: Integer to print
movb $0x30, %al # '0' Character
call criticalPrintChar
incl %ebx
movb $0x78, %al # 'x' Character
call criticalPrintChar
incl %ebx
movl $8, %ecx
.hexloop:
movl %ecx, %esi
decl %esi
push %eax
movl %eax, %edi
movl $4, %eax
mull %esi
xchg %eax, %ecx
shrl %cl, %edi
xchg %eax, %ecx
movl %edi, %edx
push %ecx
movl $2, %ecx
.hexbitloop:
push %edx
andb $0x0F, %dl
# Get the real value...
.hextest:
cmpb $0x0A, %dl
jb .hextestdecimal
jae .hextesthexa
.hextestdecimal:
addb $0x30, %dl # Calculates character between '0' and '9'
jmp .hextestend
.hextesthexa:
subb $0x0A, %dl # For offsetting
addb $0x41, %dl
jmp .hextestend
.hextestend:
movb %dl, %al
call criticalPrintChar
incl %ebx
pop %edx
shrl $4, %edx
loop .hexbitloop
pop %ecx
pop %eax
loop .hexloop
ret
criticalPrintChar:
# Parameters:
# %al: Character to print
# %ebx: Offset over VGA Memory
# Uses:
# %dx: Actual value written to VGA Memory
movb $0x4F, %dh # White text on red background
movb %al, %dl # Mix it...
movw %dx, 0xB8000(,%ebx, 2) # Print!
ret
.section rodata
# Concatenated on every error
.EERROR:
.asciz "Fatal Error Code "
.EHALT:
.asciz ". System halted! Please reboot manually."
# The actual errors
.ENOTMULTIBOOT:
.asciz "Not using a Multiboot-compliant bootloader"
Login
Register
FAQ
Search
