2 Commond Debug Agent library implementition. It mainly includes
3 the first C function called by exception/interrupt handlers,
4 read/write debug packet to communication with HOST based on transfer
7 Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
8 This program and the accompanying materials
9 are licensed and made available under the terms and conditions of the BSD License
10 which accompanies this distribution. The full text of the license may be found at
11 http://opensource.org/licenses/bsd-license.php.
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 #include "DebugAgent.h"
19 #include "Ia32/DebugException.h"
21 GLOBAL_REMOVE_IF_UNREFERENCED CHAR8 mErrorMsgVersionAlert
[] = "\rThe SourceLevelDebugPkg you are using requires a newer version of the Intel(R) UDK Debugger Tool.\r\n";
22 GLOBAL_REMOVE_IF_UNREFERENCED CHAR8 mErrorMsgSendInitPacket
[] = "\rSend INIT break packet and try to connect the HOST (Intel(R) UDK Debugger Tool v1.4) ...\r\n";
23 GLOBAL_REMOVE_IF_UNREFERENCED CHAR8 mErrorMsgConnectOK
[] = "HOST connection is successful!\r\n";
24 GLOBAL_REMOVE_IF_UNREFERENCED CHAR8 mErrorMsgConnectFail
[] = "HOST connection is failed!\r\n";
25 GLOBAL_REMOVE_IF_UNREFERENCED CHAR8 mWarningMsgIngoreBreakpoint
[] = "Ignore break point in SMM for SMI issued during DXE debugging!\r\n";
28 // Vector Handoff Info list used by Debug Agent for persist
30 GLOBAL_REMOVE_IF_UNREFERENCED EFI_VECTOR_HANDOFF_INFO mVectorHandoffInfoDebugAgent
[] = {
32 DEBUG_EXCEPT_DIVIDE_ERROR
, // Vector 0
33 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
37 DEBUG_EXCEPT_DEBUG
, // Vector 1
38 EFI_VECTOR_HANDOFF_DO_NOT_HOOK
,
42 DEBUG_EXCEPT_NMI
, // Vector 2
43 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
47 DEBUG_EXCEPT_BREAKPOINT
, // Vector 3
48 EFI_VECTOR_HANDOFF_DO_NOT_HOOK
,
52 DEBUG_EXCEPT_OVERFLOW
, // Vector 4
53 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
57 DEBUG_EXCEPT_BOUND
, // Vector 5
58 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
62 DEBUG_EXCEPT_INVALID_OPCODE
, // Vector 6
63 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
67 DEBUG_EXCEPT_DOUBLE_FAULT
, // Vector 8
68 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
72 DEBUG_EXCEPT_INVALID_TSS
, // Vector 10
73 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
77 DEBUG_EXCEPT_SEG_NOT_PRESENT
, // Vector 11
78 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
82 DEBUG_EXCEPT_STACK_FAULT
, // Vector 12
83 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
87 DEBUG_EXCEPT_GP_FAULT
, // Vector 13
88 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
92 DEBUG_EXCEPT_PAGE_FAULT
, // Vector 14
93 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
97 DEBUG_EXCEPT_FP_ERROR
, // Vector 16
98 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
102 DEBUG_EXCEPT_ALIGNMENT_CHECK
, // Vector 17
103 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
107 DEBUG_EXCEPT_MACHINE_CHECK
, // Vector 18
108 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
112 DEBUG_EXCEPT_SIMD
, // Vector 19
113 EFI_VECTOR_HANDOFF_HOOK_BEFORE
,
117 DEBUG_TIMER_VECTOR
, // Vector 32
118 EFI_VECTOR_HANDOFF_DO_NOT_HOOK
,
122 DEBUG_MAILBOX_VECTOR
, // Vector 33
123 EFI_VECTOR_HANDOFF_DO_NOT_HOOK
,
128 EFI_VECTOR_HANDOFF_LAST_ENTRY
,
133 GLOBAL_REMOVE_IF_UNREFERENCED UINTN mVectorHandoffInfoCount
= sizeof (mVectorHandoffInfoDebugAgent
) / sizeof (EFI_VECTOR_HANDOFF_INFO
);
136 Calculate CRC16 for target data.
138 @param[in] Data The target data.
139 @param[in] DataSize The target data size.
140 @param[in] Crc Initial CRC.
142 @return UINT16 The CRC16 value.
155 for (Index
= 0; Index
< DataSize
; Index
++) {
156 Crc
^= (UINT16
)Data
[Index
];
157 for (BitIndex
= 0; BitIndex
< 8; BitIndex
++) {
158 if ((Crc
& 0x8000) != 0) {
171 Read IDT entry to check if IDT entries are setup by Debug Agent.
173 @retval TRUE IDT entries were setup by Debug Agent.
174 @retval FALSE IDT entries were not setup by Debug Agent.
178 IsDebugAgentInitialzed (
182 UINTN InterruptHandler
;
184 InterruptHandler
= (UINTN
) GetExceptionHandlerInIdtEntry (0);
185 if (InterruptHandler
>= 4 && *(UINT32
*)(InterruptHandler
- 4) == AGENT_HANDLER_SIGNATURE
) {
193 Find and report module image info to HOST.
195 @param[in] AlignSize Image aligned size.
199 FindAndReportModuleImageInfo (
204 EFI_IMAGE_DOS_HEADER
*DosHdr
;
205 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr
;
206 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext
;
211 Pe32Data
= ((UINTN
)mErrorMsgVersionAlert
) & ~(AlignSize
- 1);
212 while (Pe32Data
!= 0) {
213 DosHdr
= (EFI_IMAGE_DOS_HEADER
*) Pe32Data
;
214 if (DosHdr
->e_magic
== EFI_IMAGE_DOS_SIGNATURE
) {
216 // DOS image header is present, so read the PE header after the DOS image header.
218 Hdr
.Pe32
= (EFI_IMAGE_NT_HEADERS32
*)(Pe32Data
+ (UINTN
) ((DosHdr
->e_lfanew
) & 0x0ffff));
220 // Make sure PE header address does not overflow and is less than the initial address.
222 if (((UINTN
)Hdr
.Pe32
> Pe32Data
) && ((UINTN
)Hdr
.Pe32
< (UINTN
)mErrorMsgVersionAlert
)) {
223 if (Hdr
.Pe32
->Signature
== EFI_IMAGE_NT_SIGNATURE
) {
232 // DOS image header is not present, TE header is at the image base.
234 Hdr
.Pe32
= (EFI_IMAGE_NT_HEADERS32
*)Pe32Data
;
235 if ((Hdr
.Te
->Signature
== EFI_TE_IMAGE_HEADER_SIGNATURE
) &&
236 ((Hdr
.Te
->Machine
== IMAGE_FILE_MACHINE_I386
) || Hdr
.Te
->Machine
== IMAGE_FILE_MACHINE_X64
)) {
238 // It's TE image, it TE header and Machine type match
245 // Not found the image base, check the previous aligned address
247 Pe32Data
-= AlignSize
;
250 ImageContext
.ImageAddress
= Pe32Data
;
251 ImageContext
.PdbPointer
= PeCoffLoaderGetPdbPointer ((VOID
*) (UINTN
) ImageContext
.ImageAddress
);
252 PeCoffLoaderRelocateImageExtraAction (&ImageContext
);
256 Trigger one software interrupt to debug agent to handle it.
258 @param[in] Signature Software interrupt signature.
262 TriggerSoftInterrupt (
270 // Save Debug Register State
278 AsmWriteDr0 (SOFT_INTERRUPT_SIGNATURE
);
279 AsmWriteDr1 (Signature
);
282 // Do INT3 to communicate with HOST side
287 // Restore Debug Register State only when Host didn't change it inside exception handler.
288 // Dr registers can only be changed by setting the HW breakpoint.
296 Calculate Mailbox checksum and update the checksum field.
298 @param[in] Mailbox Debug Agent Mailbox pointer.
302 UpdateMailboxChecksum (
303 IN DEBUG_AGENT_MAILBOX
*Mailbox
306 Mailbox
->CheckSum
= CalculateCheckSum8 ((UINT8
*)Mailbox
, sizeof (DEBUG_AGENT_MAILBOX
) - 2);
310 Verify Mailbox checksum.
312 If checksum error, print debug message and run init dead loop.
314 @param[in] Mailbox Debug Agent Mailbox pointer.
318 VerifyMailboxChecksum (
319 IN DEBUG_AGENT_MAILBOX
*Mailbox
324 CheckSum
= CalculateCheckSum8 ((UINT8
*) Mailbox
, sizeof (DEBUG_AGENT_MAILBOX
) - 2);
326 // The checksum updating process may be disturbed by hardware SMI, we need to check CheckSum field
327 // and ToBeCheckSum field to validate the mail box.
329 if (CheckSum
!= Mailbox
->CheckSum
&& CheckSum
!= Mailbox
->ToBeCheckSum
) {
330 DEBUG ((EFI_D_ERROR
, "DebugAgent: Mailbox checksum error, stack or heap crashed!\n"));
331 DEBUG ((EFI_D_ERROR
, "DebugAgent: CheckSum = %x, Mailbox->CheckSum = %x, Mailbox->ToBeCheckSum = %x\n", CheckSum
, Mailbox
->CheckSum
, Mailbox
->ToBeCheckSum
));
337 Update Mailbox content by index.
339 @param[in] Mailbox Debug Agent Mailbox pointer.
340 @param[in] Index Mailbox content index.
341 @param[in] Value Value to be set into Mailbox.
345 UpdateMailboxContent (
346 IN DEBUG_AGENT_MAILBOX
*Mailbox
,
351 AcquireMpSpinLock (&mDebugMpContext
.MailboxSpinLock
);
353 case DEBUG_MAILBOX_DEBUG_FLAG_INDEX
:
354 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->DebugFlag
.Uint64
, sizeof(UINT64
))
355 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINT64
));
356 Mailbox
->DebugFlag
.Uint64
= Value
;
358 case DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX
:
359 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->DebugPortHandle
, sizeof(UINTN
))
360 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINTN
));
361 Mailbox
->DebugPortHandle
= (UINTN
) Value
;
363 case DEBUG_MAILBOX_EXCEPTION_BUFFER_POINTER_INDEX
:
364 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->ExceptionBufferPointer
, sizeof(UINTN
))
365 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINTN
));
366 Mailbox
->ExceptionBufferPointer
= (UINTN
) Value
;
368 case DEBUG_MAILBOX_LAST_ACK
:
369 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->LastAck
, sizeof(UINT8
))
370 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINT8
));
371 Mailbox
->LastAck
= (UINT8
) Value
;
373 case DEBUG_MAILBOX_SEQUENCE_NO_INDEX
:
374 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->SequenceNo
, sizeof(UINT8
))
375 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINT8
));
376 Mailbox
->SequenceNo
= (UINT8
) Value
;
378 case DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
:
379 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->HostSequenceNo
, sizeof(UINT8
))
380 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINT8
));
381 Mailbox
->HostSequenceNo
= (UINT8
) Value
;
383 case DEBUG_MAILBOX_DEBUG_TIMER_FREQUENCY
:
384 Mailbox
->ToBeCheckSum
= Mailbox
->CheckSum
+ CalculateSum8 ((UINT8
*)&Mailbox
->DebugTimerFrequency
, sizeof(UINT32
))
385 - CalculateSum8 ((UINT8
*)&Value
, sizeof(UINT32
));
386 Mailbox
->DebugTimerFrequency
= (UINT32
) Value
;
389 UpdateMailboxChecksum (Mailbox
);
390 ReleaseMpSpinLock (&mDebugMpContext
.MailboxSpinLock
);
394 Read data from debug device and save the data in buffer.
396 Reads NumberOfBytes data bytes from a debug device into the buffer
397 specified by Buffer. The number of bytes actually read is returned.
398 If the return value is less than NumberOfBytes, then the rest operation failed.
399 If NumberOfBytes is zero, then return 0.
401 @param Handle Debug port handle.
402 @param Buffer Pointer to the data buffer to store the data read from the debug device.
403 @param NumberOfBytes Number of bytes which will be read.
404 @param Timeout Timeout value for reading from debug device. It unit is Microsecond.
406 @retval 0 Read data failed, no data is to be read.
407 @retval >0 Actual number of bytes read from debug device.
411 DebugAgentReadBuffer (
412 IN DEBUG_PORT_HANDLE Handle
,
414 IN UINTN NumberOfBytes
,
420 UINT32 TimeoutTicker
;
422 UINT32 TimerFrequency
;
428 TimerFrequency
= GetMailboxPointer()->DebugTimerFrequency
;
429 TimerCycle
= GetApicTimerInitCount ();
432 Begin
= GetApicTimerCurrentCount ();
433 TimeoutTicker
= (UINT32
) DivU64x32 (
440 TimerRound
= (UINT32
) DivU64x32Remainder (TimeoutTicker
, TimerCycle
/ 2, &TimeoutTicker
);
443 while (Index
< NumberOfBytes
) {
444 if (DebugPortPollBuffer (Handle
)) {
445 DebugPortReadBuffer (Handle
, Buffer
+ Index
, 1, 0);
450 if (TimerRound
== 0) {
451 if (IsDebugTimerTimeout (TimerCycle
, Begin
, TimeoutTicker
)) {
453 // If time out occurs.
458 if (IsDebugTimerTimeout (TimerCycle
, Begin
, TimerCycle
/ 2)) {
460 Begin
= GetApicTimerCurrentCount ();
470 Set debug flag in mailbox.
472 @param[in] FlagMask Debug flag mask value.
473 @param[in] FlagValue Debug flag value.
482 DEBUG_AGENT_MAILBOX
*Mailbox
;
485 Mailbox
= GetMailboxPointer ();
486 Data64
= (Mailbox
->DebugFlag
.Uint64
& ~FlagMask
) |
487 (LShiftU64 ((UINT64
)FlagValue
, LowBitSet64 (FlagMask
)) & FlagMask
);
488 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_DEBUG_FLAG_INDEX
, Data64
);
492 Get debug flag in mailbox.
494 @param[in] FlagMask Debug flag mask value.
496 @return Debug flag value.
504 DEBUG_AGENT_MAILBOX
*Mailbox
;
507 Mailbox
= GetMailboxPointer ();
508 DebugFlag
= (UINT32
) RShiftU64 (Mailbox
->DebugFlag
.Uint64
& FlagMask
, LowBitSet64 (FlagMask
));
514 Send a debug message packet to the debug port.
516 @param[in] Buffer The debug message.
517 @param[in] Length The length of debug message.
526 DEBUG_PACKET_HEADER DebugHeader
;
527 DEBUG_PORT_HANDLE Handle
;
529 Handle
= GetDebugPortHandle();
531 DebugHeader
.StartSymbol
= DEBUG_STARTING_SYMBOL_NORMAL
;
532 DebugHeader
.Command
= DEBUG_COMMAND_PRINT_MESSAGE
;
533 DebugHeader
.Length
= sizeof (DEBUG_PACKET_HEADER
) + (UINT8
) Length
;
534 DebugHeader
.SequenceNo
= 0xEE;
536 DebugHeader
.Crc
= CalculateCrc16 (
537 (UINT8
*)Buffer
, Length
,
538 CalculateCrc16 ((UINT8
*)&DebugHeader
, sizeof (DEBUG_PACKET_HEADER
), 0)
541 DebugPortWriteBuffer (Handle
, (UINT8
*)&DebugHeader
, sizeof (DEBUG_PACKET_HEADER
));
542 DebugPortWriteBuffer (Handle
, (UINT8
*)Buffer
, Length
);
546 Prints a debug message to the debug port if the specified error level is enabled.
548 If any bit in ErrorLevel is also set in Mainbox, then print the message specified
549 by Format and the associated variable argument list to the debug port.
551 @param[in] ErrorLevel The error level of the debug message.
552 @param[in] Format Format string for the debug message to print.
553 @param[in] ... Variable argument list whose contents are accessed
554 based on the format string specified by Format.
565 CHAR8 Buffer
[DEBUG_DATA_MAXIMUM_REAL_DATA
];
569 // Check driver debug mask value and global mask
571 if ((ErrorLevel
& GetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL
)) == 0) {
576 // Convert the DEBUG() message to an ASCII String
578 VA_START (Marker
, Format
);
579 AsciiVSPrint (Buffer
, sizeof (Buffer
), Format
, Marker
);
582 SendDebugMsgPacket (Buffer
, AsciiStrLen (Buffer
));
586 Prints a debug message to the debug output device if the specified error level is enabled.
588 If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function
589 GetDebugPrintErrorLevel (), then print the message specified by Format and the
590 associated variable argument list to the debug output device.
592 If Format is NULL, then ASSERT().
594 @param[in] ErrorLevel The error level of the debug message.
595 @param[in] IsSend Flag of debug message to declare that the data is being sent or being received.
596 @param[in] Data Variable argument list whose contents are accessed
597 @param[in] Length based on the format string specified by Format.
602 DebugAgentDataMsgPrint (
609 CHAR8 Buffer
[DEBUG_DATA_MAXIMUM_REAL_DATA
];
614 // Check driver debug mask value and global mask
616 if ((ErrorLevel
& GetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL
)) == 0) {
622 DestBuffer
+= AsciiSPrint (DestBuffer
, DEBUG_DATA_MAXIMUM_REAL_DATA
, "Sent data [ ");
624 DestBuffer
+= AsciiSPrint (DestBuffer
, DEBUG_DATA_MAXIMUM_REAL_DATA
, "Received data [ ");
629 if (DestBuffer
- Buffer
> DEBUG_DATA_MAXIMUM_REAL_DATA
- 6) {
631 // If there was no enough space in buffer, send out the debug message,
632 // reserving 6 bytes is for the last data and end characters "]\n".
634 SendDebugMsgPacket (Buffer
, DestBuffer
- Buffer
);
637 DestBuffer
+= AsciiSPrint (DestBuffer
, DEBUG_DATA_MAXIMUM_REAL_DATA
- (DestBuffer
- Buffer
), "%02x ", Data
[Index
]);
639 if (Index
>= Length
) {
641 // The last character of debug message has been foramtted in buffer
643 DestBuffer
+= AsciiSPrint(DestBuffer
, DEBUG_DATA_MAXIMUM_REAL_DATA
- (DestBuffer
- Buffer
), "]\n");
644 SendDebugMsgPacket (Buffer
, DestBuffer
- Buffer
);
651 Read remaing debug packet except for the start symbol
653 @param[in] Handle Pointer to Debug Port handle.
654 @param[in, out] DebugHeader Debug header buffer including start symbol.
656 @retval EFI_SUCCESS Read the symbol in BreakSymbol.
657 @retval EFI_CRC_ERROR CRC check fail.
658 @retval EFI_TIMEOUT Timeout occurs when reading debug packet.
659 @retval EFI_DEVICE_ERROR Receive the old or responsed packet.
663 ReadRemainingBreakPacket (
664 IN DEBUG_PORT_HANDLE Handle
,
665 IN OUT DEBUG_PACKET_HEADER
*DebugHeader
669 DEBUG_AGENT_MAILBOX
*Mailbox
;
672 // Has received start symbol, try to read the rest part
674 if (DebugAgentReadBuffer (Handle
, (UINT8
*)DebugHeader
+ OFFSET_OF (DEBUG_PACKET_HEADER
, Command
), sizeof (DEBUG_PACKET_HEADER
) - OFFSET_OF (DEBUG_PACKET_HEADER
, Command
), READ_PACKET_TIMEOUT
) == 0) {
676 // Timeout occur, exit
678 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "Timeout in Debug Timer interrupt\n");
682 Crc
= DebugHeader
->Crc
;
683 DebugHeader
->Crc
= 0;
684 if (CalculateCrc16 ((UINT8
*)DebugHeader
, DebugHeader
->Length
, 0) != Crc
) {
685 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "Debug Timer CRC (%x) against (%x)\n", Crc
, CalculateCrc16 ((UINT8
*) &DebugHeader
, DebugHeader
->Length
, 0));
686 DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE
, FALSE
, (UINT8
*)DebugHeader
, DebugHeader
->Length
);
687 return EFI_CRC_ERROR
;
689 Mailbox
= GetMailboxPointer();
690 if (IS_REQUEST (DebugHeader
)) {
691 if (DebugHeader
->SequenceNo
== (UINT8
) (Mailbox
->HostSequenceNo
+ 1)) {
693 // Only updagte HostSequenceNo for new command packet
695 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
, DebugHeader
->SequenceNo
);
698 if (DebugHeader
->SequenceNo
== Mailbox
->HostSequenceNo
) {
703 return EFI_DEVICE_ERROR
;
707 Check if HOST is attached based on Mailbox.
709 @retval TRUE HOST is attached.
710 @retval FALSE HOST is not attached.
718 return (BOOLEAN
) (GetDebugFlag (DEBUG_AGENT_FLAG_HOST_ATTACHED
) == 1);
722 Set HOST connect flag in Mailbox.
724 @param[in] Attached Attach status.
732 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "Attach status is %d\n", Attached
);
733 SetDebugFlag (DEBUG_AGENT_FLAG_HOST_ATTACHED
, (UINT32
)Attached
);
737 Set debug setting of Debug Agent in Mailbox.
739 @param DebugSetting Pointer to Debug Setting defined by transfer protocol.
741 @retval RETURN_SUCCESS The setting is set successfully.
742 @retval RETURN_UNSUPPORTED The Key value is not supported.
747 IN DEBUG_DATA_SET_DEBUG_SETTING
*DebugSetting
750 RETURN_STATUS Status
;
752 Status
= RETURN_SUCCESS
;
753 switch (DebugSetting
->Key
) {
754 case DEBUG_AGENT_SETTING_SMM_ENTRY_BREAK
:
755 SetDebugFlag (DEBUG_AGENT_FLAG_BREAK_ON_NEXT_SMI
, DebugSetting
->Value
);
757 case DEBUG_AGENT_SETTING_PRINT_ERROR_LEVEL
:
758 SetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL
, DebugSetting
->Value
);
760 case DEBUG_AGENT_SETTING_BOOT_SCRIPT_ENTRY_BREAK
:
761 SetDebugFlag (DEBUG_AGENT_FLAG_BREAK_BOOT_SCRIPT
, DebugSetting
->Value
);
764 Status
= RETURN_UNSUPPORTED
;
772 @param[in] CpuContext Pointer to saved CPU context.
777 IN DEBUG_CPU_CONTEXT
*CpuContext
780 IA32_EFLAGS32
*Eflags
;
782 Eflags
= (IA32_EFLAGS32
*) &CpuContext
->Eflags
;
788 Execute Stepping command.
790 @param[in] CpuContext Pointer to saved CPU context.
795 IN DEBUG_CPU_CONTEXT
*CpuContext
798 IA32_EFLAGS32
*Eflags
;
800 Eflags
= (IA32_EFLAGS32
*) &CpuContext
->Eflags
;
804 // Save and clear EFLAGS.IF to avoid interrupt happen when executing Stepping
806 SetDebugFlag (DEBUG_AGENT_FLAG_INTERRUPT_FLAG
, Eflags
->Bits
.IF
);
811 SetDebugFlag (DEBUG_AGENT_FLAG_STEPPING
, 1);
815 Do some cleanup after Stepping command done.
817 @param[in] CpuContext Pointer to saved CPU context.
821 CommandSteppingCleanup (
822 IN DEBUG_CPU_CONTEXT
*CpuContext
825 IA32_EFLAGS32
*Eflags
;
827 Eflags
= (IA32_EFLAGS32
*) &CpuContext
->Eflags
;
831 Eflags
->Bits
.IF
= GetDebugFlag (DEBUG_AGENT_FLAG_INTERRUPT_FLAG
);
833 // Clear Stepping flag
835 SetDebugFlag (DEBUG_AGENT_FLAG_STEPPING
, 0);
839 Set debug register for hardware breakpoint.
841 @param[in] CpuContext Pointer to saved CPU context.
842 @param[in] SetHwBreakpoint Hardware breakpoint to be set.
847 IN DEBUG_CPU_CONTEXT
*CpuContext
,
848 IN DEBUG_DATA_SET_HW_BREAKPOINT
*SetHwBreakpoint
854 RegisterIndex
= SetHwBreakpoint
->Type
.Index
;
859 * ((UINTN
*) &CpuContext
->Dr0
+ RegisterIndex
) = (UINTN
) SetHwBreakpoint
->Address
;
861 Dr7Value
= CpuContext
->Dr7
;
866 Dr7Value
|= (UINTN
) (0x3 << (RegisterIndex
* 2));
870 Dr7Value
&= (UINTN
) (~(0xf << (16 + RegisterIndex
* 4)));
871 Dr7Value
|= (UINTN
) ((SetHwBreakpoint
->Type
.Length
<< 2) | SetHwBreakpoint
->Type
.Access
) << (16 + RegisterIndex
* 4);
877 CpuContext
->Dr7
= Dr7Value
;
881 Clear debug register for hardware breakpoint.
883 @param[in] CpuContext Pointer to saved CPU context.
884 @param[in] ClearHwBreakpoint Hardware breakpoint to be cleared.
889 IN DEBUG_CPU_CONTEXT
*CpuContext
,
890 IN DEBUG_DATA_CLEAR_HW_BREAKPOINT
*ClearHwBreakpoint
893 if ((ClearHwBreakpoint
->IndexMask
& BIT0
) != 0) {
895 CpuContext
->Dr7
&= (UINTN
)(~(0x3 << 0));
897 if ((ClearHwBreakpoint
->IndexMask
& BIT1
) != 0) {
899 CpuContext
->Dr7
&= (UINTN
)(~(0x3 << 2));
901 if ((ClearHwBreakpoint
->IndexMask
& BIT2
) != 0) {
903 CpuContext
->Dr7
&= (UINTN
)(~(0x3 << 4));
905 if ((ClearHwBreakpoint
->IndexMask
& BIT3
) != 0) {
907 CpuContext
->Dr7
&= (UINTN
)(~(0x3 << 6));
913 Return the offset of FP / MMX / XMM registers in the FPU saved state by register index.
915 @param[in] Index Register index.
916 @param[out] Width Register width returned.
918 @return Offset in the FPU Save State.
922 ArchReadFxStatOffset (
927 if (Index
< SOFT_DEBUGGER_REGISTER_ST0
) {
929 case SOFT_DEBUGGER_REGISTER_FP_FCW
:
930 *Width
= (UINT8
) sizeof (UINT16
);
931 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Fcw
);
933 case SOFT_DEBUGGER_REGISTER_FP_FSW
:
934 *Width
= (UINT8
) sizeof (UINT16
);
935 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Fsw
);
937 case SOFT_DEBUGGER_REGISTER_FP_FTW
:
938 *Width
= (UINT8
) sizeof (UINT16
);
939 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Ftw
);
941 case SOFT_DEBUGGER_REGISTER_FP_OPCODE
:
942 *Width
= (UINT8
) sizeof (UINT16
);
943 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Opcode
);
945 case SOFT_DEBUGGER_REGISTER_FP_EIP
:
946 *Width
= (UINT8
) sizeof (UINT32
);
947 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Eip
);
949 case SOFT_DEBUGGER_REGISTER_FP_CS
:
950 *Width
= (UINT8
) sizeof (UINT16
);
951 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Cs
);
953 case SOFT_DEBUGGER_REGISTER_FP_DATAOFFSET
:
954 *Width
= (UINT8
) sizeof (UINT32
);
955 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, DataOffset
);
957 case SOFT_DEBUGGER_REGISTER_FP_DS
:
958 *Width
= (UINT8
) sizeof (UINT16
);
959 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Ds
);
961 case SOFT_DEBUGGER_REGISTER_FP_MXCSR
:
962 *Width
= (UINT8
) sizeof (UINT32
);
963 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Mxcsr
);
965 case SOFT_DEBUGGER_REGISTER_FP_MXCSR_MASK
:
966 *Width
= (UINT8
) sizeof (UINT32
);
967 return OFFSET_OF(DEBUG_DATA_FX_SAVE_STATE
, Mxcsr_Mask
);
971 if (Index
<= SOFT_DEBUGGER_REGISTER_ST7
) {
973 } else if (Index
<= SOFT_DEBUGGER_REGISTER_XMM15
) {
980 Index
-= SOFT_DEBUGGER_REGISTER_MM0
- SOFT_DEBUGGER_REGISTER_ST0
;
983 return OFFSET_OF (DEBUG_DATA_FX_SAVE_STATE
, St0Mm0
) + (Index
- SOFT_DEBUGGER_REGISTER_ST0
) * 16;
987 Return the pointer of the register value in the CPU saved context.
989 @param[in] CpuContext Pointer to saved CPU context.
990 @param[in] Index Register index value.
991 @param[out] Width Data width to read.
993 @return The pointer in the CPU saved context.
997 ArchReadRegisterBuffer (
998 IN DEBUG_CPU_CONTEXT
*CpuContext
,
1005 if (Index
< SOFT_DEBUGGER_REGISTER_FP_BASE
) {
1006 Buffer
= (UINT8
*) CpuContext
+ OFFSET_OF (DEBUG_CPU_CONTEXT
, Dr0
) + Index
* sizeof (UINTN
);
1007 *Width
= (UINT8
) sizeof (UINTN
);
1010 // FPU/MMX/XMM registers
1012 Buffer
= (UINT8
*) CpuContext
+ OFFSET_OF (DEBUG_CPU_CONTEXT
, FxSaveState
) + ArchReadFxStatOffset (Index
, Width
);
1019 Send the packet without data to HOST.
1021 @param[in] CommandType Type of Command.
1022 @param[in] SequenceNo Sequence number.
1026 SendPacketWithoutData (
1027 IN UINT8 CommandType
,
1031 DEBUG_PACKET_HEADER DebugHeader
;
1032 DEBUG_PORT_HANDLE Handle
;
1034 Handle
= GetDebugPortHandle();
1036 DebugHeader
.StartSymbol
= DEBUG_STARTING_SYMBOL_NORMAL
;
1037 DebugHeader
.Command
= CommandType
;
1038 DebugHeader
.Length
= sizeof (DEBUG_PACKET_HEADER
);
1039 DebugHeader
.SequenceNo
= SequenceNo
;
1040 DebugHeader
.Crc
= 0;
1041 DebugHeader
.Crc
= CalculateCrc16 ((UINT8
*)&DebugHeader
, sizeof (DEBUG_PACKET_HEADER
), 0);
1043 DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE
, TRUE
, (UINT8
*) &DebugHeader
, DebugHeader
.Length
);
1044 DebugPortWriteBuffer (Handle
, (UINT8
*) &DebugHeader
, DebugHeader
.Length
);
1048 Send acknowledge packet to HOST.
1050 @param[in] AckCommand Type of Acknowledge packet.
1059 DEBUG_AGENT_MAILBOX
*Mailbox
;
1061 if (AckCommand
!= DEBUG_COMMAND_OK
) {
1063 // This is not ACK OK packet
1065 DebugAgentMsgPrint (DEBUG_AGENT_ERROR
, "Send ACK(%d)\n", AckCommand
);
1067 Mailbox
= GetMailboxPointer();
1068 SequenceNo
= Mailbox
->HostSequenceNo
;
1069 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "SendAckPacket: SequenceNo = %x\n", SequenceNo
);
1070 SendPacketWithoutData (AckCommand
, SequenceNo
);
1071 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_LAST_ACK
, AckCommand
);
1075 Decompress the Data in place.
1077 @param[in, out] Data The compressed data buffer.
1078 The buffer is assumed large enough to hold the uncompressed data.
1079 @param[in] Length The length of the compressed data buffer.
1081 @return The length of the uncompressed data buffer.
1084 DecompressDataInPlace (
1091 UINTN LastCharCount
;
1094 LastChar
= (UINT16
) -1;
1096 for (Index
= 0; Index
< Length
; Index
++) {
1097 CurrentChar
= Data
[Index
];
1098 if (LastCharCount
== 2) {
1100 CopyMem (&Data
[Index
+ CurrentChar
], &Data
[Index
+ 1], Length
- Index
- 1);
1101 SetMem (&Data
[Index
], CurrentChar
, (UINT8
) LastChar
);
1102 LastChar
= (UINT16
) -1;
1103 Index
+= CurrentChar
- 1;
1104 Length
+= CurrentChar
- 1;
1106 if (LastChar
!= CurrentChar
) {
1110 LastChar
= CurrentChar
;
1114 ASSERT (Length
<= DEBUG_DATA_MAXIMUM_REAL_DATA
);
1116 return (UINT8
) Length
;
1120 Receive valid packet from HOST.
1122 @param[out] InputPacket Buffer to receive packet.
1123 @param[out] BreakReceived TRUE means break-in symbol received.
1124 FALSE means break-in symbol not received.
1125 @param[out] IncompatibilityFlag If IncompatibilityFlag is not NULL, return
1126 TRUE: Compatible packet received.
1127 FALSE: Incompatible packet received.
1128 @param[in] Timeout Time out value to wait for acknowlege from HOST.
1129 The unit is microsecond.
1130 @param[in] SkipStartSymbol TRUE: Skip time out when reading start symbol.
1131 FALSE: Does not Skip time out when reading start symbol.
1133 @retval RETURN_SUCCESS A valid package was reveived in InputPacket.
1134 @retval RETURN_TIMEOUT Timeout occurs.
1139 OUT UINT8
*InputPacket
,
1140 OUT BOOLEAN
*BreakReceived
,
1141 OUT BOOLEAN
*IncompatibilityFlag
, OPTIONAL
1143 IN BOOLEAN SkipStartSymbol
1146 DEBUG_PACKET_HEADER
*DebugHeader
;
1148 DEBUG_PORT_HANDLE Handle
;
1150 UINTN TimeoutForStartSymbol
;
1152 Handle
= GetDebugPortHandle();
1153 if (SkipStartSymbol
) {
1154 TimeoutForStartSymbol
= 0;
1156 TimeoutForStartSymbol
= Timeout
;
1159 DebugHeader
= (DEBUG_PACKET_HEADER
*) InputPacket
;
1162 // Find the valid start symbol
1164 Received
= DebugAgentReadBuffer (Handle
, &DebugHeader
->StartSymbol
, sizeof (DebugHeader
->StartSymbol
), TimeoutForStartSymbol
);
1165 if (Received
< sizeof (DebugHeader
->StartSymbol
)) {
1166 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "DebugAgentReadBuffer(StartSymbol) timeout\n");
1167 return RETURN_TIMEOUT
;
1170 if ((DebugHeader
->StartSymbol
!= DEBUG_STARTING_SYMBOL_NORMAL
) && (DebugHeader
->StartSymbol
!= DEBUG_STARTING_SYMBOL_COMPRESS
)) {
1171 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "Invalid start symbol received [%02x]\n", DebugHeader
->StartSymbol
);
1176 // Read Package header till field Length
1178 Received
= DebugAgentReadBuffer (
1180 (UINT8
*) DebugHeader
+ OFFSET_OF (DEBUG_PACKET_HEADER
, Command
),
1181 OFFSET_OF (DEBUG_PACKET_HEADER
, Length
) + sizeof (DebugHeader
->Length
) - sizeof (DebugHeader
->StartSymbol
),
1184 if (Received
== 0) {
1185 DebugAgentMsgPrint (DEBUG_AGENT_ERROR
, "DebugAgentReadBuffer(Command) timeout\n");
1186 return RETURN_TIMEOUT
;
1188 if (DebugHeader
->Length
< sizeof (DEBUG_PACKET_HEADER
)) {
1189 if (IncompatibilityFlag
!= NULL
) {
1191 // This is one old version debug packet format, set Incompatibility flag
1193 *IncompatibilityFlag
= TRUE
;
1196 // Skip the bad small packet
1202 // Read the payload data include the CRC field
1204 Received
= DebugAgentReadBuffer (Handle
, &DebugHeader
->SequenceNo
, (UINT8
) (DebugHeader
->Length
- OFFSET_OF (DEBUG_PACKET_HEADER
, SequenceNo
)), Timeout
);
1205 if (Received
== 0) {
1206 DebugAgentMsgPrint (DEBUG_AGENT_ERROR
, "DebugAgentReadBuffer(SequenceNo) timeout\n");
1207 return RETURN_TIMEOUT
;
1210 // Calculate the CRC of Debug Packet
1212 Crc
= DebugHeader
->Crc
;
1213 DebugHeader
->Crc
= 0;
1214 if (Crc
== CalculateCrc16 ((UINT8
*) DebugHeader
, DebugHeader
->Length
, 0)) {
1217 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "CRC Error (received CRC is %x)\n", Crc
);
1218 DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE
, FALSE
, (UINT8
*) DebugHeader
, DebugHeader
->Length
);
1222 DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE
, FALSE
, (UINT8
*) DebugHeader
, DebugHeader
->Length
);
1224 if (DebugHeader
->StartSymbol
== DEBUG_STARTING_SYMBOL_COMPRESS
) {
1225 DebugHeader
->StartSymbol
= DEBUG_STARTING_SYMBOL_NORMAL
;
1226 DebugHeader
->Length
= DecompressDataInPlace (
1227 (UINT8
*) (DebugHeader
+ 1), DebugHeader
->Length
- sizeof (DEBUG_PACKET_HEADER
)
1228 ) + sizeof (DEBUG_PACKET_HEADER
);
1230 return RETURN_SUCCESS
;
1234 Receive acknowledge packet OK from HOST in specified time.
1236 @param[in] Command The command type issued by TARGET.
1237 @param[in] Timeout Time out value to wait for acknowlege from HOST.
1238 The unit is microsecond.
1239 @param[out] BreakReceived If BreakReceived is not NULL,
1240 TRUE is retured if break-in symbol received.
1241 FALSE is retured if break-in symbol not received.
1242 @param[out] IncompatibilityFlag If IncompatibilityFlag is not NULL, return
1243 TRUE: Compatible packet received.
1244 FALSE: Incompatible packet received.
1246 @retval RETRUEN_SUCCESS Succeed to receive acknowlege packet from HOST,
1247 the type of acknowlege packet saved in Ack.
1248 @retval RETURN_TIMEOUT Specified timeout value was up.
1252 SendCommandAndWaitForAckOK (
1255 OUT BOOLEAN
*BreakReceived
, OPTIONAL
1256 OUT BOOLEAN
*IncompatibilityFlag OPTIONAL
1259 RETURN_STATUS Status
;
1260 UINT8 InputPacketBuffer
[DEBUG_DATA_UPPER_LIMIT
];
1261 DEBUG_PACKET_HEADER
*DebugHeader
;
1263 UINT8 HostSequenceNo
;
1267 DebugHeader
= (DEBUG_PACKET_HEADER
*) InputPacketBuffer
;
1268 Status
= RETURN_TIMEOUT
;
1269 while (RetryCount
> 0) {
1270 SequenceNo
= GetMailboxPointer()->SequenceNo
;
1271 HostSequenceNo
= GetMailboxPointer()->HostSequenceNo
;
1272 SendPacketWithoutData (Command
, SequenceNo
);
1273 Status
= ReceivePacket ((UINT8
*) DebugHeader
, BreakReceived
, IncompatibilityFlag
, Timeout
, FALSE
);
1274 if (Status
== RETURN_TIMEOUT
) {
1275 if (Command
== DEBUG_COMMAND_INIT_BREAK
) {
1278 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Timeout when waiting for ACK packet.\n");
1282 ASSERT_EFI_ERROR (Status
);
1284 // Status == RETURN_SUCCESS
1286 if (DebugHeader
->Command
== DEBUG_COMMAND_OK
&& DebugHeader
->SequenceNo
== SequenceNo
) {
1290 UpdateMailboxContent (GetMailboxPointer(), DEBUG_MAILBOX_SEQUENCE_NO_INDEX
, ++SequenceNo
);
1293 if (DebugHeader
->Command
== DEBUG_COMMAND_GO
&& (DebugHeader
->SequenceNo
== HostSequenceNo
|| Command
== DEBUG_COMMAND_INIT_BREAK
)) {
1297 if (Command
== DEBUG_COMMAND_INIT_BREAK
) {
1298 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Receive GO() in last boot\n");
1300 SendPacketWithoutData (DEBUG_COMMAND_OK
, DebugHeader
->SequenceNo
);
1304 ASSERT (Command
== DEBUG_COMMAND_INIT_BREAK
);
1309 Get current break cause.
1311 @param[in] Vector Vector value of exception or interrupt.
1312 @param[in] CpuContext Pointer to save CPU context.
1314 @return The type of break cause defined by XXXX
1320 IN DEBUG_CPU_CONTEXT
*CpuContext
1325 Cause
= DEBUG_DATA_BREAK_CAUSE_UNKNOWN
;
1328 case DEBUG_INT1_VECTOR
:
1329 case DEBUG_INT3_VECTOR
:
1331 if (Vector
== DEBUG_INT1_VECTOR
) {
1335 if ((CpuContext
->Dr6
& BIT14
) != 0) {
1336 Cause
= DEBUG_DATA_BREAK_CAUSE_STEPPING
;
1338 // DR6.BIT14 Indicates (when set) that the debug exception was
1339 // triggered by the single step execution mode.
1340 // The single-step mode is the highest priority debug exception.
1341 // This is single step, no need to check DR0, to ensure single step
1342 // work in PeCoffExtraActionLib (right after triggering a breakpoint
1343 // to report image load/unload).
1348 Cause
= DEBUG_DATA_BREAK_CAUSE_HW_BREAKPOINT
;
1354 Cause
= DEBUG_DATA_BREAK_CAUSE_SW_BREAKPOINT
;
1357 switch (CpuContext
->Dr0
) {
1358 case IMAGE_LOAD_SIGNATURE
:
1359 case IMAGE_UNLOAD_SIGNATURE
:
1361 if (CpuContext
->Dr3
== IO_PORT_BREAKPOINT_ADDRESS
) {
1363 Cause
= (UINT8
) ((CpuContext
->Dr0
== IMAGE_LOAD_SIGNATURE
) ?
1364 DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD
: DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD
);
1368 case SOFT_INTERRUPT_SIGNATURE
:
1370 if (CpuContext
->Dr1
== MEMORY_READY_SIGNATURE
) {
1371 Cause
= DEBUG_DATA_BREAK_CAUSE_MEMORY_READY
;
1372 CpuContext
->Dr0
= 0;
1373 } else if (CpuContext
->Dr1
== SYSTEM_RESET_SIGNATURE
) {
1374 Cause
= DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET
;
1375 CpuContext
->Dr0
= 0;
1386 case DEBUG_TIMER_VECTOR
:
1387 Cause
= DEBUG_DATA_BREAK_CAUSE_USER_HALT
;
1392 if (GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING
) == 1) {
1394 // If stepping command is executing
1396 Cause
= DEBUG_DATA_BREAK_CAUSE_STEPPING
;
1398 Cause
= DEBUG_DATA_BREAK_CAUSE_EXCEPTION
;
1408 Copy memory from source to destination with specified width.
1410 @param[out] Dest A pointer to the destination buffer of the memory copy.
1411 @param[in] Src A pointer to the source buffer of the memory copy.
1412 @param[in] Count The number of data with specified width to copy from source to destination.
1413 @param[in] Width Data width in byte.
1434 // Copy memory from tail to avoid memory overlap
1436 Destination
= Dest
+ (Count
- 1) * Width
;
1437 Source
= Src
+ (Count
- 1) * Width
;
1441 while (Count
-- != 0) {
1444 *(UINT8
*) Destination
= MmioRead8 ((UINTN
) Source
);
1447 *(UINT16
*) Destination
= MmioRead16 ((UINTN
) Source
);
1450 *(UINT32
*) Destination
= MmioRead32 ((UINTN
) Source
);
1453 *(UINT64
*) Destination
= MmioRead64 ((UINTN
) Source
);
1459 Destination
+= Step
;
1464 Compress the data buffer but do not modify the original buffer.
1466 The compressed data is directly send to the debug channel.
1467 Compressing in place doesn't work because the data may become larger
1468 during compressing phase. ("3 3 ..." --> "3 3 0 ...")
1469 The routine is expected to be called three times:
1470 1. Compute the length of the compressed data buffer;
1471 2. Compute the CRC of the compressed data buffer;
1472 3. Compress the data and send to the debug channel.
1474 @param[in] Handle The debug channel handle to send the compressed data buffer.
1475 @param[in] Data The data buffer.
1476 @param[in] Length The length of the data buffer.
1477 @param[in] Send TRUE to send the compressed data buffer.
1478 @param[out] CompressedLength Return the length of the compressed data buffer.
1479 It may be larger than the Length in some cases.
1480 @param[out] CompressedCrc Return the CRC of the compressed data buffer.
1484 IN DEBUG_PORT_HANDLE Handle
,
1488 OUT UINTN
*CompressedLength
, OPTIONAL
1489 OUT UINT16
*CompressedCrc OPTIONAL
1494 UINT8 LastCharCount
;
1496 UINTN CompressedIndex
;
1498 ASSERT (Length
> 0);
1499 LastChar
= Data
[0] + 1; // Just ensure it's different from the first byte.
1502 for (Index
= 0, CompressedIndex
= 0; Index
<= Length
; Index
++) {
1503 if (Index
< Length
) {
1504 CurrentChar
= Data
[Index
];
1506 CurrentChar
= (UINT8
) LastChar
+ 1; // just ensure it's different from LastChar
1508 if (LastChar
!= CurrentChar
) {
1509 if (LastCharCount
== 1) {
1511 if (CompressedCrc
!= NULL
) {
1512 *CompressedCrc
= CalculateCrc16 (&LastChar
, 1, *CompressedCrc
);
1515 DebugPortWriteBuffer (Handle
, &LastChar
, 1);
1518 } else if (LastCharCount
>= 2) {
1519 CompressedIndex
+= 3;
1521 if (CompressedCrc
!= NULL
) {
1522 *CompressedCrc
= CalculateCrc16 (&LastChar
, 1, *CompressedCrc
);
1523 *CompressedCrc
= CalculateCrc16 (&LastChar
, 1, *CompressedCrc
);
1524 *CompressedCrc
= CalculateCrc16 (&LastCharCount
, 1, *CompressedCrc
);
1527 DebugPortWriteBuffer (Handle
, &LastChar
, 1);
1528 DebugPortWriteBuffer (Handle
, &LastChar
, 1);
1529 DebugPortWriteBuffer (Handle
, &LastCharCount
, 1);
1535 LastChar
= CurrentChar
;
1538 if (CompressedLength
!= NULL
) {
1539 *CompressedLength
= CompressedIndex
;
1544 Read memory with speicifed width and send packet with response data to HOST.
1546 @param[in] Data Pointer to response data buffer.
1547 @param[in] Count The number of data with specified Width.
1548 @param[in] Width Data width in byte.
1549 @param[in] DebugHeader Pointer to a buffer for creating response packet and receiving ACK packet,
1550 to minimize the stack usage.
1552 @retval RETURN_SUCCESS Response data was sent successfully.
1556 ReadMemoryAndSendResponsePacket (
1560 IN DEBUG_PACKET_HEADER
*DebugHeader
1563 RETURN_STATUS Status
;
1565 DEBUG_PORT_HANDLE Handle
;
1567 UINTN RemainingDataSize
;
1568 UINT8 CurrentDataSize
;
1569 UINTN CompressedDataSize
;
1571 Handle
= GetDebugPortHandle();
1573 RemainingDataSize
= Count
* Width
;
1575 SequenceNo
= GetMailboxPointer()->HostSequenceNo
;
1576 if (RemainingDataSize
<= DEBUG_DATA_MAXIMUM_REAL_DATA
) {
1578 // If the remaining data is less one real packet size, this is the last data packet
1580 CurrentDataSize
= (UINT8
) RemainingDataSize
;
1582 DebugHeader
->Command
= DEBUG_COMMAND_OK
;
1585 // Data is too larger to be sent in one packet, calculate the actual data size could
1586 // be sent in one Maximum data packet
1588 CurrentDataSize
= (DEBUG_DATA_MAXIMUM_REAL_DATA
/ Width
) * Width
;
1590 DebugHeader
->Command
= DEBUG_COMMAND_IN_PROGRESS
;
1593 // Construct the rest Debug header
1595 DebugHeader
->StartSymbol
= DEBUG_STARTING_SYMBOL_NORMAL
;
1596 DebugHeader
->Length
= CurrentDataSize
+ sizeof (DEBUG_PACKET_HEADER
);
1597 DebugHeader
->SequenceNo
= SequenceNo
;
1598 DebugHeader
->Crc
= 0;
1599 CopyMemByWidth ((UINT8
*) (DebugHeader
+ 1), Data
, CurrentDataSize
/ Width
, Width
);
1602 // Compression/decompression support was added since revision 0.4.
1603 // Revision 0.3 shouldn't compress the packet.
1605 if (DEBUG_AGENT_REVISION
>= DEBUG_AGENT_REVISION_04
) {
1607 // Get the compressed data size without modifying the packet.
1611 (UINT8
*) (DebugHeader
+ 1),
1614 &CompressedDataSize
,
1618 CompressedDataSize
= CurrentDataSize
;
1620 if (CompressedDataSize
< CurrentDataSize
) {
1621 DebugHeader
->Length
= (UINT8
) CompressedDataSize
+ sizeof (DEBUG_PACKET_HEADER
);
1622 DebugHeader
->StartSymbol
= DEBUG_STARTING_SYMBOL_COMPRESS
;
1624 // Compute the CRC of the packet head without modifying the packet.
1626 DebugHeader
->Crc
= CalculateCrc16 ((UINT8
*) DebugHeader
, sizeof (DEBUG_PACKET_HEADER
), 0);
1629 (UINT8
*) (DebugHeader
+ 1),
1636 // Send out the packet head.
1638 DebugPortWriteBuffer (Handle
, (UINT8
*) DebugHeader
, sizeof (DEBUG_PACKET_HEADER
));
1640 // Compress and send out the packet data.
1644 (UINT8
*) (DebugHeader
+ 1),
1653 // Calculate and fill the checksum, DebugHeader->Crc should be 0 before invoking CalculateCrc16 ()
1655 DebugHeader
->Crc
= CalculateCrc16 ((UINT8
*) DebugHeader
, DebugHeader
->Length
, 0);
1657 DebugAgentDataMsgPrint (DEBUG_AGENT_VERBOSE
, TRUE
, (UINT8
*) DebugHeader
, DebugHeader
->Length
);
1659 DebugPortWriteBuffer (Handle
, (UINT8
*) DebugHeader
, DebugHeader
->Length
);
1663 Status
= ReceivePacket ((UINT8
*) DebugHeader
, NULL
, NULL
, READ_PACKET_TIMEOUT
, FALSE
);
1664 if (Status
== RETURN_TIMEOUT
) {
1665 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Timeout in SendDataResponsePacket()\n");
1668 if ((DebugHeader
->Command
== DEBUG_COMMAND_OK
) && (DebugHeader
->SequenceNo
== SequenceNo
) && LastPacket
) {
1670 // If this is the last packet, return RETURN_SUCCESS.
1672 return RETURN_SUCCESS
;
1674 if ((DebugHeader
->Command
== DEBUG_COMMAND_CONTINUE
) && (DebugHeader
->SequenceNo
== (UINT8
) (SequenceNo
+ 1))) {
1676 // Calculate the rest data size
1678 Data
+= CurrentDataSize
;
1679 RemainingDataSize
-= CurrentDataSize
;
1680 UpdateMailboxContent (GetMailboxPointer(), DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
, DebugHeader
->SequenceNo
);
1683 if (DebugHeader
->SequenceNo
>= SequenceNo
) {
1684 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Received one old or new command(SequenceNo is %x, last SequenceNo is %x)\n", SequenceNo
, DebugHeader
->SequenceNo
);
1692 Send packet with response data to HOST.
1694 @param[in] Data Pointer to response data buffer.
1695 @param[in] DataSize Size of response data in byte.
1696 @param[in, out] DebugHeader Pointer to a buffer for creating response packet and receiving ACK packet,
1697 to minimize the stack usage.
1699 @retval RETURN_SUCCESS Response data was sent successfully.
1703 SendDataResponsePacket (
1706 IN OUT DEBUG_PACKET_HEADER
*DebugHeader
1709 return ReadMemoryAndSendResponsePacket (Data
, DataSize
, 1, DebugHeader
);
1713 Try to attach the HOST.
1715 Send init break packet to HOST:
1716 If no acknowlege received in specified Timeout, return RETURN_TIMEOUT.
1717 If received acknowlege, check the revision of HOST.
1718 Set Attach Flag if attach successfully.
1720 @param[in] BreakCause Break cause of this break event.
1721 @param[in] Timeout Time out value to wait for acknowlege from HOST.
1722 The unit is microsecond.
1723 @param[out] BreakReceived If BreakReceived is not NULL,
1724 TRUE is retured if break-in symbol received.
1725 FALSE is retured if break-in symbol not received.
1729 IN UINT8 BreakCause
,
1731 OUT BOOLEAN
*BreakReceived
1734 RETURN_STATUS Status
;
1735 DEBUG_PORT_HANDLE Handle
;
1736 BOOLEAN IncompatibilityFlag
;
1738 IncompatibilityFlag
= FALSE
;
1739 Handle
= GetDebugPortHandle();
1742 // Send init break and wait ack in Timeout
1744 DebugPortWriteBuffer (Handle
, (UINT8
*) mErrorMsgSendInitPacket
, AsciiStrLen (mErrorMsgSendInitPacket
));
1745 if (BreakCause
== DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET
) {
1746 Status
= SendCommandAndWaitForAckOK (DEBUG_COMMAND_INIT_BREAK
, Timeout
, BreakReceived
, &IncompatibilityFlag
);
1748 Status
= SendCommandAndWaitForAckOK (DEBUG_COMMAND_ATTACH_BREAK
, Timeout
, BreakReceived
, &IncompatibilityFlag
);
1750 if (IncompatibilityFlag
) {
1752 // If the incompatible Debug Packet received, the HOST should be running transfer protocol before DEBUG_AGENT_REVISION.
1753 // It could be UDK Debugger for Windows v1.1/v1.2 or for Linux v0.8/v1.2.
1755 DebugPortWriteBuffer (Handle
, (UINT8
*) mErrorMsgVersionAlert
, AsciiStrLen (mErrorMsgVersionAlert
));
1759 if (RETURN_ERROR (Status
)) {
1760 DebugPortWriteBuffer (Handle
, (UINT8
*) mErrorMsgConnectFail
, AsciiStrLen (mErrorMsgConnectFail
));
1762 DebugPortWriteBuffer (Handle
, (UINT8
*) mErrorMsgConnectOK
, AsciiStrLen (mErrorMsgConnectOK
));
1766 SetHostAttached (TRUE
);
1772 Send Break point packet to HOST.
1774 Only the first breaking processor could sent BREAK_POINT packet.
1776 @param[in] BreakCause Break cause of this break event.
1777 @param[in] ProcessorIndex Processor index value.
1778 @param[out] BreakReceived If BreakReceived is not NULL,
1779 TRUE is retured if break-in symbol received.
1780 FALSE is retured if break-in symbol not received.
1784 SendBreakPacketToHost (
1785 IN UINT8 BreakCause
,
1786 IN UINT32 ProcessorIndex
,
1787 OUT BOOLEAN
*BreakReceived
1790 UINT8 InputCharacter
;
1791 DEBUG_PORT_HANDLE Handle
;
1793 Handle
= GetDebugPortHandle();
1795 if (IsHostAttached ()) {
1796 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "processor[%x]:Send Break Packet to HOST.\n", ProcessorIndex
);
1797 SendCommandAndWaitForAckOK (DEBUG_COMMAND_BREAK_POINT
, READ_PACKET_TIMEOUT
, BreakReceived
, NULL
);
1799 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "processor[%x]:Try to attach HOST.\n", ProcessorIndex
);
1801 // If HOST is not attached, try to attach it firstly.
1804 // Poll Attach symbols from HOST and ack OK
1807 DebugAgentReadBuffer (Handle
, &InputCharacter
, 1, 0);
1808 } while (InputCharacter
!= DEBUG_STARTING_SYMBOL_ATTACH
);
1809 SendAckPacket (DEBUG_COMMAND_OK
);
1812 // Try to attach HOST
1814 while (AttachHost (BreakCause
, 0, NULL
) != RETURN_SUCCESS
);
1820 The main function to process communication with HOST.
1822 It received the command packet from HOST, and sent response data packet to HOST.
1824 @param[in] Vector Vector value of exception or interrutp.
1825 @param[in, out] CpuContext Pointer to saved CPU context.
1826 @param[in] BreakReceived TRUE means break-in symbol received.
1827 FALSE means break-in symbol not received.
1831 CommandCommunication (
1833 IN OUT DEBUG_CPU_CONTEXT
*CpuContext
,
1834 IN BOOLEAN BreakReceived
1837 RETURN_STATUS Status
;
1838 UINT8 InputPacketBuffer
[DEBUG_DATA_UPPER_LIMIT
+ sizeof (UINT64
) - 1];
1839 DEBUG_PACKET_HEADER
*DebugHeader
;
1844 DEBUG_DATA_READ_MEMORY
*MemoryRead
;
1845 DEBUG_DATA_WRITE_MEMORY
*MemoryWrite
;
1846 DEBUG_DATA_READ_IO
*IoRead
;
1847 DEBUG_DATA_WRITE_IO
*IoWrite
;
1848 DEBUG_DATA_READ_REGISTER
*RegisterRead
;
1849 DEBUG_DATA_WRITE_REGISTER
*RegisterWrite
;
1850 UINT8
*RegisterBuffer
;
1851 DEBUG_DATA_READ_MSR
*MsrRegisterRead
;
1852 DEBUG_DATA_WRITE_MSR
*MsrRegisterWrite
;
1853 DEBUG_DATA_CPUID
*Cpuid
;
1854 DEBUG_DATA_RESPONSE_BREAK_CAUSE BreakCause
;
1855 DEBUG_DATA_RESPONSE_CPUID CpuidResponse
;
1856 DEBUG_DATA_SEARCH_SIGNATURE
*SearchSignature
;
1857 DEBUG_DATA_RESPONSE_GET_EXCEPTION Exception
;
1858 DEBUG_DATA_RESPONSE_GET_REVISION DebugAgentRevision
;
1859 DEBUG_DATA_SET_VIEWPOINT
*SetViewPoint
;
1860 BOOLEAN HaltDeferred
;
1861 UINT32 ProcessorIndex
;
1862 DEBUG_PORT_HANDLE Handle
;
1863 DEBUG_AGENT_EXCEPTION_BUFFER AgentExceptionBuffer
;
1864 UINT32 IssuedViewPoint
;
1865 DEBUG_AGENT_MAILBOX
*Mailbox
;
1866 UINT8
*AlignedDataPtr
;
1869 IssuedViewPoint
= 0;
1870 HaltDeferred
= BreakReceived
;
1872 if (MultiProcessorDebugSupport()) {
1873 ProcessorIndex
= GetProcessorIndex ();
1874 SetCpuStopFlagByIndex (ProcessorIndex
, TRUE
);
1875 if (mDebugMpContext
.ViewPointIndex
== ProcessorIndex
) {
1877 // Only the current view processor could set AgentInProgress Flag.
1879 IssuedViewPoint
= ProcessorIndex
;
1883 if (IssuedViewPoint
== ProcessorIndex
) {
1885 // Set AgentInProgress Flag.
1887 SetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS
, 1);
1890 Handle
= GetDebugPortHandle();
1894 if (MultiProcessorDebugSupport()) {
1896 // Check if the current processor is HOST view point
1898 if (mDebugMpContext
.ViewPointIndex
!= ProcessorIndex
) {
1899 if (mDebugMpContext
.RunCommandSet
) {
1901 // If HOST view point sets RUN flag, run GO command to leave
1903 SetCpuStopFlagByIndex (ProcessorIndex
, FALSE
);
1904 CommandGo (CpuContext
);
1908 // Run into loop again
1916 AcquireMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1918 DebugHeader
=(DEBUG_PACKET_HEADER
*) InputPacketBuffer
;
1920 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "TARGET: Try to get command from HOST...\n");
1921 Status
= ReceivePacket ((UINT8
*) DebugHeader
, &BreakReceived
, NULL
, READ_PACKET_TIMEOUT
, TRUE
);
1922 if (Status
!= RETURN_SUCCESS
|| !IS_REQUEST (DebugHeader
)) {
1923 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Get command[%x] sequenceno[%x] returned status is [%x] \n", DebugHeader
->Command
, DebugHeader
->SequenceNo
, Status
);
1924 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Get command failed or it's response packet not expected! \n");
1925 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1929 Mailbox
= GetMailboxPointer ();
1930 if (DebugHeader
->SequenceNo
== Mailbox
->HostSequenceNo
) {
1931 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "TARGET: Receive one old command[%x] agaist command[%x]\n", DebugHeader
->SequenceNo
, Mailbox
->HostSequenceNo
);
1932 SendAckPacket (Mailbox
->LastAck
);
1933 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1935 } else if (DebugHeader
->SequenceNo
== (UINT8
) (Mailbox
->HostSequenceNo
+ 1)) {
1936 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
, (UINT8
) DebugHeader
->SequenceNo
);
1938 DebugAgentMsgPrint (DEBUG_AGENT_WARNING
, "Receive one invalid comamnd[%x] agaist command[%x]\n", DebugHeader
->SequenceNo
, Mailbox
->HostSequenceNo
);
1939 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1944 // Save CPU content before executing HOST commond
1946 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_EXCEPTION_BUFFER_POINTER_INDEX
, (UINT64
)(UINTN
) &AgentExceptionBuffer
.JumpBuffer
);
1947 if (SetJump (&AgentExceptionBuffer
.JumpBuffer
) != 0) {
1949 // If HOST command failed, continue to wait for HOST's next command
1950 // If needed, agent could send exception info to HOST.
1952 SendAckPacket (DEBUG_COMMAND_ABORT
);
1953 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1957 DebugAgentMsgPrint (DEBUG_AGENT_INFO
, "Processor[%x]:Received one command(%x)\n", mDebugMpContext
.ViewPointIndex
, DebugHeader
->Command
);
1959 switch (DebugHeader
->Command
) {
1961 case DEBUG_COMMAND_HALT
:
1962 SendAckPacket (DEBUG_COMMAND_HALT_DEFERRED
);
1963 HaltDeferred
= TRUE
;
1964 BreakReceived
= FALSE
;
1965 Status
= RETURN_SUCCESS
;
1968 case DEBUG_COMMAND_RESET
:
1969 SendAckPacket (DEBUG_COMMAND_OK
);
1970 SendAckPacket (DEBUG_COMMAND_OK
);
1971 SendAckPacket (DEBUG_COMMAND_OK
);
1972 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
1976 // Assume system resets in 2 seconds, otherwise send TIMEOUT packet.
1977 // PCD can be used if 2 seconds isn't long enough for some platforms.
1979 MicroSecondDelay (2000000);
1980 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
, Mailbox
->HostSequenceNo
+ 1);
1981 SendAckPacket (DEBUG_COMMAND_TIMEOUT
);
1982 SendAckPacket (DEBUG_COMMAND_TIMEOUT
);
1983 SendAckPacket (DEBUG_COMMAND_TIMEOUT
);
1986 case DEBUG_COMMAND_GO
:
1987 CommandGo (CpuContext
);
1989 // Clear Dr0 to avoid to be recognized as IMAGE_LOAD/_UNLOAD again when hitting a breakpoint after GO
1990 // If HOST changed Dr0 before GO, we will not change Dr0 here
1992 Data8
= GetBreakCause (Vector
, CpuContext
);
1993 if (Data8
== DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD
|| Data8
== DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD
) {
1994 CpuContext
->Dr0
= 0;
1997 if (!HaltDeferred
) {
1999 // If no HALT command received when being in-active mode
2001 if (MultiProcessorDebugSupport()) {
2002 Data32
= FindNextPendingBreakCpu ();
2005 // If there are still others processors being in break state,
2006 // send OK packet to HOST to finish this go command
2008 SendAckPacket (DEBUG_COMMAND_OK
);
2011 // Set current view to the next breaking processor
2013 mDebugMpContext
.ViewPointIndex
= Data32
;
2014 mDebugMpContext
.BreakAtCpuIndex
= mDebugMpContext
.ViewPointIndex
;
2015 SetCpuBreakFlagByIndex (mDebugMpContext
.ViewPointIndex
, FALSE
);
2017 // Send break packet to HOST to let HOST break again
2019 SendBreakPacketToHost (DEBUG_DATA_BREAK_CAUSE_UNKNOWN
, mDebugMpContext
.BreakAtCpuIndex
, &BreakReceived
);
2021 // Continue to run into loop to read command packet from HOST
2023 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2028 // If no else processor break, set stop bitmask,
2029 // and set Running flag for all processors.
2031 SetCpuStopFlagByIndex (ProcessorIndex
, FALSE
);
2032 SetCpuRunningFlag (TRUE
);
2035 // Wait for all processors are in running state
2038 if (IsAllCpuRunning ()) {
2043 // Set BSP to be current view point.
2045 SetDebugViewPoint (mDebugMpContext
.BspIndex
);
2048 // Clear breaking processor index and running flag
2050 mDebugMpContext
.BreakAtCpuIndex
= (UINT32
) (-1);
2051 SetCpuRunningFlag (FALSE
);
2055 // Send OK packet to HOST to finish this go command
2057 SendAckPacket (DEBUG_COMMAND_OK
);
2059 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2061 if (!IsHostAttached()) {
2062 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_SEQUENCE_NO_INDEX
, 0);
2063 UpdateMailboxContent (Mailbox
, DEBUG_MAILBOX_HOST_SEQUENCE_NO_INDEX
, 0);
2069 // If reveived HALT command, need to defer the GO command
2071 SendAckPacket (DEBUG_COMMAND_HALT_PROCESSED
);
2072 HaltDeferred
= FALSE
;
2074 Vector
= DEBUG_TIMER_VECTOR
;
2078 case DEBUG_COMMAND_BREAK_CAUSE
:
2079 BreakCause
.StopAddress
= CpuContext
->Eip
;
2080 if (MultiProcessorDebugSupport() && ProcessorIndex
!= mDebugMpContext
.BreakAtCpuIndex
) {
2081 BreakCause
.Cause
= GetBreakCause (DEBUG_TIMER_VECTOR
, CpuContext
);
2083 BreakCause
.Cause
= GetBreakCause (Vector
, CpuContext
);
2085 SendDataResponsePacket ((UINT8
*) &BreakCause
, (UINT16
) sizeof (DEBUG_DATA_RESPONSE_BREAK_CAUSE
), DebugHeader
);
2088 case DEBUG_COMMAND_SET_HW_BREAKPOINT
:
2089 SetDebugRegister (CpuContext
, (DEBUG_DATA_SET_HW_BREAKPOINT
*) (DebugHeader
+ 1));
2090 SendAckPacket (DEBUG_COMMAND_OK
);
2093 case DEBUG_COMMAND_CLEAR_HW_BREAKPOINT
:
2094 ClearDebugRegister (CpuContext
, (DEBUG_DATA_CLEAR_HW_BREAKPOINT
*) (DebugHeader
+ 1));
2095 SendAckPacket (DEBUG_COMMAND_OK
);
2098 case DEBUG_COMMAND_SINGLE_STEPPING
:
2099 CommandStepping (CpuContext
);
2101 // Clear Dr0 to avoid to be recognized as IMAGE_LOAD/_UNLOAD again when hitting a breakpoint after GO
2102 // If HOST changed Dr0 before GO, we will not change Dr0 here
2104 Data8
= GetBreakCause (Vector
, CpuContext
);
2105 if (Data8
== DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD
|| Data8
== DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD
) {
2106 CpuContext
->Dr0
= 0;
2109 mDebugMpContext
.BreakAtCpuIndex
= (UINT32
) (-1);
2110 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2112 // Executing stepping command directly without sending ACK packet,
2113 // ACK packet will be sent after stepping done.
2117 case DEBUG_COMMAND_SET_SW_BREAKPOINT
:
2118 Data64
= (UINTN
) (((DEBUG_DATA_SET_SW_BREAKPOINT
*) (DebugHeader
+ 1))->Address
);
2119 Data8
= *(UINT8
*) (UINTN
) Data64
;
2120 *(UINT8
*) (UINTN
) Data64
= DEBUG_SW_BREAKPOINT_SYMBOL
;
2121 Status
= SendDataResponsePacket ((UINT8
*) &Data8
, (UINT16
) sizeof (UINT8
), DebugHeader
);
2124 case DEBUG_COMMAND_READ_MEMORY
:
2125 MemoryRead
= (DEBUG_DATA_READ_MEMORY
*) (DebugHeader
+ 1);
2126 Status
= ReadMemoryAndSendResponsePacket ((UINT8
*) (UINTN
) MemoryRead
->Address
, MemoryRead
->Count
, MemoryRead
->Width
, DebugHeader
);
2129 case DEBUG_COMMAND_WRITE_MEMORY
:
2130 MemoryWrite
= (DEBUG_DATA_WRITE_MEMORY
*) (DebugHeader
+ 1);
2132 // Copy data into one memory with 8-byte alignment address
2134 AlignedDataPtr
= ALIGN_POINTER ((UINT8
*) &MemoryWrite
->Data
, sizeof (UINT64
));
2135 if (AlignedDataPtr
!= (UINT8
*) &MemoryWrite
->Data
) {
2136 CopyMem (AlignedDataPtr
, (UINT8
*) &MemoryWrite
->Data
, MemoryWrite
->Count
* MemoryWrite
->Width
);
2138 CopyMemByWidth ((UINT8
*) (UINTN
) MemoryWrite
->Address
, AlignedDataPtr
, MemoryWrite
->Count
, MemoryWrite
->Width
);
2139 SendAckPacket (DEBUG_COMMAND_OK
);
2142 case DEBUG_COMMAND_READ_IO
:
2143 IoRead
= (DEBUG_DATA_READ_IO
*) (DebugHeader
+ 1);
2144 switch (IoRead
->Width
) {
2146 Data64
= IoRead8 ((UINTN
) IoRead
->Port
);
2149 Data64
= IoRead16 ((UINTN
) IoRead
->Port
);
2152 Data64
= IoRead32 ((UINTN
) IoRead
->Port
);
2155 Data64
= IoRead64 ((UINTN
) IoRead
->Port
);
2158 Data64
= (UINT64
) -1;
2160 Status
= SendDataResponsePacket ((UINT8
*) &Data64
, IoRead
->Width
, DebugHeader
);
2163 case DEBUG_COMMAND_WRITE_IO
:
2164 IoWrite
= (DEBUG_DATA_WRITE_IO
*) (DebugHeader
+ 1);
2165 switch (IoWrite
->Width
) {
2167 Data64
= IoWrite8 ((UINTN
) IoWrite
->Port
, *(UINT8
*) &IoWrite
->Data
);
2170 Data64
= IoWrite16 ((UINTN
) IoWrite
->Port
, *(UINT16
*) &IoWrite
->Data
);
2173 Data64
= IoWrite32 ((UINTN
) IoWrite
->Port
, *(UINT32
*) &IoWrite
->Data
);
2176 Data64
= IoWrite64 ((UINTN
) IoWrite
->Port
, *(UINT64
*) &IoWrite
->Data
);
2179 Data64
= (UINT64
) -1;
2181 SendAckPacket (DEBUG_COMMAND_OK
);
2184 case DEBUG_COMMAND_READ_ALL_REGISTERS
:
2185 Status
= SendDataResponsePacket ((UINT8
*) CpuContext
, sizeof (*CpuContext
), DebugHeader
);
2188 case DEBUG_COMMAND_READ_REGISTER
:
2189 RegisterRead
= (DEBUG_DATA_READ_REGISTER
*) (DebugHeader
+ 1);
2191 if (RegisterRead
->Index
<= SOFT_DEBUGGER_REGISTER_MAX
) {
2192 RegisterBuffer
= ArchReadRegisterBuffer (CpuContext
, RegisterRead
->Index
, &Width
);
2193 Status
= SendDataResponsePacket (RegisterBuffer
, Width
, DebugHeader
);
2195 Status
= RETURN_UNSUPPORTED
;
2199 case DEBUG_COMMAND_WRITE_REGISTER
:
2200 RegisterWrite
= (DEBUG_DATA_WRITE_REGISTER
*) (DebugHeader
+ 1);
2201 if (RegisterWrite
->Index
<= SOFT_DEBUGGER_REGISTER_MAX
) {
2202 RegisterBuffer
= ArchReadRegisterBuffer (CpuContext
, RegisterWrite
->Index
, &Width
);
2203 ASSERT (Width
== RegisterWrite
->Length
);
2204 CopyMem (RegisterBuffer
, RegisterWrite
->Data
, Width
);
2205 SendAckPacket (DEBUG_COMMAND_OK
);
2207 Status
= RETURN_UNSUPPORTED
;
2211 case DEBUG_COMMAND_ARCH_MODE
:
2212 Data8
= DEBUG_ARCH_SYMBOL
;
2213 Status
= SendDataResponsePacket ((UINT8
*) &Data8
, (UINT16
) sizeof (UINT8
), DebugHeader
);
2216 case DEBUG_COMMAND_READ_MSR
:
2217 MsrRegisterRead
= (DEBUG_DATA_READ_MSR
*) (DebugHeader
+ 1);
2218 Data64
= AsmReadMsr64 (MsrRegisterRead
->Index
);
2219 Status
= SendDataResponsePacket ((UINT8
*) &Data64
, (UINT16
) sizeof (UINT64
), DebugHeader
);
2222 case DEBUG_COMMAND_WRITE_MSR
:
2223 MsrRegisterWrite
= (DEBUG_DATA_WRITE_MSR
*) (DebugHeader
+ 1);
2224 AsmWriteMsr64 (MsrRegisterWrite
->Index
, MsrRegisterWrite
->Value
);
2225 SendAckPacket (DEBUG_COMMAND_OK
);
2228 case DEBUG_COMMAND_SET_DEBUG_SETTING
:
2229 Status
= SetDebugSetting ((DEBUG_DATA_SET_DEBUG_SETTING
*)(DebugHeader
+ 1));
2230 if (Status
== RETURN_SUCCESS
) {
2231 SendAckPacket (DEBUG_COMMAND_OK
);
2235 case DEBUG_COMMAND_GET_REVISION
:
2236 DebugAgentRevision
.Revision
= DEBUG_AGENT_REVISION
;
2237 DebugAgentRevision
.Capabilities
= DEBUG_AGENT_CAPABILITIES
;
2238 Status
= SendDataResponsePacket ((UINT8
*) &DebugAgentRevision
, (UINT16
) sizeof (DEBUG_DATA_RESPONSE_GET_REVISION
), DebugHeader
);
2241 case DEBUG_COMMAND_GET_EXCEPTION
:
2242 Exception
.ExceptionNum
= (UINT8
) Vector
;
2243 Exception
.ExceptionData
= (UINT32
) CpuContext
->ExceptionData
;
2244 Status
= SendDataResponsePacket ((UINT8
*) &Exception
, (UINT16
) sizeof (DEBUG_DATA_RESPONSE_GET_EXCEPTION
), DebugHeader
);
2247 case DEBUG_COMMAND_SET_VIEWPOINT
:
2248 SetViewPoint
= (DEBUG_DATA_SET_VIEWPOINT
*) (DebugHeader
+ 1);
2249 if (MultiProcessorDebugSupport()) {
2250 if (IsCpuStopped (SetViewPoint
->ViewPoint
)) {
2251 SetDebugViewPoint (SetViewPoint
->ViewPoint
);
2252 SendAckPacket (DEBUG_COMMAND_OK
);
2255 // If CPU is not halted
2257 SendAckPacket (DEBUG_COMMAND_NOT_SUPPORTED
);
2259 } else if (SetViewPoint
->ViewPoint
== 0) {
2260 SendAckPacket (DEBUG_COMMAND_OK
);
2263 SendAckPacket (DEBUG_COMMAND_NOT_SUPPORTED
);
2268 case DEBUG_COMMAND_GET_VIEWPOINT
:
2269 Data32
= mDebugMpContext
.ViewPointIndex
;
2270 SendDataResponsePacket((UINT8
*) &Data32
, (UINT16
) sizeof (UINT32
), DebugHeader
);
2273 case DEBUG_COMMAND_MEMORY_READY
:
2274 Data8
= (UINT8
) GetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY
);
2275 SendDataResponsePacket (&Data8
, (UINT16
) sizeof (UINT8
), DebugHeader
);
2278 case DEBUG_COMMAND_DETACH
:
2279 SetHostAttached (FALSE
);
2280 SendAckPacket (DEBUG_COMMAND_OK
);
2283 case DEBUG_COMMAND_CPUID
:
2284 Cpuid
= (DEBUG_DATA_CPUID
*) (DebugHeader
+ 1);
2286 Cpuid
->Eax
, Cpuid
->Ecx
,
2287 &CpuidResponse
.Eax
, &CpuidResponse
.Ebx
,
2288 &CpuidResponse
.Ecx
, &CpuidResponse
.Edx
2290 SendDataResponsePacket ((UINT8
*) &CpuidResponse
, (UINT16
) sizeof (CpuidResponse
), DebugHeader
);
2293 case DEBUG_COMMAND_SEARCH_SIGNATURE
:
2294 SearchSignature
= (DEBUG_DATA_SEARCH_SIGNATURE
*) (DebugHeader
+ 1);
2295 if ((SearchSignature
->Alignment
!= 0) &&
2296 (SearchSignature
->Alignment
== GetPowerOfTwo32 (SearchSignature
->Alignment
))
2298 if (SearchSignature
->Positive
) {
2300 Data64
= ALIGN_VALUE ((UINTN
) SearchSignature
->Start
, SearchSignature
->Alignment
);
2301 Data64
<= SearchSignature
->Start
+ SearchSignature
->Count
- SearchSignature
->DataLength
;
2302 Data64
+= SearchSignature
->Alignment
2304 if (CompareMem ((VOID
*) (UINTN
) Data64
, &SearchSignature
->Data
, SearchSignature
->DataLength
) == 0) {
2308 if (Data64
> SearchSignature
->Start
+ SearchSignature
->Count
- SearchSignature
->DataLength
) {
2309 Data64
= (UINT64
) -1;
2313 Data64
= ALIGN_VALUE ((UINTN
) SearchSignature
->Start
- SearchSignature
->Alignment
, SearchSignature
->Alignment
);
2314 Data64
>= SearchSignature
->Start
- SearchSignature
->Count
;
2315 Data64
-= SearchSignature
->Alignment
2317 if (CompareMem ((VOID
*) (UINTN
) Data64
, &SearchSignature
->Data
, SearchSignature
->DataLength
) == 0) {
2321 if (Data64
< SearchSignature
->Start
- SearchSignature
->Count
) {
2322 Data64
= (UINT64
) -1;
2325 SendDataResponsePacket ((UINT8
*) &Data64
, (UINT16
) sizeof (Data64
), DebugHeader
);
2327 Status
= RETURN_UNSUPPORTED
;
2332 SendAckPacket (DEBUG_COMMAND_NOT_SUPPORTED
);
2336 if (Status
== RETURN_UNSUPPORTED
) {
2337 SendAckPacket (DEBUG_COMMAND_NOT_SUPPORTED
);
2338 } else if (Status
!= RETURN_SUCCESS
) {
2339 SendAckPacket (DEBUG_COMMAND_ABORT
);
2342 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2348 C function called in interrupt handler.
2350 @param[in] Vector Vector value of exception or interrutp.
2351 @param[in] CpuContext Pointer to save CPU context.
2358 IN DEBUG_CPU_CONTEXT
*CpuContext
2361 UINT8 InputCharacter
;
2364 BOOLEAN BreakReceived
;
2365 UINT32 ProcessorIndex
;
2366 UINT32 CurrentDebugTimerInitCount
;
2367 DEBUG_PORT_HANDLE Handle
;
2370 UINT32 IssuedViewPoint
;
2371 DEBUG_AGENT_EXCEPTION_BUFFER
*ExceptionBuffer
;
2375 IssuedViewPoint
= 0;
2376 BreakReceived
= FALSE
;
2378 if (mSkipBreakpoint
) {
2380 // If Skip Breakpoint flag is set, means communication is disturbed by hardware SMI, we need to ignore the break points in SMM
2382 if ((Vector
== DEBUG_INT1_VECTOR
) || (Vector
== DEBUG_INT3_VECTOR
)) {
2383 DebugPortWriteBuffer (GetDebugPortHandle(), (UINT8
*) mWarningMsgIngoreBreakpoint
, AsciiStrLen (mWarningMsgIngoreBreakpoint
));
2388 if (MultiProcessorDebugSupport()) {
2389 ProcessorIndex
= GetProcessorIndex ();
2391 // If this processor has alreay halted before, need to check it later
2393 if (IsCpuStopped (ProcessorIndex
)) {
2394 IssuedViewPoint
= ProcessorIndex
;
2398 if (IssuedViewPoint
== ProcessorIndex
&& GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING
) != 1) {
2400 // Check if this exception is issued by Debug Agent itself
2401 // If yes, fill the debug agent exception buffer and LongJump() back to
2402 // the saved CPU content in CommandCommunication()
2403 // If exception is issued when executing Stepping, will be handled in
2404 // exception handle procedure.
2406 if (GetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS
) == 1) {
2407 DebugAgentMsgPrint (
2409 "Debug agent meet one Exception, ExceptionNum is %d, EIP = 0x%x.\n",
2411 (UINTN
)CpuContext
->Eip
2413 ExceptionBuffer
= (DEBUG_AGENT_EXCEPTION_BUFFER
*) (UINTN
) GetMailboxPointer()->ExceptionBufferPointer
;
2414 ExceptionBuffer
->ExceptionContent
.ExceptionNum
= (UINT8
) Vector
;
2415 ExceptionBuffer
->ExceptionContent
.ExceptionData
= (UINT32
) CpuContext
->ExceptionData
;
2416 LongJump ((BASE_LIBRARY_JUMP_BUFFER
*)(UINTN
)(ExceptionBuffer
), 1);
2420 if (MultiProcessorDebugSupport()) {
2422 // If RUN commmand is executing, wait for it done.
2424 while (mDebugMpContext
.RunCommandSet
) {
2429 Handle
= GetDebugPortHandle();
2430 BreakCause
= GetBreakCause (Vector
, CpuContext
);
2432 case DEBUG_INT1_VECTOR
:
2433 case DEBUG_INT3_VECTOR
:
2434 switch (BreakCause
) {
2435 case DEBUG_DATA_BREAK_CAUSE_SYSTEM_RESET
:
2436 if (AttachHost (BreakCause
, READ_PACKET_TIMEOUT
, &BreakReceived
) != RETURN_SUCCESS
) {
2438 // Try to connect HOST, return if fails
2442 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2445 case DEBUG_DATA_BREAK_CAUSE_STEPPING
:
2447 // Stepping is finished, send Ack package.
2449 if (MultiProcessorDebugSupport()) {
2450 mDebugMpContext
.BreakAtCpuIndex
= ProcessorIndex
;
2453 // Clear Stepping Flag and restore EFLAGS.IF
2455 CommandSteppingCleanup (CpuContext
);
2456 SendAckPacket (DEBUG_COMMAND_OK
);
2457 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2460 case DEBUG_DATA_BREAK_CAUSE_MEMORY_READY
:
2464 SendCommandAndWaitForAckOK (DEBUG_COMMAND_MEMORY_READY
, READ_PACKET_TIMEOUT
, &BreakReceived
, NULL
);
2465 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2468 case DEBUG_DATA_BREAK_CAUSE_IMAGE_LOAD
:
2469 case DEBUG_DATA_BREAK_CAUSE_IMAGE_UNLOAD
:
2471 // Set AL to DEBUG_AGENT_IMAGE_CONTINUE
2473 Al
= ArchReadRegisterBuffer (CpuContext
, SOFT_DEBUGGER_REGISTER_AX
, &Data8
);
2474 *Al
= DEBUG_AGENT_IMAGE_CONTINUE
;
2476 if (!IsHostAttached ()) {
2478 // If HOST is not connected for image load/unload, return
2483 // Continue to run the following common code
2486 case DEBUG_DATA_BREAK_CAUSE_HW_BREAKPOINT
:
2487 case DEBUG_DATA_BREAK_CAUSE_SW_BREAKPOINT
:
2490 // Send Break packet to HOST
2492 AcquireMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2494 // Only the first breaking processor could send BREAK_POINT to HOST
2496 if (IsFirstBreakProcessor (ProcessorIndex
)) {
2497 SendBreakPacketToHost (BreakCause
, ProcessorIndex
, &BreakReceived
);
2499 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2501 if (Vector
== DEBUG_INT3_VECTOR
) {
2503 // go back address located "0xCC"
2506 SavedEip
= CpuContext
->Eip
;
2507 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2508 if ((SavedEip
== CpuContext
->Eip
) &&
2509 (*(UINT8
*) (UINTN
) CpuContext
->Eip
== DEBUG_SW_BREAKPOINT_SYMBOL
)) {
2511 // If this is not a software breakpoint set by HOST,
2517 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2524 case DEBUG_TIMER_VECTOR
:
2526 AcquireMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2528 if (MultiProcessorDebugSupport()) {
2529 if (IsBsp (ProcessorIndex
)) {
2531 // If current processor is BSP, check Apic timer's init count if changed,
2532 // it may be re-written when switching BSP.
2533 // If it changed, re-initialize debug timer
2535 CurrentDebugTimerInitCount
= GetApicTimerInitCount ();
2536 if (mDebugMpContext
.DebugTimerInitCount
!= CurrentDebugTimerInitCount
) {
2537 InitializeDebugTimer (NULL
, FALSE
);
2541 if (!IsBsp (ProcessorIndex
) || mDebugMpContext
.IpiSentByAp
) {
2542 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2544 // If current processor is not BSP or this is one IPI sent by AP
2546 if (mDebugMpContext
.BreakAtCpuIndex
!= (UINT32
) (-1)) {
2547 CommandCommunication (Vector
, CpuContext
, FALSE
);
2551 // Clear EOI before exiting interrupt process routine.
2559 // Only BSP could run here
2563 // If there is data in debug port, will check whether it is break(attach/break-in) symbol,
2564 // If yes, go into communication mode with HOST.
2565 // If no, exit interrupt process.
2567 if (DebugReadBreakSymbol (Handle
, &InputCharacter
) == EFI_NOT_FOUND
) {
2571 if ((!IsHostAttached () && (InputCharacter
== DEBUG_STARTING_SYMBOL_ATTACH
)) ||
2572 (IsHostAttached () && (InputCharacter
== DEBUG_COMMAND_HALT
)) ||
2573 (IsHostAttached () && (InputCharacter
== DEBUG_COMMAND_GO
))
2575 DebugAgentMsgPrint (DEBUG_AGENT_VERBOSE
, "Received data [%02x]\n", InputCharacter
);
2577 // Ack OK for break-in symbol
2579 SendAckPacket (DEBUG_COMMAND_OK
);
2582 // If receive GO command in Debug Timer, means HOST may lost ACK packet before.
2584 if (InputCharacter
== DEBUG_COMMAND_GO
) {
2588 if (!IsHostAttached ()) {
2590 // Try to attach HOST, if no ack received after 200ms, return
2592 if (AttachHost (BreakCause
, READ_PACKET_TIMEOUT
, &BreakReceived
) != RETURN_SUCCESS
) {
2597 if (MultiProcessorDebugSupport()) {
2598 if(FindNextPendingBreakCpu () != -1) {
2599 SetCpuBreakFlagByIndex (ProcessorIndex
, TRUE
);
2601 HaltOtherProcessors (ProcessorIndex
);
2604 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2605 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2606 AcquireMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2612 // Clear EOI before exiting interrupt process routine.
2616 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2621 if (Vector
<= DEBUG_EXCEPT_SIMD
) {
2622 DebugAgentMsgPrint (
2624 "Exception happened, ExceptionNum is %d, EIP = 0x%x.\n",
2626 (UINTN
) CpuContext
->Eip
2628 if (BreakCause
== DEBUG_DATA_BREAK_CAUSE_STEPPING
) {
2630 // If exception happened when executing Stepping, send Ack package.
2631 // HOST consider Stepping command was finished.
2633 if (MultiProcessorDebugSupport()) {
2634 mDebugMpContext
.BreakAtCpuIndex
= ProcessorIndex
;
2637 // Clear Stepping flag and restore EFLAGS.IF
2639 CommandSteppingCleanup (CpuContext
);
2640 SendAckPacket (DEBUG_COMMAND_OK
);
2643 // Exception occurs, send Break packet to HOST
2645 AcquireMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2647 // Only the first breaking processor could send BREAK_POINT to HOST
2649 if (IsFirstBreakProcessor (ProcessorIndex
)) {
2650 SendBreakPacketToHost (BreakCause
, ProcessorIndex
, &BreakReceived
);
2652 ReleaseMpSpinLock (&mDebugMpContext
.DebugPortSpinLock
);
2655 CommandCommunication (Vector
, CpuContext
, BreakReceived
);
2660 if (MultiProcessorDebugSupport()) {
2662 // Clear flag and wait for all processors run here
2664 SetIpiSentByApFlag (FALSE
);
2665 while (mDebugMpContext
.RunCommandSet
) {
2670 // Only current (view) processor could clean up AgentInProgress flag.
2672 if (mDebugMpContext
.ViewPointIndex
== ProcessorIndex
) {
2673 IssuedViewPoint
= mDebugMpContext
.ViewPointIndex
;
2677 if (IssuedViewPoint
== ProcessorIndex
&& GetDebugFlag (DEBUG_AGENT_FLAG_STEPPING
) != 1) {
2679 // If the command is not stepping, clean up AgentInProgress flag
2681 SetDebugFlag (DEBUG_AGENT_FLAG_AGENT_IN_PROGRESS
, 0);