reactos/ntoskrnl/kd64/kdapi.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/kd64/kdapi.c
   5  * PURPOSE:         KD64 Public Routines and Internal Support
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 /* PRIVATE FUNCTIONS *********************************************************/
  16
  17 NTSTATUS
  18 NTAPI
  19 KdpCopyMemoryChunks(IN ULONG64 Address,
  20                     IN PVOID Buffer,
  21                     IN ULONG TotalSize,
  22                     IN ULONG ChunkSize,
  23                     IN ULONG Flags,
  24                     OUT PULONG ActualSize OPTIONAL)
  25 {
  26     ULONG Length;
  27     NTSTATUS Status;
  28
  29     /* Check if this is physical or virtual copy */
  30     if (Flags & MMDBG_COPY_PHYSICAL)
  31     {
  32         /* Fail physical memory read/write for now */
  33         if (Flags & MMDBG_COPY_WRITE)
  34         {
  35             KdpDprintf("KdpCopyMemoryChunks: Failing write for Physical Address 0x%I64x Length: %x\n",
  36                        Address,
  37                        TotalSize);
  38         }
  39         else
  40         {
  41             KdpDprintf("KdpCopyMemoryChunks: Failing read for Physical Address 0x%I64x Length: %x\n",
  42                        Address,
  43                        TotalSize);
  44         }
  45
  46         /* Return an error */
  47         Length = 0;
  48         Status = STATUS_UNSUCCESSFUL;
  49     }
  50     else
  51     {
  52         /* Protect against NULL */
  53         if (!Address)
  54         {
  55             if (ActualSize) *ActualSize = 0;
  56             return STATUS_UNSUCCESSFUL;
  57         }
  58
  59         /* Check if this is read or write */
  60         if (Flags & MMDBG_COPY_WRITE)
  61         {
  62             /* Do the write */
  63             RtlCopyMemory((PVOID)(ULONG_PTR)Address,
  64                           Buffer,
  65                           TotalSize);
  66         }
  67         else
  68         {
  69             /* Do the read */
  70             RtlCopyMemory(Buffer,
  71                           (PVOID)(ULONG_PTR)Address,
  72                           TotalSize);
  73         }
  74
  75         /* Set size and status */
  76         Length = TotalSize;
  77         Status = STATUS_SUCCESS;
  78     }
  79
  80     /* Return the actual length if requested */
  81     if (ActualSize) *ActualSize = Length;
  82
  83     /* Return status */
  84     return Status;
  85 }
  86
  87 VOID
  88 NTAPI
  89 KdpQueryMemory(IN PDBGKD_MANIPULATE_STATE64 State,
  90                IN PCONTEXT Context)
  91 {
  92     PDBGKD_QUERY_MEMORY Memory = &State->u.QueryMemory;
  93     STRING Header;
  94     NTSTATUS Status = STATUS_SUCCESS;
  95
  96     /* Validate the address space */
  97     if (Memory->AddressSpace == DBGKD_QUERY_MEMORY_VIRTUAL)
  98     {
  99         /* Check if this is process memory */
 100         if ((PVOID)(ULONG_PTR)Memory->Address < MmHighestUserAddress)
 101         {
 102             /* It is */
 103             Memory->AddressSpace = DBGKD_QUERY_MEMORY_PROCESS;
 104         }
 105         else
 106         {
 107             /* FIXME: Check if it's session space */
 108             Memory->AddressSpace = DBGKD_QUERY_MEMORY_KERNEL;
 109         }
 110
 111         /* Set flags */
 112         Memory->Flags = DBGKD_QUERY_MEMORY_READ |
 113                         DBGKD_QUERY_MEMORY_WRITE |
 114                         DBGKD_QUERY_MEMORY_EXECUTE;
 115     }
 116     else
 117     {
 118         /* Invalid */
 119         Status = STATUS_INVALID_PARAMETER;
 120     }
 121
 122     /* Return structure */
 123     State->ReturnStatus = Status;
 124     Memory->Reserved = 0;
 125
 126     /* Build header */
 127     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 128     Header.Buffer = (PCHAR)State;
 129
 130     /* Send the packet */
 131     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 132                  &Header,
 133                  NULL,
 134                  &KdpContext);
 135 }
 136
 137 VOID
 138 NTAPI
 139 KdpSearchMemory(IN PDBGKD_MANIPULATE_STATE64 State,
 140                 IN PSTRING Data,
 141                 IN PCONTEXT Context)
 142 {
 143     /* FIXME: STUB */
 144     KdpDprintf("KdpSearchMemory called\n");
 145     while (TRUE);
 146 }
 147
 148 VOID
 149 NTAPI
 150 KdpFillMemory(IN PDBGKD_MANIPULATE_STATE64 State,
 151               IN PSTRING Data,
 152               IN PCONTEXT Context)
 153 {
 154     /* FIXME: STUB */
 155     KdpDprintf("KdpFillMemory called\n");
 156     while (TRUE);
 157 }
 158
 159 VOID
 160 NTAPI
 161 KdpWriteBreakpoint(IN PDBGKD_MANIPULATE_STATE64 State,
 162                    IN PSTRING Data,
 163                    IN PCONTEXT Context)
 164 {
 165     PDBGKD_WRITE_BREAKPOINT64 Breakpoint = &State->u.WriteBreakPoint;
 166     STRING Header;
 167
 168     /* Build header */
 169     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 170     Header.Buffer = (PCHAR)State;
 171     ASSERT(Data->Length == 0);
 172
 173     /* Create the breakpoint */
 174     Breakpoint->BreakPointHandle =
 175         KdpAddBreakpoint((PVOID)(ULONG_PTR)Breakpoint->BreakPointAddress);
 176     if (!Breakpoint->BreakPointHandle)
 177     {
 178         /* We failed */
 179         State->ReturnStatus = STATUS_UNSUCCESSFUL;
 180     }
 181     else
 182     {
 183         /* Success! */
 184         State->ReturnStatus = STATUS_SUCCESS;
 185     }
 186
 187     /* Send the packet */
 188     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 189                  &Header,
 190                  NULL,
 191                  &KdpContext);
 192 }
 193
 194 VOID
 195 NTAPI
 196 KdpRestoreBreakpoint(IN PDBGKD_MANIPULATE_STATE64 State,
 197                      IN PSTRING Data,
 198                      IN PCONTEXT Context)
 199 {
 200     PDBGKD_RESTORE_BREAKPOINT RestoreBp = &State->u.RestoreBreakPoint;
 201     STRING Header;
 202
 203     /* Fill out the header */
 204     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 205     Header.Buffer = (PCHAR)State;
 206     ASSERT(Data->Length == 0);
 207
 208     /* Get the version block */
 209     if (KdpDeleteBreakpoint(RestoreBp->BreakPointHandle))
 210     {
 211         /* We're all good */
 212         State->ReturnStatus = STATUS_SUCCESS;
 213     }
 214     else
 215     {
 216         /* We failed */
 217         State->ReturnStatus = STATUS_UNSUCCESSFUL;
 218     }
 219
 220     /* Send the packet */
 221     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 222                  &Header,
 223                  NULL,
 224                  &KdpContext);
 225 }
 226
 227 NTSTATUS
 228 NTAPI
 229 KdpWriteBreakPointEx(IN PDBGKD_MANIPULATE_STATE64 State,
 230                      IN PSTRING Data,
 231                      IN PCONTEXT Context)
 232 {
 233     /* FIXME: STUB */
 234     KdpDprintf("KdpWriteBreakPointEx called\n");
 235     while (TRUE);
 236     return STATUS_UNSUCCESSFUL;
 237 }
 238
 239 VOID
 240 NTAPI
 241 KdpRestoreBreakPointEx(IN PDBGKD_MANIPULATE_STATE64 State,
 242                        IN PSTRING Data,
 243                        IN PCONTEXT Context)
 244 {
 245     /* FIXME: STUB */
 246     KdpDprintf("KdpRestoreBreakPointEx called\n");
 247     while (TRUE);
 248 }
 249
 250 VOID
 251 NTAPI
 252 DumpTraceData(IN PSTRING TraceData)
 253 {
 254     /* Update the buffer */
 255     TraceDataBuffer[0] = TraceDataBufferPosition;
 256
 257     /* Setup the trace data */
 258     TraceData->Length = TraceDataBufferPosition * sizeof(ULONG);
 259     TraceData->Buffer = (PCHAR)TraceDataBuffer;
 260
 261     /* Reset the buffer location */
 262     TraceDataBufferPosition = 1;
 263 }
 264
 265 VOID
 266 NTAPI
 267 KdpSetCommonState(IN ULONG NewState,
 268                   IN PCONTEXT Context,
 269                   IN PDBGKD_WAIT_STATE_CHANGE64 WaitStateChange)
 270 {
 271     USHORT InstructionCount;
 272     BOOLEAN HadBreakpoints;
 273
 274     /* Setup common stuff available for all CPU architectures */
 275     WaitStateChange->NewState = NewState;
 276     WaitStateChange->ProcessorLevel = KeProcessorLevel;
 277     WaitStateChange->Processor = (USHORT)KeGetCurrentPrcb()->Number;
 278     WaitStateChange->NumberProcessors = (ULONG)KeNumberProcessors;
 279     WaitStateChange->Thread = (ULONG64)(LONG_PTR)KeGetCurrentThread();
 280     WaitStateChange->ProgramCounter = (ULONG64)(LONG_PTR)KeGetContextPc(Context);
 281
 282     /* Zero out the Control Report */
 283     RtlZeroMemory(&WaitStateChange->ControlReport,
 284                   sizeof(DBGKD_CONTROL_REPORT));
 285
 286     /* Now copy the instruction stream and set the count */
 287     RtlCopyMemory(&WaitStateChange->ControlReport.InstructionStream[0],
 288                   (PVOID)(ULONG_PTR)WaitStateChange->ProgramCounter,
 289                   DBGKD_MAXSTREAM);
 290     InstructionCount = DBGKD_MAXSTREAM;
 291     WaitStateChange->ControlReport.InstructionCount = InstructionCount;
 292
 293     /* Clear all the breakpoints in this region */
 294     HadBreakpoints =
 295         KdpDeleteBreakpointRange((PVOID)(ULONG_PTR)WaitStateChange->ProgramCounter,
 296                                  (PVOID)((ULONG_PTR)WaitStateChange->ProgramCounter +
 297                                          WaitStateChange->ControlReport.InstructionCount - 1));
 298     if (HadBreakpoints)
 299     {
 300         /* Copy the instruction stream again, this time without breakpoints */
 301         RtlCopyMemory(&WaitStateChange->ControlReport.InstructionStream[0],
 302                       (PVOID)(ULONG_PTR)WaitStateChange->ProgramCounter,
 303                       WaitStateChange->ControlReport.InstructionCount);
 304     }
 305 }
 306
 307 VOID
 308 NTAPI
 309 KdpGetVersion(IN PDBGKD_MANIPULATE_STATE64 State)
 310 {
 311     STRING Header;
 312
 313     /* Fill out the header */
 314     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 315     Header.Buffer = (PCHAR)State;
 316
 317     /* Get the version block */
 318     KdpSysGetVersion(&State->u.GetVersion64);
 319
 320     /* Fill out the state */
 321     State->ApiNumber = DbgKdGetVersionApi;
 322     State->ReturnStatus = STATUS_SUCCESS;
 323
 324     /* Send the packet */
 325     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 326                  &Header,
 327                  NULL,
 328                  &KdpContext);
 329 }
 330
 331 VOID
 332 NTAPI
 333 KdpReadVirtualMemory(IN PDBGKD_MANIPULATE_STATE64 State,
 334                      IN PSTRING Data,
 335                      IN PCONTEXT Context)
 336 {
 337     PDBGKD_READ_MEMORY64 ReadMemory = &State->u.ReadMemory;
 338     STRING Header;
 339     ULONG Length = ReadMemory->TransferCount;
 340
 341     /* Setup the header */
 342     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 343     Header.Buffer = (PCHAR)State;
 344     ASSERT(Data->Length == 0);
 345
 346     /* Validate length */
 347     if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64)))
 348     {
 349         /* Overflow, set it to maximum possible */
 350         Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64);
 351     }
 352
 353     /* Do the read */
 354     State->ReturnStatus = KdpCopyMemoryChunks(ReadMemory->TargetBaseAddress,
 355                                               Data->Buffer,
 356                                               Length,
 357                                               0,
 358                                               MMDBG_COPY_UNSAFE,
 359                                               &Length);
 360
 361     /* Return the actual length read */
 362     Data->Length = ReadMemory->ActualBytesRead = Length;
 363
 364     /* Send the packet */
 365     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 366                  &Header,
 367                  Data,
 368                  &KdpContext);
 369 }
 370
 371 VOID
 372 NTAPI
 373 KdpWriteVirtualMemory(IN PDBGKD_MANIPULATE_STATE64 State,
 374                       IN PSTRING Data,
 375                       IN PCONTEXT Context)
 376 {
 377     PDBGKD_WRITE_MEMORY64 WriteMemory = &State->u.WriteMemory;
 378     STRING Header;
 379
 380     /* Setup the header */
 381     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 382     Header.Buffer = (PCHAR)State;
 383
 384     /* Do the write */
 385     State->ReturnStatus = KdpCopyMemoryChunks(WriteMemory->TargetBaseAddress,
 386                                               Data->Buffer,
 387                                               Data->Length,
 388                                               0,
 389                                               MMDBG_COPY_UNSAFE |
 390                                               MMDBG_COPY_WRITE,
 391                                               &WriteMemory->ActualBytesWritten);
 392
 393     /* Send the packet */
 394     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 395                  &Header,
 396                  NULL,
 397                  &KdpContext);
 398 }
 399
 400 VOID
 401 NTAPI
 402 KdpReadPhysicalmemory(IN PDBGKD_MANIPULATE_STATE64 State,
 403                       IN PSTRING Data,
 404                       IN PCONTEXT Context)
 405 {
 406     PDBGKD_READ_MEMORY64 ReadMemory = &State->u.ReadMemory;
 407     STRING Header;
 408     ULONG Length = ReadMemory->TransferCount;
 409     ULONG Flags, CacheFlags;
 410
 411     /* Setup the header */
 412     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 413     Header.Buffer = (PCHAR)State;
 414     ASSERT(Data->Length == 0);
 415
 416     /* Validate length */
 417     if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64)))
 418     {
 419         /* Overflow, set it to maximum possible */
 420         Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64);
 421     }
 422
 423     /* Start with the default flags */
 424     Flags = MMDBG_COPY_UNSAFE | MMDBG_COPY_PHYSICAL;
 425
 426     /* Get the caching flags and check if a type is specified */
 427     CacheFlags = ReadMemory->ActualBytesRead;
 428     if (CacheFlags == DBGKD_CACHING_CACHED)
 429     {
 430         /* Cached */
 431         Flags |= MMDBG_COPY_CACHED;
 432     }
 433     else if (CacheFlags == DBGKD_CACHING_UNCACHED)
 434     {
 435         /* Uncached */
 436         Flags |= MMDBG_COPY_UNCACHED;
 437     }
 438     else if (CacheFlags == DBGKD_CACHING_UNCACHED)
 439     {
 440         /* Write Combined */
 441         Flags |= DBGKD_CACHING_WRITE_COMBINED;
 442     }
 443
 444     /* Do the read */
 445     State->ReturnStatus = KdpCopyMemoryChunks(ReadMemory->TargetBaseAddress,
 446                                               Data->Buffer,
 447                                               Length,
 448                                               0,
 449                                               Flags,
 450                                               &Length);
 451
 452     /* Return the actual length read */
 453     Data->Length = ReadMemory->ActualBytesRead = Length;
 454
 455     /* Send the packet */
 456     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 457                  &Header,
 458                  Data,
 459                  &KdpContext);
 460 }
 461
 462 VOID
 463 NTAPI
 464 KdpWritePhysicalmemory(IN PDBGKD_MANIPULATE_STATE64 State,
 465                        IN PSTRING Data,
 466                        IN PCONTEXT Context)
 467 {
 468     PDBGKD_WRITE_MEMORY64 WriteMemory = &State->u.WriteMemory;
 469     STRING Header;
 470     ULONG Flags, CacheFlags;
 471
 472     /* Setup the header */
 473     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 474     Header.Buffer = (PCHAR)State;
 475
 476     /* Start with the default flags */
 477     Flags = MMDBG_COPY_UNSAFE | MMDBG_COPY_WRITE | MMDBG_COPY_PHYSICAL;
 478
 479     /* Get the caching flags and check if a type is specified */
 480     CacheFlags = WriteMemory->ActualBytesWritten;
 481     if (CacheFlags == DBGKD_CACHING_CACHED)
 482     {
 483         /* Cached */
 484         Flags |= MMDBG_COPY_CACHED;
 485     }
 486     else if (CacheFlags == DBGKD_CACHING_UNCACHED)
 487     {
 488         /* Uncached */
 489         Flags |= MMDBG_COPY_UNCACHED;
 490     }
 491     else if (CacheFlags == DBGKD_CACHING_UNCACHED)
 492     {
 493         /* Write Combined */
 494         Flags |= DBGKD_CACHING_WRITE_COMBINED;
 495     }
 496
 497     /* Do the write */
 498     State->ReturnStatus = KdpCopyMemoryChunks(WriteMemory->TargetBaseAddress,
 499                                               Data->Buffer,
 500                                               Data->Length,
 501                                               0,
 502                                               Flags,
 503                                               &WriteMemory->ActualBytesWritten);
 504
 505     /* Send the packet */
 506     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 507                  &Header,
 508                  NULL,
 509                  &KdpContext);
 510 }
 511
 512 VOID
 513 NTAPI
 514 KdpReadControlSpace(IN PDBGKD_MANIPULATE_STATE64 State,
 515                     IN PSTRING Data,
 516                     IN PCONTEXT Context)
 517 {
 518     PDBGKD_READ_MEMORY64 ReadMemory = &State->u.ReadMemory;
 519     STRING Header;
 520     ULONG Length;
 521
 522     /* Setup the header */
 523     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 524     Header.Buffer = (PCHAR)State;
 525     ASSERT(Data->Length == 0);
 526
 527     /* Check the length requested */
 528     Length = ReadMemory->TransferCount;
 529     if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64)))
 530     {
 531         /* Use maximum allowed */
 532         Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64);
 533     }
 534
 535     /* Call the internal routine */
 536     State->ReturnStatus = KdpSysReadControlSpace(State->Processor,
 537                                                  ReadMemory->TargetBaseAddress,
 538                                                  Data->Buffer,
 539                                                  Length,
 540                                                  &Length);
 541
 542     /* Return the actual length read */
 543     Data->Length = ReadMemory->ActualBytesRead = Length;
 544
 545     /* Send the reply */
 546     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 547                  &Header,
 548                  Data,
 549                  &KdpContext);
 550 }
 551
 552 VOID
 553 NTAPI
 554 KdpWriteControlSpace(IN PDBGKD_MANIPULATE_STATE64 State,
 555                      IN PSTRING Data,
 556                      IN PCONTEXT Context)
 557 {
 558     PDBGKD_WRITE_MEMORY64 WriteMemory = &State->u.WriteMemory;
 559     STRING Header;
 560
 561     /* Setup the header */
 562     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 563     Header.Buffer = (PCHAR)State;
 564
 565     /* Call the internal routine */
 566     State->ReturnStatus = KdpSysWriteControlSpace(State->Processor,
 567                                                   WriteMemory->TargetBaseAddress,
 568                                                   Data->Buffer,
 569                                                   Data->Length,
 570                                                   &WriteMemory->ActualBytesWritten);
 571
 572     /* Send the reply */
 573     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 574                  &Header,
 575                  Data,
 576                  &KdpContext);
 577 }
 578
 579 VOID
 580 NTAPI
 581 KdpGetContext(IN PDBGKD_MANIPULATE_STATE64 State,
 582               IN PSTRING Data,
 583               IN PCONTEXT Context)
 584 {
 585     STRING Header;
 586     PVOID ControlStart;
 587
 588     /* Setup the header */
 589     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 590     Header.Buffer = (PCHAR)State;
 591     ASSERT(Data->Length == 0);
 592
 593     /* Make sure that this is a valid request */
 594     if (State->Processor < KeNumberProcessors)
 595     {
 596         /* Check if the request is for this CPU */
 597         if (State->Processor == KeGetCurrentPrcb()->Number)
 598         {
 599             /* We're just copying our own context */
 600             ControlStart = Context;
 601         }
 602         else
 603         {
 604             /* SMP not yet handled */
 605             KdpDprintf("KdpGetContext: SMP UNHANDLED\n");
 606             ControlStart = NULL;
 607             while (TRUE);
 608         }
 609
 610         /* Copy the memory */
 611         RtlCopyMemory(Data->Buffer, ControlStart, sizeof(CONTEXT));
 612         Data->Length = sizeof(CONTEXT);
 613
 614         /* Finish up */
 615         State->ReturnStatus = STATUS_SUCCESS;
 616     }
 617     else
 618     {
 619         /* Invalid request */
 620         State->ReturnStatus = STATUS_UNSUCCESSFUL;
 621     }
 622
 623     /* Send the reply */
 624     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 625                  &Header,
 626                  Data,
 627                  &KdpContext);
 628 }
 629
 630 VOID
 631 NTAPI
 632 KdpSetContext(IN PDBGKD_MANIPULATE_STATE64 State,
 633               IN PSTRING Data,
 634               IN PCONTEXT Context)
 635 {
 636     STRING Header;
 637     PVOID ControlStart;
 638
 639     /* Setup the header */
 640     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 641     Header.Buffer = (PCHAR)State;
 642     ASSERT(Data->Length == sizeof(CONTEXT));
 643
 644     /* Make sure that this is a valid request */
 645     if (State->Processor < KeNumberProcessors)
 646     {
 647         /* Check if the request is for this CPU */
 648         if (State->Processor == KeGetCurrentPrcb()->Number)
 649         {
 650             /* We're just copying our own context */
 651             ControlStart = Context;
 652         }
 653         else
 654         {
 655             /* SMP not yet handled */
 656             KdpDprintf("KdpSetContext: SMP UNHANDLED\n");
 657             ControlStart = NULL;
 658             while (TRUE);
 659         }
 660
 661         /* Copy the memory */
 662         RtlCopyMemory(ControlStart, Data->Buffer, sizeof(CONTEXT));
 663
 664         /* Finish up */
 665         State->ReturnStatus = STATUS_SUCCESS;
 666     }
 667     else
 668     {
 669         /* Invalid request */
 670         State->ReturnStatus = STATUS_UNSUCCESSFUL;
 671     }
 672
 673     /* Send the reply */
 674     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 675                  &Header,
 676                  Data,
 677                  &KdpContext);
 678 }
 679
 680 VOID
 681 NTAPI
 682 KdpCauseBugCheck(IN PDBGKD_MANIPULATE_STATE64 State)
 683 {
 684     /* Crash with the special code */
 685     KeBugCheck(MANUALLY_INITIATED_CRASH);
 686 }
 687
 688 VOID
 689 NTAPI
 690 KdpReadMachineSpecificRegister(IN PDBGKD_MANIPULATE_STATE64 State,
 691                                IN PSTRING Data,
 692                                IN PCONTEXT Context)
 693 {
 694     STRING Header;
 695     PDBGKD_READ_WRITE_MSR ReadMsr = &State->u.ReadWriteMsr;
 696     LARGE_INTEGER MsrValue;
 697
 698     /* Setup the header */
 699     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 700     Header.Buffer = (PCHAR)State;
 701     ASSERT(Data->Length == 0);
 702
 703     /* Call the internal routine */
 704     State->ReturnStatus = KdpSysReadMsr(ReadMsr->Msr,
 705                                         &MsrValue);
 706
 707     /* Return the data */
 708     ReadMsr->DataValueLow = MsrValue.LowPart;
 709     ReadMsr->DataValueHigh = MsrValue.HighPart;
 710
 711     /* Send the reply */
 712     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 713                  &Header,
 714                  NULL,
 715                  &KdpContext);
 716 }
 717
 718 VOID
 719 NTAPI
 720 KdpWriteMachineSpecificRegister(IN PDBGKD_MANIPULATE_STATE64 State,
 721                                 IN PSTRING Data,
 722                                 IN PCONTEXT Context)
 723 {
 724     STRING Header;
 725     PDBGKD_READ_WRITE_MSR WriteMsr = &State->u.ReadWriteMsr;
 726     LARGE_INTEGER MsrValue;
 727
 728     /* Setup the header */
 729     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 730     Header.Buffer = (PCHAR)State;
 731     ASSERT(Data->Length == 0);
 732
 733     /* Call the internal routine */
 734     MsrValue.LowPart = WriteMsr->DataValueLow;
 735     MsrValue.HighPart = WriteMsr->DataValueHigh;
 736     State->ReturnStatus = KdpSysWriteMsr(WriteMsr->Msr,
 737                                          &MsrValue);
 738
 739     /* Send the reply */
 740     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 741                  &Header,
 742                  NULL,
 743                  &KdpContext);
 744 }
 745
 746 VOID
 747 NTAPI
 748 KdpGetBusData(IN PDBGKD_MANIPULATE_STATE64 State,
 749               IN PSTRING Data,
 750               IN PCONTEXT Context)
 751 {
 752     STRING Header;
 753     PDBGKD_GET_SET_BUS_DATA GetBusData = &State->u.GetSetBusData;
 754     ULONG Length;
 755
 756     /* Setup the header */
 757     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 758     Header.Buffer = (PCHAR)State;
 759     ASSERT(Data->Length == 0);
 760
 761     /* Check the length requested */
 762     Length = GetBusData->Length;
 763     if (Length > (PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64)))
 764     {
 765         /* Use maximum allowed */
 766         Length = PACKET_MAX_SIZE - sizeof(DBGKD_MANIPULATE_STATE64);
 767     }
 768
 769     /* Call the internal routine */
 770     State->ReturnStatus = KdpSysReadBusData(GetBusData->BusDataType,
 771                                             GetBusData->BusNumber,
 772                                             GetBusData->SlotNumber,
 773                                             GetBusData->Offset,
 774                                             Data->Buffer,
 775                                             Length,
 776                                             &Length);
 777
 778     /* Return the actual length read */
 779     Data->Length = GetBusData->Length = Length;
 780
 781     /* Send the reply */
 782     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 783                  &Header,
 784                  Data,
 785                  &KdpContext);
 786 }
 787
 788 VOID
 789 NTAPI
 790 KdpSetBusData(IN PDBGKD_MANIPULATE_STATE64 State,
 791               IN PSTRING Data,
 792               IN PCONTEXT Context)
 793 {
 794     STRING Header;
 795     PDBGKD_GET_SET_BUS_DATA SetBusData = &State->u.GetSetBusData;
 796     ULONG Length;
 797
 798     /* Setup the header */
 799     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 800     Header.Buffer = (PCHAR)State;
 801
 802     /* Call the internal routine */
 803     State->ReturnStatus = KdpSysWriteBusData(SetBusData->BusDataType,
 804                                              SetBusData->BusNumber,
 805                                              SetBusData->SlotNumber,
 806                                              SetBusData->Offset,
 807                                              Data->Buffer,
 808                                              SetBusData->Length,
 809                                              &Length);
 810
 811     /* Return the actual length written */
 812     SetBusData->Length = Length;
 813
 814     /* Send the reply */
 815     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 816                  &Header,
 817                  Data,
 818                  &KdpContext);
 819 }
 820
 821 VOID
 822 NTAPI
 823 KdpReadIoSpace(IN PDBGKD_MANIPULATE_STATE64 State,
 824                IN PSTRING Data,
 825                IN PCONTEXT Context)
 826 {
 827     STRING Header;
 828     PDBGKD_READ_WRITE_IO64 ReadIo = &State->u.ReadWriteIo;
 829
 830     /* Setup the header */
 831     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 832     Header.Buffer = (PCHAR)State;
 833     ASSERT(Data->Length == 0);
 834
 835     /*
 836      * Clear the value so 1 or 2 byte reads
 837      * don't leave the higher bits unmodified
 838      */
 839     ReadIo->DataValue = 0;
 840
 841     /* Call the internal routine */
 842     State->ReturnStatus = KdpSysReadIoSpace(Isa,
 843                                             0,
 844                                             1,
 845                                             ReadIo->IoAddress,
 846                                             &ReadIo->DataValue,
 847                                             ReadIo->DataSize,
 848                                             &ReadIo->DataSize);
 849
 850     /* Send the reply */
 851     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 852                  &Header,
 853                  NULL,
 854                  &KdpContext);
 855 }
 856
 857 VOID
 858 NTAPI
 859 KdpWriteIoSpace(IN PDBGKD_MANIPULATE_STATE64 State,
 860                 IN PSTRING Data,
 861                 IN PCONTEXT Context)
 862 {
 863     STRING Header;
 864     PDBGKD_READ_WRITE_IO64 WriteIo = &State->u.ReadWriteIo;
 865
 866     /* Setup the header */
 867     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 868     Header.Buffer = (PCHAR)State;
 869     ASSERT(Data->Length == 0);
 870
 871     /* Call the internal routine */
 872     State->ReturnStatus = KdpSysWriteIoSpace(Isa,
 873                                              0,
 874                                              1,
 875                                              WriteIo->IoAddress,
 876                                              &WriteIo->DataValue,
 877                                              WriteIo->DataSize,
 878                                              &WriteIo->DataSize);
 879
 880     /* Send the reply */
 881     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 882                  &Header,
 883                  NULL,
 884                  &KdpContext);
 885 }
 886
 887 VOID
 888 NTAPI
 889 KdpReadIoSpaceExtended(IN PDBGKD_MANIPULATE_STATE64 State,
 890                        IN PSTRING Data,
 891                        IN PCONTEXT Context)
 892 {
 893     STRING Header;
 894     PDBGKD_READ_WRITE_IO_EXTENDED64 ReadIoExtended = &State->u.
 895                                                       ReadWriteIoExtended;
 896
 897     /* Setup the header */
 898     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 899     Header.Buffer = (PCHAR)State;
 900     ASSERT(Data->Length == 0);
 901
 902     /*
 903      * Clear the value so 1 or 2 byte reads
 904      * don't leave the higher bits unmodified
 905      */
 906     ReadIoExtended->DataValue = 0;
 907
 908     /* Call the internal routine */
 909     State->ReturnStatus = KdpSysReadIoSpace(ReadIoExtended->InterfaceType,
 910                                             ReadIoExtended->BusNumber,
 911                                             ReadIoExtended->AddressSpace,
 912                                             ReadIoExtended->IoAddress,
 913                                             &ReadIoExtended->DataValue,
 914                                             ReadIoExtended->DataSize,
 915                                             &ReadIoExtended->DataSize);
 916
 917     /* Send the reply */
 918     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 919                  &Header,
 920                  NULL,
 921                  &KdpContext);
 922 }
 923
 924 VOID
 925 NTAPI
 926 KdpWriteIoSpaceExtended(IN PDBGKD_MANIPULATE_STATE64 State,
 927                         IN PSTRING Data,
 928                         IN PCONTEXT Context)
 929 {
 930     STRING Header;
 931     PDBGKD_READ_WRITE_IO_EXTENDED64 WriteIoExtended = &State->u.
 932                                                        ReadWriteIoExtended;
 933
 934     /* Setup the header */
 935     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 936     Header.Buffer = (PCHAR)State;
 937     ASSERT(Data->Length == 0);
 938
 939     /* Call the internal routine */
 940     State->ReturnStatus = KdpSysReadIoSpace(WriteIoExtended->InterfaceType,
 941                                             WriteIoExtended->BusNumber,
 942                                             WriteIoExtended->AddressSpace,
 943                                             WriteIoExtended->IoAddress,
 944                                             &WriteIoExtended->DataValue,
 945                                             WriteIoExtended->DataSize,
 946                                             &WriteIoExtended->DataSize);
 947
 948     /* Send the reply */
 949     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 950                  &Header,
 951                  NULL,
 952                  &KdpContext);
 953 }
 954
 955 VOID
 956 NTAPI
 957 KdpCheckLowMemory(IN PDBGKD_MANIPULATE_STATE64 State)
 958 {
 959     STRING Header;
 960
 961     /* Setup the header */
 962     Header.Length = sizeof(DBGKD_MANIPULATE_STATE64);
 963     Header.Buffer = (PCHAR)State;
 964
 965     /* Call the internal routine */
 966     State->ReturnStatus = KdpSysCheckLowMemory(MMDBG_COPY_UNSAFE);
 967
 968     /* Send the reply */
 969     KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
 970                  &Header,
 971                  NULL,
 972                  &KdpContext);
 973 }
 974
 975 KCONTINUE_STATUS
 976 NTAPI
 977 KdpSendWaitContinue(IN ULONG PacketType,
 978                     IN PSTRING SendHeader,
 979                     IN PSTRING SendData OPTIONAL,
 980                     IN OUT PCONTEXT Context)
 981 {
 982     STRING Data, Header;
 983     DBGKD_MANIPULATE_STATE64 ManipulateState;
 984     ULONG Length;
 985     KDSTATUS RecvCode;
 986
 987     /* Setup the Manipulate State structure */
 988     Header.MaximumLength = sizeof(DBGKD_MANIPULATE_STATE64);
 989     Header.Buffer = (PCHAR)&ManipulateState;
 990     Data.MaximumLength = sizeof(KdpMessageBuffer);
 991     Data.Buffer = KdpMessageBuffer;
 992     //KdpContextSent = FALSE;
 993
 994 SendPacket:
 995     /* Send the Packet */
 996     KdSendPacket(PacketType, SendHeader, SendData, &KdpContext);
 997
 998     /* If the debugger isn't present anymore, just return success */
 999     if (KdDebuggerNotPresent) return ContinueSuccess;
1000
1001     /* Main processing Loop */
1002     for (;;)
1003     {
1004         /* Receive Loop */
1005         do
1006         {
1007             /* Wait to get a reply to our packet */
1008             RecvCode = KdReceivePacket(PACKET_TYPE_KD_STATE_MANIPULATE,
1009                                        &Header,
1010                                        &Data,
1011                                        &Length,
1012                                        &KdpContext);
1013
1014             /* If we got a resend request, do it */
1015             if (RecvCode == KdPacketNeedsResend) goto SendPacket;
1016         } while (RecvCode == KdPacketTimedOut);
1017
1018         /* Now check what API we got */
1019         switch (ManipulateState.ApiNumber)
1020         {
1021             case DbgKdReadVirtualMemoryApi:
1022
1023                 /* Read virtual memory */
1024                 KdpReadVirtualMemory(&ManipulateState, &Data, Context);
1025                 break;
1026
1027             case DbgKdWriteVirtualMemoryApi:
1028
1029                 /* Write virtual memory */
1030                 KdpWriteVirtualMemory(&ManipulateState, &Data, Context);
1031                 break;
1032
1033             case DbgKdGetContextApi:
1034
1035                 /* Get the current context */
1036                 KdpGetContext(&ManipulateState, &Data, Context);
1037                 break;
1038
1039             case DbgKdSetContextApi:
1040
1041                 /* Set a new context */
1042                 KdpSetContext(&ManipulateState, &Data, Context);
1043                 break;
1044
1045             case DbgKdWriteBreakPointApi:
1046
1047                 /* Write the breakpoint */
1048                 KdpWriteBreakpoint(&ManipulateState, &Data, Context);
1049                 break;
1050
1051             case DbgKdRestoreBreakPointApi:
1052
1053                 /* Restore the breakpoint */
1054                 KdpRestoreBreakpoint(&ManipulateState, &Data, Context);
1055                 break;
1056
1057             case DbgKdContinueApi:
1058
1059                 /* Simply continue */
1060                 return NT_SUCCESS(ManipulateState.u.Continue.ContinueStatus);
1061
1062             case DbgKdReadControlSpaceApi:
1063
1064                 /* Read control space */
1065                 KdpReadControlSpace(&ManipulateState, &Data, Context);
1066                 break;
1067
1068             case DbgKdWriteControlSpaceApi:
1069
1070                 /* Write control space */
1071                 KdpWriteControlSpace(&ManipulateState, &Data, Context);
1072                 break;
1073
1074             case DbgKdReadIoSpaceApi:
1075
1076                 /* Read I/O Space */
1077                 KdpReadIoSpace(&ManipulateState, &Data, Context);
1078                 break;
1079
1080             case DbgKdWriteIoSpaceApi:
1081
1082                 /* Write I/O Space */
1083                 KdpWriteIoSpace(&ManipulateState, &Data, Context);
1084                 break;
1085
1086             case DbgKdRebootApi:
1087
1088                 /* Reboot the system */
1089                 HalReturnToFirmware(HalRebootRoutine);
1090                 break;
1091
1092             case DbgKdContinueApi2:
1093
1094                 /* Check if caller reports success */
1095                 if (NT_SUCCESS(ManipulateState.u.Continue2.ContinueStatus))
1096                 {
1097                     /* Update the state */
1098                     KdpGetStateChange(&ManipulateState, Context);
1099                     return ContinueSuccess;
1100                 }
1101                 else
1102                 {
1103                     /* Return an error */
1104                     return ContinueError;
1105                 }
1106
1107             case DbgKdReadPhysicalMemoryApi:
1108
1109                 /* Read  physical memory */
1110                 KdpReadPhysicalmemory(&ManipulateState, &Data, Context);
1111                 break;
1112
1113             case DbgKdWritePhysicalMemoryApi:
1114
1115                 /* Write  physical memory */
1116                 KdpWritePhysicalmemory(&ManipulateState, &Data, Context);
1117                 break;
1118
1119             case DbgKdQuerySpecialCallsApi:
1120
1121                 /* FIXME: TODO */
1122                 KdpDprintf("DbgKdQuerySpecialCallsApi called\n");
1123                 while (TRUE);
1124                 break;
1125
1126             case DbgKdSetSpecialCallApi:
1127
1128                 /* FIXME: TODO */
1129                 KdpDprintf("DbgKdSetSpecialCallApi called\n");
1130                 while (TRUE);
1131                 break;
1132
1133             case DbgKdClearSpecialCallsApi:
1134
1135                 /* FIXME: TODO */
1136                 KdpDprintf("DbgKdClearSpecialCallsApi called\n");
1137                 while (TRUE);
1138                 break;
1139
1140             case DbgKdSetInternalBreakPointApi:
1141
1142                 /* FIXME: TODO */
1143                 KdpDprintf("DbgKdSetInternalBreakPointApi called\n");
1144                 while (TRUE);
1145                 break;
1146
1147             case DbgKdGetInternalBreakPointApi:
1148
1149                 /* FIXME: TODO */
1150                 KdpDprintf("DbgKdGetInternalBreakPointApi called\n");
1151                 while (TRUE);
1152                 break;
1153
1154             case DbgKdReadIoSpaceExtendedApi:
1155
1156                 /* Read I/O Space */
1157                 KdpReadIoSpaceExtended(&ManipulateState, &Data, Context);
1158                 break;
1159
1160             case DbgKdWriteIoSpaceExtendedApi:
1161
1162                 /* Write I/O Space */
1163                 KdpWriteIoSpaceExtended(&ManipulateState, &Data, Context);
1164                 break;
1165
1166             case DbgKdGetVersionApi:
1167
1168                 /* Get version data */
1169                 KdpGetVersion(&ManipulateState);
1170                 break;
1171
1172             case DbgKdWriteBreakPointExApi:
1173
1174                 /* Write the breakpoint and check if it failed */
1175                 if (!NT_SUCCESS(KdpWriteBreakPointEx(&ManipulateState,
1176                                                      &Data,
1177                                                      Context)))
1178                 {
1179                     /* Return an error */
1180                     return ContinueError;
1181                 }
1182                 break;
1183
1184             case DbgKdRestoreBreakPointExApi:
1185
1186                 /* Restore the breakpoint */
1187                 KdpRestoreBreakPointEx(&ManipulateState, &Data, Context);
1188                 break;
1189
1190             case DbgKdCauseBugCheckApi:
1191
1192                 /* Crash the system */
1193                 KdpCauseBugCheck(&ManipulateState);
1194                 break;
1195
1196             case DbgKdSwitchProcessor:
1197
1198                 /* FIXME: TODO */
1199                 KdpDprintf("DbgKdSwitchProcessor called\n");
1200                 while (TRUE);
1201                 break;
1202
1203             case DbgKdPageInApi:
1204
1205                 /* FIXME: TODO */
1206                 KdpDprintf("DbgKdPageInApi called\n");
1207                 while (TRUE);
1208                 break;
1209
1210             case DbgKdReadMachineSpecificRegister:
1211
1212                 /* Read from the specified MSR */
1213                 KdpReadMachineSpecificRegister(&ManipulateState, &Data, Context);
1214                 break;
1215
1216             case DbgKdWriteMachineSpecificRegister:
1217
1218                 /* Write to the specified MSR */
1219                 KdpWriteMachineSpecificRegister(&ManipulateState, &Data, Context);
1220                 break;
1221
1222             case DbgKdSearchMemoryApi:
1223
1224                 /* Search memory */
1225                 KdpSearchMemory(&ManipulateState, &Data, Context);
1226                 break;
1227
1228             case DbgKdGetBusDataApi:
1229
1230                 /* Read from the bus */
1231                 KdpGetBusData(&ManipulateState, &Data, Context);
1232                 break;
1233
1234             case DbgKdSetBusDataApi:
1235
1236                 /* Write to the bus */
1237                 KdpSetBusData(&ManipulateState, &Data, Context);
1238                 break;
1239
1240             case DbgKdCheckLowMemoryApi:
1241
1242                 /* Check for memory corruption in the lower 4 GB */
1243                 KdpCheckLowMemory(&ManipulateState);
1244                 break;
1245
1246             case DbgKdClearAllInternalBreakpointsApi:
1247
1248                 /* Just clear the counter */
1249                 KdpNumInternalBreakpoints = 0;
1250                 break;
1251
1252             case DbgKdFillMemoryApi:
1253
1254                 /* Fill memory */
1255                 KdpFillMemory(&ManipulateState, &Data, Context);
1256                 break;
1257
1258             case DbgKdQueryMemoryApi:
1259
1260                 /* Query memory */
1261                 KdpQueryMemory(&ManipulateState, Context);
1262                 break;
1263
1264             case DbgKdSwitchPartition:
1265
1266                 /* FIXME: TODO */
1267                 KdpDprintf("DbgKdSwitchPartition called\n");
1268                 while (TRUE);
1269                 break;
1270
1271             /* Unsupported Message */
1272             default:
1273
1274                 /* Setup an empty message, with failure */
1275                 KdpDprintf("Received Unhandled API %lx\n", ManipulateState.ApiNumber);
1276                 Data.Length = 0;
1277                 ManipulateState.ReturnStatus = STATUS_UNSUCCESSFUL;
1278
1279                 /* Send it */
1280                 KdSendPacket(PACKET_TYPE_KD_STATE_MANIPULATE,
1281                              &Header,
1282                              &Data,
1283                              &KdpContext);
1284                 break;
1285         }
1286     }
1287 }
1288
1289 BOOLEAN
1290 NTAPI
1291 KdpReportLoadSymbolsStateChange(IN PSTRING PathName,
1292                                 IN PKD_SYMBOLS_INFO SymbolInfo,
1293                                 IN BOOLEAN Unload,
1294                                 IN OUT PCONTEXT Context)
1295 {
1296     PSTRING ExtraData;
1297     STRING Data, Header;
1298     DBGKD_WAIT_STATE_CHANGE64 WaitStateChange;
1299     KCONTINUE_STATUS Status;
1300
1301     /* Start wait loop */
1302     do
1303     {
1304         /* Build the architecture common parts of the message */
1305         KdpSetCommonState(DbgKdLoadSymbolsStateChange,
1306                           Context,
1307                           &WaitStateChange);
1308
1309         /* Now finish creating the structure */
1310         KdpSetContextState(&WaitStateChange, Context);
1311
1312         /* Fill out load data */
1313         WaitStateChange.u.LoadSymbols.UnloadSymbols = Unload;
1314         WaitStateChange.u.LoadSymbols.BaseOfDll = (ULONG64)(LONG_PTR)SymbolInfo->BaseOfDll;
1315         WaitStateChange.u.LoadSymbols.ProcessId = SymbolInfo->ProcessId;
1316         WaitStateChange.u.LoadSymbols.CheckSum = SymbolInfo->CheckSum;
1317         WaitStateChange.u.LoadSymbols.SizeOfImage = SymbolInfo->SizeOfImage;
1318
1319         /* Check if we have a symbol name */
1320         if (PathName)
1321         {
1322             /* Setup the information */
1323             WaitStateChange.u.LoadSymbols.PathNameLength = PathName->Length;
1324             RtlCopyMemory(KdpPathBuffer, PathName->Buffer, PathName->Length);
1325             Data.Buffer = KdpPathBuffer;
1326             Data.Length = WaitStateChange.u.LoadSymbols.PathNameLength;
1327             ExtraData = &Data;
1328         }
1329         else
1330         {
1331             /* No name */
1332             WaitStateChange.u.LoadSymbols.PathNameLength = 0;
1333             ExtraData = NULL;
1334         }
1335
1336         /* Setup the header */
1337         Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64);
1338         Header.Buffer = (PCHAR)&WaitStateChange;
1339
1340         /* Send the packet */
1341         Status = KdpSendWaitContinue(PACKET_TYPE_KD_STATE_CHANGE64,
1342                                      &Header,
1343                                      ExtraData,
1344                                      Context);
1345     } while (Status == ContinueProcessorReselected);
1346
1347     /* Return status */
1348     return Status;
1349 }
1350
1351 BOOLEAN
1352 NTAPI
1353 KdpReportExceptionStateChange(IN PEXCEPTION_RECORD ExceptionRecord,
1354                               IN OUT PCONTEXT Context,
1355                               IN BOOLEAN SecondChanceException)
1356 {
1357     STRING Header, Data;
1358     DBGKD_WAIT_STATE_CHANGE64 WaitStateChange;
1359     KCONTINUE_STATUS Status;
1360
1361     /* Start report loop */
1362     do
1363     {
1364         /* Build the architecture common parts of the message */
1365         KdpSetCommonState(DbgKdExceptionStateChange, Context, &WaitStateChange);
1366
1367         /* Copy the Exception Record and set First Chance flag */
1368         CopyExceptionRecord(ExceptionRecord,
1369                             &WaitStateChange.u.Exception.ExceptionRecord);
1370         WaitStateChange.u.Exception.FirstChance = !SecondChanceException;
1371
1372         /* Now finish creating the structure */
1373         KdpSetContextState(&WaitStateChange, Context);
1374
1375         /* Setup the actual header to send to KD */
1376         Header.Length = sizeof(DBGKD_WAIT_STATE_CHANGE64);
1377         Header.Buffer = (PCHAR)&WaitStateChange;
1378
1379         /* Setup the trace data */
1380         DumpTraceData(&Data);
1381
1382         /* Send State Change packet and wait for a reply */
1383         Status = KdpSendWaitContinue(PACKET_TYPE_KD_STATE_CHANGE64,
1384                                      &Header,
1385                                      &Data,
1386                                      Context);
1387     } while (Status == ContinueProcessorReselected);
1388
1389     /* Return */
1390     return Status;
1391 }
1392
1393 VOID
1394 NTAPI
1395 KdpTimeSlipDpcRoutine(IN PKDPC Dpc,
1396                       IN PVOID DeferredContext,
1397                       IN PVOID SystemArgument1,
1398                       IN PVOID SystemArgument2)
1399 {
1400     LONG OldSlip, NewSlip, PendingSlip;
1401
1402     /* Get the current pending slip */
1403     PendingSlip = KdpTimeSlipPending;
1404     do
1405     {
1406         /* Save the old value and either disable or enable it now. */
1407         OldSlip = PendingSlip;
1408         NewSlip = OldSlip > 1 ? 1 : 0;
1409
1410         /* Try to change the value */
1411     } while (InterlockedCompareExchange(&KdpTimeSlipPending,
1412                                         NewSlip,
1413                                         OldSlip) != OldSlip);
1414
1415     /* If the New Slip value is 1, then do the Time Slipping */
1416     if (NewSlip) ExQueueWorkItem(&KdpTimeSlipWorkItem, DelayedWorkQueue);
1417 }
1418
1419 VOID
1420 NTAPI
1421 KdpTimeSlipWork(IN PVOID Context)
1422 {
1423     KIRQL OldIrql;
1424     LARGE_INTEGER DueTime;
1425
1426     /* Update the System time from the CMOS */
1427     ExAcquireTimeRefreshLock(FALSE);
1428     ExUpdateSystemTimeFromCmos(FALSE, 0);
1429     ExReleaseTimeRefreshLock();
1430
1431     /* Check if we have a registered Time Slip Event and signal it */
1432     KeAcquireSpinLock(&KdpTimeSlipEventLock, &OldIrql);
1433     if (KdpTimeSlipEvent) KeSetEvent(KdpTimeSlipEvent, 0, FALSE);
1434     KeReleaseSpinLock(&KdpTimeSlipEventLock, OldIrql);
1435
1436     /* Delay the DPC until it runs next time */
1437     DueTime.QuadPart = -1800000000;
1438     KeSetTimer(&KdpTimeSlipTimer, DueTime, &KdpTimeSlipDpc);
1439 }
1440
1441 BOOLEAN
1442 NTAPI
1443 KdpSwitchProcessor(IN PEXCEPTION_RECORD ExceptionRecord,
1444                    IN OUT PCONTEXT ContextRecord,
1445                    IN BOOLEAN SecondChanceException)
1446 {
1447     BOOLEAN Status;
1448
1449     /* Save the port data */
1450     KdSave(FALSE);
1451
1452     /* Report a state change */
1453     Status = KdpReportExceptionStateChange(ExceptionRecord,
1454                                            ContextRecord,
1455                                            SecondChanceException);
1456
1457     /* Restore the port data and return */
1458     KdRestore(FALSE);
1459     return Status;
1460 }
1461
1462 LARGE_INTEGER
1463 NTAPI
1464 KdpQueryPerformanceCounter(IN PKTRAP_FRAME TrapFrame)
1465 {
1466     LARGE_INTEGER Null = {{0}};
1467
1468     /* Check if interrupts were disabled */
1469     if (!KeGetTrapFrameInterruptState(TrapFrame))
1470     {
1471         /* Nothing to return */
1472         return Null;
1473     }
1474
1475     /* Otherwise, do the call */
1476     return KeQueryPerformanceCounter(NULL);
1477 }
1478
1479 NTSTATUS
1480 NTAPI
1481 KdpAllowDisable(VOID)
1482 {
1483     /* Check if we are on MP */
1484     if (KeNumberProcessors > 1)
1485     {
1486         /* TODO */
1487         KdpDprintf("KdpAllowDisable: SMP UNHANDLED\n");
1488         while (TRUE);
1489     }
1490
1491     /* Allow disable */
1492     return STATUS_SUCCESS;
1493 }
1494
1495 BOOLEAN
1496 NTAPI
1497 KdEnterDebugger(IN PKTRAP_FRAME TrapFrame,
1498                 IN PKEXCEPTION_FRAME ExceptionFrame)
1499 {
1500     BOOLEAN Entered;
1501
1502     /* Check if we have a trap frame */
1503     if (TrapFrame)
1504     {
1505         /* Calculate the time difference for the enter */
1506         KdTimerStop = KdpQueryPerformanceCounter(TrapFrame);
1507         KdTimerDifference.QuadPart = KdTimerStop.QuadPart -
1508                                      KdTimerStart.QuadPart;
1509     }
1510     else
1511     {
1512         /* No trap frame, so can't calculate */
1513         KdTimerStop.QuadPart = 0;
1514     }
1515
1516     /* Save the current IRQL */
1517     KeGetCurrentPrcb()->DebuggerSavedIRQL = KeGetCurrentIrql();
1518
1519     /* Freeze all CPUs */
1520     Entered = KeFreezeExecution(TrapFrame, ExceptionFrame);
1521
1522     /* Lock the port, save the state and set debugger entered */
1523     KdpPortLocked = KeTryToAcquireSpinLockAtDpcLevel(&KdpDebuggerLock);
1524     KdSave(FALSE);
1525     KdEnteredDebugger = TRUE;
1526
1527     /* Check freeze flag */
1528     if (KiFreezeFlag & 1)
1529     {
1530         /* Print out errror */
1531         KdpDprintf("FreezeLock was jammed!  Backup SpinLock was used!\n");
1532     }
1533
1534     /* Check processor state */
1535     if (KiFreezeFlag & 2)
1536     {
1537         /* Print out errror */
1538         KdpDprintf("Some processors not frozen in debugger!\n");
1539     }
1540
1541     /* Make sure we acquired the port */
1542     if (!KdpPortLocked) KdpDprintf("Port lock was not acquired!\n");
1543
1544     /* Return enter state */
1545     return Entered;
1546 }
1547
1548 VOID
1549 NTAPI
1550 KdExitDebugger(IN BOOLEAN Entered)
1551 {
1552     ULONG TimeSlip;
1553
1554     /* Restore the state and unlock the port */
1555     KdRestore(FALSE);
1556     if (KdpPortLocked) KdpPortUnlock();
1557
1558     /* Unfreeze the CPUs */
1559     KeThawExecution(Entered);
1560
1561     /* Compare time with the one from KdEnterDebugger */
1562     if (!KdTimerStop.QuadPart)
1563     {
1564         /* We didn't get a trap frame earlier in so never got the time */
1565         KdTimerStart = KdTimerStop;
1566     }
1567     else
1568     {
1569         /* Query the timer */
1570         KdTimerStart = KeQueryPerformanceCounter(NULL);
1571     }
1572
1573     /* Check if a Time Slip was on queue */
1574     TimeSlip = InterlockedIncrement(&KdpTimeSlipPending);
1575     if (TimeSlip == 1)
1576     {
1577         /* Queue a DPC for the time slip */
1578         InterlockedIncrement(&KdpTimeSlipPending);
1579         KeInsertQueueDpc(&KdpTimeSlipDpc, NULL, NULL);
1580     }
1581 }
1582
1583 NTSTATUS
1584 NTAPI
1585 KdEnableDebuggerWithLock(IN BOOLEAN NeedLock)
1586 {
1587     KIRQL OldIrql;
1588
1589 #if defined(__GNUC__)
1590     /* Make gcc happy */
1591     OldIrql = PASSIVE_LEVEL;
1592 #endif
1593
1594     /* Check if enabling the debugger is blocked */
1595     if (KdBlockEnable)
1596     {
1597         /* It is, fail the enable */
1598         return STATUS_ACCESS_DENIED;
1599     }
1600
1601     /* Check if we need to acquire the lock */
1602     if (NeedLock)
1603     {
1604         /* Lock the port */
1605         KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
1606         KdpPortLock();
1607     }
1608
1609     /* Check if we're not disabled */
1610     if (!KdDisableCount)
1611     {
1612         /* Check if we had locked the port before */
1613         if (NeedLock)
1614         {
1615             /* Do the unlock */
1616             KeLowerIrql(OldIrql);
1617             KdpPortUnlock();
1618
1619             /* Fail: We're already enabled */
1620             return STATUS_INVALID_PARAMETER;
1621         }
1622         else
1623         {
1624             /*
1625              * This can only happen if we are called from a bugcheck
1626              * and were never initialized, so initialize the debugger now.
1627              */
1628             KdInitSystem(0, NULL);
1629
1630             /* Return success since we initialized */
1631             return STATUS_SUCCESS;
1632         }
1633     }
1634
1635     /* Decrease the disable count */
1636     if (!(--KdDisableCount))
1637     {
1638         /* We're now enabled again! Were we enabled before, too? */
1639         if (KdPreviouslyEnabled)
1640         {
1641             /* Reinitialize the Debugger */
1642             KdInitSystem(0, NULL) ;
1643             KdpRestoreAllBreakpoints();
1644         }
1645     }
1646
1647     /* Check if we had locked the port before */
1648     if (NeedLock)
1649     {
1650         /* Yes, now unlock it */
1651         KeLowerIrql(OldIrql);
1652         KdpPortUnlock();
1653     }
1654
1655     /* We're done */
1656     return STATUS_SUCCESS;
1657 }
1658
1659 NTSTATUS
1660 NTAPI
1661 KdDisableDebuggerWithLock(IN BOOLEAN NeedLock)
1662 {
1663     KIRQL OldIrql;
1664     NTSTATUS Status;
1665
1666 #if defined(__GNUC__)
1667     /* Make gcc happy */
1668     OldIrql = PASSIVE_LEVEL;
1669 #endif
1670
1671     /*
1672      * If enabling the debugger is blocked
1673      * then there is nothing to disable (duh)
1674      */
1675     if (KdBlockEnable)
1676     {
1677         /* Fail */
1678         return STATUS_ACCESS_DENIED;
1679     }
1680
1681     /* Check if we need to acquire the lock */
1682     if (NeedLock)
1683     {
1684         /* Lock the port */
1685         KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
1686         KdpPortLock();
1687     }
1688
1689     /* Check if we're not disabled */
1690     if (!KdDisableCount)
1691     {
1692         /* Check if the debugger was never actually initialized */
1693         if (!(KdDebuggerEnabled) && !(KdPitchDebugger))
1694         {
1695             /* It wasn't, so don't re-enable it later */
1696             KdPreviouslyEnabled = FALSE;
1697         }
1698         else
1699         {
1700             /* It was, so we will re-enable it later */
1701             KdPreviouslyEnabled = TRUE;
1702         }
1703
1704         /* Check if we were called from the exported API and are enabled */
1705         if ((NeedLock) && (KdPreviouslyEnabled))
1706         {
1707             /* Check if it is safe to disable the debugger */
1708             Status = KdpAllowDisable();
1709             if (!NT_SUCCESS(Status))
1710             {
1711                 /* Release the lock and fail */
1712                 KeLowerIrql(OldIrql);
1713                 KdpPortUnlock();
1714                 return Status;
1715             }
1716         }
1717
1718         /* Only disable the debugger if it is enabled */
1719         if (KdDebuggerEnabled)
1720         {
1721             /*
1722              * Disable the debugger; suspend breakpoints
1723              * and reset the debug stub
1724              */
1725             KdpSuspendAllBreakPoints();
1726             KiDebugRoutine = KdpStub;
1727
1728             /* We are disabled now */
1729             KdDebuggerEnabled = FALSE;
1730 #undef KdDebuggerEnabled
1731             SharedUserData->KdDebuggerEnabled = FALSE;
1732 #define KdDebuggerEnabled _KdDebuggerEnabled
1733         }
1734      }
1735
1736     /* Increment the disable count */
1737     KdDisableCount++;
1738
1739     /* Check if we had locked the port before */
1740     if (NeedLock)
1741     {
1742         /* Yes, now unlock it */
1743         KeLowerIrql(OldIrql);
1744         KdpPortUnlock();
1745     }
1746
1747     /* We're done */
1748     return STATUS_SUCCESS;
1749 }
1750
1751 /* PUBLIC FUNCTIONS **********************************************************/
1752
1753 /*
1754  * @implemented
1755  */
1756 NTSTATUS
1757 NTAPI
1758 KdEnableDebugger(VOID)
1759 {
1760     /* Use the internal routine */
1761     return KdEnableDebuggerWithLock(TRUE);
1762 }
1763
1764 /*
1765  * @implemented
1766  */
1767 NTSTATUS
1768 NTAPI
1769 KdDisableDebugger(VOID)
1770 {
1771     /* Use the internal routine */
1772     return KdDisableDebuggerWithLock(TRUE);
1773 }
1774
1775 /*
1776  * @unimplemented
1777  */
1778 NTSTATUS
1779 NTAPI
1780 KdSystemDebugControl(IN SYSDBG_COMMAND Command,
1781                      IN PVOID InputBuffer,
1782                      IN ULONG InputBufferLength,
1783                      OUT PVOID OutputBuffer,
1784                      IN ULONG OutputBufferLength,
1785                      IN OUT PULONG ReturnLength,
1786                      IN KPROCESSOR_MODE PreviousMode)
1787 {
1788     /* HACK */
1789     return STATUS_SUCCESS;
1790 }
1791
1792 /*
1793  * @unimplemented
1794  */
1795 NTSTATUS
1796 NTAPI
1797 KdChangeOption(IN KD_OPTION Option,
1798                IN ULONG InBufferBytes OPTIONAL,
1799                IN PVOID InBuffer,
1800                IN ULONG OutBufferBytes OPTIONAL,
1801                OUT PVOID OutBuffer,
1802                OUT PULONG OutBufferNeeded OPTIONAL)
1803 {
1804     /* HACK */
1805     return STATUS_SUCCESS;
1806 }
1807
1808 /*
1809  * @unimplemented
1810  */
1811 NTSTATUS
1812 NTAPI
1813 KdPowerTransition(IN DEVICE_POWER_STATE NewState)
1814 {
1815     /* HACK */
1816     return STATUS_SUCCESS;
1817 }
1818
1819 /*
1820  * @unimplemented
1821  */
1822 BOOLEAN
1823 NTAPI
1824 KdRefreshDebuggerNotPresent(VOID)
1825 {
1826     /* HACK */
1827     return KdDebuggerNotPresent;
1828 }
1829
1830 NTSTATUS
1831 NTAPI
1832 NtQueryDebugFilterState(ULONG ComponentId,
1833                         ULONG Level)
1834 {
1835     /* HACK */
1836     return STATUS_SUCCESS;
1837 }
1838
1839 NTSTATUS
1840 NTAPI
1841 NtSetDebugFilterState(ULONG ComponentId,
1842                       ULONG Level,
1843                       BOOLEAN State)
1844 {
1845     /* HACK */
1846     return STATUS_SUCCESS;
1847 }