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