Magellan Linux

  • Back to homepage
    • /[magellan-source]/trunk/grubby/grubby.c

    Diff of /trunk/grubby/grubby.c

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

    revision 2255 by niro, Mon Oct 21 14:00:38 2013 UTC revision 2708 by niro, Wed Jul 16 10:56:09 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(__aarch64__)
    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 151  struct configFileInfo { Line 161  struct configFileInfo {
    161      int defaultIsVariable;      int defaultIsVariable;
    162      int defaultSupportSaved;      int defaultSupportSaved;
    163      int defaultIsSaved;      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 182  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 221  struct keywordTypes grub2Keywords[] = { Line 234  struct keywordTypes grub2Keywords[] = {
    234      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    235      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    236      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    237        { "linux16",    LT_KERNEL_16,   ' ' },
    238      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    239      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "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 273  static char *grub2GetEnv(struct configFi Line 289  static char *grub2GetEnv(struct configFi
    289      static char buf[1025];      static char buf[1025];
    290      char *s = NULL;      char *s = NULL;
    291      char *ret = NULL;      char *ret = NULL;
    292      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    293      int rc = asprintf(&s, "grub2-editenv %s list | grep '^%s='", envFile, name);      int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    294    
    295      if (rc < 0)      if (rc < 0)
    296   return NULL;   return NULL;
    # Line 297  out: Line 313  out:
    313      return ret;      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)  static int grub2SetEnv(struct configFileInfo *info, char *name, char *value)
    354  {  {
    355      char *s = NULL;      char *s = NULL;
    356      int rc = 0;      int rc = 0;
    357      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      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, "grub2-editenv %s set '%s=%s'", envFile, name, value);      rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    365        free(value);
    366      if (rc <0)      if (rc <0)
    367   return -1;   return -1;
    368    
    # Line 353  static int isquote(char q) Line 412  static int isquote(char q)
    412  }  }
    413    
    414  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    415      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    416  }  }
    417    
    418  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    419      return (type == LT_INITRD || type == LT_INITRD_EFI);      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) {
    # Line 578  struct configFileInfo extlinuxConfigType Line 637  struct configFileInfo extlinuxConfigType
    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 669  static enum lineType_e preferredLineType Line 729  static enum lineType_e preferredLineType
    729      if (isEfi && cfi == &grub2ConfigType) {      if (isEfi && cfi == &grub2ConfigType) {
    730   switch (type) {   switch (type) {
    731   case LT_KERNEL:   case LT_KERNEL:
    732      return LT_KERNEL_EFI;      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:   case LT_INITRD:
    744      return LT_INITRD_EFI;      return LT_INITRD_16;
    745   default:   default:
    746      return type;      return type;
    747   }   }
    748    #endif
    749      }      }
    750      return type;      return type;
    751  }  }
    # Line 1023  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 1113  static struct grubConfig * readConfig(co Line 1193  static struct grubConfig * readConfig(co
    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 (iskernel(line->type)) {          } 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 1148  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 1256  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 1319  static struct grubConfig * readConfig(co Line 1402  static struct grubConfig * readConfig(co
    1402      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1403      if (defTitle) {      if (defTitle) {
    1404   int index = 0;   int index = 0;
    1405   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    1406        index = atoi(defTitle);
    1407        entry = findEntryByIndex(cfg, index);
    1408     } else {
    1409        entry = findEntryByTitle(cfg, defTitle, &index);
    1410     }
    1411   if (entry)   if (entry)
    1412      cfg->defaultImage = index;      cfg->defaultImage = index;
    1413      }      }
    # Line 1368  static struct grubConfig * readConfig(co Line 1456  static struct grubConfig * readConfig(co
    1456   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1457   if (defTitle) {   if (defTitle) {
    1458      int index = 0;      int index = 0;
    1459      entry = findEntryByTitle(cfg, defTitle, &index);      if (isnumber(defTitle)) {
    1460     index = atoi(defTitle);
    1461     entry = findEntryByIndex(cfg, index);
    1462        } else {
    1463     entry = findEntryByTitle(cfg, defTitle, &index);
    1464        }
    1465      if (entry)      if (entry)
    1466   cfg->defaultImage = index;   cfg->defaultImage = index;
    1467   }   }
    # Line 1743  int suitableImage(struct singleEntry * e Line 1836  int suitableImage(struct singleEntry * e
    1836   return 0;   return 0;
    1837      }      }
    1838    
    1839      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);
    1840      if (!line) {      if (!line) {
    1841   notSuitablePrintf(entry, 0, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1842   return 0;   return 0;
    # Line 1877  struct singleEntry * findEntryByPath(str Line 1970  struct singleEntry * findEntryByPath(str
    1970   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1971   if (!entry) return NULL;   if (!entry) return NULL;
    1972    
    1973   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);
    1974   if (!line) return NULL;   if (!line) return NULL;
    1975    
    1976   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1928  struct singleEntry * findEntryByPath(str Line 2021  struct singleEntry * findEntryByPath(str
    2021      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2022   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2023   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2024      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2025   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2026      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2027   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2028   if (!line)   if (!line)
    2029      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1952  struct singleEntry * findEntryByPath(str Line 2045  struct singleEntry * findEntryByPath(str
    2045       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2046       * unfortunate)       * unfortunate)
    2047       */       */
    2048      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))
    2049   break; /* found 'im! */   break; /* found 'im! */
    2050   }   }
    2051    
    # Line 2019  struct singleEntry * findTemplate(struct Line 2112  struct singleEntry * findTemplate(struct
    2112      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2113      if (defTitle) {      if (defTitle) {
    2114   int index = 0;   int index = 0;
    2115   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    2116        index = atoi(defTitle);
    2117        entry = findEntryByIndex(cfg, index);
    2118     } else {
    2119        entry = findEntryByTitle(cfg, defTitle, &index);
    2120     }
    2121     if (entry)
    2122        cfg->defaultImage = index;
    2123      }      }
    2124   }   }
    2125      } else if (cfg->defaultImage > -1) {      } else if (cfg->defaultImage > -1) {
    # Line 2176  void displayEntry(struct singleEntry * e Line 2276  void displayEntry(struct singleEntry * e
    2276      struct singleLine * line;      struct singleLine * line;
    2277      char * root = NULL;      char * root = NULL;
    2278      int i;      int i;
    2279        int j;
    2280    
    2281      printf("index=%d\n", index);      printf("index=%d\n", index);
    2282    
    2283      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);
    2284      if (!line) {      if (!line) {
    2285          printf("non linux entry\n");          printf("non linux entry\n");
    2286          return;          return;
    # Line 2244  void displayEntry(struct singleEntry * e Line 2345  void displayEntry(struct singleEntry * e
    2345   printf("root=%s\n", s);   printf("root=%s\n", s);
    2346      }      }
    2347    
    2348      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2349    
    2350      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2351   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2267  void displayEntry(struct singleEntry * e Line 2368  void displayEntry(struct singleEntry * e
    2368   if (title)   if (title)
    2369      printf("title=%s\n", title);      printf("title=%s\n", title);
    2370      }      }
    2371    
    2372        for (j = 0, line = entry->lines; line; line = line->next) {
    2373     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2374        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2375     printf("mbmodule%d=", j);
    2376        else
    2377     printf("mbmodule%d=%s", j, prefix);
    2378    
    2379        for (i = 1; i < line->numElements; i++)
    2380     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2381        printf("\n");
    2382        j++;
    2383     }
    2384        }
    2385  }  }
    2386    
    2387  int isSuseSystem(void) {  int isSuseSystem(void) {
    # Line 2661  struct singleLine * addLineTmpl(struct s Line 2776  struct singleLine * addLineTmpl(struct s
    2776   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2777    
    2778   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2779   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)) {
    2780      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2781      if (rootspec != NULL) {      if (rootspec != NULL) {
    2782   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3031  int updateActualImage(struct grubConfig Line 3146  int updateActualImage(struct grubConfig
    3146      firstElement = 2;      firstElement = 2;
    3147    
    3148   } else {   } else {
    3149      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);
    3150      if (!line) {      if (!line) {
    3151   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3152   continue;   continue;
    # Line 3187  int updateImage(struct grubConfig * cfg, Line 3302  int updateImage(struct grubConfig * cfg,
    3302      return rc;      return rc;
    3303  }  }
    3304    
    3305    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3306     const char * image, const char * prefix, const char * initrd) {
    3307        struct singleEntry * entry;
    3308        struct singleLine * line, * kernelLine, *endLine = NULL;
    3309        int index = 0;
    3310    
    3311        if (!image) return 0;
    3312    
    3313        for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
    3314            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3315            if (!kernelLine) continue;
    3316    
    3317            if (prefix) {
    3318                int prefixLen = strlen(prefix);
    3319                if (!strncmp(initrd, prefix, prefixLen))
    3320                    initrd += prefixLen;
    3321            }
    3322     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3323     if (endLine)
    3324        removeLine(entry, endLine);
    3325            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3326     kernelLine->indent, initrd);
    3327            if (!line)
    3328        return 1;
    3329     if (endLine) {
    3330        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3331                if (!line)
    3332     return 1;
    3333     }
    3334    
    3335            break;
    3336        }
    3337    
    3338        return 0;
    3339    }
    3340    
    3341  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3342                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3343      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3196  int updateInitrd(struct grubConfig * cfg Line 3347  int updateInitrd(struct grubConfig * cfg
    3347      if (!image) return 0;      if (!image) return 0;
    3348    
    3349      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3350          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3351          if (!kernelLine) continue;          if (!kernelLine) continue;
    3352    
    3353          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3354          if (line)          if (line)
    3355              removeLine(entry, line);              removeLine(entry, line);
    3356          if (prefix) {          if (prefix) {
    # Line 3210  int updateInitrd(struct grubConfig * cfg Line 3361  int updateInitrd(struct grubConfig * cfg
    3361   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3362   if (endLine)   if (endLine)
    3363      removeLine(entry, endLine);      removeLine(entry, endLine);
    3364          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3365   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3366        case LT_KERNEL:
    3367            lt = LT_INITRD;
    3368     break;
    3369        case LT_KERNEL_EFI:
    3370            lt = LT_INITRD_EFI;
    3371     break;
    3372        case LT_KERNEL_16:
    3373            lt = LT_INITRD_16;
    3374     break;
    3375        default:
    3376            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3377     }
    3378            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3379          if (!line)          if (!line)
    3380      return 1;      return 1;
    3381   if (endLine) {   if (endLine) {
    # Line 3570  int addNewKernel(struct grubConfig * con Line 3734  int addNewKernel(struct grubConfig * con
    3734   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3735   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3736   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3737                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3738     const char * newDevTreePath) {
    3739      struct singleEntry * new;      struct singleEntry * new;
    3740      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3741      int needs;      int needs;
    # Line 3611  int addNewKernel(struct grubConfig * con Line 3776  int addNewKernel(struct grubConfig * con
    3776          needs |= NEED_MB;          needs |= NEED_MB;
    3777          new->multiboot = 1;          new->multiboot = 1;
    3778      }      }
    3779        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3780     needs |= NEED_DEVTREE;
    3781    
    3782      if (template) {      if (template) {
    3783   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3796  int addNewKernel(struct grubConfig * con Line 3963  int addNewKernel(struct grubConfig * con
    3963   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3964   config->cfi);   config->cfi);
    3965      }      }
    3966        } else if (tmplLine->type == LT_DEVTREE &&
    3967           tmplLine->numElements == 2 && newDevTreePath) {
    3968            newLine = addLineTmpl(new, tmplLine, newLine,
    3969          newDevTreePath + strlen(prefix),
    3970          config->cfi);
    3971     needs &= ~NEED_DEVTREE;
    3972        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3973     const char *ndtp = newDevTreePath;
    3974     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3975        ndtp += strlen(prefix);
    3976     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3977      config->secondaryIndent,
    3978      ndtp);
    3979     needs &= ~NEED_DEVTREE;
    3980     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3981      } else {      } else {
    3982   /* pass through other lines from the template */   /* pass through other lines from the template */
    3983   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3809  int addNewKernel(struct grubConfig * con Line 3991  int addNewKernel(struct grubConfig * con
    3991   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3992      case LT_KERNEL:      case LT_KERNEL:
    3993      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    3994        case LT_KERNEL_16:
    3995   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3996      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3997   } else {   } else {
    # Line 3915  int addNewKernel(struct grubConfig * con Line 4098  int addNewKernel(struct grubConfig * con
    4098   free(initrdVal);   free(initrdVal);
    4099   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4100      }      }
    4101        if (needs & NEED_DEVTREE) {
    4102     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4103      config->secondaryIndent,
    4104      newDevTreePath);
    4105     needs &= ~NEED_DEVTREE;
    4106        }
    4107    
    4108        /* NEEDS_END must be last on bootloaders that need it... */
    4109      if (needs & NEED_END) {      if (needs & NEED_END) {
    4110   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4111   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    4112   needs &= ~NEED_END;   needs &= ~NEED_END;
    4113      }      }
       
    4114      if (needs) {      if (needs) {
    4115   printf(_("grubby: needs=%d, aborting\n"), needs);   printf(_("grubby: needs=%d, aborting\n"), needs);
    4116   abort();   abort();
    # Line 3966  int main(int argc, const char ** argv) { Line 4156  int main(int argc, const char ** argv) {
    4156      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4157      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4158      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4159      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4160      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4161      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4162      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4024  int main(int argc, const char ** argv) { Line 4214  int main(int argc, const char ** argv) {
    4214      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4215   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4216      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4217     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4218        _("device tree file for new stanza"), _("dtb-path") },
    4219   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4220      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4221   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4189  int main(int argc, const char ** argv) { Line 4381  int main(int argc, const char ** argv) {
    4381      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4382      }      }
    4383    
    4384      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4385      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4386      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4387      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4198  int main(int argc, const char ** argv) { Line 4390  int main(int argc, const char ** argv) {
    4390   return 1;   return 1;
    4391      }      }
    4392    
    4393      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4394     removeKernelPath)) {     removeKernelPath)) {
    4395   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4396    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4367  int main(int argc, const char ** argv) { Line 4559  int main(int argc, const char ** argv) {
    4559   if (!entry) return 0;   if (!entry) return 0;
    4560   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4561    
    4562   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);
    4563   if (!line) return 0;   if (!line) return 0;
    4564    
    4565          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4428  int main(int argc, const char ** argv) { Line 4620  int main(int argc, const char ** argv) {
    4620      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4621                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4622      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4623              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4624                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4625     bootPrefix, newKernelInitrd))
    4626        return 1;
    4627        } else {
    4628        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4629     newKernelInitrd))
    4630     return 1;
    4631        }
    4632      }      }
    4633      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4634                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4635                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4636                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4637            
    4638    
    4639      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2255  
    changed lines
      Added in v.2708