Merge lp:~sergiusens/snappy/noUpdateGrub into lp:~snappy-dev/snappy/snappy-moved-to-github

[Sergio Schvezov]

Don't run update-grub, instead use grub.cfg from the oem package.

this can land alone

[Michael Vogt (mvo)]

Yay, I like how this looks. Please merge lp:~mvo/snappy/noUpdateGrub for more that can be removed if we go to a static grub.cfg.

[lp:~sergiusens/snappy/noUpdateGrub]

488. By Sergio Schvezov on 2015-06-08

Merging mvo's neat stuff

[John Lenton (chipaca)]

LGTM. Probably needs conflict resolution though.

review: Approve

[Michael Vogt (mvo)]

I don't think we can merge this just yet, we need a new grub.cfg first if I'm not missing something.

[lp:~sergiusens/snappy/noUpdateGrub]

489. By Sergio Schvezov on 2015-06-18

Merging mvo's nice additions

490. By Sergio Schvezov on 2015-06-19

merge trunk

491. By Sergio Schvezov on 2015-07-01

Merging trunk

492. By Sergio Schvezov on 2015-07-01

fix bootloader dir and support file syncing from the oem package

493. By Sergio Schvezov on 2015-07-01

tests for copy file if different

494. By Sergio Schvezov on 2015-07-01

Test boot asset copy

495. By Sergio Schvezov on 2015-07-01

Remove spurious print

[lp:~sergiusens/snappy/noUpdateGrub]

496. By Sergio Schvezov on 2015-07-01

merge trunk

497. By Sergio Schvezov on 2015-07-01

Using helpers.CopyFile

498. By Sergio Schvezov on 2015-07-02

Revert system-image-cli change

499. By Sergio Schvezov on 2015-07-03

Trunk merge

