VariableSupport.c

Go to the documentation of this file.

 
#include "FmpDxe.h"
#include "VariableSupport.h"
 
static
VOID
GetFmpVariable (
  IN  CHAR16   *VariableName,
  OUT BOOLEAN  *Valid,
  OUT UINT32   *Value
  )
{
  EFI_STATUS  Status;
  UINTN       Size;
  UINT32      *Buffer;
 
  *Valid = FALSE;
  *Value = 0;
  Size   = 0;
  Buffer = NULL;
  Status = GetVariable2 (
             VariableName,
             &gEfiCallerIdGuid,
             (VOID **)&Buffer,
             &Size
             );
  if (!EFI_ERROR (Status) && (Size == sizeof (*Value)) && (Buffer != NULL)) {
    *Valid = TRUE;
    *Value = *Buffer;
  }
 
  if (Buffer != NULL) {
    FreePool (Buffer);
  }
}
 
static
VOID
DeleteFmpVariable (
  IN CHAR16  *VariableName
  )
{
  EFI_STATUS  Status;
  BOOLEAN     Valid;
  UINT32      Value;
 
  GetFmpVariable (VariableName, &Valid, &Value);
  if (Valid) {
    Status = gRT->SetVariable (VariableName, &gEfiCallerIdGuid, 0, 0, NULL);
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to delete variable %s.  Status = %r\n", mImageIdName, VariableName, Status));
    } else {
      DEBUG ((DEBUG_INFO, "FmpDxe(%s): Deleted variable %s\n", mImageIdName, VariableName));
    }
  }
}
 
static
FMP_CONTROLLER_STATE *
GetFmpControllerState (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS            Status;
  FMP_CONTROLLER_STATE  *FmpControllerState;
  UINTN                 Size;
 
  FmpControllerState = NULL;
  Size               = 0;
  Status             = GetVariable2 (
                         Private->FmpStateVariableName,
                         &gEfiCallerIdGuid,
                         (VOID **)&FmpControllerState,
                         &Size
                         );
  if (EFI_ERROR (Status) || (FmpControllerState == NULL)) {
    DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to get the controller state.  Status = %r\n", mImageIdName, Status));
  } else {
    if (Size == sizeof (*FmpControllerState)) {
      return FmpControllerState;
    }
 
    DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Getting controller state returned a size different than expected. Size = 0x%x\n", mImageIdName, Size));
  }
 
  if (FmpControllerState != NULL) {
    FreePool (FmpControllerState);
  }
 
  return NULL;
}
 
static
CHAR16 *
GenerateFmpVariableName (
  IN  UINT64  HardwareInstance,
  IN  CHAR16  *BaseVariableName
  )
{
  UINTN   Size;
  CHAR16  *VariableName;
 
  //
  // Allocate Unicode string with room for BaseVariableName and a 16 digit
  // hexadecimal value for the HardwareInstance value.
  //
  Size         = StrSize (BaseVariableName) + 16 * sizeof (CHAR16);
  VariableName = AllocateCopyPool (Size, BaseVariableName);
  if (VariableName == NULL) {
    DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to generate variable name %s.\n", mImageIdName, BaseVariableName));
    return VariableName;
  }
 
  if (HardwareInstance == 0) {
    return VariableName;
  }
 
  UnicodeValueToStringS (
    &VariableName[StrLen (BaseVariableName)],
    Size,
    PREFIX_ZERO | RADIX_HEX,
    HardwareInstance,
    16
    );
  return VariableName;
}
 
