1 /* $NetBSD: subr_kobj.c,v 1.69 2021/08/21 23:00:32 andvar 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) 1998-2000 Doug Rabson 34 * Copyright (c) 2004 Peter Wemm 35 * All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 46 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 49 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 56 * SUCH DAMAGE. 57 */ 58 59 /* 60 * Kernel loader for ELF objects. 61 * 62 * TODO: adjust kmem_alloc() calls to avoid needless fragmentation. 63 */ 64 65 #include <sys/cdefs.h> 66 __KERNEL_RCSID(0, "$NetBSD: subr_kobj.c,v 1.69 2021/08/21 23:00:32 andvar Exp $"); 67 68 #ifdef _KERNEL_OPT 69 #include "opt_modular.h" 70 #endif 71 72 #include <sys/kobj_impl.h> 73 74 #ifdef MODULAR 75 76 #include <sys/param.h> 77 #include <sys/kernel.h> 78 #include <sys/kmem.h> 79 #include <sys/proc.h> 80 #include <sys/ksyms.h> 81 #include <sys/module.h> 82 83 #include <uvm/uvm_extern.h> 84 85 #define kobj_error(_kobj, ...) \ 86 kobj_out(__func__, __LINE__, _kobj, __VA_ARGS__) 87 88 static int kobj_relocate(kobj_t, bool); 89 static int kobj_checksyms(kobj_t, bool); 90 static void kobj_out(const char *, int, kobj_t, const char *, ...) 91 __printflike(4, 5); 92 static void kobj_jettison(kobj_t); 93 static void kobj_free(kobj_t, void *, size_t); 94 static void kobj_close(kobj_t); 95 static int kobj_read_mem(kobj_t, void **, size_t, off_t, bool); 96 static void kobj_close_mem(kobj_t); 97 98 extern struct vm_map *module_map; 99 100 /* 101 * kobj_load_mem: 102 * 103 * Load an object already resident in memory. If size is not -1, 104 * the complete size of the object is known. 105 */ 106 int 107 kobj_load_mem(kobj_t *kop, const char *name, void *base, ssize_t size) 108 { 109 kobj_t ko; 110 111 ko = kmem_zalloc(sizeof(*ko), KM_SLEEP); 112 ko->ko_type = KT_MEMORY; 113 kobj_setname(ko, name); 114 ko->ko_source = base; 115 ko->ko_memsize = size; 116 ko->ko_read = kobj_read_mem; 117 ko->ko_close = kobj_close_mem; 118 119 *kop = ko; 120 return kobj_load(ko); 121 } 122 123 /* 124 * kobj_close: 125 * 126 * Close an open ELF object. 127 */ 128 static void 129 kobj_close(kobj_t ko) 130 { 131 132 if (ko->ko_source == NULL) { 133 return; 134 } 135 136 ko->ko_close(ko); 137 ko->ko_source = NULL; 138 } 139 140 static void 141 kobj_close_mem(kobj_t ko) 142 { 143 144 return; 145 } 146 147 /* 148 * kobj_load: 149 * 150 * Load an ELF object and prepare to link into the running kernel 151 * image. 152 */ 153 int 154 kobj_load(kobj_t ko) 155 { 156 Elf_Ehdr *hdr; 157 Elf_Shdr *shdr; 158 Elf_Sym *es; 159 vaddr_t map_text_base; 160 vaddr_t map_data_base; 161 vaddr_t map_rodata_base; 162 size_t map_text_size; 163 size_t map_data_size; 164 size_t map_rodata_size; 165 int error; 166 int symtabindex; 167 int symstrindex; 168 int nsym; 169 int pb, rl, ra; 170 int alignmask; 171 int i, j; 172 void *addr; 173 174 KASSERT(ko->ko_type != KT_UNSET); 175 KASSERT(ko->ko_source != NULL); 176 177 shdr = NULL; 178 error = 0; 179 hdr = NULL; 180 181 /* 182 * Read the elf header from the file. 183 */ 184 error = ko->ko_read(ko, (void **)&hdr, sizeof(*hdr), 0, true); 185 if (error != 0) { 186 kobj_error(ko, "read failed %d", error); 187 goto out; 188 } 189 if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) { 190 kobj_error(ko, "not an ELF object"); 191 error = ENOEXEC; 192 goto out; 193 } 194 195 if (hdr->e_ident[EI_VERSION] != EV_CURRENT || 196 hdr->e_version != EV_CURRENT) { 197 kobj_error(ko, "unsupported file version %d", 198 hdr->e_ident[EI_VERSION]); 199 error = ENOEXEC; 200 goto out; 201 } 202 if (hdr->e_type != ET_REL) { 203 kobj_error(ko, "unsupported file type %d", hdr->e_type); 204 error = ENOEXEC; 205 goto out; 206 } 207 switch (hdr->e_machine) { 208 #if ELFSIZE == 32 209 ELF32_MACHDEP_ID_CASES 210 #elif ELFSIZE == 64 211 ELF64_MACHDEP_ID_CASES 212 #else 213 #error not defined 214 #endif 215 default: 216 kobj_error(ko, "unsupported machine %d", hdr->e_machine); 217 error = ENOEXEC; 218 goto out; 219 } 220 221 ko->ko_nprogtab = 0; 222 ko->ko_shdr = 0; 223 ko->ko_nrel = 0; 224 ko->ko_nrela = 0; 225 226 /* 227 * Allocate and read in the section header. 228 */ 229 if (hdr->e_shnum == 0 || hdr->e_shnum > ELF_MAXSHNUM || 230 hdr->e_shoff == 0 || hdr->e_shentsize != sizeof(Elf_Shdr)) { 231 kobj_error(ko, "bad sizes"); 232 error = ENOEXEC; 233 goto out; 234 } 235 ko->ko_shdrsz = hdr->e_shnum * sizeof(Elf_Shdr); 236 error = ko->ko_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff, 237 true); 238 if (error != 0) { 239 kobj_error(ko, "read failed %d", error); 240 goto out; 241 } 242 ko->ko_shdr = shdr; 243 244 /* 245 * Scan the section header for information and table sizing. 246 */ 247 nsym = 0; 248 symtabindex = symstrindex = -1; 249 for (i = 0; i < hdr->e_shnum; i++) { 250 switch (shdr[i].sh_type) { 251 case SHT_PROGBITS: 252 case SHT_NOBITS: 253 ko->ko_nprogtab++; 254 break; 255 case SHT_SYMTAB: 256 nsym++; 257 symtabindex = i; 258 symstrindex = shdr[i].sh_link; 259 break; 260 case SHT_REL: 261 if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS) 262 continue; 263 ko->ko_nrel++; 264 break; 265 case SHT_RELA: 266 if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS) 267 continue; 268 ko->ko_nrela++; 269 break; 270 case SHT_STRTAB: 271 break; 272 } 273 } 274 if (ko->ko_nprogtab == 0) { 275 kobj_error(ko, "file has no contents"); 276 error = ENOEXEC; 277 goto out; 278 } 279 if (nsym != 1) { 280 /* Only allow one symbol table for now */ 281 kobj_error(ko, "file has no valid symbol table"); 282 error = ENOEXEC; 283 goto out; 284 } 285 KASSERT(symtabindex != -1); 286 KASSERT(symstrindex != -1); 287 288 if (symstrindex == SHN_UNDEF || symstrindex >= hdr->e_shnum || 289 shdr[symstrindex].sh_type != SHT_STRTAB) { 290 kobj_error(ko, "file has invalid symbol strings"); 291 error = ENOEXEC; 292 goto out; 293 } 294 295 /* 296 * Allocate space for tracking the load chunks. 297 */ 298 if (ko->ko_nprogtab != 0) { 299 ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab * 300 sizeof(*ko->ko_progtab), KM_SLEEP); 301 if (ko->ko_progtab == NULL) { 302 error = ENOMEM; 303 kobj_error(ko, "out of memory"); 304 goto out; 305 } 306 } 307 if (ko->ko_nrel != 0) { 308 ko->ko_reltab = kmem_zalloc(ko->ko_nrel * 309 sizeof(*ko->ko_reltab), KM_SLEEP); 310 if (ko->ko_reltab == NULL) { 311 error = ENOMEM; 312 kobj_error(ko, "out of memory"); 313 goto out; 314 } 315 } 316 if (ko->ko_nrela != 0) { 317 ko->ko_relatab = kmem_zalloc(ko->ko_nrela * 318 sizeof(*ko->ko_relatab), KM_SLEEP); 319 if (ko->ko_relatab == NULL) { 320 error = ENOMEM; 321 kobj_error(ko, "out of memory"); 322 goto out; 323 } 324 } 325 326 /* 327 * Allocate space for and load the symbol table. 328 */ 329 ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym); 330 if (ko->ko_symcnt == 0) { 331 kobj_error(ko, "no symbol table"); 332 error = ENOEXEC; 333 goto out; 334 } 335 error = ko->ko_read(ko, (void **)&ko->ko_symtab, 336 ko->ko_symcnt * sizeof(Elf_Sym), 337 shdr[symtabindex].sh_offset, true); 338 if (error != 0) { 339 kobj_error(ko, "read failed %d", error); 340 goto out; 341 } 342 343 /* 344 * Allocate space for and load the symbol strings. 345 */ 346 ko->ko_strtabsz = shdr[symstrindex].sh_size; 347 if (ko->ko_strtabsz == 0) { 348 kobj_error(ko, "no symbol strings"); 349 error = ENOEXEC; 350 goto out; 351 } 352 error = ko->ko_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz, 353 shdr[symstrindex].sh_offset, true); 354 if (error != 0) { 355 kobj_error(ko, "read failed %d", error); 356 goto out; 357 } 358 359 /* 360 * Adjust module symbol namespace, if necessary (e.g. with rump) 361 */ 362 error = kobj_renamespace(ko->ko_symtab, ko->ko_symcnt, 363 &ko->ko_strtab, &ko->ko_strtabsz); 364 if (error != 0) { 365 kobj_error(ko, "renamespace failed %d", error); 366 goto out; 367 } 368 369 /* 370 * Do we have a string table for the section names? 371 */ 372 if (hdr->e_shstrndx != SHN_UNDEF) { 373 if (hdr->e_shstrndx >= hdr->e_shnum) { 374 kobj_error(ko, "bad shstrndx"); 375 error = ENOEXEC; 376 goto out; 377 } 378 if (shdr[hdr->e_shstrndx].sh_size != 0 && 379 shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) { 380 ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size; 381 error = ko->ko_read(ko, (void **)&ko->ko_shstrtab, 382 shdr[hdr->e_shstrndx].sh_size, 383 shdr[hdr->e_shstrndx].sh_offset, true); 384 if (error != 0) { 385 kobj_error(ko, "read failed %d", error); 386 goto out; 387 } 388 } 389 } 390 391 /* 392 * Size up code/data(progbits) and bss(nobits). 393 */ 394 alignmask = 0; 395 map_text_size = 0; 396 map_data_size = 0; 397 map_rodata_size = 0; 398 for (i = 0; i < hdr->e_shnum; i++) { 399 if (shdr[i].sh_type != SHT_PROGBITS && 400 shdr[i].sh_type != SHT_NOBITS) 401 continue; 402 alignmask = shdr[i].sh_addralign - 1; 403 if ((shdr[i].sh_flags & SHF_EXECINSTR)) { 404 map_text_size += alignmask; 405 map_text_size &= ~alignmask; 406 map_text_size += shdr[i].sh_size; 407 } else if (!(shdr[i].sh_flags & SHF_WRITE)) { 408 map_rodata_size += alignmask; 409 map_rodata_size &= ~alignmask; 410 map_rodata_size += shdr[i].sh_size; 411 } else { 412 map_data_size += alignmask; 413 map_data_size &= ~alignmask; 414 map_data_size += shdr[i].sh_size; 415 } 416 } 417 418 if (map_text_size == 0) { 419 kobj_error(ko, "no text"); 420 error = ENOEXEC; 421 goto out; 422 } 423 424 if (map_data_size != 0) { 425 map_data_base = uvm_km_alloc(module_map, round_page(map_data_size), 426 0, UVM_KMF_WIRED); 427 if (map_data_base == 0) { 428 kobj_error(ko, "out of memory"); 429 error = ENOMEM; 430 goto out; 431 } 432 ko->ko_data_address = map_data_base; 433 ko->ko_data_size = map_data_size; 434 } else { 435 map_data_base = 0; 436 ko->ko_data_address = 0; 437 ko->ko_data_size = 0; 438 } 439 440 if (map_rodata_size != 0) { 441 map_rodata_base = uvm_km_alloc(module_map, round_page(map_rodata_size), 442 0, UVM_KMF_WIRED); 443 if (map_rodata_base == 0) { 444 kobj_error(ko, "out of memory"); 445 error = ENOMEM; 446 goto out; 447 } 448 ko->ko_rodata_address = map_rodata_base; 449 ko->ko_rodata_size = map_rodata_size; 450 } else { 451 map_rodata_base = 0; 452 ko->ko_rodata_address = 0; 453 ko->ko_rodata_size = 0; 454 } 455 456 map_text_base = uvm_km_alloc(module_map, round_page(map_text_size), 457 0, UVM_KMF_WIRED | UVM_KMF_EXEC); 458 if (map_text_base == 0) { 459 kobj_error(ko, "out of memory"); 460 error = ENOMEM; 461 goto out; 462 } 463 ko->ko_text_address = map_text_base; 464 ko->ko_text_size = map_text_size; 465 466 /* 467 * Now load code/data(progbits), zero bss(nobits), allocate space 468 * for and load relocs 469 */ 470 pb = 0; 471 rl = 0; 472 ra = 0; 473 alignmask = 0; 474 for (i = 0; i < hdr->e_shnum; i++) { 475 switch (shdr[i].sh_type) { 476 case SHT_PROGBITS: 477 case SHT_NOBITS: 478 alignmask = shdr[i].sh_addralign - 1; 479 if ((shdr[i].sh_flags & SHF_EXECINSTR)) { 480 map_text_base += alignmask; 481 map_text_base &= ~alignmask; 482 addr = (void *)map_text_base; 483 map_text_base += shdr[i].sh_size; 484 } else if (!(shdr[i].sh_flags & SHF_WRITE)) { 485 map_rodata_base += alignmask; 486 map_rodata_base &= ~alignmask; 487 addr = (void *)map_rodata_base; 488 map_rodata_base += shdr[i].sh_size; 489 } else { 490 map_data_base += alignmask; 491 map_data_base &= ~alignmask; 492 addr = (void *)map_data_base; 493 map_data_base += shdr[i].sh_size; 494 } 495 496 ko->ko_progtab[pb].addr = addr; 497 if (shdr[i].sh_type == SHT_PROGBITS) { 498 ko->ko_progtab[pb].name = "<<PROGBITS>>"; 499 error = ko->ko_read(ko, &addr, 500 shdr[i].sh_size, shdr[i].sh_offset, false); 501 if (error != 0) { 502 kobj_error(ko, "read failed %d", error); 503 goto out; 504 } 505 } else { /* SHT_NOBITS */ 506 ko->ko_progtab[pb].name = "<<NOBITS>>"; 507 memset(addr, 0, shdr[i].sh_size); 508 } 509 510 ko->ko_progtab[pb].size = shdr[i].sh_size; 511 ko->ko_progtab[pb].sec = i; 512 if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) { 513 ko->ko_progtab[pb].name = 514 ko->ko_shstrtab + shdr[i].sh_name; 515 } 516 517 /* Update all symbol values with the offset. */ 518 for (j = 0; j < ko->ko_symcnt; j++) { 519 es = &ko->ko_symtab[j]; 520 if (es->st_shndx != i) { 521 continue; 522 } 523 es->st_value += (Elf_Addr)addr; 524 } 525 pb++; 526 break; 527 case SHT_REL: 528 if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS) 529 break; 530 ko->ko_reltab[rl].size = shdr[i].sh_size; 531 ko->ko_reltab[rl].size -= 532 shdr[i].sh_size % sizeof(Elf_Rel); 533 if (ko->ko_reltab[rl].size != 0) { 534 ko->ko_reltab[rl].nrel = 535 shdr[i].sh_size / sizeof(Elf_Rel); 536 ko->ko_reltab[rl].sec = shdr[i].sh_info; 537 error = ko->ko_read(ko, 538 (void **)&ko->ko_reltab[rl].rel, 539 ko->ko_reltab[rl].size, 540 shdr[i].sh_offset, true); 541 if (error != 0) { 542 kobj_error(ko, "read failed %d", 543 error); 544 goto out; 545 } 546 } 547 rl++; 548 break; 549 case SHT_RELA: 550 if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS) 551 break; 552 ko->ko_relatab[ra].size = shdr[i].sh_size; 553 ko->ko_relatab[ra].size -= 554 shdr[i].sh_size % sizeof(Elf_Rela); 555 if (ko->ko_relatab[ra].size != 0) { 556 ko->ko_relatab[ra].nrela = 557 shdr[i].sh_size / sizeof(Elf_Rela); 558 ko->ko_relatab[ra].sec = shdr[i].sh_info; 559 error = ko->ko_read(ko, 560 (void **)&ko->ko_relatab[ra].rela, 561 shdr[i].sh_size, 562 shdr[i].sh_offset, true); 563 if (error != 0) { 564 kobj_error(ko, "read failed %d", error); 565 goto out; 566 } 567 } 568 ra++; 569 break; 570 default: 571 break; 572 } 573 } 574 if (pb != ko->ko_nprogtab) { 575 panic("%s:%d: %s: lost progbits", __func__, __LINE__, 576 ko->ko_name); 577 } 578 if (rl != ko->ko_nrel) { 579 panic("%s:%d: %s: lost rel", __func__, __LINE__, 580 ko->ko_name); 581 } 582 if (ra != ko->ko_nrela) { 583 panic("%s:%d: %s: lost rela", __func__, __LINE__, 584 ko->ko_name); 585 } 586 if (map_text_base != ko->ko_text_address + map_text_size) { 587 panic("%s:%d: %s: map_text_base 0x%lx != address %lx " 588 "+ map_text_size %ld (0x%lx)\n", 589 __func__, __LINE__, ko->ko_name, (long)map_text_base, 590 (long)ko->ko_text_address, (long)map_text_size, 591 (long)ko->ko_text_address + map_text_size); 592 } 593 if (map_data_base != ko->ko_data_address + map_data_size) { 594 panic("%s:%d: %s: map_data_base 0x%lx != address %lx " 595 "+ map_data_size %ld (0x%lx)\n", 596 __func__, __LINE__, ko->ko_name, (long)map_data_base, 597 (long)ko->ko_data_address, (long)map_data_size, 598 (long)ko->ko_data_address + map_data_size); 599 } 600 if (map_rodata_base != ko->ko_rodata_address + map_rodata_size) { 601 panic("%s:%d: %s: map_rodata_base 0x%lx != address %lx " 602 "+ map_rodata_size %ld (0x%lx)\n", 603 __func__, __LINE__, ko->ko_name, (long)map_rodata_base, 604 (long)ko->ko_rodata_address, (long)map_rodata_size, 605 (long)ko->ko_rodata_address + map_rodata_size); 606 } 607 608 /* 609 * Perform local relocations only. Relocations relating to global 610 * symbols will be done by kobj_affix(). 611 */ 612 error = kobj_checksyms(ko, false); 613 if (error == 0) { 614 error = kobj_relocate(ko, true); 615 } 616 out: 617 if (hdr != NULL) { 618 kobj_free(ko, hdr, sizeof(*hdr)); 619 } 620 kobj_close(ko); 621 if (error != 0) { 622 kobj_unload(ko); 623 } 624 625 return error; 626 } 627 628 static void 629 kobj_unload_notify(kobj_t ko, vaddr_t addr, size_t size, const char *note) 630 { 631 if (addr == 0) 632 return; 633 634 int error = kobj_machdep(ko, (void *)addr, size, false); 635 if (error) 636 kobj_error(ko, "machine dependent deinit failed (%s) %d", 637 note, error); 638 } 639 640 #define KOBJ_SEGMENT_NOTIFY(ko, what) \ 641 kobj_unload_notify(ko, (ko)->ko_ ## what ## _address, \ 642 (ko)->ko_ ## what ## _size, # what); 643 644 #define KOBJ_SEGMENT_FREE(ko, what) \ 645 do \ 646 if ((ko)->ko_ ## what ## _address != 0) \ 647 uvm_km_free(module_map, (ko)->ko_ ## what ## _address, \ 648 round_page((ko)->ko_ ## what ## _size), UVM_KMF_WIRED); \ 649 while (/*CONSTCOND*/ 0) 650 651 /* 652 * kobj_unload: 653 * 654 * Unload an object previously loaded by kobj_load(). 655 */ 656 void 657 kobj_unload(kobj_t ko) 658 { 659 kobj_close(ko); 660 kobj_jettison(ko); 661 662 663 /* 664 * Notify MD code that a module has been unloaded. 665 */ 666 if (ko->ko_loaded) { 667 KOBJ_SEGMENT_NOTIFY(ko, text); 668 KOBJ_SEGMENT_NOTIFY(ko, data); 669 KOBJ_SEGMENT_NOTIFY(ko, rodata); 670 } 671 672 KOBJ_SEGMENT_FREE(ko, text); 673 KOBJ_SEGMENT_FREE(ko, data); 674 KOBJ_SEGMENT_FREE(ko, rodata); 675 676 if (ko->ko_ksyms == true) { 677 ksyms_modunload(ko->ko_name); 678 } 679 if (ko->ko_symtab != NULL) { 680 kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym)); 681 } 682 if (ko->ko_strtab != NULL) { 683 kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz); 684 } 685 if (ko->ko_progtab != NULL) { 686 kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab * 687 sizeof(*ko->ko_progtab)); 688 ko->ko_progtab = NULL; 689 } 690 if (ko->ko_shstrtab) { 691 kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz); 692 ko->ko_shstrtab = NULL; 693 } 694 695 kmem_free(ko, sizeof(*ko)); 696 } 697 698 /* 699 * kobj_stat: 700 * 701 * Return size and load address of an object. 702 */ 703 int 704 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size) 705 { 706 707 if (address != NULL) { 708 *address = ko->ko_text_address; 709 } 710 if (size != NULL) { 711 *size = ko->ko_text_size; 712 } 713 return 0; 714 } 715 716 /* 717 * kobj_affix: 718 * 719 * Set an object's name and perform global relocs. May only be 720 * called after the module and any requisite modules are loaded. 721 */ 722 int 723 kobj_affix(kobj_t ko, const char *name) 724 { 725 int error; 726 727 KASSERT(ko->ko_ksyms == false); 728 KASSERT(ko->ko_loaded == false); 729 730 kobj_setname(ko, name); 731 732 /* Cache addresses of undefined symbols. */ 733 error = kobj_checksyms(ko, true); 734 735 /* Now do global relocations. */ 736 if (error == 0) 737 error = kobj_relocate(ko, false); 738 739 /* 740 * Now that we know the name, register the symbol table. 741 * Do after global relocations because ksyms will pack 742 * the table. 743 */ 744 if (error == 0) { 745 ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt * 746 sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz); 747 ko->ko_ksyms = true; 748 } 749 750 /* Jettison unneeded memory post-link. */ 751 kobj_jettison(ko); 752 753 /* 754 * Notify MD code that a module has been loaded. 755 * 756 * Most architectures use this opportunity to flush their caches. 757 */ 758 if (error == 0 && ko->ko_text_address != 0) { 759 error = kobj_machdep(ko, (void *)ko->ko_text_address, 760 ko->ko_text_size, true); 761 if (error != 0) 762 kobj_error(ko, "machine dependent init failed (text)" 763 " %d", error); 764 } 765 766 if (error == 0 && ko->ko_data_address != 0) { 767 error = kobj_machdep(ko, (void *)ko->ko_data_address, 768 ko->ko_data_size, true); 769 if (error != 0) 770 kobj_error(ko, "machine dependent init failed (data)" 771 " %d", error); 772 } 773 774 if (error == 0 && ko->ko_rodata_address != 0) { 775 error = kobj_machdep(ko, (void *)ko->ko_rodata_address, 776 ko->ko_rodata_size, true); 777 if (error != 0) 778 kobj_error(ko, "machine dependent init failed (rodata)" 779 " %d", error); 780 } 781 782 if (error == 0) { 783 ko->ko_loaded = true; 784 785 /* Change the memory protections, when needed. */ 786 if (ko->ko_text_address != 0) { 787 uvm_km_protect(module_map, ko->ko_text_address, 788 ko->ko_text_size, VM_PROT_READ|VM_PROT_EXECUTE); 789 } 790 if (ko->ko_rodata_address != 0) { 791 uvm_km_protect(module_map, ko->ko_rodata_address, 792 ko->ko_rodata_size, VM_PROT_READ); 793 } 794 } else { 795 /* If there was an error, destroy the whole object. */ 796 kobj_unload(ko); 797 } 798 799 return error; 800 } 801 802 /* 803 * kobj_find_section: 804 * 805 * Given a section name, search the loaded object and return 806 * virtual address if present and loaded. 807 */ 808 int 809 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 810 { 811 int i; 812 813 KASSERT(ko->ko_progtab != NULL); 814 815 for (i = 0; i < ko->ko_nprogtab; i++) { 816 if (strcmp(ko->ko_progtab[i].name, name) == 0) { 817 if (addr != NULL) { 818 *addr = ko->ko_progtab[i].addr; 819 } 820 if (size != NULL) { 821 *size = ko->ko_progtab[i].size; 822 } 823 return 0; 824 } 825 } 826 827 return ENOENT; 828 } 829 830 /* 831 * kobj_jettison: 832 * 833 * Release object data not needed after performing relocations. 834 */ 835 static void 836 kobj_jettison(kobj_t ko) 837 { 838 int i; 839 840 if (ko->ko_reltab != NULL) { 841 for (i = 0; i < ko->ko_nrel; i++) { 842 if (ko->ko_reltab[i].rel) { 843 kobj_free(ko, ko->ko_reltab[i].rel, 844 ko->ko_reltab[i].size); 845 } 846 } 847 kobj_free(ko, ko->ko_reltab, ko->ko_nrel * 848 sizeof(*ko->ko_reltab)); 849 ko->ko_reltab = NULL; 850 ko->ko_nrel = 0; 851 } 852 if (ko->ko_relatab != NULL) { 853 for (i = 0; i < ko->ko_nrela; i++) { 854 if (ko->ko_relatab[i].rela) { 855 kobj_free(ko, ko->ko_relatab[i].rela, 856 ko->ko_relatab[i].size); 857 } 858 } 859 kobj_free(ko, ko->ko_relatab, ko->ko_nrela * 860 sizeof(*ko->ko_relatab)); 861 ko->ko_relatab = NULL; 862 ko->ko_nrela = 0; 863 } 864 if (ko->ko_shdr != NULL) { 865 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz); 866 ko->ko_shdr = NULL; 867 } 868 } 869 870 /* 871 * kobj_sym_lookup: 872 * 873 * Symbol lookup function to be used when the symbol index 874 * is known (ie during relocation). 875 */ 876 int 877 kobj_sym_lookup(kobj_t ko, uintptr_t symidx, Elf_Addr *val) 878 { 879 const Elf_Sym *sym; 880 const char *symbol; 881 882 sym = ko->ko_symtab + symidx; 883 884 if (symidx == SHN_ABS || symidx == 0) { 885 *val = (uintptr_t)sym->st_value; 886 return 0; 887 } else if (symidx >= ko->ko_symcnt) { 888 /* 889 * Don't even try to lookup the symbol if the index is 890 * bogus. 891 */ 892 kobj_error(ko, "symbol index %ju out of range", 893 (uintmax_t)symidx); 894 return EINVAL; 895 } 896 897 /* Quick answer if there is a definition included. */ 898 if (sym->st_shndx != SHN_UNDEF) { 899 *val = (uintptr_t)sym->st_value; 900 return 0; 901 } 902 903 /* If we get here, then it is undefined and needs a lookup. */ 904 switch (ELF_ST_BIND(sym->st_info)) { 905 case STB_LOCAL: 906 /* Local, but undefined? huh? */ 907 kobj_error(ko, "local symbol @%ju undefined", 908 (uintmax_t)symidx); 909 return EINVAL; 910 911 case STB_GLOBAL: 912 /* Relative to Data or Function name */ 913 symbol = ko->ko_strtab + sym->st_name; 914 915 /* Force a lookup failure if the symbol name is bogus. */ 916 if (*symbol == 0) { 917 kobj_error(ko, "bad symbol @%ju name", 918 (uintmax_t)symidx); 919 return EINVAL; 920 } 921 if (sym->st_value == 0) { 922 kobj_error(ko, "%s @%ju: bad value", symbol, 923 (uintmax_t)symidx); 924 return EINVAL; 925 } 926 927 *val = (uintptr_t)sym->st_value; 928 return 0; 929 930 case STB_WEAK: 931 kobj_error(ko, "weak symbol @%ju not supported", 932 (uintmax_t)symidx); 933 return EINVAL; 934 935 default: 936 kobj_error(ko, "bad binding %#x for symbol @%ju", 937 ELF_ST_BIND(sym->st_info), (uintmax_t)symidx); 938 return EINVAL; 939 } 940 } 941 942 /* 943 * kobj_findbase: 944 * 945 * Return base address of the given section. 946 */ 947 static uintptr_t 948 kobj_findbase(kobj_t ko, int sec) 949 { 950 int i; 951 952 for (i = 0; i < ko->ko_nprogtab; i++) { 953 if (sec == ko->ko_progtab[i].sec) { 954 return (uintptr_t)ko->ko_progtab[i].addr; 955 } 956 } 957 return 0; 958 } 959 960 /* 961 * kobj_checksyms: 962 * 963 * Scan symbol table for duplicates or resolve references to 964 * external symbols. 965 */ 966 static int 967 kobj_checksyms(kobj_t ko, bool undefined) 968 { 969 unsigned long rval; 970 Elf_Sym *sym, *ksym, *ms; 971 const char *name; 972 int error; 973 974 error = 0; 975 976 for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) { 977 /* Check validity of the symbol. */ 978 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL || 979 sym->st_name == 0) 980 continue; 981 if (undefined != (sym->st_shndx == SHN_UNDEF)) { 982 continue; 983 } 984 985 /* 986 * Look it up. Don't need to lock, as it is known that 987 * the symbol tables aren't going to change (we hold 988 * module_lock). 989 */ 990 name = ko->ko_strtab + sym->st_name; 991 if (ksyms_getval_unlocked(NULL, name, &ksym, &rval, 992 KSYMS_EXTERN) != 0) { 993 if (undefined) { 994 kobj_error(ko, "symbol `%s' not found", 995 name); 996 error = ENOEXEC; 997 } 998 continue; 999 } 1000 1001 /* Save values of undefined globals. */ 1002 if (undefined) { 1003 if (ksym->st_shndx == SHN_ABS) { 1004 sym->st_shndx = SHN_ABS; 1005 } 1006 sym->st_value = (Elf_Addr)rval; 1007 continue; 1008 } 1009 1010 /* Check (and complain) about differing values. */ 1011 if (sym->st_value == rval) { 1012 continue; 1013 } 1014 if (strcmp(name, "_bss_start") == 0 || 1015 strcmp(name, "__bss_start") == 0 || 1016 strcmp(name, "_bss_end__") == 0 || 1017 strcmp(name, "__bss_end__") == 0 || 1018 strcmp(name, "_edata") == 0 || 1019 strcmp(name, "_end") == 0 || 1020 strcmp(name, "__end") == 0 || 1021 strcmp(name, "__end__") == 0 || 1022 strncmp(name, "__start_link_set_", 17) == 0 || 1023 strncmp(name, "__stop_link_set_", 16) == 0) { 1024 continue; 1025 } 1026 kobj_error(ko, "global symbol `%s' redefined", 1027 name); 1028 error = ENOEXEC; 1029 } 1030 1031 return error; 1032 } 1033 1034 /* 1035 * kobj_relocate: 1036 * 1037 * Resolve relocations for the loaded object. 1038 */ 1039 static int 1040 kobj_relocate(kobj_t ko, bool local) 1041 { 1042 const Elf_Rel *rellim; 1043 const Elf_Rel *rel; 1044 const Elf_Rela *relalim; 1045 const Elf_Rela *rela; 1046 const Elf_Sym *sym; 1047 uintptr_t base; 1048 int i, error; 1049 uintptr_t symidx; 1050 1051 /* 1052 * Perform relocations without addend if there are any. 1053 */ 1054 for (i = 0; i < ko->ko_nrel; i++) { 1055 rel = ko->ko_reltab[i].rel; 1056 if (rel == NULL) { 1057 continue; 1058 } 1059 rellim = rel + ko->ko_reltab[i].nrel; 1060 base = kobj_findbase(ko, ko->ko_reltab[i].sec); 1061 if (base == 0) { 1062 panic("%s:%d: %s: lost base for e_reltab[%d] sec %d", 1063 __func__, __LINE__, ko->ko_name, i, 1064 ko->ko_reltab[i].sec); 1065 } 1066 for (; rel < rellim; rel++) { 1067 symidx = ELF_R_SYM(rel->r_info); 1068 if (symidx >= ko->ko_symcnt) { 1069 continue; 1070 } 1071 sym = ko->ko_symtab + symidx; 1072 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 1073 continue; 1074 } 1075 error = kobj_reloc(ko, base, rel, false, local); 1076 if (error != 0) { 1077 kobj_error(ko, "unresolved rel relocation " 1078 "@%#jx type=%d symidx=%d", 1079 (intmax_t)rel->r_offset, 1080 (int)ELF_R_TYPE(rel->r_info), 1081 (int)ELF_R_SYM(rel->r_info)); 1082 return ENOEXEC; 1083 } 1084 } 1085 } 1086 1087 /* 1088 * Perform relocations with addend if there are any. 1089 */ 1090 for (i = 0; i < ko->ko_nrela; i++) { 1091 rela = ko->ko_relatab[i].rela; 1092 if (rela == NULL) { 1093 continue; 1094 } 1095 relalim = rela + ko->ko_relatab[i].nrela; 1096 base = kobj_findbase(ko, ko->ko_relatab[i].sec); 1097 if (base == 0) { 1098 panic("%s:%d: %s: lost base for e_relatab[%d] sec %d", 1099 __func__, __LINE__, ko->ko_name, i, 1100 ko->ko_relatab[i].sec); 1101 } 1102 for (; rela < relalim; rela++) { 1103 symidx = ELF_R_SYM(rela->r_info); 1104 if (symidx >= ko->ko_symcnt) { 1105 continue; 1106 } 1107 sym = ko->ko_symtab + symidx; 1108 if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { 1109 continue; 1110 } 1111 error = kobj_reloc(ko, base, rela, true, local); 1112 if (error != 0) { 1113 kobj_error(ko, "unresolved rela relocation " 1114 "@%#jx type=%d symidx=%d", 1115 (intmax_t)rela->r_offset, 1116 (int)ELF_R_TYPE(rela->r_info), 1117 (int)ELF_R_SYM(rela->r_info)); 1118 return ENOEXEC; 1119 } 1120 } 1121 } 1122 1123 return 0; 1124 } 1125 1126 /* 1127 * kobj_out: 1128 * 1129 * Utility function: log an error. 1130 */ 1131 static void 1132 kobj_out(const char *fname, int lnum, kobj_t ko, const char *fmt, ...) 1133 { 1134 va_list ap; 1135 1136 printf("%s, %d: [%s]: linker error: ", fname, lnum, ko->ko_name); 1137 va_start(ap, fmt); 1138 vprintf(fmt, ap); 1139 va_end(ap); 1140 printf("\n"); 1141 } 1142 1143 static int 1144 kobj_read_mem(kobj_t ko, void **basep, size_t size, off_t off, 1145 bool allocate) 1146 { 1147 void *base = *basep; 1148 int error; 1149 1150 KASSERT(ko->ko_source != NULL); 1151 1152 if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) { 1153 kobj_error(ko, "preloaded object short"); 1154 error = EINVAL; 1155 base = NULL; 1156 } else if (allocate) { 1157 base = kmem_alloc(size, KM_SLEEP); 1158 error = 0; 1159 } else { 1160 error = 0; 1161 } 1162 1163 if (error == 0) { 1164 /* Copy the section */ 1165 memcpy(base, (uint8_t *)ko->ko_source + off, size); 1166 } 1167 1168 if (allocate && error != 0) { 1169 kmem_free(base, size); 1170 base = NULL; 1171 } 1172 1173 if (allocate) 1174 *basep = base; 1175 1176 return error; 1177 } 1178 1179 /* 1180 * kobj_free: 1181 * 1182 * Utility function: free memory if it was allocated from the heap. 1183 */ 1184 static void 1185 kobj_free(kobj_t ko, void *base, size_t size) 1186 { 1187 1188 kmem_free(base, size); 1189 } 1190 1191 extern char module_base[]; 1192 1193 void 1194 kobj_setname(kobj_t ko, const char *name) 1195 { 1196 const char *d = name, *dots = ""; 1197 size_t len, dlen; 1198 1199 for (char *s = module_base; *d == *s; d++, s++) 1200 continue; 1201 1202 if (d == name) 1203 name = ""; 1204 else 1205 name = "%M"; 1206 dlen = strlen(d); 1207 len = dlen + strlen(name); 1208 if (len >= sizeof(ko->ko_name)) { 1209 len = (len - sizeof(ko->ko_name)) + 5; /* dots + NUL */ 1210 if (dlen >= len) { 1211 d += len; 1212 dots = "/..."; 1213 } 1214 } 1215 snprintf(ko->ko_name, sizeof(ko->ko_name), "%s%s%s", name, dots, d); 1216 } 1217 1218 #else /* MODULAR */ 1219 1220 int 1221 kobj_load_mem(kobj_t *kop, const char *name, void *base, ssize_t size) 1222 { 1223 1224 return ENOSYS; 1225 } 1226 1227 void 1228 kobj_unload(kobj_t ko) 1229 { 1230 1231 panic("not modular"); 1232 } 1233 1234 int 1235 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size) 1236 { 1237 1238 return ENOSYS; 1239 } 1240 1241 int 1242 kobj_affix(kobj_t ko, const char *name) 1243 { 1244 1245 panic("not modular"); 1246 } 1247 1248 int 1249 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size) 1250 { 1251 1252 panic("not modular"); 1253 } 1254 1255 void 1256 kobj_setname(kobj_t ko, const char *name) 1257 { 1258 1259 panic("not modular"); 1260 } 1261 1262 #endif /* MODULAR */ 1263