@aptre/v86 0.5.0

package/src/iso9660.ts

@@ -0,0 +1,317 @@
+// Source: https://wiki.osdev.org/ISO_9660
+
+// Limitations:
+// - can only generate iso files
+// - only supports a single directory, no file system hierarchy
+// - root directory entry is limited to 2 KiB (~42 files)
+// - filenames are normalised to 8.3 length and [A-Z0-9_.]
+
+import { dbg_assert } from './log.js'
+
+const BLOCK_SIZE = 2 * 1024 // 0x800
+
+const FILE_FLAGS_DIRECTORY = 1 << 1
+
+interface ISOBuffer {
+    buffer: Uint8Array
+    offset: number
+}
+
+interface ISOFile {
+    name: string
+    contents: Uint8Array
+}
+
+interface ISOFileWithLBA {
+    name: string
+    contents: Uint8Array
+    lba: number
+}
+
+export function generate(files: ISOFile[]): Uint8Array {
+    const te = new TextEncoder()
+    const date = new Date()
+
+    const write8 = (b: ISOBuffer, v: number): void => {
+        b.buffer[b.offset++] = v
+    }
+    const write_le16 = (b: ISOBuffer, v: number): void => {
+        b.buffer[b.offset++] = v
+        b.buffer[b.offset++] = v >> 8
+    }
+    const write_le32 = (b: ISOBuffer, v: number): void => {
+        b.buffer[b.offset++] = v
+        b.buffer[b.offset++] = v >> 8
+        b.buffer[b.offset++] = v >> 16
+        b.buffer[b.offset++] = v >> 24
+    }
+    const write_be16 = (b: ISOBuffer, v: number): void => {
+        b.buffer[b.offset++] = v >> 8
+        b.buffer[b.offset++] = v
+    }
+    const write_be32 = (b: ISOBuffer, v: number): void => {
+        b.buffer[b.offset++] = v >> 24
+        b.buffer[b.offset++] = v >> 16
+        b.buffer[b.offset++] = v >> 8
+        b.buffer[b.offset++] = v
+    }
+    const write_lebe16 = (b: ISOBuffer, v: number): void => {
+        write_le16(b, v)
+        write_be16(b, v)
+    }
+    const write_lebe32 = (b: ISOBuffer, v: number): void => {
+        write_le32(b, v)
+        write_be32(b, v)
+    }
+    const fill = (b: ISOBuffer, len: number, v: number): void => {
+        b.buffer.fill(v, b.offset, (b.offset += len))
+    }
+    const write_ascii = (b: ISOBuffer, v: string): void => {
+        b.offset += te.encodeInto(v, b.buffer.subarray(b.offset)).written
+    }
+    const write_padded_ascii = (b: ISOBuffer, len: number, v: string): void => {
+        b.offset += te.encodeInto(
+            v.padEnd(len),
+            b.buffer.subarray(b.offset),
+        ).written
+    }
+    const write_dummy_date_ascii = (b: ISOBuffer): void => {
+        fill(b, 16, 0x20)
+        write8(b, 0)
+    }
+    const write_date_compact = (b: ISOBuffer): void => {
+        write8(b, date.getUTCFullYear() - 1900)
+        write8(b, 1 + date.getUTCMonth())
+        write8(b, date.getUTCDate())
+        write8(b, date.getUTCHours())
+        write8(b, date.getUTCMinutes())
+        write8(b, date.getUTCSeconds())
+        write8(b, 0)
+    }
+    const skip = (b: ISOBuffer, len: number): void => {
+        b.offset += len
+    }
+
+    const write_record = (
+        b: ISOBuffer,
+        name: string,
+        flags: number,
+        is_special: boolean,
+        lba: number,
+        len: number,
+    ): void => {
+        if (!is_special) name = sanitise_filename(name) + ';1'
+        // write name first and get its length
+        const START = buffer.offset
+        const NAME_OFFSET = 33
+        const name_len = te.encodeInto(
+            name,
+            b.buffer.subarray(b.offset + NAME_OFFSET),
+        ).written
+        const pad = name_len & 1 ? 0 : 1
+        const len_field = 33 + name_len + pad
+        dbg_assert(len_field < 256)
+        write8(buffer, len_field) // Length of directory record
+        write8(buffer, 0) // Extended Attribute Record length
+        write_lebe32(buffer, lba) // Location of extent (LBA)
+        write_lebe32(buffer, len) // Data length (size of extent)
+        write_date_compact(buffer)
+        write8(buffer, flags)
+        write8(buffer, 0) // File unit size for files recorded in interleaved mode, zero otherwise
+        write8(buffer, 0) // Interleave gap size for files recorded in interleaved mode, zero otherwise
+        write_lebe16(buffer, 1) // Volume sequence number - the volume that this extent is recorded on
+        write8(buffer, name_len) // length of file name
+        dbg_assert(buffer.offset === START + NAME_OFFSET)
+        skip(buffer, name_len + pad) // File name: was already written
+        dbg_assert(buffer.offset === START + len_field)
+    }
+    const write_special_directory_record = (
+        b: ISOBuffer,
+        name: string,
+        lba: number,
+        len: number,
+    ): void => write_record(b, name, FILE_FLAGS_DIRECTORY, true, lba, len)
+    const write_file_record = (
+        b: ISOBuffer,
+        name: string,
+        lba: number,
+        len: number,
+    ): void => write_record(b, name, 0, false, lba, len)
+
+    function round_byte_size_to_block_size(n: number): number {
+        return 1 + Math.floor((n - 1) / BLOCK_SIZE)
+    }
+    dbg_assert(round_byte_size_to_block_size(0) === 0)
+    dbg_assert(round_byte_size_to_block_size(1) === 1)
+    dbg_assert(round_byte_size_to_block_size(BLOCK_SIZE - 1) === 1)
+    dbg_assert(round_byte_size_to_block_size(BLOCK_SIZE) === 1)
+    dbg_assert(round_byte_size_to_block_size(BLOCK_SIZE + 1) === 2)
+    dbg_assert(round_byte_size_to_block_size(2 * BLOCK_SIZE) === 2)
+    dbg_assert(round_byte_size_to_block_size(2 * BLOCK_SIZE + 1) === 3)
+    dbg_assert(round_byte_size_to_block_size(10 * BLOCK_SIZE + 1) === 11)
+
+    function to_msdos_filename(name: string): string {
+        const dot = name.lastIndexOf('.')
+        if (dot === -1) return name.substr(0, 8)
+        return name.substr(0, Math.min(8, dot)) + '.' + name.substr(dot + 1, 3)
+    }
+
+    dbg_assert(to_msdos_filename('abcdefghijkl.qwerty') === 'abcdefgh.qwe')
+    dbg_assert(to_msdos_filename('abcdefghijkl') === 'abcdefgh')
+
+    function sanitise_filename(name: string): string {
+        return to_msdos_filename(name.toUpperCase().replace(/[^A-Z0-9_.]/g, ''))
+    }
+
+    // layout:
+    // (lba = one block of BLOCK_SIZE bytes)
+    // LBA   | contents
+    // ------+--------
+    // 0..15 | System Area (could be used for mbr, but not used by us)
+    //    16 | Primary Volume Descriptor
+    //    17 | Volume Descriptor Set Terminator
+    //    18 | empty
+    //    19 | Little Endian Path Table
+    //    20 | empty
+    //    21 | Big Endian Path Table
+    //    22 | empty
+    //    23 | Root directory
+    // 24..n | File contents
+    const SYSTEM_AREA_SIZE = 16 * BLOCK_SIZE
+    const PRIMARY_VOLUME_LBA = 16
+    const VOLUME_SET_TERMINATOR_LBA = 17
+    const LE_PATH_TABLE_LBA = 19
+    const BE_PATH_TABLE_LBA = 21
+    const ROOT_DIRECTORY_LBA = 23
+    const LE_PATH_TABLE_SIZE = BLOCK_SIZE
+    const BE_PATH_TABLE_SIZE = BLOCK_SIZE
+    const ROOT_DIRECTORY_SIZE = BLOCK_SIZE
+
+    let next_file_lba = 24
+    const mapped_files: ISOFileWithLBA[] = files.map(({ name, contents }) => {
+        const lba = next_file_lba
+        next_file_lba += round_byte_size_to_block_size(contents.length)
+        name = to_msdos_filename(name)
+        return { name, contents, lba }
+    })
+
+    const N_LBAS = next_file_lba
+    const total_size = N_LBAS * BLOCK_SIZE
+
+    const buffer: ISOBuffer = {
+        buffer: new Uint8Array(total_size),
+        offset: SYSTEM_AREA_SIZE,
+    }
+
+    // LBA 16: Primary Volume Descriptor
+    dbg_assert(buffer.offset === PRIMARY_VOLUME_LBA * BLOCK_SIZE)
+    write8(buffer, 0x01) // Volume Descriptor type: Primary Volume Descriptor
+    write_ascii(buffer, 'CD001') // Always CD001
+    write8(buffer, 0x01) // Version
+    write8(buffer, 0x00) // unused
+    write_padded_ascii(buffer, 32, 'V86') // System Identifier
+    write_padded_ascii(buffer, 32, 'CDROM') // Identification of this volume
+    skip(buffer, 8) // unused
+    write_lebe32(buffer, N_LBAS)
+    skip(buffer, 32) // unused
+    dbg_assert(buffer.offset === 0x8000 + 120)
+
+    write_lebe16(buffer, 1) // Volume Set Size
+    write_lebe16(buffer, 1) // Volume Sequence Number
+    dbg_assert(buffer.offset === 0x8080)
+
+    write_lebe16(buffer, BLOCK_SIZE)
+
+    write_lebe32(buffer, 10) // Path Table Size
+    write_le32(buffer, LE_PATH_TABLE_LBA) // Location of Type-L Path Table
+    write_le32(buffer, 0) // Location of the Optional Type-L Path Table
+    write_be32(buffer, BE_PATH_TABLE_LBA) // Location of Type-M Path Table
+    write_be32(buffer, 0) // Location of the Optional Type-M Path Table
+    dbg_assert(buffer.offset === 0x8000 + 156)
+
+    // Directory entry for the root directory
+    write_special_directory_record(buffer, '\x00', ROOT_DIRECTORY_LBA, 0x800)
+    dbg_assert(buffer.offset === 0x8000 + 190)
+
+    fill(buffer, 128, 0x20) // Volume Set Identifier
+    fill(buffer, 128, 0x20) // Publisher Identifier
+    fill(buffer, 128, 0x20) // Data Preparer Identifier
+    fill(buffer, 128, 0x20) // Application Identifier
+    fill(buffer, 37, 0x20) // Copyright File Identifier
+    fill(buffer, 37, 0x20) // Abstract File Identifier
+    fill(buffer, 37, 0x20) // Bibliographic File Identifier
+
+    dbg_assert(buffer.offset === 0x8000 + 813)
+
+    write_dummy_date_ascii(buffer) // Volume Creation Date and Time
+    write_dummy_date_ascii(buffer) // Volume Modification Date and Time
+    write_dummy_date_ascii(buffer) // Volume Expiration Date and Time
+    write_dummy_date_ascii(buffer) // Volume Effective Date and Time
+
+    write8(buffer, 0x01) // File Structure Version
+    dbg_assert(buffer.offset === 0x8000 + 882)
+
+    write8(buffer, 0x00) // Unused
+    skip(buffer, 512) // Application Used
+    skip(buffer, 653) // Reserved
+
+    // LBA 17: Volume Descriptor Set Terminator
+    dbg_assert(buffer.offset === VOLUME_SET_TERMINATOR_LBA * BLOCK_SIZE)
+    write8(buffer, 0xff) // 0xFF: Volume Descriptor Set Terminator
+    write_ascii(buffer, 'CD001') // Always CD001
+    write8(buffer, 0x01) // Version
+
+    // LBA 19: Little Endian Path Table
+    buffer.offset = LE_PATH_TABLE_LBA * BLOCK_SIZE
+    write8(buffer, 0x01) // Length of Directory Identifier
+    write8(buffer, 0x00) // Extended Attribute Record Length
+    write_le32(buffer, ROOT_DIRECTORY_LBA) // Location of Extent (LBA)
+    write_le16(buffer, 1) // Directory number of parent directory
+    write_ascii(buffer, '\x00') // file name
+    dbg_assert(
+        buffer.offset < LE_PATH_TABLE_LBA * BLOCK_SIZE + LE_PATH_TABLE_SIZE,
+    )
+
+    // LBA 21: Big Endian Path Table
+    buffer.offset = BE_PATH_TABLE_LBA * BLOCK_SIZE
+    write8(buffer, 0x01) // Length of Directory Identifier
+    write8(buffer, 0x00) // Extended Attribute Record Length
+    write_be32(buffer, ROOT_DIRECTORY_LBA) // Location of Extent (LBA)
+    write_be16(buffer, 1) // Directory number of parent directory
+    write_ascii(buffer, '\x00') // file name
+    dbg_assert(
+        buffer.offset < BE_PATH_TABLE_LBA * BLOCK_SIZE + BE_PATH_TABLE_SIZE,
+    )
+
+    // LBA 23: root directory
+    buffer.offset = ROOT_DIRECTORY_LBA * BLOCK_SIZE
+    write_special_directory_record(buffer, '\x00', ROOT_DIRECTORY_LBA, 0x800) // "."
+    write_special_directory_record(buffer, '\x01', ROOT_DIRECTORY_LBA, 0x800) // ".."
+    for (const { name, contents, lba } of mapped_files) {
+        write_file_record(buffer, name, lba, contents.length)
+    }
+    // TODO: this assertion can fail if too many files are used as input
+    // ROOT_DIRECTORY_SIZE should be choosen dynamically
+    dbg_assert(
+        buffer.offset < ROOT_DIRECTORY_LBA * BLOCK_SIZE + ROOT_DIRECTORY_SIZE,
+    )
+
+    // file contents
+    for (const { contents, lba } of mapped_files) {
+        buffer.buffer.set(contents, lba * BLOCK_SIZE)
+    }
+
+    return buffer.buffer
+}
+
+export function is_probably_iso9660_file(buffer: Uint8Array): boolean {
+    return (
+        buffer.length >= 17 * BLOCK_SIZE &&
+        buffer[BLOCK_SIZE + 0] === 1 && // Primary Volume Descriptor
+        buffer[BLOCK_SIZE + 1] === 67 && // "C"
+        buffer[BLOCK_SIZE + 2] === 68 && // "D"
+        buffer[BLOCK_SIZE + 3] === 48 && // "0"
+        buffer[BLOCK_SIZE + 4] === 48 && // "0"
+        buffer[BLOCK_SIZE + 5] === 49 // "1"
+    )
+}

