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 * $DragonFly: src/sbin/gpt/gpt.c,v 1.5 2008/07/30 00:45:26 dillon Exp $ 30 */ 31 32 #include <sys/param.h> 33 #include <sys/types.h> 34 #include <sys/stat.h> 35 #include <sys/diskslice.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 50 char device_path[MAXPATHLEN]; 51 char *device_name; 52 53 off_t mediasz; 54 55 u_int parts; 56 u_int secsz; 57 58 int readonly, verbose; 59 60 static 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 106 uint32_t 107 crc32(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 121 uint8_t * 122 utf16_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 168 void 169 utf8_to_utf16(const uint8_t *s8, uint16_t *s16, size_t s16len) 170 { 171 size_t s16idx, s8idx, s8len; 172 uint32_t utfchar; 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 utfchar = 0; 182 c = s8[s8idx++]; 183 if ((c & 0xc0) != 0x80) { 184 /* Initial characters. */ 185 if (utfbytes != 0) { 186 /* Incomplete encoding. */ 187 s16[s16idx++] = 0xfffd; 188 if (s16idx == s16len) { 189 s16[--s16idx] = 0; 190 return; 191 } 192 } 193 if ((c & 0xf8) == 0xf0) { 194 utfchar = c & 0x07; 195 utfbytes = 3; 196 } else if ((c & 0xf0) == 0xe0) { 197 utfchar = c & 0x0f; 198 utfbytes = 2; 199 } else if ((c & 0xe0) == 0xc0) { 200 utfchar = c & 0x1f; 201 utfbytes = 1; 202 } else { 203 utfchar = c & 0x7f; 204 utfbytes = 0; 205 } 206 } else { 207 /* Followup characters. */ 208 if (utfbytes > 0) { 209 utfchar = (utfchar << 6) + (c & 0x3f); 210 utfbytes--; 211 } else if (utfbytes == 0) 212 utfbytes = -1; 213 } 214 if (utfbytes == 0) { 215 if (utfchar >= 0x10000 && s16idx + 2 >= s16len) 216 utfchar = 0xfffd; 217 if (utfchar >= 0x10000) { 218 s16[s16idx++] = 0xd800 | ((utfchar>>10)-0x40); 219 s16[s16idx++] = 0xdc00 | (utfchar & 0x3ff); 220 } else 221 s16[s16idx++] = utfchar; 222 if (s16idx == s16len) { 223 s16[--s16idx] = 0; 224 return; 225 } 226 } 227 } while (c != 0); 228 } 229 230 void 231 le_uuid_dec(void const *buf, uuid_t *uuid) 232 { 233 u_char const *p; 234 int i; 235 236 p = buf; 237 uuid->time_low = le32dec(p); 238 uuid->time_mid = le16dec(p + 4); 239 uuid->time_hi_and_version = le16dec(p + 6); 240 uuid->clock_seq_hi_and_reserved = p[8]; 241 uuid->clock_seq_low = p[9]; 242 for (i = 0; i < _UUID_NODE_LEN; i++) 243 uuid->node[i] = p[10 + i]; 244 } 245 246 void 247 le_uuid_enc(void *buf, uuid_t const *uuid) 248 { 249 u_char *p; 250 int i; 251 252 p = buf; 253 le32enc(p, uuid->time_low); 254 le16enc(p + 4, uuid->time_mid); 255 le16enc(p + 6, uuid->time_hi_and_version); 256 p[8] = uuid->clock_seq_hi_and_reserved; 257 p[9] = uuid->clock_seq_low; 258 for (i = 0; i < _UUID_NODE_LEN; i++) 259 p[10 + i] = uuid->node[i]; 260 } 261 262 int 263 parse_uuid(const char *s, uuid_t *uuid) 264 { 265 uint32_t status; 266 uuid_t tmp; 267 268 uuid_from_string(s, uuid, &status); 269 if (status == uuid_s_ok) 270 return (0); 271 272 switch (*s) { 273 case 'd': 274 if (strcmp(s, "dfly") == 0 || strcmp(s, "dragonfly") == 0) { 275 s = "DragonFly Label64"; 276 /* fall through to lookup at end */ 277 } 278 break; 279 case 'e': 280 if (strcmp(s, "efi") == 0) { 281 uuid_t efi = GPT_ENT_TYPE_EFI; 282 *uuid = efi; 283 return (0); 284 } 285 break; 286 case 'h': 287 if (strcmp(s, "hammer2") == 0) { 288 uuid_t hammer2 = GPT_ENT_TYPE_DRAGONFLY_HAMMER2; 289 *uuid = hammer2; 290 return (0); 291 } 292 if (strcmp(s, "hammer") == 0) { 293 uuid_t hammer = GPT_ENT_TYPE_DRAGONFLY_HAMMER; 294 *uuid = hammer; 295 return (0); 296 } 297 if (strcmp(s, "hfs") == 0) { 298 uuid_t hfs = GPT_ENT_TYPE_APPLE_HFS; 299 *uuid = hfs; 300 return (0); 301 } 302 break; 303 case 'l': 304 if (strcmp(s, "linux") == 0) { 305 uuid_t lnx = GPT_ENT_TYPE_MS_BASIC_DATA; 306 *uuid = lnx; 307 return (0); 308 } 309 break; 310 case 's': 311 if (strcmp(s, "swap") == 0) { 312 uuid_t sw = GPT_ENT_TYPE_FREEBSD_SWAP; 313 *uuid = sw; 314 return (0); 315 } 316 break; 317 case 'u': 318 if (strcmp(s, "ufs") == 0) { 319 uuid_t ufs = GPT_ENT_TYPE_FREEBSD_UFS; 320 *uuid = ufs; 321 return (0); 322 } 323 break; 324 case 'w': 325 if (strcmp(s, "windows") == 0) { 326 uuid_t win = GPT_ENT_TYPE_MS_BASIC_DATA; 327 *uuid = win; 328 return (0); 329 } 330 break; 331 } 332 333 uuid_name_lookup(&tmp, s, &status); 334 if (status == uuid_s_ok) { 335 *uuid = tmp; 336 return(0); 337 } 338 339 return (EINVAL); 340 } 341 342 void* 343 gpt_read(int fd, off_t lba, size_t count) 344 { 345 off_t ofs; 346 void *buf; 347 348 count *= secsz; 349 buf = malloc(count); 350 if (buf == NULL) 351 return (NULL); 352 353 ofs = lba * secsz; 354 if (lseek(fd, ofs, SEEK_SET) == ofs && 355 read(fd, buf, count) == (ssize_t)count) 356 return (buf); 357 358 free(buf); 359 return (NULL); 360 } 361 362 int 363 gpt_write(int fd, map_t *map) 364 { 365 off_t ofs; 366 size_t count; 367 368 count = map->map_size * secsz; 369 ofs = map->map_start * secsz; 370 if (lseek(fd, ofs, SEEK_SET) == ofs && 371 write(fd, map->map_data, count) == (ssize_t)count) 372 return (0); 373 return (-1); 374 } 375 376 static int 377 gpt_mbr(int fd, off_t lba) 378 { 379 struct mbr *mbr; 380 map_t *m, *p; 381 off_t size, start; 382 unsigned int i, pmbr; 383 384 mbr = gpt_read(fd, lba, 1); 385 if (mbr == NULL) 386 return (-1); 387 388 if (mbr->mbr_sig != htole16(MBR_SIG)) { 389 if (verbose) 390 warnx("%s: MBR not found at sector %llu", device_name, 391 (long long)lba); 392 free(mbr); 393 return (0); 394 } 395 396 /* 397 * Differentiate between a regular MBR and a PMBR. This is more 398 * convenient in general. A PMBR is one with a single partition 399 * of type 0xee. 400 */ 401 pmbr = 0; 402 for (i = 0; i < 4; i++) { 403 if (mbr->mbr_part[i].part_typ == 0) 404 continue; 405 if (mbr->mbr_part[i].part_typ == 0xee) 406 pmbr++; 407 else 408 break; 409 } 410 if (pmbr && (i == 1 || i == 4) && lba == 0) { 411 if (pmbr != 1) 412 warnx("%s: Suspicious PMBR at sector %llu", 413 device_name, (long long)lba); 414 else if (verbose > 1) 415 warnx("%s: PMBR at sector %llu", device_name, 416 (long long)lba); 417 p = map_add(lba, 1LL, MAP_TYPE_PMBR, mbr); 418 return ((p == NULL) ? -1 : 0); 419 } 420 if (pmbr) 421 warnx("%s: Suspicious MBR at sector %llu", device_name, 422 (long long)lba); 423 else if (verbose > 1) 424 warnx("%s: MBR at sector %llu", device_name, (long long)lba); 425 426 p = map_add(lba, 1LL, MAP_TYPE_MBR, mbr); 427 if (p == NULL) 428 return (-1); 429 for (i = 0; i < 4; i++) { 430 if (mbr->mbr_part[i].part_typ == 0 || 431 mbr->mbr_part[i].part_typ == 0xee) 432 continue; 433 start = le16toh(mbr->mbr_part[i].part_start_hi); 434 start = (start << 16) + le16toh(mbr->mbr_part[i].part_start_lo); 435 size = le16toh(mbr->mbr_part[i].part_size_hi); 436 size = (size << 16) + le16toh(mbr->mbr_part[i].part_size_lo); 437 if (start == 0 && size == 0) { 438 warnx("%s: Malformed MBR at sector %llu", device_name, 439 (long long)lba); 440 continue; 441 } 442 /* start is relative to the offset of the MBR itself. */ 443 start += lba; 444 if (verbose > 2) 445 warnx("%s: MBR part: type=%d, start=%llu, size=%llu", 446 device_name, mbr->mbr_part[i].part_typ, 447 (long long)start, (long long)size); 448 if (mbr->mbr_part[i].part_typ != 15) { 449 m = map_add(start, size, MAP_TYPE_MBR_PART, p); 450 if (m == NULL) 451 return (-1); 452 m->map_index = i; 453 } else { 454 if (gpt_mbr(fd, start) == -1) 455 return (-1); 456 } 457 } 458 return (0); 459 } 460 461 static int 462 gpt_gpt(int fd, off_t lba) 463 { 464 uuid_t type; 465 off_t size; 466 struct gpt_ent *ent; 467 struct gpt_hdr *hdr; 468 char *p, *s; 469 map_t *m; 470 size_t blocks, tblsz; 471 unsigned int i; 472 uint32_t crc; 473 474 hdr = gpt_read(fd, lba, 1); 475 if (hdr == NULL) 476 return (-1); 477 478 if (memcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig))) 479 goto fail_hdr; 480 481 crc = le32toh(hdr->hdr_crc_self); 482 hdr->hdr_crc_self = 0; 483 if (crc32(hdr, le32toh(hdr->hdr_size)) != crc) { 484 if (verbose) 485 warnx("%s: Bad CRC in GPT header at sector %llu", 486 device_name, (long long)lba); 487 goto fail_hdr; 488 } 489 490 tblsz = le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz); 491 blocks = tblsz / secsz + ((tblsz % secsz) ? 1 : 0); 492 493 /* Use generic pointer to deal with hdr->hdr_entsz != sizeof(*ent). */ 494 p = gpt_read(fd, le64toh(hdr->hdr_lba_table), blocks); 495 if (p == NULL) 496 return (-1); 497 498 if (crc32(p, tblsz) != le32toh(hdr->hdr_crc_table)) { 499 if (verbose) 500 warnx("%s: Bad CRC in GPT table at sector %llu", 501 device_name, 502 (long long)le64toh(hdr->hdr_lba_table)); 503 goto fail_ent; 504 } 505 506 if (verbose > 1) 507 warnx("%s: %s GPT at sector %llu", device_name, 508 (lba == 1) ? "Pri" : "Sec", (long long)lba); 509 510 m = map_add(lba, 1, (lba == 1) 511 ? MAP_TYPE_PRI_GPT_HDR : MAP_TYPE_SEC_GPT_HDR, hdr); 512 if (m == NULL) 513 return (-1); 514 515 m = map_add(le64toh(hdr->hdr_lba_table), blocks, (lba == 1) 516 ? MAP_TYPE_PRI_GPT_TBL : MAP_TYPE_SEC_GPT_TBL, p); 517 if (m == NULL) 518 return (-1); 519 520 if (lba != 1) 521 return (0); 522 523 for (i = 0; i < le32toh(hdr->hdr_entries); i++) { 524 ent = (void*)(p + i * le32toh(hdr->hdr_entsz)); 525 if (uuid_is_nil(&ent->ent_type, NULL)) 526 continue; 527 528 size = le64toh(ent->ent_lba_end) - le64toh(ent->ent_lba_start) + 529 1LL; 530 if (verbose > 2) { 531 le_uuid_dec(&ent->ent_type, &type); 532 uuid_to_string(&type, &s, NULL); 533 warnx( 534 "%s: GPT partition: type=%s, start=%llu, size=%llu", device_name, s, 535 (long long)le64toh(ent->ent_lba_start), 536 (long long)size); 537 free(s); 538 } 539 m = map_add(le64toh(ent->ent_lba_start), size, 540 MAP_TYPE_GPT_PART, ent); 541 if (m == NULL) 542 return (-1); 543 m->map_index = i; 544 } 545 return (0); 546 547 fail_ent: 548 free(p); 549 550 fail_hdr: 551 free(hdr); 552 return (0); 553 } 554 555 int 556 gpt_open(const char *dev) 557 { 558 struct stat sb; 559 int fd, mode; 560 561 mode = readonly ? O_RDONLY : O_RDWR|O_EXCL; 562 563 strlcpy(device_path, dev, sizeof(device_path)); 564 device_name = device_path; 565 566 if ((fd = open(device_path, mode)) != -1) 567 goto found; 568 569 snprintf(device_path, sizeof(device_path), "%s%s", _PATH_DEV, dev); 570 device_name = device_path + strlen(_PATH_DEV); 571 if ((fd = open(device_path, mode)) != -1) 572 goto found; 573 574 return (-1); 575 576 found: 577 if (fstat(fd, &sb) == -1) 578 goto close; 579 580 if ((sb.st_mode & S_IFMT) != S_IFREG) { 581 struct partinfo partinfo; 582 583 if (ioctl(fd, DIOCGPART, &partinfo) < 0) 584 goto close; 585 secsz = partinfo.media_blksize; 586 mediasz = partinfo.media_size; 587 } else { 588 secsz = 512; /* Fixed size for files. */ 589 if (sb.st_size % secsz) { 590 errno = EINVAL; 591 goto close; 592 } 593 mediasz = sb.st_size; 594 } 595 596 /* 597 * We require an absolute minimum of 6 sectors. One for the MBR, 598 * 2 for the GPT header, 2 for the GPT table and one to hold some 599 * user data. Let's catch this extreme border case here so that 600 * we don't have to worry about it later. 601 */ 602 if (mediasz / secsz < 6) { 603 errno = ENODEV; 604 goto close; 605 } 606 607 if (verbose) 608 warnx("%s: mediasize=%llu; sectorsize=%u; blocks=%llu", 609 device_name, (long long)mediasz, secsz, 610 (long long)(mediasz / secsz)); 611 612 map_init(mediasz / secsz); 613 614 if (gpt_mbr(fd, 0LL) == -1) 615 goto close; 616 if (gpt_gpt(fd, 1LL) == -1) 617 goto close; 618 if (gpt_gpt(fd, mediasz / secsz - 1LL) == -1) 619 goto close; 620 621 return (fd); 622 623 close: 624 close(fd); 625 return (-1); 626 } 627 628 void 629 gpt_close(int fd) 630 { 631 /* XXX post processing? */ 632 close(fd); 633 } 634 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_label, "label" }, 645 { cmd_migrate, "migrate" }, 646 { cmd_recover, "recover" }, 647 { cmd_remove, "remove" }, 648 { NULL, "rename" }, 649 { cmd_show, "show" }, 650 { NULL, "verify" }, 651 { NULL, NULL } 652 }; 653 654 static void 655 usage(void) 656 { 657 const char *prgname = getprogname(); 658 659 fprintf(stderr, 660 "usage: %s [-rv] [-p nparts] <command> [options] <device> ...\n" 661 " %s show <device>\n", 662 prgname, prgname); 663 exit(1); 664 } 665 666 static void 667 prefix(const char *cmd) 668 { 669 char *pfx; 670 const char *prg; 671 672 prg = getprogname(); 673 pfx = malloc(strlen(prg) + strlen(cmd) + 2); 674 /* Don't bother failing. It's not important */ 675 if (pfx == NULL) 676 return; 677 678 sprintf(pfx, "%s %s", prg, cmd); 679 setprogname(pfx); 680 } 681 682 int 683 main(int argc, char *argv[]) 684 { 685 char *cmd, *p; 686 int ch, i; 687 688 /* Get the generic options */ 689 while ((ch = getopt(argc, argv, "p:rv")) != -1) { 690 switch(ch) { 691 case 'p': 692 if (parts > 0) 693 usage(); 694 parts = strtol(optarg, &p, 10); 695 if (*p != 0 || parts < 1) 696 usage(); 697 break; 698 case 'r': 699 readonly = 1; 700 break; 701 case 'v': 702 verbose++; 703 break; 704 default: 705 usage(); 706 } 707 } 708 if (!parts) 709 parts = 128; 710 711 if (argc == optind) 712 usage(); 713 714 cmd = argv[optind++]; 715 for (i = 0; cmdsw[i].name != NULL && strcmp(cmd, cmdsw[i].name); i++); 716 717 if (cmdsw[i].fptr == NULL) 718 errx(1, "unknown command: %s", cmd); 719 720 prefix(cmd); 721 return ((*cmdsw[i].fptr)(argc, argv)); 722 } 723