mirror of
https://git.proxmox.com/git/grub2
synced 2025-10-31 15:26:57 +00:00
08bcec5020
* include/grub/i386/relocator.h (grub_relocator16_state): New member ebp. * grub-core/lib/i386/relocator.c (grub_relocator16_ebp): New extern variable. (grub_relocator16_boot): Handle %ebp. * grub-core/lib/i386/relocator16.S: Likewise. * grub-core/loader/i386/pc/freedos.c: Load BPB to pass kernel which partition to load from. Check that kernel file is not too large. Set register dl to BIOS unit number as well.
329 lines
7.0 KiB
ArmAsm
329 lines
7.0 KiB
ArmAsm
/*
|
|
* GRUB -- GRand Unified Bootloader
|
|
* Copyright (C) 2009,2010 Free Software Foundation, Inc.
|
|
*
|
|
* GRUB is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* GRUB is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* The code segment of the protected mode. */
|
|
#define CODE_SEGMENT 0x08
|
|
|
|
/* The data segment of the protected mode. */
|
|
#define DATA_SEGMENT 0x10
|
|
|
|
#define PSEUDO_REAL_CSEG 0x18
|
|
|
|
#define PSEUDO_REAL_DSEG 0x20
|
|
|
|
#include <grub/i386/relocator_private.h>
|
|
|
|
#include "relocator_common.S"
|
|
|
|
.p2align 4 /* force 16-byte alignment */
|
|
|
|
VARIABLE(grub_relocator16_start)
|
|
PREAMBLE
|
|
|
|
#ifdef __APPLE__
|
|
LOCAL(cs_base_bytes12_offset) = LOCAL (cs_base_bytes12) - LOCAL (base)
|
|
LOCAL(cs_base_byte3_offset) = LOCAL (cs_base_byte3) - LOCAL (base)
|
|
movl %esi, %eax
|
|
movw %ax, (LOCAL(cs_base_bytes12_offset)) (RSI, 1)
|
|
shrl $16, %eax
|
|
movb %al, (LOCAL (cs_base_byte3_offset)) (RSI, 1)
|
|
#else
|
|
movl %esi, %eax
|
|
movw %ax, (LOCAL (cs_base_bytes12) - LOCAL (base)) (RSI, 1)
|
|
shrl $16, %eax
|
|
movb %al, (LOCAL (cs_base_byte3) - LOCAL (base)) (RSI, 1)
|
|
#endif
|
|
|
|
RELOAD_GDT
|
|
.code32
|
|
/* Update other registers. */
|
|
movl $DATA_SEGMENT, %eax
|
|
movl %eax, %ds
|
|
movl %eax, %es
|
|
movl %eax, %fs
|
|
movl %eax, %gs
|
|
movl %eax, %ss
|
|
|
|
DISABLE_PAGING
|
|
|
|
#ifdef __x86_64__
|
|
/* Disable amd64. */
|
|
movl $GRUB_MEMORY_CPU_AMD64_MSR, %ecx
|
|
rdmsr
|
|
andl $(~GRUB_MEMORY_CPU_AMD64_MSR_ON), %eax
|
|
wrmsr
|
|
#endif
|
|
|
|
/* Turn off PAE. */
|
|
movl %cr4, %eax
|
|
andl $(~GRUB_MEMORY_CPU_CR4_PAE_ON), %eax
|
|
movl %eax, %cr4
|
|
|
|
/* Update other registers. */
|
|
movl $PSEUDO_REAL_DSEG, %eax
|
|
movl %eax, %ds
|
|
movl %eax, %es
|
|
movl %eax, %fs
|
|
movl %eax, %gs
|
|
movl %eax, %ss
|
|
|
|
movl %esi, %eax
|
|
shrl $4, %eax
|
|
#ifdef __APPLE__
|
|
LOCAL(segment_offset) = LOCAL (segment) - LOCAL (base)
|
|
LOCAL(idt_offset) = LOCAL(relocator16_idt) - LOCAL (base)
|
|
LOCAL(cont2_offset) = LOCAL (cont2) - LOCAL(base)
|
|
movw %ax, LOCAL(segment_offset) (%esi, 1)
|
|
lidt LOCAL(idt_offset) (%esi, 1)
|
|
|
|
/* jump to a 16 bit segment */
|
|
ljmp $PSEUDO_REAL_CSEG, $(LOCAL(cont2_offset))
|
|
#else
|
|
movw %ax, (LOCAL (segment) - LOCAL (base)) (%esi, 1)
|
|
|
|
lidt (EXT_C(grub_relocator16_idt) - LOCAL (base)) (%esi, 1)
|
|
|
|
/* jump to a 16 bit segment */
|
|
ljmp $PSEUDO_REAL_CSEG, $(LOCAL (cont2) - LOCAL(base))
|
|
#endif
|
|
LOCAL(cont2):
|
|
.code16
|
|
|
|
/* clear the PE bit of CR0 */
|
|
movl %cr0, %eax
|
|
andl $(~GRUB_MEMORY_CPU_CR0_PE_ON), %eax
|
|
movl %eax, %cr0
|
|
|
|
/* flush prefetch queue, reload %cs */
|
|
/* ljmp */
|
|
.byte 0xea
|
|
#ifdef __APPLE__
|
|
LOCAL(cont3_offset) = LOCAL(cont3) - LOCAL(base)
|
|
.word LOCAL(cont3_offset)
|
|
#else
|
|
.word LOCAL(cont3)-LOCAL(base)
|
|
#endif
|
|
LOCAL(segment):
|
|
.word 0
|
|
|
|
LOCAL(cont3):
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_keep_a20_enabled)
|
|
.word 0
|
|
|
|
test %ax, %ax
|
|
jnz LOCAL(gate_a20_done)
|
|
|
|
movw %cs, %ax
|
|
movw %ax, %ss
|
|
#ifdef __APPLE__
|
|
LOCAL(relocator16_end_offset) = LOCAL(relocator16_end) - LOCAL(base)
|
|
leaw LOCAL(relocator16_end_offset), %sp
|
|
#else
|
|
leaw LOCAL(relocator16_end) - LOCAL(base), %sp
|
|
#endif
|
|
addw $GRUB_RELOCATOR16_STACK_SIZE, %sp
|
|
|
|
/* second, try a BIOS call */
|
|
movw $0x2400, %ax
|
|
int $0x15
|
|
|
|
call LOCAL(gate_a20_check_state)
|
|
testb %al, %al
|
|
jz LOCAL(gate_a20_done)
|
|
|
|
/*
|
|
* In macbook, the keyboard test would hang the machine, so we move
|
|
* this forward.
|
|
*/
|
|
/* fourth, try the system control port A */
|
|
inb $0x92
|
|
andb $(~0x03), %al
|
|
outb $0x92
|
|
|
|
/* When turning off Gate A20, do not check the state strictly,
|
|
because a failure is not fatal usually, and Gate A20 is always
|
|
on some modern machines. */
|
|
jmp LOCAL(gate_a20_done)
|
|
|
|
LOCAL(gate_a20_check_state):
|
|
/* iterate the checking for a while */
|
|
movw $100, %cx
|
|
1:
|
|
xorw %ax, %ax
|
|
movw %ax, %ds
|
|
decw %ax
|
|
movw %ax, %es
|
|
xorw %ax, %ax
|
|
|
|
movw $0x8000, %ax
|
|
/* compare the byte at ADDR with that at 0x100000 + ADDR */
|
|
movw %ax, %si
|
|
addw $0x10, %ax
|
|
movw %ax, %di
|
|
|
|
/* save the original byte in DL */
|
|
movb %ds:(%si), %dl
|
|
movb %es:(%di), %al
|
|
/* try to set one less value at ADDR */
|
|
movb %al, %dh
|
|
decb %dh
|
|
movb %dh, %ds:(%si)
|
|
/* serialize */
|
|
outb %al, $0x80
|
|
outb %al, $0x80
|
|
/* obtain the value at 0x100000 + ADDR in CH */
|
|
movb %es:(%di), %dh
|
|
/* this result is 1 if A20 is on or 0 if it is off */
|
|
subb %dh, %al
|
|
xorb $1, %al
|
|
/* restore the original */
|
|
movb %dl, %ds:(%si)
|
|
|
|
testb %al, %al
|
|
jz LOCAL(gate_a20_done)
|
|
loop 1b
|
|
2:
|
|
ret
|
|
|
|
LOCAL(gate_a20_done):
|
|
/* we are in real mode now
|
|
* set up the real mode segment registers : DS, SS, ES
|
|
*/
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_ds)
|
|
.word 0
|
|
movw %ax, %ds
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_es)
|
|
.word 0
|
|
movw %ax, %es
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_fs)
|
|
.word 0
|
|
movw %ax, %fs
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_gs)
|
|
.word 0
|
|
movw %ax, %gs
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_ss)
|
|
.word 0
|
|
movw %ax, %ss
|
|
|
|
/* movw imm16, %ax. */
|
|
.byte 0xb8
|
|
VARIABLE(grub_relocator16_sp)
|
|
.word 0
|
|
movzwl %ax, %esp
|
|
|
|
/* movw imm32, %eax. */
|
|
.byte 0x66, 0xb8
|
|
VARIABLE(grub_relocator16_esi)
|
|
.long 0
|
|
movl %eax, %esi
|
|
|
|
/* movw imm32, %edx. */
|
|
.byte 0x66, 0xba
|
|
VARIABLE(grub_relocator16_edx)
|
|
.long 0
|
|
|
|
/* movw imm32, %ebx. */
|
|
.byte 0x66, 0xbb
|
|
VARIABLE(grub_relocator16_ebx)
|
|
.long 0
|
|
|
|
/* movl imm32, %ebp. */
|
|
.byte 0x66, 0xbd
|
|
VARIABLE(grub_relocator16_ebp)
|
|
.long 0
|
|
|
|
/* Cleared direction flag is of no problem with any current
|
|
payload and makes this implementation easier. */
|
|
cld
|
|
|
|
/* ljmp */
|
|
.byte 0xea
|
|
VARIABLE(grub_relocator16_ip)
|
|
.word 0
|
|
VARIABLE(grub_relocator16_cs)
|
|
.word 0
|
|
|
|
.code32
|
|
|
|
/* GDT. Copied from loader/i386/linux.c. */
|
|
.p2align 4
|
|
LOCAL(gdt):
|
|
.word 0, 0
|
|
.byte 0, 0, 0, 0
|
|
|
|
/* -- code segment --
|
|
* base = 0x00000000, limit = 0xFFFFF (4 KiB Granularity), present
|
|
* type = 32bit code execute/read, DPL = 0
|
|
*/
|
|
.word 0xFFFF, 0
|
|
.byte 0, 0x9A, 0xCF, 0
|
|
|
|
/* -- data segment --
|
|
* base = 0x00000000, limit 0xFFFFF (4 KiB Granularity), present
|
|
* type = 32 bit data read/write, DPL = 0
|
|
*/
|
|
.word 0xFFFF, 0
|
|
.byte 0, 0x92, 0xCF, 0
|
|
|
|
/* -- 16 bit real mode CS --
|
|
* base = 0x00000000, limit 0x0FFFF (1 B Granularity), present
|
|
* type = 16 bit code execute/read only/conforming, DPL = 0
|
|
*/
|
|
.word 0xFFFF
|
|
LOCAL(cs_base_bytes12):
|
|
.word 0
|
|
LOCAL(cs_base_byte3):
|
|
.byte 0
|
|
|
|
.byte 0x9E, 0, 0
|
|
|
|
/* -- 16 bit real mode DS --
|
|
* base = 0x00000000, limit 0x0FFFF (1 B Granularity), present
|
|
* type = 16 bit data read/write, DPL = 0
|
|
*/
|
|
.word 0xFFFF, 0
|
|
.byte 0, 0x92, 0, 0
|
|
LOCAL(gdt_end):
|
|
|
|
#ifdef __APPLE__
|
|
LOCAL(relocator16_idt):
|
|
#endif
|
|
VARIABLE(grub_relocator16_idt)
|
|
.word 0
|
|
.long 0
|
|
LOCAL(relocator16_end):
|
|
VARIABLE(grub_relocator16_end)
|
|
.byte 0
|