diff --git a/guides/common/assembly_bootloader-binary-location.adoc b/guides/common/assembly_bootloader-binary-location.adoc new file mode 100644 index 00000000000..b909a27642a --- /dev/null +++ b/guides/common/assembly_bootloader-binary-location.adoc @@ -0,0 +1,11 @@ +:_mod-docs-content-type: ASSEMBLY + +include::modules/con_bootloader-binary-location-overview.adoc[] + +include::modules/ref_bootloader-types.adoc[leveloffset=+1] + +include::modules/ref_pxelinux-bootloaders.adoc[leveloffset=+1] + +include::modules/ref_grub2-uefi-bootloaders.adoc[leveloffset=+1] + +include::modules/ref_ipxe-bootloaders.adoc[leveloffset=+1] diff --git a/guides/common/modules/con_bootloader-binary-location-overview.adoc b/guides/common/modules/con_bootloader-binary-location-overview.adoc new file mode 100644 index 00000000000..6010e6dfb5b --- /dev/null +++ b/guides/common/modules/con_bootloader-binary-location-overview.adoc @@ -0,0 +1,34 @@ +:_mod-docs-content-type: CONCEPT + +[id="con_bootloader-binary-location-overview_{context}"] += Boot loader management and file structure + +This section describes how {Project} manages and serves boot loader binaries through the *{SmartProxy}*, which provides the underlying network boot services used during automated host provisioning. +While traditional *PXE (Preboot Execution Environment)* remains a core method, {Project} also supports *HTTPBoot*, *iPXE*, and *UEFI HTTP(S) Boot* mechanisms. + +During a network-based installation, {SmartProxy} coordinates multiple services: + +* DHCP: Assigns IP addresses and provides the boot loader filename and `next-server` information. + +* TFTP: Delivers boot loaders such as PXELinux, GRUB, or iPXE binaries to clients. + +* HTTP(S): Serves boot loaders and installation images via the {SmartProxy}’s HTTPBoot module + +When a host begins a network boot, it retrieves the appropriate boot loader (for example, `pxelinux.0`, `grubx64.efi`, or `ipxe.efi`) according to its firmware type and *PXE Loader* setting in {Project}. +The boot loader then loads {Project}-generated configuration files that define which kernel and initrd to boot, initiating the OS installation process. + +The *{SmartProxy}* manages the distribution of these boot loader binaries and configuration files. +All boot loaders, whether used for PXE, iPXE, or HTTPBoot, are stored under the {SmartProxy}’s TFTP root directory (`/var/lib/tftpboot/`), which is also shared by the HTTPBoot service. +Each boot loader binary is organized within a directory structure based on its type, architecture, and operating system version. + +[NOTE] +==== +The TFTP root directory is configured in `/etc/foreman-proxy/settings.d/tftp.yml` under the `:tftproot` parameter. +In this document, the default path `/var/lib/tftpboot` is used for explanation. +If your environment uses a different path, please substitute it accordingly. + +The directory used by *Grub2 UEFI HTTP* and *iPXE HTTP* for file delivery is defined in `/etc/foreman-proxy/settings.d/httpboot.yml` under the `:root_dir` parameter. +This also defaults to `/var/lib/tftpboot`. +If you have customized this setting, read the descriptions in this section using your configured directory path instead. +==== + diff --git a/guides/common/modules/ref_bootloader-types.adoc b/guides/common/modules/ref_bootloader-types.adoc new file mode 100644 index 00000000000..2e1b902b32e --- /dev/null +++ b/guides/common/modules/ref_bootloader-types.adoc @@ -0,0 +1,245 @@ +:_mod-docs-content-type: REFERENCE + +[id="ref_bootloader-types_{context}"] += Boot loader types in {Project} + +This section describes the PXE boot loaders supported by {Project} and explains how each type is used during network provisioning, depending on firmware type, protocol, and boot environment. + +{Project} allows you to configure a **PXE Loader** for each host. +The PXE Loader determines which boot loader binary the host retrieves during network boot and how it communicates with the {SmartProxy} (via TFTP or HTTP). +Selection depends on whether the host uses **BIOS**, **UEFI**, **Secure Boot**, or **HTTP Boot**. + +== PXE Loader Types and Boot Protocols in {Project} + +The following table lists the PXE Loader options available in the {Project}. +Each loader is associated with a specific boot protocol and firmware type. + +. PXE Loader Types and Boot Protocols + +[cols="1,1,1,1", options="header"] +|=== +| PXE Loader (UI Label) +| Category +| Firmware +| Protocol + +| None +| None +| - +| - + +| PXELinux BIOS +| PXELinux +| BIOS +| DHCP → TFTP + +| PXELinux UEFI +| PXELinux +| UEFI +| DHCP → TFTP + +| Grub UEFI +| PXEGrub (Legacy) +| UEFI +| DHCP → TFTP + +| Grub2 BIOS +| PXEGrub2 (TFTP) +| BIOS +| DHCP → TFTP + +| Grub2 ELF +| PXEGrub2 (TFTP) +| BIOS +| DHCP → TFTP + +| Grub2 UEFI +| PXEGrub2 (TFTP) +| UEFI +| DHCP → TFTP + +| Grub2 UEFI SecureBoot +| PXEGrub2 (TFTP) +| UEFI +| DHCP → TFTP + +| Grub2 UEFI HTTP +| Grub2 (HTTP) +| UEFI +| DHCP → HTTP + +| Grub2 UEFI HTTPS +| Grub2 (HTTPS) +| UEFI +| DHCP → HTTPS + +| Grub2 UEFI HTTPS SecureBoot +| Grub2 (HTTPS) +| UEFI +| DHCP → HTTPS + +| iPXE Embedded +| iPXE Direct (HTTP) +| BIOS / UEFI +| DHCP → HTTP + +| iPXE UEFI HTTP +| iPXE Direct (HTTP) +| UEFI +| DHCP → HTTP + +| iPXE Chain BIOS +| iPXE Chainload +| BIOS +| DHCP → TFTP → HTTP + +| iPXE Chain UEFI +| iPXE Chainload +| UEFI +| DHCP → TFTP → HTTP +|=== + +This table lists the available PXE Loader categories and describes how each type delivers boot loaders and installation files during network provisioning. + +. PXE Loader categories + +[cols="30%,70%",options="header"] +|=== +| Category | Description + +| PXELinux +| Syslinux-based loaders for BIOS and UEFI environments. + +| PXEGrub (Legacy) +| Early GRUB-based loader for UEFI systems. + +| PXEGrub2 (TFTP) +| GRUB2-based loader supporting both BIOS and UEFI environments (including Secure Boot via `shim`). + +| Grub2 (HTTP/HTTPS) +| GRUB2-based UEFI boot loader fetched over HTTP or HTTPS using the {SmartProxy}’s HTTPBoot service. + +| iPXE Chainload +| A two-stage boot process in which the client first downloads an iPXE binary (`undionly-ipxe.0` or `ipxe.efi`) via TFTP. +Once loaded, iPXE retrieves {Project}’s iPXE script and installation files over HTTP, enabling flexible configuration and network boot via HTTP. + +| iPXE Direct (HTTP) +| Boots directly via embedded or firmware-level iPXE using only HTTP. + +| None +| {Project} does not specify a boot loader. +|=== + +== Boot Loader File Mapping and Architecture Naming + +{Project} automatically determines the correct boot loader filename for each host based on its *architecture* and the *PXE Loader* selected in the host settings. +This mechanism ensures that the correct boot loader binary (such as `grubx64.efi` or `grubaa64.efi`) is selected automatically, +without requiring administrators to manage architecture-specific filenames. + +.PXE Loader to Boot Loader Mapping + +[cols="1,1,1", options="header"] +|=== +| PXE Loader (UI Label) +| Boot Loader File (Template Path) +| Example (x86_64) + +| None +| - +| - + +| PXELinux BIOS +| pxelinux.0 +| pxelinux.0 + +| PXELinux UEFI +| pxelinux.efi +| pxelinux.efi + +| Grub2 BIOS +| grub<__arch__>.0 +| grubx64.0 + +| Grub2 ELF +| grub<__arch__>.elf +| grubx64.elf + +| Grub2 UEFI +| grub<__arch__>.efi +| grubx64.efi + +| Grub2 UEFI SecureBoot +| shim<__arch__>.efi +| shimx64.efi + +| Grub2 UEFI HTTP +| grub<__arch__>.efi (via HTTP) +| grubx64.efi + +| Grub2 UEFI HTTPS +| grub<__arch__>.efi (via HTTPS) +| grubx64.efi + +| Grub2 UEFI HTTPS SecureBoot +| shim<__arch__>.efi (via HTTPS) +| shimx64.efi + +| iPXE Embedded +| Rendered dynamically as {Project}_url('iPXE') +| - + +| iPXE UEFI HTTP +| ipxe-<__arch__>.efi +| ipxe-x64.efi + +| iPXE Chain BIOS +| undionly-ipxe.0 +| undionly-ipxe.0 + +| iPXE Chain UEFI +| ipxe.efi +| ipxe.efi +|=== + +== Architecture-Based File Naming + +{Project} automatically determines the correct boot loader filename for each host based on its architecture. +For example, `x86_64` hosts use `grubx64.efi`, while `aarch64` hosts use `grubaa64.efi`. + +.Boot Loader Filenames by Architecture + +[cols="1,1,1", options="header"] +|=== +| Architecture (Web UI) +| Example Filename +| Internal Suffix (for reference) + +| i386, i686, x86 +| grubia32.efi +| ia32 + +| x86_64, amd64 +| grubx64.efi, shimx64.efi +| x64 + +| aarch64, aa64 +| grubaa64.efi, shimaa64.efi +| aa64 + +| ppc64, ppc64le +| grubppc64.efi +| ppc64, ppc64le + +| Other architectures (for example, riscv64, loongarch64) +| grubriscv64.efi +| normalized name +|=== + +For instance, a host with architecture `aarch64` and PXE Loader set to “Grub2 UEFI” will use: + +---- +/var/lib/tftpboot/grub2/grubaa64.efi +---- + +This mechanism allows {Project} to select the correct boot loader automatically, +without requiring users to manage architecture-specific filenames manually. diff --git a/guides/common/modules/ref_grub2-uefi-bootloaders.adoc b/guides/common/modules/ref_grub2-uefi-bootloaders.adoc new file mode 100644 index 00000000000..f2f09905219 --- /dev/null +++ b/guides/common/modules/ref_grub2-uefi-bootloaders.adoc @@ -0,0 +1,168 @@ +:_mod-docs-content-type: REFERENCE + +[id="ref_grub2-uefi-bootloaders_{context}"] += GRUB2 UEFI boot loaders and the `bootloader-universe` structure + +This section describes GRUB-based PXE boot loaders, including *PXEGrub (Legacy)* and *PXEGrub2*, +and explains how the `bootloader-universe` directory structure organizes GRUB2 binaries by OS and architecture. + +== Overview + +{Project} supports two generations of GRUB-based PXE boot loaders: *PXEGrub (GRUB Legacy)* and *PXEGrub2 (GRUB2-based)*. +PXEGrub is used for older BIOS or early UEFI systems, while PXEGrub2 supports *UEFI* and *Secure Boot* environments. + +Both are managed by the {SmartProxy}’s TFTP service, which provides PXE clients with the appropriate boot loader binaries and configuration files. + +By using the `bootloader-universe` directory structure, GRUB2-based UEFI boot loaders can be organized and managed by distribution, version, and architecture. +This feature does not require explicit configuration; it is automatically enabled when the {SmartProxy} uses the +`/var/lib/tftpboot/bootloader-universe/pxegrub2/` directory structure. + +== Directory Structure: `bootloader-universe` + +This section explains the purpose and layout of the `bootloader-universe` directory, which enables multiple OS versions and architectures to coexist cleanly. + +=== Organized Hierarchy by OS and Architecture + +When the {SmartProxy} recognizes the `/var/lib/tftpboot/bootloader-universe/pxegrub2/` structure, +boot loaders are stored in an organized hierarchy by OS, version, and architecture. +This allows multiple distributions and versions to coexist without conflicts. + +Before placing boot loader binaries (`shim<__arch__>.efi`, `grub<__arch__>.efi`), you must manually create the corresponding directory hierarchy using the `mkdir` command. + +Example: +---- +mkdir -p /var/lib/tftpboot/bootloader-universe/pxegrub2/rocky/9.5/x86_64 +---- + +=== File Locations and Roles + +The following table summarizes the purpose of each directory in the `bootloader-universe` hierarchy. + +. File Locations and Roles + +[cols="1,2,1", options="header"] +|=== +| Path +| Purpose / Usage +| User Action + +| `/var/lib/tftpboot/bootloader-universe/pxegrub2/<__distro__>/<__version__>/<__arch__>/` +| Stores OS- and architecture-specific GRUB2 binaries (shim<__arch__>.efi, grub<__arch__>.efi) and symbolic links (boot.efi, boot-sb.efi). +Used for version-specific boot loader management within the `bootloader-universe` hierarchy. +| **Create manually** + +| `/var/lib/tftpboot/bootloader-universe/pxegrub2/<__distro__>/default/<__arch__>/` +| Stores OS- and architecture-specific GRUB2 binaries (shim<__arch__>.efi, grub<__arch__>.efi) and symbolic links (boot.efi, boot-sb.efi). +Used as a fallback directory when a specific version is not available. +| **Create manually** + +| /var/lib/tftpboot/host-config/<__My_MAC_Address__>/grub2/ +| Host-specific directory automatically created when a host enters *Build mode*. +Contains symbolic links (boot.efi, boot-sb.efi) and a generated grub.cfg. +| *Auto-created by {SmartProxy}* +|=== + +Example structure: + +---- +# tree /var/lib/tftpboot/bootloader-universe/ +/var/lib/tftpboot/bootloader-universe/ + ├── pxegrub2/ + │ ├── rocky/9.5/x86_64/ + │ │ ├── shimx64.efi + │ │ ├── grubx64.efi + │ │ ├── boot.efi -> grubx64.efi + │ │ └── boot-sb.efi -> shimx64.efi + │ └── ubuntu/22.04/x86_64/ + │ ├── shimx64.efi + │ ├── grubx64.efi + │ ├── boot.efi -> grubx64.efi + │ └── boot-sb.efi -> shimx64.efi + └── host-config/ + └── 52-54-00-ab-cd-ef/ + └── grub2/ + ├── boot.efi -> ../../../bootloader-universe/pxegrub2/rocky/9.5/x86_64/boot.efi + ├── boot-sb.efi -> ../../../bootloader-universe/pxegrub2/rocky/9.5/x86_64/boot-sb.efi + ├── grub.cfg + ├── shimx64.efi -> ../../../bootloader-universe/pxegrub2/rocky/9.5/x86_64/shimx64.efi + └── grubx64.efi -> ../../../bootloader-universe/pxegrub2/rocky/9.5/x86_64/grubx64.efi +---- + +[NOTE] +==== +* In `bootloader-universe/pxegrub2/<__distro__>/<__version__>/<__arch__>/`, +`boot.efi` and `boot-sb.efi` are symbolic links to `grub<__arch__>.efi` and `shim<__arch__>.efi`, respectively. +The {SmartProxy} automatically creates host-specific links to these files under `host-config/<__My_MAC_Address__>/grub2/`. + +* In the {ProjectWebUI}, OS and distribution identifiers (`<__distro__>`) must not contain spaces. +==== + +[IMPORTANT] +==== +You must manually create `boot.efi` and `boot-sb.efi` symbolic links within each `<__arch__>` directory. + +Example (x86_64): +[subs="+quotes"] +---- +$ ln -s grubx64.efi boot.efi +$ ln -s shimx64.efi boot-sb.efi +$ chmod 644 grubx64.efi shimx64.efi +---- + +The `chmod` command ensures that TFTP and HTTPBoot clients can read these files. +==== + +== Legacy Layout (Non-`bootloader-universe`) + +This section explains how boot loaders are handled when the `bootloader-universe` directory is not used. +This layout remains supported for backward compatibility. + +If the `/var/lib/tftpboot/bootloader-universe/pxegrub2/` structure is not used, +{Project} falls back to the legacy `/var/lib/tftpboot/grub2/` directory. +Boot loaders are stored in a flat layout, but when a host enters *Build mode*, the {SmartProxy} creates a host-specific directory with the required configuration files and links. + +=== File Locations and Roles + +. File Locations and Roles + +[cols="1,1,1", options="header"] +|=== +| Path +| Purpose / Usage +| User Action + +| /var/lib/tftpboot/grub2/ +| Default directory used when `bootloader-universe` is not enabled. +Contains GRUB2 UEFI boot loader binaries such as grubx64.efi, shimx64.efi, grubaa64.efi, and shimaa64.efi. +| Place the appropriate boot loader binaries (grub<__arch__>.efi, shim<__arch__>.efi) in this directory. +No subdirectory creation is required. + +| /var/lib/tftpboot/host-config/<__My_MAC_Address__>/grub2/ +| Host-specific directory automatically created when a host enters *Build mode*. +Contains symbolic links (boot.efi, boot-sb.efi) and a generated grub.cfg. +| *Auto-created by {SmartProxy}* +|=== + +Example (x86_64): + +---- +/var/lib/tftpboot/grub2/ + ├── grubx64.efi + └── shimx64.efi +---- + +When a host enters *Build mode*, the {SmartProxy} creates the following directory structure: + +---- +# tree /var/lib/tftpboot/ +/var/lib/tftpboot/ + └── host-config/ + └── 52-54-00-ab-cd-ef/ + └── grub2/ + ├── boot.efi -> ../../../grub2/grubx64.efi + ├── boot-sb.efi -> ../../../grub2/shimx64.efi + ├── grub.cfg + ├── grub.cfg-01-52-54-00-ab-cd-ef + └── grub.cfg-52:54:00:ab:cd:ef +---- + diff --git a/guides/common/modules/ref_ipxe-bootloaders.adoc b/guides/common/modules/ref_ipxe-bootloaders.adoc new file mode 100644 index 00000000000..85739f4df5a --- /dev/null +++ b/guides/common/modules/ref_ipxe-bootloaders.adoc @@ -0,0 +1,125 @@ +:_mod-docs-content-type: REFERENCE + +[id="ref_ipxe-bootloaders_{context}"] += iPXE / GRUB2 UEFI HTTP(S) boot loaders + +This section describes HTTP-based boot methods such as *iPXE*, *iPXE chainloading* and *GRUB2 UEFI HTTP(S) Boot*, which use the {SmartProxy}’s HTTPBoot module to deliver bootloaders and installation files. + +== Overview + +{Project} also supports boot methods that use *HTTP* instead of the traditional *TFTP-based PXE* mechanism. +These include *iPXE*, *iPXE chainloading* and *UEFI HTTP Boot*, both of which leverage the {SmartProxy}’s HTTPBoot module to deliver bootloaders and installation files. + +The *HTTPBoot* feature exposes the same files that are available via TFTP, but over the HTTP(S) protocol. +This can improve boot reliability in environments where TFTP is blocked, unreliable, or slow. + +== Boot Methods + +This section explains the two main boot workflows: *iPXE chainloading* and *iPXE*, *GRUB2 UEFI HTTP(S) Boot*. +Each method offers advantages depending on the firmware type and network environment. + +=== iPXE Chainloading (PXE → HTTP) + +In this method, the boot process starts with a traditional PXE (TFTP) stage and then switches to HTTP for improved performance and flexibility. + +*Workflow:* +1. BIOS or UEFI firmware first downloads `undionly-ipxe.0` (for BIOS) or `ipxe.efi` (for UEFI) via TFTP. +2. iPXE then initializes the network and switches to HTTP, requesting an iPXE script such as `menu.ipxe`. + +This hybrid approach enables existing PXE infrastructure to use HTTP for the later boot stages without requiring firmware-level HTTP support. + +=== iPXE, GRUB2 UEFI HTTP(S) Boot + +In this method, UEFI firmware directly loads boot loaders using HTTP or HTTPS without any TFTP step. + +*Workflow:* +1. UEFI firmware directly requests boot loader files (for example, ipxe-<__arch__>.efi) from the {SmartProxy} via HTTP or HTTPS. +2. GRUB2 then loads `grub.cfg` and starts the OS installer. + +== File Locations and Roles + +This section describes where iPXE and GRUB2 HTTPBoot files are stored, what each file is used for, +and whether it must be provided manually or is created automatically. + +. File Locations and Roles + +[cols="1,1,1", options="header"] +|=== +| Path +| Purpose / Usage +| User Action + +| /var/lib/tftpboot/undionly-ipxe.0 +| iPXE boot loader for **iPXE Chain BIOS**. +Used in BIOS environments as the first-stage loader that transitions from TFTP-based PXE to HTTP-based iPXE boot. +| Place the undionly-ipxe.0 binary in this directory. + +| /var/lib/tftpboot/ipxe.efi +| iPXE boot loader for **iPXE Chain UEFI**. +Used in UEFI environments to chainload into iPXE for HTTP-based provisioning. +| Place the ipxe.efi binary in this directory. + +| /var/lib/tftpboot/ipxe-.efi +| Architecture-specific iPXE binary for **iPXE UEFI HTTP** boot. +Used for direct iPXE boot via HTTP (without TFTP chainloading). +| Place the architecture-matched file (for example, ipxe-x64.efi) here. + +| /var/lib/tftpboot/grub2/grub.efi +| GRUB2 UEFI boot loader for **Grub2 UEFI HTTP** or **HTTPS Boot**. +Used to start UEFI installations via the {SmartProxy}’s HTTPBoot module. +| Place the corresponding architecture-specific file (for example, grubx64.efi) in this directory. + +| /var/lib/tftpboot/grub2/shim.efi +| Secure Boot shim loader for GRUB2. +Used when “Grub2 UEFI SecureBoot” or “Grub2 UEFI HTTPS SecureBoot” is selected. +| Place the matching shim binary (for example, shimx64.efi) in this directory. +|=== + +== Shared TFTP and HTTP Root + +The {SmartProxy}’s *HTTPBoot* module and *TFTP* service share the same root directory. +By default, this directory is `/var/lib/tftpboot/`. + +[subs="+quotes"] +---- +URL path: http://<__smartproxy-example-com__>/httpboot/ +Filesystem: /var/lib/tftpboot/ +---- + +This mapping means that the HTTP URL path `/httpboot/` directly corresponds to the local filesystem under `/var/lib/tftpboot/`. +For example, a file located at: + +---- +/var/lib/tftpboot/pxegrub2/grubx64.efi +---- + +is available over HTTP at: +[subs="+quotes"] +---- +http://<__smartproxy-example-com__>/httpboot/pxegrub2/grubx64.efi +---- + +This shared structure simplifies management by ensuring that both PXE (TFTP) and HTTP clients use the same set of boot loader binaries and configuration files. + +== Example Directory Layout + +This subsection provides an example layout of typical iPXE and HTTPBoot-related files under `/var/lib/tftpboot/`. + +---- +# tree /var/lib/tftpboot/ +/var/lib/tftpboot/ + ├── undionly-ipxe.0 + ├── ipxe.efi + ├── ipxe-x64.efi + └── grub2/ + ├── grubx64.efi + └── shimx64.efi +---- + +[NOTE] +==== +GRUB2 UEFI HTTPS Boot relies on the {SmartProxy}’s HTTPS service to securely deliver boot loader binaries (`boot.efi`, `shim*.efi`, and similar) to UEFI clients. +The configuration for this HTTPS service is defined in the {SmartProxy}’s main settings file: +`/etc/foreman-proxy/settings.yml`. +==== + diff --git a/guides/common/modules/ref_pxelinux-bootloaders.adoc b/guides/common/modules/ref_pxelinux-bootloaders.adoc new file mode 100644 index 00000000000..07635aad95b --- /dev/null +++ b/guides/common/modules/ref_pxelinux-bootloaders.adoc @@ -0,0 +1,64 @@ +:_mod-docs-content-type: REFERENCE + +[id="ref_pxelinux-bootloaders_{context}"] += PXELinux boot loaders + +This section describes *PXELinux*, a Syslinux-based PXE boot loader used by {Project} for BIOS and UEFI systems, and outlines its configuration and file structure. + +== Overview + +In {Project}, PXELinux enables hosts to boot into the OS installer automatically during provisioning. +When a host is set to *Build mode*, {Project} generates a host-specific configuration file and places it in the TFTP directory managed by the {SmartProxy}. + +== File Locations and Roles + +This section describes where PXELinux-related files are stored, the role of each file, +and whether the user needs to create or provide them manually. + +. File Locations and Roles + +[cols="1,2,1", options="header"] +|=== +| Path +| Purpose / Usage +| User Action + +| /var/lib/tftpboot/pxelinux.0 +| The main PXELinux boot loader binary. Installed automatically by the {foreman-installer}. +| *Auto-installed by {foreman-installer}* + +| /var/lib/tftpboot/pxelinux.cfg/ +| Directory containing configuration files generated by {Project} for each host (for example, 01-52-54-00-ab-cd-ef). +| *Auto-created during Build mode* + +| /var/lib/tftpboot/ldlinux.c32 +| Support module required by PXELinux for menu and filesystem operations. +| **Provide manually** + +| /var/lib/tftpboot/menu.c32, /var/lib/tftpboot/chain.c32 +| Optional Syslinux modules for displaying boot menus or chainloading. +| **Provide manually** +|=== + +== Example Directory Layout + +This subsection shows an example of how PXELinux files are organized under the TFTP root directory. + +---- +# tree /var/lib/tftpboot/ +/var/lib/tftpboot/ + ├── pxelinux.0 + ├── ldlinux.c32 + ├── menu.c32 + ├── chain.c32 + └── pxelinux.cfg/ + ├── default + └── 01-52-54-00-ab-cd-ef +---- + +[NOTE] +==== +When a host is set to *Build mode*, {Project} automatically generates the configuration file under `pxelinux.cfg/` based on the host’s OS, architecture, and installation template. +The {SmartProxy}’s TFTP service then serves both the PXELinux binary and its configuration file to the client during network boot. +==== + diff --git a/guides/doc-Provisioning_Hosts/master.adoc b/guides/doc-Provisioning_Hosts/master.adoc index 84a36939c15..b7de510c0ed 100644 --- a/guides/doc-Provisioning_Hosts/master.adoc +++ b/guides/doc-Provisioning_Hosts/master.adoc @@ -63,6 +63,9 @@ include::common/modules/ref_host-parameter-hierarchy.adoc[leveloffset=+1] [appendix] include::common/modules/ref_permissions-required-to-provision-hosts.adoc[leveloffset=+1] +[appendix] +include::common/assembly_bootloader-binary-location.adoc[leveloffset=+1] + ifndef::orcharhino,satellite[] include::common/ribbons.adoc[] endif::[]