Subversion Repositories c0or1k

/*

 * Australian Public Licence B (OZPLB)

 *

 * Version 1-0

 *

 * Copyright (c) 2004 University of New South Wales

 *

 * All rights reserved.

 *

 * Developed by: Operating Systems and Distributed Systems Group (DiSy)

 *               University of New South Wales

 *               http://www.disy.cse.unsw.edu.au

 *

 * Permission is granted by University of New South Wales, free of charge, to

 * any person obtaining a copy of this software and any associated

 * documentation files (the "Software") to deal with the Software without

 * restriction, including (without limitation) the rights to use, copy,

 * modify, adapt, merge, publish, distribute, communicate to the public,

 * sublicense, and/or sell, lend or rent out copies of the Software, and

 * to permit persons to whom the Software is furnished to do so, subject

 * to the following conditions:

 *

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimers.

 *

 *     * Redistributions in binary form must reproduce the above

 *       copyright notice, this list of conditions and the following

 *       disclaimers in the documentation and/or other materials provided

 *       with the distribution.

 *

 *     * Neither the name of University of New South Wales, nor the names of its

 *       contributors, may be used to endorse or promote products derived

 *       from this Software without specific prior written permission.

 *

 * EXCEPT AS EXPRESSLY STATED IN THIS LICENCE AND TO THE FULL EXTENT

 * PERMITTED BY APPLICABLE LAW, THE SOFTWARE IS PROVIDED "AS-IS", AND

 * NATIONAL ICT AUSTRALIA AND ITS CONTRIBUTORS MAKE NO REPRESENTATIONS,

 * WARRANTIES OR CONDITIONS OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING

 * BUT NOT LIMITED TO ANY REPRESENTATIONS, WARRANTIES OR CONDITIONS

 * REGARDING THE CONTENTS OR ACCURACY OF THE SOFTWARE, OR OF TITLE,

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT,

 * THE ABSENCE OF LATENT OR OTHER DEFECTS, OR THE PRESENCE OR ABSENCE OF

 * ERRORS, WHETHER OR NOT DISCOVERABLE.

 *

 * TO THE FULL EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL

 * NATIONAL ICT AUSTRALIA OR ITS CONTRIBUTORS BE LIABLE ON ANY LEGAL

 * THEORY (INCLUDING, WITHOUT LIMITATION, IN AN ACTION OF CONTRACT,

 * NEGLIGENCE OR OTHERWISE) FOR ANY CLAIM, LOSS, DAMAGES OR OTHER

 * LIABILITY, INCLUDING (WITHOUT LIMITATION) LOSS OF PRODUCTION OR

 * OPERATION TIME, LOSS, DAMAGE OR CORRUPTION OF DATA OR RECORDS; OR LOSS

 * OF ANTICIPATED SAVINGS, OPPORTUNITY, REVENUE, PROFIT OR GOODWILL, OR

 * OTHER ECONOMIC LOSS; OR ANY SPECIAL, INCIDENTAL, INDIRECT,

 * CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES, ARISING OUT OF OR IN

 * CONNECTION WITH THIS LICENCE, THE SOFTWARE OR THE USE OF OR OTHER

 * DEALINGS WITH THE SOFTWARE, EVEN IF NATIONAL ICT AUSTRALIA OR ITS

 * CONTRIBUTORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH CLAIM, LOSS,

 * DAMAGES OR OTHER LIABILITY.

 *

 * If applicable legislation implies representations, warranties, or

 * conditions, or imposes obligations or liability on University of New South

 * Wales or one of its contributors in respect of the Software that

 * cannot be wholly or partly excluded, restricted or modified, the

 * liability of University of New South Wales or the contributor is limited, to

 * the full extent permitted by the applicable legislation, at its

 * option, to:

 * a.  in the case of goods, any one or more of the following:

 * i.  the replacement of the goods or the supply of equivalent goods;

 * ii.  the repair of the goods;

 * iii. the payment of the cost of replacing the goods or of acquiring

 *  equivalent goods;

 * iv.  the payment of the cost of having the goods repaired; or

 * b.  in the case of services:

 * i.  the supplying of the services again; or

 * ii.  the payment of the cost of having the services supplied again.

 *

 * The construction, validity and performance of this licence is governed

 * by the laws in force in New South Wales, Australia.

 */

void *str;

#include <elf/elf.h>

#include <string.h>

#include <stdio.h>

/*

 * Checks that elfFile points to a valid elf file. Returns 0 if the elf

 * file is valid, < 0 if invalid.

 */

