1  /******************************************************************************
2   * libelf.h
3   *
4   * Permission is hereby granted, free of charge, to any person obtaining a copy
5   * of this software and associated documentation files (the "Software"), to
6   * deal in the Software without restriction, including without limitation the
7   * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8   * sell copies of the Software, and to permit persons to whom the Software is
9   * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20   * DEALINGS IN THE SOFTWARE.
21   */
22  
23  #ifndef __XEN_LIBELF_H__
24  #define __XEN_LIBELF_H__
25  
26  #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
27  #define XEN_ELF_LITTLE_ENDIAN
28  #else
29  #error define architectural endianness
30  #endif
31  
32  typedef int elf_errorstatus; /* 0: ok; -ve (normally -1): error */
33  typedef int elf_negerrnoval; /* 0: ok; -EFOO: error */
34  
35  #undef ELFSIZE
36  #include "elfstructs.h"
37  #ifdef __XEN__
38  #include <public/elfnote.h>
39  #include <public/features.h>
40  #include <xen/stdbool.h>
41  #include <xen/string.h>
42  #else
43  #include <xen/elfnote.h>
44  #include <xen/features.h>
45  
46  #include <stdarg.h>
47  #include <stdbool.h>
48  #include <string.h>
49  
50  struct elf_binary;
51  typedef void elf_log_callback(struct elf_binary*, void *caller_data,
52                                bool iserr, const char *fmt, va_list al);
53  
54  #endif
55  
56  #define ELF_MAX_STRING_LENGTH 4096
57  #define ELF_MAX_TOTAL_NOTE_COUNT 65536
58  
59  /* ------------------------------------------------------------------------ */
60  
61  /* Macros for accessing the input image and output area. */
62  
63  /*
64   * We abstract away the pointerness of these pointers, replacing
65   * various void*, char* and struct* with the following:
66   *   elf_ptrval  A pointer to a byte; one can do pointer arithmetic
67   *               on this.
68   *   HANDLE      A pointer to a struct.  There is one of these types
69   *               for each pointer type - that is, for each "structname".
70   *               In the arguments to the various HANDLE macros, structname
71   *               must be a single identifier which is a typedef.
72   *               It is not permitted to do arithmetic on these
73   *               pointers.  In the current code attempts to do so will
74   *               compile, but in the next patch this will become a
75   *               compile error.
76   */
77  
78  typedef uintptr_t elf_ptrval;
79  
80  #define ELF_REALPTR2PTRVAL(realpointer) ((elf_ptrval)(realpointer))
81    /* Converts an actual C pointer into a PTRVAL */
82  
83  #define ELF_HANDLE_DECL(structname)          structname##_handle
84    /* Provides a type declaration for a HANDLE. */
85  
86  #define ELF_PRPTRVAL PRIxPTR
87    /* printf format a la PRId... for a PTRVAL */
88  
89  #define ELF_DEFINE_HANDLE(structname)                                   \
90      typedef union {                                                     \
91          elf_ptrval ptrval;                                              \
92          const structname *typeonly; /* for sizeof, offsetof, &c only */ \
93      } structname##_handle;
94    /*
95     * This must be invoked for each HANDLE type to define
96     * the actual C type used for that kind of HANDLE.
97     */
98  
99  #define ELF_MAKE_HANDLE(structname, ptrval)    ((structname##_handle){ ptrval })
100    /* Converts a PTRVAL to a HANDLE */
101  
102  #define ELF_IMAGE_BASE(elf)    ((elf_ptrval)(elf)->image_base)
103    /* Returns the base of the image as a PTRVAL. */
104  
105  #define ELF_HANDLE_PTRVAL(handleval)      ((handleval).ptrval)
106    /* Converts a HANDLE to a PTRVAL. */
107  
108  #define ELF_UNSAFE_PTR(ptrval) ((void*)(elf_ptrval)(ptrval))
109    /*
110     * Turns a PTRVAL into an actual C pointer.  Before this is done
111     * the caller must have ensured that the PTRVAL does in fact point
112     * to a permissible location.
113     */
114  
115  /* PTRVALs can be INVALID (ie, NULL). */
116  #define ELF_INVALID_PTRVAL    ((elf_ptrval)0)       /* returns NULL PTRVAL */
117  #define ELF_INVALID_HANDLE(structname)		    /* returns NULL handle */ \
118      ELF_MAKE_HANDLE(structname, ELF_INVALID_PTRVAL)
119  #define ELF_PTRVAL_VALID(ptrval)    (!!(ptrval))            /* }            */
120  #define ELF_HANDLE_VALID(handleval) (!!(handleval).ptrval)  /* } predicates */
121  #define ELF_PTRVAL_INVALID(ptrval)  (!ELF_PTRVAL_VALID((ptrval))) /* }      */
122  
123  #define ELF_MAX_PTRVAL        (~(elf_ptrval)0)
124    /* PTRVAL value guaranteed to compare > to any valid PTRVAL */
125  
126  /* For internal use by other macros here */
127  #define ELF__HANDLE_FIELD_TYPE(handleval, elm) \
128    typeof((handleval).typeonly->elm)
129  #define ELF__HANDLE_FIELD_OFFSET(handleval, elm) \
130    offsetof(typeof(*(handleval).typeonly),elm)
131  
132  
133  /* ------------------------------------------------------------------------ */
134  
135  
136  typedef union {
137      Elf32_Ehdr e32;
138      Elf64_Ehdr e64;
139  } elf_ehdr;
140  
141  typedef union {
142      Elf32_Phdr e32;
143      Elf64_Phdr e64;
144  } elf_phdr;
145  
146  typedef union {
147      Elf32_Shdr e32;
148      Elf64_Shdr e64;
149  } elf_shdr;
150  
151  typedef union {
152      Elf32_Sym e32;
153      Elf64_Sym e64;
154  } elf_sym;
155  
156  typedef union {
157      Elf32_Rel e32;
158      Elf64_Rel e64;
159  } elf_rel;
160  
161  typedef union {
162      Elf32_Rela e32;
163      Elf64_Rela e64;
164  } elf_rela;
165  
166  typedef union {
167      Elf32_Note e32;
168      Elf64_Note e64;
169  } elf_note;
170  
171  ELF_DEFINE_HANDLE(elf_ehdr)
172  ELF_DEFINE_HANDLE(elf_shdr)
173  ELF_DEFINE_HANDLE(elf_phdr)
174  ELF_DEFINE_HANDLE(elf_sym)
175  ELF_DEFINE_HANDLE(elf_note)
176  
177  struct elf_binary {
178      /* elf binary */
179      const void *image_base;
180      size_t size;
181      char class;
182      char data;
183  
184      ELF_HANDLE_DECL(elf_ehdr) ehdr;
185      elf_ptrval sec_strtab;
186      ELF_HANDLE_DECL(elf_shdr) sym_tab;
187      uint64_t sym_strtab;
188  
189      /* loaded to */
190      /*
191       * dest_base and dest_size are trusted and must be correct;
192       * whenever dest_size is not 0, both of these must be valid
193       * so long as the struct elf_binary is in use.
194       */
195      char *dest_base;
196      size_t dest_size;
197      uint64_t pstart;
198      uint64_t pend;
199      uint64_t reloc_offset;
200  
201      uint64_t bsd_symtab_pstart;
202      uint64_t bsd_symtab_pend;
203  
204      /*
205       * caller's other acceptable destination.
206       * Set by elf_set_xdest.  Do not set these directly.
207       */
208      void *xdest_base;
209      uint64_t xdest_size;
210  
211  #ifndef __XEN__
212      /* misc */
213      elf_log_callback *log_callback;
214      void *log_caller_data;
215  #else
216      struct vcpu *vcpu;
217  #endif
218      bool verbose;
219      const char *broken;
220  };
221  
222  /* ------------------------------------------------------------------------ */
223  /* accessing elf header fields                                              */
224  
225  #ifdef XEN_ELF_BIG_ENDIAN
226  # define NATIVE_ELFDATA ELFDATA2MSB
227  #else
228  # define NATIVE_ELFDATA ELFDATA2LSB
229  #endif
230  
231  #define elf_32bit(elf) (ELFCLASS32 == (elf)->class)
232  #define elf_64bit(elf) (ELFCLASS64 == (elf)->class)
233  #define elf_msb(elf)   (ELFDATA2MSB == (elf)->data)
234  #define elf_lsb(elf)   (ELFDATA2LSB == (elf)->data)
235  #define elf_swap(elf)  (NATIVE_ELFDATA != (elf)->data)
236  
237  #define elf_uval_3264(elf, handle, elem)                                \
238      elf_access_unsigned((elf), (handle).ptrval,                         \
239                             offsetof(typeof(*(handle).typeonly),elem),    \
240                             sizeof((handle).typeonly->elem))
241  
242  #define elf_uval(elf, handle, elem)             \
243      ((ELFCLASS64 == (elf)->class)               \
244       ? elf_uval_3264(elf, handle, e64.elem)     \
245       : elf_uval_3264(elf, handle, e32.elem))
246    /*
247     * Reads an unsigned field in a header structure in the ELF.
248     * str is a HANDLE, and elem is the field name in it.
249     */
250  
251  
252  #define elf_size(elf, handle_or_handletype) ({          \
253      typeof(handle_or_handletype) elf_size__dummy;       \
254      ((ELFCLASS64 == (elf)->class)                       \
255       ? sizeof(elf_size__dummy.typeonly->e64)             \
256       : sizeof(elf_size__dummy.typeonly->e32));           \
257  })
258    /*
259     * Returns the size of the substructure for the appropriate 32/64-bitness.
260     * str should be a HANDLE.
261     */
262  
263  uint64_t elf_access_unsigned(struct elf_binary *elf, elf_ptrval ptr,
264                               uint64_t offset, size_t size);
265    /* Reads a field at arbitrary offset and alignemnt */
266  
267  uint64_t elf_round_up(struct elf_binary *elf, uint64_t addr);
268  
269  const char *elf_strval(struct elf_binary *elf, elf_ptrval start);
270    /* may return NULL if the string is out of range etc. */
271  
272  const char *elf_strfmt(struct elf_binary *elf, elf_ptrval start);
273    /* like elf_strval but returns "(invalid)" instead of NULL */
274  
275  void elf_memcpy_safe(struct elf_binary*, elf_ptrval dst, elf_ptrval src, size_t);
276  void elf_memset_safe(struct elf_binary*, elf_ptrval dst, int c, size_t);
277    /*
278     * Versions of memcpy and memset which arrange never to write
279     * outside permitted areas.
280     */
281  
282  bool elf_access_ok(struct elf_binary * elf,
283                     uint64_t ptrval, size_t size);
284  
285  #define elf_store_val(elf, type, ptr, val)                              \
286      ({                                                                  \
287          typeof(type) elf_store__val = (val);                            \
288          elf_ptrval elf_store__targ = ptr;                               \
289          if (elf_access_ok((elf), elf_store__targ,                       \
290                            sizeof(elf_store__val))) {			\
291              elf_memcpy_unchecked((void*)elf_store__targ, &elf_store__val, \
292                               sizeof(elf_store__val));                   \
293          }                                                               \
294      })									\
295    /* Stores a value at a particular PTRVAL. */
296  
297  #define elf_store_field(elf, hdr, elm, val)                             \
298      (elf_store_val((elf), ELF__HANDLE_FIELD_TYPE(hdr, elm),                   \
299                     ELF_HANDLE_PTRVAL(hdr) + ELF__HANDLE_FIELD_OFFSET(hdr, elm), \
300                     (val)))
301    /* Stores a 32/64-bit field.  hdr is a HANDLE and elm is the field name. */
302  
303  
304  /* ------------------------------------------------------------------------ */
305  /* xc_libelf_tools.c                                                        */
306  
307  unsigned elf_shdr_count(struct elf_binary *elf);
308  unsigned elf_phdr_count(struct elf_binary *elf);
309  
310  ELF_HANDLE_DECL(elf_shdr) elf_shdr_by_name(struct elf_binary *elf, const char *name);
311  ELF_HANDLE_DECL(elf_shdr) elf_shdr_by_index(struct elf_binary *elf, unsigned index);
312  ELF_HANDLE_DECL(elf_phdr) elf_phdr_by_index(struct elf_binary *elf, unsigned index);
313  
314  const char *elf_section_name(struct elf_binary *elf, ELF_HANDLE_DECL(elf_shdr) shdr); /* might return NULL if inputs are invalid */
315  elf_ptrval elf_section_start(struct elf_binary *elf, ELF_HANDLE_DECL(elf_shdr) shdr);
316  elf_ptrval elf_section_end(struct elf_binary *elf, ELF_HANDLE_DECL(elf_shdr) shdr);
317  
318  elf_ptrval elf_segment_start(struct elf_binary *elf, ELF_HANDLE_DECL(elf_phdr) phdr);
319  elf_ptrval elf_segment_end(struct elf_binary *elf, ELF_HANDLE_DECL(elf_phdr) phdr);
320  
321  ELF_HANDLE_DECL(elf_sym) elf_sym_by_name(struct elf_binary *elf, const char *symbol);
322  ELF_HANDLE_DECL(elf_sym) elf_sym_by_index(struct elf_binary *elf, unsigned index);
323  
324  const char *elf_note_name(struct elf_binary *elf, ELF_HANDLE_DECL(elf_note) note); /* may return NULL */
325  elf_ptrval elf_note_desc(struct elf_binary *elf, ELF_HANDLE_DECL(elf_note) note);
326  uint64_t elf_note_numeric(struct elf_binary *elf, ELF_HANDLE_DECL(elf_note) note);
327  uint64_t elf_note_numeric_array(struct elf_binary *, ELF_HANDLE_DECL(elf_note),
328                                  unsigned int unitsz, unsigned int idx);
329  
330  /*
331   * If you use elf_note_next in a loop, you must put a nontrivial upper
332   * bound on the returned value as part of your loop condition.  In
333   * some cases elf_note_next will substitute ELF_PTRVAL_MAX as return
334   * value to indicate that the iteration isn't going well (for example,
335   * the putative "next" value would be earlier in memory).  In this
336   * case the caller's loop must terminate.  Checking against the
337   * end of the notes segment with a strict inequality is sufficient.
338   */
339  ELF_HANDLE_DECL(elf_note) elf_note_next(struct elf_binary *elf, ELF_HANDLE_DECL(elf_note) note);
340  
341  /* (Only) checks that the image has the right magic number. */
342  bool elf_is_elfbinary(const void *image_start, size_t image_size);
343  
344  bool elf_phdr_is_loadable(struct elf_binary *elf, ELF_HANDLE_DECL(elf_phdr) phdr);
345  
346  /* ------------------------------------------------------------------------ */
347  /* xc_libelf_loader.c                                                       */
348  
349  elf_errorstatus elf_init(struct elf_binary *elf, const char *image, size_t size);
350    /*
351     * image and size must be correct.  They will be recorded in
352     * *elf, and must remain valid while the elf is in use.
353     */
354  #ifdef __XEN__
355  void elf_set_verbose(struct elf_binary *elf);
elf_set_vcpu(struct elf_binary * elf,struct vcpu * v)356  static inline void elf_set_vcpu(struct elf_binary *elf, struct vcpu *v)
357  {
358      elf->vcpu = v;
359  }
360  #else
361  void elf_set_log(struct elf_binary *elf, elf_log_callback*,
362                   void *log_caller_pointer, bool verbose);
363  #endif
364  
365  void elf_parse_binary(struct elf_binary *elf);
366  elf_errorstatus elf_load_binary(struct elf_binary *elf);
367  
368  elf_ptrval elf_get_ptr(struct elf_binary *elf, unsigned long addr);
369  uint64_t elf_lookup_addr(struct elf_binary *elf, const char *symbol);
370  
371  void elf_parse_bsdsyms(struct elf_binary *elf, uint64_t pstart); /* private */
372  
373  void elf_mark_broken(struct elf_binary *elf, const char *msg);
374  const char *elf_check_broken(const struct elf_binary *elf); /* NULL means OK */
375  
376  /* ------------------------------------------------------------------------ */
377  /* xc_libelf_relocate.c                                                     */
378  
379  elf_errorstatus elf_reloc(struct elf_binary *elf);
380  
381  /* ------------------------------------------------------------------------ */
382  /* xc_libelf_dominfo.c                                                      */
383  
384  #define UNSET_ADDR          ((uint64_t)-1)
385  #define UNSET_ADDR32        ((uint32_t)-1)
386  
387  enum xen_elfnote_type {
388      XEN_ENT_NONE = 0,
389      XEN_ENT_LONG = 1,
390      XEN_ENT_STR  = 2
391  };
392  
393  enum xen_pae_type {
394      XEN_PAE_NO      = 0,
395      XEN_PAE_YES     = 1,
396      XEN_PAE_EXTCR3  = 2,
397      XEN_PAE_BIMODAL = 3
398  };
399  
400  struct xen_elfnote {
401      enum xen_elfnote_type type;
402      const char *name;
403      union {
404          const char *str;
405          uint64_t num;
406      } data;
407  };
408  
409  struct elf_dom_parms {
410      /* raw */
411      elf_ptrval guest_info;
412      elf_ptrval elf_note_start;
413      elf_ptrval elf_note_end;
414      struct xen_elfnote elf_notes[XEN_ELFNOTE_MAX + 1];
415  
416      /* parsed */
417      char guest_os[16];
418      char guest_ver[16];
419      char xen_ver[16];
420      char loader[16];
421      enum xen_pae_type pae;
422      bool bsd_symtab;
423      bool unmapped_initrd;
424      uint64_t virt_base;
425      uint64_t virt_entry;
426      uint64_t virt_hypercall;
427      uint64_t virt_hv_start_low;
428      uint64_t p2m_base;
429      uint64_t elf_paddr_offset;
430      uint32_t f_supported[XENFEAT_NR_SUBMAPS];
431      uint32_t f_required[XENFEAT_NR_SUBMAPS];
432      uint32_t phys_entry;
433  
434      /* calculated */
435      uint64_t virt_kstart;
436      uint64_t virt_kend;
437  };
438  
elf_xen_feature_set(int nr,uint32_t * addr)439  static inline void elf_xen_feature_set(int nr, uint32_t * addr)
440  {
441      addr[nr >> 5] |= 1 << (nr & 31);
442  }
elf_xen_feature_get(int nr,uint32_t * addr)443  static inline int elf_xen_feature_get(int nr, uint32_t * addr)
444  {
445      return !!(addr[nr >> 5] & (1 << (nr & 31)));
446  }
447  
448  int elf_xen_parse_features(const char *features,
449                             uint32_t *supported,
450                             uint32_t *required);
451  int elf_xen_parse_note(struct elf_binary *elf,
452                         struct elf_dom_parms *parms,
453                         ELF_HANDLE_DECL(elf_note) note);
454  int elf_xen_parse_guest_info(struct elf_binary *elf,
455                               struct elf_dom_parms *parms);
456  int elf_xen_parse(struct elf_binary *elf,
457                    struct elf_dom_parms *parms);
458  
elf_memcpy_unchecked(void * dest,const void * src,size_t n)459  static inline void *elf_memcpy_unchecked(void *dest, const void *src, size_t n)
460      { return memcpy(dest, src, n); }
elf_memmove_unchecked(void * dest,const void * src,size_t n)461  static inline void *elf_memmove_unchecked(void *dest, const void *src, size_t n)
462      { return memmove(dest, src, n); }
elf_memset_unchecked(void * s,int c,size_t n)463  static inline void *elf_memset_unchecked(void *s, int c, size_t n)
464      { return memset(s, c, n); }
465    /*
466     * Unsafe versions of memcpy, memmove memset which take actual C
467     * pointers.  These are just like the real functions.
468     * We provide these so that in libelf-private.h we can #define
469     * memcpy, memset and memmove to undefined MISTAKE things.
470     */
471  
472  
473  /* Advances past amount bytes of the current destination area. */
ELF_ADVANCE_DEST(struct elf_binary * elf,uint64_t amount)474  static inline void ELF_ADVANCE_DEST(struct elf_binary *elf, uint64_t amount)
475  {
476      if ( elf->dest_base == NULL )
477      {
478          elf_mark_broken(elf, "advancing in null image");
479      }
480      else if ( elf->dest_size >= amount )
481      {
482          elf->dest_base += amount;
483          elf->dest_size -= amount;
484      }
485      else
486      {
487          elf->dest_size = 0;
488          elf_mark_broken(elf, "advancing past end (image very short?)");
489      }
490  }
491  
492  /* Specify a (single) additional destination, to which the image may
493   * cause writes.  As with dest_base and dest_size, the values provided
494   * are trusted and must be valid so long as the struct elf_binary
495   * is in use or until elf_set_xdest(,0,0) is called. */
496  void elf_set_xdest(struct elf_binary *elf, void *addr, uint64_t size);
497  
498  #endif /* __XEN_LIBELF_H__ */
499