1 /* 2 * fs/partitions/msdos.c 3 * 4 * Code extracted from drivers/block/genhd.c 5 * Copyright (C) 1991-1998 Linus Torvalds 6 * 7 * Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug 8 * in the early extended-partition checks and added DM partitions 9 * 10 * Support for DiskManager v6.0x added by Mark Lord, 11 * with information provided by OnTrack. This now works for linux fdisk 12 * and LILO, as well as loadlin and bootln. Note that disks other than 13 * /dev/hda *must* have a "DOS" type 0x51 partition in the first slot (hda1). 14 * 15 * More flexible handling of extended partitions - aeb, 950831 16 * 17 * Check partition table on IDE disks for common CHS translations 18 * 19 * Re-organised Feb 1998 Russell King 20 */ 21 #include <linux/msdos_fs.h> 22 23 #include "check.h" 24 #include "msdos.h" 25 #include "efi.h" 26 #include "aix.h" 27 28 /* 29 * Many architectures don't like unaligned accesses, while 30 * the nr_sects and start_sect partition table entries are 31 * at a 2 (mod 4) address. 32 */ 33 #include <asm/unaligned.h> 34 35 #define SYS_IND(p) get_unaligned(&p->sys_ind) 36 37 static inline sector_t nr_sects(struct partition *p) 38 { 39 return (sector_t)get_unaligned_le32(&p->nr_sects); 40 } 41 42 static inline sector_t start_sect(struct partition *p) 43 { 44 return (sector_t)get_unaligned_le32(&p->start_sect); 45 } 46 47 static inline int is_extended_partition(struct partition *p) 48 { 49 return (SYS_IND(p) == DOS_EXTENDED_PARTITION || 50 SYS_IND(p) == WIN98_EXTENDED_PARTITION || 51 SYS_IND(p) == LINUX_EXTENDED_PARTITION); 52 } 53 54 #define MSDOS_LABEL_MAGIC1 0x55 55 #define MSDOS_LABEL_MAGIC2 0xAA 56 57 static inline int 58 msdos_magic_present(unsigned char *p) 59 { 60 return (p[0] == MSDOS_LABEL_MAGIC1 && p[1] == MSDOS_LABEL_MAGIC2); 61 } 62 63 /* Value is EBCDIC 'IBMA' */ 64 #define AIX_LABEL_MAGIC1 0xC9 65 #define AIX_LABEL_MAGIC2 0xC2 66 #define AIX_LABEL_MAGIC3 0xD4 67 #define AIX_LABEL_MAGIC4 0xC1 68 static int aix_magic_present(struct parsed_partitions *state, unsigned char *p) 69 { 70 struct partition *pt = (struct partition *) (p + 0x1be); 71 Sector sect; 72 unsigned char *d; 73 int slot, ret = 0; 74 75 if (!(p[0] == AIX_LABEL_MAGIC1 && 76 p[1] == AIX_LABEL_MAGIC2 && 77 p[2] == AIX_LABEL_MAGIC3 && 78 p[3] == AIX_LABEL_MAGIC4)) 79 return 0; 80 /* Assume the partition table is valid if Linux partitions exists */ 81 for (slot = 1; slot <= 4; slot++, pt++) { 82 if (pt->sys_ind == LINUX_SWAP_PARTITION || 83 pt->sys_ind == LINUX_RAID_PARTITION || 84 pt->sys_ind == LINUX_DATA_PARTITION || 85 pt->sys_ind == LINUX_LVM_PARTITION || 86 is_extended_partition(pt)) 87 return 0; 88 } 89 d = read_part_sector(state, 7, §); 90 if (d) { 91 if (d[0] == '_' && d[1] == 'L' && d[2] == 'V' && d[3] == 'M') 92 ret = 1; 93 put_dev_sector(sect); 94 } 95 return ret; 96 } 97 98 static void set_info(struct parsed_partitions *state, int slot, 99 u32 disksig) 100 { 101 struct partition_meta_info *info = &state->parts[slot].info; 102 103 snprintf(info->uuid, sizeof(info->uuid), "%08x-%02x", disksig, 104 slot); 105 info->volname[0] = 0; 106 state->parts[slot].has_info = true; 107 } 108 109 /* 110 * Create devices for each logical partition in an extended partition. 111 * The logical partitions form a linked list, with each entry being 112 * a partition table with two entries. The first entry 113 * is the real data partition (with a start relative to the partition 114 * table start). The second is a pointer to the next logical partition 115 * (with a start relative to the entire extended partition). 116 * We do not create a Linux partition for the partition tables, but 117 * only for the actual data partitions. 118 */ 119 120 static void parse_extended(struct parsed_partitions *state, 121 sector_t first_sector, sector_t first_size, 122 u32 disksig) 123 { 124 struct partition *p; 125 Sector sect; 126 unsigned char *data; 127 sector_t this_sector, this_size; 128 sector_t sector_size = bdev_logical_block_size(state->bdev) / 512; 129 int loopct = 0; /* number of links followed 130 without finding a data partition */ 131 int i; 132 133 this_sector = first_sector; 134 this_size = first_size; 135 136 while (1) { 137 if (++loopct > 100) 138 return; 139 if (state->next == state->limit) 140 return; 141 data = read_part_sector(state, this_sector, §); 142 if (!data) 143 return; 144 145 if (!msdos_magic_present(data + 510)) 146 goto done; 147 148 p = (struct partition *) (data + 0x1be); 149 150 /* 151 * Usually, the first entry is the real data partition, 152 * the 2nd entry is the next extended partition, or empty, 153 * and the 3rd and 4th entries are unused. 154 * However, DRDOS sometimes has the extended partition as 155 * the first entry (when the data partition is empty), 156 * and OS/2 seems to use all four entries. 157 */ 158 159 /* 160 * First process the data partition(s) 161 */ 162 for (i = 0; i < 4; i++, p++) { 163 sector_t offs, size, next; 164 165 if (!nr_sects(p) || is_extended_partition(p)) 166 continue; 167 168 /* Check the 3rd and 4th entries - 169 these sometimes contain random garbage */ 170 offs = start_sect(p)*sector_size; 171 size = nr_sects(p)*sector_size; 172 next = this_sector + offs; 173 if (i >= 2) { 174 if (offs + size > this_size) 175 continue; 176 if (next < first_sector) 177 continue; 178 if (next + size > first_sector + first_size) 179 continue; 180 } 181 182 put_partition(state, state->next, next, size); 183 set_info(state, state->next, disksig); 184 if (SYS_IND(p) == LINUX_RAID_PARTITION) 185 state->parts[state->next].flags = ADDPART_FLAG_RAID; 186 loopct = 0; 187 if (++state->next == state->limit) 188 goto done; 189 } 190 /* 191 * Next, process the (first) extended partition, if present. 192 * (So far, there seems to be no reason to make 193 * parse_extended() recursive and allow a tree 194 * of extended partitions.) 195 * It should be a link to the next logical partition. 196 */ 197 p -= 4; 198 for (i = 0; i < 4; i++, p++) 199 if (nr_sects(p) && is_extended_partition(p)) 200 break; 201 if (i == 4) 202 goto done; /* nothing left to do */ 203 204 this_sector = first_sector + start_sect(p) * sector_size; 205 this_size = nr_sects(p) * sector_size; 206 put_dev_sector(sect); 207 } 208 done: 209 put_dev_sector(sect); 210 } 211 212 /* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also 213 indicates linux swap. Be careful before believing this is Solaris. */ 214 215 static void parse_solaris_x86(struct parsed_partitions *state, 216 sector_t offset, sector_t size, int origin) 217 { 218 #ifdef CONFIG_SOLARIS_X86_PARTITION 219 Sector sect; 220 struct solaris_x86_vtoc *v; 221 int i; 222 short max_nparts; 223 224 v = read_part_sector(state, offset + 1, §); 225 if (!v) 226 return; 227 if (le32_to_cpu(v->v_sanity) != SOLARIS_X86_VTOC_SANE) { 228 put_dev_sector(sect); 229 return; 230 } 231 { 232 char tmp[1 + BDEVNAME_SIZE + 10 + 11 + 1]; 233 234 snprintf(tmp, sizeof(tmp), " %s%d: <solaris:", state->name, origin); 235 strlcat(state->pp_buf, tmp, PAGE_SIZE); 236 } 237 if (le32_to_cpu(v->v_version) != 1) { 238 char tmp[64]; 239 240 snprintf(tmp, sizeof(tmp), " cannot handle version %d vtoc>\n", 241 le32_to_cpu(v->v_version)); 242 strlcat(state->pp_buf, tmp, PAGE_SIZE); 243 put_dev_sector(sect); 244 return; 245 } 246 /* Ensure we can handle previous case of VTOC with 8 entries gracefully */ 247 max_nparts = le16_to_cpu(v->v_nparts) > 8 ? SOLARIS_X86_NUMSLICE : 8; 248 for (i = 0; i < max_nparts && state->next < state->limit; i++) { 249 struct solaris_x86_slice *s = &v->v_slice[i]; 250 char tmp[3 + 10 + 1 + 1]; 251 252 if (s->s_size == 0) 253 continue; 254 snprintf(tmp, sizeof(tmp), " [s%d]", i); 255 strlcat(state->pp_buf, tmp, PAGE_SIZE); 256 /* solaris partitions are relative to current MS-DOS 257 * one; must add the offset of the current partition */ 258 put_partition(state, state->next++, 259 le32_to_cpu(s->s_start)+offset, 260 le32_to_cpu(s->s_size)); 261 } 262 put_dev_sector(sect); 263 strlcat(state->pp_buf, " >\n", PAGE_SIZE); 264 #endif 265 } 266 267 #if defined(CONFIG_BSD_DISKLABEL) 268 /* 269 * Create devices for BSD partitions listed in a disklabel, under a 270 * dos-like partition. See parse_extended() for more information. 271 */ 272 static void parse_bsd(struct parsed_partitions *state, 273 sector_t offset, sector_t size, int origin, char *flavour, 274 int max_partitions) 275 { 276 Sector sect; 277 struct bsd_disklabel *l; 278 struct bsd_partition *p; 279 char tmp[64]; 280 281 l = read_part_sector(state, offset + 1, §); 282 if (!l) 283 return; 284 if (le32_to_cpu(l->d_magic) != BSD_DISKMAGIC) { 285 put_dev_sector(sect); 286 return; 287 } 288 289 snprintf(tmp, sizeof(tmp), " %s%d: <%s:", state->name, origin, flavour); 290 strlcat(state->pp_buf, tmp, PAGE_SIZE); 291 292 if (le16_to_cpu(l->d_npartitions) < max_partitions) 293 max_partitions = le16_to_cpu(l->d_npartitions); 294 for (p = l->d_partitions; p - l->d_partitions < max_partitions; p++) { 295 sector_t bsd_start, bsd_size; 296 297 if (state->next == state->limit) 298 break; 299 if (p->p_fstype == BSD_FS_UNUSED) 300 continue; 301 bsd_start = le32_to_cpu(p->p_offset); 302 bsd_size = le32_to_cpu(p->p_size); 303 if (memcmp(flavour, "bsd\0", 4) == 0) 304 bsd_start += offset; 305 if (offset == bsd_start && size == bsd_size) 306 /* full parent partition, we have it already */ 307 continue; 308 if (offset > bsd_start || offset+size < bsd_start+bsd_size) { 309 strlcat(state->pp_buf, "bad subpartition - ignored\n", PAGE_SIZE); 310 continue; 311 } 312 put_partition(state, state->next++, bsd_start, bsd_size); 313 } 314 put_dev_sector(sect); 315 if (le16_to_cpu(l->d_npartitions) > max_partitions) { 316 snprintf(tmp, sizeof(tmp), " (ignored %d more)", 317 le16_to_cpu(l->d_npartitions) - max_partitions); 318 strlcat(state->pp_buf, tmp, PAGE_SIZE); 319 } 320 strlcat(state->pp_buf, " >\n", PAGE_SIZE); 321 } 322 #endif 323 324 static void parse_freebsd(struct parsed_partitions *state, 325 sector_t offset, sector_t size, int origin) 326 { 327 #ifdef CONFIG_BSD_DISKLABEL 328 parse_bsd(state, offset, size, origin, "bsd", BSD_MAXPARTITIONS); 329 #endif 330 } 331 332 static void parse_netbsd(struct parsed_partitions *state, 333 sector_t offset, sector_t size, int origin) 334 { 335 #ifdef CONFIG_BSD_DISKLABEL 336 parse_bsd(state, offset, size, origin, "netbsd", BSD_MAXPARTITIONS); 337 #endif 338 } 339 340 static void parse_openbsd(struct parsed_partitions *state, 341 sector_t offset, sector_t size, int origin) 342 { 343 #ifdef CONFIG_BSD_DISKLABEL 344 parse_bsd(state, offset, size, origin, "openbsd", 345 OPENBSD_MAXPARTITIONS); 346 #endif 347 } 348 349 /* 350 * Create devices for Unixware partitions listed in a disklabel, under a 351 * dos-like partition. See parse_extended() for more information. 352 */ 353 static void parse_unixware(struct parsed_partitions *state, 354 sector_t offset, sector_t size, int origin) 355 { 356 #ifdef CONFIG_UNIXWARE_DISKLABEL 357 Sector sect; 358 struct unixware_disklabel *l; 359 struct unixware_slice *p; 360 361 l = read_part_sector(state, offset + 29, §); 362 if (!l) 363 return; 364 if (le32_to_cpu(l->d_magic) != UNIXWARE_DISKMAGIC || 365 le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_DISKMAGIC2) { 366 put_dev_sector(sect); 367 return; 368 } 369 { 370 char tmp[1 + BDEVNAME_SIZE + 10 + 12 + 1]; 371 372 snprintf(tmp, sizeof(tmp), " %s%d: <unixware:", state->name, origin); 373 strlcat(state->pp_buf, tmp, PAGE_SIZE); 374 } 375 p = &l->vtoc.v_slice[1]; 376 /* I omit the 0th slice as it is the same as whole disk. */ 377 while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) { 378 if (state->next == state->limit) 379 break; 380 381 if (p->s_label != UNIXWARE_FS_UNUSED) 382 put_partition(state, state->next++, 383 le32_to_cpu(p->start_sect), 384 le32_to_cpu(p->nr_sects)); 385 p++; 386 } 387 put_dev_sector(sect); 388 strlcat(state->pp_buf, " >\n", PAGE_SIZE); 389 #endif 390 } 391 392 /* 393 * Minix 2.0.0/2.0.2 subpartition support. 394 * Anand Krishnamurthy <anandk@wiproge.med.ge.com> 395 * Rajeev V. Pillai <rajeevvp@yahoo.com> 396 */ 397 static void parse_minix(struct parsed_partitions *state, 398 sector_t offset, sector_t size, int origin) 399 { 400 #ifdef CONFIG_MINIX_SUBPARTITION 401 Sector sect; 402 unsigned char *data; 403 struct partition *p; 404 int i; 405 406 data = read_part_sector(state, offset, §); 407 if (!data) 408 return; 409 410 p = (struct partition *)(data + 0x1be); 411 412 /* The first sector of a Minix partition can have either 413 * a secondary MBR describing its subpartitions, or 414 * the normal boot sector. */ 415 if (msdos_magic_present(data + 510) && 416 SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */ 417 char tmp[1 + BDEVNAME_SIZE + 10 + 9 + 1]; 418 419 snprintf(tmp, sizeof(tmp), " %s%d: <minix:", state->name, origin); 420 strlcat(state->pp_buf, tmp, PAGE_SIZE); 421 for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) { 422 if (state->next == state->limit) 423 break; 424 /* add each partition in use */ 425 if (SYS_IND(p) == MINIX_PARTITION) 426 put_partition(state, state->next++, 427 start_sect(p), nr_sects(p)); 428 } 429 strlcat(state->pp_buf, " >\n", PAGE_SIZE); 430 } 431 put_dev_sector(sect); 432 #endif /* CONFIG_MINIX_SUBPARTITION */ 433 } 434 435 static struct { 436 unsigned char id; 437 void (*parse)(struct parsed_partitions *, sector_t, sector_t, int); 438 } subtypes[] = { 439 {FREEBSD_PARTITION, parse_freebsd}, 440 {NETBSD_PARTITION, parse_netbsd}, 441 {OPENBSD_PARTITION, parse_openbsd}, 442 {MINIX_PARTITION, parse_minix}, 443 {UNIXWARE_PARTITION, parse_unixware}, 444 {SOLARIS_X86_PARTITION, parse_solaris_x86}, 445 {NEW_SOLARIS_X86_PARTITION, parse_solaris_x86}, 446 {0, NULL}, 447 }; 448 449 int msdos_partition(struct parsed_partitions *state) 450 { 451 sector_t sector_size = bdev_logical_block_size(state->bdev) / 512; 452 Sector sect; 453 unsigned char *data; 454 struct partition *p; 455 struct fat_boot_sector *fb; 456 int slot; 457 u32 disksig; 458 459 data = read_part_sector(state, 0, §); 460 if (!data) 461 return -1; 462 463 /* 464 * Note order! (some AIX disks, e.g. unbootable kind, 465 * have no MSDOS 55aa) 466 */ 467 if (aix_magic_present(state, data)) { 468 put_dev_sector(sect); 469 #ifdef CONFIG_AIX_PARTITION 470 return aix_partition(state); 471 #else 472 strlcat(state->pp_buf, " [AIX]", PAGE_SIZE); 473 return 0; 474 #endif 475 } 476 477 if (!msdos_magic_present(data + 510)) { 478 put_dev_sector(sect); 479 return 0; 480 } 481 482 /* 483 * Now that the 55aa signature is present, this is probably 484 * either the boot sector of a FAT filesystem or a DOS-type 485 * partition table. Reject this in case the boot indicator 486 * is not 0 or 0x80. 487 */ 488 p = (struct partition *) (data + 0x1be); 489 for (slot = 1; slot <= 4; slot++, p++) { 490 if (p->boot_ind != 0 && p->boot_ind != 0x80) { 491 /* 492 * Even without a valid boot inidicator value 493 * its still possible this is valid FAT filesystem 494 * without a partition table. 495 */ 496 fb = (struct fat_boot_sector *) data; 497 if (slot == 1 && fb->reserved && fb->fats 498 && fat_valid_media(fb->media)) { 499 strlcat(state->pp_buf, "\n", PAGE_SIZE); 500 put_dev_sector(sect); 501 return 1; 502 } else { 503 put_dev_sector(sect); 504 return 0; 505 } 506 } 507 } 508 509 #ifdef CONFIG_EFI_PARTITION 510 p = (struct partition *) (data + 0x1be); 511 for (slot = 1 ; slot <= 4 ; slot++, p++) { 512 /* If this is an EFI GPT disk, msdos should ignore it. */ 513 if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) { 514 put_dev_sector(sect); 515 return 0; 516 } 517 } 518 #endif 519 p = (struct partition *) (data + 0x1be); 520 521 disksig = le32_to_cpup((__le32 *)(data + 0x1b8)); 522 523 /* 524 * Look for partitions in two passes: 525 * First find the primary and DOS-type extended partitions. 526 * On the second pass look inside *BSD, Unixware and Solaris partitions. 527 */ 528 529 state->next = 5; 530 for (slot = 1 ; slot <= 4 ; slot++, p++) { 531 sector_t start = start_sect(p)*sector_size; 532 sector_t size = nr_sects(p)*sector_size; 533 534 if (!size) 535 continue; 536 if (is_extended_partition(p)) { 537 /* 538 * prevent someone doing mkfs or mkswap on an 539 * extended partition, but leave room for LILO 540 * FIXME: this uses one logical sector for > 512b 541 * sector, although it may not be enough/proper. 542 */ 543 sector_t n = 2; 544 545 n = min(size, max(sector_size, n)); 546 put_partition(state, slot, start, n); 547 548 strlcat(state->pp_buf, " <", PAGE_SIZE); 549 parse_extended(state, start, size, disksig); 550 strlcat(state->pp_buf, " >", PAGE_SIZE); 551 continue; 552 } 553 put_partition(state, slot, start, size); 554 set_info(state, slot, disksig); 555 if (SYS_IND(p) == LINUX_RAID_PARTITION) 556 state->parts[slot].flags = ADDPART_FLAG_RAID; 557 if (SYS_IND(p) == DM6_PARTITION) 558 strlcat(state->pp_buf, "[DM]", PAGE_SIZE); 559 if (SYS_IND(p) == EZD_PARTITION) 560 strlcat(state->pp_buf, "[EZD]", PAGE_SIZE); 561 } 562 563 strlcat(state->pp_buf, "\n", PAGE_SIZE); 564 565 /* second pass - output for each on a separate line */ 566 p = (struct partition *) (0x1be + data); 567 for (slot = 1 ; slot <= 4 ; slot++, p++) { 568 unsigned char id = SYS_IND(p); 569 int n; 570 571 if (!nr_sects(p)) 572 continue; 573 574 for (n = 0; subtypes[n].parse && id != subtypes[n].id; n++) 575 ; 576 577 if (!subtypes[n].parse) 578 continue; 579 subtypes[n].parse(state, start_sect(p) * sector_size, 580 nr_sects(p) * sector_size, slot); 581 } 582 put_dev_sector(sect); 583 return 1; 584 } 585