CHAR16 * egScreenDescription(VOID)
{
if (egHasGraphics) {
if (GraphicsOutput != NULL) {
return PoolPrint(L"Graphics Output (UEFI), %dx%d",
egScreenWidth, egScreenHeight);
} else if (UgaDraw != NULL) {
return PoolPrint(L"UGA Draw (EFI 1.10), %dx%d",
egScreenWidth, egScreenHeight);
} else {
return L"Internal Error";
}
} else {
return L"Text Console";
}
}
VOID
ATIConnectorsPatchRegisterKexts (
FSINJECTION_PROTOCOL *FSInject,
FSI_STRING_LIST *ForceLoadKexts
)
{
// for future?
FSInject->AddStringToList (
ForceLoadKexts,
PoolPrint(L"\\AMD%sController.kext\\Contents\\Info.plist", gSettings.KPATIConnectorsController)
);
// Lion, ML, SnowLeo 10.6.7 2011 MBP
FSInject->AddStringToList (
ForceLoadKexts,
PoolPrint(L"\\ATI%sController.kext\\Contents\\Info.plist", gSettings.KPATIConnectorsController)
);
// SnowLeo
FSInject->AddStringToList (ForceLoadKexts, L"\\ATIFramebuffer.kext\\Contents\\Info.plist");
// dependencies
FSInject->AddStringToList (ForceLoadKexts, L"\\IOGraphicsFamily.kext\\Info.plist");
FSInject->AddStringToList (ForceLoadKexts, L"\\ATISupport.kext\\Contents\\Info.plist");
}
//
// Name:
// MainInputSetPrompt -- Set Prompt field for MainInputBar;
// it will wait for user input
// In:
// Str -- Prompt string to set
// Out:
// EFI_SUCCESS
// EFI_OUT_OF_RESOURCES
//
EFI_STATUS
MainInputBarSetPrompt (
IN CHAR16 *Str
)
{
//
// FREE the old prompt string
//
EditorFreePool (MainInputBar.Prompt);
MainInputBar.Prompt = PoolPrint (L"%s ", Str);
if (MainInputBar.Prompt == NULL) {
return EFI_OUT_OF_RESOURCES;
}
return EFI_SUCCESS;
}
EFI_STATUS
InitializeGlobalData ()
{
CHAR16 *FilePath;
EFI_STATUS Status;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
//
// init
//
mFilePath = NULL;
mDevicePath = NULL;
FilePath = NULL;
//
// Use profile lib at here just for less effect on the current system. It is
// dependent on the implementation of test framework. So need to be updated
// later.
//
Status = gtBS->LocateProtocol (
&gEfiTestProfileLibraryGuid,
NULL,
(VOID **) &ProfileLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = ProfileLib->EfiGetSystemDevicePath (
ProfileLib,
&mDevicePath,
&FilePath
);
if (EFI_ERROR (Status)) {
return Status;
}
mFilePath = PoolPrint (L"%s\\%s", FilePath, DEPENDENCY_DIR_NAME);
FreePool (FilePath);
return EFI_SUCCESS;
}
//
// Name:
// MainTitleBarInit -- Init function for MainTitleBar
// In:
// VOID
// Out:
// EFI_SUCCESS
// EFI_OUT_OF_RESOURCES
//
EFI_STATUS
MainTitleBarInit (
VOID
)
{
//
// basic initialization for MainTitleBar
//
CopyMem (&MainTitleBar, &MainTitleBarConst, sizeof (MainTitleBar));
//
// set TitlePrefix
//
MainTitleBar.TitlePrefix = PoolPrint (L" %s %s", EDITOR_NAME, EDITOR_VERSION);
if (MainTitleBar.TitlePrefix == NULL) {
return EFI_OUT_OF_RESOURCES;
}
return EFI_SUCCESS;
}
//
// Called from SetFSInjection(), before boot.efi is started,
// to allow patchers to prepare FSInject to force load needed kexts.
//
VOID
KextPatcherRegisterKexts (
FSINJECTION_PROTOCOL *FSInject,
FSI_STRING_LIST *ForceLoadKexts
)
{
INTN i;
if (gSettings.KPATIConnectorsController != NULL) {
ATIConnectorsPatchRegisterKexts (FSInject, ForceLoadKexts);
}
for (i = 0; i < gSettings.NrKexts; i++) {
FSInject->AddStringToList(ForceLoadKexts,
PoolPrint(L"\\%a.kext\\Contents\\Info.plist",
gSettings.AnyKext[i])
);
}
}
EFI_STATUS
HDiskImageBackup (
VOID
)
/*++
Routine Description:
Backup function for HDiskImage
Only a few fields need to be backup.
This is for making the Disk buffer refresh
as few as possible.
Arguments:
None
Returns:
EFI_SUCCESS - Success
EFI_OUT_OF_RESOURCES - Out of resources
--*/
{
//
// backup the disk name, offset and size
//
//
HEditorFreePool (HDiskImageBackupVar.Name);
HDiskImageBackupVar.Name = PoolPrint (L"%s", HDiskImage.Name);
if (HDiskImageBackupVar.Name == NULL) {
return EFI_OUT_OF_RESOURCES;
}
HDiskImageBackupVar.Offset = HDiskImage.Offset;
HDiskImageBackupVar.Size = HDiskImage.Size;
return EFI_SUCCESS;
}
EG_IMAGE_VIEW * egCreateImageView(IN UINTN Width, IN UINTN Height, IN BOOLEAN HasAlpha, IN UINTN PosX, IN UINTN PosY, IN CHAR16 *Name)
{
EG_IMAGE_VIEW * NewImageView;
NewImageView = (EG_IMAGE_VIEW *) AllocateZeroPool(sizeof(EG_IMAGE_VIEW));
if (NewImageView == NULL)
return NULL;
NewImageView->Image = egCreateImage(Width, Height, HasAlpha);
if (NewImageView->Image == NULL) {
FreePool(NewImageView);
return NULL;
}
NewImageView->Name = PoolPrint(Name);
if (NewImageView->Name == NULL) {
egFreeImage(NewImageView->Image);
FreePool(NewImageView);
return NULL;
}
NewImageView->PosX = PosX;
NewImageView->PosY = PosY;
return NewImageView;
}
EFI_STATUS
GetReportInfor (
OUT CHAR16 **Buffer
)
/*++
Routine Description:
Get the report information into a buffer.
--*/
{
EFI_SCT_REPORT_ITEM *ReportItem;
EFI_SCT_ASSERTION_INFOR *AssertionInfor;
CHAR16 *TempBuffer;
//
// Check parameters
//
if (Buffer == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize
//
*Buffer = NULL;
//
// Add summary head:
// "Self Certification Test Report"
// "Service\Protocol Name", "Total", "Failed", "Passed"
//
AutoStrCat (
Buffer,
L"\"Self Certification Test Report\"\n"
L"\"Service\\Protocol Name\",\"Total\",\"Failed\",\"Passed\"\n"
);
//
// For each report item, from the last one
//
ReportItem = mReportInfor.ReportItem;
while ((ReportItem != NULL) && (ReportItem->Next != NULL)) {
ReportItem = ReportItem->Next;
}
while (ReportItem != NULL) {
TempBuffer = PoolPrint (
L"\"%s\",\"%d\",\"%d\",\"%d\"\n",
ReportItem->TestCategory,
ReportItem->PassNumber + ReportItem->FailNumber,
ReportItem->FailNumber,
ReportItem->PassNumber
);
if (TempBuffer == NULL) {
break;
}
AutoStrCat (Buffer, TempBuffer);
BS->FreePool (TempBuffer);
ReportItem = ReportItem->Prev;
}
//
// Total summary
//
TempBuffer = PoolPrint (
L"\"Total service\\Protocol\",\"%d\",\"%d\",\"%d\"\n",
mReportInfor.TotalPass + mReportInfor.TotalFail,
mReportInfor.TotalFail,
mReportInfor.TotalPass
);
if (TempBuffer == NULL) {
return EFI_OUT_OF_RESOURCES;
}
AutoStrCat (Buffer, TempBuffer);
//
// Add fail head:
// "Service\Protocol Name", "Index","Instance","Iteration","Guid","Result","Title","Runtime Information","Case Revision","Case GUID","Device Path","Logfile Name"
//
AutoStrCat (
Buffer,
L"\n\"Service\\Protocol Name\",\"Index\",\"Instance\",\"Iteration\",\"Guid\",\"Result\",\"Title\",\"Runtime Information\",\"Case Revision\",\"Case GUID\",\"Device Path\",\"Logfile Name\"\n"
);
//
// For each report item, from the last one
//
ReportItem = mReportInfor.ReportItem;
while ((ReportItem != NULL) && (ReportItem->Next != NULL)) {
ReportItem = ReportItem->Next;
}
while (ReportItem != NULL) {
//
// For each failed assertion, from the last one
//
AssertionInfor = ReportItem->FailAssertion;
while ((AssertionInfor != NULL) && (AssertionInfor->Next != NULL)) {
AssertionInfor = AssertionInfor->Next;
}
while (AssertionInfor != NULL) {
TempBuffer = PoolPrint (
L"\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"FAIL\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
ReportItem->TestCategory,
AssertionInfor->Index,
AssertionInfor->CaseIndex,
AssertionInfor->CaseIteration,
AssertionInfor->Guid,
AssertionInfor->Title,
AssertionInfor->RuntimeInfor,
AssertionInfor->CaseRevision,
AssertionInfor->CaseGuid,
AssertionInfor->DevicePath,
AssertionInfor->FileName
);
if (TempBuffer == NULL) {
break;
}
AutoStrCat (Buffer, TempBuffer);
BS->FreePool (TempBuffer);
AssertionInfor = AssertionInfor->Prev;
}
ReportItem = ReportItem->Prev;
}
//
// Add pass head:
// "Service\Protocol Name","Index","Instance","Iteration","Guid","Result","Title","Runtime Information","Case Revision","Case GUID" //
//
AutoStrCat (
Buffer,
L"\n\"Service\\Protocol Name\",\"Index\",\"Instance\",\"Iteration\",\"Guid\",\"Result\",\"Title\",\"Runtime Information\",\"Case Revision\",\"Case GUID\"\n"
);
//
// For each report item, from the last one
//
ReportItem = mReportInfor.ReportItem;
while ((ReportItem != NULL) && (ReportItem->Next != NULL)) {
ReportItem = ReportItem->Next;
}
while (ReportItem != NULL) {
//
// For each passed assertion, from the last one
//
AssertionInfor = ReportItem->PassAssertion;
while ((AssertionInfor != NULL) && (AssertionInfor->Next != NULL)) {
AssertionInfor = AssertionInfor->Next;
}
while (AssertionInfor != NULL) {
TempBuffer = PoolPrint (
L"\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"PASS\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
ReportItem->TestCategory,
AssertionInfor->Index,
AssertionInfor->CaseIndex,
AssertionInfor->CaseIteration,
AssertionInfor->Guid,
AssertionInfor->Title,
AssertionInfor->RuntimeInfor,
AssertionInfor->CaseRevision,
AssertionInfor->CaseGuid
);
if (TempBuffer == NULL) {
break;
}
AutoStrCat (Buffer, TempBuffer);
BS->FreePool (TempBuffer);
AssertionInfor = AssertionInfor->Prev;
}
ReportItem = ReportItem->Prev;
}
return EFI_SUCCESS;
}
EFI_STATUS
LoadReportInfor (
IN CHAR16 *CaseIndexStr,
IN CHAR16 *CaseIterationStr,
IN CHAR16 *Buffer,
IN CHAR16 *FileName
)
/*++
Routine Description:
Load the report information from a buffer.
--*/
{
EFI_STATUS Status;
CHAR16 *LineBuffer;
CHAR16 *GuidStr;
CHAR16 *AssertionStr;
UINTN AssertionType;
CHAR16 *TestNameStr;
CHAR16 *TestCategoryStr;
CHAR16 *DevicePathStr;
CHAR16 *TitleStr;
CHAR16 *RuntimeInforStr;
CHAR16 *CaseRevisionStr;
CHAR16 *CaseGuidStr;
CHAR16 *CaseNameStr;
CHAR16 GenericGuidStr[EFI_SCT_GUID_LEN];
CHAR16 SystemHangGuidStr[EFI_SCT_GUID_LEN];
//
// Check parameters
//
if ((CaseIndexStr == NULL) || (CaseIterationStr == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize
//
ZeroMem (GenericGuidStr, EFI_SCT_GUID_LEN * sizeof(CHAR16));
SctGuidToStr (&gTestGenericFailureGuid, GenericGuidStr);
ZeroMem (SystemHangGuidStr, EFI_SCT_GUID_LEN * sizeof(CHAR16));
SctGuidToStr (&gEfiSystemHangAssertionGuid, SystemHangGuidStr);
CaseGuidStr = NULL;
CaseRevisionStr = NULL;
CaseNameStr = NULL;
TestNameStr = NULL;
TestCategoryStr = NULL;
DevicePathStr = NULL;
//
// Start to deal with the ekl file data
//
if (Buffer[0] != 0xFEFF) {
return EFI_SUCCESS;
}
LineBuffer = StrTokenLine (Buffer + 1, L"\n\r");
while (LineBuffer != NULL) {
if (LineBuffer[0] == L'|') {
if (LineBuffer[1] == L'H') {
//
// The head line
//
StrTokenField (LineBuffer, L"|");
//
// Skip the HEAD characters
//
StrTokenField (NULL, L"|");
//
// Skip the first empty string
//
StrTokenField (NULL, L"|");
//
// Skip the second empry string
//
StrTokenField (NULL, L"|");
//
// Skip the configuration number
//
StrTokenField (NULL, L"|");
//
// Skip the scenario string
//
StrTokenField (NULL, L"|");
//
// Skip the execution date
//
StrTokenField (NULL, L"|");
//
// Skip the execution time
//
StrTokenField (NULL, L"|");
//
// Get the case's GUID
//
CaseGuidStr = StrTokenField (NULL, L"|");
//
// Get the case's revision
//
CaseRevisionStr = StrTokenField (NULL, L"|");
//
// Get the case's name
//
CaseNameStr = StrTokenField (NULL, L"|");
//
// Get the test name
//
TestNameStr = StrTokenField (NULL, L"|");
//
// Get the test category
//
TestCategoryStr = StrTokenField (NULL, L"|");
//
// Get the device path
//
// Note: Don't use "|" to split the device path token, some device path
// include that. And from the other way, the device path token should
// be the last token in the .ekl header.
//
DevicePathStr = StrTokenField (NULL, L"\n");
} else if (LineBuffer[1] == L'T') {
//
// The terminate line, do nothing
//
}
LineBuffer = StrTokenLine (NULL, L"\n\r");
continue;
}
//
// The item line
//
//
// Get the assertion's GUID
//
GuidStr = StrTokenField (LineBuffer, L":");
if (GuidStr == NULL) {
LineBuffer = StrTokenLine (NULL, L"\n\r");
continue;
}
//
// Ignore the generic GUID
//
if (StrCmp (GuidStr, GenericGuidStr) == 0) {
LineBuffer = StrTokenLine (NULL, L"\n\r");
continue;
}
//
// Get the assertion's type
//
AssertionStr = StrTokenField (NULL, L"|");
if (AssertionStr == NULL) {
LineBuffer = StrTokenLine (NULL, L"\n\r");
continue;
}
if (StrCmp (AssertionStr, L"PASS") == 0) {
AssertionType = EFI_SCT_GUID_ASSERTION_TYPE_PASS;
} else if (StrCmp (AssertionStr, L"FAILURE") == 0) {
AssertionType = EFI_SCT_GUID_ASSERTION_TYPE_FAIL;
} else {
AssertionType = EFI_SCT_GUID_ASSERTION_TYPE_WARN;
}
//
// Get the Title
//
TitleStr = StrTokenField (NULL, L":");
if (StrCmp (GuidStr, SystemHangGuidStr) == 0) {
TitleStr = StrDuplicate (L"System hangs or stops abnormally.");
}
//
// Get the runtime information
//
RuntimeInforStr = StrTokenField (NULL, L"\n\r");
if (StrCmp (GuidStr, SystemHangGuidStr) == 0) {
RuntimeInforStr = PoolPrint (L"System hang in %s - %s", TestCategoryStr, CaseNameStr);
}
//
// Set the report item
//
Status = InsertReportInfor (
CaseIndexStr,
CaseIterationStr,
TestNameStr,
TestCategoryStr,
GuidStr,
AssertionType,
TitleStr,
RuntimeInforStr,
DevicePathStr,
CaseRevisionStr,
CaseGuidStr,
FileName
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Set report item - %r", Status));
if (StrCmp (GuidStr, SystemHangGuidStr) == 0) {
BS->FreePool (TitleStr);
BS->FreePool (RuntimeInforStr);
}
return Status;
}
if (StrCmp (GuidStr, SystemHangGuidStr) == 0) {
BS->FreePool (TitleStr);
BS->FreePool (RuntimeInforStr);
}
//
// Next line
//
LineBuffer = StrTokenLine (NULL, L"\n\r");
}
return EFI_SUCCESS;
}
EFI_STATUS
GenerateReport (
IN EFI_DEVICE_PATH_PROTOCOL *LogDevicePath,
IN CHAR16 *LogFilePath,
IN EFI_DEVICE_PATH_PROTOCOL *ReportDevicePath,
IN CHAR16 *ReportFileName
)
/*++
Routine Description:
Generate test report.
Arguments:
LogDevicePath - Device path of the key files.
LogFilePath - Path of the key files.
ReportDevicePath - Device path of the report file.
ReportFileName - Name of the report file.
EFI_SUCCESS - Generate the test report successfully.
--*/
{
EFI_STATUS Status;
UINT32 PassNumber;
UINT32 WarnNumber;
UINT32 FailNumber;
CHAR16 *FileName;
CHAR16 *Buffer;
UINTN AsciiBufferSize;
CHAR8 *AsciiBuffer;
UINTN ConfigBufferSize;
CHAR8 *ConfigBuffer;
EFI_FILE_HANDLE Handle;
//
// Check parameters
//
if ((LogDevicePath == NULL) || (LogFilePath == NULL) ||
(ReportDevicePath == NULL) || (ReportFileName == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize
//
PassNumber = 0;
WarnNumber = 0;
FailNumber = 0;
//
// Get the configuration data. Start this operation at first since the next
// operations will take more time. We could stop the entire process if we
// meet any problem in configuration collection.
//
Status = SctReportConfig (
&ConfigBufferSize,
&ConfigBuffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"SctReportConfig: %r", Status));
return Status;
}
//
// Load the GUID database
//
FileName = PoolPrint (L"%s\\%s", gFT->FilePath, EFI_SCT_FILE_GUID_DATABASE);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
BS->FreePool (ConfigBuffer);
return EFI_OUT_OF_RESOURCES;
}
Status = LoadGuidDatabase (gFT->DevicePath, FileName);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Load GUID database - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (FileName);
return Status;
}
BS->FreePool (FileName);
//
// Load the assertion information from the log directory
//
Status = GetProtocolAssertion (
LogDevicePath,
LogFilePath,
&PassNumber,
&WarnNumber,
&FailNumber
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Get protocol assertion - %r", Status));
BS->FreePool (ConfigBuffer);
UnloadGuidDatabase ();
UnloadReportInfor ();
return Status;
}
//
// Get the report information to a buffer
//
Status = GetReportInfor (&Buffer);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Get report infor - %r", Status));
BS->FreePool (ConfigBuffer);
UnloadGuidDatabase ();
UnloadReportInfor ();
return Status;
}
UnloadGuidDatabase ();
UnloadReportInfor ();
//
// Convert the buffer to ASCII buffer
//
AsciiBufferSize = StrLen(Buffer) + 1;
Status = BS->AllocatePool (
EfiBootServicesData,
AsciiBufferSize,
&AsciiBuffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Allocate pool - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (Buffer);
return Status;
}
Status = UnicodeToAscii (Buffer, AsciiBuffer);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Convert Unicode to ASCII - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (Buffer);
BS->FreePool (AsciiBuffer);
return Status;
}
BS->FreePool (Buffer);
//
// Create the report file
//
Status = SctCreateFileFromDevicePath (
ReportDevicePath,
ReportFileName,
&Handle
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Create report file - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (AsciiBuffer);
return Status;
}
//
// Write the ASCII buffer to the report file (remove the null-terminator)
//
AsciiBufferSize --;
Status = Handle->Write (
Handle,
&AsciiBufferSize,
AsciiBuffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Write report file - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (AsciiBuffer);
Handle->Close (Handle);
return Status;
}
//
// Write the config buffer to the report file
//
Status = Handle->Write (
Handle,
&ConfigBufferSize,
ConfigBuffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Write report file - %r", Status));
BS->FreePool (ConfigBuffer);
BS->FreePool (AsciiBuffer);
Handle->Close (Handle);
return Status;
}
BS->FreePool (ConfigBuffer);
BS->FreePool (AsciiBuffer);
//
// Close the report file
//
Handle->Close (Handle);
//
// Done
//
return EFI_SUCCESS;
}
VOID
DisplayLog (
IN EFI_MENU_PAGE *Page
)
{
EFI_STATUS Status;
EFI_FILE_DIALOG_CONTEXT *DialogContext;
CHAR16 *FileName;
EFI_DIALOG_CONTEXT MsgDialogContext;
CHAR16 *MsgDialogTitle;
CHAR16 *CmdLine;
DialogContext = NULL;
//
//allocate a new efi file dialog context.
//
Status = BS->AllocatePool (
EfiBootServicesData,
sizeof(EFI_FILE_DIALOG_CONTEXT),
(VOID **)&DialogContext
);
if (EFI_ERROR (Status)) {
return;
}
BS->SetMem (DialogContext, sizeof(EFI_FILE_DIALOG_CONTEXT), 0);
DialogContext->DialogType = EFI_FILE_DIALOG_TYPE_OPEN_FILE;
DialogContext->FileType = EFI_FILTER_FILE_TYPE_LOG;
//
//get filename through FileDialog
//
Status = DoLogFileDialog (DialogContext);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Display Log Error!");
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
MenuPageRefresh (Page);
DoDialog (MsgDialogTitle, &MsgDialogContext);
} else if (DialogContext->DevicePath != NULL && DialogContext->FileName != NULL
&& DialogContext->FileName[0] != L'\0') {
//
//make up file name
//
if (StrLen (DialogContext->FileName) > 4 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 4, L".log") == 0) {
FileName = StrDuplicate (DialogContext->FileName);
}else if ( StrLen (DialogContext->FileName) > 1 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 1, L".") == 0) {
FileName = PoolPrint (L"%slog", DialogContext->FileName);
}else {
FileName = PoolPrint (L"%s.log", DialogContext->FileName);
}
if (FileName == NULL) {
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
BS->FreePool (DialogContext);
return;
}
MsgDialogTitle = StrDuplicate (L"Wait a few minutes...");
MsgDialogContext.Type = EFI_DIALOG_TYPE_REMINDER;
//
//set default Console Attribute and clear the screen
//
ST->ConOut->SetAttribute (ST->ConOut, EFI_BACKGROUND_BLACK | EFI_WHITE);
ST->ConOut->ClearScreen (ST->ConOut);
CmdLine = PoolPrint (L"%s \"%s\"", gFT->ConfigData->EditCommandString, FileName);
if (CmdLine != NULL) {
Status = ShellExecute (
gFT->ImageHandle,
CmdLine,
FALSE
);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Cannot open the log file! Please check the edit command in the configuration page.");
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
DoDialog (MsgDialogTitle, &MsgDialogContext);
}
BS->FreePool (CmdLine);
}
BS->FreePool (FileName);
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
} else {
if (DialogContext->FileName != NULL) {
BS->FreePool (DialogContext->FileName);
}
if (DialogContext->DevicePath != NULL) {
BS->FreePool (DialogContext->DevicePath);
}
}
BS->FreePool (DialogContext);
MenuPageRefresh (Page);
return;
}
EFI_STATUS
MainMenuSaveSeqFunc (
IN EFI_MENU_PAGE *Page
)
{
EFI_STATUS Status;
EFI_FILE_DIALOG_CONTEXT *DialogContext;
CHAR16 *FileName;
EFI_DIALOG_CONTEXT MsgDialogContext;
CHAR16 *MsgDialogTitle;
DialogContext = NULL;
//
//allocate a new efi file dialog context.
//
Status = BS->AllocatePool (
EfiBootServicesData,
sizeof(EFI_FILE_DIALOG_CONTEXT),
(VOID **)&DialogContext
);
if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR;
}
BS->SetMem (DialogContext, sizeof(EFI_FILE_DIALOG_CONTEXT), 0);
DialogContext->DialogType = EFI_FILE_DIALOG_TYPE_SAVE_FILE;
DialogContext->FileType = EFI_FILTER_FILE_TYPE_SEQ;
//
//get devicepath and filename through FileDialog
//
Status = DoFileDialog (DialogContext);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Save Sequence Error!");
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
MenuPageRefresh (Page);
DoDialog (MsgDialogTitle, &MsgDialogContext);
} else if (DialogContext->DevicePath != NULL && DialogContext->FileName != NULL
&& DialogContext->FileName[0] != L'\0') {
//
//make up file name
//
if (StrLen (DialogContext->FileName) > 4 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 4, L".seq") == 0) {
FileName = StrDuplicate (DialogContext->FileName);
}else if ( StrLen (DialogContext->FileName) > 1 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 1, L".") == 0) {
FileName = PoolPrint (L"%sseq", DialogContext->FileName);
}else {
FileName = PoolPrint (L"%s.seq", DialogContext->FileName);
}
if (FileName == NULL) {
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
BS->FreePool (DialogContext);
return EFI_DEVICE_ERROR;
}
Status = SaveTestSequence (
gFT->DevicePath,
FileName,
&gFT->TestCaseList
);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Save sequence Error!");
} else {
MsgDialogTitle = StrDuplicate (L"Save sequence Succeed!");
}
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
MenuPageRefresh (Page);
DoDialog (MsgDialogTitle, &MsgDialogContext);
BS->FreePool (FileName);
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
} else {
if (DialogContext->FileName != NULL) {
BS->FreePool (DialogContext->FileName);
}
if (DialogContext->DevicePath != NULL) {
BS->FreePool (DialogContext->DevicePath);
}
}
BS->FreePool (DialogContext);
MenuPageRefresh (Page);
return EFI_SUCCESS;
}
EFI_STATUS
GetInstanceAssertion (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN CHAR16 *MetaName,
OUT EFI_SCT_LOG_STATE *FileState,
OUT UINT32 *Index,
OUT UINT32 *Iteration,
OUT UINT32 *PassNumber,
OUT UINT32 *WarnNumber,
OUT UINT32 *FailNumber
)
/*++
Routine Description:
Get the assertion number of a instance.
Arguments:
DevicePath - Device path of the key files.
MetaName - Meta name of the key files.
FileState - The log state.
Index - The index of the instance.
Interation - The index of the iteration.
PassNumber - The number of passed assertions.
WarnNumber - The number of warning assertions.
FailNumber - The number of failed assertions.
Returns:
EFI_SUCCESS - Get instance assertion number successfully.
--*/
{
EFI_STATUS Status;
CHAR16 *FileName;
UINT32 InstanceIndex;
UINT32 IterationIndex;
UINTN BufferSize;
CHAR16 *Buffer;
//
// Check parameters
//
if ((DevicePath == NULL) || (MetaName == NULL) ||
(FileState == NULL) || (Index == NULL) ||
(Iteration == NULL) || (PassNumber == NULL) ||
(WarnNumber == NULL) || (FailNumber == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Initialize
//
*FileState = EFI_SCT_LOG_STATE_UNKNOWN;
*Index = 0;
*Iteration = 0;
*PassNumber = 0;
*WarnNumber = 0;
*FailNumber = 0;
InstanceIndex = 0;
IterationIndex = 0;
//
// Found the maximum index of instance and iteration
//
for (InstanceIndex = 0; TRUE; InstanceIndex ++) {
for (IterationIndex = 0; TRUE; IterationIndex ++) {
FileName = PoolPrint (MetaName, InstanceIndex, IterationIndex);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
if (!FileExist (DevicePath, FileName)) {
//
// File does not exist
//
if (IterationIndex != 0) {
*Index = InstanceIndex;
*Iteration = IterationIndex - 1;
}
BS->FreePool (FileName);
break;
}
BS->FreePool (FileName);
}
if (IterationIndex == 0) {
break;
}
}
//
// No instance file is found
//
if ((InstanceIndex == 0) && (IterationIndex == 0)) {
*FileState = EFI_SCT_LOG_STATE_EMPTY;
*Index = 0;
*Iteration = 0;
return EFI_SUCCESS;
}
//
// The maximum instance index is found
//
FileName = PoolPrint (MetaName, *Index, *Iteration);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
//
// Read the file to a buffer
//
Status = ReadFileToBuffer (
DevicePath,
FileName,
&BufferSize,
&Buffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Read file to buffer - %r", Status));
BS->FreePool (FileName);
return Status;
}
BS->FreePool (FileName);
//
// Load the buffer to the GUID assertion table with duplicate
//
Status = LoadGuidAssertion (Buffer, TRUE, FileState);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Load GUID assertion - %r", Status));
BS->FreePool (Buffer);
return Status;
}
BS->FreePool (Buffer);
//
// Get the assertion number (free the GUID assertion table)
//
Status = GetAssertionNumber (PassNumber, WarnNumber, FailNumber);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Get assertion number - %r", Status));
return Status;
}
//
// Done
//
return EFI_SUCCESS;
}
VOID
DisplayReportGenerator(
IN EFI_MENU_PAGE *Page
)
{
EFI_STATUS Status;
EFI_FILE_DIALOG_CONTEXT *DialogContext;
CHAR16 *FileName;
EFI_DIALOG_CONTEXT MsgDialogContext;
CHAR16 *MsgDialogTitle;
CHAR16 *LogFilePath;
DialogContext = NULL;
//
//allocate a new efi file dialog context.
//
Status = BS->AllocatePool (
EfiBootServicesData,
sizeof(EFI_FILE_DIALOG_CONTEXT),
(VOID **)&DialogContext
);
if (EFI_ERROR (Status)) {
return;
}
BS->SetMem (DialogContext, sizeof(EFI_FILE_DIALOG_CONTEXT), 0);
DialogContext->DialogType = EFI_FILE_DIALOG_TYPE_SAVE_FILE;
DialogContext->FileType = EFI_FILTER_FILE_TYPE_CSV;
//
//get filename through FileDialog
//
Status = DoFileDialog (DialogContext);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Generate Report Error!");
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
MenuPageRefresh (Page);
DoDialog (MsgDialogTitle, &MsgDialogContext);
} else if (DialogContext->DevicePath != NULL && DialogContext->FileName != NULL
&& DialogContext->FileName[0] != L'\0') {
//
//make up file name
//
if (StrLen (DialogContext->FileName) > 4 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 4, L".csv") == 0) {
FileName = StrDuplicate (DialogContext->FileName);
} else if ( StrLen (DialogContext->FileName) > 1 &&
StriCmp (DialogContext->FileName + StrLen (DialogContext->FileName) - 1, L".") == 0) {
FileName = PoolPrint (L"%scsv", DialogContext->FileName);
} else {
FileName = PoolPrint (L"%s.csv", DialogContext->FileName);
}
if (FileName == NULL) {
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
BS->FreePool (DialogContext);
return;
}
MsgDialogTitle = StrDuplicate (L"Wait a few minutes...");
MsgDialogContext.Type = EFI_DIALOG_TYPE_REMINDER;
MenuPageRefresh (Page);
DoDialog (MsgDialogTitle, &MsgDialogContext);
LogFilePath = PoolPrint (
L"%s\\%s",
gFT->FilePath,
EFI_SCT_PATH_LOG
);
if (LogFilePath == NULL) {
return;
}
//
// Generate the report file
//
Status = GenerateReport (
gFT->DevicePath,
LogFilePath,
DialogContext->DevicePath,
FileName
);
if (EFI_ERROR (Status)) {
MsgDialogTitle = StrDuplicate (L"Generate Report Error!");
} else {
MsgDialogTitle = StrDuplicate (L"Generate Report Succeed!");
}
MsgDialogContext.Type = EFI_DIALOG_TYPE_MESSAGE;
DoDialog (MsgDialogTitle, &MsgDialogContext);
BS->FreePool (FileName);
BS->FreePool (DialogContext->DevicePath);
BS->FreePool (DialogContext->FileName);
} else {
if (DialogContext->FileName != NULL) {
BS->FreePool (DialogContext->FileName);
}
if (DialogContext->DevicePath != NULL) {
BS->FreePool (DialogContext->DevicePath);
}
}
BS->FreePool (DialogContext);
MenuPageRefresh (Page);
return;
}
EFI_STATUS
MainInputBarRefresh (
VOID
)
/*++
Routine Description:
refresh function for MainInputBar, it will wait for user input
Arguments:
VOID
Returns:
EFI_SUCCESS
--*/
{
EFI_EDITOR_COLOR_UNION Orig;
EFI_EDITOR_COLOR_UNION New;
EFI_INPUT_KEY Key;
UINTN Size;
EFI_STATUS Status;
BOOLEAN NoDisplay;
UINTN Limit;
UINTN PromptLen;
//
// variable initialization
//
Size = 0;
Status = EFI_SUCCESS;
//
// free status string
//
EditorFreePool (MainEditor.StatusBar->StatusString);
MainEditor.StatusBar->StatusString = PoolPrint (L"");
if (MainEditor.StatusBar->StatusString == NULL) {
return EFI_OUT_OF_RESOURCES;
}
//
// back up the old screen attributes
//
Orig = MainEditor.ColorAttributes;
New.Colors.Foreground = Orig.Colors.Background;
New.Colors.Background = Orig.Colors.Foreground;
Out->SetAttribute (Out, New.Data);
//
// clear input bar
//
EditorClearLine (INPUT_BAR_LOCATION);
Out->SetCursorPosition (Out, 0, INPUT_BAR_LOCATION - 1);
PrintToken (STRING_TOKEN (STR_EDIT_LIBINPUTBAR_MAININPUTBAR), HiiHandle, MainInputBar.Prompt);
//
// that's the maximum input length that can be displayed on screen
//
PromptLen = StrLen (MainInputBar.Prompt);
Limit = MainEditor.ScreenSize.Column - PromptLen;
//
// this is a selection prompt, cursor will stay in edit area
// actually this is for search , search/replace
//
if (StrStr (MainInputBar.Prompt, L"Yes/No")) {
NoDisplay = TRUE;
FileBufferRestorePosition ();
Out->SetAttribute (Out, Orig.Data);
} else {
NoDisplay = FALSE;
}
//
// wait for user input
//
for (;;) {
WaitForSingleEvent (In->WaitForKey, 0);
Status = In->ReadKeyStroke (In, &Key);
if (EFI_ERROR (Status)) {
continue;
}
//
// pressed ESC
//
if (Key.ScanCode == SCAN_CODE_ESC) {
Size = 0;
Status = EFI_NOT_READY;
break;
}
//
// return pressed
//
if (Key.UnicodeChar == CHAR_LF || Key.UnicodeChar == CHAR_CR) {
break;
} else if (Key.UnicodeChar == CHAR_BS) {
//
// backspace
//
if (Size > 0) {
Size--;
MainInputBar.ReturnString[Size] = L'\0';
if (!NoDisplay) {
MainInputBarPrintInput ();
}
}
} else if (Key.UnicodeChar <= 127 && Key.UnicodeChar >= 32) {
//
// VALID ASCII char pressed
//
MainInputBar.ReturnString[Size] = Key.UnicodeChar;
//
// should be less than specified length
//
if (Size >= MainInputBar.StringSize) {
continue;
}
Size++;
MainInputBar.ReturnString[Size] = L'\0';
if (!NoDisplay) {
MainInputBarPrintInput ();
} else {
//
// if just choose yes/no
//
break;
}
}
}
MainInputBar.ReturnString[Size] = 0;
FileBufferRestorePosition ();
//
// restore screen attributes
//
Out->SetAttribute (Out, Orig.Data);
StatusBarNeedRefresh = TRUE;
return Status;
}
EFI_STATUS
GatherConfigHandles (
IN EFI_HANDLE SupportHandle,
OUT UINTN *NoConfigHandles,
OUT EFI_HANDLE **ConfigHandleBuffer
)
{
EFI_STATUS Status;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *FilePath;
CHAR16 *ConfigFilePath;
EFI_INI_FILE_HANDLE IniFile;
UINT32 Order;
UINT32 OrderNum;
CHAR16 Buffer[EFI_SCT_MAX_BUFFER_SIZE];
UINTN Index;
UINTN NoHandles;
EFI_HANDLE *HandleBuffer;
CHAR16 *DevicePathStr;
//
// Locate test profile library protocol
//
Status = gtBS->HandleProtocol (
SupportHandle,
&gEfiTestProfileLibraryGuid,
&ProfileLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = ProfileLib->EfiGetSystemDevicePath (
ProfileLib,
&DevicePath,
&FilePath
);
if (EFI_ERROR (Status)) {
return Status;
}
ConfigFilePath = PoolPrint (L"%s\\%s", FilePath, EFI_SCT_FILE_DEVICE_CONFIG);
if (ConfigFilePath == NULL) {
gtBS->FreePool (DevicePath);
gtBS->FreePool (FilePath);
return EFI_OUT_OF_RESOURCES;
}
gtBS->FreePool (FilePath);
//
// Open the device configuration file
//
Status = ProfileLib->EfiIniOpen (
ProfileLib,
DevicePath,
ConfigFilePath,
&IniFile
);
if (EFI_ERROR (Status)) {
gtBS->FreePool (DevicePath);
gtBS->FreePool (ConfigFilePath);
return Status;
}
gtBS->FreePool (DevicePath);
gtBS->FreePool (ConfigFilePath);
//
// Get the number of device configuration data
//
Status = DeviceConfigGetOrderNum (
IniFile,
&OrderNum
);
if (EFI_ERROR (Status)) {
ProfileLib->EfiIniClose (ProfileLib, IniFile);
return Status;
}
//
// Get all handles
//
Status = gtBS->LocateHandleBuffer (
AllHandles,
NULL,
NULL,
&NoHandles,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
ProfileLib->EfiIniClose (ProfileLib, IniFile);
return Status;
}
//
// Initialize the output variables
//
*NoConfigHandles = 0;
Status = gtBS->AllocatePool (
EfiBootServicesData,
sizeof(EFI_HANDLE) * NoHandles,
(VOID **)ConfigHandleBuffer
);
if (EFI_ERROR (Status)) {
ProfileLib->EfiIniClose (ProfileLib, IniFile);
gtBS->FreePool (HandleBuffer);
return Status;
}
//
// Scan each device configuration data
//
for (Order = 0; Order < OrderNum; Order++) {
//
// Here, need to check the setting in configuration file and find the
// matched device path in the system
//
Status = DeviceConfigGetString (
IniFile,
Order,
L"DriverConfiguration",
Buffer
);
if (EFI_ERROR (Status)) {
continue;
}
if (StriCmp (Buffer, L"Yes") != 0) {
continue;
}
Status = DeviceConfigGetString (
IniFile,
Order,
L"DevicePath",
Buffer
);
if (EFI_ERROR (Status)) {
continue;
}
//
// Search the matched device path in the system
//
for (Index = 0; Index < NoHandles; Index++) {
Status = gtBS->HandleProtocol (
HandleBuffer[Index],
&gEfiDevicePathProtocolGuid,
&DevicePath
);
if (EFI_ERROR (Status)) {
continue;
}
DevicePathStr = DevicePathToStr (DevicePath);
if (StrCmp (Buffer, DevicePathStr) == 0) {
gtBS->FreePool (DevicePathStr);
break;
}
gtBS->FreePool (DevicePathStr);
}
//
// Found it?
//
if (Index < NoHandles) {
InsertChildHandles (
NoConfigHandles,
*ConfigHandleBuffer,
HandleBuffer[Index],
FALSE // Only for the handles on this controller
);
}
}
//
// Free resources
//
gtBS->FreePool (HandleBuffer);
//
// Close the device configuration file
//
ProfileLib->EfiIniClose (ProfileLib, IniFile);
//
// Done
//
return EFI_SUCCESS;
}
EFI_STATUS
LoadStartImage (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
IN EFI_HANDLE CurrentImageHandle,
IN CHAR16 *FileName,
IN EFI_HANDLE *StartImage
)
{
EFI_STATUS Status;
CHAR16 *EntireFileName;
EFI_LOADED_IMAGE_PROTOCOL *LoadImage;
EFI_DEVICE_PATH_PROTOCOL *FilePath;
Status = gtBS->HandleProtocol (
CurrentImageHandle,
&gEfiLoadedImageProtocolGuid,
&LoadImage
);
if (EFI_ERROR (Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.HandleProtocol - build environment",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
return Status;
}
EntireFileName = NULL;
EntireFileName = PoolPrint (L"%s\\%s", mFilePath, FileName);
FilePath = FileDevicePath (LoadImage->DeviceHandle, EntireFileName);
if (FilePath == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = gtBS->LoadImage (
FALSE,
CurrentImageHandle,
FilePath,
NULL,
0,
StartImage
);
if (EFI_ERROR (Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.LoadImage - build environment",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
gtBS->FreePool (EntireFileName);
gtBS->FreePool (FilePath);
return Status;
}
Status = gtBS->StartImage (*StartImage, 0, NULL);
if (EFI_ERROR (Status)) {
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_FAILED,
gTestGenericFailureGuid,
L"BS.StartImage - build environment",
L"%a:%d:Status - %r",
__FILE__,
(UINTN)__LINE__,
Status
);
}
gtBS->FreePool (EntireFileName);
gtBS->FreePool (FilePath);
return Status;
}
EFI_STATUS
HDiskImageRead (
IN CHAR16 *DeviceName,
IN UINTN Offset,
IN UINTN Size,
IN BOOLEAN Recover
)
/*++
Routine Description:
Read a disk from disk into HBufferImage
Arguments:
DeviceName - filename to read
Offset - The offset
Size - The size
Recover - if is for recover, no information print
Returns:
EFI_SUCCESS
EFI_LOAD_ERROR
EFI_OUT_OF_RESOURCES
EFI_INVALID_PARAMETER
--*/
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_BLOCK_IO_PROTOCOL *BlkIo;
EFI_STATUS Status;
VOID *Buffer;
CHAR16 *Str;
UINTN Bytes;
HEFI_EDITOR_LINE *Line;
UINT64 ByteOffset;
HEFI_EDITOR_ACTIVE_BUFFER_TYPE BufferTypeBackup;
BufferTypeBackup = HBufferImage.BufferType;
HBufferImage.BufferType = DISK_BUFFER;
DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) ShellGetMap (DeviceName);
if (DevicePath == NULL) {
HMainStatusBarSetStatusString (L"Cannot Find Device");
return EFI_INVALID_PARAMETER;
}
//
// get blkio interface
//
Status = LibDevicePathToInterface (
&gEfiBlockIoProtocolGuid,
DevicePath,
&BlkIo
);
if (EFI_ERROR (Status)) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return Status;
}
//
// if Offset exceeds LastBlock,
// return error
//
if (Offset > BlkIo->Media->LastBlock || Offset + Size > BlkIo->Media->LastBlock) {
HMainStatusBarSetStatusString (L"Invalid Offset + Size");
return EFI_LOAD_ERROR;
}
Bytes = BlkIo->Media->BlockSize * Size;
Buffer = AllocatePool (Bytes);
if (Buffer == NULL) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return EFI_OUT_OF_RESOURCES;
}
ByteOffset = MultU64x32 (Offset, BlkIo->Media->BlockSize);
//
// read from disk
//
Status = BlkIo->ReadBlocks (
BlkIo,
BlkIo->Media->MediaId,
Offset,
Bytes,
Buffer
);
if (EFI_ERROR (Status)) {
FreePool (Buffer);
HMainStatusBarSetStatusString (L"Read Disk Failed");
return EFI_LOAD_ERROR;
}
HBufferImageFree ();
//
// convert buffer to line list
//
Status = HBufferImageBufferToList (Buffer, Bytes);
FreePool (Buffer);
if (EFI_ERROR (Status)) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return Status;
}
Status = HDiskImageSetDiskNameOffsetSize (DeviceName, Offset, Size);
if (EFI_ERROR (Status)) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return EFI_OUT_OF_RESOURCES;
}
//
// initialize some variables
//
HDiskImage.BlockSize = BlkIo->Media->BlockSize;
HBufferImage.DisplayPosition.Row = TEXT_START_ROW;
HBufferImage.DisplayPosition.Column = HEX_POSITION;
HBufferImage.MousePosition.Row = TEXT_START_ROW;
HBufferImage.MousePosition.Column = HEX_POSITION;
HBufferImage.LowVisibleRow = 1;
HBufferImage.HighBits = TRUE;
HBufferImage.BufferPosition.Row = 1;
HBufferImage.BufferPosition.Column = 1;
if (!Recover) {
Str = PoolPrint (L"%d Lines Read", HBufferImage.NumLines);
if (Str == NULL) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return EFI_OUT_OF_RESOURCES;
}
HMainStatusBarSetStatusString (Str);
HEditorFreePool (Str);
HMainEditor.SelectStart = 0;
HMainEditor.SelectEnd = 0;
}
//
// has line
//
if (HBufferImage.Lines != NULL) {
HBufferImage.CurrentLine = CR (
HBufferImage.ListHead->Flink,
HEFI_EDITOR_LINE,
Link,
EFI_EDITOR_LINE_LIST
);
} else {
//
// create a dummy line
//
Line = HBufferImageCreateLine ();
if (Line == NULL) {
HMainStatusBarSetStatusString (L"Read Disk Failed");
return EFI_OUT_OF_RESOURCES;
}
HBufferImage.CurrentLine = Line;
}
HBufferImage.Modified = FALSE;
HBufferImageNeedRefresh = TRUE;
HBufferImageOnlyLineNeedRefresh = FALSE;
HBufferImageMouseNeedRefresh = TRUE;
return EFI_SUCCESS;
}
EFI_STATUS
simple_dir_filter(EFI_HANDLE image, CHAR16 *name, CHAR16 *filter,
CHAR16 ***result, int *count, EFI_FILE_INFO **entries)
{
EFI_STATUS status;
int tot, offs = StrLen(filter), i, c, filtercount = 1;
EFI_FILE_INFO *next;
void *ptr;
CHAR16 *newfilter = AllocatePool((StrLen(filter) + 1) * sizeof(CHAR16)),
**filterarr;
if (!newfilter)
return EFI_OUT_OF_RESOURCES;
/* just in case efi ever stops writeable strings */
StrCpy(newfilter, filter);
for (i = 0; i < offs; i++) {
if (filter[i] == '|')
filtercount++;
}
filterarr = AllocatePool(filtercount * sizeof(void *));
if (!filterarr)
return EFI_OUT_OF_RESOURCES;
c = 0;
filterarr[c++] = newfilter;
for (i = 0; i < offs; i++) {
if (filter[i] == '|') {
newfilter[i] = '\0';
filterarr[c++] = &newfilter[i+1];
}
}
*count = 0;
status = simple_dir_read_all(image, name, entries, &tot);
if (status != EFI_SUCCESS)
goto out;
ptr = next = *entries;
for (i = 0; i < tot; i++) {
int len = StrLen(next->FileName);
for (c = 0; c < filtercount; c++) {
offs = StrLen(filterarr[c]);
if (StrCmp(&next->FileName[len - offs], filterarr[c]) == 0
|| (next->Attribute & EFI_FILE_DIRECTORY)) {
(*count)++;
break;
}
}
ptr += OFFSET_OF(EFI_FILE_INFO, FileName) + (len + 1)*sizeof(CHAR16);
next = ptr;
}
if (*count)
*result = AllocatePool(((*count) + 1) * sizeof(void *));
else
*result = AllocatePool(2 * sizeof(void *));
*count = 0;
ptr = next = *entries;
for (i = 0; i < tot; i++) {
int len = StrLen(next->FileName);
if (StrCmp(next->FileName, L".") == 0)
/* ignore . directory */
goto next;
if (next->Attribute & EFI_FILE_DIRECTORY) {
(*result)[(*count)] = PoolPrint(L"%s/", next->FileName);
if (!(*result)[(*count)]) {
Print(L"Failed to allocate buffer");
return EFI_OUT_OF_RESOURCES;
}
(*count)++;
goto next;
}
for (c = 0; c < filtercount; c++) {
offs = StrLen(filterarr[c]);
if (StrCmp(&next->FileName[len - offs], filterarr[c]) == 0) {
(*result)[(*count)] = StrDuplicate(next->FileName);
if (!(*result)[(*count)]) {
Print(L"Failed to allocate buffer");
return EFI_OUT_OF_RESOURCES;
}
(*count)++;
} else {
continue;
}
break;
}
next:
if (StrCmp(next->FileName, L"..") == 0) {
/* place .. directory first */
CHAR16 *tmp = (*result)[(*count) - 1];
(*result)[(*count) - 1] = (*result)[0];
(*result)[0] = tmp;
}
ptr += OFFSET_OF(EFI_FILE_INFO, FileName) + (len + 1)*sizeof(CHAR16);
next = ptr;
}
if (*count == 0) {
/* no entries at all ... can happen because top level dir has no . or .. */
(*result)[(*count)++] = L"./";
}
(*result)[*count] = NULL;
status = EFI_SUCCESS;
out:
if (status != EFI_SUCCESS) {
if (*entries)
FreePool(*entries);
*entries = NULL;
if (*result)
FreePool(*result);
*result = NULL;
}
return status;
}
EFI_STATUS
LoadSupportFiles (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN CHAR16 *FilePath,
IN BOOLEAN Recursive,
OUT EFI_LIST_ENTRY *SupportFileList
)
/*++
Routine Description:
Load all test support files.
Arguments:
DevicePath - Device path of the files.
FilePath - Path of the files.
Recursive - Recursively.
SupportFileList - Pointer to the support file list.
Returns:
EFI_SUCCESS - Successfully.
Other value - Something failed.
--*/
{
EFI_STATUS Status;
EFI_HANDLE DeviceHandle;
EFI_FILE_HANDLE RootDir;
EFI_FILE_HANDLE SupportDir;
CHAR16 *SubDir;
CHAR16 *FileName;
UINTN FileInfoSize;
EFI_FILE_INFO *FileInfo;
EFI_SCT_TEST_FILE *SupportFile;
EFI_DEVICE_PATH_PROTOCOL *RemainderPath;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Vol;
//
// Check parameters
//
if ((DevicePath == NULL) || (FilePath == NULL) || (SupportFileList == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Debug information
//
EFI_SCT_DEBUG ((EFI_SCT_D_TRACE, L"Load support files from <%s>", FilePath));
//
// Locate the device handle from the device path
//
RemainderPath = DevicePath;
Status = BS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&RemainderPath,
&DeviceHandle
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Locate device handle - %r", Status));
return Status;
}
//
// Locate the volume of the file system
//
Status = BS->HandleProtocol (
DeviceHandle,
&gEfiSimpleFileSystemProtocolGuid,
&Vol
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Locate file system - %r", Status));
return Status;
}
//
// Open the root volume
//
Status = Vol->OpenVolume (Vol, &RootDir);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open root volume - %r", Status));
return Status;
}
//
// Open the support directory
//
Status = RootDir->Open (
RootDir,
&SupportDir,
FilePath,
EFI_FILE_MODE_READ,
EFI_FILE_DIRECTORY
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open support directory - %r", Status));
RootDir->Close (RootDir);
return Status;
}
RootDir->Close (RootDir);
//
// Allocate memory for the entries in the directory
//
FileInfoSize = sizeof(EFI_FILE_INFO) + 1024;
Status = BS->AllocatePool (
EfiBootServicesData,
FileInfoSize,
&FileInfo
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Allocate pool - %r", Status));
SupportDir->Close (SupportDir);
return Status;
}
//
// Walk through each file in the directory
//
while (TRUE) {
//
// Read a file entry
//
FileInfoSize = sizeof(EFI_FILE_INFO) + 1024;
Status = SupportDir->Read (
SupportDir,
&FileInfoSize,
FileInfo
);
if (EFI_ERROR (Status) || (FileInfoSize == 0)) {
break;
}
if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
//
// This is a file
//
if (SctStrEndWith (FileInfo->FileName, L".efi")) {
//
// Load the support file
//
FileName = PoolPrint (L"%s\\%s", FilePath, FileInfo->FileName);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
break;
}
Status = LoadSingleSupportFile (
DevicePath,
FileName,
&SupportFile
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Load a support file - %r", Status));
BS->FreePool (FileName);
continue;
}
BS->FreePool (FileName);
//
// Add the support file to the support file list
//
InsertTailList (SupportFileList, &SupportFile->Link);
}
} else {
//
// This is a directory
//
if (Recursive) {
//
// Skip the '.' and '..' dir
//
if ((StrCmp (FileInfo->FileName, L".") == 0) ||
(StrCmp (FileInfo->FileName, L"..") == 0)) {
continue;
}
//
// Load the support files under the sub directory
//
SubDir = PoolPrint (L"%s\\%s", FilePath, FileInfo->FileName);
if (SubDir == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
break;
}
Status = LoadSupportFiles (
DevicePath,
SubDir,
Recursive,
SupportFileList
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Load support files - %r", Status));
BS->FreePool (SubDir);
continue;
}
BS->FreePool (SubDir);
}
}
}
//
// Free resources
//
BS->FreePool (FileInfo);
SupportDir->Close (SupportDir);
//
// Done
//
return EFI_SUCCESS;
}
EFI_STATUS
OpenStandardSupportFiles (
VOID
)
/*++
Routine Description:
Open the standard support files.
Returns:
EFI_SUCCESS - Successfully.
Other value - Something failed.
--*/
{
EFI_STATUS Status;
CHAR16 *FileName;
//
// Debug information
//
EFI_SCT_DEBUG ((EFI_SCT_D_TRACE, L"Open standard support files"));
//
// EFI standard test support file
//
Status = OpenSingleSupportFile (
&gEfiStandardTestLibraryGuid,
&gFT->StslProtocol,
&gFT->StslInterface
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open standard test - %r", Status));
CloseStandardSupportFiles ();
return Status;
}
//
// EFI test profile support file
//
Status = OpenSingleSupportFile (
&gEfiTestProfileLibraryGuid,
&gFT->TplProtocol,
NULL
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open test profile - %r", Status));
CloseStandardSupportFiles ();
return Status;
}
//
// EFI test recovery support file
//
Status = OpenSingleSupportFile (
&gEfiTestRecoveryLibraryGuid,
&gFT->TrlProtocol,
&gFT->TrlInterface
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open test recovery - %r", Status));
CloseStandardSupportFiles ();
return Status;
}
//
// EFI test logging support file
//
Status = OpenSingleSupportFile (
&gEfiTestLoggingLibraryGuid,
&gFT->TllProtocol,
&gFT->TllInterface
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open test logging - %r", Status));
CloseStandardSupportFiles ();
return Status;
}
//
// Set the config data of test profile
//
Status = gFT->TplProtocol->EfiSetSystemDevicePath (
gFT->TplProtocol,
gFT->DevicePath,
gFT->FilePath
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Set profile config - %r", Status));
CloseStandardSupportFiles ();
return Status;
}
//
// Set the config data of test recovery
//
FileName = PoolPrint (L"%s\\%s", gFT->FilePath, EFI_SCT_FILE_RECOVERY);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
CloseStandardSupportFiles ();
return EFI_OUT_OF_RESOURCES;
}
Status = gFT->TrlInterface->SetConfig (
gFT->TrlInterface,
gFT->DevicePath,
FileName
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Set recovery config - %r", Status));
CloseStandardSupportFiles ();
BS->FreePool (FileName);
return Status;
}
BS->FreePool (FileName);
//
// Done
//
return EFI_SUCCESS;
}
EFI_STATUS
CreateStandardMenuPage (
IN CHAR16 *MenuItemHeaderText,
OUT EFI_MENU_PAGE **Page
)
/*++
Routine Description:
Create a standard menu page
Arguments:
MenuItemHeaderText - A text string of menu item header
Page - A pointer to the standard menu page
Returns:
EFI_SUCCESS - Create successfully
Other Values - Something failed
--*/
{
EFI_STATUS Status;
EFI_MENU_PAGE *MyPage;
//
// Allocate memory for the menu page
//
Status = BS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_MENU_PAGE),
(VOID **)&MyPage
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Page
//
MyPage->BackColor = EFI_BLACK;
MyPage->HasHeader = TRUE;
MyPage->HasBody = TRUE;
MyPage->HasFooter = TRUE;
MyPage->Parent = NULL;
//
// Header
//
MyPage->Header.HeaderString.Text = PoolPrint (L"%s", EFI_SCT_NAME);
MyPage->Header.HeaderString.TextColor = EFI_WHITE;
MyPage->Header.HeaderString.Align = EFI_ALIGNMENT_MIDDLE;
MyPage->Header.HeaderRect.TopLeft.Row = 0;
MyPage->Header.HeaderRect.TopLeft.Col = 0;
MyPage->Header.HeaderRect.BottomRight.Row = EFI_MENU_HEADER_ROWS;
MyPage->Header.HeaderRect.BottomRight.Col = mCols - 1;
//
// Body
//
MyPage->Body.BackColor = EFI_BACKGROUND_LIGHTGRAY;
MyPage->Body.ForeColor = EFI_BLUE;
MyPage->Body.BodyRect.TopLeft.Row = EFI_MENU_HEADER_ROWS;
MyPage->Body.BodyRect.TopLeft.Col = 0;
MyPage->Body.BodyRect.BottomRight.Row = mRows - EFI_MENU_FOOTER_ROWS - 1;
MyPage->Body.BodyRect.BottomRight.Col = mCols - 1;
MyPage->Body.SplitPoint.Row = EFI_MENU_HEADER_ROWS + 2;
MyPage->Body.SplitPoint.Col = mCols - EFI_MENU_DESCRIPTOR_COLS - 1;
MyPage->Body.MenuItemHeader.Text = StrDuplicate (MenuItemHeaderText);
MyPage->Body.MenuItemHeader.TextColor = EFI_BLACK;
MyPage->Body.MenuItemHeader.Align = EFI_ALIGNMENT_MIDDLE;
MyPage->Body.DescriptionHeader.Text = StrDuplicate (L"Description");
MyPage->Body.DescriptionHeader.TextColor = EFI_BLACK;
MyPage->Body.DescriptionHeader.Align = EFI_ALIGNMENT_MIDDLE;
MyPage->Body.HasScrollBar = FALSE;
MyPage->Body.ScrollBar = NULL;
MyPage->Body.ItemList = NULL;
MyPage->Body.CurrentSelected = NULL;
MyPage->Body.FirstInDisplay = NULL;
MyPage->Body.LastInDisplay = NULL;
//
// Footer
//
MyPage->Footer.FooterRect.TopLeft.Row = mRows - EFI_MENU_FOOTER_ROWS;
MyPage->Footer.FooterRect.TopLeft.Col = 0;
MyPage->Footer.FooterRect.BottomRight.Row = mRows - 1;
MyPage->Footer.FooterRect.BottomRight.Col = mCols - 1;
MyPage->Footer.HotKeyList = NULL;
//
// Build a new standard menu page successfully
//
*Page = MyPage;
return EFI_SUCCESS;
}
EFI_STATUS
SctReportConfig (
OUT UINTN *BufferSize,
OUT VOID **Buffer
)
/*++
Routine Description:
Report the system configuration via shell commands.
--*/
{
EFI_STATUS Status;
UINTN Index;
CHAR16 *CmdLine;
CHAR16 *FileName;
CHAR16 *CmdList[] = {
L"map -v",
L"memmap",
L"pci",
L"ver",
L"dh -v",
L""
};
//
// Record an empty line to a file via shell command
//
CmdLine = PoolPrint (
L"ECHO \" \" >a %s",
EFI_SCT_FILE_CFG
);
if (CmdLine == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = ShellExecute (
gFT->ImageHandle,
CmdLine,
FALSE
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"ShellExecute: %s - %r", CmdLine, Status));
BS->FreePool (CmdLine);
return Status;
}
BS->FreePool (CmdLine);
//
// For each shell command
//
for (Index = 0; CmdList[Index][0] != L'\0'; Index++) {
//
// Record the command to a file via shell command
//
CmdLine = PoolPrint (
L"ECHO \"%s\" >>a %s",
CmdList[Index],
EFI_SCT_FILE_CFG
);
if (CmdLine == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = ShellExecute (
gFT->ImageHandle,
CmdLine,
FALSE
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"ShellExecute: %s - %r", CmdLine, Status));
BS->FreePool (CmdLine);
return Status;
}
BS->FreePool (CmdLine);
//
// Get the system configuration to a file via shell command
//
CmdLine = PoolPrint (
L"%s >>a %s",
CmdList[Index],
EFI_SCT_FILE_CFG
);
if (CmdLine == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = ShellExecute (
gFT->ImageHandle,
CmdLine,
FALSE
);
if (EFI_ERROR (Status)) {
//
// Just record as a debug info. It is acceptable for this command return
// an error status
//
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"ShellExecute: %s - %r", CmdLine, Status));
}
BS->FreePool (CmdLine);
}
//
// Get the system configuration from the file
//
FileName = PoolPrint (
L"%s\\%s",
gFT->FilePath,
EFI_SCT_FILE_CFG
);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = ReadFileToBuffer (
gFT->DevicePath,
FileName,
BufferSize,
(VOID **)Buffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"ReadFileToBuffer: %s - %r", FileName, Status));
BS->FreePool (FileName);
return Status;
}
BS->FreePool (FileName);
//
// Done
//
return EFI_SUCCESS;
}
BOOLEAN
AutoJudgeGop (
IN UINTN X,
IN UINTN Y,
IN UINTN Seconds,
IN BOOLEAN Default,
IN CHAR16 *Message
)
/*++
Routine Description:
Assistant function to auto judge the user's choice, correct or uncorrect?
Arguments:
X - The coordination of X
Y - The coordination of Y
Seconds - The time to wait the user for judging
Default - Default value(True/False) for auto judge(Yes/No)
Message - The message printed to the serial port to remind the user
Returns:
TRUE/FALSE standing for correct/uncorrect choice respectively
--*/
{
EFI_STATUS Status;
EFI_EVENT WaitList[2];
UINTN NoWait;
UINTN WaitIndex;
EFI_INPUT_KEY Key;
BOOLEAN PressYes;
CHAR16 *Msg;
UINTN AutoJudge;
Msg = NULL;
AutoJudge = 1;
Status = gtBS->CreateEvent (
EFI_EVENT_TIMER,
0,
NULL,
NULL,
&TimerEvent
);
if (EFI_ERROR (Status)) {
DEBUG ((EFI_D_ERROR, "Create event. %a:%d:%r\n", __FILE__, (UINTN)__LINE__, Status));
return FALSE;
}
//
// Set 1 second periodic timer
//
Status = gtBS->SetTimer (TimerEvent, TimerPeriodic, 10000000);
//
// Set up a wait list for a key and the timer
//
NoWait = 0;
WaitList[NoWait++] = TimerEvent;
WaitList[NoWait++] = gtST->ConIn->WaitForKey;
PressYes = Default;
//
// Wait for either
//
PrintAt (Y, X, Message);
while (AutoJudge && (Seconds > 0)) {
if (Default == TRUE) {
Msg = PoolPrint (L"Yes/No?(Auto judge as Yes in %d seconds ", Seconds);
} else {
Msg = PoolPrint (L"Yes/No?(Auto judge as No in %d seconds ", Seconds);
}
if (Msg == NULL) {
return FALSE;
} else {
PrintAt (Y + 40, X, Msg);
FreePool (Msg);
}
Status = gtBS->WaitForEvent (NoWait, WaitList, &WaitIndex);
switch (WaitIndex) {
case 0:
Seconds--;
if (Seconds <= 0) {
//
// To stop loop
//
AutoJudge = 0;
}
break;
case 1:
//
// Read the key
//
Status = gtST->ConIn->ReadKeyStroke (gtST->ConIn, &Key);
APrint ((char *) (&Key.UnicodeChar));
switch (Key.UnicodeChar) {
case 'Y':
case 'y':
AutoJudge = 0;
PressYes = TRUE;
break;
case 'N':
case 'n':
AutoJudge = 0;
PressYes = FALSE;
break;
default:
break;
}
break;
default:
break;
//
// bad WaitIndex response
//
}
}
//
// Print (L"\r\n");
//
// Done, cancle periodic timer event
//
gtBS->CloseEvent (TimerEvent);
return PressYes;
}
EFI_STATUS
LoadAndStartImage (
EFI_HANDLE CurrentImageHandle,
CHAR16 *FileName,
EFI_HANDLE *StartImage
)
{
EFI_STATUS Status;
EFI_LOADED_IMAGE_PROTOCOL *LoadImage;
EFI_DEVICE_PATH_PROTOCOL *FileDevPath;
CHAR16 *EntireFileName;
CHAR16 *FilePath;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_TEST_PROFILE_LIBRARY_PROTOCOL *ProfileLib;
Status = gtBS->HandleProtocol (
CurrentImageHandle,
&gEfiLoadedImageProtocolGuid,
&LoadImage
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Use profile lib at here just for less effect on the current system. It is
// dependent on the implementation of test framework. So need to be updated
// later.
//
Status = gtBS->LocateProtocol (
&gEfiTestProfileLibraryGuid,
NULL,
&ProfileLib
);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Get the system device path and file path
//
Status = ProfileLib->EfiGetSystemDevicePath (
ProfileLib,
&DevicePath,
&FilePath
);
if (EFI_ERROR (Status)) {
return Status;
}
EntireFileName = PoolPrint (L"%s\\%s\\%s", FilePath, DEPENDENCY_DIR_NAME, FileName);
FreePool (FilePath);
FreePool (DevicePath);
FileDevPath = FileDevicePath (LoadImage->DeviceHandle, EntireFileName);
FreePool (EntireFileName);
if (FileDevPath == NULL) {
return EFI_OUT_OF_RESOURCES;
}
Status = gtBS->LoadImage (
FALSE,
CurrentImageHandle,
FileDevPath,
NULL,
0,
StartImage
);
gtBS->FreePool (FileDevPath);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gtBS->StartImage (*StartImage,0,NULL);
return Status;
}
/**
* Reclaim test with system reset.
* @param StandardLib A pointer to EFI_STANDARD_TEST_LIBRARY_PROTOCOL
* instance.
* @param RecoveryLib A pointer to EFI_TEST_RECOVERY_LIBRARY_PROTOCOL
* instance.
* @param LoggingLib A pointer to EFI_TEST_LOGGING_LIBRARY_PROTOCOL
* instance.
* @return EFI_SUCCESS Successfully.
* @return Other value Something failed.
*/
EFI_STATUS
OverflowStressTestSub1 (
IN EFI_RUNTIME_SERVICES *RT,
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
IN EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib,
IN EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib
)
{
EFI_STATUS Status;
UINTN Index;
CHAR16 *VariableName;
UINTN DataIndex;
UINT8 Data[MAX_BUFFER_SIZE];
UINTN RecoveryDataSize;
UINT8 *RecoveryData;
//
// Trace ...
//
if (LoggingLib != NULL) {
LoggingLib->EnterFunction (
LoggingLib,
L"OverflowStressTestSub2",
L"TDS 5.2.2.2"
);
}
//
// Allocate memory for recovery data
//
Status = gtBS->AllocatePool (
EfiLoaderData,
1024,
(VOID **)&RecoveryData
);
if (EFI_ERROR(Status)) {
if (LoggingLib != NULL) {
LoggingLib->ExitFunction (
LoggingLib,
L"OverflowStressTestSub2",
L"TDS 5.2.2.2 - Cannot allocate memory for recovery data\n"
);
}
return Status;
}
//
// Read reset record
//
RecoveryDataSize = 1024;
Status = RecoveryLib->ReadResetRecord (
RecoveryLib,
&RecoveryDataSize,
RecoveryData
);
if (!EFI_ERROR(Status) && (RecoveryDataSize > 1)) {
switch (RecoveryData[1]) {
case 2:
goto step2;
default:
goto step3;
}
}
//
// Insert variables until no enough storage
//
for (Index = 0; Index < 10000; Index++) {
//
// Insert a variable
//
VariableName = PoolPrint (L"TestVariable_%d", Index);
for (DataIndex = 0; DataIndex < 10; DataIndex++) {
Data[DataIndex] = (UINT8)DataIndex;
}
Status = RT->SetVariable (
VariableName, // VariableName
&gTestVendor1Guid, // VendorGuid
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
10, // DataSize
Data // Data
);
gtBS->FreePool (VariableName);
if (EFI_ERROR(Status)) {
break;
}
}
//
// Write reset record
//
RecoveryData[0] = 2;
RecoveryData[1] = 2;
RecoveryLib->WriteResetRecord (RecoveryLib, 2, RecoveryData);
//
// Print out some information to avoid the user thought it is an error
//
Print (L"System will cold reset after 1 second...");
gtBS->Stall (1000000);
gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
//
// After system reset
//
step2:
RecoveryLib->WriteResetRecord (RecoveryLib, 0, NULL);
//
// Delete variables until all added have been deleted
//
for (Index = 0; Index < 10000; Index++) {
//
// Delete a variable
//
VariableName = PoolPrint (L"TestVariable_%d", Index);
Status = RT->SetVariable (
VariableName, // VariableName
&gTestVendor1Guid, // VendorGuid
EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
0, // DataSize
Data // Data
);
gtBS->FreePool (VariableName);
if (EFI_ERROR(Status)) {
break;
}
}
//
// Record assertion (If system can restart, test passed)
//
StandardLib->RecordAssertion (
StandardLib,
EFI_TEST_ASSERTION_PASSED,
gVariableServicesBbTestStressAssertionGuid006,
L"RT.SetVariable - Reclaim after system reset",
L"%a:%d:Number - %d",
__FILE__,
(UINTN)__LINE__,
Index
);
//
// Free resources
//
step3:
gtBS->FreePool (RecoveryData);
if (LoggingLib != NULL) {
LoggingLib->ExitFunction (
LoggingLib,
L"OverflowStressTestSub2",
L"TDS 5.2.2.2"
);
}
//
// Done
//
return EFI_SUCCESS;
}
EFI_STATUS
GetProtocolAssertion (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN CHAR16 *FilePath,
OUT UINT32 *PassNumber,
OUT UINT32 *WarnNumber,
OUT UINT32 *FailNumber
)
/*++
Routine Description:
Get the assertion number of a protocol or service.
Arguments:
DevicePath - Device path of the key files.
FilePath - Path of the key files.
PassNumber - The number of passed assertions.
WarnNumber - The number of warning assertions.
FailNumber - The number of failed assertions.
Returns:
EFI_SUCCESS - Get instance assertion number successfully.
--*/
{
EFI_STATUS Status;
EFI_HANDLE DeviceHandle;
EFI_FILE_HANDLE RootDir;
EFI_FILE_HANDLE LogDir;
UINTN FileInfoSize;
EFI_FILE_INFO *FileInfo;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Vol;
EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath;
UINTN BufferSize;
CHAR16 *Buffer;
CHAR16 *FileName;
CHAR16 *LogName;
CHAR16 *TempName;
CHAR16 *CaseIndexStr;
CHAR16 *CaseIterationStr;
//
// Check parameters
//
if ((DevicePath == NULL) || (FilePath == NULL) ||
(PassNumber == NULL) || (WarnNumber == NULL) ||
(FailNumber == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// Locate the device handle
//
RemainingDevicePath = DevicePath;
Status = BS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&RemainingDevicePath,
&DeviceHandle
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Locate device path - %r", Status));
return Status;
}
//
// Locate the simple file system
//
Status = BS->HandleProtocol (
DeviceHandle,
&gEfiSimpleFileSystemProtocolGuid,
&Vol
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Handle protocol - %r", Status));
return Status;
}
//
// Open the root directory
//
Status = Vol->OpenVolume (Vol, &RootDir);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open volume - %r", Status));
return Status;
}
//
// Open the log directory
//
Status = RootDir->Open (
RootDir,
&LogDir,
FilePath,
EFI_FILE_MODE_READ,
EFI_FILE_DIRECTORY
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Open directory - %r", Status));
RootDir->Close (RootDir);
return Status;
}
RootDir->Close (RootDir);
//
// Allocate memory for the entries in the directory
//
FileInfoSize = sizeof(EFI_FILE_INFO) + 1024;
Status = BS->AllocatePool (
EfiBootServicesData,
FileInfoSize,
&FileInfo
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"Allocate pool - %r", Status));
LogDir->Close (LogDir);
return Status;
}
//
// Walk through each file in the directory
//
while (TRUE) {
//
// Read a file entry
//
FileInfoSize = sizeof(EFI_FILE_INFO) + 1024;
Status = LogDir->Read (
LogDir,
&FileInfoSize,
FileInfo
);
if (EFI_ERROR (Status) || (FileInfoSize == 0)) {
break;
}
if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {
//
// This is a file
//
//
// Only deal with the EFI key file
//
if (!SctStrEndWith (FileInfo->FileName, L".ekl")) {
continue;
}
//
// Read the file to a buffer
//
FileName = PoolPrint (L"%s\\%s", FilePath, FileInfo->FileName);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = ReadFileToBuffer (
DevicePath,
FileName,
&BufferSize,
&Buffer
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"Read file to buffer - %r", Status));
BS->FreePool (FileName);
continue;
}
BS->FreePool (FileName);
//
// Get the index and iteration from the file name
//
TempName = StrDuplicate (FileInfo->FileName);
//
// The following function didn't allocate memory for CaseIndexStr and
// CaseIterationStr. So DON'T free the TempName before these two strings
// are still used.
//
Status = GetIndexFromFileName (
TempName,
&CaseIndexStr,
&CaseIterationStr
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"Get index from file name - %r", Status));
BS->FreePool (TempName);
continue;
}
//
// Load the buffer to the report information structure
//
LogName = SctStrEndReplace (FileInfo->FileName, L"log");
Status = LoadReportInfor (
CaseIndexStr,
CaseIterationStr,
Buffer,
LogName
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"Load report infor - %r", Status));
BS->FreePool (TempName);
BS->FreePool (LogName);
BS->FreePool (Buffer);
continue;
}
BS->FreePool (TempName);
BS->FreePool (LogName);
BS->FreePool (Buffer);
//
// Get the assertion number (free the GUID assertion table)
//
Status = GetAssertionNumber (PassNumber, WarnNumber, FailNumber);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"Get assertion number - %r", Status));
continue;
}
} else {
//
// This is a directory
//
//
// Skip the '.' and '..' dir
//
if ((StrCmp (FileInfo->FileName, L".") == 0) ||
(StrCmp (FileInfo->FileName, L"..") == 0)) {
continue;
}
//
// Get the report information from the sub directories
//
FileName = PoolPrint (L"%s\\%s", FilePath, FileInfo->FileName);
if (FileName == NULL) {
EFI_SCT_DEBUG ((EFI_SCT_D_ERROR, L"PoolPrint: Out of resources"));
return EFI_OUT_OF_RESOURCES;
}
Status = GetProtocolAssertion (
DevicePath,
FileName,
PassNumber,
WarnNumber,
FailNumber
);
if (EFI_ERROR (Status)) {
EFI_SCT_DEBUG ((EFI_SCT_D_DEBUG, L"Get protocol assertion - %r", Status));
BS->FreePool (FileName);
continue;
}
BS->FreePool (FileName);
}
}
//
// Free resources
//
BS->FreePool (FileInfo);
LogDir->Close (LogDir);
//
// Done
//
return EFI_SUCCESS;
}
