/* Copyright 2012 The ChromiumOS Authors * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. * * Chrome OS firmware/system interface utility */ #include #include #include #include "crossystem.h" /* Flags for Param */ #define IS_STRING 0x01 /* String (not present = integer) */ #define CAN_WRITE 0x02 /* Writable (not present = read-only */ #define NO_PRINT_ALL 0x04 /* Don't print contents of parameter when * doing a print-all */ typedef struct Param { const char* name; /* Parameter name */ int flags; /* Flags (see above) */ const char* desc; /* Human-readable description */ const char* format; /* Format string, if non-NULL and 0==is_string*/ } Param; /* List of parameters, terminated with a param with NULL name */ const Param sys_param_list[] = { {"act_fwver", 0, "Active firmware version", "0x%08x"}, {"act_kernver", 0, "Active kernel version", "0x%08x"}, {"arch", IS_STRING, "Platform architecture"}, {"backup_nvram_request", CAN_WRITE, "Backup the nvram somewhere at the next boot. Cleared on success."}, {"battery_cutoff_request", CAN_WRITE, "Cut off battery and shutdown on next boot"}, {"block_devmode", CAN_WRITE, "Block all use of developer mode"}, {"board_id", 0, "Board hardware revision number"}, {"clear_tpm_owner_done", CAN_WRITE, "Clear TPM owner done"}, {"clear_tpm_owner_request", CAN_WRITE, "Clear TPM owner on next boot"}, {"cros_debug", 0, "OS should allow debug features"}, {"dbg_reset", CAN_WRITE, "Debug reset mode request"}, {"debug_build", 0, "OS image built for debug features"}, {"dev_boot_altfw", CAN_WRITE, "Enable developer mode alternate bootloader"}, {"dev_boot_signed_only", CAN_WRITE, "Enable developer mode boot only from official kernels"}, {"dev_boot_usb", CAN_WRITE, "Enable developer mode boot from external disk (USB/SD)"}, {"dev_default_boot", IS_STRING|CAN_WRITE, "Default boot from disk, altfw or usb"}, {"dev_enable_udc", CAN_WRITE, "Enable USB Device Controller"}, {"devsw_boot", 0, "Developer switch position at boot"}, {"devsw_cur", 0, "Developer switch current position"}, {"diagnostic_request", CAN_WRITE, "Request diagnostic rom run on next boot"}, {"disable_dev_request", CAN_WRITE, "Disable virtual dev-mode on next boot"}, {"ecfw_act", IS_STRING, "Active EC firmware"}, {"post_ec_sync_delay", CAN_WRITE, "Short delay after EC software sync (persistent, writable, eve only)"}, {"fw_prev_result", IS_STRING, "Firmware result of previous boot"}, {"fw_prev_tried", IS_STRING, "Firmware tried on previous boot (A or B)"}, {"fw_result", IS_STRING|CAN_WRITE, "Firmware result this boot"}, {"fw_tried", IS_STRING, "Firmware tried this boot (A or B)"}, {"fw_try_count", CAN_WRITE, "Number of times to try fw_try_next"}, {"fw_try_next", IS_STRING|CAN_WRITE, "Firmware to try next (A or B)"}, {"fw_vboot2", 0, "1 if firmware was selected by vboot2 or 0 otherwise"}, {"fwid", IS_STRING, "Active firmware ID"}, {"fwupdate_tries", CAN_WRITE, "Times to try OS firmware update (inside kern_nv)"}, {"hwid", IS_STRING, "Hardware ID"}, {"inside_vm", 0, "Running in a VM?"}, {"kern_nv", 0, "Non-volatile field for kernel use", "0x%04x"}, {"kernel_max_rollforward", CAN_WRITE, "Max kernel version to store into TPM", "0x%08x"}, {"kernkey_vfy", IS_STRING, "Type of verification done on kernel keyblock"}, {"loc_idx", CAN_WRITE, "Localization index for firmware screens"}, {"mainfw_act", IS_STRING, "Active main firmware"}, {"mainfw_type", IS_STRING, "Active main firmware type"}, {"minios_priority", IS_STRING|CAN_WRITE, "miniOS image to try first (A or B)"}, {"nvram_cleared", CAN_WRITE, "Have NV settings been lost? Write 0 to clear"}, {"display_request", CAN_WRITE, "Should we initialize the display at boot?"}, {"phase_enforcement", 0, "Board should have full security settings applied"}, {"recovery_reason", 0, "Recovery mode reason for current boot"}, {"recovery_request", CAN_WRITE, "Recovery mode request"}, {"recovery_subcode", CAN_WRITE, "Recovery reason subcode"}, {"recoverysw_boot", 0, "Recovery switch position at boot"}, {"recoverysw_cur", 0, "Recovery switch current position"}, {"recoverysw_ec_boot", 0, "Recovery switch position at EC boot"}, {"ro_fwid", IS_STRING, "Read-only firmware ID"}, {"tpm_attack", CAN_WRITE, "TPM was interrupted since this flag was cleared"}, {"tpm_fwver", 0, "Firmware version stored in TPM", "0x%08x"}, {"tpm_kernver", 0, "Kernel version stored in TPM", "0x%08x"}, {"tpm_rebooted", 0, "TPM requesting repeated reboot"}, {"try_ro_sync", 0, "try read only software sync"}, {"vdat_flags", 0, "Flags from VbSharedData", "0x%08x"}, {"vdat_lfdebug", IS_STRING|NO_PRINT_ALL, "LoadFirmware() debug data (not in print-all)"}, {"wipeout_request", CAN_WRITE, "Firmware requested factory reset (wipeout)"}, {"wpsw_cur", 0, "Firmware write protect hardware switch current position"}, /* Terminate with null name */ {NULL, 0, NULL} }; /* Longest Param name. */ static const int kNameWidth = 23; /* Print help */ static void PrintHelp(const char *progname) { const Param *p; printf("Usage:\n" " %s [--all]\n" " Prints all parameters with descriptions and current values.\n" " If --all is specified, prints even normally hidden fields.\n" " %s [param1 [param2 [...]]]\n" " Prints the current value(s) of the parameter(s).\n" " %s [param1=value1] [param2=value2 [...]]]\n" " Sets the parameter(s) to the specified value(s).\n" " %s [param1?value1] [param2?value2 [...]]]\n" " Checks if the parameter(s) all contain the specified value(s).\n" " Stops at the first error.\n" "\n" "Valid parameters:\n", progname, progname, progname, progname); for (p = sys_param_list; p->name; p++) { printf(" %-*s [%s/%s] %s\n", kNameWidth, p->name, (p->flags & CAN_WRITE) ? "RW" : "RO", (p->flags & IS_STRING) ? "str" : "int", p->desc); } printf("\n" "For more information, please see:\n" "https://chromium.googlesource.com/chromiumos/docs/+/HEAD/" "os_config.md#crossystem\n"); } /* Find the parameter in the list. * * Returns the parameter, or NULL if no match. */ static const Param* FindParam(const char* name) { const Param* p; if (!name) return NULL; /* "legacy" term deprecated in favour of "altfw" (see: b/179458327) */ if (!strcasecmp(name, "dev_boot_legacy")) { fprintf(stderr, "!!!\n" "!!! PLEASE USE 'dev_boot_altfw' INSTEAD OF 'dev_boot_legacy'\n" "!!!\n"); name = "dev_boot_altfw"; } for (p = sys_param_list; p->name; p++) { if (!strcasecmp(p->name, name)) return p; } return NULL; } /* Return code of SetParam() below. */ enum { PARAM_SUCCESS = 0, PARAM_ERROR_UNKNOWN, PARAM_ERROR_READ_ONLY, PARAM_ERROR_INVALID_INT, }; /* Set the specified parameter. * * Returns PARAM_SUCCESS if success, PARAM_ERROR_* if error. */ static int SetParam(const Param* p, const char* value) { if (!(p->flags & CAN_WRITE)) return PARAM_ERROR_READ_ONLY; if (p->flags & IS_STRING) { return (0 == VbSetSystemPropertyString(p->name, value) ? 0 : PARAM_ERROR_UNKNOWN); } else { char* e; int i = (int)strtol(value, &e, 0); if (!*value || (e && *e)) return PARAM_ERROR_INVALID_INT; return (0 == VbSetSystemPropertyInt(p->name, i) ? 0 : PARAM_ERROR_UNKNOWN); } } /* Compares the parameter with the expected value. * * Returns 0 if success (match), non-zero if error (mismatch). */ static int CheckParam(const Param* p, const char* expect) { if (p->flags & IS_STRING) { char buf[VB_MAX_STRING_PROPERTY]; const int v = VbGetSystemPropertyString(p->name, buf, sizeof(buf)); if (v != 0 || 0 != strcmp(buf, expect)) return 1; } else { char* e; int i = (int)strtol(expect, &e, 0); int v = VbGetSystemPropertyInt(p->name); if (!*expect || (e && *e)) return 1; if (v == -1 || i != v) return 1; } return 0; } /* Print the specified parameter. * * Returns 0 if success, non-zero if error. */ static int PrintParam(const Param* p) { if (p->flags & IS_STRING) { char buf[VB_MAX_STRING_PROPERTY]; const int v = VbGetSystemPropertyString(p->name, buf, sizeof(buf)); if (v != 0) return 1; printf("%s", buf); } else { int v = VbGetSystemPropertyInt(p->name); if (v == -1) return 1; printf(p->format ? p->format : "%d", v); } return 0; } /* Print all parameters with descriptions. If force_all!=0, prints even * parameters that specify the NO_PRINT_ALL flag. * * Returns 0 if success, non-zero if error. */ static int PrintAllParams(int force_all) { const Param* p; int retval = 0; char buf[VB_MAX_STRING_PROPERTY]; int result = 0; for (p = sys_param_list; p->name; p++) { if (force_all == 0 && (p->flags & NO_PRINT_ALL)) continue; if (p->flags & IS_STRING) { result = VbGetSystemPropertyString(p->name, buf, sizeof(buf)); } else { result = VbGetSystemPropertyInt(p->name); if (result != -1) snprintf(buf, sizeof(buf), p->format ? p->format : "%d", result); } printf("%-*s = %-30s # [%s/%s] %s\n", kNameWidth, p->name, ((result != -1) ? buf : "(error)"), (p->flags & CAN_WRITE) ? "RW" : "RO", (p->flags & IS_STRING) ? "str" : "int", p->desc); } return retval; } int main(int argc, char* argv[]) { int retval = 0; int i; char* progname = strrchr(argv[0], '/'); if (progname) progname++; else progname = argv[0]; /* If no args specified, print all params */ if (argc == 1) return PrintAllParams(0); /* --all or -a prints all params including normally hidden ones */ if (!strcasecmp(argv[1], "--all") || !strcmp(argv[1], "-a")) return PrintAllParams(1); /* Print help if needed */ if (!strcasecmp(argv[1], "-h") || !strcmp(argv[1], "-?") || !strcmp(argv[1], "--help")) { PrintHelp(progname); return 0; } /* Otherwise, loop through params and get/set them */ for (i = 1; i < argc && retval == 0; i++) { char* has_set = strchr(argv[i], '='); char* has_expect = strchr(argv[i], '?'); char* name = strtok(argv[i], "=?"); const char* value = strtok(NULL, "=?"); const Param* p; /* Make sure args are well-formed. '' or '=foo' or '?foo' not allowed. */ if (!name || has_set == argv[i] || has_expect == argv[i]) { fprintf(stderr, "Poorly formed parameter\n"); PrintHelp(progname); return 1; } if (!value) value=""; /* Allow setting/checking an empty string ('foo=' or 'foo?') */ if (has_set && has_expect) { fprintf(stderr, "Use either = or ? in a parameter, but not both.\n"); PrintHelp(progname); return 1; } /* Find the parameter */ p = FindParam(name); if (!p) { fprintf(stderr, "Invalid parameter name: %s\n", name); PrintHelp(progname); return 1; } if (i > 1) printf(" "); /* Output params space-delimited */ if (has_set) { retval = SetParam(p, value); switch (retval) { case PARAM_SUCCESS: break; case PARAM_ERROR_READ_ONLY: fprintf(stderr, "Parameter %s is read-only\n", p->name); break; case PARAM_ERROR_INVALID_INT: fprintf(stderr, "Value %s is not a valid integer\n", value); break; default: fprintf(stderr, "Failed to set parameter %s\n", p->name); break; } } else if (has_expect) retval = CheckParam(p, value); else retval = PrintParam(p); } return retval; }