1/*- 2 * Copyright (c) 2002 Marcel Moolenaar 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 * 26 * CRC32 code derived from work by Gary S. Brown. 27 */ 28 29#include <sys/cdefs.h> 30__FBSDID("$FreeBSD: src/sbin/gpt/gpt.c,v 1.16.2.4.6.1 2010/02/10 00:26:20 kensmith Exp $"); 31 32#include <sys/param.h> 33#include <sys/types.h> 34#include <sys/disk.h> 35#include <sys/stat.h> 36 37#include <err.h> 38#include <errno.h> 39#include <fcntl.h> 40#include <paths.h> 41#include <stddef.h> 42#include <stdio.h> 43#include <stdlib.h> 44#include <string.h> 45#include <unistd.h> 46 47#include "map.h" 48#include "gpt.h" 49 50char device_path[MAXPATHLEN]; 51char *device_name; 52 53off_t mediasz; 54 55u_int parts; 56u_int secsz; 57 58int readonly, verbose; 59 60static uint32_t crc32_tab[] = { 61 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 62 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 63 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 64 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 65 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 66 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 67 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 68 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 69 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 70 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 71 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 72 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 73 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 74 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 75 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 76 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 77 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 78 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 79 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 80 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 81 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 82 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 83 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 84 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 85 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 86 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 87 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 88 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 89 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 90 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 91 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 92 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 93 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 94 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 95 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 96 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 97 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 98 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 99 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 100 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 101 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 102 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 103 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 104}; 105 106uint32_t 107crc32(const void *buf, size_t size) 108{ 109 const uint8_t *p; 110 uint32_t crc; 111 112 p = buf; 113 crc = ~0U; 114 115 while (size--) 116 crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); 117 118 return crc ^ ~0U; 119} 120 121uint8_t * 122utf16_to_utf8(uint16_t *s16) 123{ 124 static uint8_t *s8 = NULL; 125 static size_t s8len = 0; 126 size_t s8idx, s16idx, s16len; 127 uint32_t utfchar; 128 unsigned int c; 129 130 s16len = 0; 131 while (s16[s16len++] != 0) 132 ; 133 if (s8len < s16len * 3) { 134 if (s8 != NULL) 135 free(s8); 136 s8len = s16len * 3; 137 s8 = calloc(s16len, 3); 138 } 139 s8idx = s16idx = 0; 140 while (s16idx < s16len) { 141 utfchar = le16toh(s16[s16idx++]); 142 if ((utfchar & 0xf800) == 0xd800) { 143 c = le16toh(s16[s16idx]); 144 if ((utfchar & 0x400) != 0 || (c & 0xfc00) != 0xdc00) 145 utfchar = 0xfffd; 146 else 147 s16idx++; 148 } 149 if (utfchar < 0x80) { 150 s8[s8idx++] = utfchar; 151 } else if (utfchar < 0x800) { 152 s8[s8idx++] = 0xc0 | (utfchar >> 6); 153 s8[s8idx++] = 0x80 | (utfchar & 0x3f); 154 } else if (utfchar < 0x10000) { 155 s8[s8idx++] = 0xe0 | (utfchar >> 12); 156 s8[s8idx++] = 0x80 | ((utfchar >> 6) & 0x3f); 157 s8[s8idx++] = 0x80 | (utfchar & 0x3f); 158 } else if (utfchar < 0x200000) { 159 s8[s8idx++] = 0xf0 | (utfchar >> 18); 160 s8[s8idx++] = 0x80 | ((utfchar >> 12) & 0x3f); 161 s8[s8idx++] = 0x80 | ((utfchar >> 6) & 0x3f); 162 s8[s8idx++] = 0x80 | (utfchar & 0x3f); 163 } 164 } 165 return (s8); 166} 167 168void 169utf8_to_utf16(const uint8_t *s8, uint16_t *s16, size_t s16len) 170{ 171 size_t s16idx, s8idx, s8len; 172 uint32_t utfchar = 0; 173 unsigned int c, utfbytes; 174 175 s8len = 0; 176 while (s8[s8len++] != 0) 177 ; 178 s8idx = s16idx = 0; 179 utfbytes = 0; 180 do { 181 c = s8[s8idx++]; 182 if ((c & 0xc0) != 0x80) { 183 /* Initial characters. */ 184 if (utfbytes != 0) { 185 /* Incomplete encoding. */ 186 s16[s16idx++] = htole16(0xfffd); 187 if (s16idx == s16len) { 188 s16[--s16idx] = 0; 189 return; 190 } 191 } 192 if ((c & 0xf8) == 0xf0) { 193 utfchar = c & 0x07; 194 utfbytes = 3; 195 } else if ((c & 0xf0) == 0xe0) { 196 utfchar = c & 0x0f; 197 utfbytes = 2; 198 } else if ((c & 0xe0) == 0xc0) { 199 utfchar = c & 0x1f; 200 utfbytes = 1; 201 } else { 202 utfchar = c & 0x7f; 203 utfbytes = 0; 204 } 205 } else { 206 /* Followup characters. */ 207 if (utfbytes > 0) { 208 utfchar = (utfchar << 6) + (c & 0x3f); 209 utfbytes--; 210 } else if (utfbytes == 0) 211 utfbytes = -1; 212 } 213 if (utfbytes == 0) { 214 if (utfchar >= 0x10000 && s16idx + 2 >= s16len) 215 utfchar = 0xfffd; 216 if (utfchar >= 0x10000) { 217 s16[s16idx++] = htole16(0xd800 | ((utfchar>>10)-0x40)); 218 s16[s16idx++] = htole16(0xdc00 | (utfchar & 0x3ff)); 219 } else 220 s16[s16idx++] = htole16(utfchar); 221 if (s16idx == s16len) { 222 s16[--s16idx] = 0; 223 return; 224 } 225 } 226 } while (c != 0); 227} 228 229void 230le_uuid_dec(void const *buf, uuid_t *uuid) 231{ 232#ifdef __APPLE__ 233 *((uint32_t *)uuid + 0) = OSSwapInt32(*((uint32_t *)buf + 0)); 234 *((uint16_t *)uuid + 2) = OSSwapInt16(*((uint16_t *)buf + 2)); 235 *((uint16_t *)uuid + 3) = OSSwapInt16(*((uint16_t *)buf + 3)); 236 *((uint64_t *)uuid + 1) = (*((uint64_t *)buf + 1)); 237#else 238 u_char const *p; 239 int i; 240 241 p = buf; 242 uuid->time_low = le32dec(p); 243 uuid->time_mid = le16dec(p + 4); 244 uuid->time_hi_and_version = le16dec(p + 6); 245 uuid->clock_seq_hi_and_reserved = p[8]; 246 uuid->clock_seq_low = p[9]; 247 for (i = 0; i < _UUID_NODE_LEN; i++) 248 uuid->node[i] = p[10 + i]; 249#endif 250} 251 252void 253le_uuid_enc(void *buf, uuid_t const *uuid) 254{ 255#ifdef __APPLE__ 256 *((uint32_t *)buf + 0) = OSSwapInt32(*((uint32_t *)uuid + 0)); 257 *((uint16_t *)buf + 2) = OSSwapInt16(*((uint16_t *)uuid + 2)); 258 *((uint16_t *)buf + 3) = OSSwapInt16(*((uint16_t *)uuid + 3)); 259 *((uint64_t *)buf + 1) = (*((uint64_t *)uuid + 1)); 260#else 261 u_char *p; 262 int i; 263 264 p = buf; 265 le32enc(p, uuid->time_low); 266 le16enc(p + 4, uuid->time_mid); 267 le16enc(p + 6, uuid->time_hi_and_version); 268 p[8] = uuid->clock_seq_hi_and_reserved; 269 p[9] = uuid->clock_seq_low; 270 for (i = 0; i < _UUID_NODE_LEN; i++) 271 p[10 + i] = uuid->node[i]; 272#endif 273} 274 275int 276parse_uuid(const char *s, uuid_t *uuid) 277{ 278#ifdef __APPLE__ 279 int status; 280 281 status = uuid_parse(s, *uuid); 282 if (status == 0) 283 return (0); 284 285 switch (*s) { 286 case 'e': 287 if (strcmp(s, "efi") == 0) { 288 uuid_copy(*uuid, GPT_ENT_TYPE_EFI); 289 return (0); 290 } 291 break; 292 case 'h': 293 if (strcmp(s, "hfs") == 0) { 294 uuid_copy(*uuid, GPT_ENT_TYPE_APPLE_HFS); 295 return (0); 296 } 297 break; 298 case 'l': 299 if (strcmp(s, "linux") == 0) { 300 uuid_copy(*uuid, GPT_ENT_TYPE_MS_BASIC_DATA); 301 return (0); 302 } 303 break; 304 case 'w': 305 if (strcmp(s, "windows") == 0) { 306 uuid_copy(*uuid, GPT_ENT_TYPE_MS_BASIC_DATA); 307 return (0); 308 } 309 break; 310 } 311 return (EINVAL); 312#else 313 uint32_t status; 314 315 uuid_from_string(s, uuid, &status); 316 if (status == uuid_s_ok) 317 return (0); 318 319 switch (*s) { 320 case 'b': 321 if (strcmp(s, "boot") == 0) { 322 uuid_t boot = GPT_ENT_TYPE_FREEBSD_BOOT; 323 *uuid = boot; 324 return (0); 325 } 326 break; 327 case 'e': 328 if (strcmp(s, "efi") == 0) { 329 uuid_t efi = GPT_ENT_TYPE_EFI; 330 *uuid = efi; 331 return (0); 332 } 333 break; 334 case 'h': 335 if (strcmp(s, "hfs") == 0) { 336 uuid_t hfs = GPT_ENT_TYPE_APPLE_HFS; 337 *uuid = hfs; 338 return (0); 339 } 340 break; 341 case 'l': 342 if (strcmp(s, "linux") == 0) { 343 uuid_t lnx = GPT_ENT_TYPE_MS_BASIC_DATA; 344 *uuid = lnx; 345 return (0); 346 } 347 break; 348 case 's': 349 if (strcmp(s, "swap") == 0) { 350 uuid_t sw = GPT_ENT_TYPE_FREEBSD_SWAP; 351 *uuid = sw; 352 return (0); 353 } 354 break; 355 case 'u': 356 if (strcmp(s, "ufs") == 0) { 357 uuid_t ufs = GPT_ENT_TYPE_FREEBSD_UFS; 358 *uuid = ufs; 359 return (0); 360 } 361 break; 362 case 'w': 363 if (strcmp(s, "windows") == 0) { 364 uuid_t win = GPT_ENT_TYPE_MS_BASIC_DATA; 365 *uuid = win; 366 return (0); 367 } 368 break; 369 case 'z': 370 if (strcmp(s, "zfs") == 0) { 371 uuid_t zfs = GPT_ENT_TYPE_FREEBSD_ZFS; 372 *uuid = zfs; 373 return (0); 374 } 375 break; 376 } 377 return (EINVAL); 378#endif 379} 380 381void* 382gpt_read(int fd, off_t lba, size_t count) 383{ 384 off_t ofs; 385 void *buf; 386 387 count *= secsz; 388 buf = malloc(count); 389 if (buf == NULL) 390 return (NULL); 391 392 ofs = lba * secsz; 393 if (lseek(fd, ofs, SEEK_SET) == ofs && 394 read(fd, buf, count) == (ssize_t)count) 395 return (buf); 396 397 free(buf); 398 return (NULL); 399} 400 401int 402gpt_write(int fd, map_t *map) 403{ 404 off_t ofs; 405 size_t count; 406 407 count = map->map_size * secsz; 408 ofs = map->map_start * secsz; 409 if (lseek(fd, ofs, SEEK_SET) == ofs && 410 write(fd, map->map_data, count) == (ssize_t)count) 411 return (0); 412 return (-1); 413} 414 415static int 416gpt_mbr(int fd, off_t lba) 417{ 418 struct mbr *mbr; 419 map_t *m, *p; 420 off_t size, start; 421 unsigned int i, pmbr; 422 423 mbr = gpt_read(fd, lba, 1); 424 if (mbr == NULL) 425 return (-1); 426 427 if (mbr->mbr_sig != htole16(MBR_SIG)) { 428 if (verbose) 429 warnx("%s: MBR not found at sector %llu", device_name, 430 (long long)lba); 431 free(mbr); 432 return (0); 433 } 434 435 /* 436 * Differentiate between a regular MBR and a PMBR. This is more 437 * convenient in general. A PMBR is one with a single partition 438 * of type 0xee. 439 */ 440 pmbr = 0; 441 for (i = 0; i < 4; i++) { 442 if (mbr->mbr_part[i].part_typ == 0) 443 continue; 444 if (mbr->mbr_part[i].part_typ == 0xee) 445 pmbr++; 446 else 447 break; 448 } 449 if (pmbr && i == 4 && lba == 0) { 450 if (pmbr != 1) 451 warnx("%s: Suspicious PMBR at sector %llu", 452 device_name, (long long)lba); 453 else if (verbose > 1) 454 warnx("%s: PMBR at sector %llu", device_name, 455 (long long)lba); 456 p = map_add(lba, 1LL, MAP_TYPE_PMBR, mbr); 457 return ((p == NULL) ? -1 : 0); 458 } 459 if (pmbr) 460 warnx("%s: Suspicious MBR at sector %llu", device_name, 461 (long long)lba); 462 else if (verbose > 1) 463 warnx("%s: MBR at sector %llu", device_name, (long long)lba); 464 465 p = map_add(lba, 1LL, MAP_TYPE_MBR, mbr); 466 if (p == NULL) 467 return (-1); 468 for (i = 0; i < 4; i++) { 469 if (mbr->mbr_part[i].part_typ == 0 || 470 mbr->mbr_part[i].part_typ == 0xee) 471 continue; 472 start = le16toh(mbr->mbr_part[i].part_start_hi); 473 start = (start << 16) + le16toh(mbr->mbr_part[i].part_start_lo); 474 size = le16toh(mbr->mbr_part[i].part_size_hi); 475 size = (size << 16) + le16toh(mbr->mbr_part[i].part_size_lo); 476 if (start == 0 && size == 0) { 477 warnx("%s: Malformed MBR at sector %llu", device_name, 478 (long long)lba); 479 continue; 480 } 481 /* start is relative to the offset of the MBR itself. */ 482 start += lba; 483 if (verbose > 2) 484 warnx("%s: MBR part: type=%d, start=%llu, size=%llu", 485 device_name, mbr->mbr_part[i].part_typ, 486 (long long)start, (long long)size); 487 if (mbr->mbr_part[i].part_typ != 15) { 488 m = map_add(start, size, MAP_TYPE_MBR_PART, p); 489 if (m == NULL) 490 return (-1); 491 m->map_index = i + 1; 492 } else { 493 if (gpt_mbr(fd, start) == -1) 494 return (-1); 495 } 496 } 497 return (0); 498} 499 500static int 501gpt_gpt(int fd, off_t lba) 502{ 503 uuid_t type; 504 off_t size; 505 struct gpt_ent *ent; 506 struct gpt_hdr *hdr; 507 char *p, *s; 508 map_t *m; 509 size_t blocks, tblsz; 510 unsigned int i; 511 uint32_t crc; 512 513 hdr = gpt_read(fd, lba, 1); 514 if (hdr == NULL) 515 return (-1); 516 517 if (memcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig))) 518 goto fail_hdr; 519 520 crc = le32toh(hdr->hdr_crc_self); 521 hdr->hdr_crc_self = 0; 522 if (crc32(hdr, le32toh(hdr->hdr_size)) != crc) { 523 if (verbose) 524 warnx("%s: Bad CRC in GPT header at sector %llu", 525 device_name, (long long)lba); 526 goto fail_hdr; 527 } 528 529 tblsz = le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz); 530 blocks = tblsz / secsz + ((tblsz % secsz) ? 1 : 0); 531 532 /* Use generic pointer to deal with hdr->hdr_entsz != sizeof(*ent). */ 533 p = gpt_read(fd, le64toh(hdr->hdr_lba_table), blocks); 534 if (p == NULL) 535 return (-1); 536 537 if (crc32(p, tblsz) != le32toh(hdr->hdr_crc_table)) { 538 if (verbose) 539 warnx("%s: Bad CRC in GPT table at sector %llu", 540 device_name, 541 (long long)le64toh(hdr->hdr_lba_table)); 542 goto fail_ent; 543 } 544 545 if (verbose > 1) 546 warnx("%s: %s GPT at sector %llu", device_name, 547 (lba == 1) ? "Pri" : "Sec", (long long)lba); 548 549 m = map_add(lba, 1, (lba == 1) 550 ? MAP_TYPE_PRI_GPT_HDR : MAP_TYPE_SEC_GPT_HDR, hdr); 551 if (m == NULL) 552 return (-1); 553 554 m = map_add(le64toh(hdr->hdr_lba_table), blocks, (lba == 1) 555 ? MAP_TYPE_PRI_GPT_TBL : MAP_TYPE_SEC_GPT_TBL, p); 556 if (m == NULL) 557 return (-1); 558 559 if (lba != 1) 560 return (0); 561 562 for (i = 0; i < le32toh(hdr->hdr_entries); i++) { 563 ent = (void*)(p + i * le32toh(hdr->hdr_entsz)); 564 if (uuid_is_nil(&ent->ent_type, NULL)) 565 continue; 566 567 size = le64toh(ent->ent_lba_end) - le64toh(ent->ent_lba_start) + 568 1LL; 569 if (verbose > 2) { 570 le_uuid_dec(&ent->ent_type, &type); 571 uuid_to_string(&type, &s, NULL); 572 warnx( 573 "%s: GPT partition: type=%s, start=%llu, size=%llu", device_name, s, 574 (long long)le64toh(ent->ent_lba_start), 575 (long long)size); 576 free(s); 577 } 578 m = map_add(le64toh(ent->ent_lba_start), size, 579 MAP_TYPE_GPT_PART, ent); 580 if (m == NULL) 581 return (-1); 582 m->map_index = i + 1; 583 } 584 return (0); 585 586 fail_ent: 587 free(p); 588 589 fail_hdr: 590 free(hdr); 591 return (0); 592} 593 594int 595gpt_open(const char *dev) 596{ 597 struct stat sb; 598 int fd, mode; 599 600 mode = readonly ? O_RDONLY : O_RDWR|O_EXCL; 601 602 strlcpy(device_path, dev, sizeof(device_path)); 603 device_name = device_path; 604 605 if ((fd = open(device_path, mode)) != -1) 606 goto found; 607 608 if (strncmp(dev, _PATH_DEV, strlen(_PATH_DEV)) == 0) 609 return (-1); 610 611 snprintf(device_path, sizeof(device_path), "%s%s", _PATH_DEV, dev); 612 device_name = device_path + strlen(_PATH_DEV); 613 if ((fd = open(device_path, mode)) != -1) 614 goto found; 615 616 return (-1); 617 618 found: 619 if (fstat(fd, &sb) == -1) 620 goto close; 621 622 if ((sb.st_mode & S_IFMT) != S_IFREG) { 623#ifdef __APPLE__ 624 if (ioctl(fd, DKIOCGETBLOCKSIZE, &secsz) == -1 || 625 ioctl(fd, DKIOCGETBLOCKCOUNT, &mediasz) == -1) 626 goto close; 627 mediasz *= secsz; 628#else 629 if (ioctl(fd, DIOCGSECTORSIZE, &secsz) == -1 || 630 ioctl(fd, DIOCGMEDIASIZE, &mediasz) == -1) 631 goto close; 632#endif 633 } else { 634 secsz = 512; /* Fixed size for files. */ 635 if (sb.st_size % secsz) { 636 errno = EINVAL; 637 goto close; 638 } 639 mediasz = sb.st_size; 640 } 641 642 /* 643 * We require an absolute minimum of 6 sectors. One for the MBR, 644 * 2 for the GPT header, 2 for the GPT table and one to hold some 645 * user data. Let's catch this extreme border case here so that 646 * we don't have to worry about it later. 647 */ 648 if (mediasz / secsz < 6) { 649 errno = ENODEV; 650 goto close; 651 } 652 653 if (verbose) 654 warnx("%s: mediasize=%llu; sectorsize=%u; blocks=%llu", 655 device_name, (long long)mediasz, secsz, 656 (long long)(mediasz / secsz)); 657 658 map_init(mediasz / secsz); 659 660 if (gpt_mbr(fd, 0LL) == -1) 661 goto close; 662 663#ifdef __APPLE__ 664 if (gpt_gpt(fd, 1LL) == -1) 665 goto close; 666 if (gpt_gpt(fd, mediasz / secsz - 1LL) == -1) 667 goto close; 668#else 669 /* 670 * Don't look for a GPT unless we have a valid PMBR. 671 */ 672 if (map_find(MAP_TYPE_PMBR) != NULL) { 673 if (gpt_gpt(fd, 1LL) == -1) 674 goto close; 675 if (gpt_gpt(fd, mediasz / secsz - 1LL) == -1) 676 goto close; 677 } 678#endif 679 680 return (fd); 681 682 close: 683 close(fd); 684 return (-1); 685} 686 687void 688gpt_close(int fd) 689{ 690 /* XXX post processing? */ 691 close(fd); 692} 693 694static struct { 695 int (*fptr)(int, char *[]); 696 const char *name; 697} cmdsw[] = { 698 { cmd_add, "add" }, 699#ifdef __APPLE__ 700 { NULL, "boot" }, 701#else 702 { cmd_boot, "boot" }, 703#endif 704 { cmd_create, "create" }, 705 { cmd_destroy, "destroy" }, 706 { NULL, "help" }, 707 { cmd_label, "label" }, 708#ifdef __APPLE__ 709 { NULL, "migrate" }, 710#else 711 { cmd_migrate, "migrate" }, 712#endif 713 { cmd_recover, "recover" }, 714 { cmd_remove, "remove" }, 715 { NULL, "rename" }, 716 { cmd_show, "show" }, 717 { NULL, "verify" }, 718 { NULL, NULL } 719}; 720 721static void 722usage(void) 723{ 724 725 fprintf(stderr, 726 "usage: %s [-rv] [-p nparts] command [options] device ...\n", 727 getprogname()); 728 exit(1); 729} 730 731static void 732prefix(const char *cmd) 733{ 734 char *pfx; 735 const char *prg; 736 737 prg = getprogname(); 738 pfx = malloc(strlen(prg) + strlen(cmd) + 2); 739 /* Don't bother failing. It's not important */ 740 if (pfx == NULL) 741 return; 742 743 snprintf(pfx, strlen(prg) + strlen(cmd) + 2, "%s %s", prg, cmd); 744 setprogname(pfx); 745} 746 747int 748main(int argc, char *argv[]) 749{ 750 char *cmd, *p; 751 int ch, i; 752 753 /* Get the generic options */ 754 while ((ch = getopt(argc, argv, "p:rv")) != -1) { 755 switch(ch) { 756 case 'p': 757 if (parts > 0) 758 usage(); 759 parts = strtol(optarg, &p, 10); 760 if (*p != 0 || parts < 1) 761 usage(); 762 break; 763 case 'r': 764 readonly = 1; 765 break; 766 case 'v': 767 verbose++; 768 break; 769 default: 770 usage(); 771 } 772 } 773 if (!parts) 774 parts = 128; 775 776 if (argc == optind) 777 usage(); 778 779 cmd = argv[optind++]; 780 for (i = 0; cmdsw[i].name != NULL && strcmp(cmd, cmdsw[i].name); i++); 781 782 if (cmdsw[i].fptr == NULL) 783 errx(1, "unknown command: %s", cmd); 784 785 prefix(cmd); 786 return ((*cmdsw[i].fptr)(argc, argv)); 787} 788