I have a 2 stage bootloader loading my kernel named core. I have a linker script that sections off the start address needed for each stage. For now I use a linker script and a make-file to load the kernel without a filesystem. The gdt and idt work fine and interrupts work with time and keyboard.

The problem I have is that every time I try to set up the stack selector and the stack it breaks everything. Then bochs starts to complain in a forever loop with ss bound, eax, move dword ptr, or mov ss, ax.

Since the interrupts worked fine beforehand, I know the gdt and idt are set up right, so its only when I try to set up the stack selector and the 128kb stack.

I set up a .stack section in the link.ld file because I wanted a good place to start and use stack_start and stack_end to handle the stack addresses. The issue seems to be when I try to introduce the stack_seg from the gdt table into the workflow. In osload.asm after we move into protected mode, we are suppose to be setting up the selectors into the right registers so that we can use them, then set the stack. This is where there seems to be a confliction. In gdt.c we have the load_gdt function where it seems we are manually setting a stack selector address then we are trying to set the stack up in osload.asm right after. I am not understanding how the selector and the stack work or go together. Are we suppose to be setting the stack to the base of the selector?

I have tried setting the address manually in the linker then setting the start address in the load_gdt() function. As well as tried to set it in osload.asm. I have also tried manually creating a .stack section in osload.asm and allocating bytes for it that way.

Right now I started a new project in order to produce a minimum reproduceable example here so there is no idt or interrupt stuff in the code below. The output should be that the screen gets cleared in bochs with a green screen without the stack bochs errors. Meaning it got set right. That’s the only reason why the video functions are in the same file as the gdt.

It seems I am missing the larger picture of how it all connects together. So how do I properly set up the stack workflow between a bootloader, linker, and gdt?

osboot.asm

[BITS 16]
extern osload

osboot:
     cli
     xor ax, ax                      ; Initialize seg regsisters to 0 since linker script will be placing bootloader at org 0x7c00             
     mov ds, ax
     mov es, ax
     mov fs, ax
     mov gs, ax

     mov ss, ax
     mov sp, 0x7c00                  ; Place stack just below bootloader at 0x0000:0x7c00
     sti

     call read_osload

     jmp 0:osload

read_osload:
    mov ah, 0         ; reset the drive function
    int 0x13          ; call the BIOS interrupt to reset drive

    xor ax, ax
    mov es, ax
    mov bx, 0x7E00    ; read address 0x7E00 so we can jmp to the second stage

    mov ah, 0x02      ; read sector function
    mov al, 36        ; read 36 sectors - this will need to be redone as the kernel gets larger
    mov ch, 0         ; 0 = track 1  (18 sectors per track) no need to move from track 0
    mov cl, 2         ; read sector 2
    mov dh, 0         ; head number
    int 0x13          ; call the BIOS interrupt to read drive
    ret

osload.asm

[BITS 16]
section .osload
global osload
extern start_stack
extern end_stack

osload: jmp switch_pmode


switch_pmode:
    call enable_gate                 ; enable A20 gate for additional memory
    call _set_tmode_system           ; set text mode for bootloader menu

    cli
    lgdt [selector_ptr]              ; load the GDT table

    mov eax, cr0                     ; get CR0 register value
    or eax, 1                        ; set the protected mode bit
    mov cr0, eax                     ; store the value back to CR0

    jmp core_mode_code_seg:pmode                  ; Far jump to 32-bit mode (code selector: 0x10)

[BITS 32]
pmode:
    mov ax, core_mode_data_seg
    mov ds, ax
    mov es, ax
    mov fs, ax
    mov gs, ax  

    mov ax, stack_seg               ; set the stack segment selector
    mov ss, ax
    mov esp, end_stack              ; Set stack pointer to the end of the stack

    mov ebp, esp                    ; Set base pointer to stack top (optional)
    mov esp, ebp                    ; Set stack pointer

    [EXTERN _core]
    call _core                 ; Call the core function

halt:
    cli
    hlt 

enable_gate:
    pusha
    in al, 0x92
    or al, 2
    out 0x92, al                           
    popa
    ret

_set_tmode_system:
    pusha               ; Push all general-purpose registers onto the stack

    mov ah, 00h          ; Set the video mode to text mode
    mov al, 03h          ; VGA text mode 80x50 
    int 10h              ; Call BIOS video services

    mov ax, 1112h    
    mov bh, 0
    mov bl, 32
    int 10h              ; Call BIOS video services

    popa                 ; Pop all general-purpose registers from the stack
    ret                  ; Return from the subroutine
%include "gdt.inc"

gdt.inc

gdt_start:
gdt_null:
    dw 0          ; Limit Low (16 bits)
    dw 0          ; Base Low (16 bits)
    db 0          ; Base Middle (8 bits)
    db 0          ; Access Byte
    db 0          ; Granularity Byte
    db 0          ; Base High (8 bits)