#define ISELF32(elfFile) ( ((struct Elf32_Header*)elfFile)->e_ident[EI_CLASS] == ELFCLASS32 )

#define ISELF64(elfFile) ( ((struct Elf64_Header*)elfFile)->e_ident[EI_CLASS] == ELFCLASS64 )

int

elf_checkFile(void *elfFile)

{

        return ISELF32 (elfFile)

                ? elf32_checkFile(elfFile)

                : elf64_checkFile(elfFile);

}

/* Program Headers Access functions */

uint16_t

elf_getNumProgramHeaders(void *elfFile)

{

        return ISELF32 (elfFile)

                ? elf32_getNumProgramHeaders(elfFile)

                : elf64_getNumProgramHeaders(elfFile);

}

uint32_t

elf_getProgramHeaderFlags(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderFlags(elfFile, ph)

                : elf64_getProgramHeaderFlags(elfFile, ph);

}

uint32_t

elf_getProgramHeaderType(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderType(elfFile, ph)

                : elf64_getProgramHeaderType(elfFile, ph);

}

uint64_t

elf_getProgramHeaderPaddr(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderPaddr(elfFile, ph)

                : elf64_getProgramHeaderPaddr(elfFile, ph);

}

uint64_t

elf_getProgramHeaderVaddr(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderVaddr(elfFile, ph)

                : elf64_getProgramHeaderVaddr(elfFile, ph);

}

uint64_t

elf_getProgramHeaderMemorySize(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderMemorySize(elfFile, ph)

                : elf64_getProgramHeaderMemorySize(elfFile, ph);

}

uint64_t

elf_getProgramHeaderFileSize(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderFileSize(elfFile, ph)

                : elf64_getProgramHeaderFileSize(elfFile, ph);

}

uint64_t

elf_getProgramHeaderOffset(void *elfFile, uint16_t ph)

{

        return ISELF32 (elfFile)

                ? elf32_getProgramHeaderOffset(elfFile, ph)

                : elf64_getProgramHeaderOffset(elfFile, ph);

}

char *

elf_getSegmentStringTable(void *elfFile)

{

        return ISELF32 (elfFile)

                ? elf32_getSegmentStringTable(elfFile)

                : elf64_getSegmentStringTable(elfFile);

}

char *

elf_getStringTable(void *elfFile, int string_segment)

{

        return ISELF32 (elfFile)

                ? elf32_getStringTable(elfFile)

                : elf64_getStringTable(elfFile, string_segment);

}

unsigned

elf_getNumSections(void *elfFile)

{

        return ISELF32 (elfFile)

                ? elf32_getNumSections(elfFile)

                : elf64_getNumSections(elfFile);

}

char *

elf_getSectionName(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionName(elfFile, i)

                : elf64_getSectionName(elfFile, i);

}

uint32_t

elf_getSectionFlags(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionFlags(elfFile, i)

                : elf64_getSectionFlags(elfFile, i);

}

uint32_t

elf_getSectionType(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionType(elfFile, i)

                : elf64_getSectionType(elfFile, i);

}

uint64_t

elf_getSectionSize(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionSize(elfFile, i)

                : elf64_getSectionSize(elfFile, i);

}

uint64_t

elf_getSectionAddr(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionAddr(elfFile, i)

                : elf64_getSectionAddr(elfFile, i);

}

void *

elf_getSection(void *elfFile, int i)

{

        return ISELF32 (elfFile)

                ? elf32_getSection(elfFile, i)

                : elf64_getSection(elfFile, i);

}

void *

elf_getSectionNamed(void *elfFile, char *_str)

{

        return ISELF32 (elfFile)

                ? elf32_getSectionNamed(elfFile, _str)

                : elf64_getSectionNamed(elfFile, _str);

}

void

elf_getProgramHeaderInfo(void *elfFile, uint16_t ph, uint64_t *p_vaddr,

                         uint64_t *p_paddr, uint64_t *p_filesz, uint64_t *p_offset,

                         uint64_t *p_memsz)

{

        *p_vaddr = elf_getProgramHeaderVaddr(elfFile, ph);

        *p_paddr = elf_getProgramHeaderPaddr(elfFile, ph);

        *p_filesz = elf_getProgramHeaderFileSize(elfFile, ph);

        *p_offset = elf_getProgramHeaderOffset(elfFile, ph);

        *p_memsz = elf_getProgramHeaderMemorySize(elfFile, ph);

}

uint64_t

elf_getEntryPoint(void *elfFile)

