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 * $FreeBSD: src/sbin/gpt/migrate.c,v 1.16 2005/09/01 02:42:52 marcel Exp $ 27 */ 28 29 #include <sys/types.h> 30 #include <sys/disklabel32.h> 31 #include <sys/dtype.h> 32 33 #include <err.h> 34 #include <stddef.h> 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <unistd.h> 39 40 #include "map.h" 41 #include "gpt.h" 42 43 /* 44 * Allow compilation on platforms that do not have a BSD label. 45 * The values are valid for x86_64, i386 and ia64 disklabels. 46 */ 47 #ifndef LABELOFFSET 48 #define LABELOFFSET 0 49 #endif 50 #ifndef LABELSECTOR 51 #define LABELSECTOR 1 52 #endif 53 54 static int force; 55 static int slice; 56 57 static void 58 usage_migrate(void) 59 { 60 61 fprintf(stderr, 62 "usage: %s [-fs] device ...\n", getprogname()); 63 exit(1); 64 } 65 66 static struct gpt_ent* 67 migrate_disklabel(int fd, off_t start, struct gpt_ent *ent) 68 { 69 char *buf; 70 struct disklabel32 *dl; 71 off_t ofs, rawofs; 72 int i; 73 74 buf = gpt_read(fd, start + LABELSECTOR32, 1); 75 dl = (void*)(buf + LABELOFFSET32); 76 77 if (le32toh(dl->d_magic) != DISKMAGIC32 || 78 le32toh(dl->d_magic2) != DISKMAGIC32) { 79 warnx("%s: warning: FreeBSD slice without disklabel", 80 device_name); 81 return (ent); 82 } 83 84 rawofs = le32toh(dl->d_partitions[RAW_PART].p_offset) * 85 le32toh(dl->d_secsize); 86 for (i = 0; i < le16toh(dl->d_npartitions); i++) { 87 if (dl->d_partitions[i].p_fstype == FS_UNUSED) 88 continue; 89 ofs = le32toh(dl->d_partitions[i].p_offset) * 90 le32toh(dl->d_secsize); 91 if (ofs < rawofs) 92 rawofs = 0; 93 } 94 rawofs /= secsz; 95 96 for (i = 0; i < le16toh(dl->d_npartitions); i++) { 97 switch (dl->d_partitions[i].p_fstype) { 98 case FS_UNUSED: 99 continue; 100 case FS_SWAP: { 101 uuid_t swap = GPT_ENT_TYPE_FREEBSD_SWAP; 102 le_uuid_enc(&ent->ent_type, &swap); 103 utf8_to_utf16("FreeBSD swap partition", 104 ent->ent_name, 36); 105 break; 106 } 107 case FS_BSDFFS: { 108 uuid_t ufs = GPT_ENT_TYPE_FREEBSD_UFS; 109 le_uuid_enc(&ent->ent_type, &ufs); 110 utf8_to_utf16("FreeBSD UFS partition", 111 ent->ent_name, 36); 112 break; 113 } 114 case FS_VINUM: { 115 uuid_t vinum = GPT_ENT_TYPE_FREEBSD_VINUM; 116 le_uuid_enc(&ent->ent_type, &vinum); 117 utf8_to_utf16("FreeBSD vinum partition", 118 ent->ent_name, 36); 119 break; 120 } 121 default: 122 warnx("%s: warning: unknown FreeBSD partition (%d)", 123 device_name, dl->d_partitions[i].p_fstype); 124 continue; 125 } 126 127 ofs = (le32toh(dl->d_partitions[i].p_offset) * 128 le32toh(dl->d_secsize)) / secsz; 129 ofs = (ofs > 0) ? ofs - rawofs : 0; 130 ent->ent_lba_start = htole64(start + ofs); 131 ent->ent_lba_end = htole64(start + ofs + 132 le32toh(dl->d_partitions[i].p_size) - 1LL); 133 ent++; 134 } 135 136 return (ent); 137 } 138 139 static void 140 migrate(int fd) 141 { 142 uuid_t uuid; 143 off_t blocks, last; 144 map_t *gpt, *tpg; 145 map_t *tbl, *lbt; 146 map_t *map; 147 struct gpt_hdr *hdr; 148 struct gpt_ent *ent; 149 struct mbr *mbr; 150 uint32_t start, size; 151 unsigned int i; 152 153 last = mediasz / secsz - 1LL; 154 155 map = map_find(MAP_TYPE_MBR); 156 if (map == NULL || map->map_start != 0) { 157 warnx("%s: error: no partitions to convert", device_name); 158 return; 159 } 160 161 mbr = map->map_data; 162 163 if (map_find(MAP_TYPE_PRI_GPT_HDR) != NULL || 164 map_find(MAP_TYPE_SEC_GPT_HDR) != NULL) { 165 warnx("%s: error: device already contains a GPT", device_name); 166 return; 167 } 168 169 /* Get the amount of free space after the MBR */ 170 blocks = map_free(1LL, 0LL); 171 if (blocks == 0LL) { 172 warnx("%s: error: no room for the GPT header", device_name); 173 return; 174 } 175 176 /* Don't create more than parts entries. */ 177 if ((uint64_t)(blocks - 1) * secsz > parts * sizeof(struct gpt_ent)) { 178 blocks = (parts * sizeof(struct gpt_ent)) / secsz; 179 if ((parts * sizeof(struct gpt_ent)) % secsz) 180 blocks++; 181 blocks++; /* Don't forget the header itself */ 182 } 183 184 /* Never cross the median of the device. */ 185 if ((blocks + 1LL) > ((last + 1LL) >> 1)) 186 blocks = ((last + 1LL) >> 1) - 1LL; 187 188 /* 189 * Get the amount of free space at the end of the device and 190 * calculate the size for the GPT structures. 191 */ 192 map = map_last(); 193 if (map->map_type != MAP_TYPE_UNUSED) { 194 warnx("%s: error: no room for the backup header", device_name); 195 return; 196 } 197 198 if (map->map_size < blocks) 199 blocks = map->map_size; 200 if (blocks == 1LL) { 201 warnx("%s: error: no room for the GPT table", device_name); 202 return; 203 } 204 205 blocks--; /* Number of blocks in the GPT table. */ 206 gpt = map_add(1LL, 1LL, MAP_TYPE_PRI_GPT_HDR, calloc(1, secsz)); 207 tbl = map_add(2LL, blocks, MAP_TYPE_PRI_GPT_TBL, 208 calloc(blocks, secsz)); 209 if (gpt == NULL || tbl == NULL) 210 return; 211 212 lbt = map_add(last - blocks, blocks, MAP_TYPE_SEC_GPT_TBL, 213 tbl->map_data); 214 tpg = map_add(last, 1LL, MAP_TYPE_SEC_GPT_HDR, calloc(1, secsz)); 215 216 hdr = gpt->map_data; 217 memcpy(hdr->hdr_sig, GPT_HDR_SIG, sizeof(hdr->hdr_sig)); 218 hdr->hdr_revision = htole32(GPT_HDR_REVISION); 219 /* 220 * XXX struct gpt_hdr is not a multiple of 8 bytes in size and thus 221 * contains padding we must not include in the size. 222 */ 223 hdr->hdr_size = htole32(offsetof(struct gpt_hdr, padding)); 224 hdr->hdr_lba_self = htole64(gpt->map_start); 225 hdr->hdr_lba_alt = htole64(tpg->map_start); 226 hdr->hdr_lba_start = htole64(tbl->map_start + blocks); 227 hdr->hdr_lba_end = htole64(lbt->map_start - 1LL); 228 uuid_create(&uuid, NULL); 229 le_uuid_enc(&hdr->hdr_uuid, &uuid); 230 hdr->hdr_lba_table = htole64(tbl->map_start); 231 hdr->hdr_entries = htole32((blocks * secsz) / sizeof(struct gpt_ent)); 232 if (le32toh(hdr->hdr_entries) > parts) 233 hdr->hdr_entries = htole32(parts); 234 hdr->hdr_entsz = htole32(sizeof(struct gpt_ent)); 235 236 ent = tbl->map_data; 237 for (i = 0; i < le32toh(hdr->hdr_entries); i++) { 238 uuid_create(&uuid, NULL); 239 le_uuid_enc(&ent[i].ent_uuid, &uuid); 240 } 241 242 /* Mirror partitions. */ 243 for (i = 0; i < 4; i++) { 244 start = le16toh(mbr->mbr_part[i].part_start_hi); 245 start = (start << 16) + le16toh(mbr->mbr_part[i].part_start_lo); 246 size = le16toh(mbr->mbr_part[i].part_size_hi); 247 size = (size << 16) + le16toh(mbr->mbr_part[i].part_size_lo); 248 249 switch (mbr->mbr_part[i].part_typ) { 250 case 0: 251 continue; 252 #if 0 253 case 108: 254 /* TODO: Port to DragonFly and test */ 255 continue; 256 #endif 257 case 165: { /* FreeBSD */ 258 if (slice) { 259 uuid_t freebsd = GPT_ENT_TYPE_FREEBSD; 260 le_uuid_enc(&ent->ent_type, &freebsd); 261 ent->ent_lba_start = htole64((uint64_t)start); 262 ent->ent_lba_end = htole64(start + size - 1LL); 263 utf8_to_utf16("FreeBSD disklabel partition", 264 ent->ent_name, 36); 265 ent++; 266 } else 267 ent = migrate_disklabel(fd, start, ent); 268 break; 269 } 270 case 239: { /* EFI */ 271 uuid_t efi_slice = GPT_ENT_TYPE_EFI; 272 le_uuid_enc(&ent->ent_type, &efi_slice); 273 ent->ent_lba_start = htole64((uint64_t)start); 274 ent->ent_lba_end = htole64(start + size - 1LL); 275 utf8_to_utf16("EFI system partition", 276 ent->ent_name, 36); 277 ent++; 278 break; 279 } 280 default: 281 if (!force) { 282 warnx("%s: error: unknown partition type (%d)", 283 device_name, mbr->mbr_part[i].part_typ); 284 return; 285 } 286 } 287 } 288 ent = tbl->map_data; 289 290 hdr->hdr_crc_table = htole32(crc32(ent, le32toh(hdr->hdr_entries) * 291 le32toh(hdr->hdr_entsz))); 292 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size))); 293 294 gpt_write(fd, gpt); 295 gpt_write(fd, tbl); 296 297 /* 298 * Create backup GPT. 299 */ 300 memcpy(tpg->map_data, gpt->map_data, secsz); 301 hdr = tpg->map_data; 302 hdr->hdr_lba_self = htole64(tpg->map_start); 303 hdr->hdr_lba_alt = htole64(gpt->map_start); 304 hdr->hdr_lba_table = htole64(lbt->map_start); 305 hdr->hdr_crc_self = 0; /* Don't ever forget this! */ 306 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size))); 307 308 gpt_write(fd, lbt); 309 gpt_write(fd, tpg); 310 311 map = map_find(MAP_TYPE_MBR); 312 mbr = map->map_data; 313 /* 314 * Turn the MBR into a Protective MBR. 315 */ 316 bzero(mbr->mbr_part, sizeof(mbr->mbr_part)); 317 mbr->mbr_part[0].part_shd = 0xff; 318 mbr->mbr_part[0].part_ssect = 0xff; 319 mbr->mbr_part[0].part_scyl = 0xff; 320 mbr->mbr_part[0].part_typ = 0xee; 321 mbr->mbr_part[0].part_ehd = 0xff; 322 mbr->mbr_part[0].part_esect = 0xff; 323 mbr->mbr_part[0].part_ecyl = 0xff; 324 mbr->mbr_part[0].part_start_lo = htole16(1); 325 if (last > 0xffffffff) { 326 mbr->mbr_part[0].part_size_lo = htole16(0xffff); 327 mbr->mbr_part[0].part_size_hi = htole16(0xffff); 328 } else { 329 mbr->mbr_part[0].part_size_lo = htole16(last); 330 mbr->mbr_part[0].part_size_hi = htole16(last >> 16); 331 } 332 gpt_write(fd, map); 333 } 334 335 int 336 cmd_migrate(int argc, char *argv[]) 337 { 338 int ch, fd; 339 340 /* Get the migrate options */ 341 while ((ch = getopt(argc, argv, "fs")) != -1) { 342 switch(ch) { 343 case 'f': 344 force = 1; 345 break; 346 case 's': 347 slice = 1; 348 break; 349 default: 350 usage_migrate(); 351 } 352 } 353 354 if (argc == optind) 355 usage_migrate(); 356 357 while (optind < argc) { 358 fd = gpt_open(argv[optind++]); 359 if (fd == -1) { 360 warn("unable to open device '%s'", device_name); 361 continue; 362 } 363 364 migrate(fd); 365 366 gpt_close(fd); 367 } 368 369 return (0); 370 } 371