hv: Add 9P virtio peripheral

Add some minimal implementation of virtio peripherals. At the level
of on-target hypervisor code we implement the MMIO layout and
maintain virtqueues. Once a buffer is available, we break into the
host proxyclient to deal with it.

Specific device-classes of the virtio spec ought to be implemented in
the proxyclient. Here the one device implemented is 9P transport,
exporting the m1n1 source directory.

Signed-off-by: Martin Povišer <[email protected]>

Author: povik

Makefile

@@ -99,7 +99,7 @@ OBJECTS := \
 	firmware.o \
 	gxf.o gxf_asm.o \
 	heapblock.o \
-	hv.o hv_vm.o hv_exc.o hv_vuart.o hv_wdt.o hv_asm.o hv_aic.o \
+	hv.o hv_vm.o hv_exc.o hv_vuart.o hv_wdt.o hv_asm.o hv_aic.o hv_virtio.o \
 	i2c.o \
 	iodev.o \
 	iova.o \

proxyclient/m1n1/hv/__init__.py

@@ -13,6 +13,7 @@
 
 from .gdbserver import *
 from .types import *
+from .virtio import *
 
 __all__ = ["HV"]
 
@@ -111,6 +112,7 @@ def __init__(self, iface, proxy, utils):
         self.hvcall_handlers = {}
         self.switching_context = False
         self.show_timestamps = False
+        self.virtio_devs = {}
 
     def _reloadme(self):
         super()._reloadme()
@@ -999,6 +1001,52 @@ def handle_bark(self, reason, code, info):
 
         self.p.exit(0)
 
+    def attach_virtio(self, dev, base=None, irq=None, verbose=False):
+        assert base is not None and irq is not None
+        # TODO: ^-- allocate those if not chosen by caller
+
+        data = dev.config_data
+        data_base = self.u.heap.malloc(len(data))
+        self.iface.writemem(data_base, data)
+
+        config = VirtioConfig.build({
+            "irq": irq,
+            "devid": dev.devid,
+            "feats": dev.feats,
+            "num_qus": dev.num_qus,
+            "data": data_base,
+            "data_len": len(data),
+            "verbose": verbose,
+        })
+
+        config_base = self.u.heap.malloc(len(config))
+        self.iface.writemem(config_base, config)
+
+        self.p.hv_map_virtio(base, config_base)
+        self.add_tracer(irange(base, 0x1000), "VIRTIO", TraceMode.RESERVED)
+
+        dev.base = base
+        dev.hv = self
+        self.virtio_devs[base] = dev
+
+    def handle_virtio(self, reason, code, info):
+        ctx = self.iface.readstruct(info, ExcInfo)
+        self.virtio_ctx = info = self.iface.readstruct(ctx.data, VirtioExcInfo)
+
+        try:
+            handled = self.virtio_devs[info.devbase].handle_exc(info)
+        except:
+            self.log(f"Python exception from within virtio handler")
+            traceback.print_exc()
+            handled = False
+
+        if not handled:
+            signal.signal(signal.SIGINT, self.default_sigint)
+            self.run_shell("Entering hypervisor shell", "Returning")
+            signal.signal(signal.SIGINT, self._handle_sigint)
+
+        self.p.exit(EXC_RET.HANDLED)
+
     def skip(self):
         self.ctx.elr += 4
         self.cont()
@@ -1299,6 +1347,7 @@ def init(self):
         self.iface.set_handler(START.HV, HV_EVENT.VTIMER, self.handle_exception)
         self.iface.set_handler(START.HV, HV_EVENT.WDT_BARK, self.handle_bark)
         self.iface.set_handler(START.HV, HV_EVENT.CPU_SWITCH, self.handle_exception)
+        self.iface.set_handler(START.HV, HV_EVENT.VIRTIO, self.handle_virtio)
         self.iface.set_event_handler(EVENT.MMIOTRACE, self.handle_mmiotrace)
         self.iface.set_event_handler(EVENT.IRQTRACE, self.handle_irqtrace)
 

proxyclient/m1n1/hv/types.py

@@ -37,6 +37,7 @@ class HV_EVENT(IntEnum):
     USER_INTERRUPT = 3
     WDT_BARK = 4
     CPU_SWITCH = 5
