/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2010 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <libelf.h> #include <dlfcn.h> #include "machdep.h" #include "reloc.h" #include "msg.h" #include "_librtld.h" #include "alist.h" static const char *unknown = 0; /* Stash MSG_INTL(MSG_STR_UNKNOWN) */ /* * Process all relocation records. A new `Reloc' structure is allocated to * cache the processing decisions deduced, and these will be applied during * update_reloc(). * A count of the number of null relocations (i.e., relocations that will be * fixed and whoes records will be nulled out), data and function relocations * is maintained. This allows the relocation records themselves to be * rearranged (localized) later if necessary. Note that the number of function * relocations, although coounted, shouldn't differ from the original file, * the index of a .plt must be maintained to the index of its relocation record * within the associated relocation section. * * The intention behind this file is to maintain as much relocation logic as * possible in a generic form. */ int count_reloc(Cache *cache, Cache *_cache, Rt_map *lmp, int flags, Addr addr, Xword *null, Xword *data, Xword *func, Alist *nodirect) { Rel *rel; Reloc *reloc; Shdr *shdr; Xword ent, cnt, _cnt; Sym *syms; const char *strs; Cache *__cache; Xword pltndx = 0; /* * Determine the number of relocation entries we'll be dealing with. */ shdr = _cache->c_shdr; rel = (Rel *)_cache->c_data->d_buf; ent = shdr->sh_entsize; cnt = shdr->sh_size / ent; /* * Allocate a relocation structure for this relocation section. */ if ((reloc = calloc(cnt, sizeof (Reloc))) == 0) return (1); _cache->c_info = (void *)reloc; /* * Determine the relocations associated symbol and string table. */ __cache = &cache[shdr->sh_link]; syms = (Sym *)__cache->c_data->d_buf; shdr = __cache->c_shdr; __cache = &cache[shdr->sh_link]; strs = (const char *)__cache->c_data->d_buf; /* * Loop through the relocation table. */ for (_cnt = 0; _cnt < cnt; _cnt++, reloc++, rel = (Rel *)((uintptr_t)rel + ent)) { const char *name; /* LINTED */ uchar_t type = (uchar_t)ELF_R_TYPE(rel->r_info, M_MACH); uchar_t bind; ulong_t offset = rel->r_offset + addr; Rt_map *_lmp; int _bound, _weak; ulong_t rsymndx = ELF_R_SYM(rel->r_info); Slookup sl; Sresult sr; uint_t binfo; Sym *_sym, *sym = (syms + rsymndx); if (type == M_R_JMP_SLOT) reloc->r_pltndx = ++pltndx; /* * Analyze the case where no relocations are to be applied. */ if ((flags & RTLD_REL_ALL) == 0) { /* * Don't apply any relocations to the new image but * insure their offsets are incremented to reflect any * new fixed address. */ reloc->r_flags = FLG_R_INC; /* * Undo any relocations that might have already been * applied to the memory image. */ if (flags & RTLD_MEMORY) { reloc->r_flags |= FLG_R_UNDO; /* * If a copy relocation is involved we'll need * to know the size of the copy. */ if (type == M_R_COPY) reloc->r_size = sym->st_size; else reloc->r_size = 0; } /* * Save the objects new address. */ reloc->r_value = addr; if (type == M_R_JMP_SLOT) (*func)++; else (*data)++; continue; } /* * Determine the symbol binding of the relocation. Don't assume * that relative relocations are simply M_R_RELATIVE. Although * a pic generated shared object can normally be viewed as * having relative and non-relative relocations, a non-pic * shared object will contain a number of relocations against * local symbols (normally sections). If a relocation is * against a local symbol it qualifies as a relative relocation. */ if ((type == M_R_RELATIVE) || (type == M_R_NONE) || (ELF_ST_BIND(sym->st_info) == STB_LOCAL)) bind = STB_LOCAL; else bind = STB_GLOBAL; /* * Analyze the case where only relative relocations are to be * applied. */ if ((flags & RTLD_REL_ALL) == RTLD_REL_RELATIVE) { if (flags & RTLD_MEMORY) { if (bind == STB_LOCAL) { /* * Save the relative relocations from * the memory image. The data itself * might already have been relocated, * thus clear the relocation record so * that it will not be performed again. */ reloc->r_flags = FLG_R_CLR; (*null)++; } else { /* * Any non-relative relocation must be * undone, and the relocation records * offset updated to any new fixed * address. */ reloc->r_flags = (FLG_R_UNDO | FLG_R_INC); reloc->r_value = addr; if (type == M_R_JMP_SLOT) (*func)++; else (*data)++; } } else { if (bind == STB_LOCAL) { /* * Apply relative relocation to the * file image. Clear the relocation * record so that it will not be * performed again. */ reloc->r_flags = (FLG_R_APPLY | FLG_R_CLR); reloc->r_value = addr; if (IS_PC_RELATIVE(type)) reloc->r_value -= offset; if (unknown == 0) unknown = MSG_INTL(MSG_STR_UNKNOWN); reloc->r_name = unknown; (*null)++; } else { /* * Any non-relative relocation should be * left alone, but its offset should be * updated to any new fixed address. */ reloc->r_flags = FLG_R_INC; reloc->r_value = addr; if (type == M_R_JMP_SLOT) (*func)++; else (*data)++; } } continue; } /* * Analyze the case where more than just relative relocations * are to be applied. */ if (bind == STB_LOCAL) { if (flags & RTLD_MEMORY) { /* * Save the relative relocations from the memory * image. The data itself has already been * relocated, thus clear the relocation record * so that it will not be performed again. */ reloc->r_flags = FLG_R_CLR; } else { /* * Apply relative relocation to the file image. * Clear the relocation record so that it will * not be performed again. */ reloc->r_flags = (FLG_R_APPLY | FLG_R_CLR); reloc->r_value = addr; if (IS_PC_RELATIVE(type)) reloc->r_value -= offset; if (unknown == 0) unknown = MSG_INTL(MSG_STR_UNKNOWN); reloc->r_name = unknown; } (*null)++; continue; } /* * At this point we're dealing with a non-relative relocation * that requires the symbol definition. */ name = strs + sym->st_name; /* * Find the symbol. As the object being investigated is already * a part of this process, the symbol lookup will likely * succeed. However, because of lazy binding, there is still * the possibility of a dangling .plt relocation. dldump() * users might be encouraged to set LD_FLAGS=loadavail (crle(1) * does this for them). * * Initialize the symbol lookup, and symbol result, data * structures. */ SLOOKUP_INIT(sl, name, lmp, LIST(lmp)->lm_head, ld_entry_cnt, 0, rsymndx, sym, type, LKUP_STDRELOC); SRESULT_INIT(sr, name); _bound = _weak = 0; _sym = sym; if (lookup_sym(&sl, &sr, &binfo, NULL)) { _lmp = sr.sr_dmap; sym = sr.sr_sym; /* * Determine from the various relocation requirements * whether this binding is appropriate. If we're called * from crle(1), RTLD_CONFSET is set, then only inspect * objects selected from the configuration file * (FL1_RT_CONFSET was set during load()). */ if (!(flags & RTLD_CONFSET) || (FLAGS1(_lmp) & FL1_RT_CONFSET)) { if (((flags & RTLD_REL_ALL) == RTLD_REL_ALL) || ((flags & RTLD_REL_EXEC) && (FLAGS(_lmp) & FLG_RT_ISMAIN)) || ((flags & RTLD_REL_DEPENDS) && (!(FLAGS(_lmp) & FLG_RT_ISMAIN))) || ((flags & RTLD_REL_PRELOAD) && (FLAGS(_lmp) & FLG_RT_PRELOAD)) || ((flags & RTLD_REL_SELF) && (lmp == _lmp))) { Aliste idx; Word *ndx; _bound = 1; /* * If this symbol is explicitly defined * as nodirect, don't allow any local * binding. */ for (ALIST_TRAVERSE(nodirect, idx, ndx)) { if (*ndx == rsymndx) { _bound = 0; break; } } } } } else { /* * If this is a weak reference and we've been asked to * bind unresolved weak references consider ourself * bound. This category is typically set by clre(1) for * an application cache. */ if ((ELF_ST_BIND(_sym->st_info) == STB_WEAK) && (_sym->st_shndx == SHN_UNDEF) && (flags & RTLD_REL_WEAK)) _bound = _weak = 1; } if (flags & RTLD_MEMORY) { if (_bound) { /* * We know that all data relocations will have * been performed at process startup thus clear * the relocation record so that it will not be * performed again. However, we don't know what * function relocations have been performed * because of lazy binding - regardless, we can * leave all the function relocation records in * place, because if the function has already * been bound the record won't be referenced * anyway. In the case of using LD_BIND_NOW, * a function may be bound twice - so what. */ if (type == M_R_JMP_SLOT) { reloc->r_flags = FLG_R_INC; (*func)++; } else { if (type != M_R_COPY) reloc->r_flags = FLG_R_CLR; (*null)++; } } else { /* * Clear any unrequired relocation. */ reloc->r_flags = FLG_R_UNDO | FLG_R_INC; reloc->r_value = addr; if (type == M_R_JMP_SLOT) (*func)++; else (*data)++; } } else { if (_bound) { /* * Apply the global relocation to the file * image. Clear the relocation record so that * it will not be performed again. */ if (_weak) { reloc->r_value = 0; reloc->r_size = 0; } else { reloc->r_value = sym->st_value; if (IS_PC_RELATIVE(type)) reloc->r_value -= offset; if ((!(FLAGS(_lmp) & FLG_RT_FIXED)) && (sym->st_shndx != SHN_ABS)) reloc->r_value += ADDR(_lmp); reloc->r_size = sym->st_size; } reloc->r_flags = FLG_R_APPLY | FLG_R_CLR; reloc->r_name = name; if (type == M_R_JMP_SLOT) (*func)++; else (*null)++; } else { /* * Do not apply any unrequired relocations. */ reloc->r_flags = FLG_R_INC; reloc->r_value = addr; if (type == M_R_JMP_SLOT) (*func)++; else (*data)++; } } } return (0); } /* * Perform any relocation updates to the new image using the information from * the `Reloc' structure constructed during count_reloc(). */ void update_reloc(Cache *ocache, Cache *icache, Cache *_icache, const char *name, Rt_map *lmp, Rel **null, Rel **data, Rel **func) { Shdr *shdr; Rel *rel; Reloc *reloc; Xword ent, cnt, _cnt; Cache *orcache, *ircache = 0; Half ndx; /* * Set up to read the output relocation table. */ shdr = _icache->c_shdr; rel = (Rel *)_icache->c_data->d_buf; reloc = (Reloc *)_icache->c_info; ent = shdr->sh_entsize; cnt = shdr->sh_size / ent; /* * Loop through the relocation table. */ for (_cnt = 0; _cnt < cnt; _cnt++, reloc++, rel = (Rel *)((uintptr_t)rel + ent)) { uchar_t *iaddr, *oaddr; /* LINTED */ uchar_t type = (uchar_t)ELF_R_TYPE(rel->r_info, M_MACH); Addr off, bgn, end; /* * Ignore null relocations (these may have been created from a * previous dldump() of this image). */ if (type == M_R_NONE) { (*null)++; continue; } /* * Determine the section being relocated if we haven't already * done so (we may have had to skip over some null relocation to * get to the first valid offset). The System V ABI states that * a relocation sections sh_info field indicates the section * that must be relocated. However, on Intel it seems that the * .rel.plt sh_info records the section index of the .plt, when * in fact it's the .got that gets relocated. In addition we * now create combined relocation sections with -zcomreloc. To * generically be able to cope with these anomalies, search for * the appropriate section to be relocated by comparing the * offset of the first relocation record against each sections * offset and size. */ /* BEGIN CSTYLED */ #if !defined(__lint) if ((ircache == (Cache *)0) || (rel->r_offset < bgn) || (rel->r_offset > end)) { #else /* * lint sees `bgn' and `end' as potentially referenced * before being set. */ if (ircache == (Cache *)0) { #endif _icache = icache; _icache++; for (ndx = 1; _icache->c_flags != FLG_C_END; ndx++, _icache++) { shdr = _icache->c_shdr; bgn = shdr->sh_addr; end = bgn + shdr->sh_size; if ((rel->r_offset >= bgn) && (rel->r_offset <= end)) break; } ircache = &icache[ndx]; orcache = &ocache[ndx]; } /* END CSTYLED */ /* * Determine the relocation location of both the input and * output data. Take into account that an input section may be * NOBITS (ppc .plt for example). */ off = rel->r_offset - ircache->c_shdr->sh_addr; if (ircache->c_data->d_buf) iaddr = (uchar_t *)ircache->c_data->d_buf + off; else iaddr = 0; oaddr = (uchar_t *)orcache->c_data->d_buf + off; /* * Apply the relocation to the new output image. Any base * address, or symbol value, will have been saved in the reloc * structure during count_reloc(). */ if (reloc->r_flags & FLG_R_APPLY) apply_reloc(rel, reloc, name, oaddr, lmp); /* * Undo any relocation that might already been applied to the * memory image by the runtime linker. Using the original * file, determine the relocation offset original value and * restore the new image to that value. */ if ((reloc->r_flags & FLG_R_UNDO) && (FLAGS(lmp) & FLG_RT_RELOCED)) undo_reloc(rel, oaddr, iaddr, reloc); /* * If a relocation has been applied then the relocation record * should be cleared so that the relocation isn't applied again * when the new image is used. */ if (reloc->r_flags & FLG_R_CLR) { if (type == M_R_JMP_SLOT) { clear_reloc(*func); *func = (Rel *)((uintptr_t)*func + ent); } else { clear_reloc(*null); *null = (Rel *)((uintptr_t)*null + ent); } } /* * If a relocation isn't applied, update the relocation record * to take into account the new address of the image. */ if (reloc->r_flags & FLG_R_INC) { if (type == M_R_JMP_SLOT) { inc_reloc(*func, rel, reloc, oaddr, iaddr); *func = (Rel *)((uintptr_t)*func + ent); } else { inc_reloc(*data, rel, reloc, oaddr, iaddr); *data = (Rel *)((uintptr_t)*data + ent); } } } }
