ia64/xen-unstable

changeset 15703:7ee30cf72fd3

libelf: Clean up and fix up BSD symtab handling.
Should now (hopefully) work for domU and dom0 builders.
Signed-off-by: Keir Fraser <keir@xensource.com>
author kfraser@localhost.localdomain
date Thu Aug 02 14:18:38 2007 +0100 (2007-08-02)
parents 78be123257fa
children 9f939ff527ee
files xen/arch/x86/domain_build.c xen/common/libelf/libelf-dominfo.c xen/common/libelf/libelf-loader.c xen/common/libelf/libelf-tools.c xen/include/public/libelf.h
line diff
     1.1 --- a/xen/arch/x86/domain_build.c	Thu Aug 02 10:05:14 2007 +0100
     1.2 +++ b/xen/arch/x86/domain_build.c	Thu Aug 02 14:18:38 2007 +0100
     1.3 @@ -316,9 +316,9 @@ int __init construct_dom0(
     1.4             parms.pae       ? ", PAE"  : "",
     1.5             elf_msb(&elf)   ? "msb"    : "lsb",
     1.6             elf.pstart, elf.pend);
     1.7 -    if ( parms.bsd_symtab )
     1.8 +    if ( elf.bsd_symtab_pstart )
     1.9          printk(" Dom0 symbol map 0x%" PRIx64 " -> 0x%" PRIx64 "\n",
    1.10 -               elf.sstart, elf.send);
    1.11 +               elf.bsd_symtab_pstart, elf.bsd_symtab_pend);
    1.12  
    1.13      if ( !compatible )
    1.14      {
    1.15 @@ -388,7 +388,7 @@ int __init construct_dom0(
    1.16      v_start          = parms.virt_base;
    1.17      vkern_start      = parms.virt_kstart;
    1.18      vkern_end        = parms.virt_kend;
    1.19 -    vinitrd_start    = round_pgup(parms.virt_end);
    1.20 +    vinitrd_start    = round_pgup(vkern_end);
    1.21      vinitrd_end      = vinitrd_start + initrd_len;
    1.22      vphysmap_start   = round_pgup(vinitrd_end);
    1.23      vphysmap_end     = vphysmap_start + (nr_pages * (!is_pv_32on64_domain(d) ?
    1.24 @@ -798,7 +798,7 @@ int __init construct_dom0(
    1.25  
    1.26      /* Copy the OS image and free temporary buffer. */
    1.27      elf.dest = (void*)vkern_start;
    1.28 -    elf_xen_dom_load_binary(&elf, &parms);
    1.29 +    elf_load_binary(&elf);
    1.30  
    1.31      if ( UNSET_ADDR != parms.virt_hypercall )
    1.32      {
     2.1 --- a/xen/common/libelf/libelf-dominfo.c	Thu Aug 02 10:05:14 2007 +0100
     2.2 +++ b/xen/common/libelf/libelf-dominfo.c	Thu Aug 02 14:18:38 2007 +0100
     2.3 @@ -333,99 +333,6 @@ static int elf_xen_note_check(struct elf
     2.4      return 0;
     2.5  }
     2.6  
     2.7 -
     2.8 -static void elf_xen_loadsymtab(struct elf_binary *elf,
     2.9 -                               struct elf_dom_parms *parms)
    2.10 -{
    2.11 -    unsigned long maxva, len;
    2.12 -
    2.13 -    if ( !parms->bsd_symtab )
    2.14 -        return;
    2.15 -
    2.16 -    /* Calculate the required additional kernel space for the elf image */
    2.17 -
    2.18 -    /* The absolute base address of the elf image */
    2.19 -    maxva = elf_round_up(elf, parms->virt_kend);
    2.20 -    maxva += sizeof(long); /* Space to store the size of the elf image */
    2.21 -    /* Space for the elf and elf section headers */
    2.22 -    maxva += (elf_uval(elf, elf->ehdr, e_ehsize) +
    2.23 -              elf_shdr_count(elf) * elf_uval(elf, elf->ehdr, e_shentsize));
    2.24 -    maxva = elf_round_up(elf, maxva);
    2.25 -
    2.26 -    /* Space for the symbol and string tabs */
    2.27 -    len = (unsigned long)elf->send - (unsigned long)elf->sstart;
    2.28 -    maxva = elf_round_up(elf, maxva + len);
    2.29 -
    2.30 -    /* The address the kernel must expanded to */
    2.31 -    parms->virt_end = maxva;
    2.32 -}
    2.33 -
    2.34 -int elf_xen_dom_load_binary(struct elf_binary *elf,
    2.35 -                            struct elf_dom_parms *parms)
    2.36 -{
    2.37 -    elf_ehdr *sym_ehdr;
    2.38 -    unsigned long shdr, symtab_addr;
    2.39 -    unsigned long maxva, symbase;
    2.40 -    uint8_t i;
    2.41 -    char *p;
    2.42 -
    2.43 -    elf_load_binary(elf);
    2.44 -
    2.45 -    if ( !parms->bsd_symtab )
    2.46 -        return 0;
    2.47 -
    2.48 -#define elf_hdr_elm(_elf, _hdr, _elm, _val)     \
    2.49 -do {                                            \
    2.50 -    if ( elf_64bit(_elf) )                      \
    2.51 -        (_hdr)->e64._elm = _val;                \
    2.52 -    else                                        \
    2.53 -        (_hdr)->e32._elm = _val;                \
    2.54 -} while ( 0 )
    2.55 -
    2.56 -    /* ehdr right after the kernel image (4 byte aligned) */
    2.57 -    symbase = elf_round_up(elf, parms->virt_kend);
    2.58 -    symtab_addr = maxva = symbase + sizeof(long);
    2.59 -
    2.60 -    /* Set up Elf header. */
    2.61 -    sym_ehdr = (elf_ehdr *)symtab_addr;
    2.62 -    maxva = elf_copy_ehdr(elf, sym_ehdr);
    2.63 -
    2.64 -    elf_hdr_elm(elf, sym_ehdr, e_phoff, 0);
    2.65 -    elf_hdr_elm(elf, sym_ehdr, e_shoff, elf_uval(elf, elf->ehdr, e_ehsize));
    2.66 -    elf_hdr_elm(elf, sym_ehdr, e_phentsize, 0);
    2.67 -    elf_hdr_elm(elf, sym_ehdr, e_phnum, 0);
    2.68 -
    2.69 -    /* Copy Elf section headers. */
    2.70 -    shdr = maxva;
    2.71 -    maxva = elf_copy_shdr(elf, (elf_shdr *)shdr);
    2.72 -
    2.73 -    for ( i = 0; i < elf_shdr_count(elf); i++ )
    2.74 -    {
    2.75 -        uint8_t type;
    2.76 -        unsigned long tmp;
    2.77 -        type = elf_uval(elf, (elf_shdr *)shdr, sh_type);
    2.78 -        if ( (type == SHT_STRTAB) || (type == SHT_SYMTAB) )
    2.79 -        {
    2.80 -             elf_msg(elf, "%s: shdr %i at 0x%p -> 0x%p\n", __func__, i,
    2.81 -                     elf_section_start(elf, (elf_shdr *)shdr), (void *)maxva);
    2.82 -             tmp = elf_copy_section(elf, (elf_shdr *)shdr, (void *)maxva);
    2.83 -             /* Mangled to be based on ELF header location. */
    2.84 -             elf_hdr_elm(elf, (elf_shdr *)shdr, sh_offset,
    2.85 -                         maxva - symtab_addr);
    2.86 -             maxva = tmp;
    2.87 -        }
    2.88 -        shdr += elf_uval(elf, elf->ehdr, e_shentsize);
    2.89 -    }
    2.90 -
    2.91 -    /* Write down the actual sym size. */
    2.92 -    p = (char *)symbase;
    2.93 -    *(long *)p = maxva - symtab_addr; /* sym size */
    2.94 -
    2.95 -#undef elf_ehdr_elm
    2.96 -
    2.97 -    return 0;
    2.98 -}
    2.99 -
   2.100  static int elf_xen_addr_calc_check(struct elf_binary *elf,
   2.101                                     struct elf_dom_parms *parms)
   2.102  {
   2.103 @@ -467,13 +374,16 @@ static int elf_xen_addr_calc_check(struc
   2.104      parms->virt_offset = parms->virt_base - parms->elf_paddr_offset;
   2.105      parms->virt_kstart = elf->pstart + parms->virt_offset;
   2.106      parms->virt_kend   = elf->pend   + parms->virt_offset;
   2.107 -    parms->virt_end    = parms->virt_kend;
   2.108  
   2.109      if ( parms->virt_entry == UNSET_ADDR )
   2.110          parms->virt_entry = elf_uval(elf, elf->ehdr, e_entry);
   2.111  
   2.112      if ( parms->bsd_symtab )
   2.113 -        elf_xen_loadsymtab(elf, parms);
   2.114 +    {
   2.115 +        elf_parse_bsdsyms(elf, parms->virt_kend);
   2.116 +        if ( elf->bsd_symtab_pend )
   2.117 +            parms->virt_kend = elf->bsd_symtab_pend + parms->virt_offset;
   2.118 +    }
   2.119  
   2.120      elf_msg(elf, "%s: addresses:\n", __FUNCTION__);
   2.121      elf_msg(elf, "    virt_base        = 0x%" PRIx64 "\n", parms->virt_base);
   2.122 @@ -481,14 +391,12 @@ static int elf_xen_addr_calc_check(struc
   2.123      elf_msg(elf, "    virt_offset      = 0x%" PRIx64 "\n", parms->virt_offset);
   2.124      elf_msg(elf, "    virt_kstart      = 0x%" PRIx64 "\n", parms->virt_kstart);
   2.125      elf_msg(elf, "    virt_kend        = 0x%" PRIx64 "\n", parms->virt_kend);
   2.126 -    elf_msg(elf, "    virt_end         = 0x%" PRIx64 "\n", parms->virt_end);
   2.127      elf_msg(elf, "    virt_entry       = 0x%" PRIx64 "\n", parms->virt_entry);
   2.128  
   2.129      if ( (parms->virt_kstart > parms->virt_kend) ||
   2.130           (parms->virt_entry < parms->virt_kstart) ||
   2.131           (parms->virt_entry > parms->virt_kend) ||
   2.132 -         (parms->virt_base > parms->virt_kstart) ||
   2.133 -         (parms->virt_kend > parms->virt_end) )
   2.134 +         (parms->virt_base > parms->virt_kstart) )
   2.135      {
   2.136          elf_err(elf, "%s: ERROR: ELF start or entries are out of bounds.\n",
   2.137                  __FUNCTION__);
     3.1 --- a/xen/common/libelf/libelf-loader.c	Thu Aug 02 10:05:14 2007 +0100
     3.2 +++ b/xen/common/libelf/libelf-loader.c	Thu Aug 02 14:18:38 2007 +0100
     3.3 @@ -10,8 +10,6 @@ int elf_init(struct elf_binary *elf, con
     3.4  {
     3.5      const elf_shdr *shdr;
     3.6      uint64_t i, count, section, offset;
     3.7 -    uint64_t low = -1;
     3.8 -    uint64_t high = 0;
     3.9  
    3.10      if ( !elf_is_elfbinary(image) )
    3.11      {
    3.12 @@ -22,7 +20,7 @@ int elf_init(struct elf_binary *elf, con
    3.13      memset(elf, 0, sizeof(*elf));
    3.14      elf->image = image;
    3.15      elf->size = size;
    3.16 -    elf->ehdr = (elf_ehdr *) image;
    3.17 +    elf->ehdr = (elf_ehdr *)image;
    3.18      elf->class = elf->ehdr->e32.e_ident[EI_CLASS];
    3.19      elf->data = elf->ehdr->e32.e_ident[EI_DATA];
    3.20  
    3.21 @@ -56,44 +54,17 @@ int elf_init(struct elf_binary *elf, con
    3.22      count = elf_shdr_count(elf);
    3.23      for ( i = 0; i < count; i++ )
    3.24      {
    3.25 -        const char *sh_symend, *sh_strend;
    3.26 -
    3.27          shdr = elf_shdr_by_index(elf, i);
    3.28          if ( elf_uval(elf, shdr, sh_type) != SHT_SYMTAB )
    3.29              continue;
    3.30          elf->sym_tab = shdr;
    3.31 -        sh_symend = (const char *)elf_section_end(elf, shdr);
    3.32          shdr = elf_shdr_by_index(elf, elf_uval(elf, shdr, sh_link));
    3.33          if ( shdr == NULL )
    3.34          {
    3.35              elf->sym_tab = NULL;
    3.36 -            sh_symend = 0;
    3.37              continue;
    3.38          }
    3.39          elf->sym_strtab = elf_section_start(elf, shdr);
    3.40 -        sh_strend = (const char *)elf_section_end(elf, shdr);
    3.41 -
    3.42 -        if ( low > (unsigned long)elf->sym_tab )
    3.43 -            low = (unsigned long)elf->sym_tab;
    3.44 -        if ( low > (unsigned long)shdr )
    3.45 -            low = (unsigned long)shdr;
    3.46 -
    3.47 -        if ( high < ((unsigned long)sh_symend) )
    3.48 -            high = (unsigned long)sh_symend;
    3.49 -        if ( high < ((unsigned long)sh_strend) )
    3.50 -            high = (unsigned long)sh_strend;
    3.51 -
    3.52 -        elf_msg(elf, "%s: shdr: sym_tab=%p size=0x%" PRIx64 "\n",
    3.53 -                __FUNCTION__, elf->sym_tab,
    3.54 -                elf_uval(elf, elf->sym_tab, sh_size));
    3.55 -        elf_msg(elf, "%s: shdr: str_tab=%p size=0x%" PRIx64 "\n",
    3.56 -                __FUNCTION__, elf->sym_strtab, elf_uval(elf, shdr, sh_size));
    3.57 -
    3.58 -        elf->sstart = low;
    3.59 -        elf->send = high;
    3.60 -        elf_msg(elf, "%s: symbol map: 0x%" PRIx64 " -> 0x%" PRIx64 "\n",
    3.61 -                __FUNCTION__, elf->sstart, elf->send);
    3.62 -
    3.63          break;
    3.64      }
    3.65  
    3.66 @@ -113,6 +84,101 @@ void elf_set_verbose(struct elf_binary *
    3.67  }
    3.68  #endif
    3.69  
    3.70 +/* Calculate the required additional kernel space for the elf image */
    3.71 +void elf_parse_bsdsyms(struct elf_binary *elf, uint64_t pstart)
    3.72 +{
    3.73 +    uint64_t sz;
    3.74 +    const elf_shdr *shdr;
    3.75 +    int i, type;
    3.76 +
    3.77 +    if ( !elf->sym_tab )
    3.78 +        return;
    3.79 +
    3.80 +    pstart = elf_round_up(elf, pstart);
    3.81 +
    3.82 +    /* Space to store the size of the elf image */
    3.83 +    sz = sizeof(uint32_t);
    3.84 +
    3.85 +    /* Space for the elf and elf section headers */
    3.86 +    sz += (elf_uval(elf, elf->ehdr, e_ehsize) +
    3.87 +           elf_shdr_count(elf) * elf_uval(elf, elf->ehdr, e_shentsize));
    3.88 +    sz = elf_round_up(elf, sz);
    3.89 +
    3.90 +    /* Space for the symbol and string tables. */
    3.91 +    for ( i = 0; i < elf_shdr_count(elf); i++ )
    3.92 +    {
    3.93 +        shdr = elf_shdr_by_index(elf, i);
    3.94 +        type = elf_uval(elf, (elf_shdr *)shdr, sh_type);
    3.95 +        if ( (type == SHT_STRTAB) || (type == SHT_SYMTAB) )
    3.96 +            sz = elf_round_up(elf, sz + elf_uval(elf, shdr, sh_size));
    3.97 +    }
    3.98 +
    3.99 +    elf->bsd_symtab_pstart = pstart;
   3.100 +    elf->bsd_symtab_pend   = pstart + sz;
   3.101 +}
   3.102 +
   3.103 +static void elf_load_bsdsyms(struct elf_binary *elf)
   3.104 +{
   3.105 +    elf_ehdr *sym_ehdr;
   3.106 +    unsigned long sz;
   3.107 +    char *maxva, *symbase, *symtab_addr;
   3.108 +    elf_shdr *shdr;
   3.109 +    int i, type;
   3.110 +
   3.111 +    if ( !elf->bsd_symtab_pstart )
   3.112 +        return;
   3.113 +
   3.114 +#define elf_hdr_elm(_elf, _hdr, _elm, _val)     \
   3.115 +do {                                            \
   3.116 +    if ( elf_64bit(_elf) )                      \
   3.117 +        (_hdr)->e64._elm = _val;                \
   3.118 +    else                                        \
   3.119 +        (_hdr)->e32._elm = _val;                \
   3.120 +} while ( 0 )
   3.121 +
   3.122 +    symbase = elf_get_ptr(elf, elf->bsd_symtab_pstart);
   3.123 +    symtab_addr = maxva = symbase + sizeof(uint32_t);
   3.124 +
   3.125 +    /* Set up Elf header. */
   3.126 +    sym_ehdr = (elf_ehdr *)symtab_addr;
   3.127 +    sz = elf_uval(elf, elf->ehdr, e_ehsize);
   3.128 +    memcpy(sym_ehdr, elf->ehdr, sz);
   3.129 +    maxva += sz; /* no round up */
   3.130 +
   3.131 +    elf_hdr_elm(elf, sym_ehdr, e_phoff, 0);
   3.132 +    elf_hdr_elm(elf, sym_ehdr, e_shoff, elf_uval(elf, elf->ehdr, e_ehsize));
   3.133 +    elf_hdr_elm(elf, sym_ehdr, e_phentsize, 0);
   3.134 +    elf_hdr_elm(elf, sym_ehdr, e_phnum, 0);
   3.135 +
   3.136 +    /* Copy Elf section headers. */
   3.137 +    shdr = (elf_shdr *)maxva;
   3.138 +    sz = elf_shdr_count(elf) * elf_uval(elf, elf->ehdr, e_shentsize);
   3.139 +    memcpy(shdr, elf->image + elf_uval(elf, elf->ehdr, e_shoff), sz);
   3.140 +    maxva = (char *)(long)elf_round_up(elf, (long)maxva + sz);
   3.141 +
   3.142 +    for ( i = 0; i < elf_shdr_count(elf); i++ )
   3.143 +    {
   3.144 +        type = elf_uval(elf, shdr, sh_type);
   3.145 +        if ( (type == SHT_STRTAB) || (type == SHT_SYMTAB) )
   3.146 +        {
   3.147 +             elf_msg(elf, "%s: shdr %i at 0x%p -> 0x%p\n", __func__, i,
   3.148 +                     elf_section_start(elf, shdr), maxva);
   3.149 +             sz = elf_uval(elf, shdr, sh_size);
   3.150 +             memcpy(maxva, elf_section_start(elf, shdr), sz);
   3.151 +             /* Mangled to be based on ELF header location. */
   3.152 +             elf_hdr_elm(elf, shdr, sh_offset, maxva - symtab_addr);
   3.153 +             maxva = (char *)(long)elf_round_up(elf, (long)maxva + sz);
   3.154 +        }
   3.155 +        shdr = (elf_shdr *)((long)shdr +
   3.156 +                            (long)elf_uval(elf, elf->ehdr, e_shentsize));
   3.157 +    }
   3.158 +
   3.159 +    /* Write down the actual sym size. */
   3.160 +    *(uint32_t *)symbase = maxva - symtab_addr;
   3.161 +
   3.162 +#undef elf_ehdr_elm
   3.163 +}
   3.164 +
   3.165  void elf_parse_binary(struct elf_binary *elf)
   3.166  {
   3.167      const elf_phdr *phdr;
   3.168 @@ -163,6 +229,8 @@ void elf_load_binary(struct elf_binary *
   3.169          memcpy(dest, elf->image + offset, filesz);
   3.170          memset(dest + filesz, 0, memsz - filesz);
   3.171      }
   3.172 +
   3.173 +    elf_load_bsdsyms(elf);
   3.174  }
   3.175  
   3.176  void *elf_get_ptr(struct elf_binary *elf, unsigned long addr)
     4.1 --- a/xen/common/libelf/libelf-tools.c	Thu Aug 02 10:05:14 2007 +0100
     4.2 +++ b/xen/common/libelf/libelf-tools.c	Thu Aug 02 14:18:38 2007 +0100
     4.3 @@ -238,36 +238,6 @@ int elf_phdr_is_loadable(struct elf_bina
     4.4      return ((p_type == PT_LOAD) && (p_flags & (PF_W | PF_X)) != 0);
     4.5  }
     4.6  
     4.7 -unsigned long
     4.8 -elf_copy_ehdr(struct elf_binary *elf, void *dest)
     4.9 -{
    4.10 -    uint64_t size;
    4.11 -
    4.12 -    size = elf_uval(elf, elf->ehdr, e_ehsize);
    4.13 -    memcpy(dest, elf->ehdr, size);
    4.14 -    return elf_round_up(elf, (unsigned long)(dest) + size);
    4.15 -}
    4.16 -
    4.17 -unsigned long
    4.18 -elf_copy_shdr(struct elf_binary *elf, void *dest)
    4.19 -{
    4.20 -    uint64_t size;
    4.21 -
    4.22 -    size = elf_shdr_count(elf) * elf_uval(elf, elf->ehdr, e_shentsize);
    4.23 -    memcpy(dest, elf->image + elf_uval(elf, elf->ehdr, e_shoff), size);
    4.24 -    return elf_round_up(elf, (unsigned long)(dest) + size);
    4.25 -}
    4.26 -
    4.27 -unsigned long
    4.28 -elf_copy_section(struct elf_binary *elf, const elf_shdr *shdr, void *dest)
    4.29 -{
    4.30 -    uint64_t size;
    4.31 -
    4.32 -    size = elf_uval(elf, shdr, sh_size);
    4.33 -    memcpy(dest, elf_section_start(elf, shdr), size);
    4.34 -    return elf_round_up(elf, (unsigned long)(dest) + size);
    4.35 -}
    4.36 -
    4.37  /*
    4.38   * Local variables:
    4.39   * mode: C
     5.1 --- a/xen/include/public/libelf.h	Thu Aug 02 10:05:14 2007 +0100
     5.2 +++ b/xen/include/public/libelf.h	Thu Aug 02 14:18:38 2007 +0100
     5.3 @@ -65,12 +65,13 @@ struct elf_binary {
     5.4  
     5.5      /* loaded to */
     5.6      char *dest;
     5.7 -    uint64_t sstart;
     5.8 -    uint64_t send;
     5.9      uint64_t pstart;
    5.10      uint64_t pend;
    5.11      uint64_t reloc_offset;
    5.12  
    5.13 +    uint64_t bsd_symtab_pstart;
    5.14 +    uint64_t bsd_symtab_pend;
    5.15 +
    5.16  #ifndef __XEN__
    5.17      /* misc */
    5.18      FILE *log;
    5.19 @@ -150,11 +151,6 @@ const elf_note *elf_note_next(struct elf
    5.20  int elf_is_elfbinary(const void *image);
    5.21  int elf_phdr_is_loadable(struct elf_binary *elf, const elf_phdr * phdr);
    5.22  
    5.23 -unsigned long elf_copy_ehdr(struct elf_binary *elf, void *dest);
    5.24 -unsigned long elf_copy_shdr(struct elf_binary *elf, void *dest);
    5.25 -unsigned long elf_copy_section(struct elf_binary *elf,
    5.26 -                               const elf_shdr *shdr, void *dest);
    5.27 -
    5.28  /* ------------------------------------------------------------------------ */
    5.29  /* xc_libelf_loader.c                                                       */
    5.30  
    5.31 @@ -171,6 +167,8 @@ void elf_load_binary(struct elf_binary *
    5.32  void *elf_get_ptr(struct elf_binary *elf, unsigned long addr);
    5.33  uint64_t elf_lookup_addr(struct elf_binary *elf, const char *symbol);
    5.34  
    5.35 +void elf_parse_bsdsyms(struct elf_binary *elf, uint64_t pstart); /* private */
    5.36 +
    5.37  /* ------------------------------------------------------------------------ */
    5.38  /* xc_libelf_relocate.c                                                     */
    5.39  
    5.40 @@ -221,8 +219,7 @@ struct elf_dom_parms {
    5.41      /* calculated */
    5.42      uint64_t virt_offset;
    5.43      uint64_t virt_kstart;
    5.44 -    uint64_t virt_kend; /* end of kernel image */
    5.45 -    uint64_t virt_end;  /* end of kernel symtab (== virt_kend if none) */
    5.46 +    uint64_t virt_kend;
    5.47  };
    5.48  
    5.49  static inline void elf_xen_feature_set(int nr, uint32_t * addr)
    5.50 @@ -245,7 +242,4 @@ int elf_xen_parse_guest_info(struct elf_
    5.51  int elf_xen_parse(struct elf_binary *elf,
    5.52                    struct elf_dom_parms *parms);
    5.53  
    5.54 -int elf_xen_dom_load_binary(struct elf_binary *elf,
    5.55 -                            struct elf_dom_parms *parms);
    5.56 -
    5.57  #endif /* __XC_LIBELF__ */