Double block_buffer
[yaboot.git] / second / partition.c
1 /*
2  *  partition.c - partition table support
3  *
4  *  Copyright (C) 2013 Dinar Valeev
5  *
6  *  Copyright (C) 2004 Sven Luther
7  *
8  *  Copyright (C) 2001, 2002 Ethan Benson
9  *
10  *  Copyright (C) 1999 Benjamin Herrenschmidt
11  *
12  *  This program is free software; you can redistribute it and/or modify
13  *  it under the terms of the GNU General Public License as published by
14  *  the Free Software Foundation; either version 2 of the License, or
15  *  (at your option) any later version.
16  *
17  *  This program is distributed in the hope that it will be useful,
18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  *  GNU General Public License for more details.
21  *
22  *  You should have received a copy of the GNU General Public License
23  *  along with this program; if not, write to the Free Software
24  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  */
26
27 /*
28  *  Todo: Add disklabel (or let OF do it ?). Eventually think about
29  *        fixing CDROM handling by directly using the ATAPI layer.
30  */
31
32 #include "ctype.h"
33 #include "types.h"
34 #include "stddef.h"
35 #include "stdlib.h"
36 #include "mac-part.h"
37 #include "fdisk-part.h"
38 #include "amiga-part.h"
39 #include "gpt-part.h"
40 #include "partition.h"
41 #include "prom.h"
42 #include "string.h"
43 #include "linux/iso_fs.h"
44 #include "debug.h"
45 #include "errors.h"
46 #include "bootinfo.h"
47 #include "byteorder.h"
48
49 /* We currently don't check the partition type, some users
50  * are putting crap there and still expect it to work...
51  */
52 #undef CHECK_FOR_VALID_MAC_PARTITION_TYPE
53
54 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
55 static const char *valid_mac_partition_types[] = {
56      "apple_unix_svr2",
57      "linux",
58      "apple_hfs",
59      "apple_boot",
60      "apple_bootstrap",
61      NULL
62 };
63 #endif
64
65
66 #define MAX_BLOCK_SIZE 4096
67 static unsigned char block_buffer[MAX_BLOCK_SIZE * 2];
68
69 static void
70 add_new_partition(struct partition_t**  list, int part_number, const char *part_type,
71                   const char *part_name, unsigned long long part_start, unsigned long long part_size,
72                   unsigned short part_blocksize, int sys_ind)
73 {
74      struct partition_t*        part;
75      part = (struct partition_t*)malloc(sizeof(struct partition_t));
76
77      part->part_number = part_number;
78      strncpy(part->part_type, part_type, MAX_PART_NAME);
79      strncpy(part->part_name, part_name, MAX_PART_NAME);
80      part->part_start = part_start;
81      part->part_size = part_size;
82      part->blocksize = part_blocksize;
83      part->sys_ind = sys_ind;
84
85      /* Tack this entry onto the list */
86      part->next = *list;
87      *list = part;
88 }
89
90 /* Note, we rely on partitions being dev-block-size aligned,
91  * I have to check if it's true. If it's not, then things will get
92  * a bit more complicated
93  */
94 static void
95 partition_mac_lookup( const char *dev_name, prom_handle disk,
96                       unsigned int prom_blksize, struct partition_t** list )
97 {
98      int block, map_size;
99
100      /* block_buffer contains block 0 from the partitions_lookup() stage */
101      struct mac_partition* part = (struct mac_partition *)block_buffer;
102      unsigned short ptable_block_size =
103           ((struct mac_driver_desc *)block_buffer)->block_size;
104
105      map_size = 1;
106      for (block=1; block < map_size + 1; block++)
107      {
108 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
109           int valid = 0;
110           const char *ptype;
111 #endif
112           if (prom_readblocks(disk, block, 1, block_buffer) != 1) {
113                prom_printf("Can't read partition %d\n", block);
114                break;
115           }
116           if (part->signature != MAC_PARTITION_MAGIC) {
117 #if 0
118                prom_printf("Wrong partition %d signature\n", block);
119 #endif
120                break;
121           }
122           if (block == 1)
123                map_size = part->map_count;
124
125 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
126           /* We don't bother looking at swap partitions of any type,
127            * and the rest are the ones we know about */
128           for (ptype = valid_mac_partition_types; ptype; ptype++)
129                if (!strcmp (part->type, ptype))
130                {
131                     valid = 1;
132                     break;
133                }
134 #if DEBUG
135           if (!valid)
136                prom_printf( "MAC: Unsupported partition #%d; type=%s\n",
137                             block, part->type );
138 #endif
139 #endif
140
141
142 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
143           if (valid)
144 #endif
145                /* We use the partition block size from the partition table.
146                 * The filesystem implmentations are responsible for mapping
147                 * to their own fs blocksize */
148                add_new_partition(
149                     list, /* partition list */
150                     block, /* partition number */
151                     part->type, /* type */
152                     part->name, /* name */
153                     part->start_block + part->data_start, /* start */
154                     part->data_count, /* size */
155                     ptable_block_size,
156                     0);
157      }
158 }
159
160 /*
161  * Same function as partition_mac_lookup(), except for fdisk
162  * partitioned disks.
163  */
164 static void
165 partition_fdisk_lookup( const char *dev_name, prom_handle disk,
166                         unsigned int prom_blksize, struct partition_t** list )
167 {
168      int partition;
169
170      /* fdisk partition tables start at offset 0x1be
171       * from byte 0 of the boot drive.
172       */
173      struct fdisk_partition* part =
174           (struct fdisk_partition *) (block_buffer + 0x1be);
175
176      for (partition=1; partition <= 4 ;partition++, part++) {
177           if (part->sys_ind == LINUX_NATIVE || part->sys_ind == LINUX_RAID) {
178                add_new_partition(  list,
179                                    partition,
180                                    "Linux", /* type */
181                                    '\0', /* name */
182                                    le32_to_cpu(*(unsigned int *)part->start4),
183                                    le32_to_cpu(*(unsigned int *)part->size4),
184                                    512 /*blksize*/,
185                                    part->sys_ind /* partition type */ );
186           }
187      }
188 }
189
190 /* GPT partition format */
191 static int gpt_magic_present(unsigned char *block_buffer, unsigned int prom_blksize)
192 {
193         struct gpt_header *header = (struct gpt_header *)(block_buffer + prom_blksize);
194         return cpu_to_le64(header->signature) == GPT_HEADER_SIGNATURE;
195 }
196
197 static inline int
198 guid_cmp (gpt_part_type_t left, gpt_part_type_t right)
199 {
200         return memcmp(&left, &right, sizeof (gpt_part_type_t));
201 }
202
203 static void partition_gpt_lookup(prom_handle disk, unsigned int prom_blksize,
204                                                         struct partition_t **list)
205 {
206         int partition;
207         struct gpt_header *header = (struct gpt_header *)(block_buffer + prom_blksize);
208
209         if (prom_readblocks(disk, cpu_to_le64(header->partitions), 1, block_buffer) != 1) {
210                 prom_printf("Can't read GPT partition table %Lu\n", header->partitions);
211                 return;
212         }
213         struct gpt_partition *part = (struct gpt_partition *)(block_buffer);
214
215         for (partition = 1; partition <= cpu_to_le32(header->maxpart); partition++, part++) {
216                 if ((!guid_cmp(part->type, GPT_BASIC_DATA))||(!guid_cmp(part->type, GPT_LINUX_NATIVE))||(!guid_cmp(part->type, GPT_LINUX_RAID))) {
217                         add_new_partition(list, partition, "Linux", 0, le64_to_cpu(part->start), \
218                                                 cpu_to_le64(part->end) - cpu_to_le64(part->start) + 1, \
219                                                 prom_blksize, 1);
220                 }
221         }
222 }
223
224
225 /* I don't know if it's possible to handle multisession and other multitrack
226  * stuffs with the current OF disklabel package. This can still be implemented
227  * with direct calls to atapi stuffs.
228  * Currently, we enter this code for any device of block size 0x2048 who lacks
229  * a MacOS partition map signature.
230  */
231 static int
232 identify_iso_fs(ihandle device, unsigned int *iso_root_block)
233 {
234      int block;
235
236      for (block = 16; block < 100; block++) {
237           struct iso_volume_descriptor  * vdp;
238
239           if (prom_readblocks(device, block, 1, block_buffer) != 1) {
240                prom_printf("Can't read volume desc block %d\n", block);
241                break;
242           }
243
244           vdp = (struct iso_volume_descriptor *)block_buffer;
245
246           /* Due to the overlapping physical location of the descriptors,
247            * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
248            * proper identification in this case, we first check for ISO.
249            */
250           if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
251                *iso_root_block = block;
252                return 1;
253           }
254      }
255
256      return 0;
257 }
258
259 /*
260  * Detects and read amiga partition tables.
261  */
262
263 static int
264 _amiga_checksum (unsigned int blk_size)
265 {
266         unsigned int sum;
267         int i, end;
268         unsigned int *amiga_block = (unsigned int *) block_buffer;
269
270         sum = amiga_block[0];
271         end = amiga_block[AMIGA_LENGTH];
272
273         if (end > blk_size) end = blk_size;
274
275         for (i = 1; i < end; i++) sum += amiga_block[i];
276
277         return sum;
278 }
279
280 static int
281 _amiga_find_rdb (const char *dev_name, prom_handle disk, unsigned int prom_blksize)
282 {
283         int i;
284         unsigned int *amiga_block = (unsigned int *) block_buffer;
285
286         for (i = 0; i<AMIGA_RDB_MAX; i++) {
287                 if (i != 0) {
288                         if (prom_readblocks(disk, i, 1, block_buffer) != 1) {
289                                 prom_printf("Can't read boot block %d\n", i);
290                                 break;
291                         }
292                 }
293                 if ((amiga_block[AMIGA_ID] == AMIGA_ID_RDB) && (_amiga_checksum (prom_blksize) == 0))
294                         return 1;
295         }
296         /* Amiga partition table not found, let's reread block 0 */
297         if (prom_readblocks(disk, 0, 1, block_buffer) != 1) {
298                 prom_printf("Can't read boot blocks\n");
299                 return 0; /* TODO: something bad happened, should fail more verbosely */
300         }
301         return 0;
302 }
303
304 static void
305 partition_amiga_lookup( const char *dev_name, prom_handle disk,
306                         unsigned int prom_blksize, struct partition_t** list )
307 {
308         int partition, part;
309         unsigned int blockspercyl;
310         unsigned int *amiga_block = (unsigned int *) block_buffer;
311         unsigned int *used = NULL;
312         unsigned int possible;
313         int checksum;
314         int i;
315
316         blockspercyl = amiga_block[AMIGA_SECT] * amiga_block[AMIGA_HEADS];
317         possible = amiga_block[AMIGA_RDBLIMIT]/32 +1;
318
319         used = (unsigned int *) malloc (sizeof (unsigned int) * (possible + 1));
320         if (!used) {
321                prom_printf("Can't allocate memory\n");
322                return;
323         }
324
325         for (i=0; i < possible; i++) used[i] = 0;
326
327
328         for (part = amiga_block[AMIGA_PARTITIONS], partition = 1;
329                 part != AMIGA_END;
330                 part = amiga_block[AMIGA_PART_NEXT], partition++)
331         {
332                 if (prom_readblocks(disk, part, 1, block_buffer) != 1) {
333                         prom_printf("Can't read partition block %d\n", part);
334                         break;
335                 }
336                 checksum = _amiga_checksum (prom_blksize);
337                 if ((amiga_block[AMIGA_ID] == AMIGA_ID_PART) &&
338                         (checksum == 0) &&
339                         ((used[part/32] & (0x1 << (part % 32))) == 0))
340                 {
341                         used[part/32] |= (0x1 << (part % 32));
342                 } else {
343                         prom_printf("Amiga partition table corrupted at block %d\n", part);
344                         if (amiga_block[AMIGA_ID] != AMIGA_ID_PART)
345                                 prom_printf ("block type is not partition but %08x\n", amiga_block[AMIGA_ID]);
346                         if (checksum != 0)
347                                 prom_printf ("block checsum is bad : %d\n", checksum);
348                         if ((used[part/32] & (0x1 << (part % 32))) != 0)
349                                 prom_printf ("partition table is looping, block %d already traveled\n", part);
350                         break;
351                 }
352
353                /* We use the partition block size from the partition table.
354                 * The filesystem implmentations are responsible for mapping
355                 * to their own fs blocksize */
356                add_new_partition(
357                     list, /* partition list */
358                     partition, /* partition number */
359                     "Linux", /* type */
360                     '\0', /* name */
361                     blockspercyl * amiga_block[AMIGA_PART_LOWCYL], /* start */
362                     blockspercyl * (amiga_block[AMIGA_PART_HIGHCYL] - amiga_block[AMIGA_PART_LOWCYL] + 1), /* size */
363                     prom_blksize,
364                     0 );
365         }
366         if (used)
367                 free(used);
368 }
369
370 struct partition_t*
371 partitions_lookup(const char *device)
372 {
373      ihandle    disk;
374      struct mac_driver_desc *desc = (struct mac_driver_desc *)block_buffer;
375      struct partition_t* list = NULL;
376      unsigned int prom_blksize, iso_root_block;
377
378      strncpy((char *)block_buffer, device, 2040);
379      if (_machine != _MACH_bplan)
380           strcat((char *)block_buffer, ":0");
381
382      /* Open device */
383      disk = prom_open((char *)block_buffer);
384      if (disk == NULL) {
385           prom_printf("Can't open device <%s>\n", block_buffer);
386           goto bail;
387      }
388      prom_blksize = prom_getblksize(disk);
389      DEBUG_F("block size of device is %d\n", prom_blksize);
390
391      if (prom_blksize <= 1)
392           prom_blksize = 512;
393      if (prom_blksize > MAX_BLOCK_SIZE) {
394           prom_printf("block_size %d not supported !\n", prom_blksize);
395           goto bail;
396      }
397
398      /* Read boot blocks */
399      if (prom_readblocks(disk, 0, 2, block_buffer) != 1) {
400           prom_printf("Can't read boot blocks\n");
401           goto bail;
402      }
403      if (desc->signature == MAC_DRIVER_MAGIC) {
404           /* pdisk partition format */
405           partition_mac_lookup(device, disk, prom_blksize, &list);
406      } else if (gpt_magic_present(block_buffer, prom_blksize)) {
407           /* gpt partition format */
408           partition_gpt_lookup(disk, prom_blksize, &list);
409      } else if ((block_buffer[510] == 0x55) && (block_buffer[511] == 0xaa)) {
410           /* fdisk partition format */
411           partition_fdisk_lookup(device, disk, prom_blksize, &list);
412      } else if (prom_blksize == 2048 && identify_iso_fs(disk, &iso_root_block)) {
413           add_new_partition(&list,
414                             0,
415                             '\0',
416                             '\0',
417                             iso_root_block,
418                             0,
419                             prom_blksize,
420                             0);
421           prom_printf("ISO9660 disk\n");
422      } else if (_amiga_find_rdb(device, disk, prom_blksize) != -1) {
423           /* amiga partition format */
424           partition_amiga_lookup(device, disk, prom_blksize, &list);
425      } else {
426           prom_printf("No supported partition table detected\n");
427           goto bail;
428      }
429
430 bail:
431      prom_close(disk);
432
433      return list;
434 }
435
436 char *
437 get_part_type(char *device, int partition)
438 {
439      struct partition_t*        parts;
440      struct partition_t*        p;
441      struct partition_t*        found;
442      char *type = NULL;
443
444      int device_kind = prom_get_devtype(device);
445      if (device_kind != FILE_DEVICE_BLOCK && device_kind != FILE_DEVICE_ISCSI)
446           return NULL;
447
448      parts = partitions_lookup(device);
449      found = NULL;
450
451      if (!parts)
452           return '\0';
453
454      for (p = parts; p && !found; p=p->next) {
455           DEBUG_F("number: %02d, start: 0x%08Lx, length: 0x%08Lx, type: %s, name: %s\n",
456                   p->part_number, p->part_start, p->part_size, p->part_type, p->part_name);
457           if ((partition >= 0) && (partition == p->part_number)) {
458                type = strdup(p->part_type);
459                break;
460           }
461      }
462      if (parts)
463           partitions_free(parts);
464      return type;
465 }
466
467 /* Freed in reverse order of allocation to help malloc'ator */
468 void
469 partitions_free(struct partition_t* list)
470 {
471      struct partition_t*        next;
472
473      while(list) {
474           next = list->next;
475           free(list);
476           list = next;
477      }
478 }
479
480
481 /*
482  * Local variables:
483  * c-file-style: "k&r"
484  * c-basic-offset: 5
485  * End:
486  */