partmap/acorn.c

   1 /* acorn.c - Read Linux/ADFS partition tables.  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2005,2007  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/disk.h>
  21 #include <grub/misc.h>
  22 #include <grub/mm.h>
  23 #include <grub/partition.h>
  24 #include <grub/acorn_filecore.h>
  25
  26 #define LINUX_NATIVE_MAGIC grub_cpu_to_le32 (0xdeafa1de)
  27 #define LINUX_SWAP_MAGIC   grub_cpu_to_le32 (0xdeafab1e)
  28 #define LINUX_MAP_ENTRIES  (512 / 12)
  29
  30 #define NONADFS_PARTITION_TYPE_LINUX 9
  31 #define NONADFS_PARTITION_TYPE_MASK 15
  32
  33 struct grub_acorn_boot_block
  34 {
  35   grub_uint8_t misc[0x1C0];
  36   struct grub_filecore_disc_record disc_record;
  37   grub_uint8_t flags;
  38   grub_uint16_t start_cylinder;
  39   grub_uint8_t checksum;
  40 } __attribute__ ((packed, aligned));
  41
  42 struct linux_part
  43 {
  44   grub_uint32_t magic;
  45   grub_uint32_t start;
  46   grub_uint32_t size;
  47 };
  48
  49 static struct grub_partition_map grub_acorn_partition_map;
  50
  51 static grub_err_t
  52 acorn_partition_map_find (grub_disk_t disk, struct linux_part *m,
  53                           grub_disk_addr_t *sector)
  54 {
  55   struct grub_acorn_boot_block boot;
  56   grub_err_t err;
  57   unsigned int checksum = 0;
  58   unsigned int heads;
  59   unsigned int sectors_per_cylinder;
  60   int i;
  61
  62   err = grub_disk_read (disk, 0xC00 / GRUB_DISK_SECTOR_SIZE, 0,
  63                         sizeof (struct grub_acorn_boot_block),
  64                         &boot);
  65   if (err)
  66     return err;
  67
  68   if ((boot.flags & NONADFS_PARTITION_TYPE_MASK) != NONADFS_PARTITION_TYPE_LINUX)
  69     goto fail;
  70
  71   for (i = 0; i != 0x1ff; ++i)
  72     checksum = (checksum & 0xff) + (checksum >> 8) + boot.misc[i];
  73
  74   if ((grub_uint8_t) checksum != boot.checksum)
  75     goto fail;
  76
  77   heads = (boot.disc_record.heads
  78                     + ((boot.disc_record.lowsector >> 6) & 1));
  79   sectors_per_cylinder = boot.disc_record.secspertrack * heads;
  80   *sector = grub_le_to_cpu16 (boot.start_cylinder) * sectors_per_cylinder;
  81
  82   return grub_disk_read (disk, *sector, 0,
  83                          sizeof (struct linux_part) * LINUX_MAP_ENTRIES,
  84                          m);
  85
  86 fail:
  87   return grub_error (GRUB_ERR_BAD_PART_TABLE,
  88                      "Linux/ADFS partition map not found.");
  89
  90 }
  91
  92
  93 static grub_err_t
  94 acorn_partition_map_iterate (grub_disk_t disk,
  95                              int (*hook) (grub_disk_t disk,
  96                                           const grub_partition_t partition))
  97 {
  98   struct grub_partition part;
  99   struct grub_disk raw;
 100   struct linux_part map[LINUX_MAP_ENTRIES];
 101   int i;
 102   grub_disk_addr_t sector;
 103   grub_err_t err;
 104
 105   /* Enforce raw disk access.  */
 106   raw = *disk;
 107   raw.partition = 0;
 108
 109   err = acorn_partition_map_find (&raw, map, &sector);
 110   if (err)
 111     return err;
 112
 113   part.partmap = &grub_acorn_partition_map;
 114
 115   for (i = 0; i != LINUX_MAP_ENTRIES; ++i)
 116     {
 117       if (map[i].magic != LINUX_NATIVE_MAGIC
 118           && map[i].magic != LINUX_SWAP_MAGIC)
 119         return GRUB_ERR_NONE;
 120
 121       part.start = sector + map[i].start;
 122       part.len = map[i].size;
 123       part.offset = 6;
 124       part.index = i;
 125
 126       if (hook (disk, &part))
 127         return grub_errno;
 128     }
 129
 130   return GRUB_ERR_NONE;
 131 }
 132
 133
 134 static grub_partition_t
 135 acorn_partition_map_probe (grub_disk_t disk, const char *str)
 136 {
 137   struct linux_part map[LINUX_MAP_ENTRIES];
 138   struct grub_disk raw = *disk;
 139   unsigned long partnum = grub_strtoul (str, 0, 10) - 1;
 140   grub_disk_addr_t sector;
 141   grub_err_t err;
 142   grub_partition_t p;
 143
 144   /* Enforce raw disk access.  */
 145   raw.partition = 0;
 146
 147   /* Get the partition number.  */
 148   if (partnum > LINUX_MAP_ENTRIES)
 149     goto fail;
 150
 151   err = acorn_partition_map_find (&raw, map, &sector);
 152   if (err)
 153     return 0;
 154
 155   if (map[partnum].magic != LINUX_NATIVE_MAGIC
 156       && map[partnum].magic != LINUX_SWAP_MAGIC)
 157     goto fail;
 158
 159   p = grub_malloc (sizeof (struct grub_partition));
 160   if (! p)
 161     return 0;
 162
 163   p->start = sector + map[partnum].start;
 164   p->len = map[partnum].size;
 165   p->offset = 6;
 166   p->index = partnum;
 167   return p;
 168
 169 fail:
 170   grub_error (GRUB_ERR_BAD_FILENAME, "invalid partition");
 171   return 0;
 172 }
 173
 174
 175 static char *
 176 acorn_partition_map_get_name (const grub_partition_t p)
 177 {
 178   char *name;
 179
 180   name = grub_malloc (13);
 181   if (! name)
 182     return 0;
 183
 184   grub_sprintf (name, "%d", p->index + 1);
 185   return name;
 186 }
 187 \f
 188
 189 /* Partition map type.  */
 190 static struct grub_partition_map grub_acorn_partition_map =
 191 {
 192   .name = "part_acorn",
 193   .iterate = acorn_partition_map_iterate,
 194   .probe = acorn_partition_map_probe,
 195   .get_name = acorn_partition_map_get_name
 196 };
 197
 198 GRUB_MOD_INIT(acorn_partition_map)
 199 {
 200   grub_partition_map_register (&grub_acorn_partition_map);
 201 }
 202
 203 GRUB_MOD_FINI(acorn_partition_map)
 204 {
 205   grub_partition_map_unregister (&grub_acorn_partition_map);
 206 }