In the last blog posting I have talked about how to read files from a FAT12 partition and print out its loaded content to the screen. In today’s blog posting I want to talk more about how to implement a Second Stage Boot Loader that can be loaded into memory for its execution. But let’s talk first, why we need a Second Stage Boot Loader.

Second Stage Boot Loader – Why?

In my first blog posting about OS development, we have talked about how the BIOS loads the boot sector at the memory location 0x7C00 and executes it. The restriction of the boot sector is that it has only a size of 512 bytes (one disk sector) and within that size you can’t implement that much functionality with that restriction.

Therefore, you need a Second Stage Boot Loader that gets loaded into memory and prepares the CPU and the actual OS kernel for its execution. A Second Stage Boot Loader must implement the following tasks:

• Getting date and time information from the BIOS
• Detecting the Memory Map
• Retrieving the supported Video Modes
• Enabling the A20 Gate
• Switching the CPU into x32 Protected Mode or x64 Long Mode
• Loading the real OS Kernel from Disk
• Executing the OS Kernel

As you can see from this list, it would be impossible to do all these things within 512 bytes – or even 510 bytes when you subtract the magical byte pattern 0xAA55 at the end of the boot sector.

Implementing the Second Stage Boot Loader

Let’s talk now how to implement the Second Stage Boot Loader. In my case the Second Stage Boot Loader is x16 based so that I still have access to the BIOS interrupts – otherwise you can’t implement the above-mentioned tasks. One of the first things that the Second Stage Boot Loader implements is getting the date and time information from the BIOS.

This information will then be passed over to the Kernel who must keep them up to date – as precise as possible. The following listing shows the GetDate and GetTime functions that uses the BIOS interrupt 0x1A to get this information.

;=================================================
; This function retrieves the date from the BIOS.
;=================================================
GetDate:
    ; Get the current date from the BIOS
    MOV     AH, 0x4
    INT     0x1A

    ; Century
    PUSH    CX
    MOV     AL, CH
    CALL    Bcd2Decimal
    MOV     [Year1], AX
    POP     CX

    ; Year
    MOV     AL, CL
    CALL    Bcd2Decimal
    MOV     [Year2], AX

    ; Month
    MOV     AL, DH
    CALL    Bcd2Decimal 
    MOV     [Month], AX

    ; Day
    MOV     AL, DL
    CALL    Bcd2Decimal
    MOV     [Day], AX

    ; Calculate the whole year (e.g. "20" * 100 + "22" = 2022)
    MOV     AX, [Year1]
    MOV     BX, 100
    MUL     BX
    MOV     BX, [Year2]
    ADD     AX, BX
    MOV     [Year], AX
RET

;=================================================
; This function retrieves the time from the BIOS.
;=================================================
GetTime:
    ; Get the current time from the BIOS
    MOV     AH, 0x2
    INT     0x1A

    ; Hour
    PUSH    CX
    MOV     AL, CH
    CALL    Bcd2Decimal
    MOV     [Hour], AX
    POP     CX

    ; Minute
    MOV     AL, CL
    CALL    Bcd2Decimal
    MOV     [Minute], AX

    ; Second
    MOV     AL, DH
    CALL    Bcd2Decimal
    MOV     [Second], AX
RET

As you can see from the previous listing, the BIOS interrupt 0x1A returns the current date and time as BCD numbers, therefore the function Bcd2Decimal does the conversion to decimal values:

;==========================================================
; This function converts a BCD number to a decimal number.
;==========================================================
Bcd2Decimal:
    MOV     CL, AL
    SHR     AL, 4
    MOV     CH, 10
    MUL     CH
    AND     CL, 0Fh
    ADD     AL, CL
RET

Afterwards the retrieved information is printed to the screen through the functions PrintString and PrintDecimal.

;================================================
; This function prints a whole string, where the 
; input string is stored in the register "SI"
;================================================
PrintString:
    ; Set the TTY mode
    MOV     AH, 0xE
    INT     10

    ; Set the input string
    MOV     AL, [SI]
    CMP     AL, 0
    JE      PrintString_End
    
    INT     0x10
    INC     SI
    JMP     PrintString
    
    PrintString_End:
RET

;================================================
; This function prints out a decimal number
; that is stored in the register AX.
;================================================
PrintDecimal:
    MOV     CX, 0
    MOV     DX, 0

PrintDecimal_Start:
    CMP     AX ,0
    JE      PrintDecimal_Print
    MOV     BX, 10
    DIV     BX
    PUSH    DX
    INC     CX
    XOR     DX, DX
    JMP     PrintDecimal_Start
PrintDecimal_Print:
    CMP     CX, 0
    JE      PrintDecimal_Exit
    POP     DX
        
    ; Add 48 so that it represents the ASCII value of digits
    MOV     AL, DL
    ADD     AL, 48
    MOV     AH, 0xE
    INT     0x10

    DEC     CX
    JMP     PrintDecimal_Print
PrintDecimal_Exit:
RET

Over the next blog postings, the implementation of the Second Stage Boot Loader will be enhanced with the previous mentioned tasks.

Loading and executing the Second Stage Boot Loader

The Second Stage Boot Loader code will be compiled by NASM into a raw binary file and then it will be added as an additional file to our final floppy image. Our boot loader code can then read that file with the implementation from the last blog posting into memory for its code execution. The following code shows how the Second Stage Boot Loader is loaded into memory – the variable KAOSLDR_OFFSET currently points to the memory location 0x2000.

; Load the KAOSLDR.BIN file into memory
    MOV     CX, 11
    LEA     SI, [SecondStageFileName]
    LEA     DI, [FileName]
    REP     MOVSB
    MOV     WORD [Loader_Offset], KAOSLDR_OFFSET
    CALL    LoadRootDirectory

    ; Execute the KAOSLDR.BIN file...
    CALL KAOSLDR_OFFSET

Executing the Second Stage Boot Loader code is quite easy: we just do a simple CALL to the memory location KAOSLDR_OFFSET.

Summary

Reading an additional binary file into memory for its execution is not that complicated – if we are in x16 Real Mode, who offers us the necessary BIOS interrupts. Today we have used this functionality to load and execution the Second Stage Boot Loader of our OS. This additional boot loader code is necessary because we can’t do that many things within the limited boot sector size of 512 bytes. In the next blog posting we will continue with our Second Stage Boot Loader code and will finally switch the CPU into x64 Long Mode. Stay tuned…