#!/bin/bash
#
# /sbin/aufs_init
#
# Generic script to overlay a r/w rootfs with a tmpfs in RAM,
# so that writes go only to RAM rather than the real root device.
# If any step fails, we abort and continue with normal system init.
#
# The real rootfs is still accessible (r/w) as /.rw/ when needed.
#
# Invoke with "init=/sbin/aufs_init" on the kernel command line.
#

PATH="$PATH:/sbin:/usr/sbin"
INIT=/sbin/init
TMPFS=.tmpfs
AUFS=.aufs
OLDROOT=.rw
CONS=/dev/console
ROOTDEV=/dev/root

## We want/need r/w access to the real filesystem:
cd /
mount -n "${ROOTDEV}" / -oremount,rw,noatime,nodiratime,errors=remount-ro

## Create mount points (if not already there) for tmpfs and aufs filesystems:
mkdir -p "${TMPFS}" || exec "${INIT}"
mkdir -p "${AUFS}"  || exec "${INIT}"

## Create/mount the tmpfs RAM-based filesystem:
mount -n tmpfs "${TMPFS}" -t tmpfs || exec "${INIT}"

## Use aufs to overlay the tmpfs on top of the rootfs:
mount -n -t aufs -o"noatime,nodiratime,br:${TMPFS}=rw:/=ro" none ${AUFS} || exec "${INIT}"

# Clean out some leftover temporary files, to save a little space:
cd "${AUFS}"
rm var/log/* &> /dev/null
rm -r tmp/* tmp/.[A-Z] &> /dev/null
rmdir "${TMPFS}" "${AUFS}"

# Create a default /etc/mtab file on the new aufs:
echo "none / aufs rw,noatime,nodiratime 0 0" > "etc/mtab"

## Now switch to the new aufs root filesystem, and continue with normal init:
mkdir -p "${OLDROOT}" || exec "${INIT}"
pivot_root . "${OLDROOT}"
exec chroot . "${INIT}" < "./${CONS}" > "./${CONS}" 2>&1

#include <fcntl.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <syscall.h>

int main (int argc, char *argv[])
{
        int fd;
        struct stat st;
        void *contents;

        fd = open(argv[1], O_RDONLY);
        if (fd != -1 && fstat(fd, &st) != -1) {
                contents = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
                if (contents != MAP_FAILED)
                        if (syscall(SYS_init_module, contents, st.st_size, "") == 0)
                                return 0;
        }
        perror(argv[1]);
        return 1;
}

#!/bin/bash
#
# Script to "commit" aufs tmpfs changes back to the underlying persistent filesystem.
#

SCRIPT="`realpath $0`"
ROOT=/.rw
AUFS=$ROOT/.tmpfs
arg1="$1"

MIRRORDIR=/usr/bin/mirrordir
if [ ! -x $MIRRORDIR ]; then
        echo "$MIRRORDIR: not found; aborting." >&2
        exit 1
fi

COMMIT=""
if [ "$1" = "--commit" ]; then
        COMMIT="$1"
        shift
fi

function doit(){
        echo "$*"
        [ "$COMMIT" = "--commit" ] && $*
}

if [ "$1" = "" ]; then
        cd $AUFS || exit 1
        find . -type f -name .wh.\* | xargs -n1 $SCRIPT $COMMIT WHITEOUT
        doit sync

        cd $AUFS || exit 1
        find . | xargs -n1 $SCRIPT $COMMIT COPY
        doit sync

        [ "$COMMIT" = "--commit" ] || (echo ;echo "$SCRIPT: Dry run complete. Use --commit to do it for real"; echo)
        exit 0
fi

if [ "$1" = "WHITEOUT" ]; then
        cd $AUFS || exit 1
        dir="${2%%/.wh.*}"
        fn="${2##*/.wh.}"
        if [ "$dir" = "." ]; then
                [ "$fn" = ".rw" -o "$fn" = ".aufs" -o "$fn" = ".tmpfs" ] && exit 0
        fi
        if [ "$fn" = ".wh..opq" ]; then
                if [ -d "$ROOT/$dir" ]; then
                        if [ -d "$dir" ]; then
                                doit $MIRRORDIR -v --exclude-regexp '.*/[.]wh[.].*' "$dir" "$ROOT/$dir"
                        else
                                doit rm -rf "$ROOT/$dir"
                        fi
                fi
                exit 0
        fi
        if [ "$dir/.wh.$fn" = "$2" ]; then
                [ -e "$ROOT/$dir/$fn" ] && doit rm -rf "$ROOT/$dir/$fn"
        fi
        exit 0
fi

if [ "$1" = "COPY" ]; then
        cd $AUFS || exit 1
        if [ -d "$2" ]; then
                [ "$2" = "./.wh..wh.plink" ] && exit 0
                cd $AUFS || exit 1
                dir="${2%%/.wh.*}"
                if [ ! -e "$ROOT/$dir" ]; then
                        doit mkdir -p "$ROOT/$dir"
                        doit $MIRRORDIR -v --exclude-regexp '.*/[.]wh[.].*' "$dir" "$ROOT/$dir"
                fi
                exit 0
        fi
        [ "${2:0:6}"  = "./.wh."     ] && exit 0
        [ "${2:0:6}"  = "./tmp/"     ] && exit 0
        [ "${2:0:10}" = "./var/tmp/" ] && exit 0
        dir="${2%%/*}"
        fn="${2##*/}"
        [ "${fn:0:4}" = ".wh." ] && exit 0
        [ ! -e "$ROOT/$dir" ] && doit mkdir -p "$ROOT/$dir"
        if [ -f "$2" -a -f "$ROOT/$2" ]; then
                if diff -q "$2" "$ROOT/$2" >/dev/null ; then
                        [ "$2" -nt "$ROOT/$2" ] && touch -m -r "$2" "$ROOT/$2"
                        exit 0
                fi
        fi
        doit cp -dp "$2" "$ROOT/$2"
        exit 0
fi

echo "$SCRIPT: huh?  $*" >&2