1 /* 2 * (C) Copyright 2015 Google, Inc 3 * Written by Simon Glass <sjg@chromium.org> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <command.h> 10 #include <efi.h> 11 #include <errno.h> 12 #include <malloc.h> 13 14 static const char *const type_name[] = { 15 "reserved", 16 "loader_code", 17 "loader_data", 18 "bs_code", 19 "bs_data", 20 "rt_code", 21 "rt_data", 22 "conv", 23 "unusable", 24 "acpi_reclaim", 25 "acpi_nvs", 26 "io", 27 "io_port", 28 "pal_code", 29 }; 30 31 static struct attr_info { 32 int shift; 33 const char *name; 34 } mem_attr[] = { 35 { EFI_MEMORY_UC_SHIFT, "uncached" }, 36 { EFI_MEMORY_WC_SHIFT, "write-coalescing" }, 37 { EFI_MEMORY_WT_SHIFT, "write-through" }, 38 { EFI_MEMORY_WB_SHIFT, "write-back" }, 39 { EFI_MEMORY_UCE_SHIFT, "uncached & exported" }, 40 { EFI_MEMORY_WP_SHIFT, "write-protect" }, 41 { EFI_MEMORY_RP_SHIFT, "read-protect" }, 42 { EFI_MEMORY_XP_SHIFT, "execute-protect" }, 43 { EFI_MEMORY_RUNTIME_SHIFT, "needs runtime mapping" } 44 }; 45 46 /* Maximum different attribute values we can track */ 47 #define ATTR_SEEN_MAX 30 48 49 static inline bool is_boot_services(int type) 50 { 51 return type == EFI_LOADER_CODE || type == EFI_LOADER_DATA || 52 type == EFI_BOOT_SERVICES_CODE || 53 type == EFI_BOOT_SERVICES_DATA; 54 } 55 56 static int h_cmp_entry(const void *v1, const void *v2) 57 { 58 const struct efi_mem_desc *desc1 = v1; 59 const struct efi_mem_desc *desc2 = v2; 60 int64_t diff = desc1->physical_start - desc2->physical_start; 61 62 /* 63 * Manually calculate the difference to avoid sign loss in the 64-bit 64 * to 32-bit conversion 65 */ 66 return diff < 0 ? -1 : diff > 0 ? 1 : 0; 67 } 68 69 void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs) 70 { 71 struct efi_mem_desc *desc, *end, *base, *dest, *prev; 72 int count; 73 u64 addr; 74 75 base = malloc(size + sizeof(*desc)); 76 if (!base) { 77 debug("%s: Cannot allocate %#x bytes\n", __func__, size); 78 return NULL; 79 } 80 end = (struct efi_mem_desc *)((ulong)map + size); 81 count = ((ulong)end - (ulong)map->desc) / map->desc_size; 82 memcpy(base, map->desc, (ulong)end - (ulong)map->desc); 83 qsort(base, count, map->desc_size, h_cmp_entry); 84 prev = NULL; 85 addr = 0; 86 dest = base; 87 end = base + count; 88 for (desc = base; desc < end; desc = efi_get_next_mem_desc(map, desc)) { 89 bool merge = true; 90 int type = desc->type; 91 92 if (skip_bs && is_boot_services(desc->type)) 93 type = EFI_CONVENTIONAL_MEMORY; 94 95 memcpy(dest, desc, map->desc_size); 96 dest->type = type; 97 if (!skip_bs || !prev) 98 merge = false; 99 else if (desc->physical_start != addr) 100 merge = false; 101 else if (type != EFI_CONVENTIONAL_MEMORY) 102 merge = false; 103 else if (prev->type != EFI_CONVENTIONAL_MEMORY) 104 merge = false; 105 106 if (merge) { 107 prev->num_pages += desc->num_pages; 108 } else { 109 prev = dest; 110 dest = efi_get_next_mem_desc(map, dest); 111 } 112 addr = desc->physical_start + (desc->num_pages << 113 EFI_PAGE_SHIFT); 114 } 115 116 /* Mark the end */ 117 dest->type = EFI_TABLE_END; 118 119 return base; 120 } 121 122 static void efi_print_mem_table(struct efi_entry_memmap *map, 123 struct efi_mem_desc *desc, bool skip_bs) 124 { 125 u64 attr_seen[ATTR_SEEN_MAX]; 126 int attr_seen_count; 127 int upto, i; 128 u64 addr; 129 130 printf(" # %-14s %10s %10s %10s %s\n", "Type", "Physical", 131 "Virtual", "Size", "Attributes"); 132 133 /* Keep track of all the different attributes we have seen */ 134 attr_seen_count = 0; 135 addr = 0; 136 for (upto = 0; desc->type != EFI_TABLE_END; 137 upto++, desc = efi_get_next_mem_desc(map, desc)) { 138 const char *name; 139 u64 size; 140 141 if (skip_bs && is_boot_services(desc->type)) 142 continue; 143 if (desc->physical_start != addr) { 144 printf(" %-14s %010llx %10s %010llx\n", "<gap>", 145 addr, "", desc->physical_start - addr); 146 } 147 size = desc->num_pages << EFI_PAGE_SHIFT; 148 149 name = desc->type < ARRAY_SIZE(type_name) ? 150 type_name[desc->type] : "<invalid>"; 151 printf("%2d %x:%-12s %010llx %010llx %010llx ", upto, 152 desc->type, name, desc->physical_start, 153 desc->virtual_start, size); 154 if (desc->attribute & EFI_MEMORY_RUNTIME) 155 putc('r'); 156 printf("%llx", desc->attribute & ~EFI_MEMORY_RUNTIME); 157 putc('\n'); 158 159 for (i = 0; i < attr_seen_count; i++) { 160 if (attr_seen[i] == desc->attribute) 161 break; 162 } 163 if (i == attr_seen_count && i < ATTR_SEEN_MAX) 164 attr_seen[attr_seen_count++] = desc->attribute; 165 addr = desc->physical_start + size; 166 } 167 168 printf("\nAttributes key:\n"); 169 for (i = 0; i < attr_seen_count; i++) { 170 u64 attr = attr_seen[i]; 171 bool first; 172 int j; 173 174 printf("%c%llx: ", attr & EFI_MEMORY_RUNTIME ? 'r' : ' ', 175 attr & ~EFI_MEMORY_RUNTIME); 176 for (j = 0, first = true; j < ARRAY_SIZE(mem_attr); j++) { 177 if (attr & (1ULL << mem_attr[j].shift)) { 178 if (first) 179 first = false; 180 else 181 printf(", "); 182 printf("%s", mem_attr[j].name); 183 } 184 } 185 putc('\n'); 186 } 187 if (skip_bs) 188 printf("*Some areas are merged (use 'all' to see)\n"); 189 } 190 191 static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 192 { 193 struct efi_mem_desc *desc; 194 struct efi_entry_memmap *map; 195 int size, ret; 196 bool skip_bs; 197 198 skip_bs = !argc || *argv[0] != 'a'; 199 ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size); 200 switch (ret) { 201 case -ENOENT: 202 printf("No EFI table available\n"); 203 goto done; 204 case -EPROTONOSUPPORT: 205 printf("Incorrect EFI table version\n"); 206 goto done; 207 } 208 printf("EFI table at %lx, memory map %p, size %x, version %x, descr. size %#x\n", 209 gd->arch.table, map, size, map->version, map->desc_size); 210 if (map->version != EFI_MEM_DESC_VERSION) { 211 printf("Incorrect memory map version\n"); 212 ret = -EPROTONOSUPPORT; 213 goto done; 214 } 215 216 desc = efi_build_mem_table(map, size, skip_bs); 217 if (!desc) { 218 ret = -ENOMEM; 219 goto done; 220 } 221 222 efi_print_mem_table(map, desc, skip_bs); 223 free(desc); 224 done: 225 if (ret) 226 printf("Error: %d\n", ret); 227 228 return ret ? CMD_RET_FAILURE : 0; 229 } 230 231 static cmd_tbl_t efi_commands[] = { 232 U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""), 233 }; 234 235 static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 236 { 237 cmd_tbl_t *efi_cmd; 238 int ret; 239 240 if (argc < 2) 241 return CMD_RET_USAGE; 242 efi_cmd = find_cmd_tbl(argv[1], efi_commands, ARRAY_SIZE(efi_commands)); 243 argc -= 2; 244 argv += 2; 245 if (!efi_cmd || argc > efi_cmd->maxargs) 246 return CMD_RET_USAGE; 247 248 ret = efi_cmd->cmd(efi_cmd, flag, argc, argv); 249 250 return cmd_process_error(efi_cmd, ret); 251 } 252 253 U_BOOT_CMD( 254 efi, 3, 1, do_efi, 255 "EFI access", 256 "mem [all] Dump memory information [include boot services]" 257 ); 258