Added --preserve option and logic.

build_image

 #!/bin/bash
 
 # Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Script to build a bootable keyfob-based chromeos system image from within
 # a chromiumos setup. This assumes that all needed packages have been built into
 # the given target's root with binary packages turned on. This script will
 # build the Chrome OS image using only pre-built binary packages.
@@ skipping 30 matching lines @@
   "The target image file or device"
 DEFINE_boolean factory_install ${FLAGS_FALSE} \
   "Build a smaller image to overlay the factory install shim on; this argument \
 is also required in image_to_usb."
 DEFINE_string arm_extra_bootargs "" \
   "Additional command line options to pass to the ARM kernel."
 DEFINE_integer rootfs_partition_size 1024 \
   "rootfs parition size in MBs."
 DEFINE_integer rootfs_size 720 \
   "rootfs filesystem size in MBs."
+DEFINE_boolean preserve ${FLAGS_FALSE} \
+  "Attempt to preserve the previous build image if one can be found (unstable, \
+kernel/firmware not updated)"
 
 # Parse command line.
 FLAGS "$@" || exit 1
 eval set -- "${FLAGS_ARGV}"
 
 # Only now can we die on error.  shflags functions leak non-zero error codes,
 # so will die prematurely if 'set -e' is specified before now.
 set -e
 
 if [ -z "${FLAGS_board}" ] ; then
@@ skipping 26 matching lines @@
 
 # If we are creating a developer image, also create a pristine image with a
 # different name.
 DEVELOPER_IMAGE_NAME=
 PRISTINE_IMAGE_NAME=chromiumos_image.bin
 if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ]; then
   PRISTINE_IMAGE_NAME=chromiumos_base_image.bin
   DEVELOPER_IMAGE_NAME=chromiumos_image.bin
 fi
 
-OUTPUT_IMG=${FLAGS_to:-${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME}}
+PRISTINE_IMG="${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME}"
+DEVELOPER_IMG="${OUTPUT_DIR}/${DEVELOPER_IMAGE_NAME}"
 
 BOARD="${FLAGS_board}"
 BOARD_ROOT="${FLAGS_build_root}/${BOARD}"
 
 ROOT_FS_IMG="${OUTPUT_DIR}/rootfs.image"
 ROOT_FS_DIR="${OUTPUT_DIR}/rootfs"
 
 STATEFUL_FS_IMG="${OUTPUT_DIR}/stateful_partition.image"
 STATEFUL_FS_DIR="${OUTPUT_DIR}/stateful_partition"
 
@@ skipping 53 matching lines @@
   if [[ ${FLAGS_replace} -eq ${FLAGS_TRUE} ]]; then
     sudo rm -rf "${OUTPUT_DIR}"
   else
     echo "Directory ${OUTPUT_DIR} already exists."
     echo "Use --build_attempt option to specify an unused attempt."
     echo "Or use --replace if you want to overwrite this directory."
     exit 1
   fi
 fi
 
+# Find previous build, if any...
+PREVIOUS_DIR=$($SCRIPTS_DIR/get_latest_image.sh --board="$BOARD")
+
 cleanup_rootfs_loop() {
   sudo umount -d "${ROOT_FS_DIR}"
 }
 
 cleanup_stateful_fs_loop() {
   sudo umount "${ROOT_FS_DIR}/usr/local"
   sudo umount "${ROOT_FS_DIR}/var"
   sudo umount -d "${STATEFUL_FS_DIR}"
 }
 
@@ skipping 44 matching lines @@
 
 # Modifies an existing image to add development packages
 update_dev_packages() {
   local image_name=$1
 
   echo "Adding developer packages to ${image_name}"
 
   trap "mount_gpt_cleanup \"${ROOT_FS_DIR}\" \"${STATEFUL_FS_DIR}\"" EXIT
 
   ${SCRIPTS_DIR}/mount_gpt_image.sh --from "${OUTPUT_DIR}" \
-    --image "$( basename ${image_name} )" -r "${ROOT_FS_DIR}" \
+    --image "${image_name}" -r "${ROOT_FS_DIR}" \
     -s "${STATEFUL_FS_DIR}"
 
   # Determine the root dir for developer packages.
   local root_dev_dir="${ROOT_FS_DIR}"
   [ ${FLAGS_statefuldev} -eq ${FLAGS_TRUE} ] && \
     root_dev_dir="${ROOT_FS_DIR}/usr/local"
 
   # Install developer packages described in chromeos-dev.
   sudo INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
       --root="${root_dev_dir}" --root-deps=rdeps \
-      --usepkg chromeos-dev ${EMERGE_JOBS}
+      --usepkg -uDNv chromeos-dev ${EMERGE_JOBS}
+
+  if [[ $FLAGS_preserve -eq ${FLAGS_TRUE} ]] ; then
+    # Clean out unused packages
+    sudo INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
+      --root="${ROOT_FS_DIR}" --root-deps=rdeps \
+      --usepkg --depclean ${EMERGE_JOBS}
+  fi
 
   # Re-run ldconfig to fix /etc/ldconfig.so.cache.
   sudo /sbin/ldconfig -r "${ROOT_FS_DIR}"
 
   # Mark the image as a developer image (input to chromeos_startup).
   sudo mkdir -p "${ROOT_FS_DIR}/root"
   sudo touch "${ROOT_FS_DIR}/root/.dev_mode"
 
   # Additional changes to developer image.
 
@@ skipping 12 matching lines @@
     "${SCRIPTS_DIR}/test_image" \
       --root="${ROOT_FS_DIR}" \
       --target="${ARCH}"
   fi
   echo "Developer image built and stored at ${image_name}"
 
   trap - EXIT
   ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${ROOT_FS_DIR}" -s "${STATEFUL_FS_DIR}"
 }
 
