Check for enough room in /tmp, warn about too-small USB drives.

user_tools/linux/recovery.sh

 #!/bin/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 attempts to guide linux users through the process of putting a recovery
 # image onto a removeable USB drive.
 #
 # We may not need root privileges if we have the right permissions.
@@ skipping 10 matching lines @@
 
 # Where do we look for the config file? Note that we can override this by just
 # specifying the config file URL on the command line.
 CONFIGURL="${1:-https://dl.google.com/dl/edgedl/chromeos/recovery/recovery.conf}"
 
 # Device to put this stuff on, perhaps the user knows best?
 DEVICE="${DEVICE:-}"
 
 # What version is this script? It must match the 'recovery_tool_version=' value
 # in the config file that we'll download.
-MYVERSION='0.9.1'
+MYVERSION='0.9.2'
 
 
 ##############################################################################
 # Some temporary filenames
 debug='debug.log'
 tmpfile='tmp.txt'
 config='config.txt'
 version='version.txt'
 
 ##############################################################################
@@ skipping 59 matching lines @@
 #
 # This also sets the following global variables to select alternative utilities
 # when there is more than one equivalent tool available:
 #
 #   FETCH          = name of utility used to download files from the web
 #   CHECK          = command to invoke to generate checksums on a file
 #   CHECKTYPE      = type of checksum generated
 #   DISKUTIL       = set if we have 'diskutil' (for Macs)
 #
 require_utils() {
-  local external
+  local extern
   local errors
   local tool
   local tmp
 
-  external='cat cut dd grep ls mkdir mount readlink sed sync umount unzip wc'
+  extern='awk cat cut dd grep ls mkdir mount readlink sed sync umount unzip wc'
   if [ -z "$WORKDIR" ]; then
-    external="$external mktemp"
+    extern="$extern mktemp"
   fi
   errors=
 
-  for tool in $external ; do
+  for tool in $extern ; do
     if ! type "$tool" >/dev/null 2>&1 ; then
       warn "ERROR: need \"$tool\""
       errors=yes
     fi
   done
 
   # We also need to a way to fetch files from teh internets. Note that the args
   # are different depending on which utility we find. We'll use two variants,
   # one to fetch fresh every time and one to try again from where we left off.
   FETCH=
@@ skipping 98 matching lines @@
     openssl md5 < "$filename"
   else
     $CHECK "$zipfile" | cut -d' ' -f1
   fi
 }
 
 
 ##############################################################################
 # Helper functions to handle the config file and image zipfile.
 
+# Convert bytes to MB, rounding up to determine storage needed to hold bytes.
+roundup() {
+  local num=$1
+  local div=$(( 1024 * 1024 ))
+  local rem=$(( $num % $div ))
+
+  if [ $rem -ne 0 ]; then
+    num=$(($num + $div - $rem))
+  fi
+  echo $(( $num / $div ))
+}
+
+
+# Die unless the filesystem containing the current directory has enough free
+# space. The argument is the number of MB required.
+verify_tmp_space() {
+  local need
+  local got
+  need="$1"
+
+  # The output of "df -m ." could take two forms:
+  #
+  # Filesystem           1M-blocks      Used Available Use% Mounted on
+  # /some/really/long/path/to/some/where
+  #                          37546     11118     24521  32% /
+  #
+  # Filesystem         1048576-blocks      Used Available Capacity Mounted on
+  # /some/short/path         37546     11118     24521      32% /
+  #
+  got=$(df -m . | awk '/^\/[^ ]+ +[0-9]/ {print $4} /^ +[0-9]/ {print $3}')
+
+  if [ "$need" -gt "$got" ]; then
+    fatal " There is not enough free space in ${WORKDIR}" \
+"(it has ${got}MB, we need ${need}MB).
+
+Please free up some space on that filesystem, or specify a temporary directory
+on the commandline like so:
+
+  WORKDIR=/path/to/some/dir  $0
+"
+  fi
+}
+
+
 # Each paragraph in the config file should describe a new image. Let's make
 # sure it follows all the rules. This scans the config file and returns success
 # if it looks valid. As a side-effect, it lists the line numbers of the start
 # and end of each stanza in the global variables 'start_lines' and 'end_lines'
 # and saves the total number of images in the global variable 'num_images'.
 good_config() {
   local line
   local key
   local val
   local name
@@ skipping 195 matching lines @@
     fi
   done
   echo
 
   # global
   user_choice="$num"
 }
 
 # Fetch and verify the user's chosen image. On success, it sets the global
 # variable 'image_file' to indicate the local name of the unpacked binary that
