blob: 7ff682770fdb16e71b368af16efad0edd9443d87 [file] [log] [blame]
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001#include "callchain.h"
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03002#include "debug.h"
3#include "event.h"
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03004#include "evsel.h"
5#include "hist.h"
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -03006#include "machine.h"
7#include "map.h"
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03008#include "sort.h"
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -03009#include "strlist.h"
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -030010#include "thread.h"
Adrian Hunterd027b642014-07-23 14:23:00 +030011#include "vdso.h"
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -030012#include <stdbool.h>
Arnaldo Carvalho de Meloc506c962013-12-11 09:15:00 -030013#include <symbol/kallsyms.h>
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -030014#include "unwind.h"
Andi Kleen8b7bad52014-11-12 18:05:20 -080015#include "linux/hash.h"
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -030016
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -030017static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock);
18
Arnaldo Carvalho de Meloe167f992014-10-14 15:07:48 -030019static void dsos__init(struct dsos *dsos)
20{
21 INIT_LIST_HEAD(&dsos->head);
22 dsos->root = RB_ROOT;
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -030023 pthread_rwlock_init(&dsos->lock, NULL);
Arnaldo Carvalho de Meloe167f992014-10-14 15:07:48 -030024}
25
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030026int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
27{
Arnaldo Carvalho de Melo11246c72014-10-21 17:29:02 -030028 map_groups__init(&machine->kmaps, machine);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030029 RB_CLEAR_NODE(&machine->rb_node);
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -030030 dsos__init(&machine->dsos);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030031
32 machine->threads = RB_ROOT;
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -030033 pthread_rwlock_init(&machine->threads_lock, NULL);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030034 INIT_LIST_HEAD(&machine->dead_threads);
35 machine->last_match = NULL;
36
Adrian Hunterd027b642014-07-23 14:23:00 +030037 machine->vdso_info = NULL;
38
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030039 machine->pid = pid;
40
Adrian Hunter611a5ce2013-08-08 14:32:20 +030041 machine->symbol_filter = NULL;
Jiri Olsa14bd6d22014-01-07 13:47:19 +010042 machine->id_hdr_size = 0;
Adrian Huntercfe1c412014-07-31 09:00:45 +030043 machine->comm_exec = false;
Adrian Hunterfbe2af42014-08-15 22:08:39 +030044 machine->kernel_start = 0;
Adrian Hunter611a5ce2013-08-08 14:32:20 +030045
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030046 machine->root_dir = strdup(root_dir);
47 if (machine->root_dir == NULL)
48 return -ENOMEM;
49
50 if (pid != HOST_KERNEL_ID) {
Adrian Hunter1fcb8762014-07-14 13:02:25 +030051 struct thread *thread = machine__findnew_thread(machine, -1,
Adrian Hunter314add62013-08-27 11:23:03 +030052 pid);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030053 char comm[64];
54
55 if (thread == NULL)
56 return -ENOMEM;
57
58 snprintf(comm, sizeof(comm), "[guest/%d]", pid);
Frederic Weisbecker162f0be2013-09-11 16:18:24 +020059 thread__set_comm(thread, comm, 0);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -030060 thread__put(thread);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030061 }
62
Adrian Hunterb9d266b2014-07-22 16:17:25 +030063 machine->current_tid = NULL;
64
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030065 return 0;
66}
67
David Ahern8fb598e2013-09-28 13:13:00 -060068struct machine *machine__new_host(void)
69{
70 struct machine *machine = malloc(sizeof(*machine));
71
72 if (machine != NULL) {
73 machine__init(machine, "", HOST_KERNEL_ID);
74
75 if (machine__create_kernel_maps(machine) < 0)
76 goto out_delete;
77 }
78
79 return machine;
80out_delete:
81 free(machine);
82 return NULL;
83}
84
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -030085static void dsos__purge(struct dsos *dsos)
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030086{
87 struct dso *pos, *n;
88
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -030089 pthread_rwlock_wrlock(&dsos->lock);
90
Waiman Long8fa7d872014-09-29 16:07:28 -040091 list_for_each_entry_safe(pos, n, &dsos->head, node) {
Waiman Long4598a0a2014-09-30 13:36:15 -040092 RB_CLEAR_NODE(&pos->rb_node);
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -030093 list_del_init(&pos->node);
94 dso__put(pos);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -030095 }
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -030096
97 pthread_rwlock_unlock(&dsos->lock);
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -030098}
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -030099
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -0300100static void dsos__exit(struct dsos *dsos)
101{
102 dsos__purge(dsos);
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300103 pthread_rwlock_destroy(&dsos->lock);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300104}
105
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300106void machine__delete_threads(struct machine *machine)
107{
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300108 struct rb_node *nd;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300109
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300110 pthread_rwlock_wrlock(&machine->threads_lock);
111 nd = rb_first(&machine->threads);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300112 while (nd) {
113 struct thread *t = rb_entry(nd, struct thread, rb_node);
114
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300115 nd = rb_next(nd);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300116 __machine__remove_thread(machine, t, false);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300117 }
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300118 pthread_rwlock_unlock(&machine->threads_lock);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300119}
120
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300121void machine__exit(struct machine *machine)
122{
123 map_groups__exit(&machine->kmaps);
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300124 dsos__exit(&machine->dsos);
Arnaldo Carvalho de Melo9a4388c2015-05-29 11:54:08 -0300125 machine__exit_vdso(machine);
Arnaldo Carvalho de Melo04662522013-12-26 17:41:15 -0300126 zfree(&machine->root_dir);
Adrian Hunterb9d266b2014-07-22 16:17:25 +0300127 zfree(&machine->current_tid);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300128 pthread_rwlock_destroy(&machine->threads_lock);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300129}
130
131void machine__delete(struct machine *machine)
132{
133 machine__exit(machine);
134 free(machine);
135}
136
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300137void machines__init(struct machines *machines)
138{
139 machine__init(&machines->host, "", HOST_KERNEL_ID);
140 machines->guests = RB_ROOT;
Adrian Hunter611a5ce2013-08-08 14:32:20 +0300141 machines->symbol_filter = NULL;
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300142}
143
144void machines__exit(struct machines *machines)
145{
146 machine__exit(&machines->host);
147 /* XXX exit guest */
148}
149
150struct machine *machines__add(struct machines *machines, pid_t pid,
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300151 const char *root_dir)
152{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300153 struct rb_node **p = &machines->guests.rb_node;
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300154 struct rb_node *parent = NULL;
155 struct machine *pos, *machine = malloc(sizeof(*machine));
156
157 if (machine == NULL)
158 return NULL;
159
160 if (machine__init(machine, root_dir, pid) != 0) {
161 free(machine);
162 return NULL;
163 }
164
Adrian Hunter611a5ce2013-08-08 14:32:20 +0300165 machine->symbol_filter = machines->symbol_filter;
166
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300167 while (*p != NULL) {
168 parent = *p;
169 pos = rb_entry(parent, struct machine, rb_node);
170 if (pid < pos->pid)
171 p = &(*p)->rb_left;
172 else
173 p = &(*p)->rb_right;
174 }
175
176 rb_link_node(&machine->rb_node, parent, p);
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300177 rb_insert_color(&machine->rb_node, &machines->guests);
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300178
179 return machine;
180}
181
Adrian Hunter611a5ce2013-08-08 14:32:20 +0300182void machines__set_symbol_filter(struct machines *machines,
183 symbol_filter_t symbol_filter)
184{
185 struct rb_node *nd;
186
187 machines->symbol_filter = symbol_filter;
188 machines->host.symbol_filter = symbol_filter;
189
190 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
191 struct machine *machine = rb_entry(nd, struct machine, rb_node);
192
193 machine->symbol_filter = symbol_filter;
194 }
195}
196
Adrian Huntercfe1c412014-07-31 09:00:45 +0300197void machines__set_comm_exec(struct machines *machines, bool comm_exec)
198{
199 struct rb_node *nd;
200
201 machines->host.comm_exec = comm_exec;
202
203 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
204 struct machine *machine = rb_entry(nd, struct machine, rb_node);
205
206 machine->comm_exec = comm_exec;
207 }
208}
209
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300210struct machine *machines__find(struct machines *machines, pid_t pid)
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300211{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300212 struct rb_node **p = &machines->guests.rb_node;
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300213 struct rb_node *parent = NULL;
214 struct machine *machine;
215 struct machine *default_machine = NULL;
216
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300217 if (pid == HOST_KERNEL_ID)
218 return &machines->host;
219
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300220 while (*p != NULL) {
221 parent = *p;
222 machine = rb_entry(parent, struct machine, rb_node);
223 if (pid < machine->pid)
224 p = &(*p)->rb_left;
225 else if (pid > machine->pid)
226 p = &(*p)->rb_right;
227 else
228 return machine;
229 if (!machine->pid)
230 default_machine = machine;
231 }
232
233 return default_machine;
234}
235
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300236struct machine *machines__findnew(struct machines *machines, pid_t pid)
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300237{
238 char path[PATH_MAX];
239 const char *root_dir = "";
240 struct machine *machine = machines__find(machines, pid);
241
242 if (machine && (machine->pid == pid))
243 goto out;
244
245 if ((pid != HOST_KERNEL_ID) &&
246 (pid != DEFAULT_GUEST_KERNEL_ID) &&
247 (symbol_conf.guestmount)) {
248 sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
249 if (access(path, R_OK)) {
250 static struct strlist *seen;
251
252 if (!seen)
253 seen = strlist__new(true, NULL);
254
255 if (!strlist__has_entry(seen, path)) {
256 pr_err("Can't access file %s\n", path);
257 strlist__add(seen, path);
258 }
259 machine = NULL;
260 goto out;
261 }
262 root_dir = path;
263 }
264
265 machine = machines__add(machines, pid, root_dir);
266out:
267 return machine;
268}
269
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300270void machines__process_guests(struct machines *machines,
271 machine__process_t process, void *data)
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300272{
273 struct rb_node *nd;
274
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300275 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300276 struct machine *pos = rb_entry(nd, struct machine, rb_node);
277 process(pos, data);
278 }
279}
280
281char *machine__mmap_name(struct machine *machine, char *bf, size_t size)
282{
283 if (machine__is_host(machine))
284 snprintf(bf, size, "[%s]", "kernel.kallsyms");
285 else if (machine__is_default_guest(machine))
286 snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
287 else {
288 snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms",
289 machine->pid);
290 }
291
292 return bf;
293}
294
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300295void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300296{
297 struct rb_node *node;
298 struct machine *machine;
299
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300300 machines->host.id_hdr_size = id_hdr_size;
301
302 for (node = rb_first(&machines->guests); node; node = rb_next(node)) {
Arnaldo Carvalho de Melo69d25912012-11-09 11:32:52 -0300303 machine = rb_entry(node, struct machine, rb_node);
304 machine->id_hdr_size = id_hdr_size;
305 }
306
307 return;
308}
309
Adrian Hunter29ce3612014-07-16 11:07:13 +0300310static void machine__update_thread_pid(struct machine *machine,
311 struct thread *th, pid_t pid)
312{
313 struct thread *leader;
314
315 if (pid == th->pid_ || pid == -1 || th->pid_ != -1)
316 return;
317
318 th->pid_ = pid;
319
320 if (th->pid_ == th->tid)
321 return;
322
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300323 leader = __machine__findnew_thread(machine, th->pid_, th->pid_);
Adrian Hunter29ce3612014-07-16 11:07:13 +0300324 if (!leader)
325 goto out_err;
326
327 if (!leader->mg)
Arnaldo Carvalho de Melo11246c72014-10-21 17:29:02 -0300328 leader->mg = map_groups__new(machine);
Adrian Hunter29ce3612014-07-16 11:07:13 +0300329
330 if (!leader->mg)
331 goto out_err;
332
333 if (th->mg == leader->mg)
334 return;
335
336 if (th->mg) {
337 /*
338 * Maps are created from MMAP events which provide the pid and
339 * tid. Consequently there never should be any maps on a thread
340 * with an unknown pid. Just print an error if there are.
341 */
342 if (!map_groups__empty(th->mg))
343 pr_err("Discarding thread maps for %d:%d\n",
344 th->pid_, th->tid);
Arnaldo Carvalho de Melo8e160b22015-05-19 20:07:14 -0300345 map_groups__put(th->mg);
Adrian Hunter29ce3612014-07-16 11:07:13 +0300346 }
347
348 th->mg = map_groups__get(leader->mg);
349
350 return;
351
352out_err:
353 pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid);
354}
355
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300356static struct thread *____machine__findnew_thread(struct machine *machine,
357 pid_t pid, pid_t tid,
358 bool create)
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300359{
360 struct rb_node **p = &machine->threads.rb_node;
361 struct rb_node *parent = NULL;
362 struct thread *th;
363
364 /*
Adrian Hunter38051232013-07-04 16:20:31 +0300365 * Front-end cache - TID lookups come in blocks,
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300366 * so most of the time we dont have to look up
367 * the full rbtree:
368 */
Adrian Hunter29ce3612014-07-16 11:07:13 +0300369 th = machine->last_match;
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -0300370 if (th != NULL) {
371 if (th->tid == tid) {
372 machine__update_thread_pid(machine, th, pid);
373 return th;
374 }
375
Arnaldo Carvalho de Melo0ceb8f62015-05-11 18:08:12 -0300376 machine->last_match = NULL;
Adrian Hunter99d725f2013-08-26 16:00:19 +0300377 }
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300378
379 while (*p != NULL) {
380 parent = *p;
381 th = rb_entry(parent, struct thread, rb_node);
382
Adrian Hunter38051232013-07-04 16:20:31 +0300383 if (th->tid == tid) {
Arnaldo Carvalho de Melo0ceb8f62015-05-11 18:08:12 -0300384 machine->last_match = th;
Adrian Hunter29ce3612014-07-16 11:07:13 +0300385 machine__update_thread_pid(machine, th, pid);
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300386 return th;
387 }
388
Adrian Hunter38051232013-07-04 16:20:31 +0300389 if (tid < th->tid)
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300390 p = &(*p)->rb_left;
391 else
392 p = &(*p)->rb_right;
393 }
394
395 if (!create)
396 return NULL;
397
Adrian Hunter99d725f2013-08-26 16:00:19 +0300398 th = thread__new(pid, tid);
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300399 if (th != NULL) {
400 rb_link_node(&th->rb_node, parent, p);
401 rb_insert_color(&th->rb_node, &machine->threads);
Jiri Olsacddcef62014-04-09 20:54:29 +0200402
403 /*
404 * We have to initialize map_groups separately
405 * after rb tree is updated.
406 *
407 * The reason is that we call machine__findnew_thread
408 * within thread__init_map_groups to find the thread
409 * leader and that would screwed the rb tree.
410 */
Adrian Hunter418029b2014-07-16 10:19:44 +0300411 if (thread__init_map_groups(th, machine)) {
Arnaldo Carvalho de Melo0170b142015-05-25 15:23:05 -0300412 rb_erase_init(&th->rb_node, &machine->threads);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300413 RB_CLEAR_NODE(&th->rb_node);
Adrian Hunter418029b2014-07-16 10:19:44 +0300414 thread__delete(th);
Jiri Olsacddcef62014-04-09 20:54:29 +0200415 return NULL;
Adrian Hunter418029b2014-07-16 10:19:44 +0300416 }
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -0300417 /*
418 * It is now in the rbtree, get a ref
419 */
420 thread__get(th);
Arnaldo Carvalho de Melo0ceb8f62015-05-11 18:08:12 -0300421 machine->last_match = th;
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300422 }
423
424 return th;
425}
426
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300427struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid)
428{
429 return ____machine__findnew_thread(machine, pid, tid, true);
430}
431
Adrian Hunter314add62013-08-27 11:23:03 +0300432struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
433 pid_t tid)
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300434{
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300435 struct thread *th;
436
437 pthread_rwlock_wrlock(&machine->threads_lock);
438 th = thread__get(__machine__findnew_thread(machine, pid, tid));
439 pthread_rwlock_unlock(&machine->threads_lock);
440 return th;
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300441}
442
Jiri Olsad75e6092014-03-14 15:00:03 +0100443struct thread *machine__find_thread(struct machine *machine, pid_t pid,
444 pid_t tid)
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300445{
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300446 struct thread *th;
447 pthread_rwlock_rdlock(&machine->threads_lock);
448 th = thread__get(____machine__findnew_thread(machine, pid, tid, false));
449 pthread_rwlock_unlock(&machine->threads_lock);
450 return th;
Arnaldo Carvalho de Melo9d2f8e22012-10-06 15:43:20 -0300451}
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300452
Adrian Huntercfe1c412014-07-31 09:00:45 +0300453struct comm *machine__thread_exec_comm(struct machine *machine,
454 struct thread *thread)
455{
456 if (machine->comm_exec)
457 return thread__exec_comm(thread);
458 else
459 return thread__comm(thread);
460}
461
Frederic Weisbecker162f0be2013-09-11 16:18:24 +0200462int machine__process_comm_event(struct machine *machine, union perf_event *event,
463 struct perf_sample *sample)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300464{
Adrian Hunter314add62013-08-27 11:23:03 +0300465 struct thread *thread = machine__findnew_thread(machine,
466 event->comm.pid,
467 event->comm.tid);
Adrian Hunter65de51f2014-07-31 09:00:44 +0300468 bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC;
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300469 int err = 0;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300470
Adrian Huntercfe1c412014-07-31 09:00:45 +0300471 if (exec)
472 machine->comm_exec = true;
473
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300474 if (dump_trace)
475 perf_event__fprintf_comm(event, stdout);
476
Adrian Hunter65de51f2014-07-31 09:00:44 +0300477 if (thread == NULL ||
478 __thread__set_comm(thread, event->comm.comm, sample->time, exec)) {
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300479 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300480 err = -1;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300481 }
482
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300483 thread__put(thread);
484
485 return err;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300486}
487
488int machine__process_lost_event(struct machine *machine __maybe_unused,
Frederic Weisbecker162f0be2013-09-11 16:18:24 +0200489 union perf_event *event, struct perf_sample *sample __maybe_unused)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -0300490{
491 dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
492 event->lost.id, event->lost.lost);
493 return 0;
494}
495
Kan Liangc4937a92015-05-10 15:13:15 -0400496int machine__process_lost_samples_event(struct machine *machine __maybe_unused,
497 union perf_event *event, struct perf_sample *sample)
498{
499 dump_printf(": id:%" PRIu64 ": lost samples :%" PRIu64 "\n",
500 sample->id, event->lost_samples.lost);
501 return 0;
502}
503
Arnaldo Carvalho de Melo9f2de312015-06-01 12:01:02 -0300504static struct dso *machine__findnew_module_dso(struct machine *machine,
505 struct kmod_path *m,
506 const char *filename)
Jiri Olsada17ea32015-02-12 22:10:52 +0100507{
508 struct dso *dso;
Jiri Olsada17ea32015-02-12 22:10:52 +0100509
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300510 pthread_rwlock_wrlock(&machine->dsos.lock);
511
512 dso = __dsos__find(&machine->dsos, m->name, true);
Jiri Olsada17ea32015-02-12 22:10:52 +0100513 if (!dso) {
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300514 dso = __dsos__addnew(&machine->dsos, m->name);
Jiri Olsada17ea32015-02-12 22:10:52 +0100515 if (dso == NULL)
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300516 goto out_unlock;
Jiri Olsada17ea32015-02-12 22:10:52 +0100517
518 if (machine__is_host(machine))
519 dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
520 else
521 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
522
523 /* _KMODULE_COMP should be next to _KMODULE */
Jiri Olsaca333802015-02-17 17:29:57 +0100524 if (m->kmod && m->comp)
Jiri Olsada17ea32015-02-12 22:10:52 +0100525 dso->symtab_type++;
Jiri Olsaca333802015-02-17 17:29:57 +0100526
527 dso__set_short_name(dso, strdup(m->name), true);
528 dso__set_long_name(dso, strdup(filename), true);
Jiri Olsada17ea32015-02-12 22:10:52 +0100529 }
530
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -0300531 dso__get(dso);
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -0300532out_unlock:
533 pthread_rwlock_unlock(&machine->dsos.lock);
Jiri Olsada17ea32015-02-12 22:10:52 +0100534 return dso;
535}
536
Adrian Hunter4a96f7a2015-04-30 17:37:29 +0300537int machine__process_aux_event(struct machine *machine __maybe_unused,
538 union perf_event *event)
539{
540 if (dump_trace)
541 perf_event__fprintf_aux(event, stdout);
542 return 0;
543}
544
Adrian Hunter0ad21f62015-04-30 17:37:30 +0300545int machine__process_itrace_start_event(struct machine *machine __maybe_unused,
546 union perf_event *event)
547{
548 if (dump_trace)
549 perf_event__fprintf_itrace_start(event, stdout);
550 return 0;
551}
552
Arnaldo Carvalho de Melo9f2de312015-06-01 12:01:02 -0300553struct map *machine__findnew_module_map(struct machine *machine, u64 start,
554 const char *filename)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300555{
Jiri Olsaca333802015-02-17 17:29:57 +0100556 struct map *map = NULL;
557 struct dso *dso;
558 struct kmod_path m;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300559
Jiri Olsaca333802015-02-17 17:29:57 +0100560 if (kmod_path__parse_name(&m, filename))
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300561 return NULL;
562
Jiri Olsabc84f462015-02-17 17:31:18 +0100563 map = map_groups__find_by_name(&machine->kmaps, MAP__FUNCTION,
564 m.name);
565 if (map)
566 goto out;
567
Arnaldo Carvalho de Melo9f2de312015-06-01 12:01:02 -0300568 dso = machine__findnew_module_dso(machine, &m, filename);
Jiri Olsaca333802015-02-17 17:29:57 +0100569 if (dso == NULL)
570 goto out;
571
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300572 map = map__new2(start, dso, MAP__FUNCTION);
573 if (map == NULL)
Jiri Olsaca333802015-02-17 17:29:57 +0100574 goto out;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300575
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300576 map_groups__insert(&machine->kmaps, map);
Jiri Olsaca333802015-02-17 17:29:57 +0100577
578out:
579 free(m.name);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300580 return map;
581}
582
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300583size_t machines__fprintf_dsos(struct machines *machines, FILE *fp)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300584{
585 struct rb_node *nd;
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -0300586 size_t ret = __dsos__fprintf(&machines->host.dsos.head, fp);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300587
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300588 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300589 struct machine *pos = rb_entry(nd, struct machine, rb_node);
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -0300590 ret += __dsos__fprintf(&pos->dsos.head, fp);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300591 }
592
593 return ret;
594}
595
Waiman Long8fa7d872014-09-29 16:07:28 -0400596size_t machine__fprintf_dsos_buildid(struct machine *m, FILE *fp,
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300597 bool (skip)(struct dso *dso, int parm), int parm)
598{
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -0300599 return __dsos__fprintf_buildid(&m->dsos.head, fp, skip, parm);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300600}
601
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300602size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp,
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300603 bool (skip)(struct dso *dso, int parm), int parm)
604{
605 struct rb_node *nd;
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300606 size_t ret = machine__fprintf_dsos_buildid(&machines->host, fp, skip, parm);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300607
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300608 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300609 struct machine *pos = rb_entry(nd, struct machine, rb_node);
610 ret += machine__fprintf_dsos_buildid(pos, fp, skip, parm);
611 }
612 return ret;
613}
614
615size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
616{
617 int i;
618 size_t printed = 0;
619 struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
620
621 if (kdso->has_build_id) {
622 char filename[PATH_MAX];
623 if (dso__build_id_filename(kdso, filename, sizeof(filename)))
624 printed += fprintf(fp, "[0] %s\n", filename);
625 }
626
627 for (i = 0; i < vmlinux_path__nr_entries; ++i)
628 printed += fprintf(fp, "[%d] %s\n",
629 i + kdso->has_build_id, vmlinux_path[i]);
630
631 return printed;
632}
633
634size_t machine__fprintf(struct machine *machine, FILE *fp)
635{
636 size_t ret = 0;
637 struct rb_node *nd;
638
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300639 pthread_rwlock_rdlock(&machine->threads_lock);
640
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300641 for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
642 struct thread *pos = rb_entry(nd, struct thread, rb_node);
643
644 ret += thread__fprintf(pos, fp);
645 }
646
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300647 pthread_rwlock_unlock(&machine->threads_lock);
648
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300649 return ret;
650}
651
652static struct dso *machine__get_kernel(struct machine *machine)
653{
654 const char *vmlinux_name = NULL;
655 struct dso *kernel;
656
657 if (machine__is_host(machine)) {
658 vmlinux_name = symbol_conf.vmlinux_name;
659 if (!vmlinux_name)
660 vmlinux_name = "[kernel.kallsyms]";
661
Arnaldo Carvalho de Melo459ce512015-05-28 12:40:55 -0300662 kernel = machine__findnew_kernel(machine, vmlinux_name,
663 "[kernel]", DSO_TYPE_KERNEL);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300664 } else {
665 char bf[PATH_MAX];
666
667 if (machine__is_default_guest(machine))
668 vmlinux_name = symbol_conf.default_guest_vmlinux_name;
669 if (!vmlinux_name)
670 vmlinux_name = machine__mmap_name(machine, bf,
671 sizeof(bf));
672
Arnaldo Carvalho de Melo459ce512015-05-28 12:40:55 -0300673 kernel = machine__findnew_kernel(machine, vmlinux_name,
674 "[guest.kernel]",
675 DSO_TYPE_GUEST_KERNEL);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300676 }
677
678 if (kernel != NULL && (!kernel->has_build_id))
679 dso__read_running_kernel_build_id(kernel, machine);
680
681 return kernel;
682}
683
684struct process_args {
685 u64 start;
686};
687
Adrian Hunter15a0a872014-01-29 16:14:38 +0200688static void machine__get_kallsyms_filename(struct machine *machine, char *buf,
689 size_t bufsz)
690{
691 if (machine__is_default_guest(machine))
692 scnprintf(buf, bufsz, "%s", symbol_conf.default_guest_kallsyms);
693 else
694 scnprintf(buf, bufsz, "%s/proc/kallsyms", machine->root_dir);
695}
696
Simon Quea93f0e52014-06-16 11:32:09 -0700697const char *ref_reloc_sym_names[] = {"_text", "_stext", NULL};
698
699/* Figure out the start address of kernel map from /proc/kallsyms.
700 * Returns the name of the start symbol in *symbol_name. Pass in NULL as
701 * symbol_name if it's not that important.
702 */
Adrian Hunter4b993752014-08-15 22:08:38 +0300703static u64 machine__get_running_kernel_start(struct machine *machine,
704 const char **symbol_name)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300705{
Adrian Hunter15a0a872014-01-29 16:14:38 +0200706 char filename[PATH_MAX];
Simon Quea93f0e52014-06-16 11:32:09 -0700707 int i;
708 const char *name;
709 u64 addr = 0;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300710
Adrian Hunter15a0a872014-01-29 16:14:38 +0200711 machine__get_kallsyms_filename(machine, filename, PATH_MAX);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300712
713 if (symbol__restricted_filename(filename, "/proc/kallsyms"))
714 return 0;
715
Simon Quea93f0e52014-06-16 11:32:09 -0700716 for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) {
717 addr = kallsyms__get_function_start(filename, name);
718 if (addr)
719 break;
720 }
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300721
Simon Quea93f0e52014-06-16 11:32:09 -0700722 if (symbol_name)
723 *symbol_name = name;
724
725 return addr;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300726}
727
728int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
729{
730 enum map_type type;
Adrian Hunter4b993752014-08-15 22:08:38 +0300731 u64 start = machine__get_running_kernel_start(machine, NULL);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300732
733 for (type = 0; type < MAP__NR_TYPES; ++type) {
734 struct kmap *kmap;
735
736 machine->vmlinux_maps[type] = map__new2(start, kernel, type);
737 if (machine->vmlinux_maps[type] == NULL)
738 return -1;
739
740 machine->vmlinux_maps[type]->map_ip =
741 machine->vmlinux_maps[type]->unmap_ip =
742 identity__map_ip;
743 kmap = map__kmap(machine->vmlinux_maps[type]);
Wang Nanba927322015-04-07 08:22:45 +0000744 if (!kmap)
745 return -1;
746
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300747 kmap->kmaps = &machine->kmaps;
748 map_groups__insert(&machine->kmaps,
749 machine->vmlinux_maps[type]);
750 }
751
752 return 0;
753}
754
755void machine__destroy_kernel_maps(struct machine *machine)
756{
757 enum map_type type;
758
759 for (type = 0; type < MAP__NR_TYPES; ++type) {
760 struct kmap *kmap;
761
762 if (machine->vmlinux_maps[type] == NULL)
763 continue;
764
765 kmap = map__kmap(machine->vmlinux_maps[type]);
766 map_groups__remove(&machine->kmaps,
767 machine->vmlinux_maps[type]);
Wang Nanba927322015-04-07 08:22:45 +0000768 if (kmap && kmap->ref_reloc_sym) {
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300769 /*
770 * ref_reloc_sym is shared among all maps, so free just
771 * on one of them.
772 */
773 if (type == MAP__FUNCTION) {
Arnaldo Carvalho de Melo04662522013-12-26 17:41:15 -0300774 zfree((char **)&kmap->ref_reloc_sym->name);
775 zfree(&kmap->ref_reloc_sym);
776 } else
777 kmap->ref_reloc_sym = NULL;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300778 }
779
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300780 machine->vmlinux_maps[type] = NULL;
781 }
782}
783
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300784int machines__create_guest_kernel_maps(struct machines *machines)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300785{
786 int ret = 0;
787 struct dirent **namelist = NULL;
788 int i, items = 0;
789 char path[PATH_MAX];
790 pid_t pid;
791 char *endp;
792
793 if (symbol_conf.default_guest_vmlinux_name ||
794 symbol_conf.default_guest_modules ||
795 symbol_conf.default_guest_kallsyms) {
796 machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
797 }
798
799 if (symbol_conf.guestmount) {
800 items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
801 if (items <= 0)
802 return -ENOENT;
803 for (i = 0; i < items; i++) {
804 if (!isdigit(namelist[i]->d_name[0])) {
805 /* Filter out . and .. */
806 continue;
807 }
808 pid = (pid_t)strtol(namelist[i]->d_name, &endp, 10);
809 if ((*endp != '\0') ||
810 (endp == namelist[i]->d_name) ||
811 (errno == ERANGE)) {
812 pr_debug("invalid directory (%s). Skipping.\n",
813 namelist[i]->d_name);
814 continue;
815 }
816 sprintf(path, "%s/%s/proc/kallsyms",
817 symbol_conf.guestmount,
818 namelist[i]->d_name);
819 ret = access(path, R_OK);
820 if (ret) {
821 pr_debug("Can't access file %s\n", path);
822 goto failure;
823 }
824 machines__create_kernel_maps(machines, pid);
825 }
826failure:
827 free(namelist);
828 }
829
830 return ret;
831}
832
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300833void machines__destroy_kernel_maps(struct machines *machines)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300834{
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300835 struct rb_node *next = rb_first(&machines->guests);
836
837 machine__destroy_kernel_maps(&machines->host);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300838
839 while (next) {
840 struct machine *pos = rb_entry(next, struct machine, rb_node);
841
842 next = rb_next(&pos->rb_node);
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300843 rb_erase(&pos->rb_node, &machines->guests);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300844 machine__delete(pos);
845 }
846}
847
Arnaldo Carvalho de Melo876650e2012-12-18 19:15:48 -0300848int machines__create_kernel_maps(struct machines *machines, pid_t pid)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300849{
850 struct machine *machine = machines__findnew(machines, pid);
851
852 if (machine == NULL)
853 return -1;
854
855 return machine__create_kernel_maps(machine);
856}
857
858int machine__load_kallsyms(struct machine *machine, const char *filename,
859 enum map_type type, symbol_filter_t filter)
860{
861 struct map *map = machine->vmlinux_maps[type];
862 int ret = dso__load_kallsyms(map->dso, filename, map, filter);
863
864 if (ret > 0) {
865 dso__set_loaded(map->dso, type);
866 /*
867 * Since /proc/kallsyms will have multiple sessions for the
868 * kernel, with modules between them, fixup the end of all
869 * sections.
870 */
871 __map_groups__fixup_end(&machine->kmaps, type);
872 }
873
874 return ret;
875}
876
877int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
878 symbol_filter_t filter)
879{
880 struct map *map = machine->vmlinux_maps[type];
881 int ret = dso__load_vmlinux_path(map->dso, map, filter);
882
Adrian Hunter39b12f782013-08-07 14:38:47 +0300883 if (ret > 0)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300884 dso__set_loaded(map->dso, type);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300885
886 return ret;
887}
888
889static void map_groups__fixup_end(struct map_groups *mg)
890{
891 int i;
892 for (i = 0; i < MAP__NR_TYPES; ++i)
893 __map_groups__fixup_end(mg, i);
894}
895
896static char *get_kernel_version(const char *root_dir)
897{
898 char version[PATH_MAX];
899 FILE *file;
900 char *name, *tmp;
901 const char *prefix = "Linux version ";
902
903 sprintf(version, "%s/proc/version", root_dir);
904 file = fopen(version, "r");
905 if (!file)
906 return NULL;
907
908 version[0] = '\0';
909 tmp = fgets(version, sizeof(version), file);
910 fclose(file);
911
912 name = strstr(version, prefix);
913 if (!name)
914 return NULL;
915 name += strlen(prefix);
916 tmp = strchr(name, ' ');
917 if (tmp)
918 *tmp = '\0';
919
920 return strdup(name);
921}
922
Jiri Olsabb58a8a2015-02-12 22:20:01 +0100923static bool is_kmod_dso(struct dso *dso)
924{
925 return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE ||
926 dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE;
927}
928
929static int map_groups__set_module_path(struct map_groups *mg, const char *path,
930 struct kmod_path *m)
931{
932 struct map *map;
933 char *long_name;
934
935 map = map_groups__find_by_name(mg, MAP__FUNCTION, m->name);
936 if (map == NULL)
937 return 0;
938
939 long_name = strdup(path);
940 if (long_name == NULL)
941 return -ENOMEM;
942
943 dso__set_long_name(map->dso, long_name, true);
944 dso__kernel_module_get_build_id(map->dso, "");
945
946 /*
947 * Full name could reveal us kmod compression, so
948 * we need to update the symtab_type if needed.
949 */
950 if (m->comp && is_kmod_dso(map->dso))
951 map->dso->symtab_type++;
952
953 return 0;
954}
955
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300956static int map_groups__set_modules_path_dir(struct map_groups *mg,
Richard Yao61d42902014-04-26 13:17:55 -0400957 const char *dir_name, int depth)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300958{
959 struct dirent *dent;
960 DIR *dir = opendir(dir_name);
961 int ret = 0;
962
963 if (!dir) {
964 pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
965 return -1;
966 }
967
968 while ((dent = readdir(dir)) != NULL) {
969 char path[PATH_MAX];
970 struct stat st;
971
972 /*sshfs might return bad dent->d_type, so we have to stat*/
973 snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
974 if (stat(path, &st))
975 continue;
976
977 if (S_ISDIR(st.st_mode)) {
978 if (!strcmp(dent->d_name, ".") ||
979 !strcmp(dent->d_name, ".."))
980 continue;
981
Richard Yao61d42902014-04-26 13:17:55 -0400982 /* Do not follow top-level source and build symlinks */
983 if (depth == 0) {
984 if (!strcmp(dent->d_name, "source") ||
985 !strcmp(dent->d_name, "build"))
986 continue;
987 }
988
989 ret = map_groups__set_modules_path_dir(mg, path,
990 depth + 1);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300991 if (ret < 0)
992 goto out;
993 } else {
Jiri Olsabb58a8a2015-02-12 22:20:01 +0100994 struct kmod_path m;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300995
Jiri Olsabb58a8a2015-02-12 22:20:01 +0100996 ret = kmod_path__parse_name(&m, dent->d_name);
997 if (ret)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300998 goto out;
Jiri Olsabb58a8a2015-02-12 22:20:01 +0100999
1000 if (m.kmod)
1001 ret = map_groups__set_module_path(mg, path, &m);
1002
1003 free(m.name);
1004
1005 if (ret)
1006 goto out;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001007 }
1008 }
1009
1010out:
1011 closedir(dir);
1012 return ret;
1013}
1014
1015static int machine__set_modules_path(struct machine *machine)
1016{
1017 char *version;
1018 char modules_path[PATH_MAX];
1019
1020 version = get_kernel_version(machine->root_dir);
1021 if (!version)
1022 return -1;
1023
Richard Yao61d42902014-04-26 13:17:55 -04001024 snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s",
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001025 machine->root_dir, version);
1026 free(version);
1027
Richard Yao61d42902014-04-26 13:17:55 -04001028 return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001029}
1030
Adrian Hunter316d70d2013-10-08 11:45:48 +03001031static int machine__create_module(void *arg, const char *name, u64 start)
1032{
1033 struct machine *machine = arg;
1034 struct map *map;
1035
Arnaldo Carvalho de Melo9f2de312015-06-01 12:01:02 -03001036 map = machine__findnew_module_map(machine, start, name);
Adrian Hunter316d70d2013-10-08 11:45:48 +03001037 if (map == NULL)
1038 return -1;
1039
1040 dso__kernel_module_get_build_id(map->dso, machine->root_dir);
1041
1042 return 0;
1043}
1044
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001045static int machine__create_modules(struct machine *machine)
1046{
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001047 const char *modules;
1048 char path[PATH_MAX];
1049
Adrian Hunterf4be9042013-09-22 13:22:09 +03001050 if (machine__is_default_guest(machine)) {
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001051 modules = symbol_conf.default_guest_modules;
Adrian Hunterf4be9042013-09-22 13:22:09 +03001052 } else {
1053 snprintf(path, PATH_MAX, "%s/proc/modules", machine->root_dir);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001054 modules = path;
1055 }
1056
Adrian Hunteraa7fe3b2013-09-22 13:22:09 +03001057 if (symbol__restricted_filename(modules, "/proc/modules"))
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001058 return -1;
1059
Adrian Hunter316d70d2013-10-08 11:45:48 +03001060 if (modules__parse(modules, machine, machine__create_module))
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001061 return -1;
1062
Adrian Hunter316d70d2013-10-08 11:45:48 +03001063 if (!machine__set_modules_path(machine))
1064 return 0;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001065
Adrian Hunter316d70d2013-10-08 11:45:48 +03001066 pr_debug("Problems setting modules path maps, continuing anyway...\n");
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001067
Jason Wessel8f76fcd2013-07-15 15:27:53 -05001068 return 0;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001069}
1070
1071int machine__create_kernel_maps(struct machine *machine)
1072{
1073 struct dso *kernel = machine__get_kernel(machine);
Adrian Hunter5512cf22014-01-29 16:14:39 +02001074 const char *name;
Adrian Hunter4b993752014-08-15 22:08:38 +03001075 u64 addr = machine__get_running_kernel_start(machine, &name);
Adrian Hunter5512cf22014-01-29 16:14:39 +02001076 if (!addr)
1077 return -1;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001078
1079 if (kernel == NULL ||
1080 __machine__create_kernel_maps(machine, kernel) < 0)
1081 return -1;
1082
1083 if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
1084 if (machine__is_host(machine))
1085 pr_debug("Problems creating module maps, "
1086 "continuing anyway...\n");
1087 else
1088 pr_debug("Problems creating module maps for guest %d, "
1089 "continuing anyway...\n", machine->pid);
1090 }
1091
1092 /*
1093 * Now that we have all the maps created, just set the ->end of them:
1094 */
1095 map_groups__fixup_end(&machine->kmaps);
Adrian Hunter5512cf22014-01-29 16:14:39 +02001096
1097 if (maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps, name,
1098 addr)) {
1099 machine__destroy_kernel_maps(machine);
1100 return -1;
1101 }
1102
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001103 return 0;
1104}
1105
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001106static void machine__set_kernel_mmap_len(struct machine *machine,
1107 union perf_event *event)
1108{
Namhyung Kim4552cf0f2012-11-07 16:27:10 +09001109 int i;
1110
1111 for (i = 0; i < MAP__NR_TYPES; i++) {
1112 machine->vmlinux_maps[i]->start = event->mmap.start;
1113 machine->vmlinux_maps[i]->end = (event->mmap.start +
1114 event->mmap.len);
1115 /*
1116 * Be a bit paranoid here, some perf.data file came with
1117 * a zero sized synthesized MMAP event for the kernel.
1118 */
1119 if (machine->vmlinux_maps[i]->end == 0)
1120 machine->vmlinux_maps[i]->end = ~0ULL;
1121 }
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001122}
1123
Adrian Hunter8e0cf962013-08-07 14:38:51 +03001124static bool machine__uses_kcore(struct machine *machine)
1125{
1126 struct dso *dso;
1127
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -03001128 list_for_each_entry(dso, &machine->dsos.head, node) {
Adrian Hunter8e0cf962013-08-07 14:38:51 +03001129 if (dso__is_kcore(dso))
1130 return true;
1131 }
1132
1133 return false;
1134}
1135
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001136static int machine__process_kernel_mmap_event(struct machine *machine,
1137 union perf_event *event)
1138{
1139 struct map *map;
1140 char kmmap_prefix[PATH_MAX];
1141 enum dso_kernel_type kernel_type;
1142 bool is_kernel_mmap;
1143
Adrian Hunter8e0cf962013-08-07 14:38:51 +03001144 /* If we have maps from kcore then we do not need or want any others */
1145 if (machine__uses_kcore(machine))
1146 return 0;
1147
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001148 machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
1149 if (machine__is_host(machine))
1150 kernel_type = DSO_TYPE_KERNEL;
1151 else
1152 kernel_type = DSO_TYPE_GUEST_KERNEL;
1153
1154 is_kernel_mmap = memcmp(event->mmap.filename,
1155 kmmap_prefix,
1156 strlen(kmmap_prefix) - 1) == 0;
1157 if (event->mmap.filename[0] == '/' ||
1158 (!is_kernel_mmap && event->mmap.filename[0] == '[')) {
Arnaldo Carvalho de Melo9f2de312015-06-01 12:01:02 -03001159 map = machine__findnew_module_map(machine, event->mmap.start,
1160 event->mmap.filename);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001161 if (map == NULL)
1162 goto out_problem;
1163
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001164 map->end = map->start + event->mmap.len;
1165 } else if (is_kernel_mmap) {
1166 const char *symbol_name = (event->mmap.filename +
1167 strlen(kmmap_prefix));
1168 /*
1169 * Should be there already, from the build-id table in
1170 * the header.
1171 */
Namhyung Kimb837a8b2014-11-04 10:14:33 +09001172 struct dso *kernel = NULL;
1173 struct dso *dso;
1174
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -03001175 pthread_rwlock_rdlock(&machine->dsos.lock);
1176
Arnaldo Carvalho de Melo3d39ac52015-05-28 13:06:42 -03001177 list_for_each_entry(dso, &machine->dsos.head, node) {
Wang Nan1f121b02015-06-03 08:52:21 +00001178
1179 /*
1180 * The cpumode passed to is_kernel_module is not the
1181 * cpumode of *this* event. If we insist on passing
1182 * correct cpumode to is_kernel_module, we should
1183 * record the cpumode when we adding this dso to the
1184 * linked list.
1185 *
1186 * However we don't really need passing correct
1187 * cpumode. We know the correct cpumode must be kernel
1188 * mode (if not, we should not link it onto kernel_dsos
1189 * list).
1190 *
1191 * Therefore, we pass PERF_RECORD_MISC_CPUMODE_UNKNOWN.
1192 * is_kernel_module() treats it as a kernel cpumode.
1193 */
1194
1195 if (!dso->kernel ||
1196 is_kernel_module(dso->long_name,
1197 PERF_RECORD_MISC_CPUMODE_UNKNOWN))
Namhyung Kimb837a8b2014-11-04 10:14:33 +09001198 continue;
1199
Wang Nan1f121b02015-06-03 08:52:21 +00001200
Namhyung Kimb837a8b2014-11-04 10:14:33 +09001201 kernel = dso;
1202 break;
1203 }
1204
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -03001205 pthread_rwlock_unlock(&machine->dsos.lock);
1206
Namhyung Kimb837a8b2014-11-04 10:14:33 +09001207 if (kernel == NULL)
Arnaldo Carvalho de Meloaa7cc2a2015-05-29 11:31:12 -03001208 kernel = machine__findnew_dso(machine, kmmap_prefix);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001209 if (kernel == NULL)
1210 goto out_problem;
1211
1212 kernel->kernel = kernel_type;
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -03001213 if (__machine__create_kernel_maps(machine, kernel) < 0) {
1214 dso__put(kernel);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001215 goto out_problem;
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -03001216 }
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001217
Namhyung Kim330dfa22014-11-18 13:30:28 +09001218 if (strstr(kernel->long_name, "vmlinux"))
1219 dso__set_short_name(kernel, "[kernel.vmlinux]", false);
Namhyung Kim96d78052014-11-04 10:14:34 +09001220
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001221 machine__set_kernel_mmap_len(machine, event);
1222
1223 /*
1224 * Avoid using a zero address (kptr_restrict) for the ref reloc
1225 * symbol. Effectively having zero here means that at record
1226 * time /proc/sys/kernel/kptr_restrict was non zero.
1227 */
1228 if (event->mmap.pgoff != 0) {
1229 maps__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
1230 symbol_name,
1231 event->mmap.pgoff);
1232 }
1233
1234 if (machine__is_default_guest(machine)) {
1235 /*
1236 * preload dso of guest kernel and modules
1237 */
1238 dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
1239 NULL);
1240 }
1241 }
1242 return 0;
1243out_problem:
1244 return -1;
1245}
1246
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001247int machine__process_mmap2_event(struct machine *machine,
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001248 union perf_event *event,
1249 struct perf_sample *sample __maybe_unused)
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001250{
1251 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1252 struct thread *thread;
1253 struct map *map;
1254 enum map_type type;
1255 int ret = 0;
1256
1257 if (dump_trace)
1258 perf_event__fprintf_mmap2(event, stdout);
1259
1260 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
1261 cpumode == PERF_RECORD_MISC_KERNEL) {
1262 ret = machine__process_kernel_mmap_event(machine, event);
1263 if (ret < 0)
1264 goto out_problem;
1265 return 0;
1266 }
1267
1268 thread = machine__findnew_thread(machine, event->mmap2.pid,
Don Zickus11c9abf2014-02-26 10:45:27 -05001269 event->mmap2.tid);
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001270 if (thread == NULL)
1271 goto out_problem;
1272
1273 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1274 type = MAP__VARIABLE;
1275 else
1276 type = MAP__FUNCTION;
1277
Adrian Hunter2a030682014-07-22 16:17:53 +03001278 map = map__new(machine, event->mmap2.start,
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001279 event->mmap2.len, event->mmap2.pgoff,
1280 event->mmap2.pid, event->mmap2.maj,
1281 event->mmap2.min, event->mmap2.ino,
1282 event->mmap2.ino_generation,
Don Zickus7ef80702014-05-19 15:13:49 -04001283 event->mmap2.prot,
1284 event->mmap2.flags,
Adrian Hunter5835edd2014-07-22 16:18:00 +03001285 event->mmap2.filename, type, thread);
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001286
1287 if (map == NULL)
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001288 goto out_problem_map;
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001289
1290 thread__insert_map(thread, map);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001291 thread__put(thread);
Arnaldo Carvalho de Melo84c2caf2015-05-25 16:59:56 -03001292 map__put(map);
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001293 return 0;
1294
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001295out_problem_map:
1296 thread__put(thread);
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001297out_problem:
1298 dump_printf("problem processing PERF_RECORD_MMAP2, skipping event.\n");
1299 return 0;
1300}
1301
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001302int machine__process_mmap_event(struct machine *machine, union perf_event *event,
1303 struct perf_sample *sample __maybe_unused)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001304{
1305 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1306 struct thread *thread;
1307 struct map *map;
Stephane Eranianbad40912013-01-24 16:10:40 +01001308 enum map_type type;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001309 int ret = 0;
1310
1311 if (dump_trace)
1312 perf_event__fprintf_mmap(event, stdout);
1313
1314 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
1315 cpumode == PERF_RECORD_MISC_KERNEL) {
1316 ret = machine__process_kernel_mmap_event(machine, event);
1317 if (ret < 0)
1318 goto out_problem;
1319 return 0;
1320 }
1321
Adrian Hunter314add62013-08-27 11:23:03 +03001322 thread = machine__findnew_thread(machine, event->mmap.pid,
Don Zickus11c9abf2014-02-26 10:45:27 -05001323 event->mmap.tid);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001324 if (thread == NULL)
1325 goto out_problem;
Stephane Eranianbad40912013-01-24 16:10:40 +01001326
1327 if (event->header.misc & PERF_RECORD_MISC_MMAP_DATA)
1328 type = MAP__VARIABLE;
1329 else
1330 type = MAP__FUNCTION;
1331
Adrian Hunter2a030682014-07-22 16:17:53 +03001332 map = map__new(machine, event->mmap.start,
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001333 event->mmap.len, event->mmap.pgoff,
Don Zickus7ef80702014-05-19 15:13:49 -04001334 event->mmap.pid, 0, 0, 0, 0, 0, 0,
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001335 event->mmap.filename,
Adrian Hunter5835edd2014-07-22 16:18:00 +03001336 type, thread);
Stephane Eranianbad40912013-01-24 16:10:40 +01001337
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001338 if (map == NULL)
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001339 goto out_problem_map;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001340
1341 thread__insert_map(thread, map);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001342 thread__put(thread);
Arnaldo Carvalho de Melo84c2caf2015-05-25 16:59:56 -03001343 map__put(map);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001344 return 0;
1345
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001346out_problem_map:
1347 thread__put(thread);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001348out_problem:
1349 dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
1350 return 0;
1351}
1352
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001353static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock)
David Ahern236a3bb2013-08-14 08:49:27 -06001354{
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -03001355 if (machine->last_match == th)
Arnaldo Carvalho de Melo0ceb8f62015-05-11 18:08:12 -03001356 machine->last_match = NULL;
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -03001357
Arnaldo Carvalho de Melo59a51c12015-05-15 15:32:55 -03001358 BUG_ON(atomic_read(&th->refcnt) == 0);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001359 if (lock)
1360 pthread_rwlock_wrlock(&machine->threads_lock);
Arnaldo Carvalho de Melo0170b142015-05-25 15:23:05 -03001361 rb_erase_init(&th->rb_node, &machine->threads);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001362 RB_CLEAR_NODE(&th->rb_node);
David Ahern236a3bb2013-08-14 08:49:27 -06001363 /*
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -03001364 * Move it first to the dead_threads list, then drop the reference,
1365 * if this is the last reference, then the thread__delete destructor
1366 * will be called and we will remove it from the dead_threads list.
David Ahern236a3bb2013-08-14 08:49:27 -06001367 */
1368 list_add_tail(&th->node, &machine->dead_threads);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001369 if (lock)
1370 pthread_rwlock_unlock(&machine->threads_lock);
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -03001371 thread__put(th);
David Ahern236a3bb2013-08-14 08:49:27 -06001372}
1373
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001374void machine__remove_thread(struct machine *machine, struct thread *th)
1375{
1376 return __machine__remove_thread(machine, th, true);
1377}
1378
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001379int machine__process_fork_event(struct machine *machine, union perf_event *event,
1380 struct perf_sample *sample)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001381{
Jiri Olsad75e6092014-03-14 15:00:03 +01001382 struct thread *thread = machine__find_thread(machine,
1383 event->fork.pid,
1384 event->fork.tid);
Adrian Hunter314add62013-08-27 11:23:03 +03001385 struct thread *parent = machine__findnew_thread(machine,
1386 event->fork.ppid,
1387 event->fork.ptid);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001388 int err = 0;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001389
David Ahern236a3bb2013-08-14 08:49:27 -06001390 /* if a thread currently exists for the thread id remove it */
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001391 if (thread != NULL) {
David Ahern236a3bb2013-08-14 08:49:27 -06001392 machine__remove_thread(machine, thread);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001393 thread__put(thread);
1394 }
David Ahern236a3bb2013-08-14 08:49:27 -06001395
Adrian Hunter314add62013-08-27 11:23:03 +03001396 thread = machine__findnew_thread(machine, event->fork.pid,
1397 event->fork.tid);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001398 if (dump_trace)
1399 perf_event__fprintf_task(event, stdout);
1400
1401 if (thread == NULL || parent == NULL ||
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001402 thread__fork(thread, parent, sample->time) < 0) {
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001403 dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001404 err = -1;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001405 }
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001406 thread__put(thread);
1407 thread__put(parent);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001408
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001409 return err;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001410}
1411
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001412int machine__process_exit_event(struct machine *machine, union perf_event *event,
1413 struct perf_sample *sample __maybe_unused)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001414{
Jiri Olsad75e6092014-03-14 15:00:03 +01001415 struct thread *thread = machine__find_thread(machine,
1416 event->fork.pid,
1417 event->fork.tid);
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001418
1419 if (dump_trace)
1420 perf_event__fprintf_task(event, stdout);
1421
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001422 if (thread != NULL) {
David Ahern236a3bb2013-08-14 08:49:27 -06001423 thread__exited(thread);
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001424 thread__put(thread);
1425 }
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001426
1427 return 0;
1428}
1429
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001430int machine__process_event(struct machine *machine, union perf_event *event,
1431 struct perf_sample *sample)
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001432{
1433 int ret;
1434
1435 switch (event->header.type) {
1436 case PERF_RECORD_COMM:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001437 ret = machine__process_comm_event(machine, event, sample); break;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001438 case PERF_RECORD_MMAP:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001439 ret = machine__process_mmap_event(machine, event, sample); break;
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001440 case PERF_RECORD_MMAP2:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001441 ret = machine__process_mmap2_event(machine, event, sample); break;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001442 case PERF_RECORD_FORK:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001443 ret = machine__process_fork_event(machine, event, sample); break;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001444 case PERF_RECORD_EXIT:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001445 ret = machine__process_exit_event(machine, event, sample); break;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001446 case PERF_RECORD_LOST:
Frederic Weisbecker162f0be2013-09-11 16:18:24 +02001447 ret = machine__process_lost_event(machine, event, sample); break;
Adrian Hunter4a96f7a2015-04-30 17:37:29 +03001448 case PERF_RECORD_AUX:
1449 ret = machine__process_aux_event(machine, event); break;
Adrian Hunter0ad21f62015-04-30 17:37:30 +03001450 case PERF_RECORD_ITRACE_START:
Jiri Olsaceb92912015-06-29 13:27:45 +02001451 ret = machine__process_itrace_start_event(machine, event); break;
Kan Liangc4937a92015-05-10 15:13:15 -04001452 case PERF_RECORD_LOST_SAMPLES:
1453 ret = machine__process_lost_samples_event(machine, event, sample); break;
Arnaldo Carvalho de Melob0a7d1a2012-10-06 16:26:02 -03001454 default:
1455 ret = -1;
1456 break;
1457 }
1458
1459 return ret;
1460}
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001461
Greg Priceb21484f2012-12-06 21:48:05 -08001462static bool symbol__match_regex(struct symbol *sym, regex_t *regex)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001463{
Greg Priceb21484f2012-12-06 21:48:05 -08001464 if (sym->name && !regexec(regex, sym->name, 0, NULL, 0))
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001465 return 1;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001466 return 0;
1467}
1468
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001469static void ip__resolve_ams(struct thread *thread,
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001470 struct addr_map_symbol *ams,
1471 u64 ip)
1472{
1473 struct addr_location al;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001474
1475 memset(&al, 0, sizeof(al));
Arnaldo Carvalho de Melo52a3cb82014-03-11 16:16:49 -03001476 /*
1477 * We cannot use the header.misc hint to determine whether a
1478 * branch stack address is user, kernel, guest, hypervisor.
1479 * Branches may straddle the kernel/user/hypervisor boundaries.
1480 * Thus, we have to try consecutively until we find a match
1481 * or else, the symbol is unknown
1482 */
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001483 thread__find_cpumode_addr_location(thread, MAP__FUNCTION, ip, &al);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001484
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001485 ams->addr = ip;
1486 ams->al_addr = al.addr;
1487 ams->sym = al.sym;
1488 ams->map = al.map;
1489}
1490
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001491static void ip__resolve_data(struct thread *thread,
Stephane Eranian98a3b322013-01-24 16:10:35 +01001492 u8 m, struct addr_map_symbol *ams, u64 addr)
1493{
1494 struct addr_location al;
1495
1496 memset(&al, 0, sizeof(al));
1497
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001498 thread__find_addr_location(thread, m, MAP__VARIABLE, addr, &al);
Don Zickus06b2afc2014-08-20 23:25:11 -04001499 if (al.map == NULL) {
1500 /*
1501 * some shared data regions have execute bit set which puts
1502 * their mapping in the MAP__FUNCTION type array.
1503 * Check there as a fallback option before dropping the sample.
1504 */
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001505 thread__find_addr_location(thread, m, MAP__FUNCTION, addr, &al);
Don Zickus06b2afc2014-08-20 23:25:11 -04001506 }
1507
Stephane Eranian98a3b322013-01-24 16:10:35 +01001508 ams->addr = addr;
1509 ams->al_addr = al.addr;
1510 ams->sym = al.sym;
1511 ams->map = al.map;
1512}
1513
Arnaldo Carvalho de Meloe80faac2014-01-22 13:05:06 -03001514struct mem_info *sample__resolve_mem(struct perf_sample *sample,
1515 struct addr_location *al)
Stephane Eranian98a3b322013-01-24 16:10:35 +01001516{
1517 struct mem_info *mi = zalloc(sizeof(*mi));
1518
1519 if (!mi)
1520 return NULL;
1521
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001522 ip__resolve_ams(al->thread, &mi->iaddr, sample->ip);
1523 ip__resolve_data(al->thread, al->cpumode, &mi->daddr, sample->addr);
Stephane Eranian98a3b322013-01-24 16:10:35 +01001524 mi->data_src.val = sample->data_src;
1525
1526 return mi;
1527}
1528
Andi Kleen37592b82014-11-12 18:05:19 -08001529static int add_callchain_ip(struct thread *thread,
1530 struct symbol **parent,
1531 struct addr_location *root_al,
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001532 u8 *cpumode,
Andi Kleen37592b82014-11-12 18:05:19 -08001533 u64 ip)
1534{
1535 struct addr_location al;
1536
1537 al.filtered = 0;
1538 al.sym = NULL;
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001539 if (!cpumode) {
Andi Kleen8b7bad52014-11-12 18:05:20 -08001540 thread__find_cpumode_addr_location(thread, MAP__FUNCTION,
1541 ip, &al);
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001542 } else {
Kan Liang2e777842014-12-02 10:06:53 -05001543 if (ip >= PERF_CONTEXT_MAX) {
1544 switch (ip) {
1545 case PERF_CONTEXT_HV:
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001546 *cpumode = PERF_RECORD_MISC_HYPERVISOR;
Kan Liang2e777842014-12-02 10:06:53 -05001547 break;
1548 case PERF_CONTEXT_KERNEL:
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001549 *cpumode = PERF_RECORD_MISC_KERNEL;
Kan Liang2e777842014-12-02 10:06:53 -05001550 break;
1551 case PERF_CONTEXT_USER:
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001552 *cpumode = PERF_RECORD_MISC_USER;
Kan Liang2e777842014-12-02 10:06:53 -05001553 break;
1554 default:
1555 pr_debug("invalid callchain context: "
1556 "%"PRId64"\n", (s64) ip);
1557 /*
1558 * It seems the callchain is corrupted.
1559 * Discard all.
1560 */
1561 callchain_cursor_reset(&callchain_cursor);
1562 return 1;
1563 }
1564 return 0;
1565 }
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001566 thread__find_addr_location(thread, *cpumode, MAP__FUNCTION,
1567 ip, &al);
Kan Liang2e777842014-12-02 10:06:53 -05001568 }
1569
Andi Kleen37592b82014-11-12 18:05:19 -08001570 if (al.sym != NULL) {
1571 if (sort__has_parent && !*parent &&
1572 symbol__match_regex(al.sym, &parent_regex))
1573 *parent = al.sym;
1574 else if (have_ignore_callees && root_al &&
1575 symbol__match_regex(al.sym, &ignore_callees_regex)) {
1576 /* Treat this symbol as the root,
1577 forgetting its callees. */
1578 *root_al = al;
1579 callchain_cursor_reset(&callchain_cursor);
1580 }
1581 }
1582
Andi Kleen55501712014-11-12 18:05:21 -08001583 return callchain_cursor_append(&callchain_cursor, al.addr, al.map, al.sym);
Andi Kleen37592b82014-11-12 18:05:19 -08001584}
1585
Arnaldo Carvalho de Melo644f2df2014-01-22 13:15:36 -03001586struct branch_info *sample__resolve_bstack(struct perf_sample *sample,
1587 struct addr_location *al)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001588{
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001589 unsigned int i;
Arnaldo Carvalho de Melo644f2df2014-01-22 13:15:36 -03001590 const struct branch_stack *bs = sample->branch_stack;
1591 struct branch_info *bi = calloc(bs->nr, sizeof(struct branch_info));
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001592
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001593 if (!bi)
1594 return NULL;
1595
1596 for (i = 0; i < bs->nr; i++) {
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -03001597 ip__resolve_ams(al->thread, &bi[i].to, bs->entries[i].to);
1598 ip__resolve_ams(al->thread, &bi[i].from, bs->entries[i].from);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001599 bi[i].flags = bs->entries[i].flags;
1600 }
1601 return bi;
1602}
1603
Andi Kleen8b7bad52014-11-12 18:05:20 -08001604#define CHASHSZ 127
1605#define CHASHBITS 7
1606#define NO_ENTRY 0xff
1607
1608#define PERF_MAX_BRANCH_DEPTH 127
1609
1610/* Remove loops. */
1611static int remove_loops(struct branch_entry *l, int nr)
1612{
1613 int i, j, off;
1614 unsigned char chash[CHASHSZ];
1615
1616 memset(chash, NO_ENTRY, sizeof(chash));
1617
1618 BUG_ON(PERF_MAX_BRANCH_DEPTH > 255);
1619
1620 for (i = 0; i < nr; i++) {
1621 int h = hash_64(l[i].from, CHASHBITS) % CHASHSZ;
1622
1623 /* no collision handling for now */
1624 if (chash[h] == NO_ENTRY) {
1625 chash[h] = i;
1626 } else if (l[chash[h]].from == l[i].from) {
1627 bool is_loop = true;
1628 /* check if it is a real loop */
1629 off = 0;
1630 for (j = chash[h]; j < i && i + off < nr; j++, off++)
1631 if (l[j].from != l[i + off].from) {
1632 is_loop = false;
1633 break;
1634 }
1635 if (is_loop) {
1636 memmove(l + i, l + i + off,
1637 (nr - (i + off)) * sizeof(*l));
1638 nr -= off;
1639 }
1640 }
1641 }
1642 return nr;
1643}
1644
Kan Liang384b6052015-01-05 13:23:05 -05001645/*
1646 * Recolve LBR callstack chain sample
1647 * Return:
1648 * 1 on success get LBR callchain information
1649 * 0 no available LBR callchain information, should try fp
1650 * negative error code on other errors.
1651 */
1652static int resolve_lbr_callchain_sample(struct thread *thread,
1653 struct perf_sample *sample,
1654 struct symbol **parent,
1655 struct addr_location *root_al,
1656 int max_stack)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001657{
Kan Liang384b6052015-01-05 13:23:05 -05001658 struct ip_callchain *chain = sample->callchain;
1659 int chain_nr = min(max_stack, (int)chain->nr);
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001660 u8 cpumode = PERF_RECORD_MISC_USER;
Kan Liang384b6052015-01-05 13:23:05 -05001661 int i, j, err;
1662 u64 ip;
1663
1664 for (i = 0; i < chain_nr; i++) {
1665 if (chain->ips[i] == PERF_CONTEXT_USER)
1666 break;
1667 }
1668
1669 /* LBR only affects the user callchain */
1670 if (i != chain_nr) {
1671 struct branch_stack *lbr_stack = sample->branch_stack;
1672 int lbr_nr = lbr_stack->nr;
1673 /*
1674 * LBR callstack can only get user call chain.
1675 * The mix_chain_nr is kernel call chain
1676 * number plus LBR user call chain number.
1677 * i is kernel call chain number,
1678 * 1 is PERF_CONTEXT_USER,
1679 * lbr_nr + 1 is the user call chain number.
1680 * For details, please refer to the comments
1681 * in callchain__printf
1682 */
1683 int mix_chain_nr = i + 1 + lbr_nr + 1;
1684
1685 if (mix_chain_nr > PERF_MAX_STACK_DEPTH + PERF_MAX_BRANCH_DEPTH) {
1686 pr_warning("corrupted callchain. skipping...\n");
1687 return 0;
1688 }
1689
1690 for (j = 0; j < mix_chain_nr; j++) {
1691 if (callchain_param.order == ORDER_CALLEE) {
1692 if (j < i + 1)
1693 ip = chain->ips[j];
1694 else if (j > i + 1)
1695 ip = lbr_stack->entries[j - i - 2].from;
1696 else
1697 ip = lbr_stack->entries[0].to;
1698 } else {
1699 if (j < lbr_nr)
1700 ip = lbr_stack->entries[lbr_nr - j - 1].from;
1701 else if (j > lbr_nr)
1702 ip = chain->ips[i + 1 - (j - lbr_nr)];
1703 else
1704 ip = lbr_stack->entries[0].to;
1705 }
1706
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001707 err = add_callchain_ip(thread, parent, root_al, &cpumode, ip);
Kan Liang384b6052015-01-05 13:23:05 -05001708 if (err)
1709 return (err < 0) ? err : 0;
1710 }
1711 return 1;
1712 }
1713
1714 return 0;
1715}
1716
1717static int thread__resolve_callchain_sample(struct thread *thread,
1718 struct perf_evsel *evsel,
1719 struct perf_sample *sample,
1720 struct symbol **parent,
1721 struct addr_location *root_al,
1722 int max_stack)
1723{
1724 struct branch_stack *branch = sample->branch_stack;
1725 struct ip_callchain *chain = sample->callchain;
Waiman Long91e95612013-10-18 10:38:48 -04001726 int chain_nr = min(max_stack, (int)chain->nr);
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001727 u8 cpumode = PERF_RECORD_MISC_USER;
Kan Liang2e777842014-12-02 10:06:53 -05001728 int i, j, err;
Andi Kleen8b7bad52014-11-12 18:05:20 -08001729 int skip_idx = -1;
1730 int first_call = 0;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001731
Kan Liang384b6052015-01-05 13:23:05 -05001732 callchain_cursor_reset(&callchain_cursor);
1733
1734 if (has_branch_callstack(evsel)) {
1735 err = resolve_lbr_callchain_sample(thread, sample, parent,
1736 root_al, max_stack);
1737 if (err)
1738 return (err < 0) ? err : 0;
1739 }
1740
Sukadev Bhattiprolua60335b2014-06-25 08:49:03 -07001741 /*
1742 * Based on DWARF debug information, some architectures skip
1743 * a callchain entry saved by the kernel.
1744 */
Andi Kleen8b7bad52014-11-12 18:05:20 -08001745 if (chain->nr < PERF_MAX_STACK_DEPTH)
1746 skip_idx = arch_skip_callchain_idx(thread, chain);
Sukadev Bhattiprolua60335b2014-06-25 08:49:03 -07001747
Andi Kleen8b7bad52014-11-12 18:05:20 -08001748 /*
1749 * Add branches to call stack for easier browsing. This gives
1750 * more context for a sample than just the callers.
1751 *
1752 * This uses individual histograms of paths compared to the
1753 * aggregated histograms the normal LBR mode uses.
1754 *
1755 * Limitations for now:
1756 * - No extra filters
1757 * - No annotations (should annotate somehow)
1758 */
1759
1760 if (branch && callchain_param.branch_callstack) {
1761 int nr = min(max_stack, (int)branch->nr);
1762 struct branch_entry be[nr];
1763
1764 if (branch->nr > PERF_MAX_BRANCH_DEPTH) {
1765 pr_warning("corrupted branch chain. skipping...\n");
1766 goto check_calls;
1767 }
1768
1769 for (i = 0; i < nr; i++) {
1770 if (callchain_param.order == ORDER_CALLEE) {
1771 be[i] = branch->entries[i];
1772 /*
1773 * Check for overlap into the callchain.
1774 * The return address is one off compared to
1775 * the branch entry. To adjust for this
1776 * assume the calling instruction is not longer
1777 * than 8 bytes.
1778 */
1779 if (i == skip_idx ||
1780 chain->ips[first_call] >= PERF_CONTEXT_MAX)
1781 first_call++;
1782 else if (be[i].from < chain->ips[first_call] &&
1783 be[i].from >= chain->ips[first_call] - 8)
1784 first_call++;
1785 } else
1786 be[i] = branch->entries[branch->nr - i - 1];
1787 }
1788
1789 nr = remove_loops(be, nr);
1790
1791 for (i = 0; i < nr; i++) {
1792 err = add_callchain_ip(thread, parent, root_al,
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001793 NULL, be[i].to);
Andi Kleen8b7bad52014-11-12 18:05:20 -08001794 if (!err)
1795 err = add_callchain_ip(thread, parent, root_al,
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001796 NULL, be[i].from);
Andi Kleen8b7bad52014-11-12 18:05:20 -08001797 if (err == -EINVAL)
1798 break;
1799 if (err)
1800 return err;
1801 }
1802 chain_nr -= nr;
1803 }
1804
1805check_calls:
1806 if (chain->nr > PERF_MAX_STACK_DEPTH) {
1807 pr_warning("corrupted callchain. skipping...\n");
1808 return 0;
1809 }
1810
1811 for (i = first_call; i < chain_nr; i++) {
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001812 u64 ip;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001813
1814 if (callchain_param.order == ORDER_CALLEE)
Sukadev Bhattiprolua60335b2014-06-25 08:49:03 -07001815 j = i;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001816 else
Sukadev Bhattiprolua60335b2014-06-25 08:49:03 -07001817 j = chain->nr - i - 1;
1818
1819#ifdef HAVE_SKIP_CALLCHAIN_IDX
1820 if (j == skip_idx)
1821 continue;
1822#endif
1823 ip = chain->ips[j];
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001824
David Hildenbrand73dbcd62015-03-30 10:11:00 +02001825 err = add_callchain_ip(thread, parent, root_al, &cpumode, ip);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001826
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001827 if (err)
Kan Liang2e777842014-12-02 10:06:53 -05001828 return (err < 0) ? err : 0;
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001829 }
1830
1831 return 0;
1832}
1833
1834static int unwind_entry(struct unwind_entry *entry, void *arg)
1835{
1836 struct callchain_cursor *cursor = arg;
1837 return callchain_cursor_append(cursor, entry->ip,
1838 entry->map, entry->sym);
1839}
1840
Arnaldo Carvalho de Melocc8b7c22014-10-23 15:26:17 -03001841int thread__resolve_callchain(struct thread *thread,
1842 struct perf_evsel *evsel,
1843 struct perf_sample *sample,
1844 struct symbol **parent,
1845 struct addr_location *root_al,
1846 int max_stack)
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001847{
Kan Liang384b6052015-01-05 13:23:05 -05001848 int ret = thread__resolve_callchain_sample(thread, evsel,
1849 sample, parent,
1850 root_al, max_stack);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001851 if (ret)
1852 return ret;
1853
1854 /* Can we do dwarf post unwind? */
1855 if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
1856 (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
1857 return 0;
1858
1859 /* Bail out if nothing was captured. */
1860 if ((!sample->user_regs.regs) ||
1861 (!sample->user_stack.size))
1862 return 0;
1863
Arnaldo Carvalho de Melodd8c17a2014-10-23 16:42:19 -03001864 return unwind__get_entries(unwind_entry, &callchain_cursor,
Jiri Olsa352ea452014-01-07 13:47:25 +01001865 thread, sample, max_stack);
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -03001866
1867}
David Ahern35feee12013-09-28 13:12:58 -06001868
1869int machine__for_each_thread(struct machine *machine,
1870 int (*fn)(struct thread *thread, void *p),
1871 void *priv)
1872{
1873 struct rb_node *nd;
1874 struct thread *thread;
1875 int rc = 0;
1876
1877 for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
1878 thread = rb_entry(nd, struct thread, rb_node);
1879 rc = fn(thread, priv);
1880 if (rc != 0)
1881 return rc;
1882 }
1883
1884 list_for_each_entry(thread, &machine->dead_threads, node) {
1885 rc = fn(thread, priv);
1886 if (rc != 0)
1887 return rc;
1888 }
1889 return rc;
1890}
Arnaldo Carvalho de Melo58d925d2013-11-11 11:28:02 -03001891
Adrian Huntera5499b32015-05-29 16:33:30 +03001892int machines__for_each_thread(struct machines *machines,
1893 int (*fn)(struct thread *thread, void *p),
1894 void *priv)
1895{
1896 struct rb_node *nd;
1897 int rc = 0;
1898
1899 rc = machine__for_each_thread(&machines->host, fn, priv);
1900 if (rc != 0)
1901 return rc;
1902
1903 for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
1904 struct machine *machine = rb_entry(nd, struct machine, rb_node);
1905
1906 rc = machine__for_each_thread(machine, fn, priv);
1907 if (rc != 0)
1908 return rc;
1909 }
1910 return rc;
1911}
1912
Arnaldo Carvalho de Meloa33fbd52013-11-11 11:36:12 -03001913int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001914 struct target *target, struct thread_map *threads,
Kan Liang9d9cad72015-06-17 09:51:11 -04001915 perf_event__handler_t process, bool data_mmap,
1916 unsigned int proc_map_timeout)
Arnaldo Carvalho de Melo58d925d2013-11-11 11:28:02 -03001917{
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001918 if (target__has_task(target))
Kan Liang9d9cad72015-06-17 09:51:11 -04001919 return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap, proc_map_timeout);
Arnaldo Carvalho de Melo602ad872013-11-12 16:46:16 -03001920 else if (target__has_cpu(target))
Kan Liang9d9cad72015-06-17 09:51:11 -04001921 return perf_event__synthesize_threads(tool, process, machine, data_mmap, proc_map_timeout);
Arnaldo Carvalho de Melo58d925d2013-11-11 11:28:02 -03001922 /* command specified */
1923 return 0;
1924}
Adrian Hunterb9d266b2014-07-22 16:17:25 +03001925
1926pid_t machine__get_current_tid(struct machine *machine, int cpu)
1927{
1928 if (cpu < 0 || cpu >= MAX_NR_CPUS || !machine->current_tid)
1929 return -1;
1930
1931 return machine->current_tid[cpu];
1932}
1933
1934int machine__set_current_tid(struct machine *machine, int cpu, pid_t pid,
1935 pid_t tid)
1936{
1937 struct thread *thread;
1938
1939 if (cpu < 0)
1940 return -EINVAL;
1941
1942 if (!machine->current_tid) {
1943 int i;
1944
1945 machine->current_tid = calloc(MAX_NR_CPUS, sizeof(pid_t));
1946 if (!machine->current_tid)
1947 return -ENOMEM;
1948 for (i = 0; i < MAX_NR_CPUS; i++)
1949 machine->current_tid[i] = -1;
1950 }
1951
1952 if (cpu >= MAX_NR_CPUS) {
1953 pr_err("Requested CPU %d too large. ", cpu);
1954 pr_err("Consider raising MAX_NR_CPUS\n");
1955 return -EINVAL;
1956 }
1957
1958 machine->current_tid[cpu] = tid;
1959
1960 thread = machine__findnew_thread(machine, pid, tid);
1961 if (!thread)
1962 return -ENOMEM;
1963
1964 thread->cpu = cpu;
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -03001965 thread__put(thread);
Adrian Hunterb9d266b2014-07-22 16:17:25 +03001966
1967 return 0;
1968}
Adrian Hunterfbe2af42014-08-15 22:08:39 +03001969
1970int machine__get_kernel_start(struct machine *machine)
1971{
1972 struct map *map = machine__kernel_map(machine, MAP__FUNCTION);
1973 int err = 0;
1974
1975 /*
1976 * The only addresses above 2^63 are kernel addresses of a 64-bit
1977 * kernel. Note that addresses are unsigned so that on a 32-bit system
1978 * all addresses including kernel addresses are less than 2^32. In
1979 * that case (32-bit system), if the kernel mapping is unknown, all
1980 * addresses will be assumed to be in user space - see
1981 * machine__kernel_ip().
1982 */
1983 machine->kernel_start = 1ULL << 63;
1984 if (map) {
1985 err = map__load(map, machine->symbol_filter);
1986 if (map->start)
1987 machine->kernel_start = map->start;
1988 }
1989 return err;
1990}
Arnaldo Carvalho de Meloaa7cc2a2015-05-29 11:31:12 -03001991
1992struct dso *machine__findnew_dso(struct machine *machine, const char *filename)
1993{
Arnaldo Carvalho de Meloe8807842015-06-01 15:40:01 -03001994 return dsos__findnew(&machine->dsos, filename);
Arnaldo Carvalho de Meloaa7cc2a2015-05-29 11:31:12 -03001995}