elf.c File Reference

ELF image format. More...

#include <string.h>
#include <errno.h>
#include <elf.h>
#include <ipxe/segment.h>
#include <ipxe/image.h>
#include <ipxe/uaccess.h>
#include <ipxe/elf.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	elf_load_segment (struct image *image, const Elf_Phdr *phdr, physaddr_t dest)
	Load ELF segment into memory.
static int	elf_segment (struct image *image, const Elf_Ehdr *ehdr, const Elf_Phdr *phdr, int(*process)(struct image *image, const Elf_Phdr *phdr, physaddr_t dest), physaddr_t *entry, physaddr_t *max)
	Process ELF segment.
int	elf_segments (struct image *image, const Elf_Ehdr *ehdr, int(*process)(struct image *image, const Elf_Phdr *phdr, physaddr_t dest), physaddr_t *entry, physaddr_t *max)
	Process ELF segments.
int	elf_load (struct image *image, physaddr_t *entry, physaddr_t *max)
	Load ELF image into memory.

Detailed Description

ELF image format.

A "pure" ELF image is not a bootable image. There are various bootable formats based upon ELF (e.g. Multiboot), which share common ELF-related functionality.

Definition in file elf.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

elf_load_segment()

int elf_load_segment ( struct image * image, const Elf_Phdr * phdr, physaddr_t dest )

static

Load ELF segment into memory.

Parameters

image	ELF file
phdr	ELF program header
dest	Destination address

Return values

rc	Return status code

