L'objectif de ce tutoriel est de construire un operating system avec les paquets préparés par la TOOLBOX et en utilisant OStree comme support de déploiement

OSTree est un système de gestion des versions des mises à jour des systèmes d'exploitation Linux. Il peut être considéré comme “Git pour les binaires du système d'exploitation”. Il fonctionne dans l'espace utilisateur et fonctionnera sur n'importe quel système de fichiers Linux.

Dans ce tutoriel l'approche consiste à stocker les composants dans des commits individuels dans un référentiel séparé, puis à les associer et à recréer un commit global.

Un système minimal recquiert essentiellement les paquets suivants (220 Mo):

• linux: le noyau linux
• glibc: la plupart des programmes qui tournent sous Linux utilisent des fonctions issues de la bibliotheque standard C GNU, glibc
• Ncurses: contient les bibliothèques de gestion des écrans type caractère, indépendant des terminaux.
• BusyBox: contient les versions réduites d'utilitaires UNIX courants compilés en un seul petit exécutable, ce qui fait de BusyBox une base idéale pour les systèmes à ressources limitées.
• Gawk: contient des programmes de manipulation de fichiers texte.
• DropBear: est un petit serveur et client SSH et est utile pour permettre l'accès shell distant à votre système.
• getty et login: (fournis par Busybox ou les programmes agetty et login fournis par le paquet util-linux) dont on a besoin pour pouvoir se connecter et obtenir l'invite de commande de bash
• stty: (fournit par Busybox ou CoreUtils) est utilisé dans /etc/init.d/rc, lui-même utilisé pour changer de niveau d'exécution et entrer dans le niveau initial

Cependant le système déployé dans ce tutoriel inclus beaucoup plus de paquets (1,3 Go):

1. Le noyau,la bibliothèque glib et les utilitaires de bases
2. les paquets de la LSB
3. systemd et ses dépendances
4. des utilitaires des systèmes de fichiers
5. des utilitaires de réseau
6. des utilitaires de compression
7. des utilitaires de partage réseau (curl, wget, git, rsync)
8. des languages de programmation (python, perl, java)

La Linux Standard Base (LSB) est un projet joint par nombre de distributions Linux sous la structure organisationnelle du Free Standards Group afin de concevoir et standardiser la structure interne des systèmes d'exploitation basés sur GNU/Linux.

Les paquets suivants sont requis pour satisfaire les exigences LSB:

systemd recquiert l'installation des paquets suivant :

Le démarrage d'un système Linux se fait en 6 étapes. Donc, avant que la fenêtre d'identification apparaisse, 6 processus s'exécute à tour de rôle:

• 1ère étape : le BIOS. BIOS = Basic Input/Output system : système élémentaire d'entrée/sortie. …
• 2e étape : la MBR. MBR = Master Boot Record : la zone amorce. …
• 3e étape : le programme d'amorçage ou bootloader. …
• 4e étape : le noyau. …
• 5e étape : init. …
• 6e étape : Runlevel.

Le noyau Linux chargé à l'étape 4 est de conception modulaire. On peut concevoir un noyau résident minimal qui sera chargé dans la mémoire. Par la suite, chaque fois qu'un utilisateur demande une fonction qui n'est pas présente dans le noyau résident, un module de noyau, parfois également appelé périphérique, devra être chargé en mémoire.

Cette manière de concevoir le noyau, nécessite d'utiliser un initramfs afin de pouvoir charger les modules nécessaires (essentiellement les drivers disques). Si un initramfs est utilisé, le processus de démarrage est plus long, même significativement plus long.

Lorsqu'on ne souhaite pas utiliser d'initramfs, il est nécessaire de compiler le noyau avec tous les drivers (modules) nécessaires compilés dans la partie résidente.

L'un des driver absolument indispensable pour pouvoir démarrer un distribution GNU/Linux est le driver de disque dur.

• Récupérer l'abre complet du périphérique cible (dans l'exmple /dev/sdb)

