/** * TDS 5.2 - Entry point for Variable Overflow Stress Test. * @param This A pointer to the EFI_BB_TEST_PROTOCOL instance. * @param ClientInterface A pointer to the interface to be tested. * @param TestLevel Test "thoroughness" control. * @param SupportHandle A handle containing support protocols. * @return EFI_SUCCESS Successfully. * @return Other value Something failed. */ EFI_STATUS OverflowStressTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STATUS Status; EFI_RUNTIME_SERVICES *RT; EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib; UINTN RecoveryDataSize; UINT8 *RecoveryData; // // Get test support library interfaces // Status = GetTestSupportLibrary ( SupportHandle, &StandardLib, &RecoveryLib, &LoggingLib ); if (EFI_ERROR(Status)) { return Status; } RT = (EFI_RUNTIME_SERVICES *)ClientInterface; // // Allocate memory for recovery data // Status = gtBS->AllocatePool ( EfiLoaderData, 1024, (VOID **)&RecoveryData ); if (EFI_ERROR(Status)) { return Status; } // // Read reset record // RecoveryDataSize = 1024; Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &RecoveryDataSize, RecoveryData ); if (!EFI_ERROR(Status) && (RecoveryDataSize > 0)) { switch (RecoveryData[0]) { case 2: goto step2; default: goto step3; } } // // Reclaim test with system reset // step2: Status = OverflowStressTestSub1 (RT, StandardLib, RecoveryLib, LoggingLib); // // Free resources // step3: gtBS->FreePool (RecoveryData); // // Done // return EFI_SUCCESS; }
// // TDS 4.1 // EFI_STATUS BBTestResetSystemInterfaceTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_STATUS Status; EFI_TEST_ASSERTION AssertionType; UINTN Index; EFI_TPL OldTpl; UINT8 Buffer[1024]; RESET_DATA *ResetData; UINTN Size; // // Get the Standard Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiStandardTestLibraryGuid, &StandardLib ); if (EFI_ERROR(Status)) { return Status; } // // Get the Recovery Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiTestRecoveryLibraryGuid, &RecoveryLib ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"BS.HandleProtocol - Handle recovery library", L"%a:%d:Status - %r", __FILE__, __LINE__, Status ); return Status; } // // Read reset record // Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &Size, Buffer ); ResetData = (RESET_DATA *)Buffer; if (EFI_ERROR(Status) || (Size < sizeof(RESET_DATA))) { // // Step 1 // } else if (ResetData->Step == 1) { // // Step 2 // if (ResetData->TplIndex < TPL_ARRAY_SIZE) { Index = ResetData->TplIndex; AssertionType = EFI_TEST_ASSERTION_PASSED; goto ResetSystemStep2; } } else if (ResetData->Step == 2) { // // Step 3 // if (ResetData->TplIndex < TPL_ARRAY_SIZE) { Index = ResetData->TplIndex; AssertionType = EFI_TEST_ASSERTION_PASSED; goto ResetSystemStep3; } } else { return EFI_LOAD_ERROR; } for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) { // // 4.1.2.1 ResetSystem must succeed when ResetType is EfiResetCold // ResetData->Step = 1; ResetData->TplIndex = Index; Status = RecoveryLib->WriteResetRecord ( RecoveryLib, sizeof (RESET_DATA), Buffer ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"TestRecoveryLib - WriteResetRecord", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); return Status; } // // 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); OldTpl = gtBS->RaiseTPL (TplArray[Index]); gtRT->ResetSystem ( EfiResetCold, EFI_SUCCESS, 0, NULL ); gtBS->RestoreTPL (OldTpl); AssertionType = EFI_TEST_ASSERTION_FAILED; ResetSystemStep2: StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gMiscRuntimeServicesInterfaceTestAssertionGuid001: \ (Index == 1? \ gMiscRuntimeServicesBBTestFunctionAssertionGuid001: \ gMiscRuntimeServicesBBTestFunctionAssertionGuid002), L"RT.ResetSystem - EfiResetCold", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); // // 4.1.2.2 ResetSystem must succeed when ResetType is EfiResetWarm // ResetData->Step = 2; ResetData->TplIndex = Index; Status = RecoveryLib->WriteResetRecord ( RecoveryLib, sizeof (RESET_DATA), Buffer ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"TestRecoveryLib - WriteResetRecord", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); return Status; } // // Print out some information to avoid the user thought it is an error // Print (L"System will warm reset after 1 second..."); gtBS->Stall (1000000); OldTpl = gtBS->RaiseTPL (TplArray[Index]); gtRT->ResetSystem ( EfiResetWarm, EFI_SUCCESS, 0, NULL ); gtBS->RestoreTPL (OldTpl); AssertionType = EFI_TEST_ASSERTION_FAILED; ResetSystemStep3: StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gMiscRuntimeServicesInterfaceTestAssertionGuid002: \ (Index == 1? \ gMiscRuntimeServicesBBTestFunctionAssertionGuid003: \ gMiscRuntimeServicesBBTestFunctionAssertionGuid004), L"RT.ResetSystem - EfiResetWarm", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); } return EFI_SUCCESS; }
// // TDS 4.4 // EFI_STATUS BBTestSetWakeupTimeInterfaceTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib; EFI_STATUS Status; EFI_TEST_ASSERTION AssertionType; UINTN Index; EFI_TPL OldTpl; EFI_TIME OldTime; EFI_TIME NewTime; BOOLEAN Enable; BOOLEAN Pending; UINTN RecoveryDataSize; UINT8 *RecoveryData; // // Get test support library interfaces // Status = GetTestSupportLibrary ( SupportHandle, &StandardLib, &RecoveryLib, &LoggingLib ); if (EFI_ERROR(Status)) { return Status; } // // Allocate memory for recovery data // Status = gtBS->AllocatePool ( EfiLoaderData, 1024, (VOID **)&RecoveryData ); if (EFI_ERROR(Status)) { return Status; } // // Read reset record // RecoveryDataSize = 1024; Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &RecoveryDataSize, RecoveryData ); if (!EFI_ERROR(Status) && (RecoveryDataSize > 0)) { switch (RecoveryData[0]) { case 1: goto step1; case 2: goto step2; default: goto step3; } } for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) { // // 4.4.2.1 SetWakeupTime must succeed when set the system wakeup alarm clock // Status = gtRT->GetTime ( &OldTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get time", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); continue; } // // Change hour // AddOneHour (&OldTime); OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetWakeupTime ( TRUE, &OldTime ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_UNSUPPORTED) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_WARNING, gTestGenericFailureGuid, L"RT.SetWakeupTime - Unsupported", L"%a:%d:Status - %r", __FILE__, (UINTN)__LINE__, Status ); return EFI_SUCCESS; } if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid043: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid044: \ gTimeServicesBBTestFunctionAssertionGuid045), L"RT.SetWakeupTime - Set wakeup time", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); // // Write reset record // RecoveryData[0] = 1; RecoveryData[1] = (UINT8)(Index); gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME)); RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step1: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME)); Status = gtRT->GetWakeupTime ( &Enable, &Pending, &NewTime ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get wakeup time 1", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if (Enable == TRUE) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid046: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid047: \ gTimeServicesBBTestFunctionAssertionGuid048), L"RT.SetWakeupTime - Wakeup timer should be enabled", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); if (Pending == FALSE) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid049: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid050: \ gTimeServicesBBTestFunctionAssertionGuid051), L"RT.SetWakeupTime - Timer should not be pending", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); if ((OldTime.Year != NewTime.Year) || (OldTime.Month != NewTime.Month) || (OldTime.Day != NewTime.Day) || (OldTime.Hour != NewTime.Hour) || (OldTime.Minute != NewTime.Minute) || (OldTime.Second != NewTime.Second) || (OldTime.TimeZone != NewTime.TimeZone) || (OldTime.Daylight != NewTime.Daylight)) { AssertionType = EFI_TEST_ASSERTION_FAILED; } else { AssertionType = EFI_TEST_ASSERTION_PASSED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid052: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid053: \ gTimeServicesBBTestFunctionAssertionGuid054), L"RT.SetWakeupTime - Verify wakeup time after change", L"%a:%d:Status - %r, TPL - %d, YMD-%d,%d,%d,%d,%d,%d, HMS-%d,%d,%d,%d,%d,%d, NDT-%d,%d,%d,%d,%d,%d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index], OldTime.Year, NewTime.Year, OldTime.Month, NewTime.Month, OldTime.Day, NewTime.Day, OldTime.Hour, NewTime.Hour, OldTime.Minute, NewTime.Minute, OldTime.Second, NewTime.Second, OldTime.Nanosecond, NewTime.Nanosecond, OldTime.Daylight, NewTime.Daylight, OldTime.TimeZone, NewTime.TimeZone ); } // // 4.4.2.2 SetWakeupTime must succeed when disable the wakeup alarm clock // OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetWakeupTime ( FALSE, NULL ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_UNSUPPORTED) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_WARNING, gTestGenericFailureGuid, L"RT.SetWakeupTime - Unsupported", L"%a:%d:Status - %r", __FILE__, (UINTN)__LINE__, Status ); return EFI_SUCCESS; } if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid055: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid056: \ gTimeServicesBBTestFunctionAssertionGuid057), L"RT.SetWakeupTime - Disable wakeup time", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); // // Write reset record // RecoveryData[0] = 2; RecoveryData[1] = (UINT8)(Index); RecoveryLib->WriteResetRecord (RecoveryLib, 2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step2: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; Status = gtRT->GetWakeupTime ( &Enable, &Pending, &NewTime ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get wakeup time 2", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if (Enable == FALSE) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid058: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid059: \ gTimeServicesBBTestFunctionAssertionGuid060), L"RT.SetWakeupTime - Wakeup timer should be disabled", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } } step3: gtBS->FreePool (RecoveryData); return EFI_SUCCESS; }
// // TDS 4.2 // EFI_STATUS BBTestSetTimeInterfaceTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_TEST_LOGGING_LIBRARY_PROTOCOL *LoggingLib; EFI_STATUS Status; EFI_TEST_ASSERTION AssertionType; UINTN Index; EFI_TPL OldTpl; EFI_TIME OldTime; EFI_TIME NewTime; EFI_TIME Time; UINTN RecoveryDataSize; UINT8 *RecoveryData; // // Get test support library interfaces // Status = GetTestSupportLibrary ( SupportHandle, &StandardLib, &RecoveryLib, &LoggingLib ); if (EFI_ERROR(Status)) { return Status; } // // Allocate memory for recovery data // Status = gtBS->AllocatePool ( EfiLoaderData, 1024, (VOID **)&RecoveryData ); if (EFI_ERROR(Status)) { return Status; } // // Read reset record // RecoveryDataSize = 1024; Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &RecoveryDataSize, RecoveryData ); if (!EFI_ERROR(Status) && (RecoveryDataSize > 0)) { switch (RecoveryData[0]) { case 1: goto step1; case 2: goto step2; case 3: goto step3; case 4: goto step4; default: goto step5; } } for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) { // // 4.2.2.1 SetTime must succeed with valid parameters // Status = gtRT->GetTime ( &OldTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get time", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); continue; } // // Change year // NOTES: The new year must be set as a leap year. // Time = OldTime; if (Time.Year != 2012) { Time.Year = 2012; } else { Time.Year = 2016; } // skip 2012 12 31 11:59:59 corner case Time.Day = 1; OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetTime ( &Time ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid013: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid014: \ gTimeServicesBBTestFunctionAssertionGuid015), L"RT.SetTime - Change year", L"%a:%d:Status - %r, TPL - %d, Year - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index], OldTime.Year ); // // Write reset record // RecoveryData[0] = 1; RecoveryData[1] = (UINT8)(Index); gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME)); RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step1: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME)); // // Call GetTime() to check the result of SetTime() // Status = gtRT->GetTime ( &NewTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get new time 1", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if (((OldTime.Year == 2012) && (NewTime.Year == 2016)) || ((OldTime.Year != 2012) && (NewTime.Year == 2012))) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid016: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid017: \ gTimeServicesBBTestFunctionAssertionGuid018), L"RT.SetTime - Verity year after change", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } // // Change month // Time = OldTime; if (Time.Month != 1) { Time.Month = 1; } else { Time.Month = 12; } // skip 2012 12 31 11:59:59 corner case Time.Day = 1; OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetTime ( &Time ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid019: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid020: \ gTimeServicesBBTestFunctionAssertionGuid021), L"RT.SetTime - Change month", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); // // Write reset record // RecoveryData[0] = 2; RecoveryData[1] = (UINT8)Index; gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME)); RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step2: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME)); // // Call GetTime() to check the result of SetTime() // Status = gtRT->GetTime ( &NewTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get new time 2", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if (((OldTime.Month == 1) && (NewTime.Month == 12)) || ((OldTime.Month != 1) && (NewTime.Month == 1))) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid022: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid023: \ gTimeServicesBBTestFunctionAssertionGuid024), L"RT.SetTime - Verity month after change", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } // // Change daylight // Time = OldTime; if (Time.Daylight & EFI_TIME_ADJUST_DAYLIGHT) { Time.Daylight &= ~EFI_TIME_ADJUST_DAYLIGHT; } else { Time.Daylight |= EFI_TIME_ADJUST_DAYLIGHT; } // reverse EFI_TIME_IN_DAYLIGHT bit Time.Daylight ^= EFI_TIME_IN_DAYLIGHT; OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetTime ( &Time ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid025: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid026: \ gTimeServicesBBTestFunctionAssertionGuid027), L"RT.SetTime - Change daylight", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); // // Write reset record // RecoveryData[0] = 3; RecoveryData[1] = (UINT8)Index; gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME)); RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step3: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME)); // // Call GetTime() to check the result of SetTime() // Status = gtRT->GetTime ( &NewTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get new time 3", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if ((OldTime.Daylight ^ NewTime.Daylight) == (EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT)) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid028: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid029: \ gTimeServicesBBTestFunctionAssertionGuid030), L"RT.SetTime - Verity daylight after change", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } // // Change time zone // Time = OldTime; if (Time.TimeZone != 0) { Time.TimeZone = 0; } else { Time.TimeZone = 1; } OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtRT->SetTime ( &Time ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid031: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid032: \ gTimeServicesBBTestFunctionAssertionGuid033), L"RT.SetTime - Change time zone", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); // // Write reset record // RecoveryData[0] = 4; RecoveryData[1] = (UINT8)Index; gtBS->CopyMem (&RecoveryData[2], &OldTime, sizeof(EFI_TIME)); RecoveryLib->WriteResetRecord (RecoveryLib, sizeof(EFI_TIME)+2, RecoveryData); gtBS->FreePool (RecoveryData); // // Prompt the user about the cold reset and reset the system // if (LoggingLib != NULL) { LoggingLib->EnterFunction ( LoggingLib, L"\r\nSetTime Test", L"System will cold reset after 1 second..." ); } // Print (L"System will cold reset after 1 second..."); gtBS->Stall (1000000); gtRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL); step4: // // Restore the env // RecoveryData[0] = 0; Index = RecoveryData[1]; gtBS->CopyMem (&OldTime, &RecoveryData[2], sizeof(EFI_TIME)); // // Call GetTime() to check the result of SetTime() // Status = gtRT->GetTime ( &NewTime, NULL ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.GetTime - Get new time 4", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } else { if (((OldTime.TimeZone == 0) && (NewTime.TimeZone == 1)) || ((OldTime.TimeZone != 0) && (NewTime.TimeZone == 0))) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, Index==0? \ gTimeServicesBBTestFunctionAssertionGuid034: \ (Index == 1? \ gTimeServicesBBTestFunctionAssertionGuid035: \ gTimeServicesBBTestFunctionAssertionGuid036), L"RT.SetTime - Verity time zone after change", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } // // Restore the time // Status = gtRT->SetTime ( &OldTime ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"RT.SetTime - Restore time", L"%a:%d:Status - %r, TPL - %d", __FILE__, (UINTN)__LINE__, Status, TplArray[Index] ); } } step5: gtBS->FreePool (RecoveryData); return EFI_SUCCESS; }
// // TDS 5.2 // EFI_STATUS BBTestResetSystemManualStressTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_STATUS Status; EFI_TEST_ASSERTION AssertionType; UINTN Index; UINT32 RepeatTimes; EFI_TPL OldTpl; UINT8 Buffer[1024]; RESET_DATA *ResetData; UINTN Size; // // Get the Standard Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiStandardTestLibraryGuid, &StandardLib ); if ( EFI_ERROR(Status) ) { return Status; } // // Get the Recovery Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiTestRecoveryLibraryGuid, &RecoveryLib ); if ( EFI_ERROR(Status) ) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"BS.HandleProtocol - Handle recovery library", L"%a:%d:Status - %r", __FILE__, __LINE__, Status ); return Status; } // // Read reset record // Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &Size, Buffer ); ResetData = (RESET_DATA *)Buffer; if (EFI_ERROR(Status) || (Size < sizeof(RESET_DATA))) { // // Step 1 // } else if (ResetData->Step == 1) { // // Step 2 // if (ResetData->TplIndex < TPL_ARRAY_SIZE) { Index = ResetData->TplIndex; RepeatTimes = ResetData->RepeatTimes; AssertionType = EFI_TEST_ASSERTION_PASSED; goto ManualStressTestStep2; } } else { return EFI_LOAD_ERROR; } for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) { // // 5.2.2.1 Stress test for ResetSystem when ResetType is EfiResetShutdown // for (RepeatTimes = 0; RepeatTimes < MAX_REPEAT_TIMES; RepeatTimes++) { ResetData->Step = 1; ResetData->TplIndex = Index; ResetData->RepeatTimes = RepeatTimes; Status = RecoveryLib->WriteResetRecord( RecoveryLib, sizeof (RESET_DATA), Buffer ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"TestRecoveryLib - WriteResetRecord", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); return Status; } // // Print out some information to avoid the user thought it is an error // Print (L"System will shut down (or cold reset) after 1 second..."); gtBS->Stall (1000000); OldTpl = gtBS->RaiseTPL (TplArray[Index]); gtRT->ResetSystem ( EfiResetShutdown, EFI_SUCCESS, 0, NULL ); gtBS->RestoreTPL (OldTpl); AssertionType = EFI_TEST_ASSERTION_FAILED; ManualStressTestStep2: StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscRuntimeServicesCombinationTestAssertionGuid007, L"RT.ResetSystem - Stress EfiResetShutdown", L"%a:%d:Status - %r, TPL - %d, Times - %d", __FILE__, __LINE__, Status, TplArray[Index], RepeatTimes ); } } return EFI_SUCCESS; }
// // TDS 5.5 // EFI_STATUS BBTestGetNextMonotonicCountStressTest ( IN EFI_BB_TEST_PROTOCOL *This, IN VOID *ClientInterface, IN EFI_TEST_LEVEL TestLevel, IN EFI_HANDLE SupportHandle ) { EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib; EFI_TEST_RECOVERY_LIBRARY_PROTOCOL *RecoveryLib; EFI_STATUS Status; EFI_TEST_ASSERTION AssertionType; UINTN Index; UINT64 RepeatTimes; EFI_TPL OldTpl; UINT64 Count; UINT64 OldCount; UINT8 ResetBuffer[1024]; RESET_DATA *ResetData; UINTN Size; // // Get the Standard Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiStandardTestLibraryGuid, &StandardLib ); if (EFI_ERROR(Status)) { return Status; } // // Get the Recovery Library Interface // Status = gtBS->HandleProtocol ( SupportHandle, &gEfiTestRecoveryLibraryGuid, &RecoveryLib ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"BS.HandleProtocol - Handle recovery library", L"%a:%d:Status - %r", __FILE__, __LINE__, Status ); return Status; } // // Read reset record // Status = RecoveryLib->ReadResetRecord ( RecoveryLib, &Size, ResetBuffer ); ResetData = (RESET_DATA *)&ResetBuffer; if (EFI_ERROR(Status) || (Size < sizeof(RESET_DATA))) { // // Step 1 // } else if (ResetData->Step == 1) { // // Step 2 // if (ResetData->TplIndex < TPL_ARRAY_SIZE) { Index = ResetData->TplIndex; OldCount = ResetData->Count; goto StressTestStep2; } } else { return EFI_LOAD_ERROR; } for (Index = 0; Index < TPL_ARRAY_SIZE; Index++) { // // 5.5.2.1 Stress test for GetNextMonotonicCount. // OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtBS->GetNextMonotonicCount ( &OldCount ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscBootServicesCombinationTestAssertionGuid007, L"BS.GetNextMonotonicCount - get current count", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); for (RepeatTimes = 0; RepeatTimes < MAX_REPEAT_TIMES; RepeatTimes++) { OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtBS->GetNextMonotonicCount ( &Count ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscBootServicesCombinationTestAssertionGuid008, L"BS.GetNextMonotonicCount - get next count", L"%a:%d:Status - %r, TPL - %d, Times - %d", __FILE__, __LINE__, Status, TplArray[Index], RepeatTimes ); if (Count == OldCount + 1) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscBootServicesCombinationTestAssertionGuid009, L"BS.GetNextMonotonicCount - Count == OldCount + 1", L"%a:%d:Status - %r, TPL - %d, Count - %lx, OldCount - %lx, Times - %d", __FILE__, __LINE__, Status, TplArray[Index], Count, OldCount, RepeatTimes ); OldCount = Count; } // // save the high 32 bit and reset system // ResetData->Step = 1; ResetData->TplIndex = Index; ResetData->Count = OldCount; Status = RecoveryLib->WriteResetRecord ( RecoveryLib, sizeof (RESET_DATA), ResetBuffer ); if (EFI_ERROR(Status)) { StandardLib->RecordAssertion ( StandardLib, EFI_TEST_ASSERTION_FAILED, gTestGenericFailureGuid, L"TestRecoveryLib - WriteResetRecord", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); return Status; } // // 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); StressTestStep2: OldTpl = gtBS->RaiseTPL (TplArray[Index]); Status = gtBS->GetNextMonotonicCount ( &Count ); gtBS->RestoreTPL (OldTpl); if (Status == EFI_SUCCESS) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscBootServicesCombinationTestAssertionGuid010, L"BS.GetNextMonotonicCount - get count after reset", L"%a:%d:Status - %r, TPL - %d", __FILE__, __LINE__, Status, TplArray[Index] ); if (RShiftU64 (Count, 32) == RShiftU64 (OldCount, 32) + 1) { AssertionType = EFI_TEST_ASSERTION_PASSED; } else { AssertionType = EFI_TEST_ASSERTION_FAILED; } StandardLib->RecordAssertion ( StandardLib, AssertionType, gMiscBootServicesCombinationTestAssertionGuid012, L"BS.GetNextMonotonicCount - high 32 bit increase by 1", L"%a:%d:OldCount - %lx, Count - %lx, TPL - %d", __FILE__, __LINE__, OldCount, Count, TplArray[Index] ); } return EFI_SUCCESS; }