Magellan Linux

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

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

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

    revision 2257 by niro, Mon Oct 21 14:01:48 2013 UTC revision 2692 by niro, Wed Jul 16 10:45:12 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 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 338  static int grub2SetEnv(struct configFile Line 354  static int grub2SetEnv(struct configFile
    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);      unquote(value);
    360      value = shellEscape(value);      value = shellEscape(value);
    361      if (!value)      if (!value)
    362      return -1;      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);      free(value);
    366      if (rc <0)      if (rc <0)
    367   return -1;   return -1;
    # Line 396  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 621  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 712  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 1066  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 1156  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"
    # Line 1191  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 1299  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 1362  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 1411  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 1786  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 1920  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 1971  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 1995  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 2062  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 2222  void displayEntry(struct singleEntry * e Line 2279  void displayEntry(struct singleEntry * e
    2279    
    2280      printf("index=%d\n", index);      printf("index=%d\n", index);
    2281    
    2282      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);
    2283      if (!line) {      if (!line) {
    2284          printf("non linux entry\n");          printf("non linux entry\n");
    2285          return;          return;
    # Line 2287  void displayEntry(struct singleEntry * e Line 2344  void displayEntry(struct singleEntry * e
    2344   printf("root=%s\n", s);   printf("root=%s\n", s);
    2345      }      }
    2346    
    2347      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2348    
    2349      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2350   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2704  struct singleLine * addLineTmpl(struct s Line 2761  struct singleLine * addLineTmpl(struct s
    2761   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2762    
    2763   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2764   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)) {
    2765      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2766      if (rootspec != NULL) {      if (rootspec != NULL) {
    2767   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3074  int updateActualImage(struct grubConfig Line 3131  int updateActualImage(struct grubConfig
    3131      firstElement = 2;      firstElement = 2;
    3132    
    3133   } else {   } else {
    3134      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);
    3135      if (!line) {      if (!line) {
    3136   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3137   continue;   continue;
    # Line 3230  int updateImage(struct grubConfig * cfg, Line 3287  int updateImage(struct grubConfig * cfg,
    3287      return rc;      return rc;
    3288  }  }
    3289    
    3290    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3291     const char * image, const char * prefix, const char * initrd) {
    3292        struct singleEntry * entry;
    3293        struct singleLine * line, * kernelLine, *endLine = NULL;
    3294        int index = 0;
    3295    
    3296        if (!image) return 0;
    3297    
    3298        for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
    3299            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3300            if (!kernelLine) continue;
    3301    
    3302            if (prefix) {
    3303                int prefixLen = strlen(prefix);
    3304                if (!strncmp(initrd, prefix, prefixLen))
    3305                    initrd += prefixLen;
    3306            }
    3307     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3308     if (endLine)
    3309        removeLine(entry, endLine);
    3310            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3311     kernelLine->indent, initrd);
    3312            if (!line)
    3313        return 1;
    3314     if (endLine) {
    3315        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3316                if (!line)
    3317     return 1;
    3318     }
    3319    
    3320            break;
    3321        }
    3322    
    3323        return 0;
    3324    }
    3325    
    3326  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3327                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3328      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3239  int updateInitrd(struct grubConfig * cfg Line 3332  int updateInitrd(struct grubConfig * cfg
    3332      if (!image) return 0;      if (!image) return 0;
    3333    
    3334      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3335          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3336          if (!kernelLine) continue;          if (!kernelLine) continue;
    3337    
    3338          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3339          if (line)          if (line)
    3340              removeLine(entry, line);              removeLine(entry, line);
    3341          if (prefix) {          if (prefix) {
    # Line 3253  int updateInitrd(struct grubConfig * cfg Line 3346  int updateInitrd(struct grubConfig * cfg
    3346   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3347   if (endLine)   if (endLine)
    3348      removeLine(entry, endLine);      removeLine(entry, endLine);
    3349          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3350   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3351        case LT_KERNEL:
    3352            lt = LT_INITRD;
    3353     break;
    3354        case LT_KERNEL_EFI:
    3355            lt = LT_INITRD_EFI;
    3356     break;
    3357        case LT_KERNEL_16:
    3358            lt = LT_INITRD_16;
    3359     break;
    3360        default:
    3361            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3362     }
    3363            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3364          if (!line)          if (!line)
    3365      return 1;      return 1;
    3366   if (endLine) {   if (endLine) {
    # Line 3613  int addNewKernel(struct grubConfig * con Line 3719  int addNewKernel(struct grubConfig * con
    3719   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3720   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3721   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3722                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3723     const char * newDevTreePath) {
    3724      struct singleEntry * new;      struct singleEntry * new;
    3725      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3726      int needs;      int needs;
    # Line 3654  int addNewKernel(struct grubConfig * con Line 3761  int addNewKernel(struct grubConfig * con
    3761          needs |= NEED_MB;          needs |= NEED_MB;
    3762          new->multiboot = 1;          new->multiboot = 1;
    3763      }      }
    3764        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3765     needs |= NEED_DEVTREE;
    3766    
    3767      if (template) {      if (template) {
    3768   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3839  int addNewKernel(struct grubConfig * con Line 3948  int addNewKernel(struct grubConfig * con
    3948   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3949   config->cfi);   config->cfi);
    3950      }      }
    3951        } else if (tmplLine->type == LT_DEVTREE &&
    3952           tmplLine->numElements == 2 && newDevTreePath) {
    3953            newLine = addLineTmpl(new, tmplLine, newLine,
    3954          newDevTreePath + strlen(prefix),
    3955          config->cfi);
    3956     needs &= ~NEED_DEVTREE;
    3957        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3958     const char *ndtp = newDevTreePath;
    3959     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3960        ndtp += strlen(prefix);
    3961     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3962      config->secondaryIndent,
    3963      ndtp);
    3964     needs &= ~NEED_DEVTREE;
    3965     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3966      } else {      } else {
    3967   /* pass through other lines from the template */   /* pass through other lines from the template */
    3968   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3852  int addNewKernel(struct grubConfig * con Line 3976  int addNewKernel(struct grubConfig * con
    3976   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3977      case LT_KERNEL:      case LT_KERNEL:
    3978      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    3979        case LT_KERNEL_16:
    3980   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3981      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3982   } else {   } else {
    # Line 3958  int addNewKernel(struct grubConfig * con Line 4083  int addNewKernel(struct grubConfig * con
    4083   free(initrdVal);   free(initrdVal);
    4084   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4085      }      }
    4086        if (needs & NEED_DEVTREE) {
    4087     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4088      config->secondaryIndent,
    4089      newDevTreePath);
    4090     needs &= ~NEED_DEVTREE;
    4091        }
    4092    
    4093        /* NEEDS_END must be last on bootloaders that need it... */
    4094      if (needs & NEED_END) {      if (needs & NEED_END) {
    4095   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4096   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    4097   needs &= ~NEED_END;   needs &= ~NEED_END;
    4098      }      }
       
    4099      if (needs) {      if (needs) {
    4100   printf(_("grubby: needs=%d, aborting\n"), needs);   printf(_("grubby: needs=%d, aborting\n"), needs);
    4101   abort();   abort();
    # Line 4009  int main(int argc, const char ** argv) { Line 4141  int main(int argc, const char ** argv) {
    4141      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4142      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4143      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4144      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4145      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4146      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4147      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4067  int main(int argc, const char ** argv) { Line 4199  int main(int argc, const char ** argv) {
    4199      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4200   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4201      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4202     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4203        _("device tree file for new stanza"), _("dtb-path") },
    4204   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4205      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4206   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4232  int main(int argc, const char ** argv) { Line 4366  int main(int argc, const char ** argv) {
    4366      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4367      }      }
    4368    
    4369      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4370      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4371      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4372      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4241  int main(int argc, const char ** argv) { Line 4375  int main(int argc, const char ** argv) {
    4375   return 1;   return 1;
    4376      }      }
    4377    
    4378      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4379     removeKernelPath)) {     removeKernelPath)) {
    4380   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4381    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4410  int main(int argc, const char ** argv) { Line 4544  int main(int argc, const char ** argv) {
    4544   if (!entry) return 0;   if (!entry) return 0;
    4545   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4546    
    4547   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);
    4548   if (!line) return 0;   if (!line) return 0;
    4549    
    4550          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4471  int main(int argc, const char ** argv) { Line 4605  int main(int argc, const char ** argv) {
    4605      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4606                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4607      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4608              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4609                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4610     bootPrefix, newKernelInitrd))
    4611        return 1;
    4612        } else {
    4613        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4614     newKernelInitrd))
    4615     return 1;
    4616        }
    4617      }      }
    4618      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4619                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4620                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4621                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4622            
    4623    
    4624      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2257  
    changed lines
      Added in v.2692