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