package/src/kernel.ts

@@ -0,0 +1,250 @@
+import { h } from './lib.js'
+import { dbg_assert, dbg_log } from './log.js'
+
+// https://www.kernel.org/doc/Documentation/x86/boot.txt
+
+const LINUX_BOOT_HDR_SETUP_SECTS = 0x1f1
+const LINUX_BOOT_HDR_SYSSIZE = 0x1f4
+const LINUX_BOOT_HDR_VIDMODE = 0x1fa
+const LINUX_BOOT_HDR_BOOT_FLAG = 0x1fe
+const LINUX_BOOT_HDR_HEADER = 0x202
+const LINUX_BOOT_HDR_VERSION = 0x206
+const LINUX_BOOT_HDR_TYPE_OF_LOADER = 0x210
+const LINUX_BOOT_HDR_LOADFLAGS = 0x211
+const LINUX_BOOT_HDR_CODE32_START = 0x214
+const LINUX_BOOT_HDR_RAMDISK_IMAGE = 0x218
+const LINUX_BOOT_HDR_RAMDISK_SIZE = 0x21c
+const LINUX_BOOT_HDR_HEAP_END_PTR = 0x224
+const LINUX_BOOT_HDR_CMD_LINE_PTR = 0x228
+const LINUX_BOOT_HDR_INITRD_ADDR_MAX = 0x22c
+const LINUX_BOOT_HDR_KERNEL_ALIGNMENT = 0x230
+const LINUX_BOOT_HDR_RELOCATABLE_KERNEL = 0x234
+const LINUX_BOOT_HDR_MIN_ALIGNMENT = 0x235
+const LINUX_BOOT_HDR_XLOADFLAGS = 0x236
+const LINUX_BOOT_HDR_CMDLINE_SIZE = 0x238
+const LINUX_BOOT_HDR_PAYLOAD_OFFSET = 0x248
+const LINUX_BOOT_HDR_PAYLOAD_LENGTH = 0x24c
+const LINUX_BOOT_HDR_PREF_ADDRESS = 0x258
+const LINUX_BOOT_HDR_INIT_SIZE = 0x260
+
+const LINUX_BOOT_HDR_CHECKSUM1 = 0xaa55
+const LINUX_BOOT_HDR_CHECKSUM2 = 0x53726448
+
+const LINUX_BOOT_HDR_TYPE_OF_LOADER_NOT_ASSIGNED = 0xff
+
+const LINUX_BOOT_HDR_LOADFLAGS_LOADED_HIGH = 1 << 0
+const LINUX_BOOT_HDR_LOADFLAGS_QUIET_FLAG = 1 << 5
+const LINUX_BOOT_HDR_LOADFLAGS_KEEP_SEGMENTS = 1 << 6
+const LINUX_BOOT_HDR_LOADFLAGS_CAN_USE_HEAPS = 1 << 7
+
+interface KernelBootRom {
+    name: string
+    data: Uint8Array
+}
+
+export function load_kernel(
+    mem8: Uint8Array,
+    bzimage: ArrayBuffer,
+    initrd: ArrayBuffer | undefined,
+    cmdline: string,
+): KernelBootRom | undefined {
+    dbg_log('Trying to load kernel of size ' + bzimage.byteLength)
+
+    const KERNEL_HIGH_ADDRESS = 0x100000
+
+    // Put the initrd at the 64 MB boundary. This means the minimum memory size
+    // is 64 MB plus the size of the initrd.
+    // Note: If set too low, kernel may fail to load the initrd with "invalid magic at start of compressed archive"
+    const INITRD_ADDRESS = 64 << 20
+
+    const quiet = false
+
+    const bzimage8 = new Uint8Array(bzimage)
+    const bzimage16 = new Uint16Array(bzimage)
+    const bzimage32 = new Uint32Array(bzimage)
+
+    const setup_sects = bzimage8[LINUX_BOOT_HDR_SETUP_SECTS] || 4
+    const _syssize = bzimage32[LINUX_BOOT_HDR_SYSSIZE >> 2] << 4
+
+    const _vidmode = bzimage16[LINUX_BOOT_HDR_VIDMODE >> 1]
+
+    const checksum1 = bzimage16[LINUX_BOOT_HDR_BOOT_FLAG >> 1]
+    if (checksum1 !== LINUX_BOOT_HDR_CHECKSUM1) {
+        dbg_log('Bad checksum1: ' + h(checksum1))
+        return
+    }
+
+    // Not aligned, so split into two 16-bit reads
+    const checksum2 =
+        bzimage16[LINUX_BOOT_HDR_HEADER >> 1] |
+        (bzimage16[(LINUX_BOOT_HDR_HEADER + 2) >> 1] << 16)
+    if (checksum2 !== LINUX_BOOT_HDR_CHECKSUM2) {
+        dbg_log('Bad checksum2: ' + h(checksum2))
+        return
+    }
+
+    const protocol = bzimage16[LINUX_BOOT_HDR_VERSION >> 1]
+    dbg_assert(protocol >= 0x202) // older not supported by us
+
+    const flags = bzimage8[LINUX_BOOT_HDR_LOADFLAGS]
+    dbg_assert(!!(flags & LINUX_BOOT_HDR_LOADFLAGS_LOADED_HIGH)) // low kernels not supported by us
+
+    // we don't relocate the kernel, so we don't care much about most of these
+
+    const flags2 = bzimage16[LINUX_BOOT_HDR_XLOADFLAGS >> 1]
+    const initrd_addr_max = bzimage32[LINUX_BOOT_HDR_INITRD_ADDR_MAX >> 2]
+    const kernel_alignment = bzimage32[LINUX_BOOT_HDR_KERNEL_ALIGNMENT >> 2]
+    const relocatable_kernel = bzimage8[LINUX_BOOT_HDR_RELOCATABLE_KERNEL]
+    const min_alignment = bzimage8[LINUX_BOOT_HDR_MIN_ALIGNMENT]
+    const cmdline_size =
+        protocol >= 0x206 ? bzimage32[LINUX_BOOT_HDR_CMDLINE_SIZE >> 2] : 255
+    const payload_offset = bzimage32[LINUX_BOOT_HDR_PAYLOAD_OFFSET >> 2]
+    const payload_length = bzimage32[LINUX_BOOT_HDR_PAYLOAD_LENGTH >> 2]
+    const pref_address = bzimage32[LINUX_BOOT_HDR_PREF_ADDRESS >> 2]
+    const pref_address_high = bzimage32[(LINUX_BOOT_HDR_PREF_ADDRESS + 4) >> 2]
+    const init_size = bzimage32[LINUX_BOOT_HDR_INIT_SIZE >> 2]
+
+    dbg_log('kernel boot protocol version: ' + h(protocol))
+    dbg_log('flags=' + h(flags) + ' xflags=' + h(flags2))
+    dbg_log('code32_start=' + h(bzimage32[LINUX_BOOT_HDR_CODE32_START >> 2]))
+    dbg_log('initrd_addr_max=' + h(initrd_addr_max))
+    dbg_log('kernel_alignment=' + h(kernel_alignment))
+    dbg_log('relocatable=' + relocatable_kernel)
+    dbg_log('min_alignment=' + h(min_alignment))
+    dbg_log('cmdline max=' + h(cmdline_size))
+    dbg_log(
+        'payload offset=' + h(payload_offset) + ' size=' + h(payload_length),
+    )
+    dbg_log('pref_address=' + h(pref_address_high) + ':' + h(pref_address))
+    dbg_log('init_size=' + h(init_size))
+
+    const real_mode_segment = 0x8000
+    const base_ptr = real_mode_segment << 4
+
+    const heap_end = 0xe000
+    const heap_end_ptr = heap_end - 0x200
+
+    // fill in the kernel boot header with infos the kernel needs to know
+
+    bzimage8[LINUX_BOOT_HDR_TYPE_OF_LOADER] =
+        LINUX_BOOT_HDR_TYPE_OF_LOADER_NOT_ASSIGNED
+
+    const new_flags =
+        ((quiet
+            ? flags | LINUX_BOOT_HDR_LOADFLAGS_QUIET_FLAG
+            : flags & ~LINUX_BOOT_HDR_LOADFLAGS_QUIET_FLAG) &
+            ~LINUX_BOOT_HDR_LOADFLAGS_KEEP_SEGMENTS) |
+        LINUX_BOOT_HDR_LOADFLAGS_CAN_USE_HEAPS
+    bzimage8[LINUX_BOOT_HDR_LOADFLAGS] = new_flags
+
+    bzimage16[LINUX_BOOT_HDR_HEAP_END_PTR >> 1] = heap_end_ptr
+
+    // should parse the vga=... paramter from cmdline here, but we don't really care
+    bzimage16[LINUX_BOOT_HDR_VIDMODE >> 1] = 0xffff // normal
+
+    dbg_log('heap_end_ptr=' + h(heap_end_ptr))
+
+    cmdline += '\x00'
+    dbg_assert(cmdline.length < cmdline_size)
+
+    const cmd_line_ptr = base_ptr + heap_end
+    dbg_log('cmd_line_ptr=' + h(cmd_line_ptr))
+
+    bzimage32[LINUX_BOOT_HDR_CMD_LINE_PTR >> 2] = cmd_line_ptr
+    for (let i = 0; i < cmdline.length; i++) {
+        mem8[cmd_line_ptr + i] = cmdline.charCodeAt(i)
+    }
+
+    const prot_mode_kernel_start = (setup_sects + 1) * 512
+    dbg_log('prot_mode_kernel_start=' + h(prot_mode_kernel_start))
+
+    const real_mode_kernel = new Uint8Array(bzimage, 0, prot_mode_kernel_start)
+    const protected_mode_kernel = new Uint8Array(
+        bzimage,
+        prot_mode_kernel_start,
+    )
+
+    let ramdisk_address = 0
+    let ramdisk_size = 0
+
+    if (initrd) {
+        ramdisk_address = INITRD_ADDRESS
+        ramdisk_size = initrd.byteLength
+
+        dbg_assert(
+            KERNEL_HIGH_ADDRESS + protected_mode_kernel.length <
+                ramdisk_address,
+        )
+
+        mem8.set(new Uint8Array(initrd), ramdisk_address)
+    }
+
+    bzimage32[LINUX_BOOT_HDR_RAMDISK_IMAGE >> 2] = ramdisk_address
+    bzimage32[LINUX_BOOT_HDR_RAMDISK_SIZE >> 2] = ramdisk_size
+
+    dbg_assert(base_ptr + real_mode_kernel.length < 0xa0000)
+
+    mem8.set(real_mode_kernel, base_ptr)
+    mem8.set(protected_mode_kernel, KERNEL_HIGH_ADDRESS)
+
+    return {
+        name: 'genroms/kernel.bin',
+        data: make_linux_boot_rom(real_mode_segment, heap_end),
+    }
+}
+
+function make_linux_boot_rom(
+    real_mode_segment: number,
+    heap_end: number,
+): Uint8Array {
+    // This rom will be executed by seabios after its initialisation
+    // It sets up segment registers, the stack and calls the kernel real mode entry point
+
+    const SIZE = 0x200
+
+    const data8 = new Uint8Array(SIZE)
+    const data16 = new Uint16Array(data8.buffer)
+
+    data16[0] = 0xaa55
+    data8[2] = SIZE / 0x200
+
+    let i = 3
+
+    data8[i++] = 0xfa // cli
+    data8[i++] = 0xb8 // mov ax, real_mode_segment
+    data8[i++] = real_mode_segment >> 0
+    data8[i++] = real_mode_segment >> 8
+    data8[i++] = 0x8e // mov es, ax
+    data8[i++] = 0xc0
+    data8[i++] = 0x8e // mov ds, ax
+    data8[i++] = 0xd8
+    data8[i++] = 0x8e // mov fs, ax
+    data8[i++] = 0xe0
+    data8[i++] = 0x8e // mov gs, ax
+    data8[i++] = 0xe8
+    data8[i++] = 0x8e // mov ss, ax
+    data8[i++] = 0xd0
+    data8[i++] = 0xbc // mov sp, heap_end
+    data8[i++] = heap_end >> 0
+    data8[i++] = heap_end >> 8
+    data8[i++] = 0xea // jmp (real_mode_segment+0x20):0x0
+    data8[i++] = 0x00
+    data8[i++] = 0x00
+    data8[i++] = (real_mode_segment + 0x20) >> 0
+    data8[i++] = (real_mode_segment + 0x20) >> 8
+
+    dbg_assert(i < SIZE)
+
+    const checksum_index = i
+    data8[checksum_index] = 0
+
+    let checksum = 0
+
+    for (let i = 0; i < data8.length; i++) {
+        checksum += data8[i]
+    }
+
+    data8[checksum_index] = -checksum
+
+    return data8
+}