Multiboot USB drive

Related articles
GRUB
Syslinux
archiso
A multiboot USB flash drive allows booting multiple ISO files from a single device. The ISO files can be copied to the device and booted directly without unpacking them first. There are multiple methods available, but they may not work for all ISO images.
Using GRUB and loopback devices
This article or section needs language, wiki syntax or style improvements. See
Help:Style
for reference.
Reason:
multiple
style
issues (Discuss in
Talk:Multiboot USB drive
)
Advantages:
only a single partition required
all ISO files are found in one directory
adding and removing ISO files is simple
Disadvantages:
not all ISO images are compatible
the original boot menu for the ISO file is not shown
it can be difficult to find a working boot entry
Preparation
This article or section needs expansion.
Reason:
How much extra space is needed for the boot loader? (Discuss in
Talk:Multiboot USB drive
)
Create at least one partition and a filesystem supported by
GRUB
on the USB drive. See
Partitioning
and
File systems#Create a file system
. Choose the size based on the total size of the ISO files that you want to store on the drive, and plan for extra space for the
boot loader
.
Installing GRUB
Simple installation
Mount the filesystem located on the USB drive:
# mount /dev/sdXY /mnt
Create the directory /boot:
# mkdir /mnt/boot
Install GRUB on the USB drive:
# grub-install --target=i386-pc --recheck --boot-directory=/mnt/boot /dev/sdX
In case you want to boot ISOs in UEFI mode, you have to install grub for the UEFI target:
# grub-install --target=x86_64-efi --removable --boot-directory=/mnt/boot --efi-directory=/mnt
For UEFI, the partition has to be the first one in an MBR partition table and formatted with FAT32.
Hybrid UEFI GPT + BIOS GPT/MBR boot
This article or section is being considered for removal.
Reason:
There is no reason to suggest the abominable hybrid MBR when
other workarounds for BIOS/GPT booting
exist. (Discuss in
Talk:Multiboot USB drive#Section 1.2.2 Hybrid UEFI GPT + BIOS GPT/MBR boot
)
This configuration is useful for creating a universal USB key, bootable everywhere.
First of all you must create a
GPT
partition table on your device. You need at least 3 partitions:
A
BIOS boot partition
(gdisk type code
EF02
). This partition must be 1 MiB in size
An
EFI system partition
(gdisk type code
EF00
with a
FAT32 filesystem
). This partition can be as small as 50 MiB.
Your data partition (use a filesystem supported by
GRUB
). This partition can take up the rest of the space of your drive.
Next you must create a
hybrid MBR
partition table. Without it, a BIOS MBR based system will not boot. It will not find the partitions it expects to find.
Hybrid MBR partition table creation example using
gdisk
:
# gdisk /dev/sd
X
Command (? for help): r
Recovery/transformation command (? for help): h

WARNING! Hybrid MBRs are flaky and dangerous! If you decide not to use one,
just hit the Enter key at the below prompt and your MBR partition table will
be untouched.

Type from one to three GPT partition numbers, separated by spaces, to be added to the hybrid MBR, in sequence: 1 2 3
Place EFI GPT (0xEE) partition first in MBR (good for GRUB)? (Y/N): N

Creating entry for GPT partition #1 (MBR partition #1)
Enter an MBR hex code (default EF):
Set the bootable flag? (Y/N): N

Creating entry for GPT partition #2 (MBR partition #2)
Enter an MBR hex code (default EF):
Set the bootable flag? (Y/N): N

Creating entry for GPT partition #3 (MBR partition #3)
Enter an MBR hex code (default 83):
Set the bootable flag? (Y/N): Y

Recovery/transformation command (? for help): x
Expert command (? for help): h
Expert command (? for help): w

Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING
PARTITIONS!!

