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; }