elfops_core.c

   1 #if defined(ELF32BIT)
   2
   3 #define PERBIT(x) x##32
   4 #define ElfPERBIT(x) Elf32_##x
   5 #define ELFPERBIT(x) ELF32_##x
   6 /* 32-bit unsigned integer */
   7 #define Elf32_Uint Elf32_Word
   8
   9 #elif defined(ELF64BIT)
  10
  11 #define PERBIT(x) x##64
  12 #define ElfPERBIT(x) Elf64_##x
  13 #define ELFPERBIT(x) ELF64_##x
  14 /* 64-bit unsigned integer */
  15 #define Elf64_Uint Elf64_Xword
  16
  17 #else
  18 #  error "Undefined ELF word length"
  19 #endif
  20
  21 static void *PERBIT(get_section)(struct elf_file *module,
  22                                  const char *secname,
  23                                  ElfPERBIT(Shdr) **sechdr,
  24                                  unsigned long *secsize)
  25 {
  26         void *data = module->data;
  27         unsigned long len = module->len;
  28         int conv = module->conv;
  29
  30         ElfPERBIT(Ehdr) *hdr;
  31         ElfPERBIT(Shdr) *sechdrs;
  32         ElfPERBIT(Off) e_shoff;
  33         ElfPERBIT(Half) e_shnum, e_shstrndx;
  34         ElfPERBIT(Off) secoffset;
  35
  36         const char *secnames;
  37         unsigned int i;
  38
  39         *secsize = 0;
  40
  41         if (len <= 0 || len < sizeof(*hdr))
  42                 return NULL;
  43
  44         hdr = data;
  45         e_shoff = END(hdr->e_shoff, conv);
  46         e_shnum = END(hdr->e_shnum, conv);
  47         e_shstrndx = END(hdr->e_shstrndx, conv);
  48
  49         if (len < e_shoff + e_shnum * sizeof(sechdrs[0]))
  50                 return NULL;
  51
  52         sechdrs = data + e_shoff;
  53
  54         if (len < END(sechdrs[e_shstrndx].sh_offset, conv))
  55                 return NULL;
  56
  57         /* Find section by name; return header, pointer and size. */
  58         secnames = data + END(sechdrs[e_shstrndx].sh_offset, conv);
  59         for (i = 1; i < e_shnum; i++) {
  60                 if (streq(secnames + END(sechdrs[i].sh_name, conv), secname)) {
  61                         *secsize = END(sechdrs[i].sh_size, conv);
  62                         secoffset = END(sechdrs[i].sh_offset, conv);
  63                         if (sechdr)
  64                                 *sechdr = sechdrs + i;
  65                         if (len < secoffset + *secsize)
  66                                 return NULL;
  67                         return data + secoffset;
  68                 }
  69         }
  70         return NULL;
  71 }
  72
  73 /* Load the given section: NULL on error. */
  74 static void *PERBIT(load_section)(struct elf_file *module,
  75                                   const char *secname,
  76                                   unsigned long *secsize)
  77 {
  78         return PERBIT(get_section)(module, secname, NULL, secsize);
  79 }
  80
  81 static struct string_table *PERBIT(load_strings)(struct elf_file *module,
  82                                                  const char *secname,
  83                                                  struct string_table *tbl,
  84                                                  errfn_t error)
  85 {
  86         unsigned long size;
  87         const char *strings;
  88
  89         strings = PERBIT(load_section)(module, secname, &size);
  90         if (strings) {
  91                 /* Skip any zero padding. */
  92                 while (!strings[0]) {
  93                         strings++;
  94                         if (size-- <= 1)
  95                                 return tbl;
  96                 }
  97                 for (; strings; strings = next_string(strings, &size))
  98                         tbl = NOFAIL(strtbl_add(strings, tbl));
  99         }
 100         return tbl;
 101 }
 102
 103 static struct string_table *PERBIT(load_symbols)(struct elf_file *module,
 104                                                  uint64_t **versions)
 105 {
 106         struct string_table *symtbl = NULL;
 107
 108         if (versions) {
 109                 static const char crc[] = "__crc_";
 110                 static const int crc_len = sizeof(crc) - 1;
 111                 unsigned int num_syms, i;
 112                 unsigned long size;
 113                 ElfPERBIT(Sym) *syms;
 114                 char *strings;
 115                 int conv;
 116
 117                 *versions = NULL;
 118                 strings = PERBIT(load_section)(module, ".strtab", &size);
 119                 syms = PERBIT(load_section)(module, ".symtab", &size);
 120                 if (!strings || !syms)
 121                         goto fallback;
 122                 num_syms = size / sizeof(syms[0]);
 123                 *versions = NOFAIL(calloc(sizeof(**versions), num_syms));
 124
 125                 conv = module->conv;
 126                 for (i = 1; i < num_syms; i++) {
 127                         const char *name;
 128                         name = strings + END(syms[i].st_name, conv);
 129                         if (strncmp(name, crc, crc_len) != 0)
 130                                 continue;
 131                         name += crc_len;
 132                         symtbl = NOFAIL(strtbl_add(name, symtbl));
 133                         (*versions)[symtbl->cnt - 1] = END(syms[i].st_value,
 134                                         conv);
 135                 }
 136                 if (!symtbl) {
 137                         /* Either this module does not export any symbols, or
 138                          * it was compiled without CONFIG_MODVERSIONS. If the
 139                          * latter, we will print a warning in load_dep_syms,
 140                          * so just silently fallback to __ksymtab_strings in
 141                          * both cases.
 142                          */
 143                         free(*versions);
 144                         *versions = NULL;
 145                         goto fallback;
 146                 }
 147                 return symtbl;
 148         }
 149 fallback:
 150         return PERBIT(load_strings)(module, "__ksymtab_strings", symtbl,
 151                         fatal);
 152 }
 153
 154 static char *PERBIT(get_aliases)(struct elf_file *module, unsigned long *size)
 155 {
 156         return PERBIT(load_section)(module, ".modalias", size);
 157 }
 158
 159 static char *PERBIT(get_modinfo)(struct elf_file *module, unsigned long *size)
 160 {
 161         return PERBIT(load_section)(module, ".modinfo", size);
 162 }
 163
 164 #ifndef STT_REGISTER
 165 #define STT_REGISTER    13              /* Global register reserved to app. */
 166 #endif
 167
 168 static struct string_table *PERBIT(load_dep_syms)(struct elf_file *module,
 169                                                   struct string_table **types,
 170                                                   uint64_t **versions)
 171 {
 172         unsigned int i, num_syms;
 173         unsigned int j, num_symvers, versions_size;
 174         unsigned long size;
 175         char *strings;
 176         ElfPERBIT(Sym) *syms;
 177         ElfPERBIT(Ehdr) *hdr;
 178         struct PERBIT(modver_info) **symvers;
 179         int handle_register_symbols;
 180         struct string_table *names;
 181         int conv;
 182
 183         names = NULL;
 184         *types = NULL;
 185         symvers = NULL;
 186         num_symvers = versions_size = 0;
 187
 188         if (versions) {
 189                 int ok = 1;
 190                 *versions = NULL;
 191                 struct PERBIT(modver_info) *symvers_sec;
 192
 193                 symvers_sec = module->ops->load_section(module, "__versions",
 194                                 &size);
 195                 if (!symvers_sec) {
 196                         warn("%s is built without modversions",
 197                                         module->pathname);
 198                         ok = 0;
 199                 }
 200                 if (size % sizeof(symvers[0]) != 0) {
 201                         warn("invalid __versions section size in %s",
 202                                         module->pathname);
 203                         ok = 0;
 204                 }
 205                 if (ok) {
 206                         num_symvers = size / sizeof(symvers_sec[0]);
 207                         /* symvers is used to keep track of each visited entry.
 208                          * The table also contains the fake struct_module /
 209                          * module_layout symbol which we don't want to miss.
 210                          */
 211                         symvers = NOFAIL(malloc(num_symvers *
 212                                                 sizeof(symvers[0])));
 213                         for (j = 0; j < num_symvers; j++)
 214                                 symvers[j] = &symvers_sec[j];
 215                 } else {
 216                         versions = NULL;
 217                 }
 218         }
 219
 220         strings = PERBIT(load_section)(module, ".strtab", &size);
 221         syms = PERBIT(load_section)(module, ".symtab", &size);
 222         if (!strings || !syms) {
 223                 warn("Couldn't find symtab and strtab in module %s\n",
 224                      module->pathname);
 225                 goto out;
 226         }
 227
 228         num_syms = size / sizeof(syms[0]);
 229         hdr = module->data;
 230         conv = module->conv;
 231         if (versions) {
 232                 versions_size = num_syms;
 233                 *versions = NOFAIL(calloc(sizeof(**versions), versions_size));
 234         }
 235
 236         handle_register_symbols =
 237                 (END(hdr->e_machine, conv) == EM_SPARC ||
 238                  END(hdr->e_machine, conv) == EM_SPARCV9);
 239
 240         for (i = 1; i < num_syms; i++) {
 241                 if (END(syms[i].st_shndx, conv) == SHN_UNDEF) {
 242                         /* Look for symbol */
 243                         const char *name;
 244                         int weak;
 245
 246                         name = strings + END(syms[i].st_name, conv);
 247
 248                         /* Not really undefined: sparc gcc 3.3 creates
 249                            U references when you have global asm
 250                            variables, to avoid anyone else misusing
 251                            them. */
 252                         if (handle_register_symbols
 253                             && (ELFPERBIT(ST_TYPE)(END(syms[i].st_info, conv))
 254                                 == STT_REGISTER))
 255                                 continue;
 256
 257                         weak = (ELFPERBIT(ST_BIND)(END(syms[i].st_info, conv))
 258                                 == STB_WEAK);
 259                         names = NOFAIL(strtbl_add(name, names));
 260                         *types = NOFAIL(strtbl_add(weak ? weak_sym : undef_sym,
 261                                 *types));
 262
 263                         if (!versions)
 264                                 continue;
 265                         /* Not optimal, but the number of required symbols
 266                          * is usually not huge and this is only called by
 267                          * depmod.
 268                          */
 269                         for (j = 0; j < num_symvers; j++) {
 270                                 struct PERBIT(modver_info) *info = symvers[j];
 271
 272                                 if (!info)
 273                                         continue;
 274                                 if (streq(name, info->name)) {
 275                                         (*versions)[names->cnt - 1] =
 276                                                 END(info->crc, conv);
 277                                         symvers[j] = NULL;
 278                                         break;
 279                                 }
 280                         }
 281                 }
 282         }
 283         /* add struct_module / module_layout */
 284         for (j = 0; j < num_symvers; j++) {
 285                 struct PERBIT(modver_info) *info = symvers[j];
 286
 287                 if (!info)
 288                         continue;
 289                 if ((names ? names->cnt : 0) >= versions_size) {
 290                         versions_size++;
 291                         *versions = NOFAIL(realloc(*versions, versions_size));
 292                 }
 293                 names = NOFAIL(strtbl_add(info->name, names));
 294                 *types = NOFAIL(strtbl_add(undef_sym, *types));
 295                 (*versions)[names->cnt - 1] = END(info->crc, conv);
 296         }
 297 out:
 298         free(symvers);
 299         return names;
 300 }
 301
 302 static void *PERBIT(deref_sym)(ElfPERBIT(Ehdr) *hdr,
 303                                ElfPERBIT(Shdr) *sechdrs,
 304                                ElfPERBIT(Sym) *sym,
 305                                unsigned int *secsize,
 306                                int conv)
 307 {
 308         /* In BSS?  Happens for empty device tables on
 309          * recent GCC versions. */
 310         if (END(sechdrs[END(sym->st_shndx, conv)].sh_type,conv) == SHT_NOBITS)
 311                 return NULL;
 312
 313         if (secsize)
 314                 *secsize = END(sym->st_size, conv);
 315         return (void *)hdr
 316                 + END(sechdrs[END(sym->st_shndx, conv)].sh_offset, conv)
 317                 + END(sym->st_value, conv);
 318 }
 319
 320 /* FIXME: Check size, unless we end up using aliases anyway --RR */
 321 static void PERBIT(fetch_tables)(struct elf_file *module,
 322                                  struct module_tables *tables)
 323 {
 324         unsigned int i;
 325         unsigned long size;
 326         char *strings;
 327         ElfPERBIT(Ehdr) *hdr;
 328         ElfPERBIT(Sym) *syms;
 329         ElfPERBIT(Shdr) *sechdrs;
 330         int conv;
 331
 332         hdr = module->data;
 333         conv = module->conv;
 334
 335         sechdrs = (void *)hdr + END(hdr->e_shoff, conv);
 336         strings = PERBIT(load_section)(module, ".strtab", &size);
 337         syms = PERBIT(load_section)(module, ".symtab", &size);
 338
 339         /* Don't warn again: we already have above */
 340         if (!strings || !syms)
 341                 return;
 342
 343         memset(tables, 0x00, sizeof(struct module_tables));
 344
 345         for (i = 0; i < size / sizeof(syms[0]); i++) {
 346                 char *name = strings + END(syms[i].st_name, conv);
 347
 348                 if (!tables->pci_table && streq(name, "__mod_pci_device_table")) {
 349                         tables->pci_size = PERBIT(PCI_DEVICE_SIZE);
 350                         tables->pci_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 351                                                               NULL, conv);
 352                 }
 353                 else if (!tables->usb_table && streq(name, "__mod_usb_device_table")) {
 354                         tables->usb_size = PERBIT(USB_DEVICE_SIZE);
 355                         tables->usb_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 356                                                               NULL, conv);
 357                 }
 358                 else if (!tables->ccw_table && streq(name, "__mod_ccw_device_table")) {
 359                         tables->ccw_size = PERBIT(CCW_DEVICE_SIZE);
 360                         tables->ccw_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 361                                                               NULL, conv);
 362                 }
 363                 else if (!tables->ieee1394_table && streq(name, "__mod_ieee1394_device_table")) {
 364                         tables->ieee1394_size = PERBIT(IEEE1394_DEVICE_SIZE);
 365                         tables->ieee1394_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 366                                                                    NULL, conv);
 367                 }
 368                 else if (!tables->pnp_table && streq(name, "__mod_pnp_device_table")) {
 369                         tables->pnp_size = PERBIT(PNP_DEVICE_SIZE);
 370                         tables->pnp_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 371                                                               NULL, conv);
 372                 }
 373                 else if (!tables->pnp_card_table && streq(name, "__mod_pnp_card_device_table")) {
 374                         tables->pnp_card_size = PERBIT(PNP_CARD_DEVICE_SIZE);
 375                         tables->pnp_card_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 376                                                                    NULL, conv);
 377                         tables->pnp_card_offset = PERBIT(PNP_CARD_DEVICE_OFFSET);
 378                 }
 379                 else if (!tables->input_table && streq(name, "__mod_input_device_table")) {
 380                         tables->input_size = PERBIT(INPUT_DEVICE_SIZE);
 381                         tables->input_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 382                                                                 &tables->input_table_size,
 383                                                                 conv);
 384                 }
 385                 else if (!tables->serio_table && streq(name, "__mod_serio_device_table")) {
 386                         tables->serio_size = PERBIT(SERIO_DEVICE_SIZE);
 387                         tables->serio_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 388                                                                 NULL, conv);
 389                 }
 390                 else if (!tables->of_table && streq(name, "__mod_of_device_table")) {
 391                         tables->of_size = PERBIT(OF_DEVICE_SIZE);
 392                         tables->of_table = PERBIT(deref_sym)(hdr, sechdrs, &syms[i],
 393                                                              NULL, conv);
 394                 }
 395         }
 396 }
 397
 398 /*
 399  * strip_section - tell the kernel to ignore the named section
 400  */
 401 static void PERBIT(strip_section)(struct elf_file *module, const char *secname)
 402 {
 403         void *p;
 404         ElfPERBIT(Shdr) *sechdr;
 405         unsigned long secsize;
 406
 407         p = PERBIT(get_section)(module, secname, &sechdr, &secsize);
 408         if (p) {
 409                 ElfPERBIT(Uint) mask;
 410                 mask = ~((ElfPERBIT(Uint))SHF_ALLOC);
 411                 sechdr->sh_flags &= END(mask, module->conv);
 412         }
 413 }
 414
 415 static int PERBIT(dump_modversions)(struct elf_file *module)
 416 {
 417         unsigned long secsize;
 418         struct PERBIT(modver_info) *info;
 419         int n = 0;
 420
 421         info = module->ops->load_section(module, "__versions", &secsize);
 422         if (!info)
 423                 return 0; /* not a kernel module */
 424         if (secsize % sizeof(*info) != 0)
 425                 return -1; /* invalid section size */
 426
 427         for (n = 0; n < secsize / sizeof(*info); n++) {
 428 #if defined(ELF32BIT)
 429                 printf("0x%08lx\t%s\n", (unsigned long)
 430 #else /* defined(ELF64BIT) */
 431                 printf("0x%08llx\t%s\n", (unsigned long long)
 432 #endif
 433                         END(info[n].crc, module->conv),
 434                         skip_dot(info[n].name));
 435         }
 436         return n;
 437 }
 438
 439 struct module_ops PERBIT(mod_ops) = {
 440         .load_section   = PERBIT(load_section),
 441         .load_strings   = PERBIT(load_strings),
 442         .load_symbols   = PERBIT(load_symbols),
 443         .load_dep_syms  = PERBIT(load_dep_syms),
 444         .fetch_tables   = PERBIT(fetch_tables),
 445         .get_aliases    = PERBIT(get_aliases),
 446         .get_modinfo    = PERBIT(get_modinfo),
 447         .strip_section  = PERBIT(strip_section),
 448         .dump_modvers   = PERBIT(dump_modversions),
 449 };
 450
 451 #undef PERBIT
 452 #undef ElfPERBIT
 453 #undef ELFPERBIT