/* SPDX-License-Identifier: GPL-2.0-only */ #include <inttypes.h> #include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <getopt.h> #include <dirent.h> #include <errno.h> #include <fcntl.h> #include <ctype.h> #include <arpa/inet.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h> #include <libgen.h> #include <assert.h> #include <regex.h> #include <commonlib/bsd/cbmem_id.h> #include <commonlib/bsd/ipchksum.h> #include <commonlib/bsd/tpm_log_defs.h> #include <commonlib/loglevel.h> #include <commonlib/timestamp_serialized.h> #include <commonlib/tpm_log_serialized.h> #include <commonlib/coreboot_tables.h> #ifdef __OpenBSD__ #include <sys/param.h> #include <sys/sysctl.h> #endif #if defined(__i386__) || defined(__x86_64__) #include <x86intrin.h> #endif typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; typedef uint64_t u64; /* Return < 0 on error, 0 on success. */ static int parse_cbtable(u64 address, size_t table_size); struct mapping { void *virt; size_t offset; size_t virt_size; unsigned long long phys; size_t size; }; #define CBMEM_VERSION "1.1" /* verbose output? */ static int verbose = 0; #define debug(x...) if(verbose) printf(x) /* File handle used to access /dev/mem */ static int mem_fd; static struct mapping lbtable_mapping; /* TSC frequency from the LB_TAG_TSC_INFO record. 0 if not present. */ static uint32_t tsc_freq_khz = 0; static void die(const char *msg) { if (msg) fputs(msg, stderr); exit(1); } static unsigned long long system_page_size(void) { static unsigned long long page_size; if (!page_size) page_size = getpagesize(); return page_size; } static inline size_t size_to_mib(size_t sz) { return sz >> 20; } /* Return mapping of physical address requested. */ static void *mapping_virt(const struct mapping *mapping) { char *v = mapping->virt; if (v == NULL) return NULL; return v + mapping->offset; } /* Returns virtual address on success, NULL on error. mapping is filled in. */ static void *map_memory_with_prot(struct mapping *mapping, unsigned long long phys, size_t sz, int prot) { void *v; unsigned long long page_size; page_size = system_page_size(); mapping->virt = NULL; mapping->offset = phys % page_size; mapping->virt_size = sz + mapping->offset; mapping->size = sz; mapping->phys = phys; if (size_to_mib(mapping->virt_size) == 0) { debug("Mapping %zuB of physical memory at 0x%llx (requested 0x%llx).\n", mapping->virt_size, phys - mapping->offset, phys); } else { debug("Mapping %zuMB of physical memory at 0x%llx (requested 0x%llx).\n", size_to_mib(mapping->virt_size), phys - mapping->offset, phys); } v = mmap(NULL, mapping->virt_size, prot, MAP_SHARED, mem_fd, phys - mapping->offset); if (v == MAP_FAILED) { debug("Mapping failed %zuB of physical memory at 0x%llx.\n", mapping->virt_size, phys - mapping->offset); return NULL; } mapping->virt = v; if (mapping->offset != 0) debug(" ... padding virtual address with 0x%zx bytes.\n", mapping->offset); return mapping_virt(mapping); } /* Convenience helper for the common case of read-only mappings. */ static const void *map_memory(struct mapping *mapping, unsigned long long phys, size_t sz) { return map_memory_with_prot(mapping, phys, sz, PROT_READ); } /* Returns 0 on success, < 0 on error. mapping is cleared if successful. */ static int unmap_memory(struct mapping *mapping) { if (mapping->virt == NULL) return -1; munmap(mapping->virt, mapping->virt_size); mapping->virt = NULL; mapping->offset = 0; mapping->virt_size = 0; return 0; } /* Return size of physical address mapping requested. */ static size_t mapping_size(const struct mapping *mapping) { if (mapping->virt == NULL) return 0; return mapping->size; } /* * Some architectures map /dev/mem memory in a way that doesn't support * unaligned accesses. Most normal libc memcpy()s aren't safe to use in this * case, so build our own which makes sure to never do unaligned accesses on * *src (*dest is fine since we never map /dev/mem for writing). */ static void *aligned_memcpy(void *dest, const void *src, size_t n) { u8 *d = dest; const volatile u8 *s = src; /* volatile to prevent optimization */ while ((uintptr_t)s & (sizeof(size_t) - 1)) { if (n-- == 0) return dest; *d++ = *s++; } while (n >= sizeof(size_t)) { *(size_t *)d = *(const volatile size_t *)s; d += sizeof(size_t); s += sizeof(size_t); n -= sizeof(size_t); } while (n-- > 0) *d++ = *s++; return dest; } /* Find the first cbmem entry filling in the details. */ static int find_cbmem_entry(uint32_t id, uint64_t *addr, size_t *size) { const uint8_t *table; size_t offset; int ret = -1; table = mapping_virt(&lbtable_mapping); if (table == NULL) return -1; offset = 0; while (offset < mapping_size(&lbtable_mapping)) { const struct lb_record *lbr; struct lb_cbmem_entry lbe; lbr = (const void *)(table + offset); offset += lbr->size; if (lbr->tag != LB_TAG_CBMEM_ENTRY) continue; aligned_memcpy(&lbe, lbr, sizeof(lbe)); if (lbe.id != id) continue; *addr = lbe.address; *size = lbe.entry_size; ret = 0; break; } return ret; } /* * Try finding the timestamp table and coreboot cbmem console starting from the * passed in memory offset. Could be called recursively in case a forwarding * entry is found. * * Returns pointer to a memory buffer containing the timestamp table or zero if * none found. */ static struct lb_cbmem_ref timestamps; static struct lb_cbmem_ref console; static struct lb_cbmem_ref tpm_cb_log; static struct lb_memory_range cbmem; /* This is a work-around for a nasty problem introduced by initially having * pointer sized entries in the lb_cbmem_ref structures. This caused problems * on 64bit x86 systems because coreboot is 32bit on those systems. * When the problem was found, it was corrected, but there are a lot of * systems out there with a firmware that does not produce the right * lb_cbmem_ref structure. Hence we try to autocorrect this issue here. */ static struct lb_cbmem_ref parse_cbmem_ref(const struct lb_cbmem_ref *cbmem_ref) { struct lb_cbmem_ref ret; aligned_memcpy(&ret, cbmem_ref, sizeof(ret)); if (cbmem_ref->size < sizeof(*cbmem_ref)) ret.cbmem_addr = (uint32_t)ret.cbmem_addr; debug(" cbmem_addr = %" PRIx64 "\n", ret.cbmem_addr); return ret; } static void parse_memory_tags(const struct lb_memory *mem) { int num_entries; int i; /* Peel off the header size and calculate the number of entries. */ num_entries = (mem->size - sizeof(*mem)) / sizeof(mem->map[0]); for (i = 0; i < num_entries; i++) { if (mem->map[i].type != LB_MEM_TABLE) continue; debug(" LB_MEM_TABLE found.\n"); /* The last one found is CBMEM */ aligned_memcpy(&cbmem, &mem->map[i], sizeof(cbmem)); } } /* Return < 0 on error, 0 on success, 1 if forwarding table entry found. */ static int parse_cbtable_entries(const struct mapping *table_mapping) { size_t i; const struct lb_record *lbr_p; size_t table_size = mapping_size(table_mapping); const void *lbtable = mapping_virt(table_mapping); int forwarding_table_found = 0; for (i = 0; i < table_size; i += lbr_p->size) { lbr_p = lbtable + i; debug(" coreboot table entry 0x%02x\n", lbr_p->tag); switch (lbr_p->tag) { case LB_TAG_MEMORY: debug(" Found memory map.\n"); parse_memory_tags(lbtable + i); continue; case LB_TAG_TIMESTAMPS: { debug(" Found timestamp table.\n"); timestamps = parse_cbmem_ref((struct lb_cbmem_ref *)lbr_p); continue; } case LB_TAG_CBMEM_CONSOLE: { debug(" Found cbmem console.\n"); console = parse_cbmem_ref((struct lb_cbmem_ref *)lbr_p); continue; } case LB_TAG_TPM_CB_LOG: { debug(" Found TPM CB log table.\n"); tpm_cb_log = parse_cbmem_ref((struct lb_cbmem_ref *)lbr_p); continue; } case LB_TAG_TSC_INFO: debug(" Found TSC info.\n"); tsc_freq_khz = ((struct lb_tsc_info *)lbr_p)->freq_khz; continue; case LB_TAG_FORWARD: { int ret; /* * This is a forwarding entry - repeat the * search at the new address. */ struct lb_forward lbf_p = *(const struct lb_forward *)lbr_p; debug(" Found forwarding entry.\n"); ret = parse_cbtable(lbf_p.forward, 0); /* Assume the forwarding entry is valid. If this fails * then there's a total failure. */ if (ret < 0) return -1; forwarding_table_found = 1; } default: break; } } return forwarding_table_found; } /* Return < 0 on error, 0 on success. */ static int parse_cbtable(u64 address, size_t table_size) { const void *buf; struct mapping header_mapping; size_t req_size; size_t i; req_size = table_size; /* Default to 4 KiB search space. */ if (req_size == 0) req_size = 4 * 1024; debug("Looking for coreboot table at %" PRIx64 " %zd bytes.\n", address, req_size); buf = map_memory(&header_mapping, address, req_size); if (!buf) return -1; /* look at every 16 bytes */ for (i = 0; i <= req_size - sizeof(struct lb_header); i += 16) { int ret; const struct lb_header *lbh; struct mapping table_mapping; lbh = buf + i; if (memcmp(lbh->signature, "LBIO", sizeof(lbh->signature)) || !lbh->header_bytes || ipchksum(lbh, sizeof(*lbh))) { continue; } /* Map in the whole table to parse. */ if (!map_memory(&table_mapping, address + i + lbh->header_bytes, lbh->table_bytes)) { debug("Couldn't map in table\n"); continue; } if (ipchksum(mapping_virt(&table_mapping), lbh->table_bytes) != lbh->table_checksum) { debug("Signature found, but wrong checksum.\n"); unmap_memory(&table_mapping); continue; } debug("Found!\n"); ret = parse_cbtable_entries(&table_mapping); /* Table parsing failed. */ if (ret < 0) { unmap_memory(&table_mapping); continue; } /* Succeeded in parsing the table. Header not needed anymore. */ unmap_memory(&header_mapping); /* * Table parsing succeeded. If forwarding table not found update * coreboot table mapping for future use. */ if (ret == 0) lbtable_mapping = table_mapping; else unmap_memory(&table_mapping); return 0; } unmap_memory(&header_mapping); return -1; } #if defined(linux) && (defined(__i386__) || defined(__x86_64__)) /* * read CPU frequency from a sysfs file, return an frequency in Megahertz as * an int or exit on any error. */ static unsigned long arch_tick_frequency(void) { FILE *cpuf; char freqs[100]; int size; char *endp; u64 rv; const char* freq_file = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq"; cpuf = fopen(freq_file, "r"); if (!cpuf) { fprintf(stderr, "Could not open %s: %s\n", freq_file, strerror(errno)); exit(1); } memset(freqs, 0, sizeof(freqs)); size = fread(freqs, 1, sizeof(freqs), cpuf); if (!size || (size == sizeof(freqs))) { fprintf(stderr, "Wrong number of bytes(%d) read from %s\n", size, freq_file); exit(1); } fclose(cpuf); rv = strtoull(freqs, &endp, 10); if (*endp == '\0' || *endp == '\n') /* cpuinfo_max_freq is in kHz. Convert it to MHz. */ return rv / 1000; fprintf(stderr, "Wrong formatted value ^%s^ read from %s\n", freqs, freq_file); exit(1); } #elif defined(__OpenBSD__) && (defined(__i386__) || defined(__x86_64__)) static unsigned long arch_tick_frequency(void) { int mib[2] = { CTL_HW, HW_CPUSPEED }; static int value = 0; size_t value_len = sizeof(value); /* Return 1 MHz when sysctl fails. */ if ((value == 0) && (sysctl(mib, 2, &value, &value_len, NULL, 0) == -1)) return 1; return value; } #else static unsigned long arch_tick_frequency(void) { /* 1 MHz = 1us. */ return 1; } #endif static unsigned long tick_freq_mhz; static void timestamp_set_tick_freq(unsigned long table_tick_freq_mhz) { tick_freq_mhz = table_tick_freq_mhz; /* Honor table frequency if present. */ if (!tick_freq_mhz) tick_freq_mhz = arch_tick_frequency(); if (!tick_freq_mhz) { fprintf(stderr, "Cannot determine timestamp tick frequency.\n"); exit(1); } debug("Timestamp tick frequency: %ld MHz\n", tick_freq_mhz); } static u64 arch_convert_raw_ts_entry(u64 ts) { return ts / tick_freq_mhz; } /* * Print an integer in 'normalized' form - with commas separating every three * decimal orders. */ static void print_norm(u64 v) { if (v >= 1000) { /* print the higher order sections first */ print_norm(v / 1000); printf(",%3.3u", (u32)(v % 1000)); } else { printf("%u", (u32)(v % 1000)); } } static uint64_t timestamp_get(uint64_t table_tick_freq_mhz) { #if defined(__i386__) || defined(__x86_64__) uint64_t tsc = __rdtsc(); /* No tick frequency specified means raw TSC values. */ if (!table_tick_freq_mhz) return tsc; if (tsc_freq_khz) return tsc * table_tick_freq_mhz * 1000 / tsc_freq_khz; #else (void)table_tick_freq_mhz; #endif die("Don't know how to obtain timestamps on this platform.\n"); return 0; } static const char *timestamp_name(uint32_t id) { for (size_t i = 0; i < ARRAY_SIZE(timestamp_ids); i++) { if (timestamp_ids[i].id == id) return timestamp_ids[i].name; } return "<unknown>"; } static uint32_t timestamp_enum_name_to_id(const char *name) { for (size_t i = 0; i < ARRAY_SIZE(timestamp_ids); i++) { if (!strcmp(timestamp_ids[i].enum_name, name)) return timestamp_ids[i].id; } return 0; } static uint64_t timestamp_print_parseable_entry(uint32_t id, uint64_t stamp, uint64_t prev_stamp) { const char *name; uint64_t step_time; name = timestamp_name(id); step_time = arch_convert_raw_ts_entry(stamp - prev_stamp); /* ID<tab>absolute time<tab>relative time<tab>description */ printf("%d\t", id); printf("%llu\t", (long long)arch_convert_raw_ts_entry(stamp)); printf("%llu\t", (long long)step_time); printf("%s\n", name); return step_time; } static uint64_t timestamp_print_entry(uint32_t id, uint64_t stamp, uint64_t prev_stamp) { const char *name; uint64_t step_time; name = timestamp_name(id); printf("%4d:", id); printf("%-50s", name); print_norm(arch_convert_raw_ts_entry(stamp)); step_time = arch_convert_raw_ts_entry(stamp - prev_stamp); if (prev_stamp) { printf(" ("); print_norm(step_time); printf(")"); } printf("\n"); return step_time; } static int compare_timestamp_entries(const void *a, const void *b) { const struct timestamp_entry *tse_a = (struct timestamp_entry *)a; const struct timestamp_entry *tse_b = (struct timestamp_entry *)b; if (tse_a->entry_stamp > tse_b->entry_stamp) return 1; else if (tse_a->entry_stamp < tse_b->entry_stamp) return -1; return 0; } static int find_matching_end(struct timestamp_table *sorted_tst_p, uint32_t start, uint32_t end) { uint32_t id = sorted_tst_p->entries[start].entry_id; uint32_t possible_match = 0; for (uint32_t i = 0; i < ARRAY_SIZE(timestamp_ids); ++i) { if (timestamp_ids[i].id == id) { possible_match = timestamp_ids[i].id_end; break; } } /* No match found or timestamp not defined in IDs table */ if (!possible_match) return -1; for (uint32_t i = start + 1; i < end; i++) if (sorted_tst_p->entries[i].entry_id == possible_match) return i; return -1; } static const char *get_timestamp_name(const uint32_t id) { for (uint32_t i = 0; i < ARRAY_SIZE(timestamp_ids); i++) if (timestamp_ids[i].id == id) return timestamp_ids[i].enum_name; return "UNKNOWN"; } struct ts_range_stack { const char *name; const char *end_name; uint32_t end; }; static void print_with_path(struct ts_range_stack *range_stack, const int stacklvl, const uint64_t stamp, const char *last_part) { for (int i = 1; i <= stacklvl; ++i) { printf("%s -> %s", range_stack[i].name, range_stack[i].end_name); if (i < stacklvl || last_part) putchar(';'); } if (last_part) printf("%s", last_part); printf(" %llu\n", (long long)arch_convert_raw_ts_entry(stamp)); } enum timestamps_print_type { TIMESTAMPS_PRINT_NONE, TIMESTAMPS_PRINT_NORMAL, TIMESTAMPS_PRINT_MACHINE_READABLE, TIMESTAMPS_PRINT_STACKED, }; /* dump the timestamp table */ static void dump_timestamps(enum timestamps_print_type output_type) { const struct timestamp_table *tst_p; struct timestamp_table *sorted_tst_p; size_t size; uint64_t prev_stamp = 0; uint64_t total_time = 0; struct mapping timestamp_mapping; if (timestamps.tag != LB_TAG_TIMESTAMPS) { fprintf(stderr, "No timestamps found in coreboot table.\n"); return; } size = sizeof(*tst_p); tst_p = map_memory(×tamp_mapping, timestamps.cbmem_addr, size); if (!tst_p) die("Unable to map timestamp header\n"); timestamp_set_tick_freq(tst_p->tick_freq_mhz); if (output_type == TIMESTAMPS_PRINT_NORMAL) printf("%d entries total:\n\n", tst_p->num_entries); size += tst_p->num_entries * sizeof(tst_p->entries[0]); unmap_memory(×tamp_mapping); tst_p = map_memory(×tamp_mapping, timestamps.cbmem_addr, size); if (!tst_p) die("Unable to map full timestamp table\n"); sorted_tst_p = malloc(size + sizeof(struct timestamp_entry)); if (!sorted_tst_p) die("Failed to allocate memory"); aligned_memcpy(sorted_tst_p, tst_p, size); /* * Insert a timestamp to represent the base time (start of coreboot), * in case we have to rebase for negative timestamps below. */ sorted_tst_p->entries[tst_p->num_entries].entry_id = 0; sorted_tst_p->entries[tst_p->num_entries].entry_stamp = 0; sorted_tst_p->num_entries += 1; qsort(&sorted_tst_p->entries[0], sorted_tst_p->num_entries, sizeof(struct timestamp_entry), compare_timestamp_entries); /* * If there are negative timestamp entries, rebase all of the * timestamps to the lowest one in the list. */ if (sorted_tst_p->entries[0].entry_stamp < 0) { sorted_tst_p->base_time = -sorted_tst_p->entries[0].entry_stamp; prev_stamp = 0; } else { prev_stamp = tst_p->base_time; } struct ts_range_stack range_stack[20]; range_stack[0].end = sorted_tst_p->num_entries; int stacklvl = 0; for (uint32_t i = 0; i < sorted_tst_p->num_entries; i++) { uint64_t stamp; const struct timestamp_entry *tse = &sorted_tst_p->entries[i]; /* Make all timestamps absolute. */ stamp = tse->entry_stamp + sorted_tst_p->base_time; if (output_type == TIMESTAMPS_PRINT_MACHINE_READABLE) { timestamp_print_parseable_entry(tse->entry_id, stamp, prev_stamp); } else if (output_type == TIMESTAMPS_PRINT_NORMAL) { total_time += timestamp_print_entry(tse->entry_id, stamp, prev_stamp); } else if (output_type == TIMESTAMPS_PRINT_STACKED) { bool end_of_range = false; /* Iterate over stacked entries to pop all ranges, which are closed by current element. For example, assuming two ranges: (TS_A, TS_C), (TS_B, TS_C) it will pop all of them instead of just last one. */ while (stacklvl > 0 && range_stack[stacklvl].end == i) { end_of_range = true; stacklvl--; } int match = find_matching_end(sorted_tst_p, i, range_stack[stacklvl].end); if (match != -1) { const uint64_t match_stamp = sorted_tst_p->entries[match].entry_stamp + sorted_tst_p->base_time; stacklvl++; assert(stacklvl < (int)ARRAY_SIZE(range_stack)); range_stack[stacklvl].name = get_timestamp_name(tse->entry_id); range_stack[stacklvl].end_name = get_timestamp_name( sorted_tst_p->entries[match].entry_id); range_stack[stacklvl].end = match; print_with_path(range_stack, stacklvl, match_stamp - stamp, NULL); } else if (!end_of_range) { print_with_path(range_stack, stacklvl, stamp - prev_stamp, get_timestamp_name(tse->entry_id)); } /* else: No match && end_of_range == true */ } prev_stamp = stamp; } if (output_type == TIMESTAMPS_PRINT_NORMAL) { printf("\nTotal Time: "); print_norm(total_time); printf("\n"); } unmap_memory(×tamp_mapping); free(sorted_tst_p); } /* add a timestamp entry */ static void timestamp_add_now(uint32_t timestamp_id) { struct timestamp_table *tst_p; struct mapping timestamp_mapping; if (timestamps.tag != LB_TAG_TIMESTAMPS) { die("No timestamps found in coreboot table.\n"); } tst_p = map_memory_with_prot(×tamp_mapping, timestamps.cbmem_addr, timestamps.size, PROT_READ | PROT_WRITE); if (!tst_p) die("Unable to map timestamp table\n"); /* * Note that coreboot sizes the cbmem entry in the table according to * max_entries, so it's OK to just add more entries if there's room. */ if (tst_p->num_entries >= tst_p->max_entries) { die("Not enough space to add timestamp.\n"); } else { int64_t time = timestamp_get(tst_p->tick_freq_mhz) - tst_p->base_time; tst_p->entries[tst_p->num_entries].entry_id = timestamp_id; tst_p->entries[tst_p->num_entries].entry_stamp = time; tst_p->num_entries += 1; } unmap_memory(×tamp_mapping); } static bool can_print(const uint8_t *data, size_t len) { unsigned int i; for (i = 0; i < len; i++) { if (!isprint(data[i]) && !isspace(data[i])) { /* If printable prefix is followed by zeroes, this is a valid string */ for (; i < len; i++) { if (data[i] != 0) return false; } return true; } } return true; } static void print_hex_string(const uint8_t *hex, size_t len) { unsigned int i; for (i = 0; i < len; i++) printf("%02x", hex[i]); } static void print_hex_line(const uint8_t *hex, size_t len) { print_hex_string(hex, len); printf("\n"); } static void print_event_type(uint32_t event_type) { unsigned int known_event_count = ARRAY_SIZE(tpm_event_types); if (event_type >= known_event_count) printf("Unknown (0x%x >= %u)", event_type, known_event_count); else printf("%s", tpm_event_types[event_type]); } static void parse_tpm12_log(const struct tcpa_spec_entry *spec_log) { const uint8_t zero_block[sizeof(struct tcpa_spec_entry)] = {0}; uintptr_t current; uint32_t counter = 0; printf("TCPA log:\n"); printf("\tSpecification: %d.%d%d\n", spec_log->spec_version_major, spec_log->spec_version_minor, spec_log->spec_errata); printf("\tPlatform class: %s\n", le32toh(spec_log->platform_class) == 0 ? "PC Client" : le32toh(spec_log->platform_class) == 1 ? "Server" : "Unknown"); current = (uintptr_t)&spec_log->vendor_info[spec_log->vendor_info_size]; while (memcmp((const void *)current, (const void *)zero_block, sizeof(zero_block))) { uint32_t len; struct tcpa_log_entry *log_entry = (void *)current; uint32_t event_type = le32toh(log_entry->event_type); printf("TCPA log entry %u:\n", ++counter); printf("\tPCR: %d\n", le32toh(log_entry->pcr)); printf("\tEvent type: "); print_event_type(event_type); printf("\n"); printf("\tDigest: "); print_hex_line(log_entry->digest, SHA1_DIGEST_SIZE); current += sizeof(struct tcpa_log_entry); len = le32toh(log_entry->event_data_size); if (len != 0) { current += len; printf("\tEvent data: "); if (can_print(log_entry->event, len)) printf("%.*s\n", len, log_entry->event); else print_hex_line(log_entry->event, len); } else { printf("\tEvent data not provided\n"); } } } static uint32_t print_tpm2_digests(struct tcg_pcr_event2_header *log_entry) { unsigned int i; uintptr_t current = (uintptr_t)log_entry->digests; for (i = 0; i < le32toh(log_entry->digest_count); i++) { struct tpm_hash_algorithm *hash = (struct tpm_hash_algorithm *)current; switch (le16toh(hash->hashAlg)) { case TPM2_ALG_SHA1: printf("\t\t SHA1: "); print_hex_line(hash->digest.sha1, SHA1_DIGEST_SIZE); current += sizeof(hash->hashAlg) + SHA1_DIGEST_SIZE; break; case TPM2_ALG_SHA256: printf("\t\t SHA256: "); print_hex_line(hash->digest.sha256, SHA256_DIGEST_SIZE); current += sizeof(hash->hashAlg) + SHA256_DIGEST_SIZE; break; case TPM2_ALG_SHA384: printf("\t\t SHA384: "); print_hex_line(hash->digest.sha384, SHA384_DIGEST_SIZE); current += sizeof(hash->hashAlg) + SHA384_DIGEST_SIZE; break; case TPM2_ALG_SHA512: printf("\t\t SHA512: "); print_hex_line(hash->digest.sha512, SHA512_DIGEST_SIZE); current += sizeof(hash->hashAlg) + SHA512_DIGEST_SIZE; break; case TPM2_ALG_SM3_256: printf("\t\t SM3: "); print_hex_line(hash->digest.sm3_256, SM3_256_DIGEST_SIZE); current += sizeof(hash->hashAlg) + SM3_256_DIGEST_SIZE; break; default: die("Unknown hash algorithm\n"); } } return current - (uintptr_t)&log_entry->digest_count; } static void parse_tpm2_log(const struct tcg_efi_spec_id_event *tpm2_log) { const uint8_t zero_block[12] = {0}; /* Only PCR index, event type and digest count */ uintptr_t current; uint32_t counter = 0; printf("TPM2 log:\n"); printf("\tSpecification: %d.%d%d\n", tpm2_log->spec_version_major, tpm2_log->spec_version_minor, tpm2_log->spec_errata); printf("\tPlatform class: %s\n", le32toh(tpm2_log->platform_class) == 0 ? "PC Client" : le32toh(tpm2_log->platform_class) == 1 ? "Server" : "Unknown"); /* Start after the first variable-sized part of the header */ current = (uintptr_t)&tpm2_log->digest_sizes[le32toh(tpm2_log->num_of_algorithms)]; /* current is at `uint8_t vendor_info_size` here */ current += 1 + *(uint8_t *)current; while (memcmp((const void *)current, (const void *)zero_block, sizeof(zero_block))) { uint32_t len; struct tcg_pcr_event2_header *log_entry = (void *)current; uint32_t event_type = le32toh(log_entry->event_type); printf("TPM2 log entry %u:\n", ++counter); printf("\tPCR: %d\n", le32toh(log_entry->pcr_index)); printf("\tEvent type: "); print_event_type(event_type); printf("\n"); current = (uintptr_t)&log_entry->digest_count; if (le32toh(log_entry->digest_count) > 0) { printf("\tDigests:\n"); current += print_tpm2_digests(log_entry); } else { printf("\tNo digests in this log entry\n"); current += sizeof(log_entry->digest_count); } /* Now event size and event are left to be parsed */ len = le32toh(*(uint32_t *)current); current += sizeof(uint32_t); if (len != 0) { printf("\tEvent data: %.*s\n", len, (const char *)current); current += len; } else { printf("\tEvent data not provided\n"); } } } /* Dump the TPM log table in format defined by specifications */ static void dump_tpm_std_log(uint64_t addr, size_t size) { const void *event_log; const struct tcpa_spec_entry *tspec_entry; const struct tcg_efi_spec_id_event *tcg_spec_entry; struct mapping log_mapping; event_log = map_memory(&log_mapping, addr, size); if (!event_log) die("Unable to map TPM eventlog\n"); tspec_entry = event_log; if (!strcmp((const char *)tspec_entry->signature, TCPA_SPEC_ID_EVENT_SIGNATURE)) { if (tspec_entry->spec_version_major == 1 && tspec_entry->spec_version_minor == 2 && tspec_entry->spec_errata >= 1 && le32toh(tspec_entry->entry.event_type) == EV_NO_ACTION) { parse_tpm12_log(tspec_entry); } else { fprintf(stderr, "Unknown TPM1.2 log specification\n"); } unmap_memory(&log_mapping); return; } tcg_spec_entry = event_log; if (!strcmp((const char *)tcg_spec_entry->signature, TCG_EFI_SPEC_ID_EVENT_SIGNATURE)) { if (tcg_spec_entry->spec_version_major == 2 && tcg_spec_entry->spec_version_minor == 0 && le32toh(tcg_spec_entry->event_type) == EV_NO_ACTION) { parse_tpm2_log(tcg_spec_entry); } else { fprintf(stderr, "Unknown TPM2 log specification.\n"); } unmap_memory(&log_mapping); return; } fprintf(stderr, "Unknown TPM log specification: %.*s\n", (int)sizeof(tcg_spec_entry->signature), (const char *)tcg_spec_entry->signature); unmap_memory(&log_mapping); } /* dump the TPM CB log table */ static void dump_tpm_cb_log(void) { const struct tpm_cb_log_table *tclt_p; size_t size; struct mapping log_mapping; if (tpm_cb_log.tag != LB_TAG_TPM_CB_LOG) { fprintf(stderr, "No TPM log found in coreboot table.\n"); return; } size = sizeof(*tclt_p); tclt_p = map_memory(&log_mapping, tpm_cb_log.cbmem_addr, size); if (!tclt_p) die("Unable to map TPM log header\n"); size += tclt_p->num_entries * sizeof(tclt_p->entries[0]); unmap_memory(&log_mapping); tclt_p = map_memory(&log_mapping, tpm_cb_log.cbmem_addr, size); if (!tclt_p) die("Unable to map full TPM log table\n"); printf("coreboot TPM log:\n\n"); for (uint16_t i = 0; i < tclt_p->num_entries; i++) { const struct tpm_cb_log_entry *tce = &tclt_p->entries[i]; printf(" PCR-%u ", tce->pcr); print_hex_string(tce->digest, tce->digest_length); printf(" %s [%s]\n", tce->digest_type, tce->name); } unmap_memory(&log_mapping); } static void dump_tpm_log(void) { uint64_t start; size_t size; if (!find_cbmem_entry(CBMEM_ID_TCPA_TCG_LOG, &start, &size) || !find_cbmem_entry(CBMEM_ID_TPM2_TCG_LOG, &start, &size)) dump_tpm_std_log(start, size); else dump_tpm_cb_log(); } struct cbmem_console { u32 size; u32 cursor; u8 body[]; } __attribute__ ((__packed__)); #define CBMC_CURSOR_MASK ((1 << 28) - 1) #define CBMC_OVERFLOW (1 << 31) enum console_print_type { CONSOLE_PRINT_FULL = 0, CONSOLE_PRINT_LAST, CONSOLE_PRINT_PREVIOUS, }; static int parse_loglevel(char *arg, int *print_unknown_logs) { if (arg[0] == '+') { *print_unknown_logs = 1; arg++; } else { *print_unknown_logs = 0; } char *endptr; int loglevel = strtol(arg, &endptr, 0); if (*endptr == '\0' && loglevel >= BIOS_EMERG && loglevel <= BIOS_LOG_PREFIX_MAX_LEVEL) return loglevel; /* Only match first 3 characters so `NOTE` and `NOTICE` both match. */ for (int i = BIOS_EMERG; i <= BIOS_LOG_PREFIX_MAX_LEVEL; i++) if (!strncasecmp(arg, bios_log_prefix[i], 3)) return i; *print_unknown_logs = 1; return BIOS_NEVER; } /* dump the cbmem console */ static void dump_console(enum console_print_type type, int max_loglevel, int print_unknown_logs) { const struct cbmem_console *console_p; char *console_c; size_t size, cursor, previous; struct mapping console_mapping; if (console.tag != LB_TAG_CBMEM_CONSOLE) { fprintf(stderr, "No console found in coreboot table.\n"); return; } size = sizeof(*console_p); console_p = map_memory(&console_mapping, console.cbmem_addr, size); if (!console_p) die("Unable to map console object.\n"); cursor = console_p->cursor & CBMC_CURSOR_MASK; if (!(console_p->cursor & CBMC_OVERFLOW) && cursor < console_p->size) size = cursor; else size = console_p->size; unmap_memory(&console_mapping); console_c = malloc(size + 1); if (!console_c) { fprintf(stderr, "Not enough memory for console.\n"); exit(1); } console_c[size] = '\0'; console_p = map_memory(&console_mapping, console.cbmem_addr, size + sizeof(*console_p)); if (!console_p) die("Unable to map full console object.\n"); if (console_p->cursor & CBMC_OVERFLOW) { if (cursor >= size) { printf("cbmem: ERROR: CBMEM console struct is illegal, " "output may be corrupt or out of order!\n\n"); cursor = 0; } aligned_memcpy(console_c, console_p->body + cursor, size - cursor); aligned_memcpy(console_c + size - cursor, console_p->body, cursor); } else { aligned_memcpy(console_c, console_p->body, size); } /* Slight memory corruption may occur between reboots and give us a few unprintable characters like '\0'. Replace them with '?' on output. */ for (cursor = 0; cursor < size; cursor++) if (!isprint(console_c[cursor]) && !isspace(console_c[cursor]) && !BIOS_LOG_IS_MARKER(console_c[cursor])) console_c[cursor] = '?'; /* We detect the reboot cutoff by looking for a bootblock, romstage or ramstage banner, in that order (to account for platforms without CONFIG_BOOTBLOCK_CONSOLE and/or CONFIG_EARLY_CONSOLE). Once we find a banner, store the last two matches for that stage and stop. */ cursor = previous = 0; if (type != CONSOLE_PRINT_FULL) { #define BANNER_REGEX(stage) \ "\n\n.?coreboot-[^\n]* " stage " starting.*\\.\\.\\.\n" #define OVERFLOW_REGEX(stage) "\n.?\\*\\*\\* Pre-CBMEM " stage " console overflow" const char *regex[] = { BANNER_REGEX("verstage-before-bootblock"), BANNER_REGEX("bootblock"), BANNER_REGEX("verstage"), OVERFLOW_REGEX("romstage"), BANNER_REGEX("romstage"), OVERFLOW_REGEX("ramstage"), BANNER_REGEX("ramstage") }; for (size_t i = 0; !cursor && i < ARRAY_SIZE(regex); i++) { regex_t re; regmatch_t match; int res = regcomp(&re, regex[i], REG_EXTENDED | REG_NEWLINE); assert(res == 0); /* Keep looking for matches so we find the last one. */ while (!regexec(&re, console_c + cursor, 1, &match, 0)) { previous = cursor; cursor += match.rm_so + 1; } regfree(&re); } } if (type == CONSOLE_PRINT_PREVIOUS) { console_c[cursor] = '\0'; cursor = previous; } char c; int suppressed = 0; int tty = isatty(fileno(stdout)); while ((c = console_c[cursor++])) { if (BIOS_LOG_IS_MARKER(c)) { int lvl = BIOS_LOG_MARKER_TO_LEVEL(c); if (lvl > max_loglevel) { suppressed = 1; continue; } suppressed = 0; if (tty) printf(BIOS_LOG_ESCAPE_PATTERN, bios_log_escape[lvl]); printf(BIOS_LOG_PREFIX_PATTERN, bios_log_prefix[lvl]); } else { if (!suppressed) putchar(c); if (c == '\n') { if (tty && !suppressed) printf(BIOS_LOG_ESCAPE_RESET); suppressed = !print_unknown_logs; } } } if (tty) printf(BIOS_LOG_ESCAPE_RESET); free(console_c); unmap_memory(&console_mapping); } static void hexdump(unsigned long memory, int length) { int i; const uint8_t *m; int all_zero = 0; struct mapping hexdump_mapping; m = map_memory(&hexdump_mapping, memory, length); if (!m) die("Unable to map hexdump memory.\n"); for (i = 0; i < length; i += 16) { int j; all_zero++; for (j = 0; j < 16; j++) { if(m[i+j] != 0) { all_zero = 0; break; } } if (all_zero < 2) { printf("%08lx:", memory + i); for (j = 0; j < 16; j++) printf(" %02x", m[i+j]); printf(" "); for (j = 0; j < 16; j++) printf("%c", isprint(m[i+j]) ? m[i+j] : '.'); printf("\n"); } else if (all_zero == 2) { printf("...\n"); } } unmap_memory(&hexdump_mapping); } static void dump_cbmem_hex(void) { if (cbmem.type != LB_MEM_TABLE) { fprintf(stderr, "No coreboot CBMEM area found!\n"); return; } hexdump(cbmem.start, cbmem.size); } static void rawdump(uint64_t base, uint64_t size) { const uint8_t *m; struct mapping dump_mapping; m = map_memory(&dump_mapping, base, size); if (!m) die("Unable to map rawdump memory\n"); for (uint64_t i = 0 ; i < size; i++) printf("%c", m[i]); unmap_memory(&dump_mapping); } static void dump_cbmem_raw(unsigned int id) { const uint8_t *table; size_t offset; uint64_t base = 0; uint64_t size = 0; table = mapping_virt(&lbtable_mapping); if (table == NULL) return; offset = 0; while (offset < mapping_size(&lbtable_mapping)) { const struct lb_record *lbr; struct lb_cbmem_entry lbe; lbr = (const void *)(table + offset); offset += lbr->size; if (lbr->tag != LB_TAG_CBMEM_ENTRY) continue; aligned_memcpy(&lbe, lbr, sizeof(lbe)); if (lbe.id == id) { debug("found id for raw dump %0x", lbe.id); base = lbe.address; size = lbe.entry_size; break; } } if (!base) fprintf(stderr, "id %0x not found in cbtable\n", id); else rawdump(base, size); } struct cbmem_id_to_name { uint32_t id; const char *name; }; static const struct cbmem_id_to_name cbmem_ids[] = { CBMEM_ID_TO_NAME_TABLE }; #define MAX_STAGEx 10 static void cbmem_print_entry(int n, uint32_t id, uint64_t base, uint64_t size) { const char *name; char stage_x[20]; name = NULL; for (size_t i = 0; i < ARRAY_SIZE(cbmem_ids); i++) { if (cbmem_ids[i].id == id) { name = cbmem_ids[i].name; break; } if (id >= CBMEM_ID_STAGEx_META && id < CBMEM_ID_STAGEx_META + MAX_STAGEx) { snprintf(stage_x, sizeof(stage_x), "STAGE%d META", (id - CBMEM_ID_STAGEx_META)); name = stage_x; } if (id >= CBMEM_ID_STAGEx_CACHE && id < CBMEM_ID_STAGEx_CACHE + MAX_STAGEx) { snprintf(stage_x, sizeof(stage_x), "STAGE%d $ ", (id - CBMEM_ID_STAGEx_CACHE)); name = stage_x; } } printf("%2d. ", n); if (name == NULL) name = "(unknown)"; printf("%-20s %08x", name, id); printf(" %08" PRIx64 " ", base); printf(" %08" PRIx64 "\n", size); } static void dump_cbmem_toc(void) { int i; const uint8_t *table; size_t offset; table = mapping_virt(&lbtable_mapping); if (table == NULL) return; printf("CBMEM table of contents:\n"); printf(" %-20s %-8s %-8s %-8s\n", "NAME", "ID", "START", "LENGTH"); i = 0; offset = 0; while (offset < mapping_size(&lbtable_mapping)) { const struct lb_record *lbr; struct lb_cbmem_entry lbe; lbr = (const void *)(table + offset); offset += lbr->size; if (lbr->tag != LB_TAG_CBMEM_ENTRY) continue; aligned_memcpy(&lbe, lbr, sizeof(lbe)); cbmem_print_entry(i, lbe.id, lbe.address, lbe.entry_size); i++; } } #define COVERAGE_MAGIC 0x584d4153 struct file { uint32_t magic; uint32_t next; uint32_t filename; uint32_t data; int offset; int len; }; static int mkpath(char *path, mode_t mode) { assert (path && *path); char *p; for (p = strchr(path+1, '/'); p; p = strchr(p + 1, '/')) { *p = '\0'; if (mkdir(path, mode) == -1) { if (errno != EEXIST) { *p = '/'; return -1; } } *p = '/'; } return 0; } static void dump_coverage(void) { uint64_t start; size_t size; const void *coverage; struct mapping coverage_mapping; unsigned long phys_offset; #define phys_to_virt(x) ((void *)(unsigned long)(x) + phys_offset) if (find_cbmem_entry(CBMEM_ID_COVERAGE, &start, &size)) { fprintf(stderr, "No coverage information found\n"); return; } /* Map coverage area */ coverage = map_memory(&coverage_mapping, start, size); if (!coverage) die("Unable to map coverage area.\n"); phys_offset = (unsigned long)coverage - (unsigned long)start; printf("Dumping coverage data...\n"); struct file *file = (struct file *)coverage; while (file && file->magic == COVERAGE_MAGIC) { FILE *f; char *filename; debug(" -> %s\n", (char *)phys_to_virt(file->filename)); filename = strdup((char *)phys_to_virt(file->filename)); if (mkpath(filename, 0755) == -1) { perror("Directory for coverage data could " "not be created"); exit(1); } f = fopen(filename, "wb"); if (!f) { printf("Could not open %s: %s\n", filename, strerror(errno)); exit(1); } if (fwrite((void *)phys_to_virt(file->data), file->len, 1, f) != 1) { printf("Could not write to %s: %s\n", filename, strerror(errno)); exit(1); } fclose(f); free(filename); if (file->next) file = (struct file *)phys_to_virt(file->next); else file = NULL; } unmap_memory(&coverage_mapping); } static void print_version(void) { printf("cbmem v%s -- ", CBMEM_VERSION); printf("Copyright (C) 2012 The ChromiumOS Authors. All rights reserved.\n\n"); printf( "This program is free software: you can redistribute it and/or modify\n" "it under the terms of the GNU General Public License as published by\n" "the Free Software Foundation, version 2 of the License.\n\n" "This program is distributed in the hope that it will be useful,\n" "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" "GNU General Public License for more details.\n\n"); } static void print_usage(const char *name, int exit_code) { printf("usage: %s [-cCltTLxVvh?]\n", name); printf("\n" " -c | --console: print cbmem console\n" " -1 | --oneboot: print cbmem console for last boot only\n" " -2 | --2ndtolast: print cbmem console for the boot that came before the last one only\n" " -B | --loglevel: maximum loglevel to print; prefix `+` (e.g. -B +INFO) to also print lines that have no level\n" " -C | --coverage: dump coverage information\n" " -l | --list: print cbmem table of contents\n" " -x | --hexdump: print hexdump of cbmem area\n" " -r | --rawdump ID: print rawdump of specific ID (in hex) of cbtable\n" " -t | --timestamps: print timestamp information\n" " -T | --parseable-timestamps: print parseable timestamps\n" " -S | --stacked-timestamps: print stacked timestamps (e.g. for flame graph tools)\n" " -a | --add-timestamp ID: append timestamp with ID\n" " -L | --tcpa-log print TPM log\n" " -V | --verbose: verbose (debugging) output\n" " -v | --version: print the version\n" " -h | --help: print this help\n" "\n"); exit(exit_code); } #if defined(__arm__) || defined(__aarch64__) static void dt_update_cells(const char *name, int *addr_cells_ptr, int *size_cells_ptr) { if (*addr_cells_ptr >= 0 && *size_cells_ptr >= 0) return; int buffer; size_t nlen = strlen(name); char *prop = alloca(nlen + sizeof("/#address-cells")); strcpy(prop, name); if (*addr_cells_ptr < 0) { strcpy(prop + nlen, "/#address-cells"); int fd = open(prop, O_RDONLY); if (fd < 0 && errno != ENOENT) { perror(prop); } else if (fd >= 0) { if (read(fd, &buffer, sizeof(int)) < 0) perror(prop); else *addr_cells_ptr = ntohl(buffer); close(fd); } } if (*size_cells_ptr < 0) { strcpy(prop + nlen, "/#size-cells"); int fd = open(prop, O_RDONLY); if (fd < 0 && errno != ENOENT) { perror(prop); } else if (fd >= 0) { if (read(fd, &buffer, sizeof(int)) < 0) perror(prop); else *size_cells_ptr = ntohl(buffer); close(fd); } } } static char *dt_find_compat(const char *parent, const char *compat, int *addr_cells_ptr, int *size_cells_ptr) { char *ret = NULL; struct dirent *entry; DIR *dir; if (!(dir = opendir(parent))) { perror(parent); return NULL; } /* Loop through all files in the directory (DT node). */ while ((entry = readdir(dir))) { /* We only care about compatible props or subnodes. */ if (entry->d_name[0] == '.' || !((entry->d_type & DT_DIR) || !strcmp(entry->d_name, "compatible"))) continue; /* Assemble the file name (on the stack, for speed). */ size_t plen = strlen(parent); char *name = alloca(plen + strlen(entry->d_name) + 2); strcpy(name, parent); name[plen] = '/'; strcpy(name + plen + 1, entry->d_name); /* If it's a subnode, recurse. */ if (entry->d_type & DT_DIR) { ret = dt_find_compat(name, compat, addr_cells_ptr, size_cells_ptr); /* There is only one matching node to find, abort. */ if (ret) { /* Gather cells values on the way up. */ dt_update_cells(parent, addr_cells_ptr, size_cells_ptr); break; } continue; } /* If it's a compatible string, see if it's the right one. */ int fd = open(name, O_RDONLY); int clen = strlen(compat); char *buffer = alloca(clen + 1); if (fd < 0) { perror(name); continue; } if (read(fd, buffer, clen + 1) < 0) { perror(name); close(fd); continue; } close(fd); if (!strcmp(compat, buffer)) { /* Initialize these to "unset" for the way up. */ *addr_cells_ptr = *size_cells_ptr = -1; /* Can't leave string on the stack or we'll lose it! */ ret = strdup(parent); break; } } closedir(dir); return ret; } #endif /* defined(__arm__) || defined(__aarch64__) */ int main(int argc, char** argv) { int print_defaults = 1; int print_console = 0; int print_coverage = 0; int print_list = 0; int print_hexdump = 0; int print_rawdump = 0; int print_tcpa_log = 0; enum timestamps_print_type timestamp_type = TIMESTAMPS_PRINT_NONE; enum console_print_type console_type = CONSOLE_PRINT_FULL; unsigned int rawdump_id = 0; int max_loglevel = BIOS_NEVER; int print_unknown_logs = 1; uint32_t timestamp_id = 0; int opt, option_index = 0; static struct option long_options[] = { {"console", 0, 0, 'c'}, {"oneboot", 0, 0, '1'}, {"2ndtolast", 0, 0, '2'}, {"loglevel", required_argument, 0, 'B'}, {"coverage", 0, 0, 'C'}, {"list", 0, 0, 'l'}, {"tcpa-log", 0, 0, 'L'}, {"timestamps", 0, 0, 't'}, {"parseable-timestamps", 0, 0, 'T'}, {"stacked-timestamps", 0, 0, 'S'}, {"add-timestamp", required_argument, 0, 'a'}, {"hexdump", 0, 0, 'x'}, {"rawdump", required_argument, 0, 'r'}, {"verbose", 0, 0, 'V'}, {"version", 0, 0, 'v'}, {"help", 0, 0, 'h'}, {0, 0, 0, 0} }; while ((opt = getopt_long(argc, argv, "c12B:CltTSa:LxVvh?r:", long_options, &option_index)) != EOF) { switch (opt) { case 'c': print_console = 1; print_defaults = 0; break; case '1': print_console = 1; console_type = CONSOLE_PRINT_LAST; print_defaults = 0; break; case '2': print_console = 1; console_type = CONSOLE_PRINT_PREVIOUS; print_defaults = 0; break; case 'B': max_loglevel = parse_loglevel(optarg, &print_unknown_logs); break; case 'C': print_coverage = 1; print_defaults = 0; break; case 'l': print_list = 1; print_defaults = 0; break; case 'L': print_tcpa_log = 1; print_defaults = 0; break; case 'x': print_hexdump = 1; print_defaults = 0; break; case 'r': print_rawdump = 1; print_defaults = 0; rawdump_id = strtoul(optarg, NULL, 16); break; case 't': timestamp_type = TIMESTAMPS_PRINT_NORMAL; print_defaults = 0; break; case 'T': timestamp_type = TIMESTAMPS_PRINT_MACHINE_READABLE; print_defaults = 0; break; case 'S': timestamp_type = TIMESTAMPS_PRINT_STACKED; print_defaults = 0; break; case 'a': print_defaults = 0; timestamp_id = timestamp_enum_name_to_id(optarg); /* Parse numeric value if name is unknown */ if (timestamp_id == 0) timestamp_id = strtoul(optarg, NULL, 0); break; case 'V': verbose = 1; break; case 'v': print_version(); exit(0); break; case 'h': print_usage(argv[0], 0); break; case '?': default: print_usage(argv[0], 1); break; } } if (optind < argc) { fprintf(stderr, "Error: Extra parameter found.\n"); print_usage(argv[0], 1); } mem_fd = open("/dev/mem", timestamp_id ? O_RDWR : O_RDONLY, 0); if (mem_fd < 0) { fprintf(stderr, "Failed to gain memory access: %s\n", strerror(errno)); return 1; } #if defined(__arm__) || defined(__aarch64__) int addr_cells, size_cells; char *coreboot_node = dt_find_compat("/proc/device-tree", "coreboot", &addr_cells, &size_cells); if (!coreboot_node) { fprintf(stderr, "Could not find 'coreboot' compatible node!\n"); return 1; } if (addr_cells < 0) { fprintf(stderr, "Warning: no #address-cells node in tree!\n"); addr_cells = 1; } int nlen = strlen(coreboot_node); char *reg = alloca(nlen + sizeof("/reg")); strcpy(reg, coreboot_node); strcpy(reg + nlen, "/reg"); free(coreboot_node); int fd = open(reg, O_RDONLY); if (fd < 0) { perror(reg); return 1; } int i; size_t size_to_read = addr_cells * 4 + size_cells * 4; u8 *dtbuffer = alloca(size_to_read); if (read(fd, dtbuffer, size_to_read) < 0) { perror(reg); return 1; } close(fd); /* No variable-length byte swap function anywhere in C... how sad. */ u64 baseaddr = 0; for (i = 0; i < addr_cells * 4; i++) { baseaddr <<= 8; baseaddr |= *dtbuffer; dtbuffer++; } u64 cb_table_size = 0; for (i = 0; i < size_cells * 4; i++) { cb_table_size <<= 8; cb_table_size |= *dtbuffer; dtbuffer++; } parse_cbtable(baseaddr, cb_table_size); #else unsigned long long possible_base_addresses[] = { 0, 0xf0000 }; /* Find and parse coreboot table */ for (size_t j = 0; j < ARRAY_SIZE(possible_base_addresses); j++) { if (!parse_cbtable(possible_base_addresses[j], 0)) break; } #endif if (mapping_virt(&lbtable_mapping) == NULL) die("Table not found.\n"); if (print_console) dump_console(console_type, max_loglevel, print_unknown_logs); if (print_coverage) dump_coverage(); if (print_list) dump_cbmem_toc(); if (print_hexdump) dump_cbmem_hex(); if (print_rawdump) dump_cbmem_raw(rawdump_id); if (timestamp_id) timestamp_add_now(timestamp_id); if (print_defaults) timestamp_type = TIMESTAMPS_PRINT_NORMAL; if (timestamp_type != TIMESTAMPS_PRINT_NONE) dump_timestamps(timestamp_type); if (print_tcpa_log) dump_tpm_log(); unmap_memory(&lbtable_mapping); close(mem_fd); return 0; }