=== modified file 'debian/ubuntu-snappy.install'
--- debian/ubuntu-snappy.install	2015-04-17 17:07:45 +0000
+++ debian/ubuntu-snappy.install	2015-07-03 12:26:50 +0000
@@ -1,4 +1,3 @@
 debian/*.service /lib/systemd/system/
 debian/*.target /lib/systemd/system/
-etc
 debian/*.timer /lib/systemd/system/

=== removed directory 'etc'
=== removed directory 'etc/grub.d'
=== removed file 'etc/grub.d/09_snappy'
--- etc/grub.d/09_snappy	2015-06-08 19:15:52 +0000
+++ etc/grub.d/09_snappy	1970-01-01 00:00:00 +0000
@@ -1,441 +0,0 @@
-#!/bin/sh
-#---------------------------------------------------------------------
-# Summary: Grub bootloader logic for Ubuntu Snappy systems.
-# Description: This is a heavily modified "10_linux" grub snippet that
-#   deals with Snappy dual-rootfs systems.
-#
-# XXX: Note that this script is called from within a chroot environment
-# on snappy systems!
-#
-#---------------------------------------------------------------------
-
-set -e
-
-prefix="/usr"
-exec_prefix="/usr"
-datarootdir="/usr/share"
-
-# Utility functions
-. "${datarootdir}/grub/grub-mkconfig_lib"
-
-# Globals
-machine=`uname -m`
-
-SNAPPY_OS="Ubuntu Core Snappy"
-SNAPPY_TYPE=simple
-
-#---------------------------------------------------------------------
-
-# Display message and exit
-die()
-{
-    msg="$*"
-    echo "ERROR: $msg" >&2
-    exit 1
-}
-
-# Create a grub menu entry by writing a menuentry to stdout.
-linux_entry_ext()
-{
-  local name="$1"
-  local os="$2"
-  local version="$3"
-  local type="$4"
-  local args="$5"
-  local device="$6"
-  local kernel="$7"
-  local initrd="$8"
-
-  local boot_device_id=
-  local prepare_root_cache=
-  local prepare_boot_cache=
-
-  if [ -z "$boot_device_id" ]; then
-      boot_device_id="$(grub_get_device_id "${device}")"
-  fi
-
-  echo "menuentry '$name' ${CLASS} \$menuentry_id_option 'gnulinux-simple-$boot_device_id' {" | sed "s/^/$submenu_indentation/"
-
-  if [ x$type != xrecovery ] ; then
-      save_default_entry | grub_add_tab
-  fi
-
-  # Use ELILO's generic "efifb" when it's known to be available.
-  # FIXME: We need an interface to select vesafb in case efifb can't be used.
-  if [ "x$GRUB_GFXPAYLOAD_LINUX" = x ]; then
-      echo "	load_video" | sed "s/^/$submenu_indentation/"
-  else
-      if [ "x$GRUB_GFXPAYLOAD_LINUX" != xtext ]; then
-	  echo "	load_video" | sed "s/^/$submenu_indentation/"
-      fi
-  fi
-  if ([ "$ubuntu_recovery" = 0 ] || [ x$type != xrecovery ]) && \
-     ([ "x$GRUB_GFXPAYLOAD_LINUX" != x ] || [ "$gfxpayload_dynamic" = 1 ]); then
-      echo "	gfxmode \$linux_gfx_mode" | sed "s/^/$submenu_indentation/"
-  fi
-
-  echo "	insmod gzio" | sed "s/^/$submenu_indentation/"
-  echo "	if [ x\$grub_platform = xxen ]; then insmod xzio; insmod lzopio; fi" | sed "s/^/$submenu_indentation/"
-
-  # device may be a label (LABEL=name), so convert back to full path
-  label_name=$(echo "$device"|sed 's/^LABEL=//g')
-  if [ "$device" = "$label_name" ]
-  then
-    device_path="$device"
-  else
-    # found a label
-    device_path=$(get_partition_from_label "$label_name")
-  fi
-
-  if [ x$dirname = x/ ]; then
-    if [ -z "${prepare_root_cache}" ]; then
-
-      prepare_root_cache="$(prepare_grub_to_access_device ${device_path} | grub_add_tab)"
-    fi
-    printf '%s\n' "${prepare_root_cache}" | sed "s/^/$submenu_indentation/"
-  else
-    if [ -z "${prepare_boot_cache}" ]; then
-      prepare_boot_cache="$(prepare_grub_to_access_device ${device_path} | grub_add_tab)"
-    fi
-    printf '%s\n' "${prepare_boot_cache}" | sed "s/^/$submenu_indentation/"
-  fi
-
-  if [ x"$quiet_boot" = x0 ] || [ x"$type" != xsimple ]; then
-    message="$(gettext_printf "Loading Linux %s ..." ${version})"
-    sed "s/^/$submenu_indentation/" << EOF
-	echo	'$(echo "$message" | grub_quote)'
-EOF
-  fi
-
-    sed "s/^/$submenu_indentation/" << EOF
-	linux ${kernel} root=${device} ro ${args}
-EOF
-
-  if test -n "${initrd}"; then
-    # TRANSLATORS: ramdisk isn't identifier. Should be translated.
-    if [ x"$quiet_boot" = x0 ] || [ x"$type" != xsimple ]; then
-      message="$(gettext_printf "Loading initial ramdisk ...")"
-      sed "s/^/$submenu_indentation/" << EOF
-	echo	'$(echo "$message" | grub_quote)'
-EOF
-    fi
-    sed "s/^/$submenu_indentation/" << EOF
-	initrd ${initrd}
-EOF
-  fi
-
-  sed "s/^/$submenu_indentation/" << EOF
-}
-EOF
-}
-
-# Returns a list of the currently available kernels.
-# $1: If set, look for kernel below "$1/boot/".
-get_kernels()
-{
-    local prefix_dir="$1"
-    local list
-
-    case "x$machine" in
-    xi?86 | xx86_64)
-    list=`for i in $prefix_dir/boot/vmlinuz-* \
-                         $prefix_dir/vmlinuz-* \
-                         $prefix_dir/boot/kernel-* ; do
-                  if grub_file_is_not_garbage "$i" ; then echo -n "$i " ; fi
-              done` ;;
-    *) 
-    list=`for i in $prefix_dir/boot/vmlinuz-* \
-                         $prefix_dir/boot/vmlinux-* \
-                         $prefix_dir/vmlinuz-* \
-                         $prefix_dir/vmlinux-* \
-                         $prefix_dir/boot/kernel-* ; do
-                  if grub_file_is_not_garbage "$i" ; then echo -n "$i " ; fi
-         done` ;;
-    esac
-    echo "$list"
-}
-
-# Composes and returns a kernel cmd line
-get_cmdline() {
-    channel_ini="/etc/system-image/channel.ini"
-    grep -q 'device: azure_amd64' "$channel_ini" && azure_cmdline="rootdelay=300"
-
-    echo "${GRUB_CMDLINE_LINUX} ${GRUB_CMDLINE_LINUX_DEFAULT} $azure_cmdline"
-}
-
-# Returns the path to the initrd for the kernel specified by $1.
-# $1: kernel version.
-# $2: directory to look in.
-get_initrd()
-{
-  local version="$1"
-  local dir="$2"
-
-  local alt_version=`echo $version | sed -e "s,\.old$,,g"`
-  local initrd=
-  local i=
-
-  for i in "initrd.img-${version}" "initrd-${version}.img" "initrd-${version}.gz" \
-           "initrd-${version}" "initramfs-${version}.img" \
-           "initrd.img-${alt_version}" "initrd-${alt_version}.img" \
-           "initrd-${alt_version}" "initramfs-${alt_version}.img" \
-           "initramfs-genkernel-${version}" \
-           "initramfs-genkernel-${alt_version}" \
-           "initramfs-genkernel-${GENKERNEL_ARCH}-${version}" \
-           "initramfs-genkernel-${GENKERNEL_ARCH}-${alt_version}"; do
-    if test -e "${dir}/${i}" ; then
-      initrd="${dir}/${i}"
-      break
-    fi
-  done
-  echo "$initrd"
-}
-
-# Determine full path to disk partition given a filesystem label.
-get_partition_from_label()
-{
-    local label="$1"
-    local part=
-    local path=
-
-    [ -n "$label" ] || grub_warn "need FS label"
-
-    part=$(find /dev -name "$label"|tail -1)
-    [ -z "$part" ] && return
-    path=$(readlink -f "$part")
-    [ -n "$path" ] && echo "$path"
-}
-
-# Return the partition label for the given partition device.
-# $1: full path to partition device.
-get_label_from_device()
-{
-    local root="$1"
-
-    local label=
-    local std_label=
-    local label_rootfs=
-
-    for std_label in system-a system-b; do
-        label_rootfs=$(findfs "PARTLABEL=$std_label" 2>/dev/null || :)
-        if [ "$label_rootfs" = "$root" ]; then
-            label="$std_label"
-            break
-        fi
-    done
-
-    echo "$label"
-}
-
-# Return the full path to the device corresponding to the given
-# partition label.
-#
-# $1: partition label.
-get_device_from_label()
-{
-    local label="$1"
-    local device=
-
-    device=$(findfs "PARTLABEL=$label" 2>/dev/null || :)
-    echo "$device"
-}
-
-# Given a rootfs label, return the rootfs label corresponding to the
-# "other" rootfs partition.
-get_other_rootfs_label()
-{
-    local label="$1"
-
-    if [ "$label" = "system-a" ]; then
-        echo "system-b"
-    else
-        echo "system-a"
-    fi
-}
-
-# Given a mountpoint, return the corresponding device path
-# $1: mountpoint.
-get_device_from_mountpoint()
-{
-    local mountpoint="$1"
-    local device=
-
-    # XXX: Parse mount output rather than looking in /proc/mounts to
-    # avoid seeing the mounts outside the chroot.
-    device=$(/bin/mount | grep "^/dev/.* on ${mountpoint}[[:space:]]" 2>/dev/null |\
-        awk '{print $1}' || :)
-
-    echo "$device"
-}
-
-# Convert a partition label name to a menuentry name
-make_name()
-{
-    local label="$1"
-
-    echo "$SNAPPY_OS $label rootfs" | grub_quote
-}
-
-# Arrange for a grub menuentry to be created for the given partition.
-#
-# $1: full path to rootfs partition device
-# $2: partition label associated with $1
-# $3: mountpoint of $1.
-handle_menu_entry()
-{
-    local rootfs_device="$1"
-    local label="$2"
-    local mountpoint="$3"
-
-    local name=
-    local device=
-    local mount_prefix=
-    local list=
-    local linux=
-    local basename=
-    local dirname=
-    local rel_dirname=
-    local version=
-    local initrd=
-    local cmdline=
-
-    # boot by label
-    device="LABEL=$label"
-
-    name=$(make_name "$label")
-
-    # avoid double-leading slashes and the subsequent need to call
-    # 'readlink -f'.
-    if [ "$mountpoint" = "/" ]; then
-        mount_prefix=""
-    else
-        mount_prefix="$mountpoint"
-    fi
-    list=$(get_kernels "$mount_prefix")
-
-    linux=$(version_find_latest $list)
-    basename=$(basename "$linux")
-    dirname=$(dirname "$linux")
-    rel_dirname=$(make_system_path_relative_to_its_root "$dirname")
-    version=$(echo "$basename" | sed -e "s,^[^0-9]*-,,g")
-
-    initrd=$(get_initrd "$version" "$dirname")
-
-    cmdline=$(get_cmdline)
-
-    # convert the path to the mounted "other" rootfs back to a
-    # a standard one by removing the mountpoint prefix.
-    if [ "$mountpoint" != "/" ]; then
-        linux=$(echo "$linux" | sed "s!^${mountpoint}!!g")
-        initrd=$(echo "$initrd" | sed "s!^${mountpoint}!!g")
-    fi
-
-    # Create menu entries for the 2 snappy rootfs's.
-    linux_entry_ext "$name" "$SNAPPY_OS" "$version" \
-        "$SNAPPY_TYPE" "$cmdline" "$device" \
-        "$linux" "$initrd"
-}
-
-#---------------------------------------------------------------------
-# main
-
-case "$machine" in
-    i?86) GENKERNEL_ARCH="x86" ;;
-    mips|mips64) GENKERNEL_ARCH="mips" ;;
-    mipsel|mips64el) GENKERNEL_ARCH="mipsel" ;;
-    arm*) GENKERNEL_ARCH="arm" ;;
-    *) GENKERNEL_ARCH="$machine" ;;
-esac
-
-# Determine which partition label is being used for the current root
-# directory. This is slightly convoluted but required since this code
-# runs within a chroot environment (where lsblk does not work).
-#
-# XXX: Note that since this code is run from within a chroot (where the
-# "other" rootfs is mounted), it might appear that the logic is
-# inverted. However, the code below simply 
-this_mountpoint="/"
-this_root=$(get_device_from_mountpoint "$this_mountpoint")
-[ -z "$this_root" ] && {
-    die "cannot determine rootfs for $this_mountpoint"
-}
-
-this_label=$(get_label_from_device "$this_root")
-[ -z "$this_label" ] && {
-    die "cannot determine partition label for rootfs $this_root"
-}
-
-handle_menu_entry "$this_root" "$this_label" "$this_mountpoint"
-
-other_mountpoint="/writable/cache/system"
-
-# When this script is run on a real snappy system, even if there is only
-# a single rootfs provisioned, the other rootfs partition is expected to
-# be formatted and mounted.
-#
-# However this script is also run at provisioning time where
-# $other_mountpoint will not be a mountpoint. Therefore in the provisioning
-# scenario, only a single menuentry will be generated if only a single
-# rootfs is provisioned.
-if $(mountpoint -q "$other_mountpoint"); then
-    other_label=$(get_other_rootfs_label "$this_label")
-
-    other_root=$(get_device_from_label "$other_label")
-    [ -z "$other_root" ] && {
-        die "cannot determine rootfs"
-    }
-
-    handle_menu_entry "$other_root" "$other_label" "$other_mountpoint"
-fi
-
-# Toggle rootfs if previous boot failed.
-#
-# Since grub sets snappy_trial_boot, if it is _already_ set when grub starts
-# and we're in try mode, the previous boot must have failed to unset it,
-# so toggle the rootfs.
-sed "s/^/$submenu_indentation/" << EOF
-    # set defaults
-    if [ -z "\$snappy_mode" ]; then
-        set snappy_mode=regular
-        save_env snappy_mode
-    fi
-    if [ -z "\$snappy_ab" ]; then
-        set snappy_ab=a
-        save_env snappy_ab
-    fi
-
-    if [ "\$snappy_mode" = "try" ]; then
-        if [ "\$snappy_trial_boot" = "1" ]; then
-            # Previous boot failed to unset snappy_trial_boot, so toggle
-            # rootfs.
-            if [ "\$snappy_ab" = "a" ]; then
-                set default="$(make_name system-b)"
-                set snappy_ab=b
-            else
-                set snappy_ab=a
-                set default="$(make_name system-a)"
-            fi
-            save_env snappy_ab
-        else
-            # Trial mode so set the snappy_trial_boot (which snappy is
-            # expected to unset).
-            #
-            # Note: don't use the standard recordfail variable since that forces
-            # the menu to be displayed and sets an infinite timeout if set.
-            set snappy_trial_boot=1
-            save_env snappy_trial_boot
-
-            if [ "\$snappy_ab" = "a" ]; then
-                set default="$(make_name system-a)"
-            else
-                set default="$(make_name system-b)"
-            fi
-        fi
-    else
-        if [ "\$snappy_ab" = "a" ]; then
-            set default="$(make_name system-a)"
-        else
-            set default="$(make_name system-b)"
-        fi
-    fi
-EOF

=== modified file 'helpers/helpers.go'
--- helpers/helpers.go	2015-06-09 19:11:54 +0000
+++ helpers/helpers.go	2015-07-03 12:26:50 +0000
@@ -498,3 +498,14 @@
 
 	return err
 }
+
+// CopyIfDifferent copies src to dst only if dst is different that src
+func CopyIfDifferent(src, dst string) error {
+	if !FilesAreEqual(src, dst) {
+		if err := CopyFile(src, dst, CopyFlagSync|CopyFlagOverwrite); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

=== modified file 'helpers/helpers_test.go'
--- helpers/helpers_test.go	2015-06-09 19:11:54 +0000
+++ helpers/helpers_test.go	2015-07-03 12:26:50 +0000
@@ -445,3 +445,41 @@
 	c.Check(err, NotNil)
 	c.Check(err, ErrorMatches, ".*permission denied.*")
 }
+
+func (ts *HTestSuite) TestCopyIfDifferent(c *C) {
+	srcDir := c.MkDir()
+	dstDir := c.MkDir()
+
+	// new file
+	src := filepath.Join(srcDir, "bop")
+	dst := filepath.Join(dstDir, "bob")
+	err := ioutil.WriteFile(src, []byte(nil), 0644)
+	c.Assert(err, IsNil)
+
+	err = CopyIfDifferent(src, dst)
+	c.Assert(err, IsNil)
+	c.Check(FilesAreEqual(dst, src), Equals, true)
+
+	// updated file
+	src = filepath.Join(srcDir, "bip")
+	dst = filepath.Join(dstDir, "bib")
+	err = ioutil.WriteFile(src, []byte("123"), 0644)
+	c.Assert(err, IsNil)
+	err = ioutil.WriteFile(dst, []byte(nil), 0644)
+	c.Assert(err, IsNil)
+
+	err = CopyIfDifferent(src, dst)
+	c.Assert(err, IsNil)
+	c.Check(FilesAreEqual(dst, src), Equals, true)
+}
+
+func (ts *HTestSuite) TestCopyIfDifferentErrorsOnNoSrc(c *C) {
+	srcDir := c.MkDir()
+	dstDir := c.MkDir()
+
+	src := filepath.Join(srcDir, "mop")
+	dst := filepath.Join(dstDir, "mop")
+
+	err := CopyIfDifferent(src, dst)
+	c.Assert(err, NotNil)
+}

=== modified file 'partition/bootloader.go'
--- partition/bootloader.go	2015-06-11 09:38:18 +0000
+++ partition/bootloader.go	2015-07-03 12:26:50 +0000
@@ -19,6 +19,14 @@
 
 package partition
 
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/helpers"
+)
+
 const (
 	// bootloader variable used to denote which rootfs to boot from
 	bootloaderRootfsVar = "snappy_ab"
@@ -50,7 +58,7 @@
 	// Hook function called before system-image starts downloading
 	// and applying archives that allows files to be copied between
 	// partitions.
-	SyncBootFiles() error
+	SyncBootFiles(bootAssets map[string]string) error
 
 	// Install any hardware-specific files that system-image
 	// downloaded.
@@ -72,9 +80,6 @@
 	// currently-booted rootfs as having booted successfully.
 	MarkCurrentBootSuccessful(currentRootfs string) error
 
-	// Return the additional required chroot bind mounts for this bootloader
-	AdditionalBindMounts() []string
-
 	// BootDir returns the (writable) bootloader-specific boot
 	// directory.
 	BootDir() string
@@ -98,13 +103,196 @@
 	return nil, ErrBootloader
 }
 
+type bootloaderType struct {
+	partition *Partition
+
+	// each rootfs partition has a corresponding u-boot directory named
+	// from the last character of the partition name ('a' or 'b').
+	currentRootfs string
+	otherRootfs   string
+
+	// full path to rootfs-specific assets on boot partition
+	currentBootPath string
+	otherBootPath   string
+
+	// FIXME: this should /boot if possible
+	// the dir that the bootloader lives in (e.g. /boot/uboot)
+	bootloaderDir string
+}
+
+func newBootLoader(partition *Partition, bootloaderDir string) *bootloaderType {
+	// FIXME: is this the right thing to do? i.e. what should we do
+	//        on a single partition system?
+	if partition.otherRootPartition() == nil {
+		return nil
+	}
+
+	// full label of the system {system-a,system-b}
+	currentLabel := partition.rootPartition().name
+	otherLabel := partition.otherRootPartition().name
+
+	// single letter description of the rootfs {a,b}
+	currentRootfs := string(currentLabel[len(currentLabel)-1])
+	otherRootfs := string(otherLabel[len(otherLabel)-1])
+
+	return &bootloaderType{
+		partition: partition,
+
+		currentRootfs: currentRootfs,
+		otherRootfs:   otherRootfs,
+
+		// the paths that the kernel/initramfs are loaded, e.g.
+		// /boot/uboot/a
+		currentBootPath: filepath.Join(bootloaderDir, currentRootfs),
+		otherBootPath:   filepath.Join(bootloaderDir, otherRootfs),
+
+		// the base bootloader dir, e.g. /boot/uboot or /boot/grub
+		bootloaderDir: bootloaderDir,
+	}
+}
+
+// FIXME:
+// - populate kernel if missing
+func (b *bootloaderType) SyncBootFiles(bootAssets map[string]string) (err error) {
+	for src, dst := range bootAssets {
+		if err := helpers.CopyIfDifferent(src, filepath.Join(b.bootloaderDir, dst)); err != nil {
+			return err
+		}
+	}
+
+	srcDir := b.currentBootPath
+	destDir := b.otherBootPath
+
+	// ensure they exist
+	for _, dir := range []string{srcDir, destDir} {
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return err
+		}
+
+	}
+	return helpers.RSyncWithDelete(srcDir, destDir)
+}
+
+// FIXME:
+// - if this fails it will never be re-tried because the "other" patition
+//   is updated to revision-N in /etc/system-image/channel.ini
+//   so the system only downloads from revision-N onwards even though the
+//   complete update was not applied (i.e. kernel missing)
+func (b *bootloaderType) HandleAssets() (err error) {
+	// check if we have anything, if there is no hardware yaml, there is nothing
+	// to process.
+	hardware, err := readHardwareSpec()
+	if err == ErrNoHardwareYaml {
+		return nil
+	} else if err != nil {
+		return err
+	}
+	// ensure to remove the file if there are no errors
+	defer func() {
+		if err == nil {
+			os.Remove(hardwareSpecFile)
+		}
+	}()
+
+	/*
+		// validate bootloader
+		if hardware.Bootloader != b.Name() {
+			return fmt.Errorf(
+				"bootloader is of type %s but hardware spec requires %s",
+				b.Name(),
+				hardware.Bootloader)
+		}
+	*/
+
+	// validate partition layout
+	if b.partition.dualRootPartitions() && hardware.PartitionLayout != bootloaderSystemAB {
+		return fmt.Errorf("hardware spec requires dual root partitions")
+	}
+
+	// ensure we have the destdir
+	destDir := b.otherBootPath
+	if err := os.MkdirAll(destDir, dirMode); err != nil {
+		return err
+	}
+
+	// install kernel+initrd
+	for _, file := range []string{hardware.Kernel, hardware.Initrd} {
+
+		if file == "" {
+			continue
+		}
+
+		// expand path
+		path := filepath.Join(cacheDir, file)
+
+		if !helpers.FileExists(path) {
+			return fmt.Errorf("can not find file %s", path)
+		}
+
+		// ensure we remove the dir later
+		defer func() {
+			if err == nil {
+				os.RemoveAll(filepath.Dir(path))
+			}
+		}()
+
+		if err := runCommand("/bin/cp", path, destDir); err != nil {
+			return err
+		}
+	}
+
+	// TODO: look at the OEM package for dtb changes too once that is
+	//       fully speced
+
+	// install .dtb files
+	dtbSrcDir := filepath.Join(cacheDir, hardware.DtbDir)
+	// ensure there is a DtbDir specified
+	if hardware.DtbDir != "" && helpers.FileExists(dtbSrcDir) {
+		// ensure we cleanup the source dir
+		defer func() {
+			if err == nil {
+				os.RemoveAll(dtbSrcDir)
+			}
+		}()
+
+		dtbDestDir := filepath.Join(destDir, "dtbs")
+		if err := os.MkdirAll(dtbDestDir, dirMode); err != nil {
+			return err
+		}
+
+		files, err := filepath.Glob(filepath.Join(dtbSrcDir, "*"))
+		if err != nil {
+			return err
+		}
+
+		for _, file := range files {
+			if err := runCommand("/bin/cp", file, dtbDestDir); err != nil {
+				return err
+			}
+		}
+	}
+
+	if helpers.FileExists(flashAssetsDir) {
+		// FIXME: we don't currently do anything with the
+		// MLO + uImage files since they are not specified in
+		// the hardware spec. So for now, just remove them.
+
+		if err := os.RemoveAll(flashAssetsDir); err != nil {
+			return err
+		}
+	}
+
+	return err
+}
+
 // BootloaderDir returns the full path to the (mounted and writable)
 // bootloader-specific boot directory.
 func BootloaderDir() string {
-	b, err := bootloader(nil)
-	if err != nil {
-		return ""
+	if helpers.FileExists(bootloaderUbootDir) {
+		return bootloaderUbootDir
+	} else if helpers.FileExists(bootloaderGrubDir) {
+		return bootloaderGrubDir
 	}
 
-	return b.BootDir()
+	return ""
 }

=== modified file 'partition/bootloader_grub.go'
--- partition/bootloader_grub.go	2015-06-11 09:16:26 +0000
+++ partition/bootloader_grub.go	2015-07-03 12:26:50 +0000
@@ -33,7 +33,6 @@
 	bootloaderGrubEnvFileReal    = "/boot/grub/grubenv"
 
 	bootloaderGrubEnvCmdReal       = "/usr/bin/grub-editenv"
-	bootloaderGrubUpdateCmdReal    = "/usr/sbin/update-grub"
 	bootloaderGrubTrialBootVarReal = "snappy_trial_boot"
 )
 
