EFI live image support

Add a recipe to build the GRUB efi images. This recipe is written as a native recipe as the resulting GRUB utils are required to assemble the final image. Rather than build a native and a target recipe (and increase build times), this recipe builds the utils for the host and passes an appropriate --target argument to the GRUB configure script to build the modules for the target arch. The only output of this recipe is an EFI image in the deploy directory.

Care is taken to ensure changing targets will force a rebuild of this native recipe by including the target arch in the PN.

---
 meta/recipes-bsp/grub/grub-efi-native_1.99.bb |   74 +++++++++++++++++++++++++
 1 files changed, 74 insertions(+), 0 deletions(-)
 create mode 100644 meta/recipes-bsp/grub/grub-efi-native_1.99.bb

new file mode 100644
index 0000000..3c52ec9
@@ -0,0 +1,74 @@
+SUMMARY = "GRUB2 is the next-generation GRand Unified Bootloader"
+
+DESCRIPTION = "GRUB2 is the next generaion of a GPLed bootloader \
+intended to unify bootloading across x86 operating systems. In \
+addition to loading the Linux kernel, it implements the Multiboot \
+standard, which allows for flexible loading of multiple boot images. \
+This recipe builds an EFI binary for the target. It does not install \
+or package anything, it only deploys a target-arch GRUB EFI image."
+
+HOMEPAGE = "http://www.gnu.org/software/grub/"
+SECTION = "bootloaders"
+PRIORITY = "optional"
+
+LICENSE = "GPLv3"
+LIC_FILES_CHKSUM = "file://COPYING;md5=d32239bcb673463ab874e80d47fae504"
+
+# FIXME: We should be able to optionally drop freetype as a dependency
+DEPENDS = "help2man-native"
+RDEPENDS_${PN} = "diffutils freetype"
+PR = "r1"
+
+# Native packages do not normally rebuild when the target changes.
+# Ensure this is built once per HOST-TARGET pair.
+PN := "grub-efi-${TRANSLATED_TARGET_ARCH}-native"
+
+SRC_URI = "ftp://ftp.gnu.org/gnu/grub/grub-${PV}.tar.gz"
+
+SRC_URI[md5sum] = "ca9f2a2d571b57fc5c53212d1d22e2b5"
+SRC_URI[sha256sum] = "b91f420f2c51f6155e088e34ff99bea09cc1fb89585cf7c0179644e57abd28ff"
+
+COMPATIBLE_HOST = '(x86_64.*|i.86.*)-(linux|freebsd.*)'
+
+S = "${WORKDIR}/grub-${PV}"
+
+# Determine the target arch for the grub modules before the native class
+# clobbers TARGET_ARCH.
+ORIG_TARGET_ARCH := ${TARGET_ARCH}
+python __anonymous () {
+    import re
+    target = d.getVar('ORIG_TARGET_ARCH', True)
+    if target == "x86_64":
+        grubtarget = 'x86_64'
+        grubimage = "bootx64.efi"
+    elif re.match('i.86', target):
+        grubtarget = 'i386'
+        grubimage = "bootia32.efi"
+    else:
+        raise bb.parse.SkipPackage("grub-efi is incompatible with target %s" % target)
+    d.setVar("GRUB_TARGET", grubtarget)
+    d.setVar("GRUB_IMAGE", grubimage)
+}
+
+inherit autotools
+inherit gettext
+inherit native
+inherit deploy
+
+EXTRA_OECONF = "--with-platform=efi --disable-grub-mkfont \
+                --target=${GRUB_TARGET} --enable-efiemu=no --program-prefix=''"
+
+do_mkimage() {
+	./grub-mkimage -p / -d ./grub-core/ \
+		       -O ${GRUB_TARGET}-efi -o ./${GRUB_IMAGE} \
+	               boot linux fat serial part_msdos normal
+}
+addtask mkimage after do_compile before do_install
+
+do_deploy() {
+	install -m 644 ${S}/${GRUB_IMAGE} ${DEPLOYDIR}
+}
+addtask deploy after do_install before do_build
+
+do_install[noexec] = "1"
+do_populate_sysroot[noexec] = "1"

1.7.6.4

Separate the construction of the ISO image from that of the hddimg. This is part of the groundwork for creating a much more flexible live image builder.

---
 meta/classes/bootimg.bbclass |   82 ++++++++++++++++++++++--------------------
 1 files changed, 43 insertions(+), 39 deletions(-)

index 49ee85e..26d2fae 100644
@@ -47,7 +47,47 @@ SYSLINUXMENU = "${HDDDIR}/menu"
 
 inherit syslinux
 		
