12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541 |
- /*
- * librm: a library for interfacing to real-mode code
- *
- * Michael Brown <mbrown@fensystems.co.uk>
- *
- */
-
- FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
-
- /* Drag in local definitions */
- #include "librm.h"
-
- /* CR0: protection enabled */
- #define CR0_PE ( 1 << 0 )
-
- /* CR0: paging */
- #define CR0_PG ( 1 << 31 )
-
- /* CR4: physical address extensions */
- #define CR4_PAE ( 1 << 5 )
-
- /* Extended feature enable MSR (EFER) */
- #define MSR_EFER 0xc0000080
-
- /* EFER: long mode enable */
- #define EFER_LME ( 1 << 8 )
-
- /* Page: present */
- #define PG_P 0x01
-
- /* Page: read/write */
- #define PG_RW 0x02
-
- /* Page: user/supervisor */
- #define PG_US 0x04
-
- /* Page: page size */
- #define PG_PS 0x80
-
- /* Size of various paging-related data structures */
- #define SIZEOF_PTE_LOG2 3
- #define SIZEOF_PTE ( 1 << SIZEOF_PTE_LOG2 )
- #define SIZEOF_PT_LOG2 12
- #define SIZEOF_PT ( 1 << SIZEOF_PT_LOG2 )
- #define SIZEOF_4KB_PAGE_LOG2 12
- #define SIZEOF_4KB_PAGE ( 1 << SIZEOF_4KB_PAGE_LOG2 )
- #define SIZEOF_2MB_PAGE_LOG2 21
- #define SIZEOF_2MB_PAGE ( 1 << SIZEOF_2MB_PAGE_LOG2 )
- #define SIZEOF_LOW_4GB_LOG2 32
- #define SIZEOF_LOW_4GB ( 1 << SIZEOF_LOW_4GB_LOG2 )
-
- /* Size of various C data structures */
- #define SIZEOF_I386_SEG_REGS 12
- #define SIZEOF_I386_REGS 32
- #define SIZEOF_REAL_MODE_REGS ( SIZEOF_I386_SEG_REGS + SIZEOF_I386_REGS )
- #define SIZEOF_I386_FLAGS 4
- #define SIZEOF_I386_ALL_REGS ( SIZEOF_REAL_MODE_REGS + SIZEOF_I386_FLAGS )
- #define SIZEOF_X86_64_REGS 128
-
- /* Size of an address */
- #ifdef __x86_64__
- #define SIZEOF_ADDR 8
- #else
- #define SIZEOF_ADDR 4
- #endif
-
- /* Default code size */
- #ifdef __x86_64__
- #define CODE_DEFAULT code64
- #else
- #define CODE_DEFAULT code32
- #endif
-
- /* Selectively assemble code for 32-bit/64-bit builds */
- #ifdef __x86_64__
- #define if32 if 0
- #define if64 if 1
- #else
- #define if32 if 1
- #define if64 if 0
- #endif
-
- /****************************************************************************
- * Global descriptor table
- *
- * Call init_librm to set up the GDT before attempting to use any
- * protected-mode code.
- *
- * NOTE: This must be located before prot_to_real, otherwise gas
- * throws a "can't handle non absolute segment in `ljmp'" error due to
- * not knowing the value of REAL_CS when the ljmp is encountered.
- *
- * Note also that putting ".word gdt_end - gdt - 1" directly into
- * gdt_limit, rather than going via gdt_length, will also produce the
- * "non absolute segment" error. This is most probably a bug in gas.
- ****************************************************************************
- */
- .section ".data16.gdt", "aw", @progbits
- .align 16
- gdt:
- gdtr: /* The first GDT entry is unused, the GDTR can fit here. */
- gdt_limit: .word gdt_length - 1
- gdt_base: .long 0
- .word 0 /* padding */
-
- .org gdt + VIRTUAL_CS, 0
- virtual_cs: /* 32 bit protected mode code segment, virtual addresses */
- .word 0xffff, 0
- .byte 0, 0x9f, 0xcf, 0
-
- .org gdt + VIRTUAL_DS, 0
- virtual_ds: /* 32 bit protected mode data segment, virtual addresses */
- .word 0xffff, 0
- .byte 0, 0x93, 0xcf, 0
-
- .org gdt + PHYSICAL_CS, 0
- physical_cs: /* 32 bit protected mode code segment, physical addresses */
- .word 0xffff, 0
- .byte 0, 0x9f, 0xcf, 0
-
- .org gdt + PHYSICAL_DS, 0
- physical_ds: /* 32 bit protected mode data segment, physical addresses */
- .word 0xffff, 0
- .byte 0, 0x93, 0xcf, 0
-
- .org gdt + REAL_CS, 0
- real_cs: /* 16 bit real mode code segment */
- .word 0xffff, 0
- .byte 0, 0x9b, 0x00, 0
-
- .org gdt + REAL_DS, 0
- real_ds: /* 16 bit real mode data segment */
- .word 0xffff, 0
- .byte 0, 0x93, 0x00, 0
-
- .org gdt + P2R_DS, 0
- p2r_ds: /* 16 bit real mode data segment for prot_to_real transition */
- .word 0xffff, ( P2R_DS << 4 )
- .byte 0, 0x93, 0x00, 0
-
- .org gdt + LONG_CS, 0
- long_cs: /* 64 bit long mode code segment */
- .word 0, 0
- .byte 0, 0x9a, 0x20, 0
-
- gdt_end:
- .equ gdt_length, gdt_end - gdt
-
- /****************************************************************************
- * Stored real-mode and protected-mode stack pointers
- *
- * The real-mode stack pointer is stored here whenever real_to_prot
- * is called and restored whenever prot_to_real is called. The
- * converse happens for the protected-mode stack pointer.
- *
- * Despite initial appearances this scheme is, in fact re-entrant,
- * because program flow dictates that we always return via the point
- * we left by. For example:
- * PXE API call entry
- * 1 real => prot
- * ...
- * Print a text string
- * ...
- * 2 prot => real
- * INT 10
- * 3 real => prot
- * ...
- * ...
- * 4 prot => real
- * PXE API call exit
- *
- * At point 1, the RM mode stack value, say RPXE, is stored in
- * rm_ss,sp. We want this value to still be present in rm_ss,sp when
- * we reach point 4.
- *
- * At point 2, the RM stack value is restored from RPXE. At point 3,
- * the RM stack value is again stored in rm_ss,sp. This *does*
- * overwrite the RPXE that we have stored there, but it's the same
- * value, since the code between points 2 and 3 has managed to return
- * to us.
- ****************************************************************************
- */
- .section ".bss.rm_sp", "aw", @nobits
- .globl rm_sp
- rm_sp: .word 0
-
- .section ".bss.rm_ss", "aw", @nobits
- .globl rm_ss
- rm_ss: .word 0
-
- .section ".data.pm_esp", "aw", @progbits
- pm_esp: .long VIRTUAL(_estack)
-
- /****************************************************************************
- * Virtual address offsets
- *
- * These are used by the protected-mode code to map between virtual
- * and physical addresses, and to access variables in the .text16 or
- * .data16 segments.
- ****************************************************************************
- */
- .struct 0
- VA_VIRT_OFFSET: .space SIZEOF_ADDR
- VA_TEXT16: .space SIZEOF_ADDR
- VA_DATA16: .space SIZEOF_ADDR
- VA_SIZE:
- .previous
-
- /* Internal copies, used only by librm itself */
- .section ".bss16.rm_virt_addrs", "aw", @nobits
- rm_virt_addrs: .space VA_SIZE
- .equ rm_virt_offset, ( rm_virt_addrs + VA_VIRT_OFFSET )
- .equ rm_text16, ( rm_virt_addrs + VA_TEXT16 )
- .equ rm_data16, ( rm_virt_addrs + VA_DATA16 )
-
- /* Externally visible variables, used by C code */
- .section ".bss.virt_addrs", "aw", @nobits
- virt_addrs: .space VA_SIZE
- .globl virt_offset
- .equ virt_offset, ( virt_addrs + VA_VIRT_OFFSET )
- .globl text16
- .equ text16, ( virt_addrs + VA_TEXT16 )
- .globl data16
- .equ data16, ( virt_addrs + VA_DATA16 )
-
- /****************************************************************************
- * init_librm (real-mode far call, 16-bit real-mode far return address)
- *
- * Initialise the GDT ready for transitions to protected mode.
- *
- * Parameters:
- * %cs : .text16 segment
- * %ds : .data16 segment
- * %edi : Physical base of protected-mode code
- ****************************************************************************
- */
- .section ".text16.init_librm", "ax", @progbits
- .code16
- .globl init_librm
- init_librm:
- /* Preserve registers */
- pushl %eax
- pushl %ebx
- pushl %edi
-
- /* Store rm_virt_offset and set up virtual_cs and virtual_ds segments */
- subl $VIRTUAL(_textdata), %edi
- movl %edi, rm_virt_offset
- .if64 ; setae (rm_virt_offset+4) ; .endif
- movl %edi, %eax
- movw $virtual_cs, %bx
- call set_seg_base
- movw $virtual_ds, %bx
- call set_seg_base
-
- /* Store rm_cs and rm_text16, set up real_cs segment */
- xorl %eax, %eax
- movw %cs, %ax
- movw %ax, %cs:rm_cs
- shll $4, %eax
- movw $real_cs, %bx
- call set_seg_base
- .if32 ; subl %edi, %eax ; .endif
- movl %eax, rm_text16
-
- /* Store rm_ds and rm_data16, set up real_ds segment and GDT base */
- xorl %eax, %eax
- movw %ds, %ax
- movw %ax, %cs:rm_ds
- shll $4, %eax
- movw $real_ds, %bx
- call set_seg_base
- movl %eax, gdt_base
- addl $gdt, gdt_base
- .if32 ; subl %edi, %eax ; .endif
- movl %eax, rm_data16
-
- /* Configure virt_call for protected mode, if applicable */
- .if64 ; movl $VIRTUAL(vc_pmode), %cs:vc_jmp_offset ; .endif
-
- /* Switch to protected mode */
- virtcall init_librm_pmode
- .section ".text.init_librm", "ax", @progbits
- .code32
- init_librm_pmode:
-
- /* Store virt_offset, text16, and data16 */
- pushw %ds
- movw $REAL_DS, %ax
- movw %ax, %ds
- movl $rm_virt_addrs, %esi
- movl $VIRTUAL(virt_addrs), %edi
- movl $( VA_SIZE / 4 ), %ecx
- rep movsl
- popw %ds
-
- .if64 ; /* Initialise long mode, if applicable */
- movl VIRTUAL(virt_offset), %edi
- leal VIRTUAL(p2l_ljmp_target)(%edi), %eax
- movl %eax, VIRTUAL(p2l_ljmp_offset)
- call init_pages
- .endif
- /* Return to real mode */
- ret
- .section ".text16.init_librm", "ax", @progbits
- .code16
- init_librm_rmode:
-
- /* Configure virt_call for long mode, if applicable */
- .if64 ; movl $VIRTUAL(vc_lmode), %cs:vc_jmp_offset ; .endif
-
- /* Initialise IDT */
- virtcall init_idt
-
- /* Restore registers */
- popl %edi
- popl %ebx
- popl %eax
- lret
-
- .section ".text16.set_seg_base", "ax", @progbits
- .code16
- set_seg_base:
- 1: movw %ax, 2(%bx)
- rorl $16, %eax
- movb %al, 4(%bx)
- movb %ah, 7(%bx)
- roll $16, %eax
- ret
-
- /****************************************************************************
- * real_to_prot (real-mode near call, 32-bit virtual return address)
- *
- * Switch from 16-bit real-mode to 32-bit protected mode with virtual
- * addresses. The real-mode %ss:sp is stored in rm_ss and rm_sp, and
- * the protected-mode %esp is restored from the saved pm_esp.
- * Interrupts are disabled. All other registers may be destroyed.
- *
- * The return address for this function should be a 32-bit virtual
- * address.
- *
- * Parameters:
- * %ecx : number of bytes to move from RM stack to PM stack
- *
- ****************************************************************************
- */
- .section ".text16.real_to_prot", "ax", @progbits
- .code16
- real_to_prot:
- /* Enable A20 line */
- call enable_a20
- /* A failure at this point is fatal, and there's nothing we
- * can do about it other than lock the machine to make the
- * problem immediately visible.
- */
- 1: jc 1b
-
- /* Make sure we have our data segment available */
- movw %cs:rm_ds, %ds
-
- /* Add protected-mode return address to length of data to be copied */
- addw $4, %cx /* %ecx must be less than 64kB anyway */
-
- /* Real-mode %ss:%sp => %ebp:%edx and virtual address => %esi */
- xorl %ebp, %ebp
- movw %ss, %bp
- movzwl %sp, %edx
- movl %ebp, %eax
- shll $4, %eax
- addr32 leal (%eax,%edx), %esi
- subl rm_virt_offset, %esi
-
- /* Load protected-mode global descriptor table */
- data32 lgdt gdtr
-
- /* Zero segment registers. This wastes around 12 cycles on
- * real hardware, but saves a substantial number of emulated
- * instructions under KVM.
- */
- xorw %ax, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
-
- /* Switch to protected mode (with paging disabled if applicable) */
- cli
- movl %cr0, %eax
- .if64 ; andl $~CR0_PG, %eax ; .endif
- orb $CR0_PE, %al
- movl %eax, %cr0
- data32 ljmp $VIRTUAL_CS, $VIRTUAL(r2p_pmode)
- .section ".text.real_to_prot", "ax", @progbits
- .code32
- r2p_pmode:
- /* Set up protected-mode data segments and stack pointer */
- movw $VIRTUAL_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- movl VIRTUAL(pm_esp), %esp
-
- /* Load protected-mode interrupt descriptor table */
- lidt VIRTUAL(idtr32)
-
- /* Record real-mode %ss:sp (after removal of data) */
- movw %bp, VIRTUAL(rm_ss)
- addl %ecx, %edx
- movw %dx, VIRTUAL(rm_sp)
-
- /* Move data from RM stack to PM stack */
- subl %ecx, %esp
- movl %esp, %edi
- rep movsb
-
- /* Return to virtual address */
- ret
-
- /****************************************************************************
- * prot_to_real (protected-mode near call, 32-bit real-mode return address)
- *
- * Switch from 32-bit protected mode with virtual addresses to 16-bit
- * real mode. The protected-mode %esp is stored in pm_esp and the
- * real-mode %ss:sp is restored from the saved rm_ss and rm_sp. The
- * high word of the real-mode %esp is set to zero. All real-mode data
- * segment registers are loaded from the saved rm_ds. Interrupts are
- * *not* enabled, since we want to be able to use prot_to_real in an
- * ISR. All other registers may be destroyed.
- *
- * The return address for this function should be a 32-bit (sic)
- * real-mode offset within .code16.
- *
- * Parameters:
- * %ecx : number of bytes to move from PM stack to RM stack
- * %esi : real-mode global and interrupt descriptor table registers
- *
- ****************************************************************************
- */
- .section ".text.prot_to_real", "ax", @progbits
- .code32
- prot_to_real:
- /* Copy real-mode global descriptor table register to RM code segment */
- movl VIRTUAL(text16), %edi
- .if64 ; subl VIRTUAL(virt_offset), %edi ; .endif
- leal rm_gdtr(%edi), %edi
- movsw
- movsl
-
- /* Load real-mode interrupt descriptor table register */
- lidt (%esi)
-
- /* Add return address to data to be moved to RM stack */
- addl $4, %ecx
-
- /* Real-mode %ss:sp => %ebp:edx and virtual address => %edi */
- movzwl VIRTUAL(rm_ss), %ebp
- movzwl VIRTUAL(rm_sp), %edx
- subl %ecx, %edx
- movl %ebp, %eax
- shll $4, %eax
- leal (%eax,%edx), %edi
- subl VIRTUAL(virt_offset), %edi
-
- /* Move data from PM stack to RM stack */
- movl %esp, %esi
- rep movsb
-
- /* Record protected-mode %esp (after removal of data) */
- movl %esi, VIRTUAL(pm_esp)
-
- /* Load real-mode segment limits */
- movw $P2R_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- ljmp $REAL_CS, $p2r_rmode
- .section ".text16.prot_to_real", "ax", @progbits
- .code16
- p2r_rmode:
- /* Load real-mode GDT */
- data32 lgdt %cs:rm_gdtr
- /* Switch to real mode */
- movl %cr0, %eax
- andb $0!CR0_PE, %al
- movl %eax, %cr0
- p2r_ljmp_rm_cs:
- ljmp $0, $1f
- 1:
- /* Set up real-mode data segments and stack pointer */
- movw %cs:rm_ds, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %bp, %ss
- movl %edx, %esp
-
- /* Return to real-mode address */
- data32 ret
-
-
- /* Real-mode code and data segments. Assigned by the call to
- * init_librm. rm_cs doubles as the segment part of the jump
- * instruction used by prot_to_real. Both are located in
- * .text16 rather than .data16: rm_cs since it forms part of
- * the jump instruction within the code segment, and rm_ds
- * since real-mode code needs to be able to locate the data
- * segment with no other reference available.
- */
- .globl rm_cs
- .equ rm_cs, ( p2r_ljmp_rm_cs + 3 )
-
- .section ".text16.data.rm_ds", "aw", @progbits
- .globl rm_ds
- rm_ds: .word 0
-
- /* Real-mode global and interrupt descriptor table registers */
- .section ".text16.data.rm_gdtr", "aw", @progbits
- rm_gdtr:
- .word 0 /* Limit */
- .long 0 /* Base */
-
- /****************************************************************************
- * phys_to_prot (protected-mode near call, 32-bit physical return address)
- *
- * Switch from 32-bit protected mode with physical addresses to 32-bit
- * protected mode with virtual addresses. %esp is adjusted to a
- * virtual address. All other registers are preserved.
- *
- * The return address for this function should be a 32-bit physical
- * (sic) address.
- *
- ****************************************************************************
- */
- .section ".text.phys_to_prot", "ax", @progbits
- .code32
- .globl phys_to_prot
- phys_to_prot:
- /* Preserve registers */
- pushl %eax
- pushl %ebp
-
- /* Switch to virtual code segment */
- cli
- ljmp $VIRTUAL_CS, $VIRTUAL(1f)
- 1:
- /* Switch to virtual data segment and adjust %esp */
- movw $VIRTUAL_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- movl VIRTUAL(virt_offset), %ebp
- subl %ebp, %esp
-
- /* Adjust return address to a virtual address */
- subl %ebp, 8(%esp)
-
- /* Restore registers and return */
- popl %ebp
- popl %eax
- ret
-
- .if32 /* Expose as _phys_to_virt for use by COMBOOT, if applicable */
- .globl _phys_to_virt
- .equ _phys_to_virt, phys_to_prot
- .endif
-
- /****************************************************************************
- * prot_to_phys (protected-mode near call, 32-bit virtual return address)
- *
- * Switch from 32-bit protected mode with virtual addresses to 32-bit
- * protected mode with physical addresses. %esp is adjusted to a
- * physical address. All other registers are preserved.
- *
- * The return address for this function should be a 32-bit virtual
- * (sic) address.
- *
- ****************************************************************************
- */
- .section ".text.prot_to_phys", "ax", @progbits
- .code32
- prot_to_phys:
- /* Preserve registers */
- pushl %eax
- pushl %ebp
-
- /* Adjust return address to a physical address */
- movl VIRTUAL(virt_offset), %ebp
- addl %ebp, 8(%esp)
-
- /* Switch to physical code segment */
- cli
- pushl $PHYSICAL_CS
- leal VIRTUAL(1f)(%ebp), %eax
- pushl %eax
- lret
- 1:
- /* Switch to physical data segment and adjust %esp */
- movw $PHYSICAL_DS, %ax
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
- movw %ax, %ss
- addl %ebp, %esp
-
- /* Restore registers and return */
- popl %ebp
- popl %eax
- ret
-
- .if32 /* Expose as _virt_to_phys for use by COMBOOT, if applicable */
- .globl _virt_to_phys
- .equ _virt_to_phys, prot_to_phys
- .endif
-
- /****************************************************************************
- * intr_to_prot (protected-mode near call, 32-bit virtual return address)
- *
- * Switch from 32-bit protected mode with a virtual code segment and
- * either a physical or virtual stack segment to 32-bit protected mode
- * with normal virtual addresses. %esp is adjusted if necessary to a
- * virtual address. All other registers are preserved.
- *
- * The return address for this function should be a 32-bit virtual
- * address.
- *
- ****************************************************************************
- */
- .section ".text.intr_to_prot", "ax", @progbits
- .code32
- .globl intr_to_prot
- intr_to_prot:
- /* Preserve registers */
- pushl %eax
-
- /* Check whether stack segment is physical or virtual */
- movw %ss, %ax
- cmpw $VIRTUAL_DS, %ax
- movw $VIRTUAL_DS, %ax
-
- /* Reload data segment registers */
- movw %ax, %ds
- movw %ax, %es
- movw %ax, %fs
- movw %ax, %gs
-
- /* Reload stack segment and adjust %esp if necessary */
- je 1f
- movw %ax, %ss
- subl VIRTUAL(virt_offset), %esp
- 1:
- /* Restore registers and return */
- popl %eax
- ret
-
- /* Expose as _intr_to_virt for use by GDB */
- .globl _intr_to_virt
- .equ _intr_to_virt, intr_to_prot
-
- /****************************************************************************
- * prot_to_long (protected-mode near call, 32-bit virtual return address)
- *
- * Switch from 32-bit protected mode with virtual addresses to 64-bit
- * long mode. The protected-mode %esp is adjusted to a physical
- * address. All other registers are preserved.
- *
- * The return address for this function should be a 32-bit (sic)
- * virtual address.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.prot_to_long", "ax", @progbits
- .code32
- prot_to_long:
- /* Preserve registers */
- pushl %eax
- pushl %ecx
- pushl %edx
-
- /* Set up PML4 */
- movl VIRTUAL(pml4), %eax
- movl %eax, %cr3
-
- /* Enable PAE */
- movl %cr4, %eax
- orb $CR4_PAE, %al
- movl %eax, %cr4
-
- /* Enable long mode */
- movl $MSR_EFER, %ecx
- rdmsr
- orw $EFER_LME, %ax
- wrmsr
-
- /* Enable paging */
- movl %cr0, %eax
- orl $CR0_PG, %eax
- movl %eax, %cr0
-
- /* Restore registers */
- popl %edx
- popl %ecx
- popl %eax
-
- /* Construct 64-bit return address */
- pushl (%esp)
- movl $0xffffffff, 4(%esp)
- p2l_ljmp:
- /* Switch to long mode (using a physical %rip) */
- ljmp $LONG_CS, $0
- .code64
- p2l_lmode:
- /* Adjust and zero-extend %esp to a physical address */
- addl virt_offset, %esp
-
- /* Use long-mode IDT */
- lidt idtr64
-
- /* Return to virtual address */
- ret
-
- /* Long mode jump offset and target. Required since an ljmp
- * in protected mode will zero-extend the offset, and so
- * cannot reach an address within the negative 2GB as used by
- * -mcmodel=kernel. Assigned by the call to init_librm.
- */
- .equ p2l_ljmp_offset, ( p2l_ljmp + 1 )
- .equ p2l_ljmp_target, p2l_lmode
-
- .endif
-
- /****************************************************************************
- * long_to_prot (long-mode near call, 64-bit virtual return address)
- *
- * Switch from 64-bit long mode to 32-bit protected mode with virtual
- * addresses. The long-mode %rsp is adjusted to a virtual address.
- * All other registers are preserved.
- *
- * The return address for this function should be a 64-bit (sic)
- * virtual address.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.long_to_prot", "ax", @progbits
- .code64
- long_to_prot:
- /* Switch to protected mode */
- ljmp *l2p_vector
- .code32
- l2p_pmode:
- /* Adjust %esp to a virtual address */
- subl VIRTUAL(virt_offset), %esp
-
- /* Preserve registers */
- pushl %eax
- pushl %ecx
- pushl %edx
-
- /* Disable paging */
- movl %cr0, %eax
- andl $~CR0_PG, %eax
- movl %eax, %cr0
-
- /* Disable PAE (in case external non-PAE-aware code enables paging) */
- movl %cr4, %eax
- andb $~CR4_PAE, %al
- movl %eax, %cr4
-
- /* Disable long mode */
- movl $MSR_EFER, %ecx
- rdmsr
- andw $~EFER_LME, %ax
- wrmsr
-
- /* Restore registers */
- popl %edx
- popl %ecx
- popl %eax
-
- /* Use protected-mode IDT */
- lidt VIRTUAL(idtr32)
-
- /* Return */
- ret $4
-
- /* Long mode jump vector. Required since there is no "ljmp
- * immediate" instruction in long mode.
- */
- .section ".data.l2p_vector", "aw", @progbits
- l2p_vector:
- .long VIRTUAL(l2p_pmode), VIRTUAL_CS
-
- .endif
-
- /****************************************************************************
- * long_save_regs (long-mode near call, 64-bit virtual return address)
- *
- * Preserve registers that are accessible only in long mode. This
- * includes %r8-%r15 and the upper halves of %rax, %rbx, %rcx, %rdx,
- * %rsi, %rdi, and %rbp.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.long_preserve_regs", "ax", @progbits
- .code64
- long_preserve_regs:
- /* Preserve registers */
- pushq %rax
- pushq %rcx
- pushq %rdx
- pushq %rbx
- pushq %rsp
- pushq %rbp
- pushq %rsi
- pushq %rdi
- pushq %r8
- pushq %r9
- pushq %r10
- pushq %r11
- pushq %r12
- pushq %r13
- pushq %r14
- pushq %r15
-
- /* Return */
- jmp *SIZEOF_X86_64_REGS(%rsp)
-
- .endif
-
- /****************************************************************************
- * long_restore_regs (long-mode near call, 64-bit virtual return address)
- *
- * Restore registers that are accessible only in long mode. This
- * includes %r8-%r15 and the upper halves of %rax, %rbx, %rcx, %rdx,
- * %rsi, %rdi, and %rbp.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.long_restore_regs", "ax", @progbits
- .code64
- long_restore_regs:
- /* Move return address above register dump */
- popq SIZEOF_X86_64_REGS(%rsp)
-
- /* Restore registers */
- popq %r15
- popq %r14
- popq %r13
- popq %r12
- popq %r11
- popq %r10
- popq %r9
- popq %r8
- movl %edi, (%rsp)
- popq %rdi
- movl %esi, (%rsp)
- popq %rsi
- movl %ebp, (%rsp)
- popq %rbp
- leaq 8(%rsp), %rsp /* discard */
- movl %ebx, (%rsp)
- popq %rbx
- movl %edx, (%rsp)
- popq %rdx
- movl %ecx, (%rsp)
- popq %rcx
- movl %eax, (%rsp)
- popq %rax
-
- /* Return */
- ret
-
- .endif
-
- /****************************************************************************
- * virt_call (real-mode near call, 16-bit real-mode near return address)
- *
- * Call a specific C function in 32-bit protected mode or 64-bit long
- * mode (as applicable). The prototype of the C function must be
- * void function ( struct i386_all_regs *ix86 );
- * ix86 will point to a struct containing the real-mode registers
- * at entry to virt_call().
- *
- * All registers will be preserved across virt_call(), unless the C
- * function explicitly overwrites values in ix86. Interrupt status
- * and GDT will also be preserved. Gate A20 will be enabled.
- *
- * Note that virt_call() does not rely on the real-mode stack
- * remaining intact in order to return, since everything relevant is
- * copied to the protected-mode stack for the duration of the call.
- * In particular, this means that a real-mode prefix can make a call
- * to main() which will return correctly even if the prefix's stack
- * gets vapourised during the Etherboot run. (The prefix cannot rely
- * on anything else on the stack being preserved, so should move any
- * critical data to registers before calling main()).
- *
- * Parameters:
- * function : 32-bit virtual address of function to call
- *
- * Example usage:
- * pushl $pxe_api_call
- * call virt_call
- * to call in to the C function
- * void pxe_api_call ( struct i386_all_regs *ix86 );
- ****************************************************************************
- */
- .struct 0
- VC_OFFSET_GDT: .space 6
- VC_OFFSET_IDT: .space 6
- .if64
- VC_OFFSET_PADDING64: .space 4 /* for alignment */
- VC_OFFSET_CR3: .space 4
- VC_OFFSET_CR4: .space 4
- VC_OFFSET_EMER: .space 8
- .endif
- VC_OFFSET_IX86: .space SIZEOF_I386_ALL_REGS
- VC_OFFSET_PADDING: .space 2 /* for alignment */
- VC_OFFSET_RETADDR: .space 2
- VC_OFFSET_PARAMS:
- VC_OFFSET_FUNCTION: .space 4
- VC_OFFSET_END:
- .previous
-
- .section ".text16.virt_call", "ax", @progbits
- .code16
- .globl virt_call
- virt_call:
- /* Preserve registers, flags and GDT on external RM stack */
- pushw %ss /* padding */
- pushfl
- pushal
- pushw %gs
- pushw %fs
- pushw %es
- pushw %ds
- pushw %ss
- pushw %cs
- subw $VC_OFFSET_IX86, %sp
- movw %sp, %bp
- sidt VC_OFFSET_IDT(%bp)
- sgdt VC_OFFSET_GDT(%bp)
-
- .if64 ; /* Preserve control registers, if applicable */
- movl $MSR_EFER, %ecx
- rdmsr
- movl %eax, (VC_OFFSET_EMER+0)(%bp)
- movl %edx, (VC_OFFSET_EMER+4)(%bp)
- movl %cr4, %eax
- movl %eax, VC_OFFSET_CR4(%bp)
- movl %cr3, %eax
- movl %eax, VC_OFFSET_CR3(%bp)
- .endif
- /* For sanity's sake, clear the direction flag as soon as possible */
- cld
-
- /* Switch to protected mode and move register dump to PM stack */
- movl $VC_OFFSET_END, %ecx
- pushl $VIRTUAL(vc_pmode)
- vc_jmp: jmp real_to_prot
- .section ".text.virt_call", "ax", @progbits
- .code32
- vc_pmode:
- /* Call function (in protected mode) */
- leal VC_OFFSET_IX86(%esp), %eax
- pushl %eax
- call *(VC_OFFSET_FUNCTION+4)(%esp)
- popl %eax /* discard */
-
- .if64 ; /* Switch to long mode */
- jmp 1f
- vc_lmode:
- call prot_to_long
- .code64
-
- /* Call function (in long mode) */
- leaq VC_OFFSET_IX86(%rsp), %rdi
- pushq %rdi
- movslq (VC_OFFSET_FUNCTION+8)(%rsp), %rax
- callq *%rax
- popq %rdi /* discard */
-
- /* Switch to protected mode */
- call long_to_prot
- 1: .code32
- .endif
- /* Switch to real mode and move register dump back to RM stack */
- movl $VC_OFFSET_END, %ecx
- movl %esp, %esi
- pushl $vc_rmode
- jmp prot_to_real
- .section ".text16.virt_call", "ax", @progbits
- .code16
- vc_rmode:
- .if64 ; /* Restore control registers, if applicable */
- movw %sp, %bp
- movl VC_OFFSET_CR3(%bp), %eax
- movl %eax, %cr3
- movl VC_OFFSET_CR4(%bp), %eax
- movl %eax, %cr4
- movl (VC_OFFSET_EMER+0)(%bp), %eax
- movl (VC_OFFSET_EMER+4)(%bp), %edx
- movl $MSR_EFER, %ecx
- wrmsr
- .endif
- /* Restore registers and flags and return */
- addw $( VC_OFFSET_IX86 + 4 /* also skip %cs and %ss */ ), %sp
- popw %ds
- popw %es
- popw %fs
- popw %gs
- popal
- /* popal skips %esp. We therefore want to do "movl -20(%sp),
- * %esp", but -20(%sp) is not a valid 80386 expression.
- * Fortunately, prot_to_real() zeroes the high word of %esp, so
- * we can just use -20(%esp) instead.
- */
- addr32 movl -20(%esp), %esp
- popfl
- popw %ss /* padding */
-
- /* Return and discard function parameters */
- ret $( VC_OFFSET_END - VC_OFFSET_PARAMS )
-
-
- /* Protected-mode jump target */
- .equ vc_jmp_offset, ( vc_jmp - 4 )
-
- /****************************************************************************
- * real_call (protected-mode near call, 32-bit virtual return address)
- * real_call (long-mode near call, 64-bit virtual return address)
- *
- * Call a real-mode function from protected-mode or long-mode code.
- *
- * The non-segment register values will be passed directly to the
- * real-mode code. The segment registers will be set as per
- * prot_to_real. The non-segment register values set by the real-mode
- * function will be passed back to the protected-mode or long-mode
- * caller. A result of this is that this routine cannot be called
- * directly from C code, since it clobbers registers that the C ABI
- * expects the callee to preserve.
- *
- * librm.h defines a convenient macro REAL_CODE() for using real_call.
- * See librm.h and realmode.h for details and examples.
- *
- * Parameters:
- * function : offset within .text16 of real-mode function to call
- *
- * Returns: none
- ****************************************************************************
- */
- .struct 0
- RC_OFFSET_REGS: .space SIZEOF_I386_REGS
- RC_OFFSET_REGS_END:
- .if64
- RC_OFFSET_LREGS: .space SIZEOF_X86_64_REGS
- RC_OFFSET_LREG_RETADDR: .space SIZEOF_ADDR
- .endif
- RC_OFFSET_RETADDR: .space SIZEOF_ADDR
- RC_OFFSET_PARAMS:
- RC_OFFSET_FUNCTION: .space SIZEOF_ADDR
- RC_OFFSET_END:
- .previous
-
- .section ".text.real_call", "ax", @progbits
- .CODE_DEFAULT
- .globl real_call
- real_call:
- .if64 ; /* Preserve registers and switch to protected mode, if applicable */
- call long_preserve_regs
- call long_to_prot
- .code32
- .endif
- /* Create register dump and function pointer copy on PM stack */
- pushal
- pushl RC_OFFSET_FUNCTION(%esp)
-
- /* Switch to real mode and move register dump to RM stack */
- movl $( RC_OFFSET_REGS_END + 4 /* function pointer copy */ ), %ecx
- pushl $rc_rmode
- movl $VIRTUAL(rm_default_gdtr_idtr), %esi
- jmp prot_to_real
- .section ".text16.real_call", "ax", @progbits
- .code16
- rc_rmode:
- /* Call real-mode function */
- popl rc_function
- popal
- call *rc_function
- pushal
-
- /* For sanity's sake, clear the direction flag as soon as possible */
- cld
-
- /* Switch to protected mode and move register dump back to PM stack */
- movl $RC_OFFSET_REGS_END, %ecx
- pushl $VIRTUAL(rc_pmode)
- jmp real_to_prot
- .section ".text.real_call", "ax", @progbits
- .code32
- rc_pmode:
- /* Restore registers */
- popal
-
- .if64 ; /* Switch to long mode and restore registers, if applicable */
- call prot_to_long
- .code64
- call long_restore_regs
- .endif
- /* Return and discard function parameters */
- ret $( RC_OFFSET_END - RC_OFFSET_PARAMS )
-
-
- /* Function vector, used because "call xx(%sp)" is not a valid
- * 16-bit expression.
- */
- .section ".bss16.rc_function", "aw", @nobits
- rc_function: .word 0, 0
-
- /* Default real-mode global and interrupt descriptor table registers */
- .section ".data.rm_default_gdtr_idtr", "aw", @progbits
- rm_default_gdtr_idtr:
- .word 0 /* Global descriptor table limit */
- .long 0 /* Global descriptor table base */
- .word 0x03ff /* Interrupt descriptor table limit */
- .long 0 /* Interrupt descriptor table base */
-
- /****************************************************************************
- * phys_call (protected-mode near call, 32-bit virtual return address)
- * phys_call (long-mode near call, 64-bit virtual return address)
- *
- * Call a function with flat 32-bit physical addressing
- *
- * The non-segment register values will be passed directly to the
- * function. The segment registers will be set for flat 32-bit
- * physical addressing. The non-segment register values set by the
- * function will be passed back to the caller.
- *
- * librm.h defines a convenient macro PHYS_CODE() for using phys_call.
- *
- * Parameters:
- * function : virtual (sic) address of function to call
- *
- ****************************************************************************
- */
- .struct 0
- .if64
- PHC_OFFSET_LREGS: .space SIZEOF_X86_64_REGS
- PHC_OFFSET_LREG_RETADDR:.space SIZEOF_ADDR
- .endif
- PHC_OFFSET_RETADDR: .space SIZEOF_ADDR
- PHC_OFFSET_PARAMS:
- PHC_OFFSET_FUNCTION: .space SIZEOF_ADDR
- PHC_OFFSET_END:
- .previous
-
- .section ".text.phys_call", "ax", @progbits
- .CODE_DEFAULT
- .globl phys_call
- phys_call:
- .if64 ; /* Preserve registers and switch to protected mode, if applicable */
- call long_preserve_regs
- call long_to_prot
- .code32
- .endif
- /* Adjust function pointer to a physical address */
- pushl %ebp
- movl VIRTUAL(virt_offset), %ebp
- addl %ebp, ( PHC_OFFSET_FUNCTION + 4 /* saved %ebp */ )(%esp)
- popl %ebp
-
- /* Switch to physical addresses */
- call prot_to_phys
-
- /* Call function */
- call *PHC_OFFSET_FUNCTION(%esp)
-
- /* For sanity's sake, clear the direction flag as soon as possible */
- cld
-
- /* Switch to virtual addresses */
- call phys_to_prot
-
- .if64 ; /* Switch to long mode and restore registers, if applicable */
- call prot_to_long
- .code64
- call long_restore_regs
- .endif
- /* Return and discard function parameters */
- ret $( PHC_OFFSET_END - PHC_OFFSET_PARAMS )
-
- /****************************************************************************
- * phys_to_long (protected-mode near call, 32-bit physical return address)
- *
- * Used by COMBOOT.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.phys_to_long", "ax", @progbits
- .code32
- phys_to_long:
-
- /* Switch to virtual addresses */
- call phys_to_prot
-
- /* Convert to 32-bit virtual return address */
- pushl %eax
- movl VIRTUAL(virt_offset), %eax
- subl %eax, 4(%esp)
- popl %eax
-
- /* Switch to long mode and return */
- jmp prot_to_long
-
- /* Expose as _phys_to_virt for use by COMBOOT */
- .globl _phys_to_virt
- .equ _phys_to_virt, phys_to_long
-
- .endif
-
- /****************************************************************************
- * long_to_phys (long-mode near call, 64-bit virtual return address)
- *
- * Used by COMBOOT.
- *
- ****************************************************************************
- */
- .if64
-
- .section ".text.long_to_phys", "ax", @progbits
- .code64
- long_to_phys:
-
- /* Switch to protected mode */
- call long_to_prot
- .code32
-
- /* Convert to 32-bit virtual return address */
- popl (%esp)
-
- /* Switch to physical addresses and return */
- jmp prot_to_phys
-
- /* Expose as _virt_to_phys for use by COMBOOT */
- .globl _virt_to_phys
- .equ _virt_to_phys, long_to_phys
-
- .endif
-
- /****************************************************************************
- * flatten_real_mode (real-mode near call)
- *
- * Switch to flat real mode
- *
- ****************************************************************************
- */
- .section ".text16.flatten_real_mode", "ax", @progbits
- .code16
- .globl flatten_real_mode
- flatten_real_mode:
- /* Modify GDT to use flat real mode */
- movb $0x8f, real_cs + 6
- movb $0x8f, real_ds + 6
- /* Call dummy protected-mode function */
- virtcall flatten_dummy
- /* Restore GDT */
- movb $0x00, real_cs + 6
- movb $0x00, real_ds + 6
- /* Return */
- ret
-
- .section ".text.flatten_dummy", "ax", @progbits
- .CODE_DEFAULT
- flatten_dummy:
- ret
-
- /****************************************************************************
- * Interrupt wrapper
- *
- * Used by the protected-mode and long-mode interrupt vectors to call
- * the interrupt() function.
- *
- * May be entered with either physical or virtual stack segment.
- ****************************************************************************
- */
- .section ".text.interrupt_wrapper", "ax", @progbits
- .code32
- .globl interrupt_wrapper
- interrupt_wrapper:
- /* Preserve registers (excluding already-saved %eax and
- * otherwise unused registers which are callee-save for both
- * 32-bit and 64-bit ABIs).
- */
- pushl %ebx
- pushl %ecx
- pushl %edx
- pushl %esi
- pushl %edi
-
- /* Expand IRQ number to whole %eax register */
- movzbl %al, %eax
-
- .if64 ; /* Skip transition to long mode, if applicable */
- movw %cs, %bx
- cmpw $LONG_CS, %bx
- je 1f
- .endif
- /* Preserve segment registers and original %esp */
- pushl %ds
- pushl %es
- pushl %fs
- pushl %gs
- pushl %ss
- pushl %esp
-
- /* Switch to virtual addressing */
- call intr_to_prot
- .if64
- /* Switch to long mode */
- call prot_to_long
- .code64
-
- 1: /* Preserve long-mode caller-save registers */
- pushq %r8
- pushq %r9
- pushq %r10
- pushq %r11
-
- /* Expand IRQ number to whole %rdi register */
- movl %eax, %edi
- .endif
- /* Call interrupt handler */
- call interrupt
- .if64
- /* Restore long-mode caller-save registers */
- popq %r11
- popq %r10
- popq %r9
- popq %r8
-
- /* Skip transition back to protected mode, if applicable */
- cmpw $LONG_CS, %bx
- je 1f
-
- /* Switch to protected mode */
- call long_to_prot
- .code32
- cmpw $LONG_CS, %bx
- .endif
- /* Restore segment registers and original %esp */
- lss (%esp), %esp
- popl %ss
- popl %gs
- popl %fs
- popl %es
- popl %ds
-
- 1: /* Restore registers */
- popl %edi
- popl %esi
- popl %edx
- popl %ecx
- popl %ebx
- popl %eax
-
- /* Return from interrupt (with REX prefix if required) */
- .if64 ; jne 1f ; .byte 0x48 ; .endif
- 1: iret
-
- /****************************************************************************
- * Page tables
- *
- ****************************************************************************
- */
- .section ".pages", "aw", @nobits
- .align SIZEOF_PT
-
- /* Page map level 4 entries (PML4Es)
- *
- * This comprises
- *
- * - PML4E[0x000] covering [0x0000000000000000-0x0000007fffffffff]
- * - PML4E[0x1ff] covering [0xffffff8000000000-0xffffffffffffffff]
- *
- * These point to the PDPT. This creates some aliased
- * addresses within unused portions of the 64-bit address
- * space, but allows us to use just a single PDPT.
- *
- * - PDE[...] covering arbitrary 2MB portions of I/O space
- *
- * These are 2MB pages created by ioremap() to cover I/O
- * device addresses.
- */
- pml4e:
- .space SIZEOF_PT
- .size pml4e, . - pml4e
-
- .globl io_pages
- .equ io_pages, pml4e
-
- /* Page directory pointer table entries (PDPTEs)
- *
- * This comprises:
- *
- * - PDPTE[0x000] covering [0x0000000000000000-0x000000003fffffff]
- * - PDPTE[0x001] covering [0x0000000040000000-0x000000007fffffff]
- * - PDPTE[0x002] covering [0x0000000080000000-0x00000000bfffffff]
- * - PDPTE[0x003] covering [0x00000000c0000000-0x00000000ffffffff]
- *
- * These point to the appropriate page directories (in pde_low)
- * used to identity-map the whole of the 32-bit address space.
- *
- * - PDPTE[0x004] covering [0x0000000100000000-0x000000013fffffff]
- *
- * This points back to the PML4, allowing the PML4 to be
- * (ab)used to hold 2MB pages used for I/O device addresses.
- *
- * - PDPTE[0x1ff] covering [0xffffffffc0000000-0xffffffffffffffff]
- *
- * This points back to the PDPT itself, allowing the PDPT to be
- * (ab)used to hold PDEs covering .textdata.
- *
- * - PDE[N-M] covering [_textdata,_end)
- *
- * These are used to point to the page tables (in pte_textdata)
- * used to map our .textdata section. Note that each PDE
- * covers 2MB, so we are likely to use only a single PDE in
- * practice.
- */
- pdpte:
- .space SIZEOF_PT
- .size pdpte, . - pdpte
- .equ pde_textdata, pdpte /* (ab)use */
-
- /* Page directory entries (PDEs) for the low 4GB
- *
- * This comprises 2048 2MB pages to identity-map the whole of
- * the 32-bit address space.
- */
- pde_low:
- .equ PDE_LOW_PTES, ( SIZEOF_LOW_4GB / SIZEOF_2MB_PAGE )
- .equ PDE_LOW_PTS, ( ( PDE_LOW_PTES * SIZEOF_PTE ) / SIZEOF_PT )
- .space ( PDE_LOW_PTS * SIZEOF_PT )
- .size pde_low, . - pde_low
-
- /* Page table entries (PTEs) for .textdata
- *
- * This comprises enough 4kB pages to map the whole of
- * .textdata. The required number of PTEs is calculated by
- * the linker script.
- *
- * Note that these mappings do not cover the PTEs themselves.
- * This does not matter, since code running with paging
- * enabled never needs to access these PTEs.
- */
- pte_textdata:
- /* Allocated by linker script; must be at the end of .textdata */
-
- .section ".bss.pml4", "aw", @nobits
- pml4: .long 0
-
- /****************************************************************************
- * init_pages (protected-mode near call)
- *
- * Initialise the page tables ready for long mode.
- *
- * Parameters:
- * %edi : virt_offset
- ****************************************************************************
- */
- .section ".text.init_pages", "ax", @progbits
- .code32
- init_pages:
- /* Initialise PML4Es for low 4GB and negative 2GB */
- leal ( VIRTUAL(pdpte) + ( PG_P | PG_RW | PG_US ) )(%edi), %eax
- movl %eax, VIRTUAL(pml4e)
- movl %eax, ( VIRTUAL(pml4e) + SIZEOF_PT - SIZEOF_PTE )
-
- /* Initialise PDPTE for negative 1GB */
- movl %eax, ( VIRTUAL(pdpte) + SIZEOF_PT - SIZEOF_PTE )
-
- /* Initialise PDPTE for I/O space */
- leal ( VIRTUAL(pml4e) + ( PG_P | PG_RW | PG_US ) )(%edi), %eax
- movl %eax, ( VIRTUAL(pdpte) + ( PDE_LOW_PTS * SIZEOF_PTE ) )
-
- /* Initialise PDPTEs for low 4GB */
- movl $PDE_LOW_PTS, %ecx
- leal ( VIRTUAL(pde_low) + ( PDE_LOW_PTS * SIZEOF_PT ) + \
- ( PG_P | PG_RW | PG_US ) )(%edi), %eax
- 1: subl $SIZEOF_PT, %eax
- movl %eax, ( VIRTUAL(pdpte) - SIZEOF_PTE )(,%ecx,SIZEOF_PTE)
- loop 1b
-
- /* Initialise PDEs for low 4GB */
- movl $PDE_LOW_PTES, %ecx
- leal ( 0 + ( PG_P | PG_RW | PG_US | PG_PS ) ), %eax
- 1: subl $SIZEOF_2MB_PAGE, %eax
- movl %eax, ( VIRTUAL(pde_low) - SIZEOF_PTE )(,%ecx,SIZEOF_PTE)
- loop 1b
-
- /* Initialise PDEs for .textdata */
- movl $_textdata_pdes, %ecx
- leal ( VIRTUAL(_etextdata) + ( PG_P | PG_RW | PG_US ) )(%edi), %eax
- movl $VIRTUAL(_textdata), %ebx
- shrl $( SIZEOF_2MB_PAGE_LOG2 - SIZEOF_PTE_LOG2 ), %ebx
- andl $( SIZEOF_PT - 1 ), %ebx
- 1: subl $SIZEOF_PT, %eax
- movl %eax, (VIRTUAL(pde_textdata) - SIZEOF_PTE)(%ebx,%ecx,SIZEOF_PTE)
- loop 1b
-
- /* Initialise PTEs for .textdata */
- movl $_textdata_ptes, %ecx
- leal ( VIRTUAL(_textdata) + ( PG_P | PG_RW | PG_US ) )(%edi), %eax
- addl $_textdata_paged_len, %eax
- 1: subl $SIZEOF_4KB_PAGE, %eax
- movl %eax, ( VIRTUAL(pte_textdata) - SIZEOF_PTE )(,%ecx,SIZEOF_PTE)
- loop 1b
-
- /* Record PML4 physical address */
- leal VIRTUAL(pml4e)(%edi), %eax
- movl %eax, VIRTUAL(pml4)
-
- /* Return */
- ret
|