Creating Your Own Operating System

Pritam Zope
7y
8.7k
0
12

100

Article

MyOS.zip|MyOS.zip|MyOS.zip|MyOS.zip|MyOS.zip

In this article, we will write our own bootloader using 16-bit assembly language to create our own operating system.

Introduction

Writing an operating system is the most complicated task in the world of programming.

The first part of an operating system is the Bootloader. Bootloader is a piece of program that runs before the operating system starts running. It is used to boot other operating systems and usually each operating system has a set of bootloaders specific for it. Bootloaders usually contain several ways to boot the OS kernel and also contains commands for debugging and/or modifying the kernel environment.

We will create a 3 stage OS. The first stage is to just display messages on the screen with colors, the second is to take input from user, and third stage is for drawing. The bootloaders are generally written in 16-bit assembly (also called Real mode), then the bits can be extended to 32-bit (Protected mode).

So, the bootloaders must be written in 16-bit assembly. Before you move to the next part, you must have some knowledge about 16-bit assembly language. Quick review of 16-bit registers.

Data registers

AX is the primary accumulator; it is used in input/output and most arithmetic instructions.

BX is known as the base register, and it could be used in indexed addressing.

CX is known as the count register; CX registers store the loop count in iterative operations.

DX is known as the data register. It is also used in input/output operations.

Index Registers

Source Index (SI)
It is used as source index for string operations.
Destination Index (DI)
It is used as destination index for string operations.
Segment registers
Data segment(DS), Code segment(CS), Extra segment(ES), Stack segment(SS)
8-bit registers AH, AL, BH, BL, CH, CL, DH, and DL.
where H is higher & L is Lower.
AH(8-15)+AL(0-7) = AX

For more, learn 16 bit assembly language tutorial and BIOS interrupts in assembly. Download the source code to view the complete OS code.

Requirements

You need an assembler (that can convert your assembly instructions into raw binary format) and a simulator to view. I am using NASM (Netwide Assembler) and QEMU (Quick Emulator). For Linux, type the following commands to install NASM & QEMU.

sudo apt-get install nasm
sudo apt-get install qemu qemu-system-x86_64

For Windows, download them from the following sites respectively and install.

http://www.nasm.us/
https://qemu.weilnetz.de/

Coding

Starting of coding always comes with printing Hello World, doesn't it ? Here's the code that prints "Hello World! " on screen.

(file = hello_world.asm)

[bits 16] ; tell assembler that working in real mode(16 bit mode)
[org 0x7c00] ; organize from 0x7C00 memory location where BIOS will load us
start: ; start label from where our code starts
xor ax,ax ; set ax register to 0
mov ds,ax ; set data segment(ds) to 0
mov es,ax ; set extra segment(es) to 0
mov bx,0x8000
mov si, hello_world ; point hello_world to source index
call print_string ; call print different color string function
hello_world db 'Hello World!',13,0
print_string:
mov ah, 0x0E ; value to tell interrupt handler that take value from al & print it
.repeat_next_char:
lodsb ; get character from string
cmp al, 0 ; cmp al with end of string
je .done_print ; if char is zero, end of string
int 0x10 ; otherwise, print it
jmp .repeat_next_char ; jmp to .repeat_next_char if not 0
.done_print:
ret ;return
times (510 - ($ - $$)) db 0x00 ;set 512 bytes for boot sector which are necessary
dw 0xAA55 ; boot signature 0xAA & 0x55

OK! Now, what the hell is this ?

[bits 16]

This line tells the assember that you are working in 16-bit real mode. It will convert the assembly data to 16-bit binary form.

[org 0x7c00]

This is assember directive. 0x7c00 is the memory location where BIOS will load us.

xor ax,ax

mov ds,ax

mov es,ax

mov bx,0x8000

First, we are setting the registers (such as ax, ds, and es) to zero, which we will use further. Then, we will copy the memory location 0x8000 to bx register because we want to perform operations/instructions. As we are loaded at 0x7c00 memory location, we need memory location above it.

hello_world db 'Hello World!',13,0

The above line defines the string with label hello_world, where 13 is New line and 0 is end of string.

mov si, hello_world

call print_string

