Allow disk image target for copy machine.

make_factory_package.sh

 #!/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 generate a factory install partition set and miniomaha.conf
 # file from a release image and a factory image. This creates a server
 # configuration that can be installed using a factory install shim.
 #
@@ skipping 16 matching lines @@
 # Flags
 DEFINE_string board "${DEFAULT_BOARD}" "Board for which the image was built"
 DEFINE_string factory "" \
   "Directory and file containing factory image: /path/chromiumos_test_image.bin"
 DEFINE_string firmware_updater "" \
   "If set, include the firmware shellball into the server configuration"
 DEFINE_string release "" \
   "Directory and file containing release image: /path/chromiumos_image.bin"
 DEFINE_string subfolder "" \
   "If set, the name of the subfolder to put the payload items inside"
+DEFINE_string diskimg "" \
+  "If set, the name of the diskimage file to output"
+DEFINE_integer sectors 31277232  "Size of image in sectors"

[Hung-Te, 2010/12/23 07:02:20]

I'd prefer to calculate this instead of manually assigning.

[Nick Sanders, 2010/12/28 22:52:31]

As we are creating the disk image, we don't know what size it ought to be,
unless passed in. There's nothing to calculate.

[Hung-Te, 2010/12/29 07:48:19]

We are creating the disk image from existing partitions, so we can definitely
know the size of each partition; and that can be used to derive a new disk
image.

For example, merge image A by partition 3/5 from image B: new image size =
(image A - partition 3/5 of image A + partition 3/5 of image B).

Anyway that's just an idea - I'm ok with current CL. We can create that kind of
tool (which can tweak images) later.

 
 # Parse command line
 FLAGS "$@" || exit 1
 eval set -- "${FLAGS_ARGV}"
 
 if [ ! -f "${FLAGS_release}" ]; then
   echo "Cannot find image file ${FLAGS_release}"
   exit 1
 fi
 
@@ skipping 26 matching lines @@
   sudo -v
   echo "Done"
 fi
 
 # Use this image as the source image to copy
 RELEASE_DIR="$(dirname "${FLAGS_release}")"
 FACTORY_DIR="$(dirname "${FLAGS_factory}")"
 RELEASE_IMAGE="$(basename "${FLAGS_release}")"
 FACTORY_IMAGE="$(basename "${FLAGS_factory}")"
 
+prepare_img() {
+  local outdev="$FLAGS_diskimg"
+  local sectors="$FLAGS_sectors"
+  local force_full="true"
+
+  # We'll need some code to put in the PMBR, for booting on legacy BIOS.
+  local pmbrcode="gptmbr.bin"
+  if ! [ -e gptmbr.bin ]; then

[Nick Sanders, 2010/12/23 04:05:54]

Where might be a good location for this file? Should we just always pull it from
the release image?

[Hung-Te, 2010/12/23 07:02:20]

PMBR from release images should be good enough.
build_image always creates legacy compatible stubs so there's no need to get
local gptmbr.

[Nick Sanders, 2010/12/28 22:52:31]

makes sense. done.

+    sudo dd bs=512 count=1 if="${FLAGS_release}" of="${pmbrcode}"
+  fi
+
+  image_dump_partial_file /dev/zero 0 "${sectors}" |
+      dd of="${outdev}" bs=8M
+  install_gpt "${outdev}" 0 0 "${pmbrcode}" 0 "${force_full}"

[Nick Sanders, 2010/12/23 04:05:54]

Probably only works in the chroot, not sure that there's any way around this.

+}
 
 prepare_omaha() {
   sudo rm -rf "${OMAHA_DATA_DIR}/rootfs-test.gz"
   sudo rm -rf "${OMAHA_DATA_DIR}/rootfs-release.gz"
   rm -rf "${OMAHA_DATA_DIR}/efi.gz"
   rm -rf "${OMAHA_DATA_DIR}/oem.gz"
   rm -rf "${OMAHA_DATA_DIR}/state.gz"
   if [ ! -d "${OMAHA_DATA_DIR}" ]; then
     mkdir -p "${OMAHA_DATA_DIR}"
   fi
@@ skipping 45 matching lines @@
   local output_file="$3"
 
   if [ -n "${IMAGE_IS_UNPACKED}" ]; then
     compress_and_hash_file "part_$part_num" "$output_file"
   else
     image_dump_partition "$input_file" "$part_num" |
     compress_and_hash_file "" "$output_file"
   fi
 }
 
