Enhance dmdevfs module: add driver configuration and error handling in initialization

Author: JohnAmadis

CMakeLists.txt

@@ -15,6 +15,7 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 if(NOT DEFINED DMOD_MODULE_VERSION)
     set(DMOD_MODULE_VERSION "0.1" CACHE STRING "DMOD module version")
 endif()
+set(DMOD_MODE "DMOD_MODULE" CACHE STRING "DMOD build mode")
 
 # ======================================================================
 #               Fetch DMOD repository
@@ -78,8 +79,11 @@ dmod_add_library(${DMOD_MODULE_NAME} ${DMOD_MODULE_VERSION}
 # Link to other DMOD modules (will be downloaded on build time)
 dmod_link_modules(${DMOD_MODULE_NAME}
     dmfsi
+    dmdrvi
+    dmini
+    dmlist
 )
 
 target_include_directories(${DMOD_MODULE_NAME} PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/include
-)
+)

src/dmdevfs.c

@@ -12,22 +12,45 @@
 #include "dmod.h"
 #include "dmdevfs.h"
 #include "dmfsi.h"
+#include "dmlist.h"
+#include "dmini.h"
+#include "dmdrvi.h"
 #include <string.h>
 
 /** 
  * @brief Magic number for DMDEVFS context validation
  */
 #define DMDEVFS_CONTEXT_MAGIC 0x444D4456  // 'DMDV'
 
+typedef struct 
+{
+    dmdrvi_context_t driver_context;    // Driver-specific context
+    Dmod_Context_t*  driver;            // Driver module context
+    dmdrvi_dev_num_t dev_num;           // Device number assigned to the driver
+} driver_node_t;
+
 /**
  * @brief File system context structure
  */
 struct dmfsi_context
 {
-    uint32_t magic;
-    void*    driver_context;  // Driver-specific context
+    uint32_t    magic;
+    const char* config_path;     // Path with the configuration files
+    dmlist_context_t* drivers;      // List of loaded drivers
 };
 
+
+// ============================================================================
+//                      Local prototypes
+// ============================================================================
+static int configure_drivers(dmfsi_context_t ctx, const char* driver_name, const char* config_path);
+static driver_node_t* configure_driver(const char* driver_name, dmini_context_t config_ctx);
+static bool is_file(const char* path);
+static void read_base_name(const char* path, char* base_name, size_t name_size);
+static dmini_context_t read_driver_for_config(const char* config_path, char* driver_name, size_t name_size, const char* default_driver);
+static Dmod_Context_t* prepare_driver_module(const char* driver_name, bool* was_loaded, bool* was_enabled);
+static void cleanup_driver_module(const char* driver_name, bool was_loaded, bool was_enabled);
+
 // ============================================================================
 //                      Module Interface Implementation
 // ============================================================================
@@ -67,6 +90,18 @@ int dmod_deinit(void)
  */
 dmod_dmfsi_dif_api_declaration( 1.0, dmdevfs, dmfsi_context_t, _init, (const char* config) )
 {
+    if(config == NULL)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Config path is NULL\n");
+        return NULL;
+    }
+
+    if(strlen(config) == 0)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Config path is empty\n");
+        return NULL;
+    }
+
     dmfsi_context_t ctx = Dmod_Malloc(sizeof(struct dmfsi_context));
     if (ctx == NULL)
     {
@@ -75,9 +110,18 @@ dmod_dmfsi_dif_api_declaration( 1.0, dmdevfs, dmfsi_context_t, _init, (const cha
     }
 
     ctx->magic = DMDEVFS_CONTEXT_MAGIC;
-    ctx->driver_context = NULL;
+    ctx->config_path = Dmod_StrDup(config);
+    ctx->drivers = dmlist_create(DMOD_MODULE_NAME);
 
-    // TODO: Initialize driver context based on config
+    int res = configure_drivers(ctx, NULL, ctx->config_path);
+    if (res != DMFSI_OK)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Failed to configure drivers\n");
+        dmlist_destroy(ctx->drivers);
+        Dmod_Free((void*)ctx->config_path);
+        Dmod_Free(ctx);
+        return NULL;
+    }
 
     return ctx;
 }
