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