@aptre/v86 0.5.0

package/src/virtio.ts

@@ -0,0 +1,1756 @@
+declare let DEBUG: boolean
+
+import { LOG_VIRTIO } from './const.js'
+import { h, int_log2 } from './lib.js'
+import { dbg_assert, dbg_log } from './log.js'
+
+// Minimal interface for the CPU fields VirtIO needs
+interface VirtioCPU {
+    io: VirtioIO
+    devices: {
+        pci: VirtioPCI
+        net?: unknown
+    }
+    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
+}
+
+interface VirtioIO {
+    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
+}
+
+interface VirtioPCI {
+    register_device(device: VirtIO): void
+    raise_irq(pci_id: number): void
+    lower_irq(pci_id: number): void
+}
+
+// http://docs.oasis-open.org/virtio/virtio/v1.0/virtio-v1.0.html
+
+const VIRTIO_PCI_VENDOR_ID = 0x1af4
+// Identifies vendor-specific PCI capability.
+const VIRTIO_PCI_CAP_VENDOR = 0x09
+// Length (bytes) of VIRTIO_PCI_CAP linked list entry.
+const VIRTIO_PCI_CAP_LENGTH = 16
+
+// Capability types.
+
+const VIRTIO_PCI_CAP_COMMON_CFG = 1
+const VIRTIO_PCI_CAP_NOTIFY_CFG = 2
+const VIRTIO_PCI_CAP_ISR_CFG = 3
+const VIRTIO_PCI_CAP_DEVICE_CFG = 4
+const VIRTIO_PCI_CAP_PCI_CFG = 5
+
+// Status bits (device_status values).
+
+const VIRTIO_STATUS_ACKNOWLEDGE = 1
+const VIRTIO_STATUS_DRIVER = 2
+const VIRTIO_STATUS_DRIVER_OK = 4
+const VIRTIO_STATUS_FEATURES_OK = 8
+const VIRTIO_STATUS_DEVICE_NEEDS_RESET = 64
+const VIRTIO_STATUS_FAILED = 128
+
+// ISR bits (isr_status values).
+
+const VIRTIO_ISR_QUEUE = 1
+const VIRTIO_ISR_DEVICE_CFG = 2
+
+// Feature bits (bit positions).
+
+export const VIRTIO_F_RING_INDIRECT_DESC = 28
+export const VIRTIO_F_RING_EVENT_IDX = 29
+export const VIRTIO_F_VERSION_1 = 32
+
+// Queue struct sizes.
+
+// Size (bytes) of the virtq_desc struct per queue size.
+const VIRTQ_DESC_ENTRYSIZE = 16
+// Size (bytes) of the virtq_avail struct ignoring ring entries.
+const _VIRTQ_AVAIL_BASESIZE = 6
+// Size (bytes) of the virtq_avail struct per queue size.
+const VIRTQ_AVAIL_ENTRYSIZE = 2
+// Size (bytes) of the virtq_used struct ignoring ring entries.
+const _VIRTQ_USED_BASESIZE = 6
+// Size (bytes) of the virtq_desc struct per queue size.
+const VIRTQ_USED_ENTRYSIZE = 8
+// Mask for wrapping the idx field of the virtq_used struct so that the value
+// naturally overflows after 65535 (idx is a word).
+const VIRTQ_IDX_MASK = 0xffff
+
+// Queue flags.
+
+const VIRTQ_DESC_F_NEXT = 1
+const VIRTQ_DESC_F_WRITE = 2
+const VIRTQ_DESC_F_INDIRECT = 4
+const VIRTQ_AVAIL_F_NO_INTERRUPT = 1
+const _VIRTQ_USED_F_NO_NOTIFY = 1
+
+// TypeScript types.
+
+export interface VirtIO_CapabilityStructEntry {
+    bytes: number
+    name: string
+    read: () => number
+    write: (data: number) => void
+}
+
+export type VirtIO_CapabilityStruct = VirtIO_CapabilityStructEntry[]
+
+export interface VirtIO_CapabilityInfo {
+    type: number
+    bar: number
+    port: number
+    use_mmio: boolean
+    offset: number
+    extra: Uint8Array
+    struct: VirtIO_CapabilityStruct
+}
+
+export interface VirtQueue_Options {
+    size_supported: number
+    notify_offset: number
+}
+
+export interface VirtIO_CommonCapabilityOptions {
+    initial_port: number
+    queues: VirtQueue_Options[]
+    features: number[]
+    on_driver_ok: () => void
+}
+
+export interface VirtIO_NotificationCapabilityOptions {
+    initial_port: number
+    single_handler: boolean
+    handlers: ((queue_id: number) => void)[]
+}
+
+export interface VirtIO_ISRCapabilityOptions {
+    initial_port: number
+}
+
+export interface VirtIO_DeviceSpecificCapabilityOptions {
+    initial_port: number
+    struct: VirtIO_CapabilityStruct
+}
+
+export interface VirtIO_Options {
+    name: string
+    pci_id: number
+    device_id: number
+    subsystem_device_id: number
+    common: VirtIO_CommonCapabilityOptions
+    notification: VirtIO_NotificationCapabilityOptions
+    isr_status: VirtIO_ISRCapabilityOptions
+    device_specific?: VirtIO_DeviceSpecificCapabilityOptions
+}
+
+interface VirtQueueDescriptor {
+    addr_low: number
+    addr_high: number
+    len: number
+    flags: number
+    next: number
+}
+
+export class VirtIO {
+    cpu: VirtioCPU
+    pci: VirtioPCI
+    device_id: number
+    pci_space: number[]
+    pci_id: number
+    pci_bars: { size: number }[]
+    name: string
+    device_feature_select: number
+    driver_feature_select: number
+    device_feature: Uint32Array
+    driver_feature: Uint32Array
+    features_ok: boolean
+    device_status: number
+    config_has_changed: boolean
+    config_generation: number
+    queues: VirtQueue[]
+    queue_select: number
+    queue_selected: VirtQueue | null
+    isr_status: number
+
+    constructor(cpu: VirtioCPU, options: VirtIO_Options) {
+        this.cpu = cpu
+        this.pci = cpu.devices.pci
+        this.device_id = options.device_id
+
+        this.pci_space = [
+            // Vendor ID
+            VIRTIO_PCI_VENDOR_ID & 0xff,
+            VIRTIO_PCI_VENDOR_ID >> 8,
+            // Device ID
+            options.device_id & 0xff,
+            options.device_id >> 8,
+            // Command
+            0x07,
+            0x05,
+            // Status - enable capabilities list
+            0x10,
+            0x00,
+            // Revision ID
+            0x01,
+            // Prof IF, Subclass, Class code
+            0x00,
+            0x02,
+            0x00,
+            // Cache line size
+            0x00,
+            // Latency Timer
+            0x00,
+            // Header Type
+            0x00,
+            // Built-in self test
+            0x00,
+            // BAR0
+            0x01,
+            0xa8,
+            0x00,
+            0x00,
+            // BAR1
+            0x00,
+            0x10,
+            0xbf,
+            0xfe,
+            // BAR2
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // BAR3
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // BAR4
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // BAR5
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // CardBus CIS pointer
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // Subsystem vendor ID
+            VIRTIO_PCI_VENDOR_ID & 0xff,
+            VIRTIO_PCI_VENDOR_ID >> 8,
+            // Subsystem ID
+            options.subsystem_device_id & 0xff,
+            options.subsystem_device_id >> 8,
+            // Expansion ROM base address
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // Capabilities pointer
+            0x40,
+            // Reserved
+            0x00,
+            0x00,
+            0x00,
+            // Reserved
+            0x00,
+            0x00,
+            0x00,
+            0x00,
+            // Interrupt line
+            0x00,
+            // Interrupt pin
+            0x01,
+            // Min grant
+            0x00,
+            // Max latency
+            0x00,
+        ]
+
+        // Prevent sparse arrays by preallocating.
+        this.pci_space = this.pci_space.concat(
+            Array(256 - this.pci_space.length).fill(0),
+        )
+        // Remaining PCI space is appended by capabilities further below.
+
+        this.pci_id = options.pci_id
+
+        // PCI bars gets filled in by capabilities further below.
+        this.pci_bars = []
+
+        this.name = options.name
+
+        // Feature bits grouped in dwords, dword selected by device_feature_select.
+        this.device_feature_select = 0
+        this.driver_feature_select = 0
+
+        // Unspecified upper bound. Assume 4*32=128 bits.
+        this.device_feature = new Uint32Array(4)
+        this.driver_feature = new Uint32Array(4)
+        for (const f of options.common.features) {
+            dbg_assert(
+                f >= 0,
+                'VirtIO device<' +
+                    this.name +
+                    '> feature bit numbers must be non-negative',
+            )
+            dbg_assert(
+                f < 128,
+                'VirtIO device<' +
+                    this.name +
+                    '> feature bit numbers assumed less than 128 in implementation',
+            )
+
+            // Feature bits are grouped in 32 bits.
+            this.device_feature[f >>> 5] |= 1 << (f & 0x1f)
+            this.driver_feature[f >>> 5] |= 1 << (f & 0x1f)
+        }
+
+        dbg_assert(
+            options.common.features.includes(VIRTIO_F_VERSION_1),
+            'VirtIO device<' +
+                this.name +
+                '> only non-transitional devices are supported',
+        )
+
+        // Indicates whether driver_feature bits is subset of device_feature bits.
+        this.features_ok = true
+
+        this.device_status = 0
+
+        this.config_has_changed = false
+        this.config_generation = 0
+
+        this.queues = []
+        for (const queue_options of options.common.queues) {
+            this.queues.push(new VirtQueue(cpu, this, queue_options))
+        }
+        this.queue_select = 0
+        this.queue_selected = this.queues[0]
+
+        this.isr_status = 0
+
+        // Verify notification options.
+        if (DEBUG) {
+            const offsets = new Set<number>()
+            for (const offset of this.queues.map((q) => q.notify_offset)) {
+                const effective_offset = options.notification.single_handler
+                    ? 0
+                    : offset
+                offsets.add(effective_offset)
+                dbg_assert(
+                    !!options.notification.handlers[effective_offset],
+                    'VirtIO device<' +
+                        this.name +
+                        "> every queue's notifier must exist",
+                )
+            }
+            for (const [
+                index,
+                handler,
+            ] of options.notification.handlers.entries()) {
+                dbg_assert(
+                    !handler || offsets.has(index),
+                    'VirtIO device<' +
+                        this.name +
+                        '> no defined notify handler should be unused',
+                )
+            }
+        }
+
+        const capabilities: VirtIO_CapabilityInfo[] = []
+        capabilities.push(this.create_common_capability(options.common))
+        capabilities.push(
+            this.create_notification_capability(options.notification),
+        )
+        capabilities.push(this.create_isr_capability(options.isr_status))
+        if (options.device_specific) {
+            capabilities.push(
+                this.create_device_specific_capability(options.device_specific),
+            )
+        }
+        this.init_capabilities(capabilities)
+
+        cpu.devices.pci.register_device(this)
+        this.reset()
+    }
+
+    create_common_capability(
+        options: VirtIO_CommonCapabilityOptions,
+    ): VirtIO_CapabilityInfo {
+        return {
+            type: VIRTIO_PCI_CAP_COMMON_CFG,
+            bar: 0,
+            port: options.initial_port,
+            use_mmio: false,
+            offset: 0,
+            extra: new Uint8Array(0),
+            struct: [
+                {
+                    bytes: 4,
+                    name: 'device_feature_select',
+                    read: () => this.device_feature_select,
+                    write: (data: number) => {
+                        this.device_feature_select = data
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'device_feature',
+                    read: () =>
+                        this.device_feature[this.device_feature_select] || 0,
+                    write: (_data: number) => {
+                        /* read only */
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'driver_feature_select',
+                    read: () => this.driver_feature_select,
+                    write: (data: number) => {
+                        this.driver_feature_select = data
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'driver_feature',
+                    read: () =>
+                        this.driver_feature[this.driver_feature_select] || 0,
+                    write: (data: number) => {
+                        const supported_feature =
+                            this.device_feature[this.driver_feature_select]
+
+                        if (
+                            this.driver_feature_select <
+                            this.driver_feature.length
+                        ) {
+                            // Note: only set subset of device_features is set.
+                            // Required in our implementation for is_feature_negotiated().
+                            this.driver_feature[this.driver_feature_select] =
+                                data & supported_feature
+                        }
+
+                        // Check that driver features is an inclusive subset of device features.
+                        const invalid_bits = data & ~supported_feature
+                        this.features_ok = this.features_ok && !invalid_bits
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'msix_config',
+                    read: () => {
+                        dbg_log('No msi-x capability supported.', LOG_VIRTIO)
+                        return 0xffff
+                    },
+                    write: (_data: number) => {
+                        dbg_log('No msi-x capability supported.', LOG_VIRTIO)
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'num_queues',
+                    read: () => this.queues.length,
+                    write: (_data: number) => {
+                        /* read only */
+                    },
+                },
+                {
+                    bytes: 1,
+                    name: 'device_status',
+                    read: () => this.device_status,
+                    write: (data: number) => {
+                        if (data === 0) {
+                            dbg_log(
+                                'Reset device<' + this.name + '>',
+                                LOG_VIRTIO,
+                            )
+                            this.reset()
+                        } else if (data & VIRTIO_STATUS_FAILED) {
+                            dbg_log(
+                                'Warning: Device<' +
+                                    this.name +
+                                    '> status failed',
+                                LOG_VIRTIO,
+                            )
+                        } else {
+                            dbg_log(
+                                'Device<' +
+                                    this.name +
+                                    '> status: ' +
+                                    (data & VIRTIO_STATUS_ACKNOWLEDGE
+                                        ? 'ACKNOWLEDGE '
+                                        : '') +
+                                    (data & VIRTIO_STATUS_DRIVER
+                                        ? 'DRIVER '
+                                        : '') +
+                                    (data & VIRTIO_STATUS_DRIVER_OK
+                                        ? 'DRIVER_OK'
+                                        : '') +
+                                    (data & VIRTIO_STATUS_FEATURES_OK
+                                        ? 'FEATURES_OK '
+                                        : '') +
+                                    (data & VIRTIO_STATUS_DEVICE_NEEDS_RESET
+                                        ? 'DEVICE_NEEDS_RESET'
+                                        : ''),
+                                LOG_VIRTIO,
+                            )
+                        }
+
+                        if (
+                            data &
+                                ~this.device_status &
+                                VIRTIO_STATUS_DRIVER_OK &&
+                            this.device_status &
+                                VIRTIO_STATUS_DEVICE_NEEDS_RESET
+                        ) {
+                            // We couldn't notify NEEDS_RESET earlier because DRIVER_OK was not set.
+                            // Now it has been set, notify now.
+                            this.notify_config_changes()
+                        }
+
+                        // Don't set FEATURES_OK if our device doesn't support requested features.
+                        if (!this.features_ok) {
+                            if (DEBUG && data & VIRTIO_STATUS_FEATURES_OK) {
+                                dbg_log('Removing FEATURES_OK', LOG_VIRTIO)
+                            }
+                            data &= ~VIRTIO_STATUS_FEATURES_OK
+                        }
+
+                        this.device_status = data
+
+                        if (
+                            data &
+                            ~this.device_status &
+                            VIRTIO_STATUS_DRIVER_OK
+                        ) {
+                            options.on_driver_ok()
+                        }
+                    },
+                },
+                {
+                    bytes: 1,
+                    name: 'config_generation',
+                    read: () => this.config_generation,
+                    write: (_data: number) => {
+                        /* read only */
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'queue_select',
+                    read: () => this.queue_select,
+                    write: (data: number) => {
+                        this.queue_select = data
+
+                        if (this.queue_select < this.queues.length) {
+                            this.queue_selected = this.queues[this.queue_select]
+                        } else {
+                            // Allow queue_select >= num_queues.
+                            this.queue_selected = null
+                            // Drivers can then detect that the queue is not available
+                            // using the below fields.
+                        }
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'queue_size',
+                    read: () =>
+                        this.queue_selected ? this.queue_selected.size : 0,
+                    write: (data: number) => {
+                        if (!this.queue_selected) {
+                            return
+                        }
+                        if (data & (data - 1)) {
+                            dbg_log(
+                                'Warning: dev<' +
+                                    this.name +
+                                    '> ' +
+                                    'Given queue size was not a power of 2. ' +
+                                    'Rounding up to next power of 2.',
+                                LOG_VIRTIO,
+                            )
+                            data = 1 << (int_log2(data - 1) + 1)
+                        }
+                        if (data > this.queue_selected.size_supported) {
+                            dbg_log(
+                                'Warning: dev<' +
+                                    this.name +
+                                    '> ' +
+                                    'Trying to set queue size greater than supported. ' +
+                                    'Clamping to supported size.',
+                                LOG_VIRTIO,
+                            )
+                            data = this.queue_selected.size_supported
+                        }
+                        this.queue_selected.set_size(data)
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'queue_msix_vector',
+                    read: () => {
+                        dbg_log('No msi-x capability supported.', LOG_VIRTIO)
+                        return 0xffff
+                    },
+                    write: (_data: number) => {
+                        dbg_log('No msi-x capability supported.', LOG_VIRTIO)
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'queue_enable',
+                    read: () =>
+                        this.queue_selected
+                            ? this.queue_selected.enabled
+                                ? 1
+                                : 0
+                            : 0,
+                    write: (data: number) => {
+                        if (!this.queue_selected) {
+                            return
+                        }
+                        if (data === 1) {
+                            if (this.queue_selected.is_configured()) {
+                                this.queue_selected.enable()
+                            } else {
+                                dbg_log(
+                                    'Driver bug: tried enabling unconfigured queue',
+                                    LOG_VIRTIO,
+                                )
+                            }
+                        } else if (data === 0) {
+                            dbg_log(
+                                'Driver bug: tried writing 0 to queue_enable',
+                                LOG_VIRTIO,
+                            )
+                        }
+                    },
+                },
+                {
+                    bytes: 2,
+                    name: 'queue_notify_off',
+                    read: () =>
+                        this.queue_selected
+                            ? this.queue_selected.notify_offset
+                            : 0,
+                    write: (_data: number) => {
+                        /* read only */
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_desc (low dword)',
+                    read: () =>
+                        this.queue_selected ? this.queue_selected.desc_addr : 0,
+                    write: (data: number) => {
+                        if (this.queue_selected)
+                            this.queue_selected.desc_addr = data
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_desc (high dword)',
+                    read: () => 0,
+                    write: (data: number) => {
+                        if (data !== 0)
+                            dbg_log(
+                                'Warning: High dword of 64 bit queue_desc ignored:' +
+                                    data,
+                                LOG_VIRTIO,
+                            )
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_avail (low dword)',
+                    read: () =>
+                        this.queue_selected
+                            ? this.queue_selected.avail_addr
+                            : 0,
+                    write: (data: number) => {
+                        if (this.queue_selected)
+                            this.queue_selected.avail_addr = data
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_avail (high dword)',
+                    read: () => 0,
+                    write: (data: number) => {
+                        if (data !== 0)
+                            dbg_log(
+                                'Warning: High dword of 64 bit queue_avail ignored:' +
+                                    data,
+                                LOG_VIRTIO,
+                            )
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_used (low dword)',
+                    read: () =>
+                        this.queue_selected ? this.queue_selected.used_addr : 0,
+                    write: (data: number) => {
+                        if (this.queue_selected)
+                            this.queue_selected.used_addr = data
+                    },
+                },
+                {
+                    bytes: 4,
+                    name: 'queue_used (high dword)',
+                    read: () => 0,
+                    write: (data: number) => {
+                        if (data !== 0)
+                            dbg_log(
+                                'Warning: High dword of 64 bit queue_used ignored:' +
+                                    data,
+                                LOG_VIRTIO,
+                            )
+                    },
+                },
+            ],
+        }
+    }
+
+    create_notification_capability(
+        options: VirtIO_NotificationCapabilityOptions,
+    ): VirtIO_CapabilityInfo {
+        const notify_struct: VirtIO_CapabilityStruct = []
+        let notify_off_multiplier: number
+
+        if (options.single_handler) {
+            dbg_assert(
+                options.handlers.length === 1,
+                'VirtIO device<' +
+                    this.name +
+                    '> too many notify handlers specified: expected single handler',
+            )
+
+            // Forces all queues to use the same address for notifying.
+            notify_off_multiplier = 0
+        } else {
+            notify_off_multiplier = 2
+        }
+
+        for (const [i, handler] of options.handlers.entries()) {
+            notify_struct.push({
+                bytes: 2,
+                name: 'notify' + i,
+                read: () => 0xffff,
+                write: handler || ((_data: number) => {}),
+            })
+        }
+
+        return {
+            type: VIRTIO_PCI_CAP_NOTIFY_CFG,
+            bar: 1,
+            port: options.initial_port,
+            use_mmio: false,
+            offset: 0,
+            extra: new Uint8Array([
+                notify_off_multiplier & 0xff,
+                (notify_off_multiplier >> 8) & 0xff,
+                (notify_off_multiplier >> 16) & 0xff,
+                notify_off_multiplier >> 24,
+            ]),
+            struct: notify_struct,
+        }
+    }
+
+    create_isr_capability(
+        options: VirtIO_ISRCapabilityOptions,
+    ): VirtIO_CapabilityInfo {
+        return {
+            type: VIRTIO_PCI_CAP_ISR_CFG,
+            bar: 2,
+            port: options.initial_port,
+            use_mmio: false,
+            offset: 0,
+            extra: new Uint8Array(0),
+            struct: [
+                {
+                    bytes: 1,
+                    name: 'isr_status',
+                    read: () => {
+                        const isr_status = this.isr_status
+                        this.lower_irq()
+                        return isr_status
+                    },
+                    write: (_data: number) => {
+                        /* read only */
+                    },
+                },
+            ],
+        }
+    }
+
+    create_device_specific_capability(
+        options: VirtIO_DeviceSpecificCapabilityOptions,
+    ): VirtIO_CapabilityInfo {
+        dbg_assert(
+            !(options.initial_port & 0x3),
+            'VirtIO device<' +
+                this.name +
+                '> device specific cap offset must be 4-byte aligned',
+        )
+
+        return {
+            type: VIRTIO_PCI_CAP_DEVICE_CFG,
+            bar: 3,
+            port: options.initial_port,
+            use_mmio: false,
+            offset: 0,
+            extra: new Uint8Array(0),
+            struct: options.struct,
+        }
+    }
+
+    // Writes capabilities into pci_space and hook up IO/MMIO handlers.
+    // Call only within constructor.
+    init_capabilities(capabilities: VirtIO_CapabilityInfo[]): void {
+        // Next available offset for capabilities linked list.
+        let cap_next = (this.pci_space[0x34] = 0x40)
+
+        // Current offset.
+        let cap_ptr = cap_next
+
+        for (const cap of capabilities) {
+            const cap_len = VIRTIO_PCI_CAP_LENGTH + cap.extra.length
+
+            cap_ptr = cap_next
+            cap_next = cap_ptr + cap_len
+
+            dbg_assert(
+                cap_next <= 256,
+                'VirtIO device<' +
+                    this.name +
+                    "> can't fit all capabilities into 256byte configspace",
+            )
+
+            dbg_assert(
+                0 <= cap.bar && cap.bar < 6,
+                'VirtIO device<' +
+                    this.name +
+                    '> capability invalid bar number',
+            )
+
+            let bar_size = cap.struct.reduce(
+                (bytes, field) => bytes + field.bytes,
+                0,
+            )
+            bar_size += cap.offset
+
+            // Round up to next power of 2,
+            // Minimum 16 bytes for its size to be detectable in general (esp. mmio).
+            bar_size = bar_size < 16 ? 16 : 1 << (int_log2(bar_size - 1) + 1)
+
+            dbg_assert(
+                (cap.port & (bar_size - 1)) === 0,
+                'VirtIO device<' +
+                    this.name +
+                    '> capability port should be aligned to pci bar size',
+            )
+
+            this.pci_bars[cap.bar] = {
+                size: bar_size,
+            }
+
+            this.pci_space[cap_ptr] = VIRTIO_PCI_CAP_VENDOR
+            this.pci_space[cap_ptr + 1] = cap_next
+            this.pci_space[cap_ptr + 2] = cap_len
+            this.pci_space[cap_ptr + 3] = cap.type
+            this.pci_space[cap_ptr + 4] = cap.bar
+
+            this.pci_space[cap_ptr + 5] = 0 // Padding.
+            this.pci_space[cap_ptr + 6] = 0 // Padding.
+            this.pci_space[cap_ptr + 7] = 0 // Padding.
+
+            this.pci_space[cap_ptr + 8] = cap.offset & 0xff
+            this.pci_space[cap_ptr + 9] = (cap.offset >>> 8) & 0xff
+            this.pci_space[cap_ptr + 10] = (cap.offset >>> 16) & 0xff
+            this.pci_space[cap_ptr + 11] = cap.offset >>> 24
+
+            this.pci_space[cap_ptr + 12] = bar_size & 0xff
+            this.pci_space[cap_ptr + 13] = (bar_size >>> 8) & 0xff
+            this.pci_space[cap_ptr + 14] = (bar_size >>> 16) & 0xff
+            this.pci_space[cap_ptr + 15] = bar_size >>> 24
+
+            for (const [i, extra_byte] of cap.extra.entries()) {
+                this.pci_space[cap_ptr + 16 + i] = extra_byte
+            }
+
+            const bar_offset = 0x10 + 4 * cap.bar
+            this.pci_space[bar_offset] = (cap.port & 0xfe) | +!cap.use_mmio
+            this.pci_space[bar_offset + 1] = (cap.port >>> 8) & 0xff
+            this.pci_space[bar_offset + 2] = (cap.port >>> 16) & 0xff
+            this.pci_space[bar_offset + 3] = (cap.port >>> 24) & 0xff
+
+            let port = cap.port + cap.offset
+
+            for (const field of cap.struct) {
+                let read: (...args: any[]) => number = field.read
+                let write: (...args: any[]) => void = field.write
+
+                if (DEBUG) {
+                    read = () => {
+                        const val = field.read()
+
+                        dbg_log(
+                            'Device<' +
+                                this.name +
+                                '> ' +
+                                'cap[' +
+                                cap.type +
+                                '] ' +
+                                'read[' +
+                                field.name +
+                                '] ' +
+                                '=> ' +
+                                h(val, field.bytes * 8),
+                            LOG_VIRTIO,
+                        )
+
+                        return val
+                    }
+                    write = (data: number) => {
+                        dbg_log(
+                            'Device<' +
+                                this.name +
+                                '> ' +
+                                'cap[' +
+                                cap.type +
+                                '] ' +
+                                'write[' +
+                                field.name +
+                                '] ' +
+                                '<= ' +
+                                h(data, field.bytes * 8),
+                            LOG_VIRTIO,
+                        )
+
+                        field.write(data)
+                    }
+                }
+
+                if (cap.use_mmio) {
+                    dbg_assert(
+                        false,
+                        'VirtIO device <' +
+                            this.name +
+                            '> mmio capability not implemented.',
+                    )
+                } else {
+                    // DSL (2.4 kernel) does these reads
+                    const shim_read8_on_16 = function (addr: number): number {
+                        dbg_log(
+                            'Warning: 8-bit read from 16-bit virtio port',
+                            LOG_VIRTIO,
+                        )
+                        return (read(addr & ~1) >> ((addr & 1) << 3)) & 0xff
+                    }
+                    const shim_read8_on_32 = function (addr: number): number {
+                        dbg_log(
+                            'Warning: 8-bit read from 32-bit virtio port',
+                            LOG_VIRTIO,
+                        )
+                        return (read(addr & ~3) >> ((addr & 3) << 3)) & 0xff
+                    }
+
+                    // archhurd does these reads
+                    const shim_read32_on_16 = function (addr: number): number {
+                        dbg_log(
+                            'Warning: 32-bit read from 16-bit virtio port',
+                            LOG_VIRTIO,
+                        )
+                        return read(addr)
+                    }
+
+                    switch (field.bytes) {
+                        case 4:
+                            this.cpu.io.register_read(
+                                port,
+                                this,
+                                shim_read8_on_32,
+                                undefined,
+                                read,
+                            )
+                            this.cpu.io.register_read(
+                                port + 1,
+                                this,
+                                shim_read8_on_32,
+                            )
+                            this.cpu.io.register_read(
+                                port + 2,
+                                this,
+                                shim_read8_on_32,
+                            )
+                            this.cpu.io.register_read(
+                                port + 3,
+                                this,
+                                shim_read8_on_32,
+                            )
+                            this.cpu.io.register_write(
+                                port,
+                                this,
+                                undefined,
+                                undefined,
+                                write,
+                            )
+                            break
+                        case 2:
+                            this.cpu.io.register_read(
+                                port,
+                                this,
+                                shim_read8_on_16,
+                                read,
+                                shim_read32_on_16,
+                            )
+                            this.cpu.io.register_read(
+                                port + 1,
+                                this,
+                                shim_read8_on_16,
+                            )
+                            this.cpu.io.register_write(
+                                port,
+                                this,
+                                undefined,
+                                write,
+                            )
+                            break
+                        case 1:
+                            this.cpu.io.register_read(port, this, read)
+                            this.cpu.io.register_write(port, this, write)
+                            break
+                        default:
+                            dbg_assert(
+                                false,
+                                'VirtIO device <' +
+                                    this.name +
+                                    '> invalid capability field width of ' +
+                                    field.bytes +
+                                    ' bytes',
+                            )
+                            break
+                    }
+                }
+
+                port += field.bytes
+            }
+        }
+
+        // Terminate linked list with the pci config access capability.
+
+        const cap_len = VIRTIO_PCI_CAP_LENGTH + 4
+        dbg_assert(
+            cap_next + cap_len <= 256,
+            'VirtIO device<' +
+                this.name +
+                "> can't fit all capabilities into 256byte configspace",
+        )
+        this.pci_space[cap_next] = VIRTIO_PCI_CAP_VENDOR
+        this.pci_space[cap_next + 1] = 0 // cap next (null terminator)
+        this.pci_space[cap_next + 2] = cap_len
+        this.pci_space[cap_next + 3] = VIRTIO_PCI_CAP_PCI_CFG // cap type
+        this.pci_space[cap_next + 4] = 0 // bar (written by device)
+        this.pci_space[cap_next + 5] = 0 // Padding.
+        this.pci_space[cap_next + 6] = 0 // Padding.
+        this.pci_space[cap_next + 7] = 0 // Padding.
+
+        // Remaining fields are configured by driver when needed.
+
+        // offset
+        this.pci_space[cap_next + 8] = 0
+        this.pci_space[cap_next + 9] = 0
+        this.pci_space[cap_next + 10] = 0
+        this.pci_space[cap_next + 11] = 0
+
+        // bar size
+        this.pci_space[cap_next + 12] = 0
+        this.pci_space[cap_next + 13] = 0
+        this.pci_space[cap_next + 14] = 0
+        this.pci_space[cap_next + 15] = 0
+
+        // cfg_data
+        this.pci_space[cap_next + 16] = 0
+        this.pci_space[cap_next + 17] = 0
+        this.pci_space[cap_next + 18] = 0
+        this.pci_space[cap_next + 19] = 0
+
+        //
+        // TODO
+        // The pci config access capability is required by spec, but so far, devices
+        // seem to work well without it.
+        // This capability provides a cfg_data field (at cap_next + 16 for 4 bytes)
+        // that acts like a window to the previous bars. The driver writes the bar number,
+        // offset, and length values in this capability, and the cfg_data field should
+        // mirror the data referred by the bar, offset and length. Here, length can be
+        // 1, 2, or 4.
+        //
+        // This requires some sort of pci devicespace read and write handlers.
+    }
+
+    get_state(): any[] {
+        let state: any[] = []
+
+        state[0] = this.device_feature_select
+        state[1] = this.driver_feature_select
+        state[2] = this.device_feature
+        state[3] = this.driver_feature
+        state[4] = this.features_ok
+        state[5] = this.device_status
+        state[6] = this.config_has_changed
+        state[7] = this.config_generation
+        state[8] = this.isr_status
+        state[9] = this.queue_select
+        state = state.concat(this.queues)
+
+        return state
+    }
+
+    set_state(state: any[]): void {
+        this.device_feature_select = state[0]
+        this.driver_feature_select = state[1]
+        this.device_feature = state[2]
+        this.driver_feature = state[3]
+        this.features_ok = state[4]
+        this.device_status = state[5]
+        this.config_has_changed = state[6]
+        this.config_generation = state[7]
+        this.isr_status = state[8]
+        this.queue_select = state[9]
+        let i = 0
+        for (const queue of state.slice(10)) {
+            this.queues[i].set_state(queue)
+            i++
+        }
+        this.queue_selected = this.queues[this.queue_select] || null
+    }
+
+    reset(): void {
+        this.device_feature_select = 0
+        this.driver_feature_select = 0
+        this.driver_feature.set(this.device_feature)
+
+        this.features_ok = true
+        this.device_status = 0
+
+        this.queue_select = 0
+        this.queue_selected = this.queues[0]
+
+        for (const queue of this.queues) {
+            queue.reset()
+        }
+
+        this.config_has_changed = false
+        this.config_generation = 0
+
+        this.lower_irq()
+    }
+
+    // Call this when device-specific configuration state changes.
+    // Also called when status DEVICE_NEEDS_RESET is set.
+    notify_config_changes(): void {
+        this.config_has_changed = true
+
+        if (this.device_status & VIRTIO_STATUS_DRIVER_OK) {
+            this.raise_irq(VIRTIO_ISR_DEVICE_CFG)
+        } else {
+            dbg_assert(
+                false,
+                'VirtIO device<' +
+                    this.name +
+                    '> attempted to notify driver before DRIVER_OK',
+            )
+        }
+    }
+
+    // To be called after reading any field whose write can trigger notify_config_changes().
+    update_config_generation(): void {
+        if (this.config_has_changed) {
+            this.config_generation++
+            this.config_generation &= 0xff
+            this.config_has_changed = false
+        }
+    }
+
+    is_feature_negotiated(feature: number): boolean {
+        // Feature bits are grouped in 32 bits.
+        // Note: earlier we chose not to set invalid features into driver_feature.
+        return (
+            (this.driver_feature[feature >>> 5] & (1 << (feature & 0x1f))) > 0
+        )
+    }
+
+    // Call this if an irrecoverable error has occurred.
+    // Notifies driver if DRIVER_OK, or when DRIVER_OK gets set.
+    needs_reset(): void {
+        dbg_log(
+            'Device<' + this.name + '> experienced error - requires reset',
+            LOG_VIRTIO,
+        )
+        this.device_status |= VIRTIO_STATUS_DEVICE_NEEDS_RESET
+
+        if (this.device_status & VIRTIO_STATUS_DRIVER_OK) {
+            this.notify_config_changes()
+        }
+    }
+
+    raise_irq(type: number): void {
+        dbg_log('Raise irq ' + h(type), LOG_VIRTIO)
+        this.isr_status |= type
+        this.pci.raise_irq(this.pci_id)
+    }
+
+    lower_irq(): void {
+        dbg_log('Lower irq ', LOG_VIRTIO)
+        this.isr_status = 0
+        this.pci.lower_irq(this.pci_id)
+    }
+}
+
+export class VirtQueue {
+    cpu: VirtioCPU
+    virtio: VirtIO
+    size: number
+    size_supported: number
+    mask: number
+    enabled: boolean
+    notify_offset: number
+    desc_addr: number
+    avail_addr: number
+    avail_last_idx: number
+    used_addr: number
+    num_staged_replies: number
+    fix_wrapping: boolean
+
+    constructor(cpu: VirtioCPU, virtio: VirtIO, options: VirtQueue_Options) {
+        this.cpu = cpu
+        this.virtio = virtio
+
+        // Number of entries.
+        this.size = options.size_supported
+        this.size_supported = options.size_supported
+        this.mask = this.size - 1
+        this.enabled = false
+        this.notify_offset = options.notify_offset
+
+        this.desc_addr = 0
+
+        this.avail_addr = 0
+        this.avail_last_idx = 0
+
+        this.used_addr = 0
+        this.num_staged_replies = 0
+
+        this.fix_wrapping = false
+
+        this.reset()
+    }
+
+    get_state(): any[] {
+        const state: any[] = []
+
+        state[0] = this.size
+        state[1] = this.size_supported
+        state[2] = this.enabled
+        state[3] = this.notify_offset
+        state[4] = this.desc_addr
+        state[5] = this.avail_addr
+        state[6] = this.avail_last_idx
+        state[7] = this.used_addr
+        state[8] = this.num_staged_replies
+        state[9] = 1
+
+        return state
+    }
+
+    set_state(state: any[]): void {
+        this.size = state[0]
+        this.size_supported = state[1]
+        this.enabled = state[2]
+        this.notify_offset = state[3]
+        this.desc_addr = state[4]
+        this.avail_addr = state[5]
+        this.avail_last_idx = state[6]
+        this.used_addr = state[7]
+        this.num_staged_replies = state[8]
+
+        this.mask = this.size - 1
+        this.fix_wrapping = state[9] !== 1
+    }
+
+    reset(): void {
+        this.enabled = false
+        this.desc_addr = 0
+        this.avail_addr = 0
+        this.avail_last_idx = 0
+        this.used_addr = 0
+        this.num_staged_replies = 0
+        this.set_size(this.size_supported)
+    }
+
+    is_configured(): boolean {
+        return !!(this.desc_addr && this.avail_addr && this.used_addr)
+    }
+
+    enable(): void {
+        dbg_assert(
+            this.is_configured(),
+            'VirtQueue must be configured before enabled',
+        )
+        this.enabled = true
+    }
+
+    set_size(size: number): void {
+        dbg_assert(
+            (size & (size - 1)) === 0,
+            'VirtQueue size must be power of 2 or zero',
+        )
+        dbg_assert(
+            size <= this.size_supported,
+            'VirtQueue size must be within supported size',
+        )
+        this.size = size
+        this.mask = size - 1
+    }
+
+    count_requests(): number {
+        dbg_assert(
+            !!this.avail_addr,
+            'VirtQueue addresses must be configured before use',
+        )
+        if (this.fix_wrapping) {
+            this.fix_wrapping = false
+            this.avail_last_idx =
+                (this.avail_get_idx() & ~this.mask) +
+                (this.avail_last_idx & this.mask)
+        }
+        return (this.avail_get_idx() - this.avail_last_idx) & 0xffff
+    }
+
+    has_request(): boolean {
+        dbg_assert(
+            !!this.avail_addr,
+            'VirtQueue addresses must be configured before use',
+        )
+        return this.count_requests() !== 0
+    }
+
+    pop_request(): VirtQueueBufferChain {
+        dbg_assert(
+            !!this.avail_addr,
+            'VirtQueue addresses must be configured before use',
+        )
+        dbg_assert(
+            this.has_request(),
+            'VirtQueue must not pop nonexistent request',
+        )
+
+        const desc_idx = this.avail_get_entry(this.avail_last_idx)
+        dbg_log(
+            'Pop request: avail_last_idx=' +
+                this.avail_last_idx +
+                ' desc_idx=' +
+                desc_idx,
+            LOG_VIRTIO,
+        )
+
+        const bufchain = new VirtQueueBufferChain(this, desc_idx)
+
+        this.avail_last_idx = (this.avail_last_idx + 1) & 0xffff
+
+        return bufchain
+    }
+
+    // Stage a buffer chain into the used ring.
+    // Can call push_reply many times before flushing to batch replies together.
+    // Note: this reply is not visible to driver until flush_replies is called.
+    push_reply(bufchain: VirtQueueBufferChain): void {
+        dbg_assert(
+            !!this.used_addr,
+            'VirtQueue addresses must be configured before use',
+        )
+        dbg_assert(
+            this.num_staged_replies < this.size,
+            'VirtQueue replies must not exceed queue size',
+        )
+
+        const used_idx =
+            (this.used_get_idx() + this.num_staged_replies) & this.mask
+        dbg_log(
+            'Push reply: used_idx=' +
+                used_idx +
+                ' desc_idx=' +
+                bufchain.head_idx,
+            LOG_VIRTIO,
+        )
+
+        this.used_set_entry(
+            used_idx,
+            bufchain.head_idx,
+            bufchain.length_written,
+        )
+        this.num_staged_replies++
+    }
+
+    // Makes replies visible to driver by updating the used ring idx and
+    // firing appropriate interrupt if needed.
+    flush_replies(): void {
+        dbg_assert(
+            !!this.used_addr,
+            'VirtQueue addresses must be configured before use',
+        )
+
+        if (this.num_staged_replies === 0) {
+            dbg_log('flush_replies: Nothing to flush', LOG_VIRTIO)
+            return
+        }
+
+        dbg_log('Flushing ' + this.num_staged_replies + ' replies', LOG_VIRTIO)
+        const old_idx = this.used_get_idx()
+        const new_idx = (old_idx + this.num_staged_replies) & VIRTQ_IDX_MASK
+        this.used_set_idx(new_idx)
+
+        this.num_staged_replies = 0
+
+        if (this.virtio.is_feature_negotiated(VIRTIO_F_RING_EVENT_IDX)) {
+            const used_event = this.avail_get_used_event()
+
+            // Fire irq when idx values associated with the pushed reply buffers
+            // has reached or gone past used_event.
+            let _has_passed = old_idx <= used_event && used_event < new_idx
+
+            // Has overflowed? Assumes num_staged_replies > 0.
+            if (new_idx <= old_idx) {
+                _has_passed = used_event < new_idx || old_idx <= used_event
+            }
+
+            // Commented out: Workaround for sometimes loading from the filesystem hangs and the emulator stays idle
+            //if(has_passed)
+            {
+                this.virtio.raise_irq(VIRTIO_ISR_QUEUE)
+            }
+        } else {
+            if (~this.avail_get_flags() & VIRTQ_AVAIL_F_NO_INTERRUPT) {
+                this.virtio.raise_irq(VIRTIO_ISR_QUEUE)
+            }
+        }
+    }
+
+    // If using VIRTIO_F_RING_EVENT_IDX, device must tell driver when
+    // to get notifications or else driver won't notify regularly.
+    // If not using VIRTIO_F_RING_EVENT_IDX, driver will ignore avail_event
+    // and notify every request regardless unless NO_NOTIFY is set (TODO implement when needed).
+    notify_me_after(num_skipped_requests: number): void {
+        dbg_assert(
+            num_skipped_requests >= 0,
+            'Must skip a non-negative number of requests',
+        )
+
+        // The 16 bit idx field wraps around after 2^16.
+        const avail_event =
+            (this.avail_get_idx() + num_skipped_requests) & 0xffff
+        this.used_set_avail_event(avail_event)
+    }
+
+    get_descriptor(table_address: number, i: number): VirtQueueDescriptor {
+        return {
+            addr_low: this.cpu.read32s(
+                table_address + i * VIRTQ_DESC_ENTRYSIZE,
+            ),
+            addr_high: this.cpu.read32s(
+                table_address + i * VIRTQ_DESC_ENTRYSIZE + 4,
+            ),
+            len: this.cpu.read32s(table_address + i * VIRTQ_DESC_ENTRYSIZE + 8),
+            flags: this.cpu.read16(
+                table_address + i * VIRTQ_DESC_ENTRYSIZE + 12,
+            ),
+            next: this.cpu.read16(
+                table_address + i * VIRTQ_DESC_ENTRYSIZE + 14,
+            ),
+        }
+    }
+
+    // Avail ring fields
+
+    avail_get_flags(): number {
+        return this.cpu.read16(this.avail_addr)
+    }
+
+    avail_get_idx(): number {
+        return this.cpu.read16(this.avail_addr + 2)
+    }
+
+    avail_get_entry(i: number): number {
+        return this.cpu.read16(
+            this.avail_addr + 4 + VIRTQ_AVAIL_ENTRYSIZE * (i & this.mask),
+        )
+    }
+
+    avail_get_used_event(): number {
+        return this.cpu.read16(
+            this.avail_addr + 4 + VIRTQ_AVAIL_ENTRYSIZE * this.size,
+        )
+    }
+
+    // Used ring fields
+
+    used_get_flags(): number {
+        return this.cpu.read16(this.used_addr)
+    }
+
+    used_set_flags(value: number): void {
+        this.cpu.write16(this.used_addr, value)
+    }
+
+    used_get_idx(): number {
+        return this.cpu.read16(this.used_addr + 2)
+    }
+
+    used_set_idx(value: number): void {
+        this.cpu.write16(this.used_addr + 2, value)
+    }
+
+    used_set_entry(i: number, desc_idx: number, length_written: number): void {
+        this.cpu.write32(
+            this.used_addr + 4 + VIRTQ_USED_ENTRYSIZE * i,
+            desc_idx,
+        )
+        this.cpu.write32(
+            this.used_addr + 8 + VIRTQ_USED_ENTRYSIZE * i,
+            length_written,
+        )
+    }
+
+    used_set_avail_event(value: number): void {
+        this.cpu.write16(
+            this.used_addr + 4 + VIRTQ_USED_ENTRYSIZE * this.size,
+            value,
+        )
+    }
+}
+
+// Traverses through descriptor chain starting at head_id.
+// Provides means to read/write to buffers represented by the descriptors.
+export class VirtQueueBufferChain {
+    cpu: VirtioCPU
+    virtio: VirtIO
+    head_idx: number
+    read_buffers: VirtQueueDescriptor[]
+    read_buffer_idx: number
+    read_buffer_offset: number
+    length_readable: number
+    write_buffers: VirtQueueDescriptor[]
+    write_buffer_idx: number
+    write_buffer_offset: number
+    length_written: number
+    length_writable: number
+
+    constructor(virtqueue: VirtQueue, head_idx: number) {
+        this.cpu = virtqueue.cpu
+        this.virtio = virtqueue.virtio
+
+        this.head_idx = head_idx
+
+        this.read_buffers = []
+        // Pointers for sequential consumption via get_next_blob.
+        this.read_buffer_idx = 0
+        this.read_buffer_offset = 0
+        this.length_readable = 0
+
+        this.write_buffers = []
+        // Pointers for sequential write via set_next_blob.
+        this.write_buffer_idx = 0
+        this.write_buffer_offset = 0
+        this.length_written = 0
+        this.length_writable = 0
+
+        // Traverse chain to discover buffers.
+        // - There shouldn't be an excessive amount of descriptor elements.
+        let table_address = virtqueue.desc_addr
+        let desc_idx = head_idx
+        let chain_length = 0
+        let chain_max = virtqueue.size
+        let writable_region = false
+        const has_indirect_feature = this.virtio.is_feature_negotiated(
+            VIRTIO_F_RING_INDIRECT_DESC,
+        )
+        dbg_log('<<< Descriptor chain start', LOG_VIRTIO)
+        do {
+            const desc = virtqueue.get_descriptor(table_address, desc_idx)
+
+            dbg_log(
+                'descriptor: idx=' +
+                    desc_idx +
+                    ' addr=' +
+                    h(desc.addr_high, 8) +
+                    ':' +
+                    h(desc.addr_low, 8) +
+                    ' len=' +
+                    h(desc.len, 8) +
+                    ' flags=' +
+                    h(desc.flags, 4) +
+                    ' next=' +
+                    h(desc.next, 4),
+                LOG_VIRTIO,
+            )
+
+            if (has_indirect_feature && desc.flags & VIRTQ_DESC_F_INDIRECT) {
+                if (DEBUG && desc.flags & VIRTQ_DESC_F_NEXT) {
+                    dbg_log(
+                        'Driver bug: has set VIRTQ_DESC_F_NEXT flag in an indirect table descriptor',
+                        LOG_VIRTIO,
+                    )
+                }
+
+                // Carry on using indirect table, starting at first entry.
+                table_address = desc.addr_low
+                desc_idx = 0
+                chain_length = 0
+                chain_max = desc.len / VIRTQ_DESC_ENTRYSIZE
+                dbg_log('start indirect', LOG_VIRTIO)
+                continue
+            }
+
+            if (desc.flags & VIRTQ_DESC_F_WRITE) {
+                writable_region = true
+                this.write_buffers.push(desc)
+                this.length_writable += desc.len
+            } else {
+                if (writable_region) {
+                    dbg_log(
+                        'Driver bug: readonly buffer after writeonly buffer within chain',
+                        LOG_VIRTIO,
+                    )
+                    break
+                }
+                this.read_buffers.push(desc)
+                this.length_readable += desc.len
+            }
+
+            chain_length++
+            if (chain_length > chain_max) {
+                dbg_log(
+                    'Driver bug: descriptor chain cycle detected',
+                    LOG_VIRTIO,
+                )
+                break
+            }
+
+            if (desc.flags & VIRTQ_DESC_F_NEXT) {
+                desc_idx = desc.next
+            } else {
+                break
+            }
+            // eslint-disable-next-line no-constant-condition
+        } while (true)
+        dbg_log('Descriptor chain end >>>', LOG_VIRTIO)
+    }
+
+    // Reads the next blob of memory represented by the buffer chain into dest_buffer.
+    get_next_blob(dest_buffer: Uint8Array): number {
+        let dest_offset = 0
+        let remaining = dest_buffer.length
+
+        while (remaining) {
+            if (this.read_buffer_idx === this.read_buffers.length) {
+                dbg_log(
+                    'Device<' +
+                        this.virtio.name +
+                        '> Read more than device-readable buffers has',
+                    LOG_VIRTIO,
+                )
+                break
+            }
+
+            const buf = this.read_buffers[this.read_buffer_idx]
+            const read_address = buf.addr_low + this.read_buffer_offset
+            let read_length = buf.len - this.read_buffer_offset
+
+            if (read_length > remaining) {
+                read_length = remaining
+                this.read_buffer_offset += remaining
+            } else {
+                this.read_buffer_idx++
+                this.read_buffer_offset = 0
+            }
+
+            dest_buffer.set(
+                this.cpu.read_blob(read_address, read_length),
+                dest_offset,
+            )
+
+            dest_offset += read_length
+            remaining -= read_length
+        }
+
+        return dest_offset
+    }
+
+    // Appends contents of src_buffer into the memory represented by the buffer chain.
+    set_next_blob(src_buffer: Uint8Array): number {
+        let src_offset = 0
+        let remaining = src_buffer.length
+
+        while (remaining) {
+            if (this.write_buffer_idx === this.write_buffers.length) {
+                dbg_log(
+                    'Device<' +
+                        this.virtio.name +
+                        '> Write more than device-writable capacity',
+                    LOG_VIRTIO,
+                )
+                break
+            }
+
+            const buf = this.write_buffers[this.write_buffer_idx]
+            const write_address = buf.addr_low + this.write_buffer_offset
+            let write_length = buf.len - this.write_buffer_offset
+
+            if (write_length > remaining) {
+                write_length = remaining
+                this.write_buffer_offset += remaining
+            } else {
+                this.write_buffer_idx++
+                this.write_buffer_offset = 0
+            }
+
+            const src_end = src_offset + write_length
+            this.cpu.write_blob(
+                src_buffer.subarray(src_offset, src_end),
+                write_address,
+            )
+
+            src_offset += write_length
+            remaining -= write_length
+        }
+
+        this.length_written += src_offset
+        return src_offset
+    }
+}