Definition at line 52 of file elf.c.

                                                {
        void *buffer = phys_to_virt ( dest );
        int rc;
 
        DBGC ( image, "ELF %s loading segment [%x,%x) to [%lx,%lx,%lx)\n",
               image->name, phdr->p_offset, ( phdr->p_offset + phdr->p_filesz ),
               dest, ( dest + phdr->p_filesz ), ( dest + phdr->p_memsz ) );
 
        /* Verify and prepare segment */
        if ( ( rc = prep_segment ( buffer, phdr->p_filesz,
                                   phdr->p_memsz ) ) != 0 ) {
                DBGC ( image, "ELF %s could not prepare segment: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        /* Copy image to segment */
        memcpy ( buffer, ( image->data + phdr->p_offset ), phdr->p_filesz );
 
        return 0;
}

References buffer, image::data, DBGC, dest, memcpy(), image::name, Elf32_Phdr::p_filesz, Elf32_Phdr::p_memsz, Elf32_Phdr::p_offset, prep_segment(), rc, and strerror().

Referenced by elf_load().

elf_segment()

int elf_segment ( struct image * image, const Elf_Ehdr * ehdr, const Elf_Phdr * phdr, int(* process )(struct image *image, const Elf_Phdr *phdr, physaddr_t dest), physaddr_t * entry, physaddr_t * max )

static

Process ELF segment.

Parameters

image	ELF file
ehdr	ELF executable header
phdr	ELF program header
process	Segment processor

Return values

entry	Entry point, if found
max	Maximum used address
rc	Return status code

Definition at line 86 of file elf.c.

                                                              {
        physaddr_t dest;
        physaddr_t end;
        unsigned long e_offset;
        int rc;
 
        /* Do nothing for non-PT_LOAD segments */
        if ( phdr->p_type != PT_LOAD )
                return 0;
 
        /* Check segment lies within image */
        if ( ( phdr->p_offset + phdr->p_filesz ) > image->len ) {
                DBGC ( image, "ELF %s segment outside image\n", image->name );
                return -ENOEXEC;
        }
 
        /* Find start address: use physical address for preference,
         * fall back to virtual address if no physical address
         * supplied.
         */
        dest = phdr->p_paddr;
        if ( ! dest )
                dest = phdr->p_vaddr;
        if ( ! dest ) {
                DBGC ( image, "ELF %s segment loads to physical address 0\n",
                       image->name );
                return -ENOEXEC;
        }
        end = ( dest + phdr->p_memsz );
 
        /* Update maximum used address, if applicable */
        if ( end > *max )
                *max = end;
 
        /* Process segment */
        if ( ( rc = process ( image, phdr, dest ) ) != 0 )
                return rc;
 
        /* Set execution address, if it lies within this segment */
        if ( ( e_offset = ( ehdr->e_entry - dest ) ) < phdr->p_filesz ) {
                *entry = ehdr->e_entry;
                DBGC ( image, "ELF %s found physical entry point at %lx\n",
                       image->name, *entry );
        } else if ( ( e_offset = ( ehdr->e_entry - phdr->p_vaddr ) )
                    < phdr->p_filesz ) {
                if ( ! *entry ) {
                        *entry = ( dest + e_offset );
                        DBGC ( image, "ELF %s found virtual entry point at %lx"
                               " (virt %lx)\n", image->name, *entry,
                               ( ( unsigned long ) ehdr->e_entry ) );
                }
        }
 
        return 0;
}

References DBGC, dest, Elf32_Ehdr::e_entry, end, ENOEXEC, image::len, max, image::name, Elf32_Phdr::p_filesz, Elf32_Phdr::p_memsz, Elf32_Phdr::p_offset, Elf32_Phdr::p_paddr, Elf32_Phdr::p_type, Elf32_Phdr::p_vaddr, PT_LOAD, and rc.

Referenced by elf_segments().

elf_segments()

int elf_segments	(	struct image *	image,
		const Elf_Ehdr *	ehdr,
		int(*	process )(struct image *image, const Elf_Phdr *phdr, physaddr_t dest),
		physaddr_t *	entry,
		physaddr_t *	max )

Process ELF segments.

Parameters

image	ELF file
ehdr	ELF executable header
process	Segment processor

Return values

entry	Entry point, if found
max	Maximum used address
rc	Return status code

Definition at line 157 of file elf.c.

                                                        {
        const Elf_Phdr *phdr;
        Elf_Off phoff;
        unsigned int phnum;
        int rc;
 
        /* Initialise maximum used address */
        *max = 0;
 
        /* Invalidate entry point */
        *entry = 0;
 
        /* Read and process ELF program headers */
        for ( phoff = ehdr->e_phoff , phnum = ehdr->e_phnum ; phnum ;
              phoff += ehdr->e_phentsize, phnum-- ) {
                if ( ( image->len < phoff ) ||
                     ( ( image->len - phoff ) < sizeof ( *phdr ) ) ) {
                        DBGC ( image, "ELF %s program header %d outside "
                               "image\n", image->name, phnum );
                        return -ENOEXEC;
                }
                phdr = ( image->data + phoff );
                if ( ( rc = elf_segment ( image, ehdr, phdr, process,
                                          entry, max ) ) != 0 )
                        return rc;
        }
 
        /* Check for a valid execution address */
        if ( ! *entry ) {
                DBGC ( image, "ELF %s entry point %lx outside image\n",
                       image->name, ( ( unsigned long ) ehdr->e_entry ) );
                return -ENOEXEC;
        }
 
        return 0;
}

References image::data, DBGC, dest, Elf32_Ehdr::e_entry, Elf32_Ehdr::e_phentsize, Elf32_Ehdr::e_phnum, Elf32_Ehdr::e_phoff, elf_segment(), ENOEXEC, image::len, max, image::name, and rc.

Referenced by elf_load(), and elfboot_probe().

elf_load()

int elf_load	(	struct image *	image,
		physaddr_t *	entry,
		physaddr_t *	max )

Load ELF image into memory.

Parameters

image

ELF file

Return values

entry	Entry point
max	Maximum used address
rc	Return status code

Definition at line 206 of file elf.c.

                                                                         {
        static const uint8_t e_ident[] = {
                [EI_MAG0]        = ELFMAG0,
                [EI_MAG1]        = ELFMAG1,
                [EI_MAG2]        = ELFMAG2,
                [EI_MAG3]        = ELFMAG3,
                [EI_CLASS]      = ELFCLASS,
        };
        const Elf_Ehdr *ehdr;
        int rc;
 
        /* Read ELF header */
        if ( image->len < sizeof ( *ehdr ) ) {
                DBGC ( image, "ELF %s too short for ELF header\n",
                       image->name );
                return -ENOEXEC;
        }
        ehdr = image->data;
        if ( memcmp ( ehdr->e_ident, e_ident, sizeof ( e_ident ) ) != 0 ) {
                DBGC ( image, "ELF %s has invalid signature\n", image->name );
                return -ENOEXEC;
        }
 
        /* Load ELF segments into memory */
        if ( ( rc = elf_segments ( image, ehdr, elf_load_segment,
                                   entry, max ) ) != 0 )
                return rc;
 
        return 0;
}

References image::data, DBGC, Elf32_Ehdr::e_ident, EI_CLASS, EI_MAG0, EI_MAG1, EI_MAG2, EI_MAG3, elf_load_segment(), elf_segments(), ELFCLASS, ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, ENOEXEC, image::len, max, memcmp(), image::name, and rc.

Referenced by elfboot_exec(), and multiboot_load_elf().