Merge trunk head (r43756)
authorTimo Kreuzer <timo.kreuzer@reactos.org>
Sun, 25 Oct 2009 22:13:11 +0000 (22:13 +0000)
committerTimo Kreuzer <timo.kreuzer@reactos.org>
Sun, 25 Oct 2009 22:13:11 +0000 (22:13 +0000)
svn path=/branches/ros-amd64-bringup/; revision=43759

38 files changed:
1  2  3 
reactos/base/applications/network/network.rbuild
reactos/dll/ntdll/rtl/libsupp.c
reactos/dll/win32/kernel32/except/except.c
reactos/dll/win32/mmdrv/mmdrv.h
reactos/dll/win32/wdmaud.drv/wdmaud.c
reactos/dll/win32/winmm/driver.c
reactos/dll/win32/winmm/mci.c
reactos/dll/win32/winmm/winmm.c
reactos/drivers/network/dd/ne2000/include/ne2000.h
reactos/drivers/network/dd/ne2000/ne2000/8390.c
reactos/drivers/network/dd/pcnet/pcnet.c
reactos/hal/halx86/mp/apic.c
reactos/include/ddk/winddk.h
reactos/include/ndk/i386/ketypes.h
reactos/include/psdk/basetsd.h
reactos/include/psdk/mmddk.h
reactos/include/psdk/mmsystem.h
reactos/include/psdk/wincrypt.h
reactos/include/psdk/winuser.h
reactos/include/reactos/windbgkd.h
reactos/lib/rtl/rtl.rbuild
reactos/lib/rtl/rtlp.h
reactos/ntoskrnl/config/cmkcbncb.c
reactos/ntoskrnl/config/cmsysini.c
reactos/ntoskrnl/ex/init.c
reactos/ntoskrnl/include/internal/ke.h
reactos/ntoskrnl/include/internal/mm.h
reactos/ntoskrnl/io/iomgr/irp.c
reactos/ntoskrnl/kd/kdmain.c
reactos/ntoskrnl/kd64/amd64/kdsup.c
reactos/ntoskrnl/kd64/kdapi.c
reactos/ntoskrnl/kd64/kdinit.c
reactos/ntoskrnl/ke/bug.c
reactos/ntoskrnl/mm/ARM3/contmem.c
reactos/ntoskrnl/mm/ARM3/iosup.c
reactos/ntoskrnl/mm/ARM3/mdlsup.c
reactos/ntoskrnl/mm/sysldr.c
reactos/ntoskrnl/rtl/libsupp.c

Simple merge
Simple merge
Simple merge
@@@@ -166,18 -166,18 -204,27 +204,27 @@@@ static        BOOL    DRIVER_AddToList(LPWINE_DRI
   {
       lpNewDrv->dwMagic = WINE_DI_MAGIC;
       /* First driver to be loaded for this module, need to load correctly the module */
--     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
--         /* first of this driver in list ? */
--      if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
--          if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
-               TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
 -              TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
--              return FALSE;
--          }
--          /* returned value is not checked */
--          DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
--      }
++     /* first of this driver in list ? */
++     if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->hModule, NULL) == 0) {
++         if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
++             TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
++             return FALSE;
++         }
++         /* returned value is not checked */
++         DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
       }
   
++     /* Now just open a new instance of a driver on this module */
++     lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
++ 
++     if (lpNewDrv->dwDriverID == 0)
++     {
++         TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
++         return FALSE;
++     }
++ 
++     EnterCriticalSection( &mmdriver_lock );
++ 
       lpNewDrv->lpNextItem = NULL;
       if (lpDrvItemList == NULL) {
        lpDrvItemList = lpNewDrv;
        lpNewDrv->lpPrevItem = lpDrv;
       }
   
--     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
--      /* Now just open a new instance of a driver on this module */
--      lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
-- 
--      if (lpNewDrv->d.d32.dwDriverID == 0) {
-           TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
 -          TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
--          DRIVER_RemoveFromList(lpNewDrv);
--          return FALSE;
--      }
--     }
++     LeaveCriticalSection( &mmdriver_lock );
       return TRUE;
   }
   