ls -l /sys/block/sdb

lrwxrwxrwx. 1 root root 0  1 déc.  08:23 /sys/block/sdb -> ../devices/pci0000:00/0000:00:1c.0/0000:01:00.0/host
4/target4:1:3/4:1:3:0/block/sdb

• Descendre dans l'arbre pour repérer une ligne identifiant le driver de bas niveau.

Par exemple le lien sous 4:1:3:0 n'identifie pas un driver bas niveau, mais le driver générique sd:

ls -l /sys/devices/pci0000:00/0000:00:1c.0/0000:01:00.0/host
4/target4:1:3/4:1:3:0

lrwxrwxrwx    1 root     root             0 Jul  2 10:14 driver -> ../../../../bus/scsi/drivers/sd

Alors que le lien sous 0000:01:00.0 identifie le driver de bas niveau MPTSAS

ls -l /sys/devices/pci0000:00/0000:00:1c.0/0000:01:00.0

lrwxrwxrwx.  1 root root       0  1 déc.  08:23 driver -> ../../../../bus/pci/drivers/mptsas

• activer le driver ainsi relevé en kernel et non en module:

Afin que l'on puisse accéder aux disques gérés par ce driver lors du démarrage,

  [*] Fusion MPT device support  --->
    <*>   Fusion MPT ScsiHost drivers for SAS 

L'OS doit intégrer les ressources physiques, par exemple le serveur de dev dispose de 2 disques physiques sda et sdb:

• le premier disque est réservé aux déploiements des distributions GNU/Linux construites à partir de l'environnement de compilation
• l'environnement de compilation a été déployé sur l'unique partition du deuxième disque /dev/sdb1

  Pour passer dans l'environnement de compilation il suffit de monter le deuxième disque, puis de chrooter dans celui-ci:

mount -o subvol=home /dev/sdb1 /mnt
cd /mnt/lfs/lfs
mount --bind /dev dev
mount --bind /proc proc
mount --bind /sys sys
chroot . /tools/bin/env -i \
    HOME=/root                  \
    TERM="$TERM"                \
    PS1='(lfs chroot) \u:\w\$ ' \
    PATH=/bin:/usr/bin:/sbin:/usr/sbin:/tools/bin \
    /tools/bin/bash --login +h

• addresse IPV4 : xx.xx.xxx.xxx
• gateway : xx.xx.xxx.x

le fichier /etc/resolv.conf doit avoir le contenu suivant:

# Début de /etc/resolv.conf

nameserver 10.154.59.104
nameserver 10.156.32.33

# Fin de /etc/resolv.conf

La construction d'un système de fichier avec OSTree repose essentiellement sur tois étapes

1. Etape 1: la construction d'un référenteil de paquets
2. Etape 2: la préparation du système de fichier sur lequel seront déployés les paquets
3. Etape 3: la construction de l'abre final par le déploiement des paquets dans le système de fichiers:

On va construire référentiel nu dans lequel on exporte le contenu des archives dans des branches séparées, puis un système de fichier dans le répertoire /lfsos-build

• (1) création d'un dépôt nu (/build-repo) –mode=bare-user
• (2) commit des paquets en tant que branches individuelles
• (3) ostree checkout -U –union: confection d'un système de fichie par l'union des paquets individuels