VOID
GenerateFmpVariableNames (
  IN OUT FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS            Status;
  VOID                  *Buffer;
  FMP_CONTROLLER_STATE  FmpControllerState;
 
  if (Private->VersionVariableName != NULL) {
    FreePool (Private->VersionVariableName);
  }
 
  if (Private->LsvVariableName != NULL) {
    FreePool (Private->LsvVariableName);
  }
 
  if (Private->LastAttemptStatusVariableName != NULL) {
    FreePool (Private->LastAttemptStatusVariableName);
  }
 
  if (Private->LastAttemptVersionVariableName != NULL) {
    FreePool (Private->LastAttemptVersionVariableName);
  }
 
  if (Private->FmpStateVariableName != NULL) {
    FreePool (Private->FmpStateVariableName);
  }
 
  Private->VersionVariableName = GenerateFmpVariableName (
                                   Private->Descriptor.HardwareInstance,
                                   VARNAME_VERSION
                                   );
  Private->LsvVariableName = GenerateFmpVariableName (
                               Private->Descriptor.HardwareInstance,
                               VARNAME_LSV
                               );
  Private->LastAttemptStatusVariableName = GenerateFmpVariableName (
                                             Private->Descriptor.HardwareInstance,
                                             VARNAME_LASTATTEMPTSTATUS
                                             );
  Private->LastAttemptVersionVariableName = GenerateFmpVariableName (
                                              Private->Descriptor.HardwareInstance,
                                              VARNAME_LASTATTEMPTVERSION
                                              );
  Private->FmpStateVariableName = GenerateFmpVariableName (
                                    Private->Descriptor.HardwareInstance,
                                    VARNAME_FMPSTATE
                                    );
 
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Variable %g %s\n", mImageIdName, &gEfiCallerIdGuid, Private->VersionVariableName));
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Variable %g %s\n", mImageIdName, &gEfiCallerIdGuid, Private->LsvVariableName));
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Variable %g %s\n", mImageIdName, &gEfiCallerIdGuid, Private->LastAttemptStatusVariableName));
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Variable %g %s\n", mImageIdName, &gEfiCallerIdGuid, Private->LastAttemptVersionVariableName));
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Variable %g %s\n", mImageIdName, &gEfiCallerIdGuid, Private->FmpStateVariableName));
 
  Buffer = GetFmpControllerState (Private);
  if (Buffer != NULL) {
    //
    // FMP Controller State was found with correct size.
    // Delete old variables if they exist.
    //
    FreePool (Buffer);
    DeleteFmpVariable (Private->VersionVariableName);
    DeleteFmpVariable (Private->LsvVariableName);
    DeleteFmpVariable (Private->LastAttemptStatusVariableName);
    DeleteFmpVariable (Private->LastAttemptVersionVariableName);
    return;
  }
 
  //
  // FMP Controller State was either not found or is wrong size.
  // Create a new FMP Controller State variable with the correct size.
  //
  DEBUG ((DEBUG_INFO, "FmpDxe(%s): Create controller state\n", mImageIdName));
  GetFmpVariable (
    Private->VersionVariableName,
    &FmpControllerState.VersionValid,
    &FmpControllerState.Version
    );
  GetFmpVariable (
    Private->LsvVariableName,
    &FmpControllerState.LsvValid,
    &FmpControllerState.Lsv
    );
  GetFmpVariable (
    Private->LastAttemptStatusVariableName,
    &FmpControllerState.LastAttemptStatusValid,
    &FmpControllerState.LastAttemptStatus
    );
  GetFmpVariable (
    Private->LastAttemptVersionVariableName,
    &FmpControllerState.LastAttemptVersionValid,
    &FmpControllerState.LastAttemptVersion
    );
  Status = gRT->SetVariable (
                  Private->FmpStateVariableName,
                  &gEfiCallerIdGuid,
                  EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                  sizeof (FmpControllerState),
                  &FmpControllerState
                  );
  if (EFI_ERROR (Status)) {
    //
    // Failed to create FMP Controller State.  In this case, do not
    // delete the individual variables.  They can be used again on next boot
    // to create the FMP Controller State.
    //
    DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to create controller state.  Status = %r\n", mImageIdName, Status));
  } else {
    DeleteFmpVariable (Private->VersionVariableName);
    DeleteFmpVariable (Private->LsvVariableName);
    DeleteFmpVariable (Private->LastAttemptStatusVariableName);
    DeleteFmpVariable (Private->LastAttemptVersionVariableName);
  }
}
 
UINT32
GetVersionFromVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  FMP_CONTROLLER_STATE  *FmpControllerState;
  UINT32                Value;
 
  Value              = DEFAULT_VERSION;
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState != NULL) {
    if (FmpControllerState->VersionValid) {
      Value = FmpControllerState->Version;
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Get variable %g %s Version %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        Value
        ));
    }
 
    FreePool (FmpControllerState);
  }
 
  return Value;
}
 
UINT32
GetLowestSupportedVersionFromVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  FMP_CONTROLLER_STATE  *FmpControllerState;
  UINT32                Value;
 
  Value              = DEFAULT_LOWESTSUPPORTEDVERSION;
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState != NULL) {
    if (FmpControllerState->LsvValid) {
      Value = FmpControllerState->Lsv;
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Get variable %g %s LowestSupportedVersion %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        Value
        ));
    }
 
    FreePool (FmpControllerState);
  }
 
  return Value;
}
 
UINT32
GetLastAttemptStatusFromVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  FMP_CONTROLLER_STATE  *FmpControllerState;
  UINT32                Value;
 
  Value              = DEFAULT_LASTATTEMPTSTATUS;
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState != NULL) {
    if (FmpControllerState->LastAttemptStatusValid) {
      Value = FmpControllerState->LastAttemptStatus;
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Get variable %g %s LastAttemptStatus %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        Value
        ));
    }
 
    FreePool (FmpControllerState);
  }
 
  return Value;
}
 
