wip: successfully running more than 1 container

fgr-17 · fgr-17 · commit 842a5cc5af51 · 2025-11-08T20:34:02.000Z
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -63,5 +63,6 @@ process_wasm_binaries()
 if(TARGET_PLATFORM_NAME STREQUAL "Linux")
     include(${CMAKE_CURRENT_LIST_DIR}/src/shared/platform/posix/ocre_internal.cmake)
 elseif(TARGET_PLATFORM_NAME STREQUAL "Zephyr")
+    include_directories(${CMAKE_CURRENT_BINARY_DIR})
     include(${CMAKE_CURRENT_LIST_DIR}/src/shared/platform/zephyr/ocre_internal.cmake)
 endif()
diff --git a/cmake/embed_wasm_binary.cmake b/cmake/embed_wasm_binary.cmake
@@ -90,20 +90,21 @@ function(embed_wasm_binary)
 
     message(STATUS "Detected architecture: ${ARCH_NAME}, using objcopy format: ${OBJCOPY_FORMAT}")
 
-    # Convert WASM to object file (use symbol name for unique files)
-    set(WASM_OBJECT_FILE ${CMAKE_CURRENT_BINARY_DIR}/wasm_${WASM_SYMBOL_NAME}.o)
-
-    add_custom_command(
-        OUTPUT ${WASM_OBJECT_FILE}
-        COMMAND objcopy
-            -I binary
-            -O ${OBJCOPY_FORMAT}
-            --rename-section .data=.rodata.wasm,alloc,load,readonly,data,contents
-            ${WASM_STAGED_FILE}
-            ${WASM_OBJECT_FILE}
-        DEPENDS ${WASM_STAGED_FILE}
-        COMMENT "Converting to object file (${OBJCOPY_FORMAT} for ${ARCH_NAME})"
-    )
+       # Convert WASM to object file (use symbol name for unique files)
+       set(WASM_OBJECT_FILE ${CMAKE_CURRENT_BINARY_DIR}/wasm_${WASM_SYMBOL_NAME}.o)
+
+       add_custom_command(
+           OUTPUT ${WASM_OBJECT_FILE}
+           COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_CURRENT_BINARY_DIR}
+               objcopy
+               -I binary
+               -O ${OBJCOPY_FORMAT}
+               --rename-section .data=.rodata.wasm.${WASM_SYMBOL_NAME},alloc,load,readonly,data,contents
+               ${WASM_OUTPUT_NAME}
+               wasm_${WASM_SYMBOL_NAME}.o
+           DEPENDS ${WASM_STAGED_FILE}
+           COMMENT "Converting to object file (${OBJCOPY_FORMAT} for ${ARCH_NAME})"
+       )
 
     # Create a custom target
     add_custom_target(${WASM_TARGET_NAME} DEPENDS ${WASM_OBJECT_FILE})
diff --git a/src/ocre/wasm_manifest.h.in b/src/ocre/wasm_manifest.h.in
@@ -15,17 +15,23 @@
 typedef struct {
     const char *name;        // Container name
     const uint8_t *data;     // Pointer to WASM binary
-    size_t size;             // Size in bytes
 } wasm_binary_entry_t;
 
 // Number of embedded WASM binaries
 #define WASM_BINARY_COUNT @COUNT@
 
-// Manifest array
+// Manifest array (size calculated on access, not at initialization)
 static const wasm_binary_entry_t wasm_manifest[WASM_BINARY_COUNT] = {
 @MANIFEST_ENTRIES@
 };
 
