EFI_STATUS EFIAPI FvbProtocolSetAttributes ( IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes ) /*++ Routine Description: Sets Volume attributes. No polarity translations are done. Arguments: This - Calling context Attributes - output buffer which contains attributes Returns: EFI_SUCCESS - Successfully returns **/ { EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; FvbDevice = FVB_DEVICE_FROM_THIS (This); return FvbSetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ()); }
// // FVB protocol APIs // EFI_STATUS EFIAPI FvbProtocolGetPhysicalAddress ( IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, OUT EFI_PHYSICAL_ADDRESS *Address ) /*++ Routine Description: Retrieves the physical address of the device. Arguments: This - Calling context Address - Output buffer containing the address. Returns: Returns: EFI_SUCCESS - Successfully returns **/ { EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; FvbDevice = FVB_DEVICE_FROM_THIS (This); return FvbGetPhysicalAddress (FvbDevice->Instance, Address, mFvbModuleGlobal, EfiGoneVirtual ()); }
EFI_STATUS EFIAPI FvbProtocolGetBlockSize ( IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, IN EFI_LBA Lba, OUT UINTN *BlockSize, OUT UINTN *NumOfBlocks ) /*++ Routine Description: Retrieve the size of a logical block Arguments: This - Calling context Lba - Indicates which block to return the size for. BlockSize - A pointer to a caller allocated UINTN in which the size of the block is returned NumOfBlocks - a pointer to a caller allocated UINTN in which the number of consecutive blocks starting with Lba is returned. All blocks in this range have a size of BlockSize Returns: EFI_SUCCESS - The firmware volume was read successfully and contents are in Buffer **/ { EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; FvbDevice = FVB_DEVICE_FROM_THIS (This); return FvbGetLbaAddress ( FvbDevice->Instance, Lba, NULL, BlockSize, NumOfBlocks, mFvbModuleGlobal, EfiGoneVirtual () ); }
/** Check whether crypto service provided by Runtime Crypt protocol is ready to use. Crypto service is available if the call is in physical mode prior to SetVirtualAddressMap() or virtual mode after SetVirtualAddressMap(). If either of these two conditions are met, this routine will return TRUE; if neither of these conditions are met, this routine will return FALSE. @retval TRUE The Crypto service is ready to use. @retval FALSE The Crypto service is not available. **/ BOOLEAN EFIAPI InternalIsCryptServiveAvailable ( VOID ) { INT64 CpuMode; BOOLEAN GoneVirtual; CpuMode = AsmCpuVirtual(); if (CpuMode < 0) { // // CPU is in mixed mode, return failing the operation gracefully. // return FALSE; } GoneVirtual = EfiGoneVirtual(); if ((CpuMode > 0) && !GoneVirtual) { // // CPU is in virtual mode, but SetVirtualAddressMap() has not been called, // so return failing the operation gracefully. // return FALSE; } if ((CpuMode == 0) && GoneVirtual) { // // CPU is in physical mode, but SetVirtualAddressMap() has been called, // so return failing the operation gracefully. // return FALSE; } return TRUE; }
EFI_STATUS EFIAPI FvbProtocolRead ( IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, IN EFI_LBA Lba, IN UINTN Offset, IN OUT UINTN *NumBytes, IN UINT8 *Buffer ) /*++ Routine Description: Reads data beginning at Lba:Offset from FV. The Read terminates either when *NumBytes of data have been read, or when a block boundary is reached. *NumBytes is updated to reflect the actual number of bytes written. The write opertion does not include erase. This routine will attempt to write only the specified bytes. If the writes do not stick, it will return an error. Arguments: This - Calling context Lba - Block in which to begin Read Offset - Offset in the block at which to begin Read NumBytes - On input, indicates the requested write size. On output, indicates the actual number of bytes Read Buffer - Buffer containing source data for the Read. Returns: EFI_SUCCESS - The firmware volume was read successfully and contents are in Buffer EFI_BAD_BUFFER_SIZE - Read attempted across a LBA boundary. On output, NumBytes contains the total number of bytes returned in Buffer EFI_ACCESS_DENIED - The firmware volume is in the ReadDisabled state EFI_DEVICE_ERROR - The block device is not functioning correctly and could not be read EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL **/ { EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; FvbDevice = FVB_DEVICE_FROM_THIS (This); return FvbReadBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer, mFvbModuleGlobal, EfiGoneVirtual ()); }
EFI_STATUS EFIAPI FvbProtocolEraseBlocks ( IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, ... ) /*++ Routine Description: The EraseBlock() function erases one or more blocks as denoted by the variable argument list. The entire parameter list of blocks must be verified prior to erasing any blocks. If a block is requested that does not exist within the associated firmware volume (it has a larger index than the last block of the firmware volume), the EraseBlock() function must return EFI_INVALID_PARAMETER without modifying the contents of the firmware volume. Arguments: This - Calling context ... - Starting LBA followed by Number of Lba to erase. a -1 to terminate the list. Returns: EFI_SUCCESS - The erase request was successfully completed EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state EFI_DEVICE_ERROR - The block device is not functioning correctly and could not be written. Firmware device may have been partially erased **/ { EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; EFI_FW_VOL_INSTANCE *FwhInstance = NULL; UINTN NumOfBlocks; VA_LIST args; EFI_LBA StartingLba; UINTN NumOfLba; EFI_STATUS Status; FvbDevice = FVB_DEVICE_FROM_THIS (This); Status = GetFvbInstance (FvbDevice->Instance, mFvbModuleGlobal, &FwhInstance, EfiGoneVirtual ()); ASSERT_EFI_ERROR (Status); NumOfBlocks = FwhInstance->NumOfBlocks; VA_START (args, This); do { StartingLba = VA_ARG (args, EFI_LBA); if (StartingLba == EFI_LBA_LIST_TERMINATOR) { break; } NumOfLba = VA_ARG (args, UINTN); // // Check input parameters // if (NumOfLba == 0 || (StartingLba + NumOfLba) > NumOfBlocks) { VA_END (args); return EFI_INVALID_PARAMETER; } } while (1); VA_END (args); VA_START (args, This); do { StartingLba = VA_ARG (args, EFI_LBA); if (StartingLba == EFI_LBA_LIST_TERMINATOR) { break; } NumOfLba = VA_ARG (args, UINTN); while (NumOfLba > 0) { Status = FvbEraseBlock (FvbDevice->Instance, StartingLba, mFvbModuleGlobal, EfiGoneVirtual ()); if (EFI_ERROR (Status)) { VA_END (args); return Status; } StartingLba++; NumOfLba--; } } while (1); VA_END (args); return EFI_SUCCESS; }
/** Communicates with a registered handler. This function provides a service to send and receive messages from a registered UEFI service. This function is part of the SMM Communication Protocol that may be called in physical mode prior to SetVirtualAddressMap() and in virtual mode after SetVirtualAddressMap(). @param[in] This The EFI_SMM_COMMUNICATION_PROTOCOL instance. @param[in, out] CommBuffer A pointer to the buffer to convey into SMRAM. @param[in, out] CommSize The size of the data buffer being passed in.On exit, the size of data being returned. Zero if the handler does not wish to reply with any data. @retval EFI_SUCCESS The message was successfully posted. @retval EFI_INVALID_PARAMETER The CommBuffer was NULL. **/ EFI_STATUS EFIAPI SmmCommunicationCommunicate ( IN CONST EFI_SMM_COMMUNICATION_PROTOCOL *This, IN OUT VOID *CommBuffer, IN OUT UINTN *CommSize ) { EFI_STATUS Status; EFI_SMM_COMMUNICATE_HEADER *CommunicateHeader; BOOLEAN OldInSmm; // // Check parameters // if ((CommBuffer == NULL) || (CommSize == NULL)) { return EFI_INVALID_PARAMETER; } // // CommSize must hold HeaderGuid and MessageLength // if (*CommSize < OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)) { return EFI_INVALID_PARAMETER; } // // If not already in SMM, then generate a Software SMI // if (!gSmmCorePrivate->InSmm && gSmmCorePrivate->SmmEntryPointRegistered) { // // Put arguments for Software SMI in gSmmCorePrivate // gSmmCorePrivate->CommunicationBuffer = CommBuffer; gSmmCorePrivate->BufferSize = *CommSize; // // Generate Software SMI // Status = mSmmControl2->Trigger (mSmmControl2, NULL, NULL, FALSE, 0); if (EFI_ERROR (Status)) { return EFI_UNSUPPORTED; } // // Return status from software SMI // *CommSize = gSmmCorePrivate->BufferSize; return gSmmCorePrivate->ReturnStatus; } // // If we are in SMM, then the execution mode must be physical, which means that // OS established virtual addresses can not be used. If SetVirtualAddressMap() // has been called, then a direct invocation of the Software SMI is not // not allowed so return EFI_INVALID_PARAMETER. // if (EfiGoneVirtual()) { return EFI_INVALID_PARAMETER; } // // If we are not in SMM, don't allow call SmiManage() directly when SMRAM is closed or locked. // if ((!gSmmCorePrivate->InSmm) && (!mSmmAccess->OpenState || mSmmAccess->LockState)) { return EFI_INVALID_PARAMETER; } // // Save current InSmm state and set InSmm state to TRUE // OldInSmm = gSmmCorePrivate->InSmm; gSmmCorePrivate->InSmm = TRUE; // // Already in SMM and before SetVirtualAddressMap(), so call SmiManage() directly. // CommunicateHeader = (EFI_SMM_COMMUNICATE_HEADER *)CommBuffer; *CommSize -= OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data); Status = gSmmCorePrivate->Smst->SmiManage ( &CommunicateHeader->HeaderGuid, NULL, CommunicateHeader->Data, CommSize ); // // Update CommunicationBuffer, BufferSize and ReturnStatus // Communicate service finished, reset the pointer to CommBuffer to NULL // *CommSize += OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data); // // Restore original InSmm state // gSmmCorePrivate->InSmm = OldInSmm; return (Status == EFI_WARN_INTERRUPT_SOURCE_QUIESCED) ? EFI_SUCCESS : EFI_NOT_FOUND; }