TIMEFORMAT='(BUSYBOX) Construction du tree en %R seconds ...'
time { 
rm -Rf ${LFS}/build-repo &&
ostree --repo=${LFS}/build-repo init --mode=bare-user &&
mkdir -pv ${LFS}/build-repo  &&
pkglist=""
for pkg in $(echo -e "linux\nglibc\nbusybox-hl\ndropbear\nkexec-tools\nkbd\nrootfs\nat\nbash\nreadline\nbc\nbinutils\ncoreutils\ncpio\ndiffutils\nvim\nfile\nfindutils\ngawk\ngrep\ngzip\nm4\nman-db\nncurses\nnspr\nnss\nLinux-PAM\npax\nprocps-ng\npsmisc\nsed\nsendmail\nclient-openldap\nopenssl\ncyrus-sasl\nshadow\ntar\ntime\nutil-linux\nzlib\nsystemd\ndbus\nexpat\nlibcap\ntcp_wrappers\nlibnsl\nrpcsvc-proto\nlibtirpc\nacl\nkmod\nlibgcrypt\nlibgpg-error\niptables\nlz4\nxz\nattr\ndosfstools\nxfsprogs\nzfs\nelfutils\nbtrfs-progs\nnfs-utils\nlibostree\ngpgme\nlibassuan\nglib-2\nlibxml2\nLVM2\nsquashfs\niproute2\nbridge-utils\nopenvswitch\nlzo\nzstd\nbzip2\nlibarchive\nwget\nrsync\npopt\ngit\ncurl-nss\nPython-3\nopenjdk-8\nperl"); do pkglist="${pkglist}$(git ls-remote --heads --tags http://user:password@xx.xx.xxx.xxx:/jacques/pkg.git | grep -E "refs/tags/$pkg"|awk '{print $NF ; exit}'| cut -d '/' -f3)\\n" ; done
echo -e "$pkglist" > lfsos-pkg-list &&
rm -rf ${LFS}/lfsos-build &&
mkdir ${LFS}/lfsos-build &&
cd ${LFS}/lfsos-build &&
mkdir -pv ./{bin,boot,etc/{opt,sysconfig},home,lib/firmware,mnt,opt} &&
mkdir -pv ./{media/{floppy,cdrom},sbin,srv,var} &&
install -dv -m 0750 ./root &&
install -dv -m 1777 ./tmp ./var/tmp &&
mkdir -pv ./usr/{,local/}{bin,include,lib,sbin,src} &&
mkdir -pv ./usr/{,local/}share/{color,dict,doc,info,locale,man} &&
mkdir -v  ./usr/{,local/}share/{misc,terminfo,zoneinfo} &&
mkdir -v  ./usr/libexec &&
mkdir -pv ./usr/{,local/}share/man/man{1..8} &&
mkdir -v  ./usr/lib/pkgconfig &&
mkdir -v ./var/{log,mail,spool} &&
mkdir -pv ./var/{opt,cache,lib/{color,misc,locate},local} &&
touch ./var/log/{btmp,lastlog,wtmp} &&
chgrp -v utmp ./var/log/lastlog &&
chmod -v 664  ./var/log/lastlog &&
chmod -v 600  ./var/log/btmp &&
cd "${LFS}/" &&
for package in `cat lfsos-pkg-list`; do
ostree --repo=${LFS}/build-repo commit -b lfsos/x86_64/${package} --tree=tar=${LFS}/pkg/${package}.tar.gz;
done &&
for package in `cat lfsos-pkg-list`; do
ostree --repo=${LFS}/build-repo checkout -U --union lfsos/x86_64/${package} lfsos-build;
done &&
cd /lfsos-build &&
if [ -d ./var/run ]; then
  # Take action if $DIR exists. #
  for DIR in `find ./var/run -mindepth 1 -type d`
  do
    #Do whatever you need with DIR
    install -d ./run/$(echo ${DIR} |sed 's|.*/||')
  done
  rm -rf ./var/run
fi &&
ln -sv /run ./var/run &&
ln -sv /run/lock ./var/lock &&
for file in $(ls ./etc/systemd/network/10-eth*-static*); do vim -c 'set title titlestring=...'$file'' $file; done &&
vim -c 'set title titlestring=.../etc/resolv.conf' ./etc/resolv.conf &&
# Changement du mot de passe dans /etc/shadow
sed -i '/^'root'/s/\([^:]*\):[^:]*:\(.*\)/\1:'"$(echo 'password' |openssl passwd -1 -stdin | cut -d" " -f1)"':\2/' ./etc/shadow
# Mise en place d'un point de montage "rofiles-fuse"; cela garantit que tous les processus
# exécutés pour le post-traitement de l'arbre ne corrompent pas les liens physiques.
install -d  ${LFS}/lfsos-mnt &&
if [ ! -c "/dev/fuse" ]; then mknod /dev/fuse -m 0666 c 10 229 ; fi &&
rofiles-fuse ${LFS}/lfsos-build ${LFS}/lfsos-mnt &&
cd ${LFS}/lfsos-mnt &&
ldconfig -r ${LFS}/lfsos-mnt &&
cd "${LFS}/"  &&
fusermount -u /lfsos-mnt
cd ${LFS}/lfsos-build &&
find . -print | cpio -o -H newc | gzip -9 > /pkg/lfsos-0.0.1.tar.gz
}

