DmpStore.c

Go to the documentation of this file.

 
#include "UefiShellDebug1CommandsLib.h"
 
typedef enum {
  DmpStoreDisplay,
  DmpStoreDelete,
  DmpStoreSave,
  DmpStoreLoad
} DMP_STORE_TYPE;
 
typedef struct {
  UINT32        Signature;
  CHAR16        *Name;
  EFI_GUID      Guid;
  UINT32        Attributes;
  UINT32        DataSize;
  UINT8         *Data;
  LIST_ENTRY    Link;
} DMP_STORE_VARIABLE;
 
#define DMP_STORE_VARIABLE_SIGNATURE  SIGNATURE_32 ('_', 'd', 's', 's')
 
CHAR16 *
GetAttrType (
  IN CONST UINT32  Atts
  )
{
  UINTN   BufLen;
  CHAR16  *RetString;
 
  BufLen    = 0;
  RetString = NULL;
 
  if ((Atts & EFI_VARIABLE_NON_VOLATILE) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+NV", 0);
  }
 
  if ((Atts & EFI_VARIABLE_RUNTIME_ACCESS) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+RT+BS", 0);
  } else if ((Atts & EFI_VARIABLE_BOOTSERVICE_ACCESS) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+BS", 0);
  }
 
  if ((Atts & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+HR", 0);
  }
 
  if ((Atts & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+AW", 0);
  }
 
  if ((Atts & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {
    StrnCatGrow (&RetString, &BufLen, L"+AT", 0);
  }
 
  if (RetString == NULL) {
    RetString = StrnCatGrow (&RetString, &BufLen, L"Invalid", 0);
  }
 
  if ((RetString != NULL) && (RetString[0] == L'+')) {
    CopyMem (RetString, RetString + 1, StrSize (RetString + 1));
  }
 
  return RetString;
}
 
CHAR16 *
BinaryToHexString (
  IN     VOID    *Buffer,
  IN     UINTN   BufferSize,
  IN OUT CHAR16  *HexString,
  IN     UINTN   HexStringSize
  )
{
  UINTN  Index;
  UINTN  StringIndex;
 
  ASSERT (Buffer != NULL);
  ASSERT ((BufferSize * 2 + 1) * sizeof (CHAR16) <= HexStringSize);
 
  for (Index = 0, StringIndex = 0; Index < BufferSize; Index += 1) {
    StringIndex +=
      UnicodeSPrint (
        &HexString[StringIndex],
        HexStringSize - StringIndex * sizeof (CHAR16),
        L"%02x",
        ((UINT8 *)Buffer)[Index]
        );
  }
 
  return HexString;
}
 
SHELL_STATUS
LoadVariablesFromFile (
  IN SHELL_FILE_HANDLE  FileHandle,
  IN CONST CHAR16       *Name,
  IN CONST EFI_GUID     *Guid,
  OUT BOOLEAN           *Found
  )
{
  EFI_STATUS          Status;
  SHELL_STATUS        ShellStatus;
  UINT32              NameSize;
  UINT32              DataSize;
  UINTN               BufferSize;
  UINTN               RemainingSize;
  UINT64              Position;
  UINT64              FileSize;
  LIST_ENTRY          List;
  DMP_STORE_VARIABLE  *Variable;
  LIST_ENTRY          *Link;
  CHAR16              *Attributes;
  UINT8               *Buffer;
  UINT32              Crc32;
 
  Status = ShellGetFileSize (FileHandle, &FileSize);
  if (EFI_ERROR (Status)) {
    return SHELL_DEVICE_ERROR;
  }
 
  ShellStatus = SHELL_SUCCESS;
 
  InitializeListHead (&List);
 
  Position = 0;
  while (Position < FileSize) {
    //
    // NameSize
    //
    BufferSize = sizeof (NameSize);
    Status     = ShellReadFile (FileHandle, &BufferSize, &NameSize);
    if (EFI_ERROR (Status) || (BufferSize != sizeof (NameSize))) {
      ShellStatus = SHELL_VOLUME_CORRUPTED;
      break;
    }
 
    //
    // DataSize
    //
    BufferSize = sizeof (DataSize);
    Status     = ShellReadFile (FileHandle, &BufferSize, &DataSize);
    if (EFI_ERROR (Status) || (BufferSize != sizeof (DataSize))) {
      ShellStatus = SHELL_VOLUME_CORRUPTED;
      break;
    }
 
    //
    // Name, Guid, Attributes, Data, Crc32
    //
    RemainingSize = NameSize + sizeof (EFI_GUID) + sizeof (UINT32) + DataSize + sizeof (Crc32);
    BufferSize    = sizeof (NameSize) + sizeof (DataSize) + RemainingSize;
    Buffer        = AllocatePool (BufferSize);
    if (Buffer == NULL) {
      ShellStatus = SHELL_OUT_OF_RESOURCES;
      break;
    }
 
    BufferSize = RemainingSize;
    Status     = ShellReadFile (FileHandle, &BufferSize, (UINT32 *)Buffer + 2);
    if (EFI_ERROR (Status) || (BufferSize != RemainingSize)) {
      ShellStatus = SHELL_VOLUME_CORRUPTED;
      FreePool (Buffer);
      break;
    }
 
    //
    // Check Crc32
    //
    *(UINT32 *)Buffer       = NameSize;
    *((UINT32 *)Buffer + 1) = DataSize;
    BufferSize              = RemainingSize + sizeof (NameSize) + sizeof (DataSize) - sizeof (Crc32);
    gBS->CalculateCrc32 (
           Buffer,
           BufferSize,
           &Crc32
           );
    if (Crc32 != *(UINT32 *)(Buffer + BufferSize)) {
      FreePool (Buffer);
      ShellStatus = SHELL_VOLUME_CORRUPTED;
      break;
    }
 
    Position += BufferSize + sizeof (Crc32);
 
    Variable = AllocateZeroPool (sizeof (*Variable) + NameSize + DataSize);
    if (Variable == NULL) {
      FreePool (Buffer);
      ShellStatus = SHELL_OUT_OF_RESOURCES;
      break;
    }
 
    Variable->Signature = DMP_STORE_VARIABLE_SIGNATURE;
    Variable->Name      = (CHAR16 *)(Variable + 1);
    Variable->DataSize  = DataSize;
    Variable->Data      = (UINT8 *)Variable->Name + NameSize;
    CopyMem (Variable->Name, Buffer + sizeof (NameSize) + sizeof (DataSize), NameSize);
    CopyMem (&Variable->Guid, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize, sizeof (EFI_GUID));
    CopyMem (&Variable->Attributes, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID), sizeof (UINT32));
    CopyMem (Variable->Data, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID) + sizeof (UINT32), DataSize);
 
    InsertTailList (&List, &Variable->Link);
    FreePool (Buffer);
  }
 
  if ((Position != FileSize) || (ShellStatus != SHELL_SUCCESS)) {
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_BAD_FILE), gShellDebug1HiiHandle, L"dmpstore");
    if (Position != FileSize) {
      ShellStatus = SHELL_VOLUME_CORRUPTED;
    }
  }
 
  for ( Link = GetFirstNode (&List)
        ; !IsNull (&List, Link) && (ShellStatus == SHELL_SUCCESS)
        ; Link = GetNextNode (&List, Link)
        )
  {
    Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
 
    if (((Name == NULL) || gUnicodeCollation->MetaiMatch (gUnicodeCollation, Variable->Name, (CHAR16 *)Name)) &&
        ((Guid == NULL) || CompareGuid (&Variable->Guid, Guid))
        )
    {
      Attributes = GetAttrType (Variable->Attributes);
      ShellPrintHiiEx (
        -1,
        -1,
        NULL,
        STRING_TOKEN (STR_DMPSTORE_HEADER_LINE),
        gShellDebug1HiiHandle,
        Attributes,
        &Variable->Guid,
        Variable->Name,
        Variable->DataSize
        );
      SHELL_FREE_NON_NULL (Attributes);
 
      *Found = TRUE;
      Status = gRT->SetVariable (
                      Variable->Name,
                      &Variable->Guid,
                      Variable->Attributes,
                      Variable->DataSize,
                      Variable->Data
                      );
      if (EFI_ERROR (Status)) {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_GEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", Variable->Name, Status);
      }
    }
  }
 
  for (Link = GetFirstNode (&List); !IsNull (&List, Link); ) {
    Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
    Link     = RemoveEntryList (&Variable->Link);
    FreePool (Variable);
  }
 
  return ShellStatus;
}
 
