Merge tag 'driver-core-4.21-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / kernel / module.c
index 0812a7f80fa740e00f6ea5d754d5403cdef1d557..fcbc0128810b8ff690c89f987c3af72784e26baa 100644 (file)
@@ -495,9 +495,9 @@ struct find_symbol_arg {
        const struct kernel_symbol *sym;
 };
 
-static bool check_symbol(const struct symsearch *syms,
-                                struct module *owner,
-                                unsigned int symnum, void *data)
+static bool check_exported_symbol(const struct symsearch *syms,
+                                 struct module *owner,
+                                 unsigned int symnum, void *data)
 {
        struct find_symbol_arg *fsa = data;
 
@@ -555,9 +555,9 @@ static int cmp_name(const void *va, const void *vb)
        return strcmp(a, kernel_symbol_name(b));
 }
 
-static bool find_symbol_in_section(const struct symsearch *syms,
-                                  struct module *owner,
-                                  void *data)
+static bool find_exported_symbol_in_section(const struct symsearch *syms,
+                                           struct module *owner,
+                                           void *data)
 {
        struct find_symbol_arg *fsa = data;
        struct kernel_symbol *sym;
@@ -565,13 +565,14 @@ static bool find_symbol_in_section(const struct symsearch *syms,
        sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
                        sizeof(struct kernel_symbol), cmp_name);
 
-       if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
+       if (sym != NULL && check_exported_symbol(syms, owner,
+                                                sym - syms->start, data))
                return true;
 
        return false;
 }
 
