Chain Loading¶
A running executable hands primary control to a separately loadable successor stage through a platform-defined loading interface.
Core Idea¶
Chain loading occurs when a running executable selects a separately loadable successor and hands it primary execution through a host-defined loading interface. GNU GRUB can chain-load another boot loader instead of loading an operating system directly; HP BASIC for OpenVMS uses CHAIN to start another executable image. The shared structure is a deliberate successor-stage handoff, not an ordinary returning function call.[ref-821272f5169e][ref-27a79d2b047f]
The successor need not overwrite every byte of the predecessor, receive state through a universal common-memory block, or be unable ever to return. Those matters depend on the platform: GRUB allows return on some EFI paths, while HP BASIC CHAIN does not return to the old program.[ref-821272f5169e-2][ref-27a79d2b047f]
Scope of Application¶
In boot management, GRUB loads another boot loader and jumps to it through real mode or firmware. In program segmentation, an HP BASIC program uses CHAIN to start a named executable; that implementation closes files and releases storage before the new image runs. The two cases share the stage-handoff relation but have different resource and return contracts.[ref-821272f5169e][ref-27a79d2b047f]
IBM XCTL and POSIX exec are useful neighboring mechanisms, not automatic synonyms. XCTL may transfer to an already resident module and removes the issuer module only conditionally; exec replaces a process image while retaining selected process properties and file descriptors.[ref-9089fb0c3326][ref-872f8b4bd9c2]
Clarity¶
To identify chain loading, distinguish the present controlling executable, the distinct successor, the loading interface, the transfer of primary control, and the platform-defined state contract. A returning subroutine has a different control relation; an overlay that leaves the original program in charge is not sufficient. “Load the next stage” does not itself tell us what memory persists, which resources remain open, or whether a later return is possible.[ref-821272f5169e-2][ref-27a79d2b047f]
Manages Complexity¶
The concept reduces a complicated boot or application path to a stage graph: predecessor → successor, with a loading and state boundary between them. That graph helps separate failures of target selection, loading, transferred context, and expectations about return. The precise remedy still depends on the actual loader or runtime; the graph does not erase platform rules.[ref-821272f5169e][ref-27a79d2b047f]
Abstract Reasoning¶
Given a case, ask whether an already running stage chose a distinct executable that became the primary controller. If so, inspect the platform's handoff contract before inferring state persistence or return. GRUB's documented EFI return possibility and HP BASIC's nonreturning file-closing CHAIN show why neither “all memory overwritten” nor “the first stage can never resume” is a valid universal deduction.[ref-821272f5169e-2][ref-27a79d2b047f]
Knowledge Transfer¶
The predecessor–successor–interface role map transfers between bootloader delegation and language-runtime program chaining, while their executable formats and resource rules do not. A still broader “one stage yields to another” skeleton may be worth future prime analysis, but executable loading and machine control are constitutive here. The draft therefore proposes no strict DAG parent merely from resemblance to Sequencing, Cascade, Bootstrapping, or Authority Handoff.[ref-821272f5169e][ref-27a79d2b047f]
[^ref-821272f5169e]: GNU Project, GNU GRUB Manual 2.14, §5.1.3, “Chain-loading an OS”, original maintainer documentation.
[^ref-821272f5169e-2]: GNU Project, GNU GRUB Manual 2.14, “Platform-specific operations”, paragraph on chainloading and possible return to GRUB on EFI platforms.
[^ref-27a79d2b047f]: Hewlett Packard Enterprise, HP BASIC for OpenVMS, “CHAIN,” Statements and Functions, p. 3-13, original vendor language manual.
[^ref-9089fb0c3326]: IBM, “XCTL and XCTLX description,” z/OS 3.1 Documentation, opening description and use-count behavior.
[^ref-872f8b4bd9c2]: The Open Group, The Open Group Base Specifications, Issue 8, exec, process-image and retained file-descriptor rules.
Neighborhood in Abstraction Space¶
Chain Loading sits in a sparse region of the domain-specific corpus (68th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.
Family — Program Execution & Runtime Concepts (27 abstractions)
Nearest neighbors
- Basic Block — 0.85
- Reconfigurable Computing — 0.84
- Position-Independent Code — 0.84
- Compute kernel — 0.84
- Zero-Touch Provisioning — 0.84
Computed from structural-signature embeddings · 2026-10-08