Make virtio-net backends configurable

Add Kconfig options for the virtio-net device, Linux TAP backend,
and user-mode SLIRP backend.

Exclude unused network objects at build time, build minislirp only
when the user backend is enabled, and guard the related CLI, runtime,
MMIO, DTB, and interrupt integration.

Also list only compiled backends in the CLI help and consolidate
backend initialization through a shared helper (netdev_setup in
src/devices/netdev.c).

Author: Charlie-Tsai1123

Makefile

@@ -58,6 +58,7 @@ deps :=
 # Feature Flags (Kconfig -> RV32_FEATURE_*)
 $(call set-features, ELF_LOADER MOP_FUSION BLOCK_CHAINING LOG_COLOR)
 $(call set-features, SYSTEM GOLDFISH_RTC ARCH_TEST)
+$(call set-features, VIRTIO_NET VIRTIO_NET_TAP VIRTIO_NET_USER)
 $(call set-features, EXT_M EXT_A EXT_F EXT_C EXT_V RV32E)
 $(call set-features, Zicsr Zifencei Zba Zbb Zbc Zbs)
 $(call set-features, SDL SDL_MIXER GDBSTUB JIT)
@@ -222,13 +223,35 @@ $(OUT)/emulate.o: CFLAGS += -foptimize-sibling-calls -fomit-frame-pointer -fno-s
 # HTTP Utilities (shared by external.mk and artifact.mk)
 include mk/http.mk
 
+# VirtIO networking is available only for kernel system emulation and requires
+# at least one host backend. CONFIG_* values may be overridden by legacy
+# ENABLE_* flags after loading .config, so derive the effective build state here
+# instead of relying only on the Kconfig dependency graph.
+VIRTIO_NET_BUILD_ENABLED := n
+ifeq ($(CONFIG_SYSTEM),y)
+ifneq ($(CONFIG_ELF_LOADER),y)
+ifeq ($(CONFIG_VIRTIO_NET),y)
+ifneq ($(filter y,$(CONFIG_VIRTIO_NET_TAP) $(CONFIG_VIRTIO_NET_USER)),)
+VIRTIO_NET_BUILD_ENABLED := y
+endif
+endif
+endif
+endif
+
+VIRTIO_NET_USER_BUILD_ENABLED := n
+ifeq ($(VIRTIO_NET_BUILD_ENABLED),y)
+ifeq ($(CONFIG_VIRTIO_NET_USER),y)
+VIRTIO_NET_USER_BUILD_ENABLED := y
+endif
+endif
+
 # External Dependencies & System Emulation
 include mk/external.mk
 include mk/artifact.mk
 include mk/system.mk
 include mk/wasm.mk
 
-ifeq ($(CONFIG_SYSTEM),y)
+ifeq ($(VIRTIO_NET_USER_BUILD_ENABLED),y)
 ifneq ($(CC_IS_EMCC),1)
 MINISLIRP_DIR := src/minislirp
 MINISLIRP_LIB := $(MINISLIRP_DIR)/src/libslirp.a
@@ -248,6 +271,7 @@ $(MINISLIRP_DIR)/src/Makefile:
 $(MINISLIRP_LIB): $(MINISLIRP_DIR)/src/Makefile
 	$(Q)$(MAKE) -C $(dir $<) CC="$(CC)" $(MINISLIRP_CFLAGS)
 
+$(OUT)/devices/slirp.o: $(MINISLIRP_LIB)
 $(BIN): $(MINISLIRP_LIB)
 endif
 endif
@@ -271,6 +295,7 @@ deps += $(OBJS:%.o=%.o.d)
 EFFECTIVE_CONFIG_STAMP := $(OUT)/.effective-config
 EFFECTIVE_CONFIG_VARS := \
 	CONFIG_BUILD_WASM CONFIG_SYSTEM CONFIG_GOLDFISH_RTC CONFIG_ELF_LOADER \
+	CONFIG_VIRTIO_NET CONFIG_VIRTIO_NET_TAP CONFIG_VIRTIO_NET_USER \
 	CONFIG_EXT_M CONFIG_EXT_A CONFIG_EXT_F CONFIG_EXT_C CONFIG_EXT_V CONFIG_RV32E \
 	CONFIG_Zicsr CONFIG_Zifencei CONFIG_Zba CONFIG_Zbb CONFIG_Zbc CONFIG_Zbs \
 	CONFIG_MOP_FUSION CONFIG_BLOCK_CHAINING CONFIG_LOG_COLOR CONFIG_ARCH_TEST \

configs/Kconfig

@@ -99,6 +99,13 @@ config HAVE_RISCV_TOOLCHAIN
     bool
     default $(python,assert run(sys.executable, 'tools/detect-env.py', '--have-riscv-toolchain'))
 
+# Host platform detection used by platform-specific system devices.
+config HOST_LINUX
+    def_bool $(python,assert sys.platform.startswith('linux'))
+
+config HOST_MACOS
+    def_bool $(python,assert sys.platform == 'darwin')
+
 # RISC-V ISA Extensions
 
 menu "RISC-V ISA Configuration"