Pointing to the first character of hello_world string to source index (si) register and then calling print_string function. Copying 0x0E to ah register. This will tell to interrupt handler that takes value/ASCII character from al & prints it using int 0x10.

AH = 0x0E

AL = character

BH = page

BL = color (graphics mode)

int 0x10

.repeat_next_char Label for continue to loop until end of string occurs.

lodsb
This instruction loads the first character from si to al register using ASCII code. Then, we will compare whether al contains 0 or not. If not, then print it and jump to loop, otherwise jump to .done_print.

int 0x10
This is BIOS video interrupt which takes char value from al register & prints it.

times (510 - ($ - $$)) db 0x00
A boot sector always be a 512 byte. starting with address 0x00.because on hard drive, there are only 512 bytes of sectors.

dw 0xAA55
This is the magic number of bootable devices. This line is boot signature that makes our code into bootable code. It defines word 0xAA & 0x55. These are last two bytes of our first sector.

Because of this number, BIOS loads us at 0x7c00 location when computer starts.

For Linux, type the following command to compile file.

nasm -f bin hello_world.asm -o myos.bin

Once file is compiled successfully and myos.bin file is created, run it in QEMU.

qemu-system-x86_64 myos.bin

For Windows, open NASM application. It will prompt a command at location where NASM is installed. Perform same commands as performed for linux, just with giving full file name path.

Consider I have file in C:\Users\Pritam\Documents\temp folder.

nasm.exe -f bin "C:\Users\Pritam\Documents\temp\hello_world.asm" -o "C:\Users\Pritam\Documents\temp\myos.bin"

and to run in QEMU.

"C:\Program Files\qemu\qemu-system-x86_64.exe" "C:\Users\Pritam\Documents\temp\myos.bin"

where i have installed QEMU.

This will print the following output.

Here, I have created .bin file but you can also create .iso file. Once it successfully prints "Hello World!", attach secondary device/USB drive and boot .bin/.iso in it. You can use dd command on linux or rufus software on Windows.

To print a string on screen at specific location or to set cursor at specific location, use the following actions.

AH = 0x02

BH = page

DH = row

DL = column

e.g

mov ah,0x02 ; set value for change to cursor position
mov bh,0x00 ; page
mov dh,0x06 ; y cordinate/row
mov dl,0x05 ; x cordinate/col
int 0x10
mov si, hello_world
call print_string

To get input first, set ax to 0x00 and call int 0x16. To display a character which has been input, move ah to 0x0E and call int 0x10. It will store char value to al register & key code to ah register.

e.g

inputLoop:
mov ax,0x00
int 0x16
cmp ah,0x1C ; compare input is enter(1C) or not
je .inputLoop
cmp al,0x61 ; compare input is character 'a' or not
je exitLoop
mov ah,0x0E ;display input char
int 0x10
exitLoop:
ret

As described above every sector has a size of only 512 bytes, if you write code which is taking more than 512 bytes, it will not work and assembler will give you an error.

So, to use more memory, you need to load/read next sector into main memory. To load/read sectors in main memory,

AH = sector number(1,2,3 etc.)[1 is already taken by our bootloader]
AL = number of sectors to read
DL = type of memory from where to read(0x80 is for hard drive/USB drive)
CH = cylinder number
DH = head number
CL = sector number
BX = memory location where to jump after loaded
int 0x13 = Disk I/O interrupt

Then, jump to your memory location (label in assembly).

e.g

; load second sector from memory
mov ah, 0x02 ; load second stage to memory
mov al, 1 ; numbers of sectors to read into memory
mov dl, 0x80 ; sector read from fixed/usb disk
mov ch, 0 ; cylinder number
mov dh, 0 ; head number
mov cl, 2 ; sector number
mov bx, _OS_Stage_2 ; load into es:bx segment :offset of buffer
int 0x13 ; disk I/O interrupt
jmp _OS_Stage_2 ; jump to second stage

For clearing the screen, copy 0x13 to ax & call video interrupt.

mov ax,0x13
int 0x10

For graphics, we need to access video memory segments. This can be done by pushing 0x0A000 into stack, and setting di,ax,es to specific values.

AX = color

DI = x & y cordinates(y=320 for next line(320*200 display))

[ES:DI] = value of x,y cordinates & color(AX)[segment :offset]