+    VIRTIO = 6
 
 VMProxyHookData = Struct(
     "flags" / RegAdapter(MMIOTraceFlags),

proxyclient/m1n1/hv/virtio.py

@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: MIT
+from construct import Struct, Int8ul, Int16ul, Int32sl, Int32ul, Int64ul
+from subprocess import Popen, PIPE
+import pathlib
+import struct
+import os
+import sys
+
+from ..utils import *
+
+VirtioConfig = Struct(
+    "irq" / Int32sl,
+    "devid" / Int32ul,
+    "feats" / Int64ul,
+    "num_qus" / Int32ul,
+    "data" / Int64ul,
+    "data_len" / Int64ul,
+    "verbose" / Int8ul,
+)
+
+class VirtioDescFlags(Register16):
+    WRITE = 1
+    NEXT  = 0
+
+VirtioDesc = Struct(
+    "addr" / Int64ul,
+    "len" / Int32ul,
+    "flags" / RegAdapter(VirtioDescFlags),
+    "next" / Int16ul,
+)
+
+VirtioExcInfo = Struct(
+    "devbase" / Int64ul,
+    "qu" / Int16ul,
+    "idx" / Int16ul,
+    "pad" / Int32ul, 
+    "descbase" / Int64ul,
+)
+
+class VirtioDev:
+    def __init__(self):
+        self.base, self.hv = None, None # assigned by HV object
+
+    def read_buf(self, desc):
+        return self.hv.iface.readmem(desc.addr, desc.len)
+
+    def read_desc(self, ctx, idx):
+        off = VirtioDesc.sizeof() * idx
+        return self.hv.iface.readstruct(ctx.descbase + off, VirtioDesc)
+
+    @property
+    def config_data(self):
+        return b""
+
+    @property
+    def devid(self):
+        return 0
+
+    @property
+    def num_qus(self):
+        return 1
+
+    @property
+    def feats(self):
+        return 0
+
+class Virtio9PTransport(VirtioDev):
+    def __init__(self, tag="m1n1", root=None):
+        p_stdin, self.fin = os.pipe()
+        self.fout, p_stdout = os.pipe()
+        if root is None:
+            root = str(pathlib.Path(__file__).resolve().parents[3])
+        if type(tag) is str:
+            self.tag = tag.encode("ascii")
+        else:
+            self.tag = tag
+        self.p = Popen([
+            "u9fs",
+            "-a", "none", # no auth
+            "-n", # not a network conn
+            "-u", os.getlogin(), # single user
+            root,
+        ], stdin=p_stdin, stdout=p_stdout, stderr=sys.stderr)
+
+    @property
+    def config_data(self):
+        return struct.pack("=H", len(self.tag)) + self.tag
+
+    @property
+    def devid(self):
+        return 9
+
+    @property
+    def num_qus(self):
+        return 1
+
+    @property
+    def feats(self):
+        return 1
+
+    def call(self, req):
+        os.write(self.fin, req)
+        resp = os.read(self.fout, 4)
+        length = int.from_bytes(resp, byteorder="little")
+        resp += os.read(self.fout, length - 4)
+        return resp
+
+    def handle_exc(self, ctx):
+        head = self.read_desc(ctx, ctx.idx)
+        assert not head.flags.WRITE
+
+        req = bytearray()
+
+        while not head.flags.WRITE:
+            req += self.read_buf(head)
+
+            if not head.flags.NEXT:
+                break
+            head = self.read_desc(ctx, head.next)
+
+        resp = self.call(bytes(req))
+        resplen = len(resp)
+
+        while len(resp):
+            self.hv.iface.writemem(head.addr, resp[:head.len])
+            resp = resp[head.len:]
+            if not head.flags.NEXT:
+                break
+            head = self.read_desc(ctx, head.next)
+
+        self.hv.p.virtio_put_buffer(ctx.devbase, ctx.qu, ctx.idx, resplen)
+
+        return True

proxyclient/m1n1/proxy.py

@@ -594,6 +594,8 @@ class M1N1Proxy(Reloadable):
     P_HV_SET_TIME_STEALING = 0xc0a
     P_HV_PIN_CPU = 0xc0b
     P_HV_WRITE_HCR = 0xc0c
+    P_HV_MAP_VIRTIO = 0xc0d
+    P_VIRTIO_PUT_BUFFER = 0xc0e
 
     P_FB_INIT = 0xd00
     P_FB_SHUTDOWN = 0xd01
@@ -1025,6 +1027,10 @@ def hv_pin_cpu(self, cpu):
         return self.request(self.P_HV_PIN_CPU, cpu)
     def hv_write_hcr(self, hcr):
         return self.request(self.P_HV_WRITE_HCR, hcr)
+    def hv_map_virtio(self, base, config):
+        return self.request(self.P_HV_MAP_VIRTIO, base, config)
+    def virtio_put_buffer(self, base, qu, idx, length):
+        return self.request(self.P_VIRTIO_PUT_BUFFER, base, qu, idx, length)
 
     def fb_init(self):
         return self.request(self.P_FB_INIT)

src/hv.h

@@ -47,6 +47,7 @@ typedef enum _hv_entry_type {
     HV_USER_INTERRUPT,
     HV_WDT_BARK,
     HV_CPU_SWITCH,
+    HV_VIRTIO,
 } hv_entry_type;
 
 /* VM */
@@ -69,6 +70,9 @@ bool hv_trace_irq(u32 type, u32 num, u32 count, u32 flags);
 /* Virtual peripherals */
 void hv_vuart_poll(void);
 void hv_map_vuart(u64 base, int irq, iodev_id_t iodev);
+struct virtio_conf;
+void hv_map_virtio(u64 base, struct virtio_conf *conf);
+void virtio_put_buffer(u64 base, int qu, u32 id, u32 len);
 
 /* Exceptions */
 void hv_exc_proxy(struct exc_info *ctx, uartproxy_boot_reason_t reason, u32 type, void *extra);