module_load.h-Dateireferenz

#include "module_def.h"

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

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	module_handler_t
struct	module_entry

Makrodefinitionen
#define	MAX_NUM_LOADED_MODULES   10

Funktionen
flat_hdr *	module_preload (const char *path, const char *name, _version_t ver)
int	module_load (module_handler_t *hMod)
void	module_unload (const char *name)
void	get_module_info (const char *name, ModuleInfo *mi, char *modName, int modNameLen)
int	module_run (char *name)
module_entry *	module_get_adr (unsigned int idx)
void	module_exit_alt ()
void	module_tick_unloader ()
void	module_log_clear ()

Makro-Dokumentation

#define MAX_NUM_LOADED_MODULES   10

Definiert in Zeile 8 der Datei module_load.h.

Dokumentation der Funktionen

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);
}

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();
        }
    }
}

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");
}

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;
}

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));
}