libelf: new elf parser for xen

420 lines not on this page · raw message

156 lines not on this page · raw message

51 lines not on this page · raw message

345 lines not on this page · raw message

225 lines not on this page · raw message

527 lines not on this page · raw message

238 lines not on this page · raw message

525 lines not on this page · raw message

496 lines not on this page · raw message

Index: build-32-unstable-13377/xen/arch/x86/boot/mkelf32.c
===================================================================
@@ -25,7 +25,7 @@
 #define s16 int16_t
 #define s32 int32_t
 #define s64 int64_t
-#include "../../../include/xen/elf.h"
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

515 lines not on this page · raw message

133 lines not on this page · raw message

Index: build-32-unstable-12802/tools/libxc/xc_hvm_build.c
===================================================================
@@ -2,29 +2,22 @@
  * xc_hvm_build.c
  */
 
-#define ELFSIZE 32
 #include <stddef.h>
 #include <inttypes.h>
-#include "xg_private.h"
-#include "xc_private.h"
-#include "xc_elf.h"
 #include <stdlib.h>
 #include <unistd.h>
 #include <zlib.h>
+
+#include "xg_private.h"
+#include "xc_private.h"
+
 #include <xen/hvm/hvm_info_table.h>
 #include <xen/hvm/params.h>
 #include <xen/hvm/e820.h>
 
-#define SCRATCH_PFN 0xFFFFF
+#include <xen/libelf.h>
 
-#define HVM_LOADER_ENTR_ADDR  0x00100000
-static int
-parseelfimage(
-    char *elfbase, unsigned long elfsize, struct domain_setup_info *dsi);
-static int
-loadelfimage(
-    char *elfbase, int xch, uint32_t dom, unsigned long *parray,
-    struct domain_setup_info *dsi);
+#define SCRATCH_PFN 0xFFFFF
 
 int xc_set_hvm_param(
     int handle, domid_t dom, int param, unsigned long value)

@@ -144,6 +137,48 @@ static void build_e820map(void *e820_pag
     *(((unsigned char *)e820_page) + E820_MAP_NR_OFFSET) = nr_map;
 }
 
