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