* 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 Equivelent |
|--------+---------------------|
| 68007C | push 7C00           |
| C3     | ret                 |

For an intersegment restart:
| Hex    | Assembly Equivelent |
|--------+---------------------|
| 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 choosen 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 idential binaries.

** Stage 1
Stage 1 attempts to save myself from alot 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 accidentially introduce.

We will also begin to introduce programs that make software development alot easier.