1 /* $NetBSD: kern_ksyms.c,v 1.88 2020/01/05 21:12:34 pgoyette Exp $ */ 2 3 /*- 4 * Copyright (c) 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software developed for The NetBSD Foundation 8 * by Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Copyright (c) 2001, 2003 Anders Magnusson (ragge@ludd.luth.se). 34 * All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 1. Redistributions of source code must retain the above copyright 40 * notice, this list of conditions and the following disclaimer. 41 * 2. Redistributions in binary form must reproduce the above copyright 42 * notice, this list of conditions and the following disclaimer in the 43 * documentation and/or other materials provided with the distribution. 44 * 3. The name of the author may not be used to endorse or promote products 45 * derived from this software without specific prior written permission 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 50 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 51 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 52 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 53 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 54 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 55 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 56 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 57 */ 58 59 /* 60 * Code to deal with in-kernel symbol table management + /dev/ksyms. 61 * 62 * For each loaded module the symbol table info is kept track of by a 63 * struct, placed in a circular list. The first entry is the kernel 64 * symbol table. 65 */ 66 67 /* 68 * TODO: 69 * 70 * Add support for mmap, poll. 71 * Constify tables. 72 * Constify db_symtab and move it to .rodata. 73 */ 74 75 #include <sys/cdefs.h> 76 __KERNEL_RCSID(0, "$NetBSD: kern_ksyms.c,v 1.88 2020/01/05 21:12:34 pgoyette Exp $"); 77 78 #if defined(_KERNEL) && defined(_KERNEL_OPT) 79 #include "opt_copy_symtab.h" 80 #include "opt_ddb.h" 81 #include "opt_dtrace.h" 82 #endif 83 84 #define _KSYMS_PRIVATE 85 86 #include <sys/param.h> 87 #include <sys/queue.h> 88 #include <sys/exec.h> 89 #include <sys/systm.h> 90 #include <sys/conf.h> 91 #include <sys/kmem.h> 92 #include <sys/proc.h> 93 #include <sys/atomic.h> 94 #include <sys/ksyms.h> 95 96 #ifdef DDB 97 #include <ddb/db_output.h> 98 #endif 99 100 #include "ksyms.h" 101 #if NKSYMS > 0 102 #include "ioconf.h" 103 #endif 104 105 #define KSYMS_MAX_ID 98304 106 #ifdef KDTRACE_HOOKS 107 static uint32_t ksyms_nmap[KSYMS_MAX_ID]; /* sorted symbol table map */ 108 #else 109 static uint32_t *ksyms_nmap = NULL; 110 #endif 111 112 static int ksyms_maxlen; 113 static bool ksyms_isopen; 114 static bool ksyms_initted; 115 static bool ksyms_loaded; 116 static kmutex_t ksyms_lock __cacheline_aligned; 117 static struct ksyms_symtab kernel_symtab; 118 119 static void ksyms_hdr_init(const void *); 120 static void ksyms_sizes_calc(void); 121 122 #ifdef KSYMS_DEBUG 123 #define FOLLOW_CALLS 1 124 #define FOLLOW_MORE_CALLS 2 125 #define FOLLOW_DEVKSYMS 4 126 static int ksyms_debug; 127 #endif 128 129 #define SYMTAB_FILLER "|This is the symbol table!" 130 131 #ifdef makeoptions_COPY_SYMTAB 132 extern char db_symtab[]; 133 extern int db_symtabsize; 134 #endif 135 136 /* 137 * used by savecore(8) so non-static 138 */ 139 struct ksyms_hdr ksyms_hdr; 140 int ksyms_symsz; 141 int ksyms_strsz; 142 int ksyms_ctfsz; /* this is not currently used by savecore(8) */ 143 TAILQ_HEAD(, ksyms_symtab) ksyms_symtabs = 144 TAILQ_HEAD_INITIALIZER(ksyms_symtabs); 145 146 static int 147 ksyms_verify(const void *symstart, const void *strstart) 148 { 149 #if defined(DIAGNOSTIC) || defined(DEBUG) 150 if (symstart == NULL) 151 printf("ksyms: Symbol table not found\n"); 152 if (strstart == NULL) 153 printf("ksyms: String table not found\n"); 154 if (symstart == NULL || strstart == NULL) 155 printf("ksyms: Perhaps the kernel is stripped?\n"); 156 #endif 157 if (symstart == NULL || strstart == NULL) 158 return 0; 159 return 1; 160 } 161 162 /* 163 * Finds a certain symbol name in a certain symbol table. 164 */ 165 static Elf_Sym * 166 findsym(const char *name, struct ksyms_symtab *table, int type) 167 { 168 Elf_Sym *sym, *maxsym; 169 int low, mid, high, nglob; 170 char *str, *cmp; 171 172 sym = table->sd_symstart; 173 str = table->sd_strstart - table->sd_usroffset; 174 nglob = table->sd_nglob; 175 low = 0; 176 high = nglob; 177 178 /* 179 * Start with a binary search of all global symbols in this table. 180 * Global symbols must have unique names. 181 */ 182 while (low < high) { 183 mid = (low + high) >> 1; 184 cmp = sym[mid].st_name + str; 185 if (cmp[0] < name[0] || strcmp(cmp, name) < 0) { 186 low = mid + 1; 187 } else { 188 high = mid; 189 } 190 } 191 KASSERT(low == high); 192 if (__predict_true(low < nglob && 193 strcmp(sym[low].st_name + str, name) == 0)) { 194 KASSERT(ELF_ST_BIND(sym[low].st_info) == STB_GLOBAL); 195 return &sym[low]; 196 } 197 198 /* 199 * Perform a linear search of local symbols (rare). Many local 200 * symbols with the same name can exist so are not included in 201 * the binary search. 202 */ 203 if (type != KSYMS_EXTERN) { 204 maxsym = sym + table->sd_symsize / sizeof(Elf_Sym); 205 for (sym += nglob; sym < maxsym; sym++) { 206 if (strcmp(name, sym->st_name + str) == 0) { 207 return sym; 208 } 209 } 210 } 211 return NULL; 212 } 213 214 /* 215 * The "attach" is in reality done in ksyms_init(). 216 */ 217 #if NKSYMS > 0 218 /* 219 * ksyms can be loaded even if the kernel has a missing "pseudo-device ksyms" 220 * statement because ddb and modules require it. Fixing it properly requires 221 * fixing config to warn about required, but missing preudo-devices. For now, 222 * if we don't have the pseudo-device we don't need the attach function; this 223 * is fine, as it does nothing. 224 */ 225 void 226 ksymsattach(int arg) 227 { 228 } 229 #endif 230 231 void 232 ksyms_init(void) 233 { 234 235 #ifdef makeoptions_COPY_SYMTAB 236 if (!ksyms_loaded && 237 strncmp(db_symtab, SYMTAB_FILLER, sizeof(SYMTAB_FILLER))) { 238 ksyms_addsyms_elf(db_symtabsize, db_symtab, 239 db_symtab + db_symtabsize); 240 } 241 #endif 242 243 if (!ksyms_initted) { 244 mutex_init(&ksyms_lock, MUTEX_DEFAULT, IPL_NONE); 245 ksyms_initted = true; 246 } 247 } 248 249 /* 250 * Add a symbol table. 251 * This is intended for use when the symbol table and its corresponding 252 * string table are easily available. If they are embedded in an ELF 253 * image, use addsymtab_elf() instead. 254 * 255 * name - Symbol's table name. 256 * symstart, symsize - Address and size of the symbol table. 257 * strstart, strsize - Address and size of the string table. 258 * tab - Symbol table to be updated with this information. 259 * newstart - Address to which the symbol table has to be copied during 260 * shrinking. If NULL, it is not moved. 261 */ 262 static const char *addsymtab_strstart; 263 264 static int 265 addsymtab_compar(const void *a, const void *b) 266 { 267 const Elf_Sym *sa, *sb; 268 269 sa = a; 270 sb = b; 271 272 /* 273 * Split the symbol table into two, with globals at the start 274 * and locals at the end. 275 */ 276 if (ELF_ST_BIND(sa->st_info) != ELF_ST_BIND(sb->st_info)) { 277 if (ELF_ST_BIND(sa->st_info) == STB_GLOBAL) { 278 return -1; 279 } 280 if (ELF_ST_BIND(sb->st_info) == STB_GLOBAL) { 281 return 1; 282 } 283 } 284 285 /* Within each band, sort by name. */ 286 return strcmp(sa->st_name + addsymtab_strstart, 287 sb->st_name + addsymtab_strstart); 288 } 289 290 static void 291 addsymtab(const char *name, void *symstart, size_t symsize, 292 void *strstart, size_t strsize, struct ksyms_symtab *tab, 293 void *newstart, void *ctfstart, size_t ctfsize, uint32_t *nmap) 294 { 295 Elf_Sym *sym, *nsym, ts; 296 int i, j, n, nglob; 297 char *str; 298 int nsyms = symsize / sizeof(Elf_Sym); 299 300 /* Sanity check for pre-allocated map table used during startup. */ 301 if ((nmap == ksyms_nmap) && (nsyms >= KSYMS_MAX_ID)) { 302 printf("kern_ksyms: ERROR %d > %d, increase KSYMS_MAX_ID\n", 303 nsyms, KSYMS_MAX_ID); 304 305 /* truncate for now */ 306 nsyms = KSYMS_MAX_ID - 1; 307 } 308 309 tab->sd_symstart = symstart; 310 tab->sd_symsize = symsize; 311 tab->sd_strstart = strstart; 312 tab->sd_strsize = strsize; 313 tab->sd_name = name; 314 tab->sd_minsym = UINTPTR_MAX; 315 tab->sd_maxsym = 0; 316 tab->sd_usroffset = 0; 317 tab->sd_gone = false; 318 tab->sd_ctfstart = ctfstart; 319 tab->sd_ctfsize = ctfsize; 320 tab->sd_nmap = nmap; 321 tab->sd_nmapsize = nsyms; 322 #ifdef KSYMS_DEBUG 323 printf("newstart %p sym %p ksyms_symsz %zu str %p strsz %zu send %p\n", 324 newstart, symstart, symsize, strstart, strsize, 325 tab->sd_strstart + tab->sd_strsize); 326 #endif 327 328 if (nmap) { 329 memset(nmap, 0, nsyms * sizeof(uint32_t)); 330 } 331 332 /* Pack symbol table by removing all file name references. */ 333 sym = tab->sd_symstart; 334 nsym = (Elf_Sym *)newstart; 335 str = tab->sd_strstart; 336 nglob = 0; 337 for (i = n = 0; i < nsyms; i++) { 338 339 /* 340 * This breaks CTF mapping, so don't do it when 341 * DTrace is enabled. 342 */ 343 #ifndef KDTRACE_HOOKS 344 /* 345 * Remove useless symbols. 346 * Should actually remove all typeless symbols. 347 */ 348 if (sym[i].st_name == 0) 349 continue; /* Skip nameless entries */ 350 if (sym[i].st_shndx == SHN_UNDEF) 351 continue; /* Skip external references */ 352 if (ELF_ST_TYPE(sym[i].st_info) == STT_FILE) 353 continue; /* Skip filenames */ 354 if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE && 355 sym[i].st_value == 0 && 356 strcmp(str + sym[i].st_name, "*ABS*") == 0) 357 continue; /* XXX */ 358 if (ELF_ST_TYPE(sym[i].st_info) == STT_NOTYPE && 359 strcmp(str + sym[i].st_name, "gcc2_compiled.") == 0) 360 continue; /* XXX */ 361 #endif 362 363 /* Save symbol. Set it as an absolute offset */ 364 nsym[n] = sym[i]; 365 366 #ifdef KDTRACE_HOOKS 367 if (nmap != NULL) { 368 /* 369 * Save the size, replace it with the symbol id so 370 * the mapping can be done after the cleanup and sort. 371 */ 372 nmap[i] = nsym[n].st_size; 373 nsym[n].st_size = i + 1; /* zero is reserved */ 374 } 375 #endif 376 377 if (sym[i].st_shndx != SHN_ABS) { 378 nsym[n].st_shndx = SHBSS; 379 } else { 380 /* SHN_ABS is a magic value, don't overwrite it */ 381 } 382 383 j = strlen(nsym[n].st_name + str) + 1; 384 if (j > ksyms_maxlen) 385 ksyms_maxlen = j; 386 nglob += (ELF_ST_BIND(nsym[n].st_info) == STB_GLOBAL); 387 388 /* Compute min and max symbols. */ 389 if (strcmp(str + sym[i].st_name, "*ABS*") != 0 390 && ELF_ST_TYPE(nsym[n].st_info) != STT_NOTYPE) { 391 if (nsym[n].st_value < tab->sd_minsym) { 392 tab->sd_minsym = nsym[n].st_value; 393 } 394 if (nsym[n].st_value > tab->sd_maxsym) { 395 tab->sd_maxsym = nsym[n].st_value; 396 } 397 } 398 n++; 399 } 400 401 /* Fill the rest of the record, and sort the symbols. */ 402 tab->sd_symstart = nsym; 403 tab->sd_symsize = n * sizeof(Elf_Sym); 404 tab->sd_nglob = nglob; 405 406 addsymtab_strstart = str; 407 if (kheapsort(nsym, n, sizeof(Elf_Sym), addsymtab_compar, &ts) != 0) 408 panic("addsymtab"); 409 410 #ifdef KDTRACE_HOOKS 411 /* 412 * Build the mapping from original symbol id to new symbol table. 413 * Deleted symbols will have a zero map, indices will be one based 414 * instead of zero based. 415 * Resulting map is sd_nmap[original_index] = new_index + 1 416 */ 417 if (nmap != NULL) { 418 int new; 419 for (new = 0; new < n; new++) { 420 uint32_t orig = nsym[new].st_size - 1; 421 uint32_t size = nmap[orig]; 422 423 nmap[orig] = new + 1; 424 425 /* restore the size */ 426 nsym[new].st_size = size; 427 } 428 } 429 #endif 430 431 /* ksymsread() is unlocked, so membar. */ 432 membar_producer(); 433 TAILQ_INSERT_TAIL(&ksyms_symtabs, tab, sd_queue); 434 ksyms_sizes_calc(); 435 ksyms_loaded = true; 436 } 437 438 /* 439 * Setup the kernel symbol table stuff. 440 */ 441 void 442 ksyms_addsyms_elf(int symsize, void *start, void *end) 443 { 444 int i, j; 445 Elf_Shdr *shdr; 446 char *symstart = NULL, *strstart = NULL; 447 size_t strsize = 0; 448 Elf_Ehdr *ehdr; 449 char *ctfstart = NULL; 450 size_t ctfsize = 0; 451 452 if (symsize <= 0) { 453 printf("[ Kernel symbol table missing! ]\n"); 454 return; 455 } 456 457 /* Sanity check */ 458 if (ALIGNED_POINTER(start, long) == 0) { 459 printf("[ Kernel symbol table has bad start address %p ]\n", 460 start); 461 return; 462 } 463 464 ehdr = (Elf_Ehdr *)start; 465 466 /* check if this is a valid ELF header */ 467 /* No reason to verify arch type, the kernel is actually running! */ 468 if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) || 469 ehdr->e_ident[EI_CLASS] != ELFCLASS || 470 ehdr->e_version > 1) { 471 printf("[ Kernel symbol table invalid! ]\n"); 472 return; /* nothing to do */ 473 } 474 475 /* Loaded header will be scratched in addsymtab */ 476 ksyms_hdr_init(start); 477 478 /* Find the symbol table and the corresponding string table. */ 479 shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff); 480 for (i = 1; i < ehdr->e_shnum; i++) { 481 if (shdr[i].sh_type != SHT_SYMTAB) 482 continue; 483 if (shdr[i].sh_offset == 0) 484 continue; 485 symstart = (uint8_t *)start + shdr[i].sh_offset; 486 symsize = shdr[i].sh_size; 487 j = shdr[i].sh_link; 488 if (shdr[j].sh_offset == 0) 489 continue; /* Can this happen? */ 490 strstart = (uint8_t *)start + shdr[j].sh_offset; 491 strsize = shdr[j].sh_size; 492 break; 493 } 494 495 #ifdef KDTRACE_HOOKS 496 /* Find the CTF section */ 497 shdr = (Elf_Shdr *)((uint8_t *)start + ehdr->e_shoff); 498 if (ehdr->e_shstrndx != 0) { 499 char *shstr = (uint8_t *)start + 500 shdr[ehdr->e_shstrndx].sh_offset; 501 for (i = 1; i < ehdr->e_shnum; i++) { 502 #ifdef DEBUG 503 printf("ksyms: checking %s\n", &shstr[shdr[i].sh_name]); 504 #endif 505 if (shdr[i].sh_type != SHT_PROGBITS) 506 continue; 507 if (strncmp(".SUNW_ctf", &shstr[shdr[i].sh_name], 10) 508 != 0) 509 continue; 510 ctfstart = (uint8_t *)start + shdr[i].sh_offset; 511 ctfsize = shdr[i].sh_size; 512 ksyms_ctfsz = ctfsize; 513 #ifdef DEBUG 514 aprint_normal("Found CTF at %p, size 0x%zx\n", 515 ctfstart, ctfsize); 516 #endif 517 break; 518 } 519 #ifdef DEBUG 520 } else { 521 printf("ksyms: e_shstrndx == 0\n"); 522 #endif 523 } 524 #endif 525 526 if (!ksyms_verify(symstart, strstart)) 527 return; 528 529 addsymtab("netbsd", symstart, symsize, strstart, strsize, 530 &kernel_symtab, symstart, ctfstart, ctfsize, ksyms_nmap); 531 532 #ifdef DEBUG 533 aprint_normal("Loaded initial symtab at %p, strtab at %p, # entries %ld\n", 534 kernel_symtab.sd_symstart, kernel_symtab.sd_strstart, 535 (long)kernel_symtab.sd_symsize/sizeof(Elf_Sym)); 536 #endif 537 } 538 539 /* 540 * Setup the kernel symbol table stuff. 541 * Use this when the address of the symbol and string tables are known; 542 * otherwise use ksyms_init with an ELF image. 543 * We need to pass a minimal ELF header which will later be completed by 544 * ksyms_hdr_init and handed off to userland through /dev/ksyms. We use 545 * a void *rather than a pointer to avoid exposing the Elf_Ehdr type. 546 */ 547 void 548 ksyms_addsyms_explicit(void *ehdr, void *symstart, size_t symsize, 549 void *strstart, size_t strsize) 550 { 551 if (!ksyms_verify(symstart, strstart)) 552 return; 553 554 ksyms_hdr_init(ehdr); 555 addsymtab("netbsd", symstart, symsize, strstart, strsize, 556 &kernel_symtab, symstart, NULL, 0, ksyms_nmap); 557 } 558 559 /* 560 * Get the value associated with a symbol. 561 * "mod" is the module name, or null if any module. 562 * "sym" is the symbol name. 563 * "val" is a pointer to the corresponding value, if call succeeded. 564 * Returns 0 if success or ENOENT if no such entry. 565 * 566 * Call with ksyms_lock, unless known that the symbol table can't change. 567 */ 568 int 569 ksyms_getval_unlocked(const char *mod, const char *sym, Elf_Sym **symp, 570 unsigned long *val, int type) 571 { 572 struct ksyms_symtab *st; 573 Elf_Sym *es; 574 575 #ifdef KSYMS_DEBUG 576 if (ksyms_debug & FOLLOW_CALLS) 577 printf("%s: mod %s sym %s valp %p\n", __func__, mod, sym, val); 578 #endif 579 580 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 581 if (__predict_false(st->sd_gone)) 582 continue; 583 if (mod != NULL && strcmp(st->sd_name, mod)) 584 continue; 585 if ((es = findsym(sym, st, type)) != NULL) { 586 *val = es->st_value; 587 if (symp) 588 *symp = es; 589 return 0; 590 } 591 } 592 return ENOENT; 593 } 594 595 int 596 ksyms_getval(const char *mod, const char *sym, unsigned long *val, int type) 597 { 598 int rc; 599 600 if (!ksyms_loaded) 601 return ENOENT; 602 603 mutex_enter(&ksyms_lock); 604 rc = ksyms_getval_unlocked(mod, sym, NULL, val, type); 605 mutex_exit(&ksyms_lock); 606 return rc; 607 } 608 609 struct ksyms_symtab * 610 ksyms_get_mod(const char *mod) 611 { 612 struct ksyms_symtab *st; 613 614 mutex_enter(&ksyms_lock); 615 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 616 if (__predict_false(st->sd_gone)) 617 continue; 618 if (mod != NULL && strcmp(st->sd_name, mod)) 619 continue; 620 break; 621 } 622 mutex_exit(&ksyms_lock); 623 624 return st; 625 } 626 627 628 /* 629 * ksyms_mod_foreach() 630 * 631 * Iterate over the symbol table of the specified module, calling the callback 632 * handler for each symbol. Stop iterating if the handler return is non-zero. 633 * 634 */ 635 636 int 637 ksyms_mod_foreach(const char *mod, ksyms_callback_t callback, void *opaque) 638 { 639 struct ksyms_symtab *st; 640 Elf_Sym *sym, *maxsym; 641 char *str; 642 int symindx; 643 644 if (!ksyms_loaded) 645 return ENOENT; 646 647 mutex_enter(&ksyms_lock); 648 649 /* find the module */ 650 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 651 if (__predict_false(st->sd_gone)) 652 continue; 653 if (mod != NULL && strcmp(st->sd_name, mod)) 654 continue; 655 656 sym = st->sd_symstart; 657 str = st->sd_strstart - st->sd_usroffset; 658 659 /* now iterate through the symbols */ 660 maxsym = sym + st->sd_symsize / sizeof(Elf_Sym); 661 for (symindx = 0; sym < maxsym; sym++, symindx++) { 662 if (callback(str + sym->st_name, symindx, 663 (void *)sym->st_value, 664 sym->st_size, 665 sym->st_info, 666 opaque) != 0) { 667 break; 668 } 669 } 670 } 671 mutex_exit(&ksyms_lock); 672 673 return 0; 674 } 675 676 /* 677 * Get "mod" and "symbol" associated with an address. 678 * Returns 0 if success or ENOENT if no such entry. 679 * 680 * Call with ksyms_lock, unless known that the symbol table can't change. 681 */ 682 int 683 ksyms_getname(const char **mod, const char **sym, vaddr_t v, int f) 684 { 685 struct ksyms_symtab *st; 686 Elf_Sym *les, *es = NULL; 687 vaddr_t laddr = 0; 688 const char *lmod = NULL; 689 char *stable = NULL; 690 int type, i, sz; 691 692 if (!ksyms_loaded) 693 return ENOENT; 694 695 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 696 if (st->sd_gone) 697 continue; 698 if (v < st->sd_minsym || v > st->sd_maxsym) 699 continue; 700 sz = st->sd_symsize/sizeof(Elf_Sym); 701 for (i = 0; i < sz; i++) { 702 les = st->sd_symstart + i; 703 type = ELF_ST_TYPE(les->st_info); 704 705 if ((f & KSYMS_PROC) && (type != STT_FUNC)) 706 continue; 707 708 if (type == STT_NOTYPE) 709 continue; 710 711 if (((f & KSYMS_ANY) == 0) && 712 (type != STT_FUNC) && (type != STT_OBJECT)) 713 continue; 714 715 if ((les->st_value <= v) && (les->st_value > laddr)) { 716 laddr = les->st_value; 717 es = les; 718 lmod = st->sd_name; 719 stable = st->sd_strstart - st->sd_usroffset; 720 } 721 } 722 } 723 if (es == NULL) 724 return ENOENT; 725 if ((f & KSYMS_EXACT) && (v != es->st_value)) 726 return ENOENT; 727 if (mod) 728 *mod = lmod; 729 if (sym) 730 *sym = stable + es->st_name; 731 return 0; 732 } 733 734 /* 735 * Add a symbol table from a loadable module. 736 */ 737 void 738 ksyms_modload(const char *name, void *symstart, vsize_t symsize, 739 char *strstart, vsize_t strsize) 740 { 741 struct ksyms_symtab *st; 742 void *nmap; 743 744 st = kmem_zalloc(sizeof(*st), KM_SLEEP); 745 nmap = kmem_zalloc(symsize / sizeof(Elf_Sym) * sizeof (uint32_t), 746 KM_SLEEP); 747 mutex_enter(&ksyms_lock); 748 addsymtab(name, symstart, symsize, strstart, strsize, st, symstart, 749 NULL, 0, nmap); 750 mutex_exit(&ksyms_lock); 751 } 752 753 /* 754 * Remove a symbol table from a loadable module. 755 */ 756 void 757 ksyms_modunload(const char *name) 758 { 759 struct ksyms_symtab *st; 760 761 mutex_enter(&ksyms_lock); 762 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 763 if (st->sd_gone) 764 continue; 765 if (strcmp(name, st->sd_name) != 0) 766 continue; 767 st->sd_gone = true; 768 ksyms_sizes_calc(); 769 if (!ksyms_isopen) { 770 TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue); 771 kmem_free(st->sd_nmap, 772 st->sd_nmapsize * sizeof(uint32_t)); 773 kmem_free(st, sizeof(*st)); 774 } 775 break; 776 } 777 mutex_exit(&ksyms_lock); 778 KASSERT(st != NULL); 779 } 780 781 #ifdef DDB 782 /* 783 * Keep sifting stuff here, to avoid export of ksyms internals. 784 * 785 * Systems is expected to be quiescent, so no locking done. 786 */ 787 int 788 ksyms_sift(char *mod, char *sym, int mode) 789 { 790 struct ksyms_symtab *st; 791 char *sb; 792 int i, sz; 793 794 if (!ksyms_loaded) 795 return ENOENT; 796 797 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 798 if (st->sd_gone) 799 continue; 800 if (mod && strcmp(mod, st->sd_name)) 801 continue; 802 sb = st->sd_strstart - st->sd_usroffset; 803 804 sz = st->sd_symsize/sizeof(Elf_Sym); 805 for (i = 0; i < sz; i++) { 806 Elf_Sym *les = st->sd_symstart + i; 807 char c; 808 809 if (strstr(sb + les->st_name, sym) == NULL) 810 continue; 811 812 if (mode == 'F') { 813 switch (ELF_ST_TYPE(les->st_info)) { 814 case STT_OBJECT: 815 c = '+'; 816 break; 817 case STT_FUNC: 818 c = '*'; 819 break; 820 case STT_SECTION: 821 c = '&'; 822 break; 823 case STT_FILE: 824 c = '/'; 825 break; 826 default: 827 c = ' '; 828 break; 829 } 830 db_printf("%s%c ", sb + les->st_name, c); 831 } else 832 db_printf("%s ", sb + les->st_name); 833 } 834 } 835 return ENOENT; 836 } 837 #endif /* DDB */ 838 839 /* 840 * In case we exposing the symbol table to the userland using the pseudo- 841 * device /dev/ksyms, it is easier to provide all the tables as one. 842 * However, it means we have to change all the st_name fields for the 843 * symbols so they match the ELF image that the userland will read 844 * through the device. 845 * 846 * The actual (correct) value of st_name is preserved through a global 847 * offset stored in the symbol table structure. 848 * 849 * Call with ksyms_lock held. 850 */ 851 static void 852 ksyms_sizes_calc(void) 853 { 854 struct ksyms_symtab *st; 855 int i, delta; 856 857 ksyms_symsz = ksyms_strsz = 0; 858 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 859 if (__predict_false(st->sd_gone)) 860 continue; 861 delta = ksyms_strsz - st->sd_usroffset; 862 if (delta != 0) { 863 for (i = 0; i < st->sd_symsize/sizeof(Elf_Sym); i++) 864 st->sd_symstart[i].st_name += delta; 865 st->sd_usroffset = ksyms_strsz; 866 } 867 ksyms_symsz += st->sd_symsize; 868 ksyms_strsz += st->sd_strsize; 869 } 870 } 871 872 static void 873 ksyms_fill_note(void) 874 { 875 int32_t *note = ksyms_hdr.kh_note; 876 note[0] = ELF_NOTE_NETBSD_NAMESZ; 877 note[1] = ELF_NOTE_NETBSD_DESCSZ; 878 note[2] = ELF_NOTE_TYPE_NETBSD_TAG; 879 memcpy(¬e[3], "NetBSD\0", 8); 880 note[5] = __NetBSD_Version__; 881 } 882 883 static void 884 ksyms_hdr_init(const void *hdraddr) 885 { 886 /* Copy the loaded elf exec header */ 887 memcpy(&ksyms_hdr.kh_ehdr, hdraddr, sizeof(Elf_Ehdr)); 888 889 /* Set correct program/section header sizes, offsets and numbers */ 890 ksyms_hdr.kh_ehdr.e_phoff = offsetof(struct ksyms_hdr, kh_phdr[0]); 891 ksyms_hdr.kh_ehdr.e_phentsize = sizeof(Elf_Phdr); 892 ksyms_hdr.kh_ehdr.e_phnum = NPRGHDR; 893 ksyms_hdr.kh_ehdr.e_shoff = offsetof(struct ksyms_hdr, kh_shdr[0]); 894 ksyms_hdr.kh_ehdr.e_shentsize = sizeof(Elf_Shdr); 895 ksyms_hdr.kh_ehdr.e_shnum = NSECHDR; 896 ksyms_hdr.kh_ehdr.e_shstrndx = SHSTRTAB; 897 898 /* Text/data - fake */ 899 ksyms_hdr.kh_phdr[0].p_type = PT_LOAD; 900 ksyms_hdr.kh_phdr[0].p_memsz = (unsigned long)-1L; 901 ksyms_hdr.kh_phdr[0].p_flags = PF_R | PF_X | PF_W; 902 903 #define SHTCOPY(name) strlcpy(&ksyms_hdr.kh_strtab[offs], (name), \ 904 sizeof(ksyms_hdr.kh_strtab) - offs), offs += sizeof(name) 905 906 uint32_t offs = 1; 907 /* First section header ".note.netbsd.ident" */ 908 ksyms_hdr.kh_shdr[SHNOTE].sh_name = offs; 909 ksyms_hdr.kh_shdr[SHNOTE].sh_type = SHT_NOTE; 910 ksyms_hdr.kh_shdr[SHNOTE].sh_offset = 911 offsetof(struct ksyms_hdr, kh_note[0]); 912 ksyms_hdr.kh_shdr[SHNOTE].sh_size = sizeof(ksyms_hdr.kh_note); 913 ksyms_hdr.kh_shdr[SHNOTE].sh_addralign = sizeof(int); 914 SHTCOPY(".note.netbsd.ident"); 915 ksyms_fill_note(); 916 917 /* Second section header; ".symtab" */ 918 ksyms_hdr.kh_shdr[SYMTAB].sh_name = offs; 919 ksyms_hdr.kh_shdr[SYMTAB].sh_type = SHT_SYMTAB; 920 ksyms_hdr.kh_shdr[SYMTAB].sh_offset = sizeof(struct ksyms_hdr); 921 /* ksyms_hdr.kh_shdr[SYMTAB].sh_size = filled in at open */ 922 ksyms_hdr.kh_shdr[SYMTAB].sh_link = STRTAB; /* Corresponding strtab */ 923 ksyms_hdr.kh_shdr[SYMTAB].sh_addralign = sizeof(long); 924 ksyms_hdr.kh_shdr[SYMTAB].sh_entsize = sizeof(Elf_Sym); 925 SHTCOPY(".symtab"); 926 927 /* Third section header; ".strtab" */ 928 ksyms_hdr.kh_shdr[STRTAB].sh_name = offs; 929 ksyms_hdr.kh_shdr[STRTAB].sh_type = SHT_STRTAB; 930 /* ksyms_hdr.kh_shdr[STRTAB].sh_offset = filled in at open */ 931 /* ksyms_hdr.kh_shdr[STRTAB].sh_size = filled in at open */ 932 ksyms_hdr.kh_shdr[STRTAB].sh_addralign = sizeof(char); 933 SHTCOPY(".strtab"); 934 935 /* Fourth section, ".shstrtab" */ 936 ksyms_hdr.kh_shdr[SHSTRTAB].sh_name = offs; 937 ksyms_hdr.kh_shdr[SHSTRTAB].sh_type = SHT_STRTAB; 938 ksyms_hdr.kh_shdr[SHSTRTAB].sh_offset = 939 offsetof(struct ksyms_hdr, kh_strtab); 940 ksyms_hdr.kh_shdr[SHSTRTAB].sh_size = SHSTRSIZ; 941 ksyms_hdr.kh_shdr[SHSTRTAB].sh_addralign = sizeof(char); 942 SHTCOPY(".shstrtab"); 943 944 /* Fifth section, ".bss". All symbols reside here. */ 945 ksyms_hdr.kh_shdr[SHBSS].sh_name = offs; 946 ksyms_hdr.kh_shdr[SHBSS].sh_type = SHT_NOBITS; 947 ksyms_hdr.kh_shdr[SHBSS].sh_offset = 0; 948 ksyms_hdr.kh_shdr[SHBSS].sh_size = (unsigned long)-1L; 949 ksyms_hdr.kh_shdr[SHBSS].sh_addralign = PAGE_SIZE; 950 ksyms_hdr.kh_shdr[SHBSS].sh_flags = SHF_ALLOC | SHF_EXECINSTR; 951 SHTCOPY(".bss"); 952 953 /* Sixth section header; ".SUNW_ctf" */ 954 ksyms_hdr.kh_shdr[SHCTF].sh_name = offs; 955 ksyms_hdr.kh_shdr[SHCTF].sh_type = SHT_PROGBITS; 956 /* ksyms_hdr.kh_shdr[SHCTF].sh_offset = filled in at open */ 957 /* ksyms_hdr.kh_shdr[SHCTF].sh_size = filled in at open */ 958 ksyms_hdr.kh_shdr[SHCTF].sh_link = SYMTAB; /* Corresponding symtab */ 959 ksyms_hdr.kh_shdr[SHCTF].sh_addralign = sizeof(char); 960 SHTCOPY(".SUNW_ctf"); 961 } 962 963 static int 964 ksymsopen(dev_t dev, int oflags, int devtype, struct lwp *l) 965 { 966 if (minor(dev) != 0 || !ksyms_loaded) 967 return ENXIO; 968 969 /* 970 * Create a "snapshot" of the kernel symbol table. Setting 971 * ksyms_isopen will prevent symbol tables from being freed. 972 */ 973 mutex_enter(&ksyms_lock); 974 ksyms_hdr.kh_shdr[SYMTAB].sh_size = ksyms_symsz; 975 ksyms_hdr.kh_shdr[SYMTAB].sh_info = ksyms_symsz / sizeof(Elf_Sym); 976 ksyms_hdr.kh_shdr[STRTAB].sh_offset = ksyms_symsz + 977 ksyms_hdr.kh_shdr[SYMTAB].sh_offset; 978 ksyms_hdr.kh_shdr[STRTAB].sh_size = ksyms_strsz; 979 ksyms_hdr.kh_shdr[SHCTF].sh_offset = ksyms_strsz + 980 ksyms_hdr.kh_shdr[STRTAB].sh_offset; 981 ksyms_hdr.kh_shdr[SHCTF].sh_size = ksyms_ctfsz; 982 ksyms_isopen = true; 983 mutex_exit(&ksyms_lock); 984 985 return 0; 986 } 987 988 static int 989 ksymsclose(dev_t dev, int oflags, int devtype, struct lwp *l) 990 { 991 struct ksyms_symtab *st, *next; 992 bool resize; 993 994 /* Discard references to symbol tables. */ 995 mutex_enter(&ksyms_lock); 996 ksyms_isopen = false; 997 resize = false; 998 for (st = TAILQ_FIRST(&ksyms_symtabs); st != NULL; st = next) { 999 next = TAILQ_NEXT(st, sd_queue); 1000 if (st->sd_gone) { 1001 TAILQ_REMOVE(&ksyms_symtabs, st, sd_queue); 1002 kmem_free(st->sd_nmap, 1003 st->sd_nmapsize * sizeof(uint32_t)); 1004 kmem_free(st, sizeof(*st)); 1005 resize = true; 1006 } 1007 } 1008 if (resize) 1009 ksyms_sizes_calc(); 1010 mutex_exit(&ksyms_lock); 1011 1012 return 0; 1013 } 1014 1015 static int 1016 ksymsread(dev_t dev, struct uio *uio, int ioflag) 1017 { 1018 struct ksyms_symtab *st; 1019 size_t filepos, inpos, off; 1020 int error; 1021 1022 /* 1023 * First: Copy out the ELF header. XXX Lose if ksymsopen() 1024 * occurs during read of the header. 1025 */ 1026 off = uio->uio_offset; 1027 if (off < sizeof(struct ksyms_hdr)) { 1028 error = uiomove((char *)&ksyms_hdr + off, 1029 sizeof(struct ksyms_hdr) - off, uio); 1030 if (error != 0) 1031 return error; 1032 } 1033 1034 /* 1035 * Copy out the symbol table. 1036 */ 1037 filepos = sizeof(struct ksyms_hdr); 1038 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 1039 if (__predict_false(st->sd_gone)) 1040 continue; 1041 if (uio->uio_resid == 0) 1042 return 0; 1043 if (uio->uio_offset <= st->sd_symsize + filepos) { 1044 inpos = uio->uio_offset - filepos; 1045 error = uiomove((char *)st->sd_symstart + inpos, 1046 st->sd_symsize - inpos, uio); 1047 if (error != 0) 1048 return error; 1049 } 1050 filepos += st->sd_symsize; 1051 } 1052 1053 /* 1054 * Copy out the string table 1055 */ 1056 KASSERT(filepos == sizeof(struct ksyms_hdr) + 1057 ksyms_hdr.kh_shdr[SYMTAB].sh_size); 1058 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 1059 if (__predict_false(st->sd_gone)) 1060 continue; 1061 if (uio->uio_resid == 0) 1062 return 0; 1063 if (uio->uio_offset <= st->sd_strsize + filepos) { 1064 inpos = uio->uio_offset - filepos; 1065 error = uiomove((char *)st->sd_strstart + inpos, 1066 st->sd_strsize - inpos, uio); 1067 if (error != 0) 1068 return error; 1069 } 1070 filepos += st->sd_strsize; 1071 } 1072 1073 /* 1074 * Copy out the CTF table. 1075 */ 1076 st = TAILQ_FIRST(&ksyms_symtabs); 1077 if (st->sd_ctfstart != NULL) { 1078 if (uio->uio_resid == 0) 1079 return 0; 1080 if (uio->uio_offset <= st->sd_ctfsize + filepos) { 1081 inpos = uio->uio_offset - filepos; 1082 error = uiomove((char *)st->sd_ctfstart + inpos, 1083 st->sd_ctfsize - inpos, uio); 1084 if (error != 0) 1085 return error; 1086 } 1087 filepos += st->sd_ctfsize; 1088 } 1089 1090 return 0; 1091 } 1092 1093 static int 1094 ksymswrite(dev_t dev, struct uio *uio, int ioflag) 1095 { 1096 return EROFS; 1097 } 1098 1099 __CTASSERT(offsetof(struct ksyms_ogsymbol, kg_name) == offsetof(struct ksyms_gsymbol, kg_name)); 1100 __CTASSERT(offsetof(struct ksyms_gvalue, kv_name) == offsetof(struct ksyms_gsymbol, kg_name)); 1101 1102 static int 1103 ksymsioctl(dev_t dev, u_long cmd, void *data, int fflag, struct lwp *l) 1104 { 1105 struct ksyms_ogsymbol *okg = (struct ksyms_ogsymbol *)data; 1106 struct ksyms_gsymbol *kg = (struct ksyms_gsymbol *)data; 1107 struct ksyms_gvalue *kv = (struct ksyms_gvalue *)data; 1108 struct ksyms_symtab *st; 1109 Elf_Sym *sym = NULL, copy; 1110 unsigned long val; 1111 int error = 0; 1112 char *str = NULL; 1113 int len; 1114 1115 /* Read ksyms_maxlen only once while not holding the lock. */ 1116 len = ksyms_maxlen; 1117 1118 if (cmd == OKIOCGVALUE || cmd == OKIOCGSYMBOL || 1119 cmd == KIOCGVALUE || cmd == KIOCGSYMBOL) { 1120 str = kmem_alloc(len, KM_SLEEP); 1121 if ((error = copyinstr(kg->kg_name, str, len, NULL)) != 0) { 1122 kmem_free(str, len); 1123 return error; 1124 } 1125 } 1126 1127 switch (cmd) { 1128 case OKIOCGVALUE: 1129 /* 1130 * Use the in-kernel symbol lookup code for fast 1131 * retreival of a value. 1132 */ 1133 error = ksyms_getval(NULL, str, &val, KSYMS_EXTERN); 1134 if (error == 0) 1135 error = copyout(&val, okg->kg_value, sizeof(long)); 1136 kmem_free(str, len); 1137 break; 1138 1139 case OKIOCGSYMBOL: 1140 /* 1141 * Use the in-kernel symbol lookup code for fast 1142 * retreival of a symbol. 1143 */ 1144 mutex_enter(&ksyms_lock); 1145 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 1146 if (st->sd_gone) 1147 continue; 1148 if ((sym = findsym(str, st, KSYMS_ANY)) == NULL) 1149 continue; 1150 #ifdef notdef 1151 /* Skip if bad binding */ 1152 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL) { 1153 sym = NULL; 1154 continue; 1155 } 1156 #endif 1157 break; 1158 } 1159 if (sym != NULL) { 1160 memcpy(©, sym, sizeof(copy)); 1161 mutex_exit(&ksyms_lock); 1162 error = copyout(©, okg->kg_sym, sizeof(Elf_Sym)); 1163 } else { 1164 mutex_exit(&ksyms_lock); 1165 error = ENOENT; 1166 } 1167 kmem_free(str, len); 1168 break; 1169 1170 case KIOCGVALUE: 1171 /* 1172 * Use the in-kernel symbol lookup code for fast 1173 * retreival of a value. 1174 */ 1175 error = ksyms_getval(NULL, str, &val, KSYMS_EXTERN); 1176 if (error == 0) 1177 kv->kv_value = val; 1178 kmem_free(str, len); 1179 break; 1180 1181 case KIOCGSYMBOL: 1182 /* 1183 * Use the in-kernel symbol lookup code for fast 1184 * retreival of a symbol. 1185 */ 1186 mutex_enter(&ksyms_lock); 1187 TAILQ_FOREACH(st, &ksyms_symtabs, sd_queue) { 1188 if (st->sd_gone) 1189 continue; 1190 if ((sym = findsym(str, st, KSYMS_ANY)) == NULL) 1191 continue; 1192 #ifdef notdef 1193 /* Skip if bad binding */ 1194 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL) { 1195 sym = NULL; 1196 continue; 1197 } 1198 #endif 1199 break; 1200 } 1201 if (sym != NULL) { 1202 kg->kg_sym = *sym; 1203 } else { 1204 error = ENOENT; 1205 } 1206 mutex_exit(&ksyms_lock); 1207 kmem_free(str, len); 1208 break; 1209 1210 case KIOCGSIZE: 1211 /* 1212 * Get total size of symbol table. 1213 */ 1214 mutex_enter(&ksyms_lock); 1215 *(int *)data = ksyms_strsz + ksyms_symsz + 1216 sizeof(struct ksyms_hdr); 1217 mutex_exit(&ksyms_lock); 1218 break; 1219 1220 default: 1221 error = ENOTTY; 1222 break; 1223 } 1224 1225 return error; 1226 } 1227 1228 const struct cdevsw ksyms_cdevsw = { 1229 .d_open = ksymsopen, 1230 .d_close = ksymsclose, 1231 .d_read = ksymsread, 1232 .d_write = ksymswrite, 1233 .d_ioctl = ksymsioctl, 1234 .d_stop = nullstop, 1235 .d_tty = notty, 1236 .d_poll = nopoll, 1237 .d_mmap = nommap, 1238 .d_kqfilter = nullkqfilter, 1239 .d_discard = nodiscard, 1240 .d_flag = D_OTHER | D_MPSAFE 1241 }; 1242