Create EFI System Partition on USB image during build.

src/platform/installer/chromeos-common.sh

 # 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.
 #
 # This contains common constants and functions for installer scripts. This must
 # evaluate properly for both /bin/bash and /bin/sh, since it's used both to
 # create the initial image at compile time and to install or upgrade a running
 # image.
 
 # Here are the GUIDs we'll be using to identify various partitions.
@@ skipping 10 matching lines @@
 # This returns the size of a file or device in 512-byte sectors, rounded up if
 # needed.
 # Invoke as: subshell
 # Args: FILENAME
 # Return: whole number of sectors needed to fully contain FILENAME
 numsectors() {
   case $1 in
   /dev/*[0-9])
     dnum=${1##*/}
     dev=${dnum%%[0-9]*}
-    cat /sys/block/$dev/$dnum/size 
+    cat /sys/block/$dev/$dnum/size
     ;;
   /dev/*)
     dev=${1##*/}
-    cat /sys/block/$dev/size 
+    cat /sys/block/$dev/size
     ;;
   *)
     local bytes=$(stat -c%s "$1")
     local sectors=$(( $bytes / 512 ))
     local rem=$(( $bytes % 512 ))
     if [ $rem -ne 0 ]; then
       sectors=$(( $sectors + 1 ))
     fi
     echo $sectors
     ;;
