linux/kernel/module.c
<<
>>
Prefs
   1/*
   2   Copyright (C) 2002 Richard Henderson
   3   Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18*/
  19#include <linux/export.h>
  20#include <linux/moduleloader.h>
  21#include <linux/ftrace_event.h>
  22#include <linux/init.h>
  23#include <linux/kallsyms.h>
  24#include <linux/file.h>
  25#include <linux/fs.h>
  26#include <linux/sysfs.h>
  27#include <linux/kernel.h>
  28#include <linux/slab.h>
  29#include <linux/vmalloc.h>
  30#include <linux/elf.h>
  31#include <linux/proc_fs.h>
  32#include <linux/security.h>
  33#include <linux/seq_file.h>
  34#include <linux/syscalls.h>
  35#include <linux/fcntl.h>
  36#include <linux/rcupdate.h>
  37#include <linux/capability.h>
  38#include <linux/cpu.h>
  39#include <linux/moduleparam.h>
  40#include <linux/errno.h>
  41#include <linux/err.h>
  42#include <linux/vermagic.h>
  43#include <linux/notifier.h>
  44#include <linux/sched.h>
  45#include <linux/stop_machine.h>
  46#include <linux/device.h>
  47#include <linux/string.h>
  48#include <linux/mutex.h>
  49#include <linux/rculist.h>
  50#include <asm/uaccess.h>
  51#include <asm/cacheflush.h>
  52#include <asm/mmu_context.h>
  53#include <linux/license.h>
  54#include <asm/sections.h>
  55#include <linux/tracepoint.h>
  56#include <linux/ftrace.h>
  57#include <linux/async.h>
  58#include <linux/percpu.h>
  59#include <linux/kmemleak.h>
  60#include <linux/jump_label.h>
  61#include <linux/pfn.h>
  62#include <linux/bsearch.h>
  63#include <linux/fips.h>
  64#include <uapi/linux/module.h>
  65#include "module-internal.h"
  66
  67#define CREATE_TRACE_POINTS
  68#include <trace/events/module.h>
  69
  70#ifndef ARCH_SHF_SMALL
  71#define ARCH_SHF_SMALL 0
  72#endif
  73
  74/*
  75 * Modules' sections will be aligned on page boundaries
  76 * to ensure complete separation of code and data, but
  77 * only when CONFIG_DEBUG_SET_MODULE_RONX=y
  78 */
  79#ifdef CONFIG_DEBUG_SET_MODULE_RONX
  80# define debug_align(X) ALIGN(X, PAGE_SIZE)
  81#else
  82# define debug_align(X) (X)
  83#endif
  84
  85/*
  86 * Given BASE and SIZE this macro calculates the number of pages the
  87 * memory regions occupies
  88 */
  89#define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ?         \
  90                (PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) - \
  91                         PFN_DOWN((unsigned long)BASE) + 1)     \
  92                : (0UL))
  93
  94/* If this is set, the section belongs in the init part of the module */
  95#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
  96
  97/*
  98 * Mutex protects:
  99 * 1) List of modules (also safely readable with preempt_disable),
 100 * 2) module_use links,
 101 * 3) module_addr_min/module_addr_max.
 102 * (delete uses stop_machine/add uses RCU list operations). */
 103DEFINE_MUTEX(module_mutex);
 104EXPORT_SYMBOL_GPL(module_mutex);
 105static LIST_HEAD(modules);
 106#ifdef CONFIG_KGDB_KDB
 107struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
 108#endif /* CONFIG_KGDB_KDB */
 109
 110#ifdef CONFIG_MODULE_SIG
 111#ifdef CONFIG_MODULE_SIG_FORCE
 112static bool sig_enforce = true;
 113#else
 114static bool sig_enforce = false;
 115
 116static int param_set_bool_enable_only(const char *val,
 117                                      const struct kernel_param *kp)
 118{
 119        int err;
 120        bool test;
 121        struct kernel_param dummy_kp = *kp;
 122
 123        dummy_kp.arg = &test;
 124
 125        err = param_set_bool(val, &dummy_kp);
 126        if (err)
 127                return err;
 128
 129        /* Don't let them unset it once it's set! */
 130        if (!test && sig_enforce)
 131                return -EROFS;
 132
 133        if (test)
 134                sig_enforce = true;
 135        return 0;
 136}
 137
 138static const struct kernel_param_ops param_ops_bool_enable_only = {
 139        .flags = KERNEL_PARAM_FL_NOARG,
 140        .set = param_set_bool_enable_only,
 141        .get = param_get_bool,
 142};
 143#define param_check_bool_enable_only param_check_bool
 144
 145module_param(sig_enforce, bool_enable_only, 0644);
 146#endif /* !CONFIG_MODULE_SIG_FORCE */
 147#endif /* CONFIG_MODULE_SIG */
 148
 149/* Block module loading/unloading? */
 150int modules_disabled = 0;
 151core_param(nomodule, modules_disabled, bint, 0);
 152
 153/* Waiting for a module to finish initializing? */
 154static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 155
 156static BLOCKING_NOTIFIER_HEAD(module_notify_list);
 157
 158/* Bounds of module allocation, for speeding __module_address.
 159 * Protected by module_mutex. */
 160static unsigned long module_addr_min = -1UL, module_addr_max = 0;
 161
 162int register_module_notifier(struct notifier_block * nb)
 163{
 164        return blocking_notifier_chain_register(&module_notify_list, nb);
 165}
 166EXPORT_SYMBOL(register_module_notifier);
 167
 168int unregister_module_notifier(struct notifier_block * nb)
 169{
 170        return blocking_notifier_chain_unregister(&module_notify_list, nb);
 171}
 172EXPORT_SYMBOL(unregister_module_notifier);
 173
 174struct load_info {
 175        Elf_Ehdr *hdr;
 176        unsigned long len;
 177        Elf_Shdr *sechdrs;
 178        char *secstrings, *strtab;
 179        unsigned long symoffs, stroffs;
 180        struct _ddebug *debug;
 181        unsigned int num_debug;
 182        bool sig_ok;
 183        struct {
 184                unsigned int sym, str, mod, vers, info, pcpu;
 185        } index;
 186};
 187
 188/* We require a truly strong try_module_get(): 0 means failure due to
 189   ongoing or failed initialization etc. */
 190static inline int strong_try_module_get(struct module *mod)
 191{
 192        BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);
 193        if (mod && mod->state == MODULE_STATE_COMING)
 194                return -EBUSY;
 195        if (try_module_get(mod))
 196                return 0;
 197        else
 198                return -ENOENT;
 199}
 200
 201static inline void add_taint_module(struct module *mod, unsigned flag,
 202                                    enum lockdep_ok lockdep_ok)
 203{
 204        add_taint(flag, lockdep_ok);
 205        mod->taints |= (1U << flag);
 206}
 207
 208/*
 209 * A thread that wants to hold a reference to a module only while it
 210 * is running can call this to safely exit.  nfsd and lockd use this.
 211 */
 212void __module_put_and_exit(struct module *mod, long code)
 213{
 214        module_put(mod);
 215        do_exit(code);
 216}
 217EXPORT_SYMBOL(__module_put_and_exit);
 218
 219/* Find a module section: 0 means not found. */
 220static unsigned int find_sec(const struct load_info *info, const char *name)
 221{
 222        unsigned int i;
 223
 224        for (i = 1; i < info->hdr->e_shnum; i++) {
 225                Elf_Shdr *shdr = &info->sechdrs[i];
 226                /* Alloc bit cleared means "ignore it." */
 227                if ((shdr->sh_flags & SHF_ALLOC)
 228                    && strcmp(info->secstrings + shdr->sh_name, name) == 0)
 229                        return i;
 230        }
 231        return 0;
 232}
 233
 234/* Find a module section, or NULL. */
 235static void *section_addr(const struct load_info *info, const char *name)
 236{
 237        /* Section 0 has sh_addr 0. */
 238        return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
 239}
 240
 241/* Find a module section, or NULL.  Fill in number of "objects" in section. */
 242static void *section_objs(const struct load_info *info,
 243                          const char *name,
 244                          size_t object_size,
 245                          unsigned int *num)
 246{
 247        unsigned int sec = find_sec(info, name);
 248
 249        /* Section 0 has sh_addr 0 and sh_size 0. */
 250        *num = info->sechdrs[sec].sh_size / object_size;
 251        return (void *)info->sechdrs[sec].sh_addr;
 252}
 253
 254/* Provided by the linker */
 255extern const struct kernel_symbol __start___ksymtab[];
 256extern const struct kernel_symbol __stop___ksymtab[];
 257extern const struct kernel_symbol __start___ksymtab_gpl[];
 258extern const struct kernel_symbol __stop___ksymtab_gpl[];
 259extern const struct kernel_symbol __start___ksymtab_gpl_future[];
 260extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
 261extern const unsigned long __start___kcrctab[];
 262extern const unsigned long __start___kcrctab_gpl[];
 263extern const unsigned long __start___kcrctab_gpl_future[];
 264#ifdef CONFIG_UNUSED_SYMBOLS
 265extern const struct kernel_symbol __start___ksymtab_unused[];
 266extern const struct kernel_symbol __stop___ksymtab_unused[];
 267extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
 268extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
 269extern const unsigned long __start___kcrctab_unused[];
 270extern const unsigned long __start___kcrctab_unused_gpl[];
 271#endif
 272
 273#ifndef CONFIG_MODVERSIONS
 274#define symversion(base, idx) NULL
 275#else
 276#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
 277#endif
 278
 279static bool each_symbol_in_section(const struct symsearch *arr,
 280                                   unsigned int arrsize,
 281                                   struct module *owner,
 282                                   bool (*fn)(const struct symsearch *syms,
 283                                              struct module *owner,
 284                                              void *data),
 285                                   void *data)
 286{
 287        unsigned int j;
 288
 289        for (j = 0; j < arrsize; j++) {
 290                if (fn(&arr[j], owner, data))
 291                        return true;
 292        }
 293
 294        return false;
 295}
 296
 297/* Returns true as soon as fn returns true, otherwise false. */
 298bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
 299                                    struct module *owner,
 300                                    void *data),
 301                         void *data)
 302{
 303        struct module *mod;
 304        static const struct symsearch arr[] = {
 305                { __start___ksymtab, __stop___ksymtab, __start___kcrctab,
 306                  NOT_GPL_ONLY, false },
 307                { __start___ksymtab_gpl, __stop___ksymtab_gpl,
 308                  __start___kcrctab_gpl,
 309                  GPL_ONLY, false },
 310                { __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
 311                  __start___kcrctab_gpl_future,
 312                  WILL_BE_GPL_ONLY, false },
 313#ifdef CONFIG_UNUSED_SYMBOLS
 314                { __start___ksymtab_unused, __stop___ksymtab_unused,
 315                  __start___kcrctab_unused,
 316                  NOT_GPL_ONLY, true },
 317                { __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
 318                  __start___kcrctab_unused_gpl,
 319                  GPL_ONLY, true },
 320#endif
 321        };
 322
 323        if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
 324                return true;
 325
 326        list_for_each_entry_rcu(mod, &modules, list) {
 327                struct symsearch arr[] = {
 328                        { mod->syms, mod->syms + mod->num_syms, mod->crcs,
 329                          NOT_GPL_ONLY, false },
 330                        { mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
 331                          mod->gpl_crcs,
 332                          GPL_ONLY, false },
 333                        { mod->gpl_future_syms,
 334                          mod->gpl_future_syms + mod->num_gpl_future_syms,
 335                          mod->gpl_future_crcs,
 336                          WILL_BE_GPL_ONLY, false },
 337#ifdef CONFIG_UNUSED_SYMBOLS
 338                        { mod->unused_syms,
 339                          mod->unused_syms + mod->num_unused_syms,
 340                          mod->unused_crcs,
 341                          NOT_GPL_ONLY, true },
 342                        { mod->unused_gpl_syms,
 343                          mod->unused_gpl_syms + mod->num_unused_gpl_syms,
 344                          mod->unused_gpl_crcs,
 345                          GPL_ONLY, true },
 346#endif
 347                };
 348
 349                if (mod->state == MODULE_STATE_UNFORMED)
 350                        continue;
 351
 352                if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
 353                        return true;
 354        }
 355        return false;
 356}
 357EXPORT_SYMBOL_GPL(each_symbol_section);
 358
 359struct find_symbol_arg {
 360        /* Input */
 361        const char *name;
 362        bool gplok;
 363        bool warn;
 364
 365        /* Output */
 366        struct module *owner;
 367        const unsigned long *crc;
 368        const struct kernel_symbol *sym;
 369};
 370
 371static bool check_symbol(const struct symsearch *syms,
 372                                 struct module *owner,
 373                                 unsigned int symnum, void *data)
 374{
 375        struct find_symbol_arg *fsa = data;
 376
 377        if (!fsa->gplok) {
 378                if (syms->licence == GPL_ONLY)
 379                        return false;
 380                if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
 381                        pr_warn("Symbol %s is being used by a non-GPL module, "
 382                                "which will not be allowed in the future\n",
 383                                fsa->name);
 384                }
 385        }
 386
 387#ifdef CONFIG_UNUSED_SYMBOLS
 388        if (syms->unused && fsa->warn) {
 389                pr_warn("Symbol %s is marked as UNUSED, however this module is "
 390                        "using it.\n", fsa->name);
 391                pr_warn("This symbol will go away in the future.\n");
 392                pr_warn("Please evalute if this is the right api to use and if "
 393                        "it really is, submit a report the linux kernel "
 394                        "mailinglist together with submitting your code for "
 395                        "inclusion.\n");
 396        }
 397#endif
 398
 399        fsa->owner = owner;
 400        fsa->crc = symversion(syms->crcs, symnum);
 401        fsa->sym = &syms->start[symnum];
 402        return true;
 403}
 404
 405static int cmp_name(const void *va, const void *vb)
 406{
 407        const char *a;
 408        const struct kernel_symbol *b;
 409        a = va; b = vb;
 410        return strcmp(a, b->name);
 411}
 412
 413static bool find_symbol_in_section(const struct symsearch *syms,
 414                                   struct module *owner,
 415                                   void *data)
 416{
 417        struct find_symbol_arg *fsa = data;
 418        struct kernel_symbol *sym;
 419
 420        sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
 421                        sizeof(struct kernel_symbol), cmp_name);
 422
 423        if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
 424                return true;
 425
 426        return false;
 427}
 428
 429/* Find a symbol and return it, along with, (optional) crc and
 430 * (optional) module which owns it.  Needs preempt disabled or module_mutex. */
 431const struct kernel_symbol *find_symbol(const char *name,
 432                                        struct module **owner,
 433                                        const unsigned long **crc,
 434                                        bool gplok,
 435                                        bool warn)
 436{
 437        struct find_symbol_arg fsa;
 438
 439        fsa.name = name;
 440        fsa.gplok = gplok;
 441        fsa.warn = warn;
 442
 443        if (each_symbol_section(find_symbol_in_section, &fsa)) {
 444                if (owner)
 445                        *owner = fsa.owner;
 446                if (crc)
 447                        *crc = fsa.crc;
 448                return fsa.sym;
 449        }
 450
 451        pr_debug("Failed to find symbol %s\n", name);
 452        return NULL;
 453}
 454EXPORT_SYMBOL_GPL(find_symbol);
 455
 456/* Search for module by name: must hold module_mutex. */
 457static struct module *find_module_all(const char *name, size_t len,
 458                                      bool even_unformed)
 459{
 460        struct module *mod;
 461
 462        list_for_each_entry(mod, &modules, list) {
 463                if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
 464                        continue;
 465                if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
 466                        return mod;
 467        }
 468        return NULL;
 469}
 470
 471struct module *find_module(const char *name)
 472{
 473        return find_module_all(name, strlen(name), false);
 474}
 475EXPORT_SYMBOL_GPL(find_module);
 476
 477#ifdef CONFIG_SMP
 478
 479static inline void __percpu *mod_percpu(struct module *mod)
 480{
 481        return mod->percpu;
 482}
 483
 484static int percpu_modalloc(struct module *mod, struct load_info *info)
 485{
 486        Elf_Shdr *pcpusec = &info->sechdrs[info->index.pcpu];
 487        unsigned long align = pcpusec->sh_addralign;
 488
 489        if (!pcpusec->sh_size)
 490                return 0;
 491
 492        if (align > PAGE_SIZE) {
 493                pr_warn("%s: per-cpu alignment %li > %li\n",
 494                        mod->name, align, PAGE_SIZE);
 495                align = PAGE_SIZE;
 496        }
 497
 498        mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
 499        if (!mod->percpu) {
 500                pr_warn("%s: Could not allocate %lu bytes percpu data\n",
 501                        mod->name, (unsigned long)pcpusec->sh_size);
 502                return -ENOMEM;
 503        }
 504        mod->percpu_size = pcpusec->sh_size;
 505        return 0;
 506}
 507
 508static void percpu_modfree(struct module *mod)
 509{
 510        free_percpu(mod->percpu);
 511}
 512
 513static unsigned int find_pcpusec(struct load_info *info)
 514{
 515        return find_sec(info, ".data..percpu");
 516}
 517
 518static void percpu_modcopy(struct module *mod,
 519                           const void *from, unsigned long size)
 520{
 521        int cpu;
 522
 523        for_each_possible_cpu(cpu)
 524                memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
 525}
 526
 527/**
 528 * is_module_percpu_address - test whether address is from module static percpu
 529 * @addr: address to test
 530 *
 531 * Test whether @addr belongs to module static percpu area.
 532 *
 533 * RETURNS:
 534 * %true if @addr is from module static percpu area
 535 */
 536bool is_module_percpu_address(unsigned long addr)
 537{
 538        struct module *mod;
 539        unsigned int cpu;
 540
 541        preempt_disable();
 542
 543        list_for_each_entry_rcu(mod, &modules, list) {
 544                if (mod->state == MODULE_STATE_UNFORMED)
 545                        continue;
 546                if (!mod->percpu_size)
 547                        continue;
 548                for_each_possible_cpu(cpu) {
 549                        void *start = per_cpu_ptr(mod->percpu, cpu);
 550
 551                        if ((void *)addr >= start &&
 552                            (void *)addr < start + mod->percpu_size) {
 553                                preempt_enable();
 554                                return true;
 555                        }
 556                }
 557        }
 558
 559        preempt_enable();
 560        return false;
 561}
 562
 563#else /* ... !CONFIG_SMP */
 564
 565static inline void __percpu *mod_percpu(struct module *mod)
 566{
 567        return NULL;
 568}
 569static int percpu_modalloc(struct module *mod, struct load_info *info)
 570{
 571        /* UP modules shouldn't have this section: ENOMEM isn't quite right */
 572        if (info->sechdrs[info->index.pcpu].sh_size != 0)
 573                return -ENOMEM;
 574        return 0;
 575}
 576static inline void percpu_modfree(struct module *mod)
 577{
 578}
 579static unsigned int find_pcpusec(struct load_info *info)
 580{
 581        return 0;
 582}
 583static inline void percpu_modcopy(struct module *mod,
 584                                  const void *from, unsigned long size)
 585{
 586        /* pcpusec should be 0, and size of that section should be 0. */
 587        BUG_ON(size != 0);
 588}
 589bool is_module_percpu_address(unsigned long addr)
 590{
 591        return false;
 592}
 593
 594#endif /* CONFIG_SMP */
 595
 596#define MODINFO_ATTR(field)     \
 597static void setup_modinfo_##field(struct module *mod, const char *s)  \
 598{                                                                     \
 599        mod->field = kstrdup(s, GFP_KERNEL);                          \
 600}                                                                     \
 601static ssize_t show_modinfo_##field(struct module_attribute *mattr,   \
 602                        struct module_kobject *mk, char *buffer)      \
 603{                                                                     \
 604        return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field);  \
 605}                                                                     \
 606static int modinfo_##field##_exists(struct module *mod)               \
 607{                                                                     \
 608        return mod->field != NULL;                                    \
 609}                                                                     \
 610static void free_modinfo_##field(struct module *mod)                  \
 611{                                                                     \
 612        kfree(mod->field);                                            \
 613        mod->field = NULL;                                            \
 614}                                                                     \
 615static struct module_attribute modinfo_##field = {                    \
 616        .attr = { .name = __stringify(field), .mode = 0444 },         \
 617        .show = show_modinfo_##field,                                 \
 618        .setup = setup_modinfo_##field,                               \
 619        .test = modinfo_##field##_exists,                             \
 620        .free = free_modinfo_##field,                                 \
 621};
 622
 623MODINFO_ATTR(version);
 624MODINFO_ATTR(srcversion);
 625
 626static char last_unloaded_module[MODULE_NAME_LEN+1];
 627
 628#ifdef CONFIG_MODULE_UNLOAD
 629
 630EXPORT_TRACEPOINT_SYMBOL(module_get);
 631
 632/* Init the unload section of the module. */
 633static int module_unload_init(struct module *mod)
 634{
 635        mod->refptr = alloc_percpu(struct module_ref);
 636        if (!mod->refptr)
 637                return -ENOMEM;
 638
 639        INIT_LIST_HEAD(&mod->source_list);
 640        INIT_LIST_HEAD(&mod->target_list);
 641
 642        /* Hold reference count during initialization. */
 643        __this_cpu_write(mod->refptr->incs, 1);
 644
 645        return 0;
 646}
 647
 648/* Does a already use b? */
 649static int already_uses(struct module *a, struct module *b)
 650{
 651        struct module_use *use;
 652
 653        list_for_each_entry(use, &b->source_list, source_list) {
 654                if (use->source == a) {
 655                        pr_debug("%s uses %s!\n", a->name, b->name);
 656                        return 1;
 657                }
 658        }
 659        pr_debug("%s does not use %s!\n", a->name, b->name);
 660        return 0;
 661}
 662
 663/*
 664 * Module a uses b
 665 *  - we add 'a' as a "source", 'b' as a "target" of module use
 666 *  - the module_use is added to the list of 'b' sources (so
 667 *    'b' can walk the list to see who sourced them), and of 'a'
 668 *    targets (so 'a' can see what modules it targets).
 669 */
 670static int add_module_usage(struct module *a, struct module *b)
 671{
 672        struct module_use *use;
 673
 674        pr_debug("Allocating new usage for %s.\n", a->name);
 675        use = kmalloc(sizeof(*use), GFP_ATOMIC);
 676        if (!use) {
 677                pr_warn("%s: out of memory loading\n", a->name);
 678                return -ENOMEM;
 679        }
 680
 681        use->source = a;
 682        use->target = b;
 683        list_add(&use->source_list, &b->source_list);
 684        list_add(&use->target_list, &a->target_list);
 685        return 0;
 686}
 687
 688/* Module a uses b: caller needs module_mutex() */
 689int ref_module(struct module *a, struct module *b)
 690{
 691        int err;
 692
 693        if (b == NULL || already_uses(a, b))
 694                return 0;
 695
 696        /* If module isn't available, we fail. */
 697        err = strong_try_module_get(b);
 698        if (err)
 699                return err;
 700
 701        err = add_module_usage(a, b);
 702        if (err) {
 703                module_put(b);
 704                return err;
 705        }
 706        return 0;
 707}
 708EXPORT_SYMBOL_GPL(ref_module);
 709
 710/* Clear the unload stuff of the module. */
 711static void module_unload_free(struct module *mod)
 712{
 713        struct module_use *use, *tmp;
 714
 715        mutex_lock(&module_mutex);
 716        list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
 717                struct module *i = use->target;
 718                pr_debug("%s unusing %s\n", mod->name, i->name);
 719                module_put(i);
 720                list_del(&use->source_list);
 721                list_del(&use->target_list);
 722                kfree(use);
 723        }
 724        mutex_unlock(&module_mutex);
 725
 726        free_percpu(mod->refptr);
 727}
 728
 729#ifdef CONFIG_MODULE_FORCE_UNLOAD
 730static inline int try_force_unload(unsigned int flags)
 731{
 732        int ret = (flags & O_TRUNC);
 733        if (ret)
 734                add_taint(TAINT_FORCED_RMMOD, LOCKDEP_NOW_UNRELIABLE);
 735        return ret;
 736}
 737#else
 738static inline int try_force_unload(unsigned int flags)
 739{
 740        return 0;
 741}
 742#endif /* CONFIG_MODULE_FORCE_UNLOAD */
 743
 744struct stopref
 745{
 746        struct module *mod;
 747        int flags;
 748        int *forced;
 749};
 750
 751/* Whole machine is stopped with interrupts off when this runs. */
 752static int __try_stop_module(void *_sref)
 753{
 754        struct stopref *sref = _sref;
 755
 756        /* If it's not unused, quit unless we're forcing. */
 757        if (module_refcount(sref->mod) != 0) {
 758                if (!(*sref->forced = try_force_unload(sref->flags)))
 759                        return -EWOULDBLOCK;
 760        }
 761
 762        /* Mark it as dying. */
 763        sref->mod->state = MODULE_STATE_GOING;
 764        return 0;
 765}
 766
 767static int try_stop_module(struct module *mod, int flags, int *forced)
 768{
 769        struct stopref sref = { mod, flags, forced };
 770
 771        return stop_machine(__try_stop_module, &sref, NULL);
 772}
 773
 774unsigned long module_refcount(struct module *mod)
 775{
 776        unsigned long incs = 0, decs = 0;
 777        int cpu;
 778
 779        for_each_possible_cpu(cpu)
 780                decs += per_cpu_ptr(mod->refptr, cpu)->decs;
 781        /*
 782         * ensure the incs are added up after the decs.
 783         * module_put ensures incs are visible before decs with smp_wmb.
 784         *
 785         * This 2-count scheme avoids the situation where the refcount
 786         * for CPU0 is read, then CPU0 increments the module refcount,
 787         * then CPU1 drops that refcount, then the refcount for CPU1 is
 788         * read. We would record a decrement but not its corresponding
 789         * increment so we would see a low count (disaster).
 790         *
 791         * Rare situation? But module_refcount can be preempted, and we
 792         * might be tallying up 4096+ CPUs. So it is not impossible.
 793         */
 794        smp_rmb();
 795        for_each_possible_cpu(cpu)
 796                incs += per_cpu_ptr(mod->refptr, cpu)->incs;
 797        return incs - decs;
 798}
 799EXPORT_SYMBOL(module_refcount);
 800
 801/* This exists whether we can unload or not */
 802static void free_module(struct module *mod);
 803
 804SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
 805                unsigned int, flags)
 806{
 807        struct module *mod;
 808        char name[MODULE_NAME_LEN];
 809        int ret, forced = 0;
 810
 811        if (!capable(CAP_SYS_MODULE) || modules_disabled)
 812                return -EPERM;
 813
 814        if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
 815                return -EFAULT;
 816        name[MODULE_NAME_LEN-1] = '\0';
 817
 818        if (!(flags & O_NONBLOCK))
 819                pr_warn("waiting module removal not supported: please upgrade\n");
 820
 821        if (mutex_lock_interruptible(&module_mutex) != 0)
 822                return -EINTR;
 823
 824        mod = find_module(name);
 825        if (!mod) {
 826                ret = -ENOENT;
 827                goto out;
 828        }
 829
 830        if (!list_empty(&mod->source_list)) {
 831                /* Other modules depend on us: get rid of them first. */
 832                ret = -EWOULDBLOCK;
 833                goto out;
 834        }
 835
 836        /* Doing init or already dying? */
 837        if (mod->state != MODULE_STATE_LIVE) {
 838                /* FIXME: if (force), slam module count damn the torpedoes */
 839                pr_debug("%s already dying\n", mod->name);
 840                ret = -EBUSY;
 841                goto out;
 842        }
 843
 844        /* If it has an init func, it must have an exit func to unload */
 845        if (mod->init && !mod->exit) {
 846                forced = try_force_unload(flags);
 847                if (!forced) {
 848                        /* This module can't be removed */
 849                        ret = -EBUSY;
 850                        goto out;
 851                }
 852        }
 853
 854        /* Stop the machine so refcounts can't move and disable module. */
 855        ret = try_stop_module(mod, flags, &forced);
 856        if (ret != 0)
 857                goto out;
 858
 859        mutex_unlock(&module_mutex);
 860        /* Final destruction now no one is using it. */
 861        if (mod->exit != NULL)
 862                mod->exit();
 863        blocking_notifier_call_chain(&module_notify_list,
 864                                     MODULE_STATE_GOING, mod);
 865        async_synchronize_full();
 866
 867        /* Store the name of the last unloaded module for diagnostic purposes */
 868        strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
 869
 870        free_module(mod);
 871        return 0;
 872out:
 873        mutex_unlock(&module_mutex);
 874        return ret;
 875}
 876
 877static inline void print_unload_info(struct seq_file *m, struct module *mod)
 878{
 879        struct module_use *use;
 880        int printed_something = 0;
 881
 882        seq_printf(m, " %lu ", module_refcount(mod));
 883
 884        /* Always include a trailing , so userspace can differentiate
 885           between this and the old multi-field proc format. */
 886        list_for_each_entry(use, &mod->source_list, source_list) {
 887                printed_something = 1;
 888                seq_printf(m, "%s,", use->source->name);
 889        }
 890
 891        if (mod->init != NULL && mod->exit == NULL) {
 892                printed_something = 1;
 893                seq_printf(m, "[permanent],");
 894        }
 895
 896        if (!printed_something)
 897                seq_printf(m, "-");
 898}
 899
 900void __symbol_put(const char *symbol)
 901{
 902        struct module *owner;
 903
 904        preempt_disable();
 905        if (!find_symbol(symbol, &owner, NULL, true, false))
 906                BUG();
 907        module_put(owner);
 908        preempt_enable();
 909}
 910EXPORT_SYMBOL(__symbol_put);
 911
 912/* Note this assumes addr is a function, which it currently always is. */
 913void symbol_put_addr(void *addr)
 914{
 915        struct module *modaddr;
 916        unsigned long a = (unsigned long)dereference_function_descriptor(addr);
 917
 918        if (core_kernel_text(a))
 919                return;
 920
 921        /* module_text_address is safe here: we're supposed to have reference
 922         * to module from symbol_get, so it can't go away. */
 923        modaddr = __module_text_address(a);
 924        BUG_ON(!modaddr);
 925        module_put(modaddr);
 926}
 927EXPORT_SYMBOL_GPL(symbol_put_addr);
 928
 929static ssize_t show_refcnt(struct module_attribute *mattr,
 930                           struct module_kobject *mk, char *buffer)
 931{
 932        return sprintf(buffer, "%lu\n", module_refcount(mk->mod));
 933}
 934
 935static struct module_attribute modinfo_refcnt =
 936        __ATTR(refcnt, 0444, show_refcnt, NULL);
 937
 938void __module_get(struct module *module)
 939{
 940        if (module) {
 941                preempt_disable();
 942                __this_cpu_inc(module->refptr->incs);
 943                trace_module_get(module, _RET_IP_);
 944                preempt_enable();
 945        }
 946}
 947EXPORT_SYMBOL(__module_get);
 948
 949bool try_module_get(struct module *module)
 950{
 951        bool ret = true;
 952
 953        if (module) {
 954                preempt_disable();
 955
 956                if (likely(module_is_live(module))) {
 957                        __this_cpu_inc(module->refptr->incs);
 958                        trace_module_get(module, _RET_IP_);
 959                } else
 960                        ret = false;
 961
 962                preempt_enable();
 963        }
 964        return ret;
 965}
 966EXPORT_SYMBOL(try_module_get);
 967
 968void module_put(struct module *module)
 969{
 970        if (module) {
 971                preempt_disable();
 972                smp_wmb(); /* see comment in module_refcount */
 973                __this_cpu_inc(module->refptr->decs);
 974
 975                trace_module_put(module, _RET_IP_);
 976                preempt_enable();
 977        }
 978}
 979EXPORT_SYMBOL(module_put);
 980
 981#else /* !CONFIG_MODULE_UNLOAD */
 982static inline void print_unload_info(struct seq_file *m, struct module *mod)
 983{
 984        /* We don't know the usage count, or what modules are using. */
 985        seq_printf(m, " - -");
 986}
 987
 988static inline void module_unload_free(struct module *mod)
 989{
 990}
 991
 992int ref_module(struct module *a, struct module *b)
 993{
 994        return strong_try_module_get(b);
 995}
 996EXPORT_SYMBOL_GPL(ref_module);
 997
 998static inline int module_unload_init(struct module *mod)
 999{
1000        return 0;
1001}
1002#endif /* CONFIG_MODULE_UNLOAD */
1003
1004static size_t module_flags_taint(struct module *mod, char *buf)
1005{
1006        size_t l = 0;
1007
1008        if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
1009                buf[l++] = 'P';
1010        if (mod->taints & (1 << TAINT_OOT_MODULE))
1011                buf[l++] = 'O';
1012        if (mod->taints & (1 << TAINT_FORCED_MODULE))
1013                buf[l++] = 'F';
1014        if (mod->taints & (1 << TAINT_CRAP))
1015                buf[l++] = 'C';
1016        /*
1017         * TAINT_FORCED_RMMOD: could be added.
1018         * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
1019         * apply to modules.
1020         */
1021        return l;
1022}
1023
1024static ssize_t show_initstate(struct module_attribute *mattr,
1025                              struct module_kobject *mk, char *buffer)
1026{
1027        const char *state = "unknown";
1028
1029        switch (mk->mod->state) {
1030        case MODULE_STATE_LIVE:
1031                state = "live";
1032                break;
1033        case MODULE_STATE_COMING:
1034                state = "coming";
1035                break;
1036        case MODULE_STATE_GOING:
1037                state = "going";
1038                break;
1039        default:
1040                BUG();
1041        }
1042        return sprintf(buffer, "%s\n", state);
1043}
1044
1045static struct module_attribute modinfo_initstate =
1046        __ATTR(initstate, 0444, show_initstate, NULL);
1047
1048static ssize_t store_uevent(struct module_attribute *mattr,
1049                            struct module_kobject *mk,
1050                            const char *buffer, size_t count)
1051{
1052        enum kobject_action action;
1053
1054        if (kobject_action_type(buffer, count, &action) == 0)
1055                kobject_uevent(&mk->kobj, action);
1056        return count;
1057}
1058
1059struct module_attribute module_uevent =
1060        __ATTR(uevent, 0200, NULL, store_uevent);
1061
1062static ssize_t show_coresize(struct module_attribute *mattr,
1063                             struct module_kobject *mk, char *buffer)
1064{
1065        return sprintf(buffer, "%u\n", mk->mod->core_size);
1066}
1067
1068static struct module_attribute modinfo_coresize =
1069        __ATTR(coresize, 0444, show_coresize, NULL);
1070
1071static ssize_t show_initsize(struct module_attribute *mattr,
1072                             struct module_kobject *mk, char *buffer)
1073{
1074        return sprintf(buffer, "%u\n", mk->mod->init_size);
1075}
1076
1077static struct module_attribute modinfo_initsize =
1078        __ATTR(initsize, 0444, show_initsize, NULL);
1079
1080static ssize_t show_taint(struct module_attribute *mattr,
1081                          struct module_kobject *mk, char *buffer)
1082{
1083        size_t l;
1084
1085        l = module_flags_taint(mk->mod, buffer);
1086        buffer[l++] = '\n';
1087        return l;
1088}
1089
1090static struct module_attribute modinfo_taint =
1091        __ATTR(taint, 0444, show_taint, NULL);
1092
1093static struct module_attribute *modinfo_attrs[] = {
1094        &module_uevent,
1095        &modinfo_version,
1096        &modinfo_srcversion,
1097        &modinfo_initstate,
1098        &modinfo_coresize,
1099        &modinfo_initsize,
1100        &modinfo_taint,
1101#ifdef CONFIG_MODULE_UNLOAD
1102        &modinfo_refcnt,
1103#endif
1104        NULL,
1105};
1106
1107static const char vermagic[] = VERMAGIC_STRING;
1108
1109static int try_to_force_load(struct module *mod, const char *reason)
1110{
1111#ifdef CONFIG_MODULE_FORCE_LOAD
1112        if (!test_taint(TAINT_FORCED_MODULE))
1113                pr_warn("%s: %s: kernel tainted.\n", mod->name, reason);
1114        add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);
1115        return 0;
1116#else
1117        return -ENOEXEC;
1118#endif
1119}
1120
1121#ifdef CONFIG_MODVERSIONS
1122/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
1123static unsigned long maybe_relocated(unsigned long crc,
1124                                     const struct module *crc_owner)
1125{
1126#ifdef ARCH_RELOCATES_KCRCTAB
1127        if (crc_owner == NULL)
1128                return crc - (unsigned long)reloc_start;
1129#endif
1130        return crc;
1131}
1132
1133static int check_version(Elf_Shdr *sechdrs,
1134                         unsigned int versindex,
1135                         const char *symname,
1136                         struct module *mod, 
1137                         const unsigned long *crc,
1138                         const struct module *crc_owner)
1139{
1140        unsigned int i, num_versions;
1141        struct modversion_info *versions;
1142
1143        /* Exporting module didn't supply crcs?  OK, we're already tainted. */
1144        if (!crc)
1145                return 1;
1146
1147        /* No versions at all?  modprobe --force does this. */
1148        if (versindex == 0)
1149                return try_to_force_load(mod, symname) == 0;
1150
1151        versions = (void *) sechdrs[versindex].sh_addr;
1152        num_versions = sechdrs[versindex].sh_size
1153                / sizeof(struct modversion_info);
1154
1155        for (i = 0; i < num_versions; i++) {
1156                if (strcmp(versions[i].name, symname) != 0)
1157                        continue;
1158
1159                if (versions[i].crc == maybe_relocated(*crc, crc_owner))
1160                        return 1;
1161                pr_debug("Found checksum %lX vs module %lX\n",
1162                       maybe_relocated(*crc, crc_owner), versions[i].crc);
1163                goto bad_version;
1164        }
1165
1166        pr_warn("%s: no symbol version for %s\n", mod->name, symname);
1167        return 0;
1168
1169bad_version:
1170        printk("%s: disagrees about version of symbol %s\n",
1171               mod->name, symname);
1172        return 0;
1173}
1174
1175static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1176                                          unsigned int versindex,
1177                                          struct module *mod)
1178{
1179        const unsigned long *crc;
1180
1181        /* Since this should be found in kernel (which can't be removed),
1182         * no locking is necessary. */
1183        if (!find_symbol(VMLINUX_SYMBOL_STR(module_layout), NULL,
1184                         &crc, true, false))
1185                BUG();
1186        return check_version(sechdrs, versindex,
1187                             VMLINUX_SYMBOL_STR(module_layout), mod, crc,
1188                             NULL);
1189}
1190
1191/* First part is kernel version, which we ignore if module has crcs. */
1192static inline int same_magic(const char *amagic, const char *bmagic,
1193                             bool has_crcs)
1194{
1195        if (has_crcs) {
1196                amagic += strcspn(amagic, " ");
1197                bmagic += strcspn(bmagic, " ");
1198        }
1199        return strcmp(amagic, bmagic) == 0;
1200}
1201#else
1202static inline int check_version(Elf_Shdr *sechdrs,
1203                                unsigned int versindex,
1204                                const char *symname,
1205                                struct module *mod, 
1206                                const unsigned long *crc,
1207                                const struct module *crc_owner)
1208{
1209        return 1;
1210}
1211
1212static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1213                                          unsigned int versindex,
1214                                          struct module *mod)
1215{
1216        return 1;
1217}
1218
1219static inline int same_magic(const char *amagic, const char *bmagic,
1220                             bool has_crcs)
1221{
1222        return strcmp(amagic, bmagic) == 0;
1223}
1224#endif /* CONFIG_MODVERSIONS */
1225
1226/* Resolve a symbol for this module.  I.e. if we find one, record usage. */
1227static const struct kernel_symbol *resolve_symbol(struct module *mod,
1228                                                  const struct load_info *info,
1229                                                  const char *name,
1230                                                  char ownername[])
1231{
1232        struct module *owner;
1233        const struct kernel_symbol *sym;
1234        const unsigned long *crc;
1235        int err;
1236
1237        mutex_lock(&module_mutex);
1238        sym = find_symbol(name, &owner, &crc,
1239                          !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
1240        if (!sym)
1241                goto unlock;
1242
1243        if (!check_version(info->sechdrs, info->index.vers, name, mod, crc,
1244                           owner)) {
1245                sym = ERR_PTR(-EINVAL);
1246                goto getname;
1247        }
1248
1249        err = ref_module(mod, owner);
1250        if (err) {
1251                sym = ERR_PTR(err);
1252                goto getname;
1253        }
1254
1255getname:
1256        /* We must make copy under the lock if we failed to get ref. */
1257        strncpy(ownername, module_name(owner), MODULE_NAME_LEN);
1258unlock:
1259        mutex_unlock(&module_mutex);
1260        return sym;
1261}
1262
1263static const struct kernel_symbol *
1264resolve_symbol_wait(struct module *mod,
1265                    const struct load_info *info,
1266                    const char *name)
1267{
1268        const struct kernel_symbol *ksym;
1269        char owner[MODULE_NAME_LEN];
1270
1271        if (wait_event_interruptible_timeout(module_wq,
1272                        !IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1273                        || PTR_ERR(ksym) != -EBUSY,
1274                                             30 * HZ) <= 0) {
1275                pr_warn("%s: gave up waiting for init of module %s.\n",
1276                        mod->name, owner);
1277        }
1278        return ksym;
1279}
1280
1281/*
1282 * /sys/module/foo/sections stuff
1283 * J. Corbet <corbet@lwn.net>
1284 */
1285#ifdef CONFIG_SYSFS
1286
1287#ifdef CONFIG_KALLSYMS
1288static inline bool sect_empty(const Elf_Shdr *sect)
1289{
1290        return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
1291}
1292
1293struct module_sect_attr
1294{
1295        struct module_attribute mattr;
1296        char *name;
1297        unsigned long address;
1298};
1299
1300struct module_sect_attrs
1301{
1302        struct attribute_group grp;
1303        unsigned int nsections;
1304        struct module_sect_attr attrs[0];
1305};
1306
1307static ssize_t module_sect_show(struct module_attribute *mattr,
1308                                struct module_kobject *mk, char *buf)
1309{
1310        struct module_sect_attr *sattr =
1311                container_of(mattr, struct module_sect_attr, mattr);
1312        return sprintf(buf, "0x%pK\n", (void *)sattr->address);
1313}
1314
1315static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
1316{
1317        unsigned int section;
1318
1319        for (section = 0; section < sect_attrs->nsections; section++)
1320                kfree(sect_attrs->attrs[section].name);
1321        kfree(sect_attrs);
1322}
1323
1324static void add_sect_attrs(struct module *mod, const struct load_info *info)
1325{
1326        unsigned int nloaded = 0, i, size[2];
1327        struct module_sect_attrs *sect_attrs;
1328        struct module_sect_attr *sattr;
1329        struct attribute **gattr;
1330
1331        /* Count loaded sections and allocate structures */
1332        for (i = 0; i < info->hdr->e_shnum; i++)
1333                if (!sect_empty(&info->sechdrs[i]))
1334                        nloaded++;
1335        size[0] = ALIGN(sizeof(*sect_attrs)
1336                        + nloaded * sizeof(sect_attrs->attrs[0]),
1337                        sizeof(sect_attrs->grp.attrs[0]));
1338        size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
1339        sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
1340        if (sect_attrs == NULL)
1341                return;
1342
1343        /* Setup section attributes. */
1344        sect_attrs->grp.name = "sections";
1345        sect_attrs->grp.attrs = (void *)sect_attrs + size[0];
1346
1347        sect_attrs->nsections = 0;
1348        sattr = &sect_attrs->attrs[0];
1349        gattr = &sect_attrs->grp.attrs[0];
1350        for (i = 0; i < info->hdr->e_shnum; i++) {
1351                Elf_Shdr *sec = &info->sechdrs[i];
1352                if (sect_empty(sec))
1353                        continue;
1354                sattr->address = sec->sh_addr;
1355                sattr->name = kstrdup(info->secstrings + sec->sh_name,
1356                                        GFP_KERNEL);
1357                if (sattr->name == NULL)
1358                        goto out;
1359                sect_attrs->nsections++;
1360                sysfs_attr_init(&sattr->mattr.attr);
1361                sattr->mattr.show = module_sect_show;
1362                sattr->mattr.store = NULL;
1363                sattr->mattr.attr.name = sattr->name;
1364                sattr->mattr.attr.mode = S_IRUGO;
1365                *(gattr++) = &(sattr++)->mattr.attr;
1366        }
1367        *gattr = NULL;
1368
1369        if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
1370                goto out;
1371
1372        mod->sect_attrs = sect_attrs;
1373        return;
1374  out:
1375        free_sect_attrs(sect_attrs);
1376}
1377
1378static void remove_sect_attrs(struct module *mod)
1379{
1380        if (mod->sect_attrs) {
1381                sysfs_remove_group(&mod->mkobj.kobj,
1382                                   &mod->sect_attrs->grp);
1383                /* We are positive that no one is using any sect attrs
1384                 * at this point.  Deallocate immediately. */
1385                free_sect_attrs(mod->sect_attrs);
1386                mod->sect_attrs = NULL;
1387        }
1388}
1389
1390/*
1391 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
1392 */
1393
1394struct module_notes_attrs {
1395        struct kobject *dir;
1396        unsigned int notes;
1397        struct bin_attribute attrs[0];
1398};
1399
1400static ssize_t module_notes_read(struct file *filp, struct kobject *kobj,
1401                                 struct bin_attribute *bin_attr,
1402                                 char *buf, loff_t pos, size_t count)
1403{
1404        /*
1405         * The caller checked the pos and count against our size.
1406         */
1407        memcpy(buf, bin_attr->private + pos, count);
1408        return count;
1409}
1410
1411static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
1412                             unsigned int i)
1413{
1414        if (notes_attrs->dir) {
1415                while (i-- > 0)
1416                        sysfs_remove_bin_file(notes_attrs->dir,
1417                                              &notes_attrs->attrs[i]);
1418                kobject_put(notes_attrs->dir);
1419        }
1420        kfree(notes_attrs);
1421}
1422
1423static void add_notes_attrs(struct module *mod, const struct load_info *info)
1424{
1425        unsigned int notes, loaded, i;
1426        struct module_notes_attrs *notes_attrs;
1427        struct bin_attribute *nattr;
1428
1429        /* failed to create section attributes, so can't create notes */
1430        if (!mod->sect_attrs)
1431                return;
1432
1433        /* Count notes sections and allocate structures.  */
1434        notes = 0;
1435        for (i = 0; i < info->hdr->e_shnum; i++)
1436                if (!sect_empty(&info->sechdrs[i]) &&
1437                    (info->sechdrs[i].sh_type == SHT_NOTE))
1438                        ++notes;
1439
1440        if (notes == 0)
1441                return;
1442
1443        notes_attrs = kzalloc(sizeof(*notes_attrs)
1444                              + notes * sizeof(notes_attrs->attrs[0]),
1445                              GFP_KERNEL);
1446        if (notes_attrs == NULL)
1447                return;
1448
1449        notes_attrs->notes = notes;
1450        nattr = &notes_attrs->attrs[0];
1451        for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
1452                if (sect_empty(&info->sechdrs[i]))
1453                        continue;
1454                if (info->sechdrs[i].sh_type == SHT_NOTE) {
1455                        sysfs_bin_attr_init(nattr);
1456                        nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
1457                        nattr->attr.mode = S_IRUGO;
1458                        nattr->size = info->sechdrs[i].sh_size;
1459                        nattr->private = (void *) info->sechdrs[i].sh_addr;
1460                        nattr->read = module_notes_read;
1461                        ++nattr;
1462                }
1463                ++loaded;
1464        }
1465
1466        notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
1467        if (!notes_attrs->dir)
1468                goto out;
1469
1470        for (i = 0; i < notes; ++i)
1471                if (sysfs_create_bin_file(notes_attrs->dir,
1472                                          &notes_attrs->attrs[i]))
1473                        goto out;
1474
1475        mod->notes_attrs = notes_attrs;
1476        return;
1477
1478  out:
1479        free_notes_attrs(notes_attrs, i);
1480}
1481
1482static void remove_notes_attrs(struct module *mod)
1483{
1484        if (mod->notes_attrs)
1485                free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
1486}
1487
1488#else
1489
1490static inline void add_sect_attrs(struct module *mod,
1491                                  const struct load_info *info)
1492{
1493}
1494
1495static inline void remove_sect_attrs(struct module *mod)
1496{
1497}
1498
1499static inline void add_notes_attrs(struct module *mod,
1500                                   const struct load_info *info)
1501{
1502}
1503
1504static inline void remove_notes_attrs(struct module *mod)
1505{
1506}
1507#endif /* CONFIG_KALLSYMS */
1508
1509static void add_usage_links(struct module *mod)
1510{
1511#ifdef CONFIG_MODULE_UNLOAD
1512        struct module_use *use;
1513        int nowarn;
1514
1515        mutex_lock(&module_mutex);
1516        list_for_each_entry(use, &mod->target_list, target_list) {
1517                nowarn = sysfs_create_link(use->target->holders_dir,
1518                                           &mod->mkobj.kobj, mod->name);
1519        }
1520        mutex_unlock(&module_mutex);
1521#endif
1522}
1523
1524static void del_usage_links(struct module *mod)
1525{
1526#ifdef CONFIG_MODULE_UNLOAD
1527        struct module_use *use;
1528
1529        mutex_lock(&module_mutex);
1530        list_for_each_entry(use, &mod->target_list, target_list)
1531                sysfs_remove_link(use->target->holders_dir, mod->name);
1532        mutex_unlock(&module_mutex);
1533#endif
1534}
1535
1536static int module_add_modinfo_attrs(struct module *mod)
1537{
1538        struct module_attribute *attr;
1539        struct module_attribute *temp_attr;
1540        int error = 0;
1541        int i;
1542
1543        mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
1544                                        (ARRAY_SIZE(modinfo_attrs) + 1)),
1545                                        GFP_KERNEL);
1546        if (!mod->modinfo_attrs)
1547                return -ENOMEM;
1548
1549        temp_attr = mod->modinfo_attrs;
1550        for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
1551                if (!attr->test ||
1552                    (attr->test && attr->test(mod))) {
1553                        memcpy(temp_attr, attr, sizeof(*temp_attr));
1554                        sysfs_attr_init(&temp_attr->attr);
1555                        error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
1556                        ++temp_attr;
1557                }
1558        }
1559        return error;
1560}
1561
1562static void module_remove_modinfo_attrs(struct module *mod)
1563{
1564        struct module_attribute *attr;
1565        int i;
1566
1567        for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
1568                /* pick a field to test for end of list */
1569                if (!attr->attr.name)
1570                        break;
1571                sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);
1572                if (attr->free)
1573                        attr->free(mod);
1574        }
1575        kfree(mod->modinfo_attrs);
1576}
1577
1578static void mod_kobject_put(struct module *mod)
1579{
1580        DECLARE_COMPLETION_ONSTACK(c);
1581        mod->mkobj.kobj_completion = &c;
1582        kobject_put(&mod->mkobj.kobj);
1583        wait_for_completion(&c);
1584}
1585
1586static int mod_sysfs_init(struct module *mod)
1587{
1588        int err;
1589        struct kobject *kobj;
1590
1591        if (!module_sysfs_initialized) {
1592                pr_err("%s: module sysfs not initialized\n", mod->name);
1593                err = -EINVAL;
1594                goto out;
1595        }
1596
1597        kobj = kset_find_obj(module_kset, mod->name);
1598        if (kobj) {
1599                pr_err("%s: module is already loaded\n", mod->name);
1600                kobject_put(kobj);
1601                err = -EINVAL;
1602                goto out;
1603        }
1604
1605        mod->mkobj.mod = mod;
1606
1607        memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
1608        mod->mkobj.kobj.kset = module_kset;
1609        err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
1610                                   "%s", mod->name);
1611        if (err)
1612                mod_kobject_put(mod);
1613
1614        /* delay uevent until full sysfs population */
1615out:
1616        return err;
1617}
1618
1619static int mod_sysfs_setup(struct module *mod,
1620                           const struct load_info *info,
1621                           struct kernel_param *kparam,
1622                           unsigned int num_params)
1623{
1624        int err;
1625
1626        err = mod_sysfs_init(mod);
1627        if (err)
1628                goto out;
1629
1630        mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
1631        if (!mod->holders_dir) {
1632                err = -ENOMEM;
1633                goto out_unreg;
1634        }
1635
1636        err = module_param_sysfs_setup(mod, kparam, num_params);
1637        if (err)
1638                goto out_unreg_holders;
1639
1640        err = module_add_modinfo_attrs(mod);
1641        if (err)
1642                goto out_unreg_param;
1643
1644        add_usage_links(mod);
1645        add_sect_attrs(mod, info);
1646        add_notes_attrs(mod, info);
1647
1648        kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
1649        return 0;
1650
1651out_unreg_param:
1652        module_param_sysfs_remove(mod);
1653out_unreg_holders:
1654        kobject_put(mod->holders_dir);
1655out_unreg:
1656        mod_kobject_put(mod);
1657out:
1658        return err;
1659}
1660
1661static void mod_sysfs_fini(struct module *mod)
1662{
1663        remove_notes_attrs(mod);
1664        remove_sect_attrs(mod);
1665        mod_kobject_put(mod);
1666}
1667
1668#else /* !CONFIG_SYSFS */
1669
1670static int mod_sysfs_setup(struct module *mod,
1671                           const struct load_info *info,
1672                           struct kernel_param *kparam,
1673                           unsigned int num_params)
1674{
1675        return 0;
1676}
1677
1678static void mod_sysfs_fini(struct module *mod)
1679{
1680}
1681
1682static void module_remove_modinfo_attrs(struct module *mod)
1683{
1684}
1685
1686static void del_usage_links(struct module *mod)
1687{
1688}
1689
1690#endif /* CONFIG_SYSFS */
1691
1692static void mod_sysfs_teardown(struct module *mod)
1693{
1694        del_usage_links(mod);
1695        module_remove_modinfo_attrs(mod);
1696        module_param_sysfs_remove(mod);
1697        kobject_put(mod->mkobj.drivers_dir);
1698        kobject_put(mod->holders_dir);
1699        mod_sysfs_fini(mod);
1700}
1701
1702/*
1703 * unlink the module with the whole machine is stopped with interrupts off
1704 * - this defends against kallsyms not taking locks
1705 */
1706static int __unlink_module(void *_mod)
1707{
1708        struct module *mod = _mod;
1709        list_del(&mod->list);
1710        module_bug_cleanup(mod);
1711        return 0;
1712}
1713
1714#ifdef CONFIG_DEBUG_SET_MODULE_RONX
1715/*
1716 * LKM RO/NX protection: protect module's text/ro-data
1717 * from modification and any data from execution.
1718 */
1719void set_page_attributes(void *start, void *end, int (*set)(unsigned long start, int num_pages))
1720{
1721        unsigned long begin_pfn = PFN_DOWN((unsigned long)start);
1722        unsigned long end_pfn = PFN_DOWN((unsigned long)end);
1723
1724        if (end_pfn > begin_pfn)
1725                set(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1726}
1727
1728static void set_section_ro_nx(void *base,
1729                        unsigned long text_size,
1730                        unsigned long ro_size,
1731                        unsigned long total_size)
1732{
1733        /* begin and end PFNs of the current subsection */
1734        unsigned long begin_pfn;
1735        unsigned long end_pfn;
1736
1737        /*
1738         * Set RO for module text and RO-data:
1739         * - Always protect first page.
1740         * - Do not protect last partial page.
1741         */
1742        if (ro_size > 0)
1743                set_page_attributes(base, base + ro_size, set_memory_ro);
1744
1745        /*
1746         * Set NX permissions for module data:
1747         * - Do not protect first partial page.
1748         * - Always protect last page.
1749         */
1750        if (total_size > text_size) {
1751                begin_pfn = PFN_UP((unsigned long)base + text_size);
1752                end_pfn = PFN_UP((unsigned long)base + total_size);
1753                if (end_pfn > begin_pfn)
1754                        set_memory_nx(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1755        }
1756}
1757
1758static void unset_module_core_ro_nx(struct module *mod)
1759{
1760        set_page_attributes(mod->module_core + mod->core_text_size,
1761                mod->module_core + mod->core_size,
1762                set_memory_x);
1763        set_page_attributes(mod->module_core,
1764                mod->module_core + mod->core_ro_size,
1765                set_memory_rw);
1766}
1767
1768static void unset_module_init_ro_nx(struct module *mod)
1769{
1770        set_page_attributes(mod->module_init + mod->init_text_size,
1771                mod->module_init + mod->init_size,
1772                set_memory_x);
1773        set_page_attributes(mod->module_init,
1774                mod->module_init + mod->init_ro_size,
1775                set_memory_rw);
1776}
1777
1778/* Iterate through all modules and set each module's text as RW */
1779void set_all_modules_text_rw(void)
1780{
1781        struct module *mod;
1782
1783        mutex_lock(&module_mutex);
1784        list_for_each_entry_rcu(mod, &modules, list) {
1785                if (mod->state == MODULE_STATE_UNFORMED)
1786                        continue;
1787                if ((mod->module_core) && (mod->core_text_size)) {
1788                        set_page_attributes(mod->module_core,
1789                                                mod->module_core + mod->core_text_size,
1790                                                set_memory_rw);
1791                }
1792                if ((mod->module_init) && (mod->init_text_size)) {
1793                        set_page_attributes(mod->module_init,
1794                                                mod->module_init + mod->init_text_size,
1795                                                set_memory_rw);
1796                }
1797        }
1798        mutex_unlock(&module_mutex);
1799}
1800
1801/* Iterate through all modules and set each module's text as RO */
1802void set_all_modules_text_ro(void)
1803{
1804        struct module *mod;
1805
1806        mutex_lock(&module_mutex);
1807        list_for_each_entry_rcu(mod, &modules, list) {
1808                if (mod->state == MODULE_STATE_UNFORMED)
1809                        continue;
1810                if ((mod->module_core) && (mod->core_text_size)) {
1811                        set_page_attributes(mod->module_core,
1812                                                mod->module_core + mod->core_text_size,
1813                                                set_memory_ro);
1814                }
1815                if ((mod->module_init) && (mod->init_text_size)) {
1816                        set_page_attributes(mod->module_init,
1817                                                mod->module_init + mod->init_text_size,
1818                                                set_memory_ro);
1819                }
1820        }
1821        mutex_unlock(&module_mutex);
1822}
1823#else
1824static inline void set_section_ro_nx(void *base, unsigned long text_size, unsigned long ro_size, unsigned long total_size) { }
1825static void unset_module_core_ro_nx(struct module *mod) { }
1826static void unset_module_init_ro_nx(struct module *mod) { }
1827#endif
1828
1829void __weak module_free(struct module *mod, void *module_region)
1830{
1831        vfree(module_region);
1832}
1833
1834void __weak module_arch_cleanup(struct module *mod)
1835{
1836}
1837
1838/* Free a module, remove from lists, etc. */
1839static void free_module(struct module *mod)
1840{
1841        trace_module_free(mod);
1842
1843        mod_sysfs_teardown(mod);
1844
1845        /* We leave it in list to prevent duplicate loads, but make sure
1846         * that noone uses it while it's being deconstructed. */
1847        mod->state = MODULE_STATE_UNFORMED;
1848
1849        /* Remove dynamic debug info */
1850        ddebug_remove_module(mod->name);
1851
1852        /* Arch-specific cleanup. */
1853        module_arch_cleanup(mod);
1854
1855        /* Module unload stuff */
1856        module_unload_free(mod);
1857
1858        /* Free any allocated parameters. */
1859        destroy_params(mod->kp, mod->num_kp);
1860
1861        /* Now we can delete it from the lists */
1862        mutex_lock(&module_mutex);
1863        stop_machine(__unlink_module, mod, NULL);
1864        mutex_unlock(&module_mutex);
1865
1866        /* This may be NULL, but that's OK */
1867        unset_module_init_ro_nx(mod);
1868        module_free(mod, mod->module_init);
1869        kfree(mod->args);
1870        percpu_modfree(mod);
1871
1872        /* Free lock-classes: */
1873        lockdep_free_key_range(mod->module_core, mod->core_size);
1874
1875        /* Finally, free the core (containing the module structure) */
1876        unset_module_core_ro_nx(mod);
1877        module_free(mod, mod->module_core);
1878
1879#ifdef CONFIG_MPU
1880        update_protections(current->mm);
1881#endif
1882}
1883
1884void *__symbol_get(const char *symbol)
1885{
1886        struct module *owner;
1887        const struct kernel_symbol *sym;
1888
1889        preempt_disable();
1890        sym = find_symbol(symbol, &owner, NULL, true, true);
1891        if (sym && strong_try_module_get(owner))
1892                sym = NULL;
1893        preempt_enable();
1894
1895        return sym ? (void *)sym->value : NULL;
1896}
1897EXPORT_SYMBOL_GPL(__symbol_get);
1898
1899/*
1900 * Ensure that an exported symbol [global namespace] does not already exist
1901 * in the kernel or in some other module's exported symbol table.
1902 *
1903 * You must hold the module_mutex.
1904 */
1905static int verify_export_symbols(struct module *mod)
1906{
1907        unsigned int i;
1908        struct module *owner;
1909        const struct kernel_symbol *s;
1910        struct {
1911                const struct kernel_symbol *sym;
1912                unsigned int num;
1913        } arr[] = {
1914                { mod->syms, mod->num_syms },
1915                { mod->gpl_syms, mod->num_gpl_syms },
1916                { mod->gpl_future_syms, mod->num_gpl_future_syms },
1917#ifdef CONFIG_UNUSED_SYMBOLS
1918                { mod->unused_syms, mod->num_unused_syms },
1919                { mod->unused_gpl_syms, mod->num_unused_gpl_syms },
1920#endif
1921        };
1922
1923        for (i = 0; i < ARRAY_SIZE(arr); i++) {
1924                for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
1925                        if (find_symbol(s->name, &owner, NULL, true, false)) {
1926                                pr_err("%s: exports duplicate symbol %s"
1927                                       " (owned by %s)\n",
1928                                       mod->name, s->name, module_name(owner));
1929                                return -ENOEXEC;
1930                        }
1931                }
1932        }
1933        return 0;
1934}
1935
1936/* Change all symbols so that st_value encodes the pointer directly. */
1937static int simplify_symbols(struct module *mod, const struct load_info *info)
1938{
1939        Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
1940        Elf_Sym *sym = (void *)symsec->sh_addr;
1941        unsigned long secbase;
1942        unsigned int i;
1943        int ret = 0;
1944        const struct kernel_symbol *ksym;
1945
1946        for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
1947                const char *name = info->strtab + sym[i].st_name;
1948
1949                switch (sym[i].st_shndx) {
1950                case SHN_COMMON:
1951                        /* We compiled with -fno-common.  These are not
1952                           supposed to happen.  */
1953                        pr_debug("Common symbol: %s\n", name);
1954                        printk("%s: please compile with -fno-common\n",
1955                               mod->name);
1956                        ret = -ENOEXEC;
1957                        break;
1958
1959                case SHN_ABS:
1960                        /* Don't need to do anything */
1961                        pr_debug("Absolute symbol: 0x%08lx\n",
1962                               (long)sym[i].st_value);
1963                        break;
1964
1965                case SHN_UNDEF:
1966                        ksym = resolve_symbol_wait(mod, info, name);
1967                        /* Ok if resolved.  */
1968                        if (ksym && !IS_ERR(ksym)) {
1969                                sym[i].st_value = ksym->value;
1970                                break;
1971                        }
1972
1973                        /* Ok if weak.  */
1974                        if (!ksym && ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
1975                                break;
1976
1977                        pr_warn("%s: Unknown symbol %s (err %li)\n",
1978                                mod->name, name, PTR_ERR(ksym));
1979                        ret = PTR_ERR(ksym) ?: -ENOENT;
1980                        break;
1981
1982                default:
1983                        /* Divert to percpu allocation if a percpu var. */
1984                        if (sym[i].st_shndx == info->index.pcpu)
1985                                secbase = (unsigned long)mod_percpu(mod);
1986                        else
1987                                secbase = info->sechdrs[sym[i].st_shndx].sh_addr;
1988                        sym[i].st_value += secbase;
1989                        break;
1990                }
1991        }
1992
1993        return ret;
1994}
1995
1996static int apply_relocations(struct module *mod, const struct load_info *info)
1997{
1998        unsigned int i;
1999        int err = 0;
2000
2001        /* Now do relocations. */
2002        for (i = 1; i < info->hdr->e_shnum; i++) {
2003                unsigned int infosec = info->sechdrs[i].sh_info;
2004
2005                /* Not a valid relocation section? */
2006                if (infosec >= info->hdr->e_shnum)
2007                        continue;
2008
2009                /* Don't bother with non-allocated sections */
2010                if (!(info->sechdrs[infosec].sh_flags & SHF_ALLOC))
2011                        continue;
2012
2013                if (info->sechdrs[i].sh_type == SHT_REL)
2014                        err = apply_relocate(info->sechdrs, info->strtab,
2015                                             info->index.sym, i, mod);
2016                else if (info->sechdrs[i].sh_type == SHT_RELA)
2017                        err = apply_relocate_add(info->sechdrs, info->strtab,
2018                                                 info->index.sym, i, mod);
2019                if (err < 0)
2020                        break;
2021        }
2022        return err;
2023}
2024
2025/* Additional bytes needed by arch in front of individual sections */
2026unsigned int __weak arch_mod_section_prepend(struct module *mod,
2027                                             unsigned int section)
2028{
2029        /* default implementation just returns zero */
2030        return 0;
2031}
2032
2033/* Update size with this section: return offset. */
2034static long get_offset(struct module *mod, unsigned int *size,
2035                       Elf_Shdr *sechdr, unsigned int section)
2036{
2037        long ret;
2038
2039        *size += arch_mod_section_prepend(mod, section);
2040        ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
2041        *size = ret + sechdr->sh_size;
2042        return ret;
2043}
2044
2045/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
2046   might -- code, read-only data, read-write data, small data.  Tally
2047   sizes, and place the offsets into sh_entsize fields: high bit means it
2048   belongs in init. */
2049static void layout_sections(struct module *mod, struct load_info *info)
2050{
2051        static unsigned long const masks[][2] = {
2052                /* NOTE: all executable code must be the first section
2053                 * in this array; otherwise modify the text_size
2054                 * finder in the two loops below */
2055                { SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },
2056                { SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },
2057                { SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },
2058                { ARCH_SHF_SMALL | SHF_ALLOC, 0 }
2059        };
2060        unsigned int m, i;
2061
2062        for (i = 0; i < info->hdr->e_shnum; i++)
2063                info->sechdrs[i].sh_entsize = ~0UL;
2064
2065        pr_debug("Core section allocation order:\n");
2066        for (m = 0; m < ARRAY_SIZE(masks); ++m) {
2067                for (i = 0; i < info->hdr->e_shnum; ++i) {
2068                        Elf_Shdr *s = &info->sechdrs[i];
2069                        const char *sname = info->secstrings + s->sh_name;
2070
2071                        if ((s->sh_flags & masks[m][0]) != masks[m][0]
2072                            || (s->sh_flags & masks[m][1])
2073                            || s->sh_entsize != ~0UL
2074                            || strstarts(sname, ".init"))
2075                                continue;
2076                        s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
2077                        pr_debug("\t%s\n", sname);
2078                }
2079                switch (m) {
2080                case 0: /* executable */
2081                        mod->core_size = debug_align(mod->core_size);
2082                        mod->core_text_size = mod->core_size;
2083                        break;
2084                case 1: /* RO: text and ro-data */
2085                        mod->core_size = debug_align(mod->core_size);
2086                        mod->core_ro_size = mod->core_size;
2087                        break;
2088                case 3: /* whole core */
2089                        mod->core_size = debug_align(mod->core_size);
2090                        break;
2091                }
2092        }
2093
2094        pr_debug("Init section allocation order:\n");
2095        for (m = 0; m < ARRAY_SIZE(masks); ++m) {
2096                for (i = 0; i < info->hdr->e_shnum; ++i) {
2097                        Elf_Shdr *s = &info->sechdrs[i];
2098                        const char *sname = info->secstrings + s->sh_name;
2099
2100                        if ((s->sh_flags & masks[m][0]) != masks[m][0]
2101                            || (s->sh_flags & masks[m][1])
2102                            || s->sh_entsize != ~0UL
2103                            || !strstarts(sname, ".init"))
2104                                continue;
2105                        s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
2106                                         | INIT_OFFSET_MASK);
2107                        pr_debug("\t%s\n", sname);
2108                }
2109                switch (m) {
2110                case 0: /* executable */
2111                        mod->init_size = debug_align(mod->init_size);
2112                        mod->init_text_size = mod->init_size;
2113                        break;
2114                case 1: /* RO: text and ro-data */
2115                        mod->init_size = debug_align(mod->init_size);
2116                        mod->init_ro_size = mod->init_size;
2117                        break;
2118                case 3: /* whole init */
2119                        mod->init_size = debug_align(mod->init_size);
2120                        break;
2121                }
2122        }
2123}
2124
2125static void set_license(struct module *mod, const char *license)
2126{
2127        if (!license)
2128                license = "unspecified";
2129
2130        if (!license_is_gpl_compatible(license)) {
2131                if (!test_taint(TAINT_PROPRIETARY_MODULE))
2132                        pr_warn("%s: module license '%s' taints kernel.\n",
2133                                mod->name, license);
2134                add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2135                                 LOCKDEP_NOW_UNRELIABLE);
2136        }
2137}
2138
2139/* Parse tag=value strings from .modinfo section */
2140static char *next_string(char *string, unsigned long *secsize)
2141{
2142        /* Skip non-zero chars */
2143        while (string[0]) {
2144                string++;
2145                if ((*secsize)-- <= 1)
2146                        return NULL;
2147        }
2148
2149        /* Skip any zero padding. */
2150        while (!string[0]) {
2151                string++;
2152                if ((*secsize)-- <= 1)
2153                        return NULL;
2154        }
2155        return string;
2156}
2157
2158static char *get_modinfo(struct load_info *info, const char *tag)
2159{
2160        char *p;
2161        unsigned int taglen = strlen(tag);
2162        Elf_Shdr *infosec = &info->sechdrs[info->index.info];
2163        unsigned long size = infosec->sh_size;
2164
2165        for (p = (char *)infosec->sh_addr; p; p = next_string(p, &size)) {
2166                if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
2167                        return p + taglen + 1;
2168        }
2169        return NULL;
2170}
2171
2172static void setup_modinfo(struct module *mod, struct load_info *info)
2173{
2174        struct module_attribute *attr;
2175        int i;
2176
2177        for (i = 0; (attr = modinfo_attrs[i]); i++) {
2178                if (attr->setup)
2179                        attr->setup(mod, get_modinfo(info, attr->attr.name));
2180        }
2181}
2182
2183static void free_modinfo(struct module *mod)
2184{
2185        struct module_attribute *attr;
2186        int i;
2187
2188        for (i = 0; (attr = modinfo_attrs[i]); i++) {
2189                if (attr->free)
2190                        attr->free(mod);
2191        }
2192}
2193
2194#ifdef CONFIG_KALLSYMS
2195
2196/* lookup symbol in given range of kernel_symbols */
2197static const struct kernel_symbol *lookup_symbol(const char *name,
2198        const struct kernel_symbol *start,
2199        const struct kernel_symbol *stop)
2200{
2201        return bsearch(name, start, stop - start,
2202                        sizeof(struct kernel_symbol), cmp_name);
2203}
2204
2205static int is_exported(const char *name, unsigned long value,
2206                       const struct module *mod)
2207{
2208        const struct kernel_symbol *ks;
2209        if (!mod)
2210                ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
2211        else
2212                ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
2213        return ks != NULL && ks->value == value;
2214}
2215
2216/* As per nm */
2217static char elf_type(const Elf_Sym *sym, const struct load_info *info)
2218{
2219        const Elf_Shdr *sechdrs = info->sechdrs;
2220
2221        if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
2222                if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
2223                        return 'v';
2224                else
2225                        return 'w';
2226        }
2227        if (sym->st_shndx == SHN_UNDEF)
2228                return 'U';
2229        if (sym->st_shndx == SHN_ABS)
2230                return 'a';
2231        if (sym->st_shndx >= SHN_LORESERVE)
2232                return '?';
2233        if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
2234                return 't';
2235        if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC
2236            && sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
2237                if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
2238                        return 'r';
2239                else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2240                        return 'g';
2241                else
2242                        return 'd';
2243        }
2244        if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
2245                if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2246                        return 's';
2247                else
2248                        return 'b';
2249        }
2250        if (strstarts(info->secstrings + sechdrs[sym->st_shndx].sh_name,
2251                      ".debug")) {
2252                return 'n';
2253        }
2254        return '?';
2255}
2256
2257static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,
2258                           unsigned int shnum)
2259{
2260        const Elf_Shdr *sec;
2261
2262        if (src->st_shndx == SHN_UNDEF
2263            || src->st_shndx >= shnum
2264            || !src->st_name)
2265                return false;
2266
2267        sec = sechdrs + src->st_shndx;
2268        if (!(sec->sh_flags & SHF_ALLOC)
2269#ifndef CONFIG_KALLSYMS_ALL
2270            || !(sec->sh_flags & SHF_EXECINSTR)
2271#endif
2272            || (sec->sh_entsize & INIT_OFFSET_MASK))
2273                return false;
2274
2275        return true;
2276}
2277
2278/*
2279 * We only allocate and copy the strings needed by the parts of symtab
2280 * we keep.  This is simple, but has the effect of making multiple
2281 * copies of duplicates.  We could be more sophisticated, see
2282 * linux-kernel thread starting with
2283 * <73defb5e4bca04a6431392cc341112b1@localhost>.
2284 */
2285static void layout_symtab(struct module *mod, struct load_info *info)
2286{
2287        Elf_Shdr *symsect = info->sechdrs + info->index.sym;
2288        Elf_Shdr *strsect = info->sechdrs + info->index.str;
2289        const Elf_Sym *src;
2290        unsigned int i, nsrc, ndst, strtab_size = 0;
2291
2292        /* Put symbol section at end of init part of module. */
2293        symsect->sh_flags |= SHF_ALLOC;
2294        symsect->sh_entsize = get_offset(mod, &mod->init_size, symsect,
2295                                         info->index.sym) | INIT_OFFSET_MASK;
2296        pr_debug("\t%s\n", info->secstrings + symsect->sh_name);
2297
2298        src = (void *)info->hdr + symsect->sh_offset;
2299        nsrc = symsect->sh_size / sizeof(*src);
2300
2301        /* Compute total space required for the core symbols' strtab. */
2302        for (ndst = i = 0; i < nsrc; i++) {
2303                if (i == 0 ||
2304                    is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2305                        strtab_size += strlen(&info->strtab[src[i].st_name])+1;
2306                        ndst++;
2307                }
2308        }
2309
2310        /* Append room for core symbols at end of core part. */
2311        info->symoffs = ALIGN(mod->core_size, symsect->sh_addralign ?: 1);
2312        info->stroffs = mod->core_size = info->symoffs + ndst * sizeof(Elf_Sym);
2313        mod->core_size += strtab_size;
2314
2315        /* Put string table section at end of init part of module. */
2316        strsect->sh_flags |= SHF_ALLOC;
2317        strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
2318                                         info->index.str) | INIT_OFFSET_MASK;
2319        pr_debug("\t%s\n", info->secstrings + strsect->sh_name);
2320}
2321
2322static void add_kallsyms(struct module *mod, const struct load_info *info)
2323{
2324        unsigned int i, ndst;
2325        const Elf_Sym *src;
2326        Elf_Sym *dst;
2327        char *s;
2328        Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
2329
2330        mod->symtab = (void *)symsec->sh_addr;
2331        mod->num_symtab = symsec->sh_size / sizeof(Elf_Sym);
2332        /* Make sure we get permanent strtab: don't use info->strtab. */
2333        mod->strtab = (void *)info->sechdrs[info->index.str].sh_addr;
2334
2335        /* Set types up while we still have access to sections. */
2336        for (i = 0; i < mod->num_symtab; i++)
2337                mod->symtab[i].st_info = elf_type(&mod->symtab[i], info);
2338
2339        mod->core_symtab = dst = mod->module_core + info->symoffs;
2340        mod->core_strtab = s = mod->module_core + info->stroffs;
2341        src = mod->symtab;
2342        for (ndst = i = 0; i < mod->num_symtab; i++) {
2343                if (i == 0 ||
2344                    is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2345                        dst[ndst] = src[i];
2346                        dst[ndst++].st_name = s - mod->core_strtab;
2347                        s += strlcpy(s, &mod->strtab[src[i].st_name],
2348                                     KSYM_NAME_LEN) + 1;
2349                }
2350        }
2351        mod->core_num_syms = ndst;
2352}
2353#else
2354static inline void layout_symtab(struct module *mod, struct load_info *info)
2355{
2356}
2357
2358static void add_kallsyms(struct module *mod, const struct load_info *info)
2359{
2360}
2361#endif /* CONFIG_KALLSYMS */
2362
2363static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
2364{
2365        if (!debug)
2366                return;
2367#ifdef CONFIG_DYNAMIC_DEBUG
2368        if (ddebug_add_module(debug, num, debug->modname))
2369                pr_err("dynamic debug error adding module: %s\n",
2370                        debug->modname);
2371#endif
2372}
2373
2374static void dynamic_debug_remove(struct _ddebug *debug)
2375{
2376        if (debug)
2377                ddebug_remove_module(debug->modname);
2378}
2379
2380void * __weak module_alloc(unsigned long size)
2381{
2382        return vmalloc_exec(size);
2383}
2384
2385static void *module_alloc_update_bounds(unsigned long size)
2386{
2387        void *ret = module_alloc(size);
2388
2389        if (ret) {
2390                mutex_lock(&module_mutex);
2391                /* Update module bounds. */
2392                if ((unsigned long)ret < module_addr_min)
2393                        module_addr_min = (unsigned long)ret;
2394                if ((unsigned long)ret + size > module_addr_max)
2395                        module_addr_max = (unsigned long)ret + size;
2396                mutex_unlock(&module_mutex);
2397        }
2398        return ret;
2399}
2400
2401#ifdef CONFIG_DEBUG_KMEMLEAK
2402static void kmemleak_load_module(const struct module *mod,
2403                                 const struct load_info *info)
2404{
2405        unsigned int i;
2406
2407        /* only scan the sections containing data */
2408        kmemleak_scan_area(mod, sizeof(struct module), GFP_KERNEL);
2409
2410        for (i = 1; i < info->hdr->e_shnum; i++) {
2411                /* Scan all writable sections that's not executable */
2412                if (!(info->sechdrs[i].sh_flags & SHF_ALLOC) ||
2413                    !(info->sechdrs[i].sh_flags & SHF_WRITE) ||
2414                    (info->sechdrs[i].sh_flags & SHF_EXECINSTR))
2415                        continue;
2416
2417                kmemleak_scan_area((void *)info->sechdrs[i].sh_addr,
2418                                   info->sechdrs[i].sh_size, GFP_KERNEL);
2419        }
2420}
2421#else
2422static inline void kmemleak_load_module(const struct module *mod,
2423                                        const struct load_info *info)
2424{
2425}
2426#endif
2427
2428#ifdef CONFIG_MODULE_SIG
2429static int module_sig_check(struct load_info *info)
2430{
2431        int err = -ENOKEY;
2432        const unsigned long markerlen = sizeof(MODULE_SIG_STRING) - 1;
2433        const void *mod = info->hdr;
2434
2435        if (info->len > markerlen &&
2436            memcmp(mod + info->len - markerlen, MODULE_SIG_STRING, markerlen) == 0) {
2437                /* We truncate the module to discard the signature */
2438                info->len -= markerlen;
2439                err = mod_verify_sig(mod, &info->len);
2440        }
2441
2442        if (!err) {
2443                info->sig_ok = true;
2444                return 0;
2445        }
2446
2447        /* Not having a signature is only an error if we're strict. */
2448        if (err < 0 && fips_enabled)
2449                panic("Module verification failed with error %d in FIPS mode\n",
2450                      err);
2451        if (err == -ENOKEY && !sig_enforce)
2452                err = 0;
2453
2454        return err;
2455}
2456#else /* !CONFIG_MODULE_SIG */
2457static int module_sig_check(struct load_info *info)
2458{
2459        return 0;
2460}
2461#endif /* !CONFIG_MODULE_SIG */
2462
2463/* Sanity checks against invalid binaries, wrong arch, weird elf version. */
2464static int elf_header_check(struct load_info *info)
2465{
2466        if (info->len < sizeof(*(info->hdr)))
2467                return -ENOEXEC;
2468
2469        if (memcmp(info->hdr->e_ident, ELFMAG, SELFMAG) != 0
2470            || info->hdr->e_type != ET_REL
2471            || !elf_check_arch(info->hdr)
2472            || info->hdr->e_shentsize != sizeof(Elf_Shdr))
2473                return -ENOEXEC;
2474
2475        if (info->hdr->e_shoff >= info->len
2476            || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
2477                info->len - info->hdr->e_shoff))
2478                return -ENOEXEC;
2479
2480        return 0;
2481}
2482
2483/* Sets info->hdr and info->len. */
2484static int copy_module_from_user(const void __user *umod, unsigned long len,
2485                                  struct load_info *info)
2486{
2487        int err;
2488
2489        info->len = len;
2490        if (info->len < sizeof(*(info->hdr)))
2491                return -ENOEXEC;
2492
2493        err = security_kernel_module_from_file(NULL);
2494        if (err)
2495                return err;
2496
2497        /* Suck in entire file: we'll want most of it. */
2498        info->hdr = vmalloc(info->len);
2499        if (!info->hdr)
2500                return -ENOMEM;
2501
2502        if (copy_from_user(info->hdr, umod, info->len) != 0) {
2503                vfree(info->hdr);
2504                return -EFAULT;
2505        }
2506
2507        return 0;
2508}
2509
2510/* Sets info->hdr and info->len. */
2511static int copy_module_from_fd(int fd, struct load_info *info)
2512{
2513        struct fd f = fdget(fd);
2514        int err;
2515        struct kstat stat;
2516        loff_t pos;
2517        ssize_t bytes = 0;
2518
2519        if (!f.file)
2520                return -ENOEXEC;
2521
2522        err = security_kernel_module_from_file(f.file);
2523        if (err)
2524                goto out;
2525
2526        err = vfs_getattr(&f.file->f_path, &stat);
2527        if (err)
2528                goto out;
2529
2530        if (stat.size > INT_MAX) {
2531                err = -EFBIG;
2532                goto out;
2533        }
2534
2535        /* Don't hand 0 to vmalloc, it whines. */
2536        if (stat.size == 0) {
2537                err = -EINVAL;
2538                goto out;
2539        }
2540
2541        info->hdr = vmalloc(stat.size);
2542        if (!info->hdr) {
2543                err = -ENOMEM;
2544                goto out;
2545        }
2546
2547        pos = 0;
2548        while (pos < stat.size) {
2549                bytes = kernel_read(f.file, pos, (char *)(info->hdr) + pos,
2550                                    stat.size - pos);
2551                if (bytes < 0) {
2552                        vfree(info->hdr);
2553                        err = bytes;
2554                        goto out;
2555                }
2556                if (bytes == 0)
2557                        break;
2558                pos += bytes;
2559        }
2560        info->len = pos;
2561
2562out:
2563        fdput(f);
2564        return err;
2565}
2566
2567static void free_copy(struct load_info *info)
2568{
2569        vfree(info->hdr);
2570}
2571
2572static int rewrite_section_headers(struct load_info *info, int flags)
2573{
2574        unsigned int i;
2575
2576        /* This should always be true, but let's be sure. */
2577        info->sechdrs[0].sh_addr = 0;
2578
2579        for (i = 1; i < info->hdr->e_shnum; i++) {
2580                Elf_Shdr *shdr = &info->sechdrs[i];
2581                if (shdr->sh_type != SHT_NOBITS
2582                    && info->len < shdr->sh_offset + shdr->sh_size) {
2583                        pr_err("Module len %lu truncated\n", info->len);
2584                        return -ENOEXEC;
2585                }
2586
2587                /* Mark all sections sh_addr with their address in the
2588                   temporary image. */
2589                shdr->sh_addr = (size_t)info->hdr + shdr->sh_offset;
2590
2591#ifndef CONFIG_MODULE_UNLOAD
2592                /* Don't load .exit sections */
2593                if (strstarts(info->secstrings+shdr->sh_name, ".exit"))
2594                        shdr->sh_flags &= ~(unsigned long)SHF_ALLOC;
2595#endif
2596        }
2597
2598        /* Track but don't keep modinfo and version sections. */
2599        if (flags & MODULE_INIT_IGNORE_MODVERSIONS)
2600                info->index.vers = 0; /* Pretend no __versions section! */
2601        else
2602                info->index.vers = find_sec(info, "__versions");
2603        info->index.info = find_sec(info, ".modinfo");
2604        info->sechdrs[info->index.info].sh_flags &= ~(unsigned long)SHF_ALLOC;
2605        info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
2606        return 0;
2607}
2608
2609/*
2610 * Set up our basic convenience variables (pointers to section headers,
2611 * search for module section index etc), and do some basic section
2612 * verification.
2613 *
2614 * Return the temporary module pointer (we'll replace it with the final
2615 * one when we move the module sections around).
2616 */
2617static struct module *setup_load_info(struct load_info *info, int flags)
2618{
2619        unsigned int i;
2620        int err;
2621        struct module *mod;
2622
2623        /* Set up the convenience variables */
2624        info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
2625        info->secstrings = (void *)info->hdr
2626                + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
2627
2628        err = rewrite_section_headers(info, flags);
2629        if (err)
2630                return ERR_PTR(err);
2631
2632        /* Find internal symbols and strings. */
2633        for (i = 1; i < info->hdr->e_shnum; i++) {
2634                if (info->sechdrs[i].sh_type == SHT_SYMTAB) {
2635                        info->index.sym = i;
2636                        info->index.str = info->sechdrs[i].sh_link;
2637                        info->strtab = (char *)info->hdr
2638                                + info->sechdrs[info->index.str].sh_offset;
2639                        break;
2640                }
2641        }
2642
2643        info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
2644        if (!info->index.mod) {
2645                pr_warn("No module found in object\n");
2646                return ERR_PTR(-ENOEXEC);
2647        }
2648        /* This is temporary: point mod into copy of data. */
2649        mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2650
2651        if (info->index.sym == 0) {
2652                pr_warn("%s: module has no symbols (stripped?)\n", mod->name);
2653                return ERR_PTR(-ENOEXEC);
2654        }
2655
2656        info->index.pcpu = find_pcpusec(info);
2657
2658        /* Check module struct version now, before we try to use module. */
2659        if (!check_modstruct_version(info->sechdrs, info->index.vers, mod))
2660                return ERR_PTR(-ENOEXEC);
2661
2662        return mod;
2663}
2664
2665static int check_modinfo(struct module *mod, struct load_info *info, int flags)
2666{
2667        const char *modmagic = get_modinfo(info, "vermagic");
2668        int err;
2669
2670        if (flags & MODULE_INIT_IGNORE_VERMAGIC)
2671                modmagic = NULL;
2672
2673        /* This is allowed: modprobe --force will invalidate it. */
2674        if (!modmagic) {
2675                err = try_to_force_load(mod, "bad vermagic");
2676                if (err)
2677                        return err;
2678        } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
2679                pr_err("%s: version magic '%s' should be '%s'\n",
2680                       mod->name, modmagic, vermagic);
2681                return -ENOEXEC;
2682        }
2683
2684        if (!get_modinfo(info, "intree"))
2685                add_taint_module(mod, TAINT_OOT_MODULE, LOCKDEP_STILL_OK);
2686
2687        if (get_modinfo(info, "staging")) {
2688                add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
2689                pr_warn("%s: module is from the staging directory, the quality "
2690                        "is unknown, you have been warned.\n", mod->name);
2691        }
2692
2693        /* Set up license info based on the info section */
2694        set_license(mod, get_modinfo(info, "license"));
2695
2696        return 0;
2697}
2698
2699static int find_module_sections(struct module *mod, struct load_info *info)
2700{
2701        mod->kp = section_objs(info, "__param",
2702                               sizeof(*mod->kp), &mod->num_kp);
2703        mod->syms = section_objs(info, "__ksymtab",
2704                                 sizeof(*mod->syms), &mod->num_syms);
2705        mod->crcs = section_addr(info, "__kcrctab");
2706        mod->gpl_syms = section_objs(info, "__ksymtab_gpl",
2707                                     sizeof(*mod->gpl_syms),
2708                                     &mod->num_gpl_syms);
2709        mod->gpl_crcs = section_addr(info, "__kcrctab_gpl");
2710        mod->gpl_future_syms = section_objs(info,
2711                                            "__ksymtab_gpl_future",
2712                                            sizeof(*mod->gpl_future_syms),
2713                                            &mod->num_gpl_future_syms);
2714        mod->gpl_future_crcs = section_addr(info, "__kcrctab_gpl_future");
2715
2716#ifdef CONFIG_UNUSED_SYMBOLS
2717        mod->unused_syms = section_objs(info, "__ksymtab_unused",
2718                                        sizeof(*mod->unused_syms),
2719                                        &mod->num_unused_syms);
2720        mod->unused_crcs = section_addr(info, "__kcrctab_unused");
2721        mod->unused_gpl_syms = section_objs(info, "__ksymtab_unused_gpl",
2722                                            sizeof(*mod->unused_gpl_syms),
2723                                            &mod->num_unused_gpl_syms);
2724        mod->unused_gpl_crcs = section_addr(info, "__kcrctab_unused_gpl");
2725#endif
2726#ifdef CONFIG_CONSTRUCTORS
2727        mod->ctors = section_objs(info, ".ctors",
2728                                  sizeof(*mod->ctors), &mod->num_ctors);
2729        if (!mod->ctors)
2730                mod->ctors = section_objs(info, ".init_array",
2731                                sizeof(*mod->ctors), &mod->num_ctors);
2732        else if (find_sec(info, ".init_array")) {
2733                /*
2734                 * This shouldn't happen with same compiler and binutils
2735                 * building all parts of the module.
2736                 */
2737                printk(KERN_WARNING "%s: has both .ctors and .init_array.\n",
2738                       mod->name);
2739                return -EINVAL;
2740        }
2741#endif
2742
2743#ifdef CONFIG_TRACEPOINTS
2744        mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2745                                             sizeof(*mod->tracepoints_ptrs),
2746                                             &mod->num_tracepoints);
2747#endif
2748#ifdef HAVE_JUMP_LABEL
2749        mod->jump_entries = section_objs(info, "__jump_table",
2750                                        sizeof(*mod->jump_entries),
2751                                        &mod->num_jump_entries);
2752#endif
2753#ifdef CONFIG_EVENT_TRACING
2754        mod->trace_events = section_objs(info, "_ftrace_events",
2755                                         sizeof(*mod->trace_events),
2756                                         &mod->num_trace_events);
2757#endif
2758#ifdef CONFIG_TRACING
2759        mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
2760                                         sizeof(*mod->trace_bprintk_fmt_start),
2761                                         &mod->num_trace_bprintk_fmt);
2762#endif
2763#ifdef CONFIG_FTRACE_MCOUNT_RECORD
2764        /* sechdrs[0].sh_size is always zero */
2765        mod->ftrace_callsites = section_objs(info, "__mcount_loc",
2766                                             sizeof(*mod->ftrace_callsites),
2767                                             &mod->num_ftrace_callsites);
2768#endif
2769
2770        mod->extable = section_objs(info, "__ex_table",
2771                                    sizeof(*mod->extable), &mod->num_exentries);
2772
2773        if (section_addr(info, "__obsparm"))
2774                pr_warn("%s: Ignoring obsolete parameters\n", mod->name);
2775
2776        info->debug = section_objs(info, "__verbose",
2777                                   sizeof(*info->debug), &info->num_debug);
2778
2779        return 0;
2780}
2781
2782static int move_module(struct module *mod, struct load_info *info)
2783{
2784        int i;
2785        void *ptr;
2786
2787        /* Do the allocs. */
2788        ptr = module_alloc_update_bounds(mod->core_size);
2789        /*
2790         * The pointer to this block is stored in the module structure
2791         * which is inside the block. Just mark it as not being a
2792         * leak.
2793         */
2794        kmemleak_not_leak(ptr);
2795        if (!ptr)
2796                return -ENOMEM;
2797
2798        memset(ptr, 0, mod->core_size);
2799        mod->module_core = ptr;
2800
2801        if (mod->init_size) {
2802                ptr = module_alloc_update_bounds(mod->init_size);
2803                /*
2804                 * The pointer to this block is stored in the module structure
2805                 * which is inside the block. This block doesn't need to be
2806                 * scanned as it contains data and code that will be freed
2807                 * after the module is initialized.
2808                 */
2809                kmemleak_ignore(ptr);
2810                if (!ptr) {
2811                        module_free(mod, mod->module_core);
2812                        return -ENOMEM;
2813                }
2814                memset(ptr, 0, mod->init_size);
2815                mod->module_init = ptr;
2816        } else
2817                mod->module_init = NULL;
2818
2819        /* Transfer each section which specifies SHF_ALLOC */
2820        pr_debug("final section addresses:\n");
2821        for (i = 0; i < info->hdr->e_shnum; i++) {
2822                void *dest;
2823                Elf_Shdr *shdr = &info->sechdrs[i];
2824
2825                if (!(shdr->sh_flags & SHF_ALLOC))
2826                        continue;
2827
2828                if (shdr->sh_entsize & INIT_OFFSET_MASK)
2829                        dest = mod->module_init
2830                                + (shdr->sh_entsize & ~INIT_OFFSET_MASK);
2831                else
2832                        dest = mod->module_core + shdr->sh_entsize;
2833
2834                if (shdr->sh_type != SHT_NOBITS)
2835                        memcpy(dest, (void *)shdr->sh_addr, shdr->sh_size);
2836                /* Update sh_addr to point to copy in image. */
2837                shdr->sh_addr = (unsigned long)dest;
2838                pr_debug("\t0x%lx %s\n",
2839                         (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
2840        }
2841
2842        return 0;
2843}
2844
2845static int check_module_license_and_versions(struct module *mod)
2846{
2847        /*
2848         * ndiswrapper is under GPL by itself, but loads proprietary modules.
2849         * Don't use add_taint_module(), as it would prevent ndiswrapper from
2850         * using GPL-only symbols it needs.
2851         */
2852        if (strcmp(mod->name, "ndiswrapper") == 0)
2853                add_taint(TAINT_PROPRIETARY_MODULE, LOCKDEP_NOW_UNRELIABLE);
2854
2855        /* driverloader was caught wrongly pretending to be under GPL */
2856        if (strcmp(mod->name, "driverloader") == 0)
2857                add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2858                                 LOCKDEP_NOW_UNRELIABLE);
2859
2860        /* lve claims to be GPL but upstream won't provide source */
2861        if (strcmp(mod->name, "lve") == 0)
2862                add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2863                                 LOCKDEP_NOW_UNRELIABLE);
2864
2865#ifdef CONFIG_MODVERSIONS
2866        if ((mod->num_syms && !mod->crcs)
2867            || (mod->num_gpl_syms && !mod->gpl_crcs)
2868            || (mod->num_gpl_future_syms && !mod->gpl_future_crcs)
2869#ifdef CONFIG_UNUSED_SYMBOLS
2870            || (mod->num_unused_syms && !mod->unused_crcs)
2871            || (mod->num_unused_gpl_syms && !mod->unused_gpl_crcs)
2872#endif
2873                ) {
2874                return try_to_force_load(mod,
2875                                         "no versions for exported symbols");
2876        }
2877#endif
2878        return 0;
2879}
2880
2881static void flush_module_icache(const struct module *mod)
2882{
2883        mm_segment_t old_fs;
2884
2885        /* flush the icache in correct context */
2886        old_fs = get_fs();
2887        set_fs(KERNEL_DS);
2888
2889        /*
2890         * Flush the instruction cache, since we've played with text.
2891         * Do it before processing of module parameters, so the module
2892         * can provide parameter accessor functions of its own.
2893         */
2894        if (mod->module_init)
2895                flush_icache_range((unsigned long)mod->module_init,
2896                                   (unsigned long)mod->module_init
2897                                   + mod->init_size);
2898        flush_icache_range((unsigned long)mod->module_core,
2899                           (unsigned long)mod->module_core + mod->core_size);
2900
2901        set_fs(old_fs);
2902}
2903
2904int __weak module_frob_arch_sections(Elf_Ehdr *hdr,
2905                                     Elf_Shdr *sechdrs,
2906                                     char *secstrings,
2907                                     struct module *mod)
2908{
2909        return 0;
2910}
2911
2912static struct module *layout_and_allocate(struct load_info *info, int flags)
2913{
2914        /* Module within temporary copy. */
2915        struct module *mod;
2916        int err;
2917
2918        mod = setup_load_info(info, flags);
2919        if (IS_ERR(mod))
2920                return mod;
2921
2922        err = check_modinfo(mod, info, flags);
2923        if (err)
2924                return ERR_PTR(err);
2925
2926        /* Allow arches to frob section contents and sizes.  */
2927        err = module_frob_arch_sections(info->hdr, info->sechdrs,
2928                                        info->secstrings, mod);
2929        if (err < 0)
2930                return ERR_PTR(err);
2931
2932        /* We will do a special allocation for per-cpu sections later. */
2933        info->sechdrs[info->index.pcpu].sh_flags &= ~(unsigned long)SHF_ALLOC;
2934
2935        /* Determine total sizes, and put offsets in sh_entsize.  For now
2936           this is done generically; there doesn't appear to be any
2937           special cases for the architectures. */
2938        layout_sections(mod, info);
2939        layout_symtab(mod, info);
2940
2941        /* Allocate and move to the final place */
2942        err = move_module(mod, info);
2943        if (err)
2944                return ERR_PTR(err);
2945
2946        /* Module has been copied to its final place now: return it. */
2947        mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2948        kmemleak_load_module(mod, info);
2949        return mod;
2950}
2951
2952/* mod is no longer valid after this! */
2953static void module_deallocate(struct module *mod, struct load_info *info)
2954{
2955        percpu_modfree(mod);
2956        module_free(mod, mod->module_init);
2957        module_free(mod, mod->module_core);
2958}
2959
2960int __weak module_finalize(const Elf_Ehdr *hdr,
2961                           const Elf_Shdr *sechdrs,
2962                           struct module *me)
2963{
2964        return 0;
2965}
2966
2967static int post_relocation(struct module *mod, const struct load_info *info)
2968{
2969        /* Sort exception table now relocations are done. */
2970        sort_extable(mod->extable, mod->extable + mod->num_exentries);
2971
2972        /* Copy relocated percpu area over. */
2973        percpu_modcopy(mod, (void *)info->sechdrs[info->index.pcpu].sh_addr,
2974                       info->sechdrs[info->index.pcpu].sh_size);
2975
2976        /* Setup kallsyms-specific fields. */
2977        add_kallsyms(mod, info);
2978
2979        /* Arch-specific module finalizing. */
2980        return module_finalize(info->hdr, info->sechdrs, mod);
2981}
2982
2983/* Is this module of this name done loading?  No locks held. */
2984static bool finished_loading(const char *name)
2985{
2986        struct module *mod;
2987        bool ret;
2988
2989        mutex_lock(&module_mutex);
2990        mod = find_module_all(name, strlen(name), true);
2991        ret = !mod || mod->state == MODULE_STATE_LIVE
2992                || mod->state == MODULE_STATE_GOING;
2993        mutex_unlock(&module_mutex);
2994
2995        return ret;
2996}
2997
2998/* Call module constructors. */
2999static void do_mod_ctors(struct module *mod)
3000{
3001#ifdef CONFIG_CONSTRUCTORS
3002        unsigned long i;
3003
3004        for (i = 0; i < mod->num_ctors; i++)
3005                mod->ctors[i]();
3006#endif
3007}
3008
3009/* This is where the real work happens */
3010static int do_init_module(struct module *mod)
3011{
3012        int ret = 0;
3013
3014        /*
3015         * We want to find out whether @mod uses async during init.  Clear
3016         * PF_USED_ASYNC.  async_schedule*() will set it.
3017         */
3018        current->flags &= ~PF_USED_ASYNC;
3019
3020        blocking_notifier_call_chain(&module_notify_list,
3021                        MODULE_STATE_COMING, mod);
3022
3023        /* Set RO and NX regions for core */
3024        set_section_ro_nx(mod->module_core,
3025                                mod->core_text_size,
3026                                mod->core_ro_size,
3027                                mod->core_size);
3028
3029        /* Set RO and NX regions for init */
3030        set_section_ro_nx(mod->module_init,
3031                                mod->init_text_size,
3032                                mod->init_ro_size,
3033                                mod->init_size);
3034
3035        do_mod_ctors(mod);
3036        /* Start the module */
3037        if (mod->init != NULL)
3038                ret = do_one_initcall(mod->init);
3039        if (ret < 0) {
3040                /* Init routine failed: abort.  Try to protect us from
3041                   buggy refcounters. */
3042                mod->state = MODULE_STATE_GOING;
3043                synchronize_sched();
3044                module_put(mod);
3045                blocking_notifier_call_chain(&module_notify_list,
3046                                             MODULE_STATE_GOING, mod);
3047                free_module(mod);
3048                wake_up_all(&module_wq);
3049                return ret;
3050        }
3051        if (ret > 0) {
3052                pr_warn("%s: '%s'->init suspiciously returned %d, it should "
3053                        "follow 0/-E convention\n"
3054                        "%s: loading module anyway...\n",
3055                        __func__, mod->name, ret, __func__);
3056                dump_stack();
3057        }
3058
3059        /* Now it's a first class citizen! */
3060        mod->state = MODULE_STATE_LIVE;
3061        blocking_notifier_call_chain(&module_notify_list,
3062                                     MODULE_STATE_LIVE, mod);
3063
3064        /*
3065         * We need to finish all async code before the module init sequence
3066         * is done.  This has potential to deadlock.  For example, a newly
3067         * detected block device can trigger request_module() of the
3068         * default iosched from async probing task.  Once userland helper
3069         * reaches here, async_synchronize_full() will wait on the async
3070         * task waiting on request_module() and deadlock.
3071         *
3072         * This deadlock is avoided by perfomring async_synchronize_full()
3073         * iff module init queued any async jobs.  This isn't a full
3074         * solution as it will deadlock the same if module loading from
3075         * async jobs nests more than once; however, due to the various
3076         * constraints, this hack seems to be the best option for now.
3077         * Please refer to the following thread for details.
3078         *
3079         * http://thread.gmane.org/gmane.linux.kernel/1420814
3080         */
3081        if (current->flags & PF_USED_ASYNC)
3082                async_synchronize_full();
3083
3084        mutex_lock(&module_mutex);
3085        /* Drop initial reference. */
3086        module_put(mod);
3087        trim_init_extable(mod);
3088#ifdef CONFIG_KALLSYMS
3089        mod->num_symtab = mod->core_num_syms;
3090        mod->symtab = mod->core_symtab;
3091        mod->strtab = mod->core_strtab;
3092#endif
3093        unset_module_init_ro_nx(mod);
3094        module_free(mod, mod->module_init);
3095        mod->module_init = NULL;
3096        mod->init_size = 0;
3097        mod->init_ro_size = 0;
3098        mod->init_text_size = 0;
3099        mutex_unlock(&module_mutex);
3100        wake_up_all(&module_wq);
3101
3102        return 0;
3103}
3104
3105static int may_init_module(void)
3106{
3107        if (!capable(CAP_SYS_MODULE) || modules_disabled)
3108                return -EPERM;
3109
3110        return 0;
3111}
3112
3113/*
3114 * We try to place it in the list now to make sure it's unique before
3115 * we dedicate too many resources.  In particular, temporary percpu
3116 * memory exhaustion.
3117 */
3118static int add_unformed_module(struct module *mod)
3119{
3120        int err;
3121        struct module *old;
3122
3123        mod->state = MODULE_STATE_UNFORMED;
3124
3125again:
3126        mutex_lock(&module_mutex);
3127        old = find_module_all(mod->name, strlen(mod->name), true);
3128        if (old != NULL) {
3129                if (old->state == MODULE_STATE_COMING
3130                    || old->state == MODULE_STATE_UNFORMED) {
3131                        /* Wait in case it fails to load. */
3132                        mutex_unlock(&module_mutex);
3133                        err = wait_event_interruptible(module_wq,
3134                                               finished_loading(mod->name));
3135                        if (err)
3136                                goto out_unlocked;
3137                        goto again;
3138                }
3139                err = -EEXIST;
3140                goto out;
3141        }
3142        list_add_rcu(&mod->list, &modules);
3143        err = 0;
3144
3145out:
3146        mutex_unlock(&module_mutex);
3147out_unlocked:
3148        return err;
3149}
3150
3151static int complete_formation(struct module *mod, struct load_info *info)
3152{
3153        int err;
3154
3155        mutex_lock(&module_mutex);
3156
3157        /* Find duplicate symbols (must be called under lock). */
3158        err = verify_export_symbols(mod);
3159        if (err < 0)
3160                goto out;
3161
3162        /* This relies on module_mutex for list integrity. */
3163        module_bug_finalize(info->hdr, info->sechdrs, mod);
3164
3165        /* Mark state as coming so strong_try_module_get() ignores us,
3166         * but kallsyms etc. can see us. */
3167        mod->state = MODULE_STATE_COMING;
3168
3169out:
3170        mutex_unlock(&module_mutex);
3171        return err;
3172}
3173
3174static int unknown_module_param_cb(char *param, char *val, const char *modname)
3175{
3176        /* Check for magic 'dyndbg' arg */ 
3177        int ret = ddebug_dyndbg_module_param_cb(param, val, modname);
3178        if (ret != 0)
3179                pr_warn("%s: unknown parameter '%s' ignored\n", modname, param);
3180        return 0;
3181}
3182
3183/* Allocate and load the module: note that size of section 0 is always
3184   zero, and we rely on this for optional sections. */
3185static int load_module(struct load_info *info, const char __user *uargs,
3186                       int flags)
3187{
3188        struct module *mod;
3189        long err;
3190
3191        err = module_sig_check(info);
3192        if (err)
3193                goto free_copy;
3194
3195        err = elf_header_check(info);
3196        if (err)
3197                goto free_copy;
3198
3199        /* Figure out module layout, and allocate all the memory. */
3200        mod = layout_and_allocate(info, flags);
3201        if (IS_ERR(mod)) {
3202                err = PTR_ERR(mod);
3203                goto free_copy;
3204        }
3205
3206        /* Reserve our place in the list. */
3207        err = add_unformed_module(mod);
3208        if (err)
3209                goto free_module;
3210
3211#ifdef CONFIG_MODULE_SIG
3212        mod->sig_ok = info->sig_ok;
3213        if (!mod->sig_ok) {
3214                pr_notice_once("%s: module verification failed: signature "
3215                               "and/or  required key missing - tainting "
3216                               "kernel\n", mod->name);
3217                add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_STILL_OK);
3218        }
3219#endif
3220
3221        /* To avoid stressing percpu allocator, do this once we're unique. */
3222        err = percpu_modalloc(mod, info);
3223        if (err)
3224                goto unlink_mod;
3225
3226        /* Now module is in final location, initialize linked lists, etc. */
3227        err = module_unload_init(mod);
3228        if (err)
3229                goto unlink_mod;
3230
3231        /* Now we've got everything in the final locations, we can
3232         * find optional sections. */
3233        err = find_module_sections(mod, info);
3234        if (err)
3235                goto free_unload;
3236
3237        err = check_module_license_and_versions(mod);
3238        if (err)
3239                goto free_unload;
3240
3241        /* Set up MODINFO_ATTR fields */
3242        setup_modinfo(mod, info);
3243
3244        /* Fix up syms, so that st_value is a pointer to location. */
3245        err = simplify_symbols(mod, info);
3246        if (err < 0)
3247                goto free_modinfo;
3248
3249        err = apply_relocations(mod, info);
3250        if (err < 0)
3251                goto free_modinfo;
3252
3253        err = post_relocation(mod, info);
3254        if (err < 0)
3255                goto free_modinfo;
3256
3257        flush_module_icache(mod);
3258
3259        /* Now copy in args */
3260        mod->args = strndup_user(uargs, ~0UL >> 1);
3261        if (IS_ERR(mod->args)) {
3262                err = PTR_ERR(mod->args);
3263                goto free_arch_cleanup;
3264        }
3265
3266        dynamic_debug_setup(info->debug, info->num_debug);
3267
3268        /* Finally it's fully formed, ready to start executing. */
3269        err = complete_formation(mod, info);
3270        if (err)
3271                goto ddebug_cleanup;
3272
3273        /* Module is ready to execute: parsing args may do that. */
3274        err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
3275                         -32768, 32767, unknown_module_param_cb);
3276        if (err < 0)
3277                goto bug_cleanup;
3278
3279        /* Link in to syfs. */
3280        err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
3281        if (err < 0)
3282                goto bug_cleanup;
3283
3284        /* Get rid of temporary copy. */
3285        free_copy(info);
3286
3287        /* Done! */
3288        trace_module_load(mod);
3289
3290        return do_init_module(mod);
3291
3292 bug_cleanup:
3293        /* module_bug_cleanup needs module_mutex protection */
3294        mutex_lock(&module_mutex);
3295        module_bug_cleanup(mod);
3296        mutex_unlock(&module_mutex);
3297 ddebug_cleanup:
3298        dynamic_debug_remove(info->debug);
3299        synchronize_sched();
3300        kfree(mod->args);
3301 free_arch_cleanup:
3302        module_arch_cleanup(mod);
3303 free_modinfo:
3304        free_modinfo(mod);
3305 free_unload:
3306        module_unload_free(mod);
3307 unlink_mod:
3308        mutex_lock(&module_mutex);
3309        /* Unlink carefully: kallsyms could be walking list. */
3310        list_del_rcu(&mod->list);
3311        wake_up_all(&module_wq);
3312        mutex_unlock(&module_mutex);
3313 free_module:
3314        module_deallocate(mod, info);
3315 free_copy:
3316        free_copy(info);
3317        return err;
3318}
3319
3320SYSCALL_DEFINE3(init_module, void __user *, umod,
3321                unsigned long, len, const char __user *, uargs)
3322{
3323        int err;
3324        struct load_info info = { };
3325
3326        err = may_init_module();
3327        if (err)
3328                return err;
3329
3330        pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
3331               umod, len, uargs);
3332
3333        err = copy_module_from_user(umod, len, &info);
3334        if (err)
3335                return err;
3336
3337        return load_module(&info, uargs, 0);
3338}
3339
3340SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags)
3341{
3342        int err;
3343        struct load_info info = { };
3344
3345        err = may_init_module();
3346        if (err)
3347                return err;
3348
3349        pr_debug("finit_module: fd=%d, uargs=%p, flags=%i\n", fd, uargs, flags);
3350
3351        if (flags & ~(MODULE_INIT_IGNORE_MODVERSIONS
3352                      |MODULE_INIT_IGNORE_VERMAGIC))
3353                return -EINVAL;
3354
3355        err = copy_module_from_fd(fd, &info);
3356        if (err)
3357                return err;
3358
3359        return load_module(&info, uargs, flags);
3360}
3361
3362static inline int within(unsigned long addr, void *start, unsigned long size)
3363{
3364        return ((void *)addr >= start && (void *)addr < start + size);
3365}
3366
3367#ifdef CONFIG_KALLSYMS
3368/*
3369 * This ignores the intensely annoying "mapping symbols" found
3370 * in ARM ELF files: $a, $t and $d.
3371 */
3372static inline int is_arm_mapping_symbol(const char *str)
3373{
3374        return str[0] == '$' && strchr("atd", str[1])
3375               && (str[2] == '\0' || str[2] == '.');
3376}
3377
3378static const char *get_ksymbol(struct module *mod,
3379                               unsigned long addr,
3380                               unsigned long *size,
3381                               unsigned long *offset)
3382{
3383        unsigned int i, best = 0;
3384        unsigned long nextval;
3385
3386        /* At worse, next value is at end of module */
3387        if (within_module_init(addr, mod))
3388                nextval = (unsigned long)mod->module_init+mod->init_text_size;
3389        else
3390                nextval = (unsigned long)mod->module_core+mod->core_text_size;
3391
3392        /* Scan for closest preceding symbol, and next symbol. (ELF
3393           starts real symbols at 1). */
3394        for (i = 1; i < mod->num_symtab; i++) {
3395                if (mod->symtab[i].st_shndx == SHN_UNDEF)
3396                        continue;
3397
3398                /* We ignore unnamed symbols: they're uninformative
3399                 * and inserted at a whim. */
3400                if (mod->symtab[i].st_value <= addr
3401                    && mod->symtab[i].st_value > mod->symtab[best].st_value
3402                    && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3403                    && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3404                        best = i;
3405                if (mod->symtab[i].st_value > addr
3406                    && mod->symtab[i].st_value < nextval
3407                    && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3408                    && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3409                        nextval = mod->symtab[i].st_value;
3410        }
3411
3412        if (!best)
3413                return NULL;
3414
3415        if (size)
3416                *size = nextval - mod->symtab[best].st_value;
3417        if (offset)
3418                *offset = addr - mod->symtab[best].st_value;
3419        return mod->strtab + mod->symtab[best].st_name;
3420}
3421
3422/* For kallsyms to ask for address resolution.  NULL means not found.  Careful
3423 * not to lock to avoid deadlock on oopses, simply disable preemption. */
3424const char *module_address_lookup(unsigned long addr,
3425                            unsigned long *size,
3426                            unsigned long *offset,
3427                            char **modname,
3428                            char *namebuf)
3429{
3430        struct module *mod;
3431        const char *ret = NULL;
3432
3433        preempt_disable();
3434        list_for_each_entry_rcu(mod, &modules, list) {
3435                if (mod->state == MODULE_STATE_UNFORMED)
3436                        continue;
3437                if (within_module_init(addr, mod) ||
3438                    within_module_core(addr, mod)) {
3439                        if (modname)
3440                                *modname = mod->name;
3441                        ret = get_ksymbol(mod, addr, size, offset);
3442                        break;
3443                }
3444        }
3445        /* Make a copy in here where it's safe */
3446        if (ret) {
3447                strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
3448                ret = namebuf;
3449        }
3450        preempt_enable();
3451        return ret;
3452}
3453
3454int lookup_module_symbol_name(unsigned long addr, char *symname)
3455{
3456        struct module *mod;
3457
3458        preempt_disable();
3459        list_for_each_entry_rcu(mod, &modules, list) {
3460                if (mod->state == MODULE_STATE_UNFORMED)
3461                        continue;
3462                if (within_module_init(addr, mod) ||
3463                    within_module_core(addr, mod)) {
3464                        const char *sym;
3465
3466                        sym = get_ksymbol(mod, addr, NULL, NULL);
3467                        if (!sym)
3468                                goto out;
3469                        strlcpy(symname, sym, KSYM_NAME_LEN);
3470                        preempt_enable();
3471                        return 0;
3472                }
3473        }
3474out:
3475        preempt_enable();
3476        return -ERANGE;
3477}
3478
3479int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
3480                        unsigned long *offset, char *modname, char *name)
3481{
3482        struct module *mod;
3483
3484        preempt_disable();
3485        list_for_each_entry_rcu(mod, &modules, list) {
3486                if (mod->state == MODULE_STATE_UNFORMED)
3487                        continue;
3488                if (within_module_init(addr, mod) ||
3489                    within_module_core(addr, mod)) {
3490                        const char *sym;
3491
3492                        sym = get_ksymbol(mod, addr, size, offset);
3493                        if (!sym)
3494                                goto out;
3495                        if (modname)
3496                                strlcpy(modname, mod->name, MODULE_NAME_LEN);
3497                        if (name)
3498                                strlcpy(name, sym, KSYM_NAME_LEN);
3499                        preempt_enable();
3500                        return 0;
3501                }
3502        }
3503out:
3504        preempt_enable();
3505        return -ERANGE;
3506}
3507
3508int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
3509                        char *name, char *module_name, int *exported)
3510{
3511        struct module *mod;
3512
3513        preempt_disable();
3514        list_for_each_entry_rcu(mod, &modules, list) {
3515                if (mod->state == MODULE_STATE_UNFORMED)
3516                        continue;
3517                if (symnum < mod->num_symtab) {
3518                        *value = mod->symtab[symnum].st_value;
3519                        *type = mod->symtab[symnum].st_info;
3520                        strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
3521                                KSYM_NAME_LEN);
3522                        strlcpy(module_name, mod->name, MODULE_NAME_LEN);
3523                        *exported = is_exported(name, *value, mod);
3524                        preempt_enable();
3525                        return 0;
3526                }
3527                symnum -= mod->num_symtab;
3528        }
3529        preempt_enable();
3530        return -ERANGE;
3531}
3532
3533static unsigned long mod_find_symname(struct module *mod, const char *name)
3534{
3535        unsigned int i;
3536
3537        for (i = 0; i < mod->num_symtab; i++)
3538                if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
3539                    mod->symtab[i].st_info != 'U')
3540                        return mod->symtab[i].st_value;
3541        return 0;
3542}
3543
3544/* Look for this name: can be of form module:name. */
3545unsigned long module_kallsyms_lookup_name(const char *name)
3546{
3547        struct module *mod;
3548        char *colon;
3549        unsigned long ret = 0;
3550
3551        /* Don't lock: we're in enough trouble already. */
3552        preempt_disable();
3553        if ((colon = strchr(name, ':')) != NULL) {
3554                if ((mod = find_module_all(name, colon - name, false)) != NULL)
3555                        ret = mod_find_symname(mod, colon+1);
3556        } else {
3557                list_for_each_entry_rcu(mod, &modules, list) {
3558                        if (mod->state == MODULE_STATE_UNFORMED)
3559                                continue;
3560                        if ((ret = mod_find_symname(mod, name)) != 0)
3561                                break;
3562                }
3563        }
3564        preempt_enable();
3565        return ret;
3566}
3567
3568int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
3569                                             struct module *, unsigned long),
3570                                   void *data)
3571{
3572        struct module *mod;
3573        unsigned int i;
3574        int ret;
3575
3576        list_for_each_entry(mod, &modules, list) {
3577                if (mod->state == MODULE_STATE_UNFORMED)
3578                        continue;
3579                for (i = 0; i < mod->num_symtab; i++) {
3580                        ret = fn(data, mod->strtab + mod->symtab[i].st_name,
3581                                 mod, mod->symtab[i].st_value);
3582                        if (ret != 0)
3583                                return ret;
3584                }
3585        }
3586        return 0;
3587}
3588#endif /* CONFIG_KALLSYMS */
3589
3590static char *module_flags(struct module *mod, char *buf)
3591{
3592        int bx = 0;
3593
3594        BUG_ON(mod->state == MODULE_STATE_UNFORMED);
3595        if (mod->taints ||
3596            mod->state == MODULE_STATE_GOING ||
3597            mod->state == MODULE_STATE_COMING) {
3598                buf[bx++] = '(';
3599                bx += module_flags_taint(mod, buf + bx);
3600                /* Show a - for module-is-being-unloaded */
3601                if (mod->state == MODULE_STATE_GOING)
3602                        buf[bx++] = '-';
3603                /* Show a + for module-is-being-loaded */
3604                if (mod->state == MODULE_STATE_COMING)
3605                        buf[bx++] = '+';
3606                buf[bx++] = ')';
3607        }
3608        buf[bx] = '\0';
3609
3610        return buf;
3611}
3612
3613#ifdef CONFIG_PROC_FS
3614/* Called by the /proc file system to return a list of modules. */
3615static void *m_start(struct seq_file *m, loff_t *pos)
3616{
3617        mutex_lock(&module_mutex);
3618        return seq_list_start(&modules, *pos);
3619}
3620
3621static void *m_next(struct seq_file *m, void *p, loff_t *pos)
3622{
3623        return seq_list_next(p, &modules, pos);
3624}
3625
3626static void m_stop(struct seq_file *m, void *p)
3627{
3628        mutex_unlock(&module_mutex);
3629}
3630
3631static int m_show(struct seq_file *m, void *p)
3632{
3633        struct module *mod = list_entry(p, struct module, list);
3634        char buf[8];
3635
3636        /* We always ignore unformed modules. */
3637        if (mod->state == MODULE_STATE_UNFORMED)
3638                return 0;
3639
3640        seq_printf(m, "%s %u",
3641                   mod->name, mod->init_size + mod->core_size);
3642        print_unload_info(m, mod);
3643
3644        /* Informative for users. */
3645        seq_printf(m, " %s",
3646                   mod->state == MODULE_STATE_GOING ? "Unloading":
3647                   mod->state == MODULE_STATE_COMING ? "Loading":
3648                   "Live");
3649        /* Used by oprofile and other similar tools. */
3650        seq_printf(m, " 0x%pK", mod->module_core);
3651
3652        /* Taints info */
3653        if (mod->taints)
3654                seq_printf(m, " %s", module_flags(mod, buf));
3655
3656        seq_printf(m, "\n");
3657        return 0;
3658}
3659
3660/* Format: modulename size refcount deps address
3661
3662   Where refcount is a number or -, and deps is a comma-separated list
3663   of depends or -.
3664*/
3665static const struct seq_operations modules_op = {
3666        .start  = m_start,
3667        .next   = m_next,
3668        .stop   = m_stop,
3669        .show   = m_show
3670};
3671
3672static int modules_open(struct inode *inode, struct file *file)
3673{
3674        return seq_open(file, &modules_op);
3675}
3676
3677static const struct file_operations proc_modules_operations = {
3678        .open           = modules_open,
3679        .read           = seq_read,
3680        .llseek         = seq_lseek,
3681        .release        = seq_release,
3682};
3683
3684static int __init proc_modules_init(void)
3685{
3686        proc_create("modules", 0, NULL, &proc_modules_operations);
3687        return 0;
3688}
3689module_init(proc_modules_init);
3690#endif
3691
3692/* Given an address, look for it in the module exception tables. */
3693const struct exception_table_entry *search_module_extables(unsigned long addr)
3694{
3695        const struct exception_table_entry *e = NULL;
3696        struct module *mod;
3697
3698        preempt_disable();
3699        list_for_each_entry_rcu(mod, &modules, list) {
3700                if (mod->state == MODULE_STATE_UNFORMED)
3701                        continue;
3702                if (mod->num_exentries == 0)
3703                        continue;
3704
3705                e = search_extable(mod->extable,
3706                                   mod->extable + mod->num_exentries - 1,
3707                                   addr);
3708                if (e)
3709                        break;
3710        }
3711        preempt_enable();
3712
3713        /* Now, if we found one, we are running inside it now, hence
3714           we cannot unload the module, hence no refcnt needed. */
3715        return e;
3716}
3717
3718/*
3719 * is_module_address - is this address inside a module?
3720 * @addr: the address to check.
3721 *
3722 * See is_module_text_address() if you simply want to see if the address
3723 * is code (not data).
3724 */
3725bool is_module_address(unsigned long addr)
3726{
3727        bool ret;
3728
3729        preempt_disable();
3730        ret = __module_address(addr) != NULL;
3731        preempt_enable();
3732
3733        return ret;
3734}
3735
3736/*
3737 * __module_address - get the module which contains an address.
3738 * @addr: the address.
3739 *
3740 * Must be called with preempt disabled or module mutex held so that
3741 * module doesn't get freed during this.
3742 */
3743struct module *__module_address(unsigned long addr)
3744{
3745        struct module *mod;
3746
3747        if (addr < module_addr_min || addr > module_addr_max)
3748                return NULL;
3749
3750        list_for_each_entry_rcu(mod, &modules, list) {
3751                if (mod->state == MODULE_STATE_UNFORMED)
3752                        continue;
3753                if (within_module_core(addr, mod)
3754                    || within_module_init(addr, mod))
3755                        return mod;
3756        }
3757        return NULL;
3758}
3759EXPORT_SYMBOL_GPL(__module_address);
3760
3761/*
3762 * is_module_text_address - is this address inside module code?
3763 * @addr: the address to check.
3764 *
3765 * See is_module_address() if you simply want to see if the address is
3766 * anywhere in a module.  See kernel_text_address() for testing if an
3767 * address corresponds to kernel or module code.
3768 */
3769bool is_module_text_address(unsigned long addr)
3770{
3771        bool ret;
3772
3773        preempt_disable();
3774        ret = __module_text_address(addr) != NULL;
3775        preempt_enable();
3776
3777        return ret;
3778}
3779
3780/*
3781 * __module_text_address - get the module whose code contains an address.
3782 * @addr: the address.
3783 *
3784 * Must be called with preempt disabled or module mutex held so that
3785 * module doesn't get freed during this.
3786 */
3787struct module *__module_text_address(unsigned long addr)
3788{
3789        struct module *mod = __module_address(addr);
3790        if (mod) {
3791                /* Make sure it's within the text section. */
3792                if (!within(addr, mod->module_init, mod->init_text_size)
3793                    && !within(addr, mod->module_core, mod->core_text_size))
3794                        mod = NULL;
3795        }
3796        return mod;
3797}
3798EXPORT_SYMBOL_GPL(__module_text_address);
3799
3800/* Don't grab lock, we're oopsing. */
3801void print_modules(void)
3802{
3803        struct module *mod;
3804        char buf[8];
3805
3806        printk(KERN_DEFAULT "Modules linked in:");
3807        /* Most callers should already have preempt disabled, but make sure */
3808        preempt_disable();
3809        list_for_each_entry_rcu(mod, &modules, list) {
3810                if (mod->state == MODULE_STATE_UNFORMED)
3811                        continue;
3812                printk(" %s%s", mod->name, module_flags(mod, buf));
3813        }
3814        preempt_enable();
3815        if (last_unloaded_module[0])
3816                printk(" [last unloaded: %s]", last_unloaded_module);
3817        printk("\n");
3818}
3819
3820#ifdef CONFIG_MODVERSIONS
3821/* Generate the signature for all relevant module structures here.
3822 * If these change, we don't want to try to parse the module. */
3823void module_layout(struct module *mod,
3824                   struct modversion_info *ver,
3825                   struct kernel_param *kp,
3826                   struct kernel_symbol *ks,
3827                   struct tracepoint * const *tp)
3828{
3829}
3830EXPORT_SYMBOL(module_layout);
3831#endif
3832
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.