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