Basic NASM bootstrap

Question

I've recently been researching Operating Systems, the boot process, and NASM. On my journeys I ran into a piece of useful bootstrapping code which I partially understand and have tested via a virtual floppy disk. My basic question is to what some of these lines I don't understand do. I've commented what I think the lines do, and any corrections or confirmations would be much appreciated.

; This is NASM

        BITS 16                 ; 16 bits!

start:                          ; Entry point
        mov ax, 07C0h           ; Move the starting address (after this bootloader) into 'ax'
        add ax, 288             ; Leave 288 bytes before the stack beginning for some reason
        mov ss, ax              ; Show 'stack segment' where our stack starts
        mov sp, 4096            ; Tell 'stack pointer'  that our stack is 4K in size

        mov ax, 07C0h           ; Use 'ax' as temporary variable for setting 'ds'
        mov ds, ax              ; Set data segment to where we're loaded


        mov si, text_string     ; Put string position into SI (the reg used for this!)
        call print_string       ; Call our string-printing routine

        jmp $                   ; Jump here - infinite loop!

        text_string db 'This is my cool new OS!', 0 ; Our null terminated string
                                                    ; For some reason declared after use


print_string:                   ; Routine: output string in SI to screen
        mov ah, 0Eh             ; I don't know what this does..
                                ; Continue on to 'repeat'
.repeat:
        lodsb                   ; Get character from DS:SI into AL
        cmp al, 0               ; If end of text_string
        je .done                ; We're done here
        int 10h                 ; Otherwise, print the character (What 10h means)
        jmp .repeat             ; And repeat

.done:
        ret

        times 510-($-$$) db 0   ; Pad remainder of boot sector with 0s
        dw 0xAA55               ; The standard PC 'magic word' boot signature

Thanks,

Joe

Answer 1

Your comments are largely correct.

mov ah,0Eh

This sets a parameter to the BIOS interrupt call:

int 10h

See here for more details, but essentially the call to 10h expects an operation in ah and data for the operation in al.

The segment registers cannot be loaded directly and can only load from a register, thus the use of ax as a 'temporary variable.'

The 288 bytes added to the base stack pointer are actually not bytes at all. Addresses loaded into the segment registers are actually pointers to 16-byte blocks, so to convert the number to its actual address, shift it left by 4-bits. That means that the address 07C0h is actually referring to 7C00h, which is where your bootloader code is placed. 288 is 120h in hex, and so the actual location of the stack is really 7C00h + 1200h = 8E00h.

Also, you use words like "show" and "tell" which are fine, but it's better to think of defining the stack by setting ss and sp as opposed to reporting where it is at... I hope that makes sense.

Answer 2

 mov ah, 0Eh             ; I don't know what this does..

Loading 0eh into ah sets up the int 10h function Teletype output, which will print the character in al to the screen.

Your .repeat loop will then load each character from text_string into al and call int 10h.