+static int
+loadelfimage(struct elf_binary *elf, int xch, uint32_t dom, unsigned long *parray)
+{
+    privcmd_mmap_entry_t *entries = NULL;
+    int pages = (elf->pend - elf->pstart + PAGE_SIZE - 1) >> PAGE_SHIFT;
+    int i, rc = -1;
+
+    /* map hvmloader address space */
+    entries = malloc(pages * sizeof(privcmd_mmap_entry_t));
+    if (NULL == entries)
+        goto err;
+    elf->dest = mmap(NULL, pages << PAGE_SHIFT, PROT_READ | PROT_WRITE,
+                     MAP_SHARED, xch, 0);
+    if (MAP_FAILED == elf->dest)
+        goto err;
+
+    for (i = 0; i < pages; i++)
+    {
+        entries[i].va = (uintptr_t)elf->dest + (i << PAGE_SHIFT);
+        entries[i].mfn = parray[(elf->pstart >> PAGE_SHIFT) + i];
+        entries[i].npages = 1;
+    }
+    rc = xc_map_foreign_ranges(xch, dom, entries, pages);
+    if (rc < 0)
+        goto err;
+
+    /* load hvmloader */
+    elf_load_binary(elf);
+    rc = 0;
+
+ err:
+    /* cleanup */
+    if (elf->dest) {
+        munmap(elf->dest, pages << PAGE_SHIFT);
+        elf->dest = NULL;
+    }
+    if (entries)
+        free(entries);
+
+    return rc;
+}
+
 static int setup_guest(int xc_handle,
                        uint32_t dom, int memsize,
                        char *image, unsigned long image_size,

@@ -155,35 +190,35 @@ static int setup_guest(int xc_handle,
     struct xen_add_to_physmap xatp;
     struct shared_info *shared_info;
     void *e820_page;
-    struct domain_setup_info dsi;
-    uint64_t v_end;
+    struct elf_binary elf;
+    uint64_t v_start, v_end;
     int rc;
 
-    memset(&dsi, 0, sizeof(struct domain_setup_info));
-
-    if ( (parseelfimage(image, image_size, &dsi)) != 0 )
+    if (0 != elf_init(&elf, image, image_size))
         goto error_out;
+    elf_parse_binary(&elf);
+    v_start = 0;
+    v_end = (unsigned long long)memsize << 20;
 
-    if ( (dsi.v_kernstart & (PAGE_SIZE - 1)) != 0 )
+    if ( (elf.pstart & (PAGE_SIZE - 1)) != 0 )
     {
         PERROR("Guest OS must load to a page boundary.\n");
         goto error_out;
     }
 
-    v_end = (unsigned long long)memsize << 20;
-
     IPRINTF("VIRTUAL MEMORY ARRANGEMENT:\n"
-           "  Loaded HVM loader:    %016"PRIx64"->%016"PRIx64"\n"
-           "  TOTAL:                %016"PRIx64"->%016"PRIx64"\n",
-           dsi.v_kernstart, dsi.v_kernend,
-           dsi.v_start, v_end);
-    IPRINTF("  ENTRY ADDRESS:        %016"PRIx64"\n", dsi.v_kernentry);
+            "  Loaded HVM loader:    %016"PRIx64"->%016"PRIx64"\n"
+            "  TOTAL:                %016"PRIx64"->%016"PRIx64"\n"
+            "  ENTRY ADDRESS:        %016"PRIx64"\n",
+            elf.pstart, elf.pend,
+            v_start, v_end,
+            elf_uval(&elf, elf.ehdr, e_entry));
 
-    if ( (v_end - dsi.v_start) > ((unsigned long long)nr_pages << PAGE_SHIFT) )
+    if ( (v_end - v_start) > ((unsigned long long)nr_pages << PAGE_SHIFT) )
     {
         PERROR("Initial guest OS requires too much space: "
                "(%lluMB is greater than %lluMB limit)\n",
-               (unsigned long long)(v_end - dsi.v_start) >> 20,
+               (unsigned long long)(v_end - v_start) >> 20,
                ((unsigned long long)nr_pages << PAGE_SHIFT) >> 20);
         goto error_out;
     }

@@ -212,7 +247,7 @@ static int setup_guest(int xc_handle,
         goto error_out;
     }
 
-    loadelfimage(image, xc_handle, dom, page_array, &dsi);
+    loadelfimage(&elf, xc_handle, dom, page_array);
 
     if ( (e820_page = xc_map_foreign_range(
               xc_handle, dom, PAGE_SIZE, PROT_READ | PROT_WRITE,

@@ -256,7 +291,7 @@ static int setup_guest(int xc_handle,
 
     free(page_array);
 
-    ctxt->user_regs.eip = dsi.v_kernentry;
+    ctxt->user_regs.eip = elf_uval(&elf, elf.ehdr, e_entry);
 
     return 0;
 

@@ -315,131 +350,6 @@ static inline int is_loadable_phdr(Elf32
             ((phdr->p_flags & (PF_W|PF_X)) != 0));
 }
 
-static int parseelfimage(char *elfbase,
-                         unsigned long elfsize,
-                         struct domain_setup_info *dsi)
-{
-    Elf32_Ehdr *ehdr = (Elf32_Ehdr *)elfbase;
-    Elf32_Phdr *phdr;
-    Elf32_Shdr *shdr;
-    unsigned long kernstart = ~0UL, kernend=0UL;
-    char *shstrtab;
-    int h;
-
-    if ( !IS_ELF(*ehdr) )
-    {
-        xc_set_error(XC_INVALID_KERNEL,
-                     "Kernel image does not have an ELF header.");
-        return -EINVAL;
-    }
-
-    if ( (ehdr->e_phoff + (ehdr->e_phnum * ehdr->e_phentsize)) > elfsize )
-    {
-        xc_set_error(XC_INVALID_KERNEL,
-                     "ELF program headers extend beyond end of image.");
-        return -EINVAL;
-    }
-
-    if ( (ehdr->e_shoff + (ehdr->e_shnum * ehdr->e_shentsize)) > elfsize )
-    {
-        xc_set_error(XC_INVALID_KERNEL,
-                     "ELF section headers extend beyond end of image.");
-        return -EINVAL;
-    }
-
-    /* Find the section-header strings table. */
-    if ( ehdr->e_shstrndx == SHN_UNDEF )
-    {
-        xc_set_error(XC_INVALID_KERNEL,
-                     "ELF image has no section-header strings table (shstrtab).");
-        return -EINVAL;
-    }
-    shdr = (Elf32_Shdr *)(elfbase + ehdr->e_shoff +
-                          (ehdr->e_shstrndx*ehdr->e_shentsize));
-    shstrtab = elfbase + shdr->sh_offset;
-
-    for ( h = 0; h < ehdr->e_phnum; h++ )
-    {
-        phdr = (Elf32_Phdr *)(elfbase + ehdr->e_phoff + (h*ehdr->e_phentsize));
-        if ( !is_loadable_phdr(phdr) )
-            continue;
-        if ( phdr->p_paddr < kernstart )
-            kernstart = phdr->p_paddr;
-        if ( (phdr->p_paddr + phdr->p_memsz) > kernend )
-            kernend = phdr->p_paddr + phdr->p_memsz;
-    }
-
-    if ( (kernstart > kernend) ||
-         (ehdr->e_entry < kernstart) ||
-         (ehdr->e_entry > kernend) )
-    {
-        xc_set_error(XC_INVALID_KERNEL,
-                     "Malformed ELF image.");
-        return -EINVAL;
-    }
-
-    dsi->v_start = 0x00000000;
-
-    dsi->v_kernstart = kernstart;
-    dsi->v_kernend   = kernend;
-    dsi->v_kernentry = HVM_LOADER_ENTR_ADDR;
-
-    dsi->v_end       = dsi->v_kernend;
-
-    return 0;
-}
-
-static int
-loadelfimage(
-    char *elfbase, int xch, uint32_t dom, unsigned long *parray,
-    struct domain_setup_info *dsi)
-{
-    Elf32_Ehdr *ehdr = (Elf32_Ehdr *)elfbase;
-    Elf32_Phdr *phdr;
-    int h;
-
-    char         *va;
-    unsigned long pa, done, chunksz;
-
-    for ( h = 0; h < ehdr->e_phnum; h++ )
-    {
-        phdr = (Elf32_Phdr *)(elfbase + ehdr->e_phoff + (h*ehdr->e_phentsize));
-        if ( !is_loadable_phdr(phdr) )
-            continue;
-
-        for ( done = 0; done < phdr->p_filesz; done += chunksz )
-        {
-            pa = (phdr->p_paddr + done) - dsi->v_start;
-            if ((va = xc_map_foreign_range(
-                xch, dom, PAGE_SIZE, PROT_WRITE,
-                parray[pa >> PAGE_SHIFT])) == 0)
-                return -1;
-            chunksz = phdr->p_filesz - done;
-            if ( chunksz > (PAGE_SIZE - (pa & (PAGE_SIZE-1))) )
-                chunksz = PAGE_SIZE - (pa & (PAGE_SIZE-1));
-            memcpy(va + (pa & (PAGE_SIZE-1)),
-                   elfbase + phdr->p_offset + done, chunksz);
-            munmap(va, PAGE_SIZE);
-        }
-
-        for ( ; done < phdr->p_memsz; done += chunksz )
-        {
-            pa = (phdr->p_paddr + done) - dsi->v_start;
-            if ((va = xc_map_foreign_range(
-                xch, dom, PAGE_SIZE, PROT_WRITE,
-                parray[pa >> PAGE_SHIFT])) == 0)
-                return -1;
-            chunksz = phdr->p_memsz - done;
-            if ( chunksz > (PAGE_SIZE - (pa & (PAGE_SIZE-1))) )
-                chunksz = PAGE_SIZE - (pa & (PAGE_SIZE-1));
-            memset(va + (pa & (PAGE_SIZE-1)), 0, chunksz);
-            munmap(va, PAGE_SIZE);
-        }
-    }
-
-    return 0;
-}
-
 /* xc_hvm_build
  *
  * Create a domain for a virtualized Linux, using files/filenames

Index: build-32-unstable-13534/tools/xcutils/readnotes.c
===================================================================
@@ -1,4 +1,3 @@
-#include <elf.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>

@@ -11,219 +10,35 @@
 #include <sys/stat.h>
 #include <sys/mman.h>
 
-#include <xen/elfnote.h>
-
-#define ELFNOTE_NAME(_n_) ((char*)(_n_) + sizeof(*(_n_)))
-#define ELFNOTE_DESC(_n_) (ELFNOTE_NAME(_n_) + (((_n_)->n_namesz+3)&~3))
-#define ELFNOTE_NEXT(_n_) (ELFNOTE_DESC(_n_) + (((_n_)->n_descsz+3)&~3))
-
-#ifndef ELFSIZE
-#include <limits.h>
-#if UINT_MAX == ULONG_MAX
-#define ELFSIZE 32
-#else
-#define ELFSIZE 64
-#endif
-#endif
-
-#if (ELFSIZE == 32)
-typedef Elf32_Nhdr Elf_Nhdr;
-typedef Elf32_Half Elf_Half;
-typedef Elf32_Word Elf_Word;
-#elif (ELFSIZE == 64)
-typedef Elf64_Nhdr Elf_Nhdr;
-typedef Elf64_Half Elf_Half;
-typedef Elf64_Word Elf_Word;
-#else
-#error "Unknown ELFSIZE"
-#endif
-
-static void print_string_note(const char *prefix, Elf_Nhdr *note)
-{
-	printf("%s: %s\n", prefix, (const char *)ELFNOTE_DESC(note));
-}
-
-static void print_numeric_note(const char *prefix,Elf_Nhdr *note)
-{
-	switch (note->n_descsz)
-	{
-	case 4:
-		printf("%s: %#010" PRIx32 " (4 bytes)\n",
-		       prefix, *(uint32_t *)ELFNOTE_DESC(note));
-		break;
-	case 8:
-		printf("%s: %#018" PRIx64 " (8 bytes)\n",
-		       prefix, *(uint64_t *)ELFNOTE_DESC(note));
-		break;
-	default:
-		printf("%s: unknown data size %#lx\n", prefix,
-		       (unsigned long)note->n_descsz);
-		break;
-	}
-}
-
-static inline int is_elf(void *image)
-{
-	/*
-	 * Since we are only accessing the e_ident field we can
-	 * acccess the bytes directly without needing to figure out
-	 * which version of Elf*_Ehdr structure to use.
-	 */
-	const unsigned char *hdr = image;
-	return ( hdr[EI_MAG0] == ELFMAG0 &&
-		 hdr[EI_MAG1] == ELFMAG1 &&
-		 hdr[EI_MAG2] == ELFMAG2 &&
-		 hdr[EI_MAG3] == ELFMAG3 );
-}
-
-static inline unsigned char ehdr_class(void *image)
-{
-	/*
-	 * Since we are only accessing the e_ident field we can
-	 * acccess the bytes directly without needing to figure out
-	 * which version of Elf*_Ehdr structure to use.
-	 */
-	const unsigned char *hdr = image;
-	switch (hdr[EI_CLASS])
-	{
-	case ELFCLASS32:
-	case ELFCLASS64:
-		return hdr[EI_CLASS];
-	default:
-		fprintf(stderr, "Unknown ELF class %d\n", hdr[EI_CLASS]);
-		exit(1);
-	}
-}
+#include <xg_private.h>
 
-static inline Elf_Half ehdr_shnum(void *image)
-{
-	switch (ehdr_class(image))
-	{
-	case ELFCLASS32:
-		return ((Elf32_Ehdr *)image)->e_shnum;
-	case ELFCLASS64:
-		return ((Elf64_Ehdr *)image)->e_shnum;
-	default:
-		exit(1);
-	}
-}
+#include <xen/libelf.h>
 
-static inline Elf_Word shdr_type(void *image, int shnum)
+static void print_string_note(const char *prefix, struct elf_binary *elf,
+			      const elf_note *note)
 {
-	switch (ehdr_class(image))
-	{
-	case ELFCLASS32:
-	{
-		Elf32_Ehdr *ehdr = (Elf32_Ehdr *)image;
-		Elf32_Shdr *shdr = (Elf32_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return shdr->sh_type;
-	}
-	case ELFCLASS64:
-	{
-		Elf64_Ehdr *ehdr = (Elf64_Ehdr *)image;
-		Elf64_Shdr *shdr = (Elf64_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return shdr->sh_type;
-	}
-	default:
-		exit(1);
-	}
+	printf("%s: %s\n", prefix, (char*)elf_note_desc(elf, note));
 }
 
-static inline const char *shdr_name(void *image, int shnum)
-{
-	const char *shstrtab;
-
-	switch (ehdr_class(image))
-	{
-	case ELFCLASS32:
-	{
-		Elf32_Ehdr *ehdr = (Elf32_Ehdr *)image;
-		Elf32_Shdr *shdr;
-		/* Find the section-header strings table. */
-		if ( ehdr->e_shstrndx == SHN_UNDEF )
-			return NULL;
-		shdr = (Elf32_Shdr *)(image + ehdr->e_shoff +
-				      (ehdr->e_shstrndx*ehdr->e_shentsize));
-		shstrtab = image + shdr->sh_offset;
-
-		shdr= (Elf32_Shdr*)(image + ehdr->e_shoff +
-				    (shnum*ehdr->e_shentsize));
-		return &shstrtab[shdr->sh_name];
-	}
-	case ELFCLASS64:
-	{
-		Elf64_Ehdr *ehdr = (Elf64_Ehdr *)image;
-		Elf64_Shdr *shdr;
-		/* Find the section-header strings table. */
-		if ( ehdr->e_shstrndx == SHN_UNDEF )
-			return NULL;
-		shdr = (Elf64_Shdr *)(image + ehdr->e_shoff +
-				      (ehdr->e_shstrndx*ehdr->e_shentsize));
-		shstrtab = image + shdr->sh_offset;
-
-		shdr= (Elf64_Shdr*)(image + ehdr->e_shoff +
-				    (shnum*ehdr->e_shentsize));
-		return &shstrtab[shdr->sh_name];
-	}
-	default:
-		exit(1);
-	}
-}
-static inline void *shdr_start(void *image, int shnum)
+static void print_numeric_note(const char *prefix, struct elf_binary *elf,
+			       const elf_note *note)
 {
-	switch (ehdr_class(image))
-	{
-	case ELFCLASS32:
-	{
-		Elf32_Ehdr *ehdr = (Elf32_Ehdr *)image;
-		Elf32_Shdr *shdr = (Elf32_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return image + shdr->sh_offset;
-	}
-	case ELFCLASS64:
-	{
-		Elf64_Ehdr *ehdr = (Elf64_Ehdr *)image;
-		Elf64_Shdr *shdr = (Elf64_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return image + shdr->sh_offset;
-	}
-	default:
-		exit(1);
-	}
-}
+	uint64_t value = elf_note_numeric(elf, note);
+	int descsz = elf_uval(elf, note, descsz);
 
-static inline void *shdr_end(void *image, int shnum)
-{
-	switch (ehdr_class(image))
-	{
-	case ELFCLASS32:
-	{
-		Elf32_Ehdr *ehdr = (Elf32_Ehdr *)image;
-		Elf32_Shdr *shdr = (Elf32_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return image + shdr->sh_offset + shdr->sh_size;
-	}
-	case ELFCLASS64:
-	{
-		Elf64_Ehdr *ehdr = (Elf64_Ehdr *)image;
-		Elf64_Shdr *shdr = (Elf64_Shdr*)(image + ehdr->e_shoff +
-						 (shnum*ehdr->e_shentsize));
-		return image + shdr->sh_offset + shdr->sh_size;
-	}
-	default:
-		exit(1);
-	}
+	printf("%s: %#*" PRIx64 " (%d bytes)\n",
+	       prefix, 2+2*descsz, value, descsz);
 }
 
 int main(int argc, char **argv)
 {
 	const char *f;
-	int fd,h;
+	int fd,h,size,count;
 	void *image;
 	struct stat st;
-	Elf_Nhdr *note;
+	struct elf_binary elf;
+	const elf_shdr *shdr;
+	const elf_note *note, *end;
 
 	if (argc != 2)
 	{

@@ -251,76 +66,74 @@ int main(int argc, char **argv)
 		fprintf(stderr, "Unable to map %s: %s\n", f, strerror(errno));
 		return 1;
 	}
+	size = st.st_size;
 
-	if ( !is_elf(image) )
+	if (0 != elf_init(&elf, image, size))
 	{
 		fprintf(stderr, "File %s is not an ELF image\n", f);
 		return 1;
 	}
+	elf_set_logfile(&elf, stderr, 0);
 
-	for ( h=0; h < ehdr_shnum(image); h++)
+	count = elf_shdr_count(&elf);
+	for ( h=0; h < count; h++)
 	{
-		if (shdr_type(image,h) != SHT_NOTE)
+		shdr = elf_shdr_by_index(&elf, h);
+		if (elf_uval(&elf, shdr, sh_type) != SHT_NOTE)
 			continue;
-		for (note = (Elf_Nhdr*)shdr_start(image,h);
-		     note < (Elf_Nhdr*)shdr_end(image,h);
-		     note = (Elf_Nhdr*)(ELFNOTE_NEXT(note)))
+		end = elf_section_end(&elf, shdr);
+		for (note = elf_section_start(&elf, shdr);
+		     note < end;
+		     note = elf_note_next(&elf, note))
 		{
-			switch(note->n_type)
+			if (0 != strcmp(elf_note_name(&elf, note), "Xen"))
+				continue;
+			switch(elf_uval(&elf, note, type))
 			{
 			case XEN_ELFNOTE_INFO:
-				print_string_note("INFO", note);
+				print_string_note("INFO", &elf , note);
 				break;
 			case XEN_ELFNOTE_ENTRY:
-				print_numeric_note("ENTRY", note);
+				print_numeric_note("ENTRY", &elf , note);
 				break;
 			case XEN_ELFNOTE_HYPERCALL_PAGE:
-				print_numeric_note("HYPERCALL_PAGE", note);
+				print_numeric_note("HYPERCALL_PAGE", &elf , note);
 				break;
 			case XEN_ELFNOTE_VIRT_BASE:
-				print_numeric_note("VIRT_BASE", note);
+				print_numeric_note("VIRT_BASE", &elf , note);
 				break;
 			case XEN_ELFNOTE_PADDR_OFFSET:
-				print_numeric_note("PADDR_OFFSET", note);
+				print_numeric_note("PADDR_OFFSET", &elf , note);
 				break;
 			case XEN_ELFNOTE_XEN_VERSION:
-				print_string_note("XEN_VERSION", note);
+				print_string_note("XEN_VERSION", &elf , note);
 				break;
 			case XEN_ELFNOTE_GUEST_OS:
-				print_string_note("GUEST_OS", note);
+				print_string_note("GUEST_OS", &elf , note);
 				break;
 			case XEN_ELFNOTE_GUEST_VERSION:
-				print_string_note("GUEST_VERSION", note);
+				print_string_note("GUEST_VERSION", &elf , note);
 				break;
 			case XEN_ELFNOTE_LOADER:
-				print_string_note("LOADER", note);
+				print_string_note("LOADER", &elf , note);
 				break;
 			case XEN_ELFNOTE_PAE_MODE:
-				print_string_note("PAE_MODE", note);
+				print_string_note("PAE_MODE", &elf , note);
 				break;
 			case XEN_ELFNOTE_FEATURES:
-				print_string_note("FEATURES", note);
+				print_string_note("FEATURES", &elf , note);
 				break;
 			default:
-				printf("unknown note type %#lx\n",
-				       (unsigned long)note->n_type);
+				printf("unknown note type %#x\n",
+				       (int)elf_uval(&elf, note, type));
 				break;
 			}
 		}
 	}
 
-	for ( h=0; h < ehdr_shnum(image); h++)
-	{
-		const char *name = shdr_name(image,h);
-
-		if ( name == NULL )
-			continue;
-		if ( strcmp(name, "__xen_guest") != 0 )
-			continue;
-
-		printf("__xen_guest: %s\n", (const char *)shdr_start(image, h));
-		break;
-	}
+	shdr = elf_shdr_by_name(&elf, "__xen_guest");
+	if (shdr)
+		printf("__xen_guest: %s\n", (char*)elf_section_start(&elf, shdr));
 
 	return 0;
 }