kernel/module/kallsyms.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Module kallsyms support
   4  *
   5  * Copyright (C) 2010 Rusty Russell
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/module_symbol.h>
  10 #include <linux/kallsyms.h>
  11 #include <linux/buildid.h>
  12 #include <linux/bsearch.h>
  13 #include "internal.h"
  14
  15 /* Lookup exported symbol in given range of kernel_symbols */
  16 static const struct kernel_symbol *lookup_exported_symbol(const char *name,
  17                                                           const struct kernel_symbol *start,
  18                                                           const struct kernel_symbol *stop)
  19 {
  20         return bsearch(name, start, stop - start,
  21                         sizeof(struct kernel_symbol), cmp_name);
  22 }
  23
  24 static int is_exported(const char *name, unsigned long value,
  25                        const struct module *mod)
  26 {
  27         const struct kernel_symbol *ks;
  28
  29         if (!mod)
  30                 ks = lookup_exported_symbol(name, __start___ksymtab, __stop___ksymtab);
  31         else
  32                 ks = lookup_exported_symbol(name, mod->syms, mod->syms + mod->num_syms);
  33
  34         return ks && kernel_symbol_value(ks) == value;
  35 }
  36
  37 /* As per nm */
  38 static char elf_type(const Elf_Sym *sym, const struct load_info *info)
  39 {
  40         const Elf_Shdr *sechdrs = info->sechdrs;
  41
  42         if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
  43                 if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
  44                         return 'v';
  45                 else
  46                         return 'w';
  47         }
  48         if (sym->st_shndx == SHN_UNDEF)
  49                 return 'U';
  50         if (sym->st_shndx == SHN_ABS || sym->st_shndx == info->index.pcpu)
  51                 return 'a';
  52         if (sym->st_shndx >= SHN_LORESERVE)
  53                 return '?';
  54         if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
  55                 return 't';
  56         if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC &&
  57             sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
  58                 if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
  59                         return 'r';
  60                 else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
  61                         return 'g';
  62                 else
  63                         return 'd';
  64         }
  65         if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
  66                 if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
  67                         return 's';
  68                 else
  69                         return 'b';
  70         }
  71         if (strstarts(info->secstrings + sechdrs[sym->st_shndx].sh_name,
  72                       ".debug")) {
  73                 return 'n';
  74         }
  75         return '?';
  76 }
  77
  78 static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,
  79                            unsigned int shnum, unsigned int pcpundx)
  80 {
  81         const Elf_Shdr *sec;
  82         enum mod_mem_type type;
  83
  84         if (src->st_shndx == SHN_UNDEF ||
  85             src->st_shndx >= shnum ||
  86             !src->st_name)
  87                 return false;
  88
  89 #ifdef CONFIG_KALLSYMS_ALL
  90         if (src->st_shndx == pcpundx)
  91                 return true;
  92 #endif
  93
  94         sec = sechdrs + src->st_shndx;
  95         type = sec->sh_entsize >> SH_ENTSIZE_TYPE_SHIFT;
  96         if (!(sec->sh_flags & SHF_ALLOC)
  97 #ifndef CONFIG_KALLSYMS_ALL
  98             || !(sec->sh_flags & SHF_EXECINSTR)
  99 #endif
 100             || mod_mem_type_is_init(type))
 101                 return false;
 102
 103         return true;
 104 }
 105
 106 /*
 107  * We only allocate and copy the strings needed by the parts of symtab
 108  * we keep.  This is simple, but has the effect of making multiple
 109  * copies of duplicates.  We could be more sophisticated, see
 110  * linux-kernel thread starting with
 111  * <73defb5e4bca04a6431392cc341112b1@localhost>.
 112  */
 113 void layout_symtab(struct module *mod, struct load_info *info)
 114 {
 115         Elf_Shdr *symsect = info->sechdrs + info->index.sym;
 116         Elf_Shdr *strsect = info->sechdrs + info->index.str;
 117         const Elf_Sym *src;
 118         unsigned int i, nsrc, ndst, strtab_size = 0;
 119         struct module_memory *mod_mem_data = &mod->mem[MOD_DATA];
 120         struct module_memory *mod_mem_init_data = &mod->mem[MOD_INIT_DATA];
 121
 122         /* Put symbol section at end of init part of module. */
 123         symsect->sh_flags |= SHF_ALLOC;
 124         symsect->sh_entsize = module_get_offset_and_type(mod, MOD_INIT_DATA,
 125                                                          symsect, info->index.sym);
 126         pr_debug("\t%s\n", info->secstrings + symsect->sh_name);
 127
 128         src = (void *)info->hdr + symsect->sh_offset;
 129         nsrc = symsect->sh_size / sizeof(*src);
 130
 131         /* Compute total space required for the core symbols' strtab. */
 132         for (ndst = i = 0; i < nsrc; i++) {
 133                 if (i == 0 || is_livepatch_module(mod) ||
 134                     is_core_symbol(src + i, info->sechdrs, info->hdr->e_shnum,
 135                                    info->index.pcpu)) {
 136                         strtab_size += strlen(&info->strtab[src[i].st_name]) + 1;
 137                         ndst++;
 138                 }
 139         }
 140
 141         /* Append room for core symbols at end of core part. */
 142         info->symoffs = ALIGN(mod_mem_data->size, symsect->sh_addralign ?: 1);
 143         info->stroffs = mod_mem_data->size = info->symoffs + ndst * sizeof(Elf_Sym);
 144         mod_mem_data->size += strtab_size;
 145         /* Note add_kallsyms() computes strtab_size as core_typeoffs - stroffs */
 146         info->core_typeoffs = mod_mem_data->size;
 147         mod_mem_data->size += ndst * sizeof(char);
 148
 149         /* Put string table section at end of init part of module. */
 150         strsect->sh_flags |= SHF_ALLOC;
 151         strsect->sh_entsize = module_get_offset_and_type(mod, MOD_INIT_DATA,
 152                                                          strsect, info->index.str);
 153         pr_debug("\t%s\n", info->secstrings + strsect->sh_name);
 154
 155         /* We'll tack temporary mod_kallsyms on the end. */
 156         mod_mem_init_data->size = ALIGN(mod_mem_init_data->size,
 157                                         __alignof__(struct mod_kallsyms));
 158         info->mod_kallsyms_init_off = mod_mem_init_data->size;
 159
 160         mod_mem_init_data->size += sizeof(struct mod_kallsyms);
 161         info->init_typeoffs = mod_mem_init_data->size;
 162         mod_mem_init_data->size += nsrc * sizeof(char);
 163 }
 164
 165 /*
 166  * We use the full symtab and strtab which layout_symtab arranged to
 167  * be appended to the init section.  Later we switch to the cut-down
 168  * core-only ones.
 169  */
 170 void add_kallsyms(struct module *mod, const struct load_info *info)
 171 {
 172         unsigned int i, ndst;
 173         const Elf_Sym *src;
 174         Elf_Sym *dst;
 175         char *s;
 176         Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
 177         unsigned long strtab_size;
 178         void *data_base = mod->mem[MOD_DATA].base;
 179         void *init_data_base = mod->mem[MOD_INIT_DATA].base;
 180
 181         /* Set up to point into init section. */
 182         mod->kallsyms = (void __rcu *)init_data_base +
 183                 info->mod_kallsyms_init_off;
 184
 185         rcu_read_lock();
 186         /* The following is safe since this pointer cannot change */
 187         rcu_dereference(mod->kallsyms)->symtab = (void *)symsec->sh_addr;
 188         rcu_dereference(mod->kallsyms)->num_symtab = symsec->sh_size / sizeof(Elf_Sym);
 189         /* Make sure we get permanent strtab: don't use info->strtab. */
 190         rcu_dereference(mod->kallsyms)->strtab =
 191                 (void *)info->sechdrs[info->index.str].sh_addr;
 192         rcu_dereference(mod->kallsyms)->typetab = init_data_base + info->init_typeoffs;
 193
 194         /*
 195          * Now populate the cut down core kallsyms for after init
 196          * and set types up while we still have access to sections.
 197          */
 198         mod->core_kallsyms.symtab = dst = data_base + info->symoffs;
 199         mod->core_kallsyms.strtab = s = data_base + info->stroffs;
 200         mod->core_kallsyms.typetab = data_base + info->core_typeoffs;
 201         strtab_size = info->core_typeoffs - info->stroffs;
 202         src = rcu_dereference(mod->kallsyms)->symtab;
 203         for (ndst = i = 0; i < rcu_dereference(mod->kallsyms)->num_symtab; i++) {
 204                 rcu_dereference(mod->kallsyms)->typetab[i] = elf_type(src + i, info);
 205                 if (i == 0 || is_livepatch_module(mod) ||
 206                     is_core_symbol(src + i, info->sechdrs, info->hdr->e_shnum,
 207                                    info->index.pcpu)) {
 208                         ssize_t ret;
 209
 210                         mod->core_kallsyms.typetab[ndst] =
 211                             rcu_dereference(mod->kallsyms)->typetab[i];
 212                         dst[ndst] = src[i];
 213                         dst[ndst++].st_name = s - mod->core_kallsyms.strtab;
 214                         ret = strscpy(s,
 215                                       &rcu_dereference(mod->kallsyms)->strtab[src[i].st_name],
 216                                       strtab_size);
 217                         if (ret < 0)
 218                                 break;
 219                         s += ret + 1;
 220                         strtab_size -= ret + 1;
 221                 }
 222         }
 223         rcu_read_unlock();
 224         mod->core_kallsyms.num_symtab = ndst;
 225 }
 226
 227 #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)
 228 void init_build_id(struct module *mod, const struct load_info *info)
 229 {
 230         const Elf_Shdr *sechdr;
 231         unsigned int i;
 232
 233         for (i = 0; i < info->hdr->e_shnum; i++) {
 234                 sechdr = &info->sechdrs[i];
 235                 if (!sect_empty(sechdr) && sechdr->sh_type == SHT_NOTE &&
 236                     !build_id_parse_buf((void *)sechdr->sh_addr, mod->build_id,
 237                                         sechdr->sh_size))
 238                         break;
 239         }
 240 }
 241 #else
 242 void init_build_id(struct module *mod, const struct load_info *info)
 243 {
 244 }
 245 #endif
 246
 247 static const char *kallsyms_symbol_name(struct mod_kallsyms *kallsyms, unsigned int symnum)
 248 {
 249         return kallsyms->strtab + kallsyms->symtab[symnum].st_name;
 250 }
 251
 252 /*
 253  * Given a module and address, find the corresponding symbol and return its name
 254  * while providing its size and offset if needed.
 255  */
 256 static const char *find_kallsyms_symbol(struct module *mod,
 257                                         unsigned long addr,
 258                                         unsigned long *size,
 259                                         unsigned long *offset)
 260 {
 261         unsigned int i, best = 0;
 262         unsigned long nextval, bestval;
 263         struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms);
 264         struct module_memory *mod_mem;
 265
 266         /* At worse, next value is at end of module */
 267         if (within_module_init(addr, mod))
 268                 mod_mem = &mod->mem[MOD_INIT_TEXT];
 269         else
 270                 mod_mem = &mod->mem[MOD_TEXT];
 271
 272         nextval = (unsigned long)mod_mem->base + mod_mem->size;
 273
 274         bestval = kallsyms_symbol_value(&kallsyms->symtab[best]);
 275
 276         /*
 277          * Scan for closest preceding symbol, and next symbol. (ELF
 278          * starts real symbols at 1).
 279          */
 280         for (i = 1; i < kallsyms->num_symtab; i++) {
 281                 const Elf_Sym *sym = &kallsyms->symtab[i];
 282                 unsigned long thisval = kallsyms_symbol_value(sym);
 283
 284                 if (sym->st_shndx == SHN_UNDEF)
 285                         continue;
 286
 287                 /*
 288                  * We ignore unnamed symbols: they're uninformative
 289                  * and inserted at a whim.
 290                  */
 291                 if (*kallsyms_symbol_name(kallsyms, i) == '\0' ||
 292                     is_mapping_symbol(kallsyms_symbol_name(kallsyms, i)))
 293                         continue;
 294
 295                 if (thisval <= addr && thisval > bestval) {
 296                         best = i;
 297                         bestval = thisval;
 298                 }
 299                 if (thisval > addr && thisval < nextval)
 300                         nextval = thisval;
 301         }
 302
 303         if (!best)
 304                 return NULL;
 305
 306         if (size)
 307                 *size = nextval - bestval;
 308         if (offset)
 309                 *offset = addr - bestval;
 310
 311         return kallsyms_symbol_name(kallsyms, best);
 312 }
 313
 314 void * __weak dereference_module_function_descriptor(struct module *mod,
 315                                                      void *ptr)
 316 {
 317         return ptr;
 318 }
 319
 320 /*
 321  * For kallsyms to ask for address resolution.  NULL means not found.  Careful
 322  * not to lock to avoid deadlock on oopses, simply disable preemption.
 323  */
 324 const char *module_address_lookup(unsigned long addr,
 325                                   unsigned long *size,
 326                             unsigned long *offset,
 327                             char **modname,
 328                             const unsigned char **modbuildid,
 329                             char *namebuf)
 330 {
 331         const char *ret = NULL;
 332         struct module *mod;
 333
 334         preempt_disable();
 335         mod = __module_address(addr);
 336         if (mod) {
 337                 if (modname)
 338                         *modname = mod->name;
 339                 if (modbuildid) {
 340 #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)
 341                         *modbuildid = mod->build_id;
 342 #else
 343                         *modbuildid = NULL;
 344 #endif
 345                 }
 346
 347                 ret = find_kallsyms_symbol(mod, addr, size, offset);
 348         }
 349         /* Make a copy in here where it's safe */
 350         if (ret) {
 351                 strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
 352                 ret = namebuf;
 353         }
 354         preempt_enable();
 355
 356         return ret;
 357 }
 358
 359 int lookup_module_symbol_name(unsigned long addr, char *symname)
 360 {
 361         struct module *mod;
 362
 363         preempt_disable();
 364         list_for_each_entry_rcu(mod, &modules, list) {
 365                 if (mod->state == MODULE_STATE_UNFORMED)
 366                         continue;
 367                 if (within_module(addr, mod)) {
 368                         const char *sym;
 369
 370                         sym = find_kallsyms_symbol(mod, addr, NULL, NULL);
 371                         if (!sym)
 372                                 goto out;
 373
 374                         strscpy(symname, sym, KSYM_NAME_LEN);
 375                         preempt_enable();
 376                         return 0;
 377                 }
 378         }
 379 out:
 380         preempt_enable();
 381         return -ERANGE;
 382 }
 383
 384 int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
 385                                unsigned long *offset, char *modname, char *name)
 386 {
 387         struct module *mod;
 388
 389         preempt_disable();
 390         list_for_each_entry_rcu(mod, &modules, list) {
 391                 if (mod->state == MODULE_STATE_UNFORMED)
 392                         continue;
 393                 if (within_module(addr, mod)) {
 394                         const char *sym;
 395
 396                         sym = find_kallsyms_symbol(mod, addr, size, offset);
 397                         if (!sym)
 398                                 goto out;
 399                         if (modname)
 400                                 strscpy(modname, mod->name, MODULE_NAME_LEN);
 401                         if (name)
 402                                 strscpy(name, sym, KSYM_NAME_LEN);
 403                         preempt_enable();
 404                         return 0;
 405                 }
 406         }
 407 out:
 408         preempt_enable();
 409         return -ERANGE;
 410 }
 411
 412 int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
 413                        char *name, char *module_name, int *exported)
 414 {
 415         struct module *mod;
 416
 417         preempt_disable();
 418         list_for_each_entry_rcu(mod, &modules, list) {
 419                 struct mod_kallsyms *kallsyms;
 420
 421                 if (mod->state == MODULE_STATE_UNFORMED)
 422                         continue;
 423                 kallsyms = rcu_dereference_sched(mod->kallsyms);
 424                 if (symnum < kallsyms->num_symtab) {
 425                         const Elf_Sym *sym = &kallsyms->symtab[symnum];
 426
 427                         *value = kallsyms_symbol_value(sym);
 428                         *type = kallsyms->typetab[symnum];
 429                         strscpy(name, kallsyms_symbol_name(kallsyms, symnum), KSYM_NAME_LEN);
 430                         strscpy(module_name, mod->name, MODULE_NAME_LEN);
 431                         *exported = is_exported(name, *value, mod);
 432                         preempt_enable();
 433                         return 0;
 434                 }
 435                 symnum -= kallsyms->num_symtab;
 436         }
 437         preempt_enable();
 438         return -ERANGE;
 439 }
 440
 441 /* Given a module and name of symbol, find and return the symbol's value */
 442 static unsigned long __find_kallsyms_symbol_value(struct module *mod, const char *name)
 443 {
 444         unsigned int i;
 445         struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms);
 446
 447         for (i = 0; i < kallsyms->num_symtab; i++) {
 448                 const Elf_Sym *sym = &kallsyms->symtab[i];
 449
 450                 if (strcmp(name, kallsyms_symbol_name(kallsyms, i)) == 0 &&
 451                     sym->st_shndx != SHN_UNDEF)
 452                         return kallsyms_symbol_value(sym);
 453         }
 454         return 0;
 455 }
 456
 457 static unsigned long __module_kallsyms_lookup_name(const char *name)
 458 {
 459         struct module *mod;
 460         char *colon;
 461
 462         colon = strnchr(name, MODULE_NAME_LEN, ':');
 463         if (colon) {
 464                 mod = find_module_all(name, colon - name, false);
 465                 if (mod)
 466                         return __find_kallsyms_symbol_value(mod, colon + 1);
 467                 return 0;
 468         }
 469
 470         list_for_each_entry_rcu(mod, &modules, list) {
 471                 unsigned long ret;
 472
 473                 if (mod->state == MODULE_STATE_UNFORMED)
 474                         continue;
 475                 ret = __find_kallsyms_symbol_value(mod, name);
 476                 if (ret)
 477                         return ret;
 478         }
 479         return 0;
 480 }
 481
 482 /* Look for this name: can be of form module:name. */
 483 unsigned long module_kallsyms_lookup_name(const char *name)
 484 {
 485         unsigned long ret;
 486
 487         /* Don't lock: we're in enough trouble already. */
 488         preempt_disable();
 489         ret = __module_kallsyms_lookup_name(name);
 490         preempt_enable();
 491         return ret;
 492 }
 493
 494 unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name)
 495 {
 496         unsigned long ret;
 497
 498         preempt_disable();
 499         ret = __find_kallsyms_symbol_value(mod, name);
 500         preempt_enable();
 501         return ret;
 502 }
 503
 504 int module_kallsyms_on_each_symbol(const char *modname,
 505                                    int (*fn)(void *, const char *, unsigned long),
 506                                    void *data)
 507 {
 508         struct module *mod;
 509         unsigned int i;
 510         int ret = 0;
 511
 512         mutex_lock(&module_mutex);
 513         list_for_each_entry(mod, &modules, list) {
 514                 struct mod_kallsyms *kallsyms;
 515
 516                 if (mod->state == MODULE_STATE_UNFORMED)
 517                         continue;
 518
 519                 if (modname && strcmp(modname, mod->name))
 520                         continue;
 521
 522                 /* Use rcu_dereference_sched() to remain compliant with the sparse tool */
 523                 preempt_disable();
 524                 kallsyms = rcu_dereference_sched(mod->kallsyms);
 525                 preempt_enable();
 526
 527                 for (i = 0; i < kallsyms->num_symtab; i++) {
 528                         const Elf_Sym *sym = &kallsyms->symtab[i];
 529
 530                         if (sym->st_shndx == SHN_UNDEF)
 531                                 continue;
 532
 533                         ret = fn(data, kallsyms_symbol_name(kallsyms, i),
 534                                  kallsyms_symbol_value(sym));
 535                         if (ret != 0)
 536                                 goto out;
 537                 }
 538
 539                 /*
 540                  * The given module is found, the subsequent modules do not
 541                  * need to be compared.
 542                  */
 543                 if (modname)
 544                         break;
 545         }
 546 out:
 547         mutex_unlock(&module_mutex);
 548         return ret;
 549 }