EdkModulePkg/Universal/MonotonicCounter/RuntimeDxe/MonotonicCounter.c

   1 /*++
   2
   3 Copyright (c) 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 Module Name:
  13
  14   MonotonicCounter.c
  15
  16 Abstract:
  17
  18   Produced the Monotonic Counter Services as defined in the DXE CIS
  19
  20 Revision History:
  21
  22 --*/
  23
  24 #include "MonotonicCounter.h"
  25
  26 //
  27 // The Monotonic Counter Handle
  28 //
  29 EFI_HANDLE  mMonotonicCounterHandle = NULL;
  30
  31 //
  32 // The current Monotonic count value
  33 //
  34 UINT64      mEfiMtc;
  35
  36 //
  37 // Event to use to update the Mtc's high part when wrapping
  38 //
  39 EFI_EVENT   mEfiMtcEvent;
  40
  41 //
  42 // EfiMtcName - Variable name of the MTC value
  43 //
  44 CHAR16      *mEfiMtcName = (CHAR16 *) L"MTC";
  45
  46 //
  47 // EfiMtcGuid - Guid of the MTC value
  48 //
  49 EFI_GUID    mEfiMtcGuid = { 0xeb704011, 0x1402, 0x11d3, { 0x8e, 0x77, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b } };
  50
  51 //
  52 // Worker functions
  53 //
  54 EFI_STATUS
  55 EFIAPI
  56 MonotonicCounterDriverGetNextMonotonicCount (
  57   OUT UINT64  *Count
  58   )
  59 /*++
  60
  61 Routine Description:
  62
  63 Arguments:
  64
  65 Returns:
  66
  67 --*/
  68 {
  69   EFI_TPL OldTpl;
  70
  71   //
  72   // Can not be called after ExitBootServices()
  73   //
  74   if (EfiAtRuntime ()) {
  75     return EFI_UNSUPPORTED;
  76   }
  77   //
  78   // Check input parameters
  79   //
  80   if (Count == NULL) {
  81     return EFI_INVALID_PARAMETER;
  82   }
  83   //
  84   // Update the monotonic counter with a lock
  85   //
  86   OldTpl  = gBS->RaiseTPL (EFI_TPL_HIGH_LEVEL);
  87   *Count  = mEfiMtc;
  88   mEfiMtc++;
  89   gBS->RestoreTPL (OldTpl);
  90
  91   //
  92   // If the MSB bit of the low part toggled, then signal that the high
  93   // part needs updated now
  94   //
  95   if ((((UINT32) mEfiMtc) ^ ((UINT32) *Count)) & 0x80000000) {
  96     gBS->SignalEvent (mEfiMtcEvent);
  97   }
  98
  99   return EFI_SUCCESS;
 100 }
 101
 102
 103 /**
 104   Returns the next high 32 bits of the platform's monotonic counter.
 105
 106   The GetNextHighMonotonicCount() function returns the next high 32 bits
 107   of the platform's monotonic counter. The platform's monotonic counter is
 108   comprised of two 32 bit quantities:  the high 32 bits and the low 32 bits.
 109   During boot service time the low 32 bit value is volatile:  it is reset to
 110   zero on every system reset and is increased by 1 on every call to GetNextMonotonicCount().
 111   The high 32 bit value is non-volatile and is increased by 1 whenever the system resets
 112   or whenever the low 32 bit count [returned by GetNextMonoticCount()] overflows.
 113   The GetNextMonotonicCount() function is only available at boot services time.
 114   If the operating system wishes to extend the platform monotonic counter to runtime,
 115   it may do so by utilizing GetNextHighMonotonicCount().  To do this, before calling
 116   ExitBootServices() the operating system would call GetNextMonotonicCount() to obtain
 117   the current platform monotonic count.  The operating system would then provide an
 118   interface that returns the next count by:
 119     Adding 1 to the last count.
 120     Before the lower 32 bits of the count overflows, call GetNextHighMonotonicCount().
 121     This will increase the high 32 bits of the platform's non-volatile portion of the monotonic
 122     count by 1.
 123
 124   This function may only be called at Runtime.
 125
 126   @param[out]   HighCount       Pointer to returned value.
 127
 128   @retval EFI_INVALID_PARAMETER If HighCount is NULL.
 129   @retval EFI_SUCCESS           Operation is successful.
 130   @retval EFI_OUT_OF_RESOURCES  If variable service reports that not enough storage
 131                                 is available to hold the variable and its data.
 132   @retval EFI_DEVICE_ERROR      The variable could not be saved due to a hardware failure.
 133
 134 **/
 135 EFI_STATUS
 136 EFIAPI
 137 MonotonicCounterDriverGetNextHighMonotonicCount (
 138   OUT UINT32  *HighCount
 139   )
 140 /*++
 141
 142 Routine Description:
 143
 144 Arguments:
 145
 146 Returns:
 147
 148 --*/
 149 {
 150   EFI_TPL     OldTpl;
 151
 152   //
 153   // Check input parameters
 154   //
 155   if (HighCount == NULL) {
 156     return EFI_INVALID_PARAMETER;
 157   }
 158
 159   if (!EfiAtRuntime ()) {
 160     //
 161     // Use a lock if called before ExitBootServices()
 162     //
 163     OldTpl      = gBS->RaiseTPL (EFI_TPL_HIGH_LEVEL);
 164     *HighCount  = (UINT32) RShiftU64 (mEfiMtc, 32) + 1;
 165     mEfiMtc     = LShiftU64 (*HighCount, 32);
 166     gBS->RestoreTPL (OldTpl);
 167   } else {
 168     *HighCount  = (UINT32) RShiftU64 (mEfiMtc, 32) + 1;
 169     mEfiMtc     = LShiftU64 (*HighCount, 32);
 170   }
 171   //
 172   // Update the NvRam store to match the new high part
 173   //
 174   return EfiSetVariable (
 175            mEfiMtcName,
 176            &mEfiMtcGuid,
 177            EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 178            sizeof (UINT32),
 179            HighCount
 180            );
 181
 182 }
 183
 184 VOID
 185 EFIAPI
 186 EfiMtcEventHandler (
 187   IN EFI_EVENT                Event,
 188   IN VOID                     *Context
 189   )
 190 /*++
 191
 192 Routine Description:
 193
 194   Monotonic count event handler.  This handler updates the high monotonic count.
 195
 196 Arguments:
 197
 198   Event         The event to handle
 199   Context       The event context
 200
 201 Returns:
 202
 203   EFI_SUCCESS       The event has been handled properly
 204   EFI_NOT_FOUND     An error occurred updating the variable.
 205
 206 --*/
 207 {
 208   UINT32  HighCount;
 209
 210   MonotonicCounterDriverGetNextHighMonotonicCount (&HighCount);
 211 }
 212
 213 EFI_STATUS
 214 EFIAPI
 215 MonotonicCounterDriverInitialize (
 216   IN EFI_HANDLE        ImageHandle,
 217   IN EFI_SYSTEM_TABLE  *SystemTable
 218   )
 219 /*++
 220
 221 Routine Description:
 222
 223 Arguments:
 224   (Standard EFI Image entry - EFI_IMAGE_ENTRY_POINT)
 225
 226 Returns:
 227
 228 --*/
 229 {
 230   EFI_STATUS  Status;
 231   UINT32      HighCount;
 232   UINTN       BufferSize;
 233
 234   //
 235   // Make sure the Monotonic Counter Architectural Protocol is not already installed in the system
 236   //
 237   ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiMonotonicCounterArchProtocolGuid);
 238
 239   //
 240   // Initialize event to handle overflows
 241   //
 242   Status = gBS->CreateEvent (
 243                   EFI_EVENT_NOTIFY_SIGNAL,
 244                   EFI_TPL_CALLBACK,
 245                   EfiMtcEventHandler,
 246                   NULL,
 247                   &mEfiMtcEvent
 248                   );
 249
 250   ASSERT_EFI_ERROR (Status);
 251
 252   //
 253   // Read the last high part
 254   //
 255   BufferSize = sizeof (UINT32);
 256   Status = gRT->GetVariable (
 257                   mEfiMtcName,
 258                   &mEfiMtcGuid,
 259                   NULL,
 260                   &BufferSize,
 261                   &HighCount
 262                   );
 263   if (EFI_ERROR (Status)) {
 264     HighCount = 0;
 265   }
 266   //
 267   // Set the current value
 268   //
 269   mEfiMtc = LShiftU64 (HighCount, 32);
 270
 271   //
 272   // Increment the upper 32 bits for this boot
 273   // Continue even if it fails.  It will only fail if the variable services are
 274   // not functional.
 275   //
 276   Status = MonotonicCounterDriverGetNextHighMonotonicCount (&HighCount);
 277
 278   //
 279   // Fill in the EFI Boot Services and EFI Runtime Services Monotonic Counter Fields
 280   //
 281   gBS->GetNextMonotonicCount      = MonotonicCounterDriverGetNextMonotonicCount;
 282   gRT->GetNextHighMonotonicCount  = MonotonicCounterDriverGetNextHighMonotonicCount;
 283
 284   //
 285   // Install the Monotonic Counter Architctural Protocol onto a new handle
 286   //
 287   Status = gBS->InstallMultipleProtocolInterfaces (
 288                   &mMonotonicCounterHandle,
 289                   &gEfiMonotonicCounterArchProtocolGuid,
 290                   NULL,
 291                   NULL
 292                   );
 293   ASSERT_EFI_ERROR (Status);
 294
 295   return EFI_SUCCESS;
 296 }