MdeModulePkg/Universal/FaultTolerantWriteDxe/FaultTolerantWriteSmm.c

   1 /** @file
   2
   3   This is a simple fault tolerant write driver that is intended to use in the SMM environment.
   4
   5   This boot service protocol only provides fault tolerant write capability for
   6   block devices.  The protocol has internal non-volatile intermediate storage
   7   of the data and private information. It should be able to recover
   8   automatically from a critical fault, such as power failure.
   9
  10   The implementation uses an FTW (Fault Tolerant Write) Work Space.
  11   This work space is a memory copy of the work space on the Working Block,
  12   the size of the work space is the FTW_WORK_SPACE_SIZE bytes.
  13
  14   The work space stores each write record as EFI_FTW_RECORD structure.
  15   The spare block stores the write buffer before write to the target block.
  16
  17   The write record has three states to specify the different phase of write operation.
  18   1) WRITE_ALLOCATED is that the record is allocated in write space.
  19      The information of write operation is stored in write record structure.
  20   2) SPARE_COMPLETED is that the data from write buffer is writed into the spare block as the backup.
  21   3) WRITE_COMPLETED is that the data is copied from the spare block to the target block.
  22
  23   This driver operates the data as the whole size of spare block.
  24   It first read the SpareAreaLength data from the target block into the spare memory buffer.
  25   Then copy the write buffer data into the spare memory buffer.
  26   Then write the spare memory buffer into the spare block.
  27   Final copy the data from the spare block to the target block.
  28
  29   To make this drive work well, the following conditions must be satisfied:
  30   1. The write NumBytes data must be fit within Spare area.
  31      Offset + NumBytes <= SpareAreaLength
  32   2. The whole flash range has the same block size.
  33   3. Working block is an area which contains working space in its last block and has the same size as spare block.
  34   4. Working Block area must be in the single one Firmware Volume Block range which FVB protocol is produced on.
  35   5. Spare area must be in the single one Firmware Volume Block range which FVB protocol is produced on.
  36   6. Any write data area (SpareAreaLength Area) which the data will be written into must be
  37      in the single one Firmware Volume Block range which FVB protocol is produced on.
  38   7. If write data area (such as Variable range) is enlarged, the spare area range must be enlarged.
  39      The spare area must be enough large to store the write data before write them into the target range.
  40   If one of them is not satisfied, FtwWrite may fail.
  41   Usually, Spare area only takes one block. That's SpareAreaLength = BlockSize, NumberOfSpareBlock = 1.
  42
  43   Caution: This module requires additional review when modified.
  44   This driver need to make sure the CommBuffer is not in the SMRAM range.
  45
  46 Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
  47 This program and the accompanying materials
  48 are licensed and made available under the terms and conditions of the BSD License
  49 which accompanies this distribution.  The full text of the license may be found at
  50 http://opensource.org/licenses/bsd-license.php
  51
  52 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  53 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  54
  55 **/
  56
  57 #include <PiSmm.h>
  58 #include <Library/SmmServicesTableLib.h>
  59 #include <Protocol/SmmSwapAddressRange.h>
  60 #include "FaultTolerantWrite.h"
  61 #include "FaultTolerantWriteSmmCommon.h"
  62 #include <Protocol/SmmAccess2.h>
  63
  64 EFI_EVENT                                 mFvbRegistration = NULL;
  65 EFI_FTW_DEVICE                            *mFtwDevice      = NULL;
  66 EFI_SMRAM_DESCRIPTOR                      *mSmramRanges;
  67 UINTN                                     mSmramRangeCount;
  68
  69
  70 /**
  71   This function check if the address is in SMRAM.
  72
  73   @param Buffer  the buffer address to be checked.
  74   @param Length  the buffer length to be checked.
  75
  76   @retval TRUE  this address is in SMRAM.
  77   @retval FALSE this address is NOT in SMRAM.
  78 **/
  79 BOOLEAN
  80 InternalIsAddressInSmram (
  81   IN EFI_PHYSICAL_ADDRESS  Buffer,
  82   IN UINT64                Length
  83   )
  84 {
  85   UINTN  Index;
  86
  87   for (Index = 0; Index < mSmramRangeCount; Index ++) {
  88     if (((Buffer >= mSmramRanges[Index].CpuStart) && (Buffer < mSmramRanges[Index].CpuStart + mSmramRanges[Index].PhysicalSize)) ||
  89         ((mSmramRanges[Index].CpuStart >= Buffer) && (mSmramRanges[Index].CpuStart < Buffer + Length))) {
  90       return TRUE;
  91     }
  92   }
  93
  94   return FALSE;
  95 }
  96
  97
  98 /**
  99   Retrive the SMM FVB protocol interface by HANDLE.
 100
 101   @param[in]  FvBlockHandle     The handle of SMM FVB protocol that provides services for
 102                                 reading, writing, and erasing the target block.
 103   @param[out] FvBlock           The interface of SMM FVB protocol
 104
 105   @retval EFI_SUCCESS           The interface information for the specified protocol was returned.
 106   @retval EFI_UNSUPPORTED       The device does not support the SMM FVB protocol.
 107   @retval EFI_INVALID_PARAMETER FvBlockHandle is not a valid EFI_HANDLE or FvBlock is NULL.
 108
 109 **/
 110 EFI_STATUS
 111 FtwGetFvbByHandle (
 112   IN  EFI_HANDLE                          FvBlockHandle,
 113   OUT EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  **FvBlock
 114   )
 115 {
 116   //
 117   // To get the SMM FVB protocol interface on the handle
 118   //
 119   return gSmst->SmmHandleProtocol (
 120                   FvBlockHandle,
 121                   &gEfiSmmFirmwareVolumeBlockProtocolGuid,
 122                   (VOID **) FvBlock
 123                   );
 124 }
 125
 126 /**
 127   Retrive the SMM Swap Address Range protocol interface.
 128
 129   @param[out] SarProtocol       The interface of SMM SAR protocol
 130
 131   @retval EFI_SUCCESS           The SMM SAR protocol instance was found and returned in SarProtocol.
 132   @retval EFI_NOT_FOUND         The SMM SAR protocol instance was not found.
 133   @retval EFI_INVALID_PARAMETER SarProtocol is NULL.
 134
 135 **/
 136 EFI_STATUS
 137 FtwGetSarProtocol (
 138   OUT VOID                                **SarProtocol
 139   )
 140 {
 141   EFI_STATUS                              Status;
 142
 143   //
 144   // Locate Smm Swap Address Range protocol
 145   //
 146   Status = gSmst->SmmLocateProtocol (
 147                     &gEfiSmmSwapAddressRangeProtocolGuid,
 148                     NULL,
 149                     SarProtocol
 150                     );
 151   return Status;
 152 }
 153
 154 /**
 155   Function returns an array of handles that support the SMM FVB protocol
 156   in a buffer allocated from pool.
 157
 158   @param[out]  NumberHandles    The number of handles returned in Buffer.
 159   @param[out]  Buffer           A pointer to the buffer to return the requested
 160                                 array of  handles that support SMM FVB protocol.
 161
 162   @retval EFI_SUCCESS           The array of handles was returned in Buffer, and the number of
 163                                 handles in Buffer was returned in NumberHandles.
 164   @retval EFI_NOT_FOUND         No SMM FVB handle was found.
 165   @retval EFI_OUT_OF_RESOURCES  There is not enough pool memory to store the matching results.
 166   @retval EFI_INVALID_PARAMETER NumberHandles is NULL or Buffer is NULL.
 167
 168 **/
 169 EFI_STATUS
 170 GetFvbCountAndBuffer (
 171   OUT UINTN                               *NumberHandles,
 172   OUT EFI_HANDLE                          **Buffer
 173   )
 174 {
 175   EFI_STATUS                              Status;
 176   UINTN                                   BufferSize;
 177
 178   if ((NumberHandles == NULL) || (Buffer == NULL)) {
 179     return EFI_INVALID_PARAMETER;
 180   }
 181
 182   BufferSize     = 0;
 183   *NumberHandles = 0;
 184   *Buffer        = NULL;
 185   Status = gSmst->SmmLocateHandle (
 186                     ByProtocol,
 187                     &gEfiSmmFirmwareVolumeBlockProtocolGuid,
 188                     NULL,
 189                     &BufferSize,
 190                     *Buffer
 191                     );
 192   if (EFI_ERROR(Status) && Status != EFI_BUFFER_TOO_SMALL) {
 193     return EFI_NOT_FOUND;
 194   }
 195
 196   *Buffer = AllocatePool (BufferSize);
 197   if (*Buffer == NULL) {
 198     return EFI_OUT_OF_RESOURCES;
 199   }
 200
 201   Status = gSmst->SmmLocateHandle (
 202                     ByProtocol,
 203                     &gEfiSmmFirmwareVolumeBlockProtocolGuid,
 204                     NULL,
 205                     &BufferSize,
 206                     *Buffer
 207                     );
 208
 209   *NumberHandles = BufferSize / sizeof(EFI_HANDLE);
 210   if (EFI_ERROR(Status)) {
 211     *NumberHandles = 0;
 212     FreePool (*Buffer);
 213     *Buffer = NULL;
 214   }
 215
 216   return Status;
 217 }
 218
 219
 220 /**
 221   Get the handle of the SMM FVB protocol by the FVB base address and attributes.
 222
 223   @param[in]  Address       The base address of SMM FVB protocol.
 224   @param[in]  Attributes    The attributes of the SMM FVB protocol.
 225   @param[out] SmmFvbHandle  The handle of the SMM FVB protocol.
 226
 227   @retval  EFI_SUCCESS    The FVB handle is found.
 228   @retval  EFI_ABORTED    The FVB protocol is not found.
 229
 230 **/
 231 EFI_STATUS
 232 GetFvbByAddressAndAttribute (
 233   IN  EFI_PHYSICAL_ADDRESS            Address,
 234   IN  EFI_FVB_ATTRIBUTES_2            Attributes,
 235   OUT EFI_HANDLE                      *SmmFvbHandle
 236   )
 237 {
 238   EFI_STATUS                          Status;
 239   EFI_HANDLE                          *HandleBuffer;
 240   UINTN                               HandleCount;
 241   UINTN                               Index;
 242   EFI_PHYSICAL_ADDRESS                FvbBaseAddress;
 243   EFI_FVB_ATTRIBUTES_2                FvbAttributes;
 244   EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;
 245
 246   //
 247   // Locate all handles of SMM Fvb protocol.
 248   //
 249   Status = GetFvbCountAndBuffer (&HandleCount, &HandleBuffer);
 250   if (EFI_ERROR (Status)) {
 251     return EFI_ABORTED;
 252   }
 253
 254   //
 255   // Find the proper SMM Fvb handle by the address and attributes.
 256   //
 257   for (Index = 0; Index < HandleCount; Index++) {
 258     Status = FtwGetFvbByHandle (HandleBuffer[Index], &Fvb);
 259     if (EFI_ERROR (Status)) {
 260       break;
 261     }
 262     //
 263     // Compare the address.
 264     //
 265     Status = Fvb->GetPhysicalAddress (Fvb, &FvbBaseAddress);
 266     if (EFI_ERROR (Status)) {
 267       continue;
 268     }
 269     if (Address != FvbBaseAddress) {
 270      continue;
 271     }
 272
 273     //
 274     // Compare the attribute.
 275     //
 276     Status = Fvb->GetAttributes (Fvb, &FvbAttributes);
 277     if (EFI_ERROR (Status)) {
 278       continue;
 279     }
 280     if (Attributes != FvbAttributes) {
 281      continue;
 282     }
 283
 284     //
 285     // Found the proper FVB handle.
 286     //
 287     *SmmFvbHandle = HandleBuffer[Index];
 288     FreePool (HandleBuffer);
 289     return EFI_SUCCESS;
 290   }
 291
 292   FreePool (HandleBuffer);
 293   return EFI_ABORTED;
 294 }
 295
 296 /**
 297   Communication service SMI Handler entry.
 298
 299   This SMI handler provides services for the fault tolerant write wrapper driver.
 300
 301   Caution: This function requires additional review when modified.
 302   This driver need to make sure the CommBuffer is not in the SMRAM range.
 303   Also in FTW_FUNCTION_GET_LAST_WRITE case, check SmmFtwGetLastWriteHeader->Data +
 304   SmmFtwGetLastWriteHeader->PrivateDataSize within communication buffer.
 305
 306   @param[in]     DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 307   @param[in]     RegisterContext Points to an optional handler context which was specified when the
 308                                  handler was registered.
 309   @param[in, out] CommBuffer     A pointer to a collection of data in memory that will be conveyed
 310                                  from a non-SMM environment into an SMM environment.
 311   @param[in, out] CommBufferSize The size of the CommBuffer.
 312
 313   @retval EFI_SUCCESS                         The interrupt was handled and quiesced. No other handlers
 314                                               should still be called.
 315   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED  The interrupt has been quiesced but other handlers should
 316                                               still be called.
 317   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING   The interrupt is still pending and other handlers should still
 318                                               be called.
 319   @retval EFI_INTERRUPT_PENDING               The interrupt could not be quiesced.
 320
 321 **/
 322 EFI_STATUS
 323 EFIAPI
 324 SmmFaultTolerantWriteHandler (
 325   IN     EFI_HANDLE                                DispatchHandle,
 326   IN     CONST VOID                                *RegisterContext,
 327   IN OUT VOID                                      *CommBuffer,
 328   IN OUT UINTN                                     *CommBufferSize
 329   )
 330 {
 331   EFI_STATUS                                       Status;
 332   SMM_FTW_COMMUNICATE_FUNCTION_HEADER              *SmmFtwFunctionHeader;
 333   SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER                *SmmGetMaxBlockSizeHeader;
 334   SMM_FTW_ALLOCATE_HEADER                          *SmmFtwAllocateHeader;
 335   SMM_FTW_WRITE_HEADER                             *SmmFtwWriteHeader;
 336   SMM_FTW_RESTART_HEADER                           *SmmFtwRestartHeader;
 337   SMM_FTW_GET_LAST_WRITE_HEADER                    *SmmFtwGetLastWriteHeader;
 338   VOID                                             *PrivateData;
 339   EFI_HANDLE                                       SmmFvbHandle;
 340   UINTN                                            InfoSize;
 341
 342
 343   //
 344   // If input is invalid, stop processing this SMI
 345   //
 346   if (CommBuffer == NULL || CommBufferSize == NULL) {
 347     return EFI_SUCCESS;
 348   }
 349
 350   if (*CommBufferSize < SMM_FTW_COMMUNICATE_HEADER_SIZE) {
 351     return EFI_SUCCESS;
 352   }
 353
 354   if (InternalIsAddressInSmram ((EFI_PHYSICAL_ADDRESS)(UINTN)CommBuffer, *CommBufferSize)) {
 355     DEBUG ((EFI_D_ERROR, "SMM communication buffer size is in SMRAM!\n"));
 356     return EFI_SUCCESS;
 357   }
 358
 359   SmmFtwFunctionHeader = (SMM_FTW_COMMUNICATE_FUNCTION_HEADER *)CommBuffer;
 360   switch (SmmFtwFunctionHeader->Function) {
 361     case FTW_FUNCTION_GET_MAX_BLOCK_SIZE:
 362       SmmGetMaxBlockSizeHeader = (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER *) SmmFtwFunctionHeader->Data;
 363       InfoSize = sizeof (SMM_FTW_GET_MAX_BLOCK_SIZE_HEADER);
 364
 365       //
 366       // SMRAM range check already covered before
 367       //
 368       if (InfoSize > *CommBufferSize - SMM_FTW_COMMUNICATE_HEADER_SIZE) {
 369         DEBUG ((EFI_D_ERROR, "Data size exceed communication buffer size limit!\n"));
 370         Status = EFI_ACCESS_DENIED;
 371         break;
 372       }
 373
 374       Status = FtwGetMaxBlockSize (
 375                  &mFtwDevice->FtwInstance,
 376                  &SmmGetMaxBlockSizeHeader->BlockSize
 377                  );
 378       break;
 379
 380     case FTW_FUNCTION_ALLOCATE:
 381       SmmFtwAllocateHeader = (SMM_FTW_ALLOCATE_HEADER *) SmmFtwFunctionHeader->Data;
 382       Status = FtwAllocate (
 383                  &mFtwDevice->FtwInstance,
 384                  &SmmFtwAllocateHeader->CallerId,
 385                  SmmFtwAllocateHeader->PrivateDataSize,
 386                  SmmFtwAllocateHeader->NumberOfWrites
 387                  );
 388       break;
 389
 390     case FTW_FUNCTION_WRITE:
 391       SmmFtwWriteHeader = (SMM_FTW_WRITE_HEADER *) SmmFtwFunctionHeader->Data;
 392       if (SmmFtwWriteHeader->PrivateDataSize == 0) {
 393         PrivateData = NULL;
 394       } else {
 395         PrivateData = (VOID *)&SmmFtwWriteHeader->Data[SmmFtwWriteHeader->Length];
 396       }
 397       Status = GetFvbByAddressAndAttribute (
 398                  SmmFtwWriteHeader->FvbBaseAddress,
 399                  SmmFtwWriteHeader->FvbAttributes,
 400                  &SmmFvbHandle
 401                  );
 402       if (!EFI_ERROR (Status)) {
 403         Status = FtwWrite(
 404                    &mFtwDevice->FtwInstance,
 405                    SmmFtwWriteHeader->Lba,
 406                    SmmFtwWriteHeader->Offset,
 407                    SmmFtwWriteHeader->Length,
 408                    PrivateData,
 409                    SmmFvbHandle,
 410                    SmmFtwWriteHeader->Data
 411                    );
 412       }
 413       break;
 414
 415     case FTW_FUNCTION_RESTART:
 416       SmmFtwRestartHeader = (SMM_FTW_RESTART_HEADER *) SmmFtwFunctionHeader->Data;
 417       Status = GetFvbByAddressAndAttribute (
 418                  SmmFtwRestartHeader->FvbBaseAddress,
 419                  SmmFtwRestartHeader->FvbAttributes,
 420                  &SmmFvbHandle
 421                  );
 422       if (!EFI_ERROR (Status)) {
 423         Status = FtwRestart (&mFtwDevice->FtwInstance, SmmFvbHandle);
 424       }
 425       break;
 426
 427     case FTW_FUNCTION_ABORT:
 428       Status = FtwAbort (&mFtwDevice->FtwInstance);
 429       break;
 430
 431     case FTW_FUNCTION_GET_LAST_WRITE:
 432       SmmFtwGetLastWriteHeader = (SMM_FTW_GET_LAST_WRITE_HEADER *) SmmFtwFunctionHeader->Data;
 433       InfoSize = OFFSET_OF (SMM_FTW_GET_LAST_WRITE_HEADER, Data) + SmmFtwGetLastWriteHeader->PrivateDataSize;
 434
 435       //
 436       // SMRAM range check already covered before
 437       //
 438       if (InfoSize > *CommBufferSize - SMM_FTW_COMMUNICATE_HEADER_SIZE) {
 439         DEBUG ((EFI_D_ERROR, "Data size exceed communication buffer size limit!\n"));
 440         Status = EFI_ACCESS_DENIED;
 441         break;
 442       }
 443
 444       Status = FtwGetLastWrite (
 445                  &mFtwDevice->FtwInstance,
 446                  &SmmFtwGetLastWriteHeader->CallerId,
 447                  &SmmFtwGetLastWriteHeader->Lba,
 448                  &SmmFtwGetLastWriteHeader->Offset,
 449                  &SmmFtwGetLastWriteHeader->Length,
 450                  &SmmFtwGetLastWriteHeader->PrivateDataSize,
 451                  (VOID *)SmmFtwGetLastWriteHeader->Data,
 452                  &SmmFtwGetLastWriteHeader->Complete
 453                  );
 454       break;
 455
 456     default:
 457       Status = EFI_UNSUPPORTED;
 458   }
 459
 460   SmmFtwFunctionHeader->ReturnStatus = Status;
 461
 462   return EFI_SUCCESS;
 463 }
 464
 465
 466 /**
 467   SMM Firmware Volume Block Protocol notification event handler.
 468
 469   @param[in]  Protocol      Points to the protocol's unique identifier
 470   @param[in]  Interface     Points to the interface instance
 471   @param[in]  Handle        The handle on which the interface was installed
 472
 473   @retval EFI_SUCCESS       SmmEventCallback runs successfully
 474
 475  **/
 476 EFI_STATUS
 477 EFIAPI
 478 FvbNotificationEvent (
 479   IN CONST EFI_GUID                       *Protocol,
 480   IN VOID                                 *Interface,
 481   IN EFI_HANDLE                           Handle
 482   )
 483 {
 484   EFI_STATUS                              Status;
 485   EFI_SMM_FAULT_TOLERANT_WRITE_PROTOCOL   *FtwProtocol;
 486   EFI_HANDLE                              SmmFtwHandle;
 487
 488   //
 489   // Just return to avoid install SMM FaultTolerantWriteProtocol again
 490   // if SMM Fault Tolerant Write protocol had been installed.
 491   //
 492   Status = gSmst->SmmLocateProtocol (
 493                     &gEfiSmmFaultTolerantWriteProtocolGuid,
 494                     NULL,
 495                     (VOID **) &FtwProtocol
 496                     );
 497   if (!EFI_ERROR (Status)) {
 498     return EFI_SUCCESS;
 499   }
 500
 501   //
 502   // Found proper FVB protocol and initialize FtwDevice for protocol installation
 503   //
 504   Status = InitFtwProtocol (mFtwDevice);
 505   if (EFI_ERROR(Status)) {
 506     return Status;
 507   }
 508
 509   //
 510   // Install protocol interface
 511   //
 512   Status = gSmst->SmmInstallProtocolInterface (
 513                     &mFtwDevice->Handle,
 514                     &gEfiSmmFaultTolerantWriteProtocolGuid,
 515                     EFI_NATIVE_INTERFACE,
 516                     &mFtwDevice->FtwInstance
 517                     );
 518   ASSERT_EFI_ERROR (Status);
 519
 520   //
 521   // Notify the Ftw wrapper driver SMM Ftw is ready
 522   //
 523   SmmFtwHandle = NULL;
 524   Status = gBS->InstallProtocolInterface (
 525                   &SmmFtwHandle,
 526                   &gEfiSmmFaultTolerantWriteProtocolGuid,
 527                   EFI_NATIVE_INTERFACE,
 528                   NULL
 529                   );
 530   ASSERT_EFI_ERROR (Status);
 531
 532   return EFI_SUCCESS;
 533 }
 534
 535
 536 /**
 537   This function is the entry point of the Fault Tolerant Write driver.
 538
 539   @param[in] ImageHandle        A handle for the image that is initializing this driver
 540   @param[in] SystemTable        A pointer to the EFI system table
 541
 542   @retval EFI_SUCCESS           The initialization finished successfully.
 543   @retval EFI_OUT_OF_RESOURCES  Allocate memory error
 544   @retval EFI_INVALID_PARAMETER Workspace or Spare block does not exist
 545
 546 **/
 547 EFI_STATUS
 548 EFIAPI
 549 SmmFaultTolerantWriteInitialize (
 550   IN EFI_HANDLE                           ImageHandle,
 551   IN EFI_SYSTEM_TABLE                     *SystemTable
 552   )
 553 {
 554   EFI_STATUS                              Status;
 555   EFI_HANDLE                              FtwHandle;
 556   EFI_SMM_ACCESS2_PROTOCOL                *SmmAccess;
 557   UINTN                                   Size;
 558
 559   //
 560   // Allocate private data structure for SMM FTW protocol and do some initialization
 561   //
 562   Status = InitFtwDevice (&mFtwDevice);
 563   if (EFI_ERROR(Status)) {
 564     return Status;
 565   }
 566
 567   //
 568   // Get SMRAM information
 569   //
 570   Status = gBS->LocateProtocol (&gEfiSmmAccess2ProtocolGuid, NULL, (VOID **)&SmmAccess);
 571   ASSERT_EFI_ERROR (Status);
 572
 573   Size = 0;
 574   Status = SmmAccess->GetCapabilities (SmmAccess, &Size, NULL);
 575   ASSERT (Status == EFI_BUFFER_TOO_SMALL);
 576
 577   Status = gSmst->SmmAllocatePool (
 578                     EfiRuntimeServicesData,
 579                     Size,
 580                     (VOID **)&mSmramRanges
 581                     );
 582   ASSERT_EFI_ERROR (Status);
 583
 584   Status = SmmAccess->GetCapabilities (SmmAccess, &Size, mSmramRanges);
 585   ASSERT_EFI_ERROR (Status);
 586
 587   mSmramRangeCount = Size / sizeof (EFI_SMRAM_DESCRIPTOR);
 588
 589   //
 590   // Register FvbNotificationEvent () notify function.
 591   //
 592   Status = gSmst->SmmRegisterProtocolNotify (
 593                     &gEfiSmmFirmwareVolumeBlockProtocolGuid,
 594                     FvbNotificationEvent,
 595                     &mFvbRegistration
 596                     );
 597   ASSERT_EFI_ERROR (Status);
 598
 599   FvbNotificationEvent (NULL, NULL, NULL);
 600
 601   ///
 602   /// Register SMM FTW SMI handler
 603   ///
 604   Status = gSmst->SmiHandlerRegister (SmmFaultTolerantWriteHandler, &gEfiSmmFaultTolerantWriteProtocolGuid, &FtwHandle);
 605   ASSERT_EFI_ERROR (Status);
 606
 607   return EFI_SUCCESS;
 608 }