@@ -44,22 +43,28 @@
 	bootloaderGrubTrialBootVar = bootloaderGrubTrialBootVarReal
 	bootloaderGrubEnvFile      = bootloaderGrubEnvFileReal
 
-	bootloaderGrubEnvCmd    = bootloaderGrubEnvCmdReal
-	bootloaderGrubUpdateCmd = bootloaderGrubUpdateCmdReal
+	bootloaderGrubEnvCmd = bootloaderGrubEnvCmdReal
 )
 
 type grub struct {
+	bootloaderType
 }
 
 const bootloaderNameGrub bootloaderName = "grub"
 
 // newGrub create a new Grub bootloader object
 func newGrub(partition *Partition) bootLoader {
-	if !helpers.FileExists(bootloaderGrubConfigFile) || !helpers.FileExists(bootloaderGrubUpdateCmd) {
-		return nil
-	}
-
-	return &grub{}
+	if !helpers.FileExists(bootloaderGrubConfigFile) {
+		return nil
+	}
+
+	b := newBootLoader(partition, bootloaderGrubDir)
+	if b == nil {
+		return nil
+	}
+	g := grub{bootloaderType: *b}
+
+	return &g
 }
 
 func (g *grub) Name() bootloaderName {
@@ -73,11 +78,6 @@
 // Update the grub configuration.
 func (g *grub) ToggleRootFS(otherRootfs string) (err error) {
 
-	// create the grub config
-	if err := runInChroot(mountTarget, bootloaderGrubUpdateCmd); err != nil {
-		return err
-	}
-
 	if err := g.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeTry); err != nil {
 		return err
 	}
@@ -135,24 +135,6 @@
 	return g.setBootVar(bootloaderBootmodeVar, bootloaderBootmodeSuccess)
 }
 
