blob: a5dbba95107ff3919e4a57495c7bcb1fafb77966 [file] [log] [blame]
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +02001#include "../perf.h"
2#include <stdlib.h>
3#include <stdio.h>
4#include <string.h>
Arnaldo Carvalho de Melob3165f42009-12-13 19:50:28 -02005#include "session.h"
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +02006#include "thread.h"
Adrian Hunter00447cc2014-10-30 16:09:42 +02007#include "thread-stack.h"
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +02008#include "util.h"
Frederic Weisbecker6e086432009-08-18 17:04:03 +02009#include "debug.h"
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020010#include "comm.h"
Namhyung Kim66f066d82014-10-06 09:46:00 +090011#include "unwind.h"
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +020012
Jiri Olsacddcef62014-04-09 20:54:29 +020013int thread__init_map_groups(struct thread *thread, struct machine *machine)
14{
15 struct thread *leader;
16 pid_t pid = thread->pid_;
17
Adrian Hunter1fcb8762014-07-14 13:02:25 +030018 if (pid == thread->tid || pid == -1) {
Arnaldo Carvalho de Melo11246c72014-10-21 17:29:02 -030019 thread->mg = map_groups__new(machine);
Jiri Olsacddcef62014-04-09 20:54:29 +020020 } else {
21 leader = machine__findnew_thread(machine, pid, pid);
22 if (leader)
23 thread->mg = map_groups__get(leader->mg);
24 }
25
26 return thread->mg ? 0 : -1;
27}
28
Adrian Hunter99d725f2013-08-26 16:00:19 +030029struct thread *thread__new(pid_t pid, pid_t tid)
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +020030{
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020031 char *comm_str;
32 struct comm *comm;
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030033 struct thread *thread = zalloc(sizeof(*thread));
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +020034
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030035 if (thread != NULL) {
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030036 thread->pid_ = pid;
37 thread->tid = tid;
38 thread->ppid = -1;
Adrian Hunterbf49c352014-07-22 16:17:24 +030039 thread->cpu = -1;
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020040 INIT_LIST_HEAD(&thread->comm_list);
41
Namhyung Kim66f066d82014-10-06 09:46:00 +090042 if (unwind__prepare_access(thread) < 0)
43 goto err_thread;
44
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020045 comm_str = malloc(32);
46 if (!comm_str)
47 goto err_thread;
48
49 snprintf(comm_str, 32, ":%d", tid);
Adrian Hunter65de51f2014-07-31 09:00:44 +030050 comm = comm__new(comm_str, 0, false);
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020051 free(comm_str);
52 if (!comm)
53 goto err_thread;
54
55 list_add(&comm->list, &thread->comm_list);
Namhyung Kim66f066d82014-10-06 09:46:00 +090056
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +020057 }
58
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030059 return thread;
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020060
61err_thread:
62 free(thread);
63 return NULL;
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +020064}
65
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030066void thread__delete(struct thread *thread)
Arnaldo Carvalho de Melo591765f2010-07-30 18:28:42 -030067{
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020068 struct comm *comm, *tmp;
69
Adrian Hunter00447cc2014-10-30 16:09:42 +020070 thread_stack__free(thread);
71
Adrian Hunter9608b842014-07-16 10:19:43 +030072 if (thread->mg) {
73 map_groups__put(thread->mg);
74 thread->mg = NULL;
75 }
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020076 list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) {
77 list_del(&comm->list);
78 comm__free(comm);
79 }
Namhyung Kim66f066d82014-10-06 09:46:00 +090080 unwind__finish_access(thread);
Frederic Weisbecker1902efe2013-09-11 16:56:44 +020081
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -030082 free(thread);
Arnaldo Carvalho de Melo591765f2010-07-30 18:28:42 -030083}
84
Arnaldo Carvalho de Melof3b623b2015-03-02 22:21:35 -030085struct thread *thread__get(struct thread *thread)
86{
87 ++thread->refcnt;
88 return thread;
89}
90
91void thread__put(struct thread *thread)
92{
93 if (thread && --thread->refcnt == 0) {
94 list_del_init(&thread->node);
95 thread__delete(thread);
96 }
97}
98
Namhyung Kim4dfced32013-09-13 16:28:57 +090099struct comm *thread__comm(const struct thread *thread)
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200100{
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200101 if (list_empty(&thread->comm_list))
102 return NULL;
David S. Miller4385d582010-02-26 12:08:34 -0300103
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200104 return list_first_entry(&thread->comm_list, struct comm, list);
105}
106
Adrian Hunter65de51f2014-07-31 09:00:44 +0300107struct comm *thread__exec_comm(const struct thread *thread)
108{
109 struct comm *comm, *last = NULL;
110
111 list_for_each_entry(comm, &thread->comm_list, list) {
112 if (comm->exec)
113 return comm;
114 last = comm;
115 }
116
117 return last;
118}
119
Adrian Hunter65de51f2014-07-31 09:00:44 +0300120int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
121 bool exec)
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200122{
123 struct comm *new, *curr = thread__comm(thread);
Frederic Weisbecker3178f582014-01-14 16:37:14 +0100124 int err;
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200125
Adrian Huntera8480802014-11-11 16:16:41 +0200126 /* Override the default :tid entry */
127 if (!thread->comm_set) {
Adrian Hunter65de51f2014-07-31 09:00:44 +0300128 err = comm__override(curr, str, timestamp, exec);
Frederic Weisbecker3178f582014-01-14 16:37:14 +0100129 if (err)
130 return err;
Frederic Weisbeckera5285ad2013-11-16 02:02:09 +0100131 } else {
Adrian Hunter65de51f2014-07-31 09:00:44 +0300132 new = comm__new(str, timestamp, exec);
Frederic Weisbeckera5285ad2013-11-16 02:02:09 +0100133 if (!new)
134 return -ENOMEM;
135 list_add(&new->list, &thread->comm_list);
Namhyung Kim380b5142014-10-06 09:46:01 +0900136
137 if (exec)
138 unwind__flush_access(thread);
David S. Miller4385d582010-02-26 12:08:34 -0300139 }
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200140
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200141 thread->comm_set = true;
142
143 return 0;
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200144}
145
Frederic Weisbeckerb9c51432013-09-11 14:46:56 +0200146const char *thread__comm_str(const struct thread *thread)
147{
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200148 const struct comm *comm = thread__comm(thread);
149
150 if (!comm)
151 return NULL;
152
153 return comm__str(comm);
Frederic Weisbeckerb9c51432013-09-11 14:46:56 +0200154}
155
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200156/* CHECKME: it should probably better return the max comm len from its comm list */
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300157int thread__comm_len(struct thread *thread)
Frederic Weisbeckera4fb5812009-10-22 23:23:23 +0200158{
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300159 if (!thread->comm_len) {
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200160 const char *comm = thread__comm_str(thread);
161 if (!comm)
Frederic Weisbeckera4fb5812009-10-22 23:23:23 +0200162 return 0;
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200163 thread->comm_len = strlen(comm);
Frederic Weisbeckera4fb5812009-10-22 23:23:23 +0200164 }
165
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300166 return thread->comm_len;
Frederic Weisbeckera4fb5812009-10-22 23:23:23 +0200167}
168
Arnaldo Carvalho de Melo3f067dc2012-12-07 17:39:39 -0300169size_t thread__fprintf(struct thread *thread, FILE *fp)
Arnaldo Carvalho de Melo95011c62009-11-27 16:29:20 -0200170{
Frederic Weisbeckerb9c51432013-09-11 14:46:56 +0200171 return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) +
Jiri Olsaacebd402014-07-14 23:46:47 +0200172 map_groups__fprintf(thread->mg, fp);
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200173}
174
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300175void thread__insert_map(struct thread *thread, struct map *map)
Arnaldo Carvalho de Melo1b46cdd2009-09-28 14:48:46 -0300176{
Jiri Olsaacebd402014-07-14 23:46:47 +0200177 map_groups__fixup_overlappings(thread->mg, map, stderr);
Arnaldo Carvalho de Melo93d57312014-03-21 17:57:01 -0300178 map_groups__insert(thread->mg, map);
Arnaldo Carvalho de Melo95011c62009-11-27 16:29:20 -0200179}
180
Jiri Olsacddcef62014-04-09 20:54:29 +0200181static int thread__clone_map_groups(struct thread *thread,
182 struct thread *parent)
183{
184 int i;
185
186 /* This is new thread, we share map groups for process. */
187 if (thread->pid_ == parent->pid_)
188 return 0;
189
190 /* But this one is new process, copy maps. */
191 for (i = 0; i < MAP__NR_TYPES; ++i)
192 if (map_groups__clone(thread->mg, parent->mg, i) < 0)
193 return -ENOMEM;
194
195 return 0;
196}
197
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200198int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200199{
Jiri Olsacddcef62014-04-09 20:54:29 +0200200 int err;
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200201
Arnaldo Carvalho de Melofaa5c5c2010-02-19 23:02:07 -0200202 if (parent->comm_set) {
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200203 const char *comm = thread__comm_str(parent);
204 if (!comm)
Arnaldo Carvalho de Melofaa5c5c2010-02-19 23:02:07 -0200205 return -ENOMEM;
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200206 err = thread__set_comm(thread, comm, timestamp);
David Ahern8d00be82013-12-10 21:35:38 -0700207 if (err)
Frederic Weisbecker1902efe2013-09-11 16:56:44 +0200208 return err;
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300209 thread->comm_set = true;
Arnaldo Carvalho de Melofaa5c5c2010-02-19 23:02:07 -0200210 }
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200211
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300212 thread->ppid = parent->tid;
Jiri Olsacddcef62014-04-09 20:54:29 +0200213 return thread__clone_map_groups(thread, parent);
Frederic Weisbecker6baa0a52009-08-14 12:21:53 +0200214}
Arnaldo Carvalho de Melo52a3cb82014-03-11 16:16:49 -0300215
216void thread__find_cpumode_addr_location(struct thread *thread,
Arnaldo Carvalho de Melo52a3cb82014-03-11 16:16:49 -0300217 enum map_type type, u64 addr,
218 struct addr_location *al)
219{
220 size_t i;
221 const u8 const cpumodes[] = {
222 PERF_RECORD_MISC_USER,
223 PERF_RECORD_MISC_KERNEL,
224 PERF_RECORD_MISC_GUEST_USER,
225 PERF_RECORD_MISC_GUEST_KERNEL
226 };
227
228 for (i = 0; i < ARRAY_SIZE(cpumodes); i++) {
Arnaldo Carvalho de Melobb871a92014-10-23 12:50:25 -0300229 thread__find_addr_location(thread, cpumodes[i], type, addr, al);
Arnaldo Carvalho de Melo52a3cb82014-03-11 16:16:49 -0300230 if (al->map)
231 break;
232 }
233}