Build Your OS from Scratch by Assembly X86 Language Part1 Loader code

1. How Boot From Floppy Disk ?
AHashemB OS
By
Eng. Ahmed Hashem El Fiky
Network Security Engineer
Malware Analyst
Reference: http://sebastianmihai.com/main.php?t=128&n=Snowdrop...from...assembly-language

2. Boot
Sector
FAT 1 FAT 2 Root Directory Data Area
Floppy Disk
Each floppy disk consists of four logical parts—Boot Sector, File Allocation Table (FAT), Directory and Data space.
Boot Sector contains information about how the disk is organized. That is, how many sides does it contain, how
many tracks are there on each side, how many sectors are there per track, how many bytes are there per sector,
etc.
The files and the directories are stored in the Data Space.
The Directory contains information about the files like its attributes, name, size, etc
The FAT contains information about where the files and directories are stored in the data space.

3. the four logical parts of a 1.44 MB disk.

4. The boot sector contains two parts—‘Boot Parameters’ and ‘Disk Bootstrap Program’. The Boot Parameters
are useful while performing read/write operations on the disk.
Figure 19.6 shows the break up of the boot parameters for a floppy disk

5. The boot sector
Logical sector zero is known as the boot sector and contains all essential information regarding the layout of
information on the disk (see Figure 6). The first 3 bytes form an 8086 jump instruction, the destination of which is the
entry point of the bootstrap code at the end of the sector. If this disk is used to bootstrap the computer then sector
zero is read into memory and execution transferred to the bootstrap code via the jump. Following the jump
instruction is an 8 byte field which is used by the system manufacturer for an identification string.

6. Format of a directory entry

7. Loader Code that loaded Kernel File from Floppy Disk
to Memory at Location 0000h

8. Boot Sector (Logical Sector Zero)
jmp load_kernel
bpbOEM db “AHashemB"
bpbBytesPerSector: dw 512
bpbSectorsPerCluster: db 1
bpbReservedSectors: dw 1
bpbNumberOfFATs: db 2
bpbRootEntries: dw 224
bpbTotalSectors: dw 2880
bpbMedia: db 0F0h
bpbSectorsPerFAT: dw 9
bpbSectorsPerTrack: dw 18
bpbHeads: dw 2
bpbHiddenSectors: dd 0
bpbTotalSectorsBig: dd 0
bsDriveNumber: db 0
bsUnused: db 0
bsExtBootSignature: db 29h
bsSerialNumber: dd 538A538Ah
bsVolumeLabel: db “AHashemB OS"
bsFileSystem: db "FAT12 "
Loader code (that load Kernel File From Floppy Disk to Memory)

9. Notes of Load Kernel File In Memory
1- load Kernel File from Floppy Disk , How?
1.1 - search about kernel file Name in Root Directory entries (224 entry + each entry has
32-byte).
1.2 - if kernel file name exist, we need to read First Cluster of Kernel file at (26-27 byte)
from Root Directory Entry.
1.3 - Kernel File consists of many clusters in FAT 1 and FAT 2. The First Cluster that points
to next clusters is in Root Directory Entry (Kernel File Name).
1.4 - Now we will read cluster by cluster in FAT1 and FAT2 that consist of Kernel File.
1.5 - we have FAT1 (9 sectors) and FAT2 (9 sectors) . FAT1 is Logical Sector 1 where
bootsector is Logical sector 0.
1.6 - 0xFF8 - 0xFFF (Last cluster in file) FAT12.
1.7 - when read all clusters of Kernel File we will load kernel file in memory at location
0000h

10. BOOT_LOADER_SEGMENT equ 0000h
STACK_SEGMENT equ 1000h
KERNEL_SEGMENT equ 1000h
DISK_BUFFER_SEGMENT equ 2000h
bootDriveNumber: db 0
initialLoading: db 13, 10, “AHashemB OS loader is loading..", 13, 10, 0
floppyKernelNotFound: db "No kernel!", 0
floppyDriveError: db "Disk error!", 0
floppyDriveReset: db "reset!", 0
floppyDriveLoadingRoot: db ".directory", 13, 10, 0
floppyReadFat: db ".FAT", 13, 10, 0
floppyReadCluster: db ".clusters:", 0
floppyReadClusterIncrement: db "*", 0
kernelFileName: db “AHashemBKRN"
kernelCurrentCluster: dw 0
kernelDestinationPointer: dw 0
Declaration of Parameters