mount /dev/sda2 /mnt
cd /mnt
btrfs subvolume create root
cd /
umount /mnt
mount -o subvol=root /dev/sda2 /mnt
rsync -rav /lfsos-build/ /mnt

• (4) ostree admin init-fs Initialise un système de fichiers racine physique vide dans le CHEMIN désigné, avec des niveaux supérieurs normaux et des autorisations correctes pour chaque répertoire. Principalement utile pour les installateurs de systèmes d'exploitation.
• (5) ostree admin os-init OSNAME Initialise un nouvel état pour un système d'exploitation. Garantit que les sous-répertoires principaux de /var (/tmp, /lib, /run et /lock) existent et initialisent le OSNAME donné en tant que racine OSTree. Chaque emplacement de déploiement est composé d'une seule var partagée et d'un ensemble de déploiements (chroots).

Lorsqu'on déploie un os, OSTree vérouille le répertoire dans lequel l'os est déployé. Pour cette raison l'utilisation des outils classiques (rm, mkdir) à l'intérieur d'un tree peut être la source de disfonctionnement voire perturber le file système sous jacent (impossibilité de détruire un dossier). Pour cette raison on utilisera un disque virtuel. Comme cela implique de travailler dans un jail chrooté, le déploiement automatisé de GRUB échourea lors de l'exécution de grub-probe, il faut donc remplacer le version binaire de cet utilitaire par un faux exécutable dont l'unique fonction est de répondre positivement:

if [[ $(file /sbin/grub-probe ) =~ 'text' ]]; then 
  exit;
else
  echo "faker script for grub-probe"
mv /sbin/grub-probe /sbin/grub-probe.orig &&
cat > /sbin/grub-probe << "EOF"
#!/bin/bash
#
# A faker script for grub-probe, if your's stops working properly
#

# Depends on /root/grub.hack file

# . /root/grub.hach

arg_is_device=0
target=""

# Call Order:
# / --target=device
# --target=fs_uuid /dev/sda1 --device
# /boot --target=device
# --target=fs_uuid /boot --device
# "/" "--target=fs"
# "--target=abstraction" "ext2" "--device"
# "--target=fs" "ext2" "--device"
# "--target=drive" "ext2" "--device"
# "--target=fs_uuid" "ext2" "--device"
# "--target=abstraction" "ext2" "--device"
# "--target=fs" "ext2" "--device"
# "--target=drive" "ext2" "--device"
# "--target=fs_uuid" "ext2" "--device"
# "/" "--target=device"
# "--target=fs_uuid" "ext2" "--device"
# "/boot" "--target=device"
# "--target=fs_uuid" "ext2" "--device"
# "/" "--target=fs"
# "--target=abstraction" "ext2" "--device"
# "--target=fs" "ext2" "--device"
# "--target=drive" "ext2" "--device"
# "--target=fs_uuid" "ext2" "--device"
# "--target=abstraction" "ext2" "--device"
# "--target=fs" "ext2" "--device"
# "--target=drive" "ext2" "--device"
# "--target=fs_uuid" "ext2" "--device"

