Kernel/modules.c

   1 /*
   2  * Acess2
   3  * - Module Loader
   4  */
   5 #include <common.h>
   6 #include <modules.h>
   7
   8 // === PROTOTYPES ===
   9  int    Module_LoadMem(void *Buffer, Uint Length, char *ArgString);
  10  int    Module_LoadFile(char *Path, char *ArgString);
  11  int    Module_int_ResolveDeps(tModule *Info);
  12  int    Module_IsLoaded(char *Name);
  13
  14 // === IMPORTS ===
  15 extern tModule  gKernelModules[];
  16 extern void             gKernelModulesEnd;
  17
  18 // === GLOBALS ===
  19  int    giNumBuiltinModules = 0;
  20  int    giModuleSpinlock = 0;
  21 tModule *gLoadedModules = NULL;
  22
  23 // === CODE ===
  24 int Modules_LoadBuiltins()
  25 {
  26          int    i;
  27         giNumBuiltinModules = (Uint)&gKernelModulesEnd - (Uint)&gKernelModules;
  28         giNumBuiltinModules /= sizeof(tModule);
  29
  30         for( i = 0; i < giNumBuiltinModules; i++ )
  31         {
  32                 Log("Initialising %p '%s' v%i.%i...",
  33                         &gKernelModules[i],
  34                         gKernelModules[i].Name,
  35                         gKernelModules[i].Version>>8, gKernelModules[i].Version & 0xFF
  36                         );
  37                 gKernelModules[i].Init(NULL);
  38         }
  39
  40         return 0;
  41 }
  42
  43 /**
  44  * \fn int Module_LoadMem(void *Buffer, Uint Length, char *ArgString)
  45  * \brief Load a module from a memory location
  46  */
  47 int Module_LoadMem(void *Buffer, Uint Length, char *ArgString)
  48 {
  49         char    path[VFS_MEMPATH_SIZE];
  50
  51         VFS_GetMemPath(Buffer, Length, path);
  52
  53         return Module_LoadFile( path, ArgString );
  54 }
  55
  56 /**
  57  * \fn int Module_LoadFile(char *Path, char *ArgString)
  58  * \brief Load a module from a file
  59  */
  60 int Module_LoadFile(char *Path, char *ArgString)
  61 {
  62         void    *base;
  63         tModule *info;
  64
  65         // Load Binary
  66         base = Binary_LoadKernel(Path);
  67
  68         // Error check
  69         if(base == NULL)        return 0;
  70
  71         // Check for Acess Driver
  72         if( Binary_FindSymbol(base, "DriverInfo", (Uint*)&info ) == 0 )
  73         {
  74                 #if USE_EDI
  75                 // Check for EDI Driver
  76                 if( Binary_FindSymbol(base, "driver_init", NULL ) == 0 )
  77                 {
  78                         Binary_Relocate(base);  // Relocate
  79                         return Module_InitEDI( base );  // And intialise
  80                 }
  81                 #endif
  82
  83                 // Unknown module type?, return error
  84                 Binary_Unload(base);
  85                 #if USE_EDI
  86                 Warning("Module_LoadMem: Module has neither a Module Info struct, nor an EDI entrypoint");
  87                 #else
  88                 Warning("Module_LoadMem: Module does not have a Module Info struct");
  89                 #endif
  90                 return 0;
  91         }
  92
  93         // Check magic number
  94         if(info->Magic != MODULE_MAGIC)
  95         {
  96                 Warning("Module_LoadMem: Module's magic value is invalid (0x%x != 0x%x)", info->Magic, MODULE_MAGIC);
  97                 return 0;
  98         }
  99
 100         // Check Architecture
 101         if(info->Arch != MODULE_ARCH_ID)
 102         {
 103                 Warning("Module_LoadMem: Module is for a different architecture");
 104                 return 0;
 105         }
 106
 107         // Resolve Dependencies
 108         if( !Module_int_ResolveDeps(info) ) {
 109                 Binary_Unload(base);
 110                 return 0;
 111         }
 112
 113         // Call Initialiser
 114         //if( info->Init( ArgString ) != 0 )
 115         if( info->Init( NULL ) == 0 )
 116         {
 117                 Binary_Unload(base);
 118                 return 0;
 119         }
 120
 121         // Add to list
 122         LOCK( &giModuleSpinlock );
 123         info->Next = gLoadedModules;
 124         gLoadedModules = info;
 125         RELEASE( &giModuleSpinlock );
 126
 127         return 1;
 128 }
 129
 130 /**
 131  * \fn int Module_int_ResolveDeps(tModule *Info)
 132  * \brief Resolves the dependencies
 133  * \todo Implement
 134  * \note Currently does not resolve the dependencies, just checks them
 135  */
 136 int Module_int_ResolveDeps(tModule *Info)
 137 {
 138         char    **names = Info->Dependencies;
 139
 140         // Walk dependencies array
 141         for( ; *names; names++ )
 142         {
 143                 // Check if the module is loaded
 144                 if( !Module_IsLoaded(*names) ) {
 145                         Warning("Module `%s' requires `%s', which is not loaded\n", Info->Name, *names);
 146                         return 0;
 147                 }
 148         }
 149         return 1;
 150 }
 151
 152 /**
 153  * \fn int Module_IsLoaded(char *Name)
 154  * \brief Checks if a module is loaded
 155  * \param Name  Name of module to find
 156  */
 157 int Module_IsLoaded(char *Name)
 158 {
 159         tModule *mod = gLoadedModules;
 160
 161         // Scan loaded list
 162         for( ; mod; mod = mod->Next )
 163         {
 164                 // If found, return true
 165                 if(strcmp(mod->Name, Name) == 0)
 166                         return 1;
 167         }
 168         // not found - return false
 169         return 0;
 170 }