Chroot

Resources

Wikipedia

Chroot (Change root) é um utilitário do sistema Unix usado para alterar o diretório aparente do root para criar um novo ambiente logicamente separado do diretório root do sistema principal. Este novo ambiente é conhecido como "jaula chroot". Um usuário operando de dentro da jaula não pode ver ou acessar arquivos fora do ambiente que tenha sido bloqueado.

Um dos principais usos para chrooting é criar um sistema Linux em cima de um atual para fins de teste ou compatibilidade de software. Chroot é frequentemente visto como uma alternativa leve para a virtualização, porque é capaz de funcionar sem a sobrecarga de um hypervisor.

Pré-requisitos

Configurando o ambiente

Ao criar uma nova configuração de chroot, a primeira coisa necessária é um diretório para o chroot residir. Por exemplo, um chroot pode ser criado em /mnt/mychroot:

user $mkdir /mnt/mychroot

user $cd /mnt/mychroot

Para montar uma instalação existente de uma partição o seguinte comando pode ser executado. Certifique-se de substituir <DEVICE> no exemplo abaixo com o drive e partição da instalação existente:

user $mkdir /mnt/mychroot

user $mount /dev/<DEVICE> /mnt/mychroot

Se uma instalação já tenha sido criada anteriormente em um sub-diretório do sistema de arquivo atual do root, os passos acima podem ser ignorados.

Desempacotando sistema de arquivos e a árvore do Portage (novas instalações)

Ao criar uma nova instalação, o próximo passo é baixar os tarballs do stage3 e do Portage e configurá-los no chroot. Para maiores informações nestes processos, por favor, veja Baixando o arquivo tar do stage e Desempacotando o arquivo tar de stage

root #links http://distfiles.gentoo.org/releases/amd64/autobuilds/

root #tar xvjpf stage3-*.tar.bz2 -C /mnt/mychroot

Configuração

Antes de entrar no chroot um número de diretórios precisam ser montados:

root #mount --rbind /dev /mnt/mychroot/dev

root #mount --make-rslave /mnt/mychroot/dev

root #mount -t proc /proc /mnt/mychroot/proc

root #mount --rbind /sys /mnt/mychroot/sys

root #mount --make-rslave /mnt/mychroot/sys

root #mount --rbind /tmp /mnt/mychroot/tmp

Alguns arquivos básicos de configuração terão ser copiados a partir do host, não copie mais do make.conf ao usar uma instalação existente:

user $cp /etc/portage/make.conf /mnt/mychroot/etc/portage # Quando usar uma instalação existente, ignore este comando.

user $cp /etc/resolv.conf /mnt/mychroot/etc

Uso

Uma vez feito, entre no ambiente de chroot executando os seguintes comandos:

root #chroot /mnt/mychroot /bin/bash

root #env-update && . /etc/profile

root #export PS1="(chroot) $PS1"

Ao criar uma nova instalação o Portage deve ser sincronizado para garantir que tudo está atualizado.

(chroot) root #emerge-webrsync

(chroot) root #emerge --sync

O sistema agora está pronto; fique à vontade para instalar softwares, mexer com as configurações, pacotes experimentais de teste e configurações sem ter qualquer efeito sobre o sistema principal. Para sair do chroot simplesmente digite exit ou pressione Ctrl+d. Fazendo isto, irá retornar o console de volta ao ambiente normal. Não se esqueça de executar umount nos diretórios que foram montados.

systemd-nspawn

If the system uses systemd, systemd-nspawn can be used, which can automatically handle much of the boilerplate required in administering chroots. For example, to enter a chroot via systemd-nspawn with the same configuration as specified in the Configuration section, simply run:

root #cp /etc/portage/make.conf /mnt/mychroot/etc/portage

root #systemd-nspawn -D /mnt/mychroot --bind=/tmp --resolv-conf=/etc/resolv.conf

Scripts de inicialização

Se a definição de chroots é uma tarefa que é necessária ser realizada frequentemente, é possível acelerar a montagem dos diretórios usando um script de inicialização. O script precisa ser adicionado ao runlevel default e portanto configurado automaticamente na inicialização do sistema:

FILE /etc/init.d/mychroot

#!/sbin/openrc-run
 
depend() {
   need localmount
   need bootmisc
}
 
start() {
     ebegin "Mounting chroot directories"
     mount -o rbind /dev /mnt/mychroot/dev > /dev/null &
     mount -t proc none /mnt/mychroot/proc > /dev/null &
     mount -o bind /sys /mnt/mychroot/sys > /dev/null &
     mount -o bind /tmp /mnt/mychroot/tmp > /dev/null &
     eend $? "An error occurred while mounting chroot directories"
}
 