-/* Find a symbol and return it, along with, (optional) crc and
+/* Find an exported symbol and return it, along with, (optional) crc and
  * (optional) module which owns it.  Needs preempt disabled or module_mutex. */
 const struct kernel_symbol *find_symbol(const char *name,
                                        struct module **owner,
@@ -585,7 +586,7 @@ const struct kernel_symbol *find_symbol(const char *name,
        fsa.gplok = gplok;
        fsa.warn = warn;
 
-       if (each_symbol_section(find_symbol_in_section, &fsa)) {
+       if (each_symbol_section(find_exported_symbol_in_section, &fsa)) {
                if (owner)
                        *owner = fsa.owner;
                if (crc)
@@ -2161,7 +2162,7 @@ static void free_module(struct module *mod)
        /* Remove this module from bug list, this uses list_del_rcu */
        module_bug_cleanup(mod);
        /* Wait for RCU-sched synchronizing before releasing mod->list and buglist. */
-       synchronize_sched();
+       synchronize_rcu();
        mutex_unlock(&module_mutex);
 
        /* This may be empty, but that's OK */
@@ -2200,7 +2201,7 @@ EXPORT_SYMBOL_GPL(__symbol_get);
  *
  * You must hold the module_mutex.
  */
-static int verify_export_symbols(struct module *mod)
+static int verify_exported_symbols(struct module *mod)
 {
        unsigned int i;
        struct module *owner;
@@ -2521,10 +2522,10 @@ static void free_modinfo(struct module *mod)
 
 #ifdef CONFIG_KALLSYMS
 
-/* lookup symbol in given range of kernel_symbols */
-static const struct kernel_symbol *lookup_symbol(const char *name,
-       const struct kernel_symbol *start,
-       const struct kernel_symbol *stop)
+/* Lookup exported symbol in given range of kernel_symbols */
+static const struct kernel_symbol *lookup_exported_symbol(const char *name,
+                                                         const struct kernel_symbol *start,
+                                                         const struct kernel_symbol *stop)
 {
        return bsearch(name, start, stop - start,
                        sizeof(struct kernel_symbol), cmp_name);
@@ -2535,9 +2536,10 @@ static int is_exported(const char *name, unsigned long value,
 {
        const struct kernel_symbol *ks;
        if (!mod)
-               ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
+               ks = lookup_exported_symbol(name, __start___ksymtab, __stop___ksymtab);
        else
-               ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
+               ks = lookup_exported_symbol(name, mod->syms, mod->syms + mod->num_syms);
+
        return ks != NULL && kernel_symbol_value(ks) == value;
 }
 
@@ -2684,7 +2686,7 @@ static void add_kallsyms(struct module *mod, const struct load_info *info)
 
        /* Set types up while we still have access to sections. */
        for (i = 0; i < mod->kallsyms->num_symtab; i++)
-               mod->kallsyms->symtab[i].st_info
+               mod->kallsyms->symtab[i].st_size
                        = elf_type(&mod->kallsyms->symtab[i], info);
 
        /* Now populate the cut down core kallsyms for after init. */
@@ -3095,6 +3097,11 @@ static int find_module_sections(struct module *mod, struct load_info *info)
                                             sizeof(*mod->tracepoints_ptrs),
                                             &mod->num_tracepoints);
 #endif
+#ifdef CONFIG_BPF_EVENTS
+       mod->bpf_raw_events = section_objs(info, "__bpf_raw_tp_map",
+                                          sizeof(*mod->bpf_raw_events),
+                                          &mod->num_bpf_raw_events);
+#endif
 #ifdef HAVE_JUMP_LABEL
        mod->jump_entries = section_objs(info, "__jump_table",
                                        sizeof(*mod->jump_entries),
@@ -3509,15 +3516,15 @@ static noinline int do_init_module(struct module *mod)
        /*
         * We want to free module_init, but be aware that kallsyms may be
         * walking this with preempt disabled.  In all the failure paths, we
-        * call synchronize_sched(), but we don't want to slow down the success
+        * call synchronize_rcu(), but we don't want to slow down the success
         * path, so use actual RCU here.
         * Note that module_alloc() on most architectures creates W+X page
         * mappings which won't be cleaned up until do_free_init() runs.  Any
         * code such as mark_rodata_ro() which depends on those mappings to
         * be cleaned up needs to sync with the queued work - ie
-        * rcu_barrier_sched()
+        * rcu_barrier()
         */
-       call_rcu_sched(&freeinit->rcu, do_free_init);
+       call_rcu(&freeinit->rcu, do_free_init);
        mutex_unlock(&module_mutex);
        wake_up_all(&module_wq);
 
@@ -3528,7 +3535,7 @@ fail_free_freeinit:
 fail:
        /* Try to protect us from buggy refcounters. */
        mod->state = MODULE_STATE_GOING;
-       synchronize_sched();
+       synchronize_rcu();
        module_put(mod);
        blocking_notifier_call_chain(&module_notify_list,
                                     MODULE_STATE_GOING, mod);
@@ -3594,7 +3601,7 @@ static int complete_formation(struct module *mod, struct load_info *info)
        mutex_lock(&module_mutex);
 
        /* Find duplicate symbols (must be called under lock). */
-       err = verify_export_symbols(mod);
+       err = verify_exported_symbols(mod);
        if (err < 0)
                goto out;
 
@@ -3821,7 +3828,7 @@ static int load_module(struct load_info *info, const char __user *uargs,
  ddebug_cleanup:
        ftrace_release_mod(mod);
        dynamic_debug_remove(mod, info->debug);
-       synchronize_sched();
+       synchronize_rcu();
        kfree(mod->args);
  free_arch_cleanup:
        module_arch_cleanup(mod);
@@ -3836,7 +3843,7 @@ static int load_module(struct load_info *info, const char __user *uargs,
        mod_tree_remove(mod);
        wake_up_all(&module_wq);
        /* Wait for RCU-sched synchronizing before releasing mod->list. */
-       synchronize_sched();
+       synchronize_rcu();
        mutex_unlock(&module_mutex);
  free_module:
        /* Free lock-classes; relies on the preceding sync_rcu() */
@@ -3913,18 +3920,22 @@ static inline int is_arm_mapping_symbol(const char *str)
               && (str[2] == '\0' || str[2] == '.');
 }
 
-static const char *symname(struct mod_kallsyms *kallsyms, unsigned int symnum)
+static const char *kallsyms_symbol_name(struct mod_kallsyms *kallsyms, unsigned int symnum)
 {
        return kallsyms->strtab + kallsyms->symtab[symnum].st_name;
 }
 
-static const char *get_ksymbol(struct module *mod,
-                              unsigned long addr,
-                              unsigned long *size,
-                              unsigned long *offset)
+/*
+ * Given a module and address, find the corresponding symbol and return its name
+ * while providing its size and offset if needed.
+ */
+static const char *find_kallsyms_symbol(struct module *mod,
+                                       unsigned long addr,
+                                       unsigned long *size,
+                                       unsigned long *offset)
 {
        unsigned int i, best = 0;
-       unsigned long nextval;
+       unsigned long nextval, bestval;
        struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms);
 
        /* At worse, next value is at end of module */
@@ -3933,34 +3944,40 @@ static const char *get_ksymbol(struct module *mod,
        else
                nextval = (unsigned long)mod->core_layout.base+mod->core_layout.text_size;
 
+       bestval = kallsyms_symbol_value(&kallsyms->symtab[best]);
+
        /* Scan for closest preceding symbol, and next symbol. (ELF
           starts real symbols at 1). */
        for (i = 1; i < kallsyms->num_symtab; i++) {
-               if (kallsyms->symtab[i].st_shndx == SHN_UNDEF)
+               const Elf_Sym *sym = &kallsyms->symtab[i];
+               unsigned long thisval = kallsyms_symbol_value(sym);
+
+               if (sym->st_shndx == SHN_UNDEF)
                        continue;
 
                /* We ignore unnamed symbols: they're uninformative
                 * and inserted at a whim. */
-               if (*symname(kallsyms, i) == '\0'
-                   || is_arm_mapping_symbol(symname(kallsyms, i)))
+               if (*kallsyms_symbol_name(kallsyms, i) == '\0'
+                   || is_arm_mapping_symbol(kallsyms_symbol_name(kallsyms, i)))
                        continue;
 
-               if (kallsyms->symtab[i].st_value <= addr
-                   && kallsyms->symtab[i].st_value > kallsyms->symtab[best].st_value)
+               if (thisval <= addr && thisval > bestval) {
                        best = i;
-               if (kallsyms->symtab[i].st_value > addr
-                   && kallsyms->symtab[i].st_value < nextval)
-                       nextval = kallsyms->symtab[i].st_value;
+                       bestval = thisval;
+               }
+               if (thisval > addr && thisval < nextval)
+                       nextval = thisval;
        }
 
        if (!best)
                return NULL;
 
        if (size)
-               *size = nextval - kallsyms->symtab[best].st_value;
+               *size = nextval - bestval;
        if (offset)
-               *offset = addr - kallsyms->symtab[best].st_value;
-       return symname(kallsyms, best);
+               *offset = addr - bestval;
+
+       return kallsyms_symbol_name(kallsyms, best);
 }
 
 void * __weak dereference_module_function_descriptor(struct module *mod,
@@ -3985,7 +4002,8 @@ const char *module_address_lookup(unsigned long addr,
        if (mod) {
                if (modname)
                        *modname = mod->name;
-               ret = get_ksymbol(mod, addr, size, offset);
+
+               ret = find_kallsyms_symbol(mod, addr, size, offset);
        }
        /* Make a copy in here where it's safe */
        if (ret) {
@@ -4008,9 +4026,10 @@ int lookup_module_symbol_name(unsigned long addr, char *symname)
                if (within_module(addr, mod)) {
                        const char *sym;
 
-                       sym = get_ksymbol(mod, addr, NULL, NULL);
+                       sym = find_kallsyms_symbol(mod, addr, NULL, NULL);
                        if (!sym)
                                goto out;
+
                        strlcpy(symname, sym, KSYM_NAME_LEN);
                        preempt_enable();
                        return 0;
@@ -4033,7 +4052,7 @@ int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
                if (within_module(addr, mod)) {
                        const char *sym;
 
-                       sym = get_ksymbol(mod, addr, size, offset);
+                       sym = find_kallsyms_symbol(mod, addr, size, offset);
                        if (!sym)
                                goto out;
                        if (modname)
@@ -4062,9 +4081,11 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
                        continue;
                kallsyms = rcu_dereference_sched(mod->kallsyms);
                if (symnum < kallsyms->num_symtab) {
-                       *value = kallsyms->symtab[symnum].st_value;
-                       *type = kallsyms->symtab[symnum].st_info;
-                       strlcpy(name, symname(kallsyms, symnum), KSYM_NAME_LEN);
+                       const Elf_Sym *sym = &kallsyms->symtab[symnum];
+
+                       *value = kallsyms_symbol_value(sym);
+                       *type = sym->st_size;
+                       strlcpy(name, kallsyms_symbol_name(kallsyms, symnum), KSYM_NAME_LEN);
                        strlcpy(module_name, mod->name, MODULE_NAME_LEN);
                        *exported = is_exported(name, *value, mod);
                        preempt_enable();
@@ -4076,15 +4097,19 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
        return -ERANGE;
 }
 
-static unsigned long mod_find_symname(struct module *mod, const char *name)
+/* Given a module and name of symbol, find and return the symbol's value */
+static unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name)
 {
        unsigned int i;
        struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms);
 
-       for (i = 0; i < kallsyms->num_symtab; i++)
-               if (strcmp(name, symname(kallsyms, i)) == 0 &&
-                   kallsyms->symtab[i].st_shndx != SHN_UNDEF)
-                       return kallsyms->symtab[i].st_value;
+       for (i = 0; i < kallsyms->num_symtab; i++) {
+               const Elf_Sym *sym = &kallsyms->symtab[i];
+
+               if (strcmp(name, kallsyms_symbol_name(kallsyms, i)) == 0 &&
+                   sym->st_shndx != SHN_UNDEF)
+                       return kallsyms_symbol_value(sym);
+       }
        return 0;
 }
 
@@ -4099,12 +4124,12 @@ unsigned long module_kallsyms_lookup_name(const char *name)
        preempt_disable();
        if ((colon = strnchr(name, MODULE_NAME_LEN, ':')) != NULL) {
                if ((mod = find_module_all(name, colon - name, false)) != NULL)
-                       ret = mod_find_symname(mod, colon+1);
+                       ret = find_kallsyms_symbol_value(mod, colon+1);
        } else {
                list_for_each_entry_rcu(mod, &modules, list) {
                        if (mod->state == MODULE_STATE_UNFORMED)
                                continue;
-                       if ((ret = mod_find_symname(mod, name)) != 0)
+                       if ((ret = find_kallsyms_symbol_value(mod, name)) != 0)
                                break;
                }
        }
@@ -4129,12 +4154,13 @@ int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
                if (mod->state == MODULE_STATE_UNFORMED)
                        continue;
                for (i = 0; i < kallsyms->num_symtab; i++) {
+                       const Elf_Sym *sym = &kallsyms->symtab[i];
 
-                       if (kallsyms->symtab[i].st_shndx == SHN_UNDEF)
+                       if (sym->st_shndx == SHN_UNDEF)
                                continue;
 
-                       ret = fn(data, symname(kallsyms, i),
-                                mod, kallsyms->symtab[i].st_value);
+                       ret = fn(data, kallsyms_symbol_name(kallsyms, i),
+                                mod, kallsyms_symbol_value(sym));
                        if (ret != 0)
                                return ret;
                }