Here's the code that only draws our graphical simple window on a screen with text.

mov ax,0x13 ; clears the screen
int 0x10
;//////////////////////////////////////////////////////////
; drawing window with lines
push 0x0A000 ; video memory graphics segment
pop es ; pop any extar segments from stack
xor di,di ; set destination index to 0
xor ax,ax ; set color register to zero
;//////////////////////////////////////////////
;******drawing top line of our window
mov ax,0x02 ; set color to green
mov dx,0 ; initialize counter(dx) to 0
add di,320 ; add di to 320(next line)
imul di,10 ;multiply by 10 to di to set y cordinate from where we need to start drawing
add di,10 ;set x cordinate of line from where to be drawn
_topLine_perPixel_Loop:
mov [es:di],ax ; move value ax to memory location es:di
inc di ; increment di for next pixel
inc dx ; increment our counter
cmp dx,300 ; comprae counter value with 300
jbe _topLine_perPixel_Loop ; if <= 300 jump to _topLine_perPixel_Loop
hlt ; halt process after drawing
;//////////////////////////////////////////////
;******drawing bottm line of our window
xor dx,dx
xor di,di
add di,320
imul di,190 ; set y cordinate for line to be drawn
add di,10 ;set x cordinate of line to be drawn
mov ax,0x01 ; blue color
_bottmLine_perPixel_Loop:
mov [es:di],ax
inc di
inc dx
cmp dx,300
jbe _bottmLine_perPixel_Loop
hlt
;//////////////////////////////////////////////
;******drawing left line of our window
xor dx,dx
xor di,di
add di,320
imul di,10 ; set y cordinate for line to be drawn
add di,10 ; set x cordinate for line to be drawn
mov ax,0x03 ; cyan color
_leftLine_perPixel_Loop:
mov [es:di],ax
inc dx
add di,320
cmp dx,180
jbe _leftLine_perPixel_Loop
hlt
;//////////////////////////////////////////////
;******drawing right line of our window
xor dx,dx
xor di,di
add di,320
imul di,10 ; set y cordinate for line to be drawn
add di,310 ; set x cordinate for line to be drawn
mov ax,0x06 ; orange color
_rightLine_perPixel_Loop:
mov [es:di],ax
inc dx
add di,320
cmp dx,180
jbe _rightLine_perPixel_Loop
hlt
;//////////////////////////////////////////////
;******drawing line below top line of our window
xor dx,dx
xor di,di
add di,320
imul di,27 ; set y cordinate for line to be drawn
add di,11 ; set x cordinate for line to be drawn
mov ax,0x05 ; pink color
_belowLineTopLine_perPixel_Loop:
mov [es:di],ax
inc di
inc dx
cmp dx,298
jbe _belowLineTopLine_perPixel_Loop
hlt
;***** print window_text & X char
;set cursor to specific position
mov ah,0x02
mov bh,0x00
mov dh,0x01 ; y cordinate
mov dl,0x02 ; x cordinate
int 0x10
mov si,window_text ; point si to window_text
call _print_YellowColor_String
hlt
;set cursor to specific position
mov ah,0x02
mov bh,0x00
mov dh,0x02 ; y cordinate
mov dl,0x25 ; x cordinate
int 0x10
mov ah,0x0E
mov al,0x58 ; 0x58=X
mov bh,0x00
mov bl,4 ; red color
int 0x10
hlt
;set cursor to specific position
mov ah,0x02
mov bh,0x00
mov dh,0x02 ; y cordinate
mov dl,0x23 ; x cordinate
int 0x10
mov ah,0x0E
mov al,0x5F ; 0x5F= _
mov bh,0x00
mov bl,9 ; red color
int 0x10
hlt
;set cursor to specific position
mov ah,0x02
mov bh,0x00
mov dh,0x05 ; y cordinate
mov dl,0x09 ; x cordinate
int 0x10
mov si,hello_world_text
call _print_DiffColor_String
hlt
;set cursor to specific position
mov ah,0x02
mov bh,0x00
mov dh,0x12 ; y cordinate
mov dl,0x03 ; x cordinate
int 0x10
mov si,display_text
call _print_WhiteColor_String
hlt

Here hello_world_text and window_text are defined in first sector.