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  * Copyright (C) 2023 Luis Chamberlain <mcgrof@kernel.org>
   7  */
   8
   9 #include <linux/elf.h>
  10 #include <linux/compiler.h>
  11 #include <linux/module.h>
  12 #include <linux/mutex.h>
  13 #include <linux/rculist.h>
  14 #include <linux/rcupdate.h>
  15 #include <linux/mm.h>
  16
  17 #ifndef ARCH_SHF_SMALL
  18 #define ARCH_SHF_SMALL 0
  19 #endif
  20
  21 /*
  22  * Use highest 4 bits of sh_entsize to store the mod_mem_type of this
  23  * section. This leaves 28 bits for offset on 32-bit systems, which is
  24  * about 256 MiB (WARN_ON_ONCE if we exceed that).
  25  */
  26
  27 #define SH_ENTSIZE_TYPE_BITS    4
  28 #define SH_ENTSIZE_TYPE_SHIFT   (BITS_PER_LONG - SH_ENTSIZE_TYPE_BITS)
  29 #define SH_ENTSIZE_TYPE_MASK    ((1UL << SH_ENTSIZE_TYPE_BITS) - 1)
  30 #define SH_ENTSIZE_OFFSET_MASK  ((1UL << (BITS_PER_LONG - SH_ENTSIZE_TYPE_BITS)) - 1)
  31
  32 /* Maximum number of characters written by module_flags() */
  33 #define MODULE_FLAGS_BUF_SIZE (TAINT_FLAGS_COUNT + 4)
  34
  35 struct kernel_symbol {
  36 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
  37         int value_offset;
  38         int name_offset;
  39         int namespace_offset;
  40 #else
  41         unsigned long value;
  42         const char *name;
  43         const char *namespace;
  44 #endif
  45 };
  46
  47 extern struct mutex module_mutex;
  48 extern struct list_head modules;
  49
  50 extern struct module_attribute *modinfo_attrs[];
  51 extern size_t modinfo_attrs_count;
  52
  53 /* Provided by the linker */
  54 extern const struct kernel_symbol __start___ksymtab[];
  55 extern const struct kernel_symbol __stop___ksymtab[];
  56 extern const struct kernel_symbol __start___ksymtab_gpl[];
  57 extern const struct kernel_symbol __stop___ksymtab_gpl[];
  58 extern const s32 __start___kcrctab[];
  59 extern const s32 __start___kcrctab_gpl[];
  60
  61 struct load_info {
  62         const char *name;
  63         /* pointer to module in temporary copy, freed at end of load_module() */
  64         struct module *mod;
  65         Elf_Ehdr *hdr;
  66         unsigned long len;
  67         Elf_Shdr *sechdrs;
  68         char *secstrings, *strtab;
  69         unsigned long symoffs, stroffs, init_typeoffs, core_typeoffs;
  70         bool sig_ok;
  71 #ifdef CONFIG_KALLSYMS
  72         unsigned long mod_kallsyms_init_off;
  73 #endif
  74 #ifdef CONFIG_MODULE_DECOMPRESS
  75 #ifdef CONFIG_MODULE_STATS
  76         unsigned long compressed_len;
  77 #endif
  78         struct page **pages;
  79         unsigned int max_pages;
  80         unsigned int used_pages;
  81 #endif
  82         struct {
  83                 unsigned int sym, str, mod, vers, info, pcpu;
  84         } index;
  85 };
  86
  87 enum mod_license {
  88         NOT_GPL_ONLY,
  89         GPL_ONLY,
  90 };
  91
  92 struct find_symbol_arg {
  93         /* Input */
  94         const char *name;
  95         bool gplok;
  96         bool warn;
  97
  98         /* Output */
  99         struct module *owner;
 100         const s32 *crc;
 101         const struct kernel_symbol *sym;
 102         enum mod_license license;
 103 };
 104
 105 int mod_verify_sig(const void *mod, struct load_info *info);
 106 int try_to_force_load(struct module *mod, const char *reason);
 107 bool find_symbol(struct find_symbol_arg *fsa);
 108 struct module *find_module_all(const char *name, size_t len, bool even_unformed);
 109 int cmp_name(const void *name, const void *sym);
 110 long module_get_offset_and_type(struct module *mod, enum mod_mem_type type,
 111                                 Elf_Shdr *sechdr, unsigned int section);
 112 char *module_flags(struct module *mod, char *buf, bool show_state);
 113 size_t module_flags_taint(unsigned long taints, char *buf);
 114
 115 char *module_next_tag_pair(char *string, unsigned long *secsize);
 116
 117 #define for_each_modinfo_entry(entry, info, name) \
 118         for (entry = get_modinfo(info, name); entry; entry = get_next_modinfo(info, name, entry))
 119
 120 static inline void module_assert_mutex_or_preempt(void)
 121 {
 122 #ifdef CONFIG_LOCKDEP
 123         if (unlikely(!debug_locks))
 124                 return;
 125
 126         WARN_ON_ONCE(!rcu_read_lock_sched_held() &&
 127                      !lockdep_is_held(&module_mutex));
 128 #endif
 129 }
 130
 131 static inline unsigned long kernel_symbol_value(const struct kernel_symbol *sym)
 132 {
 133 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
 134         return (unsigned long)offset_to_ptr(&sym->value_offset);
 135 #else
 136         return sym->value;
 137 #endif
 138 }
 139
 140 #ifdef CONFIG_LIVEPATCH
 141 int copy_module_elf(struct module *mod, struct load_info *info);
 142 void free_module_elf(struct module *mod);
 143 #else /* !CONFIG_LIVEPATCH */
 144 static inline int copy_module_elf(struct module *mod, struct load_info *info)
 145 {
 146         return 0;
 147 }
 148
 149 static inline void free_module_elf(struct module *mod) { }
 150 #endif /* CONFIG_LIVEPATCH */
 151
 152 static inline bool set_livepatch_module(struct module *mod)
 153 {
 154 #ifdef CONFIG_LIVEPATCH
 155         mod->klp = true;
 156         return true;
 157 #else
 158         return false;
 159 #endif
 160 }
 161
 162 /**
 163  * enum fail_dup_mod_reason - state at which a duplicate module was detected
 164  *
 165  * @FAIL_DUP_MOD_BECOMING: the module is read properly, passes all checks but
 166  *      we've determined that another module with the same name is already loaded
 167  *      or being processed on our &modules list. This happens on early_mod_check()
 168  *      right before layout_and_allocate(). The kernel would have already
 169  *      vmalloc()'d space for the entire module through finit_module(). If
 170  *      decompression was used two vmap() spaces were used. These failures can
 171  *      happen when userspace has not seen the module present on the kernel and
 172  *      tries to load the module multiple times at same time.
 173  * @FAIL_DUP_MOD_LOAD: the module has been read properly, passes all validation
 174  *      checks and the kernel determines that the module was unique and because
 175  *      of this allocated yet another private kernel copy of the module space in
 176  *      layout_and_allocate() but after this determined in add_unformed_module()
 177  *      that another module with the same name is already loaded or being processed.
 178  *      These failures should be mitigated as much as possible and are indicative
 179  *      of really fast races in loading modules. Without module decompression
 180  *      they waste twice as much vmap space. With module decompression three
 181  *      times the module's size vmap space is wasted.
 182  */
 183 enum fail_dup_mod_reason {
 184         FAIL_DUP_MOD_BECOMING = 0,
 185         FAIL_DUP_MOD_LOAD,
 186 };
 187
 188 #ifdef CONFIG_MODULE_DEBUGFS
 189 extern struct dentry *mod_debugfs_root;
 190 #endif
 191
 192 #ifdef CONFIG_MODULE_STATS
 193
 194 #define mod_stat_add_long(count, var) atomic_long_add(count, var)
 195 #define mod_stat_inc(name) atomic_inc(name)
 196
 197 extern atomic_long_t total_mod_size;
 198 extern atomic_long_t total_text_size;
 199 extern atomic_long_t invalid_kread_bytes;
 200 extern atomic_long_t invalid_decompress_bytes;
 201
 202 extern atomic_t modcount;
 203 extern atomic_t failed_kreads;
 204 extern atomic_t failed_decompress;
 205 struct mod_fail_load {
 206         struct list_head list;
 207         char name[MODULE_NAME_LEN];
 208         atomic_long_t count;
 209         unsigned long dup_fail_mask;
 210 };
 211
 212 int try_add_failed_module(const char *name, enum fail_dup_mod_reason reason);
 213 void mod_stat_bump_invalid(struct load_info *info, int flags);
 214 void mod_stat_bump_becoming(struct load_info *info, int flags);
 215
 216 #else
 217
 218 #define mod_stat_add_long(name, var)
 219 #define mod_stat_inc(name)
 220
 221 static inline int try_add_failed_module(const char *name,
 222                                         enum fail_dup_mod_reason reason)
 223 {
 224         return 0;
 225 }
 226
 227 static inline void mod_stat_bump_invalid(struct load_info *info, int flags)
 228 {
 229 }
 230
 231 static inline void mod_stat_bump_becoming(struct load_info *info, int flags)
 232 {
 233 }
 234
 235 #endif /* CONFIG_MODULE_STATS */
 236
 237 #ifdef CONFIG_MODULE_DEBUG_AUTOLOAD_DUPS
 238 bool kmod_dup_request_exists_wait(char *module_name, bool wait, int *dup_ret);
 239 void kmod_dup_request_announce(char *module_name, int ret);
 240 #else
 241 static inline bool kmod_dup_request_exists_wait(char *module_name, bool wait, int *dup_ret)
 242 {
 243         return false;
 244 }
 245
 246 static inline void kmod_dup_request_announce(char *module_name, int ret)
 247 {
 248 }
 249 #endif
 250
 251 #ifdef CONFIG_MODULE_UNLOAD_TAINT_TRACKING
 252 struct mod_unload_taint {
 253         struct list_head list;
 254         char name[MODULE_NAME_LEN];
 255         unsigned long taints;
 256         u64 count;
 257 };
 258
 259 int try_add_tainted_module(struct module *mod);
 260 void print_unloaded_tainted_modules(void);
 261 #else /* !CONFIG_MODULE_UNLOAD_TAINT_TRACKING */
 262 static inline int try_add_tainted_module(struct module *mod)
 263 {
 264         return 0;
 265 }
 266
 267 static inline void print_unloaded_tainted_modules(void)
 268 {
 269 }
 270 #endif /* CONFIG_MODULE_UNLOAD_TAINT_TRACKING */
 271
 272 #ifdef CONFIG_MODULE_DECOMPRESS
 273 int module_decompress(struct load_info *info, const void *buf, size_t size);
 274 void module_decompress_cleanup(struct load_info *info);
 275 #else
 276 static inline int module_decompress(struct load_info *info,
 277                                     const void *buf, size_t size)
 278 {
 279         return -EOPNOTSUPP;
 280 }
 281
 282 static inline void module_decompress_cleanup(struct load_info *info)
 283 {
 284 }
 285 #endif
 286
 287 struct mod_tree_root {
 288 #ifdef CONFIG_MODULES_TREE_LOOKUP
 289         struct latch_tree_root root;
 290 #endif
 291         unsigned long addr_min;
 292         unsigned long addr_max;
 293 #ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
 294         unsigned long data_addr_min;
 295         unsigned long data_addr_max;
 296 #endif
 297 };
 298
 299 extern struct mod_tree_root mod_tree;
 300
 301 #ifdef CONFIG_MODULES_TREE_LOOKUP
 302 void mod_tree_insert(struct module *mod);
 303 void mod_tree_remove_init(struct module *mod);
 304 void mod_tree_remove(struct module *mod);
 305 struct module *mod_find(unsigned long addr, struct mod_tree_root *tree);
 306 #else /* !CONFIG_MODULES_TREE_LOOKUP */
 307
 308 static inline void mod_tree_insert(struct module *mod) { }
 309 static inline void mod_tree_remove_init(struct module *mod) { }
 310 static inline void mod_tree_remove(struct module *mod) { }
 311 static inline struct module *mod_find(unsigned long addr, struct mod_tree_root *tree)
 312 {
 313         struct module *mod;
 314
 315         list_for_each_entry_rcu(mod, &modules, list,
 316                                 lockdep_is_held(&module_mutex)) {
 317                 if (within_module(addr, mod))
 318                         return mod;
 319         }
 320
 321         return NULL;
 322 }
 323 #endif /* CONFIG_MODULES_TREE_LOOKUP */
 324
 325 void module_enable_ro(const struct module *mod, bool after_init);
 326 void module_enable_nx(const struct module *mod);
 327 void module_enable_x(const struct module *mod);
 328 int module_enforce_rwx_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs,
 329                                 char *secstrings, struct module *mod);
 330
 331 #ifdef CONFIG_MODULE_SIG
 332 int module_sig_check(struct load_info *info, int flags);
 333 #else /* !CONFIG_MODULE_SIG */
 334 static inline int module_sig_check(struct load_info *info, int flags)
 335 {
 336         return 0;
 337 }
 338 #endif /* !CONFIG_MODULE_SIG */
 339
 340 #ifdef CONFIG_DEBUG_KMEMLEAK
 341 void kmemleak_load_module(const struct module *mod, const struct load_info *info);
 342 #else /* !CONFIG_DEBUG_KMEMLEAK */
 343 static inline void kmemleak_load_module(const struct module *mod,
 344                                         const struct load_info *info) { }
 345 #endif /* CONFIG_DEBUG_KMEMLEAK */
 346
 347 #ifdef CONFIG_KALLSYMS
 348 void init_build_id(struct module *mod, const struct load_info *info);
 349 void layout_symtab(struct module *mod, struct load_info *info);
 350 void add_kallsyms(struct module *mod, const struct load_info *info);
 351
 352 static inline bool sect_empty(const Elf_Shdr *sect)
 353 {
 354         return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
 355 }
 356 #else /* !CONFIG_KALLSYMS */
 357 static inline void init_build_id(struct module *mod, const struct load_info *info) { }
 358 static inline void layout_symtab(struct module *mod, struct load_info *info) { }
 359 static inline void add_kallsyms(struct module *mod, const struct load_info *info) { }
 360 #endif /* CONFIG_KALLSYMS */
 361
 362 #ifdef CONFIG_SYSFS
 363 int mod_sysfs_setup(struct module *mod, const struct load_info *info,
 364                     struct kernel_param *kparam, unsigned int num_params);
 365 void mod_sysfs_teardown(struct module *mod);
 366 void init_param_lock(struct module *mod);
 367 #else /* !CONFIG_SYSFS */
 368 static inline int mod_sysfs_setup(struct module *mod,
 369                                   const struct load_info *info,
 370                                   struct kernel_param *kparam,
 371                                   unsigned int num_params)
 372 {
 373         return 0;
 374 }
 375
 376 static inline void mod_sysfs_teardown(struct module *mod) { }
 377 static inline void init_param_lock(struct module *mod) { }
 378 #endif /* CONFIG_SYSFS */
 379
 380 #ifdef CONFIG_MODVERSIONS
 381 int check_version(const struct load_info *info,
 382                   const char *symname, struct module *mod, const s32 *crc);
 383 void module_layout(struct module *mod, struct modversion_info *ver, struct kernel_param *kp,
 384                    struct kernel_symbol *ks, struct tracepoint * const *tp);
 385 int check_modstruct_version(const struct load_info *info, struct module *mod);
 386 int same_magic(const char *amagic, const char *bmagic, bool has_crcs);
 387 #else /* !CONFIG_MODVERSIONS */
 388 static inline int check_version(const struct load_info *info,
 389                                 const char *symname,
 390                                 struct module *mod,
 391                                 const s32 *crc)
 392 {
 393         return 1;
 394 }
 395
 396 static inline int check_modstruct_version(const struct load_info *info,
 397                                           struct module *mod)
 398 {
 399         return 1;
 400 }
 401
 402 static inline int same_magic(const char *amagic, const char *bmagic, bool has_crcs)
 403 {
 404         return strcmp(amagic, bmagic) == 0;
 405 }
 406 #endif /* CONFIG_MODVERSIONS */