# Everest Linux - Installation Handbook

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

# Installation Handbook

This guide goes into detail on how to install Everest.

## Prerequisites

There are 2 officially supported ways of installing Everest, systemd/glibc/GNU or sysv/musl/busybox. This guide covers the musl/busybox installation as it recieves the most support and is the intended way. For the GNU installation, it may be a good idea to read the Linux from Scratch wiki.

For highly customized installations (such as a custom init), it is recommended to know exactly what you're doing.

Everest may be installed through 2 methods:

- ISO: can be flashed to a usb and booted

- rootfs tarball (RECOMMENDED): unpacked to a directory (usually /mnt) and instaled through an existing distribution.

Note that no matter what option you choose, you will need the rootfs tarball.

If you wish to install Everest Hike instead of Everest Summit, you can run `setup-everest`.

Commands prefixed with `$` should be run as the normal user.

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

Commands prefixed with `(chroot)$` should be run as the normal user inside the chroot environment.

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

This guide assumes your system has access to the internet. There are no tools for configuring the network in the iso. Use of a hardwired ethernet connection is recommended.

## First Steps

### Prepare the disk

Create a disk partition for your root filesystem, a boot partition, and any other partitions you may want to make.

Create valid filesystems on the partitions (FAT32 for boot, and Ext4/Btrfs/XFS/ZFS on root).

`# mkfs.vfat -F32 /dev/boot`

`# mkfs.ext4 /dev/root`

Mount the newly created root partition to /mnt/everest.

`# mkdir /mnt/everest`

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

### Create the EV variable

Create the "EV" variable, which will save some typing down the road.

`# export EV=/mnt/everest`

Ensure the variable was created correctly. It will be very important to check this multiple times during installation.

`# echo $EV`

## Unpacking Tarball

### Download the rootfs tarball

To install Everest, you will need the rootfs tarball containing the necessary toolchain.

`# wget https://github.com/everest-linux/everest/releases/download/vX.X.X-systemd-rc/everestlinux-summit-X.X.X-systemd-rc.tar.xz`

### Unpack the rootfs tarball

To unpack the tarball:

`# tar xpvf everestlinux-summit-X.X.X-systemd.tar.xz --xattrs-include='*.*' --numeric-owner`

The tarball must be unpacked with the command above. Using only `tar xpvf` will not retain ownership and some binaries will refuse to execute.

### Enter the chroot environemnt

Enter the chroot environment. This will allow you to install system packages.

`# chroot "$EV" /usr/bin/env -i \`

`HOME=/root \`

`TERM="$TERM" \`

`PS1='[everest-chroot] \u:\w \$ ' \`

`PATH=/usr/bin:/usr/sbin \`

`/bin/bash --login`

## Building the System

Now that we are inside the chroot environment, we can install packages to the system.

### Configure the Glacier build environment

Before we start, creating `/etc/make.conf` is recommended. This is so you can specify extra makeflags, most notably, the `-jX` flag will allow `make` to utilize more than 1 core.

`# /etc/make.conf`

`MAKEFLAGS=-jX`

### Symbolism

The following symbols will be used to describe packages

-(!) Vital system package, do not omit.

-(S) Source package

-(B) Binary package

-(L) Long installation time

### Install system packages

(!) (B) Glacier

This package contains the Glacier package manager, which manages installed packages on the system. It uses wget and tar as its backens, both of which are included in the tarball.

To install Glacier:`(chroot)# rm -rf /tmp/glacier && cd /tmp && git clone https://git.everestlinux.org/EverestLinux/glacier && cd glacier/install && chmod +x INSTALL-GLACIER.sh && sudo ./INSTALL-GLACIER.sh || doas ./INSTALL-GLACIER.sh`

Note that Glacier cannot manage itself, so you will need to update every month or so.

(S) Man-pages

This package contains 2,000+ manpages for the system.

To install man-pages:

`(chroot)# glacier -f`

`[ ? ] man-pages`

(!) (B) Iana-Etc

This package contains vital networking protocols.

To install Iana-Etc:

`(chroot)# glacier -f`

`[ ? ] iana-etc`

(!) (S) libgcc

This package contains libraries for GCC.

To install libgcc:

`(chroot)# glacier -f`

`[ ? ] libgcc`

(!) (S) (L) musl

This package contains the musl standard C library.

To install musl:

`(chroot)# glacier -f`

`[ ? ] musl`

(!) (S) busybox

This package contains common UNIX utilities in a single binary.

To install busybox:

`(chroot)# glacier -f`

`[ ? ] busybox`

(!) (S) (L) vim

This package contains the Vim text editor.

To install vim:

`(chroot)# glacier -f`

`[ ? ] vim`

(!) (S) (L) Linux

This package contains the Linux kernel

You will need to cache this package if you wish to build a custom kernel. Prebuilt kernels are available under the names 'linux', 'linux-zen', 'linux-lts', etc. For a custom configuration, the package is called 'linux-custom'.

To install a prebuilt kernel:

`(chroot)# glacier -f`

`[ ? ] linux-{zen,lts,hardened,rt}`

To install and configure a custom kernel:

`(chroot)# glacier -c`

`[ ? ] linux-custom`

Change directory into the Glacier cache and move the package to /tmp

`(chroot)# cd /var/cache/glacier && mv linux-custom.tar.gz /tmp`

Unpack the package

`(chroot)# tar xpvf linux-custom.tar.gz`

Ensure the kernel's source tree is clean

`(chroot)# make mrproper`

Make desired configurations to the kernel

`(chroot)# make menuconfig`

If using systemd as the init system, 'The IPv6 protocol [CONFIG_IPV6] is highly recommended.

`Networking support --->`

`Networking options --->`

`<*> The IPv6 protocol [CONFIG_IPV6]`

See this page from Linux From Scratch on other recommended kernel customizations.

Compile the kernel

`(chroot)# make`

If you enabled support for modules, compile them

`(chroot)# make modules_install`

If you intend on dual booting and are using an external boot partition, run the following command from OUTSIDE THE CHROOT ENVIRONMENT

`# mount --bind /boot /mnt/ev/boot`

Change the kernel image

`(chroot)# cp -iv arch/x86/boot/bzImage /boot/vmlinuz-X.XX.X`

Install the system map file

`(chroot)# cp -iv System.map /boot/System.map-X.XX.X`

Save your kernel's configuration

`(chroot)# cp -iv .config/boot/config-X.XX.X`

Install kernel documentation

`(chroot)# install -d /usr/share/doc/linux-X.XX.X`

`(chroot)# cp -r Documentation/* /usr/share/doc/linux-X.XX.X`

If you wish to retain the kernel's source tree

`(chroot)# chown -R 0:0 /path/to/linux-X.XX.X`

Warning: Some documentation for the kernel recommends symlinking /usr/src/linux to the kernel source tree, however this is specific to 2.6 series kernels and MUST NOT BE CREATED as it can cause conflics with Glacier.

Warning: The headers in /usr/include should ALWAYS be the ones against which your standard C library was compiled. They should NEVER be replaced by either the raw kernel headers or the sanitized headers of any other kernel.

Move the kernel source tree into `/usr/src/linux` for easy access later on.

Create /etc/modprobe.d/usb.conf, which will ensure USB modules are started in the correct order

`install -v -m755 -d /etc/modprobe.d`

`cat > /etc/modprobe.d/usb.conf`

`# Begin /etc/modprobe.d/usb.conf << "EOF"`

``

`install ohci_hcd /sbin/modprobe ehci_hcd ; /sbin/modprobe -i ohci_hcd ; true`

`install uhci_hcd /sbin/modprobe ehci_hcd ; /sbin/modprobe -i uhci_hcd ; true`

``

`# End /etc/modprobe.d/usb.conf`

`EOF`

## Configuring the System

Now we must configure the system so it will boot correctly

### Install optional administration tools

As a recommendation for easy access to the root account, installing `sudo` or `doas` is highly recommended, as it will remove the need to log in as root with `su` and will only require invoking `sudo` or `doas`.

In the case of `sudo`, the following line will need to be uncommented from `/etc/sudoers`

`%wheel ALL=(ALL) ALL`

In the case of `doas`, `/etc/doas.conf` will need to be created, containing the following:

`permit :wheel`

### Configure the network

Install NetworkManager

`(chroot)# glacier -f`

`[ ? ] networkmanager`

Set the default network interface up

`(chroot)# ip link`

`(chroot)# ip link set interface_name up`

If using systemd, enable the service

`(chroot)# systemctl enable NetworkManager`

You will be unable to start the service from inside the chroot environment.

Create `/etc/hostname` and enter the desired hostname for the system

Create `/etc/hosts` and enter the following

`127.0.0.1 localhost`

`::1 localhost`

`127.0.1.1 localdomain hostname`

### Install a bootloader

Install a bootloader capable of loading a Linux system (such as `grub`)

In the case of `grub`, install `os-prober` and `efibootmgr` (for UEFI systems), then install either `grub-bios`, `grub-uefi`, `lib32-grub-bios`, or `lib32-grub-uefi`, then run the following commands to install:``

Warning: Highly customized configurations may cause the bootloader to break. It is recommended to edit `/etc/make.conf` before building this package.

`(chroot)# grub-install /dev/sdX (BIOS/MBR)`

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

Create the GRUB configuration file

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

### Power off the system

Exit the chroot environment

`(chroot)# exit`

Unmount all drives

`# umount -R /mnt/everest`

Power off the system

`# poweroff`

## The End

Power on the system. If all went well, the GRUB boot screen should appear, followed by a shell prompt.

If using systemd, start NetworkManager and connect to a network

`# systemctl start NetworkManager`

`# nmtui`

Congratgulations! Everest has successfully been installed.

Most users will want to configure sound, a graphical environment, or multiple users. See post installation recommendations for details.