существует ряд проблем, но в целом ваш код сборки работает. Я написал ответ StackOverflow, который имеет советы для общая разработка загрузчика.

не предполагайте, что регистры сегментов установлены правильно

исходный код в вашем вопросе не установил SS регистр сегмента стека. Совет №1 я даю:

когда BIOS переходит на ваш код, вы не можете полагаться на CS, DS, ES, SS, SP регистры, имеющие допустимые или ожидаемые значения. Они должны быть настроены соответствующим образом при запуске загрузчика.

Если вам нужно ES он также должен быть установлен. Хотя в вашем коде это не так (за исключением функции print_string, которую я рассмотрю позже).

правильно определить GDT

самая большая ошибка, которая помешала бы вам далеко уйти в защищенный режим, заключалась в том, что вы настроили глобальная таблица дескрипторов (GDT) в gdt.inc начиная с:

gdt_start:
    dd 0                ; null descriptor--just fill 8 bytes    dd 0

каждый глобальный дескриптор должен быть 8 байт, но dd 0 определяет только 4 байта (двойное слово). Должно быть:

gdt_start:
    dd 0                ; null descriptor--just fill 8 bytes    
    dd 0

это на самом деле кажется, что второй dd 0 был случайно добавлен в конец комментария к предыдущей строке.

когда в 16-битном реальном режиме Не используйте 32-битный код

вы написали какую-то print_string код, но он 32-битный код:

[bits 32]
    ; prints a null - terminated string pointed to by EBX
print_string :
    pusha
    mov edx , VIDEO_MEMORY ; Set edx to the start of vid mem.
print_string_loop :
    mov al , [ ebx ] ; Store the char at EBX in AL
    mov ah , WHITE_ON_BLACK ; Store the attributes in AH
    cmp al , 0 ; if (al == 0) , at end of string , so
    je print_string_done ; jump to done
    mov [edx] , ax ; Store char and attributes at current
        ; character cell.
    add ebx , 1 ; Increment EBX to the next char in string.
    add edx , 2 ; Move to next character cell in vid mem.
    jmp print_string_loop ; loop around to print the next char.
print_string_done :
    popa
    ret ; Return from the function

вы называете print_string как обработчик ошибок в 16-битном коде, поэтому то, что вы здесь делаете, скорее всего, приведет к перезагрузке компьютера. Нельзя использовать 32-разрядные регистры и адресацию. Код может быть 16-битным с некоторыми корректировками:

    ; prints a null - terminated string pointed to by EBX
print_string :
    pusha
    push es                   ;Save ES on stack and restore when we finish

    push VIDEO_MEMORY_SEG     ;Video mem segment 0xb800
    pop es
    xor di, di                ;Video mem offset (start at 0)
print_string_loop :
    mov al , [ bx ] ; Store the char at BX in AL
    mov ah , WHITE_ON_BLACK ; Store the attributes in AH
    cmp al , 0 ; if (al == 0) , at end of string , so
    je print_string_done ; jump to done
    mov word [es:di], ax ; Store char and attributes at current
        ; character cell.
    add bx , 1 ; Increment BX to the next char in string.
    add di , 2 ; Move to next character cell in vid mem.
    jmp print_string_loop ; loop around to print the next char.

print_string_done :
    pop es                    ;Restore ES that was saved on entry
    popa
    ret ; Return from the function

