banner-hb

Installation Handbook

This guide will go into depth on how to install Everest Linux.

If you nedd assistance, feel free to reach out on IRC (#everestlinux), or Discord.

Prerequisites

The following steps will be used to complete the installation:

- Set up the environment by creating proper mountpoints, users, and partitions

- Download the Everest Linux rootfs image

- Unpack the rootfs image onto the previously set up mountpoint

- Chroot into the new system

- Set up Glacier

- Install system software

- Install the Linux kernel

- Set up init scripts/services

- Reboot the system

Note: Everest is highly flexible, and every aspect of the system can be changed.

If you are changing anything, it is assumed you know exactly what you're doing.

Commands prefixed with (user)$ should be run as an unprivileged user.

Commands prefixed with (root)# should be run as the root user.

Commands prefixed with (chroot)# should be run as the root user inside the chroot environment.

Set up the environment

Our environment needs to be set up correctly before any other steps can proceed.

Create the system mountpoint:

(root)# mkdir -v /mnt/everest

Assign the system mounpoint a variable for ease of use:

(root)# export EVEREST=/mnt/everest

Create any necessary partitions:

/boot - 256MB

(optional) swap - RAM * 2

/ - rest of the drive

Mount the root partition to the system mountpoint:

(root)# mount /dev/sdX /mnt/everest

Create the boot directory:

(root)# mkdir -pv /mnt/everest/boot

Mount the boot partition:

(root)# mount /dev/sdX /mnt/everest/boot

Our system is now set up for the installation.

Downloading the Everest image

An Everest Image is an uncomplete root filesystem image which provides a strong base to build off of.

Each image has slight differences to others, some differences may include:

- The init system

- The standard C library

- The architecture

Images are designated in the following ways:

everestlinux-X.X.X-INIT-ARCH(if not x86)-img.tar.xz

For instance, an image targeting x86_64, with the busybox init system would be called:

everestlinux-1.0.0-busybox-img.tar.xz

An image targeting arm64, with systemd would be called:

everestlinux-1.0.0-systemd-aarch64-img.tar.xz

Other designations may be used, such as:

- no_multilib

Ensure you download the correct image for your system. For most users, images targeting

x86_64 with the busybox init system are what you should use.

To get the image to our destination as easily as possible, use wget

(user)$ wget https://git.everestlinux.org/EverestLinux/everest/raw/branch/main/releases/everestlinux-X.X.X-INIT-img.tar.xz

With the image downloaded, the system can now be installed.

Unpacking the Image

The image can now be unpacked into the system mountpoint.

Ensure the image is located in

/mnt/everest

then run the following command to unpack it:

(root)# tar -xpvf everestlinux-img.tar.xz --xattrs-include='*.*' --numeric-owner

The following 2 options are very important. Without them, some binaries may refuse to run due to incorrect file ownership.

Chrooting into the new installation

Our system is now in a partially working state.

If we were to simply call it a day and try to boot into the system now, it would not be possible.

Many parts of the system are missing, including a bootloader and kernel.

Chrooting allows us to access the system to make modifications, without actually booting into it.

Before chrooting, we must mount some partitions.

Chroot into the system:

(root)# everest-chroot /mnt/everest

This program will check the following:

- /mnt/everest exists

- /bin/sh exists

Once in the chroot environment, run the following commands:

(chroot)# export PS1="(chroot) ${PS1}" && source /etc/profile

We are now fully set up for the rest of the installation.

Set up Glacier

Glacier is the package manager for Everest. It must be installed into the new system.

Download the Glacier release tarball:

(chroot)# wget RELEASE_TARBALL

Unpack the tarball and run the installation:

(chroot)# tar xpvf glacier-release-X.X.X.tar.xz && glacierX.X.X/INSTALL.sh

This script will check for the following, and make corrections if necessary:

- The C library is installed

- The C library headers are installed

- The C compiler is installed

- GNU Binutils are installed

- GNU Make is installed

- Python is installed

Edit

/etc/make.conf

and change any settings you wish.

Install the Linux kernel

The kernel can now be installed.

Install the linux-firmware package, which provides firmware for some devices:

(chroot)# glacier -f linux-firmware

Use Glacier to download the source tree:

(chroot)# glacier -f linux

Find the kernel source tree in

/usr/src/linux

Note: Alternatively, you can download a new kernel from kernel.org

Clean the kernel source tree:

(chroot)# make mrproper

Configure the kernel:

(chroot)# make menuconfig

Note: Recommended options for configuration are not provided. It is up to the user to decide what they want to enable.

Compile the kernel:

(chroot)# make && make modules_install

Copy the kernel image to /boot:

(chroot)# make install

(Optional) Build an initramfs

On some systems, an initramfs (initial ram filesystem) is required to boot properly.

Do some research and decide whether you need - or want - an initramfs.

Install dracut:

(chroot)# glacier -f dracut

Build an initramfs:

(chroot)# dracut

Configure the system

Some components of the system must be configured before we can boot.

Create an fstab file.

An example of a properly formatted fstab is below:

/dev/sda1 /boot vfat defaults,noatime 0 2

/dev/sda2 none swap sw 0 0

/dev/sda3 / ext4 noatime 0 1

Enable system services, such as a cron daemon, logger, etc:

(chroot)# esv start cronie chronyd sysklogd # for busybox init

(chroot)# systemctl enable --now cronie chronyd sysklogd # for systemd

Other things you might want to configure are:

- /etc/doas.conf

- /etc/inittab

Configure the bootloader

Our system needs one more component before it can be booted into: the bootloader

For most users, systemd-boot is recommended.

The standalone package for systemd-boot can be installed by running:

(chroot)# glacier -f gummiboot

GRUB

Install the GRUB package:

Note: GRUB is split into 2 packages, grub-bios and grub-uefi.

Ensure you install the correct package.

(chroot)# glacier -f grub-{bios,uefi}

Install GRUB:

(chroot)# grub-install /dev/sdX # for BIOS

(chroot)# grub-install --target=x86_64-efi --efi-directory=/boot --bootloader-id=grub # for UEFI

Create a GRUB configuration file:

(chroot)# grub-mkconfig -o /boot/grub/grub.cfg

systemd-boot

Note: systemd-boot only supports UEFI.

Use GRUB if your system is incompatible with UEFI.

Systemd-boot is included with systemd.

Install systemd-boot:

(chroot)# bootctl install

Edit /boot/loader/loader.conf and create a boot entry at /boot/loader/entries/everest.conf

Finishing the Installation

Every component of the system has been configured, and we can now boot into it.

Exit the chroot environment:

(chroot)# exit

Unmount all partitions from /mnt/everest:

(root)# umount -R /mnt/everest

Power off the system:

(root)# poweroff

Ensure you remove the installation media or you will not boot into the new system.

Post-installation

A base Everest system is pretty minimal. Most users will need to configure extra components,

such as a window manager, sound, or networking.

See page: General Recommendations