Release 4.10 tools/perf/util/machine.c

#include "callchain.h"
#include "debug.h"
#include "event.h"
#include "evsel.h"
#include "hist.h"
#include "machine.h"
#include "map.h"
#include "sort.h"
#include "strlist.h"
#include "thread.h"
#include "vdso.h"
#include <stdbool.h>
#include <symbol/kallsyms.h>
#include "unwind.h"
#include "linux/hash.h"

static void __machine__remove_thread(struct machine *machine, struct thread *th, bool lock);



static void dsos__init(struct dsos *dsos)
{
	INIT_LIST_HEAD(&dsos->head);
	dsos->root = RB_ROOT;
	pthread_rwlock_init(&dsos->lock, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
35
100.00%
2
100.00%
Total
35
100.00%
2
100.00%



int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
{
	memset(machine, 0, sizeof(*machine));
	map_groups__init(&machine->kmaps, machine);
	RB_CLEAR_NODE(&machine->rb_node);
	dsos__init(&machine->dsos);

	machine->threads = RB_ROOT;
	pthread_rwlock_init(&machine->threads_lock, NULL);
	machine->nr_threads = 0;
	INIT_LIST_HEAD(&machine->dead_threads);
	machine->last_match = NULL;

	machine->vdso_info = NULL;
	machine->env = NULL;

	machine->pid = pid;

	machine->id_hdr_size = 0;
	machine->kptr_restrict_warned = false;
	machine->comm_exec = false;
	machine->kernel_start = 0;

	memset(machine->vmlinux_maps, 0, sizeof(machine->vmlinux_maps));

	machine->root_dir = strdup(root_dir);
	if (machine->root_dir == NULL)
		return -ENOMEM;

	if (pid != HOST_KERNEL_ID) {
		struct thread *thread = machine__findnew_thread(machine, -1,
								pid);
		char comm[64];

		if (thread == NULL)
			return -ENOMEM;

		snprintf(comm, sizeof(comm), "[guest/%d]", pid);
		thread__set_comm(thread, comm, 0);
		thread__put(thread);
	}

	machine->current_tid = NULL;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
184
74.19%
8
44.44%
adrian hunter
adrian hunter
27
10.89%
6
33.33%
masami hiramatsu
masami hiramatsu
16
6.45%
1
5.56%
wang nan
wang nan
13
5.24%
1
5.56%
jiri olsa
jiri olsa
6
2.42%
1
5.56%
frederic weisbecker
frederic weisbecker
2
0.81%
1
5.56%
Total
248
100.00%
18
100.00%



struct machine *machine__new_host(void)
{
	struct machine *machine = malloc(sizeof(*machine));

	if (machine != NULL) {
		machine__init(machine, "", HOST_KERNEL_ID);

		if (machine__create_kernel_maps(machine) < 0)
			goto out_delete;
	}

	return machine;
out_delete:
	free(machine);
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
david ahern
david ahern
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%



static void dsos__purge(struct dsos *dsos)
{
	struct dso *pos, *n;

	pthread_rwlock_wrlock(&dsos->lock);

	list_for_each_entry_safe(pos, n, &dsos->head, node) {
		RB_CLEAR_NODE(&pos->rb_node);
		pos->root = NULL;
		list_del_init(&pos->node);
		dso__put(pos);
	}

	pthread_rwlock_unlock(&dsos->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
58
78.38%
3
50.00%
waiman long
waiman long
10
13.51%
2
33.33%
adrian hunter
adrian hunter
6
8.11%
1
16.67%
Total
74
100.00%
6
100.00%



static void dsos__exit(struct dsos *dsos)
{
	dsos__purge(dsos);
	pthread_rwlock_destroy(&dsos->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
24
100.00%
3
100.00%
Total
24
100.00%
3
100.00%



void machine__delete_threads(struct machine *machine)
{
	struct rb_node *nd;

	pthread_rwlock_wrlock(&machine->threads_lock);
	nd = rb_first(&machine->threads);
	while (nd) {
		struct thread *t = rb_entry(nd, struct thread, rb_node);

		nd = rb_next(nd);
		__machine__remove_thread(machine, t, false);
	}
	pthread_rwlock_unlock(&machine->threads_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
78
100.00%
3
100.00%
Total
78
100.00%
3
100.00%



void machine__exit(struct machine *machine)
{
	machine__destroy_kernel_maps(machine);
	map_groups__exit(&machine->kmaps);
	dsos__exit(&machine->dsos);
	machine__exit_vdso(machine);
	zfree(&machine->root_dir);
	zfree(&machine->current_tid);
	pthread_rwlock_destroy(&machine->threads_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
43
71.67%
6
66.67%
adrian hunter
adrian hunter
12
20.00%
2
22.22%
masami hiramatsu
masami hiramatsu
5
8.33%
1
11.11%
Total
60
100.00%
9
100.00%



void machine__delete(struct machine *machine)
{
	if (machine) {
		machine__exit(machine);
		free(machine);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
26
100.00%
2
100.00%
Total
26
100.00%
2
100.00%



void machines__init(struct machines *machines)
{
	machine__init(&machines->host, "", HOST_KERNEL_ID);
	machines->guests = RB_ROOT;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
28
100.00%
1
100.00%
Total
28
100.00%
1
100.00%



void machines__exit(struct machines *machines)
{
	machine__exit(&machines->host);
	/* XXX exit guest */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
19
100.00%
1
100.00%
Total
19
100.00%
1
100.00%



struct machine *machines__add(struct machines *machines, pid_t pid,
			      const char *root_dir)
{
	struct rb_node **p = &machines->guests.rb_node;
	struct rb_node *parent = NULL;
	struct machine *pos, *machine = malloc(sizeof(*machine));

	if (machine == NULL)
		return NULL;

	if (machine__init(machine, root_dir, pid) != 0) {
		free(machine);
		return NULL;
	}

	while (*p != NULL) {
		parent = *p;
		pos = rb_entry(parent, struct machine, rb_node);
		if (pid < pos->pid)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	rb_link_node(&machine->rb_node, parent, p);
	rb_insert_color(&machine->rb_node, &machines->guests);

	return machine;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
172
100.00%
2
100.00%
Total
172
100.00%
2
100.00%



void machines__set_comm_exec(struct machines *machines, bool comm_exec)
{
	struct rb_node *nd;

	machines->host.comm_exec = comm_exec;

	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
		struct machine *machine = rb_entry(nd, struct machine, rb_node);

		machine->comm_exec = comm_exec;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
70
100.00%
1
100.00%
Total
70
100.00%
1
100.00%



struct machine *machines__find(struct machines *machines, pid_t pid)
{
	struct rb_node **p = &machines->guests.rb_node;
	struct rb_node *parent = NULL;
	struct machine *machine;
	struct machine *default_machine = NULL;

	if (pid == HOST_KERNEL_ID)
		return &machines->host;

	while (*p != NULL) {
		parent = *p;
		machine = rb_entry(parent, struct machine, rb_node);
		if (pid < machine->pid)
			p = &(*p)->rb_left;
		else if (pid > machine->pid)
			p = &(*p)->rb_right;
		else
			return machine;
		if (!machine->pid)
			default_machine = machine;
	}

	return default_machine;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
140
100.00%
2
100.00%
Total
140
100.00%
2
100.00%



struct machine *machines__findnew(struct machines *machines, pid_t pid)
{
	char path[PATH_MAX];
	const char *root_dir = "";
	struct machine *machine = machines__find(machines, pid);

	if (machine && (machine->pid == pid))
		goto out;

	if ((pid != HOST_KERNEL_ID) &&
	    (pid != DEFAULT_GUEST_KERNEL_ID) &&
	    (symbol_conf.guestmount)) {
		sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
		if (access(path, R_OK)) {
			static struct strlist *seen;

			if (!seen)
				seen = strlist__new(NULL, NULL);

			if (!strlist__has_entry(seen, path)) {
				pr_err("Can't access file %s\n", path);
				strlist__add(seen, path);
			}
			machine = NULL;
			goto out;
		}
		root_dir = path;
	}

	machine = machines__add(machines, pid, root_dir);
out:
	return machine;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
174
100.00%
3
100.00%
Total
174
100.00%
3
100.00%



void machines__process_guests(struct machines *machines,
			      machine__process_t process, void *data)
{
	struct rb_node *nd;

	for (nd = rb_first(&machines->guests); nd; nd = rb_next(nd)) {
		struct machine *pos = rb_entry(nd, struct machine, rb_node);
		process(pos, data);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
67
100.00%
2
100.00%
Total
67
100.00%
2
100.00%



char *machine__mmap_name(struct machine *machine, char *bf, size_t size)
{
	if (machine__is_host(machine))
		snprintf(bf, size, "[%s]", "kernel.kallsyms");
	else if (machine__is_default_guest(machine))
		snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
	else {
		snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms",
			 machine->pid);
	}

	return bf;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
76
100.00%
1
100.00%
Total
76
100.00%
1
100.00%



void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
{
	struct rb_node *node;
	struct machine *machine;

	machines->host.id_hdr_size = id_hdr_size;

	for (node = rb_first(&machines->guests); node; node = rb_next(node)) {
		machine = rb_entry(node, struct machine, rb_node);
		machine->id_hdr_size = id_hdr_size;
	}

	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
73
100.00%
2
100.00%
Total
73
100.00%
2
100.00%



static void machine__update_thread_pid(struct machine *machine,
				       struct thread *th, pid_t pid)
{
	struct thread *leader;

	if (pid == th->pid_ || pid == -1 || th->pid_ != -1)
		return;

	th->pid_ = pid;

	if (th->pid_ == th->tid)
		return;

	leader = __machine__findnew_thread(machine, th->pid_, th->pid_);
	if (!leader)
		goto out_err;

	if (!leader->mg)
		leader->mg = map_groups__new(machine);

	if (!leader->mg)
		goto out_err;

	if (th->mg == leader->mg)
		return;

	if (th->mg) {
		/*
                 * Maps are created from MMAP events which provide the pid and
                 * tid.  Consequently there never should be any maps on a thread
                 * with an unknown pid.  Just print an error if there are.
                 */
		if (!map_groups__empty(th->mg))
			pr_err("Discarding thread maps for %d:%d\n",
			       th->pid_, th->tid);
		map_groups__put(th->mg);
	}

	th->mg = map_groups__get(leader->mg);
out_put:
	thread__put(leader);
	return;
out_err:
	pr_err("Failed to join map groups for %d:%d\n", th->pid_, th->tid);
	goto out_put;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
183
92.42%
1
20.00%
arnaldo carvalho de melo
arnaldo carvalho de melo
15
7.58%
4
80.00%
Total
198
100.00%
5
100.00%

/*
 * Caller must eventually drop thread->refcnt returned with a successful
 * lookup/new thread inserted.
 */


static struct thread *____machine__findnew_thread(struct machine *machine,
						  pid_t pid, pid_t tid,
						  bool create)
{
	struct rb_node **p = &machine->threads.rb_node;
	struct rb_node *parent = NULL;
	struct thread *th;

	/*
         * Front-end cache - TID lookups come in blocks,
         * so most of the time we dont have to look up
         * the full rbtree:
         */
	th = machine->last_match;
	if (th != NULL) {
		if (th->tid == tid) {
			machine__update_thread_pid(machine, th, pid);
			return thread__get(th);
		}

		machine->last_match = NULL;
	}

	while (*p != NULL) {
		parent = *p;
		th = rb_entry(parent, struct thread, rb_node);

		if (th->tid == tid) {
			machine->last_match = th;
			machine__update_thread_pid(machine, th, pid);
			return thread__get(th);
		}

		if (tid < th->tid)
			p = &(*p)->rb_left;
		else
			p = &(*p)->rb_right;
	}

	if (!create)
		return NULL;

	th = thread__new(pid, tid);
	if (th != NULL) {
		rb_link_node(&th->rb_node, parent, p);
		rb_insert_color(&th->rb_node, &machine->threads);

		/*
                 * We have to initialize map_groups separately
                 * after rb tree is updated.
                 *
                 * The reason is that we call machine__findnew_thread
                 * within thread__init_map_groups to find the thread
                 * leader and that would screwed the rb tree.
                 */
		if (thread__init_map_groups(th, machine)) {
			rb_erase_init(&th->rb_node, &machine->threads);
			RB_CLEAR_NODE(&th->rb_node);
			thread__put(th);
			return NULL;
		}
		/*
                 * It is now in the rbtree, get a ref
                 */
		thread__get(th);
		machine->last_match = th;
		++machine->nr_threads;
	}

	return th;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
211
72.76%
7
53.85%
adrian hunter
adrian hunter
48
16.55%
4
30.77%
namhyung kim
namhyung kim
18
6.21%
1
7.69%
jiri olsa
jiri olsa
13
4.48%
1
7.69%
Total
290
100.00%
13
100.00%



struct thread *__machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid)
{
	return ____machine__findnew_thread(machine, pid, tid, true);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
23
76.67%
2
40.00%
adrian hunter
adrian hunter
7
23.33%
3
60.00%
Total
30
100.00%
5
100.00%



struct thread *machine__findnew_thread(struct machine *machine, pid_t pid,
				       pid_t tid)
{
	struct thread *th;

	pthread_rwlock_wrlock(&machine->threads_lock);
	th = __machine__findnew_thread(machine, pid, tid);
	pthread_rwlock_unlock(&machine->threads_lock);
	return th;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
53
100.00%
1
100.00%
Total
53
100.00%
1
100.00%



struct thread *machine__find_thread(struct machine *machine, pid_t pid,
				    pid_t tid)
{
	struct thread *th;
	pthread_rwlock_rdlock(&machine->threads_lock);
	th =  ____machine__findnew_thread(machine, pid, tid, false);
	pthread_rwlock_unlock(&machine->threads_lock);
	return th;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
48
87.27%
2
40.00%
jiri olsa
jiri olsa
4
7.27%
1
20.00%
adrian hunter
adrian hunter
3
5.45%
2
40.00%
Total
55
100.00%
5
100.00%



struct comm *machine__thread_exec_comm(struct machine *machine,
				       struct thread *thread)
{
	if (machine->comm_exec)
		return thread__exec_comm(thread);
	else
		return thread__comm(thread);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%



int machine__process_comm_event(struct machine *machine, union perf_event *event,
				struct perf_sample *sample)
{
	struct thread *thread = machine__findnew_thread(machine,
							event->comm.pid,
							event->comm.tid);
	bool exec = event->header.misc & PERF_RECORD_MISC_COMM_EXEC;
	int err = 0;

	if (exec)
		machine->comm_exec = true;

	if (dump_trace)
		perf_event__fprintf_comm(event, stdout);

	if (thread == NULL ||
	    __thread__set_comm(thread, event->comm.comm, sample->time, exec)) {
		dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
		err = -1;
	}

	thread__put(thread);

	return err;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
83
68.03%
2
33.33%
adrian hunter
adrian hunter
30
24.59%
3
50.00%
frederic weisbecker
frederic weisbecker
9
7.38%
1
16.67%
Total
122
100.00%
6
100.00%



int machine__process_lost_event(struct machine *machine __maybe_unused,
				union perf_event *event, struct perf_sample *sample __maybe_unused)
{
	dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
		    event->lost.id, event->lost.lost);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
40
86.96%
1
50.00%
frederic weisbecker
frederic weisbecker
6
13.04%
1
50.00%
Total
46
100.00%
2
100.00%



int machine__process_lost_samples_event(struct machine *machine __maybe_unused,
					union perf_event *event, struct perf_sample *sample)
{
	dump_printf(": id:%" PRIu64 ": lost samples :%" PRIu64 "\n",
		    sample->id, event->lost_samples.lost);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
kan liang
kan liang
43
100.00%
1
100.00%
Total
43
100.00%
1
100.00%



static struct dso *machine__findnew_module_dso(struct machine *machine,
					       struct kmod_path *m,
					       const char *filename)
{
	struct dso *dso;

	pthread_rwlock_wrlock(&machine->dsos.lock);

	dso = __dsos__find(&machine->dsos, m->name, true);
	if (!dso) {
		dso = __dsos__addnew(&machine->dsos, m->name);
		if (dso == NULL)
			goto out_unlock;

		if (machine__is_host(machine))
			dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
		else
			dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;

		/* _KMODULE_COMP should be next to _KMODULE */
		if (m->kmod && m->comp)
			dso->symtab_type++;

		dso__set_short_name(dso, strdup(m->name), true);
		dso__set_long_name(dso, strdup(filename), true);
	}

	dso__get(dso);
out_unlock:
	pthread_rwlock_unlock(&machine->dsos.lock);
	return dso;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
arnaldo carvalho de melo
arnaldo carvalho de melo
93
56.02%
6
66.67%
jiri olsa
jiri olsa
63
37.95%
2
22.22%
namhyung kim
namhyung kim
10
6.02%
1
11.11%
Total
166
100.00%
9
100.00%



int machine__process_aux_event(struct machine *machine __maybe_unused,
			       union perf_event *event)
{
	if (dump_trace)
		perf_event__fprintf_aux(event, stdout);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%



int machine__process_itrace_start_event(struct machine *machine __maybe_unused,
					union perf_event *event)
{
	if (dump_trace)
		perf_event__fprintf_itrace_start(event, stdout);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%



int machine__process_switch_event(struct machine *machine __maybe_unused,
				  union perf_event *event)
{
	if (dump_trace)
		perf_event__fprintf_switch(event, stdout);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
adrian hunter
adrian hunter
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%



static void dso__adjust_kmod_long_name(struct dso *dso, const char *filename)
{
	const char *dup_filename;

	if (!filename || !dso || !dso->long_name)
		return;
	if (dso->long_name[0] != '[')
		return;
	if (!strchr(filename, '/'))
		return;

	dup_filename = strdup(filename);
	if (!dup_filename)
		return;

	dso__set_long_name(dso, dup_filename, true);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
wang nan
wang nan
80
100.00%
2
100.00%
Total
80
100.00%
2
100.00%



struct map *machine__findnew_module_map(struct machine *machine, u64 start,
					const char *filename)
{
	struct map *map = NULL;
	struct dso *dso = NULL;
	struct kmod_path m;

	if (kmod_path__parse_name(&m, filename))
		return NULL;

	map = map_groups__find_by_name(&machine->kmaps, MAP__FUNCTION,
				       m.name);
	if (map) {
		/*
                 * If the map's dso is an offline module, give dso__load()
                 * a chance to find the file path of that module by fixing
                 * long_name.
                 */
		dso__adjust_kmod_long_name(map->dso, filename);
		goto out;
	}

	dso = machine__findnew_module_dso(machine, &m, filename);
	if (dso == NULL)
		goto out;

	map = map__new2(start, dso, MAP__FUNCTION);
	if (map == NULL