#include "camera_info.h"
#include "conf.h"
#include "console.h"
#include "clock.h"
#include "cache.h"
#include "lang.h"
#include "gui_mbox.h"
#include "gui_lang.h"
#include "time.h"
#include "ctype.h"
#include "simple_module.h"
#include "module_load.h"
#include "module_exportlist.h"
#include "module_hash.h"

Include-Abhängigkeitsdiagramm für module_load.c:

Makrodefinitionen
#define	BUFFER_FOR_READ_SIZE 4096

#define	MODULES_PATH "A/CHDK/MODULES/"

#define	MAX_SIMPLE_MODULE 4

Funktionen
static unsigned int	hash_module_name (char *str)

static unsigned int	get_module_path (char path, const char name)

static int	get_buffer (int size)

static int	b_open (const char *name)

int	b_read (int fd, char *buf, int len)

void	b_close (int fd)

static int	namecmp (const char s1, const char s2)

static int	module_find (unsigned int hash)

static void	moduleload_error (const char name, const char text)

static int	module_do_relocations (flat_hdr flat, void relocbuf, uint32_t reloc_count)

static const void *	module_find_symbol_address (uint32_t importid)

static int	module_do_imports (flat_hdr flat, void relocbuf, uint32_t import_count)

static int	module_do_action (int fd, flat_hdr mod, uint32_t offset, uint32_t segment_size, int(func)(flat_hdr , void , uint32_t))

static void	module_writeline (char *buf)

static void	module_log_hdr ()

void	module_log_clear ()

static void	module_log_load (const char name, void adr)

static void	module_log_unload (char *name)

static int	bind_module (module_handler_t hMod, void module_lib)

static void	module_unload_idx (int idx)

void	module_unload (const char *name)

static char *	validate (ModuleInfo *mod_info, _version_t ver)

static char *	load_module_file (int fd, const char name, int size, int bss_size, flat_hdr *flat_buf)

static char *	link_module (int fd, flat_hdr *flat_buf)

flat_hdr *	module_preload (const char path, const char name, _version_t ver)

static int	_module_load (module_handler_t *hMod)

int	module_load (module_handler_t *hMod)

static int	default_run0 ()

static int	default_run1 ()

static int	default_run2 ()

static int	default_run3 ()

static void	module_run_error (int err, char *name)

static int	default_run (int n)

int	module_run (char *name)

void	module_exit_alt ()

void	module_tick_unloader ()

module_entry *	module_get_adr (unsigned int idx)

void	get_module_info (const char name, ModuleInfo mi, char *modName, int modNameLen)

Variablen
sym_hash	symbol_hash_table []

static module_entry	modules [MAX_NUM_LOADED_MODULES]

static char *	buf_load = 0

static int	buf_size = 0

static libsimple_sym	default_librun [MAX_SIMPLE_MODULE]

static libsimple_sym *	librun [MAX_SIMPLE_MODULE] = { &default_librun[0], &default_librun[1], &default_librun[2], &default_librun[3] }

static char	h_name [MAX_SIMPLE_MODULE][64]

static module_handler_t	h_run [MAX_SIMPLE_MODULE]

Makro-Dokumentation

#define BUFFER_FOR_READ_SIZE 4096

Definiert in Zeile 38 der Datei module_load.c.

#define MAX_SIMPLE_MODULE 4

Definiert in Zeile 684 der Datei module_load.c.

#define MODULES_PATH "A/CHDK/MODULES/"

Definiert in Zeile 39 der Datei module_load.c.

Dokumentation der Funktionen

static int _module_load ( module_handler_t * hMod)

static

