É possível, mas não trivial. Darei algumas dicas, mas não posso fornecer etapas detalhadas, pois nunca tentei isso sozinho.

• OverlayFS - Permite criar um sistema de arquivos "em camadas", onde a camada inferior é somente leitura e a camada superior é gravável. Dito isto, a camada inferior ainda é completamente mutável (você pode editar, excluir arquivos etc., mas eles não são realmente alterados - as alterações são armazenadas inteiramente na camada superior) e funciona como um sistema de arquivos completo.

• tmpfs - É outro sistema de arquivos completo que reside inteiramente na memória. Você pode definir uma capacidade inferior à quantidade de RAM para evitar o bloqueio acidental do sistema operacional. Além disso, a capacidade não utilizada está disponível como RAM regular, o que é bom.

• pivot_root - Uma chamada de sistema que se move /para um diretório diferente.

Normalmente, no início do processo de inicialização, pivot_root é chamado para alternar do espaço do usuário inicial para o sistema de arquivos em disco. Você pode alterar isso: crie OverlayFS com sistema de arquivos em disco na camada inferior e tmpfs na camada superior e, em seguida, pivot_root para OverlayFS.

Esteja avisado que a camada superior pode crescer rapidamente, consumindo muita RAM disponível. O zram pode ser usado para reduzir o uso de RAM ao custo do uso da CPU, mas não é uma solução definitiva. A atualização permanente do sistema operacional em disco também será complicada.

Vou expandir um pouco sobre o assunto para ajudar um iniciante completo como comecei.

Processo de inicialização

O primeiro disco rígido é normalmente dividido em 2 seções:

1. um para o processo de inicialização (a seção lida pelo computador quando você o liga) normalmente chamado /dev/sda1na maioria das distribuições linux
2. um para todas as outras coisas (como sistema e arquivos de usuário) nomeados /dev/sdb1. (os arquivos do sistema e do usuário podem estar em seções diferentes)

No setor de inicialização há uma imagem do kernel, que na verdade é uma imagem initramfs . Um intramfs é o "menor" sistema funcional carregado na RAM. Pode ser visto como uma pequena versão do seu sistema linux: você encontrará módulos, alguns diretórios que você vê em seu sistema habitual, mas com um conteúdo diferente. Esse pequeno sistema linux é usado para verificar a configuração do seu computador (que tipo de dispositivo de armazenamento você usa, quais são seus componentes, etc.) arquivos de sistema reais para torná-lo acessível para mais tarde. Em outras palavras, quando você liga o computador, ele lê a /dev/sda1partição e tenta encontrar a partição/dev/sdb1para um uso posterior. Mas para entender como seus arquivos são acessíveis, você precisa entender os pontos de montagem

Ponto de montagem

No Linux, todos os diretórios são acessíveis em um único diretório chamado root , que é /. Não misture o armazenamento do usuário root /rootcom o root do sistema de arquivos /. Quando você conecta um dispositivo de armazenamento externo, como uma unidade USB, seu sistema cria um novo diretório e o usa como raiz desse dispositivo. Em outras palavras, nesse diretório você pode acessar todos os arquivos armazenados nele. Esse diretório é chamado de ponto de montagem. Para criar um ponto de montagem você precisa ter um dispositivo (um USB por exemplo), um diretório e um sistema de arquivos (um programa que é usado como uma interface entre seus programas de espaço de usuário e a memória física de seu dispositivo) e então use o seguinte comando:

mount -t name_filesystem name_device name_directory

Tecnicamente, quando você conecta algo, precisa montar manualmente o dispositivo. Mas o linux faz isso automaticamente quando você conecta um dispositivo comum (como um USB). Todos os dispositivos internos do seu computador são montados automaticamente durante a inicialização graças ao arquivo file /etc/fstabque contém todas as informações necessárias para montá-los (como as partições do seu disco rígido, leitor de cd-ROM, ...) Para ver todos os outros pontos de montagem usado atualmente pelo sistema, você pode ver/proc/mounts

Montando o sistema de arquivos raiz na inicialização

