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, "hfs") == 0) { 288 uuid_t hfs = GPT_ENT_TYPE_APPLE_HFS; 289 *uuid = hfs; 290 return (0); 291 } 292 break; 293 case 'l': 294 if (strcmp(s, "linux") == 0) { 295 uuid_t lnx = GPT_ENT_TYPE_MS_BASIC_DATA; 296 *uuid = lnx; 297 return (0); 298 } 299 break; 300 case 's': 301 if (strcmp(s, "swap") == 0) { 302 uuid_t sw = GPT_ENT_TYPE_FREEBSD_SWAP; 303 *uuid = sw; 304 return (0); 305 } 306 break; 307 case 'u': 308 if (strcmp(s, "ufs") == 0) { 309 uuid_t ufs = GPT_ENT_TYPE_FREEBSD_UFS; 310 *uuid = ufs; 311 return (0); 312 } 313 break; 314 case 'w': 315 if (strcmp(s, "windows") == 0) { 316 uuid_t win = GPT_ENT_TYPE_MS_BASIC_DATA; 317 *uuid = win; 318 return (0); 319 } 320 break; 321 } 322 323 uuid_name_lookup(&tmp, s, &status); 324 if (status == uuid_s_ok) { 325 *uuid = tmp; 326 return(0); 327 } 328 329 return (EINVAL); 330 } 331 332 void* 333 gpt_read(int fd, off_t lba, size_t count) 334 { 335 off_t ofs; 336 void *buf; 337 338 count *= secsz; 339 buf = malloc(count); 340 if (buf == NULL) 341 return (NULL); 342 343 ofs = lba * secsz; 344 if (lseek(fd, ofs, SEEK_SET) == ofs && 345 read(fd, buf, count) == (ssize_t)count) 346 return (buf); 347 348 free(buf); 349 return (NULL); 350 } 351 352 int 353 gpt_write(int fd, map_t *map) 354 { 355 off_t ofs; 356 size_t count; 357 358 count = map->map_size * secsz; 359 ofs = map->map_start * secsz; 360 if (lseek(fd, ofs, SEEK_SET) == ofs && 361 write(fd, map->map_data, count) == (ssize_t)count) 362 return (0); 363 return (-1); 364 } 365 366 static int 367 gpt_mbr(int fd, off_t lba) 368 { 369 struct mbr *mbr; 370 map_t *m, *p; 371 off_t size, start; 372 unsigned int i, pmbr; 373 374 mbr = gpt_read(fd, lba, 1); 375 if (mbr == NULL) 376 return (-1); 377 378 if (mbr->mbr_sig != htole16(MBR_SIG)) { 379 if (verbose) 380 warnx("%s: MBR not found at sector %llu", device_name, 381 (long long)lba); 382 free(mbr); 383 return (0); 384 } 385 386 /* 387 * Differentiate between a regular MBR and a PMBR. This is more 388 * convenient in general. A PMBR is one with a single partition 389 * of type 0xee. 390 */ 391 pmbr = 0; 392 for (i = 0; i < 4; i++) { 393 if (mbr->mbr_part[i].part_typ == 0) 394 continue; 395 if (mbr->mbr_part[i].part_typ == 0xee) 396 pmbr++; 397 else 398 break; 399 } 400 if (pmbr && (i == 1 || i == 4) && lba == 0) { 401 if (pmbr != 1) 402 warnx("%s: Suspicious PMBR at sector %llu", 403 device_name, (long long)lba); 404 else if (verbose > 1) 405 warnx("%s: PMBR at sector %llu", device_name, 406 (long long)lba); 407 p = map_add(lba, 1LL, MAP_TYPE_PMBR, mbr); 408 return ((p == NULL) ? -1 : 0); 409 } 410 if (pmbr) 411 warnx("%s: Suspicious MBR at sector %llu", device_name, 412 (long long)lba); 413 else if (verbose > 1) 414 warnx("%s: MBR at sector %llu", device_name, (long long)lba); 415 416 p = map_add(lba, 1LL, MAP_TYPE_MBR, mbr); 417 if (p == NULL) 418 return (-1); 419 for (i = 0; i < 4; i++) { 420 if (mbr->mbr_part[i].part_typ == 0 || 421 mbr->mbr_part[i].part_typ == 0xee) 422 continue; 423 start = le16toh(mbr->mbr_part[i].part_start_hi); 424 start = (start << 16) + le16toh(mbr->mbr_part[i].part_start_lo); 425 size = le16toh(mbr->mbr_part[i].part_size_hi); 426 size = (size << 16) + le16toh(mbr->mbr_part[i].part_size_lo); 427 if (start == 0 && size == 0) { 428 warnx("%s: Malformed MBR at sector %llu", device_name, 429 (long long)lba); 430 continue; 431 } 432 /* start is relative to the offset of the MBR itself. */ 433 start += lba; 434 if (verbose > 2) 435 warnx("%s: MBR part: type=%d, start=%llu, size=%llu", 436 device_name, mbr->mbr_part[i].part_typ, 437 (long long)start, (long long)size); 438 if (mbr->mbr_part[i].part_typ != 15) { 439 m = map_add(start, size, MAP_TYPE_MBR_PART, p); 440 if (m == NULL) 441 return (-1); 442 m->map_index = i; 443 } else { 444 if (gpt_mbr(fd, start) == -1) 445 return (-1); 446 } 447 } 448 return (0); 449 } 450 451 static int 452 gpt_gpt(int fd, off_t lba) 453 { 454 uuid_t type; 455 off_t size; 456 struct gpt_ent *ent; 457 struct gpt_hdr *hdr; 458 char *p, *s; 459 map_t *m; 460 size_t blocks, tblsz; 461 unsigned int i; 462 uint32_t crc; 463 464 hdr = gpt_read(fd, lba, 1); 465 if (hdr == NULL) 466 return (-1); 467 468 if (memcmp(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig))) 469 goto fail_hdr; 470 471 crc = le32toh(hdr->hdr_crc_self); 472 hdr->hdr_crc_self = 0; 473 if (crc32(hdr, le32toh(hdr->hdr_size)) != crc) { 474 if (verbose) 475 warnx("%s: Bad CRC in GPT header at sector %llu", 476 device_name, (long long)lba); 477 goto fail_hdr; 478 } 479 480 tblsz = le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz); 481 blocks = tblsz / secsz + ((tblsz % secsz) ? 1 : 0); 482 483 /* Use generic pointer to deal with hdr->hdr_entsz != sizeof(*ent). */ 484 p = gpt_read(fd, le64toh(hdr->hdr_lba_table), blocks); 485 if (p == NULL) 486 return (-1); 487 488 if (crc32(p, tblsz) != le32toh(hdr->hdr_crc_table)) { 489 if (verbose) 490 warnx("%s: Bad CRC in GPT table at sector %llu", 491 device_name, 492 (long long)le64toh(hdr->hdr_lba_table)); 493 goto fail_ent; 494 } 495 496 if (verbose > 1) 497 warnx("%s: %s GPT at sector %llu", device_name, 498 (lba == 1) ? "Pri" : "Sec", (long long)lba); 499 500 m = map_add(lba, 1, (lba == 1) 501 ? MAP_TYPE_PRI_GPT_HDR : MAP_TYPE_SEC_GPT_HDR, hdr); 502 if (m == NULL) 503 return (-1); 504 505 m = map_add(le64toh(hdr->hdr_lba_table), blocks, (lba == 1) 506 ? MAP_TYPE_PRI_GPT_TBL : MAP_TYPE_SEC_GPT_TBL, p); 507 if (m == NULL) 508 return (-1); 509 510 if (lba != 1) 511 return (0); 512 513 for (i = 0; i < le32toh(hdr->hdr_entries); i++) { 514 ent = (void*)(p + i * le32toh(hdr->hdr_entsz)); 515 if (uuid_is_nil(&ent->ent_type, NULL)) 516 continue; 517 518 size = le64toh(ent->ent_lba_end) - le64toh(ent->ent_lba_start) + 519 1LL; 520 if (verbose > 2) { 521 le_uuid_dec(&ent->ent_type, &type); 522 uuid_to_string(&type, &s, NULL); 523 warnx( 524 "%s: GPT partition: type=%s, start=%llu, size=%llu", device_name, s, 525 (long long)le64toh(ent->ent_lba_start), 526 (long long)size); 527 free(s); 528 } 529 m = map_add(le64toh(ent->ent_lba_start), size, 530 MAP_TYPE_GPT_PART, ent); 531 if (m == NULL) 532 return (-1); 533 m->map_index = i; 534 } 535 return (0); 536 537 fail_ent: 538 free(p); 539 540 fail_hdr: 541 free(hdr); 542 return (0); 543 } 544 545 int 546 gpt_open(const char *dev) 547 { 548 struct stat sb; 549 int fd, mode; 550 551 mode = readonly ? O_RDONLY : O_RDWR|O_EXCL; 552 553 strlcpy(device_path, dev, sizeof(device_path)); 554 device_name = device_path; 555 556 if ((fd = open(device_path, mode)) != -1) 557 goto found; 558 559 snprintf(device_path, sizeof(device_path), "%s%s", _PATH_DEV, dev); 560 device_name = device_path + strlen(_PATH_DEV); 561 if ((fd = open(device_path, mode)) != -1) 562 goto found; 563 564 return (-1); 565 566 found: 567 if (fstat(fd, &sb) == -1) 568 goto close; 569 570 if ((sb.st_mode & S_IFMT) != S_IFREG) { 571 struct partinfo partinfo; 572 573 if (ioctl(fd, DIOCGPART, &partinfo) < 0) 574 goto close; 575 secsz = partinfo.media_blksize; 576 mediasz = partinfo.media_size; 577 } else { 578 secsz = 512; /* Fixed size for files. */ 579 if (sb.st_size % secsz) { 580 errno = EINVAL; 581 goto close; 582 } 583 mediasz = sb.st_size; 584 } 585 586 /* 587 * We require an absolute minimum of 6 sectors. One for the MBR, 588 * 2 for the GPT header, 2 for the GPT table and one to hold some 589 * user data. Let's catch this extreme border case here so that 590 * we don't have to worry about it later. 591 */ 592 if (mediasz / secsz < 6) { 593 errno = ENODEV; 594 goto close; 595 } 596 597 if (verbose) 598 warnx("%s: mediasize=%llu; sectorsize=%u; blocks=%llu", 599 device_name, (long long)mediasz, secsz, 600 (long long)(mediasz / secsz)); 601 602 map_init(mediasz / secsz); 603 604 if (gpt_mbr(fd, 0LL) == -1) 605 goto close; 606 if (gpt_gpt(fd, 1LL) == -1) 607 goto close; 608 if (gpt_gpt(fd, mediasz / secsz - 1LL) == -1) 609 goto close; 610 611 return (fd); 612 613 close: 614 close(fd); 615 return (-1); 616 } 617 618 void 619 gpt_close(int fd) 620 { 621 /* XXX post processing? */ 622 close(fd); 623 } 624 625 static struct { 626 int (*fptr)(int, char *[]); 627 const char *name; 628 } cmdsw[] = { 629 { cmd_add, "add" }, 630 { cmd_boot, "boot" }, 631 { cmd_create, "create" }, 632 { cmd_destroy, "destroy" }, 633 { NULL, "help" }, 634 { cmd_label, "label" }, 635 { cmd_migrate, "migrate" }, 636 { cmd_recover, "recover" }, 637 { cmd_remove, "remove" }, 638 { NULL, "rename" }, 639 { cmd_show, "show" }, 640 { NULL, "verify" }, 641 { NULL, NULL } 642 }; 643 644 static void 645 usage(void) 646 { 647 const char *prgname = getprogname(); 648 649 fprintf(stderr, 650 "usage: %s [-rv] [-p nparts] <command> [options] <device> ...\n" 651 " %s show <device>\n", 652 prgname, prgname); 653 exit(1); 654 } 655 656 static void 657 prefix(const char *cmd) 658 { 659 char *pfx; 660 const char *prg; 661 662 prg = getprogname(); 663 pfx = malloc(strlen(prg) + strlen(cmd) + 2); 664 /* Don't bother failing. It's not important */ 665 if (pfx == NULL) 666 return; 667 668 sprintf(pfx, "%s %s", prg, cmd); 669 setprogname(pfx); 670 } 671 672 int 673 main(int argc, char *argv[]) 674 { 675 char *cmd, *p; 676 int ch, i; 677 678 /* Get the generic options */ 679 while ((ch = getopt(argc, argv, "p:rv")) != -1) { 680 switch(ch) { 681 case 'p': 682 if (parts > 0) 683 usage(); 684 parts = strtol(optarg, &p, 10); 685 if (*p != 0 || parts < 1) 686 usage(); 687 break; 688 case 'r': 689 readonly = 1; 690 break; 691 case 'v': 692 verbose++; 693 break; 694 default: 695 usage(); 696 } 697 } 698 if (!parts) 699 parts = 128; 700 701 if (argc == optind) 702 usage(); 703 704 cmd = argv[optind++]; 705 for (i = 0; cmdsw[i].name != NULL && strcmp(cmd, cmdsw[i].name); i++); 706 707 if (cmdsw[i].fptr == NULL) 708 errx(1, "unknown command: %s", cmd); 709 710 prefix(cmd); 711 return ((*cmdsw[i].fptr)(argc, argv)); 712 } 713