Executable and Linkable Format

Description

The Executable and Linkable Format (ELF) is a ubiquitous, platform-agnostic binary file format standard. Within the context of 3GPP, it is referenced as a standardized method for packaging executable code and related data for use in network elements and user equipment. An ELF file defines how machine code, data, symbol tables, relocation information, and program metadata are organized into sections and segments. This organization is crucial for system software like linkers and loaders, which interpret the ELF structure to prepare a program for execution in memory.

Technically, an ELF file begins with an ELF header that describes the overall file structure, including the target architecture (e.g., ARM, x86), the entry point for execution, and the offsets to the section header table and program header table. The program header table, used by loaders, defines segments—portions of the file that are mapped into memory during execution, such as executable code segments (text) and data segments. The section header table, used by linkers and debuggers, defines finer-grained sections within the file, like .text for code, .data for initialized variables, .bss for uninitialized data, and .symtab for symbols.

In a 3GPP network environment, ELF is the format for software binaries that run on network functions, whether virtualized (as in a Cloud-Native Network Function - CNF) or on dedicated hardware. For example, the software for a Virtualized Network Function (VNF) or a Containerized Network Function, including the application code and shared libraries, is typically distributed and executed in ELF format. The use of a standardized format like ELF ensures that the underlying operating system and hypervisor on commercial off-the-shelf (COTS) servers can correctly load, link dependencies, and execute the telecom software, promoting portability and simplifying the software lifecycle management from development through deployment and updates.

Purpose & Motivation

ELF exists to solve the problem of incompatible binary formats across different computing platforms and operating systems. Before such standards, each system vendor often used a proprietary executable format, making it extremely difficult to port software. The creation of ELF, originally developed for Unix System V.4 and later adopted by Linux and many other systems, provided a common, flexible, and extensible format. This allows compilers, linkers, and loaders from different toolchains to produce and consume binary files interoperably.

Within 3GPP's standardization scope, referencing ELF (specifically in TS 31.131 for aspects like secure software loading) provides a stable, well-understood foundation for discussing software distribution and execution. As 3GPP networks evolved towards cloud-native principles with 5G, using COTS hardware and virtualization, the reliance on standard software formats like ELF became even more critical. It allows network function vendors to package their software independently of the final deployment hardware, as long as the target CPU architecture is supported. This decoupling is a key enabler for network function virtualization (NFV) and cloud-native network architectures, promoting vendor diversity, easier upgrades, and efficient resource utilization.

Key Features

• Standardized structure with ELF header, program header table, and section header table
• Supports multiple processor architectures (e.g., ARM, x86, PowerPC)
• Defines both linking view (sections) and execution view (segments)
• Contains symbol and relocation information for dynamic linking
• Used for executables, shared libraries, object files, and core dumps
• Enables cross-platform software portability and efficient program loading

Evolution Across Releases

Defining Specifications