OSDev.org

Code: Select all

/* Global ctors and dtors */
.ctors : {*(.ctors)}
.dtors : {*(.dtors)}

/* Just make crtstuff happy */
.tm_clone_table : {*(.tm_clone_table)}
.jcr : {*(.jcr)}
.got.plt : {*(.got.plt)}

.init : {*(.init)}
.fini : {*(.fini)}

/* Enable exception handling */
.eh_frame_hdr : {*(.eh_frame_hdr) }
.eh_frame : {*(.eh_frame)}
.gcc_except_table : { *(.gcc_except_table) }

Code: Select all

.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

.section .boot
.global __start__
__start__:
	# A Multiboot-compliant bootloader just yielded
	# execution to Bluesky 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),
	# 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
	
	# 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
	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

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"