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 - 2012, 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       VA_END (VaListMarker);
 211       return;
 212     }
 213   }
 214   VA_END (VaListMarker);
 215
 216   //
 217   // Send the DebugInfo record
 218   //
 219   REPORT_STATUS_CODE_EX (
 220     EFI_DEBUG_CODE,
 221     (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_DC_UNSPECIFIED),
 222     0,
 223     NULL,
 224     &gEfiStatusCodeDataTypeDebugGuid,
 225     DebugInfo,
 226     TotalSize
 227     );
 228 }
 229
 230 /**
 231   Prints an assert message containing a filename, line number, and description.
 232   This may be followed by a breakpoint or a dead loop.
 233
 234   Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
 235   to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of
 236   PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if
 237   DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then
 238   CpuDeadLoop() is called.  If neither of these bits are set, then this function
 239   returns immediately after the message is printed to the debug output device.
 240   DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
 241   processing another DebugAssert(), then DebugAssert() must return immediately.
 242
 243   If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
 244   If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
 245
 246   @param  FileName     Pointer to the name of the source file that generated the assert condition.
 247   @param  LineNumber   The line number in the source file that generated the assert condition
 248   @param  Description  Pointer to the description of the assert condition.
 249
 250 **/
 251 VOID
 252 EFIAPI
 253 DebugAssert (
 254   IN CONST CHAR8  *FileName,
 255   IN UINTN        LineNumber,
 256   IN CONST CHAR8  *Description
 257   )
 258 {
 259   UINT64                 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE / sizeof(UINT64)];
 260   EFI_DEBUG_ASSERT_DATA  *AssertData;
 261   UINTN                  TotalSize;
 262   CHAR8                  *Temp;
 263   UINTN                  FileNameSize;
 264   UINTN                  DescriptionSize;
 265
 266   //
 267   // Make sure it will all fit in the passed in buffer
 268   //
 269   FileNameSize    = AsciiStrSize (FileName);
 270   DescriptionSize = AsciiStrSize (Description);
 271   TotalSize = sizeof (EFI_DEBUG_ASSERT_DATA) + FileNameSize + DescriptionSize;
 272   if (TotalSize <= sizeof (Buffer)) {
 273     //
 274     // Fill in EFI_DEBUG_ASSERT_DATA
 275     //
 276     AssertData = (EFI_DEBUG_ASSERT_DATA *)Buffer;
 277     AssertData->LineNumber = (UINT32)LineNumber;
 278
 279     //
 280     // Copy Ascii FileName including NULL.
 281     //
 282     Temp = AsciiStrCpy ((CHAR8 *)(AssertData + 1), FileName);
 283
 284     //
 285     // Copy Ascii Description
 286     //
 287     AsciiStrCpy (Temp + FileNameSize, Description);
 288
 289     REPORT_STATUS_CODE_EX (
 290       (EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
 291       (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
 292       0,
 293       NULL,
 294       NULL,
 295       AssertData,
 296       TotalSize
 297       );
 298   }
 299
 300   //
 301   // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
 302   //
 303   if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
 304     CpuBreakpoint ();
 305   } else if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
 306     CpuDeadLoop ();
 307   }
 308 }
 309
 310
 311 /**
 312   Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
 313
 314   This function fills Length bytes of Buffer with the value specified by
 315   PcdDebugClearMemoryValue, and returns Buffer.
 316
 317   If Buffer is NULL, then ASSERT().
 318   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 319
 320   @param   Buffer  Pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
 321   @param   Length  Number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue.
 322
 323   @return  Buffer  Pointer to the target buffer filled with PcdDebugClearMemoryValue.
 324
 325 **/
 326 VOID *
 327 EFIAPI
 328 DebugClearMemory (
 329   OUT VOID  *Buffer,
 330   IN UINTN  Length
 331   )
 332 {
 333   ASSERT (Buffer != NULL);
 334
 335   return SetMem (Buffer, Length, PcdGet8 (PcdDebugClearMemoryValue));
 336 }
 337
 338
 339 /**
 340   Returns TRUE if ASSERT() macros are enabled.
 341
 342   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of
 343   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 344
 345   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
 346   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
 347
 348 **/
 349 BOOLEAN
 350 EFIAPI
 351 DebugAssertEnabled (
 352   VOID
 353   )
 354 {
 355   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
 356 }
 357
 358
 359 /**
 360   Returns TRUE if DEBUG() macros are enabled.
 361
 362   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of
 363   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 364
 365   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
 366   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
 367
 368 **/
 369 BOOLEAN
 370 EFIAPI
 371 DebugPrintEnabled (
 372   VOID
 373   )
 374 {
 375   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
 376 }
 377
 378
 379 /**
 380   Returns TRUE if DEBUG_CODE() macros are enabled.
 381
 382   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of
 383   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 384
 385   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
 386   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
 387
 388 **/
 389 BOOLEAN
 390 EFIAPI
 391 DebugCodeEnabled (
 392   VOID
 393   )
 394 {
 395   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
 396 }
 397
 398
 399 /**
 400   Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
 401
 402   This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of
 403   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 404
 405   @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
 406   @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
 407
 408 **/
 409 BOOLEAN
 410 EFIAPI
 411 DebugClearMemoryEnabled (
 412   VOID
 413   )
 414 {
 415   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
 416 }