static int
kobj_read_mem(kobj_t ko, void **basep, size_t size, off_t off,
bool allocate)
{
void *base = *basep;
int error;
if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
kobj_error(__func__, __LINE__, ko, "preloaded object short");
error = EINVAL;
base = NULL;
} else if (allocate) {
base = (uint8_t *)ko->ko_source + off;
error = 0;
} else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
kobj_error(__func__, __LINE__, ko, "object not aligned");
kobj_error(__func__, __LINE__, ko, "source=%p base=%p off=%d "
"size=%zu", ko->ko_source, base, (int)off, size);
error = EINVAL;
} else {
/* Nothing to do. Loading in-situ. */
error = 0;
}
if (allocate)
*basep = base;
return error;
}
/*
* kobj_sym_lookup:
*
* Symbol lookup function to be used when the symbol index
* is known (ie during relocation).
*/
uintptr_t
kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
{
const Elf_Sym *sym;
const char *symbol;
int error;
u_long addr;
/* Don't even try to lookup the symbol if the index is bogus. */
if (symidx >= ko->ko_symcnt)
return 0;
sym = ko->ko_symtab + symidx;
/* Quick answer if there is a definition included. */
if (sym->st_shndx != SHN_UNDEF) {
return sym->st_value;
}
/* If we get here, then it is undefined and needs a lookup. */
switch (ELF_ST_BIND(sym->st_info)) {
case STB_LOCAL:
/* Local, but undefined? huh? */
kobj_error("local symbol undefined");
return 0;
case STB_GLOBAL:
/* Relative to Data or Function name */
symbol = ko->ko_strtab + sym->st_name;
/* Force a lookup failure if the symbol name is bogus. */
if (*symbol == 0) {
kobj_error("bad symbol name");
return 0;
}
/*
* Don't need to lock, as it is known that the symbol
* tables aren't going to change (we hold module_lock).
*/
error = ksyms_getval(NULL, symbol, &addr, KSYMS_ANY);
if (error != 0) {
kobj_error("symbol `%s' not found", symbol);
return (uintptr_t)0;
}
return (uintptr_t)addr;
case STB_WEAK:
kobj_error("weak symbols not supported\n");
return 0;
default:
return 0;
}
}
/*
* kobj_sym_lookup:
*
* Symbol lookup function to be used when the symbol index
* is known (ie during relocation).
*/
uintptr_t
kobj_sym_lookup(kobj_t ko, uintptr_t symidx)
{
const Elf_Sym *sym;
const char *symbol;
/* Don't even try to lookup the symbol if the index is bogus. */
if (symidx >= ko->ko_symcnt)
return 0;
sym = ko->ko_symtab + symidx;
/* Quick answer if there is a definition included. */
if (sym->st_shndx != SHN_UNDEF) {
return (uintptr_t)sym->st_value;
}
/* If we get here, then it is undefined and needs a lookup. */
switch (ELF_ST_BIND(sym->st_info)) {
case STB_LOCAL:
/* Local, but undefined? huh? */
kobj_error(__func__, __LINE__, ko, "local symbol undefined");
return 0;
case STB_GLOBAL:
/* Relative to Data or Function name */
symbol = ko->ko_strtab + sym->st_name;
/* Force a lookup failure if the symbol name is bogus. */
if (*symbol == 0) {
kobj_error(__func__, __LINE__, ko, "bad symbol name");
return 0;
}
return (uintptr_t)sym->st_value;
case STB_WEAK:
kobj_error(__func__, __LINE__, ko,
"weak symbols not supported");
return 0;
default:
return 0;
}
}
/*
* kobj_read_bits:
*
* Utility function: load a section from the object.
*/
static int
kobj_read_bits(kobj_t ko, void *base, size_t size, off_t off)
{
size_t resid;
int error;
KASSERT(ko->ko_source != NULL);
switch (ko->ko_type) {
case KT_VNODE:
KASSERT((uintptr_t)base >= (uintptr_t)ko->ko_address);
KASSERT((uintptr_t)base + size <=
(uintptr_t)ko->ko_address + ko->ko_size);
error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
curlwp);
if (error == 0 && resid != 0) {
error = EINVAL;
}
break;
case KT_MEMORY:
if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
kobj_error("kobj_read_bits: preloaded object short");
error = EINVAL;
} else if ((uint8_t *)base != (uint8_t *)ko->ko_source + off) {
kobj_error("kobj_read_bits: object not aligned");
kobj_error("source=%p base=%p off=%d size=%zd",
ko->ko_source, base, (int)off, size);
error = EINVAL;
} else {
/* Nothing to do. Loading in-situ. */
error = 0;
}
break;
default:
panic("kobj_read: invalid type");
}
return error;
}
/*
* kobj_affix:
*
* Set an object's name and perform global relocs. May only be
* called after the module and any requisite modules are loaded.
*/
int
kobj_affix(kobj_t ko, const char *name)
{
int error;
KASSERT(ko->ko_ksyms == false);
KASSERT(ko->ko_loaded == false);
kobj_setname(ko, name);
/* Cache addresses of undefined symbols. */
error = kobj_checksyms(ko, true);
/* Now do global relocations. */
if (error == 0)
error = kobj_relocate(ko, false);
/*
* Now that we know the name, register the symbol table.
* Do after global relocations because ksyms will pack
* the table.
*/
if (error == 0) {
ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
ko->ko_ksyms = true;
}
/* Jettison unneeded memory post-link. */
kobj_jettison(ko);
/*
* Notify MD code that a module has been loaded.
*
* Most architectures use this opportunity to flush their caches.
*/
if (error == 0) {
error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
true);
if (error != 0)
kobj_error(__func__, __LINE__, ko,
"machine dependent init failed %d", error);
ko->ko_loaded = true;
}
/* If there was an error, destroy the whole object. */
if (error != 0) {
kobj_unload(ko);
}
return error;
}
/*
* kobj_read:
*
* Utility function: read from the object.
*/
static int
kobj_read(kobj_t ko, void **basep, size_t size, off_t off)
{
size_t resid;
void *base;
int error;
KASSERT(ko->ko_source != NULL);
switch (ko->ko_type) {
case KT_VNODE:
base = kmem_alloc(size, KM_SLEEP);
if (base == NULL) {
error = ENOMEM;
break;
}
error = vn_rdwr(UIO_READ, ko->ko_source, base, size, off,
UIO_SYSSPACE, IO_NODELOCKED, curlwp->l_cred, &resid,
curlwp);
if (error == 0 && resid != 0) {
error = EINVAL;
}
if (error != 0) {
kmem_free(base, size);
base = NULL;
}
break;
case KT_MEMORY:
if (ko->ko_memsize != -1 && off + size > ko->ko_memsize) {
kobj_error("kobj_read: preloaded object short");
error = EINVAL;
base = NULL;
} else {
base = (uint8_t *)ko->ko_source + off;
error = 0;
}
break;
default:
panic("kobj_read: invalid type");
}
*basep = base;
return error;
}
/*
* kobj_unload:
*
* Unload an object previously loaded by kobj_load().
*/
void
kobj_unload(kobj_t ko)
{
int error;
kobj_close(ko);
kobj_jettison(ko);
/*
* Notify MD code that a module has been unloaded.
*/
if (ko->ko_loaded) {
error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
false);
if (error != 0)
kobj_error(__func__, __LINE__, ko,
"machine dependent deinit failed %d", error);
}
if (ko->ko_address != 0 && ko->ko_type != KT_MEMORY) {
uvm_km_free(module_map, ko->ko_address, round_page(ko->ko_size),
UVM_KMF_WIRED);
}
if (ko->ko_ksyms == true) {
ksyms_modunload(ko->ko_name);
}
if (ko->ko_symtab != NULL) {
kobj_free(ko, ko->ko_symtab, ko->ko_symcnt * sizeof(Elf_Sym));
}
if (ko->ko_strtab != NULL) {
kobj_free(ko, ko->ko_strtab, ko->ko_strtabsz);
}
if (ko->ko_progtab != NULL) {
kobj_free(ko, ko->ko_progtab, ko->ko_nprogtab *
sizeof(*ko->ko_progtab));
ko->ko_progtab = NULL;
}
if (ko->ko_shstrtab) {
kobj_free(ko, ko->ko_shstrtab, ko->ko_shstrtabsz);
ko->ko_shstrtab = NULL;
}
kmem_free(ko, sizeof(*ko));
}
/*
* kobj_checkdup:
*
* Scan symbol table for duplicates.
*/
static int
kobj_checkdup(kobj_t ko)
{
unsigned long rval;
Elf_Sym *sym, *ms;
const char *name;
bool dup;
dup = false;
for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
/* Check validity of the symbol. */
if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
sym->st_name == 0)
continue;
/* Check if the symbol already exists */
name = ko->ko_strtab + sym->st_name;
if (ksyms_getval(NULL, name, &rval, KSYMS_EXTERN) != 0) {
continue;
}
/* Check (and complain) about differing values */
if (sym->st_value == rval || sym->st_shndx == SHN_UNDEF) {
continue;
}
if (strcmp(name, "_bss_start") == 0 ||
strcmp(name, "__bss_start") == 0 ||
strcmp(name, "_bss_end__") == 0 ||
strcmp(name, "__bss_end__") == 0 ||
strcmp(name, "_edata") == 0 ||
strcmp(name, "_end") == 0 ||
strcmp(name, "__end") == 0 ||
strcmp(name, "__end__") == 0 ||
strncmp(name, "__start_link_set_", 17) == 0 ||
strncmp(name, "__stop_link_set_", 16)) {
continue;
}
kobj_error("global symbol `%s' redefined\n", name);
dup = true;
}
return dup ? EEXIST : 0;
}
/*
* kobj_affix:
*
* Set an object's name and perform global relocs. May only be
* called after the module and any requisite modules are loaded.
*/
int
kobj_affix(kobj_t ko, const char *name)
{
int error;
KASSERT(ko->ko_ksyms == false);
KASSERT(ko->ko_loaded == false);
strlcpy(ko->ko_name, name, sizeof(ko->ko_name));
/* Now do global relocations. */
error = kobj_relocate(ko, false);
/*
* Now that we know the name, register the symbol table.
* Do after global relocations because ksyms will pack it.
*/
ksyms_modload(ko->ko_name, ko->ko_symtab, ko->ko_symcnt *
sizeof(Elf_Sym), ko->ko_strtab, ko->ko_strtabsz);
ko->ko_ksyms = true;
/* Jettison unneeded memory post-link. */
kobj_jettison(ko);
/* Notify MD code that a module has been loaded. */
if (error == 0) {
error = kobj_machdep(ko, (void *)ko->ko_address, ko->ko_size,
true);
if (error != 0) {
kobj_error("machine dependent init failed");
}
ko->ko_loaded = true;
}
/* If there was an error, destroy the whole object. */
if (error != 0) {
kobj_unload(ko);
}
return error;
}
/*
* kobj_checksyms:
*
* Scan symbol table for duplicates or resolve references to
* exernal symbols.
*/
static int
kobj_checksyms(kobj_t ko, bool undefined)
{
unsigned long rval;
Elf_Sym *sym, *ms;
const char *name;
int error;
error = 0;
for (ms = (sym = ko->ko_symtab) + ko->ko_symcnt; sym < ms; sym++) {
/* Check validity of the symbol. */
if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL ||
sym->st_name == 0)
continue;
if (undefined != (sym->st_shndx == SHN_UNDEF)) {
continue;
}
/*
* Look it up. Don't need to lock, as it is known that
* the symbol tables aren't going to change (we hold
* module_lock).
*/
name = ko->ko_strtab + sym->st_name;
if (ksyms_getval_unlocked(NULL, name, &rval,
KSYMS_EXTERN) != 0) {
if (undefined) {
kobj_error(__func__, __LINE__, ko,
"symbol `%s' not found", name);
error = ENOEXEC;
}
continue;
}
/* Save values of undefined globals. */
if (undefined) {
sym->st_value = (Elf_Addr)rval;
continue;
}
/* Check (and complain) about differing values. */
if (sym->st_value == rval) {
continue;
}
if (strcmp(name, "_bss_start") == 0 ||
strcmp(name, "__bss_start") == 0 ||
strcmp(name, "_bss_end__") == 0 ||
strcmp(name, "__bss_end__") == 0 ||
strcmp(name, "_edata") == 0 ||
strcmp(name, "_end") == 0 ||
strcmp(name, "__end") == 0 ||
strcmp(name, "__end__") == 0 ||
strncmp(name, "__start_link_set_", 17) == 0 ||
strncmp(name, "__stop_link_set_", 16)) {
continue;
}
kobj_error(__func__, __LINE__, ko,
"global symbol `%s' redefined", name);
error = ENOEXEC;
}
return error;
}
/*
* kobj_load:
*
* Load an ELF object and prepare to link into the running kernel
* image.
*/
int
kobj_load(kobj_t ko)
{
Elf_Ehdr *hdr;
Elf_Shdr *shdr;
Elf_Sym *es;
vaddr_t mapbase;
size_t mapsize;
int error;
int symtabindex;
int symstrindex;
int nsym;
int pb, rl, ra;
int alignmask;
int i, j;
void *addr;
KASSERT(ko->ko_type != KT_UNSET);
KASSERT(ko->ko_source != NULL);
shdr = NULL;
mapsize = 0;
error = 0;
hdr = NULL;
/*
* Read the elf header from the file.
*/
error = ko->ko_read(ko, (void **)&hdr, sizeof(*hdr), 0, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "read failed %d", error);
goto out;
}
if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
kobj_error(__func__, __LINE__, ko, "not an ELF object");
error = ENOEXEC;
goto out;
}
if (hdr->e_ident[EI_VERSION] != EV_CURRENT ||
hdr->e_version != EV_CURRENT) {
kobj_error(__func__, __LINE__, ko,
"unsupported file version %d", hdr->e_ident[EI_VERSION]);
error = ENOEXEC;
goto out;
}
if (hdr->e_type != ET_REL) {
kobj_error(__func__, __LINE__, ko, "unsupported file type %d",
hdr->e_type);
error = ENOEXEC;
goto out;
}
switch (hdr->e_machine) {
#if ELFSIZE == 32
ELF32_MACHDEP_ID_CASES
#elif ELFSIZE == 64
ELF64_MACHDEP_ID_CASES
#else
#error not defined
#endif
default:
kobj_error(__func__, __LINE__, ko, "unsupported machine %d",
hdr->e_machine);
error = ENOEXEC;
goto out;
}
ko->ko_nprogtab = 0;
ko->ko_shdr = 0;
ko->ko_nrel = 0;
ko->ko_nrela = 0;
/*
* Allocate and read in the section header.
*/
ko->ko_shdrsz = hdr->e_shnum * hdr->e_shentsize;
if (ko->ko_shdrsz == 0 || hdr->e_shoff == 0 ||
hdr->e_shentsize != sizeof(Elf_Shdr)) {
kobj_error(__func__, __LINE__, ko, "bad sizes");
error = ENOEXEC;
goto out;
}
error = ko->ko_read(ko, (void **)&shdr, ko->ko_shdrsz, hdr->e_shoff,
true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "read failed %d", error);
goto out;
}
ko->ko_shdr = shdr;
/*
* Scan the section header for information and table sizing.
*/
nsym = 0;
symtabindex = -1;
symstrindex = -1;
for (i = 0; i < hdr->e_shnum; i++) {
switch (shdr[i].sh_type) {
case SHT_PROGBITS:
case SHT_NOBITS:
ko->ko_nprogtab++;
break;
case SHT_SYMTAB:
nsym++;
symtabindex = i;
symstrindex = shdr[i].sh_link;
break;
case SHT_REL:
if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS)
continue;
ko->ko_nrel++;
break;
case SHT_RELA:
if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS)
continue;
ko->ko_nrela++;
break;
case SHT_STRTAB:
break;
}
}
if (ko->ko_nprogtab == 0) {
kobj_error(__func__, __LINE__, ko, "file has no contents");
error = ENOEXEC;
goto out;
}
if (nsym != 1) {
/* Only allow one symbol table for now */
kobj_error(__func__, __LINE__, ko,
"file has no valid symbol table");
error = ENOEXEC;
goto out;
}
if (symstrindex < 0 || symstrindex > hdr->e_shnum ||
shdr[symstrindex].sh_type != SHT_STRTAB) {
kobj_error(__func__, __LINE__, ko,
"file has invalid symbol strings");
error = ENOEXEC;
goto out;
}
/*
* Allocate space for tracking the load chunks.
*/
if (ko->ko_nprogtab != 0) {
ko->ko_progtab = kmem_zalloc(ko->ko_nprogtab *
sizeof(*ko->ko_progtab), KM_SLEEP);
if (ko->ko_progtab == NULL) {
error = ENOMEM;
kobj_error(__func__, __LINE__, ko, "out of memory");
goto out;
}
}
if (ko->ko_nrel != 0) {
ko->ko_reltab = kmem_zalloc(ko->ko_nrel *
sizeof(*ko->ko_reltab), KM_SLEEP);
if (ko->ko_reltab == NULL) {
error = ENOMEM;
kobj_error(__func__, __LINE__, ko, "out of memory");
goto out;
}
}
if (ko->ko_nrela != 0) {
ko->ko_relatab = kmem_zalloc(ko->ko_nrela *
sizeof(*ko->ko_relatab), KM_SLEEP);
if (ko->ko_relatab == NULL) {
error = ENOMEM;
kobj_error(__func__, __LINE__, ko, "out of memory");
goto out;
}
}
if (symtabindex == -1) {
kobj_error(__func__, __LINE__, ko, "lost symbol table index");
goto out;
}
/*
* Allocate space for and load the symbol table.
*/
ko->ko_symcnt = shdr[symtabindex].sh_size / sizeof(Elf_Sym);
if (ko->ko_symcnt == 0) {
kobj_error(__func__, __LINE__, ko, "no symbol table");
goto out;
}
error = ko->ko_read(ko, (void **)&ko->ko_symtab,
ko->ko_symcnt * sizeof(Elf_Sym),
shdr[symtabindex].sh_offset, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "read failed %d", error);
goto out;
}
/*
* Allocate space for and load the symbol strings.
*/
ko->ko_strtabsz = shdr[symstrindex].sh_size;
if (ko->ko_strtabsz == 0) {
kobj_error(__func__, __LINE__, ko, "no symbol strings");
goto out;
}
error = ko->ko_read(ko, (void *)&ko->ko_strtab, ko->ko_strtabsz,
shdr[symstrindex].sh_offset, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "read failed %d", error);
goto out;
}
/*
* Adjust module symbol namespace, if necessary (e.g. with rump)
*/
error = kobj_renamespace(ko->ko_symtab, ko->ko_symcnt,
&ko->ko_strtab, &ko->ko_strtabsz);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "renamespace failed %d",
error);
goto out;
}
/*
* Do we have a string table for the section names?
*/
if (hdr->e_shstrndx != 0 && shdr[hdr->e_shstrndx].sh_size != 0 &&
shdr[hdr->e_shstrndx].sh_type == SHT_STRTAB) {
ko->ko_shstrtabsz = shdr[hdr->e_shstrndx].sh_size;
error = ko->ko_read(ko, (void **)&ko->ko_shstrtab,
shdr[hdr->e_shstrndx].sh_size,
shdr[hdr->e_shstrndx].sh_offset, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko, "read failed %d",
error);
goto out;
}
}
/*
* Size up code/data(progbits) and bss(nobits).
*/
alignmask = 0;
mapbase = 0;
for (i = 0; i < hdr->e_shnum; i++) {
switch (shdr[i].sh_type) {
case SHT_PROGBITS:
case SHT_NOBITS:
if (mapbase == 0)
mapbase = shdr[i].sh_offset;
alignmask = shdr[i].sh_addralign - 1;
mapsize += alignmask;
mapsize &= ~alignmask;
mapsize += shdr[i].sh_size;
break;
}
}
/*
* We know how much space we need for the text/data/bss/etc.
* This stuff needs to be in a single chunk so that profiling etc
* can get the bounds and gdb can associate offsets with modules.
*/
if (mapsize == 0) {
kobj_error(__func__, __LINE__, ko, "no text/data/bss");
goto out;
}
if (ko->ko_type == KT_MEMORY) {
mapbase += (vaddr_t)ko->ko_source;
} else {
mapbase = uvm_km_alloc(module_map, round_page(mapsize),
0, UVM_KMF_WIRED | UVM_KMF_EXEC);
if (mapbase == 0) {
kobj_error(__func__, __LINE__, ko, "out of memory");
error = ENOMEM;
goto out;
}
}
ko->ko_address = mapbase;
ko->ko_size = mapsize;
/*
* Now load code/data(progbits), zero bss(nobits), allocate space
* for and load relocs
*/
pb = 0;
rl = 0;
ra = 0;
alignmask = 0;
for (i = 0; i < hdr->e_shnum; i++) {
switch (shdr[i].sh_type) {
case SHT_PROGBITS:
case SHT_NOBITS:
alignmask = shdr[i].sh_addralign - 1;
if (ko->ko_type == KT_MEMORY) {
addr = (void *)(shdr[i].sh_offset +
(vaddr_t)ko->ko_source);
if (((vaddr_t)addr & alignmask) != 0) {
kobj_error(__func__, __LINE__, ko,
"section %d not aligned",
i);
goto out;
}
} else {
mapbase += alignmask;
mapbase &= ~alignmask;
addr = (void *)mapbase;
mapbase += shdr[i].sh_size;
}
ko->ko_progtab[pb].addr = addr;
if (shdr[i].sh_type == SHT_PROGBITS) {
ko->ko_progtab[pb].name = "<<PROGBITS>>";
error = ko->ko_read(ko, &addr,
shdr[i].sh_size, shdr[i].sh_offset, false);
if (error != 0) {
kobj_error(__func__, __LINE__, ko,
"read failed %d", error);
goto out;
}
} else if (ko->ko_type == KT_MEMORY &&
shdr[i].sh_size != 0) {
kobj_error(__func__, __LINE__, ko,
"non-loadable BSS "
"section in pre-loaded module");
error = EINVAL;
goto out;
} else {
ko->ko_progtab[pb].name = "<<NOBITS>>";
memset(addr, 0, shdr[i].sh_size);
}
ko->ko_progtab[pb].size = shdr[i].sh_size;
ko->ko_progtab[pb].sec = i;
if (ko->ko_shstrtab != NULL && shdr[i].sh_name != 0) {
ko->ko_progtab[pb].name =
ko->ko_shstrtab + shdr[i].sh_name;
}
/* Update all symbol values with the offset. */
for (j = 0; j < ko->ko_symcnt; j++) {
es = &ko->ko_symtab[j];
if (es->st_shndx != i) {
continue;
}
es->st_value += (Elf_Addr)addr;
}
pb++;
break;
case SHT_REL:
if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS)
break;
ko->ko_reltab[rl].size = shdr[i].sh_size;
ko->ko_reltab[rl].size -=
shdr[i].sh_size % sizeof(Elf_Rel);
if (ko->ko_reltab[rl].size != 0) {
ko->ko_reltab[rl].nrel =
shdr[i].sh_size / sizeof(Elf_Rel);
ko->ko_reltab[rl].sec = shdr[i].sh_info;
error = ko->ko_read(ko,
(void **)&ko->ko_reltab[rl].rel,
ko->ko_reltab[rl].size,
shdr[i].sh_offset, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko,
"read failed %d", error);
goto out;
}
}
rl++;
break;
case SHT_RELA:
if (shdr[shdr[i].sh_info].sh_type != SHT_PROGBITS)
break;
ko->ko_relatab[ra].size = shdr[i].sh_size;
ko->ko_relatab[ra].size -=
shdr[i].sh_size % sizeof(Elf_Rela);
if (ko->ko_relatab[ra].size != 0) {
ko->ko_relatab[ra].nrela =
shdr[i].sh_size / sizeof(Elf_Rela);
ko->ko_relatab[ra].sec = shdr[i].sh_info;
error = ko->ko_read(ko,
(void **)&ko->ko_relatab[ra].rela,
shdr[i].sh_size,
shdr[i].sh_offset, true);
if (error != 0) {
kobj_error(__func__, __LINE__, ko,
"read failed %d", error);
goto out;
}
}
ra++;
break;
default:
break;
}
}
if (pb != ko->ko_nprogtab) {
panic("%s:%d: %s: lost progbits", __func__, __LINE__,
ko->ko_name);
}
if (rl != ko->ko_nrel) {
panic("%s:%d: %s: lost rel", __func__, __LINE__,
ko->ko_name);
}
if (ra != ko->ko_nrela) {
panic("%s:%d: %s: lost rela", __func__, __LINE__,
ko->ko_name);
}
if (ko->ko_type != KT_MEMORY && mapbase != ko->ko_address + mapsize) {
panic("%s:%d: %s: "
"mapbase 0x%lx != address %lx + mapsize %ld (0x%lx)\n",
__func__, __LINE__, ko->ko_name,
(long)mapbase, (long)ko->ko_address, (long)mapsize,
(long)ko->ko_address + mapsize);
}
/*
* Perform local relocations only. Relocations relating to global
* symbols will be done by kobj_affix().
*/
error = kobj_checksyms(ko, false);
if (error == 0) {
error = kobj_relocate(ko, true);
}
out:
if (hdr != NULL) {
kobj_free(ko, hdr, sizeof(*hdr));
}
kobj_close(ko);
if (error != 0) {
kobj_unload(ko);
}
return error;
}
