Changeset 3571


Ignore:
Timestamp:
Aug 31, 2007, 4:39:26 AM (18 years ago)
Author:
bird
Message:

Eliminated KLDRPROT.

Location:
trunk/kStuff
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/kStuff/include/k/kDbgAll.h

    r3550 r3571  
    2929#include <k/kTypes.h>
    3030#include <k/kRdr.h>
    31 //#include <k/kLdr.h>
    32 #include "kLdr.h"
     31#include <k/kLdr.h>
    3332#include <k/kDbg.h>
    3433

  • trunk/kStuff/include/k/kLdr.h

    r3570 r3571  
    161161typedef const KLDRPU *PCKLDRPU;
    162162
    163 
    164 /**
    165  * Memory Mapping Protections.
    166  *
    167  * @remark Shared segments can be mapped using the non copy-on-write variant.
    168  *         (Normally the copy-on-write variant is used because changes must
    169  *         be private and not shared with other processes mapping the file.)
    170  */
    171 typedef enum KLDRPROT
    172 {
    173     /** The usual invalid 0. */
    174     KLDRPROT_INVALID = 0,
    175     /** No access (page not present). */
    176     KLDRPROT_NOACCESS,
    177     /** Read only. */
    178     KLDRPROT_READONLY,
    179     /** Read & write. */
    180     KLDRPROT_READWRITE,
    181     /** Read & copy on write. */
    182     KLDRPROT_WRITECOPY,
    183     /** Execute only. */
    184     KLDRPROT_EXECUTE,
    185     /** Execute & read. */
    186     KLDRPROT_EXECUTE_READ,
    187     /** Execute, read & write. */
    188     KLDRPROT_EXECUTE_READWRITE,
    189     /** Execute, read & copy on write. */
    190     KLDRPROT_EXECUTE_WRITECOPY,
    191     /** The usual end value. (exclusive) */
    192     KLDRPROT_END,
    193     /** Blow the type up to 32-bits. */
    194     KLDRPROT_32BIT_HACK = 0x7fffffff
    195 } KLDRPROT;
    196163
    197164/** Pointer to a loader segment. */
    … …  
    489456    KU32            fFlags;
    490457    /** The segment protection. */
    491     KLDRPROT        enmProt;
     458    KPROT        enmProt;
    492459    /** The size of the segment. */
    493460    KLDRSIZE        cb;

  • trunk/kStuff/include/k/kRdrAll.h

    r3550 r3571  
    2929
    3030#include <k/kDefs.h>
    31 #include "../kLdr/kLdr.h" //later - <k/kLdr.h>
     31#include <k/kLdr.h>
    3232#include <k/kRdr.h>
    3333

  • trunk/kStuff/kDbg/kDbgModule.cpp

    r3552 r3571  
    343343 * @param   pSym        Where to store the symbol details.
    344344 */
    345 KDBG_DECL(int) kDbgModuleQuerySymbol(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
     345KDBG_DECL(int) kDbgModuleQuerySymbol(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PKDBGSYMBOL pSym)
    346346{
    347347    KDBGMOD_VALIDATE(pMod);
    … …  
    365365 *                      Free the returned symbol using kDbgSymbolFree().
    366366 */
    367 KDBG_DECL(int) kDbgModuleQuerySymbolA(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PPKDBGSYMBOL ppSym)
     367KDBG_DECL(int) kDbgModuleQuerySymbolA(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PPKDBGSYMBOL ppSym)
    368368{
    369369    kDbgAssertPtrReturn(ppSym, KERR_INVALID_POINTER);
    … …  
    396396 * @param   pLine       Where to store the line number details.
    397397 */
    398 KDBG_DECL(int) kDbgModuleQueryLine(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PKDBGLINE pLine)
     398KDBG_DECL(int) kDbgModuleQueryLine(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PKDBGLINE pLine)
    399399{
    400400    KDBGMOD_VALIDATE(pMod);
    … …  
    418418 *                      Free the returned line number using kDbgLineFree().
    419419 */
    420 KDBG_DECL(int) kDbgModuleQueryLineA(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PPKDBGLINE ppLine)
     420KDBG_DECL(int) kDbgModuleQueryLineA(PKDBGMOD pMod, KI32 iSegment, KDBGADDR off, PPKDBGLINE ppLine)
    421421{
    422422    kDbgAssertPtrReturn(ppLine, KERR_INVALID_POINTER);

  • trunk/kStuff/kLdr/kLdrHlp.h

    r3567 r3571  
    178178void    kldrHlpSemRelease(void);
    179179
    180 int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KLDRPROT enmProt, unsigned fFixed);
    181 int     kldrHlpPageProtect(void *pv, KSIZE cb, KLDRPROT enmProt);
     180int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KPROT enmProt, unsigned fFixed);
     181int     kldrHlpPageProtect(void *pv, KSIZE cb, KPROT enmProt);
    182182int     kldrHlpPageFree(void *pv, KSIZE cb);
    183183

  • trunk/kStuff/kLdr/kLdrHlpMem.c

    r3570 r3571  
    6464
    6565#ifdef __OS2__
    66 static ULONG kldrHlpPageProtToNative(KLDRPROT enmProt)
     66static ULONG kldrHlpPageProtToNative(KPROT enmProt)
    6767{
    6868    switch (enmProt)
    6969    {
    70         case KLDRPROT_NOACCESS:             return PAG_EXECUTE | PAG_READ | PAG_WRITE;
    71         case KLDRPROT_READONLY:             return PAG_COMMIT | PAG_READ;
    72         case KLDRPROT_READWRITE:            return PAG_COMMIT | PAG_READ | PAG_WRITE;
    73         case KLDRPROT_EXECUTE:              return PAG_COMMIT | PAG_EXECUTE;
    74         case KLDRPROT_EXECUTE_READ:         return PAG_COMMIT | PAG_EXECUTE | PAG_READ;
    75         case KLDRPROT_EXECUTE_READWRITE:    return PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE;
     70        case KPROT_NOACCESS:             return PAG_EXECUTE | PAG_READ | PAG_WRITE;
     71        case KPROT_READONLY:             return PAG_COMMIT | PAG_READ;
     72        case KPROT_READWRITE:            return PAG_COMMIT | PAG_READ | PAG_WRITE;
     73        case KPROT_EXECUTE:              return PAG_COMMIT | PAG_EXECUTE;
     74        case KPROT_EXECUTE_READ:         return PAG_COMMIT | PAG_EXECUTE | PAG_READ;
     75        case KPROT_EXECUTE_READWRITE:    return PAG_COMMIT | PAG_EXECUTE | PAG_READ | PAG_WRITE;
    7676        default:
    7777            kldrHlpAssert(0);
    … …  
    8080}
    8181#elif defined(__WIN__)
    82 static DWORD kldrHlpPageProtToNative(KLDRPROT enmProt)
     82static DWORD kldrHlpPageProtToNative(KPROT enmProt)
    8383{
    8484    switch (enmProt)
    8585    {
    86         case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
    87         case KLDRPROT_READONLY:             return PAGE_READONLY;
    88         case KLDRPROT_READWRITE:            return PAGE_READWRITE;
    89         case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
    90         case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
    91         case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
     86        case KPROT_NOACCESS:             return PAGE_NOACCESS;
     87        case KPROT_READONLY:             return PAGE_READONLY;
     88        case KPROT_READWRITE:            return PAGE_READWRITE;
     89        case KPROT_EXECUTE:              return PAGE_EXECUTE;
     90        case KPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
     91        case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
    9292        default:
    9393            kldrHlpAssert(0);
    … …  
    107107 * @param   enmProt     The new protection. Copy-on-write is invalid.
    108108 */
    109 int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KLDRPROT enmProt, unsigned fFixed)
     109int     kldrHlpPageAlloc(void **ppv, KSIZE cb, KPROT enmProt, unsigned fFixed)
    110110{
    111111#ifdef __OS2__
    … …  
    162162 * @param   enmProt     The new protection. Copy-on-write is invalid.
    163163 */
    164 int     kldrHlpPageProtect(void *pv, KSIZE cb, KLDRPROT enmProt)
     164int     kldrHlpPageProtect(void *pv, KSIZE cb, KPROT enmProt)
    165165{
    166166#ifdef __OS2__

  • trunk/kStuff/kLdr/kLdrModLX.c

    r3570 r3571  
    470470            case 0:
    471471            case OBJSHARED:
    472                 pMod->aSegments[i].enmProt = KLDRPROT_NOACCESS;
     472                pMod->aSegments[i].enmProt = KPROT_NOACCESS;
    473473                break;
    474474            case OBJREAD:
    475475            case OBJREAD | OBJSHARED:
    476                 pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
     476                pMod->aSegments[i].enmProt = KPROT_READONLY;
    477477                break;
    478478            case OBJWRITE:
    479479            case OBJWRITE | OBJREAD:
    480                 pMod->aSegments[i].enmProt = KLDRPROT_WRITECOPY;
     480                pMod->aSegments[i].enmProt = KPROT_WRITECOPY;
    481481                break;
    482482            case OBJWRITE | OBJSHARED:
    483483            case OBJWRITE | OBJSHARED | OBJREAD:
    484                 pMod->aSegments[i].enmProt = KLDRPROT_READWRITE;
     484                pMod->aSegments[i].enmProt = KPROT_READWRITE;
    485485                break;
    486486            case OBJEXEC:
    487487            case OBJEXEC | OBJSHARED:
    488                 pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE;
     488                pMod->aSegments[i].enmProt = KPROT_EXECUTE;
    489489                break;
    490490            case OBJEXEC | OBJREAD:
    491491            case OBJEXEC | OBJREAD | OBJSHARED:
    492                 pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READ;
     492                pMod->aSegments[i].enmProt = KPROT_EXECUTE_READ;
    493493                break;
    494494            case OBJEXEC | OBJWRITE:
    495495            case OBJEXEC | OBJWRITE | OBJREAD:
    496                 pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_WRITECOPY;
     496                pMod->aSegments[i].enmProt = KPROT_EXECUTE_WRITECOPY;
    497497                break;
    498498            case OBJEXEC | OBJWRITE | OBJSHARED:
    499499            case OBJEXEC | OBJWRITE | OBJSHARED | OBJREAD:
    500                 pMod->aSegments[i].enmProt = KLDRPROT_EXECUTE_READWRITE;
     500                pMod->aSegments[i].enmProt = KPROT_EXECUTE_READWRITE;
    501501                break;
    502502        }
    503503        if ((pModLX->paObjs[i].o32_flags & (OBJREAD | OBJWRITE | OBJEXEC | OBJRSRC)) == OBJRSRC)
    504             pMod->aSegments[i].enmProt = KLDRPROT_READONLY;
     504            pMod->aSegments[i].enmProt = KPROT_READONLY;
    505505        /*pMod->aSegments[i].f16bit = !(pModLX->paObjs[i].o32_flags & OBJBIGDEF)
    506506        pMod->aSegments[i].fIOPL = !(pModLX->paObjs[i].o32_flags & OBJIOPL)
    … …  
    13451345            return KLDR_ERR_ADDRESS_OVERFLOW;
    13461346    }
    1347     rc = kldrHlpPageAlloc(&pvBase, pModLX->cbMapped, KLDRPROT_EXECUTE_READWRITE, fFixed);
     1347    rc = kldrHlpPageAlloc(&pvBase, pModLX->cbMapped, KPROT_EXECUTE_READWRITE, fFixed);
    13481348    if (rc)
    13491349        return rc;
    … …  
    18291829        int rc;
    18301830        void *pv;
    1831         KLDRPROT enmProt;
     1831        KPROT enmProt;
    18321832
    18331833        /* calc new protection. */
    … …  
    18371837            switch (enmProt)
    18381838            {
    1839                 case KLDRPROT_NOACCESS:
    1840                 case KLDRPROT_READONLY:
    1841                 case KLDRPROT_READWRITE:
    1842                 case KLDRPROT_WRITECOPY:
    1843                     enmProt = KLDRPROT_READWRITE;
     1839                case KPROT_NOACCESS:
     1840                case KPROT_READONLY:
     1841                case KPROT_READWRITE:
     1842                case KPROT_WRITECOPY:
     1843                    enmProt = KPROT_READWRITE;
    18441844                    break;
    1845                 case KLDRPROT_EXECUTE:
    1846                 case KLDRPROT_EXECUTE_READ:
    1847                 case KLDRPROT_EXECUTE_READWRITE:
    1848                 case KLDRPROT_EXECUTE_WRITECOPY:
    1849                     enmProt = KLDRPROT_EXECUTE_READWRITE;
     1845                case KPROT_EXECUTE:
     1846                case KPROT_EXECUTE_READ:
     1847                case KPROT_EXECUTE_READWRITE:
     1848                case KPROT_EXECUTE_WRITECOPY:
     1849                    enmProt = KPROT_EXECUTE_READWRITE;
    18501850                    break;
    18511851                default:
    … …  
    18571857        {
    18581858            /* copy on write -> normal write. */
    1859             if (enmProt == KLDRPROT_EXECUTE_WRITECOPY)
    1860                 enmProt = KLDRPROT_EXECUTE_READWRITE;
    1861             else if (enmProt == KLDRPROT_WRITECOPY)
    1862                 enmProt = KLDRPROT_READWRITE;
     1859            if (enmProt == KPROT_EXECUTE_WRITECOPY)
     1860                enmProt = KPROT_EXECUTE_READWRITE;
     1861            else if (enmProt == KPROT_WRITECOPY)
     1862                enmProt = KPROT_READWRITE;
    18631863        }
    18641864

  • trunk/kStuff/kLdr/kLdrModMachO.c

    r3570 r3571  
    874874                                pSeg->Sel16bit = 0;
    875875                                pSeg->fFlags = 0;
    876                                 pSeg->enmProt = KLDRPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
     876                                pSeg->enmProt = KPROT_EXECUTE_WRITECOPY; /** @todo fixme! */
    877877                                pSeg->cb = pSect->size;
    878878                                pSeg->Alignment = (1 << pSect->align);

  • trunk/kStuff/kLdr/kLdrModNative.c

    r3570 r3571  
    349349    pMod->aSegments[0].pchName = "fake";
    350350    pMod->aSegments[0].cchName = sizeof("fake") - 1;
    351     pMod->aSegments[0].enmProt = KLDRPROT_NOACCESS;
     351    pMod->aSegments[0].enmProt = KPROT_NOACCESS;
    352352    pMod->aSegments[0].cb = 0;
    353353    pMod->aSegments[0].Alignment = 0;
    … …  
    377377    pMod->aSegments[0].pchName = "TheHeaders";
    378378    pMod->aSegments[0].cchName = sizeof("TheHeaders") - 1;
    379     pMod->aSegments[0].enmProt = KLDRPROT_READONLY;
     379    pMod->aSegments[0].enmProt = KPROT_READONLY;
    380380    pMod->aSegments[0].cb = pNtHdrs->OptionalHeader.SizeOfHeaders;
    381381    pMod->aSegments[0].Alignment = pNtHdrs->OptionalHeader.SectionAlignment;
    … …  
    440440            case 0:
    441441            case IMAGE_SCN_MEM_SHARED:
    442                 pMod->aSegments[i + 1].enmProt = KLDRPROT_NOACCESS;
     442                pMod->aSegments[i + 1].enmProt = KPROT_NOACCESS;
    443443                break;
    444444            case IMAGE_SCN_MEM_READ:
    445445            case IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_SHARED:
    446                 pMod->aSegments[i + 1].enmProt = KLDRPROT_READONLY;
     446                pMod->aSegments[i + 1].enmProt = KPROT_READONLY;
    447447                break;
    448448            case IMAGE_SCN_MEM_WRITE:
    449449            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ:
    450                 pMod->aSegments[i + 1].enmProt = KLDRPROT_WRITECOPY;
     450                pMod->aSegments[i + 1].enmProt = KPROT_WRITECOPY;
    451451                break;
    452452            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED:
    453453            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED | IMAGE_SCN_MEM_READ:
    454                 pMod->aSegments[i + 1].enmProt = KLDRPROT_READWRITE;
     454                pMod->aSegments[i + 1].enmProt = KPROT_READWRITE;
    455455                break;
    456456            case IMAGE_SCN_MEM_EXECUTE:
    457457            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_SHARED:
    458                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE;
     458                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE;
    459459                break;
    460460            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
    461461            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_SHARED:
    462                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_READ;
     462                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READ;
    463463                break;
    464464            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE:
    465465            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ:
    466                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_WRITECOPY;
     466                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_WRITECOPY;
    467467                break;
    468468            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED:
    469469            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED | IMAGE_SCN_MEM_READ:
    470                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_READWRITE;
     470                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READWRITE;
    471471                break;
    472472        }

  • trunk/kStuff/kLdr/kLdrModPE.c

    r3570 r3571  
    292292    pMod->aSegments[0].pchName = "TheHeaders";
    293293    pMod->aSegments[0].cchName = sizeof("TheHeaders") - 1;
    294     pMod->aSegments[0].enmProt = KLDRPROT_READONLY;
     294    pMod->aSegments[0].enmProt = KPROT_READONLY;
    295295    pMod->aSegments[0].cb = pModPE->Hdrs.OptionalHeader.SizeOfHeaders;
    296296    pMod->aSegments[0].Alignment = pModPE->Hdrs.OptionalHeader.SectionAlignment;
    … …  
    358358            case 0:
    359359            case IMAGE_SCN_MEM_SHARED:
    360                 pMod->aSegments[i + 1].enmProt = KLDRPROT_NOACCESS;
     360                pMod->aSegments[i + 1].enmProt = KPROT_NOACCESS;
    361361                break;
    362362            case IMAGE_SCN_MEM_READ:
    363363            case IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_SHARED:
    364                 pMod->aSegments[i + 1].enmProt = KLDRPROT_READONLY;
     364                pMod->aSegments[i + 1].enmProt = KPROT_READONLY;
    365365                break;
    366366            case IMAGE_SCN_MEM_WRITE:
    367367            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ:
    368                 pMod->aSegments[i + 1].enmProt = KLDRPROT_WRITECOPY;
     368                pMod->aSegments[i + 1].enmProt = KPROT_WRITECOPY;
    369369                break;
    370370            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED:
    371371            case IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED | IMAGE_SCN_MEM_READ:
    372                 pMod->aSegments[i + 1].enmProt = KLDRPROT_READWRITE;
     372                pMod->aSegments[i + 1].enmProt = KPROT_READWRITE;
    373373                break;
    374374            case IMAGE_SCN_MEM_EXECUTE:
    375375            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_SHARED:
    376                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE;
     376                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE;
    377377                break;
    378378            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ:
    379379            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_SHARED:
    380                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_READ;
     380                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READ;
    381381                break;
    382382            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE:
    383383            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ:
    384                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_WRITECOPY;
     384                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_WRITECOPY;
    385385                break;
    386386            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED:
    387387            case IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_SHARED | IMAGE_SCN_MEM_READ:
    388                 pMod->aSegments[i + 1].enmProt = KLDRPROT_EXECUTE_READWRITE;
     388                pMod->aSegments[i + 1].enmProt = KPROT_EXECUTE_READWRITE;
    389389                break;
    390390        }

  • trunk/kStuff/kLdr/kLdrRdrFile.c

    r3570 r3571  
    279279 * @param   enmProt     kLdr protection.
    280280 */
    281 static ULONG kldrRdrFileGetNtMapProt(KLDRPROT enmProt)
     281static ULONG kldrRdrFileGetNtMapProt(KPROT enmProt)
    282282{
    283283    switch (enmProt)
    284284    {
    285         case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
    286         case KLDRPROT_READONLY:             return PAGE_READONLY;
    287         case KLDRPROT_READWRITE:            return PAGE_READWRITE;
    288         case KLDRPROT_WRITECOPY:            return PAGE_WRITECOPY;
    289         case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
    290         case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
    291         case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
    292         case KLDRPROT_EXECUTE_WRITECOPY:    return PAGE_EXECUTE_WRITECOPY;
     285        case KPROT_NOACCESS:             return PAGE_NOACCESS;
     286        case KPROT_READONLY:             return PAGE_READONLY;
     287        case KPROT_READWRITE:            return PAGE_READWRITE;
     288        case KPROT_WRITECOPY:            return PAGE_WRITECOPY;
     289        case KPROT_EXECUTE:              return PAGE_EXECUTE;
     290        case KPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
     291        case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
     292        case KPROT_EXECUTE_WRITECOPY:    return PAGE_EXECUTE_WRITECOPY;
    293293        default:                            return ~(ULONG)0;
    294294    }
    … …  
    302302 * @param   enmProt     kLdr protection.
    303303 */
    304 static ULONG kldrRdrFileGetNtAllocProt(KLDRPROT enmProt)
     304static ULONG kldrRdrFileGetNtAllocProt(KPROT enmProt)
    305305{
    306306    switch (enmProt)
    307307    {
    308         case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
    309         case KLDRPROT_READONLY:             return PAGE_READONLY;
    310         case KLDRPROT_WRITECOPY:
    311         case KLDRPROT_READWRITE:            return PAGE_READWRITE;
    312         case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
    313         case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
    314         case KLDRPROT_EXECUTE_WRITECOPY:
    315         case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
     308        case KPROT_NOACCESS:             return PAGE_NOACCESS;
     309        case KPROT_READONLY:             return PAGE_READONLY;
     310        case KPROT_WRITECOPY:
     311        case KPROT_READWRITE:            return PAGE_READWRITE;
     312        case KPROT_EXECUTE:              return PAGE_EXECUTE;
     313        case KPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
     314        case KPROT_EXECUTE_WRITECOPY:
     315        case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
    316316        default:                            return ~(ULONG)0;
    317317    }
    … …  
    413413        int rc;
    414414        void *pv;
    415         KLDRPROT enmProt;
     415        KPROT enmProt;
    416416
    417417        if (paSegments[i].RVA == NIL_KLDRADDR)
    … …  
    424424            switch (enmProt)
    425425            {
    426                 case KLDRPROT_NOACCESS:
    427                 case KLDRPROT_READONLY:
    428                 case KLDRPROT_READWRITE:
    429                 case KLDRPROT_WRITECOPY:
    430                     enmProt = KLDRPROT_READWRITE;
     426                case KPROT_NOACCESS:
     427                case KPROT_READONLY:
     428                case KPROT_READWRITE:
     429                case KPROT_WRITECOPY:
     430                    enmProt = KPROT_READWRITE;
    431431                    break;
    432                 case KLDRPROT_EXECUTE:
    433                 case KLDRPROT_EXECUTE_READ:
    434                 case KLDRPROT_EXECUTE_READWRITE:
    435                 case KLDRPROT_EXECUTE_WRITECOPY:
    436                     enmProt = KLDRPROT_EXECUTE_READWRITE;
     432                case KPROT_EXECUTE:
     433                case KPROT_EXECUTE_READ:
     434                case KPROT_EXECUTE_READWRITE:
     435                case KPROT_EXECUTE_WRITECOPY:
     436                    enmProt = KPROT_EXECUTE_READWRITE;
    437437                    break;
    438438                default:
    … …  
    444444        {
    445445            /* copy on write -> normal write. */
    446             if (enmProt == KLDRPROT_EXECUTE_WRITECOPY)
    447                 enmProt = KLDRPROT_EXECUTE_READWRITE;
    448             else if (enmProt == KLDRPROT_WRITECOPY)
    449                 enmProt = KLDRPROT_READWRITE;
     446            if (enmProt == KPROT_EXECUTE_WRITECOPY)
     447                enmProt = KPROT_EXECUTE_READWRITE;
     448            else if (enmProt == KPROT_WRITECOPY)
     449                enmProt = KPROT_READWRITE;
    450450        }
    451451
    … …  
    771771     * Generic mapping code using kldrHlpPageAlloc(), kldrHlpPageFree() and kldrHlpPageProtect().
    772772     */
    773     rc = kldrHlpPageAlloc(&pPrep->pv, pPrep->cb, KLDRPROT_EXECUTE_READWRITE, fFixed);
     773    rc = kldrHlpPageAlloc(&pPrep->pv, pPrep->cb, KPROT_EXECUTE_READWRITE, fFixed);
    774774    if (rc)
    775775        return rc;

  • trunk/kStuff/kLdr/tstkLdrMod.c

    r3570 r3571  
    441441        if (pMod->aSegments[i].pvUser != NULL)
    442442            return Failure("Bad pvUser");
    443         if (pMod->aSegments[i].enmProt >= KLDRPROT_END || pMod->aSegments[i].enmProt <= KLDRPROT_INVALID)
     443        if (pMod->aSegments[i].enmProt >= KPROT_END || pMod->aSegments[i].enmProt <= KPROT_INVALID)
    444444            return Failure("Bad enmProt");
    445445        if (pMod->aSegments[i].MapAddress != 0)

  • trunk/kStuff/kRdr/Makefile.kmk

    r3548 r3571  
    3434kRdrStatic_TEMPLATE = kStuffLIB
    3535kRdrStatic_DEFS = KDBG_BUILDING
    36 kRdrStatic_INCS = ../kLdr
    3736kRdrStatic_SOURCES = \
    3837        kRdr.cpp \

  • trunk/kStuff/kRdr/kRdrFile.cpp

    r3552 r3571  
    273273 * @param   enmProt     kLdr protection.
    274274 */
    275 static ULONG krdrFileGetNtMapProt(KLDRPROT enmProt)
     275static ULONG krdrFileGetNtMapProt(KPROT enmProt)
    276276{
    277277    switch (enmProt)
    278278    {
    279         case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
    280         case KLDRPROT_READONLY:             return PAGE_READONLY;
    281         case KLDRPROT_READWRITE:            return PAGE_READWRITE;
    282         case KLDRPROT_WRITECOPY:            return PAGE_WRITECOPY;
    283         case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
    284         case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
    285         case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
    286         case KLDRPROT_EXECUTE_WRITECOPY:    return PAGE_EXECUTE_WRITECOPY;
     279        case KPROT_NOACCESS:             return PAGE_NOACCESS;
     280        case KPROT_READONLY:             return PAGE_READONLY;
     281        case KPROT_READWRITE:            return PAGE_READWRITE;
     282        case KPROT_WRITECOPY:            return PAGE_WRITECOPY;
     283        case KPROT_EXECUTE:              return PAGE_EXECUTE;
     284        case KPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
     285        case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
     286        case KPROT_EXECUTE_WRITECOPY:    return PAGE_EXECUTE_WRITECOPY;
    287287        default:                            return ~(ULONG)0;
    288288    }
    … …  
    296296 * @param   enmProt     kLdr protection.
    297297 */
    298 static ULONG krdrFileGetNtAllocProt(KLDRPROT enmProt)
     298static ULONG krdrFileGetNtAllocProt(KPROT enmProt)
    299299{
    300300    switch (enmProt)
    301301    {
    302         case KLDRPROT_NOACCESS:             return PAGE_NOACCESS;
    303         case KLDRPROT_READONLY:             return PAGE_READONLY;
    304         case KLDRPROT_WRITECOPY:
    305         case KLDRPROT_READWRITE:            return PAGE_READWRITE;
    306         case KLDRPROT_EXECUTE:              return PAGE_EXECUTE;
    307         case KLDRPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
    308         case KLDRPROT_EXECUTE_WRITECOPY:
    309         case KLDRPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
     302        case KPROT_NOACCESS:             return PAGE_NOACCESS;
     303        case KPROT_READONLY:             return PAGE_READONLY;
     304        case KPROT_WRITECOPY:
     305        case KPROT_READWRITE:            return PAGE_READWRITE;
     306        case KPROT_EXECUTE:              return PAGE_EXECUTE;
     307        case KPROT_EXECUTE_READ:         return PAGE_EXECUTE_READ;
     308        case KPROT_EXECUTE_WRITECOPY:
     309        case KPROT_EXECUTE_READWRITE:    return PAGE_EXECUTE_READWRITE;
    310310        default:                            return ~(ULONG)0;
    311311    }
    … …  
    444444        }
    445445
    446         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     446        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    447447
    448448        rc = kHlpPageProtect(pv, paSegments[i].cbMapped, enmProt);
    … …  
    511511            continue;
    512512
    513         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     513        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    514514        rc = pRdr->pOps->pfnRead(pRdr, pv, paSegments[i].cbFile, paSegments[i].offFile);
    515515        if (rc)
    … …  
    671671                continue;
    672672
    673             pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     673            pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    674674            if (paSegments[i].cbFile > 0)
    675675            {
    … …  
    729729                continue;
    730730
    731             pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     731            pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    732732            if (paSegments[i].cbFile > 0)
    733733                NtUnmapViewOfSection(NtCurrentProcess(), pv);
    … …  
    780780            continue;
    781781
    782         pv = (uint8_t *)pPrep->pv + paSegments[i].RVA;
     782        pv = (KU8 *)pPrep->pv + paSegments[i].RVA;
    783783        rc = pRdr->pOps->pfnRead(pRdr, pv, paSegments[i].cbFile, paSegments[i].offFile);
    784784        if (rc)
Note: See TracChangeset for help on using the changeset viewer.