static int check_fw_support(fwts_framework *fw, uint64_t status)
{
if ((status == EFI_INVALID_PARAMETER) &&
((attributes & FWTS_UEFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) ||
(attributes & FWTS_UEFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) ||
(attributes & FWTS_UEFI_VARIABLE_APPEND_WRITE))) {
fwts_uefi_print_status_info(fw, status);
fwts_skipped(fw,
"EFI_INVALID_PARAMETER shall be returned, "
"when firmware doesn't support these operations "
"with EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS, "
"EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS "
"or EFI_VARIABLE_APPEND_WRITE attributes is set.");
return FWTS_SKIP;
}
if (status == EFI_OUT_OF_RESOURCES) {
fwts_uefi_print_status_info(fw, status);
fwts_skipped(fw,
"Run out of resources for SetVariable "
"UEFI runtime interface: cannot test.");
fwts_advice(fw,
"Firmware may reclaim some resources "
"after rebooting. Reboot and test "
"again may be helpful to continue "
"the test.");
return FWTS_SKIP;
}
return FWTS_OK;
}
/*
* Set the created authenticated variable, AuthVarCreate,
* and checking the data size and data.
* expect EFI_SUCCESS returned.
*/
static int uefirtauthvar_test1(fwts_framework *fw)
{
long ioret;
uint8_t data[getvar_buf_size];
uint64_t getdatasize = sizeof(data);
uint64_t status;
uint32_t attributestest;
size_t i;
ioret = setvar(>estguid, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFICreateAuthVar",
"Failed to create authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFICreateAuthVar",
"Failed to get authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (getdatasize != sizeof(AuthVarCreateData)) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFICreateAuthVar",
"Get authenticated variable data size is not the "
"same as it set.");
return FWTS_ERROR;
}
for (i = 0; i < sizeof(AuthVarCreateData); i++) {
if (data[i] != AuthVarCreateData[i]) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFICreateAuthVar",
"Get authenticated variable data are not the "
"same as it set.");
return FWTS_ERROR;
}
}
data_exist |= E_AUTHVARCREATE;
fwts_passed(fw, "Create authenticated variable test passed.");
return FWTS_OK;
}
static int uefirttime_test_settime_invalid_time(
fwts_framework *fw,
EFI_TIME *time)
{
struct efi_gettime gettime;
struct efi_settime settime;
EFI_TIME oldtime, newtime;
uint64_t status = ~0ULL;
int ret, ioret;
gettime.Time = &oldtime;
gettime.status = &status;
gettime.Capabilities = NULL;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
memcpy(&newtime, &oldtime, sizeof(EFI_TIME));
if (time->Year != 0xffff)
newtime.Year = time->Year;
if (time->Month != 0xff)
newtime.Month = time->Month;
if (time->Day != 0xff)
newtime.Day = time->Day;
if (time->Hour != 0xff)
newtime.Hour = time->Hour;
if (time->Minute != 0xff)
newtime.Minute = time->Minute;
if (time->Second != 0xff)
newtime.Second = time->Second;
if (time->Nanosecond != 0xffffffff)
newtime.Nanosecond = time->Nanosecond;
if ((uint16_t)time->TimeZone != 0xffff)
newtime.TimeZone = time->TimeZone;
settime.Time = &newtime;
settime.status = &status;
ret = uefirttime_test_settime_invalid(fw, &settime);
/* Restore original time */
settime.Time = &oldtime;
status = ~0ULL;
settime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime",
"Failed to set wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
return ret;
}
/*
* Delete the test authenticated variable.
*/
static int uefirtauthvar_test7(fwts_framework *fw)
{
long ioret;
uint8_t data[getvar_buf_size];
uint64_t getdatasize = sizeof(data);
uint64_t status;
uint32_t attributestest;
if (!(data_exist & E_AUTHVARCREATE)) {
fwts_skipped(fw,"The test data, AuthVarCreate, doesn't exist, skip the test.");
return FWTS_SKIP;
}
ioret = setvar(>estguid, attributes, sizeof(AuthVarDel), AuthVarDel, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIDelAuthVar",
"Failed to delete authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status);
if (ioret == -1) {
if (status == EFI_NOT_FOUND) {
fwts_passed(fw, "Delete authenticated variable tests passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_MEDIUM,
"UEFIDelAuthVar",
"Failed to get authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIDelAuthVar",
"Failed to delete authenticated variable still get the test"
"authenticated variable.");
return FWTS_ERROR;
}
/*
* Set the authenticated variable with different guid, expect
* EFI_SECURITY_VIOLATION returned.
*/
static int uefirtauthvar_test10(fwts_framework *fw)
{
long ioret;
uint64_t status;
EFI_GUID gtestguiddiff = TEST_GUID1;
ioret = setvar(>estguiddiff, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
if (status == EFI_SECURITY_VIOLATION) {
fwts_passed(fw, "Set authenticated variable test with different guid passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_MEDIUM,
"UEFISetAuthVarDiffGuid",
"Set authenticated variable fail");
fwts_uefi_print_status_info(fw, status);
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarDiffGuid",
"Set authenticated variable expected fail but success");
return FWTS_ERROR;
}
/*
* Set the authenticated variable with invalid modified timestamp, expect
* EFI_SECURITY_VIOLATION returned.
*/
static int uefirtauthvar_test9(fwts_framework *fw)
{
long ioret;
uint64_t status;
ioret = setvar(>estguid, attributes, sizeof(AuthVarModTime), AuthVarModTime, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
if (status == EFI_SECURITY_VIOLATION) {
fwts_passed(fw, "Set authenticated variable test with invalid modified timestamp passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_MEDIUM,
"UEFISetAuthVarInvalidTime",
"Set authenticated variable fail");
fwts_uefi_print_status_info(fw, status);
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarInvalidTime",
"Set authenticated variable expected fail but success");
return FWTS_ERROR;
}
/*
* After updated, set the old data and timestamp authenticated variable,
* AuthVarCreate, expect EFI_SECURITY_VIOLATION returned.
*/
static int uefirtauthvar_test6(fwts_framework *fw)
{
long ioret;
uint64_t status;
if (!(data_exist & E_AUTHVARUPDATE)) {
fwts_skipped(fw,"The test variable, AuthVarUpdate, doesn't exist, skip the test.");
return FWTS_SKIP;
}
ioret = setvar(>estguid, attributes, sizeof(AuthVarCreate), AuthVarCreate, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
if (status == EFI_SECURITY_VIOLATION) {
fwts_passed(fw, "Authenticated variable test with old authenticated variable passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_MEDIUM,
"UEFISetOldAuthVar",
"Set authenticated variable fail");
fwts_uefi_print_status_info(fw, status);
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetOldAuthVar",
"Set authenticated variable expected fail but success");
return FWTS_ERROR;
}
/*
* The authenticated variable is followed EFI_VARIABLE_AUTHENTICATION_2 descriptor,
* set the authenticated variable with invalid
* EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS instead of
* EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute should
* return EFI_SECURITY_VIOLATION.
*/
static int uefirtauthvar_test11(fwts_framework *fw)
{
long ioret;
uint64_t status;
uint32_t attr = FWTS_UEFI_VAR_NON_VOLATILE |
FWTS_UEFI_VAR_BOOTSERVICE_ACCESS |
FWTS_UEFI_VAR_RUNTIME_ACCESS |
FWTS_UEFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS;
ioret = setvar(>estguid, attr, sizeof(AuthVarCreate), AuthVarCreate, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
if (status == EFI_SECURITY_VIOLATION) {
fwts_passed(fw, "Set authenticated variable test with invalid attributes passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_MEDIUM,
"UEFISetAuthVarInvalidAttr",
"Set authenticated variable fail");
fwts_uefi_print_status_info(fw, status);
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarInvalidAttr",
"Set authenticated variable expected fail but success");
return FWTS_ERROR;
}
static int uefirttime_test1(fwts_framework *fw)
{
long ioret;
struct efi_gettime gettime;
EFI_TIME efi_time;
EFI_TIME_CAPABILITIES efi_time_cap;
uint64_t status;
gettime.Capabilities = &efi_time_cap;
gettime.Time = &efi_time;
gettime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (!checktimefields(fw, gettime.Time))
return FWTS_ERROR;
fwts_passed(fw, "UEFI runtime service GetTime interface test passed.");
return FWTS_OK;
}
static int uefirttime_test18(fwts_framework *fw)
{
long ioret;
struct efi_getwakeuptime getwakeuptime;
uint64_t status;
uint8_t enabled, pending;
EFI_TIME efi_time;
getwakeuptime.Enabled = &enabled;
getwakeuptime.Pending = &pending;
getwakeuptime.Time = &efi_time;
getwakeuptime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (!checktimefields(fw, getwakeuptime.Time))
return FWTS_ERROR;
fwts_passed(fw, "UEFI runtime service GetWakeupTime interface test passed.");
return FWTS_OK;
}
static int uefirttime_test_setwakeuptime_invalid(
fwts_framework *fw,
struct efi_setwakeuptime *setwakeuptime
)
{
long ioret;
uint64_t status;
setwakeuptime->status = &status;
ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, setwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
if (status == EFI_INVALID_PARAMETER) {
fwts_passed(fw, "UEFI runtime service SetTimeWakeupTime interface test "
"passed, returned EFI_INVALID_PARAMETER as expected.");
return FWTS_OK;
} else {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime",
"Failed to get correct return status from UEFI runtime service, "
"expecting EFI_INVALID_PARAMETER.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime",
"Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER.");
return FWTS_ERROR;
}
static int uefirttime_test_getwaketime_invalid(
fwts_framework *fw,
struct efi_getwakeuptime *getwakeuptime)
{
long ioret;
uint64_t status;
getwakeuptime->status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, getwakeuptime);
if (ioret == -1) {
if (status == EFI_INVALID_PARAMETER ||
status == EFI_UNSUPPORTED) {
fwts_passed(fw, "UEFI runtime service GetTimeWakeupTime interface test "
"passed, returned EFI_INVALID_PARAMETER or "
"EFI_UNSUPPORTED as expected.");
return FWTS_OK;
} else {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get correct return status from UEFI "
"runtime service, expecting EFI_INVALID_PARAMETER "
"or EFI_UNSUPPORTED.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER.");
return FWTS_ERROR;
}
static int uefirttime_test_settime_invalid(
fwts_framework *fw,
struct efi_settime *settime)
{
long ioret;
uint64_t status;
settime->status = &status;
ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, settime);
if (ioret == -1) {
if (status == EFI_INVALID_PARAMETER) {
fwts_passed(fw, "UEFI runtime service SetTime interface test "
"passed, returned EFI_INVALID_PARAMETER as expected.");
return FWTS_OK;
} else {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime",
"Failed to get correct return status from UEFI runtime service, expecting EFI_INVALID_PARAMETER.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime",
"Failed to get error return status from UEFI runtime service, expected EFI_INVALID_PARAMETER.");
return FWTS_ERROR;
}
static int uefirttime_test_gettime_invalid(
fwts_framework *fw,
EFI_TIME *efi_time,
EFI_TIME_CAPABILITIES *efi_time_cap)
{
long ioret;
struct efi_gettime gettime;
uint64_t status;
gettime.Capabilities = efi_time_cap;
gettime.Time = efi_time;
gettime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
if (status == EFI_INVALID_PARAMETER) {
fwts_passed(fw, "UEFI runtime service GetTime interface test "
"passed, returned EFI_INVALID_PARAMETER as expected.");
return FWTS_OK;
} else {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get correct return status from UEFI runtime service, expecting EFI_INVALID_PARAMETER.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get error return status from UEFI runtime service, expected EFI_INAVLID_PARAMETER.");
return FWTS_ERROR;
}
static int uefivarinfo_test1(fwts_framework *fw)
{
uint64_t status;
uint64_t remvarstoragesize;
uint64_t maxvariablesize;
uint64_t maxvarstoragesize;
uint64_t usedvars;
uint64_t usedvarssize;
if (do_queryvariableinfo(&status, &maxvarstoragesize, &remvarstoragesize, &maxvariablesize) == FWTS_ERROR) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw,
"QueryVariableInfo UEFI runtime interface not supported: cannot test.");
fwts_advice(fw,
"Firmware also needs to check if the revision "
"of system table is correct or not. Linux "
"kernel returns EFI_UNSUPPORTED as well, if "
"the FirmwareRevision of system table is less "
"than EFI_2_00_SYSTEM_TABLE_REVISION.");
return FWTS_SKIP;
} else {
fwts_log_info(fw, "Failed to query variable info with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
}
fwts_log_info_verbatim(fw, "UEFI NVRAM storage:");
fwts_log_info_verbatim(fw, " Maximum storage: %8" PRIu64 " bytes", maxvarstoragesize);
fwts_log_info_verbatim(fw, " Remaining storage: %8" PRIu64 " bytes", remvarstoragesize);
fwts_log_info_verbatim(fw, " Maximum variable size: %8" PRIu64 " bytes", maxvariablesize);
if (do_checkvariables(fw, &usedvars, &usedvarssize, maxvariablesize) == FWTS_OK) {
fwts_log_info_verbatim(fw, "Currently used:");
fwts_log_info_verbatim(fw, " %" PRIu64 " variables, storage used: %" PRIu64 " bytes", usedvars, usedvarssize);
}
return FWTS_OK;
}
static int do_checkvariables(
fwts_framework *fw,
uint64_t *usedvars,
uint64_t *usedvarssize,
const uint64_t maxvarsize)
{
uint64_t status;
struct efi_getnextvariablename getnextvariablename;
uint64_t variablenamesize = MAX_VARNAME_LENGTH;
uint16_t variablename[MAX_VARNAME_LENGTH];
EFI_GUID vendorguid;
uint8_t *data;
uint64_t getdatasize;
uint32_t attributestest;
struct efi_getvariable getvariable;
getvariable.Attributes = &attributestest;
getvariable.status = &status;
getnextvariablename.VariableNameSize = &variablenamesize;
getnextvariablename.VariableName = variablename;
getnextvariablename.VendorGuid = &vendorguid;
getnextvariablename.status = &status;
*usedvars = 0;
*usedvarssize = 0;
/*
* To start the search, need to pass a Null-terminated string
* in VariableName
*/
variablename[0] = '\0';
while (true) {
long ioret;
status = ~0ULL;
variablenamesize = MAX_VARNAME_LENGTH;
ioret = ioctl(fd, EFI_RUNTIME_GET_NEXTVARIABLENAME, &getnextvariablename);
if (ioret == -1) {
/* no next variable was found*/
if (*getnextvariablename.status == EFI_NOT_FOUND)
break;
fwts_log_info(fw, "Failed to get next variable name with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
(*usedvars)++;
data = malloc(maxvarsize);
if (!data) {
fwts_log_info(fw, "Failed to allocate memory for test.");
return FWTS_ERROR;
}
getdatasize = maxvarsize;
getvariable.VariableName = variablename;
getvariable.VendorGuid = &vendorguid;
getvariable.DataSize = &getdatasize;
getvariable.Data = data;
status = ~0ULL;
ioret = ioctl(fd, EFI_RUNTIME_GET_VARIABLE, &getvariable);
if (ioret == -1) {
if (status != EFI_BUFFER_TOO_SMALL) {
free(data);
fwts_log_info(fw, "Failed to get variable with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
} else if (getdatasize > maxvarsize) {
free(data);
fwts_log_info(fw, "Variable is larger than maximum variable length.");
fwts_uefi_print_status_info(fw, status);
/*
* Although the variable is larger than maximum variable length,
* still try to calculate the total sizes of the used variables.
*/
data = malloc(getdatasize);
if (!data) {
fwts_log_info(fw, "Failed to allocate memory for test.");
return FWTS_ERROR;
}
getvariable.Data = data;
status = ~0ULL;
ioret = ioctl(fd, EFI_RUNTIME_GET_VARIABLE, &getvariable);
if (ioret == -1) {
fwts_log_info(fw, "Failed to get variable with variable larger than maximum variable length.");
fwts_uefi_print_status_info(fw, status);
free(data);
return FWTS_ERROR;
}
}
}
free(data);
(*usedvarssize) += getdatasize;
};
return FWTS_OK;
}
static int uefirttime_test_setwakeuptime_invalid_time(
fwts_framework *fw,
EFI_TIME *time)
{
struct efi_getwakeuptime getwakeuptime;
struct efi_setwakeuptime setwakeuptime;
EFI_TIME oldtime, newtime;
uint64_t status;
uint8_t pending, enabled;
int ret, ioret;
getwakeuptime.Enabled = &enabled;
getwakeuptime.Pending = &pending;
getwakeuptime.Time = &oldtime;
getwakeuptime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
memcpy(&newtime, &oldtime, sizeof(EFI_TIME));
if (time->Year != 0xffff)
newtime.Year = time->Year;
if (time->Month != 0xff)
newtime.Month = time->Month;
if (time->Day != 0xff)
newtime.Day = time->Day;
if (time->Hour != 0xff)
newtime.Hour = time->Hour;
if (time->Minute != 0xff)
newtime.Minute = time->Minute;
if (time->Second != 0xff)
newtime.Second = time->Second;
if (time->Nanosecond != 0xffffffff)
newtime.Nanosecond = time->Nanosecond;
if ((uint16_t)time->TimeZone != 0xffff)
newtime.TimeZone = time->TimeZone;
setwakeuptime.Time = &newtime;
setwakeuptime.status = &status;
setwakeuptime.Enabled = true;
ret = uefirttime_test_setwakeuptime_invalid(fw, &setwakeuptime);
/* Restore original time */
setwakeuptime.Time = &oldtime;
setwakeuptime.status = &status;
setwakeuptime.Enabled = true;
ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime",
"Failed to set wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
return ret;
}
static int uefirttime_test23(fwts_framework *fw)
{
long ioret;
struct efi_setwakeuptime setwakeuptime;
uint64_t status;
EFI_TIME oldtime;
EFI_TIME newtime;
struct efi_gettime gettime;
EFI_TIME_CAPABILITIES efi_time_cap;
struct efi_getwakeuptime getwakeuptime;
uint8_t enabled, pending;
gettime.Capabilities = &efi_time_cap;
gettime.Time = &oldtime;
gettime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
/* change the hour, add 1 hour*/
addonehour(&oldtime);
setwakeuptime.Time = &oldtime;
setwakeuptime.status = &status;
setwakeuptime.Enabled = true;
ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime",
"Failed to set wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
sleep(1);
getwakeuptime.Enabled = &enabled;
getwakeuptime.Pending = &pending;
getwakeuptime.Time = &newtime;
getwakeuptime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (*getwakeuptime.Enabled != true) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeEnable",
"Failed to set wakeup alarm clock, wakeup timer should be enabled.");
return FWTS_ERROR;
}
if (*getwakeuptime.Pending != false) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimePending",
"Get error alarm signle status.");
return FWTS_ERROR;
}
if ((oldtime.Year != newtime.Year) || (oldtime.Month != newtime.Month) ||
(oldtime.Day != newtime.Day) || (oldtime.Hour != newtime.Hour)) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeVerify",
"Failed to verify wakeup time after change.");
return FWTS_ERROR;
}
setwakeuptime.Enabled = false;
ioret = ioctl(fd, EFI_RUNTIME_SET_WAKETIME, &setwakeuptime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTime",
"Failed to set wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
sleep(1);
ioret = ioctl(fd, EFI_RUNTIME_GET_WAKETIME, &getwakeuptime);
if (ioret == -1) {
if (status == EFI_UNSUPPORTED) {
fwts_skipped(fw, "Skipping test, GetWakeupTime runtime "
"service is not supported on this platform.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetWakeupTime",
"Failed to get wakeup time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (*getwakeuptime.Enabled != false) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetWakeupTimeEnable",
"Failed to set wakeup alarm clock, wakeup timer should be disabled.");
return FWTS_ERROR;
}
fwts_passed(fw, "UEFI runtime service SetWakeupTime interface test passed.");
return FWTS_OK;
}
static int uefirttime_test4(fwts_framework *fw)
{
long ioret;
struct efi_settime settime;
uint64_t status;
struct efi_gettime gettime;
EFI_TIME oldtime;
EFI_TIME newtime;
EFI_TIME time;
EFI_TIME_CAPABILITIES efi_time_cap;
gettime.Capabilities = &efi_time_cap;
gettime.Time = &oldtime;
gettime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
/* refer to UEFI SCT 2.3 test items */
/* change year */
time = oldtime;
if (time.Year != 2012)
time.Year = 2012;
else
time.Year = 2016;
/* change month */
if (time.Month != 1)
time.Month = 1;
else
time.Month = 12;
/* Change daylight */
if (time.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT)
time.Daylight &= ~FWTS_UEFI_TIME_ADJUST_DAYLIGHT;
else
time.Daylight |= FWTS_UEFI_TIME_ADJUST_DAYLIGHT;
/* Change time zone */
if (time.TimeZone != 0)
time.TimeZone = 0;
else
/* Unspecified timezone, local time */
time.TimeZone = 2047;
settime.Time = &time;
settime.status = &status;
ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime",
"Failed to set time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
sleep(1);
gettime.Time = &newtime;
ioret = ioctl(fd, EFI_RUNTIME_GET_TIME, &gettime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeGetTime",
"Failed to get time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (!((oldtime.Year == 2012) && (newtime.Year == 2016)) &&
!((oldtime.Year != 2012) && (newtime.Year == 2012))) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeYear",
"Failed to set year with UEFI runtime service.");
return FWTS_ERROR;
}
if (!((oldtime.Month == 1) && (newtime.Month == 12)) &&
!((oldtime.Month != 1) && (newtime.Month == 1))) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeMonth",
"Failed to set month with UEFI runtime service.");
return FWTS_ERROR;
}
if (!((oldtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT) &&
(!(newtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT))) &&
!((!(oldtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT)) &&
(newtime.Daylight & FWTS_UEFI_TIME_ADJUST_DAYLIGHT))) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeDaylight",
"Failed to set daylight with UEFI runtime service.");
return FWTS_ERROR;
}
if (!((oldtime.TimeZone == 0) && (newtime.TimeZone == 2047)) &&
!((oldtime.TimeZone != 0) && (newtime.TimeZone == 0))) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTimeTimezone",
"Failed to set timezone with UEFI runtime service.");
return FWTS_ERROR;
}
/* restore the previous time. */
settime.Time = &oldtime;
ioret = ioctl(fd, EFI_RUNTIME_SET_TIME, &settime);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH, "UEFIRuntimeSetTime",
"Failed to set time with UEFI runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
fwts_passed(fw, "UEFI runtime service SetTime interface test passed.");
return FWTS_OK;
}
/*
* Execute the normal append operation.
*/
static int uefirtauthvar_test4(fwts_framework *fw)
{
long ioret;
uint8_t data[getvar_buf_size];
uint64_t getdatasize = sizeof(data);
uint64_t status;
uint32_t attributestest;
size_t i;
uint32_t attribappend = attributes | FWTS_UEFI_VARIABLE_APPEND_WRITE;
if (!(data_exist & E_AUTHVARCREATE)) {
fwts_skipped(fw,"The test variable, AuthVarCreate, doesn't exist, skip the test.");
return FWTS_SKIP;
}
ioret = setvar(>estguid, attribappend, sizeof(AuthVarAppend), AuthVarAppend, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIAppendAuthVar",
"Failed to append authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIAppendAuthVar",
"Failed to get authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (getdatasize != (sizeof(AuthVarCreateData) + sizeof(AuthVarAppendData))) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIAppendAuthVar",
"Get total authenticated variable data size is not the "
"same as it set and appended.");
return FWTS_ERROR;
}
for (i = 0; i < getdatasize; i++) {
if (i < sizeof(AuthVarCreateData)) {
if (data[i] != AuthVarCreateData[i]) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIAppendAuthVar",
"Get authenticated variable data are not the "
"same as it set.");
return FWTS_ERROR;
}
} else {
if (data[i] != AuthVarAppendData[i - sizeof(AuthVarCreateData)]) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIAppendAuthVar",
"Get authenticated variable data are not the "
"same as it set.");
return FWTS_ERROR;
}
}
}
data_exist |= E_AUTHVARAPPEND;
fwts_passed(fw, "Append authenticated variable tests passed.");
return FWTS_OK;
}
/*
* Test with setting and deleting another authenticated variable,
* after previous test authenticated variable was deleted.
*/
static int uefirtauthvar_test12(fwts_framework *fw)
{
long ioret;
uint8_t data[getvar_buf_size];
uint64_t getdatasize = sizeof(data);
uint64_t status;
uint32_t attributestest;
size_t i;
ioret = setvar(>estguid, attributes, sizeof(AuthVarCreateDiff), AuthVarCreateDiff, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarDiff",
"Failed to set authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status);
if (ioret == -1) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarDiff",
"Failed to get authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
if (getdatasize != sizeof(AuthVarCreateData)) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarDiff",
"Get authenticated variable data size is not the "
"same as it set.");
return FWTS_ERROR;
}
for (i = 0; i < sizeof(AuthVarCreateData); i++) {
if (data[i] != AuthVarCreateData[i]) {
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFISetAuthVarDiff",
"Get authenticated variable data are not the "
"same as it set.");
return FWTS_ERROR;
}
}
fwts_passed(fw, "Set authenticated variable created by different key test passed.");
ioret = setvar(>estguid, attributes, sizeof(AuthVarDelDiff), AuthVarDelDiff, &status);
if (ioret == -1) {
int supcheck = check_fw_support(fw, status);
if (supcheck != FWTS_OK)
return supcheck;
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIDelAuthVarDiff",
"Failed to delete authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
ioret = getvar(>estguid, &attributestest, &getdatasize, data, &status);
if (ioret == -1) {
if (status == EFI_NOT_FOUND) {
fwts_passed(fw, "Delete authenticated variable created by different key test passed.");
return FWTS_OK;
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIDelAuthVarDiff",
"Failed to get authenticated variable with UEFI "
"runtime service.");
fwts_uefi_print_status_info(fw, status);
return FWTS_ERROR;
}
fwts_failed(fw, LOG_LEVEL_HIGH,
"UEFIDelAuthVarDiff",
"Failed to delete authenticated variable still get the test"
"authenticated variable.");
return FWTS_ERROR;
}
