Magellan Linux

Diff of /trunk/grubby/grubby.c

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

revision 2682 by niro, Wed Jul 16 09:49:24 2014 UTC revision 2709 by niro, Wed Jul 16 10:57:06 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 223  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 398  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 623  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 714  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 1167  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 1202  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 1310  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 1807  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 1941  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 1992  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 2016  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 2247  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 2315  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 2338  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 2732  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 3102  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 3303  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 3317  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 3677  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 3718  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 3903  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 3916  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 3977  int addNewKernel(struct grubConfig * con Line 4053  int addNewKernel(struct grubConfig * con
4053   }   }
4054      }      }
4055    
4056        struct singleLine *endLine = NULL;
4057        endLine = getLineByType(LT_ENTRY_END, new->lines);
4058        if (endLine) {
4059        removeLine(new, endLine);
4060        needs |= NEED_END;
4061        }
4062    
4063      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
4064       * weren't present in the template, or in the case of no template,       * weren't present in the template, or in the case of no template,
4065       * all the lines following the entryStart.       * all the lines following the entryStart.
# Line 4022  int addNewKernel(struct grubConfig * con Line 4105  int addNewKernel(struct grubConfig * con
4105   free(initrdVal);   free(initrdVal);
4106   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
4107      }      }
4108        if (needs & NEED_DEVTREE) {
4109     newLine = addLine(new, config->cfi, LT_DEVTREE,
4110      config->secondaryIndent,
4111      newDevTreePath);
4112     needs &= ~NEED_DEVTREE;
4113        }
4114    
4115        /* NEEDS_END must be last on bootloaders that need it... */
4116      if (needs & NEED_END) {      if (needs & NEED_END) {
4117   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
4118   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
# Line 4073  int main(int argc, const char ** argv) { Line 4164  int main(int argc, const char ** argv) {
4164      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
4165      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
4166      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
4167      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
4168      char * newMBKernel = NULL;      char * newMBKernel = NULL;
4169      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
4170      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
# Line 4131  int main(int argc, const char ** argv) { Line 4222  int main(int argc, const char ** argv) {
4222      _("display the index of the default kernel") },      _("display the index of the default kernel") },
4223   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
4224      _("display the title of the default kernel") },      _("display the title of the default kernel") },
4225     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
4226        _("device tree file for new stanza"), _("dtb-path") },
4227   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
4228      _("configure elilo bootloader") },      _("configure elilo bootloader") },
4229   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
# Line 4296  int main(int argc, const char ** argv) { Line 4389  int main(int argc, const char ** argv) {
4389      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
4390      }      }
4391    
4392      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
4393      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
4394      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
4395      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
# Line 4305  int main(int argc, const char ** argv) { Line 4398  int main(int argc, const char ** argv) {
4398   return 1;   return 1;
4399      }      }
4400    
4401      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
4402     removeKernelPath)) {     removeKernelPath)) {
4403   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
4404    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
# Line 4474  int main(int argc, const char ** argv) { Line 4567  int main(int argc, const char ** argv) {
4567   if (!entry) return 0;   if (!entry) return 0;
4568   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
4569    
4570   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);
4571   if (!line) return 0;   if (!line) return 0;
4572    
4573          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
# Line 4548  int main(int argc, const char ** argv) { Line 4641  int main(int argc, const char ** argv) {
4641      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
4642                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
4643                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
4644                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
4645            
4646    
4647      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {

Legend:
Removed from v.2682  
changed lines
  Added in v.2709