toaruos/kernel/include/module.h

#include <types.h>
#include <hashmap.h>

#ifndef MODULE_H
#define MODULE_H

typedef struct {
    char * name;
    int (* initialize)(void);
    int (* finalize)(void);
} module_defs;

typedef struct {
    module_defs * mod_info;
    void * bin_data;
    hashmap_t * symbols;
} module_data_t;

extern void * module_load(char * filename);
extern void module_unload(char * name);
extern void modules_install(void);

#define MODULE_DEF(n,init,fini) \
        module_defs module_info_ ## n = { \
            .name       = #n, \
            .initialize = &init, \
            .finalize   = &fini \
        }

#endif
Initial work on modules There's a lot here, so let's through it: - Lots of work to include a symbol table in the kernel. We can't rely on our bootloader to give us our own ELF information, so we do this separately. This probably should be changed to output a C source rather than assembly, but that's a TODO. - Makefile can now generate modules. It works basically the same way any other kernel object works, expect with a slightly different linking scheme. - Commands have been added to the debug shell to load modules, but they don't work yet - still need to get through relocation and linking. - Commands have been added to the debug shell to print the symbol list, as well as print symbol values (but note that printing symbol values is kinda dangerous if you don't know what they are, so don't just go printing things willy-nilly). 2014-03-09 19:36:28 -07:00			`#include <types.h>`
More real module loading Still need to do proper loading of the ELF sections somewhere, but other than that, we've got a standard interface now. Needs a syscall so we can write an insmod or something like that. 2014-03-11 23:56:08 -07:00			`#include <hashmap.h>`
Initial work on modules There's a lot here, so let's through it: - Lots of work to include a symbol table in the kernel. We can't rely on our bootloader to give us our own ELF information, so we do this separately. This probably should be changed to output a C source rather than assembly, but that's a TODO. - Makefile can now generate modules. It works basically the same way any other kernel object works, expect with a slightly different linking scheme. - Commands have been added to the debug shell to load modules, but they don't work yet - still need to get through relocation and linking. - Commands have been added to the debug shell to print the symbol list, as well as print symbol values (but note that printing symbol values is kinda dangerous if you don't know what they are, so don't just go printing things willy-nilly). 2014-03-09 19:36:28 -07:00
			`#ifndef MODULE_H`
			`#define MODULE_H`

			`typedef struct {`
More real module loading Still need to do proper loading of the ELF sections somewhere, but other than that, we've got a standard interface now. Needs a syscall so we can write an insmod or something like that. 2014-03-11 23:56:08 -07:00			`char * name;`
			`int (* initialize)(void);`
			`int (* finalize)(void);`
Initial work on modules There's a lot here, so let's through it: - Lots of work to include a symbol table in the kernel. We can't rely on our bootloader to give us our own ELF information, so we do this separately. This probably should be changed to output a C source rather than assembly, but that's a TODO. - Makefile can now generate modules. It works basically the same way any other kernel object works, expect with a slightly different linking scheme. - Commands have been added to the debug shell to load modules, but they don't work yet - still need to get through relocation and linking. - Commands have been added to the debug shell to print the symbol list, as well as print symbol values (but note that printing symbol values is kinda dangerous if you don't know what they are, so don't just go printing things willy-nilly). 2014-03-09 19:36:28 -07:00			`} module_defs;`

More real module loading Still need to do proper loading of the ELF sections somewhere, but other than that, we've got a standard interface now. Needs a syscall so we can write an insmod or something like that. 2014-03-11 23:56:08 -07:00			`typedef struct {`
			`module_defs * mod_info;`
			`void * bin_data;`
			`hashmap_t * symbols;`
			`} module_data_t;`

			`extern void * module_load(char * filename);`
			`extern void module_unload(char * name);`
			`extern void modules_install(void);`

			`#define MODULE_DEF(n,init,fini) \`
			`module_defs module_info_ ## n = { \`
			`.name = #n, \`
			`.initialize = &init, \`
			`.finalize = &fini \`
			`}`

Initial work on modules There's a lot here, so let's through it: - Lots of work to include a symbol table in the kernel. We can't rely on our bootloader to give us our own ELF information, so we do this separately. This probably should be changed to output a C source rather than assembly, but that's a TODO. - Makefile can now generate modules. It works basically the same way any other kernel object works, expect with a slightly different linking scheme. - Commands have been added to the debug shell to load modules, but they don't work yet - still need to get through relocation and linking. - Commands have been added to the debug shell to print the symbol list, as well as print symbol values (but note that printing symbol values is kinda dangerous if you don't know what they are, so don't just go printing things willy-nilly). 2014-03-09 19:36:28 -07:00			`#endif`