# Everest Linux - Install

Home About Install Packages Downloads Docs Errata Git ↗

## Installation Handbook

This guide is the official installation handbook for Everest Linux.

<warnhead>WARNING:</warnhead>

Using unofficial guides is not recommended, as they may be outdated, or unreliable. The official guide is located at https://www.everestlinux.org/install.

<warnhead>WARNING:</warnhead>

Simply copy and pasting commands from this guide won't cut it, and you'll most likely end up with a broken installation. Ensure you know what each command does, and how to tailor it to your system, if necessary.

<warnhead>WARNING:</warnhead>

Everest is not for the faint of heart. If you have never touched Linux in your life, Everest is most certainly not for you. Linux Mint is a great distribution that works out of the box, and is a great entry point into Linux.

<warnhead>WARNING:</warnhead>

Everest at its current state is highly experimental. Install at your own risk.

If you need assistance, reach out to us on IRC (libera.chat, #everestlinux) or Discord.

## Prerequisites

The following steps are required to complete an installation:

1. Set up the build environment
2. Download a system image
3. Unpack the system image
4. Change root into the new system
5. Install programs
6. Install the Linux kernel
7. Set up init scripts and services
8. Install the bootloader
9. Reboot the system

Note that Everest is highly flexible. That being said, it is up to you to make modifications yourself.

Run commands prefixed with `(user)$` as an unprivileged user.

Run commands prefixed with `(root)#` as the root user.

Run commands prefixed with `(chroot)#` inside the chroot environment.

## Set up the environment

Everest needs a proper environment set up in order to install correctly.

A system mountpoint is where the new system's root (/) will be. Where you put this doesn't matter, as the host system used to build the system won't be included in the final installation. In this example, we will use /mnt/everest.

Create a system mountpoint:

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

A variable pointing to the system mountpoint may be useful in the future, as it will save you a bit of typing.

Create a variable for the system mountpoint:

`(root)# SYS_MNT=/mnt/everest`

Partitions must be created on the drive you wish to install Everest to. The typical partition layout on an Everest system may differ from other distributions.

The typical layout is:

Mount point | Type | Suggested size
--- | --- | ---
/mnt/everest/boot | EFI system partition (esp) | No smaller than 256 MB, no larger than 1 GB
/mnt/everest/usr | /usr | No smaller than 25 GB
/mnt/everest | Root filesystem | Remainder of the drive

Partition the target drive:

`(root)# cfdisk /dev/sdX`

A valid filesystem is required on the drive.

Most filesystems should work, however ensure the system has the corresponding package for whatever filesystem you choose.

For example, if XFS is used, when installing the system:

`(chroot)# gpkg -f world/xfsprogs`

<warnhead>WARNING:</warnhead>

Zfs is not officially supported by Everest, and requires a lot of configuration to work properly. Use Zfs at your own risk.

In this example, Ext4 will be used.

Create a filesystem:

`(root)# mkfs.ext4 /dev/root`

`(root)# mkfs.ext4 /dev/usr`

The EFI system partition (esp) must be formatted as FAT32.

`(root)# mkfs.vfat -F32 /dev/boot`

Mount the root partition to the system mountpoint:

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

Some additional directories may need to be created.

Create extra needed directories:

`(root)# mkdir /mnt/everest/boot`

`(root)# mkdir /mnt/everest/usr`

Mount the remaining partitions:

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

`(root)# mount /dev/usr /mnt/everest/usr`

Create remaining directories on /usr with mkusrskel:

`(root)# mkusrskel -d /mnt/everest/usr`

## Downloading a system image

An Everest system image provides an incomplete root filesystem which users can build a system off of. Users should be careful of which image they choose, as switching in the future is arduous, time consuming, and requires rebuilding a lot of packages.

It's a lot better to get it right the first time, rather than trying to get it right later.

Do some thorough planning to ensure you get the right system image. For instance, ask yourself a few questions, such as:

1. Do I need 32 bit libraries?
2. Will I be using proprietary software that cannot be recompiled?
3. Do I require a specific C library for my hardware setup?
4. Do I want to set up NSA Security Enhanced Linux (SELinux)
5. Do I want an init system other than Busybox's built in init configured out of the box?

<warnhead>WARNING:</warnhead>

Make sure you're happy with the system image you choose. While migrating in the future is possible, it requires rebuilding the majority of the system.

Downloading a system image that is severely out of date is not recommended. Many programs, such as the kernel or SSL library will be vulnerable to attacks.

Download a system image with wget:

`(user)$ wget https://git.everestlinux.org/EverestLinux/everest/raw/branch/main/releases/SYSTEM_IMAGE.tar.xz`

## Unpacking the system image

Now that a system image has been downloaded, we can unpack it.

Ensure the system image is inside the system mountpoint, otherwise you may run into trouble.

Since a Linux root filesystem is complex, and many different files need to be owned by certain users, or have certain permissions, simply running `tar xf` will result in a broken image. A couple extra flags are needed to preserve these permissions in the unpacked image.

Unpack the system image:

`(root)# tar -xpvf SYSTEM_IMAGE --xattrs-include='*.*' --numeric-owner`

If this command was run correctly, you shouldn't need to edit any permissions manually.

In case permissions were changed, you can use the 'prep' command from everest-build-tools.

## Chrooting into the system mountpoint

Although we have a relatively complete root filesystem at this point, many essential programs are still missing. These include the kernel and bootloader. Without these, the system is unable to boot. At this point, we must chroot into the new system. This will allow us to complete the system without booting.

Chroot into the new system:

`(root)# everest-chroot /mnt/everest`

Change the shell prompt to differentiate the two environments:

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

## Install packages

Any programs you wish to install, such as display servers, login managers, and desktop environments, should be installed now. The kernel can take multiple hours to compile on some hardware.

Glacier manages packages on the system, and it allows users to install, or 'merge' their own. It is recommended to get familiar with this system.

<wikihead>WIKI: Introduction to Glacier</wikihead>

## Install the Linux kernel

The most important part of the system, the kernel, which allows hardware to communicate with software, is ready to be installed.

If needed, merge the linux-firmware package, which provides device firmware:

`(chroot)# gpkg -f world/linux-firmware`

At this stage, you can decide which kernel you want to install. In Everest's package repository, many prebuilt kernels are available, as well as the source code, should you wish to compile your own.

Option 1: Custom kernel

Compiling a custom kernel is the recommended option for most users, as it allows the most control.

Download the kernel's source tree:

`(chroot)# gpkg -f world/linux`

The source tree will be located under /usr/src/linux.

Inside /usr/src/linux, ensure the source tree is completely clean by running the following:

`(chroot)# make mrproper`

The kernel must be configured before it is compiled.

Users installing systemd should enable IPv6 in the kernel configuration:

<khead>KERNEL: Enbable support for IPv6</khead>

Networking support --->

Networking options --->

<*> The IPv6 protocol [CONFIG_IPV6]

Recommended options are not provided - it is up to you to configure the kernel for your setup.

Configure the kernel:

`(chroot)# export EVEREST_ARCH="$(echo $MACHTYPE)"`

`(chroot)# ARCH=$EVEREST_ARCH make defconfig`

`(chroot)# ARCH=$EVEREST_ARCH make menuconfig`

Once the kernel is configured, compile it:

`(chroot)# make && make modules install`

Option 2: Distribution kernel

For those who do not wish to configure a custom kernel, or likewise do not have the time or system resources to do so, a distribution kernel provides a binary kernel. However, there are a couple of pitfalls to this option:

1. Distribution kernels are not fine tuned to your system, they are generic and bloated
2. Distribution kernels are managed by their respective development teams, who must be relied upon for fixes
3. Distribution kernels deprive the user of the experience gained by configuring and compiling a custom kernel

Everest offers many distribution kernels, some notable ones include:

1. linux-everest
2. linux-zen
3. linux-hardened

Install a distribution kernel:

`(chroot)# gpkg -f world/linux-{everest,zen,hardened}`

## Build an initramfs

Depending on your system, an initramfs may be required. For example, users of distribution kernels will ALWAYS need to build an initramfs, while those who configured and compiled their own will usually not need one.

To build an initramfs, you will need dracut. Install dracut:

`(chroot)# gpkg -f world/dracut`

Build an initramfs:

`(chroot)# dracut`

## Configure the system

Now that the kernel is installed, various other parts of the system should be configured.

Create /etc/fstab, which provides the system with information about mounted filesystems.

For example, on a system with a root, /usr, and boot partition, /etc/fstab will look like this:

<fhead>FILE: /etc/fstab</fhead>

/dev/sda1 / ext4 noatime 0 1

/dev/sda2 /usr ext4 noatime 0 1

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

System services that some may find helpful, such as a cron daemon or logging daemon, should be set up now.

On systems using systemd:

`(chroot)# systemctl enable cronie chronyd sysklogd`

On systems without a service manager, all services under /etc/init.d will be initialied by rcS.

The system's timezone is read from /etc/localtime, which is a symlink.

In case timezone information is missing from /usr/share/zoneinfo, install it:

`(chroot)# gpkg -f world/tzdata`

Create /etc/localtime:

`(chroot)# ln -sv /usr/share/zoneinfo/Region/City /etc/localtime`

The hostname assigns a name to the system. This can be changed at any time.

Set the hostname:

`(chroot)# echo hostname > /etc/hostname`

Or, on systemd:

`(chroot)# hostnamectl hostname hostname`

A network connection is very important, and there are multiple ways to set one up.

<warnhead>WARNING:</warnhead>

Ensure your network is fully set up before proceeding with any other steps. It's better to get it right the first time, rather than trying to fix it later.

First, ensure the desired network interface is not blocked by rfkill:

`(chroot)# rfkill`

If the network interface is blocked:

`(chroot)# rfkill unblock interface`

The network can now be configured.

Option 1: Busybox networking

Busybox includes networking tools that can quickly configure the network.

On a busybox system, the network can be set up with one simple command:

`(chroot)# ifup`

rcS will also run this command at boot time.

Option 2: dhcpcd and wpa_supplicant

On systems without Busybox, dhcpcd can be used. This is another very simple solution.

Install dhcpcd:

`(chroot)# gpkg -f world/dhcpcd`

Install wpa_supplicant:

`(chroot)# gpkg -f world/wpa_supplicant`

rcS will start dhcpcd at boot time.

Option 3: NetworkManager

NetworkManager is recommended on systems using systemd as the init system.

NetworkManager should be fairly easy and straightforward to set up for most.

Install NetworkManager:

`(chroot)# gpkg -f world/networkmanager`

Enable and start NetworkManager:

`(chroot)# systemctl enable --now NetworkManager`

The /etc/hosts file is used to resolve IP addresses not resolved by the DHCP server.

<fhead>FILE: /etc/hosts</fhead>

127.0.0.1 localhost

::1 localhost

127.0.1.1 localdomain hostname

The root password is extremely important, as it controls access to the root user, the most powerful user on the system.

Ensure your chosen root password is strong enough where it cannot be guessed easily.

Set the root password:

`(chroot)# passwd`

If remote access is desired on the system, install sshd:

`(chroot)# gpkg -f world/sshd`

Using the root account for daily use is not recommended. Create an unprivileged user:

`(chroot)# adduser USERNAME`

A privilege elevation program is recommended for most users. The most popular choices are sudo and doas, with doas being recommended for most users.

Install doas:

`(chroot)# gpkg -f world/doas`

Create /etc/doas.conf:

<fhead>FILE: /etc/doas.conf</fhead>

permit USER as root

## Configure the bootloader

Now that the system is correctly configured and the kernel is installed, the final step can proceed - installing the bootloader. Without a bootloader, the system will be unable to load the Linux kernel upon boot.

This guide only mentions GRUB, however note that other bootloaders are supported.

Merge GRUB for BIOS:

`(chroot)# gpkg -f world/grub-bios`

Merge GRUB for UEFI:

`(chroot)# gpkg -f world/grub-efi`

Install GRUB for BIOS:

`(chroot)# grub-install /dev/sda`

Install GRUB for UEFI:

`(chroot)# grub-install --target=x86_64-efi --efi-directory=/boot`

For GRUB to work correctly, a configuration file must be created. Create one now:

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

## Exit chroot

The system has been finished. If everything is done to your liking, you can now exit the chroot environment.

`(chroot)# exit`

Unmount all mounted partitions:

`(root)# umount -l /mnt/everest/dev/{shm,pts}`

`(root)# umount -R /mnt/everest`

Reboot the system:

`(root)# reboot`

Ensure the installation medium is removed, or else you will not boot into the new system, rather back into the installation medium.

## Conclusion

If all went well, Everest should boot up with no problems.

Remove the system image from /:

`(root)# rm /everestlinux-*.tar.*`

With the installation out of the way, you now have a minimal Linux environment to play around in, and to build around.

Many things still need to be set up and configured.

<wiki>See: General Recommendations</wiki>

If you require assistance, reach out to the community on Discord (HJzJUwSmDf) or IRC (#everestlinux on libera.chat)