-# Clean up stale config and data files.
-prepare_omaha
-
 # Decide if we should unpack partition
 if image_has_part_tools; then
   IMAGE_IS_UNPACKED=
 else
   #TODO(hungte) Currently we run unpack_partitions.sh if part_tools are not
   # found. If the format of unpack_partitions.sh is reliable, we can prevent
   # creating temporary files. See image_part_offset for more information.
   echo "WARNING: cannot find partition tools. Using unpack_partitions.sh." >&2
   IMAGE_IS_UNPACKED=1
 fi
 
-# Get the release image.
-pushd "${RELEASE_DIR}" >/dev/null
-echo "Generating omaha release image from ${FLAGS_release}"
-echo "Generating omaha factory image from ${FLAGS_factory}"
-echo "Output omaha image to ${OMAHA_DATA_DIR}"
-echo "Output omaha config to ${OMAHA_CONF}"
+partition_copy() {
+  local src="$1"
+  local srcpart="$2"
+  local dst="$3"
+  local dstpart="$4"
 
-prepare_dir
+  local srcoffset=$(partoffset "${src}" "${srcpart}")
+  local dstoffset=$(partoffset "${dst}" "${dstpart}")
+  local length=$(partsize "${src}" "${srcpart}")
 
-if [ -n "${IMAGE_IS_UNPACKED}" ]; then
-  echo "Unpacking image ${RELEASE_IMAGE} ..." >&2
-  sudo ./unpack_partitions.sh "${RELEASE_IMAGE}" 2>/dev/null
-fi
+  image_dump_partition "${src}" "${srcpart}" |
+      dd of="${dst}" bs=512 seek="${length}" conv=notrunc
+}
 
-release_hash="$(compress_and_hash_memento_image "${RELEASE_IMAGE}")"
-sudo chmod a+rw update.gz
-mv update.gz rootfs-release.gz
-mv rootfs-release.gz "${OMAHA_DATA_DIR}"
-echo "release: ${release_hash}"
+generate_img() {
+  local outdev="$FLAGS_diskimg"
+  local sectors="$FLAGS_sectors"
 
-oem_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 8 "oem.gz")"
-mv oem.gz "${OMAHA_DATA_DIR}"
-echo "oem: ${oem_hash}"
+  prepare_img
 
-efi_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 12 "efi.gz")"
-mv efi.gz "${OMAHA_DATA_DIR}"
-echo "efi: ${efi_hash}"
+  # Get the release image.
+  pushd "${RELEASE_DIR}" >/dev/null
 
-popd >/dev/null
+  echo "Release Kernel"
+  partition_copy "${RELEASE_IMAGE}" 2 "${outdev}" 4
 
-# Go to retrieve the factory test image.
-pushd "${FACTORY_DIR}" >/dev/null
-prepare_dir
+  echo "Release Rootfs"
+  partition_copy "${RELEASE_IMAGE}" 3 "${outdev}" 5
 
-if [ -n "${IMAGE_IS_UNPACKED}" ]; then
-  echo "Unpacking image ${FACTORY_IMAGE} ..." >&2
-  sudo ./unpack_partitions.sh "${FACTORY_IMAGE}" 2>/dev/null
-fi
+  echo "OEM parition"
+  partition_copy "${RELEASE_IMAGE}" 8 "${outdev}" 8
+  echo "EFI Partition"
+  partition_copy "${RELEASE_IMAGE}" 12 "${outdev}" 12
 
-test_hash="$(compress_and_hash_memento_image "${FACTORY_IMAGE}")"
-sudo chmod a+rw update.gz
-mv update.gz rootfs-test.gz
-mv rootfs-test.gz "${OMAHA_DATA_DIR}"
-echo "test: ${test_hash}"
+  popd >/dev/null
 
-state_hash="$(compress_and_hash_partition "${FACTORY_IMAGE}" 1 "state.gz")"
-mv state.gz "${OMAHA_DATA_DIR}"
-echo "state: ${state_hash}"
+  # Go to retrieve the factory test image.
+  pushd "${FACTORY_DIR}" >/dev/null
 