+# Update the base package on an existing image.
+update_base_packages() {
+  local image_name=$1
+
+  echo "Updating base packages on ${image_name}"
+
+  # Create stateful partition of the same size as the rootfs.
+  trap "mount_gpt_cleanup \"${ROOT_FS_DIR}\" \"${STATEFUL_FS_DIR}\"" EXIT
+
+  ${SCRIPTS_DIR}/mount_gpt_image.sh --from "${OUTPUT_DIR}" \
+    --image "${image_name}" -r "${ROOT_FS_DIR}" \
+    -s "${STATEFUL_FS_DIR}"
+
+  # Emerge updated packages, exactly like when creating base image
+  sudo INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
+    --root="${ROOT_FS_DIR}" --root-deps=rdeps \
+    --usepkg -uDNv chromeos ${EMERGE_JOBS}
+
+  # Clean out unused packages
+  sudo INSTALL_MASK="${INSTALL_MASK}" ${EMERGE_BOARD_CMD} \
+    --root="${ROOT_FS_DIR}" --root-deps=rdeps \
+    --usepkg --depclean ${EMERGE_JOBS}
+
+  trap - EXIT
+  ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${ROOT_FS_DIR}" -s "${STATEFUL_FS_DIR}"
+}
+
 create_base_image() {
+  local image_name=$1
 
   trap "cleanup && delete_prompt" EXIT
 
+  UUID=$(uuidgen)
+
   # Create and format the root file system.
 
   # Check for loop device before creating image.
   LOOP_DEV=$(sudo losetup -f)
   if [ -z "${LOOP_DEV}" ] ; then
     echo "No free loop device.  Free up a loop device or reboot.  exiting. "
     exit 1
   fi
 
   # Create root file system disk image to fit on a 1GB memory stick.
   # 1 GB in hard-drive-manufacturer-speak is 10^9, not 2^30.  950MB < 10^9 bytes.
   if [[ ${FLAGS_factory_install} -eq ${FLAGS_TRUE} ]] ; then
     ROOT_SIZE_BYTES=$((1024 * 1024 * 300))
   else
     ROOT_SIZE_BYTES=$((1024 * 1024 * ${FLAGS_rootfs_size}))
   fi
 
   dd if=/dev/zero of="${ROOT_FS_IMG}" bs=1 count=1 seek=$((ROOT_SIZE_BYTES - 1))
   sudo losetup "${LOOP_DEV}" "${ROOT_FS_IMG}"
   sudo mkfs.ext3 "${LOOP_DEV}"
 
   # Tune and mount rootfs.
-  UUID=$(uuidgen)
   DISK_LABEL="C-KEYFOB"
   sudo tune2fs -L "${DISK_LABEL}" -U "${UUID}" -c 0 -i 0 "${LOOP_DEV}"
   sudo mount "${LOOP_DEV}" "${ROOT_FS_DIR}"
 
   # Create stateful partition of the same size as the rootfs.
   STATEFUL_LOOP_DEV=$(sudo losetup -f)
   if [ -z "${STATEFUL_LOOP_DEV}" ] ; then
     echo "No free loop device.  Free up a loop device or reboot.  exiting. "
     exit 1
   fi
@@ skipping 147 matching lines @@
 
   trap delete_prompt EXIT
 
   # Create the GPT-formatted image.
   ${SCRIPTS_DIR}/build_gpt.sh \
     --arch=${ARCH} \
     --board=${FLAGS_board} \
     --arm_extra_bootargs="${FLAGS_arm_extra_bootargs}" \
     --rootfs_partition_size=${FLAGS_rootfs_partition_size} \
     "${OUTPUT_DIR}" \
-    "${OUTPUT_IMG}"
+    "${OUTPUT_DIR}/${image_name}"
+
+  trap - EXIT
+
+  # FIXME: only signing things for x86 right now.
+  if [[ "${ARCH}" = "x86" ]]; then
+    # Verify the final image.
+    load_kernel_test "${OUTPUT_DIR}/${image_name}" \
+      "${OUTPUT_DIR}/key_alg8.vbpubk"
+  fi
 }
 
 # Create the output directory.
 mkdir -p "${OUTPUT_DIR}"
 mkdir -p "${ROOT_FS_DIR}"
 mkdir -p "${STATEFUL_FS_DIR}"
 mkdir -p "${ESP_FS_DIR}"
 
