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