Definiert in Zeile 586 der Datei module_load.c.

 {
     int idx;
 
     // Get full path to module file, and hash of path
     char path[60];
     unsigned int hash = get_module_path(path, hMod->name);
 
     // Check if module already loaded
     idx = module_find(hash);
     if (idx >= 0)
         return idx;
 
     // Reset lib (should not be needed, loader should only be called from 'default' lib)
     *hMod->lib = hMod->default_lib;
 
     // Simple lock to prevent multiple attempts to load modules simultaneously (in different tasks)
     // Not perfect; but should be sufficient
     static int isLoading = 0;
     while (isLoading != 0) msleep(10);
     isLoading = 1;
 
     // Find empty slot   
     for (idx=0; idx<MAX_NUM_LOADED_MODULES && modules[idx].hdr; idx++) ;
 
     // If no slot found return error
     if  (idx == MAX_NUM_LOADED_MODULES)
     {
         moduleload_error(hMod->name, "too many modules loaded");
         idx = -1;
     }
     else
     {
         // Load and relocate module (returns 0 if error)
         flat_hdr* mod = module_preload(path, hMod->name, hMod->version);
 
         if (mod != 0)
         {
             // Module is valid. Finalize binding
             modules[idx].hdr = mod;
             modules[idx].hName = hash;
             modules[idx].hMod = hMod;
 
             int bind_err = bind_module(hMod, mod->_module_info->lib);
 
             // Call module loader if required
             if (!bind_err && mod->_module_info->lib->loader)
             {
                 bind_err = mod->_module_info->lib->loader();
             }
 
             // If any errors, unload module and display error message
             if (bind_err)
             {
                 module_unload_idx(idx);
                 moduleload_error(hMod->name, "loader error");
                 idx = -1;
             }
         }
         else
         {
             // module did not load, return invalid index
             idx = -1;
         }
     }
 
     // Release lock
     isLoading = 0;
 
     return idx;
 }

void b_close ( int fd)

Definiert in Zeile 138 der Datei module_load.c.

 {
     if (fd >= 0)
         close(fd);
 }

static int b_open ( const char * name)

static

Definiert in Zeile 106 der Datei module_load.c.

 {
     if (!get_buffer(BUFFER_FOR_READ_SIZE))
     {
         return -1;
     }
 
     return open(name, O_RDONLY, 0777);
 }

int b_read	(	int	fd,
		char *	buf,
		int	len
	)

Definiert in Zeile 119 der Datei module_load.c.

 {
     int loaded = 0, now = 1;
 
     while (now && loaded<len)
     {
         now = len - loaded;
         if (now > buf_size)
             now = buf_size;
 
         now = read(fd, buf_load, now);
         memcpy(buf+loaded, buf_load, now);
         loaded += now;
     }
 
     return loaded;
 }

static int bind_module	(	module_handler_t *	hMod,
		void *	module_lib
	)

static

Definiert in Zeile 376 der Datei module_load.c.

 {
     // If unloading module, reset library to unloaded default
     if (module_lib == 0)
         *hMod->lib = hMod->default_lib;
     else
         *hMod->lib = module_lib;
 
     return 0;
 }

static int default_run ( int n)

static

Definiert in Zeile 726 der Datei module_load.c.

 {
     if (module_load(&h_run[n]))
     {
         if ((*h_run[n].lib)->run)
         {
             return (*h_run[n].lib)->run();
         }
         else
         {
             // Error - module does not support 'simple' mode
             module_run_error(LANG_MODULE_NOT_SIMPLE, h_run[n].name);
             // Assumption - module will unload automatically via module_tick_unloader()
         }
     }
 
     return -1;
 }

static int default_run0 ( )

static

Definiert in Zeile 746 der Datei module_load.c.

746 { return default_run(0); }

static int default_run1 ( )

static

Definiert in Zeile 747 der Datei module_load.c.

747 { return default_run(1); }

static int default_run2 ( )

static

Definiert in Zeile 748 der Datei module_load.c.

748 { return default_run(2); }

static int default_run3 ( )

static

Definiert in Zeile 749 der Datei module_load.c.

749 { return default_run(3); }

static int get_buffer ( int size)

static

Definiert in Zeile 85 der Datei module_load.c.

 {
     size = (size + 3) & 0xFFFFFFFC; // round up to 4 byte boundary
     if (size > buf_size)
     {
         if (buf_load)
         {
             ufree(buf_load);
             buf_load = 0;
             buf_size = 0;
         }
         buf_load = umalloc(size);
         if (buf_load)
             buf_size = size;
     }
 
     return buf_size;
 }

void get_module_info	(	const char *	name,
		ModuleInfo *	mi,
		char *	modName,
		int	modNameLen
	)

Definiert in Zeile 838 der Datei module_load.c.

 {
     memset(mi, 0, sizeof(ModuleInfo));
     if (modName)
         modName[0] = 0;     // Only used if module name stored in file (not a LANG string)
 
     // Get full path to module file, and hash of path
     char path[60];
     get_module_path(path, name);
 
     // open file
     int fd = open(path, O_RDONLY, 0777);
     if (fd < 0)
         return;
 
     // Read module header only to get size info
     flat_hdr flat;
     read(fd, (char*)&flat, sizeof(flat_hdr));
 
     // Check version and magic number - make sure it is a CHDK module file
     if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
     {
         lseek(fd, flat._module_info_offset, SEEK_SET);
         read(fd, mi, sizeof(ModuleInfo));
 
         if ((mi->moduleName >= 0) && modName)
         {
             // Load module name string
             lseek(fd, mi->moduleName, SEEK_SET);
             read(fd, modName, modNameLen-1);
             modName[modNameLen-1] = 0;
         }
     }
 
     close(fd);
 }