{

        return ISELF32 (elfFile)

                ? elf32_getEntryPoint (elfFile)

                : elf64_getEntryPoint (elfFile);

}

void

elf_fprintf(FILE *f, void *file, int size, const char *name, int flags)

{

        elf32_fprintf(f, file, size, name, flags);

}

bool

elf_getMemoryBounds(void *elfFile, bool phys, uint64_t *min, uint64_t *max)

{

        uint64_t mem_min = UINT64_MAX;

        uint64_t mem_max = 0;

        int i;

        if (elf_checkFile(elfFile) != 0) {

                return false;

        }

        for(i=0; i < elf_getNumProgramHeaders(elfFile); i++) {

                uint64_t sect_min, sect_max;

                if (elf_getProgramHeaderMemorySize(elfFile, i) == 0) {

                        continue;

                }

                if (phys) {

                        sect_min = elf_getProgramHeaderPaddr(elfFile, i);

                } else {

                        sect_min = elf_getProgramHeaderVaddr(elfFile, i);

                }

                sect_max = sect_min + elf_getProgramHeaderMemorySize(elfFile, i);

                if (sect_max > mem_max) {

                        mem_max = sect_max;

                }

                if (sect_min < mem_min) {

                        mem_min = sect_min;

                }

        }

        *min = mem_min;

        *max = mem_max;

        return true;

};

bool

elf_vaddrInProgramHeader(void *elfFile, uint16_t ph, uint64_t vaddr)

{

        uint64_t min = elf_getProgramHeaderVaddr(elfFile, ph);

        uint64_t max = min + elf_getProgramHeaderMemorySize(elfFile, ph);

        if (vaddr >= min && vaddr < max) {

                return true;

        } else {

                return false;

        }

}

uint64_t

elf_vtopProgramHeader(void *elfFile, uint16_t ph, uint64_t vaddr)

{

        uint64_t ph_phys = elf_getProgramHeaderPaddr(elfFile, ph);

        uint64_t ph_virt = elf_getProgramHeaderVaddr(elfFile, ph);

        uint64_t paddr;

        paddr = vaddr - ph_virt + ph_phys;

        return paddr;

}

bool

elf_loadFile(void *elfFile, bool phys)

{

        int i;

        int num_pheaders;

        int pheader_offset;

        int pheader_type;

        if (elf_checkFile(elfFile) != 0) {

                return false;

        }

        num_pheaders = elf_getNumProgramHeaders(elfFile);

        pheader_offset = elf_getProgramHeaderOffset(elfFile, 0);

        //printf("Number of program headers: %d\n", num_pheaders);

        //printf("Program header offset of first header from file beginning: 0x%p\n",pheader_offset);

        /*

         * FIXME:

         * This should have a linked list of mapped ranges so that it can check

         * at run-time whether any images are overlapping in their LMA and refuse to load.

         */

        for(i=0; i < num_pheaders; i++) {

                /* Load that section */

                uint64_t dest, src;

                uint32_t clrsize;

                size_t len;

                if (phys) {

                        dest = elf_getProgramHeaderPaddr(elfFile, i);

                //      printf("Elf file pheader physical: 0x%x\n", (unsigned int)dest);

                //      printf("Elf file pheader virtual: 0x%x\n",

                //             (unsigned int)elf_getProgramHeaderVaddr(elfFile,i));

                } else {

                //      printf("Elf file pheader virtual: 0x%x\n", (unsigned int)dest);

                        dest = elf_getProgramHeaderVaddr(elfFile, i);

                }

                len = elf_getProgramHeaderFileSize(elfFile, i);

        //      printf("This section's size in file: %p\n", len);

                src = (uint64_t) (uintptr_t) elfFile + elf_getProgramHeaderOffset(elfFile, i);

        //      printf("Elf program header offset: %p\n", src);

                pheader_type = elf_getProgramHeaderType(elfFile, i);

        //      printf("Elf program header type: %p\n", pheader_type);

// Comment

//printf("Copying to range from 0x%x to 0x%x of size: 0x%x\n", (unsigned int)dest, (unsigned int)dest + (unsigned int)len, (unsigned int)len);

                memcpy((void*) (uintptr_t) dest, (void*) (uintptr_t) src, len);

                dest += len;

                clrsize = elf_getProgramHeaderMemorySize(elfFile, i) - len;

//              printf("Clearing memory... starting from %x, size: %x\n", (unsigned int)dest, (unsigned int)clrsize);

                memset((void*) (uintptr_t) dest, 0, clrsize);

//              printf("Memory cleared.\n");

        }

// And this one

//      printf("\n");

        return true;

}