BaseTools/Capsule: Do not support -o with --dump-info
[mirror_edk2.git] / EmbeddedPkg / GdbStub / GdbStubInternal.h
1 /** @file
2 Private include file for GDB stub
3
4 Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #ifndef __GDB_STUB_INTERNAL__
17 #define __GDB_STUB_INTERNAL__
18
19 #include <Uefi.h>
20 #include <Library/BaseLib.h>
21 #include <Library/BaseMemoryLib.h>
22 #include <Library/MemoryAllocationLib.h>
23 #include <Library/DebugLib.h>
24 #include <Library/UefiLib.h>
25 #include <Library/UefiBootServicesTableLib.h>
26 #include <Library/PcdLib.h>
27 #include <Library/GdbSerialLib.h>
28 #include <Library/PrintLib.h>
29
30 #include <Protocol/DebugSupport.h>
31 #include <Protocol/SerialIo.h>
32 #include <Protocol/LoadedImage.h>
33 #include <Protocol/LoadedImage.h>
34 #include <Guid/DebugImageInfoTable.h>
35 #include <IndustryStandard/PeImage.h>
36
37 extern CONST CHAR8 mHexToStr[];
38
39 // maximum size of input and output buffers
40 // This value came from the show remote command of the gdb we tested against
41 #define MAX_BUF_SIZE 2000
42
43 // maximum size of address buffer
44 #define MAX_ADDR_SIZE 32
45
46 // maximum size of register number buffer
47 #define MAX_REG_NUM_BUF_SIZE 32
48
49 // maximum size of length buffer
50 #define MAX_LENGTH_SIZE 32
51
52 // maximum size of T signal members
53 #define MAX_T_SIGNAL_SIZE 64
54
55 // the mask used to clear all the cache
56 #define TF_BIT 0x00000100
57
58
59 //
60 // GDB Signal definitions - generic names for interrupts
61 //
62 #define GDB_SIGILL 4 // Illegal instruction
63 #define GDB_SIGTRAP 5 // Trace Trap (Breakpoint and SingleStep)
64 #define GDB_SIGEMT 7 // Emulator Trap
65 #define GDB_SIGFPE 8 // Floating point exception
66 #define GDB_SIGSEGV 11 // Segment violation, page fault
67
68
69 //
70 // GDB File I/O Error values, zero means no error
71 // Includes all general GDB Unix like error values
72 //
73 #define GDB_EBADMEMADDRBUFSIZE 11 // the buffer that stores memory Address to be read from/written to is not the right size
74 #define GDB_EBADMEMLENGBUFSIZE 12 // the buffer that stores Length is not the right size
75 #define GDB_EBADMEMLENGTH 13 // Length, the given number of bytes to read or write, is not the right size
76 #define GDB_EBADMEMDATA 14 // one of the bytes or nibbles of the memory is leess than 0
77 #define GDB_EBADMEMDATASIZE 15 // the memory data, 'XX..', is too short or too long
78 #define GDB_EBADBUFSIZE 21 // the buffer created is not the correct size
79 #define GDB_EINVALIDARG 31 // argument is invalid
80 #define GDB_ENOSPACE 41 //
81 #define GDB_EINVALIDBRKPOINTTYPE 51 // the breakpoint type is not recognized
82 #define GDB_EINVALIDREGNUM 61 // given register number is not valid: either <0 or >=Number of Registers
83 #define GDB_EUNKNOWN 255 // unknown
84
85
86 //
87 // These devices are open by GDB so we can just read and write to them
88 //
89 #define GDB_STDIN 0x00
90 #define GDB_STDOUT 0x01
91 #define GDB_STDERR 0x02
92
93 //
94 //Define Register size for different architectures
95 //
96 #if defined (MDE_CPU_IA32)
97 #define REG_SIZE 32
98 #elif defined (MDE_CPU_X64)
99 #define REG_SIZE 64
100 #elif defined (MDE_CPU_ARM)
101 #define REG_SIZE 32
102 #endif
103
104 #define GDB_SERIAL_DEV_SIGNATURE SIGNATURE_32 ('g', 'd', 'b', 's')
105
106 typedef struct {
107 VENDOR_DEVICE_PATH VendorDevice;
108 UINT32 Index; // Suport more than one
109 EFI_DEVICE_PATH_PROTOCOL End;
110 } GDB_SERIAL_DEVICE_PATH;
111
112 //
113 // Name: SERIAL_DEV
114 // Purpose: To provide device specific information
115 // Fields:
116 // Signature UINTN: The identity of the serial device
117 // SerialIo SERIAL_IO_PROTOCOL: Serial I/O protocol interface
118 // SerialMode SERIAL_IO_MODE:
119 // DevicePath EFI_DEVICE_PATH_PROTOCOL *: Device path of the serial device
120 //
121 typedef struct {
122 UINTN Signature;
123 EFI_HANDLE Handle;
124 EFI_SERIAL_IO_PROTOCOL SerialIo;
125 EFI_SERIAL_IO_MODE SerialMode;
126 GDB_SERIAL_DEVICE_PATH DevicePath;
127 INTN InFileDescriptor;
128 INTN OutFileDescriptor;
129 } GDB_SERIAL_DEV;
130
131
132 #define GDB_SERIAL_DEV_FROM_THIS(a) CR (a, GDB_SERIAL_DEV, SerialIo, GDB_SERIAL_DEV_SIGNATURE)
133
134
135 typedef struct {
136 EFI_EXCEPTION_TYPE Exception;
137 UINT8 SignalNo;
138 } EFI_EXCEPTION_TYPE_ENTRY;
139
140
141 #if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64)
142
143 //
144 // Byte packed structure for DR6
145 // 32-bits on IA-32
146 // 64-bits on X64. The upper 32-bits on X64 are reserved
147 //
148 typedef union {
149 struct {
150 UINT32 B0:1; // Breakpoint condition detected
151 UINT32 B1:1; // Breakpoint condition detected
152 UINT32 B2:1; // Breakpoint condition detected
153 UINT32 B3:1; // Breakpoint condition detected
154 UINT32 Reserved_1:9; // Reserved
155 UINT32 BD:1; // Debug register access detected
156 UINT32 BS:1; // Single step
157 UINT32 BT:1; // Task switch
158 UINT32 Reserved_2:16; // Reserved
159 } Bits;
160 UINTN UintN;
161 } IA32_DR6;
162
163 //
164 // Byte packed structure for DR7
165 // 32-bits on IA-32
166 // 64-bits on X64. The upper 32-bits on X64 are reserved
167 //
168 typedef union {
169 struct {
170 UINT32 L0:1; // Local breakpoint enable
171 UINT32 G0:1; // Global breakpoint enable
172 UINT32 L1:1; // Local breakpoint enable
173 UINT32 G1:1; // Global breakpoint enable
174 UINT32 L2:1; // Local breakpoint enable
175 UINT32 G2:1; // Global breakpoint enable
176 UINT32 L3:1; // Local breakpoint enable
177 UINT32 G3:1; // Global breakpoint enable
178 UINT32 LE:1; // Local exact breakpoint enable
179 UINT32 GE:1; // Global exact breakpoint enable
180 UINT32 Reserved_1:3; // Reserved
181 UINT32 GD:1; // Global detect enable
182 UINT32 Reserved_2:2; // Reserved
183 UINT32 RW0:2; // Read/Write field
184 UINT32 LEN0:2; // Length field
185 UINT32 RW1:2; // Read/Write field
186 UINT32 LEN1:2; // Length field
187 UINT32 RW2:2; // Read/Write field
188 UINT32 LEN2:2; // Length field
189 UINT32 RW3:2; // Read/Write field
190 UINT32 LEN3:2; // Length field
191 } Bits;
192 UINTN UintN;
193 } IA32_DR7;
194
195 #endif /* if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) */
196
197 typedef enum {
198 InstructionExecution, //Hardware breakpoint
199 DataWrite, //watch
200 DataRead, //rwatch
201 DataReadWrite, //awatch
202 SoftwareBreakpoint, //Software breakpoint
203 NotSupported
204 } BREAK_TYPE;
205
206 //
207 // Array of exception types that need to be hooked by the debugger
208 //
209 extern EFI_EXCEPTION_TYPE_ENTRY gExceptionType[];
210
211 //
212 // Set TRUE if F Reply package signals a ctrl-c. We can not process the Ctrl-c
213 // here we need to wait for the periodic callback to do this.
214 //
215 extern BOOLEAN gCtrlCBreakFlag;
216
217 //
218 // If the periodic callback is called while we are processing an F packet we need
219 // to let the callback know to not read from the serail stream as it could steal
220 // characters from the F reponse packet
221 //
222 extern BOOLEAN gProcessingFPacket;
223
224
225 // The offsets of registers SystemContext.
226 // The fields in the array are in the gdb ordering.
227 //
228 extern UINTN gRegisterOffsets[];
229
230 /**
231 Return the number of entries in the gExceptionType[]
232
233 @retval UINTN, the number of entries in the gExceptionType[] array.
234 **/
235 UINTN
236 MaxEfiException (
237 VOID
238 );
239
240
241 /**
242 Return the number of entries in the gRegisters[]
243
244 @retval UINTN, the number of entries (registers) in the gRegisters[] array.
245 **/
246 UINTN
247 MaxRegisterCount (
248 VOID
249 );
250
251
252 /**
253 Check to see if the ISA is supported.
254 ISA = Instruction Set Architecture
255
256 @retval TRUE if Isa is supported,
257 FALSE otherwise.
258 **/
259 BOOLEAN
260 CheckIsa (
261 IN EFI_INSTRUCTION_SET_ARCHITECTURE Isa
262 );
263
264
265 /**
266 Send the T signal with the given exception type (in gdb order) and possibly with n:r pairs related to the watchpoints
267
268 @param SystemContext Register content at time of the exception
269 @param GdbExceptionType GDB exception type
270 **/
271
272 VOID
273 GdbSendTSignal (
274 IN EFI_SYSTEM_CONTEXT SystemContext,
275 IN UINT8 GdbExceptionType
276 );
277
278
279 /**
280 Translates the EFI mapping to GDB mapping
281
282 @param EFIExceptionType EFI Exception that is being processed
283 @retval UINTN that corresponds to EFIExceptionType's GDB exception type number
284 **/
285 UINT8
286 ConvertEFItoGDBtype (
287 IN EFI_EXCEPTION_TYPE EFIExceptionType
288 );
289
290
291 /**
292 Empties the given buffer
293 @param *Buf pointer to the first element in buffer to be emptied
294 **/
295 VOID
296 EmptyBuffer (
297 IN CHAR8 *Buf
298 );
299
300
301 /**
302 Converts an 8-bit Hex Char into a INTN.
303
304 @param Char - the hex character to be converted into UINTN
305 @retval a INTN, from 0 to 15, that corressponds to Char
306 -1 if Char is not a hex character
307 **/
308 INTN
309 HexCharToInt (
310 IN CHAR8 Char
311 );
312
313
314 /** 'E NN'
315 Send an error with the given error number after converting to hex.
316 The error number is put into the buffer in hex. '255' is the biggest errno we can send.
317 ex: 162 will be sent as A2.
318
319 @param errno the error number that will be sent
320 **/
321 VOID
322 EFIAPI
323 SendError (
324 IN UINT8 ErrorNum
325 );
326
327
328 /**
329 Send 'OK' when the function is done executing successfully.
330 **/
331 VOID
332 SendSuccess (
333 VOID
334 );
335
336
337 /**
338 Send empty packet to specify that particular command/functionality is not supported.
339 **/
340 VOID
341 SendNotSupported (
342 VOID
343 );
344
345 /** ‘p n’
346 Reads the n-th register's value into an output buffer and sends it as a packet
347 @param SystemContext Register content at time of the exception
348 @param InBuffer This is the input buffer received from gdb server
349 **/
350 VOID
351 ReadNthRegister (
352 IN EFI_SYSTEM_CONTEXT SystemContext,
353 IN CHAR8 *InBuffer
354 );
355
356
357 /** ‘g’
358 Reads the general registers into an output buffer and sends it as a packet
359 @param SystemContext Register content at time of the exception
360 **/
361 VOID
362 ReadGeneralRegisters (
363 IN EFI_SYSTEM_CONTEXT SystemContext
364 );
365
366
367 /** ‘P n...=r...’
368 Writes the new value of n-th register received into the input buffer to the n-th register
369 @param SystemContext Register content at time of the exception
370 @param InBuffer This is the input buffer received from gdb server
371 **/
372 VOID
373 WriteNthRegister (
374 IN EFI_SYSTEM_CONTEXT SystemContext,
375 IN CHAR8 *InBuffer
376 );
377
378
379 /** ‘G XX...’
380 Writes the new values received into the input buffer to the general registers
381 @param SystemContext Register content at time of the exception
382 @param InBuffer Pointer to the input buffer received from gdb server
383 **/
384
385 VOID
386 WriteGeneralRegisters (
387 IN EFI_SYSTEM_CONTEXT SystemContext,
388 IN CHAR8 *InBuffer
389 );
390
391
392 /** ‘m addr,length ’
393 Find the Length of the area to read and the start addres. Finally, pass them to
394 another function, TransferFromMemToOutBufAndSend, that will read from that memory space and
395 send it as a packet.
396
397 @param *PacketData Pointer to Payload data for the packet
398 **/
399 VOID
400 ReadFromMemory (
401 IN CHAR8 *PacketData
402 );
403
404
405 /** ‘M addr,length :XX...’
406 Find the Length of the area in bytes to write and the start addres. Finally, pass them to
407 another function, TransferFromInBufToMem, that will write to that memory space the info in
408 the input buffer.
409
410 @param PacketData Pointer to Payload data for the packet
411 **/
412 VOID
413 WriteToMemory (
414 IN CHAR8 *PacketData
415 );
416
417
418 /** ‘c [addr ]’
419 Continue. addr is Address to resume. If addr is omitted, resume at current
420 Address.
421
422 @param SystemContext Register content at time of the exception
423 @param *PacketData Pointer to PacketData
424 **/
425
426 VOID
427 ContinueAtAddress (
428 IN EFI_SYSTEM_CONTEXT SystemContext,
429 IN CHAR8 *PacketData
430 );
431
432
433 /** ‘s [addr ]’
434 Single step. addr is the Address at which to resume. If addr is omitted, resume
435 at same Address.
436
437 @param SystemContext Register content at time of the exception
438 @param PacketData Pointer to Payload data for the packet
439 **/
440 VOID
441 SingleStep (
442 IN EFI_SYSTEM_CONTEXT SystemContext,
443 IN CHAR8 *PacketData
444 );
445
446 /**
447 Insert Single Step in the SystemContext
448
449 @param SystemContext Register content at time of the exception
450 **/
451 VOID
452 AddSingleStep (
453 IN EFI_SYSTEM_CONTEXT SystemContext
454 );
455
456 /**
457 Remove Single Step in the SystemContext
458
459 @param SystemContext Register content at time of the exception
460 **/
461 VOID
462 RemoveSingleStep (
463 IN EFI_SYSTEM_CONTEXT SystemContext
464 );
465
466
467 /**
468 ‘Z1, [addr], [length]’
469 ‘Z2, [addr], [length]’
470 ‘Z3, [addr], [length]’
471 ‘Z4, [addr], [length]’
472
473 Insert hardware breakpoint/watchpoint at address addr of size length
474
475 @param SystemContext Register content at time of the exception
476 @param *PacketData Pointer to the Payload data for the packet
477
478 **/
479 VOID
480 EFIAPI
481 InsertBreakPoint(
482 IN EFI_SYSTEM_CONTEXT SystemContext,
483 IN CHAR8 *PacketData
484 );
485
486
487 /**
488 ‘z1, [addr], [length]’
489 ‘z2, [addr], [length]’
490 ‘z3, [addr], [length]’
491 ‘z4, [addr], [length]’
492
493 Remove hardware breakpoint/watchpoint at address addr of size length
494
495 @param SystemContext Register content at time of the exception
496 @param *PacketData Pointer to the Payload data for the packet
497
498 **/
499 VOID
500 EFIAPI
501 RemoveBreakPoint(
502 IN EFI_SYSTEM_CONTEXT SystemContext,
503 IN CHAR8 *PacketData
504 );
505
506
507 /**
508 Exception Hanldler for GDB. It will be called for all exceptions
509 registered via the gExceptionType[] array.
510
511 @param ExceptionType Exception that is being processed
512 @param SystemContext Register content at time of the exception
513
514 **/
515 VOID
516 EFIAPI
517 GdbExceptionHandler (
518 IN EFI_EXCEPTION_TYPE ExceptionType,
519 IN OUT EFI_SYSTEM_CONTEXT SystemContext
520 );
521
522
523 /**
524 Periodic callback for GDB. This function is used to catch a ctrl-c or other
525 break in type command from GDB.
526
527 @param SystemContext Register content at time of the call
528
529 **/
530 VOID
531 EFIAPI
532 GdbPeriodicCallBack (
533 IN OUT EFI_SYSTEM_CONTEXT SystemContext
534 );
535
536
537 /**
538 Make two serail consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.
539
540 These console show up on the remote system running GDB
541
542 **/
543
544 VOID
545 GdbInitializeSerialConsole (
546 VOID
547 );
548
549
550 /**
551 Send a GDB Remote Serial Protocol Packet
552
553 $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',
554 the packet teminating character '#' and the two digit checksum.
555
556 If an ack '+' is not sent resend the packet, but timeout eventually so we don't end up
557 in an infinit loop. This is so if you unplug the debugger code just keeps running
558
559 @param PacketData Payload data for the packet
560
561 @retval Number of bytes of packet data sent.
562
563 **/
564 UINTN
565 SendPacket (
566 IN CHAR8 *PacketData
567 );
568
569
570 /**
571 Receive a GDB Remote Serial Protocol Packet
572
573 $PacketData#checksum PacketData is passed in and this function adds the packet prefix '$',
574 the packet teminating character '#' and the two digit checksum.
575
576 If host re-starts sending a packet without ending the previous packet, only the last valid packet is processed.
577 (In other words, if received packet is '$12345$12345$123456#checksum', only '$123456#checksum' will be processed.)
578
579 If an ack '+' is not sent resend the packet
580
581 @param PacketData Payload data for the packet
582
583 @retval Number of bytes of packet data received.
584
585 **/
586 UINTN
587 ReceivePacket (
588 OUT CHAR8 *PacketData,
589 IN UINTN PacketDataSize
590 );
591
592
593 /**
594 Read data from a FileDescriptor. On success number of bytes read is returned. Zero indicates
595 the end of a file. On error -1 is returned. If count is zero, GdbRead returns zero.
596
597 @param FileDescriptor Device to talk to.
598 @param Buffer Buffer to hold Count bytes that were read
599 @param Count Number of bytes to transfer.
600
601 @retval -1 Error
602 @retval {other} Number of bytes read.
603
604 **/
605 INTN
606 GdbRead (
607 IN INTN FileDescriptor,
608 OUT VOID *Buffer,
609 IN UINTN Count
610 );
611
612
613 /**
614 Write data to a FileDescriptor. On success number of bytes written is returned. Zero indicates
615 nothing was written. On error -1 is returned.
616
617 @param FileDescriptor Device to talk to.
618 @param Buffer Buffer to hold Count bytes that are to be written
619 @param Count Number of bytes to transfer.
620
621 @retval -1 Error
622 @retval {other} Number of bytes written.
623
624 **/
625 INTN
626 GdbWrite (
627 IN INTN FileDescriptor,
628 OUT CONST VOID *Buffer,
629 IN UINTN Count
630 );
631
632 UINTN *
633 FindPointerToRegister (
634 IN EFI_SYSTEM_CONTEXT SystemContext,
635 IN UINTN RegNumber
636 );
637
638 CHAR8 *
639 BasicReadRegister (
640 IN EFI_SYSTEM_CONTEXT SystemContext,
641 IN UINTN RegNumber,
642 IN CHAR8 *OutBufPtr
643 );
644
645 VOID
646 TransferFromInBufToMem (
647 IN UINTN Length,
648 IN UINT8 *Address,
649 IN CHAR8 *NewData
650 );
651
652 VOID
653 TransferFromMemToOutBufAndSend (
654 IN UINTN Length,
655 IN UINT8 *Address
656 );
657
658 CHAR8 *
659 BasicWriteRegister (
660 IN EFI_SYSTEM_CONTEXT SystemContext,
661 IN UINTN RegNumber,
662 IN CHAR8 *InBufPtr
663 );
664
665 VOID
666 PrintReg (
667 EFI_SYSTEM_CONTEXT SystemContext
668 );
669
670 UINTN
671 ParseBreakpointPacket (
672 IN CHAR8 *PacketData,
673 OUT UINTN *Type,
674 OUT UINTN *Address,
675 OUT UINTN *Length
676 );
677
678 UINTN
679 GetBreakpointDataAddress (
680 IN EFI_SYSTEM_CONTEXT SystemContext,
681 IN UINTN BreakpointNumber
682 );
683
684 UINTN
685 GetBreakpointDetected (
686 IN EFI_SYSTEM_CONTEXT SystemContext
687 );
688
689 BREAK_TYPE
690 GetBreakpointType (
691 IN EFI_SYSTEM_CONTEXT SystemContext,
692 IN UINTN BreakpointNumber
693 );
694
695 UINTN
696 ConvertLengthData (
697 IN UINTN Length
698 );
699
700 EFI_STATUS
701 FindNextFreeDebugRegister (
702 IN EFI_SYSTEM_CONTEXT SystemContext,
703 OUT UINTN *Register
704 );
705
706 EFI_STATUS
707 EnableDebugRegister (
708 IN EFI_SYSTEM_CONTEXT SystemContext,
709 IN UINTN Register,
710 IN UINTN Address,
711 IN UINTN Length,
712 IN UINTN Type
713 );
714
715 EFI_STATUS
716 FindMatchingDebugRegister (
717 IN EFI_SYSTEM_CONTEXT SystemContext,
718 IN UINTN Address,
719 IN UINTN Length,
720 IN UINTN Type,
721 OUT UINTN *Register
722 );
723
724 EFI_STATUS
725 DisableDebugRegister (
726 IN EFI_SYSTEM_CONTEXT SystemContext,
727 IN UINTN Register
728 );
729
730 VOID
731 InitializeProcessor (
732 VOID
733 );
734
735 BOOLEAN
736 ValidateAddress (
737 IN VOID *Address
738 );
739
740 BOOLEAN
741 ValidateException (
742 IN EFI_EXCEPTION_TYPE ExceptionType,
743 IN OUT EFI_SYSTEM_CONTEXT SystemContext
744 );
745
746 #endif