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