modutils/modutils-24.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini insmod implementation for busybox
   4  *
   5  * This version of insmod supports ARM, CRIS, H8/300, x86, ia64, x86_64,
   6  * m68k, MIPS, PowerPC, S390, SH3/4/5, Sparc, v850e, and x86_64.
   7  *
   8  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
   9  * and Ron Alder <alder@lineo.com>
  10  *
  11  * Rodney Radford <rradford@mindspring.com> 17-Aug-2004.
  12  *   Added x86_64 support.
  13  *
  14  * Miles Bader <miles@gnu.org> added NEC V850E support.
  15  *
  16  * Modified by Bryan Rittmeyer <bryan@ixiacom.com> to support SH4
  17  * and (theoretically) SH3. I have only tested SH4 in little endian mode.
  18  *
  19  * Modified by Alcove, Julien Gaulmin <julien.gaulmin@alcove.fr> and
  20  * Nicolas Ferre <nicolas.ferre@alcove.fr> to support ARM7TDMI.  Only
  21  * very minor changes required to also work with StrongArm and presumably
  22  * all ARM based systems.
  23  *
  24  * Yoshinori Sato <ysato@users.sourceforge.jp> 19-May-2004.
  25  *   added Renesas H8/300 support.
  26  *
  27  * Paul Mundt <lethal@linux-sh.org> 08-Aug-2003.
  28  *   Integrated support for sh64 (SH-5), from preliminary modutils
  29  *   patches from Benedict Gaster <benedict.gaster@superh.com>.
  30  *   Currently limited to support for 32bit ABI.
  31  *
  32  * Magnus Damm <damm@opensource.se> 22-May-2002.
  33  *   The plt and got code are now using the same structs.
  34  *   Added generic linked list code to fully support PowerPC.
  35  *   Replaced the mess in arch_apply_relocation() with architecture blocks.
  36  *   The arch_create_got() function got cleaned up with architecture blocks.
  37  *   These blocks should be easy maintain and sync with obj_xxx.c in modutils.
  38  *
  39  * Magnus Damm <damm@opensource.se> added PowerPC support 20-Feb-2001.
  40  *   PowerPC specific code stolen from modutils-2.3.16,
  41  *   written by Paul Mackerras, Copyright 1996, 1997 Linux International.
  42  *   I've only tested the code on mpc8xx platforms in big-endian mode.
  43  *   Did some cleanup and added USE_xxx_ENTRIES...
  44  *
  45  * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
  46  *   based on modutils-2.4.2
  47  *   MIPS specific support for Elf loading and relocation.
  48  *   Copyright 1996, 1997 Linux International.
  49  *   Contributed by Ralf Baechle <ralf@gnu.ai.mit.edu>
  50  *
  51  * Based almost entirely on the Linux modutils-2.3.11 implementation.
  52  *   Copyright 1996, 1997 Linux International.
  53  *   New implementation contributed by Richard Henderson <rth@tamu.edu>
  54  *   Based on original work by Bjorn Ekwall <bj0rn@blox.se>
  55  *   Restructured (and partly rewritten) by:
  56  *   Björn Ekwall <bj0rn@blox.se> February 1999
  57  *
  58  * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  59  */
  60
  61 #include "libbb.h"
  62 #include "modutils.h"
  63 #include <libgen.h>
  64 #include <sys/utsname.h>
  65
  66 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
  67 #define LOADBITS 0
  68 #else
  69 #define LOADBITS 1
  70 #endif
  71
  72 /* Alpha */
  73 #if defined(__alpha__)
  74 #define MATCH_MACHINE(x) (x == EM_ALPHA)
  75 #define SHT_RELM       SHT_RELA
  76 #define Elf64_RelM     Elf64_Rela
  77 #define ELFCLASSM      ELFCLASS64
  78 #endif
  79
  80 /* ARM support */
  81 #if defined(__arm__)
  82 #define MATCH_MACHINE(x) (x == EM_ARM)
  83 #define SHT_RELM        SHT_REL
  84 #define Elf32_RelM      Elf32_Rel
  85 #define ELFCLASSM       ELFCLASS32
  86 #define USE_PLT_ENTRIES
  87 #define PLT_ENTRY_SIZE 8
  88 #define USE_GOT_ENTRIES
  89 #define GOT_ENTRY_SIZE 8
  90 #define USE_SINGLE
  91 #endif
  92
  93 /* NDS32 support */
  94 #if defined(__nds32__) || defined(__NDS32__)
  95 #define CONFIG_USE_GOT_ENTRIES
  96 #define CONFIG_GOT_ENTRY_SIZE 4
  97 #define CONFIG_USE_SINGLE
  98
  99 #if defined(__NDS32_EB__)
 100 #define MATCH_MACHINE(x) (x == EM_NDS32)
 101 #define SHT_RELM    SHT_RELA
 102 #define Elf32_RelM  Elf32_Rela
 103 #define ELFCLASSM   ELFCLASS32
 104 #endif
 105
 106 #if defined(__NDS32_EL__)
 107 #define MATCH_MACHINE(x) (x == EM_NDS32)
 108 #define SHT_RELM    SHT_RELA
 109 #define Elf32_RelM  Elf32_Rela
 110 #define ELFCLASSM   ELFCLASS32
 111 #endif
 112 #endif
 113
 114 /* blackfin */
 115 #if defined(BFIN)
 116 #define MATCH_MACHINE(x) (x == EM_BLACKFIN)
 117 #define SHT_RELM        SHT_RELA
 118 #define Elf32_RelM      Elf32_Rela
 119 #define ELFCLASSM       ELFCLASS32
 120 #endif
 121
 122 /* CRIS */
 123 #if defined(__cris__)
 124 #define MATCH_MACHINE(x) (x == EM_CRIS)
 125 #define SHT_RELM        SHT_RELA
 126 #define Elf32_RelM      Elf32_Rela
 127 #define ELFCLASSM       ELFCLASS32
 128 #ifndef EM_CRIS
 129 #define EM_CRIS 76
 130 #define R_CRIS_NONE 0
 131 #define R_CRIS_32   3
 132 #endif
 133 #endif
 134
 135 /* H8/300 */
 136 #if defined(__H8300H__) || defined(__H8300S__)
 137 #define MATCH_MACHINE(x) (x == EM_H8_300)
 138 #define SHT_RELM        SHT_RELA
 139 #define Elf32_RelM      Elf32_Rela
 140 #define ELFCLASSM       ELFCLASS32
 141 #define USE_SINGLE
 142 #define SYMBOL_PREFIX   "_"
 143 #endif
 144
 145 /* PA-RISC / HP-PA */
 146 #if defined(__hppa__)
 147 #define MATCH_MACHINE(x) (x == EM_PARISC)
 148 #define SHT_RELM       SHT_RELA
 149 #if defined(__LP64__)
 150 #define Elf64_RelM     Elf64_Rela
 151 #define ELFCLASSM      ELFCLASS64
 152 #else
 153 #define Elf32_RelM     Elf32_Rela
 154 #define ELFCLASSM      ELFCLASS32
 155 #endif
 156 #endif
 157
 158 /* x86 */
 159 #if defined(__i386__)
 160 #ifndef EM_486
 161 #define MATCH_MACHINE(x) (x == EM_386)
 162 #else
 163 #define MATCH_MACHINE(x) (x == EM_386 || x == EM_486)
 164 #endif
 165 #define SHT_RELM        SHT_REL
 166 #define Elf32_RelM      Elf32_Rel
 167 #define ELFCLASSM       ELFCLASS32
 168 #define USE_GOT_ENTRIES
 169 #define GOT_ENTRY_SIZE 4
 170 #define USE_SINGLE
 171 #endif
 172
 173 /* IA64, aka Itanium */
 174 #if defined(__ia64__)
 175 #define MATCH_MACHINE(x) (x == EM_IA_64)
 176 #define SHT_RELM       SHT_RELA
 177 #define Elf64_RelM     Elf64_Rela
 178 #define ELFCLASSM      ELFCLASS64
 179 #endif
 180
 181 /* m68k */
 182 #if defined(__mc68000__)
 183 #define MATCH_MACHINE(x) (x == EM_68K)
 184 #define SHT_RELM        SHT_RELA
 185 #define Elf32_RelM      Elf32_Rela
 186 #define ELFCLASSM       ELFCLASS32
 187 #define USE_GOT_ENTRIES
 188 #define GOT_ENTRY_SIZE 4
 189 #define USE_SINGLE
 190 #endif
 191
 192 /* Microblaze */
 193 #if defined(__microblaze__)
 194 #define USE_SINGLE
 195 #include <linux/elf-em.h>
 196 #define MATCH_MACHINE(x) (x == EM_XILINX_MICROBLAZE)
 197 #define SHT_RELM        SHT_RELA
 198 #define Elf32_RelM      Elf32_Rela
 199 #define ELFCLASSM       ELFCLASS32
 200 #endif
 201
 202 /* MIPS */
 203 #if defined(__mips__)
 204 #define MATCH_MACHINE(x) (x == EM_MIPS || x == EM_MIPS_RS3_LE)
 205 #define SHT_RELM        SHT_REL
 206 #define Elf32_RelM      Elf32_Rel
 207 #define ELFCLASSM       ELFCLASS32
 208 /* Account for ELF spec changes.  */
 209 #ifndef EM_MIPS_RS3_LE
 210 #ifdef EM_MIPS_RS4_BE
 211 #define EM_MIPS_RS3_LE  EM_MIPS_RS4_BE
 212 #else
 213 #define EM_MIPS_RS3_LE  10
 214 #endif
 215 #endif /* !EM_MIPS_RS3_LE */
 216 #define ARCHDATAM       "__dbe_table"
 217 #endif
 218
 219 /* Nios II */
 220 #if defined(__nios2__)
 221 #define MATCH_MACHINE(x) (x == EM_ALTERA_NIOS2)
 222 #define SHT_RELM        SHT_RELA
 223 #define Elf32_RelM      Elf32_Rela
 224 #define ELFCLASSM       ELFCLASS32
 225 #endif
 226
 227 /* PowerPC */
 228 #if defined(__powerpc64__)
 229 #define MATCH_MACHINE(x) (x == EM_PPC64)
 230 #define SHT_RELM        SHT_RELA
 231 #define Elf64_RelM      Elf64_Rela
 232 #define ELFCLASSM       ELFCLASS64
 233 #elif defined(__powerpc__)
 234 #define MATCH_MACHINE(x) (x == EM_PPC)
 235 #define SHT_RELM        SHT_RELA
 236 #define Elf32_RelM      Elf32_Rela
 237 #define ELFCLASSM       ELFCLASS32
 238 #define USE_PLT_ENTRIES
 239 #define PLT_ENTRY_SIZE 16
 240 #define USE_PLT_LIST
 241 #define LIST_ARCHTYPE ElfW(Addr)
 242 #define USE_LIST
 243 #define ARCHDATAM       "__ftr_fixup"
 244 #endif
 245
 246 /* S390 */
 247 #if defined(__s390__)
 248 #define MATCH_MACHINE(x) (x == EM_S390)
 249 #define SHT_RELM        SHT_RELA
 250 #define Elf32_RelM      Elf32_Rela
 251 #define ELFCLASSM       ELFCLASS32
 252 #define USE_PLT_ENTRIES
 253 #define PLT_ENTRY_SIZE 8
 254 #define USE_GOT_ENTRIES
 255 #define GOT_ENTRY_SIZE 8
 256 #define USE_SINGLE
 257 #endif
 258
 259 /* SuperH */
 260 #if defined(__sh__)
 261 #define MATCH_MACHINE(x) (x == EM_SH)
 262 #define SHT_RELM        SHT_RELA
 263 #define Elf32_RelM      Elf32_Rela
 264 #define ELFCLASSM       ELFCLASS32
 265 #define USE_GOT_ENTRIES
 266 #define GOT_ENTRY_SIZE 4
 267 #define USE_SINGLE
 268 /* the SH changes have only been tested in =little endian= mode */
 269 /* I'm not sure about big endian, so let's warn: */
 270 #if defined(__sh__) && BB_BIG_ENDIAN
 271 # error insmod.c may require changes for use on big endian SH
 272 #endif
 273 /* it may or may not work on the SH1/SH2... Error on those also */
 274 #if ((!(defined(__SH3__) || defined(__SH4__) || defined(__SH5__)))) && (defined(__sh__))
 275 #error insmod.c may require changes for SH1 or SH2 use
 276 #endif
 277 #endif
 278
 279 /* Sparc */
 280 #if defined(__sparc__)
 281 #define MATCH_MACHINE(x) (x == EM_SPARC)
 282 #define SHT_RELM       SHT_RELA
 283 #define Elf32_RelM     Elf32_Rela
 284 #define ELFCLASSM      ELFCLASS32
 285 #endif
 286
 287 /* v850e */
 288 #if defined(__v850e__)
 289 #define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
 290 #define SHT_RELM        SHT_RELA
 291 #define Elf32_RelM      Elf32_Rela
 292 #define ELFCLASSM       ELFCLASS32
 293 #define USE_PLT_ENTRIES
 294 #define PLT_ENTRY_SIZE 8
 295 #define USE_SINGLE
 296 #ifndef EM_CYGNUS_V850  /* grumble */
 297 #define EM_CYGNUS_V850  0x9080
 298 #endif
 299 #define SYMBOL_PREFIX   "_"
 300 #endif
 301
 302 /* X86_64  */
 303 #if defined(__x86_64__)
 304 #define MATCH_MACHINE(x) (x == EM_X86_64)
 305 #define SHT_RELM        SHT_RELA
 306 #define USE_GOT_ENTRIES
 307 #define GOT_ENTRY_SIZE 8
 308 #define USE_SINGLE
 309 #define Elf64_RelM      Elf64_Rela
 310 #define ELFCLASSM       ELFCLASS64
 311 #endif
 312
 313 #ifndef SHT_RELM
 314 #error Sorry, but insmod.c does not yet support this architecture...
 315 #endif
 316
 317
 318 //----------------------------------------------------------------------------
 319 //--------modutils module.h, lines 45-242
 320 //----------------------------------------------------------------------------
 321
 322 /* Definitions for the Linux module syscall interface.
 323    Copyright 1996, 1997 Linux International.
 324
 325    Contributed by Richard Henderson <rth@tamu.edu>
 326
 327    This file is part of the Linux modutils.
 328
 329    This program is free software; you can redistribute it and/or modify it
 330    under the terms of the GNU General Public License as published by the
 331    Free Software Foundation; either version 2 of the License, or (at your
 332    option) any later version.
 333
 334    This program is distributed in the hope that it will be useful, but
 335    WITHOUT ANY WARRANTY; without even the implied warranty of
 336    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 337    General Public License for more details.
 338
 339    You should have received a copy of the GNU General Public License
 340    along with this program; if not, write to the Free Software Foundation,
 341    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 342
 343
 344 #ifndef MODUTILS_MODULE_H
 345
 346 /*======================================================================*/
 347 /* For sizeof() which are related to the module platform and not to the
 348    environment isnmod is running in, use sizeof_xx instead of sizeof(xx).  */
 349
 350 #define tgt_sizeof_char         sizeof(char)
 351 #define tgt_sizeof_short        sizeof(short)
 352 #define tgt_sizeof_int          sizeof(int)
 353 #define tgt_sizeof_long         sizeof(long)
 354 #define tgt_sizeof_char_p       sizeof(char *)
 355 #define tgt_sizeof_void_p       sizeof(void *)
 356 #define tgt_long                long
 357
 358 #if defined(__sparc__) && !defined(__sparc_v9__) && defined(ARCH_sparc64)
 359 #undef tgt_sizeof_long
 360 #undef tgt_sizeof_char_p
 361 #undef tgt_sizeof_void_p
 362 #undef tgt_long
 363 enum {
 364         tgt_sizeof_long = 8,
 365         tgt_sizeof_char_p = 8,
 366         tgt_sizeof_void_p = 8
 367 };
 368 #define tgt_long                long long
 369 #endif
 370
 371 /*======================================================================*/
 372 /* The structures used in Linux 2.1.  */
 373
 374 /* Note: new_module_symbol does not use tgt_long intentionally */
 375 struct new_module_symbol {
 376         unsigned long value;
 377         unsigned long name;
 378 };
 379
 380 struct new_module_persist;
 381
 382 struct new_module_ref {
 383         unsigned tgt_long dep;          /* kernel addresses */
 384         unsigned tgt_long ref;
 385         unsigned tgt_long next_ref;
 386 };
 387
 388 struct new_module {
 389         unsigned tgt_long size_of_struct;       /* == sizeof(module) */
 390         unsigned tgt_long next;
 391         unsigned tgt_long name;
 392         unsigned tgt_long size;
 393
 394         tgt_long usecount;
 395         unsigned tgt_long flags;                /* AUTOCLEAN et al */
 396
 397         unsigned nsyms;
 398         unsigned ndeps;
 399
 400         unsigned tgt_long syms;
 401         unsigned tgt_long deps;
 402         unsigned tgt_long refs;
 403         unsigned tgt_long init;
 404         unsigned tgt_long cleanup;
 405         unsigned tgt_long ex_table_start;
 406         unsigned tgt_long ex_table_end;
 407 #ifdef __alpha__
 408         unsigned tgt_long gp;
 409 #endif
 410         /* Everything after here is extension.  */
 411         unsigned tgt_long persist_start;
 412         unsigned tgt_long persist_end;
 413         unsigned tgt_long can_unload;
 414         unsigned tgt_long runsize;
 415         const char *kallsyms_start;     /* All symbols for kernel debugging */
 416         const char *kallsyms_end;
 417         const char *archdata_start;     /* arch specific data for module */
 418         const char *archdata_end;
 419         const char *kernel_data;        /* Reserved for kernel internal use */
 420 };
 421
 422 #ifdef ARCHDATAM
 423 #define ARCHDATA_SEC_NAME ARCHDATAM
 424 #else
 425 #define ARCHDATA_SEC_NAME "__archdata"
 426 #endif
 427 #define KALLSYMS_SEC_NAME "__kallsyms"
 428
 429
 430 struct new_module_info {
 431         unsigned long addr;
 432         unsigned long size;
 433         unsigned long flags;
 434         long usecount;
 435 };
 436
 437 /* Bits of module.flags.  */
 438 enum {
 439         NEW_MOD_RUNNING = 1,
 440         NEW_MOD_DELETED = 2,
 441         NEW_MOD_AUTOCLEAN = 4,
 442         NEW_MOD_VISITED = 8,
 443         NEW_MOD_USED_ONCE = 16
 444 };
 445
 446 int init_module(const char *name, const struct new_module *);
 447 int query_module(const char *name, int which, void *buf,
 448                 size_t bufsize, size_t *ret);
 449
 450 /* Values for query_module's which.  */
 451 enum {
 452         QM_MODULES = 1,
 453         QM_DEPS = 2,
 454         QM_REFS = 3,
 455         QM_SYMBOLS = 4,
 456         QM_INFO = 5
 457 };
 458
 459 /*======================================================================*/
 460 /* The system calls unchanged between 2.0 and 2.1.  */
 461
 462 unsigned long create_module(const char *, size_t);
 463 int delete_module(const char *module, unsigned int flags);
 464
 465
 466 #endif /* module.h */
 467
 468 //----------------------------------------------------------------------------
 469 //--------end of modutils module.h
 470 //----------------------------------------------------------------------------
 471
 472
 473
 474 //----------------------------------------------------------------------------
 475 //--------modutils obj.h, lines 253-462
 476 //----------------------------------------------------------------------------
 477
 478 /* Elf object file loading and relocation routines.
 479    Copyright 1996, 1997 Linux International.
 480
 481    Contributed by Richard Henderson <rth@tamu.edu>
 482
 483    This file is part of the Linux modutils.
 484
 485    This program is free software; you can redistribute it and/or modify it
 486    under the terms of the GNU General Public License as published by the
 487    Free Software Foundation; either version 2 of the License, or (at your
 488    option) any later version.
 489
 490    This program is distributed in the hope that it will be useful, but
 491    WITHOUT ANY WARRANTY; without even the implied warranty of
 492    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 493    General Public License for more details.
 494
 495    You should have received a copy of the GNU General Public License
 496    along with this program; if not, write to the Free Software Foundation,
 497    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 498
 499
 500 #ifndef MODUTILS_OBJ_H
 501
 502 /* The relocatable object is manipulated using elfin types.  */
 503
 504 #include <elf.h>
 505 #include <endian.h>
 506
 507 #ifndef ElfW
 508 # if ELFCLASSM == ELFCLASS32
 509 #  define ElfW(x)  Elf32_ ## x
 510 #  define ELFW(x)  ELF32_ ## x
 511 # else
 512 #  define ElfW(x)  Elf64_ ## x
 513 #  define ELFW(x)  ELF64_ ## x
 514 # endif
 515 #endif
 516
 517 /* For some reason this is missing from some ancient C libraries....  */
 518 #ifndef ELF32_ST_INFO
 519 # define ELF32_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))
 520 #endif
 521
 522 #ifndef ELF64_ST_INFO
 523 # define ELF64_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))
 524 #endif
 525
 526 #define ELF_ST_BIND(info) ELFW(ST_BIND)(info)
 527 #define ELF_ST_TYPE(info) ELFW(ST_TYPE)(info)
 528 #define ELF_ST_INFO(bind, type) ELFW(ST_INFO)(bind, type)
 529 #define ELF_R_TYPE(val) ELFW(R_TYPE)(val)
 530 #define ELF_R_SYM(val) ELFW(R_SYM)(val)
 531
 532 struct obj_string_patch;
 533 struct obj_symbol_patch;
 534
 535 struct obj_section {
 536         ElfW(Shdr) header;
 537         const char *name;
 538         char *contents;
 539         struct obj_section *load_next;
 540         int idx;
 541 };
 542
 543 struct obj_symbol {
 544         struct obj_symbol *next;        /* hash table link */
 545         const char *name;
 546         unsigned long value;
 547         unsigned long size;
 548         int secidx;                     /* the defining section index/module */
 549         int info;
 550         int ksymidx;                    /* for export to the kernel symtab */
 551         int referenced;         /* actually used in the link */
 552 };
 553
 554 /* Hardcode the hash table size.  We shouldn't be needing so many
 555    symbols that we begin to degrade performance, and we get a big win
 556    by giving the compiler a constant divisor.  */
 557
 558 #define HASH_BUCKETS  521
 559
 560 struct obj_file {
 561         ElfW(Ehdr) header;
 562         ElfW(Addr) baseaddr;
 563         struct obj_section **sections;
 564         struct obj_section *load_order;
 565         struct obj_section **load_order_search_start;
 566         struct obj_string_patch *string_patches;
 567         struct obj_symbol_patch *symbol_patches;
 568         int (*symbol_cmp)(const char *, const char *); /* cant be FAST_FUNC */
 569         unsigned long (*symbol_hash)(const char *) FAST_FUNC;
 570         unsigned long local_symtab_size;
 571         struct obj_symbol **local_symtab;
 572         struct obj_symbol *symtab[HASH_BUCKETS];
 573 };
 574
 575 enum obj_reloc {
 576         obj_reloc_ok,
 577         obj_reloc_overflow,
 578         obj_reloc_dangerous,
 579         obj_reloc_unhandled
 580 };
 581
 582 struct obj_string_patch {
 583         struct obj_string_patch *next;
 584         int reloc_secidx;
 585         ElfW(Addr) reloc_offset;
 586         ElfW(Addr) string_offset;
 587 };
 588
 589 struct obj_symbol_patch {
 590         struct obj_symbol_patch *next;
 591         int reloc_secidx;
 592         ElfW(Addr) reloc_offset;
 593         struct obj_symbol *sym;
 594 };
 595
 596
 597 /* Generic object manipulation routines.  */
 598
 599 static unsigned long FAST_FUNC obj_elf_hash(const char *);
 600
 601 static unsigned long obj_elf_hash_n(const char *, unsigned long len);
 602
 603 static struct obj_symbol *obj_find_symbol(struct obj_file *f,
 604                 const char *name);
 605
 606 static ElfW(Addr) obj_symbol_final_value(struct obj_file *f,
 607                 struct obj_symbol *sym);
 608
 609 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
 610 static void obj_set_symbol_compare(struct obj_file *f,
 611                 int (*cmp)(const char *, const char *),
 612                 unsigned long (*hash)(const char *) FAST_FUNC);
 613 #endif
 614
 615 static struct obj_section *obj_find_section(struct obj_file *f,
 616                 const char *name);
 617
 618 static void obj_insert_section_load_order(struct obj_file *f,
 619                 struct obj_section *sec);
 620
 621 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
 622                 const char *name,
 623                 unsigned long align,
 624                 unsigned long size);
 625
 626 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
 627                 const char *name,
 628                 unsigned long align,
 629                 unsigned long size);
 630
 631 static void *obj_extend_section(struct obj_section *sec, unsigned long more);
 632
 633 static void obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
 634                 const char *string);
 635
 636 static void obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
 637                 struct obj_symbol *sym);
 638
 639 static void obj_check_undefineds(struct obj_file *f);
 640
 641 static void obj_allocate_commons(struct obj_file *f);
 642
 643 static unsigned long obj_load_size(struct obj_file *f);
 644
 645 static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
 646
 647 #if !LOADBITS
 648 #define obj_load(image, image_size, loadprogbits) \
 649         obj_load(image, image_size)
 650 #endif
 651 static struct obj_file *obj_load(char *image, size_t image_size, int loadprogbits);
 652
 653 static int obj_create_image(struct obj_file *f, char *image);
 654
 655 /* Architecture specific manipulation routines.  */
 656
 657 static struct obj_file *arch_new_file(void);
 658
 659 static struct obj_section *arch_new_section(void);
 660
 661 static struct obj_symbol *arch_new_symbol(void);
 662
 663 static enum obj_reloc arch_apply_relocation(struct obj_file *f,
 664                 struct obj_section *targsec,
 665                 /*struct obj_section *symsec,*/
 666                 struct obj_symbol *sym,
 667                 ElfW(RelM) *rel, ElfW(Addr) value);
 668
 669 static void arch_create_got(struct obj_file *f);
 670 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
 671 static int obj_gpl_license(struct obj_file *f, const char **license);
 672 #endif
 673 #endif /* obj.h */
 674 //----------------------------------------------------------------------------
 675 //--------end of modutils obj.h
 676 //----------------------------------------------------------------------------
 677
 678
 679 /* SPFX is always a string, so it can be concatenated to string constants.  */
 680 #ifdef SYMBOL_PREFIX
 681 #define SPFX    SYMBOL_PREFIX
 682 #else
 683 #define SPFX    ""
 684 #endif
 685
 686 enum { STRVERSIONLEN = 64 };
 687
 688 /*======================================================================*/
 689
 690 #define flag_force_load (option_mask32 & INSMOD_OPT_FORCE)
 691 #define flag_autoclean (option_mask32 & INSMOD_OPT_KERNELD)
 692 #define flag_verbose (option_mask32 & INSMOD_OPT_VERBOSE)
 693 #define flag_quiet (option_mask32 & INSMOD_OPT_SILENT)
 694 #define flag_noexport (option_mask32 & INSMOD_OPT_NO_EXPORT)
 695 #define flag_print_load_map (option_mask32 & INSMOD_OPT_PRINT_MAP)
 696
 697 /*======================================================================*/
 698
 699 #if defined(USE_LIST)
 700
 701 struct arch_list_entry {
 702         struct arch_list_entry *next;
 703         LIST_ARCHTYPE addend;
 704         int offset;
 705         int inited : 1;
 706 };
 707
 708 #endif
 709
 710 #if defined(USE_SINGLE)
 711
 712 struct arch_single_entry {
 713         int offset;
 714         int inited : 1;
 715         int allocated : 1;
 716 };
 717
 718 #endif
 719
 720 #if defined(__mips__)
 721 struct mips_hi16 {
 722         struct mips_hi16 *next;
 723         ElfW(Addr) *addr;
 724         ElfW(Addr) value;
 725 };
 726 #endif
 727
 728 struct arch_file {
 729         struct obj_file root;
 730 #if defined(USE_PLT_ENTRIES)
 731         struct obj_section *plt;
 732 #endif
 733 #if defined(USE_GOT_ENTRIES)
 734         struct obj_section *got;
 735 #endif
 736 #if defined(__mips__)
 737         struct mips_hi16 *mips_hi16_list;
 738 #endif
 739 };
 740
 741 struct arch_symbol {
 742         struct obj_symbol root;
 743 #if defined(USE_PLT_ENTRIES)
 744 #if defined(USE_PLT_LIST)
 745         struct arch_list_entry *pltent;
 746 #else
 747         struct arch_single_entry pltent;
 748 #endif
 749 #endif
 750 #if defined(USE_GOT_ENTRIES)
 751         struct arch_single_entry gotent;
 752 #endif
 753 };
 754
 755
 756 struct external_module {
 757         const char *name;
 758         ElfW(Addr) addr;
 759         int used;
 760         size_t nsyms;
 761         struct new_module_symbol *syms;
 762 };
 763
 764 static struct new_module_symbol *ksyms;
 765 static size_t nksyms;
 766
 767 static struct external_module *ext_modules;
 768 static int n_ext_modules;
 769 static int n_ext_modules_used;
 770
 771 /*======================================================================*/
 772
 773
 774 static struct obj_file *arch_new_file(void)
 775 {
 776         struct arch_file *f;
 777         f = xzalloc(sizeof(*f));
 778         return &f->root; /* it's a first member */
 779 }
 780
 781 static struct obj_section *arch_new_section(void)
 782 {
 783         return xzalloc(sizeof(struct obj_section));
 784 }
 785
 786 static struct obj_symbol *arch_new_symbol(void)
 787 {
 788         struct arch_symbol *sym;
 789         sym = xzalloc(sizeof(*sym));
 790         return &sym->root;
 791 }
 792
 793 static enum obj_reloc
 794 arch_apply_relocation(struct obj_file *f,
 795                 struct obj_section *targsec,
 796                 /*struct obj_section *symsec,*/
 797                 struct obj_symbol *sym,
 798                 ElfW(RelM) *rel, ElfW(Addr) v)
 799 {
 800 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
 801  || defined(__sh__) || defined(__s390__) || defined(__x86_64__) \
 802  || defined(__powerpc__) || defined(__mips__)
 803         struct arch_file *ifile = (struct arch_file *) f;
 804 #endif
 805         enum obj_reloc ret = obj_reloc_ok;
 806         ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
 807 #if defined(__arm__) || defined(__H8300H__) || defined(__H8300S__) \
 808  || defined(__i386__) || defined(__mc68000__) || defined(__microblaze__) \
 809  || defined(__mips__) || defined(__nios2__) || defined(__powerpc__) \
 810  || defined(__s390__) || defined(__sh__) || defined(__x86_64__)
 811         ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
 812 #endif
 813 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
 814         struct arch_symbol *isym = (struct arch_symbol *) sym;
 815 #endif
 816 #if defined(__arm__) || defined(__i386__) || defined(__mc68000__) \
 817  || defined(__sh__) || defined(__s390__)
 818 #if defined(USE_GOT_ENTRIES)
 819         ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
 820 #endif
 821 #endif
 822 #if defined(USE_PLT_ENTRIES)
 823         ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
 824         unsigned long *ip;
 825 # if defined(USE_PLT_LIST)
 826         struct arch_list_entry *pe;
 827 # else
 828         struct arch_single_entry *pe;
 829 # endif
 830 #endif
 831
 832         switch (ELF_R_TYPE(rel->r_info)) {
 833
 834 #if defined(__arm__)
 835
 836                 case R_ARM_NONE:
 837                         break;
 838
 839                 case R_ARM_ABS32:
 840                         *loc += v;
 841                         break;
 842
 843                 case R_ARM_GOT32:
 844                         goto bb_use_got;
 845
 846                 case R_ARM_GOTPC:
 847                         /* relative reloc, always to _GLOBAL_OFFSET_TABLE_
 848                          * (which is .got) similar to branch,
 849                          * but is full 32 bits relative */
 850
 851                         *loc += got - dot;
 852                         break;
 853
 854                 case R_ARM_PC24:
 855                 case R_ARM_PLT32:
 856                         goto bb_use_plt;
 857
 858                 case R_ARM_GOTOFF: /* address relative to the got */
 859                         *loc += v - got;
 860                         break;
 861
 862 #elif defined(__cris__)
 863
 864                 case R_CRIS_NONE:
 865                         break;
 866
 867                 case R_CRIS_32:
 868                         /* CRIS keeps the relocation value in the r_addend field and
 869                          * should not use whats in *loc at all
 870                          */
 871                         *loc = v;
 872                         break;
 873
 874 #elif defined(__H8300H__) || defined(__H8300S__)
 875
 876                 case R_H8_DIR24R8:
 877                         loc = (ElfW(Addr) *)((ElfW(Addr))loc - 1);
 878                         *loc = (*loc & 0xff000000) | ((*loc & 0xffffff) + v);
 879                         break;
 880                 case R_H8_DIR24A8:
 881                         *loc += v;
 882                         break;
 883                 case R_H8_DIR32:
 884                 case R_H8_DIR32A16:
 885                         *loc += v;
 886                         break;
 887                 case R_H8_PCREL16:
 888                         v -= dot + 2;
 889                         if ((ElfW(Sword))v > 0x7fff
 890                          || (ElfW(Sword))v < -(ElfW(Sword))0x8000
 891                         ) {
 892                                 ret = obj_reloc_overflow;
 893                         } else {
 894                                 *(unsigned short *)loc = v;
 895                         }
 896                         break;
 897                 case R_H8_PCREL8:
 898                         v -= dot + 1;
 899                         if ((ElfW(Sword))v > 0x7f
 900                          || (ElfW(Sword))v < -(ElfW(Sword))0x80
 901                         ) {
 902                                 ret = obj_reloc_overflow;
 903                         } else {
 904                                 *(unsigned char *)loc = v;
 905                         }
 906                         break;
 907
 908 #elif defined(__i386__)
 909
 910                 case R_386_NONE:
 911                         break;
 912
 913                 case R_386_32:
 914                         *loc += v;
 915                         break;
 916
 917                 case R_386_PLT32:
 918                 case R_386_PC32:
 919                 case R_386_GOTOFF:
 920                         *loc += v - dot;
 921                         break;
 922
 923                 case R_386_GLOB_DAT:
 924                 case R_386_JMP_SLOT:
 925                         *loc = v;
 926                         break;
 927
 928                 case R_386_RELATIVE:
 929                         *loc += f->baseaddr;
 930                         break;
 931
 932                 case R_386_GOTPC:
 933                         *loc += got - dot;
 934                         break;
 935
 936                 case R_386_GOT32:
 937                         goto bb_use_got;
 938                         break;
 939
 940 #elif defined(__microblaze__)
 941                 case R_MICROBLAZE_NONE:
 942                 case R_MICROBLAZE_64_NONE:
 943                 case R_MICROBLAZE_32_SYM_OP_SYM:
 944                 case R_MICROBLAZE_32_PCREL:
 945                         break;
 946
 947                 case R_MICROBLAZE_64_PCREL: {
 948                         /* dot is the address of the current instruction.
 949                          * v is the target symbol address.
 950                          * So we need to extract the offset in the code,
 951                          * adding v, then subtrating the current address
 952                          * of this instruction.
 953                          * Ex: "IMM 0xFFFE  bralid 0x0000" = "bralid 0xFFFE0000"
 954                          */
 955
 956                         /* Get split offset stored in code */
 957                         unsigned int temp = (loc[0] & 0xFFFF) << 16 |
 958                                                 (loc[1] & 0xFFFF);
 959
 960                         /* Adjust relative offset. -4 adjustment required
 961                          * because dot points to the IMM insn, but branch
 962                          * is computed relative to the branch instruction itself.
 963                          */
 964                         temp += v - dot - 4;
 965
 966                         /* Store back into code */
 967                         loc[0] = (loc[0] & 0xFFFF0000) | temp >> 16;
 968                         loc[1] = (loc[1] & 0xFFFF0000) | (temp & 0xFFFF);
 969
 970                         break;
 971                 }
 972
 973                 case R_MICROBLAZE_32:
 974                         *loc += v;
 975                         break;
 976
 977                 case R_MICROBLAZE_64: {
 978                         /* Get split pointer stored in code */
 979                         unsigned int temp1 = (loc[0] & 0xFFFF) << 16 |
 980                                                 (loc[1] & 0xFFFF);
 981
 982                         /* Add reloc offset */
 983                         temp1+=v;
 984
 985                         /* Store back into code */
 986                         loc[0] = (loc[0] & 0xFFFF0000) | temp1 >> 16;
 987                         loc[1] = (loc[1] & 0xFFFF0000) | (temp1 & 0xFFFF);
 988
 989                         break;
 990                 }
 991
 992                 case R_MICROBLAZE_32_PCREL_LO:
 993                 case R_MICROBLAZE_32_LO:
 994                 case R_MICROBLAZE_SRO32:
 995                 case R_MICROBLAZE_SRW32:
 996                         ret = obj_reloc_unhandled;
 997                         break;
 998
 999 #elif defined(__mc68000__)
1000
1001                 case R_68K_NONE:
1002                         break;
1003
1004                 case R_68K_32:
1005                         *loc += v;
1006                         break;
1007
1008                 case R_68K_8:
1009                         if (v > 0xff) {
1010                                 ret = obj_reloc_overflow;
1011                         }
1012                         *(char *)loc = v;
1013                         break;
1014
1015                 case R_68K_16:
1016                         if (v > 0xffff) {
1017                                 ret = obj_reloc_overflow;
1018                         }
1019                         *(short *)loc = v;
1020                         break;
1021
1022                 case R_68K_PC8:
1023                         v -= dot;
1024                         if ((ElfW(Sword))v > 0x7f
1025                          || (ElfW(Sword))v < -(ElfW(Sword))0x80
1026                         ) {
1027                                 ret = obj_reloc_overflow;
1028                         }
1029                         *(char *)loc = v;
1030                         break;
1031
1032                 case R_68K_PC16:
1033                         v -= dot;
1034                         if ((ElfW(Sword))v > 0x7fff
1035                          || (ElfW(Sword))v < -(ElfW(Sword))0x8000
1036                         ) {
1037                                 ret = obj_reloc_overflow;
1038                         }
1039                         *(short *)loc = v;
1040                         break;
1041
1042                 case R_68K_PC32:
1043                         *(int *)loc = v - dot;
1044                         break;
1045
1046                 case R_68K_GLOB_DAT:
1047                 case R_68K_JMP_SLOT:
1048                         *loc = v;
1049                         break;
1050
1051                 case R_68K_RELATIVE:
1052                         *(int *)loc += f->baseaddr;
1053                         break;
1054
1055                 case R_68K_GOT32:
1056                         goto bb_use_got;
1057
1058 # ifdef R_68K_GOTOFF
1059                 case R_68K_GOTOFF:
1060                         *loc += v - got;
1061                         break;
1062 # endif
1063
1064 #elif defined(__mips__)
1065
1066                 case R_MIPS_NONE:
1067                         break;
1068
1069                 case R_MIPS_32:
1070                         *loc += v;
1071                         break;
1072
1073                 case R_MIPS_26:
1074                         if (v % 4)
1075                                 ret = obj_reloc_dangerous;
1076                         if ((v & 0xf0000000) != ((dot + 4) & 0xf0000000))
1077                                 ret = obj_reloc_overflow;
1078                         *loc =
1079                                 (*loc & ~0x03ffffff) | ((*loc + (v >> 2)) &
1080                                                                                 0x03ffffff);
1081                         break;
1082
1083                 case R_MIPS_HI16:
1084                         {
1085                                 struct mips_hi16 *n;
1086
1087                                 /* We cannot relocate this one now because we don't know the value
1088                                    of the carry we need to add.  Save the information, and let LO16
1089                                    do the actual relocation.  */
1090                                 n = xmalloc(sizeof *n);
1091                                 n->addr = loc;
1092                                 n->value = v;
1093                                 n->next = ifile->mips_hi16_list;
1094                                 ifile->mips_hi16_list = n;
1095                                 break;
1096                         }
1097
1098                 case R_MIPS_LO16:
1099                         {
1100                                 unsigned long insnlo = *loc;
1101                                 ElfW(Addr) val, vallo;
1102
1103                                 /* Sign extend the addend we extract from the lo insn.  */
1104                                 vallo = ((insnlo & 0xffff) ^ 0x8000) - 0x8000;
1105
1106                                 if (ifile->mips_hi16_list != NULL) {
1107                                         struct mips_hi16 *l;
1108
1109                                         l = ifile->mips_hi16_list;
1110                                         while (l != NULL) {
1111                                                 struct mips_hi16 *next;
1112                                                 unsigned long insn;
1113
1114                                                 /* Do the HI16 relocation.  Note that we actually don't
1115                                                    need to know anything about the LO16 itself, except where
1116                                                    to find the low 16 bits of the addend needed by the LO16.  */
1117                                                 insn = *l->addr;
1118                                                 val =
1119                                                         ((insn & 0xffff) << 16) +
1120                                                         vallo;
1121                                                 val += v;
1122
1123                                                 /* Account for the sign extension that will happen in the
1124                                                    low bits.  */
1125                                                 val =
1126                                                         ((val >> 16) +
1127                                                          ((val & 0x8000) !=
1128                                                           0)) & 0xffff;
1129
1130                                                 insn = (insn & ~0xffff) | val;
1131                                                 *l->addr = insn;
1132
1133                                                 next = l->next;
1134                                                 free(l);
1135                                                 l = next;
1136                                         }
1137
1138                                         ifile->mips_hi16_list = NULL;
1139                                 }
1140
1141                                 /* Ok, we're done with the HI16 relocs.  Now deal with the LO16.  */
1142                                 val = v + vallo;
1143                                 insnlo = (insnlo & ~0xffff) | (val & 0xffff);
1144                                 *loc = insnlo;
1145                                 break;
1146                         }
1147
1148 #elif defined(__nios2__)
1149
1150                 case R_NIOS2_NONE:
1151                         break;
1152
1153                 case R_NIOS2_BFD_RELOC_32:
1154                         *loc += v;
1155                         break;
1156
1157                 case R_NIOS2_BFD_RELOC_16:
1158                         if (v > 0xffff) {
1159                                 ret = obj_reloc_overflow;
1160                         }
1161                         *(short *)loc = v;
1162                         break;
1163
1164                 case R_NIOS2_BFD_RELOC_8:
1165                         if (v > 0xff) {
1166                                 ret = obj_reloc_overflow;
1167                         }
1168                         *(char *)loc = v;
1169                         break;
1170
1171                 case R_NIOS2_S16:
1172                         {
1173                                 Elf32_Addr word;
1174
1175                                 if ((Elf32_Sword)v > 0x7fff
1176                                  || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1177                                 ) {
1178                                         ret = obj_reloc_overflow;
1179                                 }
1180
1181                                 word = *loc;
1182                                 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1183                                        (word & 0x3f);
1184                         }
1185                         break;
1186
1187                 case R_NIOS2_U16:
1188                         {
1189                                 Elf32_Addr word;
1190
1191                                 if (v > 0xffff) {
1192                                         ret = obj_reloc_overflow;
1193                                 }
1194
1195                                 word = *loc;
1196                                 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1197                                        (word & 0x3f);
1198                         }
1199                         break;
1200
1201                 case R_NIOS2_PCREL16:
1202                         {
1203                                 Elf32_Addr word;
1204
1205                                 v -= dot + 4;
1206                                 if ((Elf32_Sword)v > 0x7fff
1207                                  || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1208                                 ) {
1209                                         ret = obj_reloc_overflow;
1210                                 }
1211
1212                                 word = *loc;
1213                                 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1214                         }
1215                         break;
1216
1217                 case R_NIOS2_GPREL:
1218                         {
1219                                 Elf32_Addr word, gp;
1220                                 /* get _gp */
1221                                 gp = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "_gp"));
1222                                 v -= gp;
1223                                 if ((Elf32_Sword)v > 0x7fff
1224                                  || (Elf32_Sword)v < -(Elf32_Sword)0x8000
1225                                 ) {
1226                                         ret = obj_reloc_overflow;
1227                                 }
1228
1229                                 word = *loc;
1230                                 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) | (word & 0x3f);
1231                         }
1232                         break;
1233
1234                 case R_NIOS2_CALL26:
1235                         if (v & 3)
1236                                 ret = obj_reloc_dangerous;
1237                         if ((v >> 28) != (dot >> 28))
1238                                 ret = obj_reloc_overflow;
1239                         *loc = (*loc & 0x3f) | ((v >> 2) << 6);
1240                         break;
1241
1242                 case R_NIOS2_IMM5:
1243                         {
1244                                 Elf32_Addr word;
1245
1246                                 if (v > 0x1f) {
1247                                         ret = obj_reloc_overflow;
1248                                 }
1249
1250                                 word = *loc & ~0x7c0;
1251                                 *loc = word | ((v & 0x1f) << 6);
1252                         }
1253                         break;
1254
1255                 case R_NIOS2_IMM6:
1256                         {
1257                                 Elf32_Addr word;
1258
1259                                 if (v > 0x3f) {
1260                                         ret = obj_reloc_overflow;
1261                                 }
1262
1263                                 word = *loc & ~0xfc0;
1264                                 *loc = word | ((v & 0x3f) << 6);
1265                         }
1266                         break;
1267
1268                 case R_NIOS2_IMM8:
1269                         {
1270                                 Elf32_Addr word;
1271
1272                                 if (v > 0xff) {
1273                                         ret = obj_reloc_overflow;
1274                                 }
1275
1276                                 word = *loc & ~0x3fc0;
1277                                 *loc = word | ((v & 0xff) << 6);
1278                         }
1279                         break;
1280
1281                 case R_NIOS2_HI16:
1282                         {
1283                                 Elf32_Addr word;
1284
1285                                 word = *loc;
1286                                 *loc = ((((word >> 22) << 16) | ((v >>16) & 0xffff)) << 6) |
1287                                        (word & 0x3f);
1288                         }
1289                         break;
1290
1291                 case R_NIOS2_LO16:
1292                         {
1293                                 Elf32_Addr word;
1294
1295                                 word = *loc;
1296                                 *loc = ((((word >> 22) << 16) | (v & 0xffff)) << 6) |
1297                                        (word & 0x3f);
1298                         }
1299                         break;
1300
1301                 case R_NIOS2_HIADJ16:
1302                         {
1303                                 Elf32_Addr word1, word2;
1304
1305                                 word1 = *loc;
1306                                 word2 = ((v >> 16) + ((v >> 15) & 1)) & 0xffff;
1307                                 *loc = ((((word1 >> 22) << 16) | word2) << 6) |
1308                                        (word1 & 0x3f);
1309                         }
1310                         break;
1311
1312 #elif defined(__powerpc64__)
1313                 /* PPC64 needs a 2.6 kernel, 2.4 module relocation irrelevant */
1314
1315 #elif defined(__powerpc__)
1316
1317                 case R_PPC_ADDR16_HA:
1318                         *(unsigned short *)loc = (v + 0x8000) >> 16;
1319                         break;
1320
1321                 case R_PPC_ADDR16_HI:
1322                         *(unsigned short *)loc = v >> 16;
1323                         break;
1324
1325                 case R_PPC_ADDR16_LO:
1326                         *(unsigned short *)loc = v;
1327                         break;
1328
1329                 case R_PPC_REL24:
1330                         goto bb_use_plt;
1331
1332                 case R_PPC_REL32:
1333                         *loc = v - dot;
1334                         break;
1335
1336                 case R_PPC_ADDR32:
1337                         *loc = v;
1338                         break;
1339
1340 #elif defined(__s390__)
1341
1342                 case R_390_32:
1343                         *(unsigned int *) loc += v;
1344                         break;
1345                 case R_390_16:
1346                         *(unsigned short *) loc += v;
1347                         break;
1348                 case R_390_8:
1349                         *(unsigned char *) loc += v;
1350                         break;
1351
1352                 case R_390_PC32:
1353                         *(unsigned int *) loc += v - dot;
1354                         break;
1355                 case R_390_PC16DBL:
1356                         *(unsigned short *) loc += (v - dot) >> 1;
1357                         break;
1358                 case R_390_PC16:
1359                         *(unsigned short *) loc += v - dot;
1360                         break;
1361
1362                 case R_390_PLT32:
1363                 case R_390_PLT16DBL:
1364                         /* find the plt entry and initialize it.  */
1365                         pe = (struct arch_single_entry *) &isym->pltent;
1366                         if (pe->inited == 0) {
1367                                 ip = (unsigned long *)(ifile->plt->contents + pe->offset);
1368                                 ip[0] = 0x0d105810; /* basr 1,0; lg 1,10(1); br 1 */
1369                                 ip[1] = 0x100607f1;
1370                                 if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1371                                         ip[2] = v - 2;
1372                                 else
1373                                         ip[2] = v;
1374                                 pe->inited = 1;
1375                         }
1376
1377                         /* Insert relative distance to target.  */
1378                         v = plt + pe->offset - dot;
1379                         if (ELF_R_TYPE(rel->r_info) == R_390_PLT32)
1380                                 *(unsigned int *) loc = (unsigned int) v;
1381                         else if (ELF_R_TYPE(rel->r_info) == R_390_PLT16DBL)
1382                                 *(unsigned short *) loc = (unsigned short) ((v + 2) >> 1);
1383                         break;
1384
1385                 case R_390_GLOB_DAT:
1386                 case R_390_JMP_SLOT:
1387                         *loc = v;
1388                         break;
1389
1390                 case R_390_RELATIVE:
1391                         *loc += f->baseaddr;
1392                         break;
1393
1394                 case R_390_GOTPC:
1395                         *(unsigned long *) loc += got - dot;
1396                         break;
1397
1398                 case R_390_GOT12:
1399                 case R_390_GOT16:
1400                 case R_390_GOT32:
1401                         if (!isym->gotent.inited)
1402                         {
1403                                 isym->gotent.inited = 1;
1404                                 *(ElfW(Addr) *)(ifile->got->contents + isym->gotent.offset) = v;
1405                         }
1406                         if (ELF_R_TYPE(rel->r_info) == R_390_GOT12)
1407                                 *(unsigned short *) loc |= (*(unsigned short *) loc + isym->gotent.offset) & 0xfff;
1408                         else if (ELF_R_TYPE(rel->r_info) == R_390_GOT16)
1409                                 *(unsigned short *) loc += isym->gotent.offset;
1410                         else if (ELF_R_TYPE(rel->r_info) == R_390_GOT32)
1411                                 *(unsigned int *) loc += isym->gotent.offset;
1412                         break;
1413
1414 # ifndef R_390_GOTOFF32
1415 #  define R_390_GOTOFF32 R_390_GOTOFF
1416 # endif
1417                 case R_390_GOTOFF32:
1418                         *loc += v - got;
1419                         break;
1420
1421 #elif defined(__sh__)
1422
1423                 case R_SH_NONE:
1424                         break;
1425
1426                 case R_SH_DIR32:
1427                         *loc += v;
1428                         break;
1429
1430                 case R_SH_REL32:
1431                         *loc += v - dot;
1432                         break;
1433
1434                 case R_SH_PLT32:
1435                         *loc = v - dot;
1436                         break;
1437
1438                 case R_SH_GLOB_DAT:
1439                 case R_SH_JMP_SLOT:
1440                         *loc = v;
1441                         break;
1442
1443                 case R_SH_RELATIVE:
1444                         *loc = f->baseaddr + rel->r_addend;
1445                         break;
1446
1447                 case R_SH_GOTPC:
1448                         *loc = got - dot + rel->r_addend;
1449                         break;
1450
1451                 case R_SH_GOT32:
1452                         goto bb_use_got;
1453
1454                 case R_SH_GOTOFF:
1455                         *loc = v - got;
1456                         break;
1457
1458 # if defined(__SH5__)
1459                 case R_SH_IMM_MEDLOW16:
1460                 case R_SH_IMM_LOW16:
1461                         {
1462                                 ElfW(Addr) word;
1463
1464                                 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16)
1465                                         v >>= 16;
1466
1467                                 /*
1468                                  *  movi and shori have the format:
1469                                  *
1470                                  *  |  op  | imm  | reg | reserved |
1471                                  *   31..26 25..10 9.. 4 3   ..   0
1472                                  *
1473                                  * so we simply mask and or in imm.
1474                                  */
1475                                 word = *loc & ~0x3fffc00;
1476                                 word |= (v & 0xffff) << 10;
1477
1478                                 *loc = word;
1479
1480                                 break;
1481                         }
1482
1483                 case R_SH_IMM_MEDLOW16_PCREL:
1484                 case R_SH_IMM_LOW16_PCREL:
1485                         {
1486                                 ElfW(Addr) word;
1487
1488                                 word = *loc & ~0x3fffc00;
1489
1490                                 v -= dot;
1491
1492                                 if (ELF_R_TYPE(rel->r_info) == R_SH_IMM_MEDLOW16_PCREL)
1493                                         v >>= 16;
1494
1495                                 word |= (v & 0xffff) << 10;
1496
1497                                 *loc = word;
1498
1499                                 break;
1500                         }
1501 # endif /* __SH5__ */
1502
1503 #elif defined(__v850e__)
1504
1505                 case R_V850_NONE:
1506                         break;
1507
1508                 case R_V850_32:
1509                         /* We write two shorts instead of a long because even
1510                            32-bit insns only need half-word alignment, but
1511                            32-bit data needs to be long-word aligned.  */
1512                         v += ((unsigned short *)loc)[0];
1513                         v += ((unsigned short *)loc)[1] << 16;
1514                         ((unsigned short *)loc)[0] = v & 0xffff;
1515                         ((unsigned short *)loc)[1] = (v >> 16) & 0xffff;
1516                         break;
1517
1518                 case R_V850_22_PCREL:
1519                         goto bb_use_plt;
1520
1521 #elif defined(__x86_64__)
1522
1523                 case R_X86_64_NONE:
1524                         break;
1525
1526                 case R_X86_64_64:
1527                         *loc += v;
1528                         break;
1529
1530                 case R_X86_64_32:
1531                         *(unsigned int *) loc += v;
1532                         if (v > 0xffffffff)
1533                         {
1534                                 ret = obj_reloc_overflow; /* Kernel module compiled without -mcmodel=kernel. */
1535                                 /* error("Possibly is module compiled without -mcmodel=kernel!"); */
1536                         }
1537                         break;
1538
1539                 case R_X86_64_32S:
1540                         *(signed int *) loc += v;
1541                         break;
1542
1543                 case R_X86_64_16:
1544                         *(unsigned short *) loc += v;
1545                         break;
1546
1547                 case R_X86_64_8:
1548                         *(unsigned char *) loc += v;
1549                         break;
1550
1551                 case R_X86_64_PC32:
1552                         *(unsigned int *) loc += v - dot;
1553                         break;
1554
1555                 case R_X86_64_PC16:
1556                         *(unsigned short *) loc += v - dot;
1557                         break;
1558
1559                 case R_X86_64_PC8:
1560                         *(unsigned char *) loc += v - dot;
1561                         break;
1562
1563                 case R_X86_64_GLOB_DAT:
1564                 case R_X86_64_JUMP_SLOT:
1565                         *loc = v;
1566                         break;
1567
1568                 case R_X86_64_RELATIVE:
1569                         *loc += f->baseaddr;
1570                         break;
1571
1572                 case R_X86_64_GOT32:
1573                 case R_X86_64_GOTPCREL:
1574                         goto bb_use_got;
1575 # if 0
1576                         if (!isym->gotent.reloc_done)
1577                         {
1578                                 isym->gotent.reloc_done = 1;
1579                                 *(Elf64_Addr *)(ifile->got->contents + isym->gotent.offset) = v;
1580                         }
1581                         /* XXX are these really correct?  */
1582                         if (ELF64_R_TYPE(rel->r_info) == R_X86_64_GOTPCREL)
1583                                 *(unsigned int *) loc += v + isym->gotent.offset;
1584                         else
1585                                 *loc += isym->gotent.offset;
1586                         break;
1587 # endif
1588
1589 #else
1590 # warning "no idea how to handle relocations on your arch"
1591 #endif
1592
1593                 default:
1594                         printf("Warning: unhandled reloc %d\n", (int)ELF_R_TYPE(rel->r_info));
1595                         ret = obj_reloc_unhandled;
1596                         break;
1597
1598 #if defined(USE_PLT_ENTRIES)
1599
1600 bb_use_plt:
1601
1602                         /* find the plt entry and initialize it if necessary */
1603
1604 #if defined(USE_PLT_LIST)
1605                         for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
1606                                 pe = pe->next;
1607 #else
1608                         pe = &isym->pltent;
1609 #endif
1610
1611                         if (! pe->inited) {
1612                                 ip = (unsigned long *) (ifile->plt->contents + pe->offset);
1613
1614                                 /* generate some machine code */
1615
1616 #if defined(__arm__)
1617                                 ip[0] = 0xe51ff004;                     /* ldr pc,[pc,#-4] */
1618                                 ip[1] = v;                              /* sym@ */
1619 #endif
1620 #if defined(__powerpc__)
1621                                 ip[0] = 0x3d600000 + ((v + 0x8000) >> 16);  /* lis r11,sym@ha */
1622                                 ip[1] = 0x396b0000 + (v & 0xffff);          /* addi r11,r11,sym@l */
1623                                 ip[2] = 0x7d6903a6;                           /* mtctr r11 */
1624                                 ip[3] = 0x4e800420;                           /* bctr */
1625 #endif
1626 #if defined(__v850e__)
1627                                 /* We have to trash a register, so we assume that any control
1628                                    transfer more than 21-bits away must be a function call
1629                                    (so we can use a call-clobbered register).  */
1630                                 ip[0] = 0x0621 + ((v & 0xffff) << 16);   /* mov sym, r1 ... */
1631                                 ip[1] = ((v >> 16) & 0xffff) + 0x610000; /* ...; jmp r1 */
1632 #endif
1633                                 pe->inited = 1;
1634                         }
1635
1636                         /* relative distance to target */
1637                         v -= dot;
1638                         /* if the target is too far away.... */
1639 #if defined(__arm__) || defined(__powerpc__)
1640                         if ((int)v < -0x02000000 || (int)v >= 0x02000000)
1641 #elif defined(__v850e__)
1642                                 if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
1643 #endif
1644                                         /* go via the plt */
1645                                         v = plt + pe->offset - dot;
1646
1647 #if defined(__v850e__)
1648                         if (v & 1)
1649 #else
1650                                 if (v & 3)
1651 #endif
1652                                         ret = obj_reloc_dangerous;
1653
1654                         /* merge the offset into the instruction. */
1655 #if defined(__arm__)
1656                         /* Convert to words. */
1657                         v >>= 2;
1658
1659                         *loc = (*loc & ~0x00ffffff) | ((v + *loc) & 0x00ffffff);
1660 #endif
1661 #if defined(__powerpc__)
1662                         *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
1663 #endif
1664 #if defined(__v850e__)
1665                         /* We write two shorts instead of a long because even 32-bit insns
1666                            only need half-word alignment, but the 32-bit data write needs
1667                            to be long-word aligned.  */
1668                         ((unsigned short *)loc)[0] =
1669                                 (*(unsigned short *)loc & 0xffc0) /* opcode + reg */
1670                                 | ((v >> 16) & 0x3f);             /* offs high part */
1671                         ((unsigned short *)loc)[1] =
1672                                 (v & 0xffff);                    /* offs low part */
1673 #endif
1674                         break;
1675 #endif /* USE_PLT_ENTRIES */
1676
1677 #if defined(USE_GOT_ENTRIES)
1678 bb_use_got:
1679
1680                         /* needs an entry in the .got: set it, once */
1681                         if (!isym->gotent.inited) {
1682                                 isym->gotent.inited = 1;
1683                                 *(ElfW(Addr) *) (ifile->got->contents + isym->gotent.offset) = v;
1684                         }
1685                         /* make the reloc with_respect_to_.got */
1686 #if defined(__sh__)
1687                         *loc += isym->gotent.offset + rel->r_addend;
1688 #elif defined(__i386__) || defined(__arm__) || defined(__mc68000__)
1689                         *loc += isym->gotent.offset;
1690 #endif
1691                         break;
1692
1693 #endif /* USE_GOT_ENTRIES */
1694         }
1695
1696         return ret;
1697 }
1698
1699
1700 #if defined(USE_LIST)
1701
1702 static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
1703                           int offset, int size)
1704 {
1705         struct arch_list_entry *pe;
1706
1707         for (pe = *list; pe != NULL; pe = pe->next) {
1708                 if (pe->addend == rel->r_addend) {
1709                         break;
1710                 }
1711         }
1712
1713         if (pe == NULL) {
1714                 pe = xzalloc(sizeof(struct arch_list_entry));
1715                 pe->next = *list;
1716                 pe->addend = rel->r_addend;
1717                 pe->offset = offset;
1718                 /*pe->inited = 0;*/
1719                 *list = pe;
1720                 return size;
1721         }
1722         return 0;
1723 }
1724
1725 #endif
1726
1727 #if defined(USE_SINGLE)
1728
1729 static int arch_single_init(/*ElfW(RelM) *rel,*/ struct arch_single_entry *single,
1730                 int offset, int size)
1731 {
1732         if (single->allocated == 0) {
1733                 single->allocated = 1;
1734                 single->offset = offset;
1735                 single->inited = 0;
1736                 return size;
1737         }
1738         return 0;
1739 }
1740
1741 #endif
1742
1743 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1744
1745 static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
1746                 int offset, int size)
1747 {
1748         struct obj_section *myrelsec = obj_find_section(f, name);
1749
1750         if (offset == 0) {
1751                 offset += size;
1752         }
1753
1754         if (myrelsec) {
1755                 obj_extend_section(myrelsec, offset);
1756         } else {
1757                 myrelsec = obj_create_alloced_section(f, name,
1758                                 size, offset);
1759         }
1760
1761         return myrelsec;
1762 }
1763
1764 #endif
1765
1766 static void arch_create_got(struct obj_file *f)
1767 {
1768 #if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
1769         struct arch_file *ifile = (struct arch_file *) f;
1770         int i;
1771 #if defined(USE_GOT_ENTRIES)
1772         int got_offset = 0, got_needed = 0, got_allocate;
1773 #endif
1774 #if defined(USE_PLT_ENTRIES)
1775         int plt_offset = 0, plt_needed = 0, plt_allocate;
1776 #endif
1777         struct obj_section *relsec, *symsec, *strsec;
1778         ElfW(RelM) *rel, *relend;
1779         ElfW(Sym) *symtab, *extsym;
1780         const char *strtab, *name;
1781         struct arch_symbol *intsym;
1782
1783         for (i = 0; i < f->header.e_shnum; ++i) {
1784                 relsec = f->sections[i];
1785                 if (relsec->header.sh_type != SHT_RELM)
1786                         continue;
1787
1788                 symsec = f->sections[relsec->header.sh_link];
1789                 strsec = f->sections[symsec->header.sh_link];
1790
1791                 rel = (ElfW(RelM) *) relsec->contents;
1792                 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
1793                 symtab = (ElfW(Sym) *) symsec->contents;
1794                 strtab = (const char *) strsec->contents;
1795
1796                 for (; rel < relend; ++rel) {
1797                         extsym = &symtab[ELF_R_SYM(rel->r_info)];
1798
1799 #if defined(USE_GOT_ENTRIES)
1800                         got_allocate = 0;
1801 #endif
1802 #if defined(USE_PLT_ENTRIES)
1803                         plt_allocate = 0;
1804 #endif
1805
1806                         switch (ELF_R_TYPE(rel->r_info)) {
1807 #if defined(__arm__)
1808                         case R_ARM_PC24:
1809                         case R_ARM_PLT32:
1810                                 plt_allocate = 1;
1811                                 break;
1812
1813                         case R_ARM_GOTOFF:
1814                         case R_ARM_GOTPC:
1815                                 got_needed = 1;
1816                                 continue;
1817
1818                         case R_ARM_GOT32:
1819                                 got_allocate = 1;
1820                                 break;
1821
1822 #elif defined(__i386__)
1823                         case R_386_GOTPC:
1824                         case R_386_GOTOFF:
1825                                 got_needed = 1;
1826                                 continue;
1827
1828                         case R_386_GOT32:
1829                                 got_allocate = 1;
1830                                 break;
1831
1832 #elif defined(__powerpc__)
1833                         case R_PPC_REL24:
1834                                 plt_allocate = 1;
1835                                 break;
1836
1837 #elif defined(__mc68000__)
1838                         case R_68K_GOT32:
1839                                 got_allocate = 1;
1840                                 break;
1841
1842 #ifdef R_68K_GOTOFF
1843                         case R_68K_GOTOFF:
1844                                 got_needed = 1;
1845                                 continue;
1846 #endif
1847
1848 #elif defined(__sh__)
1849                         case R_SH_GOT32:
1850                                 got_allocate = 1;
1851                                 break;
1852
1853                         case R_SH_GOTPC:
1854                         case R_SH_GOTOFF:
1855                                 got_needed = 1;
1856                                 continue;
1857
1858 #elif defined(__v850e__)
1859                         case R_V850_22_PCREL:
1860                                 plt_needed = 1;
1861                                 break;
1862
1863 #endif
1864                         default:
1865                                 continue;
1866                         }
1867
1868                         if (extsym->st_name != 0) {
1869                                 name = strtab + extsym->st_name;
1870                         } else {
1871                                 name = f->sections[extsym->st_shndx]->name;
1872                         }
1873                         intsym = (struct arch_symbol *) obj_find_symbol(f, name);
1874 #if defined(USE_GOT_ENTRIES)
1875                         if (got_allocate) {
1876                                 got_offset += arch_single_init(
1877                                                 /*rel,*/ &intsym->gotent,
1878                                                 got_offset, GOT_ENTRY_SIZE);
1879
1880                                 got_needed = 1;
1881                         }
1882 #endif
1883 #if defined(USE_PLT_ENTRIES)
1884                         if (plt_allocate) {
1885 #if defined(USE_PLT_LIST)
1886                                 plt_offset += arch_list_add(
1887                                                 rel, &intsym->pltent,
1888                                                 plt_offset, PLT_ENTRY_SIZE);
1889 #else
1890                                 plt_offset += arch_single_init(
1891                                                 /*rel,*/ &intsym->pltent,
1892                                                 plt_offset, PLT_ENTRY_SIZE);
1893 #endif
1894                                 plt_needed = 1;
1895                         }
1896 #endif
1897                 }
1898         }
1899
1900 #if defined(USE_GOT_ENTRIES)
1901         if (got_needed) {
1902                 ifile->got = arch_xsect_init(f, ".got", got_offset,
1903                                 GOT_ENTRY_SIZE);
1904         }
1905 #endif
1906
1907 #if defined(USE_PLT_ENTRIES)
1908         if (plt_needed) {
1909                 ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
1910                                 PLT_ENTRY_SIZE);
1911         }
1912 #endif
1913
1914 #endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
1915 }
1916
1917 /*======================================================================*/
1918
1919 /* Standard ELF hash function.  */
1920 static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
1921 {
1922         unsigned long h = 0;
1923         unsigned long g;
1924         unsigned char ch;
1925
1926         while (n > 0) {
1927                 ch = *name++;
1928                 h = (h << 4) + ch;
1929                 g = (h & 0xf0000000);
1930                 if (g != 0) {
1931                         h ^= g >> 24;
1932                         h &= ~g;
1933                 }
1934                 n--;
1935         }
1936         return h;
1937 }
1938
1939 static unsigned long FAST_FUNC obj_elf_hash(const char *name)
1940 {
1941         return obj_elf_hash_n(name, strlen(name));
1942 }
1943
1944 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
1945 /* String comparison for non-co-versioned kernel and module.  */
1946
1947 static int ncv_strcmp(const char *a, const char *b)
1948 {
1949         size_t alen = strlen(a), blen = strlen(b);
1950
1951         if (blen == alen + 10 && b[alen] == '_' && b[alen + 1] == 'R')
1952                 return strncmp(a, b, alen);
1953         else if (alen == blen + 10 && a[blen] == '_' && a[blen + 1] == 'R')
1954                 return strncmp(a, b, blen);
1955         else
1956                 return strcmp(a, b);
1957 }
1958
1959 /* String hashing for non-co-versioned kernel and module.  Here
1960    we are simply forced to drop the crc from the hash.  */
1961
1962 static unsigned long FAST_FUNC ncv_symbol_hash(const char *str)
1963 {
1964         size_t len = strlen(str);
1965         if (len > 10 && str[len - 10] == '_' && str[len - 9] == 'R')
1966                 len -= 10;
1967         return obj_elf_hash_n(str, len);
1968 }
1969
1970 static void
1971 obj_set_symbol_compare(struct obj_file *f,
1972                 int (*cmp) (const char *, const char *),
1973                 unsigned long (*hash) (const char *) FAST_FUNC)
1974 {
1975         if (cmp)
1976                 f->symbol_cmp = cmp;
1977         if (hash) {
1978                 struct obj_symbol *tmptab[HASH_BUCKETS], *sym, *next;
1979                 int i;
1980
1981                 f->symbol_hash = hash;
1982
1983                 memcpy(tmptab, f->symtab, sizeof(tmptab));
1984                 memset(f->symtab, 0, sizeof(f->symtab));
1985
1986                 for (i = 0; i < HASH_BUCKETS; ++i) {
1987                         for (sym = tmptab[i]; sym; sym = next) {
1988                                 unsigned long h = hash(sym->name) % HASH_BUCKETS;
1989                                 next = sym->next;
1990                                 sym->next = f->symtab[h];
1991                                 f->symtab[h] = sym;
1992                         }
1993                 }
1994         }
1995 }
1996
1997 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
1998
1999 static struct obj_symbol *
2000 obj_add_symbol(struct obj_file *f, const char *name,
2001                 unsigned long symidx, int info,
2002                 int secidx, ElfW(Addr) value,
2003                 unsigned long size)
2004 {
2005         struct obj_symbol *sym;
2006         unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2007         int n_type = ELF_ST_TYPE(info);
2008         int n_binding = ELF_ST_BIND(info);
2009
2010         for (sym = f->symtab[hash]; sym; sym = sym->next) {
2011                 if (f->symbol_cmp(sym->name, name) == 0) {
2012                         int o_secidx = sym->secidx;
2013                         int o_info = sym->info;
2014                         int o_type = ELF_ST_TYPE(o_info);
2015                         int o_binding = ELF_ST_BIND(o_info);
2016
2017                         /* A redefinition!  Is it legal?  */
2018
2019                         if (secidx == SHN_UNDEF)
2020                                 return sym;
2021                         else if (o_secidx == SHN_UNDEF)
2022                                 goto found;
2023                         else if (n_binding == STB_GLOBAL && o_binding == STB_LOCAL) {
2024                                 /* Cope with local and global symbols of the same name
2025                                    in the same object file, as might have been created
2026                                    by ld -r.  The only reason locals are now seen at this
2027                                    level at all is so that we can do semi-sensible things
2028                                    with parameters.  */
2029
2030                                 struct obj_symbol *nsym, **p;
2031
2032                                 nsym = arch_new_symbol();
2033                                 nsym->next = sym->next;
2034                                 nsym->ksymidx = -1;
2035
2036                                 /* Excise the old (local) symbol from the hash chain.  */
2037                                 for (p = &f->symtab[hash]; *p != sym; p = &(*p)->next)
2038                                         continue;
2039                                 *p = sym = nsym;
2040                                 goto found;
2041                         } else if (n_binding == STB_LOCAL) {
2042                                 /* Another symbol of the same name has already been defined.
2043                                    Just add this to the local table.  */
2044                                 sym = arch_new_symbol();
2045                                 sym->next = NULL;
2046                                 sym->ksymidx = -1;
2047                                 f->local_symtab[symidx] = sym;
2048                                 goto found;
2049                         } else if (n_binding == STB_WEAK)
2050                                 return sym;
2051                         else if (o_binding == STB_WEAK)
2052                                 goto found;
2053                         /* Don't unify COMMON symbols with object types the programmer
2054                            doesn't expect.  */
2055                         else if (secidx == SHN_COMMON
2056                                         && (o_type == STT_NOTYPE || o_type == STT_OBJECT))
2057                                 return sym;
2058                         else if (o_secidx == SHN_COMMON
2059                                         && (n_type == STT_NOTYPE || n_type == STT_OBJECT))
2060                                 goto found;
2061                         else {
2062                                 /* Don't report an error if the symbol is coming from
2063                                    the kernel or some external module.  */
2064                                 if (secidx <= SHN_HIRESERVE)
2065                                         bb_error_msg("%s multiply defined", name);
2066                                 return sym;
2067                         }
2068                 }
2069         }
2070
2071         /* Completely new symbol.  */
2072         sym = arch_new_symbol();
2073         sym->next = f->symtab[hash];
2074         f->symtab[hash] = sym;
2075         sym->ksymidx = -1;
2076         if (ELF_ST_BIND(info) == STB_LOCAL && symidx != (unsigned long)(-1)) {
2077                 if (symidx >= f->local_symtab_size)
2078                         bb_error_msg("local symbol %s with index %ld exceeds local_symtab_size %ld",
2079                                         name, (long) symidx, (long) f->local_symtab_size);
2080                 else
2081                         f->local_symtab[symidx] = sym;
2082         }
2083
2084 found:
2085         sym->name = name;
2086         sym->value = value;
2087         sym->size = size;
2088         sym->secidx = secidx;
2089         sym->info = info;
2090
2091         return sym;
2092 }
2093
2094 static struct obj_symbol *
2095 obj_find_symbol(struct obj_file *f, const char *name)
2096 {
2097         struct obj_symbol *sym;
2098         unsigned long hash = f->symbol_hash(name) % HASH_BUCKETS;
2099
2100         for (sym = f->symtab[hash]; sym; sym = sym->next)
2101                 if (f->symbol_cmp(sym->name, name) == 0)
2102                         return sym;
2103         return NULL;
2104 }
2105
2106 static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
2107 {
2108         if (sym) {
2109                 if (sym->secidx >= SHN_LORESERVE)
2110                         return sym->value;
2111                 return sym->value + f->sections[sym->secidx]->header.sh_addr;
2112         }
2113         /* As a special case, a NULL sym has value zero.  */
2114         return 0;
2115 }
2116
2117 static struct obj_section *obj_find_section(struct obj_file *f, const char *name)
2118 {
2119         int i, n = f->header.e_shnum;
2120
2121         for (i = 0; i < n; ++i)
2122                 if (strcmp(f->sections[i]->name, name) == 0)
2123                         return f->sections[i];
2124         return NULL;
2125 }
2126
2127 static int obj_load_order_prio(struct obj_section *a)
2128 {
2129         unsigned long af, ac;
2130
2131         af = a->header.sh_flags;
2132
2133         ac = 0;
2134         if (a->name[0] != '.' || strlen(a->name) != 10
2135          || strcmp(a->name + 5, ".init") != 0
2136         ) {
2137                 ac |= 32;
2138         }
2139         if (af & SHF_ALLOC)
2140                 ac |= 16;
2141         if (!(af & SHF_WRITE))
2142                 ac |= 8;
2143         if (af & SHF_EXECINSTR)
2144                 ac |= 4;
2145         if (a->header.sh_type != SHT_NOBITS)
2146                 ac |= 2;
2147
2148         return ac;
2149 }
2150
2151 static void
2152 obj_insert_section_load_order(struct obj_file *f, struct obj_section *sec)
2153 {
2154         struct obj_section **p;
2155         int prio = obj_load_order_prio(sec);
2156         for (p = f->load_order_search_start; *p; p = &(*p)->load_next)
2157                 if (obj_load_order_prio(*p) < prio)
2158                         break;
2159         sec->load_next = *p;
2160         *p = sec;
2161 }
2162
2163 static struct obj_section *helper_create_alloced_section(struct obj_file *f,
2164                 const char *name,
2165                 unsigned long align,
2166                 unsigned long size)
2167 {
2168         int newidx = f->header.e_shnum++;
2169         struct obj_section *sec;
2170
2171         f->sections = xrealloc_vector(f->sections, 2, newidx);
2172         f->sections[newidx] = sec = arch_new_section();
2173
2174         sec->header.sh_type = SHT_PROGBITS;
2175         sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
2176         sec->header.sh_size = size;
2177         sec->header.sh_addralign = align;
2178         sec->name = name;
2179         sec->idx = newidx;
2180         if (size)
2181                 sec->contents = xzalloc(size);
2182
2183         return sec;
2184 }
2185
2186 static struct obj_section *obj_create_alloced_section(struct obj_file *f,
2187                 const char *name,
2188                 unsigned long align,
2189                 unsigned long size)
2190 {
2191         struct obj_section *sec;
2192
2193         sec = helper_create_alloced_section(f, name, align, size);
2194         obj_insert_section_load_order(f, sec);
2195         return sec;
2196 }
2197
2198 static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
2199                 const char *name,
2200                 unsigned long align,
2201                 unsigned long size)
2202 {
2203         struct obj_section *sec;
2204
2205         sec = helper_create_alloced_section(f, name, align, size);
2206         sec->load_next = f->load_order;
2207         f->load_order = sec;
2208         if (f->load_order_search_start == &f->load_order)
2209                 f->load_order_search_start = &sec->load_next;
2210
2211         return sec;
2212 }
2213
2214 static void *obj_extend_section(struct obj_section *sec, unsigned long more)
2215 {
2216         unsigned long oldsize = sec->header.sh_size;
2217         if (more) {
2218                 sec->header.sh_size += more;
2219                 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2220         }
2221         return sec->contents + oldsize;
2222 }
2223
2224
2225 /* Conditionally add the symbols from the given symbol set to the
2226    new module.  */
2227
2228 static int add_symbols_from(struct obj_file *f,
2229                 int idx,
2230                 struct new_module_symbol *syms,
2231                 size_t nsyms)
2232 {
2233         struct new_module_symbol *s;
2234         size_t i;
2235         int used = 0;
2236 #ifdef SYMBOL_PREFIX
2237         char *name_buf = NULL;
2238         size_t name_alloced_size = 0;
2239 #endif
2240 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2241         int gpl;
2242
2243         gpl = obj_gpl_license(f, NULL) == 0;
2244 #endif
2245         for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2246                 /* Only add symbols that are already marked external.
2247                    If we override locals we may cause problems for
2248                    argument initialization.  We will also create a false
2249                    dependency on the module.  */
2250                 struct obj_symbol *sym;
2251                 char *name;
2252
2253                 /* GPL licensed modules can use symbols exported with
2254                  * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2255                  * exported names.  Non-GPL modules never see any GPLONLY_
2256                  * symbols so they cannot fudge it by adding the prefix on
2257                  * their references.
2258                  */
2259                 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2260 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2261                         if (gpl)
2262                                 s->name += 8;
2263                         else
2264 #endif
2265                                 continue;
2266                 }
2267                 name = (char *)s->name;
2268
2269 #ifdef SYMBOL_PREFIX
2270                 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2271                    kernel exports `C names', but module object files
2272                    reference `linker names').  */
2273                 size_t extra = sizeof SYMBOL_PREFIX;
2274                 size_t name_size = strlen(name) + extra;
2275                 if (name_size > name_alloced_size) {
2276                         name_alloced_size = name_size * 2;
2277                         name_buf = alloca(name_alloced_size);
2278                 }
2279                 strcpy(name_buf, SYMBOL_PREFIX);
2280                 strcpy(name_buf + extra - 1, name);
2281                 name = name_buf;
2282 #endif
2283
2284                 sym = obj_find_symbol(f, name);
2285                 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2286 #ifdef SYMBOL_PREFIX
2287                         /* Put NAME_BUF into more permanent storage.  */
2288                         name = xmalloc(name_size);
2289                         strcpy(name, name_buf);
2290 #endif
2291                         sym = obj_add_symbol(f, name, -1,
2292                                         ELF_ST_INFO(STB_GLOBAL,
2293                                                 STT_NOTYPE),
2294                                         idx, s->value, 0);
2295                         /* Did our symbol just get installed?  If so, mark the
2296                            module as "used".  */
2297                         if (sym->secidx == idx)
2298                                 used = 1;
2299                 }
2300         }
2301
2302         return used;
2303 }
2304
2305 static void add_kernel_symbols(struct obj_file *f)
2306 {
2307         struct external_module *m;
2308         int i, nused = 0;
2309
2310         /* Add module symbols first.  */
2311
2312         for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2313                 if (m->nsyms
2314                  && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2315                 ) {
2316                         m->used = 1;
2317                         ++nused;
2318                 }
2319         }
2320
2321         n_ext_modules_used = nused;
2322
2323         /* And finally the symbols from the kernel proper.  */
2324
2325         if (nksyms)
2326                 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2327 }
2328
2329 static char *get_modinfo_value(struct obj_file *f, const char *key)
2330 {
2331         struct obj_section *sec;
2332         char *p, *v, *n, *ep;
2333         size_t klen = strlen(key);
2334
2335         sec = obj_find_section(f, ".modinfo");
2336         if (sec == NULL)
2337                 return NULL;
2338         p = sec->contents;
2339         ep = p + sec->header.sh_size;
2340         while (p < ep) {
2341                 v = strchr(p, '=');
2342                 n = strchr(p, '\0');
2343                 if (v) {
2344                         if (p + klen == v && strncmp(p, key, klen) == 0)
2345                                 return v + 1;
2346                 } else {
2347                         if (p + klen == n && strcmp(p, key) == 0)
2348                                 return n;
2349                 }
2350                 p = n + 1;
2351         }
2352
2353         return NULL;
2354 }
2355
2356
2357 /*======================================================================*/
2358 /* Functions relating to module loading after 2.1.18.  */
2359
2360 /* From Linux-2.6 sources */
2361 /* You can use " around spaces, but can't escape ". */
2362 /* Hyphens and underscores equivalent in parameter names. */
2363 static char *next_arg(char *args, char **param, char **val)
2364 {
2365         unsigned int i, equals = 0;
2366         int in_quote = 0, quoted = 0;
2367         char *next;
2368
2369         if (*args == '"') {
2370                 args++;
2371                 in_quote = 1;
2372                 quoted = 1;
2373         }
2374
2375         for (i = 0; args[i]; i++) {
2376                 if (args[i] == ' ' && !in_quote)
2377                         break;
2378                 if (equals == 0) {
2379                         if (args[i] == '=')
2380                                 equals = i;
2381                 }
2382                 if (args[i] == '"')
2383                         in_quote = !in_quote;
2384         }
2385
2386         *param = args;
2387         if (!equals)
2388                 *val = NULL;
2389         else {
2390                 args[equals] = '\0';
2391                 *val = args + equals + 1;
2392
2393                 /* Don't include quotes in value. */
2394                 if (**val == '"') {
2395                         (*val)++;
2396                         if (args[i-1] == '"')
2397                                 args[i-1] = '\0';
2398                 }
2399                 if (quoted && args[i-1] == '"')
2400                         args[i-1] = '\0';
2401         }
2402
2403         if (args[i]) {
2404                 args[i] = '\0';
2405                 next = args + i + 1;
2406         } else
2407                 next = args + i;
2408
2409         /* Chew up trailing spaces. */
2410         return skip_whitespace(next);
2411 }
2412
2413 static void
2414 new_process_module_arguments(struct obj_file *f, const char *options)
2415 {
2416         char *xoptions, *pos;
2417         char *param, *val;
2418
2419         xoptions = pos = xstrdup(skip_whitespace(options));
2420         while (*pos) {
2421                 unsigned long charssize = 0;
2422                 char *tmp, *contents, *loc, *pinfo, *p;
2423                 struct obj_symbol *sym;
2424                 int min, max, n, len;
2425
2426                 pos = next_arg(pos, &param, &val);
2427
2428                 tmp = xasprintf("parm_%s", param);
2429                 pinfo = get_modinfo_value(f, tmp);
2430                 free(tmp);
2431                 if (pinfo == NULL)
2432                         bb_error_msg_and_die("invalid parameter %s", param);
2433
2434 #ifdef SYMBOL_PREFIX
2435                 tmp = xasprintf(SYMBOL_PREFIX "%s", param);
2436                 sym = obj_find_symbol(f, tmp);
2437                 free(tmp);
2438 #else
2439                 sym = obj_find_symbol(f, param);
2440 #endif
2441
2442                 /* Also check that the parameter was not resolved from the kernel.  */
2443                 if (sym == NULL || sym->secidx > SHN_HIRESERVE)
2444                         bb_error_msg_and_die("symbol for parameter %s not found", param);
2445
2446                 /* Number of parameters */
2447                 if (isdigit(*pinfo)) {
2448                         min = strtoul(pinfo, &pinfo, 10);
2449                         if (*pinfo == '-')
2450                                 max = strtoul(pinfo + 1, &pinfo, 10);
2451                         else
2452                                 max = min;
2453                 } else
2454                         min = max = 1;
2455
2456                 contents = f->sections[sym->secidx]->contents;
2457                 loc = contents + sym->value;
2458
2459                 if (*pinfo == 'c') {
2460                         if (!isdigit(pinfo[1])) {
2461                                 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2462                                                      " the maximum size", param);
2463                         }
2464                         charssize = strtoul(pinfo + 1, NULL, 10);
2465                 }
2466
2467                 if (val == NULL) {
2468                         if (*pinfo != 'b')
2469                                 bb_error_msg_and_die("argument expected for parameter %s", param);
2470                         val = (char *) "1";
2471                 }
2472
2473                 /* Parse parameter values */
2474                 n = 0;
2475                 p = val;
2476                 while (*p != 0) {
2477                         char *endp;
2478
2479                         if (++n > max)
2480                                 bb_error_msg_and_die("too many values for %s (max %d)", param, max);
2481
2482                         switch (*pinfo) {
2483                         case 's':
2484                                 len = strcspn(p, ",");
2485                                 p[len] = 0;
2486                                 obj_string_patch(f, sym->secidx,
2487                                                  loc - contents, p);
2488                                 loc += tgt_sizeof_char_p;
2489                                 p += len;
2490                                 break;
2491                         case 'c':
2492                                 len = strcspn(p, ",");
2493                                 p[len] = 0;
2494                                 if (len >= charssize)
2495                                         bb_error_msg_and_die("string too long for %s (max %ld)", param,
2496                                                              charssize - 1);
2497                                 strcpy((char *) loc, p);
2498                                 loc += charssize;
2499                                 p += len;
2500                                 break;
2501                         case 'b':
2502                                 *loc++ = strtoul(p, &endp, 0);
2503                                 p = endp; /* gcc likes temp var for &endp */
2504                                 break;
2505                         case 'h':
2506                                 *(short *) loc = strtoul(p, &endp, 0);
2507                                 loc += tgt_sizeof_short;
2508                                 p = endp;
2509                                 break;
2510                         case 'i':
2511                                 *(int *) loc = strtoul(p, &endp, 0);
2512                                 loc += tgt_sizeof_int;
2513                                 p = endp;
2514                                 break;
2515                         case 'l':
2516                                 *(long *) loc = strtoul(p, &endp, 0);
2517                                 loc += tgt_sizeof_long;
2518                                 p = endp;
2519                                 break;
2520                         default:
2521                                 bb_error_msg_and_die("unknown parameter type '%c' for %s",
2522                                                      *pinfo, param);
2523                         }
2524
2525                         p = skip_whitespace(p);
2526                         if (*p != ',')
2527                                 break;
2528                         p = skip_whitespace(p + 1);
2529                 }
2530
2531                 if (n < min)
2532                         bb_error_msg_and_die("parameter %s requires at least %d arguments", param, min);
2533                 if (*p != '\0')
2534                         bb_error_msg_and_die("invalid argument syntax for %s", param);
2535         }
2536
2537         free(xoptions);
2538 }
2539
2540 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2541 static int new_is_module_checksummed(struct obj_file *f)
2542 {
2543         const char *p = get_modinfo_value(f, "using_checksums");
2544         if (p)
2545                 return xatoi(p);
2546         return 0;
2547 }
2548
2549 /* Get the module's kernel version in the canonical integer form.  */
2550
2551 static int
2552 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2553 {
2554         char *p, *q;
2555         int a, b, c;
2556
2557         p = get_modinfo_value(f, "kernel_version");
2558         if (p == NULL)
2559                 return -1;
2560         safe_strncpy(str, p, STRVERSIONLEN);
2561
2562         a = strtoul(p, &p, 10);
2563         if (*p != '.')
2564                 return -1;
2565         b = strtoul(p + 1, &p, 10);
2566         if (*p != '.')
2567                 return -1;
2568         c = strtoul(p + 1, &q, 10);
2569         if (p + 1 == q)
2570                 return -1;
2571
2572         return a << 16 | b << 8 | c;
2573 }
2574
2575 #endif   /* FEATURE_INSMOD_VERSION_CHECKING */
2576
2577
2578 /* Fetch the loaded modules, and all currently exported symbols.  */
2579
2580 static void new_get_kernel_symbols(void)
2581 {
2582         char *module_names, *mn;
2583         struct external_module *modules, *m;
2584         struct new_module_symbol *syms, *s;
2585         size_t ret, bufsize, nmod, nsyms, i, j;
2586
2587         /* Collect the loaded modules.  */
2588
2589         bufsize = 256;
2590         module_names = xmalloc(bufsize);
2591
2592  retry_modules_load:
2593         if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2594                 if (errno == ENOSPC && bufsize < ret) {
2595                         bufsize = ret;
2596                         module_names = xrealloc(module_names, bufsize);
2597                         goto retry_modules_load;
2598                 }
2599                 bb_perror_msg_and_die("QM_MODULES");
2600         }
2601
2602         n_ext_modules = nmod = ret;
2603
2604         /* Collect the modules' symbols.  */
2605
2606         if (nmod) {
2607                 ext_modules = modules = xzalloc(nmod * sizeof(*modules));
2608                 for (i = 0, mn = module_names, m = modules;
2609                                 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2610                         struct new_module_info info;
2611
2612                         if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2613                                 if (errno == ENOENT) {
2614                                         /* The module was removed out from underneath us.  */
2615                                         continue;
2616                                 }
2617                                 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2618                         }
2619
2620                         bufsize = 1024;
2621                         syms = xmalloc(bufsize);
2622  retry_mod_sym_load:
2623                         if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2624                                 switch (errno) {
2625                                         case ENOSPC:
2626                                                 bufsize = ret;
2627                                                 syms = xrealloc(syms, bufsize);
2628                                                 goto retry_mod_sym_load;
2629                                         case ENOENT:
2630                                                 /* The module was removed out from underneath us.  */
2631                                                 continue;
2632                                         default:
2633                                                 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2634                                 }
2635                         }
2636                         nsyms = ret;
2637
2638                         m->name = mn;
2639                         m->addr = info.addr;
2640                         m->nsyms = nsyms;
2641                         m->syms = syms;
2642
2643                         for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2644                                 s->name += (unsigned long) syms;
2645                         }
2646                 }
2647         }
2648
2649         /* Collect the kernel's symbols.  */
2650
2651         bufsize = 16 * 1024;
2652         syms = xmalloc(bufsize);
2653  retry_kern_sym_load:
2654         if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2655                 if (errno == ENOSPC && bufsize < ret) {
2656                         bufsize = ret;
2657                         syms = xrealloc(syms, bufsize);
2658                         goto retry_kern_sym_load;
2659                 }
2660                 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2661         }
2662         nksyms = nsyms = ret;
2663         ksyms = syms;
2664
2665         for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2666                 s->name += (unsigned long) syms;
2667         }
2668 }
2669
2670
2671 /* Return the kernel symbol checksum version, or zero if not used.  */
2672
2673 static int new_is_kernel_checksummed(void)
2674 {
2675         struct new_module_symbol *s;
2676         size_t i;
2677
2678         /* Using_Versions is not the first symbol, but it should be in there.  */
2679
2680         for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2681                 if (strcmp((char *) s->name, "Using_Versions") == 0)
2682                         return s->value;
2683
2684         return 0;
2685 }
2686
2687
2688 static void new_create_this_module(struct obj_file *f, const char *m_name)
2689 {
2690         struct obj_section *sec;
2691
2692         sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2693                         sizeof(struct new_module));
2694         /* done by obj_create_alloced_section_first: */
2695         /*memset(sec->contents, 0, sizeof(struct new_module));*/
2696
2697         obj_add_symbol(f, SPFX "__this_module", -1,
2698                         ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2699                         sizeof(struct new_module));
2700
2701         obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2702                         m_name);
2703 }
2704
2705 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2706 /* add an entry to the __ksymtab section, creating it if necessary */
2707 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2708 {
2709         struct obj_section *sec;
2710         ElfW(Addr) ofs;
2711
2712         /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2713          * If __ksymtab is defined but not marked alloc, x out the first character
2714          * (no obj_delete routine) and create a new __ksymtab with the correct
2715          * characteristics.
2716          */
2717         sec = obj_find_section(f, "__ksymtab");
2718         if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2719                 *((char *)(sec->name)) = 'x';   /* override const */
2720                 sec = NULL;
2721         }
2722         if (!sec)
2723                 sec = obj_create_alloced_section(f, "__ksymtab",
2724                                 tgt_sizeof_void_p, 0);
2725         if (!sec)
2726                 return;
2727         sec->header.sh_flags |= SHF_ALLOC;
2728         /* Empty section might be byte-aligned */
2729         sec->header.sh_addralign = tgt_sizeof_void_p;
2730         ofs = sec->header.sh_size;
2731         obj_symbol_patch(f, sec->idx, ofs, sym);
2732         obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2733         obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2734 }
2735 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2736
2737 static int new_create_module_ksymtab(struct obj_file *f)
2738 {
2739         struct obj_section *sec;
2740         int i;
2741
2742         /* We must always add the module references.  */
2743
2744         if (n_ext_modules_used) {
2745                 struct new_module_ref *dep;
2746                 struct obj_symbol *tm;
2747
2748                 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2749                                 (sizeof(struct new_module_ref)
2750                                  * n_ext_modules_used));
2751                 if (!sec)
2752                         return 0;
2753
2754                 tm = obj_find_symbol(f, SPFX "__this_module");
2755                 dep = (struct new_module_ref *) sec->contents;
2756                 for (i = 0; i < n_ext_modules; ++i)
2757                         if (ext_modules[i].used) {
2758                                 dep->dep = ext_modules[i].addr;
2759                                 obj_symbol_patch(f, sec->idx,
2760                                                 (char *) &dep->ref - sec->contents, tm);
2761                                 dep->next_ref = 0;
2762                                 ++dep;
2763                         }
2764         }
2765
2766         if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2767                 size_t nsyms;
2768                 int *loaded;
2769
2770                 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2771
2772                 /* We don't want to export symbols residing in sections that
2773                    aren't loaded.  There are a number of these created so that
2774                    we make sure certain module options don't appear twice.  */
2775                 i = f->header.e_shnum;
2776                 loaded = alloca(sizeof(int) * i);
2777                 while (--i >= 0)
2778                         loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2779
2780                 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2781                         struct obj_symbol *sym;
2782                         for (sym = f->symtab[i]; sym; sym = sym->next) {
2783                                 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2784                                  && sym->secidx <= SHN_HIRESERVE
2785                                  && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
2786                                 ) {
2787                                         ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2788
2789                                         obj_symbol_patch(f, sec->idx, ofs, sym);
2790                                         obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2791                                                         sym->name);
2792                                         nsyms++;
2793                                 }
2794                         }
2795                 }
2796
2797                 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2798         }
2799
2800         return 1;
2801 }
2802
2803
2804 static int
2805 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2806 {
2807         struct new_module *module;
2808         struct obj_section *sec;
2809         void *image;
2810         int ret;
2811         tgt_long m_addr;
2812
2813         sec = obj_find_section(f, ".this");
2814         if (!sec || !sec->contents) {
2815                 bb_perror_msg_and_die("corrupt module %s?", m_name);
2816         }
2817         module = (struct new_module *) sec->contents;
2818         m_addr = sec->header.sh_addr;
2819
2820         module->size_of_struct = sizeof(*module);
2821         module->size = m_size;
2822         module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2823
2824         sec = obj_find_section(f, "__ksymtab");
2825         if (sec && sec->header.sh_size) {
2826                 module->syms = sec->header.sh_addr;
2827                 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2828         }
2829
2830         if (n_ext_modules_used) {
2831                 sec = obj_find_section(f, ".kmodtab");
2832                 module->deps = sec->header.sh_addr;
2833                 module->ndeps = n_ext_modules_used;
2834         }
2835
2836         module->init = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2837         module->cleanup = obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2838
2839         sec = obj_find_section(f, "__ex_table");
2840         if (sec) {
2841                 module->ex_table_start = sec->header.sh_addr;
2842                 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2843         }
2844
2845         sec = obj_find_section(f, ".text.init");
2846         if (sec) {
2847                 module->runsize = sec->header.sh_addr - m_addr;
2848         }
2849         sec = obj_find_section(f, ".data.init");
2850         if (sec) {
2851                 if (!module->runsize
2852                  || module->runsize > sec->header.sh_addr - m_addr
2853                 ) {
2854                         module->runsize = sec->header.sh_addr - m_addr;
2855                 }
2856         }
2857         sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2858         if (sec && sec->header.sh_size) {
2859                 module->archdata_start = (void*)sec->header.sh_addr;
2860                 module->archdata_end = module->archdata_start + sec->header.sh_size;
2861         }
2862         sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2863         if (sec && sec->header.sh_size) {
2864                 module->kallsyms_start = (void*)sec->header.sh_addr;
2865                 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2866         }
2867
2868         /* Whew!  All of the initialization is complete.  Collect the final
2869            module image and give it to the kernel.  */
2870
2871         image = xmalloc(m_size);
2872         obj_create_image(f, image);
2873
2874         ret = init_module(m_name, (struct new_module *) image);
2875         if (ret)
2876                 bb_perror_msg("init_module: %s", m_name);
2877
2878         free(image);
2879
2880         return ret == 0;
2881 }
2882
2883
2884 /*======================================================================*/
2885
2886 static void
2887 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2888                                  const char *string)
2889 {
2890         struct obj_string_patch *p;
2891         struct obj_section *strsec;
2892         size_t len = strlen(string) + 1;
2893         char *loc;
2894
2895         p = xzalloc(sizeof(*p));
2896         p->next = f->string_patches;
2897         p->reloc_secidx = secidx;
2898         p->reloc_offset = offset;
2899         f->string_patches = p;
2900
2901         strsec = obj_find_section(f, ".kstrtab");
2902         if (strsec == NULL) {
2903                 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2904                 /*p->string_offset = 0;*/
2905                 loc = strsec->contents;
2906         } else {
2907                 p->string_offset = strsec->header.sh_size;
2908                 loc = obj_extend_section(strsec, len);
2909         }
2910         memcpy(loc, string, len);
2911 }
2912
2913 static void
2914 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2915                 struct obj_symbol *sym)
2916 {
2917         struct obj_symbol_patch *p;
2918
2919         p = xmalloc(sizeof(*p));
2920         p->next = f->symbol_patches;
2921         p->reloc_secidx = secidx;
2922         p->reloc_offset = offset;
2923         p->sym = sym;
2924         f->symbol_patches = p;
2925 }
2926
2927 static void obj_check_undefineds(struct obj_file *f)
2928 {
2929         unsigned i;
2930
2931         for (i = 0; i < HASH_BUCKETS; ++i) {
2932                 struct obj_symbol *sym;
2933                 for (sym = f->symtab[i]; sym; sym = sym->next) {
2934                         if (sym->secidx == SHN_UNDEF) {
2935                                 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
2936                                         sym->secidx = SHN_ABS;
2937                                         sym->value = 0;
2938                                 } else {
2939                                         if (!flag_quiet)
2940                                                 bb_error_msg_and_die("unresolved symbol %s", sym->name);
2941                                 }
2942                         }
2943                 }
2944         }
2945 }
2946
2947 static void obj_allocate_commons(struct obj_file *f)
2948 {
2949         struct common_entry {
2950                 struct common_entry *next;
2951                 struct obj_symbol *sym;
2952         } *common_head = NULL;
2953
2954         unsigned long i;
2955
2956         for (i = 0; i < HASH_BUCKETS; ++i) {
2957                 struct obj_symbol *sym;
2958                 for (sym = f->symtab[i]; sym; sym = sym->next) {
2959                         if (sym->secidx == SHN_COMMON) {
2960                                 /* Collect all COMMON symbols and sort them by size so as to
2961                                    minimize space wasted by alignment requirements.  */
2962                                 struct common_entry **p, *n;
2963                                 for (p = &common_head; *p; p = &(*p)->next)
2964                                         if (sym->size <= (*p)->sym->size)
2965                                                 break;
2966                                 n = alloca(sizeof(*n));
2967                                 n->next = *p;
2968                                 n->sym = sym;
2969                                 *p = n;
2970                         }
2971                 }
2972         }
2973
2974         for (i = 1; i < f->local_symtab_size; ++i) {
2975                 struct obj_symbol *sym = f->local_symtab[i];
2976                 if (sym && sym->secidx == SHN_COMMON) {
2977                         struct common_entry **p, *n;
2978                         for (p = &common_head; *p; p = &(*p)->next) {
2979                                 if (sym == (*p)->sym)
2980                                         break;
2981                                 if (sym->size < (*p)->sym->size) {
2982                                         n = alloca(sizeof(*n));
2983                                         n->next = *p;
2984                                         n->sym = sym;
2985                                         *p = n;
2986                                         break;
2987                                 }
2988                         }
2989                 }
2990         }
2991
2992         if (common_head) {
2993                 /* Find the bss section.  */
2994                 for (i = 0; i < f->header.e_shnum; ++i)
2995                         if (f->sections[i]->header.sh_type == SHT_NOBITS)
2996                                 break;
2997
2998                 /* If for some reason there hadn't been one, create one.  */
2999                 if (i == f->header.e_shnum) {
3000                         struct obj_section *sec;
3001
3002                         f->header.e_shnum++;
3003                         f->sections = xrealloc_vector(f->sections, 2, i);
3004                         f->sections[i] = sec = arch_new_section();
3005
3006                         sec->header.sh_type = SHT_PROGBITS;
3007                         sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
3008                         sec->name = ".bss";
3009                         sec->idx = i;
3010                 }
3011
3012                 /* Allocate the COMMONS.  */
3013                 {
3014                         ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
3015                         ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
3016                         struct common_entry *c;
3017
3018                         for (c = common_head; c; c = c->next) {
3019                                 ElfW(Addr) align = c->sym->value;
3020
3021                                 if (align > max_align)
3022                                         max_align = align;
3023                                 if (bss_size & (align - 1))
3024                                         bss_size = (bss_size | (align - 1)) + 1;
3025
3026                                 c->sym->secidx = i;
3027                                 c->sym->value = bss_size;
3028
3029                                 bss_size += c->sym->size;
3030                         }
3031
3032                         f->sections[i]->header.sh_size = bss_size;
3033                         f->sections[i]->header.sh_addralign = max_align;
3034                 }
3035         }
3036
3037         /* For the sake of patch relocation and parameter initialization,
3038            allocate zeroed data for NOBITS sections now.  Note that after
3039            this we cannot assume NOBITS are really empty.  */
3040         for (i = 0; i < f->header.e_shnum; ++i) {
3041                 struct obj_section *s = f->sections[i];
3042                 if (s->header.sh_type == SHT_NOBITS) {
3043                         s->contents = NULL;
3044                         if (s->header.sh_size != 0)
3045                                 s->contents = xzalloc(s->header.sh_size);
3046                         s->header.sh_type = SHT_PROGBITS;
3047                 }
3048         }
3049 }
3050
3051 static unsigned long obj_load_size(struct obj_file *f)
3052 {
3053         unsigned long dot = 0;
3054         struct obj_section *sec;
3055
3056         /* Finalize the positions of the sections relative to one another.  */
3057
3058         for (sec = f->load_order; sec; sec = sec->load_next) {
3059                 ElfW(Addr) align;
3060
3061                 align = sec->header.sh_addralign;
3062                 if (align && (dot & (align - 1)))
3063                         dot = (dot | (align - 1)) + 1;
3064
3065                 sec->header.sh_addr = dot;
3066                 dot += sec->header.sh_size;
3067         }
3068
3069         return dot;
3070 }
3071
3072 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3073 {
3074         int i, n = f->header.e_shnum;
3075         int ret = 1;
3076
3077         /* Finalize the addresses of the sections.  */
3078
3079         f->baseaddr = base;
3080         for (i = 0; i < n; ++i)
3081                 f->sections[i]->header.sh_addr += base;
3082
3083         /* And iterate over all of the relocations.  */
3084
3085         for (i = 0; i < n; ++i) {
3086                 struct obj_section *relsec, *symsec, *targsec, *strsec;
3087                 ElfW(RelM) * rel, *relend;
3088                 ElfW(Sym) * symtab;
3089                 const char *strtab;
3090
3091                 relsec = f->sections[i];
3092                 if (relsec->header.sh_type != SHT_RELM)
3093                         continue;
3094
3095                 symsec = f->sections[relsec->header.sh_link];
3096                 targsec = f->sections[relsec->header.sh_info];
3097                 strsec = f->sections[symsec->header.sh_link];
3098
3099                 rel = (ElfW(RelM) *) relsec->contents;
3100                 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3101                 symtab = (ElfW(Sym) *) symsec->contents;
3102                 strtab = (const char *) strsec->contents;
3103
3104                 for (; rel < relend; ++rel) {
3105                         ElfW(Addr) value = 0;
3106                         struct obj_symbol *intsym = NULL;
3107                         unsigned long symndx;
3108                         ElfW(Sym) *extsym = NULL;
3109                         const char *errmsg;
3110
3111                         /* Attempt to find a value to use for this relocation.  */
3112
3113                         symndx = ELF_R_SYM(rel->r_info);
3114                         if (symndx) {
3115                                 /* Note we've already checked for undefined symbols.  */
3116
3117                                 extsym = &symtab[symndx];
3118                                 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3119                                         /* Local symbols we look up in the local table to be sure
3120                                            we get the one that is really intended.  */
3121                                         intsym = f->local_symtab[symndx];
3122                                 } else {
3123                                         /* Others we look up in the hash table.  */
3124                                         const char *name;
3125                                         if (extsym->st_name)
3126                                                 name = strtab + extsym->st_name;
3127                                         else
3128                                                 name = f->sections[extsym->st_shndx]->name;
3129                                         intsym = obj_find_symbol(f, name);
3130                                 }
3131
3132                                 value = obj_symbol_final_value(f, intsym);
3133                                 intsym->referenced = 1;
3134                         }
3135 #if SHT_RELM == SHT_RELA
3136 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3137                         /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9.  */
3138                         if (!extsym || !extsym->st_name
3139                          || ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3140 #endif
3141                                 value += rel->r_addend;
3142 #endif
3143
3144                         /* Do it! */
3145                         switch (arch_apply_relocation
3146                                         (f, targsec, /*symsec,*/ intsym, rel, value)
3147                         ) {
3148                         case obj_reloc_ok:
3149                                 break;
3150
3151                         case obj_reloc_overflow:
3152                                 errmsg = "Relocation overflow";
3153                                 goto bad_reloc;
3154                         case obj_reloc_dangerous:
3155                                 errmsg = "Dangerous relocation";
3156                                 goto bad_reloc;
3157                         case obj_reloc_unhandled:
3158                                 errmsg = "Unhandled relocation";
3159 bad_reloc:
3160                                 if (extsym) {
3161                                         bb_error_msg("%s of type %ld for %s", errmsg,
3162                                                         (long) ELF_R_TYPE(rel->r_info),
3163                                                         strtab + extsym->st_name);
3164                                 } else {
3165                                         bb_error_msg("%s of type %ld", errmsg,
3166                                                         (long) ELF_R_TYPE(rel->r_info));
3167                                 }
3168                                 ret = 0;
3169                                 break;
3170                         }
3171                 }
3172         }
3173
3174         /* Finally, take care of the patches.  */
3175
3176         if (f->string_patches) {
3177                 struct obj_string_patch *p;
3178                 struct obj_section *strsec;
3179                 ElfW(Addr) strsec_base;
3180                 strsec = obj_find_section(f, ".kstrtab");
3181                 strsec_base = strsec->header.sh_addr;
3182
3183                 for (p = f->string_patches; p; p = p->next) {
3184                         struct obj_section *targsec = f->sections[p->reloc_secidx];
3185                         *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3186                                 = strsec_base + p->string_offset;
3187                 }
3188         }
3189
3190         if (f->symbol_patches) {
3191                 struct obj_symbol_patch *p;
3192
3193                 for (p = f->symbol_patches; p; p = p->next) {
3194                         struct obj_section *targsec = f->sections[p->reloc_secidx];
3195                         *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3196                                 = obj_symbol_final_value(f, p->sym);
3197                 }
3198         }
3199
3200         return ret;
3201 }
3202
3203 static int obj_create_image(struct obj_file *f, char *image)
3204 {
3205         struct obj_section *sec;
3206         ElfW(Addr) base = f->baseaddr;
3207
3208         for (sec = f->load_order; sec; sec = sec->load_next) {
3209                 char *secimg;
3210
3211                 if (sec->contents == 0 || sec->header.sh_size == 0)
3212                         continue;
3213
3214                 secimg = image + (sec->header.sh_addr - base);
3215
3216                 /* Note that we allocated data for NOBITS sections earlier.  */
3217                 memcpy(secimg, sec->contents, sec->header.sh_size);
3218         }
3219
3220         return 1;
3221 }
3222
3223 /*======================================================================*/
3224
3225 static struct obj_file *obj_load(char *image, size_t image_size, int loadprogbits)
3226 {
3227         typedef uint32_t aliased_uint32_t FIX_ALIASING;
3228 #if BB_LITTLE_ENDIAN
3229 # define ELFMAG_U32 ((uint32_t)(ELFMAG0 + 0x100 * (ELFMAG1 + (0x100 * (ELFMAG2 + 0x100 * ELFMAG3)))))
3230 #else
3231 # define ELFMAG_U32 ((uint32_t)((((ELFMAG0 * 0x100) + ELFMAG1) * 0x100 + ELFMAG2) * 0x100 + ELFMAG3))
3232 #endif
3233         struct obj_file *f;
3234         ElfW(Shdr) * section_headers;
3235         size_t shnum, i;
3236         char *shstrtab;
3237
3238         /* Read the file header.  */
3239
3240         f = arch_new_file();
3241         f->symbol_cmp = strcmp;
3242         f->symbol_hash = obj_elf_hash;
3243         f->load_order_search_start = &f->load_order;
3244
3245         if (image_size < sizeof(f->header))
3246                 bb_error_msg_and_die("error while loading ELF header");
3247         memcpy(&f->header, image, sizeof(f->header));
3248
3249         if (*(aliased_uint32_t*)(&f->header.e_ident) != ELFMAG_U32) {
3250                 bb_error_msg_and_die("not an ELF file");
3251         }
3252         if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3253          || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB)
3254          || f->header.e_ident[EI_VERSION] != EV_CURRENT
3255          || !MATCH_MACHINE(f->header.e_machine)
3256         ) {
3257                 bb_error_msg_and_die("ELF file not for this architecture");
3258         }
3259         if (f->header.e_type != ET_REL) {
3260                 bb_error_msg_and_die("ELF file not a relocatable object");
3261         }
3262
3263         /* Read the section headers.  */
3264
3265         if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3266                 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3267                                 (unsigned long) f->header.e_shentsize,
3268                                 (unsigned long) sizeof(ElfW(Shdr)));
3269         }
3270
3271         shnum = f->header.e_shnum;
3272         /* Growth of ->sections vector will be done by
3273          * xrealloc_vector(..., 2, ...), therefore we must allocate
3274          * at least 2^2 = 4 extra elements here. */
3275         f->sections = xzalloc(sizeof(f->sections[0]) * (shnum + 4));
3276
3277         section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3278         if (image_size < f->header.e_shoff + sizeof(ElfW(Shdr)) * shnum)
3279                 bb_error_msg_and_die("error while loading section headers");
3280         memcpy(section_headers, image + f->header.e_shoff, sizeof(ElfW(Shdr)) * shnum);
3281
3282         /* Read the section data.  */
3283
3284         for (i = 0; i < shnum; ++i) {
3285                 struct obj_section *sec;
3286
3287                 f->sections[i] = sec = arch_new_section();
3288
3289                 sec->header = section_headers[i];
3290                 sec->idx = i;
3291
3292                 if (sec->header.sh_size) {
3293                         switch (sec->header.sh_type) {
3294                         case SHT_NULL:
3295                         case SHT_NOTE:
3296                         case SHT_NOBITS:
3297                                 /* ignore */
3298                                 break;
3299                         case SHT_PROGBITS:
3300 #if LOADBITS
3301                                 if (!loadprogbits) {
3302                                         sec->contents = NULL;
3303                                         break;
3304                                 }
3305 #endif
3306                         case SHT_SYMTAB:
3307                         case SHT_STRTAB:
3308                         case SHT_RELM:
3309 #if defined(__mips__)
3310                         case SHT_MIPS_DWARF:
3311 #endif
3312                                 sec->contents = NULL;
3313                                 if (sec->header.sh_size > 0) {
3314                                         sec->contents = xmalloc(sec->header.sh_size);
3315                                         if (image_size < (sec->header.sh_offset + sec->header.sh_size))
3316                                                 bb_error_msg_and_die("error while loading section data");
3317                                         memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
3318                                 }
3319                                 break;
3320 #if SHT_RELM == SHT_REL
3321                         case SHT_RELA:
3322                                 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3323 #else
3324                         case SHT_REL:
3325                                 bb_error_msg_and_die("REL relocations not supported on this architecture");
3326 #endif
3327                         default:
3328                                 if (sec->header.sh_type >= SHT_LOPROC) {
3329                                         /* Assume processor specific section types are debug
3330                                            info and can safely be ignored.  If this is ever not
3331                                            the case (Hello MIPS?), don't put ifdefs here but
3332                                            create an arch_load_proc_section().  */
3333                                         break;
3334                                 }
3335
3336                                 bb_error_msg_and_die("can't handle sections of type %ld",
3337                                                 (long) sec->header.sh_type);
3338                         }
3339                 }
3340         }
3341
3342         /* Do what sort of interpretation as needed by each section.  */
3343
3344         shstrtab = f->sections[f->header.e_shstrndx]->contents;
3345
3346         for (i = 0; i < shnum; ++i) {
3347                 struct obj_section *sec = f->sections[i];
3348                 sec->name = shstrtab + sec->header.sh_name;
3349         }
3350
3351         for (i = 0; i < shnum; ++i) {
3352                 struct obj_section *sec = f->sections[i];
3353
3354                 /* .modinfo should be contents only but gcc has no attribute for that.
3355                  * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3356                  */
3357                 if (strcmp(sec->name, ".modinfo") == 0)
3358                         sec->header.sh_flags &= ~SHF_ALLOC;
3359
3360                 if (sec->header.sh_flags & SHF_ALLOC)
3361                         obj_insert_section_load_order(f, sec);
3362
3363                 switch (sec->header.sh_type) {
3364                 case SHT_SYMTAB:
3365                         {
3366                                 unsigned long nsym, j;
3367                                 char *strtab;
3368                                 ElfW(Sym) * sym;
3369
3370                                 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3371                                         bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3372                                                         (unsigned long) sec->header.sh_entsize,
3373                                                         (unsigned long) sizeof(ElfW(Sym)));
3374                                 }
3375
3376                                 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3377                                 strtab = f->sections[sec->header.sh_link]->contents;
3378                                 sym = (ElfW(Sym) *) sec->contents;
3379
3380                                 /* Allocate space for a table of local symbols.  */
3381                                 j = f->local_symtab_size = sec->header.sh_info;
3382                                 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3383
3384                                 /* Insert all symbols into the hash table.  */
3385                                 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3386                                         ElfW(Addr) val = sym->st_value;
3387                                         const char *name;
3388                                         if (sym->st_name)
3389                                                 name = strtab + sym->st_name;
3390                                         else if (sym->st_shndx < shnum)
3391                                                 name = f->sections[sym->st_shndx]->name;
3392                                         else
3393                                                 continue;
3394 #if defined(__SH5__)
3395                                         /*
3396                                          * For sh64 it is possible that the target of a branch
3397                                          * requires a mode switch (32 to 16 and back again).
3398                                          *
3399                                          * This is implied by the lsb being set in the target
3400                                          * address for SHmedia mode and clear for SHcompact.
3401                                          */
3402                                         val |= sym->st_other & 4;
3403 #endif
3404                                         obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3405                                                         val, sym->st_size);
3406                                 }
3407                         }
3408                         break;
3409
3410                 case SHT_RELM:
3411                         if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3412                                 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3413                                                 (unsigned long) sec->header.sh_entsize,
3414                                                 (unsigned long) sizeof(ElfW(RelM)));
3415                         }
3416                         break;
3417                         /* XXX  Relocation code from modutils-2.3.19 is not here.
3418                          * Why?  That's about 20 lines of code from obj/obj_load.c,
3419                          * which gets done in a second pass through the sections.
3420                          * This BusyBox insmod does similar work in obj_relocate(). */
3421                 }
3422         }
3423
3424         return f;
3425 }
3426
3427 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3428 /*
3429  * load the unloaded sections directly into the memory allocated by
3430  * kernel for the module
3431  */
3432
3433 static int obj_load_progbits(char *image, size_t image_size, struct obj_file *f, char *imagebase)
3434 {
3435         ElfW(Addr) base = f->baseaddr;
3436         struct obj_section* sec;
3437
3438         for (sec = f->load_order; sec; sec = sec->load_next) {
3439                 /* section already loaded? */
3440                 if (sec->contents != NULL)
3441                         continue;
3442                 if (sec->header.sh_size == 0)
3443                         continue;
3444                 sec->contents = imagebase + (sec->header.sh_addr - base);
3445                 if (image_size < (sec->header.sh_offset + sec->header.sh_size)) {
3446                         bb_error_msg("error reading ELF section data");
3447                         return 0; /* need to delete half-loaded module! */
3448                 }
3449                 memcpy(sec->contents, image + sec->header.sh_offset, sec->header.sh_size);
3450         }
3451         return 1;
3452 }
3453 #endif
3454
3455 static void hide_special_symbols(struct obj_file *f)
3456 {
3457         static const char *const specials[] = {
3458                 SPFX "cleanup_module",
3459                 SPFX "init_module",
3460                 SPFX "kernel_version",
3461                 NULL
3462         };
3463
3464         struct obj_symbol *sym;
3465         const char *const *p;
3466
3467         for (p = specials; *p; ++p) {
3468                 sym = obj_find_symbol(f, *p);
3469                 if (sym != NULL)
3470                         sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3471         }
3472 }
3473
3474
3475 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3476 static int obj_gpl_license(struct obj_file *f, const char **license)
3477 {
3478         struct obj_section *sec;
3479         /* This list must match *exactly* the list of allowable licenses in
3480          * linux/include/linux/module.h.  Checking for leading "GPL" will not
3481          * work, somebody will use "GPL sucks, this is proprietary".
3482          */
3483         static const char *const gpl_licenses[] = {
3484                 "GPL",
3485                 "GPL v2",
3486                 "GPL and additional rights",
3487                 "Dual BSD/GPL",
3488                 "Dual MPL/GPL"
3489         };
3490
3491         sec = obj_find_section(f, ".modinfo");
3492         if (sec) {
3493                 const char *value, *ptr, *endptr;
3494                 ptr = sec->contents;
3495                 endptr = ptr + sec->header.sh_size;
3496                 while (ptr < endptr) {
3497                         value = strchr(ptr, '=');
3498                         if (value && strncmp(ptr, "license", value-ptr) == 0) {
3499                                 unsigned i;
3500                                 if (license)
3501                                         *license = value+1;
3502                                 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3503                                         if (strcmp(value+1, gpl_licenses[i]) == 0)
3504                                                 return 0;
3505                                 }
3506                                 return 2;
3507                         }
3508                         ptr = strchr(ptr, '\0');
3509                         if (ptr)
3510                                 ptr++;
3511                         else
3512                                 ptr = endptr;
3513                 }
3514         }
3515         return 1;
3516 }
3517
3518 #define TAINT_FILENAME                  "/proc/sys/kernel/tainted"
3519 #define TAINT_PROPRIETORY_MODULE        (1 << 0)
3520 #define TAINT_FORCED_MODULE             (1 << 1)
3521 #define TAINT_UNSAFE_SMP                (1 << 2)
3522 #define TAINT_URL                       "http://www.tux.org/lkml/#export-tainted"
3523
3524 static void set_tainted(int fd, const char *m_name,
3525                 int kernel_has_tainted, int taint,
3526                 const char *text1, const char *text2)
3527 {
3528         static smallint printed_info;
3529
3530         char buf[80];
3531         int oldval;
3532
3533         if (fd < 0 && !kernel_has_tainted)
3534                 return;         /* New modutils on old kernel */
3535         printf("Warning: loading %s will taint the kernel: %s%s\n",
3536                         m_name, text1, text2);
3537         if (!printed_info) {
3538                 printf("  See %s for information about tainted modules\n", TAINT_URL);
3539                 printed_info = 1;
3540         }
3541         if (fd >= 0) {
3542                 read(fd, buf, sizeof(buf)-1);
3543                 buf[sizeof(buf)-1] = '\0';
3544                 oldval = strtoul(buf, NULL, 10);
3545                 sprintf(buf, "%d\n", oldval | taint);
3546                 xwrite_str(fd, buf);
3547         }
3548 }
3549
3550 /* Check if loading this module will taint the kernel. */
3551 static void check_tainted_module(struct obj_file *f, const char *m_name)
3552 {
3553         int fd, kernel_has_tainted;
3554         const char *ptr;
3555
3556         kernel_has_tainted = 1;
3557         fd = open(TAINT_FILENAME, O_RDWR);
3558         if (fd < 0) {
3559                 if (errno == ENOENT)
3560                         kernel_has_tainted = 0;
3561                 else if (errno == EACCES)
3562                         kernel_has_tainted = 1;
3563                 else {
3564                         perror(TAINT_FILENAME);
3565                         kernel_has_tainted = 0;
3566                 }
3567         }
3568
3569         switch (obj_gpl_license(f, &ptr)) {
3570                 case 0:
3571                         break;
3572                 case 1:
3573                         set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3574                         break;
3575                 default: /* case 2: */
3576                         /* The module has a non-GPL license so we pretend that the
3577                          * kernel always has a taint flag to get a warning even on
3578                          * kernels without the proc flag.
3579                          */
3580                         set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3581                         break;
3582         }
3583
3584         if (flag_force_load)
3585                 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3586
3587         if (fd >= 0)
3588                 close(fd);
3589 }
3590 #else /* !FEATURE_CHECK_TAINTED_MODULE */
3591 #define check_tainted_module(x, y) do { } while (0);
3592 #endif
3593
3594 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3595 /* add module source, timestamp, kernel version and a symbol for the
3596  * start of some sections.  this info is used by ksymoops to do better
3597  * debugging.
3598  */
3599 #if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3600 #define get_module_version(f, str) get_module_version(str)
3601 #endif
3602 static int
3603 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3604 {
3605 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3606         return new_get_module_version(f, str);
3607 #else
3608         strncpy(str, "???", sizeof(str));
3609         return -1;
3610 #endif
3611 }
3612
3613 /* add module source, timestamp, kernel version and a symbol for the
3614  * start of some sections.  this info is used by ksymoops to do better
3615  * debugging.
3616  */
3617 static void
3618 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3619                 const char *m_name)
3620 {
3621         static const char symprefix[] ALIGN1 = "__insmod_";
3622         static const char section_names[][8] = {
3623                 ".text",
3624                 ".rodata",
3625                 ".data",
3626                 ".bss",
3627                 ".sbss"
3628         };
3629
3630         struct obj_section *sec;
3631         struct obj_symbol *sym;
3632         char *name, *absolute_filename;
3633         char str[STRVERSIONLEN];
3634         unsigned i;
3635         int lm_name, lfilename, use_ksymtab, version;
3636         struct stat statbuf;
3637
3638         /* WARNING: was using realpath, but replaced by readlink to stop using
3639          * lots of stack. But here it seems to be able to cause problems? */
3640         absolute_filename = xmalloc_readlink(filename);
3641         if (!absolute_filename)
3642                 absolute_filename = xstrdup(filename);
3643
3644         lm_name = strlen(m_name);
3645         lfilename = strlen(absolute_filename);
3646
3647         /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3648          * are not to be exported.  otherwise leave ksymtab alone for now, the
3649          * "export all symbols" compatibility code will export these symbols later.
3650          */
3651         use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3652
3653         sec = obj_find_section(f, ".this");
3654         if (sec) {
3655                 /* tag the module header with the object name, last modified
3656                  * timestamp and module version.  worst case for module version
3657                  * is 0xffffff, decimal 16777215.  putting all three fields in
3658                  * one symbol is less readable but saves kernel space.
3659                  */
3660                 if (stat(absolute_filename, &statbuf) != 0)
3661                         statbuf.st_mtime = 0;
3662                 version = get_module_version(f, str);   /* -1 if not found */
3663                 name = xasprintf("%s%s_O%s_M%0*lX_V%d",
3664                                 symprefix, m_name, absolute_filename,
3665                                 (int)(2 * sizeof(statbuf.st_mtime)),
3666                                 (long)statbuf.st_mtime,
3667                                 version);
3668                 sym = obj_add_symbol(f, name, -1,
3669                                 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3670                                 sec->idx, sec->header.sh_addr, 0);
3671                 if (use_ksymtab)
3672                         new_add_ksymtab(f, sym);
3673         }
3674         free(absolute_filename);
3675 #ifdef _NOT_SUPPORTED_
3676         /* record where the persistent data is going, same address as previous symbol */
3677         if (f->persist) {
3678                 name = xasprintf("%s%s_P%s",
3679                                 symprefix, m_name, f->persist);
3680                 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3681                                 sec->idx, sec->header.sh_addr, 0);
3682                 if (use_ksymtab)
3683                         new_add_ksymtab(f, sym);
3684         }
3685 #endif
3686         /* tag the desired sections if size is non-zero */
3687         for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3688                 sec = obj_find_section(f, section_names[i]);
3689                 if (sec && sec->header.sh_size) {
3690                         name = xasprintf("%s%s_S%s_L%ld",
3691                                         symprefix, m_name, sec->name,
3692                                         (long)sec->header.sh_size);
3693                         sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3694                                         sec->idx, sec->header.sh_addr, 0);
3695                         if (use_ksymtab)
3696                                 new_add_ksymtab(f, sym);
3697                 }
3698         }
3699 }
3700 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3701
3702 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3703 static void print_load_map(struct obj_file *f)
3704 {
3705         struct obj_section *sec;
3706 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3707         struct obj_symbol **all, **p;
3708         int i, nsyms;
3709         char *loaded; /* array of booleans */
3710         struct obj_symbol *sym;
3711 #endif
3712         /* Report on the section layout.  */
3713         printf("Sections:       Size      %-*s  Align\n",
3714                         (int) (2 * sizeof(void *)), "Address");
3715
3716         for (sec = f->load_order; sec; sec = sec->load_next) {
3717                 int a;
3718                 unsigned long tmp;
3719
3720                 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3721                         tmp >>= 1;
3722                 if (a == -1)
3723                         a = 0;
3724
3725                 printf("%-15s %08lx  %0*lx  2**%d\n",
3726                                 sec->name,
3727                                 (long)sec->header.sh_size,
3728                                 (int) (2 * sizeof(void *)),
3729                                 (long)sec->header.sh_addr,
3730                                 a);
3731         }
3732 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3733         /* Quick reference which section indices are loaded.  */
3734         i = f->header.e_shnum;
3735         loaded = alloca(i * sizeof(loaded[0]));
3736         while (--i >= 0)
3737                 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3738
3739         /* Collect the symbols we'll be listing.  */
3740         for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3741                 for (sym = f->symtab[i]; sym; sym = sym->next)
3742                         if (sym->secidx <= SHN_HIRESERVE
3743                          && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3744                         ) {
3745                                 ++nsyms;
3746                         }
3747
3748         all = alloca(nsyms * sizeof(all[0]));
3749
3750         for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3751                 for (sym = f->symtab[i]; sym; sym = sym->next)
3752                         if (sym->secidx <= SHN_HIRESERVE
3753                          && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx])
3754                         ) {
3755                                 *p++ = sym;
3756                         }
3757
3758         /* And list them.  */
3759         printf("\nSymbols:\n");
3760         for (p = all; p < all + nsyms; ++p) {
3761                 char type = '?';
3762                 unsigned long value;
3763
3764                 sym = *p;
3765                 if (sym->secidx == SHN_ABS) {
3766                         type = 'A';
3767                         value = sym->value;
3768                 } else if (sym->secidx == SHN_UNDEF) {
3769                         type = 'U';
3770                         value = 0;
3771                 } else {
3772                         sec = f->sections[sym->secidx];
3773
3774                         if (sec->header.sh_type == SHT_NOBITS)
3775                                 type = 'B';
3776                         else if (sec->header.sh_flags & SHF_ALLOC) {
3777                                 if (sec->header.sh_flags & SHF_EXECINSTR)
3778                                         type = 'T';
3779                                 else if (sec->header.sh_flags & SHF_WRITE)
3780                                         type = 'D';
3781                                 else
3782                                         type = 'R';
3783                         }
3784                         value = sym->value + sec->header.sh_addr;
3785                 }
3786
3787                 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3788                         type |= 0x20; /* tolower. safe for '?' too */
3789
3790                 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3791                                 type, sym->name);
3792         }
3793 #endif
3794 }
3795 #else /* !FEATURE_INSMOD_LOAD_MAP */
3796 static void print_load_map(struct obj_file *f UNUSED_PARAM)
3797 {
3798 }
3799 #endif
3800
3801 int FAST_FUNC bb_init_module_24(const char *m_filename, const char *options)
3802 {
3803         int k_crcs;
3804         unsigned long m_size;
3805         ElfW(Addr) m_addr;
3806         struct obj_file *f;
3807         int exit_status = EXIT_FAILURE;
3808         char *m_name;
3809 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3810         int m_has_modinfo;
3811 #endif
3812         char *image;
3813         size_t image_size;
3814         bool mmaped;
3815
3816         image_size = INT_MAX - 4095;
3817         mmaped = 0;
3818         image = try_to_mmap_module(m_filename, &image_size);
3819         if (image) {
3820                 mmaped = 1;
3821         } else {
3822                 /* Load module into memory and unzip if compressed */
3823                 image = xmalloc_open_zipped_read_close(m_filename, &image_size);
3824                 if (!image)
3825                         return EXIT_FAILURE;
3826         }
3827
3828         m_name = xstrdup(bb_basename(m_filename));
3829         /* "module.o[.gz]" -> "module" */
3830         *strchrnul(m_name, '.') = '\0';
3831
3832         f = obj_load(image, image_size, LOADBITS);
3833
3834 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3835         /* Version correspondence?  */
3836         m_has_modinfo = (get_modinfo_value(f, "kernel_version") != NULL);
3837         if (!flag_quiet) {
3838                 char m_strversion[STRVERSIONLEN];
3839                 struct utsname uts;
3840
3841                 if (m_has_modinfo) {
3842                         int m_version = new_get_module_version(f, m_strversion);
3843                         if (m_version == -1) {
3844                                 bb_error_msg_and_die("can't find the kernel version "
3845                                         "the module was compiled for");
3846                         }
3847                 }
3848
3849                 uname(&uts);
3850                 if (strncmp(uts.release, m_strversion, STRVERSIONLEN) != 0) {
3851                         bb_error_msg("%skernel-module version mismatch\n"
3852                                 "\t%s was compiled for kernel version %s\n"
3853                                 "\twhile this kernel is version %s",
3854                                 flag_force_load ? "warning: " : "",
3855                                 m_name, m_strversion, uts.release);
3856                         if (!flag_force_load)
3857                                 goto out;
3858                 }
3859         }
3860 #endif
3861
3862         if (query_module(NULL, 0, NULL, 0, NULL))
3863                 bb_error_msg_and_die("old (unsupported) kernel");
3864         new_get_kernel_symbols();
3865         k_crcs = new_is_kernel_checksummed();
3866
3867 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3868         {
3869                 int m_crcs = 0;
3870                 if (m_has_modinfo)
3871                         m_crcs = new_is_module_checksummed(f);
3872                 if (m_crcs != k_crcs)
3873                         obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
3874         }
3875 #endif
3876
3877         /* Let the module know about the kernel symbols.  */
3878         add_kernel_symbols(f);
3879
3880         /* Allocate common symbols, symbol tables, and string tables.  */
3881         new_create_this_module(f, m_name);
3882         obj_check_undefineds(f);
3883         obj_allocate_commons(f);
3884         check_tainted_module(f, m_name);
3885
3886         /* Done with the module name, on to the optional var=value arguments */
3887         new_process_module_arguments(f, options);
3888
3889         arch_create_got(f);
3890         hide_special_symbols(f);
3891
3892 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3893         add_ksymoops_symbols(f, m_filename, m_name);
3894 #endif
3895
3896         new_create_module_ksymtab(f);
3897
3898         /* Find current size of the module */
3899         m_size = obj_load_size(f);
3900
3901         m_addr = create_module(m_name, m_size);
3902         if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
3903         case EEXIST:
3904                 bb_error_msg_and_die("a module named %s already exists", m_name);
3905         case ENOMEM:
3906                 bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
3907                                 m_size);
3908         default:
3909                 bb_perror_msg_and_die("create_module: %s", m_name);
3910         }
3911
3912 #if !LOADBITS
3913         /*
3914          * the PROGBITS section was not loaded by the obj_load
3915          * now we can load them directly into the kernel memory
3916          */
3917         if (!obj_load_progbits(image, image_size, f, (char*)m_addr)) {
3918                 delete_module(m_name, 0);
3919                 goto out;
3920         }
3921 #endif
3922
3923         if (!obj_relocate(f, m_addr)) {
3924                 delete_module(m_name, 0);
3925                 goto out;
3926         }
3927
3928         if (!new_init_module(m_name, f, m_size)) {
3929                 delete_module(m_name, 0);
3930                 goto out;
3931         }
3932
3933         if (flag_print_load_map)
3934                 print_load_map(f);
3935
3936         exit_status = EXIT_SUCCESS;
3937
3938  out:
3939         if (mmaped)
3940                 munmap(image, image_size);
3941         else
3942                 free(image);
3943         free(m_name);
3944
3945         return exit_status;
3946 }