Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 1 | #include "../perf.h" |
| 2 | #include <stdlib.h> |
| 3 | #include <stdio.h> |
| 4 | #include <string.h> |
Arnaldo Carvalho de Melo | b3165f4 | 2009-12-13 19:50:28 -0200 | [diff] [blame] | 5 | #include "session.h" |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 6 | #include "thread.h" |
Adrian Hunter | 00447cc | 2014-10-30 16:09:42 +0200 | [diff] [blame] | 7 | #include "thread-stack.h" |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 8 | #include "util.h" |
Frederic Weisbecker | 6e08643 | 2009-08-18 17:04:03 +0200 | [diff] [blame] | 9 | #include "debug.h" |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 10 | #include "comm.h" |
Namhyung Kim | 66f066d8 | 2014-10-06 09:46:00 +0900 | [diff] [blame] | 11 | #include "unwind.h" |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 12 | |
Jiri Olsa | cddcef6 | 2014-04-09 20:54:29 +0200 | [diff] [blame] | 13 | int thread__init_map_groups(struct thread *thread, struct machine *machine) |
| 14 | { |
| 15 | struct thread *leader; |
| 16 | pid_t pid = thread->pid_; |
| 17 | |
Adrian Hunter | 1fcb876 | 2014-07-14 13:02:25 +0300 | [diff] [blame] | 18 | if (pid == thread->tid || pid == -1) { |
Arnaldo Carvalho de Melo | 11246c7 | 2014-10-21 17:29:02 -0300 | [diff] [blame] | 19 | thread->mg = map_groups__new(machine); |
Jiri Olsa | cddcef6 | 2014-04-09 20:54:29 +0200 | [diff] [blame] | 20 | } 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 Hunter | 99d725f | 2013-08-26 16:00:19 +0300 | [diff] [blame] | 29 | struct thread *thread__new(pid_t pid, pid_t tid) |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 30 | { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 31 | char *comm_str; |
| 32 | struct comm *comm; |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 33 | struct thread *thread = zalloc(sizeof(*thread)); |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 34 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 35 | if (thread != NULL) { |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 36 | thread->pid_ = pid; |
| 37 | thread->tid = tid; |
| 38 | thread->ppid = -1; |
Adrian Hunter | bf49c35 | 2014-07-22 16:17:24 +0300 | [diff] [blame] | 39 | thread->cpu = -1; |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 40 | INIT_LIST_HEAD(&thread->comm_list); |
| 41 | |
Namhyung Kim | 66f066d8 | 2014-10-06 09:46:00 +0900 | [diff] [blame] | 42 | if (unwind__prepare_access(thread) < 0) |
| 43 | goto err_thread; |
| 44 | |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 45 | comm_str = malloc(32); |
| 46 | if (!comm_str) |
| 47 | goto err_thread; |
| 48 | |
| 49 | snprintf(comm_str, 32, ":%d", tid); |
Adrian Hunter | 65de51f | 2014-07-31 09:00:44 +0300 | [diff] [blame] | 50 | comm = comm__new(comm_str, 0, false); |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 51 | free(comm_str); |
| 52 | if (!comm) |
| 53 | goto err_thread; |
| 54 | |
| 55 | list_add(&comm->list, &thread->comm_list); |
Namhyung Kim | 66f066d8 | 2014-10-06 09:46:00 +0900 | [diff] [blame] | 56 | |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 57 | } |
| 58 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 59 | return thread; |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 60 | |
| 61 | err_thread: |
| 62 | free(thread); |
| 63 | return NULL; |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 64 | } |
| 65 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 66 | void thread__delete(struct thread *thread) |
Arnaldo Carvalho de Melo | 591765f | 2010-07-30 18:28:42 -0300 | [diff] [blame] | 67 | { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 68 | struct comm *comm, *tmp; |
| 69 | |
Adrian Hunter | 00447cc | 2014-10-30 16:09:42 +0200 | [diff] [blame] | 70 | thread_stack__free(thread); |
| 71 | |
Adrian Hunter | 9608b84 | 2014-07-16 10:19:43 +0300 | [diff] [blame] | 72 | if (thread->mg) { |
| 73 | map_groups__put(thread->mg); |
| 74 | thread->mg = NULL; |
| 75 | } |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 76 | list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) { |
| 77 | list_del(&comm->list); |
| 78 | comm__free(comm); |
| 79 | } |
Namhyung Kim | 66f066d8 | 2014-10-06 09:46:00 +0900 | [diff] [blame] | 80 | unwind__finish_access(thread); |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 81 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 82 | free(thread); |
Arnaldo Carvalho de Melo | 591765f | 2010-07-30 18:28:42 -0300 | [diff] [blame] | 83 | } |
| 84 | |
Arnaldo Carvalho de Melo | f3b623b | 2015-03-02 22:21:35 -0300 | [diff] [blame^] | 85 | struct thread *thread__get(struct thread *thread) |
| 86 | { |
| 87 | ++thread->refcnt; |
| 88 | return thread; |
| 89 | } |
| 90 | |
| 91 | void 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 Kim | 4dfced3 | 2013-09-13 16:28:57 +0900 | [diff] [blame] | 99 | struct comm *thread__comm(const struct thread *thread) |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 100 | { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 101 | if (list_empty(&thread->comm_list)) |
| 102 | return NULL; |
David S. Miller | 4385d58 | 2010-02-26 12:08:34 -0300 | [diff] [blame] | 103 | |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 104 | return list_first_entry(&thread->comm_list, struct comm, list); |
| 105 | } |
| 106 | |
Adrian Hunter | 65de51f | 2014-07-31 09:00:44 +0300 | [diff] [blame] | 107 | struct 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 Hunter | 65de51f | 2014-07-31 09:00:44 +0300 | [diff] [blame] | 120 | int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp, |
| 121 | bool exec) |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 122 | { |
| 123 | struct comm *new, *curr = thread__comm(thread); |
Frederic Weisbecker | 3178f58 | 2014-01-14 16:37:14 +0100 | [diff] [blame] | 124 | int err; |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 125 | |
Adrian Hunter | a848080 | 2014-11-11 16:16:41 +0200 | [diff] [blame] | 126 | /* Override the default :tid entry */ |
| 127 | if (!thread->comm_set) { |
Adrian Hunter | 65de51f | 2014-07-31 09:00:44 +0300 | [diff] [blame] | 128 | err = comm__override(curr, str, timestamp, exec); |
Frederic Weisbecker | 3178f58 | 2014-01-14 16:37:14 +0100 | [diff] [blame] | 129 | if (err) |
| 130 | return err; |
Frederic Weisbecker | a5285ad | 2013-11-16 02:02:09 +0100 | [diff] [blame] | 131 | } else { |
Adrian Hunter | 65de51f | 2014-07-31 09:00:44 +0300 | [diff] [blame] | 132 | new = comm__new(str, timestamp, exec); |
Frederic Weisbecker | a5285ad | 2013-11-16 02:02:09 +0100 | [diff] [blame] | 133 | if (!new) |
| 134 | return -ENOMEM; |
| 135 | list_add(&new->list, &thread->comm_list); |
Namhyung Kim | 380b514 | 2014-10-06 09:46:01 +0900 | [diff] [blame] | 136 | |
| 137 | if (exec) |
| 138 | unwind__flush_access(thread); |
David S. Miller | 4385d58 | 2010-02-26 12:08:34 -0300 | [diff] [blame] | 139 | } |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 140 | |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 141 | thread->comm_set = true; |
| 142 | |
| 143 | return 0; |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 144 | } |
| 145 | |
Frederic Weisbecker | b9c5143 | 2013-09-11 14:46:56 +0200 | [diff] [blame] | 146 | const char *thread__comm_str(const struct thread *thread) |
| 147 | { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 148 | const struct comm *comm = thread__comm(thread); |
| 149 | |
| 150 | if (!comm) |
| 151 | return NULL; |
| 152 | |
| 153 | return comm__str(comm); |
Frederic Weisbecker | b9c5143 | 2013-09-11 14:46:56 +0200 | [diff] [blame] | 154 | } |
| 155 | |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 156 | /* CHECKME: it should probably better return the max comm len from its comm list */ |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 157 | int thread__comm_len(struct thread *thread) |
Frederic Weisbecker | a4fb581 | 2009-10-22 23:23:23 +0200 | [diff] [blame] | 158 | { |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 159 | if (!thread->comm_len) { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 160 | const char *comm = thread__comm_str(thread); |
| 161 | if (!comm) |
Frederic Weisbecker | a4fb581 | 2009-10-22 23:23:23 +0200 | [diff] [blame] | 162 | return 0; |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 163 | thread->comm_len = strlen(comm); |
Frederic Weisbecker | a4fb581 | 2009-10-22 23:23:23 +0200 | [diff] [blame] | 164 | } |
| 165 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 166 | return thread->comm_len; |
Frederic Weisbecker | a4fb581 | 2009-10-22 23:23:23 +0200 | [diff] [blame] | 167 | } |
| 168 | |
Arnaldo Carvalho de Melo | 3f067dc | 2012-12-07 17:39:39 -0300 | [diff] [blame] | 169 | size_t thread__fprintf(struct thread *thread, FILE *fp) |
Arnaldo Carvalho de Melo | 95011c6 | 2009-11-27 16:29:20 -0200 | [diff] [blame] | 170 | { |
Frederic Weisbecker | b9c5143 | 2013-09-11 14:46:56 +0200 | [diff] [blame] | 171 | return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) + |
Jiri Olsa | acebd40 | 2014-07-14 23:46:47 +0200 | [diff] [blame] | 172 | map_groups__fprintf(thread->mg, fp); |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 173 | } |
| 174 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 175 | void thread__insert_map(struct thread *thread, struct map *map) |
Arnaldo Carvalho de Melo | 1b46cdd | 2009-09-28 14:48:46 -0300 | [diff] [blame] | 176 | { |
Jiri Olsa | acebd40 | 2014-07-14 23:46:47 +0200 | [diff] [blame] | 177 | map_groups__fixup_overlappings(thread->mg, map, stderr); |
Arnaldo Carvalho de Melo | 93d5731 | 2014-03-21 17:57:01 -0300 | [diff] [blame] | 178 | map_groups__insert(thread->mg, map); |
Arnaldo Carvalho de Melo | 95011c6 | 2009-11-27 16:29:20 -0200 | [diff] [blame] | 179 | } |
| 180 | |
Jiri Olsa | cddcef6 | 2014-04-09 20:54:29 +0200 | [diff] [blame] | 181 | static 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 Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 198 | int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp) |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 199 | { |
Jiri Olsa | cddcef6 | 2014-04-09 20:54:29 +0200 | [diff] [blame] | 200 | int err; |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 201 | |
Arnaldo Carvalho de Melo | faa5c5c | 2010-02-19 23:02:07 -0200 | [diff] [blame] | 202 | if (parent->comm_set) { |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 203 | const char *comm = thread__comm_str(parent); |
| 204 | if (!comm) |
Arnaldo Carvalho de Melo | faa5c5c | 2010-02-19 23:02:07 -0200 | [diff] [blame] | 205 | return -ENOMEM; |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 206 | err = thread__set_comm(thread, comm, timestamp); |
David Ahern | 8d00be8 | 2013-12-10 21:35:38 -0700 | [diff] [blame] | 207 | if (err) |
Frederic Weisbecker | 1902efe | 2013-09-11 16:56:44 +0200 | [diff] [blame] | 208 | return err; |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 209 | thread->comm_set = true; |
Arnaldo Carvalho de Melo | faa5c5c | 2010-02-19 23:02:07 -0200 | [diff] [blame] | 210 | } |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 211 | |
Arnaldo Carvalho de Melo | c824c43 | 2013-10-22 19:01:31 -0300 | [diff] [blame] | 212 | thread->ppid = parent->tid; |
Jiri Olsa | cddcef6 | 2014-04-09 20:54:29 +0200 | [diff] [blame] | 213 | return thread__clone_map_groups(thread, parent); |
Frederic Weisbecker | 6baa0a5 | 2009-08-14 12:21:53 +0200 | [diff] [blame] | 214 | } |
Arnaldo Carvalho de Melo | 52a3cb8 | 2014-03-11 16:16:49 -0300 | [diff] [blame] | 215 | |
| 216 | void thread__find_cpumode_addr_location(struct thread *thread, |
Arnaldo Carvalho de Melo | 52a3cb8 | 2014-03-11 16:16:49 -0300 | [diff] [blame] | 217 | 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 Melo | bb871a9 | 2014-10-23 12:50:25 -0300 | [diff] [blame] | 229 | thread__find_addr_location(thread, cpumodes[i], type, addr, al); |
Arnaldo Carvalho de Melo | 52a3cb8 | 2014-03-11 16:16:49 -0300 | [diff] [blame] | 230 | if (al->map) |
| 231 | break; |
| 232 | } |
| 233 | } |