diff options
Diffstat (limited to 'host/lib/crossystem.c')
-rw-r--r-- | host/lib/crossystem.c | 235 |
1 files changed, 114 insertions, 121 deletions
diff --git a/host/lib/crossystem.c b/host/lib/crossystem.c index 216ff32c..5a758616 100644 --- a/host/lib/crossystem.c +++ b/host/lib/crossystem.c @@ -16,6 +16,10 @@ #include <fcntl.h> #include <unistd.h> +#include "2sysincludes.h" +#include "2api.h" +#include "2nvstorage.h" + #include "host_common.h" #include "crossystem.h" @@ -23,7 +27,6 @@ #include "crossystem_vbnv.h" #include "utility.h" #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Filename for kernel command line */ @@ -93,75 +96,58 @@ int FwidStartsWith(const char *start) static int vnc_read; -int VbGetNvStorage(VbNvParam param) +int vb2_get_nv_storage(enum vb2_nv_param param) { - uint32_t value; - int retval; - static VbNvContext cached_vnc; + static struct vb2_context cached_ctx; /* TODO: locking around NV access */ if (!vnc_read) { - if (0 != VbReadNvStorage(&cached_vnc)) + memset(&cached_ctx, 0, sizeof(cached_ctx)); + if (0 != vb2_read_nv_storage(&cached_ctx)) return -1; - vnc_read = 1; - } + vb2_nv_init(&cached_ctx); - if (0 != VbNvSetup(&cached_vnc)) - return -1; - retval = VbNvGet(&cached_vnc, param, &value); - if (0 != VbNvTeardown(&cached_vnc)) - return -1; - if (0 != retval) - return -1; + /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write + * and save the new defaults. If we're able to, log. */ - /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write and - * save the new defaults. If we're able to, log. */ - /* TODO: release lock */ + vnc_read = 1; + } - return (int)value; + return (int)vb2_nv_get(&cached_ctx, param); } -int VbSetNvStorage(VbNvParam param, int value) +int vb2_set_nv_storage(enum vb2_nv_param param, int value) { - VbNvContext vnc; - int retval = -1; - int i; + struct vb2_context ctx; - if (0 != VbReadNvStorage(&vnc)) + /* TODO: locking around NV access */ + memset(&ctx, 0, sizeof(ctx)); + if (0 != vb2_read_nv_storage(&ctx)) return -1; + vb2_nv_init(&ctx); + vb2_nv_set(&ctx, param, (uint32_t)value); - if (0 != VbNvSetup(&vnc)) - goto VbSetNvCleanup; - i = VbNvSet(&vnc, param, (uint32_t)value); - if (0 != VbNvTeardown(&vnc)) - goto VbSetNvCleanup; - if (0 != i) - goto VbSetNvCleanup; - - if (vnc.raw_changed) { + if (ctx.flags & VB2_CONTEXT_NVDATA_CHANGED) { vnc_read = 0; - if (0 != VbWriteNvStorage(&vnc)) - goto VbSetNvCleanup; + if (0 != vb2_write_nv_storage(&ctx)) + return -1; } /* Success */ - retval = 0; - -VbSetNvCleanup: - /* TODO: release lock */ - return retval; + return 0; } /* - * 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. + * Set a param value, and try to flag it for persistent backup. It's okay if + * backup isn't supported (which it isn't, in current designs). It's + * best-effort only. */ -static int VbSetNvStorage_WithBackup(VbNvParam param, int value) +static int vb2_set_nv_storage_with_backup(enum vb2_nv_param param, int value) { int retval; - retval = VbSetNvStorage(param, value); + retval = vb2_set_nv_storage(param, value); if (!retval) - VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, 1); + vb2_set_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST, 1); return retval; } @@ -468,63 +454,62 @@ int VbGetSystemPropertyInt(const char *name) /* NV storage values */ else if (!strcasecmp(name,"kern_nv")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); } else if (!strcasecmp(name,"nvram_cleared")) { - value = VbGetNvStorage(VBNV_KERNEL_SETTINGS_RESET); + value = vb2_get_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET); } else if (!strcasecmp(name,"recovery_request")) { - value = VbGetNvStorage(VBNV_RECOVERY_REQUEST); + value = vb2_get_nv_storage(VB2_NV_RECOVERY_REQUEST); } else if (!strcasecmp(name,"dbg_reset")) { - value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE); + value = vb2_get_nv_storage(VB2_NV_DEBUG_RESET_MODE); } else if (!strcasecmp(name,"disable_dev_request")) { - value = VbGetNvStorage(VBNV_DISABLE_DEV_REQUEST); + value = vb2_get_nv_storage(VB2_NV_DISABLE_DEV_REQUEST); } else if (!strcasecmp(name,"clear_tpm_owner_request")) { - value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST); + value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_REQUEST); } else if (!strcasecmp(name,"clear_tpm_owner_done")) { - value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE); + value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE); } else if (!strcasecmp(name,"tpm_rebooted")) { - value = VbGetNvStorage(VBNV_TPM_REQUESTED_REBOOT); - } else if (!strcasecmp(name,"fwb_tries")) { - value = VbGetNvStorage(VBNV_TRY_B_COUNT); + value = vb2_get_nv_storage(VB2_NV_TPM_REQUESTED_REBOOT); + } else if (!strcasecmp(name,"fwb_tries") || + !strcasecmp(name,"fw_try_count")) { + value = vb2_get_nv_storage(VB2_NV_TRY_COUNT); } else if (!strcasecmp(name,"fw_vboot2")) { value = GetVdatInt(VDAT_INT_FW_BOOT2); - } else if (!strcasecmp(name,"fw_try_count")) { - value = VbGetNvStorage(VBNV_FW_TRY_COUNT); } else if (!strcasecmp(name,"fwupdate_tries")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) value &= KERN_NV_FWUPDATE_TRIES_MASK; } else if (!strcasecmp(name,"block_devmode")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) { value &= KERN_NV_BLOCK_DEVMODE_FLAG; value = !!value; } } else if (!strcasecmp(name,"tpm_attack")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) { value &= KERN_NV_TPM_ATTACK_FLAG; value = !!value; } } else if (!strcasecmp(name,"loc_idx")) { - value = VbGetNvStorage(VBNV_LOCALIZATION_INDEX); + value = vb2_get_nv_storage(VB2_NV_LOCALIZATION_INDEX); } else if (!strcasecmp(name,"backup_nvram_request")) { - value = VbGetNvStorage(VBNV_BACKUP_NVRAM_REQUEST); + value = vb2_get_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST); } else if (!strcasecmp(name,"dev_boot_usb")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_USB); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_USB); } else if (!strcasecmp(name,"dev_boot_legacy")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_LEGACY); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_LEGACY); } else if (!strcasecmp(name,"dev_boot_signed_only")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_SIGNED_ONLY); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_SIGNED_ONLY); } else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_FASTBOOT_FULL_CAP); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP); } else if (!strcasecmp(name,"oprom_needed")) { - value = VbGetNvStorage(VBNV_OPROM_NEEDED); + value = vb2_get_nv_storage(VB2_NV_OPROM_NEEDED); } else if (!strcasecmp(name,"recovery_subcode")) { - value = VbGetNvStorage(VBNV_RECOVERY_SUBCODE); + value = vb2_get_nv_storage(VB2_NV_RECOVERY_SUBCODE); } else if (!strcasecmp(name,"wipeout_request")) { - value = VbGetNvStorage(VBNV_FW_REQ_WIPEOUT); + value = vb2_get_nv_storage(VB2_NV_REQ_WIPEOUT); } else if (!strcasecmp(name,"kernel_max_rollforward")) { - value = VbGetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD); } /* Other parameters */ else if (!strcasecmp(name,"cros_debug")) { @@ -550,13 +535,13 @@ int VbGetSystemPropertyInt(const char *name) } else if (!strcasecmp(name,"recovery_reason")) { value = GetVdatInt(VDAT_INT_RECOVERY_REASON); } else if (!strcasecmp(name, "fastboot_unlock_in_fw")) { - value = VbGetNvStorage(VBNV_FASTBOOT_UNLOCK_IN_FW); + value = vb2_get_nv_storage(VB2_NV_FASTBOOT_UNLOCK_IN_FW); } else if (!strcasecmp(name, "boot_on_ac_detect")) { - value = VbGetNvStorage(VBNV_BOOT_ON_AC_DETECT); + value = vb2_get_nv_storage(VB2_NV_BOOT_ON_AC_DETECT); } else if (!strcasecmp(name, "try_ro_sync")) { - value = VbGetNvStorage(VBNV_TRY_RO_SYNC); + value = vb2_get_nv_storage(VB2_NV_TRY_RO_SYNC); } else if (!strcasecmp(name, "battery_cutoff_request")) { - value = VbGetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST); + value = vb2_get_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST); } else if (!strcasecmp(name, "inside_vm")) { /* Detect if the host is a VM. If there is no HWID and the * firmware type is "nonchrome", then assume it is a VM. If @@ -604,25 +589,25 @@ const char *VbGetSystemPropertyString(const char *name, char *dest, } else if (!strcasecmp(name, "vdat_lkdebug")) { return GetVdatString(dest, size, VDAT_STRING_LOAD_KERNEL_DEBUG); } else if (!strcasecmp(name, "fw_try_next")) { - return VbGetNvStorage(VBNV_FW_TRY_NEXT) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_TRY_NEXT) ? "B" : "A"; } else if (!strcasecmp(name, "fw_tried")) { - return VbGetNvStorage(VBNV_FW_TRIED) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_FW_TRIED) ? "B" : "A"; } else if (!strcasecmp(name, "fw_result")) { - int v = VbGetNvStorage(VBNV_FW_RESULT); + int v = vb2_get_nv_storage(VB2_NV_FW_RESULT); if (v < ARRAY_SIZE(fw_results)) return fw_results[v]; else return "unknown"; } else if (!strcasecmp(name, "fw_prev_tried")) { - return VbGetNvStorage(VBNV_FW_PREV_TRIED) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_FW_PREV_TRIED) ? "B" : "A"; } else if (!strcasecmp(name, "fw_prev_result")) { - int v = VbGetNvStorage(VBNV_FW_PREV_RESULT); + int v = vb2_get_nv_storage(VB2_NV_FW_PREV_RESULT); if (v < ARRAY_SIZE(fw_results)) return fw_results[v]; else return "unknown"; } else if (!strcasecmp(name,"dev_default_boot")) { - int v = VbGetNvStorage(VBNV_DEV_DEFAULT_BOOT); + int v = vb2_get_nv_storage(VB2_NV_DEV_DEFAULT_BOOT); if (v < ARRAY_SIZE(default_boot)) return default_boot[v]; else @@ -644,82 +629,89 @@ int VbSetSystemPropertyInt(const char *name, int value) 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); + return vb2_set_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET, 0); } else if (!strcasecmp(name,"recovery_request")) { - return VbSetNvStorage(VBNV_RECOVERY_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_RECOVERY_REQUEST, value); } else if (!strcasecmp(name,"recovery_subcode")) { - return VbSetNvStorage(VBNV_RECOVERY_SUBCODE, value); + return vb2_set_nv_storage(VB2_NV_RECOVERY_SUBCODE, value); } else if (!strcasecmp(name,"dbg_reset")) { - return VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value); + return vb2_set_nv_storage(VB2_NV_DEBUG_RESET_MODE, value); } else if (!strcasecmp(name,"disable_dev_request")) { - return VbSetNvStorage(VBNV_DISABLE_DEV_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_DISABLE_DEV_REQUEST, value); } else if (!strcasecmp(name,"clear_tpm_owner_request")) { - return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_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); + return vb2_set_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE, 0); + } else if (!strcasecmp(name,"fwb_tries") || + !strcasecmp(name,"fw_try_count")) { + return vb2_set_nv_storage(VB2_NV_TRY_COUNT, value); } else if (!strcasecmp(name,"oprom_needed")) { - return VbSetNvStorage(VBNV_OPROM_NEEDED, value); + return vb2_set_nv_storage(VB2_NV_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); + return vb2_set_nv_storage(VB2_NV_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); + return vb2_set_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST, value); } else if (!strcasecmp(name,"fwupdate_tries")) { - int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); + int kern_nv = vb2_get_nv_storage(VB2_NV_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); + return vb2_set_nv_storage_with_backup(VB2_NV_KERNEL_FIELD, + kern_nv); } else if (!strcasecmp(name,"block_devmode")) { - int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); + int kern_nv = vb2_get_nv_storage(VB2_NV_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); + return vb2_set_nv_storage_with_backup(VB2_NV_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); + int kern_nv = vb2_get_nv_storage(VB2_NV_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); + return vb2_set_nv_storage_with_backup( + VB2_NV_KERNEL_FIELD, kern_nv); } else if (!strcasecmp(name,"loc_idx")) { - return VbSetNvStorage_WithBackup(VBNV_LOCALIZATION_INDEX, + return vb2_set_nv_storage_with_backup( + VB2_NV_LOCALIZATION_INDEX, value); } else if (!strcasecmp(name,"dev_boot_usb")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_USB, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_USB, value); } else if (!strcasecmp(name,"dev_boot_legacy")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_LEGACY, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_LEGACY, value); } else if (!strcasecmp(name,"dev_boot_signed_only")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_SIGNED_ONLY, - value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_SIGNED_ONLY, value); } else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) { - return VbSetNvStorage_WithBackup( - VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, value); } else if (!strcasecmp(name, "fastboot_unlock_in_fw")) { - return VbSetNvStorage_WithBackup(VBNV_FASTBOOT_UNLOCK_IN_FW, - value); + return vb2_set_nv_storage_with_backup( + VB2_NV_FASTBOOT_UNLOCK_IN_FW, value); } else if (!strcasecmp(name, "boot_on_ac_detect")) { - return VbSetNvStorage_WithBackup(VBNV_BOOT_ON_AC_DETECT, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_BOOT_ON_AC_DETECT, value); } else if (!strcasecmp(name, "try_ro_sync")) { - return VbSetNvStorage_WithBackup(VBNV_TRY_RO_SYNC, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_TRY_RO_SYNC, value); } else if (!strcasecmp(name, "battery_cutoff_request")) { - return VbSetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST, value); } else if (!strcasecmp(name,"kernel_max_rollforward")) { - return VbSetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD, value); + return vb2_set_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD, value); } return -1; @@ -733,9 +725,9 @@ int VbSetSystemPropertyString(const char* name, const char* value) if (!strcasecmp(name, "fw_try_next")) { if (!strcasecmp(value, "A")) - return VbSetNvStorage(VBNV_FW_TRY_NEXT, 0); + return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 0); else if (!strcasecmp(value, "B")) - return VbSetNvStorage(VBNV_FW_TRY_NEXT, 1); + return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 1); else return -1; @@ -744,7 +736,7 @@ int VbSetSystemPropertyString(const char* name, const char* value) for (i = 0; i < ARRAY_SIZE(fw_results); i++) { if (!strcasecmp(value, fw_results[i])) - return VbSetNvStorage(VBNV_FW_RESULT, i); + return vb2_set_nv_storage(VB2_NV_FW_RESULT, i); } return -1; } else if (!strcasecmp(name, "dev_default_boot")) { @@ -752,7 +744,8 @@ int VbSetSystemPropertyString(const char* name, const char* value) for (i = 0; i < ARRAY_SIZE(default_boot); i++) { if (!strcasecmp(value, default_boot[i])) - return VbSetNvStorage(VBNV_DEV_DEFAULT_BOOT, i); + return vb2_set_nv_storage( + VB2_NV_DEV_DEFAULT_BOOT, i); } return -1; } @@ -839,7 +832,7 @@ static int ExecuteMosys(char * const argv[], char *buf, size_t bufsize) return 0; } -int VbReadNvStorage_mosys(VbNvContext *vnc) +int vb2_read_nv_storage_mosys(struct vb2_context *ctx) { char hexstring[VBNV_BLOCK_SIZE * 2 + 32]; /* Reserve extra 32 bytes */ char * const argv[] = { @@ -855,12 +848,12 @@ int VbReadNvStorage_mosys(VbNvContext *vnc) for (i = 0; i < VBNV_BLOCK_SIZE; i++) { hexdigit[0] = hexstring[i * 2]; hexdigit[1] = hexstring[i * 2 + 1]; - vnc->raw[i] = strtol(hexdigit, NULL, 16); + ctx->nvdata[i] = strtol(hexdigit, NULL, 16); } return 0; } -int VbWriteNvStorage_mosys(VbNvContext* vnc) +int vb2_write_nv_storage_mosys(struct vb2_context *ctx) { char hexstring[VBNV_BLOCK_SIZE * 2 + 1]; char * const argv[] = { @@ -870,7 +863,7 @@ int VbWriteNvStorage_mosys(VbNvContext* vnc) int i; for (i = 0; i < VBNV_BLOCK_SIZE; i++) - snprintf(hexstring + i * 2, 3, "%02x", vnc->raw[i]); + snprintf(hexstring + i * 2, 3, "%02x", ctx->nvdata[i]); hexstring[sizeof(hexstring) - 1] = '\0'; if (ExecuteMosys(argv, NULL, 0)) return -1; |