Magellan Linux

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

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

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

    revision 2263 by niro, Mon Oct 21 14:08:21 2013 UTC revision 2962 by niro, Wed Jun 29 14:40:57 2016 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 275  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 340  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 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 1931  struct singleEntry * findEntryByPath(str Line 1960  struct singleEntry * findEntryByPath(str
    1960   }   }
    1961    
    1962   indexVars[i + 1] = -1;   indexVars[i + 1] = -1;
    1963    
    1964   i = 0;   i = 0;
    1965   if (index) {   if (index) {
    1966      while (i < *index) i++;      while (i < *index) {
    1967      if (indexVars[i] == -1) return NULL;   i++;
    1968     if (indexVars[i] == -1) return NULL;
    1969        }
    1970   }   }
    1971    
    1972   entry = findEntryByIndex(config, indexVars[i]);   entry = findEntryByIndex(config, indexVars[i]);
    1973   if (!entry) return NULL;   if (!entry) return NULL;
    1974    
    1975   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);
    1976   if (!line) return NULL;   if (!line) return NULL;
    1977    
    1978   if (index) *index = indexVars[i];   if (index) *index = indexVars[i];
    # Line 1992  struct singleEntry * findEntryByPath(str Line 2023  struct singleEntry * findEntryByPath(str
    2023      for (line = entry->lines; line; line = line->next) {      for (line = entry->lines; line; line = line->next) {
    2024   enum lineType_e ct = checkType;   enum lineType_e ct = checkType;
    2025   if (entry->multiboot && checkType == LT_KERNEL)   if (entry->multiboot && checkType == LT_KERNEL)
    2026      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;      ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER|LT_KERNEL_16;
    2027   else if (checkType & LT_KERNEL)   else if (checkType & LT_KERNEL)
    2028      ct = checkType | LT_KERNEL_EFI;      ct = checkType | LT_KERNEL_EFI | LT_KERNEL_16;
    2029   line = getLineByType(ct, line);   line = getLineByType(ct, line);
    2030   if (!line)   if (!line)
    2031      break;  /* not found in this entry */      break;  /* not found in this entry */
    # Line 2016  struct singleEntry * findEntryByPath(str Line 2047  struct singleEntry * findEntryByPath(str
    2047       * non-Linux boot entries (could find netbsd etc, though, which is       * non-Linux boot entries (could find netbsd etc, though, which is
    2048       * unfortunate)       * unfortunate)
    2049       */       */
    2050      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))
    2051   break; /* found 'im! */   break; /* found 'im! */
    2052   }   }
    2053    
    # Line 2089  struct singleEntry * findTemplate(struct Line 2120  struct singleEntry * findTemplate(struct
    2120   } else {   } else {
    2121      entry = findEntryByTitle(cfg, defTitle, &index);      entry = findEntryByTitle(cfg, defTitle, &index);
    2122   }   }
    2123   if (entry)   if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2124      cfg->defaultImage = index;      cfg->defaultImage = index;
    2125        if (indexPtr)
    2126     *indexPtr = index;
    2127        return entry;
    2128     }
    2129      }      }
    2130   }   }
    2131      } else if (cfg->defaultImage > -1) {      } else if (cfg->defaultImage > -1) {
    # Line 2247  void displayEntry(struct singleEntry * e Line 2282  void displayEntry(struct singleEntry * e
    2282      struct singleLine * line;      struct singleLine * line;
    2283      char * root = NULL;      char * root = NULL;
    2284      int i;      int i;
    2285        int j;
    2286    
    2287      printf("index=%d\n", index);      printf("index=%d\n", index);
    2288    
    2289      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);
    2290      if (!line) {      if (!line) {
    2291          printf("non linux entry\n");          printf("non linux entry\n");
    2292          return;          return;
    # Line 2315  void displayEntry(struct singleEntry * e Line 2351  void displayEntry(struct singleEntry * e
    2351   printf("root=%s\n", s);   printf("root=%s\n", s);
    2352      }      }
    2353    
    2354      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2355    
    2356      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2357   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2334  void displayEntry(struct singleEntry * e Line 2370  void displayEntry(struct singleEntry * e
    2370      } else {      } else {
    2371   char * title;   char * title;
    2372   line = getLineByType(LT_MENUENTRY, entry->lines);   line = getLineByType(LT_MENUENTRY, entry->lines);
    2373   title = grub2ExtractTitle(line);   if (!line) {
    2374   if (title)      title = grub2ExtractTitle(line);
    2375      printf("title=%s\n", title);      if (title)
    2376     printf("title=%s\n", title);
    2377     }
    2378        }
    2379    
    2380        for (j = 0, line = entry->lines; line; line = line->next) {
    2381     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2382        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2383     printf("mbmodule%d=", j);
    2384        else
    2385     printf("mbmodule%d=%s", j, prefix);
    2386    
    2387        for (i = 1; i < line->numElements; i++)
    2388     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2389        printf("\n");
    2390        j++;
    2391     }
    2392      }      }
    2393  }  }
    2394    
    # Line 2732  struct singleLine * addLineTmpl(struct s Line 2784  struct singleLine * addLineTmpl(struct s
    2784   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2785    
    2786   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2787   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)) {
    2788      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2789      if (rootspec != NULL) {      if (rootspec != NULL) {
    2790   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3102  int updateActualImage(struct grubConfig Line 3154  int updateActualImage(struct grubConfig
    3154      firstElement = 2;      firstElement = 2;
    3155    
    3156   } else {   } else {
    3157      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);
    3158      if (!line) {      if (!line) {
    3159   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3160   continue;   continue;
    # Line 3259  int updateImage(struct grubConfig * cfg, Line 3311  int updateImage(struct grubConfig * cfg,
    3311  }  }
    3312    
    3313  int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,  int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3314   const char * image, const char * prefix, const char * initrd) {   const char * image, const char * prefix, const char * initrd,
    3315     const char * title) {
    3316      struct singleEntry * entry;      struct singleEntry * entry;
    3317      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3318      int index = 0;      int index = 0;
    3319    
    3320      if (!image) return 0;      if (!image) return 0;
    3321    
    3322      for (; (entry = findEntryByPath(cfg, newMBKernel, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3323          kernelLine = getLineByType(LT_MBMODULE, entry->lines);          kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3324          if (!kernelLine) continue;          if (!kernelLine) continue;
    3325    
    3326     /* if title is supplied, the entry's title must match it. */
    3327     if (title) {
    3328        char *linetitle;
    3329    
    3330        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3331        if (!line)
    3332     continue;
    3333    
    3334        linetitle = extractTitle(line);
    3335        if (!linetitle)
    3336     continue;
    3337        if (strcmp(title, linetitle)) {
    3338     free(linetitle);
    3339     continue;
    3340        }
    3341        free(linetitle);
    3342     }
    3343    
    3344          if (prefix) {          if (prefix) {
    3345              int prefixLen = strlen(prefix);              int prefixLen = strlen(prefix);
    3346              if (!strncmp(initrd, prefix, prefixLen))              if (!strncmp(initrd, prefix, prefixLen))
    # Line 3295  int addMBInitrd(struct grubConfig * cfg, Line 3366  int addMBInitrd(struct grubConfig * cfg,
    3366  }  }
    3367    
    3368  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3369                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd, const char * title) {
    3370      struct singleEntry * entry;      struct singleEntry * entry;
    3371      struct singleLine * line, * kernelLine, *endLine = NULL;      struct singleLine * line, * kernelLine, *endLine = NULL;
    3372      int index = 0;      int index = 0;
    # Line 3303  int updateInitrd(struct grubConfig * cfg Line 3374  int updateInitrd(struct grubConfig * cfg
    3374      if (!image) return 0;      if (!image) return 0;
    3375    
    3376      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3377          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3378          if (!kernelLine) continue;          if (!kernelLine) continue;
    3379    
    3380          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);   /* if title is supplied, the entry's title must match it. */
    3381     if (title) {
    3382        char *linetitle;
    3383    
    3384        line = getLineByType(LT_TITLE|LT_MENUENTRY, entry->lines);
    3385        if (!line)
    3386     continue;
    3387    
    3388        linetitle = extractTitle(line);
    3389        if (!linetitle)
    3390     continue;
    3391        if (strcmp(title, linetitle)) {
    3392     free(linetitle);
    3393     continue;
    3394        }
    3395        free(linetitle);
    3396     }
    3397    
    3398            line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3399          if (line)          if (line)
    3400              removeLine(entry, line);              removeLine(entry, line);
    3401          if (prefix) {          if (prefix) {
    # Line 3317  int updateInitrd(struct grubConfig * cfg Line 3406  int updateInitrd(struct grubConfig * cfg
    3406   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3407   if (endLine)   if (endLine)
    3408      removeLine(entry, endLine);      removeLine(entry, endLine);
    3409          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3410   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3411        case LT_KERNEL:
    3412            lt = LT_INITRD;
    3413     break;
    3414        case LT_KERNEL_EFI:
    3415            lt = LT_INITRD_EFI;
    3416     break;
    3417        case LT_KERNEL_16:
    3418            lt = LT_INITRD_16;
    3419     break;
    3420        default:
    3421            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3422     }
    3423            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3424          if (!line)          if (!line)
    3425      return 1;      return 1;
    3426   if (endLine) {   if (endLine) {
    # Line 3677  int addNewKernel(struct grubConfig * con Line 3779  int addNewKernel(struct grubConfig * con
    3779   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3780   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3781   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3782                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3783     const char * newDevTreePath) {
    3784      struct singleEntry * new;      struct singleEntry * new;
    3785      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3786      int needs;      int needs;
    # Line 3718  int addNewKernel(struct grubConfig * con Line 3821  int addNewKernel(struct grubConfig * con
    3821          needs |= NEED_MB;          needs |= NEED_MB;
    3822          new->multiboot = 1;          new->multiboot = 1;
    3823      }      }
    3824        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3825     needs |= NEED_DEVTREE;
    3826    
    3827      if (template) {      if (template) {
    3828   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3903  int addNewKernel(struct grubConfig * con Line 4008  int addNewKernel(struct grubConfig * con
    4008   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    4009   config->cfi);   config->cfi);
    4010      }      }
    4011        } else if (tmplLine->type == LT_DEVTREE &&
    4012           tmplLine->numElements == 2 && newDevTreePath) {
    4013            newLine = addLineTmpl(new, tmplLine, newLine,
    4014          newDevTreePath + strlen(prefix),
    4015          config->cfi);
    4016     needs &= ~NEED_DEVTREE;
    4017        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    4018     const char *ndtp = newDevTreePath;
    4019     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    4020        ndtp += strlen(prefix);
    4021     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4022      config->secondaryIndent,
    4023      ndtp);
    4024     needs &= ~NEED_DEVTREE;
    4025     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    4026      } else {      } else {
    4027   /* pass through other lines from the template */   /* pass through other lines from the template */
    4028   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3916  int addNewKernel(struct grubConfig * con Line 4036  int addNewKernel(struct grubConfig * con
    4036   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    4037      case LT_KERNEL:      case LT_KERNEL:
    4038      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    4039        case LT_KERNEL_16:
    4040   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4041      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4042   } else {   } else {
    # Line 3977  int addNewKernel(struct grubConfig * con Line 4098  int addNewKernel(struct grubConfig * con
    4098   }   }
    4099      }      }
    4100    
    4101        struct singleLine *endLine = NULL;
    4102        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4103        if (endLine) {
    4104        removeLine(new, endLine);
    4105        needs |= NEED_END;
    4106        }
    4107    
    4108      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4109       * 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,
    4110       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 4022  int addNewKernel(struct grubConfig * con Line 4150  int addNewKernel(struct grubConfig * con
    4150   free(initrdVal);   free(initrdVal);
    4151   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4152      }      }
    4153        if (needs & NEED_DEVTREE) {
    4154     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4155      config->secondaryIndent,
    4156      newDevTreePath);
    4157     needs &= ~NEED_DEVTREE;
    4158        }
    4159    
    4160        /* NEEDS_END must be last on bootloaders that need it... */
    4161      if (needs & NEED_END) {      if (needs & NEED_END) {
    4162   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4163   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 4073  int main(int argc, const char ** argv) { Line 4209  int main(int argc, const char ** argv) {
    4209      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4210      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4211      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4212      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4213      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4214      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4215      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4131  int main(int argc, const char ** argv) { Line 4267  int main(int argc, const char ** argv) {
    4267      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4268   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4269      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4270     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4271        _("device tree file for new stanza"), _("dtb-path") },
    4272   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4273      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4274   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4296  int main(int argc, const char ** argv) { Line 4434  int main(int argc, const char ** argv) {
    4434      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4435      }      }
    4436    
    4437      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4438      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4439      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4440      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4305  int main(int argc, const char ** argv) { Line 4443  int main(int argc, const char ** argv) {
    4443   return 1;   return 1;
    4444      }      }
    4445    
    4446      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4447     removeKernelPath)) {     removeKernelPath)) {
    4448   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4449    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4315  int main(int argc, const char ** argv) { Line 4453  int main(int argc, const char ** argv) {
    4453      if (newKernelPath && !newKernelTitle) {      if (newKernelPath && !newKernelTitle) {
    4454   fprintf(stderr, _("grubby: kernel title must be specified\n"));   fprintf(stderr, _("grubby: kernel title must be specified\n"));
    4455   return 1;   return 1;
    4456      } else if (!newKernelPath && (newKernelTitle  || copyDefault ||      } else if (!newKernelPath && (copyDefault ||
    4457    (newKernelInitrd && !updateKernelPath)||    (newKernelInitrd && !updateKernelPath)||
    4458    makeDefault || extraInitrdCount > 0)) {    makeDefault || extraInitrdCount > 0)) {
    4459   fprintf(stderr, _("grubby: kernel path expected\n"));   fprintf(stderr, _("grubby: kernel path expected\n"));
    # Line 4474  int main(int argc, const char ** argv) { Line 4612  int main(int argc, const char ** argv) {
    4612   if (!entry) return 0;   if (!entry) return 0;
    4613   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4614    
    4615   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);
    4616   if (!line) return 0;   if (!line) return 0;
    4617    
    4618          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4537  int main(int argc, const char ** argv) { Line 4675  int main(int argc, const char ** argv) {
    4675      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4676      if (newMBKernel) {      if (newMBKernel) {
    4677      if (addMBInitrd(config, newMBKernel, updateKernelPath,      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4678   bootPrefix, newKernelInitrd))   bootPrefix, newKernelInitrd,
    4679     newKernelTitle))
    4680      return 1;      return 1;
    4681      } else {      } else {
    4682      if (updateInitrd(config, updateKernelPath, bootPrefix,      if (updateInitrd(config, updateKernelPath, bootPrefix,
    4683   newKernelInitrd))   newKernelInitrd, newKernelTitle))
    4684   return 1;   return 1;
    4685      }      }
    4686      }      }
    4687      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4688                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4689                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4690                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4691            
    4692    
    4693      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2263  
    changed lines
      Added in v.2962