How to make your own operating system!!
Writing your own operating system.
Download project files - 4.51 Kb
Download BOOT sector utility - 41.4 Kb
Introduction
If you know how an operating system works, it will help you a lot in programmingespecially for system programs like device drivers; even for non-system-
programming, it can help a lot. And also, I'm sure every one would like to have their
own operating system.
You would also learn from this article how to read and write raw sectors from a disk.
Background
In this article, I would explain the first part of building an operating system.
Here is what happens when you start your computer:
1. The BIOS (Basic Input Output System – this is a program that comes with any
mother board and it is placed in a chip on the mother board) checks all the
computer components to make sure that they are all working.
2. If all the components are working, the BIOS starts searching for a drive that
might have an operating system. (The BIOS can look in hard drives, floppy
drives, CD-ROM drives etc. The order the BIOS checks can be set it in the BIOS
setup program. To get to the BIOS setup, right when the computer turns on,
press the DELETE key until you see the BIOS setup program; in some
computers, it can be a different button than DELETE, so look in your mother
board specification to find how to get to the BIOS setup program. And also look
up (if you don’t now how to do it) how to change the search search of BIOS
while looking for an operating system.)
3. The BIOS checks the first drive to see if he has a valid BOOT sector. (A disk is
divided into little regions that are named sectors. The BOOT sector size is 512
bytes in most drives.) If the drive has a valid BOOT sector, the BIOS loads that
sector in to the memory at address 0:7c00 (=31,744) and gives control to that
area of the memory.4. Restart your computer (make sure that the floppy diskette is in the drive), and
watch what our BOOT sector does.
With BOOTSectorUtility.exe, you can also search your regular operating system, by
saving the boot sector of the drive of your operating system to a file.
And to read that file, start the command line and type Debug <file path> (if you have
a Microsoft operating system).
The Debug command starts a 16 bit debugger (any boot sector is in 16 bit code,
because when the computer starts, it is in 16 bit mode, and only after the boot sector
is run, can it change the CPU to 32 bit mode or 64 bit mode). Press u <Enter> (u =
unassemble) to unassemble the file. Figure 1 shows an example.
Figure 1 Unassembeling 16 bit code.
Reading raw bytes from a drive
You can read raw sectors from a drive like this:4. Now this little program that was loaded from the BOOT sector continues to
load the operating system, and after the operating system is loaded, it
initializes the operating system and gives the control to the operating system.
Making a bootable disk
The steps would be like this:
1. Take a floppy diskette that you don't need.
2. Use the program that comes with this article, BOOTSectorUtility.exe, to copy the
file BOOT.bin to the floppy diskette BOOT sector.
3. Make sure that your BIOS is set to BOOT from the floppy drive first, so that our
operating system would be loaded.
Reading raw bytes from a drive:-
You can read raw sectors from a drive like this:
//
// Reading/writing raw sectors.
//
//pBuffer has to be at least 512 bytes wide.
BOOL ReadSector(char chDriveName,char *pBuffer,DWORD nSector)
{
char Buffer[256];
HANDLE hDevice;
DWORD dwBytesReaden;
//Init the drive name (as a Driver name).
sprintf(Buffer,"\\\\.\\%c:",chDriveName);
hDevice =
CreateFile(Buffer, // drive to open.
GENERIC_READ,
FILE_SHARE_READ | // share mode.
FILE_SHARE_WRITE,
NULL, // default security attributes.
OPEN_EXISTING, // disposition.
0, // file attributes.
NULL); //
if(hDrive==INVALID_HANDLE_VALUE)//if Error Openning a drive.
{
return FALSE;
}
//Move the read pointer to the right sector.
if(SetFilePointer(hDevice,
nSector*512,
NULL,
FILE_BEGIN)==0xFFFFFFFF)
return FALSE;
//Read the Sector.
ReadFile(hDevice,
pBuffer,
512,
&dwBytesReaden,
0);
//if Error reading the sector.
if(dwBytesReaden!=512)
return FALSE;
return TRUE;
}
Making a boot program:-
Now, I will explain the basics of a boot program (to understand this, you need to be
familiar with Assembler and Interrupts and Interrupts vector table).
[Interrupts vector table = From Address 0 -> 1,024 holds 256 structures (4 bytes in
size) that holds an address in the form: CS:IP = xxxx:xxxx. So you have addresses
from INT 1 -> INT 256. Each interrupt has an index into that table. This table is usedlike this: if you, for example, use the instruction INT 10h, the CPU checks in index
10h in the interrupt table were the address of the routine is that handles INT 10h,
and the CPU jumps to that address to execute it].
Now, I will explain how to print a string, read sectors, and wait for a key press using
only the BIOS.
To print a string, I use the INT 10hfunction 0Ah(AH = 0Ah). To move the cursor, I use
the INT 10hfunction 2h(AH = 2h). To read sectors, I use the INT 13hfunction 2h(AH
= 2h). To wait for a key stroke, use the INT 16hfunction 0h(AH = 0h).
I used TASM v3.1 and TLINK to make my boot sector, but you can use any x86 16 bit
assembler compiler.
(If you can't get a copy of TASM and TLINK, you can send me an e-mail and if it is
legal, I would send you a copy of them).
(TASM and TLINK v3.1 were released in 1992 by Borland International).
Now I would explain the steps the BOOT program does.
1. Make a stack frame (if not you don't have any stack).
2. Set the DS (data segment) so you can access the data.
3. In my boot sector, I added this: (Display a message to the user, Wait for a key
stroke, Continue).
4. Set up the Disk Parameter Block (the Disk Parameter Block is a structure that
holds information about the drive, like how much sectors it has etc., the drive
controller uses it for knowing how to read the disk in the drive).
5. To set the Disk Parameter Block, get its address (its address is pointed by INT
1Eh(in the memory, this is 1E x 4 bytes = 78h = 30 x 4 bytes = 120).
This is an example of how to initialize the Disk Parameter Block for a <!--?
xml:namespace prefix = st1 /-->3.5 inch (1.44 MB) floppy Disk.
StepRateAndHeadUnloadTime db 0DFh
HeadLoadTimeAndDMAModeFlag db 2h
DelayForMotorTurnOff db 25h
BytesPerSector db 2h
SectorsPerTrack db 12h
IntersectorGapLength db 1bh
DataLength db 0FFh
IntersectorGapLengthDuringFormat db 54h
FormatByteValue db 0F6h
HeadSettlingTime db 0Fh
DelayUntilMotorAtNormalSpeed db 8h
DisketteSectorAddress(as LBA)OfTheDataArea db 0
CylinderNumberToReadFrom db 0
SectorNumberToReadFrom db 0
DisketteSectorAddress (as LBA) OfTheRootDirectory db 0
6. And set the address that INT 1Epoints at to the address of the Disk Parameter
Block you set up.
7. Reset the drive (by using the INT 13hfunction 0).
8. Start reading the diskette by using the INT 13hfunction 2h.
9. Give control to the loaded operating system (this is done by inserting in the
code the op code of a jump to were you loaded the operating system. Let's say
you loaded the operating system 512 bytes from were the BIOS loaded the
BOOT sector (0:7c00h)
db 0E9h ; FAR JMP op code.
db 512 ; 512 bytes
or you can use another way: call some address, and there, change the return
address in the stack to were you want the jump to, like this:
call GiveControlToOS
GiveControlToOS:
Pop ax
Pop ax
Mov ax,CodeSegement ;Push the new CS to return.
Push ax
mov ax,InstructionPointer ;Push the new IP to return.
Push ax
ret ;Return to the modified address.
10. In the end of the boot sector the bytes would be 0x55h 0x0AAh. If the boot
sector doesn’t have this value, the BIOS would not load that boot sector.
After this, the BOOT sector finishes its job and the operating system starts running.
You can download the files I used for my boot sector here, the files are BOOT.asm,
BOOT.bin (this is the sector itself).
The BOOT sector program
.MODEL SMALL
.CODE
ORG 7c00h ;Because BIOS loades the OS at
; address 0:7C00h so ORG 7C00h
; makes that the refrence to date
; are with the right offset (7c00h).
ProgramStart:
; CS = 0 / IP = 7C00h // SS = ? / SP = ?
; You are now at address 7c00.
jmp start ;Here we start the, BIOS gave us now the control.
;///////////////////////////////////////////
;//Here goes all the data of the program.
;///////////////////////////////////////////
xCursor db 0
yCursor db 0
nSector db 0
nTrack db 0
nSide db 0
nDrive db 0
nTrays db 0
'Are You Ready to start Loading the OS...',0
szReady db
'Error Reading Drive, Press any Key to reboot...',0
szErrorReadingDrive db
;//Done Reading a track.
szPlaceMarker db '~~~~',0
szDone db 'Done',0
pOS dw 7E00h
;//Points to were to download the Operating System.
;//Disk Paremeter Table.
StepRateAndHeadUnloadTime db 0DFh
HeadLoadTimeAndDMAModeFlag db 2h
DelayForMotorTurnOff db 25h
;// (1 = 256) //(2 = 512 bytes)
BytesPerSector db 2h
;// 18 sectors in a track.
SectorsPerTrack db 18
IntersectorGapLength db 1Bh
DataLength db 0FFh
IntersectorGapLengthDuringFormat db 54h
FormatByteValue db 0F6h
HeadSettlingTime db 0Fh
DelayUntilMotorAtNormalSpeed db 8h
DisketteSectorAddress_as_LBA_OfTheDataArea db 0
CylinderNumberToReadFrom db 0
SectorNumberToReadFrom db 0
DisketteSectorAddress_as_LBA_OfTheRootDirectory db 0
;/////////////////////////////////
;//Here the program starts.
;/////////////////////////////////
Start:
CLI ;Clear Interupt Flag so while setting
;up the stack any intrupt would not be fired.
mov AX,7B0h ;lets have the stack start at 7c00h-256 = 7B00h
mov SS,ax ;SS:SP = 7B0h:256 = 7B00h:256
mov SP,256 ;Lets make the stack 256 bytes.
Mov ax,CS ;Set the data segment = CS = 0
mov DS,ax
XOR AX,AX ;Makes AX=0.
MOV ES,AX ;Make ES=0
STI ;Set Back the Interupt Flag after
;we finished setting a stack fram.
Call ClearScreen ;ClearScreen()
LEA AX,szReady ;Get Address of szReady.
CALL PrintMessage ;Call PrintfMessage()
CALL GetKey ;Call GetKey()
CALL SetNewDisketteParameterTable
;SetNewDisketteParameterTable()
CALL DownloadOS
CALL GetKey ;Call GetKey()
CALL FAR PTR GiveControlToOS ;Give Control To OS.
ret
;/////////////////////////////////////
;//Prints a message to the screen.
;/////////////////////////////////////
PrintMessage PROC
mov DI,AX ;AX holds the address of the string to Display.
Mov xCursor,1 ;Column.
ContinuPrinting:
cmp byte ptr [DI],0 ;Did we get to the End of String.
JE EndPrintingMessage ;if you gat to the end of the string return.
mov AH,2 ;Move Cursor
mov DH,yCursor ;row.
mov DL,xCursor ;column.
mov BH,0 ;page number.
INT 10h
INC xCursor
mov AH,0Ah ;Display Character Function.
mov AL,[DI] ;character to display.
mov BH,0 ;page number.
mov CX,1 ;number of times to write character
INT 10h
INC DI ;Go to next character.
JMP ContinuPrinting ;go to Print Next Character.
EndPrintingMessage:
Inc yCursor ;So Next time the message would
;be printed in the second line.
cmp yCursor,25
JNE dontMoveCorsurToBegin
Mov yCursor,0
dontMoveCorsurToBegin:
ret
PrintMessage EndP
;//////////////////////////////////////
;//Watis for the user to press a key.
;//////////////////////////////////////
GetKey PROC
mov ah,0
int 16h ;Wait for a key press.
Ret
GetKey EndP
;///////////////////////////////////////////
;//Gives Control To Second Part Loader.
;///////////////////////////////////////////
GiveControlToOS PROC
LEA AX,szDone
Call PrintMessage
CALL GetKey
db 0e9h ;Far JMP op code.
dw 512 ;JMP 512 bytes ahead.
; POP AX ;//Another why to make
;the CPU jump to a new place.
; POP AX
; Push 7E0h ;Push New CS address.
; Push 0 ;Push New IP address.
;The address that comes out is 7E00:0000.
;(512 bytes Higher from were BIOS Put us.)
; ret
GiveControlToOS EndP
;///////////////////////////////////
;//Clear Screen.
;///////////////////////////////////
ClearScreen PROC
mov ax,0600h ;//Scroll All Screen UP to Clear Screen.
mov bh,07
mov cx,0
mov dx,184fh
int 10h
Mov xCursor,0 ;//Set Corsur Position So next
//write would start in
//the beginning of screen.
Mov yCursor,0
Ret
ClearScreen EndP
;/////////////////////////////////
;//PrintPlaceMarker.
;/////////////////////////////////
PrintPlaceMarker PROC
LEA AX,szPlaceMarker
CALL PrintMessage ;Call PrintfMessage()
CALL GetKey ;Call GetKey()
ret
PrintPlaceMarker EndP
;/////////////////////////////////////////
;//Set New Disk Parameter Table
;/////////////////////////////////////////
SetNewDisketteParameterTable PROC
LEA DX,StepRateAndHeadUnloadTime
;//Get the address of the Disk Parameters Block.
;//Int 1E (that is in address 0:78h)
;//holds the address of the disk parametrs
;//block, so now change it to
;//our parametr black.
;//DX holds the address of our Parameters block.
MOV WORD PTR CS:[0078h],DX
MOV WORD PTR CS:[007Ah],0000
;Reset Drive To Update the DisketteParameterTable.
MOV AH,0
INT 13H
ret
SetNewDisketteParameterTable EndP
;///////////////////////////////////
;//DownloadOS
;///////////////////////////////////
DownloadOS PROC
mov nDrive,0
mov nSide,0
mov nTrack,0
mov nSector,1
ContinueDownload:
INC nSector ;Read Next Sector.
cmp nSector,19 ;Did we get to end of track.
JNE StayInTrack
CALL PrintPlaceMarker ;Print now '~~~~' so the user would
;now that we finished reding a track
INC nTrack ;If we gat to end of track Move to next track.
mov nSector,1 ;And Read Next Sector.
CMP nTrack,5 ;Read 5 Tracks (Modify this value
;to how much Tracks you want to read).
JE EndDownloadingOS
StayInTrack:
;ReadSector();
Call ReadSector
JMP ContinueDownload
;If diden't yet finish Loading OS.
EndDownloadingOS:
ret
DownloadOS EndP
;////////////////////////////////////////
;//Read Sector.
;////////////////////////////////////////
ReadSector PROC
mov nTrays,0
TryAgain:
mov AH,2 ;//Read Function.
mov AL,1 ;//1 Sector.
mov CH,nTrack
mov CL,nSector ;//Remember: Sectors start with 1, not 0.
mov DH,nSide
mov DL,nDrive
Mov BX,pOS ;//ES:BX points to the address
;to were to store the sector.
INT 13h
CMP AH,0 ;Int 13 return Code is in AH.
JE EndReadSector ;if 'Sucsess' (AH = 0) End function.
mov AH,0 ;Else Reset Drive . And Try Again...
INT 13h
cmp nTrays,3 ;Chack if you tryed reading
;more then 3 times.
JE DisplayError ; if tryed 3 Times Display Error.
INC nTrays
jmp TryAgain ;Try Reading again.
DisplayError:
LEA AX,szErrorReadingDrive
Call PrintMessage
Call GetKey
mov AH,0 ;Reboot Computer.
INT 19h
EndReadSector:
;ADD WORD PTR pOS,512 ;//Move the pointer
;(ES:BX = ES:pOS = 0:pOS) 512 bytes.
;//Here you set the varible
;pOS (pOS points to were BIOS
;//Would load the Next Sector).
Ret
ReadSector EndP
;////////////////////////////////////
;//
;////////////////////////////////////
END ProgramStart
Points of interest
It took some time until I got a running boot sector. I would list a couple of bugs I had
in the beginning while writing my boot sector.
1. I didn’t set up a right stack frame.
2. I didn’t modify the Disk Parameter Block.
3. I loaded the operating system to areas that are used by BIOS routines (and even
to the Interpret table).
4. In the end of the boot sector, it must have the bytes 0x55h 0x0AAh(this is a
signature that it is a valid bootable sector).
(For using BOOTSectorUtility.exe, you would need the .NET 2.0 Framework
installed on your computer.
If I see that this article interests people, I would write some more articles on this
subject.
Writing your own operating system.
Download project files - 4.51 Kb
Download BOOT sector utility - 41.4 Kb
Introduction
If you know how an operating system works, it will help you a lot in programmingespecially for system programs like device drivers; even for non-system-
programming, it can help a lot. And also, I'm sure every one would like to have their
own operating system.
You would also learn from this article how to read and write raw sectors from a disk.
Background
In this article, I would explain the first part of building an operating system.
Here is what happens when you start your computer:
1. The BIOS (Basic Input Output System – this is a program that comes with any
mother board and it is placed in a chip on the mother board) checks all the
computer components to make sure that they are all working.
2. If all the components are working, the BIOS starts searching for a drive that
might have an operating system. (The BIOS can look in hard drives, floppy
drives, CD-ROM drives etc. The order the BIOS checks can be set it in the BIOS
setup program. To get to the BIOS setup, right when the computer turns on,
press the DELETE key until you see the BIOS setup program; in some
computers, it can be a different button than DELETE, so look in your mother
board specification to find how to get to the BIOS setup program. And also look
up (if you don’t now how to do it) how to change the search search of BIOS
while looking for an operating system.)
3. The BIOS checks the first drive to see if he has a valid BOOT sector. (A disk is
divided into little regions that are named sectors. The BOOT sector size is 512
bytes in most drives.) If the drive has a valid BOOT sector, the BIOS loads that
sector in to the memory at address 0:7c00 (=31,744) and gives control to that
area of the memory.4. Restart your computer (make sure that the floppy diskette is in the drive), and
watch what our BOOT sector does.
With BOOTSectorUtility.exe, you can also search your regular operating system, by
saving the boot sector of the drive of your operating system to a file.
And to read that file, start the command line and type Debug <file path> (if you have
a Microsoft operating system).
The Debug command starts a 16 bit debugger (any boot sector is in 16 bit code,
because when the computer starts, it is in 16 bit mode, and only after the boot sector
is run, can it change the CPU to 32 bit mode or 64 bit mode). Press u <Enter> (u =
unassemble) to unassemble the file. Figure 1 shows an example.
Figure 1 Unassembeling 16 bit code.
Reading raw bytes from a drive
You can read raw sectors from a drive like this:4. Now this little program that was loaded from the BOOT sector continues to
load the operating system, and after the operating system is loaded, it
initializes the operating system and gives the control to the operating system.
Making a bootable disk
The steps would be like this:
1. Take a floppy diskette that you don't need.
2. Use the program that comes with this article, BOOTSectorUtility.exe, to copy the
file BOOT.bin to the floppy diskette BOOT sector.
3. Make sure that your BIOS is set to BOOT from the floppy drive first, so that our
operating system would be loaded.
Reading raw bytes from a drive:-
You can read raw sectors from a drive like this:
//
// Reading/writing raw sectors.
//
//pBuffer has to be at least 512 bytes wide.
BOOL ReadSector(char chDriveName,char *pBuffer,DWORD nSector)
{
char Buffer[256];
HANDLE hDevice;
DWORD dwBytesReaden;
//Init the drive name (as a Driver name).
sprintf(Buffer,"\\\\.\\%c:",chDriveName);
hDevice =
CreateFile(Buffer, // drive to open.
GENERIC_READ,
FILE_SHARE_READ | // share mode.
FILE_SHARE_WRITE,
NULL, // default security attributes.
OPEN_EXISTING, // disposition.
0, // file attributes.
NULL); //
if(hDrive==INVALID_HANDLE_VALUE)//if Error Openning a drive.
{
return FALSE;
}
//Move the read pointer to the right sector.
if(SetFilePointer(hDevice,
nSector*512,
NULL,
FILE_BEGIN)==0xFFFFFFFF)
return FALSE;
//Read the Sector.
ReadFile(hDevice,
pBuffer,
512,
&dwBytesReaden,
0);
//if Error reading the sector.
if(dwBytesReaden!=512)
return FALSE;
return TRUE;
}
Making a boot program:-
Now, I will explain the basics of a boot program (to understand this, you need to be
familiar with Assembler and Interrupts and Interrupts vector table).
[Interrupts vector table = From Address 0 -> 1,024 holds 256 structures (4 bytes in
size) that holds an address in the form: CS:IP = xxxx:xxxx. So you have addresses
from INT 1 -> INT 256. Each interrupt has an index into that table. This table is usedlike this: if you, for example, use the instruction INT 10h, the CPU checks in index
10h in the interrupt table were the address of the routine is that handles INT 10h,
and the CPU jumps to that address to execute it].
Now, I will explain how to print a string, read sectors, and wait for a key press using
only the BIOS.
To print a string, I use the INT 10hfunction 0Ah(AH = 0Ah). To move the cursor, I use
the INT 10hfunction 2h(AH = 2h). To read sectors, I use the INT 13hfunction 2h(AH
= 2h). To wait for a key stroke, use the INT 16hfunction 0h(AH = 0h).
I used TASM v3.1 and TLINK to make my boot sector, but you can use any x86 16 bit
assembler compiler.
(If you can't get a copy of TASM and TLINK, you can send me an e-mail and if it is
legal, I would send you a copy of them).
(TASM and TLINK v3.1 were released in 1992 by Borland International).
Now I would explain the steps the BOOT program does.
1. Make a stack frame (if not you don't have any stack).
2. Set the DS (data segment) so you can access the data.
3. In my boot sector, I added this: (Display a message to the user, Wait for a key
stroke, Continue).
4. Set up the Disk Parameter Block (the Disk Parameter Block is a structure that
holds information about the drive, like how much sectors it has etc., the drive
controller uses it for knowing how to read the disk in the drive).
5. To set the Disk Parameter Block, get its address (its address is pointed by INT
1Eh(in the memory, this is 1E x 4 bytes = 78h = 30 x 4 bytes = 120).
This is an example of how to initialize the Disk Parameter Block for a <!--?
xml:namespace prefix = st1 /-->3.5 inch (1.44 MB) floppy Disk.
StepRateAndHeadUnloadTime db 0DFh
HeadLoadTimeAndDMAModeFlag db 2h
DelayForMotorTurnOff db 25h
BytesPerSector db 2h
SectorsPerTrack db 12h
IntersectorGapLength db 1bh
DataLength db 0FFh
IntersectorGapLengthDuringFormat db 54h
FormatByteValue db 0F6h
HeadSettlingTime db 0Fh
DelayUntilMotorAtNormalSpeed db 8h
DisketteSectorAddress(as LBA)OfTheDataArea db 0
CylinderNumberToReadFrom db 0
SectorNumberToReadFrom db 0
DisketteSectorAddress (as LBA) OfTheRootDirectory db 0
6. And set the address that INT 1Epoints at to the address of the Disk Parameter
Block you set up.
7. Reset the drive (by using the INT 13hfunction 0).
8. Start reading the diskette by using the INT 13hfunction 2h.
9. Give control to the loaded operating system (this is done by inserting in the
code the op code of a jump to were you loaded the operating system. Let's say
you loaded the operating system 512 bytes from were the BIOS loaded the
BOOT sector (0:7c00h)
db 0E9h ; FAR JMP op code.
db 512 ; 512 bytes
or you can use another way: call some address, and there, change the return
address in the stack to were you want the jump to, like this:
call GiveControlToOS
GiveControlToOS:
Pop ax
Pop ax
Mov ax,CodeSegement ;Push the new CS to return.
Push ax
mov ax,InstructionPointer ;Push the new IP to return.
Push ax
ret ;Return to the modified address.
10. In the end of the boot sector the bytes would be 0x55h 0x0AAh. If the boot
sector doesn’t have this value, the BIOS would not load that boot sector.
After this, the BOOT sector finishes its job and the operating system starts running.
You can download the files I used for my boot sector here, the files are BOOT.asm,
BOOT.bin (this is the sector itself).
The BOOT sector program
.MODEL SMALL
.CODE
ORG 7c00h ;Because BIOS loades the OS at
; address 0:7C00h so ORG 7C00h
; makes that the refrence to date
; are with the right offset (7c00h).
ProgramStart:
; CS = 0 / IP = 7C00h // SS = ? / SP = ?
; You are now at address 7c00.
jmp start ;Here we start the, BIOS gave us now the control.
;///////////////////////////////////////////
;//Here goes all the data of the program.
;///////////////////////////////////////////
xCursor db 0
yCursor db 0
nSector db 0
nTrack db 0
nSide db 0
nDrive db 0
nTrays db 0
'Are You Ready to start Loading the OS...',0
szReady db
'Error Reading Drive, Press any Key to reboot...',0
szErrorReadingDrive db
;//Done Reading a track.
szPlaceMarker db '~~~~',0
szDone db 'Done',0
pOS dw 7E00h
;//Points to were to download the Operating System.
;//Disk Paremeter Table.
StepRateAndHeadUnloadTime db 0DFh
HeadLoadTimeAndDMAModeFlag db 2h
DelayForMotorTurnOff db 25h
;// (1 = 256) //(2 = 512 bytes)
BytesPerSector db 2h
;// 18 sectors in a track.
SectorsPerTrack db 18
IntersectorGapLength db 1Bh
DataLength db 0FFh
IntersectorGapLengthDuringFormat db 54h
FormatByteValue db 0F6h
HeadSettlingTime db 0Fh
DelayUntilMotorAtNormalSpeed db 8h
DisketteSectorAddress_as_LBA_OfTheDataArea db 0
CylinderNumberToReadFrom db 0
SectorNumberToReadFrom db 0
DisketteSectorAddress_as_LBA_OfTheRootDirectory db 0
;/////////////////////////////////
;//Here the program starts.
;/////////////////////////////////
Start:
CLI ;Clear Interupt Flag so while setting
;up the stack any intrupt would not be fired.
mov AX,7B0h ;lets have the stack start at 7c00h-256 = 7B00h
mov SS,ax ;SS:SP = 7B0h:256 = 7B00h:256
mov SP,256 ;Lets make the stack 256 bytes.
Mov ax,CS ;Set the data segment = CS = 0
mov DS,ax
XOR AX,AX ;Makes AX=0.
MOV ES,AX ;Make ES=0
STI ;Set Back the Interupt Flag after
;we finished setting a stack fram.
Call ClearScreen ;ClearScreen()
LEA AX,szReady ;Get Address of szReady.
CALL PrintMessage ;Call PrintfMessage()
CALL GetKey ;Call GetKey()
CALL SetNewDisketteParameterTable
;SetNewDisketteParameterTable()
CALL DownloadOS
CALL GetKey ;Call GetKey()
CALL FAR PTR GiveControlToOS ;Give Control To OS.
ret
;/////////////////////////////////////
;//Prints a message to the screen.
;/////////////////////////////////////
PrintMessage PROC
mov DI,AX ;AX holds the address of the string to Display.
Mov xCursor,1 ;Column.
ContinuPrinting:
cmp byte ptr [DI],0 ;Did we get to the End of String.
JE EndPrintingMessage ;if you gat to the end of the string return.
mov AH,2 ;Move Cursor
mov DH,yCursor ;row.
mov DL,xCursor ;column.
mov BH,0 ;page number.
INT 10h
INC xCursor
mov AH,0Ah ;Display Character Function.
mov AL,[DI] ;character to display.
mov BH,0 ;page number.
mov CX,1 ;number of times to write character
INT 10h
INC DI ;Go to next character.
JMP ContinuPrinting ;go to Print Next Character.
EndPrintingMessage:
Inc yCursor ;So Next time the message would
;be printed in the second line.
cmp yCursor,25
JNE dontMoveCorsurToBegin
Mov yCursor,0
dontMoveCorsurToBegin:
ret
PrintMessage EndP
;//////////////////////////////////////
;//Watis for the user to press a key.
;//////////////////////////////////////
GetKey PROC
mov ah,0
int 16h ;Wait for a key press.
Ret
GetKey EndP
;///////////////////////////////////////////
;//Gives Control To Second Part Loader.
;///////////////////////////////////////////
GiveControlToOS PROC
LEA AX,szDone
Call PrintMessage
CALL GetKey
db 0e9h ;Far JMP op code.
dw 512 ;JMP 512 bytes ahead.
; POP AX ;//Another why to make
;the CPU jump to a new place.
; POP AX
; Push 7E0h ;Push New CS address.
; Push 0 ;Push New IP address.
;The address that comes out is 7E00:0000.
;(512 bytes Higher from were BIOS Put us.)
; ret
GiveControlToOS EndP
;///////////////////////////////////
;//Clear Screen.
;///////////////////////////////////
ClearScreen PROC
mov ax,0600h ;//Scroll All Screen UP to Clear Screen.
mov bh,07
mov cx,0
mov dx,184fh
int 10h
Mov xCursor,0 ;//Set Corsur Position So next
//write would start in
//the beginning of screen.
Mov yCursor,0
Ret
ClearScreen EndP
;/////////////////////////////////
;//PrintPlaceMarker.
;/////////////////////////////////
PrintPlaceMarker PROC
LEA AX,szPlaceMarker
CALL PrintMessage ;Call PrintfMessage()
CALL GetKey ;Call GetKey()
ret
PrintPlaceMarker EndP
;/////////////////////////////////////////
;//Set New Disk Parameter Table
;/////////////////////////////////////////
SetNewDisketteParameterTable PROC
LEA DX,StepRateAndHeadUnloadTime
;//Get the address of the Disk Parameters Block.
;//Int 1E (that is in address 0:78h)
;//holds the address of the disk parametrs
;//block, so now change it to
;//our parametr black.
;//DX holds the address of our Parameters block.
MOV WORD PTR CS:[0078h],DX
MOV WORD PTR CS:[007Ah],0000
;Reset Drive To Update the DisketteParameterTable.
MOV AH,0
INT 13H
ret
SetNewDisketteParameterTable EndP
;///////////////////////////////////
;//DownloadOS
;///////////////////////////////////
DownloadOS PROC
mov nDrive,0
mov nSide,0
mov nTrack,0
mov nSector,1
ContinueDownload:
INC nSector ;Read Next Sector.
cmp nSector,19 ;Did we get to end of track.
JNE StayInTrack
CALL PrintPlaceMarker ;Print now '~~~~' so the user would
;now that we finished reding a track
INC nTrack ;If we gat to end of track Move to next track.
mov nSector,1 ;And Read Next Sector.
CMP nTrack,5 ;Read 5 Tracks (Modify this value
;to how much Tracks you want to read).
JE EndDownloadingOS
StayInTrack:
;ReadSector();
Call ReadSector
JMP ContinueDownload
;If diden't yet finish Loading OS.
EndDownloadingOS:
ret
DownloadOS EndP
;////////////////////////////////////////
;//Read Sector.
;////////////////////////////////////////
ReadSector PROC
mov nTrays,0
TryAgain:
mov AH,2 ;//Read Function.
mov AL,1 ;//1 Sector.
mov CH,nTrack
mov CL,nSector ;//Remember: Sectors start with 1, not 0.
mov DH,nSide
mov DL,nDrive
Mov BX,pOS ;//ES:BX points to the address
;to were to store the sector.
INT 13h
CMP AH,0 ;Int 13 return Code is in AH.
JE EndReadSector ;if 'Sucsess' (AH = 0) End function.
mov AH,0 ;Else Reset Drive . And Try Again...
INT 13h
cmp nTrays,3 ;Chack if you tryed reading
;more then 3 times.
JE DisplayError ; if tryed 3 Times Display Error.
INC nTrays
jmp TryAgain ;Try Reading again.
DisplayError:
LEA AX,szErrorReadingDrive
Call PrintMessage
Call GetKey
mov AH,0 ;Reboot Computer.
INT 19h
EndReadSector:
;ADD WORD PTR pOS,512 ;//Move the pointer
;(ES:BX = ES:pOS = 0:pOS) 512 bytes.
;//Here you set the varible
;pOS (pOS points to were BIOS
;//Would load the Next Sector).
Ret
ReadSector EndP
;////////////////////////////////////
;//
;////////////////////////////////////
END ProgramStart
Points of interest
It took some time until I got a running boot sector. I would list a couple of bugs I had
in the beginning while writing my boot sector.
1. I didn’t set up a right stack frame.
2. I didn’t modify the Disk Parameter Block.
3. I loaded the operating system to areas that are used by BIOS routines (and even
to the Interpret table).
4. In the end of the boot sector, it must have the bytes 0x55h 0x0AAh(this is a
signature that it is a valid bootable sector).
(For using BOOTSectorUtility.exe, you would need the .NET 2.0 Framework
installed on your computer.
If I see that this article interests people, I would write some more articles on this
subject.
Comments
Post a Comment