]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
6baa0a5a | 2 | #include "../perf.h" |
a43783ae | 3 | #include <errno.h> |
6baa0a5a FW |
4 | #include <stdlib.h> |
5 | #include <stdio.h> | |
6 | #include <string.h> | |
877a7a11 | 7 | #include <linux/kernel.h> |
7f7c536f | 8 | #include <linux/zalloc.h> |
b3165f41 | 9 | #include "session.h" |
6baa0a5a | 10 | #include "thread.h" |
00447ccd | 11 | #include "thread-stack.h" |
6e086437 | 12 | #include "debug.h" |
f3b3614a | 13 | #include "namespaces.h" |
1902efe7 | 14 | #include "comm.h" |
15325938 | 15 | #include "map.h" |
daecf9e0 | 16 | #include "symbol.h" |
66f066d8 | 17 | #include "unwind.h" |
382619c0 | 18 | #include "callchain.h" |
6baa0a5a | 19 | |
2f3027ac ACM |
20 | #include <api/fs/fs.h> |
21 | ||
cddcef60 JO |
22 | int thread__init_map_groups(struct thread *thread, struct machine *machine) |
23 | { | |
cddcef60 JO |
24 | pid_t pid = thread->pid_; |
25 | ||
1fcb8768 | 26 | if (pid == thread->tid || pid == -1) { |
11246c70 | 27 | thread->mg = map_groups__new(machine); |
cddcef60 | 28 | } else { |
18ef15c6 | 29 | struct thread *leader = __machine__findnew_thread(machine, pid, pid); |
abd82868 | 30 | if (leader) { |
cddcef60 | 31 | thread->mg = map_groups__get(leader->mg); |
abd82868 ACM |
32 | thread__put(leader); |
33 | } | |
cddcef60 JO |
34 | } |
35 | ||
36 | return thread->mg ? 0 : -1; | |
37 | } | |
38 | ||
99d725fc | 39 | struct thread *thread__new(pid_t pid, pid_t tid) |
6baa0a5a | 40 | { |
1902efe7 FW |
41 | char *comm_str; |
42 | struct comm *comm; | |
c824c433 | 43 | struct thread *thread = zalloc(sizeof(*thread)); |
6baa0a5a | 44 | |
c824c433 | 45 | if (thread != NULL) { |
c824c433 ACM |
46 | thread->pid_ = pid; |
47 | thread->tid = tid; | |
48 | thread->ppid = -1; | |
bf49c35f | 49 | thread->cpu = -1; |
f3b3614a | 50 | INIT_LIST_HEAD(&thread->namespaces_list); |
1902efe7 | 51 | INIT_LIST_HEAD(&thread->comm_list); |
b32ee9e5 KL |
52 | init_rwsem(&thread->namespaces_lock); |
53 | init_rwsem(&thread->comm_lock); | |
1902efe7 FW |
54 | |
55 | comm_str = malloc(32); | |
56 | if (!comm_str) | |
57 | goto err_thread; | |
58 | ||
59 | snprintf(comm_str, 32, ":%d", tid); | |
65de51f9 | 60 | comm = comm__new(comm_str, 0, false); |
1902efe7 FW |
61 | free(comm_str); |
62 | if (!comm) | |
63 | goto err_thread; | |
64 | ||
65 | list_add(&comm->list, &thread->comm_list); | |
e34f5b11 | 66 | refcount_set(&thread->refcnt, 1); |
b91fc39f | 67 | RB_CLEAR_NODE(&thread->rb_node); |
843ff37b KJ |
68 | /* Thread holds first ref to nsdata. */ |
69 | thread->nsinfo = nsinfo__new(pid); | |
dd2e18e9 | 70 | srccode_state_init(&thread->srccode_state); |
6baa0a5a FW |
71 | } |
72 | ||
c824c433 | 73 | return thread; |
1902efe7 FW |
74 | |
75 | err_thread: | |
76 | free(thread); | |
77 | return NULL; | |
6baa0a5a FW |
78 | } |
79 | ||
c824c433 | 80 | void thread__delete(struct thread *thread) |
591765fd | 81 | { |
f3b3614a HB |
82 | struct namespaces *namespaces, *tmp_namespaces; |
83 | struct comm *comm, *tmp_comm; | |
1902efe7 | 84 | |
b91fc39f | 85 | BUG_ON(!RB_EMPTY_NODE(&thread->rb_node)); |
b91fc39f | 86 | |
00447ccd AH |
87 | thread_stack__free(thread); |
88 | ||
9608b84e AH |
89 | if (thread->mg) { |
90 | map_groups__put(thread->mg); | |
91 | thread->mg = NULL; | |
92 | } | |
b32ee9e5 | 93 | down_write(&thread->namespaces_lock); |
f3b3614a HB |
94 | list_for_each_entry_safe(namespaces, tmp_namespaces, |
95 | &thread->namespaces_list, list) { | |
e56fbc9d | 96 | list_del_init(&namespaces->list); |
f3b3614a HB |
97 | namespaces__free(namespaces); |
98 | } | |
b32ee9e5 KL |
99 | up_write(&thread->namespaces_lock); |
100 | ||
101 | down_write(&thread->comm_lock); | |
f3b3614a | 102 | list_for_each_entry_safe(comm, tmp_comm, &thread->comm_list, list) { |
e56fbc9d | 103 | list_del_init(&comm->list); |
1902efe7 FW |
104 | comm__free(comm); |
105 | } | |
b32ee9e5 KL |
106 | up_write(&thread->comm_lock); |
107 | ||
66f066d8 | 108 | unwind__finish_access(thread); |
843ff37b | 109 | nsinfo__zput(thread->nsinfo); |
dd2e18e9 | 110 | srccode_state_free(&thread->srccode_state); |
1902efe7 | 111 | |
b32ee9e5 KL |
112 | exit_rwsem(&thread->namespaces_lock); |
113 | exit_rwsem(&thread->comm_lock); | |
c824c433 | 114 | free(thread); |
591765fd ACM |
115 | } |
116 | ||
f3b623b8 ACM |
117 | struct thread *thread__get(struct thread *thread) |
118 | { | |
b91fc39f | 119 | if (thread) |
e34f5b11 | 120 | refcount_inc(&thread->refcnt); |
f3b623b8 ACM |
121 | return thread; |
122 | } | |
123 | ||
124 | void thread__put(struct thread *thread) | |
125 | { | |
e34f5b11 | 126 | if (thread && refcount_dec_and_test(&thread->refcnt)) { |
abd82868 | 127 | /* |
4c00af0e ACM |
128 | * Remove it from the dead threads list, as last reference is |
129 | * gone, if it is in a dead threads list. | |
130 | * | |
131 | * We may not be there anymore if say, the machine where it was | |
132 | * stored was already deleted, so we already removed it from | |
133 | * the dead threads and some other piece of code still keeps a | |
134 | * reference. | |
135 | * | |
136 | * This is what 'perf sched' does and finally drops it in | |
137 | * perf_sched__lat(), where it calls perf_sched__read_events(), | |
138 | * that processes the events by creating a session and deleting | |
139 | * it, which ends up destroying the list heads for the dead | |
140 | * threads, but before it does that it removes all threads from | |
141 | * it using list_del_init(). | |
142 | * | |
143 | * So we need to check here if it is in a dead threads list and | |
144 | * if so, remove it before finally deleting the thread, to avoid | |
145 | * an use after free situation. | |
abd82868 | 146 | */ |
4c00af0e ACM |
147 | if (!list_empty(&thread->node)) |
148 | list_del_init(&thread->node); | |
f3b623b8 ACM |
149 | thread__delete(thread); |
150 | } | |
151 | } | |
152 | ||
6584140b | 153 | static struct namespaces *__thread__namespaces(const struct thread *thread) |
f3b3614a HB |
154 | { |
155 | if (list_empty(&thread->namespaces_list)) | |
156 | return NULL; | |
157 | ||
158 | return list_first_entry(&thread->namespaces_list, struct namespaces, list); | |
159 | } | |
160 | ||
7cb10a08 | 161 | struct namespaces *thread__namespaces(struct thread *thread) |
6584140b NK |
162 | { |
163 | struct namespaces *ns; | |
164 | ||
7cb10a08 | 165 | down_read(&thread->namespaces_lock); |
6584140b | 166 | ns = __thread__namespaces(thread); |
7cb10a08 | 167 | up_read(&thread->namespaces_lock); |
6584140b NK |
168 | |
169 | return ns; | |
170 | } | |
171 | ||
b32ee9e5 KL |
172 | static int __thread__set_namespaces(struct thread *thread, u64 timestamp, |
173 | struct namespaces_event *event) | |
f3b3614a | 174 | { |
6584140b | 175 | struct namespaces *new, *curr = __thread__namespaces(thread); |
f3b3614a HB |
176 | |
177 | new = namespaces__new(event); | |
178 | if (!new) | |
179 | return -ENOMEM; | |
180 | ||
181 | list_add(&new->list, &thread->namespaces_list); | |
182 | ||
183 | if (timestamp && curr) { | |
184 | /* | |
185 | * setns syscall must have changed few or all the namespaces | |
186 | * of this thread. Update end time for the namespaces | |
187 | * previously used. | |
188 | */ | |
189 | curr = list_next_entry(new, list); | |
190 | curr->end_time = timestamp; | |
191 | } | |
192 | ||
193 | return 0; | |
194 | } | |
195 | ||
b32ee9e5 KL |
196 | int thread__set_namespaces(struct thread *thread, u64 timestamp, |
197 | struct namespaces_event *event) | |
198 | { | |
199 | int ret; | |
200 | ||
201 | down_write(&thread->namespaces_lock); | |
202 | ret = __thread__set_namespaces(thread, timestamp, event); | |
203 | up_write(&thread->namespaces_lock); | |
204 | return ret; | |
205 | } | |
206 | ||
4dfced35 | 207 | struct comm *thread__comm(const struct thread *thread) |
6baa0a5a | 208 | { |
1902efe7 FW |
209 | if (list_empty(&thread->comm_list)) |
210 | return NULL; | |
4385d580 | 211 | |
1902efe7 FW |
212 | return list_first_entry(&thread->comm_list, struct comm, list); |
213 | } | |
214 | ||
65de51f9 AH |
215 | struct comm *thread__exec_comm(const struct thread *thread) |
216 | { | |
217 | struct comm *comm, *last = NULL; | |
218 | ||
219 | list_for_each_entry(comm, &thread->comm_list, list) { | |
220 | if (comm->exec) | |
221 | return comm; | |
222 | last = comm; | |
223 | } | |
224 | ||
225 | return last; | |
226 | } | |
227 | ||
b32ee9e5 KL |
228 | static int ____thread__set_comm(struct thread *thread, const char *str, |
229 | u64 timestamp, bool exec) | |
1902efe7 FW |
230 | { |
231 | struct comm *new, *curr = thread__comm(thread); | |
232 | ||
a8480808 AH |
233 | /* Override the default :tid entry */ |
234 | if (!thread->comm_set) { | |
18ef15c6 | 235 | int err = comm__override(curr, str, timestamp, exec); |
3178f58b FW |
236 | if (err) |
237 | return err; | |
a5285ad9 | 238 | } else { |
65de51f9 | 239 | new = comm__new(str, timestamp, exec); |
a5285ad9 FW |
240 | if (!new) |
241 | return -ENOMEM; | |
242 | list_add(&new->list, &thread->comm_list); | |
380b5143 NK |
243 | |
244 | if (exec) | |
245 | unwind__flush_access(thread); | |
4385d580 | 246 | } |
1902efe7 | 247 | |
1902efe7 FW |
248 | thread->comm_set = true; |
249 | ||
250 | return 0; | |
6baa0a5a FW |
251 | } |
252 | ||
b32ee9e5 KL |
253 | int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp, |
254 | bool exec) | |
255 | { | |
256 | int ret; | |
257 | ||
258 | down_write(&thread->comm_lock); | |
259 | ret = ____thread__set_comm(thread, str, timestamp, exec); | |
260 | up_write(&thread->comm_lock); | |
261 | return ret; | |
262 | } | |
263 | ||
2f3027ac ACM |
264 | int thread__set_comm_from_proc(struct thread *thread) |
265 | { | |
266 | char path[64]; | |
267 | char *comm = NULL; | |
268 | size_t sz; | |
269 | int err = -1; | |
270 | ||
271 | if (!(snprintf(path, sizeof(path), "%d/task/%d/comm", | |
272 | thread->pid_, thread->tid) >= (int)sizeof(path)) && | |
273 | procfs__read_str(path, &comm, &sz) == 0) { | |
274 | comm[sz - 1] = '\0'; | |
275 | err = thread__set_comm(thread, comm, 0); | |
276 | } | |
277 | ||
278 | return err; | |
279 | } | |
280 | ||
b32ee9e5 | 281 | static const char *__thread__comm_str(const struct thread *thread) |
b9c5143a | 282 | { |
1902efe7 FW |
283 | const struct comm *comm = thread__comm(thread); |
284 | ||
285 | if (!comm) | |
286 | return NULL; | |
287 | ||
288 | return comm__str(comm); | |
b9c5143a FW |
289 | } |
290 | ||
7cb10a08 | 291 | const char *thread__comm_str(struct thread *thread) |
b32ee9e5 KL |
292 | { |
293 | const char *str; | |
294 | ||
7cb10a08 | 295 | down_read(&thread->comm_lock); |
b32ee9e5 | 296 | str = __thread__comm_str(thread); |
7cb10a08 | 297 | up_read(&thread->comm_lock); |
b32ee9e5 KL |
298 | |
299 | return str; | |
300 | } | |
301 | ||
1902efe7 | 302 | /* CHECKME: it should probably better return the max comm len from its comm list */ |
c824c433 | 303 | int thread__comm_len(struct thread *thread) |
a4fb581b | 304 | { |
c824c433 | 305 | if (!thread->comm_len) { |
1902efe7 FW |
306 | const char *comm = thread__comm_str(thread); |
307 | if (!comm) | |
a4fb581b | 308 | return 0; |
1902efe7 | 309 | thread->comm_len = strlen(comm); |
a4fb581b FW |
310 | } |
311 | ||
c824c433 | 312 | return thread->comm_len; |
a4fb581b FW |
313 | } |
314 | ||
3f067dca | 315 | size_t thread__fprintf(struct thread *thread, FILE *fp) |
9958e1f0 | 316 | { |
b9c5143a | 317 | return fprintf(fp, "Thread %d %s\n", thread->tid, thread__comm_str(thread)) + |
acebd408 | 318 | map_groups__fprintf(thread->mg, fp); |
6baa0a5a FW |
319 | } |
320 | ||
8132a2a8 | 321 | int thread__insert_map(struct thread *thread, struct map *map) |
1b46cddf | 322 | { |
8132a2a8 HK |
323 | int ret; |
324 | ||
a2873325 | 325 | ret = unwind__prepare_access(thread, map, NULL); |
8132a2a8 HK |
326 | if (ret) |
327 | return ret; | |
328 | ||
acebd408 | 329 | map_groups__fixup_overlappings(thread->mg, map, stderr); |
93d5731d | 330 | map_groups__insert(thread->mg, map); |
8132a2a8 HK |
331 | |
332 | return 0; | |
6baa0a5a FW |
333 | } |
334 | ||
6c502584 JO |
335 | static int __thread__prepare_access(struct thread *thread) |
336 | { | |
337 | bool initialized = false; | |
3183f8ca ACM |
338 | int err = 0; |
339 | struct maps *maps = &thread->mg->maps; | |
340 | struct map *map; | |
6c502584 | 341 | |
3183f8ca | 342 | down_read(&maps->lock); |
6c502584 | 343 | |
3183f8ca ACM |
344 | for (map = maps__first(maps); map; map = map__next(map)) { |
345 | err = unwind__prepare_access(thread, map, &initialized); | |
346 | if (err || initialized) | |
347 | break; | |
6c502584 JO |
348 | } |
349 | ||
3183f8ca ACM |
350 | up_read(&maps->lock); |
351 | ||
6c502584 JO |
352 | return err; |
353 | } | |
354 | ||
355 | static int thread__prepare_access(struct thread *thread) | |
356 | { | |
357 | int err = 0; | |
358 | ||
382619c0 | 359 | if (dwarf_callchain_users) |
6c502584 JO |
360 | err = __thread__prepare_access(thread); |
361 | ||
362 | return err; | |
363 | } | |
364 | ||
cddcef60 | 365 | static int thread__clone_map_groups(struct thread *thread, |
4f8f382e DM |
366 | struct thread *parent, |
367 | bool do_maps_clone) | |
cddcef60 | 368 | { |
cddcef60 JO |
369 | /* This is new thread, we share map groups for process. */ |
370 | if (thread->pid_ == parent->pid_) | |
6c502584 | 371 | return thread__prepare_access(thread); |
cddcef60 | 372 | |
0d7e7acc AH |
373 | if (thread->mg == parent->mg) { |
374 | pr_debug("broken map groups on thread %d/%d parent %d/%d\n", | |
375 | thread->pid_, thread->tid, parent->pid_, parent->tid); | |
376 | return 0; | |
377 | } | |
cddcef60 | 378 | /* But this one is new process, copy maps. */ |
4f8f382e | 379 | return do_maps_clone ? map_groups__clone(thread, parent->mg) : 0; |
cddcef60 JO |
380 | } |
381 | ||
4f8f382e | 382 | int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp, bool do_maps_clone) |
95011c60 | 383 | { |
faa5c5c3 | 384 | if (parent->comm_set) { |
1902efe7 | 385 | const char *comm = thread__comm_str(parent); |
18ef15c6 | 386 | int err; |
1902efe7 | 387 | if (!comm) |
faa5c5c3 | 388 | return -ENOMEM; |
1902efe7 | 389 | err = thread__set_comm(thread, comm, timestamp); |
8d00be81 | 390 | if (err) |
1902efe7 | 391 | return err; |
faa5c5c3 | 392 | } |
6baa0a5a | 393 | |
c824c433 | 394 | thread->ppid = parent->tid; |
4f8f382e | 395 | return thread__clone_map_groups(thread, parent, do_maps_clone); |
6baa0a5a | 396 | } |
52a3cb8c | 397 | |
26bd9331 | 398 | void thread__find_cpumode_addr_location(struct thread *thread, u64 addr, |
52a3cb8c ACM |
399 | struct addr_location *al) |
400 | { | |
401 | size_t i; | |
3b556bce | 402 | const u8 cpumodes[] = { |
52a3cb8c ACM |
403 | PERF_RECORD_MISC_USER, |
404 | PERF_RECORD_MISC_KERNEL, | |
405 | PERF_RECORD_MISC_GUEST_USER, | |
406 | PERF_RECORD_MISC_GUEST_KERNEL | |
407 | }; | |
408 | ||
409 | for (i = 0; i < ARRAY_SIZE(cpumodes); i++) { | |
26bd9331 | 410 | thread__find_symbol(thread, cpumodes[i], addr, al); |
52a3cb8c ACM |
411 | if (al->map) |
412 | break; | |
413 | } | |
414 | } | |
480ca357 AK |
415 | |
416 | struct thread *thread__main_thread(struct machine *machine, struct thread *thread) | |
417 | { | |
418 | if (thread->pid_ == thread->tid) | |
419 | return thread__get(thread); | |
420 | ||
421 | if (thread->pid_ == -1) | |
422 | return NULL; | |
423 | ||
424 | return machine__find_thread(machine, thread->pid_, thread->pid_); | |
425 | } | |
15325938 AK |
426 | |
427 | int thread__memcpy(struct thread *thread, struct machine *machine, | |
428 | void *buf, u64 ip, int len, bool *is64bit) | |
429 | { | |
430 | u8 cpumode = PERF_RECORD_MISC_USER; | |
431 | struct addr_location al; | |
432 | long offset; | |
433 | ||
434 | if (machine__kernel_ip(machine, ip)) | |
435 | cpumode = PERF_RECORD_MISC_KERNEL; | |
436 | ||
437 | if (!thread__find_map(thread, cpumode, ip, &al) || !al.map->dso || | |
438 | al.map->dso->data.status == DSO_DATA_STATUS_ERROR || | |
439 | map__load(al.map) < 0) | |
440 | return -1; | |
441 | ||
442 | offset = al.map->map_ip(al.map, ip); | |
443 | if (is64bit) | |
444 | *is64bit = al.map->dso->is_64_bit; | |
445 | ||
446 | return dso__data_read_offset(al.map->dso, machine, offset, buf, len); | |
447 | } |