How to Update Your Multi-Boot Linux Setup Like a Pro
If you’re a Linux enthusiast like me, there’s no way you can make do with just one distribution on your laptop or p.c. If you’re like me, you run at least one large-capacity SSD device on your laptop, or even a second one installed in a dvd caddy. You’re able to fit 3 to 8 (or more) operating systems on these internal drives, which scratches the distro-hopping itch while challenging you to gain proficiency with multiple package managers, such as apt (Debian/Ubuntu), dnf (Fedora), zypper (OpenSUSE) or pacman (Arch and its derivatives). If you’re a fan of rolling-release distributions like me, you spend a portion of most days running system updates.
On a multi-boot system, what is the most efficient and safe way to ensure that all your distributions stay updated, requiring the least amount of time and energy? Is a graphical user interface (GUI) the best way to go, or is the command line a better choice?
Forget About the GUI Update Option
Many Linux distributions provide at least one graphical interface for installing updates.
Ubuntu utilizes its Software Updater.
Mint uses its very well designed Update Manager.
Manjaro offers Pamac.
OpenSUSE provides its all-encompassing control center, YAST.
Fedora and Debian running Gnome use Gnome Software, while on KDE they use the Muon Package Manager.
These are just a few of the update gui’s floating around out there, and for the most part, they do their job in terms of notifying the user of available updates, then performing the update with just a click or two.
In a multi-boot scenario, where the Linux enthusiast may have 3 to 8 or more distributions installed on a single machine, and may have more than one machine similarly packed, attempting to update through a graphical interface is just too time-consuming.
Instead, the multi-boot user needs to familiarize him-or-herself with the TTY subsystem.
What is TTY?
…TTY is an abstract device in UNIX and Linux. Sometimes it refers to a physical input device such as a serial port, and sometimes it refers to a virtual TTY where it allows users to interact with the system.
TTY is a subsystem in Linux and Unix that makes process management, line editing, and session management possible at the kernel level through TTY drivers.
You may want to read the two links immediately above for a deeper look at the history and usage of the TTY subsystem.
From what I’ve read, TTY stands for TeleTYpe, and in our modern computing world, what once involved typing and paper printing has evolved into a set of virtual command line interfaces connecting at the kernel level. Programmers, system administrators, developers and “guru-level” users are able to do much of their computing from TTY, completely bypassing a graphical environment if they wish. For our purposes, all we need to know is that, once the boot process reaches the display manager login screen:
…we have an opportunity to access a TTY console/terminal, where we can run our updates with a just a few taps on the keyboard.
Another big benefit to updating via TTY is that it removes the potential for a graphical environment crash during the update. Before I started running updates via TTY, I had a few occasions where Gnome crashed as the downloaded packages updated, which corrupted the update process to the point where I had to reinstall the entire operating system. Lesson learned!
The GRUB-Controlling Distro
In this scenario, we will multi-boot several different Linux distributions, each one accessed from a GRUB menu that greets us after powering-on the machine. For this article, we will assume that you’ve already installed two or more distributions and are able to access them through the GRUB menu. The order in which you update the distros does not matter, except that you’ll want to reserve the GRUB-controlling distro for last. The reason for this is, if there are kernel or firmware changes on any of the other distros, these changes will need to be written onto the controlling GRUB menu so that it can successfully navigate to all the kernel-updated distributions. If you forget this step, when you attempt to boot into a kernel-upgraded distro, it may fail.
What do we mean by “GRUB-controlling distro?”
In a multi-boot scheme, we rely on just one of the distributions to provide a GRUB menu that gives boot options for all installed distros. Each distribution can generate its own GRUB menu at the time of installation, but only one is subsequently chosen from the BIOS settings, and I’m calling this the “controlling” GRUB menu.
In the past, I would typically use Manjaro as the GRUB-controlling distro, since other distributions configure their GRUB in a way that does not boot Manjaro — but Manjaro’s GRUB seems to boot everyone else without issue. Lately, however, Manjaro’s GRUB configuration takes an uncomfortably long time to find the other distributions on my system, so that, when I update GRUB, OS-prober can take 20 minutes or longer to detect the other distributions that need to be listed. My workaround: Install OpenSUSE Tumbleweed (or Gecko Rolling, nearly the same thing) and use it as the GRUB-controlling distro, since Manjaro boots just fine with the OpenSUSE GRUB. OS-prober with OpenSUSE only takes a few seconds to detect other distros. I’m sure this would work with OpenSUSE Leap, as well.
Of course, if Manjaro is not installed, you can pick any distribution to be the Grub-controlling distro. Through testing, you’ll find that some work better than others in a multi-boot setup.
Updating from TTY Like a Pro
Here are the steps:
- Power-on your laptop or p.c.
- From the GRUB menu, choose any distribution except the one that controls GRUB — leave this one for last
3. When the login screen pops up, hit
Ctrl + Alt + F3
(if this doesn’t work, try Ctrl + Alt + F1, F2, F4, F5 or F6 — experimentation encouraged)
4. This should take you to a TTY console/terminal, which looks something like this:
5. Provide login credentials
6. Issue update command(s) (see examples below)
7. After update completes, type either
“reboot -i”
or if that doesn’t work, try
“systemctl reboot -i.”
8. At GRUB menu, choose another distribution to update, then repeat steps 1 through 7
9. Once the GRUB-controlling distro has been updated, if any of the other distros have made changes to their kernels or firmware, update GRUB by typing
“grub-mkconfig -o /boot/grub/grub.cfg”
or if that doesn’t work,
“grub2-mkconfig -o /boot/grub2/grub.cfg”
alternatively, try
“update-grub” (typically works on Ubuntu and Arch/Manjaro/EndeavorOS, etc.)
10. Type the reboot command from step 7, then from GRUB choose the distribution you want to use
That’s it!
For me, updating four rolling-releases (Gecko/OpenSUSE Tumbleweed, Manjaro Unstable, EndeavorOS and Debian Sid) and one static (Fedora), all on SSD drives with a fairly fast i7 processor and a decent Internet connection, averages 10 to 20 minutes, depending on how many packages are in the pipeline. If I tried to boot into each distro and update via the graphical interface, this would take 2–3 times as long, at minimum. Using the TTY console/terminal, I’m better able to keep track of where I am in the process, so that when I get to the GRUB-controlling distro, I know whether or not to update GRUB.
I’ve been doing this for at least ten years with almost no problems, assuming there are no issues with dependencies or broken packages — which, of course, would be present no matter how I do the updates.
Common Update Commands
Here are some typical update commands for the main Linux distributions, plus universal package managers Flatpak and Snaps:
Ubuntu or Debian (including MX and Sparky, etc.):
sudo apt update && sudo apt upgrade
Fedora:
sudo dnf update
OpenSUSE Tumbleweed
sudo zypper dup
OpenSUSE Leap
sudo zypper update
Arch, EndeavorOS and other Arch-based Distros:
sudo pacman -Syu
Manjaro
pamac update -a
or
sudo pacman -Syu
Flatpak
flatpak update
Snaps
sudo snap refresh
