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 FAST_FUNC check_module_name_match(const char *filename,
 795                 struct stat *statbuf UNUSED_PARAM,
 796                 void *userdata, int depth UNUSED_PARAM)
 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_vector(f->sections, 2, newidx);
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->header.sh_size += more;
2254                 sec->contents = xrealloc(sec->contents, sec->header.sh_size);
2255         }
2256         return sec->contents + oldsize;
2257 }
2258
2259
2260 /* Conditionally add the symbols from the given symbol set to the
2261    new module.  */
2262
2263 static int
2264 add_symbols_from( struct obj_file *f,
2265                                  int idx, struct new_module_symbol *syms, size_t nsyms)
2266 {
2267         struct new_module_symbol *s;
2268         size_t i;
2269         int used = 0;
2270 #ifdef SYMBOL_PREFIX
2271         char *name_buf = 0;
2272         size_t name_alloced_size = 0;
2273 #endif
2274 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2275         int gpl;
2276
2277         gpl = obj_gpl_license(f, NULL) == 0;
2278 #endif
2279         for (i = 0, s = syms; i < nsyms; ++i, ++s) {
2280                 /* Only add symbols that are already marked external.
2281                    If we override locals we may cause problems for
2282                    argument initialization.  We will also create a false
2283                    dependency on the module.  */
2284                 struct obj_symbol *sym;
2285                 char *name;
2286
2287                 /* GPL licensed modules can use symbols exported with
2288                  * EXPORT_SYMBOL_GPL, so ignore any GPLONLY_ prefix on the
2289                  * exported names.  Non-GPL modules never see any GPLONLY_
2290                  * symbols so they cannot fudge it by adding the prefix on
2291                  * their references.
2292                  */
2293                 if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
2294 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
2295                         if (gpl)
2296                                 s->name += 8;
2297                         else
2298 #endif
2299                                 continue;
2300                 }
2301                 name = (char *)s->name;
2302
2303 #ifdef SYMBOL_PREFIX
2304                 /* Prepend SYMBOL_PREFIX to the symbol's name (the
2305                    kernel exports `C names', but module object files
2306                    reference `linker names').  */
2307                 size_t extra = sizeof SYMBOL_PREFIX;
2308                 size_t name_size = strlen(name) + extra;
2309                 if (name_size > name_alloced_size) {
2310                         name_alloced_size = name_size * 2;
2311                         name_buf = alloca(name_alloced_size);
2312                 }
2313                 strcpy(name_buf, SYMBOL_PREFIX);
2314                 strcpy(name_buf + extra - 1, name);
2315                 name = name_buf;
2316 #endif /* SYMBOL_PREFIX */
2317
2318                 sym = obj_find_symbol(f, name);
2319                 if (sym && !(ELF_ST_BIND(sym->info) == STB_LOCAL)) {
2320 #ifdef SYMBOL_PREFIX
2321                         /* Put NAME_BUF into more permanent storage.  */
2322                         name = xmalloc(name_size);
2323                         strcpy(name, name_buf);
2324 #endif
2325                         sym = obj_add_symbol(f, name, -1,
2326                                         ELF_ST_INFO(STB_GLOBAL,
2327                                                 STT_NOTYPE),
2328                                         idx, s->value, 0);
2329                         /* Did our symbol just get installed?  If so, mark the
2330                            module as "used".  */
2331                         if (sym->secidx == idx)
2332                                 used = 1;
2333                 }
2334         }
2335
2336         return used;
2337 }
2338
2339 static void add_kernel_symbols(struct obj_file *f)
2340 {
2341         struct external_module *m;
2342         int i, nused = 0;
2343
2344         /* Add module symbols first.  */
2345
2346         for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
2347                 if (m->nsyms
2348                  && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
2349                 ) {
2350                         m->used = 1;
2351                         ++nused;
2352                 }
2353         }
2354
2355         n_ext_modules_used = nused;
2356
2357         /* And finally the symbols from the kernel proper.  */
2358
2359         if (nksyms)
2360                 add_symbols_from(f, SHN_HIRESERVE + 1, ksyms, nksyms);
2361 }
2362
2363 static char *get_modinfo_value(struct obj_file *f, const char *key)
2364 {
2365         struct obj_section *sec;
2366         char *p, *v, *n, *ep;
2367         size_t klen = strlen(key);
2368
2369         sec = obj_find_section(f, ".modinfo");
2370         if (sec == NULL)
2371                 return NULL;
2372         p = sec->contents;
2373         ep = p + sec->header.sh_size;
2374         while (p < ep) {
2375                 v = strchr(p, '=');
2376                 n = strchr(p, '\0');
2377                 if (v) {
2378                         if (p + klen == v && strncmp(p, key, klen) == 0)
2379                                 return v + 1;
2380                 } else {
2381                         if (p + klen == n && strcmp(p, key) == 0)
2382                                 return n;
2383                 }
2384                 p = n + 1;
2385         }
2386
2387         return NULL;
2388 }
2389
2390
2391 /*======================================================================*/
2392 /* Functions relating to module loading after 2.1.18.  */
2393
2394 static void
2395 new_process_module_arguments(struct obj_file *f, int argc, char **argv)
2396 {
2397         while (argc > 0) {
2398                 char *p, *q, *key, *sym_name;
2399                 struct obj_symbol *sym;
2400                 char *contents, *loc;
2401                 int min, max, n;
2402
2403                 p = *argv;
2404                 q = strchr(p, '=');
2405                 if (q == NULL) {
2406                         argc--;
2407                         continue;
2408                 }
2409
2410                 key = alloca(q - p + 6);
2411                 memcpy(key, "parm_", 5);
2412                 memcpy(key + 5, p, q - p);
2413                 key[q - p + 5] = 0;
2414
2415                 p = get_modinfo_value(f, key);
2416                 key += 5;
2417                 if (p == NULL) {
2418                         bb_error_msg_and_die("invalid parameter %s", key);
2419                 }
2420
2421 #ifdef SYMBOL_PREFIX
2422                 sym_name = alloca(strlen(key) + sizeof SYMBOL_PREFIX);
2423                 strcpy(sym_name, SYMBOL_PREFIX);
2424                 strcat(sym_name, key);
2425 #else
2426                 sym_name = key;
2427 #endif
2428                 sym = obj_find_symbol(f, sym_name);
2429
2430                 /* Also check that the parameter was not resolved from the kernel.  */
2431                 if (sym == NULL || sym->secidx > SHN_HIRESERVE) {
2432                         bb_error_msg_and_die("symbol for parameter %s not found", key);
2433                 }
2434
2435                 if (isdigit(*p)) {
2436                         min = strtoul(p, &p, 10);
2437                         if (*p == '-')
2438                                 max = strtoul(p + 1, &p, 10);
2439                         else
2440                                 max = min;
2441                 } else
2442                         min = max = 1;
2443
2444                 contents = f->sections[sym->secidx]->contents;
2445                 loc = contents + sym->value;
2446                 n = (*++q != '\0');
2447
2448                 while (1) {
2449                         if ((*p == 's') || (*p == 'c')) {
2450                                 char *str;
2451
2452                                 /* Do C quoting if we begin with a ", else slurp the lot.  */
2453                                 if (*q == '"') {
2454                                         char *r;
2455
2456                                         str = alloca(strlen(q));
2457                                         for (r = str, q++; *q != '"'; ++q, ++r) {
2458                                                 if (*q == '\0')
2459                                                         bb_error_msg_and_die("improperly terminated string argument for %s",
2460                                                                         key);
2461                                                 if (*q == '\\')
2462                                                         switch (*++q) {
2463                                                         case 'a':
2464                                                                 *r = '\a';
2465                                                                 break;
2466                                                         case 'b':
2467                                                                 *r = '\b';
2468                                                                 break;
2469                                                         case 'e':
2470                                                                 *r = '\033';
2471                                                                 break;
2472                                                         case 'f':
2473                                                                 *r = '\f';
2474                                                                 break;
2475                                                         case 'n':
2476                                                                 *r = '\n';
2477                                                                 break;
2478                                                         case 'r':
2479                                                                 *r = '\r';
2480                                                                 break;
2481                                                         case 't':
2482                                                                 *r = '\t';
2483                                                                 break;
2484
2485                                                         case '0':
2486                                                         case '1':
2487                                                         case '2':
2488                                                         case '3':
2489                                                         case '4':
2490                                                         case '5':
2491                                                         case '6':
2492                                                         case '7':
2493                                                                 {
2494                                                                         int c = *q - '0';
2495                                                                         if (q[1] >= '0' && q[1] <= '7') {
2496                                                                                 c = (c * 8) + *++q - '0';
2497                                                                                 if (q[1] >= '0' && q[1] <= '7')
2498                                                                                         c = (c * 8) + *++q - '0';
2499                                                                         }
2500                                                                         *r = c;
2501                                                                 }
2502                                                                 break;
2503
2504                                                         default:
2505                                                                 *r = *q;
2506                                                                 break;
2507                                                         }
2508                                                 else
2509                                                         *r = *q;
2510                                         }
2511                                         *r = '\0';
2512                                         ++q;
2513                                 } else {
2514                                         char *r;
2515
2516                                         /* In this case, the string is not quoted. We will break
2517                                            it using the coma (like for ints). If the user wants to
2518                                            include comas in a string, he just has to quote it */
2519
2520                                         /* Search the next coma */
2521                                         r = strchr(q, ',');
2522
2523                                         /* Found ? */
2524                                         if (r != (char *) NULL) {
2525                                                 /* Recopy the current field */
2526                                                 str = alloca(r - q + 1);
2527                                                 memcpy(str, q, r - q);
2528
2529                                                 /* I don't know if it is useful, as the previous case
2530                                                    doesn't nul terminate the string ??? */
2531                                                 str[r - q] = '\0';
2532
2533                                                 /* Keep next fields */
2534                                                 q = r;
2535                                         } else {
2536                                                 /* last string */
2537                                                 str = q;
2538                                                 q = (char*)"";
2539                                         }
2540                                 }
2541
2542                                 if (*p == 's') {
2543                                         /* Normal string */
2544                                         obj_string_patch(f, sym->secidx, loc - contents, str);
2545                                         loc += tgt_sizeof_char_p;
2546                                 } else {
2547                                         /* Array of chars (in fact, matrix!) */
2548                                         unsigned long charssize;        /* size of each member */
2549
2550                                         /* Get the size of each member */
2551                                         /* Probably we should do that outside the loop ? */
2552                                         if (!isdigit(*(p + 1))) {
2553                                                 bb_error_msg_and_die("parameter type 'c' for %s must be followed by"
2554                                                                 " the maximum size", key);
2555                                         }
2556                                         charssize = strtoul(p + 1, (char **) NULL, 10);
2557
2558                                         /* Check length */
2559                                         if (strlen(str) >= charssize) {
2560                                                 bb_error_msg_and_die("string too long for %s (max %ld)", key,
2561                                                                 charssize - 1);
2562                                         }
2563
2564                                         /* Copy to location */
2565                                         strcpy((char *) loc, str);
2566                                         loc += charssize;
2567                                 }
2568                         } else {
2569                                 long v = strtoul(q, &q, 0);
2570                                 switch (*p) {
2571                                 case 'b':
2572                                         *loc++ = v;
2573                                         break;
2574                                 case 'h':
2575                                         *(short *) loc = v;
2576                                         loc += tgt_sizeof_short;
2577                                         break;
2578                                 case 'i':
2579                                         *(int *) loc = v;
2580                                         loc += tgt_sizeof_int;
2581                                         break;
2582                                 case 'l':
2583                                         *(long *) loc = v;
2584                                         loc += tgt_sizeof_long;
2585                                         break;
2586
2587                                 default:
2588                                         bb_error_msg_and_die("unknown parameter type '%c' for %s", *p, key);
2589                                 }
2590                         }
2591  retry_end_of_value:
2592                         switch (*q) {
2593                         case '\0':
2594                                 goto end_of_arg;
2595
2596                         case ' ':
2597                         case '\t':
2598                         case '\n':
2599                         case '\r':
2600                                 ++q;
2601                                 goto retry_end_of_value;
2602
2603                         case ',':
2604                                 if (++n > max) {
2605                                         bb_error_msg_and_die("too many values for %s (max %d)", key, max);
2606                                 }
2607                                 ++q;
2608                                 break;
2609
2610                         default:
2611                                 bb_error_msg_and_die("invalid argument syntax for %s", key);
2612                         }
2613                 }
2614  end_of_arg:
2615                 if (n < min) {
2616                         bb_error_msg_and_die("too few values for %s (min %d)", key, min);
2617                 }
2618
2619                 argc--;
2620                 argv++;
2621         }
2622 }
2623
2624 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
2625 static int new_is_module_checksummed(struct obj_file *f)
2626 {
2627         const char *p = get_modinfo_value(f, "using_checksums");
2628         if (p)
2629                 return xatoi(p);
2630         return 0;
2631 }
2632
2633 /* Get the module's kernel version in the canonical integer form.  */
2634
2635 static int
2636 new_get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
2637 {
2638         char *p, *q;
2639         int a, b, c;
2640
2641         p = get_modinfo_value(f, "kernel_version");
2642         if (p == NULL)
2643                 return -1;
2644         safe_strncpy(str, p, STRVERSIONLEN);
2645
2646         a = strtoul(p, &p, 10);
2647         if (*p != '.')
2648                 return -1;
2649         b = strtoul(p + 1, &p, 10);
2650         if (*p != '.')
2651                 return -1;
2652         c = strtoul(p + 1, &q, 10);
2653         if (p + 1 == q)
2654                 return -1;
2655
2656         return a << 16 | b << 8 | c;
2657 }
2658
2659 #endif   /* FEATURE_INSMOD_VERSION_CHECKING */
2660
2661
2662 /* Fetch the loaded modules, and all currently exported symbols.  */
2663
2664 static void new_get_kernel_symbols(void)
2665 {
2666         char *module_names, *mn;
2667         struct external_module *modules, *m;
2668         struct new_module_symbol *syms, *s;
2669         size_t ret, bufsize, nmod, nsyms, i, j;
2670
2671         /* Collect the loaded modules.  */
2672
2673         bufsize = 256;
2674         module_names = xmalloc(bufsize);
2675
2676  retry_modules_load:
2677         if (query_module(NULL, QM_MODULES, module_names, bufsize, &ret)) {
2678                 if (errno == ENOSPC && bufsize < ret) {
2679                         bufsize = ret;
2680                         module_names = xrealloc(module_names, bufsize);
2681                         goto retry_modules_load;
2682                 }
2683                 bb_perror_msg_and_die("QM_MODULES");
2684         }
2685
2686         n_ext_modules = nmod = ret;
2687
2688         /* Collect the modules' symbols.  */
2689
2690         if (nmod) {
2691                 ext_modules = modules = xmalloc(nmod * sizeof(*modules));
2692                 memset(modules, 0, nmod * sizeof(*modules));
2693                 for (i = 0, mn = module_names, m = modules;
2694                                 i < nmod; ++i, ++m, mn += strlen(mn) + 1) {
2695                         struct new_module_info info;
2696
2697                         if (query_module(mn, QM_INFO, &info, sizeof(info), &ret)) {
2698                                 if (errno == ENOENT) {
2699                                         /* The module was removed out from underneath us.  */
2700                                         continue;
2701                                 }
2702                                 bb_perror_msg_and_die("query_module: QM_INFO: %s", mn);
2703                         }
2704
2705                         bufsize = 1024;
2706                         syms = xmalloc(bufsize);
2707  retry_mod_sym_load:
2708                         if (query_module(mn, QM_SYMBOLS, syms, bufsize, &ret)) {
2709                                 switch (errno) {
2710                                         case ENOSPC:
2711                                                 bufsize = ret;
2712                                                 syms = xrealloc(syms, bufsize);
2713                                                 goto retry_mod_sym_load;
2714                                         case ENOENT:
2715                                                 /* The module was removed out from underneath us.  */
2716                                                 continue;
2717                                         default:
2718                                                 bb_perror_msg_and_die("query_module: QM_SYMBOLS: %s", mn);
2719                                 }
2720                         }
2721                         nsyms = ret;
2722
2723                         m->name = mn;
2724                         m->addr = info.addr;
2725                         m->nsyms = nsyms;
2726                         m->syms = syms;
2727
2728                         for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2729                                 s->name += (unsigned long) syms;
2730                         }
2731                 }
2732         }
2733
2734         /* Collect the kernel's symbols.  */
2735
2736         syms = xmalloc(bufsize = 16 * 1024);
2737  retry_kern_sym_load:
2738         if (query_module(NULL, QM_SYMBOLS, syms, bufsize, &ret)) {
2739                 if (errno == ENOSPC && bufsize < ret) {
2740                         bufsize = ret;
2741                         syms = xrealloc(syms, bufsize);
2742                         goto retry_kern_sym_load;
2743                 }
2744                 bb_perror_msg_and_die("kernel: QM_SYMBOLS");
2745         }
2746         nksyms = nsyms = ret;
2747         ksyms = syms;
2748
2749         for (j = 0, s = syms; j < nsyms; ++j, ++s) {
2750                 s->name += (unsigned long) syms;
2751         }
2752 }
2753
2754
2755 /* Return the kernel symbol checksum version, or zero if not used.  */
2756
2757 static int new_is_kernel_checksummed(void)
2758 {
2759         struct new_module_symbol *s;
2760         size_t i;
2761
2762         /* Using_Versions is not the first symbol, but it should be in there.  */
2763
2764         for (i = 0, s = ksyms; i < nksyms; ++i, ++s)
2765                 if (strcmp((char *) s->name, "Using_Versions") == 0)
2766                         return s->value;
2767
2768         return 0;
2769 }
2770
2771
2772 static void  new_create_this_module(struct obj_file *f, const char *m_name)
2773 {
2774         struct obj_section *sec;
2775
2776         sec = obj_create_alloced_section_first(f, ".this", tgt_sizeof_long,
2777                         sizeof(struct new_module));
2778         memset(sec->contents, 0, sizeof(struct new_module));
2779
2780         obj_add_symbol(f, SPFX "__this_module", -1,
2781                         ELF_ST_INFO(STB_LOCAL, STT_OBJECT), sec->idx, 0,
2782                         sizeof(struct new_module));
2783
2784         obj_string_patch(f, sec->idx, offsetof(struct new_module, name),
2785                         m_name);
2786 }
2787
2788 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
2789 /* add an entry to the __ksymtab section, creating it if necessary */
2790 static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
2791 {
2792         struct obj_section *sec;
2793         ElfW(Addr) ofs;
2794
2795         /* ensure __ksymtab is allocated, EXPORT_NOSYMBOLS creates a non-alloc section.
2796          * If __ksymtab is defined but not marked alloc, x out the first character
2797          * (no obj_delete routine) and create a new __ksymtab with the correct
2798          * characteristics.
2799          */
2800         sec = obj_find_section(f, "__ksymtab");
2801         if (sec && !(sec->header.sh_flags & SHF_ALLOC)) {
2802                 *((char *)(sec->name)) = 'x';   /* override const */
2803                 sec = NULL;
2804         }
2805         if (!sec)
2806                 sec = obj_create_alloced_section(f, "__ksymtab",
2807                                 tgt_sizeof_void_p, 0);
2808         if (!sec)
2809                 return;
2810         sec->header.sh_flags |= SHF_ALLOC;
2811         /* Empty section might be byte-aligned */
2812         sec->header.sh_addralign = tgt_sizeof_void_p;
2813         ofs = sec->header.sh_size;
2814         obj_symbol_patch(f, sec->idx, ofs, sym);
2815         obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p, sym->name);
2816         obj_extend_section(sec, 2 * tgt_sizeof_char_p);
2817 }
2818 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
2819
2820 static int new_create_module_ksymtab(struct obj_file *f)
2821 {
2822         struct obj_section *sec;
2823         int i;
2824
2825         /* We must always add the module references.  */
2826
2827         if (n_ext_modules_used) {
2828                 struct new_module_ref *dep;
2829                 struct obj_symbol *tm;
2830
2831                 sec = obj_create_alloced_section(f, ".kmodtab", tgt_sizeof_void_p,
2832                                 (sizeof(struct new_module_ref)
2833                                  * n_ext_modules_used));
2834                 if (!sec)
2835                         return 0;
2836
2837                 tm = obj_find_symbol(f, SPFX "__this_module");
2838                 dep = (struct new_module_ref *) sec->contents;
2839                 for (i = 0; i < n_ext_modules; ++i)
2840                         if (ext_modules[i].used) {
2841                                 dep->dep = ext_modules[i].addr;
2842                                 obj_symbol_patch(f, sec->idx,
2843                                                 (char *) &dep->ref - sec->contents, tm);
2844                                 dep->next_ref = 0;
2845                                 ++dep;
2846                         }
2847         }
2848
2849         if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
2850                 size_t nsyms;
2851                 int *loaded;
2852
2853                 sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
2854
2855                 /* We don't want to export symbols residing in sections that
2856                    aren't loaded.  There are a number of these created so that
2857                    we make sure certain module options don't appear twice.  */
2858
2859                 loaded = alloca(sizeof(int) * (i = f->header.e_shnum));
2860                 while (--i >= 0)
2861                         loaded[i] = (f->sections[i]->header.sh_flags & SHF_ALLOC) != 0;
2862
2863                 for (nsyms = i = 0; i < HASH_BUCKETS; ++i) {
2864                         struct obj_symbol *sym;
2865                         for (sym = f->symtab[i]; sym; sym = sym->next)
2866                                 if (ELF_ST_BIND(sym->info) != STB_LOCAL
2867                                                 && sym->secidx <= SHN_HIRESERVE
2868                                                 && (sym->secidx >= SHN_LORESERVE
2869                                                         || loaded[sym->secidx])) {
2870                                         ElfW(Addr) ofs = nsyms * 2 * tgt_sizeof_void_p;
2871
2872                                         obj_symbol_patch(f, sec->idx, ofs, sym);
2873                                         obj_string_patch(f, sec->idx, ofs + tgt_sizeof_void_p,
2874                                                         sym->name);
2875
2876                                         nsyms++;
2877                                 }
2878                 }
2879
2880                 obj_extend_section(sec, nsyms * 2 * tgt_sizeof_char_p);
2881         }
2882
2883         return 1;
2884 }
2885
2886
2887 static int
2888 new_init_module(const char *m_name, struct obj_file *f, unsigned long m_size)
2889 {
2890         struct new_module *module;
2891         struct obj_section *sec;
2892         void *image;
2893         int ret;
2894         tgt_long m_addr;
2895
2896         sec = obj_find_section(f, ".this");
2897         if (!sec || !sec->contents) {
2898                 bb_perror_msg_and_die("corrupt module %s?", m_name);
2899         }
2900         module = (struct new_module *) sec->contents;
2901         m_addr = sec->header.sh_addr;
2902
2903         module->size_of_struct = sizeof(*module);
2904         module->size = m_size;
2905         module->flags = flag_autoclean ? NEW_MOD_AUTOCLEAN : 0;
2906
2907         sec = obj_find_section(f, "__ksymtab");
2908         if (sec && sec->header.sh_size) {
2909                 module->syms = sec->header.sh_addr;
2910                 module->nsyms = sec->header.sh_size / (2 * tgt_sizeof_char_p);
2911         }
2912
2913         if (n_ext_modules_used) {
2914                 sec = obj_find_section(f, ".kmodtab");
2915                 module->deps = sec->header.sh_addr;
2916                 module->ndeps = n_ext_modules_used;
2917         }
2918
2919         module->init =
2920                 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "init_module"));
2921         module->cleanup =
2922                 obj_symbol_final_value(f, obj_find_symbol(f, SPFX "cleanup_module"));
2923
2924         sec = obj_find_section(f, "__ex_table");
2925         if (sec) {
2926                 module->ex_table_start = sec->header.sh_addr;
2927                 module->ex_table_end = sec->header.sh_addr + sec->header.sh_size;
2928         }
2929
2930         sec = obj_find_section(f, ".text.init");
2931         if (sec) {
2932                 module->runsize = sec->header.sh_addr - m_addr;
2933         }
2934         sec = obj_find_section(f, ".data.init");
2935         if (sec) {
2936                 if (!module->runsize ||
2937                                 module->runsize > sec->header.sh_addr - m_addr)
2938                         module->runsize = sec->header.sh_addr - m_addr;
2939         }
2940         sec = obj_find_section(f, ARCHDATA_SEC_NAME);
2941         if (sec && sec->header.sh_size) {
2942                 module->archdata_start = (void*)sec->header.sh_addr;
2943                 module->archdata_end = module->archdata_start + sec->header.sh_size;
2944         }
2945         sec = obj_find_section(f, KALLSYMS_SEC_NAME);
2946         if (sec && sec->header.sh_size) {
2947                 module->kallsyms_start = (void*)sec->header.sh_addr;
2948                 module->kallsyms_end = module->kallsyms_start + sec->header.sh_size;
2949         }
2950
2951         /* Whew!  All of the initialization is complete.  Collect the final
2952            module image and give it to the kernel.  */
2953
2954         image = xmalloc(m_size);
2955         obj_create_image(f, image);
2956
2957         ret = init_module(m_name, (struct new_module *) image);
2958         if (ret)
2959                 bb_perror_msg("init_module: %s", m_name);
2960
2961         free(image);
2962
2963         return ret == 0;
2964 }
2965
2966
2967 /*======================================================================*/
2968
2969 static void
2970 obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2971                                  const char *string)
2972 {
2973         struct obj_string_patch *p;
2974         struct obj_section *strsec;
2975         size_t len = strlen(string) + 1;
2976         char *loc;
2977
2978         p = xmalloc(sizeof(*p));
2979         p->next = f->string_patches;
2980         p->reloc_secidx = secidx;
2981         p->reloc_offset = offset;
2982         f->string_patches = p;
2983
2984         strsec = obj_find_section(f, ".kstrtab");
2985         if (strsec == NULL) {
2986                 strsec = obj_create_alloced_section(f, ".kstrtab", 1, len);
2987                 p->string_offset = 0;
2988                 loc = strsec->contents;
2989         } else {
2990                 p->string_offset = strsec->header.sh_size;
2991                 loc = obj_extend_section(strsec, len);
2992         }
2993         memcpy(loc, string, len);
2994 }
2995
2996 static void
2997 obj_symbol_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
2998                                  struct obj_symbol *sym)
2999 {
3000         struct obj_symbol_patch *p;
3001
3002         p = xmalloc(sizeof(*p));
3003         p->next = f->symbol_patches;
3004         p->reloc_secidx = secidx;
3005         p->reloc_offset = offset;
3006         p->sym = sym;
3007         f->symbol_patches = p;
3008 }
3009
3010 static void obj_check_undefineds(struct obj_file *f)
3011 {
3012         unsigned i;
3013
3014         for (i = 0; i < HASH_BUCKETS; ++i) {
3015                 struct obj_symbol *sym;
3016                 for (sym = f->symtab[i]; sym; sym = sym->next)
3017                         if (sym->secidx == SHN_UNDEF) {
3018                                 if (ELF_ST_BIND(sym->info) == STB_WEAK) {
3019                                         sym->secidx = SHN_ABS;
3020                                         sym->value = 0;
3021                                 } else {
3022                                         if (!flag_quiet)
3023                                                 bb_error_msg_and_die("unresolved symbol %s", sym->name);
3024                                 }
3025                         }
3026         }
3027 }
3028
3029 static void obj_allocate_commons(struct obj_file *f)
3030 {
3031         struct common_entry {
3032                 struct common_entry *next;
3033                 struct obj_symbol *sym;
3034         } *common_head = NULL;
3035
3036         unsigned long i;
3037
3038         for (i = 0; i < HASH_BUCKETS; ++i) {
3039                 struct obj_symbol *sym;
3040                 for (sym = f->symtab[i]; sym; sym = sym->next)
3041                         if (sym->secidx == SHN_COMMON) {
3042                                 /* Collect all COMMON symbols and sort them by size so as to
3043                                    minimize space wasted by alignment requirements.  */
3044                                 {
3045                                         struct common_entry **p, *n;
3046                                         for (p = &common_head; *p; p = &(*p)->next)
3047                                                 if (sym->size <= (*p)->sym->size)
3048                                                         break;
3049
3050                                         n = alloca(sizeof(*n));
3051                                         n->next = *p;
3052                                         n->sym = sym;
3053                                         *p = n;
3054                                 }
3055                         }
3056         }
3057
3058         for (i = 1; i < f->local_symtab_size; ++i) {
3059                 struct obj_symbol *sym = f->local_symtab[i];
3060                 if (sym && sym->secidx == SHN_COMMON) {
3061                         struct common_entry **p, *n;
3062                         for (p = &common_head; *p; p = &(*p)->next)
3063                                 if (sym == (*p)->sym)
3064                                         break;
3065                                 else if (sym->size < (*p)->sym->size) {
3066                                         n = alloca(sizeof(*n));
3067                                         n->next = *p;
3068                                         n->sym = sym;
3069                                         *p = n;
3070                                         break;
3071                                 }
3072                 }
3073         }
3074
3075         if (common_head) {
3076                 /* Find the bss section.  */
3077                 for (i = 0; i < f->header.e_shnum; ++i)
3078                         if (f->sections[i]->header.sh_type == SHT_NOBITS)
3079                                 break;
3080
3081                 /* If for some reason there hadn't been one, create one.  */
3082                 if (i == f->header.e_shnum) {
3083                         struct obj_section *sec;
3084
3085                         f->sections = xrealloc_vector(f->sections, 2, i);
3086                         f->sections[i] = sec = arch_new_section();
3087                         f->header.e_shnum = i + 1;
3088
3089                         sec->header.sh_type = SHT_PROGBITS;
3090                         sec->header.sh_flags = SHF_WRITE | SHF_ALLOC;
3091                         sec->name = ".bss";
3092                         sec->idx = i;
3093                 }
3094
3095                 /* Allocate the COMMONS.  */
3096                 {
3097                         ElfW(Addr) bss_size = f->sections[i]->header.sh_size;
3098                         ElfW(Addr) max_align = f->sections[i]->header.sh_addralign;
3099                         struct common_entry *c;
3100
3101                         for (c = common_head; c; c = c->next) {
3102                                 ElfW(Addr) align = c->sym->value;
3103
3104                                 if (align > max_align)
3105                                         max_align = align;
3106                                 if (bss_size & (align - 1))
3107                                         bss_size = (bss_size | (align - 1)) + 1;
3108
3109                                 c->sym->secidx = i;
3110                                 c->sym->value = bss_size;
3111
3112                                 bss_size += c->sym->size;
3113                         }
3114
3115                         f->sections[i]->header.sh_size = bss_size;
3116                         f->sections[i]->header.sh_addralign = max_align;
3117                 }
3118         }
3119
3120         /* For the sake of patch relocation and parameter initialization,
3121            allocate zeroed data for NOBITS sections now.  Note that after
3122            this we cannot assume NOBITS are really empty.  */
3123         for (i = 0; i < f->header.e_shnum; ++i) {
3124                 struct obj_section *s = f->sections[i];
3125                 if (s->header.sh_type == SHT_NOBITS) {
3126                         if (s->header.sh_size != 0)
3127                                 s->contents = memset(xmalloc(s->header.sh_size),
3128                                                 0, s->header.sh_size);
3129                         else
3130                                 s->contents = NULL;
3131
3132                         s->header.sh_type = SHT_PROGBITS;
3133                 }
3134         }
3135 }
3136
3137 static unsigned long obj_load_size(struct obj_file *f)
3138 {
3139         unsigned long dot = 0;
3140         struct obj_section *sec;
3141
3142         /* Finalize the positions of the sections relative to one another.  */
3143
3144         for (sec = f->load_order; sec; sec = sec->load_next) {
3145                 ElfW(Addr) align;
3146
3147                 align = sec->header.sh_addralign;
3148                 if (align && (dot & (align - 1)))
3149                         dot = (dot | (align - 1)) + 1;
3150
3151                 sec->header.sh_addr = dot;
3152                 dot += sec->header.sh_size;
3153         }
3154
3155         return dot;
3156 }
3157
3158 static int obj_relocate(struct obj_file *f, ElfW(Addr) base)
3159 {
3160         int i, n = f->header.e_shnum;
3161         int ret = 1;
3162
3163         /* Finalize the addresses of the sections.  */
3164
3165         f->baseaddr = base;
3166         for (i = 0; i < n; ++i)
3167                 f->sections[i]->header.sh_addr += base;
3168
3169         /* And iterate over all of the relocations.  */
3170
3171         for (i = 0; i < n; ++i) {
3172                 struct obj_section *relsec, *symsec, *targsec, *strsec;
3173                 ElfW(RelM) * rel, *relend;
3174                 ElfW(Sym) * symtab;
3175                 const char *strtab;
3176
3177                 relsec = f->sections[i];
3178                 if (relsec->header.sh_type != SHT_RELM)
3179                         continue;
3180
3181                 symsec = f->sections[relsec->header.sh_link];
3182                 targsec = f->sections[relsec->header.sh_info];
3183                 strsec = f->sections[symsec->header.sh_link];
3184
3185                 rel = (ElfW(RelM) *) relsec->contents;
3186                 relend = rel + (relsec->header.sh_size / sizeof(ElfW(RelM)));
3187                 symtab = (ElfW(Sym) *) symsec->contents;
3188                 strtab = (const char *) strsec->contents;
3189
3190                 for (; rel < relend; ++rel) {
3191                         ElfW(Addr) value = 0;
3192                         struct obj_symbol *intsym = NULL;
3193                         unsigned long symndx;
3194                         ElfW(Sym) * extsym = 0;
3195                         const char *errmsg;
3196
3197                         /* Attempt to find a value to use for this relocation.  */
3198
3199                         symndx = ELF_R_SYM(rel->r_info);
3200                         if (symndx) {
3201                                 /* Note we've already checked for undefined symbols.  */
3202
3203                                 extsym = &symtab[symndx];
3204                                 if (ELF_ST_BIND(extsym->st_info) == STB_LOCAL) {
3205                                         /* Local symbols we look up in the local table to be sure
3206                                            we get the one that is really intended.  */
3207                                         intsym = f->local_symtab[symndx];
3208                                 } else {
3209                                         /* Others we look up in the hash table.  */
3210                                         const char *name;
3211                                         if (extsym->st_name)
3212                                                 name = strtab + extsym->st_name;
3213                                         else
3214                                                 name = f->sections[extsym->st_shndx]->name;
3215                                         intsym = obj_find_symbol(f, name);
3216                                 }
3217
3218                                 value = obj_symbol_final_value(f, intsym);
3219                                 intsym->referenced = 1;
3220                         }
3221 #if SHT_RELM == SHT_RELA
3222 #if defined(__alpha__) && defined(AXP_BROKEN_GAS)
3223                         /* Work around a nasty GAS bug, that is fixed as of 2.7.0.9.  */
3224                         if (!extsym || !extsym->st_name ||
3225                                         ELF_ST_BIND(extsym->st_info) != STB_LOCAL)
3226 #endif
3227                                 value += rel->r_addend;
3228 #endif
3229
3230                         /* Do it! */
3231                         switch (arch_apply_relocation
3232                                         (f, targsec, /*symsec,*/ intsym, rel, value)
3233                         ) {
3234                         case obj_reloc_ok:
3235                                 break;
3236
3237                         case obj_reloc_overflow:
3238                                 errmsg = "Relocation overflow";
3239                                 goto bad_reloc;
3240                         case obj_reloc_dangerous:
3241                                 errmsg = "Dangerous relocation";
3242                                 goto bad_reloc;
3243                         case obj_reloc_unhandled:
3244                                 errmsg = "Unhandled relocation";
3245 bad_reloc:
3246                                 if (extsym) {
3247                                         bb_error_msg("%s of type %ld for %s", errmsg,
3248                                                         (long) ELF_R_TYPE(rel->r_info),
3249                                                         strtab + extsym->st_name);
3250                                 } else {
3251                                         bb_error_msg("%s of type %ld", errmsg,
3252                                                         (long) ELF_R_TYPE(rel->r_info));
3253                                 }
3254                                 ret = 0;
3255                                 break;
3256                         }
3257                 }
3258         }
3259
3260         /* Finally, take care of the patches.  */
3261
3262         if (f->string_patches) {
3263                 struct obj_string_patch *p;
3264                 struct obj_section *strsec;
3265                 ElfW(Addr) strsec_base;
3266                 strsec = obj_find_section(f, ".kstrtab");
3267                 strsec_base = strsec->header.sh_addr;
3268
3269                 for (p = f->string_patches; p; p = p->next) {
3270                         struct obj_section *targsec = f->sections[p->reloc_secidx];
3271                         *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3272                                 = strsec_base + p->string_offset;
3273                 }
3274         }
3275
3276         if (f->symbol_patches) {
3277                 struct obj_symbol_patch *p;
3278
3279                 for (p = f->symbol_patches; p; p = p->next) {
3280                         struct obj_section *targsec = f->sections[p->reloc_secidx];
3281                         *(ElfW(Addr) *) (targsec->contents + p->reloc_offset)
3282                                 = obj_symbol_final_value(f, p->sym);
3283                 }
3284         }
3285
3286         return ret;
3287 }
3288
3289 static int obj_create_image(struct obj_file *f, char *image)
3290 {
3291         struct obj_section *sec;
3292         ElfW(Addr) base = f->baseaddr;
3293
3294         for (sec = f->load_order; sec; sec = sec->load_next) {
3295                 char *secimg;
3296
3297                 if (sec->contents == 0 || sec->header.sh_size == 0)
3298                         continue;
3299
3300                 secimg = image + (sec->header.sh_addr - base);
3301
3302                 /* Note that we allocated data for NOBITS sections earlier.  */
3303                 memcpy(secimg, sec->contents, sec->header.sh_size);
3304         }
3305
3306         return 1;
3307 }
3308
3309 /*======================================================================*/
3310
3311 static struct obj_file *obj_load(FILE *fp, int loadprogbits UNUSED_PARAM)
3312 {
3313         struct obj_file *f;
3314         ElfW(Shdr) * section_headers;
3315         size_t shnum, i;
3316         char *shstrtab;
3317
3318         /* Read the file header.  */
3319
3320         f = arch_new_file();
3321         f->symbol_cmp = strcmp;
3322         f->symbol_hash = obj_elf_hash;
3323         f->load_order_search_start = &f->load_order;
3324
3325         fseek(fp, 0, SEEK_SET);
3326         if (fread(&f->header, sizeof(f->header), 1, fp) != 1) {
3327                 bb_perror_msg_and_die("error reading ELF header");
3328         }
3329
3330         if (f->header.e_ident[EI_MAG0] != ELFMAG0
3331                         || f->header.e_ident[EI_MAG1] != ELFMAG1
3332                         || f->header.e_ident[EI_MAG2] != ELFMAG2
3333                         || f->header.e_ident[EI_MAG3] != ELFMAG3) {
3334                 bb_error_msg_and_die("not an ELF file");
3335         }
3336         if (f->header.e_ident[EI_CLASS] != ELFCLASSM
3337                         || f->header.e_ident[EI_DATA] != (BB_BIG_ENDIAN
3338                                 ? ELFDATA2MSB : ELFDATA2LSB)
3339                         || f->header.e_ident[EI_VERSION] != EV_CURRENT
3340                         || !MATCH_MACHINE(f->header.e_machine)) {
3341                 bb_error_msg_and_die("ELF file not for this architecture");
3342         }
3343         if (f->header.e_type != ET_REL) {
3344                 bb_error_msg_and_die("ELF file not a relocatable object");
3345         }
3346
3347         /* Read the section headers.  */
3348
3349         if (f->header.e_shentsize != sizeof(ElfW(Shdr))) {
3350                 bb_error_msg_and_die("section header size mismatch: %lu != %lu",
3351                                 (unsigned long) f->header.e_shentsize,
3352                                 (unsigned long) sizeof(ElfW(Shdr)));
3353         }
3354
3355         shnum = f->header.e_shnum;
3356         f->sections = xmalloc(sizeof(struct obj_section *) * shnum);
3357         memset(f->sections, 0, sizeof(struct obj_section *) * shnum);
3358
3359         section_headers = alloca(sizeof(ElfW(Shdr)) * shnum);
3360         fseek(fp, f->header.e_shoff, SEEK_SET);
3361         if (fread(section_headers, sizeof(ElfW(Shdr)), shnum, fp) != shnum) {
3362                 bb_perror_msg_and_die("error reading ELF section headers");
3363         }
3364
3365         /* Read the section data.  */
3366
3367         for (i = 0; i < shnum; ++i) {
3368                 struct obj_section *sec;
3369
3370                 f->sections[i] = sec = arch_new_section();
3371
3372                 sec->header = section_headers[i];
3373                 sec->idx = i;
3374
3375                 if (sec->header.sh_size) {
3376                         switch (sec->header.sh_type) {
3377                         case SHT_NULL:
3378                         case SHT_NOTE:
3379                         case SHT_NOBITS:
3380                                 /* ignore */
3381                                 break;
3382
3383                         case SHT_PROGBITS:
3384 #if LOADBITS
3385                                 if (!loadprogbits) {
3386                                         sec->contents = NULL;
3387                                         break;
3388                                 }
3389 #endif
3390                         case SHT_SYMTAB:
3391                         case SHT_STRTAB:
3392                         case SHT_RELM:
3393                                 if (sec->header.sh_size > 0) {
3394                                         sec->contents = xmalloc(sec->header.sh_size);
3395                                         fseek(fp, sec->header.sh_offset, SEEK_SET);
3396                                         if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3397                                                 bb_perror_msg_and_die("error reading ELF section data");
3398                                         }
3399                                 } else {
3400                                         sec->contents = NULL;
3401                                 }
3402                                 break;
3403
3404 #if SHT_RELM == SHT_REL
3405                         case SHT_RELA:
3406                                 bb_error_msg_and_die("RELA relocations not supported on this architecture");
3407 #else
3408                         case SHT_REL:
3409                                 bb_error_msg_and_die("REL relocations not supported on this architecture");
3410 #endif
3411                         default:
3412                                 if (sec->header.sh_type >= SHT_LOPROC) {
3413                                         /* Assume processor specific section types are debug
3414                                            info and can safely be ignored.  If this is ever not
3415                                            the case (Hello MIPS?), don't put ifdefs here but
3416                                            create an arch_load_proc_section().  */
3417                                         break;
3418                                 }
3419
3420                                 bb_error_msg_and_die("can't handle sections of type %ld",
3421                                                 (long) sec->header.sh_type);
3422                         }
3423                 }
3424         }
3425
3426         /* Do what sort of interpretation as needed by each section.  */
3427
3428         shstrtab = f->sections[f->header.e_shstrndx]->contents;
3429
3430         for (i = 0; i < shnum; ++i) {
3431                 struct obj_section *sec = f->sections[i];
3432                 sec->name = shstrtab + sec->header.sh_name;
3433         }
3434
3435         for (i = 0; i < shnum; ++i) {
3436                 struct obj_section *sec = f->sections[i];
3437
3438                 /* .modinfo should be contents only but gcc has no attribute for that.
3439                  * The kernel may have marked .modinfo as ALLOC, ignore this bit.
3440                  */
3441                 if (strcmp(sec->name, ".modinfo") == 0)
3442                         sec->header.sh_flags &= ~SHF_ALLOC;
3443
3444                 if (sec->header.sh_flags & SHF_ALLOC)
3445                         obj_insert_section_load_order(f, sec);
3446
3447                 switch (sec->header.sh_type) {
3448                 case SHT_SYMTAB:
3449                         {
3450                                 unsigned long nsym, j;
3451                                 char *strtab;
3452                                 ElfW(Sym) * sym;
3453
3454                                 if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
3455                                         bb_error_msg_and_die("symbol size mismatch: %lu != %lu",
3456                                                         (unsigned long) sec->header.sh_entsize,
3457                                                         (unsigned long) sizeof(ElfW(Sym)));
3458                                 }
3459
3460                                 nsym = sec->header.sh_size / sizeof(ElfW(Sym));
3461                                 strtab = f->sections[sec->header.sh_link]->contents;
3462                                 sym = (ElfW(Sym) *) sec->contents;
3463
3464                                 /* Allocate space for a table of local symbols.  */
3465                                 j = f->local_symtab_size = sec->header.sh_info;
3466                                 f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
3467
3468                                 /* Insert all symbols into the hash table.  */
3469                                 for (j = 1, ++sym; j < nsym; ++j, ++sym) {
3470                                         ElfW(Addr) val = sym->st_value;
3471                                         const char *name;
3472                                         if (sym->st_name)
3473                                                 name = strtab + sym->st_name;
3474                                         else if (sym->st_shndx < shnum)
3475                                                 name = f->sections[sym->st_shndx]->name;
3476                                         else
3477                                                 continue;
3478 #if defined(__SH5__)
3479                                         /*
3480                                          * For sh64 it is possible that the target of a branch
3481                                          * requires a mode switch (32 to 16 and back again).
3482                                          *
3483                                          * This is implied by the lsb being set in the target
3484                                          * address for SHmedia mode and clear for SHcompact.
3485                                          */
3486                                         val |= sym->st_other & 4;
3487 #endif
3488                                         obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
3489                                                         val, sym->st_size);
3490                                 }
3491                         }
3492                         break;
3493
3494                 case SHT_RELM:
3495                         if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
3496                                 bb_error_msg_and_die("relocation entry size mismatch: %lu != %lu",
3497                                                 (unsigned long) sec->header.sh_entsize,
3498                                                 (unsigned long) sizeof(ElfW(RelM)));
3499                         }
3500                         break;
3501                         /* XXX  Relocation code from modutils-2.3.19 is not here.
3502                          * Why?  That's about 20 lines of code from obj/obj_load.c,
3503                          * which gets done in a second pass through the sections.
3504                          * This BusyBox insmod does similar work in obj_relocate(). */
3505                 }
3506         }
3507
3508         return f;
3509 }
3510
3511 #if ENABLE_FEATURE_INSMOD_LOADINKMEM
3512 /*
3513  * load the unloaded sections directly into the memory allocated by
3514  * kernel for the module
3515  */
3516
3517 static int obj_load_progbits(FILE *fp, struct obj_file *f, char *imagebase)
3518 {
3519         ElfW(Addr) base = f->baseaddr;
3520         struct obj_section* sec;
3521
3522         for (sec = f->load_order; sec; sec = sec->load_next) {
3523
3524                 /* section already loaded? */
3525                 if (sec->contents != NULL)
3526                         continue;
3527
3528                 if (sec->header.sh_size == 0)
3529                         continue;
3530
3531                 sec->contents = imagebase + (sec->header.sh_addr - base);
3532                 fseek(fp, sec->header.sh_offset, SEEK_SET);
3533                 if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
3534                         bb_perror_msg("error reading ELF section data");
3535                         return 0;
3536                 }
3537
3538         }
3539         return 1;
3540 }
3541 #endif
3542
3543 static void hide_special_symbols(struct obj_file *f)
3544 {
3545         static const char *const specials[] = {
3546                 SPFX "cleanup_module",
3547                 SPFX "init_module",
3548                 SPFX "kernel_version",
3549                 NULL
3550         };
3551
3552         struct obj_symbol *sym;
3553         const char *const *p;
3554
3555         for (p = specials; *p; ++p) {
3556                 sym = obj_find_symbol(f, *p);
3557                 if (sym != NULL)
3558                         sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
3559         }
3560 }
3561
3562
3563 #if ENABLE_FEATURE_CHECK_TAINTED_MODULE
3564 static int obj_gpl_license(struct obj_file *f, const char **license)
3565 {
3566         struct obj_section *sec;
3567         /* This list must match *exactly* the list of allowable licenses in
3568          * linux/include/linux/module.h.  Checking for leading "GPL" will not
3569          * work, somebody will use "GPL sucks, this is proprietary".
3570          */
3571         static const char *const gpl_licenses[] = {
3572                 "GPL",
3573                 "GPL v2",
3574                 "GPL and additional rights",
3575                 "Dual BSD/GPL",
3576                 "Dual MPL/GPL"
3577         };
3578
3579         sec = obj_find_section(f, ".modinfo");
3580         if (sec) {
3581                 const char *value, *ptr, *endptr;
3582                 ptr = sec->contents;
3583                 endptr = ptr + sec->header.sh_size;
3584                 while (ptr < endptr) {
3585                         value = strchr(ptr, '=');
3586                         if (value && strncmp(ptr, "license", value-ptr) == 0) {
3587                                 unsigned i;
3588                                 if (license)
3589                                         *license = value+1;
3590                                 for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
3591                                         if (strcmp(value+1, gpl_licenses[i]) == 0)
3592                                                 return 0;
3593                                 }
3594                                 return 2;
3595                         }
3596                         ptr = strchr(ptr, '\0');
3597                         if (ptr)
3598                                 ptr++;
3599                         else
3600                                 ptr = endptr;
3601                 }
3602         }
3603         return 1;
3604 }
3605
3606 #define TAINT_FILENAME                  "/proc/sys/kernel/tainted"
3607 #define TAINT_PROPRIETORY_MODULE        (1 << 0)
3608 #define TAINT_FORCED_MODULE             (1 << 1)
3609 #define TAINT_UNSAFE_SMP                (1 << 2)
3610 #define TAINT_URL                       "http://www.tux.org/lkml/#export-tainted"
3611
3612 static void set_tainted(int fd, char *m_name,
3613                 int kernel_has_tainted, int taint, const char *text1, const char *text2)
3614 {
3615         static smallint printed_info;
3616
3617         char buf[80];
3618         int oldval;
3619
3620         if (fd < 0 && !kernel_has_tainted)
3621                 return;         /* New modutils on old kernel */
3622         printf("Warning: loading %s will taint the kernel: %s%s\n",
3623                         m_name, text1, text2);
3624         if (!printed_info) {
3625                 printf("  See %s for information about tainted modules\n", TAINT_URL);
3626                 printed_info = 1;
3627         }
3628         if (fd >= 0) {
3629                 read(fd, buf, sizeof(buf)-1);
3630                 buf[sizeof(buf)-1] = '\0';
3631                 oldval = strtoul(buf, NULL, 10);
3632                 sprintf(buf, "%d\n", oldval | taint);
3633                 write(fd, buf, strlen(buf));
3634         }
3635 }
3636
3637 /* Check if loading this module will taint the kernel. */
3638 static void check_tainted_module(struct obj_file *f, char *m_name)
3639 {
3640         static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
3641
3642         int fd, kernel_has_tainted;
3643         const char *ptr;
3644
3645         kernel_has_tainted = 1;
3646         fd = open(tainted_file, O_RDWR);
3647         if (fd < 0) {
3648                 if (errno == ENOENT)
3649                         kernel_has_tainted = 0;
3650                 else if (errno == EACCES)
3651                         kernel_has_tainted = 1;
3652                 else {
3653                         perror(tainted_file);
3654                         kernel_has_tainted = 0;
3655                 }
3656         }
3657
3658         switch (obj_gpl_license(f, &ptr)) {
3659                 case 0:
3660                         break;
3661                 case 1:
3662                         set_tainted(fd, m_name, kernel_has_tainted, TAINT_PROPRIETORY_MODULE, "no license", "");
3663                         break;
3664                 case 2:
3665                         /* The module has a non-GPL license so we pretend that the
3666                          * kernel always has a taint flag to get a warning even on
3667                          * kernels without the proc flag.
3668                          */
3669                         set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "non-GPL license - ", ptr);
3670                         break;
3671                 default:
3672                         set_tainted(fd, m_name, 1, TAINT_PROPRIETORY_MODULE, "Unexpected return from obj_gpl_license", "");
3673                         break;
3674         }
3675
3676         if (flag_force_load)
3677                 set_tainted(fd, m_name, 1, TAINT_FORCED_MODULE, "forced load", "");
3678
3679         if (fd >= 0)
3680                 close(fd);
3681 }
3682 #else /* FEATURE_CHECK_TAINTED_MODULE */
3683 #define check_tainted_module(x, y) do { } while (0);
3684 #endif /* FEATURE_CHECK_TAINTED_MODULE */
3685
3686 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
3687 /* add module source, timestamp, kernel version and a symbol for the
3688  * start of some sections.  this info is used by ksymoops to do better
3689  * debugging.
3690  */
3691 #if !ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3692 #define get_module_version(f, str) get_module_version(str)
3693 #endif
3694 static int
3695 get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
3696 {
3697 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3698         return new_get_module_version(f, str);
3699 #else  /* FEATURE_INSMOD_VERSION_CHECKING */
3700         strncpy(str, "???", sizeof(str));
3701         return -1;
3702 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
3703 }
3704
3705 /* add module source, timestamp, kernel version and a symbol for the
3706  * start of some sections.  this info is used by ksymoops to do better
3707  * debugging.
3708  */
3709 static void
3710 add_ksymoops_symbols(struct obj_file *f, const char *filename,
3711                                  const char *m_name)
3712 {
3713         static const char symprefix[] ALIGN1 = "__insmod_";
3714         static const char section_names[][8] = {
3715                 ".text",
3716                 ".rodata",
3717                 ".data",
3718                 ".bss",
3719                 ".sbss"
3720         };
3721
3722         struct obj_section *sec;
3723         struct obj_symbol *sym;
3724         char *name, *absolute_filename;
3725         char str[STRVERSIONLEN];
3726         unsigned i;
3727         int l, lm_name, lfilename, use_ksymtab, version;
3728         struct stat statbuf;
3729
3730         /* WARNING: was using realpath, but replaced by readlink to stop using
3731          * lots of stack. But here it seems to be able to cause problems? */
3732         absolute_filename = xmalloc_readlink(filename);
3733         if (!absolute_filename)
3734                 absolute_filename = xstrdup(filename);
3735
3736         lm_name = strlen(m_name);
3737         lfilename = strlen(absolute_filename);
3738
3739         /* add to ksymtab if it already exists or there is no ksymtab and other symbols
3740          * are not to be exported.  otherwise leave ksymtab alone for now, the
3741          * "export all symbols" compatibility code will export these symbols later.
3742          */
3743         use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
3744
3745         sec = obj_find_section(f, ".this");
3746         if (sec) {
3747                 /* tag the module header with the object name, last modified
3748                  * timestamp and module version.  worst case for module version
3749                  * is 0xffffff, decimal 16777215.  putting all three fields in
3750                  * one symbol is less readable but saves kernel space.
3751                  */
3752                 l = sizeof(symprefix) +                 /* "__insmod_" */
3753                         lm_name +                       /* module name */
3754                         2 +                             /* "_O" */
3755                         lfilename +                     /* object filename */
3756                         2 +                             /* "_M" */
3757                         2 * sizeof(statbuf.st_mtime) +  /* mtime in hex */
3758                         2 +                             /* "_V" */
3759                         8 +                             /* version in dec */
3760                         1;                              /* nul */
3761                 name = xmalloc(l);
3762                 if (stat(absolute_filename, &statbuf) != 0)
3763                         statbuf.st_mtime = 0;
3764                 version = get_module_version(f, str);   /* -1 if not found */
3765                 snprintf(name, l, "%s%s_O%s_M%0*lX_V%d",
3766                                 symprefix, m_name, absolute_filename,
3767                                 (int)(2 * sizeof(statbuf.st_mtime)), statbuf.st_mtime,
3768                                 version);
3769                 sym = obj_add_symbol(f, name, -1,
3770                                 ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3771                                 sec->idx, sec->header.sh_addr, 0);
3772                 if (use_ksymtab)
3773                         new_add_ksymtab(f, sym);
3774         }
3775         free(absolute_filename);
3776 #ifdef _NOT_SUPPORTED_
3777         /* record where the persistent data is going, same address as previous symbol */
3778
3779         if (f->persist) {
3780                 l = sizeof(symprefix) +         /* "__insmod_" */
3781                         lm_name +               /* module name */
3782                         2 +                     /* "_P" */
3783                         strlen(f->persist) +    /* data store */
3784                         1;                      /* nul */
3785                 name = xmalloc(l);
3786                 snprintf(name, l, "%s%s_P%s",
3787                                 symprefix, m_name, f->persist);
3788                 sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3789                                 sec->idx, sec->header.sh_addr, 0);
3790                 if (use_ksymtab)
3791                         new_add_ksymtab(f, sym);
3792         }
3793 #endif /* _NOT_SUPPORTED_ */
3794         /* tag the desired sections if size is non-zero */
3795
3796         for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
3797                 sec = obj_find_section(f, section_names[i]);
3798                 if (sec && sec->header.sh_size) {
3799                         l = sizeof(symprefix) +         /* "__insmod_" */
3800                                 lm_name +               /* module name */
3801                                 2 +                     /* "_S" */
3802                                 strlen(sec->name) +     /* section name */
3803                                 2 +                     /* "_L" */
3804                                 8 +                     /* length in dec */
3805                                 1;                      /* nul */
3806                         name = xmalloc(l);
3807                         snprintf(name, l, "%s%s_S%s_L%ld",
3808                                         symprefix, m_name, sec->name,
3809                                         (long)sec->header.sh_size);
3810                         sym = obj_add_symbol(f, name, -1, ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
3811                                         sec->idx, sec->header.sh_addr, 0);
3812                         if (use_ksymtab)
3813                                 new_add_ksymtab(f, sym);
3814                 }
3815         }
3816 }
3817 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
3818
3819 #if ENABLE_FEATURE_INSMOD_LOAD_MAP
3820 static void print_load_map(struct obj_file *f)
3821 {
3822         struct obj_section *sec;
3823 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3824         struct obj_symbol **all, **p;
3825         int i, nsyms, *loaded;
3826         struct obj_symbol *sym;
3827 #endif
3828         /* Report on the section layout.  */
3829
3830         printf("Sections:       Size      %-*s  Align\n",
3831                         (int) (2 * sizeof(void *)), "Address");
3832
3833         for (sec = f->load_order; sec; sec = sec->load_next) {
3834                 int a;
3835                 unsigned long tmp;
3836
3837                 for (a = -1, tmp = sec->header.sh_addralign; tmp; ++a)
3838                         tmp >>= 1;
3839                 if (a == -1)
3840                         a = 0;
3841
3842                 printf("%-15s %08lx  %0*lx  2**%d\n",
3843                                 sec->name,
3844                                 (long)sec->header.sh_size,
3845                                 (int) (2 * sizeof(void *)),
3846                                 (long)sec->header.sh_addr,
3847                                 a);
3848         }
3849 #if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
3850         /* Quick reference which section indicies are loaded.  */
3851
3852         i = f->header.e_shnum;
3853         loaded = alloca(sizeof(int) * i);
3854         while (--i >= 0)
3855                 loaded[i] = ((f->sections[i]->header.sh_flags & SHF_ALLOC) != 0);
3856
3857         /* Collect the symbols we'll be listing.  */
3858
3859         for (nsyms = i = 0; i < HASH_BUCKETS; ++i)
3860                 for (sym = f->symtab[i]; sym; sym = sym->next)
3861                         if (sym->secidx <= SHN_HIRESERVE
3862                                         && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3863                                 ++nsyms;
3864
3865         all = alloca(nsyms * sizeof(struct obj_symbol *));
3866
3867         for (i = 0, p = all; i < HASH_BUCKETS; ++i)
3868                 for (sym = f->symtab[i]; sym; sym = sym->next)
3869                         if (sym->secidx <= SHN_HIRESERVE
3870                                         && (sym->secidx >= SHN_LORESERVE || loaded[sym->secidx]))
3871                                 *p++ = sym;
3872
3873         /* And list them.  */
3874         printf("\nSymbols:\n");
3875         for (p = all; p < all + nsyms; ++p) {
3876                 char type = '?';
3877                 unsigned long value;
3878
3879                 sym = *p;
3880                 if (sym->secidx == SHN_ABS) {
3881                         type = 'A';
3882                         value = sym->value;
3883                 } else if (sym->secidx == SHN_UNDEF) {
3884                         type = 'U';
3885                         value = 0;
3886                 } else {
3887                         sec = f->sections[sym->secidx];
3888
3889                         if (sec->header.sh_type == SHT_NOBITS)
3890                                 type = 'B';
3891                         else if (sec->header.sh_flags & SHF_ALLOC) {
3892                                 if (sec->header.sh_flags & SHF_EXECINSTR)
3893                                         type = 'T';
3894                                 else if (sec->header.sh_flags & SHF_WRITE)
3895                                         type = 'D';
3896                                 else
3897                                         type = 'R';
3898                         }
3899                         value = sym->value + sec->header.sh_addr;
3900                 }
3901
3902                 if (ELF_ST_BIND(sym->info) == STB_LOCAL)
3903                         type = tolower(type);
3904
3905                 printf("%0*lx %c %s\n", (int) (2 * sizeof(void *)), value,
3906                                 type, sym->name);
3907         }
3908 #endif
3909 }
3910 #else /* !FEATURE_INSMOD_LOAD_MAP */
3911 void print_load_map(struct obj_file *f);
3912 #endif
3913
3914 int insmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
3915 int insmod_main(int argc, char **argv)
3916 {
3917         char *opt_o, *arg1;
3918         int len;
3919         int k_crcs;
3920         char *tmp, *tmp1;
3921         unsigned long m_size;
3922         ElfW(Addr) m_addr;
3923         struct obj_file *f;
3924         struct stat st;
3925         char *m_name = NULL;
3926         int exit_status = EXIT_FAILURE;
3927         int m_has_modinfo;
3928 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
3929         struct utsname uts_info;
3930         char m_strversion[STRVERSIONLEN];
3931         int m_version, m_crcs;
3932 #endif
3933 #if ENABLE_FEATURE_CLEAN_UP
3934         FILE *fp = NULL;
3935 #else
3936         FILE *fp;
3937 #endif
3938         int k_version = 0;
3939         struct utsname myuname;
3940
3941         /* Parse any options */
3942         getopt32(argv, OPTION_STR, &opt_o);
3943         arg1 = argv[optind];
3944         if (option_mask32 & OPT_o) { // -o /* name the output module */
3945                 free(m_name);
3946                 m_name = xstrdup(opt_o);
3947         }
3948
3949         if (arg1 == NULL) {
3950                 bb_show_usage();
3951         }
3952
3953         /* Grab the module name */
3954         tmp1 = xstrdup(arg1);
3955         tmp = basename(tmp1);
3956         len = strlen(tmp);
3957
3958         if (uname(&myuname) == 0) {
3959                 if (myuname.release[0] == '2') {
3960                         k_version = myuname.release[2] - '0';
3961                 }
3962         }
3963
3964 #if ENABLE_FEATURE_2_6_MODULES
3965         if (k_version > 4 && len > 3 && tmp[len - 3] == '.'
3966          && tmp[len - 2] == 'k' && tmp[len - 1] == 'o'
3967         ) {
3968                 len -= 3;
3969                 tmp[len] = '\0';
3970         } else
3971 #endif
3972                 if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o') {
3973                         len -= 2;
3974                         tmp[len] = '\0';
3975                 }
3976
3977
3978 #if ENABLE_FEATURE_2_6_MODULES
3979         if (k_version > 4)
3980                 m_fullName = xasprintf("%s.ko", tmp);
3981         else
3982 #endif
3983                 m_fullName = xasprintf("%s.o", tmp);
3984
3985         if (!m_name) {
3986                 m_name = tmp;
3987         } else {
3988                 free(tmp1);
3989                 tmp1 = NULL;       /* flag for free(m_name) before exit() */
3990         }
3991
3992         /* Get a filedesc for the module.  Check that we have a complete path */
3993         if (stat(arg1, &st) < 0 || !S_ISREG(st.st_mode)
3994          || (fp = fopen(arg1, "r")) == NULL
3995         ) {
3996                 /* Hmm.  Could not open it.  First search under /lib/modules/`uname -r`,
3997                  * but do not error out yet if we fail to find it... */
3998                 if (k_version) {        /* uname succeedd */
3999                         char *module_dir;
4000                         char *tmdn;
4001
4002                         tmdn = concat_path_file(CONFIG_DEFAULT_MODULES_DIR, myuname.release);
4003                         /* Jump through hoops in case /lib/modules/`uname -r`
4004                          * is a symlink.  We do not want recursive_action to
4005                          * follow symlinks, but we do want to follow the
4006                          * /lib/modules/`uname -r` dir, So resolve it ourselves
4007                          * if it is a link... */
4008                         module_dir = xmalloc_readlink(tmdn);
4009                         if (!module_dir)
4010                                 module_dir = xstrdup(tmdn);
4011                         recursive_action(module_dir, ACTION_RECURSE,
4012                                         check_module_name_match, NULL, m_fullName, 0);
4013                         free(module_dir);
4014                         free(tmdn);
4015                 }
4016
4017                 /* Check if we have found anything yet */
4018                 if (!m_filename || ((fp = fopen(m_filename, "r")) == NULL)) {
4019                         int r;
4020                         char *module_dir;
4021
4022                         free(m_filename);
4023                         m_filename = NULL;
4024                         module_dir = xmalloc_readlink(CONFIG_DEFAULT_MODULES_DIR);
4025                         if (!module_dir)
4026                                 module_dir = xstrdup(CONFIG_DEFAULT_MODULES_DIR);
4027                         /* No module found under /lib/modules/`uname -r`, this
4028                          * time cast the net a bit wider.  Search /lib/modules/ */
4029                         r = recursive_action(module_dir, ACTION_RECURSE,
4030                                         check_module_name_match, NULL, m_fullName, 0);
4031                         if (r)
4032                                 bb_error_msg_and_die("%s: module not found", m_fullName);
4033                         free(module_dir);
4034                         if (m_filename == NULL
4035                          || ((fp = fopen(m_filename, "r")) == NULL)
4036                         ) {
4037                                 bb_error_msg_and_die("%s: module not found", m_fullName);
4038                         }
4039                 }
4040         } else
4041                 m_filename = xstrdup(arg1);
4042
4043         if (flag_verbose)
4044                 printf("Using %s\n", m_filename);
4045
4046 #if ENABLE_FEATURE_2_6_MODULES
4047         if (k_version > 4) {
4048                 argv[optind] = m_filename;
4049                 optind--;
4050                 return insmod_ng_main(argc - optind, argv + optind);
4051         }
4052 #endif
4053
4054         f = obj_load(fp, LOADBITS);
4055
4056         if (get_modinfo_value(f, "kernel_version") == NULL)
4057                 m_has_modinfo = 0;
4058         else
4059                 m_has_modinfo = 1;
4060
4061 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
4062         /* Version correspondence?  */
4063         if (!flag_quiet) {
4064                 if (uname(&uts_info) < 0)
4065                         uts_info.release[0] = '\0';
4066                 if (m_has_modinfo) {
4067                         m_version = new_get_module_version(f, m_strversion);
4068                         if (m_version == -1) {
4069                                 bb_error_msg_and_die("cannot find the kernel version the module was "
4070                                                 "compiled for");
4071                         }
4072                 }
4073
4074                 if (strncmp(uts_info.release, m_strversion, STRVERSIONLEN) != 0) {
4075                         bb_error_msg("%skernel-module version mismatch\n"
4076                                 "\t%s was compiled for kernel version %s\n"
4077                                 "\twhile this kernel is version %s",
4078                                 flag_force_load ? "warning: " : "",
4079                                 m_filename, m_strversion, uts_info.release);
4080                         if (!flag_force_load)
4081                                 goto out;
4082                 }
4083         }
4084         k_crcs = 0;
4085 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
4086
4087         if (query_module(NULL, 0, NULL, 0, NULL))
4088                 bb_error_msg_and_die("not configured to support old kernels");
4089         new_get_kernel_symbols();
4090         k_crcs = new_is_kernel_checksummed();
4091
4092 #if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
4093         m_crcs = 0;
4094         if (m_has_modinfo)
4095                 m_crcs = new_is_module_checksummed(f);
4096
4097         if (m_crcs != k_crcs)
4098                 obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
4099 #endif /* FEATURE_INSMOD_VERSION_CHECKING */
4100
4101         /* Let the module know about the kernel symbols.  */
4102         add_kernel_symbols(f);
4103
4104         /* Allocate common symbols, symbol tables, and string tables.  */
4105
4106         new_create_this_module(f, m_name);
4107         obj_check_undefineds(f);
4108         obj_allocate_commons(f);
4109         check_tainted_module(f, m_name);
4110
4111         /* done with the module name, on to the optional var=value arguments */
4112         ++optind;
4113         if (optind < argc) {
4114                 new_process_module_arguments(f, argc - optind, argv + optind);
4115         }
4116
4117         arch_create_got(f);
4118         hide_special_symbols(f);
4119
4120 #if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
4121         add_ksymoops_symbols(f, m_filename, m_name);
4122 #endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
4123
4124         new_create_module_ksymtab(f);
4125
4126         /* Find current size of the module */
4127         m_size = obj_load_size(f);
4128
4129         m_addr = create_module(m_name, m_size);
4130         if (m_addr == (ElfW(Addr))(-1)) switch (errno) {
4131                 case EEXIST:
4132                         bb_error_msg_and_die("a module named %s already exists", m_name);
4133                 case ENOMEM:
4134                         bb_error_msg_and_die("can't allocate kernel memory for module; needed %lu bytes",
4135                                         m_size);
4136                 default:
4137                         bb_perror_msg_and_die("create_module: %s", m_name);
4138         }
4139
4140 #if !LOADBITS
4141         /*
4142          * the PROGBITS section was not loaded by the obj_load
4143          * now we can load them directly into the kernel memory
4144          */
4145         if (!obj_load_progbits(fp, f, (char*)m_addr)) {
4146                 delete_module(m_name, 0);
4147                 goto out;
4148         }
4149 #endif
4150
4151         if (!obj_relocate(f, m_addr)) {
4152                 delete_module(m_name, 0);
4153                 goto out;
4154         }
4155
4156         if (!new_init_module(m_name, f, m_size)) {
4157                 delete_module(m_name, 0);
4158                 goto out;
4159         }
4160
4161         if (flag_print_load_map)
4162                 print_load_map(f);
4163
4164         exit_status = EXIT_SUCCESS;
4165
4166  out:
4167 #if ENABLE_FEATURE_CLEAN_UP
4168         if (fp)
4169                 fclose(fp);
4170         free(tmp1);
4171         if (!tmp1)
4172                 free(m_name);
4173         free(m_filename);
4174 #endif
4175         return exit_status;
4176 }
4177
4178 #endif /* ENABLE_FEATURE_2_4_MODULES */
4179 /*
4180  * End of big piece of 2.4-specific code
4181  */
4182
4183
4184 #if ENABLE_FEATURE_2_6_MODULES
4185
4186 #include <sys/mman.h>
4187
4188 #if defined __UCLIBC__ && !ENABLE_FEATURE_2_4_MODULES
4189 /* big time suckage. The old prototype above renders our nice fwd-decl wrong */
4190 extern int init_module(void *module, unsigned long len, const char *options);
4191 #else
4192 #include <asm/unistd.h>
4193 #include <sys/syscall.h>
4194 #define init_module(mod, len, opts) syscall(__NR_init_module, mod, len, opts)
4195 #endif
4196
4197 /* We use error numbers in a loose translation... */
4198 static const char *moderror(int err)
4199 {
4200         switch (err) {
4201         case ENOEXEC:
4202                 return "invalid module format";
4203         case ENOENT:
4204                 return "unknown symbol in module";
4205         case ESRCH:
4206                 return "module has wrong symbol version";
4207         case EINVAL:
4208                 return "invalid parameters";
4209         default:
4210                 return strerror(err);
4211         }
4212 }
4213
4214 #if !ENABLE_FEATURE_2_4_MODULES
4215 int insmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
4216 int insmod_main(int argc UNUSED_PARAM, char **argv)
4217 #else
4218 static int insmod_ng_main(int argc UNUSED_PARAM, char **argv)
4219 #endif
4220 {
4221         size_t len;
4222         int optlen;
4223         void *map;
4224         char *filename, *options;
4225
4226         filename = *++argv;
4227         if (!filename)
4228                 bb_show_usage();
4229
4230         /* Rest is options */
4231         options = xzalloc(1);
4232         optlen = 0;
4233         while (*++argv) {
4234                 options = xrealloc(options, optlen + 2 + strlen(*argv) + 2);
4235                 /* Spaces handled by "" pairs, but no way of escaping quotes */
4236                 optlen += sprintf(options + optlen, (strchr(*argv,' ') ? "\"%s\" " : "%s "), *argv);
4237         }
4238
4239 #if 0
4240         /* Any special reason why mmap? It isn't performance critical. -vda */
4241         /* Yes, xmalloc'ing can use *alot* of RAM. Don't forget that there are
4242          * modules out there that are half a megabyte! mmap()ing is way nicer
4243          * for small mem boxes, i guess. */
4244         /* But after load, these modules will take up that 0.5mb in kernel
4245          * anyway. Using malloc here causes only a transient spike to 1mb,
4246          * after module is loaded, we go back to normal 0.5mb usage
4247          * (in kernel). Also, mmap isn't magic - when we touch mapped data,
4248          * we use memory. -vda */
4249         int fd;
4250         struct stat st;
4251         unsigned long len;
4252         fd = xopen(filename, O_RDONLY);
4253         fstat(fd, &st);
4254         len = st.st_size;
4255         map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
4256         if (map == MAP_FAILED) {
4257                 bb_perror_msg_and_die("cannot mmap '%s'", filename);
4258         }
4259
4260         /* map == NULL on Blackfin, probably on other MMU-less systems too. Workaround. */
4261         if (map == NULL) {
4262                 map = xmalloc(len);
4263                 xread(fd, map, len);
4264         }
4265 #else
4266         len = MAXINT(ssize_t);
4267         map = xmalloc_open_read_close(filename, &len);
4268 #endif
4269
4270         if (init_module(map, len, options) != 0)
4271                 bb_error_msg_and_die("cannot insert '%s': %s",
4272                                 filename, moderror(errno));
4273         return 0;
4274 }
4275
4276 #endif