De volta ao processo de inicialização, quando a imagem initramfs é carregada na memória, ela verifica qual partição do seu disco rígido é usada para armazenar seus arquivos (como /dev/sdb1) e monta-a na raiz do seu sistema de arquivos comumente chamado de /root. Isso /rootnão é o mesmo que /rootem seu espaço de usuário (quando seu sistema está completamente carregado). Com isso /root, você terá acesso a todos os seus arquivos e ao /rootque você conhece:

/root <--- initramfs
   /home
      /myName
        ... all my files
   /root <--- super user

O sistema de arquivos raiz é montado como somente leitura durante a inicialização e então remontado como leitura/gravação em um sistema de arquivos virtual (que é apenas uma maneira de lidar com diferentes dispositivos, portanto, diferentes sistemas de arquivos relacionados a cada dispositivo, com os mesmos comandos para programas em seu espaço de usuário )

Initrd vs Initramfs

Initramfs é o sucessor do initrd que foi carregado na memória com todas as ferramentas necessárias para então montar o sistema de arquivos real e finalmente se descarregar da memória. Mas um initramfs permanece na memória e todo o sistema é baseado no sistema de arquivos raiz que é montado pelo initramfs. Essa diferença também implica em comandos diferentes ( por exemplo pivot_root , torne- se switch_root)

Editar initramfs

A imagem do kernel usada para o processo de inicialização pode ser editada no sistema. Essa imagem está armazenada em /boot. Você pode editá-lo descompactando -o. O processo que você deseja editar é o initda sua imagem (que é o primeiro script executado) e precisamente a parte quando o sistema de arquivos real é montado sob o /rootqual se parece com:

log_begin_msg "Mounting root file system"
# Always load local and nfs (since these might be needed for /etc or
# /usr, irrespective of the boot script used to mount the rootfs).
. /scripts/local
. /scripts/nfs
. /scripts/${BOOT}
parse_numeric ${ROOT}
maybe_break mountroot
mount_top
mount_premount
mountroot

Observe que ${ROOT}contém o nome do dispositivo usado para seus arquivos de sistema (por exemplo /dev/sdb1, mas pode ser diferente)

Mas essa é uma solução confusa porque quando a imagem for atualizada pelo seu sistema (por alguns motivos), suas modificações serão perdidas. Mas o linux tem a solução para manter suas modificações em todas as imagens do kernel, mesmo após as atualizações: initramfs-tools . Todas as modificações que você terá que fazer serão feitas em /etc/initramfs-tools Então, depois de editar sua imagem, use o seguinte comando para atualizar a imagem do kernel:

update-initramfs -u

Essa imagem será usada após a próxima reinicialização. Portanto, para evitar travar seu sistema, use uma máquina virtual como virtualBox ou

Depois de construído, você desejará instalar seu novo kernel junto com o antigo e configurar o gerenciador de inicialização para tornar o kernel selecionável no momento da inicialização. Dessa forma, mesmo que algo dê muito errado, você ainda pode inicializar seu sistema usando o kernel existente.

Sobreposição

Para montar a sobreposição sobre um diretório existente, use:

mount -t overlay -o lowerdir=/overlay/lower,upperdir=/overlay/upper,workdir=/overlay/work overlay /myDir

