#!/bin/sh
ROOTAUFS2(){
ver=221125 #sfs
msg2() { ###sfs
    [ "${quiet}" != "y" ] && echo $@
    echo "$@" >>/log-rootaufs2
    if [ "${debug}" = "y" ] || [ "${step}" = "y" ] ;then
	[ "${quiet}" = "y" ] && echo $@
        echo -e "[1;33m"":: Debugging shell started. Ctrl+D: continue booting. Ctrl+Alt+Del: reboot""[0m" 
#        launch_interactive_shell
        sh 2>/dev/null #; echo -e "\n\n"
    fi
}
#export -f msg2
#=====================================================================
# TOOLS
#=====================================================================
# args: source, mountpoint
_mnt_aufs_init() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Creating aufs mount ${src} in ${mnt}"
    mkdir -p "${mnt}"
    #/bin/mount -t aufs -o br:"${src}" rootaufs "${mnt}"
    /bin/mount -t aufs -o nowarn_perm,br:"${src}" rootaufs "${mnt}"
		if [ $? != 0 ]; then
	            err 'rootaufs2: mount -t aufs -o nowarn_perm,br:"${src}" rootaufs "${mnt}"'
	            launch_interactive_shell
	        fi
}

# args: source, mountpoint
_mnt_aufs_add() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Adding new aufs branch ${src} in ${mnt}"
    #/bin/mount -t aufs -o remount,append:"${src}" none "${mnt}"
    /bin/mount -t aufs -o remount,append:"${src}"=rr+wh none "${mnt}"
}

# args: source, mountpoint
_mnt_dev() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Mounting device ${src} to ${mnt}"
    mkdir -p "${mnt}"
    /bin/mount "${src}" "${mnt}"
}

# args: source, mountpoint
_mnt_bind() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Binding ${src} to ${mnt}"
    mkdir -p "${mnt}"
    /bin/mount --bind "${src}" "${mnt}"
}

# args: source, mountpoint
_mnt_move() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Moving ${src} to ${mnt}"
    mkdir -p "${mnt}"
    /bin/mount --move "${src}" "${mnt}"
}

# args: file, mountpoint
_mnt_loop() {
    src="${1}"
    mnt="${2}"
    msg2 "::: Mounting file ${src} to ${mnt}"
    mkdir -p "${mnt}"
    /bin/mount -o loop "${src}" "${mnt}"
}

# args: size, mountpoint
_mnt_tmpfs() {
    size="${1}"
    mnt="${2}"
    msg2 "::: Mounting tmpfs, size=${size} to ${mnt}"
    mkdir -p "${mnt}"
    /bin/mount -t tmpfs -o "size=${size}" tmpfs "${mnt}"
}

# args: mountpoint
_mnt_rerw() {
    mnt="${1}"
    msg2 "::: Re-mounting rw ${mnt}"
    /bin/mount -o "remount,rw" "${mnt}"
}
}
#=====================================================================
# HOOK
#=====================================================================
run_hook () {
    [ "x${diro}" = "x" ] || return
    [ "x${changeso}" = "x" ] || return
    [ "x${aufs}" = "x" ] || return
    [ "x${ofs}" = "x" ] || return
ROOTAUFS2

    rootaufs="${changes}" ###sfs
    tmpfs_size="${ramsize}"
    step2="$step"
    [ "${dir}" ] && roothide=y && msg2 ":: dir= detected. Autoaddition 'roothide'"
    [ "${dir}" ] && [ ! "${rootaufs}" ] && rootaufs=y && msg2 ":: dir= detected. 'changes' not defined. Autoaddition 'changes' (mounts a tmpfs RW filesystem)"
    #check if wanted
    [ "x${rootaufs}" = "x" ] && return
    #defaults
    [ "${rootaufs}" == "y" ] && export rootaufs=tmpfs
    [ "x${tmpfs_size}" = "x" ] && tmpfs_size="60%"
    #        tmpfs_size="75%"
    
    #load modules
   if [ ! -d /sys/fs/aufs ] ;then ###sfs 
    /sbin/modprobe aufs 2>/dev/null
    if [ $? != 0 ]; then
        err "Could NOT load aufs module, bailing out"
        launch_interactive_shell
        return
    fi
   fi
    ls /usr/lib/modules/*/modules.dep.bin  2>/dev/null 1>&2 && /sbin/modprobe loop 2>/dev/null #kernel-pf 
    ls /usr/lib/modules/*/modules.dep.bin  2>/dev/null 1>&2 && /sbin/modprobe squashfs 2>/dev/null

    # set mount handler for rootaufs
    mount_handler="rootaufs_mount_handler"
    export mount_handler
}

