← Back to branch summary

~ubuntu-branches/ubuntu/trusty/grub2/trusty-updates

« back to all changes in this revision

Viewing changes to partmap/amiga.c

Tags: upstream-1.99~20101122
Import upstream version 1.99~20101122

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
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
 
  return grub_asprintf ("%d", p->index + 1);
188
 
}
189
 
 
190
 
 
191
 
/* Partition map type.  */
192
 
static struct grub_partition_map grub_amiga_partition_map =
193
 
  {
194
 
    .name = "part_amiga",
195
 
    .iterate = amiga_partition_map_iterate,
196
 
    .probe = amiga_partition_map_probe,
197
 
    .get_name = amiga_partition_map_get_name
198
 
  };
199
 
 
200
 
GRUB_MOD_INIT(amiga_partition_map)
201
 
{
202
 
  grub_partition_map_register (&grub_amiga_partition_map);
203
 
}
204
 
 
205
 
GRUB_MOD_FINI(amiga_partition_map)
206
 
{
207
 
  grub_partition_map_unregister (&grub_amiga_partition_map);
208
 
}