UINT32
GetLastAttemptVersionFromVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  FMP_CONTROLLER_STATE  *FmpControllerState;
  UINT32                Value;
 
  Value              = DEFAULT_LASTATTEMPTVERSION;
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState != NULL) {
    if (FmpControllerState->LastAttemptVersionValid) {
      Value = FmpControllerState->LastAttemptVersion;
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Get variable %g %s LastAttemptVersion %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        Value
        ));
    }
 
    FreePool (FmpControllerState);
  }
 
  return Value;
}
 
VOID
SetVersionInVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private,
  IN UINT32                            Version
  )
{
  EFI_STATUS            Status;
  FMP_CONTROLLER_STATE  *FmpControllerState;
  BOOLEAN               Update;
 
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState == NULL) {
    //
    // Can not update value if FMP Controller State does not exist.
    // This variable is guaranteed to be created by GenerateFmpVariableNames().
    //
    return;
  }
 
  Update = FALSE;
  if (!FmpControllerState->VersionValid) {
    Update = TRUE;
  }
 
  if (FmpControllerState->Version != Version) {
    Update = TRUE;
  }
 
  if (!Update) {
    DEBUG ((DEBUG_INFO, "FmpDxe(%s): No need to update controller state.  Same value as before.\n", mImageIdName));
  } else {
    FmpControllerState->VersionValid = TRUE;
    FmpControllerState->Version      = Version;
    Status                           = gRT->SetVariable (
                                              Private->FmpStateVariableName,
                                              &gEfiCallerIdGuid,
                                              EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                                              sizeof (*FmpControllerState),
                                              FmpControllerState
                                              );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to update controller state.  Status = %r\n", mImageIdName, Status));
    } else {
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Set variable %g %s Version %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        Version
        ));
    }
  }
 
  FreePool (FmpControllerState);
}
 
VOID
SetLowestSupportedVersionInVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private,
  IN UINT32                            LowestSupportedVersion
  )
{
  EFI_STATUS            Status;
  FMP_CONTROLLER_STATE  *FmpControllerState;
  BOOLEAN               Update;
 
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState == NULL) {
    //
    // Can not update value if FMP Controller State does not exist.
    // This variable is guaranteed to be created by GenerateFmpVariableNames().
    //
    return;
  }
 
  Update = FALSE;
  if (!FmpControllerState->LsvValid) {
    Update = TRUE;
  }
 
  if (FmpControllerState->Lsv < LowestSupportedVersion) {
    Update = TRUE;
  }
 
  if (!Update) {
    DEBUG ((DEBUG_INFO, "FmpDxe(%s): No need to update controller state.  Same value as before.\n", mImageIdName));
  } else {
    FmpControllerState->LsvValid = TRUE;
    FmpControllerState->Lsv      = LowestSupportedVersion;
    Status                       = gRT->SetVariable (
                                          Private->FmpStateVariableName,
                                          &gEfiCallerIdGuid,
                                          EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                                          sizeof (*FmpControllerState),
                                          FmpControllerState
                                          );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to update controller state.  Status = %r\n", mImageIdName, Status));
    } else {
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Set variable %g %s LowestSupportedVersion %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        LowestSupportedVersion
        ));
    }
  }
 
  FreePool (FmpControllerState);
}
 
VOID
SetLastAttemptStatusInVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private,
  IN UINT32                            LastAttemptStatus
  )
{
  EFI_STATUS            Status;
  FMP_CONTROLLER_STATE  *FmpControllerState;
  BOOLEAN               Update;
 
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState == NULL) {
    //
    // Can not update value if FMP Controller State does not exist.
    // This variable is guaranteed to be created by GenerateFmpVariableNames().
    //
    return;
  }
 
  Update = FALSE;
  if (!FmpControllerState->LastAttemptStatusValid) {
    Update = TRUE;
  }
 
  if (FmpControllerState->LastAttemptStatus != LastAttemptStatus) {
    Update = TRUE;
  }
 
  if (!Update) {
    DEBUG ((DEBUG_INFO, "FmpDxe(%s): No need to update controller state.  Same value as before.\n", mImageIdName));
  } else {
    FmpControllerState->LastAttemptStatusValid = TRUE;
    FmpControllerState->LastAttemptStatus      = LastAttemptStatus;
    Status                                     = gRT->SetVariable (
                                                        Private->FmpStateVariableName,
                                                        &gEfiCallerIdGuid,
                                                        EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                                                        sizeof (*FmpControllerState),
                                                        FmpControllerState
                                                        );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to update controller state.  Status = %r\n", mImageIdName, Status));
    } else {
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Set variable %g %s LastAttemptStatus %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        LastAttemptStatus
        ));
    }
  }
 
  FreePool (FmpControllerState);
}
 
