2 * fs/partitions/msdos.c
4 * Code extracted from drivers/block/genhd.c
5 * Copyright (C) 1991-1998 Linus Torvalds
7 * Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
8 * in the early extended-partition checks and added DM partitions
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).
15 * More flexible handling of extended partitions - aeb, 950831
17 * Check partition table on IDE disks for common CHS translations
19 * Re-organised Feb 1998 Russell King
21 #include <linux/msdos_fs.h>
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.
32 #include <asm/unaligned.h>
34 #define SYS_IND(p) get_unaligned(&p->sys_ind)
36 static inline sector_t
nr_sects(struct partition
*p
)
38 return (sector_t
)get_unaligned_le32(&p
->nr_sects
);
41 static inline sector_t
start_sect(struct partition
*p
)
43 return (sector_t
)get_unaligned_le32(&p
->start_sect
);
46 static inline int is_extended_partition(struct partition
*p
)
48 return (SYS_IND(p
) == DOS_EXTENDED_PARTITION
||
49 SYS_IND(p
) == WIN98_EXTENDED_PARTITION
||
50 SYS_IND(p
) == LINUX_EXTENDED_PARTITION
);
53 #define MSDOS_LABEL_MAGIC1 0x55
54 #define MSDOS_LABEL_MAGIC2 0xAA
57 msdos_magic_present(unsigned char *p
)
59 return (p
[0] == MSDOS_LABEL_MAGIC1
&& p
[1] == MSDOS_LABEL_MAGIC2
);
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
)
69 struct partition
*pt
= (struct partition
*) (p
+ 0x1be);
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
))
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
))
88 d
= read_part_sector(state
, 7, §
);
90 if (d
[0] == '_' && d
[1] == 'L' && d
[2] == 'V' && d
[3] == 'M')
97 static void set_info(struct parsed_partitions
*state
, int slot
,
100 struct partition_meta_info
*info
= &state
->parts
[slot
].info
;
102 snprintf(info
->uuid
, sizeof(info
->uuid
), "%08x-%02x", disksig
,
104 info
->volname
[0] = 0;
105 state
->parts
[slot
].has_info
= true;
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.
119 static void parse_extended(struct parsed_partitions
*state
,
120 sector_t first_sector
, sector_t first_size
,
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 */
132 this_sector
= first_sector
;
133 this_size
= first_size
;
138 if (state
->next
== state
->limit
)
140 data
= read_part_sector(state
, this_sector
, §
);
144 if (!msdos_magic_present(data
+ 510))
147 p
= (struct partition
*) (data
+ 0x1be);
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.
159 * First process the data partition(s)
161 for (i
=0; i
<4; i
++, p
++) {
162 sector_t offs
, size
, next
;
163 if (!nr_sects(p
) || is_extended_partition(p
))
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
;
172 if (offs
+ size
> this_size
)
174 if (next
< first_sector
)
176 if (next
+ size
> first_sector
+ first_size
)
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
;
185 if (++state
->next
== state
->limit
)
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.
196 for (i
=0; i
<4; i
++, p
++)
197 if (nr_sects(p
) && is_extended_partition(p
))
200 goto done
; /* nothing left to do */
202 this_sector
= first_sector
+ start_sect(p
) * sector_size
;
203 this_size
= nr_sects(p
) * sector_size
;
204 put_dev_sector(sect
);
207 put_dev_sector(sect
);
210 /* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also
211 indicates linux swap. Be careful before believing this is Solaris. */
213 static void parse_solaris_x86(struct parsed_partitions
*state
,
214 sector_t offset
, sector_t size
, int origin
)
216 #ifdef CONFIG_SOLARIS_X86_PARTITION
218 struct solaris_x86_vtoc
*v
;
222 v
= read_part_sector(state
, offset
+ 1, §
);
225 if (le32_to_cpu(v
->v_sanity
) != SOLARIS_X86_VTOC_SANE
) {
226 put_dev_sector(sect
);
230 char tmp
[1 + BDEVNAME_SIZE
+ 10 + 11 + 1];
232 snprintf(tmp
, sizeof(tmp
), " %s%d: <solaris:", state
->name
, origin
);
233 strlcat(state
->pp_buf
, tmp
, PAGE_SIZE
);
235 if (le32_to_cpu(v
->v_version
) != 1) {
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
);
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];
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
));
260 put_dev_sector(sect
);
261 strlcat(state
->pp_buf
, " >\n", PAGE_SIZE
);
265 #if defined(CONFIG_BSD_DISKLABEL)
267 * Create devices for BSD partitions listed in a disklabel, under a
268 * dos-like partition. See parse_extended() for more information.
270 static void parse_bsd(struct parsed_partitions
*state
,
271 sector_t offset
, sector_t size
, int origin
, char *flavour
,
275 struct bsd_disklabel
*l
;
276 struct bsd_partition
*p
;
279 l
= read_part_sector(state
, offset
+ 1, §
);
282 if (le32_to_cpu(l
->d_magic
) != BSD_DISKMAGIC
) {
283 put_dev_sector(sect
);
287 snprintf(tmp
, sizeof(tmp
), " %s%d: <%s:", state
->name
, origin
, flavour
);
288 strlcat(state
->pp_buf
, tmp
, PAGE_SIZE
);
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
;
295 if (state
->next
== state
->limit
)
297 if (p
->p_fstype
== BSD_FS_UNUSED
)
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 */
304 if (offset
> bsd_start
|| offset
+size
< bsd_start
+bsd_size
) {
305 strlcat(state
->pp_buf
, "bad subpartition - ignored\n", PAGE_SIZE
);
308 put_partition(state
, state
->next
++, bsd_start
, bsd_size
);
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
);
316 strlcat(state
->pp_buf
, " >\n", PAGE_SIZE
);
320 static void parse_freebsd(struct parsed_partitions
*state
,
321 sector_t offset
, sector_t size
, int origin
)
323 #ifdef CONFIG_BSD_DISKLABEL
324 parse_bsd(state
, offset
, size
, origin
, "bsd", BSD_MAXPARTITIONS
);
328 static void parse_netbsd(struct parsed_partitions
*state
,
329 sector_t offset
, sector_t size
, int origin
)
331 #ifdef CONFIG_BSD_DISKLABEL
332 parse_bsd(state
, offset
, size
, origin
, "netbsd", BSD_MAXPARTITIONS
);
336 static void parse_openbsd(struct parsed_partitions
*state
,
337 sector_t offset
, sector_t size
, int origin
)
339 #ifdef CONFIG_BSD_DISKLABEL
340 parse_bsd(state
, offset
, size
, origin
, "openbsd",
341 OPENBSD_MAXPARTITIONS
);
346 * Create devices for Unixware partitions listed in a disklabel, under a
347 * dos-like partition. See parse_extended() for more information.
349 static void parse_unixware(struct parsed_partitions
*state
,
350 sector_t offset
, sector_t size
, int origin
)
352 #ifdef CONFIG_UNIXWARE_DISKLABEL
354 struct unixware_disklabel
*l
;
355 struct unixware_slice
*p
;
357 l
= read_part_sector(state
, offset
+ 29, §
);
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
);
366 char tmp
[1 + BDEVNAME_SIZE
+ 10 + 12 + 1];
368 snprintf(tmp
, sizeof(tmp
), " %s%d: <unixware:", state
->name
, origin
);
369 strlcat(state
->pp_buf
, tmp
, PAGE_SIZE
);
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
)
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
));
383 put_dev_sector(sect
);
384 strlcat(state
->pp_buf
, " >\n", PAGE_SIZE
);
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>
393 static void parse_minix(struct parsed_partitions
*state
,
394 sector_t offset
, sector_t size
, int origin
)
396 #ifdef CONFIG_MINIX_SUBPARTITION
402 data
= read_part_sector(state
, offset
, §
);
406 p
= (struct partition
*)(data
+ 0x1be);
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];
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
)
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
));
425 strlcat(state
->pp_buf
, " >\n", PAGE_SIZE
);
427 put_dev_sector(sect
);
428 #endif /* CONFIG_MINIX_SUBPARTITION */
433 void (*parse
)(struct parsed_partitions
*, sector_t
, sector_t
, int);
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
},
445 int msdos_partition(struct parsed_partitions
*state
)
447 sector_t sector_size
= bdev_logical_block_size(state
->bdev
) / 512;
451 struct fat_boot_sector
*fb
;
455 data
= read_part_sector(state
, 0, §
);
460 * Note order! (some AIX disks, e.g. unbootable kind,
461 * have no MSDOS 55aa)
463 if (aix_magic_present(state
, data
)) {
464 put_dev_sector(sect
);
465 strlcat(state
->pp_buf
, " [AIX]", PAGE_SIZE
);
469 if (!msdos_magic_present(data
+ 510)) {
470 put_dev_sector(sect
);
475 * Now that the 55aa signature is present, this is probably
476 * either the boot sector of a FAT filesystem or a DOS-type
477 * partition table. Reject this in case the boot indicator
480 p
= (struct partition
*) (data
+ 0x1be);
481 for (slot
= 1; slot
<= 4; slot
++, p
++) {
482 if (p
->boot_ind
!= 0 && p
->boot_ind
!= 0x80) {
484 * Even without a valid boot inidicator value
485 * its still possible this is valid FAT filesystem
486 * without a partition table.
488 fb
= (struct fat_boot_sector
*) data
;
489 if (slot
== 1 && fb
->reserved
&& fb
->fats
490 && fat_valid_media(fb
->media
)) {
491 strlcat(state
->pp_buf
, "\n", PAGE_SIZE
);
492 put_dev_sector(sect
);
495 put_dev_sector(sect
);
501 #ifdef CONFIG_EFI_PARTITION
502 p
= (struct partition
*) (data
+ 0x1be);
503 for (slot
= 1 ; slot
<= 4 ; slot
++, p
++) {
504 /* If this is an EFI GPT disk, msdos should ignore it. */
505 if (SYS_IND(p
) == EFI_PMBR_OSTYPE_EFI_GPT
) {
506 put_dev_sector(sect
);
511 p
= (struct partition
*) (data
+ 0x1be);
513 disksig
= le32_to_cpup((__le32
*)(data
+ 0x1b8));
516 * Look for partitions in two passes:
517 * First find the primary and DOS-type extended partitions.
518 * On the second pass look inside *BSD, Unixware and Solaris partitions.
522 for (slot
= 1 ; slot
<= 4 ; slot
++, p
++) {
523 sector_t start
= start_sect(p
)*sector_size
;
524 sector_t size
= nr_sects(p
)*sector_size
;
527 if (is_extended_partition(p
)) {
529 * prevent someone doing mkfs or mkswap on an
530 * extended partition, but leave room for LILO
531 * FIXME: this uses one logical sector for > 512b
532 * sector, although it may not be enough/proper.
535 n
= min(size
, max(sector_size
, n
));
536 put_partition(state
, slot
, start
, n
);
538 strlcat(state
->pp_buf
, " <", PAGE_SIZE
);
539 parse_extended(state
, start
, size
, disksig
);
540 strlcat(state
->pp_buf
, " >", PAGE_SIZE
);
543 put_partition(state
, slot
, start
, size
);
544 set_info(state
, slot
, disksig
);
545 if (SYS_IND(p
) == LINUX_RAID_PARTITION
)
546 state
->parts
[slot
].flags
= ADDPART_FLAG_RAID
;
547 if (SYS_IND(p
) == DM6_PARTITION
)
548 strlcat(state
->pp_buf
, "[DM]", PAGE_SIZE
);
549 if (SYS_IND(p
) == EZD_PARTITION
)
550 strlcat(state
->pp_buf
, "[EZD]", PAGE_SIZE
);
553 strlcat(state
->pp_buf
, "\n", PAGE_SIZE
);
555 /* second pass - output for each on a separate line */
556 p
= (struct partition
*) (0x1be + data
);
557 for (slot
= 1 ; slot
<= 4 ; slot
++, p
++) {
558 unsigned char id
= SYS_IND(p
);
564 for (n
= 0; subtypes
[n
].parse
&& id
!= subtypes
[n
].id
; n
++)
567 if (!subtypes
[n
].parse
)
569 subtypes
[n
].parse(state
, start_sect(p
) * sector_size
,
570 nr_sects(p
) * sector_size
, slot
);
572 put_dev_sector(sect
);