11. Load Kernel routines
1- load_root_directory routine.
2- find_root_directory_entry routine.
3- find_root_directory_entry_check_file routine.
4- find_root_directory_kernel_not_found routine.
5- find_root_directory_entry_found routine.
6- read_fat routine.
7- read_fat_success routine.
8- read_cluster_contents routine.
9- read_cluster_contents_perform routine.
10 - read_cluster_contents_success routine.
11- calculate_next_cluster routine.
12- cluster_is_odd routine.
13- cluster_is_even routine.
14- calculate_last_cluster routine.
15- transfer_control_to_kernel routine.
16- floppy_logical_to_physical routine.
17- reset_floppy routine.
18- reset_floppy_loop routine.
19- reset_floppy_success routine.
20- reset_floppy_failure routine.
21- halt_cpu routine.
22- debug_print_string routine.
23- debug_print_string_loop routine.
24- debug_print_string_end routine.
25- bootsector Signature.

12. Initialization Segments
load_kernel:
cld
push word BOOT_LOADER_SEGMENT
pop ds
mov byte [bootDriveNumber], dl
cli
mov ax, STACK_SEGMENT
mov ss, ax
mov ax, 0000h
mov sp, ax
sti
mov si, initialLoading
call debug_print_string
debug_print_string:
pusha
mov ah, 0Eh
mov bx, 0007h
debug_print_string_loop:
lodsb
cmp al, 0
je debug_print_string_end
int 10h
jmp debug_print_string_loop
debug_print_string_end:
popa
ret

13. load_root_directory:
mov si, floppyDriveLoadingRoot
call debug_print_string
mov ax, 19
call floppy_logical_to_physical
push word DISK_BUFFER_SEGMENT
pop es
mov bx, 0
mov ax, 020Eh
int 13h
jnc find_root_directory_entry
call reset_floppy
jmp load_root_directory
find_root_directory_entry:
mov di, 0
mov bx, [bpbRootEntries]
find_root_directory_entry_check_file:
push di
mov si, kernelFileName
mov cx, 11
repe cmpsb
jz find_root_directory_entry_found
dec bx
cmp bx, 0
je find_root_directory_kernel_not_found
pop di
add di, 32
jmp find_root_directory_entry_check_file
find_root_directory_kernel_not_found:
pop bx
mov si, floppyKernelNotFound
call debug_print_string
jmp halt_cpu
find_root_directory_entry_found:
pop di
mov ax, word [es:di+26]
mov word [kernelCurrentCluster], ax
halt_cpu:
cli
hlt

14. reset_floppy:
pusha
mov cx, 10
reset_floppy_loop:
mov si, floppyDriveReset
call debug_print_string
mov ah, 0
mov dl, byte [bootDriveNumber]
clc
int 13h
jnc reset_floppy_success
dec cx
jcxz reset_floppy_failure
jmp reset_floppy_loop
reset_floppy_success:
popa
ret
reset_floppy_failure:
mov si, floppyDriveError
call debug_print_string
floppy_logical_to_physical:
push ax
mov dx, 0
div word [bpbSectorsPerTrack]
inc dl
mov cl, dl
pop ax
mov dx, 0
div word [bpbSectorsPerTrack]
mov dx, 0
div word [bpbHeads]
mov dh, dl
mov ch, al
mov dl, byte [bootDriveNumber]
ret

15. read_fat:
mov si, floppyReadFat
call debug_print_string
mov ax, 1
call floppy_logical_to_physical
mov bx, 0
mov ax, 0212h
int 13h
jnc read_fat_success
call reset_floppy
jmp read_fat
read_fat_success:
push word KERNEL_SEGMENT
pop es
mov ax, word [kernelCurrentCluster]
mov si, floppyReadCluster
call debug_print_string
read_cluster_contents:
add ax, 31
read_cluster_contents_perform:
mov si, floppyReadClusterIncrement
call debug_print_string
push ax
call floppy_logical_to_physical
mov ax, 0201h
mov bx, [kernelDestinationPointer]
int 13h
jnc read_cluster_contents_success
call reset_floppy
pop ax
jmp read_cluster_contents_perform
read_cluster_contents_success:
pop ax

16. calculate_next_cluster:
mov ax, [kernelCurrentCluster]
mov bx, 3
mul bx
dec bx
push ds
push DISK_BUFFER_SEGMENT
pop ds
mov si, ax
mov ax, word [ds:si]
pop ds
dec dx
jnz cluster_is_even
cluster_is_odd:
shr ax, 4
jmp calculate_Last_cluster
cluster_is_even:
and ax, 0FFFh
calculate_Last_cluster:
mov word [kernelCurrentCluster], ax
cmp ax, 0FF8h
jae transfer_control_to_kernel
add word [kernelDestinationPointer], 512
jmp read_cluster_contents
transfer_control_to_kernel:
mov al, byte [bootDriveNumber]
jmp KERNEL_SEGMENT:0000

17. Part1 Finished