If you know how an operating system works, it will help you a lot in programming, especially 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.
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. 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.
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:
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 used like 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 10h function 0Ah (AH = 0Ah). To move the cursor, I use the INT 10h function 2h (AH = 2h). To read sectors, I use the INT 13h function 2h (AH = 2h). To wait for a key stroke, use the INT 16h function 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 3.5 inch (1.44 MB) floppy Disk.
6. And set the address that INT 1E points at to the address of the Disk Parameter Block you set up.
7. Reset the drive (by using the INT 13h function 0).
8. Start reading the diskette by using the INT 13h function 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).
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:
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
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. To download the .NET 2.0 Framework, click here.) The building files are located in the download section.
S Keller from codeproject
Occupation: Systems Engineer
Location: United States United States