Randall Spangler | c0e3742 | 2012-06-08 12:30:17 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 2 | * Use of this source code is governed by a BSD-style license that can be |
| 3 | * found in the LICENSE file. |
| 4 | */ |
| 5 | |
| 6 | #include <stdio.h> |
| 7 | #include <string.h> |
Vadim Bendebury | 2008423 | 2011-03-15 09:29:48 -0700 | [diff] [blame] | 8 | #include <sys/types.h> |
| 9 | #include <sys/stat.h> |
| 10 | #include <unistd.h> |
| 11 | #include <ctype.h> |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 12 | |
| 13 | #include "host_common.h" |
| 14 | |
| 15 | #include "crossystem.h" |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 16 | #include "crossystem_arch.h" |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 17 | #include "utility.h" |
| 18 | #include "vboot_common.h" |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 19 | #include "vboot_nvstorage.h" |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 20 | #include "vboot_struct.h" |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 21 | |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 22 | /* Filename for kernel command line */ |
| 23 | #define KERNEL_CMDLINE_PATH "/proc/cmdline" |
| 24 | |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 25 | /* Fields that GetVdatString() can get */ |
| 26 | typedef enum VdatStringField { |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 27 | VDAT_STRING_TIMERS = 0, /* Timer values */ |
| 28 | VDAT_STRING_LOAD_FIRMWARE_DEBUG, /* LoadFirmware() debug information */ |
Randall Spangler | a185b8d | 2011-07-15 16:28:38 -0700 | [diff] [blame] | 29 | VDAT_STRING_LOAD_KERNEL_DEBUG, /* LoadKernel() debug information */ |
| 30 | VDAT_STRING_MAINFW_ACT /* Active main firmware */ |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 31 | } VdatStringField; |
| 32 | |
| 33 | |
| 34 | /* Fields that GetVdatInt() can get */ |
| 35 | typedef enum VdatIntField { |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 36 | VDAT_INT_FLAGS = 0, /* Flags */ |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 37 | VDAT_INT_HEADER_VERSION, /* Header version for VbSharedData */ |
| 38 | VDAT_INT_DEVSW_BOOT, /* Dev switch position at boot */ |
| 39 | VDAT_INT_DEVSW_VIRTUAL, /* Dev switch is virtual */ |
| 40 | VDAT_INT_RECSW_BOOT, /* Recovery switch position at boot */ |
| 41 | VDAT_INT_WPSW_BOOT, /* WP switch position at boot */ |
| 42 | |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 43 | VDAT_INT_FW_VERSION_TPM, /* Current firmware version in TPM */ |
| 44 | VDAT_INT_KERNEL_VERSION_TPM, /* Current kernel version in TPM */ |
| 45 | VDAT_INT_TRIED_FIRMWARE_B, /* Tried firmware B due to fwb_tries */ |
Randall Spangler | 7adcc60 | 2011-06-24 16:11:45 -0700 | [diff] [blame] | 46 | VDAT_INT_KERNEL_KEY_VERIFIED, /* Kernel key verified using |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 47 | * signature, not just hash */ |
Randall Spangler | 7adcc60 | 2011-06-24 16:11:45 -0700 | [diff] [blame] | 48 | VDAT_INT_RECOVERY_REASON /* Recovery reason for current boot */ |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 49 | } VdatIntField; |
| 50 | |
| 51 | |
Randall Spangler | ff3f000 | 2011-07-26 10:43:53 -0700 | [diff] [blame] | 52 | /* Masks for kern_nv usage by kernel. */ |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 53 | #define KERN_NV_FWUPDATE_TRIES_MASK 0x0000000F |
Randall Spangler | ff3f000 | 2011-07-26 10:43:53 -0700 | [diff] [blame] | 54 | /* If you want to use the remaining currently-unused bits in kern_nv |
| 55 | * for something kernel-y, define a new field (the way we did for |
| 56 | * fwupdate_tries). Don't just modify kern_nv directly, because that |
| 57 | * makes it too easy to accidentally corrupt other sub-fields. */ |
| 58 | #define KERN_NV_CURRENTLY_UNUSED 0xFFFFFFF0 |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 59 | |
Randall Spangler | c80fe65 | 2011-02-17 11:06:47 -0800 | [diff] [blame] | 60 | /* Return true if the FWID starts with the specified string. */ |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 61 | int FwidStartsWith(const char *start) { |
Randall Spangler | c80fe65 | 2011-02-17 11:06:47 -0800 | [diff] [blame] | 62 | char fwid[128]; |
| 63 | if (!VbGetSystemPropertyString("fwid", fwid, sizeof(fwid))) |
| 64 | return 0; |
| 65 | |
| 66 | return 0 == strncmp(fwid, start, strlen(start)); |
| 67 | } |
| 68 | |
| 69 | |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 70 | int VbGetNvStorage(VbNvParam param) { |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 71 | VbNvContext vnc; |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 72 | uint32_t value; |
| 73 | int retval; |
| 74 | |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 75 | /* TODO: locking around NV access */ |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 76 | |
| 77 | if (0 != VbReadNvStorage(&vnc)) |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 78 | return -1; |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 79 | if (0 != VbNvSetup(&vnc)) |
| 80 | return -1; |
| 81 | retval = VbNvGet(&vnc, param, &value); |
| 82 | if (0 != VbNvTeardown(&vnc)) |
| 83 | return -1; |
| 84 | if (0 != retval) |
| 85 | return -1; |
| 86 | |
| 87 | /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write and |
| 88 | * save the new defaults. If we're able to, log. */ |
| 89 | /* TODO: release lock */ |
| 90 | |
| 91 | return (int)value; |
| 92 | } |
| 93 | |
| 94 | |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 95 | int VbSetNvStorage(VbNvParam param, int value) { |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 96 | VbNvContext vnc; |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 97 | int retval = -1; |
| 98 | int i; |
| 99 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 100 | if (0 != VbReadNvStorage(&vnc)) |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 101 | return -1; |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 102 | |
| 103 | if (0 != VbNvSetup(&vnc)) |
| 104 | goto VbSetNvCleanup; |
| 105 | i = VbNvSet(&vnc, param, (uint32_t)value); |
| 106 | if (0 != VbNvTeardown(&vnc)) |
| 107 | goto VbSetNvCleanup; |
| 108 | if (0 != i) |
| 109 | goto VbSetNvCleanup; |
| 110 | |
| 111 | if (vnc.raw_changed) { |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 112 | if (0 != VbWriteNvStorage(&vnc)) |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 113 | goto VbSetNvCleanup; |
| 114 | } |
| 115 | |
| 116 | /* Success */ |
| 117 | retval = 0; |
| 118 | |
| 119 | VbSetNvCleanup: |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 120 | /* TODO: release lock */ |
| 121 | return retval; |
| 122 | } |
| 123 | |
| 124 | |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 125 | /* Determine whether OS-level debugging should be allowed. Passed the |
| 126 | * destination and its size. Returns 1 if yes, 0 if no, -1 if error. */ |
| 127 | int VbGetCrosDebug(void) { |
| 128 | FILE* f = NULL; |
| 129 | char buf[4096] = ""; |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 130 | char *t, *saveptr; |
| 131 | |
J. Richard Barnette | dbffddc | 2011-08-25 11:22:43 -0700 | [diff] [blame] | 132 | /* If the currently running system specifies its debug status, use |
| 133 | * that in preference to other indicators. */ |
| 134 | f = fopen(KERNEL_CMDLINE_PATH, "r"); |
| 135 | if (NULL != f) { |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 136 | if (NULL == fgets(buf, sizeof(buf), f)) |
J. Richard Barnette | dbffddc | 2011-08-25 11:22:43 -0700 | [diff] [blame] | 137 | buf[0] = 0; |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 138 | fclose(f); |
| 139 | } |
| 140 | for (t = strtok_r(buf, " ", &saveptr); t; t=strtok_r(NULL, " ", &saveptr)) { |
| 141 | if (0 == strcmp(t, "cros_debug")) |
| 142 | return 1; |
Randall Spangler | 227f792 | 2011-03-11 13:34:56 -0800 | [diff] [blame] | 143 | else if (0 == strcmp(t, "cros_nodebug")) |
| 144 | return 0; |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 145 | } |
| 146 | |
J. Richard Barnette | dbffddc | 2011-08-25 11:22:43 -0700 | [diff] [blame] | 147 | /* Command line is silent; allow debug if the dev switch is on. */ |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 148 | if (1 == VbGetSystemPropertyInt("devsw_boot")) |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 149 | return 1; |
| 150 | |
| 151 | /* All other cases disallow debug. */ |
| 152 | return 0; |
| 153 | } |
| 154 | |
Randall Spangler | b47ed5a | 2011-02-23 13:05:40 -0800 | [diff] [blame] | 155 | |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 156 | char* GetVdatLoadFirmwareDebug(char* dest, int size, |
| 157 | const VbSharedDataHeader* sh) { |
| 158 | snprintf(dest, size, |
| 159 | "Check A result=%d\n" |
| 160 | "Check B result=%d\n" |
| 161 | "Firmware index booted=0x%02x\n" |
| 162 | "TPM combined version at start=0x%08x\n" |
| 163 | "Lowest combined version from firmware=0x%08x\n", |
| 164 | sh->check_fw_a_result, |
| 165 | sh->check_fw_b_result, |
| 166 | sh->firmware_index, |
| 167 | sh->fw_version_tpm_start, |
| 168 | sh->fw_version_lowest); |
| 169 | return dest; |
| 170 | } |
| 171 | |
| 172 | |
| 173 | #define TRUNCATED "\n(truncated)\n" |
| 174 | |
| 175 | char* GetVdatLoadKernelDebug(char* dest, int size, |
| 176 | const VbSharedDataHeader* sh) { |
| 177 | int used = 0; |
| 178 | int first_call_tracked = 0; |
| 179 | int call; |
| 180 | |
| 181 | /* Make sure we have space for truncation warning */ |
| 182 | if (size < strlen(TRUNCATED) + 1) |
| 183 | return NULL; |
| 184 | size -= strlen(TRUNCATED) + 1; |
| 185 | |
| 186 | used += snprintf( |
| 187 | dest + used, size - used, |
| 188 | "Calls to LoadKernel()=%d\n", |
| 189 | sh->lk_call_count); |
| 190 | if (used > size) |
| 191 | goto LoadKernelDebugExit; |
| 192 | |
| 193 | /* Report on the last calls */ |
| 194 | if (sh->lk_call_count > VBSD_MAX_KERNEL_CALLS) |
| 195 | first_call_tracked = sh->lk_call_count - VBSD_MAX_KERNEL_CALLS; |
| 196 | for (call = first_call_tracked; call < sh->lk_call_count; call++) { |
| 197 | const VbSharedDataKernelCall* shc = |
| 198 | sh->lk_calls + (call & (VBSD_MAX_KERNEL_CALLS - 1)); |
| 199 | int first_part_tracked = 0; |
| 200 | int part; |
| 201 | |
| 202 | used += snprintf( |
| 203 | dest + used, size - used, |
| 204 | "Call %d:\n" |
| 205 | " Boot flags=0x%02x\n" |
| 206 | " Boot mode=%d\n" |
| 207 | " Test error=%d\n" |
| 208 | " Return code=%d\n" |
| 209 | " Debug flags=0x%02x\n" |
| 210 | " Drive sectors=%" PRIu64 "\n" |
| 211 | " Sector size=%d\n" |
| 212 | " Check result=%d\n" |
| 213 | " Kernel partitions found=%d\n", |
| 214 | call + 1, |
| 215 | shc->boot_flags, |
| 216 | shc->boot_mode, |
| 217 | shc->test_error_num, |
| 218 | shc->return_code, |
| 219 | shc->flags, |
| 220 | shc->sector_count, |
| 221 | shc->sector_size, |
| 222 | shc->check_result, |
| 223 | shc->kernel_parts_found); |
| 224 | if (used > size) |
| 225 | goto LoadKernelDebugExit; |
| 226 | |
| 227 | /* If we found too many partitions, only prints ones where the |
| 228 | * structure has info. */ |
| 229 | if (shc->kernel_parts_found > VBSD_MAX_KERNEL_PARTS) |
| 230 | first_part_tracked = shc->kernel_parts_found - VBSD_MAX_KERNEL_PARTS; |
| 231 | |
| 232 | /* Report on the partitions checked */ |
| 233 | for (part = first_part_tracked; part < shc->kernel_parts_found; part++) { |
| 234 | const VbSharedDataKernelPart* shp = |
| 235 | shc->parts + (part & (VBSD_MAX_KERNEL_PARTS - 1)); |
| 236 | |
| 237 | used += snprintf( |
| 238 | dest + used, size - used, |
| 239 | " Kernel %d:\n" |
| 240 | " GPT index=%d\n" |
| 241 | " Start sector=%" PRIu64 "\n" |
| 242 | " Sector count=%" PRIu64 "\n" |
| 243 | " Combined version=0x%08x\n" |
| 244 | " Check result=%d\n" |
| 245 | " Debug flags=0x%02x\n", |
| 246 | part + 1, |
| 247 | shp->gpt_index, |
| 248 | shp->sector_start, |
| 249 | shp->sector_count, |
| 250 | shp->combined_version, |
| 251 | shp->check_result, |
| 252 | shp->flags); |
| 253 | if (used > size) |
| 254 | goto LoadKernelDebugExit; |
| 255 | } |
| 256 | } |
| 257 | |
| 258 | LoadKernelDebugExit: |
| 259 | |
| 260 | /* Warn if data was truncated; we left space for this above. */ |
| 261 | if (used > size) |
| 262 | strcat(dest, TRUNCATED); |
| 263 | |
| 264 | return dest; |
| 265 | } |
| 266 | |
| 267 | |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 268 | char* GetVdatString(char* dest, int size, VdatStringField field) |
| 269 | { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 270 | VbSharedDataHeader* sh = VbSharedDataRead(); |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 271 | char* value = dest; |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 272 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 273 | if (!sh) |
| 274 | return NULL; |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 275 | |
| 276 | switch (field) { |
| 277 | case VDAT_STRING_TIMERS: |
| 278 | snprintf(dest, size, |
| 279 | "LFS=%" PRIu64 ",%" PRIu64 |
| 280 | " LF=%" PRIu64 ",%" PRIu64 |
| 281 | " LK=%" PRIu64 ",%" PRIu64, |
Randall Spangler | 9619112 | 2011-07-08 14:01:54 -0700 | [diff] [blame] | 282 | sh->timer_vb_init_enter, |
| 283 | sh->timer_vb_init_exit, |
| 284 | sh->timer_vb_select_firmware_enter, |
| 285 | sh->timer_vb_select_firmware_exit, |
| 286 | sh->timer_vb_select_and_load_kernel_enter, |
| 287 | sh->timer_vb_select_and_load_kernel_exit); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 288 | break; |
| 289 | |
| 290 | case VDAT_STRING_LOAD_FIRMWARE_DEBUG: |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 291 | value = GetVdatLoadFirmwareDebug(dest, size, sh); |
| 292 | break; |
| 293 | |
| 294 | case VDAT_STRING_LOAD_KERNEL_DEBUG: |
| 295 | value = GetVdatLoadKernelDebug(dest, size, sh); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 296 | break; |
| 297 | |
Randall Spangler | a185b8d | 2011-07-15 16:28:38 -0700 | [diff] [blame] | 298 | case VDAT_STRING_MAINFW_ACT: |
| 299 | switch(sh->firmware_index) { |
| 300 | case 0: |
| 301 | StrCopy(dest, "A", size); |
| 302 | break; |
| 303 | case 1: |
| 304 | StrCopy(dest, "B", size); |
| 305 | break; |
| 306 | case 0xFF: |
| 307 | StrCopy(dest, "recovery", size); |
| 308 | break; |
| 309 | default: |
| 310 | value = NULL; |
| 311 | } |
| 312 | break; |
| 313 | |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 314 | default: |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 315 | value = NULL; |
| 316 | break; |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 317 | } |
| 318 | |
Randall Spangler | 32a6526 | 2011-06-27 10:49:11 -0700 | [diff] [blame] | 319 | free(sh); |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 320 | return value; |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | |
| 324 | int GetVdatInt(VdatIntField field) { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 325 | VbSharedDataHeader* sh = VbSharedDataRead(); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 326 | int value = -1; |
| 327 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 328 | if (!sh) |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 329 | return -1; |
| 330 | |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 331 | /* Fields supported in version 1 */ |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 332 | switch (field) { |
| 333 | case VDAT_INT_FLAGS: |
| 334 | value = (int)sh->flags; |
| 335 | break; |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 336 | case VDAT_INT_HEADER_VERSION: |
| 337 | value = sh->struct_version; |
Randall Spangler | 5ac39bf | 2011-03-17 17:58:56 -0700 | [diff] [blame] | 338 | break; |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 339 | case VDAT_INT_TRIED_FIRMWARE_B: |
| 340 | value = (sh->flags & VBSD_FWB_TRIED ? 1 : 0); |
| 341 | break; |
| 342 | case VDAT_INT_KERNEL_KEY_VERIFIED: |
| 343 | value = (sh->flags & VBSD_KERNEL_KEY_VERIFIED ? 1 : 0); |
| 344 | break; |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 345 | default: |
Randall Spangler | 7adcc60 | 2011-06-24 16:11:45 -0700 | [diff] [blame] | 346 | break; |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 347 | } |
| 348 | |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 349 | /* Fields added in struct version 2 */ |
| 350 | if (sh->struct_version >= 2) { |
| 351 | switch(field) { |
| 352 | case VDAT_INT_DEVSW_BOOT: |
| 353 | value = (sh->flags & VBSD_BOOT_DEV_SWITCH_ON ? 1 : 0); |
| 354 | break; |
| 355 | case VDAT_INT_DEVSW_VIRTUAL: |
| 356 | value = (sh->flags & VBSD_HONOR_VIRT_DEV_SWITCH ? 1 : 0); |
| 357 | break; |
| 358 | case VDAT_INT_RECSW_BOOT: |
| 359 | value = (sh->flags & VBSD_BOOT_REC_SWITCH_ON ? 1 : 0); |
| 360 | break; |
| 361 | case VDAT_INT_WPSW_BOOT: |
| 362 | value = (sh->flags & VBSD_BOOT_FIRMWARE_WP_ENABLED ? 1 : 0); |
| 363 | break; |
| 364 | case VDAT_INT_FW_VERSION_TPM: |
| 365 | value = (int)sh->fw_version_tpm; |
| 366 | break; |
| 367 | case VDAT_INT_KERNEL_VERSION_TPM: |
| 368 | value = (int)sh->kernel_version_tpm; |
| 369 | break; |
| 370 | case VDAT_INT_RECOVERY_REASON: |
| 371 | value = sh->recovery_reason; |
| 372 | break; |
| 373 | default: |
| 374 | break; |
| 375 | } |
| 376 | } |
| 377 | |
Randall Spangler | 32a6526 | 2011-06-27 10:49:11 -0700 | [diff] [blame] | 378 | free(sh); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 379 | return value; |
| 380 | } |
| 381 | |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 382 | /* Return version of VbSharedData struct or -1 if not found. */ |
| 383 | int VbSharedDataVersion(void) { |
| 384 | return GetVdatInt(VDAT_INT_HEADER_VERSION); |
| 385 | } |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 386 | |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 387 | int VbGetSystemPropertyInt(const char* name) { |
Randall Spangler | c80fe65 | 2011-02-17 11:06:47 -0800 | [diff] [blame] | 388 | int value = -1; |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 389 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 390 | /* Check architecture-dependent properties first */ |
| 391 | value = VbGetArchPropertyInt(name); |
| 392 | if (-1 != value) |
| 393 | return value; |
| 394 | |
| 395 | /* NV storage values */ |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 396 | else if (!strcasecmp(name,"kern_nv")) { |
Randall Spangler | 618d17d | 2011-03-01 10:33:11 -0800 | [diff] [blame] | 397 | value = VbGetNvStorage(VBNV_KERNEL_FIELD); |
Randall Spangler | b416714 | 2011-03-01 13:04:22 -0800 | [diff] [blame] | 398 | } else if (!strcasecmp(name,"nvram_cleared")) { |
| 399 | value = VbGetNvStorage(VBNV_KERNEL_SETTINGS_RESET); |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 400 | } else if (!strcasecmp(name,"recovery_request")) { |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 401 | value = VbGetNvStorage(VBNV_RECOVERY_REQUEST); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 402 | } else if (!strcasecmp(name,"dbg_reset")) { |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 403 | value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE); |
Bill Richardson | 35d0733 | 2012-05-25 12:55:58 -0700 | [diff] [blame] | 404 | } else if (!strcasecmp(name,"disable_dev_request")) { |
| 405 | value = VbGetNvStorage(VBNV_DISABLE_DEV_REQUEST); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 406 | } else if (!strcasecmp(name,"fwb_tries")) { |
Randall Spangler | 0f8ffb1 | 2011-02-25 09:50:54 -0800 | [diff] [blame] | 407 | value = VbGetNvStorage(VBNV_TRY_B_COUNT); |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 408 | } else if (!strcasecmp(name,"fwupdate_tries")) { |
| 409 | value = VbGetNvStorage(VBNV_KERNEL_FIELD); |
| 410 | if (value != -1) |
| 411 | value &= KERN_NV_FWUPDATE_TRIES_MASK; |
Randall Spangler | 44a1276 | 2011-04-12 13:16:40 -0700 | [diff] [blame] | 412 | } else if (!strcasecmp(name,"loc_idx")) { |
| 413 | value = VbGetNvStorage(VBNV_LOCALIZATION_INDEX); |
Randall Spangler | daa807c | 2011-07-11 10:55:18 -0700 | [diff] [blame] | 414 | } else if (!strcasecmp(name,"dev_boot_usb")) { |
| 415 | value = VbGetNvStorage(VBNV_DEV_BOOT_USB); |
Bill Richardson | 7272a69 | 2011-11-17 10:48:59 -0800 | [diff] [blame] | 416 | } else if (!strcasecmp(name,"dev_boot_signed_only")) { |
| 417 | value = VbGetNvStorage(VBNV_DEV_BOOT_SIGNED_ONLY); |
Bill Richardson | 17b8224 | 2012-06-26 16:33:56 -0700 | [diff] [blame] | 418 | } else if (!strcasecmp(name,"oprom_needed")) { |
| 419 | value = VbGetNvStorage(VBNV_OPROM_NEEDED); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 420 | } |
Randall Spangler | b47ed5a | 2011-02-23 13:05:40 -0800 | [diff] [blame] | 421 | /* Other parameters */ |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 422 | else if (!strcasecmp(name,"cros_debug")) { |
Randall Spangler | 196e177 | 2011-03-10 11:31:06 -0800 | [diff] [blame] | 423 | value = VbGetCrosDebug(); |
Randall Spangler | da8d32d | 2012-08-03 12:48:24 -0700 | [diff] [blame^] | 424 | } else if (!strcasecmp(name,"devsw_boot")) { |
| 425 | value = GetVdatInt(VDAT_INT_DEVSW_BOOT); |
| 426 | } else if (!strcasecmp(name,"devsw_virtual")) { |
| 427 | value = GetVdatInt(VDAT_INT_DEVSW_VIRTUAL); |
| 428 | } else if (!strcasecmp(name, "recoverysw_boot")) { |
| 429 | value = GetVdatInt(VDAT_INT_RECSW_BOOT); |
| 430 | } else if (!strcasecmp(name, "wpsw_boot")) { |
| 431 | value = GetVdatInt(VDAT_INT_WPSW_BOOT); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 432 | } else if (!strcasecmp(name,"vdat_flags")) { |
| 433 | value = GetVdatInt(VDAT_INT_FLAGS); |
Randall Spangler | 5ac39bf | 2011-03-17 17:58:56 -0700 | [diff] [blame] | 434 | } else if (!strcasecmp(name,"tpm_fwver")) { |
| 435 | value = GetVdatInt(VDAT_INT_FW_VERSION_TPM); |
| 436 | } else if (!strcasecmp(name,"tpm_kernver")) { |
| 437 | value = GetVdatInt(VDAT_INT_KERNEL_VERSION_TPM); |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 438 | } else if (!strcasecmp(name,"tried_fwb")) { |
| 439 | value = GetVdatInt(VDAT_INT_TRIED_FIRMWARE_B); |
Randall Spangler | 7adcc60 | 2011-06-24 16:11:45 -0700 | [diff] [blame] | 440 | } else if (!strcasecmp(name,"recovery_reason")) { |
| 441 | value = GetVdatInt(VDAT_INT_RECOVERY_REASON); |
Randall Spangler | b47ed5a | 2011-02-23 13:05:40 -0800 | [diff] [blame] | 442 | } |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 443 | |
Randall Spangler | c80fe65 | 2011-02-17 11:06:47 -0800 | [diff] [blame] | 444 | return value; |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 445 | } |
| 446 | |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 447 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 448 | const char* VbGetSystemPropertyString(const char* name, char* dest, int size) { |
Tom Wai-Hong Tam | d808a43 | 2012-06-29 17:24:27 +0800 | [diff] [blame] | 449 | static const char unknown_string[] = "unknown"; |
| 450 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 451 | /* Check architecture-dependent properties first */ |
| 452 | if (VbGetArchPropertyString(name, dest, size)) |
| 453 | return dest; |
| 454 | |
| 455 | if (!strcasecmp(name,"kernkey_vfy")) { |
Randall Spangler | cabe6b3 | 2011-03-18 12:44:27 -0700 | [diff] [blame] | 456 | switch(GetVdatInt(VDAT_INT_KERNEL_KEY_VERIFIED)) { |
Randall Spangler | 1726028 | 2011-02-25 12:06:26 -0800 | [diff] [blame] | 457 | case 0: |
| 458 | return "hash"; |
| 459 | case 1: |
| 460 | return "sig"; |
| 461 | default: |
| 462 | return NULL; |
| 463 | } |
Randall Spangler | a185b8d | 2011-07-15 16:28:38 -0700 | [diff] [blame] | 464 | } else if (!strcasecmp(name, "mainfw_act")) { |
| 465 | return GetVdatString(dest, size, VDAT_STRING_MAINFW_ACT); |
Randall Spangler | f4ba19d | 2011-03-17 16:10:21 -0700 | [diff] [blame] | 466 | } else if (!strcasecmp(name, "vdat_timers")) { |
| 467 | return GetVdatString(dest, size, VDAT_STRING_TIMERS); |
| 468 | } else if (!strcasecmp(name, "vdat_lfdebug")) { |
| 469 | return GetVdatString(dest, size, VDAT_STRING_LOAD_FIRMWARE_DEBUG); |
Randall Spangler | 7141571 | 2011-03-21 11:04:50 -0700 | [diff] [blame] | 470 | } else if (!strcasecmp(name, "vdat_lkdebug")) { |
| 471 | return GetVdatString(dest, size, VDAT_STRING_LOAD_KERNEL_DEBUG); |
Tom Wai-Hong Tam | d808a43 | 2012-06-29 17:24:27 +0800 | [diff] [blame] | 472 | } else if (!strcasecmp(name, "ddr_type")) { |
| 473 | return unknown_string; |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 474 | } |
| 475 | |
| 476 | return NULL; |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 477 | } |
| 478 | |
| 479 | |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 480 | int VbSetSystemPropertyInt(const char* name, int value) { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 481 | /* Check architecture-dependent properties first */ |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 482 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 483 | if (0 == VbSetArchPropertyInt(name, value)) |
| 484 | return 0; |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 485 | |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 486 | /* NV storage values */ |
Randall Spangler | b416714 | 2011-03-01 13:04:22 -0800 | [diff] [blame] | 487 | if (!strcasecmp(name,"nvram_cleared")) { |
| 488 | /* Can only clear this flag; it's set inside the NV storage library. */ |
| 489 | return VbSetNvStorage(VBNV_KERNEL_SETTINGS_RESET, 0); |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 490 | } else if (!strcasecmp(name,"recovery_request")) { |
| 491 | return VbSetNvStorage(VBNV_RECOVERY_REQUEST, value); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 492 | } else if (!strcasecmp(name,"dbg_reset")) { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 493 | return VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value); |
Bill Richardson | 35d0733 | 2012-05-25 12:55:58 -0700 | [diff] [blame] | 494 | } else if (!strcasecmp(name,"disable_dev_request")) { |
| 495 | return VbSetNvStorage(VBNV_DISABLE_DEV_REQUEST, value); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 496 | } else if (!strcasecmp(name,"fwb_tries")) { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 497 | return VbSetNvStorage(VBNV_TRY_B_COUNT, value); |
Randall Spangler | d772823 | 2011-04-08 14:04:21 -0700 | [diff] [blame] | 498 | } else if (!strcasecmp(name,"fwupdate_tries")) { |
| 499 | int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); |
| 500 | if (kern_nv == -1) |
| 501 | return -1; |
| 502 | kern_nv &= ~KERN_NV_FWUPDATE_TRIES_MASK; |
| 503 | kern_nv |= (value & KERN_NV_FWUPDATE_TRIES_MASK); |
| 504 | return VbSetNvStorage(VBNV_KERNEL_FIELD, kern_nv); |
Randall Spangler | 44a1276 | 2011-04-12 13:16:40 -0700 | [diff] [blame] | 505 | } else if (!strcasecmp(name,"loc_idx")) { |
| 506 | return VbSetNvStorage(VBNV_LOCALIZATION_INDEX, value); |
Randall Spangler | daa807c | 2011-07-11 10:55:18 -0700 | [diff] [blame] | 507 | } else if (!strcasecmp(name,"dev_boot_usb")) { |
| 508 | return VbSetNvStorage(VBNV_DEV_BOOT_USB, value); |
Bill Richardson | 7272a69 | 2011-11-17 10:48:59 -0800 | [diff] [blame] | 509 | } else if (!strcasecmp(name,"dev_boot_signed_only")) { |
| 510 | return VbSetNvStorage(VBNV_DEV_BOOT_SIGNED_ONLY, value); |
Bill Richardson | 17b8224 | 2012-06-26 16:33:56 -0700 | [diff] [blame] | 511 | } else if (!strcasecmp(name,"oprom_needed")) { |
| 512 | return VbSetNvStorage(VBNV_OPROM_NEEDED, value); |
Randall Spangler | e73302c | 2011-02-18 14:53:01 -0800 | [diff] [blame] | 513 | } |
| 514 | |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 515 | return -1; |
| 516 | } |
| 517 | |
| 518 | |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 519 | int VbSetSystemPropertyString(const char* name, const char* value) { |
Randall Spangler | eb59195 | 2011-04-07 10:02:00 -0700 | [diff] [blame] | 520 | /* Chain to architecture-dependent properties */ |
| 521 | return VbSetArchPropertyString(name, value); |
Randall Spangler | 5421866 | 2011-02-07 11:20:20 -0800 | [diff] [blame] | 522 | } |