#=====================================================================
# MOUNT HANDLER
#=====================================================================
rootaufs_mount_handler() {
msg2 "$ver"
    if [ "${break}" = "pre" ]; then
        msg2 ":: '${break}' Break requested, type 'exit' to resume operation"
        launch_interactive_shell
    fi
    newroot="${1}"

    #-----------------------------------
    #aufs tree
###sfs    aufs_base="/aufs/"
#    aufs_base="/mnt/"
    aufs_base="/run/archroot/"
#    aufs_root="${aufs_base}root"
#    aufs_root="${aufs_base}home"
    aufs_root="${aufs_base}root_ro"
    aufs_home="${aufs_base}home"
#    aufs_rw="${aufs_base}rw"
    aufs_rw="${aufs_base}live/memory/changes"
    aufs_ro="${aufs_base}live/memory/images"
    aufs_cr="${aufs_base}live/memory/copy2ram"
    aufs_rwtype=""
    #overlay: "${aufs_base}${img##*/}"    
    
    #=======================================================
    # Mount filesystems
    #=======================================================
    #TODO
    # replace "_mnt_loop" with versatile mount handler:
    # * enable passing options: fstype, rw, loop, copy2ram...
    # * check file systems
    # * use default_mount_handler ?

    #-----------------------------------
    #mount default root to "ro"
    msg2 ":: Mounting root $root..."

if [ ! "${root}" ];then #start autodetect
# Функции поиска:
param() { grep -E -qo " $1( |\$)" /proc/cmdline; }

fstab() { 
msg2 "::: fstab $@"
FND=none
rm -f /tmp/devices
param nocd || for x in /dev/sr*; do blkid $x >>/tmp/devices; done
param nohd || blkid | grep -E -v '/dev/sr|/dev/loop|/dev/mapper' >>/tmp/devices
dev=`grep -E -v 'TYPE="sw|TYPE="LVM|TYPE="linux_raid' /tmp/devices 2>/dev/null | cut -d: -f1 | cut -d/ -f3 | sort | uniq`
for x in $dev; do
    mnt=
    fs=`grep -w /dev/$x /tmp/devices | grep -E -o ' TYPE=[^ ]+' | cut -d'"' -f2`
    msg2 ":::: mount $x $fs"
    #if [ ! -d /mnt/$x ]; then
	#mkdir -p /mnt/$x
	mkdir -p ${aufs_root}
	if [ $fs = ntfs ]; then
	    #ntfs-3g /dev/$x /mnt/$x -o $MOPT 2>/dev/null || rmdir /mnt/$x
	    #ntfs-3g /dev/$x /mnt/$x && mnt=y || rmdir /mnt/$x
	    modprobe ntfs3 && sleep 0.5
	    if [ -d /sys/module/ntfs3 ];then
		mount -t ntfs3  /dev/$x ${aufs_root} && mnt=y || rmdir /mnt/$x
	    else ntfs-3g 	/dev/$x ${aufs_root} && mnt=y || rmdir /mnt/$x
	    fi
	else
	    #mount /dev/$x /mnt/$x 2>/dev/null && mnt=y || { modprobe $fs 2>/dev/null && mount -n /mnt/$x 2>/dev/null && mnt=y || rmdir /mnt/$x ; }
	    mount /dev/$x ${aufs_root} 2>/dev/null && mnt=y || { modprobe $fs 2>/dev/null && mount -n /mnt/$x 2>/dev/null && mnt=y || rmdir /mnt/$x ; }
	fi
	msg2 "::::: Mounted: `mount |grep -E '^/dev'`"
    #fi
    #if [ $1 /mnt/$x/$2 ];then
    if [ $1 ${aufs_root}$2 ];then
	DEV=$x; FND=y; break
    else  
	[ "$mnt" ] && umount /dev/$x && rmdir ${aufs_root} && msg2 ":::: umount XXX /dev/$x"
    fi
[ "$FND" = y ]
done
}

lazy() { 
msg2 "::: lazy $@"
[ "${rootdelay}" ] && SLEEP="${rootdelay}" || SLEEP=6
while [ $SLEEP -gt 0 -a $FND = none ]; do 
    #fstab; search $* && break
    fstab $* && break
    nap; let SLEEP=SLEEP-1
done 
}

located(){ msg2 "::: located $@" ; LPTH=$2; FND=none ;lazy $* ; }
nap() { msg2 "::: Media is not ready. Wait $SLEEP sec."; sleep 1; }

    msg2 "::: root= not specified. Autosearch $dir" 
    [ "$dir" ]     && located -d "${dir}" 
    [ "$rootdir" ] && located -d "${rootdir}" 
#    msg2 "::: root= not specified. Autosearch $dir" && lazy -d "${dir}" || lazy -d "${rootdir}" 
#    if [ "$DEV" ] ;then
    if [ "$FND" = y ] ;then
	#root="/dev/$DEV" ; ln -sf "/mnt/$DEV" /mnt/home ; msg2 ":::: root=/dev/$DEV"
	root="/dev/$DEV" ; msg2 ":::: root=/dev/$DEV"
    #else err " root= not defined" && launch_interactive_shell 
    fi
fi
######### end autodetect
[ ! "$root" ] && err " root= not defined" && launch_interactive_shell 
    mkdir -p "${aufs_root}"

mnt_ntfs(){
    [ "${rootdelay}" ] && sleep ${rootdelay} && msg2 "::Wait rootdelay=${rootdelay}..."
    #[ "$FND" != y ] && msg2 "::: default_mount_handler ${aufs_root}" && default_mount_handler "${aufs_root}" 
    fsn=`blkid |grep -w ${root} | grep -E -o ' TYPE=[^ ]+' | cut -d'"' -f2`
    msg2 "::: $root fs is $fsn"
    if [ "$fsn" = ntfs ] ;then
#	[ "$FND" != y ] && ntfs-3g $root ${1} && msg2 "::: Mount $root as ntfs"
	if [ "$FND" != y ] ;then
	    modprobe ntfs3 && sleep 0.5
	    if [ -d /sys/module/ntfs3 ] ;then
		mount -t ntfs3  	$root ${1} && msg2 "::: Mount $root as ntfs3"
	    else ntfs-3g 		$root ${1} && msg2 "::: Mount $root as ntfs"
	    fi
	fi
    else 
	[ "$FND" != y ] && default_mount_handler "${1}"  && msg2 "::: default_mount_handler ${1}"
    fi
}

if [ "$rootdir" ]; then
#    mkdir -p "${aufs_root}1" 
    mkdir -p "${aufs_home}" 
#    default_mount_handler "${aufs_home}"
    mnt_ntfs ${aufs_home}
    mount --bind "${aufs_home}/$rootdir" "${aufs_root}"
    #umount "${aufs_root}1" && msg2 "::: umount ${aufs_root}1" 
else
    ln -s "${aufs_root}" "${aufs_home}"
    mnt_ntfs ${aufs_root}
fi

#    [ -L "${aufs_home}/$rootdir/${aufs_root}" ] && rm "${aufs_home}/$rootdir/${aufs_root}" && msg2 "::: rm simlink ${aufs_home}/$rootdir/${aufs_root}" 
#    [ -d "${aufs_home}/$rootdir/${aufs_root}" ] && umount "${aufs_home}/$rootdir/${aufs_root}" 
    #-----------------------------------
    #mount "rw":
    msg2 ":: Mounting rw ${rootaufs}..."
    if [ "${rootaufs}" == "tmpfs" ]; then
        #tmpfs
        aufs_rwtype="tmpfs"
        _mnt_tmpfs "${tmpfs_size}" "${aufs_rw}"

    elif [ -b $rootaufs ]; then
        #block device
        aufs_rwtype="block"
        #FIXME: add options...
        _mnt_dev "${rootaufs}" "${aufs_rw}"
    
    else
        #sub mount inside root

        #remount root rw
        _mnt_rerw "${aufs_root}"

        #source real path
    	    src="${aufs_root}/${rootaufs#/}"
	    mkdir -p ${src}

        #mount based on $src type
        if [ -f $src ]; then
            #file: loop
            aufs_rwtype="loop"
            _mnt_loop "${src}" "${aufs_rw}"

        elif [ -d $src ]; then
#	if [ ! -f ${src} ] ;then ###sfs
	    [ ! -d ${src} ] && msg2 "::: changes=dir not fount. Create $src"
    	    src="${aufs_root}/${rootaufs#/}/changes"
	    mkdir -p ${src}
#	fi
            #dir: use this as rw
            aufs_rwtype="dir" #; ln -sf $src "${aufs_base}live/memory/changes"
            aufs_rw="${src}"
            
            #FIXME: bind doesn't seem to work with aufs2: overlapped
            #aufs_rwtype="bind"
            #_mnt_bind "${src}" "${aufs_rw}"

        else
            #error
            msg2 "ERROR: rootaufs '${src}' not found, fallback to tmpfs"
            aufs_rwtype="tmpfs"
            _mnt_tmpfs "${tmpfs_size}" "${aufs_rw}"
            launch_interactive_shell
        fi
    fi
    msg2 ":: aufs_rwtype ${rootaufs} : $aufs_rwtype ..."

    #-----------------------------------
    #mount overlays
    overlay_mnt=""
###sfs dir 
  LOAD=`echo   "${load}" | sed 's/;/|/g'`; [ $LOAD ] || LOAD=._null
NOLOAD=`echo "${noload}" | sed 's/;/|/g'`; [ $NOLOAD ] || NOLOAD=._null
RAMMOD=`echo "${rammod}" | sed 's/;/|/g'`
PTH="${aufs_root}/${dir}"
#find $PTH/base $PTH/modules -name "*.pfs" 2>/dev/null | grep -E -v "$NOLOAD" | sort >/tmp/modules
#find $PTH/optional -name "*.pfs" 2>/dev/null | grep -E "$LOAD" | sort >>/tmp/modules

#ls -1 "$PTH"/base/*.*[xpsh][fz][sm] "$PTH"/modules/*.*[xpsh][fz][sm] 2>/dev/null | grep -E -v "$NOLOAD" >/tmp/modules
#find "$PTH"/base/ "$PTH"/modules/ -name "*.[xpsh][fz][sm]" 2>/dev/null | grep -E -v "$NOLOAD" >/tmp/modules
[ "${xzm}" ] || xzm=pfs #xzm=[ps][fb]s?
find "$PTH"/base/ "$PTH"/modules/ -type f -regex .*'\.'$xzm'' 2>/dev/null | grep -E -v "$NOLOAD" >/tmp/modules
#ls -1 "$PTH"/optional/*.*[xpsh][fz][sm] 2>/dev/null | grep -E "$LOAD"  >>/tmp/modules
find "$PTH"/optional/ -type f -regex .*'\.'$xzm'' 2>/dev/null | grep -E "$LOAD"  >>/tmp/modules
    if [ "$extramod" ]; then
	EXTRAMOD1=`echo "$extramod" | sed 's/;/ /g'`
	for folder in $EXTRAMOD1; do
	    msg2 ":: search extramod : ${aufs_root}/${folder} ..."
#	    locate -d $folder && { find /mnt/$DEV/$LPTH -name "*.$xzm" 2>/dev/null | egrep -v "$NOLOAD" | sort >>/tmp/modules; } || fail $folder
#	    locate -d $folder && { find /mnt/$DEV/$LPTH -name "*.$xzm" 2>/dev/null | egrep -ve "$NOLOAD" | sort >>/tmp/modules; } || fail $folder
	    #ls -1 "${aufs_root}/${extramod}"/*.*[xpsh][fz][sm] 2>/dev/null | grep -E -v "$NOLOAD"  >>/tmp/modules
	    if [ -d "${aufs_root}/$folder" ] ;then
		find "${aufs_root}/${folder}"/ -type f -regex .*'\.'$xzm'' 2>/dev/null | grep -E -v "$NOLOAD"  >>/tmp/modules
	    else
		err " not found extramod dir : ${aufs_root}/${folder} ... skip"
	    fi
	done
    fi

###sfs( Перенос номерных модулей в верхний слой aufs с сортировкой
#SORT=2-9 
#SORT=`value sort'`
if [ "$SORT" ];then
    sort2="/0[$SORT][0-9]-|"
    if [ "`echo "$SORT" |grep -v "^[0-9-]\+$"`" ];then
	echo -e "[31m""!!Ошибка!!\nВ параметре sort= можно указывать только цифры.\n
Например : sort=456789 или sort=4-9
Модули, начинающиеся с 0xy- , будут загружены верхний слой
AUFS по алфавиту (т.е. перекроют остальные модули)
   x - указанное Вами маска в sort=; y - любая цифра
Модули 089(исправления) и 09x(сохранения) всегда в верхнем слое.

Например :
/mnt/sda1/pra3/base/000-kernel.pfs
/mnt/sda1/pra3/base/001-Pra03arch12nos.pfs
/mnt/sda1/pra3/base/040-jwm-pra3c.pfs
/mnt/sda1/pra3/base/070-Pra-151119.pfs
/mnt/sda1/pra3/base/089-pra-up.pfs
/mnt/sda1/pra3/base/090-save-150921net-pra.pfs
/mnt/sda1/pra3/modules/042-cow-notify-s04.pfs
/mnt/sda1/pra3/optional/075-Systemd-217-8-s03.pfs

с sort=4-9 :
/mnt/sda1/pra3/base/000-kernel.pfs
/mnt/sda1/pra3/base/001-Pra03arch12nos.pfs
/mnt/sda1/pra3/base/040-jwm-pra3c.pfs
/mnt/sda1/pra3/modules/042-cow-notify-s04.pfs
/mnt/sda1/pra3/base/070-Pra-151119.pfs
/mnt/sda1/pra3/optional/075-Systemd-217-8-s03.pfs
/mnt/sda1/pra3/base/089-pra-up.pfs
/mnt/sda1/pra3/base/090-save-150921net-pra.pfs

Нажмите Ctrl+Alt+Del для перезагрузки.""[0m" >> /dev/null
	#exit
	err " rootaufs2 sort=: Could NOT use letter. Exanple sort=456789 or sort=4-9"
        launch_interactive_shell
    fi
fi
grep -Ev ''$sort2'/089-|/09[0-9]-' /tmp/modules >/tmp/modules1
grep -E  ''$sort2'/089-|/09[0-9]-' /tmp/modules | while read i; do
    i1=${i##*/}
    i2=${i%/*}
    echo "$i1$i2"
done | sort -n | while read i; do
    i1=${i#*/}
    i2=${i%%/*}
    echo "/$i1/$i2"
done >/tmp/modules2
#089 и 09х в верхний слой aufs
cat /tmp/modules1 /tmp/modules2 >/tmp/modules

#km="$(basename `grep "/000-kernel-`uname -r`$unm" /tmp/modules`)" 
km="$(grep "/000-kernel-`uname -r`$unm" /tmp/modules)"
km="`basename "$km"`"
    if [ "$km" ] ; then
	[ "`uname -m`" = "x86_64" ] && unm=_64
	sed -i "/000-kernel-`uname -r`$unm/p; /000-kernel-/d;" /tmp/modules &&
	        msg2 ":: ${km} found : skip other 000-kernel-*.$xzm ..."
    fi

[ "${base_only}" = "y" ] && grep /base/0 /tmp/modules > /tmp/mod && mv /tmp/mod /tmp/modules
###sfs)
step=
    if [ "x${dir}" != "x" ]; then
        msg2 ":: dir= Mounting overlays from ${dir}..."
#        for img in `ls -1 "${aufs_root}"/${dir}/[bm][ao]*/*.pfs |sort -r`; do
#        for img in `ls -1 "${aufs_root}"/"${dir}"/modules/*.pfs |sort -r` `ls -1 "${aufs_root}"/${dir}/base/*.pfs |sort -r`; do
        for img in `tac /tmp/modules`; do
###sfs            mnt="${aufs_base}${img##*/}"
            mnt="${aufs_ro}/${img##*/}"
            overlay_mnt="${overlay_mnt} ${mnt}"
##            src="${aufs_root}/${img#/}"
            src="${img#/}"
            
            #FIXME: copy2ram
#            if [ "${copy2ram}" = "y" ] && [ "${aufs_rwtype}" == "tmpfs" ]; then
            if [ "${copy2ram}" = "y" ] && [ "${aufs_rwtype}" == "tmpfs" ] && [ "`echo "${img}" |grep -E "$RAMMOD"`"  ] ; then
                #aufs_rw2="`dirname ${aufs_rw}`/copy2ram"
                aufs_rw2="${aufs_cr}"
                mkdir -p "${aufs_rw2}"
                src_rw="${aufs_rw2}/${img##*/}"
                msg2 -n "::: Copying image file to ${src_rw}..."
                /bin/cp "${src}" "${src_rw}"
                msg2 "done."
                src="$src_rw"
            fi
            
            _mnt_loop ${src} ${mnt}
        done
    fi

    if [ "x${overlay}" != "x" ]; then
        msg2 ":: Mounting overlays..."
###sfs        for img in ${overlay/,/ }; do
        for img in `echo ${overlay} |sed 's/,/ /g'`; do
###sfs            mnt="${aufs_base}${img##*/}"
            mnt="${aufs_ro}/${img##*/}"
            overlay_mnt="${overlay_mnt} ${mnt}"
            src="${aufs_root}/${img#/}"
            
            #FIXME: copy2ram
            if [ "${copy2ram}" = "y" ] && [ "${aufs_rwtype}" == "tmpfs" ]; then
                src_rw="${aufs_rw}/${img##*/}"
                msg2 -n "::: Copying image file to ${src_rw}..."
                /bin/cp "${src}" "${src_rw}"
                msg2 "done."
                src="$src_rw"
            fi
            
            _mnt_loop ${src} ${mnt}
        done
    fi
    
    
    #=======================================================
    # Build aufs new root
    #=======================================================
    msg2 ":: Mounting aufs..."

    #-----------------------------------
    #aufs merge: rw + overlays + ro
    if [ "${break}" = "aufs" ]; then
        msg2 ":: '${break}' Break requested, type 'exit' to resume operation"
        launch_interactive_shell
    fi

    _mnt_aufs_init ${aufs_rw} "${newroot}"
    msg2 ":: _mnt_aufs_init ${aufs_rw} ${newroot}"
    for mnt in ${overlay_mnt}; do
        _mnt_aufs_add ${mnt} "${newroot}"
    done

    if [ "x${roothide}" = "x" ]; then
        _mnt_aufs_add ${aufs_root} "${newroot}"
	msg2 ":: _mnt_aufs_add ${aufs_root} ${newroot}"
sdx(){
###subdir2 sfs(
	#[ "x${rootaufs}" != "x" ] && 
	#[ ! "$DEV" ] && [ "${root}" ] &&
	[ ! "${root}" ] && err " root= not defined" && launch_interactive_shell
	[ "$FND" != y ] && [ "${root}" ] &&
	    root2="${newroot}${aufs_base}`basename ${root}`" &&
	    mkdir -p "${root2}" && 
    	    default_mount_handler "${root2}" &&
            msg2 "::: Mount ${root} in ${root2} (default_mount_handler)"
###subdir2 sfs)
}
#sdx
    fi
XX(){
    #-----------------------------------
    #move aufs mount points into the live system
    _mnt_move "${aufs_root}" "${newroot}${aufs_root}"
    if [ "${aufs_rwtype}" != "dir" ]; then
        #if rw is a dir in root: no link
        _mnt_move "${aufs_rw}" "${newroot}${aufs_rw}"
    fi
    for mnt in ${overlay_mnt}; do
        _mnt_move "${mnt}" "${newroot}${mnt}"
    done

}    
    #=======================================================
    # Fix new root
    #=======================================================
step="$step2"
    msg2 ":: Setting aufs root..."
	msg2 "::::: Mounted: `mount |grep -E '^/dev'`"
    #-----------------------------------
#[ "${noswap}" = "y" ] && FSTAB
[ "${aufs_rwtype}" = "dir" ] && ln -sf "${aufs_root}/$dir/changes" "${newroot}/${aufs_base}live/memory/changes"
cp ${newroot}/etc/fstab ${newroot}/etc/fstab.old
if [ "${noswap}" = "y" ] ;then
    sed '/^[^\s]\+\s*swap\s/s/^/#/' -i ${newroot}/etc/fstab #add#
else
    sed '/^[^\s]\+\s*swap\s/s/^#\+//'  -i ${newroot}/etc/fstab #rempve#
    grep " swap " ${newroot}/etc/fstab || for x in `blkid |grep 'TYPE="swap"'  | cut -d: -f1`; do echo "$x none swap sw,pri=1 0 0" >>${newroot}/etc/fstab; done
fi

if [ ! "${dir}${overlay}" ] ;then 
    sed '/^[^\s]\+\s*\/\s/s/^/#/' -i ${newroot}/etc/fstab #frugal
else
    sed '/^[^\s]\+\s*\/\s/s/^#\+//'  -i ${newroot}/etc/fstab #full
fi
    #-----------------------------------
    #avoid root fs remount/check in rc.sysinit...    
    if [ ! -e /run/initramfs/root-fsck ]; then
        msg2 "WARNING: missing 'fsck' hook, root fs will NOT be checked"
        msg2 "WARNING: please add fsck to HOOKS in mkinitcpio.conf"
        echo 0 > /run/initramfs/root-fsck
    fi
    #arch FCK
    cp /run/initramfs/root-fsck /run/initramfs/fsck-root

    #-----------------------------------
    #fix etc/rc.sysinit: checkable root is now "/aufs/rw", not "/"
    #no root check if tmpfs
    if [ "${aufs_rwtype}" != "tmpfs" -a  "${aufs_rwtype}" != "dir" ]; then
        rm /run/initramfs/*fsck*
        sed -e 's/\(mount -o remount\(,ro\)* \/\)$/\1aufs\/rw/' \
            -i ${newroot}/etc/rc.sysinit
    fi

    #-----------------------------------
    #build remountrw
    file="${newroot}/bin/remountrw"
    echo \#!/bin/sh >$file
    echo mount -o remount,rw ${aufs_root} >>$file
    chmod 0700 $file

    #build remountro
    file="${newroot}/bin/remountro"
    echo \#!/bin/sh >$file
    echo mount -o remount,ro ${aufs_root} >>$file
    chmod 0700 $file

###sfs(
# Копирование папки /rootcopy:
if [ "${norootcopy}" = "y" -a "${dir}" ]; then
    ROOTCOPY=none
    #echo $i"пропуск директории /rootcopy"
    msg2 ":: Skip /rootcopy ..."
else
    if [ -d "${PTH}/rootcopy" ]; then
#	locate -d $ROOTCOPY
#	if [ $? -eq 0 ]; then echo $i"копирование содержимого директории $ROOTCOPY"; cp -af /mnt/$DEV/$LPTH/. /union/. 2>/dev/null; else fail $ROOTCOPY; ROOTCOPY=none; fi
#    else
	ROOTCOPY=none
	#echo $i"копирование содержимого директории $PTH/rootcopy"
        msg2 ":: Copy ${newroot}${PTH}/rootcopy to ${aufs_rw}/ ..."
	#cp -af $PTH/rootcopy/. /union/. 2>/dev/null
	#cp -af "${newroot}${PTH}"/rootcopy/. "${newroot}". 2>/dev/null
##	cp -af "${newroot}${PTH}"/rootcopy/. "${newroot}${aufs_rw}/". 2>/dev/null
	cp -af "${PTH}"/rootcopy/. "${newroot}/". 2>/log-rootaufs2 #/dev/null
		if [ $? != 0 ]; then
	            err 'rootaufs2: cp -af "${PTH}"/rootcopy/. "${newroot}/". '
	            launch_interactive_shell
	        fi
        #launch_interactive_shell
    fi
fi
#	cp -af "${newroot}/${PTH}"/rootcopy/. "${newroot}". ; sleep 7 #2>/dev/null

	msg2 "::::: Mounted: `mount |grep -E '^/dev'`"
    msg2 ":: rootaufs2 end"

    mkdir -p "${newroot}/var/log" && mv /log-rootaufs2 "${newroot}/var/log/initrd.log" && 
	echo -e "\n===Top layer AUFS:===" >> "${newroot}/var/log/initrd.log" &&
	tac /tmp/modules >> "${newroot}/var/log/initrd.log" &&
	echo -e "===Lower layer AUFS===" >> "${newroot}/var/log/initrd.log" &&

#porteus initrd support
LNK(){
	    rmdir "${2}" 2>/dev/null
	    [ -L "${2}" ] && rm "${2}"
	    mkdir -p "`dirname "$2"`"
	    [ -d "$1" ] && ln -sf "${1}" "${2}"
}
LNK "${aufs_home}" "${newroot}/mnt/home"
LNK "${aufs_rw}" "${newroot}/mnt/live/memory/changes"
LNK "${aufs_ro}" "${newroot}/mnt/live/memory/images"
LNK "${aufs_cr}" "${newroot}/mnt/live/memory/copy2ram"
###sfs)

    if [ "${break}" = "post" ]; then
        msg2 ":: '${break}' Break requested, type 'exit' to resume operation"
        launch_interactive_shell
    fi
}

# vim:ft=sh:ts=4:sw=4:et:
