From fdefbf704c2424e2fa6eebe9f87d24330f73b406 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Wed, 18 Dec 2013 13:48:12 -0800
Subject: [PATCH 01/29] add(disk_util): Rename cgpt.py to disk_util.

Use a more generic name so cgpt.py and disk_layout_util.sh can be merged
into one tool. Wrappers around wrappers around wrappers are tedious.
---
 build_library/disk_layout_util.sh    | 2 +-
 build_library/{cgpt.py => disk_util} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename build_library/{cgpt.py => disk_util} (100%)

diff --git a/build_library/disk_layout_util.sh b/build_library/disk_layout_util.sh
index dbbd1a0704..7cd02a5f4e 100644
--- a/build_library/disk_layout_util.sh
+++ b/build_library/disk_layout_util.sh
@@ -2,7 +2,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-CGPT_PY="${BUILD_LIBRARY_DIR}/cgpt.py"
+CGPT_PY="${BUILD_LIBRARY_DIR}/disk_util"
 
 cgpt_py() {
   if [[ -n "${FLAGS_adjust_part-}" ]]; then
diff --git a/build_library/cgpt.py b/build_library/disk_util
similarity index 100%
rename from build_library/cgpt.py
rename to build_library/disk_util

From de9ff4fc8e5a554ca4c17deec151c371a73413eb Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Thu, 19 Dec 2013 16:43:00 -0800
Subject: [PATCH 02/29] fix(disk_util): Rework how argument parsing/passing
 works.

Move from optparse to argparse. Move layout file and layout type to
global options with reasonable default values so every command doesn't
need to them. Adjust calling scripts to match.

For now layout type is being passed via an environment variable
DISK_LAYOUT_TYPE but this is a temporary situation.
---
 bin/cros_make_image_bootable                  |   1 -
 build_library/base_image_util.sh              |  22 +-
 .../create_legacy_bootloader_templates.sh     |   4 +-
 build_library/disk_layout_util.sh             |  61 ++--
 build_library/disk_util                       | 289 +++++++-----------
 build_library/vm_image_util.sh                |  10 +-
 image_to_vm.sh                                |   4 +-
 7 files changed, 153 insertions(+), 238 deletions(-)

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
index 6d33cf1cfd..e27862c367 100755
--- a/bin/cros_make_image_bootable
+++ b/bin/cros_make_image_bootable
@@ -35,7 +35,6 @@ assert_inside_chroot
 . /usr/lib/installer/chromeos-common.sh || exit 1
 . "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
 
 switch_to_strict_mode
 
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 52331b3fab..55fc293c45 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -41,12 +41,10 @@ create_base_image() {
   local rootfs_verification_enabled=$2
 
   get_disk_layout_type
-  local image_type="${DISK_LAYOUT_TYPE}"
-
   check_valid_layout "base"
-  check_valid_layout ${image_type}
+  check_valid_layout "${DISK_LAYOUT_TYPE}"
 
-  info "Using image type ${image_type}"
+  info "Using image type ${DISK_LAYOUT_TYPE}"
 
   root_fs_dir="${BUILD_DIR}/rootfs"
   state_fs_dir="${BUILD_DIR}/state"
@@ -57,25 +55,25 @@ create_base_image() {
   cleanup_mounts &> /dev/null
 
   local root_fs_label="ROOT-A"
-  local root_fs_num=$(get_num ${image_type} ${root_fs_label})
+  local root_fs_num=$(get_num ${root_fs_label})
   local root_fs_img="${BUILD_DIR}/rootfs.image"
-  local root_fs_bytes=$(get_filesystem_size ${image_type} ${root_fs_num})
+  local root_fs_bytes=$(get_filesystem_size ${root_fs_num})
 
   local state_fs_label="STATE"
-  local state_fs_num=$(get_num ${image_type} ${state_fs_label})
+  local state_fs_num=$(get_num ${state_fs_label})
   local state_fs_img="${BUILD_DIR}/state.image"
-  local state_fs_bytes=$(get_filesystem_size ${image_type} ${state_fs_num})
+  local state_fs_bytes=$(get_filesystem_size ${state_fs_num})
   local state_fs_uuid=$(uuidgen)
 
   local esp_fs_label="EFI-SYSTEM"
-  local esp_fs_num=$(get_num ${image_type} ${esp_fs_label})
+  local esp_fs_num=$(get_num ${esp_fs_label})
   local esp_fs_img="${BUILD_DIR}/esp.image"
-  local esp_fs_bytes=$(get_filesystem_size ${image_type} ${esp_fs_num})
+  local esp_fs_bytes=$(get_filesystem_size ${esp_fs_num})
 
   local oem_fs_label="OEM"
-  local oem_fs_num=$(get_num ${image_type} ${oem_fs_label})
+  local oem_fs_num=$(get_num ${oem_fs_label})
   local oem_fs_img="${BUILD_DIR}/oem.image"
-  local oem_fs_bytes=$(get_filesystem_size ${image_type} ${oem_fs_num})
+  local oem_fs_bytes=$(get_filesystem_size ${oem_fs_num})
   local oem_fs_uuid=$(uuidgen)
 
   local fs_block_size=$(get_fs_block_size)
diff --git a/build_library/create_legacy_bootloader_templates.sh b/build_library/create_legacy_bootloader_templates.sh
index c4dd64a08b..f6b6467fa1 100755
--- a/build_library/create_legacy_bootloader_templates.sh
+++ b/build_library/create_legacy_bootloader_templates.sh
@@ -42,8 +42,8 @@ if [[ "${FLAGS_arch}" = "x86" || "${FLAGS_arch}" = "amd64"  ]]; then
   sudo mkdir -p ${FLAGS_to}
 
   # Get partition UUIDs from the json config
-  ROOTA="PARTUUID=$(get_uuid base ROOT-A)"
-  ROOTB="PARTUUID=$(get_uuid base ROOT-B)"
+  ROOTA="PARTUUID=$(get_uuid ROOT-A)"
+  ROOTB="PARTUUID=$(get_uuid ROOT-B)"
 
   # Build configuration files for pygrub/pvgrub
   GRUB_DIR="${FLAGS_to}/grub"
diff --git a/build_library/disk_layout_util.sh b/build_library/disk_layout_util.sh
index 7cd02a5f4e..915f8d3255 100644
--- a/build_library/disk_layout_util.sh
+++ b/build_library/disk_layout_util.sh
@@ -17,13 +17,8 @@ cgpt_py() {
   "${CGPT_PY}" "$@"
 }
 
-get_disk_layout_path() {
-  DISK_LAYOUT_PATH="${BUILD_LIBRARY_DIR}/legacy_disk_layout.json"
-}
-
 write_partition_table() {
-  local image_type=$1
-  local outdev=$2
+  local outdev=$1
 
   local pmbr_img
   case ${ARCH} in
@@ -39,77 +34,59 @@ write_partition_table() {
     ;;
   esac
 
-  get_disk_layout_path
-  cgpt_py write_gpt "${image_type}" "${DISK_LAYOUT_PATH}" "${outdev}"
-  cgpt_py write_mbr \
-      "${image_type}" "${DISK_LAYOUT_PATH}" "${outdev}" "${pmbr_img}"
+  cgpt_py write_gpt "${outdev}"
+  cgpt_py write_mbr "${outdev}" "${pmbr_img}"
 }
 
 get_fs_block_size() {
-  get_disk_layout_path
-
-  cgpt_py readfsblocksize "${DISK_LAYOUT_PATH}"
+  cgpt_py readfsblocksize
 }
 
 get_block_size() {
-  get_disk_layout_path
-
-  cgpt_py readblocksize "${DISK_LAYOUT_PATH}"
+  cgpt_py readblocksize
 }
 
 get_partition_size() {
-  local image_type=$1
-  local part_id=$2
-  get_disk_layout_path
+  local part_id=$1
 
-  cgpt_py readpartsize "${image_type}" "${DISK_LAYOUT_PATH}" ${part_id}
+  cgpt_py readpartsize ${part_id}
 }
 
 get_filesystem_size() {
-  local image_type=$1
-  local part_id=$2
-  get_disk_layout_path
+  local part_id=$1
 
-  cgpt_py readfssize "${image_type}" "${DISK_LAYOUT_PATH}" ${part_id}
+  cgpt_py readfssize ${part_id}
 }
 
 get_label() {
-  local image_type=$1
-  local part_id=$2
-  get_disk_layout_path
+  local part_id=$1
 
-  cgpt_py readlabel "${image_type}" "${DISK_LAYOUT_PATH}" ${part_id}
+  cgpt_py readlabel ${part_id}
 }
 
 get_num() {
-  local image_type=$1
-  local label=$2
-  get_disk_layout_path
+  local label=$1
 
-  cgpt_py readnum "${image_type}" "${DISK_LAYOUT_PATH}" ${label}
+  cgpt_py readnum ${label}
 }
 
 get_uuid() {
-  local image_type=$1
-  local label=$2
-  get_disk_layout_path
+  local label=$1
 
-  cgpt_py readuuid "${image_type}" "${DISK_LAYOUT_PATH}" ${label}
+  cgpt_py readuuid ${label}
 }
 
 check_valid_layout() {
-  local image_type=$1
-  get_disk_layout_path
-
-  cgpt_py parseonly "${image_type}" "${DISK_LAYOUT_PATH}" > /dev/null
+  cgpt_py parseonly > /dev/null
 }
 
 get_disk_layout_type() {
-  DISK_LAYOUT_TYPE="base"
+  DISK_LAYOUT_TYPE="${1:-base}"
   if [[ -n "${FLAGS_disk_layout}" && \
       "${FLAGS_disk_layout}" != "default" ]]; then
     DISK_LAYOUT_TYPE="${FLAGS_disk_layout}"
   fi
+  export DISK_LAYOUT_TYPE
 }
 
 emit_gpt_scripts() {
@@ -180,7 +157,7 @@ build_gpt() {
   local oem_img="$5"
 
   get_disk_layout_type
-  write_partition_table "${DISK_LAYOUT_TYPE}" "${outdev}"
+  write_partition_table "${outdev}"
 
   local sudo=
   if [ ! -w "$outdev" ] ; then
diff --git a/build_library/disk_util b/build_library/disk_util
index 0299730204..6b391e754b 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -3,13 +3,13 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import argparse
 import json
 import os
 import re
 import subprocess
 import sys
 import uuid
-from optparse import OptionParser
 
 # First sector we can use.
 GPT_RESERVED_SECTORS = 34
@@ -24,11 +24,11 @@ class InvalidAdjustment(Exception):
   pass
 
 
-def LoadPartitionConfig(filename):
+def LoadPartitionConfig(options):
   """Loads a partition tables configuration file into a Python object.
 
   Args:
-    filename: Filename to load into object
+    options: Flags passed to the script
   Returns:
     Object containing disk layout configuration
   """
@@ -38,6 +38,7 @@ def LoadPartitionConfig(filename):
       '_comment', 'type', 'num', 'label', 'blocks', 'block_size', 'fs_blocks',
       'fs_block_size', 'features', 'uuid', 'alignment'))
 
+  filename = options.disk_layout_file
   if not os.path.exists(filename):
     raise ConfigNotFound('Partition config %s was not found!' % filename)
   with open(filename) as f:
@@ -99,9 +100,7 @@ def LoadPartitionConfig(filename):
   return config
 
 
-
-
-def GetPartitionTable(options, config, image_type):
+def GetPartitionTable(options, config):
   """Generates requested image_type layout from a layout configuration.
   This loads the base table and then overlays the requested layout over
   the base layout.
@@ -109,13 +108,13 @@ def GetPartitionTable(options, config, image_type):
   Args:
     options: Flags passed to the script
     config: Partition configuration file object
-    image_type: Type of image eg base/test/dev/factory_install
   Returns:
     Object representing a selected partition table
   """
 
   partitions = config['layouts']['base']
   metadata = config['metadata']
+  image_type = options.disk_layout
 
   if image_type != 'base':
     for partition_t in config['layouts'][image_type]:
@@ -198,29 +197,26 @@ def ApplyPartitionAdjustment(partitions, metadata, label, operator, operand):
     partition['bytes'] = partition['blocks'] * metadata['block_size']
 
 
-def GetPartitionTableFromConfig(options, layout_filename, image_type):
+def GetPartitionTableFromConfig(options):
   """Loads a partition table and returns a given partition table type
 
   Args:
     options: Flags passed to the script
-    layout_filename: The filename to load tables from
-    image_type: The type of partition table to return
+  Returns:
+    A list defining all known partitions.
   """
 
-  config = LoadPartitionConfig(layout_filename)
-  partitions = GetPartitionTable(options, config, image_type)
+  config = LoadPartitionConfig(options)
+  partitions = GetPartitionTable(options, config)
 
   return partitions
 
 
-def WritePartitionTable(options, image_type, layout_filename, disk_filename):
+def WritePartitionTable(options):
   """Writes the given partition table to a disk image or device.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    disk_filename: Path to disk image or device file
   """
 
   def Cgpt(*args):
@@ -232,9 +228,8 @@ def WritePartitionTable(options, image_type, layout_filename, disk_filename):
       count += alignment - offset
     return count
 
-  config = LoadPartitionConfig(layout_filename)
-  metadata = config['metadata']
-  partitions = GetPartitionTable(options, config, image_type)
+  config = LoadPartitionConfig(options)
+  partitions = GetPartitionTable(options, config)
   disk_block_count = GPT_RESERVED_SECTORS
 
   for partition in partitions:
@@ -245,7 +240,7 @@ def WritePartitionTable(options, image_type, layout_filename, disk_filename):
   # Sometimes qemu-img expects disks sizes aligned to 64k
   disk_block_count = Align(disk_block_count, config['metadata']['alignment'])
 
-  Cgpt('create', '-c', '-s', disk_block_count, disk_filename)
+  Cgpt('create', '-c', '-s', disk_block_count, options.disk_image)
 
   sector = GPT_RESERVED_SECTORS
   for partition in partitions:
@@ -257,29 +252,24 @@ def WritePartitionTable(options, image_type, layout_filename, disk_filename):
                   '-t', partition['type'],
                   '-l', partition['label'],
                   '-u', partition['uuid'],
-                  disk_filename)
+                  options.disk_image)
 
     sector += partition['blocks']
 
-  Cgpt('show', disk_filename)
+  Cgpt('show', options.disk_image)
 
 
-def WriteMbrBoot(options, image_type, layout_filename,
-                 disk_filename, mbr_filename):
+def WriteMbrBoot(options):
   """Writes the protective MBR with the given boot code.
 
   The EFI System Partition will be marked as the 'boot' partition.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    disk_filename: Path to disk image or device file
-    mbr_filename: Path to boot code, usually gptmbr.bin from syslinux.
   """
 
-  config = LoadPartitionConfig(layout_filename)
-  partitions = GetPartitionTable(options, config, image_type)
+  config = LoadPartitionConfig(options)
+  partitions = GetPartitionTable(options, config)
 
   esp_number = None
   for partition in partitions:
@@ -289,8 +279,8 @@ def WriteMbrBoot(options, image_type, layout_filename,
   if esp_number is None:
     raise InvalidLayout('Table does not include an EFI partition.')
 
-  subprocess.check_call(['cgpt', 'boot', '-p', '-b', mbr_filename,
-      '-i', str(partition['num']), disk_filename])
+  subprocess.check_call(['cgpt', 'boot', '-p', '-b', options.mbr_boot_code,
+      '-i', str(partition['num']), options.disk_image])
 
 
 def GetPartitionByNumber(partitions, num):
@@ -329,142 +319,107 @@ def GetPartitionByLabel(partitions, label):
   raise PartitionNotFound('Partition not found')
 
 
-def GetBlockSize(options, layout_filename):
+def GetBlockSize(options):
   """Returns the partition table block size.
 
   Args:
     options: Flags passed to the script
-    layout_filename: Path to partition configuration file
-  Returns:
+  Prints:
     Block size of all partitions in the layout
   """
 
-  config = LoadPartitionConfig(layout_filename)
-  return config['metadata']['block_size']
+  config = LoadPartitionConfig(options)
+  print config['metadata']['block_size']
 
 
-def GetFilesystemBlockSize(options, layout_filename):
+def GetFilesystemBlockSize(options):
   """Returns the filesystem block size.
 
-  Args:
-    options: Flags passed to the script
-
   This is used for all partitions in the table that have filesystems.
 
   Args:
-    layout_filename: Path to partition configuration file
-  Returns:
+    options: Flags passed to the script
+  Prints:
     Block size of all filesystems in the layout
   """
 
-  config = LoadPartitionConfig(layout_filename)
-  return config['metadata']['fs_block_size']
+  config = LoadPartitionConfig(options)
+  print config['metadata']['fs_block_size']
 
 
-def GetPartitionSize(options, image_type, layout_filename, num):
+def GetPartitionSize(options):
   """Returns the partition size of a given partition for a given layout type.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    num: Number of the partition you want to read from
-  Returns:
+  Prints:
     Size of selected partition in bytes
   """
 
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
-  partition = GetPartitionByNumber(partitions, num)
-
-  return partition['bytes']
+  partitions = GetPartitionTableFromConfig(options)
+  partition = GetPartitionByNumber(partitions, options.partition_num)
+  print partition['bytes']
 
 
-def GetFilesystemSize(options, image_type, layout_filename, num):
+def GetFilesystemSize(options):
   """Returns the filesystem size of a given partition for a given layout type.
 
   If no filesystem size is specified, returns the partition size.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    num: Number of the partition you want to read from
-  Returns:
+  Prints:
     Size of selected partition filesystem in bytes
   """
 
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
-  partition = GetPartitionByNumber(partitions, num)
-
-  if 'fs_bytes' in partition:
-    return partition['fs_bytes']
-  else:
-    return partition['bytes']
+  partitions = GetPartitionTableFromConfig(options)
+  partition = GetPartitionByNumber(partitions, options.partition_num)
+  print partition.get('fs_bytes', partition['bytes'])
 
 
-def GetLabel(options, image_type, layout_filename, num):
+def GetLabel(options):
   """Returns the label for a given partition.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    num: Number of the partition you want to read from
-  Returns:
+  Prints:
     Label of selected partition, or 'UNTITLED' if none specified
   """
 
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
-  partition = GetPartitionByNumber(partitions, num)
-
-  if 'label' in partition:
-    return partition['label']
-  else:
-    return 'UNTITLED'
+  partitions = GetPartitionTableFromConfig(options)
+  partition = GetPartitionByNumber(partitions, options.partition_num)
+  print partition.get('label', 'UNTITLED')
 
 
-def GetNum(options, image_type, layout_filename, label):
+def GetNum(options):
   """Returns the number for a given label.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
-    label: Label of the partition you want to read from
-  Returns:
+  Prints:
     Number of selected partition, or '-1' if there is no number
   """
 
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
-  partition = GetPartitionByLabel(partitions, label)
-
-  if 'num' in partition:
-    return partition['num']
-  else:
-    return '-1'
+  partitions = GetPartitionTableFromConfig(options)
+  partition = GetPartitionByLabel(partitions, options.label)
+  print partition.get('num', '-1')
 
 
-def GetUuid(options, image_type, layout_filename, label):
+def GetUuid(options):
   """Returns the unique partition UUID for a given label.
 
-  Note: Only useful if the UUID is specified in the config file, otherwise
-  the value returned unlikely to be what is actually used in the image.
-
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/prod
-    layout_filename: Path to partition configuration file
-    label: Label of the partition you want to read from
-  Returns:
+  Prints:
     String containing the requested UUID
   """
 
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
-  partition = GetPartitionByLabel(partitions, label)
-  return partition['uuid']
+  partitions = GetPartitionTableFromConfig(options)
+  partition = GetPartitionByLabel(partitions, options.label)
+  print partition.get('uuid', '')
 
 
-def DoDebugOutput(options, image_type, layout_filename):
+def DoDebugOutput(options):
   """Prints out a human readable disk layout in on-disk order.
 
   This will round values larger than 1MB, it's exists to quickly
@@ -472,10 +427,8 @@ def DoDebugOutput(options, image_type, layout_filename):
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
   """
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
+  partitions = GetPartitionTableFromConfig(options)
 
   for partition in partitions:
     if partition['bytes'] < 1024 * 1024:
@@ -495,85 +448,73 @@ def DoDebugOutput(options, image_type, layout_filename):
       print 'blank - %s' %  size
 
 
-def DoParseOnly(options, image_type, layout_filename):
+def DoParseOnly(options):
   """Parses a layout file only, used before reading sizes to check for errors.
 
   Args:
     options: Flags passed to the script
-    image_type: Type of image eg base/test/dev/factory_install
-    layout_filename: Path to partition configuration file
   """
-  partitions = GetPartitionTableFromConfig(options, layout_filename, image_type)
+  GetPartitionTableFromConfig(options)
 
 
 def main(argv):
-  action_map = {
-    'write_gpt': {
-      'usage': ['<image_type>', '<partition_config_file>', '<disk_image>'],
-      'func': WritePartitionTable,
-    },
-    'write_mbr': {
-      'usage': ['<image_type>', '<partition_config_file>', '<disk_image>',
-                '<mbr_boot_code>'],
-      'func': WriteMbrBoot,
-    },
-    'readblocksize': {
-      'usage': ['<partition_config_file>'],
-      'func': GetBlockSize,
-    },
-    'readfsblocksize': {
-      'usage': ['<partition_config_file>'],
-      'func': GetFilesystemBlockSize,
-    },
-    'readpartsize': {
-      'usage': ['<image_type>', '<partition_config_file>', '<partition_num>'],
-      'func': GetPartitionSize,
-    },
-    'readfssize': {
-      'usage': ['<image_type>', '<partition_config_file>', '<partition_num>'],
-      'func': GetFilesystemSize,
-    },
-    'readlabel': {
-      'usage': ['<image_type>', '<partition_config_file>', '<partition_num>'],
-      'func': GetLabel,
-    },
-    'readnum': {
-      'usage': ['<image_type>', '<partition_config_file>', '<label>'],
-      'func': GetNum,
-    },
-    'readuuid': {
-      'usage': ['<image_type>', '<partition_config_file>', '<label>'],
-      'func': GetUuid,
-    },
-    'debug': {
-      'usage': ['<image_type>', '<partition_config_file>'],
-      'func': DoDebugOutput,
-    },
-    'parseonly': {
-      'usage': ['<image_type>', '<partition_config_file>'],
-      'func': DoParseOnly,
-    }
-  }
+  default_layout_file = os.environ.get('DISK_LAYOUT_FILE',
+          os.path.join(os.path.dirname(__file__), 'legacy_disk_layout.json'))
+  default_layout_type = os.environ.get('DISK_LAYOUT_TYPE', 'base')
 
-  parser = OptionParser()
-  parser.add_option("--adjust_part", dest="adjust_part",
-                    help="adjust partition sizes", default="")
-  (options, args) = parser.parse_args()
+  parser = argparse.ArgumentParser(
+          formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+  parser.add_argument('--adjust_part', default='',
+          help='adjust partition sizes')
+  parser.add_argument('--disk_layout_file', default=default_layout_file,
+          help='path to disk layout json file')
+  parser.add_argument('--disk_layout', default=default_layout_type,
+          help='disk layout type from the json file')
+  actions = parser.add_subparsers(title='actions')
 
-  if len(args) < 1 or args[0] not in action_map:
-    print 'Usage: %s <action>\n' % sys.argv[0]
-    print 'Valid actions are:'
-    for action in action_map:
-      print '  %s %s' % (action, ' '.join(action_map[action]['usage']))
-    sys.exit(1)
-  else:
-    action_name = args[0]
-    action = action_map[action_name]
-    if len(action['usage']) == len(args) - 1:
-      print action['func'](options, *args[1:])
-    else:
-      sys.exit('Usage: %s %s %s' % (sys.argv[0], args[0],
-               ' '.join(action['usage'])))
+  a = actions.add_parser('write_gpt', help='write gpt to new image')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.set_defaults(func=WritePartitionTable)
+
+  a = actions.add_parser('write_mbr', help='write mbr to existing image')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.add_argument('mbr_boot_code', help='path to mbr boot block')
+  a.set_defaults(func=WriteMbrBoot)
+
+  a = actions.add_parser('readblocksize', help='get device block size')
+  a.set_defaults(func=GetBlockSize)
+
+  a = actions.add_parser('readfsblocksize', help='get filesystem block size')
+  a.set_defaults(func=GetFilesystemBlockSize)
+
+  a = actions.add_parser('readpartsize', help='get partition size')
+  a.add_argument('partition_num', type=int, help='partition number')
+  a.set_defaults(func=GetPartitionSize)
+
+  a = actions.add_parser('readfssize', help='get filesystem size')
+  a.add_argument('partition_num', type=int, help='partition number')
+  a.set_defaults(func=GetFilesystemSize)
+
+  a = actions.add_parser('readlabel', help='get partition label')
+  a.add_argument('partition_num', type=int, help='partition number')
+  a.set_defaults(func=GetLabel)
+
+  a = actions.add_parser('readnum', help='get partition number')
+  a.add_argument('label', help='partition label')
+  a.set_defaults(func=GetNum)
+
+  a = actions.add_parser('readuuid', help='get partition uuid')
+  a.add_argument('label', help='partition label')
+  a.set_defaults(func=GetUuid)
+
+  a = actions.add_parser('debug', help='dump debug output')
+  a.set_defaults(func=DoDebugOutput)
+
+  a = actions.add_parser('parseonly', help='validate config')
+  a.set_defaults(func=DoParseOnly)
+
+  options = parser.parse_args(argv[1:])
+  options.func(options)
 
 
 if __name__ == '__main__':
diff --git a/build_library/vm_image_util.sh b/build_library/vm_image_util.sh
index 568e5ab402..03d1bd7289 100644
--- a/build_library/vm_image_util.sh
+++ b/build_library/vm_image_util.sh
@@ -199,8 +199,8 @@ _disk_ext() {
 # alternate filesystem image for the state partition instead of the one
 # from VM_SRC_IMG. Start new image using the given disk layout.
 unpack_source_disk() {
-    local disk_layout="${1:-$(_get_vm_opt DISK_LAYOUT)}"
-    local alternate_state_image="$2"
+    get_disk_layout_type $(_get_vm_opt DISK_LAYOUT)
+    local alternate_state_image="$1"
 
     if [[ -n "${alternate_state_image}" && ! -f "${alternate_state_image}" ]]
     then
@@ -229,13 +229,13 @@ unpack_source_disk() {
 
     if [[ $(_get_vm_opt PARTITIONED_IMG) -eq 1 ]]; then
       info "Initializing new partition table..."
-      write_partition_table "${disk_layout}" "${VM_TMP_IMG}"
+      write_partition_table "${VM_TMP_IMG}"
     fi
 }
 
 resize_state_partition() {
-    local disk_layout="${1:-$(_get_vm_opt DISK_LAYOUT)}"
-    local size_in_bytes=$(get_filesystem_size "${disk_layout}" ${NUM_STATEFUL})
+    get_disk_layout_type $(_get_vm_opt DISK_LAYOUT)
+    local size_in_bytes=$(get_filesystem_size ${NUM_STATEFUL})
     local size_in_sectors=$(( size_in_bytes / 512 ))
     local size_in_mb=$(( size_in_bytes / 1024 / 1024 ))
     local original_size=$(stat -c%s "${TEMP_STATE}")
diff --git a/image_to_vm.sh b/image_to_vm.sh
index c6727987b1..1e35812d6b 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -109,8 +109,8 @@ trap vm_cleanup EXIT
 
 # Unpack image, using alternate state image if defined
 # Resize to use all available space in new disk layout
-unpack_source_disk "${FLAGS_disk_layout}" "${FLAGS_state_image}"
-resize_state_partition "${FLAGS_disk_layout}"
+unpack_source_disk "${FLAGS_state_image}"
+resize_state_partition
 
 # Optionally install any OEM packages
 install_oem_package

From cc341f856b78d7f3733be59a5ec2042851cffac2 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Thu, 19 Dec 2013 16:53:14 -0800
Subject: [PATCH 03/29] fix(disk_util): Merge write_mbr into write_gpt

No need for this to be a different command.
---
 build_library/disk_layout_util.sh |  3 +--
 build_library/disk_util           | 40 ++++++++++---------------------
 2 files changed, 14 insertions(+), 29 deletions(-)

diff --git a/build_library/disk_layout_util.sh b/build_library/disk_layout_util.sh
index 915f8d3255..59b869bf39 100644
--- a/build_library/disk_layout_util.sh
+++ b/build_library/disk_layout_util.sh
@@ -34,8 +34,7 @@ write_partition_table() {
     ;;
   esac
 
-  cgpt_py write_gpt "${outdev}"
-  cgpt_py write_mbr "${outdev}" "${pmbr_img}"
+  cgpt_py write_gpt --mbr_boot_code="${pmbr_img}" "${outdev}"
 }
 
 get_fs_block_size() {
diff --git a/build_library/disk_util b/build_library/disk_util
index 6b391e754b..3751a9c70f 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -243,6 +243,7 @@ def WritePartitionTable(options):
   Cgpt('create', '-c', '-s', disk_block_count, options.disk_image)
 
   sector = GPT_RESERVED_SECTORS
+  esp_number = None
   for partition in partitions:
     sector = Align(sector, partition['alignment'])
     if partition['type'] != 'blank':
@@ -254,33 +255,21 @@ def WritePartitionTable(options):
                   '-u', partition['uuid'],
                   options.disk_image)
 
-    sector += partition['blocks']
-
-  Cgpt('show', options.disk_image)
-
-
-def WriteMbrBoot(options):
-  """Writes the protective MBR with the given boot code.
-
-  The EFI System Partition will be marked as the 'boot' partition.
-
-  Args:
-    options: Flags passed to the script
-  """
-
-  config = LoadPartitionConfig(options)
-  partitions = GetPartitionTable(options, config)
-
-  esp_number = None
-  for partition in partitions:
     if partition['type'] == 'efi':
       esp_number = partition['num']
-      break
+
+    sector += partition['blocks']
+
   if esp_number is None:
     raise InvalidLayout('Table does not include an EFI partition.')
 
-  subprocess.check_call(['cgpt', 'boot', '-p', '-b', options.mbr_boot_code,
-      '-i', str(partition['num']), options.disk_image])
+  if options.mbr_boot_code:
+    Cgpt('boot', '-p',
+                 '-b', options.mbr_boot_code,
+                 '-i', esp_number,
+                 options.disk_image)
+
+  Cgpt('show', options.disk_image)
 
 
 def GetPartitionByNumber(partitions, num):
@@ -473,14 +462,11 @@ def main(argv):
   actions = parser.add_subparsers(title='actions')
 
   a = actions.add_parser('write_gpt', help='write gpt to new image')
+  a.add_argument('--mbr_boot_code',
+          help='path to mbr boot block, such as syslinux/gptmbr.bin')
   a.add_argument('disk_image', help='path to disk image file')
   a.set_defaults(func=WritePartitionTable)
 
-  a = actions.add_parser('write_mbr', help='write mbr to existing image')
-  a.add_argument('disk_image', help='path to disk image file')
-  a.add_argument('mbr_boot_code', help='path to mbr boot block')
-  a.set_defaults(func=WriteMbrBoot)
-
   a = actions.add_parser('readblocksize', help='get device block size')
   a.set_defaults(func=GetBlockSize)
 

From 576c8996f49dd1e98ca42843c2ab1f8888e99991 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Thu, 19 Dec 2013 18:25:11 -0800
Subject: [PATCH 04/29] fix(disk_util): Remove support for --adjust_part

This isn't a feature we've been using as far as I know and if someone
needs a custom partition layout it's probably better to just add it to
the json file. Removing this avoids some complexity.
---
 bin/cros_make_image_bootable      |  2 -
 build_image                       |  2 -
 build_library/base_image_util.sh  |  2 +-
 build_library/disk_layout_util.sh |  9 ----
 build_library/disk_util           | 72 -------------------------------
 image_to_vm.sh                    |  2 -
 6 files changed, 1 insertion(+), 88 deletions(-)

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
index e27862c367..182a5f8248 100755
--- a/bin/cros_make_image_bootable
+++ b/bin/cros_make_image_bootable
@@ -71,8 +71,6 @@ locate_gpt
 set +e
 
 # Now parse the build settings from ${OUTPUT_DIR}/boot.desc
-DEFINE_string adjust_part "" \
-  "Adjustments to apply to the partition table"
 DEFINE_string board "${DEFAULT_BOARD}" \
   "Board we're building for."
 DEFINE_string output_dir "/tmp" \
diff --git a/build_image b/build_image
index e28fa96635..2c042688d7 100755
--- a/build_image
+++ b/build_image
@@ -13,8 +13,6 @@ SCRIPT_ROOT=$(dirname $(readlink -f "$0"))
 . "${SCRIPT_ROOT}/build_library/build_common.sh" || exit 1
 
 # Developer-visible flags.
-DEFINE_string adjust_part "" \
-  "Adjustments to apply to the partition table"
 DEFINE_string board "${DEFAULT_BOARD}" \
   "The board to build an image for."
 DEFINE_string boot_args "" \
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 55fc293c45..9844c86032 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -215,7 +215,7 @@ create_base_image() {
   emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
 
   ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-    ${image_name} --adjust_part="${FLAGS_adjust_part}"
+    "${image_name}"
 
   trap - EXIT
 }
diff --git a/build_library/disk_layout_util.sh b/build_library/disk_layout_util.sh
index 59b869bf39..e89cbf33e4 100644
--- a/build_library/disk_layout_util.sh
+++ b/build_library/disk_layout_util.sh
@@ -5,15 +5,6 @@
 CGPT_PY="${BUILD_LIBRARY_DIR}/disk_util"
 
 cgpt_py() {
-  if [[ -n "${FLAGS_adjust_part-}" ]]; then
-    set -- --adjust_part "${FLAGS_adjust_part}" "$@"
-    if [[ ! -t 0 ]]; then
-      warn "The --adjust_part flag was passed." \
-           "This option must ONLY be used interactively. If" \
-           "you need to pass a size from another script, you're" \
-           "doing it wrong and should be using a disk layout type."
-    fi
-  fi
   "${CGPT_PY}" "$@"
 }
 
diff --git a/build_library/disk_util b/build_library/disk_util
index 3751a9c70f..dc8e3ce520 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -6,7 +6,6 @@
 import argparse
 import json
 import os
-import re
 import subprocess
 import sys
 import uuid
@@ -125,78 +124,9 @@ def GetPartitionTable(options, config):
           for k, v in partition_t.items():
             partition[k] = v
 
-  for adjustment_str in options.adjust_part.split():
-    adjustment = adjustment_str.split(':')
-    if len(adjustment) < 2:
-      raise InvalidAdjustment('Adjustment specified was incomplete')
-
-    label = adjustment[0]
-    operator = adjustment[1][0]
-    operand = adjustment[1][1:]
-    ApplyPartitionAdjustment(partitions, metadata, label, operator, operand)
-
   return partitions
 
 
-def ApplyPartitionAdjustment(partitions, metadata, label, operator, operand):
-  """Applies an adjustment to a partition specified by label
-
-  Args:
-    partitions: Partition table to modify
-    metadata: Partition table metadata
-    label: The label of the partition to adjust
-    operator: Type of adjustment (+/-/=)
-    operand: How much to adjust by
-  """
-
-  partition = GetPartitionByLabel(partitions, label)
-
-  operand_digits = re.sub('\D', '', operand)
-  size_factor = block_factor = 1
-  suffix = operand[len(operand_digits):]
-  if suffix:
-    size_factors = { 'B': 0, 'K': 1, 'M': 2, 'G': 3, 'T': 4, }
-    try:
-      size_factor = size_factors[suffix[0].upper()]
-    except KeyError:
-      raise InvalidAdjustment('Unknown size type %s' % suffix)
-    if size_factor == 0 and len(suffix) > 1:
-      raise InvalidAdjustment('Unknown size type %s' % suffix)
-    block_factors = { '': 1024, 'B': 1000, 'IB': 1024, }
-    try:
-      block_factor = block_factors[suffix[1:].upper()]
-    except KeyError:
-      raise InvalidAdjustment('Unknown size type %s' % suffix)
-
-  operand_bytes = int(operand_digits) * pow(block_factor, size_factor)
-
-  if operand_bytes % metadata['block_size'] == 0:
-    operand_blocks = operand_bytes / metadata['block_size']
-  else:
-    raise InvalidAdjustment('Adjustment size not divisible by block size')
-
-  if operator == '+':
-    partition['blocks'] += operand_blocks
-    partition['bytes'] += operand_bytes
-  elif operator == '-':
-    partition['blocks'] -= operand_blocks
-    partition['bytes'] -= operand_bytes
-  elif operator == '=':
-    partition['blocks'] = operand_blocks
-    partition['bytes'] = operand_bytes
-  else:
-    raise ValueError('unknown operator %s' % operator)
-
-  if partition['type'] == 'rootfs':
-    # If we're adjusting a rootFS partition, we assume the full partition size
-    # specified is being used for the filesytem, minus the space reserved for
-    # the hashpad.
-    partition['fs_bytes'] = partition['bytes']
-    partition['fs_blocks'] = partition['fs_bytes'] / metadata['fs_block_size']
-    partition['blocks'] = int(partition['blocks'] * 1.15)
-    partition['bytes'] = partition['blocks'] * metadata['block_size']
-
-
 def GetPartitionTableFromConfig(options):
   """Loads a partition table and returns a given partition table type
 
@@ -453,8 +383,6 @@ def main(argv):
 
   parser = argparse.ArgumentParser(
           formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-  parser.add_argument('--adjust_part', default='',
-          help='adjust partition sizes')
   parser.add_argument('--disk_layout_file', default=default_layout_file,
           help='path to disk layout json file')
   parser.add_argument('--disk_layout', default=default_layout_type,
diff --git a/image_to_vm.sh b/image_to_vm.sh
index 1e35812d6b..149b791d79 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -26,8 +26,6 @@ assert_inside_chroot
 . "${SCRIPT_ROOT}/lib/cros_vm_constants.sh" || exit 1
 
 # Flags
-DEFINE_string adjust_part "" \
-  "Adjustments to apply to the partition table"
 DEFINE_string board "${DEFAULT_BOARD}" \
   "Board for which the image was built"
 

From 0f4b52134ab6f18428791b7e72ba3ebffa200330 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 20 Dec 2013 12:00:01 -0800
Subject: [PATCH 05/29] fix(disk_util): Convert partition list to an object.

Hey, 'num' is a primary key! Lets use it and avoid pointless looping.
---
 build_library/disk_util               | 67 ++++++++++++---------------
 build_library/legacy_disk_layout.json | 45 +++++++-----------
 2 files changed, 47 insertions(+), 65 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index dc8e3ce520..1a036550da 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -60,17 +60,20 @@ def LoadPartitionConfig(options):
     if len(config['layouts']) <= 0:
       raise InvalidLayout('Missing "layouts" entries')
 
-    for layout_name, layout in config['layouts'].items():
-      for part in layout:
+    for layout_name, layout in config['layouts'].iteritems():
+      for part_num, part in layout.iteritems():
         unknown_keys = set(part.keys()) - valid_layout_keys
         if unknown_keys:
           raise InvalidLayout('Unknown items in layout %s: %r' %
                               (layout_name, unknown_keys))
 
-        if part['type'] != 'blank':
-          for s in ('num', 'label'):
-            if not s in part:
-              raise InvalidLayout('Layout "%s" missing "%s"' % (layout_name, s))
+        part['num'] = int(part_num)
+        if part['type'] == 'blank':
+          continue
+
+        if not part.get('label', None):
+          raise InvalidLayout('Layout "%s" missing "label" in partition %s' %
+                              (layout_name, part_num))
 
         part['alignment'] = int(part.get('alignment', metadata['alignment']))
         part['blocks'] = int(part['blocks'])
@@ -111,18 +114,9 @@ def GetPartitionTable(options, config):
     Object representing a selected partition table
   """
 
-  partitions = config['layouts']['base']
-  metadata = config['metadata']
-  image_type = options.disk_layout
-
-  if image_type != 'base':
-    for partition_t in config['layouts'][image_type]:
-      for partition in partitions:
-        if partition['type'] == 'blank' or partition_t['type'] == 'blank':
-          continue
-        if partition_t['num'] == partition['num']:
-          for k, v in partition_t.items():
-            partition[k] = v
+  partitions = config['layouts']['base'].copy()
+  for part_num, part in config['layouts'][options.disk_layout].iteritems():
+    partitions[part_num].update(part)
 
   return partitions
 
@@ -174,7 +168,7 @@ def WritePartitionTable(options):
 
   sector = GPT_RESERVED_SECTORS
   esp_number = None
-  for partition in partitions:
+  for partition in partitions.itervalues():
     sector = Align(sector, partition['alignment'])
     if partition['type'] != 'blank':
       Cgpt('add', '-i', partition['num'],
@@ -211,13 +205,12 @@ def GetPartitionByNumber(partitions, num):
   Returns:
     An object for the selected partition
   """
-  for partition in partitions:
-    if partition['type'] == 'blank':
-      continue
-    if partition['num'] == int(num):
-      return partition
 
-  raise PartitionNotFound('Partition not found')
+  partition = partitions.get(str(num), None)
+  if not partition or partition['type'] == 'blank':
+    raise PartitionNotFound('Partition not found')
+
+  return partition
 
 
 def GetPartitionByLabel(partitions, label):
@@ -229,10 +222,10 @@ def GetPartitionByLabel(partitions, label):
   Returns:
     An object for the selected partition
   """
-  for partition in partitions:
-    if 'label' not in partition:
+  for partition in partitions.itervalues():
+    if partition['type'] == 'blank':
       continue
-    if partition['label'] == label:
+    elif partition['label'] == label:
       return partition
 
   raise PartitionNotFound('Partition not found')
@@ -349,22 +342,22 @@ def DoDebugOutput(options):
   """
   partitions = GetPartitionTableFromConfig(options)
 
-  for partition in partitions:
-    if partition['bytes'] < 1024 * 1024:
-      size = '%d bytes' % partition['bytes']
-    else:
-      size = '%d MB' % (partition['bytes'] / 1024 / 1024)
-    if 'label' in partition:
+  for num, partition in sorted(partitions.iteritems()):
+    if partition['type'] != 'blank':
+      if partition['bytes'] < 1024 * 1024:
+        size = '%d bytes' % partition['bytes']
+      else:
+        size = '%d MB' % (partition['bytes'] / 1024 / 1024)
       if 'fs_bytes' in partition:
         if partition['fs_bytes'] < 1024 * 1024:
           fs_size = '%d bytes' % partition['fs_bytes']
         else:
           fs_size = '%d MB' % (partition['fs_bytes'] / 1024 / 1024)
-        print '%s - %s/%s' % (partition['label'], fs_size, size)
+        print '%s: %s - %s/%s' % (num, partition['label'], fs_size, size)
       else:
-        print '%s - %s' % (partition['label'], size)
+        print '%s: %s - %s' % (num, partition['label'], size)
     else:
-      print 'blank - %s' %  size
+      print '%s: blank' % num
 
 
 def DoParseOnly(options):
diff --git a/build_library/legacy_disk_layout.json b/build_library/legacy_disk_layout.json
index 183de0332f..87395e2adf 100644
--- a/build_library/legacy_disk_layout.json
+++ b/build_library/legacy_disk_layout.json
@@ -6,82 +6,71 @@
     "fs_block_size": 4096
   },
   "layouts":{
-    "base":[
-      {
-        "num": 1,
+    "base":{
+      "1":{
         "label":"EFI-SYSTEM",
         "type":"efi",
         "blocks":"262144"
       },
-      {
-        "num": 2,
+      "2":{
         "label":"BOOT-B",
         "type":"coreos-reserved",
         "blocks":"131072"
       },
-      {
-        "num": 3,
+      "3":{
         "label":"ROOT-A",
         "uuid":"7130c94a-213a-4e5a-8e26-6cce9662f132",
         "type":"coreos-rootfs",
         "blocks":"2097152",
         "fs_blocks":"262144"
       },
-      {
-        "num": 4,
+      "4":{
         "label":"ROOT-B",
         "uuid":"e03dd35c-7c2d-4a47-b3fe-27f15780a57c",
         "type":"coreos-rootfs",
         "blocks":"2097152",
         "fs_blocks":"262144"
       },
-      {
-        "num": 5,
+      "5":{
         "label":"ROOT-C",
         "uuid":"d82521b4-07ac-4f1c-8840-ddefedc332f3",
         "type":"blank",
         "blocks":"0"
       },
-      {
-        "num": 6,
+      "6":{
         "label":"OEM",
         "type":"data",
         "blocks":"262144"
       },
-      {
-        "num": 7,
+      "7":{
         "type":"blank",
         "label":"coreos-reserved",
         "blocks":"0"
       },
-      {
-        "num": 8,
+      "8":{
         "type":"blank",
         "label":"coreos-reserved",
         "blocks":"0"
       },
-      {
-        "num": 9,
+      "9":{
         "label":"STATE",
         "type":"data",
         "blocks":"1048576"
       }
-    ],
-    "vm": [
-      {
-        "num": 9,
+    },
+    "vm":{
+      "9":{
         "label":"STATE",
         "type":"data",
         "blocks":"6291456"
       }
-    ],
-    "vagrant": [
-      {
-        "num": 9,
+    },
+    "vagrant":{
+      "9":{
         "label":"STATE",
         "type":"data",
         "blocks":"33587200"
       }
-    ]
+    }
   }
 }

From ab233534485076fb0d249f404e0c89bfc08a20b0 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Thu, 19 Dec 2013 17:46:09 -0800
Subject: [PATCH 06/29] fix(disk_util): Rework config parsing.

Merge GetPartitionTable and partition alignment from WritePartitionTable
into LoadPartitionConfig so that all this config manipulation code is in
one place and inheritance from the 'base' layout is more predictable.
---
 build_library/disk_util | 201 +++++++++++++++++++++-------------------
 1 file changed, 108 insertions(+), 93 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 1a036550da..510c04bff0 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -36,6 +36,9 @@ def LoadPartitionConfig(options):
   valid_layout_keys = set((
       '_comment', 'type', 'num', 'label', 'blocks', 'block_size', 'fs_blocks',
       'fs_block_size', 'features', 'uuid', 'alignment'))
+  integer_layout_keys = set((
+      'blocks', 'block_size', 'fs_blocks', 'fs_block_size', 'alignment'))
+  required_layout_keys = set(('type', 'num', 'label', 'blocks'))
 
   filename = options.disk_layout_file
   if not os.path.exists(filename):
@@ -43,82 +46,116 @@ def LoadPartitionConfig(options):
   with open(filename) as f:
     config = json.load(f)
 
+  unknown_keys = set(config.keys()) - valid_keys
+  if unknown_keys:
+    raise InvalidLayout('Unknown items: %s' % ' '.join(unknown_keys))
+
   try:
     metadata = config['metadata']
+    base = config['layouts']['base']
     for key in ('alignment', 'block_size', 'fs_block_size'):
       metadata[key] = int(metadata[key])
-
-    # Sometimes qemu-img expects disks sizes aligned to 64k
-    align_bytes = metadata['alignment'] * metadata['block_size']
-    if align_bytes < 65536 or align_bytes % 65536 != 0:
-      raise InvalidLayout('Invalid alignment, 64KB or better required')
-
-    unknown_keys = set(config.keys()) - valid_keys
-    if unknown_keys:
-      raise InvalidLayout('Unknown items: %r' % unknown_keys)
-
-    if len(config['layouts']) <= 0:
-      raise InvalidLayout('Missing "layouts" entries')
-
-    for layout_name, layout in config['layouts'].iteritems():
-      for part_num, part in layout.iteritems():
-        unknown_keys = set(part.keys()) - valid_layout_keys
-        if unknown_keys:
-          raise InvalidLayout('Unknown items in layout %s: %r' %
-                              (layout_name, unknown_keys))
-
-        part['num'] = int(part_num)
-        if part['type'] == 'blank':
-          continue
-
-        if not part.get('label', None):
-          raise InvalidLayout('Layout "%s" missing "label" in partition %s' %
-                              (layout_name, part_num))
-
-        part['alignment'] = int(part.get('alignment', metadata['alignment']))
-        part['blocks'] = int(part['blocks'])
-        part['bytes'] = part['blocks'] * metadata['block_size']
-
-        if 'fs_blocks' in part:
-          part['fs_blocks'] = int(part['fs_blocks'])
-          part['fs_bytes'] = part['fs_blocks'] * metadata['fs_block_size']
-
-          if part['fs_bytes'] > part['bytes']:
-            raise InvalidLayout(
-                'Filesystem may not be larger than partition: %s %s: %d > %d' %
-                (layout_name, part['label'], part['fs_bytes'], part['bytes']))
-
-        if 'uuid' in part:
-          try:
-            # double check the string formatting
-            part['uuid'] = str(uuid.UUID(part['uuid']))
-          except ValueError as e:
-            raise InvalidLayout('Invalid uuid %r: %s' % (part['uuid'], e))
-        else:
-          part['uuid'] = str(uuid.uuid4())
   except KeyError as e:
-    raise InvalidLayout('Layout is missing required entries: %s' % e)
+    raise InvalidLayout('Metadata is missing required entries: %s' % e)
 
-  return config
+  # Sometimes qemu-img expects disks sizes aligned to 64k
+  align_bytes = metadata['alignment'] * metadata['block_size']
+  if align_bytes < 65536 or align_bytes % 65536 != 0:
+    raise InvalidLayout('Invalid alignment, 64KB or better required')
 
 
-def GetPartitionTable(options, config):
-  """Generates requested image_type layout from a layout configuration.
-  This loads the base table and then overlays the requested layout over
-  the base layout.
+  def VerifyLayout(layout_name, layout, base=None):
+    for part_num, part in layout.iteritems():
+      part['num'] = int(part_num)
+      part_keys = set(part.iterkeys())
+      unknown_keys = part_keys - valid_layout_keys
+      if unknown_keys:
+        raise InvalidLayout('Unknown items in partition %s %s: %r' %
+                            (layout_name, part_num, ' '.join(unknown_keys)))
 
-  Args:
-    options: Flags passed to the script
-    config: Partition configuration file object
-  Returns:
-    Object representing a selected partition table
-  """
+      for int_key in integer_layout_keys.intersection(part_keys):
+        part[int_key] = int(part[int_key])
 
-  partitions = config['layouts']['base'].copy()
-  for part_num, part in config['layouts'][options.disk_layout].iteritems():
-    partitions[part_num].update(part)
+      if part.get('type', None) == 'blank':
+        continue
 
-  return partitions
+      if base:
+        part_keys.update(base.iterkeys())
+
+      missing_keys = required_layout_keys - part_keys
+      if missing_keys:
+        raise InvalidLayout('Missing items in partition %s %s: %s' %
+                            (layout_name, part_num, ' '.join(missing_keys)))
+
+      if 'uuid' in part:
+        try:
+          # double check the string formatting
+          part['uuid'] = str(uuid.UUID(part['uuid']))
+        except ValueError as e:
+          raise InvalidLayout('Invalid uuid %r: %s' % (part['uuid'], e))
+
+
+  def Align(count, alignment):
+    offset = count % alignment
+    if offset:
+      count += alignment - offset
+    return count
+
+
+  def FillExtraValues(layout_name, layout, base=None):
+    # Reserved size for first GPT
+    disk_block_count = GPT_RESERVED_SECTORS
+
+    # Fill in default values from base,
+    # dict doesn't have a update()+setdefault() method so this looks tedious
+    if base:
+      for part_num, base_part in base.iteritems():
+        part = layout.setdefault(part_num, {})
+        for base_key, base_value in base_part.iteritems():
+          part.setdefault(base_key, base_value)
+
+    for part_num, part in layout.iteritems():
+      if part['type'] == 'blank':
+        continue
+
+      part.setdefault('alignment', metadata['alignment'])
+      part['bytes'] = part['blocks'] * metadata['block_size']
+      part.setdefault('fs_block_size', metadata['fs_block_size'])
+      part.setdefault('fs_blocks', part['bytes'] // part['fs_block_size'])
+      part['fs_bytes'] = part['fs_blocks'] * part['fs_block_size']
+
+      if part['fs_bytes'] > part['bytes']:
+        raise InvalidLayout(
+            'Filesystem may not be larger than partition: %s %s: %d > %d' %
+            (layout_name, part_num, part['fs_bytes'], part['bytes']))
+
+      disk_block_count = Align(disk_block_count, part['alignment'])
+      part['first_block'] = disk_block_count
+      disk_block_count += part['blocks']
+
+      part.setdefault('uuid', str(uuid.uuid4()))
+
+    # Reserved size for second GPT plus align disk image size
+    disk_block_count += GPT_RESERVED_SECTORS
+    disk_block_count = Align(disk_block_count, metadata['alignment'])
+
+    # If this is the requested layout stash the disk size into the global
+    # metadata. Kinda odd but the best place I've got with this data structure.
+    if layout_name == options.disk_layout:
+      metadata['blocks'] = disk_block_count
+
+
+  # Verify 'base' before other layouts because it is inherited by the others
+  # Fill in extra/default values in base last so they aren't inherited
+  VerifyLayout('base', base)
+  for layout_name, layout in config['layouts'].iteritems():
+    if layout_name == 'base':
+      continue
+    VerifyLayout(layout_name, layout, base)
+    FillExtraValues(layout_name, layout, base)
+  FillExtraValues('base', base)
+
+  return config, config['layouts'][options.disk_layout]
 
 
 def GetPartitionTableFromConfig(options):
@@ -130,9 +167,7 @@ def GetPartitionTableFromConfig(options):
     A list defining all known partitions.
   """
 
-  config = LoadPartitionConfig(options)
-  partitions = GetPartitionTable(options, config)
-
+  config, partitions = LoadPartitionConfig(options)
   return partitions
 
 
@@ -146,33 +181,15 @@ def WritePartitionTable(options):
   def Cgpt(*args):
     subprocess.check_call(['cgpt'] + [str(a) for a in args])
 
-  def Align(count, alignment):
-    offset = count % alignment
-    if offset:
-      count += alignment - offset
-    return count
+  config, partitions = LoadPartitionConfig(options)
 
-  config = LoadPartitionConfig(options)
-  partitions = GetPartitionTable(options, config)
-  disk_block_count = GPT_RESERVED_SECTORS
+  Cgpt('create', '-c', '-s', config['metadata']['blocks'], options.disk_image)
 
-  for partition in partitions:
-    disk_block_count = Align(disk_block_count, partition['alignment'])
-    disk_block_count += partition['blocks']
-
-  disk_block_count += GPT_RESERVED_SECTORS
-  # Sometimes qemu-img expects disks sizes aligned to 64k
-  disk_block_count = Align(disk_block_count, config['metadata']['alignment'])
-
-  Cgpt('create', '-c', '-s', disk_block_count, options.disk_image)
-
-  sector = GPT_RESERVED_SECTORS
   esp_number = None
   for partition in partitions.itervalues():
-    sector = Align(sector, partition['alignment'])
     if partition['type'] != 'blank':
       Cgpt('add', '-i', partition['num'],
-                  '-b', sector,
+                  '-b', partition['first_block'],
                   '-s', partition['blocks'],
                   '-t', partition['type'],
                   '-l', partition['label'],
@@ -182,8 +199,6 @@ def WritePartitionTable(options):
     if partition['type'] == 'efi':
       esp_number = partition['num']
 
-    sector += partition['blocks']
-
   if esp_number is None:
     raise InvalidLayout('Table does not include an EFI partition.')
 
@@ -240,7 +255,7 @@ def GetBlockSize(options):
     Block size of all partitions in the layout
   """
 
-  config = LoadPartitionConfig(options)
+  config, partitions = LoadPartitionConfig(options)
   print config['metadata']['block_size']
 
 
@@ -255,7 +270,7 @@ def GetFilesystemBlockSize(options):
     Block size of all filesystems in the layout
   """
 
-  config = LoadPartitionConfig(options)
+  config, partitions = LoadPartitionConfig(options)
   print config['metadata']['fs_block_size']
 
 

From ba45152b4b8305f409ad8426783e24e232de8032 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 20 Dec 2013 22:03:44 -0800
Subject: [PATCH 07/29] feat(disk_util): Add 'format' command to create
 filesystems in an image.

This will replace the less flexible code in base_image_util.sh
---
 build_library/disk_util               | 122 +++++++++++++++++++++++++-
 build_library/legacy_disk_layout.json |  12 ++-
 2 files changed, 127 insertions(+), 7 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 510c04bff0..c0aa1fc84f 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -35,7 +35,7 @@ def LoadPartitionConfig(options):
   valid_keys = set(('_comment', 'metadata', 'layouts'))
   valid_layout_keys = set((
       '_comment', 'type', 'num', 'label', 'blocks', 'block_size', 'fs_blocks',
-      'fs_block_size', 'features', 'uuid', 'alignment'))
+      'fs_block_size', 'fs_type', 'features', 'uuid', 'alignment'))
   integer_layout_keys = set((
       'blocks', 'block_size', 'fs_blocks', 'fs_block_size', 'alignment'))
   required_layout_keys = set(('type', 'num', 'label', 'blocks'))
@@ -94,6 +94,10 @@ def LoadPartitionConfig(options):
         except ValueError as e:
           raise InvalidLayout('Invalid uuid %r: %s' % (part['uuid'], e))
 
+      if 'fs_type' in part:
+        if part['fs_type'] not in ('ext2', 'ext4', 'vfat'):
+          raise InvalidLayout('Invalid fs_type: %r' % part['fs_type'])
+
 
   def Align(count, alignment):
     offset = count % alignment
@@ -131,6 +135,7 @@ def LoadPartitionConfig(options):
 
       disk_block_count = Align(disk_block_count, part['alignment'])
       part['first_block'] = disk_block_count
+      part['first_byte'] = disk_block_count * metadata['block_size']
       disk_block_count += part['blocks']
 
       part.setdefault('uuid', str(uuid.uuid4()))
@@ -171,17 +176,20 @@ def GetPartitionTableFromConfig(options):
   return partitions
 
 
-def WritePartitionTable(options):
+def WritePartitionTable(options, config=None, partitions=None):
   """Writes the given partition table to a disk image or device.
 
   Args:
     options: Flags passed to the script
+    config: Complete layout configuration file object
+    partitions: Selected layout configuration object
   """
 
   def Cgpt(*args):
     subprocess.check_call(['cgpt'] + [str(a) for a in args])
 
-  config, partitions = LoadPartitionConfig(options)
+  if not (config and partitions):
+    config, partitions = LoadPartitionConfig(options)
 
   Cgpt('create', '-c', '-s', config['metadata']['blocks'], options.disk_image)
 
@@ -211,6 +219,108 @@ def WritePartitionTable(options):
   Cgpt('show', options.disk_image)
 
 
+def Sudo(cmd, stdout_null=False):
+  """Little wrapper around sudo with support for redirecting to /dev/null
+
+  Some tools like tune2fs don't have a quiet mode which just adds
+  useless noise to our build output, drowning out what may be more
+  interesting news.
+
+  Args:
+    cmd: a command and arguments to run.
+    stdout_null: bool to enable redirecting stdout to /dev/null.
+  """
+
+  null = None
+  if stdout_null:
+    null = open('/dev/null', 'w')
+
+  try:
+    subprocess.check_call(['sudo'] + [str(c) for c in cmd], stdout=null)
+  finally:
+    if null:
+      null.close()
+
+
+def FormatExt(part, device):
+  """Format an ext2 or ext4 filesystem.
+
+  Args:
+    part: dict defining the partition
+    device: name of the block device to format
+  """
+  Sudo(['mke2fs', '-q',
+                  '-t', part['fs_type'],
+                  '-b', part['fs_block_size'],
+                  device,
+                  part['fs_blocks']])
+
+  # TODO(marineam): Make more of these fs options configurable.
+  Sudo(['tune2fs', '-L', part['label'],
+                   '-U', 'clear',
+                   '-T', '20091119110000',
+                   '-c', '0', '-i', '0', # Disable auto fsck
+                   '-m', '0', '-r', '0', # Disable reserve blocks
+                   '-e', 'remount-ro',
+                   device],
+                   stdout_null=True)
+
+
+def FormatFat(part, device):
+  """Format a FAT filesystem.
+
+  Args:
+    part: dict defining the partition
+    device: name of the block device to format
+  """
+  # The block-count argument to mkfs.vfat is in units of 1k
+  vfat_block_size = 1024
+  vfat_blocks = part['bytes'] // vfat_block_size
+
+  Sudo(['mkfs.vfat', '-n', part['label'],
+                     device,
+                     vfat_blocks],
+                     stdout_null=True)
+
+
+def Format(options):
+  """Writes the given partition table and initialize fresh filesystems.
+
+  Args:
+    options: Flags passed to the script
+  """
+
+  # Note on using sudo: We don't really need to do this stuff as root
+  # but mke2fs and friends doesn't have an option to make filesystems at
+  # arbitrary offsets but using loop devices makes that possible.
+
+  config, partitions = LoadPartitionConfig(options)
+  WritePartitionTable(options, config, partitions)
+
+  for part in partitions.itervalues():
+    if 'fs_type' not in part:
+      continue
+
+    print "Formatting partition %s (%s) as %s" % (
+            part['num'], part['label'], part['fs_type'])
+
+    loop_dev = subprocess.check_output(['sudo', 'losetup',
+        '--offset', str(part['first_byte']),
+        '--sizelimit', str(part['bytes']),
+        '--find', '--show', options.disk_image])
+    loop_dev = loop_dev.strip()
+
+    try:
+      if part['fs_type'] in ('ext2', 'ext4'):
+        FormatExt(part, loop_dev)
+      elif part['fs_type'] == 'vfat':
+        FormatFat(part, loop_dev)
+      else:
+        raise Exception("Unhandled fs type %s" % part['fs_type'])
+    finally:
+      Sudo(['losetup', '--detach', loop_dev])
+
+
 def GetPartitionByNumber(partitions, num):
   """Given a partition table and number returns the partition object.
 
@@ -403,6 +513,12 @@ def main(argv):
   a.add_argument('disk_image', help='path to disk image file')
   a.set_defaults(func=WritePartitionTable)
 
+  a = actions.add_parser('format', help='write gpt and filesystems to image')
+  a.add_argument('--mbr_boot_code',
+          help='path to mbr boot block, such as syslinux/gptmbr.bin')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.set_defaults(func=Format)
+
   a = actions.add_parser('readblocksize', help='get device block size')
   a.set_defaults(func=GetBlockSize)
 
diff --git a/build_library/legacy_disk_layout.json b/build_library/legacy_disk_layout.json
index 87395e2adf..b427d0c65d 100644
--- a/build_library/legacy_disk_layout.json
+++ b/build_library/legacy_disk_layout.json
@@ -10,7 +10,8 @@
       "1":{
         "label":"EFI-SYSTEM",
         "type":"efi",
-        "blocks":"262144"
+        "blocks":"262144",
+        "fs_type":"vfat"
       },
       "2":{
         "label":"BOOT-B",
@@ -22,7 +23,8 @@
         "uuid":"7130c94a-213a-4e5a-8e26-6cce9662f132",
         "type":"coreos-rootfs",
         "blocks":"2097152",
-        "fs_blocks":"262144"
+        "fs_blocks":"262144",
+        "fs_type":"ext2"
       },
       "4":{
         "label":"ROOT-B",
@@ -40,7 +42,8 @@
       "6":{
         "label":"OEM",
         "type":"data",
-        "blocks":"262144"
+        "blocks":"262144",
+        "fs_type":"ext4"
       },
       "7":{
         "type":"blank",
@@ -55,7 +58,8 @@
       "9":{
         "label":"STATE",
         "type":"data",
-        "blocks":"1048576"
+        "blocks":"1048576",
+        "fs_type":"ext4"
       }
     },
     "vm":{

From 8ca62121d96fdc6cc24eda83ab1ffafee1f83d70 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Mon, 23 Dec 2013 15:54:14 -0800
Subject: [PATCH 08/29] feat(disk_util): Add mount and unmount commands.

This will replace the assorted mix of mount/umount scripts.
---
 build_library/disk_util               | 88 ++++++++++++++++++++++++++-
 build_library/legacy_disk_layout.json | 19 ++++--
 2 files changed, 102 insertions(+), 5 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index c0aa1fc84f..6ea07fa57d 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -35,7 +35,8 @@ def LoadPartitionConfig(options):
   valid_keys = set(('_comment', 'metadata', 'layouts'))
   valid_layout_keys = set((
       '_comment', 'type', 'num', 'label', 'blocks', 'block_size', 'fs_blocks',
-      'fs_block_size', 'fs_type', 'features', 'uuid', 'alignment'))
+      'fs_block_size', 'fs_type', 'features', 'uuid', 'alignment', 'mount',
+      'binds'))
   integer_layout_keys = set((
       'blocks', 'block_size', 'fs_blocks', 'fs_block_size', 'alignment'))
   required_layout_keys = set(('type', 'num', 'label', 'blocks'))
@@ -321,6 +322,81 @@ def Format(options):
       Sudo(['losetup', '--detach', loop_dev])
 
 
+def Mount(options):
+  """Mount the given disk image.
+
+  The existing partition table is used to determine what exists but the
+  disk layout config is used to look up mount points and binds.
+
+  Args:
+    options: Flags passed to the script
+  """
+
+  config, partitions = LoadPartitionConfig(options)
+  mounts = {}
+
+  cgpt_show = subprocess.check_output(
+          ['cgpt', 'show', '-q', options.disk_image])
+  for line in cgpt_show.split('\n'):
+    if not line.strip():
+      continue
+    fields = line.split(None, 3)
+    if len(fields) != 4 or not all(f.isdigit() for f in fields[:3]):
+      raise Exception('Invalid output from cgpt show -q: %r' % line)
+
+    first_block = int(fields[0])
+    blocks = int(fields[1])
+    part_num = fields[2]
+    part = partitions.get(part_num, {})
+    path = part.get('mount', None)
+    if not path or not path.startswith('/'):
+      continue
+
+    mounts[path] = {'path': path,
+                    'offset': first_block * config['metadata']['block_size'],
+                    'size': blocks * config['metadata']['block_size'],
+                    'type': part.get('fs_type', 'auto'),
+                    'binds': part.get('binds', {})}
+
+  rootfs = mounts.pop('/', None)
+  if not rootfs:
+    raise InvalidLayout('No partition defined to mount on /')
+
+  def DoMount(mount):
+    full_path = os.path.realpath(options.mount_dir + mount['path'])
+    mount_opts = ['loop',
+                  'offset=%d' % mount['offset'],
+                  'sizelimit=%d' % mount['size']]
+    if options.read_only:
+      mount_opts.append('ro')
+    else:
+      Sudo(['mkdir', '-p', full_path])
+
+    Sudo(['mount', '-t', mount['type'],
+                   '-o', ','.join(mount_opts),
+                   options.disk_image, full_path])
+
+    for src, dst in mount['binds'].iteritems():
+      # src may be relative or absolute, os.path.join handles this.
+      full_src =  os.path.realpath(
+              options.mount_dir + os.path.join(mount['path'], src))
+      full_dst = os.path.realpath(options.mount_dir + dst)
+      Sudo(['mkdir', '-p', full_src, full_dst])
+      Sudo(['mount', '--bind', full_src, full_dst])
+
+  DoMount(rootfs)
+  for mount in mounts.itervalues():
+    DoMount(mount)
+
+def Umount(options):
+  """Unmount the given path.
+
+  Args:
+    options: Flags passed to the script
+  """
+  Sudo(['umount', '--recursive', '--detach-loop', options.mount_dir])
+
+
 def GetPartitionByNumber(partitions, num):
   """Given a partition table and number returns the partition object.
 
@@ -519,6 +595,16 @@ def main(argv):
   a.add_argument('disk_image', help='path to disk image file')
   a.set_defaults(func=Format)
 
+  a = actions.add_parser('mount', help='mount filesystems in image')
+  a.add_argument('--read_only', '-r', help='mount filesystems read-only')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.add_argument('mount_dir', help='path to root filesystem mount point')
+  a.set_defaults(func=Mount)
+
+  a = actions.add_parser('umount', help='unmount a image mount point')
+  a.add_argument('mount_dir', help='path to root filesystem mount point')
+  a.set_defaults(func=Umount)
+
   a = actions.add_parser('readblocksize', help='get device block size')
   a.set_defaults(func=GetBlockSize)
 
diff --git a/build_library/legacy_disk_layout.json b/build_library/legacy_disk_layout.json
index b427d0c65d..dbe1628d9b 100644
--- a/build_library/legacy_disk_layout.json
+++ b/build_library/legacy_disk_layout.json
@@ -11,7 +11,8 @@
         "label":"EFI-SYSTEM",
         "type":"efi",
         "blocks":"262144",
-        "fs_type":"vfat"
+        "fs_type":"vfat",
+        "mount":"/boot/efi"
       },
       "2":{
         "label":"BOOT-B",
@@ -24,7 +25,8 @@
         "type":"coreos-rootfs",
         "blocks":"2097152",
         "fs_blocks":"262144",
-        "fs_type":"ext2"
+        "fs_type":"ext2",
+        "mount":"/"
       },
       "4":{
         "label":"ROOT-B",
@@ -43,7 +45,8 @@
         "label":"OEM",
         "type":"data",
         "blocks":"262144",
-        "fs_type":"ext4"
+        "fs_type":"ext4",
+        "mount":"/usr/share/oem"
       },
       "7":{
         "type":"blank",
@@ -59,7 +62,15 @@
         "label":"STATE",
         "type":"data",
         "blocks":"1048576",
-        "fs_type":"ext4"
+        "fs_type":"ext4",
+        "mount":"/media/state",
+        "binds":{
+          "overlays/home":"/home",
+          "overlays/opt":"/opt",
+          "overlays/srv":"/srv",
+          "overlays/usr/local":"/usr/local",
+          "overlays/var":"/var"
+        }
       }
     },
     "vm":{

From 9bc36ee3440d0c19eb4b3c6cac7d61ab7f1c5e34 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 13:18:28 -0800
Subject: [PATCH 09/29] fix(base_image_util): Remove dead code, leave rootfs
 writable.

The verification flag was being passed through to the bootloader
template script but no longer had any effect.
Force the base image to always remain writable, its only purpose is to
be modified in a later build step anyway.
---
 build_image                                   |  2 +-
 build_library/base_image_util.sh              | 19 ++-----------------
 .../create_legacy_bootloader_templates.sh     |  2 --
 3 files changed, 3 insertions(+), 20 deletions(-)

diff --git a/build_image b/build_image
index 2c042688d7..728138eb2c 100755
--- a/build_image
+++ b/build_image
@@ -121,7 +121,7 @@ fi
 mkdir -p "${BUILD_DIR}"
 
 # Create the base image.
-create_base_image ${PRISTINE_IMAGE_NAME} ${FLAGS_enable_rootfs_verification}
+create_base_image ${PRISTINE_IMAGE_NAME}
 if should_build_image ${PRISTINE_IMAGE_NAME}; then
   upload_image "${BUILD_DIR}/${PRISTINE_IMAGE_NAME}"
 fi
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 9844c86032..7f2b49ab06 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -174,25 +174,10 @@ create_base_image() {
   # cros_make_image_bootable.
   create_boot_desc
 
-  # Populates the root filesystem with legacy bootloader templates
-  # appropriate for the platform.  The autoupdater and installer will
-  # use those templates to update the legacy boot partition (12/ESP)
-  # on update.
-  local enable_rootfs_verification=
-  if [[ ${rootfs_verification_enabled} -eq ${FLAGS_TRUE} ]]; then
-    enable_rootfs_verification="--enable_rootfs_verification"
-  fi
-
   ${BUILD_LIBRARY_DIR}/create_legacy_bootloader_templates.sh \
     --arch=${ARCH} \
     --to="${root_fs_dir}"/boot \
-    --boot_args="${FLAGS_boot_args}" \
-      ${enable_rootfs_verification}
-
-  if [[ ${skip_test_image_content} -ne 1 ]]; then
-    # Check that the image has been correctly created.
-    test_image_content "$root_fs_dir"
-  fi
+    --boot_args="${FLAGS_boot_args}"
 
   # Zero all fs free space to make it more compressible so auto-update
   # payloads become smaller, not fatal since it won't work on linux < 3.2
@@ -215,7 +200,7 @@ create_base_image() {
   emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
 
   ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-    "${image_name}"
+    "${image_name}" --noenable_rootfs_verification
 
   trap - EXIT
 }
diff --git a/build_library/create_legacy_bootloader_templates.sh b/build_library/create_legacy_bootloader_templates.sh
index f6b6467fa1..5fbd6bcb61 100755
--- a/build_library/create_legacy_bootloader_templates.sh
+++ b/build_library/create_legacy_bootloader_templates.sh
@@ -20,8 +20,6 @@ DEFINE_string to "/tmp/boot" \
   "Path to populate with bootloader templates (Default: /tmp/boot)"
 DEFINE_string boot_args "" \
   "Additional boot arguments to pass to the commandline (Default: '')"
-DEFINE_boolean enable_rootfs_verification ${FLAGS_FALSE} \
-  "Controls if verity is used for root filesystem checking (Default: false)"
 
 # Parse flags
 FLAGS "$@" || exit 1

From 52e1dba3ec69e433ee37eca460301d0d225b15a2 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Thu, 26 Dec 2013 15:40:02 -0800
Subject: [PATCH 10/29] fix(build_image): Migrate to new disk_util commands

---
 build_image                       |   3 +-
 build_library/base_image_util.sh  | 155 +++---------------------------
 build_library/build_image_util.sh |   5 +
 build_library/dev_image_util.sh   |  16 +--
 build_library/mount_gpt_util.sh   |  35 -------
 5 files changed, 31 insertions(+), 183 deletions(-)
 delete mode 100755 build_library/mount_gpt_util.sh

diff --git a/build_image b/build_image
index 728138eb2c..784fe0b483 100755
--- a/build_image
+++ b/build_image
@@ -21,7 +21,7 @@ DEFINE_boolean enable_rootfs_verification ${FLAGS_TRUE} \
   "Default all bootloaders to use kernel-based root fs integrity checking."
 DEFINE_string output_root "${DEFAULT_BUILD_ROOT}/images" \
   "Directory in which to place image result directories (named by version)"
-DEFINE_string disk_layout "default" \
+DEFINE_string disk_layout "base" \
   "The disk layout type to use for this image."
 
 # include upload options
@@ -74,7 +74,6 @@ check_gsutil_opts
 . "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/board_options.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/mount_gpt_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/base_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/dev_image_util.sh" || exit 1
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 7f2b49ab06..104a88f2fb 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -4,140 +4,22 @@
 
 . "${SRC_ROOT}/platform/dev/toolchain_utils.sh" || exit 1
 
-# Overlays are parts of the disk that live on the state partition
-ROOT_OVERLAYS=(var opt srv home usr/local)
-
-cleanup_mounts() {
-  local prev_ret=$?
-
-  # Disable die on error.
-  set +e
-
-  # See if we ran out of space.  Only show if we errored out via a trap.
-  if [[ ${prev_ret} -ne 0 ]]; then
-    local df=$(df -B 1M "${root_fs_dir}")
-    if [[ ${df} == *100%* ]]; then
-      error "Here are the biggest files (by disk usage):"
-      # Send final output to stderr to match `error` behavior.
-      sudo find "${root_fs_dir}" -xdev -type f -printf '%b %P\n' | \
-        awk '$1 > 16 { $1 = $1 * 512; print }' | sort -n | tail -100 1>&2
-      error "Target image has run out of space:"
-      error "${df}"
-    fi
-  fi
-
-  echo "Cleaning up mounts"
-  safe_umount_tree "${root_fs_dir}"
-  safe_umount_tree "${state_fs_dir}"
-  safe_umount_tree "${esp_fs_dir}"
-  safe_umount_tree "${oem_fs_dir}"
-
-   # Turn die on error back on.
-  set -e
-}
-
 create_base_image() {
   local image_name=$1
   local rootfs_verification_enabled=$2
 
-  get_disk_layout_type
-  check_valid_layout "base"
-  check_valid_layout "${DISK_LAYOUT_TYPE}"
+  local disk_layout="${FLAGS_disk_layout:-base}"
+  local disk_img="${BUILD_DIR}/${image_name}"
+  local mbr_img="/usr/share/syslinux/gptmbr.bin"
+  local root_fs_dir="${BUILD_DIR}/rootfs"
 
-  info "Using image type ${DISK_LAYOUT_TYPE}"
+  info "Using image type ${disk_layout}"
+  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+      format --mbr_boot_code="${mbr_img}" "${disk_img}"
 
-  root_fs_dir="${BUILD_DIR}/rootfs"
-  state_fs_dir="${BUILD_DIR}/state"
-  esp_fs_dir="${BUILD_DIR}/esp"
-  oem_fs_dir="${BUILD_DIR}/oem"
-
-  trap "cleanup_mounts && delete_prompt" EXIT
-  cleanup_mounts &> /dev/null
-
-  local root_fs_label="ROOT-A"
-  local root_fs_num=$(get_num ${root_fs_label})
-  local root_fs_img="${BUILD_DIR}/rootfs.image"
-  local root_fs_bytes=$(get_filesystem_size ${root_fs_num})
-
-  local state_fs_label="STATE"
-  local state_fs_num=$(get_num ${state_fs_label})
-  local state_fs_img="${BUILD_DIR}/state.image"
-  local state_fs_bytes=$(get_filesystem_size ${state_fs_num})
-  local state_fs_uuid=$(uuidgen)
-
-  local esp_fs_label="EFI-SYSTEM"
-  local esp_fs_num=$(get_num ${esp_fs_label})
-  local esp_fs_img="${BUILD_DIR}/esp.image"
-  local esp_fs_bytes=$(get_filesystem_size ${esp_fs_num})
-
-  local oem_fs_label="OEM"
-  local oem_fs_num=$(get_num ${oem_fs_label})
-  local oem_fs_img="${BUILD_DIR}/oem.image"
-  local oem_fs_bytes=$(get_filesystem_size ${oem_fs_num})
-  local oem_fs_uuid=$(uuidgen)
-
-  local fs_block_size=$(get_fs_block_size)
-
-  # Build root FS image.
-  info "Building ${root_fs_img}"
-  truncate --size="${root_fs_bytes}" "${root_fs_img}"
-  /sbin/mkfs.ext2 -F -q -b ${fs_block_size} "${root_fs_img}" \
-    "$((root_fs_bytes / fs_block_size))"
-  /sbin/tune2fs -L "${root_fs_label}" \
-               -U clear \
-               -T 20091119110000 \
-               -c 0 \
-               -i 0 \
-               -m 0 \
-               -r 0 \
-               -e remount-ro \
-                "${root_fs_img}"
-  mkdir -p "${root_fs_dir}"
-  sudo mount -o loop "${root_fs_img}" "${root_fs_dir}"
-
-  df -h "${root_fs_dir}"
-
-  # Build state FS disk image.
-  info "Building ${state_fs_img}"
-  truncate --size="${state_fs_bytes}" "${state_fs_img}"
-  /sbin/mkfs.ext4 -F -q "${state_fs_img}"
-  /sbin/tune2fs -L "${state_fs_label}" -U "${state_fs_uuid}" \
-               -c 0 -i 0 "${state_fs_img}"
-  mkdir -p "${state_fs_dir}"
-  sudo mount -o loop "${state_fs_img}" "${state_fs_dir}"
-
-  # Build ESP disk image.
-  info "Building ${esp_fs_img}"
-  truncate --size="${esp_fs_bytes}" "${esp_fs_img}"
-  /usr/sbin/mkfs.vfat "${esp_fs_img}"
-
-  # Build OEM FS disk image.
-  info "Building ${oem_fs_img}"
-  truncate --size="${oem_fs_bytes}" "${oem_fs_img}"
-  /sbin/mkfs.ext4 -F -q "${oem_fs_img}"
-  /sbin/tune2fs -L "${oem_fs_label}" -U "${oem_fs_uuid}" \
-               -c 0 -i 0 "${oem_fs_img}"
-  mkdir -p "${oem_fs_dir}"
-  sudo mount -o loop "${oem_fs_img}" "${oem_fs_dir}"
-
-  # Prepare state partition with some pre-created directories.
-  info "Binding directories from state partition onto the rootfs"
-  for i in "${ROOT_OVERLAYS[@]}"; do
-    sudo mkdir -p "${state_fs_dir}/overlays/$i"
-    sudo mkdir -p "${root_fs_dir}/$i"
-    sudo mount --bind "${state_fs_dir}/overlays/$i" "${root_fs_dir}/$i"
-  done
-
-  # TODO(bp): remove these temporary fixes for /mnt/stateful_partition going moving
-  sudo mkdir -p "${root_fs_dir}/mnt/stateful_partition/"
-  sudo ln -s /media/state/overlays/usr/local "${root_fs_dir}/mnt/stateful_partition/dev_image"
-  sudo ln -s /media/state/overlays/home "${root_fs_dir}/mnt/stateful_partition/home"
-  sudo ln -s /media/state/overlays/var "${root_fs_dir}/mnt/stateful_partition/var_overlay"
-  sudo ln -s /media/state/etc "${root_fs_dir}/mnt/stateful_partition/etc"
-
-  info "Binding directories from OEM partition onto the rootfs"
-  sudo mkdir -p "${root_fs_dir}/usr/share/oem"
-  sudo mount --bind "${oem_fs_dir}" "${root_fs_dir}/usr/share/oem"
+  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+      mount "${disk_img}" "${root_fs_dir}"
+  trap "cleanup_mounts '${root_fs_dir}' && delete_prompt" EXIT
 
   # First thing first, install baselayout with USE=build to create a
   # working directory tree. Don't use binpkgs due to the use flag change.
@@ -182,19 +64,12 @@ create_base_image() {
   # Zero all fs free space to make it more compressible so auto-update
   # payloads become smaller, not fatal since it won't work on linux < 3.2
   sudo fstrim "${root_fs_dir}" || true
-  sudo fstrim "${state_fs_dir}" || true
+  if [[ -d "${root_fs_dir}/media/state" ]]; then
+      sudo fstrim "${root_fs_dir}/media/state" || true
+  fi
 
-  cleanup_mounts
-
-  # Create the GPT-formatted image.
-  build_gpt "${BUILD_DIR}/${image_name}" \
-          "${root_fs_img}" \
-          "${state_fs_img}" \
-          "${esp_fs_img}" \
-          "${oem_fs_img}"
-
-  # Clean up temporary files.
-  rm -f "${root_fs_img}" "${state_fs_img}" "${esp_fs_img}" "{oem_fs_img}"
+  cleanup_mounts "${root_fs_dir}"
+  trap "delete_prompt" EXIT
 
   # Emit helpful scripts for testers, etc.
   emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
diff --git a/build_library/build_image_util.sh b/build_library/build_image_util.sh
index f2ce6406d0..eb89050a0f 100755
--- a/build_library/build_image_util.sh
+++ b/build_library/build_image_util.sh
@@ -96,6 +96,11 @@ create_boot_desc() {
 EOF
 }
 
+cleanup_mounts() {
+  echo "Cleaning up mounts"
+  "${BUILD_LIBRARY_DIR}/disk_util" umount "$1" || true
+}
+
 delete_prompt() {
   echo "An error occurred in your build so your latest output directory" \
     "is invalid."
diff --git a/build_library/dev_image_util.sh b/build_library/dev_image_util.sh
index d93bc6f6ac..2d0aab09cd 100755
--- a/build_library/dev_image_util.sh
+++ b/build_library/dev_image_util.sh
@@ -13,11 +13,12 @@ install_dev_packages() {
   local image_name=$1
 
   info "Adding developer packages to ${image_name}"
+  local disk_layout="${FLAGS_disk_layout:-base}"
+  local root_fs_dir="${BUILD_DIR}/rootfs"
 
-  trap "unmount_image ; delete_prompt" EXIT
-
-  mount_image "${BUILD_DIR}/${image_name}" "${root_fs_dir}" \
-    "${state_fs_dir}" "${esp_fs_dir}"
+  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+      mount "${BUILD_DIR}/${image_name}" "${root_fs_dir}"
+  trap "cleanup_mounts '${root_fs_dir}' && delete_prompt" EXIT
 
   # Install developer packages described in coreos-dev.
   emerge_to_image --root="${root_fs_dir}" coreos-base/coreos-dev
@@ -37,11 +38,14 @@ install_dev_packages() {
 
   # Zero all fs free space, not fatal since it won't work on linux < 3.2
   sudo fstrim "${root_fs_dir}" || true
-  sudo fstrim "${state_fs_dir}" || true
+  if [[ -d "${root_fs_dir}/media/state" ]]; then
+      sudo fstrim "${root_fs_dir}/media/state" || true
+  fi
 
   info "Developer image built and stored at ${image_name}"
 
-  cleanup_mounts
+  cleanup_mounts "${root_fs_dir}"
+  trap "delete_prompt" EXIT
 
   if should_build_image ${image_name}; then
     ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
diff --git a/build_library/mount_gpt_util.sh b/build_library/mount_gpt_util.sh
deleted file mode 100755
index bf83e281c3..0000000000
--- a/build_library/mount_gpt_util.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) 2011 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.
-
-# This global array variable is used to remember options from
-# mount_image so that unmount_image can do its job.
-MOUNT_GPT_OPTIONS=( )
-
-# mount_image - Mount the root, stateful, and optionally ESP partitions
-#   in a Chromium OS image.
-# $1: path to image to be mounted
-# $2: path to root fs mount point
-# $3: path to stateful fs mount point
-# $4: path to ESP fs mount point; if empty the ESP will not be mounted
-mount_image() {
-  local image_dir="$(dirname $1)"
-  local image="$(basename $1)"
-  MOUNT_GPT_OPTIONS=( -r "$2" -s "$3" )
-
-  if [ $# -ge 4 ]; then
-    MOUNT_GPT_OPTIONS=( "${MOUNT_GPT_OPTIONS[@]}" -e "$4" )
-  fi
-
-  "${SCRIPTS_DIR}/mount_gpt_image.sh" --from="$image_dir" --image="$image" \
-    "${MOUNT_GPT_OPTIONS[@]}"
-}
-
-# unmount_image - Unmount the file systems mounted in the previous
-#   call to mount_image.
-# No arguments
-unmount_image() {
-  "${SCRIPTS_DIR}/mount_gpt_image.sh" -u "${MOUNT_GPT_OPTIONS[@]}"
-
-  MOUNT_GPT_OPTIONS=( )
-}

From d1fee3653e48c5adcb519e040dd97de8c42da1f7 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 13:46:26 -0800
Subject: [PATCH 11/29] fix(cros_make_image_bootable): Remove dead command line
 flags.

Lots of things are either unused or meaningless. A particularly creative
one is the fact that there are command line flags for mount point
locations that are then overwritten.
---
 bin/cros_make_image_bootable      | 127 ++++++------------------------
 build_library/build_image_util.sh |   3 -
 build_library/dev_image_util.sh   |   2 +-
 3 files changed, 24 insertions(+), 108 deletions(-)

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
index 182a5f8248..b9d9df44f8 100755
--- a/bin/cros_make_image_bootable
+++ b/bin/cros_make_image_bootable
@@ -73,58 +73,19 @@ set +e
 # Now parse the build settings from ${OUTPUT_DIR}/boot.desc
 DEFINE_string board "${DEFAULT_BOARD}" \
   "Board we're building for."
-DEFINE_string output_dir "/tmp" \
-  "Directory to place output in."
 DEFINE_string image "coreos_base.img" \
   "Full path to the coreos image to make bootable."
 DEFINE_string arch "x86" \
   "Architecture to make bootable for: arm, x86, or amd64"
-DEFINE_boolean cleanup_dirs ${FLAGS_TRUE} \
-  "Whether the mount dirs should be removed on completion."
-
-DEFINE_string boot_args "noinitrd" \
-  "Additional boot arguments to pass to the commandline"
-
 DEFINE_boolean enable_rootfs_verification ${FLAGS_FALSE} \
   "Default all bootloaders to NOT use kernel-based root fs integrity checking."
-
-DEFINE_string keys_dir "/usr/share/vboot/devkeys" \
-  "Directory containing the signing keys."
-
 DEFINE_string au_key "" \
   "Filename of the au_key to install"
-
 DEFINE_string production_track "" \
     "Use production values and a given track for update service."
-
-DEFINE_string rootfs_mountpoint "/tmp/rootfs" \
-  "Path where the rootfs can be safely mounted"
-DEFINE_string statefulfs_mountpoint "/tmp/statefulfs" \
-  "Path where the statefulfs can be safely mounted"
-DEFINE_string espfs_mountpoint "/tmp/espfs" \
-  "Path where the espfs can be safely mounted"
-
-DEFINE_boolean use_dev_keys ${FLAGS_FALSE} \
-  "Use developer keys for signing. (Default: false)"
-
 DEFINE_boolean fsck_rootfs ${FLAGS_FALSE} \
   "Check integrity of the rootfs on the modified image."
 
-# TODO(pkumar): Remove once known that no images are using this flag
-DEFINE_boolean crosbug12352_arm_kernel_signing ${FLAGS_FALSE} \
-  "This flag is deprecated but the bots still need parse old images."
-
-# TODO(sosa):  Remove once known images no longer use this in their config.
-DEFINE_string arm_extra_bootargs "" "DEPRECATED FLAG.  Do not use."
-
-DEFINE_boolean force_developer_mode ${FLAGS_FALSE} \
-  "Add cros_debug to boot args."
-
-DEFINE_boolean enable_squashfs ${FLAGS_FALSE} \
-  "Make the rootfs of the image squashfs."
-DEFINE_string squash_sort_file "" \
-  "Specify the priority of files when squashing the rootfs."
-
 
 # Parse the boot.desc and any overrides
 eval set -- "${BOOT_DESC} ${FLAG_OVERRIDES}"
@@ -136,20 +97,14 @@ FLAGS "${@}" || exit 1
 # so will die prematurely if 'switch_to_strict_mode' is specified before now.
 switch_to_strict_mode -u
 
-# $1 - Directory where developer rootfs is mounted.
-# $2 - Directory where developer stateful_partition is mounted.
-# $3 - Directory where the ESP partition is mounted.
 mount_gpt_cleanup() {
-  local rootfs="${1-$FLAGS_rootfs_mountpoint}"
-  local statefs="${2-$FLAGS_statefulfs_mountpoint}"
-  local espfs="${3-$FLAGS_espfs_mountpoint}"
   "${SCRIPTS_DIR}/mount_gpt_image.sh" \
-    -u -r "${rootfs}" -s "${statefs}" -e "${espfs}"
+    -u -r "${rootfs_mountpoint}" \
+    -s "${statefs_mountpoint}" -e "${espfs_mountpoint}"
 }
 
 make_image_bootable() {
   local image="$1"
-  local use_dev_keys=
 
   # Default to non-verified
   local enable_rootfs_verification_flag=--noenable_rootfs_verification
@@ -159,8 +114,8 @@ make_image_bootable() {
 
   trap "mount_gpt_cleanup" EXIT
   "${SCRIPTS_DIR}/mount_gpt_image.sh" --from "$(dirname "${image}")" \
-    --image "$(basename ${image})" -r "${FLAGS_rootfs_mountpoint}" \
-    -s "${FLAGS_statefulfs_mountpoint}"
+    --image "$(basename ${image})" -r "${rootfs_mountpoint}" \
+    -s "${statefulfs_mountpoint}"
 
   legacy_offset_size_export ${image}
 
@@ -168,13 +123,13 @@ make_image_bootable() {
     # Replace /etc/lsb-release on the image.
     "${BUILD_LIBRARY_DIR}/set_lsb_release" \
       --production_track="${FLAGS_production_track}" \
-      --root="${FLAGS_rootfs_mountpoint}" \
+      --root="${rootfs_mountpoint}" \
       --board="${BOARD}"
   fi
 
   # Install an auto update key on the root before sealing it off
   if [ ! -z "${FLAGS_au_key}" ]; then
-    local key_location=${FLAGS_rootfs_mountpoint}"/usr/share/update_engine/"
+    local key_location=${rootfs_mountpoint}"/usr/share/update_engine/"
     sudo mkdir -p "${key_location}"
     sudo cp "${FLAGS_au_key}" "$key_location/update-payload-key.pub.pem"
     sudo chown root:root "$key_location/update-payload-key.pub.pem"
@@ -184,10 +139,10 @@ make_image_bootable() {
 
   # The rootfs should never be mounted rw again after this point without
   # re-calling make_image_bootable.
-  sudo mount -o remount,ro "${FLAGS_rootfs_mountpoint}"
+  sudo mount -o remount,ro "${rootfs_mountpoint}"
   # Newer `mount` will decode the filename backing the loop device,
   # so we need to dig deeper and find the answer ourselves.
-  root_dev=$(awk -v mnt="${FLAGS_rootfs_mountpoint}" \
+  root_dev=$(awk -v mnt="${rootfs_mountpoint}" \
              '$2 == mnt { print $1 }' /proc/mounts)
 
   # Make the filesystem un-mountable as read-write.
@@ -199,26 +154,6 @@ make_image_bootable() {
     disable_rw_mount "$root_dev"
   fi
 
-  if [ ${FLAGS_use_dev_keys} -eq ${FLAGS_TRUE} ]; then
-    use_dev_keys="--use_dev_keys"
-  fi
-
-  if [ ${FLAGS_force_developer_mode} -eq ${FLAGS_TRUE} ]; then
-    FLAGS_boot_args="${FLAGS_boot_args} cros_debug"
-  fi
-
-  local squash_sort_flag=
-  if [ -n "${FLAGS_squash_sort_file}" ]; then
-    squash_sort_flag="-sort ${FLAGS_squash_sort_file}"
-  fi
-
-  if [ $FLAGS_enable_squashfs -eq $FLAGS_TRUE ]; then
-    local squashfs_img="${FLAGS_output_dir}/squashfs.image"
-    sudo mksquashfs "${FLAGS_rootfs_mountpoint}" ${squashfs_img} -comp lzo \
-      -noI -noF -ef ${SCRIPTS_DIR}/exclude-list -wildcards ${squash_sort_flag}
-    root_dev=$squashfs_img
-  fi
-
   # We should update the esp in place in the image.
   local bootloader_to="${image}"
   local esp_offset="$(partoffset ${image} ${NUM_ESP})"
@@ -232,24 +167,14 @@ make_image_bootable() {
   ${SCRIPTS_DIR}/update_bootloaders.sh \
     --arch=${FLAGS_arch} \
     --to="${bootloader_to}" \
-    --from="${FLAGS_rootfs_mountpoint}"/boot \
-    --vmlinuz_boot_kernel="${FLAGS_rootfs_mountpoint}"/boot/vmlinuz \
-    --vmlinuz="${FLAGS_rootfs_mountpoint}"/boot/vmlinuz \
+    --from="${rootfs_mountpoint}"/boot \
+    --vmlinuz_boot_kernel="${rootfs_mountpoint}"/boot/vmlinuz \
+    --vmlinuz="${rootfs_mountpoint}"/boot/vmlinuz \
     ${bootloader_to_flags}
 
   trap - EXIT
-  ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${FLAGS_rootfs_mountpoint}" \
-    -s "${FLAGS_statefulfs_mountpoint}"
-
-  # I can only copy the squashfs image to the image only when it is umounted.
-  if [ $FLAGS_enable_squashfs -eq $FLAGS_TRUE ]; then
-    # copy the squashfs image to the partition
-    info "copy the squashfs to the partition"
-    local part_offset="$(partoffset ${image} ${NUM_ROOTFS_A})"
-    sudo dd bs=512 if="${squashfs_img}" of="${image}" \
-            seek=${part_offset} conv=notrunc status=none
-    sudo rm "${squashfs_img}"
-  fi
+  ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${rootfs_mountpoint}" \
+    -s "${statefulfs_mountpoint}"
 }
 
 verify_image_rootfs() {
@@ -271,26 +196,20 @@ command line parameters are correct"
 }
 
 # Store output and temporary files next to image.
-FLAGS_output_dir="${IMAGE_DIR}"
-FLAGS_rootfs_mountpoint="${IMAGE_DIR}/rootfs_dir"
-FLAGS_statefulfs_mountpoint="${IMAGE_DIR}/stateful_dir"
-FLAGS_espfs_mountpoint="${IMAGE_DIR}/esp"
+rootfs_mountpoint="${IMAGE_DIR}/rootfs_dir"
+statefulfs_mountpoint="${IMAGE_DIR}/stateful_dir"
+espfs_mountpoint="${IMAGE_DIR}/esp"
 
 # Create the directories if they don't exist.
-mkdir -p ${FLAGS_rootfs_mountpoint}
-mkdir -p ${FLAGS_statefulfs_mountpoint}
-mkdir -p ${FLAGS_espfs_mountpoint}
+mkdir -p ${rootfs_mountpoint}
+mkdir -p ${statefulfs_mountpoint}
+mkdir -p ${espfs_mountpoint}
 
 make_image_bootable "${IMAGE}"
-# We can't verify the image if squashfs is enabled because the kernel
-# on the host does not support squashfs with LZO
-if [ ${FLAGS_fsck_rootfs} -eq ${FLAGS_TRUE} \
-    -a ${FLAGS_enable_squashfs} -eq ${FLAGS_FALSE} ]; then
+if [ ${FLAGS_fsck_rootfs} -eq ${FLAGS_TRUE} ]; then
   verify_image_rootfs "${IMAGE}"
 fi
 
-if [ ${FLAGS_cleanup_dirs} -eq ${FLAGS_TRUE} ]; then
-  rmdir ${FLAGS_rootfs_mountpoint}
-  rmdir ${FLAGS_statefulfs_mountpoint}
-  rmdir ${FLAGS_espfs_mountpoint}
-fi
+rmdir ${rootfs_mountpoint}
+rmdir ${statefulfs_mountpoint}
+rmdir ${espfs_mountpoint}
diff --git a/build_library/build_image_util.sh b/build_library/build_image_util.sh
index eb89050a0f..a3e8746277 100755
--- a/build_library/build_image_util.sh
+++ b/build_library/build_image_util.sh
@@ -89,9 +89,6 @@ create_boot_desc() {
   cat <<EOF > ${BUILD_DIR}/boot.desc
   --board=${BOARD}
   --arch="${ARCH}"
-  --keys_dir="${DEVKEYSDIR}"
-  --boot_args="${FLAGS_boot_args}"
-  --nocleanup_dirs
   ${enable_rootfs_verification_flag}
 EOF
 }
diff --git a/build_library/dev_image_util.sh b/build_library/dev_image_util.sh
index 2d0aab09cd..735af8556f 100755
--- a/build_library/dev_image_util.sh
+++ b/build_library/dev_image_util.sh
@@ -49,7 +49,7 @@ install_dev_packages() {
 
   if should_build_image ${image_name}; then
     ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-      ${image_name} --force_developer_mode --noenable_rootfs_verification
+      "${image_name}" --noenable_rootfs_verification
   fi
 
   trap - EXIT

From 359505490d02cf0ba5df03e298e15ed05b133e1b Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 16:56:21 -0800
Subject: [PATCH 12/29] fix(disk_util): Install syslinux as part of filesystem
 formatting.

This means scripts later don't need to deal with the ESP block device
directly, they can just copy the config files into place.
---
 build_library/disk_util               | 14 ++++++++++++++
 build_library/legacy_disk_layout.json |  3 ++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 6ea07fa57d..f1b4514324 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -8,6 +8,7 @@ import json
 import os
 import subprocess
 import sys
+import tempfile
 import uuid
 
 # First sector we can use.
@@ -283,6 +284,19 @@ def FormatFat(part, device):
                      vfat_blocks],
                      stdout_null=True)
 
+  if 'syslinux' in part.get('features', []):
+    # The syslinux directory must exist before installing ldlinux.sys to it.
+    vfat_mount = tempfile.mkdtemp()
+    Sudo(['mount', '-t', 'vfat', device, vfat_mount])
+    try:
+      Sudo(['mkdir', os.path.join(vfat_mount, 'syslinux')])
+    finally:
+      Sudo(['umount', vfat_mount])
+      os.rmdir(vfat_mount)
+
+    Sudo(['syslinux', '-d', '/syslinux', device])
+    print "Installed SYSLINUX to %s" % part['label']
+
 
 def Format(options):
   """Writes the given partition table and initialize fresh filesystems.
diff --git a/build_library/legacy_disk_layout.json b/build_library/legacy_disk_layout.json
index dbe1628d9b..31248796dd 100644
--- a/build_library/legacy_disk_layout.json
+++ b/build_library/legacy_disk_layout.json
@@ -12,7 +12,8 @@
         "type":"efi",
         "blocks":"262144",
         "fs_type":"vfat",
-        "mount":"/boot/efi"
+        "mount":"/boot/efi",
+        "features": ["syslinux"]
       },
       "2":{
         "label":"BOOT-B",

From e2c2271579a2214e5e371eea754fdb13507a99f5 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 17:20:58 -0800
Subject: [PATCH 13/29] fix(create_legacy_bootloader_templates): Setup ESP
 partition.

Replace "update_bootloaders" script.
---
 bin/cros_make_image_bootable                  |  18 ---
 build_library/base_image_util.sh              |   3 +-
 .../create_legacy_bootloader_templates.sh     |  57 +++++---
 update_bootloaders.sh                         | 127 ------------------
 4 files changed, 43 insertions(+), 162 deletions(-)
 delete mode 100755 update_bootloaders.sh

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
index b9d9df44f8..405a3db053 100755
--- a/bin/cros_make_image_bootable
+++ b/bin/cros_make_image_bootable
@@ -154,24 +154,6 @@ make_image_bootable() {
     disable_rw_mount "$root_dev"
   fi
 
-  # We should update the esp in place in the image.
-  local bootloader_to="${image}"
-  local esp_offset="$(partoffset ${image} ${NUM_ESP})"
-  esp_offset=$((esp_offset * 512))  # sectors to bytes
-  local esp_size="$(partsize ${image} ${NUM_ESP})"
-  esp_size=$((esp_size * 512))  # sectors to bytes
-  local bootloader_to_flags="--to_offset=${esp_offset} --to_size=${esp_size}"
-
-  # Update ESP partition
-  # NOTE: Boot kernel is identical to regular kernel for now
-  ${SCRIPTS_DIR}/update_bootloaders.sh \
-    --arch=${FLAGS_arch} \
-    --to="${bootloader_to}" \
-    --from="${rootfs_mountpoint}"/boot \
-    --vmlinuz_boot_kernel="${rootfs_mountpoint}"/boot/vmlinuz \
-    --vmlinuz="${rootfs_mountpoint}"/boot/vmlinuz \
-    ${bootloader_to_flags}
-
   trap - EXIT
   ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${rootfs_mountpoint}" \
     -s "${statefulfs_mountpoint}"
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 104a88f2fb..1757021b01 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -58,7 +58,8 @@ create_base_image() {
 
   ${BUILD_LIBRARY_DIR}/create_legacy_bootloader_templates.sh \
     --arch=${ARCH} \
-    --to="${root_fs_dir}"/boot \
+    --boot_dir="${root_fs_dir}"/boot \
+    --esp_dir="${root_fs_dir}"/boot/efi \
     --boot_args="${FLAGS_boot_args}"
 
   # Zero all fs free space to make it more compressible so auto-update
diff --git a/build_library/create_legacy_bootloader_templates.sh b/build_library/create_legacy_bootloader_templates.sh
index 5fbd6bcb61..d205a374da 100755
--- a/build_library/create_legacy_bootloader_templates.sh
+++ b/build_library/create_legacy_bootloader_templates.sh
@@ -16,8 +16,10 @@ assert_inside_chroot
 # Flags.
 DEFINE_string arch "x86" \
   "The boot architecture: arm or x86. (Default: x86)"
-DEFINE_string to "/tmp/boot" \
-  "Path to populate with bootloader templates (Default: /tmp/boot)"
+DEFINE_string boot_dir "/tmp/boot" \
+  "Path to boot directory in root filesystem (Default: /tmp/boot)"
+DEFINE_string esp_dir "" \
+  "Path to ESP partition mount point (Default: none)"
 DEFINE_string boot_args "" \
   "Additional boot arguments to pass to the commandline (Default: '')"
 
@@ -33,18 +35,15 @@ switch_to_strict_mode
 common_args="console=tty0 ro noswap cros_legacy"
 common_args="${common_args} ${FLAGS_boot_args}"
 
-# Populate the x86 rootfs to support legacy and EFI bios config templates.
-# The templates are used by the installer to populate partition 12 with
-# the correct bootloader configuration.
-if [[ "${FLAGS_arch}" = "x86" || "${FLAGS_arch}" = "amd64"  ]]; then
-  sudo mkdir -p ${FLAGS_to}
+# Get partition UUIDs from the json config
+ROOTA="PARTUUID=$(get_uuid ROOT-A)"
+ROOTB="PARTUUID=$(get_uuid ROOT-B)"
 
-  # Get partition UUIDs from the json config
-  ROOTA="PARTUUID=$(get_uuid ROOT-A)"
-  ROOTB="PARTUUID=$(get_uuid ROOT-B)"
+GRUB_DIR="${FLAGS_boot_dir}/grub"
+SYSLINUX_DIR="${FLAGS_boot_dir}/syslinux"
 
-  # Build configuration files for pygrub/pvgrub
-  GRUB_DIR="${FLAGS_to}/grub"
+# Build configuration files for pygrub/pvgrub
+configure_grub() {
   sudo mkdir -p "${GRUB_DIR}"
 
   # Add hvc0 for hypervisors
@@ -69,8 +68,10 @@ EOF
   sudo_append "${GRUB_DIR}/menu.lst.B" <"${GRUB_DIR}/menu.lst.A"
   info "Emitted ${GRUB_DIR}/menu.lst.B"
   sudo cp ${GRUB_DIR}/menu.lst.A ${GRUB_DIR}/menu.lst
+}
 
-  SYSLINUX_DIR="${FLAGS_to}/syslinux"
+# Build configuration files for syslinux
+configure_syslinux() {
   sudo mkdir -p "${SYSLINUX_DIR}"
 
   # Add ttyS0 as a secondary console, useful for qemu -nographic
@@ -119,8 +120,32 @@ label coreos.B
   append ${syslinux_args} root=${ROOTB}
 EOF
   info "Emitted ${SYSLINUX_DIR}/root.B.cfg"
+}
 
-  exit 0
+# Copy configurations to the ESP, this is what is actually used to boot
+copy_to_esp() {
+  if ! mountpoint -q "${FLAGS_esp_dir}"; then
+    die "${FLAGS_esp_dir} is not a mount point."
+  fi
+
+  sudo mkdir -p "${FLAGS_esp_dir}"/{syslinux,boot/grub,EFI/boot}
+  sudo cp -r "${GRUB_DIR}/." "${FLAGS_esp_dir}/boot/grub"
+  sudo cp -r "${SYSLINUX_DIR}/." "${FLAGS_esp_dir}/syslinux"
+
+  # Stage all kernels with the only one we built.
+  for kernel in syslinux/{vmlinuz-boot_kernel,vmlinuz.A,vmlinuz.B} \
+                EFI/boot/bootx64.efi
+  do
+    sudo cp "${FLAGS_boot_dir}/vmlinuz" "${FLAGS_esp_dir}/${kernel}"
+  done
+}
+
+if [[ "${FLAGS_arch}" = "x86" || "${FLAGS_arch}" = "amd64"  ]]; then
+  configure_grub
+  configure_syslinux
+  if [[ -n "${FLAGS_esp_dir}" ]]; then
+    copy_to_esp
+  fi
+else
+  error "No bootloader configuration for ${FLAGS_arch}"
 fi
-
-info "The target platform does not use bootloader templates."
diff --git a/update_bootloaders.sh b/update_bootloaders.sh
deleted file mode 100755
index 41092cfd7a..0000000000
--- a/update_bootloaders.sh
+++ /dev/null
@@ -1,127 +0,0 @@
-#!/bin/bash
-
-# Copyright (c) 2012 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.
-
-# Helper script that generates the legacy/efi bootloader partitions.
-# It does not populate the templates, but can update a loop device.
-
-SCRIPT_ROOT=$(dirname $(readlink -f "$0"))
-. "${SCRIPT_ROOT}/common.sh" || exit 1
-
-# Need to be inside the chroot to load chromeos-common.sh
-assert_inside_chroot
-
-# Load functions and constants for chromeos-install
-. /usr/lib/installer/chromeos-common.sh || exit 1
-
-# Flags.
-DEFINE_string arch "x86" \
-  "The boot architecture: arm or x86. (Default: x86)"
-DEFINE_string from "/tmp/boot" \
-  "Path the legacy bootloader templates are copied from. (Default /tmp/boot)"
-DEFINE_string to "/tmp/esp.img" \
-  "Path to esp image (Default: /tmp/esp.img)"
-DEFINE_integer to_offset 0 \
-  "Offset in bytes into 'to' if it is a file (Default: 0)"
-DEFINE_integer to_size -1 \
-  "Size in bytes of 'to' to use if it is a file. -1 is ignored. (Default: -1)"
-DEFINE_string vmlinuz "/tmp/vmlinuz" \
-  "Path to the vmlinuz file to use (Default: /tmp/vmlinuz)"
-DEFINE_string vmlinuz_boot_kernel "/tmp/vmlinuz-boot_kernel" \
-  "Path to the vmlinuz-boot_kernel file to use (Default: /tmp/vmlinuz)"
-
-# Parse flags
-FLAGS "$@" || exit 1
-eval set -- "${FLAGS_ARGV}"
-switch_to_strict_mode
-
-part_index_to_uuid() {
-  local image="$1"
-  local index="$2"
-  cgpt show -i "$index" -u "$image"
-}
-
-ESP_DEV=
-if [[ ! -e "${FLAGS_to}" ]]; then
-  error "The ESP doesn't exist"
-  # This shouldn't happen.
-  info "Creating a new esp image at ${FLAGS_to}" anyway.
-  # Create EFI System Partition to boot stock EFI BIOS (but not ChromeOS EFI
-  # BIOS).  ARM uses this space to determine which partition is bootable.
-  # NOTE: The size argument for mkfs.vfat is in 1024-byte blocks.
-  # We'll hard-code it to 16M for now.
-  ESP_BLOCKS=16384
-  /usr/sbin/mkfs.vfat -C "${FLAGS_to}" ${ESP_BLOCKS}
-  ESP_DEV=$(sudo losetup --show -f "${FLAGS_to}")
-  if [ -z "${ESP_DEV}" ]; then
-    die "No free loop devices."
-  fi
-else
-  if [[ -f "${FLAGS_to}" ]]; then
-    esp_offset="--offset ${FLAGS_to_offset}"
-    esp_size="--sizelimit ${FLAGS_to_size}"
-    if [ ${FLAGS_to_size} -lt 0 ]; then
-      esp_size=
-    fi
-    ESP_DEV=$(sudo losetup --show -f ${esp_offset} ${esp_size} "${FLAGS_to}")
-    if [ -z "${ESP_DEV}" ]; then
-      die "No free loop devices."
-    fi
-  else
-    # If it is a block device or something else, try to mount it anyway.
-    ESP_DEV="${FLAGS_to}"
-  fi
-fi
-
-ESP_FS_DIR=$(mktemp -d /tmp/esp.XXXXXX)
-cleanup() {
-  set +e
-  if ! safe_umount "${ESP_FS_DIR}"; then
-      # There is a race condition possible on some ubuntu setups
-      # with mounting and unmounting a device very quickly
-      # Doing a quick sleep/retry as a temporary workaround
-      warn "Initial unmount failed. Possibly crosbug.com/23443. Retrying"
-      sleep 5
-      safe_umount "${ESP_FS_DIR}"
-  fi
-  if [[ -n "${ESP_DEV}" && -z "${ESP_DEV//\/dev\/loop*}" ]]; then
-    sudo losetup -d  "${ESP_DEV}"
-  fi
-  rm -rf "${ESP_FS_DIR}"
-}
-trap cleanup EXIT
-sudo mount "${ESP_DEV}" "${ESP_FS_DIR}"
-
-if [[ "${FLAGS_arch}" = "x86" || "${FLAGS_arch}" = "amd64" ]]; then
-  # Copy over the grub configurations for cloud machines and the
-  # kernel into both the A and B slot
-  sudo mkdir -p "${ESP_FS_DIR}"/boot/grub
-  sudo cp -r "${FLAGS_from}"/grub/. "${ESP_FS_DIR}"/boot/grub
-  sudo cp -r "${FLAGS_from}"/grub/menu.lst.A "${ESP_FS_DIR}"/boot/grub/menu.lst
-
-  # Prepopulate the syslinux directories too and update for verified boot values
-  # after the rootfs work is done.
-  sudo mkdir -p "${ESP_FS_DIR}"/syslinux
-  sudo cp -r "${FLAGS_from}"/syslinux/. "${ESP_FS_DIR}"/syslinux
-
-  # Stage both kernels with the only one we built.
-  sudo cp -f "${FLAGS_vmlinuz_boot_kernel}" "${ESP_FS_DIR}"/syslinux/vmlinuz-boot_kernel
-  sudo cp -f "${FLAGS_vmlinuz}" "${ESP_FS_DIR}"/syslinux/vmlinuz.A
-  sudo cp -f "${FLAGS_vmlinuz}" "${ESP_FS_DIR}"/syslinux/vmlinuz.B
-
-  # create the EFI directory tree as a fall-back for UEFI builds and put a copy
-  # of the kernel in there.
-  sudo mkdir -p "${ESP_FS_DIR}"/EFI/boot
-  sudo cp -f "${FLAGS_vmlinuz}" "${ESP_FS_DIR}"/EFI/boot/bootx64.efi
-
-  safe_umount "${ESP_FS_DIR}"
-  sudo syslinux -d /syslinux "${ESP_DEV}"
-  # mount again for cleanup to free resource gracefully
-  sudo mount -o ro "${ESP_DEV}" "${ESP_FS_DIR}"
-else
-  die "Unknown arch ${FLAGS_arch}"
-fi
-
-set +e

From 306a2f6cbc11dcc0f62e5e0cff403cd5995676c2 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 18:35:15 -0800
Subject: [PATCH 14/29] fix(cros_make_image_bootable): Switch to disk_util
 mount/umount

---
 bin/cros_make_image_bootable     |  23 +---
 build_image                      |   1 +
 build_library/base_image_util.sh |   3 +-
 build_library/dev_image_util.sh  |   3 +-
 mount_gpt_image.sh               | 194 -------------------------------
 5 files changed, 11 insertions(+), 213 deletions(-)
 delete mode 100755 mount_gpt_image.sh

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
index 405a3db053..b5dd669f57 100755
--- a/bin/cros_make_image_bootable
+++ b/bin/cros_make_image_bootable
@@ -77,6 +77,8 @@ DEFINE_string image "coreos_base.img" \
   "Full path to the coreos image to make bootable."
 DEFINE_string arch "x86" \
   "Architecture to make bootable for: arm, x86, or amd64"
+DEFINE_string disk_layout "base" \
+  "The disk layout type to use for this image."
 DEFINE_boolean enable_rootfs_verification ${FLAGS_FALSE} \
   "Default all bootloaders to NOT use kernel-based root fs integrity checking."
 DEFINE_string au_key "" \
@@ -98,9 +100,7 @@ FLAGS "${@}" || exit 1
 switch_to_strict_mode -u
 
 mount_gpt_cleanup() {
-  "${SCRIPTS_DIR}/mount_gpt_image.sh" \
-    -u -r "${rootfs_mountpoint}" \
-    -s "${statefs_mountpoint}" -e "${espfs_mountpoint}"
+  "${BUILD_LIBRARY_DIR}/disk_util" umount "${rootfs_mountpoint}" || true
 }
 
 make_image_bootable() {
@@ -112,12 +112,9 @@ make_image_bootable() {
     enable_rootfs_verification_flag=--enable_rootfs_verification
   fi
 
+  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${FLAGS_disk_layout}" \
+      mount "${image}" "${rootfs_mountpoint}"
   trap "mount_gpt_cleanup" EXIT
-  "${SCRIPTS_DIR}/mount_gpt_image.sh" --from "$(dirname "${image}")" \
-    --image "$(basename ${image})" -r "${rootfs_mountpoint}" \
-    -s "${statefulfs_mountpoint}"
-
-  legacy_offset_size_export ${image}
 
   if [ -n "${FLAGS_production_track}" ]; then
     # Replace /etc/lsb-release on the image.
@@ -146,7 +143,6 @@ make_image_bootable() {
              '$2 == mnt { print $1 }' /proc/mounts)
 
   # Make the filesystem un-mountable as read-write.
-  # mount_gpt_image.sh will undo this as needed.
   # TODO(wad) make sure there is parity in the signing scripts.
   if [ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]; then
     # TODO(wad) this would be a good place to reset any other ext2 metadata.
@@ -155,8 +151,7 @@ make_image_bootable() {
   fi
 
   trap - EXIT
-  ${SCRIPTS_DIR}/mount_gpt_image.sh -u -r "${rootfs_mountpoint}" \
-    -s "${statefulfs_mountpoint}"
+  "${BUILD_LIBRARY_DIR}/disk_util" umount "${rootfs_mountpoint}"
 }
 
 verify_image_rootfs() {
@@ -179,13 +174,9 @@ command line parameters are correct"
 
 # Store output and temporary files next to image.
 rootfs_mountpoint="${IMAGE_DIR}/rootfs_dir"
-statefulfs_mountpoint="${IMAGE_DIR}/stateful_dir"
-espfs_mountpoint="${IMAGE_DIR}/esp"
 
 # Create the directories if they don't exist.
 mkdir -p ${rootfs_mountpoint}
-mkdir -p ${statefulfs_mountpoint}
-mkdir -p ${espfs_mountpoint}
 
 make_image_bootable "${IMAGE}"
 if [ ${FLAGS_fsck_rootfs} -eq ${FLAGS_TRUE} ]; then
@@ -193,5 +184,3 @@ if [ ${FLAGS_fsck_rootfs} -eq ${FLAGS_TRUE} ]; then
 fi
 
 rmdir ${rootfs_mountpoint}
-rmdir ${statefulfs_mountpoint}
-rmdir ${espfs_mountpoint}
diff --git a/build_image b/build_image
index 784fe0b483..a69e5315d0 100755
--- a/build_image
+++ b/build_image
@@ -149,6 +149,7 @@ if should_build_image ${COREOS_PRODUCTION_IMAGE_NAME}; then
     "${BUILD_DIR}" \
      ${COREOS_PRODUCTION_IMAGE_NAME} \
     --production_track="dev-channel" \
+    --disk_layout="${FLAGS_disk_layout}" \
     --au_key=${SRC_ROOT}/third_party/coreos-overlay/coreos-base/coreos-au-key/files/update-payload-key.pub.pem
 
   upload_image "${BUILD_DIR}/${COREOS_PRODUCTION_IMAGE_NAME}"
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 1757021b01..7b9206410b 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -76,7 +76,8 @@ create_base_image() {
   emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
 
   ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-    "${image_name}" --noenable_rootfs_verification
+    "${image_name}" --disk_layout="${disk_layout}" \
+    --noenable_rootfs_verification
 
   trap - EXIT
 }
diff --git a/build_library/dev_image_util.sh b/build_library/dev_image_util.sh
index 735af8556f..574d96047a 100755
--- a/build_library/dev_image_util.sh
+++ b/build_library/dev_image_util.sh
@@ -49,7 +49,8 @@ install_dev_packages() {
 
   if should_build_image ${image_name}; then
     ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-      "${image_name}" --noenable_rootfs_verification
+      "${image_name}" --disk_layout="${disk_layout}" \
+      --noenable_rootfs_verification
   fi
 
   trap - EXIT
diff --git a/mount_gpt_image.sh b/mount_gpt_image.sh
deleted file mode 100755
index 579f9d7853..0000000000
--- a/mount_gpt_image.sh
+++ /dev/null
@@ -1,194 +0,0 @@
-#!/bin/bash
-
-# Copyright (c) 2012 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.
-
-# Helper script that mounts chromium os image from a device or directory
-# and creates mount points for /var and /usr/local (if in dev_mode).
-
-# Helper scripts should be run from the same location as this script.
-SCRIPT_ROOT=$(dirname "$(readlink -f "$0")")
-. "${SCRIPT_ROOT}/common.sh" || exit 1
-
-if [ $INSIDE_CHROOT -ne 1 ]; then
-  INSTALL_ROOT="$SRC_ROOT/platform/installer/"
-else
-  INSTALL_ROOT=/usr/lib/installer/
-fi
-# Load functions and constants for chromeos-install
-. "${INSTALL_ROOT}/chromeos-common.sh" || exit 1
-
-locate_gpt
-
-# Flags.
-DEFINE_string board "$DEFAULT_BOARD" \
-  "The board for which the image was built." b
-DEFINE_boolean read_only $FLAGS_FALSE \
-  "Mount in read only mode -- skips stateful items."
-DEFINE_boolean safe $FLAGS_FALSE \
-  "Mount rootfs in read only mode."
-DEFINE_boolean unmount $FLAGS_FALSE \
-  "Unmount previously mounted dir." u
-DEFINE_string from "/dev/sdc" \
-  "Directory, image, or device with image on it" f
-DEFINE_string image "$COREOS_IMAGE_NAME" \
-  "Name of the bin file if a directory is specified in the from flag" i
-DEFINE_string "rootfs_mountpt" "/tmp/m" "Mount point for rootfs" "r"
-DEFINE_string "stateful_mountpt" "/tmp/s" \
-    "Mount point for stateful partition" "s"
-DEFINE_string "esp_mountpt" "" \
-    "Mount point for esp partition" "e"
-DEFINE_boolean most_recent ${FLAGS_FALSE} "Use the most recent image dir" m
-
-# Parse flags
-FLAGS "$@" || exit 1
-eval set -- "${FLAGS_ARGV}"
-
-# Die on error
-switch_to_strict_mode
-
-# Find the last image built on the board.
-if [ ${FLAGS_most_recent} -eq ${FLAGS_TRUE} ] ; then
-  FLAGS_from="$(${SCRIPT_ROOT}/get_latest_image.sh --board="${FLAGS_board}")"
-fi
-
-# Check for conflicting args.
-# If --from is a block device, --image can't also be specified.
-if [ -b "${FLAGS_from}" ]; then
-  if [ "${FLAGS_image}" != "$COREOS_IMAGE_NAME" ]; then
-    die_notrace "-i ${FLAGS_image} can't be used with block device ${FLAGS_from}"
-  fi
-fi
-
-# Allow --from /foo/file.bin
-if [ -f "${FLAGS_from}" ]; then
-  # If --from is specified as a file, --image cannot be also specified.
-  if [ "${FLAGS_image}" != "$COREOS_IMAGE_NAME" ]; then
-    die_notrace "-i ${FLAGS_image} can't be used with --from file ${FLAGS_from}"
-  fi
-  pathname=$(dirname "${FLAGS_from}")
-  filename=$(basename "${FLAGS_from}")
-  FLAGS_image="${filename}"
-  FLAGS_from="${pathname}"
-fi
-
-# Common unmounts for either a device or directory
-unmount_image() {
-  info "Unmounting image from ${FLAGS_stateful_mountpt}" \
-      "and ${FLAGS_rootfs_mountpt}"
-  # Don't die on error to force cleanup
-  set +e
-  safe_umount "${FLAGS_rootfs_mountpt}/usr/local"
-  safe_umount "${FLAGS_rootfs_mountpt}/var"
-  if [[ -n "${FLAGS_esp_mountpt}" ]]; then
-    safe_umount "${FLAGS_esp_mountpt}"
-  fi
-  safe_umount "${FLAGS_stateful_mountpt}"
-  safe_umount "${FLAGS_rootfs_mountpt}"
-  switch_to_strict_mode
-}
-
-get_usb_partitions() {
-  local ro_flag=""
-  local safe_flag=""
-  [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} ] && ro_flag="-o ro"
-  [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} -o \
-    ${FLAGS_safe} -eq ${FLAGS_TRUE} ] && safe_flag="-o ro -t ext2"
-
-  sudo mount ${safe_flag} "${FLAGS_from}4" "${FLAGS_rootfs_mountpt}"
-  sudo mount ${ro_flag} "${FLAGS_from}10" "${FLAGS_stateful_mountpt}"
-  if [[ -n "${FLAGS_esp_mountpt}" ]]; then
-    sudo mount ${ro_flag} "${FLAGS_from}2" "${FLAGS_esp_mountpt}"
-  fi
-}
-
-get_gpt_partitions() {
-  local filename="${FLAGS_image}"
-
-  legacy_offset_size_export "${FLAGS_from}/${FLAGS_image}"
-
-  # Mount the rootfs partition using a loopback device.
-  local offset=$(partoffset "${FLAGS_from}/${filename}" ${NUM_ROOTFS_A})
-  local ro_flag=""
-  local safe_flag=""
-
-  if [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} ]; then
-    ro_flag=",ro"
-  fi
-
-  if [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} -o \
-       ${FLAGS_safe} -eq ${FLAGS_TRUE} ]; then
-    safe_flag=",ro"
-  else
-    # Make sure any callers can actually mount and modify the fs
-    # if desired.
-    # cros_make_image_bootable should restore the bit if needed.
-    enable_rw_mount "${FLAGS_from}/${filename}" "$(( offset * 512 ))"
-  fi
-
-  if ! sudo mount -o loop,offset=$(( offset * 512 ))${safe_flag}  \
-      "${FLAGS_from}/${filename}" "${FLAGS_rootfs_mountpt}" ; then
-    error "mount failed: options=${safe_flag} offset=$(( offset * 512 ))" \
-        "target=${FLAGS_rootfs_mountpt}"
-    return 1
-  fi
-
-  # Mount the stateful partition using a loopback device.
-  offset=$(partoffset "${FLAGS_from}/${filename}" ${NUM_STATEFUL})
-  if ! sudo mount -o loop,offset=$(( offset * 512 ))${ro_flag} \
-      "${FLAGS_from}/${filename}" "${FLAGS_stateful_mountpt}" ; then
-    error "mount failed: options=${ro_flag} offset=$(( offset * 512 ))" \
-        "target=${FLAGS_stateful_mountpt}"
-    return 1
-  fi
-
-  # Mount the esp partition using a loopback device.
-  if [[ -n "${FLAGS_esp_mountpt}" ]]; then
-    offset=$(partoffset "${FLAGS_from}/${filename}" ${NUM_ESP})
-    if ! sudo mount -o loop,offset=$(( offset * 512 ))${ro_flag}  \
-        "${FLAGS_from}/${filename}" "${FLAGS_esp_mountpt}" ; then
-      error "mount failed: options=${ro_flag} offset=$(( offset * 512 ))" \
-          "target=${FLAGS_esp_mountpt}"
-      return 1
-    fi
-  fi
-}
-
-# Mount a gpt based image.
-mount_image() {
-  mkdir -p "${FLAGS_rootfs_mountpt}"
-  mkdir -p "${FLAGS_stateful_mountpt}"
-  if [[ -n "${FLAGS_esp_mountpt}" ]]; then
-    mkdir -p "${FLAGS_esp_mountpt}"
-  fi
-
-  # Get the partitions for the image / device.
-  if [ -b ${FLAGS_from} ] ; then
-    get_usb_partitions
-  elif ! get_gpt_partitions ; then
-    echo "Current loopback device status:"
-    sudo losetup --all | sed 's/^/    /'
-    die "Failed to mount all partitions in ${FLAGS_from}/${FLAGS_image}"
-  fi
-
-  # Mount directories and setup symlinks.
-  sudo mount --bind "${FLAGS_stateful_mountpt}/overlays/var" \
-    "${FLAGS_rootfs_mountpt}/var"
-  sudo mount --bind "${FLAGS_stateful_mountpt}/overlays/usr/local" \
-    "${FLAGS_rootfs_mountpt}/usr/local"
-  info "Image specified by ${FLAGS_from} mounted at"\
-    "${FLAGS_rootfs_mountpt} successfully."
-}
-
-# Turn paths into absolute paths.
-FLAGS_from=`eval readlink -f ${FLAGS_from}`
-FLAGS_rootfs_mountpt=`eval readlink -f ${FLAGS_rootfs_mountpt}`
-FLAGS_stateful_mountpt=`eval readlink -f ${FLAGS_stateful_mountpt}`
-
-# Perform desired operation.
-if [ ${FLAGS_unmount} -eq ${FLAGS_TRUE} ] ; then
-  unmount_image
-else
-  mount_image
-fi

From 213472652c453afddc78abd0eae594f04380aaff Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 28 Dec 2013 19:20:00 -0800
Subject: [PATCH 15/29] add(prod_image_util): Rename what remains of
 cros_make_image_bootable

cros_make_image_bootable now only is relevant for prod images, so move
the remaining code to prod_image_util in a similar scheme that base and
dev images use.
---
 bin/cros_make_image_bootable      | 186 ------------------------------
 build_image                       |   9 +-
 build_library/base_image_util.sh  |   9 --
 build_library/build_image_util.sh |  13 ---
 build_library/dev_image_util.sh   |   8 --
 build_library/prod_image_util.sh  |  47 ++++++++
 6 files changed, 50 insertions(+), 222 deletions(-)
 delete mode 100755 bin/cros_make_image_bootable
 create mode 100755 build_library/prod_image_util.sh

diff --git a/bin/cros_make_image_bootable b/bin/cros_make_image_bootable
deleted file mode 100755
index b5dd669f57..0000000000
--- a/bin/cros_make_image_bootable
+++ /dev/null
@@ -1,186 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2010 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 which ensures that a given image has an up-to-date
-# kernel partition, rootfs integrity hashes, and legacy bootloader configs.
-
-# --- BEGIN COMMON.SH BOILERPLATE ---
-# Load common CrOS utilities.  Inside the chroot this file is installed in
-# /usr/lib/crosutils.  Outside the chroot we find it relative to the script's
-# location.
-find_common_sh() {
-  local common_paths=("$(dirname "$(readlink -f "$0")")/.." /usr/lib/crosutils)
-  local path
-
-  SCRIPT_ROOT="${common_paths[0]}"
-  for path in "${common_paths[@]}"; do
-    if [ -r "${path}/common.sh" ]; then
-      SCRIPT_ROOT="${path}"
-      break
-    fi
-  done
-}
-
-find_common_sh
-. "${SCRIPT_ROOT}/common.sh" || exit 1
-# --- END COMMON.SH BOILERPLATE ---
-
-# Need to be inside the chroot to load chromeos-common.sh
-assert_inside_chroot
-
-# Load functions and constants for chromeos-install
-. /usr/lib/installer/chromeos-common.sh || exit 1
-. "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
-
-switch_to_strict_mode
-
-if [ $# -lt 2 ]; then
-  echo "Usage: ${0} /PATH/TO/IMAGE IMAGE.BIN [shflags overrides]"
-  exit 1
-fi
-
-IMAGE_DIR="$(readlink -f "${1}")"
-BOOT_DESC_FILE="${IMAGE_DIR}/boot.desc"
-IMAGE="${IMAGE_DIR}/${2}"
-shift
-shift
-FLAG_OVERRIDES="${@}"
-
-if [ ! -r "${BOOT_DESC_FILE}" ]; then
-  warn "${BOOT_DESC_FILE} cannot be read!"
-  warn "Falling back to command line parsing"
-  BOOT_DESC="${@}"
-else
-  BOOT_DESC="$(cat ${BOOT_DESC_FILE} | tr -s '\n' ' ')"
-  info "Boot-time configuration for $(dirname "${IMAGE}"): "
-  cat ${BOOT_DESC_FILE} | while read line; do
-    info "  ${line}"
-  done
-fi
-
-if [ ! -r "${IMAGE}" ]; then
-  die "${IMAGE} cannot be read!"
-fi
-
-
-locate_gpt
-set +e
-
-# Now parse the build settings from ${OUTPUT_DIR}/boot.desc
-DEFINE_string board "${DEFAULT_BOARD}" \
-  "Board we're building for."
-DEFINE_string image "coreos_base.img" \
-  "Full path to the coreos image to make bootable."
-DEFINE_string arch "x86" \
-  "Architecture to make bootable for: arm, x86, or amd64"
-DEFINE_string disk_layout "base" \
-  "The disk layout type to use for this image."
-DEFINE_boolean enable_rootfs_verification ${FLAGS_FALSE} \
-  "Default all bootloaders to NOT use kernel-based root fs integrity checking."
-DEFINE_string au_key "" \
-  "Filename of the au_key to install"
-DEFINE_string production_track "" \
-    "Use production values and a given track for update service."
-DEFINE_boolean fsck_rootfs ${FLAGS_FALSE} \
-  "Check integrity of the rootfs on the modified image."
-
-
-# Parse the boot.desc and any overrides
-eval set -- "${BOOT_DESC} ${FLAG_OVERRIDES}"
-FLAGS "${@}" || exit 1
-
-. "${BUILD_LIBRARY_DIR}/board_options.sh" || exit 1
-
-# Only now can we die on error.  shflags functions leak non-zero error codes,
-# so will die prematurely if 'switch_to_strict_mode' is specified before now.
-switch_to_strict_mode -u
-
-mount_gpt_cleanup() {
-  "${BUILD_LIBRARY_DIR}/disk_util" umount "${rootfs_mountpoint}" || true
-}
-
-make_image_bootable() {
-  local image="$1"
-
-  # Default to non-verified
-  local enable_rootfs_verification_flag=--noenable_rootfs_verification
-  if [[ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]]; then
-    enable_rootfs_verification_flag=--enable_rootfs_verification
-  fi
-
-  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${FLAGS_disk_layout}" \
-      mount "${image}" "${rootfs_mountpoint}"
-  trap "mount_gpt_cleanup" EXIT
-
-  if [ -n "${FLAGS_production_track}" ]; then
-    # Replace /etc/lsb-release on the image.
-    "${BUILD_LIBRARY_DIR}/set_lsb_release" \
-      --production_track="${FLAGS_production_track}" \
-      --root="${rootfs_mountpoint}" \
-      --board="${BOARD}"
-  fi
-
-  # Install an auto update key on the root before sealing it off
-  if [ ! -z "${FLAGS_au_key}" ]; then
-    local key_location=${rootfs_mountpoint}"/usr/share/update_engine/"
-    sudo mkdir -p "${key_location}"
-    sudo cp "${FLAGS_au_key}" "$key_location/update-payload-key.pub.pem"
-    sudo chown root:root "$key_location/update-payload-key.pub.pem"
-    sudo chmod 644 "$key_location/update-payload-key.pub.pem"
-    echo "AU verification key was installed. Do not forget to resign the image!"
-  fi
-
-  # The rootfs should never be mounted rw again after this point without
-  # re-calling make_image_bootable.
-  sudo mount -o remount,ro "${rootfs_mountpoint}"
-  # Newer `mount` will decode the filename backing the loop device,
-  # so we need to dig deeper and find the answer ourselves.
-  root_dev=$(awk -v mnt="${rootfs_mountpoint}" \
-             '$2 == mnt { print $1 }' /proc/mounts)
-
-  # Make the filesystem un-mountable as read-write.
-  # TODO(wad) make sure there is parity in the signing scripts.
-  if [ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]; then
-    # TODO(wad) this would be a good place to reset any other ext2 metadata.
-    warn "Disabling r/w mount of the root filesystem"
-    disable_rw_mount "$root_dev"
-  fi
-
-  trap - EXIT
-  "${BUILD_LIBRARY_DIR}/disk_util" umount "${rootfs_mountpoint}"
-}
-
-verify_image_rootfs() {
-  local image=$1
-  local rootfs_offset="$(partoffset ${image} 3)"
-
-  local rootfs_tmp_file=$(mktemp)
-  trap "rm ${rootfs_tmp_file}" EXIT
-  sudo dd if="${image}" of="${rootfs_tmp_file}" bs=512 skip="${rootfs_offset}" \
-          status=none
-
-  # This flips the read-only compatibility flag, so that
-  # e2fsck does not complain about unknown file system capabilities.
-  enable_rw_mount "${rootfs_tmp_file}"
-  info "Running e2fsck to check root file system for errors"
-  sudo e2fsck -fn "${rootfs_tmp_file}" ||
-    die "Root file system has errors, please ensure boot.desc and/or \
-command line parameters are correct"
-}
-
-# Store output and temporary files next to image.
-rootfs_mountpoint="${IMAGE_DIR}/rootfs_dir"
-
-# Create the directories if they don't exist.
-mkdir -p ${rootfs_mountpoint}
-
-make_image_bootable "${IMAGE}"
-if [ ${FLAGS_fsck_rootfs} -eq ${FLAGS_TRUE} ]; then
-  verify_image_rootfs "${IMAGE}"
-fi
-
-rmdir ${rootfs_mountpoint}
diff --git a/build_image b/build_image
index a69e5315d0..5b3554056f 100755
--- a/build_image
+++ b/build_image
@@ -76,6 +76,7 @@ check_gsutil_opts
 . "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/base_image_util.sh" || exit 1
+. "${BUILD_LIBRARY_DIR}/prod_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/dev_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/test_image_content.sh" || exit 1
 
@@ -145,12 +146,8 @@ fi
 if should_build_image ${COREOS_PRODUCTION_IMAGE_NAME}; then
   copy_image ${CHROMEOS_BASE_IMAGE_NAME} ${COREOS_PRODUCTION_IMAGE_NAME}
 
-  ${SCRIPTS_DIR}/bin/cros_make_image_bootable \
-    "${BUILD_DIR}" \
-     ${COREOS_PRODUCTION_IMAGE_NAME} \
-    --production_track="dev-channel" \
-    --disk_layout="${FLAGS_disk_layout}" \
-    --au_key=${SRC_ROOT}/third_party/coreos-overlay/coreos-base/coreos-au-key/files/update-payload-key.pub.pem
+  setup_prod_image ${COREOS_PRODUCTION_IMAGE_NAME} "dev-channel" \
+    ${SRC_ROOT}/third_party/coreos-overlay/coreos-base/coreos-au-key/files/update-payload-key.pub.pem
 
   upload_image "${BUILD_DIR}/${COREOS_PRODUCTION_IMAGE_NAME}"
 fi
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 7b9206410b..2d3c27191a 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -51,11 +51,6 @@ create_base_image() {
   --root="${root_fs_dir}" \
   --board="${BOARD}"
 
-  # Create the boot.desc file which stores the build-time configuration
-  # information needed for making the image bootable after creation with
-  # cros_make_image_bootable.
-  create_boot_desc
-
   ${BUILD_LIBRARY_DIR}/create_legacy_bootloader_templates.sh \
     --arch=${ARCH} \
     --boot_dir="${root_fs_dir}"/boot \
@@ -75,9 +70,5 @@ create_base_image() {
   # Emit helpful scripts for testers, etc.
   emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
 
-  ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-    "${image_name}" --disk_layout="${disk_layout}" \
-    --noenable_rootfs_verification
-
   trap - EXIT
 }
diff --git a/build_library/build_image_util.sh b/build_library/build_image_util.sh
index a3e8746277..517b3b4f0b 100755
--- a/build_library/build_image_util.sh
+++ b/build_library/build_image_util.sh
@@ -80,19 +80,6 @@ make_salt() {
   xxd -l 32 -p -c 32 /dev/urandom
 }
 
-create_boot_desc() {
-  local enable_rootfs_verification_flag=""
-  if [[ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]]; then
-    enable_rootfs_verification_flag="--enable_rootfs_verification"
-  fi
-
-  cat <<EOF > ${BUILD_DIR}/boot.desc
-  --board=${BOARD}
-  --arch="${ARCH}"
-  ${enable_rootfs_verification_flag}
-EOF
-}
-
 cleanup_mounts() {
   echo "Cleaning up mounts"
   "${BUILD_LIBRARY_DIR}/disk_util" umount "$1" || true
diff --git a/build_library/dev_image_util.sh b/build_library/dev_image_util.sh
index 574d96047a..ea624f2f59 100755
--- a/build_library/dev_image_util.sh
+++ b/build_library/dev_image_util.sh
@@ -45,13 +45,5 @@ install_dev_packages() {
   info "Developer image built and stored at ${image_name}"
 
   cleanup_mounts "${root_fs_dir}"
-  trap "delete_prompt" EXIT
-
-  if should_build_image ${image_name}; then
-    ${SCRIPTS_DIR}/bin/cros_make_image_bootable "${BUILD_DIR}" \
-      "${image_name}" --disk_layout="${disk_layout}" \
-      --noenable_rootfs_verification
-  fi
-
   trap - EXIT
 }
diff --git a/build_library/prod_image_util.sh b/build_library/prod_image_util.sh
new file mode 100755
index 0000000000..8129c4309b
--- /dev/null
+++ b/build_library/prod_image_util.sh
@@ -0,0 +1,47 @@
+# Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+# Copyright (c) 2013 The CoreOS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+setup_prod_image() {
+  local image_name="$1"
+  local update_track="$2"
+  local au_key="$3"
+
+  info "Configuring production image ${image_name}"
+  local disk_layout="${FLAGS_disk_layout:-base}"
+  local root_fs_dir="${BUILD_DIR}/rootfs"
+  local enable_rootfs_verification_flag=--noenable_rootfs_verification
+  if [[ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]]; then
+    enable_rootfs_verification_flag=--enable_rootfs_verification
+  fi
+
+  "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+      mount "${BUILD_DIR}/${image_name}" "${root_fs_dir}"
+  trap "cleanup_mounts '${root_fs_dir}' && delete_prompt" EXIT
+
+  # Replace /etc/lsb-release on the image.
+  "${BUILD_LIBRARY_DIR}/set_lsb_release" \
+    --production_track="${update_track}" \
+    --root="${root_fs_dir}" \
+    --board="${BOARD}"
+
+  # Install an auto update key on the root before sealing it off
+  local key_location=${root_fs_dir}"/usr/share/update_engine/"
+  sudo mkdir -p "${key_location}"
+  sudo cp "${au_key}" "$key_location/update-payload-key.pub.pem"
+  sudo chown root:root "$key_location/update-payload-key.pub.pem"
+  sudo chmod 644 "$key_location/update-payload-key.pub.pem"
+
+  # Make the filesystem un-mountable as read-write.
+  if [ ${FLAGS_enable_rootfs_verification} -eq ${FLAGS_TRUE} ]; then
+    warn "Disabling r/w mount of the root filesystem"
+    sudo mount -o remount,ro "${root_fs_dir}"
+    root_dev=$(awk -v mnt="${root_fs_dir}" \
+               '$2 == mnt { print $1 }' /proc/mounts)
+    disable_rw_mount "$root_dev"
+  fi
+
+  cleanup_mounts "${root_fs_dir}"
+  trap - EXIT
+}

From 8e0d6306999af4a4bc7808dd165db6b6cca800c9 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Mon, 30 Dec 2013 16:32:37 -0800
Subject: [PATCH 16/29] fix(image_to_vm): Remove support for alternate state fs
 image.

We haven't really needed this, remove the option to simplify things.
---
 build_library/vm_image_util.sh | 15 ++-------------
 image_to_vm.sh                 |  6 ++----
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/build_library/vm_image_util.sh b/build_library/vm_image_util.sh
index 03d1bd7289..f7b74f45db 100644
--- a/build_library/vm_image_util.sh
+++ b/build_library/vm_image_util.sh
@@ -195,17 +195,10 @@ _disk_ext() {
     esac
 }
 
-# Unpack the source disk to individual partitions, optionally using an
-# alternate filesystem image for the state partition instead of the one
-# from VM_SRC_IMG. Start new image using the given disk layout.
+# Unpack the source disk to individual partitions.
+# Start new image using the given disk layout.
 unpack_source_disk() {
     get_disk_layout_type $(_get_vm_opt DISK_LAYOUT)
-    local alternate_state_image="$1"
-
-    if [[ -n "${alternate_state_image}" && ! -f "${alternate_state_image}" ]]
-    then
-        die "State image does not exist: $alternate_state_image"
-    fi
 
     info "Unpacking source image to $(relpath "${VM_TMP_DIR}")"
 
@@ -222,10 +215,6 @@ unpack_source_disk() {
     TEMP_OEM="${VM_TMP_DIR}"/part_${NUM_OEM}
     TEMP_ROOTFS="${VM_TMP_DIR}"/part_${NUM_ROOTFS_A}
     TEMP_STATE="${VM_TMP_DIR}"/part_${NUM_STATEFUL}
-    # Copy the replacement STATE image if it is set
-    if [[ -n "${alternate_state_image}" ]]; then
-        cp --sparse=always "${alternate_state_image}" "${TEMP_STATE}"
-    fi
 
     if [[ $(_get_vm_opt PARTITIONED_IMG) -eq 1 ]]; then
       info "Initializing new partition table..."
diff --git a/image_to_vm.sh b/image_to_vm.sh
index 149b791d79..b7a7cafd5f 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -39,8 +39,6 @@ DEFINE_string disk_layout "" \
   "The disk layout type to use for this image."
 DEFINE_integer mem "${DEFAULT_MEM}" \
   "Memory size for the vm config in MBs."
-DEFINE_string state_image "" \
-  "Stateful partition image (defaults to creating new statful partition)"
 DEFINE_boolean prod_image "${FLAGS_FALSE}" \
   "Use the production image instead of the default developer image."
 DEFINE_string to "" \
@@ -105,9 +103,9 @@ legacy_offset_size_export ${VM_SRC_IMG}
 # Make sure things are cleaned up on failure
 trap vm_cleanup EXIT
 
-# Unpack image, using alternate state image if defined
+# Unpack image
 # Resize to use all available space in new disk layout
-unpack_source_disk "${FLAGS_state_image}"
+unpack_source_disk
 resize_state_partition
 
 # Optionally install any OEM packages

From 5afd720956b58024f95207ec7c8a5b4678986a53 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 3 Jan 2014 16:37:48 -0800
Subject: [PATCH 17/29] fix(disk_util): Move existing image reading code to new
 function.

This will allow the code to be shared, making it possible to safely
resize existing images with disk_util.
---
 build_library/disk_util | 45 ++++++++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 12 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index f1b4514324..556970bfe4 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -178,6 +178,35 @@ def GetPartitionTableFromConfig(options):
   return partitions
 
 
+def GetPartitionTableFromImage(options):
+  """Loads very basic partition table info from an existing image.
+
+  Currently only includes blocks and first_block values.
+
+  Args:
+    options: Flags passed to the script
+  Returns:
+    A list defining all existing partitions.
+  """
+  partitions = {}
+  cgpt_show = subprocess.check_output(
+          ['cgpt', 'show', '-q', options.disk_image])
+  for line in cgpt_show.split('\n'):
+    if not line.strip():
+      continue
+    fields = line.split(None, 3)
+    if len(fields) != 4 or not all(f.isdigit() for f in fields[:3]):
+      raise Exception('Invalid output from cgpt show -q: %r' % line)
+
+    part_num = fields[2]
+    partitions[part_num] = {
+            'num': int(part_num),
+            'first_block': int(fields[0]),
+            'blocks': int(fields[1])}
+
+  return partitions
+
+
 def WritePartitionTable(options, config=None, partitions=None):
   """Writes the given partition table to a disk image or device.
 
@@ -347,20 +376,12 @@ def Mount(options):
   """
 
   config, partitions = LoadPartitionConfig(options)
+  image_parts = GetPartitionTableFromImage(options)
   mounts = {}
 
-  cgpt_show = subprocess.check_output(
-          ['cgpt', 'show', '-q', options.disk_image])
-  for line in cgpt_show.split('\n'):
-    if not line.strip():
-      continue
-    fields = line.split(None, 3)
-    if len(fields) != 4 or not all(f.isdigit() for f in fields[:3]):
-      raise Exception('Invalid output from cgpt show -q: %r' % line)
-
-    first_block = int(fields[0])
-    blocks = int(fields[1])
-    part_num = fields[2]
+  for part_num, image_part in image_parts.iteritems():
+    first_block = image_part['first_block']
+    blocks = image_part['blocks']
     part = partitions.get(part_num, {})
     path = part.get('mount', None)
     if not path or not path.startswith('/'):

From 805cc65ffd7b5894e8cb52c7e11d8656ead08621 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 3 Jan 2014 16:40:54 -0800
Subject: [PATCH 18/29] fix(disk_util): Add option to safely rewrite partition
 table.

write_gpt --update <img> will read an existing image and make sure all
existing partitions will not get moved or truncated in the new layout.
This is mostly useful for resizing the final partition or just rewriting
metadata like partition types and labels.
---
 build_library/disk_util | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 556970bfe4..6883a2df45 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -222,6 +222,18 @@ def WritePartitionTable(options, config=None, partitions=None):
   if not (config and partitions):
     config, partitions = LoadPartitionConfig(options)
 
+  # If we are not creating a fresh image all existing partitions must:
+  # - be defined in the new layout
+  # - start at the same position
+  # - be the same size or larger in the new layout
+  if not options.create:
+    old_parts = GetPartitionTableFromImage(options)
+    for part_num, old_part in old_parts.iteritems():
+      part = partitions.get(part_num, {})
+      if (old_part['first_block'] != part.get('first_block', -1) or
+          old_part['blocks'] > part.get('blocks', -1)):
+        raise InvalidLayout("New disk layout is incompatible existing image")
+
   Cgpt('create', '-c', '-s', config['metadata']['blocks'], options.disk_image)
 
   esp_number = None
@@ -618,7 +630,11 @@ def main(argv):
           help='disk layout type from the json file')
   actions = parser.add_subparsers(title='actions')
 
-  a = actions.add_parser('write_gpt', help='write gpt to new image')
+  a = actions.add_parser('write_gpt', help='write/update partition table')
+  a.add_argument('--create', action='store_true', default=True,
+          help='initialize new partition table')
+  a.add_argument('--update', action='store_false', dest='create',
+          help='update existing partition table')
   a.add_argument('--mbr_boot_code',
           help='path to mbr boot block, such as syslinux/gptmbr.bin')
   a.add_argument('disk_image', help='path to disk image file')
@@ -628,7 +644,7 @@ def main(argv):
   a.add_argument('--mbr_boot_code',
           help='path to mbr boot block, such as syslinux/gptmbr.bin')
   a.add_argument('disk_image', help='path to disk image file')
-  a.set_defaults(func=Format)
+  a.set_defaults(func=Format, create=True)
 
   a = actions.add_parser('mount', help='mount filesystems in image')
   a.add_argument('--read_only', '-r', help='mount filesystems read-only')

From ebc83599b387588e2c3ac914cc8bb9164d61f2b2 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 3 Jan 2014 17:59:15 -0800
Subject: [PATCH 19/29] fix(disk_util): Move loop device setup code to generic
 function

---
 build_library/disk_util | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 6883a2df45..77d14d5af9 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -4,6 +4,7 @@
 # found in the LICENSE file.
 
 import argparse
+import contextlib
 import json
 import os
 import subprocess
@@ -339,6 +340,22 @@ def FormatFat(part, device):
     print "Installed SYSLINUX to %s" % part['label']
 
 
+@contextlib.contextmanager
+def PartitionLoop(options, partition):
+  """Allocate (and automatically free) loop devices for a partition."""
+
+  loop_dev = subprocess.check_output(['sudo', 'losetup',
+      '--offset', str(partition['first_byte']),
+      '--sizelimit', str(partition['bytes']),
+      '--find', '--show', options.disk_image])
+  loop_dev = loop_dev.strip()
+
+  try:
+    yield loop_dev
+  finally:
+    Sudo(['losetup', '--detach', loop_dev])
+
+
 def Format(options):
   """Writes the given partition table and initialize fresh filesystems.
 
@@ -360,21 +377,13 @@ def Format(options):
     print "Formatting partition %s (%s) as %s" % (
             part['num'], part['label'], part['fs_type'])
 
-    loop_dev = subprocess.check_output(['sudo', 'losetup',
-        '--offset', str(part['first_byte']),
-        '--sizelimit', str(part['bytes']),
-        '--find', '--show', options.disk_image])
-    loop_dev = loop_dev.strip()
-
-    try:
+    with PartitionLoop(options, part) as loop_dev:
       if part['fs_type'] in ('ext2', 'ext4'):
         FormatExt(part, loop_dev)
       elif part['fs_type'] == 'vfat':
         FormatFat(part, loop_dev)
       else:
         raise Exception("Unhandled fs type %s" % part['fs_type'])
-    finally:
-      Sudo(['losetup', '--detach', loop_dev])
 
 
 def Mount(options):

From c992d45dd3d149ea76987d4e78e4efaa601b6dcd Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Fri, 3 Jan 2014 18:14:12 -0800
Subject: [PATCH 20/29] feat(disk_util): Add resize command.

Based on the new gpt update code add the ability to resize filesystems
in existing images. Usually just the last (STATE) partition is resized.
---
 build_library/disk_util | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/build_library/disk_util b/build_library/disk_util
index 77d14d5af9..3aef47706d 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -386,6 +386,29 @@ def Format(options):
         raise Exception("Unhandled fs type %s" % part['fs_type'])
 
 
+def Resize(options):
+  """Writes the given partition table and resize ext[234] filesystems.
+
+  Args:
+    options: Flags passed to the script
+  """
+
+  config, partitions = LoadPartitionConfig(options)
+  WritePartitionTable(options, config, partitions)
+
+  for part in partitions.itervalues():
+    if part.get('fs_type', None) not in ('ext2', 'ext4'):
+      continue
+
+    print "Resizing partition %s (%s) to %s bytes" % (
+            part['num'], part['label'], part['fs_bytes'])
+
+    with PartitionLoop(options, part) as loop_dev:
+      Sudo(['e2fsck', '-p', '-f', loop_dev], stdout_null=True)
+      Sudo(['resize2fs', loop_dev, str(part['fs_blocks'])])
+      Sudo(['tune2fs', '-U', 'clear', loop_dev], stdout_null=True)
+
+
 def Mount(options):
   """Mount the given disk image.
 
@@ -655,6 +678,12 @@ def main(argv):
   a.add_argument('disk_image', help='path to disk image file')
   a.set_defaults(func=Format, create=True)
 
+  a = actions.add_parser('resize', help='write gpt and resize filesystems')
+  a.add_argument('--mbr_boot_code',
+          help='path to mbr boot block, such as syslinux/gptmbr.bin')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.set_defaults(func=Resize, create=False)
+
   a = actions.add_parser('mount', help='mount filesystems in image')
   a.add_argument('--read_only', '-r', help='mount filesystems read-only')
   a.add_argument('disk_image', help='path to disk image file')

From 1ee1840a895bef883bbc182405a03ff89cbb1112 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 16:55:03 -0800
Subject: [PATCH 21/29] fix(disk_util): Fix mount --read_only option.

---
 build_library/disk_util | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 3aef47706d..e5f480d564 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -685,7 +685,8 @@ def main(argv):
   a.set_defaults(func=Resize, create=False)
 
   a = actions.add_parser('mount', help='mount filesystems in image')
-  a.add_argument('--read_only', '-r', help='mount filesystems read-only')
+  a.add_argument('--read_only', '-r', action='store_true',
+          help='mount filesystems read-only')
   a.add_argument('disk_image', help='path to disk image file')
   a.add_argument('mount_dir', help='path to root filesystem mount point')
   a.set_defaults(func=Mount)

From 89b61ac7b0c9c772c9d9441081d45125ef0c622d Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 19:48:10 -0800
Subject: [PATCH 22/29] fix(disk_util): Rework how code handles existing
 images.

Read partition size and offset into the normal partition config with the
prefix 'image_' for each key.
---
 build_library/disk_util | 81 +++++++++++++++++++++++------------------
 1 file changed, 45 insertions(+), 36 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index e5f480d564..32ab33ea71 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -179,7 +179,7 @@ def GetPartitionTableFromConfig(options):
   return partitions
 
 
-def GetPartitionTableFromImage(options):
+def GetPartitionTableFromImage(options, config, partitions):
   """Loads very basic partition table info from an existing image.
 
   Currently only includes blocks and first_block values.
@@ -189,7 +189,7 @@ def GetPartitionTableFromImage(options):
   Returns:
     A list defining all existing partitions.
   """
-  partitions = {}
+  block_size = config['metadata']['block_size']
   cgpt_show = subprocess.check_output(
           ['cgpt', 'show', '-q', options.disk_image])
   for line in cgpt_show.split('\n'):
@@ -199,13 +199,32 @@ def GetPartitionTableFromImage(options):
     if len(fields) != 4 or not all(f.isdigit() for f in fields[:3]):
       raise Exception('Invalid output from cgpt show -q: %r' % line)
 
-    part_num = fields[2]
-    partitions[part_num] = {
-            'num': int(part_num),
-            'first_block': int(fields[0]),
-            'blocks': int(fields[1])}
+    part = partitions.setdefault(fields[2], {})
+    part['image_first_block'] = int(fields[0])
+    part['image_first_byte'] = int(fields[0]) * block_size
+    part['image_blocks'] = int(fields[1])
+    part['image_bytes'] = int(fields[1]) * block_size
 
-  return partitions
+    # Pre-compute whether the image and config are compatible.
+    # The image is compatible with the config if each partition:
+    # - starts at the same position
+    # - is the same size or larger in th layout config
+
+    part['image_exists'] = True
+    if part.get('type', 'blank') == 'blank':
+      part['image_compat'] = False
+    elif part['first_block'] == part['image_first_block']:
+      part['image_compat'] = part['blocks'] >= part['image_blocks']
+    else:
+      part['image_compat'] = False
+
+  # Set compat flags for any partition not in the image
+  for part in partitions.itervalues():
+    part.setdefault('image_exists', False)
+    if part.get('type', 'blank') == 'blank':
+      part.setdefault('image_compat', True)
+    else:
+      part.setdefault('image_compat', False)
 
 
 def WritePartitionTable(options, config=None, partitions=None):
@@ -223,17 +242,11 @@ def WritePartitionTable(options, config=None, partitions=None):
   if not (config and partitions):
     config, partitions = LoadPartitionConfig(options)
 
-  # If we are not creating a fresh image all existing partitions must:
-  # - be defined in the new layout
-  # - start at the same position
-  # - be the same size or larger in the new layout
+  # If we are not creating a fresh image all partitions must be compatible.
   if not options.create:
-    old_parts = GetPartitionTableFromImage(options)
-    for part_num, old_part in old_parts.iteritems():
-      part = partitions.get(part_num, {})
-      if (old_part['first_block'] != part.get('first_block', -1) or
-          old_part['blocks'] > part.get('blocks', -1)):
-        raise InvalidLayout("New disk layout is incompatible existing image")
+    GetPartitionTableFromImage(options, config, partitions)
+    if not all(p['image_compat'] for p in partitions.itervalues()):
+      raise InvalidLayout("New disk layout is incompatible existing image")
 
   Cgpt('create', '-c', '-s', config['metadata']['blocks'], options.disk_image)
 
@@ -399,6 +412,8 @@ def Resize(options):
   for part in partitions.itervalues():
     if part.get('fs_type', None) not in ('ext2', 'ext4'):
       continue
+    elif part['bytes'] == part['image_bytes']:
+      continue
 
     print "Resizing partition %s (%s) to %s bytes" % (
             part['num'], part['label'], part['fs_bytes'])
@@ -420,45 +435,39 @@ def Mount(options):
   """
 
   config, partitions = LoadPartitionConfig(options)
-  image_parts = GetPartitionTableFromImage(options)
+  GetPartitionTableFromImage(options, config, partitions)
   mounts = {}
 
-  for part_num, image_part in image_parts.iteritems():
-    first_block = image_part['first_block']
-    blocks = image_part['blocks']
-    part = partitions.get(part_num, {})
+  for part_num, part in partitions.iteritems():
     path = part.get('mount', None)
     if not path or not path.startswith('/'):
       continue
+    if not part.get('image_exists', False):
+      continue
 
-    mounts[path] = {'path': path,
-                    'offset': first_block * config['metadata']['block_size'],
-                    'size': blocks * config['metadata']['block_size'],
-                    'type': part.get('fs_type', 'auto'),
-                    'binds': part.get('binds', {})}
+    mounts[path] = part
 
   rootfs = mounts.pop('/', None)
   if not rootfs:
     raise InvalidLayout('No partition defined to mount on /')
 
   def DoMount(mount):
-    full_path = os.path.realpath(options.mount_dir + mount['path'])
+    full_path = os.path.realpath(options.mount_dir + mount['mount'])
     mount_opts = ['loop',
-                  'offset=%d' % mount['offset'],
-                  'sizelimit=%d' % mount['size']]
+                  'offset=%d' % mount['image_first_byte'],
+                  'sizelimit=%d' % mount['image_bytes']]
     if options.read_only:
       mount_opts.append('ro')
-    else:
-      Sudo(['mkdir', '-p', full_path])
 
-    Sudo(['mount', '-t', mount['type'],
+    Sudo(['mkdir', '-p', full_path])
+    Sudo(['mount', '-t', mount.get('fs_type', 'auto'),
                    '-o', ','.join(mount_opts),
                    options.disk_image, full_path])
 
-    for src, dst in mount['binds'].iteritems():
+    for src, dst in mount.get('binds', {}).iteritems():
       # src may be relative or absolute, os.path.join handles this.
       full_src =  os.path.realpath(
-              options.mount_dir + os.path.join(mount['path'], src))
+              options.mount_dir + os.path.join(mount['mount'], src))
       full_dst = os.path.realpath(options.mount_dir + dst)
       Sudo(['mkdir', '-p', full_src, full_dst])
       Sudo(['mount', '--bind', full_src, full_dst])

From e066f91ca3d51c7fa0a51ffe3c801f3319199ad1 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 19:55:30 -0800
Subject: [PATCH 23/29] feat(disk_util): Add tune command, controlling fs
 read-only hack.

Now disk_util is aware of the weird ext2 read-only hack, both by
providing a command to manipulate it and support in the mount command to
automatically set the 'ro' mount option for filesystems with it.

Making mount aware of the hack makes it much easier to mount prod
images with a mix read-only and read-write filesystems.
---
 build_library/disk_util | 116 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)

diff --git a/build_library/disk_util b/build_library/disk_util
index 32ab33ea71..b562eda6b2 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -414,6 +414,8 @@ def Resize(options):
       continue
     elif part['bytes'] == part['image_bytes']:
       continue
+    elif not IsE2fsReadWrite(options, part):
+      continue
 
     print "Resizing partition %s (%s) to %s bytes" % (
             part['num'], part['label'], part['fs_bytes'])
@@ -458,6 +460,9 @@ def Mount(options):
                   'sizelimit=%d' % mount['image_bytes']]
     if options.read_only:
       mount_opts.append('ro')
+    elif (mount.get('fs_type', None) in ('ext2', 'ext4') and
+          not IsE2fsReadWrite(options, mount)):
+      mount_opts.append('ro')
 
     Sudo(['mkdir', '-p', full_path])
     Sudo(['mount', '-t', mount.get('fs_type', 'auto'),
@@ -485,6 +490,93 @@ def Umount(options):
   Sudo(['umount', '--recursive', '--detach-loop', options.mount_dir])
 
 
+def Tune2fsReadWrite(options, partition):
+  """Enable/Disable read-only hack.
+
+  From common.sh:
+  This helper clobbers the ro compat value in our root filesystem.
+
+  When the system is built with --enable_rootfs_verification, bit-precise
+  integrity checking is performed.  That precision poses a usability issue on
+  systems that automount partitions with recognizable filesystems, such as
+  ext2/3/4.  When the filesystem is mounted 'rw', ext2 metadata will be
+  automatically updated even if no other writes are performed to the
+  filesystem.  In addition, ext2+ does not support a "read-only" flag for a
+  given filesystem.  That said, forward and backward compatibility of
+  filesystem features are supported by tracking if a new feature breaks r/w or
+  just write compatibility.  We abuse the read-only compatibility flag[1] in
+  the filesystem header by setting the high order byte (le) to FF.  This tells
+  the kernel that features R24-R31 are all enabled.  Since those features are
+  undefined on all ext-based filesystem, all standard kernels will refuse to
+  mount the filesystem as read-write -- only read-only[2].
+
+  [1] 32-bit flag we are modifying:
+   http://git.chromium.org/cgi-bin/gitweb.cgi?p=kernel.git;a=blob;f=include/linux/ext2_fs.h#l417
+  [2] Mount behavior is enforced here:
+   http://git.chromium.org/cgi-bin/gitweb.cgi?p=kernel.git;a=blob;f=fs/ext2/super.c#l857
+
+  N.B., if the high order feature bits are used in the future, we will need to
+        revisit this technique.
+
+  Args:
+    options: Flags passed to the script
+    partition: Config for partition to manipulate
+  """
+
+  if options.disable2fs_rw:
+    print "Disabling read-write mounting of partition %s (%s)" % (
+            partition['num'], partition['label'])
+  else:
+    print "Enabling read-write mounting of partition %s (%s)" % (
+            partition['num'], partition['label'])
+
+  # offset of ro_compat, highest order byte (le 32 bit field)
+  flag_offset = 0x464 + 3
+  flag_value = 0xff if options.disable2fs_rw else 0x00
+  with open(options.disk_image, 'r+') as image:
+    image.seek(partition['first_byte'] + flag_offset)
+    image.write(chr(flag_value))
+
+
+def IsE2fsReadWrite(options, partition):
+  """Returns True if FS is read-write, False if hack is active.
+
+  Args:
+    options: Flags passed to the script
+    partition: Config for partition to query
+  """
+
+  # offset of ro_compat, highest order byte (le 32 bit field)
+  flag_offset = 0x464 + 3
+  with open(options.disk_image, 'r') as image:
+    image.seek(partition['first_byte'] + flag_offset)
+    flag_value = image.read(1)
+
+  return ord(flag_value) == 0
+
+
+def Tune(options):
+  """Tweak some filesystem options.
+
+  Args:
+    options: Flags passed to the script
+  """
+
+  config, partitions = LoadPartitionConfig(options)
+  GetPartitionTableFromImage(options, config, partitions)
+  part = GetPartition(partitions, options.partition)
+
+  if not part['image_compat']:
+    raise InvalidLayout("Disk layout is incompatible existing image")
+
+  if options.disable2fs_rw is not None:
+    if part.get('fs_type', None) not in ('ext2', 'ext4'):
+      raise Exception("Partition %s is not a ext2 or ext4" % options.partition)
+    Tune2fsReadWrite(options, part)
+  else:
+    raise Exception("No options specified!")
+
+
 def GetPartitionByNumber(partitions, num):
   """Given a partition table and number returns the partition object.
 
@@ -520,6 +612,21 @@ def GetPartitionByLabel(partitions, label):
   raise PartitionNotFound('Partition not found')
 
 
+def GetPartition(partitions, part_id):
+  """Given a partition table and label or num returns the partition object.
+
+  Args:
+    partitions: List of partitions to search in
+    part_id: Label or number of partition to find
+  Returns:
+    An object for the selected partition
+  """
+  if str(part_id).isdigit():
+    return GetPartitionByNumber(partitions, part_id)
+  else:
+    return GetPartitionByLabel(partitions, part_id)
+
+
 def GetBlockSize(options):
   """Returns the partition table block size.
 
@@ -704,6 +811,15 @@ def main(argv):
   a.add_argument('mount_dir', help='path to root filesystem mount point')
   a.set_defaults(func=Umount)
 
+  a = actions.add_parser('tune', help='tweak filesystem options')
+  a.add_argument('--disable2fs_rw', action='store_true', default=None,
+          help='disable mounting ext2 filesystems read-write')
+  a.add_argument('--enable2fs_rw', action='store_false', dest='disable2fs_rw',
+          help='re-enable mounting ext2 filesystems read-write')
+  a.add_argument('disk_image', help='path to disk image file')
+  a.add_argument('partition', help='number or label of partition to edit')
+  a.set_defaults(func=Tune)
+
   a = actions.add_parser('readblocksize', help='get device block size')
   a.set_defaults(func=GetBlockSize)
 

From bfcbb3f57f0ad87fe333dd61906b3d43d8f6c376 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 20:55:08 -0800
Subject: [PATCH 24/29] fix(image_to_vm): Move to disk_util, modify images
 in-place.

Avoid unpacking/repacking partitions by using disk_util's resize and
mount commands. Also simplify assorted bits along the way.
---
 build_library/vm_image_util.sh | 146 ++++++++-------------------------
 image_to_vm.sh                 |   6 +-
 2 files changed, 35 insertions(+), 117 deletions(-)

diff --git a/build_library/vm_image_util.sh b/build_library/vm_image_util.sh
index f7b74f45db..4b0c44a406 100644
--- a/build_library/vm_image_util.sh
+++ b/build_library/vm_image_util.sh
@@ -27,6 +27,7 @@ VM_IMG_TYPE=DEFAULT
 VM_SRC_IMG=
 VM_TMP_IMG=
 VM_TMP_DIR=
+VM_TMP_ROOT=
 VM_DST_IMG=
 VM_README=
 VM_NAME=
@@ -149,6 +150,7 @@ set_vm_paths() {
     VM_DST_IMG="${dst_dir}/${dst_name}"
     VM_TMP_DIR="${dst_dir}/${dst_name}.vmtmpdir"
     VM_TMP_IMG="${VM_TMP_DIR}/disk_image.bin"
+    VM_TMP_ROOT="${VM_TMP_DIR}/rootfs"
     VM_NAME="$(_src_to_dst_name "${src_name}" "")-${COREOS_VERSION_STRING}"
     VM_UUID=$(uuidgen)
     VM_README="${dst_dir}/$(_src_to_dst_name "${src_name}" ".README")"
@@ -195,93 +197,46 @@ _disk_ext() {
     esac
 }
 
-# Unpack the source disk to individual partitions.
-# Start new image using the given disk layout.
-unpack_source_disk() {
-    get_disk_layout_type $(_get_vm_opt DISK_LAYOUT)
-
-    info "Unpacking source image to $(relpath "${VM_TMP_DIR}")"
+setup_disk_image() {
+    local disk_layout="${1:-$(_get_vm_opt DISK_LAYOUT)}"
 
     rm -rf "${VM_TMP_DIR}"
-    mkdir -p "${VM_TMP_DIR}"
+    mkdir -p "${VM_TMP_DIR}" "${VM_TMP_ROOT}"
 
-    pushd "${VM_TMP_DIR}" >/dev/null
-    local src_dir=$(dirname "${VM_SRC_IMG}")
-    "${src_dir}/unpack_partitions.sh" "${VM_SRC_IMG}"
-    popd >/dev/null
-
-    # Partition paths that have been unpacked from VM_SRC_IMG
-    TEMP_ESP="${VM_TMP_DIR}"/part_${NUM_ESP}
-    TEMP_OEM="${VM_TMP_DIR}"/part_${NUM_OEM}
-    TEMP_ROOTFS="${VM_TMP_DIR}"/part_${NUM_ROOTFS_A}
-    TEMP_STATE="${VM_TMP_DIR}"/part_${NUM_STATEFUL}
+    info "Initializing new disk image..."
+    cp --sparse=always "${VM_SRC_IMG}" "${VM_TMP_IMG}"
 
     if [[ $(_get_vm_opt PARTITIONED_IMG) -eq 1 ]]; then
-      info "Initializing new partition table..."
-      write_partition_table "${VM_TMP_IMG}"
-    fi
-}
-
-resize_state_partition() {
-    get_disk_layout_type $(_get_vm_opt DISK_LAYOUT)
-    local size_in_bytes=$(get_filesystem_size ${NUM_STATEFUL})
-    local size_in_sectors=$(( size_in_bytes / 512 ))
-    local size_in_mb=$(( size_in_bytes / 1024 / 1024 ))
-    local original_size=$(stat -c%s "${TEMP_STATE}")
-
-    if [[ "${original_size}" -gt "${size_in_bytes}" ]]; then
-        die "Cannot resize state image to smaller than original."
+      # TODO(marineam): Fix this so --mbr_boot_code isn't required
+      local mbr_img="/usr/share/syslinux/gptmbr.bin"
+      "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+          resize --mbr_boot_code="${mbr_img}" "${VM_TMP_IMG}"
     fi
 
-    info "Resizing state partition to ${size_in_mb}MB"
-    /sbin/e2fsck -pf "${TEMP_STATE}"
-    /sbin/resize2fs "${TEMP_STATE}" "${size_in_sectors}s"
+    info "Mounting image to $(relpath "${VM_TMP_ROOT}")"
+    "${BUILD_LIBRARY_DIR}/disk_util" --disk_layout="${disk_layout}" \
+        mount "${VM_TMP_IMG}" "${VM_TMP_ROOT}"
 }
 
 # If the current type defines a oem package install it to the given fs image.
 install_oem_package() {
     local oem_pkg=$(_get_vm_opt OEM_PACKAGE)
-    local oem_mnt="${VM_TMP_DIR}/oem"
+    local oem_mnt="${VM_TMP_ROOT}/usr/share/oem"
 
     if [[ -z "${oem_pkg}" ]]; then
         return 0
     fi
 
-    mkdir -p "${oem_mnt}"
-
-    # Install directly to root if this is not a partitioned image
-    if [[ $(_get_vm_opt PARTITIONED_IMG) -eq 0 ]]; then
-      emerge_oem_package "${oem_mnt}"
-      return 0
-    fi
-
-    sudo mount -o loop "${TEMP_OEM}" "${oem_mnt}"
-    emerge_oem_package ${oem_mnt}
-    sudo umount "${oem_mnt}"
-    rm -rf "${oem_mnt}"
-}
-
-emerge_oem_package() {
-    local oem_pkg=$(_get_vm_opt OEM_PACKAGE)
-
     info "Installing ${oem_pkg} to OEM partition"
-    # TODO(polvi): figure out how to keep portage from putting these
-    # portage files on disk, we don't need or want them.
-    emerge-${BOARD} --root="$1" --root-deps=rdeps "${oem_pkg}"
+    emerge-${BOARD} --root="${oem_mnt}" --root-deps=rdeps "${oem_pkg}"
+    sudo rm -rf "${oem_mnt}/var"  # clean out /var/pkg/db and friends
 }
 
 # Write the vm disk image to the target directory in the proper format
 write_vm_disk() {
     if [[ $(_get_vm_opt PARTITIONED_IMG) -eq 1 ]]; then
-      info "Writing partitions to new disk image"
-      dd if="${TEMP_ROOTFS}" of="${VM_TMP_IMG}" conv=notrunc,sparse \
-          bs=512 seek=$(partoffset ${VM_TMP_IMG} ${NUM_ROOTFS_A})
-      dd if="${TEMP_STATE}"  of="${VM_TMP_IMG}" conv=notrunc,sparse \
-          bs=512 seek=$(partoffset ${VM_TMP_IMG} ${NUM_STATEFUL})
-      dd if="${TEMP_ESP}"    of="${VM_TMP_IMG}" conv=notrunc,sparse \
-          bs=512 seek=$(partoffset ${VM_TMP_IMG} ${NUM_ESP})
-      dd if="${TEMP_OEM}"    of="${VM_TMP_IMG}" conv=notrunc,sparse \
-          bs=512 seek=$(partoffset ${VM_TMP_IMG} ${NUM_OEM})
+        # unmount before creating block device images
+        cleanup_mounts "${VM_TMP_ROOT}"
     fi
 
     if [[ $(_get_vm_opt HYBRID_MBR) -eq 1 ]]; then
@@ -327,60 +282,23 @@ _write_vmdk_scsi_disk() {
     qemu-img convert -f raw "$1" -O vmdk -o adapter_type=lsilogic "$2"
 }
 
-# the cpio is a little complicated because everything gets put into one
-# ramfs. So, it does a lot more work at the write disk step. 
+# The cpio "disk" is a bit special,
+# consists of a kernel+initrd not a block device
 _write_cpio_disk() {
     local cpio_target="${VM_TMP_DIR}/rootcpio"
-
-    if [ -f "$2" ]; then
-      rm $2
-    fi
-
-    # Create the cpio with squashfs embedded
-    _write_squashfs_root ${cpio_target}
-
-    # Create the cpio and gzip it
-    local cpio=${VM_TMP_DIR}/root.cpio
-    _write_dir_to_cpio "${cpio_target}" "${cpio}"
-    gzip < ${cpio} > $2
-    rm -rf "${cpio_target}"
-}
-
-_write_dir_to_cpio() {
-    pushd "$1" >/dev/null
-
-    append_flag=""
-    if [ -f "$2" ]; then
-      append_flag="-A"
-    fi
-    sudo find ./ | sudo cpio -o ${append_flag} -H newc -O "$2"
-    popd >/dev/null
-}
-
-_write_squashfs_root() {
-    local cpio_target="$1"
-    local root_mnt="${VM_TMP_DIR}/rootfs"
-    local oem_mnt="${VM_TMP_DIR}/oem"
     local dst_dir=$(_dst_dir)
     local vmlinuz_name="$(_dst_name ".vmlinuz")"
 
-    mkdir -p "${root_mnt}"
+    # Build the squashfs, embed squashfs into a gzipped cpio
     mkdir -p "${cpio_target}"
+    pushd "${cpio_target}" >/dev/null
+    sudo mksquashfs "${VM_TMP_ROOT}" ./newroot.squashfs
+    echo ./newroot.squashfs | cpio -o -H newc | gzip > "$2"
+    popd >/dev/null
 
-    # Roll the rootfs into the build dir
-    sudo mount -o loop,ro "${TEMP_ROOTFS}" "${root_mnt}"
-
-    # Roll the OEM into the build dir
-    sudo mount --bind "${oem_mnt}" "${root_mnt}"/usr/share/oem
-    # Build the squashfs
-    sudo mksquashfs "${root_mnt}" "${cpio_target}"/newroot.squashfs
-
-    cp "${root_mnt}"/boot/vmlinuz "${dst_dir}/${vmlinuz_name}"
-
-    sudo umount "${root_mnt}"/usr/share/oem
-    sudo umount "${root_mnt}"
-
-    sudo rm -rf "${root_mnt}"
+    # Pull the kernel out of the root filesystem
+    cp "${VM_TMP_ROOT}"/boot/vmlinuz "${dst_dir}/${vmlinuz_name}"
+    VM_GENERATED_FILES+=( "${dst_dir}/${vmlinuz_name}" )
 }
 
 # If a config format is defined write it!
@@ -427,7 +345,6 @@ EOF
 
 _write_pxe_conf() {
     local dst_name=$(basename "$VM_DST_IMG")
-    local dst_dir=$(_dst_dir)
     local vmlinuz_name="$(_dst_name ".vmlinuz")"
 
     cat >"${VM_README}" <<EOF
@@ -438,7 +355,7 @@ If you have qemu installed (or in the SDK), you can start the image with:
 
 EOF
 
-    VM_GENERATED_FILES+=( "${dst_dir}/${vmlinuz_name}" "${VM_README}" )
+    VM_GENERATED_FILES+=( "${VM_README}" )
 }
 
 # Generate the vmware config file
@@ -701,6 +618,9 @@ _write_gce_conf() {
 
 vm_cleanup() {
     info "Cleaning up temporary files"
+    if mountpoint -q "${VM_TMP_ROOT}"; then
+        cleanup_mounts "${VM_TMP_ROOT}"
+    fi
     sudo rm -rf "${VM_TMP_DIR}"
 }
 
diff --git a/image_to_vm.sh b/image_to_vm.sh
index b7a7cafd5f..52a9beaedf 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -103,10 +103,8 @@ legacy_offset_size_export ${VM_SRC_IMG}
 # Make sure things are cleaned up on failure
 trap vm_cleanup EXIT
 
-# Unpack image
-# Resize to use all available space in new disk layout
-unpack_source_disk
-resize_state_partition
+# Setup new (raw) image, possibly resizing filesystems
+setup_disk_image "${FLAGS_disk_layout}"
 
 # Optionally install any OEM packages
 install_oem_package

From 15eead682ba78717509eb392c2a62126f7679359 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 21:17:06 -0800
Subject: [PATCH 25/29] cleanup(build_library): Remove old disk_layout_util.sh

All of this code can go away now.
---
 build_image                                   |   1 -
 build_library/base_image_util.sh              |   5 -
 .../create_legacy_bootloader_templates.sh     |   6 +-
 build_library/disk_layout_util.sh             | 272 ------------------
 image_to_vm.sh                                |   1 -
 5 files changed, 3 insertions(+), 282 deletions(-)
 delete mode 100644 build_library/disk_layout_util.sh

diff --git a/build_image b/build_image
index 5b3554056f..af1d1869c9 100755
--- a/build_image
+++ b/build_image
@@ -73,7 +73,6 @@ check_gsutil_opts
 # some of the files contain initialization used by later files.
 . "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/board_options.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/base_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/prod_image_util.sh" || exit 1
diff --git a/build_library/base_image_util.sh b/build_library/base_image_util.sh
index 2d3c27191a..27e7f47986 100755
--- a/build_library/base_image_util.sh
+++ b/build_library/base_image_util.sh
@@ -65,10 +65,5 @@ create_base_image() {
   fi
 
   cleanup_mounts "${root_fs_dir}"
-  trap "delete_prompt" EXIT
-
-  # Emit helpful scripts for testers, etc.
-  emit_gpt_scripts "${BUILD_DIR}/${image_name}" "${BUILD_DIR}"
-
   trap - EXIT
 }
diff --git a/build_library/create_legacy_bootloader_templates.sh b/build_library/create_legacy_bootloader_templates.sh
index d205a374da..2845d840dd 100755
--- a/build_library/create_legacy_bootloader_templates.sh
+++ b/build_library/create_legacy_bootloader_templates.sh
@@ -28,14 +28,14 @@ FLAGS "$@" || exit 1
 eval set -- "${FLAGS_ARGV}"
 switch_to_strict_mode
 
-# Useful for getting partition UUID values
-. "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
-
 # Common kernel command-line args
 common_args="console=tty0 ro noswap cros_legacy"
 common_args="${common_args} ${FLAGS_boot_args}"
 
 # Get partition UUIDs from the json config
+get_uuid() {
+  "${BUILD_LIBRARY_DIR}/disk_util" readuuid "$1"
+}
 ROOTA="PARTUUID=$(get_uuid ROOT-A)"
 ROOTB="PARTUUID=$(get_uuid ROOT-B)"
 
diff --git a/build_library/disk_layout_util.sh b/build_library/disk_layout_util.sh
deleted file mode 100644
index e89cbf33e4..0000000000
--- a/build_library/disk_layout_util.sh
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright (c) 2012 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.
-
-CGPT_PY="${BUILD_LIBRARY_DIR}/disk_util"
-
-cgpt_py() {
-  "${CGPT_PY}" "$@"
-}
-
-write_partition_table() {
-  local outdev=$1
-
-  local pmbr_img
-  case ${ARCH} in
-  arm)
-    pmbr_img=/dev/zero
-    ;;
-  amd64|x86)
-    pmbr_img=$(readlink -f /usr/share/syslinux/gptmbr.bin)
-    ;;
-  *)
-    error "Unknown architecture: $ARCH"
-    return 1
-    ;;
-  esac
-
-  cgpt_py write_gpt --mbr_boot_code="${pmbr_img}" "${outdev}"
-}
-
-get_fs_block_size() {
-  cgpt_py readfsblocksize
-}
-
-get_block_size() {
-  cgpt_py readblocksize
-}
-
-get_partition_size() {
-  local part_id=$1
-
-  cgpt_py readpartsize ${part_id}
-}
-
-get_filesystem_size() {
-  local part_id=$1
-
-  cgpt_py readfssize ${part_id}
-}
-
-get_label() {
-  local part_id=$1
-
-  cgpt_py readlabel ${part_id}
-}
-
-get_num() {
-  local label=$1
-
-  cgpt_py readnum ${label}
-}
-
-get_uuid() {
-  local label=$1
-
-  cgpt_py readuuid ${label}
-}
-
-check_valid_layout() {
-  cgpt_py parseonly > /dev/null
-}
-
-get_disk_layout_type() {
-  DISK_LAYOUT_TYPE="${1:-base}"
-  if [[ -n "${FLAGS_disk_layout}" && \
-      "${FLAGS_disk_layout}" != "default" ]]; then
-    DISK_LAYOUT_TYPE="${FLAGS_disk_layout}"
-  fi
-  export DISK_LAYOUT_TYPE
-}
-
-emit_gpt_scripts() {
-  local image="$1"
-  local dir="$2"
-
-  local pack="${dir}/pack_partitions.sh"
-  local unpack="${dir}/unpack_partitions.sh"
-  local mount="${dir}/mount_image.sh"
-  local umount="${dir}/umount_image.sh"
-
-  local start size part x
-
-  cat >"${unpack}" <<EOF
-#!/bin/bash -eu
-# File automatically generated. Do not edit.
-TARGET=\${1:-}
-if [[ -z \${TARGET} ]]; then
-  echo "Usage: \$0 <image>" 1>&2
-  echo "Example: \$0 $COREOS_IMAGE_NAME" 1>&2
-  exit 1
-fi
-set -x
-$(${GPT} show "${image}" | sed -e 's/^/# /')
-EOF
-
-  for x in "${pack}" "${mount}" "${umount}"; do
-    cp "${unpack}" "${x}"
-  done
-
-  while read start size part x; do
-    local file="part_${part}"
-    local dir="dir_${part}"
-    local target='"${TARGET}"'
-    local dd_args="bs=512 count=${size} conv=sparse"
-    local start_b=$(( start * 512 ))
-    local size_b=$(( size * 512 ))
-    echo "dd if=${target} of=${file} ${dd_args} skip=${start}" >>"${unpack}"
-    echo "dd if=${file} of=${target} ${dd_args} seek=${start} conv=notrunc" \
-      >>"${pack}"
-    if [[ ${size} -gt 1 ]]; then
-      cat <<-EOF >>"${mount}"
-mkdir -p ${dir}
-m=( sudo mount -o loop,offset=${start_b},sizelimit=${size_b} ${target} ${dir} )
-if ! "\${m[@]}"; then
-  if ! "\${m[@]}" -o ro; then
-    rmdir ${dir}
-  fi
-fi
-EOF
-      cat <<-EOF >>"${umount}"
-if [[ -d ${dir} ]]; then
-  sudo umount ${dir} || :
-  rmdir ${dir}
-fi
-EOF
-    fi
-  done < <(${GPT} show -q "${image}")
-
-  chmod +x "${unpack}" "${pack}" "${mount}" "${umount}"
-}
-
-build_gpt() {
-  local outdev="$1"
-  local rootfs_img="$2"
-  local stateful_img="$3"
-  local esp_img="$4"
-  local oem_img="$5"
-
-  get_disk_layout_type
-  write_partition_table "${outdev}"
-
-  local sudo=
-  if [ ! -w "$outdev" ] ; then
-    # use sudo when writing to a block device.
-    sudo=sudo
-  fi
-
-  local root_fs_label="ROOT-A"
-  local root_fs_num=$(get_num ${image_type} ${root_fs_label})
-
-  local stateful_fs_label="STATE"
-  local stateful_fs_num=$(get_num ${image_type} ${stateful_fs_label})
-
-  local esp_fs_label="EFI-SYSTEM"
-  local esp_fs_num=$(get_num ${image_type} ${esp_fs_label})
-
-  local oem_fs_label="OEM"
-  local oem_fs_num=$(get_num ${image_type} ${oem_fs_label})
-
-  # Now populate the partitions.
-  info "Copying stateful partition..."
-  $sudo dd if="$stateful_img" of="$outdev" conv=notrunc,sparse bs=512 \
-      seek=$(partoffset ${outdev} ${stateful_fs_num}) status=none
-
-  info "Copying rootfs..."
-  $sudo dd if="$rootfs_img" of="$outdev" conv=notrunc,sparse bs=512 \
-      seek=$(partoffset ${outdev} ${root_fs_num}) status=none
-
-  info "Copying EFI system partition..."
-  $sudo dd if="$esp_img" of="$outdev" conv=notrunc,sparse bs=512 \
-      seek=$(partoffset ${outdev} ${esp_fs_num}) status=none
-
-  info "Copying OEM partition..."
-  $sudo dd if="$oem_img" of="$outdev" conv=notrunc,sparse bs=512 \
-      seek=$(partoffset ${outdev} ${oem_fs_num}) status=none
-
-  # Pre-set "sucessful" bit in gpt, so we will never mark-for-death
-  # a partition on an SDCard/USB stick.
-  cgpt add -i 2 -S 1 "$outdev"
-}
-
-# Rebuild an image's partition table with new stateful size.
-#  $1: source image filename
-#  $2: source stateful partition image filename
-#  $3: number of sectors to allocate to the new stateful partition
-#  $4: destination image filename
-# Used by dev/host/tests/mod_recovery_for_decryption.sh and
-# mod_image_for_recovery.sh.
-update_partition_table() {
-  local src_img=$1              # source image
-  local src_state=$2            # stateful partition image
-  local dst_stateful_blocks=$3  # number of blocks in resized stateful partition
-  local dst_img=$4
-
-  rm -f "${dst_img}"
-
-  # Calculate change in image size.
-  local src_stateful_blocks=$(cgpt show -i 1 -s ${src_img})
-  local delta_blocks=$(( dst_stateful_blocks - src_stateful_blocks ))
-  local dst_stateful_bytes=$(( dst_stateful_blocks * 512 ))
-  local src_stateful_bytes=$(( src_stateful_blocks * 512 ))
-  local src_size=$(stat -c %s ${src_img})
-  local dst_size=$(( src_size - src_stateful_bytes + dst_stateful_bytes ))
-  truncate -s ${dst_size} ${dst_img}
-
-  # Copy MBR, initialize GPT.
-  dd if="${src_img}" of="${dst_img}" conv=notrunc bs=512 count=1 status=none
-  cgpt create ${dst_img}
-
-  # Find partition number of STATE (really should always be "1")
-  local part=0
-  local label=""
-  while [ "${label}" != "STATE" ]; do
-    part=$(( part + 1 ))
-    local label=$(cgpt show -i ${part} -l ${src_img})
-    local src_start=$(cgpt show -i ${part} -b ${src_img})
-    if [ ${src_start} -eq 0 ]; then
-      echo "Could not find 'STATE' partition" >&2
-      return 1
-    fi
-  done
-  local src_state_start=$(cgpt show -i ${part} -b ${src_img})
-
-  # Duplicate each partition entry.
-  part=0
-  while :; do
-    part=$(( part + 1 ))
-    local src_start=$(cgpt show -i ${part} -b ${src_img})
-    if [ ${src_start} -eq 0 ]; then
-      # No more partitions to copy.
-      break
-    fi
-    local dst_start=${src_start}
-    # Load source partition details.
-    local size=$(cgpt show -i ${part} -s ${src_img})
-    local label=$(cgpt show -i ${part} -l ${src_img})
-    local attr=$(cgpt show -i ${part} -A ${src_img})
-    local tguid=$(cgpt show -i ${part} -t ${src_img})
-    local uguid=$(cgpt show -i ${part} -u ${src_img})
-    # Change size of stateful.
-    if [ "${label}" = "STATE" ]; then
-      size=${dst_stateful_blocks}
-    fi
-    # Partitions located after STATE need to have their start moved.
-    if [ ${src_start} -gt ${src_state_start} ]; then
-      dst_start=$(( dst_start + delta_blocks ))
-    fi
-    # Add this partition to the destination.
-    cgpt add -i ${part} -b ${dst_start} -s ${size} -l "${label}" -A ${attr} \
-             -t ${tguid} -u ${uguid} ${dst_img}
-    if [ "${label}" != "STATE" ]; then
-      # Copy source partition as-is.
-      dd if="${src_img}" of="${dst_img}" conv=notrunc,sparse bs=512 \
-        skip=${src_start} seek=${dst_start} count=${size} status=none
-    else
-      # Copy new stateful partition into place.
-      dd if="${src_state}" of="${dst_img}" conv=notrunc,sparse bs=512 \
-        seek=${dst_start} status=none
-    fi
-  done
-  return 0
-}
diff --git a/image_to_vm.sh b/image_to_vm.sh
index 52a9beaedf..3c77700ad4 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -13,7 +13,6 @@
 SCRIPT_ROOT=$(dirname "$(readlink -f "$0")")
 . "${SCRIPT_ROOT}/common.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/disk_layout_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_common.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/vm_image_util.sh" || exit 1

From 35462565973e94dc9c1f869c879abfafda5d57c6 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sat, 4 Jan 2014 21:39:31 -0800
Subject: [PATCH 26/29] fix(vm_image_util): Unmount STATE before making
 squashfs

---
 build_library/vm_image_util.sh | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/build_library/vm_image_util.sh b/build_library/vm_image_util.sh
index 4b0c44a406..b4b5eb1299 100644
--- a/build_library/vm_image_util.sh
+++ b/build_library/vm_image_util.sh
@@ -289,6 +289,12 @@ _write_cpio_disk() {
     local dst_dir=$(_dst_dir)
     local vmlinuz_name="$(_dst_name ".vmlinuz")"
 
+    # The STATE partition and all of its bind mounts shouldn't be
+    # packed into the squashfs image. Just ROOT and OEM.
+    if mountpoint -q "${VM_TMP_ROOT}/media/state"; then
+        sudo umount --all-targets "${VM_TMP_ROOT}/media/state"
+    fi
+
     # Build the squashfs, embed squashfs into a gzipped cpio
     mkdir -p "${cpio_target}"
     pushd "${cpio_target}" >/dev/null

From ba532952b1f7298ad494ebedb3528aa08d48ef9c Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sun, 5 Jan 2014 13:55:52 -0800
Subject: [PATCH 27/29] fix(disk_util): Fix layout inheritance in config
 verification.

---
 build_library/disk_util | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index b562eda6b2..3bf722ece7 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -79,12 +79,13 @@ def LoadPartitionConfig(options):
       for int_key in integer_layout_keys.intersection(part_keys):
         part[int_key] = int(part[int_key])
 
+      if base:
+        part_base = base.get(part_num, {})
+        part_keys.update(part_base.iterkeys())
+
       if part.get('type', None) == 'blank':
         continue
 
-      if base:
-        part_keys.update(base.iterkeys())
-
       missing_keys = required_layout_keys - part_keys
       if missing_keys:
         raise InvalidLayout('Missing items in partition %s %s: %s' %

From 19ecd4572f1e467c9b9c18db222cf74f81d17417 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sun, 5 Jan 2014 18:09:25 -0800
Subject: [PATCH 28/29] fix(disk_util): Sort mount order instead of special
 casing /

Now that /usr is a mount point we need to make sure it gets mounted
before /usr/share/oem. Simply sorting by path length works well enough.
---
 build_library/disk_util | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/build_library/disk_util b/build_library/disk_util
index 3bf722ece7..a022b08173 100755
--- a/build_library/disk_util
+++ b/build_library/disk_util
@@ -450,8 +450,7 @@ def Mount(options):
 
     mounts[path] = part
 
-  rootfs = mounts.pop('/', None)
-  if not rootfs:
+  if '/' not in mounts:
     raise InvalidLayout('No partition defined to mount on /')
 
   def DoMount(mount):
@@ -478,9 +477,8 @@ def Mount(options):
       Sudo(['mkdir', '-p', full_src, full_dst])
       Sudo(['mount', '--bind', full_src, full_dst])
 
-  DoMount(rootfs)
-  for mount in mounts.itervalues():
-    DoMount(mount)
+  for mount in sorted(mounts, key=len):
+    DoMount(mounts[mount])
 
 def Umount(options):
   """Unmount the given path.

From e84f922ba5430851fe534273c4947ebcc7e8c8e7 Mon Sep 17 00:00:00 2001
From: Michael Marineau <michael.marineau@coreos.com>
Date: Sun, 5 Jan 2014 18:26:55 -0800
Subject: [PATCH 29/29] fix(build_library): remove references to
 chromeos-common.sh

Nothing from chromeos-common.sh is needed for image building now. Also
kill off build_common.sh which was just a weird way of sourcing
common.sh. The two piddly functions it provided fit better in
build_image_util.sh
---
 build_image                       |  2 +-
 build_library/build_common.sh     | 49 -------------------------------
 build_library/build_image_util.sh | 29 ++++++++++++++++++
 image_to_vm.sh                    | 10 -------
 4 files changed, 30 insertions(+), 60 deletions(-)
 delete mode 100644 build_library/build_common.sh

diff --git a/build_image b/build_image
index af1d1869c9..e033414df0 100755
--- a/build_image
+++ b/build_image
@@ -10,7 +10,7 @@
 # build the Chrome OS image using only pre-built binary packages.
 
 SCRIPT_ROOT=$(dirname $(readlink -f "$0"))
-. "${SCRIPT_ROOT}/build_library/build_common.sh" || exit 1
+. "${SCRIPT_ROOT}/common.sh" || exit 1
 
 # Developer-visible flags.
 DEFINE_string board "${DEFAULT_BOARD}" \
diff --git a/build_library/build_common.sh b/build_library/build_common.sh
deleted file mode 100644
index 92e2ee6391..0000000000
--- a/build_library/build_common.sh
+++ /dev/null
@@ -1,49 +0,0 @@
-# Copyright (c) 2011 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.
-
-# Common library file to be sourced by build_image,
-# mod_image_for_test.sh, and mod_image_for_recovery.sh.  This
-# file ensures that library source files needed by all the scripts
-# are included once, and also takes care of certain bookeeping tasks
-# common to all the scripts.
-
-# SCRIPT_ROOT must be set prior to sourcing this file
-. "${SCRIPT_ROOT}/common.sh" || exit 1
-
-# All scripts using this file must be run inside the chroot.
-restart_in_chroot_if_needed "$@"
-
-INSTALLER_ROOT=/usr/lib/installer
-. "${INSTALLER_ROOT}/chromeos-common.sh" || exit 1
-
-locate_gpt
-
-should_build_image() {
-  # Fast pass back if we should build all incremental images.
-  local image_name
-  local image_to_build
-
-  for image_name in "$@"; do
-    for image_to_build in ${IMAGES_TO_BUILD}; do
-      [ "${image_to_build}" = "${image_name}" ] && return 0
-    done
-  done
-
-  return 1
-}
-
-# Utility function for creating a copy of an image prior to
-# modification from the BUILD_DIR:
-#  $1: source filename
-#  $2: destination filename
-copy_image() {
-  local src="${BUILD_DIR}/$1"
-  local dst="${BUILD_DIR}/$2"
-  if should_build_image $1; then
-    echo "Creating $2 from $1..."
-    cp --sparse=always "${src}" "${dst}" || die "Cannot copy $1 to $2"
-  else
-    mv "${src}" "${dst}" || die "Cannot move $1 to $2"
-  fi
-}
diff --git a/build_library/build_image_util.sh b/build_library/build_image_util.sh
index 517b3b4f0b..fb46c20975 100755
--- a/build_library/build_image_util.sh
+++ b/build_library/build_image_util.sh
@@ -55,6 +55,35 @@ parse_build_image_args() {
   get_images_to_build ${FLAGS_ARGV}
 }
 
+should_build_image() {
+  # Fast pass back if we should build all incremental images.
+  local image_name
+  local image_to_build
+
+  for image_name in "$@"; do
+    for image_to_build in ${IMAGES_TO_BUILD}; do
+      [ "${image_to_build}" = "${image_name}" ] && return 0
+    done
+  done
+
+  return 1
+}
+
+# Utility function for creating a copy of an image prior to
+# modification from the BUILD_DIR:
+#  $1: source filename
+#  $2: destination filename
+copy_image() {
+  local src="${BUILD_DIR}/$1"
+  local dst="${BUILD_DIR}/$2"
+  if should_build_image $1; then
+    echo "Creating $2 from $1..."
+    cp --sparse=always "${src}" "${dst}" || die "Cannot copy $1 to $2"
+  else
+    mv "${src}" "${dst}" || die "Cannot move $1 to $2"
+  fi
+}
+
 check_blacklist() {
   info "Verifying that the base image does not contain a blacklisted package."
   info "Generating list of packages for ${BASE_PACKAGE}."
diff --git a/image_to_vm.sh b/image_to_vm.sh
index 3c77700ad4..d2bf6823b5 100755
--- a/image_to_vm.sh
+++ b/image_to_vm.sh
@@ -13,15 +13,8 @@
 SCRIPT_ROOT=$(dirname "$(readlink -f "$0")")
 . "${SCRIPT_ROOT}/common.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/toolchain_util.sh" || exit 1
-. "${BUILD_LIBRARY_DIR}/build_common.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/build_image_util.sh" || exit 1
 . "${BUILD_LIBRARY_DIR}/vm_image_util.sh" || exit 1
-
-# Need to be inside the chroot to load chromeos-common.sh
-assert_inside_chroot
-
-# Load functions and constants for chromeos-install
-. /usr/lib/installer/chromeos-common.sh || exit 1
 . "${SCRIPT_ROOT}/lib/cros_vm_constants.sh" || exit 1
 
 # Flags
@@ -96,9 +89,6 @@ else
   set_vm_paths "${FLAGS_from}" "${FLAGS_to}" "${CHROMEOS_IMAGE_NAME}"
 fi
 
-locate_gpt
-legacy_offset_size_export ${VM_SRC_IMG}
-
 # Make sure things are cleaned up on failure
 trap vm_cleanup EXIT