-func (g *grub) SyncBootFiles() (err error) {
-	// NOP
-	return nil
-}
-
-func (g *grub) HandleAssets() (err error) {
-
-	// NOP - since grub is used on generic hardware, it doesn't
-	// need to make use of hardware-specific assets
-	return nil
-}
-
-func (g *grub) AdditionalBindMounts() []string {
-	// grub needs this in addition to "system-boot" as its the
-	// well known location for its configuration
-	return []string{"/boot/grub"}
-}
-
 func (g *grub) BootDir() string {
 	return bootloaderGrubDir
 }

=== modified file 'partition/bootloader_grub_test.go'
--- partition/bootloader_grub_test.go	2015-06-11 09:16:26 +0000
+++ partition/bootloader_grub_test.go	2015-07-03 12:26:50 +0000
@@ -23,6 +23,9 @@
 	"fmt"
 	"io/ioutil"
 	"os"
+	"path/filepath"
+
+	"launchpad.net/snappy/helpers"
 
 	. "gopkg.in/check.v1"
 )
@@ -40,7 +43,6 @@
 	// these files just needs to exist
 	mockGrubFile(c, bootloaderGrubConfigFile, 0644)
 	mockGrubFile(c, bootloaderGrubEnvFile, 0644)
-	mockGrubFile(c, bootloaderGrubUpdateCmd, 0755)
 
 	// do not run commands for real
 	runCommand = mockRunCommandWithCapture
