CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
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_hdrmodule_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_entrymodule_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 837 der Datei module_load.c.

838 {
839  memset(mi, 0, sizeof(ModuleInfo));
840  if (modName)
841  modName[0] = 0; // Only used if module name stored in file (not a LANG string)
842 
843  // Get full path to module file, and hash of path
844  char path[60];
845  get_module_path(path, name);
846 
847  // open file
848  int fd = open(path, O_RDONLY, 0777);
849  if (fd < 0)
850  return;
851 
852  // Read module header only to get size info
853  flat_hdr flat;
854  read(fd, (char*)&flat, sizeof(flat_hdr));
855 
856  // Check version and magic number - make sure it is a CHDK module file
857  if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
858  {
860  read(fd, mi, sizeof(ModuleInfo));
861 
862  if ((mi->moduleName >= 0) && modName)
863  {
864  // Load module name string
865  lseek(fd, mi->moduleName, SEEK_SET);
866  read(fd, modName, modNameLen-1);
867  modName[modNameLen-1] = 0;
868  }
869  }
870 
871  close(fd);
872 }
void module_exit_alt ( )

Definiert in Zeile 791 der Datei module_load.c.

792 {
793  int idx;
794 
795  for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
796  {
797  if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->exit_alt)
798  {
799  // Tell module we are leaving <ALT>
800  modules[idx].hdr->_module_info->lib->exit_alt();
801  }
802  }
803 }
module_entry* module_get_adr ( unsigned int  idx)

Definiert in Zeile 827 der Datei module_load.c.

828 {
829  if ((idx >= 0) && (idx < MAX_NUM_LOADED_MODULES))
830  if (modules[idx].hdr)
831  return &modules[idx];
832  return 0;
833 }
int module_load ( module_handler_t hMod)

Definiert in Zeile 659 der Datei module_load.c.

660 {
661  // Attempt to load module
662  _module_load(hMod);
663 
664  // If load succeeded return success
665  if (*hMod->lib && (*hMod->lib != hMod->default_lib))
666  {
667  return 1;
668  }
669 
670  // If load failed reset library to unloaded default (should not be needed!)
671  if (*hMod->lib == 0)
672  *hMod->lib = hMod->default_lib;
673 
674  // Failure
675  return 0;
676 }
void module_log_clear ( )

Definiert in Zeile 342 der Datei module_load.c.

343 {
344  remove("A/MODULES.LOG");
345 }
flat_hdr* module_preload ( const char *  path,
const char *  name,
_version_t  ver 
)

Definiert in Zeile 517 der Datei module_load.c.

518 {
519  // Allocate buffer and open file
520  int module_fd = b_open(path);
521  if (module_fd <= 0)
522  {
523  moduleload_error(name, "open error");
524  return 0;
525  }
526 
527  // Read module header only to get size info
528  flat_hdr flat;
529  b_read(module_fd, (char*)&flat, sizeof(flat)); // TODO - compare loaded with requested size
530 
531  // Error message
532  char *msg = 0;
533 
534  // Pointer to memory allocated to load module
535  flat_hdr* flat_buf = 0;
536 
537  // Check version and magic number - make sure it is a CHDK module file
538  if ((flat.rev == FLAT_VERSION) && (flat.magic == FLAT_MAGIC_NUMBER))
539  {
540  // Allocate module memory, and load module code
541  msg = load_module_file(module_fd, name, flat.reloc_start, flat.bss_size, &flat_buf);
542  if (msg == 0)
543  {
544  // Module info checks
545  ModuleInfo *mod_info = flat_buf->_module_info = (ModuleInfo*)((unsigned int)flat_buf+flat_buf->_module_info_offset);
546 
547  // Validate version requirements
548  msg = validate(mod_info, ver);
549  if (msg == 0)
550  {
551  // Make relocations
552  msg = link_module(module_fd, flat_buf);
553  }
554  }
555  }
556  else
557  msg = "bad magicnum";
558 
559  // Close file
560  b_close(module_fd);
561 
562  // If any error found, free module memory and display error
563  if (msg)
564  {
565  if (flat_buf)
566  free(flat_buf);
567  moduleload_error(name, msg);
568  return 0;
569  }
570 
571  // TODO these could be changed to operate on affected address ranges only
572  // after relocating but before attempting to execute loaded code
573  // clean data cache to ensure code is in main memory
575  // then flush instruction cache to ensure no addresses containing new code are cached
577 
578  // Return module memory address
579  return flat_buf;
580 }
int module_run ( char *  name)

Definiert in Zeile 754 der Datei module_load.c.

755 {
756  int i;
757  for (i=0; i<MAX_SIMPLE_MODULE; i++)
758  {
759  // Check if module loaded (otherwise name not valid)
760  if (*h_run[i].lib != h_run[i].default_lib)
761  {
762  if (namecmp(name, h_run[i].name))
763  {
764  // Already loaded
765  return (*h_run[i].lib)->run();
766  }
767  }
768  }
769  for (i=0; i<MAX_SIMPLE_MODULE; i++)
770  {
771  // Look for empty slot
772  if (*h_run[i].lib == h_run[i].default_lib)
773  {
774  // Found space - run module
775  strcpy(h_run[i].name, name);
776  return (*h_run[i].lib)->run();
777  }
778  }
779 
780  // Error - no space
782 
783  return -1;
784 }
void module_tick_unloader ( )

Definiert in Zeile 808 der Datei module_load.c.

809 {
810  int idx;
811 
812  for (idx=MAX_NUM_LOADED_MODULES-1; idx>=0; idx--)
813  {
814  if (modules[idx].hdr && modules[idx].hdr->_module_info->lib->can_unload)
815  {
816  // Ask module if it is safe to unload
817  if (modules[idx].hdr->_module_info->lib->can_unload())
818  module_unload_idx(idx);
819  }
820  }
821 }
void module_unload ( const char *  name)

Definiert in Zeile 409 der Datei module_load.c.

410 {
411  // Get full path to module file, and hash of path
412  char path[60];
413  unsigned int hash = get_module_path(path, name);
414 
415  // Find loaded module, and unload it
417 }