-popd >/dev/null
+  echo "Factory Kernel"
+  partition_copy "${FACTORY_IMAGE}" 2 "${outdev}" 2
+  echo "Factory Rootfs"
+  partition_copy "${FACTORY_IMAGE}" 3 "${outdev}" 3
+  echo "Factory Stateful"
+  partition_copy "${FACTORY_IMAGE}" 1 "${outdev}" 1
 
-if [ -n "${FLAGS_firmware_updater}" ]; then
-  SHELLBALL="${FLAGS_firmware_updater}"
-  if [ ! -f  "$SHELLBALL" ]; then
-    echo "Failed to find firmware updater: $SHELLBALL."
-    exit 1
+  echo "Generated Image at $outdev."
+  echo "Done"
+}
+
+generate_omaha() {
+  # Clean up stale config and data files.

[Nick Sanders, 2010/12/23 04:05:54]

Everythign below this line is unchanged except for indentation, reitveld just is
confused.

+  prepare_omaha
+
+  # Get the release image.
+  pushd "${RELEASE_DIR}" >/dev/null
+  echo "Generating omaha release image from ${FLAGS_release}"
+  echo "Generating omaha factory image from ${FLAGS_factory}"
+  echo "Output omaha image to ${OMAHA_DATA_DIR}"
+  echo "Output omaha config to ${OMAHA_CONF}"
+
+  prepare_dir
+
+  if [ -n "${IMAGE_IS_UNPACKED}" ]; then
+    echo "Unpacking image ${RELEASE_IMAGE} ..." >&2
+    sudo ./unpack_partitions.sh "${RELEASE_IMAGE}" 2>/dev/null
   fi
 
-  firmware_hash="$(compress_and_hash_file "$SHELLBALL" "firmware.gz")"
-  mv firmware.gz "${OMAHA_DATA_DIR}"
-  echo "firmware: ${firmware_hash}"
-fi
+  release_hash="$(compress_and_hash_memento_image "${RELEASE_IMAGE}")"
+  sudo chmod a+rw update.gz
+  mv update.gz rootfs-release.gz
+  mv rootfs-release.gz "${OMAHA_DATA_DIR}"
+  echo "release: ${release_hash}"
 
-# If the file does exist and we are using the subfolder flag we are going to
-# append another config.
-if [ -n "${FLAGS_subfolder}" ] &&
-   [ -f "${OMAHA_CONF}" ]; then
-  # Remove the ']' from the last line of the file so we can add another config.
-  while  [ -s "${OMAHA_CONF}" ]; do
-    # If the last line is null
-    if [ -z "$(tail -1 "${OMAHA_CONF}")" ]; then
-      sed -i '$d' "${OMAHA_CONF}"
-    elif [ "$(tail -1 "${OMAHA_CONF}")" != ']' ]; then
-      sed -i '$d' "${OMAHA_CONF}"
-    else
-      break
-    fi
-  done
+  oem_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 8 "oem.gz")"
+  mv oem.gz "${OMAHA_DATA_DIR}"
+  echo "oem: ${oem_hash}"
 
-  # Remove the last ]
-  if [ "$(tail -1 "${OMAHA_CONF}")" = ']' ]; then
-    sed -i '$d' "${OMAHA_CONF}"
+  efi_hash="$(compress_and_hash_partition "${RELEASE_IMAGE}" 12 "efi.gz")"
+  mv efi.gz "${OMAHA_DATA_DIR}"
+  echo "efi: ${efi_hash}"
+
+  popd >/dev/null
+
+  # Go to retrieve the factory test image.
+  pushd "${FACTORY_DIR}" >/dev/null
+  prepare_dir
+
+  if [ -n "${IMAGE_IS_UNPACKED}" ]; then
+    echo "Unpacking image ${FACTORY_IMAGE} ..." >&2
+    sudo ./unpack_partitions.sh "${FACTORY_IMAGE}" 2>/dev/null
   fi
 
