doc/modules.txt

   1 Modules
   2 =======
   3
   4 Concepts
   5 --------
   6
   7 A kernel module is an object file which can be loaded into the kernel at
   8 run-time, rather than being compiled into the kernel directly.
   9
  10 Each kernel module has an entry point (`_start`) and can reference symbols in
  11 the kernel, as well as symbols in other modules.
  12
  13 Modules are *trusted*. They run with full kernel privileges.
  14
  15 The Module Loader
  16 -----------------
  17
  18 The module loader loads a kernel module and patches up the relocations for
  19 execution. It also resolves references to kernel symbols, and symbols in other
  20 modules.
  21
  22 When the module is ready to run, it calls the `_start` function of the module.
  23 Note that the `_start` function is not given its own thread! It is expected to
  24 call various kernel functions to install itself, and then return.
  25
  26 The `modinit` section
  27 ---------------------
  28
  29 Kernel modules have a section called `modinit`. This section contains an array
  30 of function pointers to initialisation functions. If you're familiar with the
  31 `.ctors` sections of C++, `modinit` works in exactly the same way.
  32
  33 If a module is actually built as a kernel module, it is linked with
  34 `kernel/module-entry.c`, which provides the entry point `_start` and calls each
  35 function in the `modinit` section in turn.
  36
  37 This produces some desirable effects:
  38
  39 - Modules can be linked together into a supermodule, with no code changes. This
  40   will merge .text, .data and .bss sections of the modules together and will
  41   save memory that would otherwise be wasted due to alignment. For example, it
  42   may be useful for a user to link together all the modules they know they need.
  43
  44 - Modules can even be linked statically into the kernel! The kernel can look in
  45   its own `modinit` section for the module initialisation functions. This means
  46   that modules can be compiled into the kernel, or compiled as separate modules,
  47   very easily.
  48
  49 Problems
  50 ~~~~~~~~
  51
  52 The `modinit` section does not take into account module dependencies. For
  53 example, if module A uses module B, module B would have to be initialised before
  54 A, although currently the initialisation order would depend on the order of the
  55 linker arguments!
  56
  57 Kernel symbols
  58 --------------
  59
  60 The kernel symbols are read from the ELF symbol table. The multiboot boot loader
  61 loads all the ELF sections in the kernel, including the symbol table, and gives
  62 the kernel the address of the section headers. The kernel can use this to find
  63 the address of the symbol table, and read in all the symbols.