partmap/amiga.c

   1 /* amiga.c - Read amiga partition tables (RDB).  */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2002,2004,2005,2006,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/dl.h>
  25
  26 struct grub_amiga_rdsk
  27 {
  28   /* "RDSK".  */
  29   grub_uint8_t magic[4];
  30   grub_uint32_t size;
  31   grub_int32_t checksum;
  32   grub_uint32_t scsihost;
  33   grub_uint32_t blksz;
  34   grub_uint32_t flags;
  35   grub_uint32_t badblcklst;
  36   grub_uint32_t partitionlst;
  37   grub_uint32_t fslst;
  38
  39   /* The other information is not important for us.  */
  40 } __attribute__ ((packed));
  41
  42 struct grub_amiga_partition
  43 {
  44   /* "PART".  */
  45   grub_uint8_t magic[4];
  46   grub_int32_t size;
  47   grub_int32_t checksum;
  48   grub_uint32_t scsihost;
  49   grub_uint32_t next;
  50   grub_uint32_t flags;
  51   grub_uint32_t unused1[2];
  52   grub_uint32_t devflags;
  53   grub_uint8_t namelen;
  54   grub_uint8_t name[31];
  55   grub_uint32_t unused2[15];
  56
  57   grub_uint32_t unused3[3];
  58   grub_uint32_t heads;
  59   grub_uint32_t unused4;
  60   grub_uint32_t block_per_track;
  61   grub_uint32_t unused5[3];
  62   grub_uint32_t lowcyl;
  63   grub_uint32_t highcyl;
  64
  65   grub_uint32_t firstcyl;
  66 } __attribute__ ((packed));
  67
  68 static struct grub_partition_map grub_amiga_partition_map;
  69
  70 \f
  71
  72 static grub_err_t
  73 amiga_partition_map_iterate (grub_disk_t disk,
  74                              int (*hook) (grub_disk_t disk,
  75                                           const grub_partition_t partition))
  76 {
  77   struct grub_partition part;
  78   struct grub_amiga_rdsk rdsk;
  79   struct grub_disk raw;
  80   int partno = 0;
  81   int next = -1;
  82   unsigned pos;
  83
  84   /* Enforce raw disk access.  */
  85   raw = *disk;
  86   raw.partition = 0;
  87
  88   /* The RDSK block is one of the first 15 blocks.  */
  89   for (pos = 0; pos < 15; pos++)
  90     {
  91       /* Read the RDSK block which is a descriptor for the entire disk.  */
  92       if (grub_disk_read (&raw, pos, 0, sizeof (rdsk), &rdsk))
  93         return grub_errno;
  94
  95       if (grub_strcmp ((char *) rdsk.magic, "RDSK") == 0)
  96         {
  97           /* Found the first PART block.  */
  98           next = grub_be_to_cpu32 (rdsk.partitionlst);
  99           break;
 100         }
 101     }
 102
 103   if (next == -1)
 104     return grub_error (GRUB_ERR_BAD_PART_TABLE,
 105                        "Amiga partition map not found.");
 106
 107   /* The end of the partition list is marked using "-1".  */
 108   while (next != -1)
 109     {
 110       struct grub_amiga_partition apart;
 111
 112       /* Read the RDSK block which is a descriptor for the entire disk.  */
 113       if (grub_disk_read (&raw, next, 0, sizeof (apart), &apart))
 114         return grub_errno;
 115
 116       /* Calculate the first block and the size of the partition.  */
 117       part.start = (grub_be_to_cpu32 (apart.lowcyl)
 118                     * grub_be_to_cpu32 (apart.heads)
 119                     * grub_be_to_cpu32 (apart.block_per_track));
 120       part.len = ((grub_be_to_cpu32 (apart.highcyl)
 121                    - grub_be_to_cpu32 (apart.lowcyl) + 1)
 122                   * grub_be_to_cpu32 (apart.heads)
 123                   * grub_be_to_cpu32 (apart.block_per_track));
 124
 125       part.offset = (grub_off_t) next * 512;
 126       part.index = partno;
 127       part.partmap = &grub_amiga_partition_map;
 128
 129       if (hook (disk, &part))
 130         return grub_errno;
 131
 132       next = grub_be_to_cpu32 (apart.next);
 133       partno++;
 134     }
 135
 136   return 0;
 137 }
 138
 139
 140 static grub_partition_t
 141 amiga_partition_map_probe (grub_disk_t disk, const char *str)
 142 {
 143   grub_partition_t p = 0;
 144   int partnum = 0;
 145   char *s = (char *) str;
 146
 147   auto int find_func (grub_disk_t d, const grub_partition_t partition);
 148
 149   int find_func (grub_disk_t d __attribute__ ((unused)),
 150                  const grub_partition_t partition)
 151     {
 152       if (partnum == partition->index)
 153         {
 154           p = (grub_partition_t) grub_malloc (sizeof (*p));
 155           if (! p)
 156             return 1;
 157
 158           grub_memcpy (p, partition, sizeof (*p));
 159           return 1;
 160         }
 161
 162       return 0;
 163     }
 164
 165   /* Get the partition number.  */
 166   partnum = grub_strtoul (s, 0, 10) - 1;
 167   if (grub_errno)
 168     {
 169       grub_error (GRUB_ERR_BAD_FILENAME, "invalid partition");
 170       return 0;
 171     }
 172
 173   if (amiga_partition_map_iterate (disk, find_func))
 174     goto fail;
 175
 176   return p;
 177
 178  fail:
 179   grub_free (p);
 180   return 0;
 181 }
 182
 183
 184 static char *
 185 amiga_partition_map_get_name (const grub_partition_t p)
 186 {
 187   char *name;
 188
 189   name = grub_malloc (13);
 190   if (! name)
 191     return 0;
 192
 193   grub_sprintf (name, "%d", p->index + 1);
 194   return name;
 195 }
 196
 197 \f
 198 /* Partition map type.  */
 199 static struct grub_partition_map grub_amiga_partition_map =
 200   {
 201     .name = "amiga_partition_map",
 202     .iterate = amiga_partition_map_iterate,
 203     .probe = amiga_partition_map_probe,
 204     .get_name = amiga_partition_map_get_name
 205   };
 206
 207 GRUB_MOD_INIT(amiga_partition_map)
 208 {
 209   grub_partition_map_register (&grub_amiga_partition_map);
 210 }
 211
 212 GRUB_MOD_FINI(amiga_partition_map)
 213 {
 214   grub_partition_map_unregister (&grub_amiga_partition_map);
 215 }