@@ -86,18 +88,15 @@
 	mp := singleCommand{"/bin/mountpoint", mountTarget}
 	c.Assert(allCommands[0], DeepEquals, mp)
 
-	expectedGrubUpdate := singleCommand{"/usr/sbin/chroot", mountTarget, bootloaderGrubUpdateCmd}
-	c.Assert(allCommands[1], DeepEquals, expectedGrubUpdate)
-
 	expectedGrubSet := singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_mode=try"}
-	c.Assert(allCommands[2], DeepEquals, expectedGrubSet)
+	c.Assert(allCommands[1], DeepEquals, expectedGrubSet)
 
 	// the https://developer.ubuntu.com/en/snappy/porting guide says
 	// we always use the short names
 	expectedGrubSet = singleCommand{bootloaderGrubEnvCmd, bootloaderGrubEnvFile, "set", "snappy_ab=b"}
-	c.Assert(allCommands[3], DeepEquals, expectedGrubSet)
+	c.Assert(allCommands[2], DeepEquals, expectedGrubSet)
 
-	c.Assert(len(allCommands), Equals, 4)
+	c.Assert(len(allCommands), Equals, 3)
 }
 
 func mockGrubEditenvList(cmd ...string) (string, error) {
@@ -152,3 +151,32 @@
 	c.Assert(allCommands[3], DeepEquals, expectedGrubSet3)
 
 }