Observe que não há absolutamente nenhum espaço entre lowerdir=..,upperdir=...,workdir=... e o último overlaypode ser substituído por none(porque você não monta nada, nenhum dispositivo sobre /myDir; basta montar overlay). E quando você fizer algo ruim (se um diretório não existir ou você colocar espaços nas opções de montagem -o ..., o resultado será "não existe tal dispositivo em /etc/fstab" ( overlay gerencia terrivelmente erros durante a montagem). Você pode olhar para esse link e aquele para encontrar mais ajuda.

Abaixo /myDirvocê verá todos os arquivos que estão em /overlay/lowere todas as modificações que você fez (que estão armazenadas em /overlay/upper):

/overlay/lower      /overlay/upper          /myDir (mountpoint)
   /file1  ---------->  /file1   --------->   /file1
      'abcdef'            'abOdef'               'abOdef'
   /file2 -------------------------------->   /file2

tmpfs

tmpfs é um sistema de arquivos que pode manipular a RAM como uma memória padrão. Para criar um disco RAM (uma parte da RAM que funciona como uma parte de um disco rígido), use:

mount -t tmpfs none /myDir
           or
mount -t tmpfs tmpfs /myDir

Em seguida, todas as operações feitas /myDirserão salvas na RAM.

Solução

Módulos

Adicione o módulo de sobreposição à imagem do kernel (para que o módulo possa ser usado durante o processo de inicialização). Adicionar overlayno arquivo/etc/initramfs-tools/modules

ganchos

Adicione o seguinte script em /etc/initramfs-tools/hooks( como um executável )

#!/bin/sh

#set kernel functions file as sources (so these functions can be used)
. /usr/share/initramfs-tools/scripts/functions
. /usr/share/initramfs-tools/hook-functions

#If you want to use a custom package into the initramfs use 
#copy_exec path_to_package
#For example if you want to use whiptail add : copy_exec /usr/bin/whiptail

Roteiro

Adicione o seguinte script em /etc/initramfs-tools/scripts/init-bottom(como um executável)

#!/bin/sh

PREREQ=""
prereqs()
{
   echo "$PREREQ"
}

case $1 in
prereqs)
   prereqs
   exit 0
   ;;
esac

DIR=/overlay
UPPER_DIR=$DIR/upper
LOWER_DIR=$DIR/lower
WORK_DIR=$DIR/work

mkdir $DIR
#create temporary filesystem in RAM
mount -t tmpfs tmpfs $DIR
if [ $? -ne 0 ]; then
    fail_err "Fail to mount tmpfs on $DIR"
    exit 1
fi

#create lower, upper and workdir for overlay
mkdir $UPPER_DIR $LOWER_DIR $WORK_DIR

# move root mountpoint to the lower layer
mount -n -o move ${rootmnt} $LOWER_DIR
if [ $? -ne 0 ]; then
    fail_err "Cannot move ${rootmnt} to $LOWER_DIR"
    exit 1
fi

#mount overlay on to the root
mount -t overlay -o lowerdir=$LOWER_DIR,upperdir=$UPPER_DIR,workdir=$WORK_DIR overlay ${rootmnt}
if [ $? -ne 0 ]; then
    fail_err "Cannot mount overlay on ${rootmnt} [lowerdir=$LOWER_DIR, upperdir=$UPPER_DIR, workdir=$WORK_DIR]"
    exit 1
fi

#mount virtual filesystem over the lower dir (as it's donne for the root with /proc and /sysfs which are mounted on to the root at the end of the init)

#uncomment that section if you want to access the layers of overlay whithin userspace
#mkdir -p ${rootmnt}$DIR
#mount -n -o rbind $DIR ${rootmnt}$DIR
#if [ $? -ne 0 ]; then
#    fail_err "Cannot remount ${rootmnt} and its sub mountpoints on ${rootmnt}$DIR"
#    exit 1
#fi

# edit fstab to match the actual modifications

#get the device that is mounted on the rootfilesystem
root_device="$(awk '$2 == "/" {print $0}' ${rootmnt}/etc/fstab)"
#check if that device exists
blkid $root_device
if [ ! $? -gt 0 ]; then
    target=${rootmnt}/etc/fstab
    target_c=$target.orig
    #create a copy of the file (that will be accessible later)
    cp $target $target_c
    #remove the root device from the file
    grep -v "$root_device" $target_c > $target

    #add overlay on root as a device in the file
    awk '$2 == "'${rootmnt}'" { $2 = "/" ; print $0}' /etc/mtab >> $target
fi

Atualizar

Atualize a imagem do kernel com:update-initramfs -u

Links para montar a sobreposição sobre o sistema de arquivos raiz

resolva problemas de corrupção de cartão SD raspbian com partição raiz montada somente leitura

Initramfs personalizados

Não é possível desmontar após pivot_root

Montar raiz como overlayfs

Can not mount overlayfs inside initrd

How to use OverlayFS to protect the root filesystem ?