Linux from Scratch with Coaching Wheels

or, “Linux from scratch the usage of digital machines on a Apple Mac M1 notebook computer”

Steps

Working LFS hackers should always serene doubtlessly learn this article in reverse-piece
describe, simply attending to the meat of issues, after which reading the introductory
cloth for added context.

Introduction

Linux from scratch (LFS) is a
step-by-step
tutorial
for constructing your private Linux
distribution. The expend of the LFS intention, you commence with a serious Linux distribution
that you ranking (e.g. Ubuntu) and bootstrap your private customized distribution. Your closing
LFS distribution would possibly presumably maybe maintain nothing from the authentic distribution you began
your bootstrapping from.

LFS is a glorious finding out instrument even while that you would be in a position to maintain been growing on or
administering Linux programs for a very prolonged time. There’s about a roughly magic in
the “finding out by doing” intention – your mind will preserve up a bunch of
subtleties after you maintain a distribution where you, as an illustration, configure
each facet of the boot job. LFS shall be a very simply technique to
learn, in no train describe:

• Kernel hacking – that you would be in a position to maintain created the operating machine across the
  kernel that you attain hacking on, which in a roundabout intention helps you reason about
  customized kernels that you form.

• Custom kernels – for the same reason above, you would possibly presumably maybe safe a deep
  figuring out of why and customize a kernel

• Building Linux software program from provide – yes, all of us know flee “form”
  and “form install” but, believe me, there would possibly be extra to it than that. Whenever you
  must stage-up your recordsdata on safe programs on Linux it is a long way a
  sizable intention.

• How one can safe deplorable-compilers – you would possibly presumably maybe simulate the approach of constructing
  a distribution focusing on an fully contemporary machine. This would possibly presumably maybe include
  bootstrapping the total GNU toolchain (gcc, libc, etc)

LFS the usage of Virtual Machines

Nowadays there could be a stunningly sizable amount of open-provide virtualization instruments
for any operating machine you are operating, which allows you to plan the
steps in the LFS e-book in VMs.

Right here’s a simply element because it allows you to experiment with disk partitioning,
grub and the boot job (including UEFI), and rescuing your unbootable
distribution extra with out concerns than for your main box.

This fashion I am terming “LFS with Coaching Wheels”. Imagine me while you
experiment ample and learn the ideas deeply, as portion of that job you
will conclude up by likelihood erasing disks, including a typo to a serious boot
script, or other natural errors that flip out to be catastrophic. In a
digital atmosphere you are nearly continually ready to safe smartly from any of these.
Studying to safe smartly from them is solely recordsdata that you would possibly presumably maybe be practice in a “genuine”
atmosphere.

LFS on VMs on a Mac M1 (ARM 64 / Cortex)

This weblog post will screen specifics on attain all this on a Mac M1 notebook computer.
Right here’s simply for my consolation, expectantly the total steps right here are easy to
translate to other host machines with the relieve of the Google machine.

Total Design

The intention in which described right here, and or no longer it isn’t the most efficient one which will work, simply
a formula, is to lift the next steps:

• Plug two guest VMs for your computer, one with a serious Linux distribution,
  the second your customized LFS distribution. We can faux that the well-known
  guest operating the well-known Linux distribution is a physical host computer.
  Within the LFS e-book, you would possibly presumably maybe must mentally translate at any time when it talks
  regarding the host as the well-known guest VM. Sure or no longer it is turtles the total intention down.

• The second guest will commence simply as a digital disk image. Mediate of including
  a physical anxious force to your notebook computer/desktop and constructing a bootable Linux
  on that disk. We can put a smooth, unformatted, raw digital disk image
  to the well-known guest VM (our faux host) to commence, and constructed it into a
  working, independently bootable image.

• We can play some games with digital flash recordsdata / drives so that we can
  safely play with grub and UEFI booting. This would possibly presumably maybe include, at key facets,
  restoring a backup file after grub goes loopy formatting our first guest
  vm’s boot partition. There’s slicker recommendations to achieve this, savor making our
  first host vm twin-boot, but, our intention would possibly be easy.

Details

This text augments the LFS e-book. Give the e-book a skim now, then expend the
steps right here.

Accomplish a guest VM the usage of qemu that serves as the “host”.

On a Mac M1, as of this writing (October 2021), this github gist
is the finest manual.

At the conclude of the approach, expectantly after your imprint-contemporary Ubuntu image is
bootable, you would possibly presumably maybe maintain a closing script to flee your host VM:

start_host.sh: (sooner than second force)

qemu-machine-aarch64 
  -machine virt,accel=hvf,highmem=off 
  -cpu cortex-a72 -smp 8 -m 2G 
  -system virtio-gpu-pci 
  -system virtio-keyboard-pci 
  -force "layout=raw,file=edk2-aarch64-code.fd,if=pflash,readonly=on" 
  -force "layout=raw,file=ovmf_vars.fd,if=pflash" 
  -force "layout=qcow2,file=digital-disk.qcow2" 
  -nic hostfwd=tcp: 127.0.0.1: 9922-0.0.0.0: 22 
  -nographic

This script, line by line:

• Begins the ARM64 CPU emulator (this is in a position to presumably maybe very smartly be assorted for you if no longer on a MAC
  1)
• Uses the ARM Cortex A72 instruction effort for the CPU (one more time train to an
  M@), with 8 hyper-threaded cores an 2 gigs of memory
• Involves a gpu system
• Involves a keyboard system
• Involves 2 flash drives to simulate UEFI booting
• Embody a anxious force for the machine
• Permits localhost 9922 to be worn to ssh into the system
• Turns of the screen, so all the issues is displayed in the terminal

