Why doesn't my bootloader load my kernel

Question

I wrote a bootloader and a kernel and want my bootloader to load my kernel

[org 0x7c00]

    jmp     start

    ;%include "console.inc"

start:
    xor     ax, ax
    mov     ds, ax

    ;call    init_console
    ;call    clrscr

    ;mov     si, head
    ;mov     ah, 0x0f
    ;call    str_out

    ;mov     si, prompt
    ;mov     ah, 0x0f
    ;call    str_out

wait_in:
    in      al, 0x60

    cmp     al, 0
    jg      end_wait_in

    jmp     wait_in

end_wait_in:
    mov     ax, 0
    int     0x13

    jc      end_wait_in

read:
    mov     ax, 0x8000
    mov     es, ax
    mov     bx, 0

    mov     ah, 2
    mov     al, 1
    mov     ch, 0
    mov     cl, 2
    mov     dh, 0
    int     0x13

    jc      read

    jmp     0x8000:0x0000

head:        db          'XordaOS Bootloader v0.0.1', 0xa, 0xa, 0x0
prompt:      db          'Press any key to boot', 0x0

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

This was my bootloader and now my kernel

    jmp     start

    %include "console.inc"

start:
    xor     ax, ax
    mov     ds, ax

    call    init_console
    call    clrscr

    mov     si, msg
    mov     ah, 0x0f
    call    str_out

    cli
    jmp     $

msg:        db          'Hello World', 0x0

This is console.inc (commented in loader.asm with all console code)

init_console:
    mov     ax, 0xb800
    mov     es, ax
    xor     bx, bx
    xor     dx, dx

    ret

str_out:
    lodsb
    cmp     al, 0x0
    je      str_out_end

    cmp     al, 0xa
    je      new_line

    mov     [es:bx], ax
    add     bx, 2

    jmp     str_out

new_line:
    add     dx, 160
    mov     cx, dx
    sub     dx, bx
    add     bx, dx
    mov     dx, cx

    jmp     str_out

str_out_end:

    ret

clrscr:
    mov     cx, 2000
    xor     bx, bx

    mov     al, ' '
    mov     ah, 0x00        

start_clr:
    mov     [es:bx], ax
    add     bx, 2

    loop    start_clr

    xor     bx, bx

    ret

then I entered following commands:

#!/bin/bash

nasm -fbin -o loader.bin loader.asm
nasm -fbin -o kernel.bin kernel.asm

dd if=/dev/zero of=XordaOS.img bs=1024 count=1440
dd if=loader.bin of=XordaOS.img bs=512 seek=0 conv=notrunc
dd if=kernel.bin of=XordaOS.img bs=512 seek=1 conv=notrunc

And then I started it in QEMU Launcher (GUI)

Everything is working until the code area where I load the kernel. After end_wait_in I called my clear screen function clrscr and the screen is cleared but after that my kernel doesn't do anything

I think something is wrong. Can anyone help me?

I haven't tried running it (or done assembly in the last 10 years), but aren't you loading all the contents of the kernel to the same byte by always resetting bx to 0 at the beginning of read? — Jakub Judas, Oct 14 '17 at 19:01
@JakubJudas he's reading his entire kernel all at once with the one read. — Michael Petch, Oct 14 '17 at 19:02
No if it goes to read at jc read it happens because an error occured — Grevak, Oct 14 '17 at 19:04
My guess is that the emulator doesn't like the fact that you created the disk image in such a way that you may not have a full disk sector for your kernel. Your disk image is probably over 512 and under 1024. Many emulators will not read a sector from a disk image that is incomplete. — Michael Petch, Oct 14 '17 at 19:04
You're right, my bad. Nevermid then. I'll be interested in the answer though. — Jakub Judas, Oct 14 '17 at 19:04
Humour me and try these dd commands: `dd if=/dev/zero of=XordaOS.img bs=1024 count=1440` to create 1.44M floppy image `dd if=loader.bin of=XordaOS.img bs=512 seek=0 conv=notrunc` and then `dd if=kernel.bin of=XordaOS.img bs=512 seek=1 conv=notrunc` . The `conv=notrunc` ensures after the write that the disk image isn't truncated. — Michael Petch, Oct 14 '17 at 19:05
Just a side note. For the disk read you use DL=0 (you hard code 0). When the BIOS transfers control to your bootloader it places the boot drive number in _DL_. You should use that value for disk accesses from the boot device that was actually used. As it is your code will only work if booted off drive 0 (floppy drive A) — Michael Petch, Oct 14 '17 at 19:07
I loaded dl into unitialized resb 1 fd at the beginning of my bootloader and moved it back into dl in section read but it doesn't work — Grevak, Oct 14 '17 at 19:24
Learn to use a debugger and check that your kernel is loaded. Also, show code for `init_console` and `str_out`. — Jester, Oct 14 '17 at 19:40
Did you make the disk image as I suggest above? As Jester points out a debygger is a good tool. In the case of a basic bootloader I suggest bochs that has a built in debugger that handles real mode code debugging very well (QEMU can be used to debug such code but there are limitations and some pitfalls to be aware of) — Michael Petch, Oct 14 '17 at 19:48
I think I accomplished to load my kernel but it doesn't do what I coded. It should output Hello World to the screen but it outputs a character like T. Yes I did the disk as explained above — Grevak, Oct 14 '17 at 19:49
Did you set the _DS_ register in your kernel? I suspect that you haven't and are reading your string from the wrong segment and offset. — Michael Petch, Oct 14 '17 at 19:49
Update your question with current code including `str_out`. Use the debugger to verify the address you use and the content of that memory. — Jester, Oct 14 '17 at 19:51
Did you set DS in the kernel to 0x8000? And as an addendum to Jester's request can you just post your entire `console.inc`? — Michael Petch, Oct 14 '17 at 19:55

Michael Petch · Accepted Answer · 2017-10-15T02:40:45.547

Given your original question, the disk read you are doing won't work on a number of emulators if the read is of a sector that doesn't have at least a sector worth of data in it (in this case a sector is 512 bytes). Emulator disk reads will usually return some type of error if there is an attempt to read an incomplete sector from a disk image.

To get around this I often just create a 1.44MB disk image with something like:

dd if=/dev/zero of=XordaOS.img bs=1024 count=1440

This creates a zero filled file of 1024*1440 bytes, the size of a 1.44MB floppy. Many emulators will automatically determine the disk type from such a file size which is a bonus. You then need to add each part of the bootloader and kernel into the image without truncating it after each write (using DD's conv=notrunc option. You can do that with:

dd if=loader.bin of=XordaOS.img bs=512 seek=0 conv=notrunc 
dd if=kernel.bin of=XordaOS.img bs=512 seek=1 conv=notrunc

When doing a disk read with Int 13h/ah=2h DL is the drive number. In your code you hard code it to 0 by placing 0 in DL. You should consider using the value passed to the bootloader by the BIOS in DL. You can save that value and restore it when needed for disk operations. As it is your code will only work on drive 0 (usually floppy disk A:).

When you finally get the kernel loaded at 0x8000:0x0000 and you FAR JMP to it you need to ensure that DS is properly set. In this case you need to have 0x8000 in DS.

I have a number of bootloader tips some of which you may wish to consider.

To debug real mode bootloaders and other 16-bit real mode code I recommend using BOCHS which has proper real mode debugging support. You can use QEMU with remote debugging but it has limitations and pitfalls. You can get some ideas on debugging 16-bit code in QEMU in my other Stackoverflow Answer.

Why doesn't my bootloader load my kernel

1 Answers1