+// Helper function to get size (calculated at runtime)
+static inline size_t wasm_get_size(int index) {
+    if (index < 0 || index >= WASM_BINARY_COUNT) return 0;
+@SIZE_CALCULATIONS@
+    return 0;
+}
+
 // Helper function to find a WASM binary by name
 static inline const wasm_binary_entry_t* wasm_find(const char *name) {
     if (!name) return NULL;
@@ -37,9 +43,10 @@ static inline const wasm_binary_entry_t* wasm_find(const char *name) {
     return NULL;
 }
 
-// Helper function to get WASM binary by index
+// Helper function to get WASM binary by index (with runtime size calculation)
 static inline const wasm_binary_entry_t* wasm_get(int index) {
     if (index < 0 || index >= WASM_BINARY_COUNT) return NULL;
+    // Note: size field is 0 in static array, use wasm_get_size() to get actual size
     return &wasm_manifest[index];
 }
 
diff --git a/src/samples-mini/zephyr/main.c b/src/samples-mini/zephyr/main.c
@@ -5,106 +5,146 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#include <zephyr/kernel.h>
-#include <zephyr/fs/fs.h>
-#include "ocre_core_external.h"
-#include <zephyr/net/net_if.h>
-#include <zephyr/net/dhcpv4.h>
-
-#include <ocre/ocre.h>
-#include <ocre/ocre_container_runtime/ocre_container_runtime.h>
-
-#ifdef HAS_GENERATED_INPUT
-#include <ocre/ocre_input_file.g>
-#else
-#include <ocre/ocre_input_file.h>
-#endif
-
-void create_sample_container();
-int ocre_network_init();
-
-int main(int argc, char *argv[]) {
-    ocre_cs_ctx ctx;
-    ocre_container_init_arguments_t args;
-    char *container_filename = "hello";
-
-#ifdef CONFIG_OCRE_NETWORKING
-    int net_status = ocre_network_init();
-    if (net_status < 0) {
-        printf("Unable to connect to network\n");
-    } else {
-        printf("Network is UP\n");
-    }
-#endif
-
-    ocre_app_storage_init();
-
-    // Step 1:  Initialize the Ocre runtime
-    ocre_container_runtime_status_t ret = ocre_container_runtime_init(&ctx, &args);
-
-    if (ret == RUNTIME_STATUS_INITIALIZED) {
-        printf("\n\nOcre runtime started\n");
-
-        create_sample_container(container_filename);
-
-        // Step 2:  Create the container, this allocates and loads the container binary
-        ocre_container_data_t ocre_container_data;
-        int container_ID;
-
-        ocre_container_data.heap_size = 0;
-        snprintf(ocre_container_data.name, sizeof(ocre_container_data.name), "Hello World");
-        snprintf(ocre_container_data.sha256, sizeof(ocre_container_data.sha256), "%s", container_filename);
-        ocre_container_data.timers = 0;
-        ocre_container_runtime_create_container(&ctx, &ocre_container_data, &container_ID, NULL);
-
-        // Step 3:  Execute the container
-        ocre_container_runtime_run_container(container_ID, NULL);
-        // Loop forever, without this the application will exit and stop all execution
-        while (true) {
-            core_sleep_ms(1000);
+ #include <zephyr/kernel.h>
+ #include <zephyr/fs/fs.h>
+ #include "ocre_core_external.h"
+ #include <zephyr/net/net_if.h>
+ #include <zephyr/net/dhcpv4.h>
+
+ #include <ocre/ocre.h>
+ #include <ocre/ocre_container_runtime/ocre_container_runtime.h>
+
+ #ifdef HAS_WASM_MANIFEST
+ #include "wasm_manifest.h"
+ #endif
+
+ void create_containers_from_manifest(ocre_cs_ctx *ctx);
+ int ocre_network_init();
+
+ int main(int argc, char *argv[]) {
+     ocre_cs_ctx ctx;
+     ocre_container_init_arguments_t args;
+
+ #ifdef CONFIG_OCRE_NETWORKING
+     int net_status = ocre_network_init();
+     if (net_status < 0) {
+         printf("Unable to connect to network\n");
+     } else {
+         printf("Network is UP\n");
+     }
+ #endif
+
+     ocre_app_storage_init();
+
+     // Step 1: Initialize the Ocre runtime
+     ocre_container_runtime_status_t ret = ocre_container_runtime_init(&ctx, &args);
+
+     if (ret == RUNTIME_STATUS_INITIALIZED) {
+         printf("\n\nOcre runtime started\n");
+
+ #ifdef HAS_WASM_MANIFEST
+         // Create and run all containers from manifest
+         printf("Found %d WASM binaries to load\n", WASM_BINARY_COUNT);
+         create_containers_from_manifest(&ctx);
+ #else
+         printf("ERROR: No WASM binaries provided. Build with -f option.\n");
+ #endif
+
+         // Loop forever, without this the application will exit and stop all execution
+         while (true) {
+             core_sleep_ms(1000);
+         }
+
+     } else {
+         printf("\n\nOcre runtime failed to start.\n");
+     }
+ }
+
+ #ifdef HAS_WASM_MANIFEST
+ /**
+  * Create and run all containers from the embedded WASM manifest
+  */
+  void create_containers_from_manifest(ocre_cs_ctx *ctx) {
+    int container_IDs[WASM_BINARY_COUNT];
+
+    // Step 1: Write all WASM binaries to filesystem
+    for (int i = 0; i < WASM_BINARY_COUNT; i++) {
+        const wasm_binary_entry_t *entry = wasm_get(i);
+        size_t actual_size = wasm_get_size(i);  // ← Use the helper function!
+
+        printf("Loading WASM: %s (%zu bytes) from flash\n", entry->name, actual_size);
+
+        // Write to filesystem
+        char file_path[64];
+        struct fs_file_t f;
+        snprintf(file_path, sizeof(file_path), "/lfs/ocre/images/%s.bin", entry->name);
+
+        fs_file_t_init(&f);
+        int res = fs_open(&f, file_path, FS_O_CREATE | FS_O_RDWR);
+        if (res < 0) {
+            printf("  ERROR: Failed to create file: %d\n", res);
+            continue;
         }
 
-    } else {
-        printf("\n\nOcre runtime failed to start.\n");
+        fs_write(&f, entry->data, actual_size);  // ← Use actual_size
+        fs_close(&f);
+        printf("  Written to: %s\n", file_path);
     }
-}
 
-/**
- * Creates a container image file using the sample "hello-word" WASM module
- * This is for demostration purposes only and does not perform any error checking.
- *
- * @param file_name a string containing the name of the file to create
- */
+    // Step 2: Create all containers
+    for (int i = 0; i < WASM_BINARY_COUNT; i++) {
+        const wasm_binary_entry_t *entry = wasm_get(i);
+
+        ocre_container_data_t container_data;
+        container_data.heap_size = 0;
+        snprintf(container_data.name, sizeof(container_data.name), "%s", entry->name);
+        snprintf(container_data.sha256, sizeof(container_data.sha256), "%s", entry->name);
+        container_data.timers = 0;
+
+        ocre_container_status_t status = ocre_container_runtime_create_container(ctx, &container_data,
+                                                                                  &container_IDs[i], NULL);
+        // Check for CREATED status, not 0!
+        if (status == CONTAINER_STATUS_CREATED) {
+            printf("Container requested: %s (ID: %d)\n", entry->name, container_IDs[i]);
+            core_sleep_ms(100);
+        } else {
+            printf("ERROR: Failed to request container %s: %d\n", entry->name, status);
+            container_IDs[i] = -1;
+        }
+    }
 
-void create_sample_container(char *file_name) {
-    static char file_path[64];
-    struct fs_file_t f;
-    snprintf((char *)&file_path, 64, "/lfs/ocre/images/%s.bin", file_name);
-    int res;
+    // Give containers time to actually be created asynchronously
+    printf("Waiting for containers to be created...\n");
+    core_sleep_ms(500);  // Wait for async creation to complete
 
-    fs_file_t_init(&f);
-    res = fs_open(&f, file_path, FS_O_CREATE | FS_O_RDWR);
+    // Run all containers
+    for (int i = 0; i < WASM_BINARY_COUNT; i++) {
+        if (container_IDs[i] >= 0) {
+            const wasm_binary_entry_t *entry = wasm_get(i);
+            printf("Starting container: %s\n", entry->name);
+            ocre_container_runtime_run_container(container_IDs[i], NULL);
+        }
+    }
 
-    fs_write(&f, &wasm_binary, wasm_binary_len);
-    fs_close(&f);
+    printf("All containers started!\n");
 }
+ #endif
 
-int ocre_network_init() {
+ int ocre_network_init() {
+     struct net_if *iface = net_if_get_default();
+     net_dhcpv4_start(iface);
 
-    struct net_if *iface = net_if_get_default();
-    net_dhcpv4_start(iface);
+     printf("Waiting for network to be ready...\n");
 
-    printf("Waiting for network to be ready...\n");
+     int sleep_cnt = 0;
+     while (!net_if_is_up(iface) && (sleep_cnt < 10)) {
+         k_sleep(K_MSEC(200));
+         sleep_cnt++;
+     }
 
-    int sleep_cnt = 0;
-    while (!net_if_is_up(iface) && (sleep_cnt < 10)) {
-        k_sleep(K_MSEC(200));
-        sleep_cnt++;
-    }
+     if (!net_if_is_up(iface)) {
+         return -ENOTCONN;
+     }
 
-    if (!net_if_is_up(iface)) {
-        return -ENOTCONN;
-    }
-
-    return 0;
-}
+     return 0;
+ }
diff --git a/src/shared/platform/zephyr/ocre_internal.cmake b/src/shared/platform/zephyr/ocre_internal.cmake
@@ -119,8 +119,21 @@ target_sources(app PRIVATE
 
 add_dependencies(app generate_messages)
 
-if(NOT "${OCRE_INPUT_FILE}" STREQUAL "")
-    add_dependencies(app generate_ocre_file)
-    # Add the WASM object file to the app sources
-    target_sources(app PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/wasm_binary.o)
+message(STATUS "DEBUG: WASM_MANIFEST_ENTRIES = '${WASM_MANIFEST_ENTRIES}'")
+message(STATUS "DEBUG: CMAKE_CURRENT_BINARY_DIR = '${CMAKE_CURRENT_BINARY_DIR}'")
+
+# Link WASM object files if manifest was generated
+if(DEFINED WASM_MANIFEST_ENTRIES AND WASM_MANIFEST_ENTRIES)
+    message(STATUS "Linking WASM object files: ${WASM_MANIFEST_ENTRIES}")
+
+    foreach(WASM_NAME ${WASM_MANIFEST_ENTRIES})
+        set(WASM_OBJ ${CMAKE_CURRENT_BINARY_DIR}/wasm_${WASM_NAME}.o)
+
+        # Don't check if EXISTS - files are generated at build time!
+        target_sources(app PRIVATE ${WASM_OBJ})
+        add_dependencies(app generate_${WASM_NAME}_wasm)
+        message(STATUS "  → Will link: ${WASM_OBJ}")
+    endforeach()
+else()
+    message(WARNING "No WASM_MANIFEST_ENTRIES defined!")
 endif()
diff --git a/tools/generate_wasm_manifest.py b/tools/generate_wasm_manifest.py
@@ -21,18 +21,25 @@ def generate_extern_declarations(wasm_names):
     return "\n".join(declarations)
 
 def generate_manifest_entries(wasm_names):
-    """Generate manifest array entries"""
+    """Generate manifest array entries WITHOUT size field"""
     entries = []
     for name in wasm_names:
         safe_name = sanitize_name(name)
         entry = f"""    {{
         .name = "{name}",
-        .data = _binary_{safe_name}_wasm_start,
-        .size = (size_t)(_binary_{safe_name}_wasm_end - _binary_{safe_name}_wasm_start)
+        .data = _binary_{safe_name}_wasm_start
     }}"""
         entries.append(entry)
     return ",\n".join(entries)
 
+def generate_size_calculations(wasm_names):
+    """Generate size calculation switch statement"""
+    cases = []
+    for i, name in enumerate(wasm_names):
+        safe_name = sanitize_name(name)
+        cases.append(f"    if (index == {i}) return (size_t)(_binary_{safe_name}_wasm_end - _binary_{safe_name}_wasm_start);")
+    return "\n".join(cases)
+
 def main():
     parser = argparse.ArgumentParser(description='Generate WASM manifest header from template')
     parser.add_argument('names', nargs='+', help='WASM container names')
@@ -52,11 +59,13 @@ def main():
     # Generate content pieces
     extern_decls = generate_extern_declarations(args.names)
     manifest_entries = generate_manifest_entries(args.names)
+    size_calculations = generate_size_calculations(args.names)
 
     # Replace placeholders
     content = template.replace('@EXTERN_DECLARATIONS@', extern_decls)
     content = content.replace('@COUNT@', str(len(args.names)))
     content = content.replace('@MANIFEST_ENTRIES@', manifest_entries)
+    content = content.replace('@SIZE_CALCULATIONS@', size_calculations)
 
     # Write output
     output_path = Path(args.output)
