Allow RO rootfs and writeable stateful.

mount_gpt_image.sh

 #!/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.
 
 # 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).
 
 . "$(dirname "$0")/common.sh"
 
 # For functions related to gpt images.
 . "$(dirname "$0")/chromeos-common.sh"
 locate_gpt
 
 get_default_board
 
 # 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 containing image or device with image on it" f
 DEFINE_string image "chromiumos_image.bin"\
   "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" "" \
@@ skipping 24 matching lines @@
   if [[ -n "${FLAGS_esp_mountpt}" ]]; then
     sudo umount -d "${FLAGS_esp_mountpt}"
   fi
   sudo umount -d "${FLAGS_stateful_mountpt}"
   sudo umount -d "${FLAGS_rootfs_mountpt}"
   set -e
 }
 
 function 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 ${ro_flag} "${FLAGS_from}3" "${FLAGS_rootfs_mountpt}"
+  sudo mount ${safe_flag} "${FLAGS_from}3" "${FLAGS_rootfs_mountpt}"
   sudo mount ${ro_flag} "${FLAGS_from}1" "${FLAGS_stateful_mountpt}"
   if [[ -n "${FLAGS_esp_mountpt}" ]]; then
     sudo mount ${ro_flag} "${FLAGS_from}12" "${FLAGS_esp_mountpt}"
   fi
 }
 
 function get_gpt_partitions() {
   local filename="${FLAGS_image}"
 
   # Mount the rootfs partition using a loopback device.
   local offset=$(partoffset "${FLAGS_from}/${filename}" 3)
   local ro_flag=""
+  local safe_flag=""
+
   if [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} ]; then
     ro_flag="-o ro"
+  fi
+
+  if [ ${FLAGS_read_only} -eq ${FLAGS_TRUE} -o \
+       ${FLAGS_safe} -eq ${FLAGS_TRUE} ]; then
+    safe_flag="-o ro -t ext2"
   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
 
-  sudo mount ${ro_flag} -o loop,offset=$(( offset * 512 )) \
+  sudo mount ${safe_flag} -o loop,offset=$(( offset * 512 )) \
     "${FLAGS_from}/${filename}" "${FLAGS_rootfs_mountpt}"
 
   # Mount the stateful partition using a loopback device.
   offset=$(partoffset "${FLAGS_from}/${filename}" 1)
   sudo mount ${ro_flag} -o loop,offset=$(( offset * 512 )) \
     "${FLAGS_from}/${filename}" "${FLAGS_stateful_mountpt}"
 
   # Mount the stateful partition using a loopback device.
   if [[ -n "${FLAGS_esp_mountpt}" ]]; then
     offset=$(partoffset "${FLAGS_from}/${filename}" 12)
@@ skipping 17 matching lines @@
     get_gpt_partitions
   fi
 
   # Mount directories and setup symlinks.
   sudo mount --bind "${FLAGS_stateful_mountpt}/var" \
     "${FLAGS_rootfs_mountpt}/var"
   sudo mount --bind "${FLAGS_stateful_mountpt}/dev_image" \
     "${FLAGS_rootfs_mountpt}/usr/local"
   # Setup symlinks in /usr/local so you can emerge packages into /usr/local.
 
-  if [ ${FLAGS_read_only} -eq ${FLAGS_FALSE} ]; then
+  if [ ${FLAGS_read_only} -eq ${FLAGS_FALSE} -a \

[sosa, 2010/11/16 23:04:24]

Should be -o FLAGS_safe = true ... if the stateful partition is mounted rw ever
this should be run.

[Nick Sanders, 2010/11/17 00:15:33]

What does this do exactly, why do we want to write onto the stateful partition?

On 2010/11/16 23:04:24, sosa wrote:

[sosa, 2010/11/17 00:32:38]

In a nutshell, there are symlinks in /usr/local (i.e.
/mnt/stateful_partition/dev_image) that allow someone to emerge something with
--root=/usr/local.  It does things likes redirects /usr/local/usr/bin ->
/usr/local/bin, etc.  
These symlinks are setup on a finished image to run on the image (i.e. rooted
from /).  When we want to add packages on a build system onto an image ... we
have to replace / with the build root on the host.

Anyway, if someone wants to emerge something to /usr/local, they should be able
to do it using --safe and root=/tmp/s/usr/local (the equivlanent of what we do
in build_image).  Otherwise (if they try) they will emerge stuff into their own
/usr/local on their host system.

On 2010/11/17 00:15:33, Nick Sanders wrote:

[Nick Sanders, 2010/11/17 01:00:26]

Ok, that makes sense, thanks!

+       ${FLAGS_safe} -eq ${FLAGS_FALSE} ]; then
     setup_symlinks_on_root "${FLAGS_stateful_mountpt}/dev_image" \
       "${FLAGS_stateful_mountpt}/var" "${FLAGS_stateful_mountpt}"
   fi
   echo "Image specified by ${FLAGS_from} mounted at"\
     "${FLAGS_rootfs_mountpt} successfully."
 }
 
 # Find the last image built on the board.
 if [ ${FLAGS_most_recent} -eq ${FLAGS_TRUE} ] ; then
   FLAGS_from="$(./get_latest_image.sh --board="${FLAGS_board}")"
 fi
 
 # 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