ia64/xen-unstable

view tools/xcutils/readnotes.c @ 15841:c5f735271e22

[IA64] Foreign p2m: Fix vti domain builder.

It should set arch_domain::convmem_end.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Alex Williamson <alex.williamson@hp.com>
date Thu Sep 06 13:48:43 2007 -0600 (2007-09-06)
parents 9149ef0e61ce
children 7df072566b8c
line source
1 #include <errno.h>
2 #include <fcntl.h>
3 #include <inttypes.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <unistd.h>
9 #include <sys/types.h>
10 #include <sys/stat.h>
11 #include <sys/mman.h>
13 #include <xg_private.h>
14 #include <xc_dom.h> /* gunzip bits */
16 #include <xen/libelf.h>
18 static void print_string_note(const char *prefix, struct elf_binary *elf,
19 const elf_note *note)
20 {
21 printf("%s: %s\n", prefix, (char*)elf_note_desc(elf, note));
22 }
24 static void print_numeric_note(const char *prefix, struct elf_binary *elf,
25 const elf_note *note)
26 {
27 uint64_t value = elf_note_numeric(elf, note);
28 int descsz = elf_uval(elf, note, descsz);
30 printf("%s: %#*" PRIx64 " (%d bytes)\n",
31 prefix, 2+2*descsz, value, descsz);
32 }
34 static void print_l1_mfn_valid_note(const char *prefix, struct elf_binary *elf,
35 const elf_note *note)
36 {
37 int descsz = elf_uval(elf, note, descsz);
38 const uint32_t *desc32 = elf_note_desc(elf, note);
39 const uint64_t *desc64 = elf_note_desc(elf, note);
41 /* XXX should be able to cope with a list of values. */
42 switch ( descsz / 2 )
43 {
44 case 8:
45 printf("%s: mask=%#"PRIx64" value=%#"PRIx64"\n", prefix,
46 desc64[0], desc64[1]);
47 break;
48 case 4:
49 printf("%s: mask=%#"PRIx32" value=%#"PRIx32"\n", prefix,
50 desc32[0],desc32[1]);
51 break;
52 }
54 }
56 static int print_notes(struct elf_binary *elf, const elf_note *start, const elf_note *end)
57 {
58 const elf_note *note;
59 int notes_found = 0;
61 for ( note = start; note < end; note = elf_note_next(elf, note) )
62 {
63 if (0 != strcmp(elf_note_name(elf, note), "Xen"))
64 continue;
66 notes_found++;
68 switch(elf_uval(elf, note, type))
69 {
70 case XEN_ELFNOTE_INFO:
71 print_string_note("INFO", elf , note);
72 break;
73 case XEN_ELFNOTE_ENTRY:
74 print_numeric_note("ENTRY", elf , note);
75 break;
76 case XEN_ELFNOTE_HYPERCALL_PAGE:
77 print_numeric_note("HYPERCALL_PAGE", elf , note);
78 break;
79 case XEN_ELFNOTE_VIRT_BASE:
80 print_numeric_note("VIRT_BASE", elf , note);
81 break;
82 case XEN_ELFNOTE_PADDR_OFFSET:
83 print_numeric_note("PADDR_OFFSET", elf , note);
84 break;
85 case XEN_ELFNOTE_XEN_VERSION:
86 print_string_note("XEN_VERSION", elf , note);
87 break;
88 case XEN_ELFNOTE_GUEST_OS:
89 print_string_note("GUEST_OS", elf , note);
90 break;
91 case XEN_ELFNOTE_GUEST_VERSION:
92 print_string_note("GUEST_VERSION", elf , note);
93 break;
94 case XEN_ELFNOTE_LOADER:
95 print_string_note("LOADER", elf , note);
96 break;
97 case XEN_ELFNOTE_PAE_MODE:
98 print_string_note("PAE_MODE", elf , note);
99 break;
100 case XEN_ELFNOTE_FEATURES:
101 print_string_note("FEATURES", elf , note);
102 break;
103 case XEN_ELFNOTE_HV_START_LOW:
104 print_numeric_note("HV_START_LOW", elf , note);
105 break;
106 case XEN_ELFNOTE_SUSPEND_CANCEL:
107 print_numeric_note("SUSPEND_CANCEL", elf, note);
108 break;
109 case XEN_ELFNOTE_L1_MFN_VALID:
110 print_l1_mfn_valid_note("L1_MFN_VALID", elf , note);
111 break;
112 default:
113 printf("unknown note type %#x\n",
114 (int)elf_uval(elf, note, type));
115 break;
116 }
117 }
118 return notes_found;
119 }
121 int main(int argc, char **argv)
122 {
123 const char *f;
124 int fd,h,size,usize,count;
125 void *image,*tmp;
126 struct stat st;
127 struct elf_binary elf;
128 const elf_shdr *shdr;
129 int notes_found = 0;
131 if (argc != 2)
132 {
133 fprintf(stderr, "Usage: readnotes <elfimage>\n");
134 return 1;
135 }
136 f = argv[1];
138 fd = open(f, O_RDONLY);
139 if (fd == -1)
140 {
141 fprintf(stderr, "Unable to open %s: %s\n", f, strerror(errno));
142 return 1;
143 }
144 if (fstat(fd, &st) == -1)
145 {
146 fprintf(stderr, "Unable to determine size of %s: %s\n",
147 f, strerror(errno));
148 return 1;
149 }
151 image = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
152 if (image == MAP_FAILED)
153 {
154 fprintf(stderr, "Unable to map %s: %s\n", f, strerror(errno));
155 return 1;
156 }
157 size = st.st_size;
159 usize = xc_dom_check_gzip(image, st.st_size);
160 if (usize)
161 {
162 tmp = malloc(usize);
163 xc_dom_do_gunzip(image, st.st_size, tmp, usize);
164 image = tmp;
165 size = usize;
166 }
168 if (0 != elf_init(&elf, image, size))
169 {
170 fprintf(stderr, "File %s is not an ELF image\n", f);
171 return 1;
172 }
173 elf_set_logfile(&elf, stderr, 0);
175 count = elf_phdr_count(&elf);
176 for ( h=0; h < count; h++)
177 {
178 const elf_phdr *phdr;
179 phdr = elf_phdr_by_index(&elf, h);
180 if (elf_uval(&elf, phdr, p_type) != PT_NOTE)
181 continue;
183 /* Some versions of binutils do not correctly set
184 * p_offset for note segments.
185 */
186 if (elf_uval(&elf, phdr, p_offset) == 0)
187 continue;
189 notes_found = print_notes(&elf,
190 elf_segment_start(&elf, phdr),
191 elf_segment_end(&elf, phdr));
192 }
194 if ( notes_found == 0 )
195 {
196 count = elf_shdr_count(&elf);
197 for ( h=0; h < count; h++)
198 {
199 const elf_shdr *shdr;
200 shdr = elf_shdr_by_index(&elf, h);
201 if (elf_uval(&elf, shdr, sh_type) != SHT_NOTE)
202 continue;
203 notes_found = print_notes(&elf,
204 elf_section_start(&elf, shdr),
205 elf_section_end(&elf, shdr));
206 if ( notes_found )
207 fprintf(stderr, "using notes from SHT_NOTE section\n");
209 }
210 }
212 shdr = elf_shdr_by_name(&elf, "__xen_guest");
213 if (shdr)
214 printf("__xen_guest: %s\n", (char*)elf_section_start(&elf, shdr));
216 return 0;
217 }