Magellan Linux

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

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

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

    revision 2258 by niro, Mon Oct 21 14:02:25 2013 UTC revision 2957 by niro, Wed Jun 29 14:06:18 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 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 1165  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 1200  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 1308  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 1805  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 1929  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 1990  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 2014  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 2245  void displayEntry(struct singleEntry * e Line 2278  void displayEntry(struct singleEntry * e
    2278      struct singleLine * line;      struct singleLine * line;
    2279      char * root = NULL;      char * root = NULL;
    2280      int i;      int i;
    2281        int j;
    2282    
    2283      printf("index=%d\n", index);      printf("index=%d\n", index);
    2284    
    2285      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);
    2286      if (!line) {      if (!line) {
    2287          printf("non linux entry\n");          printf("non linux entry\n");
    2288          return;          return;
    # Line 2313  void displayEntry(struct singleEntry * e Line 2347  void displayEntry(struct singleEntry * e
    2347   printf("root=%s\n", s);   printf("root=%s\n", s);
    2348      }      }
    2349    
    2350      line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);      line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    2351    
    2352      if (line && line->numElements >= 2) {      if (line && line->numElements >= 2) {
    2353   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))   if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    # Line 2336  void displayEntry(struct singleEntry * e Line 2370  void displayEntry(struct singleEntry * e
    2370   if (title)   if (title)
    2371      printf("title=%s\n", title);      printf("title=%s\n", title);
    2372      }      }
    2373    
    2374        for (j = 0, line = entry->lines; line; line = line->next) {
    2375     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2376        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2377     printf("mbmodule%d=", j);
    2378        else
    2379     printf("mbmodule%d=%s", j, prefix);
    2380    
    2381        for (i = 1; i < line->numElements; i++)
    2382     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2383        printf("\n");
    2384        j++;
    2385     }
    2386        }
    2387  }  }
    2388    
    2389  int isSuseSystem(void) {  int isSuseSystem(void) {
    # Line 2730  struct singleLine * addLineTmpl(struct s Line 2778  struct singleLine * addLineTmpl(struct s
    2778   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2779    
    2780   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2781   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)) {
    2782      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2783      if (rootspec != NULL) {      if (rootspec != NULL) {
    2784   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3100  int updateActualImage(struct grubConfig Line 3148  int updateActualImage(struct grubConfig
    3148      firstElement = 2;      firstElement = 2;
    3149    
    3150   } else {   } else {
    3151      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);
    3152      if (!line) {      if (!line) {
    3153   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3154   continue;   continue;
    # Line 3256  int updateImage(struct grubConfig * cfg, Line 3304  int updateImage(struct grubConfig * cfg,
    3304      return rc;      return rc;
    3305  }  }
    3306    
    3307    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3308     const char * image, const char * prefix, const char * initrd) {
    3309        struct singleEntry * entry;
    3310        struct singleLine * line, * kernelLine, *endLine = NULL;
    3311        int index = 0;
    3312    
    3313        if (!image) return 0;
    3314    
    3315        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3316            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3317            if (!kernelLine) continue;
    3318    
    3319            if (prefix) {
    3320                int prefixLen = strlen(prefix);
    3321                if (!strncmp(initrd, prefix, prefixLen))
    3322                    initrd += prefixLen;
    3323            }
    3324     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3325     if (endLine)
    3326        removeLine(entry, endLine);
    3327            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3328     kernelLine->indent, initrd);
    3329            if (!line)
    3330        return 1;
    3331     if (endLine) {
    3332        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3333                if (!line)
    3334     return 1;
    3335     }
    3336    
    3337            break;
    3338        }
    3339    
    3340        return 0;
    3341    }
    3342    
    3343  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3344                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3345      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3265  int updateInitrd(struct grubConfig * cfg Line 3349  int updateInitrd(struct grubConfig * cfg
    3349      if (!image) return 0;      if (!image) return 0;
    3350    
    3351      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3352          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3353          if (!kernelLine) continue;          if (!kernelLine) continue;
    3354    
    3355          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3356          if (line)          if (line)
    3357              removeLine(entry, line);              removeLine(entry, line);
    3358          if (prefix) {          if (prefix) {
    # Line 3279  int updateInitrd(struct grubConfig * cfg Line 3363  int updateInitrd(struct grubConfig * cfg
    3363   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3364   if (endLine)   if (endLine)
    3365      removeLine(entry, endLine);      removeLine(entry, endLine);
    3366          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3367   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3368        case LT_KERNEL:
    3369            lt = LT_INITRD;
    3370     break;
    3371        case LT_KERNEL_EFI:
    3372            lt = LT_INITRD_EFI;
    3373     break;
    3374        case LT_KERNEL_16:
    3375            lt = LT_INITRD_16;
    3376     break;
    3377        default:
    3378            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3379     }
    3380            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3381          if (!line)          if (!line)
    3382      return 1;      return 1;
    3383   if (endLine) {   if (endLine) {
    # Line 3639  int addNewKernel(struct grubConfig * con Line 3736  int addNewKernel(struct grubConfig * con
    3736   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3737   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3738   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3739                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3740     const char * newDevTreePath) {
    3741      struct singleEntry * new;      struct singleEntry * new;
    3742      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3743      int needs;      int needs;
    # Line 3680  int addNewKernel(struct grubConfig * con Line 3778  int addNewKernel(struct grubConfig * con
    3778          needs |= NEED_MB;          needs |= NEED_MB;
    3779          new->multiboot = 1;          new->multiboot = 1;
    3780      }      }
    3781        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3782     needs |= NEED_DEVTREE;
    3783    
    3784      if (template) {      if (template) {
    3785   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3865  int addNewKernel(struct grubConfig * con Line 3965  int addNewKernel(struct grubConfig * con
    3965   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3966   config->cfi);   config->cfi);
    3967      }      }
    3968        } else if (tmplLine->type == LT_DEVTREE &&
    3969           tmplLine->numElements == 2 && newDevTreePath) {
    3970            newLine = addLineTmpl(new, tmplLine, newLine,
    3971          newDevTreePath + strlen(prefix),
    3972          config->cfi);
    3973     needs &= ~NEED_DEVTREE;
    3974        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3975     const char *ndtp = newDevTreePath;
    3976     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3977        ndtp += strlen(prefix);
    3978     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3979      config->secondaryIndent,
    3980      ndtp);
    3981     needs &= ~NEED_DEVTREE;
    3982     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3983      } else {      } else {
    3984   /* pass through other lines from the template */   /* pass through other lines from the template */
    3985   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3878  int addNewKernel(struct grubConfig * con Line 3993  int addNewKernel(struct grubConfig * con
    3993   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3994      case LT_KERNEL:      case LT_KERNEL:
    3995      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    3996        case LT_KERNEL_16:
    3997   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    3998      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    3999   } else {   } else {
    # Line 3939  int addNewKernel(struct grubConfig * con Line 4055  int addNewKernel(struct grubConfig * con
    4055   }   }
    4056      }      }
    4057    
    4058        struct singleLine *endLine = NULL;
    4059        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4060        if (endLine) {
    4061        removeLine(new, endLine);
    4062        needs |= NEED_END;
    4063        }
    4064    
    4065      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4066       * 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,
    4067       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3984  int addNewKernel(struct grubConfig * con Line 4107  int addNewKernel(struct grubConfig * con
    4107   free(initrdVal);   free(initrdVal);
    4108   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4109      }      }
    4110        if (needs & NEED_DEVTREE) {
    4111     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4112      config->secondaryIndent,
    4113      newDevTreePath);
    4114     needs &= ~NEED_DEVTREE;
    4115        }
    4116    
    4117        /* NEEDS_END must be last on bootloaders that need it... */
    4118      if (needs & NEED_END) {      if (needs & NEED_END) {
    4119   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4120   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 4035  int main(int argc, const char ** argv) { Line 4166  int main(int argc, const char ** argv) {
    4166      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4167      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4168      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4169      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4170      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4171      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4172      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4093  int main(int argc, const char ** argv) { Line 4224  int main(int argc, const char ** argv) {
    4224      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4225   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4226      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4227     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4228        _("device tree file for new stanza"), _("dtb-path") },
    4229   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4230      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4231   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4258  int main(int argc, const char ** argv) { Line 4391  int main(int argc, const char ** argv) {
    4391      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4392      }      }
    4393    
    4394      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4395      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4396      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4397      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4267  int main(int argc, const char ** argv) { Line 4400  int main(int argc, const char ** argv) {
    4400   return 1;   return 1;
    4401      }      }
    4402    
    4403      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4404     removeKernelPath)) {     removeKernelPath)) {
    4405   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4406    "be used when adding or removing kernels\n"));    "be used when adding or removing kernels\n"));
    # Line 4436  int main(int argc, const char ** argv) { Line 4569  int main(int argc, const char ** argv) {
    4569   if (!entry) return 0;   if (!entry) return 0;
    4570   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4571    
    4572   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);
    4573   if (!line) return 0;   if (!line) return 0;
    4574    
    4575          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4497  int main(int argc, const char ** argv) { Line 4630  int main(int argc, const char ** argv) {
    4630      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4631                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4632      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4633              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4634                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4635     bootPrefix, newKernelInitrd))
    4636        return 1;
    4637        } else {
    4638        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4639     newKernelInitrd))
    4640     return 1;
    4641        }
    4642      }      }
    4643      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4644                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4645                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4646                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4647            
    4648    
    4649      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2258  
    changed lines
      Added in v.2957