You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
496 lines
10 KiB
496 lines
10 KiB
/*++
|
|
|
|
Module Name:
|
|
|
|
savrstor.c
|
|
|
|
Abstract:
|
|
|
|
Save/Restore boot options to/from disk
|
|
|
|
Author:
|
|
|
|
Raj Kuramkote (v-rajk) 07-12-00
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include <precomp.h>
|
|
|
|
//
|
|
// externs
|
|
//
|
|
VOID
|
|
UtoA(
|
|
OUT CHAR8* c,
|
|
IN CHAR16* u
|
|
);
|
|
|
|
|
|
#define EFINVRAM_DEBUG 0
|
|
|
|
//
|
|
// Writes boot options data to file
|
|
//
|
|
EFI_STATUS
|
|
PopulateNvrFile (
|
|
EFI_FILE_HANDLE NvrFile,
|
|
CHAR8* bootoptions,
|
|
UINT32 buffersize
|
|
)
|
|
{
|
|
UINTN size;
|
|
|
|
size= buffersize;
|
|
|
|
NvrFile->Write (NvrFile,&size,bootoptions);
|
|
|
|
NvrFile->Close(NvrFile);
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
|
|
|
INTN
|
|
ParseNvrFile (
|
|
EFI_FILE_HANDLE NvrFile
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
CHAR8 *buffer;
|
|
UINTN i,j,k,size;
|
|
|
|
UINT64 BootNumber;
|
|
UINT64 BootSize;
|
|
UINT16 FreeBootNumber;
|
|
VOID *BootOption;
|
|
UINTN blockBegin;
|
|
|
|
EFI_DEVICE_PATH *FilePath;
|
|
EFI_FILE_INFO *fileInfo;
|
|
EFI_STATUS status;
|
|
|
|
size= SIZE_OF_EFI_FILE_INFO+255*sizeof (CHAR16);
|
|
|
|
fileInfo = AllocatePool (size);
|
|
|
|
if (fileInfo == NULL) {
|
|
Print(L"\n");
|
|
Print (L"Failed to allocate memory for File Info buffer!\n");
|
|
return -1;
|
|
}
|
|
|
|
Status = NvrFile->GetInfo(NvrFile,&GenericFileInfo,&size,fileInfo);
|
|
|
|
size=(UINTN) fileInfo->FileSize;
|
|
|
|
FreePool (fileInfo);
|
|
|
|
buffer = AllocatePool ((size+1));
|
|
|
|
if (buffer == NULL) {
|
|
Print(L"\n");
|
|
Print (L"Failed to allocate memory for File buffer!\n");
|
|
return -1;
|
|
}
|
|
|
|
Status = NvrFile->Read(NvrFile,&size,buffer);
|
|
|
|
NvrFile->Close (NvrFile);
|
|
|
|
if (EFI_ERROR (Status)) {
|
|
Print(L"\n");
|
|
Print (L"Failed to read nvr file!\n");
|
|
FreePool (buffer);
|
|
return -1;
|
|
}
|
|
|
|
#if EFINVRAM_DEBUG
|
|
Print (L"\nRestoring NVRAM. Filesize = %x\n",
|
|
size
|
|
);
|
|
#endif
|
|
|
|
//
|
|
// One ugly hack! Needs to be cleaned up..
|
|
//
|
|
k=0;
|
|
|
|
while(k < size ) {
|
|
|
|
blockBegin = k;
|
|
|
|
CopyMem( &BootNumber, &buffer[k], sizeof(BootNumber));
|
|
k += sizeof(UINT64);
|
|
|
|
CopyMem( &BootSize, &buffer[k], sizeof(BootSize));
|
|
k += sizeof(UINT64);
|
|
|
|
BootOption = (VOID *)((CHAR8*)buffer + k);
|
|
k += BootSize;
|
|
|
|
#if EFINVRAM_DEBUG
|
|
Print (L"Boot%04x: start = %x, end = %x, options size %x, ptr = %x\n",
|
|
BootNumber,
|
|
blockBegin,
|
|
k-1,
|
|
BootSize,
|
|
BootOption
|
|
);
|
|
#endif
|
|
|
|
//
|
|
// We don't use the incoming BootNumber because that number
|
|
// is relative to the boot options that were present when
|
|
// it was saved. Hence, we need to find a new boot entry #
|
|
// relative to the current boot option table
|
|
//
|
|
FreeBootNumber = FindFreeBootOption();
|
|
|
|
//
|
|
// write the current boot entry into the table at the
|
|
// free boot entry location
|
|
//
|
|
status = WritePackedDataToNvr(
|
|
FreeBootNumber,
|
|
BootOption,
|
|
(UINT32)BootSize
|
|
);
|
|
if (status != EFI_SUCCESS) {
|
|
Print (L"Failed to write to NVRAM\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
FreePool (buffer);
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
OpenCreateFile (
|
|
UINT64 OCFlags,
|
|
EFI_FILE_HANDLE* StartHdl,
|
|
CHAR16* Name
|
|
)
|
|
{
|
|
EFI_FILE_IO_INTERFACE *Vol;
|
|
EFI_FILE_HANDLE RootFs;
|
|
EFI_FILE_HANDLE CurDir;
|
|
EFI_FILE_HANDLE FileHandle;
|
|
CHAR16 FileName[100],*DevicePathAsString;
|
|
UINTN i;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Open the volume for the device where the nvrutil was started.
|
|
//
|
|
Status = BS->HandleProtocol (ExeImage->DeviceHandle,
|
|
&FileSystemProtocol,
|
|
&Vol
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Print(L"\n");
|
|
Print(L"Can not get a FileSystem handle for %s DeviceHandle\n",ExeImage->FilePath);
|
|
return Status;
|
|
}
|
|
|
|
Status = Vol->OpenVolume (Vol, &RootFs);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
Print(L"\n");
|
|
Print(L"Can not open the volume for the file system\n");
|
|
return Status;
|
|
}
|
|
|
|
CurDir = RootFs;
|
|
|
|
//
|
|
// Open saved boot options file
|
|
//
|
|
FileName[0] = 0;
|
|
|
|
DevicePathAsString = DevicePathToStr(ExeImage->FilePath);
|
|
if (DevicePathAsString!=NULL) {
|
|
StrCpy(FileName,DevicePathAsString);
|
|
FreePool(DevicePathAsString);
|
|
}
|
|
|
|
// for(i=StrLen(FileName);i>0 && FileName[i]!='\\';i--);
|
|
// FileName[i+1] = 0;
|
|
|
|
StrCpy(FileName, L".\\");
|
|
StrCat(FileName,Name);
|
|
|
|
|
|
Status = CurDir->Open (CurDir,
|
|
&FileHandle,
|
|
FileName,
|
|
OCFlags,
|
|
0
|
|
);
|
|
|
|
*StartHdl=FileHandle;
|
|
|
|
return Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
DeleteFile (
|
|
CHAR16 *FileName
|
|
)
|
|
{
|
|
EFI_FILE_HANDLE FileHandle;
|
|
EFI_STATUS Status;
|
|
|
|
//
|
|
// Get the file handle
|
|
//
|
|
Status = OpenCreateFile (
|
|
EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE,
|
|
&FileHandle,
|
|
FileName
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// do the delete
|
|
//
|
|
Status = FileHandle->Delete(FileHandle);
|
|
if (EFI_ERROR(Status)) {
|
|
Print(L"\n");
|
|
Print(L"Can not delete the file %s\n",FileName);
|
|
return Status;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
EFI_STATUS
|
|
InitializeNvrSaveFile(
|
|
CHAR16* fileName,
|
|
EFI_FILE_HANDLE* nvrFile
|
|
)
|
|
{
|
|
EFI_STATUS status;
|
|
|
|
//
|
|
// we need to delete the existing NVRFILE so that we avoid
|
|
// the problem of the new data buffer being smaller than the
|
|
// existing file length. If this happens, the remains of the
|
|
// previous osbootdata exist after the new buffer and before the
|
|
// EOF.
|
|
//
|
|
status = DeleteFile (fileName);
|
|
if (EFI_ERROR(status) && status != EFI_NOT_FOUND) {
|
|
return status;
|
|
}
|
|
|
|
status = OpenCreateFile (EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE,nvrFile,fileName);
|
|
if (EFI_ERROR (status)) {
|
|
return status;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
INTN
|
|
SaveBootOption (
|
|
CHAR16* fileName,
|
|
UINT64 bootEntryNumber
|
|
)
|
|
{
|
|
EFI_STATUS status;
|
|
EFI_FILE_HANDLE nvrFile;
|
|
UINT32 k;
|
|
CHAR8* buffer;
|
|
UINT64 BootNumber;
|
|
UINT64 BootSize;
|
|
INTN val;
|
|
UINT64 bufferSize;
|
|
|
|
if(bootEntryNumber > (UINT32)GetOsBootOptionsCount()) {
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// open the save file
|
|
//
|
|
status = InitializeNvrSaveFile(fileName, &nvrFile);
|
|
if (EFI_ERROR (status)) {
|
|
Print(L"\nCan not open the file %s\n",fileName);
|
|
return status;
|
|
}
|
|
|
|
|
|
BootNumber = ((CHAR16*)BootOrder)[bootEntryNumber];
|
|
BootSize = LoadOptionsSize[bootEntryNumber];
|
|
|
|
ASSERT(LoadOptions[bootEntryNumber] != NULL);
|
|
ASSERT(LoadOptionsSize[bootEntryNumber] > 0);
|
|
|
|
//
|
|
// Sanity checking for the the load options
|
|
//
|
|
|
|
bufferSize = BootSize + sizeof(BootNumber) + sizeof(BootSize);
|
|
ASSERT(bufferSize <= MAXBOOTVARSIZE);
|
|
|
|
buffer = AllocatePool(bufferSize);
|
|
|
|
k = 0;
|
|
|
|
CopyMem( &buffer[k], &BootNumber, sizeof(BootNumber));
|
|
k += sizeof(BootNumber);
|
|
|
|
CopyMem( &buffer[k], &BootSize, sizeof(BootSize));
|
|
k += sizeof(BootSize);
|
|
|
|
CopyMem( &buffer[k], LoadOptions[bootEntryNumber], LoadOptionsSize[bootEntryNumber] );
|
|
k += (UINT32)LoadOptionsSize[bootEntryNumber];
|
|
|
|
#if EFINVRAM_DEBUG
|
|
Print(L"Boot%04x: options size = %x, total size = %x\n",
|
|
BootNumber,
|
|
BootSize,
|
|
k
|
|
);
|
|
#endif
|
|
|
|
ASSERT(k == bufferSize);
|
|
|
|
val = PopulateNvrFile (nvrFile, buffer, (UINT32)bufferSize );
|
|
|
|
FreePool(buffer);
|
|
|
|
return val;
|
|
}
|
|
|
|
INTN
|
|
SaveAllBootOptions (
|
|
CHAR16* fileName
|
|
)
|
|
{
|
|
EFI_STATUS status;
|
|
EFI_FILE_HANDLE nvrFile;
|
|
UINT32 i, j, k;
|
|
INTN val;
|
|
CHAR8* buffer;
|
|
UINT32 beginBlock;
|
|
|
|
j = (UINT32)GetOsBootOptionsCount();
|
|
if(j == 0) {
|
|
return -1;
|
|
}
|
|
|
|
buffer = AllocatePool( j * MAXBOOTVARSIZE );
|
|
if(buffer == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// open the save file
|
|
//
|
|
status = InitializeNvrSaveFile(fileName, &nvrFile);
|
|
if (EFI_ERROR (status)) {
|
|
Print(L"\nCan not open the file %s\n",fileName);
|
|
return status;
|
|
}
|
|
|
|
k = 0;
|
|
|
|
//
|
|
// get boot option env variables
|
|
//
|
|
for ( i = 0; i < j; i++ ) {
|
|
|
|
UINT64 BootNumber;
|
|
UINT64 BootSize;
|
|
|
|
beginBlock = k;
|
|
|
|
BootNumber = ((CHAR16*)BootOrder)[i];
|
|
CopyMem( &buffer[k], &BootNumber, sizeof(BootNumber));
|
|
k += sizeof(BootNumber);
|
|
|
|
BootSize = LoadOptionsSize[i];
|
|
CopyMem( &buffer[k], &BootSize, sizeof(BootSize));
|
|
k += sizeof(BootSize);
|
|
|
|
CopyMem( &buffer[k], LoadOptions[i], LoadOptionsSize[i] );
|
|
k += (UINT32)LoadOptionsSize[i];
|
|
|
|
#if EFINVRAM_DEBUG
|
|
Print(L"Boot%04x: begin = %x, end = %x, options size = %x\n",
|
|
BootNumber,
|
|
beginBlock,
|
|
k-1,
|
|
BootSize
|
|
);
|
|
#endif
|
|
|
|
}
|
|
|
|
#if EFINVRAM_DEBUG
|
|
Print(L"Total size = %x\n", k);
|
|
#endif
|
|
|
|
ASSERT(k <= j*MAXBOOTVARSIZE);
|
|
|
|
val = PopulateNvrFile (nvrFile, buffer, k );
|
|
|
|
FreePool(buffer);
|
|
|
|
return val;
|
|
}
|
|
|
|
BOOLEAN
|
|
RestoreFileExists(
|
|
CHAR16* fileName
|
|
)
|
|
{
|
|
|
|
EFI_STATUS Status;
|
|
EFI_FILE_HANDLE nvrFile;
|
|
|
|
//
|
|
// Read from saved boot options file
|
|
//
|
|
Status = OpenCreateFile (EFI_FILE_MODE_READ,&nvrFile,fileName);
|
|
if (EFI_ERROR (Status)) {
|
|
return FALSE;
|
|
}
|
|
|
|
nvrFile->Close(nvrFile);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
INTN
|
|
RestoreNvr (
|
|
CHAR16* fileName
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_FILE_HANDLE nvrFile;
|
|
|
|
//
|
|
// Read from saved boot options file
|
|
//
|
|
Status = OpenCreateFile (EFI_FILE_MODE_READ,&nvrFile,fileName);
|
|
if (EFI_ERROR (Status)) {
|
|
Print(L"\nCan not open the file %s\n",fileName);
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// This updates nvram with saved boot options
|
|
//
|
|
return (ParseNvrFile (nvrFile));
|
|
|
|
}
|