Migrate virtio-net from semu

This commit migrates virtio-net support from semu with the
following modifications:

1. Implement virtio-net device model
The virtio-net implementation follows the VirtIO-MMIO flow used by
virtio-blk, including feature negotiation, queue setup, QueueNotify
handling, used ring update, interrupt status, and device status reset.

The device currently supports a TAP-backend network interface and
handles basic RX/TX virtqueue processing for guest network packets.

2. Add TAP backend helper
Introduce netdev.c and netdev.h to provide host-side TAP device access.
Future work may support other host-side backend.

3. Handle virtio-net header processing
For guest TX, the device skips the virtio-net header before writing the
Ethernet frame to the TAP backend.
For guest RX, the device prepends a virtio-net header before copying
the received Ethernet frame into the guest-provided RX buffer.

4. Implement MMIO_VIRTIONET
Add MMIO routing for virtio-net and connect the device interrupt status
to the PLIC, following the existing virtio-blk and virtio-rng interrupt
update model.

5. Introduce new argument '-x vnet:<tap>'
When virtio-net is enabled, rv32emu dynamically creates a virtio-mmio
node in the generated device tree and assigns an MMIO base address and
IRQ for the device.

6. Support coexistence with virtio-blk and virtio-rng
Update the dynamic virtio-mmio device tree allocation path so
virtio-net can coexist with existing virtio-blk and virtio-rng devices
without reusing MMIO base addresses or IRQs.

7. Use virtio-net state
Unlike semu's device integration model, rv32emu stores the virtio-net
state in vm_attr_t so MMIO routing, interrupt routing, and device
cleanup can access the same device instance.

The emulator should be run with sudo when using the virtio-net TAP
backend.

Co-authored-by: Jim Huang <jserv@biilabs.io>

Author: Charlie-Tsai1123

