661 lines
33 KiB
Python
661 lines
33 KiB
Python
"""
|
|
SPDX-FileCopyrightText: 2023-2025 PeppermintOS Team
|
|
(peppermintosteam@proton.me)
|
|
|
|
SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
This module handles the creation of bootloaders for different architectures and boot methods.
|
|
|
|
Credits:
|
|
- PeppermintOS Team (peppermintosteam@proton.me) - Development and maintenance of the project.
|
|
|
|
License:
|
|
This code is distributed under the GNU General Public License version 3 or later (GPL-3.0-or-later).
|
|
For more details, please refer to the LICENSE file included in the project or visit:
|
|
https://www.gnu.org/licenses/gpl-3.0.html
|
|
"""
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import logging
|
|
import sys
|
|
import contextlib
|
|
|
|
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
sys.path.insert(0, BASE_DIR)
|
|
|
|
try:
|
|
from builder.configs import logger_config
|
|
from builder.core.copy_customizations import copy_grub_theme
|
|
except ImportError as e:
|
|
print(f"Error importing necessary modules: {e}. Ensure your environment is set up correctly. Details: {e}")
|
|
sys.exit(1)
|
|
|
|
logger = logger_config.setup_logger('bootloaders')
|
|
|
|
|
|
|
|
def create_isolinux_boot(architecture, kernel_version, initrd_path, boot_title, paths, keymap="us", locale="en_US.UTF-8", boot_cmdline="", Volume_ID=""):
|
|
"""Generates Isolinux bootloader for BIOS."""
|
|
logger.info("=> Starting Isolinux bootloader generation...")
|
|
|
|
isolinux_dir = os.path.join(paths['IMAGEDIR'], 'boot', 'isolinux')
|
|
boot_dir = os.path.join(paths['IMAGEDIR'], 'boot')
|
|
os.makedirs(isolinux_dir, exist_ok=True)
|
|
|
|
boot_cat_path = os.path.join(isolinux_dir, "boot.cat")
|
|
open(boot_cat_path, 'w').close()
|
|
logger.info(f"=> Created empty boot.cat file: {boot_cat_path} (will be populated by mkisofs/xorriso)")
|
|
|
|
syslinux_data_dir = os.path.join(paths['PEPTARGETDIR'], "usr/lib/syslinux")
|
|
SPLASH_DIR = paths['SPLASH_DIR']
|
|
TEMPLATES_DIR = paths['TEMPLATES_DIR']
|
|
splash_image_path = os.path.join(SPLASH_DIR, "splash.png")
|
|
|
|
logger.info(f"=> Destination Isolinux directory: {isolinux_dir}")
|
|
logger.info(f"=> Syslinux data source directory: {syslinux_data_dir}")
|
|
logger.info(f"=> Splash image path: {splash_image_path}")
|
|
|
|
syslinux_files = [
|
|
"isolinux.bin", "ldlinux.c32", "libcom32.c32", "vesamenu.c32",
|
|
"libutil.c32", "chain.c32", "reboot.c32", "poweroff.c32"
|
|
]
|
|
logger.info("=> Copying Syslinux files...")
|
|
for file in syslinux_files:
|
|
source_file = os.path.join(syslinux_data_dir, file)
|
|
destination_file = os.path.join(isolinux_dir, file)
|
|
if os.path.exists(source_file):
|
|
shutil.copy2(source_file, destination_file)
|
|
logger.debug(f" Copied: {file}")
|
|
else:
|
|
logger.warning(f" Syslinux file not found: {source_file}. Ignoring.")
|
|
|
|
logger.info("=> Copying and configuring isolinux.cfg...")
|
|
isolinux_cfg_in_path = os.path.join(TEMPLATES_DIR, "isolinux", "isolinux.cfg.in")
|
|
isolinux_cfg_path = os.path.join(isolinux_dir, "isolinux.cfg")
|
|
try:
|
|
with open(isolinux_cfg_in_path, 'r') as f_in:
|
|
isolinux_cfg_content = f_in.read()
|
|
|
|
replacements = {
|
|
"@@SPLASHIMAGE@@": os.path.basename(splash_image_path),
|
|
"@@KERNVER@@": kernel_version,
|
|
"@@INITRD@@": os.path.basename(initrd_path),
|
|
"@@KEYMAP@@": keymap,
|
|
"@@ARCH@@": architecture,
|
|
"@@LOCALE@@": locale,
|
|
"@@BOOT_TITLE@@": boot_title,
|
|
"@@BOOT_CMDLINE@@": boot_cmdline,
|
|
"@@Volume_ID@@": Volume_ID
|
|
}
|
|
|
|
kernel_image_name = "vmlinuz" if architecture.startswith('x86') or architecture.startswith('i686') else "vmlinux"
|
|
replacements["@@KERNELIMAGE@@"] = kernel_image_name
|
|
|
|
|
|
for placeholder, value in replacements.items():
|
|
isolinux_cfg_content = isolinux_cfg_content.replace(placeholder, value)
|
|
|
|
with open(isolinux_cfg_path, 'w') as f_out:
|
|
f_out.write(isolinux_cfg_content)
|
|
logger.debug(f" isolinux.cfg file created at: {isolinux_cfg_path}")
|
|
except FileNotFoundError:
|
|
logger.error(f" isolinux.cfg.in template file not found: {isolinux_cfg_in_path}. Failed to create isolinux.cfg")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f" Error processing or creating isolinux.cfg: {e}")
|
|
return None
|
|
|
|
logger.info("=> Copying splash image...")
|
|
if os.path.exists(splash_image_path):
|
|
splash_destination_path = os.path.join(isolinux_dir, os.path.basename(splash_image_path))
|
|
shutil.copy2(splash_image_path, splash_destination_path)
|
|
logger.debug(f" Splash image copied to: {splash_destination_path}")
|
|
else:
|
|
logger.warning(f" Splash image not found: {splash_image_path}. Ignoring.")
|
|
|
|
memtest_files = {
|
|
"memtest.bin": os.path.join(paths['PEPTARGETDIR'], "boot", "memtest86+", "memtest.bin"),
|
|
"memtest.efi": os.path.join(paths['PEPTARGETDIR'], "boot", "memtest86+", "memtest.efi")
|
|
}
|
|
for filename, source_path in memtest_files.items():
|
|
dest_path = os.path.join(boot_dir, filename)
|
|
if os.path.exists(source_path):
|
|
logger.info(f"=> Copying {filename}...")
|
|
shutil.copy2(source_path, dest_path)
|
|
logger.debug(f" {filename} copied to: {dest_path}")
|
|
else:
|
|
logger.info(f"=> {filename} not found in PEPTARGETDIR. Ignoring.")
|
|
|
|
logger.info("=> Isolinux bootloader generated successfully.")
|
|
return isolinux_dir
|
|
|
|
def create_grub_efi_boot(architecture, kernel_version, initrd_path, boot_title, iso_build_config, repositories_data, paths, keymap="us", locale="en_US.UTF-8", boot_cmdline="", Volume_ID="", config=None, logger_instance=None, pep_target_path=None, splash_image=None):
|
|
"""
|
|
Generates GRUB EFI bootloader for UEFI systems.
|
|
|
|
Args:
|
|
architecture (str): Target architecture (e.g., 'x86_64', 'aarch64').
|
|
kernel_version (str): The full kernel version string (e.g., '6.1.130_1').
|
|
initrd_path (str): The path to the generated initramfs file (in the ISO BOOT directory).
|
|
boot_title (str): The title for the boot menu entry.
|
|
iso_build_config (dict): Dictionary containing ISO build configuration.
|
|
repositories_data (list): List of repository dictionaries.
|
|
paths (dict): Dictionary containing all build paths (IMAGEDIR, PEPTARGETDIR, etc.).
|
|
keymap (str, optional): Keymap to use (default: 'us').
|
|
locale (str, optional): Locale to use (default: 'en_US.UTF-8').
|
|
boot_cmdline (str, optional): Additional kernel command line arguments.
|
|
Volume_ID (str, optional): Volume ID for the ISO filesystem.
|
|
config (dict, optional): General configuration dictionary.
|
|
logger_instance (logging.Logger, optional): Logger instance to use.
|
|
pep_target_path (str, optional): Path to the PEPTARGETDIR (redundant if paths is used).
|
|
splash_image (str, optional): Path to the splash image (redundant if paths is used).
|
|
"""
|
|
# Use the passed logger instance if available, otherwise use the module logger
|
|
logger = logger_instance if logger_instance is not None else logging.getLogger('bootloaders')
|
|
|
|
logger.info("=> Starting GRUB EFI bootloader generation...")
|
|
|
|
# Use paths dictionary passed as argument for all path-related operations
|
|
grub_dir = os.path.join(paths['IMAGEDIR'], 'boot', 'grub')
|
|
pep_target_path = paths['PEPTARGETDIR'] # Use path from dictionary
|
|
iso_image_boot_dir = os.path.join(paths['IMAGEDIR'], 'boot') # Use path from dictionary
|
|
grub_data_dir = os.path.join(pep_target_path, "usr/share/grub") # Use path from dictionary
|
|
TEMPLATES_DIR = paths['TEMPLATES_DIR'] # Use path from dictionary
|
|
SPLASH_DIR = paths['SPLASH_DIR'] # Use path from dictionary
|
|
# SPLASH_THEMES_DIR = os.path.join(BASE_DIR, "peppermint/grub/themes") # This path seems relative to BASE_DIR, ensure it's correct
|
|
SPLASH_THEMES_DIR = os.path.join(paths['BUILDDIR'], "peppermint", "grub", "themes") # Assuming peppermint/grub/themes is within BUILDDIR or similar
|
|
|
|
os.makedirs(grub_dir, exist_ok=True)
|
|
|
|
# Copy GRUB theme - assuming copy_grub_theme is defined elsewhere
|
|
# The destination should be within the ISO's boot directory structure
|
|
copy_grub_theme(SPLASH_THEMES_DIR, os.path.join(paths['IMAGEDIR'], 'boot'))
|
|
|
|
|
|
# 1. Copy additional files from TEMPLATES_DIR
|
|
logger.info("=> Copying additional template files to the GRUB directory...")
|
|
|
|
# Source directory for templates
|
|
templates_grub_dir = os.path.join(TEMPLATES_DIR, "grub")
|
|
|
|
# List of files to copy (grub.cfg will be generated, not copied directly as a template)
|
|
# We will generate grub.cfg content later.
|
|
files_to_copy = [] # No files to copy directly, grub.cfg is generated
|
|
|
|
# If you have other static files in templates_grub_dir to copy, list them here
|
|
# for filename in files_to_copy:
|
|
# source_path = os.path.join(templates_grub_dir, filename)
|
|
# dest_path = os.path.join(grub_dir, filename)
|
|
# if os.path.exists(source_path):
|
|
# shutil.copy2(source_path, dest_path)
|
|
# logger.debug(f" Copied template file: {filename} to: {dest_path}")
|
|
# else:
|
|
# logger.warning(f" Template file not found: {filename} in: {source_path}")
|
|
|
|
|
|
# Copy splash image from SPLASH_DIR to grub_dir
|
|
# The splash image needs to be accessible by GRUB, usually in the same dir as grub.cfg or themes dir
|
|
splash_source = os.path.join(SPLASH_DIR, "splash.png")
|
|
splash_dest = os.path.join(grub_dir, "splash.png") # Copy to grub_dir
|
|
|
|
if os.path.exists(splash_source):
|
|
shutil.copy2(splash_source, splash_dest)
|
|
logger.debug(f" Copied splash image from: {splash_source} to: {splash_dest}")
|
|
else:
|
|
logger.warning(f" Splash image not found in: {splash_source}")
|
|
|
|
# Determine kernel image name based on architecture
|
|
kernel_img_name = "vmlinuz"
|
|
want_memtest = True # Memtest is typically for x86
|
|
if architecture == "aarch64":
|
|
kernel_img_name = "vmlinux"
|
|
want_memtest = False # Memtest86+ is for x86
|
|
elif architecture == "x86_64":
|
|
kernel_img_name = "vmlinuz"
|
|
want_memtest = True # Memtest86+ is for x86
|
|
elif architecture == "i686":
|
|
kernel_img_name = "vmlinuz"
|
|
want_memtest = True # Memtest86+ is for x86
|
|
|
|
|
|
logger.info(f"=> Destination GRUB directory: {grub_dir}")
|
|
logger.info(f"=> GRUB data source directory: {grub_data_dir}")
|
|
logger.info(f"=> Kernel image name for GRUB config: {kernel_img_name}")
|
|
logger.info(f"=> Include memtest86+ in GRUB config: {want_memtest}")
|
|
|
|
# 1. Prepare GRUB directory and copy font (Moved this up)
|
|
logger.info("=> Preparing GRUB directory and copying fonts...")
|
|
os.makedirs(os.path.join(grub_dir, "fonts"), exist_ok=True)
|
|
unicode_pf2_source = os.path.join(grub_data_dir, "unicode.pf2")
|
|
unicode_pf2_dest = os.path.join(grub_dir, "fonts", "unicode.pf2")
|
|
if os.path.exists(unicode_pf2_source):
|
|
shutil.copy2(unicode_pf2_source, unicode_pf2_dest)
|
|
logger.debug(f" Copied unicode.pf2 font to: {unicode_pf2_dest}")
|
|
else:
|
|
logger.warning(f" unicode.pf2 font not found in: {unicode_pf2_source}. Ignoring.")
|
|
|
|
|
|
# 2. Create EFI vfat image
|
|
# This image will contain the EFI bootloader (BOOT{arch}.EFI) and grub.cfg
|
|
logger.info("=> Creating EFI vfat image (efiboot.img)...")
|
|
efi_img_path = os.path.join(grub_dir, "efiboot.img")
|
|
efi_img_size_mb = 32 # Size in MB
|
|
try:
|
|
# Use a fixed size for the EFI image
|
|
subprocess.run(["truncate", "-s", f"{efi_img_size_mb}M", efi_img_path], check=True)
|
|
# Format as VFAT, label it
|
|
subprocess.run(["mkfs.vfat", "-F12", "-S", "512", "-n", "grub_uefi", efi_img_path], check=True)
|
|
logger.debug(f" EFI vfat image created: {efi_img_path} with size {efi_img_size_mb}MB")
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error(f" Error creating EFI vfat image: {e.stderr.decode('utf-8', errors='ignore')}")
|
|
return None
|
|
except FileNotFoundError as e:
|
|
logger.error(f" Command not found: {e}. Make sure truncate and mkfs.vfat are installed on the host.")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f" Unexpected error during EFI vfat image creation: {e}")
|
|
return None
|
|
|
|
|
|
# 3. Mount vfat image and build GRUB image function
|
|
grub_efi_tmpdir = None # Initialize to None
|
|
loop_device = None # Initialize to None
|
|
try:
|
|
# Create a temporary directory to mount the vfat image
|
|
grub_efi_tmpdir = tempfile.mkdtemp(dir=paths['BUILDDIR'], prefix="grub-efi.")
|
|
|
|
# Find a free loop device and attach the vfat image
|
|
loop_device_output = subprocess.run(["losetup", "--show", "--find", efi_img_path], check=True, text=True, capture_output=True)
|
|
|
|
if loop_device_output.returncode != 0:
|
|
logger.error(f" Error attaching loop device for {efi_img_path}. Stderr: {loop_device_output.stderr.strip()}")
|
|
return None
|
|
|
|
loop_device = loop_device_output.stdout.strip()
|
|
logger.debug(f" Attached loop device: {loop_device}")
|
|
|
|
# Mount the vfat image to the temporary directory
|
|
subprocess.run(["mount", "-o", "rw,loop", loop_device, grub_efi_tmpdir], check=True) # Removed offset=0 as it's not always needed and can cause issues
|
|
logger.debug(f" EFI vfat image mounted at: {grub_efi_tmpdir}")
|
|
|
|
# Copy boot directory contents (kernel, initrd, etc.) to the mounted vfat image
|
|
# This step copies the kernel image, initramfs, and any other boot files
|
|
# from the ISO's boot staging directory to the EFI partition.
|
|
# The source is the directory where kernel/initrd were copied in iso_builder_main
|
|
# The destination is the root of the mounted EFI image
|
|
logger.info("=> Copying boot directory contents to the mounted EFI image...")
|
|
# Assuming iso_image_boot_dir is the directory containing vmlinuz/vmlinux and initrd
|
|
source_boot_contents = iso_image_boot_dir # This is the directory like /files/builder.../fusato/image/boot
|
|
destination_efi_root = grub_efi_tmpdir # This is the temporary mount point
|
|
|
|
# Copy all contents from source_boot_contents to destination_efi_root
|
|
# Use a robust copy method like rsync or shutil.copytree
|
|
# shutil.copytree(source_boot_contents, destination_efi_root, dirs_exist_ok=True) # Requires Python 3.8+
|
|
# Alternative using subprocess and rsync
|
|
try:
|
|
subprocess.run(["rsync", "-a", f"{source_boot_contents}/", destination_efi_root], check=True)
|
|
logger.debug(f" Boot directory contents copied from {source_boot_contents} to {destination_efi_root}")
|
|
except FileNotFoundError as e:
|
|
logger.error(f" Command not found: {e}. Make sure rsync is installed on the host.")
|
|
return None
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error(f" Error copying boot directory contents with rsync: {e.stderr.decode('utf-8', errors='ignore')}")
|
|
return None
|
|
|
|
|
|
# Generate the content of grub_pep.cfg
|
|
# This file will be placed in the mounted EFI partition (/EFI/BOOT/grub.cfg or similar)
|
|
# The actual path where GRUB looks depends on the architecture and the grub-mkstandalone call
|
|
# Let's generate it in the grub_dir first and then decide where it goes in the EFI image
|
|
# It's common to place it in /EFI/BOOT/grub.cfg or /grub/grub.cfg within the EFI partition
|
|
# The grub-mkstandalone command below specifies the config file path within the EFI image.
|
|
# Let's generate it directly in the mounted EFI partition for simplicity.
|
|
grub_pep_cfg_path_in_efi = os.path.join(grub_efi_tmpdir, "grub", "grub.cfg") # Common path within EFI partition
|
|
os.makedirs(os.path.dirname(grub_pep_cfg_path_in_efi), exist_ok=True) # Ensure directory exists
|
|
|
|
# Ensure config is passed if needed by generate_grub_pep_cfg
|
|
desktop_environment = config.get("desktop", "XFCE") if config else "XFCE"
|
|
kernel_flavor_name = config.get("kernel_flavor", "current") if config else "current"
|
|
|
|
|
|
logger.debug(f" Value of boot_cmdline being passed to generate_grub_pep_cfg: '{boot_cmdline}'")
|
|
|
|
# Assuming generate_grub_pep_cfg is defined elsewhere and imported
|
|
grub_pep_cfg_content = generate_grub_pep_cfg(
|
|
kernel_version=kernel_version, # Use the kernel_version argument
|
|
initrd_filename=os.path.basename(initrd_path), # Pass just the filename
|
|
kernel_image_filename=kernel_img_name, # Pass just the filename
|
|
boot_cmdline=boot_cmdline, # Use the boot_cmdline argument
|
|
boot_title=boot_title, # Use the boot_title argument
|
|
keymap=keymap, # Use the keymap argument
|
|
locale=locale, # Use the locale argument
|
|
architecture=architecture, # Use the architecture argument
|
|
want_memtest=want_memtest, # Use the determined want_memtest
|
|
# splash_image and SPLASH_DIR might be used by generate_grub_pep_cfg
|
|
# Ensure they are passed if needed by that function
|
|
splash_image=splash_image, # Use the splash_image argument
|
|
SPLASH_DIR=SPLASH_DIR # Use the SPLASH_DIR argument
|
|
)
|
|
|
|
# Write the content to the grub.cfg file in the mounted EFI partition
|
|
with open(grub_pep_cfg_path_in_efi, "w") as f:
|
|
f.write(grub_pep_cfg_content)
|
|
logger.info(f" grub.cfg generated at: {grub_pep_cfg_path_in_efi} (inside mounted EFI image)")
|
|
|
|
|
|
def build_grub_image_internal(target_architecture, grub_efi_tmpdir, pep_target_path):
|
|
"""Internal function to build the GRUB EFI image for a specific architecture."""
|
|
logger.info(f"Building GRUB EFI image for architecture: {target_architecture}")
|
|
|
|
# Determine GRUB platform and EFI boot filename based on target architecture
|
|
grub_platform = ""
|
|
efi_boot_filename = ""
|
|
if target_architecture == "x86_64":
|
|
grub_platform = "x86_64-efi"
|
|
efi_boot_filename = "BOOTX64.EFI"
|
|
elif target_architecture == "aarch64":
|
|
grub_platform = "arm64-efi"
|
|
efi_boot_filename = "BOOTAA64.EFI"
|
|
elif target_architecture == "i686":
|
|
grub_platform = "i386-efi"
|
|
efi_boot_filename = "BOOTIA32.EFI"
|
|
else:
|
|
logger.error(f" Unsupported architecture for GRUB EFI build: {target_architecture}")
|
|
return None # Or raise an exception
|
|
|
|
logger.info(f" => Building GRUB EFI image for platform: {grub_platform}")
|
|
|
|
# grub-mkstandalone command to create the EFI bootloader
|
|
# Output is directed to a temporary file within the uchroot environment's /tmp
|
|
# The input config file path is relative to the root of the mounted EFI partition
|
|
# which is also the root of the uchroot environment for this command.
|
|
efi_file_tmp_path_in_uchroot = f"/tmp/{efi_boot_filename.lower()}" # Temporary path inside uchroot /tmp
|
|
|
|
grub_mkstandalone_command = [
|
|
"xbps-uchroot",
|
|
pep_target_path, # The rootfs to use for uchroot
|
|
"grub-mkstandalone",
|
|
"--", # Arguments for grub-mkstandalone start here
|
|
f"--directory=/usr/lib/grub/{grub_platform}", # GRUB modules directory in the target rootfs
|
|
f"--format={grub_platform}", # Output format
|
|
f"--output={efi_file_tmp_path_in_uchroot}", # Output path inside uchroot /tmp
|
|
"/grub/grub.cfg" # Path to the grub.cfg file relative to the uchroot root (mounted EFI partition root)
|
|
]
|
|
logger.debug(f" => Executing grub-mkstandalone command [UCHROOT: {pep_target_path}]: {' '.join(grub_mkstandalone_command)}")
|
|
|
|
try:
|
|
subprocess.run(grub_mkstandalone_command, check=True, text=True, capture_output=True)
|
|
logger.debug(f" grub-mkstandalone command executed successfully.")
|
|
# logger.debug(f" grub-mkstandalone stdout: {result.stdout.strip()}") # Uncomment for verbose debug
|
|
# logger.debug(f" grub-mkstandalone stderr: {result.stderr.strip()}") # Uncomment for verbose debug
|
|
|
|
except FileNotFoundError as e:
|
|
logger.error(f" Command not found: {e}. Make sure grub-mkstandalone is installed in the target rootfs.")
|
|
return None
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error(f" Error generating EFI loader (grub-mkstandalone): Exit code {e.returncode}")
|
|
logger.error(f" Command: {' '.join(e.cmd)}")
|
|
logger.error(f" Stdout: {e.stdout.strip()}")
|
|
logger.error(f" Stderr: {e.stderr.strip()}")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f" Unexpected error during grub-mkstandalone: {e}")
|
|
return None
|
|
|
|
# Copy the generated EFI file from the uchroot environment's /tmp to the mounted EFI partition
|
|
# The file is generated at pep_target_path/tmp/boot{arch}.efi on the host filesystem
|
|
efi_source_path_on_host = os.path.join(pep_target_path, "tmp", os.path.basename(efi_file_tmp_path_in_uchroot))
|
|
efi_boot_dir_in_tmpfs = os.path.join(grub_efi_tmpdir, "EFI", "BOOT")
|
|
efi_file_destination_in_efi = os.path.join(efi_boot_dir_in_tmpfs, efi_boot_filename)
|
|
|
|
logger.debug(f" => Creating EFI/BOOT directory in mounted EFI image: {efi_boot_dir_in_tmpfs}")
|
|
os.makedirs(efi_boot_dir_in_tmpfs, exist_ok=True)
|
|
|
|
logger.debug(f" => Copying generated EFI loader from host path: {efi_source_path_on_host} to mounted EFI path: {efi_file_destination_in_efi}")
|
|
try:
|
|
shutil.copy2(efi_source_path_on_host, efi_file_destination_in_efi)
|
|
logger.debug(f" EFI loader copied successfully.")
|
|
except FileNotFoundError:
|
|
logger.error(f" Error: Generated EFI loader not found at host path: {efi_source_path_on_host}")
|
|
logger.error(f" grub-mkstandalone might have failed to create the output file.")
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f" Unexpected error while copying EFI loader: {e}")
|
|
return None
|
|
|
|
return efi_file_destination_in_efi # Return path to the copied EFI file
|
|
|
|
|
|
# Build EFI images for relevant architectures
|
|
# For x86_64, you might want both BOOTX64.EFI and BOOTIA32.EFI for compatibility
|
|
# For aarch64, only BOOTAA64.EFI is needed
|
|
efi_images = {} # Dictionary to store paths to generated EFI files
|
|
|
|
if architecture == "x86_64":
|
|
# Build for x86_64 (BOOTX64.EFI)
|
|
efi_images["x86_64"] = build_grub_image_internal("x86_64", grub_efi_tmpdir, pep_target_path)
|
|
# Optionally build for i686 (BOOTIA32.EFI) for compatibility
|
|
# efi_images["i686"] = build_grub_image_internal("i686", grub_efi_tmpdir, pep_target_path)
|
|
|
|
elif architecture == "aarch64":
|
|
# Build only for aarch64 (BOOTAA64.EFI)
|
|
efi_images["aarch64"] = build_grub_image_internal("aarch64", grub_efi_tmpdir, pep_target_path)
|
|
|
|
elif architecture == "i686":
|
|
# Build only for i686 (BOOTIA32.EFI)
|
|
efi_images["i686"] = build_grub_image_internal("i686", grub_efi_tmpdir, pep_target_path)
|
|
else:
|
|
logger.warning(f"Unsupported architecture for GRUB EFI build: {architecture}. Skipping EFI bootloader generation.")
|
|
|
|
|
|
# Check if EFI images were successfully built
|
|
if not efi_images or any(img is None for img in efi_images.values()):
|
|
logger.error("=> Failed to build one or more GRUB EFI images.")
|
|
# Decide whether to return None or raise an exception based on how critical this is
|
|
return None
|
|
|
|
|
|
logger.info("=> GRUB EFI bootloader generated successfully.")
|
|
return grub_dir # Return the path to the grub directory containing efiboot.img
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
logger.error(f"Error executing subprocess commands for GRUB EFI: Exit code {e.returncode}")
|
|
logger.error(f"Command: {' '.join(e.cmd)}")
|
|
logger.error(f"Stdout: {e.stdout.decode('utf-8', errors='ignore').strip()}")
|
|
logger.error(f"Stderr: {e.stderr.decode('utf-8', errors='ignore').strip()}")
|
|
# Decide whether to return None or raise based on criticality
|
|
return None
|
|
except FileNotFoundError as e:
|
|
logger.error(f"Command not found: {e}. Ensure necessary tools (losetup, mount, rsync, grub-mkstandalone) are installed.")
|
|
# Decide whether to return None or raise based on criticality
|
|
return None
|
|
except Exception as e:
|
|
logger.error(f"Unexpected error while generating GRUB EFI: {e}")
|
|
# Decide whether to return None or raise based on criticality
|
|
return None
|
|
finally:
|
|
# Clean up: Unmount loop device and remove temporary directory
|
|
if grub_efi_tmpdir and os.path.exists(grub_efi_tmpdir):
|
|
try:
|
|
# Attempt unmount multiple times if necessary
|
|
for _ in range(5):
|
|
subprocess.run(["umount", "-l", grub_efi_tmpdir], check=True) # Use -l for lazy unmount
|
|
logger.debug(f" EFI vfat image unmounted from: {grub_efi_tmpdir}")
|
|
break # Exit loop if unmount successful
|
|
else:
|
|
logger.warning(f" Warning: Failed to unmount EFI vfat image after multiple attempts: {grub_efi_tmpdir}")
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
logger.warning(f" Warning: Failed to unmount EFI vfat image: {e}")
|
|
except Exception as e:
|
|
logger.warning(f" Warning: Unexpected error during unmount: {e}")
|
|
|
|
|
|
if loop_device:
|
|
try:
|
|
# Attempt detach multiple times if necessary
|
|
for _ in range(5):
|
|
subprocess.run(["losetup", "--detach", loop_device], check=True)
|
|
logger.debug(f" Loop device {loop_device} detached.")
|
|
break # Exit loop if detach successful
|
|
else:
|
|
logger.warning(f" Warning: Failed to detach loop device after multiple attempts: {loop_device}")
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
logger.warning(f" Warning: Failed to detach loop device {loop_device}: {e}")
|
|
except Exception as e:
|
|
logger.warning(f" Warning: Unexpected error during loop device detach: {e}")
|
|
|
|
if grub_efi_tmpdir and os.path.exists(grub_efi_tmpdir):
|
|
# Use ignore_errors=True for rmtree as unmount might still fail
|
|
shutil.rmtree(grub_efi_tmpdir, ignore_errors=True)
|
|
logger.debug(f" Temporary directory {grub_efi_tmpdir} removed.")
|
|
|
|
def copy_boot_directory_contents(source_boot_dir, dest_boot_dir):
|
|
"""Copies contents of source boot dir to dest boot dir, merging if necessary."""
|
|
logger.info(f" => Copying boot directory contents from: {source_boot_dir} to: {dest_boot_dir} (merge)...")
|
|
os.makedirs(dest_boot_dir, exist_ok=True)
|
|
|
|
for item in os.listdir(source_boot_dir):
|
|
s_item = os.path.join(source_boot_dir, item)
|
|
d_item = os.path.join(dest_boot_dir, item)
|
|
if os.path.isdir(s_item):
|
|
logger.debug(f" Merging directory: {item}")
|
|
shutil.copytree(s_item, d_item, dirs_exist_ok=True)
|
|
else:
|
|
logger.debug(f" Copying file: {item}")
|
|
shutil.copy2(s_item, d_item)
|
|
|
|
logger.debug(" => Boot directory contents copied/merged successfully.")
|
|
|
|
def generate_grub_pep_cfg(kernel_version, boot_cmdline, boot_title, keymap, locale, architecture, want_memtest, splash_image, SPLASH_DIR):
|
|
"""Generates the content of grub_pep.cfg using the provided template."""
|
|
grub_pep_cfg_template = """
|
|
|
|
set pager="1"
|
|
set locale_dir="(${peppermintos})/boot/grub/locale"
|
|
set theme="(${peppermintos})/boot/grub/themes/peppermint/theme.txt"
|
|
|
|
if [ -e "${prefix}/${grub_cpu}-${grub_platform}/all_video.mod" ]; then
|
|
insmod all_video
|
|
else
|
|
insmod efi_gop
|
|
insmod efi_uga
|
|
insmod video_bochs
|
|
insmod video_cirrus
|
|
fi
|
|
|
|
insmod font
|
|
|
|
if loadfont "(${peppermintos})/boot/grub/fonts/unicode.pf2" ; then
|
|
insmod gfxterm
|
|
set gfxmode="auto"
|
|
|
|
terminal_input console
|
|
terminal_output gfxterm
|
|
|
|
insmod png
|
|
background_image "(${peppermintos})/boot/isolinux/@@SPLASHIMAGE@@"
|
|
fi
|
|
|
|
# Set default menu entry
|
|
default=linux
|
|
timeout=15
|
|
timeout_style=menu
|
|
|
|
# GRUB init tune for accessibility
|
|
play 600 988 1 1319 4
|
|
|
|
if [ cpuid -l ]; then
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@)" --id "linux" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@) (RAM)" --id "linuxram" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@ rd.live.ram
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@) (graphics disabled)" --id "linuxnogfx" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@ nomodeset
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@)" with speech --hotkey s --id "linuxa11y" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@ live.accessibility live.autologin
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@) with speech (RAM)" --hotkey r --id "linuxa11yram" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@ live.accessibility live.autologin rd.live.ram
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
menuentry "@@BOOT_TITLE@@ @@KERNVER@@ (@@ARCH@@) with speech (graphics disabled)" --hotkey g --id "linuxa11ynogfx" {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/vmlinuz \\
|
|
root=live:CDLABEL=PEPPERMINTOS ro init=/sbin/init \\
|
|
rd.luks=0 rd.md=0 rd.dm=0 loglevel=4 gpt add_efi_memmap \\
|
|
vconsole.unicode=1 vconsole.keymap=@@KEYMAP@@ \\
|
|
locale.LANG=@@LOCALE@@ @@BOOT_CMDLINE@@ live.accessibility live.autologin nomodeset
|
|
initrd (${peppermintos})/boot/initrd
|
|
}
|
|
if [ "${grub_platform}" == "efi" ]; then
|
|
menuentry "Run Memtest86+ (RAM test)" --hotkey m --id memtest {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/memtest.efi
|
|
}
|
|
menuentry 'UEFI Firmware Settings' --hotkey f --id uefifw {
|
|
fwsetup
|
|
}
|
|
else
|
|
menuentry "Run Memtest86+ (RAM test)" --id memtest {
|
|
set gfxpayload="keep"
|
|
linux (${peppermintos})/boot/memtest.bin
|
|
}
|
|
fi
|
|
|
|
menuentry "System restart" --hotkey b --id restart {
|
|
echo "System rebooting..."
|
|
reboot
|
|
}
|
|
|
|
menuentry "System shutdown" --hotkey p --id poweroff {
|
|
echo "System shutting down..."
|
|
halt
|
|
}
|
|
fi
|
|
"""
|
|
splash_image_path = os.path.join(SPLASH_DIR, "splash.png") if SPLASH_DIR else " "
|
|
grub_pep_cfg_content = grub_pep_cfg_template.replace("@@BOOT_TITLE@@", boot_title)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@KERNVER@@", kernel_version)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@ARCH@@", architecture)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@KEYMAP@@", keymap)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@LOCALE@@", locale)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@BOOT_CMDLINE@@", boot_cmdline)
|
|
grub_pep_cfg_content = grub_pep_cfg_content.replace("@@SPLASHIMAGE@@", os.path.basename(splash_image_path) if splash_image_path and os.path.exists(splash_image_path) else " ")
|
|
|
|
return grub_pep_cfg_content |