-# should be written to the USB drive.
+# should be written to the USB drive. It also sets the global variable
+# 'disk_needed' to the minimum capacity of the USB drive required (in MB).
 fetch_image() {
   local start
   local end
   local line
   local key
   local val
   local file
   local zipfilesize
   local filesize
   local url
@@ skipping 43 matching lines @@
         filesize)
           filesize="$val"
           ;;
         md5)
           md5="$val"
           ;;
         sha1)
           sha1="$val"
           ;;
         url)
+          # Make sure we have enough temp space available. Die if we don't.
+          verify_tmp_space $(roundup $(( $zipfilesize + $filesize )))
           # Try to download each url until one works.
           if [ -n "$url" ]; then
             # We've already got one (it's very nice).
             continue;
           fi
           warn "Downloading image zipfile from $val"
           warn ""
           zipfile=${val##*/}
           if fetch_url "$val" "$zipfile" "resumeok"; then
             # Got it.
@@ skipping 32 matching lines @@
     return 1
   fi
 
   if ! ls -l "$file" | grep -q "$filesize"; then
     DEBUG "unpacked filesize is wrong"
     return 1
   fi
 
   # global
   image_file="$file"
+  disk_needed=$(roundup "$filesize")
 }
 
 ##############################################################################
 # Helper functions to manage USB drives.
 
 # Return a list of base device names ("sda sdb ...") for all USB drives
 get_devlist() {
   local dev
   local t
   local r
@@ skipping 16 matching lines @@
       t=$(cat "/sys/block/$dev/device/type") &&
       [ "$t" = "0" ] &&
       r=$(cat "/sys/block/$dev/removable") &&
       [ "$r" = "1" ] &&
       readlink -f "/sys/block/$dev" | grep -q -i usb &&
       echo "$dev" || true
     done
   fi
 }
 
+# Return the raw size in MB of each provided base device name ("sda sdb ...")
+get_devsize() {
+  local dev
+  local bytes
+  local sectors
+
+  # Are we on a mac?
+  if [ -n "$DISKUTIL" ]; then
+    for dev in $1; do
+      bytes=$(diskutil info $dev | \
+        awk '/\([0-9]+ Bytes\)/' | sed -E 's/.*\(([0-9]+) Bytes\).*/\1/')
+      echo $(( $bytes / 1024 / 1024))
+    done
+  else
+    for dev in $1; do
+      sectors=$(cat "/sys/block/$dev/size")
+      echo $(( $sectors * 512 / 1024 / 1024 ))
+    done
+  fi
+}
+
+
 # Return descriptions for each provided base device name ("sda sdb ...")
 get_devinfo() {
   local dev
   local v
   local m
   local s
   local ss
 
   # Are we on a mac?
   if [ -n "$DISKUTIL" ]; then
@@ skipping 45 matching lines @@
   while true; do
     if [ -n "$show" ]; then
       devlist=$(get_devlist)
       choices=$(get_choices "$devlist")
       if [ -z "$devlist" ]; then
         num_drives="0"
         msg="I can't seem to find a valid USB drive."
       else
         num_drives=$(echo "$devlist" | wc -l)
         if [ "$num_drives" != "1" ]; then
-          msg="I found $num_drives USB drives"
+          msg="I found $num_drives USB drives."
         else
-          msg="I found $num_drives USB drive"
+          msg="I found $num_drives USB drive."
         fi
       fi
       echo "
 
-$msg
+$msg  We need one with at least ${disk_needed}MB capacity.
 
 $choices
+
 "
       show=
     fi
     prompt "Tell me what to do (or just press Enter to scan again): "
     read num
     if [ -z "$num" ] || [ "$num" = "?" ]; then
       show=yes
     elif echo "$num" | grep -q '[^0-9]'; then
       echo "Sorry, I didn't understand that."
     else
@@ skipping 83 matching lines @@
 if [ -n "$DEVICE" ]; then
   user_choice="${DEVICE#/dev/}"
   dev_desc="${DEVICE}"
 else
   # Make the user pick a USB drive, or exit.
   choose_drive
 
   # Be sure
   dev_desc=$(get_devinfo "$user_choice")
 fi
+
+# Start asking for confirmation
+dev_size=$(get_devsize "$user_choice")
+if [ "$dev_size" -lt "$disk_needed" ]; then
+  echo "
+
+WARNING: This drive seems too small (${dev_size}MB)." \
+  "The recovery image is ${disk_needed}MB."
+fi
 echo "
 Is this the device you want to put the recovery image on?
 
   $dev_desc
 "
 prompt "You must enter 'YES' (all uppercase) to continue: "
 read tmp
 if [ "$tmp" != "YES" ]; then
   quit
 fi
@@ skipping 45 matching lines @@
 prompt "Shall I remove the temporary files now? [y/n] "
 read tmp
 case $tmp in
   [Yy]*)
     cd
     \rm -rf ${WORKDIR}
     ;;
 esac
 
 exit 0