source: grub-pc/trunk/fuentes/grub-core/osdep/devmapper/getroot.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: 7.0 KB
Line 
1/*
2 *  GRUB  --  GRand Unified Bootloader
3 *  Copyright (C) 1999,2000,2001,2002,2003,2006,2007,2008,2009,2010,2011,2012,2013  Free Software Foundation, Inc.
4 *
5 *  GRUB is free software: you can redistribute it and/or modify
6 *  it under the terms of the GNU General Public License as published by
7 *  the Free Software Foundation, either version 3 of the License, or
8 *  (at your option) any later version.
9 *
10 *  GRUB is distributed in the hope that it will be useful,
11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 *  GNU General Public License for more details.
14 *
15 *  You should have received a copy of the GNU General Public License
16 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
19#include <config-util.h>
20#include <config.h>
21
22#include <grub/emu/getroot.h>
23#include <grub/mm.h>
24
25#ifdef HAVE_DEVICE_MAPPER
26
27#include <sys/stat.h>
28#include <sys/types.h>
29#include <assert.h>
30#include <fcntl.h>
31#include <unistd.h>
32#include <string.h>
33#include <dirent.h>
34#include <errno.h>
35#include <error.h>
36#include <stdio.h>
37#include <stdlib.h>
38#include <stdint.h>
39#ifdef HAVE_LIMITS_H
40#include <limits.h>
41#endif
42
43#include <libdevmapper.h>
44
45#include <grub/types.h>
46#include <grub/util/misc.h>
47
48#include <grub/mm.h>
49#include <grub/misc.h>
50#include <grub/emu/misc.h>
51#include <grub/emu/hostdisk.h>
52
53static int
54grub_util_open_dm (const char *os_dev, struct dm_tree **tree,
55                   struct dm_tree_node **node)
56{
57  uint32_t maj, min;
58  struct stat st;
59
60  *node = NULL;
61  *tree = NULL;
62
63  if (stat (os_dev, &st) < 0)
64    return 0;
65
66  maj = major (st.st_rdev);
67  min = minor (st.st_rdev);
68
69  if (!dm_is_dm_major (maj))
70    return 0;
71
72  *tree = dm_tree_create ();
73  if (! *tree)
74    {
75      grub_puts_ (N_("Failed to create `device-mapper' tree"));
76      grub_dprintf ("hostdisk", "dm_tree_create failed\n");
77      return 0;
78    }
79
80  if (! dm_tree_add_dev (*tree, maj, min))
81    {
82      grub_dprintf ("hostdisk", "dm_tree_add_dev failed\n");
83      dm_tree_free (*tree);
84      *tree = NULL;
85      return 0;
86    }
87
88  *node = dm_tree_find_node (*tree, maj, min);
89  if (! *node)
90    {
91      grub_dprintf ("hostdisk", "dm_tree_find_node failed\n");
92      dm_tree_free (*tree);
93      *tree = NULL;
94      return 0;
95    }
96  return 1;
97}
98
99static char *
100get_dm_uuid (const char *os_dev)
101{
102  struct dm_tree *tree;
103  struct dm_tree_node *node;
104  const char *node_uuid;
105  char *ret;
106
107  if (!grub_util_open_dm (os_dev, &tree, &node))
108    return NULL;
109
110  node_uuid = dm_tree_node_get_uuid (node);
111  if (! node_uuid)
112    {
113      grub_dprintf ("hostdisk", "%s has no DM uuid\n", os_dev);
114      dm_tree_free (tree);
115      return NULL;
116    }
117
118  ret = grub_strdup (node_uuid);
119
120  dm_tree_free (tree);
121
122  return ret;
123}
124
125enum grub_dev_abstraction_types
126grub_util_get_dm_abstraction (const char *os_dev)
127{
128  char *uuid;
129
130  uuid = get_dm_uuid (os_dev);
131
132  if (uuid == NULL)
133    return GRUB_DEV_ABSTRACTION_NONE;
134
135  if (strncmp (uuid, "LVM-", 4) == 0)
136    {
137      grub_free (uuid);
138      return GRUB_DEV_ABSTRACTION_LVM;
139    }
140  if (strncmp (uuid, "CRYPT-LUKS1-", 4) == 0)
141    {
142      grub_free (uuid);
143      return GRUB_DEV_ABSTRACTION_LUKS;
144    }
145
146  grub_free (uuid);
147  return GRUB_DEV_ABSTRACTION_NONE;
148}
149
150void
151grub_util_pull_devmapper (const char *os_dev)
152{
153  struct dm_tree *tree;
154  struct dm_tree_node *node;
155  struct dm_tree_node *child;
156  void *handle = NULL;
157  char *lastsubdev = NULL;
158  char *uuid;
159
160  uuid = get_dm_uuid (os_dev);
161
162  if (!grub_util_open_dm (os_dev, &tree, &node))
163    return;
164
165  while ((child = dm_tree_next_child (&handle, node, 0)))
166    {
167      const struct dm_info *dm = dm_tree_node_get_info (child);
168      char *subdev;
169      if (!dm)
170        continue;
171      subdev = grub_find_device ("/dev", makedev (dm->major, dm->minor));
172      if (subdev)
173        {
174          lastsubdev = subdev;
175          grub_util_pull_device (subdev);
176        }
177    }
178  if (uuid && strncmp (uuid, "CRYPT-LUKS1-", sizeof ("CRYPT-LUKS1-") - 1) == 0
179      && lastsubdev)
180    {
181      char *grdev = grub_util_get_grub_dev (lastsubdev);
182      dm_tree_free (tree);
183      if (grdev)
184        {
185          grub_err_t err;
186          err = grub_cryptodisk_cheat_mount (grdev, os_dev);
187          if (err)
188            grub_util_error (_("can't mount encrypted volume `%s': %s"),
189                             lastsubdev, grub_errmsg);
190        }
191      grub_free (grdev);
192    }
193  else
194    dm_tree_free (tree);
195}
196
197char *
198grub_util_devmapper_part_to_disk (struct stat *st,
199                                  int *is_part, const char *path)
200{
201  int major, minor;
202
203  if (grub_util_get_dm_node_linear_info (st->st_rdev,
204                                         &major, &minor, 0))
205    {
206      *is_part = 1;
207      return grub_find_device ("/dev",
208                               (major << 8) | minor);
209    }
210  *is_part = 0;
211  return xstrdup (path);
212}
213
214char *
215grub_util_get_devmapper_grub_dev (const char *os_dev)
216{
217  char *uuid, *optr;
218  char *grub_dev;
219
220  uuid = get_dm_uuid (os_dev);
221  if (!uuid)
222    return NULL;
223 
224  if (strncmp (uuid, "LVM-", sizeof ("LVM-") - 1) == 0)
225    {
226        unsigned i;
227        int dashes[] = { 0, 6, 10, 14, 18, 22, 26, 32, 38, 42, 46, 50, 54, 58};
228        grub_dev = xmalloc (grub_strlen (uuid) + 40);
229        optr = grub_stpcpy (grub_dev, "lvmid/");
230        for (i = 0; i < ARRAY_SIZE (dashes) - 1; i++)
231          {
232            memcpy (optr, uuid + sizeof ("LVM-") - 1 + dashes[i],
233                    dashes[i+1] - dashes[i]);
234            optr += dashes[i+1] - dashes[i];
235            *optr++ = '-';
236          }
237        optr = stpcpy (optr, uuid + sizeof ("LVM-") - 1 + dashes[i]);
238        *optr = '\0';
239        grub_dev[sizeof("lvmid/xxxxxx-xxxx-xxxx-xxxx-xxxx-xxxx-xxxxxx") - 1]
240          = '/';
241        free (uuid);
242        return grub_dev;
243      }
244
245  if (strncmp (uuid, "CRYPT-LUKS1-", sizeof ("CRYPT-LUKS1-") - 1) == 0)
246    {
247      char *dash;
248      dash = grub_strchr (uuid + sizeof ("CRYPT-LUKS1-") - 1, '-');
249      if (dash)
250        *dash = 0;
251      grub_dev = grub_xasprintf ("cryptouuid/%s",
252                                 uuid + sizeof ("CRYPT-LUKS1-") - 1);
253      grub_free (uuid);
254      return grub_dev;
255    }
256  return NULL;
257}
258
259char *
260grub_util_get_vg_uuid (const char *os_dev)
261{
262  char *uuid, *vgid;
263  int dashes[] = { 0, 6, 10, 14, 18, 22, 26, 32};
264  unsigned i;
265  char *optr;
266
267  uuid = get_dm_uuid (os_dev);
268  if (!uuid)
269    return NULL;
270
271  vgid = xmalloc (grub_strlen (uuid));
272  optr = vgid;
273  for (i = 0; i < ARRAY_SIZE (dashes) - 1; i++)
274    {
275      memcpy (optr, uuid + sizeof ("LVM-") - 1 + dashes[i],
276              dashes[i+1] - dashes[i]);
277      optr += dashes[i+1] - dashes[i];
278      *optr++ = '-';
279    }
280  optr--;
281  *optr = '\0';
282  return vgid;
283}
284
285void
286grub_util_devmapper_cleanup (void)
287{
288  dm_lib_release ();
289}
290
291#else
292void
293grub_util_pull_devmapper (const char *os_dev __attribute__ ((unused)))
294{
295  return;
296}
297
298void
299grub_util_devmapper_cleanup (void)
300{
301}
302
303enum grub_dev_abstraction_types
304grub_util_get_dm_abstraction (const char *os_dev __attribute__ ((unused)))
305{
306  return GRUB_DEV_ABSTRACTION_NONE;
307}
308
309char *
310grub_util_get_vg_uuid (const char *os_dev __attribute__ ((unused)))
311{
312  return NULL;
313}
314
315char *
316grub_util_devmapper_part_to_disk (struct stat *st __attribute__ ((unused)),
317                                  int *is_part __attribute__ ((unused)),
318                                  const char *os_dev __attribute__ ((unused)))
319{
320  return NULL;
321}
322
323char *
324grub_util_get_devmapper_grub_dev (const char *os_dev __attribute__ ((unused)))
325{
326  return NULL;
327}
328
329#endif
Note: See TracBrowser for help on using the repository browser.