-  # If the file is empty, create it from scratch
-  if [ ! -s "${OMAHA_CONF}" ]; then
+  test_hash="$(compress_and_hash_memento_image "${FACTORY_IMAGE}")"
+  sudo chmod a+rw update.gz
+  mv update.gz rootfs-test.gz
+  mv rootfs-test.gz "${OMAHA_DATA_DIR}"
+  echo "test: ${test_hash}"
+
+  state_hash="$(compress_and_hash_partition "${FACTORY_IMAGE}" 1 "state.gz")"
+  mv state.gz "${OMAHA_DATA_DIR}"
+  echo "state: ${state_hash}"
+
+  popd >/dev/null
+
+  if [ -n "${FLAGS_firmware_updater}" ]; then
+    SHELLBALL="${FLAGS_firmware_updater}"
+    if [ ! -f  "$SHELLBALL" ]; then
+      echo "Failed to find firmware updater: $SHELLBALL."
+      exit 1
+    fi
+
+    firmware_hash="$(compress_and_hash_file "$SHELLBALL" "firmware.gz")"
+    mv firmware.gz "${OMAHA_DATA_DIR}"
+    echo "firmware: ${firmware_hash}"
+  fi
+
+  # If the file does exist and we are using the subfolder flag we are going to
+  # append another config.
+  if [ -n "${FLAGS_subfolder}" ] &&
+     [ -f "${OMAHA_CONF}" ]; then
+    # Remove the ']' from the last line of the file so we can add another config.
+    while  [ -s "${OMAHA_CONF}" ]; do
+      # If the last line is null
+      if [ -z "$(tail -1 "${OMAHA_CONF}")" ]; then
+        sed -i '$d' "${OMAHA_CONF}"
+      elif [ "$(tail -1 "${OMAHA_CONF}")" != ']' ]; then
+        sed -i '$d' "${OMAHA_CONF}"
+      else
+        break
+      fi
+    done
+
+    # Remove the last ]
+    if [ "$(tail -1 "${OMAHA_CONF}")" = ']' ]; then
+      sed -i '$d' "${OMAHA_CONF}"
+    fi
+
+    # If the file is empty, create it from scratch
+    if [ ! -s "${OMAHA_CONF}" ]; then
+      echo "config = [" >"${OMAHA_CONF}"
+    fi
+  else
     echo "config = [" >"${OMAHA_CONF}"
   fi
-else
-  echo "config = [" >"${OMAHA_CONF}"
-fi
 
-if [ -n "${FLAGS_subfolder}" ]; then
-  subfolder="${FLAGS_subfolder}/"
-fi
+  if [ -n "${FLAGS_subfolder}" ]; then
+    subfolder="${FLAGS_subfolder}/"
+  fi
 
-echo -n "{
+  echo -n "{
    'qual_ids': set([\"${FLAGS_board}\"]),
    'factory_image': '${subfolder}rootfs-test.gz',
    'factory_checksum': '${test_hash}',
    'release_image': '${subfolder}rootfs-release.gz',
    'release_checksum': '${release_hash}',
    'oempartitionimg_image': '${subfolder}oem.gz',
    'oempartitionimg_checksum': '${oem_hash}',
    'efipartitionimg_image': '${subfolder}efi.gz',
    'efipartitionimg_checksum': '${efi_hash}',
    'stateimg_image': '${subfolder}state.gz',
    'stateimg_checksum': '${state_hash}'," >>"${OMAHA_CONF}"
 
-if [ -n "${FLAGS_firmware_updater}" ]  ; then
-  echo -n "
+  if [ -n "${FLAGS_firmware_updater}" ]  ; then
+    echo -n "
    'firmware_image': '${subfolder}firmware.gz',
    'firmware_checksum': '${firmware_hash}'," >>"${OMAHA_CONF}"
-fi
+  fi
 
-echo -n "
+  echo -n "
  },
 ]
 " >>"${OMAHA_CONF}"
 
-echo "The miniomaha server lives in src/platform/dev.
+  echo "The miniomaha server lives in src/platform/dev.
 To validate the configutarion, run:
   python2.6 devserver.py --factory_config miniomaha.conf \
   --validate_factory_config
 To run the server:
   python2.6 devserver.py --factory_config miniomaha.conf"
+}
+
+# Main
+if [ -n "$FLAGS_diskimg" ]; then
+  generate_img
+else
+  generate_omaha
+fi