_IMPLEMENTING LOADABLE KERNEL MODULES FOR LINUX_
by Matt Welsh

Listing One

/* Header for a.out object and executable files. */
struct exec {
    unsigned long a_info;  /* Describes object file. */
    unsigned a_text;       /* Length of text segment in bytes */
    unsigned a_data;       /* Length of data segment */
    unsigned a_bss;        /* Length of BSS segment */
    unsigned a_syms;       /* Length of symbol table */
    unsigned a_entry;      /* Entry point address */
    unsigned a_trsize;     /* Length of text relocation info */
    unsigned a_drsize;     /* Length of data relocation info */
};
/* The object file symbol table is an array of struct nlist. */
struct nlist {
    union {
      /* Only one of the following are available, based on
       * context. E.g., n_strx is used when the data is stored
       * in a file, n_name when in core.
       */
      char *n_name;          /* Symbol name */
      struct nlist *n_next;  /* Next symbol in list */
      long n_strx;           /* Index to 
    } n_un;
    unsigned char n_type;    /* Type of symbol, e.g., text or data */
    char n_other;            /* Unused by the system, but useful for insmod */
    short n_desc;            /* Used by symbolic debuggers */
    unsigned n_value;        /* Address of this symbol */
};
/* Binary tree of symbols used for relocation. Defined by insmod. */
struct symbol {
    struct nlist n;
    struct symbol *child[2];
};
/* Relocation information stored in the module object file */
struct relocation_info {
    int r_address;               /* Address to be relocated */
    unsigned int r_symbolnum:24; /* Index of symbol in symbol table */
    unsigned int r_pcrel:1;      /* 1 for PC-relative offset */
    unsigned int r_length:2;     /* Relocate (1<<r_length) bytes */
    unsigned int r_extern:1;     /* 1 if relocating with addr of symbol */
    unsigned int r_pad:4;        /* Unused */
};


Listing Two

/* Obtains list of symbols from kernel for module relocation */
int get_kernel_syms(struct kernel_sym *table);

/* Allows kernel to allocate space for module */
int create_module(char *module_name, unsigned long size);

/* Sends module code and data to kernel, as well as init/cleanup
 * routines and symbol table used by module. */
int init_module(char *module_name, char *code, unsigned codesize,
  struct mod_routines *routines, struct symbol_table *symtab);

/* Removes module from kernel */
int delete_module(char *module_name);

/* An array of struct kernel_sym is returned by get_kernel_syms */
struct kernel_sym {
  unsigned long value;       /* Symbol value */
  char name[SYM_MAX_NAME];   /* Symbol name */
};
/* The init and cleanup functions provided by the module */
struct mod_routines {
  int (*init)(void);         /* Module init routine */
  void (*cleanup)(void);     /* Module cleanup routine */
};
/* Symbol table passed to init_module */
struct symbol_table {
  int size;                  /* Total size, including string table */
  int n_symbols;             /* Number of symbols */
  int n_refs;                /* Number of module references */
  struct internal_symbol symbol[0];  /* Array of symbols; space
                                      * allocated elsewhere */
  struct module_ref ref[0];          /* Array of module references */
};
/* Symbols provided by the module */
struct internal_symbol {
  void *addr;               /* Address of symbol */
  char *name;               /* Name of symbol */
};
/* Reference to another module. */
struct module_ref {
  struct module *module;   /* Module referenced */
  struct module_ref *next; /* Next module in list */
};
/* Kernel data structure describing a module */
struct module {
  struct module *next;         /* Next module in list */
  struct module_ref *ref;      /* List of modules referring to this one */
  struct symbol_table *symtab; /* Symbol table given to init_module */
  char *name;                  /* Name of module */
  int size;                    /* Size of module in (4K) pages */
  void* addr;                  /* Address of module code in kernel */
  int state;                   /* State (running, deleted, uninitialized) */
  void (*cleanup)(void);       /* Cleanup function */
};