-  esac    
+  esac
 }
 
 # Round a number of 512-byte sectors up to an integral number of 4096-byte
 # blocks.
 # Invoke as: subshell
 # Args: SECTORS
 # Return: Next largest multiple-of-8 sectors (ex: 4->8, 33->40, 32->32)
 roundup() {
   local num=$1
   local rem=$(( $num % 8 ))
@@ skipping 31 matching lines @@
     echo "can't find gpt tool" 1>&2
     exit 1
   fi
 fi
 
 
 # This installs a GPT into the specified device or file, using the given
 # components. If the target is a block device or the FORCE_FULL arg is "true"
 # we'll do a full install. Otherwise, it'll be just enough to boot.
 # Invoke as: command (not subshell)
-# Args: TARGET ROOTFS_IMG KERNEL_IMG STATEFUL_IMG PMBRCODE FORCE_FULL
+# Args: TARGET ROOTFS_IMG KERNEL_IMG STATEFUL_IMG PMBRCODE ESP_IMG FORCE_FULL
 # Return: nothing
 # Side effects: Sets these global variables describing the GPT partitions
 #   (all untis are 512-byte sectors):
 #   NUM_KERN_SECTORS
 #   NUM_ROOTFS_SECTORS
 #   NUM_STATEFUL_SECTORS
 #   NUM_RESERVED_SECTORS
+#   NUM_ESP_SECTORS
 #   START_KERN_A
 #   START_STATEFUL
 #   START_ROOTFS_A
 #   START_KERN_B
 #   START_ROOTFS_B
 #   START_RESERVED
+#   START_ESP
 install_gpt() {
   local outdev=$1
   local rootfs_img=$2
   local kernel_img=$3
   local stateful_img=$4
   local pmbrcode=$5
-  local force_full="${6:-}"
+  local esp_img=$6
+  local force_full="${7:-}"
 
   # The gpt tool requires a fixed-size target to work on, so we may have to
   # create a file of the appropriate size. Let's figure out what that size is
   # now. The partition layout is gonna look something like this:
   #
   #   PMBR (512 bytes)
   #   Primary GPT Header (512 bytes)
   #   Primary GPT Table (16K)
   #   Kernel A                                        partition 2
   #   Kernel B                                        partition 4
@@ skipping 13 matching lines @@
   # the size of the stateful partition.
   #
   # One nonobvious contraint is that the ext2-based filesystems typically use
   # 4096-byte blocks. We'll need a little padding at each end of the disk to
   # align the useable space to that size boundary.
 
   # Here are the size limits that we're currently requiring
   local max_kern_sectors=32768        # 16M
   local max_rootfs_sectors=2097152    # 1G
   local max_reserved_sectors=131072   # 64M
+  local max_esp_sectors=32768         # 16M
   local min_stateful_sectors=262144   # 128M, expands to fill available space
 
   local num_pmbr_sectors=1
   local num_gpt_hdr_sectors=1
   local num_gpt_table_sectors=32              # 16K
   local num_footer_sectors=$(($num_gpt_hdr_sectors + $num_gpt_table_sectors))
   local num_header_sectors=$(($num_pmbr_sectors + $num_footer_sectors))
 
   local start_useful=$(roundup $num_header_sectors)
 
   # What are we doing?
   if [ -b "$outdev" -o "$force_full" = "true" ]; then
     # Block device, need to be root.
     if [ -b "$outdev" ]; then
       local sudo=sudo
     else
       local sudo=""
     fi
 
     # Full install, use max sizes and create both A & B images.
     NUM_KERN_SECTORS=$max_kern_sectors
     NUM_ROOTFS_SECTORS=$max_rootfs_sectors
+    NUM_ESP_SECTORS=$max_esp_sectors
     NUM_RESERVED_SECTORS=$max_reserved_sectors
 
     # Where do things go?
     START_KERN_A=$start_useful
     START_KERN_B=$(($START_KERN_A + $NUM_KERN_SECTORS))
-    START_RESERVED=$(($START_KERN_B + $NUM_KERN_SECTORS))
+    START_ESP=$(($START_KERN_B + $NUM_KERN_SECTORS))
+    START_RESERVED=$(($START_ESP + $NUM_ESP_SECTORS))
     START_STATEFUL=$(($START_RESERVED + $NUM_RESERVED_SECTORS))
 
     local total_sectors=$(numsectors $outdev)
     local start_gpt_footer=$(($total_sectors - $num_footer_sectors))
     local end_useful=$(rounddown $start_gpt_footer)
 
     START_ROOTFS_A=$(($end_useful - $NUM_ROOTFS_SECTORS))
     START_ROOTFS_B=$(($START_ROOTFS_A - $NUM_ROOTFS_SECTORS))
 
     NUM_STATEFUL_SECTORS=$(($START_ROOTFS_B - $START_STATEFUL))
   else
     # Just a local file.
     local sudo=
 
     # We'll only populate partitions 1, 2, 3. Image B isn't required for this,
     # and the others are still theoretical.
     NUM_KERN_SECTORS=$(roundup $(numsectors $kernel_img))
     NUM_ROOTFS_SECTORS=$(roundup $(numsectors $rootfs_img))
     NUM_STATEFUL_SECTORS=$(roundup $(numsectors $stateful_img))
+    NUM_ESP_SECTORS=$(roundup $(numsectors $esp_img))
     NUM_RESERVED_SECTORS=0
 
     START_KERN_A=$start_useful
-    START_STATEFUL=$(($START_KERN_A + $NUM_KERN_SECTORS))
+    START_ESP=$(($START_KERN_A + $NUM_KERN_SECTORS))
+    START_STATEFUL=$(($START_ESP + $NUM_ESP_SECTORS))
     START_ROOTFS_A=$(($START_STATEFUL + $NUM_STATEFUL_SECTORS))
     START_KERN_B=""
     START_ROOTFS_B=""
     START_RESERVED=""
 
     # For minimal install, we're not worried about the secondary GPT header
     # being at the end of the device because we're almost always writing to a
     # file. If that's not true, the secondary will just be invalid.
     local start_gpt_footer=$(($START_ROOTFS_A + $NUM_ROOTFS_SECTORS))
     local end_useful=$start_gpt_footer
 
     local total_sectors=$(($start_gpt_footer + $num_footer_sectors))
 
     # Create the image file if it doesn't exist.
     if [ ! -e ${outdev} ]; then
       dd if=/dev/zero of=${outdev} bs=512 count=1 seek=$(($total_sectors - 1))
     fi
   fi
 
   echo "Creating partition tables..."
 
   # Zap any old partitions (otherwise gpt complains).
   $sudo dd if=/dev/zero of=${outdev} conv=notrunc bs=512 \
     count=$num_header_sectors
   $sudo dd if=/dev/zero of=${outdev} conv=notrunc bs=512 \
     seek=${start_gpt_footer} count=$num_footer_sectors
-  
+
   # Create the new GPT partitions. The order determines the partition number.
   # Note that the partition label is in the GPT only. The filesystem label is
   # what's used to populate /dev/disk/by-label/, and this is not that.
   $sudo $GPT create ${outdev}
-  
+
   $sudo $GPT add -b ${START_STATEFUL} -s ${NUM_STATEFUL_SECTORS} \
     -t ${STATEFUL_GUID} ${outdev}
   $sudo $GPT label -i 1 -l "STATE" ${outdev}
-  
+
   $sudo $GPT add -b ${START_KERN_A} -s ${NUM_KERN_SECTORS} \
     -t ${KERN_GUID} ${outdev}
   $sudo $GPT label -i 2 -l "KERN-A" ${outdev}
-  
+
   $sudo $GPT add -b ${START_ROOTFS_A} -s ${NUM_ROOTFS_SECTORS} \
     -t ${ROOTFS_GUID} ${outdev}
   $sudo $GPT label -i 3 -l "ROOT-A" ${outdev}
-  
+
   # add the rest of the partitions for a full install
   if [ -n "$START_KERN_B" ]; then
     $sudo $GPT add -b ${START_KERN_B} -s ${NUM_KERN_SECTORS} \
       -t ${KERN_GUID} ${outdev}
     $sudo $GPT label -i 4 -l "KERN-B" ${outdev}
-   
+
     $sudo $GPT add -b ${START_ROOTFS_B} -s ${NUM_ROOTFS_SECTORS} \
       -t ${ROOTFS_GUID} ${outdev}
     $sudo $GPT label -i 5 -l "ROOT-B" ${outdev}
   fi
 
+  # add the ESP partition
+  $sudo $GPT add -b ${START_ESP} -s ${NUM_ESP_SECTORS} \
+    -t ${ESP_GUID} ${outdev}
+  # FIXME: no label because I've lost count of the partition number
+  # I'll fix this when I've modified gpt to accept a label arg to 'add'.
+
   # Create the PMBR and instruct it to boot ROOT-A
   $sudo $GPT boot -i 3 -b ${pmbrcode} ${outdev}
-  
+
   # Display what we've got
   $sudo $GPT -r show -l ${outdev}
 
   sync
 }
 
 
 # Helper function, please ignore and look below.
 _partinfo() {
   local device=$1
@@ skipping 38 matching lines @@
 # Args: DEVICE PARTNUM
 # Returns: size (in sectors) of partition PARTNUM
 partsize() {
   # get string
   local X="$(_partinfo $1 $2)"
   # detect success or failure here
   [ -n "$X" ]
   echo ${X#* }
 }