static unsigned int get_module_path	(	char *	path,
		const char *	name
	)

static

Definiert in Zeile 60 der Datei module_load.c.

 {
     // Check if full path supplied?
     if ((tolower(name[0]) != 'a') || (name[1] != '/'))
         strcpy(path, MODULES_PATH);
     else
         path[0] = 0;
     // Add supplied name to path
     strcat(path, name);
 
     return hash_module_name(path);
 }

static unsigned int hash_module_name ( char * str)

static

Definiert in Zeile 44 der Datei module_load.c.

 {
     unsigned int hash = 5381;
     int c;
 
     // djb2 hash algorithm (Dan Bernstein - http://cr.yp.to/djb.html)
     while ((c = *str++) != 0)
         hash = ((hash << 5) + hash) ^ toupper(c); /* hash * 33 xor c */
 
     return hash;
 }

static char* link_module	(	int	fd,
		flat_hdr *	flat_buf
	)

static

Definiert in Zeile 494 der Datei module_load.c.

 {
     // Make relocations
     int reloc_size = flat_buf->import_start - flat_buf->reloc_start;
     int import_size = flat_buf->import_size;
 
     // Get larger buffer size if needed
     int sz = (reloc_size > import_size) ? reloc_size : import_size;
 
     if (!get_buffer(sz))  // Re-allocate if needed
         return "malloc";
 
     if (!module_do_action(fd, flat_buf, flat_buf->reloc_start, reloc_size, module_do_relocations))
         return "reloc error";
 
     if (!module_do_action(fd, flat_buf, flat_buf->import_start, import_size, module_do_imports))
         return "link error";
 
     return 0;
 }

static char* load_module_file	(	int	fd,
		const char *	name,
		int	size,
		int	bss_size,
		flat_hdr **	flat_buf
	)

static

Definiert in Zeile 468 der Datei module_load.c.

 {
     *flat_buf = (flat_hdr*)malloc(size+bss_size);
     if (!*flat_buf)
         return "malloc";
 
     module_log_load(name, *flat_buf);
 
     if (lseek(fd, 0, SEEK_SET) == 0)
     {
         if (b_read(fd, (char*)*flat_buf, size) == size)
         {
             memset((unsigned char*)(*flat_buf)+size, 0, bss_size);
             return 0;
         }
     }
 
     // Load failed, free memory
     free(*flat_buf);
     *flat_buf = 0;
 
     return "read";
 }

static int module_do_action	(	int	fd,
		flat_hdr *	mod,
		uint32_t	offset,
		uint32_t	segment_size,
		int()(flat_hdr , void *, uint32_t)	func
	)

static

Definiert in Zeile 277 der Datei module_load.c.

 {
     if (segment_size > 0)
     {
         if (lseek(fd, offset, SEEK_SET) == (int)offset)
         {
             if (read(fd, buf_load, segment_size) == (int)segment_size)
             {
                 // relocate or link module
                 return func(mod, (uint32_t*)buf_load, segment_size >> 2);
             }
         }
         return 0;
     }
     return 1;
 }

static int module_do_imports	(	flat_hdr *	flat,
		void *	relocbuf,
		uint32_t	import_count
	)

static

Definiert in Zeile 248 der Datei module_load.c.

 {
     uint32_t i;
     unsigned char* buf = (unsigned char*)flat;  // base address of module in memory
     uint32_t* rbuf = (uint32_t*)relocbuf;       // link array
 
     for (i=0; i < import_count;)
     {
         // Find CHDK address of symbol via hash value, if not found return error
         int importaddress = (int)module_find_symbol_address(rbuf[i++]);
         if (importaddress == 0) return 0;
 
         // Get number of locations in module to link
         int cnt = rbuf[i] >> 24;
 
         for (; cnt>0; cnt--)
         {
             // Get offset into module (exclude count value)
             uint32_t offs = rbuf[i++] & 0x00FFFFFF;
             // Add initial value at location to symbol address
             *(uint32_t*)(buf+offs) += importaddress;
         }
     }  
     return 1;
 }

static int module_do_relocations	(	flat_hdr *	flat,
		void *	relocbuf,
		uint32_t	reloc_count
	)