@@@@ -435,8 -435,8 -475,9 +475,9 @@@@ HDRVR WINAPI OpenDriver(LPCWSTR lpDrive
    *                   CloseDriver                             [WINMM.@]
    *                   DrvClose                                [WINMM.@]
    */
 --LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 ++LRESULT WINAPI CloseDriver(HDRVR hDrvr, LONG lParam1, LONG lParam2)
   {
++     BOOL ret;
       LPWINE_DRIVER    lpDrv;
   
       TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
@@@@ -1298,14 -1298,14 -1282,15 +1282,15 @@@@ DWORD WINAPI mciSendStringW(LPCWSTR lps
            tmp = devType; devType = dev; dev = tmp;
   
            dwFlags |= MCI_OPEN_TYPE;
 --         data[2] = (DWORD)devType;
 ++         data[2] = (DWORD_PTR)devType;
            devType = str_dup_upper(devType);
            dwFlags |= MCI_OPEN_ELEMENT;
 --         data[3] = (DWORD)dev;
 -      } else if (strchrW(dev, '.') == NULL) {
 -          tmp = strchrW(dev,' ');
 ++         data[3] = (DWORD_PTR)dev;
-       } else if (strchrW(dev, '.') == NULL) {
-           tmp = strchrW(dev,' ');
++      } else if (DRIVER_GetLibName(dev, wszMci, buf, sizeof(buf))) {
++             /* this is the name of a mci driver's type */
++          tmp = strchrW(dev, ' ');
            if (tmp) *tmp = '\0';
 --         data[2] = (DWORD)dev;
 ++         data[2] = (DWORD_PTR)dev;
            devType = str_dup_upper(dev);
            if (tmp) *tmp = ' ';
            dwFlags |= MCI_OPEN_TYPE;
               tmp2 = HeapAlloc(GetProcessHeap(), 0, (tmp - devAlias + 1) * sizeof(WCHAR) );
               memcpy( tmp2, devAlias, (tmp - devAlias) * sizeof(WCHAR) );
               tmp2[tmp - devAlias] = 0;
 --            data[4] = (DWORD)tmp2;
 ++            data[4] = (DWORD_PTR)tmp2;
            /* should be done in regular options parsing */
            /* dwFlags |= MCI_OPEN_ALIAS; */
++      } else if (dev == 0) {
++          /* "open new" requires alias */
++          dwRet = MCIERR_NEW_REQUIRES_ALIAS;
++          goto errCleanUp;
        }
   
        dwRet = MCI_LoadMciDriver(devType, &wmd);
        goto errCleanUp;
       }
   
--     /* set up call back */
--     if (hwndCallback != 0) {
--      dwFlags |= MCI_NOTIFY;
-       data[0] = (DWORD_PTR)hwndCallback;
 -      data[0] = (DWORD)hwndCallback;
--     }
-- 
       /* set return information */
       switch (retType = MCI_GetReturnType(lpCmd)) {
       case 0:          offset = 1;     break;
@@@@ -1543,79 -1543,79 -1523,16 +1523,16 @@@@ BOOL WINAPI mciFreeCommandResource(UIN
   {
       TRACE("(%08x)!\n", uTable);
   
--     return MCI_DeleteCommandTable(uTable, FALSE);
-- }
-- 
-- /**************************************************************************
--  *                   MCI_SendCommandFrom32                   [internal]
--  */
-  DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
 - DWORD MCI_SendCommandFrom32(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-- {
--     DWORD            dwRet = MCIERR_INVALID_DEVICE_ID;
--     LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
-- 
--     if (wmd) {
--      if (wmd->bIs32) {
--          dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
--      } else if (pFnMciMapMsg32WTo16) {
--          WINMM_MapType       res;
-- 
--          switch (res = pFnMciMapMsg32WTo16(wmd->wType, wMsg, dwParam1, &dwParam2)) {
--          case WINMM_MAP_MSGERROR:
--              TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
--              dwRet = MCIERR_DRIVER_INTERNAL;
--              break;
--          case WINMM_MAP_NOMEM:
--              TRACE("Problem mapping msg=%s from 32a to 16\n", MCI_MessageToString(wMsg));
--              dwRet = MCIERR_OUT_OF_MEMORY;
--              break;
--          case WINMM_MAP_OK:
--          case WINMM_MAP_OKMEM:
--              dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
--              if (res == WINMM_MAP_OKMEM)
--                  pFnMciUnMapMsg32WTo16(wmd->wType, wMsg, dwParam1, dwParam2);
--              break;
--          }
--      }
--     }
--     return dwRet;
-- }
-- 
-- /**************************************************************************
--  *                   MCI_SendCommandFrom16                   [internal]
--  */
-  DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
 - DWORD MCI_SendCommandFrom16(MCIDEVICEID wDevID, UINT16 wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
-- {
--     DWORD            dwRet = MCIERR_INVALID_DEVICE_ID;
--     LPWINE_MCIDRIVER wmd = MCI_GetDriver(wDevID);
-- 
--     if (wmd) {
--      dwRet = MCIERR_INVALID_DEVICE_ID;
-- 
--      if (wmd->bIs32 && pFnMciMapMsg16To32W) {
--          WINMM_MapType               res;
++     if (uTable >= MAX_MCICMDTABLE || !S_MciCmdTable[uTable].lpTable)
++      return FALSE;
   
--          switch (res = pFnMciMapMsg16To32W(wmd->wType, wMsg, dwParam1, &dwParam2)) {
--          case WINMM_MAP_MSGERROR:
--              TRACE("Not handled yet (%s)\n", MCI_MessageToString(wMsg));
--              dwRet = MCIERR_DRIVER_INTERNAL;
--              break;
--          case WINMM_MAP_NOMEM:
--              TRACE("Problem mapping msg=%s from 16 to 32a\n", MCI_MessageToString(wMsg));
--              dwRet = MCIERR_OUT_OF_MEMORY;
--              break;
--          case WINMM_MAP_OK:
--          case WINMM_MAP_OKMEM:
--              dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
--              if (res == WINMM_MAP_OKMEM)
--                  pFnMciUnMapMsg16To32W(wmd->wType, wMsg, dwParam1, dwParam2);
--              break;
--          }
--      } else {
--          dwRet = SendDriverMessage(wmd->hDriver, wMsg, dwParam1, dwParam2);
--      }
--     }
--     return dwRet;
++     FreeResource(S_MciCmdTable[uTable].hMem);
++     S_MciCmdTable[uTable].hMem = NULL;
++     S_MciCmdTable[uTable].lpTable = NULL;
++     HeapFree(GetProcessHeap(), 0, S_MciCmdTable[uTable].aVerbs);
++     S_MciCmdTable[uTable].aVerbs = 0;
++     S_MciCmdTable[uTable].nVerbs = 0;
++     return TRUE;
   }
   
   /**************************************************************************
@@@@ -1643,7 -1643,7 -1560,7 +1560,7 @@@@ static        DWORD MCI_Open(DWORD dwParam, LP
   
       if (dwParam & MCI_OPEN_TYPE) {
        if (dwParam & MCI_OPEN_TYPE_ID) {
-           WORD uDevType = LOWORD((DWORD_PTR)lpParms->lpstrDeviceType);
 -          WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
++          WORD uDevType = LOWORD(lpParms->lpstrDeviceType);
   
            if (uDevType < MCI_DEVTYPE_FIRST ||
                uDevType > MCI_DEVTYPE_LAST ||
@@@@ -1822,10 -1822,10 -1746,11 +1746,11 @@@@ static    DWORD MCI_SysInfo(UINT uDevID, D
       LPWINE_MCIDRIVER wmd;
       HKEY             hKey;
   
--     if (lpParms == NULL)                     return MCIERR_NULL_PARAMETER_BLOCK;
++     if (lpParms == NULL || lpParms->lpstrReturn == NULL)
++         return MCIERR_NULL_PARAMETER_BLOCK;
   
--     TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
 -        uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
++     TRACE("(%08x, %08X, %p[num=%d, wDevTyp=%u])\n",
 +        uDevID, dwFlags, lpParms, lpParms->dwNumber, lpParms->wDeviceType);
   
       switch (dwFlags & ~MCI_SYSINFO_OPEN) {
       case MCI_SYSINFO_QUANTITY:
@@@@ -308,11 -308,11 -309,24 +309,24 @@@@ UINT WINAPI mixerGetDevCapsW(UINT_PTR u
       if ((wmld = MMDRV_Get((HANDLE)uDeviceID, MMDRV_MIXER, TRUE)) == NULL)
           return MMSYSERR_BADDEVICEID;
   
--     return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize, TRUE);
++     return MMDRV_Message(wmld, MXDM_GETDEVCAPS, (DWORD_PTR)lpCaps, uSize);
 + }
 + 
-  UINT  MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
-                   DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
++ static void CALLBACK MIXER_WCallback(HMIXEROBJ hmx, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam, DWORD_PTR param2)
++ {
++     HWND hWnd = (HWND)dwInstance;
++ 
++     if (!dwInstance)
++         return;
++ 
++     PostMessageW(hWnd, uMsg, (WPARAM)hmx, (LPARAM)dwParam);
+  }
+  
 - UINT  MIXER_Open(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
 -                  DWORD_PTR dwInstance, DWORD fdwOpen, BOOL bFrom32)
++ /**************************************************************************
++  *                           mixerOpen                       [WINMM.@]
++  */
++ UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
++                       DWORD_PTR dwInstance, DWORD fdwOpen)
   {
       HANDLE           hMix;
       LPWINE_MLD               wmld;
       return dwRet;
   }
   
-- /**************************************************************************
--  *                           mixerOpen                       [WINMM.@]
--  */
-  MMRESULT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
 - UINT WINAPI mixerOpen(LPHMIXER lphMix, UINT uDeviceID, DWORD_PTR dwCallback,
--                      DWORD_PTR dwInstance, DWORD fdwOpen)
-- {
--     return MIXER_Open(lphMix, uDeviceID, dwCallback, dwInstance, fdwOpen, TRUE);
-- }
-- 
   /**************************************************************************
    *                           mixerClose                      [WINMM.@]
    */
@@@@ -935,15 -935,15 -966,6 +966,6 @@@@ UINT WINAPI midiOutOpen(LPHMIDIOUT lphM
       return dwRet;
   }
   
-- /**************************************************************************
--  *                           midiOutOpen             [WINMM.@]
--  */
-  MMRESULT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT_PTR uDeviceID,
 - UINT WINAPI midiOutOpen(LPHMIDIOUT lphMidiOut, UINT uDeviceID,
--                        DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-- {
--     return MIDI_OutOpen(lphMidiOut, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-- }
-- 
   /**************************************************************************
    *                           midiOutClose            [WINMM.@]
    */
@@@@ -1235,15 -1235,15 -1260,6 +1260,6 @@@@ UINT WINAPI midiInOpen(HMIDIIN* lphMidi
       return dwRet;
   }
   
-- /**************************************************************************
--  *                           midiInOpen              [WINMM.@]
--  */
-  MMRESULT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT_PTR uDeviceID,
 - UINT WINAPI midiInOpen(HMIDIIN* lphMidiIn, UINT uDeviceID,
--                     DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD dwFlags)
-- {
--     return MIDI_InOpen(lphMidiIn, uDeviceID, dwCallback, dwInstance, dwFlags, TRUE);
-- }
-- 
   /**************************************************************************
    *                           midiInClose             [WINMM.@]
    */
Simple merge
Simple merge
Simple merge
Simple merge
@@@@ -452,18 -452,18 -452,18 +452,18 @@@@ BOOL                  WINAPI  mciFreeCommandResource(UI
   #define DCB_TYPEMASK         0x0007
   #define DCB_NOSWITCH         0x0008                  /* don't switch stacks for callback */
   
-  BOOL                 WINAPI  DriverCallback(DWORD_PTR dwCallBack, UINT uFlags, HDRVR hDev,
-                                              UINT wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
 - BOOL                 WINAPI  DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
 -                                             UINT wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
++ BOOL                 APIENTRY        DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
++                                             DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2);
   
   typedef void (*LPTASKCALLBACK)(DWORD dwInst);
   
   #define TASKERR_NOTASKSUPPORT 1
   #define TASKERR_OUTOFMEMORY   2
   MMRESULT WINAPI mmTaskCreate(LPTASKCALLBACK, HANDLE*, DWORD);
-- void     WINAPI mmTaskBlock(HANDLE);
 - BOOL     WINAPI mmTaskSignal(HANDLE);
++ void     WINAPI mmTaskBlock(DWORD);
 + BOOL     WINAPI mmTaskSignal(DWORD);
   void     WINAPI mmTaskYield(void);
 - HANDLE   WINAPI mmGetCurrentTask(void);
 + DWORD   WINAPI mmGetCurrentTask(void);
   
   
   #define  WAVE_DIRECTSOUND               0x0080
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@@ -27,76 -28,19 -28,19 +27,76 @@@@ KdpSysGetVersion(IN PDBGKD_GET_VERSION6
   
   VOID
   NTAPI
 - KdpSetContextState(IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange,
  -KdpSetContextState(IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange,
 --                   IN PCONTEXT Context)
 ++KdpGetStateChange(IN PDBGKD_MANIPULATE_STATE64 State,
 ++                  IN PCONTEXT Context)
   {
 --    UNIMPLEMENTED;
 --    while (TRUE);
 ++    PKPRCB Prcb;
 ++    ULONG i;
 ++
 ++    /* Check for success */
 ++    if (NT_SUCCESS(State->u.Continue2.ContinueStatus))
 ++    {
 ++        /* Check if we're tracing */
 ++        if (State->u.Continue2.ControlSet.TraceFlag)
 ++        {
 ++            /* Enable TF */
 ++            Context->EFlags |= EFLAGS_TF;
 ++        }
 ++        else
 ++        {
 ++            /* Remove it */
 ++            Context->EFlags &= ~EFLAGS_TF;
 ++        }
 ++
 ++        /* Loop all processors */
 ++        for (i = 0; i < KeNumberProcessors; i++)
 ++        {
 ++            /* Get the PRCB and update DR7 and DR6 */
 ++            Prcb = KiProcessorBlock[i];
 ++            Prcb->ProcessorState.SpecialRegisters.KernelDr7 =
 ++                State->u.Continue2.ControlSet.Dr7;
 ++            Prcb->ProcessorState.SpecialRegisters.KernelDr6 = 0;
 ++        }
 ++
 ++        /* Check if we have new symbol information */
 ++        if (State->u.Continue2.ControlSet.CurrentSymbolStart != 1)
 ++        {
 ++            /* Update it */
 ++            KdpCurrentSymbolStart =
 ++                State->u.Continue2.ControlSet.CurrentSymbolStart;
 ++            KdpCurrentSymbolEnd= State->u.Continue2.ControlSet.CurrentSymbolEnd;
 ++        }
 ++    }
   }
   
   VOID
   NTAPI
-  KdpSetContextState(IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange,
 --KdpSysGetVersion(IN PDBGKD_GET_VERSION64 Version)
+++KdpSetContextState(IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange,
 ++                   IN PCONTEXT Context)
   {
 --    UNIMPLEMENTED;
 --    while (TRUE);
 ++    PKPRCB Prcb = KeGetCurrentPrcb();
 ++
 ++    /* Copy i386 specific debug registers */
 ++    WaitStateChange->ControlReport.Dr6 = Prcb->ProcessorState.SpecialRegisters.
 ++                                         KernelDr6;
 ++    WaitStateChange->ControlReport.Dr7 = Prcb->ProcessorState.SpecialRegisters.
 ++                                         KernelDr7;
 ++
 ++    /* Copy i386 specific segments */
 ++    WaitStateChange->ControlReport.SegCs = (USHORT)Context->SegCs;
 ++    WaitStateChange->ControlReport.SegDs = (USHORT)Context->SegDs;
 ++    WaitStateChange->ControlReport.SegEs = (USHORT)Context->SegEs;
 ++    WaitStateChange->ControlReport.SegFs = (USHORT)Context->SegFs;
 ++
 ++    /* Copy EFlags */
 ++    WaitStateChange->ControlReport.EFlags = Context->EFlags;
 ++
 ++    /* Set Report Flags */
 ++    WaitStateChange->ControlReport.ReportFlags = REPORT_INCLUDES_SEGS;
 ++    if (WaitStateChange->ControlReport.SegCs == KGDT_64_R0_CODE)
 ++    {
 ++        WaitStateChange->ControlReport.ReportFlags |= REPORT_STANDARD_CS;
 ++    }
   }
   
   NTSTATUS
@@@@ -266,7 -266,7 -267,7 +267,7 @@@@ VOI
   NTAPI
   KdpSetCommonState(IN ULONG NewState,
                     IN PCONTEXT Context,
-                    OUT PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange)
 -                   IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange)
++                   IN PDBGKD_ANY_WAIT_STATE_CHANGE WaitStateChange)
   {
       USHORT InstructionCount;
       BOOLEAN HadBreakpoints;
@@@@ -1374,7 -1373,7 -1380,7 +1381,7 @@@@ KdpReportExceptionStateChange(IN PEXCEP
           KdpSetContextState(&WaitStateChange, Context);
   
           /* Setup the actual header to send to KD */
-          Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64) - sizeof(CONTEXT);
 -         Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64);
++         Header.Length = sizeof(DBGKD_ANY_WAIT_STATE_CHANGE);
           Header.Buffer = (PCHAR)&WaitStateChange;
   
           /* Setup the trace data */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge