Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/modutils


Ignore:
Timestamp:
Nov 4, 2007, 3:16:40 AM (16 years ago)
Author:
Bruno Cornec
Message:

Update to busybox 1.7.2

Location:
branches/2.2.5/mindi-busybox/modutils
Files:
1 added
2 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • branches/2.2.5/mindi-busybox/modutils/Config.in

    r821 r1765  
    66menu "Linux Module Utilities"
    77
    8 config CONFIG_INSMOD
     8config INSMOD
    99    bool "insmod"
    1010    default n
     
    1212      insmod is used to load specified modules in the running kernel.
    1313
    14 config CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     14config FEATURE_INSMOD_VERSION_CHECKING
    1515    bool "Module version checking"
    1616    default n
    17     depends on CONFIG_INSMOD && CONFIG_FEATURE_2_4_MODULES
     17    depends on INSMOD && FEATURE_2_4_MODULES
    1818    help
    1919      Support checking of versions for modules.  This is used to
    2020      ensure that the kernel and module are made for each other.
    2121
    22 config CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
     22config FEATURE_INSMOD_KSYMOOPS_SYMBOLS
    2323    bool "Add module symbols to kernel symbol table"
    2424    default n
    25     depends on CONFIG_INSMOD && CONFIG_FEATURE_2_4_MODULES
     25    depends on INSMOD && FEATURE_2_4_MODULES
    2626    help
    2727      By adding module symbols to the kernel symbol table, Oops messages
     
    3131      Oops messages from kernel modules, say N.
    3232
    33 config CONFIG_FEATURE_INSMOD_LOADINKMEM
     33config FEATURE_INSMOD_LOADINKMEM
    3434    bool "In kernel memory optimization (uClinux only)"
    3535    default n
    36     depends on CONFIG_INSMOD && CONFIG_FEATURE_2_4_MODULES
     36    depends on INSMOD && FEATURE_2_4_MODULES
    3737    help
    3838      This is a special uClinux only memory optimization that lets insmod
     
    4141      being loaded into memory.
    4242
    43 config CONFIG_FEATURE_INSMOD_LOAD_MAP
     43config FEATURE_INSMOD_LOAD_MAP
    4444    bool "Enable load map (-m) option"
    4545    default n
    46     depends on CONFIG_INSMOD && CONFIG_FEATURE_2_4_MODULES
     46    depends on INSMOD && ( FEATURE_2_4_MODULES || FEATURE_2_6_MODULES )
    4747    help
    4848      Enabling this, one would be able to get a load map
     
    5252      don't need this option.
    5353
    54 config CONFIG_FEATURE_INSMOD_LOAD_MAP_FULL
     54config FEATURE_INSMOD_LOAD_MAP_FULL
    5555    bool "Symbols in load map"
    5656    default y
    57     depends on CONFIG_FEATURE_INSMOD_LOAD_MAP
     57    depends on FEATURE_INSMOD_LOAD_MAP
    5858    help
    5959      Without this option, -m will only output section
     
    6161      symbols load map.
    6262
    63 config CONFIG_RMMOD
     63config RMMOD
    6464    bool "rmmod"
    6565    default n
     
    6767      rmmod is used to unload specified modules from the kernel.
    6868
    69 config CONFIG_LSMOD
     69config LSMOD
    7070    bool "lsmod"
    7171    default n
     
    7373      lsmod is used to display a list of loaded modules.
    7474
    75 config CONFIG_FEATURE_LSMOD_PRETTY_2_6_OUTPUT
     75config FEATURE_LSMOD_PRETTY_2_6_OUTPUT
    7676    bool "lsmod pretty output for 2.6.x Linux kernels "
    7777    default n
    78     depends on CONFIG_LSMOD
     78    depends on LSMOD
    7979    help
    8080      This option makes output format of lsmod adjusted to
    8181      the format of module-init-tools for Linux kernel 2.6.
    8282
    83 config CONFIG_MODPROBE
     83config MODPROBE
    8484    bool "modprobe"
    8585    default n
     
    9191      module options from the configuration file. See option below.
    9292
    93 config CONFIG_FEATURE_MODPROBE_MULTIPLE_OPTIONS
    94     bool "Multiple options parsing"
     93config FEATURE_MODPROBE_MULTIPLE_OPTIONS
     94    bool
     95    prompt "Multiple options parsing" if NITPICK
    9596    default y
    96     depends on CONFIG_MODPROBE
     97    depends on MODPROBE
    9798    help
    9899      Allow modprobe to understand more than one option to pass to
     
    107108      on storage capacity.
    108109
     110config FEATURE_MODPROBE_FANCY_ALIAS
     111    bool
     112    prompt "Fancy alias parsing" if NITPICK
     113    default y
     114    depends on MODPROBE && FEATURE_2_6_MODULES
     115    help
     116      Say 'y' here to enable parsing of aliases with underscore/dash
     117      mismatch between module name and file name, along with bus-specific
     118      aliases (such as pci:... or usb:... aliases).
     119
    109120comment "Options common to multiple modutils"
    110     depends on CONFIG_INSMOD || CONFIG_RMMOD || CONFIG_MODPROBE || CONFIG_LSMOD
     121    depends on INSMOD || RMMOD || MODPROBE || LSMOD
    111122
    112 config CONFIG_FEATURE_CHECK_TAINTED_MODULE
     123config FEATURE_CHECK_TAINTED_MODULE
    113124    # Simulate indentation
    114125    bool "Support tainted module checking with new kernels"
    115126    default y
    116     depends on CONFIG_INSMOD || CONFIG_LSMOD
     127    depends on INSMOD || LSMOD
    117128    help
    118129      Support checking for tainted modules.  These are usually binary
     
    121132      This option is required to support GPLONLY modules.
    122133
    123 config CONFIG_FEATURE_2_4_MODULES
     134config FEATURE_2_4_MODULES
    124135    # Simulate indentation
    125136    bool "Support version 2.2.x to 2.4.x Linux kernels"
    126137    default y
    127     depends on CONFIG_INSMOD || CONFIG_RMMOD
     138    depends on INSMOD || RMMOD || MODPROBE
    128139    help
    129140      Support module loading for 2.2.x and 2.4.x Linux kernels.
    130141
    131 config CONFIG_FEATURE_2_6_MODULES
     142config FEATURE_2_6_MODULES
    132143    # Simulate indentation
    133144    bool "Support version 2.6.x Linux kernels"
    134145    default y
    135     depends on CONFIG_INSMOD || CONFIG_RMMOD || CONFIG_MODPROBE
     146    depends on INSMOD || RMMOD || MODPROBE
    136147    help
    137148      Support module loading for newer 2.6.x Linux kernels.
    138149
    139150
    140 config CONFIG_FEATURE_QUERY_MODULE_INTERFACE
     151config FEATURE_QUERY_MODULE_INTERFACE
    141152    bool
    142153    default y
    143     depends on CONFIG_FEATURE_2_4_MODULES && !CONFIG_FEATURE_2_6_MODULES
     154    depends on FEATURE_2_4_MODULES && !FEATURE_2_6_MODULES
    144155
    145156
  • branches/2.2.5/mindi-busybox/modutils/insmod.c

    r821 r1765  
    4141 *   written by Paul Mackerras, Copyright 1996, 1997 Linux International.
    4242 *   I've only tested the code on mpc8xx platforms in big-endian mode.
    43  *   Did some cleanup and added CONFIG_USE_xxx_ENTRIES...
     43 *   Did some cleanup and added USE_xxx_ENTRIES...
    4444 *
    4545 * Quinn Jensen <jensenq@lineo.com> added MIPS support 23-Feb-2001.
     
    5959 */
    6060
    61 #include "busybox.h"
    62 #include <stdlib.h>
    63 #include <stdio.h>
    64 #include <stddef.h>
    65 #include <errno.h>
    66 #include <unistd.h>
    67 #include <dirent.h>
    68 #include <ctype.h>
    69 #include <assert.h>
    70 #include <string.h>
    71 #include <getopt.h>
    72 #include <fcntl.h>
     61#include "libbb.h"
     62#include <libgen.h>
    7363#include <sys/utsname.h>
    7464
    75 #if !defined(CONFIG_FEATURE_2_4_MODULES) && \
    76     !defined(CONFIG_FEATURE_2_6_MODULES)
    77 #define CONFIG_FEATURE_2_4_MODULES
    78 #endif
    79 
    80 #if !defined(CONFIG_FEATURE_2_4_MODULES)
     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#if !ENABLE_FEATURE_2_4_MODULES
    8171#define insmod_ng_main insmod_main
    8272#endif
    8373
    84 #if defined(CONFIG_FEATURE_2_6_MODULES)
     74#if ENABLE_FEATURE_2_6_MODULES
    8575extern int insmod_ng_main( int argc, char **argv);
    8676#endif
    8777
    8878
    89 #if defined(CONFIG_FEATURE_2_4_MODULES)
    90 
    91 
    92 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
     79#if ENABLE_FEATURE_2_4_MODULES
     80
     81
     82#if ENABLE_FEATURE_INSMOD_LOADINKMEM
    9383#define LOADBITS 0
    9484#else
     
    111101#define Elf32_RelM  Elf32_Rel
    112102#define ELFCLASSM   ELFCLASS32
    113 #define CONFIG_USE_PLT_ENTRIES
    114 #define CONFIG_PLT_ENTRY_SIZE 8
    115 #define CONFIG_USE_GOT_ENTRIES
    116 #define CONFIG_GOT_ENTRY_SIZE 8
    117 #define CONFIG_USE_SINGLE
     103#define USE_PLT_ENTRIES
     104#define PLT_ENTRY_SIZE 8
     105#define USE_GOT_ENTRIES
     106#define GOT_ENTRY_SIZE 8
     107#define USE_SINGLE
    118108#endif
    119109
     
    145135#define Elf32_RelM  Elf32_Rela
    146136#define ELFCLASSM   ELFCLASS32
    147 #define CONFIG_USE_SINGLE
     137#define USE_SINGLE
    148138#define SYMBOL_PREFIX   "_"
    149139#endif
     
    172162#define Elf32_RelM  Elf32_Rel
    173163#define ELFCLASSM   ELFCLASS32
    174 #define CONFIG_USE_GOT_ENTRIES
    175 #define CONFIG_GOT_ENTRY_SIZE 4
    176 #define CONFIG_USE_SINGLE
     164#define USE_GOT_ENTRIES
     165#define GOT_ENTRY_SIZE 4
     166#define USE_SINGLE
    177167#endif
    178168
     
    191181#define Elf32_RelM  Elf32_Rela
    192182#define ELFCLASSM   ELFCLASS32
    193 #define CONFIG_USE_GOT_ENTRIES
    194 #define CONFIG_GOT_ENTRY_SIZE 4
    195 #define CONFIG_USE_SINGLE
     183#define USE_GOT_ENTRIES
     184#define GOT_ENTRY_SIZE 4
     185#define USE_SINGLE
    196186#endif
    197187
    198188/* Microblaze */
    199189#if defined(__microblaze__)
    200 #define CONFIG_USE_SINGLE
     190#define USE_SINGLE
    201191#define MATCH_MACHINE(x) (x == EM_XILINX_MICROBLAZE)
    202192#define SHT_RELM    SHT_RELA
     
    241231#define Elf32_RelM  Elf32_Rela
    242232#define ELFCLASSM   ELFCLASS32
    243 #define CONFIG_USE_PLT_ENTRIES
    244 #define CONFIG_PLT_ENTRY_SIZE 16
    245 #define CONFIG_USE_PLT_LIST
    246 #define CONFIG_LIST_ARCHTYPE ElfW(Addr)
    247 #define CONFIG_USE_LIST
     233#define USE_PLT_ENTRIES
     234#define PLT_ENTRY_SIZE 16
     235#define USE_PLT_LIST
     236#define LIST_ARCHTYPE ElfW(Addr)
     237#define USE_LIST
    248238#define ARCHDATAM       "__ftr_fixup"
    249239#endif
     
    255245#define Elf32_RelM  Elf32_Rela
    256246#define ELFCLASSM   ELFCLASS32
    257 #define CONFIG_USE_PLT_ENTRIES
    258 #define CONFIG_PLT_ENTRY_SIZE 8
    259 #define CONFIG_USE_GOT_ENTRIES
    260 #define CONFIG_GOT_ENTRY_SIZE 8
    261 #define CONFIG_USE_SINGLE
     247#define USE_PLT_ENTRIES
     248#define PLT_ENTRY_SIZE 8
     249#define USE_GOT_ENTRIES
     250#define GOT_ENTRY_SIZE 8
     251#define USE_SINGLE
    262252#endif
    263253
     
    268258#define Elf32_RelM  Elf32_Rela
    269259#define ELFCLASSM   ELFCLASS32
    270 #define CONFIG_USE_GOT_ENTRIES
    271 #define CONFIG_GOT_ENTRY_SIZE 4
    272 #define CONFIG_USE_SINGLE
     260#define USE_GOT_ENTRIES
     261#define GOT_ENTRY_SIZE 4
     262#define USE_SINGLE
    273263/* the SH changes have only been tested in =little endian= mode */
    274264/* I'm not sure about big endian, so let's warn: */
     
    291281
    292282/* v850e */
    293 #if defined (__v850e__)
     283#if defined(__v850e__)
    294284#define MATCH_MACHINE(x) ((x) == EM_V850 || (x) == EM_CYGNUS_V850)
    295285#define SHT_RELM    SHT_RELA
    296286#define Elf32_RelM  Elf32_Rela
    297287#define ELFCLASSM   ELFCLASS32
    298 #define CONFIG_USE_PLT_ENTRIES
    299 #define CONFIG_PLT_ENTRY_SIZE 8
    300 #define CONFIG_USE_SINGLE
     288#define USE_PLT_ENTRIES
     289#define PLT_ENTRY_SIZE 8
     290#define USE_SINGLE
    301291#ifndef EM_CYGNUS_V850  /* grumble */
    302292#define EM_CYGNUS_V850  0x9080
     
    309299#define MATCH_MACHINE(x) (x == EM_X86_64)
    310300#define SHT_RELM    SHT_RELA
    311 #define CONFIG_USE_GOT_ENTRIES
    312 #define CONFIG_GOT_ENTRY_SIZE 8
    313 #define CONFIG_USE_SINGLE
     301#define USE_GOT_ENTRIES
     302#define GOT_ENTRY_SIZE 8
     303#define USE_SINGLE
    314304#define Elf64_RelM  Elf64_Rela
    315305#define ELFCLASSM   ELFCLASS64
     
    348338
    349339#ifndef MODUTILS_MODULE_H
    350 /* Why? static const int MODUTILS_MODULE_H = 1;*/
    351 
    352 #ident "$Id: insmod.c,v 1.126 2004/12/26 09:13:32 vapier Exp $"
    353340
    354341/*======================================================================*/
     
    381368
    382369/* Note: new_module_symbol does not use tgt_long intentionally */
    383 struct new_module_symbol
    384 {
     370struct new_module_symbol {
    385371    unsigned long value;
    386372    unsigned long name;
     
    389375struct new_module_persist;
    390376
    391 struct new_module_ref
    392 {
     377struct new_module_ref {
    393378    unsigned tgt_long dep;      /* kernel addresses */
    394379    unsigned tgt_long ref;
     
    396381};
    397382
    398 struct new_module
    399 {
     383struct new_module {
    400384    unsigned tgt_long size_of_struct;   /* == sizeof(module) */
    401385    unsigned tgt_long next;
     
    439423
    440424
    441 struct new_module_info
    442 {
     425struct new_module_info {
    443426    unsigned long addr;
    444427    unsigned long size;
     
    511494
    512495#ifndef MODUTILS_OBJ_H
    513 /* Why? static const int MODUTILS_OBJ_H = 1; */
    514 
    515 #ident "$Id: insmod.c,v 1.126 2004/12/26 09:13:32 vapier Exp $"
    516496
    517497/* The relocatable object is manipulated using elfin types.  */
    518498
    519 #include <stdio.h>
    520499#include <elf.h>
    521500#include <endian.h>
     
    576555#define HASH_BUCKETS  521
    577556
    578 struct obj_file
    579 {
     557struct obj_file {
    580558    ElfW(Ehdr) header;
    581559    ElfW(Addr) baseaddr;
     
    592570};
    593571
    594 enum obj_reloc
    595 {
     572enum obj_reloc {
    596573    obj_reloc_ok,
    597574    obj_reloc_overflow,
     
    600577};
    601578
    602 struct obj_string_patch
    603 {
     579struct obj_string_patch {
    604580    struct obj_string_patch *next;
    605581    int reloc_secidx;
     
    608584};
    609585
    610 struct obj_symbol_patch
    611 {
     586struct obj_symbol_patch {
    612587    struct obj_symbol_patch *next;
    613588    int reloc_secidx;
     
    623598static unsigned long obj_elf_hash_n(const char *, unsigned long len);
    624599
    625 static struct obj_symbol *obj_find_symbol (struct obj_file *f,
     600static struct obj_symbol *obj_find_symbol(struct obj_file *f,
    626601                     const char *name);
    627602
     
    629604                  struct obj_symbol *sym);
    630605
    631 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     606#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    632607static void obj_set_symbol_compare(struct obj_file *f,
    633608                int (*cmp)(const char *, const char *),
     
    635610#endif
    636611
    637 static struct obj_section *obj_find_section (struct obj_file *f,
     612static struct obj_section *obj_find_section(struct obj_file *f,
    638613                       const char *name);
    639614
    640 static void obj_insert_section_load_order (struct obj_file *f,
     615static void obj_insert_section_load_order(struct obj_file *f,
    641616                    struct obj_section *sec);
    642617
    643 static struct obj_section *obj_create_alloced_section (struct obj_file *f,
     618static struct obj_section *obj_create_alloced_section(struct obj_file *f,
    644619                        const char *name,
    645620                        unsigned long align,
    646621                        unsigned long size);
    647622
    648 static struct obj_section *obj_create_alloced_section_first (struct obj_file *f,
     623static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
    649624                              const char *name,
    650625                              unsigned long align,
    651626                              unsigned long size);
    652627
    653 static void *obj_extend_section (struct obj_section *sec, unsigned long more);
     628static void *obj_extend_section(struct obj_section *sec, unsigned long more);
    654629
    655630static int obj_string_patch(struct obj_file *f, int secidx, ElfW(Addr) offset,
     
    663638static void obj_allocate_commons(struct obj_file *f);
    664639
    665 static unsigned long obj_load_size (struct obj_file *f);
    666 
    667 static int obj_relocate (struct obj_file *f, ElfW(Addr) base);
     640static unsigned long obj_load_size(struct obj_file *f);
     641
     642static int obj_relocate(struct obj_file *f, ElfW(Addr) base);
    668643
    669644static struct obj_file *obj_load(FILE *f, int loadprogbits);
    670645
    671 static int obj_create_image (struct obj_file *f, char *image);
     646static int obj_create_image(struct obj_file *f, char *image);
    672647
    673648/* Architecture specific manipulation routines.  */
    674649
    675 static struct obj_file *arch_new_file (void);
    676 
    677 static struct obj_section *arch_new_section (void);
    678 
    679 static struct obj_symbol *arch_new_symbol (void);
    680 
    681 static enum obj_reloc arch_apply_relocation (struct obj_file *f,
     650static struct obj_file *arch_new_file(void);
     651
     652static struct obj_section *arch_new_section(void);
     653
     654static struct obj_symbol *arch_new_symbol(void);
     655
     656static enum obj_reloc arch_apply_relocation(struct obj_file *f,
    682657                      struct obj_section *targsec,
    683658                      struct obj_section *symsec,
     
    685660                      ElfW(RelM) *rel, ElfW(Addr) value);
    686661
    687 static void arch_create_got (struct obj_file *f);
     662static void arch_create_got(struct obj_file *f);
    688663#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
    689664static int obj_gpl_license(struct obj_file *f, const char **license);
    690 #endif /* ENABLE_FEATURE_CHECK_TAINTED_MODULE */
     665#endif /* FEATURE_CHECK_TAINTED_MODULE */
    691666#endif /* obj.h */
    692667//----------------------------------------------------------------------------
     
    704679
    705680#define _PATH_MODULES   "/lib/modules"
    706 enum { STRVERSIONLEN = 32 };
     681enum { STRVERSIONLEN = 64 };
    707682
    708683/*======================================================================*/
    709684
    710 static int flag_force_load = 0;
    711 static int flag_autoclean = 0;
    712 static int flag_verbose = 0;
    713 static int flag_quiet = 0;
    714 static int flag_export = 1;
    715 
     685#define OPTION_STR "sLo:fkvqx" USE_FEATURE_INSMOD_LOAD_MAP("m")
     686enum {
     687    OPT_s = 0x1, // -s /* log to syslog */
     688        /* Not supported but kernel needs this for request_module(),
     689           as this calls: modprobe -k -s -- <module>
     690           so silently ignore this flag */
     691    OPT_L = 0x2, // -L /* Stub warning */
     692        /* Compatibility with modprobe.
     693           In theory, this does locking, but we don't do
     694           that.  So be careful and plan your life around not
     695           loading the same module 50 times concurrently. */
     696    OPT_o = 0x4, // -o /* name the output module */
     697    OPT_f = 0x8, // -f /* force loading */
     698    OPT_k = 0x10, // -k /* module loaded by kerneld, auto-cleanable */
     699    OPT_v = 0x20, // -v /* verbose output */
     700    OPT_q = 0x40, // -q /* silent */
     701    OPT_x = 0x80, // -x /* do not export externs */
     702    OPT_m = 0x100, // -m /* print module load map */
     703};
     704#define flag_force_load (option_mask32 & OPT_f)
     705#define flag_autoclean (option_mask32 & OPT_k)
     706#define flag_verbose (option_mask32 & OPT_v)
     707#define flag_quiet (option_mask32 & OPT_q)
     708#define flag_noexport (option_mask32 & OPT_x)
     709#if ENABLE_FEATURE_INSMOD_LOAD_MAP
     710#define flag_print_load_map (option_mask32 & OPT_m)
     711#else
     712#define flag_print_load_map 0
     713#endif
    716714
    717715/*======================================================================*/
    718716
    719 #if defined(CONFIG_USE_LIST)
     717#if defined(USE_LIST)
    720718
    721719struct arch_list_entry
    722720{
    723721    struct arch_list_entry *next;
    724     CONFIG_LIST_ARCHTYPE addend;
     722    LIST_ARCHTYPE addend;
    725723    int offset;
    726724    int inited : 1;
     
    729727#endif
    730728
    731 #if defined(CONFIG_USE_SINGLE)
     729#if defined(USE_SINGLE)
    732730
    733731struct arch_single_entry
     
    751749struct arch_file {
    752750    struct obj_file root;
    753 #if defined(CONFIG_USE_PLT_ENTRIES)
     751#if defined(USE_PLT_ENTRIES)
    754752    struct obj_section *plt;
    755753#endif
    756 #if defined(CONFIG_USE_GOT_ENTRIES)
     754#if defined(USE_GOT_ENTRIES)
    757755    struct obj_section *got;
    758756#endif
     
    764762struct arch_symbol {
    765763    struct obj_symbol root;
    766 #if defined(CONFIG_USE_PLT_ENTRIES)
    767 #if defined(CONFIG_USE_PLT_LIST)
     764#if defined(USE_PLT_ENTRIES)
     765#if defined(USE_PLT_LIST)
    768766    struct arch_list_entry *pltent;
    769767#else
     
    771769#endif
    772770#endif
    773 #if defined(CONFIG_USE_GOT_ENTRIES)
     771#if defined(USE_GOT_ENTRIES)
    774772    struct arch_single_entry gotent;
    775773#endif
     
    797795
    798796
    799 
    800797/*======================================================================*/
    801798
    802799
    803800static int check_module_name_match(const char *filename, struct stat *statbuf,
    804                            void *userdata)
     801                void *userdata, int depth)
    805802{
    806803    char *fullname = (char *) userdata;
    807804
    808805    if (fullname[0] == '\0')
    809         return (FALSE);
     806        return FALSE;
    810807    else {
    811         char *tmp, *tmp1 = bb_xstrdup(filename);
     808        char *tmp, *tmp1 = xstrdup(filename);
    812809        tmp = bb_get_last_path_component(tmp1);
    813810        if (strcmp(tmp, fullname) == 0) {
    814811            free(tmp1);
    815812            /* Stop searching if we find a match */
    816             m_filename = bb_xstrdup(filename);
    817             return (FALSE);
     813            m_filename = xstrdup(filename);
     814            return FALSE;
    818815        }
    819816        free(tmp1);
    820817    }
    821     return (TRUE);
     818    return TRUE;
    822819}
    823820
     
    852849static enum obj_reloc
    853850arch_apply_relocation(struct obj_file *f,
    854                       struct obj_section *targsec,
    855                       struct obj_section *symsec,
    856                       struct obj_symbol *sym,
    857                       ElfW(RelM) *rel, ElfW(Addr) v)
     851                struct obj_section *targsec,
     852                struct obj_section *symsec,
     853                struct obj_symbol *sym,
     854                ElfW(RelM) *rel, ElfW(Addr) v)
    858855{
    859856    struct arch_file *ifile = (struct arch_file *) f;
     
    861858    ElfW(Addr) *loc = (ElfW(Addr) *) (targsec->contents + rel->r_offset);
    862859    ElfW(Addr) dot = targsec->header.sh_addr + rel->r_offset;
    863 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
     860#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
    864861    struct arch_symbol *isym = (struct arch_symbol *) sym;
    865862#endif
    866863#if defined(__arm__) || defined(__i386__) || defined(__mc68000__) || defined(__sh__) || defined(__s390__)
    867 #if defined(CONFIG_USE_GOT_ENTRIES)
     864#if defined(USE_GOT_ENTRIES)
    868865    ElfW(Addr) got = ifile->got ? ifile->got->header.sh_addr : 0;
    869866#endif
    870867#endif
    871 #if defined(CONFIG_USE_PLT_ENTRIES)
     868#if defined(USE_PLT_ENTRIES)
    872869    ElfW(Addr) plt = ifile->plt ? ifile->plt->header.sh_addr : 0;
    873870    unsigned long *ip;
    874 # if defined(CONFIG_USE_PLT_LIST)
     871# if defined(USE_PLT_LIST)
    875872    struct arch_list_entry *pe;
    876873# else
     
    898895             * but is full 32 bits relative */
    899896
    900             assert(got != 0);
    901897            *loc += got - dot;
    902898            break;
     
    907903
    908904        case R_ARM_GOTOFF: /* address relative to the got */
    909             assert(got != 0);
    910905            *loc += v - got;
    911906            break;
     
    977972
    978973        case R_386_GOTPC:
    979             assert(got != 0);
    980974            *loc += got - dot;
    981975            break;
     
    985979
    986980        case R_386_GOTOFF:
    987             assert(got != 0);
    988981            *loc += v - got;
    989982            break;
    990983
    991 #elif defined (__microblaze__)
     984#elif defined(__microblaze__)
    992985        case R_MICROBLAZE_NONE:
    993986        case R_MICROBLAZE_64_NONE:
     
    1000993             * v is the target symbol address.
    1001994             * So we need to extract the offset in the code,
    1002              * adding v, then subtrating the current address 
     995             * adding v, then subtrating the current address
    1003996             * of this instruction.
    1004997             * Ex: "IMM 0xFFFE  bralid 0x0000" = "bralid 0xFFFE0000"
     
    10091002                        (loc[1] & 0xFFFF);
    10101003
    1011             /* Adjust relative offset. -4 adjustment required 
     1004            /* Adjust relative offset. -4 adjustment required
    10121005             * because dot points to the IMM insn, but branch
    10131006             * is computed relative to the branch instruction itself.
     
    11071100# ifdef R_68K_GOTOFF
    11081101        case R_68K_GOTOFF:
    1109             assert(got != 0);
    11101102            *loc += v - got;
    11111103            break;
     
    11381130                   of the carry we need to add.  Save the information, and let LO16
    11391131                   do the actual relocation.  */
    1140                 n = (struct mips_hi16 *) xmalloc(sizeof *n);
     1132                n = xmalloc(sizeof *n);
    11411133                n->addr = loc;
    11421134                n->value = v;
     
    11611153                        struct mips_hi16 *next;
    11621154                        unsigned long insn;
    1163 
    1164                         /* The value for the HI16 had best be the same. */
    1165                         assert(v == l->value);
    11661155
    11671156                        /* Do the HI16 relocation.  Note that we actually don't
     
    14131402        case R_390_PLT16DBL:
    14141403            /* find the plt entry and initialize it.  */
    1415             assert(isym != NULL);
    14161404            pe = (struct arch_single_entry *) &isym->pltent;
    1417             assert(pe->allocated);
    14181405            if (pe->inited == 0) {
    14191406                ip = (unsigned long *)(ifile->plt->contents + pe->offset);
     
    14451432
    14461433        case R_390_GOTPC:
    1447             assert(got != 0);
    14481434            *(unsigned long *) loc += got - dot;
    14491435            break;
     
    14521438        case R_390_GOT16:
    14531439        case R_390_GOT32:
    1454             assert(isym != NULL);
    1455             assert(got != 0);
    14561440            if (!isym->gotent.inited)
    14571441            {
     
    14711455# endif
    14721456        case R_390_GOTOFF32:
    1473             assert(got != 0);
    14741457            *loc += v - got;
    14751458            break;
     
    15021485
    15031486        case R_SH_GOTPC:
    1504             assert(got != 0);
    15051487            *loc = got - dot + rel->r_addend;
    15061488            break;
     
    15101492
    15111493        case R_SH_GOTOFF:
    1512             assert(got != 0);
    15131494            *loc = v - got;
    15141495            break;
     
    15591540# endif /* __SH5__ */
    15601541
    1561 #elif defined (__v850e__)
     1542#elif defined(__v850e__)
    15621543
    15631544        case R_V850_NONE:
     
    16321613            goto bb_use_got;
    16331614# if 0
    1634             assert(isym != NULL);
    16351615            if (!isym->gotent.reloc_done)
    16361616            {
     
    16551635            break;
    16561636
    1657 #if defined(CONFIG_USE_PLT_ENTRIES)
     1637#if defined(USE_PLT_ENTRIES)
    16581638
    16591639bb_use_plt:
    16601640
    16611641            /* find the plt entry and initialize it if necessary */
    1662             assert(isym != NULL);
    1663 
    1664 #if defined(CONFIG_USE_PLT_LIST)
     1642
     1643#if defined(USE_PLT_LIST)
    16651644            for (pe = isym->pltent; pe != NULL && pe->addend != rel->r_addend;)
    16661645                pe = pe->next;
    1667             assert(pe != NULL);
    16681646#else
    16691647            pe = &isym->pltent;
     
    16851663                ip[3] = 0x4e800420;               /* bctr */
    16861664#endif
    1687 #if defined (__v850e__)
     1665#if defined(__v850e__)
    16881666                /* We have to trash a register, so we assume that any control
    16891667                   transfer more than 21-bits away must be a function call
     
    16981676            v -= dot;
    16991677            /* if the target is too far away.... */
    1700 #if defined (__arm__) || defined (__powerpc__)
     1678#if defined(__arm__) || defined(__powerpc__)
    17011679            if ((int)v < -0x02000000 || (int)v >= 0x02000000)
    1702 #elif defined (__v850e__)
     1680#elif defined(__v850e__)
    17031681                if ((ElfW(Sword))v > 0x1fffff || (ElfW(Sword))v < (ElfW(Sword))-0x200000)
    17041682#endif
     
    17061684                    v = plt + pe->offset - dot;
    17071685
    1708 #if defined (__v850e__)
     1686#if defined(__v850e__)
    17091687            if (v & 1)
    17101688#else
     
    17231701            *loc = (*loc & ~0x03fffffc) | (v & 0x03fffffc);
    17241702#endif
    1725 #if defined (__v850e__)
     1703#if defined(__v850e__)
    17261704            /* We write two shorts instead of a long because even 32-bit insns
    17271705               only need half-word alignment, but the 32-bit data write needs
     
    17341712#endif
    17351713            break;
    1736 #endif /* CONFIG_USE_PLT_ENTRIES */
    1737 
    1738 #if defined(CONFIG_USE_GOT_ENTRIES)
     1714#endif /* USE_PLT_ENTRIES */
     1715
     1716#if defined(USE_GOT_ENTRIES)
    17391717bb_use_got:
    17401718
    1741             assert(isym != NULL);
    17421719            /* needs an entry in the .got: set it, once */
    17431720            if (!isym->gotent.inited) {
     
    17531730            break;
    17541731
    1755 #endif /* CONFIG_USE_GOT_ENTRIES */
     1732#endif /* USE_GOT_ENTRIES */
    17561733    }
    17571734
     
    17601737
    17611738
    1762 #if defined(CONFIG_USE_LIST)
     1739#if defined(USE_LIST)
    17631740
    17641741static int arch_list_add(ElfW(RelM) *rel, struct arch_list_entry **list,
     
    17871764#endif
    17881765
    1789 #if defined(CONFIG_USE_SINGLE)
     1766#if defined(USE_SINGLE)
    17901767
    17911768static int arch_single_init(ElfW(RelM) *rel, struct arch_single_entry *single,
     
    18031780#endif
    18041781
    1805 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
    1806 
    1807 static struct obj_section *arch_xsect_init(struct obj_file *f, char *name,
     1782#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
     1783
     1784static struct obj_section *arch_xsect_init(struct obj_file *f, const char *name,
    18081785                       int offset, int size)
    18091786{
     
    18191796        myrelsec = obj_create_alloced_section(f, name,
    18201797                size, offset);
    1821         assert(myrelsec);
    18221798    }
    18231799
     
    18291805static void arch_create_got(struct obj_file *f)
    18301806{
    1831 #if defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES)
     1807#if defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES)
    18321808    struct arch_file *ifile = (struct arch_file *) f;
    18331809    int i;
    1834 #if defined(CONFIG_USE_GOT_ENTRIES)
     1810#if defined(USE_GOT_ENTRIES)
    18351811    int got_offset = 0, got_needed = 0, got_allocate;
    18361812#endif
    1837 #if defined(CONFIG_USE_PLT_ENTRIES)
     1813#if defined(USE_PLT_ENTRIES)
    18381814    int plt_offset = 0, plt_needed = 0, plt_allocate;
    18391815#endif
     
    18601836            extsym = &symtab[ELF_R_SYM(rel->r_info)];
    18611837
    1862 #if defined(CONFIG_USE_GOT_ENTRIES)
     1838#if defined(USE_GOT_ENTRIES)
    18631839            got_allocate = 0;
    18641840#endif
    1865 #if defined(CONFIG_USE_PLT_ENTRIES)
     1841#if defined(USE_PLT_ENTRIES)
    18661842            plt_allocate = 0;
    18671843#endif
     
    18691845            switch (ELF_R_TYPE(rel->r_info)) {
    18701846#if defined(__arm__)
    1871                 case R_ARM_PC24:
    1872                 case R_ARM_PLT32:
    1873                     plt_allocate = 1;
    1874                     break;
    1875 
    1876                 case R_ARM_GOTOFF:
    1877                 case R_ARM_GOTPC:
    1878                     got_needed = 1;
    1879                     continue;
    1880 
    1881                 case R_ARM_GOT32:
    1882                     got_allocate = 1;
    1883                     break;
     1847            case R_ARM_PC24:
     1848            case R_ARM_PLT32:
     1849                plt_allocate = 1;
     1850                break;
     1851
     1852            case R_ARM_GOTOFF:
     1853            case R_ARM_GOTPC:
     1854                got_needed = 1;
     1855                continue;
     1856
     1857            case R_ARM_GOT32:
     1858                got_allocate = 1;
     1859                break;
    18841860
    18851861#elif defined(__i386__)
    1886                 case R_386_GOTPC:
    1887                 case R_386_GOTOFF:
    1888                     got_needed = 1;
    1889                     continue;
    1890 
    1891                 case R_386_GOT32:
    1892                     got_allocate = 1;
    1893                     break;
     1862            case R_386_GOTPC:
     1863            case R_386_GOTOFF:
     1864                got_needed = 1;
     1865                continue;
     1866
     1867            case R_386_GOT32:
     1868                got_allocate = 1;
     1869                break;
    18941870
    18951871#elif defined(__powerpc__)
    1896                 case R_PPC_REL24:
    1897                     plt_allocate = 1;
    1898                     break;
     1872            case R_PPC_REL24:
     1873                plt_allocate = 1;
     1874                break;
    18991875
    19001876#elif defined(__mc68000__)
    1901                 case R_68K_GOT32:
    1902                     got_allocate = 1;
    1903                     break;
     1877            case R_68K_GOT32:
     1878                got_allocate = 1;
     1879                break;
    19041880
    19051881#ifdef R_68K_GOTOFF
    1906                 case R_68K_GOTOFF:
    1907                     got_needed = 1;
    1908                     continue;
     1882            case R_68K_GOTOFF:
     1883                got_needed = 1;
     1884                continue;
    19091885#endif
    19101886
    19111887#elif defined(__sh__)
    1912                 case R_SH_GOT32:
    1913                     got_allocate = 1;
    1914                     break;
    1915 
    1916                 case R_SH_GOTPC:
    1917                 case R_SH_GOTOFF:
    1918                     got_needed = 1;
    1919                     continue;
    1920 
    1921 #elif defined (__v850e__)
    1922                 case R_V850_22_PCREL:
    1923                     plt_needed = 1;
    1924                     break;
    1925 
    1926 #endif
    1927                 default:
    1928                     continue;
     1888            case R_SH_GOT32:
     1889                got_allocate = 1;
     1890                break;
     1891
     1892            case R_SH_GOTPC:
     1893            case R_SH_GOTOFF:
     1894                got_needed = 1;
     1895                continue;
     1896
     1897#elif defined(__v850e__)
     1898            case R_V850_22_PCREL:
     1899                plt_needed = 1;
     1900                break;
     1901
     1902#endif
     1903            default:
     1904                continue;
    19291905            }
    19301906
     
    19351911            }
    19361912            intsym = (struct arch_symbol *) obj_find_symbol(f, name);
    1937 #if defined(CONFIG_USE_GOT_ENTRIES)
     1913#if defined(USE_GOT_ENTRIES)
    19381914            if (got_allocate) {
    19391915                got_offset += arch_single_init(
    19401916                        rel, &intsym->gotent,
    1941                         got_offset, CONFIG_GOT_ENTRY_SIZE);
     1917                        got_offset, GOT_ENTRY_SIZE);
    19421918
    19431919                got_needed = 1;
    19441920            }
    19451921#endif
    1946 #if defined(CONFIG_USE_PLT_ENTRIES)
     1922#if defined(USE_PLT_ENTRIES)
    19471923            if (plt_allocate) {
    1948 #if defined(CONFIG_USE_PLT_LIST)
     1924#if defined(USE_PLT_LIST)
    19491925                plt_offset += arch_list_add(
    19501926                        rel, &intsym->pltent,
    1951                         plt_offset, CONFIG_PLT_ENTRY_SIZE);
     1927                        plt_offset, PLT_ENTRY_SIZE);
    19521928#else
    19531929                plt_offset += arch_single_init(
    19541930                        rel, &intsym->pltent,
    1955                         plt_offset, CONFIG_PLT_ENTRY_SIZE);
     1931                        plt_offset, PLT_ENTRY_SIZE);
    19561932#endif
    19571933                plt_needed = 1;
     
    19611937    }
    19621938
    1963 #if defined(CONFIG_USE_GOT_ENTRIES)
     1939#if defined(USE_GOT_ENTRIES)
    19641940    if (got_needed) {
    19651941        ifile->got = arch_xsect_init(f, ".got", got_offset,
    1966                 CONFIG_GOT_ENTRY_SIZE);
    1967     }
    1968 #endif
    1969 
    1970 #if defined(CONFIG_USE_PLT_ENTRIES)
     1942                GOT_ENTRY_SIZE);
     1943    }
     1944#endif
     1945
     1946#if defined(USE_PLT_ENTRIES)
    19711947    if (plt_needed) {
    19721948        ifile->plt = arch_xsect_init(f, ".plt", plt_offset,
    1973                 CONFIG_PLT_ENTRY_SIZE);
    1974     }
    1975 #endif
    1976 
    1977 #endif /* defined(CONFIG_USE_GOT_ENTRIES) || defined(CONFIG_USE_PLT_ENTRIES) */
     1949                PLT_ENTRY_SIZE);
     1950    }
     1951#endif
     1952
     1953#endif /* defined(USE_GOT_ENTRIES) || defined(USE_PLT_ENTRIES) */
    19781954}
    19791955
     
    19811957
    19821958/* Standard ELF hash function.  */
    1983 static inline unsigned long obj_elf_hash_n(const char *name, unsigned long n)
     1959static unsigned long obj_elf_hash_n(const char *name, unsigned long n)
    19841960{
    19851961    unsigned long h = 0;
     
    20041980}
    20051981
    2006 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     1982#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    20071983/* String comparison for non-co-versioned kernel and module.  */
    20081984
     
    20562032}
    20572033
    2058 #endif                          /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     2034#endif /* FEATURE_INSMOD_VERSION_CHECKING */
    20592035
    20602036static struct obj_symbol *
    20612037obj_add_symbol(struct obj_file *f, const char *name,
    2062                                   unsigned long symidx, int info,
    2063                                   int secidx, ElfW(Addr) value,
    2064                                   unsigned long size)
     2038                unsigned long symidx, int info,
     2039                int secidx, ElfW(Addr) value,
     2040                unsigned long size)
    20652041{
    20662042    struct obj_symbol *sym;
     
    21662142}
    21672143
    2168 static ElfW(Addr)
    2169     obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
     2144static ElfW(Addr) obj_symbol_final_value(struct obj_file * f, struct obj_symbol * sym)
    21702145{
    21712146    if (sym) {
     
    22262201
    22272202static struct obj_section *obj_create_alloced_section(struct obj_file *f,
    2228                                                const char *name,
    2229                                                unsigned long align,
    2230                                                unsigned long size)
     2203                const char *name,
     2204                unsigned long align,
     2205                unsigned long size)
    22312206{
    22322207    int newidx = f->header.e_shnum++;
     
    22522227
    22532228static struct obj_section *obj_create_alloced_section_first(struct obj_file *f,
    2254                                                      const char *name,
    2255                                                      unsigned long align,
    2256                                                      unsigned long size)
     2229                const char *name,
     2230                unsigned long align,
     2231                unsigned long size)
    22572232{
    22582233    int newidx = f->header.e_shnum++;
     
    23042279    size_t name_alloced_size = 0;
    23052280#endif
    2306 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
     2281#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
    23072282    int gpl;
    23082283
     
    23242299         */
    23252300        if (strncmp((char *)s->name, "GPLONLY_", 8) == 0) {
    2326 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
     2301#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
    23272302            if (gpl)
    23282303                s->name += 8;
     
    23382313           reference `linker names').  */
    23392314        size_t extra = sizeof SYMBOL_PREFIX;
    2340         size_t name_size = strlen (name) + extra;
     2315        size_t name_size = strlen(name) + extra;
    23412316        if (name_size > name_alloced_size) {
    23422317            name_alloced_size = name_size * 2;
    2343             name_buf = alloca (name_alloced_size);
     2318            name_buf = alloca(name_alloced_size);
    23442319        }
    2345         strcpy (name_buf, SYMBOL_PREFIX);
    2346         strcpy (name_buf + extra - 1, name);
     2320        strcpy(name_buf, SYMBOL_PREFIX);
     2321        strcpy(name_buf + extra - 1, name);
    23472322        name = name_buf;
    23482323#endif /* SYMBOL_PREFIX */
     
    23522327#ifdef SYMBOL_PREFIX
    23532328            /* Put NAME_BUF into more permanent storage.  */
    2354             name = xmalloc (name_size);
    2355             strcpy (name, name_buf);
     2329            name = xmalloc(name_size);
     2330            strcpy(name, name_buf);
    23562331#endif
    23572332            sym = obj_add_symbol(f, name, -1,
     
    23762351    /* Add module symbols first.  */
    23772352
    2378     for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m)
     2353    for (i = 0, m = ext_modules; i < n_ext_modules; ++i, ++m) {
    23792354        if (m->nsyms
    2380                 && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms,
    2381                     m->nsyms)) m->used = 1, ++nused;
     2355         && add_symbols_from(f, SHN_HIRESERVE + 2 + i, m->syms, m->nsyms)
     2356        ) {
     2357            m->used = 1;
     2358            ++nused;
     2359        }
     2360    }
    23822361
    23832362    n_ext_modules_used = nused;
     
    24482427
    24492428#ifdef SYMBOL_PREFIX
    2450         sym_name = alloca (strlen (key) + sizeof SYMBOL_PREFIX);
    2451         strcpy (sym_name, SYMBOL_PREFIX);
    2452         strcat (sym_name, key);
     2429        sym_name = alloca(strlen(key) + sizeof SYMBOL_PREFIX);
     2430        strcpy(sym_name, SYMBOL_PREFIX);
     2431        strcat(sym_name, key);
    24532432#else
    24542433        sym_name = key;
     
    24912470                        } else if (*q == '\\')
    24922471                            switch (*++q) {
    2493                                 case 'a':
    2494                                     *r = '\a';
    2495                                     break;
    2496                                 case 'b':
    2497                                     *r = '\b';
    2498                                     break;
    2499                                 case 'e':
    2500                                     *r = '\033';
    2501                                     break;
    2502                                 case 'f':
    2503                                     *r = '\f';
    2504                                     break;
    2505                                 case 'n':
    2506                                     *r = '\n';
    2507                                     break;
    2508                                 case 'r':
    2509                                     *r = '\r';
    2510                                     break;
    2511                                 case 't':
    2512                                     *r = '\t';
    2513                                     break;
    2514 
    2515                                 case '0':
    2516                                 case '1':
    2517                                 case '2':
    2518                                 case '3':
    2519                                 case '4':
    2520                                 case '5':
    2521                                 case '6':
    2522                                 case '7':
    2523                                     {
    2524                                         int c = *q - '0';
    2525                                         if (q[1] >= '0' && q[1] <= '7') {
     2472                            case 'a':
     2473                                *r = '\a';
     2474                                break;
     2475                            case 'b':
     2476                                *r = '\b';
     2477                                break;
     2478                            case 'e':
     2479                                *r = '\033';
     2480                                break;
     2481                            case 'f':
     2482                                *r = '\f';
     2483                                break;
     2484                            case 'n':
     2485                                *r = '\n';
     2486                                break;
     2487                            case 'r':
     2488                                *r = '\r';
     2489                                break;
     2490                            case 't':
     2491                                *r = '\t';
     2492                                break;
     2493
     2494                            case '0':
     2495                            case '1':
     2496                            case '2':
     2497                            case '3':
     2498                            case '4':
     2499                            case '5':
     2500                            case '6':
     2501                            case '7':
     2502                                {
     2503                                    int c = *q - '0';
     2504                                    if (q[1] >= '0' && q[1] <= '7') {
     2505                                        c = (c * 8) + *++q - '0';
     2506                                        if (q[1] >= '0' && q[1] <= '7')
    25262507                                            c = (c * 8) + *++q - '0';
    2527                                             if (q[1] >= '0' && q[1] <= '7')
    2528                                                 c = (c * 8) + *++q - '0';
    2529                                         }
    2530                                         *r = c;
    25312508                                    }
    2532                                     break;
    2533 
    2534                                 default:
    2535                                     *r = *q;
    2536                                     break;
     2509                                    *r = c;
     2510                                }
     2511                                break;
     2512
     2513                            default:
     2514                                *r = *q;
     2515                                break;
    25372516                            } else
    25382517                                *r = *q;
     
    25652544                        /* last string */
    25662545                        str = q;
    2567                         q = "";
     2546                        q = (char*)"";
    25682547                    }
    25692548                }
     
    25742553                    loc += tgt_sizeof_char_p;
    25752554                } else {
    2576                     /* Array of chars (in fact, matrix !) */
     2555                    /* Array of chars (in fact, matrix!) */
    25772556                    unsigned long charssize;    /* size of each member */
    25782557
     
    26002579                long v = strtoul(q, &q, 0);
    26012580                switch (*p) {
    2602                     case 'b':
    2603                         *loc++ = v;
    2604                         break;
    2605                     case 'h':
    2606                         *(short *) loc = v;
    2607                         loc += tgt_sizeof_short;
    2608                         break;
    2609                     case 'i':
    2610                         *(int *) loc = v;
    2611                         loc += tgt_sizeof_int;
    2612                         break;
    2613                     case 'l':
    2614                         *(long *) loc = v;
    2615                         loc += tgt_sizeof_long;
    2616                         break;
    2617 
    2618                     default:
    2619                         bb_error_msg("unknown parameter type '%c' for %s", *p, key);
    2620                         return 0;
     2581                case 'b':
     2582                    *loc++ = v;
     2583                    break;
     2584                case 'h':
     2585                    *(short *) loc = v;
     2586                    loc += tgt_sizeof_short;
     2587                    break;
     2588                case 'i':
     2589                    *(int *) loc = v;
     2590                    loc += tgt_sizeof_int;
     2591                    break;
     2592                case 'l':
     2593                    *(long *) loc = v;
     2594                    loc += tgt_sizeof_long;
     2595                    break;
     2596
     2597                default:
     2598                    bb_error_msg("unknown parameter type '%c' for %s", *p, key);
     2599                    return 0;
    26212600                }
    26222601            }
     
    26242603retry_end_of_value:
    26252604            switch (*q) {
    2626                 case '\0':
    2627                     goto end_of_arg;
    2628 
    2629                 case ' ':
    2630                 case '\t':
    2631                 case '\n':
    2632                 case '\r':
    2633                     ++q;
    2634                     goto retry_end_of_value;
    2635 
    2636                 case ',':
    2637                     if (++n > max) {
    2638                         bb_error_msg("too many values for %s (max %d)", key, max);
    2639                         return 0;
    2640                     }
    2641                     ++q;
    2642                     break;
    2643 
    2644                 default:
    2645                     bb_error_msg("invalid argument syntax for %s", key);
     2605            case '\0':
     2606                goto end_of_arg;
     2607
     2608            case ' ':
     2609            case '\t':
     2610            case '\n':
     2611            case '\r':
     2612                ++q;
     2613                goto retry_end_of_value;
     2614
     2615            case ',':
     2616                if (++n > max) {
     2617                    bb_error_msg("too many values for %s (max %d)", key, max);
    26462618                    return 0;
     2619                }
     2620                ++q;
     2621                break;
     2622
     2623            default:
     2624                bb_error_msg("invalid argument syntax for %s", key);
     2625                return 0;
    26472626            }
    26482627        }
     
    26602639}
    26612640
    2662 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     2641#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    26632642static int new_is_module_checksummed(struct obj_file *f)
    26642643{
    26652644    const char *p = get_modinfo_value(f, "using_checksums");
    26662645    if (p)
    2667         return atoi(p);
     2646        return xatoi(p);
    26682647    else
    26692648        return 0;
     
    26962675}
    26972676
    2698 #endif   /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     2677#endif   /* FEATURE_INSMOD_VERSION_CHECKING */
    26992678
    27002679
     
    27252704    /* Collect the modules' symbols.  */
    27262705
    2727     if (nmod){
     2706    if (nmod) {
    27282707        ext_modules = modules = xmalloc(nmod * sizeof(*modules));
    27292708        memset(modules, 0, nmod * sizeof(*modules));
     
    28262805}
    28272806
    2828 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
     2807#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
    28292808/* add an entry to the __ksymtab section, creating it if necessary */
    28302809static void new_add_ksymtab(struct obj_file *f, struct obj_symbol *sym)
     
    28492828        return;
    28502829    sec->header.sh_flags |= SHF_ALLOC;
    2851     sec->header.sh_addralign = tgt_sizeof_void_p;   /* Empty section might
    2852                                                        be byte-aligned */
     2830    /* Empty section might be byte-aligned */
     2831    sec->header.sh_addralign = tgt_sizeof_void_p;
    28532832    ofs = sec->header.sh_size;
    28542833    obj_symbol_patch(f, sec->idx, ofs, sym);
     
    28562835    obj_extend_section(sec, 2 * tgt_sizeof_char_p);
    28572836}
    2858 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
     2837#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
    28592838
    28602839static int new_create_module_ksymtab(struct obj_file *f)
     
    28872866    }
    28882867
    2889     if (flag_export && !obj_find_section(f, "__ksymtab")) {
     2868    if (!flag_noexport && !obj_find_section(f, "__ksymtab")) {
    28902869        size_t nsyms;
    28912870        int *loaded;
    28922871
    2893         sec =
    2894             obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p,
    2895                     0);
     2872        sec = obj_create_alloced_section(f, "__ksymtab", tgt_sizeof_void_p, 0);
    28962873
    28972874        /* We don't want to export symbols residing in sections that
     
    32823259            /* Do it! */
    32833260            switch (arch_apply_relocation
    3284                     (f, targsec, symsec, intsym, rel, value)) {
    3285                 case obj_reloc_ok:
    3286                     break;
    3287 
    3288                 case obj_reloc_overflow:
    3289                     errmsg = "Relocation overflow";
    3290                     goto bad_reloc;
    3291                 case obj_reloc_dangerous:
    3292                     errmsg = "Dangerous relocation";
    3293                     goto bad_reloc;
    3294                 case obj_reloc_unhandled:
    3295                     errmsg = "Unhandled relocation";
     3261                    (f, targsec, symsec, intsym, rel, value)
     3262            ) {
     3263            case obj_reloc_ok:
     3264                break;
     3265
     3266            case obj_reloc_overflow:
     3267                errmsg = "Relocation overflow";
     3268                goto bad_reloc;
     3269            case obj_reloc_dangerous:
     3270                errmsg = "Dangerous relocation";
     3271                goto bad_reloc;
     3272            case obj_reloc_unhandled:
     3273                errmsg = "Unhandled relocation";
    32963274bad_reloc:
    3297                     if (extsym) {
    3298                         bb_error_msg("%s of type %ld for %s", errmsg,
    3299                                 (long) ELF_R_TYPE(rel->r_info),
    3300                                 strtab + extsym->st_name);
    3301                     } else {
    3302                         bb_error_msg("%s of type %ld", errmsg,
    3303                                 (long) ELF_R_TYPE(rel->r_info));
    3304                     }
    3305                     ret = 0;
    3306                     break;
     3275                if (extsym) {
     3276                    bb_error_msg("%s of type %ld for %s", errmsg,
     3277                            (long) ELF_R_TYPE(rel->r_info),
     3278                            strtab + extsym->st_name);
     3279                } else {
     3280                    bb_error_msg("%s of type %ld", errmsg,
     3281                            (long) ELF_R_TYPE(rel->r_info));
     3282                }
     3283                ret = 0;
     3284                break;
    33073285            }
    33083286        }
     
    34323410        sec->idx = i;
    34333411
    3434         if(sec->header.sh_size) switch (sec->header.sh_type) {
     3412        if (sec->header.sh_size) {
     3413            switch (sec->header.sh_type) {
    34353414            case SHT_NULL:
    34363415            case SHT_NOTE:
     
    34833462                        (long) sec->header.sh_type);
    34843463                return NULL;
     3464            }
    34853465        }
    34863466    }
     
    35083488
    35093489        switch (sec->header.sh_type) {
    3510             case SHT_SYMTAB:
    3511                 {
    3512                     unsigned long nsym, j;
    3513                     char *strtab;
    3514                     ElfW(Sym) * sym;
    3515 
    3516                     if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
    3517                         bb_error_msg("symbol size mismatch: %lu != %lu",
    3518                                 (unsigned long) sec->header.sh_entsize,
    3519                                 (unsigned long) sizeof(ElfW(Sym)));
    3520                         return NULL;
    3521                     }
    3522 
    3523                     nsym = sec->header.sh_size / sizeof(ElfW(Sym));
    3524                     strtab = f->sections[sec->header.sh_link]->contents;
    3525                     sym = (ElfW(Sym) *) sec->contents;
    3526 
    3527                     /* Allocate space for a table of local symbols.  */
    3528                     j = f->local_symtab_size = sec->header.sh_info;
    3529                     f->local_symtab = xcalloc(j, sizeof(struct obj_symbol *));
    3530 
    3531                     /* Insert all symbols into the hash table.  */
    3532                     for (j = 1, ++sym; j < nsym; ++j, ++sym) {
    3533                         ElfW(Addr) val = sym->st_value;
    3534                         const char *name;
    3535                         if (sym->st_name)
    3536                             name = strtab + sym->st_name;
    3537                         else if (sym->st_shndx < shnum)
    3538                             name = f->sections[sym->st_shndx]->name;
    3539                         else
    3540                             continue;
    3541 
    3542 #if defined(__SH5__)
    3543                         /*
    3544                          * For sh64 it is possible that the target of a branch
    3545                          * requires a mode switch (32 to 16 and back again).
    3546                          *
    3547                          * This is implied by the lsb being set in the target
    3548                          * address for SHmedia mode and clear for SHcompact.
    3549                          */
    3550                         val |= sym->st_other & 4;
    3551 #endif
    3552 
    3553                         obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
    3554                                 val, sym->st_size);
    3555                     }
    3556                 }
    3557                 break;
    3558 
    3559             case SHT_RELM:
    3560                 if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
    3561                     bb_error_msg("relocation entry size mismatch: %lu != %lu",
     3490        case SHT_SYMTAB:
     3491            {
     3492                unsigned long nsym, j;
     3493                char *strtab;
     3494                ElfW(Sym) * sym;
     3495
     3496                if (sec->header.sh_entsize != sizeof(ElfW(Sym))) {
     3497                    bb_error_msg("symbol size mismatch: %lu != %lu",
    35623498                            (unsigned long) sec->header.sh_entsize,
    3563                             (unsigned long) sizeof(ElfW(RelM)));
     3499                            (unsigned long) sizeof(ElfW(Sym)));
    35643500                    return NULL;
    35653501                }
    3566                 break;
    3567                 /* XXX  Relocation code from modutils-2.3.19 is not here.
    3568                  * Why?  That's about 20 lines of code from obj/obj_load.c,
    3569                  * which gets done in a second pass through the sections.
    3570                  * This BusyBox insmod does similar work in obj_relocate(). */
     3502
     3503                nsym = sec->header.sh_size / sizeof(ElfW(Sym));
     3504                strtab = f->sections[sec->header.sh_link]->contents;
     3505                sym = (ElfW(Sym) *) sec->contents;
     3506
     3507                /* Allocate space for a table of local symbols.  */
     3508                j = f->local_symtab_size = sec->header.sh_info;
     3509                f->local_symtab = xzalloc(j * sizeof(struct obj_symbol *));
     3510
     3511                /* Insert all symbols into the hash table.  */
     3512                for (j = 1, ++sym; j < nsym; ++j, ++sym) {
     3513                    ElfW(Addr) val = sym->st_value;
     3514                    const char *name;
     3515                    if (sym->st_name)
     3516                        name = strtab + sym->st_name;
     3517                    else if (sym->st_shndx < shnum)
     3518                        name = f->sections[sym->st_shndx]->name;
     3519                    else
     3520                        continue;
     3521#if defined(__SH5__)
     3522                    /*
     3523                     * For sh64 it is possible that the target of a branch
     3524                     * requires a mode switch (32 to 16 and back again).
     3525                     *
     3526                     * This is implied by the lsb being set in the target
     3527                     * address for SHmedia mode and clear for SHcompact.
     3528                     */
     3529                    val |= sym->st_other & 4;
     3530#endif
     3531
     3532                    obj_add_symbol(f, name, j, sym->st_info, sym->st_shndx,
     3533                            val, sym->st_size);
     3534                }
     3535            }
     3536            break;
     3537
     3538        case SHT_RELM:
     3539            if (sec->header.sh_entsize != sizeof(ElfW(RelM))) {
     3540                bb_error_msg("relocation entry size mismatch: %lu != %lu",
     3541                        (unsigned long) sec->header.sh_entsize,
     3542                        (unsigned long) sizeof(ElfW(RelM)));
     3543                return NULL;
     3544            }
     3545            break;
     3546            /* XXX  Relocation code from modutils-2.3.19 is not here.
     3547             * Why?  That's about 20 lines of code from obj/obj_load.c,
     3548             * which gets done in a second pass through the sections.
     3549             * This BusyBox insmod does similar work in obj_relocate(). */
    35713550        }
    35723551    }
     
    35753554}
    35763555
    3577 #ifdef CONFIG_FEATURE_INSMOD_LOADINKMEM
     3556#if ENABLE_FEATURE_INSMOD_LOADINKMEM
    35783557/*
    35793558 * load the unloaded sections directly into the memory allocated by
     
    35983577        fseek(fp, sec->header.sh_offset, SEEK_SET);
    35993578        if (fread(sec->contents, sec->header.sh_size, 1, fp) != 1) {
    3600             bb_error_msg("error reading ELF section data: %s\n", strerror(errno));
     3579            bb_perror_msg("error reading ELF section data");
    36013580            return 0;
    36023581        }
     
    36193598    const char *const *p;
    36203599
    3621     for (p = specials; *p; ++p)
    3622         if ((sym = obj_find_symbol(f, *p)) != NULL)
    3623             sym->info =
    3624                 ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
    3625 }
    3626 
    3627 
    3628 #ifdef CONFIG_FEATURE_CHECK_TAINTED_MODULE
     3600    for (p = specials; *p; ++p) {
     3601        sym = obj_find_symbol(f, *p);
     3602        if (sym != NULL)
     3603            sym->info = ELF_ST_INFO(STB_LOCAL, ELF_ST_TYPE(sym->info));
     3604    }
     3605}
     3606
     3607
     3608#if ENABLE_FEATURE_CHECK_TAINTED_MODULE
    36293609static int obj_gpl_license(struct obj_file *f, const char **license)
    36303610{
     
    36343614     * work, somebody will use "GPL sucks, this is proprietary".
    36353615     */
    3636     static const char * const gpl_licenses[] = {
     3616    static const char *const gpl_licenses[] = {
    36373617        "GPL",
    36383618        "GPL v2",
    36393619        "GPL and additional rights",
    36403620        "Dual BSD/GPL",
    3641         "Dual MPL/GPL",
     3621        "Dual MPL/GPL"
    36423622    };
    36433623
    3644     if ((sec = obj_find_section(f, ".modinfo"))) {
     3624    sec = obj_find_section(f, ".modinfo");
     3625    if (sec) {
    36453626        const char *value, *ptr, *endptr;
    36463627        ptr = sec->contents;
    36473628        endptr = ptr + sec->header.sh_size;
    36483629        while (ptr < endptr) {
    3649             if ((value = strchr(ptr, '=')) && strncmp(ptr, "license", value-ptr) == 0) {
     3630            value = strchr(ptr, '=');
     3631            if (value && strncmp(ptr, "license", value-ptr) == 0) {
    36503632                int i;
    36513633                if (license)
    36523634                    *license = value+1;
    3653                 for (i = 0; i < sizeof(gpl_licenses)/sizeof(gpl_licenses[0]); ++i) {
     3635                for (i = 0; i < ARRAY_SIZE(gpl_licenses); ++i) {
    36543636                    if (strcmp(value+1, gpl_licenses[i]) == 0)
    3655                         return(0);
     3637                        return 0;
    36563638                }
    3657                 return(2);
     3639                return 2;
    36583640            }
    36593641            if (strchr(ptr, '\0'))
     
    36633645        }
    36643646    }
    3665     return(1);
     3647    return 1;
    36663648}
    36673649
     
    36753657        int kernel_has_tainted, int taint, const char *text1, const char *text2)
    36763658{
     3659    static smallint printed_info;
     3660
    36773661    char buf[80];
    36783662    int oldval;
    3679     static int first = 1;
     3663
    36803664    if (fd < 0 && !kernel_has_tainted)
    36813665        return;     /* New modutils on old kernel */
    36823666    printf("Warning: loading %s will taint the kernel: %s%s\n",
    36833667            m_name, text1, text2);
    3684     if (first) {
     3668    if (!printed_info) {
    36853669        printf("  See %s for information about tainted modules\n", TAINT_URL);
    3686         first = 0;
     3670        printed_info = 1;
    36873671    }
    36883672    if (fd >= 0) {
     
    36983682static void check_tainted_module(struct obj_file *f, char *m_name)
    36993683{
    3700     static const char tainted_file[] = TAINT_FILENAME;
     3684    static const char tainted_file[] ALIGN1 = TAINT_FILENAME;
     3685
    37013686    int fd, kernel_has_tainted;
    37023687    const char *ptr;
    37033688
    37043689    kernel_has_tainted = 1;
    3705     if ((fd = open(tainted_file, O_RDWR)) < 0) {
     3690    fd = open(tainted_file, O_RDWR);
     3691    if (fd < 0) {
    37063692        if (errno == ENOENT)
    37073693            kernel_has_tainted = 0;
     
    37383724        close(fd);
    37393725}
    3740 #else /* CONFIG_FEATURE_CHECK_TAINTED_MODULE */
    3741 #define check_tainted_module(x, y) do { } while(0);
    3742 #endif /* CONFIG_FEATURE_CHECK_TAINTED_MODULE */
    3743 
    3744 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
     3726#else /* FEATURE_CHECK_TAINTED_MODULE */
     3727#define check_tainted_module(x, y) do { } while (0);
     3728#endif /* FEATURE_CHECK_TAINTED_MODULE */
     3729
     3730#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
    37453731/* add module source, timestamp, kernel version and a symbol for the
    37463732 * start of some sections.  this info is used by ksymoops to do better
     
    37503736get_module_version(struct obj_file *f, char str[STRVERSIONLEN])
    37513737{
    3752 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     3738#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    37533739    return new_get_module_version(f, str);
    3754 #else  /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     3740#else  /* FEATURE_INSMOD_VERSION_CHECKING */
    37553741    strncpy(str, "???", sizeof(str));
    37563742    return -1;
    3757 #endif /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     3743#endif /* FEATURE_INSMOD_VERSION_CHECKING */
    37583744}
    37593745
     
    37663752                 const char *m_name)
    37673753{
    3768     static const char symprefix[] = "__insmod_";
     3754    static const char symprefix[] ALIGN1 = "__insmod_";
     3755
    37693756    struct obj_section *sec;
    37703757    struct obj_symbol *sym;
     
    37833770
    37843771    if (realpath(filename, real)) {
    3785         absolute_filename = bb_xstrdup(real);
    3786     }
    3787     else {
    3788         int save_errno = errno;
    3789         bb_error_msg("cannot get realpath for %s", filename);
    3790         errno = save_errno;
    3791         perror("");
    3792         absolute_filename = bb_xstrdup(filename);
     3772        absolute_filename = xstrdup(real);
     3773    } else {
     3774        bb_perror_msg("cannot get realpath for %s", filename);
     3775        absolute_filename = xstrdup(filename);
    37933776    }
    37943777
     
    38003783     * "export all symbols" compatibility code will export these symbols later.
    38013784     */
    3802     use_ksymtab =  obj_find_section(f, "__ksymtab") || !flag_export;
    3803 
    3804     if ((sec = obj_find_section(f, ".this"))) {
     3785    use_ksymtab = obj_find_section(f, "__ksymtab") || flag_noexport;
     3786
     3787    sec = obj_find_section(f, ".this");
     3788    if (sec) {
    38053789        /* tag the module header with the object name, last modified
    38063790         * timestamp and module version.  worst case for module version
     
    38523836    /* tag the desired sections if size is non-zero */
    38533837
    3854     for (i = 0; i < sizeof(section_names)/sizeof(section_names[0]); ++i) {
    3855         if ((sec = obj_find_section(f, section_names[i])) &&
    3856                 sec->header.sh_size) {
     3838    for (i = 0; i < ARRAY_SIZE(section_names); ++i) {
     3839        sec = obj_find_section(f, section_names[i]);
     3840        if (sec && sec->header.sh_size) {
    38573841            l = sizeof(symprefix)+      /* "__insmod_" */
    38583842                lm_name+        /* module name */
     
    38733857    }
    38743858}
    3875 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
    3876 
    3877 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
     3859#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
     3860
     3861#if ENABLE_FEATURE_INSMOD_LOAD_MAP
    38783862static void print_load_map(struct obj_file *f)
    38793863{
     3864    struct obj_section *sec;
     3865#if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
     3866    struct obj_symbol **all, **p;
     3867    int i, nsyms, *loaded;
    38803868    struct obj_symbol *sym;
    3881     struct obj_symbol **all, **p;
    3882     struct obj_section *sec;
    3883     int i, nsyms, *loaded;
    3884 
     3869#endif
    38853870    /* Report on the section layout.  */
    38863871
     
    39043889                a);
    39053890    }
    3906 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP_FULL
     3891#if ENABLE_FEATURE_INSMOD_LOAD_MAP_FULL
    39073892    /* Quick reference which section indicies are loaded.  */
    39083893
     
    39643949#endif
    39653950}
    3966 
    3967 #endif
    3968 
     3951#else /* !FEATURE_INSMOD_LOAD_MAP */
     3952void print_load_map(struct obj_file *f);
     3953#endif
     3954
     3955int insmod_main( int argc, char **argv);
    39693956int insmod_main( int argc, char **argv)
    39703957{
    3971     int opt;
     3958    char *opt_o, *arg1;
    39723959    int len;
    39733960    int k_crcs;
     
    39803967    int exit_status = EXIT_FAILURE;
    39813968    int m_has_modinfo;
    3982 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     3969#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    39833970    struct utsname uts_info;
    39843971    char m_strversion[STRVERSIONLEN];
    39853972    int m_version, m_crcs;
    39863973#endif
    3987 #ifdef CONFIG_FEATURE_CLEAN_UP
     3974#if ENABLE_FEATURE_CLEAN_UP
    39883975    FILE *fp = 0;
    39893976#else
    39903977    FILE *fp;
    39913978#endif
    3992 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
    3993     int flag_print_load_map = 0;
    3994 #endif
    39953979    int k_version = 0;
    39963980    struct utsname myuname;
    39973981
    39983982    /* Parse any options */
    3999 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
    4000     while ((opt = getopt(argc, argv, "fkqsvxmLo:")) > 0)
    4001 #else
    4002     while ((opt = getopt(argc, argv, "fkqsvxLo:")) > 0)
    4003 #endif
    4004         {
    4005             switch (opt) {
    4006                 case 'f':           /* force loading */
    4007                     flag_force_load = 1;
    4008                     break;
    4009                 case 'k':           /* module loaded by kerneld, auto-cleanable */
    4010                     flag_autoclean = 1;
    4011                     break;
    4012                 case 's':           /* log to syslog */
    4013                     /* log to syslog -- not supported              */
    4014                     /* but kernel needs this for request_module(), */
    4015                     /* as this calls: modprobe -k -s -- <module>   */
    4016                     /* so silently ignore this flag                */
    4017                     break;
    4018                 case 'v':           /* verbose output */
    4019                     flag_verbose = 1;
    4020                     break;
    4021                 case 'q':           /* silent */
    4022                     flag_quiet = 1;
    4023                     break;
    4024                 case 'x':           /* do not export externs */
    4025                     flag_export = 0;
    4026                     break;
    4027                 case 'o':           /* name the output module */
    4028                     free(m_name);
    4029                     m_name = bb_xstrdup(optarg);
    4030                     break;
    4031                 case 'L':           /* Stub warning */
    4032                     /* This is needed for compatibility with modprobe.
    4033                      * In theory, this does locking, but we don't do
    4034                      * that.  So be careful and plan your life around not
    4035                      * loading the same module 50 times concurrently. */
    4036                     break;
    4037 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
    4038                 case 'm':           /* print module load map */
    4039                     flag_print_load_map = 1;
    4040                     break;
    4041 #endif
    4042                 default:
    4043                     bb_show_usage();
    4044             }
    4045         }
    4046 
    4047     if (argv[optind] == NULL) {
     3983    getopt32(argv, OPTION_STR, &opt_o);
     3984    arg1 = argv[optind];
     3985    if (option_mask32 & OPT_o) { // -o /* name the output module */
     3986        free(m_name);
     3987        m_name = xstrdup(opt_o);
     3988    }
     3989
     3990    if (arg1 == NULL) {
    40483991        bb_show_usage();
    40493992    }
    40503993
    40513994    /* Grab the module name */
    4052     tmp1 = bb_xstrdup(argv[optind]);
     3995    tmp1 = xstrdup(arg1);
    40533996    tmp = basename(tmp1);
    40543997    len = strlen(tmp);
     
    40604003    }
    40614004
    4062 #if defined(CONFIG_FEATURE_2_6_MODULES)
    4063     if (k_version > 4 && len > 3 && tmp[len - 3] == '.' &&
    4064             tmp[len - 2] == 'k' && tmp[len - 1] == 'o') {
    4065         len-=3;
     4005#if ENABLE_FEATURE_2_6_MODULES
     4006    if (k_version > 4 && len > 3 && tmp[len - 3] == '.'
     4007     && tmp[len - 2] == 'k' && tmp[len - 1] == 'o'
     4008    ) {
     4009        len -= 3;
    40664010        tmp[len] = '\0';
    4067     }
    4068     else
     4011    } else
    40694012#endif
    40704013        if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o') {
    4071             len-=2;
     4014            len -= 2;
    40724015            tmp[len] = '\0';
    40734016        }
    40744017
    40754018
    4076 #if defined(CONFIG_FEATURE_2_6_MODULES)
     4019#if ENABLE_FEATURE_2_6_MODULES
    40774020    if (k_version > 4)
    4078         m_fullName = bb_xasprintf("%s.ko", tmp);
     4021        m_fullName = xasprintf("%s.ko", tmp);
    40794022    else
    40804023#endif
    4081         m_fullName = bb_xasprintf("%s.o", tmp);
     4024        m_fullName = xasprintf("%s.o", tmp);
    40824025
    40834026    if (!m_name) {
     
    40894032
    40904033    /* Get a filedesc for the module.  Check we we have a complete path */
    4091     if (stat(argv[optind], &st) < 0 || !S_ISREG(st.st_mode) ||
    4092             (fp = fopen(argv[optind], "r")) == NULL) {
     4034    if (stat(arg1, &st) < 0 || !S_ISREG(st.st_mode)
     4035     || (fp = fopen(arg1, "r")) == NULL
     4036    ) {
    40934037        /* Hmm.  Could not open it.  First search under /lib/modules/`uname -r`,
    40944038         * but do not error out yet if we fail to find it... */
     
    41044048             * /lib/modules/`uname -r` dir, So resolve it ourselves
    41054049             * if it is a link... */
    4106             if (realpath (tmdn, real_module_dir) == NULL)
     4050            if (realpath(tmdn, real_module_dir) == NULL)
    41074051                module_dir = tmdn;
    41084052            else
    41094053                module_dir = real_module_dir;
    4110             recursive_action(module_dir, TRUE, FALSE, FALSE,
    4111                     check_module_name_match, 0, m_fullName);
     4054            recursive_action(module_dir, ACTION_RECURSE,
     4055                    check_module_name_match, 0, m_fullName, 0);
    41124056            free(tmdn);
    41134057        }
    41144058
    41154059        /* Check if we have found anything yet */
    4116         if (m_filename == 0 || ((fp = fopen(m_filename, "r")) == NULL))
    4117         {
     4060        if (m_filename == 0 || ((fp = fopen(m_filename, "r")) == NULL)) {
    41184061            char module_dir[FILENAME_MAX];
    41194062
     
    41244067            /* No module found under /lib/modules/`uname -r`, this
    41254068             * time cast the net a bit wider.  Search /lib/modules/ */
    4126             if (! recursive_action(module_dir, TRUE, FALSE, FALSE,
    4127                         check_module_name_match, 0, m_fullName))
    4128             {
     4069            if (!recursive_action(module_dir, ACTION_RECURSE,
     4070                            check_module_name_match, 0, m_fullName, 0)
     4071            ) {
    41294072                if (m_filename == 0
    4130                         || ((fp = fopen(m_filename, "r")) == NULL))
    4131                 {
     4073                 || ((fp = fopen(m_filename, "r")) == NULL)
     4074                ) {
    41324075                    bb_error_msg("%s: no module by that name found", m_fullName);
    41334076                    goto out;
     
    41374080        }
    41384081    } else
    4139         m_filename = bb_xstrdup(argv[optind]);
     4082        m_filename = xstrdup(arg1);
    41404083
    41414084    if (flag_verbose)
    41424085        printf("Using %s\n", m_filename);
    41434086
    4144 #ifdef CONFIG_FEATURE_2_6_MODULES
    4145     if (k_version > 4)
    4146     {
     4087#if ENABLE_FEATURE_2_6_MODULES
     4088    if (k_version > 4) {
     4089        argv[optind] = m_filename;
    41474090        optind--;
    4148         argv[optind + 1] = m_filename;
    41494091        return insmod_ng_main(argc - optind, argv + optind);
    41504092    }
    41514093#endif
    41524094
    4153     if ((f = obj_load(fp, LOADBITS)) == NULL)
    4154         bb_perror_msg_and_die("Could not load the module");
     4095    f = obj_load(fp, LOADBITS);
     4096    if (f == NULL)
     4097        bb_perror_msg_and_die("cannot load the module");
    41554098
    41564099    if (get_modinfo_value(f, "kernel_version") == NULL)
     
    41594102        m_has_modinfo = 1;
    41604103
    4161 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     4104#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    41624105    /* Version correspondence?  */
    41634106    if (!flag_quiet) {
     
    41674110            m_version = new_get_module_version(f, m_strversion);
    41684111            if (m_version == -1) {
    4169                 bb_error_msg("couldn't find the kernel version the module was "
     4112                bb_error_msg("cannot find the kernel version the module was "
    41704113                        "compiled for");
    41714114                goto out;
     
    41744117
    41754118        if (strncmp(uts_info.release, m_strversion, STRVERSIONLEN) != 0) {
    4176             if (flag_force_load) {
    4177                 bb_error_msg("Warning: kernel-module version mismatch\n"
    4178                         "\t%s was compiled for kernel version %s\n"
    4179                         "\twhile this kernel is version %s",
    4180                         m_filename, m_strversion, uts_info.release);
    4181             } else {
    4182                 bb_error_msg("kernel-module version mismatch\n"
    4183                         "\t%s was compiled for kernel version %s\n"
    4184                         "\twhile this kernel is version %s.",
    4185                         m_filename, m_strversion, uts_info.release);
     4119            bb_error_msg("%skernel-module version mismatch\n"
     4120                "\t%s was compiled for kernel version %s\n"
     4121                "\twhile this kernel is version %s",
     4122                flag_force_load ? "warning: " : "",
     4123                m_filename, m_strversion, uts_info.release);
     4124            if (!flag_force_load)
    41864125                goto out;
    4187             }
    41884126        }
    41894127    }
    41904128    k_crcs = 0;
    4191 #endif                          /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     4129#endif /* FEATURE_INSMOD_VERSION_CHECKING */
    41924130
    41934131    if (!query_module(NULL, 0, NULL, 0, NULL)) {
     
    41964134        k_crcs = new_is_kernel_checksummed();
    41974135    } else {
    4198         bb_error_msg("Not configured to support old kernels");
     4136        bb_error_msg("not configured to support old kernels");
    41994137        goto out;
    42004138    }
    42014139
    4202 #ifdef CONFIG_FEATURE_INSMOD_VERSION_CHECKING
     4140#if ENABLE_FEATURE_INSMOD_VERSION_CHECKING
    42034141    m_crcs = 0;
    42044142    if (m_has_modinfo)
     
    42074145    if (m_crcs != k_crcs)
    42084146        obj_set_symbol_compare(f, ncv_strcmp, ncv_symbol_hash);
    4209 #endif                          /* CONFIG_FEATURE_INSMOD_VERSION_CHECKING */
     4147#endif /* FEATURE_INSMOD_VERSION_CHECKING */
    42104148
    42114149    /* Let the module know about the kernel symbols.  */
     
    42144152    /* Allocate common symbols, symbol tables, and string tables.  */
    42154153
    4216     if (!new_create_this_module(f, m_name))
    4217     {
     4154    if (!new_create_this_module(f, m_name)) {
    42184155        goto out;
    42194156    }
     
    42274164    /* done with the module name, on to the optional var=value arguments */
    42284165    ++optind;
    4229 
    42304166    if (optind < argc) {
    4231         if (!new_process_module_arguments(f, argc - optind, argv + optind))
    4232         {
     4167        if (!new_process_module_arguments(f, argc - optind, argv + optind)) {
    42334168            goto out;
    42344169        }
     
    42384173    hide_special_symbols(f);
    42394174
    4240 #ifdef CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
     4175#if ENABLE_FEATURE_INSMOD_KSYMOOPS_SYMBOLS
    42414176    add_ksymoops_symbols(f, m_filename, m_name);
    4242 #endif /* CONFIG_FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
     4177#endif /* FEATURE_INSMOD_KSYMOOPS_SYMBOLS */
    42434178
    42444179    new_create_module_ksymtab(f);
     
    42514186    if (m_addr == -1) switch (errno) {
    42524187        case EEXIST:
    4253             bb_error_msg("A module named %s already exists", m_name);
     4188            bb_error_msg("a module named %s already exists", m_name);
    42544189            goto out;
    42554190        case ENOMEM:
    4256             bb_error_msg("Can't allocate kernel memory for module; needed %lu bytes",
     4191            bb_error_msg("can't allocate kernel memory for module; needed %lu bytes",
    42574192                    m_size);
    42584193            goto out;
     
    42784213    }
    42794214
    4280     if (!new_init_module(m_name, f, m_size))
    4281     {
     4215    if (!new_init_module(m_name, f, m_size)) {
    42824216        delete_module(m_name);
    42834217        goto out;
    42844218    }
    42854219
    4286 #ifdef CONFIG_FEATURE_INSMOD_LOAD_MAP
    4287     if(flag_print_load_map)
     4220    if (flag_print_load_map)
    42884221        print_load_map(f);
    4289 #endif
    42904222
    42914223    exit_status = EXIT_SUCCESS;
    42924224
    42934225out:
    4294 #ifdef CONFIG_FEATURE_CLEAN_UP
    4295     if(fp)
     4226#if ENABLE_FEATURE_CLEAN_UP
     4227    if (fp)
    42964228        fclose(fp);
    42974229    free(tmp1);
    4298     if(!tmp1) {
     4230    if (!tmp1)
    42994231        free(m_name);
    4300     }
    43014232    free(m_filename);
    43024233#endif
    4303     return(exit_status);
    4304 }
    4305 
    4306 
    4307 #endif
    4308 
    4309 
    4310 #ifdef CONFIG_FEATURE_2_6_MODULES
     4234    return exit_status;
     4235}
     4236
     4237
     4238#endif
     4239
     4240
     4241#if ENABLE_FEATURE_2_6_MODULES
    43114242
    43124243#include <sys/mman.h>
     
    43184249{
    43194250    switch (err) {
    4320         case ENOEXEC:
    4321             return "Invalid module format";
    4322         case ENOENT:
    4323             return "Unknown symbol in module";
    4324         case ESRCH:
    4325             return "Module has wrong symbol version";
    4326         case EINVAL:
    4327             return "Invalid parameters";
    4328         default:
    4329             return strerror(err);
    4330     }
    4331 }
    4332 
    4333 int insmod_ng_main( int argc, char **argv)
    4334 {
    4335     int i;
     4251    case ENOEXEC:
     4252        return "Invalid module format";
     4253    case ENOENT:
     4254        return "Unknown symbol in module";
     4255    case ESRCH:
     4256        return "Module has wrong symbol version";
     4257    case EINVAL:
     4258        return "Invalid parameters";
     4259    default:
     4260        return strerror(err);
     4261    }
     4262}
     4263
     4264int insmod_ng_main(int argc, char **argv);
     4265int insmod_ng_main(int argc, char **argv)
     4266{
     4267    long ret;
     4268    size_t len;
     4269    int optlen;
     4270    void *map;
     4271    char *filename, *options;
     4272
     4273    filename = *++argv;
     4274    if (!filename)
     4275        bb_show_usage();
     4276
     4277    /* Rest is options */
     4278    options = xzalloc(1);
     4279    optlen = 0;
     4280    while (*++argv) {
     4281        options = xrealloc(options, optlen + 2 + strlen(*argv) + 2);
     4282        /* Spaces handled by "" pairs, but no way of escaping quotes */
     4283        optlen += sprintf(options + optlen, (strchr(*argv,' ') ? "\"%s\" " : "%s "), *argv);
     4284    }
     4285
     4286#if 0
     4287    /* Any special reason why mmap? It isn't performace critical... */
    43364288    int fd;
    4337     long int ret;
    43384289    struct stat st;
    43394290    unsigned long len;
    4340     void *map;
    4341     char *filename, *options = bb_xstrdup("");
    4342 
    4343     filename = argv[1];
    4344     if (!filename) {
    4345         bb_show_usage();
    4346         return -1;
    4347     }
    4348 
    4349     /* Rest is options */
    4350     for (i = 2; i < argc; i++) {
    4351         options = xrealloc(options, strlen(options) + 2 + strlen(argv[i]) + 2);
    4352         /* Spaces handled by "" pairs, but no way of escaping quotes */
    4353         if (strchr(argv[i], ' ')) {
    4354             strcat(options, "\"");
    4355             strcat(options, argv[i]);
    4356             strcat(options, "\"");
    4357         } else {
    4358             strcat(options, argv[i]);
    4359         }
    4360         strcat(options, " ");
    4361     }
    4362 
    4363     fd = bb_xopen3(filename, O_RDONLY, 0);
    4364 
     4291    fd = xopen(filename, O_RDONLY);
    43654292    fstat(fd, &st);
    43664293    len = st.st_size;
    43674294    map = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
    43684295    if (map == MAP_FAILED) {
    4369         bb_perror_msg_and_die("cannot mmap `%s'", filename);
    4370     }
     4296        bb_perror_msg_and_die("cannot mmap '%s'", filename);
     4297    }
     4298
     4299    /* map == NULL on Blackfin, probably on other MMU-less systems too. Workaround. */
     4300    if (map == NULL) {
     4301        map = xmalloc(len);
     4302        xread(fd, map, len);
     4303    }
     4304#else
     4305    len = MAXINT(ssize_t);
     4306    map = xmalloc_open_read_close(filename, &len);
     4307#endif
    43714308
    43724309    ret = syscall(__NR_init_module, map, len, options);
    43734310    if (ret != 0) {
    4374         bb_perror_msg_and_die("cannot insert `%s': %s (%li)",
     4311        bb_perror_msg_and_die("cannot insert '%s': %s (%li)",
    43754312                filename, moderror(errno), ret);
    43764313    }
  • branches/2.2.5/mindi-busybox/modutils/lsmod.c

    r902 r1765  
    1212 */
    1313
    14 #include "busybox.h"
    15 #include <stdlib.h>
    16 #include <stdio.h>
    17 #include <string.h>
    18 #include <stddef.h>
    19 #include <errno.h>
    20 #include <unistd.h>
    21 #include <dirent.h>
    22 #include <ctype.h>
    23 #include <assert.h>
    24 #include <getopt.h>
    25 #include <sys/utsname.h>
    26 #include <sys/file.h>
     14#include "libbb.h"
    2715
    2816
    29 #ifndef CONFIG_FEATURE_CHECK_TAINTED_MODULE
    30 static inline void check_tainted(void) { printf("\n"); }
     17#if !ENABLE_FEATURE_CHECK_TAINTED_MODULE
     18static void check_tainted(void) { puts(""); }
    3119#else
    3220#define TAINT_FILENAME                  "/proc/sys/kernel/tainted"
     
    5745#endif
    5846
    59 #ifdef CONFIG_FEATURE_QUERY_MODULE_INTERFACE
     47#if ENABLE_FEATURE_QUERY_MODULE_INTERFACE
    6048
    6149struct module_info
     
    8775};
    8876
     77int lsmod_main(int argc, char **argv);
    8978int lsmod_main(int argc, char **argv)
    9079{
     
    9382    size_t bufsize, depsize, nmod, count, i, j;
    9483
    95     module_names = xmalloc(bufsize = 256);
    96     if (my_query_module(NULL, QM_MODULES, &module_names, &bufsize, &nmod)) {
    97         bb_perror_msg_and_die("QM_MODULES");
     84    module_names = deps = NULL;
     85    bufsize = depsize = 0;
     86    while (query_module(NULL, QM_MODULES, module_names, bufsize, &nmod)) {
     87        if (errno != ENOSPC) bb_perror_msg_and_die("QM_MODULES");
     88        module_names = xmalloc(bufsize = nmod);
    9889    }
    9990
    10091    deps = xmalloc(depsize = 256);
    101     printf("Module                  Size  Used by");
     92    printf("Module\t\t\tSize  Used by");
    10293    check_tainted();
    10394
     
    111102            bb_perror_msg_and_die("module %s: QM_INFO", mn);
    112103        }
    113         if (my_query_module(mn, QM_REFS, &deps, &depsize, &count)) {
     104        while (query_module(mn, QM_REFS, deps, depsize, &count)) {
    114105            if (errno == ENOENT) {
    115106                /* The module was removed out from underneath us. */
    116107                continue;
    117             }
    118             bb_perror_msg_and_die("module %s: QM_REFS", mn);
     108            } else if (errno != ENOSPC)
     109                bb_perror_msg_and_die("module %s: QM_REFS", mn);
     110            deps = xrealloc(deps, count);
    119111        }
    120112        printf("%-20s%8lu%4ld", mn, info.size, info.usecount);
     
    137129        if (count) printf("]");
    138130
    139         printf("\n");
     131        puts("");
    140132    }
    141133
    142 #ifdef CONFIG_FEATURE_CLEAN_UP
     134#if ENABLE_FEATURE_CLEAN_UP
    143135    free(module_names);
    144136#endif
    145137
    146     return( 0);
     138    return 0;
    147139}
    148140
    149141#else /* CONFIG_FEATURE_QUERY_MODULE_INTERFACE */
    150142
     143int lsmod_main(int argc, char **argv);
    151144int lsmod_main(int argc, char **argv)
    152145{
     146    FILE *file = xfopen("/proc/modules", "r");
     147
    153148    printf("Module                  Size  Used by");
    154149    check_tainted();
    155150#if defined(CONFIG_FEATURE_LSMOD_PRETTY_2_6_OUTPUT)
    156151    {
    157       FILE *file;
    158       char line[4096];
     152        char *line;
     153        while ((line = xmalloc_fgets(file)) != NULL) {
     154            char *tok;
    159155
    160       file = bb_xfopen("/proc/modules", "r");
    161 
    162       while (fgets(line, sizeof(line), file)) {
    163         char *tok;
    164 
    165         tok = strtok(line, " \t");
    166         printf("%-19s", tok);
    167         tok = strtok(NULL, " \t\n");
    168         printf(" %8s", tok);
    169         tok = strtok(NULL, " \t\n");
    170         /* Null if no module unloading support. */
    171         if (tok) {
    172           printf("  %s", tok);
    173           tok = strtok(NULL, "\n");
    174           if (!tok)
    175         tok = "";
    176           /* New-style has commas, or -.  If so,
    177          truncate (other fields might follow). */
    178           else if (strchr(tok, ',')) {
    179         tok = strtok(tok, "\t ");
    180         /* Strip trailing comma. */
    181         if (tok[strlen(tok)-1] == ',')
    182           tok[strlen(tok)-1] = '\0';
    183           } else if (tok[0] == '-'
    184              && (tok[1] == '\0' || isspace(tok[1])))
    185         tok = "";
    186           printf(" %s", tok);
    187         }
    188         printf("\n");
    189       }
    190       fclose(file);
     156            tok = strtok(line, " \t");
     157            printf("%-19s", tok);
     158            tok = strtok(NULL, " \t\n");
     159            printf(" %8s", tok);
     160            tok = strtok(NULL, " \t\n");
     161            /* Null if no module unloading support. */
     162            if (tok) {
     163                printf("  %s", tok);
     164                tok = strtok(NULL, "\n");
     165                if (!tok)
     166                    tok = (char*)"";
     167                /* New-style has commas, or -.  If so,
     168                truncate (other fields might follow). */
     169                else if (strchr(tok, ',')) {
     170                    tok = strtok(tok, "\t ");
     171                    /* Strip trailing comma. */
     172                    if (tok[strlen(tok)-1] == ',')
     173                        tok[strlen(tok)-1] = '\0';
     174                } else if (tok[0] == '-'
     175                 && (tok[1] == '\0' || isspace(tok[1]))
     176                ) {
     177                    tok = (char*)"";
     178                }
     179                printf(" %s", tok);
     180            }
     181            puts("");
     182            free(line);
     183        }
     184        fclose(file);
    191185    }
     186#else
     187    xprint_and_close_file(file);
     188#endif  /*  CONFIG_FEATURE_2_6_MODULES  */
    192189    return EXIT_SUCCESS;
    193 #else
    194     if (bb_xprint_file_by_name("/proc/modules") == 0)
    195         return EXIT_SUCCESS;
    196 #endif  /*  CONFIG_FEATURE_2_6_MODULES  */
    197 
    198     return EXIT_FAILURE;
    199190}
    200191
  • branches/2.2.5/mindi-busybox/modutils/modprobe.c

    r902 r1765  
    1212*/
    1313
    14 #include "busybox.h"
     14#include "libbb.h"
    1515#include <sys/utsname.h>
    16 #include <sys/types.h>
    17 #include <sys/wait.h>
    18 #include <getopt.h>
    19 #include <stdlib.h>
    20 #include <unistd.h>
    21 #include <syslog.h>
    22 #include <string.h>
    23 #include <ctype.h>
    24 #include <fcntl.h>
    2516#include <fnmatch.h>
    2617
     
    3223struct dep_t {  /* one-way list of dependency rules */
    3324    /* a dependency rule */
    34     char *  m_name;             /* the module name*/
    35     char *  m_path;             /* the module file path */
    36     struct mod_opt_t *  m_options;  /* the module options */
    37 
    38     int     m_isalias  : 1;         /* the module is an alias */
    39     int     m_reserved : 15;        /* stuffin' */
    40 
    41     int     m_depcnt   : 16;        /* the number of dependable module(s) */
    42     char ** m_deparr;           /* the list of dependable module(s) */
    43 
    44     struct dep_t * m_next;          /* the next dependency rule */
     25    char *  m_name;                         /* the module name*/
     26    char *  m_path;                         /* the module file path */
     27    struct mod_opt_t *  m_options;          /* the module options */
     28
     29    int     m_isalias  : 1;                 /* the module is an alias */
     30    int     m_reserved : 15;                /* stuffin' */
     31
     32    int     m_depcnt   : 16;                /* the number of dependable module(s) */
     33    char ** m_deparr;                       /* the list of dependable module(s) */
     34
     35    struct dep_t * m_next;                  /* the next dependency rule */
    4536};
    4637
    4738struct mod_list_t { /* two-way list of modules to process */
    4839    /* a module description */
    49     char * m_name;
    50     char *  m_path;
    51     struct mod_opt_t *  m_options;
     40    const char * m_name;
     41    char * m_path;
     42    struct mod_opt_t * m_options;
    5243
    5344    struct mod_list_t * m_prev;
     
    8273static int main_opts;
    8374
    84 static int parse_tag_value ( char *buffer, char **ptag, char **pvalue )
     75static int parse_tag_value(char *buffer, char **ptag, char **pvalue)
    8576{
    8677    char *tag, *value;
    8778
    88     while ( isspace ( *buffer ))
    89         buffer++;
     79    buffer = skip_whitespace(buffer);
    9080    tag = value = buffer;
    91     while ( !isspace ( *value ))
     81    while (!isspace(*value))
    9282        if (!*value) return 0;
    9383        else value++;
    9484    *value++ = 0;
    95     while ( isspace ( *value ))
    96         value++;
     85    value = skip_whitespace(value);
    9786    if (!*value) return 0;
    9887
     
    10190
    10291    return 1;
    103 }
    104 
    105 /* Jump through hoops to simulate how fgets() grabs just one line at a
    106  * time... Don't use any stdio since modprobe gets called from a kernel
    107  * thread and stdio junk can overflow the limited stack...
    108  */
    109 static char *reads ( int fd, char *buffer, size_t len )
    110 {
    111     int n = read ( fd, buffer, len );
    112 
    113     if ( n > 0 ) {
    114         char *p;
    115 
    116         buffer [len-1] = 0;
    117         p = strchr ( buffer, '\n' );
    118 
    119         if ( p ) {
    120             off_t offset;
    121 
    122             offset = lseek ( fd, 0L, SEEK_CUR );               // Get the current file descriptor offset
    123             lseek ( fd, offset-n + (p-buffer) + 1, SEEK_SET ); // Set the file descriptor offset to right after the \n
    124 
    125             p[1] = 0;
    126         }
    127         return buffer;
    128     }
    129 
    130     else
    131         return 0;
    13292}
    13393
     
    13595 * This function appends an option to a list
    13696 */
    137 static struct mod_opt_t *append_option( struct mod_opt_t *opt_list, char *opt )
     97static struct mod_opt_t *append_option(struct mod_opt_t *opt_list, char *opt)
    13898{
    13999    struct mod_opt_t *ol = opt_list;
    140100
    141     if( ol ) {
    142         while( ol-> m_next ) {
    143             ol = ol-> m_next;
    144         }
    145         ol-> m_next = xmalloc( sizeof( struct mod_opt_t ) );
    146         ol = ol-> m_next;
     101    if (ol) {
     102        while (ol->m_next) {
     103            ol = ol->m_next;
     104        }
     105        ol->m_next = xmalloc(sizeof(struct mod_opt_t));
     106        ol = ol->m_next;
    147107    } else {
    148         ol = opt_list = xmalloc( sizeof( struct mod_opt_t ) );
    149     }
    150 
    151     ol-> m_opt_val = bb_xstrdup( opt );
    152     ol-> m_next = NULL;
     108        ol = opt_list = xmalloc(sizeof(struct mod_opt_t));
     109    }
     110
     111    ol->m_opt_val = xstrdup(opt);
     112    ol->m_next = NULL;
    153113
    154114    return opt_list;
     
    156116
    157117#if ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS
    158 /* static char* parse_command_string( char* src, char **dst );
     118/* static char* parse_command_string(char* src, char **dst);
    159119 *   src: pointer to string containing argument
    160120 *   dst: pointer to where to store the parsed argument
    161121 *   return value: the pointer to the first char after the parsed argument,
    162122 *                 NULL if there was no argument parsed (only trailing spaces).
    163  *   Note that memory is allocated with bb_xstrdup when a new argument was
     123 *   Note that memory is allocated with xstrdup when a new argument was
    164124 *   parsed. Don't forget to free it!
    165125 */
     
    167127#define ARG_IN_DQUOTES 0x01
    168128#define ARG_IN_SQUOTES 0x02
    169 static char *parse_command_string( char *src, char **dst )
     129static char *parse_command_string(char *src, char **dst)
    170130{
    171131    int opt_status = ARG_EMPTY;
     
    173133
    174134    /* Dumb you, I have nothing to do... */
    175     if( src == NULL ) return src;
     135    if (src == NULL) return src;
    176136
    177137    /* Skip leading spaces */
    178     while( *src == ' ' ) {
     138    while (*src == ' ') {
    179139        src++;
    180140    }
    181141    /* Is the end of string reached? */
    182     if( *src == '\0' ) {
     142    if (*src == '\0') {
    183143        return NULL;
    184144    }
     
    186146     * By the way, we duplicate a little too much
    187147     * here but what is too much is freed later. */
    188     *dst = tmp_str = bb_xstrdup( src );
     148    *dst = tmp_str = xstrdup(src);
    189149    /* Get to the end of that argument */
    190     while(    ( *tmp_str != '\0' )
    191            && (    ( *tmp_str != ' ' )
    192             || ( opt_status & ( ARG_IN_DQUOTES | ARG_IN_SQUOTES ) ) ) ) {
    193         switch( *tmp_str ) {
    194             case '\'':
    195                 if( opt_status & ARG_IN_DQUOTES ) {
    196                     /* Already in double quotes, keep current char as is */
    197                 } else {
    198                     /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
    199                     memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
    200                     /* mark me: we enter or leave single quotes */
    201                     opt_status ^= ARG_IN_SQUOTES;
    202                     /* Back one char, as we need to re-scan the new char there. */
    203                     tmp_str--;
    204                 }
     150    while (*tmp_str != '\0'
     151     && (*tmp_str != ' ' || (opt_status & (ARG_IN_DQUOTES | ARG_IN_SQUOTES)))
     152    ) {
     153        switch (*tmp_str) {
     154        case '\'':
     155            if (opt_status & ARG_IN_DQUOTES) {
     156                /* Already in double quotes, keep current char as is */
     157            } else {
     158                /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
     159                memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
     160                /* mark me: we enter or leave single quotes */
     161                opt_status ^= ARG_IN_SQUOTES;
     162                /* Back one char, as we need to re-scan the new char there. */
     163                tmp_str--;
     164            }
    205165            break;
    206             case '"':
    207                 if( opt_status & ARG_IN_SQUOTES ) {
    208                     /* Already in single quotes, keep current char as is */
    209                 } else {
    210                     /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
    211                     memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
    212                     /* mark me: we enter or leave double quotes */
    213                     opt_status ^= ARG_IN_DQUOTES;
    214                     /* Back one char, as we need to re-scan the new char there. */
    215                     tmp_str--;
    216                 }
     166        case '"':
     167            if (opt_status & ARG_IN_SQUOTES) {
     168                /* Already in single quotes, keep current char as is */
     169            } else {
     170                /* shift left 1 char, until end of string: get rid of the opening/closing quotes */
     171                memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
     172                /* mark me: we enter or leave double quotes */
     173                opt_status ^= ARG_IN_DQUOTES;
     174                /* Back one char, as we need to re-scan the new char there. */
     175                tmp_str--;
     176            }
    217177            break;
    218             case '\\':
    219                 if( opt_status & ARG_IN_SQUOTES ) {
    220                     /* Between single quotes: keep as is. */
    221                 } else {
    222                     switch( *(tmp_str+1) ) {
    223                         case 'a':
    224                         case 'b':
    225                         case 't':
    226                         case 'n':
    227                         case 'v':
    228                         case 'f':
    229                         case 'r':
    230                         case '0':
    231                             /* We escaped a special character. For now, keep
    232                             * both the back-slash and the following char. */
    233                             tmp_str++; src++;
    234                             break;
    235                         default:
    236                             /* We escaped a space or a single or double quote,
    237                             * or a back-slash, or a non-escapable char. Remove
    238                             * the '\' and keep the new current char as is. */
    239                             memmove( tmp_str, tmp_str + 1, strlen( tmp_str ) );
    240                             break;
    241                     }
    242                 }
     178        case '\\':
     179            if (opt_status & ARG_IN_SQUOTES) {
     180                /* Between single quotes: keep as is. */
     181            } else {
     182                switch (*(tmp_str+1)) {
     183                case 'a':
     184                case 'b':
     185                case 't':
     186                case 'n':
     187                case 'v':
     188                case 'f':
     189                case 'r':
     190                case '0':
     191                    /* We escaped a special character. For now, keep
     192                    * both the back-slash and the following char. */
     193                    tmp_str++; src++;
     194                    break;
     195                default:
     196                    /* We escaped a space or a single or double quote,
     197                    * or a back-slash, or a non-escapable char. Remove
     198                    * the '\' and keep the new current char as is. */
     199                    memmove(tmp_str, tmp_str + 1, strlen(tmp_str));
     200                    break;
     201                }
     202            }
    243203            break;
    244             /* Any other char that is special shall appear here.
    245             * Example: $ starts a variable
    246             case '$':
    247                 do_variable_expansion();
    248                 break;
    249             * */
    250             default:
    251                 /* any other char is kept as is. */
    252                 break;
     204        /* Any other char that is special shall appear here.
     205        * Example: $ starts a variable
     206        case '$':
     207            do_variable_expansion();
     208            break;
     209        * */
     210        default:
     211            /* any other char is kept as is. */
     212            break;
    253213        }
    254214        tmp_str++; /* Go to next char */
     
    256216    }
    257217    /* End of string, but still no ending quote */
    258     if( opt_status & ( ARG_IN_DQUOTES | ARG_IN_SQUOTES ) ) {
    259         bb_error_msg_and_die( "unterminated (single or double) quote in options list: %s", src );
     218    if (opt_status & (ARG_IN_DQUOTES | ARG_IN_SQUOTES)) {
     219        bb_error_msg_and_die("unterminated (single or double) quote in options list: %s", src);
    260220    }
    261221    *tmp_str++ = '\0';
    262     *dst = xrealloc( *dst, (tmp_str - *dst ) );
     222    *dst = xrealloc(*dst, (tmp_str - *dst));
    263223    return src;
    264224}
     
    271231 * (/etc/modprobe.conf syntax). It supports includes (only files, no directories).
    272232 */
    273 static void include_conf ( struct dep_t **first, struct dep_t **current, char *buffer, int buflen, int fd )
     233static void include_conf(struct dep_t **first, struct dep_t **current, char *buffer, int buflen, int fd)
    274234{
    275235    int continuation_line = 0;
    276236
    277     // alias parsing is not 100% correct (no correct handling of continuation lines within an alias) !
    278 
    279     while ( reads ( fd, buffer, buflen)) {
     237    // alias parsing is not 100% correct (no correct handling of continuation lines within an alias)!
     238
     239    while (reads(fd, buffer, buflen)) {
    280240        int l;
    281241        char *p;
    282242
    283         p = strchr ( buffer, '#' );
    284         if ( p )
     243        p = strchr(buffer, '#');
     244        if (p)
    285245            *p = 0;
    286246
    287         l = strlen ( buffer );
    288 
    289         while ( l && isspace ( buffer [l-1] )) {
    290             buffer [l-1] = 0;
     247        l = strlen(buffer);
     248
     249        while (l && isspace(buffer[l-1])) {
     250            buffer[l-1] = 0;
    291251            l--;
    292252        }
    293253
    294         if ( l == 0 ) {
     254        if (l == 0) {
    295255            continuation_line = 0;
    296256            continue;
    297257        }
    298258
    299         if ( !continuation_line ) {
    300             if (( strncmp ( buffer, "alias", 5 ) == 0 ) && isspace ( buffer [5] )) {
     259        if (!continuation_line) {
     260            if ((strncmp(buffer, "alias", 5) == 0) && isspace(buffer[5])) {
    301261                char *alias, *mod;
    302262
    303                 if ( parse_tag_value ( buffer + 6, &alias, &mod )) {
     263                if (parse_tag_value(buffer + 6, &alias, &mod)) {
    304264                    /* handle alias as a module dependent on the aliased module */
    305                     if ( !*current ) {
    306                         (*first) = (*current) = (struct dep_t *) xcalloc ( 1, sizeof ( struct dep_t ));
     265                    if (!*current) {
     266                        (*first) = (*current) = xzalloc(sizeof(struct dep_t));
     267                    } else {
     268                        (*current)->m_next = xzalloc(sizeof(struct dep_t));
     269                        (*current) = (*current)->m_next;
    307270                    }
    308                     else {
    309                         (*current)-> m_next = (struct dep_t *) xcalloc ( 1, sizeof ( struct dep_t ));
    310                         (*current) = (*current)-> m_next;
     271                    (*current)->m_name  = xstrdup(alias);
     272                    (*current)->m_isalias = 1;
     273
     274                    if ((strcmp(mod, "off") == 0) || (strcmp(mod, "null") == 0)) {
     275                        (*current)->m_depcnt = 0;
     276                        (*current)->m_deparr = 0;
     277                    } else {
     278                        (*current)->m_depcnt  = 1;
     279                        (*current)->m_deparr  = xmalloc(1 * sizeof(char *));
     280                        (*current)->m_deparr[0] = xstrdup(mod);
    311281                    }
    312                     (*current)-> m_name  = bb_xstrdup ( alias );
    313                     (*current)-> m_isalias = 1;
    314 
    315                     if (( strcmp ( mod, "off" ) == 0 ) || ( strcmp ( mod, "null" ) == 0 )) {
    316                         (*current)-> m_depcnt = 0;
    317                         (*current)-> m_deparr = 0;
    318                     }
    319                     else {
    320                         (*current)-> m_depcnt  = 1;
    321                         (*current)-> m_deparr  = xmalloc ( 1 * sizeof( char * ));
    322                         (*current)-> m_deparr[0] = bb_xstrdup ( mod );
    323                     }
    324                     (*current)-> m_next    = 0;
    325                 }
    326             }
    327             else if (( strncmp ( buffer, "options", 7 ) == 0 ) && isspace ( buffer [7] )) {
     282                    (*current)->m_next    = 0;
     283                }
     284            } else if ((strncmp(buffer, "options", 7) == 0) && isspace(buffer[7])) {
    328285                char *mod, *opt;
    329286
    330287                /* split the line in the module/alias name, and options */
    331                 if ( parse_tag_value ( buffer + 8, &mod, &opt )) {
     288                if (parse_tag_value(buffer + 8, &mod, &opt)) {
    332289                    struct dep_t *dt;
    333290
    334291                    /* find the corresponding module */
    335                     for ( dt = *first; dt; dt = dt-> m_next ) {
    336                         if ( strcmp ( dt-> m_name, mod ) == 0 )
     292                    for (dt = *first; dt; dt = dt->m_next) {
     293                        if (strcmp(dt->m_name, mod) == 0)
    337294                            break;
    338295                    }
    339                     if ( dt ) {
    340                         if ( ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS ) {
     296                    if (dt) {
     297                        if (ENABLE_FEATURE_MODPROBE_MULTIPLE_OPTIONS) {
    341298                            char* new_opt = NULL;
    342                             while( ( opt = parse_command_string( opt, &new_opt ) ) ) {
    343                                 dt-> m_options = append_option( dt-> m_options, new_opt );
     299                            while ((opt = parse_command_string(opt, &new_opt))) {
     300                                dt->m_options = append_option(dt->m_options, new_opt);
    344301                            }
    345302                        } else {
    346                             dt-> m_options = append_option( dt-> m_options, opt );
     303                            dt->m_options = append_option(dt->m_options, opt);
    347304                        }
    348305                    }
    349306                }
    350             }
    351             else if (( strncmp ( buffer, "include", 7 ) == 0 ) && isspace ( buffer [7] )) {
    352 
    353                 int fdi; char *filename = buffer + 8;
    354 
    355                 while ( isspace ( *filename ))
    356                     filename++;
    357 
    358                 if (( fdi = open ( filename, O_RDONLY )) >= 0 ) {
     307            } else if ((strncmp(buffer, "include", 7) == 0) && isspace(buffer[7])) {
     308                int fdi; char *filename;
     309
     310                filename = skip_whitespace(buffer + 8);
     311
     312                if ((fdi = open(filename, O_RDONLY)) >= 0) {
    359313                    include_conf(first, current, buffer, buflen, fdi);
    360314                    close(fdi);
     
    366320
    367321/*
    368  * This function builds a list of dependency rules from /lib/modules/`uname -r`\modules.dep.
     322 * This function builds a list of dependency rules from /lib/modules/`uname -r`/modules.dep.
    369323 * It then fills every modules and aliases with their default options, found by parsing
    370324 * modprobe.conf (or modules.conf, or conf.modules).
    371325 */
    372 static struct dep_t *build_dep ( void )
     326static struct dep_t *build_dep(void)
    373327{
    374328    int fd;
     
    381335    int k_version;
    382336
     337    if (uname(&un))
     338        bb_error_msg_and_die("can't determine kernel version");
     339
    383340    k_version = 0;
    384     if ( uname ( &un ))
    385         bb_error_msg_and_die("can't determine kernel version");
    386 
    387341    if (un.release[0] == '2') {
    388342        k_version = un.release[2] - '0';
    389343    }
    390344
    391     filename = bb_xasprintf("/lib/modules/%s/modules.dep", un.release );
    392     fd = open ( filename, O_RDONLY );
     345    filename = xasprintf("/lib/modules/%s/modules.dep", un.release);
     346    fd = open(filename, O_RDONLY);
    393347    if (ENABLE_FEATURE_CLEAN_UP)
    394348        free(filename);
    395349    if (fd < 0) {
    396350        /* Ok, that didn't work.  Fall back to looking in /lib/modules */
    397         if (( fd = open ( "/lib/modules/modules.dep", O_RDONLY )) < 0 ) {
     351        fd = open("/lib/modules/modules.dep", O_RDONLY);
     352        if (fd < 0) {
    398353            return 0;
    399354        }
    400355    }
    401356
    402     while ( reads ( fd, buffer, sizeof( buffer ))) {
    403         int l = strlen ( buffer );
     357    while (reads(fd, buffer, sizeof(buffer))) {
     358        int l = strlen(buffer);
    404359        char *p = 0;
    405360
    406         while ( l > 0 && isspace ( buffer [l-1] )) {
    407             buffer [l-1] = 0;
     361        while (l > 0 && isspace(buffer[l-1])) {
     362            buffer[l-1] = 0;
    408363            l--;
    409364        }
    410365
    411         if ( l == 0 ) {
     366        if (l == 0) {
    412367            continuation_line = 0;
    413368            continue;
     
    415370
    416371        /* Is this a new module dep description? */
    417         if ( !continuation_line ) {
     372        if (!continuation_line) {
    418373            /* find the dep beginning */
    419             char *col = strchr ( buffer, ':' );
     374            char *col = strchr(buffer, ':');
    420375            char *dot = col;
    421376
    422             if ( col ) {
     377            if (col) {
    423378                /* This line is a dep description */
    424                 char *mods;
     379                const char *mods;
    425380                char *modpath;
    426381                char *mod;
     
    428383                /* Find the beginning of the module file name */
    429384                *col = 0;
    430                 mods = strrchr ( buffer, '/' );
    431 
    432                 if ( !mods )
    433                     mods = buffer; /* no path for this module */
    434                 else
    435                     mods++; /* there was a path for this module... */
     385                mods = bb_basename(buffer);
    436386
    437387                /* find the path of the module */
    438                 modpath = strchr ( buffer, '/' ); /* ... and this is the path */
    439                 if ( !modpath )
     388                modpath = strchr(buffer, '/'); /* ... and this is the path */
     389                if (!modpath)
    440390                    modpath = buffer; /* module with no path */
    441391                /* find the end of the module name in the file name */
    442                 if ( ENABLE_FEATURE_2_6_MODULES &&
    443                      (k_version > 4) && ( *(col-3) == '.' ) &&
    444                      ( *(col-2) == 'k' ) && ( *(col-1) == 'o' ) )
     392                if (ENABLE_FEATURE_2_6_MODULES &&
     393                     (k_version > 4) && (*(col-3) == '.') &&
     394                    (*(col-2) == 'k') && (*(col-1) == 'o'))
    445395                    dot = col - 3;
    446396                else
    447                     if (( *(col-2) == '.' ) && ( *(col-1) == 'o' ))
     397                    if ((*(col-2) == '.') && (*(col-1) == 'o'))
    448398                        dot = col - 2;
    449399
    450                 mod = bb_xstrndup ( mods, dot - mods );
     400                mod = xstrndup(mods, dot - mods);
    451401
    452402                /* enqueue new module */
    453                 if ( !current ) {
    454                     first = current = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
    455                 }
    456                 else {
    457                     current-> m_next = (struct dep_t *) xmalloc ( sizeof ( struct dep_t ));
    458                     current = current-> m_next;
    459                 }
    460                 current-> m_name  = mod;
    461                 current-> m_path  = bb_xstrdup(modpath);
    462                 current-> m_options = NULL;
    463                 current-> m_isalias = 0;
    464                 current-> m_depcnt  = 0;
    465                 current-> m_deparr  = 0;
    466                 current-> m_next    = 0;
     403                if (!current) {
     404                    first = current = xmalloc(sizeof(struct dep_t));
     405                } else {
     406                    current->m_next = xmalloc(sizeof(struct dep_t));
     407                    current = current->m_next;
     408                }
     409                current->m_name    = mod;
     410                current->m_path    = xstrdup(modpath);
     411                current->m_options = NULL;
     412                current->m_isalias = 0;
     413                current->m_depcnt  = 0;
     414                current->m_deparr  = 0;
     415                current->m_next    = 0;
    467416
    468417                p = col + 1;
    469             }
    470             else
     418            } else
    471419                /* this line is not a dep description */
    472420                p = 0;
    473         }
    474         else
     421        } else
    475422            /* It's a dep description continuation */
    476423            p = buffer;
    477424
    478         while ( p && *p && isblank(*p))
     425        while (p && *p && isblank(*p))
    479426            p++;
    480427
    481428        /* p points to the first dependable module; if NULL, no dependable module */
    482         if ( p && *p ) {
    483             char *end = &buffer [l-1];
    484             char *deps;
     429        if (p && *p) {
     430            char *end = &buffer[l-1];
     431            const char *deps;
    485432            char *dep;
    486433            char *next;
    487434            int ext = 0;
    488435
    489             while ( isblank ( *end ) || ( *end == '\\' ))
     436            while (isblank(*end) || (*end == '\\'))
    490437                end--;
    491438
    492             do
    493             {
     439            do {
    494440                /* search the end of the dependency */
    495                 next = strchr (p, ' ' );
    496                 if (next)
    497                 {
     441                next = strchr(p, ' ');
     442                if (next) {
    498443                    *next = 0;
    499444                    next--;
    500                 }
    501                 else
     445                } else
    502446                    next = end;
    503447
    504448                /* find the beginning of the module file name */
    505                 deps = strrchr ( p, '/' );
    506 
    507                 if ( !deps || ( deps < p )) {
    508                     deps = p;
    509 
    510                     while ( isblank ( *deps ))
     449                deps = bb_basename(p);
     450                if (deps == p) {
     451                    while (isblank(*deps))
    511452                        deps++;
    512453                }
    513                 else
    514                     deps++;
    515454
    516455                /* find the end of the module name in the file name */
    517                 if ( ENABLE_FEATURE_2_6_MODULES &&
    518                      (k_version > 4) && ( *(next-2) == '.' ) &&
    519                      ( *(next-1) == 'k' )  && ( *next == 'o' ) )
     456                if (ENABLE_FEATURE_2_6_MODULES
     457                 && (k_version > 4) && (*(next-2) == '.')
     458                 && (*(next-1) == 'k') && (*next == 'o'))
    520459                    ext = 3;
    521460                else
    522                     if (( *(next-1) == '.' ) && ( *next == 'o' ))
     461                    if ((*(next-1) == '.') && (*next == 'o'))
    523462                        ext = 2;
    524463
     
    526465                if ((next-deps-ext+1) <= 0)
    527466                    continue;
    528                 dep = bb_xstrndup ( deps, next - deps - ext + 1 );
     467                dep = xstrndup(deps, next - deps - ext + 1);
    529468
    530469                /* Add the new dependable module name */
    531                 current-> m_depcnt++;
    532                 current-> m_deparr = (char **) xrealloc ( current-> m_deparr,
    533                         sizeof ( char *) * current-> m_depcnt );
    534                 current-> m_deparr [current-> m_depcnt - 1] = dep;
     470                current->m_depcnt++;
     471                current->m_deparr = xrealloc(current->m_deparr,
     472                        sizeof(char *) * current->m_depcnt);
     473                current->m_deparr[current->m_depcnt - 1] = dep;
    535474
    536475                p = next + 2;
     
    539478
    540479        /* is there other dependable module(s) ? */
    541         if ( buffer [l-1] == '\\' )
     480        if (buffer[l-1] == '\\')
    542481            continuation_line = 1;
    543482        else
    544483            continuation_line = 0;
    545484    }
    546     close ( fd );
     485    close(fd);
    547486
    548487    /*
    549488     * First parse system-specific options and aliases
    550489     * as they take precedence over the kernel ones.
     490     * >=2.6: we only care about modprobe.conf
     491     * <=2.4: we care about modules.conf and conf.modules
    551492     */
    552     if (!ENABLE_FEATURE_2_6_MODULES
    553             || ( fd = open ( "/etc/modprobe.conf", O_RDONLY )) < 0 )
    554         if (( fd = open ( "/etc/modules.conf", O_RDONLY )) < 0 )
    555             fd = open ( "/etc/conf.modules", O_RDONLY );
     493    if (ENABLE_FEATURE_2_6_MODULES
     494     && (fd = open("/etc/modprobe.conf", O_RDONLY)) < 0)
     495        if (ENABLE_FEATURE_2_4_MODULES
     496         && (fd = open("/etc/modules.conf", O_RDONLY)) < 0)
     497            if (ENABLE_FEATURE_2_4_MODULES)
     498                fd = open("/etc/conf.modules", O_RDONLY);
    556499
    557500    if (fd >= 0) {
    558         include_conf (&first, &current, buffer, sizeof(buffer), fd);
     501        include_conf(&first, &current, buffer, sizeof(buffer), fd);
    559502        close(fd);
    560503    }
     
    562505    /* Only 2.6 has a modules.alias file */
    563506    if (ENABLE_FEATURE_2_6_MODULES) {
    564         /* Parse kernel-declared aliases */
    565         filename = bb_xasprintf("/lib/modules/%s/modules.alias", un.release);
    566         if ((fd = open ( filename, O_RDONLY )) < 0) {
     507        /* Parse kernel-declared module aliases */
     508        filename = xasprintf("/lib/modules/%s/modules.alias", un.release);
     509        fd = open(filename, O_RDONLY);
     510        if (fd < 0) {
    567511            /* Ok, that didn't work.  Fall back to looking in /lib/modules */
    568             fd = open ( "/lib/modules/modules.alias", O_RDONLY );
     512            fd = open("/lib/modules/modules.alias", O_RDONLY);
    569513        }
    570514        if (ENABLE_FEATURE_CLEAN_UP)
     
    572516
    573517        if (fd >= 0) {
    574             include_conf (&first, &current, buffer, sizeof(buffer), fd);
     518            include_conf(&first, &current, buffer, sizeof(buffer), fd);
    575519            close(fd);
    576520        }
     521
     522        /* Parse kernel-declared symbol aliases */
     523        filename = xasprintf("/lib/modules/%s/modules.symbols", un.release);
     524        fd = open(filename, O_RDONLY);
     525        if (fd < 0) {
     526            /* Ok, that didn't work.  Fall back to looking in /lib/modules */
     527            fd = open("/lib/modules/modules.symbols", O_RDONLY);
     528        }
     529        if (ENABLE_FEATURE_CLEAN_UP)
     530            free(filename);
     531
     532        if (fd >= 0) {
     533            include_conf(&first, &current, buffer, sizeof(buffer), fd);
     534            close(fd);
     535        }
    577536    }
    578537
     
    581540
    582541/* return 1 = loaded, 0 = not loaded, -1 = can't tell */
    583 static int already_loaded (const char *name)
     542static int already_loaded(const char *name)
    584543{
    585544    int fd, ret = 0;
    586545    char buffer[4096];
    587546
    588     fd = open ("/proc/modules", O_RDONLY);
     547    fd = open("/proc/modules", O_RDONLY);
    589548    if (fd < 0)
    590549        return -1;
    591550
    592     while ( reads ( fd, buffer, sizeof( buffer ))) {
     551    while (reads(fd, buffer, sizeof(buffer))) {
    593552        char *p;
    594553
     
    621580}
    622581
    623 static int mod_process ( struct mod_list_t *list, int do_insert )
     582static int mod_process(const struct mod_list_t *list, int do_insert)
    624583{
    625584    int rc = 0;
     
    629588    int argc;
    630589
    631     while ( list ) {
     590    while (list) {
    632591        argc = 0;
    633         if( ENABLE_FEATURE_CLEAN_UP )
     592        if (ENABLE_FEATURE_CLEAN_UP)
    634593            argc_malloc = 0;
    635594        /* If CONFIG_FEATURE_CLEAN_UP is not defined, then we leak memory
     
    644603         * problem. */
    645604        /* enough for minimal insmod (5 args + NULL) or rmmod (3 args + NULL) */
    646         argv = (char**) malloc( 6 * sizeof( char* ) );
    647         if ( do_insert ) {
    648             if (already_loaded (list->m_name) != 1) {
    649                 argv[argc++] = "insmod";
     605        argv = xmalloc(6 * sizeof(char*));
     606        if (do_insert) {
     607            if (already_loaded(list->m_name) != 1) {
     608                argv[argc++] = (char*)"insmod";
    650609                if (ENABLE_FEATURE_2_4_MODULES) {
    651610                    if (do_syslog)
    652                         argv[argc++] = "-s";
     611                        argv[argc++] = (char*)"-s";
    653612                    if (autoclean)
    654                         argv[argc++] = "-k";
     613                        argv[argc++] = (char*)"-k";
    655614                    if (quiet)
    656                         argv[argc++] = "-q";
    657                     else if(verbose) /* verbose and quiet are mutually exclusive */
    658                         argv[argc++] = "-v";
    659                 }
    660                 argv[argc++] = list-> m_path;
    661                 if( ENABLE_FEATURE_CLEAN_UP )
     615                        argv[argc++] = (char*)"-q";
     616                    else if (verbose) /* verbose and quiet are mutually exclusive */
     617                        argv[argc++] = (char*)"-v";
     618                }
     619                argv[argc++] = list->m_path;
     620                if (ENABLE_FEATURE_CLEAN_UP)
    662621                    argc_malloc = argc;
    663                 opts = list-> m_options;
    664                 while( opts ) {
     622                opts = list->m_options;
     623                while (opts) {
    665624                    /* Add one more option */
    666625                    argc++;
    667                     argv = (char**) xrealloc( argv, ( argc + 1 ) * sizeof( char* ) );
    668                     argv[argc-1] = opts-> m_opt_val;
    669                     opts = opts-> m_next;
     626                    argv = xrealloc(argv,(argc + 1)* sizeof(char*));
     627                    argv[argc-1] = opts->m_opt_val;
     628                    opts = opts->m_next;
    670629                }
    671630            }
    672631        } else {
    673632            /* modutils uses short name for removal */
    674             if (already_loaded (list->m_name) != 0) {
    675                 argv[argc++] = "rmmod";
     633            if (already_loaded(list->m_name) != 0) {
     634                argv[argc++] = (char*)"rmmod";
    676635                if (do_syslog)
    677                     argv[argc++] = "-s";
    678                 argv[argc++] = list->m_name;
    679                 if( ENABLE_FEATURE_CLEAN_UP )
     636                    argv[argc++] = (char*)"-s";
     637                argv[argc++] = (char*)list->m_name;
     638                if (ENABLE_FEATURE_CLEAN_UP)
    680639                    argc_malloc = argc;
    681640            }
     
    685644        if (argc) {
    686645            if (verbose) {
    687                 printf("%s module %s\n", do_insert?"Loading":"Unloading", list-> m_name );
     646                printf("%s module %s\n", do_insert?"Loading":"Unloading", list->m_name);
    688647            }
    689648            if (!show_only) {
    690                 int rc2 = wait4pid(bb_spawn(argv));
     649                int rc2 = wait4pid(spawn(argv));
    691650
    692651                if (do_insert) {
    693652                    rc = rc2; /* only last module matters */
    694                 }
    695                 else if (!rc2) {
     653                } else if (!rc2) {
    696654                    rc = 0; /* success if remove any mod */
    697655                }
    698656            }
    699             if( ENABLE_FEATURE_CLEAN_UP )
     657            if (ENABLE_FEATURE_CLEAN_UP) {
    700658                /* the last value in the array has index == argc, but
    701659                 * it is the terminating NULL, so we must not free it. */
    702                 while( argc_malloc < argc ) {
    703                     free( argv[argc_malloc++] );
    704             }
    705         }
    706         if( ENABLE_FEATURE_CLEAN_UP ) {
    707             free( argv );
     660                while (argc_malloc < argc) {
     661                    free(argv[argc_malloc++]);
     662                }
     663            }
     664        }
     665        if (ENABLE_FEATURE_CLEAN_UP) {
     666            free(argv);
    708667            argv = NULL;
    709668        }
    710         list = do_insert ? list-> m_prev : list-> m_next;
     669        list = do_insert ? list->m_prev : list->m_next;
    711670    }
    712671    return (show_only) ? 0 : rc;
     672}
     673
     674/*
     675 * Check the matching between a pattern and a module name.
     676 * We need this as *_* is equivalent to *-*, even in pattern matching.
     677 */
     678static int check_pattern(const char* pat_src, const char* mod_src)
     679{
     680    int ret;
     681
     682    if (ENABLE_FEATURE_MODPROBE_FANCY_ALIAS) {
     683        char* pat;
     684        char* mod;
     685        char* p;
     686
     687        pat = xstrdup(pat_src);
     688        mod = xstrdup(mod_src);
     689
     690        for (p = pat; (p = strchr(p, '-')); *p++ = '_');
     691        for (p = mod; (p = strchr(p, '-')); *p++ = '_');
     692
     693        ret = fnmatch(pat, mod, 0);
     694
     695        if (ENABLE_FEATURE_CLEAN_UP) {
     696            free(pat);
     697            free(mod);
     698        }
     699
     700        return ret;
     701    } else {
     702        return fnmatch(pat_src, mod_src, 0);
     703    }
    713704}
    714705
     
    718709 * tail: the lowest module in the stack (first to insmod, last to rmmod)
    719710 */
    720 static void check_dep ( char *mod, struct mod_list_t **head, struct mod_list_t **tail )
     711static void check_dep(char *mod, struct mod_list_t **head, struct mod_list_t **tail)
    721712{
    722713    struct mod_list_t *find;
     
    730721     * Of course if the name in the dependency rule is a plain string,
    731722     * then we consider it a pattern, and matching will still work. */
    732     for ( dt = depend; dt; dt = dt-> m_next ) {
    733         if ( fnmatch ( dt-> m_name, mod, 0 ) == 0) {
     723    for (dt = depend; dt; dt = dt->m_next) {
     724        if (check_pattern(dt->m_name, mod) == 0) {
    734725            break;
    735726        }
    736727    }
    737728
    738     if( !dt ) {
    739         bb_error_msg ("module %s not found.", mod);
     729    if (!dt) {
     730        bb_error_msg("module %s not found", mod);
    740731        return;
    741732    }
    742733
    743734    // resolve alias names
    744     while ( dt-> m_isalias ) {
    745         if ( dt-> m_depcnt == 1 ) {
     735    while (dt->m_isalias) {
     736        if (dt->m_depcnt == 1) {
    746737            struct dep_t *adt;
    747738
    748             for ( adt = depend; adt; adt = adt-> m_next ) {
    749                 if ( strcmp ( adt-> m_name, dt-> m_deparr [0] ) == 0 )
     739            for (adt = depend; adt; adt = adt->m_next) {
     740                if (check_pattern(adt->m_name, dt->m_deparr[0]) == 0)
    750741                    break;
    751742            }
    752             if ( adt ) {
     743            if (adt) {
    753744                /* This is the module we are aliased to */
    754                 struct mod_opt_t *opts = dt-> m_options;
     745                struct mod_opt_t *opts = dt->m_options;
    755746                /* Option of the alias are appended to the options of the module */
    756                 while( opts ) {
    757                     adt-> m_options = append_option( adt-> m_options, opts-> m_opt_val );
    758                     opts = opts-> m_next;
     747                while (opts) {
     748                    adt->m_options = append_option(adt->m_options, opts->m_opt_val);
     749                    opts = opts->m_next;
    759750                }
    760751                dt = adt;
    761             }
    762             else {
    763                 bb_error_msg ("module %s not found.", mod);
     752            } else {
     753                bb_error_msg("module %s not found", mod);
    764754                return;
    765755            }
    766         }
    767         else {
    768             bb_error_msg ("Bad alias %s", dt-> m_name);
     756        } else {
     757            bb_error_msg("bad alias %s", dt->m_name);
    769758            return;
    770759        }
    771760    }
    772761
    773     mod = dt-> m_name;
    774     path = dt-> m_path;
    775     opt = dt-> m_options;
     762    mod = dt->m_name;
     763    path = dt->m_path;
     764    opt = dt->m_options;
    776765
    777766    // search for duplicates
    778     for ( find = *head; find; find = find-> m_next ) {
    779         if ( !strcmp ( mod, find-> m_name )) {
    780             // found -> dequeue it
    781 
    782             if ( find-> m_prev )
    783                 find-> m_prev-> m_next = find-> m_next;
     767    for (find = *head; find; find = find->m_next) {
     768        if (!strcmp(mod, find->m_name)) {
     769            // found ->dequeue it
     770
     771            if (find->m_prev)
     772                find->m_prev->m_next = find->m_next;
    784773            else
    785                 *head = find-> m_next;
    786 
    787             if ( find-> m_next )
    788                 find-> m_next-> m_prev = find-> m_prev;
     774                *head = find->m_next;
     775
     776            if (find->m_next)
     777                find->m_next->m_prev = find->m_prev;
    789778            else
    790                 *tail = find-> m_prev;
     779                *tail = find->m_prev;
    791780
    792781            break; // there can be only one duplicate
     
    794783    }
    795784
    796     if ( !find ) { // did not find a duplicate
    797         find = (struct mod_list_t *) xmalloc ( sizeof(struct mod_list_t));
    798         find-> m_name = mod;
    799         find-> m_path = path;
    800         find-> m_options = opt;
     785    if (!find) { // did not find a duplicate
     786        find = xmalloc(sizeof(struct mod_list_t));
     787        find->m_name = mod;
     788        find->m_path = path;
     789        find->m_options = opt;
    801790    }
    802791
    803792    // enqueue at tail
    804     if ( *tail )
    805         (*tail)-> m_next = find;
    806     find-> m_prev  = *tail;
    807     find-> m_next  = 0;
    808 
    809     if ( !*head )
     793    if (*tail)
     794        (*tail)->m_next = find;
     795    find->m_prev = *tail;
     796    find->m_next = 0;
     797
     798    if (!*head)
    810799        *head = find;
    811800    *tail = find;
    812801
    813     if ( dt ) {
     802    if (dt) {
    814803        int i;
    815804
    816805        /* Add all dependable module for that new module */
    817         for ( i = 0; i < dt-> m_depcnt; i++ )
    818             check_dep ( dt-> m_deparr [i], head, tail );
    819     }
    820 }
    821 
    822 static int mod_insert ( char *mod, int argc, char **argv )
    823 {
    824     struct mod_list_t *tail = 0;
    825     struct mod_list_t *head = 0;
     806        for (i = 0; i < dt->m_depcnt; i++)
     807            check_dep(dt->m_deparr[i], head, tail);
     808    }
     809}
     810
     811static int mod_insert(char *mod, int argc, char **argv)
     812{
     813    struct mod_list_t *tail = NULL;
     814    struct mod_list_t *head = NULL;
    826815    int rc;
    827816
    828817    // get dep list for module mod
    829     check_dep ( mod, &head, &tail );
    830 
    831     if ( head && tail ) {
    832         if( argc ) {
     818    check_dep(mod, &head, &tail);
     819
     820    rc = 1;
     821    if (head && tail) {
     822        if (argc) {
    833823            int i;
    834824            // append module args
    835             for ( i = 0; i < argc; i++ )
    836                 head->m_options = append_option( head->m_options, argv[i] );
     825            for (i = 0; i < argc; i++)
     826                head->m_options = append_option(head->m_options, argv[i]);
    837827        }
    838828
    839829        // process tail ---> head
    840         if ((rc = mod_process ( tail, 1 )) != 0) {
     830        rc = mod_process(tail, 1);
     831        if (rc) {
    841832            /*
    842833             * In case of using udev, multiple instances of modprobe can be
     
    845836             * fail if the module was loaded, and not by us.
    846837             */
    847             if (already_loaded (mod) )
     838            if (already_loaded(mod))
    848839                rc = 0;
    849840        }
    850841    }
    851     else
    852         rc = 1;
    853 
    854842    return rc;
    855843}
    856844
    857 static int mod_remove ( char *mod )
     845static int mod_remove(char *mod)
    858846{
    859847    int rc;
    860     static struct mod_list_t rm_a_dummy = { "-a", NULL, NULL, NULL, NULL };
    861 
    862     struct mod_list_t *head = 0;
    863     struct mod_list_t *tail = 0;
    864 
    865     if ( mod )
    866         check_dep ( mod, &head, &tail );
     848    static const struct mod_list_t rm_a_dummy = { "-a", NULL, NULL, NULL, NULL };
     849
     850    struct mod_list_t *head = NULL;
     851    struct mod_list_t *tail = NULL;
     852
     853    if (mod)
     854        check_dep(mod, &head, &tail);
    867855    else  // autoclean
    868         head = tail = &rm_a_dummy;
    869 
    870     if ( head && tail )
    871         rc = mod_process ( head, 0 );  // process head ---> tail
    872     else
    873         rc = 1;
     856        head = tail = (struct mod_list_t*) &rm_a_dummy;
     857
     858    rc = 1;
     859    if (head && tail)
     860        rc = mod_process(head, 0);  // process head ---> tail
    874861    return rc;
    875 
    876 }
    877 
     862}
     863
     864int modprobe_main(int argc, char** argv);
    878865int modprobe_main(int argc, char** argv)
    879866{
     
    881868    char *unused;
    882869
    883     bb_opt_complementally = "?V-:q-v:v-q";
    884     main_opts = bb_getopt_ulflags(argc, argv, "acdklnqrst:vVC:",
     870    opt_complementary = "?V-:q-v:v-q";
     871    main_opts = getopt32(argv, "acdklnqrst:vVC:",
    885872                            &unused, &unused);
    886     if((main_opts & (DUMP_CONF_EXIT | LIST_ALL)))
    887                 return EXIT_SUCCESS;
    888     if((main_opts & (RESTRICT_DIR | CONFIG_FILE)))
    889                 bb_error_msg_and_die("-t and -C not supported");
    890 
    891     depend = build_dep ( );
    892 
    893     if ( !depend )
    894         bb_error_msg_and_die ( "could not parse modules.dep" );
     873    if (main_opts & (DUMP_CONF_EXIT | LIST_ALL))
     874        return EXIT_SUCCESS;
     875    if (main_opts & (RESTRICT_DIR | CONFIG_FILE))
     876        bb_error_msg_and_die("-t and -C not supported");
     877
     878    depend = build_dep();
     879
     880    if (!depend)
     881        bb_error_msg_and_die("cannot parse modules.dep");
    895882
    896883    if (remove_opt) {
    897884        do {
    898             if (mod_remove ( optind < argc ?
    899                         argv [optind] : NULL )) {
    900                 bb_error_msg ("failed to remove module %s",
    901                         argv [optind] );
     885            if (mod_remove(optind < argc ?
     886                        argv[optind] : NULL)) {
     887                bb_error_msg("failed to remove module %s",
     888                        argv[optind]);
    902889                rc = EXIT_FAILURE;
    903890            }
    904         } while ( ++optind < argc );
     891        } while (++optind < argc);
    905892    } else {
    906893        if (optind >= argc)
    907             bb_error_msg_and_die ( "No module or pattern provided" );
    908 
    909         if ( mod_insert ( argv [optind], argc - optind - 1, argv + optind + 1 ))
    910             bb_error_msg_and_die ( "failed to load module %s", argv [optind] );
     894            bb_error_msg_and_die("no module or pattern provided");
     895
     896        if (mod_insert(argv[optind], argc - optind - 1, argv + optind + 1))
     897            bb_error_msg_and_die("failed to load module %s", argv[optind]);
    911898    }
    912899
  • branches/2.2.5/mindi-busybox/modutils/rmmod.c

    r821 r1765  
    88 */
    99
    10 #include "busybox.h"
    11 #include <stdio.h>
    12 #include <errno.h>
    13 #include <unistd.h>
    14 #include <stdlib.h>
    15 #include <getopt.h>
    16 #include <fcntl.h>
    17 #include <string.h>
    18 #include <sys/utsname.h>
     10#include "libbb.h"
    1911#include <sys/syscall.h>
    2012
    21 #ifdef CONFIG_FEATURE_2_6_MODULES
     13#if ENABLE_FEATURE_2_6_MODULES
    2214static inline void filename2modname(char *modname, const char *afterslash)
    2315{
    2416    unsigned int i;
     17    int kr_chk = 1;
    2518
    26 #if ENABLE_FEATURE_2_4_MODULES
    27     int kr_chk = 1;
    28     if (get_linux_version_code() <= KERNEL_VERSION(2,6,0))
    29         kr_chk = 0;
    30 #else
    31 #define kr_chk 1
    32 #endif
     19    if (ENABLE_FEATURE_2_4_MODULES
     20            && get_linux_version_code() <= KERNEL_VERSION(2,6,0))
     21                kr_chk = 0;
    3322
    3423    /* Convert to underscores, stop at first . */
     
    4130    modname[i] = '\0';
    4231}
     32#else
     33void filename2modname(char *modname, const char *afterslash);
    4334#endif
    4435
     36// There really should be a header file for this...
     37
     38int query_module(const char *name, int which, void *buf,
     39            size_t bufsize, size_t *ret);
     40
     41int rmmod_main(int argc, char **argv);
    4542int rmmod_main(int argc, char **argv)
    4643{
    4744    int n, ret = EXIT_SUCCESS;
    4845    unsigned int flags = O_NONBLOCK|O_EXCL;
    49 #ifdef CONFIG_FEATURE_QUERY_MODULE_INTERFACE
    50     /* bb_common_bufsiz1 hold the module names which we ignore
    51        but must get */
    52     size_t bufsize = sizeof(bb_common_bufsiz1);
    53 #endif
     46
     47#define misc_buf bb_common_bufsiz1
    5448
    5549    /* Parse command line. */
    56     n = bb_getopt_ulflags(argc, argv, "wfa");
    57     if((n & 1)) // --wait
     50    n = getopt32(argv, "wfa");
     51    if (n & 1)  // --wait
    5852        flags &= ~O_NONBLOCK;
    59     if((n & 2)) // --force
     53    if (n & 2)  // --force
    6054        flags |= O_TRUNC;
    61     if((n & 4)) {
     55    if (n & 4) {
    6256        /* Unload _all_ unused modules via NULL delete_module() call */
    6357        /* until the number of modules does not change */
     
    6761        while (nmod != pnmod) {
    6862            if (syscall(__NR_delete_module, NULL, flags) != 0) {
    69                 if (errno==EFAULT)
    70                     return(ret);
     63                if (errno == EFAULT)
     64                    return ret;
    7165                bb_perror_msg_and_die("rmmod");
    7266            }
    7367            pnmod = nmod;
    74 #ifdef CONFIG_FEATURE_QUERY_MODULE_INTERFACE
    75             /* 1 == QM_MODULES */
    76             if (my_query_module(NULL, 1, &bb_common_bufsiz1, &bufsize, &nmod)) {
     68            // the 1 here is QM_MODULES.
     69            if (ENABLE_FEATURE_QUERY_MODULE_INTERFACE && query_module(NULL,
     70                    1, misc_buf, sizeof(misc_buf),
     71                    &nmod))
     72            {
    7773                bb_perror_msg_and_die("QM_MODULES");
    7874            }
    79 #endif
    8075        }
    8176        return EXIT_SUCCESS;
     
    8681
    8782    for (n = optind; n < argc; n++) {
    88 #ifdef CONFIG_FEATURE_2_6_MODULES
    89         const char *afterslash;
    90         char *module_name;
     83        if (ENABLE_FEATURE_2_6_MODULES) {
     84            filename2modname(misc_buf, bb_basename(argv[n]));
     85        }
    9186
    92         afterslash = strrchr(argv[n], '/');
    93         if (!afterslash)
    94             afterslash = argv[n];
    95         else
    96             afterslash++;
    97         module_name = alloca(strlen(afterslash) + 1);
    98         filename2modname(module_name, afterslash);
    99 #else
    100 #define module_name     argv[n]
    101 #endif
    102         if (syscall(__NR_delete_module, module_name, flags) != 0) {
     87        if (syscall(__NR_delete_module, ENABLE_FEATURE_2_6_MODULES ? misc_buf : argv[n], flags)) {
    10388            bb_perror_msg("%s", argv[n]);
    10489            ret = EXIT_FAILURE;
     
    10691    }
    10792
    108     return(ret);
     93    return ret;
    10994}
Note: See TracChangeset for help on using the changeset viewer.