static

Definiert in Zeile 205 der Datei module_load.c.

 {
     uint32_t i;
     unsigned char* buf = (unsigned char*)flat;      // base address of module in memory
     uint32_t* rbuf = (uint32_t*)relocbuf;           // relocation array
 
     for (i=0; i < reloc_count; i++)
     {
         // Add initial value at relocated address to the base module address
         *(uint32_t*)(buf+rbuf[i]) += (uint32_t)buf;
     }
 
     return 1;
 }

void module_exit_alt ( )

Definiert in Zeile 792 der Datei module_load.c.

 {
     int idx;
 
     for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
     {
         if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->exit_alt)
         {
             // Tell module we are leaving <ALT>
             modules[idx].hdr->_module_info->lib->exit_alt();
         }
     }
 }

static int module_find ( unsigned int hash)

static

Definiert in Zeile 167 der Datei module_load.c.

 {
     int i;
 
     for (i=0; i<MAX_NUM_LOADED_MODULES; i++)
     {
         if (modules[i].hdr && (modules[i].hName == hash))
         {
             return i;
         }
     }
     return -1;
 }

static const void* module_find_symbol_address ( uint32_t importid)

static

Definiert in Zeile 223 der Datei module_load.c.

 {
     int min = 0, max = EXPORTLIST_COUNT-1;
     do
     {
         int mid = (min + max) >> 1;
         if (importid == symbol_hash_table[mid].hash)
             return symbol_hash_table[mid].address;
         else if (importid > symbol_hash_table[mid].hash)
             min = mid + 1;
         else
             max = mid - 1;
     } while (min <= max);
     return 0;
 }

module_entry* module_get_adr ( unsigned int idx)

Definiert in Zeile 828 der Datei module_load.c.

 {
     if (idx < MAX_NUM_LOADED_MODULES)
         if (modules[idx].hdr)
             return &modules[idx];
     return 0;
 }

int module_load ( module_handler_t * hMod)

Definiert in Zeile 660 der Datei module_load.c.

 {
     // Attempt to load module
     _module_load(hMod);
 
     // If load succeeded return success
     if (*hMod->lib && (*hMod->lib != hMod->default_lib))
     {
         return 1;
     }
 
     // If load failed reset library to unloaded default (should not be needed!)
     if (*hMod->lib == 0)
         *hMod->lib = hMod->default_lib;
 
     // Failure
     return 0;
 }

void module_log_clear ( )

Definiert in Zeile 343 der Datei module_load.c.

 {
     remove("A/MODULES.LOG");
 }

static void module_log_hdr ( )

static

Definiert in Zeile 318 der Datei module_load.c.

 {
     static int hdr_logged = 0;
 
     if (conf.module_logging)
     {
         if (hdr_logged == 0)
         {
             hdr_logged = 1;
 
             time_t datetime;
             struct tm *ttm;
             char buf[100];
 
             datetime = time(NULL);
             ttm = localtime(&datetime);
 
             sprintf(buf, "Tick    ,Op,Address ,Name (%04d:%02d:%02d %02d:%02d:%02d)\n", ttm->tm_year+1900, ttm->tm_mon+1, ttm->tm_mday, ttm->tm_hour, ttm->tm_min, ttm->tm_sec);
 
             module_writeline(buf);
         }
     }
 }

static void module_log_load	(	const char *	name,
		void *	adr
	)

static

Definiert in Zeile 349 der Datei module_load.c.

 {
     if (conf.module_logging)
     {
         char buf[100];
         sprintf(buf,"%8d,LD,%08x,%s\n",get_tick_count(),adr,name);
 
         module_log_hdr();
         module_writeline(buf);
     }
 }

static void module_log_unload ( char * name)

static

Definiert in Zeile 362 der Datei module_load.c.

 {
     if (conf.module_logging)
     {
         char buf[100];
         sprintf(buf,"%8d,UN,        ,%s\n",get_tick_count(),name);
 
         module_log_hdr();
         module_writeline(buf);
     }
 }

flat_hdr* module_preload	(	const char *	path,
		const char *	name,
		_version_t	ver
	)