Which you can regulate this step to make expend of a assorted roughly virtualization while you
would savor, as an illustration VirtualBox.

Now we add a second smooth force that will change into constructed out to be our LFS
distribution.

qemu-img maintain -f qcow2 digital-lfs-disk.qcow2 30G

Label we are reserving 30G for the force, but this can most efficient lift in home that
is critical.

We add this disk to our start_host.sh script and we are on our intention:

start_host.sh : (now with second force)

qemu-machine-aarch64 
  -machine virt,accel=hvf,highmem=off 
  -cpu cortex-a72 -smp 8 -m 2G 
  -system virtio-gpu-pci 
  -system virtio-keyboard-pci 
  -force "layout=raw,file=edk2-aarch64-code.fd,if=pflash,readonly=on" 
  -force "layout=raw,file=ovmf_vars.fd,if=pflash" 
  -force "layout=qcow2,file=digital-disk.qcow2" 
  -force "layout=qcow2,file=digital-lfs-disk.qcow2" 
  -nic hostfwd=tcp: 127.0.0.1: 9922-0.0.0.0: 22 
  -nographic

At this level you need to always serene be conscious the LFS e-book until you safe to
Chapter 2.4 “Rising a contemporary
partition”

If you attain 2.4 “Rising a contemporary
partion” in the LFS e-book:

Whereas SSH’ed into the VM (host VM) from step 1, as root, flee the “cfdisk”
(curses-basically based mostly fdisk instrument) on /dev/vdb (NOT /dev/vda), savor so:

cfdisk /dev/vdb

Label that irrespective of mistakes you form is no longer going to have an effect on the well-known anxious force
operating your main Linux distribution.

I maintain 3 partitions:

1. An “EFI” machine partition 1M substantial (will finally be /boot/efi)
2. A “Linux Filesystem” partion 200M substantial (will finally be /boot)
3. A “Lunux Filesystem” partition with the rest of the disk (will
   finally be /)

Because the books says, or no longer it is completely as a lot as you the intention you would like to partition the
disk. One single partition over the total disk will work fine for our
capabilities, otherwise you would possibly presumably maybe add a pair of partitions as described in the e-book.

I would uncover experimenting with cfdisk, writing out about a partitions, nuking
them, rewriting a assorted effort, simply fiddling with it until you are
gratified.

At this level the steps in 2.5 and above should always serene work fine.

Capture this step while on Chapter 10.3 Linux-5.13.12, where you maintain a kernel
for your contemporary machine.

Which you can iteratively form quite so a lot of customized kernels after finding success once.
I would uncover doing the minimum amout of customization in the inspiration. Your
intuition would possibly be to form the leanest, meanest kernel attainable but preserve off on
that for future iterations.

Lawful traipse alongside with the defaults from “form menuconfig”, and also add these drivers
to enhance qemu virtualization: (in most cases safe the total main virtio drivers in)

CONFIG_VIRTIO_INPUT=y
CONFIG_VIRTIO_PCI=y
CONFIG_VIRTIO_PCI_LEGACY=y
CONFIG_VIRTIO_CONSOLE=y
CONFIG_DRM_VIRTIO_GPU=m

Supplemental Step 4: Putting in GRUB and UEFI booting safely

Be conscious these steps in the subsequent piece 10.4. The expend of GRUB to Subject Up the Boot Assignment.

Right here’s the trickiest portion. We’re going to:

1. Backup our digital flash drives for the working UEFI booting of our host VM
   (first, non LFS VM)
2. Set up grub for UEFI, destructively wiping out our host flash force
3. Reproduction this contemporary flash for our contemporary LFS VM, and maintain a qemu script to flee our
   LFS machine
4. Swap our backup reproduction from step 1 so that our host VM serene works

Step 1: Reduction up boot flash force:

• Shut down the host VM
• in the checklist with all of our qemu recordsdata:

cp ovmf_vars.fd ovmf_vars.fd.host

• Initiate the host VM

Step 2: Set up grub in UEFI mode

In LFS chapter 10.4, Be conscious the hyperlink to Chapter 5 of the “Previous Linux From Scratch”
to put in UEFI booting the usage of grub. This would possibly presumably maybe overwrite “ovmf_vars.fd” in
our VM, (hence the backup step 1)

Step 3: Develop a reproduction of the flash boot force for LFS machine booting:

• Shut down the host VM
• Within the checklist with all of our qemu file:

cp ovmf_vars.fd ovmf_cars.fd.lfs

You has to be ready to maintain a commence script for your contemporary LFS VM at this
level. Mine appears to be like to be like savor this:

start_lfs.sh:

qemu-machine-aarch64 
  -machine virt,accel=hvf,highmem=off 
  -cpu cortex-a72 -smp 8 -m 2G 
  -system virtio-gpu-pci 
  -system virtio-keyboard-pci 
  -force "layout=raw,file=edk2-aarch64-code.fd,if=pflash,readonly=on" 
  -force "layout=raw,file=ovmf_vars.fd.lfs,if=pflash" 
  -force "layout=qcow2,file=digital-lfs-disk.qcow2" 
  -nic hostfwd=tcp: 127.0.0.1: 9923-0.0.0.0: 22 
  -nographic

Step 4: Restore the Backup:

cp ovmf_vars.fd.host ovmf_vars.fd

Totally different notes:

• There are some idiosyncrasies on the aarm64 architecture. I would possibly presumably maybe simply no longer traipse into
  too many runt print right here, but this article is worth a careful learn while you
  safe to chapter 9.4, managing devices
  What is ttyama0?
• Develop no longer flee both the host machine and LFS machine at the same time! (unless
  you seize the lfs force from the host machine first.)