Do you want to proceed? (Y/N): Y
Do not forget to format the partitions:
# mkfs.fat -F32 /dev/sd
X
2
# mkfs.ext4 /dev/sd
X
3
You can now install GRUB to support both EFI + GPT and BIOS + GPT/MBR. The GRUB configuration (--boot-directory) can be kept in the same place.
First, you need to mount the EFI system partition and the data partition of your USB drive.
An example of this would be as follows:
# mount /dev/sd
X
3 /mnt
# mkdir /mnt/boot /mnt/efi
# mount /dev/sd
X
2 /mnt/efi
Then, you can install GRUB for UEFI with:
In most cases
EFI_MOUNTPOINT
will correspond to the
/mnt/efi
directory on your mounted USB disk.
DATA_MOUNTPOINT
is where your data partition is mounted. In this example it would be the mount point of sd
X
3,
/mnt
.
# grub-install --target=x86_64-efi --recheck --removable --efi-directory=/
EFI_MOUNTPOINT
--boot-directory=/
DATA_MOUNTPOINT
/boot
And for BIOS with:
# grub-install --target=i386-pc --recheck --boot-directory=/
DATA_MOUNTPOINT
/boot /dev/sd
X
As an additional fallback, you can also install GRUB on your MBR-bootable data partition:
# grub-install --target=i386-pc --recheck --boot-directory=/
DATA_MOUNTPOINT
/boot /dev/sd
X
3
Configuring GRUB
Using a template
There are some git projects which provide some pre-existing GRUB configuration files, and a nice generic
grub.cfg
which can be used to load the other boot entries on demand, showing them only if the specified ISO files - or folders containing them - are present on the drive.
Multiboot USB:
https://github.com/hackerncoder/multibootusb
GLIM (GRUB2 Live ISO Multiboot):
https://github.com/thias/glim
Manual configuration
For the purpose of multiboot USB drive it is easier to edit
grub.cfg
by hand instead of generating it. Alternatively, make the following changes in
/etc/grub.d/40_custom
or
/mnt/boot/grub/custom.cfg
and generate
/mnt/boot/grub/grub.cfg
using
grub-mkconfig
.
As it is recommend to use a
persistent name
instead of
/dev/sd
xY
to identify the partition on the USB drive where the image files are located, define a variable for convenience to hold the value. If the ISO images are on the same partition as GRUB, use the following to read the UUID at boot time:
/mnt/boot/grub/grub.cfg
# path to the partition holding ISO images (using UUID)
probe -u $root --set=rootuuid
set imgdevpath="/dev/disk/by-uuid/$rootuuid"
Or specify the UUID explicitly:
/mnt/boot/grub/grub.cfg
# path to the partition holding ISO images (using UUID)
set imgdevpath="/dev/disk/by-uuid/
UUID_value
"
Alternatively, use the device label instead of UUID:
/mnt/boot/grub/grub.cfg
# path to the partition holding ISO images (using labels)
set imgdevpath="/dev/disk/by-label/
label_value
"
The necessary UUID or label can be found using
lsblk -f
. Do not use the same label as the Arch ISO for the USB device, otherwise the boot process will fail.
To complete the configuration, a boot entry for each ISO image has to be added below this header, see the next section for examples.
Boot entries
It is assumed that the ISO images are stored in the
/boot-isos
directory on the same filesystem where GRUB is installed. Otherwise it would be necessary to prefix the path to ISO file with device identification when using the
loopback
command, for example
loopback loop
(hd1,2)
$iso_path
. As this identification of devices is not
persistent
, it is not used in the examples in this section.
One can use persistent block device naming like so. Replace the UUID according to your ISO filesystem UUID.
# define globally (i.e outside any menuentry)
insmod search_fs_uuid
search --no-floppy --set=
isopart
--fs-uuid
123-456
# later use inside each menuentry instead
loopback loop
($isopart)
$iso_path
Tip
For a list of kernel parameters, see
the kernel's command-line parameter documentation
. For more examples of boot entries, see the
GRUB upstream documentation
or the documentation for the distribution you wish to boot.
Arch Linux monthly release
The ISO provides a
loopback.cfg
which you can leverage with an entry like this.
menuentry '[loopback]archlinux-2023.10.14-x86_64.iso' {
	set iso_path='/boot-isos/archlinux-2023.10.14-x86_64.iso'
	export iso_path
	search --set=root --file "$iso_path"
	loopback loop "$iso_path"
	root=(loop)
	configfile /boot/grub/loopback.cfg
	loopback --delete loop
}
Also see
archiso
.
MemTest86+
MemTest86+
is included in the monthly ISO.
menuentry '[loopback]archlinux-2023.03.01-x86_64.iso MemTest86+' {
	set iso_path='/boot-isos/archlinux-2023.03.01-x86_64.iso'
	loopback loop $iso_path
	linux (loop)/boot/memtest86+/memtest.efi
}
Archboot
See
Archboot Homepage
.
menuentry '[loopback]archlinux-2014.11-1-archboot' {
	set iso_path='/boot-isos/archlinux-2014.11-1-archboot.iso'
	loopback loop $iso_path
	linux (loop)/boot/vmlinuz_
x86_64
iso_loop_dev=$imgdevpath iso_loop_path=$iso_path
	initrd (loop)/boot/initramfs_
x86_64
.img
}
Using Syslinux and memdisk
Using the
memdisk
module, the ISO image is loaded into memory, and its
boot loader
is loaded. Make sure that the system that will boot this USB drive has sufficient amount of memory for the image file and running operating system.
Preparation
Make sure that the USB drive is properly
partitioned
and that there is a partition with
file system
supported by Syslinux, for example fat32 or ext4. Then install Syslinux to this partition, see
Syslinux#BIOS systems
.
Install the memdisk module
The memdisk module was not installed during Syslinux installation, it has to be installed manually. Mount the partition where Syslinux is installed to
/mnt/
and copy the memdisk module to the same directory where Syslinux is installed:
# cp /usr/lib/syslinux/bios/memdisk /mnt/boot/syslinux/
Configuration
After copying the ISO files on the USB drive, edit the
Syslinux configuration file
and create menu entries for the ISO images. The basic entry looks like this:
boot/syslinux/syslinux.cfg
LABEL
some_label
LINUX memdisk
    INITRD
/path/to/image.iso
APPEND iso
See
memdisk on Syslinux wiki
for more configuration options.
Automated tools
GRUB2 Live ISO Multiboot (GLIM)
— A set of GRUB configuration files to turn a VFAT formatted USB memory stick with GNU/Linux distribution ISO images into a multiboot USB drive.
https://github.com/thias/glim
||
not packaged?
search in AUR
liveusb-builder
— A script suite to create multiboot USB stick for GNU/Linux distributions
https://github.com/mytbk/liveusb-builder
||
liveusb-builder-git
AUR
MultiOS-USB
— A minimal open source tool to create a multiboot USB drive for ISO/WIM/EFI files with Secure Boot support and minimal changes to GRUB2.
https://github.com/Mexit/MultiOS-USB
||
multios-usb-bin
AUR
Ventoy
— A tool to create a multiboot USB drive for ISO/WIM/IMG/VHD(x)/EFI files with Secure Boot support but security and licensing
concerns
about provided blobs.
https://www.ventoy.net/
||
ventoy
AUR
See also
GRUB:
https://help.ubuntu.com/community/Grub2/ISOBoot/Examples
https://help.ubuntu.com/community/Grub2/ISOBoot
Syslinux:
Boot an ISO image