core_mode_code:
    dw 0xffff
    dw 0
    db 0
    db 10011010b               
    db 11001111b
    db 0
core_mode_data:
    dw 0xffff
    dw 0
    db 0
    db 10010010b              
    db 11001111b
    db 0

user_mode_code:
    dw 0xffff
    dw 0
    db 0
    db 11111010b               
    db 11001111b
    db 0

user_mode_data:
    dw 0xffff
    dw 0
    db 0
    db 11110010b               
    db 11001111b
    db 0
stack_segment:
    dw 0xffff        ; Limit Low (16 bits)
    dw 0x0000        ; Base Low (16 bits)
    db 0x00          ; Base Middle (8 bits)
    db 0x92          ; Access Byte: 10010010b - present, privilege level 0, data, writable, accessed
    db 0xCF          ; Granularity Byte: 11001111b - 4KB granularity, 32-bit, not 64-bit, User bit 0
    db 0x00          ; Base High (8 bits)

gdt_end:
selector_ptr:
    dw gdt_end - gdt_start - 1
    dd gdt_start

core_mode_code_seg equ core_mode_code - gdt_start
core_mode_data_seg equ core_mode_data - gdt_start
user_mode_code_seg equ user_mode_code - gdt_start
user_mode_data_seg equ user_mode_data - gdt_start

stack_seg equ stack_segment - gdt_start

[extern gdt_ptr]
[global flush_gdt]
flush_gdt:
    lgdt [gdt_ptr]
    ret

gdt.c

#include "gdt.h"

#define tmode_screen_width     80
#define tmode_screen_height    50

bay *video_memory = (bay *)0xB8000;

// cursor positions
static den cursor_pos_x = 0;
static den cursor_pos_y = 0;

void set_gdt_gate_access(aisles gdt_seg_index, aisle seg_base, aisle seg_limit, den seg_access, den seg_gran)
{
    gdt_entry[gdt_seg_index].gdt_seg_low_base = (seg_base & 0xFFFF);
    gdt_entry[gdt_seg_index].gdt_seg_mid_base = (seg_base >> 16) & 0xFF;
    gdt_entry[gdt_seg_index].gdt_seg_high_base = (seg_base >> 24) & 0xFF;

    gdt_entry[gdt_seg_index].gdt_seg_low_limit = (seg_limit & 0xFFFF);
    gdt_entry[gdt_seg_index].gdt_seg_region_type = ((seg_limit >> 16) & 0x0F);

    gdt_entry[gdt_seg_index].gdt_seg_region_type |= (seg_gran & 0xF0);
    gdt_entry[gdt_seg_index].gdt_seg_access = seg_access;
}

void load_gdt(void)
{
    gdt_ptr.gdt_seg_limit = (sizeof(struct gdt_global_entry) * 6) - 1;
    gdt_ptr.gdt_seg_base = (aisle)&gdt_entry;

    set_gdt_gate_access(0, 0, 0, 0, 0);                // null segment
    set_gdt_gate_access(1, 0, 0xFFFFFFFF, 0x9A, 0xCF); // core code segment
    set_gdt_gate_access(2, 0, 0xFFFFFFFF, 0x92, 0xCF); // core data segment
    set_gdt_gate_access(3, 0, 0xFFFFFFFF, 0xFA, 0xCF); // user code segment
    set_gdt_gate_access(4, 0, 0xFFFFFFFF, 0xF2, 0xCF); // user data segment
    set_gdt_gate_access(5, 0, 0xfff0, 0x92, 0xCF); // stack segment with base 0x0000 and limit 0xFFFFF

    flush_gdt((aisle)&gdt_ptr);   /* Flush out the old GDT and install the new changes! */
}

static void move_cursor()
{
    // The screen is 80 characters wide...
    bay cursorLocation = (cursor_pos_y * tmode_screen_width) + cursor_pos_x;
    porthub_write_den_out(0x3D4, 14);                  // Tell the VGA board we are setting the high cursor byte.
    porthub_write_den_out(0x3D5, cursorLocation >> 8); // Send the high cursor byte.
    porthub_write_den_out(0x3D4, 15);                  // Tell the VGA board we are setting the low cursor byte.
    porthub_write_den_out(0x3D5, cursorLocation);      // Send the low cursor byte.
}

// Clears the screen, by copying lots of spaces to the framebuffer.
void monitor_clear()
{
    // Make an attribute byte for the green background and black text.
    den attributeByte = (2 /*green*/ << 4) | (0 /*black*/ & 0x0F);
    bay blank_mark = 0x20 /* space */ | (attributeByte << 8);

    int i;
    for (i = 0; i < tmode_screen_width * tmode_screen_height; i++)
    {
        video_memory[i] = blank_mark;
    }

    // Move the hardware cursor back to the start.
    cursor_pos_x = 0;
    cursor_pos_y = 0;
    move_cursor();
}

