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