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 2685 by niro, Wed Jul 16 10:38:09 2014 UTC
    # Line 90  enum lineType_e { Line 90  enum lineType_e {
    90      LT_SET_VARIABLE = 1 << 19,      LT_SET_VARIABLE = 1 << 19,
    91      LT_KERNEL_EFI   = 1 << 20,      LT_KERNEL_EFI   = 1 << 20,
    92      LT_INITRD_EFI   = 1 << 21,      LT_INITRD_EFI   = 1 << 21,
    93      LT_UNKNOWN      = 1 << 22,      LT_KERNEL_16    = 1 << 22,
    94        LT_INITRD_16    = 1 << 23,
    95        LT_DEVTREE      = 1 << 24,
    96        LT_UNKNOWN      = 1 << 25,
    97  };  };
    98    
    99  struct singleLine {  struct singleLine {
    # Line 119  struct singleEntry { Line 122  struct singleEntry {
    122  #define NEED_ARGS    (1 << 3)  #define NEED_ARGS    (1 << 3)
    123  #define NEED_MB      (1 << 4)  #define NEED_MB      (1 << 4)
    124  #define NEED_END     (1 << 5)  #define NEED_END     (1 << 5)
    125    #define NEED_DEVTREE (1 << 6)
    126    
    127  #define MAIN_DEFAULT    (1 << 0)  #define MAIN_DEFAULT    (1 << 0)
    128  #define DEFAULT_SAVED       -2  #define DEFAULT_SAVED       -2
    # Line 182  const char *grubFindConfig(struct config Line 186  const char *grubFindConfig(struct config
    186   "/boot/grub/grub.conf",   "/boot/grub/grub.conf",
    187   "/boot/grub/menu.lst",   "/boot/grub/menu.lst",
    188   "/etc/grub.conf",   "/etc/grub.conf",
    189     "/boot/grub2/grub.cfg",
    190     "/boot/grub2-efi/grub.cfg",
    191   NULL   NULL
    192      };      };
    193      static int i = -1;      static int i = -1;
    # Line 221  struct keywordTypes grub2Keywords[] = { Line 227  struct keywordTypes grub2Keywords[] = {
    227      { "fallback",   LT_FALLBACK,    ' ' },      { "fallback",   LT_FALLBACK,    ' ' },
    228      { "linux",      LT_KERNEL,      ' ' },      { "linux",      LT_KERNEL,      ' ' },
    229      { "linuxefi",   LT_KERNEL_EFI,  ' ' },      { "linuxefi",   LT_KERNEL_EFI,  ' ' },
    230        { "linux16",    LT_KERNEL_16,   ' ' },
    231      { "initrd",     LT_INITRD,      ' ', ' ' },      { "initrd",     LT_INITRD,      ' ', ' ' },
    232      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },      { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
    233        { "initrd16",   LT_INITRD_16,   ' ', ' ' },
    234      { "module",     LT_MBMODULE,    ' ' },      { "module",     LT_MBMODULE,    ' ' },
    235      { "kernel",     LT_HYPER,       ' ' },      { "kernel",     LT_HYPER,       ' ' },
    236        { "devicetree", LT_DEVTREE,  ' ' },
    237      { NULL, 0, 0 },      { NULL, 0, 0 },
    238  };  };
    239    
    # Line 273  static char *grub2GetEnv(struct configFi Line 282  static char *grub2GetEnv(struct configFi
    282      static char buf[1025];      static char buf[1025];
    283      char *s = NULL;      char *s = NULL;
    284      char *ret = NULL;      char *ret = NULL;
    285      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    286      int rc = asprintf(&s, "grub2-editenv %s list | grep '^%s='", envFile, name);      int rc = asprintf(&s, "grub-editenv %s list | grep '^%s='", envFile, name);
    287    
    288      if (rc < 0)      if (rc < 0)
    289   return NULL;   return NULL;
    # Line 338  static int grub2SetEnv(struct configFile Line 347  static int grub2SetEnv(struct configFile
    347  {  {
    348      char *s = NULL;      char *s = NULL;
    349      int rc = 0;      int rc = 0;
    350      char *envFile = info->envFile ? info->envFile : "/boot/grub2/grubenv";      char *envFile = info->envFile ? info->envFile : "/boot/grub/grubenv";
    351    
    352      unquote(value);      unquote(value);
    353      value = shellEscape(value);      value = shellEscape(value);
    354      if (!value)      if (!value)
    355      return -1;      return -1;
    356    
    357      rc = asprintf(&s, "grub2-editenv %s set '%s=%s'", envFile, name, value);      rc = asprintf(&s, "grub-editenv %s set '%s=%s'", envFile, name, value);
    358      free(value);      free(value);
    359      if (rc <0)      if (rc <0)
    360   return -1;   return -1;
    # Line 396  static int isquote(char q) Line 405  static int isquote(char q)
    405  }  }
    406    
    407  static int iskernel(enum lineType_e type) {  static int iskernel(enum lineType_e type) {
    408      return (type == LT_KERNEL || type == LT_KERNEL_EFI);      return (type == LT_KERNEL || type == LT_KERNEL_EFI || type == LT_KERNEL_16);
    409  }  }
    410    
    411  static int isinitrd(enum lineType_e type) {  static int isinitrd(enum lineType_e type) {
    412      return (type == LT_INITRD || type == LT_INITRD_EFI);      return (type == LT_INITRD || type == LT_INITRD_EFI || type == LT_INITRD_16);
    413  }  }
    414    
    415  char *grub2ExtractTitle(struct singleLine * line) {  char *grub2ExtractTitle(struct singleLine * line) {
    # Line 718  static enum lineType_e preferredLineType Line 727  static enum lineType_e preferredLineType
    727   default:   default:
    728      return type;      return type;
    729   }   }
    730    #if defined(__i386__) || defined(__x86_64__)
    731        } else if (cfi == &grub2ConfigType) {
    732     switch (type) {
    733     case LT_KERNEL:
    734        return LT_KERNEL_16;
    735     case LT_INITRD:
    736        return LT_INITRD_16;
    737     default:
    738        return type;
    739     }
    740    #endif
    741      }      }
    742      return type;      return type;
    743  }  }
    # Line 1066  static int getNextLine(char ** bufPtr, s Line 1086  static int getNextLine(char ** bufPtr, s
    1086      return 0;      return 0;
    1087  }  }
    1088    
    1089    static int isnumber(const char *s)
    1090    {
    1091        int i;
    1092        for (i = 0; s[i] != '\0'; i++)
    1093     if (s[i] < '0' || s[i] > '9')
    1094        return 0;
    1095        return i;
    1096    }
    1097    
    1098  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1099        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1100      int in;      int in;
    # Line 1362  static struct grubConfig * readConfig(co Line 1391  static struct grubConfig * readConfig(co
    1391      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1392      if (defTitle) {      if (defTitle) {
    1393   int index = 0;   int index = 0;
    1394   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    1395        index = atoi(defTitle);
    1396        entry = findEntryByIndex(cfg, index);
    1397     } else {
    1398        entry = findEntryByTitle(cfg, defTitle, &index);
    1399     }
    1400   if (entry)   if (entry)
    1401      cfg->defaultImage = index;      cfg->defaultImage = index;
    1402      }      }
    # Line 1411  static struct grubConfig * readConfig(co Line 1445  static struct grubConfig * readConfig(co
    1445   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1446   if (defTitle) {   if (defTitle) {
    1447      int index = 0;      int index = 0;
    1448      entry = findEntryByTitle(cfg, defTitle, &index);      if (isnumber(defTitle)) {
    1449     index = atoi(defTitle);
    1450     entry = findEntryByIndex(cfg, index);
    1451        } else {
    1452     entry = findEntryByTitle(cfg, defTitle, &index);
    1453        }
    1454      if (entry)      if (entry)
    1455   cfg->defaultImage = index;   cfg->defaultImage = index;
    1456   }   }
    # Line 1786  int suitableImage(struct singleEntry * e Line 1825  int suitableImage(struct singleEntry * e
    1825   return 0;   return 0;
    1826      }      }
    1827    
    1828      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);
    1829      if (!line) {      if (!line) {
    1830   notSuitablePrintf(entry, 0, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1831   return 0;   return 0;
    # Line 1920  struct singleEntry * findEntryByPath(str Line 1959  struct singleEntry * findEntryByPath(str
    1959   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1960   if (!entry) return NULL;   if (!entry) return NULL;
    1961    
    1962   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);
    1963   if (!line) return NULL;   if (!line) return NULL;
    1964    
    1965   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1971  struct singleEntry * findEntryByPath(str Line 2010  struct singleEntry * findEntryByPath(str
    2010      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2011   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2012   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2013      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2014   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2015      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2016   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2017   if (!line)   if (!line)
    2018      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 1995  struct singleEntry * findEntryByPath(str Line 2034  struct singleEntry * findEntryByPath(str
    2034       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2035       * unfortunate)       * unfortunate)
    2036       */       */
    2037      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))
    2038   break; /* found 'im! */   break; /* found 'im! */
    2039   }   }
    2040    
    # Line 2062  struct singleEntry * findTemplate(struct Line 2101  struct singleEntry * findTemplate(struct
    2101      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2102      if (defTitle) {      if (defTitle) {
    2103   int index = 0;   int index = 0;
    2104   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    2105        index = atoi(defTitle);
    2106        entry = findEntryByIndex(cfg, index);
    2107     } else {
    2108        entry = findEntryByTitle(cfg, defTitle, &index);
    2109     }
    2110     if (entry)
    2111        cfg->defaultImage = index;
    2112      }      }
    2113   }   }
    2114      } else if (cfg->defaultImage > -1) {      } else if (cfg->defaultImage > -1) {
    # Line 2222  void displayEntry(struct singleEntry * e Line 2268  void displayEntry(struct singleEntry * e
    2268    
    2269      printf("index=%d\n", index);      printf("index=%d\n", index);
    2270    
    2271      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);
    2272      if (!line) {      if (!line) {
    2273          printf("non linux entry\n");          printf("non linux entry\n");
    2274          return;          return;
    # Line 2287  void displayEntry(struct singleEntry * e Line 2333  void displayEntry(struct singleEntry * e
    2333   printf("root=%s\n", s);   printf("root=%s\n", s);
    2334      }      }
    2335    
    2336      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2337    
    2338      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2339   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 2750  struct singleLine * addLineTmpl(struct s
    2750   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2751    
    2752   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2753   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)) {
    2754      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2755      if (rootspec != NULL) {      if (rootspec != NULL) {
    2756   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3074  int updateActualImage(struct grubConfig Line 3120  int updateActualImage(struct grubConfig
    3120      firstElement = 2;      firstElement = 2;
    3121    
    3122   } else {   } else {
    3123      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);
    3124      if (!line) {      if (!line) {
    3125   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3126   continue;   continue;
    # Line 3230  int updateImage(struct grubConfig * cfg, Line 3276  int updateImage(struct grubConfig * cfg,
    3276      return rc;      return rc;
    3277  }  }
    3278    
    3279    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3280     const char * image, const char * prefix, const char * initrd) {
    3281        struct singleEntry * entry;
    3282        struct singleLine * line, * kernelLine, *endLine = NULL;
    3283        int index = 0;
    3284    
    3285        if (!image) return 0;
    3286    
    3287        for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {
    3288            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3289            if (!kernelLine) continue;
    3290    
    3291            if (prefix) {
    3292                int prefixLen = strlen(prefix);
    3293                if (!strncmp(initrd, prefix, prefixLen))
    3294                    initrd += prefixLen;
    3295            }
    3296     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3297     if (endLine)
    3298        removeLine(entry, endLine);
    3299            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3300     kernelLine->indent, initrd);
    3301            if (!line)
    3302        return 1;
    3303     if (endLine) {
    3304        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3305                if (!line)
    3306     return 1;
    3307     }
    3308    
    3309            break;
    3310        }
    3311    
    3312        return 0;
    3313    }
    3314    
    3315  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3316                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3317      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3239  int updateInitrd(struct grubConfig * cfg Line 3321  int updateInitrd(struct grubConfig * cfg
    3321      if (!image) return 0;      if (!image) return 0;
    3322    
    3323      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3324          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3325          if (!kernelLine) continue;          if (!kernelLine) continue;
    3326    
    3327          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3328          if (line)          if (line)
    3329              removeLine(entry, line);              removeLine(entry, line);
    3330          if (prefix) {          if (prefix) {
    # Line 3253  int updateInitrd(struct grubConfig * cfg Line 3335  int updateInitrd(struct grubConfig * cfg
    3335   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3336   if (endLine)   if (endLine)
    3337      removeLine(entry, endLine);      removeLine(entry, endLine);
    3338          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3339   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3340        case LT_KERNEL:
    3341            lt = LT_INITRD;
    3342     break;
    3343        case LT_KERNEL_EFI:
    3344            lt = LT_INITRD_EFI;
    3345     break;
    3346        case LT_KERNEL_16:
    3347            lt = LT_INITRD_16;
    3348     break;
    3349        default:
    3350            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3351     }
    3352            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3353          if (!line)          if (!line)
    3354      return 1;      return 1;
    3355   if (endLine) {   if (endLine) {
    # Line 3613  int addNewKernel(struct grubConfig * con Line 3708  int addNewKernel(struct grubConfig * con
    3708   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3709   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3710   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3711                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3712     const char * newDevTreePath) {
    3713      struct singleEntry * new;      struct singleEntry * new;
    3714      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3715      int needs;      int needs;
    # Line 3654  int addNewKernel(struct grubConfig * con Line 3750  int addNewKernel(struct grubConfig * con
    3750          needs |= NEED_MB;          needs |= NEED_MB;
    3751          new->multiboot = 1;          new->multiboot = 1;
    3752      }      }
    3753        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3754     needs |= NEED_DEVTREE;
    3755    
    3756      if (template) {      if (template) {
    3757   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3839  int addNewKernel(struct grubConfig * con Line 3937  int addNewKernel(struct grubConfig * con
    3937   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3938   config->cfi);   config->cfi);
    3939      }      }
    3940        } else if (tmplLine->type == LT_DEVTREE &&
    3941           tmplLine->numElements == 2 && newDevTreePath) {
    3942            newLine = addLineTmpl(new, tmplLine, newLine,
    3943          newDevTreePath + strlen(prefix),
    3944          config->cfi);
    3945     needs &= ~NEED_DEVTREE;
    3946        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3947     const char *ndtp = newDevTreePath;
    3948     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3949        ndtp += strlen(prefix);
    3950     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3951      config->secondaryIndent,
    3952      ndtp);
    3953     needs &= ~NEED_DEVTREE;
    3954     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3955      } else {      } else {
    3956   /* pass through other lines from the template */   /* pass through other lines from the template */
    3957   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3852  int addNewKernel(struct grubConfig * con Line 3965  int addNewKernel(struct grubConfig * con
    3965   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3966      case LT_KERNEL:      case LT_KERNEL:
    3967      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    3968        case LT_KERNEL_16:
    3969   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3970      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3971   } else {   } else {
    # Line 3958  int addNewKernel(struct grubConfig * con Line 4072  int addNewKernel(struct grubConfig * con
    4072   free(initrdVal);   free(initrdVal);
    4073   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4074      }      }
    4075        if (needs & NEED_DEVTREE) {
    4076     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4077      config->secondaryIndent,
    4078      newDevTreePath);
    4079     needs &= ~NEED_DEVTREE;
    4080        }
    4081    
    4082        /* NEEDS_END must be last on bootloaders that need it... */
    4083      if (needs & NEED_END) {      if (needs & NEED_END) {
    4084   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4085   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    4086   needs &= ~NEED_END;   needs &= ~NEED_END;
    4087      }      }
       
    4088      if (needs) {      if (needs) {
    4089   printf(_("grubby: needs=%d, aborting\n"), needs);   printf(_("grubby: needs=%d, aborting\n"), needs);
    4090   abort();   abort();
    # Line 4009  int main(int argc, const char ** argv) { Line 4130  int main(int argc, const char ** argv) {
    4130      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4131      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4132      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4133      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4134      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4135      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4136      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4067  int main(int argc, const char ** argv) { Line 4188  int main(int argc, const char ** argv) {
    4188      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4189   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4190      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4191     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4192        _("device tree file for new stanza"), _("dtb-path") },
    4193   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4194      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4195   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4232  int main(int argc, const char ** argv) { Line 4355  int main(int argc, const char ** argv) {
    4355      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4356      }      }
    4357    
    4358      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4359      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4360      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4361      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4241  int main(int argc, const char ** argv) { Line 4364  int main(int argc, const char ** argv) {
    4364   return 1;   return 1;
    4365      }      }
    4366    
    4367      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4368     removeKernelPath)) {     removeKernelPath)) {
    4369   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4370    "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 4533  int main(int argc, const char ** argv) {
    4533   if (!entry) return 0;   if (!entry) return 0;
    4534   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4535    
    4536   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);
    4537   if (!line) return 0;   if (!line) return 0;
    4538    
    4539          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4471  int main(int argc, const char ** argv) { Line 4594  int main(int argc, const char ** argv) {
    4594      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4595                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4596      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4597              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4598                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4599     bootPrefix, newKernelInitrd))
    4600        return 1;
    4601        } else {
    4602        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4603     newKernelInitrd))
    4604     return 1;
    4605        }
    4606      }      }
    4607      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4608                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4609                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4610                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4611            
    4612    
    4613      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2257  
    changed lines
      Added in v.2685