1 files changed, 140 insertions, 122 deletions

diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 45efb5db0d1..2fde0d5e40b 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -2,174 +2,192 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include "session.h"
 #include "thread.h"
 #include "util.h"
 #include "debug.h"
+#include "comm.h"
 
-static struct thread *thread__new(pid_t pid)
+int thread__init_map_groups(struct thread *thread, struct machine *machine)
 {
-	struct thread *self = calloc(1, sizeof(*self));
-
-	if (self != NULL) {
-		self->pid = pid;
-		self->comm = malloc(32);
-		if (self->comm)
-			snprintf(self->comm, 32, ":%d", self->pid);
-		INIT_LIST_HEAD(&self->maps);
+	struct thread *leader;
+	pid_t pid = thread->pid_;
+
+	if (pid == thread->tid) {
+		thread->mg = map_groups__new();
+	} else {
+		leader = machine__findnew_thread(machine, pid, pid);
+		if (leader)
+			thread->mg = map_groups__get(leader->mg);
 	}
 
-	return self;
+	return thread->mg ? 0 : -1;
 }
 
-int thread__set_comm(struct thread *self, const char *comm)
+struct thread *thread__new(pid_t pid, pid_t tid)
 {
-	if (self->comm)
-		free(self->comm);
-	self->comm = strdup(comm);
-	return self->comm ? 0 : -ENOMEM;
+	char *comm_str;
+	struct comm *comm;
+	struct thread *thread = zalloc(sizeof(*thread));
+
+	if (thread != NULL) {
+		thread->pid_ = pid;
+		thread->tid = tid;
+		thread->ppid = -1;
+		INIT_LIST_HEAD(&thread->comm_list);
+
+		comm_str = malloc(32);
+		if (!comm_str)
+			goto err_thread;
+
+		snprintf(comm_str, 32, ":%d", tid);
+		comm = comm__new(comm_str, 0);
+		free(comm_str);
+		if (!comm)
+			goto err_thread;
+
+		list_add(&comm->list, &thread->comm_list);
+	}
+
+	return thread;
+
+err_thread:
+	free(thread);
+	return NULL;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+void thread__delete(struct thread *thread)
 {
-	struct map *pos;
-	size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
+	struct comm *comm, *tmp;
 
-	list_for_each_entry(pos, &self->maps, node)
-		ret += map__fprintf(pos, fp);
+	map_groups__put(thread->mg);
+	thread->mg = NULL;
+	list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) {
+		list_del(&comm->list);
+		comm__free(comm);
+	}
 
-	return ret;
+	free(thread);
 }
 
-struct thread *
-threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
+struct comm *thread__comm(const struct thread *thread)
 {
-	struct rb_node **p = &threads->rb_node;
-	struct rb_node *parent = NULL;
-	struct thread *th;
-
-	/*
-	 * Font-end cache - PID lookups come in blocks,
-	 * so most of the time we dont have to look up
-	 * the full rbtree:
-	 */
-	if (*last_match && (*last_match)->pid == pid)
-		return *last_match;
-
-	while (*p != NULL) {
-		parent = *p;
-		th = rb_entry(parent, struct thread, rb_node);
-
-		if (th->pid == pid) {
-			*last_match = th;
-			return th;
-		}
-
-		if (pid < th->pid)
-			p = &(*p)->rb_left;
-		else
-			p = &(*p)->rb_right;
-	}
+	if (list_empty(&thread->comm_list))
+		return NULL;
 
-	th = thread__new(pid);
-	if (th != NULL) {
-		rb_link_node(&th->rb_node, parent, p);
-		rb_insert_color(&th->rb_node, threads);
-		*last_match = th;
+	return list_first_entry(&thread->comm_list, struct comm, list);
+}
+
+/* CHECKME: time should always be 0 if event aren't ordered */
+int thread__set_comm(struct thread *thread, const char *str, u64 timestamp)
+{
+	struct comm *new, *curr = thread__comm(thread);
+	int err;
+
+	/* Override latest entry if it had no specific time coverage */
+	if (!curr->start) {
+		err = comm__override(curr, str, timestamp);
+		if (err)
+			return err;
+	} else {
+		new = comm__new(str, timestamp);
+		if (!new)
+			return -ENOMEM;
+		list_add(&new->list, &thread->comm_list);
 	}
 
-	return th;
+	thread->comm_set = true;
+
+	return 0;
 }
 
-struct thread *
-register_idle_thread(struct rb_root *threads, struct thread **last_match)
+const char *thread__comm_str(const struct thread *thread)
 {
-	struct thread *thread = threads__findnew(0, threads, last_match);
+	const struct comm *comm = thread__comm(thread);
 
-	if (!thread || thread__set_comm(thread, "swapper")) {
-		fprintf(stderr, "problem inserting idle task.\n");
-		exit(-1);
-	}
+	if (!comm)
+		return NULL;
 
-	return thread;
+	return comm__str(comm);
 }
 
-void thread__insert_map(struct thread *self, struct map *map)
+/* CHECKME: it should probably better return the max comm len from its comm list */
+int thread__comm_len(struct thread *thread)
 {
-	struct map *pos, *tmp;
-
-	list_for_each_entry_safe(pos, tmp, &self->maps, node) {
-		if (map__overlap(pos, map)) {
-			if (verbose >= 2) {
-				printf("overlapping maps:\n");
-				map__fprintf(map, stdout);
-				map__fprintf(pos, stdout);
-			}
-
-			if (map->start <= pos->start && map->end > pos->start)
-				pos->start = map->end;
-
-			if (map->end >= pos->end && map->start < pos->end)
-				pos->end = map->start;
-
-			if (verbose >= 2) {
-				printf("after collision:\n");
-				map__fprintf(pos, stdout);
-			}
-
-			if (pos->start >= pos->end) {
-				list_del_init(&pos->node);
-				free(pos);
-			}
-		}
+	if (!thread->comm_len) {
+		const char *comm = thread__comm_str(thread);
+		if (!comm)
+			return 0;
+		thread->comm_len = strlen(comm);
 	}
 
-	list_add_tail(&map->node, &self->maps);
+	return thread->comm_len;
 }
 
-int thread__fork(struct thread *self, struct thread *parent)
+size_t thread__fprintf(struct thread *thread, FILE *fp)
 {
-	struct map *map;
+	return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) +
+	       map_groups__fprintf(thread->mg, verbose, fp);
+}
 
-	if (self->comm)
-		free(self->comm);
-	self->comm = strdup(parent->comm);
-	if (!self->comm)
-		return -ENOMEM;
+void thread__insert_map(struct thread *thread, struct map *map)
+{
+	map_groups__fixup_overlappings(thread->mg, map, verbose, stderr);
+	map_groups__insert(thread->mg, map);
+}
 
-	list_for_each_entry(map, &parent->maps, node) {
-		struct map *new = map__clone(map);
-		if (!new)
+static int thread__clone_map_groups(struct thread *thread,
+				    struct thread *parent)
+{
+	int i;
+
+	/* This is new thread, we share map groups for process. */
+	if (thread->pid_ == parent->pid_)
+		return 0;
+
+	/* But this one is new process, copy maps. */
+	for (i = 0; i < MAP__NR_TYPES; ++i)
+		if (map_groups__clone(thread->mg, parent->mg, i) < 0)
 			return -ENOMEM;
-		thread__insert_map(self, new);
-	}
 
 	return 0;
 }
 
-struct map *thread__find_map(struct thread *self, u64 ip)
+int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
 {
-	struct map *pos;
+	int err;
 
-	if (self == NULL)
-		return NULL;
-
-	list_for_each_entry(pos, &self->maps, node)
-		if (ip >= pos->start && ip <= pos->end)
-			return pos;
+	if (parent->comm_set) {
+		const char *comm = thread__comm_str(parent);
+		if (!comm)
+			return -ENOMEM;
+		err = thread__set_comm(thread, comm, timestamp);
+		if (err)
+			return err;
+		thread->comm_set = true;
+	}
 
-	return NULL;
+	thread->ppid = parent->tid;
+	return thread__clone_map_groups(thread, parent);
 }
 
-size_t threads__fprintf(FILE *fp, struct rb_root *threads)
+void thread__find_cpumode_addr_location(struct thread *thread,
+					struct machine *machine,
+					enum map_type type, u64 addr,
+					struct addr_location *al)
 {
-	size_t ret = 0;
-	struct rb_node *nd;
-
-	for (nd = rb_first(threads); nd; nd = rb_next(nd)) {
-		struct thread *pos = rb_entry(nd, struct thread, rb_node);
-
-		ret += thread__fprintf(pos, fp);
+	size_t i;
+	const u8 const cpumodes[] = {
+		PERF_RECORD_MISC_USER,
+		PERF_RECORD_MISC_KERNEL,
+		PERF_RECORD_MISC_GUEST_USER,
+		PERF_RECORD_MISC_GUEST_KERNEL
+	};
+
+	for (i = 0; i < ARRAY_SIZE(cpumodes); i++) {
+		thread__find_addr_location(thread, machine, cpumodes[i], type,
+					   addr, al);
+		if (al->map)
+			break;
 	}
-
-	return ret;
 }