MdeModulePkg/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 - 2018, 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 <PiPei.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     TotalSize = sizeof (Buffer);
 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. It will be truncated if it's too long.
 117   //
 118   AsciiStrnCpyS (
 119     FormatString, sizeof(Buffer) - (4 + sizeof(EFI_DEBUG_INFO) + 12 * sizeof(UINT64)),
 120     Format,       sizeof(Buffer) - (4 + sizeof(EFI_DEBUG_INFO) + 12 * sizeof(UINT64)) - 1
 121     );
 122
 123   //
 124   // The first 12 * sizeof (UINT64) bytes following EFI_DEBUG_INFO are for variable arguments
 125   // of format in DEBUG string, which is followed by the DEBUG format string.
 126   // Here we will process the variable arguments and pack them in this area.
 127   //
 128   VA_START (VaListMarker, Format);
 129
 130   //
 131   // Use the actual format string.
 132   //
 133   Format = FormatString;
 134   for (; *Format != '\0'; Format++) {
 135     //
 136     // Only format with prefix % is processed.
 137     //
 138     if (*Format != '%') {
 139       continue;
 140     }
 141     Long = FALSE;
 142     //
 143     // Parse Flags and Width
 144     //
 145     for (Format++; TRUE; Format++) {
 146       if (*Format == '.' || *Format == '-' || *Format == '+' || *Format == ' ') {
 147         //
 148         // These characters in format field are omitted.
 149         //
 150         continue;
 151       }
 152       if (*Format >= '0' && *Format <= '9') {
 153         //
 154         // These characters in format field are omitted.
 155         //
 156         continue;
 157       }
 158       if (*Format == 'L' || *Format == 'l') {
 159         //
 160         // 'L" or "l" in format field means the number being printed is a UINT64
 161         //
 162         Long = TRUE;
 163         continue;
 164       }
 165       if (*Format == '*') {
 166         //
 167         // '*' in format field means the precision of the field is specified by
 168         // a UINTN argument in the argument list.
 169         //
 170         BASE_ARG (BaseListMarker, UINTN) = VA_ARG (VaListMarker, UINTN);
 171         continue;
 172       }
 173       if (*Format == '\0') {
 174         //
 175         // Make no output if Format string terminates unexpectedly when
 176         // looking up for flag, width, precision and type.
 177         //
 178         Format--;
 179       }
 180       //
 181       // When valid argument type detected or format string terminates unexpectedly,
 182       // the inner loop is done.
 183       //
 184       break;
 185     }
 186
 187     //
 188     // Pack variable arguments into the storage area following EFI_DEBUG_INFO.
 189     //
 190     if ((*Format == 'p') && (sizeof (VOID *) > 4)) {
 191       Long = TRUE;
 192     }
 193     if (*Format == 'p' || *Format == 'X' || *Format == 'x' || *Format == 'd' || *Format == 'u') {
 194       if (Long) {
 195         BASE_ARG (BaseListMarker, INT64) = VA_ARG (VaListMarker, INT64);
 196       } else {
 197         BASE_ARG (BaseListMarker, int) = VA_ARG (VaListMarker, int);
 198       }
 199     } else if (*Format == 's' || *Format == 'S' || *Format == 'a' || *Format == 'g' || *Format == 't') {
 200       BASE_ARG (BaseListMarker, VOID *) = VA_ARG (VaListMarker, VOID *);
 201     } else if (*Format == 'c') {
 202       BASE_ARG (BaseListMarker, UINTN) = VA_ARG (VaListMarker, UINTN);
 203     } else if (*Format == 'r') {
 204       BASE_ARG (BaseListMarker, RETURN_STATUS) = VA_ARG (VaListMarker, RETURN_STATUS);
 205     }
 206
 207     //
 208     // If the converted BASE_LIST is larger than the 12 * sizeof (UINT64) allocated bytes, then ASSERT()
 209     // This indicates that the DEBUG() macro is passing in more argument than can be handled by
 210     // the EFI_DEBUG_INFO record
 211     //
 212     ASSERT ((CHAR8 *)BaseListMarker <= FormatString);
 213
 214     //
 215     // If the converted BASE_LIST is larger than the 12 * sizeof (UINT64) allocated bytes, then return
 216     //
 217     if ((CHAR8 *)BaseListMarker > FormatString) {
 218       VA_END (VaListMarker);
 219       return;
 220     }
 221   }
 222   VA_END (VaListMarker);
 223
 224   //
 225   // Send the DebugInfo record
 226   //
 227   REPORT_STATUS_CODE_EX (
 228     EFI_DEBUG_CODE,
 229     (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_DC_UNSPECIFIED),
 230     0,
 231     NULL,
 232     &gEfiStatusCodeDataTypeDebugGuid,
 233     DebugInfo,
 234     TotalSize
 235     );
 236 }
 237
 238 /**
 239   Prints an assert message containing a filename, line number, and description.
 240   This may be followed by a breakpoint or a dead loop.
 241
 242   Print a message of the form "ASSERT <FileName>(<LineNumber>): <Description>\n"
 243   to the debug output device.  If DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED bit of
 244   PcdDebugProperyMask is set then CpuBreakpoint() is called. Otherwise, if
 245   DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED bit of PcdDebugProperyMask is set then
 246   CpuDeadLoop() is called.  If neither of these bits are set, then this function
 247   returns immediately after the message is printed to the debug output device.
 248   DebugAssert() must actively prevent recursion.  If DebugAssert() is called while
 249   processing another DebugAssert(), then DebugAssert() must return immediately.
 250
 251   If FileName is NULL, then a <FileName> string of "(NULL) Filename" is printed.
 252   If Description is NULL, then a <Description> string of "(NULL) Description" is printed.
 253
 254   @param  FileName     Pointer to the name of the source file that generated the assert condition.
 255   @param  LineNumber   The line number in the source file that generated the assert condition
 256   @param  Description  Pointer to the description of the assert condition.
 257
 258 **/
 259 VOID
 260 EFIAPI
 261 DebugAssert (
 262   IN CONST CHAR8  *FileName,
 263   IN UINTN        LineNumber,
 264   IN CONST CHAR8  *Description
 265   )
 266 {
 267   UINT64                 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE / sizeof(UINT64)];
 268   EFI_DEBUG_ASSERT_DATA  *AssertData;
 269   UINTN                  HeaderSize;
 270   UINTN                  TotalSize;
 271   CHAR8                  *Temp;
 272   UINTN                  ModuleNameSize;
 273   UINTN                  FileNameSize;
 274   UINTN                  DescriptionSize;
 275
 276   //
 277   // Get string size
 278   //
 279   HeaderSize       = sizeof (EFI_DEBUG_ASSERT_DATA);
 280   //
 281   // Compute string size of module name enclosed by []
 282   //
 283   ModuleNameSize   = 2 + AsciiStrSize (gEfiCallerBaseName);
 284   FileNameSize     = AsciiStrSize (FileName);
 285   DescriptionSize  = AsciiStrSize (Description);
 286
 287   //
 288   // Make sure it will all fit in the passed in buffer.
 289   //
 290   if (HeaderSize + ModuleNameSize + FileNameSize + DescriptionSize > sizeof (Buffer)) {
 291     //
 292     // remove module name if it's too long to be filled into buffer
 293     //
 294     ModuleNameSize = 0;
 295     if (HeaderSize + FileNameSize + DescriptionSize > sizeof (Buffer)) {
 296       //
 297       // FileName + Description is too long to be filled into buffer.
 298       //
 299       if (HeaderSize + FileNameSize < sizeof (Buffer)) {
 300         //
 301         // Description has enough buffer to be truncated.
 302         //
 303         DescriptionSize = sizeof (Buffer) - HeaderSize - FileNameSize;
 304       } else {
 305         //
 306         // FileName is too long to be filled into buffer.
 307         // FileName will be truncated. Reserved one byte for Description NULL terminator.
 308         //
 309         DescriptionSize = 1;
 310         FileNameSize    = sizeof (Buffer) - HeaderSize - DescriptionSize;
 311       }
 312     }
 313   }
 314   //
 315   // Fill in EFI_DEBUG_ASSERT_DATA
 316   //
 317   AssertData = (EFI_DEBUG_ASSERT_DATA *)Buffer;
 318   AssertData->LineNumber = (UINT32)LineNumber;
 319   TotalSize  = sizeof (EFI_DEBUG_ASSERT_DATA);
 320
 321   Temp = (CHAR8 *)(AssertData + 1);
 322
 323   //
 324   // Copy Ascii [ModuleName].
 325   //
 326   if (ModuleNameSize != 0) {
 327     CopyMem(Temp, "[", 1);
 328     CopyMem(Temp + 1, gEfiCallerBaseName, ModuleNameSize - 3);
 329     CopyMem(Temp + ModuleNameSize - 2, "] ", 2);
 330   }
 331
 332   //
 333   // Copy Ascii FileName including NULL terminator.
 334   //
 335   Temp = CopyMem (Temp + ModuleNameSize, FileName, FileNameSize);
 336   Temp[FileNameSize - 1] = 0;
 337   TotalSize += (ModuleNameSize + FileNameSize);
 338
 339   //
 340   // Copy Ascii Description include NULL terminator.
 341   //
 342   Temp = CopyMem (Temp + FileNameSize, Description, DescriptionSize);
 343   Temp[DescriptionSize - 1] = 0;
 344   TotalSize += DescriptionSize;
 345
 346   REPORT_STATUS_CODE_EX (
 347     (EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
 348     (EFI_SOFTWARE_DXE_BS_DRIVER | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
 349     0,
 350     NULL,
 351     NULL,
 352     AssertData,
 353     TotalSize
 354     );
 355
 356   //
 357   // Generate a Breakpoint, DeadLoop, or NOP based on PCD settings
 358   //
 359   if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {
 360     CpuBreakpoint ();
 361   } else if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {
 362     CpuDeadLoop ();
 363   }
 364 }
 365
 366
 367 /**
 368   Fills a target buffer with PcdDebugClearMemoryValue, and returns the target buffer.
 369
 370   This function fills Length bytes of Buffer with the value specified by
 371   PcdDebugClearMemoryValue, and returns Buffer.
 372
 373   If Buffer is NULL, then ASSERT().
 374   If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
 375
 376   @param   Buffer  Pointer to the target buffer to be filled with PcdDebugClearMemoryValue.
 377   @param   Length  Number of bytes in Buffer to fill with zeros PcdDebugClearMemoryValue.
 378
 379   @return  Buffer  Pointer to the target buffer filled with PcdDebugClearMemoryValue.
 380
 381 **/
 382 VOID *
 383 EFIAPI
 384 DebugClearMemory (
 385   OUT VOID  *Buffer,
 386   IN UINTN  Length
 387   )
 388 {
 389   ASSERT (Buffer != NULL);
 390
 391   return SetMem (Buffer, Length, PcdGet8 (PcdDebugClearMemoryValue));
 392 }
 393
 394
 395 /**
 396   Returns TRUE if ASSERT() macros are enabled.
 397
 398   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of
 399   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 400
 401   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is set.
 402   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED bit of PcdDebugProperyMask is clear.
 403
 404 **/
 405 BOOLEAN
 406 EFIAPI
 407 DebugAssertEnabled (
 408   VOID
 409   )
 410 {
 411   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);
 412 }
 413
 414
 415 /**
 416   Returns TRUE if DEBUG() macros are enabled.
 417
 418   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of
 419   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 420
 421   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is set.
 422   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_PRINT_ENABLED bit of PcdDebugProperyMask is clear.
 423
 424 **/
 425 BOOLEAN
 426 EFIAPI
 427 DebugPrintEnabled (
 428   VOID
 429   )
 430 {
 431   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);
 432 }
 433
 434
 435 /**
 436   Returns TRUE if DEBUG_CODE() macros are enabled.
 437
 438   This function returns TRUE if the DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of
 439   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 440
 441   @retval  TRUE    The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is set.
 442   @retval  FALSE   The DEBUG_PROPERTY_DEBUG_CODE_ENABLED bit of PcdDebugProperyMask is clear.
 443
 444 **/
 445 BOOLEAN
 446 EFIAPI
 447 DebugCodeEnabled (
 448   VOID
 449   )
 450 {
 451   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);
 452 }
 453
 454
 455 /**
 456   Returns TRUE if DEBUG_CLEAR_MEMORY() macro is enabled.
 457
 458   This function returns TRUE if the DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of
 459   PcdDebugProperyMask is set.  Otherwise FALSE is returned.
 460
 461   @retval  TRUE    The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is set.
 462   @retval  FALSE   The DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED bit of PcdDebugProperyMask is clear.
 463
 464 **/
 465 BOOLEAN
 466 EFIAPI
 467 DebugClearMemoryEnabled (
 468   VOID
 469   )
 470 {
 471   return (BOOLEAN) ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);
 472 }
 473
 474 /**
 475   Returns TRUE if any one of the bit is set both in ErrorLevel and PcdFixedDebugPrintErrorLevel.
 476
 477   This function compares the bit mask of ErrorLevel and PcdFixedDebugPrintErrorLevel.
 478
 479   @retval  TRUE    Current ErrorLevel is supported.
 480   @retval  FALSE   Current ErrorLevel is not supported.
 481
 482 **/
 483 BOOLEAN
 484 EFIAPI
 485 DebugPrintLevelEnabled (
 486   IN  CONST UINTN        ErrorLevel
 487   )
 488 {
 489   return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);
 490 }