Chroot on Ivon's Blog

Solutions when Termux proot cannot use the systemctl command

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 31 Aug 2024 23:00:00 +0800

Systemd is an init program. Almost all Linux distributions use Systemd to manage system services, and common commands include systemctl, journalctl, and so on.

However, Termux cannot use Systemd. If you run commands related to systemctl start inside a Termux proot-distro or chroot container environment, you will see this error: System has not been booted with systemd as init system (PID 1). Can't operate. Failed to connect to bus: Host is down

This is because the container environment does not support Systemd.

There is actually no real solution, unless the Termux development team learns from Microsoft WSL and finds a way to make Systemd run. However, we do have some alternatives to address this problem.

Method 1: Start the program directly from the executable path
#

First, understand that Systemd is just an init program for managing system services. It is responsible for starting programs after Linux boots and letting users turn programs on and off. But simply starting a program does not actually require systemctl.

For example, to start the SSH service in proot Debian, the Systemd way is to run the following command:

sudo systemctl start sshd

If we find Systemd’s service file /etc/systemd/system/sshd.service (most Systemd service files are here), we will see that what follows ExecStart= is the command it really executes:

[Service]
EnvironmentFile=-/etc/default/ssh
ExecStartPre=/usr/sbin/sshd -t
ExecStart=/usr/sbin/sshd -D

Therefore, the SSH service can be started directly with this command and run in the background:

mkdir -p /run/sshd

/usr/sbin/sshd -D

Note: programs inside Termux proot-distro cannot use ports below 1000. When logging in to proot-distro, add the --fix-low-ports parameter to redirect SSH port 22 to 2022.

If you want to automatically start a specific program after logging in to proot-distro, the simplest way is to add the command you want to run to ~/.bashrc in the user’s home directory.

Method 2: Switch to a distribution that uses OpenRC
#

OpenRC and runit are more traditional init programs. They are not as complex as Systemd, and they can run and manage services in proot. Users unfamiliar with OpenRC commands can refer to the Systemd and OpenRC command comparison table below.

At present, the proot-distro distribution that uses OpenRC is Alpine Linux, while Artix Linux and Void Linux use runit.

Install Alpine Linux

proot-distro install alpine
proot-distro login alpine

Install the OpenRC package

apk add openrc

After that, append this command when logging in to proot, and the OpenRC program will start

proot-distro login alpine --fix-low-ports -- /bin/ash -c "/sbin/openrc default; /bin/ash -l"

After that, you can use OpenRC to manage services. For example, SSH can be managed with the rc-service command, without typing the executable path

sudo rc-service sshd start

You can also configure the SSH service to start automatically after logging in to proot-distro.

sudo rc-update add sshd

Method 3: Run a full Linux system virtual machine
#

The ultimate solution is to emulate a full Linux system so that Systemd can run.

Use debootstrap on x86 to create an ARM rootfs and install a chroot Debian environment on Android

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 23:00:00 +0800

According to the Debian Wiki, debootstrap is a wrapper script that can produce a minimal Debian or Ubuntu rootfs (root filesystem) according to personal preference. It is suitable for people who want to set up Linux from scratch themselves, installing a Linux system in a way similar to Arch Linux’s pacstrap.

But that is not my purpose here. I want to move the completed rootfs to a phone for chroot or Termux proot use, and run a Debian environment on the phone.

I will use a Linux computer to create the Debian rootfs. Since the computer is x86_64, I need to use the QEMU emulator in order to enter an ARM64 chroot environment on the computer.

If you do not want to use a computer, then take a more roundabout route: first install chroot Ubuntu on the phone, then install debootstrap inside it to create the Debian rootfs. This method does not need QEMU translation, but it cannot be done through a rootless Termux environment.

Install the debootstrap package; most Linux distributions include it. As for installing arch-linstall-scripts, that is because it provides the useful arch-chroot script

sudo apt install debootstraparch-linstall-scripts

To create an ARM rootfs on an x86 computer, we need to use the qemu-user-static tool to emulate the ARM64 instruction set

sudo apt install qemu-user-static

Confirm that the binfmt service is enabled

sudo systemctl enable --now systemd-binfmt.service

Create the Debian rootfs directory

cd ~/Downloads
mkdir debian

Start creating the Debian 12 Bookworm rootfs, downloading packages from the Taiwan Debian server

sudo debootstrap --arch arm64 --components=main,universe bookworm debian12 http://ftp.tw.debian.org/debian/

After installation, first put qemu-aarc64 into the rootfs, so it will automatically translate instructions

which qemu-aarch64

sudo cp /usr/bin/qemu-aarch64 debian/usr/bin

Chroot into it and do some initialization. When using arch-chroot, you do not need to manually mount /proc and such; everything is handled automatically

sudo arch-chroot debian

Use cat /etc/os-release to confirm that it is a Debian system
After configuring it, exit chroot

exit

Compress the rootfs into a tar.gz

sudo tar -zcpf debian.tar.gz debian/*

Send it to the Android phone with ADB and extract it on the phone.

The process of installing a desktop environment is similar, so I will not repeat it. The steps involving commands below can also be completed first on the computer described above.

If the phone has root privileges, refer to chroot Ubuntu

If it does not have root privileges, refer to Termux proot for installing the desktop environment.

Install Linux distributions on an Android phone: Termux proot-distro tutorial

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 15:00:00 +0800

This article discusses how to use proot-distro to install Linux distributions.

Termux, as a terminal emulator, can install Linux distributions on a phone with the proot-distro tool, without root privileges.

For example, you can install Ubuntu, Arch Linux, Alpine Linux, Fedora, Debian, openSUSE, and so on.

Running Debian 11 on a Sony Xperia 5 II

Linux distributions installed by proot-distro only have a text interface. The graphical interface has to be configured yourself.

If you find that troublesome, you can refer to the automated scripts provided at the end of the article.

1. What are proot & proot-distro?
#

On a GNU/Linux computer system, we can use the chroot command to create an isolated Linux environment. This is the earliest container concept, which appeared before cgroups. After switching into it through the chroot command, it feels as if you have entered another system. For example, using debootstrap on Ubuntu to create a Debian environment, then running a Debian environment.

chroot is neither a virtual machine nor an emulator, because the inside of a chroot container shares the Linux kernel with the host and shares many system resources.

Chroot on Ivon's Blog

Solutions when Termux proot cannot use the systemctl command

Method 1: Start the program directly from the executable path #

Method 2: Switch to a distribution that uses OpenRC #