Magellan Linux

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

    Diff of /tags/grubby-8_36/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 2959 by niro, Wed Jun 29 14:07:33 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:   case LT_INITRD:
    734      return LT_INITRD_EFI;      return isEfiOnly ? LT_INITRD : LT_INITRD_EFI;
    735   default:   default:
    736      return type;      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:
    744        return LT_INITRD_16;
    745     default:
    746        return type;
    747     }
    748    #endif
    749      }      }
    750      return type;      return type;
    751  }  }
    # Line 1066  static int getNextLine(char ** bufPtr, s Line 1094  static int getNextLine(char ** bufPtr, s
    1094      return 0;      return 0;
    1095  }  }
    1096    
    1097    static int isnumber(const char *s)
    1098    {
    1099        int i;
    1100        for (i = 0; s[i] != '\0'; i++)
    1101     if (s[i] < '0' || s[i] > '9')
    1102        return 0;
    1103        return i;
    1104    }
    1105    
    1106  static struct grubConfig * readConfig(const char * inName,  static struct grubConfig * readConfig(const char * inName,
    1107        struct configFileInfo * cfi) {        struct configFileInfo * cfi) {
    1108      int in;      int in;
    # Line 1156  static struct grubConfig * readConfig(co Line 1193  static struct grubConfig * readConfig(co
    1193   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;   cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1194   defaultLine = line;   defaultLine = line;
    1195      }      }
      } else if (line->type == LT_DEFAULT && line->numElements == 2) {  
         cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;  
         defaultLine = line;  
    1196    
    1197          } else if (iskernel(line->type)) {          } else if (iskernel(line->type)) {
    1198      /* if by some freak chance this is multiboot and the "module"      /* if by some freak chance this is multiboot and the "module"
    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 1191  static struct grubConfig * readConfig(co Line 1225  static struct grubConfig * readConfig(co
    1225      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);      cfg->fallbackImage = strtol(line->elements[1].item, &end, 10);
    1226      if (*end) cfg->fallbackImage = -1;      if (*end) cfg->fallbackImage = -1;
    1227    
    1228   } else if (line->type == LT_TITLE && line->numElements > 1) {   } else if ((line->type == LT_DEFAULT && cfi->defaultIsUnquoted) ||
    1229      /* make the title a single argument (undoing our parsing) */                  (line->type == LT_TITLE && line->numElements > 1)) {
    1230        /* make the title/default a single argument (undoing our parsing) */
    1231      len = 0;      len = 0;
    1232      for (int i = 1; i < line->numElements; i++) {      for (int i = 1; i < line->numElements; i++) {
    1233   len += strlen(line->elements[i].item);   len += strlen(line->elements[i].item);
    # Line 1299  static struct grubConfig * readConfig(co Line 1334  static struct grubConfig * readConfig(co
    1334      }      }
    1335   }   }
    1336    
    1337     if (line->type == LT_DEFAULT && line->numElements == 2) {
    1338        cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
    1339        defaultLine = line;
    1340     }
    1341    
    1342   /* If we find a generic config option which should live at the   /* If we find a generic config option which should live at the
    1343     top of the file, move it there. Old versions of grubby were     top of the file, move it there. Old versions of grubby were
    1344     probably responsible for putting new images in the wrong     probably responsible for putting new images in the wrong
    # Line 1362  static struct grubConfig * readConfig(co Line 1402  static struct grubConfig * readConfig(co
    1402      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1403      if (defTitle) {      if (defTitle) {
    1404   int index = 0;   int index = 0;
    1405   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    1406        index = atoi(defTitle);
    1407        entry = findEntryByIndex(cfg, index);
    1408     } else {
    1409        entry = findEntryByTitle(cfg, defTitle, &index);
    1410     }
    1411   if (entry)   if (entry)
    1412      cfg->defaultImage = index;      cfg->defaultImage = index;
    1413      }      }
    # Line 1411  static struct grubConfig * readConfig(co Line 1456  static struct grubConfig * readConfig(co
    1456   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");   char *defTitle = cfi->getEnv(cfg->cfi, "saved_entry");
    1457   if (defTitle) {   if (defTitle) {
    1458      int index = 0;      int index = 0;
    1459      entry = findEntryByTitle(cfg, defTitle, &index);      if (isnumber(defTitle)) {
    1460     index = atoi(defTitle);
    1461     entry = findEntryByIndex(cfg, index);
    1462        } else {
    1463     entry = findEntryByTitle(cfg, defTitle, &index);
    1464        }
    1465      if (entry)      if (entry)
    1466   cfg->defaultImage = index;   cfg->defaultImage = index;
    1467   }   }
    # Line 1786  int suitableImage(struct singleEntry * e Line 1836  int suitableImage(struct singleEntry * e
    1836   return 0;   return 0;
    1837      }      }
    1838    
    1839      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);      line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    1840      if (!line) {      if (!line) {
    1841   notSuitablePrintf(entry, 0, "no line found\n");   notSuitablePrintf(entry, 0, "no line found\n");
    1842   return 0;   return 0;
    # Line 1910  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 1971  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 1995  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 2062  struct singleEntry * findTemplate(struct Line 2114  struct singleEntry * findTemplate(struct
    2114      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");      char *defTitle = cfg->cfi->getEnv(cfg->cfi, "saved_entry");
    2115      if (defTitle) {      if (defTitle) {
    2116   int index = 0;   int index = 0;
    2117   entry = findEntryByTitle(cfg, defTitle, &index);   if (isnumber(defTitle)) {
    2118        index = atoi(defTitle);
    2119        entry = findEntryByIndex(cfg, index);
    2120     } else {
    2121        entry = findEntryByTitle(cfg, defTitle, &index);
    2122     }
    2123     if (entry && suitableImage(entry, prefix, skipRemoved, flags)) {
    2124        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 2219  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 2287  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 2310  void displayEntry(struct singleEntry * e Line 2374  void displayEntry(struct singleEntry * e
    2374   if (title)   if (title)
    2375      printf("title=%s\n", title);      printf("title=%s\n", title);
    2376      }      }
    2377    
    2378        for (j = 0, line = entry->lines; line; line = line->next) {
    2379     if ((line->type & LT_MBMODULE) && line->numElements >= 2) {
    2380        if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
    2381     printf("mbmodule%d=", j);
    2382        else
    2383     printf("mbmodule%d=%s", j, prefix);
    2384    
    2385        for (i = 1; i < line->numElements; i++)
    2386     printf("%s%s", line->elements[i].item, line->elements[i].indent);
    2387        printf("\n");
    2388        j++;
    2389     }
    2390        }
    2391  }  }
    2392    
    2393  int isSuseSystem(void) {  int isSuseSystem(void) {
    # Line 2704  struct singleLine * addLineTmpl(struct s Line 2782  struct singleLine * addLineTmpl(struct s
    2782   insertElement(newLine, val, 1, cfi);   insertElement(newLine, val, 1, cfi);
    2783    
    2784   /* but try to keep the rootspec from the template... sigh */   /* but try to keep the rootspec from the template... sigh */
    2785   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)) {
    2786      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);      char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
    2787      if (rootspec != NULL) {      if (rootspec != NULL) {
    2788   free(newLine->elements[1].item);   free(newLine->elements[1].item);
    # Line 3074  int updateActualImage(struct grubConfig Line 3152  int updateActualImage(struct grubConfig
    3152      firstElement = 2;      firstElement = 2;
    3153    
    3154   } else {   } else {
    3155      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);
    3156      if (!line) {      if (!line) {
    3157   /* no LT_KERNEL or LT_MBMODULE in this entry? */   /* no LT_KERNEL or LT_MBMODULE in this entry? */
    3158   continue;   continue;
    # Line 3230  int updateImage(struct grubConfig * cfg, Line 3308  int updateImage(struct grubConfig * cfg,
    3308      return rc;      return rc;
    3309  }  }
    3310    
    3311    int addMBInitrd(struct grubConfig * cfg, const char *newMBKernel,
    3312     const char * image, const char * prefix, const char * initrd) {
    3313        struct singleEntry * entry;
    3314        struct singleLine * line, * kernelLine, *endLine = NULL;
    3315        int index = 0;
    3316    
    3317        if (!image) return 0;
    3318    
    3319        for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3320            kernelLine = getLineByType(LT_MBMODULE, entry->lines);
    3321            if (!kernelLine) continue;
    3322    
    3323            if (prefix) {
    3324                int prefixLen = strlen(prefix);
    3325                if (!strncmp(initrd, prefix, prefixLen))
    3326                    initrd += prefixLen;
    3327            }
    3328     endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3329     if (endLine)
    3330        removeLine(entry, endLine);
    3331            line = addLine(entry, cfg->cfi, preferredLineType(LT_MBMODULE,cfg->cfi),
    3332     kernelLine->indent, initrd);
    3333            if (!line)
    3334        return 1;
    3335     if (endLine) {
    3336        line = addLine(entry, cfg->cfi, LT_ENTRY_END, "", NULL);
    3337                if (!line)
    3338     return 1;
    3339     }
    3340    
    3341            break;
    3342        }
    3343    
    3344        return 0;
    3345    }
    3346    
    3347  int updateInitrd(struct grubConfig * cfg, const char * image,  int updateInitrd(struct grubConfig * cfg, const char * image,
    3348                   const char * prefix, const char * initrd) {                   const char * prefix, const char * initrd) {
    3349      struct singleEntry * entry;      struct singleEntry * entry;
    # Line 3239  int updateInitrd(struct grubConfig * cfg Line 3353  int updateInitrd(struct grubConfig * cfg
    3353      if (!image) return 0;      if (!image) return 0;
    3354    
    3355      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
    3356          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);          kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI|LT_KERNEL_16, entry->lines);
    3357          if (!kernelLine) continue;          if (!kernelLine) continue;
    3358    
    3359          line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);          line = getLineByType(LT_INITRD|LT_INITRD_EFI|LT_INITRD_16, entry->lines);
    3360          if (line)          if (line)
    3361              removeLine(entry, line);              removeLine(entry, line);
    3362          if (prefix) {          if (prefix) {
    # Line 3253  int updateInitrd(struct grubConfig * cfg Line 3367  int updateInitrd(struct grubConfig * cfg
    3367   endLine = getLineByType(LT_ENTRY_END, entry->lines);   endLine = getLineByType(LT_ENTRY_END, entry->lines);
    3368   if (endLine)   if (endLine)
    3369      removeLine(entry, endLine);      removeLine(entry, endLine);
    3370          line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),   enum lineType_e lt;
    3371   kernelLine->indent, initrd);   switch(kernelLine->type) {
    3372        case LT_KERNEL:
    3373            lt = LT_INITRD;
    3374     break;
    3375        case LT_KERNEL_EFI:
    3376            lt = LT_INITRD_EFI;
    3377     break;
    3378        case LT_KERNEL_16:
    3379            lt = LT_INITRD_16;
    3380     break;
    3381        default:
    3382            lt = preferredLineType(LT_INITRD, cfg->cfi);
    3383     }
    3384            line = addLine(entry, cfg->cfi, lt, kernelLine->indent, initrd);
    3385          if (!line)          if (!line)
    3386      return 1;      return 1;
    3387   if (endLine) {   if (endLine) {
    # Line 3613  int addNewKernel(struct grubConfig * con Line 3740  int addNewKernel(struct grubConfig * con
    3740   const char * newKernelPath, const char * newKernelTitle,   const char * newKernelPath, const char * newKernelTitle,
    3741   const char * newKernelArgs, const char * newKernelInitrd,   const char * newKernelArgs, const char * newKernelInitrd,
    3742   const char ** extraInitrds, int extraInitrdCount,   const char ** extraInitrds, int extraInitrdCount,
    3743                   const char * newMBKernel, const char * newMBKernelArgs) {                   const char * newMBKernel, const char * newMBKernelArgs,
    3744     const char * newDevTreePath) {
    3745      struct singleEntry * new;      struct singleEntry * new;
    3746      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;      struct singleLine * newLine = NULL, * tmplLine = NULL, * masterLine = NULL;
    3747      int needs;      int needs;
    # Line 3654  int addNewKernel(struct grubConfig * con Line 3782  int addNewKernel(struct grubConfig * con
    3782          needs |= NEED_MB;          needs |= NEED_MB;
    3783          new->multiboot = 1;          new->multiboot = 1;
    3784      }      }
    3785        if (newDevTreePath && getKeywordByType(LT_DEVTREE, config->cfi))
    3786     needs |= NEED_DEVTREE;
    3787    
    3788      if (template) {      if (template) {
    3789   for (masterLine = template->lines;   for (masterLine = template->lines;
    # Line 3839  int addNewKernel(struct grubConfig * con Line 3969  int addNewKernel(struct grubConfig * con
    3969   newLine = addLineTmpl(new, tmplLine, newLine, NULL,   newLine = addLineTmpl(new, tmplLine, newLine, NULL,
    3970   config->cfi);   config->cfi);
    3971      }      }
    3972        } else if (tmplLine->type == LT_DEVTREE &&
    3973           tmplLine->numElements == 2 && newDevTreePath) {
    3974            newLine = addLineTmpl(new, tmplLine, newLine,
    3975          newDevTreePath + strlen(prefix),
    3976          config->cfi);
    3977     needs &= ~NEED_DEVTREE;
    3978        } else if (tmplLine->type == LT_ENTRY_END && needs & NEED_DEVTREE) {
    3979     const char *ndtp = newDevTreePath;
    3980     if (!strncmp(newDevTreePath, prefix, strlen(prefix)))
    3981        ndtp += strlen(prefix);
    3982     newLine = addLine(new, config->cfi, LT_DEVTREE,
    3983      config->secondaryIndent,
    3984      ndtp);
    3985     needs &= ~NEED_DEVTREE;
    3986     newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    3987      } else {      } else {
    3988   /* pass through other lines from the template */   /* pass through other lines from the template */
    3989   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);   newLine = addLineTmpl(new, tmplLine, newLine, NULL, config->cfi);
    # Line 3852  int addNewKernel(struct grubConfig * con Line 3997  int addNewKernel(struct grubConfig * con
    3997   switch (config->cfi->entryStart) {   switch (config->cfi->entryStart) {
    3998      case LT_KERNEL:      case LT_KERNEL:
    3999      case LT_KERNEL_EFI:      case LT_KERNEL_EFI:
    4000        case LT_KERNEL_16:
    4001   if (new->multiboot && config->cfi->mbHyperFirst) {   if (new->multiboot && config->cfi->mbHyperFirst) {
    4002      /* fall through to LT_HYPER */      /* fall through to LT_HYPER */
    4003   } else {   } else {
    # Line 3913  int addNewKernel(struct grubConfig * con Line 4059  int addNewKernel(struct grubConfig * con
    4059   }   }
    4060      }      }
    4061    
    4062        struct singleLine *endLine = NULL;
    4063        endLine = getLineByType(LT_ENTRY_END, new->lines);
    4064        if (endLine) {
    4065        removeLine(new, endLine);
    4066        needs |= NEED_END;
    4067        }
    4068    
    4069      /* add the remainder of the lines, i.e. those that either      /* add the remainder of the lines, i.e. those that either
    4070       * 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,
    4071       * all the lines following the entryStart.       * all the lines following the entryStart.
    # Line 3958  int addNewKernel(struct grubConfig * con Line 4111  int addNewKernel(struct grubConfig * con
    4111   free(initrdVal);   free(initrdVal);
    4112   needs &= ~NEED_INITRD;   needs &= ~NEED_INITRD;
    4113      }      }
    4114        if (needs & NEED_DEVTREE) {
    4115     newLine = addLine(new, config->cfi, LT_DEVTREE,
    4116      config->secondaryIndent,
    4117      newDevTreePath);
    4118     needs &= ~NEED_DEVTREE;
    4119        }
    4120    
    4121        /* NEEDS_END must be last on bootloaders that need it... */
    4122      if (needs & NEED_END) {      if (needs & NEED_END) {
    4123   newLine = addLine(new, config->cfi, LT_ENTRY_END,   newLine = addLine(new, config->cfi, LT_ENTRY_END,
    4124   config->secondaryIndent, NULL);   config->secondaryIndent, NULL);
    # Line 4009  int main(int argc, const char ** argv) { Line 4170  int main(int argc, const char ** argv) {
    4170      char * newKernelArgs = NULL;      char * newKernelArgs = NULL;
    4171      char * newKernelInitrd = NULL;      char * newKernelInitrd = NULL;
    4172      char * newKernelTitle = NULL;      char * newKernelTitle = NULL;
    4173      char * newKernelVersion = NULL;      char * newDevTreePath = NULL;
    4174      char * newMBKernel = NULL;      char * newMBKernel = NULL;
    4175      char * newMBKernelArgs = NULL;      char * newMBKernelArgs = NULL;
    4176      char * removeMBKernelArgs = NULL;      char * removeMBKernelArgs = NULL;
    # Line 4067  int main(int argc, const char ** argv) { Line 4228  int main(int argc, const char ** argv) {
    4228      _("display the index of the default kernel") },      _("display the index of the default kernel") },
    4229   { "default-title", 0, 0, &displayDefaultTitle, 0,   { "default-title", 0, 0, &displayDefaultTitle, 0,
    4230      _("display the title of the default kernel") },      _("display the title of the default kernel") },
    4231     { "devtree", 0, POPT_ARG_STRING, &newDevTreePath, 0,
    4232        _("device tree file for new stanza"), _("dtb-path") },
    4233   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,   { "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
    4234      _("configure elilo bootloader") },      _("configure elilo bootloader") },
    4235   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,   { "efi", 0, POPT_ARG_NONE, &isEfi, 0,
    # Line 4232  int main(int argc, const char ** argv) { Line 4395  int main(int argc, const char ** argv) {
    4395      grubConfig = cfi->defaultConfig;      grubConfig = cfi->defaultConfig;
    4396      }      }
    4397    
    4398      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||      if (bootloaderProbe && (displayDefault || kernelInfo ||
    4399      newKernelPath || removeKernelPath || makeDefault ||      newKernelPath || removeKernelPath || makeDefault ||
    4400      defaultKernel || displayDefaultIndex || displayDefaultTitle ||      defaultKernel || displayDefaultIndex || displayDefaultTitle ||
    4401      (defaultIndex >= 0))) {      (defaultIndex >= 0))) {
    # Line 4241  int main(int argc, const char ** argv) { Line 4404  int main(int argc, const char ** argv) {
    4404   return 1;   return 1;
    4405      }      }
    4406    
    4407      if ((displayDefault || kernelInfo) && (newKernelVersion || newKernelPath ||      if ((displayDefault || kernelInfo) && (newKernelPath ||
    4408     removeKernelPath)) {     removeKernelPath)) {
    4409   fprintf(stderr, _("grubby: --default-kernel and --info may not "   fprintf(stderr, _("grubby: --default-kernel and --info may not "
    4410    "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 4573  int main(int argc, const char ** argv) {
    4573   if (!entry) return 0;   if (!entry) return 0;
    4574   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;   if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
    4575    
    4576   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);
    4577   if (!line) return 0;   if (!line) return 0;
    4578    
    4579          rootspec = getRootSpecifier(line->elements[1].item);          rootspec = getRootSpecifier(line->elements[1].item);
    # Line 4471  int main(int argc, const char ** argv) { Line 4634  int main(int argc, const char ** argv) {
    4634      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
    4635                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;
    4636      if (updateKernelPath && newKernelInitrd) {      if (updateKernelPath && newKernelInitrd) {
    4637              if (updateInitrd(config, updateKernelPath, bootPrefix,      if (newMBKernel) {
    4638                               newKernelInitrd)) return 1;      if (addMBInitrd(config, newMBKernel, updateKernelPath,
    4639     bootPrefix, newKernelInitrd))
    4640        return 1;
    4641        } else {
    4642        if (updateInitrd(config, updateKernelPath, bootPrefix,
    4643     newKernelInitrd))
    4644     return 1;
    4645        }
    4646      }      }
    4647      if (addNewKernel(config, template, bootPrefix, newKernelPath,      if (addNewKernel(config, template, bootPrefix, newKernelPath,
    4648                       newKernelTitle, newKernelArgs, newKernelInitrd,                       newKernelTitle, newKernelArgs, newKernelInitrd,
    4649                       (const char **)extraInitrds, extraInitrdCount,                       (const char **)extraInitrds, extraInitrdCount,
    4650                       newMBKernel, newMBKernelArgs)) return 1;                       newMBKernel, newMBKernelArgs, newDevTreePath)) return 1;
    4651            
    4652    
    4653      if (numEntries(config) == 0) {      if (numEntries(config) == 0) {
    Legend:
    Removed from v.2257  
    changed lines
      Added in v.2959