IntelFrameworkModulePkg/Library/PeiDxeDebugLibReportStatusCode/DebugLib.c

   1 /** @file
   2   Debug Library based on report status code library.
   3
   4   Note that if the debug message length is larger than the maximum allowable
   5   record length, then the debug message will be ignored directly.
   6
   7   Copyright (c) 2006 - 2011, 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
  12
  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.
  15
  16 **/
  17
  18 #include <FrameworkPei.h>
  19
  20 #include <Guid/StatusCodeDataTypeId.h>
  21 #include <Guid/StatusCodeDataTypeDebug.h>
  22
  23 #include <Library/DebugLib.h>
  24 #include <Library/BaseLib.h>
  25 #include <Library/BaseMemoryLib.h>
  26 #include <Library/ReportStatusCodeLib.h>
  27 #include <Library/PcdLib.h>
  28 #include <Library/DebugPrintErrorLevelLib.h>
  29
  30 /**
  31   Prints a debug message to the debug output device if the specified error level is enabled.
  32
  33   If any bit in ErrorLevel is also set in DebugPrintErrorLevelLib function
  34   GetDebugPrintErrorLevel (), then print the message specified by Format and the
  35   associated variable argument list to the debug output device.
  36
  37   If Format is NULL, then ASSERT().
  38
  39   If the length of the message string specificed by Format is larger than the maximum allowable
  40   record length, then directly return and not print it.
  41
  42   @param  ErrorLevel  The error level of the debug message.
  43   @param  Format      Format string for the debug message to print.
  44   @param  ...         Variable argument list whose contents are accessed
  45                       based on the format string specified by Format.
  46
  47 **/
  48 VOID
  49 EFIAPI
  50 DebugPrint (
  51   IN  UINTN        ErrorLevel,
  52   IN  CONST CHAR8  *Format,
  53   ...
  54   )
  55 {
  56   UINT64          Buffer[(EFI_STATUS_CODE_DATA_MAX_SIZE / sizeof (UINT64)) + 1];
  57   EFI_DEBUG_INFO  *DebugInfo;
  58   UINTN           TotalSize;
  59   VA_LIST         VaListMarker;
  60   BASE_LIST       BaseListMarker;
  61   CHAR8           *FormatString;
  62   BOOLEAN         Long;
  63
  64   //
  65   // If Format is NULL, then ASSERT().
  66   //
  67   ASSERT (Format != NULL);
  68
  69   //
  70   // Check driver Debug Level value and global debug level
  71   //
  72   if ((ErrorLevel & GetDebugPrintErrorLevel ()) == 0) {
  73     return;
  74   }
  75
  76   //
  77   // Compute the total size of the record.
  78   // Note that the passing-in format string and variable parameters will be constructed to
  79   // the following layout:
  80   //
  81   //         Buffer->|------------------------|
  82   //                 |         Padding        | 4 bytes
  83   //      DebugInfo->|------------------------|
  84   //                 |      EFI_DEBUG_INFO    | sizeof(EFI_DEBUG_INFO)
  85   // BaseListMarker->|------------------------|
  86   //                 |           ...          |
  87   //                 |   variable arguments   | 12 * sizeof (UINT64)
  88   //                 |           ...          |
  89   //                 |------------------------|
  90   //                 |       Format String    |
  91   //                 |------------------------|<- (UINT8 *)Buffer + sizeof(Buffer)
  92   //
  93   TotalSize = 4 + sizeof (EFI_DEBUG_INFO) + 12 * sizeof (UINT64) + AsciiStrSize (Format);
  94
  95   //
  96   // If the TotalSize is larger than the maximum record size, then return
  97   //
  98   if (TotalSize > sizeof (Buffer)) {
  99     return;
 100   }
 101
 102   //
 103   // Fill in EFI_DEBUG_INFO
 104   //
 105   // Here we skip the first 4 bytes of Buffer, because we must ensure BaseListMarker is
 106   // 64-bit aligned, otherwise retrieving 64-bit parameter from BaseListMarker will cause
 107   // exception on IPF. Buffer starts at 64-bit aligned address, so skipping 4 types (sizeof(EFI_DEBUG_INFO))
 108   // just makes address of BaseListMarker, which follows DebugInfo, 64-bit aligned.
 109   //
 110   DebugInfo             = (EFI_DEBUG_INFO *)(Buffer) + 1;
 111   DebugInfo->ErrorLevel = (UINT32)ErrorLevel;
 112   BaseListMarker        = (BASE_LIST)(DebugInfo + 1);
 113   FormatString          = (CHAR8 *)((UINT64 *)(DebugInfo + 1) + 12);
 114
 115   //
 116   // Copy the Format string into the record
 117   //
 118   AsciiStrCpy (FormatString, Format);
 119
 120   //
 121   // The first 12 * sizeof (UINT64) bytes following EFI_DEBUG_INFO are for variable arguments
 122   // of format in DEBUG string, which is followed by the DEBUG format string.
 123   // Here we will process the variable arguments and pack them in this area.
 124   //
 125   VA_START (VaListMarker, Format);
 126   for (; *Format != '\0'; Format++) {
 127     //
 128     // Only format with prefix % is processed.
 129     //
 130     if (*Format != '%') {
 131       continue;
 132     }
 133     Long = FALSE;
 134     //
 135     // Parse Flags and Width
 136     //
 137     for (Format++; TRUE; Format++) {
 138       if (*Format == '.' || *Format == '-' || *Format == '+' || *Format == ' ') {
 139         //
 140         // These characters in format field are omitted.
 141         //
 142         continue;
 143       }
 144       if (*Format >= '0' && *Format <= '9') {
 145         //
 146         // These characters in format field are omitted.
 147         //
 148         continue;
 149       }
 150       if (*Format == 'L' || *Format == 'l') {
 151         //
 152         // 'L" or "l" in format field means the number being printed is a UINT64
 153         //
 154         Long = TRUE;
 155         continue;
 156       }
 157       if (*Format == '*') {
 158         //
 159         // '*' in format field means the precision of the field is specified by
 160         // a UINTN argument in the argument list.
 161         //
 162         BASE_ARG (BaseListMarker, UINTN) = VA_ARG (VaListMarker, UINTN);
 163         continue;
 164       }
 165       if (*Format == '\0') {
 166         //
 167         // Make no output if Format string terminates unexpectedly when
 168         // looking up for flag, width, precision and type.
 169         //
 170         Format--;
 171       }
 172       //
 173       // When valid argument type detected or format string terminates unexpectedly,
 174       // the inner loop is done.
 175       //
 176       break;
 177     }
 178
 179     //
 180     // Pack variable arguments into the storage area following EFI_DEBUG_INFO.
 181     //
 182     if ((*Format == 'p') && (sizeof (VOID *) > 4)) {
 183       Long = TRUE;
 184     }
 185     if (*Format == 'p' || *Format == 'X' || *Format == 'x' || *Format == 'd') {
 186       if (Long) {
 187         BASE_ARG (BaseListMarker, INT64) = VA_ARG (VaListMarker, INT64);
 188       } else {
 189         BASE_ARG (BaseListMarker, int) = VA_ARG (VaListMarker, int);
 190       }
 191     } else if (*Format == 's' || *Format == 'S' || *Format == 'a' || *Format == 'g' || *Format == 't') {
 192       BASE_ARG (BaseListMarker, VOID *) = VA_ARG (VaListMarker, VOID *);
 193     } else if (*Format == 'c') {
 194       BASE_ARG (BaseListMarker, UINTN) = VA_ARG (VaListMarker, UINTN);
 195     } else if (*Format == 'r') {
 196       BASE_ARG (BaseListMarker, RETURN_STATUS) = VA_ARG (VaListMarker, RETURN_STATUS);
 197     }
 198
 199     //
 200     // If the converted BASE_LIST is larger than the 12 * sizeof (UINT64) allocated bytes, then ASSERT()
 201     // This indicates that the DEBUG() macro is passing in more argument than can be handled by
 202     // the EFI_DEBUG_INFO record
 203     //
 204     ASSERT ((CHAR8 *)BaseListMarker <= FormatString);
 205
 206     //
 207     // If the converted BASE_LIST is larger than the 12 * sizeof (UINT64) allocated bytes, then return
 208     //
 209     if ((CHAR8 *)BaseListMarker > FormatString) {
 210       return;
 211     }
 212   }
 213   VA_END (VaListMarker);
 214
 215   //
 216   // Send the DebugInfo record
 217   //
 218   REPORT_STATUS_CODE_EX (
 219     EFI_DEBUG_CODE,
 220     (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_DC_UNSPECIFIED),
 221     0,
 222     NULL,
 223     &gEfiStatusCodeDataTypeDebugGuid,
 224     DebugInfo,
 225     TotalSize
 226     );
 227 }
 228
 229 /**
 230   Prints an assert message containing a filename, line number, and description.
 231   This may be followed by a breakpoint or a dead loop.
 232
 233   Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
 234   to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of
 235   PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if
 236   DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then
 237   CpuDeadLoop() is called.  If neither of these bits are set, then this function
 238   returns immediately after the message is printed to the debug output device.
 239   DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
 240   processing another DebugAssert(), then DebugAssert() must return immediately.
 241
 242   If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
 243   If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
 244
 245   @param  FileName     Pointer to the name of the source file that generated the assert condition.
 246   @param  LineNumber   The line number in the source file that generated the assert condition
 247   @param  Description  Pointer to the description of the assert condition.
 248
 249 **/
 250 VOID
 251 EFIAPI
 252 DebugAssert (
 253   IN CONST CHAR8  *FileName,
 254   IN UINTN        LineNumber,
 255   IN CONST CHAR8  *Description
 256   )
 257 {
 258   UINT64                 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE / sizeof(UINT64)];
 259   EFI_DEBUG_ASSERT_DATA  *AssertData;
 260   UINTN                  TotalSize;
 261   CHAR8                  *Temp;
 262   UINTN                  FileNameSize;
 263   UINTN                  DescriptionSize;
 264
 265   //
 266   // Make sure it will all fit in the passed in buffer
 267   //
 268   FileNameSize    = AsciiStrSize (FileName);
 269   DescriptionSize = AsciiStrSize (Description);
 270   TotalSize = sizeof (EFI_DEBUG_ASSERT_DATA) + FileNameSize + DescriptionSize;
 271   if (TotalSize <= sizeof (Buffer)) {
 272     //
 273     // Fill in EFI_DEBUG_ASSERT_DATA
 274     //
 275     AssertData = (EFI_DEBUG_ASSERT_DATA *)Buffer;
 276     AssertData->LineNumber = (UINT32)LineNumber;
 277
 278     //
 279     // Copy Ascii FileName including NULL.
 280     //
 281     Temp = AsciiStrCpy ((CHAR8 *)(AssertData + 1), FileName);
 282
 283     //
 284     // Copy Ascii Description
 285     //
 286     AsciiStrCpy (Temp + FileNameSize, Description);
 287
 288     REPORT_STATUS_CODE_EX (
 289       (EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
 290       (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
 291       0,
 292       NULL,
 293       NULL,
 294       AssertData,
 295       TotalSize
 296       );
 297   }
 298
 299   //
 300   // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
 301   //
 302   if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
 303     CpuBreakpoint ();
 304   } else if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
 305     CpuDeadLoop ();
 306   }
 307 }
 308
 309
 310 /**
 311   Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
 312
 313   This function fills Length bytes of Buffer with the value specified by
 314   PcdDebugClearMemoryValue, and returns Buffer.
 315
 316   If Buffer is NULL, then ASSERT().
 317   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 318
 319   @param   Buffer  Pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
 320   @param   Length  Number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue.
 321
 322   @return  Buffer  Pointer to the target buffer filled with PcdDebugClearMemoryValue.
 323
 324 **/
 325 VOID *
 326 EFIAPI
 327 DebugClearMemory (
 328   OUT VOID  *Buffer,
 329   IN UINTN  Length
 330   )
 331 {
 332   ASSERT (Buffer != NULL);
 333
 334   return SetMem (Buffer, Length, PcdGet8 (PcdDebugClearMemoryValue));
 335 }
 336
 337
 338 /**
 339   Returns TRUE if ASSERT() macros are enabled.
 340
 341   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of
 342   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 343
 344   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
 345   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
 346
 347 **/
 348 BOOLEAN
 349 EFIAPI
 350 DebugAssertEnabled (
 351   VOID
 352   )
 353 {
 354   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
 355 }
 356
 357
 358 /**
 359   Returns TRUE if DEBUG() macros are enabled.
 360
 361   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of
 362   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 363
 364   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
 365   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
 366
 367 **/
 368 BOOLEAN
 369 EFIAPI
 370 DebugPrintEnabled (
 371   VOID
 372   )
 373 {
 374   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
 375 }
 376
 377
 378 /**
 379   Returns TRUE if DEBUG_CODE() macros are enabled.
 380
 381   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of
 382   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 383
 384   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
 385   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
 386
 387 **/
 388 BOOLEAN
 389 EFIAPI
 390 DebugCodeEnabled (
 391   VOID
 392   )
 393 {
 394   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
 395 }
 396
 397
 398 /**
 399   Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
 400
 401   This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of
 402   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 403
 404   @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
 405   @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
 406
 407 **/
 408 BOOLEAN
 409 EFIAPI
 410 DebugClearMemoryEnabled (
 411   VOID
 412   )
 413 {
 414   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
 415 }