EdkCompatibilityPkg/Foundation/Library/EdkIIGlueLib/Library/DxeReportStatusCodeLib/ReportStatusCodeLib.c

   1 /*++
   2
   3 Copyright (c) 2004 - 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12
  13 Module Name:
  14
  15   ReportStatusCodeLib.c
  16
  17 Abstract:
  18
  19   Report Status Code Library for DXE Phase.
  20
  21 --*/
  22
  23 #include "EdkIIGlueDxe.h"
  24
  25 //
  26 // Global pointer to the Status Code Protocol
  27 //
  28 static EFI_STATUS_CODE_PROTOCOL  *gStatusCode = NULL;
  29
  30
  31 /**
  32   Internal worker function that reports a status code through the Status Code Protocol
  33
  34   This function checks to see if a Status Code Protocol is present in the handle
  35   database.  If a Status Code Protocol is not present, then EFI_UNSUPPORTED is
  36   returned.  If a Status Code Protocol is present, then it is cached in gStatusCode,
  37   and the ReportStatusCode() service of the Status Code Protocol is called passing in
  38   Type, Value, Instance, CallerId, and Data.  The result of this call is returned.
  39
  40   @param  Type              Status code type.
  41   @param  Value             Status code value.
  42   @param  Instance          Status code instance number.
  43   @param  CallerId          Pointer to a GUID that identifies the caller of this
  44                             function.  This is an optional parameter that may be
  45                             NULL.
  46   @param  Data              Pointer to the extended data buffer.  This is an
  47                             optional parameter that may be NULL.
  48
  49   @retval  EFI_SUCCESS           The status code was reported.
  50   @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to report the status code.
  51   @retval  EFI_UNSUPPORTED       Status Code Protocol is not available.
  52
  53 **/
  54 STATIC
  55 EFI_STATUS
  56 InternalReportStatusCode (
  57   IN EFI_STATUS_CODE_TYPE     Type,
  58   IN EFI_STATUS_CODE_VALUE    Value,
  59   IN UINT32                   Instance,
  60   IN CONST EFI_GUID           *CallerId OPTIONAL,
  61   IN EFI_STATUS_CODE_DATA     *Data     OPTIONAL
  62   )
  63 {
  64   EFI_STATUS  Status;
  65
  66   if (gRT == NULL) {
  67     return EFI_UNSUPPORTED;
  68   }
  69
  70   if (gRT->Hdr.Revision >= 0x00020000) {
  71     //
  72     // If gStatusCode is NULL, then see if a Status Code Protocol instance is present
  73     // in the handle database.
  74     //
  75     if (gStatusCode == NULL) {
  76       Status = gBS->LocateProtocol (&gEfiStatusCodeRuntimeProtocolGuid, NULL, (VOID **)&gStatusCode);
  77       if (EFI_ERROR (Status) || gStatusCode == NULL) {
  78         return EFI_UNSUPPORTED;
  79       }
  80     }
  81
  82     //
  83     // A Status Code Protocol is present in the handle database, so pass in all the
  84     // parameters to the ReportStatusCode() service of the Status Code Protocol
  85     //
  86     return (gStatusCode->ReportStatusCode) (Type, Value, Instance, (EFI_GUID *)CallerId, Data);
  87   } else {
  88 #if (EFI_SPECIFICATION_VERSION < 0x00020000)
  89     return (gRT->ReportStatusCode) (Type, Value, Instance, (EFI_GUID *)CallerId, Data);
  90 #endif
  91     return EFI_UNSUPPORTED;
  92   }
  93
  94 }
  95
  96
  97 /**
  98   Computes and returns the size, in bytes, of a device path.
  99
 100   @param  DevicePath  A pointer to a device path.
 101
 102   @return  The size, in bytes, of DevicePath.
 103
 104 **/
 105 STATIC
 106 UINTN
 107 InternalReportStatusCodeDevicePathSize (
 108   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 109   )
 110 {
 111   CONST EFI_DEVICE_PATH_PROTOCOL  *Start;
 112
 113   //
 114   // Search for the end of the device path structure
 115   //
 116   Start = DevicePath;
 117   while (!EfiIsDevicePathEnd (DevicePath)) {
 118     DevicePath = EfiNextDevicePathNode (DevicePath);
 119   }
 120
 121   //
 122   // Subtract the start node from the end node and add in the size of the end node
 123   //
 124   return ((UINTN) DevicePath - (UINTN) Start) + DevicePathNodeLength (DevicePath);
 125 }
 126
 127
 128 /**
 129   Converts a status code to an 8-bit POST code value.
 130
 131   Converts the status code specified by CodeType and Value to an 8-bit POST code
 132   and returns the 8-bit POST code in PostCode.  If CodeType is an
 133   EFI_PROGRESS_CODE or CodeType is an EFI_ERROR_CODE, then bits 0..4 of PostCode
 134   are set to bits 16..20 of Value, and bits 5..7 of PostCode are set to bits
 135   24..26 of Value., and TRUE is returned.  Otherwise, FALSE is returned.
 136
 137   If PostCode is NULL, then ASSERT().
 138
 139   @param  CodeType  The type of status code being converted.
 140   @param  Value     The status code value being converted.
 141   @param  PostCode  A pointer to the 8-bit POST code value to return.
 142
 143   @retval  TRUE   The status code specified by CodeType and Value was converted
 144                   to an 8-bit POST code and returned in  PostCode.
 145   @retval  FALSE  The status code specified by CodeType and Value could not be
 146                   converted to an 8-bit POST code value.
 147
 148 **/
 149 BOOLEAN
 150 EFIAPI
 151 GlueCodeTypeToPostCode (
 152   IN  EFI_STATUS_CODE_TYPE   CodeType,
 153   IN  EFI_STATUS_CODE_VALUE  Value,
 154   OUT UINT8                  *PostCode
 155   )
 156 {
 157   //
 158   // If PostCode is NULL, then ASSERT()
 159   //
 160   ASSERT (PostCode != NULL);
 161
 162   //
 163   // Convert Value to an 8 bit post code
 164   //
 165   if (((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_PROGRESS_CODE) ||
 166       ((CodeType & EFI_STATUS_CODE_TYPE_MASK) == EFI_ERROR_CODE)       ) {
 167     *PostCode  = (UINT8) ((((Value & EFI_STATUS_CODE_CLASS_MASK) >> 24) << 5) |
 168                           (((Value & EFI_STATUS_CODE_SUBCLASS_MASK) >> 16) & 0x1f));
 169     return TRUE;
 170   }
 171   return FALSE;
 172 }
 173
 174
 175 /**
 176   Extracts ASSERT() information from a status code structure.
 177
 178   Converts the status code specified by CodeType, Value, and Data to the ASSERT()
 179   arguments specified by Filename, Description, and LineNumber.  If CodeType is
 180   an EFI_ERROR_CODE, and CodeType has a severity of EFI_ERROR_UNRECOVERED, and
 181   Value has an operation mask of EFI_SW_EC_ILLEGAL_SOFTWARE_STATE, extract
 182   Filename, Description, and LineNumber from the optional data area of the
 183   status code buffer specified by Data.  The optional data area of Data contains
 184   a Null-terminated ASCII string for the FileName, followed by a Null-terminated
 185   ASCII string for the Description, followed by a 32-bit LineNumber.  If the
 186   ASSERT() information could be extracted from Data, then return TRUE.
 187   Otherwise, FALSE is returned.
 188
 189   If Data is NULL, then ASSERT().
 190   If Filename is NULL, then ASSERT().
 191   If Description is NULL, then ASSERT().
 192   If LineNumber is NULL, then ASSERT().
 193
 194   @param  CodeType     The type of status code being converted.
 195   @param  Value        The status code value being converted.
 196   @param  Data         Pointer to status code data buffer.
 197   @param  Filename     Pointer to the source file name that generated the ASSERT().
 198   @param  Description  Pointer to the description of the ASSERT().
 199   @param  LineNumber   Pointer to source line number that generated the ASSERT().
 200
 201   @retval  TRUE   The status code specified by CodeType, Value, and Data was
 202                   converted ASSERT() arguments specified by Filename, Description,
 203                   and LineNumber.
 204   @retval  FALSE  The status code specified by CodeType, Value, and Data could
 205                   not be converted to ASSERT() arguments.
 206
 207 **/
 208 BOOLEAN
 209 EFIAPI
 210 GlueReportStatusCodeExtractAssertInfo (
 211   IN EFI_STATUS_CODE_TYPE        CodeType,
 212   IN EFI_STATUS_CODE_VALUE       Value,
 213   IN CONST EFI_STATUS_CODE_DATA  *Data,
 214   OUT CHAR8                      **Filename,
 215   OUT CHAR8                      **Description,
 216   OUT UINT32                     *LineNumber
 217   )
 218 {
 219   EFI_DEBUG_ASSERT_DATA  *AssertData;
 220
 221   ASSERT (Data        != NULL);
 222   ASSERT (Filename    != NULL);
 223   ASSERT (Description != NULL);
 224   ASSERT (LineNumber  != NULL);
 225
 226   if (((CodeType & EFI_STATUS_CODE_TYPE_MASK)      == EFI_ERROR_CODE) &&
 227       ((CodeType & EFI_STATUS_CODE_SEVERITY_MASK)  == EFI_ERROR_UNRECOVERED) &&
 228       ((Value    & EFI_STATUS_CODE_OPERATION_MASK) == EFI_SW_EC_ILLEGAL_SOFTWARE_STATE)) {
 229     AssertData   = (EFI_DEBUG_ASSERT_DATA *)(Data + 1);
 230     *Filename    = (CHAR8 *)(AssertData + 1);
 231     *Description = *Filename + AsciiStrLen (*Filename) + 1;
 232     *LineNumber  = AssertData->LineNumber;
 233     return TRUE;
 234   }
 235   return FALSE;
 236 }
 237
 238
 239 /**
 240   Extracts DEBUG() information from a status code structure.
 241
 242   Converts the status code specified by Data to the DEBUG() arguments specified
 243   by ErrorLevel, Marker, and Format.  If type GUID in Data is
 244   EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID, then extract ErrorLevel, Marker, and
 245   Format from the optional data area of the status code buffer specified by Data.
 246   The optional data area of Data contains a 32-bit ErrorLevel followed by Marker
 247   which is 12 UINTN parameters, followed by a Null-terminated ASCII string for
 248   the Format.  If the DEBUG() information could be extracted from Data, then
 249   return TRUE.  Otherwise, FALSE is returned.
 250
 251   If Data is NULL, then ASSERT().
 252   If ErrorLevel is NULL, then ASSERT().
 253   If Marker is NULL, then ASSERT().
 254   If Format is NULL, then ASSERT().
 255
 256   @param  Data        Pointer to status code data buffer.
 257   @param  ErrorLevel  Pointer to error level mask for a debug message.
 258   @param  Marker      Pointer to the variable argument list associated with Format.
 259   @param  Format      Pointer to a Null-terminated ASCII format string of a
 260                       debug message.
 261
 262   @retval  TRUE   The status code specified by Data was converted DEBUG() arguments
 263                   specified by ErrorLevel, Marker, and Format.
 264   @retval  FALSE  The status code specified by Data could not be converted to
 265                   DEBUG() arguments.
 266
 267 **/
 268 BOOLEAN
 269 EFIAPI
 270 GlueReportStatusCodeExtractDebugInfo (
 271   IN CONST EFI_STATUS_CODE_DATA  *Data,
 272   OUT UINT32                     *ErrorLevel,
 273   OUT VA_LIST                    *Marker,
 274   OUT CHAR8                      **Format
 275   )
 276 {
 277   EFI_DEBUG_INFO  *DebugInfo;
 278
 279   ASSERT (Data       != NULL);
 280   ASSERT (ErrorLevel != NULL);
 281   ASSERT (Marker     != NULL);
 282   ASSERT (Format     != NULL);
 283
 284   //
 285   // If the GUID type is not EFI_STATUS_CODE_DATA_TYPE_DEBUG_GUID then return FALSE
 286   //
 287   if (!CompareGuid (&Data->Type, &gEfiStatusCodeDataTypeDebugGuid)) {
 288     return FALSE;
 289   }
 290
 291   //
 292   // Retrieve the debug information from the status code record
 293   //
 294   DebugInfo = (EFI_DEBUG_INFO *)(Data + 1);
 295
 296   *ErrorLevel = DebugInfo->ErrorLevel;
 297
 298   //
 299   // The first 12 * UINTN bytes of the string are really an
 300   // argument stack to support varargs on the Format string.
 301   //
 302   *Marker = (VA_LIST) (DebugInfo + 1);
 303   *Format = (CHAR8 *)(((UINT64 *)*Marker) + 12);
 304
 305   return TRUE;
 306 }
 307
 308
 309 /**
 310   Reports a status code.
 311
 312   Reports the status code specified by the parameters Type and Value.  Status
 313   code also require an instance, caller ID, and extended data.  This function
 314   passed in a zero instance, NULL extended data, and a caller ID of
 315   gEfiCallerIdGuid, which is the GUID for the module.
 316
 317   ReportStatusCode()must actively prevent recusrsion.  If ReportStatusCode()
 318   is called while processing another any other Report Status Code Library function,
 319   then ReportStatusCode() must return immediately.
 320
 321   @param  Type   Status code type.
 322   @param  Value  Status code value.
 323
 324   @retval  EFI_SUCCESS       The status code was reported.
 325   @retval  EFI_DEVICE_ERROR  There status code could not be reported due to a
 326                              device error.
 327   @retval  EFI_UNSUPPORTED   Report status code is not supported
 328
 329 **/
 330 EFI_STATUS
 331 EFIAPI
 332 GlueReportStatusCode (
 333   IN EFI_STATUS_CODE_TYPE   Type,
 334   IN EFI_STATUS_CODE_VALUE  Value
 335   )
 336 {
 337   return InternalReportStatusCode (Type, Value, 0, &gEfiCallerIdGuid, NULL);
 338 }
 339
 340
 341 /**
 342   Reports a status code with a Device Path Protocol as the extended data.
 343
 344   Allocates and fills in the extended data section of a status code with the
 345   Device Path Protocol specified by DevicePath.  This function is responsible
 346   for allocating a buffer large enough for the standard header and the device
 347   path.  The standard header is filled in with a GUID of
 348   gEfiStatusCodeSpecificDataGuid.  The status code is reported with a zero
 349   instance and a caller ID of gEfiCallerIdGuid.
 350
 351   ReportStatusCodeWithDevicePath()must actively prevent recursion.  If
 352   ReportStatusCodeWithDevicePath() is called while processing another any other
 353   Report Status Code Library function, then ReportStatusCodeWithDevicePath()
 354   must return EFI_DEVICE_ERROR immediately.
 355
 356   If DevicePath is NULL, then ASSERT().
 357
 358   @param  Type        Status code type.
 359   @param  Value       Status code value.
 360   @param  DevicePath  Pointer to the Device Path Protocol to be reported.
 361
 362   @retval  EFI_SUCCESS           The status code was reported with the extended
 363                                  data specified by DevicePath.
 364   @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the
 365                                  extended data section.
 366   @retval  EFI_UNSUPPORTED       Report status code is not supported
 367
 368 **/
 369 EFI_STATUS
 370 EFIAPI
 371 GlueReportStatusCodeWithDevicePath (
 372   IN EFI_STATUS_CODE_TYPE            Type,
 373   IN EFI_STATUS_CODE_VALUE           Value,
 374   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 375   )
 376 {
 377   ASSERT (DevicePath != NULL);
 378   return ReportStatusCodeWithExtendedData (
 379            Type,
 380            Value,
 381            (VOID *)DevicePath,
 382            InternalReportStatusCodeDevicePathSize (DevicePath)
 383            );
 384 }
 385
 386
 387 /**
 388   Reports a status code with an extended data buffer.
 389
 390   Allocates and fills in the extended data section of a status code with the
 391   extended data specified by ExtendedData and ExtendedDataSize.  ExtendedData
 392   is assumed to be one of the data structures specified in Related Definitions.
 393   These data structure do not have the standard header, so this function is
 394   responsible for allocating a buffer large enough for the standard header and
 395   the extended data passed into this function.  The standard header is filled
 396   in with a GUID of  gEfiStatusCodeSpecificDataGuid.  The status code is reported
 397   with a zero instance and a caller ID of gEfiCallerIdGuid.
 398
 399   ReportStatusCodeWithExtendedData()must actively prevent recursion.  If
 400   ReportStatusCodeWithExtendedData() is called while processing another any other
 401   Report Status Code Library function, then ReportStatusCodeWithExtendedData()
 402   must return EFI_DEVICE_ERROR immediately.
 403
 404   If ExtendedData is NULL, then ASSERT().
 405   If ExtendedDataSize is 0, then ASSERT().
 406
 407   @param  Type              Status code type.
 408   @param  Value             Status code value.
 409   @param  ExtendedData      Pointer to the extended data buffer to be reported.
 410   @param  ExtendedDataSize  The size, in bytes, of the extended data buffer to
 411                             be reported.
 412
 413   @retval  EFI_SUCCESS           The status code was reported with the extended
 414                                  data specified by ExtendedData and ExtendedDataSize.
 415   @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate the
 416                                  extended data section.
 417   @retval  EFI_UNSUPPORTED       Report status code is not supported
 418
 419 **/
 420 EFI_STATUS
 421 EFIAPI
 422 GlueReportStatusCodeWithExtendedData (
 423   IN EFI_STATUS_CODE_TYPE   Type,
 424   IN EFI_STATUS_CODE_VALUE  Value,
 425   IN CONST VOID             *ExtendedData,
 426   IN UINTN                  ExtendedDataSize
 427   )
 428 {
 429   ASSERT (ExtendedData     != NULL);
 430   ASSERT (ExtendedDataSize != 0);
 431   return ReportStatusCodeEx (
 432            Type,
 433            Value,
 434            0,
 435            NULL,
 436            NULL,
 437            ExtendedData,
 438            ExtendedDataSize
 439            );
 440 }
 441
 442
 443 /**
 444   Reports a status code with full parameters.
 445
 446   The function reports a status code.  If ExtendedData is NULL and ExtendedDataSize
 447   is 0, then an extended data buffer is not reported.  If ExtendedData is not
 448   NULL and ExtendedDataSize is not 0, then an extended data buffer is allocated.
 449   ExtendedData is assumed not have the standard status code header, so this function
 450   is responsible for allocating a buffer large enough for the standard header and
 451   the extended data passed into this function.  The standard header is filled in
 452   with a GUID specified by ExtendedDataGuid.  If ExtendedDataGuid is NULL, then a
 453   GUID of gEfiStatusCodeSpecificDatauid is used.  The status code is reported with
 454   an instance specified by Instance and a caller ID specified by CallerId.  If
 455   CallerId is NULL, then a caller ID of gEfiCallerIdGuid is used.
 456
 457   ReportStatusCodeEx()must actively prevent recursion.  If ReportStatusCodeEx()
 458   is called while processing another any other Report Status Code Library function,
 459   then ReportStatusCodeEx() must return EFI_DEVICE_ERROR immediately.
 460
 461   If ExtendedData is NULL and ExtendedDataSize is not zero, then ASSERT().
 462   If ExtendedData is not NULL and ExtendedDataSize is zero, then ASSERT().
 463
 464   @param  Type              Status code type.
 465   @param  Value             Status code value.
 466   @param  Instance          Status code instance number.
 467   @param  CallerId          Pointer to a GUID that identifies the caller of this
 468                             function.  If this parameter is NULL, then a caller
 469                             ID of gEfiCallerIdGuid is used.
 470   @param  ExtendedDataGuid  Pointer to the GUID for the extended data buffer.
 471                             If this parameter is NULL, then a the status code
 472                             standard header is filled in with
 473                             gEfiStatusCodeSpecificDataGuid.
 474   @param  ExtendedData      Pointer to the extended data buffer.  This is an
 475                             optional parameter that may be NULL.
 476   @param  ExtendedDataSize  The size, in bytes, of the extended data buffer.
 477
 478   @retval  EFI_SUCCESS           The status code was reported.
 479   @retval  EFI_OUT_OF_RESOURCES  There were not enough resources to allocate
 480                                  the extended data section if it was specified.
 481   @retval  EFI_UNSUPPORTED       Report status code is not supported
 482
 483 **/
 484 EFI_STATUS
 485 EFIAPI
 486 GlueReportStatusCodeEx (
 487   IN EFI_STATUS_CODE_TYPE   Type,
 488   IN EFI_STATUS_CODE_VALUE  Value,
 489   IN UINT32                 Instance,
 490   IN CONST EFI_GUID         *CallerId          OPTIONAL,
 491   IN CONST EFI_GUID         *ExtendedDataGuid  OPTIONAL,
 492   IN CONST VOID             *ExtendedData      OPTIONAL,
 493   IN UINTN                  ExtendedDataSize
 494   )
 495 {
 496   EFI_STATUS            Status;
 497   EFI_STATUS_CODE_DATA  *StatusCodeData;
 498
 499   ASSERT (!((ExtendedData == NULL) && (ExtendedDataSize != 0)));
 500   ASSERT (!((ExtendedData != NULL) && (ExtendedDataSize == 0)));
 501
 502   //
 503   // Allocate space for the Status Code Header and its buffer
 504   //
 505   StatusCodeData = NULL;
 506   (gBS->AllocatePool) (EfiBootServicesData, sizeof (EFI_STATUS_CODE_DATA) + ExtendedDataSize, (VOID **)&StatusCodeData);
 507   if (StatusCodeData == NULL) {
 508     return EFI_OUT_OF_RESOURCES;
 509   }
 510
 511   //
 512   // Fill in the extended data header
 513   //
 514   StatusCodeData->HeaderSize = sizeof (EFI_STATUS_CODE_DATA);
 515   StatusCodeData->Size = (UINT16)ExtendedDataSize;
 516   if (ExtendedDataGuid == NULL) {
 517     ExtendedDataGuid = &gEfiStatusCodeSpecificDataGuid;
 518   }
 519   CopyGuid (&StatusCodeData->Type, ExtendedDataGuid);
 520
 521   //
 522   // Fill in the extended data buffer
 523   //
 524   CopyMem (StatusCodeData + 1, ExtendedData, ExtendedDataSize);
 525
 526   //
 527   // Report the status code
 528   //
 529   if (CallerId == NULL) {
 530     CallerId = &gEfiCallerIdGuid;
 531   }
 532   Status = InternalReportStatusCode (Type, Value, Instance, CallerId, StatusCodeData);
 533
 534   //
 535   // Free the allocated buffer
 536   //
 537   (gBS->FreePool) (StatusCodeData);
 538
 539   return Status;
 540 }
 541
 542
 543 /**
 544   Returns TRUE if status codes of type EFI_PROGRESS_CODE are enabled
 545
 546   This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED
 547   bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
 548
 549   @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of
 550                   PcdReportStatusCodeProperyMask is set.
 551   @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED bit of
 552                   PcdReportStatusCodeProperyMask is clear.
 553
 554 **/
 555 BOOLEAN
 556 EFIAPI
 557 GlueReportProgressCodeEnabled (
 558   VOID
 559   )
 560 {
 561   return (BOOLEAN) ((PcdGet8(PcdReportStatusCodePropertyMask) & REPORT_STATUS_CODE_PROPERTY_PROGRESS_CODE_ENABLED) != 0);
 562 }
 563
 564
 565 /**
 566   Returns TRUE if status codes of type EFI_ERROR_CODE are enabled
 567
 568   This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED
 569   bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
 570
 571   @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of
 572                   PcdReportStatusCodeProperyMask is set.
 573   @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED bit of
 574                   PcdReportStatusCodeProperyMask is clear.
 575
 576 **/
 577 BOOLEAN
 578 EFIAPI
 579 GlueReportErrorCodeEnabled (
 580   VOID
 581   )
 582 {
 583   return (BOOLEAN) ((PcdGet8(PcdReportStatusCodePropertyMask) & REPORT_STATUS_CODE_PROPERTY_ERROR_CODE_ENABLED) != 0);
 584 }
 585
 586
 587 /**
 588   Returns TRUE if status codes of type EFI_DEBUG_CODE are enabled
 589
 590   This function returns TRUE if the REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED
 591   bit of PcdReportStatusCodeProperyMask is set.  Otherwise FALSE is returned.
 592
 593   @retval  TRUE   The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of
 594                   PcdReportStatusCodeProperyMask is set.
 595   @retval  FALSE  The REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED bit of
 596                   PcdReportStatusCodeProperyMask is clear.
 597
 598 **/
 599 BOOLEAN
 600 EFIAPI
 601 GlueReportDebugCodeEnabled (
 602   VOID
 603   )
 604 {
 605   return (BOOLEAN) ((PcdGet8(PcdReportStatusCodePropertyMask) & REPORT_STATUS_CODE_PROPERTY_DEBUG_CODE_ENABLED) != 0);
 606 }