kernel/module/internal.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /* Module internals
   3  *
   4  * Copyright (C) 2012 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/elf.h>
   9 #include <linux/compiler.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/rculist.h>
  13 #include <linux/rcupdate.h>
  14 #include <linux/mm.h>
  15
  16 #ifndef ARCH_SHF_SMALL
  17 #define ARCH_SHF_SMALL 0
  18 #endif
  19
  20 /* If this is set, the section belongs in the init part of the module */
  21 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG - 1))
  22 /* Maximum number of characters written by module_flags() */
  23 #define MODULE_FLAGS_BUF_SIZE (TAINT_FLAGS_COUNT + 4)
  24
  25 #ifndef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
  26 #define data_layout core_layout
  27 #endif
  28
  29 /*
  30  * Modules' sections will be aligned on page boundaries
  31  * to ensure complete separation of code and data, but
  32  * only when CONFIG_STRICT_MODULE_RWX=y
  33  */
  34 static inline unsigned int strict_align(unsigned int size)
  35 {
  36         if (IS_ENABLED(CONFIG_STRICT_MODULE_RWX))
  37                 return PAGE_ALIGN(size);
  38         else
  39                 return size;
  40 }
  41
  42 extern struct mutex module_mutex;
  43 extern struct list_head modules;
  44
  45 extern struct module_attribute *modinfo_attrs[];
  46 extern size_t modinfo_attrs_count;
  47
  48 /* Provided by the linker */
  49 extern const struct kernel_symbol __start___ksymtab[];
  50 extern const struct kernel_symbol __stop___ksymtab[];
  51 extern const struct kernel_symbol __start___ksymtab_gpl[];
  52 extern const struct kernel_symbol __stop___ksymtab_gpl[];
  53 extern const s32 __start___kcrctab[];
  54 extern const s32 __start___kcrctab_gpl[];
  55
  56 #include <linux/dynamic_debug.h>
  57 struct load_info {
  58         const char *name;
  59         /* pointer to module in temporary copy, freed at end of load_module() */
  60         struct module *mod;
  61         Elf_Ehdr *hdr;
  62         unsigned long len;
  63         Elf_Shdr *sechdrs;
  64         char *secstrings, *strtab;
  65         unsigned long symoffs, stroffs, init_typeoffs, core_typeoffs;
  66         struct _ddebug_info dyndbg;
  67         bool sig_ok;
  68 #ifdef CONFIG_KALLSYMS
  69         unsigned long mod_kallsyms_init_off;
  70 #endif
  71 #ifdef CONFIG_MODULE_DECOMPRESS
  72         struct page **pages;
  73         unsigned int max_pages;
  74         unsigned int used_pages;
  75 #endif
  76         struct {
  77                 unsigned int sym, str, mod, vers, info, pcpu;
  78         } index;
  79 };
  80
  81 enum mod_license {
  82         NOT_GPL_ONLY,
  83         GPL_ONLY,
  84 };
  85
  86 struct find_symbol_arg {
  87         /* Input */
  88         const char *name;
  89         bool gplok;
  90         bool warn;
  91
  92         /* Output */
  93         struct module *owner;
  94         const s32 *crc;
  95         const struct kernel_symbol *sym;
  96         enum mod_license license;
  97 };
  98
  99 int mod_verify_sig(const void *mod, struct load_info *info);
 100 int try_to_force_load(struct module *mod, const char *reason);
 101 bool find_symbol(struct find_symbol_arg *fsa);
 102 struct module *find_module_all(const char *name, size_t len, bool even_unformed);
 103 int cmp_name(const void *name, const void *sym);
 104 long module_get_offset(struct module *mod, unsigned int *size, Elf_Shdr *sechdr,
 105                        unsigned int section);
 106 char *module_flags(struct module *mod, char *buf, bool show_state);
 107 size_t module_flags_taint(unsigned long taints, char *buf);
 108
 109 static inline void module_assert_mutex_or_preempt(void)
 110 {
 111 #ifdef CONFIG_LOCKDEP
 112         if (unlikely(!debug_locks))
 113                 return;
 114
 115         WARN_ON_ONCE(!rcu_read_lock_sched_held() &&
 116                      !lockdep_is_held(&module_mutex));
 117 #endif
 118 }
 119
 120 static inline unsigned long kernel_symbol_value(const struct kernel_symbol *sym)
 121 {
 122 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
 123         return (unsigned long)offset_to_ptr(&sym->value_offset);
 124 #else
 125         return sym->value;
 126 #endif
 127 }
 128
 129 #ifdef CONFIG_LIVEPATCH
 130 int copy_module_elf(struct module *mod, struct load_info *info);
 131 void free_module_elf(struct module *mod);
 132 #else /* !CONFIG_LIVEPATCH */
 133 static inline int copy_module_elf(struct module *mod, struct load_info *info)
 134 {
 135         return 0;
 136 }
 137
 138 static inline void free_module_elf(struct module *mod) { }
 139 #endif /* CONFIG_LIVEPATCH */
 140
 141 static inline bool set_livepatch_module(struct module *mod)
 142 {
 143 #ifdef CONFIG_LIVEPATCH
 144         mod->klp = true;
 145         return true;
 146 #else
 147         return false;
 148 #endif
 149 }
 150
 151 #ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
 152 struct mod_unload_taint {
 153         struct list_head list;
 154         char name[MODULE_NAME_LEN];
 155         unsigned long taints;
 156         u64 count;
 157 };
 158
 159 int try_add_tainted_module(struct module *mod);
 160 void print_unloaded_tainted_modules(void);
 161 #else /* !CONFIG_MODULE_UNLOAD_TAINT_TRACKING */
 162 static inline int try_add_tainted_module(struct module *mod)
 163 {
 164         return 0;
 165 }
 166
 167 static inline void print_unloaded_tainted_modules(void)
 168 {
 169 }
 170 #endif /* CONFIG_MODULE_UNLOAD_TAINT_TRACKING */
 171
 172 #ifdef CONFIG_MODULE_DECOMPRESS
 173 int module_decompress(struct load_info *info, const void *buf, size_t size);
 174 void module_decompress_cleanup(struct load_info *info);
 175 #else
 176 static inline int module_decompress(struct load_info *info,
 177                                     const void *buf, size_t size)
 178 {
 179         return -EOPNOTSUPP;
 180 }
 181
 182 static inline void module_decompress_cleanup(struct load_info *info)
 183 {
 184 }
 185 #endif
 186
 187 struct mod_tree_root {
 188 #ifdef CONFIG_MODULES_TREE_LOOKUP
 189         struct latch_tree_root root;
 190 #endif
 191         unsigned long addr_min;
 192         unsigned long addr_max;
 193 };
 194
 195 extern struct mod_tree_root mod_tree;
 196 extern struct mod_tree_root mod_data_tree;
 197
 198 #ifdef CONFIG_MODULES_TREE_LOOKUP
 199 void mod_tree_insert(struct module *mod);
 200 void mod_tree_remove_init(struct module *mod);
 201 void mod_tree_remove(struct module *mod);
 202 struct module *mod_find(unsigned long addr, struct mod_tree_root *tree);
 203 #else /* !CONFIG_MODULES_TREE_LOOKUP */
 204
 205 static inline void mod_tree_insert(struct module *mod) { }
 206 static inline void mod_tree_remove_init(struct module *mod) { }
 207 static inline void mod_tree_remove(struct module *mod) { }
 208 static inline struct module *mod_find(unsigned long addr, struct mod_tree_root *tree)
 209 {
 210         struct module *mod;
 211
 212         list_for_each_entry_rcu(mod, &modules, list,
 213                                 lockdep_is_held(&module_mutex)) {
 214                 if (within_module(addr, mod))
 215                         return mod;
 216         }
 217
 218         return NULL;
 219 }
 220 #endif /* CONFIG_MODULES_TREE_LOOKUP */
 221
 222 void module_enable_ro(const struct module *mod, bool after_init);
 223 void module_enable_nx(const struct module *mod);
 224 void module_enable_x(const struct module *mod);
 225 int module_enforce_rwx_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
 226                                 char *secstrings, struct module *mod);
 227 bool module_check_misalignment(const struct module *mod);
 228
 229 #ifdef CONFIG_MODULE_SIG
 230 int module_sig_check(struct load_info *info, int flags);
 231 #else /* !CONFIG_MODULE_SIG */
 232 static inline int module_sig_check(struct load_info *info, int flags)
 233 {
 234         return 0;
 235 }
 236 #endif /* !CONFIG_MODULE_SIG */
 237
 238 #ifdef CONFIG_DEBUG_KMEMLEAK
 239 void kmemleak_load_module(const struct module *mod, const struct load_info *info);
 240 #else /* !CONFIG_DEBUG_KMEMLEAK */
 241 static inline void kmemleak_load_module(const struct module *mod,
 242                                         const struct load_info *info) { }
 243 #endif /* CONFIG_DEBUG_KMEMLEAK */
 244
 245 #ifdef CONFIG_KALLSYMS
 246 void init_build_id(struct module *mod, const struct load_info *info);
 247 void layout_symtab(struct module *mod, struct load_info *info);
 248 void add_kallsyms(struct module *mod, const struct load_info *info);
 249 unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name);
 250
 251 static inline bool sect_empty(const Elf_Shdr *sect)
 252 {
 253         return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
 254 }
 255 #else /* !CONFIG_KALLSYMS */
 256 static inline void init_build_id(struct module *mod, const struct load_info *info) { }
 257 static inline void layout_symtab(struct module *mod, struct load_info *info) { }
 258 static inline void add_kallsyms(struct module *mod, const struct load_info *info) { }
 259 #endif /* CONFIG_KALLSYMS */
 260
 261 #ifdef CONFIG_SYSFS
 262 int mod_sysfs_setup(struct module *mod, const struct load_info *info,
 263                     struct kernel_param *kparam, unsigned int num_params);
 264 void mod_sysfs_teardown(struct module *mod);
 265 void init_param_lock(struct module *mod);
 266 #else /* !CONFIG_SYSFS */
 267 static inline int mod_sysfs_setup(struct module *mod,
 268                                   const struct load_info *info,
 269                                   struct kernel_param *kparam,
 270                                   unsigned int num_params)
 271 {
 272         return 0;
 273 }
 274
 275 static inline void mod_sysfs_teardown(struct module *mod) { }
 276 static inline void init_param_lock(struct module *mod) { }
 277 #endif /* CONFIG_SYSFS */
 278
 279 #ifdef CONFIG_MODVERSIONS
 280 int check_version(const struct load_info *info,
 281                   const char *symname, struct module *mod, const s32 *crc);
 282 void module_layout(struct module *mod, struct modversion_info *ver, struct kernel_param *kp,
 283                    struct kernel_symbol *ks, struct tracepoint * const *tp);
 284 int check_modstruct_version(const struct load_info *info, struct module *mod);
 285 int same_magic(const char *amagic, const char *bmagic, bool has_crcs);
 286 #else /* !CONFIG_MODVERSIONS */
 287 static inline int check_version(const struct load_info *info,
 288                                 const char *symname,
 289                                 struct module *mod,
 290                                 const s32 *crc)
 291 {
 292         return 1;
 293 }
 294
 295 static inline int check_modstruct_version(const struct load_info *info,
 296                                           struct module *mod)
 297 {
 298         return 1;
 299 }
 300
 301 static inline int same_magic(const char *amagic, const char *bmagic, bool has_crcs)
 302 {
 303         return strcmp(amagic, bmagic) == 0;
 304 }
 305 #endif /* CONFIG_MODVERSIONS */