EFI_STATUS
AppendSingleVariableToFile (
  IN SHELL_FILE_HANDLE  FileHandle,
  IN CONST CHAR16       *Name,
  IN CONST EFI_GUID     *Guid,
  IN UINT32             Attributes,
  IN UINT32             DataSize,
  IN CONST UINT8        *Data
  )
{
  UINT32      NameSize;
  UINT8       *Buffer;
  UINT8       *Ptr;
  UINTN       BufferSize;
  EFI_STATUS  Status;
 
  NameSize   = (UINT32)StrSize (Name);
  BufferSize = sizeof (NameSize) + sizeof (DataSize)
               + sizeof (*Guid)
               + sizeof (Attributes)
               + NameSize + DataSize
               + sizeof (UINT32);
 
  Buffer = AllocatePool (BufferSize);
  if (Buffer == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Ptr = Buffer;
  //
  // NameSize and DataSize
  //
  *(UINT32 *)Ptr = NameSize;
  Ptr           += sizeof (NameSize);
  *(UINT32 *)Ptr = DataSize;
  Ptr           += sizeof (DataSize);
 
  //
  // Name
  //
  CopyMem (Ptr, Name, NameSize);
  Ptr += NameSize;
 
  //
  // Guid
  //
  CopyMem (Ptr, Guid, sizeof (*Guid));
  Ptr += sizeof (*Guid);
 
  //
  // Attributes
  //
  *(UINT32 *)Ptr = Attributes;
  Ptr           += sizeof (Attributes);
 
  //
  // Data
  //
  CopyMem (Ptr, Data, DataSize);
  Ptr += DataSize;
 
  //
  // Crc32
  //
  gBS->CalculateCrc32 (Buffer, (UINTN)Ptr - (UINTN)Buffer, (UINT32 *)Ptr);
 
  Status = ShellWriteFile (FileHandle, &BufferSize, Buffer);
  FreePool (Buffer);
 
  if (!EFI_ERROR (Status) &&
      (BufferSize != sizeof (NameSize) + sizeof (DataSize) + sizeof (*Guid) + sizeof (Attributes) + NameSize + DataSize + sizeof (UINT32))
      )
  {
    Status = EFI_DEVICE_ERROR;
  }
 
  return Status;
}
 
SHELL_STATUS
CascadeProcessVariables (
  IN CONST CHAR16              *Name        OPTIONAL,
  IN CONST EFI_GUID            *Guid        OPTIONAL,
  IN DMP_STORE_TYPE            Type,
  IN EFI_FILE_PROTOCOL         *FileHandle  OPTIONAL,
  IN CONST CHAR16      *CONST  PrevName,
  IN EFI_GUID                  FoundVarGuid,
  IN BOOLEAN                   *FoundOne,
  IN BOOLEAN                   StandardFormatOutput
  )
{
  EFI_STATUS    Status;
  CHAR16        *FoundVarName;
  UINT8         *DataBuffer;
  UINTN         DataSize;
  UINT32        Atts;
  SHELL_STATUS  ShellStatus;
  UINTN         NameSize;
  CHAR16        *AttrString;
  CHAR16        *HexString;
  EFI_STATUS    SetStatus;
  CONST CHAR16  *GuidName;
 
  if (ShellGetExecutionBreakFlag ()) {
    return (SHELL_ABORTED);
  }
 
  NameSize     = 0;
  FoundVarName = NULL;
 
  if (PrevName != NULL) {
    StrnCatGrow (&FoundVarName, &NameSize, PrevName, 0);
  } else {
    FoundVarName = AllocateZeroPool (sizeof (CHAR16));
    if (FoundVarName == NULL) {
      return (SHELL_OUT_OF_RESOURCES);
    }
 
    NameSize = sizeof (CHAR16);
  }
 
  Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
  if (Status == EFI_BUFFER_TOO_SMALL) {
    SHELL_FREE_NON_NULL (FoundVarName);
    FoundVarName = AllocateZeroPool (NameSize);
    if (FoundVarName != NULL) {
      if (PrevName != NULL) {
        StrnCpyS (FoundVarName, NameSize/sizeof (CHAR16), PrevName, NameSize/sizeof (CHAR16) - 1);
      }
 
      Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
    } else {
      Status = EFI_OUT_OF_RESOURCES;
    }
  }
 
  //
  // No more is fine.
  //
  if (Status == EFI_NOT_FOUND) {
    SHELL_FREE_NON_NULL (FoundVarName);
    return (SHELL_SUCCESS);
  } else if (EFI_ERROR (Status)) {
    SHELL_FREE_NON_NULL (FoundVarName);
    return (SHELL_DEVICE_ERROR);
  }
 
  //
  // Recurse to the next iteration.  We know "our" variable's name.
  //
  ShellStatus = CascadeProcessVariables (Name, Guid, Type, FileHandle, FoundVarName, FoundVarGuid, FoundOne, StandardFormatOutput);
 
  if (ShellGetExecutionBreakFlag () || (ShellStatus == SHELL_ABORTED)) {
    SHELL_FREE_NON_NULL (FoundVarName);
    return (SHELL_ABORTED);
  }
 
  //
  // No matter what happened we process our own variable
  // Only continue if Guid and VariableName are each either NULL or a match
  //
  if (  (  (Name == NULL)
        || gUnicodeCollation->MetaiMatch (gUnicodeCollation, FoundVarName, (CHAR16 *)Name))
     && (  (Guid == NULL)
        || CompareGuid (&FoundVarGuid, Guid))
        )
  {
    DataSize   = 0;
    DataBuffer = NULL;
    //
    // do the print or delete
    //
    *FoundOne = TRUE;
    Status    = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
    if (Status == EFI_BUFFER_TOO_SMALL) {
      SHELL_FREE_NON_NULL (DataBuffer);
      DataBuffer = AllocatePool (DataSize);
      if (DataBuffer == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
      } else {
        Status = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
      }
    }
 
    //
    // Last error check then print this variable out.
    //
    if (Type == DmpStoreDisplay) {
      if (!EFI_ERROR (Status) && (DataBuffer != NULL) && (FoundVarName != NULL)) {
        AttrString = GetAttrType (Atts);
        if (StandardFormatOutput) {
          HexString = AllocatePool ((DataSize * 2 + 1) * sizeof (CHAR16));
          if (HexString != NULL) {
            ShellPrintHiiEx (
              -1,
              -1,
              NULL,
              STRING_TOKEN (STR_DMPSTORE_VAR_SFO),
              gShellDebug1HiiHandle,
              FoundVarName,
              &FoundVarGuid,
              Atts,
              DataSize,
              BinaryToHexString (
                DataBuffer,
                DataSize,
                HexString,
                (DataSize * 2 + 1) * sizeof (CHAR16)
                )
              );
            FreePool (HexString);
          } else {
            Status = EFI_OUT_OF_RESOURCES;
          }
        } else {
          Status = gEfiShellProtocol->GetGuidName (&FoundVarGuid, &GuidName);
          if (EFI_ERROR (Status)) {
            ShellPrintHiiEx (
              -1,
              -1,
              NULL,
              STRING_TOKEN (STR_DMPSTORE_HEADER_LINE),
              gShellDebug1HiiHandle,
              AttrString,
              &FoundVarGuid,
              FoundVarName,
              DataSize
              );
          } else {
            ShellPrintHiiEx (
              -1,
              -1,
              NULL,
              STRING_TOKEN (STR_DMPSTORE_HEADER_LINE2),
              gShellDebug1HiiHandle,
              AttrString,
              GuidName,
              FoundVarName,
              DataSize
              );
          }
 
          DumpHex (2, 0, DataSize, DataBuffer);
        }
 
        SHELL_FREE_NON_NULL (AttrString);
      }
    } else if (Type == DmpStoreSave) {
      if (!EFI_ERROR (Status) && (DataBuffer != NULL) && (FoundVarName != NULL)) {
        AttrString = GetAttrType (Atts);
        ShellPrintHiiEx (
          -1,
          -1,
          NULL,
          STRING_TOKEN (STR_DMPSTORE_HEADER_LINE),
          gShellDebug1HiiHandle,
          AttrString,
          &FoundVarGuid,
          FoundVarName,
          DataSize
          );
        Status = AppendSingleVariableToFile (
                   FileHandle,
                   FoundVarName,
                   &FoundVarGuid,
                   Atts,
                   (UINT32)DataSize,
                   DataBuffer
                   );
        SHELL_FREE_NON_NULL (AttrString);
      }
    } else if (Type == DmpStoreDelete) {
      //
      // We only need name to delete it...
      //
      SetStatus = gRT->SetVariable (FoundVarName, &FoundVarGuid, Atts, 0, NULL);
      if (StandardFormatOutput) {
        if (SetStatus == EFI_SUCCESS) {
          ShellPrintHiiEx (
            -1,
            -1,
            NULL,
            STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_NG_SFO),
            gShellDebug1HiiHandle,
            FoundVarName,
            &FoundVarGuid
            );
        }
      } else {
        ShellPrintHiiEx (
          -1,
          -1,
          NULL,
          STRING_TOKEN (STR_DMPSTORE_DELETE_LINE),
          gShellDebug1HiiHandle,
          &FoundVarGuid,
          FoundVarName,
          SetStatus
          );
      }
    }
 
    SHELL_FREE_NON_NULL (DataBuffer);
  }
 
  SHELL_FREE_NON_NULL (FoundVarName);
 
  if (Status == EFI_DEVICE_ERROR) {
    ShellStatus = SHELL_DEVICE_ERROR;
  } else if (Status == EFI_SECURITY_VIOLATION) {
    ShellStatus = SHELL_SECURITY_VIOLATION;
  } else if (EFI_ERROR (Status)) {
    ShellStatus = SHELL_NOT_READY;
  }
 
  return (ShellStatus);
}
 