@@ -282,6 +289,37 @@ config ELF_LOADER
       Enable this for running 'make check' tests in system mode.
       Disable this for booting Linux kernel images.
 
+config VIRTIO_NET
+    bool "Enable VirtIO network device"
+    default y
+    depends on SYSTEM && !ELF_LOADER && !CC_IS_EMCC
+    depends on HOST_LINUX || HOST_MACOS
+    help
+      Enable VirtIO network device emulation.
+
+      Disable this option to exclude virtio-net, its host backends,
+      and their dependencies from the rv32emu executable.
+
+config VIRTIO_NET_TAP
+    bool "Enable Linux TAP backend"
+    default y
+    depends on VIRTIO_NET && HOST_LINUX
+    help
+      Enable the Linux TAP backend for VirtIO networking.
+
+      This backend uses /dev/net/tun and normally requires root
+      privileges or CAP_NET_ADMIN.
+
+config VIRTIO_NET_USER
+    bool "Enable user-mode SLIRP backend"
+    default y
+    depends on VIRTIO_NET && (HOST_LINUX || HOST_MACOS)
+    help
+      Enable user-mode networking through minislirp.
+
+      This backend does not require a TAP interface or root privileges,
+      but it adds minislirp to the final executable.
+
 endmenu
 
 # Performance Optimizations

configs/system_defconfig

@@ -1,3 +1,6 @@
 # System emulation for Linux kernel
 CONFIG_SYSTEM=y
 CONFIG_GOLDFISH_RTC=y
+CONFIG_VIRTIO_NET=y
+CONFIG_VIRTIO_NET_TAP=y
+CONFIG_VIRTIO_NET_USER=y

mk/system.mk

