| /* 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 <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #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"}, | |
| {"dev_fastboot_en", CAN_WRITE, "Enable fastboot in developer mode"}, | |
| {"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?"}, | |
| {"oem_lock", CAN_WRITE, "Device OEM Lock state"}, | |
| {"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"}, | |
| {"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; | |
| } |