sys/kern/subr_kobj.c

   1 /*      $NetBSD: subr_kobj.c,v 1.39 2009/06/17 21:04:25 dyoung 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.39 2009/06/17 21:04:25 dyoung Exp $");
  67
  68 #include "opt_modular.h"
  69
  70 #include <sys/kobj_impl.h>
  71
  72 #ifdef MODULAR
  73
  74 #include <sys/param.h>
  75 #include <sys/kernel.h>
  76 #include <sys/kmem.h>
  77 #include <sys/proc.h>
  78 #include <sys/ksyms.h>
  79 #include <sys/module.h>
  80
  81 #include <machine/stdarg.h>
  82
  83 #include <uvm/uvm_extern.h>
  84
  85 static int      kobj_relocate(kobj_t, bool);
  86 static int      kobj_checksyms(kobj_t, bool);
  87 static void     kobj_error(const char *, ...);
  88 static void     kobj_jettison(kobj_t);
  89 static void     kobj_free(kobj_t, void *, size_t);
  90 static void     kobj_close(kobj_t);
  91 static int      kobj_read_mem(kobj_t, void **, size_t, off_t, bool);
  92 static void     kobj_close_mem(kobj_t);
  93
  94 extern struct vm_map *module_map;
  95
  96 /*
  97  * kobj_load_mem:
  98  *
  99  *      Load an object already resident in memory.  If size is not -1,
 100  *      the complete size of the object is known.
 101  */
 102 int
 103 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
 104 {
 105         kobj_t ko;
 106
 107         ko = kmem_zalloc(sizeof(*ko), KM_SLEEP);
 108         if (ko == NULL) {
 109                 return ENOMEM;
 110         }
 111
 112         ko->ko_type = KT_MEMORY;
 113         ko->ko_source = base;
 114         ko->ko_memsize = size;
 115         ko->ko_read = kobj_read_mem;
 116         ko->ko_close = kobj_close_mem;
 117
 118         *kop = ko;
 119         return kobj_load(ko);
 120 }
 121
 122 /*
 123  * kobj_close:
 124  *
 125  *      Close an open ELF object.
 126  */
 127 static void
 128 kobj_close(kobj_t ko)
 129 {
 130
 131         if (ko->ko_source == NULL) {
 132                 return;
 133         }
 134
 135         ko->ko_close(ko);
 136         ko->ko_source = NULL;
 137 }
 138
 139 static void
 140 kobj_close_mem(kobj_t ko)
 141 {
 142
 143         return;
 144 }
 145
 146 /*
 147  * kobj_load:
 148  *
 149  *      Load an ELF object and prepare to link into the running kernel
 150  *      image.
 151  */
 152 int
 153 kobj_load(kobj_t ko)
 154 {
 155         Elf_Ehdr *hdr;
 156         Elf_Shdr *shdr;
 157         Elf_Sym *es;
 158         vaddr_t mapbase;
 159         size_t mapsize;
 160         int error;
 161         int symtabindex;
 162         int symstrindex;
 163         int nsym;
 164         int pb, rl, ra;
 165         int alignmask;
 166         int i, j;
 167         void *addr;
 168
 169         KASSERT(ko->ko_type != KT_UNSET);
 170         KASSERT(ko->ko_source != NULL);
 171
 172         shdr = NULL;
 173         mapsize = 0;
 174         error = 0;
 175         hdr = NULL;
 176
 177         /*
 178          * Read the elf header from the file.
 179          */
 180         error = ko->ko_read(ko, (void **)&hdr, sizeof(*hdr), 0, true);
 181         if (error != 0)
 182                 goto out;
 183         if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
 184                 kobj_error("not an ELF object");
 185                 error = ENOEXEC;
 186                 goto out;
 187         }
 188
 189         if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
 190             hdr->e_version != EV_CURRENT) {
 191                 kobj_error("unsupported file version");
 192                 error = ENOEXEC;
 193                 goto out;
 194         }
 195         if (hdr->e_type != ET_REL) {
 196                 kobj_error("unsupported file type");
 197                 error = ENOEXEC;
 198                 goto out;
 199         }
 200         switch (hdr->e_machine) {
 201 #if ELFSIZE == 32
 202         ELF32_MACHDEP_ID_CASES
 203 #else
 204         ELF64_MACHDEP_ID_CASES
 205 #endif
 206         default:
 207                 kobj_error("unsupported machine");
 208                 error = ENOEXEC;
 209                 goto out;
 210         }
 211
 212         ko->ko_nprogtab = 0;
 213         ko->ko_shdr = 0;
 214         ko->ko_nrel = 0;
 215         ko->ko_nrela = 0;
 216
 217         /*
 218          * Allocate and read in the section header.
 219          */
 220         ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize;
 221         if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 ||
 222             hdr->e_shentsize != sizeof(Elf_Shdr)) {
 223                 error = ENOEXEC;
 224                 goto out;
 225         }
 226         error = ko->ko_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff,
 227             true);
 228         if (error != 0) {
 229                 goto out;
 230         }
 231         ko->ko_shdr = shdr;
 232
 233         /*
 234          * Scan the section header for information and table sizing.
 235          */
 236         nsym = 0;
 237         symtabindex = -1;
 238         symstrindex = -1;
 239         for (i = 0; i < hdr->e_shnum; i++) {
 240                 switch (shdr[i].sh_type) {
 241                 case SHT_PROGBITS:
 242                 case SHT_NOBITS:
 243                         ko->ko_nprogtab++;
 244                         break;
 245                 case SHT_SYMTAB:
 246                         nsym++;
 247                         symtabindex = i;
 248                         symstrindex = shdr[i].sh_link;
 249                         break;
 250                 case SHT_REL:
 251                         ko->ko_nrel++;
 252                         break;
 253                 case SHT_RELA:
 254                         ko->ko_nrela++;
 255                         break;
 256                 case SHT_STRTAB:
 257                         break;
 258                 }
 259         }
 260         if (ko->ko_nprogtab == 0) {
 261                 kobj_error("file has no contents");
 262                 error = ENOEXEC;
 263                 goto out;
 264         }
 265         if (nsym != 1) {
 266                 /* Only allow one symbol table for now */
 267                 kobj_error("file has no valid symbol table");
 268                 error = ENOEXEC;
 269                 goto out;
 270         }
 271         if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
 272             shdr[symstrindex].sh_type != SHT_STRTAB) {
 273                 kobj_error("file has invalid symbol strings");
 274                 error = ENOEXEC;
 275                 goto out;
 276         }
 277
 278         /*
 279          * Allocate space for tracking the load chunks.
 280          */
 281         if (ko->ko_nprogtab != 0) {
 282                 ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab *
 283                     sizeof(*ko->ko_progtab), KM_SLEEP);
 284                 if (ko->ko_progtab == NULL) {
 285                         error = ENOMEM;
 286                         goto out;
 287                 }
 288         }
 289         if (ko->ko_nrel != 0) {
 290                 ko->ko_reltab = kmem_zalloc(ko->ko_nrel *
 291                     sizeof(*ko->ko_reltab), KM_SLEEP);
 292                 if (ko->ko_reltab == NULL) {
 293                         error = ENOMEM;
 294                         goto out;
 295                 }
 296         }
 297         if (ko->ko_nrela != 0) {
 298                 ko->ko_relatab = kmem_zalloc(ko->ko_nrela *
 299                     sizeof(*ko->ko_relatab), KM_SLEEP);
 300                 if (ko->ko_relatab == NULL) {
 301                         error = ENOMEM;
 302                         goto out;
 303                 }
 304         }
 305         if (symtabindex == -1) {
 306                 kobj_error("lost symbol table index");
 307                 goto out;
 308         }
 309
 310         /*
 311          * Allocate space for and load the symbol table.
 312          */
 313         ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
 314         if (ko->ko_symcnt == 0) {
 315                 kobj_error("no symbol table");
 316                 goto out;
 317         }
 318         error = ko->ko_read(ko, (void **)&ko->ko_symtab,
 319             ko->ko_symcnt * sizeof(Elf_Sym),
 320             shdr[symtabindex].sh_offset, true);
 321         if (error != 0) {
 322                 goto out;
 323         }
 324
 325         /*
 326          * Allocate space for and load the symbol strings.
 327          */
 328         ko->ko_strtabsz = shdr[symstrindex].sh_size;
 329         if (ko->ko_strtabsz == 0) {
 330                 kobj_error("no symbol strings");
 331                 goto out;
 332         }
 333         error = ko->ko_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz,
 334             shdr[symstrindex].sh_offset, true);
 335         if (error != 0) {
 336                 goto out;
 337         }
 338
 339         /*
 340          * Do we have a string table for the section names?
 341          */
 342         if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 &&
 343             shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
 344                 ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size;
 345                 error = ko->ko_read(ko, (void **)&ko->ko_shstrtab,
 346                     shdr[hdr->e_shstrndx].sh_size,
 347                     shdr[hdr->e_shstrndx].sh_offset, true);
 348                 if (error != 0) {
 349                         goto out;
 350                 }
 351         }
 352
 353         /*
 354          * Size up code/data(progbits) and bss(nobits).
 355          */
 356         alignmask = 0;
 357         mapbase = 0;
 358         for (i = 0; i < hdr->e_shnum; i++) {
 359                 switch (shdr[i].sh_type) {
 360                 case SHT_PROGBITS:
 361                 case SHT_NOBITS:
 362                         if (mapbase == 0)
 363                                 mapbase = shdr[i].sh_offset;
 364                         alignmask = shdr[i].sh_addralign - 1;
 365                         mapsize += alignmask;
 366                         mapsize &= ~alignmask;
 367                         mapsize += shdr[i].sh_size;
 368                         break;
 369                 }
 370         }
 371
 372         /*
 373          * We know how much space we need for the text/data/bss/etc.
 374          * This stuff needs to be in a single chunk so that profiling etc
 375          * can get the bounds and gdb can associate offsets with modules.
 376          */
 377         if (mapsize == 0) {
 378                 kobj_error("no text/data/bss");
 379                 goto out;
 380         }
 381         if (ko->ko_type == KT_MEMORY) {
 382                 mapbase += (vaddr_t)ko->ko_source;
 383         } else {
 384                 mapbase = uvm_km_alloc(module_map, round_page(mapsize),
 385                     0, UVM_KMF_WIRED | UVM_KMF_EXEC);
 386                 if (mapbase == 0) {
 387                         error = ENOMEM;
 388                         goto out;
 389                 }
 390         }
 391         ko->ko_address = mapbase;
 392         ko->ko_size = mapsize;
 393
 394         /*
 395          * Now load code/data(progbits), zero bss(nobits), allocate space
 396          * for and load relocs
 397          */
 398         pb = 0;
 399         rl = 0;
 400         ra = 0;
 401         alignmask = 0;
 402         for (i = 0; i < hdr->e_shnum; i++) {
 403                 switch (shdr[i].sh_type) {
 404                 case SHT_PROGBITS:
 405                 case SHT_NOBITS:
 406                         alignmask = shdr[i].sh_addralign - 1;
 407                         if (ko->ko_type == KT_MEMORY) {
 408                                 addr = (void *)(shdr[i].sh_offset +
 409                                     (vaddr_t)ko->ko_source);
 410                                 if (((vaddr_t)addr & alignmask) != 0) {
 411                                         kobj_error("section %d not aligned\n",
 412                                             i);
 413                                         goto out;
 414                                 }
 415                         } else {
 416                                 mapbase += alignmask;
 417                                 mapbase &= ~alignmask;
 418                                 addr = (void *)mapbase;
 419                                 mapbase += shdr[i].sh_size;
 420                         }
 421                         ko->ko_progtab[pb].addr = addr;
 422                         if (shdr[i].sh_type == SHT_PROGBITS) {
 423                                 ko->ko_progtab[pb].name = "<<PROGBITS>>";
 424                                 error = ko->ko_read(ko, &addr,
 425                                     shdr[i].sh_size, shdr[i].sh_offset, false);
 426                                 if (error != 0) {
 427                                         goto out;
 428                                 }
 429                         } else if (ko->ko_type == KT_MEMORY &&
 430                             shdr[i].sh_size != 0) {
 431                                 kobj_error("non-loadable BSS section in "
 432                                     "pre-loaded module");
 433                                 error = EINVAL;
 434                                 goto out;
 435                         } else {
 436                                 ko->ko_progtab[pb].name = "<<NOBITS>>";
 437                                 memset(addr, 0, shdr[i].sh_size);
 438                         }
 439                         ko->ko_progtab[pb].size = shdr[i].sh_size;
 440                         ko->ko_progtab[pb].sec = i;
 441                         if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) {
 442                                 ko->ko_progtab[pb].name =
 443                                     ko->ko_shstrtab + shdr[i].sh_name;
 444                         }
 445
 446                         /* Update all symbol values with the offset. */
 447                         for (j = 0; j < ko->ko_symcnt; j++) {
 448                                 es = &ko->ko_symtab[j];
 449                                 if (es->st_shndx != i) {
 450                                         continue;
 451                                 }
 452                                 es->st_value += (Elf_Addr)addr;
 453                         }
 454                         pb++;
 455                         break;
 456                 case SHT_REL:
 457                         ko->ko_reltab[rl].size = shdr[i].sh_size;
 458                         ko->ko_reltab[rl].size -=
 459                             shdr[i].sh_size % sizeof(Elf_Rel);
 460                         if (ko->ko_reltab[rl].size != 0) {
 461                                 ko->ko_reltab[rl].nrel =
 462                                     shdr[i].sh_size / sizeof(Elf_Rel);
 463                                 ko->ko_reltab[rl].sec = shdr[i].sh_info;
 464                                 error = ko->ko_read(ko,
 465                                     (void **)&ko->ko_reltab[rl].rel,
 466                                     ko->ko_reltab[rl].size,
 467                                     shdr[i].sh_offset, true);
 468                                 if (error != 0) {
 469                                         goto out;
 470                                 }
 471                         }
 472                         rl++;
 473                         break;
 474                 case SHT_RELA:
 475                         ko->ko_relatab[ra].size = shdr[i].sh_size;
 476                         ko->ko_relatab[ra].size -=
 477                             shdr[i].sh_size % sizeof(Elf_Rela);
 478                         if (ko->ko_relatab[ra].size != 0) {
 479                                 ko->ko_relatab[ra].nrela =
 480                                     shdr[i].sh_size / sizeof(Elf_Rela);
 481                                 ko->ko_relatab[ra].sec = shdr[i].sh_info;
 482                                 error = ko->ko_read(ko,
 483                                     (void **)&ko->ko_relatab[ra].rela,
 484                                     shdr[i].sh_size,
 485                                     shdr[i].sh_offset, true);
 486                                 if (error != 0) {
 487                                         goto out;
 488                                 }
 489                         }
 490                         ra++;
 491                         break;
 492                 default:
 493                         break;
 494                 }
 495         }
 496         if (pb != ko->ko_nprogtab) {
 497                 panic("lost progbits");
 498         }
 499         if (rl != ko->ko_nrel) {
 500                 panic("lost rel");
 501         }
 502         if (ra != ko->ko_nrela) {
 503                 panic("lost rela");
 504         }
 505         if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) {
 506                 panic("mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n",
 507                     (long)mapbase, (long)ko->ko_address, (long)mapsize,
 508                     (long)ko->ko_address + mapsize);
 509         }
 510
 511         /*
 512          * Perform local relocations only.  Relocations relating to global
 513          * symbols will be done by kobj_affix().
 514          */
 515         error = kobj_checksyms(ko, false);
 516         if (error == 0) {
 517                 error = kobj_relocate(ko, true);
 518         }
 519  out:
 520         if (hdr != NULL) {
 521                 kobj_free(ko, hdr, sizeof(*hdr));
 522         }
 523         kobj_close(ko);
 524         if (error != 0) {
 525                 kobj_unload(ko);
 526         }
 527
 528         return error;
 529 }
 530
 531 /*
 532  * kobj_unload:
 533  *
 534  *      Unload an object previously loaded by kobj_load().
 535  */
 536 void
 537 kobj_unload(kobj_t ko)
 538 {
 539         int error;
 540
 541         kobj_close(ko);
 542         kobj_jettison(ko);
 543
 544         /*
 545          * Notify MD code that a module has been unloaded.
 546          */
 547         if (ko->ko_loaded) {
 548                 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
 549                     false);
 550                 if (error != 0) {
 551                         kobj_error("machine dependent deinit failed");
 552                 }
 553         }
 554         if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) {
 555                 uvm_km_free(module_map, ko->ko_address, round_page(ko->ko_size),
 556                     UVM_KMF_WIRED);
 557         }
 558         if (ko->ko_ksyms == true) {
 559                 ksyms_modunload(ko->ko_name);
 560         }
 561         if (ko->ko_symtab != NULL) {
 562                 kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym));
 563         }
 564         if (ko->ko_strtab != NULL) {
 565                 kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz);
 566         }
 567         if (ko->ko_progtab != NULL) {
 568                 kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab *
 569                     sizeof(*ko->ko_progtab));
 570                 ko->ko_progtab = NULL;
 571         }
 572         if (ko->ko_shstrtab) {
 573                 kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz);
 574                 ko->ko_shstrtab = NULL;
 575         }
 576
 577         kmem_free(ko, sizeof(*ko));
 578 }
 579
 580 /*
 581  * kobj_stat:
 582  *
 583  *      Return size and load address of an object.
 584  */
 585 int
 586 kobj_stat(kobj_t ko, vaddr_t *address, size_t *size)
 587 {
 588
 589         if (address != NULL) {
 590                 *address = ko->ko_address;
 591         }
 592         if (size != NULL) {
 593                 *size = ko->ko_size;
 594         }
 595         return 0;
 596 }
 597
 598 /*
 599  * kobj_affix:
 600  *
 601  *      Set an object's name and perform global relocs.  May only be
 602  *      called after the module and any requisite modules are loaded.
 603  */
 604 int
 605 kobj_affix(kobj_t ko, const char *name)
 606 {
 607         int error;
 608
 609         KASSERT(ko->ko_ksyms == false);
 610         KASSERT(ko->ko_loaded == false);
 611
 612         strlcpy(ko->ko_name, name, sizeof(ko->ko_name));
 613
 614         /* Cache addresses of undefined symbols. */
 615         error = kobj_checksyms(ko, true);
 616
 617         /* Now do global relocations. */
 618         if (error == 0)
 619                 error = kobj_relocate(ko, false);
 620
 621         /*
 622          * Now that we know the name, register the symbol table.
 623          * Do after global relocations because ksyms will pack
 624          * the table.
 625          */
 626         if (error == 0) {
 627                 ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
 628                     sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
 629                 ko->ko_ksyms = true;
 630         }
 631
 632         /* Jettison unneeded memory post-link. */
 633         kobj_jettison(ko);
 634
 635         /*
 636          * Notify MD code that a module has been loaded.
 637          *
 638          * Most architectures use this opportunity to flush their caches.
 639          */
 640         if (error == 0) {
 641                 error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
 642                     true);
 643                 if (error != 0) {
 644                         kobj_error("machine dependent init failed");
 645                 }
 646                 ko->ko_loaded = true;
 647         }
 648
 649         /* If there was an error, destroy the whole object. */
 650         if (error != 0) {
 651                 kobj_unload(ko);
 652         }
 653
 654         return error;
 655 }
 656
 657 /*
 658  * kobj_find_section:
 659  *
 660  *      Given a section name, search the loaded object and return
 661  *      virtual address if present and loaded.
 662  */
 663 int
 664 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
 665 {
 666         int i;
 667
 668         KASSERT(ko->ko_progtab != NULL);
 669
 670         for (i = 0; i < ko->ko_nprogtab; i++) {
 671                 if (strcmp(ko->ko_progtab[i].name, name) == 0) {
 672                         if (addr != NULL) {
 673                                 *addr = ko->ko_progtab[i].addr;
 674                         }
 675                         if (size != NULL) {
 676                                 *size = ko->ko_progtab[i].size;
 677                         }
 678                         return 0;
 679                 }
 680         }
 681
 682         return ENOENT;
 683 }
 684
 685 /*
 686  * kobj_jettison:
 687  *
 688  *      Release object data not needed after performing relocations.
 689  */
 690 static void
 691 kobj_jettison(kobj_t ko)
 692 {
 693         int i;
 694
 695         if (ko->ko_reltab != NULL) {
 696                 for (i = 0; i < ko->ko_nrel; i++) {
 697                         if (ko->ko_reltab[i].rel) {
 698                                 kobj_free(ko, ko->ko_reltab[i].rel,
 699                                     ko->ko_reltab[i].size);
 700                         }
 701                 }
 702                 kobj_free(ko, ko->ko_reltab, ko->ko_nrel *
 703                     sizeof(*ko->ko_reltab));
 704                 ko->ko_reltab = NULL;
 705                 ko->ko_nrel = 0;
 706         }
 707         if (ko->ko_relatab != NULL) {
 708                 for (i = 0; i < ko->ko_nrela; i++) {
 709                         if (ko->ko_relatab[i].rela) {
 710                                 kobj_free(ko, ko->ko_relatab[i].rela,
 711                                     ko->ko_relatab[i].size);
 712                         }
 713                 }
 714                 kobj_free(ko, ko->ko_relatab, ko->ko_nrela *
 715                     sizeof(*ko->ko_relatab));
 716                 ko->ko_relatab = NULL;
 717                 ko->ko_nrela = 0;
 718         }
 719         if (ko->ko_shdr != NULL) {
 720                 kobj_free(ko, ko->ko_shdr, ko->ko_shdrsz);
 721                 ko->ko_shdr = NULL;
 722         }
 723 }
 724
 725 /*
 726  * kobj_sym_lookup:
 727  *
 728  *      Symbol lookup function to be used when the symbol index
 729  *      is known (ie during relocation).
 730  */
 731 uintptr_t
 732 kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
 733 {
 734         const Elf_Sym *sym;
 735         const char *symbol;
 736
 737         /* Don't even try to lookup the symbol if the index is bogus. */
 738         if (symidx >= ko->ko_symcnt)
 739                 return 0;
 740
 741         sym = ko->ko_symtab + symidx;
 742
 743         /* Quick answer if there is a definition included. */
 744         if (sym->st_shndx != SHN_UNDEF) {
 745                 return (uintptr_t)sym->st_value;
 746         }
 747
 748         /* If we get here, then it is undefined and needs a lookup. */
 749         switch (ELF_ST_BIND(sym->st_info)) {
 750         case STB_LOCAL:
 751                 /* Local, but undefined? huh? */
 752                 kobj_error("local symbol undefined");
 753                 return 0;
 754
 755         case STB_GLOBAL:
 756                 /* Relative to Data or Function name */
 757                 symbol = ko->ko_strtab + sym->st_name;
 758
 759                 /* Force a lookup failure if the symbol name is bogus. */
 760                 if (*symbol == 0) {
 761                         kobj_error("bad symbol name");
 762                         return 0;
 763                 }
 764
 765                 return (uintptr_t)sym->st_value;
 766
 767         case STB_WEAK:
 768                 kobj_error("weak symbols not supported\n");
 769                 return 0;
 770
 771         default:
 772                 return 0;
 773         }
 774 }
 775
 776 /*
 777  * kobj_findbase:
 778  *
 779  *      Return base address of the given section.
 780  */
 781 static uintptr_t
 782 kobj_findbase(kobj_t ko, int sec)
 783 {
 784         int i;
 785
 786         for (i = 0; i < ko->ko_nprogtab; i++) {
 787                 if (sec == ko->ko_progtab[i].sec) {
 788                         return (uintptr_t)ko->ko_progtab[i].addr;
 789                 }
 790         }
 791         return 0;
 792 }
 793
 794 /*
 795  * kobj_checksyms:
 796  *
 797  *      Scan symbol table for duplicates or resolve references to
 798  *      exernal symbols.
 799  */
 800 static int
 801 kobj_checksyms(kobj_t ko, bool undefined)
 802 {
 803         unsigned long rval;
 804         Elf_Sym *sym, *ms;
 805         const char *name;
 806         int error;
 807
 808         error = 0;
 809
 810         for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
 811                 /* Check validity of the symbol. */
 812                 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
 813                     sym->st_name == 0)
 814                         continue;
 815                 if (undefined != (sym->st_shndx == SHN_UNDEF)) {
 816                         continue;
 817                 }
 818
 819                 /*
 820                  * Look it up.  Don't need to lock, as it is known that
 821                  * the symbol tables aren't going to change (we hold
 822                  * module_lock).
 823                  */
 824                 name = ko->ko_strtab + sym->st_name;
 825                 if (ksyms_getval_unlocked(NULL, name, &rval,
 826                     KSYMS_EXTERN) != 0) {
 827                         if (undefined) {
 828                                 kobj_error("symbol `%s' not found", name);
 829                                 error = ENOEXEC;
 830                         }
 831                         continue;
 832                 }
 833
 834                 /* Save values of undefined globals. */
 835                 if (undefined) {
 836                         sym->st_value = (Elf_Addr)rval;
 837                         continue;
 838                 }
 839
 840                 /* Check (and complain) about differing values. */
 841                 if (sym->st_value == rval) {
 842                         continue;
 843                 }
 844                 if (strcmp(name, "_bss_start") == 0 ||
 845                     strcmp(name, "__bss_start") == 0 ||
 846                     strcmp(name, "_bss_end__") == 0 ||
 847                     strcmp(name, "__bss_end__") == 0 ||
 848                     strcmp(name, "_edata") == 0 ||
 849                     strcmp(name, "_end") == 0 ||
 850                     strcmp(name, "__end") == 0 ||
 851                     strcmp(name, "__end__") == 0 ||
 852                     strncmp(name, "__start_link_set_", 17) == 0 ||
 853                     strncmp(name, "__stop_link_set_", 16)) {
 854                         continue;
 855                 }
 856                 kobj_error("global symbol `%s' redefined\n", name);
 857                 error = ENOEXEC;
 858         }
 859
 860         return error;
 861 }
 862
 863 /*
 864  * kobj_relocate:
 865  *
 866  *      Resolve relocations for the loaded object.
 867  */
 868 static int
 869 kobj_relocate(kobj_t ko, bool local)
 870 {
 871         const Elf_Rel *rellim;
 872         const Elf_Rel *rel;
 873         const Elf_Rela *relalim;
 874         const Elf_Rela *rela;
 875         const Elf_Sym *sym;
 876         uintptr_t base;
 877         int i, error;
 878         uintptr_t symidx;
 879
 880         /*
 881          * Perform relocations without addend if there are any.
 882          */
 883         for (i = 0; i < ko->ko_nrel; i++) {
 884                 rel = ko->ko_reltab[i].rel;
 885                 if (rel == NULL) {
 886                         continue;
 887                 }
 888                 rellim = rel + ko->ko_reltab[i].nrel;
 889                 base = kobj_findbase(ko, ko->ko_reltab[i].sec);
 890                 if (base == 0) {
 891                         panic("lost base for e_reltab");
 892                 }
 893                 for (; rel < rellim; rel++) {
 894                         symidx = ELF_R_SYM(rel->r_info);
 895                         if (symidx >= ko->ko_symcnt) {
 896                                 continue;
 897                         }
 898                         sym = ko->ko_symtab + symidx;
 899                         if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 900                                 continue;
 901                         }
 902                         error = kobj_reloc(ko, base, rel, false, local);
 903                         if (error != 0) {
 904                                 return ENOENT;
 905                         }
 906                 }
 907         }
 908
 909         /*
 910          * Perform relocations with addend if there are any.
 911          */
 912         for (i = 0; i < ko->ko_nrela; i++) {
 913                 rela = ko->ko_relatab[i].rela;
 914                 if (rela == NULL) {
 915                         continue;
 916                 }
 917                 relalim = rela + ko->ko_relatab[i].nrela;
 918                 base = kobj_findbase(ko, ko->ko_relatab[i].sec);
 919                 if (base == 0) {
 920                         panic("lost base for e_relatab");
 921                 }
 922                 for (; rela < relalim; rela++) {
 923                         symidx = ELF_R_SYM(rela->r_info);
 924                         if (symidx >= ko->ko_symcnt) {
 925                                 continue;
 926                         }
 927                         sym = ko->ko_symtab + symidx;
 928                         if (local != (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) {
 929                                 continue;
 930                         }
 931                         error = kobj_reloc(ko, base, rela, true, local);
 932                         if (error != 0) {
 933                                 return ENOENT;
 934                         }
 935                 }
 936         }
 937
 938         return 0;
 939 }
 940
 941 /*
 942  * kobj_error:
 943  *
 944  *      Utility function: log an error.
 945  */
 946 static void
 947 kobj_error(const char *fmt, ...)
 948 {
 949         va_list ap;
 950
 951         va_start(ap, fmt);
 952         printf("WARNING: linker error: ");
 953         vprintf(fmt, ap);
 954         printf("\n");
 955         va_end(ap);
 956 }
 957
 958 static int
 959 kobj_read_mem(kobj_t ko, void **basep, size_t size, off_t off,
 960         bool allocate)
 961 {
 962         void *base = *basep;
 963         int error;
 964
 965         if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
 966                 kobj_error("kobj_read_mem: preloaded object short");
 967                 error = EINVAL;
 968                 base = NULL;
 969         } else if (allocate) {
 970                 base = (uint8_t *)ko->ko_source + off;
 971                 error = 0;
 972         } else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
 973                 kobj_error("kobj_read_mem: object not aligned");
 974                 kobj_error("source=%p base=%p off=%d size=%zd",
 975                     ko->ko_source, base, (int)off, size);
 976                 error = EINVAL;
 977         } else {
 978                 /* Nothing to do.  Loading in-situ. */
 979                 error = 0;
 980         }
 981
 982         if (allocate)
 983                 *basep = base;
 984
 985         return error;
 986 }
 987
 988 /*
 989  * kobj_free:
 990  *
 991  *      Utility function: free memory if it was allocated from the heap.
 992  */
 993 static void
 994 kobj_free(kobj_t ko, void *base, size_t size)
 995 {
 996
 997         if (ko->ko_type != KT_MEMORY)
 998                 kmem_free(base, size);
 999 }
1000
1001 #else   /* MODULAR */
1002
1003 int
1004 kobj_load_mem(kobj_t *kop, void *base, ssize_t size)
1005 {
1006
1007         return ENOSYS;
1008 }
1009
1010 void
1011 kobj_unload(kobj_t ko)
1012 {
1013
1014         panic("not modular");
1015 }
1016
1017 int
1018 kobj_stat(kobj_t ko, vaddr_t *base, size_t *size)
1019 {
1020
1021         return ENOSYS;
1022 }
1023
1024 int
1025 kobj_affix(kobj_t ko, const char *name)
1026 {
1027
1028         panic("not modular");
1029 }
1030
1031 int
1032 kobj_find_section(kobj_t ko, const char *name, void **addr, size_t *size)
1033 {
1034
1035         panic("not modular");
1036 }
1037
1038 #endif  /* MODULAR */