/[magellan-source]/tags/grubby-8_32/grubby.c

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

Parent Directory | Revision Log | View Patch Patch

-revision 1849 by niro,
Mon Jul  2 13:08:29 2012 UTC
+revision 2052 by niro,
Wed Feb 20 14:00:54 2013 UTC
 Line 56 
 int debug = 0;	/* Currently just for tem
  #define NOOP_OPCODE 0x90
  #define JMP_SHORT_OPCODE 0xeb
+ int isEfi = 0;
  /* comments get lumped in with indention */
  struct lineElement {
      char * item;
-Line 82 
 enum lineType_e {
+Line 84 
 enum lineType_e {
      LT_MENUENTRY    = 1 << 17,
      LT_ENTRY_END    = 1 << 18,
      LT_SET_VARIABLE = 1 << 19,
-     LT_UNKNOWN      = 1 << 20,
+     LT_KERNEL_EFI   = 1 << 20,
+     LT_INITRD_EFI   = 1 << 21,
+     LT_UNKNOWN      = 1 << 22,
  };
  struct singleLine {
-Line 164 
 struct keywordTypes grubKeywords[] = {
+Line 168 
 struct keywordTypes grubKeywords[] = {
  const char *grubFindConfig(struct configFileInfo *cfi) {
      static const char *configFiles[] = {
- 	"/etc/grub.conf",
  	"/boot/grub/grub.conf",
  	"/boot/grub/menu.lst",
+ 	"/etc/grub.conf",
  	NULL
      };
      static int i = -1;
-Line 205 
 struct keywordTypes grub2Keywords[] = {
+Line 209 
 struct keywordTypes grub2Keywords[] = {
      { "default",    LT_DEFAULT,     ' ' },
      { "fallback",   LT_FALLBACK,    ' ' },
      { "linux",      LT_KERNEL,      ' ' },
+     { "linuxefi",   LT_KERNEL_EFI,  ' ' },
      { "initrd",     LT_INITRD,      ' ', ' ' },
+     { "initrdefi",  LT_INITRD_EFI,  ' ', ' ' },
      { "module",     LT_MBMODULE,    ' ' },
      { "kernel",     LT_HYPER,       ' ' },
      { NULL, 0, 0 },
-Line 271 
 static int isquote(char q)
+Line 277 
 static int isquote(char q)
      return 0;
  }
+ static int iskernel(enum lineType_e type) {
+     return (type == LT_KERNEL || type == LT_KERNEL_EFI);
+ }
+ static int isinitrd(enum lineType_e type) {
+     return (type == LT_INITRD || type == LT_INITRD_EFI);
+ }
  char *grub2ExtractTitle(struct singleLine * line) {
      char * current;
      char * current_indent;
-Line 570 
 static char * sdupprintf(const char *for
+Line 584 
 static char * sdupprintf(const char *for
      return buf;
  }
+ static enum lineType_e preferredLineType(enum lineType_e type,
+ 					 struct configFileInfo *cfi) {
+     if (isEfi && cfi == &grub2ConfigType) {
+ 	switch (type) {
+ 	case LT_KERNEL:
+ 	    return LT_KERNEL_EFI;
+ 	case LT_INITRD:
+ 	    return LT_INITRD_EFI;
+ 	default:
+ 	    return type;
+ 	}
+     }
+     return type;
+ }
  static struct keywordTypes * getKeywordByType(enum lineType_e type,
  					      struct configFileInfo * cfi) {
      for (struct keywordTypes *kw = cfi->keywords; kw->key; kw++) {
-Line 994 
 static struct grubConfig * readConfig(co
+Line 1023 
 static struct grubConfig * readConfig(co
  	    cfg->flags &= ~GRUB_CONFIG_NO_DEFAULT;
  	    defaultLine = line;
-         } else if (line->type == LT_KERNEL) {
+         } else if (iskernel(line->type)) {
  	    /* if by some freak chance this is multiboot and the "module"
  	     * lines came earlier in the template, make sure to use LT_HYPER
  	     * instead of LT_KERNEL now
-Line 1011 
 static struct grubConfig * readConfig(co
+Line 1040 
 static struct grubConfig * readConfig(co
  	    for (struct singleLine *l = entry->lines; l; l = l->next) {
  		if (l->type == LT_HYPER)
  		    break;
- 		else if (l->type == LT_KERNEL) {
+ 		else if (iskernel(l->type)) {
  		    l->type = LT_HYPER;
  		    break;
  		}
-Line 1310 
 static int writeConfig(struct grubConfig
+Line 1339 
 static int writeConfig(struct grubConfig
  	    /* most likely the symlink is relative, so change our
  	       directory to the dir of the symlink */
-             rc = chdir(dirname(outName));
+ 	    char *dir = strdupa(outName);
+ 	    rc = chdir(dirname(dir));
  	    do {
  		buf = alloca(len + 1);
  		rc = readlink(basename(outName), buf, len);
-Line 1564 
 int suitableImage(struct singleEntry * e
+Line 1594 
 int suitableImage(struct singleEntry * e
  	return 0;
      }
-     line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
      if (!line) {
  	notSuitablePrintf(entry, "no line found\n");
  	return 0;
-Line 1694 
 struct singleEntry * findEntryByPath(str
+Line 1724 
 struct singleEntry * findEntryByPath(str
  	entry = findEntryByIndex(config, indexVars[i]);
  	if (!entry) return NULL;
- 	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
  	if (!line) return NULL;
  	if (index) *index = indexVars[i];
-Line 1743 
 struct singleEntry * findEntryByPath(str
+Line 1773 
 struct singleEntry * findEntryByPath(str
  	    /* check all the lines matching checkType */
  	    for (line = entry->lines; line; line = line->next) {
- 		line = getLineByType(entry->multiboot && checkType == LT_KERNEL ?
+ 		enum lineType_e ct = checkType;
- 				     LT_KERNEL|LT_MBMODULE|LT_HYPER :
+ 		if (entry->multiboot && checkType == LT_KERNEL)
- 				     checkType, line);
+ 		    ct = LT_KERNEL|LT_KERNEL_EFI|LT_MBMODULE|LT_HYPER;
- 		if (!line) break;  /* not found in this entry */
+ 		else if (checkType & LT_KERNEL)
+ 		    ct = checkType | LT_KERNEL_EFI;
+ 		line = getLineByType(ct, line);
+ 		if (!line)
+ 		    break;  /* not found in this entry */
  		if (line && line->type != LT_MENUENTRY &&
  			line->numElements >= 2) {
-Line 1765 
 struct singleEntry * findEntryByPath(str
+Line 1799 
 struct singleEntry * findEntryByPath(str
  	     * non-Linux boot entries (could find netbsd etc, though, which is
  	     * unfortunate)
  	     */
- 	    if (line && getLineByType(LT_KERNEL|LT_HYPER, entry->lines))
+ 	    if (line && getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines))
  		break; /* found 'im! */
  	}
-Line 1867 
 void markRemovedImage(struct grubConfig
+Line 1901 
 void markRemovedImage(struct grubConfig
  void setDefaultImage(struct grubConfig * config, int hasNew,
  		     const char * defaultKernelPath, int newIsDefault,
- 		     const char * prefix, int flags) {
+ 		     const char * prefix, int flags, int index) {
      struct singleEntry * entry, * entry2, * newDefault;
      int i, j;
      if (newIsDefault) {
  	config->defaultImage = 0;
  	return;
+     } else if ((index >= 0) && config->cfi->defaultIsIndex) {
+ 	if (findEntryByIndex(config, index))
+ 	    config->defaultImage = index;
+ 	else
+ 	    config->defaultImage = -1;
+ 	return;
      } else if (defaultKernelPath) {
  	i = 0;
  	if (findEntryByPath(config, defaultKernelPath, prefix, &i)) {
-Line 1948 
 void displayEntry(struct singleEntry * e
+Line 1988 
 void displayEntry(struct singleEntry * e
      printf("index=%d\n", index);
-     line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+     line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
      if (!line) {
          printf("non linux entry\n");
          return;
-Line 2013 
 void displayEntry(struct singleEntry * e
+Line 2053 
 void displayEntry(struct singleEntry * e
  	printf("root=%s\n", s);
      }
-     line = getLineByType(LT_INITRD, entry->lines);
+     line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
      if (line && line->numElements >= 2) {
  	if (!strncmp(prefix, line->elements[1].item, strlen(prefix)))
-Line 2038 
 void displayEntry(struct singleEntry * e
+Line 2078 
 void displayEntry(struct singleEntry * e
      }
  }
+ int isSuseSystem(void) {
+     const char * path;
+     const static char default_path[] = "/etc/SuSE-release";
+     if ((path = getenv("GRUBBY_SUSE_RELEASE")) == NULL)
+ 	path = default_path;
+     if (!access(path, R_OK))
+ 	return 1;
+     return 0;
+ }
+ int isSuseGrubConf(const char * path) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t len = 0, res = 0;
+     grubConf = fopen(path, "r");
+     if (!grubConf) {
+         dbgPrintf("Could not open SuSE configuration file '%s'\n", path);
+ 	return 0;
+     }
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (!strncmp(line, "setup", 5)) {
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+     }
+     dbgPrintf("SuSE configuration file '%s' does not appear to be valid\n",
+ 	      path);
+     fclose(grubConf);
+     free(line);
+     return 0;
+ }
+ int suseGrubConfGetLba(const char * path, int * lbaPtr) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     if (!path) return 1;
+     if (!lbaPtr) return 1;
+     grubConf = fopen(path, "r");
+     if (!grubConf) return 1;
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	if (!strncmp(line, "setup", 5)) {
+ 	    if (strstr(line, "--force-lba")) {
+ 	        *lbaPtr = 1;
+ 	    } else {
+ 	        *lbaPtr = 0;
+ 	    }
+ 	    dbgPrintf("lba: %i\n", *lbaPtr);
+ 	    break;
+ 	}
+     }
+     free(line);
+     fclose(grubConf);
+     return 0;
+ }
+ int suseGrubConfGetInstallDevice(const char * path, char ** devicePtr) {
+     FILE * grubConf;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     char * lastParamPtr = NULL;
+     char * secLastParamPtr = NULL;
+     char installDeviceNumber = '\0';
+     char * bounds = NULL;
+     if (!path) return 1;
+     if (!devicePtr) return 1;
+     grubConf = fopen(path, "r");
+     if (!grubConf) return 1;
+     while ((res = getline(&line, &len, grubConf)) != -1) {
+ 	if (strncmp(line, "setup", 5))
+ 	    continue;
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	lastParamPtr = bounds = line + res;
+ 	/* Last parameter in grub may be an optional IMAGE_DEVICE */
+ 	while (!isspace(*lastParamPtr))
+ 	    lastParamPtr--;
+ 	lastParamPtr++;
+ 	secLastParamPtr = lastParamPtr - 2;
+ 	dbgPrintf("lastParamPtr: %s\n", lastParamPtr);
+ 	if (lastParamPtr + 3 > bounds) {
+ 	    dbgPrintf("lastParamPtr going over boundary");
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+ 	if (!strncmp(lastParamPtr, "(hd", 3))
+ 	    lastParamPtr += 3;
+ 	dbgPrintf("lastParamPtr: %c\n", *lastParamPtr);
+ 	/*
+ 	 * Second last parameter will decide wether last parameter is
+ 	 * an IMAGE_DEVICE or INSTALL_DEVICE
+ 	 */
+ 	while (!isspace(*secLastParamPtr))
+ 	    secLastParamPtr--;
+ 	secLastParamPtr++;
+ 	if (secLastParamPtr + 3 > bounds) {
+ 	    dbgPrintf("secLastParamPtr going over boundary");
+ 	    fclose(grubConf);
+ 	    free(line);
+ 	    return 1;
+ 	}
+ 	dbgPrintf("secLastParamPtr: %s\n", secLastParamPtr);
+ 	if (!strncmp(secLastParamPtr, "(hd", 3)) {
+ 	    secLastParamPtr += 3;
+ 	    dbgPrintf("secLastParamPtr: %c\n", *secLastParamPtr);
+ 	    installDeviceNumber = *secLastParamPtr;
+ 	} else {
+ 	    installDeviceNumber = *lastParamPtr;
+ 	}
+ 	*devicePtr = malloc(6);
+ 	snprintf(*devicePtr, 6, "(hd%c)", installDeviceNumber);
+ 	dbgPrintf("installDeviceNumber: %c\n", installDeviceNumber);
+ 	fclose(grubConf);
+ 	free(line);
+ 	return 0;
+     }
+     free(line);
+     fclose(grubConf);
+     return 1;
+ }
+ int grubGetBootFromDeviceMap(const char * device,
+ 			     char ** bootPtr) {
+     FILE * deviceMap;
+     char * line = NULL;
+     size_t res = 0, len = 0;
+     char * devicePtr;
+     char * bounds = NULL;
+     const char * path;
+     const static char default_path[] = "/boot/grub/device.map";
+     if (!device) return 1;
+     if (!bootPtr) return 1;
+     if ((path = getenv("GRUBBY_GRUB_DEVICE_MAP")) == NULL)
+ 	path = default_path;
+     dbgPrintf("opening grub device.map file from: %s\n", path);
+     deviceMap = fopen(path, "r");
+     if (!deviceMap)
+ 	return 1;
+     while ((res = getline(&line, &len, deviceMap)) != -1) {
+         if (!strncmp(line, "#", 1))
+ 	    continue;
+ 	if (line[res - 1] == '\n')
+ 	    line[res - 1] = '\0';
+ 	else if (len > res)
+ 	    line[res] = '\0';
+ 	else {
+ 	    line = realloc(line, res + 1);
+ 	    line[res] = '\0';
+ 	}
+ 	devicePtr = line;
+ 	bounds = line + res;
+ 	while ((isspace(*line) && ((devicePtr + 1) <= bounds)))
+ 	    devicePtr++;
+ 	dbgPrintf("device: %s\n", devicePtr);
+ 	if (!strncmp(devicePtr, device, strlen(device))) {
+ 	    devicePtr += strlen(device);
+ 	    while (isspace(*devicePtr) && ((devicePtr + 1) <= bounds))
+ 	        devicePtr++;
+ 	    *bootPtr = strdup(devicePtr);
+ 	    break;
+ 	}
+     }
+     free(line);
+     fclose(deviceMap);
+     return 0;
+ }
+ int suseGrubConfGetBoot(const char * path, char ** bootPtr) {
+     char * grubDevice;
+     if (suseGrubConfGetInstallDevice(path, &grubDevice))
+ 	dbgPrintf("error looking for grub installation device\n");
+     else
+ 	dbgPrintf("grubby installation device: %s\n", grubDevice);
+     if (grubGetBootFromDeviceMap(grubDevice, bootPtr))
+ 	dbgPrintf("error looking for grub boot device\n");
+     else
+ 	dbgPrintf("grubby boot device: %s\n", *bootPtr);
+     free(grubDevice);
+     return 0;
+ }
+ int parseSuseGrubConf(int * lbaPtr, char ** bootPtr) {
+     /*
+      * This SuSE grub configuration file at this location is not your average
+      * grub configuration file, but instead the grub commands used to setup
+      * grub on that system.
+      */
+     const char * path;
+     const static char default_path[] = "/etc/grub.conf";
+     if ((path = getenv("GRUBBY_SUSE_GRUB_CONF")) == NULL)
+ 	path = default_path;
+     if (!isSuseGrubConf(path)) return 1;
+     if (lbaPtr) {
+         *lbaPtr = 0;
+         if (suseGrubConfGetLba(path, lbaPtr))
+             return 1;
+     }
+     if (bootPtr) {
+         *bootPtr = NULL;
+         suseGrubConfGetBoot(path, bootPtr);
+     }
+     return 0;
+ }
  int parseSysconfigGrub(int * lbaPtr, char ** bootPtr) {
      FILE * in;
      char buf[1024];
-Line 2086 
 int parseSysconfigGrub(int * lbaPtr, cha
+Line 2387 
 int parseSysconfigGrub(int * lbaPtr, cha
  }
  void dumpSysconfigGrub(void) {
-     char * boot;
+     char * boot = NULL;
      int lba;
-     if (!parseSysconfigGrub(&lba, &boot)) {
+     if (isSuseSystem()) {
- 	if (lba) printf("lba\n");
+         if (parseSuseGrubConf(&lba, &boot)) {
- 	if (boot) printf("boot=%s\n", boot);
+ 	    free(boot);
+ 	    return;
+ 	}
+     } else {
+         if (parseSysconfigGrub(&lba, &boot)) {
+ 	    free(boot);
+ 	    return;
+ 	}
+     }
+     if (lba) printf("lba\n");
+     if (boot) {
+ 	printf("boot=%s\n", boot);
+ 	free(boot);
      }
  }
-Line 2140 
 struct singleLine * addLineTmpl(struct s
+Line 2454 
 struct singleLine * addLineTmpl(struct s
  {
      struct singleLine * newLine = lineDup(tmplLine);
+     if (isEfi && cfi == &grub2ConfigType) {
+ 	enum lineType_e old = newLine->type;
+ 	newLine->type = preferredLineType(newLine->type, cfi);
+ 	if (old != newLine->type)
+ 	    newLine->elements[0].item = getKeyByType(newLine->type, cfi);
+     }
      if (val) {
  	/* override the inherited value with our own.
  	 * This is a little weak because it only applies to elements[1]
-Line 2149 
 struct singleLine * addLineTmpl(struct s
+Line 2470 
 struct singleLine * addLineTmpl(struct s
  	insertElement(newLine, val, 1, cfi);
  	/* but try to keep the rootspec from the template... sigh */
- 	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD)) {
+ 	if (tmplLine->type & (LT_HYPER|LT_KERNEL|LT_MBMODULE|LT_INITRD|LT_KERNEL_EFI|LT_INITRD_EFI)) {
  	    char * rootspec = getRootSpecifier(tmplLine->elements[1].item);
  	    if (rootspec != NULL) {
  		free(newLine->elements[1].item);
-Line 2186 
 struct singleLine *  addLine(struct sing
+Line 2507 
 struct singleLine *  addLine(struct sing
      /* NB: This function shouldn't allocate items on the heap, rather on the
       * stack since it calls addLineTmpl which will make copies.
       */
      if (type == LT_TITLE && cfi->titleBracketed) {
  	/* we're doing a bracketed title (zipl) */
  	tmpl.type = type;
-Line 2520 
 int updateActualImage(struct grubConfig
+Line 2840 
 int updateActualImage(struct grubConfig
  	    firstElement = 2;
  	} else {
- 	    line = getLineByType(LT_KERNEL|LT_MBMODULE, entry->lines);
+ 	    line = getLineByType(LT_KERNEL|LT_MBMODULE|LT_KERNEL_EFI, entry->lines);
  	    if (!line) {
  		/* no LT_KERNEL or LT_MBMODULE in this entry? */
  		continue;
-Line 2685 
 int updateInitrd(struct grubConfig * cfg
+Line 3005 
 int updateInitrd(struct grubConfig * cfg
      if (!image) return 0;
      for (; (entry = findEntryByPath(cfg, image, prefix, &index)); index++) {
-         kernelLine = getLineByType(LT_KERNEL, entry->lines);
+         kernelLine = getLineByType(LT_KERNEL|LT_KERNEL_EFI, entry->lines);
          if (!kernelLine) continue;
-         line = getLineByType(LT_INITRD, entry->lines);
+         line = getLineByType(LT_INITRD|LT_INITRD_EFI, entry->lines);
          if (line)
              removeLine(entry, line);
          if (prefix) {
-Line 2699 
 int updateInitrd(struct grubConfig * cfg
+Line 3019 
 int updateInitrd(struct grubConfig * cfg
  	endLine = getLineByType(LT_ENTRY_END, entry->lines);
  	if (endLine)
  	    removeLine(entry, endLine);
-         line = addLine(entry, cfg->cfi, LT_INITRD, kernelLine->indent, initrd);
+         line = addLine(entry, cfg->cfi, preferredLineType(LT_INITRD, cfg->cfi),
+ 			kernelLine->indent, initrd);
          if (!line)
  	    return 1;
  	if (endLine) {
-Line 2905 
 int checkForGrub(struct grubConfig * con
+Line 3226 
 int checkForGrub(struct grubConfig * con
      int fd;
      unsigned char bootSect[512];
      char * boot;
+     int onSuse = isSuseSystem();
-     if (parseSysconfigGrub(NULL, &boot))
- 	return 0;
+     if (onSuse) {
+ 	if (parseSuseGrubConf(NULL, &boot))
+ 	    return 0;
+     } else {
+ 	if (parseSysconfigGrub(NULL, &boot))
+ 	    return 0;
+     }
      /* assume grub is not installed -- not an error condition */
      if (!boot)
-Line 2926 
 int checkForGrub(struct grubConfig * con
+Line 3254 
 int checkForGrub(struct grubConfig * con
      }
      close(fd);
+     /* The more elaborate checks do not work on SuSE. The checks done
+      * seem to be reasonble (at least for now), so just return success
+      */
+     if (onSuse)
+ 	return 2;
      return checkDeviceBootloader(boot, bootSect);
  }
-Line 2959 
 int checkForExtLinux(struct grubConfig *
+Line 3293 
 int checkForExtLinux(struct grubConfig *
      return checkDeviceBootloader(boot, bootSect);
  }
+ int checkForYaboot(struct grubConfig * config) {
+     /*
+      * This is a simplistic check that we consider good enough for own puporses
+      *
+      * If we were to properly check if yaboot is *installed* we'd need to:
+      * 1) get the system boot device (LT_BOOT)
+      * 2) considering it's a raw filesystem, check if the yaboot binary matches
+      *    the content on the boot device
+      * 3) if not, copy the binary to a temporary file and run "addnote" on it
+      * 4) check again if binary and boot device contents match
+      */
+     if (!access("/etc/yaboot.conf", R_OK))
+ 	return 2;
+     return 1;
+ }
+ int checkForElilo(struct grubConfig * config) {
+     if (!access("/etc/elilo.conf", R_OK))
+ 	return 2;
+     return 1;
+ }
  static char * getRootSpecifier(char * str) {
      char * idx, * rootspec = NULL;
-Line 3075 
 int addNewKernel(struct grubConfig * con
+Line 3433 
 int addNewKernel(struct grubConfig * con
  	    while (*chptr && isspace(*chptr)) chptr++;
  	    if (*chptr == '#') continue;
- 	    if (tmplLine->type == LT_KERNEL &&
+ 	    if (iskernel(tmplLine->type) && tmplLine->numElements >= 2) {
- 		    tmplLine->numElements >= 2) {
  		if (!template->multiboot && (needs & NEED_MB)) {
  		    /* it's not a multiboot template and this is the kernel
  		     * line.  Try to be intelligent about inserting the
-Line 3153 
 int addNewKernel(struct grubConfig * con
+Line 3510 
 int addNewKernel(struct grubConfig * con
  		    /* template is multi but new is not,
  		     * insert the kernel in the first module slot
  		     */
- 		    tmplLine->type = LT_KERNEL;
+ 		    tmplLine->type = preferredLineType(LT_KERNEL, config->cfi);
  		    free(tmplLine->elements[0].item);
  		    tmplLine->elements[0].item =
- 			strdup(getKeywordByType(LT_KERNEL, config->cfi)->key);
+ 			strdup(getKeywordByType(tmplLine->type,
+ 						config->cfi)->key);
  		    newLine = addLineTmpl(new, tmplLine, newLine,
- 					  newKernelPath + strlen(prefix), config->cfi);
+ 					  newKernelPath + strlen(prefix),
+ 					  config->cfi);
  		    needs &= ~NEED_KERNEL;
  		} else if (needs & NEED_INITRD) {
  		    char *initrdVal;
  		    /* template is multi but new is not,
  		     * insert the initrd in the second module slot
  		     */
- 		    tmplLine->type = LT_INITRD;
+ 		    tmplLine->type = preferredLineType(LT_INITRD, config->cfi);
  		    free(tmplLine->elements[0].item);
  		    tmplLine->elements[0].item =
- 			strdup(getKeywordByType(LT_INITRD, config->cfi)->key);
+ 			strdup(getKeywordByType(tmplLine->type,
+ 						config->cfi)->key);
  		    initrdVal = getInitrdVal(config, prefix, tmplLine, newKernelInitrd, extraInitrds, extraInitrdCount);
  		    newLine = addLineTmpl(new, tmplLine, newLine, initrdVal, config->cfi);
  		    free(initrdVal);
  		    needs &= ~NEED_INITRD;
  		}
- 	    } else if (tmplLine->type == LT_INITRD &&
+ 	    } else if (isinitrd(tmplLine->type) && tmplLine->numElements >= 2) {
- 		       tmplLine->numElements >= 2) {
  		if (needs & NEED_INITRD &&
  		    new->multiboot && !template->multiboot &&
  		    config->cfi->mbInitRdIsModule) {
-Line 3230 
 int addNewKernel(struct grubConfig * con
+Line 3589 
 int addNewKernel(struct grubConfig * con
  		    static const char *prefix = "'Loading ";
  		    if (tmplLine->numElements > 1 &&
  			    strstr(tmplLine->elements[1].item, prefix) &&
- 			    masterLine->next && masterLine->next->type == LT_KERNEL) {
+ 			    masterLine->next &&
+ 			    iskernel(masterLine->next->type)) {
  			char *newTitle = malloc(strlen(prefix) +
  						strlen(newKernelTitle) + 2);
-Line 3257 
 int addNewKernel(struct grubConfig * con
+Line 3617 
 int addNewKernel(struct grubConfig * con
  	 */
  	switch (config->cfi->entryStart) {
  	    case LT_KERNEL:
+ 	    case LT_KERNEL_EFI:
  		if (new->multiboot && config->cfi->mbHyperFirst) {
  		    /* fall through to LT_HYPER */
  		} else {
- 		    newLine = addLine(new, config->cfi, LT_KERNEL,
+ 		    newLine = addLine(new, config->cfi,
+ 		    		      preferredLineType(LT_KERNEL, config->cfi),
  				      config->primaryIndent,
  				      newKernelPath + strlen(prefix));
  		    needs &= ~NEED_KERNEL;
-Line 3336 
 int addNewKernel(struct grubConfig * con
+Line 3698 
 int addNewKernel(struct grubConfig * con
      if (needs & NEED_KERNEL) {
  	newLine = addLine(new, config->cfi,
  			  (new->multiboot && getKeywordByType(LT_MBMODULE,
- 							      config->cfi)) ?
+ 							      config->cfi))
- 			  LT_MBMODULE : LT_KERNEL,
+ 			  	? LT_MBMODULE
+ 				: preferredLineType(LT_KERNEL, config->cfi),
  			  config->secondaryIndent,
  			  newKernelPath + strlen(prefix));
  	needs &= ~NEED_KERNEL;
-Line 3353 
 int addNewKernel(struct grubConfig * con
+Line 3716 
 int addNewKernel(struct grubConfig * con
  	initrdVal = getInitrdVal(config, prefix, NULL, newKernelInitrd, extraInitrds, extraInitrdCount);
  	newLine = addLine(new, config->cfi,
  			  (new->multiboot && getKeywordByType(LT_MBMODULE,
- 							      config->cfi)) ?
+ 							      config->cfi))
- 			  LT_MBMODULE : LT_INITRD,
+ 			   ? LT_MBMODULE
+ 			   : preferredLineType(LT_INITRD, config->cfi),
  			  config->secondaryIndent,
  			  initrdVal);
  	free(initrdVal);
-Line 3429 
 int main(int argc, const char ** argv) {
+Line 3793 
 int main(int argc, const char ** argv) {
      int displayDefault = 0;
      int displayDefaultIndex = 0;
      int displayDefaultTitle = 0;
+     int defaultIndex = -1;
      struct poptOption options[] = {
  	{ "add-kernel", 0, POPT_ARG_STRING, &newKernelPath, 0,
  	    _("add an entry for the specified kernel"), _("kernel-path") },
-Line 3446 
 int main(int argc, const char ** argv) {
+Line 3811 
 int main(int argc, const char ** argv) {
  	{ "boot-filesystem", 0, POPT_ARG_STRING, &bootPrefix, 0,
  	    _("filestystem which contains /boot directory (for testing only)"),
  	    _("bootfs") },
- #if defined(__i386__) || defined(__x86_64__)
+ #if defined(__i386__) || defined(__x86_64__) || defined (__powerpc64__) || defined (__ia64__)
  	{ "bootloader-probe", 0, POPT_ARG_NONE, &bootloaderProbe, 0,
- 	    _("check if lilo is installed on lilo.conf boot sector") },
+ 	    _("check which bootloader is installed on boot sector") },
  #endif
  	{ "config-file", 'c', POPT_ARG_STRING, &grubConfig, 0,
  	    _("path to grub config file to update (\"-\" for stdin)"),
-Line 3469 
 int main(int argc, const char ** argv) {
+Line 3834 
 int main(int argc, const char ** argv) {
  	    _("display the title of the default kernel") },
  	{ "elilo", 0, POPT_ARG_NONE, &configureELilo, 0,
  	    _("configure elilo bootloader") },
+ 	{ "efi", 0, POPT_ARG_NONE, &isEfi, 0,
+ 	    _("force grub2 stanzas to use efi") },
  	{ "extlinux", 0, POPT_ARG_NONE, &configureExtLinux, 0,
  	    _("configure extlinux bootloader (from syslinux)") },
  	{ "grub", 0, POPT_ARG_NONE, &configureGrub, 0,
-Line 3501 
 int main(int argc, const char ** argv) {
+Line 3868 
 int main(int argc, const char ** argv) {
  	{ "set-default", 0, POPT_ARG_STRING, &defaultKernel, 0,
  	    _("make the first entry referencing the specified kernel "
  	      "the default"), _("kernel-path") },
+ 	{ "set-default-index", 0, POPT_ARG_INT, &defaultIndex, 0,
+ 	    _("make the given entry index the default entry"),
+ 	    _("entry-index") },
  	{ "silo", 0, POPT_ARG_NONE, &configureSilo, 0,
  	    _("configure silo bootloader") },
  	{ "title", 0, POPT_ARG_STRING, &newKernelTitle, 0,
-Line 3609 
 int main(int argc, const char ** argv) {
+Line 3979 
 int main(int argc, const char ** argv) {
      }
      if (bootloaderProbe && (displayDefault || kernelInfo || newKernelVersion ||
- 			  newKernelPath || removeKernelPath || makeDefault ||
+ 			    newKernelPath || removeKernelPath || makeDefault ||
- 			  defaultKernel || displayDefaultIndex || displayDefaultTitle)) {
+ 			    defaultKernel || displayDefaultIndex || displayDefaultTitle ||
+ 			    (defaultIndex >= 0))) {
  	fprintf(stderr, _("grubby: --bootloader-probe may not be used with "
  			  "specified option"));
  	return 1;
-Line 3652 
 int main(int argc, const char ** argv) {
+Line 4023 
 int main(int argc, const char ** argv) {
  	makeDefault = 1;
  	defaultKernel = NULL;
      }
+     else if (defaultKernel && (defaultIndex >= 0)) {
+ 	fprintf(stderr, _("grubby: --set-default and --set-default-index "
+ 			  "may not be used together\n"));
+ 	return 1;
+     }
      if (grubConfig && !strcmp(grubConfig, "-") && !outputFile) {
  	fprintf(stderr, _("grubby: output file must be specified if stdin "
-Line 3660 
 int main(int argc, const char ** argv) {
+Line 4036 
 int main(int argc, const char ** argv) {
      }
      if (!removeKernelPath && !newKernelPath && !displayDefault && !defaultKernel
  	&& !kernelInfo && !bootloaderProbe && !updateKernelPath
-         && !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle) {
+ 	&& !removeMBKernel && !displayDefaultIndex && !displayDefaultTitle
+ 	&& (defaultIndex == -1)) {
  	fprintf(stderr, _("grubby: no action specified\n"));
  	return 1;
      }
-Line 3688 
 int main(int argc, const char ** argv) {
+Line 4065 
 int main(int argc, const char ** argv) {
      }
      if (bootloaderProbe) {
- 	int lrc = 0, grc = 0, gr2c = 0, erc = 0;
+ 	int lrc = 0, grc = 0, gr2c = 0, extrc = 0, yrc = 0, erc = 0;
- 	struct grubConfig * lconfig, * gconfig;
+ 	struct grubConfig * lconfig, * gconfig, * yconfig, * econfig;
  	const char *grub2config = grub2FindConfig(&grub2ConfigType);
  	if (grub2config) {
-Line 3717 
 int main(int argc, const char ** argv) {
+Line 4094 
 int main(int argc, const char ** argv) {
  		lrc = checkForLilo(lconfig);
  	}
+ 	if (!access(eliloConfigType.defaultConfig, F_OK)) {
+ 	    econfig = readConfig(eliloConfigType.defaultConfig,
+ 				 &eliloConfigType);
+ 	    if (!econfig)
+ 		erc = 1;
+ 	    else
+ 		erc = checkForElilo(econfig);
+ 	}
  	if (!access(extlinuxConfigType.defaultConfig, F_OK)) {
  	    lconfig = readConfig(extlinuxConfigType.defaultConfig, &extlinuxConfigType);
  	    if (!lconfig)
- 		erc = 1;
+ 		extrc = 1;
  	    else
- 		erc = checkForExtLinux(lconfig);
+ 		extrc = checkForExtLinux(lconfig);
  	}
- 	if (lrc == 1 || grc == 1 || gr2c == 1) return 1;
+ 	if (!access(yabootConfigType.defaultConfig, F_OK)) {
+ 	    yconfig = readConfig(yabootConfigType.defaultConfig,
+ 				 &yabootConfigType);
+ 	    if (!yconfig)
+ 		yrc = 1;
+ 	    else
+ 		yrc = checkForYaboot(yconfig);
+ 	}
+ 	if (lrc == 1 || grc == 1 || gr2c == 1 || extrc == 1 || yrc == 1 ||
+ 		erc == 1)
+ 	    return 1;
  	if (lrc == 2) printf("lilo\n");
  	if (gr2c == 2) printf("grub2\n");
  	if (grc == 2) printf("grub\n");
- 	if (erc == 2) printf("extlinux\n");
+ 	if (extrc == 2) printf("extlinux\n");
+ 	if (yrc == 2) printf("yaboot\n");
+ 	if (erc == 2) printf("elilo\n");
  	return 0;
      }
-Line 3748 
 int main(int argc, const char ** argv) {
+Line 4148 
 int main(int argc, const char ** argv) {
  	if (!entry) return 0;
  	if (!suitableImage(entry, bootPrefix, 0, flags)) return 0;
- 	line = getLineByType(LT_KERNEL|LT_HYPER, entry->lines);
+ 	line = getLineByType(LT_KERNEL|LT_HYPER|LT_KERNEL_EFI, entry->lines);
  	if (!line) return 0;
          rootspec = getRootSpecifier(line->elements[1].item);
-Line 3797 
 int main(int argc, const char ** argv) {
+Line 4197 
 int main(int argc, const char ** argv) {
      markRemovedImage(config, removeKernelPath, bootPrefix);
      markRemovedImage(config, removeMBKernel, bootPrefix);
      setDefaultImage(config, newKernelPath != NULL, defaultKernel, makeDefault,
- 		    bootPrefix, flags);
+ 		    bootPrefix, flags, defaultIndex);
      setFallbackImage(config, newKernelPath != NULL);
      if (updateImage(config, updateKernelPath, bootPrefix, newKernelArgs,
                      removeArgs, newMBKernelArgs, removeMBKernelArgs)) return 1;

 Legend:



Removed from v.1849
 


changed lines


 
Added in v.2052
 Legend:



Removed from v.1849
 


changed lines


 
Added in v.2052
-Removed from v.1849
+Added in v.2052