.ci/test-netdev.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+. "${SCRIPT_DIR}/common.sh"
+
+check_platform
+
+if [[ "${OS_TYPE}" != "Linux" ]]; then
+    print_warning "Skipping virtio-net test on non-Linux host"
+    exit 0
+fi
+
+register_cleanup cleanup_emulator
+
+TIMEOUT=${BOOT_TIMEOUT:-60}
+
+ASSERT expect <<- DONE
+    set timeout ${TIMEOUT}
+    set tap_if ""
+
+    spawn sudo -E build/rv32emu \
+        -k build/linux-image/Image \
+        -i build/linux-image/rootfs.cpio \
+        -x vnet:tap
+
+    expect {
+        -re {allocated TAP interface: (tap[0-9]+)} {
+            set tap_if \$expect_out(1,string)
+            exp_continue
+        }
+        "buildroot login:" {
+            if { "\$tap_if" == "" } {
+                set tap_if [exec sh -c {ip -o link show | awk -F': ' '\$2 ~ /^tap[0-9]+/ {print \$2; exit}'}]
+            }
+
+            exec sudo ip addr replace 192.168.100.1/24 dev \$tap_if
+            exec sudo ip link set \$tap_if up
+
+            send "root\\r"
+        }
+        timeout {
+            exit 1
+        }
+    }
+
+    expect "# "
+    send "readlink /sys/bus/virtio/devices/virtio0/driver\\r"
+    expect {
+        "virtio_net" {}
+        timeout { exit 2 }
+    }
+
+    expect "# "
+    send "ip link set eth0 up\\r"
+
+    expect "# "
+    send "ip addr add 192.168.100.2/24 dev eth0\\r"
+
+    expect "# "
+    send "ip addr show eth0\\r"
+    expect {
+        "192.168.100.2/24" {}
+        timeout { exit 3 }
+    }
+
+    expect "# "
+    send "ping -c 3 -W 5 192.168.100.1\r"
+    expect {
+        -re {3 packets transmitted, 3 packets received|3 packets transmitted, 3 received} {
+            send "\x01"
+            send "x"
+            exit 0
+        }
+        timeout {
+            exit 4
+        }
+DONE
+
+print_success "virtio-net boot test passed"

.github/workflows/main.yml

@@ -444,6 +444,14 @@ jobs:
             fi
             bash -c "${BOOT_LINUX_TEST}"
 
+    - name: virtio-net boot test
+      if: success() && matrix.compiler == 'gcc' && matrix.boot_type == 'interpreter'
+      env:
+        CC: ${{ steps.install_cc.outputs.cc }}
+        BOOT_TIMEOUT: 60
+      run: |
+            .ci/test-netdev.sh
+
   # Native AArch64 on GitHub ARM runners - fast, no QEMU overhead
   host-arm64:
     needs: [detect-code-related-file-changes]

src/devices/netdev.c

@@ -0,0 +1,116 @@
+/*
+ * rv32emu is freely redistributable under the MIT License. See the file
+ * "LICENSE" for information on usage and redistribution of this file.
+ */
+
+#include "netdev.h"
+
+#include <stdbool.h>
+#include <string.h>
+
+#include "utils.h"
+
+#if defined(__linux__) && !defined(__EMSCRIPTEN__)
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/if.h>
+#include <linux/if_tun.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+static int net_init_tap(netdev_t *netdev)
+{
+    net_tap_options_t *tap = (net_tap_options_t *) netdev->op;
+
+    tap->tap_fd = open("/dev/net/tun", O_RDWR);
+    if (tap->tap_fd < 0) {
+        rv_log_error("failed to open TAP device: %s", strerror(errno));
+        return -1;
+    }
+
+    struct ifreq ifreq = {
+        .ifr_flags = IFF_TAP | IFF_NO_PI,
+    };
+
+    strncpy(ifreq.ifr_name, "tap%d", sizeof(ifreq.ifr_name) - 1);
+
+    if (ioctl(tap->tap_fd, TUNSETIFF, &ifreq) < 0) {
+        rv_log_error("failed to allocate TAP device: %s", strerror(errno));
+        close(tap->tap_fd);
+        tap->tap_fd = -1;
+        return -1;
+    }
+
+    rv_log_info("allocated TAP interface: %s", ifreq.ifr_name);
+
+    if (fcntl(tap->tap_fd, F_SETFL,
+              fcntl(tap->tap_fd, F_GETFL, 0) | O_NONBLOCK) < 0) {
+        rv_log_error("failed to set TAP non-blocking mode: %s",
+                     strerror(errno));
+        close(tap->tap_fd);
+        tap->tap_fd = -1;
+        return -1;
+    }
+
+    return 0;
+}
+
+bool netdev_init(netdev_t *netdev, const char *net_type)
+{
+    if (!netdev || !net_type || strcmp(net_type, "tap"))
+        return false;
+
+    netdev->name = (char *) net_type;
+    netdev->type = NETDEV_IMPL_tap;
+    netdev->op = calloc(1, sizeof(net_tap_options_t));
+    if (!netdev->op)
+        return false;
+
+    if (net_init_tap(netdev) < 0) {
+        free(netdev->op);
+        netdev->op = NULL;
+        return false;
+    }
+
+    return true;
+}
+
+void netdev_delete(netdev_t *netdev)
+{
+    if (!netdev || !netdev->op)
+        return;
+
+    switch (netdev->type) {
+    case NETDEV_IMPL_tap: {
+        net_tap_options_t *tap = (net_tap_options_t *) netdev->op;
+        if (tap->tap_fd >= 0)
+            close(tap->tap_fd);
+        break;
+    }
+    default:
+        break;
+    }
+
+    free(netdev->op);
+    netdev->op = NULL;
+}
+
+#else
+
+bool netdev_init(netdev_t *netdev, const char *net_type)
+{
+    (void) netdev;
+    (void) net_type;
+
+    rv_log_error("virtio-net TAP backend is only supported on Linux hosts");
+    return false;
+}
+
+void netdev_delete(netdev_t *netdev)
+{
+    (void) netdev;
+}
+
+#endif

src/devices/netdev.h

@@ -0,0 +1,28 @@
+/*
+ * rv32emu is freely redistributable under the MIT License. See the file
+ * "LICENSE" for information on usage and redistribution of this file.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+
+typedef struct netdev netdev_t;
+
+typedef enum {
+    NETDEV_IMPL_tap,
+} netdev_impl_t;
+
+typedef struct {
+    int tap_fd;
+} net_tap_options_t;
+
+struct netdev {
+    char *name;
+    netdev_impl_t type;
+    void *op;
+};
+
+bool netdev_init(netdev_t *netdev, const char *net_type);
+
+void netdev_delete(netdev_t *netdev);