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