+
+func (s *PartitionTestSuite) TestSyncBootFilesWithAssets(c *C) {
+	err := os.MkdirAll(bootloaderGrubDir, 0755)
+	c.Assert(err, IsNil)
+
+	runCommand = mockRunCommand
+	b := grub{
+		bootloaderType{
+			currentBootPath: c.MkDir(),
+			otherBootPath:   c.MkDir(),
+			bootloaderDir:   c.MkDir(),
+		},
+	}
+
+	bootfile := filepath.Join(c.MkDir(), "bootfile")
+	err = ioutil.WriteFile(bootfile, []byte(bootfile), 0644)
+	c.Assert(err, IsNil)
+
+	bootassets := map[string]string{
+		bootfile: filepath.Base(bootfile),
+	}
+
+	err = b.SyncBootFiles(bootassets)
+	c.Assert(err, IsNil)
+
+	dst := filepath.Join(b.bootloaderDir, bootassets[bootfile])
+	c.Check(helpers.FileExists(dst), Equals, true)
+	c.Check(helpers.FilesAreEqual(bootfile, dst), Equals, true)
+}

=== modified file 'partition/bootloader_uboot.go'
--- partition/bootloader_uboot.go	2015-06-11 09:16:26 +0000
+++ partition/bootloader_uboot.go	2015-07-03 12:26:50 +0000
@@ -58,9 +58,7 @@
 const bootloaderNameUboot bootloaderName = "u-boot"
 
 type uboot struct {
-	// full path to rootfs-specific assets on boot partition
-	currentBootPath string
-	otherBootPath   string
+	bootloaderType
 }
 
 // Stores a Name and a Value to be added as a name=value pair in a file.
@@ -76,13 +74,11 @@
 		return nil
 	}
 
-	u := uboot{}
-
-	currentRootfs := partition.rootPartition().shortName
-	u.currentBootPath = filepath.Join(bootloaderUbootDir, currentRootfs)
-
-	otherRootfs := partition.otherRootPartition().shortName
-	u.otherBootPath = filepath.Join(bootloaderUbootDir, otherRootfs)
+	b := newBootLoader(partition, bootloaderUbootDir)
+	if b == nil {
+		return nil
+	}
+	u := uboot{bootloaderType: *b}
 
 	return &u
 }
@@ -207,110 +203,6 @@
 	return os.RemoveAll(bootloaderUbootStampFile)
 }
 
