@aptre/v86 0.5.0 → 0.6.0

package/src/virtio_mem.ts

@@ -0,0 +1,349 @@
+// https://docs.oasis-open.org/virtio/virtio/v1.2/csd01/virtio-v1.2-csd01.html#x1-4500006
+
+import { LOG_PCI } from './const.js'
+import { dbg_log } from './log.js'
+import { VirtIO, VIRTIO_F_VERSION_1 } from './virtio.js'
+import * as _marshall from '../lib/marshall.js'
+import { BusConnector } from './bus.js'
+
+interface VirtioMemCPU {
+    io: {
+        register_read(
+            port: number,
+            device: object,
+            r8?: ((port: number) => number) | undefined,
+            r16?: ((port: number) => number) | undefined,
+            r32?: ((port: number) => number) | undefined,
+        ): void
+        register_write(
+            port: number,
+            device: object,
+            w8?: ((port: number) => void) | undefined,
+            w16?: ((port: number) => void) | undefined,
+            w32?: ((port: number) => void) | undefined,
+        ): void
+    }
+    devices: {
+        pci: {
+            register_device(device: VirtIO): void
+            raise_irq(pci_id: number): void
+            lower_irq(pci_id: number): void
+        }
+    }
+    read16(addr: number): number
+    read32s(addr: number): number
+    write16(addr: number, value: number): void
+    write32(addr: number, value: number): void
+    read_blob(addr: number, length: number): Uint8Array
+    write_blob(blob: Uint8Array, addr: number): void
+    zero_memory(addr: number, length: number): void
+    memory_size: Int32Array
+    resize_memory(new_size: number): void
+    full_clear_tlb(): void
+}
+
+// Request types
+const VIRTIO_MEM_REQ_PLUG = 0
+const VIRTIO_MEM_REQ_UNPLUG = 1
+const _VIRTIO_MEM_REQ_UNPLUG_ALL = 2
+const VIRTIO_MEM_REQ_STATE = 3
+
+// Response types
+const VIRTIO_MEM_RESP_ACK = 0
+const VIRTIO_MEM_RESP_NACK = 1
+const _VIRTIO_MEM_RESP_BUSY = 2
+const VIRTIO_MEM_RESP_ERROR = 3
+
+// Default block size: 128MB
+const DEFAULT_BLOCK_SIZE = 128 * 1024 * 1024
+
+export class VirtioMem {
+    bus: BusConnector
+    cpu: VirtioMemCPU
+    virtio: VirtIO
+
+    block_size: number
+    region_addr: number
+    region_size: number
+    usable_region_size: number
+    plugged_size: number
+    requested_size: number
+
+    constructor(
+        cpu: VirtioMemCPU,
+        bus: BusConnector,
+        region_addr: number,
+        region_size: number,
+        block_size?: number,
+    ) {
+        this.bus = bus
+        this.cpu = cpu
+        this.block_size = block_size || DEFAULT_BLOCK_SIZE
+        this.region_addr = region_addr
+        this.region_size = region_size
+        this.usable_region_size = region_size
+        this.plugged_size = 0
+        this.requested_size = 0
+
+        const queues = [{ size_supported: 32, notify_offset: 0 }]
+
+        this.virtio = new VirtIO(cpu, {
+            name: 'virtio-mem',
+            pci_id: 0x0d << 3,
+            device_id: 0x1058,
+            subsystem_device_id: 24,
+            common: {
+                initial_port: 0xe800,
+                queues,
+                features: [VIRTIO_F_VERSION_1],
+                on_driver_ok: () => {
+                    dbg_log('virtio-mem setup', LOG_PCI)
+                },
+            },
+            notification: {
+                initial_port: 0xe900,
+                single_handler: false,
+                handlers: [
+                    (queue_id: number) => {
+                        this.handle_request(queue_id)
+                    },
+                ],
+            },
+            isr_status: {
+                initial_port: 0xe700,
+            },
+            device_specific: {
+                initial_port: 0xe600,
+                struct: [
+                    // block_size low
+                    {
+                        bytes: 4,
+                        name: 'block_size_low',
+                        read: () => this.block_size >>> 0,
+                        write: () => {},
+                    },
+                    // block_size high
+                    {
+                        bytes: 4,
+                        name: 'block_size_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // node_id (u16 padded to u32)
+                    {
+                        bytes: 2,
+                        name: 'node_id',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // padding (6 bytes as 2+4)
+                    {
+                        bytes: 2,
+                        name: 'padding0',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    {
+                        bytes: 4,
+                        name: 'padding1',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // addr low
+                    {
+                        bytes: 4,
+                        name: 'addr_low',
+                        read: () => this.region_addr >>> 0,
+                        write: () => {},
+                    },
+                    // addr high
+                    {
+                        bytes: 4,
+                        name: 'addr_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // region_size low
+                    {
+                        bytes: 4,
+                        name: 'region_size_low',
+                        read: () => this.region_size >>> 0,
+                        write: () => {},
+                    },
+                    // region_size high
+                    {
+                        bytes: 4,
+                        name: 'region_size_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // usable_region_size low
+                    {
+                        bytes: 4,
+                        name: 'usable_region_size_low',
+                        read: () => this.usable_region_size >>> 0,
+                        write: () => {},
+                    },
+                    // usable_region_size high
+                    {
+                        bytes: 4,
+                        name: 'usable_region_size_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // plugged_size low
+                    {
+                        bytes: 4,
+                        name: 'plugged_size_low',
+                        read: () => this.plugged_size >>> 0,
+                        write: () => {},
+                    },
+                    // plugged_size high
+                    {
+                        bytes: 4,
+                        name: 'plugged_size_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                    // requested_size low
+                    {
+                        bytes: 4,
+                        name: 'requested_size_low',
+                        read: () => this.requested_size >>> 0,
+                        write: () => {},
+                    },
+                    // requested_size high
+                    {
+                        bytes: 4,
+                        name: 'requested_size_high',
+                        read: () => 0,
+                        write: () => {},
+                    },
+                ],
+            },
+        })
+    }
+
+    handle_request(queue_id: number): void {
+        const queue = this.virtio.queues[queue_id]
+        while (queue.has_request()) {
+            const bufchain = queue.pop_request()
+            const request = new Uint8Array(bufchain.length_readable)
+            bufchain.get_next_blob(request)
+
+            const type = request[0] | (request[1] << 8)
+            const resp = new Uint8Array(8)
+
+            let resp_type = VIRTIO_MEM_RESP_ERROR
+            switch (type) {
+                case VIRTIO_MEM_REQ_PLUG:
+                    resp_type = this.handle_plug(request)
+                    break
+                case VIRTIO_MEM_REQ_UNPLUG:
+                    resp_type = VIRTIO_MEM_RESP_NACK
+                    break
+                case VIRTIO_MEM_REQ_STATE:
+                    resp_type = this.handle_state(request, resp)
+                    break
+                default:
+                    dbg_log('virtio-mem: unknown request type ' + type, LOG_PCI)
+            }
+
+            resp[0] = resp_type & 0xff
+            resp[1] = (resp_type >> 8) & 0xff
+
+            bufchain.set_next_blob(resp)
+            queue.push_reply(bufchain)
+        }
+        queue.flush_replies()
+    }
+
+    handle_plug(request: Uint8Array): number {
+        // Request layout after type (8 bytes header):
+        // addr: u64 at offset 8
+        // nb_blocks: u16 at offset 16
+        const addr =
+            (request[8] |
+                (request[9] << 8) |
+                (request[10] << 16) |
+                (request[11] << 24)) >>>
+            0
+        const nb_blocks = request[16] | (request[17] << 8)
+
+        const size = nb_blocks * this.block_size
+        const new_plugged = this.plugged_size + size
+
+        if (new_plugged > this.usable_region_size) {
+            return VIRTIO_MEM_RESP_NACK
+        }
+
+        // Grow guest memory to accommodate the plug
+        const new_memory_size = this.cpu.memory_size[0] + size
+        this.cpu.resize_memory(new_memory_size)
+        this.cpu.full_clear_tlb()
+        this.plugged_size = new_plugged
+
+        dbg_log(
+            'virtio-mem: plugged ' +
+                nb_blocks +
+                ' blocks at 0x' +
+                addr.toString(16) +
+                ' (' +
+                (size >> 20) +
+                'MB)',
+            LOG_PCI,
+        )
+
+        return VIRTIO_MEM_RESP_ACK
+    }
+
+    handle_state(request: Uint8Array, resp: Uint8Array): number {
+        const addr =
+            (request[8] |
+                (request[9] << 8) |
+                (request[10] << 16) |
+                (request[11] << 24)) >>>
+            0
+        const nb_blocks = request[16] | (request[17] << 8)
+
+        // Report all requested blocks as plugged if within plugged_size
+        const offset = addr - this.region_addr
+        const end = offset + nb_blocks * this.block_size
+        const all_plugged = end <= this.plugged_size ? 1 : 0
+
+        // State response: count field at offset 8
+        resp[8] = all_plugged & 0xff
+        resp[9] = (all_plugged >> 8) & 0xff
+
+        return VIRTIO_MEM_RESP_ACK
+    }
+
+    set_requested_size(size: number): void {
+        this.requested_size = size
+        if (this.virtio.device_status & 4) {
+            this.virtio.notify_config_changes()
+        }
+    }
+
+    get_state(): any[] {
+        const state: any[] = []
+        state[0] = this.virtio
+        state[1] = this.block_size
+        state[2] = this.region_addr
+        state[3] = this.region_size
+        state[4] = this.usable_region_size
+        state[5] = this.plugged_size
+        state[6] = this.requested_size
+        return state
+    }
+
+    set_state(state: any[]): void {
+        this.virtio.set_state(state[0])
+        this.block_size = state[1]
+        this.region_addr = state[2]
+        this.region_size = state[3]
+        this.usable_region_size = state[4]
+        this.plugged_size = state[5]
+        this.requested_size = state[6]
+    }
+}