Changeset 3571 for trunk/kStuff/kLdr


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

Eliminated KLDRPROT.

Location:
trunk/kStuff/kLdr
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • 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)
Note: See TracChangeset for help on using the changeset viewer.