Changeset 13416

Timestamp:

Feb 21, 2000, 5:45:47 AM (25 years ago)

Author:

bird

Message:

ProbKrnl and code for importing krnl symbols has been enhanched.
Now we'll lock 32-bit segments into memory too.
And some other fixes...

Location:

tags/trunk/src/win32k

Files:

• dev16/d16init.c (modified) (8 diffs)
• dev16/d16strat.c (modified) (3 diffs)
• dev16/probkrnl.c (modified) (9 diffs)
• dev32/d32init.c (modified) (26 diffs)
• dev32/devfirst.asm (modified) (2 diffs)
• dev32/devlast.asm (modified) (2 diffs)
• include/dev16.h (modified) (2 diffs)
• include/dev32.h (modified) (2 diffs)
• include/devSegDf.inc (modified) (3 diffs)
• include/options.h (modified) (2 diffs)
• ldr/calltab.asm (modified) (2 diffs)
• ldr/myldrOpen.cpp (modified) (12 diffs)
• win32k.def (modified) (2 diffs)

tags/trunk/src/win32k/dev16/d16init.c ¶

@@ -1 @@
-/* $Id: d16init.c,v 1.4 1999-11-10 01:45:30 bird Exp $
+/* $Id: d16init.c,v 1.5 2000-02-21 04:45:45 bird Exp $
  *
  * d16init - init routines for both drivers.
@@ -48 +48 @@
  * @remark    pRpIn and pRpOut points to the same memory.
  */
-USHORT _near dev0Init(PRPINITIN pRpIn, PRPINITOUT pRpOut)
+USHORT NEAR dev0Init(PRPINITIN pRpIn, PRPINITOUT pRpOut)
 {
     Device_Help = pRpIn->DevHlpEP;
@@ -70 +70 @@
  * @remark    pRpIn and pRpOut points to the same memory.
  */
-USHORT _near dev1Init(PRPINITIN pRpIn, PRPINITOUT pRpOut)
+USHORT NEAR dev1Init(PRPINITIN pRpIn, PRPINITOUT pRpOut)
 {
     APIRET          rc;
@@ -103 +103 @@
             }
             else
-                npszErrMsg = "DosDevIOCtl failed.\n\r";
+            {
+                APIRET rc2 = rc;
+                NPSZ   npsz;
+                            /*0123456789012345678901234567890 1*/
+                npszErrMsg = "DosDevIOCtl failed. rc=       \n\r";
+
+                npsz  = &npszErrMsg[29];
+                do
+                {
+                    *npsz-- = (char)((rc2 % 10) + '0');
+                    rc2 = rc2/10;
+                } while (rc2 > 0);
+            }
+
             DosClose(hDev0);
         }
@@ -133 +146 @@
  * @param     pRp  Generic IO Control request packet.
  */
