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