/*read a den from the porthub  1 unsigned byte*/
den porthub_read_den_in(bay port_hub)
{
    den ret;
    asm volatile("inb %1, %0" : "=a"(ret) : "Nd"(port_hub));
    return ret;
}

/*write a den to the porthub  1 unsigned byte*/
void porthub_write_den_out(bay port_hub, den outgoing_data)
{
    asm volatile("outb %1, %0" : : "dN"(port_hub), "a"(outgoing_data));
}

gdt.h

#ifndef _gdt_h
#define _gdt_h

typedef unsigned long long zone;  // 8 unsigned bytes
typedef unsigned int aisle;       // 4 unsigned bytes
typedef unsigned short bay;       // 2 unsigned bytes
typedef unsigned char den;        // 1 unsigned bytes


typedef long long zones;          // 8 signed bytes
typedef int aisles;               // 4 signed bytes
typedef short bays;               // 2 signed bytes
typedef char dens;                // 1 signed bytes

#pragma pack(push, 1) // Start 1-byte alignment

typedef struct gdt_global_entry
{
    bay  gdt_seg_low_base;    //16 bit
    den  gdt_seg_mid_base;     //8 bit
    den  gdt_seg_high_base;    //8 bit

    bay  gdt_seg_low_limit;   //16 bit
    den  gdt_seg_access;       //8 bit
    den  gdt_seg_region_type;  //8 bit  granularity flag
} gdt_global_entry;

typedef struct gdt_global_ptr
{
    bay    gdt_seg_limit;
    aisle  gdt_seg_base;
} gdt_global_ptr;

#pragma pack(pop) // Restore the previous alignment

struct gdt_global_entry gdt_entry[6];
struct gdt_global_ptr gdt_ptr;


void load_gdt(void);
void set_gdt_gate_access(aisles gdt_seg_index, aisle seg_base, aisle seg_limit, den seg_access, den seg_gran);


// Lets us access our ASM functions from our C code.
extern void gdt_flush(aisle);


void monitor_clear();
den porthub_read_den_in(bay port_hub);
void porthub_write_den_out(bay port_hub, den outgoing_data);

#endif

core.c

#include "gdt.h"


int _core()
{
    monitor_clear();

    load_gdt();

    for (;;)
    {
        asm("hlt");  // Halt CPU until next interrupt to save power
    }
    return 0;
}

link.ld

ENTRY(_core)
OUTPUT_FORMAT(elf32-i386)

SECTIONS
{
    . = 0x7C00;                  /* osboot.asm starts at 0x7C00*/
    .osboot : AT(0x7C00) SUBALIGN(4)
    {
        osboot.o(.text)
        osboot.o(.*)
    }

    . = 0x7DFE;
    .bootsig : {
        SHORT(0xaa55);
    }

    . = 0x7E00;                 /* osload.asm starts at 0x7E00. We need a place to jmp to from osboot */
    .osload : AT(0x7E00) SUBALIGN(4)
    {
        osload.o(.text)
        osload.o(.*)
    }

    . = 0x8320;                /* core.c started at 0x8320. As the os grows so will this address. This is the address where the core _core starts */
    ._core : SUBALIGN(4)
    {
        *(.text*)
        *(.rodata*)
        *(.data*)
    }

    .bss : SUBALIGN(4) {
        __bss_start = .;
        *(COMMON);
        *(.bss*);
    }
    . = ALIGN(4);              /* Round BSS up to 4 byte boundary */
    __bss_end = .;

    .stack : ALIGN(4)          /* Define the stack section */
    {
       start_stack = .;
       . += 0x20000;          /* Allocate 128KB for the stack */
       end_stack = .;
    }

    core_sectors = (SIZEOF(._core) + 511) / 512;

    /DISCARD/ : {
        *(.eh_frame)
        *(.comment)
    }
}

makefile

all: elle.flp

osboot.o: osboot.asm
    nasm -f elf32 osboot.asm -o osboot.o

osload.o: osload.asm
    nasm -f elf32 osload.asm -o osload.o

core.o: core.c
    gcc -m32 -fno-pie -Wall -ffreestanding --no-builtin -nostdinc -nostdlib -c core.c -o core.o

gdt.o: gdt.c
    gcc -m32 -fno-pie -Wall -ffreestanding --no-builtin -nostdinc -nostdlib -c gdt.c -o gdt.o

core.bin: core.o osload.o osboot.o gdt.o
 

    ld -T link.ld -melf_i386 -o core.elf core.o osload.o osboot.o  gdt.o

    objcopy -O binary core.elf core.bin

elle.flp: core.bin  
    dd if=/dev/zero of=elle.flp bs=1K count=1440
    dd if=core.bin of=elle.flp conv=notrunc

clean:
    rm -f core.bin core.o osboot.o osload.o elle.flp core.elf gdt.o