Questions and patches related to casper.
Ben Greear
greearb at candelatech.com
Thu May 17 22:35:27 UTC 2012
On 05/17/2012 09:32 AM, Ben Greear wrote:
> On 05/16/2012 08:30 PM, Akkana Peck wrote:
>> Ben Greear writes:
>>>
>>> I have been having issues trying to do a persistent-usb image for
>>> Ubuntu 12.04.
>>
>> I got it working once on Oneiric, but only on a multi-distro USB
>> stick using grub, with a separate partition for casper, like this:
>> http://shallowsky.com/blog/linux/install/ubuntu-persistent-live-cd.html
>> I've never had any luck on either O or P in getting a single-boot
>> USB stick to be persistent.
>>
>> I'm currently setting up some USB sticks to use in a classroom/workshop
>> setting, with everybody booted from the same image. After wasting
>> most of a day trying to make persistence work, it occurred to me to
>> wonder why I was doing all that work: for a USB stick, why not just
>> install Ubuntu to the stick, and have a normal install that saves
>> whatever changes you make? No need for overlays like casper, just
>> install to a normal filesystem on the USB stick.
>
> Using 'dd' on windows is a royal pain, so if I can just point the
> users at some third-party pendrive tools and feed our modified .iso
> image into that, that is the easiest I think. I also like that the
> user can choose the amount of persistent storage based on their USB
> stick size.
>
> That said, if I can't find a way to cleanly un-mount the /cow
> (or mount it (ro)) on shutdown, then I'm going to have to try
> something else...
After some excellent help from the aufs maintainer and mailing
list denizens, I have this at least mostly working. The /cow
is properly un-mounted on shutdown, and fsck properly runs
on startup (that part was working last time I posted).
I'm attaching the casper initrd file and the /etc/init.d/umountroot
scripts that I modifed. It would be grand if someone with commit
privs would consider this for upstream inclusion.
Thanks,
Ben
>
> And, I'm seeing ubiquity panel cores on startup of the live-cd
> image, which is almost worse. I'm going to re-build the modified
> cd image from scratch today in hope that that will somehow fix
> the cores. They started after I removed /var/cache/* in an attempt
> to make the cd image smaller...seems that might have been a bad
> idea...
>
> Thanks,
> Ben
>
>
--
Ben Greear <greearb at candelatech.com>
Candela Technologies Inc http://www.candelatech.com
-------------- next part --------------
#! /bin/sh
### BEGIN INIT INFO
# Provides: umountroot
# Required-Start:
# Required-Stop:
# Should-Stop: halt reboot kexec
# Default-Start:
# Default-Stop: 0 6
# Short-Description: Mount the root filesystem read-only.
### END INIT INFO
PATH=/sbin:/bin:/usr/bin
. /lib/init/vars.sh
. /lib/lsb/init-functions
do_stop () {
[ "$VERBOSE" = no ] || log_action_begin_msg "Mounting root filesystem read-only"
# Ask init to re-exec itself before we go down if it has been
# upgraded this cycle. It'll lose all its state, but at least
# it won't hold open files on the root filesystem (lp:#672177).
if [ -f /var/run/init.upgraded ]
then
old_map=$( cat /proc/1/maps )
map=$old_map
telinit u || :
i=0
timeout=5
while [ "$map" = "$old_map" ]
do
sleep 1
map=$( cat /proc/1/maps )
/usr/bin/logger "waiting for init to respawn"
i=$((i+1))
if [ $i -eq $timeout ] ; then
break
fi
done
if [ "$map" = "$old_map" ] ; then
/usr/bin/logger "FAIL: init failed to respawn in $timeout seconds - unmounting anyway"
else
/usr/bin/logger "SUCCESS: init respawned after $i seconds (within $timeout seconds timeout)"
fi
fi
# These directories must exist on the root filesystem as they are
# targets for system mountpoints. We've just unmounted all other
# filesystems, so either they are mounted now (in which case the
# mount point exists) or we can make the mountpoint.
for dir in /proc /sys; do
mkdir -p $dir || true
done
# These must be turned into symlinks for the /run transition. We
# can't do this at boot time because / is remounted read-write too
# late, so do it on shutdown instead.
if [ -d /var/run ]; then
umount -l /var/run || true
rm -rf /var/run
ln -nsf /run /var/run
fi
if [ -d /var/lock ]; then
umount -l /var/lock || true
rm -rf /var/lock
ln -nsf /run/lock /var/lock
fi
if [ -d /dev/shm ]; then
umount -l /dev/shm || true
rm -rf /dev/shm
ln -nsf /run/shm /dev/shm
fi
if [ ! -L /lib/init/rw ] && umount -l /lib/init/rw && \
rm -rf /lib/init/rw; then
ln -nsf /run /lib/init/rw
elif [ -L /lib/init/rw ] && [ $(readlink /lib/init/rw) != /run ]; then
rm -f /lib/init/rw
ln -nsf /run /lib/init/rw
fi
MOUNT_FORCE_OPT=
[ "$(uname -s)" = "GNU/kFreeBSD" ] && MOUNT_FORCE_OPT=-f
# This:
# mount -n -o remount,ro /
# will act on a bind mount of / if there is one.
# See #339023 and the comment in checkroot.sh
# AUFS is special...have to do things just right to properly
# unmount the /cow.
if cat /proc/mounts | grep "aufs / "
then
set -x
if [ ! -x /sbin/mount.aufs ]
then
# mount.aufs will do this automatically if it exists, but otherwise
# it is probably a good idea to explicitly call the flush.
auplink / flush || echo "auplink flush failed: $?"
fi
if [ -d /cow ]
then
# Unmount the backing storage for /cow cleanly.
mount -n -o remount,noxino / || echo "Remount noxino / failed: $?"
# This next fails, but over-all, things work, so leaving it in in case
# it has some partial benefit.
mount -n -o remount,mod:/cow=ro / || echo "Remount /cow(ro) failed: $?"
mount -n -o remount,ro /cow || echo "Remount /cow (ro) failed: $?"
mount -n -o remount,ro /
ES=$?
[ $ES = 0 ] || echo "Remount / (ro) failed: $?"
else
# Well, don't know where the copy-on-write directory is, so just do
# a normal unmount
mount $MOUNT_FORCE_OPT -n -o remount,ro -t dummytype dummydev / 2>/dev/null \
|| mount $MOUNT_FORCE_OPT -n -o remount,ro dummydev / 2>/dev/null \
|| mount $MOUNT_FORCE_OPT -n -o remount,ro /
ES=$?
fi
else
mount $MOUNT_FORCE_OPT -n -o remount,ro -t dummytype dummydev / 2>/dev/null \
|| mount $MOUNT_FORCE_OPT -n -o remount,ro dummydev / 2>/dev/null \
|| mount $MOUNT_FORCE_OPT -n -o remount,ro /
ES=$?
fi
[ "$VERBOSE" = no ] || log_action_end_msg $ES
cat /proc/mounts
cat /sys/fs/aufs/*/br*
# Give usb persistent storage a chance to calm down??
sleep 10
}
case "$1" in
start)
# No-op
;;
restart|reload|force-reload)
echo "Error: argument '$1' not supported" >&2
exit 3
;;
stop)
do_stop
;;
*)
echo "Usage: $0 start|stop" >&2
exit 3
;;
esac
:
-------------- next part --------------
#!/bin/sh
# set -e
export PATH=/usr/bin:/usr/sbin:/bin:/sbin
mountpoint=/cdrom
LIVE_MEDIA_PATH=casper
[ -f /conf/uuid.conf ] && UUID="$(cat /conf/uuid.conf)"
root_persistence="casper-rw"
home_persistence="home-rw"
root_snapshot_label="casper-sn"
home_snapshot_label="home-sn"
USERNAME=casper
USERFULLNAME="Live session user"
HOST=live
BUILD_SYSTEM=Custom
FSCKARG=-p
mkdir -p $mountpoint
tried=/tmp/tried
[ -f /etc/casper.conf ] && . /etc/casper.conf
export USERNAME USERFULLNAME HOST BUILD_SYSTEM
. /scripts/casper-helpers
if [ ! -f /casper.vars ]; then
touch /casper.vars
fi
parse_cmdline() {
for x in $(cat /proc/cmdline); do
case $x in
showmounts|show-cow)
export SHOWMOUNTS='Yes' ;;
persistent)
export PERSISTENT="Yes" ;;
nopersistent)
export PERSISTENT="" ;;
persistent-path=*)
export PERSISTENT_PATH="${x#persistent-path=}" ;;
union=*)
export UNIONFS="${x#union=}";;
ip=*)
STATICIP=${x#ip=}
if [ "${STATICIP}" = "" ]; then
STATICIP="frommedia"
fi
export STATICIP ;;
uuid=*)
UUID=${x#uuid=} ;;
ignore_uuid)
UUID="" ;;
live-media-path=*)
LIVE_MEDIA_PATH="${x#live-media-path=}"
export LIVE_MEDIA_PATH
echo "export LIVE_MEDIA_PATH=\"$LIVE_MEDIA_PATH\"" >> /etc/casper.conf ;;
toram)
export TORAM="Yes" ;;
todisk=*)
export TODISK="${x#todisk=}" ;;
fscky)
FSCKARG=-y ;;
casper-notquiet)
quiet=n ;;
esac
done
if [ "${UNIONFS}" = "" ]; then
export UNIONFS="DEFAULT"
fi
}
is_casper_path() {
path=$1
if [ -d "$path/$LIVE_MEDIA_PATH" ]; then
if [ "$(echo $path/$LIVE_MEDIA_PATH/*.squashfs)" != "$path/$LIVE_MEDIA_PATH/*.squashfs" ] ||
[ "$(echo $path/$LIVE_MEDIA_PATH/*.ext2)" != "$path/$LIVE_MEDIA_PATH/*.ext2" ] ||
[ "$(echo $path/$LIVE_MEDIA_PATH/*.dir)" != "$path/$LIVE_MEDIA_PATH/*.dir" ]; then
return 0
fi
fi
return 1
}
matches_uuid() {
if [ -z "$UUID" ]; then
return 0
fi
path="$1"
for try_uuid_file in "$path/.disk/casper-uuid"*; do
[ -e "$try_uuid_file" ] || continue
try_uuid="$(cat "$try_uuid_file")"
if [ "$UUID" = "$try_uuid" ]; then
return 0
fi
done
return 1
}
get_backing_device() {
case "$1" in
*.squashfs|*.ext2)
echo $(setup_loop "$1" "loop" "/sys/block/loop*")
;;
*.dir)
echo "directory"
;;
*)
panic "Unrecognized casper filesystem: $1"
;;
esac
}
match_files_in_dir() {
# Does any files match pattern $1 ?
local pattern="$1"
if [ "$(echo $pattern)" != "$pattern" ]; then
return 0
fi
return 1
}
mount_images_in_directory() {
directory="$1"
rootmnt="$2"
if match_files_in_dir "$directory/$LIVE_MEDIA_PATH/*.squashfs" ||
match_files_in_dir "$directory/$LIVE_MEDIA_PATH/*.ext2" ||
match_files_in_dir "$directory/$LIVE_MEDIA_PATH/*.dir"; then
setup_unionfs "$directory/$LIVE_MEDIA_PATH" "$rootmnt"
else
:
fi
}
is_nice_device() {
sysfs_path="${1#/sys}"
if /sbin/udevadm test-builtin path_id "${sysfs_path}" | egrep -q "ID_PATH=(usb|pci-[^-]*-(ide|sas|scsi|usb|virtio)|platform-sata_mv|platform-orion-ehci|platform-mmc|platform-mxsdhci|platform-omap_hsmmc|platform-sdhci-tegra)"; then
return 0
fi
if echo ${sysfs_path} | grep -q "^/block/dm-"; then
return 0
fi
return 1
}
copy_live_to() {
copyfrom="${1}"
copytodev="${2}"
copyto="${copyfrom}_swap"
size=$(fs_size "" ${copyfrom} "used")
if [ "${copytodev}" = "ram" ]; then
# copying to ram:
freespace=$(awk '/^MemFree:/{f=$2} /^Cached:/{c=$2} END{print f+c}' /proc/meminfo)
mount_options="-o size=${size}k"
free_string="memory"
fstype="tmpfs"
dev="/dev/shm"
else
# it should be a writable block device
if [ -b "${copytodev}" ]; then
dev="${copytodev}"
free_string="space"
fstype=$(get_fstype "${dev}")
freespace=$(fs_size "${dev}")
else
[ "$quiet" != "y" ] && log_warning_msg "${copytodev} is not a block device."
return 1
fi
fi
if [ "${freespace}" -lt "${size}" ] ; then
[ "$quiet" != "y" ] && log_warning_msg "Not enough free ${free_string} (${freespace}k > ${size}k) to copy live media in ${copytodev}."
return 1
fi
# begin copying..
mkdir "${copyto}"
echo "mount -t ${fstype} ${mount_options} ${dev} ${copyto}"
mount -t "${fstype}" ${mount_options} "${dev}" "${copyto}"
cp -a ${copyfrom}/* ${copyto}
if [ -e ${copyfrom}/.disk ]; then
cp -a ${copyfrom}/.disk ${copyto}
fi
umount ${copyfrom}
mount -r -o move ${copyto} ${copyfrom}
rmdir ${copyto}
return 0
}
do_netmount() {
rc=1
modprobe "${MP_QUIET}" af_packet # For DHCP
/sbin/udevadm trigger
/sbin/udevadm settle
configure_networking
export DEVICE
if [ "${NFSROOT}" = "auto" ]; then
NFSROOT=${ROOTSERVER}:${ROOTPATH}
fi
[ "$quiet" != "y" ] && log_begin_msg "Trying netboot from ${NFSROOT}"
if [ "${NETBOOT}" != "nfs" ] && do_cifsmount ; then
rc=0
elif do_nfsmount ; then
NETBOOT="nfs"
export NETBOOT
rc=0
fi
[ "$quiet" != "y" ] && log_end_msg
return ${rc}
}
do_nfsmount() {
rc=1
modprobe "${MP_QUIET}" nfs
if [ -z "${NFSOPTS}" ]; then
NFSOPTS=""
fi
[ "$quiet" != "y" ] && log_begin_msg "Trying nfsmount -o nolock -o ro ${NFSOPTS} ${NFSROOT} ${mountpoint}"
# FIXME: This while loop is an ugly HACK round an nfs bug
i=0
while [ "$i" -lt 60 ]; do
nfsmount -o nolock -o ro ${NFSOPTS} "${NFSROOT}" "${mountpoint}" && rc=0 && break
sleep 1
i="$(($i + 1))"
done
return ${rc}
}
do_cifsmount() {
rc=1
if [ -x "/sbin/mount.cifs" ]; then
if [ -z "${NFSOPTS}" ]; then
CIFSOPTS="-ouser=root,password="
else
CIFSOPTS="${NFSOPTS}"
fi
[ "$quiet" != "y" ] && log_begin_msg "Trying mount.cifs ${NFSROOT} ${mountpoint} ${CIFSOPTS}"
modprobe "${MP_QUIET}" cifs
if mount.cifs "${NFSROOT}" "${mountpoint}" "${CIFSOPTS}" ; then
rc=0
fi
fi
return ${rc}
}
do_snap_copy ()
{
fromdev="${1}"
todir="${2}"
snap_type="${3}"
size=$(fs_size "${fromdev}" "" "used")
if [ -b "${fromdev}" ]; then
# look for free mem
if [ -n "${HOMEMOUNTED}" -a "${snap_type}" = "HOME" ]; then
todev=$(cat /proc/mounts | grep -s " $(base_path ${todir}) " | awk '{print $1}' )
freespace=$(df -k | grep -s ${todev} | awk '{print $4}')
else
freespace=$(awk '/^MemFree:/{f=$2} /^Cached:/{c=$2} END{print f+c}' /proc/meminfo)
fi
tomount="/mnt/tmpsnap"
if [ ! -d "${tomount}" ] ; then
mkdir -p "${tomount}"
fi
fstype=$(get_fstype "${fromdev}")
if [ -n "${fstype}" ]; then
# Copying stuff...
mount -t "${fstype}" -o ro,noatime "${fromdev}" "${tomount}"
cp -a "${tomount}"/* ${todir}
umount "${tomount}"
else
log_warning_msg "Unrecognized fstype: ${fstype} on ${fromdev}:${snap_type}"
fi
rmdir "${tomount}"
if echo ${fromdev} | grep -qs loop; then
losetup -d "${fromdev}"
fi
return 0
else
return 1
[ "$quiet" != "y" ] && log_warning_msg "Unable to find the snapshot ${snap_type} medium"
fi
}
try_snap ()
{
# Look for $snap_label.* in block devices and copy the contents to $snap_mount
# and remember the device and filename for resync on exit in casper.init
snap_label="${1}"
snap_mount="${2}"
snap_type="${3}"
snapdata=$(find_files "${snap_label}.squashfs ${snap_label}.cpio.gz ${snap_label}.ext2")
if [ ! -z "${snapdata}" ]; then
snapdev="$(echo ${snapdata} | cut -f1 -d ' ')"
snapback="$(echo ${snapdata} | cut -f2 -d ' ')"
snapfile="$(echo ${snapdata} | cut -f3 -d ' ')"
if echo "${snapfile}" | grep -qs '\(squashfs\|ext2\)'; then
# squashfs or ext2 snapshot
dev=$(get_backing_device "${snapback}/${snapfile}")
if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}"; then
log_warning_msg "Impossible to include the ${snapfile} Snapshot"
return 1
fi
else
# cpio.gz snapshot
# Unfortunately klibc's cpio is incompatible with the rest of
# the world; everything else requires -u -d, while klibc doesn't
# implement them. Try to detect whether it's in use.
cpiopath="$(which cpio)" || true
if [ "$cpiopath" ] && grep -aq /lib/klibc "$cpiopath"; then
cpioargs=
else
cpioargs='-u -d'
fi
if ! (cd "${snap_mount}" && zcat "${snapback}/${snapfile}" | cpio -i $cpioargs 2>/dev/null) ; then
log_warning_msg "Impossible to include the ${snapfile} Snapshot"
return 1
fi
fi
umount "${snapback}"
else
dev=$(find_cow_device "${snap_label}")
if [ -b "${dev}" ]; then
if echo "${dev}" | grep -qs loop; then
# strange things happens, user confused?
snaploop=$( losetup ${dev} | awk '{print $3}' | tr -d '()' )
snapfile=$(basename ${snaploop})
snapdev=$(cat /proc/mounts | awk '{print $2,$1}' | grep -es "^$( dirname ${snaploop} )" | cut -f2 -d ' ')
else
snapdev="${dev}"
fi
if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}" ; then
log_warning_msg "Impossible to include the ${snap_label} Snapshot"
return 1
else
if [ -n "${snapfile}" ]; then
# it was a loop device, user confused
umount ${snapdev}
fi
fi
else
log_warning_msg "Impossible to include the ${snap_label} Snapshot"
return 1
fi
fi
echo "export ${snap_type}SNAP="/cow${snap_mount#$rootmnt}":${snapdev}:${snapfile}" >> /etc/casper.conf # for resync on reboot/halt
return 0
}
setup_unionfs() {
image_directory="$1"
rootmnt="$2"
if [ "${UNIONFS}" = 'DEFAULT' ]; then
for union in 'overlayfs' 'aufs' 'unionfs'
do
modprobe "${MP_QUIET}" -b ${union} || true
if cut -f2 /proc/filesystems | grep -q "^${union}\$"; then
UNIONFS="${union}"
break
fi
done
fi
if [ "${UNIONFS}" = 'DEFAULT' -a -x /bin/unionfs-fuse ]; then
UNIONFS="unionfs-fuse"
fi
# If all else fails fall back to aufs.
if [ "${UNIONFS}" = 'DEFAULT' ]; then
UNIONFS='aufs'
fi
# run-init can't deal with images in a subdir, but we're going to
# move all of these away before it runs anyway. No, we're not,
# put them in / since move-mounting them into / breaks mono and
# some other apps.
croot="/"
# Let's just mount the read-only file systems first
rofsstring=""
rofslist=""
if [ "${UNIONFS}" = "aufs" ]; then
roopt="rr"
elif [ "${UNIONFS}" = "unionfs-fuse" ]; then
roopt="RO"
else
roopt="ro"
fi
mkdir -p "${croot}"
for image_type in "ext2" "squashfs" "dir" ; do
for image in "${image_directory}"/*."${image_type}"; do
imagename=$(basename "${image}")
if [ -d "${image}" ]; then
# it is a plain directory: do nothing
rofsstring="${image}=${roopt}:${rofsstring}"
rofslist="${image} ${rofslist}"
elif [ -f "${image}" ]; then
backdev=$(get_backing_device "$image")
fstype=$(get_fstype "${backdev}")
if [ "${fstype}" = "unknown" ]; then
panic "Unknown file system type on ${backdev} (${image})"
fi
mkdir -p "${croot}/${imagename}"
mount -t "${fstype}" -o ro,noatime "${backdev}" "${croot}/${imagename}" || panic "Can not mount $backdev ($image) on ${croot}/${imagename}" && rofsstring="${croot}/${imagename}=${roopt}:${rofsstring}" && rofslist="${croot}/${imagename} ${rofslist}"
fi
done
done
rofsstring=${rofsstring%:}
mkdir -p /cow
cowdevice="tmpfs"
cow_fstype="tmpfs"
cow_mountopt="rw,noatime,mode=755"
# Looking for "${root_persistence}" device or file
if [ -n "${PERSISTENT}" ]; then
cowprobe=$(find_cow_device "${root_persistence}")
if [ -b "${cowprobe}" ]; then
cowdevice=${cowprobe}
cow_fstype=$(get_fstype "${cowprobe}")
cow_mountopt="rw,noatime"
else
[ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent medium"
fi
fi
if [ "_${cow_fstype}" = "_ext2" -o "_${cow_fstype}" = "_ext3" -o "_${cow_fstype}" = "_ext4" ]
then
[ "$quiet" != "y" ] && log_warning_msg "Running e2fsck on ${cowdevice}, fstype: ${cow_fstype}"
e2fsck ${FSCKARG} ${cowdevice}
EC2=$?
if [ $EC2 != "0" ]
then
if [ $EC2 = "1" ]
then
log_warning_msg "e2fsck automatically corrected errors on ${cowdevice}, fstype: ${cow_fstype}"
else
panic "ERROR: Possible file system corruption on ${cowdevice}: $EC2 Run: e2fsck ${cowdevice} or e2fsck -y ${cowdevice} and then exit"
fi
fi
else
[ "$quiet" != "y" ] && log_warning_msg "Not running fsck on ${cowdevice}, only ext2/2/4 fsck supported: ${cow_fstype}"
fi
mount -t ${cow_fstype} -o ${cow_mountopt} ${cowdevice} /cow || panic "Can not mount $cowdevice on /cow"
case ${UNIONFS} in
unionfs-fuse)
(ulimit -n 16384; unionfs-fuse -o cow -o noinitgroups -o default_permissions -o allow_other -o use_ino -o suid /cow=RW:$rofsstring "$rootmnt" || panic "${UNIONFS} mount failed")
mkdir -p /dev/.initramfs/varrun
pidof unionfs-fuse >> /dev/.initramfs/varrun/sendsigs.omit || true
;;
aufs|unionfs)
mount -t ${UNIONFS} -o noatime,dirs=/cow=rw:$rofsstring ${UNIONFS} "$rootmnt" || panic "${UNIONFS} mount failed"
;;
overlayfs)
# Mount the layers pairwise from the bottom onto rootmnt,
# for the second and later layers rootmnt forms the lower layer.
mounts=""
for mount in /cow $rofslist
do
mounts="$mount $mounts"
done
lower=""
for mount in $mounts
do
if [ "$lower" = "" ]; then
lower="$mount"
continue
fi
mount -t overlayfs -o "upperdir=$mount,lowerdir=$lower" \
"$mount" "$rootmnt"
lower="$rootmnt"
done
;;
esac
# Adding other custom mounts
if [ -n "${PERSISTENT}" ]; then
# directly mount /home
# FIXME: add a custom mounts configurable system
homecow=$(find_cow_device "${home_persistence}" )
if [ -b "${homecow}" ]; then
mount -t $(get_fstype "${homecow}") -o rw,noatime "${homecow}" "${rootmnt}/home"
export HOMEMOUNTED=1 # used to proper calculate free space in do_snap_copy()
else
[ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent home medium"
fi
# Look for other snapshots to copy in
try_snap "${root_snapshot_label}" "${rootmnt}" "ROOT"
try_snap "${home_snapshot_label}" "${rootmnt}/home" "HOME"
fi
if [ -n "${SHOWMOUNTS}" ]; then
for d in ${rofslist}; do
mkdir -p "${rootmnt}/${LIVE_MEDIA_PATH}/${d##*/}"
case d in
*.dir) # do nothing # mount -o bind "${d}" "${rootmnt}/${LIVE_MEDIA_PATH}/${d##*/}"
;;
*)
if [ "${UNIONFS}" = unionfs-fuse ]; then
mount -o bind "${d}" "${rootmnt}/${LIVE_MEDIA_PATH}/${d##*/}"
else
mount -o move "${d}" "${rootmnt}/${LIVE_MEDIA_PATH}/${d##*/}"
fi
;;
esac
done
fi
# We always need to show cow so we can at least try to gracefully
# unmount it on shutdown (or re-mount ro or whatever)
# shows cow fs on /cow for use by casper-snapshot
mkdir -p "${rootmnt}/cow"
if [ "${UNIONFS}" = unionfs-fuse ]; then
mount -o bind /cow "${rootmnt}/cow"
else
mount -o move /cow "${rootmnt}/cow"
fi
# move the first mount; no head in busybox-initramfs
for d in $(mount -t squashfs | cut -d\ -f 3); do
mkdir -p "${rootmnt}/rofs"
if [ "${UNIONFS}" = unionfs-fuse ]; then
mount -o bind "${d}" "${rootmnt}/rofs"
else
mount -o move "${d}" "${rootmnt}/rofs"
fi
break
done
}
check_dev ()
{
sysdev="${1}"
devname="${2}"
skip_uuid_check="${3}"
if [ -z "${devname}" ]; then
devname=$(sys2dev "${sysdev}")
fi
if [ -d "${devname}" ]; then
mount -o bind "${devname}" $mountpoint || continue
if is_casper_path $mountpoint; then
echo $mountpoint
return 0
else
umount $mountpoint
fi
fi
[ -e "$devname" ] || continue
if [ -n "${LIVEMEDIA_OFFSET}" ]; then
loopdevname=$(setup_loop "${devname}" "loop" "/sys/block/loop*" "${LIVEMEDIA_OFFSET}")
devname="${loopdevname}"
fi
fstype=$(get_fstype "${devname}")
if is_supported_fs ${fstype}; then
devuid=$(blkid -o value -s UUID "$devname")
[ -n "$devuid" ] && grep -qs "\<$devuid\>" $tried && continue
mount -t ${fstype} -o ro,noatime "${devname}" $mountpoint || continue
[ -n "$devuid" ] && echo "$devuid" >> $tried
if is_casper_path $mountpoint && \
([ "$skip_uuid_check" ] || [ "$UUID" = "$devuid" ] || matches_uuid $mountpoint); then
echo $mountpoint
return 0
else
umount $mountpoint
fi
fi
if [ -n "${LIVEMEDIA_OFFSET}" ]; then
losetup -d "${loopdevname}"
fi
return 1
}
find_livefs() {
timeout="${1}"
# first look at the one specified in the command line
if [ ! -z "${LIVEMEDIA}" ]; then
if check_dev "null" "${LIVEMEDIA}" "skip_uuid_check"; then
return 0
fi
fi
# don't start autodetection before timeout has expired
if [ -n "${LIVEMEDIA_TIMEOUT}" ]; then
if [ "${timeout}" -lt "${LIVEMEDIA_TIMEOUT}" ]; then
return 1
fi
fi
# or do the scan of block devices
for sysblock in $(echo /sys/block/* | tr ' ' '\n' | egrep -v "/(loop|ram|fd)"); do
devname=$(sys2dev "${sysblock}")
[ -e "$devname" ] || continue
fstype=$(get_fstype "${devname}")
if /lib/udev/cdrom_id ${devname} > /dev/null; then
if check_dev "null" "${devname}" ; then
return 0
fi
elif is_nice_device "${sysblock}" ; then
for dev in $(subdevices "${sysblock}"); do
if check_dev "${dev}" ; then
return 0
fi
done
elif [ "${fstype}" = "squashfs" -o \
"${fstype}" = "ext4" -o \
"${fstype}" = "ext3" -o \
"${fstype}" = "ext2" -o \
"${fstype}" = "btrfs" ]; then
# This is an ugly hack situation, the block device has
# an image directly on it. It's hopefully
# casper, so take it and run with it.
ln -s "${devname}" "${devname}.${fstype}"
echo "${devname}.${fstype}"
return 0
fi
done
return 1
}
set_usplash_timeout() {
if [ -x /sbin/usplash_write ]; then
/sbin/usplash_write "TIMEOUT 120"
fi
}
start_usplash_pulse() {
if [ -x /sbin/usplash_write ]; then
/sbin/usplash_write "PULSELOGO"
fi
}
mountroot() {
exec 6>&1
exec 7>&2
exec > casper.log
exec 2>&1
tail -f casper.log >&7 &
tailpid="$!"
parse_cmdline
set_usplash_timeout
start_usplash_pulse
[ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-premount"
run_scripts /scripts/casper-premount
[ "$quiet" != "y" ] && log_end_msg
# Needed here too because some things (*cough* udev *cough*)
# changes the timeout
set_usplash_timeout
if [ ! -z "${NETBOOT}" ]; then
if do_netmount ; then
livefs_root="${mountpoint}"
else
panic "Unable to find a live file system on the network"
fi
else
# Scan local devices for the image
i=0
while [ "$i" -lt 60 ]; do
livefs_root=$(find_livefs $i)
if [ "${livefs_root}" ]; then
break
fi
sleep 1
i="$(($i + 1))"
done
fi
if [ -z "${livefs_root}" ]; then
panic "Unable to find a medium containing a live file system"
fi
if [ "${TORAM}" ]; then
live_dest="ram"
elif [ "${TODISK}" ]; then
live_dest="${TODISK}"
fi
if [ "${live_dest}" ]; then
log_begin_msg "Copying live_media to ${live_dest}"
copy_live_to "${livefs_root}" "${live_dest}"
log_end_msg
fi
mount_images_in_directory "${livefs_root}" "${rootmnt}"
log_end_msg
# Allow to override USERNAME and HOST based on media information
# make it skipable by setting FLAVOUR= in casper.conf
if [ -f /cdrom/.disk/info ] && [ -z "$FLAVOUR" ]; then
FLAVOUR="$(cut -d' ' -f1 "/cdrom/.disk/info" 2>/dev/null | tr '[A-Z]' '[a-z]')" || FLAVOUR=
if [ -n "$FLAVOUR" ]; then
HOST=$FLAVOUR
USERNAME=$FLAVOUR
export HOST USERNAME
sed -i "s,USERNAME=.*,USERNAME=\"$FLAVOUR\",g; s,HOST=.*,HOST=\"$FLAVOUR\",g" /etc/casper.conf
fi
fi
# unionfs-fuse needs /dev to be bind-mounted for the duration of
# casper-bottom; udev's init script will take care of things after that
if [ "${UNIONFS}" = unionfs-fuse ]; then
mount -n -o bind /dev "${rootmnt}/dev"
fi
# Open up two fifo's fd's for debconf-communicate to use. Speeds up
# the Casper process considerably.
log_begin_msg "Creating debconf-communicate fifo mechanism"
mkfifo /tmp/debconf-in.fifo
mkfifo /tmp/debconf-out.fifo
# Make the template database read-only, so that passthrough debconf
# instances can write to it directly; otherwise templates are only
# passed through when necessary. Use temporary config databases as
# well; we'll copy their contents back at the end.
DEBCONF_TMPDIR="$(chroot /root mktemp -dt debconf.XXXXXX)"
cp -a /root/var/cache/debconf/config.dat "/root$DEBCONF_TMPDIR/"
cp -a /root/var/cache/debconf/passwords.dat "/root$DEBCONF_TMPDIR/"
sed "s,^Filename: /var/cache/debconf/\(config\|passwords\).dat$,Filename: $DEBCONF_TMPDIR/\1.dat,; /^Name: templatedb/a\
Readonly: true" /root/etc/debconf.conf >"/root$DEBCONF_TMPDIR/debconf.conf"
DEBCONF_SYSTEMRC="$DEBCONF_TMPDIR/debconf.conf" chroot /root debconf-communicate -fnoninteractive casper > /tmp/debconf-out.fifo < /tmp/debconf-in.fifo &
debconfpid="$!"
if [ ! -p /tmp/debconf-in.fifo ] || [ ! -p /tmp/debconf-out.fifo ]; then
log_warning_msg "failed to setup debconf-communicate channel"
fi
log_end_msg
# Order matters!
# These file descriptors must stay open until we're finished with
# debconf-communicate.
exec 4</tmp/debconf-out.fifo 3>/tmp/debconf-in.fifo
maybe_break casper-bottom
[ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-bottom"
run_scripts /scripts/casper-bottom
[ "$quiet" != "y" ] && log_end_msg
if [ "${UNIONFS}" = unionfs-fuse ]; then
umount "${rootmnt}/dev"
fi
# Close the fd's associated with debconf-communicate.
exec 3>&- 4<&-
rm -f /tmp/debconf-in.fifo
rm -f /tmp/debconf-out.fifo
wait $debconfpid
# Copy config database changes back to the master files.
chroot /root debconf-copydb tmpdb config \
--config=Name:tmpdb --config=Driver:File \
--config="Filename:$DEBCONF_TMPDIR/config.dat"
chroot /root debconf-copydb tmpdb passwords \
--config=Name:tmpdb --config=Driver:File \
--config="Filename:$DEBCONF_TMPDIR/passwords.dat"
rm -rf "$DEBCONF_TMPDIR"
exec 1>&6 6>&-
exec 2>&7 7>&-
kill "$tailpid"
cp casper.log "${rootmnt}/var/log/"
if [ -f /etc/casper.conf ]; then
cp /etc/casper.conf "${rootmnt}/etc/"
fi
}
More information about the Ubuntu-devel-discuss
mailing list