6.5 KiB
## Copyright (C) 2016 Jeremiah Orians ## This file is part of stage0. ## ## stage0 is free software: you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation, either version 3 of the License, or ## (at your option) any later version. ## ## stage0 is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with stage0. If not, see <http://www.gnu.org/licenses/>.
Purpose
These notes exist for those people who want to independently create their own bootstrap tree. Those wishing to save themselves decades of work, would be wise to use the below information and Plan on making the following tools: Hex Monitor which writes out binaries to external storage medium and Text input into another A Loader (especially on platforms that have a 512byte bootloader limitation) A Line Text editor (because perfect typing is hard) A hex/octal assembler (So that you will not need the Hex Monitor any further) An improved hex/octal assembler that supports labels and calculation of relative and absolute addresses A Cat equivalent (Because definition files are awesome) A Less equivalent (Because you want to be able to just read your written code) A line macro program (Because Hex mnemonics suck and ADD32I are a lot easier to identify) The stage0-vm in assembly or a compiler/interpreter for the higher language of your choice you plan on leveraging to implement the stage0-vm
Platform specific information
8086
To encode assembly to hex, please reference: http://ref.x86asm.net/geek.html WARNING encoding is an extremely slow and painful process by hand, BE VERY VERY THANKFUL for those that came before us and made such wonderful things as assemblers and C compilers that hide most of the horrible darkness from our eyes…
Default memory map
| 16-bit mem map (seg:off) | What is there |
|---|---|
| 0x0000:0x0000 -> 0x0000:0x0500 | BIOS stuff |
| 0x0000:0x0500 -> 0x0000:0x2100 | root |
| 0x0000:0x2100 -> 0x0000:0x3300 | fat |
| 0x0000:0x3300 -> 0x0000:0x6c00 | 14,25kb free space |
| 0x0000:0x6c00 -> 0x0000:0x7c00 | IDT and GDT (256 desc. eatch) |
| 0x0000:0x7c00 -> 0x0000:0x7e00 | bootsector |
| 0x0000:0x7e00 <- 0x0000:0xffff | ~32,5kb stack for boot |
| 0x1000:0x0000 -> 0x9000:0xffff | 576kb free space |
| 0xa000:0x0000 -> …………. | VGA mem etc. |
Restart code
To restart the segment loaded from the bootsector:
| Hex | Assembly Equivalent |
|---|---|
| 68007C | push 7C00 |
| C3 | ret |
For an intersegment restart:
| Hex | Assembly Equivalent |
|---|---|
| 6A00 | push 0 |
| 68007C | push 7C00 |
| CF | iret |
Testing notes
Making blank floppy disk images
dd if=/dev/zero of=$filename.img count=1440 bs=1k
Changing floppies inside of qemu
While qemu is running it is possible to change floppies To achieve this you first must enter the qemu monitor by pressing: Ctrl-Alt-Shift-2
You then may change the floppy by typing: change $drivename $filename
for example to use the file blank_floppy.img in the A drive: change floppy0 blank_floppy.img
Building binaries for testing
stage0_monitor
There are literally hundreds of ways of building the root bootstrap binary.
All that is required is a simply hex compiler written in any language on any system available to the user.
This repository contains a hex compiler written for Linux in hex and assembly as well as a platform independent C implementation.
Then to complete the build process write to the master boot record of a floppy disk. Or should you desire simply use qemu to boot the compiled file directly.
Creation journal
Linux bootstrap
The initial prototyping was done on linux with the goal of not requiring anything other than the linux kernel.
However it was pointed out to me that should a trusting trust attack be in the compiled kernel, there would be no way to even trust the binaries produced by these programs.
That being said they may be of some use to you.
Stage 0
Lacking a good basis for reducing the trusting trust attack, it was decided to reduce the scope down.
By writing the stage 0 code in commented hex, it becomes possible for universal cross compilation and verification.
The only real problem is that the commented hex has to be manually validated [An insanely painful process] and each and every single platform has to perform the exact same tasks.
Since all such projects have to start somewhere, I have chosen to do it myself and with the 8088.
To make my work easier, I first created the working code in 16bit assembly.
Then after testing is validated, I begin the pain staking process of manually converting the code to hex [With usually a dozen bugs along the way].
What I however require is someone with a completely alien platform verify the compiled hex for the stage0_monitor.
Which is listed along with all of the checksums of the validated binaries produced thus far in the file Checksums.org
If your compiled hex is different in any way, please let me know as the process should produce bit identical binaries.
Stage 1
Stage 1 attempts to save myself from a lot of manual typing and the inevitable errors that occur.
It simply provides the functionality required to produce 32KB or smaller binaries from Commented Hex files.
This is a minor stopping point of functionality that provides a stable nub for our much more ambitious stages that come later.
The editors lack the ability to correct mistakes and always writes a 64KB file onto the B: floppy.
The loader is so stupid is only loads 64KB from the A: Floppy and doesn't even prompt the user.
However despite those stupid limitations, they have saved alot of manual work compared to stage0.
Having these binaries are a huge step forward compared to not having them but they assume you don't make mistakes.
Stage 2
Stage 2 will be introducing enhancements to Stage 1 programs that allow you to fix the problems you accidentally introduce.
We will also begin to introduce programs that make software development a lot easier.