основное отличие (в 16-битном коде) заключается в том, что мы больше не используем EAX и EDX 32-битные регистры. Для доступа к видеопамяти @ 0xb8000 нам нужно использовать пару segment: offset, которая представляет то же самое. 0xb8000 может быть представлен как сегмент: offset 0xb800:от 0x0 (вычисляется как (0xb8000xb8000 физический адрес. Мы можем использовать эти знания для хранения b800 на ES регистрация и использование DI регистрация в качестве смещения для обновления видеопамяти. Теперь мы используем:

mov word [es:di], ax

переместить слово в видеопамять.

сборка и связывание ядра и загрузчика

одна из проблем при построении ядра заключается в том, что вы неправильно генерируете плоский двоичный образ, который можно загрузить в память напрямую. А не с помощью gcc -ffreestanding -o kernel.bin kernel.c я рекомендую сделать это таким образом:

gcc -g -m32 -c -ffreestanding -o kernel.o kernel.c -lgcc
ld -melf_i386 -Tlinker.ld -nostdlib --nmagic -o kernel.elf kernel.o
objcopy -O binary kernel.elf kernel.bin

это собирает ядра.c to ядра.o с отладочной информации (-g). Затем компоновщик принимает ядра.o (32-бит эльф binary) и производит эльф исполняемый файл называется ядра.эльф (этот файл будет удобен, если вы хотите отладить свое ядро). Затем мы используем objcopy взять исполняемый файл ELF32 ядра.эльф и преобразовать его в плоское бинарное изображение ядра.бин который может быть загружен BIOS. Ключевая вещь, чтобы отметить, что с -Tlinker.ld вариант мы просим LD(компоновщик) для чтения параметров из файл линкер.ld . Это просто linker.ld вы можете использовать, чтобы начать работу:

OUTPUT_FORMAT(elf32-i386)
ENTRY(main)

SECTIONS
{
    . = 0x9000;
    .text : { *(.text) }
    .data : { *(.data) }
    .bss  : { *(.bss) *(COMMON) }
}

здесь следует отметить, что . = 0x9000 говорит компоновщику, что он должен создать исполняемый файл, который будет загружен по адресу памяти 0x9000 . 0x9000 где вы, кажется, разместили свое ядро в своем вопросе. Остальные строки делают доступными C разделы, которые необходимо будет включить в ядро для работы правильно.

я рекомендую делать что-то подобное при использовании NASM так вместо того, чтобы делать nasm -f bin -o boot.bin bootloader.asm сделать это так:

nasm -g -f elf32 -F dwarf -o boot.o bootloader.asm
ld -melf_i386 -Ttext=0x7c00 -nostdlib --nmagic -o boot.elf boot.o
objcopy -O binary boot.elf boot.bin

это похоже на компиляцию C ядра. Мы не используем сценарий компоновщика здесь, но мы говорим компоновщику создать наш код, предполагая, что код (загрузчик) будет загружен в 0x7c00 .

для этого, чтобы работать вам нужно будет удалить эта строка из загрузчика.asm :

[ORG 0x7c00]

очистка ядра (kernel.c)

изменить ядра.c для:

/* This code will be placed at the beginning of the object by the linker script */    
__asm__ (".pushsection .text.start\r\n" \
         "jmp main\r\n" \
         ".popsection\r\n"
         );

/* Place main as the first function defined in kernel.c so
 * that it will be at the entry point where our bootloader
 * will call. In our case it will be at 0x9000 */

int main(){
    /* Do Stuff Here*/

    return 0; /* return back to bootloader */
}

на загрузчика.asm мы должны позвонить main функция (которая будет размещена на 0x9000), а не прыгать на нее. Вместо:

jmp 0x9000

меняем его на:

    call 0x9000
    cli
loopend:                ;Infinite loop when finished
    hlt
    jmp loopend

код после вызова будет выполняться, когда C функция main возвращается. Это простой цикл, который эффективно остановит процессор и останется таким до бесконечности, так как нам некуда возвращаться.

Код После Принятия Всех Рекомендуемых Изменения

загрузчика.asm:

[bits 16]

global _start
_start:
    cli
    xor ax, ax
    mov ds, ax
    mov es, ax
    mov ss, ax
    mov sp, 0x8000      ; Stack pointer at SS:SP = 0x0000:0x8000
    mov [BOOT_DRIVE], dl; Boot drive passed to us by the BIOS
    mov dh, 17          ; Number of sectors (kernel.bin) to read from disk
                        ; 17*512 allows for a kernel.bin up to 8704 bytes
    mov bx, 0x9000      ; Load Kernel to ES:BX = 0x0000:0x9000

    call load_kernel
    call enable_A20

;   call graphics_mode  ; Uncomment if you want to switch to graphics mode 0x13
    lgdt [gdtr]
    mov eax, cr0
    or al, 1
    mov cr0, eax
    jmp CODE_SEG:init_pm

graphics_mode:
    mov ax, 0013h
    int 10h
    ret

load_kernel:
                        ; load DH sectors to ES:BX from drive DL
    push dx             ; Store DX on stack so later we can recall
                        ; how many sectors were request to be read ,
                        ; even if it is altered in the meantime
    mov ah , 0x02       ; BIOS read sector function
    mov al , dh         ; Read DH sectors
    mov ch , 0x00       ; Select cylinder 0
    mov dh , 0x00       ; Select head 0
    mov cl , 0x02       ; Start reading from second sector ( i.e.
                        ; after the boot sector )
    int 0x13            ; BIOS interrupt
    jc disk_error       ; Jump if error ( i.e. carry flag set )
    pop dx              ; Restore DX from the stack
    cmp dh , al         ; if AL ( sectors read ) != DH ( sectors expected )
    jne disk_error      ; display error message
    ret
disk_error :
    mov bx , ERROR_MSG
    call print_string
    hlt

; prints a null - terminated string pointed to by EDX
print_string :
    pusha
    push es                   ;Save ES on stack and restore when we finish

    push VIDEO_MEMORY_SEG     ;Video mem segment 0xb800
    pop es
    xor di, di                ;Video mem offset (start at 0)
print_string_loop :
    mov al , [ bx ] ; Store the char at BX in AL
    mov ah , WHITE_ON_BLACK ; Store the attributes in AH
    cmp al , 0 ; if (al == 0) , at end of string , so
    je print_string_done ; jump to done
    mov word [es:di], ax ; Store char and attributes at current
        ; character cell.
    add bx , 1 ; Increment BX to the next char in string.
    add di , 2 ; Move to next character cell in vid mem.
    jmp print_string_loop ; loop around to print the next char.

print_string_done :
    pop es                    ;Restore ES that was saved on entry
    popa
    ret ; Return from the function

%include "a20.inc"
%include "gdt.inc"

[bits 32]
init_pm:
    mov ax, DATA_SEG
    mov ds, ax
    mov ss, ax
    mov es, ax
    mov fs, ax
    mov gs, ax

    mov ebp, 0x90000
    mov esp, ebp

    call 0x9000
    cli
loopend:                                ;Infinite loop when finished
    hlt
    jmp loopend

[bits 16]
; Variables
ERROR            db "A20 Error!" , 0
ERROR_MSG        db "Error!" , 0
BOOT_DRIVE:      db 0

VIDEO_MEMORY_SEG equ 0xb800
WHITE_ON_BLACK   equ 0x0f

times 510-($-$$) db 0
db 0x55
db 0xAA

gdt.inc:

gdt_start:
    dd 0                ; null descriptor--just fill 8 bytes
    dd 0

gdt_code:
    dw 0FFFFh           ; limit low
    dw 0                ; base low
    db 0                ; base middle
    db 10011010b        ; access
    db 11001111b        ; granularity
    db 0                ; base high

gdt_data:
    dw 0FFFFh           ; limit low (Same as code)
    dw 0                ; base low
    db 0                ; base middle
    db 10010010b        ; access
    db 11001111b        ; granularity
    db 0                ; base high
end_of_gdt:

gdtr:
    dw end_of_gdt - gdt_start - 1   ; limit (Size of GDT)
    dd gdt_start        ; base of GDT

    CODE_SEG equ gdt_code - gdt_start
    DATA_SEG equ gdt_data - gdt_start

a20.inc:

enable_A20:
    call check_a20
    cmp ax, 1
    je enabled
    call a20_bios
    call check_a20
    cmp ax, 1
    je enabled
    call a20_keyboard
    call check_a20
    cmp ax, 1
    je enabled
    call a20_fast
    call check_a20
    cmp ax, 1
    je enabled
    mov bx, [ERROR]
    call print_string
enabled:
    ret

check_a20:
    pushf
    push ds
    push es
    push di
    push si

    cli
    xor ax, ax ; ax = 0
    mov es, ax
    not ax ; ax = 0xFFFF
    mov ds, ax
    mov di, 0x0500
    mov si, 0x0510
    mov al, byte [es:di]
    push ax
    mov al, byte [ds:si]
    push ax
    mov byte [es:di], 0x00
    mov byte [ds:si], 0xFF
    cmp byte [es:di], 0xFF
    pop ax
    mov byte [ds:si], al
    pop ax
    mov byte [es:di], al
    mov ax, 0
    je check_a20__exit
    mov ax, 1

check_a20__exit:
    pop si
    pop di
    pop es
    pop ds
    popf
    ret

a20_bios:
    mov ax, 0x2401
    int 0x15
    ret

a20_fast:
    in al, 0x92
    or al, 2
    out 0x92, al
    ret

    [bits 32]
    [section .text]

a20_keyboard:
    cli

    call    a20wait
    mov     al,0xAD
    out     0x64,al
    call    a20wait
    mov     al,0xD0
    out     0x64,al
    call    a20wait2
    in      al,0x60
    push    eax
    call    a20wait
    mov     al,0xD1
    out     0x64,al
    call    a20wait
    pop     eax
    or      al,2
    out     0x60,al
    call    a20wait
    mov     al,0xAE
    out     0x64,al
    call    a20wait
    sti
    ret

a20wait:
    in      al,0x64
    test    al,2
    jnz     a20wait
    ret

a20wait2:
    in      al,0x64
    test    al,1
    jz      a20wait2
    ret

ядра.c:

/* This code will be placed at the beginning of the object by the linker script */    
__asm__ (".pushsection .text.start\r\n" \
         "jmp main\r\n" \
         ".popsection\r\n"
         );

/* Place main as the first function defined in kernel.c so
 * that it will be at the entry point where our bootloader
 * will call. In our case it will be at 0x9000 */

int main(){
    /* Do Stuff Here*/

    return 0; /* return back to bootloader */
}

линкер.ld

OUTPUT_FORMAT(elf32-i386)
ENTRY(main)

SECTIONS
{
    . = 0x9000;
    .text : { *(.text.start) *(.text) }
    .data : { *(.data) }
    .bss  : { *(.bss) *(COMMON) }
}

создать образ диска с помощью DD / отладки с помощью QEMU

если вы используете файлы выше и создаете необходимый загрузчик и файлы ядра, используя эти команды (как упоминалось ранее)

nasm -g -f elf32 -F dwarf -o boot.o bootloader.asm
ld -melf_i386 -Ttext=0x7c00 -nostdlib --nmagic -o boot.elf boot.o
objcopy -O binary boot.elf boot.bin

gcc -g -m32 -c -ffreestanding -o kernel.o kernel.c -lgcc
ld -melf_i386 -Tlinker.ld -nostdlib --nmagic -o kernel.elf kernel.o
objcopy -O binary kernel.elf kernel.bin

вы можете создать образ диска (в этом случае мы сделаем его размером с дискету) с помощью следующих команд:

dd if=/dev/zero of=disk.img bs=512 count=2880
dd if=boot.bin of=disk.img bs=512 conv=notrunc
dd if=kernel.bin of=disk.img bs=512 seek=1 conv=notrunc

это создает образ диска с нулевым заполнением размером 512 * 2880 байт (размер дискеты 1,44 мегабайта). dd if=boot.bin of=disk.img bs=512 conv=notrunc пишет boot.бин в первый сектор файла без усечения образ диска. dd if=kernel.bin of=disk.img bs=512 seek=1 conv=notrunc мест ядра.бин в образ диска начиная со второй сектор. The seek=1 пропускает первый блок (bs=512) перед записью.

если вы хотите запустить ядро, вы можете запустить его как дисковод a: (-fda) в в QEMU такой:

qemu-system-i386 -fda disk.img

вы также можете отлаживать 32-разрядное ядро с помощью в QEMU и отладчик GNU (GDB) с отладочной информацией, которую мы создали при компиляции/сборке кода с приведенными выше инструкциями.

qemu-system-i386 -fda disk.img -S -s &
gdb kernel.elf  \
        -ex 'target remote localhost:1234' \
        -ex 'layout src' \
        -ex 'layout reg' \
        -ex 'break main' \
        -ex 'continue'

этот пример запуска в QEMU С помощью удаленного отладчика и эмуляции гибкого диска с помощью файла disk.img(который мы создали с DD). GDB запуск с помощью ядра.elf (файл, который мы создали с отладочной информацией), затем подключается к в QEMU, и устанавливает точку останова в функции main () в C код. Когда отладчик, наконец, будет готов, вам будет предложено нажать <return> для продолжения. Если повезет, ты будешь функция просмотра main в отладчике.