SHELL_STATUS
ProcessVariables (
  IN CONST CHAR16       *Name      OPTIONAL,
  IN CONST EFI_GUID     *Guid      OPTIONAL,
  IN DMP_STORE_TYPE     Type,
  IN SHELL_FILE_HANDLE  FileHandle OPTIONAL,
  IN BOOLEAN            StandardFormatOutput
  )
{
  SHELL_STATUS  ShellStatus;
  BOOLEAN       Found;
  EFI_GUID      FoundVarGuid;
 
  Found       = FALSE;
  ShellStatus = SHELL_SUCCESS;
  ZeroMem (&FoundVarGuid, sizeof (EFI_GUID));
 
  if (StandardFormatOutput) {
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellDebug1HiiHandle, L"dmpstore");
  }
 
  if (Type == DmpStoreLoad) {
    ShellStatus = LoadVariablesFromFile (FileHandle, Name, Guid, &Found);
  } else {
    ShellStatus = CascadeProcessVariables (Name, Guid, Type, FileHandle, NULL, FoundVarGuid, &Found, StandardFormatOutput);
  }
 
  if (!Found) {
    if (ShellStatus == SHELL_OUT_OF_RESOURCES) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle, L"dmpstore");
      return (ShellStatus);
    } else if ((Name != NULL) && (Guid == NULL)) {
      if (StandardFormatOutput) {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N_SFO), gShellDebug1HiiHandle, Name);
      } else {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N), gShellDebug1HiiHandle, L"dmpstore", Name);
      }
    } else if ((Name != NULL) && (Guid != NULL)) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_GN), gShellDebug1HiiHandle, L"dmpstore", Guid, Name);
    } else if ((Name == NULL) && (Guid == NULL)) {
      if (StandardFormatOutput) {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_SFO), gShellDebug1HiiHandle);
      } else {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND), gShellDebug1HiiHandle, L"dmpstore");
      }
    } else if ((Name == NULL) && (Guid != NULL)) {
      if (StandardFormatOutput) {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_G_SFO), gShellDebug1HiiHandle, Guid);
      } else {
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_G), gShellDebug1HiiHandle, L"dmpstore", Guid);
      }
    }
 
    return (SHELL_NOT_FOUND);
  }
 
  return (ShellStatus);
}
 
