- Home
- About
- Handbook
- Packages
- Downloads
- Git

# 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 and modify it, 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`

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