Added support of allocators names

Author: JohnAmadis

inc/dmod_sal.h

@@ -67,9 +67,9 @@ extern "C" {
  * @{
  */
 #if defined(DMOD_MODULE_NAME)
-#   define Dmod_Malloc(Size)                        Dmod_MallocEx(Size, Dmod_GetCurrentModuleName())
-#   define Dmod_Realloc(Ptr, Size)                  Dmod_ReallocEx(Ptr, Size, Dmod_GetCurrentModuleName())
-#   define Dmod_AlignedMalloc(Size, Alignment)      Dmod_AlignedMallocEx(Size, Alignment, Dmod_GetCurrentModuleName(DMOD_MODULE_NAME))
+#   define Dmod_Malloc(Size)                        Dmod_MallocEx(Size, Dmod_GetCurrentAllocatorName())
+#   define Dmod_Realloc(Ptr, Size)                  Dmod_ReallocEx(Ptr, Size, Dmod_GetCurrentAllocatorName())
+#   define Dmod_AlignedMalloc(Size, Alignment)      Dmod_AlignedMallocEx(Size, Alignment, Dmod_GetCurrentAllocatorName(DMOD_MODULE_NAME))
 #   define Dmod_Free(Ptr)                           Dmod_FreeEx(Ptr, false)
 #else 
     DMOD_BUILTIN_API(Dmod, 1.0, void*,  _Malloc ,           ( size_t Size )                     );
@@ -199,13 +199,36 @@ DMOD_BUILTIN_API(Dmod, 1.0, size_t, _ReadKernel,  ( void* Buffer, size_t Size )
 #   define Dmod_GetCurrentModuleName()      Dmod_GetCurrentModuleNameEx(NULL)
 #endif
 
+/**
+ * @brief Name used to attribute heap allocations (Dmod_Malloc/Dmod_MallocEx/...) to their owner.
+ *
+ * This is deliberately a *separate* identity from Dmod_GetCurrentModuleName(): the module name
+ * is not unique when the same module is loaded more than once at the same time (e.g. a shell
+ * spawning another instance of itself in the background) - two independent Dmod_Context_t's
+ * end up sharing one name. Allocation tracking (dmheap and similar) keys everything off this
+ * string, including bulk-freeing all of a module's memory on unload (Dmod_FreeModule) - if two
+ * live instances shared that key, unloading one would free memory the other is still using.
+ *
+ * The default (weak) implementation just falls back to the module name, same as
+ * Dmod_GetCurrentModuleName() - a platform without real process tracking has no way to tell two
+ * instances apart anyway. A real implementation (see the dmosi glue layer) can return something
+ * that also incorporates the current process's identity (e.g. name + PID), which is unique per
+ * spawned instance even when the module name repeats.
+ */
+#ifdef DMOD_MODULE_NAME
+#   define Dmod_GetCurrentAllocatorName()      Dmod_GetCurrentAllocatorNameEx(DMOD_MODULE_NAME)
+#else
+#   define Dmod_GetCurrentAllocatorName()      Dmod_GetCurrentAllocatorNameEx(NULL)
+#endif
+
 DMOD_BUILTIN_API(Dmod, 1.0, const char*, _GetEnv, ( const char* Name ) );
 DMOD_BUILTIN_API(Dmod, 1.0, int, _SetEnv, ( const char* Name, const char* Value, int Overwrite ) );
 DMOD_BUILTIN_API(Dmod, 1.0, int, _Unsetenv, ( const char* Name ) );
 DMOD_BUILTIN_API(Dmod, 1.0, const char*, _GetNextEnvName, ( const char* Last ) );
 DMOD_BUILTIN_API(Dmod, 1.0, int, _EnvCtx_Push, ( void ) );
 DMOD_BUILTIN_API(Dmod, 1.0, int, _EnvCtx_Pop, ( void ) );
 DMOD_BUILTIN_API(Dmod, 1.0, const char*, _GetCurrentModuleNameEx, ( const char* Default ) );
+DMOD_BUILTIN_API(Dmod, 1.0, const char*, _GetCurrentAllocatorNameEx, ( const char* Default ) );
 
 //! @}
 

src/system/dmod_system.c

@@ -716,8 +716,21 @@ Dmod_Context_t* Dmod_LoadModuleByName(const char* ModuleName)
 
     if(Dmod_Mgr_IsLoaded(ModuleName))
     {
-        DMOD_LOG_INFO("Module %s is already loaded\n", ModuleName);
-        return Dmod_Context_Get(ModuleName);
+        Dmod_Context_t* existing = Dmod_Context_Get(ModuleName);
+
+        // Only Library modules are shared singletons (drivers etc. must stay one
+        // instance). Application modules are not: reusing an already-loaded
+        // Application's context here would hand out the SAME context (and so the
+        // same Dmod_Run() mutex) to a second, concurrent invocation - which would
+        // then block forever waiting for a mutex the first, still-running instance
+        // never releases, instead of getting its own independent run. So for an
+        // Application module that's already loaded, fall through and load a fresh,
+        // independent context instead of reusing this one.
+        if( existing != NULL && Dmod_GetModuleType( existing ) != Dmod_ModuleType_Application )
+        {
+            DMOD_LOG_INFO("Module %s is already loaded\n", ModuleName);
+            return existing;
+        }
     }
 
     Dmod_SearchNode_t* searchNode = Dmod_Hlp_PrepareModulesSearchNodes();
@@ -783,8 +796,17 @@ Dmod_Context_t* Dmod_LoadModuleFromPackage(const char* ModuleName, const char* P
 
     if(Dmod_Mgr_IsLoaded(ModuleName))
     {
-        DMOD_LOG_INFO("Module %s is already loaded\n", ModuleName);
-        return Dmod_Context_Get(ModuleName);
+        Dmod_Context_t* existing = Dmod_Context_Get(ModuleName);
+
+        // See the matching comment in Dmod_LoadModuleByName: only Library modules
+        // are shared singletons - an already-loaded Application module keeps its
+        // own context so a concurrent second run doesn't deadlock on the first
+        // instance's Dmod_Run() mutex.
+        if( existing != NULL && Dmod_GetModuleType( existing ) != Dmod_ModuleType_Application )
+        {
+            DMOD_LOG_INFO("Module %s is already loaded\n", ModuleName);
+            return existing;
+        }
     }
 
     Dmod_Context_t* context = Dmod_LoadFromPackage( PackageName, ModuleName );

src/system/if/dmod_if_env.c

@@ -247,4 +247,22 @@ DMOD_INPUT_WEAK_API_DECLARATION(Dmod, 1.0, const char*, _GetCurrentModuleNameEx,
 {
     /* The default implementation simply returns the provided default name. */
     return Default;
+}
+
+/**
+ * @brief Get the name used to attribute heap allocations to their owner
+ *
+ * This is a weak implementation with no real process tracking to draw on, so it can't
+ * tell apart two concurrently loaded instances of the same module - it just falls back
+ * to the module name, same as Dmod_GetCurrentModuleNameEx(). The real implementation
+ * should be provided by the dmosi layer, which can incorporate process identity (e.g.
+ * name + PID) to give each spawned instance its own unique allocator name.
+ *
+ * @param Default The default name to return if no better allocator name is available
+ *
+ * @return The current allocator name, or Default if it cannot be determined
+ */
+DMOD_INPUT_WEAK_API_DECLARATION(Dmod, 1.0, const char*, _GetCurrentAllocatorNameEx, ( const char* Default ))
+{
+    return Default;
 }