9 if [ -d "${DIRECTORY}"/"${LIVE_MEDIA_PATH}" ]
11 for FILESYSTEM
in squashfs ext2 ext3 ext4 xfs dir jffs2
13 if [ "$(echo ${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM})" != "${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM}" ]
25 if [ "${IGNORE_UUID}" ] ||
[ ! -e /conf
/uuid.conf
]
31 uuid
="$(cat /conf/uuid.conf)"
33 for try_uuid_file
in "${path}/.disk/live-uuid"*
35 [ -e "${try_uuid_file}" ] ||
continue
37 try_uuid
="$(cat "${try_uuid_file}")"
39 if [ "${uuid}" = "${try_uuid}" ]
51 *.squashfs|
*.ext2|
*.ext3|
*.ext4|
*.jffs2
)
52 echo $
(setup_loop
"${1}" "loop" "/sys/block/loop*" '0' "${LIVE_MEDIA_ENCRYPTION}" "${2}")
60 panic
"Unrecognized live filesystem: ${1}"
67 # Does any files match pattern ${1} ?
70 if [ "$(echo ${pattern})" != "${pattern}" ]
78 mount_images_in_directory
()
84 if match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.squashfs" ||
85 match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.ext2" ||
86 match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.ext3" ||
87 match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.ext4" ||
88 match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.jffs2" ||
89 match_files_in_dir
"${directory}/${LIVE_MEDIA_PATH}/*.dir"
91 [ -n "${mac}" ] && adddirectory="${directory}/${LIVE_MEDIA_PATH}/${mac}"
92 setup_unionfs
"${directory}/${LIVE_MEDIA_PATH}" "${rootmnt}" "${adddirectory}"
94 panic
"No supported filesystem images found at /${LIVE_MEDIA_PATH}."
100 sysfs_path
="${1#/sys}"
102 if [ -e /lib
/udev
/path_id
]
105 PATH_ID
="/lib/udev/path_id"
107 # wheezy/sid (udev >= 174)
108 PATH_ID
="/sbin/udevadm test-builtin path_id"
111 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)"
114 elif echo "${sysfs_path}" |
grep -q '^/block/vd[a-z]$'
117 elif echo ${sysfs_path} |
grep -q "^/block/dm-"
120 elif echo ${sysfs_path} |
grep -q "^/block/mtdblock"
132 skip_uuid_check
="${3}"
134 # support for fromiso=.../isofrom=....
137 ISO_DEVICE
=$
(dirname $FROMISO)
138 if ! [ -b $ISO_DEVICE ]
140 # to support unusual device names like /dev/cciss/c0d0p1
141 # as well we have to identify the block device name, let's
142 # do that for up to 15 levels
144 while [ -n "$ISO_DEVICE" ] && [ "$i" -gt 0 ]
146 ISO_DEVICE
=$
(dirname ${ISO_DEVICE})
147 [ -b "$ISO_DEVICE" ] && break
152 if [ "$ISO_DEVICE" = "/" ]
154 echo "Warning: device for bootoption fromiso= ($FROMISO) not found.">>/boot.log
156 fs_type
=$
(get_fstype
"${ISO_DEVICE}")
157 if is_supported_fs
${fs_type}
160 mount
-t $fs_type "$ISO_DEVICE" /live
/fromiso
161 ISO_NAME
="$(echo $FROMISO | sed "s|
$ISO_DEVICE||
")"
162 loopdevname
=$
(setup_loop
"/live/fromiso/${ISO_NAME}" "loop" "/sys/block/loop*" "" '')
163 devname
="${loopdevname}"
165 echo "Warning: unable to mount $ISO_DEVICE." >>/boot.log
170 if [ -z "${devname}" ]
172 devname
=$
(sys2dev
"${sysdev}")
175 if [ -d "${devname}" ]
177 mount
-o bind "${devname}" $mountpoint ||
continue
179 if is_live_path
$mountpoint
189 for device
in ${devname}
194 if [ -x /scripts
/local-top
/lvm2
]
196 ROOT
="$device" resume
="" /scripts
/local-top
/lvm2
201 # Adding raid support
202 if [ -x /scripts
/local-top
/mdadm
]
204 cp /conf
/conf.d
/md
/conf
/conf.d
/md.orig
205 echo "MD_DEVS=$device " >> /conf
/conf.d
/md
206 /scripts
/local-top
/mdadm
207 mv /conf
/conf.d
/md.orig
/conf
/conf.d
/md
214 [ -n "$device" ] && devname
="$device"
216 [ -e "$devname" ] ||
continue
218 if [ -n "${LIVE_MEDIA_OFFSET}" ]
220 loopdevname
=$
(setup_loop
"${devname}" "loop" "/sys/block/loop*" "${LIVE_MEDIA_OFFSET}" '')
221 devname
="${loopdevname}"
224 fstype
=$
(get_fstype
"${devname}")
226 if is_supported_fs
${fstype}
228 devuid
=$
(blkid
-o value
-s UUID
"$devname")
229 [ -n "$devuid" ] && grep -qs "\<$devuid\>" $tried && continue
230 mount
-t ${fstype} -o ro,noatime "${devname}" ${mountpoint} ||
continue
231 [ -n "$devuid" ] && echo "$devuid" >> $tried
233 if [ -n "${FINDISO}" ]
235 if [ -f ${mountpoint}/${FINDISO} ]
238 mkdir
-p /live
/findiso
239 mount
-t ${fstype} -o ro
,noatime
"${devname}" /live
/findiso
240 loopdevname
=$
(setup_loop
"/live/findiso/${FINDISO}" "loop" "/sys/block/loop*" 0 "")
241 devname
="${loopdevname}"
242 mount
-t iso9660
-o ro
,noatime
"${devname}" ${mountpoint}
248 if is_live_path
${mountpoint} && \
249 ([ "${skip_uuid_check}" ] || matches_uuid
${mountpoint})
254 umount
${mountpoint} 2>/dev
/null
258 if [ -n "${LIVE_MEDIA_OFFSET}" ]
260 losetup
-d "${loopdevname}"
270 # don't start autodetection before timeout has expired
271 if [ -n "${LIVE_MEDIA_TIMEOUT}" ]
273 if [ "${timeout}" -lt "${LIVE_MEDIA_TIMEOUT}" ]
279 # first look at the one specified in the command line
280 case "${LIVE_MEDIA}" in
282 for sysblock
in $
(removable_usb_dev
"sys")
284 for dev
in $
(subdevices
"${sysblock}")
286 if check_dev
"${dev}"
296 for sysblock
in $
(removable_dev
"sys")
298 for dev
in $
(subdevices
"${sysblock}")
300 if check_dev
"${dev}"
310 if [ ! -z "${LIVE_MEDIA}" ]
312 if check_dev
"null" "${LIVE_MEDIA}" "skip_uuid_check"
320 # or do the scan of block devices
321 # prefer removable devices over non-removable devices, so scan them first
322 devices_to_scan
="$(removable_dev 'sys') $(non_removable_dev 'sys')"
324 for sysblock
in $devices_to_scan
326 devname
=$
(sys2dev
"${sysblock}")
327 [ -e "$devname" ] ||
continue
328 fstype
=$
(get_fstype
"${devname}")
330 if /lib
/udev
/cdrom_id
${devname} > /dev
/null
332 if check_dev
"null" "${devname}"
336 elif is_nice_device
"${sysblock}"
338 for dev
in $
(subdevices
"${sysblock}")
340 if check_dev
"${dev}"
345 elif [ "${fstype}" = "squashfs" -o \
346 "${fstype}" = "btrfs" -o \
347 "${fstype}" = "ext2" -o \
348 "${fstype}" = "ext3" -o \
349 "${fstype}" = "ext4" -o \
350 "${fstype}" = "jffs2" ]
352 # This is an ugly hack situation, the block device has
353 # an image directly on it. It's hopefully
354 # live-boot, so take it and run with it.
355 ln -s "${devname}" "${devname}.${fstype}"
356 echo "${devname}.${fstype}"
367 VALUE
="$(eval echo -n \${$STRING})"
369 if [ -f /live.vars
] && grep -sq "export ${STRING}" /live.vars
371 sed -i -e 's/\('${STRING}'=\).*$/\1'${VALUE}'/' /live.vars
373 echo "export ${STRING}=\"${VALUE}\"" >> /live.vars
376 eval export "${STRING}"="${VALUE}"
379 is_in_list_separator_helper
()
386 echo ${list} | grep -qe "^\(.*${sep}\)\?${element}\(${sep}.
*\
)\?$
"
389 is_in_space_sep_list ()
393 is_in_list_separator_helper "[[:space
:]]" "${element}" "${*}"
396 is_in_comma_sep_list ()
400 is_in_list_separator_helper "," "${element}" "${*}"
406 echo "/dev
/$
($udevinfo -q name
-p ${sysdev} 2>/dev
/null||
echo ${sysdev##*/})"
414 for dev in "${sysblock}"/* "${sysblock}"
416 if [ -e "${dev}/dev
" ]
427 black_listed_devices="${1}"
428 white_listed_devices="${2}"
430 for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "loop|ram|fd
")
432 fulldevname=$(sys2dev "${sysblock}")
434 if is_in_space_sep_list ${fulldevname} ${black_listed_devices} || \
435 [ -n "${white_listed_devices}" ] && \
436 ! is_in_space_sep_list ${fulldevname} ${white_listed_devices}
438 # skip this device entirely
442 for dev in $(subdevices "${sysblock}")
444 devname=$(sys2dev "${dev}")
446 if is_in_space_sep_list ${devname} ${black_listed_devices}
448 # skip this subdevice
461 # Validate input first
462 if [ -z "${fstype}" ]
467 # Try to look if it is already supported by the kernel
468 if grep -q ${fstype} /proc/filesystems
472 # Then try to add support for it the gentle way using the initramfs capabilities
474 if grep -q ${fstype} /proc/filesystems
477 # Then try the hard way if /root is already reachable
479 kmodule="/root
/lib
/modules
/`uname -r`/${fstype}/${fstype}.ko
"
480 if [ -e "${kmodule}" ]
483 if grep -q ${fstype} /proc/filesystems
496 /sbin/blkid -s TYPE -o value $1 2>/dev/null
503 grep -m1 "^
${device} " /proc/mounts | cut -f2 -d ' '
508 # remove all unnecessary /:s in the path, including last one (except
509 # if path is just "/")
510 echo ${1} | sed 's|//\+|/|g' | sed 's|^\(.*[^/]\)/$|\1|'
513 what_is_mounted_on ()
515 local dir="$
(trim_path
${1})"
516 grep -m1 "^
[^
]\
+ ${dir} " /proc/mounts | cut -d' ' -f1
521 local reference="${1}"
524 local owner=$(stat -c %u:%g "${reference}")
525 chown -h ${owner} ${targets}
530 local reference="${1}"
533 local rights=$(stat -c %a "${reference}")
534 chmod ${rights} ${targets}
550 mounts="$
(awk '{print $2}' /proc
/mounts
)"
551 testpath="$
(busybox realpath
${testpath})"
555 if echo "${mounts}" | grep -qs "^
${testpath}"
557 set -- $(echo "${mounts}" | grep "^
${testpath}" | lastline)
561 testpath=$(dirname $testpath)
568 # Returns used/free fs kbytes + 5% more
569 # You could pass a block device as ${1} or the mount point as ${2}
575 if [ -z "${mountp}" ]
577 mountp="$
(where_is_mounted
${dev})"
579 if [ -z "${mountp}" ]
581 mountp="/mnt
/tmp_fs_size
"
584 mount -t $(get_fstype "${dev}") -o ro "${dev}" "${mountp}" || log_warning_msg "cannot mount -t $(get_fstype ${dev}) -o ro ${dev} ${mountp}"
590 if [ "${used}" = "used
" ]
592 size=$(du -ks ${mountp} | cut -f1)
593 size=$(expr ${size} + ${size} / 20 ) # FIXME: 5% more to be sure
596 size="$
(df
-k |
grep -s ${mountp} |
awk '{print $4}')"
599 if [ -n "${doumount}" ]
601 umount "${mountp}" || log_warning_msg "cannot umount
${mountp}"
611 if [ -x /bin/loadkeys -a -r /etc/boottime.kmap.gz ]
613 loadkeys /etc/boottime.kmap.gz
623 local encryption=${5}
626 # the output of setup_loop is evaluated in other functions,
627 # modprobe leaks kernel options like "libata.dma
=0"
628 # as "options libata dma
=0" on stdout, causing serious
629 # problems therefor, so instead always avoid output to stdout
630 modprobe -q -b "${module}" 1>/dev/null
634 for loopdev in ${pattern}
636 if [ "$
(cat ${loopdev}/size
)" -eq 0 ]
638 dev=$(sys2dev "${loopdev}")
641 if [ -n "${readonly}" ]
643 if losetup --help 2>&1 | grep -q -- "-r\b"
645 options="${options} -r"
649 if [ -n "${offset}" ] && [ 0 -lt "${offset}" ]
651 options="${options} -o ${offset}"
654 if [ -z "${encryption}" ]
656 losetup ${options} "${dev}" "${fspath}"
658 # Loop AES encryption
663 echo -n "Enter passphrase for root filesystem: " >&6
665 echo "${passphrase}" > /tmp
/passphrase
667 exec 9</tmp
/passphrase
668 /sbin
/losetup
${options} -e "${encryption}" -p 9 "${dev}" "${fspath}"
671 rm -f /tmp/passphrase
673 if [ 0 -eq ${error} ]
680 echo -n "There was an error decrypting the root filesystem ... Retry?
[Y
/n
] " >&6
683 if [ "$
(echo "${answer}" | cut
-b1 |
tr A-Z a-z
)" = "n
" ]
696 panic "No loop devices available
"
706 old_mountp="$
(where_is_mounted
${dev})"
708 if [ -n "${old_mountp}" ]
710 if [ "${opts}" != "ro
" ]
712 mount -o remount,"${opts}" "${dev}" "${old_mountp}" || panic "Remounting ${dev} ${opts} on ${old_mountp} failed
"
715 mount -o bind "${old_mountp}" "${mountp}" || panic "Cannot bind-mount ${old_mountp} on ${mountp}"
717 if [ -z "${fstype}" ]
719 fstype=$(get_fstype "${dev}")
721 mount -t "${fstype}" -o "${opts}" "${dev}" "${mountp}" || \
722 ( echo "SKIPPING
: Cannot mount
${dev} on ${mountp}, fstype=${fstype}, options=${opts}" > boot.log && return 0 )
726 mount_persistence_media ()
731 local backing="/live
/persistence
/$
(basename ${device})"
733 mkdir -p "${backing}"
734 local old_backing="$
(where_is_mounted
${device})"
735 if [ -z "${old_backing}" ]
737 local fstype="$
(get_fstype
${device})"
738 local mount_opts="rw
,noatime
"
739 if [ -n "${PERSISTENCE_READONLY}" ]
741 mount_opts="ro
,noatime
"
743 if mount -t "${fstype}" -o "${mount_opts}" "${device}" "${backing}" >/dev/null
748 [ -z "${probe}" ] && log_warning_msg "Failed to mount persistence media
${device}"
752 elif [ "${backing}" != "${old_backing}" ]
754 if mount --move ${old_backing} ${backing} >/dev/null
759 [ -z "${probe}" ] && log_warning_msg "Failed to move persistence media
${device}"
767 close_persistence_media ()
770 local backing="$
(where_is_mounted
${device})"
772 if [ -d "${backing}" ]
774 umount "${backing}" >/dev/null 2>&1
775 rmdir "${backing}" >/dev/null 2>&1
778 if is_active_luks_mapping ${device}
780 /sbin/cryptsetup luksClose ${device}
787 name="$
(basename ${dev})"
789 if [ -n "${PERSISTENCE_READONLY}" ]
791 opts="${opts} --readonly"
794 if /sbin/cryptsetup status "${name}" >/dev/null 2>&1
796 re="^
[[:space
:]]*device
:[[:space
:]]*\
([^
[:space
:]]*\
)$
"
797 opened_dev=$(cryptsetup status ${name} 2>/dev/null | grep "${re}" | sed "s|${re}|\1|")
798 if [ "${opened_dev}" = "${dev}" ]
800 luks_device
="/dev/mapper/${name}"
804 log_warning_msg
"Cannot open luks device ${dev} since ${opened_dev} already is opened with its name"
813 /lib
/cryptsetup
/askpass
"Enter passphrase for ${dev}: " | \
814 /sbin
/cryptsetup
-T 1 luksOpen
${dev} ${name} ${opts}
818 luks_device
="/dev/mapper/${name}"
824 echo -n "There was an error decrypting ${dev} ... Retry? [Y/n] " >&6
827 if [ "$(echo "${answer}" | cut -b1 | tr A-Z a-z)" = "n" ]
837 /sbin
/blkid
-s PART_ENTRY_NAME
-p -o value
${dev} 2>/dev
/null
843 [ "$(/sbin/blkid -s PART_ENTRY_SCHEME -p -o value ${dev} 2>/dev/null)" = "gpt" ]
846 probe_for_gpt_name
()
848 local overlays
="${1}"
851 local gpt_dev
="${dev}"
852 if is_active_luks_mapping
${dev}
854 # if $dev is an opened luks device, we need to check
855 # GPT stuff on the backing device
856 gpt_dev
=$
(get_luks_backing_device
"${dev}")
859 if ! is_gpt_device
${gpt_dev}
864 local gpt_name
=$
(get_gpt_name
${gpt_dev})
865 for label
in ${overlays}
867 if [ "${gpt_name}" = "${label}" ]
869 echo "${label}=${dev}"
874 probe_for_fs_label
()
876 local overlays
="${1}"
879 for label
in ${overlays}
881 if [ "$(/sbin/blkid -s LABEL -o value $dev 2>/dev/null)" = "${label}" ]
883 echo "${label}=${dev}"
888 probe_for_file_name
()
890 local overlays
="${1}"
894 local backing
="$(mount_persistence_media ${dev} probe)"
895 if [ -z "${backing}" ]
900 for label
in ${overlays}
902 path
=${backing}/${PERSISTENCE_PATH}${label}
905 local loopdev
=$
(setup_loop
"${path}" "loop" "/sys/block/loop*")
906 ret
="${ret} ${label}=${loopdev}"
914 umount
${backing} > /dev
/null
2>&1 || true
918 find_persistence_media
()
920 # Scans devices for overlays, and returns a whitespace
921 # separated list of how to use them. Only overlays with a partition
922 # label or file name in ${overlays} are returned.
924 # When scanning a LUKS device, the user will be asked to enter the
925 # passphrase; on failure to enter it, or if no persistence partitions
926 # or files were found, the LUKS device is closed.
928 # For all other cases (overlay partition and overlay file) the
929 # return value is "${label}=${device}", where ${device} a device that
930 # can mount the content. In the case of an overlay file, the device
931 # containing the file will remain mounted as a side-effect.
933 # No devices in ${black_listed_devices} will be scanned, and if
934 # ${white_list_devices} is non-empty, only devices in it will be
937 local overlays
="${1}"
938 local white_listed_devices
="${2}"
941 local black_listed_devices
="$(what_is_mounted_on /live/image)"
943 for dev
in $
(storage_devices
"${black_listed_devices}" "${white_listed_devices}")
948 # Check if it's a luks device; we'll have to open the device
949 # in order to probe any filesystem it contains, like we do
950 # below. activate_custom_mounts() also depends on that any luks
951 # device already has been opened.
952 if is_in_comma_sep_list luks
${PERSISTENCE_ENCRYPTION} && is_luks_partition
${dev}
954 if luks_device
=$
(open_luks_device
"${dev}")
958 # skip $dev since we failed/chose not to open it
961 elif ! is_in_comma_sep_list none
${PERSISTENCE_ENCRYPTION}
963 # skip $dev since we don't allow unencrypted storage
967 # Probe for matching GPT partition names or filesystem labels
968 if is_in_comma_sep_list filesystem
${PERSISTENCE_STORAGE}
970 result
=$
(probe_for_gpt_name
"${overlays}" ${dev})
971 if [ -n "${result}" ]
973 ret
="${ret} ${result}"
977 result
=$
(probe_for_fs_label
"${overlays}" ${dev})
978 if [ -n "${result}" ]
980 ret
="${ret} ${result}"
985 # Probe for files with matching name on mounted partition
986 if is_in_comma_sep_list
file ${PERSISTENCE_STORAGE}
988 result
=$
(probe_for_file_name
"${overlays}" ${dev})
989 if [ -n "${result}" ]
991 ret
="${ret} ${result}"
996 # Close luks device if it isn't used
997 if [ -z "${result}" ] && [ -n "${luks_device}" ] && is_active_luks_mapping "${luks_device}"
999 /sbin
/cryptsetup luksClose
"${luks_device}"
1013 for adaptor
in /sys
/class
/net
/*
1015 status
="$(cat ${adaptor}/iflink)"
1017 if [ "${status}" -eq 2 ]
1019 mac
="$(cat ${adaptor}/address)"
1020 mac
="$(echo ${mac} | sed 's/:/-/g' | tr '[a-z]' '[A-Z]')"
1027 is_luks_partition
()
1030 /sbin
/cryptsetup isLuks
"${device}" 1>/dev
/null
2>&1
1033 is_active_luks_mapping
()
1036 /sbin
/cryptsetup status
"${device}" 1>/dev
/null
2>&1
1039 get_luks_backing_device
()
1042 cryptsetup status
${device} 2> /dev
/null | \
1043 awk '{if ($1 == "device:") print $2}'
1048 output_format
="${1}"
1052 for sysblock
in $
(echo /sys
/block
/* |
tr ' ' '\n' |
grep -vE "/(loop|ram|dm-|fd)")
1055 if [ "$(cat ${sysblock}/removable)" = "1" ]
1057 if [ -z "${want_usb}" ]
1061 if readlink
${sysblock} |
grep -q usb
1068 if [ "${dev_ok}" = "true" ]
1070 case "${output_format}" in
1072 ret
="${ret} ${sysblock}"
1075 devname
=$
(sys2dev
"${sysblock}")
1076 ret
="${ret} ${devname}"
1085 removable_usb_dev
()
1087 output_format
="${1}"
1089 removable_dev
"${output_format}" "want_usb"
1092 non_removable_dev
()
1094 output_format
="${1}"
1097 for sysblock
in $
(echo /sys
/block
/* |
tr ' ' '\n' |
grep -vE "/(loop|ram|dm-|fd)")
1099 if [ "$(cat ${sysblock}/removable)" = "0" ]
1101 case "${output_format}" in
1103 ret
="${ret} ${sysblock}"
1106 devname
=$
(sys2dev
"${sysblock}")
1107 ret
="${ret} ${devname}"
1118 # create source's directory structure in dest, and recursively
1119 # create symlinks in dest to to all files in source. if mask
1120 # is non-empty, remove mask from all source paths when
1121 # creating links (will be necessary if we change root, which
1122 # live-boot normally does (into $rootmnt)).
1124 # remove multiple /:s and ensure ending on /
1125 local src_dir
="$(trim_path ${1})/"
1126 local dest_dir
="$(trim_path ${2})/"
1127 local src_mask
="${3}"
1129 # This check can only trigger on the inital, non-recursive call since
1130 # we create the destination before recursive calls
1131 if [ ! -d "${dest_dir}" ]
1133 log_warning_msg
"Must link_files into a directory"
1137 find "${src_dir}" -mindepth 1 -maxdepth 1 | \
1140 local dest
="${dest_dir}$(basename "${src}")"
1143 if [ -z "$(ls -A "${src}")" ]
1147 if [ ! -d "${dest}" ]
1150 chown_ref
"${src}" "${dest}"
1151 chmod_ref
"${src}" "${dest}"
1153 link_files
"${src}" "${dest}" "${src_mask}"
1155 local final_src
=${src}
1156 if [ -n "${src_mask}" ]
1158 final_src
="$(echo ${final_src} | sed "s|^
${src_mask}||
")"
1160 rm -rf "${dest}" 2> /dev
/null
1161 ln -s "${final_src}" "${dest}"
1162 chown_ref
"${src}" "${dest}"
1169 local unionmountpoint
="${1}" # directory where the union is mounted
1170 local unionrw
="${2}" # branch where the union changes are stored
1171 local unionro1
="${3}" # first underlying read-only branch (optional)
1172 local unionro2
="${4}" # second underlying read-only branch (optional)
1174 case "${UNIONTYPE}" in
1192 case "${UNIONTYPE}" in
1194 unionmountopts
="-o cow -o noinitgroups -o default_permissions -o allow_other -o use_ino -o suid"
1195 unionmountopts
="${unionmountopts} ${unionrw}=${rw_opt}"
1196 if [ -n "${unionro1}" ]
1198 unionmountopts
="${unionmountopts}:${unionro1}=${ro_opt}"
1200 if [ -n "${unionro2}" ]
1202 unionmountopts
="${unionmountopts}:${unionro2}=${ro_opt}"
1204 ( sysctl
-w fs.file-max
=391524 ; ulimit -HSn 16384
1205 unionfs-fuse
${unionmountopts} "${unionmountpoint}" ) && \
1206 ( mkdir
-p /run
/sendsigs.omit.d
1207 pidof unionfs-fuse
>> /run
/sendsigs.omit.d
/unionfs-fuse || true
)
1211 # XXX: can unionro2 be used? (overlayfs only handles two dirs, but perhaps they can be chained?)
1212 # XXX: and can unionro1 be optional? i.e. can overlayfs skip lowerdir?
1213 unionmountopts
="-o noatime,lowerdir=${unionro1},upperdir=${unionrw}"
1214 mount
-t ${UNIONTYPE} ${unionmountopts} ${UNIONTYPE} "${unionmountpoint}"
1218 unionmountopts="-o noatime
,${noxino_opt},dirs=${unionrw}=${rw_opt}"
1219 if [ -n "${unionro1}" ]
1221 unionmountopts="${unionmountopts}:${unionro1}=${ro_opt}"
1223 if [ -n "${unionro2}" ]
1225 unionmountopts="${unionmountopts}:${unionro2}=${ro_opt}"
1227 mount -t ${UNIONTYPE} ${unionmountopts} ${UNIONTYPE} "${unionmountpoint}"
1232 get_custom_mounts
()
1234 # Side-effect: leaves $devices with live-persistence.conf mounted in /live/persistence
1235 # Side-effect: prints info to file $custom_mounts
1237 local custom_mounts
=${1}
1241 local bindings
="/tmp/bindings.list"
1242 local links
="/tmp/links.list"
1243 rm -rf ${bindings} ${links} 2> /dev
/null
1245 for device
in ${devices}
1247 if [ ! -b "${device}" ]
1252 local device_name
="$(basename ${device})"
1253 local backing
=$
(mount_persistence_media
${device})
1254 if [ -z "${backing}" ]
1259 local include_list
="${backing}/${persistence_list}"
1260 if [ ! -r "${include_list}" ]
1265 if [ -n "${DEBUG}" ] && [ -e "${include_list}" ]
1267 cp ${include_list} /live/persistence/${persistence_list}.${device_name}
1270 while read dir options
# < ${include_list}
1272 if echo ${dir} |
grep -qe "^[[:space:]]*\(#.*\)\?$"
1274 # skipping empty or commented lines
1278 if trim_path
${dir} |
grep -q -e "^[^/]" -e "^/live\(/.*\)\?$" -e "^/\(.*/\)\?\.\.\?\(/.*\)\?$"
1280 log_warning_msg
"Skipping unsafe custom mount ${dir}: must be an absolute path containing neither the \".\" nor \"..\" special dirs, and cannot be \"/live\" or any sub-directory therein."
1286 for opt
in $
(echo ${options} |
tr ',' ' ');
1290 opt_source
=${opt#source=}
1298 log_warning_msg
"Skipping custom mount with unkown option: ${opt}"
1304 local source="${dir}"
1305 if [ -n "${opt_source}" ]
1307 if echo ${opt_source} |
grep -q -e "^/" -e "^\(.*/\)\?\.\.\?\(/.*\)\?$" && [ "${source}" != "." ]
1309 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"
1312 source="${opt_source}"
1316 local full_source
="$(trim_path ${backing}/${source})"
1317 local full_dest
="$(trim_path ${rootmnt}/${dir})"
1318 if [ -n "${opt_link}" ]
1320 echo "${device} ${full_source} ${full_dest} ${options}" >> ${links}
1322 echo "${device} ${full_source} ${full_dest} ${options}" >> ${bindings}
1324 done < ${include_list}
1327 # We sort the list according to destination so we're sure that
1328 # we won't hide a previous mount. We also ignore duplicate
1329 # destinations in a more or less arbitrary way.
1330 [ -e "${bindings}" ] && sort -k3 -sbu ${bindings} >> ${custom_mounts} && rm ${bindings}
1332 # After all mounts are considered we add symlinks so they
1333 # won't be hidden by some mount.
1334 [ -e "${links}" ] && cat ${links} >> ${custom_mounts} && rm ${links}
1336 # We need to make sure that no two custom mounts have the same sources
1337 # or are nested; if that is the case, too much weird stuff can happen.
1338 local prev_source
="impossible source" # first iteration must not match
1340 # This sort will ensure that a source /a comes right before a source
1341 # /a/b so we only need to look at the previous source
1342 sort -k2 -b ${custom_mounts} |
1343 while read device
source dest options
1345 if echo ${source} |
grep -qe "^${prev_source}\(/.*\)\?$"
1347 panic
"Two persistence mounts have the same or nested sources: ${source} on ${dest}, and ${prev_source} on ${prev_dest}"
1349 prev_source
=${source}
1354 activate_custom_mounts
()
1356 local custom_mounts
="${1}" # the ouput from get_custom_mounts()
1357 local used_devices
=""
1359 while read device
source dest options
# < ${custom_mounts}
1361 local opt_bind
="true"
1364 for opt
in $
(echo ${options} |
tr ',' ' ');
1369 unset opt_link opt_union
1373 unset opt_bind opt_union
1377 unset opt_bind opt_link
1382 if [ -n "$(what_is_mounted_on "${dest}")" ]
1384 if [ "${dest}" = "${rootmnt}" ]
1388 log_warning_msg
"Skipping custom mount ${dest}: $(what_is_mounted_on "${dest}") is already mounted there"
1393 if [ ! -d "${dest}" ]
1395 # create the destination and delete existing files in
1396 # its path that are in the way
1398 for dir
in $
(echo ${dest} |
sed -e 's|/\+| |g')
1400 path
=$
(trim_path
${path}/${dir})
1408 if echo ${path} |
grep -qe "^${rootmnt}/*home/[^/]\+"
1410 # if ${dest} is in /home try fixing proper ownership by assuming that the intended user is the first, which is usually the case
1411 # FIXME: this should really be handled by live-config since we don't know for sure which uid a certain user has until then
1412 chown
1000:1000 ${path}
1418 # if ${source} doesn't exist on our persistence media
1419 # we bootstrap it with $dest from the live filesystem.
1420 # this both makes sense and is critical if we're
1421 # dealing with /etc or other system dir.
1422 if [ ! -d "${source}" ]
1424 if [ -n "${PERSISTENCE_READONLY}" ]
1427 elif [ -n "${opt_union}" ] ||
[ -n "${opt_link}" ]
1429 # unions and don't need to be bootstrapped
1430 # link dirs can't be bootstrapped in a sensible way
1431 mkdir
-p "${source}"
1432 chown_ref
"${dest}" "${source}"
1433 chmod_ref
"${dest}" "${source}"
1434 elif [ -n "${opt_bind}" ]
1436 # ensure that $dest is not copied *into* $source
1437 mkdir
-p "$(dirname ${source})"
1438 cp -a "${dest}" "${source}"
1442 # XXX: If CONFIG_AUFS_ROBR is added to the Debian kernel we can
1443 # ignore the loop below and set rofs_dest_backing=$dest
1444 local rofs_dest_backing
=""
1445 if [ -n "${opt_link}"]
1447 for d
in /live
/rofs
/*
1449 if [ -n "${rootmnt}" ]
1451 rofs_dest_backing
="${d}/$(echo ${dest} | sed -e "s|${rootmnt}||")"
1453 rofs_dest_backing="${d}/${dest}"
1455 if [ -d "${rofs_dest_backing}" ]
1459 rofs_dest_backing=""
1464 if [ -n "${opt_link}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1466 link_files ${source} ${dest} ${rootmnt}
1467 elif [ -n "${opt_link}" ] && [ -n "${PERSISTENCE_READONLY}" ]
1469 mkdir -p /live/persistence
1470 local links_source=$(mktemp -d /live/persistence/links-source-XXXXXX)
1471 chown_ref ${source} ${links_source}
1472 chmod_ref ${source} ${links_source}
1473 # We put the cow dir in the below strange place to
1474 # make it absolutely certain that the link source
1475 # has its own directory and isn't nested with some
1476 # other custom mount (if so that mount's files would
1477 # be linked, causing breakage.
1478 local cow_dir="/live
/overlay
/live
/persistence
/$
(basename ${links_source})"
1480 chown_ref "${source}" "${cow_dir}"
1481 chmod_ref "${source}" "${cow_dir}"
1482 do_union ${links_source} ${cow_dir} ${source} ${rofs_dest_backing}
1483 link_files ${links_source} ${dest} ${rootmnt}
1484 elif [ -n "${opt_union}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1486 do_union ${dest} ${source} ${rofs_dest_backing}
1487 elif [ -n "${opt_bind}" ] && [ -z "${PERSISTENCE_READONLY}" ]
1489 mount --bind "${source}" "${dest}"
1490 elif [ -n "${opt_bind}" -o -n "${opt_union}" ] && [ -n "${PERSISTENCE_READONLY}" ]
1492 # bind-mount and union mount are handled the same
1493 # in read-only mode, but note that rofs_dest_backing
1494 # is non-empty (and necessary) only for unions
1495 if [ -n "${rootmnt}" ]
1497 local cow_dir="$
(echo ${dest} |
sed -e "s|^${rootmnt}|/live/overlay/|")"
1499 # This is happens if persistence is activated
1501 local cow_dir="/live
/overlay
/${dest}"
1503 if [ -e "${cow_dir}" ] && [ -z "${opt_link}" ]
1505 # If an earlier custom mount has files here
1506 # it will "block
" the current mount's files
1507 # which is undesirable
1511 chown_ref "${source}" "${cow_dir}"
1512 chmod_ref "${source}" "${cow_dir}"
1513 do_union ${dest} ${cow_dir} ${source} ${rofs_dest_backing}
1516 PERSISTENCE_IS_ON="1"
1517 export PERSISTENCE_IS_ON
1519 if echo ${used_devices} | grep -qve "^\
(.
* \
)\?${device}\
( .
*\
)\?$
"
1521 used_devices="${used_devices} ${device}"
1523 done < ${custom_mounts}
1525 echo ${used_devices}
1528 fix_backwards_compatibility ()
1534 if [ -n "${PERSISTENCE_READONLY}" ]
1539 local backing="$
(mount_persistence_media
${device})"
1540 if [ -z "${backing}" ]
1545 local include_list="${backing}/${persistence_list}"
1546 if [ ! -r "${include_list}" ]
1548 echo "# persistence backwards compatibility:
1549 ${dir} ${opt},source=." > "${include_list}"
1557 [ $(stat -fc%d:%D "${directory}") != $(stat -fc%d:%D "${directory}/..
") ]