Commit | Line | Data |
---|---|---|
7dbf4dcf JO |
1 | |
2 | #include <unistd.h> | |
3 | #include <stdio.h> | |
4 | #include <string.h> | |
5 | #include <sys/types.h> | |
6 | #include <sys/stat.h> | |
7 | #include <fcntl.h> | |
8 | #include <stdlib.h> | |
9 | #include <linux/kernel.h> | |
10 | ||
11 | #include "vdso.h" | |
12 | #include "util.h" | |
13 | #include "symbol.h" | |
2a03068c | 14 | #include "machine.h" |
f6832e17 | 15 | #include "thread.h" |
7dbf4dcf | 16 | #include "linux/string.h" |
84f5d36f | 17 | #include "debug.h" |
7dbf4dcf | 18 | |
e477f3f0 AH |
19 | /* |
20 | * Include definition of find_vdso_map() also used in perf-read-vdso.c for | |
21 | * building perf-read-vdso32 and perf-read-vdsox32. | |
22 | */ | |
23 | #include "find-vdso-map.c" | |
24 | ||
30f4f815 AH |
25 | #define VDSO__TEMP_FILE_NAME "/tmp/perf-vdso.so-XXXXXX" |
26 | ||
27 | struct vdso_file { | |
28 | bool found; | |
29 | bool error; | |
30 | char temp_file_name[sizeof(VDSO__TEMP_FILE_NAME)]; | |
31 | const char *dso_name; | |
f6832e17 | 32 | const char *read_prog; |
30f4f815 AH |
33 | }; |
34 | ||
35 | struct vdso_info { | |
36 | struct vdso_file vdso; | |
f6832e17 AH |
37 | #if BITS_PER_LONG == 64 |
38 | struct vdso_file vdso32; | |
39 | struct vdso_file vdsox32; | |
40 | #endif | |
30f4f815 AH |
41 | }; |
42 | ||
d027b640 AH |
43 | static struct vdso_info *vdso_info__new(void) |
44 | { | |
45 | static const struct vdso_info vdso_info_init = { | |
46 | .vdso = { | |
47 | .temp_file_name = VDSO__TEMP_FILE_NAME, | |
51682dc7 | 48 | .dso_name = DSO__NAME_VDSO, |
d027b640 | 49 | }, |
f6832e17 AH |
50 | #if BITS_PER_LONG == 64 |
51 | .vdso32 = { | |
52 | .temp_file_name = VDSO__TEMP_FILE_NAME, | |
53 | .dso_name = DSO__NAME_VDSO32, | |
54 | .read_prog = "perf-read-vdso32", | |
55 | }, | |
56 | .vdsox32 = { | |
57 | .temp_file_name = VDSO__TEMP_FILE_NAME, | |
58 | .dso_name = DSO__NAME_VDSOX32, | |
59 | .read_prog = "perf-read-vdsox32", | |
60 | }, | |
61 | #endif | |
d027b640 AH |
62 | }; |
63 | ||
64 | return memdup(&vdso_info_init, sizeof(vdso_info_init)); | |
65 | } | |
7dbf4dcf | 66 | |
30f4f815 | 67 | static char *get_file(struct vdso_file *vdso_file) |
7dbf4dcf JO |
68 | { |
69 | char *vdso = NULL; | |
70 | char *buf = NULL; | |
71 | void *start, *end; | |
72 | size_t size; | |
73 | int fd; | |
74 | ||
30f4f815 AH |
75 | if (vdso_file->found) |
76 | return vdso_file->temp_file_name; | |
7dbf4dcf | 77 | |
30f4f815 | 78 | if (vdso_file->error || find_vdso_map(&start, &end)) |
7dbf4dcf JO |
79 | return NULL; |
80 | ||
81 | size = end - start; | |
82 | ||
83 | buf = memdup(start, size); | |
84 | if (!buf) | |
85 | return NULL; | |
86 | ||
30f4f815 | 87 | fd = mkstemp(vdso_file->temp_file_name); |
7dbf4dcf JO |
88 | if (fd < 0) |
89 | goto out; | |
90 | ||
91 | if (size == (size_t) write(fd, buf, size)) | |
30f4f815 | 92 | vdso = vdso_file->temp_file_name; |
7dbf4dcf JO |
93 | |
94 | close(fd); | |
95 | ||
96 | out: | |
97 | free(buf); | |
98 | ||
30f4f815 AH |
99 | vdso_file->found = (vdso != NULL); |
100 | vdso_file->error = !vdso_file->found; | |
7dbf4dcf JO |
101 | return vdso; |
102 | } | |
103 | ||
9a4388c7 | 104 | void machine__exit_vdso(struct machine *machine) |
7dbf4dcf | 105 | { |
d027b640 AH |
106 | struct vdso_info *vdso_info = machine->vdso_info; |
107 | ||
108 | if (!vdso_info) | |
109 | return; | |
110 | ||
30f4f815 AH |
111 | if (vdso_info->vdso.found) |
112 | unlink(vdso_info->vdso.temp_file_name); | |
f6832e17 AH |
113 | #if BITS_PER_LONG == 64 |
114 | if (vdso_info->vdso32.found) | |
115 | unlink(vdso_info->vdso32.temp_file_name); | |
116 | if (vdso_info->vdsox32.found) | |
117 | unlink(vdso_info->vdsox32.temp_file_name); | |
118 | #endif | |
d027b640 AH |
119 | |
120 | zfree(&machine->vdso_info); | |
7dbf4dcf JO |
121 | } |
122 | ||
e8807844 ACM |
123 | static struct dso *__machine__addnew_vdso(struct machine *machine, const char *short_name, |
124 | const char *long_name) | |
4f71f2a0 AH |
125 | { |
126 | struct dso *dso; | |
127 | ||
128 | dso = dso__new(short_name); | |
129 | if (dso != NULL) { | |
e8807844 | 130 | __dsos__add(&machine->dsos, dso); |
4f71f2a0 AH |
131 | dso__set_long_name(dso, long_name, false); |
132 | } | |
133 | ||
134 | return dso; | |
135 | } | |
136 | ||
f6832e17 AH |
137 | #if BITS_PER_LONG == 64 |
138 | ||
139 | static enum dso_type machine__thread_dso_type(struct machine *machine, | |
140 | struct thread *thread) | |
141 | { | |
142 | enum dso_type dso_type = DSO__TYPE_UNKNOWN; | |
143 | struct map *map; | |
144 | struct dso *dso; | |
145 | ||
146 | map = map_groups__first(thread->mg, MAP__FUNCTION); | |
147 | for (; map ; map = map_groups__next(map)) { | |
148 | dso = map->dso; | |
149 | if (!dso || dso->long_name[0] != '/') | |
150 | continue; | |
151 | dso_type = dso__type(dso, machine); | |
152 | if (dso_type != DSO__TYPE_UNKNOWN) | |
153 | break; | |
154 | } | |
155 | ||
156 | return dso_type; | |
157 | } | |
158 | ||
159 | static int vdso__do_copy_compat(FILE *f, int fd) | |
160 | { | |
161 | char buf[4096]; | |
162 | size_t count; | |
163 | ||
164 | while (1) { | |
165 | count = fread(buf, 1, sizeof(buf), f); | |
166 | if (ferror(f)) | |
167 | return -errno; | |
168 | if (feof(f)) | |
169 | break; | |
170 | if (count && writen(fd, buf, count) != (ssize_t)count) | |
171 | return -errno; | |
172 | } | |
173 | ||
174 | return 0; | |
175 | } | |
176 | ||
177 | static int vdso__copy_compat(const char *prog, int fd) | |
178 | { | |
179 | FILE *f; | |
180 | int err; | |
181 | ||
182 | f = popen(prog, "r"); | |
183 | if (!f) | |
184 | return -errno; | |
185 | ||
186 | err = vdso__do_copy_compat(f, fd); | |
187 | ||
188 | if (pclose(f) == -1) | |
189 | return -errno; | |
190 | ||
191 | return err; | |
192 | } | |
193 | ||
194 | static int vdso__create_compat_file(const char *prog, char *temp_name) | |
195 | { | |
196 | int fd, err; | |
197 | ||
198 | fd = mkstemp(temp_name); | |
199 | if (fd < 0) | |
200 | return -errno; | |
201 | ||
202 | err = vdso__copy_compat(prog, fd); | |
203 | ||
204 | if (close(fd) == -1) | |
205 | return -errno; | |
206 | ||
207 | return err; | |
208 | } | |
209 | ||
210 | static const char *vdso__get_compat_file(struct vdso_file *vdso_file) | |
211 | { | |
212 | int err; | |
213 | ||
214 | if (vdso_file->found) | |
215 | return vdso_file->temp_file_name; | |
216 | ||
217 | if (vdso_file->error) | |
218 | return NULL; | |
219 | ||
220 | err = vdso__create_compat_file(vdso_file->read_prog, | |
221 | vdso_file->temp_file_name); | |
222 | if (err) { | |
223 | pr_err("%s failed, error %d\n", vdso_file->read_prog, err); | |
224 | vdso_file->error = true; | |
225 | return NULL; | |
226 | } | |
227 | ||
228 | vdso_file->found = true; | |
229 | ||
230 | return vdso_file->temp_file_name; | |
231 | } | |
232 | ||
e8807844 ACM |
233 | static struct dso *__machine__findnew_compat(struct machine *machine, |
234 | struct vdso_file *vdso_file) | |
f6832e17 AH |
235 | { |
236 | const char *file_name; | |
237 | struct dso *dso; | |
238 | ||
e8807844 ACM |
239 | pthread_rwlock_wrlock(&machine->dsos.lock); |
240 | dso = __dsos__find(&machine->dsos, vdso_file->dso_name, true); | |
f6832e17 | 241 | if (dso) |
e8807844 | 242 | goto out_unlock; |
f6832e17 AH |
243 | |
244 | file_name = vdso__get_compat_file(vdso_file); | |
245 | if (!file_name) | |
e8807844 | 246 | goto out_unlock; |
f6832e17 | 247 | |
e8807844 ACM |
248 | dso = __machine__addnew_vdso(machine, vdso_file->dso_name, file_name); |
249 | out_unlock: | |
250 | pthread_rwlock_unlock(&machine->dsos.lock); | |
251 | return dso; | |
f6832e17 AH |
252 | } |
253 | ||
e8807844 ACM |
254 | static int __machine__findnew_vdso_compat(struct machine *machine, |
255 | struct thread *thread, | |
256 | struct vdso_info *vdso_info, | |
257 | struct dso **dso) | |
f6832e17 AH |
258 | { |
259 | enum dso_type dso_type; | |
260 | ||
261 | dso_type = machine__thread_dso_type(machine, thread); | |
46b1fa85 AH |
262 | |
263 | #ifndef HAVE_PERF_READ_VDSO32 | |
264 | if (dso_type == DSO__TYPE_32BIT) | |
265 | return 0; | |
266 | #endif | |
267 | #ifndef HAVE_PERF_READ_VDSOX32 | |
268 | if (dso_type == DSO__TYPE_X32BIT) | |
269 | return 0; | |
270 | #endif | |
271 | ||
f6832e17 AH |
272 | switch (dso_type) { |
273 | case DSO__TYPE_32BIT: | |
e8807844 | 274 | *dso = __machine__findnew_compat(machine, &vdso_info->vdso32); |
f6832e17 AH |
275 | return 1; |
276 | case DSO__TYPE_X32BIT: | |
e8807844 | 277 | *dso = __machine__findnew_compat(machine, &vdso_info->vdsox32); |
f6832e17 AH |
278 | return 1; |
279 | case DSO__TYPE_UNKNOWN: | |
280 | case DSO__TYPE_64BIT: | |
281 | default: | |
282 | return 0; | |
283 | } | |
284 | } | |
285 | ||
286 | #endif | |
287 | ||
9a4388c7 ACM |
288 | struct dso *machine__findnew_vdso(struct machine *machine, |
289 | struct thread *thread __maybe_unused) | |
7dbf4dcf | 290 | { |
d027b640 | 291 | struct vdso_info *vdso_info; |
e8807844 | 292 | struct dso *dso = NULL; |
d027b640 | 293 | |
e8807844 | 294 | pthread_rwlock_wrlock(&machine->dsos.lock); |
d027b640 AH |
295 | if (!machine->vdso_info) |
296 | machine->vdso_info = vdso_info__new(); | |
297 | ||
298 | vdso_info = machine->vdso_info; | |
299 | if (!vdso_info) | |
e8807844 | 300 | goto out_unlock; |
7dbf4dcf | 301 | |
f6832e17 | 302 | #if BITS_PER_LONG == 64 |
e8807844 ACM |
303 | if (__machine__findnew_vdso_compat(machine, thread, vdso_info, &dso)) |
304 | goto out_unlock; | |
f6832e17 AH |
305 | #endif |
306 | ||
e8807844 | 307 | dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO, true); |
7dbf4dcf JO |
308 | if (!dso) { |
309 | char *file; | |
310 | ||
30f4f815 | 311 | file = get_file(&vdso_info->vdso); |
e8807844 ACM |
312 | if (file) |
313 | dso = __machine__addnew_vdso(machine, DSO__NAME_VDSO, file); | |
7dbf4dcf JO |
314 | } |
315 | ||
e8807844 | 316 | out_unlock: |
d3a7c489 | 317 | dso__get(dso); |
e8807844 | 318 | pthread_rwlock_unlock(&machine->dsos.lock); |
7dbf4dcf JO |
319 | return dso; |
320 | } | |
51682dc7 AH |
321 | |
322 | bool dso__is_vdso(struct dso *dso) | |
323 | { | |
f6832e17 AH |
324 | return !strcmp(dso->short_name, DSO__NAME_VDSO) || |
325 | !strcmp(dso->short_name, DSO__NAME_VDSO32) || | |
326 | !strcmp(dso->short_name, DSO__NAME_VDSOX32); | |
51682dc7 | 327 | } |