scripts/boot/9990-overlay.sh

   1 #!/bin/sh
   2
   3 #set -e
   4
   5 setup_unionfs ()
   6 {
   7         image_directory="${1}"
   8         rootmnt="${2}"
   9         addimage_directory="${3}"
  10
  11         case ${UNIONTYPE} in
  12                 aufs|unionfs|overlayfs)
  13                         modprobe -q -b ${UNIONTYPE}
  14
  15                         if ! cut -f2 /proc/filesystems | grep -q "^${UNIONTYPE}\$" && [ -x /bin/unionfs-fuse ]
  16                         then
  17                                 echo "${UNIONTYPE} not available, falling back to unionfs-fuse."
  18                                 echo "This might be really slow."
  19
  20                                 UNIONTYPE="unionfs-fuse"
  21                         fi
  22                         ;;
  23         esac
  24
  25         case "${UNIONTYPE}" in
  26                 unionfs-fuse)
  27                         modprobe fuse
  28                         ;;
  29         esac
  30
  31         # run-init can't deal with images in a subdir, but we're going to
  32         # move all of these away before it runs anyway.  No, we're not,
  33         # put them in / since move-mounting them into / breaks mono and
  34         # some other apps.
  35
  36         croot="/"
  37
  38         # Let's just mount the read-only file systems first
  39         rootfslist=""
  40
  41         if [ -z "${PLAIN_ROOT}" ]
  42         then
  43                 # Read image names from ${MODULE}.module if it exists
  44                 if [ -e "${image_directory}/filesystem.${MODULE}.module" ]
  45                 then
  46                         for IMAGE in $(cat ${image_directory}/filesystem.${MODULE}.module)
  47                         do
  48                                 image_string="${image_string} ${image_directory}/${IMAGE}"
  49                         done
  50                 elif [ -e "${image_directory}/${MODULE}.module" ]
  51                 then
  52                         for IMAGE in $(cat ${image_directory}/${MODULE}.module)
  53                         do
  54                                 image_string="${image_string} ${image_directory}/${IMAGE}"
  55                         done
  56                 else
  57                         # ${MODULE}.module does not exist, create a list of images
  58                         for FILESYSTEM in squashfs ext2 ext3 ext4 xfs jffs2 dir
  59                         do
  60                                 for IMAGE in "${image_directory}"/*."${FILESYSTEM}"
  61                                 do
  62                                         if [ -e "${IMAGE}" ]
  63                                         then
  64                                                 image_string="${image_string} ${IMAGE}"
  65                                         fi
  66                                 done
  67                         done
  68
  69                         if [ -n "${addimage_directory}" ] && [ -d "${addimage_directory}" ]
  70                         then
  71                                 for FILESYSTEM in squashfs ext2 ext3 ext4 xfs jffs2 dir
  72                                 do
  73                                         for IMAGE in "${addimage_directory}"/*."${FILESYSTEM}"
  74                                         do
  75                                                 if [ -e "${IMAGE}" ]
  76                                                 then
  77                                                         image_string="${image_string} ${IMAGE}"
  78                                                 fi
  79                                         done
  80                                 done
  81                         fi
  82
  83                         # Now sort the list
  84                         image_string="$(echo ${image_string} | sed -e 's/ /\n/g' | sort )"
  85                 fi
  86
  87                 [ -n "${MODULETORAMFILE}" ] && image_string="${image_directory}/$(basename ${MODULETORAMFILE})"
  88
  89                 mkdir -p "${croot}"
  90
  91                 for image in ${image_string}
  92                 do
  93                         imagename=$(basename "${image}")
  94
  95                         export image devname
  96                         maybe_break live-realpremount
  97                         log_begin_msg "Running /scripts/live-realpremount"
  98                         run_scripts /scripts/live-realpremount
  99                         log_end_msg
 100
 101                         if [ -d "${image}" ]
 102                         then
 103                                 # it is a plain directory: do nothing
 104                                 rootfslist="${image} ${rootfslist}"
 105                         elif [ -f "${image}" ]
 106                         then
 107                                 if losetup --help 2>&1 | grep -q -- "-r\b"
 108                                 then
 109                                         backdev=$(get_backing_device "${image}" "-r")
 110                                 else
 111                                         backdev=$(get_backing_device "${image}")
 112                                 fi
 113                                 fstype=$(get_fstype "${backdev}")
 114
 115                                 case "${fstype}" in
 116                                         unknown)
 117                                                 panic "Unknown file system type on ${backdev} (${image})"
 118                                                 ;;
 119
 120                                         "")
 121                                                 fstype="${imagename##*.}"
 122                                                 log_warning_msg "Unknown file system type on ${backdev} (${image}), assuming ${fstype}."
 123                                                 ;;
 124                                 esac
 125
 126                                 case "${UNIONTYPE}" in
 127                                         unionmount)
 128                                                 mpoint="${rootmnt}"
 129                                                 rootfslist="${rootmnt} ${rootfslist}"
 130                                                 ;;
 131
 132                                         *)
 133                                                 mpoint="${croot}/${imagename}"
 134                                                 rootfslist="${mpoint} ${rootfslist}"
 135                                                 ;;
 136                                 esac
 137
 138                                 mkdir -p "${mpoint}"
 139                                 log_begin_msg "Mounting \"${image}\" on \"${mpoint}\" via \"${backdev}\""
 140                                 mount -t "${fstype}" -o ro,noatime "${backdev}" "${mpoint}" || panic "Can not mount ${backdev} (${image}) on ${mpoint}"
 141                                 log_end_msg
 142                         fi
 143                 done
 144         else
 145                 # we have a plain root system
 146                 mkdir -p "${croot}/filesystem"
 147                 log_begin_msg "Mounting \"${image_directory}\" on \"${croot}/filesystem\""
 148                 mount -t $(get_fstype "${image_directory}") -o ro,noatime "${image_directory}" "${croot}/filesystem" || \
 149                         panic "Can not mount ${image_directory} on ${croot}/filesystem" && \
 150                         rootfslist="${croot}/filesystem ${rootfslist}"
 151                 # probably broken:
 152                 mount -o bind ${croot}/filesystem $mountpoint
 153                 log_end_msg
 154         fi
 155
 156         # tmpfs file systems
 157         touch /etc/fstab
 158         mkdir -p /live/overlay
 159         mount -t tmpfs tmpfs /live/overlay
 160
 161         # Looking for persistence devices or files
 162         if [ -n "${PERSISTENCE}" ] && [ -z "${NOPERSISTENCE}" ]
 163         then
 164
 165                 if [ -z "${QUICKUSBMODULES}" ]
 166                 then
 167                         # Load USB modules
 168                         num_block=$(ls -l /sys/block | wc -l)
 169                         for module in sd_mod uhci-hcd ehci-hcd ohci-hcd usb-storage
 170                         do
 171                                 modprobe -q -b ${module}
 172                         done
 173
 174                         udevadm trigger
 175                         udevadm settle
 176
 177                         # For some reason, udevsettle does not block in this scenario,
 178                         # so we sleep for a little while.
 179                         #
 180                         # See https://bugs.launchpad.net/ubuntu/+source/casper/+bug/84591
 181                         for timeout in 5 4 3 2 1
 182                         do
 183                                 sleep 1
 184
 185                                 if [ $(ls -l /sys/block | wc -l) -gt ${num_block} ]
 186                                 then
 187                                         break
 188                                 fi
 189                         done
 190                 fi
 191
 192                 local whitelistdev=""
 193                 if [ -n "${PERSISTENCE_MEDIA}" ]
 194                 then
 195                         case "${PERSISTENCE_MEDIA}" in
 196                                 removable)
 197                                         whitelistdev="$(removable_dev)"
 198                                         ;;
 199
 200                                 removable-usb)
 201                                         whitelistdev="$(removable_usb_dev)"
 202                                         ;;
 203                         esac
 204                         if [ -z "${whitelistdev}" ]
 205                         then
 206                                 whitelistdev="ignore_all_devices"
 207                         fi
 208                 fi
 209
 210                 if is_in_comma_sep_list overlay ${PERSISTENCE_METHOD}
 211                 then
 212                         overlays="${old_root_overlay_label} ${old_home_overlay_label} ${custom_overlay_label}"
 213                 fi
 214
 215                 local overlay_devices=""
 216                 if [ "${whitelistdev}" != "ignore_all_devices" ]
 217                 then
 218                         for media in $(find_persistence_media "${overlays}" "${whitelistdev}")
 219                         do
 220                                 media="$(echo ${media} | tr ":" " ")"
 221
 222                                 case ${media} in
 223                                         ${old_root_overlay_label}=*)
 224                                                 device="${media#*=}"
 225                                                 fix_backwards_compatibility ${device} / union
 226                                                 overlay_devices="${overlay_devices} ${device}"
 227                                                 ;;
 228
 229                                         ${old_home_overlay_label}=*)
 230                                                 device="${media#*=}"
 231                                                 fix_backwards_compatibility ${device} /home bind
 232                                                 overlay_devices="${overlay_devices} ${device}"
 233                                                 ;;
 234
 235                                         ${custom_overlay_label}=*)
 236                                                 device="${media#*=}"
 237                                                 overlay_devices="${overlay_devices} ${device}"
 238                                                 ;;
 239                                  esac
 240                         done
 241                 fi
 242         elif [ -n "${NFS_COW}" ] && [ -z "${NOPERSISTENCE}" ]
 243         then
 244                 # check if there are any nfs options
 245                 if echo ${NFS_COW} | grep -q ','
 246                 then
 247                         nfs_cow_opts="-o nolock,$(echo ${NFS_COW}|cut -d, -f2-)"
 248                         nfs_cow=$(echo ${NFS_COW}|cut -d, -f1)
 249                 else
 250                         nfs_cow_opts="-o nolock"
 251                         nfs_cow=${NFS_COW}
 252                 fi
 253
 254                 if [ -n "${PERSISTENCE_READONLY}" ]
 255                 then
 256                         nfs_cow_opts="${nfs_cow_opts},nocto,ro"
 257                 fi
 258
 259                 mac="$(get_mac)"
 260                 if [ -n "${mac}" ]
 261                 then
 262                         cowdevice=$(echo ${nfs_cow} | sed "s/client_mac_address/${mac}/")
 263                         cow_fstype="nfs"
 264                 else
 265                         panic "unable to determine mac address"
 266                 fi
 267         fi
 268
 269         if [ -z "${cowdevice}" ]
 270         then
 271                 cowdevice="tmpfs"
 272                 cow_fstype="tmpfs"
 273                 cow_mountopt="rw,noatime,mode=755"
 274         fi
 275
 276         if [ "${UNIONTYPE}" != "unionmount" ]
 277         then
 278                 if [ -n "${PERSISTENCE_READONLY}" ] && [ "${cowdevice}" != "tmpfs" ]
 279                 then
 280                         mount -t tmpfs -o rw,noatime,mode=755 tmpfs "/live/overlay"
 281                         root_backing="/live/persistence/$(basename ${cowdevice})-root"
 282                         mkdir -p ${root_backing}
 283                 else
 284                         root_backing="/live/overlay"
 285                 fi
 286
 287                 if [ "${cow_fstype}" = "nfs" ]
 288                 then
 289                         log_begin_msg \
 290                                 "Trying nfsmount ${nfs_cow_opts} ${cowdevice} ${root_backing}"
 291                         nfsmount ${nfs_cow_opts} ${cowdevice} ${root_backing} || \
 292                                 panic "Can not mount ${cowdevice} (n: ${cow_fstype}) on ${root_backing}"
 293                 else
 294                         mount -t ${cow_fstype} -o ${cow_mountopt} ${cowdevice} ${root_backing} || \
 295                                 panic "Can not mount ${cowdevice} (o: ${cow_fstype}) on ${root_backing}"
 296                 fi
 297         fi
 298
 299         rootfscount=$(echo ${rootfslist} |wc -w)
 300
 301         rootfs=${rootfslist%% }
 302
 303         if [ -n "${EXPOSED_ROOT}" ]
 304         then
 305                 if [ ${rootfscount} -ne 1 ]
 306                 then
 307                         panic "only one RO file system supported with exposedroot: ${rootfslist}"
 308                 fi
 309
 310                 mount --bind ${rootfs} ${rootmnt} || \
 311                         panic "bind mount of ${rootfs} failed"
 312
 313                 if [ -z "${SKIP_UNION_MOUNTS}" ]
 314                 then
 315                         cow_dirs='/var/tmp /var/lock /var/run /var/log /var/spool /home /var/lib/live'
 316                 else
 317                         cow_dirs=''
 318                 fi
 319         else
 320                 cow_dirs="/"
 321         fi
 322
 323         if [ "${cow_fstype}" != "tmpfs" ] && [ "${cow_dirs}" != "/" ] && [ "${UNIONTYPE}" = "unionmount" ]
 324         then
 325                 true # FIXME: Maybe it does, I don't really know.
 326                 #panic "unionmount does not support subunions (${cow_dirs})."
 327         fi
 328
 329         for dir in ${cow_dirs}; do
 330                 unionmountpoint="${rootmnt}${dir}"
 331                 mkdir -p ${unionmountpoint}
 332                 if [ "${UNIONTYPE}" = "unionmount" ]
 333                 then
 334                         # FIXME: handle PERSISTENCE_READONLY
 335                         unionmountopts="-t ${cow_fstype} -o noatime,union,${cow_mountopt} ${cowdevice}"
 336                         mount_full $unionmountopts "${unionmountpoint}"
 337                 else
 338                         cow_dir="/live/overlay${dir}"
 339                         rootfs_dir="${rootfs}${dir}"
 340                         mkdir -p ${cow_dir}
 341                         if [ -n "${PERSISTENCE_READONLY}" ] && [ "${cowdevice}" != "tmpfs" ]
 342                         then
 343                                 do_union ${unionmountpoint} ${cow_dir} ${root_backing} ${rootfs_dir}
 344                         else
 345                                 do_union ${unionmountpoint} ${cow_dir} ${rootfs_dir}
 346                         fi
 347                 fi || panic "mount ${UNIONTYPE} on ${unionmountpoint} failed with option ${unionmountopts}"
 348         done
 349
 350         # Correct the permissions of /:
 351         chmod 0755 "${rootmnt}"
 352
 353         # Correct the permission of /tmp:
 354         if [ -d "${rootmnt}/tmp" ]
 355         then
 356                 chmod 1777 "${rootmnt}"/tmp
 357         fi
 358
 359         live_rootfs_list=""
 360         for d in ${rootfslist}
 361         do
 362                 live_rootfs="/live/rootfs/${d##*/}"
 363                 live_rootfs_list="${live_rootfs_list} ${live_rootfs}"
 364                 mkdir -p "${live_rootfs}"
 365                 case d in
 366                         *.dir)
 367                                 # do nothing # mount -o bind "${d}" "${live_rootfs}"
 368                                 ;;
 369                         *)
 370                                 case "${UNIONTYPE}" in
 371                                         unionfs-fuse)
 372                                                 mount -o bind "${d}" "${live_rootfs}"
 373                                                 ;;
 374
 375                                         *)
 376                                                 mount -o move "${d}" "${live_rootfs}"
 377                                                 ;;
 378                                 esac
 379                                 ;;
 380                 esac
 381         done
 382
 383         # move all /live mountpoints that the custom persistence
 384         # system depends on into /lib/live on the root filesystem
 385         for _DIRECTORY in rootfs
 386         do
 387                 if [ -d "/live/${_DIRECTORY}" ]
 388                 then
 389                         mkdir -p "${rootmnt}/lib/live/mount/${_DIRECTORY}"
 390
 391                         for _MOUNT in $(ls /live/${_DIRECTORY})
 392                         do
 393                                 mkdir -p "${rootmnt}/lib/live/mount/${_DIRECTORY}/${_MOUNT}"
 394                                 mount -o move "/live/${_DIRECTORY}/${_MOUNT}" "${rootmnt}/lib/live/mount/${_DIRECTORY}/${_MOUNT}" > /dev/null 2>&1 || \
 395                                         mount -o bind "/live/${_DIRECTORY}/${_MOUNT}" "${rootmnt}/lib/live/mount/${_DIRECTORY}/${_MOUNT}" || \
 396                                         log_warning_msg "W: failed to mount /live/${_DIRECTORY}/${_MOUNT} to ${rootmnt}/lib/live/mount/${_DIRECTORY}/${_MOUNT}"
 397                         done
 398                 fi
 399         done
 400
 401         mkdir -p "${rootmnt}/lib/live/mount/overlay"
 402         mount -o move /live/overlay "${rootmnt}/lib/live/mount/overlay" > /dev/null 2>&1 || \
 403                 mount -o bind /live/overlay "${rootmnt}/lib/live/mount/overlay" || \
 404                 log_warning_msg "W: failed to mount /live/overlay to ${rootmnt}/lib/live/mount/overlay"
 405
 406         # Adding custom persistence
 407         if [ -n "${PERSISTENCE}" ] && [ -z "${NOPERSISTENCE}" ]
 408         then
 409                 local custom_mounts="/tmp/custom_mounts.list"
 410                 rm -rf ${custom_mounts} 2> /dev/null
 411
 412                 # Gather information about custom mounts from devies detected as overlays
 413                 get_custom_mounts ${custom_mounts} ${overlay_devices}
 414
 415                 [ -n "${DEBUG}" ] && cp ${custom_mounts} "/lib/live/mount/persistence"
 416
 417                 # Now we do the actual mounting (and symlinking)
 418                 local used_overlays=""
 419                 used_overlays=$(activate_custom_mounts ${custom_mounts})
 420                 rm ${custom_mounts}
 421
 422                 # Close unused overlays (e.g. due to missing $persistence_list)
 423                 for overlay in ${overlay_devices}
 424                 do
 425                         if echo ${used_overlays} | grep -qve "^\(.* \)\?${device}\( .*\)\?$"
 426                         then
 427                                 close_persistence_media ${overlay}
 428                         fi
 429                 done
 430         fi
 431
 432         # ensure that a potentially stray tmpfs gets removed
 433         # otherways, initramfs-tools is unable to remove /live
 434         # and fails to boot
 435         umount /live/overlay || true
 436 }