1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * kallsyms.c: in-kernel printing of symbolic oopses and stack traces. 4 * 5 * Rewritten and vastly simplified by Rusty Russell for in-kernel 6 * module loader: 7 * Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation 8 * 9 * ChangeLog: 10 * 11 * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com> 12 * Changed the compression method from stem compression to "table lookup" 13 * compression (see scripts/kallsyms.c for a more complete description) 14 */ 15 #include <linux/kallsyms.h> 16 #include <linux/init.h> 17 #include <linux/seq_file.h> 18 #include <linux/fs.h> 19 #include <linux/kdb.h> 20 #include <linux/err.h> 21 #include <linux/proc_fs.h> 22 #include <linux/sched.h> /* for cond_resched */ 23 #include <linux/ctype.h> 24 #include <linux/slab.h> 25 #include <linux/filter.h> 26 #include <linux/ftrace.h> 27 #include <linux/kprobes.h> 28 #include <linux/build_bug.h> 29 #include <linux/compiler.h> 30 #include <linux/module.h> 31 #include <linux/kernel.h> 32 #include <linux/bsearch.h> 33 #include <linux/btf_ids.h> 34 35 #include "kallsyms_internal.h" 36 37 /* 38 * Expand a compressed symbol data into the resulting uncompressed string, 39 * if uncompressed string is too long (>= maxlen), it will be truncated, 40 * given the offset to where the symbol is in the compressed stream. 41 */ 42 static unsigned int kallsyms_expand_symbol(unsigned int off, 43 char *result, size_t maxlen) 44 { 45 int len, skipped_first = 0; 46 const char *tptr; 47 const u8 *data; 48 49 /* Get the compressed symbol length from the first symbol byte. */ 50 data = &kallsyms_names[off]; 51 len = *data; 52 data++; 53 off++; 54 55 /* If MSB is 1, it is a "big" symbol, so needs an additional byte. */ 56 if ((len & 0x80) != 0) { 57 len = (len & 0x7F) | (*data << 7); 58 data++; 59 off++; 60 } 61 62 /* 63 * Update the offset to return the offset for the next symbol on 64 * the compressed stream. 65 */ 66 off += len; 67 68 /* 69 * For every byte on the compressed symbol data, copy the table 70 * entry for that byte. 71 */ 72 while (len) { 73 tptr = &kallsyms_token_table[kallsyms_token_index[*data]]; 74 data++; 75 len--; 76 77 while (*tptr) { 78 if (skipped_first) { 79 if (maxlen <= 1) 80 goto tail; 81 *result = *tptr; 82 result++; 83 maxlen--; 84 } else 85 skipped_first = 1; 86 tptr++; 87 } 88 } 89 90 tail: 91 if (maxlen) 92 *result = '\0'; 93 94 /* Return to offset to the next symbol. */ 95 return off; 96 } 97 98 /* 99 * Get symbol type information. This is encoded as a single char at the 100 * beginning of the symbol name. 101 */ 102 static char kallsyms_get_symbol_type(unsigned int off) 103 { 104 /* 105 * Get just the first code, look it up in the token table, 106 * and return the first char from this token. 107 */ 108 return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]]; 109 } 110 111 112 /* 113 * Find the offset on the compressed stream given and index in the 114 * kallsyms array. 115 */ 116 static unsigned int get_symbol_offset(unsigned long pos) 117 { 118 const u8 *name; 119 int i, len; 120 121 /* 122 * Use the closest marker we have. We have markers every 256 positions, 123 * so that should be close enough. 124 */ 125 name = &kallsyms_names[kallsyms_markers[pos >> 8]]; 126 127 /* 128 * Sequentially scan all the symbols up to the point we're searching 129 * for. Every symbol is stored in a [<len>][<len> bytes of data] format, 130 * so we just need to add the len to the current pointer for every 131 * symbol we wish to skip. 132 */ 133 for (i = 0; i < (pos & 0xFF); i++) { 134 len = *name; 135 136 /* 137 * If MSB is 1, it is a "big" symbol, so we need to look into 138 * the next byte (and skip it, too). 139 */ 140 if ((len & 0x80) != 0) 141 len = ((len & 0x7F) | (name[1] << 7)) + 1; 142 143 name = name + len + 1; 144 } 145 146 return name - kallsyms_names; 147 } 148 149 static unsigned long kallsyms_sym_address(int idx) 150 { 151 if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) 152 return kallsyms_addresses[idx]; 153 154 /* values are unsigned offsets if --absolute-percpu is not in effect */ 155 if (!IS_ENABLED(CONFIG_KALLSYMS_ABSOLUTE_PERCPU)) 156 return kallsyms_relative_base + (u32)kallsyms_offsets[idx]; 157 158 /* ...otherwise, positive offsets are absolute values */ 159 if (kallsyms_offsets[idx] >= 0) 160 return kallsyms_offsets[idx]; 161 162 /* ...and negative offsets are relative to kallsyms_relative_base - 1 */ 163 return kallsyms_relative_base - 1 - kallsyms_offsets[idx]; 164 } 165 166 static bool cleanup_symbol_name(char *s) 167 { 168 char *res; 169 170 if (!IS_ENABLED(CONFIG_LTO_CLANG)) 171 return false; 172 173 /* 174 * LLVM appends various suffixes for local functions and variables that 175 * must be promoted to global scope as part of LTO. This can break 176 * hooking of static functions with kprobes. '.' is not a valid 177 * character in an identifier in C. Suffixes observed: 178 * - foo.llvm.[0-9a-f]+ 179 * - foo.[0-9a-f]+ 180 * - foo.[0-9a-f]+.cfi_jt 181 */ 182 res = strchr(s, '.'); 183 if (res) { 184 *res = '\0'; 185 return true; 186 } 187 188 if (!IS_ENABLED(CONFIG_CFI_CLANG) || 189 !IS_ENABLED(CONFIG_LTO_CLANG_THIN) || 190 CONFIG_CLANG_VERSION >= 130000) 191 return false; 192 193 /* 194 * Prior to LLVM 13, the following suffixes were observed when thinLTO 195 * and CFI are both enabled: 196 * - foo$[0-9]+ 197 */ 198 res = strrchr(s, '$'); 199 if (res) { 200 *res = '\0'; 201 return true; 202 } 203 204 return false; 205 } 206 207 /* Lookup the address for this symbol. Returns 0 if not found. */ 208 unsigned long kallsyms_lookup_name(const char *name) 209 { 210 char namebuf[KSYM_NAME_LEN]; 211 unsigned long i; 212 unsigned int off; 213 214 /* Skip the search for empty string. */ 215 if (!*name) 216 return 0; 217 218 for (i = 0, off = 0; i < kallsyms_num_syms; i++) { 219 off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); 220 221 if (strcmp(namebuf, name) == 0) 222 return kallsyms_sym_address(i); 223 224 if (cleanup_symbol_name(namebuf) && strcmp(namebuf, name) == 0) 225 return kallsyms_sym_address(i); 226 } 227 return module_kallsyms_lookup_name(name); 228 } 229 230 /* 231 * Iterate over all symbols in vmlinux. For symbols from modules use 232 * module_kallsyms_on_each_symbol instead. 233 */ 234 int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *, 235 unsigned long), 236 void *data) 237 { 238 char namebuf[KSYM_NAME_LEN]; 239 unsigned long i; 240 unsigned int off; 241 int ret; 242 243 for (i = 0, off = 0; i < kallsyms_num_syms; i++) { 244 off = kallsyms_expand_symbol(off, namebuf, ARRAY_SIZE(namebuf)); 245 ret = fn(data, namebuf, NULL, kallsyms_sym_address(i)); 246 if (ret != 0) 247 return ret; 248 cond_resched(); 249 } 250 return 0; 251 } 252 253 static unsigned long get_symbol_pos(unsigned long addr, 254 unsigned long *symbolsize, 255 unsigned long *offset) 256 { 257 unsigned long symbol_start = 0, symbol_end = 0; 258 unsigned long i, low, high, mid; 259 260 /* This kernel should never had been booted. */ 261 if (!IS_ENABLED(CONFIG_KALLSYMS_BASE_RELATIVE)) 262 BUG_ON(!kallsyms_addresses); 263 else 264 BUG_ON(!kallsyms_offsets); 265 266 /* Do a binary search on the sorted kallsyms_addresses array. */ 267 low = 0; 268 high = kallsyms_num_syms; 269 270 while (high - low > 1) { 271 mid = low + (high - low) / 2; 272 if (kallsyms_sym_address(mid) <= addr) 273 low = mid; 274 else 275 high = mid; 276 } 277 278 /* 279 * Search for the first aliased symbol. Aliased 280 * symbols are symbols with the same address. 281 */ 282 while (low && kallsyms_sym_address(low-1) == kallsyms_sym_address(low)) 283 --low; 284 285 symbol_start = kallsyms_sym_address(low); 286 287 /* Search for next non-aliased symbol. */ 288 for (i = low + 1; i < kallsyms_num_syms; i++) { 289 if (kallsyms_sym_address(i) > symbol_start) { 290 symbol_end = kallsyms_sym_address(i); 291 break; 292 } 293 } 294 295 /* If we found no next symbol, we use the end of the section. */ 296 if (!symbol_end) { 297 if (is_kernel_inittext(addr)) 298 symbol_end = (unsigned long)_einittext; 299 else if (IS_ENABLED(CONFIG_KALLSYMS_ALL)) 300 symbol_end = (unsigned long)_end; 301 else 302 symbol_end = (unsigned long)_etext; 303 } 304 305 if (symbolsize) 306 *symbolsize = symbol_end - symbol_start; 307 if (offset) 308 *offset = addr - symbol_start; 309 310 return low; 311 } 312 313 /* 314 * Lookup an address but don't bother to find any names. 315 */ 316 int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize, 317 unsigned long *offset) 318 { 319 char namebuf[KSYM_NAME_LEN]; 320 321 if (is_ksym_addr(addr)) { 322 get_symbol_pos(addr, symbolsize, offset); 323 return 1; 324 } 325 return !!module_address_lookup(addr, symbolsize, offset, NULL, NULL, namebuf) || 326 !!__bpf_address_lookup(addr, symbolsize, offset, namebuf); 327 } 328 329 static const char *kallsyms_lookup_buildid(unsigned long addr, 330 unsigned long *symbolsize, 331 unsigned long *offset, char **modname, 332 const unsigned char **modbuildid, char *namebuf) 333 { 334 const char *ret; 335 336 namebuf[KSYM_NAME_LEN - 1] = 0; 337 namebuf[0] = 0; 338 339 if (is_ksym_addr(addr)) { 340 unsigned long pos; 341 342 pos = get_symbol_pos(addr, symbolsize, offset); 343 /* Grab name */ 344 kallsyms_expand_symbol(get_symbol_offset(pos), 345 namebuf, KSYM_NAME_LEN); 346 if (modname) 347 *modname = NULL; 348 if (modbuildid) 349 *modbuildid = NULL; 350 351 ret = namebuf; 352 goto found; 353 } 354 355 /* See if it's in a module or a BPF JITed image. */ 356 ret = module_address_lookup(addr, symbolsize, offset, 357 modname, modbuildid, namebuf); 358 if (!ret) 359 ret = bpf_address_lookup(addr, symbolsize, 360 offset, modname, namebuf); 361 362 if (!ret) 363 ret = ftrace_mod_address_lookup(addr, symbolsize, 364 offset, modname, namebuf); 365 366 found: 367 cleanup_symbol_name(namebuf); 368 return ret; 369 } 370 371 /* 372 * Lookup an address 373 * - modname is set to NULL if it's in the kernel. 374 * - We guarantee that the returned name is valid until we reschedule even if. 375 * It resides in a module. 376 * - We also guarantee that modname will be valid until rescheduled. 377 */ 378 const char *kallsyms_lookup(unsigned long addr, 379 unsigned long *symbolsize, 380 unsigned long *offset, 381 char **modname, char *namebuf) 382 { 383 return kallsyms_lookup_buildid(addr, symbolsize, offset, modname, 384 NULL, namebuf); 385 } 386 387 int lookup_symbol_name(unsigned long addr, char *symname) 388 { 389 int res; 390 391 symname[0] = '\0'; 392 symname[KSYM_NAME_LEN - 1] = '\0'; 393 394 if (is_ksym_addr(addr)) { 395 unsigned long pos; 396 397 pos = get_symbol_pos(addr, NULL, NULL); 398 /* Grab name */ 399 kallsyms_expand_symbol(get_symbol_offset(pos), 400 symname, KSYM_NAME_LEN); 401 goto found; 402 } 403 /* See if it's in a module. */ 404 res = lookup_module_symbol_name(addr, symname); 405 if (res) 406 return res; 407 408 found: 409 cleanup_symbol_name(symname); 410 return 0; 411 } 412 413 int lookup_symbol_attrs(unsigned long addr, unsigned long *size, 414 unsigned long *offset, char *modname, char *name) 415 { 416 int res; 417 418 name[0] = '\0'; 419 name[KSYM_NAME_LEN - 1] = '\0'; 420 421 if (is_ksym_addr(addr)) { 422 unsigned long pos; 423 424 pos = get_symbol_pos(addr, size, offset); 425 /* Grab name */ 426 kallsyms_expand_symbol(get_symbol_offset(pos), 427 name, KSYM_NAME_LEN); 428 modname[0] = '\0'; 429 goto found; 430 } 431 /* See if it's in a module. */ 432 res = lookup_module_symbol_attrs(addr, size, offset, modname, name); 433 if (res) 434 return res; 435 436 found: 437 cleanup_symbol_name(name); 438 return 0; 439 } 440 441 /* Look up a kernel symbol and return it in a text buffer. */ 442 static int __sprint_symbol(char *buffer, unsigned long address, 443 int symbol_offset, int add_offset, int add_buildid) 444 { 445 char *modname; 446 const unsigned char *buildid; 447 const char *name; 448 unsigned long offset, size; 449 int len; 450 451 address += symbol_offset; 452 name = kallsyms_lookup_buildid(address, &size, &offset, &modname, &buildid, 453 buffer); 454 if (!name) 455 return sprintf(buffer, "0x%lx", address - symbol_offset); 456 457 if (name != buffer) 458 strcpy(buffer, name); 459 len = strlen(buffer); 460 offset -= symbol_offset; 461 462 if (add_offset) 463 len += sprintf(buffer + len, "+%#lx/%#lx", offset, size); 464 465 if (modname) { 466 len += sprintf(buffer + len, " [%s", modname); 467 #if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID) 468 if (add_buildid && buildid) { 469 /* build ID should match length of sprintf */ 470 #if IS_ENABLED(CONFIG_MODULES) 471 static_assert(sizeof(typeof_member(struct module, build_id)) == 20); 472 #endif 473 len += sprintf(buffer + len, " %20phN", buildid); 474 } 475 #endif 476 len += sprintf(buffer + len, "]"); 477 } 478 479 return len; 480 } 481 482 /** 483 * sprint_symbol - Look up a kernel symbol and return it in a text buffer 484 * @buffer: buffer to be stored 485 * @address: address to lookup 486 * 487 * This function looks up a kernel symbol with @address and stores its name, 488 * offset, size and module name to @buffer if possible. If no symbol was found, 489 * just saves its @address as is. 490 * 491 * This function returns the number of bytes stored in @buffer. 492 */ 493 int sprint_symbol(char *buffer, unsigned long address) 494 { 495 return __sprint_symbol(buffer, address, 0, 1, 0); 496 } 497 EXPORT_SYMBOL_GPL(sprint_symbol); 498 499 /** 500 * sprint_symbol_build_id - Look up a kernel symbol and return it in a text buffer 501 * @buffer: buffer to be stored 502 * @address: address to lookup 503 * 504 * This function looks up a kernel symbol with @address and stores its name, 505 * offset, size, module name and module build ID to @buffer if possible. If no 506 * symbol was found, just saves its @address as is. 507 * 508 * This function returns the number of bytes stored in @buffer. 509 */ 510 int sprint_symbol_build_id(char *buffer, unsigned long address) 511 { 512 return __sprint_symbol(buffer, address, 0, 1, 1); 513 } 514 EXPORT_SYMBOL_GPL(sprint_symbol_build_id); 515 516 /** 517 * sprint_symbol_no_offset - Look up a kernel symbol and return it in a text buffer 518 * @buffer: buffer to be stored 519 * @address: address to lookup 520 * 521 * This function looks up a kernel symbol with @address and stores its name 522 * and module name to @buffer if possible. If no symbol was found, just saves 523 * its @address as is. 524 * 525 * This function returns the number of bytes stored in @buffer. 526 */ 527 int sprint_symbol_no_offset(char *buffer, unsigned long address) 528 { 529 return __sprint_symbol(buffer, address, 0, 0, 0); 530 } 531 EXPORT_SYMBOL_GPL(sprint_symbol_no_offset); 532 533 /** 534 * sprint_backtrace - Look up a backtrace symbol and return it in a text buffer 535 * @buffer: buffer to be stored 536 * @address: address to lookup 537 * 538 * This function is for stack backtrace and does the same thing as 539 * sprint_symbol() but with modified/decreased @address. If there is a 540 * tail-call to the function marked "noreturn", gcc optimized out code after 541 * the call so that the stack-saved return address could point outside of the 542 * caller. This function ensures that kallsyms will find the original caller 543 * by decreasing @address. 544 * 545 * This function returns the number of bytes stored in @buffer. 546 */ 547 int sprint_backtrace(char *buffer, unsigned long address) 548 { 549 return __sprint_symbol(buffer, address, -1, 1, 0); 550 } 551 552 /** 553 * sprint_backtrace_build_id - Look up a backtrace symbol and return it in a text buffer 554 * @buffer: buffer to be stored 555 * @address: address to lookup 556 * 557 * This function is for stack backtrace and does the same thing as 558 * sprint_symbol() but with modified/decreased @address. If there is a 559 * tail-call to the function marked "noreturn", gcc optimized out code after 560 * the call so that the stack-saved return address could point outside of the 561 * caller. This function ensures that kallsyms will find the original caller 562 * by decreasing @address. This function also appends the module build ID to 563 * the @buffer if @address is within a kernel module. 564 * 565 * This function returns the number of bytes stored in @buffer. 566 */ 567 int sprint_backtrace_build_id(char *buffer, unsigned long address) 568 { 569 return __sprint_symbol(buffer, address, -1, 1, 1); 570 } 571 572 /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */ 573 struct kallsym_iter { 574 loff_t pos; 575 loff_t pos_arch_end; 576 loff_t pos_mod_end; 577 loff_t pos_ftrace_mod_end; 578 loff_t pos_bpf_end; 579 unsigned long value; 580 unsigned int nameoff; /* If iterating in core kernel symbols. */ 581 char type; 582 char name[KSYM_NAME_LEN]; 583 char module_name[MODULE_NAME_LEN]; 584 int exported; 585 int show_value; 586 }; 587 588 int __weak arch_get_kallsym(unsigned int symnum, unsigned long *value, 589 char *type, char *name) 590 { 591 return -EINVAL; 592 } 593 594 static int get_ksymbol_arch(struct kallsym_iter *iter) 595 { 596 int ret = arch_get_kallsym(iter->pos - kallsyms_num_syms, 597 &iter->value, &iter->type, 598 iter->name); 599 600 if (ret < 0) { 601 iter->pos_arch_end = iter->pos; 602 return 0; 603 } 604 605 return 1; 606 } 607 608 static int get_ksymbol_mod(struct kallsym_iter *iter) 609 { 610 int ret = module_get_kallsym(iter->pos - iter->pos_arch_end, 611 &iter->value, &iter->type, 612 iter->name, iter->module_name, 613 &iter->exported); 614 if (ret < 0) { 615 iter->pos_mod_end = iter->pos; 616 return 0; 617 } 618 619 return 1; 620 } 621 622 /* 623 * ftrace_mod_get_kallsym() may also get symbols for pages allocated for ftrace 624 * purposes. In that case "__builtin__ftrace" is used as a module name, even 625 * though "__builtin__ftrace" is not a module. 626 */ 627 static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter) 628 { 629 int ret = ftrace_mod_get_kallsym(iter->pos - iter->pos_mod_end, 630 &iter->value, &iter->type, 631 iter->name, iter->module_name, 632 &iter->exported); 633 if (ret < 0) { 634 iter->pos_ftrace_mod_end = iter->pos; 635 return 0; 636 } 637 638 return 1; 639 } 640 641 static int get_ksymbol_bpf(struct kallsym_iter *iter) 642 { 643 int ret; 644 645 strlcpy(iter->module_name, "bpf", MODULE_NAME_LEN); 646 iter->exported = 0; 647 ret = bpf_get_kallsym(iter->pos - iter->pos_ftrace_mod_end, 648 &iter->value, &iter->type, 649 iter->name); 650 if (ret < 0) { 651 iter->pos_bpf_end = iter->pos; 652 return 0; 653 } 654 655 return 1; 656 } 657 658 /* 659 * This uses "__builtin__kprobes" as a module name for symbols for pages 660 * allocated for kprobes' purposes, even though "__builtin__kprobes" is not a 661 * module. 662 */ 663 static int get_ksymbol_kprobe(struct kallsym_iter *iter) 664 { 665 strlcpy(iter->module_name, "__builtin__kprobes", MODULE_NAME_LEN); 666 iter->exported = 0; 667 return kprobe_get_kallsym(iter->pos - iter->pos_bpf_end, 668 &iter->value, &iter->type, 669 iter->name) < 0 ? 0 : 1; 670 } 671 672 /* Returns space to next name. */ 673 static unsigned long get_ksymbol_core(struct kallsym_iter *iter) 674 { 675 unsigned off = iter->nameoff; 676 677 iter->module_name[0] = '\0'; 678 iter->value = kallsyms_sym_address(iter->pos); 679 680 iter->type = kallsyms_get_symbol_type(off); 681 682 off = kallsyms_expand_symbol(off, iter->name, ARRAY_SIZE(iter->name)); 683 684 return off - iter->nameoff; 685 } 686 687 static void reset_iter(struct kallsym_iter *iter, loff_t new_pos) 688 { 689 iter->name[0] = '\0'; 690 iter->nameoff = get_symbol_offset(new_pos); 691 iter->pos = new_pos; 692 if (new_pos == 0) { 693 iter->pos_arch_end = 0; 694 iter->pos_mod_end = 0; 695 iter->pos_ftrace_mod_end = 0; 696 iter->pos_bpf_end = 0; 697 } 698 } 699 700 /* 701 * The end position (last + 1) of each additional kallsyms section is recorded 702 * in iter->pos_..._end as each section is added, and so can be used to 703 * determine which get_ksymbol_...() function to call next. 704 */ 705 static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) 706 { 707 iter->pos = pos; 708 709 if ((!iter->pos_arch_end || iter->pos_arch_end > pos) && 710 get_ksymbol_arch(iter)) 711 return 1; 712 713 if ((!iter->pos_mod_end || iter->pos_mod_end > pos) && 714 get_ksymbol_mod(iter)) 715 return 1; 716 717 if ((!iter->pos_ftrace_mod_end || iter->pos_ftrace_mod_end > pos) && 718 get_ksymbol_ftrace_mod(iter)) 719 return 1; 720 721 if ((!iter->pos_bpf_end || iter->pos_bpf_end > pos) && 722 get_ksymbol_bpf(iter)) 723 return 1; 724 725 return get_ksymbol_kprobe(iter); 726 } 727 728 /* Returns false if pos at or past end of file. */ 729 static int update_iter(struct kallsym_iter *iter, loff_t pos) 730 { 731 /* Module symbols can be accessed randomly. */ 732 if (pos >= kallsyms_num_syms) 733 return update_iter_mod(iter, pos); 734 735 /* If we're not on the desired position, reset to new position. */ 736 if (pos != iter->pos) 737 reset_iter(iter, pos); 738 739 iter->nameoff += get_ksymbol_core(iter); 740 iter->pos++; 741 742 return 1; 743 } 744 745 static void *s_next(struct seq_file *m, void *p, loff_t *pos) 746 { 747 (*pos)++; 748 749 if (!update_iter(m->private, *pos)) 750 return NULL; 751 return p; 752 } 753 754 static void *s_start(struct seq_file *m, loff_t *pos) 755 { 756 if (!update_iter(m->private, *pos)) 757 return NULL; 758 return m->private; 759 } 760 761 static void s_stop(struct seq_file *m, void *p) 762 { 763 } 764 765 static int s_show(struct seq_file *m, void *p) 766 { 767 void *value; 768 struct kallsym_iter *iter = m->private; 769 770 /* Some debugging symbols have no name. Ignore them. */ 771 if (!iter->name[0]) 772 return 0; 773 774 value = iter->show_value ? (void *)iter->value : NULL; 775 776 if (iter->module_name[0]) { 777 char type; 778 779 /* 780 * Label it "global" if it is exported, 781 * "local" if not exported. 782 */ 783 type = iter->exported ? toupper(iter->type) : 784 tolower(iter->type); 785 seq_printf(m, "%px %c %s\t[%s]\n", value, 786 type, iter->name, iter->module_name); 787 } else 788 seq_printf(m, "%px %c %s\n", value, 789 iter->type, iter->name); 790 return 0; 791 } 792 793 static const struct seq_operations kallsyms_op = { 794 .start = s_start, 795 .next = s_next, 796 .stop = s_stop, 797 .show = s_show 798 }; 799 800 #ifdef CONFIG_BPF_SYSCALL 801 802 struct bpf_iter__ksym { 803 __bpf_md_ptr(struct bpf_iter_meta *, meta); 804 __bpf_md_ptr(struct kallsym_iter *, ksym); 805 }; 806 807 static int ksym_prog_seq_show(struct seq_file *m, bool in_stop) 808 { 809 struct bpf_iter__ksym ctx; 810 struct bpf_iter_meta meta; 811 struct bpf_prog *prog; 812 813 meta.seq = m; 814 prog = bpf_iter_get_info(&meta, in_stop); 815 if (!prog) 816 return 0; 817 818 ctx.meta = &meta; 819 ctx.ksym = m ? m->private : NULL; 820 return bpf_iter_run_prog(prog, &ctx); 821 } 822 823 static int bpf_iter_ksym_seq_show(struct seq_file *m, void *p) 824 { 825 return ksym_prog_seq_show(m, false); 826 } 827 828 static void bpf_iter_ksym_seq_stop(struct seq_file *m, void *p) 829 { 830 if (!p) 831 (void) ksym_prog_seq_show(m, true); 832 else 833 s_stop(m, p); 834 } 835 836 static const struct seq_operations bpf_iter_ksym_ops = { 837 .start = s_start, 838 .next = s_next, 839 .stop = bpf_iter_ksym_seq_stop, 840 .show = bpf_iter_ksym_seq_show, 841 }; 842 843 static int bpf_iter_ksym_init(void *priv_data, struct bpf_iter_aux_info *aux) 844 { 845 struct kallsym_iter *iter = priv_data; 846 847 reset_iter(iter, 0); 848 849 /* cache here as in kallsyms_open() case; use current process 850 * credentials to tell BPF iterators if values should be shown. 851 */ 852 iter->show_value = kallsyms_show_value(current_cred()); 853 854 return 0; 855 } 856 857 DEFINE_BPF_ITER_FUNC(ksym, struct bpf_iter_meta *meta, struct kallsym_iter *ksym) 858 859 static const struct bpf_iter_seq_info ksym_iter_seq_info = { 860 .seq_ops = &bpf_iter_ksym_ops, 861 .init_seq_private = bpf_iter_ksym_init, 862 .fini_seq_private = NULL, 863 .seq_priv_size = sizeof(struct kallsym_iter), 864 }; 865 866 static struct bpf_iter_reg ksym_iter_reg_info = { 867 .target = "ksym", 868 .feature = BPF_ITER_RESCHED, 869 .ctx_arg_info_size = 1, 870 .ctx_arg_info = { 871 { offsetof(struct bpf_iter__ksym, ksym), 872 PTR_TO_BTF_ID_OR_NULL }, 873 }, 874 .seq_info = &ksym_iter_seq_info, 875 }; 876 877 BTF_ID_LIST(btf_ksym_iter_id) 878 BTF_ID(struct, kallsym_iter) 879 880 static int __init bpf_ksym_iter_register(void) 881 { 882 ksym_iter_reg_info.ctx_arg_info[0].btf_id = *btf_ksym_iter_id; 883 return bpf_iter_reg_target(&ksym_iter_reg_info); 884 } 885 886 late_initcall(bpf_ksym_iter_register); 887 888 #endif /* CONFIG_BPF_SYSCALL */ 889 890 static inline int kallsyms_for_perf(void) 891 { 892 #ifdef CONFIG_PERF_EVENTS 893 extern int sysctl_perf_event_paranoid; 894 if (sysctl_perf_event_paranoid <= 1) 895 return 1; 896 #endif 897 return 0; 898 } 899 900 /* 901 * We show kallsyms information even to normal users if we've enabled 902 * kernel profiling and are explicitly not paranoid (so kptr_restrict 903 * is clear, and sysctl_perf_event_paranoid isn't set). 904 * 905 * Otherwise, require CAP_SYSLOG (assuming kptr_restrict isn't set to 906 * block even that). 907 */ 908 bool kallsyms_show_value(const struct cred *cred) 909 { 910 switch (kptr_restrict) { 911 case 0: 912 if (kallsyms_for_perf()) 913 return true; 914 fallthrough; 915 case 1: 916 if (security_capable(cred, &init_user_ns, CAP_SYSLOG, 917 CAP_OPT_NOAUDIT) == 0) 918 return true; 919 fallthrough; 920 default: 921 return false; 922 } 923 } 924 925 static int kallsyms_open(struct inode *inode, struct file *file) 926 { 927 /* 928 * We keep iterator in m->private, since normal case is to 929 * s_start from where we left off, so we avoid doing 930 * using get_symbol_offset for every symbol. 931 */ 932 struct kallsym_iter *iter; 933 iter = __seq_open_private(file, &kallsyms_op, sizeof(*iter)); 934 if (!iter) 935 return -ENOMEM; 936 reset_iter(iter, 0); 937 938 /* 939 * Instead of checking this on every s_show() call, cache 940 * the result here at open time. 941 */ 942 iter->show_value = kallsyms_show_value(file->f_cred); 943 return 0; 944 } 945 946 #ifdef CONFIG_KGDB_KDB 947 const char *kdb_walk_kallsyms(loff_t *pos) 948 { 949 static struct kallsym_iter kdb_walk_kallsyms_iter; 950 if (*pos == 0) { 951 memset(&kdb_walk_kallsyms_iter, 0, 952 sizeof(kdb_walk_kallsyms_iter)); 953 reset_iter(&kdb_walk_kallsyms_iter, 0); 954 } 955 while (1) { 956 if (!update_iter(&kdb_walk_kallsyms_iter, *pos)) 957 return NULL; 958 ++*pos; 959 /* Some debugging symbols have no name. Ignore them. */ 960 if (kdb_walk_kallsyms_iter.name[0]) 961 return kdb_walk_kallsyms_iter.name; 962 } 963 } 964 #endif /* CONFIG_KGDB_KDB */ 965 966 static const struct proc_ops kallsyms_proc_ops = { 967 .proc_open = kallsyms_open, 968 .proc_read = seq_read, 969 .proc_lseek = seq_lseek, 970 .proc_release = seq_release_private, 971 }; 972 973 static int __init kallsyms_init(void) 974 { 975 proc_create("kallsyms", 0444, NULL, &kallsyms_proc_ops); 976 return 0; 977 } 978 device_initcall(kallsyms_init); 979