init: preload networking modules for Ubuntu support

On Ubuntu, hv_netvsc, hv_sock, bridge, and other networking modules are
loadable (=m) rather than built-in (=y). The existing ftw()-based
load_all_modules() may not resolve them reliably by path alone.

Add preload_networking_modules() to load critical modules by name before
the general module scan. Also enable KMOD=1 in the default Makefile and
improve module load logging with structured messages.

Without hv_netvsc: hot-added NICs timeout waiting for sysfs net interface.
Without hv_sock: vsock-based entropy and GCS communication fail.

Signed-off-by: Jie Chen <jiechen3@microsoft.com>

Author: jiechen0826

Makefile

@@ -3,7 +3,7 @@ include Makefile.bootfiles
 # C settings
 
 # enable loading kernel modules in init
-KMOD:=0
+KMOD:=1
 
 CFLAGS:=-O2 -Wall
 LDFLAGS:=-static -s #strip C binaries

init/init.c

@@ -366,6 +366,51 @@ void init_network(const char* iface, int domain) {
     close(s);
 }
 
+// Preload networking modules that may not be built-in on all distros (e.g., Ubuntu).
+// On kernels where these are built-in (=y), the probe call is a harmless no-op.
+// Must only be called when MODULES is defined (caller is responsible for the guard).
+void preload_networking_modules() {
+    const char* modules[] = {
+        "hv_netvsc",     // Hyper-V network driver
+        "hv_sock",       // Hyper-V vsocket support
+        "bridge",        // Linux bridge support
+        "veth",          // Virtual ethernet pairs
+        "nf_conntrack",  // Connection tracking for NAT/masquerading
+        "br_netfilter",  // Bridge netfilter for iptables
+        NULL
+    };
+
+    if (k_ctx == NULL) {
+        k_ctx = kmod_new(NULL, NULL);
+        if (k_ctx == NULL) {
+            dmesgWarn("preload_networking_modules: failed to create kmod context\n");
+            return;
+        }
+    }
+
+    kmod_load_resources(k_ctx);
+
+    for (int i = 0; modules[i] != NULL; i++) {
+        struct kmod_module* mod = NULL;
+        int err = kmod_module_new_from_name(k_ctx, modules[i], &mod);
+        if (err < 0)
+            continue;
+
+        err = kmod_module_probe_insert_module(mod, KMOD_PROBE_IGNORE_LOADED, NULL, NULL, NULL, NULL);
+        char msg[256];
+        const char* status = (err == 0 || err == -EEXIST) ? "ok"
+                           : (err == -ENOENT)             ? "not found (may be built-in)"
+                                                          : "failed";
+        snprintf(msg, sizeof(msg), "preload module %s: %s (err=%d)\n", modules[i], status, err);
+        if (err == 0 || err == -EEXIST || err == -ENOENT)
+            dmesgInfo(msg);
+        else
+            dmesgWarn(msg);
+
+        kmod_module_unref(mod);
+    }
+}
+
 // inject boot-time entropy after reading it from a vsock port
 void init_entropy(int port) {
     int s = openvsock(VMADDR_CID_HOST, port);
@@ -507,7 +552,8 @@ int load_module(struct kmod_ctx* ctx, const char* module_path) {
         return err;
     }
 
-    err = kmod_module_probe_insert_module(mod, 0, NULL, NULL, NULL, NULL);
+    // Use probe_insert_module for automatic dependency resolution
+    err = kmod_module_probe_insert_module(mod, KMOD_PROBE_APPLY_BLACKLIST | KMOD_PROBE_IGNORE_LOADED, NULL, NULL, NULL, NULL);
     if (err < 0) {
         kmod_module_unref(mod);
         return err;
@@ -549,10 +595,14 @@ int parse_tree_entry(const char* fpath, const struct stat* sb, int typeflag) {
     // print warning if we fail to load the module, but don't fail fn so
     // we keep trying to load the rest of the modules.
     result = load_module(k_ctx, fpath);
+    char msg[512];
     if (result != 0) {
-        warn2("failed to load module", fpath);
+        snprintf(msg, sizeof(msg), "failed to load module %s (error %d)\n", fpath, result);
+        dmesgWarn(msg);
+    } else {
+        snprintf(msg, sizeof(msg), "loaded module: %s\n", fpath);
+        dmesgInfo(msg);
     }
-    dmesgInfo(fpath);
     return 0;
 }
 
@@ -777,12 +827,21 @@ int main(int argc, char** argv) {
     init_network("lo", AF_INET6);
 
 #ifdef MODULES
+    // Preload networking modules by name before the general ftw()-based scan.
+    // On Ubuntu, hv_netvsc and hv_sock are loadable (=m) not built-in (=y),
+    // and load_all_modules() may not resolve them reliably by path alone.
+    // Without hv_netvsc: hot-added NICs timeout. Without hv_sock: vsock fails.
+    preload_networking_modules();
+
 #ifdef DEBUG
     printf("loading modules\n");
 #endif
     load_all_modules();
 #endif
 
+    // Initialize entropy after module loading: on distros where hv_sock is a
+    // loadable module (e.g., Ubuntu), the vsock transport used by init_entropy
+    // is not available until the module is loaded above.
     if (entropy_port != 0) {
         init_entropy(entropy_port);
     }