![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libelf.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / xen / public|
Return to libelf.h CVS log | Up to [GnuMach] / Gnu-Mach / xen / public |
1.1 root 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 __XC_LIBELF__
24: #define __XC_LIBELF__ 1
25:
26: #if defined(__i386__) || defined(__x86_64__) || defined(__ia64__)
27: #define XEN_ELF_LITTLE_ENDIAN
28: #else
29: #error define architectural endianness
30: #endif
31:
32: #undef ELFSIZE
33: #include "elfnote.h"
34: #include "elfstructs.h"
35: #include "features.h"
36:
37: /* ------------------------------------------------------------------------ */
38:
39: typedef union {
40: Elf32_Ehdr e32;
41: Elf64_Ehdr e64;
42: } elf_ehdr;
43:
44: typedef union {
45: Elf32_Phdr e32;
46: Elf64_Phdr e64;
47: } elf_phdr;
48:
49: typedef union {
50: Elf32_Shdr e32;
51: Elf64_Shdr e64;
52: } elf_shdr;
53:
54: typedef union {
55: Elf32_Sym e32;
56: Elf64_Sym e64;
57: } elf_sym;
58:
59: typedef union {
60: Elf32_Rel e32;
61: Elf64_Rel e64;
62: } elf_rel;
63:
64: typedef union {
65: Elf32_Rela e32;
66: Elf64_Rela e64;
67: } elf_rela;
68:
69: typedef union {
70: Elf32_Note e32;
71: Elf64_Note e64;
72: } elf_note;
73:
74: struct elf_binary {
75: /* elf binary */
76: const char *image;
77: size_t size;
78: char class;
79: char data;
80:
81: const elf_ehdr *ehdr;
82: const char *sec_strtab;
83: const elf_shdr *sym_tab;
84: const char *sym_strtab;
85:
86: /* loaded to */
87: char *dest;
88: uint64_t pstart;
89: uint64_t pend;
90: uint64_t reloc_offset;
91:
92: uint64_t bsd_symtab_pstart;
93: uint64_t bsd_symtab_pend;
94:
95: #ifndef __XEN__
96: /* misc */
97: FILE *log;
98: #endif
99: int verbose;
100: };
101:
102: /* ------------------------------------------------------------------------ */
103: /* accessing elf header fields */
104:
105: #ifdef XEN_ELF_BIG_ENDIAN
106: # define NATIVE_ELFDATA ELFDATA2MSB
107: #else
108: # define NATIVE_ELFDATA ELFDATA2LSB
109: #endif
110:
111: #define elf_32bit(elf) (ELFCLASS32 == (elf)->class)
112: #define elf_64bit(elf) (ELFCLASS64 == (elf)->class)
113: #define elf_msb(elf) (ELFDATA2MSB == (elf)->data)
114: #define elf_lsb(elf) (ELFDATA2LSB == (elf)->data)
115: #define elf_swap(elf) (NATIVE_ELFDATA != (elf)->data)
116:
117: #define elf_uval(elf, str, elem) \
118: ((ELFCLASS64 == (elf)->class) \
119: ? elf_access_unsigned((elf), (str), \
120: offsetof(typeof(*(str)),e64.elem), \
121: sizeof((str)->e64.elem)) \
122: : elf_access_unsigned((elf), (str), \
123: offsetof(typeof(*(str)),e32.elem), \
124: sizeof((str)->e32.elem)))
125:
126: #define elf_sval(elf, str, elem) \
127: ((ELFCLASS64 == (elf)->class) \
128: ? elf_access_signed((elf), (str), \
129: offsetof(typeof(*(str)),e64.elem), \
130: sizeof((str)->e64.elem)) \
131: : elf_access_signed((elf), (str), \
132: offsetof(typeof(*(str)),e32.elem), \
133: sizeof((str)->e32.elem)))
134:
135: #define elf_size(elf, str) \
136: ((ELFCLASS64 == (elf)->class) \
137: ? sizeof((str)->e64) : sizeof((str)->e32))
138:
139: uint64_t elf_access_unsigned(struct elf_binary *elf, const void *ptr,
140: uint64_t offset, size_t size);
141: int64_t elf_access_signed(struct elf_binary *elf, const void *ptr,
142: uint64_t offset, size_t size);
143:
144: uint64_t elf_round_up(struct elf_binary *elf, uint64_t addr);
145:
146: /* ------------------------------------------------------------------------ */
147: /* xc_libelf_tools.c */
148:
149: int elf_shdr_count(struct elf_binary *elf);
150: int elf_phdr_count(struct elf_binary *elf);
151:
152: const elf_shdr *elf_shdr_by_name(struct elf_binary *elf, const char *name);
153: const elf_shdr *elf_shdr_by_index(struct elf_binary *elf, int index);
154: const elf_phdr *elf_phdr_by_index(struct elf_binary *elf, int index);
155:
156: const char *elf_section_name(struct elf_binary *elf, const elf_shdr * shdr);
157: const void *elf_section_start(struct elf_binary *elf, const elf_shdr * shdr);
158: const void *elf_section_end(struct elf_binary *elf, const elf_shdr * shdr);
159:
160: const void *elf_segment_start(struct elf_binary *elf, const elf_phdr * phdr);
161: const void *elf_segment_end(struct elf_binary *elf, const elf_phdr * phdr);
162:
163: const elf_sym *elf_sym_by_name(struct elf_binary *elf, const char *symbol);
164: const elf_sym *elf_sym_by_index(struct elf_binary *elf, int index);
165:
166: const char *elf_note_name(struct elf_binary *elf, const elf_note * note);
167: const void *elf_note_desc(struct elf_binary *elf, const elf_note * note);
168: uint64_t elf_note_numeric(struct elf_binary *elf, const elf_note * note);
169: const elf_note *elf_note_next(struct elf_binary *elf, const elf_note * note);
170:
171: int elf_is_elfbinary(const void *image);
172: int elf_phdr_is_loadable(struct elf_binary *elf, const elf_phdr * phdr);
173:
174: /* ------------------------------------------------------------------------ */
175: /* xc_libelf_loader.c */
176:
177: int elf_init(struct elf_binary *elf, const char *image, size_t size);
178: #ifdef __XEN__
179: void elf_set_verbose(struct elf_binary *elf);
180: #else
181: void elf_set_logfile(struct elf_binary *elf, FILE * log, int verbose);
182: #endif
183:
184: void elf_parse_binary(struct elf_binary *elf);
185: void elf_load_binary(struct elf_binary *elf);
186:
187: void *elf_get_ptr(struct elf_binary *elf, unsigned long addr);
188: uint64_t elf_lookup_addr(struct elf_binary *elf, const char *symbol);
189:
190: void elf_parse_bsdsyms(struct elf_binary *elf, uint64_t pstart); /* private */
191:
192: /* ------------------------------------------------------------------------ */
193: /* xc_libelf_relocate.c */
194:
195: int elf_reloc(struct elf_binary *elf);
196:
197: /* ------------------------------------------------------------------------ */
198: /* xc_libelf_dominfo.c */
199:
200: #define UNSET_ADDR ((uint64_t)-1)
201:
202: enum xen_elfnote_type {
203: XEN_ENT_NONE = 0,
204: XEN_ENT_LONG = 1,
205: XEN_ENT_STR = 2
206: };
207:
208: struct xen_elfnote {
209: enum xen_elfnote_type type;
210: const char *name;
211: union {
212: const char *str;
213: uint64_t num;
214: } data;
215: };
216:
217: struct elf_dom_parms {
218: /* raw */
219: const char *guest_info;
220: const void *elf_note_start;
221: const void *elf_note_end;
222: struct xen_elfnote elf_notes[XEN_ELFNOTE_MAX + 1];
223:
224: /* parsed */
225: char guest_os[16];
226: char guest_ver[16];
227: char xen_ver[16];
228: char loader[16];
229: int pae;
230: int bsd_symtab;
231: uint64_t virt_base;
232: uint64_t virt_entry;
233: uint64_t virt_hypercall;
234: uint64_t virt_hv_start_low;
235: uint64_t elf_paddr_offset;
236: uint32_t f_supported[XENFEAT_NR_SUBMAPS];
237: uint32_t f_required[XENFEAT_NR_SUBMAPS];
238:
239: /* calculated */
240: uint64_t virt_offset;
241: uint64_t virt_kstart;
242: uint64_t virt_kend;
243: };
244:
245: static inline void elf_xen_feature_set(int nr, uint32_t * addr)
246: {
247: addr[nr >> 5] |= 1 << (nr & 31);
248: }
249: static inline int elf_xen_feature_get(int nr, uint32_t * addr)
250: {
251: return !!(addr[nr >> 5] & (1 << (nr & 31)));
252: }
253:
254: int elf_xen_parse_features(const char *features,
255: uint32_t *supported,
256: uint32_t *required);
257: int elf_xen_parse_note(struct elf_binary *elf,
258: struct elf_dom_parms *parms,
259: const elf_note *note);
260: int elf_xen_parse_guest_info(struct elf_binary *elf,
261: struct elf_dom_parms *parms);
262: int elf_xen_parse(struct elf_binary *elf,
263: struct elf_dom_parms *parms);
264:
265: #endif /* __XC_LIBELF__ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.