@@ -52,6 +52,21 @@ $(DEV_OUT)/%.o: $(DEV_SRC)/%.c $(EFFECTIVE_CONFIG_STAMP) | $(DEV_OUT)
 	$(Q)$(CC) -o $@ $(CFLAGS) $(CFLAGS_emcc) -c -MMD -MF $@.d $<
 
 DEV_OBJS := $(patsubst $(DEV_SRC)/%.c, $(DEV_OUT)/%.o, $(wildcard $(DEV_SRC)/*.c))
+# VirtIO networking is optional. Exclude all network-related objects unless
+# kernel system emulation is active and at least one host backend is enabled.
+# The SLIRP object is only needed by the user-mode backend.
+ifneq ($(VIRTIO_NET_BUILD_ENABLED),y)
+DEV_OBJS := $(filter-out \
+    $(DEV_OUT)/virtio-net.o \
+    $(DEV_OUT)/netdev.o \
+    $(DEV_OUT)/slirp.o, \
+    $(DEV_OBJS))
+else
+ifneq ($(VIRTIO_NET_USER_BUILD_ENABLED),y)
+DEV_OBJS := $(filter-out $(DEV_OUT)/slirp.o, $(DEV_OBJS))
+endif
+endif
+
 # Enable Goldfish RTC peripheral
 ifneq ($(CONFIG_GOLDFISH_RTC),y)
 DEV_OBJS := $(filter-out $(DEV_OUT)/rtc.o, $(DEV_OBJS))

src/devices/netdev.c

@@ -19,21 +19,52 @@
 #include <sys/ioctl.h>
 #endif
 
+#if RV32EMU_NET_HAS_TAP || RV32EMU_NET_HAS_SLIRP
+typedef int (*netdev_init_fn_t)(netdev_t *netdev);
+#endif
+
 static void netdev_reset(netdev_t *netdev)
 {
     if (!netdev)
         return;
 
     netdev->name = NULL;
-    netdev->type = NETDEV_IMPL_none;
+    netdev->type = NETDEV_IMPL_NONE;
     netdev->op = NULL;
 }
 
+#if RV32EMU_NET_HAS_TAP || RV32EMU_NET_HAS_SLIRP
+static bool netdev_setup(netdev_t *netdev,
+                         const char *name,
+                         netdev_impl_t type,
+                         size_t options_size,
+                         netdev_init_fn_t init_fn)
+{
+    netdev->name = name;
+    netdev->type = type;
+    netdev->op = calloc(1, options_size);
+
+    if (!netdev->op) {
+        netdev_reset(netdev);
+        return false;
+    }
+
+    if (init_fn(netdev) < 0) {
+        free(netdev->op);
+        netdev_reset(netdev);
+        return false;
+    }
+
+    return true;
+}
+#endif
+
 #if RV32EMU_NET_HAS_TAP
 static int net_init_tap(netdev_t *netdev)
 {
     net_tap_options_t *tap = (net_tap_options_t *) netdev->op;
 
+    tap->tap_fd = -1;
     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));
@@ -84,19 +115,16 @@ static int net_init_user(netdev_t *netdev)
 }
 #endif
 
-#if RV32EMU_NET_HAS_TAP
-static const char *netdev_linux_default(void)
+static const char *netdev_default_backend(void)
 {
+#if RV32EMU_NET_HAS_TAP
     return "tap";
-}
-#endif
-
-#if defined(__APPLE__) && RV32EMU_NET_HAS_SLIRP
-static const char *netdev_macos_default(void)
-{
+#elif RV32EMU_NET_HAS_SLIRP
     return "user";
-}
+#else
+    return NULL;
 #endif
+}
 
 bool netdev_init(netdev_t *netdev, const char *net_type)
 {
@@ -105,73 +133,28 @@ bool netdev_init(netdev_t *netdev, const char *net_type)
 
     netdev_reset(netdev);
 
-#if defined(__APPLE__) && RV32EMU_NET_HAS_SLIRP
-    const char *requested = net_type ? net_type : netdev_macos_default();
-
-    if (!strcmp(requested, "user")) {
-        netdev->name = "user";
-        netdev->type = NETDEV_IMPL_user;
-        netdev->op = calloc(1, sizeof(net_user_options_t));
-        if (!netdev->op)
-            return false;
-
-        if (net_init_user(netdev) < 0) {
-            free(netdev->op);
-            netdev->op = NULL;
-            return false;
-        }
-
-        return true;
+    const char *requested = net_type ? net_type : netdev_default_backend();
+    if (!requested) {
+        rv_log_error("no virtio-net backend was compiled");
+        return false;
     }
 
-    rv_log_error("unsupported virtio-net backend on macOS: %s", requested);
-    return false;
-
-#elif RV32EMU_NET_HAS_TAP
-    const char *requested = net_type ? net_type : netdev_linux_default();
-
+#if RV32EMU_NET_HAS_TAP
     if (!strcmp(requested, "tap")) {
-        netdev->name = "tap";
-        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;
+        return netdev_setup(netdev, "tap", NETDEV_IMPL_TAP,
+                            sizeof(net_tap_options_t), net_init_tap);
     }
+#endif
 
 #if RV32EMU_NET_HAS_SLIRP
     if (!strcmp(requested, "user")) {
-        netdev->name = "user";
-        netdev->type = NETDEV_IMPL_user;
-        netdev->op = calloc(1, sizeof(net_user_options_t));
-        if (!netdev->op)
-            return false;
-
-        if (net_init_user(netdev) < 0) {
-            free(netdev->op);
-            netdev->op = NULL;
-            return false;
-        }
-
-        return true;
+        return netdev_setup(netdev, "user", NETDEV_IMPL_USER,
+                            sizeof(net_user_options_t), net_init_user);
     }
 #endif
 
-    rv_log_error("unsupported virtio-net backend on Linux: %s", requested);
+    rv_log_error("unsupported virtio-net backend: %s", requested);
     return false;
-
-#else
-    (void) net_type;
-    rv_log_error("virtio-net networking is disabled on this host");
-    return false;
-#endif
 }
 
 void netdev_delete(netdev_t *netdev)
@@ -181,7 +164,7 @@ void netdev_delete(netdev_t *netdev)
 
     switch (netdev->type) {
 #if RV32EMU_NET_HAS_TAP
-    case NETDEV_IMPL_tap: {
+    case NETDEV_IMPL_TAP: {
         net_tap_options_t *tap = (net_tap_options_t *) netdev->op;
         if (tap->tap_fd >= 0)
             close(tap->tap_fd);
@@ -190,11 +173,12 @@ void netdev_delete(netdev_t *netdev)
 #endif
 
 #if RV32EMU_NET_HAS_SLIRP
-    case NETDEV_IMPL_user:
+    case NETDEV_IMPL_USER:
         net_slirp_cleanup((net_user_options_t *) netdev->op);
         break;
 #endif
 
+    case NETDEV_IMPL_NONE:
     default:
         break;
     }

src/devices/netdev.h

@@ -11,6 +11,8 @@
 #include <sys/types.h>
 #include <sys/uio.h>
 
+#include "feature.h"
+
 /*
  * Networking backends:
  *
@@ -22,18 +24,15 @@
  *   - user : user-mode SLIRP
  *
  * Emscripten:
- * * Networking backends:
- *
- *
  *   - virtio-net networking backends are disabled
  */
-#if defined(__linux__) && !defined(__EMSCRIPTEN__)
+#if RV32_HAS(VIRTIO_NET_TAP) && defined(__linux__) && !defined(__EMSCRIPTEN__)
 #define RV32EMU_NET_HAS_TAP 1
 #else
 #define RV32EMU_NET_HAS_TAP 0
 #endif
 
-#if !defined(__EMSCRIPTEN__)
+#if RV32_HAS(VIRTIO_NET_USER) && !defined(__EMSCRIPTEN__)
 #define RV32EMU_NET_HAS_SLIRP 1
 #else
 #define RV32EMU_NET_HAS_SLIRP 0
@@ -44,12 +43,12 @@
 typedef struct netdev netdev_t;
 
 typedef enum {
-    NETDEV_IMPL_none = 0,
+    NETDEV_IMPL_NONE = 0,
 #if RV32EMU_NET_HAS_TAP
-    NETDEV_IMPL_tap,
+    NETDEV_IMPL_TAP,
 #endif
 #if RV32EMU_NET_HAS_SLIRP
-    NETDEV_IMPL_user,
+    NETDEV_IMPL_USER,
 #endif
 } netdev_impl_t;