sambuc/codezero
1
0
Fork 0
mirror of https://github.com/drasko/codezero.git synced 2026-01-22 15:53:16 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Bahadir Balban
2008-01-13 13:53:52 +00:00
commit e2b791a3d8
789 changed files with 95825 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

383
libs/elf/src/elf.c Normal file
View File

@@ -0,0 +1,383 @@
/*
* 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);
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: %p\n", dest);
// printf("Elf file pheader virtual: %p\n",
// elf_getProgramHeaderVaddr(elfFile,i));
} else {
// printf("Elf file pheader virtual: %p\n", 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);
// printf("Copying from %x to %x of size: %p\n", (unsigned int)src, (unsigned int)dest, 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, clrsize);
memset((void*) (uintptr_t) dest, 0, clrsize);
// printf("Memory cleared.\n");
}
return true;
}