scripts/casper

   1 #!/bin/sh
   2
   3 # set -e
   4
   5 export PATH=/root/usr/bin:/root/usr/sbin:/root/bin:/root/sbin:/usr/bin:/usr/sbin:/bin:/sbin
   6
   7 mountpoint=/live_media
   8
   9 # Will be mounted if found as copy on write instead of tmpfs
  10 root_persistence="casper-rw"
  11
  12 # TODO
  13 ## Each file found with this pattern will be mounted directly in the
  14 ## mountpoint extracted from file name "${other_mounts_pattern}<mountpoint>"
  15 #other_mounts_pattern="casper-mount-"
  16 home_persistence="home-rw"
  17
  18 #overlay_method=unionfs
  19 #if [ "${DPKG_ARCH}" = "ia64" ] || [ "${DPKG_ARCH}" = "hppa" ] || [ "${DPKG_ARCH}" = "sparc" ]; then
  20 #    overlay_method=devmapper
  21 #fi
  22
  23 USERNAME="casper"
  24 USERFULLNAME="Live session user"
  25 HOST="live"
  26
  27 mkdir -p $mountpoint
  28
  29 [ -f /etc/casper.conf ] && . /etc/casper.conf
  30
  31 export USERNAME USERFULLNAME HOST
  32
  33 # looking for casper specifics options as kernel parameters
  34 for x in $(cat /proc/cmdline); do
  35         case $x in
  36                 netboot*)
  37                         NETBOOT=${x#netboot=}
  38                         export NETBOOT
  39                         ;;
  40                 toram)
  41                         TORAM=1
  42                         export TORAM
  43                         ;;
  44                 show-cow)
  45                         SHOWCOW=1
  46                         export SHOWCOW
  47                         ;;
  48                 persistent)
  49                         PERSISTENT=1
  50                         export PERSISTENT
  51                         ;;
  52         esac
  53 done
  54
  55 # sort of compatibility with netboot.h from linux docs
  56 if [ -z "${NETBOOT}" ]; then
  57         if [ "${ROOT}" == "/dev/nfs" ]; then
  58                 NETBOOT="nfs"
  59                 export NETBOOT
  60         elif [ "${ROOT}" == "/dev/cifs" ]; then
  61                 NETBOOT="cifs"
  62                 export NETBOOT
  63         fi
  64 fi
  65
  66 is_casper_path() {
  67         path=$1
  68         if [ -d "$path/casper" ]; then
  69                 if [ "$(echo $path/casper/*.cloop)" != "$path/casper/*.cloop" ] ||
  70                         [ "$(echo $path/casper/*.squashfs)" != "$path/casper/*.squashfs" ] ||
  71                         [ "$(echo $path/casper/*.ext2)" != "$path/casper/*.ext2" ] ||
  72                         [ "$(echo $path/casper/*.dir)" != "$path/casper/*.dir" ]; then
  73                         return 0
  74                 fi
  75         fi
  76         return 1
  77 }
  78
  79 subdevices() {
  80         sysblock=$1
  81         r=""
  82         for dev in "${sysblock}" "${sysblock}"/*; do
  83                 if [ -e "${dev}/dev" ]; then
  84                         r="${r} ${dev}"
  85                 fi
  86         done
  87         echo ${r}
  88 }
  89
  90 get_backing_device() {
  91         case "$1" in
  92                 *.cloop)
  93                         echo $(setup_loop "$1" "cloop" "/sys/block/cloop*")
  94                         ;;
  95                 *.squashfs|*.ext2)
  96                         echo $(setup_loop "$1" "loop" "/sys/block/loop*")
  97                         ;;
  98                 *.dir)
  99                         echo "directory"
 100                         ;;
 101                 *)
 102                         panic "Unrecognized casper filesystem: $1"
 103                         ;;
 104         esac
 105 }
 106
 107 match_files_in_dir() {
 108         # Does any files match pattern $1 ?
 109
 110         local pattern="$1"
 111         if [ "$(echo $pattern)" != "$pattern" ]; then
 112                 return 0
 113         fi
 114         return 1
 115 }
 116
 117 mount_images_in_directory() {
 118         directory="$1"
 119         rootmnt="$2"
 120         if match_files_in_dir "$directory/casper/*.cloop"; then
 121                 # Let's hope there's just one matching *.cloop... FIXME
 122                 setup_devmapper $(get_backing_device "$directory/casper/*.cloop") "$rootmnt"
 123         elif match_files_in_dir "$directory/casper/*.squashfs" ||
 124                 match_files_in_dir "$directory/casper/*.ext2" ||
 125                 match_files_in_dir "$directory/casper/*.dir"; then
 126                 setup_unionfs "$directory/casper" "$rootmnt"
 127         else
 128                 :
 129         fi
 130 }
 131
 132 sys2dev() {
 133         sysdev=${1#/sys}
 134         echo "/dev/$(udevinfo -q name -p ${sysdev} 2>/dev/null|| echo ${sysdev##*/})"
 135 }
 136
 137 setup_loop() {
 138         local fspath=$1
 139         local module=$2
 140         local pattern=$3
 141
 142         modprobe -qb "$module"
 143         if [ -x /sbin/udevplug ]; then
 144                 udevplug -W
 145         else
 146                 udevtrigger
 147         fi
 148
 149         for loopdev in $pattern; do
 150                 if [ "$(cat $loopdev/size)" -eq 0 ]; then
 151                         dev=$(sys2dev "${loopdev}")
 152                         losetup "$dev" "$fspath"
 153                         echo "$dev"
 154                         return 0
 155                 fi
 156         done
 157         panic "No loop devices available"
 158 }
 159
 160 get_fstype() {
 161         #FIXME# one use of this function expects "unknown" another does not!
 162         # which is it???
 163         local FSTYPE
 164         local FSSIZE
 165         eval $(fstype < $1)
 166         if [ "$FSTYPE" != "unknown" ]; then
 167                 echo $FSTYPE
 168                 return 0
 169         fi
 170         /lib/udev/vol_id -t $1 2>/dev/null
 171 }
 172
 173 setup_devmapper() {
 174         backdev="$1"
 175         rootmnt="$2"
 176
 177         modprobe -qb dm-mod
 178         COW_DEVICE=/dev/ram1
 179         COW_NAME="casper-cow"
 180
 181         BACKING_FILE_SIZE=$(blockdev --getsize "$backdev")
 182         MAX_COW_SIZE=$(blockdev --getsize "$COW_DEVICE")
 183         CHUNK_SIZE=8 # sectors
 184
 185         if [ -z "$COW_SIZE" -o "$COW_SIZE" -gt "$MAX_COW_SIZE" ]; then
 186                 COW_SIZE=$MAX_COW_SIZE
 187         fi
 188
 189         echo "0 $COW_SIZE linear $COW_DEVICE 0" | dmsetup create $COW_NAME
 190
 191         echo "0 $BACKING_FILE_SIZE snapshot $backdev /dev/mapper/$COW_NAME p $CHUNK_SIZE" | \
 192                 dmsetup create casper-snapshot
 193         if [ "$(get_fstype $backdev)" = "unknown" ]; then
 194                 panic "Unknown file system type on $backdev"
 195         fi
 196         mount -t $(get_fstype "$backdev") /dev/mapper/casper-snapshot $rootmnt || panic "Can not mount /dev/mapper/casper/snapshot on $rootmnt"
 197
 198         mkdir -p "$rootmnt/rofs"
 199         echo "0 $BACKING_FILE_SIZE linear $backdev 0" | dmsetup create casper-backing
 200         mount -t $(get_fstype "$backdev") /dev/mapper/casper-backing "$rootmnt/rofs"
 201 }
 202
 203 where_is_mounted() {
 204         device=$1
 205         if grep -q "^$device " /proc/mounts; then
 206                 grep "^$device " /proc/mounts | read d mountpoint rest
 207                 echo $mountpoint
 208                 return 0
 209         fi
 210         return 1
 211 }
 212
 213 copy_to_ram() {
 214         copyfrom="$1"
 215
 216         if [ ! -z "${2}" ] ; then
 217                 # This will enable future rampersistence, todo yet
 218                 copyto="${2}"
 219                 moveit="False"
 220         else
 221                 copyto="${copyfrom}_swap"
 222                 moveit="True"
 223         fi
 224
 225         size=$(du -ks ${copyfrom} | cut -f1)
 226         size=$(expr ${size} + ${size}/20 ) # Fixme: 5% more to be sure
 227         needed_space=$(expr ${size} * 1024)
 228         freespace=$( expr $(awk '/MemFree/{print $2}' /proc/meminfo) + $( cat /proc/meminfo | grep Cached | head -n 1 | awk '/Cached/{print $2}' - ))
 229
 230         if [ ! ${freespace} -lt ${needed_space}  ] ; then
 231                 [ "$quiet" != "y" ] && log_begin_msg "Not enough free memory to copy to ram"
 232                 [ "$quiet" != "y" ] && log_end_msg
 233                 return
 234         else
 235                 [ "$quiet" != "y" ] && log_begin_msg "Copying live media to ram..."
 236                 mkdir "${copyto}"
 237                 mount -t tmpfs -o size=${size}k /dev/shm ${copyto}
 238                 cp -a ${copyfrom}/* ${copyto} # "cp -a" from busybox also copies hidden files
 239                 umount ${copyfrom}
 240                 if [ "${moveit}" == "True" ]; then
 241                         mount -r -o move ${copyto} ${copyfrom}
 242                         rmdir ${copyto}
 243                 fi
 244                 [ "$quiet" != "y" ] && log_end_msg
 245         fi
 246 }
 247
 248 find_cow_device() {
 249         pers_label="${1}"
 250         cow_backing="/${pers_label}-backing"
 251         for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -v loop); do
 252                 for dev in $(subdevices "${sysblock}"); do
 253                         devname=$(sys2dev "${dev}")
 254                         if [ "$(/lib/udev/vol_id -l $devname 2>/dev/null)" = "${pers_label}" ]; then
 255                                 echo "$devname"
 256                                 return
 257                         elif [ "$(get_fstype ${devname})" = "vfat" ]; then
 258                                 mkdir -p "${cow_backing}"
 259                                 if where_is_mounted ${devname} > /dev/null; then
 260                                         mount -o remount,rw ${devname} $(where_is_mounted ${devname}) || panic "Remounting failed"
 261                                         mount -o bind $(where_is_mounted ${devname}) ${cow_backing} || panic "Cannot bind-mount"
 262                                 else
 263                                         mount -t $(get_fstype "${devname}") -o rw "${devname}" ${cow_backing} || panic "Cannot mount $devname on /cow-backing"
 264                                 fi
 265
 266                                 if [ -e "${cow_backing}/${pers_label}" ]; then
 267                                         echo $(setup_loop "${cow_backing}/${pers_label}" "loop" "/sys/block/loop*")
 268                                         return 0
 269                                 else
 270                                         umount ${cow_backing}
 271                                 fi
 272                         fi
 273                 done
 274         done
 275 }
 276
 277 do_netmount() {
 278         rc=1
 279
 280         modprobe -q af_packet # For DHCP
 281
 282         ipconfig ${DEVICE} /tmp/net-${DEVICE}.conf
 283
 284         if [ "${NFSROOT}" = "auto" ]; then
 285                 NFSROOT=${ROOTSERVER}:${ROOTPATH}
 286         fi
 287
 288         [ "$quiet" != "y" ] && log_begin_msg "Trying netboot from ${NFSROOT}"
 289
 290         if [ "${NETBOOT}" != "nfs" ] && do_cifsmount ; then
 291                 rc=0
 292         elif do_nfsmount ; then
 293                 rc=0
 294         fi
 295
 296         [ "$quiet" != "y" ] && log_end_msg
 297         return ${rc}
 298 }
 299
 300 do_nfsmount() {
 301         rc=1
 302         modprobe -q nfs
 303         if [ -z "${NFSOPTS}" ]; then
 304                 NFSOPTS=""
 305         fi
 306
 307         [ "$quiet" != "y" ] && log_begin_msg "Trying nfsmount -o nolock -o ro ${NFSOPTS} ${NFSROOT} ${mountpoint}"
 308         # FIXME: This for loop is an ugly HACK round an nfs bug
 309         for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13; do
 310                 nfsmount -o nolock -o ro ${NFSOPTS} "${NFSROOT}" "${mountpoint}" && rc=0 && break
 311                 sleep 1
 312         done
 313         return ${rc}
 314 }
 315
 316 do_cifsmount() {
 317         rc=1
 318         if [ -x "/sbin/mount.cifs" ]; then
 319                 if [ -z "${NFSOPTS}" ]; then
 320                         CIFSOPTS="-ouser=root,password="
 321                 else
 322                         CIFSOPTS="${NFSOPTS}"
 323                 fi
 324
 325                 [ "$quiet" != "y" ] && log_begin_msg "Trying mount.cifs ${NFSROOT} ${mountpoint} ${CIFSOPTS}"
 326                 modprobe -q cifs
 327
 328                 if mount.cifs "${NFSROOT}" "${mountpoint}" "${CIFSOPTS}" ; then
 329                         rc=0
 330                 fi
 331         fi
 332         return ${rc}
 333 }
 334
 335 setup_unionfs() {
 336         image_directory="$1"
 337         rootmnt="$2"
 338
 339         modprobe -qb unionfs
 340
 341         croot=""        # Should really be /casper, but run-init doesn't handle
 342                                 # mount-points in subdirectories at all
 343
 344         # Let's just mount the read-only file systems first
 345         rofsstring=""
 346         rofslist=""
 347         mkdir -p "${croot}"
 348         for image_type in "ext2" "squashfs" "dir" ; do
 349                 for image in "${image_directory}"/*."${image_type}"; do
 350                         imagename=$(basename "${image}")
 351                         if [ -d "${image}" ]; then
 352                                 # it is a plain directory: do nothing
 353                                 rofslist="${image} ${rofslist}"
 354                                 rofsstring="${image}=ro:${rofsstring}"
 355                         elif [ -f "${image}" ]; then
 356                                 backdev=$(get_backing_device "$image")
 357                                 fstype=$(get_fstype "${backdev}")
 358                                 if [ "${fstype}" = "unknown" ]; then
 359                                         panic "Unknown file system type on ${backdev} (${image})"
 360                                 fi
 361                                 mkdir -p "${croot}/${imagename}"
 362                                 mount -t "${fstype}" -o ro "${backdev}" "${croot}/${imagename}" || panic "Can not mount $backdev ($image) on ${croot}/${imagename}" && rofsstring="${croot}/${imagename}=ro:${rofsstring}" && rofslist="${croot}/${imagename} ${rofslist}"
 363                         fi
 364                 done
 365         done
 366         rofsstring=${rofsstring%:}
 367
 368         mkdir -p /cow
 369         cowdevice="tmpfs"
 370         cow_fstype="tmpfs"
 371
 372         # Looking for "${root_persistence}" device or file
 373         if [ ! -z "${PERSISTENT}" ]; then
 374                 cowprobe=$(find_cow_device "${root_persistence}")
 375                 if [ -b "${cowprobe}" ]; then
 376                         cowdevice=${cowprobe}
 377                         cow_fstype=$(get_fstype "${cowprobe}")
 378                 else
 379                         [ "$quiet" != "y" ] &&  log_begin_msg "Unable to find the persistent medium"
 380                 fi
 381         fi
 382
 383         mount ${cowdevice} -t ${cow_fstype} -o rw /cow || panic "Can not mount $cowdevice on /cow"
 384
 385         mount -t unionfs -o dirs=/cow=rw:$rofsstring unionfs "$rootmnt" || panic "Unionfs mount failed"
 386
 387         for d in ${rofslist}; do
 388                 mkdir -p "${rootmnt}/casper/${d}"
 389                 mount -o bind "${d}" "${rootmnt}/casper/${d}"
 390                 case d in
 391                         *.dir) ;; # do nothing
 392                         *) umount "${d}" ;;
 393                 esac
 394         done
 395
 396         # Adding other custom mounts
 397         if [ ! -z "${PERSISTENT}" ]; then
 398                 homecow=$(find_cow_device "${home_persistence}" )
 399                 if [ -b "${homecow}" ]; then
 400                         mount ${homecow} -t $(get_fstype "${homecow}") -o rw "${rootmnt}/home"
 401                 else
 402                         [ "$quiet" != "y" ] &&  log_begin_msg "Unable to find the persistent home medium"
 403                 fi
 404         fi
 405
 406         if [ ! -z "${SHOWCOW}" ]; then
 407                 mkdir -p "$rootmnt/cow"
 408                 mount -o bind /cow "$rootmnt/cow"
 409         fi
 410 }
 411
 412 is_usb_device() {
 413     sysfs_path="${1#/sys}"
 414     if /lib/udev/path_id "${sysfs_path}" | grep -Eq "ID_PATH=(usb|pci-[^-]*-usb)"; then
 415         return 0
 416     fi
 417     return 1
 418 }
 419
 420 find_livefs() {
 421         mounted=
 422         for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -v loop | grep -v ram); do
 423                 devname=$(sys2dev "${sysblock}")
 424                 fstype=$(get_fstype "${devname}")
 425                 if /lib/udev/cdrom_id ${devname} > /dev/null; then
 426                         mount -t ${fstype} -o ro "$devname" $mountpoint || continue
 427                         if is_casper_path $mountpoint; then
 428                                 echo $mountpoint
 429                                 return
 430                         else
 431                                 umount $mountpoint
 432                         fi
 433                 elif is_usb_device "$sysblock"; then
 434                         for dev in $(subdevices "${sysblock}"); do
 435                                 devname=$(sys2dev "${dev}")
 436                                 fstype=$(get_fstype "${devname}")
 437                                 case ${fstype} in
 438                                         vfat|iso9660|udf)
 439                                                 mount -t ${fstype} -o ro "${devname}" $mountpoint || continue
 440                                                 if is_casper_path $mountpoint; then
 441                                                         echo $mountpoint
 442                                                         return
 443                                                 else
 444                                                         umount $mountpoint
 445                                                 fi
 446                                                 ;;
 447                                 esac
 448                         done
 449                 elif [ "${fstype}" = "squashfs" ||  \
 450                                 "${fstype}" = "ext2" ]; then
 451
 452                         # This is an ugly hack situation, the block device has
 453                         # an image directly on it.  It's hopefully
 454                         # casper, so take it and run with it.
 455
 456                         ln -s "${devname}" "${devname}.${fstype}"
 457                         echo "${devname}.${fstype}"
 458                         return
 459                 fi
 460         done
 461 }
 462
 463 set_usplash_timeout() {
 464         if [ -x /sbin/usplash_write ]; then
 465                 /sbin/usplash_write "TIMEOUT 120"
 466         fi
 467 }
 468
 469 mountroot() {
 470         exec 6>&1
 471         exec 7>&2
 472         exec > casper.log
 473         exec 2>&1
 474
 475         set_usplash_timeout
 476         [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-premount"
 477         run_scripts /scripts/casper-premount
 478         [ "$quiet" != "y" ] && log_end_msg
 479
 480         # Needed here too because some things (*cough* udev *cough*)
 481         # changes the timeout
 482
 483         set_usplash_timeout
 484
 485         if [ ! -z "${NETBOOT}" ]; then
 486                 if do_netmount ; then
 487                         livefs_root="${mountpoint}"
 488                 else
 489                         panic "Unable to find a the network rootfs live file system"
 490                 fi
 491         else
 492                 # Scan local devices for the image
 493                 for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13; do
 494                         livefs_root=$(find_livefs)
 495                         if [ "${livefs_root}" ]; then
 496                                 break
 497                         fi
 498                 done
 499
 500                 if [ "$?" -gt 0 ]; then
 501                         panic "Unable to find a medium containing a live file system"
 502                 fi
 503
 504                 if [ ! -z "${TORAM}" ]; then
 505                         copy_to_ram "${livefs_root}"
 506                 fi
 507         fi
 508         sleep 1
 509
 510         mount_images_in_directory "$livefs_root" "$rootmnt"
 511
 512         log_end_msg
 513
 514         maybe_break casper-bottom
 515         [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-bottom"
 516
 517         run_scripts /scripts/casper-bottom
 518         [ "$quiet" != "y" ] && log_end_msg
 519
 520         exec 1>&6 6>&-
 521         exec 2>&7 7>&-
 522         cp casper.log "${rootmnt}/var/log/"
 523 }