-USHORT R0Init16(PRP_GENIOCTL pRp)
+USHORT NEAR R0Init16(PRP_GENIOCTL pRp)
 {
     USHORT usRc = STATUS_DONE;
     APIRET rc;
-    PDOSTABLE  pDT;
-    PDOSTABLE2 pDT2;
 
     /* First we're to get the DosTable2 stuff. */
-    rc = DevHelp_GetDOSVar(9, 0, &pDT);
+    rc = initGetDosTableData();
     if (rc == NO_ERROR)
     {
@@ -150 +161 @@
         ULONG ulLinData;
 
-        pDT2 = (PDOSTABLE2)((char FAR *)pDT + pDT->cul*4 + 1);
-        TKSSBase16 = (ULONG)pDT2->pTKSSBase;
-        R0FlatCS16 = (USHORT)pDT2->R0FlatCS;
-        R0FlatDS16 = (USHORT)pDT2->R0FlatDS;
         if (!DevHelp_VirtToLin(SELECTOROF(pRp->ParmPacket), OFFSETOF(pRp->ParmPacket), &ulLinParm)
             &&
@@ -159 +166 @@
             )
         {
-            if (!(rc = DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE | VMDHL_VERIFY,
+            if (!(rc = DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE,
                                 ulLinParm, sizeof(D16R0INITPARAM),
                                 (LIN)~0UL, SSToDS_16(&hLockParm[0]), &cPages))
                 &&
-                !DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE | VMDHL_VERIFY,
+                !DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE,
                                 ulLinData, sizeof(D16R0INITDATA),
                                 (LIN)~0UL, SSToDS_16(&hLockData[0]), &cPages)
@@ -215 +222 @@
     return usRc;
 }
+
+
+
+/**
+ * Gets the data we need from the DosTables.
+ * This data is TKSSBase16, R0FlatCS16 and R0FlatDS16.
+ * @returns   Same as DevHelp_GetDosVar.
+ * @status    completely implemented.
+ * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ * @remark    If you are not sure if TKSSBase16 is set or not, call this.
+ *            After R0Init16 is called TKSSBase16 _is_ set.
+ *            IMPORTANT! This function must _not_ be called after the initiation of the second device driver!!!
+ */
+USHORT NEAR initGetDosTableData(void)
+{
+    APIRET     rc;
+    PDOSTABLE  pDT;
+    PDOSTABLE2 pDT2;
+
+    if (TKSSBase16 != 0)
+        return NO_ERROR;
+
+    /* First we're to get the DosTable2 stuff. */
+    rc = DevHelp_GetDOSVar(9, 0, &pDT);
+    if (rc == NO_ERROR)
+    {
+        pDT2 = (PDOSTABLE2)((char FAR *)pDT + pDT->cul*4 + 1);
+        TKSSBase16 = (ULONG)pDT2->pTKSSBase;
+        R0FlatCS16 = (USHORT)pDT2->R0FlatCS;
+        R0FlatDS16 = (USHORT)pDT2->R0FlatDS;
+    }
+    return rc;
+}

tags/trunk/src/win32k/dev16/d16strat.c ¶

@@ -1 @@
-/* $Id: d16strat.c,v 1.5 2000-02-20 04:27:22 bird Exp $
+/* $Id: d16strat.c,v 1.6 2000-02-21 04:45:45 bird Exp $
  *
  * d16strat.c - 16-bit strategy routine, device headers, device_helper (ptr)
@@ -145 +145 @@
             {
                 ULONG ulLin;
+                if (fInitTime && TKSSBase16 == 0)
+                    initGetDosTableData();
                 if (DevHelp_VirtToLin(SELECTOROF(pRp->DataPacket), OFFSETOF(pRp->DataPacket),
                                       &ulLin) != NO_ERROR)
@@ -153 +155 @@
             case D16_IOCTL_VERIFYPROCTAB:
                 if (fInitTime)
+                {
+                    if (TKSSBase16 == 0)
+                        initGetDosTableData();
                     return CallVerifyImportTab32();
+                }
                 break;
         }

tags/trunk/src/win32k/dev16/probkrnl.c ¶

@@ -1 @@
-/* $Id: probkrnl.c,v 1.12 2000-02-20 04:27:23 bird Exp $
+/* $Id: probkrnl.c,v 1.13 2000-02-21 04:45:45 bird Exp $
  *
  * Description:   Autoprobes the os2krnl file and os2krnl[*].sym files.
@@ -157 +157 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
+/* File an output replacements */
 static HFILE    fopen(const char * pszFilename, const char * pszIgnored);
 static int      fread(void * pvBuffer, USHORT cbBlock, USHORT cBlock,  HFILE hFile);
@@ -163 +164 @@
 static void     puts(char *psz);
 
+/* C-library replacements. */
 static void     kmemcpy(char *psz1, const char *psz2, int cch);
 static char *   kstrstr(const char *psz1, const char *psz2);
 static int      kstrcmp(const char *psz1, const char *psz2);
 static int      kstrncmp(const char *psz1, const char *psz2, int cch);
+static int      kstrnicmp(const char *psz1, const char *psz2, int cch);
 static int      kstrlen(const char *psz);
 static int      kargncpy(char *pszTarget, const char *pszArg, unsigned cchMaxlen);
 
+/* Workers */
 static int      VerifyPrologs(void);
 static int      ProbeSymFile(char *pszFilename);
@@ -177 +181 @@
 static int      GetKernelOTEs(void);
 
+/* Ouput */
 static void     ShowDecNumber(unsigned long ul);
 static void     ShowHexNumber(unsigned long ul);
@@ -338 +343 @@
 
 
-
 /**
  * kstrncmp - String 'n' compare.
@@ -360 +364 @@
 
 
+#if 0 /* not in use */
+/**
+ * kstrnicmp - String 'n' compare, case-insensitive.
+ * @returns   0 - equal else !0
+ * @param     p1  String 1
+ * @param     p2  String 2
+ * @param     len length
+ */
+static int      kstrnicmp(const char *psz1, const char *psz2, int cch)
+{
+    register char ch1, ch2;
+
+    do
+    {
+        ch1 = *psz1++;
+        if (ch1 >= 'A' && ch1 <= 'Z')
+            ch1 += 'a' - 'A';           /* to lower case */
+        ch2 = *psz2++;
+        if (ch2 >= 'A' && ch2 <= 'Z')
+            ch2 += 'a' - 'A';           /* to lower case */
+    } while (--cch > 0 && ch1 == ch2 && ch1 != '\0' && ch2 != '\0');
+
+    return ch1 - ch2;
+}
+#endif
+
+
 /**
  * kstrlen - String length.
@@ -431 +462 @@
 
 /*******************************************************************************
-*   Implementation Of The Important Function                                   *
+*   Implementation Of The Important Functions                                  *
 *******************************************************************************/
 
@@ -727 +758 @@
  * @param     filename   Filename of the OS/2 kernel.
  * @result    ulBuild is set.
+ * @remark    This step will be eliminated by searching thru the DOSGROUP datasegment
+ *            in the kernel memory. This segment have a string "Internal revision 9.034[smp|uni]"
+ *            This would be much faster than reading the kernel file. It will also give us a more precise
+ *            answer to the question! This is currently a TODO issue. !FIXME!
  */
 static int ReadOS2Krnl(char * pszFilename)
@@ -1117 +1152 @@
                     case 'S': /* Symbol file */
                         i++;
-                        i += kargncpy(szUsrSym, &pReqPack->InitArgs[i], sizeof(szUsrSym));
+                        if (pReqPack->InitArgs[i] == 'Y' || pReqPack->InitArgs[i] == 'y')
+                            i += kargncpy(szUsrSym, &pReqPack->InitArgs[i], sizeof(szUsrSym));
                         break;
 

tags/trunk/src/win32k/dev32/d32init.c ¶

@@ -1 @@
-/* $Id: d32init.c,v 1.12 2000-02-20 04:27:23 bird Exp $
+/* $Id: d32init.c,v 1.13 2000-02-21 04:45:46 bird Exp $
  *
  * d32init.c - 32-bits init routines.
@@ -12 +12 @@
 *   Defined Constants                                                          *
 *******************************************************************************/
-#define MAXSIZE_PROLOG 0x10             /* Note that this must be synced with */
+#define MAXSIZE_PROLOG 0x18             /* Note that this must be synced with */
                                         /* the one used in calltab.asm.       */
 #define static                          /* just to make all symbols visible in the kernel debugger.  */
@@ -32 +32 @@
 #include "dev1632.h"
 #include "dev32.h"
+#include "dev32hlp.h"
 #include "probkrnl.h"
 #include "log.h"
@@ -38 +39 @@
 #include "ldr.h"
 #include "ldrCalls.h"
-
+#include "macros.h"
+
+/*******************************************************************************
+*   Global Variables                                                           *
+*******************************************************************************/
+#ifdef DEBUG
+static char * apszPE[] = {"FLAGS_PE_NOT", "FLAGS_PE_PE2LX", "FLAGS_PE_PE", "FLAGS_PE_MIXED", "!invalid!"};
+static char * apszInfoLevel[] = {"INFOLEVEL_QUIET", "INFOLEVEL_ERROR", "INFOLEVEL_WARNING", "INFOLEVEL_INFO", "INFOLEVEL_INFOALL", "!invalid!"};
+#endif
 
 /*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
-static ULONG    readnum(const char *pszNum);
-static signed char interpretFunctionProlog32(char *pach, BOOL fOverload);
-static signed char interpretFunctionProlog16(char *pach, BOOL fOverload);
-static int      ImportTabInit(void);
+static ULONG        readnum(const char *pszNum);
+_Inline int         ModR_M_32bit(char bModRM);
+static int          interpretFunctionProlog32(char *pach, BOOL fOverload);
+static int          interpretFunctionProlog16(char *pach, BOOL fOverload);
+static int          ImportTabInit(void);
 
 
@@ -59 +69 @@
 /* extern(s) located in mytkExecPgm.asm  */
 extern char     mytkExecPgm;
-
+extern char     CODE32START;
+extern char     CODE32END;
+extern char     CONST32_ROEND;
+extern char     DATA16START;
+extern char     DATA16_CONSTEND;
 
 
@@ -81 +95 @@
     char   *pszTmp;
     ULONG   ul;
+    APIRET  rc;
+    LOCKHANDLE lhData16={0,0,0,0, 0,0,0,0, 0,0,0,0};
+    LOCKHANDLE lhData = {0,0,0,0, 0,0,0,0, 0,0,0,0};
+    LOCKHANDLE lhCode = {0,0,0,0, 0,0,0,0, 0,0,0,0};
 
     pulTKSSBase32 = (PULONG)_TKSSBase16;
@@ -258 +276 @@
 
     /* log option summary - FIXME */
-    kprintf(("Options - Summary\n"));
+    kprintf(("Options - Summary - Start\n"));
+    if (options.fQuiet)
+        kprintf(("\tQuiet init\n"));
+    else
+        kprintf(("\tVerbose init\n"));
+
+    if (options.fLogging)
+        kprintf(("\tlogging enabled\n"));
+    else
+        kprintf(("\tlogging disabled\n"));
+    kprintf(("\tCom port no.%d\n", options.usCom));
+
     kprintf(("\tKernel: ver%d.%d  build %d  type %s\n",
                 options.usVerMajor,
@@ -265 +294 @@
                 (options.fKernel & KF_SMP) ? "SMP" : "UNI"
               ));
-    kprintf(("\tCom port no.%d\n", options.usCom));
-    if (options.fQuiet)
-        kprintf(("\tQuiet init\n"));
-    else
-        kprintf(("\tVerbose init\n"));
-    if (options.fLogging)
-        kprintf(("\tlogging enabled\n"));
-    else
-        kprintf(("\tlogging disabled\n"));
+    kprintf(("\tfPE=%d (%s)\n", options.fPE, apszPE[MIN(options.fPE, 5)]));
+    kprintf(("\tulInfoLevel=%d (%s)\n", options.ulInfoLevel, apszInfoLevel[MIN(options.ulInfoLevel, 5)]));
+    kprintf(("\tfElf=%d\n", options.fElf));
+    kprintf(("\tfScript=%d\n", options.fScript));
+    kprintf(("\tfNoLoader=%d\n", options.fNoLoader));
+    kprintf(("\tcbSwpHeapInit=0x%08x  cbSwpHeapMax=0x%08x\n",
+             options.cbSwpHeapInit, options.cbSwpHeapMax));
+    kprintf(("\tcbResHeapInit=0x%08x  cbResHeapMax=0x%08x\n",
+             options.cbSwpHeapInit, options.cbSwpHeapMax));
+    kprintf(("Options - Summary - End\n"));
     /* end option summary */
 
@@ -294 +324 @@
         if (ImportTabInit() != NO_ERROR)
             return STATUS_DONE | STERR | ERROR_I24_QUIET_INIT_FAIL;
+
+    /*
+     * Lock the 32-bit objects/segments and 16-bit datasegment in memory
+     */
+    /* 32-bit code segment */
+    rc = D32Hlp_VMLock2(&CODE32START,
+                        ((unsigned)&CODE32END & ~0xFFF) - (unsigned)&CODE32START, /* Round down so we don't overlap with the next request. */
+                        VMDHL_LONG,
+                        SSToDS(&lhCode));
+    if (rc != NO_ERROR)
+        kprintf(("code segment lock failed with with rc=%d\n", rc));
+
+    /* 32-bit data segment */
+    rc = D32Hlp_VMLock2(callTab,
+                        &CONST32_ROEND - (char*)callTab,
+                        VMDHL_LONG | VMDHL_WRITE,
+                        SSToDS(&lhData));
+    if (rc != NO_ERROR)
+        kprintf(("data segment lock failed with with rc=%d\n", rc));
+
+    /* 16-bit data segment */
+    rc = D32Hlp_VMLock2(&DATA16START,
+                        &DATA16_CONSTEND - &DATA16START,
+                        VMDHL_LONG | VMDHL_WRITE,
+                        SSToDS(&lhData16));
+    if (rc != NO_ERROR)
+        kprintf(("data segment lock failed with with rc=%d\n", rc));
 
     return STATUS_DONE;
@@ -395 +452 @@
 
 
+
+/**
+ * Functions which cacluates the instructionsize given a ModR/M byte.
+ * @returns   Number of bytes to add to cb and pach.
+ * @param     bModRM  ModR/M byte.
+ * @status    completely implemented.
+ * @author    knut st. osmundsen (knut.stange.osmundsen@pmsc.no)
+ */
+_Inline int ModR_M_32bit(char bModRM)
+{
+    if ((bModRM & 0xc0) == 0x80  /* ex. mov ax,[ebp+11145543h] */
+        || ((bModRM & 0xc0) == 0 && (bModRM & 0x07) == 5)) /* ex. mov ebp,[0ff231234h] */
+    {   /* 32-bit displacement */
+        return 5;
+    }
+    else if ((bModRM & 0xc0) == 0x40) /* ex. mov ecx,[esi]+4fh */
+    {   /* 8-bit displacement */
+        return 2;
+    }
+    /* no displacement (only /r byte) */
+    return 1;
+}
+
+
+
+
+
 /**
  * 32-bit! Interpret function prolog to find where to jmp back.
@@ -404 +488 @@
  *                       FALSE: Function is to be imported.
  */
-static signed char interpretFunctionProlog32(char *pach, BOOL fOverload)
+static int interpretFunctionProlog32(char *pach, BOOL fOverload)
 {
-    int cb;
+    int cb = -3;
+
+    kprintf(("interpretFunctionProlog32(0x%08x, %d):\n"
+             "\t%02x %02x %02x %02x - %02x %02x %02x %02x\n"
+             "\t%02x %02x %02x %02x - %02x %02x %02x %02x\n",
+             pach, fOverload,
+             pach[0], pach[1], pach[2], pach[3], pach[4], pach[5], pach[6], pach[7],
+             pach[8], pach[9], pach[10],pach[11],pach[12],pach[13],pach[14],pach[15]));
 
     /*
@@ -416 +507 @@
      *     push ebp
      *     mov ecx, dword ptr [xxxxxxxx]
+     *
+     * These are allowed when not overloading:
+     *     mov eax, imm32
+     *     jmp short
+     *  or
+     *     mov eax, imm32
+     *     push ebp
      */
-
-    if (pach[0] == 0x55 && pach[1] == 0x8b)
+    if ((pach[0] == 0x55 && (pach[1] == 0x8b || pach[1] == 0xa1)) /* two first prologs */
+        ||
+        (pach[0] == 0xB8 && (pach[5] == 0xEB || pach[5] == 0x55) && !fOverload) /* two last prologs */
+        )
     {
-        if (pach[2] == 0xec)
-            cb = 3;
-        else
-            cb = 1;
-        while (cb < 5)
-        {
-            /*
-             * This is not at all very stable or correct - but it works
-             * for the current functions.
-             * There will never be any doubt when something goes wrong!
-             */
-            switch(pach[cb])
+        BOOL fForce;
+        cb = 0;
+        while (cb < 5 || fForce)                  /* 5 is the size of a jump instruction. */
+        {
+            int cb2;
+            fForce = FALSE;
+            switch (*pach)
             {
-                case 0x33: /* xor (ldrClose, ldrOpen) */
-                    cb +=2;
-                    break;
-                case 0x8b:
-                    if (pach[cb+1] == 0x0d)
-                        cb += 6;
+                /* simple one byte prefixes */
+                case 0x2e:              /* cs segment override */
+                case 0x36:              /* ss segment override */
+                case 0x3e:              /* ds segment override */
+                case 0x26:              /* es segment override */
+                case 0x64:              /* fs segment override */
+                case 0x65:              /* gs segment override */
+                    fForce = TRUE;
+                    break;
+
+                /* simple one byte instructions */
+                case 0x50:              /* push ax */
+                case 0x51:              /* push cx */
+                case 0x52:              /* push dx */
+                case 0x53:              /* push bx */
+                case 0x54:              /* push sp */
+                case 0x55:              /* push bp */
+                case 0x56:              /* push si */
+                case 0x57:              /* push di */
+                    break;
+
+                /* simple two byte instructions */
+                case 0xb0:              /* mov al, imm8 */
+                case 0xb1:              /* mov cl, imm8 */
+                case 0xb2:              /* mov dl, imm8 */
+                case 0xb3:              /* mov bl, imm8 */
+                case 0xb4:              /* mov ah, imm8 */
+                case 0xb5:              /* mov ch, imm8 */
+                case 0xb6:              /* mov dh, imm8 */
+                case 0xb7:              /* mov bh, imm8 */
+                case 0x2c:              /* sub al, imm8 */
+                case 0x34:              /* xor al, imm8 */
+                case 0x3c:              /* cmp al, imm8 */
+                case 0x6a:              /* push <byte> */
+                    pach++;
+                    cb++;
+                    break;
+
+                /* simple five byte instructions */
+                case 0xb8:              /* mov eax, imm32 */
+                case 0xb9:              /* mov ecx, imm32 */
+                case 0xba:              /* mov edx, imm32 */
+                case 0xbb:              /* mov ebx, imm32 */
+                case 0xbc:              /* mov esx, imm32 */
+                case 0xbd:              /* mov ebx, imm32 */
+                case 0xbe:              /* mov esi, imm32 */
+                case 0xbf:              /* mov edi, imm32 */
+                case 0x2d:              /* sub eax, imm32 */
+                case 0x35:              /* xor eax, imm32 */
+                case 0x3d:              /* cmp eax, imm32 */
+                case 0x68:              /* push <dword> */
+                    pach += 4;
+                    cb += 4;
+                    break;
+
+                /* complex sized instructions -  "/r" */
+                case 0x30:              /* xor r/m8,  r8 */
+                case 0x31:              /* xor r/m32, r32 */
+                case 0x32:              /* xor r8,  r/m8 */
+                case 0x33:              /* xor r32, r/m32 */
+                case 0x38:              /* cmp r/m8, r8 */
+                case 0x39:              /* cmp r/m32, r32 */
+                case 0x3a:              /* cmp r8, r/m8 */
+                case 0x3b:              /* cmp r32, r/m32 */
+                case 0x28:              /* sub r/m8, r8 */
+                case 0x29:              /* sub r/m32, r32 */
+                case 0x2a:              /* sub r8, r/m8 */
+                case 0x2b:              /* sub r32, r/m32 */
+                case 0x8b:              /* mov /r */
+                case 0x8d:              /* lea /r */
+                    if ((pach[1] & 0x7) == 4 && (pach[1] & 0xc0) != 0xc0) /* invalid instruction!?! */
+                        return -1;
+                    cb += cb2 = ModR_M_32bit(pach[1]);
+                    pach += cb2;
+                    break;
+
+                /* complex sized instruction - "/5 ib" */
+                case 0x80:              /* 5: sub r/m8, imm8  7: cmp r/m8, imm8 */
+                case 0x83:              /* 5: sub r/m32, imm8 7: cmp r/m32, imm8 */
+                    if ((pach[1] & 0x38) == (5<<3)
+                        || (pach[1] & 0x38) == (7<<3)
+                        )
+                    {
+                        cb += cb2 = 1 + ModR_M_32bit(pach[1]); /* 1 is the size of the imm8 */
+                        pach += cb2;
+                    }
                     else
-                        cb += 2; /*????!*/
-                    break;
-                case 0x8d: /* lea (ldrRead) */
-                    cb += 3;
-                    break;
-                case 0x83: /* sub (LDRQAppType) */
-                    cb += 3;
-                    break;
+                    {
+                        kprintf(("interpretFunctionProlog32: unknown instruction (-3) 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
+                        return -3;
+                    }
+                    break;
+
+                /* complex sized instruction - "/digit id" */
+                case 0x81:              /* sub r/m32, imm32 + more instructions! */
+                    if ((pach[1] & 0x38) == (5<<3)       /* sub r/m32, imm32  */
+                        || (pach[1] & 0x38) == (7<<3)    /* cmp r/m32, imm32  */
+                        )
+                    {
+                        cb += cb2 = 4 + ModR_M_32bit(pach[1]); /* 4 is the size of the imm32 */
+                        pach += cb2;
+                    }
+                    else
+                    {
+                        kprintf(("interpretFunctionProlog32: unknown instruction (-2) 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
+                        return -2;
+                    }
+                    break;
+
                 default:
-                    kprintf(("interpretFunctionProlog: unknown instruction 0x%x\n", pach[cb]));
+                    kprintf(("interpretFunctionProlog32: unknown instruction 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
                     return 0;
             }
-        }
-    }
-    else if (pach[0] == 0x55 && pach[1] == 0xa1) /* ldrEnum32bitRelRecs on WS4eB */
-    {
-        cb = 1 + 5;
+            pach++;
+            cb++;
+        }
     }
     else
     {
-        /* special case for IOSftReadAt and IOSftWriteAt */
-        if (fOverload == FALSE && pach[0] == 0xB8 && (pach[5] == 0xEB || pach[5] == 0x55))
-            cb = 5;
-        else
-            cb = 0;
+        kprintf(("interpretFunctionProlog32: unknown prolog start. 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
+        cb = 0;
     }
-
-    return (signed char)cb;
+    return cb;
 }
 
@@ -480 +663 @@
  *                       FALSE: Function is to be imported.
  */
-static signed char interpretFunctionProlog16(char *pach, BOOL fOverload)
+static int interpretFunctionProlog16(char *pach, BOOL fOverload)
 {
-    int cb;
-
+    int cb = -7;
+
+    kprintf(("interpretFunctionProlog16(0x%08x, %d):\n"
+             "\t%02x %02x %02x %02x - %02x %02x %02x %02x\n"
+             "\t%02x %02x %02x %02x - %02x %02x %02x %02x\n",
+             pach, fOverload,
+             pach[0], pach[1], pach[2], pach[3], pach[4], pach[5], pach[6], pach[7],
+             pach[8], pach[9], pach[10],pach[11],pach[12],pach[13],pach[14],pach[15]));
     /*
      * Check for the well known prolog (the only that is supported now)
@@ -493 +682 @@
         BOOL fForce;
         cb = 0;
-        while (cb < 8 || fForce)
+        while (cb < 8 || fForce)        /* 8 is the size of a 66h prefixed far jump instruction. */
         {
             fForce = FALSE;
@@ -528 +717 @@
 
                 case 0x8b:              /* mov /r */
-                    if ((pach[1] & 0xc0) == 10  /* ex. mov ax,bp+1114h */
-                        || ((pach[1] & 0xc0) == 0 && (pach[1] & 0xc0) == 6)) /* ex. mov bp,0ff23h */
+                    if ((pach[1] & 0xc0) == 0x80  /* ex. mov ax,bp+1114h */
+                        || ((pach[1] & 0xc0) == 0 && (pach[1] & 0x7) == 6)) /* ex. mov bp,0ff23h */
                     {   /* 16-bit displacement */
                         pach += 3;
@@ -548 +737 @@
 
                 default:
-                    kprintf(("interpretFunctionProlog: unknown instruction 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
+                    kprintf(("interpretFunctionProlog16: unknown instruction 0x%x 0x%x 0x%x\n", pach[0], pach[1], pach[2]));
                     return 0;
             }
@@ -557 +746 @@
 
     fOverload = fOverload;
-    return (signed char)cb;
+    return cb;
 }
+
 
 
@@ -601 +791 @@
                  * Verify known function prolog.
                  */
-                if (_aImportTab[i].fType & EPT_32BIT)
+                if (EPT32BitEntry(_aImportTab[i]))
                 {
                     cb = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, _aImportTab[i].fType == EPT_PROC32);
-                    cbmin = 5;
+                    cbmin = 5; /* Size of the jump instruction */
                 }
                 else
                 {
                     cb = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, _aImportTab[i].fType == EPT_PROC16);
-                    cbmin = 8;
+                    cbmin = 7; /* Size of the far jump instruction */
                 }
 
@@ -628 +818 @@
             default:
                 kprintf(("VerifyImportTab32: only EPT_PROC is implemented\n",i));
+                Int3(); /* temporary fix! */
                 return STATUS_DONE | STERR | 4;
         }
@@ -665 +856 @@
     int i;
     int cb;
-
+    int cbmin;
 
     /*
@@ -676 +867 @@
             continue;
 
-        if (_aImportTab[i].fType & EPT_32BIT)
+        if (EPT32BitEntry(_aImportTab[i]))
+        {
             cb = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, _aImportTab[i].fType == EPT_PROC32);
+            cbmin = 5; /* Size of the jump instruction */
+        }
         else
+        {
             cb = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, _aImportTab[i].fType == EPT_PROC16);
-        if (cb <= 0 || cb + 5 >= MAXSIZE_PROLOG)
-        {
-            kprintf(("ImportTabInit: verify failed for procedure no.%d, cb=%d\n", i, cb));
+            cbmin = 7; /* Size of the far jump instruction */
+        }
+        if (cb <= 0 || cb + cbmin >= MAXSIZE_PROLOG)
+        {
+            kprintf(("ImportTabInit: Verify failed for procedure no.%d, cb=%d\n", i, cb));
             return 1;
         }
@@ -702 +899 @@
             case EPT_PROC32:
             {
-                cb = _aImportTab[i].cbProlog = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, TRUE);
-                if (cb > 0 && cb + 5 < MAXSIZE_PROLOG)
-                {
+                cb = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, TRUE);
+                _aImportTab[i].cbProlog = (char)cb;
+                if (cb >= 5 && cb + 5 < MAXSIZE_PROLOG) /* 5(1st): size of jump instruction in the function prolog which jumps to my overloading function */
+                {                                       /* 5(2nd): size of jump instruction which jumps back to the original function after executing the prolog copied to the callTab entry for this function. */
                     /*
                      * Copy function prolog which will be overwritten by the jmp to calltabl.
@@ -743 +941 @@
                 Int3();
 
-                cb = _aImportTab[i].cbProlog = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, TRUE);
-                if (cb > 0 && cb + 8 < MAXSIZE_PROLOG) /* a 16:32 jump must be prefixed with 66h in a 16-bit segment */
-                {
+                cb = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, TRUE);
+                _aImportTab[i].cbProlog = (char)cb;
+                if (cb >= 8 && cb + 7 < MAXSIZE_PROLOG) /* 8: size of a 16:32 jump which jumps to my overloading function (prefixed with 66h in a 16-bit segment) */
+                {                                       /* 7: size of a 16:32 jump which is added to the call tab */
                     /*
                      * Copy function prolog which is to be overwritten.
@@ -784 +983 @@
             case EPT_PROCIMPORT32:
             {
-                cb = _aImportTab[i].cbProlog = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, FALSE);
-                if (cb > 0 && cb + 5 < MAXSIZE_PROLOG)
+                cb = interpretFunctionProlog32((char*)_aImportTab[i].ulAddress, FALSE);
+                _aImportTab[i].cbProlog = (char)cb;
+                if (cb > 0) /* Since no prolog part is copied to the function table, it's ok as long as the prolog has been recognzied. */
                 {
                     /*
@@ -811 +1011 @@
             case EPT_PROCIMPORT16:
             {
-                cb = _aImportTab[i].cbProlog = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, FALSE);
-                if (cb > 0 && cb + 8 < MAXSIZE_PROLOG)
+                cb = interpretFunctionProlog16((char*)_aImportTab[i].ulAddress, FALSE);
+                _aImportTab[i].cbProlog = (char)cb;
+                if (cb > 0) /* Since no prolog part is copied to the function table, it's ok as long as the prolog has been recognzied. */
                 {
                     /*
@@ -842 +1043 @@
             case EPT_VARIMPORT32:
             case EPT_VARIMPORT16:
+                _aImportTab[i].cbProlog = (char)0;
                 *(unsigned long*)(void*)&callTab[i][0] = _aImportTab[i].ulAddress;
                 *(unsigned long*)(void*)&callTab[i][4] = _aImportTab[i].offObject;

tags/trunk/src/win32k/dev32/devfirst.asm ¶

@@ -1 @@
-; $Id: devfirst.asm,v 1.3 2000-02-15 23:39:19 bird Exp $
+; $Id: devfirst.asm,v 1.4 2000-02-21 04:45:46 bird Exp $
 ;
 ; DevFirst - entrypoint and segment definitions
@@ -239 +239 @@
 CONST32_ROSTART label byte
 CONST32_RO ends
+
+_VFT segment
+_VFTSTART LABEL BYTE
+_VFT ends
+
+EH_DATA segment
+EH_DATASTART LABEL BYTE
+EH_DATA ends
+
 END
 

tags/trunk/src/win32k/dev32/devlast.asm ¶

@@ -1 @@
-; $Id: devlast.asm,v 1.3 2000-02-20 04:27:23 bird Exp $
+; $Id: devlast.asm,v 1.4 2000-02-21 04:45:46 bird Exp $
 ;
 ; DevLast - the object file termintating the resident part of the objects.
@@ -105 +105 @@
 
 CONST32_RO segment
-CONST32_ROEND db ?
+CONST32_ROEND LABEL BYTE
 CONST32_RO ends
+
+_VFT segment
+_VFTEND LABEL BYTE
+_VFT ends
+
+EH_DATA segment
+EH_DATAEND LABEL BYTE
+EH_DATA ends
+
 END
 

tags/trunk/src/win32k/include/dev16.h ¶

@@ -1 @@
-/* $Id: dev16.h,v 1.6 2000-02-20 04:27:23 bird Exp $
+/* $Id: dev16.h,v 1.7 2000-02-21 04:45:46 bird Exp $
  * dev16 - 16-bit specific. Should not be used in 32-bit C/C++.
  *
@@ -105 +105 @@
 USHORT NEAR dev1Init(PRPINITIN pRpIn, PRPINITOUT pRpOut);
 USHORT NEAR R0Init16(PRP_GENIOCTL pRp);
+USHORT NEAR initGetDosTableData(void);
 
 

tags/trunk/src/win32k/include/dev32.h ¶

@@ -1 @@
-/* $Id: dev32.h,v 1.6 2000-02-20 04:27:23 bird Exp $
+/* $Id: dev32.h,v 1.7 2000-02-21 04:45:46 bird Exp $
  *
  * dev32 - header file for 32-bit part of the driver.
@@ -82 +82 @@
  * variable into an function call; like the addToModule calls.
  *
- * @returns    32-bit FLAT stack pointer.
+ * Warning - At init-time you have ot make sure that the pulTKSSBase32 pointer is set!
+ *
+ * @returns    32-bit FLAT pointer.
  */
 #ifdef RING0

tags/trunk/src/win32k/include/devSegDf.inc ¶

@@ -1 @@
-; $Id: devSegDf.inc,v 1.3 1999-11-10 01:45:32 bird Exp $
+; $Id: devSegDf.inc,v 1.4 2000-02-21 04:45:46 bird Exp $
 ;
 ; Segment definitions for win32k.sys.
@@ -20 +20 @@
 DATA16_GROUP    group DATA16, DATA16_CONST, DATA16_BSS
 
+
 CODE16 segment word public 'CODE' use16
 CODE16 ends
+
 
 CODE32 segment dword public 'CODE' use32
 CODE32 ends
 
+EH_CODE segment dword public 'CODE' use32
+EH_CODE ends
+
 CALLTAB segment dword public 'DATA' use32
 CALLTAB ends
 
-DGROUP group BSS32, DATA32
+
+;DGROUP group BSS32, DATA32
+DGROUP group BSS32, DATA32, CONST32_RO, _VFT, EH_DATA, CALLTAB
 
 DATA32  segment dword public 'DATA' use32
@@ -40 +47 @@
 BSS32 ends
 
+
+;CONSTGROUP group CONST32_RO, _VFT, EH_DATA
+
 CONST32_RO segment dword public 'CONST' use32
 CONST32_RO ends
 
+_VFT segment dword public 'CONST' use32
+_VFT ends
+
+EH_DATA segment byte public 'CONST' use32
+EH_DATA ends
+

tags/trunk/src/win32k/include/options.h ¶

@@ -1 @@
-/* $Id: options.h,v 1.6 2000-01-24 18:18:59 bird Exp $
+/* $Id: options.h,v 1.7 2000-02-21 04:45:47 bird Exp $
  *
  * Options.
@@ -44 +44 @@
             o.usCom         = OUTPUT_COM2;          \
             o.fLogging      = FALSE;                \
+//            o.fLogging      = TRUE;                 \
             o.fKernel       = KF_UNI;               \
             o.ulBuild       = ~0UL;                 \

tags/trunk/src/win32k/ldr/calltab.asm ¶

@@ -1 @@
-; $Id: calltab.asm,v 1.8 2000-02-20 04:27:24 bird Exp $
+; $Id: calltab.asm,v 1.9 2000-02-21 04:45:47 bird Exp $
 ;
 ; callTab - Call back again table - table with entry for each function which is overrided.
@@ -42 +42 @@
 ; Constants
 ;
-MAXSIZE_PROLOG EQU 10h
+MAXSIZE_PROLOG EQU 18h
 
 

tags/trunk/src/win32k/ldr/myldrOpen.cpp ¶

@@ -1 @@
-/* $Id: myldrOpen.cpp,v 1.7 2000-02-19 08:40:30 bird Exp $
+/* $Id: myldrOpen.cpp,v 1.8 2000-02-21 04:45:47 bird Exp $
  *
  * myldrOpen - ldrOpen.
@@ -130 +130 @@
                 if (options.fPE == FLAGS_PE_NOT)
                 {
-                    free(pszBuffer);
+                    rfree(pszBuffer);
                     return NO_ERROR;
                 }
@@ -208 +208 @@
                             rc = ldrOpen(phFile, "pe.exe", param3);  /* path....! problems! */
                             kprintf(("ldrOpen: pe.exe - open returned with rc = %d\n", rc));
-                            free(pszBuffer);
+                            rfree(pszBuffer);
                             return rc;
                         }
                     }
                 }
-                free(pszBuffer);
+                rfree(pszBuffer);
                 return NO_ERROR;
             }
@@ -231 +231 @@
                      * Do nothing more yet. NEED AN ELF LOADER!!!
                      */
-                    free(pszBuffer);
+                    rfree(pszBuffer);
                     return NO_ERROR;
                 }
@@ -273 +273 @@
                 {
                     char *pszStart = pach+2;
+                    kprintf(("ldrOpen: scrtip debug 1\n"));
 
                     /* Make sure we don't read to much... */
@@ -283 +284 @@
                     while (*pszStart != '\0' && (*pszStart == ' ' || *pszStart == '\t'))
                         pszStart++;
+                    kprintf(("ldrOpen: scrtip debug 2\n"));
 
                     /* anything left on the line? */
@@ -295 +297 @@
                          */
                         pszEnd = pszStart;
+                        kprintf(("ldrOpen: scrtip debug 3\n"));
                         //pszFirstArg = NULL;
                         while (*pszEnd != '\0' && *pszEnd != '\r' && *pszEnd != '\n')
@@ -314 +317 @@
                         }
                         *pszEnd = '\0';
+                        kprintf(("ldrOpen: scrtip debug 4\n"));
 
                         /*
@@ -319 +323 @@
                          */
                         pBuffer = QueryBufferPointerFromFilename(pszFilename);
+                        kprintf(("ldrOpen: scrtip debug 5\n"));
                         if (pBuffer != NULL)
                         {
                             unsigned cchArguments = getArgsLength(pBuffer->achArgs);
                             kprintf(("ldrOpen: debug1\n"));
+
+                            kprintf(("ldrOpen: scrtip debug 6\n"));
 
                             /*
@@ -329 +336 @@
                             if (cchArguments + cchToAdd < sizeof(pBuffer->achArgs))
                             {
-                                kprintf(("ldrOpen: debug2\n"));
+                                kprintf(("ldrOpen: scrtip debug 7\n"));
                                 /*
                                  * Open the interpreter.
@@ -337 +344 @@
                                 if (rc == NO_ERROR)
                                 {
-                                    kprintf(("ldrOpen: debug3\n"));
+                                    kprintf(("ldrOpen: scritp debug 8\n"));
                                     /* Make space for the addition arguments. */
                                     memmove(&pBuffer->achArgs[cchToAdd], &pBuffer->achArgs[0], cchArguments);
                                     memcpy(&pBuffer->achArgs[0], pszBuffer, cchToAdd);
-                                    kprintf(("ldrOpen: debug4\n"));
+                                    kprintf(("ldrOpen: scrtip debug 9\n"));
                                 }
                                 else
@@ -375 +382 @@
             rc = NO_ERROR;
         }
-        free(pszBuffer);
+        rfree(pszBuffer);
     }
     return rc;

tags/trunk/src/win32k/win32k.def ¶

@@ -1 +1 @@
 ;******************************************************************************
-; Copyright 1998 knut st. osmundsen
+; Copyright 1998-2000 knut st. osmundsen
 ; Definition file for Win32k
 ; Project Odin Software License can be found in LICENSE.TXT
 ;******************************************************************************
-PHYSICAL DEVICE WIN32K
-DESCRIPTION "$@#knut st. osmundsen:v0.5.0alpha#@Win32k - Odin32, Ring-0 part - Copyright (c) 1998-1999 knut st. osmundsen"
+PHYSICAL DEVICE Grace
+DESCRIPTION "$@#knut st. osmundsen:v0.5.0alpha#@Grace - Odin32 and OS2NIX Ring-0 part - Copyright (c) 1998-2000 knut st. osmundsen"
 
 CODE PRELOAD EXECUTEREAD
@@ -17 +17 @@
     CODE32          class 'CODE'
     CALLTAB         class 'DATA'
-;    CALLTAB         class 'CODE' WRITABLE
     DATA32          class 'DATA'
     c_common        class 'DATA'
     BSS32           class 'BSS'
+    _VFT            class 'CONST'
     CONST32_RO      class 'CONST'
 
-