Definiert in Zeile 518 der Datei module_load.c.

 {
     // Allocate buffer and open file
     int module_fd = b_open(path);
     if (module_fd <= 0)
     {
         moduleload_error(name, "open error");
         return 0;
     }
 
     // Read module header only to get size info
     flat_hdr flat;
     b_read(module_fd, (char*)&flat, sizeof(flat));  // TODO - compare loaded with requested size
 
     // Error message
     char *msg = 0;
 
     // Pointer to memory allocated to load module
     flat_hdr* flat_buf = 0;
 
     // Check version and magic number - make sure it is a CHDK module file
     if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
     {
         // Allocate module memory, and load module code
         msg = load_module_file(module_fd, name, flat.reloc_start, flat.bss_size, &flat_buf);
         if (msg == 0)
         {
             // Module info checks
             ModuleInfo *mod_info = flat_buf->_module_info = (ModuleInfo*)((unsigned int)flat_buf+flat_buf->_module_info_offset);
 
             // Validate version requirements
             msg = validate(mod_info, ver);
             if (msg == 0)
             {
                 // Make relocations
                 msg = link_module(module_fd, flat_buf);
             }
         }
     }
     else
         msg = "bad magicnum";
 
     // Close file
     b_close(module_fd);
 
     // If any error found, free module memory and display error
     if (msg)
     {
         if (flat_buf)
             free(flat_buf);
         moduleload_error(name, msg);
         return 0;
     }
 
     // TODO these could be changed to operate on affected address ranges only
     // after relocating but before attempting to execute loaded code
     // clean data cache to ensure code is in main memory
     dcache_clean_all();
     // then flush instruction cache to ensure no addresses containing new code are cached
     icache_flush_all();
 
     // Return module memory address
     return flat_buf;
 }

int module_run ( char * name)

Definiert in Zeile 755 der Datei module_load.c.

 {
     int i;
     for (i=0; i<MAX_SIMPLE_MODULE; i++)
     {
         // Check if module loaded (otherwise name not valid)
         if (*h_run[i].lib != h_run[i].default_lib)
         {
             if (namecmp(name, h_run[i].name))
             {
                 // Already loaded
                 return (*h_run[i].lib)->run();
             }
         }
     }
     for (i=0; i<MAX_SIMPLE_MODULE; i++)
     {
         // Look for empty slot
         if (*h_run[i].lib == h_run[i].default_lib)
         {
             // Found space - run module
             strcpy(h_run[i].name, name);
             return (*h_run[i].lib)->run();
         }
     }
 
     // Error - no space
     module_run_error(LANG_MODULE_NO_SPACE, name);
 
     return -1;
 }

static void module_run_error	(	int	err,
		char *	name
	)

static

Definiert in Zeile 716 der Datei module_load.c.

 {
     char buf[100];
     sprintf(buf, lang_str(err), name);
     gui_mbox_init(LANG_ERROR, (int)buf, MBOX_BTN_OK|MBOX_TEXT_CENTER, NULL);
 }

void module_tick_unloader ( )

Definiert in Zeile 809 der Datei module_load.c.

 {
     int idx;
 
     for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
     {
         if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->can_unload)
         {
             // Ask module if it is safe to unload
             if (modules[idx].hdr->_module_info->lib->can_unload())
                 module_unload_idx(idx);
         }
     }
 }

void module_unload ( const char * name)

Definiert in Zeile 410 der Datei module_load.c.

 {
     // Get full path to module file, and hash of path
     char path[60];
     unsigned int hash = get_module_path(path, name);
 
     // Find loaded module, and unload it
     module_unload_idx(module_find(hash));
 }

static void module_unload_idx ( int idx)

static

Definiert in Zeile 389 der Datei module_load.c.

 {
     if ((idx >= 0) && (modules[idx].hdr != 0))
     {
         // Log unload
         module_log_unload(modules[idx].hMod->name);
 
         // Call module unload function
         if (modules[idx].hdr->_module_info->lib->unloader)
             modules[idx].hdr->_module_info->lib->unloader();
 
         // Unbind pointers to module (chdk core callback)
         bind_module(modules[idx].hMod, 0);
 
         // Free module memory, and mark module as inactive
         free(modules[idx].hdr);
         modules[idx].hdr = 0;
     }
 }

static void module_writeline ( char * buf)

static

Definiert in Zeile 302 der Datei module_load.c.

 {
     if (conf.module_logging)
     {
         int fd = open("A/MODULES.LOG", O_WRONLY|O_CREAT|O_APPEND, 0777);
         if (fd >= 0)
         {
             lseek(fd, 0, SEEK_END);
             write(fd, buf, strlen(buf));
             close(fd);
         }
     }
 }

static void moduleload_error	(	const char *	name,
		const char *	text
	)

static

