Magellan Linux

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

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

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

    revision 2250 by niro, Mon Oct 21 13:56:22 2013 UTC revision 2688 by niro, Wed Jul 16 10:42:34 2014 UTC
    # Line 60  int debug = 0; /* Currently just for tem Line 60  int debug = 0; /* Currently just for tem
    60    
    61  int isEfi = 0;  int isEfi = 0;
    62    
    63    #if defined(__arch64__)
    64    #define isEfiOnly 1
    65    #else
    66    #define isEfiOnly 0
    67    #endif
    68    
    69  char *saved_command_line = NULL;  char *saved_command_line = NULL;
    70    
    71  /* comments get lumped in with indention */  /* comments get lumped in with indention */
    # Line 90  enum lineType_e { Line 96  enum lineType_e {
    96      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    97      LT_KERNEL_EFI   = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    98      LT_INITRD_EFI   = 1 << 21,      LT_INITRD_EFI   = 1 << 21,
    99      LT_UNKNOWN      = 1 << 22,      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 119  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 136  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;      int caseInsensitive;
    160      int defaultIsIndex;      int defaultIsIndex;
    161      int defaultIsVariable;      int defaultIsVariable;
    162      int defaultSupportSaved;      int defaultSupportSaved;
    163        int defaultIsSaved;
    164      enum lineType_e entryStart;      enum lineType_e entryStart;
    165      enum lineType_e entryEnd;      enum lineType_e entryEnd;
    166      int needsBootPrefix;      int needsBootPrefix;
    # Line 157  struct configFileInfo { Line 172  struct configFileInfo {
    172      int mbInitRdIsModule;      int mbInitRdIsModule;
    173      int mbConcatArgs;      int mbConcatArgs;
    174      int mbAllowExtraInitRds;      int mbAllowExtraInitRds;
    175        char *envFile;
    176  };  };
    177    
    178  struct keywordTypes grubKeywords[] = {  struct keywordTypes grubKeywords[] = {
    # Line 176  const char *grubFindConfig(struct config Line 192  const char *grubFindConfig(struct config
    192   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    193   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    194   "/etc/grub.conf",   "/etc/grub.conf",
    195     "/boot/grub2/grub.cfg",
    196     "/boot/grub2-efi/grub.cfg",
    197   NULL   NULL
    198      };      };
    199      static int i = -1;      static int i = -1;
    # Line 215  struct keywordTypes grub2Keywords[] = { Line 233  struct keywordTypes grub2Keywords[] = {
    233      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    234      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    235      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    236        { "linux16",    LT_KERNEL_16,   ' ' },
    237      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    238      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    239        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    240      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    241      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    242        { "devicetree", LT_DEVTREE,  ' ' },
    243      { NULL, 0, 0 },      { NULL, 0, 0 },
    244  };  };
    245    
    # Line 261  const char *grub2FindConfig(struct confi Line 282  const char *grub2FindConfig(struct confi
    282      return configFiles[i];      return configFiles[i];
    283  }  }
    284    
    285    /* kind of hacky.  It'll give the first 1024 bytes, ish. */
    286    static char *grub2GetEnv(struct configFileInfo *info, char *name)
    287    {
    288        static char buf[1025];
    289        char *s = NULL;
    290        char *ret = NULL;
    291        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    292        int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    293    
    294        if (rc < 0)
    295     return NULL;
    296    
    297        FILE *f = popen(s, "r");
    298        if (!f)
    299     goto out;
    300    
    301        memset(buf, '\0', sizeof (buf));
    302        ret = fgets(buf, 1024, f);
    303        pclose(f);
    304    
    305        if (ret) {
    306     ret += strlen(name) + 1;
    307     ret[strlen(ret) - 1] = '\0';
    308        }
    309        dbgPrintf("grub2GetEnv(%s): %s\n", name, ret);
    310    out:
    311        free(s);
    312        return ret;
    313    }
    314    
    315    static int sPopCount(const char *s, const char *c)
    316    {
    317        int ret = 0;
    318        if (!s)
    319     return -1;
    320        for (int i = 0; s[i] != '\0'; i++)
    321     for (int j = 0; c[j] != '\0'; j++)
    322        if (s[i] == c[j])
    323     ret++;
    324        return ret;
    325    }
    326    
    327    static char *shellEscape(const char *s)
    328    {
    329        int l = strlen(s) + sPopCount(s, "'") * 2;
    330    
    331        char *ret = calloc(l+1, sizeof (*ret));
    332        if (!ret)
    333     return NULL;
    334        for (int i = 0, j = 0; s[i] != '\0'; i++, j++) {
    335     if (s[i] == '\'')
    336        ret[j++] = '\\';
    337     ret[j] = s[i];
    338        }
    339        return ret;
    340    }
    341    
    342    static void unquote(char *s)
    343    {
    344        int l = strlen(s);
    345    
    346        if ((s[l-1] == '\'' && s[0] == '\'') || (s[l-1] == '"' && s[0] == '"')) {
    347     memmove(s, s+1, l-2);
    348     s[l-2] = '\0';
    349        }
    350    }
    351    
    352    static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
    353    {
    354        char *s = NULL;
    355        int rc = 0;
    356        char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    357    
    358        unquote(value);
    359        value = shellEscape(value);
    360        if (!value)
    361        return -1;
    362    
    363        rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    364        free(value);
    365        if (rc <0)
    366     return -1;
    367    
    368        dbgPrintf("grub2SetEnv(%s): %s\n", name, s);
    369        rc = system(s);
    370        free(s);
    371        return rc;
    372    }
    373    
    374    /* this is a gigantic hack to avoid clobbering grub2 variables... */
    375    static int is_special_grub2_variable(const char *name)
    376    {
    377        if (!strcmp(name,"\"${next_entry}\""))
    378     return 1;
    379        if (!strcmp(name,"\"${prev_saved_entry}\""))
    380     return 1;
    381        return 0;
    382    }
    383    
    384  int sizeOfSingleLine(struct singleLine * line) {  int sizeOfSingleLine(struct singleLine * line) {
    385    int count = 0;    int count = 0;
    386    
    # Line 291  static int isquote(char q) Line 411  static int isquote(char q)
    411  }  }
    412    
    413  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    414      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    415  }  }
    416    
    417  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    418      return (type == LT_INITRD || type == LT_INITRD_EFI);      return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    419  }  }
    420    
    421  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    # Line 355  char *grub2ExtractTitle(struct singleLin Line 475  char *grub2ExtractTitle(struct singleLin
    475    
    476  struct configFileInfo grub2ConfigType = {  struct configFileInfo grub2ConfigType = {
    477      .findConfig = grub2FindConfig,      .findConfig = grub2FindConfig,
    478        .getEnv = grub2GetEnv,
    479        .setEnv = grub2SetEnv,
    480      .keywords = grub2Keywords,      .keywords = grub2Keywords,
    481      .defaultIsIndex = 1,      .defaultIsIndex = 1,
    482      .defaultSupportSaved = 1,      .defaultSupportSaved = 1,
    # Line 534  struct singleEntry * findEntryByIndex(st Line 656  struct singleEntry * findEntryByIndex(st
    656  struct singleEntry * findEntryByPath(struct grubConfig * cfg,  struct singleEntry * findEntryByPath(struct grubConfig * cfg,
    657       const char * path, const char * prefix,       const char * path, const char * prefix,
    658       int * index);       int * index);
    659    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    660          int * index);
    661  static int readFile(int fd, char ** bufPtr);  static int readFile(int fd, char ** bufPtr);
    662  static void lineInit(struct singleLine * line);  static void lineInit(struct singleLine * line);
    663  struct singleLine * lineDup(struct singleLine * line);  struct singleLine * lineDup(struct singleLine * line);
    # Line 603  static enum lineType_e preferredLineType Line 727  static enum lineType_e preferredLineType
    727      if (isEfi && cfi == &grub2ConfigType) {      if (isEfi && cfi == &grub2ConfigType) {
    728   switch (type) {   switch (type) {
    729   case LT_KERNEL:   case LT_KERNEL:
    730      return LT_KERNEL_EFI;      return isEfiOnly ? LT_KERNEL : LT_KERNEL_EFI;
    731     case LT_INITRD:
    732        return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    733     default:
    734        return type;
    735     }
    736    #if defined(__i386__) || defined(__x86_64__)
    737        } else if (cfi == &grub2ConfigType) {
    738     switch (type) {
    739     case LT_KERNEL:
    740        return LT_KERNEL_16;
    741   case LT_INITRD:   case LT_INITRD:
    742      return LT_INITRD_EFI;      return LT_INITRD_16;
    743   default:   default:
    744      return type;      return type;
    745   }   }
    746    #endif
    747      }      }
    748      return type;      return type;
    749  }  }
    # Line 691  static int isEntryStart(struct singleLin Line 826  static int isEntryStart(struct singleLin
    826  /* extract the title from within brackets (for zipl) */  /* extract the title from within brackets (for zipl) */
    827  static char * extractTitle(struct singleLine * line) {  static char * extractTitle(struct singleLine * line) {
    828      /* bracketed title... let's extract it (leaks a byte) */      /* bracketed title... let's extract it (leaks a byte) */
    829      char * title;      char * title = NULL;
    830      title = strdup(line->elements[0].item);      if (line->type == LT_TITLE) {
    831      title++;   title = strdup(line->elements[0].item);
    832      *(title + strlen(title) - 1) = '\0';   title++;
    833     *(title + strlen(title) - 1) = '\0';
    834        } else if (line->type == LT_MENUENTRY)
    835     title = strdup(line->elements[1].item);
    836        else
    837     return NULL;
    838      return title;      return title;
    839  }  }
    840    
    # Line 952  static int getNextLine(char ** bufPtr, s Line 1092  static int getNextLine(char ** bufPtr, s
    1092      return 0;      return 0;
    1093  }  }
    1094    
    1095    static int isnumber(const char *s)
    1096    {
    1097        int i;
    1098        for (i = 0; s[i] != '\0'; i++)
    1099     if (s[i] < '0' || s[i] > '9')
    1100        return 0;
    1101        return i;
    1102    }
    1103    
    1104  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1105        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1106      int in;      int in;
    # Line 1036  static struct grubConfig * readConfig(co Line 1185  static struct grubConfig * readConfig(co
    1185      dbgPrintf("\n");      dbgPrintf("\n");
    1186      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);      struct keywordTypes *kwType = getKeywordByType(LT_DEFAULT, cfi);
    1187      if (kwType && line->numElements == 3 &&      if (kwType && line->numElements == 3 &&
    1188      !strcmp(line->elements[1].item, kwType->key)) {      !strcmp(line->elements[1].item, kwType->key) &&
    1189        !is_special_grub2_variable(line->elements[2].item)) {
    1190   dbgPrintf("Line sets default config\n");   dbgPrintf("Line sets default config\n");
    1191   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1192   defaultLine = line;   defaultLine = line;
    # Line 1241  static struct grubConfig * readConfig(co Line 1391  static struct grubConfig * readConfig(co
    1391          if (defaultLine->numElements > 2 &&          if (defaultLine->numElements > 2 &&
    1392      cfi->defaultSupportSaved &&      cfi->defaultSupportSaved &&
    1393      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {      !strncmp(defaultLine->elements[2].item,"\"${saved_entry}\"", 16)) {
    1394      cfg->defaultImage = DEFAULT_SAVED_GRUB2;   cfg->cfi->defaultIsSaved = 1;
    1395     cfg->defaultImage = DEFAULT_SAVED_GRUB2;
    1396     if (cfg->cfi->getEnv) {
    1397        char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1398        if (defTitle) {
    1399     int index = 0;
    1400     if (isnumber(defTitle)) {
    1401        index = atoi(defTitle);
    1402        entry = findEntryByIndex(cfg, index);
    1403     } else {
    1404        entry = findEntryByTitle(cfg, defTitle, &index);
    1405     }
    1406     if (entry)
    1407        cfg->defaultImage = index;
    1408        }
    1409     }
    1410   } else if (cfi->defaultIsVariable) {   } else if (cfi->defaultIsVariable) {
    1411      char *value = defaultLine->elements[2].item;      char *value = defaultLine->elements[2].item;
    1412      while (*value && (*value == '"' || *value == '\'' ||      while (*value && (*value == '"' || *value == '\'' ||
    # Line 1282  static struct grubConfig * readConfig(co Line 1447  static struct grubConfig * readConfig(co
    1447          cfg->defaultImage = -1;          cfg->defaultImage = -1;
    1448      }      }
    1449   }   }
    1450        } else if (cfg->cfi->defaultIsSaved && cfg->cfi->getEnv) {
    1451     char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1452     if (defTitle) {
    1453        int index = 0;
    1454        if (isnumber(defTitle)) {
    1455     index = atoi(defTitle);
    1456     entry = findEntryByIndex(cfg, index);
    1457        } else {
    1458     entry = findEntryByTitle(cfg, defTitle, &index);
    1459        }
    1460        if (entry)
    1461     cfg->defaultImage = index;
    1462     }
    1463      } else {      } else {
    1464          cfg->defaultImage = 0;          cfg->defaultImage = 0;
    1465      }      }
    # Line 1299  static void writeDefault(FILE * out, cha Line 1477  static void writeDefault(FILE * out, cha
    1477    
    1478      if (cfg->defaultImage == DEFAULT_SAVED)      if (cfg->defaultImage == DEFAULT_SAVED)
    1479   fprintf(out, "%sdefault%ssaved\n", indent, separator);   fprintf(out, "%sdefault%ssaved\n", indent, separator);
    1480      else if (cfg->defaultImage == DEFAULT_SAVED_GRUB2)      else if (cfg->cfi->defaultIsSaved) {
    1481   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);   fprintf(out, "%sset default=\"${saved_entry}\"\n", indent);
    1482      else if (cfg->defaultImage > -1) {   if (cfg->defaultImage >= 0 && cfg->cfi->setEnv) {
    1483        char *title;
    1484        entry = findEntryByIndex(cfg, cfg->defaultImage);
    1485        line = getLineByType(LT_MENUENTRY, entry->lines);
    1486        if (!line)
    1487     line = getLineByType(LT_TITLE, entry->lines);
    1488        if (line) {
    1489     title = extractTitle(line);
    1490     if (title)
    1491        cfg->cfi->setEnv(cfg->cfi, "saved_entry", title);
    1492        }
    1493     }
    1494        } else if (cfg->defaultImage > -1) {
    1495   if (cfg->cfi->defaultIsIndex) {   if (cfg->cfi->defaultIsIndex) {
    1496      if (cfg->cfi->defaultIsVariable) {      if (cfg->cfi->defaultIsVariable) {
    1497          fprintf(out, "%sset default=\"%d\"\n", indent,          fprintf(out, "%sset default=\"%d\"\n", indent,
    # Line 1404  static int writeConfig(struct grubConfig Line 1594  static int writeConfig(struct grubConfig
    1594      while (line) {      while (line) {
    1595          if (line->type == LT_SET_VARIABLE && defaultKw &&          if (line->type == LT_SET_VARIABLE && defaultKw &&
    1596   line->numElements == 3 &&   line->numElements == 3 &&
    1597   !strcmp(line->elements[1].item, defaultKw->key)) {   !strcmp(line->elements[1].item, defaultKw->key) &&
    1598     !is_special_grub2_variable(line->elements[2].item)) {
    1599      writeDefault(out, line->indent, line->elements[0].indent, cfg);      writeDefault(out, line->indent, line->elements[0].indent, cfg);
    1600      needs &= ~MAIN_DEFAULT;      needs &= ~MAIN_DEFAULT;
    1601   } else if (line->type == LT_DEFAULT) {   } else if (line->type == LT_DEFAULT) {
    # Line 1640  int suitableImage(struct singleEntry * e Line 1831  int suitableImage(struct singleEntry * e
    1831   return 0;   return 0;
    1832      }      }
    1833    
    1834      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1835      if (!line) {      if (!line) {
    1836   notSuitablePrintf(entry, 0, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1837   return 0;   return 0;
    # Line 1774  struct singleEntry * findEntryByPath(str Line 1965  struct singleEntry * findEntryByPath(str
    1965   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1966   if (!entry) return NULL;   if (!entry) return NULL;
    1967    
    1968   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1969   if (!line) return NULL;   if (!line) return NULL;
    1970    
    1971   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1825  struct singleEntry * findEntryByPath(str Line 2016  struct singleEntry * findEntryByPath(str
    2016      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2017   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2018   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2019      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2020   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2021      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2022   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2023   if (!line)   if (!line)
    2024      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1849  struct singleEntry * findEntryByPath(str Line 2040  struct singleEntry * findEntryByPath(str
    2040       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2041       * unfortunate)       * unfortunate)
    2042       */       */
    2043      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))      if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines))
    2044   break; /* found 'im! */   break; /* found 'im! */
    2045   }   }
    2046    
    # Line 1859  struct singleEntry * findEntryByPath(str Line 2050  struct singleEntry * findEntryByPath(str
    2050      return entry;      return entry;
    2051  }  }
    2052    
    2053    struct singleEntry * findEntryByTitle(struct grubConfig * cfg, char *title,
    2054          int * index) {
    2055        struct singleEntry * entry;
    2056        struct singleLine * line;
    2057        int i;
    2058        char * newtitle;
    2059    
    2060        for (i = 0, entry = cfg->entries; entry; entry = entry->next, i++) {
    2061     if (index && i < *index)
    2062        continue;
    2063     line = getLineByType(LT_TITLE, entry->lines);
    2064     if (!line)
    2065        line = getLineByType(LT_MENUENTRY, entry->lines);
    2066     if (!line)
    2067        continue;
    2068     newtitle = grub2ExtractTitle(line);
    2069     if (!newtitle)
    2070        continue;
    2071     if (!strcmp(title, newtitle))
    2072        break;
    2073        }
    2074    
    2075        if (!entry)
    2076     return NULL;
    2077    
    2078        if (index)
    2079     *index = i;
    2080        return entry;
    2081    }
    2082    
    2083  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {  struct singleEntry * findEntryByIndex(struct grubConfig * cfg, int index) {
    2084      struct singleEntry * entry;      struct singleEntry * entry;
    2085    
    # Line 1881  struct singleEntry * findTemplate(struct Line 2102  struct singleEntry * findTemplate(struct
    2102      struct singleEntry * entry, * entry2;      struct singleEntry * entry, * entry2;
    2103      int index;      int index;
    2104    
    2105      if (cfg->defaultImage > -1) {      if (cfg->cfi->defaultIsSaved) {
    2106     if (cfg->cfi->getEnv) {
    2107        char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2108        if (defTitle) {
    2109     int index = 0;
    2110     if (isnumber(defTitle)) {
    2111        index = atoi(defTitle);
    2112        entry = findEntryByIndex(cfg, index);
    2113     } else {
    2114        entry = findEntryByTitle(cfg, defTitle, &index);
    2115     }
    2116     if (entry)
    2117        cfg->defaultImage = index;
    2118        }
    2119     }
    2120        } else if (cfg->defaultImage > -1) {
    2121   entry = findEntryByIndex(cfg, cfg->defaultImage);   entry = findEntryByIndex(cfg, cfg->defaultImage);
    2122   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2123      if (indexPtr) *indexPtr = cfg->defaultImage;      if (indexPtr) *indexPtr = cfg->defaultImage;
    # Line 2038  void displayEntry(struct singleEntry * e Line 2274  void displayEntry(struct singleEntry * e
    2274    
    2275      printf("index=%d\n", index);      printf("index=%d\n", index);
    2276    
    2277      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    2278      if (!line) {      if (!line) {
    2279          printf("non linux entry\n");          printf("non linux entry\n");
    2280          return;          return;
    # Line 2103  void displayEntry(struct singleEntry * e Line 2339  void displayEntry(struct singleEntry * e
    2339   printf("root=%s\n", s);   printf("root=%s\n", s);
    2340      }      }
    2341    
    2342      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2343    
    2344      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2345   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2520  struct singleLine * addLineTmpl(struct s Line 2756  struct singleLine * addLineTmpl(struct s
    2756   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2757    
    2758   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2759   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI)) {   if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI|LT_KERNEL_16|LT_INITRD_16)) {
    2760      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2761      if (rootspec != NULL) {      if (rootspec != NULL) {
    2762   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 2890  int updateActualImage(struct grubConfig Line 3126  int updateActualImage(struct grubConfig
    3126      firstElement = 2;      firstElement = 2;
    3127    
    3128   } else {   } else {
    3129      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3130      if (!line) {      if (!line) {
    3131   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3132   continue;   continue;
    # Line 3046  int updateImage(struct grubConfig * cfg, Line 3282  int updateImage(struct grubConfig * cfg,
    3282      return rc;      return rc;
    3283  }  }
    3284    
    3285    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3286     const char * image, const char * prefix, const char * initrd) {
    3287        struct singleEntry * entry;
    3288        struct singleLine * line, * kernelLine, *endLine = NULL;
    3289        int index = 0;
    3290    
    3291        if (!image) return 0;
    3292    
    3293        for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
    3294            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3295            if (!kernelLine) continue;
    3296    
    3297            if (prefix) {
    3298                int prefixLen = strlen(prefix);
    3299                if (!strncmp(initrd, prefix, prefixLen))
    3300                    initrd += prefixLen;
    3301            }
    3302     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3303     if (endLine)
    3304        removeLine(entry, endLine);
    3305            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3306     kernelLine->indent, initrd);
    3307            if (!line)
    3308        return 1;
    3309     if (endLine) {
    3310        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3311                if (!line)
    3312     return 1;
    3313     }
    3314    
    3315            break;
    3316        }
    3317    
    3318        return 0;
    3319    }
    3320    
    3321  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3322                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3323      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3055  int updateInitrd(struct grubConfig * cfg Line 3327  int updateInitrd(struct grubConfig * cfg
    3327      if (!image) return 0;      if (!image) return 0;
    3328    
    3329      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3330          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3331          if (!kernelLine) continue;          if (!kernelLine) continue;
    3332    
    3333          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3334          if (line)          if (line)
    3335              removeLine(entry, line);              removeLine(entry, line);
    3336          if (prefix) {          if (prefix) {
    # Line 3069  int updateInitrd(struct grubConfig * cfg Line 3341  int updateInitrd(struct grubConfig * cfg
    3341   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3342   if (endLine)   if (endLine)
    3343      removeLine(entry, endLine);      removeLine(entry, endLine);
    3344          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3345   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3346        case LT_KERNEL:
    3347            lt = LT_INITRD;
    3348     break;
    3349        case LT_KERNEL_EFI:
    3350            lt = LT_INITRD_EFI;
    3351     break;
    3352        case LT_KERNEL_16:
    3353            lt = LT_INITRD_16;
    3354     break;
    3355        default:
    3356            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3357     }
    3358            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3359          if (!line)          if (!line)
    3360      return 1;      return 1;
    3361   if (endLine) {   if (endLine) {
    # Line 3429  int addNewKernel(struct grubConfig * con Line 3714  int addNewKernel(struct grubConfig * con
    3714   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3715   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3716   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3717                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3718     const char * newDevTreePath) {
    3719      struct singleEntry * new;      struct singleEntry * new;
    3720      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3721      int needs;      int needs;
    # Line 3470  int addNewKernel(struct grubConfig * con Line 3756  int addNewKernel(struct grubConfig * con
    3756          needs |= NEED_MB;          needs |= NEED_MB;
    3757          new->multiboot = 1;          new->multiboot = 1;
    3758      }      }
    3759        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3760     needs |= NEED_DEVTREE;
    3761    
    3762      if (template) {      if (template) {
    3763   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3655  int addNewKernel(struct grubConfig * con Line 3943  int addNewKernel(struct grubConfig * con
    3943   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3944   config->cfi);   config->cfi);
    3945      }      }
    3946        } else if (tmplLine->type == LT_DEVTREE &&
    3947           tmplLine->numElements == 2 && newDevTreePath) {
    3948            newLine = addLineTmpl(new, tmplLine, newLine,
    3949          newDevTreePath + strlen(prefix),
    3950          config->cfi);
    3951     needs &= ~NEED_DEVTREE;
    3952        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3953     const char *ndtp = newDevTreePath;
    3954     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3955        ndtp += strlen(prefix);
    3956     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3957      config->secondaryIndent,
    3958      ndtp);
    3959     needs &= ~NEED_DEVTREE;
    3960     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3961      } else {      } else {
    3962   /* pass through other lines from the template */   /* pass through other lines from the template */
    3963   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3668  int addNewKernel(struct grubConfig * con Line 3971  int addNewKernel(struct grubConfig * con
    3971   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3972      case LT_KERNEL:      case LT_KERNEL:
    3973      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    3974        case LT_KERNEL_16:
    3975   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3976      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3977   } else {   } else {
    # Line 3774  int addNewKernel(struct grubConfig * con Line 4078  int addNewKernel(struct grubConfig * con
    4078   free(initrdVal);   free(initrdVal);
    4079   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4080      }      }
    4081        if (needs & NEED_DEVTREE) {
    4082     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4083      config->secondaryIndent,
    4084      newDevTreePath);
    4085     needs &= ~NEED_DEVTREE;
    4086        }
    4087    
    4088        /* NEEDS_END must be last on bootloaders that need it... */
    4089      if (needs & NEED_END) {      if (needs & NEED_END) {
    4090   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4091   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    4092   needs &= ~NEED_END;   needs &= ~NEED_END;
    4093      }      }
       
    4094      if (needs) {      if (needs) {
    4095   printf(_("grubby: needs=%d, aborting\n"), needs);   printf(_("grubby: needs=%d, aborting\n"), needs);
    4096   abort();   abort();
    # Line 3825  int main(int argc, const char ** argv) { Line 4136  int main(int argc, const char ** argv) {
    4136      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4137      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4138      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4139      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4140      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4141      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4142      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 3835  int main(int argc, const char ** argv) { Line 4146  int main(int argc, const char ** argv) {
    4146      char * removeArgs = NULL;      char * removeArgs = NULL;
    4147      char * kernelInfo = NULL;      char * kernelInfo = NULL;
    4148      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };      char * extraInitrds[MAX_EXTRA_INITRDS] = { NULL };
    4149        char * envPath = NULL;
    4150      const char * chptr = NULL;      const char * chptr = NULL;
    4151      struct configFileInfo * cfi = NULL;      struct configFileInfo * cfi = NULL;
    4152      struct grubConfig * config;      struct grubConfig * config;
    # Line 3882  int main(int argc, const char ** argv) { Line 4194  int main(int argc, const char ** argv) {
    4194      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4195   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4196      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4197     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4198        _("device tree file for new stanza"), _("dtb-path") },
    4199   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4200      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4201   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    4202      _("force grub2 stanzas to use efi") },      _("force grub2 stanzas to use efi") },
    4203     { "env", 0, POPT_ARG_STRING, &envPath, 0,
    4204        _("path for environment data"),
    4205        _("path") },
    4206   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,   { "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
    4207      _("configure extlinux bootloader (from syslinux)") },      _("configure extlinux bootloader (from syslinux)") },
    4208   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,   { "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
    # Line 3999  int main(int argc, const char ** argv) { Line 4316  int main(int argc, const char ** argv) {
    4316   return 1;   return 1;
    4317      } else if (configureGrub2) {      } else if (configureGrub2) {
    4318   cfi = &grub2ConfigType;   cfi = &grub2ConfigType;
    4319     if (envPath)
    4320        cfi->envFile = envPath;
    4321      } else if (configureLilo) {      } else if (configureLilo) {
    4322   cfi = &liloConfigType;   cfi = &liloConfigType;
    4323      } else if (configureGrub) {      } else if (configureGrub) {
    # Line 4042  int main(int argc, const char ** argv) { Line 4361  int main(int argc, const char ** argv) {
    4361      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4362      }      }
    4363    
    4364      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4365      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4366      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4367      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4051  int main(int argc, const char ** argv) { Line 4370  int main(int argc, const char ** argv) {
    4370   return 1;   return 1;
    4371      }      }
    4372    
    4373      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4374     removeKernelPath)) {     removeKernelPath)) {
    4375   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4376    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4213  int main(int argc, const char ** argv) { Line 4532  int main(int argc, const char ** argv) {
    4532          char * rootspec;          char * rootspec;
    4533    
    4534   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4535     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4536     cfi->defaultIsSaved)
    4537        config->defaultImage = 0;
    4538   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4539   if (!entry) return 0;   if (!entry) return 0;
    4540   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4541    
    4542   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);   line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    4543   if (!line) return 0;   if (!line) return 0;
    4544    
    4545          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4231  int main(int argc, const char ** argv) { Line 4553  int main(int argc, const char ** argv) {
    4553   struct singleEntry * entry;   struct singleEntry * entry;
    4554    
    4555   if (config->defaultImage == -1) return 0;   if (config->defaultImage == -1) return 0;
    4556     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4557     cfi->defaultIsSaved)
    4558        config->defaultImage = 0;
    4559   entry = findEntryByIndex(config, config->defaultImage);   entry = findEntryByIndex(config, config->defaultImage);
    4560   if (!entry) return 0;   if (!entry) return 0;
    4561    
    # Line 4253  int main(int argc, const char ** argv) { Line 4578  int main(int argc, const char ** argv) {
    4578    
    4579      } else if (displayDefaultIndex) {      } else if (displayDefaultIndex) {
    4580          if (config->defaultImage == -1) return 0;          if (config->defaultImage == -1) return 0;
    4581     if (config->defaultImage == DEFAULT_SAVED_GRUB2 &&
    4582     cfi->defaultIsSaved)
    4583        config->defaultImage = 0;
    4584          printf("%i\n", config->defaultImage);          printf("%i\n", config->defaultImage);
    4585          return 0;          return 0;
    4586    
    # Line 4272  int main(int argc, const char ** argv) { Line 4600  int main(int argc, const char ** argv) {
    4600      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4601                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4602      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4603              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4604                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4605     bootPrefix, newKernelInitrd))
    4606        return 1;
    4607        } else {
    4608        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4609     newKernelInitrd))
    4610     return 1;
    4611        }
    4612      }      }
    4613      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4614                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4615                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4616                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4617            
    4618    
    4619      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2250  
    changed lines
      Added in v.2688