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