Есть не так уж много вариантов использования нескольких дистрибутивов Linux на одной машине. Вы можете установить их все на жесткий диск, на виртуальную машину или сохранить в виде ISO образа и загружаться в реальном времени.
Первый и второй способы не очень выгодны так как требуют очень много места на жестком диске, с другой стороны, для третьего способа нужно иметь CD диск или USB флешку для хранения образа и загрузчика. Но есть еще один вариант — хранить ISO образ на жестком диске, и загружаться с него по мере надобности. Здесь не нужно столько дискового пространства как при установке, и не нужен внешний носитель информации. В этой статье будет рассмотрена загрузка с ISO образа в Grub.
Содержание статьи
- Что нам понадобится
- Загрузка с ISO образа в Grub
- Загрузка windows с iso образа в Grub
- Завершение настройки Grub
- Выводы
Что нам понадобится
В этой статье мы будем использовать загрузчик Grub, впрочем, он и так используется в большинстве дистрибутивов Linux. Также нам понадобится ISO образ, с которого будем загружаться и вы должны знать на каком разделе он размещён. Удобнее всего разместить его на загрузочном разделе. Чтобы узнать какой раздел диска у вас загрузочный выполните:
fdisk -l
Загрузочный раздел будет помечен знаком * в колонке Загрузочный или Boot. Например, у меня /dev/sda2 или как пишется в Grub hd0,2 — загрузочный.
Разделы /dev/sda1 и /dev/sdb3 будут называться в Grub hd0,1 и hd1,3 соответственно. В синтаксисе Grub именование дисков начинается с нуля, а именование разделов с единицы.
Сначала откройте файл /etc/default/grub и закомментируйте там эту строку если она там есть:
GRUB_HIDDEN_TIMEOUT=0
Перед строчкой должна стоять решетка. Сохраните изменения, а затем откройте файл /etc/grub.d/40_custom. Здесь мы добавим пункт для загрузки с образа, синтаксис выглядит следующим образом:
menuentry «Заголовок пункта» {
set isofile=«Адрес ISO файла»
loopback loop Раздел в форме записи Grub на котором расположен ISO$isofile
Параметры загрузки ядра
}
Перед тем, как переходить к настройке Grub надо выяснить ещё один момент. Как в оригинальном образе выполняется загрузка дистрибутива. Обычно в каждом загрузочном образе есть папка Grub в которой можно посмотреть файл grub.cfg или другой подобный, например loopback.cfg и узнать какими строками там загружается ядро:
Только перед путями к файлам надо добавить адрес (loop). Путь к образу надо указывать от начала того диска, на котором он расположен. Например, если диск расположен в корне загрузочного раздела, который монтируется в /boot, то и путь будет /файл.iso, а не /boot/файл.iso. Теперь можно переходить к примеру, запись для загрузки Puppy Linux будет выглядеть вот так:
menuentry "Puppy 20.04 Live" {
set isofile="/puppylinux.iso"
loopback loop (hd0,2)$isofile
linux (loop)/vmlinuz pfix=fsck pmedia=cd findiso="/puppylinux.iso"
initrd (loop)/initrd.gz
}
Каждый дистрибутив индивидуален и надо с каждым разбираться отдельно. Если вы хотите запускать Gparted:
menuentry "GParted Live amd64" {
set isofile="/gparted-live-0.18.0-2-amd64.iso"
loopback loop (hd0,2)$isofile
loopback loop $isofile
linux (loop)/live/vmlinuz boot=live config union=aufs noswap noprompt ip=frommedia toram=filesystem.squashfs findiso=${isofile}
initrd (loop)/live/initrd.img
}
Или даже Fedora Linux:
menuentry "Fedora Live" {
set isofile="/Fedora.iso"
loopback loop (hd0,2)$isofile
loopback loop $isofile
linux (loop)/isolinux/vmlinuz0 root=live:CDLABEL=Fedora-Live rootfstype=auto ro rd.live.image quiet rhgb rd.luks=0 rd.md=0 rd.dm=0 iso-scan/filename=${isofile}
initrd (loop)/isolinux/initrd0.img
}
Обратите внимание, что опции будут меняться в зависимости от дистрибутива и расположения в нем загрузочных файлов. Кроме того, важно то где размещен ISO образ, если ваш домашний каталог зашифрован лучше его хранить на загрузочном разделе, как в примерах выше.
Хотите больше? Можно загрузится с ISO для автоматического выполнения каких-либо действий. Например, если вы параноик и хотите иметь возможность быстро стереть свой жесткий диск можно использовать DBAN. Но будьте осторожны так как это сотрет все данные без возможности восстановления.
menuentry "Darik's Boot and Nuke" {
set isofile="/dban.iso"
loopback loop (hd0,1)$isofile
linux (loop)/dban.bzi nuke="dwipe" silent
}
Есть еще много вещей, которые можно сделать с помощью загрузки ISO образа в Grub, неважно хотите ли вы очень быструю Live систему или иметь возможность уничтожить все кончиком пальца.
Загрузка windows с iso образа в Grub
Если вам нужна загрузка Windows с ISO образа Grub, то это делается тоже не очень сложно, но немного по другому. Сначала нужно скачать syslinux и извлечь оттуда memdisk в папку /boot/. Это должна быть папка, куда установлены файлы Grub. Дальше добавьте в конфигурационный файл 40-grub.conf такие строки:
menuentry "Boot Windows" {
search -f "--set-root /Windows.iso"
insmod memdisk
linux16 /boot/memdisk iso
initrd16 /Windows.iso
}
Образ Windows должен лежать в корне одного из разделов и называться Windows.iso, дальше команда search автоматически найдет этот раздел и установит его в качестве корня. Потом останется только загрузка windows с iso образа grub.
Завершение настройки Grub
Мы все подготовили, теперь остается обновить конфигурацию загрузчика Grub, чтобы новые пункты добавились в /boot/grub/grub.cfg и появились в меню загрузки. Для Ubuntu команда будет выглядеть вот так:
sudo update-grub
В других дистрибутивах может понадобится команда:
sudo grub-mkconfig -o /boot/grub/grub.cfg
Затем можно перезагрузиться и посмотреть что получилось:
Если что-то пошло не так, вы можете нажать клавишу E и редактировать этот пункт меню чтобы попытаться исправить проблему прямо в загрузчике.
Выводы
Теперь вы знаете как выполняется загрузка iso образа grub, здесь нет ничего сложного, но зато это очень полезная возможность получить несколько систем на своем компьютере, затратив при этом минимум памяти и времени на их установки. Если у вас остались вопросы, спрашивайте в комментариях!
This tutorial will be showing you how to boot ISO files stored on your hard drive with the GRUB2 boot loader. Normally you need to create a live DVD or live USB in order to boot Linux ISO images. You can do it with graphical tools or from the command line. But what if you don’t have an optical disk or USB thumb drive around, or your computer does not support burning ISO images to an optical disk?
GRUB to the rescue
GRUB2 (GRand Unified Bootloader) is the standard boot loader for Linux. It can boot Linux ISO image files stored on the hard drive without a USB or DVD. GRUB Legacy (version 0.x) doesn’t have this feature. Many Linux distributions can be booted directly from an ISO file.
- GRUB2 supports many file systems, including but not limited to
ext4
,HFS+
, andNTFS
, which means you can put your ISO file on any of these file systems. - GRUB2 can read files directly from LVM and RAID devices.
- GRUB2 also has network support. You can load ISO images over the network by using the TFTP protocol.
To use GRUB2 to boot ISO files, you need a Linux distro with GRUB2 as the boot loader already installed on your computer. The following instructions work on both the traditional BIOS and the newer UEFI firmware. However, if you use UEFI, then you should disable secure boot in the firmware for GRUB2 to boot ISO files, otherwise, you might see the “can not find command loopback” error.
Now let’s get started.
Boot Ubuntu ISO Files From GRUB2
Log in to a computer running Linux and download an Ubuntu ISO image file. Then open up a terminal window and edit the /etc/grub.d/40_custom
file with a command-line text editor like Nano.
sudo nano /etc/grub.d/40_custom
The first line of this file is #! /bin/sh
indicating it’s a shell script. In this file, we can add custom entries to the GRUB boot menu.
Copy and paste the following text at the end of this file.
menuentry "ubuntu-20.04.2.0-desktop-amd64.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/ubuntu-20.04.2.0-desktop-amd64.iso" loopback loop (hd0,5)$isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet noeject noprompt splash initrd (loop)/casper/initrd }
Where:
- menuentry: This entry will be displayed on the GRUB2 boot menu. You can name it whatever you like.
- The insmod command inserts a module. Since the ISO file is stored under my
ext4
home dierctory, theext2
module is needed. If it’s stored on an NTFS partition, then you needinsmod ntfs
instead. Note that GRUB may not be able to recognize XFS and Btrfs file system, so it’s not recommended to store the ISO file on a XFS or Btrfs partition. - set isofile: Specify that path of your ISO image file. Here I’m using Ubuntu 20.04 Desktop ISO file saved under the
Downloads
folder. - loopback: Mount the ISO file.
hd0
means the first hard drive in the computer and5
means the ISO file is stored on the 5th disk partition. - The
linux
command loads a Linux kernel from the specified path. casper/vmlinuz.efi is the linux kernel inside the Ubuntu ISO image. - The
initrd
command loads an initial ramdisk from the specified path. It can only be used after thelinux
command has been run. The initial ramdisk is a minimal root file system mounted to the RAM. casper/initrd.lz is the initrd file inside the Ubuntu ISO image.
Note that GRUB does not distinguish IDE from SCSI. In Linux kernel:
/dev/hda
refers to the first IDE hard drive and/dev/sda
refers to the first SCSI or SATA hard drive./dev/nvme0n1
refers to the first NVMe SSD./dev/nvme1n1
refers to the second NVMe SSD.
But in GRUB, the first hard drive is always referred to as hd0
, no matter what the interface type is. Also note that partition numbers in GRUB start at 1, not 0.
If the ISO file is stored on an extended partition of MBR disk, the partition number starts from 5, instead of 1. For example, the first logical partition inside an extended partition will be numbered as 5; the second logical partition inside an extended partition will be numbered as 6. To check your partition number, you can run lsblk
or sudo parted -l
command in the terminal window.
Save and close the file. (Press Ctrl+O
, then press Enter
to save a file in Nano text editor. Press Ctrl+X
to exit.)
Then update GRUB boot menu with the following command:
sudo grub-mkconfig -o /boot/grub/grub.cfg
On Fedora, CentOS, RHEL, OpenSUSE, the command to run is:
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
On Debian, Ubuntu, Linux Mint, you can use the following command to update GRUB boot menu.
sudo update-grub
You might not see the new menu entry right away, but you will see it when you reboot your computer.
sudo shutdown -r now
You will see your custom entry at the bottom of the GRUB2 boot menu. If GRUB couldn’t boot your ISO image, please check /etc/grub.d/40_custom
file to see if there is a typo or you left out a space or something like that.
You can add as many menu entries as you like in the /etc/grub.d/40_custom
file.
Debian ISO
Download the Debian live CD ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot a Debian ISO file.
menuentry "debian-live-10.8.0-amd64-lxqt.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/debian-live-10.8.0-amd64-lxqt.iso" loopback loop (hd0,5)$isofile linux (loop)/live/vmlinuz-4.19.0-14-amd64 boot=live findiso=$isofile initrd (loop)/live/initrd.img-4.19.0-14-amd64 }
Note that the vmlinuz
and initrd.img
file include version number. You should mount your Debian ISO file and check if you should update it. Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Arch Linux ISO
Download the Arch Linux ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot a Arch Linux ISO file.
menuentry "archlinux-2021.03.01-x86_64.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/archlinux-2021.03.01-x86_64.iso" loopback loop (hd0,5)$isofile linux (loop)/arch/boot/x86_64/vmlinuz-linux archisolabel=ARCH_202103 img_dev=/dev/sda5 img_loop=$isofile earlymodules=loop initrd (loop)/arch/boot/x86_64/initramfs-linux.img }
Note that if you download a newer Arch Linux ISO file such as archlinux-2021.04.01-x86_64.iso
, then you need to update the archisolabel
to ARCH_202104
. You can also find out what the label should be by mounting the Arch Linux ISO in your file manager. The label will be shown in your file manager.
Also you might need to change the value of img_dev
. It’s the name of the device where your ISO file is stored.
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Clonezilla Live ISO
Clonezilla is a free open-source and reliable tool for bare metal backup and recovery of disk drives. Download the Clonezilla live ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot Clonezilla Live ISO file.
menuentry "clonezilla-live-20210127-groovy-amd64.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/clonezilla-live-20210127-groovy-amd64.iso" loopback loop (hd0,5)$isofile linux (loop)/live/vmlinuz boot=live findiso=$isofile initrd (loop)/live/initrd.img }
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
RHEL 8/CentOS Stream ISO
First, download the ISO image file. For RHEL 8, please read the following article to learn how to download ISO image file.
- How to Download and Install RHEL8 For Free (Red Hat Enterprise Linux)
CentOS Stream ISO image can be downloaded from its official website.
Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot RHEL 8/CentOS/Fedora ISO file.
menuentry "rhel-8.3-x86_64-boot.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/rhel-8.3-x86_64-boot.iso" loopback loop (hd0,5)$isofile linux (loop)/isolinux/vmlinuz noeject inst.stage2=hd:/dev/sda5:$isofile initrd (loop)/isolinux/initrd.img }
In the above code, /dev/sda5
is the 5th partition of the first disk where the ISO image file is stored. Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Fedora ISO
Fedora ISO image can be downloaded from its official website. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot Fedora ISO file.
menuentry "Fedora-Workstation-Live-x86_64-33-1.2.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/Fedora-Workstation-Live-x86_64-33-1.2.iso" loopback loop (hd0,5)$isofile linux (loop)/isolinux/vmlinuz root=live:CDLABEL=Fedora-WS-Live-33-1-2 rd.live.image verbose iso-scan/filename=$isofile initrd (loop)/isolinux/initrd.img }
In the above code, CDLABEL
is the the label displayed in your file manager when the ISO image is mounted.
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
OpenSUSE Leap Live ISO
Download the OpenSUSE Leap live ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot OpenSUSE Leap Live ISO file.
menuentry "openSUSE-Leap-15.2-KDE-Live-x86_64-Build31.383-Media.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/openSUSE-Leap-15.2-KDE-Live-x86_64-Build31.383-Media.iso" loopback loop (hd0,5)$isofile linux (loop)/boot/x86_64/loader/linux boot=isolinux root=live:CDLABEL=openSUSE_Leap_15.2_KDE_Live rd.live.image verbose iso-scan/filename=$isofile initrd (loop)/boot/x86_64/loader/initrd }
In the above code, CDLABEL
is the the label displayed in your file manager when the ISO image is mounted.
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Kali Linux Live ISO
Download the Kali Linux live ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot a Kali Linux Live ISO file.
menuentry "kali-linux-2021.1-live-amd64.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/kali-linux-2021.1-live-amd64.iso" loopback loop (hd0,5)$isofile linux (loop)/live/vmlinuz boot=live findiso=$isofile initrd (loop)/live/initrd.img }
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Linux Mint Live ISO
Download the Linux Mint ISO file. Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot a Linux Mint ISO file.
menuentry "linuxmint-20.1-cinnamon-64bit.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/linuxmint-20.1-cinnamon-64bit.iso" loopback loop (hd0,5)$isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet noeject noprompt splash initrd (loop)/casper/initrd.lz }
The above config is for the standard Ubuntu-based Linux Mint ISO file. If you use Linux Mint Debian Edition ISO file, then add the following lines instead.
menuentry "lmde-6-cinnamon-64bit.iso" { insmod ext2 set isofile="/home/linuxbabe/Downloads/lmde-6-cinnamon-64bit.iso" loopback loop (hd0,5)$isofile linux (loop)/live/vmlinuz boot=live findiso=$isofile initrd (loop)/live/initrd.lz }
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Finding Out the Linux kernel and initrd File Name
The Linux kernel and initrd (initial ramdisk) file can be different for different Linux ISO images. For Ubuntu, the Linux kernel is located at /casper/vmlinuz
and the initrd image file is located at /casper/initrd
. If you don’t know where they are located, just open your ISO image with archive manager. The following screenshot shows the Arch Linux ISO image file.
Display GRUB Boot Menu
Some Linux distributions like Ubuntu hide the GRUB boot menu if there’s only one OS installed on the hard drive. To show the GRUB boot menu, edit a configuration file.
sudo nano /etc/default/grub
Find the following line, which tells GRUB to hide the boot menu.
GRUB_TIMEOUT_STYLE=hidden
Add the #
character at the beginning to comment out this line.
#GRUB_TIMEOUT_STYLE=hidden
Then find the following line.
GRUB_TIMEOUT=0
Change 0
to 10
, so you will have 10 seconds to choose an entry in the GRUB boot menu.
GRUB_TIMEOUT=10
Save and close the file. Then update GRUB configurations.
sudo update-grub
Change the Boot Order in GRUB
Let’s say you want to boot into the ISO by default in GRUB, then edit the configuration file.
sudo nano /etc/default/grub
Find the following line, which makes GRUB select the first entry in the boot menu.
GRUB_DEFAULT=0
Change it to something like this:
GRUB_DEFAULT="clonezilla-live-20210127-groovy-amd64.iso"
If the /etc/grub.d/40_custom
file has this entry menuentry "clonezilla-live-20210127-groovy-amd64.iso"
, then GRUB will select this entry by default. Update GRUB for the changes to take effect.
sudo update-grub
You can also keep the default boot order, but boot an ISO file for the next boot only with:
sudo grub-reboot clonezilla-live-20210127-groovy-amd64.iso
or
sudo grub2-reboot clonezilla-live-20210127-groovy-amd64.iso
Then reboot.
sudo shutdown -r now
Additional Tips
If you have a SATA disk and an NVMe SSD inside your computer, the SATA disk is the first and the NVMe SSD is the second. The same goes for a USB drive and an NVMe SSD. If you have an optical disk, then GRUB might think the optical disk is the first disk.
If you see the following error when GRUB trying to boot an ISO image file, it likely that you have specified the ISO file location to an optical disk.
can not get C/H/S value
If you have a file system that spans the entire disk, then you don’t need to specify the partition number in GRUB. For example, I have an ISO file on my second disk. I didn’t make any partitions on the second disk, so I can specify (hd1)
in GRUB configuration file.
loopback loop (hd1)$isofile
If you see an error message like below when updating the GRUB boot menu, you can ignore this error.
grub-probe: error: cannot find a GRUB drive for /dev/loop11p3. Check your device.map.
Load Linux Live System into RAM
Grub allows you to load the entire Linux live system into RAM. This will make the system run much faster. Simply add the toram
parameter at the end of the linux
line like this:
linux (loop)/live/vmlinuz boot=live findiso=$isofile toram
Make sure the ISO file is smaller than your RAM. I like to use the Linux Mint Debian Edition ISO, which is only 2.6 GB in size.
Windows 10 ISO
Yes, you can create a Windows 10 bootable USB on Ubuntu or any Linux distro. If you don’t have a USB thumb drive, you can boot Windows 10 ISO on the hard drive with GRUB2. Download the Windows 10 ISO file. Note that you might not be able to download the ISO from this link on a Windows computer. This download link is visible to users on Linux computer.
GRUB2 can not boot Windows 10 ISO directly. You need to create a separate NTFS partition on your disk with a partition editor like GParted and extract the Windows 10 ISO to that partition. The latest Windows 10 ISO file is 5.8G. The new NTFS partition should be at least 7G and it should not be used to store any other files.
Then find your Windows 10 ISO in file manager. Open it with disk image mounter.
Open the mounted file system. Select all files and folders and copy them to the NTFS partition.
Sometimes the file manager on Ubuntu hangs and it seems that the copy operation has stopped. Actually, it’s working. Just be patient. When you see a checkmark, it means the copy operation has finished.
Next, open up a terminal window and edit the /etc/grub.d/40_custom
file with a text editor such as Nano.
sudo nano /etc/grub.d/40_custom
In this file, we can add custom entries to the GRUB boot menu. In this case, we want to add an entry to boot the Windows 10 installer. If your computer still uses the traditional BIOS firmware, then add the following text in this file.
menuentry "Windows-10-Installer.iso" { set root=(hd0,6) insmod part_msdos insmod ntfs insmod ntldr #uncomment the following line if your computer has multiple hard drives. #drivemap -s (hd0) ${root} ntldr /bootmgr }
My NTFS partition number is 6, so I use (hd0,6)
as the root. You can run sudo parted -l
command to check your NTFS partition number. If your computer has multiple hard drives, use the drivemap
command to set the partition (hd0,6)
as the first hard disk, so Windows will be able to boot.
If your computer uses UEFI firmware, then add the following text in this file.
menuentry "Windows-10-Installer.iso" { set root=(hd0,6) insmod part_gpt insmod ntfs insmod chain chainloader /efi/boot/bootx64.efi }
Save and close the file. Then update GRUB boot menu.
sudo grub-mkconfig -o /boot/grub/grub.cfg
or
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
Unplug all your external USB storage devices, then reboot your computer. Note that the Windows desktop ISO installer doesn’t work properly on Proxmox KVM virtual machines.
Wrapping Up
I hop this tutorial helped you boot ISO files with GRUB2 boot loader. As always, if you found this post useful, then subscribe to our free newsletter to get more tips and tricks. Take care 🙂
This method allows you to directly boot from a number of different unmodified Windows Install 7/8/10 ISOs on a bootable USB drive AND then run Setup to install Windows to a system.
No files need to be extracted from the ISO – just copy the ISO file and boot!
- Legacy, UEFI or PXE boot is supported.
- The ISO is automatically mounted as a virtual drive so Setup can find and use the Install.wim\esd file.
- 2GB or more RAM is required to be in the system (it may fail to work if not enough RAM is available).
- The Windows Install ISO file does not need to be modified in any way.
I will describe here only the outline process so that you can see how it is done. Easy2Boot uses a similar (but not identical) process when MBR-booting.
Example grub2 menus are also provided (grub4dos only MBR boots, grub2 will MBR and UEFI32 and UEFI64 boot).
PROCESS IN OUTLINE:
- Add Windows Install ISO to a grub4dos or grub2 bootable USB drive
- Add a menu for grub4dos\grub2
- The menu uses wimboot to boot to files inside the ISO
- Add in a null.cfg file which contains the full path of the ISO (except for the drive letter)
- The menu also injects a startnet.bat file and winpeshl.ini file
- For MBR booting we swap BIOS device hd0 with hd1 so that Windows does not think the boot drive is the USB drive (it may refuse to install Windows to a Removable USB drive or Setup may install the Windows boot code to a USB hard disk if we don’t do this).
- When the grub2\grub4dos menu is picked, here is what happens…
- The ISO is mounted (by grub4dos as a CD device using map or by grub2 as a loop device)
- wimboot will load the boot.wim, boot.SDI and BCD from the mounted ISO into RAM
- wimboot injects into the boot.wim\X: RAM drive a null.cfg file which contains the file path of the ISO
- wimboot injects into the boot.wim\X: RAM drive a winpeshl.ini and startup.bat file
- The boot.wim file is booted to by wimboot via bootmgr+BCD and startup.bat runs
- startup.bat finds the USB drive and installs ImDisk (which is also located in a folder on the USB drive somewhere)
- startup.bat finds the null.cfg file in X:\Windows\System32 and from this we can determine the name of the ISO that we need to load
- startup.bat uses ImDisk to load the ISO as drive Y: from the USB drive
- startup.bat runs X:\Setup.exe which will now be able to find the \sources\install.wim file on the Y: virtual DVD drive mounted by ImDisk
If required, we can also inject an XML file into the X:\Windows\System32 folder and specify this as the unattend file when we run setup.exe. This will cause Setup to be automated.
For MBR-bootong, it is necessary to swap the BIOS drives 0 (USB drive) and 1 around so that Windows will think the ‘boot’ drive is the internal hard disk and not the USB drive – otherwise Windows will refuse to install the boot code (and the Windows OS) to the first internal hard disk.
Download files – see link at the bottom of this article.
You can use VBox+VMUB to test (see Tutorial 4) but the grub2 drivemap command can cause WinPE to hang and not boot in a VM.
Example grub2 MBR menu:
menuentry "WIN10 Install" --unrestricted --class Windows {
set isoname=win10.iso
loopback loop /$isoname
linux16 /wimboot/wimboot
initrd16 \
newc:bcd:(loop)/boot/bcd \
newc:null.cfg:/wimboot/null.cfg \
newc:winpeshl.ini:/wimboot/winpeshl.ini \
newc:startup.bat.sdi:/wimboot/startup.bat \
newc:boot.sdi:(loop)/boot/boot.sdi \
newc:boot.wim:(loop)/sources/boot.wim
drivemap -s hd0 hd1
boot
)
Note: filenames defined after newc: must not be bigger than 31 characters or wimboot will fail.
Also grub is case sensitive so beware! – e.g. /Boot/boot.sdi instead of /boot/boot.sdi.
wimboot will try to locate a suitable bootmgr or bootxxx.efi boot file, so you don’t usually need to specify one.
You can also add in bootmgr.exe or bootmgr or bootx64.efi/bootmgfw.efi files if the wim file does not contain a suitable file (copy the files to the \wimboot folder) add an extra @bootmgr=/bootmgr.exe entry (or /bootmgr (or /bootmgfw.efi if UEFI).
iPXE wimboot is used for MBR booting but a special grub2 (unsigned, non-secure) version of grub2 with wimboot.mod is required for UEFI-booting.
Example MBR grub4dos menu:
Use Grub4dos 2020-02-29.7z (note: shows as 2020-03-04 in command prompt) (other versions may have bugs – so try this version first!)
Most files are in grub2_wimboot.zip (see end of page).
title Install Windows10x64UK_Oct_2018 using wimboot method
map /Windows10x64UK_Oct_2018.iso (0xff)
map --hook
root (0xff)
# the root path now points to the files inside the ISO file
# hd0,0 is the USB drive that we booted from
kernel (hd0,0)/wimboot/wimboot
initrd @null.cfg=(hd0,0)/wimboot/null.cfg @startup.bat=(hd0,0)/wimboot/startup.bat @winpeshl.ini=(hd0,0)/wimboot/winpeshl.ini @bcd=/boot/bcd @boot.sdi=/boot/boot.sdi @boot.wim=/sources/boot.wim
map (hd0) (hd1)
map (hd1) (hd0)
map --hook
boot
IMPORTANT: order of the files in the initrd line seems to be important, the bcd and .wim file should be the last files loaded for the MBR version of wimboot.
On our USB drive we have a \wimboot folder:
- \wimboot\wimboot
- \wimboot\winpeshl.ini
- \wimboot\startup.bat
- \wimboot\null.cfg (contains the line installiso=xxxxxxxxx where xxxxxxxxx is the path and filename of the ISO using forward slashes)
- \wimboot\imdisk\(files from grub2_wimboot.zip)
- \Windows10x64UK_Oct_2018.iso
Example winpeshl.ini
[LaunchApps]
startup.bat
See Easy2Boot’s \_ISO\e2b\docs\QRUN.g4b file (search for ‘wimboot’ to see how you can use grub4dos to change null.cfg contents, etc.
ADDING A ‘WINDOWS INSTALL FROM ISO’ MENU TO THE E2B GRUB2 MENU SYSTEM
Set up your E2B drive with a second partition and the E2B grub2 menu files FIRST, then switch to the .imgPTN23 file so that the first partition contains the standard grub2 boot menu system files and the second partition contains your grub2 menu folders (e.g. \_ISO\MAINMENU, etc.) and then…
The following windows_install.grub2 menu text file can be added to the \_ISO\MAINMENU folder on the 2nd partition.
- Download the grub2_wimboot files – extract it onto the root of the 2nd partition so you have a new \wimboot folder
- Download the windows_install.grub2 file and copy it to \_ISO\MAINMENU\grub2 folder on the 2nd E2B partition. Rename it as custom_menu.grub2 if using grub2 Beta 10 or later.
- Create a new \_ISO\MAINMENU\WINDOWS folder (must be in capital letters) on the 2nd partition and place all your Windows Install ISOs in that folder.
This is for MBR booting
2nd partition (additions)
- \wimboot folder
- \_ISO\MAINMENU\grub2\custom_menu.grub2
- \_ISO\MAINMENU\WINDOWS\ (your windows isos here)
Note: E2B grub2 v10W.imgPTN already includes wimboot and a new Windows Install W menu (you just copy your ISOs to the 2nd partition!) – see next section below…
Add grub2 UEFI + wimboot (using a1ive grub2)
I suggest you use the latest E2B grub2 v10W .imgPTN file – see bottom of this page for instructions.
The following instructions are for the v10A E2B grub2 menu system and is more difficult to set up…
A1ive has added a wimboot grub2 module into his special version of grub2 (unsigned).
1. Download the grub2 UEFI zip file
2. Extract the files to the \EFI\BOOT folder on the first FAT32 partition (after switching in the E2B grub2 .imgPTN file)
3. Use the windows_install.grub2 menu file (copy to \_ISO\MAINMENU\grub2 folder)
4. Place all your Windows Install ISO files in the \_ISO\MAINMENU\WINDOWS folder – must end in .ISO or .iso.
5. Add this line into one of the customX_menu.grub2 files at the very bottom to add in the windows menu
source $isofpath/grub2/windows_install.grub2
The E2B grub2 menu system will automatically add-in any customX_menu.grub2 files but the source line is required so that it adds in the windows_install.grub2 menu (or rename it as custom3_menu.grub2 instead if you wish),
The Windows ISOs will be automatically added into the main grub2 menu when you boot. If you have placed Windows Install ISOs in the \_ISO\MAINMENU\WINDOWS folder, they should be listed in the grub2 menu when you boot.
The ISO filename can contain spaces. It must end in .ISO or .iso (case sensitive – so not .ISo for instance).
Standard Microsoft dual-architecture Install ISOs are supported, x64 will be used if the CPU is a 64-bit processor.
For MBR-booting, the menu may run bootmgr and then hang on a Virtual Machine due to the drivemap command – so test on a REAL SYSTEM if you have boot problems on a VM.
\_ISO\MAINMENU\grub2\windows_install.grub2
#WINDOWS INSTALL MENU
#$isofpath e.g. (hd0,msdos2)/_ISO/LINUX - use only in if [ -e tests
#$root2 e.g. (hd0,msdos2) partition containing payload files
#$root e.g. hd0,msdos1 boot partition with grub2 on it
#$root2uuid e.g. 1234-2123-33 (uuid of $root2)
#Special variables: MBR EFI MBR32 MBR64 EFI32 EFI64 BIT32 BIT64 FAT (true if filesystem on ptn2 is FAT)
#Examples:
#if $BIT32 ; then echo 32-bit ; fi
#if ! $BIT64 ; then echo not 64-bit ; fi
#if [ $BIT64 = true and $FAT = true ] ; then echo 64-bit MBR on FAT partititon ; fi
#if [ $BIT64 = true and $EFI = true ] ; then echo 64-bit EFI (same as \$EFI64) ; fi
#CHECK_MNU_FOLDER sets these variables on return - do not use filename and filenamex inside menuentry
#$ip e.g. /_ISO/LINUX
#$ipf e.g. (hd0,msdos2)/_ISO/LINUX
#$isofile e.g. /_ISO/LINUX/xxxx.iso
#supports filenames with spaces
function ListWimBoot {
echo Adding WINDOWS ISO files from $ifp/WINDOWS
for file in $ifp/WINDOWS/*.iso $ifp/WINDOWS/*.ISO; do
if ! test -f "$file"; then continue; fi
regexp -s filename "$ip/WINDOWS/(.*)" "$file"
regexp -s filenamex "$ip/WINDOWS/(.*)(.[iI][Ss][oO])" "$file"
# echo $file
menuentry "${filenamex}" "${filename}" {
#do not use $filename inside menuentry - use $isoname instead!
set isoname="$2" ; CHECK_MNU_FOLDER
#ip, ipf and isofile are now set correctly after CHECK_MNU_FOLDER
loopback loop "${ipf}/WINDOWS/${isoname}"
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if $MBR32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
fi
echo Using ${pp}/sources/boot.wim...
set root=$root2
set installiso="${ip}/WINDOWS/${isoname}"
save_env -f /wimboot/null.cfg installiso
# cat /wimboot/null.cfg
# read
linux16 /wimboot/wimboot
initrd16 \
# newc:bootmgr:(loop)${pp}/bootmgr \
newc:winpeshl.ini:/wimboot/winpeshl.ini \
newc:null.cfg:/wimboot/null.cfg \
newc:startup.bat:/wimboot/startup.bat \
newc:boot.wim:(loop)${pp}/sources/boot.wim \
newc:bcd:(loop)${pp}/boot/bcd \
newc:boot.sdi:(loop)${pp}/boot/boot.sdi
#swap hd0 (USB) with hd1 (internal hdd) so 'boot disk' is internal hdd
#this means may only work on real system
drivemap -s hd0 hd1
boot
}
done
}
function ListWimBootEFI {
echo Adding WINDOWS ISO files from $ifp/WINDOWS/
for file in $ifp/WINDOWS/*.iso $ifp/WINDOWS/*.ISO; do
if ! test -f "$file"; then continue; fi
regexp -s filename "$ip/WINDOWS/(.*)" "$file"
regexp -s filenamex "$ip/WINDOWS/(.*)(.[iI][Ss][oO])" "$file"
# echo $file
menuentry "${filenamex} EFI" "${filename}" {
set isoname="$2" ; CHECK_MNU_FOLDER
#ip ipf and isofile are now set correctly after CHECK_MNU_FOLDER
loopback loop "${ipf}/WINDOWS/${isoname}"
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
set bootmg=bootia32.efi
if $EFI32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
set bootmg=bootx64.efi
fi
echo Using ${pp}/sources/boot.wim...
set root=$root2
set installiso="${ip}/WINDOWS/${isoname}"
save_env -f /wimboot/null.cfg installiso
# cat /wimboot/null.cfg
# read
#NOTE: ORDER IS IMPORTANT! May get 0xC000000f error if order is wrong! boot.wim should be first.
#use wimboot --pause to see any error ( also --rawbcd --rawwim --index=1 --gui )
wimboot \
@:startup.bat:/wimboot/startup.bat \
@:winpeshl.ini:/wimboot/winpeshl.ini \
@:null.cfg:/wimboot/null.cfg \
@:boot.wim:(loop)${pp}/sources/boot.wim \
# @:bootmgfw.efi:(loop)${pp}/efi/boot/$bootmg \
@:bcd:(loop)${pp}/efi/microsoft/boot/bcd \
@:boot.sdi:(loop)${pp}/boot/boot.sdi
boot
}
done
}
if ! $EFI ; then ListWimBoot; fi
if $EFI ; then ListWimBootEFI; fi
If wimboot uses an incorrect bootmgr/bootgmfw.efi file you may get a 0xc000000f unknown error BSOD – it is often better to not specify this file and let wimboot find it.
Note that the full path of the ISO is placed in null.cfg which is later picked up by startup.bat.
Example startup.bat file:
@echo off
TITLE %~dpnx0 (WIMBOOT startup.bat)
wpeinit.exe
REM prevent wpeinit from running again
ren X:\windows\system32\wpeinit.exe wpeinit.exe.old
for %%I in (C D E F G H I J K L M N O P Q R S T U V W X Y Z) do if exist %%I:\wimboot\startup.bat set USBDRIVE=%%I:
IF "%USBDRIVE%"=="" (
echo ERROR - could not find \wimboot\startup.bat on any drive!
@echo on
for %%I in (C D E F G H I J K L M N O P Q R S T U V W X Y Z) do if exist %%I:\wimboot\startup.bat set USBDRIVE=%%I:
pause
goto :EOF
)
color 1f
cls
@echo FOUND USB DRIVE AT DRIVE %USBDRIVE%
SET BIT=32
if "%PROCESSOR_ARCHITECTURE%"=="AMD64" SET BIT=64
FOR /L %%A IN (0,1,5000) DO ECHO NOTHING > nul
:: get path of the ISO into MYISO e.g. /_ISO/WINDOWS/WIN10/Windows10ProBoth.iso
cd /d %USBDRIVE%\
set MYISO=INVALID_ISO_NAME.ISO
echo Looking for X:\Windows\System32\null.cfg contents...
for /f "tokens=1,2 delims==" %%a in ('find "installiso=" X:\Windows\System32\null.cfg') do set isopath=%%b
REM change linux forward slash to Windows backslash
set string1=%isopath:/=\%
if exist "%USBDRIVE%%string1%" set MYISO=%string1%
if not exist "%USBDRIVE%%MYISO%" if exist X:\Windows\System32\null.cfg type X:\Windows\System32\null.cfg
if not exist "%USBDRIVE%%MYISO%" echo ERROR: Can't find %USBDRIVE%%MYISO% && pause && goto :EOF
if exist "%USBDRIVE%%MYISO%" echo Loading %USBDRIVE%%MYISO%...
REM Load ISO using ImDisk
TITLE LOAD WINDOWS ISO USING IMDISK
call \wimboot\imdisk\IMDISK_install.cmd
call \wimboot\imdisk\IMDISK_instiso.cmd
REM Find mounted DVD drive
set DVDDRIVE=
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\x86\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\x86\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\SOURCES\x64\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\SOURCES\x64\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\x86\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\x86\SOURCES\install.*
)
FOR %%D IN (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) DO (
DIR %%D:\x64\SOURCES\install.* > nul 2>&1 && (call set DVDDRIVE=%%D:) && echo FOUND %%D:\x64\SOURCES\install.*
)
:ENDSEARCH
IF "%DVDDRIVE%"=="" echo WARNING: VIRTUAL DRIVE DRIVE NOT FOUND!
IF "%DVDDRIVE%"=="" echo WARNING: install.* not found on any mounted volume.
IF "%DVDDRIVE%"=="" pause
echo.
IF NOT "%DVDDRIVE%"=="" echo ISO FILE MOUNTED AS %DVDDRIVE%
REM startnet.cmd normally only contains wpeinit.exe, custom ISOs may contain other commands, so try to run them
if exist X:\WINDOWS\SYSTEM32\startnet.cmd call cmd /c X:\WINDOWS\SYSTEM32\startnet.cmd
if not exist X:\WINDOWS\SYSTEM32\startup.bat exit
IF "%DVDDRIVE%"=="" cmd
MODE CON COLS=30 LINES=2
echo DO NOT CLOSE THIS WINDOW
REM X:\Sources\setup.exe /Unattend:%E2BDRIVE%\AutoUnattend.xml
REM X:\Setup.exe will allow the repair option, X:\Sources\Setup.exe will directly run Setup
X:\setup.exe
THE BCD
You must use a standard Microsoft WinPE BCD which is usually already present in a standard Microsoft Windows Install ISO.
Special WinPE ISOs tend to contain non-standard BCDs which will give a BSOD.
If in doubt, make a new BCD file using BootIce and copy it to the \wimboot folder so you can use it with wimboot.
The files will be placed by wimboot into their standard locations inside the RAMDisk that it makes so you must use standard names and paths in the BCD.
For UEFI – BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi and boot file=\Windows\system32\boot\winload.efi
For MBR – BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi
and boot file=\Windows\system32\boot\winload.exe
If you get an error check that the winload file exists in the correct path inside the boot.wim by using 7Zip to open the ISO and \sources\boot.wim file.
Note: A solid black checkbox indicates ‘not defined in BCD’.
wimboot command line
wimboot will parse the following extra commands on the same line (e.g. linux16 /wimboot pause):
rawbcd Use raw (unpatched) BCD files
rawwim Use raw (unpatched) WIM files
gui Allow graphical output from bootmgr/bootmgfw
pause Pause before booting OS
pause=quiet Pause without displaying any prompt
index=n WIM boot index
initrdfile Ignored to allow to be used with syslinux
after processing the command line, the files in the initrd ramdrive will be loaded.
For UEFI:
wimboot [--gui] [--rawbcd] [--rawwim] [--pause] [--index=n] @:boot.wim:/path/to/test.wim @:bootmgfw.efi:/path/to/test.efi @:bcd:/path/to/bcd @:boot.sdi:/path/to/boot.sdi * params: * --gui or -g Display graphical boot messages. * --rawbcd or -b Disable rewriting .exe to .efi in the BCD file. * --rawwim or -w Disable patching the wim file. * --pause or -p * --index=n or -i n Use WIM image index n.
File Injection into \Windows\System32
Files named ‘BCD’, or ending in ‘.wim’ or ‘.sdi’ are ignored and are not injected into the X:\Windows\System32 folder.
All other files added using wimboot will be added to the X:\windows\system32 folder with the new name that you specify.
Make your own grub2 boot files
The bootx64.efi and bootia32.efi files are stub files which load grubx64.efi and grubia32.efi.
To build you own grub2 files, download a build from here.
C:\TEMP\builds-master\
- .gitignore
- build_grub.bat <<< run this
- grub-install.exe
- grub-mkimage.exe
- README.md
- +—arch
- | +—arm64
- | +—ia32
- | +—legacy
- | | \—ntboot
- | | \—NTBOOT.MOD
- | \—x64
- +—i386-efi
- +—i386-pc
- +—locale
- \—x86_64-efi
Double-click on build_grub.bat to make new core.img, grubx64.efi and grubia32.efi boot files.
The builtin.lst files under the arch folder contain a list of modules which will be added into grub2.
The EFI files will be unsigned and so will not Secure Boot.
EXAMPLE WINPE E2B .GRUB2 MENUS
Download custom2_menu.grub2 for WinPE files.
Create a .grub2 menu – e.g. \_ISO\MAINMENU\grub2\custom2_menu.grub2 in the 2nd E2B partition.
#WINDOWS PE EXAMPLES
# uses iPXE wimboot (2017-05-1) 30242 bytes http://ipxe.org/wimboot#download
# \wimboot folder on Partition 2 should contain wimboot, bootmgr, bootmgr.exe
# bootmgr.exe can be found in \Windows\Boot\PXE folder - copy it to the USB:\wimboot folder
#$isofpath e.g. (hd0,msdos2)/_ISO/LINUX - use only in if [ -e tests
#$root2 e.g. (hd0,msdos2) partition containing payload files
#$root e.g. hd0,msdos1 boot partition with grub2 on it
#$root2uuid e.g. 1234-2123-33 (uuid of $root2)
#Special variables: MBR EFI MBR32 MBR64 EFI32 EFI64 BIT32 BIT64 FAT (true if filesystem on ptn2 is FAT)
#Examples:
#if $BIT32 ; then echo 32-bit ; fi
#if ! $BIT64 ; then echo not 64-bit ; fi
#if [ $BIT64 = true and $FAT = true ] ; then echo 64-bit MBR on FAT partititon ; fi
#if [ $BIT64 = true and $EFI = true ] ; then echo 64-bit EFI (same as \$EFI64) ; fi
#CHECK_MNU_FOLDER sets these variables on return
#$ip e.g. /_ISO/LINUX
#$ifp e.g. (hd0,msdos2)/_ISO/LINUX
#$isofile e.g. /_ISO/LINUX/xxxx.iso
# ---------------------
function GetWimbootFiles {
#This function looks for files needed for iPXE WIMBOOT
#The filenames are case-sensitive, so we try to look for most likely ones!
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/Boot.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/BOOT.wim; then set pp=/x64; fi
if test -f (loop)/x64/Sources/BOOT.WIM; then set pp=/x64; fi
if $BIT32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/Boot.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/BOOT.wim; then set pp=/x86; fi
if test -f (loop)/x86/Sources/BOOT.WIM; then set pp=/x86; fi
fi
unset bme
if [ -e "/wimboot/bootmgr.exe" ]; then set bme=/wimboot/bootmgr.exe ; fi
if [ -e "(loop)/bootmgr.exe" ]; then set bme=(loop)/bootmgr.exe ; fi
if [ -e "(loop)/BOOTMGR.EXE" ]; then set bme=(loop)/BOOTMGR.EXE ; fi
if [ -e "(loop)/BOOTMGR.exe" ]; then set bme=(loop)/BOOTMGR.exe ; fi
if [ -e "(loop)/Bootmgr.exe" ]; then set bme=(loop)/Bootmgr.exe ; fi
unset bm1
if [ -e "/wimboot/bootmgr" ]; then set bm1=/wimboot/bootmgr ; fi
if [ -e "(loop)/bootmgr" ]; then set bm1=(loop)/bootmgr ; fi
if [ -e "(loop)/Bootmgr" ]; then set bm1=(loop)/Bootmgr ; fi
if [ -e "(loop)/BOOTMGR" ]; then set bm1=(loop)/BOOTMGR ; fi
unset bcd
if [ -e "(loop)${pp}/BOOT/BCD" ]; then set bcd=(loop)${pp}/BOOT/BCD ; fi
if [ -e "(loop)${pp}/BOOT/bcd" ]; then set bcd=(loop)${pp}/BOOT/bcd ; fi
if [ -e "(loop)${pp}/BOOT/Bcd" ]; then set bcd=(loop)${pp}/BOOT/bcd ; fi
if [ -e "(loop)${pp}/Boot/BCD" ]; then set bcd=(loop)${pp}/Boot/BCD ; fi
if [ -e "(loop)${pp}/Boot/bcd" ]; then set bcd=(loop)${pp}/Boot/bcd ; fi
if [ -e "(loop)${pp}/Boot/Bcd" ]; then set bcd=(loop)${pp}/Boot/bcd ; fi
if [ -e "(loop)${pp}/boot/BCD" ]; then set bcd=(loop)${pp}/boot/BCD ; fi
if [ -e "(loop)${pp}/boot/bcd" ]; then set bcd=(loop)${pp}/boot/bcd ; fi
if [ -e "(loop)${pp}/boot/Bcd" ]; then set bcd=(loop)${pp}/boot/bcd ; fi
unset sdi
if [ -e "(loop)${pp}/BOOT/BOOT.SDI" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/BOOT/boot.sdi" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/BOOT/Boot.sdi" ]; then set sdi=(loop)${pp}/BOOT/BOOT.SDI ; fi
if [ -e "(loop)${pp}/Boot/BOOT.SDI" ]; then set sdi=(loop)${pp}/Boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/Boot/boot.sdi" ]; then set sdi=(loop)${pp}/Boot/boot.sdi ; fi
if [ -e "(loop)${pp}/Boot/Boot.sdi" ]; then set sdi=(loop)${pp}/Boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/boot/BOOT.SDI" ]; then set sdi=(loop)${pp}/boot/BOOT.SDI ; fi
if [ -e "(loop)${pp}/boot/boot.sdi" ]; then set sdi=(loop)${pp}/boot/boot.sdi ; fi
if [ -e "(loop)${pp}/boot/Boot.sdi" ]; then set sdi=(loop)${pp}/boot/BOOT.sdi ; fi
unset wim
if [ -e "(loop)${pp}/sources/boot.wim" ]; then set wim=(loop)${pp}/sources/boot.wim ; fi
if [ -e "(loop)${pp}/Sources/boot.wim" ]; then set wim=(loop)${pp}/Sources/boot.wim ; fi
if [ -e "(loop)${pp}/Sources/Boot.wim" ]; then set wim=(loop)${pp}/Sources/Boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/boot.wim" ]; then set wim=(loop)${pp}/SOURCES/boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/Boot.wim" ]; then set wim=(loop)${pp}/SOURCES/Boot.wim ; fi
if [ -e "(loop)${pp}/SOURCES/BOOT.wim" ]; then set wim=(loop)${pp}/SOURCES/BOOT.wim ; fi
if [ -e "(loop)${pp}/SOURCES/BOOT.WIM" ]; then set wim=(loop)${pp}/SOURCES/BOOT.WIM ; fi
unset bmefi64
set t="(loop)${pp}/bootmgr.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/EFI/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
set t="(loop)${pp}/efi/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi64="$t" ; fi
unset bmefi32
set t="(loop)${pp}/bootmgr.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/EFI/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/Efi/BOOT/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/BOOTX64.EFI" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/Bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
set t="(loop)${pp}/efi/Boot/bootx64.efi" ; if [ -e "$t" ]; then set bmefi32="$t" ; fi
#either bootmgr.exe or bootmgr is required. It can be inside the boot.wim file
if ! [ -e /wimboot/wimboot ]; then echo ERROR: /wimboot/wimboot does not exist! Please add /wimboot folder to Partition 2 ; read ; fi
echo
if [ "$bme" = "" ]; then echo WARNING: bootmgr.exe not found ; fi
if [ "$bm1" = "" ]; then echo WARNING: bootmgr not found ; fi
if [ "$bme" = "" -a "$bm1" = "" ]; then set werr=1 ; fi
if [ "$bcd" = "" ]; then echo ERROR: BCD not found in ISO file ; set werr=1 ; fi
if [ "$sdi" = "" ]; then echo ERROR: boot.sdi not found in ISO file ; set werr=1 ; fi
if [ "$wim" = "" ]; then echo ERROR: boot.wim not found in ISO file ; set werr=1 ; fi
echo Using:
echo bm1=$bm1
echo bme=$bme
echo bcd=$bcd
echo sdi=$sdi
echo wim=$wim
echo bmefi64=$bmefi64
echo bmefi32=$bmefi32
echo --------
if [ "$werr" = "1" ]; then echo Possible error: Press a key to continue anyway... ; read ; fi
}
# ---------- Win10PESE_x64.ISO ------
if $MBR64; then
if [ -e "$isofpath/Win10PESE_x64.ISO" ]; then
menuentry "Win10PESE_x64.ISO (BIOS WIMBOOT)" --unrestricted --class windows {
set isoname=Win10PESE_x64.ISO ; CHECK_MNU_FOLDER
set root=$root2
loopback loop $isofile
GetWimbootFiles
linux16 /wimboot/wimboot pause
initrd16 \
# newc:bootmgr:$bm1 \
newc:boot.sdi:$sdi \
newc:boot.wim:$wim \
newc:bcd:$bcd
boot
}
fi
fi
#This menu will be shown for 32-bit and 64-bit CPUs
if $EFI; then
if [ -e "$isofpath/Win10PESE_x64.ISO" ]; then
menuentry "Win10PESE_x64.ISO (UEFI WIMBOOT)" --unrestricted --class windows {
set isoname=Win10PESE_x64.ISO ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
# GetWimbootFiles
set pp=
if test -f (loop)/x64/sources/boot.wim; then set pp=/x64; fi
if $EFI32; then
if test -f (loop)/x86/sources/boot.wim; then set pp=/x86; fi
fi
echo Using ${pp}/sources/boot.wim...
wimboot --pause \
@:boot.sdi:(loop)${pp}/Boot/boot.sdi \
# @:bootmgfw.efi:(loop)${pp}/efi/boot/bootx64.efi \
@:boot.wim:(loop)${pp}/sources/boot.wim \
@:bcd:(loop)${pp}/efi/microsoft/boot/bcd
boot
}
fi
fi
# ------------- Win10XPE_X64.iso ----------------------
#WORKS (wimboot doesn't work)
if $MBR64; then
if [ -e "$isofpath/Win10XPE_x64.ISO" ]; then
menuentry "Win10XPE_x64 (BIOS MEMDISK)" --unrestricted --class windows {
set isoname=Win10XPE_x64.ISO ; CHECK_MNU_FOLDER
linux16 ($root)/boot/grub/memdisk iso raw
set root=$root2
initrd16 $isofile
# drivemap -s (hd0) (hd1)
boot
}
fi
fi
# ----------- ampe64.iso ------------------
if $MBR64; then
if [ -e "$isofpath/ampe64.iso" ]; then
menuentry "ampe64.iso WORKS (BIOS WIMBOOT)" --unrestricted --class windows {
set isoname=ampe64.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop $isofile
GetWimbootFiles
linux16 /wimboot/wimboot pause
initrd16 \
# newc:bootmgr:$bm1 \
newc:boot.sdi:$sdi \
newc:boot.wim:$wim \
newc:bcd:$bcd
boot
}
fi
fi
#This menu will be shown for 32-bit and 64-bit CPUs
if $EFI; then
if [ -e "$isofpath/ampe64.iso" ]; then
menuentry "ampe64.iso (UEFI WIMBOOT)" --unrestricted --class windows {
set isoname=ampe64.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
GetWimbootFiles
if [ "$bmefi64" = "" ]; then echo ERROR: bootmgr EFI file not found ; fi
if [ "$sdi" = "" ]; then echo ERROR: boot.sdi file not found ; fi
if [ "$wim" = "" ]; then echo ERROR: boot.wim file not found ; fi
if [ "$bcd" = "" ]; then echo ERROR: BCD file not found ; fi
echo Using $wim...
wimboot --pause \
# @:bootmgfw.efi:$bmefi64 \
@:boot.sdi:$sdi \
@:boot.wim:$wim \
@:bcd:$bcd
echo boot...
read
boot
}
fi
fi
# Strelec WinPE TEST
# This menu will be shown for 32-bit and 64-bit CPUs
# Make strelec_BCD using BootIce - BCD must be set to boot from \sources\boot.wim and use \boot\boot.sdi and boot file=\Windows\system32\boot\winload.efi
# Need to obtain missing bootx64.efi from a standard Win10 ISO and add to \wimboot folder
# Once at Desktop, right-click on Strelec ISO in Explorer and MOUNT as Y: - then run MistAll from start menu
if $EFI64; then
if [ -e "$isofpath/WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso" ]; then
menuentry "TEST WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso (UEFI WINPE WIMBOOT)" --unrestricted --class windows {
set isoname=WinPE10_8_Sergei_Strelec_x86_x64_2019.02.04_English.iso ; CHECK_MNU_FOLDER
set root=$root2
loopback loop "$isofile"
wimboot --pause \
@:boot.sdi:(loop)/SSTR/boot.sdi \
@:bootmgfw.efi:/wimboot/bootx64.efi \
@:boot.wim:(loop)/SSTR/strelec10x64Eng.wim \
@:bcd:/wimboot/strelec64_BCD
boot
}
fi
fi
————————————————-
GRUB2 UEFI + WIMBOOT (IPXE)
You can use the iPXE environment instead of a grub2 environment
- \boot.ipxe – config file run by iPXE
- \ipxe64.efi – contains iPXE boot code (x64)
- \ipxe32.efi – contains iPXE boot code (32-bit)
- \wimboot – the wimboot code
- \win\boot64.wim – \win folder contains your bootable wim file (any name)
- \win\BCD2 – and name for BCD
- \win\boot.sdi – generic boot.sdi
1. Go to the ROMMatic site and create a 64-bit and 32-bit .EFI file using – Advanced – EFI PXE bootstrap xx-bit (.efi)
and paste in the following script in the Embedded script box at the bottom:
#!ipxe
chain file:/boot.ipxe
then click on Proceed and wait (if you get a timeout – try again)
2. Now you should have a ipxe64.efi file and a ipxe32.efi file which you can load from grub2:
- menuentry “iPXE wimboot” {
- chainloader /ipxe64.efi
- boot
- }
3. Create the iPXE config file \boot.ipxe
#!ipxe
#use --name for UEFI when file has different name from default
#add second virtual name for MBR booting
#ensure BCD has standard \sources\boot.wim and \sources\boot.sdi paths
ifopen
kernel file:/wimboot
initrd --name bcd file:/win/bcd2 bcd
initrd --name boot.sdi file:/win/boot.sdi boot.sdi
initrd --name boot.wim file:/win/boot64.wim boot.wim
echo
echo Platform=${platform} BuildArch=${buildarch}
echo
imgstat
prompt --timeout 5000 Press a key... ||
boot
The same boot.sdi file can be used by all Windows 7/8/10 etc. AFAIK.
4. Use BootIce to ensure that the BCD2 file has standard file paths for the boot.wim and boot.sdi
If these paths are not ‘standard’, then you will get a BSOD 0xc000000f error!
See iPXE wimboot description for more details.
The big problem with this method is that the boot.ipxe configuration file cannot be passed the path of the boot.wim file by grub. Once grub chainloads the .efi boot file, all connections with grub are lost.
This means that you can only boot to one boot.wim OR you must prompt the user to enter path of the boot.wim file by adding scripting into the boot.ipxe file,
e.g.
echo Please enter the full path of the boot.wim file...
read wimboot
- and then use
initrd --name boot.wim file:$wimboot boot.wim
in the boot.iPXE menuentry…
#!ipxe
#use --name for UEFI when file has different name from default
#add second virtual name for MBR booting
#ensure BCD has standard \sources\boot.wim and \sources\boot.sdi paths
ifopen
:getwim
imgfree
echo
echo
echo Please enter the full path of the boot.wim file...
echo Press ENTER for /win/boot64.wim
clear wimboot
echo
read wimboot
isset ${wimboot} || set wimboot /win/boot64.wim
echo wimboot=${wimboot}
#check file exists
imgfetch file:${wimboot} || goto getwim
read ask
kernel file:/wimboot
initrd --name bcd file:/win/bcd2 bcd
initrd --name boot.sdi file:/win/boot.sdi boot.sdi
initrd --name boot.wim file:${wimboot} boot.wim
echo
echo Platform=${platform} BuildArch=${buildarch}
echo
imgstat
prompt --timeout 5000 Press a key... || boot
Download files
Click here (OneDrive folder) if you cannot find any file mentioned in the articles on this site or Contact Me.
В данном уроке мы рассмотрим процесс загрузки ISO-файлов, которые находятся на вашем жестком диске, с использованием загрузчика GRUB2. Обычно для загрузки образов Linux ISO требуется создание живого DVD или USB-накопителя. Это можно выполнить как с помощью графических приложений, так и через командную строку. Однако что делать, если у вас нет оптического диска или флешки, либо ваш компьютер не поддерживает запись ISO-образов на диск?
Содержание статьи
- 1 GRUB приходит на выручку
- 2 Загрузка ISO-образов Ubuntu через GRUB2
- 3 ISO-образ Debian
- 4 Образ ISO для Arch Linux
- 5 Образ ISO Clonezilla Live
- 6 ISO-образ RHEL 8/CentOS Stream
- 7 Образ ISO для Fedora
- 8 Live ISO OpenSUSE Leap
- 9 Образ Kali Linux в формате Live ISO
- 10 Образ ISO для живой системы Linux Mint
- 11 Определение названия файла ядра Linux и initrd.
- 12 Отобразить меню загрузки GRUB.
- 13 Изменение последовательности загрузки в GRUB
- 14 Дополнительные рекомендации
- 15 Образ Windows 10 в формате ISO
- 16 Завершение
GRUB приходит на выручку
GRUB2 (GRand Unified Bootloader) представляет собой основной загрузчик для операционных систем на базе Linux. Он обладает возможностью загружать ISO-образ Linux, который хранится на жестком диске, без необходимости использования USB-накопителей или DVD-дисков. В отличие от него, GRUB Legacy (версия 0.x) не поддерживает данную функцию. Существует множество дистрибутивов Linux, которые можно загрузить непосредственно из ISO-файла.
- GRUB2 совместим с различными файловыми системами, такими как ext4, HFS+ и NTFS, что позволяет вам размещать ваш ISO-файл на любой из этих систем.
- GRUB2 способен непосредственно считывать файлы с устройств LVM и RAID.
- GRUB2 поддерживает сетевые функции. Вы можете загружать ISO-образы через сеть, применяя протокол TFTP.
Для загрузки ISO-файлов с помощью GRUB2 требуется дистрибутив Linux, на котором установлен этот загрузчик. Указанные далее шаги подходят как для классического BIOS, так и для UEFI. Важно отметить, что при использовании UEFI необходимо отключить функцию secure boot в настройках прошивки, иначе может возникнуть ошибка “can not find command loopback”.
Приступим!
Загрузка ISO-образов Ubuntu через GRUB2
Загрузите ISO-образ Ubuntu на свой компьютер с Linux, затем запустите терминал и измените файл /etc/grub. d/40_custom, используя текстовый редактор командной строки, такой как Nano.
sudo nano /etc/grub. d/40_custom
Первая строка данного файла — #! /bin/sh, что сигнализирует о том, что он является скриптом оболочки. В этом файле есть возможность добавлять пользовательские записи в меню загрузки GRUB.
Сделайте копию этого текста и вставьте его в нижнюю часть данного документа.
menuentry "ubuntu-20.04.2.0-desktop-amd64.iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/ubuntu-20.04.2.0-desktop-amd64.iso"петля обратного вызова"hd0,5)$isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet noeject noprompt splash initrd (loop)/casper/initrd >
- menuentry: Данная запись будет показана в меню загрузки GRUB2. Вы можете выбрать для нее любое название.
- Команда insmod загружает модуль. Поскольку файл ISO находится в моем домашнем каталоге на файловой системе ext4, необходимо использовать модуль ext2. Если же файл находится на разделе NTFS, следует использовать insmod ntfs. Имейте в виду, что GRUB может не поддерживать файловые системы XFS и Btrfs, поэтому не рекомендуется размещать файл ISO на разделах с этими файловыми системами.
- Установите переменную isofile: укажите путь к вашему ISO-образу. В данном случае я использую ISO-образ Ubuntu 20.04 Desktop, который хранится в папке «Загрузки».
- loopback: Подключите файл ISO. hd0 указывает на первый жесткий диск в системе, а 5 означает, что ISO-файл расположен на пятом разделе этого диска.
- Команда Linux инициирует загрузку ядра Linux из определенного местоположения. casper/vmlinuz. efi представляет собой ядро Linux, содержащееся в ISO-образе Ubuntu.
- Команда initrd отвечает за загрузку начального ramdisk из заданного пути. Ее использование возможно лишь после выполнения команды linux. Начальный ramdisk представляет собой упрощённую корневую файловую систему, размещённую в оперативной памяти. В образе ISO Ubuntu файл initrd находится по пути casper/initrd. lz.
Имейте в виду, что GRUB не делает различий между IDE и SCSI. В ядре Linux:
- /dev/hda обозначает первый жесткий диск, подключенный через интерфейс IDE.
- /dev/sda соответствует первому жесткому диску SCSI или SATA.
- /dev/nvme0n1 представляет собой первый NVMe SSD, тогда как /dev/nvme1n1 соответствует второму NVMe SSD.
В GRUB первый жесткий диск обозначается как hd0, независимо от используемого интерфейса. Кроме того, стоит отметить, что в GRUB номера разделов начинаются с 1, а не с 0.
Если файл ISO расположен на расширенном разделе диска MBR, то номер этого раздела будет начинаться с 5, а не с 1. К примеру, первый логический раздел в рамках расширенного раздела получит номер 5, а второй – номер 6. Чтобы узнать номер вашего раздела, можно воспользоваться командами lsblk или sudo parted — l в терминале.
Сохраните изменения и закройте файл. (Для сохранения файла в текстовом редакторе Nano нажмите Ctrl+O, затем подтвердите нажатием Enter. Чтобы выйти, используйте Ctrl+X.)
После этого обновите меню загрузки GRUB, выполнив следующую команду:
sudo grub-mkconfig - o /boot/grub/grub.cfg
Для Fedora, CentOS, RHEL и OpenSUSE используется следующая команда:
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
В системах Debian, Ubuntu и Linux Mint вы можете применить следующую команду для обновления меню загрузчика GRUB.
sudo update-grub
Вы можете не заметить новую запись в меню сразу, однако она станет доступна после перезагрузки компьютера.
sudo shutdown - r now
Внизу меню загрузки GRUB2 вы сможете найти вашу пользовательскую запись. Если GRUB не удается загрузить ваш ISO файл, пожалуйста, проверьте файл /etc/grub. d/40_custom на наличие ошибок или пропусков.
В файле /etc/grub. d/40_custom возможно добавить любое количество пунктов меню по вашему усмотрению.
ISO-образ Debian
Загрузите ISO-образ живого CD Debian. После этого запустите терминал и внесите изменения в файл /etc/grub. d/40_custom, используя текстовый редактор, например, Nano.
sudo nano /etc/grub. d/40_custom
В данном файле можно внести изменения в меню загрузки GRUB, добавив пользовательские записи. В нашем случае необходимо создать запись для загрузки ISO-образа Debian.
menuentry "debian-live-10.8.0-amd64-lxqt. iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/debian-live-10.8.0-amd64-lxqt. iso"петля обратного вызова"hd0,5$isoфайл linux (loop)/live/vmlinuz-4.19.0-14-amd64 загрузка=live поискiso=$isofile initrd (loop)/live/initrd. img4.19.0-14-amd64 >
Имейте в виду, что файлы vmlinuz и initrd. img содержат номер версии. Рекомендуется смонтировать ISO-образ Debian и выяснить, требуется ли обновление версии. После этого сохраните изменения и закройте файл, затем обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Образ ISO для Arch Linux
Загрузите ISO-образ Arch Linux. После этого запустите терминал и внесите изменения в файл /etc/grub. d/40_custom, используя текстовый редактор, например, Nano.
sudo nano /etc/grub. d/40_custom
В данном документе мы можем внести индивидуальные записи в меню загрузки GRUB. В этом конкретном случае мы собираемся добавить запись для загрузки ISO-образа Arch Linux.
menuentry "archlinux-2021.03.01-x86_64.iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/archlinux-2021.03.01-x86_64.iso"петля обратного вызова"hd0,5) $isofile linux (loop)/arch/boot/x86_64/vmlinuz-linux archisolabel=ARCH_202103 img_dev=/dev/sda5 img_loop=$isofile earlymodules=loop initrd (loop)/arch/boot/x86_64/initramfs-linux. img >
Имейте в виду, что при загрузке более свежей версии ISO-образа Arch Linux, например archlinux-2021.04.01-x86_64.iso, необходимо обновить archisolabel на ARCH_202104. Чтобы узнать, какое название метки должно быть, смонтируйте ISO-образ Arch Linux в файловом менеджере. Метка будет отображаться в этом менеджере.
Возможно, вам потребуется изменить значение img_dev, которое указывает на устройство, где расположен ваш ISO-файл.
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Образ ISO Clonezilla Live
Clonezilla — это бесплатный и открытый инструмент, предназначенный для надежного резервного копирования и восстановления данных с дисков. Для начала загрузите ISO-образ Clonezilla live. После этого откройте терминал и внесите изменения в файл /etc/grub. d/40_custom с помощью текстового редактора, например, Nano.
sudo nano /etc/grub. d/40_custom
В этом документе есть возможность включить индивидуальные записи в меню загрузки GRUB. В данном случае мы планируем добавить запись для загрузки ISO-образа Clonezilla Live.
menuentry "clonezilla-live-20210127-groovy-amd64.iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/clonezilla-live-20210127-groovy-amd64.iso"петля обратного вызова"hd0,5)$isofile linux (loop)/live/vmlinuz boot=live findiso=$isofile initrd (loop)/live/initrd. img >
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
ISO-образ RHEL 8/CentOS Stream
Сначала загрузите ISO-образ. Для RHEL 8 ознакомьтесь со следующей статьей, чтобы понять, как получить ISO-образ.
- Как бесплатно загрузить и установить RHEL8 (Red Hat Enterprise Linux)
ISO-образ CentOS Stream доступен для загрузки на официальном сайте.
После этого запустите терминал и внесите изменения в файл /etc/grub. d/40_custom, используя текстовый редактор, например, Nano.
sudo nano /etc/grub. d/40_custom
В этом документе есть возможность внести пользовательские записи в меню загрузки GRUB. В данном случае мы собираемся добавить запись для загрузки ISO-образа RHEL 8/CentOS/Fedora.
menuentry "rhel-8.3-x86_64-boot. iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/rhel-8.3-x86_64-boot. iso"петля обратного вызова"hd0,5) $isofile linux (loop)/isolinux/vmlinuz noeject inst. stage2=hd:/dev/sda5:$isofile initrd (loop)/isolinux/initrd. img >
В указанном коде /dev/sda5 обозначает пятый раздел первого жесткого диска, на котором располагается ISO-образ. После этого сохраните изменения и закройте файл. Затем выполните обновление меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Образ ISO для Fedora
ISO-образ Fedora доступен для загрузки на официальном сайте проекта. После этого запустите терминал и внесите изменения в файл /etc/grub. d/40_custom, используя текстовый редактор, например, Nano.
sudo nano /etc/grub. d/40_custom
В этом документе имеется возможность вставить пользовательские записи в меню загрузки GRUB. В данном случае нам необходимо добавить запись для загрузки ISO-образа Fedora.
menuentry "Fedora-Workstation-Live-x86_64-33-1.2.iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/Fedora-Workstation-Live-x86_64-33-1.2.iso"петля обратного вызова"hd0,5) $isofile linux (loop)/isolinux/vmlinuz root=liveFedora-WS-Live-33-1-2 rd. live. image verbose iso-scan/filename=$isofile initrd (loop)/isolinux/initrd. img >
В указанном коде CDLABEL представляет собой название, которое отображается в файловом менеджере при монтировании ISO-образа.
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Live ISO OpenSUSE Leap
Загрузите образ ISO OpenSUSE Leap live. Затем запустите терминал и измените файл /etc/grub. d/40_custom, используя текстовый редактор, такой как Nano.
sudo nano /etc/grub. d/40_custom
В этом документе есть возможность добавления пользовательских пунктов в меню загрузчика GRUB. В частности, мы собираемся создать запись для загрузки ISO-образа OpenSUSE Leap Live.
menuentry "openSUSE-Leap-15.2-KDE-Live-x86_64-Build31.383-Media. iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/openSUSE-Leap-15.2-KDE-Live-x86_64-Build31.383-Media. isoЦиклический возврат (hd)0,5) $isofile linux (loop)/boot/x86_64/loader/linux boot=isolinux root=liveopenSUSE_Leap_15.2_KDE_Live rd. live. image verbose iso-scan/filename=$isofile initrd (loop)/boot/x86_64/loader/initrd >
В указанном коде CDLABEL представляет собой название, которое отображается в файловом менеджере при монтировании образа ISO.
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Образ Kali Linux в формате Live ISO
Сначала загрузите образ ISO Kali Linux в режиме live. Затем запустите терминал и внесите изменения в файл /etc/grub. d/40_custom с помощью текстового редактора, такого как Nano.
sudo nano /etc/grub. d/40_custom
В этом документе мы можем внести индивидуальные записи в меню загрузки GRUB. В данном примере мы намерены добавить запись для загрузки образа Kali Linux Live ISO.
menuentry "kali-linux-2021.1-live-amd64.iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/kali-linux-2021.1-live-amd64.isoЦиклический возврат (hd)0,5)$isofile linux (loop)/live/vmlinuz boot=live findiso=$isofile initrd (loop)/live/initrd. img >
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Образ ISO для живой системы Linux Mint
Скачайте ISO-образ Linux Mint. После этого запустите терминал и внесите изменения в файл /etc/grub. d/40_custom, используя текстовый редактор, например, Nano.
sudo nano /etc/grub. d/40_custom
В этом документе можно внести пользовательские записи в меню загрузки GRUB. В данном примере мы намерены добавить запись для загрузки образа ISO Linux Mint.
menuentry "linuxmint-20.1-cinnamon-64bit. iso" < insmod ext2 set isofile color: #ff0000;">/home/linuxbabe/Downloads/linuxmint-20.1-cinnamon-64bit. isoЦиклический возврат (hd)0,5)$isofile linux (loop)/casper/vmlinuz boot=casper iso-scan/filename=$isofile quiet noeject noprompt splash initrd (loop)/casper/initrd. lz >
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Определение названия файла ядра Linux и initrd.
Ядро Linux и файл initrd (начальный ramdisk) могут отличаться в различных образах Linux ISO. Для Ubuntu ядро расположено по пути /casper/vmlinuz, а файл initrd находится по адресу /casper/initrd. Если вам не известно, где их найти, вы можете открыть ISO-образ с помощью архиватора. На следующем изображении представлен файл образа ISO Arch Linux.
Отобразить меню загрузки GRUB.
Некоторые дистрибутивы Linux, например, Ubuntu, не показывают меню загрузки GRUB, если на жестком диске установлена только одна операционная система. Чтобы вывести это меню, необходимо изменить файл конфигурации.
sudo nano /etc/default/grub
Определите следующую строку, которая указывает GRUB на скрытие загрузочного меню.
GRUB_TIMEOUT_STYLE=hidden
Вставьте знак # в начале, чтобы сделать эту строку комментарием.
#GRUB_TIMEOUT_STYLE=hidden
После этого найдите следующую строку.
GRUB_TIMEOUT=0
Поставьте значение 10 вместо 0, чтобы получить 10 секунд для выбора пункта в меню загрузки GRUB.
GRUB_TIMEOUT=10
Сохраните изменения в файле и закройте его. После этого обновите настройки GRUB.
sudo update-grub
Изменение последовательности загрузки в GRUB
Если вы хотите, чтобы ISO-файл загружался в GRUB по умолчанию, вам следует внести изменения в файл конфигурации.
sudo nano /etc/default/grub
Найдите следующую строку, которая обеспечивает выбор первого элемента в меню загрузки GRUB.
GRUB_DEFAULT=0
Пожалуйста, предоставьте текст, который вы хотите перефразировать.
GRUB_DEFAULT="clonezilla-live-20210127-groovy-amd64.iso"
Если в файле /etc/grub. d/40_custom присутствует пункт menuentry «clonezilla-live-20210127-groovy-amd64.iso», то GRUB автоматически будет выбирать этот пункт. Не забудьте обновить GRUB, чтобы изменения начали действовать.
sudo update-grub
Вы можете оставить порядок загрузки стандартным, однако загрузить ISO-файл лишь для следующей загрузки, воспользовавшись:
sudo grub-reboot clonezilla-live-20210127-groovy-amd64.iso
sudo grub2-reboot clonezilla-live-20210127-groovy-amd64.iso
sudo shutdown - r now
Дополнительные рекомендации
При наличии SATA-диска и NVMe SSD в вашем компьютере, SATA-диск будет определён как первичный, а NVMe SSD — вторичный. Аналогичная ситуация возникает и с USB-накопителем по сравнению с NVMe SSD. Если в системе есть оптический диск, GRUB может распознать его как первый диск.
Если при попытке GRUB загрузить ISO-образ возникает указанная ошибка, вероятнее всего, вы ошибочно указали путь к ISO-файлу для оптического привода.
can not get C/H/S value
Если ваша файловая система охватывает весь диск, указывать номер раздела в GRUB не потребуется. К примеру, у меня есть ISO-образ на втором диске. Так как я не создавал разделы на этом диске, в конфигурационном файле GRUB я могу просто указать (hd1).
loopback loop (hd1)$isofile
Если при обновлении меню загрузки GRUB появляется сообщение об ошибке, вы можете не обращать на него внимания.
grub-probe: error: cannot find a GRUB drive for /dev/loop11p3. Check your device. map.
Образ Windows 10 в формате ISO
Да, вы можете создать загрузочный USB с Windows 10 на Ubuntu или другом Linux-дистрибутиве. Если у вас нет USB-накопителя, вы можете использовать GRUB2 для загрузки ISO образа Windows 10 с жесткого диска. Сначала скачайте ISO файл Windows 10. Учтите, что на компьютерах с Windows эта ссылка для скачивания может быть недоступна, она предназначена для пользователей Linux.
GRUB2 не способен загрузить ISO образ Windows 10 напрямую. Для этого потребуется создать отдельный раздел с файловой системой NTFS, используя утилиту для работы с разделами, например GParted, и распаковать ISO образ Windows 10 в этот раздел. Так как размер последней версии ISO файла Windows 10 составляет 5.8 ГБ, новый NTFS раздел должен иметь объем не менее 7 ГБ и быть выделен исключительно для этой задачи, без хранения других данных.
Найдите файл с образом Windows 10 в проводнике и откройте его, используя встроенную программу для монтирования дисков.
Откройте смонтированную файловую систему, выделите все каталоги и файлы, а затем скопируйте их на раздел, отформатированный в NTFS.
Иногда файловый менеджер в Ubuntu может зависнуть, создавая впечатление, что копирование прервалось. Однако процесс продолжается. Просто нужно немного подождать. Когда появится отметка в виде галочки, это будет означать, что копирование успешно завершено.
Откройте терминал и используйте текстовый редактор, например, Nano, для редактирования файла /etc/grub. d/40_custom.
sudo nano /etc/grub. d/40_custom
В этом файле можно добавить собственные записи в меню загрузчика GRUB. В данном примере требуется добавить запись для запуска установщика Windows 10. Если ваш компьютер продолжает использовать традиционную прошивку BIOS, вставьте следующий текст в этот файл.
menuentry "Windows-10-Installer. iso" < set root=(hd0,6) insmod part_msdos insmod ntfs insmod ntldr #раскомментируйте следующую строку, если у вашего компьютера несколько жестких дисков. #drivemap - s (hd0) $ ntldr /bootmgr >
Мой NTFS-раздел имеет номер 6, поэтому в качестве корневого я указываю (hd0,6). Чтобы узнать номер вашего NTFS-раздела, можно воспользоваться командой sudo parted — l. Если на вашем компьютере установлено несколько жестких дисков, воспользуйтесь командой drivemap для того, чтобы сделать раздел (hd0,6) первым жестким диском, обеспечивая загрузку Windows.
Если на вашем компьютере установлена прошивка UEFI, вставьте следующий текст в данный файл.
menuentry "Windows-10-Installer. iso" < set root=(hd0,6) insmod part_gpt insmod ntfs insmod chain chainloader /efi/boot/bootx64.efi >
Сохраните изменения и закройте файл. После этого обновите меню загрузки GRUB.
sudo grub-mkconfig - o /boot/grub/grub.cfg
sudo grub2-mkconfig - o /boot/grub2/grub.cfg
Отключите все внешние USB-устройства, а затем перезапустите компьютер. Учтите, что ISO-образ установщика Windows для настольных систем может некорректно функционировать на виртуальных машинах Proxmox KVM.
Завершение
Надеюсь, что этот справочник оказался для вас полезным в процессе загрузки ISO-образов с помощью загрузчика GRUB2. Как всегда, если вам понравился этот материал, подписывайтесь на нашу бесплатную рассылку, чтобы не пропустить новые советы и рекомендации.
Рубрика: Администрирование / Инструменты | Дополнительные материалы |
Мой мир Вконтакте Одноклассники Google+ |
ИГОРЬ ОРЕЩЕНКОВ, инженер-программист, iharsw@tut.by
Загрузочный носитель
на основе GRUB2 for Windows
В статье рассматривается подготовка мультизагрузочного носителя для BIOS/EFI компьютеров на основе загрузчика GRUB2 в среде операционной системы Windows. Он может быть пригоден для первичной инициализации компьютера или восстановления работоспособности операционной системы компьютера
Технические требования к загрузочному носителю
Сменный загрузочный носитель, как правило, предназначен для первоначальной установки операционной системы или восстановления работоспособности компьютера. Для первого варианта использования на носителе должен находиться инсталляционный образ операционной системы с возможностью запуска процедуры установки. Во втором случае вероятно использование носителя в среде, пораженной компьютерными вирусами, откуда следует необходимость защиты его от записи на аппаратном уровне.
С учетом высказанных предпосылок в качестве загрузочного носителя удобно выбрать SD-карту. Оптические диски практически вышли из широкого обращения, а USB-флешки с аппаратной защитой от записи не везде можно встретить в продаже, и цена на них не всегда оправдана. В то же время любая SD-карта имеет переключатель защиты от записи, что в комплекте с кардридером превращает ее в недорогой, но функциональный носитель (см. рис. 1).
Рисунок 1. Из SD-карты и кардридера можно собрать функциональный носитель с аппаратной защитой от записи
Чтобы носитель можно было использовать как на компьютерах с загрузчиком BIOS, так и на платформах со схемой загрузки EFI, создадим на носителе три раздела MBR:
- Раздел FAT32 – для загрузчика GRUB2, ISO-образов специализированных дистрибутивов для восстановления работоспособности системы и Windows-утилит.
- Раздел с ISO-образом дистрибутива Mageia-6.1-Live-DVD-Xfce-i586-DVD.iso, который, будучи не требовательным к ресурсам компьютера, предоставляет полноценный рабочий стол с офисным пакетом и веб-браузером.
- Раздел с инсталляционным ISO-образом дистрибутива Mageia-6-i586-DVD.iso, который содержит в себе набор программного обеспечения, достаточный для организации как автоматизированного рабочего места офисного работника, так и для построения сервера организации.
Разметка носителя
Для хранения перечисленных выше данных будет достаточно накопителя емкостью 8 Гб. Его разметку можно выполнить под Windows с помощью штатной утилиты diskpart. Сначала нужно с помощью команды list disk вывести таблицу подключенных к компьютеру накопителей, чтобы определить, над каким выполнять операции.
C:\> diskpart
DISKPART> list disk
По значению в колонке «Размер», которое должно равняться 7580 Мбайт, определяем номер носителя для дальнейшей работы. Допустим, что в колонке «Диск ###» интересующему носителю соответствует номер 9. Очистим его содержимое.
DISKPART> select disk 9
Выбран диск 9
DISKPART> detail disk
В соответствии с принципом осмотрительности администраторов баз данных «Семь раз SELECT – один UPDATE» убедимся в правильности нашего выбора нужного сменного носителя.
В выводе команды detail disk должна содержаться следующая надпись:
USB Mass Storage Device USB Device, Тип: USB
и информация о единственном пока что разделе:
FAT32 Сменный 7576 Мб Исправен
Если сомнений больше не осталось, выполняем очистку носителя:
DISKPART> clean
После успешного выполнения команды должно появиться сообщение:
DiskPart: очистка диска выполнена успешно
Если же появилось сообщение об ошибке, например:
Программа DiskPart обнаружила ошибку: Не удается найти указанный файл
то команду нужно повторить.
Снова выводим таблицу со списком носителей:
DISKPART> list disk
Для инициализированного носителя «Диск 9» будет выведено:
Размер: 7580 Мб, Свободно 7579 Мб
Свободное пространство нужно разметить на три раздела:
- Один раздел – для ISO-образа Mageia-6-i586-DVD.iso размером 3,921,674,240 байт или 3740 Мб (если дважды разделить количество байтов на 1024).
- Второй раздел – для ISO-образа Mageia-6.1-LiveDVD-Xfce-i586-DVD.iso размером 2,028,994,560 байт или 1935 Мб.
- Третий раздел, который займет оставшееся свободным пространство, будет предназначен для загрузчика, Windows-утилит и вспомогательных загрузочных образов. Его размер составит 7579 – (3740 + 1935) = 1904 Мб.
Разделы лучше располагать на носителе в порядке, обратном перечисленному, – сначала загрузочный раздел, а после него – с ISO-образами дисков. Поэтому создадим сначала раздел размером 1904 Мб. Поскольку загрузочный носитель планируется максимально универсальным, попытаемся сделать этот раздел загрузочным по спецификации EFI:
DISKPART> create partition efi size=1904
Эта команда завершится с ошибкой и сообщением о том, что EFI-разделы поддерживаются только для GPT-дисков. К сожалению, один накопитель может быть размечен либо по схеме MBR, которую поддерживают загрузчики BIOS, либо по схеме GPT, которую поддерживают загрузчики EFI, и совместить эти схемы в пределах одного накопителя согласно разделу 5 спецификации UEFI 2.7 [8] никак не возможно.
Тем не менее практика показывает, что в большинстве случаев реальные реализации загрузчиков EFI без особых проблем распознают в качестве загрузочных разделы FAT32 с шестнадцатеричным кодом файловой системы EF, размещенные на дисках MBR. Воспользуемся этим фактом и создадим первичный MBR-раздел, после чего отформатируем его с присвоением метки BOOTDISK:
DISKPART> create partition primary size=1904
DISKPART> format FS=FAT32 LABEL="BOOTDISK" QUICK
DISKPART> set id=EF
Если между командами create partition и format по каким-то причинам пришлось завершить утилиту diskpart, то восстановить контекст после ее запуска можно командами:
DISKPART> select disk 9
DISKPART> select partition 1
При выполнении же команд в непрерывной последовательности вновь созданный раздел становится текущим автоматически, поэтому выполнять команду select partition для переключения фокуса нет необходимости.
Теперь можно создать остальные разделы. В качестве идентификатора файловой системы им нужно назначить шестнадцатеричное значение 17 (ISO 9660).
DISKPART> create partition primary size=1935
DISKPART> set id=17
DISKPART> create partition primary size=3740
DISKPART> set id=17
Каждая команда create partition должна завершаться сообщением:
Diskpart: указанный раздел успешно создан
а команда set сообщением:
Программа Diskpart успешно задала идентификатор раздела
Результат работы можно просмотреть с помощью команды list partition. А с помощью команды list disk можно убедиться, что на носителе не осталось неиспользованного пространства:
Свободно 0 байт
После этого можно завершить работу с программой diskpart:
DISKPART> exit
Запись ISO-образов в разделы накопителя
К сожалению, в операционной системе Windows нет средства, позволяющего с такой же легкостью, как утилита dd в мире UNIX, записывать файлы на устройства и обратно. Вероятно, по этой причине появился Windows-клон этой программы, которым мы воспользуемся для записи ISO-образов на разделы загрузочного накопителя.
Может возникнуть вопрос: «Зачем записывать образы ISO-дисков как «сырые данные» логических разделов и почему не записать их в виде файлов на обычный раздел, например FAT32?»
Дело в том, что образы Mageia [6] не поддерживают «петлевой» запуск из файла, как это уже давно умеют делать другие дистрибутивы, например Ubuntu и Fedora. Но поскольку они все же являются «гибридными» (то есть позволяют записывать себя как на DVD-матрицу, так и на USB-флешку), то есть шанс заставить их работать с раздела создаваемого носителя.
Для дальнейшей работы потребуется загрузить дистрибутивный архив dd-0.6beta3.zip [1] и извлечь из него программу dd.exe. Предполагается, что файлы с ISO-образами уже лежат в текущей папке.
Выясним способ адресации разделов создаваемого загрузочного носителя программой dd:
C:\> dd.exe --list
NT Block Device Objects
...
Ошибка! Недопустимый объект гиперссылки.
link to Ошибка! Недопустимый объект гиперссылки.
Removable media other than floppy. Block size = 512
size is 7948206080 bytes
Ошибка! Недопустимый объект гиперссылки.
link to Ошибка! Недопустимый объект гиперссылки.
Removable media other than floppy. Block size = 512
size is 1996488704 bytes
Ошибка! Недопустимый объект гиперссылки.
link to Ошибка! Недопустимый объект гиперссылки.
Removable media other than floppy. Block size = 512
size is 2028994560 bytes
Ошибка! Недопустимый объект гиперссылки.
link to Ошибка! Недопустимый объект гиперссылки.
Removable media other than floppy. Block size = 512
size is 3921674240 bytes
В секции NT Block Device Objects нужно отыскать группу строк, сопровождаемых текстом Removable media other than floppy («Сменный носитель, отличный от гибкого диска»). Сведения о размерах найденных разделов подтверждают предположение о том, что записи «Ошибка! Недопустимый объект гиперссылки.» относятся к недавно созданным разделам на накопителе «Ошибка! Недопустимый объект гиперссылки.».
Теперь можно выполнять команды записи ISO-образов:
C:\> dd.exe if=Mageia-6-i586-DVD.iso of=Ошибка! Недопустимый объект гиперссылки. bs=1M --progress
C:\> dd.exe if=Mageia-6.1-LiveDVD-Xfce-i586-DVD.iso of=Ошибка! Недопустимый объект гиперссылки. bs=1M --progress
С помощью параметра if= программе передается имя записываемого файла ISO-образа, через параметр of= указывается раздел накопителя, в который будет произведена запись, параметр bs= задает размер единовременно копируемого блока, а параметр —progress позволяет интерактивно наблюдать в консоли количество записанных данных (из-за большого размера файлов процесс занимает продолжительное время, которое зависит от класса SD-карты и версии интерфейса кардридера).
Успешная запись должна завершиться следующими сообщениями:
3,740M 3740+0 records in 3740+0 records out
1935M 1935+0 records in 1935+0 records out
для первого и второго образа соответственно, которые говорят о равенстве количества прочитанных и записанных данных.
Установка и проверка загрузчика
Для установки на носитель загрузчика GRUB2 нужно загрузить дистрибутивный пакет grub-2.02-for-windows.zip [2], извлечь из него папку grub-2.02-for-windows и сделать ее текущей. Для продолжения работы нужно выяснить, под какой буквой подключен в операционной системе раздел FAT32 настраиваемого носителя. Это можно сделать в программе diskpart с помощью команды list volume. Строка таблицы с нужным разделом будет содержать:
Тип: Сменный, Размер: 1904 Мб, Состояние: Непригоден
Допустим, что искомому разделу соответствует буква «R». Установка загрузчика может быть произведена командой:
C:\> grub-install.exe --boot-directory=R:\ --target=i386-PC //./PHYSICALDRIVE9
Параметр —boot-directory задает путь, где будет создана папка grub с файлами загрузчика, параметр —target указывает тип загрузки (в рассматриваемом случае это BIOS), а последний параметр задает накопитель, загрузочный сектор которого будет модифицирован. Об успешной установке должны сообщить надписи:
Installing for i386-pc platform. Installation finished. No error reported
Поскольку было принято решение о создании универсального загрузочного носителя, можно установить загрузчики для 32- и 64-битных EFI:
C:\> grub-install.exe --boot-directory=R:\ --efi-directory=R:\ --removable --target=i386-efi
C:\> grub-install.exe --boot-directory=R:\ --efi-directory=R:\ --removable --target=x86_64-efi
Параметр —efi-directory указывает, где будет создана папка EFI с модулями, необходимыми для загрузки в режиме EFI, а параметр —removable информирует инсталлятор о том, что установка производится на сменный носитель.
На этом установка загрузчика завершена. Можно проверить созданный носитель на реальных компьютерах или с помощью специализированного эмулятора QemuBootTester. Последний позволяет выбрать носитель, с которого будет произведена загрузка виртуальной машины, и полный спектр режимов загрузки: BIOS, EFI-IA32 и EFI-x64 (см. рис. 2).
Рисунок 2. Эмулятор QemuBootTester позволяет выбрать загрузочный носитель (1) и режим загрузки (2). Для тестирования загрузчика достаточно 128 Мб (3) виртуальной памяти, а виртуальный жесткий диск можно отключить. Запуск осуществляется кнопкой Run QEMU (4)
Отметим, что при подключении носителя к компьютеру под управлением Windows система отображает диалоговые окна с предложением отформатировать нераспознанные разделы, на которые записаны образы дистрибутивов Linux. Естественно, делать этого не нужно.
При выборе носителя в качестве загрузочного управление системой возьмет на себя GRUB2. Его работа должна управляться с конфигурационным файлом, который пока что отсутствует. Поэтому на экране отобразится приглашение командного режима (см. рис. 3). В нем можно сразу опробовать команды:
grub> help
– отображение списка команд;grub> help команда
– отображение подсказки по использованию команды.
Рисунок 3. В командном режиме загрузчика GRUB2 можно проанализировать конфигурацию компьютера и выполнить загрузку операционной системы в аварийном режиме
Зачастую выводится больше информации, чем может уместиться на экране. Чтобы вывод на экран приостанавливался перед прокруткой и выдачей очередной порции сведений, нужно включить режим постраничного вывода:
grub> set pager=1
Очистить экран можно командой clear. Для завершения работы GRUB2 предусмотрены команды:
grub> reboot
– перезагрузка;grub> halt
– выключение компьютера.
В компьютерах на основе Phoenix BIOS может возникнуть трудность, связанная с выбором загрузочного носителя. В предлагаемых вариантах присутствуют USB-FDD, USB-ZIP, USB-CDROM – и не ясно, какой является правильным. На самом деле – ни один из перечисленных.
Нужно через пункт меню Advanced BIOS Features → Boot Seq&Floppy Setup установить в качестве первичного устройства загрузки First Boot Device значение Hard Disk (вероятно, оно и так установлено), а в пункте меню Advanced BIOS Features → Hard Disk Boot Priority на первое место переместить значение USB-HDD0: USB Mass Storage Device. Если такой вариант для выбора отсутствует, нужно убедиться, что загрузочный носитель подключен, после чего выполнить «теплую» перезагрузку по <Ctrl> + <Alt> + <Del> и повторить процедуру.
Настройка загрузчика
Как уже было отмечено, в своей работе загрузчик GRUB2 руководствуется командами, записанными в конфигурационном файле /grub/grub.cfg на загрузочном носителе.
Язык конфигурирования очень напоминает язык командного интерпретатора bash, однако для включения поддержки некоторых конструкций нужно явным образом подключить соответствующие модули. Например, для проверки условий требуется модуль test, а для использования регулярных выражений – модуль regexp. Скомпилированные модули в файлах с расширением .mod на этапе установки GRUB2 уже были записаны в подкаталоги i386-pc, i386-efi и x86_64-efi, соответствующие режимам загрузки.
Загрузчик GRUB2 можно русифицировать. Для этого необходимо:
- записать из дистрибутива файл с русифицированными сообщениями grub-2.02-for-windows\locale\ru\grub.mo на загрузочный носитель под именем \grub\locale\ru.gmo;
- записать из дистрибутива файл со шрифтом UNICODE \grub-2.02-for-windows\unicode.pf2 на загрузочный носитель в подкаталог grub\fonts\;
- подключить модули поддержки локализации, установки графических режимов и графической консоли для отображения символов кириллицы:
grub> insmod gettext grub> insmod all_video grub> insmod gfxterm
- загрузить шрифт UNICODE, установить русский язык, задать графический режим и активировать графическую консоль:
grub> loadfont "unicode" grub> set lang=ru grub> set gfxmode=auto grub> terminal_output gfxterm
После выполнения приведенных настроек GRUB2 «заговорит» по-русски. Помимо этого открывается возможность использования файлов с заранее подготовленными подсказками на русском языке, которые можно записать на носитель в кодировке UTF-8, а в нужный момент вывести на экран с помощью команды cat:
grub> cat --dos /grub/help.txt
Ключ —dos предписывает трактовать двухбайтовые последовательности \0D\0A как символы перевода строки.
При запуске GRUB2 инициализирует некоторые переменные среды окружения, полный список которых можно вывести на экран командой set.
Так, переменная $prefix содержит путь к папке с файлами GRUB2, а переменная $grub_platform содержит идентификатор способа загрузки:
- efi – если загрузка выполнена в режиме EFI-IA32 или EFI-x64;
- pc – если загрузка выполнена в режиме BIOS.
Этот факт можно использовать для условной загрузки блоков конфигурации из файлов /grub/efi.cfg или /grub/pc.cfg для учета специфики режима или подключения пунктов меню:
insmod test
set pcfg="$prefix/$grub_platform.cfg"
if [ -e $pcfg ]; then
source $pcfg
fi
Система меню и загрузка операционных систем
В конфигурационном файле grub.cfg можно описать меню с вариантами выбора, которые будут отображаться после загрузки вместо режима командной строки:
submenu "НазваниеРазделаМеню" {
menuentry "НазваниеПунктаМеню" {
... последовательность команд ...
}
}
При этом сохраняется возможность выхода в командную строку с помощью клавиши <c>.
Для работы с файлами, находящимися на ISO-образах, удобно использовать файловый менеджер 7ZipFM [3] с подключенным в его настройках (через пункт меню «Сервис → Настройки → Редактор») текстовым редактором AkelPad [4] (см. рис. 4).
Рисунок 4. Файловый менеджер из пакета 7Zip позволяет исследовать содержимое ISO-образов и извлекать из них необходимые файлы, а текстовый редактор AkelPad дает возможность «на месте» просматривать содержимое текстовых файлов
Если требуется выполнять загрузку с ISO-образа дистрибутива Linux, который поддерживает «петлевой» запуск, то пункты меню для этих целей можно извлечь из самого конфигурационного файла загрузчика нашего дистрибутива Linux.
Например, в случае Ubuntu это будет ubuntu-18.10-desktop-amd64.iso\boot\grub\loopback.cfg (еще потребуется указать путь к файлу с ISO-образом на загрузочном носителе в переменной окружения $iso_path).
Для дистрибутива Fedora можно воспользоваться блоком меню из файла Fedora-Workstation-Live-x86_64-29-1.2.iso\EFI\BOOT\grub.cfg в качестве основы, но к параметрам ядра нужно дописать указание пути к файлу образа в виде «iso-scan/filename=…».
Множество примеров пунктов меню для «петлевого» запуска различных дистрибутивов Linux можно найти в файле \grub-2.02\docs\autoiso.cfg дистрибутивного пакета grub-2.02.tar.gz.
Описанным способом были сформированы пункты меню для запуска модулей дистрибутива System Resque CD [7], ISO-образ которого размещен в файле /ISO/systemrescuecd-x86-5.3.2.iso загрузочного носителя.
Стоит отметить метод подключения корневой файловой системы модуля NTPASSWD, предназначенного для сброса пароля администратора Windows. Она состоит из двух блоков: основного initrd.cgz и вспомогательного scsi.cgz с драйверами устройств SCSI. Их совместное использование реализовано командой:
initrd16 (loop0)/ntpasswd/initrd.cgz (loop0)/ntpasswd/scsi.cgz
Дистрибутивы Mageia не поддерживают «петлевую» загрузку, из-за чего их ISO-образы были записаны в разделы загрузочного носителя.
К сожалению, попытка выполнить запуск путем установки фокуса на содержащий дистрибутив раздел и передачи управления загрузчику командой chainloader +1 не увенчалась успехом. Это не удивительно, потому что загрузчик рассчитан на размещение в MBR, а не в загрузочный сектор раздела.
На помощь пришла команда GRUB2 syslinux_configfile, обнаруженная в эталонном конфигурационном файле \grub-2.02\docs\osdetect.cfg, который входит в состав дистрибутивного пакета grub-2.02.tar.gz. Она позволяет подключить к текущему меню GRUB2 блок, записанный в формате загрузчика isolinux. Так это выглядит для дистрибутивов Mageia:
menuentry "Mageia 6.1 Live DVD" {
search --set=root --fs-uuid 2018-10-01-18-55-31-00
syslinux_configfile -i /isolinux/isolinux.cfg
}
menuentry "Mageia 6 Installation DVD" {
search --set=root --fs-uuid 2017-07-15-07-08-52-00
syslinux_configfile -i /isolinux/isolinux.cfg
}
Команды search в приведенных примерах осуществляют поиск на доступных носителях разделов с указанными в параметрах —fs-uuid уникальными идентификаторами и делают их текущими.
Узнать значения идентификаторов разделов можно с помощью команды ls -l, введенной в командном режиме GRUB2:
grub> ls -l
...
Раздел hd0,msdos3: Тип файловой системы iso9660 – Метка "Mageia-6-i586" – Время последнего изменения 2017-07-15 07:08:52 Суббота,
UUID 2017-07-15-07-08-52-00 – Раздел начинается с 3932160КиБ – Общий размер 3829760КиБ
Раздел hd0,msdos2: Тип файловой системы iso9660 – Метка "Mageia-6.1-Xfce-LiveDVD" – Время последнего изменения 2018-10-01 18:55:31 Понедельник,
UUID 2018-10-01-18-55-31-00 – Раздел начинается с 1950720КиБ – Общий размер 1981440КиБ
...
Команды syslinux_configfile подключают блоки меню из файлов isolinux.cfg на найденных разделах. Эстетический недостаток этого способа состоит в том, что вместо описаний пунктов меню на экране будут отображаться их метки. Но зато сохраняется функциональность.
Образ LiveDVD работает без замечаний – так, как будто был использован обычный загрузочный носитель. А для образа инсталляционного диска придется указать местонахождение установочных файлов. Для этого:
- в окне с сообщением I can’t access a Mageia Installation disc in your CDROM drive нажать кнопку No;
- в окне запроса носителя с установочными файлами (Please select the disk containing the copy of the Mageia Distribution install source) выбрать устройство USB Mass Storage Device;
- в окне запроса раздела (Please select the partition containing the copy of the Mageia Distribution install source) выбрать третий раздел размером 3740 Мбайт;
- в окне ввода пути к установочным файлам поле Please select directory оставить пустым – просто нажать <Enter>.
Установочные файлы будут найдены, запустится инсталлятор, и установка продолжится в штатном режиме.
Заключение
В результате выполнения приведенных в статье рекомендаций в среде операционной системы Windows с использованием штатных средств и минимального набора стороннего программного обеспечения может быть создан универсальный мультизагрузочный носитель на базе GRUB2, пригодный для первичной инициализации компьютера или восстановления работоспособности операционной системы компьютера.
В статье рассмотрен способ подключения блоков загрузочного меню из конфигурационных файлов загрузчиков SysLinux/IsoLinux с помощью команды syslinux_configfile.
На сайте журнала http://samag.ru приведен рабочий вариант конфигурационного файла GRUB2 для загрузочного носителя BIOS/EFI с возможностью запуска модулей SystemResqueCD, получения рабочей среды на базе GNU/Linux Mageia 6 и установки этой операционной системы, который содержит.
- grub.cfg – основной конфигурационный файл GRUB2;
- pc.cfg – блок меню, специфичный для загрузки в режиме BIOS;
- efi.cfg – блок меню, специфичный для загрузки в режиме EFI;
- help.txt – файл с подсказкой о процедуре загрузки Windows;
- helpefi.txt – файл с описанием особенностей использования SystemRescueCD в режиме EFI.
При изучении возможностей GRUB2, помимо интернет-источников [5], целесообразно использовать справочную информацию, имеющуюся в папке \grub-2.02\docs\ дистрибутивного пакета grub-2.02.tar.gz:
- grub.info – документация на английском языке, которая может быть просмотрена в любом текстовом редакторе;
- grub.cfg – конфигурационный файл, содержащий основные примеры загрузки операционных систем;
- autoiso.cfg – конфигурационный файл, содержащий примеры загрузки операционных систем в «петлевом» режиме из файлов ISO-образов;
- osdetect.cfg – конфигурационный файл, содержащий сценарии поиска загрузочных разделов для множества операционных систем с последующей их загрузкой.
В ходе подготовки загрузочного носителя следует сконцентрировать внимание на выполняемых действиях. Ошибка в набранной команде может привести к необратимой потере информации, хранящейся на компьютере.
- Утилита DD для Windows – http://www.chrysocome.net/dd.
- Загрузчик GRUB2 – ftp://ftp.gnu.org/gnu/grub/.
- Архиватор и файловый менеджер 7Zip – https://www.7-zip.org.
- Текстовый редактор AkelPad – http://akelpad.sourceforge.net/.
- Cтатьи о загрузочных носителях – https://www.bootdev.ru.
- Mageia GNU/Linux – http://www.mageia.org/ru/.
- System Rescue CD – http://www.system-rescue-cd.org.
- Спецификация UEFI 2.7 – http://www.uefi.org/sites/default/files/resources/UEFI%20Spec%202_7_A%20Sept%206.pdf.
Ключевые слова: Linux, rescue.
Мой мир
Вконтакте
Одноклассники
Google+