1 // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #define __STDC_FORMAT_MACROS 6 7 #include <string.h> 8 9 #include "cgpt.h" 10 #include "cgptlib_internal.h" 11 #include "crc32.h" 12 #include "vboot_host.h" 13 14 /* Generate output like: 15 * 16 * [AB-CD-EF-01] for group = 1 17 * [ABCD-EF01] for group = 3 (low byte first) 18 * 19 * Needs (size*3-1+3) bytes of space in 'buf' (included the tailing '\0'). 20 */ 21 #define BUFFER_SIZE(size) (size *3 - 1 + 3) 22 static short Uint8To2Chars(const uint8_t t) { 23 int h = t >> 4; 24 int l = t & 0xf; 25 h = (h >= 0xA) ? h - 0xA + 'A' : h + '0'; 26 l = (l >= 0xA) ? l - 0xA + 'A' : l + '0'; 27 return (h << 8) + l; 28 } 29 30 static void RawDump(const uint8_t *memory, const int size, 31 char *buf, int group) { 32 int i, outlen = 0; 33 buf[outlen++] = '['; 34 for (i = 0; i < size; ++i) { 35 short c2 = Uint8To2Chars(memory[i]); 36 buf[outlen++] = c2 >> 8; 37 buf[outlen++] = c2 & 0xff; 38 if (i != (size - 1) && ((i + 1) % group) == 0) 39 buf[outlen++] = '-'; 40 } 41 buf[outlen++] = ']'; 42 buf[outlen++] = '\0'; 43 } 44 45 /* Output formatters */ 46 #define TITLE_FMT "%12s%12s%8s %s\n" 47 #define GPT_FMT "%12d%12d%8s %s\n" 48 #define GPT_MORE "%12s%12s%8s ", "", "", "" 49 #define PARTITION_FMT "%12d%12d%8d %s\n" 50 #define PARTITION_MORE "%12s%12s%8s %s%s\n", "", "", "" 51 52 void PrintSignature(const char *indent, const char *sig, size_t n, int raw) { 53 size_t i; 54 printf("%sSig: ", indent); 55 if (!raw) { 56 printf("["); 57 for (i = 0; i < n; ++i) 58 printf("%c", sig[i]); 59 printf("]"); 60 } else { 61 char *buf = malloc(BUFFER_SIZE(n)); 62 RawDump((uint8_t *)sig, n, buf, 1); 63 printf("%s", buf); 64 free(buf); 65 } 66 printf("\n"); 67 } 68 69 static void HeaderDetails(GptHeader *header, GptEntry *entries, 70 const char *indent, int raw) { 71 PrintSignature(indent, header->signature, sizeof(header->signature), raw); 72 73 printf("%sRev: 0x%08x\n", indent, header->revision); 74 printf("%sSize: %d\n", indent, header->size); 75 printf("%sHeader CRC: 0x%08x %s\n", indent, header->header_crc32, 76 (HeaderCrc(header) != header->header_crc32) ? "(INVALID)" : ""); 77 printf("%sMy LBA: %lld\n", indent, (long long)header->my_lba); 78 printf("%sAlternate LBA: %lld\n", indent, (long long)header->alternate_lba); 79 printf("%sFirst LBA: %lld\n", indent, (long long)header->first_usable_lba); 80 printf("%sLast LBA: %lld\n", indent, (long long)header->last_usable_lba); 81 82 { /* For disk guid */ 83 char buf[GUID_STRLEN]; 84 GuidToStr(&header->disk_uuid, buf, GUID_STRLEN); 85 printf("%sDisk UUID: %s\n", indent, buf); 86 } 87 88 printf("%sEntries LBA: %lld\n", indent, (long long)header->entries_lba); 89 printf("%sNumber of entries: %d\n", indent, header->number_of_entries); 90 printf("%sSize of entry: %d\n", indent, header->size_of_entry); 91 printf("%sEntries CRC: 0x%08x %s\n", indent, header->entries_crc32, 92 header->entries_crc32 != 93 Crc32((const uint8_t *)entries,header->size_of_entry * 94 header->number_of_entries) 95 ? "INVALID" : "" 96 ); 97 } 98 99 void EntryDetails(GptEntry *entry, uint32_t index, int raw) { 100 char contents[256]; // scratch buffer for formatting output 101 uint8_t label[GPT_PARTNAME_LEN]; 102 char type[GUID_STRLEN], unique[GUID_STRLEN]; 103 104 UTF16ToUTF8(entry->name, sizeof(entry->name) / sizeof(entry->name[0]), 105 label, sizeof(label)); 106 require(snprintf(contents, sizeof(contents), 107 "Label: \"%s\"", label) < sizeof(contents)); 108 printf(PARTITION_FMT, (int)entry->starting_lba, 109 (int)(entry->ending_lba - entry->starting_lba + 1), 110 index+1, contents); 111 112 if (!raw && CGPT_OK == ResolveType(&entry->type, type)) { 113 printf(PARTITION_MORE, "Type: ", type); 114 } else { 115 GuidToStr(&entry->type, type, GUID_STRLEN); 116 printf(PARTITION_MORE, "Type: ", type); 117 } 118 GuidToStr(&entry->unique, unique, GUID_STRLEN); 119 printf(PARTITION_MORE, "UUID: ", unique); 120 121 if (!raw) { 122 if (GuidEqual(&guid_chromeos_kernel, &entry->type)) { 123 int tries = (entry->attrs.fields.gpt_att & 124 CGPT_ATTRIBUTE_TRIES_MASK) >> 125 CGPT_ATTRIBUTE_TRIES_OFFSET; 126 int successful = (entry->attrs.fields.gpt_att & 127 CGPT_ATTRIBUTE_SUCCESSFUL_MASK) >> 128 CGPT_ATTRIBUTE_SUCCESSFUL_OFFSET; 129 int priority = (entry->attrs.fields.gpt_att & 130 CGPT_ATTRIBUTE_PRIORITY_MASK) >> 131 CGPT_ATTRIBUTE_PRIORITY_OFFSET; 132 require(snprintf(contents, sizeof(contents), 133 "priority=%d tries=%d successful=%d", 134 priority, tries, successful) < sizeof(contents)); 135 printf(PARTITION_MORE, "Attr: ", contents); 136 } 137 } else { 138 require(snprintf(contents, sizeof(contents), 139 "[%x]", entry->attrs.fields.gpt_att) < sizeof(contents)); 140 printf(PARTITION_MORE, "Attr: ", contents); 141 } 142 } 143 144 void EntriesDetails(struct drive *drive, const int secondary, int raw) { 145 uint32_t i; 146 147 for (i = 0; i < GetNumberOfEntries(drive); ++i) { 148 GptEntry *entry; 149 entry = GetEntry(&drive->gpt, secondary, i); 150 151 if (GuidIsZero(&entry->type)) 152 continue; 153 154 EntryDetails(entry, i, raw); 155 } 156 } 157 158 static int GptShow(struct drive *drive, CgptShowParams *params) { 159 int gpt_retval; 160 if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive->gpt))) { 161 Error("GptSanityCheck() returned %d: %s\n", 162 gpt_retval, GptError(gpt_retval)); 163 return CGPT_FAILED; 164 } 165 166 if (params->partition) { // show single partition 167 168 if (params->partition > GetNumberOfEntries(drive)) { 169 Error("invalid partition number: %d\n", params->partition); 170 return CGPT_FAILED; 171 } 172 173 uint32_t index = params->partition - 1; 174 GptEntry *entry = GetEntry(&drive->gpt, ANY_VALID, index); 175 char buf[256]; // scratch buffer for string conversion 176 177 if (params->single_item) { 178 switch(params->single_item) { 179 case 'b': 180 printf("%" PRId64 "\n", entry->starting_lba); 181 break; 182 case 's': { 183 uint64_t size = 0; 184 // If these aren't actually defined, don't show anything 185 if (entry->ending_lba || entry->starting_lba) 186 size = entry->ending_lba - entry->starting_lba + 1; 187 printf("%" PRId64 "\n", size); 188 break; 189 } 190 case 't': 191 GuidToStr(&entry->type, buf, sizeof(buf)); 192 printf("%s\n", buf); 193 break; 194 case 'u': 195 GuidToStr(&entry->unique, buf, sizeof(buf)); 196 printf("%s\n", buf); 197 break; 198 case 'l': 199 UTF16ToUTF8(entry->name, sizeof(entry->name) / sizeof(entry->name[0]), 200 (uint8_t *)buf, sizeof(buf)); 201 printf("%s\n", buf); 202 break; 203 case 'S': 204 printf("%d\n", GetSuccessful(drive, ANY_VALID, index)); 205 break; 206 case 'T': 207 printf("%d\n", GetTries(drive, ANY_VALID, index)); 208 break; 209 case 'P': 210 printf("%d\n", GetPriority(drive, ANY_VALID, index)); 211 break; 212 case 'A': 213 printf("0x%x\n", entry->attrs.fields.gpt_att); 214 break; 215 } 216 } else { 217 printf(TITLE_FMT, "start", "size", "part", "contents"); 218 EntryDetails(entry, index, params->numeric); 219 } 220 221 } else if (params->quick) { // show all partitions, quickly 222 uint32_t i; 223 GptEntry *entry; 224 char type[GUID_STRLEN]; 225 226 for (i = 0; i < GetNumberOfEntries(drive); ++i) { 227 entry = GetEntry(&drive->gpt, ANY_VALID, i); 228 229 if (GuidIsZero(&entry->type)) 230 continue; 231 232 if (!params->numeric && CGPT_OK == ResolveType(&entry->type, type)) { 233 } else { 234 GuidToStr(&entry->type, type, GUID_STRLEN); 235 } 236 printf(PARTITION_FMT, (int)entry->starting_lba, 237 (int)(entry->ending_lba - entry->starting_lba + 1), 238 i+1, type); 239 } 240 } else { // show all partitions 241 GptEntry *entries; 242 243 if (CGPT_OK != ReadPMBR(drive)) { 244 Error("Unable to read PMBR\n"); 245 return CGPT_FAILED; 246 } 247 248 printf(TITLE_FMT, "start", "size", "part", "contents"); 249 char buf[256]; // buffer for formatted PMBR content 250 PMBRToStr(&drive->pmbr, buf, sizeof(buf)); // will exit if buf is too small 251 printf(GPT_FMT, 0, GPT_PMBR_SECTORS, "", buf); 252 253 if (drive->gpt.valid_headers & MASK_PRIMARY) { 254 printf(GPT_FMT, (int)GPT_PMBR_SECTORS, 255 (int)GPT_HEADER_SECTORS, "", "Pri GPT header"); 256 } else { 257 printf(GPT_FMT, (int)GPT_PMBR_SECTORS, 258 (int)GPT_HEADER_SECTORS, "INVALID", "Pri GPT header"); 259 } 260 261 if (params->debug || 262 ((drive->gpt.valid_headers & MASK_PRIMARY) && params->verbose)) { 263 GptHeader *header; 264 char indent[64]; 265 266 require(snprintf(indent, sizeof(indent), GPT_MORE) < sizeof(indent)); 267 header = (GptHeader*)drive->gpt.primary_header; 268 entries = (GptEntry*)drive->gpt.primary_entries; 269 HeaderDetails(header, entries, indent, params->numeric); 270 } 271 272 GptHeader* primary_header = (GptHeader*)drive->gpt.primary_header; 273 printf(GPT_FMT, (int)primary_header->entries_lba, 274 (int)CalculateEntriesSectors(primary_header), 275 drive->gpt.valid_entries & MASK_PRIMARY ? "" : "INVALID", 276 "Pri GPT table"); 277 278 if (params->debug || 279 (drive->gpt.valid_entries & MASK_PRIMARY)) 280 EntriesDetails(drive, PRIMARY, params->numeric); 281 282 /****************************** Secondary *************************/ 283 GptHeader* secondary_header = (GptHeader*)drive->gpt.secondary_header; 284 printf(GPT_FMT, (int)secondary_header->entries_lba, 285 (int)CalculateEntriesSectors(secondary_header), 286 drive->gpt.valid_entries & MASK_SECONDARY ? "" : "INVALID", 287 "Sec GPT table"); 288 /* We show secondary table details if any of following is true. 289 * 1. in debug mode. 290 * 2. only secondary is valid. 291 * 3. secondary is not identical to promary. 292 */ 293 if (params->debug || 294 ((drive->gpt.valid_entries & MASK_SECONDARY) && 295 (!(drive->gpt.valid_entries & MASK_PRIMARY) || 296 memcmp(drive->gpt.primary_entries, drive->gpt.secondary_entries, 297 secondary_header->number_of_entries * 298 secondary_header->size_of_entry)))) { 299 EntriesDetails(drive, SECONDARY, params->numeric); 300 } 301 302 if (drive->gpt.valid_headers & MASK_SECONDARY) 303 printf(GPT_FMT, (int)(drive->gpt.gpt_drive_sectors - GPT_HEADER_SECTORS), 304 (int)GPT_HEADER_SECTORS, "", "Sec GPT header"); 305 else 306 printf(GPT_FMT, (int)GPT_PMBR_SECTORS, 307 (int)GPT_HEADER_SECTORS, "INVALID", "Sec GPT header"); 308 /* We show secondary header if any of following is true: 309 * 1. in debug mode. 310 * 2. only secondary is valid. 311 * 3. secondary is not synonymous to primary. 312 */ 313 if (params->debug || 314 ((drive->gpt.valid_headers & MASK_SECONDARY) && 315 (!(drive->gpt.valid_headers & MASK_PRIMARY) || 316 !IsSynonymous((GptHeader*)drive->gpt.primary_header, 317 (GptHeader*)drive->gpt.secondary_header)) && 318 params->verbose)) { 319 GptHeader *header; 320 char indent[64]; 321 322 require(snprintf(indent, sizeof(indent), GPT_MORE) < sizeof(indent)); 323 header = (GptHeader*)drive->gpt.secondary_header; 324 entries = (GptEntry*)drive->gpt.secondary_entries; 325 HeaderDetails(header, entries, indent, params->numeric); 326 } 327 } 328 329 CheckValid(drive); 330 331 return CGPT_OK; 332 } 333 334 int CgptShow(CgptShowParams *params) { 335 struct drive drive; 336 337 if (params == NULL) 338 return CGPT_FAILED; 339 340 if (CGPT_OK != DriveOpen(params->drive_name, &drive, O_RDONLY, 341 params->drive_size)) 342 return CGPT_FAILED; 343 344 if (GptShow(&drive, params)) 345 return CGPT_FAILED; 346 347 DriveClose(&drive, 0); 348 return CGPT_OK; 349 } 350
