{"id":217,"date":"2022-04-11T08:59:47","date_gmt":"2022-04-11T08:59:47","guid":{"rendered":"https:\/\/wqrld.net\/blog\/?p=217"},"modified":"2022-04-18T09:28:22","modified_gmt":"2022-04-18T09:28:22","slug":"building-a-boot-sector-os","status":"publish","type":"post","link":"https:\/\/wqrld.net\/blog\/building-a-boot-sector-os\/","title":{"rendered":"Building a boot-sector OS"},"content":{"rendered":"\n

<\/p>\n\n\n\n

Many technical people always want to re-invent the wheel. “Operating systems are bloated” and all kinds of that stuff. I challenge you to make your own. (with a bit of help from this tutorial, i won’t leave you hanging \ud83d\ude42 )<\/p>\n\n\n\n

Tools<\/h2>\n\n\n\n

We are going to build a simle boot sector operating system. This is basically a operating system that fits in the first 512 bytes that the bios initializes when executing code on a disk.<\/p>\n\n\n\n

To do this we will need 3 tools:
– NASM: A x86 assembler to turn your assembly language into a binary file.
– QEMU – Quick emulator. This can natively deal with your raw binary files and has text output
– Any text editor, i like nano<\/p>\n\n\n\n

On a linux debian-y based os, these can be installed with:
apt -y install nasm qemu-system-x86 nano<\/code><\/p>\n\n\n\n

Simple boot sector<\/h2>\n\n\n\n
jmp $   ; jump to current address - infinite loop\n\ntimes 510-($-$$) db 0\n     ; fill the empty space with zeroes\n\ndw 0xaa55            ; write the magic bytes 55 aa at the end of our file.\n<\/code><\/pre>\n\n\n\n
This is a simple piece of assembly that will jump infinitely to the current address. This will not do much appart from spinning up your fans, but it will be a great start!<\/p>\n\n\n\n
The middle line fills the empty space with zeroes. $ is an alias for the current line and $$ is the alias for the start of your program. So with 510-($-$$) you can pad the program to be exactly 510 bytes (and then 2 for the magic bytes following to make our 512) docs<\/a><\/p>\n\n\n\n
As you can see, comments are added with the ; symbol. This works just like pyhon’s # or javascript’s \/\/. It is smart to add plenty of comments to your assembly code as it will otherwise become quite hard to read.<\/p>\n\n\n\n
We have to fill the last 2 bytes with 0xaa55 to show the BIOS that we have an operating system here. It wouldn’t be good if you started booting from your game storage disk would it?<\/p>\n\n\n\n
Running our first program<\/h2>\n\n\n\n
Save your code to a file called boot.asm and then run<\/p>\n\n\n\n
nasm boot.asm -f bin -o boot_sect.bin<\/code><\/p>\n\n\n\n
to assemble boot.asm  into a boot_sect.bin that your pc can understand. And then you can use<\/p>\n\n\n\n
qemu-system-x86_64 boot_sect.bin -curses<\/code><\/p>\n\n\n\n
To boot, -curses will emulate the vga text on your screen.<\/p>\n\n\n\n
\"\"\/
You should see the bios boot screen pop up and see one core shoot to 100% (your jmp loop)<\/figcaption><\/figure>\n\n\n\n
You might not be able to ctrl-c\/z out of this. If this is the case you can open a separate shell and kill the qemu process id: kill $(ps -ef | grep curses | awk '{print $2}' | head -n 1)<\/code><\/p>\n\n\n\n
But thats just a bios boot screen?!<\/h2>\n\n\n\n
mov ah, 0x0e ; BIOS routine scrolling teletype\n\nmov al, 'H' ; move byte for 'F' into the al register\nint 0x10   ; execute the 0x10 \"print to screen\" interrupt\nmov al, 'E'\nint 0x10\nmov al, 'L'\nint 0x10\nmov al, 'L'\nint 0x10\nmov al, 'O'\nint 0x10\nmov al, '!'\nint 0x10\n\n\n\njmp $ ; freeze the screen so we can see our text\n\n\ntimes 510-($-$$) db 0\n\n\n\ndw 0xaa55 ; magic bytes<\/code><\/pre>\n\n\n\n
The code above will use a BIOS routine to print some text to your screen. Try it yourself and play around a bit with the text.<\/p>\n\n\n\n
The code first loads the routine name into the AH register and then the ascii code for the letter in the AL register. Then it calls the 0x10 interrupt which tells the BIOS to use the AH and AL register to print something to the screen. You can find more on registers here<\/a>. (absolutely worth reading after this article)<\/p>\n\n\n\n
—<\/p>\n\n\n\n
And then assemble and run:<\/p>\n\n\n\n
\"\"\/
Yay!<\/figcaption><\/figure>\n\n\n\n
Logic<\/h2>\n\n\n\n
Right now we are just manually printing out registers, but it wouldn’t be a computer with some compute. So let’s do a simple calculation<\/p>\n\n\n\n
mov ah, 0x0e ; BIOS text typing routine\r\n\r\nmov al, '1' ; our text, to make it look better\r\nint 0x10\r\nmov al, ' '\r\nint 0x10\r\nmov al, '+'\r\nint 0x10\r\nmov al, ' '\r\nint 0x10\r\nmov al, '1'\r\nint 0x10\r\nmov al, ' '\r\nint 0x10\r\nmov al, '='\r\nint 0x10\r\nmov al, ' '\r\nint 0x10\r\n\r\n\r\n; We are upping the ascii code here, not the actual integer\r\nmov cl, 49 ; ascii code for '1', make sure to use another 8 bit register\r\nadd cl, 1 ; after '1' comes '2'\r\nmov al, cl ; move to the al register that is used for printing\r\nint 0x10 ; print!\r\n\r\n\r\njmp $ ; freeze the screen so we can see our text\r\n\r\ntimes 510-($-$$) db 0\r\n\ndw 0xaa55 ; magic bytes<\/code><\/pre>\n\n\n\n
The import part here is the block right above the jmp $ instruction.<\/p>\n\n\n\n
Old computers use what’s called an “ascii table”, this is basically a mapping between numbers (bytes) and letters.<\/p>\n\n\n\n
\"ASCII<\/figure>\n\n\n\n
As you can see, we start by moving the decimal number 49 into the cl (8 bit) register. In The table this corresponds to a ‘1’. Nasm also lets you move the actual character directly but that does the same thing under the hood.<\/p>\n\n\n\n
The cool thing with ascii is that they are just numbers, you can increment 1 and get 2. But you can also increment 57 by one and end up with a “:”.<\/p>\n\n\n\n
The order of arguments might be a mit misleading to anyone who has never worked with assembly. Generally we use the first argument as the destination, and the second as source. You can see this quite well in the add and mov instructions.<\/p>\n\n\n\n
So let’s compile it and try!<\/p>\n\n\n\n
\"\"
yay!<\/figcaption><\/figure>\n\n\n\n
Functions and loops<\/h2>\n\n\n\n
(WIP chapter) It would be a lot easier if  we could print strings at once. Here’s a function that does just that!<\/p>\n\n\n\n
Do not forget the org symbol, this mentions where the code\/data of your program is located so you can use indirect addressing with square brackets.<\/p>\n\n\n\n
Caveat: In This way of recursively calling yourself, the stack will not be restored when the null byte is called. How do we fix this?<\/p>\n\n\n\n
[org 0x7c00]\r\n\r\nmov ah, 0x0e ; BIOS text typing routine\r\n\r\nmov bx, str\r\ncall printstring\r\n\r\nfreeze:\r\n  jmp $ ; freeze the screen so we can see our text\r\n\r\n\r\nprintstring:\r\n  pusha\r\n  cmp byte [bx], 0 ; Stop when we see a null byte\r\n  je freeze ; pop back variables when we've had all letters\r\n\r\n  mov al, [bx] ; move contents of bx register to al register\r\n  int 0x10 ; print!\r\n\r\n  add bx, 1 ; move to the next letter\r\n\r\n  call printstring ; recursively print all letters\r\n\r\n\r\nstr:\r\n  db 'Hello, Wqrld!',0 ; terminate with \\0\r\n\r\n\r\ntimes 510-($-$$) db 0\r\n\r\ndw 0xaa55 ; magic bytes\r<\/code><\/pre>\n\n\n\n
\"\"\/
You can now print strings<\/figcaption><\/figure>\n\n\n\n
And onwards…<\/h2>\n\n\n\n
<\/p>\n\n\n\n
You did it, you have now made your own very very very basic OS. The rest is up to you \ud83d\ude09<\/p>\n\n\n\n
<\/p>\n\n\n\n
Just joking, you can read more awesome stuff at https:\/\/www.cs.bham.ac.uk\/~exr\/lectures\/opsys\/10_11\/lectures\/os-dev.pdf <\/a><\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
Many technical people always want to re-invent the wheel. “Operating systems are bloated” and all kinds of that stuff. I challenge you to make your own. (with a bit of help from this tutorial, i won’t leave you hanging \ud83d\ude42 ) Tools We are going to build a simle boot sector operating system. This is … Continue reading “Building a boot-sector OS”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":245,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-217","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/posts\/217","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/comments?post=217"}],"version-history":[{"count":22,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/posts\/217\/revisions"}],"predecessor-version":[{"id":247,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/posts\/217\/revisions\/247"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/media\/245"}],"wp:attachment":[{"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/media?parent=217"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/categories?post=217"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wqrld.net\/blog\/wp-json\/wp\/v2\/tags?post=217"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}