-func (u *uboot) SyncBootFiles() (err error) {
-	srcDir := u.currentBootPath
-	destDir := u.otherBootPath
-
-	return helpers.RSyncWithDelete(srcDir, destDir)
-}
-
-func (u *uboot) HandleAssets() (err error) {
-	// check if we have anything, if there is no hardware yaml, there is nothing
-	// to process.
-	hardware, err := readHardwareSpec()
-	if err == ErrNoHardwareYaml {
-		return nil
-	} else if err != nil {
-		return err
-	}
-	// ensure to remove the file once we are done (and all was good)
-	defer func() {
-		if err == nil {
-			os.Remove(hardwareSpecFile)
-		}
-	}()
-
-	// validate bootloader
-	if hardware.Bootloader != u.Name() {
-		return fmt.Errorf(
-			"bootloader is of type %s but hardware spec requires %s",
-			u.Name(),
-			hardware.Bootloader)
-	}
-
-	// validate partition layout, we ONLY support bootloaderSystemAB
-	// currently
-	if hardware.PartitionLayout != bootloaderSystemAB {
-		return fmt.Errorf("hardware spec requires dual root partitions")
-	}
-
-	// ensure we have the destdir
-	destDir := u.otherBootPath
-	if err := os.MkdirAll(destDir, dirMode); err != nil {
-		return err
-	}
-
-	// install kernel+initrd
-	for _, file := range []string{hardware.Kernel, hardware.Initrd} {
-
-		if file == "" {
-			continue
-		}
-
-		// expand path
-		path := filepath.Join(cacheDir, file)
-
-		if !helpers.FileExists(path) {
-			return fmt.Errorf("can not find file %s", path)
-		}
-
-		// ensure we remove the dir later
-		defer os.RemoveAll(filepath.Dir(path))
-
-		if err := runCommand("/bin/cp", path, destDir); err != nil {
-			return err
-		}
-	}
-
-	// TODO: look at the OEM package for dtb changes too once that is
-	//       fully speced
-
-	// install .dtb files
-	dtbSrcDir := filepath.Join(cacheDir, hardware.DtbDir)
-	if helpers.FileExists(dtbSrcDir) {
-		// ensure we cleanup the source dir
-		defer os.RemoveAll(dtbSrcDir)
-
-		dtbDestDir := filepath.Join(destDir, "dtbs")
-		if err := os.MkdirAll(dtbDestDir, dirMode); err != nil {
-			return err
-		}
-
-		files, err := filepath.Glob(filepath.Join(dtbSrcDir, "*"))
-		if err != nil {
-			return err
-		}
-
-		for _, file := range files {
-			if err := runCommand("/bin/cp", file, dtbDestDir); err != nil {
-				return err
-			}
-		}
-	}
-
-	if helpers.FileExists(flashAssetsDir) {
-		// FIXME: we don't currently do anything with the
-		// MLO + uImage files since they are not specified in
-		// the hardware spec. So for now, just remove them.
-
-		if err := os.RemoveAll(flashAssetsDir); err != nil {
-			return err
-		}
-	}
-
-	return err
-}
-
 // Write lines to file atomically. File does not have to preexist.
 // FIXME: put into utils package
 func atomicFileUpdateImpl(file string, lines []string) (err error) {
@@ -399,11 +291,6 @@
 	return nil
 }
 
-func (u *uboot) AdditionalBindMounts() []string {
-	// nothing additional to system-boot required on uboot
-	return []string{}
-}
-
 func (u *uboot) BootDir() string {
 	return bootloaderUbootDir
 }

=== modified file 'partition/partition.go'
--- partition/partition.go	2015-06-29 23:15:00 +0000
+++ partition/partition.go	2015-07-03 12:26:50 +0000
@@ -75,7 +75,7 @@
 	MarkBootSuccessful() error
 	// FIXME: could we make SyncBootloaderFiles part of ToogleBootloader
 	//        to expose even less implementation details?
-	SyncBootloaderFiles() error
+	SyncBootloaderFiles(bootAssets map[string]string) error
 	IsNextBootOther() bool
 
 	// run the function f with the otherRoot mounted
@@ -303,12 +303,13 @@
 
 // SyncBootloaderFiles syncs the bootloader files
 // FIXME: can we unexport this?
-func (p *Partition) SyncBootloaderFiles() (err error) {
+func (p *Partition) SyncBootloaderFiles(bootAssets map[string]string) (err error) {
 	bootloader, err := bootloader(p)
 	if err != nil {
 		return err
 	}
-	return bootloader.SyncBootFiles()
+
+	return bootloader.SyncBootFiles(bootAssets)
 }
 
 // ToggleNextBoot toggles the roofs that should be used on the next boot
@@ -541,14 +542,6 @@
 		requiredChrootMounts = append(requiredChrootMounts, boot.mountpoint)
 	}
 
-	// add additional bootloader mounts, this is required for grub
-	bootloader, err := bootloader(p)
-	if err == nil && bootloader != nil {
-		for _, mount := range bootloader.AdditionalBindMounts() {
-			requiredChrootMounts = append(requiredChrootMounts, mount)
-		}
-	}
-
 	for _, fs := range requiredChrootMounts {
 		target := filepath.Join(mountTarget, fs)
 
@@ -595,17 +588,22 @@
 		return err
 	}
 
-	// XXX: first toggle roofs and then handle assets? that seems
-	//      wrong given that handleAssets may fails and we will
-	//      knowingly boot into a broken system
-	err = p.RunWithOther(RW, func(otherRoot string) (err error) {
-		otherRootfs := p.otherRootPartition().shortName
-		return bootloader.ToggleRootFS(otherRootfs)
-	})
-
+	// ensure we have updated kernels etc
+	if err := bootloader.HandleAssets(); err != nil {
+		return err
+	}
+
+	otherRootfs := p.otherRootPartition().shortName
+	return bootloader.ToggleRootFS(otherRootfs)
+}
+
+// BootloaderDir returns the full path to the (mounted and writable)
+// bootloader-specific boot directory.
+func (p *Partition) BootloaderDir() string {
+	bootloader, err := bootloader(p)
 	if err != nil {
-		return err
+		return ""
 	}
 
-	return bootloader.HandleAssets()
+	return bootloader.BootDir()
 }

