1 | /* $Id: DBGPlugInCommonELFTmpl.cpp.h 69496 2017-10-28 14:55:58Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * DBGPlugInCommonELF - Code Template for dealing with one kind of ELF.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2008-2017 Oracle Corporation
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
12 | * General Public License (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 |
|
---|
18 | #if ELF_MODE == 32
|
---|
19 | # define Elf_Ehdr Elf32_Ehdr
|
---|
20 | # define Elf_Shdr Elf32_Shdr
|
---|
21 | # define Elf_Phdr Elf32_Phdr
|
---|
22 | # define Elf_Sym Elf32_Sym
|
---|
23 | # define MY_ELFCLASS ELFCLASS32
|
---|
24 | # define ELF_ST_BIND ELF32_ST_BIND
|
---|
25 | # define DBGDiggerCommonParseElfMod DBGDiggerCommonParseElf32Mod
|
---|
26 | #else
|
---|
27 | # define Elf_Ehdr Elf64_Ehdr
|
---|
28 | # define Elf_Shdr Elf64_Shdr
|
---|
29 | # define Elf_Phdr Elf64_Phdr
|
---|
30 | # define Elf_Sym Elf64_Sym
|
---|
31 | # define MY_ELFCLASS ELFCLASS64
|
---|
32 | # define ELF_ST_BIND ELF64_ST_BIND
|
---|
33 | # define DBGDiggerCommonParseElfMod DBGDiggerCommonParseElf64Mod
|
---|
34 | #endif
|
---|
35 |
|
---|
36 |
|
---|
37 | /**
|
---|
38 | * Common ELF module parser.
|
---|
39 | *
|
---|
40 | * It takes the essential bits of the ELF module (elf header, section headers,
|
---|
41 | * symbol table and string table), and inserts/updates the module and symbols.
|
---|
42 | *
|
---|
43 | *
|
---|
44 | * @returns VBox status code.
|
---|
45 | *
|
---|
46 | * @param pUVM The user mode VM handle.
|
---|
47 | * @param pszModName The module name.
|
---|
48 | * @param pszFilename The filename. optional.
|
---|
49 | * @param fFlags Flags.
|
---|
50 | * @param pEhdr Pointer to the ELF header.
|
---|
51 | * @param paShdrs Pointer to the section headers. The caller must verify that
|
---|
52 | * the e_shnum member of the ELF header is within the bounds of
|
---|
53 | * this table. The caller should also adjust the section addresses
|
---|
54 | * so these correspond to actual load addresses.
|
---|
55 | * @param paSyms Pointer to the symbol table.
|
---|
56 | * @param cMaxSyms The maximum number of symbols paSyms may hold. This isn't
|
---|
57 | * the exact count, it's just a cap for avoiding SIGSEGVs
|
---|
58 | * and general corruption.
|
---|
59 | * @param pbStrings Pointer to the string table.
|
---|
60 | * @param cbMaxStrings The size of the memory pbStrings points to. This doesn't
|
---|
61 | * have to match the string table size exactly, it's just to
|
---|
62 | * avoid SIGSEGV when a bad string index is encountered.
|
---|
63 | * @param MinAddr Min address to care about.
|
---|
64 | * @param MaxAddr Max address to care about (inclusive). Together
|
---|
65 | * with MinAddr this forms a valid address range for
|
---|
66 | * symbols and sections that we care about. Anything
|
---|
67 | * outside the range is ignored, except when doing
|
---|
68 | * sanity checks..
|
---|
69 | * @param uModTag Module tag. Pass 0 if tagging is of no interest.
|
---|
70 | */
|
---|
71 | int DBGDiggerCommonParseElfMod(PUVM pUVM, const char *pszModName, const char *pszFilename, uint32_t fFlags,
|
---|
72 | Elf_Ehdr const *pEhdr, Elf_Shdr const *paShdrs,
|
---|
73 | Elf_Sym const *paSyms, size_t cMaxSyms,
|
---|
74 | char const *pbStrings, size_t cbMaxStrings,
|
---|
75 | RTGCPTR MinAddr, RTGCPTR MaxAddr, uint64_t uModTag)
|
---|
76 | {
|
---|
77 | AssertPtrReturn(pUVM, VERR_INVALID_POINTER);
|
---|
78 | AssertPtrReturn(pszModName, VERR_INVALID_POINTER);
|
---|
79 | AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
|
---|
80 | AssertReturn(!(fFlags & ~DBG_DIGGER_ELF_MASK), VERR_INVALID_PARAMETER);
|
---|
81 | AssertReturn((fFlags & (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE))
|
---|
82 | != (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE), VERR_INVALID_PARAMETER);
|
---|
83 | AssertPtrReturn(paShdrs, VERR_INVALID_POINTER);
|
---|
84 | AssertPtrReturn(paSyms, VERR_INVALID_POINTER);
|
---|
85 | AssertPtrReturn(pbStrings, VERR_INVALID_POINTER);
|
---|
86 |
|
---|
87 | /*
|
---|
88 | * Validate the ELF header.
|
---|
89 | */
|
---|
90 | if ( pEhdr->e_ident[EI_MAG0] != ELFMAG0
|
---|
91 | || pEhdr->e_ident[EI_MAG1] != ELFMAG1
|
---|
92 | || pEhdr->e_ident[EI_MAG2] != ELFMAG2
|
---|
93 | || pEhdr->e_ident[EI_MAG3] != ELFMAG3)
|
---|
94 | return VERR_INVALID_EXE_SIGNATURE;
|
---|
95 | if (pEhdr->e_ident[EI_CLASS] != MY_ELFCLASS)
|
---|
96 | return VERR_LDRELF_MACHINE;
|
---|
97 |
|
---|
98 | if (pEhdr->e_ident[EI_DATA] != ELFDATA2LSB)
|
---|
99 | return VERR_LDRELF_ODD_ENDIAN;
|
---|
100 | if (pEhdr->e_ident[EI_VERSION] != EV_CURRENT)
|
---|
101 | return VERR_LDRELF_VERSION;
|
---|
102 | if (pEhdr->e_version != EV_CURRENT)
|
---|
103 | return VERR_LDRELF_VERSION;
|
---|
104 | if (pEhdr->e_ehsize != sizeof(*pEhdr))
|
---|
105 | return VERR_BAD_EXE_FORMAT;
|
---|
106 |
|
---|
107 | #if ELF_MODE == 32
|
---|
108 | if ( pEhdr->e_machine != EM_386
|
---|
109 | && pEhdr->e_machine != EM_486)
|
---|
110 | return VERR_LDRELF_MACHINE;
|
---|
111 | #else
|
---|
112 | if (pEhdr->e_machine != EM_X86_64)
|
---|
113 | return VERR_LDRELF_MACHINE;
|
---|
114 | #endif
|
---|
115 |
|
---|
116 | if ( pEhdr->e_type != ET_DYN
|
---|
117 | && pEhdr->e_type != ET_REL
|
---|
118 | && pEhdr->e_type != ET_EXEC) //??
|
---|
119 | return VERR_BAD_EXE_FORMAT;
|
---|
120 | if ( pEhdr->e_phentsize != sizeof(Elf_Phdr)
|
---|
121 | && pEhdr->e_phentsize) //??
|
---|
122 | return VERR_BAD_EXE_FORMAT;
|
---|
123 | if (pEhdr->e_shentsize != sizeof(Elf_Shdr))
|
---|
124 | return VERR_BAD_EXE_FORMAT;
|
---|
125 | if (pEhdr->e_shentsize != sizeof(Elf_Shdr))
|
---|
126 | return VERR_BAD_EXE_FORMAT;
|
---|
127 | if (!ASMMemIsZero(&pEhdr->e_ident[EI_PAD], EI_NIDENT - EI_PAD)) //??
|
---|
128 | return VERR_BAD_EXE_FORMAT;
|
---|
129 |
|
---|
130 | /*
|
---|
131 | * Validate the section headers, finding the string and symbol table
|
---|
132 | * headers and the load address while at it.
|
---|
133 | */
|
---|
134 | uint64_t uLoadAddr = UINT64_MAX;
|
---|
135 | const Elf_Shdr *pSymShdr = NULL;
|
---|
136 | const Elf_Shdr *pStrShdr = NULL;
|
---|
137 | for (unsigned iSh = fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS ? 1 : 0; iSh < pEhdr->e_shnum; iSh++)
|
---|
138 | {
|
---|
139 | /* Minimal validation. */
|
---|
140 | if (paShdrs[iSh].sh_link >= pEhdr->e_shnum)
|
---|
141 | return VERR_BAD_EXE_FORMAT;
|
---|
142 |
|
---|
143 | /* Is it the symbol table?*/
|
---|
144 | if (paShdrs[iSh].sh_type == SHT_SYMTAB)
|
---|
145 | {
|
---|
146 | if (pSymShdr)
|
---|
147 | return VERR_LDRELF_MULTIPLE_SYMTABS;
|
---|
148 | pSymShdr = &paShdrs[iSh];
|
---|
149 | if (pSymShdr->sh_entsize != sizeof(Elf32_Sym))
|
---|
150 | return VERR_BAD_EXE_FORMAT;
|
---|
151 | pStrShdr = &paShdrs[paShdrs[iSh].sh_link];
|
---|
152 | }
|
---|
153 | if (uLoadAddr > paShdrs[iSh].sh_addr)
|
---|
154 | uLoadAddr = paShdrs[iSh].sh_addr;
|
---|
155 | }
|
---|
156 |
|
---|
157 | /*
|
---|
158 | * Validate the symbol table and determine the max section index
|
---|
159 | * when DBG_DIGGER_ELF_FUNNY_SHDRS is flagged.
|
---|
160 | */
|
---|
161 | uint32_t uMaxShIdx = fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS ? 0 : pEhdr->e_shnum - 1;
|
---|
162 | size_t const cbStrings = pStrShdr ? pStrShdr->sh_size : cbMaxStrings;
|
---|
163 | size_t const cSyms = pSymShdr
|
---|
164 | ? RT_MIN(cMaxSyms, pSymShdr->sh_size / sizeof(Elf_Sym))
|
---|
165 | : cMaxSyms;
|
---|
166 | for (size_t iSym = 1; iSym < cSyms; iSym++)
|
---|
167 | {
|
---|
168 | if (paSyms[iSym].st_name >= cbStrings)
|
---|
169 | return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
|
---|
170 | if (fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS)
|
---|
171 | {
|
---|
172 | if ( paSyms[iSym].st_shndx > uMaxShIdx
|
---|
173 | && paSyms[iSym].st_shndx < SHN_LORESERVE)
|
---|
174 | uMaxShIdx = paSyms[iSym].st_shndx;
|
---|
175 | }
|
---|
176 | else if ( paSyms[iSym].st_shndx >= pEhdr->e_shnum
|
---|
177 | && paSyms[iSym].st_shndx != SHN_UNDEF
|
---|
178 | && ( paSyms[iSym].st_shndx < SHN_LORESERVE
|
---|
179 | /*|| paSyms[iSym].st_shndx > SHN_HIRESERVE*/
|
---|
180 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
---|
181 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK) )
|
---|
182 | return VERR_BAD_EXE_FORMAT;
|
---|
183 | }
|
---|
184 | if (uMaxShIdx > 4096)
|
---|
185 | return VERR_BAD_EXE_FORMAT;
|
---|
186 |
|
---|
187 | /*
|
---|
188 | * Create new module.
|
---|
189 | * The funny ELF section headers on solaris makes this very complicated.
|
---|
190 | */
|
---|
191 | uint32_t cSegs = uMaxShIdx + 1;
|
---|
192 | PDBGDIGGERELFSEG paSegs = (PDBGDIGGERELFSEG)alloca(sizeof(paSegs[0]) * cSegs);
|
---|
193 | for (uint32_t i = 0; i < cSegs; i++)
|
---|
194 | {
|
---|
195 | paSegs[i].uLoadAddr = RTGCPTR_MAX;
|
---|
196 | paSegs[i].uLastAddr = 0;
|
---|
197 | paSegs[i].iSeg = NIL_RTDBGSEGIDX;
|
---|
198 | }
|
---|
199 |
|
---|
200 | RTDBGMOD hMod;
|
---|
201 | int rc = RTDbgModCreate(&hMod, pszModName, 0 /*cbSeg*/, 0 /*fFlags*/);
|
---|
202 | if (RT_FAILURE(rc))
|
---|
203 | return rc;
|
---|
204 | rc = RTDbgModSetTag(hMod, uModTag); AssertRC(rc);
|
---|
205 |
|
---|
206 | if (fFlags & DBG_DIGGER_ELF_FUNNY_SHDRS)
|
---|
207 | {
|
---|
208 | /* Seek out the min and max symbol values for each section. */
|
---|
209 | for (uint32_t iSym = 1; iSym < cSyms; iSym++)
|
---|
210 | {
|
---|
211 | /* Ignore undefined, absolute and weak symbols in this pass,
|
---|
212 | but include local ones as well as nameless. */
|
---|
213 | uint32_t iSh = paSyms[iSym].st_shndx;
|
---|
214 | if ( iSh != SHN_UNDEF
|
---|
215 | && iSh < cSegs
|
---|
216 | && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
---|
217 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_LOCAL))
|
---|
218 | {
|
---|
219 | /* Calc the address and check that it doesn't wrap with the size. */
|
---|
220 | RTGCUINTPTR Address = paSyms[iSym].st_value;
|
---|
221 | RTGCUINTPTR AddressLast = Address + RT_MAX(paSyms[iSym].st_size, 1) - 1;
|
---|
222 | if (AddressLast < Address)
|
---|
223 | continue;
|
---|
224 | if ( Address < MinAddr
|
---|
225 | || AddressLast > MaxAddr)
|
---|
226 | continue;
|
---|
227 |
|
---|
228 | /* update min/max. */
|
---|
229 | if (Address < paSegs[iSh].uLoadAddr)
|
---|
230 | paSegs[iSh].uLoadAddr = Address;
|
---|
231 | if (AddressLast > paSegs[iSh].uLastAddr)
|
---|
232 | paSegs[iSh].uLastAddr = AddressLast;
|
---|
233 | }
|
---|
234 | }
|
---|
235 |
|
---|
236 | /* Add the segments and fill in the translation table. */
|
---|
237 | RTGCPTR uRvaNext = 0;
|
---|
238 | for (unsigned i = 0; i < cSegs; i++)
|
---|
239 | if (paSegs[i].uLastAddr != 0)
|
---|
240 | {
|
---|
241 | char szSeg[32];
|
---|
242 | RTStrPrintf(szSeg, sizeof(szSeg), "sec%02u", i);
|
---|
243 | RTGCPTR cbSeg = paSegs[i].uLastAddr - paSegs[i].uLoadAddr + 1;
|
---|
244 | rc = RTDbgModSegmentAdd(hMod, uRvaNext, cbSeg, szSeg, 0 /*fFlags*/, &paSegs[i].iSeg);
|
---|
245 | if (RT_FAILURE(rc))
|
---|
246 | break;
|
---|
247 | uRvaNext += RT_ALIGN_T(cbSeg, 32, RTGCPTR);
|
---|
248 | }
|
---|
249 | }
|
---|
250 | else
|
---|
251 | {
|
---|
252 | /* Add the segments and fill in the translation table. */
|
---|
253 | for (unsigned i = 0; i < cSegs; i++)
|
---|
254 | if (paShdrs[i].sh_flags & SHF_ALLOC)
|
---|
255 | {
|
---|
256 | char szSeg[32];
|
---|
257 | RTStrPrintf(szSeg, sizeof(szSeg), "sec%02u", i);
|
---|
258 | rc = RTDbgModSegmentAdd(hMod, paShdrs[i].sh_addr - uLoadAddr, paShdrs[i].sh_size, szSeg, 0 /*fFlags*/, &paSegs[i].iSeg);
|
---|
259 | if (RT_FAILURE(rc))
|
---|
260 | break;
|
---|
261 | paSegs[i].uLoadAddr = paShdrs[i].sh_addr;
|
---|
262 | paSegs[i].uLastAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size - 1;
|
---|
263 | }
|
---|
264 | }
|
---|
265 | if (RT_FAILURE(rc))
|
---|
266 | {
|
---|
267 | RTDbgModRelease(hMod);
|
---|
268 | return rc;
|
---|
269 | }
|
---|
270 |
|
---|
271 |
|
---|
272 | /*
|
---|
273 | * Add all relevant symbols in the module
|
---|
274 | */
|
---|
275 | for (uint32_t iSym = 1; iSym < cSyms; iSym++)
|
---|
276 | {
|
---|
277 | /* Undefined symbols are not exports, they are imports. */
|
---|
278 | RTDBGSEGIDX iSeg = paSyms[iSym].st_shndx;
|
---|
279 | if ( iSeg != SHN_UNDEF
|
---|
280 | && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
|
---|
281 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_LOCAL
|
---|
282 | || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK))
|
---|
283 | {
|
---|
284 | /* Get the symbol name. */
|
---|
285 | if (paSyms[iSym].st_name >= cbMaxStrings)
|
---|
286 | continue;
|
---|
287 | const char *pszSymbol = pbStrings + paSyms[iSym].st_name;
|
---|
288 | if (!*pszSymbol)
|
---|
289 | continue;
|
---|
290 |
|
---|
291 | /* Calc the address (value) and size. */
|
---|
292 | RTGCUINTPTR cbSym = paSyms[iSym].st_size;
|
---|
293 | RTGCUINTPTR offSeg = paSyms[iSym].st_value;
|
---|
294 | if (iSeg == SHN_ABS)
|
---|
295 | iSeg = RTDBGSEGIDX_ABS; /* absolute symbols are not subject to any relocation. */
|
---|
296 | else
|
---|
297 | {
|
---|
298 | Assert(iSeg < cSegs);
|
---|
299 | if (fFlags & (DBG_DIGGER_ELF_FUNNY_SHDRS | DBG_DIGGER_ELF_ADJUST_SYM_VALUE))
|
---|
300 | offSeg -= paSegs[iSeg].uLoadAddr;
|
---|
301 | iSeg = paSegs[iSeg].iSeg;
|
---|
302 | if (iSeg == NIL_RTDBGSEGIDX)
|
---|
303 | continue;
|
---|
304 | }
|
---|
305 | if (offSeg + cbSym < offSeg)
|
---|
306 | continue;
|
---|
307 |
|
---|
308 | rc = RTDbgModSymbolAdd(hMod, pszSymbol, iSeg, offSeg, cbSym, 0 /*fFlags*/, NULL);
|
---|
309 | Log(("%02x:%RGv %RGv %s!%s (rc=%Rrc)\n", paSyms[iSym].st_shndx, offSeg, cbSym, pszModName, pszSymbol, rc));
|
---|
310 | }
|
---|
311 | /*else: silently ignore */
|
---|
312 | }
|
---|
313 |
|
---|
314 | /*
|
---|
315 | * Link it into the address space.
|
---|
316 | */
|
---|
317 | RTDBGAS hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
|
---|
318 | if (hAs != NIL_RTDBGAS)
|
---|
319 | rc = dbgDiggerCommonLinkElfSegs(hAs, hMod, paSegs, cSegs);
|
---|
320 | else
|
---|
321 | rc = VERR_INTERNAL_ERROR;
|
---|
322 | RTDbgModRelease(hMod);
|
---|
323 | RTDbgAsRelease(hAs);
|
---|
324 | return rc;
|
---|
325 | }
|
---|
326 |
|
---|
327 |
|
---|
328 | #undef Elf_Ehdr
|
---|
329 | #undef Elf_Shdr
|
---|
330 | #undef Elf_Phdr
|
---|
331 | #undef Elf_Sym
|
---|
332 | #undef MY_ELFCLASS
|
---|
333 | #undef ELF_ST_BIND
|
---|
334 | #undef DBGDiggerCommonParseElfMod
|
---|
335 |
|
---|