org 0x100

%define DOSLINUX_INT 0xe7

; get current default drive

mov ah, 0x19

int 0x21

add al, 'a' ; interrupt returns drive index, not letter in AL

mov [current_drive], al

; get current directory, returns pointer to ASCIZ string in DS:SI

mov ah, 0x47

xor dl, dl ; default drive

mov si, current_dir_buffer

int 0x21

; detect XMS (eg HIMEM.SYS) and bail if present

mov ax, 0x4300

int 0x2f

cmp al, 0x80

jne no_xms

; print error message if XMS found

mov dx, xms_not_supported

mov ah, 0x09

int 0x21

; exit

mov ah, 0x4c

int 0x21

no_xms:

; detect already running instance of WSL

call detect_dsl

test ax, ax

jz start_linux

run_command:

; doslinux is already running, prepare to run linux command

; flush disk first

mov ah, 0x0d

int 0x21

; invoke the run command syscall

mov ah, 1

mov dl, [current_drive]

mov si, current_dir_buffer

int DOSLINUX_INT

; replicate linux cursor position in BIOS

call fix_cursor

; exit

mov ah, 0x4c

int 0x21

start_linux:

; open bzimage.com

mov ax, 0x3d00

mov dx, bzimage_path

int 0x21

; check error

mov dx, bzimage_open_err

jc fatal

; store file handle

mov [bzimage_handle], ax

; read first sector of bzimage

mov ah, 0x3f

mov dx, bzimage

mov bx, [bzimage_handle]

mov cx, 512

int 0x21

; check error

mov dx, bzimage_read_err

jc fatal

; pull setup_sects value from header

movzx ax, byte [k_setup_sects_b]

shl ax, 9 ; multiply by 512 to get byte count from sector count

mov [setup_bytes], ax

; read remaining setup code

mov ah, 0x3f

mov dx, bzimage + 512

mov bx, [bzimage_handle]

mov cx, [setup_bytes]

int 0x21

; check error

mov dx, bzimage_read_err

jc fatal

; check magic header value

mov eax, [k_header_magic_d]

cmp eax, 0x53726448 ; 'HdrS'

mov dx, not_kernel_err

jne fatal

; pull syssize from header - count of 16 byte paras of system code after setup

mov eax, [k_syssize_d]

shl eax, 4 ; multiply by 16 to get bytes

mov [sys_bytes], eax

; calculate sys_load_end pointer

add eax, [sys_load_ptr]

mov [sys_load_end], eax

; init unreal mode switching in prep for loading kernel to extended memory

call init_unreal

.sys_load_loop:

mov ah, 0x3f

mov dx, readbuf

mov bx, [bzimage_handle]

mov cx, READBUF_SIZE

int 0x21

; check error

mov dx, bzimage_read_err

jc fatal

; do unreal copy

mov si, readbuf

mov edi, [sys_load_ptr]

mov ecx, READBUF_SIZE

call copy_unreal

; advance load pointer

add dword [sys_load_ptr], READBUF_SIZE

; loop around again if more to read

mov eax, [sys_load_ptr]

cmp eax, [sys_load_end]

jb .sys_load_loop

; finished reading kernel, set obligatory kernel params:

; use our current video mode for kernel vidmode parameter

mov [k_vidmode_w], word 0

; we are not a registered bootloader

mov byte [k_type_of_loader_b], 0xff

; set load flags

%define LOADED_HIGH_FLAG 0x01

%define CAN_USE_HEAP_FLAG 0x80

mov byte [k_loadflags_b], LOADED_HIGH_FLAG | CAN_USE_HEAP_FLAG

; no ramdisk

mov dword [k_ramdisk_size_d], 0

mov dword [k_ramdisk_image_d], 0

; set heap end pointer - TODO is this correct?

%define HEAP_END 0xe000

mov word [k_heap_end_ptr_w], HEAP_END

; copy cmd line into place

mov si, cmdline

mov di, bzimage + HEAP_END

mov cx, cmdline.end - cmdline

rep movsb

; now calculate linear address for pointer

mov ax, ds

