gptsubr.c revision 1.4
1 /* $NetBSD: gptsubr.c,v 1.4 2025/03/02 00:23:59 riastradh Exp $ */ 2 3 /* 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 14 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 15 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 16 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 19 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 #include <sys/cdefs.h> 27 #ifndef lint 28 __RCSID("$NetBSD: gptsubr.c,v 1.4 2025/03/02 00:23:59 riastradh Exp $"); 29 #endif /* not lint */ 30 31 #include <sys/param.h> 32 33 #include <sys/disk.h> 34 #include <sys/disklabel.h> 35 #include <sys/disklabel_gpt.h> 36 #include <sys/dkio.h> 37 #include <sys/ioctl.h> 38 #include <sys/stat.h> 39 #include <sys/statvfs.h> 40 41 #include <err.h> 42 #include <fcntl.h> 43 #include <libgen.h> 44 #include <paths.h> 45 #include <stdbool.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <unistd.h> 49 #include <uuid.h> 50 51 #include "defs.h" 52 #include "gpt.h" 53 #include "gptsubr.h" 54 #include "map.h" 55 56 #define DEBUG 57 58 #ifdef DEBUG 59 #define DPRINTF(fmt, ...) printf(fmt, __VA_ARGS__) 60 #else 61 #define DPRINTF(fmt, ...) do { } while (/*CONSTCOND*/0) 62 #endif 63 64 static const char * 65 map_type_name(int map_type) 66 { 67 const char *xtbl[] = { 68 "UNUSED", // 0 69 "MBR", // 1 70 "MBR_PART", // 2 71 "PRI_GPT_HDR", // 3 72 "SEC_GPT_HDR", // 4 73 "PRI_GPT_TBL", // 5 74 "SEC_GPT_TBL", // 6 75 "GPT_PART", // 7 76 "PMBR", // 8 77 }; 78 79 if (map_type >= (int)__arraycount(xtbl)) 80 return "UNKNOWN"; 81 82 return xtbl[map_type]; 83 } 84 85 #if 0 86 struct map { 87 off_t map_start; 88 off_t map_size; 89 struct map *map_next; 90 struct map *map_prev; 91 int map_type; 92 #define MAP_TYPE_UNUSED 0 93 #define MAP_TYPE_MBR 1 94 #define MAP_TYPE_MBR_PART 2 95 #define MAP_TYPE_PRI_GPT_HDR 3 96 #define MAP_TYPE_SEC_GPT_HDR 4 97 #define MAP_TYPE_PRI_GPT_TBL 5 98 #define MAP_TYPE_SEC_GPT_TBL 6 99 #define MAP_TYPE_GPT_PART 7 100 #define MAP_TYPE_PMBR 8 101 unsigned int map_index; 102 void *map_data; 103 int map_alloc; 104 }; 105 106 struct gpt_ent { 107 uint8_t ent_type[16]; /* partition type GUID */ 108 uint8_t ent_guid[16]; /* unique partition GUID */ 109 uint64_t ent_lba_start; /* start of partition */ 110 uint64_t ent_lba_end; /* end of partition */ 111 uint64_t ent_attr; /* partition attributes */ 112 uint16_t ent_name[36]; /* partition name in UCS-2 */ 113 }; 114 115 struct gpt_hdr { 116 int8_t hdr_sig[8]; /* identifies GUID Partition Table */ 117 uint32_t hdr_revision; /* GPT specification revision */ 118 uint32_t hdr_size; /* size of GPT Header */ 119 uint32_t hdr_crc_self; /* CRC32 of GPT Header */ 120 uint32_t hdr__rsvd0; /* must be zero */ 121 uint64_t hdr_lba_self; /* LBA that contains this Header */ 122 uint64_t hdr_lba_alt; /* LBA of backup GPT Header */ 123 uint64_t hdr_lba_start; /* first LBA usable for partitions */ 124 uint64_t hdr_lba_end; /* last LBA usable for partitions */ 125 uint8_t hdr_guid[16]; /* GUID to identify the disk */ 126 uint64_t hdr_lba_table; /* first LBA of GPE array */ 127 uint32_t hdr_entries; /* number of entries in GPE array */ 128 uint32_t hdr_entsz; /* size of each GPE */ 129 uint32_t hdr_crc_table; /* CRC32 of GPE array */ 130 /* 131 * The remainder of the block that contains the GPT Header 132 * is reserved by EFI for future GPT Header expansion, and 133 * must be zero. 134 */ 135 }; 136 #endif 137 138 struct map_widths { 139 uint start; 140 uint size; 141 uint type_name; 142 }; 143 144 static struct map_widths 145 get_map_widths(gpt_t gpt) 146 { 147 struct map_widths w; 148 off_t max_start = 0; 149 off_t max_size = 0; 150 map_t m; 151 152 w.type_name = 0; 153 for (m = map_first(gpt); m != NULL; m = m->map_next) { 154 uint n; 155 156 if (max_start < m->map_start) 157 max_start = m->map_start; 158 if (max_size < m->map_size) 159 max_size = m->map_size; 160 if (m->map_type == MAP_TYPE_GPT_PART) { 161 struct gpt_ent *ent = m->map_data; 162 gpt_uuid_t gpt_uuid; 163 char ent_type[128]; 164 165 memcpy(&gpt_uuid, ent->ent_type, sizeof(gpt_uuid)); 166 n = (uint)gpt_uuid_snprintf(ent_type, sizeof(ent_type), "%s", gpt_uuid); 167 if (w.type_name < n) 168 w.type_name = n; 169 } 170 171 } 172 w.start = (uint)snprintf(NULL, 0, "%" PRIx64, max_start); 173 w.size = (uint)snprintf(NULL, 0, "%" PRIx64, max_size); 174 175 #define MIN_WIDTH_OF(s) (sizeof(s) - 1) 176 if (w.type_name < MIN_WIDTH_OF("TYPE_NAME")) 177 w.type_name = MIN_WIDTH_OF("TYPE_NAME"); 178 if (w.start < MIN_WIDTH_OF("START")) 179 w.start = MIN_WIDTH_OF("START"); 180 if (w.size < MIN_WIDTH_OF("SIZE")) 181 w.size = MIN_WIDTH_OF("SIZE"); 182 #undef MIN_WIDTH_OF 183 184 return w; 185 } 186 187 static void 188 show_map_banner(struct map_widths w) 189 { 190 191 printf("IDX %*s %*s ATTR PARTITION_GUID" 192 " TYPE_UUID %*s " 193 "TYPE_NAME ENTRY_NAME DESCRIPTION\n", 194 w.start, "START", 195 w.size, "SIZE", 196 w.type_name, ""); 197 } 198 199 static void 200 show_map(map_t m, struct map_widths w) 201 { 202 struct gpt_ent *ent; 203 struct gpt_hdr *hdr; 204 gpt_uuid_t gpt_uuid; 205 uuid_t uuid; 206 uint32_t status; 207 char *type_uuid; 208 char *part_guid; 209 uint64_t ent_attr; 210 uint8_t ent_desc[128]; 211 char ent_type[128]; 212 213 ent_desc[0] = '\0'; 214 ent_type[0] = '\0'; 215 ent_attr = 0; 216 217 switch (m->map_type) { 218 case MAP_TYPE_PRI_GPT_HDR: 219 case MAP_TYPE_SEC_GPT_HDR: 220 hdr = m->map_data; 221 memcpy(&uuid, hdr->hdr_guid, sizeof(uuid)); 222 uuid_to_string(&uuid, &part_guid, &status); 223 type_uuid = estrdup(""); 224 break; 225 226 case MAP_TYPE_GPT_PART: 227 ent = m->map_data; 228 229 memcpy(&uuid, ent->ent_type, sizeof(uuid)); 230 uuid_to_string(&uuid, &type_uuid, &status); 231 232 memcpy(&uuid, ent->ent_guid, sizeof(uuid)); 233 uuid_to_string(&uuid, &part_guid, &status); 234 235 ent_attr = ent->ent_attr; 236 237 memcpy(&gpt_uuid, ent->ent_type, sizeof(uuid)); 238 gpt_uuid_snprintf(ent_type, sizeof(ent_type), "%s", gpt_uuid); 239 240 /* 241 * Use the gpt.c code here rather than our 242 * ucs2_to_utf8() as we are in their world. 243 */ 244 utf16_to_utf8(ent->ent_name, sizeof(ent->ent_name), 245 ent_desc, sizeof(ent_desc)); 246 247 break; 248 249 case MAP_TYPE_MBR_PART: 250 part_guid = estrdup(""); 251 type_uuid = estrdup(""); 252 break; 253 254 case MAP_TYPE_MBR: { 255 struct mbr *mbr = m->map_data; 256 257 easprintf(&part_guid, "%02x%02x%02x%02x-0000-0000-0000-000000000000", 258 mbr->mbr_code[440], 259 mbr->mbr_code[441], 260 mbr->mbr_code[442], 261 mbr->mbr_code[443]); 262 uuid_to_string(&(uuid_t)GPT_ENT_TYPE_MBR, &type_uuid, &status); 263 break; 264 } 265 default: 266 part_guid = estrdup(""); 267 type_uuid = estrdup(""); 268 break; 269 } 270 271 printf("%2u: %*" PRIx64 " %*" PRIx64 " %08" PRIx64 272 " %36s %36s %*s %-11s %s\n", 273 m->map_index, 274 w.start, 275 m->map_start, 276 w.size, 277 m->map_size, 278 ent_attr, 279 part_guid, 280 type_uuid, 281 w.type_name, 282 ent_type, 283 map_type_name(m->map_type), 284 ent_desc); 285 286 free(part_guid); 287 free(type_uuid); 288 } 289 290 PUBLIC map_t 291 find_gpt_map(const char *dev, uint idx) 292 { 293 gpt_t gpt; 294 map_t m; 295 296 gpt = gpt_open(dev, GPT_READONLY, 0, 0, 0, 0); 297 298 if (gpt == NULL) 299 err(EXIT_FAILURE, "gpt_open"); 300 301 if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL) 302 printf("GPT not found, displaying data from MBR.\n"); 303 304 for (m = map_first(gpt); m != NULL; m = m->map_next) { 305 if (m->map_index == idx) 306 break; 307 } 308 gpt_close(gpt); 309 return m; 310 } 311 312 PUBLIC char * 313 parent_of_fname(const char *fname) 314 { 315 struct dkwedge_info dkinfo; 316 struct statvfs vfsb; 317 struct stat sb; 318 const char *d, *b; 319 char *p; 320 size_t n; 321 int fd, rv; 322 323 rv = stat(fname, &sb); 324 if (rv == -1) 325 err(EXIT_FAILURE, "stat: %s", fname); 326 327 if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) 328 return estrdup(fname); 329 330 rv = statvfs(fname, &vfsb); 331 if (rv == -1) 332 err(EXIT_FAILURE, "statvfs: %s", fname); 333 334 b = basename(vfsb.f_mntfromname); 335 d = dirname(vfsb.f_mntfromname); 336 easprintf(&p, "%s/r%s", d, b); 337 338 fd = open(p, O_RDONLY); 339 if (fd == -1) 340 err(EXIT_FAILURE, "open"); 341 342 rv = ioctl(fd, DIOCGWEDGEINFO, &dkinfo); 343 close(fd); 344 345 if (rv != -1) { 346 free(p); 347 return estrdup(dkinfo.dkw_parent); 348 } 349 350 warn("ioctl: DIOCGWEDGEINFO"); 351 352 /* 353 * Hum. No wedges? Assume we have the old disklabel 354 * "/dev/rwd0x" syntax. Convert it to "/dev/rwd0d". 355 * XXX: this probably won't work. 356 */ 357 n = strlen(p); 358 p[n - 1] = 'd'; 359 360 return p; 361 } 362 363 PUBLIC int 364 mbr_sig_write(const char *fname, uint32_t new_sig, bool force, int verbose) 365 { 366 gpt_t gpt; 367 map_t m; 368 struct mbr *mbr; 369 const char *dev; 370 uint32_t old_sig; 371 372 if (fname == NULL) 373 errx(EXIT_FAILURE, "please specify a device"); 374 375 dev = parent_of_fname(fname); 376 if (dev == NULL) { 377 warnx("unable to find parent device of %s\n", fname); 378 return -1; 379 } 380 381 gpt = gpt_open(dev, GPT_MODIFIED, verbose, 0, 0, 0); 382 383 if (gpt == NULL) 384 err(EXIT_FAILURE, "gpt_open"); 385 386 m = map_find(gpt, MAP_TYPE_MBR); 387 if (m == NULL) 388 printf("No MBR partition found!\n"); 389 else { 390 mbr = m->map_data; 391 392 memcpy(&old_sig, &mbr->mbr_code[440], 4); 393 394 if (old_sig == 0) 395 force = true; 396 397 if (force) { 398 memcpy(&mbr->mbr_code[440], &new_sig, 4); 399 if (gpt_write(gpt, m) == -1) 400 warn("gpt_write"); 401 else if (verbose) 402 printf("sig: 0x%08x -> 0x%08x\n", 403 old_sig, new_sig); 404 } 405 else if (verbose) 406 printf("sig: 0x%08x (unchanged)\n", old_sig); 407 } 408 409 gpt_close(gpt); 410 return 0; 411 } 412 413 PUBLIC int 414 show_gpt(const char *fname, int verbose) 415 { 416 gpt_t gpt; 417 map_t m; 418 struct map_widths w; 419 const char *dev; 420 421 dev = parent_of_fname(fname); 422 if (dev == NULL) 423 return -1; 424 425 gpt = gpt_open(dev, GPT_READONLY, verbose, 0, 0, 0); 426 427 if (gpt == NULL) 428 err(EXIT_FAILURE, "gpt_open"); 429 430 if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL) 431 warnx("GPT not found, displaying data from MBR."); 432 433 w = get_map_widths(gpt); 434 show_map_banner(w); 435 436 for (m = map_first(gpt); m != NULL; m = m->map_next) 437 show_map(m, w); 438 439 gpt_close(gpt); 440 return 0; 441 } 442 443 #if 0 /* UNUSED */ 444 445 PUBLIC char * 446 wedge_of_fname(const char *fname) 447 { 448 struct statvfs vfsbuf; 449 int rv; 450 451 rv = statvfs(fname, &vfsbuf); 452 if (rv) { 453 warn("statvfs: %s", fname); 454 return NULL; 455 } 456 457 return estrdup(vfsbuf.f_mntfromname); 458 } 459 460 PUBLIC int 461 find_partition_idx(const char *fname, int verbose) 462 { 463 struct dkwedge_info dkinfo; 464 struct stat sb; 465 struct statvfs vfsbuf; 466 gpt_t gpt; 467 map_t m; 468 off_t offset; 469 size_t size; 470 const char *parent; 471 char *b, *d; 472 int rv; 473 474 /* the following are for gpt_open() */ 475 off_t mediasz = 0; 476 u_int secsz = 0; 477 time_t timestamp = 0; 478 479 rv = stat(fname, &sb); 480 if (rv == -1) 481 err(EXIT_FAILURE, "stat: %s", fname); 482 483 if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) { 484 parent = fname; 485 offset = 0; 486 size = 0; 487 goto doit; 488 } 489 490 rv = statvfs(fname, &vfsbuf); 491 if (rv == -1) 492 err(EXIT_FAILURE, "statvfs: %s", fname); 493 494 b = basename(vfsbuf.f_mntfromname); 495 d = dirname(vfsbuf.f_mntfromname); 496 497 { 498 char *p; 499 500 easprintf(&p, "%s/r%s", d, b); 501 502 int fd = open(p, O_RDONLY); 503 if (fd == -1) 504 err(EXIT_FAILURE, "open"); 505 506 rv = ioctl(fd, DIOCGWEDGEINFO, &dkinfo); 507 if (rv != -1) { 508 parent = dkinfo.dkw_parent; 509 offset = dkinfo.dkw_offset; 510 size = dkinfo.dkw_size; 511 } 512 else { 513 struct disklabel dl; 514 515 warn("ioctl: DIOCGWEDGEINFO"); 516 517 rv = ioctl(fd, DIOCGDINFO, &dl); 518 if (rv == -1) 519 err(EXIT_FAILURE, "ioctl: DIOCGDINFO"); 520 521 size_t n = strlen(p); 522 523 int pnum = p[n - 1] - 'a'; 524 p[n - 1] = 'd'; 525 526 printf("num_parts: %u\n", dl.d_npartitions); 527 printf("partition %d\n", pnum); 528 printf(" offset = %u (%#x)\n", 529 dl.d_partitions[pnum].p_offset, 530 dl.d_partitions[pnum].p_offset); 531 printf(" size = %u (%#x)\n", 532 dl.d_partitions[pnum].p_size, 533 dl.d_partitions[pnum].p_size); 534 535 parent = p; // vfsbuf.f_mntfromname; 536 offset = dl.d_partitions[pnum].p_offset; 537 size = dl.d_partitions[pnum].p_size; 538 } 539 540 close(fd); 541 free(p); 542 } 543 544 doit: 545 DPRINTF("parent: %s\n", parent); 546 DPRINTF("offset: 0x%lx\n", offset); 547 DPRINTF("size: 0x%lx\n", size); 548 549 gpt = gpt_open(parent, GPT_READONLY, 550 verbose, mediasz, secsz, timestamp); 551 552 if (gpt == NULL) 553 err(EXIT_FAILURE, "gpt_open"); 554 555 if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL) 556 printf("GPT not found, displaying data from MBR.\n"); 557 558 int index = -1; 559 struct map_widths w; 560 if (verbose) { 561 w = get_map_widths(gpt); 562 show_map_banner(w); 563 } 564 for (m = map_first(gpt); m != NULL; m = m->map_next) { 565 if (verbose) 566 show_map(m, w); 567 568 if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1) { 569 continue; 570 } 571 572 if ((off_t)offset == m->map_start && 573 (off_t)size == m->map_size) { 574 if (index != -1) 575 printf("match: %u\n", index); 576 index = (int)m->map_index; 577 } 578 } 579 return index; 580 } 581 582 PUBLIC char * 583 find_partition_pathname(const char *fname) 584 { 585 char *pname; /* partition name */ 586 char *rname; /* real name */ 587 struct statvfs vfsbuf; 588 int i, rv; 589 590 rname = realpath(fname, NULL); 591 592 DPRINTF("fname: %s\n", fname); 593 DPRINTF("rname: %s\n", rname); 594 595 rv = statvfs(rname, &vfsbuf); 596 if (rv) { 597 warn("statvfs: %s", rname); 598 free(rname); 599 return NULL; 600 } 601 602 DPRINTF("mount: %s\n", vfsbuf.f_mntonname); 603 604 i = 0; 605 while (vfsbuf.f_mntonname[i] == rname[i] && vfsbuf.f_mntonname[i] != '\0') 606 i++; 607 608 if (vfsbuf.f_mntonname[i] != '\0') 609 errx(EXIT_FAILURE, "mntonname mismatch: %s", 610 vfsbuf.f_mntonname + i); 611 612 pname = estrdup(rname + i); 613 free(rname); 614 615 return pname; 616 } 617 618 #endif 619
Indexes created Tue Sep 30 17:09:57 GMT 2025