-build_boot_bin() {
+build_iso() {
+	# Only create an ISO if we have an INITRD and NOISO was not set
+	if [ -z "${INITRD}" ] || [ ! -s "${INITRD}" ] || [ "${NOISO}" = "1" ]; then
+		bbnote "ISO image will not be created."
+		return
+	fi
+
+	install -d ${ISODIR}
+
+	# Install the kernel
+	install -m 0644 ${STAGING_DIR_HOST}/kernel/bzImage \
+	        ${ISODIR}/vmlinuz
+
+	# Install the configuration files
+	cp ${HDDDIR}/syslinux.cfg ${ISODIR}/isolinux.cfg
+
+	if [ -f ${SYSLINUXMENU} ]; then
+		cp ${SYSLINUXMENU} ${ISODIR}
+	fi
+
+	install -m 0644 ${INITRD} ${ISODIR}/initrd
+
+	if [ -n "${ROOTFS}" ] && [ -s "${ROOTFS}" ]; then 
+		install -m 0644 ${ROOTFS} ${ISODIR}/rootfs.img
+	fi
+
+	# And install the syslinux stuff 
+	cp ${STAGING_LIBDIR}/syslinux/isolinux.bin ${ISODIR}
+
+	mkisofs -V ${BOOTIMG_VOLUME_ID} \
+	-o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
+	-b isolinux/isolinux.bin -c isolinux/boot.cat -r \
+	-no-emul-boot -boot-load-size 4 -boot-info-table \
+	${S}/cd/
+
+	cd ${DEPLOY_DIR_IMAGE}
+	rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso
+	ln -s ${IMAGE_NAME}.iso ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso
+}
+
+build_hddimg() {
 	install -d ${HDDDIR}
 	install -m 0644 ${STAGING_DIR_HOST}/kernel/bzImage \
 	${HDDDIR}/vmlinuz

@@ -77,48 +117,12 @@ build_boot_bin() {
 	rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.hddimg
 	ln -s ${IMAGE_NAME}.hddimg ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.hddimg
 	
-	#Create an ISO if we have an INITRD
-	if [ -n "${INITRD}" ] && [ -s "${INITRD}" ] && [ "${NOISO}" != "1" ] ; then
-		install -d ${ISODIR}
-
-		# Install the kernel
-
-		install -m 0644 ${STAGING_DIR_HOST}/kernel/bzImage \
-		        ${ISODIR}/vmlinuz
-
-		# Install the configuration files
-
-		cp ${HDDDIR}/syslinux.cfg ${ISODIR}/isolinux.cfg
-
-		if [ -f ${SYSLINUXMENU} ]; then
-			cp ${SYSLINUXMENU} ${ISODIR}
-		fi
-
-		install -m 0644 ${INITRD} ${ISODIR}/initrd
-
-		if [ -n "${ROOTFS}" ] && [ -s "${ROOTFS}" ]; then 
-			install -m 0644 ${ROOTFS} ${ISODIR}/rootfs.img
-		fi
-
-		# And install the syslinux stuff 
-		cp ${STAGING_LIBDIR}/syslinux/isolinux.bin ${ISODIR}
-
-		mkisofs -V ${BOOTIMG_VOLUME_ID} \
-		-o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
-		-b isolinux/isolinux.bin -c isolinux/boot.cat -r \
-		-no-emul-boot -boot-load-size 4 -boot-info-table \
-		${S}/cd/
-
-		cd ${DEPLOY_DIR_IMAGE}
-		rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso
-		ln -s ${IMAGE_NAME}.iso ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso
-
-	fi
 } 
 
 python do_bootimg() {
 	bb.build.exec_func('build_syslinux_cfg', d)
-	bb.build.exec_func('build_boot_bin', d)
+	bb.build.exec_func('build_hddimg', d)
+	bb.build.exec_func('build_iso', d)
 }
 
 addtask bootimg before do_build

1.7.6.4

Working towards a more generic bootimg.bbclass, pull out all syslinux specific bits and let syslinux.bbclass manage them directly. This introduces no functional changes to the images constructed and the behavior remains unchanged.

---
 meta/classes/bootimg.bbclass  |   74 ++++++++---------------------------
 meta/classes/syslinux.bbclass |   84 +++++++++++++++++++++++++++++++++--------
 2 files changed, 85 insertions(+), 73 deletions(-)

index 26d2fae..d4da95b 100644
@@ -17,36 +17,26 @@
 # in syslinux. Actions based on the label are then performed (e.g. installing to 
 # an hdd)
 
-# External variables
+# External variables (also used by syslinux.bbclass)
 # ${INITRD} - indicates a filesystem image to use as an initrd (optional)
+# ${NOISO}  - skip building the ISO image if set to 1
 # ${ROOTFS} - indicates a filesystem image to include as the root filesystem (optional)
-# ${AUTO_SYSLINUXCFG} - set this to 1 to enable creating an automatic config
-# ${LABELS} - a list of targets for the automatic config
-# ${APPEND} - an override list of append strings for each label
-# ${SYSLINUX_OPTS} - additional options to add to the syslinux file ';' delimited 
 
 do_bootimg[depends] += "dosfstools-native:do_populate_sysroot \
-                       syslinux:do_populate_sysroot \
-                       syslinux-native:do_populate_sysroot \
-		       mtools-native:do_populate_sysroot \
-		       cdrtools-native:do_populate_sysroot"
+                        mtools-native:do_populate_sysroot \
+                        cdrtools-native:do_populate_sysroot"
 
 PACKAGES = " "
 EXCLUDE_FROM_WORLD = "1"
 
 HDDDIR = "${S}/hdd/boot"
-ISODIR = "${S}/cd/isolinux"
+ISODIR = "${S}/cd"
 
 BOOTIMG_VOLUME_ID   ?= "boot"
 BOOTIMG_EXTRA_SPACE ?= "512"
 
-# Get the build_syslinux_cfg() function from the syslinux class
-
-SYSLINUXCFG  = "${HDDDIR}/syslinux.cfg"
-SYSLINUXMENU = "${HDDDIR}/menu"
-
 inherit syslinux
-		
+
 build_iso() {
 	# Only create an ISO if we have an INITRD and NOISO was not set
 	if [ -z "${INITRD}" ] || [ ! -s "${INITRD}" ] || [ "${NOISO}" = "1" ]; then

@@ -56,31 +46,12 @@ build_iso() {
 
 	install -d ${ISODIR}
 
-	# Install the kernel
-	install -m 0644 ${STAGING_DIR_HOST}/kernel/bzImage \
-	        ${ISODIR}/vmlinuz
-
-	# Install the configuration files
-	cp ${HDDDIR}/syslinux.cfg ${ISODIR}/isolinux.cfg
-
-	if [ -f ${SYSLINUXMENU} ]; then
-		cp ${SYSLINUXMENU} ${ISODIR}
-	fi
-
-	install -m 0644 ${INITRD} ${ISODIR}/initrd
-
-	if [ -n "${ROOTFS}" ] && [ -s "${ROOTFS}" ]; then 
-		install -m 0644 ${ROOTFS} ${ISODIR}/rootfs.img
-	fi
-
-	# And install the syslinux stuff 
-	cp ${STAGING_LIBDIR}/syslinux/isolinux.bin ${ISODIR}
+	syslinux_iso_populate
 
 	mkisofs -V ${BOOTIMG_VOLUME_ID} \
-	-o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
-	-b isolinux/isolinux.bin -c isolinux/boot.cat -r \
-	-no-emul-boot -boot-load-size 4 -boot-info-table \
-	${S}/cd/
+	        -o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
+		-b ${ISO_BOOTIMG} -c ${ISO_BOOTCAT} -r \
+		${MKISOFS_OPTIONS} ${ISODIR}
 
 	cd ${DEPLOY_DIR_IMAGE}
 	rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso

@@ -89,35 +60,24 @@ build_iso() {
 
 build_hddimg() {
 	install -d ${HDDDIR}
-	install -m 0644 ${STAGING_DIR_HOST}/kernel/bzImage \
-	${HDDDIR}/vmlinuz
-
-	if [ -n "${INITRD}" ] && [ -s "${INITRD}" ]; then 
-    		install -m 0644 ${INITRD} ${HDDDIR}/initrd
-	fi
 
-	if [ -n "${ROOTFS}" ] && [ -s "${ROOTFS}" ]; then 
-    		install -m 0644 ${ROOTFS} ${HDDDIR}/rootfs.img
-	fi
-
-	install -m 444 ${STAGING_LIBDIR}/syslinux/ldlinux.sys ${HDDDIR}/ldlinux.sys
+	syslinux_hddimg_populate
 
-	# Do a little math, bash style
-	#BLOCKS=`du -s ${HDDDIR} | cut -f 1`
+	# Determine the block count for the final image
 	BLOCKS=`du -bks ${HDDDIR} | cut -f 1`
-	SIZE=`expr $BLOCKS + ${BOOTIMG_EXTRA_SPACE}`	
+	SIZE=`expr $BLOCKS + ${BOOTIMG_EXTRA_SPACE}`
 
 	mkdosfs -n ${BOOTIMG_VOLUME_ID} -d ${HDDDIR} \
-	-C ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg $SIZE 
+	        -C ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg $SIZE 
+
+	syslinux_hddimg_install
 
-	syslinux ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg
 	chmod 644 ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg
 
 	cd ${DEPLOY_DIR_IMAGE}
 	rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.hddimg
 	ln -s ${IMAGE_NAME}.hddimg ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.hddimg
-	
-} 
+}
 
 python do_bootimg() {
 	bb.build.exec_func('build_syslinux_cfg', d)

1.7.6.4

Create a new grub-efi.bbclass and integrate it into bootimg alongside the syslinux support. This new class uses the output from the grub-efi-native recipe. Thanks goes to Josef Ahmad <[email protected]> for the original build_grub_cfg() routine.

The EFI features are only added to the image if MACHINE_FEATURES contains "efi". The resulting images are therefor either legacy boot only (like they were originally) or legacy boot and EFI boot.

A new "dummy.bbclass" was added to allow for the conditional include of grub-efi. This makes it so if efi support is not to be built in, we don't spend time building grub-efi-native just because the include adds the dependency.

There is a bug in the mkdosfs tool from the dosfstools package which causes it to crash when the directory passed with the -d parameter contains sub-directories. An /EFI/BOOT directory is required for a proper EFI installation. Until it is fixed, we install to the top level directory for the hddimg.

---
 meta/classes/bootimg.bbclass  |   13 ++++
 meta/classes/dummy.bbclass    |    2 +
 meta/classes/grub-efi.bbclass |  140 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 155 insertions(+), 0 deletions(-)
 create mode 100644 meta/classes/dummy.bbclass
 create mode 100644 meta/classes/grub-efi.bbclass

index d4da95b..44bb61e 100644
@@ -35,7 +35,12 @@ ISODIR = "${S}/cd"
 BOOTIMG_VOLUME_ID   ?= "boot"
 BOOTIMG_EXTRA_SPACE ?= "512"
 
+EFI = ${@base_contains("MACHINE_FEATURES", "efi", "1", "0", d)}
+EFI_CLASS = ${@base_contains("MACHINE_FEATURES", "efi", "grub-efi", "dummy", d)}
+
 inherit syslinux
+inherit ${EFI_CLASS}
+
 
 build_iso() {
 	# Only create an ISO if we have an INITRD and NOISO was not set

@@ -47,6 +52,9 @@ build_iso() {
 	install -d ${ISODIR}
 
 	syslinux_iso_populate
+	if [ "${EFI}" = "1" ]; then
+		grubefi_iso_populate
+	fi
 
 	mkisofs -V ${BOOTIMG_VOLUME_ID} \
 	        -o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \

@@ -62,6 +70,9 @@ build_hddimg() {
 	install -d ${HDDDIR}
 
 	syslinux_hddimg_populate
+	if [ "${EFI}" = "1" ]; then
+		grubefi_hddimg_populate
+	fi
 
 	# Determine the block count for the final image
 	BLOCKS=`du -bks ${HDDDIR} | cut -f 1`

@@ -81,6 +92,8 @@ build_hddimg() {
 
 python do_bootimg() {
 	bb.build.exec_func('build_syslinux_cfg', d)
+	if d.getVar("EFI", True) == "1":
+		bb.build.exec_func('build_grub_cfg', d)
 	bb.build.exec_func('build_hddimg', d)
 	bb.build.exec_func('build_iso', d)
 }

new file mode 100644
index 0000000..8c30071
@@ -0,0 +1,2 @@
+# An empty bbclass to facilitate dynamic inherit, include,
+# and require statements.

1.7.6.4

Condition building PCBIOS legacy images on MACHINE_FEATURES containing "pcbios" or not containing "efi". This ensures existing BSPs will continue to get the old PCBIOS legacy-only images. New BSPs can add "efi", "pcbios", or both. The images created likewise support one or the other or both.

EFI-only ISO images are untested.

---
 meta/classes/bootimg.bbclass |   49 ++++++++++++++++++++++++++++++++++-------
 1 files changed, 40 insertions(+), 9 deletions(-)

index 44bb61e..d2088fe 100644
@@ -38,7 +38,24 @@ BOOTIMG_EXTRA_SPACE ?= "512"
 EFI = ${@base_contains("MACHINE_FEATURES", "efi", "1", "0", d)}
 EFI_CLASS = ${@base_contains("MACHINE_FEATURES", "efi", "grub-efi", "dummy", d)}
 
-inherit syslinux
+# Include legacy boot if MACHINE_FEATURES includes "pcbios" or if it does not
+# contain "efi". This way legacy is supported by default if neither is
+# specified, maintaining the original behavior.
+def pcbios(d):
+	pcbios = base_contains("MACHINE_FEATURES", "pcbios", "1", "0", d)
+	if pcbios == "0":
+		pcbios = base_contains("MACHINE_FEATURES", "efi", "0", "1", d)
+	return pcbios
+
+def pcbios_class(d):
+	if d.getVar("PCBIOS", True) == "1":
+		return "syslinux"
+	return "dummy"
+
+PCBIOS = ${@pcbios(d)}
+PCBIOS_CLASS = ${@pcbios_class(d)}
+
+inherit ${PCBIOS_CLASS}
 inherit ${EFI_CLASS}
 
 

@@ -51,15 +68,24 @@ build_iso() {
 
 	install -d ${ISODIR}
 
-	syslinux_iso_populate
+	if [ "${PCBIOS}" = "1" ]; then
+		syslinux_iso_populate
+	fi
 	if [ "${EFI}" = "1" ]; then
 		grubefi_iso_populate
 	fi
 
-	mkisofs -V ${BOOTIMG_VOLUME_ID} \
-	        -o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
-		-b ${ISO_BOOTIMG} -c ${ISO_BOOTCAT} -r \
-		${MKISOFS_OPTIONS} ${ISODIR}
+	if [ "${PCBIOS}" = "1" ]; then
+		mkisofs -V ${BOOTIMG_VOLUME_ID} \
+		        -o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
+			-b ${ISO_BOOTIMG} -c ${ISO_BOOTCAT} -r \
+			${MKISOFS_OPTIONS} ${ISODIR}
+	else
+		bbnote "EFI-only ISO images are untested, please provide feedback."
+		mkisofs -V ${BOOTIMG_VOLUME_ID} \
+		        -o ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.iso \
+			-r ${ISODIR}
+	fi
 
 	cd ${DEPLOY_DIR_IMAGE}
 	rm -f ${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.iso

@@ -69,7 +95,9 @@ build_iso() {
 build_hddimg() {
 	install -d ${HDDDIR}
 
-	syslinux_hddimg_populate
+	if [ "${PCBIOS}" = "1" ]; then
+		syslinux_hddimg_populate
+	fi
 	if [ "${EFI}" = "1" ]; then
 		grubefi_hddimg_populate
 	fi

@@ -81,7 +109,9 @@ build_hddimg() {
 	mkdosfs -n ${BOOTIMG_VOLUME_ID} -d ${HDDDIR} \
 	        -C ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg $SIZE 
 
-	syslinux_hddimg_install
+	if [ "${PCBIOS}" = "1" ]; then
+		syslinux_hddimg_install
+	fi
 
 	chmod 644 ${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.hddimg
 

@@ -91,7 +121,8 @@ build_hddimg() {
 }
 
 python do_bootimg() {
-	bb.build.exec_func('build_syslinux_cfg', d)
+	if d.getVar("PCBIOS", True) == "1":
+		bb.build.exec_func('build_syslinux_cfg', d)
 	if d.getVar("EFI", True) == "1":
 		bb.build.exec_func('build_grub_cfg', d)
 	bb.build.exec_func('build_hddimg', d)

1.7.6.4

This series provides optional support for EFI boot for live images, both hddimg and ISO, on ia32 platforms. It creates a new grub-efi-native recipe to create the boot image. bootimg.bbclass has been refactored and syslinux support has been made optional. The new live images can be built as PCBIOS-legacy (the original type), EFI, or both. The MACHINE_FEATURES values "pcbios" and "efi" dictate this behavior, if neither are specified, it defaults to PCBIOS-legacy only to maintain current behavior.

It is careful not to add unecessary dependencies to the build by dynamically including only the necessary bootloader classes (syslinux and/or grub-efi).

EFI hddimg's do not install into /EFI/BOOT as is proper due to a bug in the
dosfstools: http://bugzilla.yoctoproject.org/show_bug.cgi?id=1783. For now, the files are installe in the root directory and users will need to update their firmware or use a startup.nsh script for pure EFI booting.

Testing performed includes verification of the images built for the n450 BSP with all combinations of the MACHINE_FEATURES. The syslinux and grub-efi boot methods were validated on the n450 hardware as well. EFI-only ISO images are untested, help here would be appreciated.

While the "install" target is preserved for the EFI boot, it will perform the same install as it does currently - namely a GRUB legacy boot mechanism. Support for EFI boot post install will follow in another patch series.

Thanks to Koen Kooi, Chris Larson, Richard Purdie, and Josef Ahmad for their contributions of expertise, code, and testing.

NOTE: This is an RFC and not intended for inclusion. I would appreciate at least
one round of reviews from the OE experts and some additional testing before this is pulled.

The following changes since commit c5bdef56175c0b6863e3d588a5a2c23cbea7b568:

documentation/adt-manual/adt-prepare.xml: Fixed broken link (2011-11-08 21:49:45 +0000)

are available in the git repository at:
git://git.pokylinux.org/poky-contrib dvhart/efi
http://git.pokylinux.org/cgit.cgi/poky-contrib/log/?h=dvhart/efi

Darren Hart (5):
grub-efi-native: New recipe to build GRUB EFI images
bootimg: Refactor build_hddimg and build_iso routines
bootimg: Pull syslinux specific bits into syslinux.bbclass
bootimg: Add grub-efi support
bootimg: Allow for EFI-only boot images

 meta/classes/bootimg.bbclass                  |  148 +++++++++++++------------
 meta/classes/dummy.bbclass                    |    2 +
 meta/classes/grub-efi.bbclass                 |  140 +++++++++++++++++++++++
 meta/classes/syslinux.bbclass                 |   84 +++++++++++---
 meta/recipes-bsp/grub/grub-efi-native_1.99.bb |   74 ++++++++++++
 5 files changed, 362 insertions(+), 86 deletions(-)
 create mode 100644 meta/classes/dummy.bbclass
 create mode 100644 meta/classes/grub-efi.bbclass
 create mode 100644 meta/recipes-bsp/grub/grub-efi-native_1.99.bb

1.7.6.4

The problem of course with listing people, is that you are likely to miss some. Especially at midnight prior to a major holiday. My apologies to Saul Wold and Joshua Lock who also provided valuable assistance, as well as the others whom I shall predictably recall promptly upon pressing "Send".

Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel

Op 24 nov. 2011, om 09:05 heeft Darren Hart het volgende geschreven:

That's a false dilemma. If you write it as a regular recipe with BBCLASSEXTEND=native your buildtime doesn't increase and you leave open the option of adding more BBCLASSEXTENDS if someone wants to ship it in an SDK.

That isn't true, if you build a target and a native version your build time does increase. Using BBCLASSEXTEND does improve parsing time over having two separate recipes though.

I did talk with Darren about why the recipe is the way it is and there are some pretty nasty issues with the way grub builds itself. I'm therefore ok with this as a version 1 and we can see whether there are any issues that result which need us to rethink the way the recipe is constructed.

Its currently behaving very like the way the binutils/gcc cross recipes will end up (see the separate thread with Matthew) Perhaps it should be called grub-efi-cross even if it uses native.bbclass.

Cheers,

Richard

Right, while it isn't a huge project to build, I didn't want to contribute to the expanding build time unnecessarily.

I think the right thing to do here is to modify the origin grub recipe to build with the efi platform enabled if we want to ship the binaries on the TARGET. This recipe doesn't build the grub tools for deployment, it builds the target bootloader binary image for the boot media. That's the distinction I'm going with anyway.

If you prefer I can change it, I don't have a strong preference for the name. That would end up as "grub-efi-${TRANSLATED_TARGET_ARCH}-cross" after the PN adjustment then?

Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel

Op 24 nov. 2011, om 12:26 heeft Richard Purdie het volgende geschreven:

Are you really saying that 'bitbake grub-native' will build both versions if you use BBCLASSEXTEND!?!?! If not, it remains a false dilemma.

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

No, that isn't it. Because of the way grub builds, you need the utils in HOST_ARCH and the grub modules in TARGET_ARCH. Grub has a monolithic build system, so in order to do this with BBCLASSEXTEND, we would need to have grub-efi depend on grub-efi-native so that the final do_mkimage task could use the -native version of grub-mkimage to assemble the target-built modules into a final binary.

This approach builds grub natively and sets the --target to the TARGET_ARCH so the modules are built for the target. This is why I'm making the distinction between build the grub tools for deployment and building the grub efi boot image. The approach to each is different, and this recipe generates the boot image for the target.

- --
Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iQEcBAEBAgAGBQJOznttAAoJEKbMaAwKp364dG0H/0tScwNt0pc9gHDXDELdhCvp JGJ8soO+yWgksG9o/p077oysd7HMm24Tq//m7FuRzgm0D2JymYwPwdLe06mA1ARs BpwtvltUW5SLaWzJVeamxeNn5cDpdIcyaa904BdS2Ink/alZgTdoV60qh9LvElIh P70Pb/GeV/Po5OLALmnYuEV39JPnRxz7RfaXr7qU/0e0JVGKxXa/hrBp8ZgzpYI4 WvGns2LrZRPi/Fp93Vc312NfZYa2y/s9H8ji+B2Nvdza99Zo9y4xtWSf9bDRn+4J 04Kw/CFUe4GqXrIoBATLvm8LmcS/fLaqtVY5Ewz5bSnPFRvXyYApmmNvWpy5hGs= =LaXk
-----END PGP SIGNATURE-----

The grub-help list came through with an alternative approach:

"./configure CC=powerpc-linux-gcc --host=ppc-linux-gnu --target=i386 --with-platform=pc TARGET_CC=i386-linux-gcc"

This would allow for building on a host of arch ppc for a target of arch i386.

Would it be preferable then to build this as a target package and manipuate the configure flags to use the BUILD_CC ? I presume a similar PN rename would be desirable to account for the HOST component of the build as I used here for the TARGET on the -native version?

--
Darren

Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel

I have been working on trying to get this working as a target recipe. I've resolved a number of issues, but something is still biting me and I haven't been able to sort out what. I would really appreciate a few more sets of eyes on this.

I have pushed my dvhart/efi/dev branch to poky-contrib for reference:

http://git.yoctoproject.org/cgit/cgit.cgi/poky-contrib/?h=dvhart/efi/dev

When building this recipe, the mkimage task fails with the grub-mkimage command segfaulting. I can build with the same ./configure command and using the Yocto 1.1 x86_64-i586 toolchain for the TARGET_CC and the mkimage succeeds. The configure command is:

./configure --build=x86_64-linux --host=x86_64-linux --target=i586-poky-linux --prefix=/usr --exec_prefix=/usr --bindir=/usr/bin --sbindir=/usr/sbin --libexecdir=/usr/libexec --datadir=/usr/share --sysconfdir=/etc --sharedstatedir=/com --localstatedir=/var --libdir=/usr/lib --includedir=/usr/include --oldincludedir=/usr/include --infodir=/usr/share/info --mandir=/usr/share/man --disable-silent-rules --with-libtool-sysroot=/build/poky/n450/tmp/sysroots/n450 CC=gcc TARGET_CC=i586-poky-linux-gcc --with-platform=efi --enable-efiemu=no --disable-grub-mkfont --program-prefix='' --enable-nls

The make output from building manually vs. within bitbake is nearly identical with a couple minor path changes for the cross toolchain. The bitbake make also prints more errors, including the following for the grub-mkimage target (which is the one that segfaults).

gcc -DHAVE_CONFIG_H -I. -Wall -W -I./include -DGRUB_UTIL=1 -DGRUB_LIBDIR=\"/usr/lib/grub\" -DLOCALEDIR=\"/usr/share/locale\" -DGRUB_MACHINE_EFI=1 -DGRUB_MACHINE=I386_EFI -DGRUB_FILE=\"util/grub-mkimage.c\" -I. -I. -I. -I. -I./include -I./include -I./grub-core/gnulib -I./grub-core/gnulib -DGRUB_PKGLIBROOTDIR=\"/usr/lib/''grub\" -Wno-undef -Wno-sign-compare -Wno-unused -Wno-unused-parameter -MT util/grub_mkimage-grub-mkimage.o -MD -MP -MF util/.deps-util/grub_mkimage-grub-mkimage.Tpo -c -o util/grub_mkimage-grub-mkimage.o test -f 'util/grub-mkimage.c' || echo './'util/grub-mkimage.c
util/grub-mkimage.c: In function 'generate_image':
util/grub-mkimage.c:665:11: warning: passing argument 2 of 'load_image32' from incompatible pointer type [enabled by default] util/grub-mkimagexx.c:601:1: note: expected 'grub_size_t *' but argument is of type 'size_t *' util/grub-mkimage.c:665:11: warning: passing argument 3 of 'load_image32' from incompatible pointer type [enabled by default] util/grub-mkimagexx.c:601:1: note: expected 'grub_size_t *' but argument is of type 'size_t *' util/grub-mkimage.c:669:11: warning: passing argument 2 of 'load_image64' from incompatible pointer type [enabled by default] util/grub-mkimagexx.c:601:1: note: expected 'grub_size_t *' but argument is of type 'size_t *' util/grub-mkimage.c:669:11: warning: passing argument 3 of 'load_image64' from incompatible pointer type [enabled by default] util/grub-mkimagexx.c:601:1: note: expected 'grub_size_t *' but argument is of type 'size_t *'

The recipe follows for your reference and for inline comments. Any thoughts on why this might be failing? Is there are better way to go about trying to build this as a target recipe?

grub-efi_1.99.bb
----------------
SUMMARY = "GRUB2 is the next-generation GRand Unified Bootloader"

DESCRIPTION = "GRUB2 is the next generaion of a GPLed bootloader \
intended to unify bootloading across x86 operating systems. In \
addition to loading the Linux kernel, it implements the Multiboot \
standard, which allows for flexible loading of multiple boot images. \
This recipe builds an EFI binary for the target. It does not install \
or package anything, it only deploys a target-arch GRUB EFI image."

HOMEPAGE = "http://www.gnu.org/software/grub/"
SECTION = "bootloaders"
PRIORITY = "optional"

LICENSE = "GPLv3"
LIC_FILES_CHKSUM = "file://COPYING;md5=d32239bcb673463ab874e80d47fae504"

# FIXME: We should be able to optionally drop freetype as a dependency DEPENDS = "help2man-native"
RDEPENDS_${PN} = "diffutils freetype"
PR = "r1"

# FIXME: make this use build arch too?
# Native packages do not normally rebuild when the target changes. # Ensure this is built once per HOST-TARGET pair.
PN := "grub-efi"

SRC_URI = "ftp://ftp.gnu.org/gnu/grub/grub-${PV}.tar.gz"

SRC_URI[md5sum] = "ca9f2a2d571b57fc5c53212d1d22e2b5"
SRC_URI[sha256sum] = "b91f420f2c51f6155e088e34ff99bea09cc1fb89585cf7c0179644e57abd28ff"

COMPATIBLE_HOST = '(x86_64.*|i.86.*)-(linux|freebsd.*)'

S = "${WORKDIR}/grub-${PV}"

inherit autotools
inherit gettext
inherit deploy
#inherit cross

# Translate machine arches to grub arch values

python __anonymous () {
    import re
    target = d.getVar("TARGET_ARCH", True)
    if target == "x86_64":
        grubtarget = "x86_64"
        grubimage = "bootx64.efi"
    elif re.match("i.86", target):
        grubtarget = "i386"
        grubimage = "bootia32.efi"
    else:
        raise bb.parse.SkipPackage("grub-efi is incompatible with target %s" % target)
    d.setVar("GRUB_TARGET", grubtarget)
    d.setVar("GRUB_IMAGE", grubimage)

    host = d.getVar("BUILD_ARCH", True)
    if re.match("x86_64", host):
        hostarch = "x86_64"
    elif re.match("i.86", host):
        hostarch = "i386"
    else:
        # This should have been caught by COMPATIBLE_HOST above
        bb.error("grub-efi is incompatible with host %s" % host)
    d.setVar("GRUB_HOST", host)

}

# Build utils for the host and modules and images for the target:

# ./configure CC=powerpc-linux-gcc  --host=ppc-linux-gnu --target=i386 \
# --with-platform=efi TARGET_CC=i386-linux-gcc
#EXTRA_OECONF = "CC=${BUILD_PREFIX}gcc --host=${GRUB_HOST} RANLIB=${BUILD_RANLIB} \
#                TARGET_CC=${TARGET_PREFIX}gcc --target=${GRUB_TARGET} \
#                --with-platform=efi --enable-efiemu=no \
#		--disable-grub-mkfont --program-prefix=''"

#HOST_ARCH = "${BUILD_ARCH}"
#HOST_VENDOR = "${BUILD_VENDOR}"
#HOST_OS = "${BUILD_OS}"
#HOST_PREFIX = "${BUILD_PREFIX}"
#HOST_CC_ARCH = "${BUILD_CC_ARCH}"
#HOST_LD_ARCH = "${BUILD_LD_ARCH}"
#HOST_AS_ARCH = "${BUILD_AS_ARCH}"
SELECTED_OPTIMIZATION=""
FULL_OPTIMIZATION=""
CPP="${BUILD_PREFIX}gcc -E"
HOST_SYS="${BUILD_SYS}"
RANLIB="${BUILD_PREFIX}ranlib"
#LDFLAGS=""
ASNEEDED=""
TARGET_LINK_HASH_STYLE=""
TARGET_LDFLAGS=""

EXTRA_OECONF = "CC=${BUILD_PREFIX}gcc \
                TARGET_CC=${TARGET_PREFIX}gcc \
                --with-platform=efi --enable-efiemu=no \
		--disable-grub-mkfont --program-prefix=''"

do_mkimage() {
	./grub-mkimage -p / -d ./grub-core/ \
		       -O ${GRUB_TARGET}-efi -o ./${GRUB_IMAGE} \
	               boot linux fat serial part_msdos normal
}

do_compile(){
# export CFLAGS="-Os"
# export TARGET_CFLAGS="-Os"
# export CC="${BUILD_PREFIX}gcc"

	bbnote "CC=${CC}"
	bbnote "CFLAGS=${CFLAGS}"
	bbnote "TARGET_CFLAGS=${TARGET_CFLAGS}"
	bbnote "RANLIB=${RANLIB}"
	bbnote "gcc=$(which gcc)"
	oe_runmake
}

addtask mkimage after do_compile before do_install

do_deploy() {
	install -m 644 ${S}/${GRUB_IMAGE} ${DEPLOYDIR}
}

addtask deploy after do_install before do_build

do_install[noexec] = "1"
do_populate_sysroot[noexec] = "1"

--
Thanks,

Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel

Op 29 nov. 2011, om 09:03 heeft Darren Hart het volgende geschreven:

This is against poky, so I can't build it. If it was against OE-core, like one would expect on the OE-core mailing list, I could build it.

OK, fair enough.

git://git.infradead.org/srv/git/users/dvhart/oe-core.git dvhart/efi/dev

I just fixed up the patch series - untested.

Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel

Op 29 nov. 2011, om 09:58 heeft Darren Hart het volgende geschreven:

I get:

$ git fetch git://git.infradead.org/srv/git/users/dvhart/oe-core.git
fatal: The remote end hung up unexpectedly

regards,

Koen

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

When building this recipe

Grmble... too late... too rushed... too many copy buffers. Sorry about that:

git://git.infradead.org/users/dvhart/oe-core.git dvhart/efi/dev

- --
Darren Hart
Intel Open Source Technology Center
Yocto Project - Linux Kernel
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.11 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iQEcBAEBAgAGBQJO1KO/AAoJEKbMaAwKp364F3QH/iwqj6yfAuMfX1XNWFmvC+Pr yreEjQMz6n7LjN47svDZb0vTjiUTufdE6peIez1j2WZV5riXA4qePwXHa562zN1e bsBYH3pjJ87CYZ9Hyg2jdGX7VSeJGpX+dkKggucg0VwzU5MJOM1E0cwKIhfyG3Ja ytqDhQQXlTQfwHqFkKI1yp7usXDjLZc/OS/nOgNan5x2RVBnfXug33E02Y7yhldW yRIa0aoCk8LdKGj+PdOVAiHMjXA67KxO16P0Moqk4K3lSV34GBZmSNYT9Mmpk9AV nFoaxIKYZdaBqLg7i6wyM/g8U0qVajdE3koAj2Hy/KPHXaU/nhiUx9vYg09yyw8= =e2h9
-----END PGP SIGNATURE-----