movzx eax, ax

shl eax, 4

mov ebx, bzimage + HEAP_END

add ebx, eax

mov [k_cmd_line_ptr_d], ebx

; set kernel boot params relevant to relocation

mov dword [k_code32_start_d], kernel_base

; write CS:IP of vm86_return into somewhere init can grab it from

call enter_unreal

push es

mov ax, 0x08

mov es, ax

a32 mov [es:0x100000], word vm86_return

mov ax, cs

a32 mov [es:0x100002], word ax

pushf

pop ax

a32 mov [es:0x100004], word ax

a32 mov [es:0x100006], sp

mov ax, ss

a32 mov [es:0x100008], word ax

call exit_unreal

pop es

; print initializing message right before starting kernel

mov dx, initializing

mov ah, 0x09

int 0x21

; calculate kernel segment

mov ax, ds

movzx eax, ax

shl eax, 4

add eax, bzimage

shr eax, 4

; disable interrupts and setup segments/stack

cli

mov ss, ax

mov sp, HEAP_END

mov ds, ax

mov es, ax

mov fs, ax

mov gs, ax

; enter kernel

; see https://www.kernel.org/doc/html/latest/x86/boot.html#running-the-kernel

; kernel code seg is + 0x20

add ax, 0x20

; since the segment is dynamic we need an indirect jump

mov bx, sp

sub bx, 4

mov [bx], word 0

mov [bx + 2], ax

jmp far [bx]

vm86_return:

; now DSL is running we can run the originally invoked command

jmp run_command

;

; helper subroutines

;

; print error message and exit

fatal:

mov ah, 0x09

int 0x21

mov ah, 0x4c

int 0x21

; initialize unreal mode switching

init_unreal:

; setup gdt offset in gdtr

mov eax, ds

shl eax, 4

add eax, gdt

mov [gdtr.offset], eax

ret

; copy from low to extended memory (> 1 MiB)

; DS:ESI - source (far pointer)

; EDI - destination (linear address)

; ECX - byte count

; clobbers EAX

copy_unreal:

; zero high bits of ESI

movzx eax, si

mov esi, eax

; save ds/es and load 32 bit segment selectors

call enter_unreal

push es

mov ax, 0x08

mov es, ax

; copy 4 bytes at a time:

add ecx, 3

shr ecx, 2

; do the copy, using 32 bit address override

a32 rep movsd

; restore ds/es

call exit_unreal

pop es

ret

enter_unreal:

; load gdt to prepare to enter protected mode

cli

lgdt [gdtr]

; enable protected mode

mov eax, cr0

or al, 1

mov cr0, eax

ret

exit_unreal:

; disable protected mode

mov eax, cr0

and al, ~1

mov cr0, eax

ret

; returns line VGA cursor is on in AL, 0 indexed

; clobbers DX and BX

cursor_line:

; read cursor pos into bx from vga

mov al, 0x0f

mov dx, 0x3d4

out dx, al

mov dx, 0x3d5

in al, dx

mov bl, al

mov al, 0x0e

mov dx, 0x3d4

out dx, al

mov dx, 0x3d5

in al, dx

mov bh, al

; calculate line

mov ax, bx

xor dx, dx

add ax, 79 ; for round-up division

mov bx, 80

div bx

xor ah, ah

ret

; replicate VGA cursor pos in BIOS

fix_cursor:

call cursor_line

mov dh, al ; line number

xor dl, dl ; column

xor bh, bh ; page number (?)

mov ah, 0x02 ; set cursor pos

int 0x10

ret

; detects running DSL instance

; returns 1 if running in AX, 0 otherwise

detect_dsl:

; push flags and disable interrupts before we do anything dodgy

pushf

cli

; set fs to zero to access IVT

push fs

xor ax, ax

mov fs, ax

; save previous handler for doslinux interrupt

mov ax, [fs:DOSLINUX_INT * 4]

push ax

mov ax, [fs:DOSLINUX_INT * 4 + 2]

push ax

; set up dummy interrupt handler so we don't crash or invoke any

