int VbSetSystemPropertyString(const char* name, const char* value) {
/* Chain to architecture-dependent properties */
if (0 == VbSetArchPropertyString(name, value))
return 0;
if (!strcasecmp(name, "fw_try_next")) {
if (!strcasecmp(value, "A"))
return VbSetNvStorage(VBNV_FW_TRY_NEXT, 0);
else if (!strcasecmp(value, "B"))
return VbSetNvStorage(VBNV_FW_TRY_NEXT, 1);
else
return -1;
} else if (!strcasecmp(name, "fw_result")) {
int i;
for (i = 0; i < ARRAY_SIZE(fw_results); i++) {
if (!strcasecmp(value, fw_results[i]))
return VbSetNvStorage(VBNV_FW_RESULT, i);
}
return -1;
} else if (!strcasecmp(name, "dev_default_boot")) {
int i;
for (i = 0; i < ARRAY_SIZE(default_boot); i++) {
if (!strcasecmp(value, default_boot[i]))
return VbSetNvStorage(VBNV_DEV_DEFAULT_BOOT, i);
}
return -1;
}
return -1;
}
/*
* Set a param value, and try to flag it for persistent backup.
* It's okay if backup isn't supported. It's best-effort only.
*/
static int VbSetNvStorage_WithBackup(VbNvParam param, int value)
{
int retval;
retval = VbSetNvStorage(param, value);
if (!retval)
VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, 1);
return retval;
}
int VbSetArchPropertyInt(const char* name, int value) {
/* NV storage values. If unable to get from NV storage, fall back to the
* CMOS reboot field used by older BIOS. */
if (!strcasecmp(name,"recovery_request")) {
if (0 == VbSetNvStorage(VBNV_RECOVERY_REQUEST, value))
return 0;
return VbSetCmosRebootField(CMOSRF_RECOVERY, value);
} else if (!strcasecmp(name,"dbg_reset")) {
if (0 == VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value))
return 0;
return VbSetCmosRebootField(CMOSRF_DEBUG_RESET, value);
} else if (!strcasecmp(name,"fwb_tries")) {
if (0 == VbSetNvStorage(VBNV_TRY_B_COUNT, value))
return 0;
return VbSetCmosRebootField(CMOSRF_TRY_B, value);
}
/* Firmware update tries is now stored in the kernel field. On
* older systems where it's not, it was stored in a file in the
* stateful partition. */
else if (!strcasecmp(name,"fwupdate_tries")) {
if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD))
return -1; /* NvStorage supported; fail through arch-specific
* implementation to normal implementation */
if (value) {
char buf[32];
snprintf(buf, sizeof(buf), "%d", value);
return WriteFile(NEED_FWUPDATE_PATH, buf, strlen(buf));
} else {
/* No update tries, so remove file if it exists. */
unlink(NEED_FWUPDATE_PATH);
return 0;
}
}
return -1;
}
int VbSetSystemPropertyInt(const char* name, int value) {
/* Check architecture-dependent properties first */
if (0 == VbSetArchPropertyInt(name, value))
return 0;
/* NV storage values */
if (!strcasecmp(name,"nvram_cleared")) {
/* Can only clear this flag; it's set inside the NV storage library. */
return VbSetNvStorage(VBNV_KERNEL_SETTINGS_RESET, 0);
} else if (!strcasecmp(name,"recovery_request")) {
return VbSetNvStorage(VBNV_RECOVERY_REQUEST, value);
} else if (!strcasecmp(name,"recovery_subcode")) {
return VbSetNvStorage(VBNV_RECOVERY_SUBCODE, value);
} else if (!strcasecmp(name,"dbg_reset")) {
return VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value);
} else if (!strcasecmp(name,"disable_dev_request")) {
return VbSetNvStorage(VBNV_DISABLE_DEV_REQUEST, value);
} else if (!strcasecmp(name,"clear_tpm_owner_request")) {
return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST, value);
} else if (!strcasecmp(name,"clear_tpm_owner_done")) {
/* Can only clear this flag; it's set by firmware. */
return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE, 0);
} else if (!strcasecmp(name,"fwb_tries")) {
return VbSetNvStorage(VBNV_TRY_B_COUNT, value);
} else if (!strcasecmp(name,"fw_try_count")) {
return VbSetNvStorage(VBNV_FW_TRY_COUNT, value);
} else if (!strcasecmp(name,"oprom_needed")) {
return VbSetNvStorage(VBNV_OPROM_NEEDED, value);
} else if (!strcasecmp(name,"wipeout_request")) {
/* Can only clear this flag, set only by firmware. */
return VbSetNvStorage(VBNV_FW_REQ_WIPEOUT, 0);
} else if (!strcasecmp(name,"backup_nvram_request")) {
/* Best-effort only, since it requires firmware and TPM support. */
return VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, value);
} else if (!strcasecmp(name,"fwupdate_tries")) {
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_FWUPDATE_TRIES_MASK;
kern_nv |= (value & KERN_NV_FWUPDATE_TRIES_MASK);
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
} else if (!strcasecmp(name,"block_devmode")) {
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_BLOCK_DEVMODE_FLAG;
if (value)
kern_nv |= KERN_NV_BLOCK_DEVMODE_FLAG;
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
} else if (!strcasecmp(name,"tpm_attack")) {
/* This value should only be read and cleared, but we allow setting it to 1
* for testing.
*/
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_TPM_ATTACK_FLAG;
if (value)
kern_nv |= KERN_NV_TPM_ATTACK_FLAG;
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
} else if (!strcasecmp(name,"loc_idx")) {
return VbSetNvStorage_WithBackup(VBNV_LOCALIZATION_INDEX, value);
} else if (!strcasecmp(name,"dev_boot_usb")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_USB, value);
} else if (!strcasecmp(name,"dev_boot_legacy")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_LEGACY, value);
} else if (!strcasecmp(name,"dev_boot_signed_only")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_SIGNED_ONLY, value);
} else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, value);
} else if (!strcasecmp(name, "fastboot_unlock_in_fw")) {
return VbSetNvStorage_WithBackup(VBNV_FASTBOOT_UNLOCK_IN_FW, value);
} else if (!strcasecmp(name, "boot_on_ac_detect")) {
return VbSetNvStorage_WithBackup(VBNV_BOOT_ON_AC_DETECT, value);
} else if (!strcasecmp(name, "try_ro_sync")) {
return VbSetNvStorage_WithBackup(VBNV_TRY_RO_SYNC, value);
}
return -1;
}
