source: grub-pc/trunk/fuentes/grub-core/partmap/gpt.c @ 22

Last change on this file since 22 was 22, checked in by mabarracus, 4 years ago

updated version and apply net.ifnames=0 into debian/rules

File size: 6.3 KB
Line 
1/* gpt.c - Read GUID Partition Tables (GPT).  */
2/*
3 *  GRUB  --  GRand Unified Bootloader
4 *  Copyright (C) 2002,2005,2006,2007,2008  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#include <grub/msdos_partition.h>
26#include <grub/gpt_partition.h>
27#include <grub/i18n.h>
28
29GRUB_MOD_LICENSE ("GPLv3+");
30
31static grub_uint8_t grub_gpt_magic[8] =
32  {
33    0x45, 0x46, 0x49, 0x20, 0x50, 0x41, 0x52, 0x54
34  };
35
36static const grub_gpt_part_type_t grub_gpt_partition_type_empty = GRUB_GPT_PARTITION_TYPE_EMPTY;
37
38#ifdef GRUB_UTIL
39static const grub_gpt_part_type_t grub_gpt_partition_type_bios_boot = GRUB_GPT_PARTITION_TYPE_BIOS_BOOT;
40#endif
41
42/* 512 << 7 = 65536 byte sectors.  */
43#define MAX_SECTOR_LOG 7
44
45static struct grub_partition_map grub_gpt_partition_map;
46
47
48
49grub_err_t
50grub_gpt_partition_map_iterate (grub_disk_t disk,
51                                grub_partition_iterate_hook_t hook,
52                                void *hook_data)
53{
54  struct grub_partition part;
55  struct grub_gpt_header gpt;
56  struct grub_gpt_partentry entry;
57  struct grub_msdos_partition_mbr mbr;
58  grub_uint64_t entries;
59  unsigned int i;
60  int last_offset = 0;
61  int sector_log = 0;
62
63  /* Read the protective MBR.  */
64  if (grub_disk_read (disk, 0, 0, sizeof (mbr), &mbr))
65    return grub_errno;
66
67  /* Check if it is valid.  */
68  if (mbr.signature != grub_cpu_to_le16 (GRUB_PC_PARTITION_SIGNATURE))
69    return grub_error (GRUB_ERR_BAD_PART_TABLE, "no signature");
70
71  /* Make sure the MBR is a protective MBR and not a normal MBR.  */
72  for (i = 0; i < 4; i++)
73    if (mbr.entries[i].type == GRUB_PC_PARTITION_TYPE_GPT_DISK)
74      break;
75  if (i == 4)
76    return grub_error (GRUB_ERR_BAD_PART_TABLE, "no GPT partition map found");
77
78  /* Read the GPT header.  */
79  for (sector_log = 0; sector_log < MAX_SECTOR_LOG; sector_log++)
80    {
81      if (grub_disk_read (disk, 1 << sector_log, 0, sizeof (gpt), &gpt))
82        return grub_errno;
83
84      if (grub_memcmp (gpt.magic, grub_gpt_magic, sizeof (grub_gpt_magic)) == 0)
85        break;
86    }
87  if (sector_log == MAX_SECTOR_LOG)
88    return grub_error (GRUB_ERR_BAD_PART_TABLE, "no valid GPT header");
89
90  grub_dprintf ("gpt", "Read a valid GPT header\n");
91
92  entries = grub_le_to_cpu64 (gpt.partitions) << sector_log;
93  for (i = 0; i < grub_le_to_cpu32 (gpt.maxpart); i++)
94    {
95      if (grub_disk_read (disk, entries, last_offset,
96                          sizeof (entry), &entry))
97        return grub_errno;
98
99      if (grub_memcmp (&grub_gpt_partition_type_empty, &entry.type,
100                       sizeof (grub_gpt_partition_type_empty)))
101        {
102          /* Calculate the first block and the size of the partition.  */
103          part.start = grub_le_to_cpu64 (entry.start) << sector_log;
104          part.len = (grub_le_to_cpu64 (entry.end)
105                      - grub_le_to_cpu64 (entry.start) + 1)  << sector_log;
106          part.offset = entries;
107          part.number = i;
108          part.index = last_offset;
109          part.partmap = &grub_gpt_partition_map;
110          part.parent = disk->partition;
111
112          grub_dprintf ("gpt", "GPT entry %d: start=%lld, length=%lld\n", i,
113                        (unsigned long long) part.start,
114                        (unsigned long long) part.len);
115
116          if (hook (disk, &part, hook_data))
117            return grub_errno;
118        }
119
120      last_offset += grub_le_to_cpu32 (gpt.partentry_size);
121      if (last_offset == GRUB_DISK_SECTOR_SIZE)
122        {
123          last_offset = 0;
124          entries++;
125        }
126    }
127
128  return GRUB_ERR_NONE;
129}
130
131#ifdef GRUB_UTIL
132/* Context for gpt_partition_map_embed.  */
133struct gpt_partition_map_embed_ctx
134{
135  grub_disk_addr_t start, len;
136};
137
138/* Helper for gpt_partition_map_embed.  */
139static int
140find_usable_region (grub_disk_t disk __attribute__ ((unused)),
141                    const grub_partition_t p, void *data)
142{
143  struct gpt_partition_map_embed_ctx *ctx = data;
144  struct grub_gpt_partentry gptdata;
145  grub_partition_t p2;
146
147  p2 = disk->partition;
148  disk->partition = p->parent;
149  if (grub_disk_read (disk, p->offset, p->index,
150                      sizeof (gptdata), &gptdata))
151    {
152      disk->partition = p2;
153      return 0;
154    }
155  disk->partition = p2;
156
157  /* If there's an embed region, it is in a dedicated partition.  */
158  if (! grub_memcmp (&gptdata.type, &grub_gpt_partition_type_bios_boot, 16))
159    {
160      ctx->start = p->start;
161      ctx->len = p->len;
162      return 1;
163    }
164
165  return 0;
166}
167
168static grub_err_t
169gpt_partition_map_embed (struct grub_disk *disk, unsigned int *nsectors,
170                         unsigned int max_nsectors,
171                         grub_embed_type_t embed_type,
172                         grub_disk_addr_t **sectors)
173{
174  struct gpt_partition_map_embed_ctx ctx = {
175    .start = 0,
176    .len = 0
177  };
178  unsigned i;
179  grub_err_t err;
180
181  if (embed_type != GRUB_EMBED_PCBIOS)
182    return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
183                       "GPT currently supports only PC-BIOS embedding");
184
185  err = grub_gpt_partition_map_iterate (disk, find_usable_region, &ctx);
186  if (err)
187    return err;
188
189  if (ctx.len == 0)
190    return grub_error (GRUB_ERR_FILE_NOT_FOUND,
191                       N_("this GPT partition label contains no BIOS Boot Partition;"
192                          " embedding won't be possible"));
193
194  if (ctx.len < *nsectors)
195    return grub_error (GRUB_ERR_OUT_OF_RANGE,
196                       N_("your BIOS Boot Partition is too small;"
197                          " embedding won't be possible"));
198
199  *nsectors = ctx.len;
200  if (*nsectors > max_nsectors)
201    *nsectors = max_nsectors;
202  *sectors = grub_malloc (*nsectors * sizeof (**sectors));
203  if (!*sectors)
204    return grub_errno;
205  for (i = 0; i < *nsectors; i++)
206    (*sectors)[i] = ctx.start + i;
207
208  return GRUB_ERR_NONE;
209}
210#endif
211
212
213/* Partition map type.  */
214static struct grub_partition_map grub_gpt_partition_map =
215  {
216    .name = "gpt",
217    .iterate = grub_gpt_partition_map_iterate,
218#ifdef GRUB_UTIL
219    .embed = gpt_partition_map_embed
220#endif
221  };
222
223GRUB_MOD_INIT(part_gpt)
224{
225  grub_partition_map_register (&grub_gpt_partition_map);
226}
227
228GRUB_MOD_FINI(part_gpt)
229{
230  grub_partition_map_unregister (&grub_gpt_partition_map);
231}
Note: See TracBrowser for help on using the repository browser.