; unintended behaviour when calling the doslinux interrupt

mov [fs:DOSLINUX_INT * 4], word .dummy_handler

mov ax, cs

mov [fs:DOSLINUX_INT * 4 + 2], ax

; hit it

xor ax, ax

int DOSLINUX_INT

mov [.is_running], ax

; restore previous interrupt handler

pop ax

mov [fs:DOSLINUX_INT * 4 + 2], ax

pop ax

mov [fs:DOSLINUX_INT * 4], ax

; restore previous fs

pop fs

; restore flags

popf

; test ax

mov ax, [.is_running]

ret

.is_running dw 0

.dummy_handler:

mov [.is_running], word 0

iret

;

; RO data

;

xms_not_supported db "Extended memory manager detected (maybe HIMEM.SYS?) - cannot start DOS Subsystem for Linux", 13, 10, "$"

bzimage_path db "C:\doslinux\bzimage", 0

bzimage_open_err db "Could not open bzImage", 13, 10, "$"

bzimage_read_err db "Could not read bzImage", 13, 10, "$"

not_kernel_err db "bzImage is not a Linux kernel", 13, 10, "$"

initializing db "Starting DOS Subsystem for Linux, please wait...$"

newline db 13, 10, "$"

; reserve entire low memory region

cmdline: db "quiet init=/doslinux/init root=/dev/sda1 "

; kernel should scroll in software rather than hardware, DOS/BIOS

; only scrolls in software:

db "nomodeset no-scroll "

; reserve low 640k (the maximum) to keep DOS intact during boot

db "reservelow=655360 "

; mark phys memory from 0x100000-0x110000 as reserved, we may

; use high memory area in DOS

db "memmap=64K$0x100000 "

; disable kernel PAT support - PAT imposes aliasing restrictions on

; physical memory pages which cause our mmap of all conventional

; memory to fail

db "nopat "

db 0

.end:

gdt:

; entry 0x00 : null

dq 0

; data entry

dw 0xffff ; limit 0:15

.data_base_0_w:

dw 0x0000 ; base 0:15

.data_base_16_b:

db 0x00 ; base 16:23

db 0b10010010 ; access byte - data

db 0xcf ; flags/(limit 16:19). 4 KB granularity + 32 bit mode flags

.data_base_24_b:

db 0x00 ; base 24:31

.end:

;

; variables

;

align 4

bzimage_handle: dw 0

setup_bytes: dw 0

heap_end: dw 0

align 4

sys_bytes: dd 0

sys_load_ptr: dd kernel_base

sys_load_end: dd 0

current_drive: db 0

current_dir_buffer: times 64 db 0

align 4

gdtr:

dw gdt.end - gdt - 1

.offset:

dd 0

;

; constants

;

kernel_base equ 0x200000

; kernel real mode header fields

; see https://www.kernel.org/doc/html/latest/x86/boot.html#the-real-mode-kernel-header

k_setup_sects_b equ bzimage + 0x1f1

k_syssize_d equ bzimage + 0x1f4

k_header_magic_d equ bzimage + 0x202

; obligatory fields - we must supply this information to kernel

k_vidmode_w equ bzimage + 0x1fa

k_type_of_loader_b equ bzimage + 0x210

k_loadflags_b equ bzimage + 0x211

k_setup_move_size_w equ bzimage + 0x212

k_ramdisk_image_d equ bzimage + 0x218

k_ramdisk_size_d equ bzimage + 0x21c

k_heap_end_ptr_w equ bzimage + 0x224

k_ext_loader_type_b equ bzimage + 0x227

k_cmd_line_ptr_d equ bzimage + 0x228

; reloc fields - we must supply if kernel is relocated

k_code32_start_d equ bzimage + 0x214

k_kernel_alignment_d equ bzimage + 0x230

k_relocatable_kernel_b equ bzimage + 0x234

k_min_alignment_b equ bzimage + 0x235

k_pref_address_q equ bzimage + 0x258

align 16

progend:

READBUF_SIZE equ 4096

readbuf equ progend

bzimage equ progend + READBUF_SIZE