LCOV - code coverage report
Current view: top level - kernel - module.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 885 1602 55.2 %
Date: 2022-04-01 14:58:12 Functions: 80 145 55.2 %
Branches: 329 812 40.5 %

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

Generated by: LCOV version 1.14