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