VOID
SetLastAttemptVersionInVariable (
  IN FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private,
  IN UINT32                            LastAttemptVersion
  )
{
  EFI_STATUS            Status;
  FMP_CONTROLLER_STATE  *FmpControllerState;
  BOOLEAN               Update;
 
  FmpControllerState = GetFmpControllerState (Private);
  if (FmpControllerState == NULL) {
    //
    // Can not update value if FMP Controller State does not exist.
    // This variable is guaranteed to be created by GenerateFmpVariableNames().
    //
    return;
  }
 
  Update = FALSE;
  if (!FmpControllerState->LastAttemptVersionValid) {
    Update = TRUE;
  }
 
  if (FmpControllerState->LastAttemptVersion != LastAttemptVersion) {
    Update = TRUE;
  }
 
  if (!Update) {
    DEBUG ((DEBUG_INFO, "FmpDxe(%s): No need to update controller state.  Same value as before.\n", mImageIdName));
  } else {
    FmpControllerState->LastAttemptVersionValid = TRUE;
    FmpControllerState->LastAttemptVersion      = LastAttemptVersion;
    Status                                      = gRT->SetVariable (
                                                         Private->FmpStateVariableName,
                                                         &gEfiCallerIdGuid,
                                                         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
                                                         sizeof (*FmpControllerState),
                                                         FmpControllerState
                                                         );
    if (EFI_ERROR (Status)) {
      DEBUG ((DEBUG_ERROR, "FmpDxe(%s): Failed to update controller state.  Status = %r\n", mImageIdName, Status));
    } else {
      DEBUG ((
        DEBUG_INFO,
        "FmpDxe(%s): Set variable %g %s LastAttemptVersion %08x\n",
        mImageIdName,
        &gEfiCallerIdGuid,
        Private->FmpStateVariableName,
        LastAttemptVersion
        ));
    }
  }
 
  FreePool (FmpControllerState);
}
 
static
EFI_STATUS
LockFmpVariable (
  IN EFI_STATUS                      PreviousStatus,
  IN EDKII_VARIABLE_POLICY_PROTOCOL  *VariablePolicy,
  IN CHAR16                          *VariableName
  )
{
  EFI_STATUS  Status;
 
  // If success, go ahead and set the policies to protect the target variables.
  Status = RegisterBasicVariablePolicy (
             VariablePolicy,
             &gEfiCallerIdGuid,
             VariableName,
             VARIABLE_POLICY_NO_MIN_SIZE,
             VARIABLE_POLICY_NO_MAX_SIZE,
             VARIABLE_POLICY_NO_MUST_ATTR,
             VARIABLE_POLICY_NO_CANT_ATTR,
             VARIABLE_POLICY_TYPE_LOCK_NOW
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((
      DEBUG_ERROR,
      "FmpDxe(%s): Failed to lock variable %g %s. Status = %r\n",
      mImageIdName,
      &gEfiCallerIdGuid,
      VariableName,
      Status
      ));
  }
 
  if (EFI_ERROR (PreviousStatus)) {
    return PreviousStatus;
  }
 
  return Status;
}
 
EFI_STATUS
LockAllFmpVariables (
  FIRMWARE_MANAGEMENT_PRIVATE_DATA  *Private
  )
{
  EFI_STATUS                      Status;
  EDKII_VARIABLE_POLICY_PROTOCOL  *VariablePolicy;
 
  // Locate the VariablePolicy protocol.
  Status = gBS->LocateProtocol (&gEdkiiVariablePolicyProtocolGuid, NULL, (VOID **)&VariablePolicy);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "FmpDxe %a - Could not locate VariablePolicy protocol! %r\n", __func__, Status));
    return Status;
  }
 
  Status = EFI_SUCCESS;
  Status = LockFmpVariable (Status, VariablePolicy, Private->VersionVariableName);
  Status = LockFmpVariable (Status, VariablePolicy, Private->LsvVariableName);
  Status = LockFmpVariable (Status, VariablePolicy, Private->LastAttemptStatusVariableName);
  Status = LockFmpVariable (Status, VariablePolicy, Private->LastAttemptVersionVariableName);
  Status = LockFmpVariable (Status, VariablePolicy, Private->FmpStateVariableName);
 
  return Status;
}