[2826] | 1 | /* $Id: kLdrMod.c 2859 2006-11-06 04:48:53Z bird $ */
|
---|
[2825] | 2 | /** @file
|
---|
| 3 | *
|
---|
[2854] | 4 | * kLdr - The Module Interpreter.
|
---|
[2825] | 5 | *
|
---|
| 6 | * Copyright (c) 2006 knut st. osmundsen <bird-kbuild-src@anduin.net>
|
---|
| 7 | *
|
---|
| 8 | *
|
---|
| 9 | * This file is part of kLdr.
|
---|
| 10 | *
|
---|
| 11 | * kLdr is free software; you can redistribute it and/or modify
|
---|
| 12 | * it under the terms of the GNU General Public License as published by
|
---|
| 13 | * the Free Software Foundation; either version 2 of the License, or
|
---|
| 14 | * (at your option) any later version.
|
---|
| 15 | *
|
---|
| 16 | * kLdr is distributed in the hope that it will be useful,
|
---|
| 17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 19 | * GNU General Public License for more details.
|
---|
| 20 | *
|
---|
| 21 | * You should have received a copy of the GNU General Public License
|
---|
| 22 | * along with kLdr; if not, write to the Free Software
|
---|
| 23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
---|
| 24 | *
|
---|
| 25 | */
|
---|
| 26 |
|
---|
| 27 |
|
---|
| 28 | /*******************************************************************************
|
---|
| 29 | * Header Files *
|
---|
| 30 | *******************************************************************************/
|
---|
| 31 | #include <kLdr.h>
|
---|
| 32 | #include "kLdrHlp.h"
|
---|
| 33 | #include "kLdrInternal.h"
|
---|
[2827] | 34 | #include "kLdrModMZ.h"
|
---|
| 35 | #if 1 /* testing headers */
|
---|
| 36 | # include "kLdrModPE.h"
|
---|
[2828] | 37 | # include "kLdrModLX.h"
|
---|
[2827] | 38 | # include "kLdrModELF32.h"
|
---|
| 39 | # include "kLdrModELF64.h"
|
---|
| 40 | #endif
|
---|
[2825] | 41 |
|
---|
| 42 |
|
---|
[2851] | 43 | /*******************************************************************************
|
---|
| 44 | * Defined Constants And Macros *
|
---|
| 45 | *******************************************************************************/
|
---|
| 46 | /** @def KLDRMOD_STRICT
|
---|
| 47 | * Define KLDRMOD_STRICT to enabled strict checks in KLDRMOD. */
|
---|
| 48 | #define KLDRMOD_STRICT 1
|
---|
| 49 |
|
---|
| 50 | /** @def KLDRMOD_ASSERT
|
---|
| 51 | * Assert that an expression is true when KLDR_STRICT is defined.
|
---|
| 52 | */
|
---|
| 53 | #ifdef KLDRMOD_STRICT
|
---|
| 54 | # define KLDRMOD_ASSERT(expr) kldrHlpAssert(expr)
|
---|
| 55 | #else
|
---|
| 56 | # define KLDRMOD_ASSERT(expr) do {} while (0)
|
---|
| 57 | #endif
|
---|
| 58 |
|
---|
| 59 | /** Return / crash validation of a module argument. */
|
---|
| 60 | #define KLDRMOD_VALIDATE_EX(pMod, rc) \
|
---|
| 61 | do { \
|
---|
| 62 | if ( (pMod)->u32Magic != KLDRMOD_MAGIC \
|
---|
| 63 | || (pMod)->pOps == NULL \
|
---|
| 64 | )\
|
---|
| 65 | { \
|
---|
| 66 | return (rc); \
|
---|
| 67 | } \
|
---|
| 68 | } while (0)
|
---|
| 69 |
|
---|
| 70 | /** Return / crash validation of a module argument. */
|
---|
| 71 | #define KLDRMOD_VALIDATE(pMod) \
|
---|
| 72 | KLDRMOD_VALIDATE_EX(pMod, KLDR_ERR_INVALID_PARAMETER)
|
---|
| 73 |
|
---|
| 74 | /** Return / crash validation of a module argument. */
|
---|
| 75 | #define KLDRMOD_VALIDATE_VOID(pMod) \
|
---|
| 76 | do { \
|
---|
| 77 | if ( (pMod)->u32Magic != KLDRMOD_MAGIC \
|
---|
| 78 | || (pMod)->pOps == NULL \
|
---|
| 79 | )\
|
---|
| 80 | { \
|
---|
| 81 | return; \
|
---|
| 82 | } \
|
---|
| 83 | } while (0)
|
---|
| 84 |
|
---|
| 85 |
|
---|
| 86 | /*******************************************************************************
|
---|
| 87 | * Global Variables *
|
---|
| 88 | *******************************************************************************/
|
---|
| 89 | /** The list of module interpreters. */
|
---|
| 90 | static PCKLDRMODOPS g_pModInterpreterHead = NULL;
|
---|
| 91 |
|
---|
| 92 |
|
---|
| 93 |
|
---|
| 94 | /*******************************************************************************
|
---|
| 95 | * Internal Functions *
|
---|
| 96 | *******************************************************************************/
|
---|
| 97 |
|
---|
| 98 |
|
---|
| 99 |
|
---|
[2827] | 100 | /**
|
---|
[2848] | 101 | * Open a executable image by file name.
|
---|
| 102 | *
|
---|
| 103 | * @returns 0 on success and *ppMod pointing to a module instance.
|
---|
| 104 | * On failure, a non-zero OS specific error code is returned.
|
---|
| 105 | * @param pszFilename The filename to open.
|
---|
| 106 | * @param ppMod Where to store the module handle.
|
---|
| 107 | */
|
---|
| 108 | int kLdrModOpen(const char *pszFilename, PPKLDRMOD ppMod)
|
---|
| 109 | {
|
---|
| 110 | /*
|
---|
| 111 | * Open the file using a bit provider.
|
---|
| 112 | */
|
---|
| 113 | PKLDRRDR pRdr;
|
---|
| 114 | int rc = kLdrRdrOpen(&pRdr, pszFilename);
|
---|
| 115 | if (!rc)
|
---|
| 116 | {
|
---|
| 117 | rc = kLdrModOpenFromRdr(pRdr, ppMod);
|
---|
| 118 | if (!rc)
|
---|
| 119 | return 0;
|
---|
| 120 | kLdrRdrClose(pRdr);
|
---|
| 121 | }
|
---|
| 122 | return rc;
|
---|
| 123 | }
|
---|
| 124 |
|
---|
| 125 |
|
---|
| 126 | /**
|
---|
[2827] | 127 | * Open a executable image from a file provider instance.
|
---|
| 128 | *
|
---|
| 129 | * @returns 0 on success and *ppMod pointing to a module instance.
|
---|
| 130 | * On failure, a non-zero OS specific error code is returned.
|
---|
| 131 | * @param pRdr The file provider instance to use.
|
---|
| 132 | * On success, the ownership of the instance is taken by the
|
---|
| 133 | * module and the caller must not ever touch it again.
|
---|
| 134 | * (The instance is not closed on failure, the call has to do that.)
|
---|
| 135 | * @param ppMod Where to store the module handle.
|
---|
| 136 | */
|
---|
| 137 | int kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod)
|
---|
| 138 | {
|
---|
| 139 | union
|
---|
| 140 | {
|
---|
| 141 | uint32_t u32;
|
---|
| 142 | uint16_t u16;
|
---|
| 143 | uint16_t au16[2];
|
---|
| 144 | uint8_t au8[4];
|
---|
| 145 | } u;
|
---|
| 146 | off_t offHdr = 0;
|
---|
| 147 | int rc;
|
---|
| 148 |
|
---|
| 149 | /*
|
---|
| 150 | * Try figure out what kind of image this is.
|
---|
| 151 | * Always read the 'new header' if we encounter MZ.
|
---|
| 152 | */
|
---|
| 153 | rc = kLdrRdrRead(pRdr, &u, sizeof(u), 0);
|
---|
| 154 | if (rc)
|
---|
| 155 | return rc;
|
---|
| 156 | if ( u.u16 == IMAGE_DOS_SIGNATURE
|
---|
| 157 | && kLdrRdrSize(pRdr) > sizeof(IMAGE_DOS_HEADER))
|
---|
| 158 | {
|
---|
| 159 | rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), KLDR_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
|
---|
| 160 | if (rc)
|
---|
| 161 | return rc;
|
---|
| 162 | if ((off_t)u.u32 < kLdrRdrSize(pRdr))
|
---|
| 163 | {
|
---|
| 164 | offHdr = u.u32;
|
---|
| 165 | rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), offHdr);
|
---|
| 166 | if (rc)
|
---|
| 167 | return rc;
|
---|
| 168 | }
|
---|
| 169 | else
|
---|
| 170 | u.u16 = IMAGE_DOS_SIGNATURE;
|
---|
| 171 | }
|
---|
| 172 |
|
---|
| 173 | /*
|
---|
[2851] | 174 | * Use the magic to select the appropriate image interpreter head on.
|
---|
[2827] | 175 | */
|
---|
| 176 | if (u.u16 == IMAGE_DOS_SIGNATURE)
|
---|
[2851] | 177 | rc = KLDR_ERR_MZ_NOT_SUPPORTED;
|
---|
[2827] | 178 | else if (u.u16 == IMAGE_NE_SIGNATURE)
|
---|
[2851] | 179 | rc = KLDR_ERR_NE_NOT_SUPPORTED;
|
---|
[2827] | 180 | else if (u.u16 == IMAGE_LX_SIGNATURE)
|
---|
[2851] | 181 | rc = KLDR_ERR_LX_NOT_SUPPORTED;
|
---|
[2827] | 182 | else if (u.u16 == IMAGE_LE_SIGNATURE)
|
---|
[2851] | 183 | rc = KLDR_ERR_LE_NOT_SUPPORTED;
|
---|
[2827] | 184 | else if (u.u32 == IMAGE_NT_SIGNATURE)
|
---|
[2858] | 185 | rc = g_kLdrModPEOps.pfnCreate(&g_kLdrModPEOps, pRdr, offHdr, ppMod);
|
---|
[2827] | 186 | else if (u.u32 == IMAGE_ELF_SIGNATURE)
|
---|
[2851] | 187 | rc = KLDR_ERR_ELF_NOT_SUPPORTED;
|
---|
| 188 | else
|
---|
| 189 | rc = KLDR_ERR_UNKNOWN_FORMAT;
|
---|
| 190 |
|
---|
| 191 | /*
|
---|
| 192 | * If no head on hit, let each interpreter have a go.
|
---|
| 193 | */
|
---|
| 194 | if (rc)
|
---|
| 195 | {
|
---|
| 196 | PCKLDRMODOPS pOps;
|
---|
| 197 | for (pOps = g_pModInterpreterHead; pOps; pOps = pOps->pNext)
|
---|
| 198 | {
|
---|
| 199 | int rc2 = pOps->pfnCreate(pOps, pRdr, offHdr, ppMod);
|
---|
| 200 | if (!rc2)
|
---|
| 201 | return rc;
|
---|
| 202 | }
|
---|
| 203 | *ppMod = NULL;
|
---|
| 204 | }
|
---|
| 205 | return rc;
|
---|
[2827] | 206 | }
|
---|
| 207 |
|
---|
| 208 |
|
---|
| 209 | /**
|
---|
[2848] | 210 | * Open a executable image using the native loader (if any).
|
---|
[2827] | 211 | *
|
---|
| 212 | * @returns 0 on success and *ppMod pointing to a module instance.
|
---|
| 213 | * On failure, a non-zero OS specific error code is returned.
|
---|
| 214 | * @param pszFilename The filename to open.
|
---|
| 215 | * @param ppMod Where to store the module handle.
|
---|
| 216 | */
|
---|
[2848] | 217 | int kLdrModOpenNative(const char *pszFilename, PPKLDRMOD ppMod)
|
---|
[2825] | 218 | {
|
---|
[2848] | 219 | #ifdef __OS2__
|
---|
| 220 |
|
---|
| 221 | //DosLoadModule()
|
---|
| 222 | #elif defined(__WIN__)
|
---|
| 223 |
|
---|
| 224 | #else
|
---|
| 225 | # error "Port me"
|
---|
| 226 | #endif
|
---|
| 227 | return -1;
|
---|
[2825] | 228 | }
|
---|
| 229 |
|
---|
[2848] | 230 |
|
---|
| 231 |
|
---|
| 232 | /**
|
---|
| 233 | * Closes an open module.
|
---|
| 234 | *
|
---|
| 235 | * The caller is responsible for calling kLdrModUnmap() and kLdrFreeTLS()
|
---|
| 236 | * before closing the module.
|
---|
| 237 | *
|
---|
[2851] | 238 | * @returns 0 on success, non-zero on failure. The module instance state
|
---|
| 239 | * is unknown on failure, it's best not to touch it.
|
---|
[2848] | 240 | * @param pMod The module.
|
---|
| 241 | */
|
---|
| 242 | int kLdrModClose(PKLDRMOD pMod)
|
---|
| 243 | {
|
---|
[2851] | 244 | KLDRMOD_VALIDATE(pMod);
|
---|
| 245 | return pMod->pOps->pfnDestroy(pMod);
|
---|
[2848] | 246 | }
|
---|
| 247 |
|
---|
| 248 |
|
---|
| 249 | /**
|
---|
| 250 | * Queries a symbol by name or ordinal number.
|
---|
| 251 | *
|
---|
| 252 | * @returns 0 and *puValue and *pfKind on success.
|
---|
| 253 | * KLDR_ERR_SYMBOL_NOT_FOUND is returned if the symbol wasn't found.
|
---|
| 254 | * Other failures could stem from bad executable format failures,
|
---|
| 255 | * read failure in case pvBits isn't specified and no mapping should be used.
|
---|
| 256 | * @param pMod The module.
|
---|
| 257 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits() currently located at BaseAddress.
|
---|
| 258 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 259 | * @param BaseAddress The module base address to use when calculating the symbol value.
|
---|
| 260 | * There are two special values that can be used:
|
---|
| 261 | * KLDRMOD_BASEADDRESS_LINK and KLDRMOD_BASEADDRESS_MAP.
|
---|
[2859] | 262 | * @param iSymbol The symbol ordinal. (optional)
|
---|
[2848] | 263 | * @param pszSymbol The symbol name. (optional)
|
---|
[2854] | 264 | * @param pfnGetForwarder The callback to use when resolving a forwarder symbol. This is optional
|
---|
| 265 | * and if not specified KLDR_ERR_FORWARDER is returned instead.
|
---|
| 266 | * @param pvUser The user argument for the pfnGetForwarder callback.
|
---|
[2848] | 267 | * @param puValue Where to store the symbol value. (optional)
|
---|
| 268 | * @param pfKind Where to store the symbol kind. (optional)
|
---|
| 269 | */
|
---|
[2859] | 270 | int kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t iSymbol,
|
---|
[2854] | 271 | const char *pszSymbol, PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser,
|
---|
| 272 | PKLDRADDR puValue, uint32_t *pfKind)
|
---|
[2848] | 273 | {
|
---|
[2851] | 274 | KLDRMOD_VALIDATE(pMod);
|
---|
| 275 | if (!puValue && !pfKind)
|
---|
| 276 | return KLDR_ERR_INVALID_PARAMETER;
|
---|
| 277 | if (puValue)
|
---|
| 278 | *puValue = 0;
|
---|
| 279 | if (pfKind)
|
---|
| 280 | *pfKind = 0;
|
---|
[2859] | 281 | return pMod->pOps->pfnQuerySymbol(pMod, pvBits, BaseAddress, iSymbol, pszSymbol, pfnGetForwarder, pvUser, puValue, pfKind);
|
---|
[2848] | 282 | }
|
---|
| 283 |
|
---|
| 284 |
|
---|
| 285 | /**
|
---|
| 286 | * Enumerate the symbols in the module.
|
---|
| 287 | *
|
---|
| 288 | * @returns 0 on success and non-zero a status code on failure.
|
---|
| 289 | * @param pMod The module which symbols should be enumerated.
|
---|
| 290 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits() currently located at BaseAddress.
|
---|
| 291 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 292 | * @param BaseAddress The module base address to use when calculating the symbol values.
|
---|
| 293 | * There are two special values that could be can:
|
---|
| 294 | * KLDRMOD_BASEADDRESS_LINK and KLDRMOD_BASEADDRESS_MAP.
|
---|
[2854] | 295 | * @param fFlags The enumeration flags. A combination of the KLDRMOD_ENUM_SYMS_FLAGS_* \#defines.
|
---|
[2848] | 296 | * @param pfnCallback The enumeration callback function.
|
---|
| 297 | * @param pvUser The user argument to the callback function.
|
---|
| 298 | */
|
---|
[2854] | 299 | int kLdrModEnumSymbols(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, uint32_t fFlags,
|
---|
[2848] | 300 | PFNKLDRMODENUMSYMS pfnCallback, void *pvUser)
|
---|
| 301 | {
|
---|
[2851] | 302 | KLDRMOD_VALIDATE(pMod);
|
---|
| 303 | KLDRHLP_VALIDATE_FLAGS(fFlags, KLDRMOD_ENUM_SYMS_FLAGS_ALL);
|
---|
[2854] | 304 | return pMod->pOps->pfnEnumSymbols(pMod, pvBits, BaseAddress, fFlags, pfnCallback, pvUser);
|
---|
[2848] | 305 | }
|
---|
| 306 |
|
---|
| 307 |
|
---|
| 308 | /**
|
---|
| 309 | * Get the name of an import module by ordinal number.
|
---|
| 310 | *
|
---|
| 311 | * @returns 0 and name in pszName on success.
|
---|
| 312 | * On buffer overruns KLDR_ERR_BUFFER_OVERFLOW will be returned.
|
---|
| 313 | * On other failures and appropriate error code is returned.
|
---|
| 314 | * @param pMod The module.
|
---|
| 315 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits().
|
---|
| 316 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 317 | * @param iImport The import module ordinal number.
|
---|
| 318 | * @param pszName Where to store the name.
|
---|
| 319 | * @param cchName The size of the name buffer.
|
---|
| 320 | */
|
---|
[2855] | 321 | int kLdrModGetImport(PKLDRMOD pMod, const void *pvBits, uint32_t iImport, char *pszName, size_t cchName)
|
---|
[2848] | 322 | {
|
---|
[2851] | 323 | KLDRMOD_VALIDATE(pMod);
|
---|
| 324 | return pMod->pOps->pfnGetImport(pMod, pvBits, iImport, pszName, cchName);
|
---|
[2848] | 325 | }
|
---|
| 326 |
|
---|
| 327 |
|
---|
| 328 | /**
|
---|
| 329 | * Get the number of import modules.
|
---|
| 330 | *
|
---|
| 331 | * @returns The number of import modules. -1 if something really bad happens.
|
---|
| 332 | * @param pMod The module.
|
---|
| 333 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits().
|
---|
| 334 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 335 | */
|
---|
[2855] | 336 | int32_t kLdrModNumberOfImports(PKLDRMOD pMod, const void *pvBits)
|
---|
[2848] | 337 | {
|
---|
[2851] | 338 | KLDRMOD_VALIDATE(pMod);
|
---|
| 339 | return pMod->pOps->pfnNumberOfImports(pMod, pvBits);
|
---|
[2848] | 340 | }
|
---|
| 341 |
|
---|
| 342 |
|
---|
| 343 | /**
|
---|
| 344 | * Checks if this module can be executed by the specified arch+cpu.
|
---|
| 345 | *
|
---|
| 346 | * @returns 0 if it can, KLDR_ERR_ARCH_CPU_NOT_COMPATIBLE if it can't.
|
---|
| 347 | * Other failures may occur and cause other return values.
|
---|
| 348 | * @param pMod The module.
|
---|
| 349 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits().
|
---|
| 350 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 351 | */
|
---|
[2855] | 352 | int kLdrModCanExecuteOn(PKLDRMOD pMod, const void *pvBits, KLDRARCH enmArch, KLDRCPU enmCpu)
|
---|
[2848] | 353 | {
|
---|
[2851] | 354 | KLDRMOD_VALIDATE(pMod);
|
---|
[2855] | 355 | if (pMod->pOps->pfnCanExecuteOn)
|
---|
| 356 | return pMod->pOps->pfnCanExecuteOn(pMod, pvBits, enmArch, enmCpu);
|
---|
| 357 | return kLdrCompareCpus(pMod->enmArch, pMod->enmCpu, enmArch, enmCpu);
|
---|
[2848] | 358 | }
|
---|
| 359 |
|
---|
| 360 |
|
---|
| 361 | /**
|
---|
| 362 | * Gets the image stack info.
|
---|
| 363 | *
|
---|
| 364 | * @returns 0 on success, non-zero on failure.
|
---|
| 365 | * @param pMod
|
---|
| 366 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits() currently located at BaseAddress.
|
---|
| 367 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 368 | * @param BaseAddress The module base address to use when calculating the stack address.
|
---|
| 369 | * There are two special values that can be used:
|
---|
| 370 | * KLDRMOD_BASEADDRESS_LINK and KLDRMOD_BASEADDRESS_MAP.
|
---|
| 371 | * @param pStackInfo The stack information.
|
---|
| 372 | */
|
---|
[2855] | 373 | int kLdrModGetStackInfo(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRSTACKINFO pStackInfo)
|
---|
[2848] | 374 | {
|
---|
[2851] | 375 | KLDRMOD_VALIDATE(pMod);
|
---|
| 376 | return pMod->pOps->pfnGetStackInfo(pMod, pvBits, BaseAddress, pStackInfo);
|
---|
[2848] | 377 | }
|
---|
| 378 |
|
---|
| 379 |
|
---|
| 380 | /**
|
---|
| 381 | * Queries the main entrypoint of the module.
|
---|
| 382 | *
|
---|
| 383 | * Only executable are supposed to have an main entrypoint, though some object and DLL
|
---|
| 384 | * formats will also allow this.
|
---|
| 385 | *
|
---|
| 386 | * @returns 0 and *pMainEPAddress on success. Non-zero status code on failure.
|
---|
| 387 | * @param pMod The module.
|
---|
| 388 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits() currently located at BaseAddress.
|
---|
| 389 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 390 | * @param BaseAddress The module base address to use when calculating the entrypoint address.
|
---|
| 391 | * There are two special values that can be used:
|
---|
| 392 | * KLDRMOD_BASEADDRESS_LINK and KLDRMOD_BASEADDRESS_MAP.
|
---|
| 393 | * @param pMainEPAddress Where to store the entry point address.
|
---|
| 394 | */
|
---|
[2855] | 395 | int kLdrModQueryMainEntrypoint(PKLDRMOD pMod, const void *pvBits, KLDRADDR BaseAddress, PKLDRADDR pMainEPAddress)
|
---|
[2848] | 396 | {
|
---|
[2851] | 397 | KLDRMOD_VALIDATE(pMod);
|
---|
| 398 | *pMainEPAddress = 0;
|
---|
| 399 | return pMod->pOps->pfnQueryMainEntrypoint(pMod, pvBits, BaseAddress, pMainEPAddress);
|
---|
[2848] | 400 | }
|
---|
| 401 |
|
---|
| 402 |
|
---|
| 403 | /**
|
---|
[2849] | 404 | * Enumerate the debug info formats contained in the executable image.
|
---|
[2848] | 405 | *
|
---|
[2849] | 406 | * @returns 0 on success, non-zero OS or kLdr status code on failure, or non-zero callback status.
|
---|
[2848] | 407 | * @param pMod The module.
|
---|
[2849] | 408 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits().
|
---|
| 409 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 410 | * @param pfnCallback The callback function.
|
---|
| 411 | * @param pvUser The user argument.
|
---|
| 412 | * @see pg_kDbg for the debug info reader.
|
---|
[2848] | 413 | */
|
---|
[2855] | 414 | int kLdrModEnumDbgInfo(PKLDRMOD pMod, const void *pvBits, PFNKLDRENUMDBG pfnCallback, void *pvUser)
|
---|
[2848] | 415 | {
|
---|
[2851] | 416 | KLDRMOD_VALIDATE(pMod);
|
---|
| 417 | return pMod->pOps->pfnEnumDbgInfo(pMod, pvBits, pfnCallback, pvUser);
|
---|
[2848] | 418 | }
|
---|
| 419 |
|
---|
| 420 |
|
---|
| 421 | /**
|
---|
[2849] | 422 | * Checks if the module has debug info embedded or otherwise associated with it.
|
---|
| 423 | *
|
---|
| 424 | * @returns 0 if it has debug info, KLDR_ERR_NO_DEBUG_INFO if no debug info,
|
---|
| 425 | * and non-zero OS or kLdr status code on failure.
|
---|
| 426 | * @param pMod The module.
|
---|
| 427 | * @param pvBits Optional pointer to bits returned by kLdrModGetBits().
|
---|
| 428 | * This can be used by some module interpreters to reduce memory consumption.
|
---|
| 429 | */
|
---|
[2855] | 430 | int kLdrModHasDbgInfo(PKLDRMOD pMod, const void *pvBits)
|
---|
[2849] | 431 | {
|
---|
[2851] | 432 | KLDRMOD_VALIDATE(pMod);
|
---|
| 433 | return pMod->pOps->pfnHasDbgInfo(pMod, pvBits);
|
---|
[2849] | 434 | }
|
---|
| 435 |
|
---|
| 436 |
|
---|
| 437 | /**
|
---|
[2848] | 438 | * Maps the module into the memory of the caller.
|
---|
| 439 | *
|
---|
| 440 | * On success the actual addresses for the segments can be found in MapAddress
|
---|
| 441 | * member of each segment in the segment array.
|
---|
| 442 | *
|
---|
| 443 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 444 | * @param pMod The module to be mapped.
|
---|
| 445 | * @remark kLdr only supports one mapping at a time of a module.
|
---|
| 446 | */
|
---|
| 447 | int kLdrModMap(PKLDRMOD pMod)
|
---|
| 448 | {
|
---|
[2851] | 449 | KLDRMOD_VALIDATE(pMod);
|
---|
| 450 | return pMod->pOps->pfnMap(pMod);
|
---|
[2848] | 451 | }
|
---|
| 452 |
|
---|
| 453 |
|
---|
| 454 | /**
|
---|
| 455 | * Unmaps a module previously mapped by kLdrModMap().
|
---|
| 456 | *
|
---|
| 457 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 458 | * @param pMod The module to unmap.
|
---|
| 459 | */
|
---|
| 460 | int kLdrModUnmap(PKLDRMOD pMod)
|
---|
| 461 | {
|
---|
[2851] | 462 | KLDRMOD_VALIDATE(pMod);
|
---|
| 463 | return pMod->pOps->pfnUnmap(pMod);
|
---|
[2848] | 464 | }
|
---|
| 465 |
|
---|
| 466 |
|
---|
| 467 | /**
|
---|
| 468 | * Allocates Thread Local Storage for module mapped by kLdrModMap().
|
---|
| 469 | *
|
---|
| 470 | * Calling kLdrModAllocTLS() more than once without calling kLdrModFreeTLS()
|
---|
| 471 | * between each invocation is not supported.
|
---|
| 472 | *
|
---|
| 473 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 474 | * @param pMod The module.
|
---|
| 475 | */
|
---|
| 476 | int kLdrModAllocTLS(PKLDRMOD pMod)
|
---|
| 477 | {
|
---|
[2851] | 478 | KLDRMOD_VALIDATE(pMod);
|
---|
| 479 | return pMod->pOps->pfnAllocTLS(pMod);
|
---|
[2848] | 480 | }
|
---|
| 481 |
|
---|
| 482 |
|
---|
| 483 | /**
|
---|
| 484 | * Frees Thread Local Storage previously allocated by kLdrModAllocTLS().
|
---|
| 485 | *
|
---|
| 486 | * The caller is responsible for only calling kLdrModFreeTLS() once
|
---|
| 487 | * after calling kLdrModAllocTLS().
|
---|
| 488 | *
|
---|
| 489 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 490 | * @param pMod The module.
|
---|
| 491 | */
|
---|
| 492 | void kLdrModFreeTLS(PKLDRMOD pMod)
|
---|
| 493 | {
|
---|
[2851] | 494 | KLDRMOD_VALIDATE_VOID(pMod);
|
---|
| 495 | pMod->pOps->pfnFreeTLS(pMod);
|
---|
[2848] | 496 | }
|
---|
| 497 |
|
---|
| 498 |
|
---|
| 499 | /**
|
---|
| 500 | * Reloads all dirty pages in a module previously mapped by kLdrModMap().
|
---|
| 501 | *
|
---|
| 502 | * The module interpreter may omit code pages if it can safely apply code
|
---|
| 503 | * fixups again in a subsequent kLdrModFixupMapping() call.
|
---|
| 504 | *
|
---|
| 505 | * The caller is responsible for freeing TLS before calling this function.
|
---|
| 506 | *
|
---|
| 507 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 508 | * @param pMod The module.
|
---|
| 509 | */
|
---|
| 510 | int kLdrModReload(PKLDRMOD pMod)
|
---|
| 511 | {
|
---|
[2851] | 512 | KLDRMOD_VALIDATE(pMod);
|
---|
| 513 | return pMod->pOps->pfnReload(pMod);
|
---|
[2848] | 514 | }
|
---|
| 515 |
|
---|
| 516 |
|
---|
| 517 | /**
|
---|
| 518 | * Fixup the mapping made by kLdrModMap().
|
---|
| 519 | *
|
---|
| 520 | * The caller is only responsible for not calling this function more than
|
---|
| 521 | * once without doing kLDrModReload() inbetween.
|
---|
| 522 | *
|
---|
| 523 | * @returns 0 on success, non-zero OS or kLdr status code on failure.
|
---|
| 524 | * @param pMod The module.
|
---|
| 525 | * @param pfnGetImport The callback for resolving external (imported) symbols.
|
---|
| 526 | * @param pvUser The callback user argument.
|
---|
| 527 | */
|
---|
| 528 | int kLdrModFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
|
---|
| 529 | {
|
---|
[2851] | 530 | KLDRMOD_VALIDATE(pMod);
|
---|
| 531 | return pMod->pOps->pfnFixupMapping(pMod, pfnGetImport, pvUser);
|
---|
[2848] | 532 | }
|
---|
| 533 |
|
---|
| 534 |
|
---|
| 535 | /**
|
---|
| 536 | * Call the module initializiation function of a mapped module (if any).
|
---|
| 537 | *
|
---|
| 538 | * @returns 0 on success or no init function, non-zero on init function failure or invalid pMod.
|
---|
| 539 | * @param pMod The module.
|
---|
[2856] | 540 | * @param uHandle The module handle to use if any of the init functions requires the module handle.
|
---|
[2848] | 541 | */
|
---|
[2856] | 542 | int kLdrModCallInit(PKLDRMOD pMod, uintptr_t uHandle)
|
---|
[2848] | 543 | {
|
---|
[2851] | 544 | KLDRMOD_VALIDATE(pMod);
|
---|
[2856] | 545 | return pMod->pOps->pfnCallInit(pMod, uHandle);
|
---|
[2848] | 546 | }
|
---|
| 547 |
|
---|
| 548 |
|
---|
| 549 | /**
|
---|
| 550 | * Call the module termination function of a mapped module (if any).
|
---|
| 551 | *
|
---|
| 552 | * @returns 0 on success or no term function, non-zero on invalid pMod.
|
---|
| 553 | * @param pMod The module.
|
---|
[2856] | 554 | * @param uHandle The module handle to use if any of the term functions requires the module handle.
|
---|
[2848] | 555 | *
|
---|
| 556 | * @remark Termination function failure will be ignored by the module interpreter.
|
---|
| 557 | */
|
---|
[2856] | 558 | int kLdrModCallTerm(PKLDRMOD pMod, uintptr_t uHandle)
|
---|
[2848] | 559 | {
|
---|
[2851] | 560 | KLDRMOD_VALIDATE(pMod);
|
---|
[2856] | 561 | return pMod->pOps->pfnCallTerm(pMod, uHandle);
|
---|
[2848] | 562 | }
|
---|
| 563 |
|
---|
| 564 |
|
---|
| 565 | /**
|
---|
| 566 | * Call the thread attach or detach function of a mapped module (if any).
|
---|
| 567 | *
|
---|
[2856] | 568 | * Any per-thread TLS initialization/termination will have to be done at this time too.
|
---|
| 569 | *
|
---|
[2848] | 570 | * @returns 0 on success or no attach/detach function, non-zero on attach failure or invalid pMod.
|
---|
| 571 | * @param pMod The module.
|
---|
[2856] | 572 | * @param uHandle The module handle to use if any of the thread attach/detach functions
|
---|
| 573 | * requires the module handle.
|
---|
[2848] | 574 | *
|
---|
| 575 | * @remark Detach function failure will be ignored by the module interpreter.
|
---|
| 576 | */
|
---|
[2856] | 577 | int kLdrModCallThread(PKLDRMOD pMod, uintptr_t uHandle, unsigned fAttachingOrDetaching)
|
---|
[2848] | 578 | {
|
---|
[2851] | 579 | KLDRMOD_VALIDATE(pMod);
|
---|
| 580 | KLDRHLP_VALIDATE_FLAGS(fAttachingOrDetaching, 1);
|
---|
[2856] | 581 | return pMod->pOps->pfnCallThread(pMod, uHandle, fAttachingOrDetaching);
|
---|
[2848] | 582 | }
|
---|
| 583 |
|
---|
| 584 |
|
---|
| 585 | /**
|
---|
[2849] | 586 | * Get the size of the mapped module.
|
---|
| 587 | *
|
---|
| 588 | * @returns The size of the mapped module (in bytes).
|
---|
| 589 | * @param pMod The module.
|
---|
| 590 | */
|
---|
[2856] | 591 | KLDRADDR kLdrModSize(PKLDRMOD pMod)
|
---|
[2849] | 592 | {
|
---|
[2851] | 593 | KLDRMOD_VALIDATE_EX(pMod, 0);
|
---|
| 594 | return pMod->pOps->pfnSize(pMod);
|
---|
[2849] | 595 | }
|
---|
| 596 |
|
---|
| 597 |
|
---|
| 598 | /**
|
---|
[2848] | 599 | * Gets the module bits.
|
---|
| 600 | *
|
---|
| 601 | * The module interpreter will fill a mapping allocated by the caller with the
|
---|
| 602 | * module bits reallocated to the specified address.
|
---|
| 603 | *
|
---|
| 604 | * @returns 0 on succes, non-zero OS or kLdr status code on failure.
|
---|
| 605 | * @param pMod The module.
|
---|
| 606 | * @param pvBits Where to put the bits.
|
---|
| 607 | * @param BaseAddress The base address that should correspond to the first byte in pvBits
|
---|
| 608 | * upon return.
|
---|
| 609 | * @param pfnGetImport The callback ufor resolving external (imported) symbols.
|
---|
| 610 | * @param pvUser The callback user argument.
|
---|
| 611 | */
|
---|
| 612 | int kLdrModGetBits(PKLDRMOD pMod, void *pvBits, KLDRADDR BaseAddress, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
|
---|
| 613 | {
|
---|
[2851] | 614 | KLDRMOD_VALIDATE(pMod);
|
---|
| 615 | return pMod->pOps->pfnGetBits(pMod, pvBits, BaseAddress, pfnGetImport, pvUser);
|
---|
[2848] | 616 | }
|
---|
| 617 |
|
---|
| 618 |
|
---|
| 619 | /**
|
---|
| 620 | * Relocates the module bits previously obtained by kLdrModGetBits().
|
---|
| 621 | *
|
---|
| 622 | * @returns 0 on succes, non-zero OS or kLdr status code on failure.
|
---|
| 623 | * @param pMod The module.
|
---|
| 624 | * @param pvBits Where to put the bits.
|
---|
| 625 | * @param NewBaseAddress The new base address.
|
---|
| 626 | * @param OldBaseAddress The old base address (i.e. the one specified to kLdrModGetBits() or as
|
---|
| 627 | * NewBaseAddressto the previous kLdrModRelocateBits() call).
|
---|
| 628 | * @param pfnGetImport The callback ufor resolving external (imported) symbols.
|
---|
| 629 | * @param pvUser The callback user argument.
|
---|
| 630 | */
|
---|
| 631 | int kLdrModRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
|
---|
| 632 | PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser)
|
---|
| 633 | {
|
---|
[2851] | 634 | KLDRMOD_VALIDATE(pMod);
|
---|
| 635 | return pMod->pOps->pfnRelocateBits(pMod, pvBits, NewBaseAddress, OldBaseAddress, pfnGetImport, pvUser);
|
---|
[2848] | 636 | }
|
---|
| 637 |
|
---|