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 #ifndef GRUB_UTIL
  71 static grub_dl_t my_mod;
  72 #endif
  73
  74 \f
  75
  76 static grub_err_t
  77 amiga_partition_map_iterate (grub_disk_t disk,
  78                              int (*hook) (grub_disk_t disk,
  79                                           const grub_partition_t partition))
  80 {
  81   struct grub_partition part;
  82   struct grub_amiga_rdsk rdsk;
  83   struct grub_disk raw;
  84   int partno = 0;
  85   int next = -1;
  86   unsigned pos;
  87
  88   /* Enforce raw disk access.  */
  89   raw = *disk;
  90   raw.partition = 0;
  91
  92   /* The RDSK block is one of the first 15 blocks.  */
  93   for (pos = 0; pos < 15; pos++)
  94     {
  95       /* Read the RDSK block which is a descriptor for the entire disk.  */
  96       if (grub_disk_read (&raw, pos, 0, sizeof (rdsk), (char *) &rdsk))
  97         return grub_errno;
  98
  99       if (grub_strcmp ((char *) rdsk.magic, "RDSK") == 0)
 100         {
 101           /* Found the first PART block.  */
 102           next = grub_be_to_cpu32 (rdsk.partitionlst);
 103           break;
 104         }
 105     }
 106
 107   if (next == -1)
 108     return grub_error (GRUB_ERR_BAD_PART_TABLE,
 109                        "Amiga partition map not found.");
 110
 111   /* The end of the partition list is marked using "-1".  */
 112   while (next != -1)
 113     {
 114       struct grub_amiga_partition apart;
 115
 116       /* Read the RDSK block which is a descriptor for the entire disk.  */
 117       if (grub_disk_read (&raw, next, 0, sizeof (apart), (char *) &apart))
 118         return grub_errno;
 119
 120       /* Calculate the first block and the size of the partition.  */
 121       part.start = (grub_be_to_cpu32 (apart.lowcyl)
 122                     * grub_be_to_cpu32 (apart.heads)
 123                     * grub_be_to_cpu32 (apart.block_per_track));
 124       part.len = ((grub_be_to_cpu32 (apart.highcyl)
 125                    - grub_be_to_cpu32 (apart.lowcyl) + 1)
 126                   * grub_be_to_cpu32 (apart.heads)
 127                   * grub_be_to_cpu32 (apart.block_per_track));
 128
 129       part.offset = (grub_off_t) next * 512;
 130       part.index = partno;
 131       part.partmap = &grub_amiga_partition_map;
 132
 133       if (hook (disk, &part))
 134         return grub_errno;
 135
 136       next = grub_be_to_cpu32 (apart.next);
 137       partno++;
 138     }
 139
 140   return 0;
 141 }
 142
 143
 144 static grub_partition_t
 145 amiga_partition_map_probe (grub_disk_t disk, const char *str)
 146 {
 147   grub_partition_t p = 0;
 148   int partnum = 0;
 149   char *s = (char *) str;
 150
 151   auto int find_func (grub_disk_t d, const grub_partition_t partition);
 152
 153   int find_func (grub_disk_t d __attribute__ ((unused)),
 154                  const grub_partition_t partition)
 155     {
 156       if (partnum == partition->index)
 157         {
 158           p = (grub_partition_t) grub_malloc (sizeof (*p));
 159           if (! p)
 160             return 1;
 161
 162           grub_memcpy (p, partition, sizeof (*p));
 163           return 1;
 164         }
 165
 166       return 0;
 167     }
 168
 169   /* Get the partition number.  */
 170   partnum = grub_strtoul (s, 0, 10) - 1;
 171   if (grub_errno)
 172     {
 173       grub_error (GRUB_ERR_BAD_FILENAME, "invalid partition");
 174       return 0;
 175     }
 176
 177   if (amiga_partition_map_iterate (disk, find_func))
 178     goto fail;
 179
 180   return p;
 181
 182  fail:
 183   grub_free (p);
 184   return 0;
 185 }
 186
 187
 188 static char *
 189 amiga_partition_map_get_name (const grub_partition_t p)
 190 {
 191   char *name;
 192
 193   name = grub_malloc (13);
 194   if (! name)
 195     return 0;
 196
 197   grub_sprintf (name, "%d", p->index + 1);
 198   return name;
 199 }
 200
 201 \f
 202 /* Partition map type.  */
 203 static struct grub_partition_map grub_amiga_partition_map =
 204   {
 205     .name = "amiga_partition_map",
 206     .iterate = amiga_partition_map_iterate,
 207     .probe = amiga_partition_map_probe,
 208     .get_name = amiga_partition_map_get_name
 209   };
 210
 211 GRUB_MOD_INIT(amiga_partition_map)
 212 {
 213   grub_partition_map_register (&grub_amiga_partition_map);
 214 #ifndef GRUB_UTIL
 215   my_mod = mod;
 216 #endif
 217 }
 218
 219 GRUB_MOD_FINI(amiga_partition_map)
 220 {
 221   grub_partition_map_unregister (&grub_amiga_partition_map);
 222 }