@@ -406,3 +450,203 @@ dmod_dmfsi_dif_api_declaration( 1.0, dmdevfs, int, _rename, (dmfsi_context_t ctx
     // TODO: Implement file renaming
     return DMFSI_ERR_GENERAL;
 }
+
+
+// ============================================================================
+//                      Local functions
+// ============================================================================
+
+/**
+ * @brief Configure drivers based on the configuration file
+ */
+static int configure_drivers(dmfsi_context_t ctx, const char* driver_name, const char* config_path)
+{
+    void* dir = Dmod_OpenDir(config_path);
+    if (dir == NULL)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Failed to open config directory: %s\n", ctx->config_path);
+        return DMFSI_ERR_NOT_FOUND;
+    }
+
+    const char* entry;
+    while ((entry = Dmod_ReadDir(dir)) != NULL)
+    {
+        if (is_file(entry))
+        {
+            char module_name[DMOD_MAX_MODULE_NAME_LENGTH];
+            dmini_context_t config_ctx = read_driver_for_config(entry, module_name, sizeof(module_name), driver_name);
+            if (config_ctx == NULL)
+            {
+                DMOD_LOG_ERROR("dmdevfs: Failed to read driver for config: %s\n", entry);
+                continue;
+            }
+
+            driver_node_t* driver_node = configure_driver(module_name, config_ctx);
+            dmini_destroy(config_ctx);
+            if (driver_node == NULL)
+            {
+                DMOD_LOG_ERROR("dmdevfs: Failed to configure driver: %s\n", module_name);
+                continue;
+            }
+            if(dmlist_push_back(ctx->drivers, driver_node) != 0)
+            {
+                DMOD_LOG_ERROR("dmdevfs: Failed to add driver to list: %s\n", module_name);
+                Dmod_Free(driver_node);
+                continue;
+            }
+        }
+        else 
+        {
+            // read driver name from directory name
+            char module_name[DMOD_MAX_MODULE_NAME_LENGTH];
+            read_base_name(entry, module_name, sizeof(module_name));
+            int res = configure_drivers(ctx, driver_name, entry);
+            if (res != DMFSI_OK)
+            {
+                DMOD_LOG_ERROR("dmdevfs: Failed to configure drivers in directory: %s\n", entry);
+            }
+        }
+    }
+    Dmod_CloseDir(dir);
+    return DMFSI_OK;
+}
+
+/**
+ * @brief Configure a single driver based on its name and configuration file
+ */
+static driver_node_t* configure_driver(const char* driver_name, dmini_context_t config_ctx)
+{
+    bool was_loaded = false;
+    bool was_enabled = false;
+    Dmod_Context_t* driver = prepare_driver_module(driver_name, &was_loaded, &was_enabled);
+    if (driver == NULL)
+    {
+        return NULL;
+    }
+
+    dmod_dmdrvi_create_t dmdrvi_create = Dmod_GetDifFunction(driver, dmod_dmdrvi_create_sig);
+    if (dmdrvi_create == NULL)
+    {
+        DMOD_LOG_ERROR("Driver module does not implement dmdrvi_create: %s\n", driver_name);
+        cleanup_driver_module(driver_name, was_loaded, was_enabled);
+        return NULL;
+    }
+
+    driver_node_t* driver_node = Dmod_Malloc(sizeof(driver_node_t));
+    if (driver_node == NULL)
+    {
+        DMOD_LOG_ERROR("Failed to allocate memory for driver node: %s\n", driver_name);
+        cleanup_driver_module(driver_name, was_loaded, was_enabled);
+        return NULL;
+    }
+
+    driver_node->driver = driver;
+    driver_node->driver_context = dmdrvi_create(config_ctx, &driver_node->dev_num);
+    if (driver_node->driver_context == NULL)
+    {
+        DMOD_LOG_ERROR("Failed to create driver context: %s\n", driver_name);
+        cleanup_driver_module(driver_name, was_loaded, was_enabled);
+        Dmod_Free(driver_node);
+        return NULL;
+    }
+
+    return driver_node;
+}
+
+/**
+ * @brief Check if a path is a file
+ */
+static bool is_file(const char* path)
+{
+    return Dmod_Access(path, DMOD_F_OK) == 0;
+}
+
+/**
+ * @brief Extract base name from a path
+ */
+static void read_base_name(const char* path, char* base_name, size_t name_size)
+{
+    const char* last_slash = strrchr(path, '/');
+    const char* name_start = (last_slash != NULL) ? last_slash + 1 : path;
+    strncpy(base_name, name_start, name_size);
+    base_name[name_size - 1] = '\0';
+}
+
+/**
+ * @brief Read driver name from configuration file
+ */
+static dmini_context_t read_driver_for_config(const char* config_path, char* driver_name, size_t name_size, const char* default_driver)
+{
+    dmini_context_t ctx = dmini_create();
+    if (ctx == NULL)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Failed to create INI context\n");
+        return NULL;
+    }
+
+    int res = dmini_parse_file(ctx, config_path);
+    if (res != DMINI_OK)
+    {
+        DMOD_LOG_ERROR("dmdevfs: Failed to parse INI file: %s\n", config_path);
+        dmini_destroy(ctx);
+        return NULL;  
+    }
+
+    const char* name = dmini_get_string(ctx, "main", "driver_name", default_driver);
+    if(name != NULL)
+    {
+        strncpy(driver_name, name, name_size);
+        driver_name[name_size - 1] = '\0';
+        return ctx;
+    }
+    
+    read_base_name(config_path, driver_name, name_size);
+
+    // cut the `.ini` extension if present
+    char* ext = strrchr(driver_name, '.');
+    if (ext != NULL && strcmp(ext, ".ini") == 0)
+    {
+        *ext = '\0';
+    }
+    return ctx;
+}
+
+/**
+ * @brief Prepare and load a driver module
+ */
+static Dmod_Context_t* prepare_driver_module(const char* driver_name, bool* was_loaded, bool* was_enabled)
+{
+    *was_loaded = Dmod_IsModuleLoaded(driver_name);
+    *was_enabled = Dmod_IsModuleEnabled(driver_name);
+    Dmod_Context_t* driver = Dmod_LoadModuleByName(driver_name);
+    if (driver == NULL)
+    {
+        DMOD_LOG_ERROR("Failed to load driver module: %s\n", driver_name);
+        return NULL;
+    }
+    if (!*was_enabled && !Dmod_EnableModule(driver_name, true, NULL))
+    {
+        DMOD_LOG_ERROR("Failed to enable driver module: %s\n", driver_name);
+        if(!*was_loaded)
+        {
+            Dmod_UnloadModule(driver_name, false);
+        }
+        return NULL;
+    }
+    return driver;
+}
+
+/**
+ * @brief Cleanup and unload a driver module
+ */
+static void cleanup_driver_module(const char* driver_name, bool was_loaded, bool was_enabled)
+{
+    if(!was_enabled)
+    {
+        Dmod_DisableModule(driver_name, false);
+    }
+    if(!was_loaded)
+    {
+        Dmod_UnloadModule(driver_name, false);
+    }
+}