VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/ldr/ldrELFRelocatable.cpp.h@ 52213

Last change on this file since 52213 was 52213, checked in by vboxsync, 10 years ago

SUP,IPRT: Implemented forwarder support in RTLdr and cleaned up some the ordinal mess. Resolved imports when doing the process verification/purification runs other than SUPHARDNTVPKIND_CHILD_PURIFICATION. This is necessary since 32-bit windows combine .text with .rdata, and we don't want to overwrite the import table after it has been snapped. Include read-only sections in the verfication runs.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 74.3 KB
Line 
1/* $Id: ldrELFRelocatable.cpp.h 52213 2014-07-28 17:52:58Z vboxsync $ */
2/** @file
3 * IPRT - Binary Image Loader, Template for ELF Relocatable Images.
4 */
5
6/*
7 * Copyright (C) 2006-2012 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 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*******************************************************************************
29* Defined Constants And Macros *
30*******************************************************************************/
31#if ELF_MODE == 32
32#define RTLDRELF_NAME(name) rtldrELF32##name
33#define RTLDRELF_SUFF(name) name##32
34#define RTLDRELF_MID(pre,suff) pre##32##suff
35#define FMT_ELF_ADDR "%08RX32"
36#define FMT_ELF_HALF "%04RX16"
37#define FMT_ELF_OFF "%08RX32"
38#define FMT_ELF_SIZE "%08RX32"
39#define FMT_ELF_SWORD "%RI32"
40#define FMT_ELF_WORD "%08RX32"
41#define FMT_ELF_XWORD "%08RX32"
42#define FMT_ELF_SXWORD "%RI32"
43
44#elif ELF_MODE == 64
45#define RTLDRELF_NAME(name) rtldrELF64##name
46#define RTLDRELF_SUFF(name) name##64
47#define RTLDRELF_MID(pre,suff) pre##64##suff
48#define FMT_ELF_ADDR "%016RX64"
49#define FMT_ELF_HALF "%04RX16"
50#define FMT_ELF_SHALF "%RI16"
51#define FMT_ELF_OFF "%016RX64"
52#define FMT_ELF_SIZE "%016RX64"
53#define FMT_ELF_SWORD "%RI32"
54#define FMT_ELF_WORD "%08RX32"
55#define FMT_ELF_XWORD "%016RX64"
56#define FMT_ELF_SXWORD "%RI64"
57#endif
58
59#define Elf_Ehdr RTLDRELF_MID(Elf,_Ehdr)
60#define Elf_Phdr RTLDRELF_MID(Elf,_Phdr)
61#define Elf_Shdr RTLDRELF_MID(Elf,_Shdr)
62#define Elf_Sym RTLDRELF_MID(Elf,_Sym)
63#define Elf_Rel RTLDRELF_MID(Elf,_Rel)
64#define Elf_Rela RTLDRELF_MID(Elf,_Rela)
65#define Elf_Nhdr RTLDRELF_MID(Elf,_Nhdr)
66#define Elf_Dyn RTLDRELF_MID(Elf,_Dyn)
67#define Elf_Addr RTLDRELF_MID(Elf,_Addr)
68#define Elf_Half RTLDRELF_MID(Elf,_Half)
69#define Elf_Off RTLDRELF_MID(Elf,_Off)
70#define Elf_Size RTLDRELF_MID(Elf,_Size)
71#define Elf_Sword RTLDRELF_MID(Elf,_Sword)
72#define Elf_Word RTLDRELF_MID(Elf,_Word)
73
74#define RTLDRMODELF RTLDRELF_MID(RTLDRMODELF,RT_NOTHING)
75#define PRTLDRMODELF RTLDRELF_MID(PRTLDRMODELF,RT_NOTHING)
76
77#define ELF_R_SYM(info) RTLDRELF_MID(ELF,_R_SYM)(info)
78#define ELF_R_TYPE(info) RTLDRELF_MID(ELF,_R_TYPE)(info)
79#define ELF_R_INFO(sym, type) RTLDRELF_MID(ELF,_R_INFO)(sym, type)
80
81#define ELF_ST_BIND(info) RTLDRELF_MID(ELF,_ST_BIND)(info)
82
83
84
85/*******************************************************************************
86* Structures and Typedefs *
87*******************************************************************************/
88/**
89 * The ELF loader structure.
90 */
91typedef struct RTLDRMODELF
92{
93 /** Core module structure. */
94 RTLDRMODINTERNAL Core;
95 /** Pointer to readonly mapping of the image bits.
96 * This mapping is provided by the pReader. */
97 const void *pvBits;
98
99 /** The ELF header. */
100 Elf_Ehdr Ehdr;
101 /** Pointer to our copy of the section headers with sh_addr as RVAs.
102 * The virtual addresses in this array is the 0 based assignments we've given the image.
103 * Not valid if the image is DONE. */
104 Elf_Shdr *paShdrs;
105 /** Unmodified section headers (allocated after paShdrs, so no need to free).
106 * Not valid if the image is DONE. */
107 Elf_Shdr const *paOrgShdrs;
108 /** The size of the loaded image. */
109 size_t cbImage;
110
111 /** The image base address if it's an EXEC or DYN image. */
112 Elf_Addr LinkAddress;
113
114 /** The symbol section index. */
115 unsigned iSymSh;
116 /** Number of symbols in the table. */
117 unsigned cSyms;
118 /** Pointer to symbol table within RTLDRMODELF::pvBits. */
119 const Elf_Sym *paSyms;
120
121 /** The string section index. */
122 unsigned iStrSh;
123 /** Size of the string table. */
124 unsigned cbStr;
125 /** Pointer to string table within RTLDRMODELF::pvBits. */
126 const char *pStr;
127
128 /** Size of the section header string table. */
129 unsigned cbShStr;
130 /** Pointer to section header string table within RTLDRMODELF::pvBits. */
131 const char *pShStr;
132} RTLDRMODELF, *PRTLDRMODELF;
133
134
135/**
136 * Maps the image bits into memory and resolve pointers into it.
137 *
138 * @returns iprt status code.
139 * @param pModElf The ELF loader module instance data.
140 * @param fNeedsBits Set if we actually need the pvBits member.
141 * If we don't, we can simply read the string and symbol sections, thus saving memory.
142 */
143static int RTLDRELF_NAME(MapBits)(PRTLDRMODELF pModElf, bool fNeedsBits)
144{
145 NOREF(fNeedsBits);
146 if (pModElf->pvBits)
147 return VINF_SUCCESS;
148 int rc = pModElf->Core.pReader->pfnMap(pModElf->Core.pReader, &pModElf->pvBits);
149 if (RT_SUCCESS(rc))
150 {
151 const uint8_t *pu8 = (const uint8_t *)pModElf->pvBits;
152 if (pModElf->iSymSh != ~0U)
153 pModElf->paSyms = (const Elf_Sym *)(pu8 + pModElf->paShdrs[pModElf->iSymSh].sh_offset);
154 if (pModElf->iStrSh != ~0U)
155 pModElf->pStr = (const char *)(pu8 + pModElf->paShdrs[pModElf->iStrSh].sh_offset);
156 pModElf->pShStr = (const char *)(pu8 + pModElf->paShdrs[pModElf->Ehdr.e_shstrndx].sh_offset);
157 }
158 return rc;
159}
160
161
162/*
163 *
164 * EXEC & DYN.
165 * EXEC & DYN.
166 * EXEC & DYN.
167 * EXEC & DYN.
168 * EXEC & DYN.
169 *
170 */
171
172
173/**
174 * Applies the fixups for a section in an executable image.
175 *
176 * @returns iprt status code.
177 * @param pModElf The ELF loader module instance data.
178 * @param BaseAddr The base address which the module is being fixedup to.
179 * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
180 * @param pvUser User argument to pass to the callback.
181 * @param SecAddr The section address. This is the address the relocations are relative to.
182 * @param cbSec The section size. The relocations must be inside this.
183 * @param pu8SecBaseR Where we read section bits from.
184 * @param pu8SecBaseW Where we write section bits to.
185 * @param pvRelocs Pointer to where we read the relocations from.
186 * @param cbRelocs Size of the relocations.
187 */
188static int RTLDRELF_NAME(RelocateSectionExecDyn)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr,
189 PFNRTLDRIMPORT pfnGetImport, void *pvUser,
190 const Elf_Addr SecAddr, Elf_Size cbSec,
191 const uint8_t *pu8SecBaseR, uint8_t *pu8SecBaseW,
192 const void *pvRelocs, Elf_Size cbRelocs)
193{
194#if ELF_MODE != 32
195 NOREF(pu8SecBaseR);
196#endif
197
198 /*
199 * Iterate the relocations.
200 * The relocations are stored in an array of Elf32_Rel records and covers the entire relocation section.
201 */
202 const Elf_Addr offDelta = BaseAddr - pModElf->LinkAddress;
203 const Elf_Reloc *paRels = (const Elf_Reloc *)pvRelocs;
204 const unsigned iRelMax = (unsigned)(cbRelocs / sizeof(paRels[0]));
205 AssertMsgReturn(iRelMax == cbRelocs / sizeof(paRels[0]), (FMT_ELF_SIZE "\n", cbRelocs / sizeof(paRels[0])),
206 VERR_IMAGE_TOO_BIG);
207 for (unsigned iRel = 0; iRel < iRelMax; iRel++)
208 {
209 /*
210 * Skip R_XXX_NONE entries early to avoid confusion in the symbol
211 * getter code.
212 */
213#if ELF_MODE == 32
214 if (ELF_R_TYPE(paRels[iRel].r_info) == R_386_NONE)
215 continue;
216#elif ELF_MODE == 64
217 if (ELF_R_TYPE(paRels[iRel].r_info) == R_X86_64_NONE)
218 continue;
219#endif
220
221 /*
222 * Validate and find the symbol, resolve undefined ones.
223 */
224 Elf_Size iSym = ELF_R_SYM(paRels[iRel].r_info);
225 if (iSym >= pModElf->cSyms)
226 {
227 AssertMsgFailed(("iSym=%d is an invalid symbol index!\n", iSym));
228 return VERR_LDRELF_INVALID_SYMBOL_INDEX;
229 }
230 const Elf_Sym *pSym = &pModElf->paSyms[iSym];
231 if (pSym->st_name >= pModElf->cbStr)
232 {
233 AssertMsgFailed(("iSym=%d st_name=%d str sh_size=%d\n", iSym, pSym->st_name, pModElf->cbStr));
234 return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
235 }
236
237 Elf_Addr SymValue = 0;
238 if (pSym->st_shndx == SHN_UNDEF)
239 {
240 /* Try to resolve the symbol. */
241 const char *pszName = ELF_STR(pModElf, pSym->st_name);
242 RTUINTPTR ExtValue;
243 int rc = pfnGetImport(&pModElf->Core, "", pszName, ~0, &ExtValue, pvUser);
244 AssertMsgRCReturn(rc, ("Failed to resolve '%s' rc=%Rrc\n", pszName, rc), rc);
245 SymValue = (Elf_Addr)ExtValue;
246 AssertMsgReturn((RTUINTPTR)SymValue == ExtValue, ("Symbol value overflowed! '%s'\n", pszName),
247 VERR_SYMBOL_VALUE_TOO_BIG);
248 Log2(("rtldrELF: #%-3d - UNDEF " FMT_ELF_ADDR " '%s'\n", iSym, SymValue, pszName));
249 }
250 else
251 {
252 AssertReturn(pSym->st_shndx < pModElf->cSyms || pSym->st_shndx == SHN_ABS, ("%#x\n", pSym->st_shndx));
253#if ELF_MODE == 64
254 SymValue = pSym->st_value;
255#endif
256 }
257
258#if ELF_MODE == 64
259 /* Calc the value. */
260 Elf_Addr Value;
261 if (pSym->st_shndx < pModElf->cSyms)
262 Value = SymValue + offDelta;
263 else
264 Value = SymValue + paRels[iRel].r_addend;
265#endif
266
267 /*
268 * Apply the fixup.
269 */
270 AssertMsgReturn(paRels[iRel].r_offset < cbSec, (FMT_ELF_ADDR " " FMT_ELF_SIZE "\n", paRels[iRel].r_offset, cbSec), VERR_LDRELF_INVALID_RELOCATION_OFFSET);
271#if ELF_MODE == 32
272 const Elf_Addr *pAddrR = (const Elf_Addr *)(pu8SecBaseR + paRels[iRel].r_offset); /* Where to read the addend. */
273#endif
274 Elf_Addr *pAddrW = (Elf_Addr *)(pu8SecBaseW + paRels[iRel].r_offset); /* Where to write the fixup. */
275 switch (ELF_R_TYPE(paRels[iRel].r_info))
276 {
277#if ELF_MODE == 32
278 /*
279 * Absolute addressing.
280 */
281 case R_386_32:
282 {
283 Elf_Addr Value;
284 if (pSym->st_shndx < pModElf->Ehdr.e_shnum)
285 Value = *pAddrR + offDelta; /* Simplified. */
286 else if (pSym->st_shndx == SHN_ABS)
287 continue; /* Internal fixup, no need to apply it. */
288 else if (pSym->st_shndx == SHN_UNDEF)
289 Value = SymValue + *pAddrR;
290 else
291 AssertFailedReturn(VERR_LDR_GENERAL_FAILURE); /** @todo SHN_COMMON */
292 *(uint32_t *)pAddrW = Value;
293 Log4((FMT_ELF_ADDR": R_386_32 Value=" FMT_ELF_ADDR "\n", SecAddr + paRels[iRel].r_offset + BaseAddr, Value));
294 break;
295 }
296
297 /*
298 * PC relative addressing.
299 */
300 case R_386_PC32:
301 {
302 Elf_Addr Value;
303 if (pSym->st_shndx < pModElf->Ehdr.e_shnum)
304 continue; /* Internal fixup, no need to apply it. */
305 else if (pSym->st_shndx == SHN_ABS)
306 Value = *pAddrR + offDelta; /* Simplified. */
307 else if (pSym->st_shndx == SHN_UNDEF)
308 {
309 const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
310 Value = SymValue + *(uint32_t *)pAddrR - SourceAddr;
311 *(uint32_t *)pAddrW = Value;
312 }
313 else
314 AssertFailedReturn(VERR_LDR_GENERAL_FAILURE); /** @todo SHN_COMMON */
315 Log4((FMT_ELF_ADDR": R_386_PC32 Value=" FMT_ELF_ADDR "\n", SecAddr + paRels[iRel].r_offset + BaseAddr, Value));
316 break;
317 }
318
319#elif ELF_MODE == 64
320
321 /*
322 * Absolute addressing
323 */
324 case R_X86_64_64:
325 {
326 *(uint64_t *)pAddrW = Value;
327 Log4((FMT_ELF_ADDR": R_X86_64_64 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
328 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
329 break;
330 }
331
332 /*
333 * Truncated 32-bit value (zero-extendedable to the 64-bit value).
334 */
335 case R_X86_64_32:
336 {
337 *(uint32_t *)pAddrW = (uint32_t)Value;
338 Log4((FMT_ELF_ADDR": R_X86_64_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
339 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
340 AssertMsgReturn((Elf_Addr)*(uint32_t *)pAddrW == SymValue, ("Value=" FMT_ELF_ADDR "\n", SymValue),
341 VERR_SYMBOL_VALUE_TOO_BIG);
342 break;
343 }
344
345 /*
346 * Truncated 32-bit value (sign-extendedable to the 64-bit value).
347 */
348 case R_X86_64_32S:
349 {
350 *(int32_t *)pAddrW = (int32_t)Value;
351 Log4((FMT_ELF_ADDR": R_X86_64_32S Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
352 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
353 AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
354 break;
355 }
356
357 /*
358 * PC relative addressing.
359 */
360 case R_X86_64_PC32:
361 {
362 const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
363 Value -= SourceAddr;
364 *(int32_t *)pAddrW = (int32_t)Value;
365 Log4((FMT_ELF_ADDR": R_X86_64_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
366 SourceAddr, Value, SymValue));
367 AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
368 break;
369 }
370#endif
371
372 default:
373 AssertMsgFailed(("Unknown relocation type: %d (iRel=%d iRelMax=%d)\n",
374 ELF_R_TYPE(paRels[iRel].r_info), iRel, iRelMax));
375 return VERR_LDRELF_RELOCATION_NOT_SUPPORTED;
376 }
377 }
378
379 return VINF_SUCCESS;
380}
381
382
383
384/*
385 *
386 * REL
387 * REL
388 * REL
389 * REL
390 * REL
391 *
392 */
393
394/**
395 * Get the symbol and symbol value.
396 *
397 * @returns iprt status code.
398 * @param pModElf The ELF loader module instance data.
399 * @param BaseAddr The base address which the module is being fixedup to.
400 * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
401 * @param pvUser User argument to pass to the callback.
402 * @param iSym The symbol to get.
403 * @param ppSym Where to store the symbol pointer on success. (read only)
404 * @param pSymValue Where to store the symbol value on success.
405 */
406static int RTLDRELF_NAME(Symbol)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
407 Elf_Size iSym, const Elf_Sym **ppSym, Elf_Addr *pSymValue)
408{
409 /*
410 * Validate and find the symbol.
411 */
412 if (iSym >= pModElf->cSyms)
413 {
414 AssertMsgFailed(("iSym=%d is an invalid symbol index!\n", iSym));
415 return VERR_LDRELF_INVALID_SYMBOL_INDEX;
416 }
417 const Elf_Sym *pSym = &pModElf->paSyms[iSym];
418 *ppSym = pSym;
419
420 if (pSym->st_name >= pModElf->cbStr)
421 {
422 AssertMsgFailed(("iSym=%d st_name=%d str sh_size=%d\n", iSym, pSym->st_name, pModElf->cbStr));
423 return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
424 }
425 const char *pszName = ELF_STR(pModElf, pSym->st_name);
426
427 /*
428 * Determine the symbol value.
429 *
430 * Symbols needs different treatment depending on which section their are in.
431 * Undefined and absolute symbols goes into special non-existing sections.
432 */
433 switch (pSym->st_shndx)
434 {
435 /*
436 * Undefined symbol, needs resolving.
437 *
438 * Since ELF has no generic concept of importing from specific module (the OS/2 ELF format
439 * has but that's a OS extension and only applies to programs and dlls), we'll have to ask
440 * the resolver callback to do a global search.
441 */
442 case SHN_UNDEF:
443 {
444 /* Try to resolve the symbol. */
445 RTUINTPTR Value;
446 int rc = pfnGetImport(&pModElf->Core, "", pszName, ~0, &Value, pvUser);
447 if (RT_FAILURE(rc))
448 {
449 AssertMsgFailed(("Failed to resolve '%s' rc=%Rrc\n", pszName, rc));
450 return rc;
451 }
452 *pSymValue = (Elf_Addr)Value;
453 if ((RTUINTPTR)*pSymValue != Value)
454 {
455 AssertMsgFailed(("Symbol value overflowed! '%s'\n", pszName));
456 return VERR_SYMBOL_VALUE_TOO_BIG;
457 }
458
459 Log2(("rtldrELF: #%-3d - UNDEF " FMT_ELF_ADDR " '%s'\n", iSym, *pSymValue, pszName));
460 break;
461 }
462
463 /*
464 * Absolute symbols needs no fixing since they are, well, absolute.
465 */
466 case SHN_ABS:
467 *pSymValue = pSym->st_value;
468 Log2(("rtldrELF: #%-3d - ABS " FMT_ELF_ADDR " '%s'\n", iSym, *pSymValue, pszName));
469 break;
470
471 /*
472 * All other symbols are addressed relative to their section and need to be fixed up.
473 */
474 default:
475 if (pSym->st_shndx >= pModElf->Ehdr.e_shnum)
476 {
477 /* what about common symbols? */
478 AssertMsg(pSym->st_shndx < pModElf->Ehdr.e_shnum,
479 ("iSym=%d st_shndx=%d e_shnum=%d pszName=%s\n", iSym, pSym->st_shndx, pModElf->Ehdr.e_shnum, pszName));
480 return VERR_BAD_EXE_FORMAT;
481 }
482 *pSymValue = pSym->st_value + pModElf->paShdrs[pSym->st_shndx].sh_addr + BaseAddr;
483 Log2(("rtldrELF: #%-3d - %5d " FMT_ELF_ADDR " '%s'\n", iSym, pSym->st_shndx, *pSymValue, pszName));
484 break;
485 }
486
487 return VINF_SUCCESS;
488}
489
490
491/**
492 * Applies the fixups for a sections.
493 *
494 * @returns iprt status code.
495 * @param pModElf The ELF loader module instance data.
496 * @param BaseAddr The base address which the module is being fixedup to.
497 * @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
498 * @param pvUser User argument to pass to the callback.
499 * @param SecAddr The section address. This is the address the relocations are relative to.
500 * @param cbSec The section size. The relocations must be inside this.
501 * @param pu8SecBaseR Where we read section bits from.
502 * @param pu8SecBaseW Where we write section bits to.
503 * @param pvRelocs Pointer to where we read the relocations from.
504 * @param cbRelocs Size of the relocations.
505 */
506static int RTLDRELF_NAME(RelocateSection)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
507 const Elf_Addr SecAddr, Elf_Size cbSec, const uint8_t *pu8SecBaseR, uint8_t *pu8SecBaseW,
508 const void *pvRelocs, Elf_Size cbRelocs)
509{
510#if ELF_MODE != 32
511 NOREF(pu8SecBaseR);
512#endif
513
514 /*
515 * Iterate the relocations.
516 * The relocations are stored in an array of Elf32_Rel records and covers the entire relocation section.
517 */
518 const Elf_Reloc *paRels = (const Elf_Reloc *)pvRelocs;
519 const unsigned iRelMax = (unsigned)(cbRelocs / sizeof(paRels[0]));
520 AssertMsgReturn(iRelMax == cbRelocs / sizeof(paRels[0]), (FMT_ELF_SIZE "\n", cbRelocs / sizeof(paRels[0])), VERR_IMAGE_TOO_BIG);
521 for (unsigned iRel = 0; iRel < iRelMax; iRel++)
522 {
523 /*
524 * Skip R_XXX_NONE entries early to avoid confusion in the symbol
525 * getter code.
526 */
527#if ELF_MODE == 32
528 if (ELF_R_TYPE(paRels[iRel].r_info) == R_386_NONE)
529 continue;
530#elif ELF_MODE == 64
531 if (ELF_R_TYPE(paRels[iRel].r_info) == R_X86_64_NONE)
532 continue;
533#endif
534
535
536 /*
537 * Get the symbol.
538 */
539 const Elf_Sym *pSym = NULL; /* shut up gcc */
540 Elf_Addr SymValue = 0; /* shut up gcc-4 */
541 int rc = RTLDRELF_NAME(Symbol)(pModElf, BaseAddr, pfnGetImport, pvUser, ELF_R_SYM(paRels[iRel].r_info), &pSym, &SymValue);
542 if (RT_FAILURE(rc))
543 return rc;
544
545 Log3(("rtldrELF: " FMT_ELF_ADDR " %02x %06x - " FMT_ELF_ADDR " %3d %02x %s\n",
546 paRels[iRel].r_offset, ELF_R_TYPE(paRels[iRel].r_info), (unsigned)ELF_R_SYM(paRels[iRel].r_info),
547 SymValue, (unsigned)pSym->st_shndx, pSym->st_info, ELF_STR(pModElf, pSym->st_name)));
548
549 /*
550 * Apply the fixup.
551 */
552 AssertMsgReturn(paRels[iRel].r_offset < cbSec, (FMT_ELF_ADDR " " FMT_ELF_SIZE "\n", paRels[iRel].r_offset, cbSec), VERR_LDRELF_INVALID_RELOCATION_OFFSET);
553#if ELF_MODE == 32
554 const Elf_Addr *pAddrR = (const Elf_Addr *)(pu8SecBaseR + paRels[iRel].r_offset); /* Where to read the addend. */
555#endif
556 Elf_Addr *pAddrW = (Elf_Addr *)(pu8SecBaseW + paRels[iRel].r_offset); /* Where to write the fixup. */
557 switch (ELF_R_TYPE(paRels[iRel].r_info))
558 {
559#if ELF_MODE == 32
560 /*
561 * Absolute addressing.
562 */
563 case R_386_32:
564 {
565 const Elf_Addr Value = SymValue + *pAddrR;
566 *(uint32_t *)pAddrW = Value;
567 Log4((FMT_ELF_ADDR": R_386_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
568 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
569 break;
570 }
571
572 /*
573 * PC relative addressing.
574 */
575 case R_386_PC32:
576 {
577 const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
578 const Elf_Addr Value = SymValue + *(uint32_t *)pAddrR - SourceAddr;
579 *(uint32_t *)pAddrW = Value;
580 Log4((FMT_ELF_ADDR": R_386_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
581 SourceAddr, Value, SymValue));
582 break;
583 }
584
585 /* ignore */
586 case R_386_NONE:
587 break;
588
589#elif ELF_MODE == 64
590
591 /*
592 * Absolute addressing
593 */
594 case R_X86_64_64:
595 {
596 const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
597 *(uint64_t *)pAddrW = Value;
598 Log4((FMT_ELF_ADDR": R_X86_64_64 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
599 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
600 break;
601 }
602
603 /*
604 * Truncated 32-bit value (zero-extendedable to the 64-bit value).
605 */
606 case R_X86_64_32:
607 {
608 const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
609 *(uint32_t *)pAddrW = (uint32_t)Value;
610 Log4((FMT_ELF_ADDR": R_X86_64_32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
611 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
612 AssertMsgReturn((Elf_Addr)*(uint32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
613 break;
614 }
615
616 /*
617 * Truncated 32-bit value (sign-extendedable to the 64-bit value).
618 */
619 case R_X86_64_32S:
620 {
621 const Elf_Addr Value = SymValue + paRels[iRel].r_addend;
622 *(int32_t *)pAddrW = (int32_t)Value;
623 Log4((FMT_ELF_ADDR": R_X86_64_32S Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
624 SecAddr + paRels[iRel].r_offset + BaseAddr, Value, SymValue));
625 AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
626 break;
627 }
628
629 /*
630 * PC relative addressing.
631 */
632 case R_X86_64_PC32:
633 {
634 const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
635 const Elf_Addr Value = SymValue + paRels[iRel].r_addend - SourceAddr;
636 *(int32_t *)pAddrW = (int32_t)Value;
637 Log4((FMT_ELF_ADDR": R_X86_64_PC32 Value=" FMT_ELF_ADDR " SymValue=" FMT_ELF_ADDR "\n",
638 SourceAddr, Value, SymValue));
639 AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
640 break;
641 }
642
643 /* ignore */
644 case R_X86_64_NONE:
645 break;
646#endif
647
648 default:
649 AssertMsgFailed(("Unknown relocation type: %d (iRel=%d iRelMax=%d)\n",
650 ELF_R_TYPE(paRels[iRel].r_info), iRel, iRelMax));
651 return VERR_LDRELF_RELOCATION_NOT_SUPPORTED;
652 }
653 }
654
655 return VINF_SUCCESS;
656}
657
658
659
660/** @copydoc RTLDROPS::pfnClose */
661static DECLCALLBACK(int) RTLDRELF_NAME(Close)(PRTLDRMODINTERNAL pMod)
662{
663 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
664
665 if (pModElf->paShdrs)
666 {
667 RTMemFree(pModElf->paShdrs);
668 pModElf->paShdrs = NULL;
669 }
670
671 pModElf->pvBits = NULL;
672
673 return VINF_SUCCESS;
674}
675
676
677/** @copydoc RTLDROPS::Done */
678static DECLCALLBACK(int) RTLDRELF_NAME(Done)(PRTLDRMODINTERNAL pMod)
679{
680 NOREF(pMod); /*PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;*/
681 /** @todo Have to think more about this .... */
682 return -1;
683}
684
685
686/** @copydoc RTLDROPS::EnumSymbols */
687static DECLCALLBACK(int) RTLDRELF_NAME(EnumSymbols)(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
688 PFNRTLDRENUMSYMS pfnCallback, void *pvUser)
689{
690 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
691 NOREF(pvBits);
692
693 /*
694 * Validate the input.
695 */
696 Elf_Addr BaseAddr = (Elf_Addr)BaseAddress;
697 AssertMsgReturn((RTUINTPTR)BaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
698
699 /*
700 * Make sure we've got the string and symbol tables. (We don't need the pvBits.)
701 */
702 int rc = RTLDRELF_NAME(MapBits)(pModElf, false);
703 if (RT_FAILURE(rc))
704 return rc;
705
706 /*
707 * Enumerate the symbol table.
708 */
709 const Elf_Sym *paSyms = pModElf->paSyms;
710 unsigned cSyms = pModElf->cSyms;
711 for (unsigned iSym = 1; iSym < cSyms; iSym++)
712 {
713 /*
714 * Skip imports (undefined).
715 */
716 if (paSyms[iSym].st_shndx != SHN_UNDEF)
717 {
718 /*
719 * Calc value and get name.
720 */
721 Elf_Addr Value;
722 if (paSyms[iSym].st_shndx == SHN_ABS)
723 /* absolute symbols are not subject to any relocation. */
724 Value = paSyms[iSym].st_value;
725 else if (paSyms[iSym].st_shndx < pModElf->Ehdr.e_shnum)
726 {
727 if (pModElf->Ehdr.e_type == ET_REL)
728 /* relative to the section. */
729 Value = BaseAddr + paSyms[iSym].st_value + pModElf->paShdrs[paSyms[iSym].st_shndx].sh_addr;
730 else /* Fixed up for link address. */
731 Value = BaseAddr + paSyms[iSym].st_value - pModElf->LinkAddress;
732 }
733 else
734 {
735 AssertMsgFailed(("Arg! paSyms[%u].st_shndx=" FMT_ELF_HALF "\n", iSym, paSyms[iSym].st_shndx));
736 return VERR_BAD_EXE_FORMAT;
737 }
738 const char *pszName = ELF_STR(pModElf, paSyms[iSym].st_name);
739 if ( (pszName && *pszName)
740 && ( (fFlags & RTLDR_ENUM_SYMBOL_FLAGS_ALL)
741 || ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL)
742 )
743 {
744 /*
745 * Call back.
746 */
747 AssertMsgReturn(Value == (RTUINTPTR)Value, (FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
748 rc = pfnCallback(pMod, pszName, ~0, (RTUINTPTR)Value, pvUser);
749 if (rc)
750 return rc;
751 }
752 }
753 }
754
755 return VINF_SUCCESS;
756}
757
758
759/** @copydoc RTLDROPS::GetImageSize */
760static DECLCALLBACK(size_t) RTLDRELF_NAME(GetImageSize)(PRTLDRMODINTERNAL pMod)
761{
762 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
763
764 return pModElf->cbImage;
765}
766
767
768/** @copydoc RTLDROPS::GetBits */
769static DECLCALLBACK(int) RTLDRELF_NAME(GetBits)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
770{
771 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
772
773 /*
774 * This operation is currently only available on relocatable images.
775 */
776 switch (pModElf->Ehdr.e_type)
777 {
778 case ET_REL:
779 break;
780 case ET_EXEC:
781 Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
782 return VERR_LDRELF_EXEC;
783 case ET_DYN:
784 Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader)));
785 return VERR_LDRELF_DYN;
786 default: AssertFailedReturn(VERR_BAD_EXE_FORMAT);
787 }
788
789 /*
790 * Load the bits into pvBits.
791 */
792 const Elf_Shdr *paShdrs = pModElf->paShdrs;
793 for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
794 {
795 if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
796 {
797 AssertMsgReturn((size_t)paShdrs[iShdr].sh_size == (size_t)paShdrs[iShdr].sh_size, (FMT_ELF_SIZE "\n", paShdrs[iShdr].sh_size), VERR_IMAGE_TOO_BIG);
798 switch (paShdrs[iShdr].sh_type)
799 {
800 case SHT_NOBITS:
801 memset((uint8_t *)pvBits + paShdrs[iShdr].sh_addr, 0, (size_t)paShdrs[iShdr].sh_size);
802 break;
803
804 case SHT_PROGBITS:
805 default:
806 {
807 int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, (uint8_t *)pvBits + paShdrs[iShdr].sh_addr,
808 (size_t)paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset);
809 if (RT_FAILURE(rc))
810 {
811 Log(("RTLdrELF: %s: Read error when reading " FMT_ELF_SIZE " bytes at " FMT_ELF_OFF ", iShdr=%d\n",
812 pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader),
813 paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_offset, iShdr));
814 return rc;
815 }
816 }
817 }
818 }
819 }
820
821 /*
822 * Relocate the image.
823 */
824 return pModElf->Core.pOps->pfnRelocate(pMod, pvBits, BaseAddress, ~(RTUINTPTR)0, pfnGetImport, pvUser);
825}
826
827
828/** @copydoc RTLDROPS::Relocate */
829static DECLCALLBACK(int) RTLDRELF_NAME(Relocate)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress,
830 RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
831{
832 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
833#ifdef LOG_ENABLED
834 const char *pszLogName = pModElf->Core.pReader->pfnLogName(pModElf->Core.pReader);
835#endif
836 NOREF(OldBaseAddress);
837
838 /*
839 * This operation is currently only available on relocatable images.
840 */
841 switch (pModElf->Ehdr.e_type)
842 {
843 case ET_REL:
844 break;
845 case ET_EXEC:
846 Log(("RTLdrELF: %s: Executable images are not supported yet!\n", pszLogName));
847 return VERR_LDRELF_EXEC;
848 case ET_DYN:
849 Log(("RTLdrELF: %s: Dynamic images are not supported yet!\n", pszLogName));
850 return VERR_LDRELF_DYN;
851 default: AssertFailedReturn(VERR_BAD_EXE_FORMAT);
852 }
853
854 /*
855 * Validate the input.
856 */
857 Elf_Addr BaseAddr = (Elf_Addr)NewBaseAddress;
858 AssertMsgReturn((RTUINTPTR)BaseAddr == NewBaseAddress, ("#RTptr", NewBaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
859
860 /*
861 * Map the image bits if not already done and setup pointer into it.
862 */
863 int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
864 if (RT_FAILURE(rc))
865 return rc;
866
867 /*
868 * Iterate the sections looking for interesting SHT_REL[A] sections.
869 * SHT_REL[A] sections have the section index of the section they contain fixups
870 * for in the sh_info member.
871 */
872 const Elf_Shdr *paShdrs = pModElf->paShdrs;
873 Log2(("rtLdrElf: %s: Fixing up image\n", pszLogName));
874 for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
875 {
876 const Elf_Shdr *pShdrRel = &paShdrs[iShdr];
877
878 /*
879 * Skip sections without interest to us.
880 */
881#if ELF_MODE == 32
882 if (pShdrRel->sh_type != SHT_REL)
883#else
884 if (pShdrRel->sh_type != SHT_RELA)
885#endif
886 continue;
887 if (pShdrRel->sh_info >= pModElf->Ehdr.e_shnum)
888 continue;
889 const Elf_Shdr *pShdr = &paShdrs[pShdrRel->sh_info]; /* the section to fixup. */
890 if (!(pShdr->sh_flags & SHF_ALLOC))
891 continue;
892
893 /*
894 * Relocate the section.
895 */
896 Log2(("rtldrELF: %s: Relocation records for #%d [%s] (sh_info=%d sh_link=%d) found in #%d [%s] (sh_info=%d sh_link=%d)\n",
897 pszLogName, (int)pShdrRel->sh_info, ELF_SH_STR(pModElf, pShdr->sh_name), (int)pShdr->sh_info, (int)pShdr->sh_link,
898 iShdr, ELF_SH_STR(pModElf, pShdrRel->sh_name), (int)pShdrRel->sh_info, (int)pShdrRel->sh_link));
899
900 /** @todo Make RelocateSection a function pointer so we can select the one corresponding to the machine when opening the image. */
901 if (pModElf->Ehdr.e_type == ET_REL)
902 rc = RTLDRELF_NAME(RelocateSection)(pModElf, BaseAddr, pfnGetImport, pvUser,
903 pShdr->sh_addr,
904 pShdr->sh_size,
905 (const uint8_t *)pModElf->pvBits + pShdr->sh_offset,
906 (uint8_t *)pvBits + pShdr->sh_addr,
907 (const uint8_t *)pModElf->pvBits + pShdrRel->sh_offset,
908 pShdrRel->sh_size);
909 else
910 rc = RTLDRELF_NAME(RelocateSectionExecDyn)(pModElf, BaseAddr, pfnGetImport, pvUser,
911 pShdr->sh_addr,
912 pShdr->sh_size,
913 (const uint8_t *)pModElf->pvBits + pShdr->sh_offset,
914 (uint8_t *)pvBits + pShdr->sh_addr,
915 (const uint8_t *)pModElf->pvBits + pShdrRel->sh_offset,
916 pShdrRel->sh_size);
917 if (RT_FAILURE(rc))
918 return rc;
919 }
920 return VINF_SUCCESS;
921}
922
923
924/**
925 * Worker for pfnGetSymbolEx.
926 */
927static int RTLDRELF_NAME(ReturnSymbol)(PRTLDRMODELF pThis, const Elf_Sym *pSym, Elf_Addr uBaseAddr, PRTUINTPTR pValue)
928{
929 Elf_Addr Value;
930 if (pSym->st_shndx == SHN_ABS)
931 /* absolute symbols are not subject to any relocation. */
932 Value = pSym->st_value;
933 else if (pSym->st_shndx < pThis->Ehdr.e_shnum)
934 {
935 if (pThis->Ehdr.e_type == ET_REL)
936 /* relative to the section. */
937 Value = uBaseAddr + pSym->st_value + pThis->paShdrs[pSym->st_shndx].sh_addr;
938 else /* Fixed up for link address. */
939 Value = uBaseAddr + pSym->st_value - pThis->LinkAddress;
940 }
941 else
942 {
943 AssertMsgFailed(("Arg! pSym->st_shndx=%d\n", pSym->st_shndx));
944 return VERR_BAD_EXE_FORMAT;
945 }
946 AssertMsgReturn(Value == (RTUINTPTR)Value, (FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
947 *pValue = (RTUINTPTR)Value;
948 return VINF_SUCCESS;
949}
950
951
952/** @copydoc RTLDROPS::pfnGetSymbolEx */
953static DECLCALLBACK(int) RTLDRELF_NAME(GetSymbolEx)(PRTLDRMODINTERNAL pMod, const void *pvBits, RTUINTPTR BaseAddress,
954 uint32_t iOrdinal, const char *pszSymbol, RTUINTPTR *pValue)
955{
956 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
957 NOREF(pvBits);
958
959 /*
960 * Validate the input.
961 */
962 Elf_Addr uBaseAddr = (Elf_Addr)BaseAddress;
963 AssertMsgReturn((RTUINTPTR)uBaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
964
965 /*
966 * Map the image bits if not already done and setup pointer into it.
967 */
968 int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
969 if (RT_FAILURE(rc))
970 return rc;
971
972 /*
973 * Calc all kinds of pointers before we start iterating the symbol table.
974 */
975 const Elf_Sym *paSyms = pModElf->paSyms;
976 unsigned cSyms = pModElf->cSyms;
977 if (iOrdinal == UINT32_MAX)
978 {
979 const char *pStr = pModElf->pStr;
980 for (unsigned iSym = 1; iSym < cSyms; iSym++)
981 {
982 /* Undefined symbols are not exports, they are imports. */
983 if ( paSyms[iSym].st_shndx != SHN_UNDEF
984 && ( ELF_ST_BIND(paSyms[iSym].st_info) == STB_GLOBAL
985 || ELF_ST_BIND(paSyms[iSym].st_info) == STB_WEAK))
986 {
987 /* Validate the name string and try match with it. */
988 if (paSyms[iSym].st_name < pModElf->cbStr)
989 {
990 if (!strcmp(pszSymbol, pStr + paSyms[iSym].st_name))
991 {
992 /* matched! */
993 return RTLDRELF_NAME(ReturnSymbol)(pModElf, &paSyms[iSym], uBaseAddr, pValue);
994 }
995 }
996 else
997 {
998 AssertMsgFailed(("String outside string table! iSym=%d paSyms[iSym].st_name=%#x\n", iSym, paSyms[iSym].st_name));
999 return VERR_LDRELF_INVALID_SYMBOL_NAME_OFFSET;
1000 }
1001 }
1002 }
1003 }
1004 else if (iOrdinal < cSyms)
1005 {
1006 if ( paSyms[iOrdinal].st_shndx != SHN_UNDEF
1007 && ( ELF_ST_BIND(paSyms[iOrdinal].st_info) == STB_GLOBAL
1008 || ELF_ST_BIND(paSyms[iOrdinal].st_info) == STB_WEAK))
1009 return RTLDRELF_NAME(ReturnSymbol)(pModElf, &paSyms[iOrdinal], uBaseAddr, pValue);
1010 }
1011
1012 return VERR_SYMBOL_NOT_FOUND;
1013}
1014
1015
1016/** @copydoc RTLDROPS::pfnEnumDbgInfo */
1017static DECLCALLBACK(int) RTLDRELF_NAME(EnumDbgInfo)(PRTLDRMODINTERNAL pMod, const void *pvBits,
1018 PFNRTLDRENUMDBG pfnCallback, void *pvUser)
1019{
1020 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1021
1022 /*
1023 * Map the image bits if not already done and setup pointer into it.
1024 */
1025 int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
1026 if (RT_FAILURE(rc))
1027 return rc;
1028
1029 /*
1030 * Do the enumeration.
1031 */
1032 const Elf_Shdr *paShdrs = pModElf->paOrgShdrs;
1033 for (unsigned iShdr = 0; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
1034 {
1035 /* Debug sections are expected to be PROGBITS and not allocated. */
1036 if (paShdrs[iShdr].sh_type != SHT_PROGBITS)
1037 continue;
1038 if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
1039 continue;
1040
1041 RTLDRDBGINFO DbgInfo;
1042 const char *pszSectName = ELF_SH_STR(pModElf, paShdrs[iShdr].sh_name);
1043 if ( !strncmp(pszSectName, RT_STR_TUPLE(".debug_"))
1044 || !strcmp(pszSectName, ".WATCOM_references") )
1045 {
1046 RT_ZERO(DbgInfo.u);
1047 DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF;
1048 DbgInfo.pszExtFile = NULL;
1049 DbgInfo.offFile = paShdrs[iShdr].sh_offset;
1050 DbgInfo.cb = paShdrs[iShdr].sh_size;
1051 DbgInfo.u.Dwarf.pszSection = pszSectName;
1052 }
1053 else if (!strcmp(pszSectName, ".gnu_debuglink"))
1054 {
1055 if ((paShdrs[iShdr].sh_size & 3) || paShdrs[iShdr].sh_size < 8)
1056 return VERR_BAD_EXE_FORMAT;
1057
1058 RT_ZERO(DbgInfo.u);
1059 DbgInfo.enmType = RTLDRDBGINFOTYPE_DWARF_DWO;
1060 DbgInfo.pszExtFile = (const char *)((uintptr_t)pModElf->pvBits + (uintptr_t)paShdrs[iShdr].sh_offset);
1061 if (!RTStrEnd(DbgInfo.pszExtFile, paShdrs[iShdr].sh_size))
1062 return VERR_BAD_EXE_FORMAT;
1063 DbgInfo.u.Dwo.uCrc32 = *(uint32_t *)((uintptr_t)DbgInfo.pszExtFile + (uintptr_t)paShdrs[iShdr].sh_size
1064 - sizeof(uint32_t));
1065 DbgInfo.offFile = -1;
1066 DbgInfo.cb = 0;
1067 }
1068 else
1069 continue;
1070
1071 DbgInfo.LinkAddress = NIL_RTLDRADDR;
1072 DbgInfo.iDbgInfo = iShdr - 1;
1073
1074 rc = pfnCallback(pMod, &DbgInfo, pvUser);
1075 if (rc != VINF_SUCCESS)
1076 return rc;
1077
1078 }
1079
1080 return VINF_SUCCESS;
1081}
1082
1083
1084/**
1085 * Helper that locates the first allocated section.
1086 *
1087 * @returns Pointer to the section header if found, NULL if none.
1088 * @param pShdr The section header to start searching at.
1089 * @param cLeft The number of section headers left to search. Can be 0.
1090 */
1091static const Elf_Shdr *RTLDRELF_NAME(GetFirstAllocatedSection)(const Elf_Shdr *pShdr, unsigned cLeft)
1092{
1093 while (cLeft-- > 0)
1094 {
1095 if (pShdr->sh_flags & SHF_ALLOC)
1096 return pShdr;
1097 pShdr++;
1098 }
1099 return NULL;
1100}
1101
1102/** @copydoc RTLDROPS::pfnEnumSegments. */
1103static DECLCALLBACK(int) RTLDRELF_NAME(EnumSegments)(PRTLDRMODINTERNAL pMod, PFNRTLDRENUMSEGS pfnCallback, void *pvUser)
1104{
1105 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1106
1107 /*
1108 * Map the image bits if not already done and setup pointer into it.
1109 */
1110 int rc = RTLDRELF_NAME(MapBits)(pModElf, true);
1111 if (RT_FAILURE(rc))
1112 return rc;
1113
1114 /*
1115 * Do the enumeration.
1116 */
1117 char szName[32];
1118 Elf_Addr uPrevMappedRva = 0;
1119 const Elf_Shdr *paShdrs = pModElf->paShdrs;
1120 const Elf_Shdr *paOrgShdrs = pModElf->paOrgShdrs;
1121 for (unsigned iShdr = 1; iShdr < pModElf->Ehdr.e_shnum; iShdr++)
1122 {
1123 RTLDRSEG Seg;
1124 Seg.pszName = ELF_SH_STR(pModElf, paShdrs[iShdr].sh_name);
1125 Seg.cchName = (uint32_t)strlen(Seg.pszName);
1126 if (Seg.cchName == 0)
1127 {
1128 Seg.pszName = szName;
1129 Seg.cchName = (uint32_t)RTStrPrintf(szName, sizeof(szName), "UnamedSect%02u", iShdr);
1130 }
1131 Seg.SelFlat = 0;
1132 Seg.Sel16bit = 0;
1133 Seg.fFlags = 0;
1134 Seg.fProt = RTMEM_PROT_READ;
1135 if (paShdrs[iShdr].sh_flags & SHF_WRITE)
1136 Seg.fProt |= RTMEM_PROT_WRITE;
1137 if (paShdrs[iShdr].sh_flags & SHF_EXECINSTR)
1138 Seg.fProt |= RTMEM_PROT_EXEC;
1139 Seg.cb = paShdrs[iShdr].sh_size;
1140 Seg.Alignment = paShdrs[iShdr].sh_addralign;
1141 if (paShdrs[iShdr].sh_flags & SHF_ALLOC)
1142 {
1143 Seg.LinkAddress = paOrgShdrs[iShdr].sh_addr;
1144 Seg.RVA = paShdrs[iShdr].sh_addr;
1145 const Elf_Shdr *pShdr2 = RTLDRELF_NAME(GetFirstAllocatedSection)(&paShdrs[iShdr + 1],
1146 pModElf->Ehdr.e_shnum - iShdr - 1);
1147 if ( pShdr2
1148 && pShdr2->sh_addr >= paShdrs[iShdr].sh_addr
1149 && Seg.RVA >= uPrevMappedRva)
1150 Seg.cbMapped = pShdr2->sh_addr - paShdrs[iShdr].sh_addr;
1151 else
1152 Seg.cbMapped = RT_MAX(paShdrs[iShdr].sh_size, paShdrs[iShdr].sh_addralign);
1153 uPrevMappedRva = Seg.RVA;
1154 }
1155 else
1156 {
1157 Seg.LinkAddress = NIL_RTLDRADDR;
1158 Seg.RVA = NIL_RTLDRADDR;
1159 Seg.cbMapped = NIL_RTLDRADDR;
1160 }
1161 if (paShdrs[iShdr].sh_type != SHT_NOBITS)
1162 {
1163 Seg.offFile = paShdrs[iShdr].sh_offset;
1164 Seg.cbFile = paShdrs[iShdr].sh_size;
1165 }
1166 else
1167 {
1168 Seg.offFile = -1;
1169 Seg.cbFile = 0;
1170 }
1171
1172 rc = pfnCallback(pMod, &Seg, pvUser);
1173 if (rc != VINF_SUCCESS)
1174 return rc;
1175 }
1176
1177 return VINF_SUCCESS;
1178}
1179
1180
1181/** @copydoc RTLDROPS::pfnLinkAddressToSegOffset. */
1182static DECLCALLBACK(int) RTLDRELF_NAME(LinkAddressToSegOffset)(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress,
1183 uint32_t *piSeg, PRTLDRADDR poffSeg)
1184{
1185 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1186
1187 const Elf_Shdr *pShdrEnd = NULL;
1188 unsigned cLeft = pModElf->Ehdr.e_shnum - 1;
1189 const Elf_Shdr *pShdr = &pModElf->paOrgShdrs[cLeft];
1190 while (cLeft-- > 0)
1191 {
1192 if (pShdr->sh_flags & SHF_ALLOC)
1193 {
1194 RTLDRADDR offSeg = LinkAddress - pShdr->sh_addr;
1195 if (offSeg < pShdr->sh_size)
1196 {
1197 *poffSeg = offSeg;
1198 *piSeg = cLeft;
1199 return VINF_SUCCESS;
1200 }
1201 if (offSeg == pShdr->sh_size)
1202 pShdrEnd = pShdr;
1203 }
1204 pShdr--;
1205 }
1206
1207 if (pShdrEnd)
1208 {
1209 *poffSeg = pShdrEnd->sh_size;
1210 *piSeg = pShdrEnd - pModElf->paOrgShdrs - 1;
1211 return VINF_SUCCESS;
1212 }
1213
1214 return VERR_LDR_INVALID_LINK_ADDRESS;
1215}
1216
1217
1218/** @copydoc RTLDROPS::pfnLinkAddressToRva. */
1219static DECLCALLBACK(int) RTLDRELF_NAME(LinkAddressToRva)(PRTLDRMODINTERNAL pMod, RTLDRADDR LinkAddress, PRTLDRADDR pRva)
1220{
1221 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1222 uint32_t iSeg;
1223 RTLDRADDR offSeg;
1224 int rc = RTLDRELF_NAME(LinkAddressToSegOffset)(pMod, LinkAddress, &iSeg, &offSeg);
1225 if (RT_SUCCESS(rc))
1226 *pRva = pModElf->paShdrs[iSeg + 1].sh_addr + offSeg;
1227 return rc;
1228}
1229
1230
1231/** @copydoc RTLDROPS::pfnSegOffsetToRva. */
1232static DECLCALLBACK(int) RTLDRELF_NAME(SegOffsetToRva)(PRTLDRMODINTERNAL pMod, uint32_t iSeg, RTLDRADDR offSeg,
1233 PRTLDRADDR pRva)
1234{
1235 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1236 if (iSeg >= pModElf->Ehdr.e_shnum - 1U)
1237 return VERR_LDR_INVALID_SEG_OFFSET;
1238
1239 iSeg++; /* skip section 0 */
1240 if (offSeg > pModElf->paShdrs[iSeg].sh_size)
1241 {
1242 const Elf_Shdr *pShdr2 = RTLDRELF_NAME(GetFirstAllocatedSection)(&pModElf->paShdrs[iSeg + 1],
1243 pModElf->Ehdr.e_shnum - iSeg - 1);
1244 if ( !pShdr2
1245 || offSeg > (pShdr2->sh_addr - pModElf->paShdrs[iSeg].sh_addr))
1246 return VERR_LDR_INVALID_SEG_OFFSET;
1247 }
1248
1249 if (!(pModElf->paShdrs[iSeg].sh_flags & SHF_ALLOC))
1250 return VERR_LDR_INVALID_SEG_OFFSET;
1251
1252 *pRva = pModElf->paShdrs[iSeg].sh_addr;
1253 return VINF_SUCCESS;
1254}
1255
1256
1257/** @copydoc RTLDROPS::pfnRvaToSegOffset. */
1258static DECLCALLBACK(int) RTLDRELF_NAME(RvaToSegOffset)(PRTLDRMODINTERNAL pMod, RTLDRADDR Rva,
1259 uint32_t *piSeg, PRTLDRADDR poffSeg)
1260{
1261 PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
1262
1263 Elf_Addr PrevAddr = 0;
1264 unsigned cLeft = pModElf->Ehdr.e_shnum - 1;
1265 const Elf_Shdr *pShdr = &pModElf->paShdrs[cLeft];
1266 while (cLeft-- > 0)
1267 {
1268 if (pShdr->sh_flags & SHF_ALLOC)
1269 {
1270 Elf_Addr cbSeg = PrevAddr ? PrevAddr - pShdr->sh_addr : pShdr->sh_size;
1271 RTLDRADDR offSeg = Rva - pShdr->sh_addr;
1272 if (offSeg <= cbSeg)
1273 {
1274 *poffSeg = offSeg;
1275 *piSeg = cLeft;
1276 return VINF_SUCCESS;
1277 }
1278 PrevAddr = pShdr->sh_addr;
1279 }
1280 pShdr--;
1281 }
1282
1283 return VERR_LDR_INVALID_RVA;
1284}
1285
1286
1287/** @callback_method_impl{FNRTLDRIMPORT, Stub used by ReadDbgInfo.} */
1288static DECLCALLBACK(int) RTLDRELF_NAME(GetImportStubCallback)(RTLDRMOD hLdrMod, const char *pszModule, const char *pszSymbol,
1289 unsigned uSymbol, PRTLDRADDR pValue, void *pvUser)
1290{
1291 return VERR_SYMBOL_NOT_FOUND;
1292}
1293
1294
1295/** @copydoc RTLDROPS::pfnRvaToSegOffset. */
1296static DECLCALLBACK(int) RTLDRELF_NAME(ReadDbgInfo)(PRTLDRMODINTERNAL pMod, uint32_t iDbgInfo, RTFOFF off,
1297 size_t cb, void *pvBuf)
1298{
1299 PRTLDRMODELF pThis = (PRTLDRMODELF)pMod;
1300 LogFlow(("%s: iDbgInfo=%#x off=%RTfoff cb=%#zu\n", __FUNCTION__, iDbgInfo, off, cb));
1301
1302 /*
1303 * Input validation.
1304 */
1305 AssertReturn(iDbgInfo < pThis->Ehdr.e_shnum && iDbgInfo + 1 < pThis->Ehdr.e_shnum, VERR_INVALID_PARAMETER);
1306 iDbgInfo++;
1307 AssertReturn(!(pThis->paShdrs[iDbgInfo].sh_flags & SHF_ALLOC), VERR_INVALID_PARAMETER);
1308 AssertReturn(pThis->paShdrs[iDbgInfo].sh_type == SHT_PROGBITS, VERR_INVALID_PARAMETER);
1309 AssertReturn(pThis->paShdrs[iDbgInfo].sh_offset == (uint64_t)off, VERR_INVALID_PARAMETER);
1310 AssertReturn(pThis->paShdrs[iDbgInfo].sh_size == cb, VERR_INVALID_PARAMETER);
1311 RTFOFF cbRawImage = pThis->Core.pReader->pfnSize(pThis->Core.pReader);
1312 AssertReturn(cbRawImage >= 0, VERR_INVALID_PARAMETER);
1313 AssertReturn(off >= 0 && cb <= (uint64_t)cbRawImage && (uint64_t)off + cb <= (uint64_t)cbRawImage, VERR_INVALID_PARAMETER);
1314
1315 /*
1316 * Read it from the file and look for fixup sections.
1317 */
1318 int rc;
1319 if (pThis->pvBits)
1320 memcpy(pvBuf, (const uint8_t *)pThis->pvBits + (size_t)off, cb);
1321 else
1322 {
1323 rc = pThis->Core.pReader->pfnRead(pThis->Core.pReader, pvBuf, cb, off);
1324 if (RT_FAILURE(rc))
1325 return rc;
1326 }
1327
1328 uint32_t iRelocs = iDbgInfo + 1;
1329 if ( iRelocs >= pThis->Ehdr.e_shnum
1330 || pThis->paShdrs[iRelocs].sh_info != iDbgInfo
1331 || ( pThis->paShdrs[iRelocs].sh_type != SHT_REL
1332 && pThis->paShdrs[iRelocs].sh_type != SHT_RELA) )
1333 {
1334 iRelocs = 0;
1335 while ( iRelocs < pThis->Ehdr.e_shnum
1336 && ( pThis->paShdrs[iRelocs].sh_info != iDbgInfo
1337 || ( pThis->paShdrs[iRelocs].sh_type != SHT_REL
1338 && pThis->paShdrs[iRelocs].sh_type != SHT_RELA)) )
1339 iRelocs++;
1340 }
1341 if ( iRelocs < pThis->Ehdr.e_shnum
1342 && pThis->paShdrs[iRelocs].sh_size > 0)
1343 {
1344 /*
1345 * Load the relocations.
1346 */
1347 uint8_t *pbRelocsBuf = NULL;
1348 const uint8_t *pbRelocs;
1349 if (pThis->pvBits)
1350 pbRelocs = (const uint8_t *)pThis->pvBits + pThis->paShdrs[iRelocs].sh_offset;
1351 else
1352 {
1353 pbRelocs = pbRelocsBuf = (uint8_t *)RTMemTmpAlloc(pThis->paShdrs[iRelocs].sh_size);
1354 if (!pbRelocsBuf)
1355 return VERR_NO_TMP_MEMORY;
1356 rc = pThis->Core.pReader->pfnRead(pThis->Core.pReader, pbRelocsBuf,
1357 pThis->paShdrs[iRelocs].sh_size,
1358 pThis->paShdrs[iRelocs].sh_offset);
1359 if (RT_FAILURE(rc))
1360 {
1361 RTMemTmpFree(pbRelocsBuf);
1362 return rc;
1363 }
1364 }
1365
1366 /*
1367 * Apply the relocations.
1368 */
1369 if (pThis->Ehdr.e_type == ET_REL)
1370 rc = RTLDRELF_NAME(RelocateSection)(pThis, pThis->LinkAddress,
1371 RTLDRELF_NAME(GetImportStubCallback), NULL /*pvUser*/,
1372 pThis->paShdrs[iDbgInfo].sh_addr,
1373 pThis->paShdrs[iDbgInfo].sh_size,
1374 (const uint8_t *)pvBuf,
1375 (uint8_t *)pvBuf,
1376 pbRelocs,
1377 pThis->paShdrs[iRelocs].sh_size);
1378 else
1379 rc = RTLDRELF_NAME(RelocateSectionExecDyn)(pThis, pThis->LinkAddress,
1380 RTLDRELF_NAME(GetImportStubCallback), NULL /*pvUser*/,
1381 pThis->paShdrs[iDbgInfo].sh_addr,
1382 pThis->paShdrs[iDbgInfo].sh_size,
1383 (const uint8_t *)pvBuf,
1384 (uint8_t *)pvBuf,
1385 pbRelocs,
1386 pThis->paShdrs[iRelocs].sh_size);
1387
1388 RTMemTmpFree(pbRelocsBuf);
1389 }
1390 else
1391 rc = VINF_SUCCESS;
1392 return rc;
1393}
1394
1395
1396
1397/**
1398 * The ELF module operations.
1399 */
1400static RTLDROPS RTLDRELF_MID(s_rtldrElf,Ops) =
1401{
1402#if ELF_MODE == 32
1403 "elf32",
1404#elif ELF_MODE == 64
1405 "elf64",
1406#endif
1407 RTLDRELF_NAME(Close),
1408 NULL, /* Get Symbol */
1409 RTLDRELF_NAME(Done),
1410 RTLDRELF_NAME(EnumSymbols),
1411 /* ext: */
1412 RTLDRELF_NAME(GetImageSize),
1413 RTLDRELF_NAME(GetBits),
1414 RTLDRELF_NAME(Relocate),
1415 RTLDRELF_NAME(GetSymbolEx),
1416 NULL /*pfnQueryForwarderInfo*/,
1417 RTLDRELF_NAME(EnumDbgInfo),
1418 RTLDRELF_NAME(EnumSegments),
1419 RTLDRELF_NAME(LinkAddressToSegOffset),
1420 RTLDRELF_NAME(LinkAddressToRva),
1421 RTLDRELF_NAME(SegOffsetToRva),
1422 RTLDRELF_NAME(RvaToSegOffset),
1423 RTLDRELF_NAME(ReadDbgInfo),
1424 NULL /*pfnQueryProp*/,
1425 NULL /*pfnVerifySignature*/,
1426 NULL /*pfnHashImage*/,
1427 42
1428};
1429
1430
1431
1432/**
1433 * Validates the ELF header.
1434 *
1435 * @returns iprt status code.
1436 * @param pEhdr Pointer to the ELF header.
1437 * @param pszLogName The log name.
1438 * @param cbRawImage The size of the raw image.
1439 */
1440static int RTLDRELF_NAME(ValidateElfHeader)(const Elf_Ehdr *pEhdr, const char *pszLogName, uint64_t cbRawImage,
1441 PRTLDRARCH penmArch)
1442{
1443 Log3(("RTLdrELF: e_ident: %.*Rhxs\n"
1444 "RTLdrELF: e_type: " FMT_ELF_HALF "\n"
1445 "RTLdrELF: e_version: " FMT_ELF_HALF "\n"
1446 "RTLdrELF: e_entry: " FMT_ELF_ADDR "\n"
1447 "RTLdrELF: e_phoff: " FMT_ELF_OFF "\n"
1448 "RTLdrELF: e_shoff: " FMT_ELF_OFF "\n"
1449 "RTLdrELF: e_flags: " FMT_ELF_WORD "\n"
1450 "RTLdrELF: e_ehsize: " FMT_ELF_HALF "\n"
1451 "RTLdrELF: e_phentsize: " FMT_ELF_HALF "\n"
1452 "RTLdrELF: e_phnum: " FMT_ELF_HALF "\n"
1453 "RTLdrELF: e_shentsize: " FMT_ELF_HALF "\n"
1454 "RTLdrELF: e_shnum: " FMT_ELF_HALF "\n"
1455 "RTLdrELF: e_shstrndx: " FMT_ELF_HALF "\n",
1456 RT_ELEMENTS(pEhdr->e_ident), &pEhdr->e_ident[0], pEhdr->e_type, pEhdr->e_version,
1457 pEhdr->e_entry, pEhdr->e_phoff, pEhdr->e_shoff,pEhdr->e_flags, pEhdr->e_ehsize, pEhdr->e_phentsize,
1458 pEhdr->e_phnum, pEhdr->e_shentsize, pEhdr->e_shnum, pEhdr->e_shstrndx));
1459
1460 if ( pEhdr->e_ident[EI_MAG0] != ELFMAG0
1461 || pEhdr->e_ident[EI_MAG1] != ELFMAG1
1462 || pEhdr->e_ident[EI_MAG2] != ELFMAG2
1463 || pEhdr->e_ident[EI_MAG3] != ELFMAG3
1464 )
1465 {
1466 Log(("RTLdrELF: %s: Invalid ELF magic (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident)); NOREF(pszLogName);
1467 return VERR_BAD_EXE_FORMAT;
1468 }
1469 if (pEhdr->e_ident[EI_CLASS] != RTLDRELF_SUFF(ELFCLASS))
1470 {
1471 Log(("RTLdrELF: %s: Invalid ELF class (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident));
1472 return VERR_BAD_EXE_FORMAT;
1473 }
1474 if (pEhdr->e_ident[EI_DATA] != ELFDATA2LSB)
1475 {
1476 Log(("RTLdrELF: %s: ELF endian %x is unsupported\n", pEhdr->e_ident[EI_DATA]));
1477 return VERR_LDRELF_ODD_ENDIAN;
1478 }
1479 if (pEhdr->e_version != EV_CURRENT)
1480 {
1481 Log(("RTLdrELF: %s: ELF version %x is unsupported\n", pEhdr->e_version));
1482 return VERR_LDRELF_VERSION;
1483 }
1484
1485 if (sizeof(Elf_Ehdr) != pEhdr->e_ehsize)
1486 {
1487 Log(("RTLdrELF: %s: Elf header e_ehsize is %d expected %d!\n",
1488 pszLogName, pEhdr->e_ehsize, sizeof(Elf_Ehdr)));
1489 return VERR_BAD_EXE_FORMAT;
1490 }
1491 if ( sizeof(Elf_Phdr) != pEhdr->e_phentsize
1492 && ( pEhdr->e_phnum != 0
1493 || pEhdr->e_type == ET_DYN))
1494 {
1495 Log(("RTLdrELF: %s: Elf header e_phentsize is %d expected %d!\n",
1496 pszLogName, pEhdr->e_phentsize, sizeof(Elf_Phdr)));
1497 return VERR_BAD_EXE_FORMAT;
1498 }
1499 if (sizeof(Elf_Shdr) != pEhdr->e_shentsize)
1500 {
1501 Log(("RTLdrELF: %s: Elf header e_shentsize is %d expected %d!\n",
1502 pszLogName, pEhdr->e_shentsize, sizeof(Elf_Shdr)));
1503 return VERR_BAD_EXE_FORMAT;
1504 }
1505
1506 switch (pEhdr->e_type)
1507 {
1508 case ET_REL:
1509 case ET_EXEC:
1510 case ET_DYN:
1511 break;
1512 default:
1513 Log(("RTLdrELF: %s: image type %#x is not supported!\n", pszLogName, pEhdr->e_type));
1514 return VERR_BAD_EXE_FORMAT;
1515 }
1516
1517 switch (pEhdr->e_machine)
1518 {
1519#if ELF_MODE == 32
1520 case EM_386:
1521 case EM_486:
1522 *penmArch = RTLDRARCH_X86_32;
1523 break;
1524#elif ELF_MODE == 64
1525 case EM_X86_64:
1526 *penmArch = RTLDRARCH_AMD64;
1527 break;
1528#endif
1529 default:
1530 Log(("RTLdrELF: %s: machine type %u is not supported!\n", pEhdr->e_machine));
1531 return VERR_LDRELF_MACHINE;
1532 }
1533
1534 if ( pEhdr->e_phoff < pEhdr->e_ehsize
1535 && !(pEhdr->e_phoff && pEhdr->e_phnum)
1536 && pEhdr->e_phnum)
1537 {
1538 Log(("RTLdrELF: %s: The program headers overlap with the ELF header! e_phoff=" FMT_ELF_OFF "\n",
1539 pszLogName, pEhdr->e_phoff));
1540 return VERR_BAD_EXE_FORMAT;
1541 }
1542 if ( pEhdr->e_phoff + pEhdr->e_phnum * pEhdr->e_phentsize > cbRawImage
1543 || pEhdr->e_phoff + pEhdr->e_phnum * pEhdr->e_phentsize < pEhdr->e_phoff)
1544 {
1545 Log(("RTLdrELF: %s: The program headers extends beyond the file! e_phoff=" FMT_ELF_OFF " e_phnum=" FMT_ELF_HALF "\n",
1546 pszLogName, pEhdr->e_phoff, pEhdr->e_phnum));
1547 return VERR_BAD_EXE_FORMAT;
1548 }
1549
1550
1551 if ( pEhdr->e_shoff < pEhdr->e_ehsize
1552 && !(pEhdr->e_shoff && pEhdr->e_shnum))
1553 {
1554 Log(("RTLdrELF: %s: The section headers overlap with the ELF header! e_shoff=" FMT_ELF_OFF "\n",
1555 pszLogName, pEhdr->e_shoff));
1556 return VERR_BAD_EXE_FORMAT;
1557 }
1558 if ( pEhdr->e_shoff + pEhdr->e_shnum * pEhdr->e_shentsize > cbRawImage
1559 || pEhdr->e_shoff + pEhdr->e_shnum * pEhdr->e_shentsize < pEhdr->e_shoff)
1560 {
1561 Log(("RTLdrELF: %s: The section headers extends beyond the file! e_shoff=" FMT_ELF_OFF " e_shnum=" FMT_ELF_HALF "\n",
1562 pszLogName, pEhdr->e_shoff, pEhdr->e_shnum));
1563 return VERR_BAD_EXE_FORMAT;
1564 }
1565
1566 if (pEhdr->e_shstrndx == 0 || pEhdr->e_shstrndx > pEhdr->e_shnum)
1567 {
1568 Log(("RTLdrELF: %s: The section headers string table is out of bounds! e_shstrndx=" FMT_ELF_HALF " e_shnum=" FMT_ELF_HALF "\n",
1569 pszLogName, pEhdr->e_shstrndx, pEhdr->e_shnum));
1570 return VERR_BAD_EXE_FORMAT;
1571 }
1572
1573 return VINF_SUCCESS;
1574}
1575
1576/**
1577 * Gets the section header name.
1578 *
1579 * @returns pszName.
1580 * @param pEhdr The elf header.
1581 * @param offName The offset of the section header name.
1582 * @param pszName Where to store the name.
1583 * @param cbName The size of the buffer pointed to by pszName.
1584 */
1585const char *RTLDRELF_NAME(GetSHdrName)(PRTLDRMODELF pModElf, Elf_Word offName, char *pszName, size_t cbName)
1586{
1587 RTFOFF off = pModElf->paShdrs[pModElf->Ehdr.e_shstrndx].sh_offset + offName;
1588 int rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName, cbName - 1, off);
1589 if (RT_FAILURE(rc))
1590 {
1591 /* read by for byte. */
1592 for (unsigned i = 0; i < cbName; i++, off++)
1593 {
1594 rc = pModElf->Core.pReader->pfnRead(pModElf->Core.pReader, pszName + i, 1, off);
1595 if (RT_FAILURE(rc))
1596 {
1597 pszName[i] = '\0';
1598 break;
1599 }
1600 }
1601 }
1602
1603 pszName[cbName - 1] = '\0';
1604 return pszName;
1605}
1606
1607
1608/**
1609 * Validates a section header.
1610 *
1611 * @returns iprt status code.
1612 * @param pModElf Pointer to the module structure.
1613 * @param iShdr The index of section header which should be validated.
1614 * The section headers are found in the pModElf->paShdrs array.
1615 * @param pszLogName The log name.
1616 * @param cbRawImage The size of the raw image.
1617 */
1618static int RTLDRELF_NAME(ValidateSectionHeader)(PRTLDRMODELF pModElf, unsigned iShdr, const char *pszLogName, RTFOFF cbRawImage)
1619{
1620 const Elf_Shdr *pShdr = &pModElf->paShdrs[iShdr];
1621 char szSectionName[80]; NOREF(szSectionName);
1622 Log3(("RTLdrELF: Section Header #%d:\n"
1623 "RTLdrELF: sh_name: " FMT_ELF_WORD " - %s\n"
1624 "RTLdrELF: sh_type: " FMT_ELF_WORD " (%s)\n"
1625 "RTLdrELF: sh_flags: " FMT_ELF_XWORD "\n"
1626 "RTLdrELF: sh_addr: " FMT_ELF_ADDR "\n"
1627 "RTLdrELF: sh_offset: " FMT_ELF_OFF "\n"
1628 "RTLdrELF: sh_size: " FMT_ELF_XWORD "\n"
1629 "RTLdrELF: sh_link: " FMT_ELF_WORD "\n"
1630 "RTLdrELF: sh_info: " FMT_ELF_WORD "\n"
1631 "RTLdrELF: sh_addralign: " FMT_ELF_XWORD "\n"
1632 "RTLdrELF: sh_entsize: " FMT_ELF_XWORD "\n",
1633 iShdr,
1634 pShdr->sh_name, RTLDRELF_NAME(GetSHdrName)(pModElf, pShdr->sh_name, szSectionName, sizeof(szSectionName)),
1635 pShdr->sh_type, rtldrElfGetShdrType(pShdr->sh_type), pShdr->sh_flags, pShdr->sh_addr,
1636 pShdr->sh_offset, pShdr->sh_size, pShdr->sh_link, pShdr->sh_info, pShdr->sh_addralign,
1637 pShdr->sh_entsize));
1638
1639 if (iShdr == 0)
1640 {
1641 if ( pShdr->sh_name != 0
1642 || pShdr->sh_type != SHT_NULL
1643 || pShdr->sh_flags != 0
1644 || pShdr->sh_addr != 0
1645 || pShdr->sh_size != 0
1646 || pShdr->sh_offset != 0
1647 || pShdr->sh_link != SHN_UNDEF
1648 || pShdr->sh_addralign != 0
1649 || pShdr->sh_entsize != 0 )
1650 {
1651 Log(("RTLdrELF: %s: Bad #0 section: %.*Rhxs\n", pszLogName, sizeof(*pShdr), pShdr ));
1652 return VERR_BAD_EXE_FORMAT;
1653 }
1654 return VINF_SUCCESS;
1655 }
1656
1657 if (pShdr->sh_name >= pModElf->cbShStr)
1658 {
1659 Log(("RTLdrELF: %s: Shdr #%d: sh_name (%d) is beyond the end of the section header string table (%d)!\n",
1660 pszLogName, iShdr, pShdr->sh_name, pModElf->cbShStr)); NOREF(pszLogName);
1661 return VERR_BAD_EXE_FORMAT;
1662 }
1663
1664 if (pShdr->sh_link >= pModElf->Ehdr.e_shnum)
1665 {
1666 Log(("RTLdrELF: %s: Shdr #%d: sh_link (%d) is beyond the end of the section table (%d)!\n",
1667 pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum)); NOREF(pszLogName);
1668 return VERR_BAD_EXE_FORMAT;
1669 }
1670
1671 switch (pShdr->sh_type)
1672 {
1673 /** @todo find specs and check up which sh_info fields indicates section table entries */
1674 case 12301230:
1675 if (pShdr->sh_info >= pModElf->Ehdr.e_shnum)
1676 {
1677 Log(("RTLdrELF: %s: Shdr #%d: sh_info (%d) is beyond the end of the section table (%d)!\n",
1678 pszLogName, iShdr, pShdr->sh_link, pModElf->Ehdr.e_shnum));
1679 return VERR_BAD_EXE_FORMAT;
1680 }
1681 break;
1682
1683 case SHT_NULL:
1684 break;
1685 case SHT_PROGBITS:
1686 case SHT_SYMTAB:
1687 case SHT_STRTAB:
1688 case SHT_RELA:
1689 case SHT_HASH:
1690 case SHT_DYNAMIC:
1691 case SHT_NOTE:
1692 case SHT_NOBITS:
1693 case SHT_REL:
1694 case SHT_SHLIB:
1695 case SHT_DYNSYM:
1696 /*
1697 * For these types sh_info doesn't have any special meaning, or anything which
1698 * we need/can validate now.
1699 */
1700 break;
1701
1702
1703 default:
1704 Log(("RTLdrELF: %s: Warning, unknown type %d!\n", pszLogName, pShdr->sh_type));
1705 break;
1706 }
1707
1708 if ( pShdr->sh_type != SHT_NOBITS
1709 && pShdr->sh_size)
1710 {
1711 RTFOFF offEnd = pShdr->sh_offset + pShdr->sh_size;
1712 if ( offEnd > cbRawImage
1713 || offEnd < (RTFOFF)pShdr->sh_offset)
1714 {
1715 Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD " = %RTfoff) is beyond the end of the file (%RTfoff)!\n",
1716 pszLogName, iShdr, pShdr->sh_offset, pShdr->sh_size, offEnd, cbRawImage));
1717 return VERR_BAD_EXE_FORMAT;
1718 }
1719 if (pShdr->sh_offset < sizeof(Elf_Ehdr))
1720 {
1721 Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD ") is starting in the ELF header!\n",
1722 pszLogName, iShdr, pShdr->sh_offset, pShdr->sh_size, cbRawImage));
1723 return VERR_BAD_EXE_FORMAT;
1724 }
1725 }
1726
1727 return VINF_SUCCESS;
1728}
1729
1730
1731
1732/**
1733 * Opens an ELF image, fixed bitness.
1734 *
1735 * @returns iprt status code.
1736 * @param pReader The loader reader instance which will provide the raw image bits.
1737 * @param fFlags Reserved, MBZ.
1738 * @param enmArch Architecture specifier.
1739 * @param phLdrMod Where to store the handle.
1740 */
1741static int RTLDRELF_NAME(Open)(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod)
1742{
1743 const char *pszLogName = pReader->pfnLogName(pReader);
1744 RTFOFF cbRawImage = pReader->pfnSize(pReader);
1745
1746 /*
1747 * Create the loader module instance.
1748 */
1749 PRTLDRMODELF pModElf = (PRTLDRMODELF)RTMemAllocZ(sizeof(*pModElf));
1750 if (!pModElf)
1751 return VERR_NO_MEMORY;
1752
1753 pModElf->Core.u32Magic = RTLDRMOD_MAGIC;
1754 pModElf->Core.eState = LDR_STATE_INVALID;
1755 pModElf->Core.pReader = pReader;
1756 pModElf->Core.enmFormat = RTLDRFMT_ELF;
1757 pModElf->Core.enmType = RTLDRTYPE_OBJECT;
1758 pModElf->Core.enmEndian = RTLDRENDIAN_LITTLE;
1759#if ELF_MODE == 32
1760 pModElf->Core.enmArch = RTLDRARCH_X86_32;
1761#else
1762 pModElf->Core.enmArch = RTLDRARCH_AMD64;
1763#endif
1764 //pModElf->pvBits = NULL;
1765 //pModElf->Ehdr = {0};
1766 //pModElf->paShdrs = NULL;
1767 //pModElf->paSyms = NULL;
1768 pModElf->iSymSh = ~0U;
1769 //pModElf->cSyms = 0;
1770 pModElf->iStrSh = ~0U;
1771 //pModElf->cbStr = 0;
1772 //pModElf->cbImage = 0;
1773 //pModElf->LinkAddress = 0;
1774 //pModElf->pStr = NULL;
1775 //pModElf->cbShStr = 0;
1776 //pModElf->pShStr = NULL;
1777
1778 /*
1779 * Read and validate the ELF header and match up the CPU architecture.
1780 */
1781 int rc = pReader->pfnRead(pReader, &pModElf->Ehdr, sizeof(pModElf->Ehdr), 0);
1782 if (RT_SUCCESS(rc))
1783 {
1784 RTLDRARCH enmArchImage = RTLDRARCH_INVALID; /* shut up gcc */
1785 rc = RTLDRELF_NAME(ValidateElfHeader)(&pModElf->Ehdr, pszLogName, cbRawImage, &enmArchImage);
1786 if (RT_SUCCESS(rc))
1787 {
1788 if ( enmArch != RTLDRARCH_WHATEVER
1789 && enmArch != enmArchImage)
1790 rc = VERR_LDR_ARCH_MISMATCH;
1791 }
1792 }
1793 if (RT_SUCCESS(rc))
1794 {
1795 /*
1796 * Read the section headers, keeping a prestine copy for the module
1797 * introspection methods.
1798 */
1799 size_t const cbShdrs = pModElf->Ehdr.e_shnum * sizeof(Elf_Shdr);
1800 Elf_Shdr *paShdrs = (Elf_Shdr *)RTMemAlloc(cbShdrs * 2);
1801 if (paShdrs)
1802 {
1803 pModElf->paShdrs = paShdrs;
1804 rc = pReader->pfnRead(pReader, paShdrs, cbShdrs, pModElf->Ehdr.e_shoff);
1805 if (RT_SUCCESS(rc))
1806 {
1807 memcpy(&paShdrs[pModElf->Ehdr.e_shnum], paShdrs, cbShdrs);
1808 pModElf->paOrgShdrs = &paShdrs[pModElf->Ehdr.e_shnum];
1809
1810 pModElf->cbShStr = paShdrs[pModElf->Ehdr.e_shstrndx].sh_size;
1811
1812 /*
1813 * Validate the section headers and find relevant sections.
1814 */
1815 Elf_Addr uNextAddr = 0;
1816 for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
1817 {
1818 rc = RTLDRELF_NAME(ValidateSectionHeader)(pModElf, i, pszLogName, cbRawImage);
1819 if (RT_FAILURE(rc))
1820 break;
1821
1822 /* We're looking for symbol tables. */
1823 if (paShdrs[i].sh_type == SHT_SYMTAB)
1824 {
1825 if (pModElf->iSymSh != ~0U)
1826 {
1827 Log(("RTLdrElf: %s: Multiple symbol tabs! iSymSh=%d i=%d\n", pszLogName, pModElf->iSymSh, i));
1828 rc = VERR_LDRELF_MULTIPLE_SYMTABS;
1829 break;
1830 }
1831 pModElf->iSymSh = i;
1832 pModElf->cSyms = (unsigned)(paShdrs[i].sh_size / sizeof(Elf_Sym));
1833 AssertReturn(pModElf->cSyms == paShdrs[i].sh_size / sizeof(Elf_Sym), VERR_IMAGE_TOO_BIG);
1834 pModElf->iStrSh = paShdrs[i].sh_link;
1835 pModElf->cbStr = (unsigned)paShdrs[pModElf->iStrSh].sh_size;
1836 AssertReturn(pModElf->cbStr == paShdrs[pModElf->iStrSh].sh_size, VERR_IMAGE_TOO_BIG);
1837 }
1838
1839 /* Special checks for the section string table. */
1840 if (i == pModElf->Ehdr.e_shstrndx)
1841 {
1842 if (paShdrs[i].sh_type != SHT_STRTAB)
1843 {
1844 Log(("RTLdrElf: Section header string table is not a SHT_STRTAB: %#x\n", paShdrs[i].sh_type));
1845 rc = VERR_BAD_EXE_FORMAT;
1846 break;
1847 }
1848 if (paShdrs[i].sh_size == 0)
1849 {
1850 Log(("RTLdrElf: Section header string table is empty\n"));
1851 rc = VERR_BAD_EXE_FORMAT;
1852 break;
1853 }
1854 }
1855
1856 /* Kluge for the .data..percpu segment in 64-bit linux kernels. */
1857 if (paShdrs[i].sh_flags & SHF_ALLOC)
1858 {
1859 if ( paShdrs[i].sh_addr == 0
1860 && paShdrs[i].sh_addr < uNextAddr)
1861 {
1862 Elf_Addr uAddr = RT_ALIGN_T(uNextAddr, paShdrs[i].sh_addralign, Elf_Addr);
1863 Log(("RTLdrElf: Out of order section #%d; adjusting sh_addr from " FMT_ELF_ADDR " to " FMT_ELF_ADDR "\n",
1864 paShdrs[i].sh_addr, uAddr));
1865 paShdrs[i].sh_addr = uAddr;
1866 }
1867 uNextAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size;
1868 }
1869 } /* for each section header */
1870
1871 /*
1872 * Calculate the image base address if the image isn't relocatable.
1873 */
1874 if (RT_SUCCESS(rc) && pModElf->Ehdr.e_type != ET_REL)
1875 {
1876 pModElf->LinkAddress = ~(Elf_Addr)0;
1877 for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
1878 if ( (paShdrs[i].sh_flags & SHF_ALLOC)
1879 && paShdrs[i].sh_addr < pModElf->LinkAddress)
1880 pModElf->LinkAddress = paShdrs[i].sh_addr;
1881 if (pModElf->LinkAddress == ~(Elf_Addr)0)
1882 {
1883 AssertFailed();
1884 rc = VERR_LDR_GENERAL_FAILURE;
1885 }
1886 }
1887
1888 /*
1889 * Perform allocations / RVA calculations, determine the image size.
1890 */
1891 if (RT_SUCCESS(rc))
1892 for (unsigned i = 0; i < pModElf->Ehdr.e_shnum; i++)
1893 if (paShdrs[i].sh_flags & SHF_ALLOC)
1894 {
1895 if (pModElf->Ehdr.e_type == ET_REL)
1896 paShdrs[i].sh_addr = paShdrs[i].sh_addralign
1897 ? RT_ALIGN_T(pModElf->cbImage, paShdrs[i].sh_addralign, Elf_Addr)
1898 : (Elf_Addr)pModElf->cbImage;
1899 else
1900 paShdrs[i].sh_addr -= pModElf->LinkAddress;
1901 Elf_Addr EndAddr = paShdrs[i].sh_addr + paShdrs[i].sh_size;
1902 if (pModElf->cbImage < EndAddr)
1903 {
1904 pModElf->cbImage = (size_t)EndAddr;
1905 AssertMsgReturn(pModElf->cbImage == EndAddr, (FMT_ELF_ADDR "\n", EndAddr), VERR_IMAGE_TOO_BIG);
1906 }
1907 Log2(("RTLdrElf: %s: Assigned " FMT_ELF_ADDR " to section #%d\n", pszLogName, paShdrs[i].sh_addr, i));
1908 }
1909
1910 Log2(("RTLdrElf: iSymSh=%u cSyms=%u iStrSh=%u cbStr=%u rc=%Rrc cbImage=%#zx LinkAddress=" FMT_ELF_ADDR "\n",
1911 pModElf->iSymSh, pModElf->cSyms, pModElf->iStrSh, pModElf->cbStr, rc,
1912 pModElf->cbImage, pModElf->LinkAddress));
1913 if (RT_SUCCESS(rc))
1914 {
1915 pModElf->Core.pOps = &RTLDRELF_MID(s_rtldrElf,Ops);
1916 pModElf->Core.eState = LDR_STATE_OPENED;
1917 *phLdrMod = &pModElf->Core;
1918
1919 LogFlow(("%s: %s: returns VINF_SUCCESS *phLdrMod=%p\n", __FUNCTION__, pszLogName, *phLdrMod));
1920 return VINF_SUCCESS;
1921 }
1922 }
1923
1924 RTMemFree(paShdrs);
1925 }
1926 else
1927 rc = VERR_NO_MEMORY;
1928 }
1929
1930 RTMemFree(pModElf);
1931 LogFlow(("%s: returns %Rrc\n", __FUNCTION__, rc));
1932 return rc;
1933}
1934
1935
1936
1937
1938/*******************************************************************************
1939* Cleanup Constants And Macros *
1940*******************************************************************************/
1941#undef RTLDRELF_NAME
1942#undef RTLDRELF_SUFF
1943#undef RTLDRELF_MID
1944
1945#undef FMT_ELF_ADDR
1946#undef FMT_ELF_HALF
1947#undef FMT_ELF_SHALF
1948#undef FMT_ELF_OFF
1949#undef FMT_ELF_SIZE
1950#undef FMT_ELF_SWORD
1951#undef FMT_ELF_WORD
1952#undef FMT_ELF_XWORD
1953#undef FMT_ELF_SXWORD
1954
1955#undef Elf_Ehdr
1956#undef Elf_Phdr
1957#undef Elf_Shdr
1958#undef Elf_Sym
1959#undef Elf_Rel
1960#undef Elf_Rela
1961#undef Elf_Reloc
1962#undef Elf_Nhdr
1963#undef Elf_Dyn
1964
1965#undef Elf_Addr
1966#undef Elf_Half
1967#undef Elf_Off
1968#undef Elf_Size
1969#undef Elf_Sword
1970#undef Elf_Word
1971
1972#undef RTLDRMODELF
1973#undef PRTLDRMODELF
1974
1975#undef ELF_R_SYM
1976#undef ELF_R_TYPE
1977#undef ELF_R_INFO
1978
1979#undef ELF_ST_BIND
1980
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette