brl/citadel
1
0
Fork 2
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity
f287e7d92d
citadel/poky/meta/recipes-core/glibc/ldconfig-native-2.12.1/32and64bit.patch

332 lines
9.5 KiB
Diff
Raw Blame History

Upstream-Status: Inappropriate [embedded specific]
We run the ldconfig in the cross fashion. make the code bitsize aware so that
we can cross build ldconfig cache for various architectures.
Richard Purdie <richard.purdie@linuxfoundation.org> 2009/05/19
Nitin A Kamble <nitin.a.kamble@intel.com> 2009/03/29
Index: ldconfig-native-2.12.1/readelflib.c
===================================================================
--- ldconfig-native-2.12.1.orig/readelflib.c
+++ ldconfig-native-2.12.1/readelflib.c
@@ -40,39 +40,212 @@ do \
/* Returns 0 if everything is ok, != 0 in case of error. */
int
-process_elf_file (const char *file_name, const char *lib, int *flag,
+process_elf_file32 (const char *file_name, const char *lib, int *flag,
unsigned int *osversion, char **soname, void *file_contents,
size_t file_length)
{
int i;
unsigned int j;
- ElfW(Addr) loadaddr;
+ Elf32_Addr loadaddr;
unsigned int dynamic_addr;
size_t dynamic_size;
char *program_interpreter;
- ElfW(Ehdr) *elf_header;
- ElfW(Phdr) *elf_pheader, *segment;
- ElfW(Dyn) *dynamic_segment, *dyn_entry;
+ Elf32_Ehdr *elf_header;
+ Elf32_Phdr *elf_pheader, *segment;
+ Elf32_Dyn *dynamic_segment, *dyn_entry;
char *dynamic_strings;
- elf_header = (ElfW(Ehdr) *) file_contents;
+ elf_header = (Elf32_Ehdr *) file_contents;
*osversion = 0;
- if (elf_header->e_ident [EI_CLASS] != ElfW (CLASS))
+ if (elf_header->e_type != ET_DYN)
{
- if (opt_verbose)
+ error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
+ elf_header->e_type);
+ return 1;
+ }
+
+ /* Get information from elf program header. */
+ elf_pheader = (Elf32_Phdr *) (elf_header->e_phoff + file_contents);
+ check_ptr (elf_pheader);
+
+ /* The library is an elf library, now search for soname and
+ libc5/libc6. */
+ *flag = FLAG_ELF;
+
+ loadaddr = -1;
+ dynamic_addr = 0;
+ dynamic_size = 0;
+ program_interpreter = NULL;
+ for (i = 0, segment = elf_pheader;
+ i < elf_header->e_phnum; i++, segment++)
+ {
+ check_ptr (segment);
+
+ switch (segment->p_type)
{
- if (elf_header->e_ident [EI_CLASS] == ELFCLASS32)
- error (0, 0, _("%s is a 32 bit ELF file.\n"), file_name);
- else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64)
- error (0, 0, _("%s is a 64 bit ELF file.\n"), file_name);
- else
- error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name);
+ case PT_LOAD:
+ if (loadaddr == (Elf32_Addr) -1)
+ loadaddr = segment->p_vaddr - segment->p_offset;
+ break;
+
+ case PT_DYNAMIC:
+ if (dynamic_addr)
+ error (0, 0, _("more than one dynamic segment\n"));
+
+ dynamic_addr = segment->p_offset;
+ dynamic_size = segment->p_filesz;
+ break;
+
+ case PT_INTERP:
+ program_interpreter = (char *) (file_contents + segment->p_offset);
+ check_ptr (program_interpreter);
+
+ /* Check if this is enough to classify the binary. */
+ for (j = 0; j < sizeof (interpreters) / sizeof (interpreters [0]);
+ ++j)
+ if (strcmp (program_interpreter, interpreters[j].soname) == 0)
+ {
+ *flag = interpreters[j].flag;
+ break;
+ }
+ break;
+
+ case PT_NOTE:
+ if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4)
+ {
+ Elf32_Word *abi_note = (Elf32_Word *) (file_contents
+ + segment->p_offset);
+ Elf32_Addr size = segment->p_filesz;
+
+ while (abi_note [0] != 4 || abi_note [1] != 16
+ || abi_note [2] != 1
+ || memcmp (abi_note + 3, "GNU", 4) != 0)
+ {
+#define ROUND(len) (((len) + sizeof (Elf32_Word)) - 1) & -sizeof (Elf32_Word)))
+ Elf32_Addr) note_size = 3 * sizeof (Elf32_Word))
+ + ROUND (abi_note[0])
+ + ROUND (abi_note[1]);
+
+ if (size - 32 < note_size || note_size == 0)
+ {
+ size = 0;
+ break;
+ }
+ size -= note_size;
+ abi_note = (void *) abi_note + note_size;
+ }
+
+ if (size == 0)
+ break;
+
+ *osversion = (abi_note [4] << 24) |
+ ((abi_note [5] & 0xff) << 16) |
+ ((abi_note [6] & 0xff) << 8) |
+ (abi_note [7] & 0xff);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ }
+ if (loadaddr == (Elf32_Addr) -1)
+ {
+ /* Very strange. */
+ loadaddr = 0;
+ }
+
+ /* Now we can read the dynamic sections. */
+ if (dynamic_size == 0)
+ return 1;
+
+ dynamic_segment = (Elf32_Dyn *) (file_contents + dynamic_addr);
+ check_ptr (dynamic_segment);
+
+ /* Find the string table. */
+ dynamic_strings = NULL;
+ for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
+ ++dyn_entry)
+ {
+ check_ptr (dyn_entry);
+ if (dyn_entry->d_tag == DT_STRTAB)
+ {
+ dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr);
+ check_ptr (dynamic_strings);
+ break;
}
- return 1;
}
+ if (dynamic_strings == NULL)
+ return 1;
+
+ /* Now read the DT_NEEDED and DT_SONAME entries. */
+ for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
+ ++dyn_entry)
+ {
+ if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
+ {
+ char *name = dynamic_strings + dyn_entry->d_un.d_val;
+ check_ptr (name);
+
+ if (dyn_entry->d_tag == DT_NEEDED)
+ {
+
+ if (*flag == FLAG_ELF)
+ {
+ /* Check if this is enough to classify the binary. */
+ for (j = 0;
+ j < sizeof (known_libs) / sizeof (known_libs [0]);
+ ++j)
+ if (strcmp (name, known_libs [j].soname) == 0)
+ {
+ *flag = known_libs [j].flag;
+ break;
+ }
+ }
+ }
+
+ else if (dyn_entry->d_tag == DT_SONAME)
+ *soname = xstrdup (name);
+
+ /* Do we have everything we need? */
+ if (*soname && *flag != FLAG_ELF)
+ return 0;
+ }
+ }
+
+ /* We reach this point only if the file doesn't contain a DT_SONAME
+ or if we can't classify the library. If it doesn't have a
+ soname, return the name of the library. */
+ if (*soname == NULL)
+ *soname = xstrdup (lib);
+
+ return 0;
+}
+
+int
+process_elf_file64 (const char *file_name, const char *lib, int *flag,
+ unsigned int *osversion, char **soname, void *file_contents,
+ size_t file_length)
+{
+ int i;
+ unsigned int j;
+ Elf64_Addr loadaddr;
+ unsigned int dynamic_addr;
+ size_t dynamic_size;
+ char *program_interpreter;
+
+ Elf64_Ehdr *elf_header;
+ Elf64_Phdr *elf_pheader, *segment;
+ Elf64_Dyn *dynamic_segment, *dyn_entry;
+ char *dynamic_strings;
+
+ elf_header = (Elf64_Ehdr *) file_contents;
+ *osversion = 0;
+
if (elf_header->e_type != ET_DYN)
{
error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
@@ -81,7 +254,7 @@ process_elf_file (const char *file_name,
}
/* Get information from elf program header. */
- elf_pheader = (ElfW(Phdr) *) (elf_header->e_phoff + file_contents);
+ elf_pheader = (Elf64_Phdr *) (elf_header->e_phoff + file_contents);
check_ptr (elf_pheader);
/* The library is an elf library, now search for soname and
@@ -100,7 +273,7 @@ process_elf_file (const char *file_name,
switch (segment->p_type)
{
case PT_LOAD:
- if (loadaddr == (ElfW(Addr)) -1)
+ if (loadaddr == (Elf64_Addr) -1)
loadaddr = segment->p_vaddr - segment->p_offset;
break;
@@ -129,16 +302,16 @@ process_elf_file (const char *file_name,
case PT_NOTE:
if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4)
{
- ElfW(Word) *abi_note = (ElfW(Word) *) (file_contents
+ Elf64_Word *abi_note = (Elf64_Word *) (file_contents
+ segment->p_offset);
- ElfW(Addr) size = segment->p_filesz;
+ Elf64_Addr size = segment->p_filesz;
while (abi_note [0] != 4 || abi_note [1] != 16
|| abi_note [2] != 1
|| memcmp (abi_note + 3, "GNU", 4) != 0)
{
-#define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word)))
- ElfW(Addr) note_size = 3 * sizeof (ElfW(Word))
+#define ROUND(len) (((len) + sizeof (Elf64_Word) - 1) & -sizeof (Elf64_Word))
+ Elf64_Addr note_size = 3 * sizeof (Elf64_Word)
+ ROUND (abi_note[0])
+ ROUND (abi_note[1]);
@@ -166,7 +339,7 @@ process_elf_file (const char *file_name,
}
}
- if (loadaddr == (ElfW(Addr)) -1)
+ if (loadaddr == (Elf64_Addr) -1)
{
/* Very strange. */
loadaddr = 0;
@@ -176,7 +349,7 @@ process_elf_file (const char *file_name,
if (dynamic_size == 0)
return 1;
- dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr);
+ dynamic_segment = (Elf64_Dyn *) (file_contents + dynamic_addr);
check_ptr (dynamic_segment);
/* Find the string table. */
@@ -233,3 +406,33 @@ process_elf_file (const char *file_name,
return 0;
}
+/* Returns 0 if everything is ok, != 0 in case of error. */
+int
+process_elf_file (const char *file_name, const char *lib, int *flag,
+ unsigned int *osversion, char **soname, void *file_contents,
+ size_t file_length)
+{
+ int i;
+ unsigned int j;
+ ElfW(Addr) loadaddr;
+ unsigned int dynamic_addr;
+ size_t dynamic_size;
+ char *program_interpreter;
+
+ ElfW(Ehdr) *elf_header;
+ ElfW(Phdr) *elf_pheader, *segment;
+ ElfW(Dyn) *dynamic_segment, *dyn_entry;
+ char *dynamic_strings;
+
+ elf_header = (ElfW(Ehdr) *) file_contents;
+ *osversion = 0;
+
+ if (elf_header->e_ident [EI_CLASS] == ELFCLASS32)
+ return process_elf_file32(file_name, lib,flag, osversion, soname, file_contents, file_length);
+ else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64)
+ return process_elf_file64(file_name, lib,flag, osversion, soname, file_contents, file_length);
+ error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name);
+ return 1;
+}
+
+
Reference in New Issue View Git Blame Copy Permalink