VirtualBox

Changeset 81 in kStuff for trunk


Ignore:
Timestamp:
Aug 18, 2016 10:10:38 PM (8 years ago)
Author:
bird
Message:

kLdr: some refactoring and fixes.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/k/kLdr.h

    r58 r81  
    637637int     kLdrModMap(PKLDRMOD pMod);
    638638int     kLdrModUnmap(PKLDRMOD pMod);
    639 int     kLdrModAllocTLS(PKLDRMOD pMod);
    640 void    kLdrModFreeTLS(PKLDRMOD pMod);
    641639int     kLdrModReload(PKLDRMOD pMod);
    642640int     kLdrModFixupMapping(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    643 int     kLdrModCallInit(PKLDRMOD pMod, KUPTR uHandle);
    644 int     kLdrModCallTerm(PKLDRMOD pMod, KUPTR uHandle);
    645 int     kLdrModCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching);
    646641/** @} */
    647642
    … …  
    652647int     kLdrModRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    653648                            PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
     649/** @} */
     650
     651/** @name Operations on both internally and externally managed mappings.
     652 * @{ */
     653/** Special pvMapping value to pass to kLdrModAllocTLS,
     654 * kLdrModFreeTLS, kLdrModCallInit, kLdrModCallTerm, and kLdrModCallThread that
     655 * specifies the internal mapping (kLdrModMap). */
     656#define KLDRMOD_INT_MAP    ((void *)~(KUPTR)0)
     657int     kLdrModAllocTLS(PKLDRMOD pMod, void *pvMapping);
     658void    kLdrModFreeTLS(PKLDRMOD pMod, void *pvMapping);
     659int     kLdrModCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle);
     660int     kLdrModCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle);
     661int     kLdrModCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching);
    654662/** @} */
    655663
    … …  
    726734    int (* pfnUnmap)(PKLDRMOD pMod);
    727735    /** @copydoc kLdrModAllocTLS */
    728     int (* pfnAllocTLS)(PKLDRMOD pMod);
     736    int (* pfnAllocTLS)(PKLDRMOD pMod, void *pvMapping);
    729737    /** @copydoc kLdrModFreeTLS */
    730     void (*pfnFreeTLS)(PKLDRMOD pMod);
     738    void (*pfnFreeTLS)(PKLDRMOD pMod, void *pvMapping);
    731739    /** @copydoc kLdrModReload */
    732740    int (* pfnReload)(PKLDRMOD pMod);
    … …  
    734742    int (* pfnFixupMapping)(PKLDRMOD pMod, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    735743    /** @copydoc kLdrModCallInit */
    736     int (* pfnCallInit)(PKLDRMOD pMod, KUPTR uHandle);
     744    int (* pfnCallInit)(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle);
    737745    /** @copydoc kLdrModCallTerm */
    738     int (* pfnCallTerm)(PKLDRMOD pMod, KUPTR uHandle);
     746    int (* pfnCallTerm)(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle);
    739747    /** @copydoc kLdrModCallThread */
    740     int (* pfnCallThread)(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching);
     748    int (* pfnCallThread)(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching);
    741749    /** @copydoc kLdrModSize */
    742750    KLDRADDR (* pfnSize)(PKLDRMOD pMod);

  • trunk/kLdr/kLdrDyldMod.c

    r33 r81  
    256256    if (pMod->fAllocatedTLS)
    257257    {
    258         kLdrModFreeTLS(pMod->pMod);
     258        kLdrModFreeTLS(pMod->pMod, KLDRMOD_INT_MAP);
    259259        pMod->fAllocatedTLS = 0;
    260260    }
    … …  
    820820    if (!rc)
    821821    {
    822         rc = kLdrModAllocTLS(pMod->pMod);
     822        rc = kLdrModAllocTLS(pMod->pMod, KLDRMOD_INT_MAP);
    823823        if (!rc)
    824824        {
    … …  
    861861    if (pMod->fAllocatedTLS)
    862862    {
    863         kLdrModFreeTLS(pMod->pMod);
     863        kLdrModFreeTLS(pMod->pMod, KLDRMOD_INT_MAP);
    864864        pMod->fAllocatedTLS = 0;
    865865    }
    … …  
    911911    if (pMod->fAllocatedTLS)
    912912    {
    913         kLdrModFreeTLS(pMod->pMod);
     913        kLdrModFreeTLS(pMod->pMod, KLDRMOD_INT_MAP);
    914914        pMod->fAllocatedTLS = 0;
    915915    }
    … …  
    919919    if (!rc)
    920920    {
    921         rc = kLdrModAllocTLS(pMod->pMod);
     921        rc = kLdrModAllocTLS(pMod->pMod, KLDRMOD_INT_MAP);
    922922        if (!rc)
    923923        {
    … …  
    10601060
    10611061    pMod->enmState = KLDRSTATE_INITIALIZING;
    1062     rc = kLdrModCallInit(pMod->pMod, (KUPTR)pMod->hMod);
     1062    rc = kLdrModCallInit(pMod->pMod, KLDRMOD_INT_MAP, (KUPTR)pMod->hMod);
    10631063    if (!rc)
    10641064    {
    … …  
    10921092
    10931093    pMod->enmState = KLDRSTATE_TERMINATING;
    1094     kLdrModCallTerm(pMod->pMod, (KUPTR)pMod->hMod);
     1094    kLdrModCallTerm(pMod->pMod, KLDRMOD_INT_MAP, (KUPTR)pMod->hMod);
    10951095    pMod->enmState = KLDRSTATE_PENDING_GC;
    10961096    /* unlinking on destruction. */
    … …  
    11081108    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
    11091109
    1110     return kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 1 /* attach */);
     1110    return kLdrModCallThread(pMod->pMod, KLDRMOD_INT_MAP, (KUPTR)pMod->hMod, 1 /* attach */);
    11111111}
    11121112
    … …  
    11221122    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
    11231123
    1124     kLdrModCallThread(pMod->pMod, (KUPTR)pMod->hMod, 0 /* detach */);
     1124    kLdrModCallThread(pMod->pMod, KLDRMOD_INT_MAP, (KUPTR)pMod->hMod, 0 /* detach */);
    11251125}
    11261126

  • trunk/kLdr/kLdrMod.c

    r79 r81  
    736736
    737737/**
    738  * Allocates Thread Local Storage for module mapped by kLdrModMap().
    739  *
    740  * Calling kLdrModAllocTLS() more than once without calling kLdrModFreeTLS()
    741  * between each invocation is not supported.
    742  *
    743  * @returns 0 on success, non-zero OS or kLdr status code on failure.
    744  * @param   pMod            The module.
    745  */
    746 int     kLdrModAllocTLS(PKLDRMOD pMod)
    747 {
    748     KLDRMOD_VALIDATE(pMod);
    749     return pMod->pOps->pfnAllocTLS(pMod);
    750 }
    751 
    752 
    753 /**
    754  * Frees Thread Local Storage previously allocated by kLdrModAllocTLS().
    755  *
    756  * The caller is responsible for only calling kLdrModFreeTLS() once
    757  * after calling kLdrModAllocTLS().
    758  *
    759  * @returns 0 on success, non-zero OS or kLdr status code on failure.
    760  * @param   pMod            The module.
    761  */
    762 void    kLdrModFreeTLS(PKLDRMOD pMod)
    763 {
    764     KLDRMOD_VALIDATE_VOID(pMod);
    765     pMod->pOps->pfnFreeTLS(pMod);
    766 }
    767 
    768 
    769 /**
    770738 * Reloads all dirty pages in a module previously mapped by kLdrModMap().
    771739 *
    … …  
    800768    KLDRMOD_VALIDATE(pMod);
    801769    return pMod->pOps->pfnFixupMapping(pMod, pfnGetImport, pvUser);
    802 }
    803 
    804 
    805 /**
    806  * Call the module initializiation function of a mapped module (if any).
    807  *
    808  * @returns 0 on success or no init function, non-zero on init function failure or invalid pMod.
    809  * @param   pMod            The module.
    810  * @param   uHandle         The module handle to use if any of the init functions requires the module handle.
    811  */
    812 int     kLdrModCallInit(PKLDRMOD pMod, KUPTR uHandle)
    813 {
    814     KLDRMOD_VALIDATE(pMod);
    815     return pMod->pOps->pfnCallInit(pMod, uHandle);
    816 }
    817 
    818 
    819 /**
    820  * Call the module termination function of a mapped module (if any).
    821  *
    822  * @returns 0 on success or no term function, non-zero on invalid pMod.
    823  * @param   pMod            The module.
    824  * @param   uHandle         The module handle to use if any of the term functions requires the module handle.
    825  *
    826  * @remark  Termination function failure will be ignored by the module interpreter.
    827  */
    828 int     kLdrModCallTerm(PKLDRMOD pMod, KUPTR uHandle)
    829 {
    830     KLDRMOD_VALIDATE(pMod);
    831     return pMod->pOps->pfnCallTerm(pMod, uHandle);
    832 }
    833 
    834 
    835 /**
    836  * Call the thread attach or detach function of a mapped module (if any).
    837  *
    838  * Any per-thread TLS initialization/termination will have to be done at this time too.
    839  *
    840  * @returns 0 on success or no attach/detach function, non-zero on attach failure or invalid pMod.
    841  * @param   pMod            The module.
    842  * @param   uHandle         The module handle to use if any of the thread attach/detach functions
    843  *                          requires the module handle.
    844  *
    845  * @remark  Detach function failure will be ignored by the module interpreter.
    846  */
    847 int     kLdrModCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
    848 {
    849     KLDRMOD_VALIDATE(pMod);
    850     K_VALIDATE_FLAGS(fAttachingOrDetaching, 1);
    851     return pMod->pOps->pfnCallThread(pMod, uHandle, fAttachingOrDetaching);
    852770}
    853771
    … …  
    906824}
    907825
     826
     827/**
     828 * Allocates Thread Local Storage for module mapped by kLdrModMap().
     829 *
     830 * Calling kLdrModAllocTLS() more than once without calling kLdrModFreeTLS()
     831 * between each invocation is not supported.
     832 *
     833 * @returns 0 on success, non-zero OS or kLdr status code on failure.
     834 * @param   pMod            The module.
     835 * @param   pvMapping       The external mapping address or RTLDRMOD_INT_MAP.
     836 */
     837int     kLdrModAllocTLS(PKLDRMOD pMod, void *pvMapping)
     838{
     839    KLDRMOD_VALIDATE(pMod);
     840    return pMod->pOps->pfnAllocTLS(pMod, pvMapping);
     841}
     842
     843
     844/**
     845 * Frees Thread Local Storage previously allocated by kLdrModAllocTLS().
     846 *
     847 * The caller is responsible for only calling kLdrModFreeTLS() once
     848 * after calling kLdrModAllocTLS().
     849 *
     850 * @returns 0 on success, non-zero OS or kLdr status code on failure.
     851 * @param   pMod            The module.
     852 * @param   pvMapping       The external mapping address or RTLDRMOD_INT_MAP.
     853 */
     854void    kLdrModFreeTLS(PKLDRMOD pMod, void *pvMapping)
     855{
     856    KLDRMOD_VALIDATE_VOID(pMod);
     857    pMod->pOps->pfnFreeTLS(pMod, pvMapping);
     858}
     859
     860
     861
     862
     863/**
     864 * Call the module initializiation function of a mapped module (if any).
     865 *
     866 * @returns 0 on success or no init function, non-zero on init function failure or invalid pMod.
     867 * @param   pMod            The module.
     868 * @param   pvMapping       The external mapping address or RTLDRMOD_INT_MAP.
     869 * @param   uHandle         The module handle to use if any of the init functions requires the module handle.
     870 */
     871int     kLdrModCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
     872{
     873    KLDRMOD_VALIDATE(pMod);
     874    return pMod->pOps->pfnCallInit(pMod, pvMapping, uHandle);
     875}
     876
     877
     878/**
     879 * Call the module termination function of a mapped module (if any).
     880 *
     881 * @returns 0 on success or no term function, non-zero on invalid pMod.
     882 * @param   pMod            The module.
     883 * @param   pvMapping       The external mapping address or RTLDRMOD_INT_MAP.
     884 * @param   uHandle         The module handle to use if any of the term functions requires the module handle.
     885 *
     886 * @remark  Termination function failure will be ignored by the module interpreter.
     887 */
     888int     kLdrModCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
     889{
     890    KLDRMOD_VALIDATE(pMod);
     891    return pMod->pOps->pfnCallTerm(pMod, pvMapping, uHandle);
     892}
     893
     894
     895/**
     896 * Call the thread attach or detach function of a mapped module (if any).
     897 *
     898 * Any per-thread TLS initialization/termination will have to be done at this time too.
     899 *
     900 * @returns 0 on success or no attach/detach function, non-zero on attach failure or invalid pMod.
     901 * @param   pMod            The module.
     902 * @param   pvMapping       The external mapping address or RTLDRMOD_INT_MAP.
     903 * @param   uHandle         The module handle to use if any of the thread attach/detach functions
     904 *                          requires the module handle.
     905 *
     906 * @remark  Detach function failure will be ignored by the module interpreter.
     907 */
     908int     kLdrModCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
     909{
     910    KLDRMOD_VALIDATE(pMod);
     911    K_VALIDATE_FLAGS(fAttachingOrDetaching, 1);
     912    return pMod->pOps->pfnCallThread(pMod, pvMapping, uHandle, fAttachingOrDetaching);
     913}
     914

  • trunk/kLdr/kLdrModLX.c

    r80 r81  
    128128static void kLdrModLXMemCopyW(KU8 *pbDst, const KU8 *pbSrc, int cb);
    129129static int kldrModLXDoProtect(PKLDRMODLX pModLX, void *pvBits, unsigned fUnprotectOrProtect);
    130 static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, KUPTR uHandle);
     130static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, void *pvMapping, unsigned uOp, KUPTR uHandle);
    131131static int kldrModLXDoForwarderQuery(PKLDRMODLX pModLX, const struct e32_entry *pEntry,
    132132                                     PFNKLDRMODGETIMPORT pfnGetForwarder, void *pvUser, PKLDRADDR puValue, KU32 *pfKind);
    … …  
    19371937
    19381938/** @copydoc kLdrModAllocTLS */
    1939 static int kldrModLXAllocTLS(PKLDRMOD pMod)
     1939static int kldrModLXAllocTLS(PKLDRMOD pMod, void *pvMapping)
    19401940{
    19411941    PKLDRMODLX  pModLX = (PKLDRMODLX)pMod->pvData;
    19421942
    19431943    /* no tls, just do the error checking. */
    1944     if (!pModLX->pvMapping)
     1944    if (   pvMapping == KLDRMOD_INT_MAP
     1945        && pModLX->pvMapping)
    19451946        return KLDR_ERR_NOT_MAPPED;
    19461947    return 0;
    … …  
    19491950
    19501951/** @copydoc kLdrModFreeTLS */
    1951 static void kldrModLXFreeTLS(PKLDRMOD pMod)
     1952static void kldrModLXFreeTLS(PKLDRMOD pMod, void *pvMapping)
    19521953{
    19531954    /* no tls. */
    19541955    K_NOREF(pMod);
     1956    K_NOREF(pvMapping);
    19551957
    19561958}
    … …  
    20272029
    20282030/** @copydoc kLdrModCallInit */
    2029 static int kldrModLXCallInit(PKLDRMOD pMod, KUPTR uHandle)
     2031static int kldrModLXCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    20302032{
    20312033    PKLDRMODLX pModLX = (PKLDRMODLX)pMod->pvData;
    … …  
    20352037     * Mapped?
    20362038     */
    2037     if (!pModLX->pvMapping)
    2038         return KLDR_ERR_NOT_MAPPED;
     2039    if (pvMapping == KLDRMOD_INT_MAP)
     2040    {
     2041        pvMapping = pModLX->pvMapping;
     2042        if (!pvMapping)
     2043            return KLDR_ERR_NOT_MAPPED;
     2044    }
    20392045
    20402046    /*
    … …  
    20422048     */
    20432049    if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
    2044         rc = kldrModLXDoCallDLL(pModLX, 0 /* attach */, uHandle);
     2050        rc = kldrModLXDoCallDLL(pModLX, pvMapping, 0 /* attach */, uHandle);
    20452051    else
    20462052        rc = 0;
    … …  
    20552061 * @returns KLDR_ERR_MODULE_INIT_FAILED  or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
    20562062 * @param   pModLX          The LX module interpreter instance.
     2063 * @param   pvMapping       The module mapping to use (resolved).
    20572064 * @param   uOp             The operation (DLL_*).
    20582065 * @param   uHandle         The module handle to present.
    20592066 */
    2060 static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, unsigned uOp, KUPTR uHandle)
     2067static int kldrModLXDoCallDLL(PKLDRMODLX pModLX, void *pvMapping, unsigned uOp, KUPTR uHandle)
    20612068{
    20622069    int rc;
    … …  
    20722079     * Invoke the entrypoint and convert the boolean result to a kLdr status code.
    20732080     */
    2074     rc = kldrModLXDoCall((KUPTR)pModLX->pvMapping
     2081    rc = kldrModLXDoCall((KUPTR)pvMapping
    20752082                         + (KUPTR)pModLX->pMod->aSegments[pModLX->Hdr.e32_startobj - 1].RVA
    20762083                         + pModLX->Hdr.e32_eip,
    … …  
    21502157
    21512158/** @copydoc kLdrModCallTerm */
    2152 static int kldrModLXCallTerm(PKLDRMOD pMod, KUPTR uHandle)
     2159static int kldrModLXCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    21532160{
    21542161    PKLDRMODLX  pModLX = (PKLDRMODLX)pMod->pvData;
    … …  
    21572164     * Mapped?
    21582165     */
    2159     if (!pModLX->pvMapping)
    2160         return KLDR_ERR_NOT_MAPPED;
     2166    if (pvMapping == KLDRMOD_INT_MAP)
     2167    {
     2168        pvMapping = pModLX->pvMapping;
     2169        if (!pvMapping)
     2170            return KLDR_ERR_NOT_MAPPED;
     2171    }
    21612172
    21622173    /*
    … …  
    21642175     */
    21652176    if ((pModLX->Hdr.e32_mflags & E32MODMASK) == E32MODDLL)
    2166         kldrModLXDoCallDLL(pModLX, 1 /* detach */, uHandle);
     2177        kldrModLXDoCallDLL(pModLX, pvMapping, 1 /* detach */, uHandle);
    21672178
    21682179    return 0;
    … …  
    21712182
    21722183/** @copydoc kLdrModCallThread */
    2173 static int kldrModLXCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
     2184static int kldrModLXCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
    21742185{
    21752186    /* no thread attach/detach callout. */
    21762187    K_NOREF(pMod);
     2188    K_NOREF(pvMapping);
    21772189    K_NOREF(uHandle);
    21782190    K_NOREF(fAttachingOrDetaching);

  • trunk/kLdr/kLdrModMachO.c

    r79 r81  
    24912491
    24922492/** @copydoc kLdrModAllocTLS */
    2493 static int kldrModMachOAllocTLS(PKLDRMOD pMod)
     2493static int kldrModMachOAllocTLS(PKLDRMOD pMod, void *pvMapping)
    24942494{
    24952495    PKLDRMODMACHO pModMachO = (PKLDRMODMACHO)pMod->pvData;
    … …  
    24982498     * Mapped?
    24992499     */
    2500     if (!pModMachO->pvMapping)
     2500    if (   pvMapping == KLDRMOD_INT_MAP
     2501        && !pModMachO->pvMapping )
    25012502        return KLDR_ERR_NOT_MAPPED;
    25022503    return 0;
    … …  
    25052506
    25062507/** @copydoc kLdrModFreeTLS */
    2507 static void kldrModMachOFreeTLS(PKLDRMOD pMod)
     2508static void kldrModMachOFreeTLS(PKLDRMOD pMod, void *pvMapping)
    25082509{
    25092510    K_NOREF(pMod);
     2511    K_NOREF(pvMapping);
    25102512}
    25112513
    … …  
    34553457
    34563458/** @copydoc kLdrModCallInit */
    3457 static int kldrModMachOCallInit(PKLDRMOD pMod, KUPTR uHandle)
     3459static int kldrModMachOCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    34583460{
    34593461    /* later */
    34603462    K_NOREF(pMod);
     3463    K_NOREF(pvMapping);
    34613464    K_NOREF(uHandle);
    34623465    return 0;
    … …  
    34653468
    34663469/** @copydoc kLdrModCallTerm */
    3467 static int kldrModMachOCallTerm(PKLDRMOD pMod, KUPTR uHandle)
     3470static int kldrModMachOCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    34683471{
    34693472    /* later */
    34703473    K_NOREF(pMod);
     3474    K_NOREF(pvMapping);
    34713475    K_NOREF(uHandle);
    34723476    return 0;
    … …  
    34753479
    34763480/** @copydoc kLdrModCallThread */
    3477 static int kldrModMachOCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
     3481static int kldrModMachOCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
    34783482{
    34793483    /* Relevant for Mach-O? */
    34803484    K_NOREF(pMod);
     3485    K_NOREF(pvMapping);
    34813486    K_NOREF(uHandle);
    34823487    K_NOREF(fAttachingOrDetaching);

  • trunk/kLdr/kLdrModNative.c

    r58 r81  
    145145static KI32 kldrModNativeNumberOfImports(PKLDRMOD pMod, const void *pvBits);
    146146
     147/*********************************************************************************************************************************
     148*   Global Variables                                                                                                             *
     149*********************************************************************************************************************************/
     150extern KLDRMODOPS g_kLdrModNativeOps;
     151
    147152
    148153
    … …  
    157162 * @param   ppMod           Where to store the module instance pointer.
    158163 */
    159 static int kldrModNativeCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
     164static int kldrModNativeCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KU32 fFlags, KCPUARCH enmCpuArch,
     165                               KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
    160166{
    161167    int rc = kLdrModOpenNative(kRdrName(pRdr), ppMod);
    … …  
    510516     * We're done.
    511517     */
     518    pMod->u32Magic = KLDRMOD_MAGIC;
     519    pMod->pOps = &g_kLdrModNativeOps;
    512520    *ppMod = pMod;
    513521    return 0;
    … …  
    943951
    944952        rc = pfnCallback(pMod, iDbgInfo,
    945                          enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion,
     953                         enmDbgInfoType, pDbgDir->MajorVersion, pDbgDir->MinorVersion, NULL /*pszPartNm*/,
    946954                         pDbgDir->PointerToRawData ? pDbgDir->PointerToRawData : -1,
    947955                         pDbgDir->AddressOfRawData ? pDbgDir->AddressOfRawData : NIL_KLDRADDR,
    948956                         pDbgDir->SizeOfData,
    949                          NULL,
    950                          pvUser);
     957                         NULL /*pszExtFile*/, pvUser);
    951958        if (rc)
    952959            break;
    … …  
    10161023
    10171024/** @copydoc kLdrModAllocTLS */
    1018 static int kldrModNativeAllocTLS(PKLDRMOD pMod)
     1025static int kldrModNativeAllocTLS(PKLDRMOD pMod, void *pvMapping)
    10191026{
    10201027    return 0;
    … …  
    10231030
    10241031/** @copydoc kLdrModFreeTLS */
    1025 static void kldrModNativeFreeTLS(PKLDRMOD pMod)
     1032static void kldrModNativeFreeTLS(PKLDRMOD pMod, void *pvMapping)
    10261033{
    10271034}
    … …  
    10431050
    10441051/** @copydoc kLdrModCallInit */
    1045 static int kldrModNativeCallInit(PKLDRMOD pMod, KUPTR uHandle)
     1052static int kldrModNativeCallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    10461053{
    10471054    return 0;
    … …  
    10501057
    10511058/** @copydoc kLdrModCallTerm */
    1052 static int kldrModNativeCallTerm(PKLDRMOD pMod, KUPTR uHandle)
     1059static int kldrModNativeCallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    10531060{
    10541061    return 0;
    … …  
    10571064
    10581065/** @copydoc kLdrModCallThread */
    1059 static int kldrModNativeCallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
     1066static int kldrModNativeCallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
    10601067{
    10611068    return 0;

  • trunk/kLdr/kLdrModPE.c

    r79 r81  
    121121                                    PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    122122static int  kldrModPEDoImports(PKLDRMODPE pModPE, void *pvMapping, PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    123 static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
    124 static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle);
     123static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, void *pvMapping, unsigned uOp, KUPTR uHandle);
     124static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, void *pvMapping, unsigned uOp, KUPTR uHandle);
    125125static KI32 kldrModPEDoCall(KUPTR uEntrypoint, KUPTR uHandle, KU32 uOp, void *pvReserved);
    126126
    … …  
    12831283
    12841284/** @copydoc kLdrModAllocTLS */
    1285 static int kldrModPEAllocTLS(PKLDRMOD pMod)
     1285static int kldrModPEAllocTLS(PKLDRMOD pMod, void *pvMapping)
    12861286{
    12871287    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    12901290     * Mapped?
    12911291     */
    1292     if (!pModPE->pvMapping)
    1293         return KLDR_ERR_NOT_MAPPED;
     1292    if (pvMapping == KLDRMOD_INT_MAP)
     1293    {
     1294        pvMapping = pModPE->pvMapping;
     1295        if (!pvMapping)
     1296            return KLDR_ERR_NOT_MAPPED;
     1297    }
    12941298
    12951299    /*
    … …  
    13051309
    13061310/** @copydoc kLdrModFreeTLS */
    1307 static void kldrModPEFreeTLS(PKLDRMOD pMod)
     1311static void kldrModPEFreeTLS(PKLDRMOD pMod, void *pvMapping)
    13081312{
    13091313    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    13121316     * Mapped?
    13131317     */
    1314     if (!pModPE->pvMapping)
    1315         return;
     1318    if (pvMapping == KLDRMOD_INT_MAP)
     1319    {
     1320        pvMapping = pModPE->pvMapping;
     1321        if (!pvMapping)
     1322            return;
     1323    }
    13161324
    13171325    /*
    … …  
    17091717
    17101718/** @copydoc kLdrModCallInit */
    1711 static int kldrModPECallInit(PKLDRMOD pMod, KUPTR uHandle)
     1719static int kldrModPECallInit(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    17121720{
    17131721    PKLDRMODPE pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    17171725     * Mapped?
    17181726     */
    1719     if (!pModPE->pvMapping)
    1720         return KLDR_ERR_NOT_MAPPED;
     1727    if (pvMapping == KLDRMOD_INT_MAP)
     1728    {
     1729        pvMapping = pModPE->pvMapping;
     1730        if (!pvMapping)
     1731            return KLDR_ERR_NOT_MAPPED;
     1732    }
    17211733
    17221734    /*
    17231735     * Do TLS callbacks first and then call the init/term function if it's a DLL.
    17241736     */
    1725     rc = kldrModPEDoCallTLS(pModPE, DLL_PROCESS_ATTACH, uHandle);
     1737    rc = kldrModPEDoCallTLS(pModPE, pvMapping, DLL_PROCESS_ATTACH, uHandle);
    17261738    if (    !rc
    17271739        &&  (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL))
    17281740    {
    1729         rc = kldrModPEDoCallDLL(pModPE, DLL_PROCESS_ATTACH, uHandle);
     1741        rc = kldrModPEDoCallDLL(pModPE, pvMapping, DLL_PROCESS_ATTACH, uHandle);
    17301742        if (rc)
    1731             kldrModPEDoCallTLS(pModPE, DLL_PROCESS_DETACH, uHandle);
     1743            kldrModPEDoCallTLS(pModPE, pvMapping, DLL_PROCESS_DETACH, uHandle);
    17321744    }
    17331745
    … …  
    17421754 * @returns KLDR_ERR_MODULE_INIT_FAILED  or KLDR_ERR_THREAD_ATTACH_FAILED on failure.
    17431755 * @param   pModPE          The PE module interpreter instance.
     1756 * @param   pvMapping       The module mapping to use (resolved).
    17441757 * @param   uOp             The operation (DLL_*).
    17451758 * @param   uHandle         The module handle to present.
    17461759 */
    1747 static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
     1760static int  kldrModPEDoCallDLL(PKLDRMODPE pModPE, void *pvMapping, unsigned uOp, KUPTR uHandle)
    17481761{
    17491762    int rc;
    … …  
    17581771     * Invoke the entrypoint and convert the boolean result to a kLdr status code.
    17591772     */
    1760     rc = kldrModPEDoCall((KUPTR)pModPE->pvMapping + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint,
    1761                          uHandle, uOp, NULL);
     1773    rc = kldrModPEDoCall((KUPTR)pvMapping + pModPE->Hdrs.OptionalHeader.AddressOfEntryPoint, uHandle, uOp, NULL);
    17621774    if (rc)
    17631775        rc = 0;
    … …  
    17781790 * @returns KLDR_ERR_THREAD_ATTACH_FAILED on failure.
    17791791 * @param   pModPE          The PE module interpreter instance.
     1792 * @param   pvMapping       The module mapping to use (resolved).
    17801793 * @param   uOp             The operation (DLL_*).
    17811794 * @param   uHandle         The module handle to present.
    17821795 */
    1783 static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, unsigned uOp, KUPTR uHandle)
     1796static int  kldrModPEDoCallTLS(PKLDRMODPE pModPE, void *pvMapping, unsigned uOp, KUPTR uHandle)
    17841797{
    17851798    /** @todo implement TLS support. */
    17861799    K_NOREF(pModPE);
     1800    K_NOREF(pvMapping);
    17871801    K_NOREF(uOp);
    17881802    K_NOREF(uHandle);
    … …  
    18621876
    18631877/** @copydoc kLdrModCallTerm */
    1864 static int kldrModPECallTerm(PKLDRMOD pMod, KUPTR uHandle)
     1878static int kldrModPECallTerm(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle)
    18651879{
    18661880    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    18691883     * Mapped?
    18701884     */
    1871     if (!pModPE->pvMapping)
    1872         return KLDR_ERR_NOT_MAPPED;
     1885    if (pvMapping == KLDRMOD_INT_MAP)
     1886    {
     1887        pvMapping = pModPE->pvMapping;
     1888        if (!pvMapping)
     1889            return KLDR_ERR_NOT_MAPPED;
     1890    }
    18731891
    18741892    /*
    18751893     * Do TLS callbacks first.
    18761894     */
    1877     kldrModPEDoCallTLS(pModPE, DLL_PROCESS_DETACH, uHandle);
     1895    kldrModPEDoCallTLS(pModPE, pvMapping, DLL_PROCESS_DETACH, uHandle);
    18781896    if (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL)
    1879         kldrModPEDoCallDLL(pModPE, DLL_PROCESS_DETACH, uHandle);
     1897        kldrModPEDoCallDLL(pModPE, pvMapping, DLL_PROCESS_DETACH, uHandle);
    18801898
    18811899    return 0;
    … …  
    18841902
    18851903/** @copydoc kLdrModCallThread */
    1886 static int kldrModPECallThread(PKLDRMOD pMod, KUPTR uHandle, unsigned fAttachingOrDetaching)
     1904static int kldrModPECallThread(PKLDRMOD pMod, void *pvMapping, KUPTR uHandle, unsigned fAttachingOrDetaching)
    18871905{
    18881906    PKLDRMODPE  pModPE = (PKLDRMODPE)pMod->pvData;
    … …  
    18911909
    18921910    /*
     1911     * Mapped?
     1912     */
     1913    if (pvMapping == KLDRMOD_INT_MAP)
     1914    {
     1915        pvMapping = pModPE->pvMapping;
     1916        if (!pvMapping)
     1917            return KLDR_ERR_NOT_MAPPED;
     1918    }
     1919
     1920    /*
    18931921     * Do TLS callbacks first and then call the init/term function if it's a DLL.
    18941922     */
    1895     rc = kldrModPEDoCallTLS(pModPE, uOp, uHandle);
     1923    rc = kldrModPEDoCallTLS(pModPE, pvMapping, uOp, uHandle);
    18961924    if (!fAttachingOrDetaching)
    18971925        rc = 0;
    … …  
    18991927        &&  (pModPE->Hdrs.FileHeader.Characteristics & IMAGE_FILE_DLL))
    19001928    {
    1901         rc = kldrModPEDoCallDLL(pModPE, uOp, uHandle);
     1929        rc = kldrModPEDoCallDLL(pModPE, pvMapping, uOp, uHandle);
    19021930        if (!fAttachingOrDetaching)
    19031931            rc = 0;
    19041932        if (rc)
    1905             kldrModPEDoCallTLS(pModPE, uOp, uHandle);
     1933            kldrModPEDoCallTLS(pModPE, pvMapping, uOp, uHandle);
    19061934    }
    19071935

  • trunk/kRdr/kRdrFile.cpp

    r29 r81  
    12981298    pRdrFile->cb = cb;
    12991299    pRdrFile->off = 0;
     1300    pRdrFile->cPreps = 0;
    13001301    pRdrFile->cMappings = 0;
    1301     pRdrFile->cPreps = 0;
     1302    pRdrFile->pvMapping = NULL;
    13021303    kHlpMemCopy(&pRdrFile->szFilename[0], szFilename, cchFilename + 1);
    13031304
Note: See TracChangeset for help on using the changeset viewer.

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