MdeModulePkg/Include/Guid/Performance.h

   1 /** @file
   2   This file defines performance-related definitions, including the format of:
   3   * performance GUID HOB.
   4   * performance protocol interfaces.
   5   * performance variables.
   6
   7 Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   8 This program and the accompanying materials are licensed and made available under
   9 the terms and conditions of the BSD License that accompanies this distribution.
  10 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 #ifndef __PERFORMANCE_DATA_H__
  19 #define __PERFORMANCE_DATA_H__
  20
  21 //
  22 // PEI_PERFORMANCE_STRING_SIZE must be a multiple of 8.
  23 //
  24 #define PEI_PERFORMANCE_STRING_SIZE     8
  25 #define PEI_PERFORMANCE_STRING_LENGTH   (PEI_PERFORMANCE_STRING_SIZE - 1)
  26
  27 typedef struct {
  28   EFI_PHYSICAL_ADDRESS  Handle;
  29   CHAR8                 Token[PEI_PERFORMANCE_STRING_SIZE];   ///< Measured token string name.
  30   CHAR8                 Module[PEI_PERFORMANCE_STRING_SIZE];  ///< Module string name.
  31   UINT64                StartTimeStamp;                       ///< Start time point.
  32   UINT64                EndTimeStamp;                         ///< End time point.
  33 } PEI_PERFORMANCE_LOG_ENTRY;
  34
  35 //
  36 // The header must be aligned at 8 bytes.
  37 //
  38 typedef struct {
  39   UINT32                NumberOfEntries;  ///< The number of all performance log entries.
  40   UINT32                Reserved;
  41 } PEI_PERFORMANCE_LOG_HEADER;
  42
  43
  44 //
  45 // The data structure for performance data in ACPI memory.
  46 //
  47 #define PERFORMANCE_SIGNATURE   SIGNATURE_32 ('P', 'e', 'r', 'f')
  48 #define PERF_TOKEN_SIZE         28
  49 #define PERF_TOKEN_LENGTH       (PERF_TOKEN_SIZE - 1)
  50 #define PERF_PEI_ENTRY_MAX_NUM  50
  51
  52 typedef struct {
  53   CHAR8   Token[PERF_TOKEN_SIZE];
  54   UINT32  Duration;
  55 } PERF_DATA;
  56
  57 typedef struct {
  58   UINT64        BootToOs;
  59   UINT64        S3Resume;
  60   UINT32        S3EntryNum;
  61   PERF_DATA     S3Entry[PERF_PEI_ENTRY_MAX_NUM];
  62   UINT64        CpuFreq;
  63   UINT64        BDSRaw;
  64   UINT32        Count;
  65   UINT32        Signiture;
  66 } PERF_HEADER;
  67
  68 #define PERFORMANCE_PROTOCOL_GUID \
  69   { 0x76b6bdfa, 0x2acd, 0x4462, { 0x9E, 0x3F, 0xcb, 0x58, 0xC9, 0x69, 0xd9, 0x37 } }
  70
  71 #define PERFORMANCE_EX_PROTOCOL_GUID \
  72   { 0x1ea81bec, 0xf01a, 0x4d98, { 0xa2, 0x1,  0x4a, 0x61, 0xce, 0x2f, 0xc0, 0x22 } }
  73
  74 //
  75 // Forward reference for pure ANSI compatibility
  76 //
  77 typedef struct _PERFORMANCE_PROTOCOL PERFORMANCE_PROTOCOL;
  78 typedef struct _PERFORMANCE_EX_PROTOCOL PERFORMANCE_EX_PROTOCOL;
  79
  80 //
  81 // DXE_PERFORMANCE_STRING_SIZE must be a multiple of 8.
  82 //
  83 #define DXE_PERFORMANCE_STRING_SIZE     32
  84 #define DXE_PERFORMANCE_STRING_LENGTH   (DXE_PERFORMANCE_STRING_SIZE - 1)
  85
  86 //
  87 // The default guage entries number for DXE phase.
  88 //
  89 #define INIT_DXE_GAUGE_DATA_ENTRIES     800
  90
  91 typedef struct {
  92   EFI_PHYSICAL_ADDRESS  Handle;
  93   CHAR8                 Token[DXE_PERFORMANCE_STRING_SIZE];  ///< Measured token string name.
  94   CHAR8                 Module[DXE_PERFORMANCE_STRING_SIZE]; ///< Module string name.
  95   UINT64                StartTimeStamp;                      ///< Start time point.
  96   UINT64                EndTimeStamp;                        ///< End time point.
  97 } GAUGE_DATA_ENTRY;
  98
  99 typedef struct {
 100   EFI_PHYSICAL_ADDRESS  Handle;
 101   CHAR8                 Token[DXE_PERFORMANCE_STRING_SIZE];  ///< Measured token string name.
 102   CHAR8                 Module[DXE_PERFORMANCE_STRING_SIZE]; ///< Module string name.
 103   UINT64                StartTimeStamp;                      ///< Start time point.
 104   UINT64                EndTimeStamp;                        ///< End time point.
 105   UINT32                Identifier;                          ///< Identifier.
 106 } GAUGE_DATA_ENTRY_EX;
 107
 108 //
 109 // The header must be aligned at 8 bytes
 110 //
 111 typedef struct {
 112   UINT32                NumberOfEntries; ///< The number of all performance gauge entries.
 113   UINT32                Reserved;
 114 } GAUGE_DATA_HEADER;
 115
 116 //
 117 // SMM Performance Protocol definitions
 118 //
 119
 120 #define SMM_PERFORMANCE_PROTOCOL_GUID \
 121   { 0xf866226a, 0xeaa5, 0x4f5a, { 0xa9, 0xa,  0x6c, 0xfb, 0xa5, 0x7c, 0x58, 0x8e } }
 122
 123 #define SMM_PERFORMANCE_EX_PROTOCOL_GUID \
 124   { 0x931fc048, 0xc71d, 0x4455, { 0x89, 0x30, 0x47, 0x6,  0x30, 0xe3, 0xe,  0xe5 } }
 125
 126 //
 127 // SMM_PERFORMANCE_STRING_SIZE.
 128 //
 129 #define SMM_PERFORMANCE_STRING_SIZE     32
 130 #define SMM_PERFORMANCE_STRING_LENGTH   (SMM_PERFORMANCE_STRING_SIZE - 1)
 131
 132 //
 133 // The default guage entries number for SMM phase.
 134 //
 135 #define INIT_SMM_GAUGE_DATA_ENTRIES     200
 136
 137 typedef struct {
 138   UINTN             Function;
 139   EFI_STATUS        ReturnStatus;
 140   UINTN             NumberOfEntries;
 141   UINTN             LogEntryKey;
 142   GAUGE_DATA_ENTRY  *GaugeData;
 143 } SMM_PERF_COMMUNICATE;
 144
 145 typedef struct {
 146   UINTN                Function;
 147   EFI_STATUS           ReturnStatus;
 148   UINTN                NumberOfEntries;
 149   UINTN                LogEntryKey;
 150   GAUGE_DATA_ENTRY_EX  *GaugeDataEx;
 151 } SMM_PERF_COMMUNICATE_EX;
 152
 153 #define SMM_PERF_FUNCTION_GET_GAUGE_ENTRY_NUMBER          1
 154 #define SMM_PERF_FUNCTION_GET_GAUGE_DATA                  2
 155
 156 /**
 157   Adds a record at the end of the performance measurement log
 158   that records the start time of a performance measurement.
 159
 160   The added record contains the Handle, Token, and Module.
 161   The end time of the new record is not recorded, so it is set to zero.
 162   If TimeStamp is not zero, then TimeStamp is used to fill in the start time in the record.
 163   If TimeStamp is zero, the start time in the record is filled in with the value
 164   read from the current time stamp.
 165
 166   @param  Handle                  The pointer to environment specific context used
 167                                   to identify the component being measured.
 168   @param  Token                   The pointer to a Null-terminated ASCII string
 169                                   that identifies the component being measured.
 170   @param  Module                  The pointer to a Null-terminated ASCII string
 171                                   that identifies the module being measured.
 172   @param  TimeStamp               The 64-bit time stamp.
 173
 174   @retval EFI_SUCCESS             The data was read correctly from the device.
 175   @retval EFI_OUT_OF_RESOURCES    There are not enough resources to record the measurement.
 176
 177 **/
 178 typedef
 179 EFI_STATUS
 180 (EFIAPI * PERFORMANCE_START_GAUGE)(
 181   IN CONST VOID   *Handle,  OPTIONAL
 182   IN CONST CHAR8  *Token,   OPTIONAL
 183   IN CONST CHAR8  *Module,  OPTIONAL
 184   IN UINT64       TimeStamp
 185   );
 186
 187 /**
 188   Searches the performance measurement log from the beginning of the log
 189   for the first matching record that contains a zero end time and fills in a valid end time.
 190
 191   Searches the performance measurement log from the beginning of the log
 192   for the first record that matches Handle, Token, and Module, and has an end time value of zero.
 193   If the record can not be found then return EFI_NOT_FOUND.
 194   If the record is found and TimeStamp is not zero,
 195   then the end time in the record is filled in with the value specified by TimeStamp.
 196   If the record is found and TimeStamp is zero, then the end time in the matching record
 197   is filled in with the current time stamp value.
 198
 199   @param  Handle                  The pointer to environment specific context used
 200                                   to identify the component being measured.
 201   @param  Token                   The pointer to a Null-terminated ASCII string
 202                                   that identifies the component being measured.
 203   @param  Module                  The pointer to a Null-terminated ASCII string
 204                                   that identifies the module being measured.
 205   @param  TimeStamp               The 64-bit time stamp.
 206
 207   @retval EFI_SUCCESS             The end of  the measurement was recorded.
 208   @retval EFI_NOT_FOUND           The specified measurement record could not be found.
 209
 210 **/
 211 typedef
 212 EFI_STATUS
 213 (EFIAPI * PERFORMANCE_END_GAUGE)(
 214   IN CONST VOID   *Handle,  OPTIONAL
 215   IN CONST CHAR8  *Token,   OPTIONAL
 216   IN CONST CHAR8  *Module,  OPTIONAL
 217   IN UINT64       TimeStamp
 218   );
 219
 220 /**
 221   Retrieves a previously logged performance measurement.
 222   It can also retrieve the log created by StartGaugeEx and EndGaugeEx of PERFORMANCE_EX_PROTOCOL,
 223   and then eliminate the Identifier.
 224
 225   Retrieves the performance log entry from the performance log specified by LogEntryKey.
 226   If it stands for a valid entry, then EFI_SUCCESS is returned and
 227   GaugeDataEntry stores the pointer to that entry.
 228
 229   @param  LogEntryKey             The key for the previous performance measurement log entry.
 230                                   If 0, then the first performance measurement log entry is retrieved.
 231   @param  GaugeDataEntry          Out parameter for the indirect pointer to the gauge data entry specified by LogEntryKey.
 232
 233   @retval EFI_SUCCESS             The GuageDataEntry is successfully found based on LogEntryKey.
 234   @retval EFI_NOT_FOUND           There is no entry after the measurement referred to by LogEntryKey.
 235   @retval EFI_INVALID_PARAMETER   The LogEntryKey is not a valid entry, or GaugeDataEntry is NULL.
 236
 237 **/
 238 typedef
 239 EFI_STATUS
 240 (EFIAPI * PERFORMANCE_GET_GAUGE)(
 241   IN  UINTN               LogEntryKey,
 242   OUT GAUGE_DATA_ENTRY    **GaugeDataEntry
 243   );
 244
 245 /**
 246   Adds a record at the end of the performance measurement log
 247   that records the start time of a performance measurement.
 248
 249   The added record contains the Handle, Token, Module and Identifier.
 250   The end time of the new record is not recorded, so it is set to zero.
 251   If TimeStamp is not zero, then TimeStamp is used to fill in the start time in the record.
 252   If TimeStamp is zero, the start time in the record is filled in with the value
 253   read from the current time stamp.
 254
 255   @param  Handle                  The pointer to environment specific context used
 256                                   to identify the component being measured.
 257   @param  Token                   The pointer to a Null-terminated ASCII string
 258                                   that identifies the component being measured.
 259   @param  Module                  The pointer to a Null-terminated ASCII string
 260                                   that identifies the module being measured.
 261   @param  TimeStamp               The 64-bit time stamp.
 262   @param  Identifier              32-bit identifier. If the value is 0, the created record
 263                                   is same as the one created by StartGauge of PERFORMANCE_PROTOCOL.
 264
 265   @retval EFI_SUCCESS             The data was read correctly from the device.
 266   @retval EFI_OUT_OF_RESOURCES    There are not enough resources to record the measurement.
 267
 268 **/
 269 typedef
 270 EFI_STATUS
 271 (EFIAPI * PERFORMANCE_START_GAUGE_EX)(
 272   IN CONST VOID   *Handle,  OPTIONAL
 273   IN CONST CHAR8  *Token,   OPTIONAL
 274   IN CONST CHAR8  *Module,  OPTIONAL
 275   IN UINT64       TimeStamp,
 276   IN UINT32       Identifier
 277   );
 278
 279 /**
 280   Searches the performance measurement log from the beginning of the log
 281   for the first matching record that contains a zero end time and fills in a valid end time.
 282
 283   Searches the performance measurement log from the beginning of the log
 284   for the first record that matches Handle, Token, Module and Identifier, and has an end time value of zero.
 285   If the record can not be found then return EFI_NOT_FOUND.
 286   If the record is found and TimeStamp is not zero,
 287   then the end time in the record is filled in with the value specified by TimeStamp.
 288   If the record is found and TimeStamp is zero, then the end time in the matching record
 289   is filled in with the current time stamp value.
 290
 291   @param  Handle                  The pointer to environment specific context used
 292                                   to identify the component being measured.
 293   @param  Token                   The pointer to a Null-terminated ASCII string
 294                                   that identifies the component being measured.
 295   @param  Module                  The pointer to a Null-terminated ASCII string
 296                                   that identifies the module being measured.
 297   @param  TimeStamp               The 64-bit time stamp.
 298   @param  Identifier              32-bit identifier. If the value is 0, the found record
 299                                   is same as the one found by EndGauge of PERFORMANCE_PROTOCOL.
 300
 301   @retval EFI_SUCCESS             The end of  the measurement was recorded.
 302   @retval EFI_NOT_FOUND           The specified measurement record could not be found.
 303
 304 **/
 305 typedef
 306 EFI_STATUS
 307 (EFIAPI * PERFORMANCE_END_GAUGE_EX)(
 308   IN CONST VOID   *Handle,  OPTIONAL
 309   IN CONST CHAR8  *Token,   OPTIONAL
 310   IN CONST CHAR8  *Module,  OPTIONAL
 311   IN UINT64       TimeStamp,
 312   IN UINT32       Identifier
 313   );
 314
 315 /**
 316   Retrieves a previously logged performance measurement.
 317   It can also retrieve the log created by StartGauge and EndGauge of PERFORMANCE_PROTOCOL,
 318   and then assign the Identifier with 0.
 319
 320   Retrieves the performance log entry from the performance log specified by LogEntryKey.
 321   If it stands for a valid entry, then EFI_SUCCESS is returned and
 322   GaugeDataEntryEx stores the pointer to that entry.
 323
 324   @param  LogEntryKey             The key for the previous performance measurement log entry.
 325                                   If 0, then the first performance measurement log entry is retrieved.
 326   @param  GaugeDataEntryEx        Out parameter for the indirect pointer to the extented gauge data entry specified by LogEntryKey.
 327
 328   @retval EFI_SUCCESS             The GuageDataEntryEx is successfully found based on LogEntryKey.
 329   @retval EFI_NOT_FOUND           There is no entry after the measurement referred to by LogEntryKey.
 330   @retval EFI_INVALID_PARAMETER   The LogEntryKey is not a valid entry, or GaugeDataEntryEx is NULL.
 331
 332 **/
 333 typedef
 334 EFI_STATUS
 335 (EFIAPI * PERFORMANCE_GET_GAUGE_EX)(
 336   IN  UINTN                 LogEntryKey,
 337   OUT GAUGE_DATA_ENTRY_EX   **GaugeDataEntryEx
 338   );
 339
 340 struct _PERFORMANCE_PROTOCOL {
 341   PERFORMANCE_START_GAUGE             StartGauge;
 342   PERFORMANCE_END_GAUGE               EndGauge;
 343   PERFORMANCE_GET_GAUGE               GetGauge;
 344 };
 345
 346 struct _PERFORMANCE_EX_PROTOCOL {
 347   PERFORMANCE_START_GAUGE_EX          StartGaugeEx;
 348   PERFORMANCE_END_GAUGE_EX            EndGaugeEx;
 349   PERFORMANCE_GET_GAUGE_EX            GetGaugeEx;
 350 };
 351
 352 extern EFI_GUID gPerformanceProtocolGuid;
 353 extern EFI_GUID gSmmPerformanceProtocolGuid;
 354 extern EFI_GUID gPerformanceExProtocolGuid;
 355 extern EFI_GUID gSmmPerformanceExProtocolGuid;
 356
 357 #endif