minimal/config/includes.chroot/lib/live/boot/9990-misc-helpers.sh

   1 #!/bin/sh
   2
   3 #set -e
   4
   5 is_live_path ()
   6 {
   7         DIRECTORY="${1}"
   8
   9         if [ -d "${DIRECTORY}"/"${LIVE_MEDIA_PATH}" ]
  10         then
  11                 for FILESYSTEM in squashfs ext2 ext3 ext4 xfs dir jffs2
  12                 do
  13                         if [ "$(echo ${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM})" != "${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM}" ]
  14                         then
  15                                 return 0
  16                         fi
  17                 done
  18         fi
  19
  20         return 1
  21 }
  22
  23 matches_uuid ()
  24 {
  25         if [ "${IGNORE_UUID}" ] || [ ! -e /conf/uuid.conf ]
  26         then
  27                 return 0
  28         fi
  29
  30         path="${1}"
  31         uuid="$(cat /conf/uuid.conf)"
  32
  33         for try_uuid_file in "${path}/.disk/live-uuid"*
  34         do
  35                 [ -e "${try_uuid_file}" ] || continue
  36
  37                 try_uuid="$(cat "${try_uuid_file}")"
  38
  39                 if [ "${uuid}" = "${try_uuid}" ]
  40                 then
  41                         return 0
  42                 fi
  43         done
  44
  45         return 1
  46 }
  47
  48 get_backing_device ()
  49 {
  50         case "${1}" in
  51                 *.squashfs|*.ext2|*.ext3|*.ext4|*.jffs2)
  52                         echo $(setup_loop "${1}" "loop" "/sys/block/loop*" '0' "${LIVE_MEDIA_ENCRYPTION}" "${2}")
  53                         ;;
  54
  55                 *.dir)
  56                         echo "directory"
  57                         ;;
  58
  59                 *)
  60                         panic "Unrecognized live filesystem: ${1}"
  61                         ;;
  62         esac
  63 }
  64
  65 match_files_in_dir ()
  66 {
  67         # Does any files match pattern ${1} ?
  68         local pattern
  69         pattern="${1}"
  70
  71         if [ "$(echo ${pattern})" != "${pattern}" ]
  72         then
  73                 return 0
  74         fi
  75
  76         return 1
  77 }
  78
  79 mount_images_in_directory ()
  80 {
  81         directory="${1}"
  82         rootmnt="${2}"
  83         mac="${3}"
  84
  85         if match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.squashfs" ||
  86                 match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext2" ||
  87                 match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext3" ||
  88                 match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext4" ||
  89                 match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.jffs2" ||
  90                 match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.dir"
  91         then
  92                 [ -n "${mac}" ] && adddirectory="${directory}/${LIVE_MEDIA_PATH}/${mac}"
  93                 setup_unionfs "${directory}/${LIVE_MEDIA_PATH}" "${rootmnt}" "${adddirectory}"
  94         else
  95                 panic "No supported filesystem images found at /${LIVE_MEDIA_PATH}."
  96         fi
  97 }
  98
  99 is_nice_device ()
 100 {
 101         sysfs_path="${1#/sys}"
 102
 103         if [ -e /lib/udev/path_id ]
 104         then
 105                 # squeeze
 106                 PATH_ID="/lib/udev/path_id"
 107         else
 108                 # wheezy/sid (udev >= 174)
 109                 PATH_ID="/sbin/udevadm test-builtin path_id"
 110         fi
 111
 112         if ${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)"
 113         then
 114                 return 0
 115         elif echo "${sysfs_path}" | grep -q '^/block/vd[a-z]$'
 116         then
 117                 return 0
 118         elif echo ${sysfs_path} | grep -q "^/block/dm-"
 119         then
 120                 return 0
 121         elif echo ${sysfs_path} | grep -q "^/block/mtdblock"
 122         then
 123                 return 0
 124         fi
 125
 126         return 1
 127 }
 128
 129 check_dev ()
 130 {
 131         sysdev="${1}"
 132         devname="${2}"
 133         skip_uuid_check="${3}"
 134
 135         # support for fromiso=.../isofrom=....
 136         if [ -n "$FROMISO" ]
 137         then
 138                 ISO_DEVICE=$(dirname $FROMISO)
 139                 if ! [ -b $ISO_DEVICE ]
 140                 then
 141                         # to support unusual device names like /dev/cciss/c0d0p1
 142                         # as well we have to identify the block device name, let's
 143                         # do that for up to 15 levels
 144                         i=15
 145                         while [ -n "$ISO_DEVICE" ] && [ "$i" -gt 0 ]
 146                         do
 147                                 ISO_DEVICE=$(dirname ${ISO_DEVICE})
 148                                 [ -b "$ISO_DEVICE" ] && break
 149                                 i=$(($i -1))
 150                         done
 151                 fi
 152
 153                 if [ "$ISO_DEVICE" = "/" ]
 154                 then
 155                         echo "Warning: device for bootoption fromiso= ($FROMISO) not found.">>/boot.log
 156                 else
 157                         fs_type=$(get_fstype "${ISO_DEVICE}")
 158                         if is_supported_fs ${fs_type}
 159                         then
 160                                 mkdir /live/fromiso
 161                                 mount -t $fs_type "$ISO_DEVICE" /live/fromiso
 162                                 ISO_NAME="$(echo $FROMISO | sed "s|$ISO_DEVICE||")"
 163                                 loopdevname=$(setup_loop "/live/fromiso/${ISO_NAME}" "loop" "/sys/block/loop*" "" '')
 164                                 devname="${loopdevname}"
 165                         else
 166                                 echo "Warning: unable to mount $ISO_DEVICE." >>/boot.log
 167                         fi
 168                 fi
 169         fi
 170
 171         if [ -z "${devname}" ]
 172         then
 173                 devname=$(sys2dev "${sysdev}")
 174         fi
 175
 176         if [ -d "${devname}" ]
 177         then
 178                 mount -o bind "${devname}" $mountpoint || continue
 179
 180                 if is_live_path $mountpoint
 181                 then
 182                         echo $mountpoint
 183                         return 0
 184                 else
 185                         umount $mountpoint
 186                 fi
 187         fi
 188
 189         IFS=","
 190         for device in ${devname}
 191         do
 192                 case "$device" in
 193                         *mapper*)
 194                                 # Adding lvm support
 195                                 if [ -x /scripts/local-top/lvm2 ]
 196                                 then
 197                                         ROOT="$device" resume="" /scripts/local-top/lvm2
 198                                 fi
 199                                 ;;
 200
 201                         /dev/md*)
 202                                 # Adding raid support
 203                                 if [ -x /scripts/local-top/mdadm ]
 204                                 then
 205                                         cp /conf/conf.d/md /conf/conf.d/md.orig
 206                                         echo "MD_DEVS=$device " >> /conf/conf.d/md
 207                                         /scripts/local-top/mdadm
 208                                         mv /conf/conf.d/md.orig /conf/conf.d/md
 209                                 fi
 210                                 ;;
 211                 esac
 212         done
 213         unset IFS
 214
 215         [ -n "$device" ] && devname="$device"
 216
 217         [ -e "$devname" ] || continue
 218
 219         if [ -n "${LIVE_MEDIA_OFFSET}" ]
 220         then
 221                 loopdevname=$(setup_loop "${devname}" "loop" "/sys/block/loop*" "${LIVE_MEDIA_OFFSET}" '')
 222                 devname="${loopdevname}"
 223         fi
 224
 225         fstype=$(get_fstype "${devname}")
 226
 227         if is_supported_fs ${fstype}
 228         then
 229                 devuid=$(blkid -o value -s UUID "$devname")
 230                 [ -n "$devuid" ] && grep -qs "\<$devuid\>" $tried && continue
 231                 mount -t ${fstype} -o ro,noatime "${devname}" ${mountpoint} || continue
 232                 [ -n "$devuid" ] && echo "$devuid" >> $tried
 233
 234                 if [ -n "${FINDISO}" ]
 235                 then
 236                         if [ -f ${mountpoint}/${FINDISO} ]
 237                         then
 238                                 umount ${mountpoint}
 239                                 mkdir -p /live/findiso
 240                                 mount -t ${fstype} -o ro,noatime "${devname}" /live/findiso
 241                                 loopdevname=$(setup_loop "/live/findiso/${FINDISO}" "loop" "/sys/block/loop*" 0 "")
 242                                 devname="${loopdevname}"
 243                                 mount -t iso9660 -o ro,noatime "${devname}" ${mountpoint}
 244                         else
 245                                 umount ${mountpoint}
 246                         fi
 247                 fi
 248
 249                 if is_live_path ${mountpoint} && \
 250                         ([ "${skip_uuid_check}" ] || matches_uuid ${mountpoint})
 251                 then
 252                         echo ${mountpoint}
 253                         return 0
 254                 else
 255                         umount ${mountpoint} 2>/dev/null
 256                 fi
 257         fi
 258
 259         if [ -n "${LIVE_MEDIA_OFFSET}" ]
 260         then
 261                 losetup -d "${loopdevname}"
 262         fi
 263
 264         return 1
 265 }
 266
 267 find_livefs ()
 268 {
 269         timeout="${1}"
 270
 271         # don't start autodetection before timeout has expired
 272         if [ -n "${LIVE_MEDIA_TIMEOUT}" ]
 273         then
 274                 if [ "${timeout}" -lt "${LIVE_MEDIA_TIMEOUT}" ]
 275                 then
 276                         return 1
 277                 fi
 278         fi
 279
 280         # first look at the one specified in the command line
 281         case "${LIVE_MEDIA}" in
 282                 removable-usb)
 283                         for sysblock in $(removable_usb_dev "sys")
 284                         do
 285                                 for dev in $(subdevices "${sysblock}")
 286                                 do
 287                                         if check_dev "${dev}"
 288                                         then
 289                                                 return 0
 290                                         fi
 291                                 done
 292                         done
 293                         return 1
 294                         ;;
 295
 296                 removable)
 297                         for sysblock in $(removable_dev "sys")
 298                         do
 299                                 for dev in $(subdevices "${sysblock}")
 300                                 do
 301                                         if check_dev "${dev}"
 302                                         then
 303                                                 return 0
 304                                         fi
 305                                 done
 306                         done
 307                         return 1
 308                         ;;
 309
 310                 *)
 311                         if [ ! -z "${LIVE_MEDIA}" ]
 312                         then
 313                                 if check_dev "null" "${LIVE_MEDIA}" "skip_uuid_check"
 314                                 then
 315                                         return 0
 316                                 fi
 317                         fi
 318                         ;;
 319         esac
 320
 321         # or do the scan of block devices
 322         # prefer removable devices over non-removable devices, so scan them first
 323         devices_to_scan="$(removable_dev 'sys') $(non_removable_dev 'sys')"
 324
 325         for sysblock in $devices_to_scan
 326         do
 327                 devname=$(sys2dev "${sysblock}")
 328                 [ -e "$devname" ] || continue
 329                 fstype=$(get_fstype "${devname}")
 330
 331                 if /lib/udev/cdrom_id ${devname} > /dev/null
 332                 then
 333                         if check_dev "null" "${devname}"
 334                         then
 335                                 return 0
 336                         fi
 337                 elif is_nice_device "${sysblock}"
 338                 then
 339                         for dev in $(subdevices "${sysblock}")
 340                         do
 341                                 if check_dev "${dev}"
 342                                 then
 343                                         return 0
 344                                 fi
 345                         done
 346                 elif [ "${fstype}" = "squashfs" -o \
 347                         "${fstype}" = "btrfs" -o \
 348                         "${fstype}" = "ext2" -o \
 349                         "${fstype}" = "ext3" -o \
 350                         "${fstype}" = "ext4" -o \
 351                         "${fstype}" = "jffs2" ]
 352                 then
 353                         # This is an ugly hack situation, the block device has
 354                         # an image directly on it.  It's hopefully
 355                         # live-boot, so take it and run with it.
 356                         ln -s "${devname}" "${devname}.${fstype}"
 357                         echo "${devname}.${fstype}"
 358                         return 0
 359                 fi
 360         done
 361
 362         return 1
 363 }
 364
 365 really_export ()
 366 {
 367         STRING="${1}"
 368         VALUE="$(eval echo -n \${$STRING})"
 369
 370         if [ -f /live.vars ] && grep -sq "export ${STRING}" /live.vars
 371         then
 372                 sed -i -e 's/\('${STRING}'=\).*$/\1'${VALUE}'/' /live.vars
 373         else
 374                 echo "export ${STRING}=\"${VALUE}\"" >> /live.vars
 375         fi
 376
 377         eval export "${STRING}"="${VALUE}"
 378 }
 379
 380 is_in_list_separator_helper ()
 381 {
 382         local sep element list
 383         sep=${1}
 384         shift
 385         element=${1}
 386         shift
 387         list=${*}
 388         echo ${list} | grep -qe "^\(.*${sep}\)\?${element}\(${sep}.*\)\?$"
 389 }
 390
 391 is_in_space_sep_list ()
 392 {
 393         local element
 394         element=${1}
 395         shift
 396         is_in_list_separator_helper "[[:space:]]" "${element}" "${*}"
 397 }
 398
 399 is_in_comma_sep_list ()
 400 {
 401         local element
 402         element=${1}
 403         shift
 404         is_in_list_separator_helper "," "${element}" "${*}"
 405 }
 406
 407 sys2dev ()
 408 {
 409         sysdev=${1#/sys}
 410         echo "/dev/$($udevinfo -q name -p ${sysdev} 2>/dev/null|| echo ${sysdev##*/})"
 411 }
 412
 413 subdevices ()
 414 {
 415         sysblock=${1}
 416         r=""
 417
 418         for dev in "${sysblock}"/* "${sysblock}"
 419         do
 420                 if [ -e "${dev}/dev" ]
 421                 then
 422                         r="${r} ${dev}"
 423                 fi
 424         done
 425
 426         echo ${r}
 427 }
 428
 429 storage_devices()
 430 {
 431         black_listed_devices="${1}"
 432         white_listed_devices="${2}"
 433
 434         for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "loop|ram|fd")
 435         do
 436                 fulldevname=$(sys2dev "${sysblock}")
 437
 438                 if is_in_space_sep_list ${fulldevname} ${black_listed_devices} || \
 439                         [ -n "${white_listed_devices}" ] && \
 440                         ! is_in_space_sep_list ${fulldevname} ${white_listed_devices}
 441                 then
 442                         # skip this device entirely
 443                         continue
 444                 fi
 445
 446                 for dev in $(subdevices "${sysblock}")
 447                 do
 448                         devname=$(sys2dev "${dev}")
 449
 450                         if is_in_space_sep_list ${devname} ${black_listed_devices}
 451                         then
 452                                 # skip this subdevice
 453                                 continue
 454                         else
 455                                 echo "${devname}"
 456                         fi
 457                 done
 458         done
 459 }
 460
 461 is_supported_fs ()
 462 {
 463         fstype="${1}"
 464
 465         # Validate input first
 466         if [ -z "${fstype}" ]
 467         then
 468                 return 1
 469         fi
 470
 471         # Try to look if it is already supported by the kernel
 472         if grep -q ${fstype} /proc/filesystems
 473         then
 474                 return 0
 475         else
 476                 # Then try to add support for it the gentle way using the initramfs capabilities
 477                 modprobe ${fstype}
 478                 if grep -q ${fstype} /proc/filesystems
 479                 then
 480                         return 0
 481                 # Then try the hard way if /root is already reachable
 482                 else
 483                         kmodule="/root/lib/modules/`uname -r`/${fstype}/${fstype}.ko"
 484                         if [ -e "${kmodule}" ]
 485                         then
 486                                 insmod "${kmodule}"
 487                                 if grep -q ${fstype} /proc/filesystems
 488                                 then
 489                                         return 0
 490                                 fi
 491                         fi
 492                 fi
 493         fi
 494
 495         return 1
 496 }
 497
 498 get_fstype ()
 499 {
 500         /sbin/blkid -s TYPE -o value $1 2>/dev/null
 501 }
 502
 503 where_is_mounted ()
 504 {
 505         device=${1}
 506         # return first found
 507         grep -m1 "^${device} " /proc/mounts | cut -f2 -d ' '
 508 }
 509
 510 trim_path ()
 511 {
 512         # remove all unnecessary /:s in the path, including last one (except
 513         # if path is just "/")
 514         echo ${1} | sed 's|//\+|/|g' | sed 's|^\(.*[^/]\)/$|\1|'
 515 }
 516
 517 what_is_mounted_on ()
 518 {
 519         local dir
 520         dir="$(trim_path ${1})"
 521         grep -m1 "^[^ ]\+ ${dir} " /proc/mounts | cut -d' ' -f1
 522 }
 523
 524 chown_ref ()
 525 {
 526         local reference targets owner
 527         reference="${1}"
 528         shift
 529         targets=${@}
 530         owner=$(stat -c %u:%g "${reference}")
 531         chown -h ${owner} ${targets}
 532 }
 533
 534 chmod_ref ()
 535 {
 536         local reference targets rights
 537         reference="${1}"
 538         shift
 539         targets=${@}
 540         rights=$(stat -c %a "${reference}")
 541         chmod ${rights} ${targets}
 542 }
 543
 544 lastline ()
 545 {
 546         while read lines
 547         do
 548                 line=${lines}
 549         done
 550
 551         echo "${line}"
 552 }
 553
 554 base_path ()
 555 {
 556         testpath="${1}"
 557         mounts="$(awk '{print $2}' /proc/mounts)"
 558         testpath="$(busybox realpath ${testpath})"
 559
 560         while true
 561         do
 562                 if echo "${mounts}" | grep -qs "^${testpath}"
 563                 then
 564                         set -- $(echo "${mounts}" | grep "^${testpath}" | lastline)
 565                         echo ${1}
 566                         break
 567                 else
 568                         testpath=$(dirname $testpath)
 569                 fi
 570         done
 571 }
 572
 573 fs_size ()
 574 {
 575         # Returns used/free fs kbytes + 5% more
 576         # You could pass a block device as ${1} or the mount point as ${2}
 577
 578         dev="${1}"
 579         mountp="${2}"
 580         used="${3}"
 581
 582         if [ -z "${mountp}" ]
 583         then
 584                 mountp="$(where_is_mounted ${dev})"
 585
 586                 if [ -z "${mountp}" ]
 587                 then
 588                         mountp="/mnt/tmp_fs_size"
 589
 590                         mkdir -p "${mountp}"
 591                         mount -t $(get_fstype "${dev}") -o ro "${dev}" "${mountp}" || log_warning_msg "cannot mount -t $(get_fstype ${dev}) -o ro ${dev} ${mountp}"
 592
 593                         doumount=1
 594                 fi
 595         fi
 596
 597         if [ "${used}" = "used" ]
 598         then
 599                 size=$(du -ks ${mountp} | cut -f1)
 600                 size=$(expr ${size} + ${size} / 20 ) # FIXME: 5% more to be sure
 601         else
 602                 # free space
 603                 size="$(df -kP | grep -s ${mountp} | awk '{print $4}')"
 604         fi
 605
 606         if [ -n "${doumount}" ]
 607         then
 608                 umount "${mountp}" || log_warning_msg "cannot umount ${mountp}"
 609                 rmdir "${mountp}"
 610         fi
 611
 612         echo "${size}"
 613 }
 614
 615 load_keymap ()
 616 {
 617         # Load custom keymap
 618         if [ -x /bin/loadkeys -a -r /etc/boottime.kmap.gz ]
 619         then
 620                 loadkeys -q /etc/boottime.kmap.gz
 621         fi
 622 }
 623
 624 setup_loop ()
 625 {
 626         local fspath module pattern offset encryption readonly
 627         fspath=${1}
 628         module=${2}
 629         pattern=${3}
 630         offset=${4}
 631         encryption=${5}
 632         readonly=${6}
 633
 634         # the output of setup_loop is evaluated in other functions,
 635         # modprobe leaks kernel options like "libata.dma=0"
 636         # as "options libata dma=0" on stdout, causing serious
 637         # problems therefor, so instead always avoid output to stdout
 638         modprobe -q -b "${module}" 1>/dev/null
 639
 640         udevadm settle
 641
 642         for loopdev in ${pattern}
 643         do
 644                 if [ "$(cat ${loopdev}/size)" -eq 0 ]
 645                 then
 646                         dev=$(sys2dev "${loopdev}")
 647                         options=''
 648
 649                         if [ -n "${readonly}" ]
 650                         then
 651                                 if losetup --help 2>&1 | grep -q -- "-r\b"
 652                                 then
 653                                         options="${options} -r"
 654                                 fi
 655                         fi
 656
 657                         if [ -n "${offset}" ] && [ 0 -lt "${offset}" ]
 658                         then
 659                                 options="${options} -o ${offset}"
 660                         fi
 661
 662                         if [ -z "${encryption}" ]
 663                         then
 664                                 losetup ${options} "${dev}" "${fspath}"
 665                         else
 666                                 # Loop AES encryption
 667                                 while true
 668                                 do
 669                                         load_keymap
 670
 671                                         echo -n "Enter passphrase for root filesystem: " >&6
 672                                         read -s passphrase
 673                                         echo "${passphrase}" > /tmp/passphrase
 674                                         unset passphrase
 675                                         exec 9</tmp/passphrase
 676                                         /sbin/losetup ${options} -e "${encryption}" -p 9 "${dev}" "${fspath}"
 677                                         error=${?}
 678                                         exec 9<&-
 679                                         rm -f /tmp/passphrase
 680
 681                                         if [ 0 -eq ${error} ]
 682                                         then
 683                                                 unset error
 684                                                 break
 685                                         fi
 686
 687                                         echo
 688                                         echo -n "There was an error decrypting the root filesystem ... Retry? [Y/n] " >&6
 689                                         read answer
 690
 691                                         if [ "$(echo "${answer}" | cut -b1 | tr A-Z a-z)" = "n" ]
 692                                         then
 693                                                 unset answer
 694                                                 break
 695                                         fi
 696                                 done
 697                         fi
 698
 699                         echo "${dev}"
 700                         return 0
 701                 fi
 702         done
 703
 704         panic "No loop devices available"
 705 }
 706
 707 try_mount ()
 708 {
 709         dev="${1}"
 710         mountp="${2}"
 711         opts="${3}"
 712         fstype="${4}"
 713
 714         old_mountp="$(where_is_mounted ${dev})"
 715
 716         if [ -n "${old_mountp}" ]
 717         then
 718                 if [ "${opts}" != "ro" ]
 719                 then
 720                         mount -o remount,"${opts}" "${dev}" "${old_mountp}" || panic "Remounting ${dev} ${opts} on ${old_mountp} failed"
 721                 fi
 722
 723                 mount -o bind "${old_mountp}" "${mountp}" || panic "Cannot bind-mount ${old_mountp} on ${mountp}"
 724         else
 725                 if [ -z "${fstype}" ]
 726                 then
 727                         fstype=$(get_fstype "${dev}")
 728                 fi
 729                 mount -t "${fstype}" -o "${opts}" "${dev}" "${mountp}" || \
 730                 ( echo "SKIPPING: Cannot mount ${dev} on ${mountp}, fstype=${fstype}, options=${opts}" > boot.log && return 0 )
 731         fi
 732 }
 733
 734 # Try to mount $device to the place expected by live-boot. If $device
 735 # is already mounted somewhere, move it to the expected place. If
 736 # we're only probing $device (to check if it has custom persistence)
 737 # $probe should be set, which suppresses warnings upon failure. On
 738 # success, print the mount point for $device.
 739 mount_persistence_media ()
 740 {
 741         local device probe backing old_backing fstype mount_opts
 742         device=${1}
 743         probe=${2}
 744
 745         backing="/live/persistence/$(basename ${device})"
 746
 747         mkdir -p "${backing}"
 748         old_backing="$(where_is_mounted ${device})"
 749         if [ -z "${old_backing}" ]
 750         then
 751                 fstype="$(get_fstype ${device})"
 752                 mount_opts="rw,noatime"
 753                 if [ -n "${PERSISTENCE_READONLY}" ]
 754                 then
 755                         mount_opts="ro,noatime"
 756                 fi
 757                 if mount -t "${fstype}" -o "${mount_opts}" "${device}" "${backing}" >/dev/null
 758                 then
 759                         echo ${backing}
 760                         return 0
 761                 else
 762                         [ -z "${probe}" ] && log_warning_msg "Failed to mount persistence media ${device}"
 763                         rmdir "${backing}"
 764                         return 1
 765                 fi
 766         elif [ "${backing}" != "${old_backing}" ]
 767         then
 768                 if mount --move ${old_backing} ${backing} >/dev/null
 769                 then
 770                         echo ${backing}
 771                         return 0
 772                 else
 773                         [ -z "${probe}" ] && log_warning_msg "Failed to move persistence media ${device}"
 774                         rmdir "${backing}"
 775                         return 1
 776                 fi
 777         else
 778                 # This means that $device has already been mounted on
 779                 # the place expected by live-boot, so we're done.
 780                 echo ${backing}
 781                 return 0
 782         fi
 783 }
 784
 785 close_persistence_media ()
 786 {
 787         local device backing
 788         device=${1}
 789         backing="$(where_is_mounted ${device})"
 790
 791         if [ -d "${backing}" ]
 792         then
 793                 umount "${backing}" >/dev/null 2>&1
 794                 rmdir "${backing}" >/dev/null 2>&1
 795         fi
 796
 797         if is_active_luks_mapping ${device}
 798         then
 799                 /sbin/cryptsetup luksClose ${device}
 800         fi
 801 }
 802
 803 open_luks_device ()
 804 {
 805         dev="${1}"
 806         name="$(basename ${dev})"
 807         opts="--key-file=-"
 808         if [ -n "${PERSISTENCE_READONLY}" ]
 809         then
 810                 opts="${opts} --readonly"
 811         fi
 812
 813         if /sbin/cryptsetup status "${name}" >/dev/null 2>&1
 814         then
 815                 re="^[[:space:]]*device:[[:space:]]*\([^[:space:]]*\)$"
 816                 opened_dev=$(cryptsetup status ${name} 2>/dev/null | grep "${re}" | sed "s|${re}|\1|")
 817                 if [ "${opened_dev}" = "${dev}" ]
 818                 then
 819                         luks_device="/dev/mapper/${name}"
 820                         echo ${luks_device}
 821                         return 0
 822                 else
 823                         log_warning_msg "Cannot open luks device ${dev} since ${opened_dev} already is opened with its name"
 824                         return 1
 825                 fi
 826         fi
 827
 828         load_keymap
 829
 830         while true
 831         do
 832                 /lib/cryptsetup/askpass "Enter passphrase for ${dev}: " | \
 833                         /sbin/cryptsetup -T 1 luksOpen ${dev} ${name} ${opts}
 834
 835                 if [ 0 -eq ${?} ]
 836                 then
 837                         luks_device="/dev/mapper/${name}"
 838                         echo ${luks_device}
 839                         return 0
 840                 fi
 841
 842                 echo >&6
 843                 echo -n "There was an error decrypting ${dev} ... Retry? [Y/n] " >&6
 844                 read answer
 845
 846                 if [ "$(echo "${answer}" | cut -b1 | tr A-Z a-z)" = "n" ]
 847                 then
 848                         return 2
 849                 fi
 850         done
 851 }
 852
 853 get_gpt_name ()
 854 {
 855     local dev
 856     dev="${1}"
 857     /sbin/blkid -s PART_ENTRY_NAME -p -o value ${dev} 2>/dev/null
 858 }
 859
 860 is_gpt_device ()
 861 {
 862     local dev
 863     dev="${1}"
 864     [ "$(/sbin/blkid -s PART_ENTRY_SCHEME -p -o value ${dev} 2>/dev/null)" = "gpt" ]
 865 }
 866
 867 probe_for_gpt_name ()
 868 {
 869         local overlays dev gpt_dev gpt_name
 870         overlays="${1}"
 871         dev="${2}"
 872
 873         gpt_dev="${dev}"
 874         if is_active_luks_mapping ${dev}
 875         then
 876                 # if $dev is an opened luks device, we need to check
 877                 # GPT stuff on the backing device
 878                 gpt_dev=$(get_luks_backing_device "${dev}")
 879         fi
 880
 881         if ! is_gpt_device ${gpt_dev}
 882         then
 883                 return
 884         fi
 885
 886         gpt_name=$(get_gpt_name ${gpt_dev})
 887         for label in ${overlays}
 888         do
 889                 if [ "${gpt_name}" = "${label}" ]
 890                 then
 891                         echo "${label}=${dev}"
 892                 fi
 893         done
 894 }
 895
 896 probe_for_fs_label ()
 897 {
 898         local overlays dev
 899         overlays="${1}"
 900         dev="${2}"
 901
 902         for label in ${overlays}
 903         do
 904                 if [ "$(/sbin/blkid -s LABEL -o value $dev 2>/dev/null)" = "${label}" ]
 905                 then
 906                         echo "${label}=${dev}"
 907                 fi
 908         done
 909 }
 910
 911 probe_for_file_name ()
 912 {
 913         local overlays dev ret backing
 914         overlays="${1}"
 915         dev="${2}"
 916
 917         ret=""
 918         backing="$(mount_persistence_media ${dev} probe)"
 919         if [ -z "${backing}" ]
 920         then
 921             return
 922         fi
 923
 924         for label in ${overlays}
 925         do
 926                 path=${backing}/${PERSISTENCE_PATH}${label}
 927                 if [ -f "${path}" ]
 928                 then
 929                         local loopdev
 930                         loopdev=$(setup_loop "${path}" "loop" "/sys/block/loop*")
 931                         ret="${ret} ${label}=${loopdev}"
 932                 fi
 933         done
 934
 935         if [ -n "${ret}" ]
 936         then
 937                 echo ${ret}
 938         else
 939                 # unmount and remove mountpoint
 940                 umount ${backing} > /dev/null 2>&1 || true
 941                 rmdir ${backing} > /dev/null 2>&1 || true
 942         fi
 943 }
 944
 945 find_persistence_media ()
 946 {
 947         # Scans devices for overlays, and returns a whitespace
 948         # separated list of how to use them. Only overlays with a partition
 949         # label or file name in ${overlays} are returned.
 950         #
 951         # When scanning a LUKS device, the user will be asked to enter the
 952         # passphrase; on failure to enter it, or if no persistence partitions
 953         # or files were found, the LUKS device is closed.
 954         #
 955         # For all other cases (overlay partition and overlay file) the
 956         # return value is "${label}=${device}", where ${device} a device that
 957         # can mount the content. In the case of an overlay file, the device
 958         # containing the file will remain mounted as a side-effect.
 959         #
 960         # No devices in ${black_listed_devices} will be scanned, and if
 961         # ${white_list_devices} is non-empty, only devices in it will be
 962         # scanned.
 963
 964         local overlays white_listed_devices ret black_listed_devices
 965         overlays="${1}"
 966         white_listed_devices="${2}"
 967         ret=""
 968
 969         black_listed_devices="$(what_is_mounted_on /live/medium)"
 970
 971         for dev in $(storage_devices "${black_listed_devices}" "${white_listed_devices}")
 972         do
 973                 local result luks_device
 974                 result=""
 975
 976                 luks_device=""
 977                 # Check if it's a luks device; we'll have to open the device
 978                 # in order to probe any filesystem it contains, like we do
 979                 # below. activate_custom_mounts() also depends on that any luks
 980                 # device already has been opened.
 981                 if is_in_comma_sep_list luks ${PERSISTENCE_ENCRYPTION} && is_luks_partition ${dev}
 982                 then
 983                         if luks_device=$(open_luks_device "${dev}")
 984                         then
 985                                 dev="${luks_device}"
 986                         else
 987                                 # skip $dev since we failed/chose not to open it
 988                                 continue
 989                         fi
 990                 elif ! is_in_comma_sep_list none ${PERSISTENCE_ENCRYPTION}
 991                 then
 992                         # skip $dev since we don't allow unencrypted storage
 993                         continue
 994                 fi
 995
 996                 # Probe for matching GPT partition names or filesystem labels
 997                 if is_in_comma_sep_list filesystem ${PERSISTENCE_STORAGE}
 998                 then
 999                         result=$(probe_for_gpt_name "${overlays}" ${dev})
1000                         if [ -n "${result}" ]
1001                         then
1002                                 ret="${ret} ${result}"
1003                                 continue
1004                         fi
1005
1006                         result=$(probe_for_fs_label "${overlays}" ${dev})
1007                         if [ -n "${result}" ]
1008                         then
1009                                 ret="${ret} ${result}"
1010                                 continue
1011                         fi
1012                 fi
1013
1014                 # Probe for files with matching name on mounted partition
1015                 if is_in_comma_sep_list file ${PERSISTENCE_STORAGE}
1016                 then
1017                         result=$(probe_for_file_name "${overlays}" ${dev})
1018                         if [ -n "${result}" ]
1019                         then
1020                                 ret="${ret} ${result}"
1021                                 continue
1022                         fi
1023                 fi
1024
1025                 # Close luks device if it isn't used
1026                 if [ -z "${result}" ] && [ -n "${luks_device}" ] && is_active_luks_mapping "${luks_device}"
1027                 then
1028                         /sbin/cryptsetup luksClose "${luks_device}"
1029                 fi
1030         done
1031
1032         if [ -n "${ret}" ]
1033         then
1034                 echo ${ret}
1035         fi
1036 }
1037
1038 get_mac ()
1039 {
1040         mac=""
1041
1042         for adaptor in /sys/class/net/*
1043         do
1044                 status="$(cat ${adaptor}/iflink)"
1045
1046                 if [ "${status}" -eq 2 ]
1047                 then
1048                         mac="$(cat ${adaptor}/address)"
1049                         mac="$(echo ${mac} | sed 's/:/-/g' | tr '[a-z]' '[A-Z]')"
1050                 fi
1051         done
1052
1053         echo ${mac}
1054 }
1055
1056 is_luks_partition ()
1057 {
1058         device="${1}"
1059         /sbin/cryptsetup isLuks "${device}" 1>/dev/null 2>&1
1060 }
1061
1062 is_active_luks_mapping ()
1063 {
1064         device="${1}"
1065         /sbin/cryptsetup status "${device}" 1>/dev/null 2>&1
1066 }
1067
1068 get_luks_backing_device ()
1069 {
1070         device=${1}
1071         cryptsetup status ${device} 2> /dev/null | \
1072                 awk '{if ($1 == "device:") print $2}'
1073 }
1074
1075 removable_dev ()
1076 {
1077         output_format="${1}"
1078         want_usb="${2}"
1079         ret=
1080
1081         for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "/(loop|ram|dm-|fd)")
1082         do
1083                 dev_ok=
1084                 if [ "$(cat ${sysblock}/removable)" = "1" ]
1085                 then
1086                         if [ -z "${want_usb}" ]
1087                         then
1088                                 dev_ok="true"
1089                         else
1090                                 if readlink ${sysblock} | grep -q usb
1091                                 then
1092                                         dev_ok="true"
1093                                 fi
1094                         fi
1095                 fi
1096
1097                 if [ "${dev_ok}" = "true" ]
1098                 then
1099                         case "${output_format}" in
1100                                 sys)
1101                                         ret="${ret} ${sysblock}"
1102                                         ;;
1103                                 *)
1104                                         devname=$(sys2dev "${sysblock}")
1105                                         ret="${ret} ${devname}"
1106                                         ;;
1107                         esac
1108                 fi
1109         done
1110
1111         echo "${ret}"
1112 }
1113
1114 removable_usb_dev ()
1115 {
1116         output_format="${1}"
1117
1118         removable_dev "${output_format}" "want_usb"
1119 }
1120
1121 non_removable_dev ()
1122 {
1123         output_format="${1}"
1124         ret=
1125
1126         for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "/(loop|ram|dm-|fd)")
1127         do
1128                 if [ "$(cat ${sysblock}/removable)" = "0" ]
1129                 then
1130                         case "${output_format}" in
1131                                 sys)
1132                                         ret="${ret} ${sysblock}"
1133                                         ;;
1134                                 *)
1135                                         devname=$(sys2dev "${sysblock}")
1136                                         ret="${ret} ${devname}"
1137                                         ;;
1138                         esac
1139                 fi
1140         done
1141
1142         echo "${ret}"
1143 }
1144
1145 link_files ()
1146 {
1147         # create source's directory structure in dest, and recursively
1148         # create symlinks in dest to to all files in source. if mask
1149         # is non-empty, remove mask from all source paths when
1150         # creating links (will be necessary if we change root, which
1151         # live-boot normally does (into $rootmnt)).
1152         local src_dir dest_dir src_mask
1153
1154         # remove multiple /:s and ensure ending on /
1155         src_dir="$(trim_path ${1})/"
1156         dest_dir="$(trim_path ${2})/"
1157         src_mask="${3}"
1158
1159         # This check can only trigger on the inital, non-recursive call since
1160         # we create the destination before recursive calls
1161         if [ ! -d "${dest_dir}" ]
1162         then
1163                 log_warning_msg "Must link_files into a directory"
1164                 return
1165         fi
1166
1167         find "${src_dir}" -mindepth 1 -maxdepth 1 | \
1168         while read src
1169         do
1170                 local dest final_src
1171                 dest="${dest_dir}$(basename "${src}")"
1172                 if [ -d "${src}" ]
1173                 then
1174                         if [ -z "$(ls -A "${src}")" ]
1175                         then
1176                                 continue
1177                         fi
1178                         if [ ! -d "${dest}" ]
1179                         then
1180                                 mkdir -p "${dest}"
1181                                 chown_ref "${src}" "${dest}"
1182                                 chmod_ref "${src}" "${dest}"
1183                         fi
1184                         link_files "${src}" "${dest}" "${src_mask}"
1185                 else
1186                         final_src=${src}
1187                         if [ -n "${src_mask}" ]
1188                         then
1189                                 final_src="$(echo ${final_src} | sed "s|^${src_mask}||")"
1190                         fi
1191                         rm -rf "${dest}" 2> /dev/null
1192                         ln -s "${final_src}" "${dest}"
1193                         chown_ref "${src}" "${dest}"
1194                 fi
1195         done
1196 }
1197
1198 do_union ()
1199 {
1200         local unionmountpoint unionrw unionro
1201         unionmountpoint="${1}"  # directory where the union is mounted
1202         shift
1203         unionrw="${1}"          # branch where the union changes are stored
1204         shift
1205         unionro="${*}"          # space separated list of read-only branches (optional)
1206
1207         case "${UNIONTYPE}" in
1208                 aufs)
1209                         rw_opt="rw"
1210                         ro_opt="rr+wh"
1211                         noxino_opt="noxino"
1212                         ;;
1213
1214                 unionfs-fuse)
1215                         rw_opt="RW"
1216                         ro_opt="RO"
1217                         ;;
1218
1219                 *)
1220                         rw_opt="rw"
1221                         ro_opt="ro"
1222                         ;;
1223         esac
1224
1225         case "${UNIONTYPE}" in
1226                 unionfs-fuse)
1227                         unionmountopts="-o cow -o noinitgroups -o default_permissions -o allow_other -o use_ino -o suid"
1228                         unionmountopts="${unionmountopts} ${unionrw}=${rw_opt}"
1229                         if [ -n "${unionro}" ]
1230                         then
1231                                 for rofs in ${unionro}
1232                                 do
1233                                         unionmountopts="${unionmountopts}:${rofs}=${ro_opt}"
1234                                 done
1235                         fi
1236                         ( sysctl -w fs.file-max=391524 ; ulimit -HSn 16384
1237                         unionfs-fuse ${unionmountopts} "${unionmountpoint}" ) && \
1238                         ( mkdir -p /run/sendsigs.omit.d
1239                         pidof unionfs-fuse >> /run/sendsigs.omit.d/unionfs-fuse || true )
1240                         ;;
1241
1242                 overlayfs)
1243                         # XXX: can multiple unionro be used? (overlayfs only handles two dirs, but perhaps they can be chained?)
1244                         # XXX: and can unionro be optional? i.e. can overlayfs skip lowerdir?
1245                         if echo ${unionro} | grep -q " "
1246                         then
1247                                 panic "Multiple lower filesystems are currently not supported with overlayfs (unionro = ${unionro})."
1248                         elif [ -z "${unionro}"  ]
1249                         then
1250                                 panic "Overlayfs needs at least one lower filesystem (read-only branch)."
1251                         fi
1252                         unionmountopts="-o noatime,lowerdir=${unionro},upperdir=${unionrw}"
1253                         mount -t ${UNIONTYPE} ${unionmountopts} ${UNIONTYPE} "${unionmountpoint}"
1254                         ;;
1255
1256                 *)
1257                         unionmountopts="-o noatime,${noxino_opt},dirs=${unionrw}=${rw_opt}"
1258                         if [ -n "${unionro}" ]
1259                         then
1260                                 for rofs in ${unionro}
1261                                 do
1262                                         unionmountopts="${unionmountopts}:${rofs}=${ro_opt}"
1263                                 done
1264                         fi
1265                         mount -t ${UNIONTYPE} ${unionmountopts} ${UNIONTYPE} "${unionmountpoint}"
1266                         ;;
1267         esac
1268 }
1269
1270 get_custom_mounts ()
1271 {
1272         # Side-effect: leaves $devices with persistence.conf mounted in /live/persistence
1273         # Side-effect: prints info to file $custom_mounts
1274
1275         local custom_mounts devices bindings links
1276         custom_mounts=${1}
1277         shift
1278         devices=${@}
1279
1280         bindings="/tmp/bindings.list"
1281         links="/tmp/links.list"
1282         rm -rf ${bindings} ${links} 2> /dev/null
1283
1284         for device in ${devices}
1285         do
1286                 if [ ! -b "${device}" ]
1287                 then
1288                         continue
1289                 fi
1290
1291                 local device_name backing include_list
1292                 device_name="$(basename ${device})"
1293                 backing=$(mount_persistence_media ${device})
1294                 if [ -z "${backing}" ]
1295                 then
1296                         continue
1297                 fi
1298
1299                 if [ -r "${backing}/${persistence_list}" ]
1300                 then
1301                         include_list="${backing}/${persistence_list}"
1302                 elif [ -r "${backing}/${old_persistence_list}" ]
1303                 then
1304                         include_list="${backing}/${old_persistence_list}"
1305                 else
1306                         continue
1307                 fi
1308
1309                 if [ -n "${DEBUG}" ] && [ -e "${include_list}" ]
1310                 then
1311                         cp ${include_list} /live/persistence/${persistence_list}.${device_name}
1312                 fi
1313
1314                 while read dir options # < ${include_list}
1315                 do
1316                         if echo ${dir} | grep -qe "^[[:space:]]*\(#.*\)\?$"
1317                         then
1318                                 # skipping empty or commented lines
1319                                 continue
1320                         fi
1321
1322                         if trim_path ${dir} | grep -q -e "^[^/]" -e "^/lib" -e "^/lib/live\(/.*\)\?$" -e "^/\(.*/\)\?\.\.\?\(/.*\)\?$"
1323                         then
1324                                 log_warning_msg "Skipping unsafe custom mount ${dir}: must be an absolute path containing neither the \".\" nor \"..\" special dirs, and cannot be \"/lib\", or \"/lib/live\" or any of its sub-directories."
1325                                 continue
1326                         fi
1327
1328                         local opt_source opt_link source full_source full_dest
1329                         opt_source=""
1330                         opt_link=""
1331                         for opt in $(echo ${options} | tr ',' ' ');
1332                         do
1333                                 case "${opt}" in
1334                                         source=*)
1335                                                 opt_source=${opt#source=}
1336                                                 ;;
1337                                         link)
1338                                                 opt_link="true"
1339                                                 ;;
1340                                         union|bind)
1341                                                 ;;
1342                                         *)
1343                                                 log_warning_msg "Skipping custom mount with unkown option: ${opt}"
1344                                                 continue 2
1345                                                 ;;
1346                                 esac
1347                         done
1348
1349                         source="${dir}"
1350                         if [ -n "${opt_source}" ]
1351                         then
1352                                 if echo ${opt_source} | grep -q -e "^/" -e "^\(.*/\)\?\.\.\?\(/.*\)\?$" && [ "${opt_source}" != "." ]
1353                                 then
1354                                         log_warning_msg "Skipping unsafe custom mount with option source=${opt_source}: must be either \".\" (the media root) or a relative path w.r.t. the media root that contains neither comas, nor the special \".\" and \"..\" path components"
1355                                         continue
1356                                 else
1357                                         source="${opt_source}"
1358                                 fi
1359                         fi
1360
1361                         full_source="$(trim_path ${backing}/${source})"
1362                         full_dest="$(trim_path ${rootmnt}/${dir})"
1363                         if [ -n "${opt_link}" ]
1364                         then
1365                                 echo "${device} ${full_source} ${full_dest} ${options}" >> ${links}
1366                         else
1367                                 echo "${device} ${full_source} ${full_dest} ${options}" >> ${bindings}
1368                         fi
1369                 done < ${include_list}
1370         done
1371
1372         # We sort the list according to destination so we're sure that
1373         # we won't hide a previous mount. We also ignore duplicate
1374         # destinations in a more or less arbitrary way.
1375         [ -e "${bindings}" ] && sort -k3 -sbu ${bindings} >> ${custom_mounts} && rm ${bindings}
1376
1377         # After all mounts are considered we add symlinks so they
1378         # won't be hidden by some mount.
1379         [ -e "${links}" ] && cat ${links} >> ${custom_mounts} && rm ${links}
1380
1381         # We need to make sure that no two custom mounts have the same sources
1382         # or are nested; if that is the case, too much weird stuff can happen.
1383         local prev_source prev_dest
1384         prev_source="impossible source" # first iteration must not match
1385         prev_dest=""
1386         # This sort will ensure that a source /a comes right before a source
1387         # /a/b so we only need to look at the previous source
1388         sort -k2 -b ${custom_mounts} |
1389         while read device source dest options
1390         do
1391                 if echo ${source} | grep -qe "^${prev_source}\(/.*\)\?$"
1392                 then
1393                         panic "Two persistence mounts have the same or nested sources: ${source} on ${dest}, and ${prev_source} on ${prev_dest}"
1394                 fi
1395                 prev_source=${source}
1396                 prev_dest=${dest}
1397         done
1398 }
1399
1400 activate_custom_mounts ()
1401 {
1402         local custom_mounts used_devices
1403         custom_mounts="${1}" # the ouput from get_custom_mounts()
1404         used_devices=""
1405
1406         while read device source dest options # < ${custom_mounts}
1407         do
1408                 local opt_bind opt_link opt_union
1409                 opt_bind="true"
1410                 opt_link=""
1411                 opt_union=""
1412                 for opt in $(echo ${options} | tr ',' ' ');
1413                 do
1414                         case "${opt}" in
1415                                 bind)
1416                                         opt_bind="true"
1417                                         unset opt_link opt_union
1418                                         ;;
1419                                 link)
1420                                         opt_link="true"
1421                                         unset opt_bind opt_union
1422                                         ;;
1423                                 union)
1424                                         opt_union="true"
1425                                         unset opt_bind opt_link
1426                                         ;;
1427                         esac
1428                 done
1429
1430                 if [ -n "$(what_is_mounted_on "${dest}")" ]
1431                 then
1432                         if [ "${dest}" = "${rootmnt}" ]
1433                         then
1434                                 umount "${dest}"
1435                         else
1436                                 log_warning_msg "Skipping custom mount ${dest}: $(what_is_mounted_on "${dest}") is already mounted there"
1437                                 continue
1438                         fi
1439                 fi
1440
1441                 if [ ! -d "${dest}" ]
1442                 then
1443                         # create the destination and delete existing files in
1444                         # its path that are in the way
1445                         path="/"
1446                         for dir in $(echo ${dest} | sed -e 's|/\+| |g')
1447                         do
1448                                 path=$(trim_path ${path}/${dir})
1449                                 if [ -f ${path} ]
1450                                 then
1451                                         rm -f ${path}
1452                                 fi
1453                                 if [ ! -e ${path} ]
1454                                 then
1455                                         mkdir -p ${path}
1456                                         if echo ${path} | grep -qe "^${rootmnt}/*home/[^/]\+"
1457                                         then
1458                                                 # if ${dest} is in /home try fixing proper ownership by assuming that the intended user is the first, which is usually the case
1459                                                 # FIXME: this should really be handled by live-config since we don't know for sure which uid a certain user has until then
1460                                                 chown 1000:1000 ${path}
1461                                         fi
1462                                 fi
1463                         done
1464                 fi
1465
1466                 # if ${source} doesn't exist on our persistence media
1467                 # we bootstrap it with $dest from the live filesystem.
1468                 # this both makes sense and is critical if we're
1469                 # dealing with /etc or other system dir.
1470                 if [ ! -d "${source}" ]
1471                 then
1472                         if [ -n "${PERSISTENCE_READONLY}" ]
1473                         then
1474                                 continue
1475                         elif [ -n "${opt_union}" ] || [ -n "${opt_link}" ]
1476                         then
1477                                 # unions and don't need to be bootstrapped
1478                                 # link dirs can't be bootstrapped in a sensible way
1479                                 mkdir -p "${source}"
1480                                 chown_ref "${dest}" "${source}"
1481                                 chmod_ref "${dest}" "${source}"
1482                         elif [ -n "${opt_bind}" ]
1483                         then
1484                                 # ensure that $dest is not copied *into* $source
1485                                 mkdir -p "$(dirname ${source})"
1486                                 cp -a "${dest}" "${source}"
1487                         fi
1488                 fi
1489
1490                 # XXX: If CONFIG_AUFS_ROBR is added to the Debian kernel we can
1491                 # ignore the loop below and set rootfs_dest_backing=$dest
1492                 local rootfs_dest_backing
1493                 rootfs_dest_backing=""
1494                 if [ -n "${opt_link}"]
1495                 then
1496                         for d in /live/rootfs/*
1497                         do
1498                                 if [ -n "${rootmnt}" ]
1499                                 then
1500                                         fs="${d}/$(echo ${dest} | sed -e "s|${rootmnt}||")"
1501                                 else
1502                                         fs="${d}/${dest}"
1503                                 fi
1504                                 if [ -d "${fs}" ]
1505                                 then
1506                                         rootfs_dest_backing="${rootfs_dest_backing} ${fs}"
1507                                 fi
1508                         done
1509                 fi
1510
1511                 local cow_dir links_source
1512                 if [ -n "${opt_link}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1513                 then
1514                         link_files ${source} ${dest} ${rootmnt}
1515                 elif [ -n "${opt_link}" ] && [ -n "${PERSISTENCE_READONLY}" ]
1516                 then
1517                         mkdir -p ${rootmnt}/lib/live/mount/persistence
1518                         links_source=$(mktemp -d ${rootmnt}/lib/live/mount/persistence/links-source-XXXXXX)
1519                         chown_ref ${source} ${links_source}
1520                         chmod_ref ${source} ${links_source}
1521                         # We put the cow dir in the below strange place to
1522                         # make it absolutely certain that the link source
1523                         # has its own directory and isn't nested with some
1524                         # other custom mount (if so that mount's files would
1525                         # be linked, causing breakage.
1526                         cow_dir="/live/overlay/lib/live/mount/persistence/$(basename ${links_source})"
1527                         mkdir -p ${cow_dir}
1528                         chown_ref "${source}" "${cow_dir}"
1529                         chmod_ref "${source}" "${cow_dir}"
1530                         do_union ${links_source} ${cow_dir} ${source} ${rootfs_dest_backing}
1531                         link_files ${links_source} ${dest} ${rootmnt}
1532                 elif [ -n "${opt_union}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1533                 then
1534                         do_union ${dest} ${source} ${rootfs_dest_backing}
1535                 elif [ -n "${opt_bind}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1536                 then
1537                         mount --bind "${source}" "${dest}"
1538                 elif [ -n "${opt_bind}" -o -n "${opt_union}" ] && [ -n "${PERSISTENCE_READONLY}" ]
1539                 then
1540                         # bind-mount and union mount are handled the same
1541                         # in read-only mode, but note that rootfs_dest_backing
1542                         # is non-empty (and necessary) only for unions
1543                         cow_dir="/live/overlay/${dest}"
1544                         if [ -e "${cow_dir}" ] && [ -z "${opt_link}" ]
1545                         then
1546                                 # If an earlier custom mount has files here
1547                                 # it will "block" the current mount's files
1548                                 # which is undesirable
1549                                 rm -rf "${cow_dir}"
1550                         fi
1551                         mkdir -p ${cow_dir}
1552                         chown_ref "${source}" "${cow_dir}"
1553                         chmod_ref "${source}" "${cow_dir}"
1554                         do_union ${dest} ${cow_dir} ${source} ${rootfs_dest_backing}
1555                 fi
1556
1557                 PERSISTENCE_IS_ON="1"
1558                 export PERSISTENCE_IS_ON
1559
1560                 if echo ${used_devices} | grep -qve "^\(.* \)\?${device}\( .*\)\?$"
1561                 then
1562                         used_devices="${used_devices} ${device}"
1563                 fi
1564         done < ${custom_mounts}
1565
1566         echo ${used_devices}
1567 }
1568
1569 fix_backwards_compatibility ()
1570 {
1571         local device dir opt backing include_list
1572         device=${1}
1573         dir=${2}
1574         opt=${3}
1575
1576         if [ -n "${PERSISTENCE_READONLY}" ]
1577         then
1578                 return
1579         fi
1580
1581         backing="$(mount_persistence_media ${device})"
1582         if [ -z "${backing}" ]
1583         then
1584                 return
1585         fi
1586
1587         include_list="${backing}/${persistence_list}"
1588         if [ ! -r "${include_list}" ] && [ ! -r "${backing}/${old_persistence_list}" ]
1589         then
1590                 echo "# persistence backwards compatibility:
1591 ${dir} ${opt},source=." > "${include_list}"
1592         fi
1593 }
1594
1595 is_mountpoint ()
1596 {
1597         directory="$1"
1598
1599         [ $(stat -fc%d:%D "${directory}") != $(stat -fc%d:%D "${directory}/..") ]
1600 }