Magellan Linux

  • Back to homepage
    • /[magellan-source]/tags/grubby-8_37/grubby.c

    Diff of /tags/grubby-8_37/grubby.c

    Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

    revision 1859 by niro, Mon Jul 2 13:15:20 2012 UTC revision 2960 by niro, Wed Jun 29 14:07:59 2016 UTC
    # Line 36  Line 36 
    36  #include <signal.h>  #include <signal.h>
    37  #include <blkid/blkid.h>  #include <blkid/blkid.h>
    38    
    39    #include "log.h"
    40    
    41  #ifndef DEBUG  #ifndef DEBUG
    42  #define DEBUG 0  #define DEBUG 0
    43  #endif  #endif
    # Line 56  int debug = 0; /* Currently just for tem Line 58  int debug = 0; /* Currently just for tem
    58  #define NOOP_OPCODE 0x90  #define NOOP_OPCODE 0x90
    59  #define JMP_SHORT_OPCODE 0xeb  #define JMP_SHORT_OPCODE 0xeb
    60    
    61    int isEfi = 0;
    62    
    63    #if defined(__aarch64__)
    64    #define isEfiOnly 1
    65    #else
    66    #define isEfiOnly 0
    67    #endif
    68    
    69    char *saved_command_line = NULL;
    70    
    71  /* comments get lumped in with indention */  /* comments get lumped in with indention */
    72  struct lineElement {  struct lineElement {
    73      char * item;      char * item;
    # Line 82  enum lineType_e { Line 94  enum lineType_e {
    94      LT_MENUENTRY    = 1 << 17,      LT_MENUENTRY    = 1 << 17,
    95      LT_ENTRY_END    = 1 << 18,      LT_ENTRY_END    = 1 << 18,
    96      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    97      LT_UNKNOWN      = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    98        LT_INITRD_EFI   = 1 << 21,
    99        LT_KERNEL_16    = 1 << 22,
    100        LT_INITRD_16    = 1 << 23,
    101        LT_DEVTREE      = 1 << 24,
    102        LT_UNKNOWN      = 1 << 25,
    103  };  };
    104    
    105  struct singleLine {  struct singleLine {
    # Line 111  struct singleEntry { Line 128  struct singleEntry {
    128  #define NEED_ARGS    (1 << 3)  #define NEED_ARGS    (1 << 3)
    129  #define NEED_MB      (1 << 4)  #define NEED_MB      (1 << 4)
    130  #define NEED_END     (1 << 5)  #define NEED_END     (1 << 5)
    131    #define NEED_DEVTREE (1 << 6)
    132    
    133  #define MAIN_DEFAULT    (1 << 0)  #define MAIN_DEFAULT    (1 << 0)
    134  #define DEFAULT_SAVED       -2  #define DEFAULT_SAVED       -2
    # Line 128  struct configFileInfo; Line 146  struct configFileInfo;
    146  typedef const char *(*findConfigFunc)(struct configFileInfo *);  typedef const char *(*findConfigFunc)(struct configFileInfo *);
    147  typedef const int (*writeLineFunc)(struct configFileInfo *,  typedef const int (*writeLineFunc)(struct configFileInfo *,
    148   struct singleLine *line);   struct singleLine *line);
    149    typedef char *(*getEnvFunc)(struct configFileInfo *, char *name);
    150    typedef int (*setEnvFunc)(struct configFileInfo *, char *name, char *value);
    151    
    152  struct configFileInfo {  struct configFileInfo {
    153      char * defaultConfig;      char * defaultConfig;
    154      findConfigFunc findConfig;      findConfigFunc findConfig;
    155      writeLineFunc writeLine;      writeLineFunc writeLine;
    156        getEnvFunc getEnv;
    157        setEnvFunc setEnv;
    158      struct keywordTypes * keywords;      struct keywordTypes * keywords;
    159        int caseInsensitive;
    160      int defaultIsIndex;      int defaultIsIndex;
    161      int defaultIsVariable;      int defaultIsVariable;
    162      int defaultSupportSaved;      int defaultSupportSaved;
    163        int defaultIsSaved;
    164        int defaultIsUnquoted;
    165      enum lineType_e entryStart;      enum lineType_e entryStart;
    166      enum lineType_e entryEnd;      enum lineType_e entryEnd;
    167      int needsBootPrefix;      int needsBootPrefix;
    # Line 148  struct configFileInfo { Line 173  struct configFileInfo {
    173      int mbInitRdIsModule;      int mbInitRdIsModule;
    174      int mbConcatArgs;      int mbConcatArgs;
    175      int mbAllowExtraInitRds;      int mbAllowExtraInitRds;
    176        char *envFile;
    177  };  };
    178    
    179  struct keywordTypes grubKeywords[] = {  struct keywordTypes grubKeywords[] = {
    # Line 167  const char *grubFindConfig(struct config Line 193  const char *grubFindConfig(struct config
    193   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    194   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    195   "/etc/grub.conf",   "/etc/grub.conf",
    196     "/boot/grub2/grub.cfg",
    197     "/boot/grub2-efi/grub.cfg",
    198   NULL   NULL
    199      };      };
    200      static int i = -1;      static int i = -1;
    # Line 205  struct keywordTypes grub2Keywords[] = { Line 233  struct keywordTypes grub2Keywords[] = {
    233      { "default",    LT_DEFAULT,     ' ' },      { "default",    LT_DEFAULT,     ' ' },
    234      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    235      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    236        { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    237        { "linux16",    LT_KERNEL_16,   ' ' },
    238      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    239        { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    240        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    241      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    242      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    243        { "devicetree", LT_DEVTREE,  ' ' },
    244      { NULL, 0, 0 },      { NULL, 0, 0 },
    245  };  };
    246    
    # Line 219  const char *grub2FindConfig(struct confi Line 252  const char *grub2FindConfig(struct confi
    252      };      };
    253      static int i = -1;      static int i = -1;
    254      static const char *grub_cfg = "/boot/grub/grub.cfg";      static const char *grub_cfg = "/boot/grub/grub.cfg";
    255        int rc = -1;
    256    
    257      if (i == -1) {      if (i == -1) {
    258   for (i = 0; configFiles[i] != NULL; i++) {   for (i = 0; configFiles[i] != NULL; i++) {
    259      dbgPrintf("Checking \"%s\": ", configFiles[i]);      dbgPrintf("Checking \"%s\": ", configFiles[i]);
    260      if (!access(configFiles[i], R_OK)) {      if ((rc = access(configFiles[i], R_OK))) {
    261     if (errno == EACCES) {
    262        printf("Unable to access bootloader configuration file "
    263           "\"%s\": %m\n", configFiles[i]);
    264        exit(1);
    265     }
    266     continue;
    267        } else {
    268   dbgPrintf("found\n");   dbgPrintf("found\n");
    269   return configFiles[i];   return configFiles[i];
    270      }      }
    # Line 242  const char *grub2FindConfig(struct confi Line 283  const char *grub2FindConfig(struct confi
    283      return configFiles[i];      return configFiles[i];
    284  }  }
    285    
    286    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
    287    static char *grub2GetEnv(struct configFileInfo *info, char *name)
    288    {
    289        static char buf[1025];
    290        char *s = NULL;
    291        char *ret = NULL;
    292        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    293        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    294    
    295        if (rc < 0)
    296     return NULL;
    297    
    298        FILE *f = popen(s, "r");
    299        if (!f)
    300     goto out;
    301    
    302        memset(buf, '\0', sizeof (buf));
    303        ret = fgets(buf, 1024, f);
    304        pclose(f);
    305    
    306        if (ret) {
    307     ret += strlen(name) + 1;
    308     ret[strlen(ret) - 1] = '\0';
    309        }
    310        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
    311    out:
    312        free(s);
    313        return ret;
    314    }
    315    
    316    static int sPopCount(const char *s, const char *c)
    317    {
    318        int ret = 0;
    319        if (!s)
    320     return -1;
    321        for (int i = 0; s[i] != '\0'; i++)
    322     for (int j = 0; c[j] != '\0'; j++)
    323        if (s[i] == c[j])
    324     ret++;
    325        return ret;
    326    }
    327    
    328    static char *shellEscape(const char *s)
    329    {
    330        int l = strlen(s) + sPopCount(s, "'") * 2;
    331    
    332        char *ret = calloc(l+1, sizeof (*ret));
    333        if (!ret)
    334     return NULL;
    335        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
    336     if (s[i] == '\'')
    337        ret[j++] = '\\';
    338     ret[j] = s[i];
    339        }
    340        return ret;
    341    }
    342    
    343    static void unquote(char *s)
    344    {
    345        int l = strlen(s);
    346    
    347        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
    348     memmove(s, s+1, l-2);
    349     s[l-2] = '\0';
    350        }
    351    }
    352    
    353    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
    354    {
    355        char *s = NULL;
    356        int rc = 0;
    357        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    358    
    359        unquote(value);
    360        value = shellEscape(value);
    361        if (!value)
    362        return -1;
    363    
    364        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    365        free(value);
    366        if (rc <0)
    367     return -1;
    368    
    369        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
    370        rc = system(s);
    371        free(s);
    372        return rc;
    373    }
    374    
    375    /* this is a gigantic hack to avoid clobbering grub2 variables... */
    376    static int is_special_grub2_variable(const char *name)
    377    {
    378        if (!strcmp(name,"\"${next_entry}\""))
    379     return 1;
    380        if (!strcmp(name,"\"${prev_saved_entry}\""))
    381     return 1;
    382        return 0;
    383    }
    384    
    385  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
    386    int count = 0;    int count = 0;
    387    
    # Line 271  static int isquote(char q) Line 411  static int isquote(char q)
    411      return 0;      return 0;
    412  }  }
    413    
    414    static int iskernel(enum lineType_e type) {
    415        return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    416    }
    417    
    418    static int isinitrd(enum lineType_e type) {
    419        return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    420    }
    421    
    422  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    423      char * current;      char * current;
    424      char * current_indent;      char * current_indent;
    # Line 328  char *grub2ExtractTitle(struct singleLin Line 476  char *grub2ExtractTitle(struct singleLin
    476    
    477  struct configFileInfo grub2ConfigType = {  struct configFileInfo grub2ConfigType = {
    478      .findConfig = grub2FindConfig,      .findConfig = grub2FindConfig,
    479        .getEnv = grub2GetEnv,
    480        .setEnv = grub2SetEnv,
    481      .keywords = grub2Keywords,      .keywords = grub2Keywords,
    482      .defaultIsIndex = 1,      .defaultIsIndex = 1,
    483      .defaultSupportSaved = 1,      .defaultSupportSaved = 1,
    # Line 482  struct configFileInfo ziplConfigType = { Line 632  struct configFileInfo ziplConfigType = {
    632  struct configFileInfo extlinuxConfigType = {  struct configFileInfo extlinuxConfigType = {
    633      .defaultConfig = "/boot/extlinux/extlinux.conf",      .defaultConfig = "/boot/extlinux/extlinux.conf",
    634      .keywords = extlinuxKeywords,      .keywords = extlinuxKeywords,
    635        .caseInsensitive = 1,
    636      .entryStart = LT_TITLE,      .entryStart = LT_TITLE,
    637      .needsBootPrefix = 1,      .needsBootPrefix = 1,
    638      .maxTitleLength = 255,      .maxTitleLength = 255,
    639      .mbAllowExtraInitRds = 1,      .mbAllowExtraInitRds = 1,
    640        .defaultIsUnquoted = 1,
    641  };  };
    642    
    643  struct grubConfig {  struct grubConfig {
    # Line 506  struct singleEntry * findEntryByIndex(st Line 658  struct singleEntry * findEntryByIndex(st
    658  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
    659       const char * path, const char * prefix,       const char * path, const char * prefix,
    660       int * index);       int * index);
    661    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    662          int * index);
    663  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
    664  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
    665  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
    # Line 570  static char * sdupprintf(const char *for Line 724  static char * sdupprintf(const char *for
    724      return buf;      return buf;
    725  }  }
    726    
    727    static enum lineType_e preferredLineType(enum lineType_e type,
    728     struct configFileInfo *cfi) {
    729        if (isEfi && cfi == &grub2ConfigType) {
    730     switch (type) {
    731     case LT_KERNEL:
    732        return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    733     case LT_INITRD:
    734        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    735     default:
    736        return type;
    737     }
    738    #if defined(__i386__) || defined(__x86_64__)
    739        } else if (cfi == &grub2ConfigType) {
    740     switch (type) {
    741     case LT_KERNEL:
    742        return LT_KERNEL_16;
    743     case LT_INITRD:
    744        return LT_INITRD_16;
    745     default:
    746        return type;
    747     }
    748    #endif
    749        }
    750        return type;
    751    }
    752    
    753  static struct keywordTypes * getKeywordByType(enum lineType_e type,  static struct keywordTypes * getKeywordByType(enum lineType_e type,
    754        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    755      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
    # Line 603  static char * getuuidbydev(char *device) Line 783  static char * getuuidbydev(char *device)
    783  static enum lineType_e getTypeByKeyword(char * keyword,  static enum lineType_e getTypeByKeyword(char * keyword,
    784   struct configFileInfo * cfi) {   struct configFileInfo * cfi) {
    785      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
    786   if (!strcmp(keyword, kw->key))   if (cfi->caseInsensitive) {
    787      return kw->type;      if (!strcasecmp(keyword, kw->key))
    788                    return kw->type;
    789     } else {
    790        if (!strcmp(keyword, kw->key))
    791            return kw->type;
    792     }
    793      }      }
    794      return LT_UNKNOWN;      return LT_UNKNOWN;
    795  }  }
    # Line 643  static int isEntryStart(struct singleLin Line 828  static int isEntryStart(struct singleLin
    828  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    829  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct singleLine * line) {
    830      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it (leaks a byte) */
    831      char * title;      char * title = NULL;
    832      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
    833      title++;   title = strdup(line->elements[0].item);
    834      *(title + strlen(title) - 1) = '\0';   title++;
    835     *(title + strlen(title) - 1) = '\0';
    836        } else if (line->type == LT_MENUENTRY)
    837     title = strdup(line->elements[1].item);
    838        else
    839     return NULL;
    840      return title;      return title;
    841  }  }
    842    
    # Line 904  static int getNextLine(char ** bufPtr, s Line 1094  static int getNextLine(char ** bufPtr, s
    1094      return 0;      return 0;
    1095  }  }
    1096    
    1097    static int isnumber(const char *s)
    1098    {
    1099        int i;
    1100        for (i = 0; s[i] != '\0'; i++)
    1101     if (s[i] < '0' || s[i] > '9')
    1102        return 0;
    1103        return i;
    1104    }
    1105    
    1106  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1107        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1108      int in;      int in;
    # Line 918  static struct grubConfig * readConfig(co Line 1117  static struct grubConfig * readConfig(co
    1117      int len;      int len;
    1118      char * buf;      char * buf;
    1119    
    1120      if (!strcmp(inName, "-")) {      if (inName == NULL) {
    1121            printf("Could not find bootloader configuration\n");
    1122            exit(1);
    1123        } else if (!strcmp(inName, "-")) {
    1124   in = 0;   in = 0;
    1125      } else {      } else {
    1126   if ((in = open(inName, O_RDONLY)) < 0) {   if ((in = open(inName, O_RDONLY)) < 0) {
    # Line 985  static struct grubConfig * readConfig(co Line 1187  static struct grubConfig * readConfig(co
    1187      dbgPrintf("\n");      dbgPrintf("\n");
    1188      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    1189      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
    1190      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
    1191        !is_special_grub2_variable(line->elements[2].item)) {
    1192   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
    1193   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1194   defaultLine = line;   defaultLine = line;
    1195      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1196    
    1197          } else if (line->type == LT_KERNEL) {          } else if (iskernel(line->type)) {
    1198      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    1199       * lines came earlier in the template, make sure to use LT_HYPER       * lines came earlier in the template, make sure to use LT_HYPER
    1200       * instead of LT_KERNEL now       * instead of LT_KERNEL now
    1201       */       */
    1202      if (entry->multiboot)      if (entry && entry->multiboot)
    1203   line->type = LT_HYPER;   line->type = LT_HYPER;
    1204    
    1205          } else if (line->type == LT_MBMODULE) {          } else if (line->type == LT_MBMODULE) {
    # Line 1011  static struct grubConfig * readConfig(co Line 1211  static struct grubConfig * readConfig(co
    1211      for (struct singleLine *l = entry->lines; l; l = l->next) {      for (struct singleLine *l = entry->lines; l; l = l->next) {
    1212   if (l->type == LT_HYPER)   if (l->type == LT_HYPER)
    1213      break;      break;
    1214   else if (l->type == LT_KERNEL) {   else if (iskernel(l->type)) {
    1215      l->type = LT_HYPER;      l->type = LT_HYPER;
    1216      break;      break;
    1217   }   }
    # Line 1025  static struct grubConfig * readConfig(co Line 1225  static struct grubConfig * readConfig(co
    1225      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1226      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1227    
    1228   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1229      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1230        /* make the title/default a single argument (undoing our parsing) */
    1231      len = 0;      len = 0;
    1232      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1233   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1133  static struct grubConfig * readConfig(co Line 1334  static struct grubConfig * readConfig(co
    1334      }      }
    1335   }   }
    1336    
    1337     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1338        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1339        defaultLine = line;
    1340     }
    1341    
    1342   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1343     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1344     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1190  static struct grubConfig * readConfig(co Line 1396  static struct grubConfig * readConfig(co
    1396          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
    1397      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
    1398      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
    1399      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
    1400     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
    1401     if (cfg->cfi->getEnv) {
    1402        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1403        if (defTitle) {
    1404     int index = 0;
    1405     if (isnumber(defTitle)) {
    1406        index = atoi(defTitle);
    1407        entry = findEntryByIndex(cfg, index);
    1408     } else {
    1409        entry = findEntryByTitle(cfg, defTitle, &index);
    1410     }
    1411     if (entry)
    1412        cfg->defaultImage = index;
    1413        }
    1414     }
    1415   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
    1416      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
    1417      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
    # Line 1231  static struct grubConfig * readConfig(co Line 1452  static struct grubConfig * readConfig(co
    1452          cfg->defaultImage = -1;          cfg->defaultImage = -1;
    1453      }      }
    1454   }   }
    1455        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
    1456     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1457     if (defTitle) {
    1458        int index = 0;
    1459        if (isnumber(defTitle)) {
    1460     index = atoi(defTitle);
    1461     entry = findEntryByIndex(cfg, index);
    1462        } else {
    1463     entry = findEntryByTitle(cfg, defTitle, &index);
    1464        }
    1465        if (entry)
    1466     cfg->defaultImage = index;
    1467     }
    1468      } else {      } else {
    1469          cfg->defaultImage = 0;          cfg->defaultImage = 0;
    1470      }      }
    # Line 1248  static void writeDefault(FILE * out, cha Line 1482  static void writeDefault(FILE * out, cha
    1482    
    1483      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
    1484   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
    1485      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
    1486   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
    1487      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
    1488        char *title;
    1489        entry = findEntryByIndex(cfg, cfg->defaultImage);
    1490        line = getLineByType(LT_MENUENTRY, entry->lines);
    1491        if (!line)
    1492     line = getLineByType(LT_TITLE, entry->lines);
    1493        if (line) {
    1494     title = extractTitle(line);
    1495     if (title)
    1496        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1497        }
    1498     }
    1499        } else if (cfg->defaultImage > -1) {
    1500   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
    1501      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
    1502          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
    # Line 1310  static int writeConfig(struct grubConfig Line 1556  static int writeConfig(struct grubConfig
    1556    
    1557      /* most likely the symlink is relative, so change our      /* most likely the symlink is relative, so change our
    1558         directory to the dir of the symlink */         directory to the dir of the symlink */
    1559              rc = chdir(dirname(outName));      char *dir = strdupa(outName);
    1560        rc = chdir(dirname(dir));
    1561      do {      do {
    1562   buf = alloca(len + 1);   buf = alloca(len + 1);
    1563   rc = readlink(basename(outName), buf, len);   rc = readlink(basename(outName), buf, len);
    # Line 1352  static int writeConfig(struct grubConfig Line 1599  static int writeConfig(struct grubConfig
    1599      while (line) {      while (line) {
    1600          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
    1601   line->numElements == 3 &&   line->numElements == 3 &&
    1602   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
    1603     !is_special_grub2_variable(line->elements[2].item)) {
    1604      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
    1605      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
    1606   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
    # Line 1497  static char *findDiskForRoot() Line 1745  static char *findDiskForRoot()
    1745      return NULL;      return NULL;
    1746  }  }
    1747    
    1748  void printEntry(struct singleEntry * entry) {  void printEntry(struct singleEntry * entry, FILE *f) {
    1749      int i;      int i;
    1750      struct singleLine * line;      struct singleLine * line;
    1751    
    1752      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    1753   fprintf(stderr, "DBG: %s", line->indent);   log_message(f, "DBG: %s", line->indent);
    1754   for (i = 0; i < line->numElements; i++) {   for (i = 0; i < line->numElements; i++) {
    1755      /* Need to handle this, because we strip the quotes from      /* Need to handle this, because we strip the quotes from
    1756       * menuentry when read it. */       * menuentry when read it. */
    1757      if (line->type == LT_MENUENTRY && i == 1) {      if (line->type == LT_MENUENTRY && i == 1) {
    1758   if(!isquote(*line->elements[i].item))   if(!isquote(*line->elements[i].item))
    1759      fprintf(stderr, "\'%s\'", line->elements[i].item);      log_message(f, "\'%s\'", line->elements[i].item);
    1760   else   else
    1761      fprintf(stderr, "%s", line->elements[i].item);      log_message(f, "%s", line->elements[i].item);
    1762   fprintf(stderr, "%s", line->elements[i].indent);   log_message(f, "%s", line->elements[i].indent);
    1763    
    1764   continue;   continue;
    1765      }      }
    1766            
    1767      fprintf(stderr, "%s%s",      log_message(f, "%s%s",
    1768      line->elements[i].item, line->elements[i].indent);      line->elements[i].item, line->elements[i].indent);
    1769   }   }
    1770   fprintf(stderr, "\n");   log_message(f, "\n");
    1771      }      }
    1772  }  }
    1773    
    1774  void notSuitablePrintf(struct singleEntry * entry, const char *fmt, ...)  void notSuitablePrintf(struct singleEntry * entry, int okay, const char *fmt, ...)
    1775  {  {
    1776      va_list argp;      static int once;
    1777        va_list argp, argq;
    1778    
    1779        va_start(argp, fmt);
    1780    
    1781        va_copy(argq, argp);
    1782        if (!once) {
    1783     log_time(NULL);
    1784     log_message(NULL, "command line: %s\n", saved_command_line);
    1785        }
    1786        log_message(NULL, "DBG: Image entry %s: ", okay ? "succeeded" : "failed");
    1787        log_vmessage(NULL, fmt, argq);
    1788    
    1789        printEntry(entry, NULL);
    1790        va_end(argq);
    1791    
    1792      if (!debug)      if (!debug) {
    1793     once = 1;
    1794         va_end(argp);
    1795   return;   return;
    1796        }
    1797    
    1798      va_start(argp, fmt);      if (okay) {
    1799     va_end(argp);
    1800     return;
    1801        }
    1802    
    1803        if (!once)
    1804     log_message(stderr, "DBG: command line: %s\n", saved_command_line);
    1805        once = 1;
    1806      fprintf(stderr, "DBG: Image entry failed: ");      fprintf(stderr, "DBG: Image entry failed: ");
    1807      vfprintf(stderr, fmt, argp);      vfprintf(stderr, fmt, argp);
    1808      printEntry(entry);      printEntry(entry, stderr);
    1809      va_end(argp);      va_end(argp);
    1810  }  }
    1811    
    # Line 1560  int suitableImage(struct singleEntry * e Line 1832  int suitableImage(struct singleEntry * e
    1832      char * rootdev;      char * rootdev;
    1833    
    1834      if (skipRemoved && entry->skip) {      if (skipRemoved && entry->skip) {
    1835   notSuitablePrintf(entry, "marked to skip\n");   notSuitablePrintf(entry, 0, "marked to skip\n");
    1836   return 0;   return 0;
    1837      }      }
    1838    
    1839      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1840      if (!line) {      if (!line) {
    1841   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1842   return 0;   return 0;
    1843      }      }
    1844      if (line->numElements < 2) {      if (line->numElements < 2) {
    1845   notSuitablePrintf(entry, "line has only %d elements\n",   notSuitablePrintf(entry, 0, "line has only %d elements\n",
    1846      line->numElements);      line->numElements);
    1847   return 0;   return 0;
    1848      }      }
    1849    
    1850      if (flags & GRUBBY_BADIMAGE_OKAY) return 1;      if (flags & GRUBBY_BADIMAGE_OKAY) {
    1851        notSuitablePrintf(entry, 1, "\n");
    1852        return 1;
    1853        }
    1854    
    1855      fullName = alloca(strlen(bootPrefix) +      fullName = alloca(strlen(bootPrefix) +
    1856        strlen(line->elements[1].item) + 1);        strlen(line->elements[1].item) + 1);
    # Line 1586  int suitableImage(struct singleEntry * e Line 1861  int suitableImage(struct singleEntry * e
    1861      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",      sprintf(fullName, "%s%s%s", bootPrefix, hasslash ? "" : "/",
    1862              line->elements[1].item + rootspec_offset);              line->elements[1].item + rootspec_offset);
    1863      if (access(fullName, R_OK)) {      if (access(fullName, R_OK)) {
    1864   notSuitablePrintf(entry, "access to %s failed\n", fullName);   notSuitablePrintf(entry, 0, "access to %s failed\n", fullName);
    1865   return 0;   return 0;
    1866      }      }
    1867      for (i = 2; i < line->numElements; i++)      for (i = 2; i < line->numElements; i++)
    # Line 1607  int suitableImage(struct singleEntry * e Line 1882  int suitableImage(struct singleEntry * e
    1882    
    1883              /* failed to find one */              /* failed to find one */
    1884              if (!line) {              if (!line) {
    1885   notSuitablePrintf(entry, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1886   return 0;   return 0;
    1887              }              }
    1888    
    # Line 1616  int suitableImage(struct singleEntry * e Line 1891  int suitableImage(struct singleEntry * e
    1891      if (i < line->numElements)      if (i < line->numElements)
    1892          dev = line->elements[i].item + 5;          dev = line->elements[i].item + 5;
    1893      else {      else {
    1894   notSuitablePrintf(entry, "no root= entry found\n");   notSuitablePrintf(entry, 0, "no root= entry found\n");
    1895   /* it failed too...  can't find root= */   /* it failed too...  can't find root= */
    1896          return 0;          return 0;
    1897              }              }
    # Line 1625  int suitableImage(struct singleEntry * e Line 1900  int suitableImage(struct singleEntry * e
    1900    
    1901      dev = getpathbyspec(dev);      dev = getpathbyspec(dev);
    1902      if (!getpathbyspec(dev)) {      if (!getpathbyspec(dev)) {
    1903          notSuitablePrintf(entry, "can't find blkid entry for %s\n", dev);          notSuitablePrintf(entry, 0, "can't find blkid entry for %s\n", dev);
    1904          return 0;          return 0;
    1905      } else      } else
    1906   dev = getpathbyspec(dev);   dev = getpathbyspec(dev);
    1907    
    1908      rootdev = findDiskForRoot();      rootdev = findDiskForRoot();
    1909      if (!rootdev) {      if (!rootdev) {
    1910          notSuitablePrintf(entry, "can't find root device\n");          notSuitablePrintf(entry, 0, "can't find root device\n");
    1911   return 0;   return 0;
    1912      }      }
    1913    
    1914      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {      if (!getuuidbydev(rootdev) || !getuuidbydev(dev)) {
    1915          notSuitablePrintf(entry, "uuid missing: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid missing: rootdev %s, dev %s\n",
    1916   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1917          free(rootdev);          free(rootdev);
    1918          return 0;          return 0;
    1919      }      }
    1920    
    1921      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {      if (strcmp(getuuidbydev(rootdev), getuuidbydev(dev))) {
    1922          notSuitablePrintf(entry, "uuid mismatch: rootdev %s, dev %s\n",          notSuitablePrintf(entry, 0, "uuid mismatch: rootdev %s, dev %s\n",
    1923   getuuidbydev(rootdev), getuuidbydev(dev));   getuuidbydev(rootdev), getuuidbydev(dev));
    1924   free(rootdev);   free(rootdev);
    1925          return 0;          return 0;
    1926      }      }
    1927    
    1928      free(rootdev);      free(rootdev);
    1929        notSuitablePrintf(entry, 1, "\n");
    1930    
    1931      return 1;      return 1;
    1932  }  }
    # Line 1684  struct singleEntry * findEntryByPath(str Line 1960  struct singleEntry * findEntryByPath(str
    1960   }   }
    1961    
    1962   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
    1963    
    1964   i = 0;   i = 0;
    1965   if (index) {   if (index) {
    1966      while (i < *index) i++;      while (i < *index) {
    1967      if (indexVars[i] == -1) return NULL;   i++;
    1968     if (indexVars[i] == -1) return NULL;
    1969        }
    1970   }   }
    1971    
    1972   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1973   if (!entry) return NULL;   if (!entry) return NULL;
    1974    
    1975   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1976   if (!line) return NULL;   if (!line) return NULL;
    1977    
    1978   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1743  struct singleEntry * findEntryByPath(str Line 2021  struct singleEntry * findEntryByPath(str
    2021    
    2022      /* check all the lines matching checkType */      /* check all the lines matching checkType */
    2023      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2024   line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?   enum lineType_e ct = checkType;
    2025       LT_KERNEL|LT_MBMODULE|LT_HYPER :   if (entry->multiboot && checkType == LT_KERNEL)
    2026       checkType, line);      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2027   if (!line) break;  /* not found in this entry */   else if (checkType & LT_KERNEL)
    2028        ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2029     line = getLineByType(ct, line);
    2030     if (!line)
    2031        break;  /* not found in this entry */
    2032    
    2033   if (line && line->type != LT_MENUENTRY &&   if (line && line->type != LT_MENUENTRY &&
    2034   line->numElements >= 2) {   line->numElements >= 2) {
    # Line 1765  struct singleEntry * findEntryByPath(str Line 2047  struct singleEntry * findEntryByPath(str
    2047       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2048       * unfortunate)       * unfortunate)
    2049       */       */
    2050      if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
    2051   break; /* found 'im! */   break; /* found 'im! */
    2052   }   }
    2053    
    # Line 1775  struct singleEntry * findEntryByPath(str Line 2057  struct singleEntry * findEntryByPath(str
    2057      return entry;      return entry;
    2058  }  }
    2059    
    2060    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    2061          int * index) {
    2062        struct singleEntry * entry;
    2063        struct singleLine * line;
    2064        int i;
    2065        char * newtitle;
    2066    
    2067        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
    2068     if (index && i < *index)
    2069        continue;
    2070     line = getLineByType(LT_TITLE, entry->lines);
    2071     if (!line)
    2072        line = getLineByType(LT_MENUENTRY, entry->lines);
    2073     if (!line)
    2074        continue;
    2075     newtitle = grub2ExtractTitle(line);
    2076     if (!newtitle)
    2077        continue;
    2078     if (!strcmp(title, newtitle))
    2079        break;
    2080        }
    2081    
    2082        if (!entry)
    2083     return NULL;
    2084    
    2085        if (index)
    2086     *index = i;
    2087        return entry;
    2088    }
    2089    
    2090  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
    2091      struct singleEntry * entry;      struct singleEntry * entry;
    2092    
    # Line 1797  struct singleEntry * findTemplate(struct Line 2109  struct singleEntry * findTemplate(struct
    2109      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
    2110      int index;      int index;
    2111    
    2112      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
    2113     if (cfg->cfi->getEnv) {
    2114        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2115        if (defTitle) {
    2116     int index = 0;
    2117     if (isnumber(defTitle)) {
    2118        index = atoi(defTitle);
    2119        entry = findEntryByIndex(cfg, index);
    2120     } else {
    2121        entry = findEntryByTitle(cfg, defTitle, &index);
    2122     }
    2123     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2124        cfg->defaultImage = index;
    2125        if (indexPtr)
    2126     *indexPtr = index;
    2127        return entry;
    2128     }
    2129        }
    2130     }
    2131        } else if (cfg->defaultImage > -1) {
    2132   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
    2133   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2134      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
    # Line 1951  void displayEntry(struct singleEntry * e Line 2282  void displayEntry(struct singleEntry * e
    2282      struct singleLine * line;      struct singleLine * line;
    2283      char * root = NULL;      char * root = NULL;
    2284      int i;      int i;
    2285        int j;
    2286    
    2287      printf("index=%d\n", index);      printf("index=%d\n", index);
    2288    
    2289      line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2290      if (!line) {      if (!line) {
    2291          printf("non linux entry\n");          printf("non linux entry\n");
    2292          return;          return;
    # Line 2019  void displayEntry(struct singleEntry * e Line 2351  void displayEntry(struct singleEntry * e
    2351   printf("root=%s\n", s);   printf("root=%s\n", s);
    2352      }      }
    2353    
    2354      line = getLineByType(LT_INITRD, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2355    
    2356      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2357   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2042  void displayEntry(struct singleEntry * e Line 2374  void displayEntry(struct singleEntry * e
    2374   if (title)   if (title)
    2375      printf("title=%s\n", title);      printf("title=%s\n", title);
    2376      }      }
    2377    
    2378        for (j = 0, line = entry->lines; line; line = line->next) {
    2379     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2380        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2381     printf("mbmodule%d=", j);
    2382        else
    2383     printf("mbmodule%d=%s", j, prefix);
    2384    
    2385        for (i = 1; i < line->numElements; i++)
    2386     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2387        printf("\n");
    2388        j++;
    2389     }
    2390        }
    2391  }  }
    2392    
    2393  int isSuseSystem(void) {  int isSuseSystem(void) {
    # Line 2420  struct singleLine * addLineTmpl(struct s Line 2766  struct singleLine * addLineTmpl(struct s
    2766  {  {
    2767      struct singleLine * newLine = lineDup(tmplLine);      struct singleLine * newLine = lineDup(tmplLine);
    2768    
    2769        if (isEfi && cfi == &grub2ConfigType) {
    2770     enum lineType_e old = newLine->type;
    2771     newLine->type = preferredLineType(newLine->type, cfi);
    2772     if (old != newLine->type)
    2773        newLine->elements[0].item = getKeyByType(newLine->type, cfi);
    2774        }
    2775    
    2776      if (val) {      if (val) {
    2777   /* override the inherited value with our own.   /* override the inherited value with our own.
    2778   * This is a little weak because it only applies to elements[1]   * This is a little weak because it only applies to elements[1]
    # Line 2429  struct singleLine * addLineTmpl(struct s Line 2782  struct singleLine * addLineTmpl(struct s
    2782   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2783    
    2784   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2785   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
    2786      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2787      if (rootspec != NULL) {      if (rootspec != NULL) {
    2788   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2466  struct singleLine *  addLine(struct sing Line 2819  struct singleLine *  addLine(struct sing
    2819      /* NB: This function shouldn't allocate items on the heap, rather on the      /* NB: This function shouldn't allocate items on the heap, rather on the
    2820       * stack since it calls addLineTmpl which will make copies.       * stack since it calls addLineTmpl which will make copies.
    2821       */       */
       
    2822      if (type == LT_TITLE && cfi->titleBracketed) {      if (type == LT_TITLE && cfi->titleBracketed) {
    2823   /* we're doing a bracketed title (zipl) */   /* we're doing a bracketed title (zipl) */
    2824   tmpl.type = type;   tmpl.type = type;
    # Line 2800  int updateActualImage(struct grubConfig Line 3152  int updateActualImage(struct grubConfig
    3152      firstElement = 2;      firstElement = 2;
    3153    
    3154   } else {   } else {
    3155      line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3156      if (!line) {      if (!line) {
    3157   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3158   continue;   continue;
    # Line 2956  int updateImage(struct grubConfig * cfg, Line 3308  int updateImage(struct grubConfig * cfg,
    3308      return rc;      return rc;
    3309  }  }
    3310    
    3311    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3312     const char * image, const char * prefix, const char * initrd,
    3313     const char * title) {
    3314        struct singleEntry * entry;
    3315        struct singleLine * line, * kernelLine, *endLine = NULL;
    3316        int index = 0;
    3317    
    3318        if (!image) return 0;
    3319    
    3320        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3321            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3322            if (!kernelLine) continue;
    3323    
    3324     /* if title is supplied, the entry's title must match it. */
    3325     if (title) {
    3326        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3327        char *linetitle = extractTitle(line);
    3328    
    3329        if (!linetitle)
    3330     continue;
    3331        if (strcmp(title, linetitle)) {
    3332     free(linetitle);
    3333     continue;
    3334        }
    3335        free(linetitle);
    3336     }
    3337    
    3338            if (prefix) {
    3339                int prefixLen = strlen(prefix);
    3340                if (!strncmp(initrd, prefix, prefixLen))
    3341                    initrd += prefixLen;
    3342            }
    3343     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3344     if (endLine)
    3345        removeLine(entry, endLine);
    3346            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3347     kernelLine->indent, initrd);
    3348            if (!line)
    3349        return 1;
    3350     if (endLine) {
    3351        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3352                if (!line)
    3353     return 1;
    3354     }
    3355    
    3356            break;
    3357        }
    3358    
    3359        return 0;
    3360    }
    3361    
    3362  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3363                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
    3364      struct singleEntry * entry;      struct singleEntry * entry;
    3365      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3366      int index = 0;      int index = 0;
    # Line 2965  int updateInitrd(struct grubConfig * cfg Line 3368  int updateInitrd(struct grubConfig * cfg
    3368      if (!image) return 0;      if (!image) return 0;
    3369    
    3370      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3371          kernelLine = getLineByType(LT_KERNEL, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3372          if (!kernelLine) continue;          if (!kernelLine) continue;
    3373    
    3374          line = getLineByType(LT_INITRD, entry->lines);   /* if title is supplied, the entry's title must match it. */
    3375     if (title) {
    3376        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3377        char *linetitle = extractTitle(line);
    3378    
    3379        if (!linetitle)
    3380     continue;
    3381        if (strcmp(title, linetitle)) {
    3382     free(linetitle);
    3383     continue;
    3384        }
    3385        free(linetitle);
    3386     }
    3387    
    3388            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3389          if (line)          if (line)
    3390              removeLine(entry, line);              removeLine(entry, line);
    3391          if (prefix) {          if (prefix) {
    # Line 2979  int updateInitrd(struct grubConfig * cfg Line 3396  int updateInitrd(struct grubConfig * cfg
    3396   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3397   if (endLine)   if (endLine)
    3398      removeLine(entry, endLine);      removeLine(entry, endLine);
    3399          line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);   enum lineType_e lt;
    3400     switch(kernelLine->type) {
    3401        case LT_KERNEL:
    3402            lt = LT_INITRD;
    3403     break;
    3404        case LT_KERNEL_EFI:
    3405            lt = LT_INITRD_EFI;
    3406     break;
    3407        case LT_KERNEL_16:
    3408            lt = LT_INITRD_16;
    3409     break;
    3410        default:
    3411            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3412     }
    3413            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3414          if (!line)          if (!line)
    3415      return 1;      return 1;
    3416   if (endLine) {   if (endLine) {
    # Line 3338  int addNewKernel(struct grubConfig * con Line 3769  int addNewKernel(struct grubConfig * con
    3769   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3770   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3771   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3772                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3773     const char * newDevTreePath) {
    3774      struct singleEntry * new;      struct singleEntry * new;
    3775      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3776      int needs;      int needs;
    # Line 3379  int addNewKernel(struct grubConfig * con Line 3811  int addNewKernel(struct grubConfig * con
    3811          needs |= NEED_MB;          needs |= NEED_MB;
    3812          new->multiboot = 1;          new->multiboot = 1;
    3813      }      }
    3814        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3815     needs |= NEED_DEVTREE;
    3816    
    3817      if (template) {      if (template) {
    3818   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3392  int addNewKernel(struct grubConfig * con Line 3826  int addNewKernel(struct grubConfig * con
    3826      while (*chptr && isspace(*chptr)) chptr++;      while (*chptr && isspace(*chptr)) chptr++;
    3827      if (*chptr == '#') continue;      if (*chptr == '#') continue;
    3828    
    3829      if (tmplLine->type == LT_KERNEL &&      if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
         tmplLine->numElements >= 2) {  
    3830   if (!template->multiboot && (needs & NEED_MB)) {   if (!template->multiboot && (needs & NEED_MB)) {
    3831      /* it's not a multiboot template and this is the kernel      /* it's not a multiboot template and this is the kernel
    3832       * line.  Try to be intelligent about inserting the       * line.  Try to be intelligent about inserting the
    # Line 3470  int addNewKernel(struct grubConfig * con Line 3903  int addNewKernel(struct grubConfig * con
    3903      /* template is multi but new is not,      /* template is multi but new is not,
    3904       * insert the kernel in the first module slot       * insert the kernel in the first module slot
    3905       */       */
    3906      tmplLine->type = LT_KERNEL;      tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
    3907      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3908      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3909   strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3910     config->cfi)->key);
    3911      newLine = addLineTmpl(new, tmplLine, newLine,      newLine = addLineTmpl(new, tmplLine, newLine,
    3912    newKernelPath + strlen(prefix), config->cfi);    newKernelPath + strlen(prefix),
    3913      config->cfi);
    3914      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    3915   } else if (needs & NEED_INITRD) {   } else if (needs & NEED_INITRD) {
    3916      char *initrdVal;      char *initrdVal;
    3917      /* template is multi but new is not,      /* template is multi but new is not,
    3918       * insert the initrd in the second module slot       * insert the initrd in the second module slot
    3919       */       */
    3920      tmplLine->type = LT_INITRD;      tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
    3921      free(tmplLine->elements[0].item);      free(tmplLine->elements[0].item);
    3922      tmplLine->elements[0].item =      tmplLine->elements[0].item =
    3923   strdup(getKeywordByType(LT_INITRD, config->cfi)->key);   strdup(getKeywordByType(tmplLine->type,
    3924     config->cfi)->key);
    3925      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);      initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
    3926      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);      newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
    3927      free(initrdVal);      free(initrdVal);
    3928      needs &= ~NEED_INITRD;      needs &= ~NEED_INITRD;
    3929   }   }
    3930    
    3931      } else if (tmplLine->type == LT_INITRD &&      } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
            tmplLine->numElements >= 2) {  
    3932   if (needs & NEED_INITRD &&   if (needs & NEED_INITRD &&
    3933      new->multiboot && !template->multiboot &&      new->multiboot && !template->multiboot &&
    3934      config->cfi->mbInitRdIsModule) {      config->cfi->mbInitRdIsModule) {
    # Line 3547  int addNewKernel(struct grubConfig * con Line 3982  int addNewKernel(struct grubConfig * con
    3982      static const char *prefix = "'Loading ";      static const char *prefix = "'Loading ";
    3983      if (tmplLine->numElements > 1 &&      if (tmplLine->numElements > 1 &&
    3984      strstr(tmplLine->elements[1].item, prefix) &&      strstr(tmplLine->elements[1].item, prefix) &&
    3985      masterLine->next && masterLine->next->type == LT_KERNEL) {      masterLine->next &&
    3986        iskernel(masterLine->next->type)) {
    3987   char *newTitle = malloc(strlen(prefix) +   char *newTitle = malloc(strlen(prefix) +
    3988   strlen(newKernelTitle) + 2);   strlen(newKernelTitle) + 2);
    3989    
    # Line 3562  int addNewKernel(struct grubConfig * con Line 3998  int addNewKernel(struct grubConfig * con
    3998   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3999   config->cfi);   config->cfi);
    4000      }      }
    4001        } else if (tmplLine->type == LT_DEVTREE &&
    4002           tmplLine->numElements == 2 && newDevTreePath) {
    4003            newLine = addLineTmpl(new, tmplLine, newLine,
    4004          newDevTreePath + strlen(prefix),
    4005          config->cfi);
    4006     needs &= ~NEED_DEVTREE;
    4007        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    4008     const char *ndtp = newDevTreePath;
    4009     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    4010        ndtp += strlen(prefix);
    4011     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4012      config->secondaryIndent,
    4013      ndtp);
    4014     needs &= ~NEED_DEVTREE;
    4015     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    4016      } else {      } else {
    4017   /* pass through other lines from the template */   /* pass through other lines from the template */
    4018   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3574  int addNewKernel(struct grubConfig * con Line 4025  int addNewKernel(struct grubConfig * con
    4025   */   */
    4026   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    4027      case LT_KERNEL:      case LT_KERNEL:
    4028        case LT_KERNEL_EFI:
    4029        case LT_KERNEL_16:
    4030   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4031      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4032   } else {   } else {
    4033      newLine = addLine(new, config->cfi, LT_KERNEL,      newLine = addLine(new, config->cfi,
    4034              preferredLineType(LT_KERNEL, config->cfi),
    4035        config->primaryIndent,        config->primaryIndent,
    4036        newKernelPath + strlen(prefix));        newKernelPath + strlen(prefix));
    4037      needs &= ~NEED_KERNEL;      needs &= ~NEED_KERNEL;
    # Line 3634  int addNewKernel(struct grubConfig * con Line 4088  int addNewKernel(struct grubConfig * con
    4088   }   }
    4089      }      }
    4090    
    4091        struct singleLine *endLine = NULL;
    4092        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4093        if (endLine) {
    4094        removeLine(new, endLine);
    4095        needs |= NEED_END;
    4096        }
    4097    
    4098      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4099       * weren't present in the template, or in the case of no template,       * weren't present in the template, or in the case of no template,
    4100       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3653  int addNewKernel(struct grubConfig * con Line 4114  int addNewKernel(struct grubConfig * con
    4114      if (needs & NEED_KERNEL) {      if (needs & NEED_KERNEL) {
    4115   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    4116    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    4117        config->cfi)) ?        config->cfi))
    4118    LT_MBMODULE : LT_KERNEL,     ? LT_MBMODULE
    4119     : preferredLineType(LT_KERNEL, config->cfi),
    4120    config->secondaryIndent,    config->secondaryIndent,
    4121    newKernelPath + strlen(prefix));    newKernelPath + strlen(prefix));
    4122   needs &= ~NEED_KERNEL;   needs &= ~NEED_KERNEL;
    # Line 3670  int addNewKernel(struct grubConfig * con Line 4132  int addNewKernel(struct grubConfig * con
    4132   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);   initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
    4133   newLine = addLine(new, config->cfi,   newLine = addLine(new, config->cfi,
    4134    (new->multiboot && getKeywordByType(LT_MBMODULE,    (new->multiboot && getKeywordByType(LT_MBMODULE,
    4135        config->cfi)) ?        config->cfi))
    4136    LT_MBMODULE : LT_INITRD,     ? LT_MBMODULE
    4137       : preferredLineType(LT_INITRD, config->cfi),
    4138    config->secondaryIndent,    config->secondaryIndent,
    4139    initrdVal);    initrdVal);
    4140   free(initrdVal);   free(initrdVal);
    4141   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4142      }      }
    4143        if (needs & NEED_DEVTREE) {
    4144     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4145      config->secondaryIndent,
    4146      newDevTreePath);
    4147     needs &= ~NEED_DEVTREE;
    4148        }
    4149    
    4150        /* NEEDS_END must be last on bootloaders that need it... */
    4151      if (needs & NEED_END) {      if (needs & NEED_END) {
    4152   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4153   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 3703  static void traceback(int signum) Line 4174  static void traceback(int signum)
    4174      memset(array, '\0', sizeof (array));      memset(array, '\0', sizeof (array));
    4175      size = backtrace(array, 40);      size = backtrace(array, 40);
    4176    
    4177      fprintf(stderr, "grubby recieved SIGSEGV!  Backtrace (%ld):\n",      fprintf(stderr, "grubby received SIGSEGV!  Backtrace (%ld):\n",
    4178              (unsigned long)size);              (unsigned long)size);
    4179      backtrace_symbols_fd(array, size, STDERR_FILENO);      backtrace_symbols_fd(array, size, STDERR_FILENO);
    4180      exit(1);      exit(1);
    # Line 3728  int main(int argc, const char ** argv) { Line 4199  int main(int argc, const char ** argv) {
    4199      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4200      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4201      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4202      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4203      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4204      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4205      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 3738  int main(int argc, const char ** argv) { Line 4209  int main(int argc, const char ** argv) {
    4209      char * removeArgs = NULL;      char * removeArgs = NULL;
    4210      char * kernelInfo = NULL;      char * kernelInfo = NULL;
    4211      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
    4212        char * envPath = NULL;
    4213      const char * chptr = NULL;      const char * chptr = NULL;
    4214      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
    4215      struct grubConfig * config;      struct grubConfig * config;
    # Line 3785  int main(int argc, const char ** argv) { Line 4257  int main(int argc, const char ** argv) {
    4257      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4258   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4259      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4260     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4261        _("device tree file for new stanza"), _("dtb-path") },
    4262   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4263      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4264     { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    4265        _("force grub2 stanzas to use efi") },
    4266     { "env", 0, POPT_ARG_STRING, &envPath, 0,
    4267        _("path for environment data"),
    4268        _("path") },
    4269   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    4270      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    4271   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3799  int main(int argc, const char ** argv) { Line 4278  int main(int argc, const char ** argv) {
    4278   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,   { "initrd", 0, POPT_ARG_STRING, &newKernelInitrd, 0,
    4279      _("initrd image for the new kernel"), _("initrd-path") },      _("initrd image for the new kernel"), _("initrd-path") },
    4280   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',   { "extra-initrd", 'i', POPT_ARG_STRING, NULL, 'i',
    4281      _("auxilliary initrd image for things other than the new kernel"), _("initrd-path") },      _("auxiliary initrd image for things other than the new kernel"), _("initrd-path") },
    4282   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,   { "lilo", 0, POPT_ARG_NONE, &configureLilo, 0,
    4283      _("configure lilo bootloader") },      _("configure lilo bootloader") },
    4284   { "make-default", 0, 0, &makeDefault, 0,   { "make-default", 0, 0, &makeDefault, 0,
    # Line 3843  int main(int argc, const char ** argv) { Line 4322  int main(int argc, const char ** argv) {
    4322    
    4323      signal(SIGSEGV, traceback);      signal(SIGSEGV, traceback);
    4324    
    4325        int i = 0;
    4326        for (int j = 1; j < argc; j++)
    4327     i += strlen(argv[j]) + 1;
    4328        saved_command_line = malloc(i);
    4329        if (!saved_command_line) {
    4330     fprintf(stderr, "grubby: %m\n");
    4331     exit(1);
    4332        }
    4333        saved_command_line[0] = '\0';
    4334        for (int j = 1; j < argc; j++) {
    4335     strcat(saved_command_line, argv[j]);
    4336     strncat(saved_command_line, j == argc -1 ? "" : " ", 1);
    4337        }
    4338    
    4339      optCon = poptGetContext("grubby", argc, argv, options, 0);      optCon = poptGetContext("grubby", argc, argv, options, 0);
    4340      poptReadDefaultConfig(optCon, 1);      poptReadDefaultConfig(optCon, 1);
    4341    
    # Line 3886  int main(int argc, const char ** argv) { Line 4379  int main(int argc, const char ** argv) {
    4379   return 1;   return 1;
    4380      } else if (configureGrub2) {      } else if (configureGrub2) {
    4381   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
    4382     if (envPath)
    4383        cfi->envFile = envPath;
    4384      } else if (configureLilo) {      } else if (configureLilo) {
    4385   cfi = &liloConfigType;   cfi = &liloConfigType;
    4386      } else if (configureGrub) {      } else if (configureGrub) {
    # Line 3929  int main(int argc, const char ** argv) { Line 4424  int main(int argc, const char ** argv) {
    4424      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4425      }      }
    4426    
    4427      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4428      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4429      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4430      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 3938  int main(int argc, const char ** argv) { Line 4433  int main(int argc, const char ** argv) {
    4433   return 1;   return 1;
    4434      }      }
    4435    
    4436      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4437     removeKernelPath)) {     removeKernelPath)) {
    4438   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4439    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 3948  int main(int argc, const char ** argv) { Line 4443  int main(int argc, const char ** argv) {
    4443      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
    4444   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
    4445   return 1;   return 1;
    4446      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
    4447    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
    4448    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
    4449   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
    # Line 4069  int main(int argc, const char ** argv) { Line 4564  int main(int argc, const char ** argv) {
    4564      if (!yconfig)      if (!yconfig)
    4565   yrc = 1;   yrc = 1;
    4566      else      else
    4567   yrc = checkForYaboot(lconfig);   yrc = checkForYaboot(yconfig);
    4568   }   }
    4569    
    4570   if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||   if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
    # Line 4086  int main(int argc, const char ** argv) { Line 4581  int main(int argc, const char ** argv) {
    4581   return 0;   return 0;
    4582      }      }
    4583    
    4584        if (grubConfig == NULL) {
    4585     printf("Could not find bootloader configuration file.\n");
    4586     exit(1);
    4587        }
    4588    
    4589      config = readConfig(grubConfig, cfi);      config = readConfig(grubConfig, cfi);
    4590      if (!config) return 1;      if (!config) return 1;
    4591    
    # Line 4095  int main(int argc, const char ** argv) { Line 4595  int main(int argc, const char ** argv) {
    4595          char * rootspec;          char * rootspec;
    4596    
    4597   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4598     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4599     cfi->defaultIsSaved)
    4600        config->defaultImage = 0;
    4601   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4602   if (!entry) return 0;   if (!entry) return 0;
    4603   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4604    
    4605   line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    4606   if (!line) return 0;   if (!line) return 0;
    4607    
    4608          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4113  int main(int argc, const char ** argv) { Line 4616  int main(int argc, const char ** argv) {
    4616   struct singleEntry * entry;   struct singleEntry * entry;
    4617    
    4618   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4619     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4620     cfi->defaultIsSaved)
    4621        config->defaultImage = 0;
    4622   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4623   if (!entry) return 0;   if (!entry) return 0;
    4624    
    # Line 4135  int main(int argc, const char ** argv) { Line 4641  int main(int argc, const char ** argv) {
    4641    
    4642      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
    4643          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
    4644     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4645     cfi->defaultIsSaved)
    4646        config->defaultImage = 0;
    4647          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
    4648            return 0;
    4649    
    4650      } else if (kernelInfo)      } else if (kernelInfo)
    4651   return displayInfo(config, kernelInfo, bootPrefix);   return displayInfo(config, kernelInfo, bootPrefix);
    # Line 4153  int main(int argc, const char ** argv) { Line 4663  int main(int argc, const char ** argv) {
    4663      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4664                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4665      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4666              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4667                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4668     bootPrefix, newKernelInitrd,
    4669     newKernelTitle))
    4670        return 1;
    4671        } else {
    4672        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4673     newKernelInitrd, newKernelTitle))
    4674     return 1;
    4675        }
    4676      }      }
    4677      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4678                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4679                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4680                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4681            
    4682    
    4683      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.1859  
    changed lines
      Added in v.2960