STATIC CONST SHELL_PARAM_ITEM  ParamList[] = {
  { L"-d",    TypeFlag  },
  { L"-l",    TypeValue },
  { L"-s",    TypeValue },
  { L"-all",  TypeFlag  },
  { L"-guid", TypeValue },
  { L"-sfo",  TypeFlag  },
  { NULL,     TypeMax   }
};
 
SHELL_STATUS
EFIAPI
ShellCommandRunDmpStore (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS         Status;
  RETURN_STATUS      RStatus;
  LIST_ENTRY         *Package;
  CHAR16             *ProblemParam;
  SHELL_STATUS       ShellStatus;
  CONST CHAR16       *GuidStr;
  CONST CHAR16       *File;
  EFI_GUID           *Guid;
  EFI_GUID           GuidData;
  CONST CHAR16       *Name;
  DMP_STORE_TYPE     Type;
  SHELL_FILE_HANDLE  FileHandle;
  EFI_FILE_INFO      *FileInfo;
  BOOLEAN            StandardFormatOutput;
 
  ShellStatus          = SHELL_SUCCESS;
  Package              = NULL;
  FileHandle           = NULL;
  File                 = NULL;
  Type                 = DmpStoreDisplay;
  StandardFormatOutput = FALSE;
 
  Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
  if (EFI_ERROR (Status)) {
    if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, L"dmpstore", ProblemParam);
      FreePool (ProblemParam);
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      ASSERT (FALSE);
    }
  } else {
    if (ShellCommandLineGetCount (Package) > 2) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDebug1HiiHandle, L"dmpstore");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else if (ShellCommandLineGetFlag (Package, L"-all") && ShellCommandLineGetFlag (Package, L"-guid")) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-all", L"-guid");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else if (ShellCommandLineGetFlag (Package, L"-s") && ShellCommandLineGetFlag (Package, L"-l")) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l", L"-s");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else if ((ShellCommandLineGetFlag (Package, L"-s") || ShellCommandLineGetFlag (Package, L"-l")) && ShellCommandLineGetFlag (Package, L"-d")) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l or -s", L"-d");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else if ((ShellCommandLineGetFlag (Package, L"-s") || ShellCommandLineGetFlag (Package, L"-l")) && ShellCommandLineGetFlag (Package, L"-sfo")) {
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"dmpstore", L"-l or -s", L"-sfo");
      ShellStatus = SHELL_INVALID_PARAMETER;
    } else {
      //
      // Determine the GUID to search for based on -all and -guid parameters
      //
      if (!ShellCommandLineGetFlag (Package, L"-all")) {
        GuidStr = ShellCommandLineGetValue (Package, L"-guid");
        if (GuidStr != NULL) {
          RStatus = StrToGuid (GuidStr, &GuidData);
          if (RETURN_ERROR (RStatus) || (GuidStr[GUID_STRING_LENGTH] != L'\0')) {
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellDebug1HiiHandle, L"dmpstore", GuidStr);
            ShellStatus = SHELL_INVALID_PARAMETER;
          }
 
          Guid = &GuidData;
        } else {
          Guid = &gEfiGlobalVariableGuid;
        }
      } else {
        Guid = NULL;
      }
 
      //
      // Get the Name of the variable to find
      //
      Name = ShellCommandLineGetRawValue (Package, 1);
 
      if (ShellStatus == SHELL_SUCCESS) {
        if (ShellCommandLineGetFlag (Package, L"-s")) {
          Type = DmpStoreSave;
          File = ShellCommandLineGetValue (Package, L"-s");
          if (File == NULL) {
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"dmpstore", L"-s");
            ShellStatus = SHELL_INVALID_PARAMETER;
          } else {
            Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
            if (!EFI_ERROR (Status)) {
              //
              // Delete existing file, but do not delete existing directory
              //
              FileInfo = ShellGetFileInfo (FileHandle);
              if (FileInfo == NULL) {
                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
                Status = EFI_DEVICE_ERROR;
              } else {
                if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
                  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, L"dmpstore", File);
                  Status = EFI_INVALID_PARAMETER;
                } else {
                  Status = ShellDeleteFile (&FileHandle);
                  if (EFI_ERROR (Status)) {
                    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_DELETE_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
                  }
                }
 
                FreePool (FileInfo);
              }
            } else if (Status == EFI_NOT_FOUND) {
              //
              // Good when file doesn't exist
              //
              Status = EFI_SUCCESS;
            } else {
              //
              // Otherwise it's bad.
              //
              ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
            }
 
            if (!EFI_ERROR (Status)) {
              Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
              if (EFI_ERROR (Status)) {
                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
              }
            }
 
            if (EFI_ERROR (Status)) {
              ShellStatus = SHELL_INVALID_PARAMETER;
            }
          }
        } else if (ShellCommandLineGetFlag (Package, L"-l")) {
          Type = DmpStoreLoad;
          File = ShellCommandLineGetValue (Package, L"-l");
          if (File == NULL) {
            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"dmpstore", L"-l");
            ShellStatus = SHELL_INVALID_PARAMETER;
          } else {
            Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_READ, 0);
            if (EFI_ERROR (Status)) {
              ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
              ShellStatus = SHELL_INVALID_PARAMETER;
            } else {
              FileInfo = ShellGetFileInfo (FileHandle);
              if (FileInfo == NULL) {
                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, L"dmpstore", File);
                ShellStatus = SHELL_DEVICE_ERROR;
              } else {
                if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
                  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, L"dmpstore", File);
                  ShellStatus = SHELL_INVALID_PARAMETER;
                }
 
                FreePool (FileInfo);
              }
            }
          }
        } else if (ShellCommandLineGetFlag (Package, L"-d")) {
          Type = DmpStoreDelete;
        }
 
        if (ShellCommandLineGetFlag (Package, L"-sfo")) {
          StandardFormatOutput = TRUE;
        }
      }
 
      if (ShellStatus == SHELL_SUCCESS) {
        if (Type == DmpStoreSave) {
          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_SAVE), gShellDebug1HiiHandle, File);
        } else if (Type == DmpStoreLoad) {
          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD), gShellDebug1HiiHandle, File);
        }
 
        ShellStatus = ProcessVariables (Name, Guid, Type, FileHandle, StandardFormatOutput);
        if ((Type == DmpStoreLoad) || (Type == DmpStoreSave)) {
          ShellCloseFile (&FileHandle);
        }
      }
    }
  }
 
  if (Package != NULL) {
    ShellCommandLineFreeVarList (Package);
  }
 
  return ShellStatus;
}