git.ozlabs.org Git - petitboot/blob - discover/grub2-parser.c

   1 /*
   2  *  Copyright Geoff Levand <geoff@infradead.org>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; version 2 of the License.
   7  *
   8  *  This program is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *  GNU General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public License
  14  *  along with this program; if not, write to the Free Software
  15  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 #if defined(HAVE_CONFIG_H)
  19 #include "config.h"
  20 #endif
  21
  22 #define _GNU_SOURCE
  23
  24 #include <assert.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "log/log.h"
  29 #include "talloc/talloc.h"
  30 #include "types/types.h"
  31 #include "parser-conf.h"
  32 #include "parser-utils.h"
  33 #include "paths.h"
  34 #include "resource.h"
  35
  36 struct grub2_root {
  37         char *uuid;
  38 };
  39
  40 struct grub2_state {
  41         struct discover_boot_option *opt;
  42         char *desc_image;
  43         char *desc_initrd;
  44         const char *const *known_names;
  45         struct grub2_root *root;
  46 };
  47
  48 struct grub2_resource_info {
  49         struct grub2_root *root;
  50         char *path;
  51 };
  52
  53 /* we use slightly different resources for grub2 */
  54 static struct resource *create_grub2_resource(void *ctx,
  55                 struct discover_device *orig_device,
  56                 struct grub2_root *root, const char *path)
  57 {
  58         struct grub2_resource_info *info;
  59         struct resource *res;
  60
  61         res = talloc(ctx, struct resource);
  62
  63         if (root) {
  64                 info = talloc(res, struct grub2_resource_info);
  65                 info->root = root;
  66                 talloc_reference(info, root);
  67                 info->path = talloc_strdup(info, path);
  68
  69                 res->resolved = false;
  70                 res->info = info;
  71
  72         } else
  73                 resolve_resource_against_device(res, orig_device, path);
  74
  75         return res;
  76 }
  77
  78 static bool resolve_grub2_resource(struct device_handler *handler,
  79                 struct resource *res)
  80 {
  81         struct grub2_resource_info *info = res->info;
  82         struct discover_device *dev;
  83
  84         assert(!res->resolved);
  85
  86         dev = device_lookup_by_uuid(handler, info->root->uuid);
  87
  88         if (!dev)
  89                 return false;
  90
  91         resolve_resource_against_device(res, dev, info->path);
  92         talloc_free(info);
  93
  94         return true;
  95 }
  96
  97 static void grub2_finish(struct conf_context *conf)
  98 {
  99         struct device *dev = conf->dc->device->device;
 100         struct grub2_state *state = conf->parser_info;
 101         struct boot_option *opt;
 102
 103         if (!state->desc_image) {
 104                 pb_log("%s: %s: no image found\n", __func__, dev->id);
 105                 return;
 106         }
 107
 108         assert(state->opt);
 109         opt = state->opt->option;
 110
 111         assert(opt);
 112         assert(opt->name);
 113         assert(opt->boot_args);
 114
 115         opt->description = talloc_asprintf(opt, "%s %s %s",
 116                 state->desc_image,
 117                 (state->desc_initrd ? state->desc_initrd : ""),
 118                 opt->boot_args);
 119
 120         talloc_free(state->desc_initrd);
 121         state->desc_initrd = NULL;
 122
 123         conf_strip_str(opt->boot_args);
 124         conf_strip_str(opt->description);
 125
 126         /* opt is persistent, so must be associated with device */
 127
 128         discover_context_add_boot_option(conf->dc, state->opt);
 129
 130         state->opt = NULL;
 131 }
 132
 133 static void grub2_process_pair(struct conf_context *conf, const char *name,
 134                 char *value)
 135 {
 136         struct device *dev = conf->dc->device->device;
 137         struct grub2_state *state = conf->parser_info;
 138         struct discover_boot_option *opt = state->opt;
 139
 140         if (!name || !conf_param_in_list(state->known_names, name))
 141                 return;
 142
 143         if (streq(name, "menuentry")) {
 144                 /* complete any existing option... */
 145                 if (state->opt)
 146                         grub2_finish(conf);
 147
 148                 /* ... then start the new one */
 149                 opt = discover_boot_option_create(conf->dc, conf->dc->device);
 150                 opt->option->boot_args = talloc_strdup(opt->option, "");
 151
 152                 value = strtok(value, "\'{\"");
 153
 154                 opt->option->id = talloc_asprintf(opt->option,
 155                                         "%s#%s", dev->id, value);
 156                 opt->option->name = talloc_strdup(opt->option, value);
 157                 opt->option->boot_args = talloc_strdup(opt, "");
 158
 159                 state->opt = opt;
 160
 161                 return;
 162         }
 163
 164         if (streq(name, "linux") || streq(name, "linux16")) {
 165                 char *sep;
 166
 167                 sep = strchr(value, ' ');
 168
 169                 if (sep)
 170                         *sep = 0;
 171
 172                 opt->boot_image = create_grub2_resource(opt, conf->dc->device,
 173                                         state->root, value);
 174                 state->desc_image = talloc_strdup(opt, value);
 175
 176                 if (sep)
 177                         opt->option->boot_args = talloc_strdup(opt, sep + 1);
 178
 179                 return;
 180         }
 181
 182         if (streq(name, "initrd")) {
 183                 opt->initrd = create_grub2_resource(opt, conf->dc->device,
 184                                         state->root, value);
 185                 state->desc_initrd = talloc_asprintf(state, "initrd=%s",
 186                         value);
 187                 return;
 188         }
 189
 190         if (streq(name, "search")) {
 191                 struct grub2_root *root;
 192                 char *uuid;
 193
 194                 if (!strstr(value, "--set=root")) {
 195                         pb_log("%s: no root\n", __func__);
 196                         return;
 197                 }
 198
 199                 /* The UUID should be the last argument to the search command.
 200                  * FIXME: this is a little fragile; would be nice to have some
 201                  * parser helpers to deal with "command args" parsing
 202                  */
 203                 uuid = strrchr(value, ' ');
 204                 if (!uuid)
 205                         return;
 206
 207                 uuid++;
 208                 pb_log("%s: uuid %s\n", __func__, uuid);
 209
 210                 if (state->root)
 211                         talloc_unlink(state, state->root);
 212
 213                 root = talloc(state, struct grub2_root);
 214                 root->uuid = talloc_strdup(root, uuid);
 215                 state->root = root;
 216                 return;
 217         }
 218
 219         pb_log("%s: unknown name: %s\n", __func__, name);
 220 }
 221
 222 static const char *const grub2_conf_files[] = {
 223         "/grub.cfg",
 224         "/menu.lst",
 225         "/grub/grub.cfg",
 226         "/grub2/grub.cfg",
 227         "/grub/menu.lst",
 228         "/boot/grub/grub.cfg",
 229         "/boot/grub/menu.lst",
 230         "/GRUB.CFG",
 231         "/MENU.LST",
 232         "/GRUB/GRUB.CFG",
 233         "/GRUB2/GRUB.CFG",
 234         "/GRUB/MENU.LST",
 235         "/BOOT/GRUB/GRUB.CFG",
 236         "/BOOT/GRUB/MENU.LST",
 237         NULL
 238 };
 239
 240 static const char *grub2_known_names[] = {
 241         "menuentry",
 242         "linux",
 243         "linux16",
 244         "initrd",
 245         "search",
 246         NULL
 247 };
 248
 249 static int grub2_parse(struct discover_context *dc, char *buf, int len)
 250 {
 251         struct conf_context *conf;
 252         struct grub2_state *state;
 253
 254         conf = talloc_zero(dc, struct conf_context);
 255
 256         if (!conf)
 257                 return 0;
 258
 259         conf->dc = dc;
 260         conf_init_global_options(conf);
 261         conf->get_pair = conf_get_pair_space;
 262         conf->process_pair = grub2_process_pair;
 263         conf->finish = grub2_finish;
 264         conf->parser_info = state = talloc_zero(conf, struct grub2_state);
 265
 266         state->known_names = grub2_known_names;
 267
 268         conf_parse_buf(conf, buf, len);
 269
 270         talloc_free(conf);
 271         return 1;
 272 }
 273
 274 static struct parser grub2_parser = {
 275         .name                   = "grub2",
 276         .method                 = CONF_METHOD_LOCAL_FILE,
 277         .parse                  = grub2_parse,
 278         .filenames              = grub2_conf_files,
 279         .resolve_resource       = resolve_grub2_resource,
 280 };
 281
 282 register_parser(grub2_parser);