-create_base_image ${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME}
+# Preserve old images by copying them forward for --preserve.
+if [[ $FLAGS_preserve -eq ${FLAGS_TRUE} ]] ; then
+  if [[ -f ${PREVIOUS_DIR}/${PRISTINE_IMAGE_NAME} ]] ; then
+    # Copy forward pristine image, and associated files
+    cp ${PREVIOUS_DIR}/*.sh ${PREVIOUS_DIR}/config.txt ${OUTPUT_DIR}
+    cp ${PREVIOUS_DIR}/${PRISTINE_IMAGE_NAME} ${OUTPUT_DIR}
+
+    # Copy forward the developer image, if we already copied forward the base.
+    if [[ ${FLAGS_withdev} -eq ${FLAGS_TRUE} ]] && \
+       [[ -f ${PREVIOUS_DIR}/${DEVELOPER_IMAGE_NAME} ]] ; then
+      cp ${PREVIOUS_DIR}/${DEVELOPER_IMAGE_NAME} ${OUTPUT_DIR}
+    fi
+  fi
+fi
+
+if [[ -f ${PRISTINE_IMG} ]] ; then
+  update_base_packages ${PRISTINE_IMAGE_NAME}
+else
+  create_base_image ${PRISTINE_IMAGE_NAME}
+fi
 
 # Create a developer image based on the chromium os base image.
 if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ] ; then
-  echo "Creating developer image from base image ${OUTPUT_IMG}"
-  cp ${OUTPUT_DIR}/${PRISTINE_IMAGE_NAME} ${OUTPUT_DIR}/${DEVELOPER_IMAGE_NAME}
-  update_dev_packages ${OUTPUT_DIR}/${DEVELOPER_IMAGE_NAME}
-fi
+  if [[ ! -f ${DEVELOPER_IMG} ]] ; then
+    echo "Creating developer image from base image ${PRISTINE_IMAGE_NAME}"
+    cp ${PRISTINE_IMG} ${DEVELOPER_IMG}
+  fi
 
-trap - EXIT
-
-# FIXME: only signing things for x86 right now.
-if [[ "${ARCH}" = "x86" ]]; then
-  # Verify the final image.
-  # key_alg8.vbpubk is generated by build_kernel_image.sh --keep_work
-  load_kernel_test "${OUTPUT_IMG}" "${OUTPUT_DIR}/key_alg8.vbpubk"
+  update_dev_packages ${DEVELOPER_IMAGE_NAME}
 fi
 
 # Clean up temporary files.
 rm -f "${ROOT_FS_IMG}" "${STATEFUL_FS_IMG}" "${OUTPUT_DIR}/vmlinuz.image" \
   "${ESP_FS_IMG}" "${OUTPUT_DIR}/data4_sign8.keyblock" \
   "${OUTPUT_DIR}/key_alg4.vbpubk" "${OUTPUT_DIR}/key_alg8.vbpubk"
 rmdir "${ROOT_FS_DIR}" "${STATEFUL_FS_DIR}" "${ESP_FS_DIR}"
 
 echo "Done.  Image created in ${OUTPUT_DIR}"
 echo "Chromium OS image created as ${PRISTINE_IMAGE_NAME}"
 if [ "${FLAGS_withdev}" -eq "${FLAGS_TRUE}" ]; then
   echo "Developer image created as ${DEVELOPER_IMAGE_NAME}"
 fi
 
 print_time_elapsed
 
 echo "To copy to USB keyfob, OUTSIDE the chroot, do something like:"
 echo "  ./image_to_usb.sh --from=${OUTSIDE_OUTPUT_DIR} --to=/dev/sdX"
 echo "To convert to VMWare image, OUTSIDE the chroot, do something like:"
 echo "  ./image_to_vmware.sh --from=${OUTSIDE_OUTPUT_DIR}"
 echo "from the scripts directory where you entered the chroot."