stop() {
     ebegin "Unmounting chroot directories"
     umount -f /mnt/mychroot/dev > /dev/null &
     umount -f /mnt/mychroot/proc > /dev/null &
     umount -f /mnt/mychroot/sys > /dev/null &
     umount -f /mnt/mychroot/tmp > /dev/null &
     eend $? "An error occurred while unmounting chroot directories"
}

Ao usar um diretório ou partição diferente, adicione os comandos de montagem necessários na função start() e altere /mnt/chroot para o nome apropriado.

Sound and graphics

The software running inside the chroot will by default not have access to the system sound- and display-server. Fixing this is done by either sharing a socket, or by running the communication with TCP over localhost.

Wayland

Wayland uses a socket to connect clients with the compositor. This socket needs to be shared with the chroot to make graphical applications work. The general procedure for finding this socket is:

1. If WAYLAND_SOCKET is set, interpret it as a file descriptor number on which the connection is already established, assuming that the parent process configured the connection for us.
2. If WAYLAND_DISPLAY is set, concat with XDG_RUNTIME_DIR to form the path to the Unix socket.
3. Assume the socket name is wayland-0 and concat with XDG_RUNTIME_DIR to form the path to the Unix socket.

Using WAYLAND_DISPLAY and XDG_RUNTIME_DIR is fine in most cases and will be used here. By default XDG_RUNTIME_DIR is set to /run/user/$(uid). This directory will not be available in the chroot because the #Configuration instructions bind mounts /run non-recursively. Assuming the user's uid is 1000, this can be solved by either bind-mounting /run/user/1000 with:

root #mkdir -p /mnt/mychroot/run/user/1000

root #mount --bind /run/user/1000 /mnt/mychroot/run/user/1000

or by simply recursively bind mounting /run with:

root #mount --rbind /run /mnt/mychroot/run

The Wayland library dev-libs/wayland uses the same procedure for finding out the socket as listed above. So to share the socket with the chroot, the only thing that's needed to do is defining XDG_RUNTIME_DIR and WAYLAND_DISPLAY. Here it is assumed that the Wayland socket name WAYLAND_DISPLAY is wayland-0.

(chroot) root #useradd -m user

(chroot) root #su -l user

(chroot) user $export XDG_RUNTIME_DIR=/run/user/1000

(chroot) user $export WAYLAND_DISPLAY=wayland-0

(chroot) user $MOZ_ENABLE_WAYLAND=1 firefox-bin

Permission errors will occur if the user in the chroot does not have permissions to access the Wayland socket. This can be solved by using user namespace remapping or ACLs. The easiest solution is to just make sure that the user ids match. The useradd -u, --uid UID option can be used when creating a user.

PipeWire

Like Wayland, PipeWire uses a socket to connect clients to the PipeWire daemon.

Applications assume that the PipeWire socket will be located in ${XDG_RUNTIME_DIR}/pipewire-0, so the only thing that's needed to get PipeWire clients to connect to the host's daemon is to expose XDG_RUNTIME_DIR to the chroot. This process is identical to the one described in #Wayland. To expose XDG_RUNTIME_DIR, often /run/user/$(uid), the following commands are used:

root #mkdir -p /mnt/mychroot/run/user/1000

root #mount --bind /run/user/1000 /mnt/mychroot/run/user/1000

XDG_RUNTIME_DIR will not be set when logging in inside the chroot, therefore XDG_RUNTIME_DIR needs to exported so the PipeWire client can find the socket:

(chroot) user $export XDG_RUNTIME_DIR=/run/user/1000

(chroot) user $pw-cli

Xorg

Xorg by default listens on a socket located in /tmp/.X11-unix/X${DISPLAY}, as well as on localhost TCP port 6000 + ${DISPLAY}. The instructions in #Configuration bind mounts /tmp, and therefore no additional configuration is needed except setting the DISPLAY variable before running a graphical application:

(chroot) user $DISPLAY=:0 firefox-bin

If the uid of the user inside the chroot does not match the uid outside the chroot, then setting permissions with xhost will be needed. To allow all local connections, run outside the chroot:

user $xhost +local:

Veja também

• Project:X86/Chroot Guide — provides instructions on how to create chroots to assist in testing Gentoo packages for stabilization.
• Usando chroot em serviços de proxy
• Usando chroot em servidores virtuais

External resources

• chroot on Archlinux's wiki