for opt in $@
do
    case "${opt}" in
    --device)
        # Means the thing in $arg is a device
        arg_is_device=1
        ;;
    --target=*)
        # = device, = fs, = fs_uuid
        target=${opt#*=}
        ;;
    *)
        arg=$opt
        ;;
    esac
done

set >> /tmp/probe.env

case "$target" in
abstraction)
    echo
    ;;
device)
    echo "/dev/sda1"
    ;;
drive)
    echo "(hd0)"
    ;;
fs)
    # Returns the filesystem type
    echo "ext2"
    ;;
fs_uuid)
    tune2fs -l $arg | awk '/Filesystem UUID/ { print $3 }'
    ;;
esac
EOF

chmod 0755 /sbin/grub-probe
fi

TIMEFORMAT='(BUSYBOX) Deploiement image OSTree en %R seconds ...'
time {
qemu-img create -f qcow2 lfsos001.qcow2 8G &&
qemu-nbd -v -c /dev/nbd0 lfsos001.qcow2  &&
mv -v /lfsos-build/etc/* /lfsos-build/usr/etc
parted --script /dev/nbd0 \
    mklabel gpt \
    mkpart primary 1MiB 100% \
    set 1 esp on
mkfs.ext4 /dev/nbd0p1
mkdir -pv /tmp/lfsos001
mount /dev/nbd0p1 /tmp/lfsos001
cd /tmp/lfsos001
for rep in $(echo -e "bin\ndev\nlib\nlib64\nproc\nusr\nsbin\nsys\nlfsos-build\nbuild-repo"); do
  mkdir -pv $rep
  mount --bind /$rep ./$rep
done
chroot .
ostree admin init-fs .
ostree admin os-init lfsos
}

• (6) ostree commit standard: créer un nouveau commit global dans la branche lfsos/x86_64/standard.
• (7) ostree pull-local: Copie les données d'un référentiel donné (dans le répertoire repo)
• (8) ostree admin deploy: met le nouveau déploiement par défaut au redémarrage.

TIMEFORMAT='(BUSYBOX) Deploiement image OSTree en %R seconds ...'
time {
checksum=$(ostree --repo=${LFS}/build-repo commit -b lfsos/x86_64/standard --link-checkout-speedup /lfsos-build) &&
ostree --repo=ostree/repo pull-local /build-repo lfsos/x86_64/standard &&
ostree admin deploy --os=lfsos --karg-proc-cmdline --karg=enforcing=0 lfsos/x86_64/standard &&
exit
for rep in $(echo -e "bin\ndev\nlib\nlib64\nproc\nusr\nsbin\nsys\nlfsos-build\nbuild-repo"); do
  umount ./$rep
done
rm -rf /ost-lfsos-9.0.gz 
find . -print | cpio -o -H newc | gzip -9 > /ost-lfsos-9.0.gz &&
cd "${LFS}/"
}

if [[ $(file /sbin/grub-probe ) =~ 'text' ]]; then
  echo "restauration grub-probe"
  mv /sbin/grub-probe.orig /sbin/grub-probe
fi

Au démarrage du système :

1. soit le micrologiciel BIOS charge les 512 premiers octets de ce disque, ces 512 octets constituant le MBR (master boot record ou zone d'amorçage) ou lorsque le disque de boot a plusieurs partitions, le micrologiciel BIOS lit le MBR du disque, puis le VBR de la partition (Volume Boot Record). À partir de ces informations, il peut déterminer l'emplacement du chargeur d'amorçage et le lancer.
2. soit le micrologiciel UEFI (et non pas le BIOS) est utilisé pour lancer le chargeur d'amorçage : l'UEFI lit la GPT du disque (GUID Partition Table) pour déterminer l'emplacement de la routine d'amorçage.

Pour créer une table de partition GPT

parted --script /dev/sdb \
    mklabel gpt \
    mkpart primary 1MiB 261MiB \
    mkpart primary 261MiB 100% \
    set 1 esp on

Pour créer une table de partition MBR

parted --script /dev/sdb \
    mklabel msdos \
    mkpart primary 1MiB 261MiB \
    mkpart primary 261MiB 100% \
    set 1 esp on

blkid -s UUID -o value /dev/sdb2 2041109a-0a94-4683-94b2-0ef2e6c45a2c

La partition qui héberge le bootloader (BOOT ou ESP) doit être formatée en FAT32

mkfs.fat -F 32 /dev/sdb1

La partition qui va recevoir le système de fichier de la distribution doit être formatée dans l'une des formats gérés par le Noyau.

mkfs.btrfs /dev/sdb2

cd /mnt
mv usr/etc .
cat > etc/fstab << "EOF"
# Begin /etc/fstab

# file system  mount-point  type     options             dump  fsck
#                                                              order

/dev/sda2      /            btrfs    subvol=/root,defaults,noatime   1     1
proc           /proc        proc     nosuid,noexec,nodev 0     0
sysfs          /sys         sysfs    nosuid,noexec,nodev 0     0
devpts         /dev/pts     devpts   gid=5,mode=620      0     0
tmpfs          /run         tmpfs    defaults            0     0
devtmpfs       /dev         devtmpfs mode=0755,nosuid    0     0

# End /etc/fstab
EOF

Le noyau linux, le fichier System.map ainsi que la sauvegarde du fichier config utilisé pour compiler le noyau doivent être déposés à la racine de la partition ESP

mount /dev/sdb1 /boot/efi
cp -a ls /src/linux-5.4.8/_pkg/boot/* /boot/efi

Pour installer le gestionnaire de démarrage EFI, il faut s'assurer d'abord que le système a démarré en mode UEFI et que les variables UEFI sont accessibles. Cela peut être vérifié en exécutant la commande efivar --list ou, si efivar n'est pas installé, en faisant ls /sys/firmware/efi/efivars (si le répertoire existe, le système est démarré en mode UEFI).

rEFInd Boot Manager graphique, fork actif de rEFIt

Pour Installer rEFInd, il faut de monter la partition dédiée sur /boot/efi, télécharger le binaire refind-install puis l'exécuter:

mount /dev/sdb1 /boot/efi
mkdir /boot/efi/EFI
cd /download/refind-bin-0.11.5/
./refind-install
ShimSource is none
Installing rEFInd on Linux....
ESP was found at /boot/efi using vfat
Copied rEFInd binary files

Copying sample configuration file as refind.conf; edit this file to configure
rEFInd.

Could not parse device path: Invalid argument
Could not parse device path: Invalid argument
Creating new NVRAM entry
rEFInd is set as the default boot manager.
Existing //boot/refind_linux.conf found; not overwriting.
exit

Commme dans l'exemple il sera peut-être nécessaire de forcer l'insertion d'une entrée de démarrage avec efibootmgr.

efibootmgr -v -c -d /dev/sdb -p 1 -l \\EFI\\refind\\refind_x64.efi -L rEFInd

BootCurrent: 0008
Timeout: 10 seconds
BootOrder: 000E,0000,0001,0002,0003,0008,000C,0004,0005,0006,0007,0009,000A,000B,000D
Boot0000* CD/DVD Rom	ACPI(a0341d0,0)PCI(1f,2)ATAPI(0,0,0)CD-ROM(1,1c8,30f8)
Boot0001* Floppy Disk	Vendor(0c588db8-6af4-11dd-a992-00197d890238,00)
Boot0002* Hard Disk 0	ACPI(a0341d0,0)PCI(1c,0)PCI(0,0)SCSI(3,0)HD(2,103000,5b800,b381ffad-b370-4e67-9bc0-64032de09b5f)File(\EFI\grub\grubx64.efi)
Boot0003* PXE Network	ACPI(a0341d0,0)PCI(1,0)PCI(0,0)MAC(e41f1360e8e4,0)
Boot0004* Hard Disk 1	Vendor(0c588db8-6af4-11dd-a992-00197d890238,09)
Boot0005* Hard Disk 2	Vendor(0c588db8-6af4-11dd-a992-00197d890238,0a)
Boot0006* Hard Disk 3	Vendor(0c588db8-6af4-11dd-a992-00197d890238,0b)
Boot0007* Hard Disk 4	Vendor(0c588db8-6af4-11dd-a992-00197d890238,0e)
Boot0008* USB Storage	ACPI(a0341d0,0)PCI(1a,7)USB(1,0)HD(1,ac,2774,03c37324)
Boot0009* Diagnostics	Vendor(0c588db8-6af4-11dd-a992-00197d890238,da)
Boot000A* iSCSI	Vendor(0c588db8-6af4-11dd-a992-00197d890238,04)
Boot000B* iSCSI Critical	Vendor(0c588db8-6af4-11dd-a992-00197d890238,05)
Boot000C* Legacy Only	Vendor(0c588db8-6af4-11dd-a992-00197d890238,ee)
Boot000D* Embedded Hypervisor	Vendor(0c588db8-6af4-11dd-a992-00197d890238,01)
Boot000E* rEFInd	HD(1,800,82000,a64c020c)File(\EFI\refind\refind_x64.efi)

Pour terminer l'installation, configurer refind.conf.

cat >> /boot/efi/EFI/refind/refind.conf <<EOF
menuentry "LFSos" {
    icon EFI/refind/icons/os_linux.png
    volume 2041109a-0a94-4683-94b2-0ef2e6c45a2c
    loader vmlinuz-4ca3a5f1c599a63b40e1d8ab2a8830f0e35b7908a230749c7a3b7e80253fa655
    options "root=UUID=2041109a-0a94-4683-94b2-0ef2e6c45a2c rw rootflags=subvol=root"
}
EOF

Systemd-boot est un simple gestionnaire de démarrage UEFI qui exécute des images EFI configurées. Il est inclus par défaut dans systemd.

Après avoir monté l'ESP sur /boot/efi, utiliser bootctl pour installer systemd-boot dans la partition système EFI en exécutant:

mount /dev/sdb1 /boot
bootctl install

Cela copiera le chargeur de démarrage systemd-boot sur la partition EFI: sur un système d'architecture x64, les deux fichiers binaires identiques /boot/efi/EFI/systemd/systemd-bootx64.efi et /boot/efi/EFI/BOOT/BOOTX64.EFI seront transférés vers l'ESP . Il définira ensuite systemd-boot comme l'application EFI par défaut (entrée de démarrage par défaut) chargée par le gestionnaire de démarrage EFI.

Commme pour rEFInd il sera peut-être nécessaire de forcer l'insertion d'une entrée de démarrage, en dehors du processus automatisé avec efibootmgr.

efibootmgr -v -c -d /dev/sdb -p 1 -l \\EFI\\systemd\\systemd-bootx64.efi` -L bootctl

Pour terminer l'installation, configurer systemd-boot.

Le fichier /boot/loader/loader.conf doit pointer vers un menu dans le répertoire /boot/loader/entries/

cat > /boot/loader/loader.conf << "EOF" 
#timeout 3
#console-mode keep
#default 262496a661004cb99e9b543ad12c5750-*
default lfsos
timeout 1
editor 0
EOF

Le fichier /boot/loader/entries/xxxxxx.conf est le fichier de boot qui sera exécuté:

cat > /boot/loader/entries/lfsos.conf <<EOF
title   lfsos
linux   /vmlinuz-75666a4cac006bf2ce21e2c0874eca8b9fc0152295a0bf2147f9927ada62bb7c
options root=/dev/sda2 rootflags=subvol=root rw
EOF

A l'issue de la configuration l'arbre de la partition doit ressembler à quelque chose comme ça: