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