Definiert in Zeile 183 der Datei module_load.c.

 {
     extern volatile int chdk_started_flag;
     if (chdk_started_flag)
     {
         char buf[100];
         sprintf(buf, "Fail to load %s: %s", name, text);
 
         console_clear();
         console_add_line(buf);
         msleep(1000);
     }
 }

static int namecmp	(	const char *	s1,
		const char *	s2
	)

static

Definiert in Zeile 150 der Datei module_load.c.

 {
     if ((s1 == 0) && (s2 == 0)) return 1;   // Both null --> equal
     if ((s1 == 0) || (s2 == 0)) return 0;   // One null (but not both) --> not equal
     while (*s1 && *s2)
     {
         if (tolower(*s1) != tolower(*s2)) return 0;
         s1++;
         s2++;
     }
     return ((*s1 == 0) && (*s2 == 0));
 }

static char* validate	(	ModuleInfo *	mod_info,
		_version_t	ver
	)

static

Definiert in Zeile 423 der Datei module_load.c.

 {
     static char msg[50];
 
     if ((mod_info->magicnum != MODULEINFO_V1_MAGICNUM) || (mod_info->sizeof_struct != sizeof(ModuleInfo)))
         return "Malformed module info";
 
     if (mod_info->chdk_required_branch && (mod_info->chdk_required_branch != CURRENT_CHDK_BRANCH))
         return "require different CHDK branch";
 
     if (mod_info->chdk_required_architecture != OPT_ARCHITECTURE)
         return "wrong CHDK architecture";
 
     if (mod_info->chdk_required_ver > CHDK_BUILD_NUM)
     {
         sprintf(msg, "require CHDK%05d", mod_info->chdk_required_ver);
         return msg;
     }
 
     if (mod_info->chdk_required_platfid && (mod_info->chdk_required_platfid != (uint32_t)conf.platformid))
     {
         sprintf(msg, "require platfid %d", mod_info->chdk_required_platfid);
         return msg;
     }
 
     if (!chk_api_version(mod_info->module_version, ver))
         return "incorrect module version";
 
     if (!chk_api_version((_version_t)CONF_VERSION, mod_info->conf_ver))
         return "incorrect CONF version";
 
     if (!chk_api_version((_version_t)CAM_SCREEN_VERSION, mod_info->cam_screen_ver))
         return "incorrect CAM SCREEN version";
 
     if (!chk_api_version((_version_t)CAM_SENSOR_VERSION, mod_info->cam_sensor_ver))
         return "incorrect CAM SENSOR version";
 
     if (!chk_api_version((_version_t)CAM_INFO_VERSION, mod_info->cam_info_ver))
         return "incorrect CAM INFO version";
 
     return 0;
 }

Variablen-Dokumentation

char* buf_load = 0

static

Definiert in Zeile 79 der Datei module_load.c.

int buf_size = 0

static

Definiert in Zeile 80 der Datei module_load.c.

libsimple_sym default_librun[MAX_SIMPLE_MODULE]

static

Initialisierung:

=
{
    { { 0, 0, 0, 0, default_run0 } },
    { { 0, 0, 0, 0, default_run1 } },
    { { 0, 0, 0, 0, default_run2 } },
    { { 0, 0, 0, 0, default_run3 } }
}

Definiert in Zeile 693 der Datei module_load.c.

char h_name[MAX_SIMPLE_MODULE][64]

static

Definiert in Zeile 704 der Datei module_load.c.

module_handler_t h_run[MAX_SIMPLE_MODULE]

static

Initialisierung:

=
{
    { (base_interface_t**)&librun[0], &default_librun[0].base, ANY_VERSION, h_name[0] },
    { (base_interface_t**)&librun[1], &default_librun[1].base, ANY_VERSION, h_name[1] },
    { (base_interface_t**)&librun[2], &default_librun[2].base, ANY_VERSION, h_name[2] },
    { (base_interface_t**)&librun[3], &default_librun[3].base, ANY_VERSION, h_name[3] }
}

Definiert in Zeile 707 der Datei module_load.c.

libsimple_sym* librun[MAX_SIMPLE_MODULE] = { &default_librun[0], &default_librun[1], &default_librun[2], &default_librun[3] }

static

Definiert in Zeile 700 der Datei module_load.c.

module_entry modules[MAX_NUM_LOADED_MODULES]

static

Definiert in Zeile 34 der Datei module_load.c.

sym_hash symbol_hash_table[]

Makrodefinitionen

Funktionen

Variablen

Makro-Dokumentation

Dokumentation der Funktionen

Variablen-Dokumentation