Changeset 2878 for trunk/src


Ignore:
Timestamp:
Feb 24, 2000, 12:01:00 AM (26 years ago)
Author:
bird
Message:

Corrections for Aurora retail kernel.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/win32k/dev32/d32init.c

    r2838 r2878  
    1 /* $Id: d32init.c,v 1.14 2000-02-21 09:24:00 bird Exp $
     1/* $Id: d32init.c,v 1.15 2000-02-23 23:01:00 bird Exp $
    22 *
    33 * d32init.c - 32-bits init routines.
     
    4141#include "macros.h"
    4242
     43
    4344/*******************************************************************************
    4445*   Global Variables                                                           *
     
    7677
    7778
     79#ifndef DEBUGR3
    7880/**
    7981 * Ring-0, 32-bit, init function.
     
    429431                if (pOTE != NULL)
    430432                {
     433                    /* Copy OTEs */
    431434                    for (i = 0; i < pOTEBuf->cObjects; i++)
    432435                        memcpy((void*)&pOTEBuf->aObjects[i], &pOTE[i], sizeof(OTE));
    433436                    usRc = 0;
     437
     438                    /*
     439                     * Search for internal revision stuff in the two first objects.
     440                     */
     441                    #if 0
     442                    for (i = 0; i < 2; i++)
     443                    {
     444                        const char *psz = (const char*)pOTE[i].ote_base;
     445                        const char *pszEnd = psz + pOTE[i].ote_size;
     446
     447                        while (psz + 100 < pszEnd)
     448                        {
     449                            strncmp(psz, "Internal revision");
     450
     451                            /* next */
     452                            psz++;
     453                        }
     454                    }
     455                    #endif
    434456                }
    435457                else
     
    450472    return (USHORT)(usRc | (usRc != NO_ERROR ? STATUS_DONE | STERR : STATUS_DONE));
    451473}
     474#endif /* !DEBUGR3*/
    452475
    453476
     
    506529     *  or
    507530     *     push ebp
    508      *     mov ecx, dword ptr [xxxxxxxx]
     531     *     mov eax, dword ptr [xxxxxxxx]
    509532     *
    510533     * These are allowed when not overloading:
     
    514537     *     mov eax, imm32
    515538     *     push ebp
     539     *  or
     540     *     mov eax, msoff32
     541     *
    516542     */
    517543    if ((pach[0] == 0x55 && (pach[1] == 0x8b || pach[1] == 0xa1)) /* two first prologs */
    518544        ||
    519         (pach[0] == 0xB8 && (pach[5] == 0xEB || pach[5] == 0x55) && !fOverload) /* two last prologs */
     545        (pach[0] == 0xB8 && (pach[5] == 0xEB || pach[5] == 0x55 ) && !fOverload) /* two next prologs */
     546        ||
     547        (pach[0] == 0xa1 && !fOverload) /* last prolog */
    520548        )
    521549    {
     
    562590                case 0x3c:              /* cmp al, imm8 */
    563591                case 0x6a:              /* push <byte> */
     592                case 0xa0:              /* mov al, moffs8 */
     593                case 0xa2:              /* mov moffs8, al */
    564594                    pach++;
    565595                    cb++;
     
    579609                case 0x3d:              /* cmp eax, imm32 */
    580610                case 0x68:              /* push <dword> */
     611                case 0xa1:              /* mov eax, moffs16 */
     612                case 0xa3:              /* mov moffs16, eax */
    581613                    pach += 4;
    582614                    cb += 4;
     
    681713    {
    682714        BOOL fForce;
     715        int  cOpPrefix = 0;
    683716        cb = 0;
    684717        while (cb < 8 || fForce)        /* 8 is the size of a 66h prefixed far jump instruction. */
     
    687720            switch (*pach)
    688721            {
     722                case 0x0f:              /* push gs and push fs */
     723                    if (pach[1] != 0xA0 && pach[1] != 0xA8)
     724                    {
     725                        kprintf(("interpretFunctionProlog16: unknown instruction 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
     726                        return -11;
     727                    }
     728                    pach++;
     729                    cb++;
     730                    break;
     731
    689732                case 0x50:              /* push ax */
    690733                case 0x51:              /* push cx */
     
    704747                case 0x65:              /* gs segment override */
    705748                    fForce = TRUE;
     749                    if (cOpPrefix > 0)
     750                        cOpPrefix++;
     751                    break;
     752
     753                case 0x66:
     754                    cOpPrefix = 2;      /* it's decremented once before it's used. */
     755                    fForce = TRUE;
    706756                    break;
    707757
     
    712762
    713763                case 0x68:              /* push <word> */
     764                    if (cOpPrefix > 0)
     765                    {
     766                        pach += 2;
     767                        cb += 2;
     768                    }
    714769                    pach += 2;
    715770                    cb += 2;
     
    720775                        || ((pach[1] & 0xc0) == 0 && (pach[1] & 0x7) == 6)) /* ex. mov bp,0ff23h */
    721776                    {   /* 16-bit displacement */
     777                        if (cOpPrefix > 0)
     778                        {
     779                            pach += 2;
     780                            cb += 2;
     781                        }
    722782                        pach += 3;
    723783                        cb += 3;
     
    742802            pach++;
    743803            cb++;
     804            if (cOpPrefix > 0)
     805                cOpPrefix--;
    744806        }
    745807    }
     
    750812
    751813
    752 
     814#ifndef DEBUGR3
    753815/**
    754816 * Verifies the aImportTab.
     
    10611123    return NO_ERROR;
    10621124}
    1063 
     1125#endif /* !DEBUGR3 */
     1126
     1127
     1128
     1129
     1130/*******************************************************************************
     1131*   Ring-3 Debug Stuff
     1132*******************************************************************************/
     1133#ifdef DEBUGR3
     1134#include <stdio.h>
     1135
     1136void main(void)
     1137{
     1138    char ach_ldrRead[] = {
     1139        0x55, 0x8b, 0xec, 0x8d, 0x65, 0xf8, 0x53, 0x56,
     1140        0x57, 0x33, 0xd2, 0x42, 0x89, 0x55, 0xf8, 0x38,
     1141        0x35, 0xce, 0x70, 0x00, 0x00, 0x75, 0x4d, 0x8b,
     1142        0x55, 0x08, 0x66, 0x83, 0xfa, 0xff, 0x74, 0x62
     1143    };
     1144    char ach_ldrOpen[] = {
     1145        0x55, 0x8b, 0xec, 0x33, 0xc0, 0x38, 0x05, 0xce,
     1146        0x70, 0x00, 0x00, 0x75, 0x4b, 0x50, 0xff, 0x75,
     1147        0x08, 0x6a, 0x01, 0x68, 0xa3, 0x00, 0x00, 0x00,
     1148        0xff, 0x75, 0x0c, 0xff, 0x15, 0xc4, 0xc1, 0x0d
     1149    };
     1150    char ach_ldrClose[] = {
     1151        0x55, 0x8b, 0xec, 0x33, 0xc0, 0x38, 0x05, 0xce,
     1152        0x70, 0x00, 0x00, 0x75, 0x13, 0x8b, 0x55, 0x08,
     1153        0x0f, 0xb7, 0xd2, 0x66, 0x83, 0xfa, 0xff, 0x74,
     1154        0x07, 0x52, 0xff, 0x15, 0xcc, 0xc1, 0x0d, 0x00
     1155    };
     1156    char ach_LDRQAppType[] = {
     1157        0x55, 0x8b, 0x0d, 0xa0, 0x0a, 0x00, 0x00, 0x8b,
     1158        0xec, 0x83, 0xec, 0x3c, 0x53, 0x81, 0xc1, 0x24,
     1159        0x06, 0x00, 0x00, 0x57, 0x56, 0x6a, 0xff, 0x66,
     1160        0xc7, 0x45, 0xc6, 0x00, 0x00, 0x51, 0xe8, 0x38
     1161    };
     1162    char ach_ldrEnum32bitRelRecs[] = {
     1163        0x55, 0xa1, 0xe8, 0xcf, 0x0d, 0x00, 0x8b, 0xec,
     1164        0x83, 0xec, 0x5c, 0x53, 0x8b, 0x55, 0x08, 0x57,
     1165        0x56, 0x8b, 0x52, 0x04, 0xf6, 0x40, 0x04, 0x80,
     1166        0x89, 0x55, 0xfc, 0x0f, 0x84, 0x10, 0x01, 0x00
     1167    };
     1168    char ach_IOSftOpen[] = {
     1169        0x55, 0x8b, 0xec, 0x8d, 0xa5, 0xa0, 0xfe, 0xff,
     1170        0xff, 0xf6, 0x05, 0x95, 0x2d, 0x00, 0x00, 0x80,
     1171        0x74, 0x13, 0x66, 0x68, 0x50, 0x30, 0xff, 0x75,
     1172        0x08, 0x6a, 0x3c, 0x6a, 0x06, 0xe8, 0x5a, 0x03
     1173    };
     1174    char ach_IOSftClose[] = {
     1175        0x55, 0x8b, 0xec, 0x8d, 0xa5, 0x28, 0xff, 0xff,
     1176        0xff, 0xf6, 0x05, 0x95, 0x2d, 0x00, 0x00, 0x80,
     1177        0x74, 0x16, 0x50, 0x66, 0x68, 0x51, 0x30, 0x8b,
     1178        0x45, 0x08, 0x50, 0x6a, 0x0c, 0x6a, 0x06, 0xe8
     1179    };
     1180    char ach_IOSftTransPath[] = {
     1181        0x55, 0x8b, 0xec, 0x8d, 0xa5, 0xd8, 0xfd, 0xff,
     1182        0xff, 0x53, 0x56, 0x57, 0x1e, 0x06, 0xa1, 0xa4,
     1183        0x0a, 0x00, 0x00, 0x66, 0x8d, 0x9d, 0xe2, 0xfe,
     1184        0xff, 0xff, 0x66, 0x89, 0x98, 0xf6, 0x01, 0x00
     1185    };
     1186    char ach_IOSftReadAt[] = {
     1187        0xb8, 0xc4, 0x68, 0x14, 0x00, 0xeb, 0x05, 0xb8,
     1188        0xcc, 0x68, 0x14, 0x00, 0x55, 0x8b, 0xec, 0x8d,
     1189        0xa5, 0x20, 0xff, 0xff, 0xff, 0xf6, 0x05, 0x95,
     1190        0x2d, 0x00, 0x00, 0x80, 0x74, 0x28, 0x50, 0x66
     1191    };
     1192    char ach_IOSftWriteAt[] = {
     1193        0xb8, 0xcc, 0x68, 0x14, 0x00, 0x55, 0x8b, 0xec,
     1194        0x8d, 0xa5, 0x20, 0xff, 0xff, 0xff, 0xf6, 0x05,
     1195        0x95, 0x2d, 0x00, 0x00, 0x80, 0x74, 0x28, 0x50,
     1196        0x66, 0x68, 0x52, 0x30, 0x8b, 0x45, 0x08, 0x25
     1197    };
     1198    char ach_SftFileSize[] = {
     1199        0x55, 0x8b, 0xec, 0x8d, 0xa5, 0x28, 0xff, 0xff,
     1200        0xff, 0x57, 0x56, 0x53, 0xc6, 0x85, 0x2b, 0xff,
     1201        0xff, 0xff, 0x00, 0x8b, 0x35, 0xa4, 0x0a, 0x00,
     1202        0x00, 0xf6, 0x46, 0x04, 0x01, 0x74, 0x0a, 0x80
     1203    };
     1204    char ach_VMAllocMem[] = {
     1205        0xa1, 0xe8, 0xcf, 0x0d, 0x00, 0x55, 0x8b, 0xec,
     1206        0x83, 0xec, 0x44, 0x53, 0x57, 0xf6, 0x40, 0x04,
     1207        0x80, 0x56, 0x0f, 0x84, 0x34, 0x01, 0x00, 0x00,
     1208        0xf6, 0x00, 0x40, 0x74, 0x44, 0xa1, 0xcc, 0x02
     1209    };
     1210    char ach_VMGetOwner[] = {
     1211        0x55, 0x8b, 0xec, 0x83, 0xec, 0x30, 0x57, 0x66,
     1212        0x8b, 0x4d, 0x08, 0x66, 0x89, 0x4d, 0xd8, 0xf6,
     1213        0xc1, 0x04, 0x75, 0x39, 0x80, 0x3d, 0x40, 0x8c,
     1214        0x00, 0x00, 0x00, 0x74, 0x07, 0xa1, 0xac, 0x0a
     1215    };
     1216    char achg_tkExecPgm[] = {
     1217        0x55, 0x8b, 0xec, 0x8d, 0x65, 0xa4, 0x66, 0x89,
     1218        0x5d, 0xf4, 0x66, 0x8c, 0x45, 0xf6, 0x66, 0x89,
     1219        0x55, 0xfc, 0x66, 0x8c, 0x5d, 0xfe, 0x66, 0x89,
     1220        0x75, 0xf0, 0x66, 0x89, 0x7d, 0xf2, 0xc7, 0x45
     1221    };
     1222    char achf_FuStrLenZ[] = {
     1223        0x6a, 0x02, 0x52, 0x66, 0x55, 0x0f, 0xa8, 0x68,
     1224        0x0c, 0x00, 0x0f, 0xa9, 0x65, 0x67, 0x66, 0x8b,
     1225        0x2d, 0xa8, 0x0a, 0x00, 0x00, 0x65, 0x67, 0xff,
     1226        0xb5, 0xb4, 0x1f, 0x00, 0x00, 0x65, 0x67, 0x66
     1227    };
     1228    char achf_FuStrLen[] = {
     1229        0x6a, 0x02, 0x52, 0x66, 0x55, 0x0f, 0xa8, 0x68,
     1230        0x0c, 0x00, 0x0f, 0xa9, 0x65, 0x67, 0x66, 0x8b,
     1231        0x2d, 0xa8, 0x0a, 0x00, 0x00, 0x65, 0x67, 0xff,
     1232        0xb5, 0xb4, 0x1f, 0x00, 0x00, 0x65, 0x67, 0x66
     1233    };
     1234    char achf_FuBuff[] = {
     1235        0x6a, 0x02, 0x52, 0x66, 0x55, 0x0f, 0xa8, 0x68,
     1236        0x0c, 0x00, 0x0f, 0xa9, 0x65, 0x67, 0x66, 0x8b,
     1237        0x2d, 0xa8, 0x0a, 0x00, 0x00, 0x65, 0x67, 0xff,
     1238        0xb5, 0xb4, 0x1f, 0x00, 0x00, 0x65, 0x67, 0x66
     1239    };
     1240
     1241
     1242    char *aProcs[] =
     1243    {
     1244        ach_ldrRead            ,
     1245        ach_ldrOpen            ,
     1246        ach_ldrClose           ,
     1247        ach_LDRQAppType        ,
     1248        ach_ldrEnum32bitRelRecs,
     1249        ach_IOSftOpen          ,
     1250        ach_IOSftClose         ,
     1251        ach_IOSftTransPath     ,
     1252        ach_IOSftReadAt        ,
     1253        ach_IOSftWriteAt       ,
     1254        ach_SftFileSize        ,
     1255        ach_VMAllocMem         ,
     1256        ach_VMGetOwner         ,
     1257        achg_tkExecPgm         ,
     1258        achf_FuStrLenZ         ,
     1259        achf_FuStrLen          ,
     1260        achf_FuBuff            ,
     1261        NULL
     1262    };
     1263    int i;
     1264
     1265    /* loop thru procs */
     1266    for (i = 0; aProcs[i] != NULL; i++)
     1267    {
     1268        unsigned cb;
     1269        printf("Proc.no.%i\n", i);
     1270        if (i < 14 )
     1271            cb = interpretFunctionProlog32(aProcs[i], i < 5 || i == 13);
     1272        else
     1273            cb = interpretFunctionProlog16(aProcs[i], FALSE);
     1274        printf(" cb=%d\n\n", cb);
     1275    }
     1276}
     1277#endif
Note: See TracChangeset for help on using the changeset viewer.