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.

This implementation is based on semu's virtio-net device, originally
introduced by Jserv.

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

Author: Charlie-Tsai1123

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);