=== modified file 'partition/partition_test.go'
--- partition/partition_test.go	2015-06-11 09:16:26 +0000
+++ partition/partition_test.go	2015-07-03 12:26:50 +0000
@@ -55,7 +55,6 @@
 	bootloaderGrubDir = filepath.Join(s.tempdir, "boot", "grub")
 	bootloaderGrubConfigFile = filepath.Join(bootloaderGrubDir, "grub.cfg")
 	bootloaderGrubEnvFile = filepath.Join(bootloaderGrubDir, "grubenv")
-	bootloaderGrubUpdateCmd = filepath.Join(s.tempdir, "update-grub")
 
 	// and uboot
 	bootloaderUbootDir = filepath.Join(s.tempdir, "boot", "uboot")
@@ -79,7 +78,6 @@
 	// grub vars
 	bootloaderGrubConfigFile = bootloaderGrubConfigFileReal
 	bootloaderGrubEnvFile = bootloaderGrubEnvFileReal
-	bootloaderGrubUpdateCmd = bootloaderGrubUpdateCmdReal
 
 	// uboot vars
 	bootloaderUbootDir = bootloaderUbootDirReal
@@ -278,10 +276,6 @@
 		mountEntry{source: "/boot/efi", target: mountTarget + "/boot/efi",
 			options: "bind", bindMount: true},
 
-		// this comes from the grub bootloader via AdditionalBindMounts
-		mountEntry{source: "/boot/grub", target: mountTarget + "/boot/grub",
-			options: "bind", bindMount: true},
-
 		// Required to allow grub inside the chroot to access
 		// the "current" rootfs outside the chroot (used
 		// to generate the grub menuitems).
@@ -383,7 +377,7 @@
 	b.ToggleRootFSCalled = true
 	return nil
 }
-func (b *mockBootloader) SyncBootFiles() error {
+func (b *mockBootloader) SyncBootFiles(bootAssets map[string]string) error {
 	b.SyncBootFilesCalled = true
 	return nil
 }
@@ -401,10 +395,6 @@
 	b.MarkCurrentBootSuccessfulCalled = true
 	return nil
 }
-func (b *mockBootloader) AdditionalBindMounts() []string {
-	return nil
-}
-
 func (b *mockBootloader) BootDir() string {
 	return ""
 }
@@ -453,7 +443,7 @@
 	p := New()
 	c.Assert(c, NotNil)
 
-	err := p.SyncBootloaderFiles()
+	err := p.SyncBootloaderFiles(nil)
 	c.Assert(err, IsNil)
 	c.Assert(b.SyncBootFilesCalled, Equals, true)
 }

=== modified file 'snappy/oem.go'
--- snappy/oem.go	2015-05-28 11:58:30 +0000
+++ snappy/oem.go	2015-07-03 12:26:50 +0000
@@ -40,7 +40,8 @@
 type OEM struct {
 	Store    Store `yaml:"store,omitempty"`
 	Hardware struct {
-		Assign []HardwareAssign `yaml:"assign,omitempty"`
+		Assign     []HardwareAssign `yaml:"assign,omitempty"`
+		BootAssets *BootAssets      `yaml:"boot-assets,omitempty"`
 	} `yaml:"hardware,omitempty"`
 	Software Software `yaml:"software,omitempty"`
 }
@@ -55,6 +56,28 @@
 	BuiltIn []string `yaml:"built-in,omitempty"`
 }
 
+// BootAssets represent all the artifacts required for booting a system
+// that are particular to the board.
+type BootAssets struct {
+	Files    []BootAssetFiles    `yaml:"files,omitempty"`
+	RawFiles []BootAssetRawFiles `yaml:"raw-files,omitempty"`
+}
+
+// BootAssetRawFiles represent all the artifacts required for booting a system
+// that are particular to the board and require copying to specific sectors of
+// the disk
+type BootAssetRawFiles struct {
+	Path   string `yaml:"path"`
+	Offset string `yaml:"offset"`
+}
+
+// BootAssetFiles represent all the files required for booting a system
+// that are particular to the board
+type BootAssetFiles struct {
+	Path   string `yaml:"path"`
+	Target string `yaml:"target,omitempty"`
+}
+
 // HardwareAssign describes the hardware a app can use
 type HardwareAssign struct {
 	PartID string `yaml:"part-id,omitempty"`
@@ -111,6 +134,28 @@
 	return nil, errors.New("no oem snap")
 }
 
+func bootAssetFilePaths() map[string]string {
+	oem, err := getOem()
+	if err != nil {
+		return nil
+	}
+
+	fileList := make(map[string]string)
+	oemPath := filepath.Join(snapOemDir, oem.Name, oem.Version)
+
+	for _, asset := range oem.OEM.Hardware.BootAssets.Files {
+		orig := filepath.Join(oemPath, asset.Path)
+
+		if asset.Target == "" {
+			fileList[orig] = filepath.Base(orig)
+		} else {
+			fileList[orig] = asset.Target
+		}
+	}
+
+	return fileList
+}
+
 // StoreID returns the store id setup by the oem package or an empty string
 func StoreID() string {
 	oem, err := getOem()

=== modified file 'snappy/systemimage.go'
--- snappy/systemimage.go	2015-06-30 10:34:01 +0000
+++ snappy/systemimage.go	2015-07-03 12:26:50 +0000
@@ -194,7 +194,7 @@
 	if pb != nil {
 		pb.Notify("Syncing boot files")
 	}
-	err = s.partition.SyncBootloaderFiles()
+	err = s.partition.SyncBootloaderFiles(bootAssetFilePaths())
 	if err != nil {
 		return "", err
 	}

=== modified file 'snappy/systemimage_test.go'
--- snappy/systemimage_test.go	2015-06-30 10:34:01 +0000
+++ snappy/systemimage_test.go	2015-07-03 12:26:50 +0000
@@ -161,7 +161,7 @@
 	p.markBootSuccessfulCalled = true
 	return nil
 }
-func (p *MockPartition) SyncBootloaderFiles() error {
+func (p *MockPartition) SyncBootloaderFiles(map[string]string) error {
 	p.syncBootloaderFilesCalled = true
 	return nil
 }