Changeset 3578 for trunk/kStuff/kLdr


Ignore:
Timestamp:
Sep 2, 2007, 10:55:51 PM (18 years ago)
Author:
bird
Message:

kLdrRdr cleanup.

Location:
trunk/kStuff/kLdr
Files:
2 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/kStuff/kLdr/Makefile.kmk

    r3577 r3578  
    122122        kLdrErr.c \
    123123        kLdrMisc.c \
    124         kLdrRdr.c \
    125         kLdrRdrFile.c \
    126124        kLdrMod.c \
    127125        kLdrModLX.c \
    … …  
    137135        kLdr-win.c
    138136kLdr_LIBS += \
    139         $(PATH_LIB)/kHlpBaseStatic$(SUFF_LIB)
     137        $(PATH_LIB)/kRdrStatic$(SUFF_LIB) \
     138        $(PATH_LIB)/kHlpBareStatic$(SUFF_LIB)
    140139
    141140kLdrErr.c_DEPS = $(PATH_TARGET)/kldrErrConsts.h

  • trunk/kStuff/kLdr/kLdr-os2.def

    r3537 r3578  
    3030EXPORTS
    3131    ; The file reader API
    32     _kLdrRdrAddProvider
    33     _kLdrRdrOpen
    34     _kLdrRdrClose
    35     _kLdrRdrRead
    36     _kLdrRdrAllMap
    37     _kLdrRdrAllUnmap
    38     _kLdrRdrSize
    39     _kLdrRdrTell
    40     _kLdrRdrName
    41     _kLdrRdrPageSize
    42     _kLdrRdrMap
    43     _kLdrRdrRefresh
    44     _kLdrRdrProtect
    45     _kLdrRdrUnmap
    46     _kLdrRdrDone
     32    _kRdrAddProvider
     33    _kRdrOpen
     34    _kRdrClose
     35    _kRdrRead
     36    _kRdrAllMap
     37    _kRdrAllUnmap
     38    _kRdrSize
     39    _kRdrTell
     40    _kRdrName
     41    _kRdrPageSize
     42    _kRdrMap
     43    _kRdrRefresh
     44    _kRdrProtect
     45    _kRdrUnmap
     46    _kRdrDone
    4747
    4848    ; The module interpreter API

  • trunk/kStuff/kLdr/kLdr-win.def

    r3537 r3578  
    2929EXPORTS
    3030    ; The file reader API
    31     kLdrRdrAddProvider
    32     kLdrRdrOpen
    33     kLdrRdrClose
    34     kLdrRdrRead
    35     kLdrRdrAllMap
    36     kLdrRdrAllUnmap
    37     kLdrRdrSize
    38     kLdrRdrTell
    39     kLdrRdrName
    40     kLdrRdrPageSize
    41     kLdrRdrMap
    42     kLdrRdrRefresh
    43     kLdrRdrProtect
    44     kLdrRdrUnmap
    45     kLdrRdrDone
     31    kRdrAddProvider
     32    kRdrOpen
     33    kRdrClose
     34    kRdrRead
     35    kRdrAllMap
     36    kRdrAllUnmap
     37    kRdrSize
     38    kRdrTell
     39    kRdrName
     40    kRdrPageSize
     41    kRdrMap
     42    kRdrRefresh
     43    kRdrProtect
     44    kRdrUnmap
     45    kRdrDone
    4646
    4747    ; The module interpreter API

  • trunk/kStuff/kLdr/kLdrDyldFind.c

    r3574 r3578  
    9494    KLDRDYLDSEARCH  enmSearch;
    9595    KU32            fFlags;
    96     PPKLDRRDR       ppRdr;
     96    PPKRDR          ppRdr;
    9797} KLDRDYLDFINDARGS, *PKLDRDYLDFINDARGS;
    9898
    … …  
    201201*******************************************************************************/
    202202static int kldrDyldFindDoDllSearch(const char *pszName, const char *pszPrefix, const char *pszSuffix,
    203                                 KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr);
     203                                KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKRDR ppRdr);
    204204static int kldrDyldFindDoExeSearch(const char *pszName, const char *pszPrefix, const char *pszSuffix,
    205                                    KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr);
    206 static int kldrDyldFindTryOpen(const char *pszFilename, PPKLDRRDR ppRdr);
     205                                   KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKRDR ppRdr);
     206static int kldrDyldFindTryOpen(const char *pszFilename, PPKRDR ppRdr);
    207207static int kldrDyldFindTryOpenPath(const char *pchPath, KSIZE cchPath, PCKLDRDYLDFINDARGS pArgs);
    208208static int kldrDyldFindEnumeratePath(const char *pszSearchPath, PCKLDRDYLDFINDARGS pArgs);
    … …  
    356356{
    357357    int rc;
    358     PKLDRRDR pRdr = NULL;
     358    PKRDR pRdr = NULL;
    359359
    360360    *ppMod = NULL;
    … …  
    376376        if (fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE)
    377377        {
    378             const char     *pszFilename = kLdrRdrName(pRdr);
     378            const char     *pszFilename = kRdrName(pRdr);
    379379            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
    380380            PKLDRDYLDMOD    pCur;
    … …  
    390390        if (!(fFlags & KLDRYDLD_LOAD_FLAGS_SPECIFIC_MODULE))
    391391        {
    392             const char     *pszFilename = kLdrRdrName(pRdr);
     392            const char     *pszFilename = kRdrName(pRdr);
    393393            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
    394394            PKLDRDYLDMOD    pCur;
    … …  
    399399                    &&  !kHlpMemComp(pCur->pMod->pszFilename, pszFilename, cchFilename))
    400400                {
    401                     kLdrRdrClose(pRdr);
     401                    kRdrClose(pRdr);
    402402                    kldrDyldModMarkGlobal(pCur);
    403403                    *ppMod = pCur;
    … …  
    414414        rc = kldrDyldModCreate(pRdr, fFlags, ppMod);
    415415        if (rc)
    416             kLdrRdrClose(pRdr);
     416            kRdrClose(pRdr);
    417417    }
    418418    return rc;
    … …  
    434434 */
    435435static int kldrDyldFindDoDllSearch(const char *pszName, const char *pszPrefix, const char *pszSuffix,
    436                                    KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr)
     436                                   KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKRDR ppRdr)
    437437{
    438438    int rc;
    … …  
    548548 */
    549549static int kldrDyldFindDoExeSearch(const char *pszName, const char *pszPrefix, const char *pszSuffix,
    550                                    KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRRDR ppRdr)
     550                                   KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKRDR ppRdr)
    551551{
    552552    int rc;
    … …  
    609609 * @param   ppRdr           Where to store the pointer to the new module.
    610610 */
    611 static int kldrDyldFindTryOpen(const char *pszFilename, PPKLDRRDR ppRdr)
     611static int kldrDyldFindTryOpen(const char *pszFilename, PPKRDR ppRdr)
    612612{
    613613    int rc;
    … …  
    616616     * Try open the file.
    617617     */
    618     rc = kLdrRdrOpen(ppRdr, pszFilename);
     618    rc = kRdrOpen(ppRdr, pszFilename);
    619619    if (!rc)
    620620        return 0;
    … …  
    899899       )
    900900    {
    901         PKLDRRDR pRdr;
     901        PKRDR pRdr;
    902902        if (fOS2LibpathStrict)
    903903            rc = kldrDyldFindDoDllSearch(pszName, pszPrefix, pszSuffix, enmSearch, fFlags, &pRdr);
    … …  
    907907        {
    908908            /* do a filename based search. */
    909             const char     *pszFilename = kLdrRdrName(pRdr);
     909            const char     *pszFilename = kRdrName(pRdr);
    910910            const KSIZE     cchFilename = kHlpStrLen(pszFilename);
    911911            PKLDRDYLDMOD    pCur;
    … …  
    921921                }
    922922            }
    923             kLdrRdrClose(pRdr);
     923            kRdrClose(pRdr);
    924924        }
    925925    }

  • trunk/kStuff/kLdr/kLdrDyldMod.c

    r3573 r3578  
    6666 * @param   ppMod   Where to put the pointer to the new module on success.
    6767 */
    68 int kldrDyldModCreate(PKLDRRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod)
     68int kldrDyldModCreate(PKRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod)
    6969{
    7070    PKLDRDYLDMOD pMod;
    … …  
    8181    rc = kLdrModOpenFromRdr(pRdr, &pRawMod);
    8282    if (rc)
    83         return kldrDyldFailure(rc, "%s: %rc", kLdrRdrName(pRdr), rc);
     83        return kldrDyldFailure(rc, "%s: %rc", kRdrName(pRdr), rc);
    8484
    8585    /*
    … …  
    207207#ifdef __OS2__
    208208    HMODULE hmod = NULLHANDLE;
    209     APIRET rc = DosQueryModuleHandle(kLdrRdrName(pRdr), &hmod);
     209    APIRET rc = DosQueryModuleHandle(kRdrName(pRdr), &hmod);
    210210    if (!rc)
    211211
    212212#elif defined(__WIN__)
    213213    HMODULE hmod = NULL;
    214     if (GetModuleHandle(kLdrRdrName(pRdr))
     214    if (GetModuleHandle(kRdrName(pRdr))
    215215
    216216#else

  • trunk/kStuff/kLdr/kLdrInternal.h

    r3576 r3578  
    3030
    3131#include <k/kHlp.h>
     32#include <k/kRdr.h>
    3233
    3334#ifdef __cplusplus
    … …  
    8182 * @{
    8283 */
    83 
    84 
    85 /** Native file provider operations. */
    86 extern const KLDRRDROPS g_kLdrRdrFileOps;
    8784
    8885
    … …  
    359356
    360357
    361 int kldrDyldModCreate(PKLDRRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod);
     358int kldrDyldModCreate(PKRDR pRdr, KU32 fFlags, PPKLDRDYLDMOD ppMod);
    362359void kldrDyldModDestroy(PKLDRDYLDMOD pMod);
    363360void kldrDyldModAddRef(PKLDRDYLDMOD pMod);

  • trunk/kStuff/kLdr/kLdrMod.c

    r3573 r3578  
    111111     * Open the file using a bit provider.
    112112     */
    113     PKLDRRDR pRdr;
    114     int rc = kLdrRdrOpen(&pRdr, pszFilename);
     113    PKRDR pRdr;
     114    int rc = kRdrOpen(&pRdr, pszFilename);
    115115    if (!rc)
    116116    {
    … …  
    118118        if (!rc)
    119119            return 0;
    120        kLdrRdrClose(pRdr);
     120       kRdrClose(pRdr);
    121121    }
    122122    return rc;
    … …  
    135135 * @param   ppMod           Where to store the module handle.
    136136 */
    137 int kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod)
     137int kLdrModOpenFromRdr(PKRDR pRdr, PPKLDRMOD ppMod)
    138138{
    139139    union
    … …  
    151151     * Always read the 'new header' if we encounter MZ.
    152152     */
    153     rc = kLdrRdrRead(pRdr, &u, sizeof(u), 0);
     153    rc = kRdrRead(pRdr, &u, sizeof(u), 0);
    154154    if (rc)
    155155        return rc;
    156156    if (    u.u16 == IMAGE_DOS_SIGNATURE
    157         &&  kLdrRdrSize(pRdr) > sizeof(IMAGE_DOS_HEADER))
     157        &&  kRdrSize(pRdr) > sizeof(IMAGE_DOS_HEADER))
    158158    {
    159         rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), K_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
     159        rc = kRdrRead(pRdr, &u, sizeof(u.u32), K_OFFSETOF(IMAGE_DOS_HEADER, e_lfanew));
    160160        if (rc)
    161161            return rc;
    162         if ((KLDRFOFF)u.u32 < kLdrRdrSize(pRdr))
     162        if ((KLDRFOFF)u.u32 < kRdrSize(pRdr))
    163163        {
    164164            offHdr = u.u32;
    165             rc = kLdrRdrRead(pRdr, &u, sizeof(u.u32), offHdr);
     165            rc = kRdrRead(pRdr, &u, sizeof(u.u32), offHdr);
    166166            if (rc)
    167167                return rc;

  • trunk/kStuff/kLdr/kLdrModLX.c

    r3573 r3578  
    115115static int kldrModLXRelocateBits(PKLDRMOD pMod, void *pvBits, KLDRADDR NewBaseAddress, KLDRADDR OldBaseAddress,
    116116                                 PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    117 static int kldrModLXDoCreate(PKLDRRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX);
     117static int kldrModLXDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX);
    118118static const KU8 *kldrModLXDoNameTableLookupByOrdinal(const KU8 *pbNameTable, KI32 cbNameTable, KU32 iOrdinal);
    119119static int kldrModLXDoNameLookup(PKLDRMODLX pModLX, const char *pchSymbol, KU32 cchSymbol, KU32 *piSymbol);
    … …  
    145145 * @param   ppMod           Where to store the module instance pointer.
    146146 */
    147 static int kldrModLXCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
     147static int kldrModLXCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
    148148{
    149149    PKLDRMODLX pModLX;
    … …  
    170170 * simplify cleanup on failure.
    171171 */
    172 static int kldrModLXDoCreate(PKLDRRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX)
     172static int kldrModLXDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODLX *ppModLX)
    173173{
    174174    struct e32_exe Hdr;
    … …  
    187187     * Read the signature and file header.
    188188     */
    189     rc = kLdrRdrRead(pRdr, &Hdr, sizeof(Hdr), offNewHdr > 0 ? offNewHdr : 0);
     189    rc = kRdrRead(pRdr, &Hdr, sizeof(Hdr), offNewHdr > 0 ? offNewHdr : 0);
    190190    if (rc)
    191191        return rc;
    … …  
    205205
    206206    /* Some rough sanity checks. */
    207     offEnd = kLdrRdrSize(pRdr) >= (KLDRFOFF)~(KU32)16 ? ~(KU32)16 : (KU32)kLdrRdrSize(pRdr);
     207    offEnd = kRdrSize(pRdr) >= (KLDRFOFF)~(KU32)16 ? ~(KU32)16 : (KU32)kRdrSize(pRdr);
    208208    if (    Hdr.e32_itermap > offEnd
    209209        ||  Hdr.e32_datapage > offEnd
    … …  
    266266     * Calc the instance size, allocate and initialize it.
    267267     */
    268     cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     268    cchFilename = kHlpStrLen(kRdrName(pRdr));
    269269    cb = K_ALIGN_Z(sizeof(KLDRMODLX), 8)
    270270       + K_ALIGN_Z(K_OFFSETOF(KLDRMOD, aSegments[Hdr.e32_objcnt + 1]), 8)
    … …  
    284284    pMod->cchFilename = cchFilename;
    285285    pMod->pszFilename = (char *)K_ALIGN_P(&pMod->aSegments[pMod->cSegments], 8);
    286     kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
     286    kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
    287287    pMod->pszName = NULL; /* finalized further down */
    288288    pMod->cchName = 0;
    … …  
    357357     * Read the loader data.
    358358     */
    359     rc = kLdrRdrRead(pRdr, (void *)pModLX->pbLoaderSection, pModLX->Hdr.e32_ldrsize, pModLX->Hdr.e32_objtab + pModLX->offHdr);
     359    rc = kRdrRead(pRdr, (void *)pModLX->pbLoaderSection, pModLX->Hdr.e32_ldrsize, pModLX->Hdr.e32_objtab + pModLX->offHdr);
    360360    if (rc)
    361361        return rc;
    … …  
    527527    if (pMod->pRdr)
    528528    {
    529         rc = kLdrRdrClose(pMod->pRdr);
     529        rc = kRdrClose(pMod->pRdr);
    530530        pMod->pRdr = NULL;
    531531    }
    … …  
    941941
    942942    off = pModLX->Hdr.e32_objtab + pModLX->Hdr.e32_ldrsize;
    943     rc = kLdrRdrRead(pModLX->pMod->pRdr, pv, pModLX->Hdr.e32_fixupsize,
     943    rc = kRdrRead(pModLX->pMod->pRdr, pv, pModLX->Hdr.e32_fixupsize,
    944944                     off + pModLX->offHdr);
    945945    if (!rc)
    … …  
    13811381static int kldrModLXDoLoadBits(PKLDRMODLX pModLX, void *pvBits)
    13821382{
    1383     const PKLDRRDR pRdr = pModLX->pMod->pRdr;
     1383    const PKRDR pRdr = pModLX->pMod->pRdr;
    13841384    KU8 *pbTmpPage = NULL;
    13851385    int rc = 0;
    … …  
    14061406                case VALID:
    14071407                    if (pMap->o32_pagesize == OBJPAGELEN)
    1408                         rc = kLdrRdrRead(pRdr, pbPage, OBJPAGELEN,
     1408                        rc = kRdrRead(pRdr, pbPage, OBJPAGELEN,
    14091409                                         pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
    14101410                    else if (pMap->o32_pagesize < OBJPAGELEN)
    14111411                    {
    1412                         rc = kLdrRdrRead(pRdr, pbPage, pMap->o32_pagesize,
     1412                        rc = kRdrRead(pRdr, pbPage, pMap->o32_pagesize,
    14131413                                         pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
    14141414                        kHlpMemSet(pbPage + pMap->o32_pagesize, 0, OBJPAGELEN - pMap->o32_pagesize);
    … …  
    14351435
    14361436                    /* read it and ensure 4 extra zero bytes. */
    1437                     rc = kLdrRdrRead(pRdr, pbTmpPage, pMap->o32_pagesize,
     1437                    rc = kRdrRead(pRdr, pbTmpPage, pMap->o32_pagesize,
    14381438                                     pModLX->Hdr.e32_datapage + (pMap->o32_pagedataoffset << pModLX->Hdr.e32_pageshift));
    14391439                    if (rc)

  • trunk/kStuff/kLdr/kLdrModMachO.c

    r3573 r3578  
    159159                                    PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    160160
    161 static int  kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppMod);
    162 static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
     161static int  kldrModMachODoCreate(PKRDR pRdr, PKLDRMODMACHO *ppMod);
     162static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKRDR pRdr,
    163163                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool);
    164164static int  kldrModMachOParseLoadCommands(PKLDRMODMACHO pModMachO, char *pbStringPool, KU32 cbStringPool);
    … …  
    196196 * @param   ppMod           Where to store the module instance pointer.
    197197 */
    198 static int kldrModMachOCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
     198static int kldrModMachOCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
    199199{
    200200    PKLDRMODMACHO pModMachO;
    … …  
    225225 * simplify cleanup on failure.
    226226 */
    227 static int kldrModMachODoCreate(PKLDRRDR pRdr, PKLDRMODMACHO *ppModMachO)
     227static int kldrModMachODoCreate(PKRDR pRdr, PKLDRMODMACHO *ppModMachO)
    228228{
    229229    union
    … …  
    246246     * Read the Mach-O header.
    247247     */
    248     rc = kLdrRdrRead(pRdr, &s, sizeof(s), 0);
     248    rc = kRdrRead(pRdr, &s, sizeof(s), 0);
    249249    if (rc)
    250250        return rc;
    … …  
    260260
    261261    /* sanity checks. */
    262     if (    s.Hdr32.sizeofcmds > kLdrRdrSize(pRdr) - sizeof(mach_header_32_t)
     262    if (    s.Hdr32.sizeofcmds > kRdrSize(pRdr) - sizeof(mach_header_32_t)
    263263        ||  s.Hdr32.sizeofcmds < sizeof(load_command_t) * s.Hdr32.ncmds
    264264        ||  (s.Hdr32.flags & ~MH_VALID_FLAGS))
    … …  
    281281    if (!pbLoadCommands)
    282282        return KLDR_ERR_NO_MEMORY;
    283     rc = kLdrRdrRead(pRdr, pbLoadCommands, s.Hdr32.sizeofcmds,
     283    rc = kRdrRead(pRdr, pbLoadCommands, s.Hdr32.sizeofcmds,
    284284                        s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE
    285285                     || s.Hdr32.magic == IMAGE_MACHO32_SIGNATURE_OE
    … …  
    297297     * Calc the instance size, allocate and initialize it.
    298298     */
    299     cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     299    cchFilename = kHlpStrLen(kRdrName(pRdr));
    300300    cb = K_ALIGN_Z(  K_OFFSETOF(KLDRMODMACHO, aSegments[cSegments])
    301301                      + sizeof(KLDRMODMACHOSECT) * cSections, 16)
    … …  
    318318    pMod->cchFilename = cchFilename;
    319319    pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
    320     kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
     320    kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
    321321    pMod->pszName = kHlpGetFilename(pMod->pszFilename);
    322322    pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
    … …  
    429429 * @param   pcbStringPool   Where to store the string pool size.
    430430 */
    431 static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKLDRRDR pRdr,
     431static int  kldrModMachOPreParseLoadCommands(KU8 *pbLoadCommands, const mach_header_32_t *pHdr, PKRDR pRdr,
    432432                                             KU32 *pcSegments, KU32 *pcSections, KU32 *pcbStringPool)
    433433{
    … …  
    442442        uuid_command_t       *pUuid;
    443443    } u;
    444     const KU64 cbFile = kLdrRdrSize(pRdr);
     444    const KU64 cbFile = kRdrSize(pRdr);
    445445    KU32 cSegments = 0;
    446446    KU32 cSections = 0;
    … …  
    670670                      : sizeof(macho_nlist_64_t);
    671671                if (    u.pSymTab->symoff >= cbFile
    672                     ||  (KU64)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kLdrRdrSize(pRdr))
     672                    ||  (KU64)u.pSymTab->symoff + u.pSymTab->nsyms * cbSym > kRdrSize(pRdr))
    673673                    return KLDR_ERR_MACHO_BAD_LOAD_COMMAND;
    674674                if (    u.pSymTab->stroff >= cbFile
    … …  
    10081008    if (pMod->pRdr)
    10091009    {
    1010         rc = kLdrRdrClose(pMod->pRdr);
     1010        rc = kRdrClose(pMod->pRdr);
    10111011        pMod->pRdr = NULL;
    10121012    }
    … …  
    15721572    else
    15731573    {
    1574         rc = kLdrRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
     1574        rc = kRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
    15751575        if (rc)
    15761576            return rc;
    … …  
    16111611    else
    16121612    {
    1613         rc = kLdrRdrUnmap(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
     1613        rc = kRdrUnmap(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
    16141614        if (rc)
    16151615            return rc;
    … …  
    16591659
    16601660    /* the file provider does it all */
    1661     return kLdrRdrRefresh(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
     1661    return kRdrRefresh(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments);
    16621662}
    16631663
    … …  
    16821682    else
    16831683    {
    1684         rc = kLdrRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
     1684        rc = kRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
    16851685        if (rc)
    16861686            return rc;
    … …  
    16991699        rc2 = KLDR_ERR_TODO; /* deal with this if it ever occurs. */
    17001700    else
    1701         rc2 = kLdrRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
     1701        rc2 = kRdrProtect(pMod->pRdr, pModMachO->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
    17021702    if (!rc && rc2)
    17031703        rc = rc2;
    … …  
    21512151            {
    21522152                /* read */
    2153                 rc = kLdrRdrRead(pModMachO->pMod->pRdr, pvSyms, cbSyms, pModMachO->offSymbols);
     2153                rc = kRdrRead(pModMachO->pMod->pRdr, pvSyms, cbSyms, pModMachO->offSymbols);
    21542154                if (!rc && pModMachO->cchStrings)
    2155                     rc = kLdrRdrRead(pModMachO->pMod->pRdr, pvStrings, pModMachO->cchStrings, pModMachO->offStrings);
     2155                    rc = kRdrRead(pModMachO->pMod->pRdr, pvStrings, pModMachO->cchStrings, pModMachO->offStrings);
    21562156                if (!rc)
    21572157                {
    … …  
    22242224
    22252225    /* read the fixups. */
    2226     rc = kLdrRdrRead(pModMachO->pMod->pRdr, paFixups, cbFixups, offFixups);
     2226    rc = kRdrRead(pModMachO->pMod->pRdr, paFixups, cbFixups, offFixups);
    22272227    if (!rc)
    22282228    {
    … …  
    22582258    int rc = 0;
    22592259    if (!pModMachO->pvBits)
    2260         rc = kLdrRdrAllMap(pModMachO->pMod->pRdr, &pModMachO->pvBits);
     2260        rc = kRdrAllMap(pModMachO->pMod->pRdr, &pModMachO->pvBits);
    22612261    return rc;
    22622262}
    … …  
    23232323                ||  !pMod->aSegments[i].Alignment)
    23242324                continue;
    2325             rc = kLdrRdrRead(pMod->pRdr,
     2325            rc = kRdrRead(pMod->pRdr,
    23262326                             (KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModMachO->LinkAddress),
    23272327                             pMod->aSegments[i].cbFile,

  • trunk/kStuff/kLdr/kLdrModNative.c

    r3573 r3578  
    153153 * @param   ppMod           Where to store the module instance pointer.
    154154 */
    155 static int kldrModNativeCreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
    156 {
    157     int rc = kLdrModOpenNative(kLdrRdrName(pRdr), ppMod);
     155static int kldrModNativeCreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
     156{
     157    int rc = kLdrModOpenNative(kRdrName(pRdr), ppMod);
    158158    if (rc)
    159159        return rc;
    160     rc = kLdrRdrClose(pRdr);
     160    rc = kRdrClose(pRdr);
    161161    KLDRMODNATIVE_ASSERT(!rc);
    162162    return 0;

  • trunk/kStuff/kLdr/kLdrModPE.c

    r3574 r3578  
    105105                                  PFNKLDRMODGETIMPORT pfnGetImport, void *pvUser);
    106106
    107 static int  kldrModPEDoCreate(PKLDRRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppMod);
     107static int  kldrModPEDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppMod);
    108108/*static void kldrModPEDoLoadConfigConversion(PIMAGE_LOAD_CONFIG_DIRECTORY64 pLoadCfg); */
    109109static int  kLdrModPEDoOptionalHeaderValidation(PKLDRMODPE pModPE);
    … …  
    134134 * @param   ppMod           Where to store the module instance pointer.
    135135 */
    136 static int kldrModPECreate(PCKLDRMODOPS pOps, PKLDRRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
     136static int kldrModPECreate(PCKLDRMODOPS pOps, PKRDR pRdr, KLDRFOFF offNewHdr, PPKLDRMOD ppMod)
    137137{
    138138    PKLDRMODPE pModPE;
    … …  
    159159 * simplify cleanup on failure.
    160160 */
    161 static int kldrModPEDoCreate(PKLDRRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppModPE)
     161static int kldrModPEDoCreate(PKRDR pRdr, KLDRFOFF offNewHdr, PKLDRMODPE *ppModPE)
    162162{
    163163    struct
    … …  
    178178     * Read the signature and file header.
    179179     */
    180     rc = kLdrRdrRead(pRdr, &s, sizeof(s), offNewHdr > 0 ? offNewHdr : 0);
     180    rc = kRdrRead(pRdr, &s, sizeof(s), offNewHdr > 0 ? offNewHdr : 0);
    181181    if (rc)
    182182        return rc;
    … …  
    199199     * Calc the instance size, allocate and initialize it.
    200200     */
    201     cchFilename = kHlpStrLen(kLdrRdrName(pRdr));
     201    cchFilename = kHlpStrLen(kRdrName(pRdr));
    202202    cb = K_ALIGN_Z(K_OFFSETOF(KLDRMODPE, aShdrs[s.FileHdr.NumberOfSections]), 16)
    203203       + K_OFFSETOF(KLDRMOD, aSegments[s.FileHdr.NumberOfSections + 1])
    … …  
    216216    pMod->cchFilename = cchFilename;
    217217    pMod->pszFilename = (char *)&pMod->aSegments[pMod->cSegments];
    218     kHlpMemCopy((char *)pMod->pszFilename, kLdrRdrName(pRdr), cchFilename + 1);
     218    kHlpMemCopy((char *)pMod->pszFilename, kRdrName(pRdr), cchFilename + 1);
    219219    pMod->pszName = kHlpGetFilename(pMod->pszFilename);
    220220    pMod->cchName = cchFilename - (pMod->pszName - pMod->pszFilename);
    … …  
    261261     */
    262262    off = pModPE->offHdrs + sizeof(pModPE->Hdrs.Signature) + sizeof(pModPE->Hdrs.FileHeader);
    263     rc = kLdrRdrRead(pRdr, &pModPE->Hdrs.OptionalHeader, pModPE->Hdrs.FileHeader.SizeOfOptionalHeader, off);
     263    rc = kRdrRead(pRdr, &pModPE->Hdrs.OptionalHeader, pModPE->Hdrs.FileHeader.SizeOfOptionalHeader, off);
    264264    if (rc)
    265265        return rc;
    … …  
    267267        kldrModPEDoOptionalHeaderConversion(&pModPE->Hdrs.OptionalHeader);
    268268    off += pModPE->Hdrs.FileHeader.SizeOfOptionalHeader;
    269     rc = kLdrRdrRead(pRdr, &pModPE->aShdrs[0], sizeof(IMAGE_SECTION_HEADER) * pModPE->Hdrs.FileHeader.NumberOfSections, off);
     269    rc = kRdrRead(pRdr, &pModPE->aShdrs[0], sizeof(IMAGE_SECTION_HEADER) * pModPE->Hdrs.FileHeader.NumberOfSections, off);
    270270    if (rc)
    271271        return rc;
    … …  
    530530    if (pMod->pRdr)
    531531    {
    532         rc = kLdrRdrClose(pMod->pRdr);
     532        rc = kRdrClose(pMod->pRdr);
    533533        pMod->pRdr = NULL;
    534534    }
    … …  
    553553{
    554554    PKLDRMOD    pMod = pModPE->pMod;
    555     unsigned    fFixed;
     555    KBOOL       fFixed;
    556556    void       *pvBase;
    557557    int         rc;
    … …  
    575575
    576576    /* try do the prepare */
    577     rc = kLdrRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
     577    rc = kRdrMap(pMod->pRdr, &pvBase, pMod->cSegments, pMod->aSegments, fFixed);
    578578    if (rc)
    579579        return rc;
    … …  
    616616     * Try unmap the image.
    617617     */
    618     rc = kLdrRdrUnmap(pMod->pRdr, (void *)pvMapping, pMod->cSegments, pMod->aSegments);
     618    rc = kRdrUnmap(pMod->pRdr, (void *)pvMapping, pMod->cSegments, pMod->aSegments);
    619619    if (rc)
    620620        return rc;
    … …  
    13151315
    13161316    /* the file provider does it all */
    1317     return kLdrRdrRefresh(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments);
     1317    return kRdrRefresh(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments);
    13181318}
    13191319
    … …  
    13341334     * Before doing anything we'll have to make all pages writable.
    13351335     */
    1336     rc = kLdrRdrProtect(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
     1336    rc = kRdrProtect(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 1 /* unprotect */);
    13371337    if (rc)
    13381338        return rc;
    … …  
    13531353     * Restore protection.
    13541354     */
    1355     rc2 = kLdrRdrProtect(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
     1355    rc2 = kRdrProtect(pMod->pRdr, (void *)pModPE->pvMapping, pMod->cSegments, pMod->aSegments, 0 /* protect */);
    13561356    if (!rc && rc2)
    13571357        rc = rc2;
    … …  
    19141914            ||  !pMod->aSegments[i].Alignment)
    19151915            continue;
    1916         rc = kLdrRdrRead(pMod->pRdr,
     1916        rc = kRdrRead(pMod->pRdr,
    19171917                         (KU8 *)pvBits + (pMod->aSegments[i].LinkAddress - pModPE->Hdrs.OptionalHeader.ImageBase),
    19181918                         pMod->aSegments[i].cbFile,
Note: See TracChangeset for help on using the changeset viewer.