---

elf32.c

Go to the documentation of this file.

/*!     \file kernel/elf32.c
 *      \brief ELF32 file format loader.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update:\n
 *              2003-01-24 Andrea Righi:
 *                      Skip NULL sections when copying them to
 *                      memory.\n
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#include <const.h>
#include <errno.h>

#include <arch/mem.h>

#include <kernel/console.h>
#include <kernel/fat.h>
#include <kernel/kernel_map.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>

#include <kernel/elf32.h>

//! \brief
//!     Check if a file has a valid elf32 header.
//! \param f The file header.
//! \return
//!     \li 0 if success;
//!     \li -ENOEXEC if \p f is not a valid ELF32 header.
int elf32_check(elf32_hdr_t *f)
{
// Check if "f" is a valid ELF32 header                                 //
        #ifdef ELF32_DEBUG
                kprintf("\n\rFile header:");
                kprintf("\n\rmagic[]=%c%c%c%c class=%u data=%u",
                        f->e_ident[EI_MAG0],
                        f->e_ident[EI_MAG1],
                        f->e_ident[EI_MAG2],
                        f->e_ident[EI_MAG3],
                        f->e_ident[EI_CLASS],
                        f->e_ident[EI_DATA]
                );
        #endif
        // Magic number check                                           //
        if (
                (f->e_ident[EI_MAG0] != ELF_MAG0) ||
                (f->e_ident[EI_MAG1] != ELF_MAG1) ||
                (f->e_ident[EI_MAG2] != ELF_MAG2) ||
                (f->e_ident[EI_MAG3] != ELF_MAG3)
        )
                return( -ENOEXEC );

        // Class check                                                  //
        if ( f->e_ident[EI_CLASS] != ELF_CLASS32 )
                return( -ENOEXEC );

        // Data encoding check                                          //
        if ( f->e_ident[EI_DATA] != ELF_DATA2LSB )
                return( -ENOEXEC );

        // Check OK!                                                    //
        return(0);
}

//! \brief
//!     Copy the ELF32 sections at the right locations in memory.
//! \param f The buffer where the ELF32 file is located.
//! \return
//!     \li the entry point address on success;
//!     \li NULL if an error occurs.
uint32_t elf32_copy_sections(elf32_hdr_t *f)
{
        elf32_shdr_t *sec;
        int     sec_num;
        int     sec_entsize;
        int     i;

        void copy_section(elf32_shdr_t *sec)
        {
                #ifdef ELF32_DEBUG
                kprintf("\n\rsh_name      = %#010x", sec->sh_name);
                kprintf("\n\rsh_type      = %#010x", sec->sh_type);
                kprintf("\n\rsh_flags     = %#010x", sec->sh_flags);
                kprintf("\n\rsh_addr      = %#010x", sec->sh_addr);
                kprintf("\n\rsh_offset    = %#010x", sec->sh_offset);
                kprintf("\n\rsh_size      = %#010x", sec->sh_size);
                kprintf("\n\rsh_link      = %#010x", sec->sh_link);
                kprintf("\n\rsh_info      = %#010x", sec->sh_info);
                kprintf("\n\rsh_addralign = %#010x", sec->sh_addralign);
                kprintf("\n\rsh_entsize   = %#010x", sec->sh_entsize);
                kprintf("\n\r");
                #endif

                // Skip NULL sections.
                if( (sec->sh_addr==NULL) || (sec->sh_offset==NULL) )
                        return;

                // Copy this section into the current address space.
                memcpy( (void *)(sec->sh_addr),
                        (void *)((uint32_t)f + sec->sh_offset),
                        sec->sh_size );
        }

        // Check if it is a valid ELF32 file                            //
        if ( elf32_check(f)<0 )
                return(NULL);

        // Get the section informations                                 //
        sec_num =       f->e_shnum;
        sec_entsize =   f->e_shentsize;
        #ifdef ELF32_DEBUG
        kprintf("\n\rEntry point @ %#010x", f->e_entry);
        kprintf("\n\rsec_num=%#010x, sec_entsize=%#010x\n\r", sec_num, sec_entsize);
        #endif

        // First of all check if the sections are not in the user space
        // boundaries.
        // ----- User Sections          (4KB - 1GB)
        // ----- User Heap              (1GB - 2GB)
        // ----- User Stack             (2GB - 3GB)
        sec = (elf32_shdr_t *)((uint32_t)f->e_shoff + (uint32_t)f);
        for (i=0; i<sec_num; i++)
        {
                if ( (sec->sh_addr >= K_VIR_START) || (sec->sh_addr + sec->sh_size) >= K_VIR_START )
                        return( NULL );
                (uint32_t)sec += sec_entsize;
        }

        // Copy the sections in memory                                  //
        sec = (elf32_shdr_t *)((uint32_t)f->e_shoff + (uint32_t)f);
        for (i=0; i<sec_num; i++)
        {
                copy_section( sec );
                (uint32_t)sec += sec_entsize;
        }
        return( f->e_entry );
}

//! \brief
//!     Load an ELF32 file into a buffer.
//! \param file_name The name of the file to be loaded.
//! \param file_buffer The buffer where the file will be loaded.
//! \return
//!     \li 0 on success;
//!     \li -ENOENT if the file doesn't exist;
//!     \li -ENOEXEC if the file is not a valid ELF32 file.
int elf32_load_file(char *file_name, void *file_buffer)
{
        // Load the file into the buffer                                //
        // TODO: replace with:
        //      int fread(void *buf, size_t size, size_t count, FILE *stream);
        if ( !(load_file(file_name, file_buffer)) )
                return( -ENOENT );

        // Check if it is a valid ELF file                              //
        if ( elf32_check((elf32_hdr_t *)file_buffer) < 0 )
                return( -ENOEXEC );

        // The ELF32 file is successfully loaded                        //
        return(0);
}

//! \brief Execute a file.
int elf32_exec(void *f, int argc, char **argv)
{
        int (*entry)(int argc, char **argv) = (int(*)(int argc, char **argv))(((elf32_hdr_t *)f)->e_entry);
        return( entry(argc, argv) );
}

---