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