moduleops_core.c

   1 /* Load the given section: NULL on error. */
   2 static void *PERBIT(load_section)(ElfPERBIT(Ehdr) *hdr,
   3                             const char *secname,
   4                             unsigned long *size,
   5                             int conv)
   6 {
   7         ElfPERBIT(Shdr) *sechdrs;
   8         unsigned int i;
   9         char *secnames;
  10
  11         /* Grab section headers and strings so we can tell who is who */
  12         sechdrs = (void *)hdr + END(hdr->e_shoff, conv);
  13         secnames = (void *)hdr
  14                 + END(sechdrs[END(hdr->e_shstrndx, conv)].sh_offset, conv);
  15
  16         /* Find the section they want */
  17         for (i = 1; i < END(hdr->e_shnum, conv); i++) {
  18                 if (streq(secnames+END(sechdrs[i].sh_name, conv), secname)) {
  19                         *size = END(sechdrs[i].sh_size, conv);
  20                         return (void *)hdr + END(sechdrs[i].sh_offset, conv);
  21                 }
  22         }
  23         *size = 0;
  24         return NULL;
  25 }
  26
  27 static void PERBIT(load_symbols)(struct module *module)
  28 {
  29         struct PERBIT(kernel_symbol) *ksyms;
  30         char *ksymstrings;
  31         unsigned long i, size;
  32
  33         /* New-style: strings are in this section. */
  34         ksymstrings = PERBIT(load_section)(module->data, "__ksymtab_strings",
  35                                            &size, module->conv);
  36         if (ksymstrings) {
  37                 unsigned int i = 0;
  38                 for (;;) {
  39                         /* Skip any zero padding. */
  40                         while (!ksymstrings[i])
  41                                 if (++i >= size)
  42                                         return;
  43                         add_symbol(ksymstrings+i, module);
  44                         i += strlen(ksymstrings+i);
  45                 }
  46                 /* GPL symbols too */
  47                 ksymstrings = PERBIT(load_section)(module->data,
  48                                                    "__ksymtab_strings_gpl",
  49                                                    &size, module->conv);
  50                 for (;;) {
  51                         /* Skip any zero padding. */
  52                         while (!ksymstrings[i])
  53                                 if (++i >= size)
  54                                         return;
  55                         add_symbol(ksymstrings+i, module);
  56                         i += strlen(ksymstrings+i);
  57                 }
  58                 return;
  59         }
  60
  61         /* Old-style. */
  62         ksyms = PERBIT(load_section)(module->data, "__ksymtab", &size,
  63                                      module->conv);
  64         for (i = 0; i < size / sizeof(struct PERBIT(kernel_symbol)); i++)
  65                 add_symbol(ksyms[i].name, module);
  66         ksyms = PERBIT(load_section)(module->data, "__gpl_ksymtab", &size,
  67                                      module->conv);
  68         for (i = 0; i < size / sizeof(struct PERBIT(kernel_symbol)); i++)
  69                 add_symbol(ksyms[i].name, module);
  70 }
  71
  72 static char *PERBIT(get_aliases)(struct module *module, unsigned long *size)
  73 {
  74         return PERBIT(load_section)(module->data, ".modalias", size,
  75                                     module->conv);
  76 }
  77
  78 static char *PERBIT(get_modinfo)(struct module *module, unsigned long *size)
  79 {
  80         return PERBIT(load_section)(module->data, ".modinfo", size,
  81                                     module->conv);
  82 }
  83
  84 #ifndef STT_REGISTER
  85 #define STT_REGISTER    13              /* Global register reserved to app. */
  86 #endif
  87
  88 /* Calculate the dependencies for this module */
  89 static void PERBIT(calculate_deps)(struct module *module, int verbose)
  90 {
  91         unsigned int i;
  92         unsigned long size;
  93         char *strings;
  94         ElfPERBIT(Sym) *syms;
  95         ElfPERBIT(Ehdr) *hdr;
  96         int handle_register_symbols;
  97
  98         strings = PERBIT(load_section)(module->data, ".strtab", &size,
  99                                        module->conv);
 100         syms = PERBIT(load_section)(module->data, ".symtab", &size,
 101                                     module->conv);
 102
 103         module->num_deps = 0;
 104         module->deps = NULL;
 105
 106         if (!strings || !syms) {
 107                 warn("Couldn't find symtab and strtab in module %s\n",
 108                      module->pathname);
 109                 return;
 110         }
 111
 112         hdr = module->data;
 113         handle_register_symbols = 0;
 114         if (END(hdr->e_machine, module->conv) == EM_SPARC ||
 115             END(hdr->e_machine, module->conv) == EM_SPARCV9)
 116                 handle_register_symbols = 1;
 117
 118         for (i = 1; i < size / sizeof(syms[0]); i++) {
 119                 if (END(syms[i].st_shndx, module->conv) == SHN_UNDEF) {
 120                         /* Look for symbol */
 121                         const char *name;
 122                         struct module *owner;
 123                         int weak;
 124
 125                         name = strings + END(syms[i].st_name, module->conv);
 126
 127                         /* Not really undefined: sparc gcc 3.3 creates
 128                            U references when you have global asm
 129                            variables, to avoid anyone else misusing
 130                            them. */
 131                         if (handle_register_symbols
 132                             && (ELFPERBIT(ST_TYPE)(END(syms[i].st_info,
 133                                                        module->conv))
 134                                 == STT_REGISTER))
 135                                 continue;
 136
 137                         weak = (ELFPERBIT(ST_BIND)(END(syms[i].st_info,
 138                                                        module->conv))
 139                                 == STB_WEAK);
 140                         owner = find_symbol(name, module->pathname, weak);
 141                         if (owner) {
 142                                 if (verbose)
 143                                         printf("%s needs \"%s\": %s\n",
 144                                                module->pathname, name,
 145                                                owner->pathname);
 146                                 add_dep(module, owner);
 147                         }
 148                 }
 149         }
 150 }
 151
 152 static void *PERBIT(deref_sym)(ElfPERBIT(Ehdr) *hdr, const char *name,
 153                                unsigned int *secsize,
 154                                int conv)
 155 {
 156         unsigned int i;
 157         unsigned long size;
 158         char *strings;
 159         ElfPERBIT(Sym) *syms;
 160         ElfPERBIT(Shdr) *sechdrs;
 161
 162         sechdrs = (void *)hdr + END(hdr->e_shoff, conv);
 163         strings = PERBIT(load_section)(hdr, ".strtab", &size, conv);
 164         syms = PERBIT(load_section)(hdr, ".symtab", &size, conv);
 165
 166         /* Don't warn again: we already have above */
 167         if (!strings || !syms)
 168                 return NULL;
 169
 170         for (i = 0; i < size / sizeof(syms[0]); i++) {
 171                 if (streq(strings + END(syms[i].st_name, conv), name)) {
 172                         /* In BSS?  Happens for empty device tables on
 173                          * recent GCC versions. */
 174                         if (END(sechdrs[END(syms[i].st_shndx, conv)].sh_type,
 175                                 conv) == SHT_NOBITS)
 176                                 return NULL;
 177                         if (secsize)
 178                                 *secsize = END(syms[i].st_size, conv);
 179                         return (void *)hdr
 180                                 + END(sechdrs[END(syms[i].st_shndx, conv)]
 181                                       .sh_offset, conv)
 182                                 + END(syms[i].st_value, conv);
 183                 }
 184         }
 185         return NULL;
 186 }
 187
 188 /* FIXME: Check size, unless we end up using aliases anyway --RR */
 189 static void PERBIT(fetch_tables)(struct module *module)
 190 {
 191         module->pci_size = PERBIT(PCI_DEVICE_SIZE);
 192         module->pci_table = PERBIT(deref_sym)(module->data,
 193                                         "__mod_pci_device_table",
 194                                         NULL, module->conv);
 195
 196         module->usb_size = PERBIT(USB_DEVICE_SIZE);
 197         module->usb_table = PERBIT(deref_sym)(module->data,
 198                                         "__mod_usb_device_table",
 199                                         NULL, module->conv);
 200
 201         module->ccw_size = PERBIT(CCW_DEVICE_SIZE);
 202         module->ccw_table = PERBIT(deref_sym)(module->data,
 203                                         "__mod_ccw_device_table",
 204                                         NULL, module->conv);
 205
 206         module->ieee1394_size = PERBIT(IEEE1394_DEVICE_SIZE);
 207         module->ieee1394_table = PERBIT(deref_sym)(module->data,
 208                                         "__mod_ieee1394_device_table",
 209                                         NULL, module->conv);
 210
 211         module->pnp_size = PERBIT(PNP_DEVICE_SIZE);
 212         module->pnp_table = PERBIT(deref_sym)(module->data,
 213                                         "__mod_pnp_device_table",
 214                                         NULL, module->conv);
 215
 216         module->pnp_card_size = PERBIT(PNP_CARD_DEVICE_SIZE);
 217         module->pnp_card_table = PERBIT(deref_sym)(module->data,
 218                                         "__mod_pnp_card_device_table",
 219                                         NULL, module->conv);
 220         module->pnp_card_offset = PERBIT(PNP_CARD_DEVICE_OFFSET);
 221
 222         module->input_size = PERBIT(INPUT_DEVICE_SIZE);
 223         module->input_table = PERBIT(deref_sym)(module->data,
 224                                         "__mod_input_device_table",
 225                                         &module->input_table_size,
 226                                                 module->conv);
 227
 228         module->serio_size = PERBIT(SERIO_DEVICE_SIZE);
 229         module->serio_table = PERBIT(deref_sym)(module->data,
 230                                         "__mod_serio_device_table",
 231                                         NULL, module->conv);
 232
 233         module->of_size = PERBIT(OF_DEVICE_SIZE);
 234         module->of_table = PERBIT(deref_sym)(module->data,
 235                                         "__mod_of_device_table",
 236                                         NULL, module->conv);
 237 }
 238
 239 struct module_ops PERBIT(mod_ops) = {
 240         .load_symbols   = PERBIT(load_symbols),
 241         .calculate_deps = PERBIT(calculate_deps),
 242         .fetch_tables   = PERBIT(fetch_tables),
 243         .get_aliases    = PERBIT(get_aliases),
 244         .get_modinfo    = PERBIT(get_modinfo),
 245 };