xref: /openbmc/linux/tools/perf/util/thread_map.c (revision 8c609698) 
1 // SPDX-License-Identifier: GPL-2.0
2 #include <dirent.h>
3 #include <errno.h>
4 #include <limits.h>
5 #include <stdbool.h>
6 #include <stdlib.h>
7 #include <stdio.h>
8 #include <sys/types.h>
9 #include <sys/stat.h>
10 #include <unistd.h>
11 #include "string2.h"
12 #include "strlist.h"
13 #include <string.h>
14 #include <api/fs/fs.h>
15 #include "asm/bug.h"
16 #include "thread_map.h"
17 #include "util.h"
18 #include "debug.h"
19 #include "event.h"
20 
21 /* Skip "." and ".." directories */
22 static int filter(const struct dirent *dir)
23 {
24 	if (dir->d_name[0] == '.')
25 		return 0;
26 	else
27 		return 1;
28 }
29 
30 static void thread_map__reset(struct thread_map *map, int start, int nr)
31 {
32 	size_t size = (nr - start) * sizeof(map->map[0]);
33 
34 	memset(&map->map[start], 0, size);
35 }
36 
37 static struct thread_map *thread_map__realloc(struct thread_map *map, int nr)
38 {
39 	size_t size = sizeof(*map) + sizeof(map->map[0]) * nr;
40 	int start = map ? map->nr : 0;
41 
42 	map = realloc(map, size);
43 	/*
44 	 * We only realloc to add more items, let's reset new items.
45 	 */
46 	if (map)
47 		thread_map__reset(map, start, nr);
48 
49 	return map;
50 }
51 
52 #define thread_map__alloc(__nr) thread_map__realloc(NULL, __nr)
53 
54 struct thread_map *thread_map__new_by_pid(pid_t pid)
55 {
56 	struct thread_map *threads;
57 	char name[256];
58 	int items;
59 	struct dirent **namelist = NULL;
60 	int i;
61 
62 	sprintf(name, "/proc/%d/task", pid);
63 	items = scandir(name, &namelist, filter, NULL);
64 	if (items <= 0)
65 		return NULL;
66 
67 	threads = thread_map__alloc(items);
68 	if (threads != NULL) {
69 		for (i = 0; i < items; i++)
70 			thread_map__set_pid(threads, i, atoi(namelist[i]->d_name));
71 		threads->nr = items;
72 		refcount_set(&threads->refcnt, 1);
73 	}
74 
75 	for (i=0; i<items; i++)
76 		zfree(&namelist[i]);
77 	free(namelist);
78 
79 	return threads;
80 }
81 
82 struct thread_map *thread_map__new_by_tid(pid_t tid)
83 {
84 	struct thread_map *threads = thread_map__alloc(1);
85 
86 	if (threads != NULL) {
87 		thread_map__set_pid(threads, 0, tid);
88 		threads->nr = 1;
89 		refcount_set(&threads->refcnt, 1);
90 	}
91 
92 	return threads;
93 }
94 
95 struct thread_map *thread_map__new_by_uid(uid_t uid)
96 {
97 	DIR *proc;
98 	int max_threads = 32, items, i;
99 	char path[NAME_MAX + 1 + 6];
100 	struct dirent *dirent, **namelist = NULL;
101 	struct thread_map *threads = thread_map__alloc(max_threads);
102 
103 	if (threads == NULL)
104 		goto out;
105 
106 	proc = opendir("/proc");
107 	if (proc == NULL)
108 		goto out_free_threads;
109 
110 	threads->nr = 0;
111 	refcount_set(&threads->refcnt, 1);
112 
113 	while ((dirent = readdir(proc)) != NULL) {
114 		char *end;
115 		bool grow = false;
116 		struct stat st;
117 		pid_t pid = strtol(dirent->d_name, &end, 10);
118 
119 		if (*end) /* only interested in proper numerical dirents */
120 			continue;
121 
122 		snprintf(path, sizeof(path), "/proc/%s", dirent->d_name);
123 
124 		if (stat(path, &st) != 0)
125 			continue;
126 
127 		if (st.st_uid != uid)
128 			continue;
129 
130 		snprintf(path, sizeof(path), "/proc/%d/task", pid);
131 		items = scandir(path, &namelist, filter, NULL);
132 		if (items <= 0)
133 			goto out_free_closedir;
134 
135 		while (threads->nr + items >= max_threads) {
136 			max_threads *= 2;
137 			grow = true;
138 		}
139 
140 		if (grow) {
141 			struct thread_map *tmp;
142 
143 			tmp = thread_map__realloc(threads, max_threads);
144 			if (tmp == NULL)
145 				goto out_free_namelist;
146 
147 			threads = tmp;
148 		}
149 
150 		for (i = 0; i < items; i++) {
151 			thread_map__set_pid(threads, threads->nr + i,
152 					    atoi(namelist[i]->d_name));
153 		}
154 
155 		for (i = 0; i < items; i++)
156 			zfree(&namelist[i]);
157 		free(namelist);
158 
159 		threads->nr += items;
160 	}
161 
162 out_closedir:
163 	closedir(proc);
164 out:
165 	return threads;
166 
167 out_free_threads:
168 	free(threads);
169 	return NULL;
170 
171 out_free_namelist:
172 	for (i = 0; i < items; i++)
173 		zfree(&namelist[i]);
174 	free(namelist);
175 
176 out_free_closedir:
177 	zfree(&threads);
178 	goto out_closedir;
179 }
180 
181 struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid)
182 {
183 	if (pid != -1)
184 		return thread_map__new_by_pid(pid);
185 
186 	if (tid == -1 && uid != UINT_MAX)
187 		return thread_map__new_by_uid(uid);
188 
189 	return thread_map__new_by_tid(tid);
190 }
191 
192 static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
193 {
194 	struct thread_map *threads = NULL, *nt;
195 	char name[256];
196 	int items, total_tasks = 0;
197 	struct dirent **namelist = NULL;
198 	int i, j = 0;
199 	pid_t pid, prev_pid = INT_MAX;
200 	char *end_ptr;
201 	struct str_node *pos;
202 	struct strlist_config slist_config = { .dont_dupstr = true, };
203 	struct strlist *slist = strlist__new(pid_str, &slist_config);
204 
205 	if (!slist)
206 		return NULL;
207 
208 	strlist__for_each_entry(pos, slist) {
209 		pid = strtol(pos->s, &end_ptr, 10);
210 
211 		if (pid == INT_MIN || pid == INT_MAX ||
212 		    (*end_ptr != '\0' && *end_ptr != ','))
213 			goto out_free_threads;
214 
215 		if (pid == prev_pid)
216 			continue;
217 
218 		sprintf(name, "/proc/%d/task", pid);
219 		items = scandir(name, &namelist, filter, NULL);
220 		if (items <= 0)
221 			goto out_free_threads;
222 
223 		total_tasks += items;
224 		nt = thread_map__realloc(threads, total_tasks);
225 		if (nt == NULL)
226 			goto out_free_namelist;
227 
228 		threads = nt;
229 
230 		for (i = 0; i < items; i++) {
231 			thread_map__set_pid(threads, j++, atoi(namelist[i]->d_name));
232 			zfree(&namelist[i]);
233 		}
234 		threads->nr = total_tasks;
235 		free(namelist);
236 	}
237 
238 out:
239 	strlist__delete(slist);
240 	if (threads)
241 		refcount_set(&threads->refcnt, 1);
242 	return threads;
243 
244 out_free_namelist:
245 	for (i = 0; i < items; i++)
246 		zfree(&namelist[i]);
247 	free(namelist);
248 
249 out_free_threads:
250 	zfree(&threads);
251 	goto out;
252 }
253 
254 struct thread_map *thread_map__new_dummy(void)
255 {
256 	struct thread_map *threads = thread_map__alloc(1);
257 
258 	if (threads != NULL) {
259 		thread_map__set_pid(threads, 0, -1);
260 		threads->nr = 1;
261 		refcount_set(&threads->refcnt, 1);
262 	}
263 	return threads;
264 }
265 
266 struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
267 {
268 	struct thread_map *threads = NULL, *nt;
269 	int ntasks = 0;
270 	pid_t tid, prev_tid = INT_MAX;
271 	char *end_ptr;
272 	struct str_node *pos;
273 	struct strlist_config slist_config = { .dont_dupstr = true, };
274 	struct strlist *slist;
275 
276 	/* perf-stat expects threads to be generated even if tid not given */
277 	if (!tid_str)
278 		return thread_map__new_dummy();
279 
280 	slist = strlist__new(tid_str, &slist_config);
281 	if (!slist)
282 		return NULL;
283 
284 	strlist__for_each_entry(pos, slist) {
285 		tid = strtol(pos->s, &end_ptr, 10);
286 
287 		if (tid == INT_MIN || tid == INT_MAX ||
288 		    (*end_ptr != '\0' && *end_ptr != ','))
289 			goto out_free_threads;
290 
291 		if (tid == prev_tid)
292 			continue;
293 
294 		ntasks++;
295 		nt = thread_map__realloc(threads, ntasks);
296 
297 		if (nt == NULL)
298 			goto out_free_threads;
299 
300 		threads = nt;
301 		thread_map__set_pid(threads, ntasks - 1, tid);
302 		threads->nr = ntasks;
303 	}
304 out:
305 	if (threads)
306 		refcount_set(&threads->refcnt, 1);
307 	return threads;
308 
309 out_free_threads:
310 	zfree(&threads);
311 	strlist__delete(slist);
312 	goto out;
313 }
314 
315 struct thread_map *thread_map__new_str(const char *pid, const char *tid,
316 				       uid_t uid)
317 {
318 	if (pid)
319 		return thread_map__new_by_pid_str(pid);
320 
321 	if (!tid && uid != UINT_MAX)
322 		return thread_map__new_by_uid(uid);
323 
324 	return thread_map__new_by_tid_str(tid);
325 }
326 
327 static void thread_map__delete(struct thread_map *threads)
328 {
329 	if (threads) {
330 		int i;
331 
332 		WARN_ONCE(refcount_read(&threads->refcnt) != 0,
333 			  "thread map refcnt unbalanced\n");
334 		for (i = 0; i < threads->nr; i++)
335 			free(thread_map__comm(threads, i));
336 		free(threads);
337 	}
338 }
339 
340 struct thread_map *thread_map__get(struct thread_map *map)
341 {
342 	if (map)
343 		refcount_inc(&map->refcnt);
344 	return map;
345 }
346 
347 void thread_map__put(struct thread_map *map)
348 {
349 	if (map && refcount_dec_and_test(&map->refcnt))
350 		thread_map__delete(map);
351 }
352 
353 size_t thread_map__fprintf(struct thread_map *threads, FILE *fp)
354 {
355 	int i;
356 	size_t printed = fprintf(fp, "%d thread%s: ",
357 				 threads->nr, threads->nr > 1 ? "s" : "");
358 	for (i = 0; i < threads->nr; ++i)
359 		printed += fprintf(fp, "%s%d", i ? ", " : "", thread_map__pid(threads, i));
360 
361 	return printed + fprintf(fp, "\n");
362 }
363 
364 static int get_comm(char **comm, pid_t pid)
365 {
366 	char *path;
367 	size_t size;
368 	int err;
369 
370 	if (asprintf(&path, "%s/%d/comm", procfs__mountpoint(), pid) == -1)
371 		return -ENOMEM;
372 
373 	err = filename__read_str(path, comm, &size);
374 	if (!err) {
375 		/*
376 		 * We're reading 16 bytes, while filename__read_str
377 		 * allocates data per BUFSIZ bytes, so we can safely
378 		 * mark the end of the string.
379 		 */
380 		(*comm)[size] = 0;
381 		rtrim(*comm);
382 	}
383 
384 	free(path);
385 	return err;
386 }
387 
388 static void comm_init(struct thread_map *map, int i)
389 {
390 	pid_t pid = thread_map__pid(map, i);
391 	char *comm = NULL;
392 
393 	/* dummy pid comm initialization */
394 	if (pid == -1) {
395 		map->map[i].comm = strdup("dummy");
396 		return;
397 	}
398 
399 	/*
400 	 * The comm name is like extra bonus ;-),
401 	 * so just warn if we fail for any reason.
402 	 */
403 	if (get_comm(&comm, pid))
404 		pr_warning("Couldn't resolve comm name for pid %d\n", pid);
405 
406 	map->map[i].comm = comm;
407 }
408 
409 void thread_map__read_comms(struct thread_map *threads)
410 {
411 	int i;
412 
413 	for (i = 0; i < threads->nr; ++i)
414 		comm_init(threads, i);
415 }
416 
417 static void thread_map__copy_event(struct thread_map *threads,
418 				   struct thread_map_event *event)
419 {
420 	unsigned i;
421 
422 	threads->nr = (int) event->nr;
423 
424 	for (i = 0; i < event->nr; i++) {
425 		thread_map__set_pid(threads, i, (pid_t) event->entries[i].pid);
426 		threads->map[i].comm = strndup(event->entries[i].comm, 16);
427 	}
428 
429 	refcount_set(&threads->refcnt, 1);
430 }
431 
432 struct thread_map *thread_map__new_event(struct thread_map_event *event)
433 {
434 	struct thread_map *threads;
435 
436 	threads = thread_map__alloc(event->nr);
437 	if (threads)
438 		thread_map__copy_event(threads, event);
439 
440 	return threads;
441 }
442 
443 bool thread_map__has(struct thread_map *threads, pid_t pid)
444 {
445 	int i;
446 
447 	for (i = 0; i < threads->nr; ++i) {
448 		if (threads->map[i].pid == pid)
449 			return true;
450 	}
451 
452 	return false;
453 }
454 
455 int thread_map__remove(struct thread_map *threads, int idx)
456 {
457 	int i;
458 
459 	if (threads->nr < 1)
460 		return -EINVAL;
461 
462 	if (idx >= threads->nr)
463 		return -EINVAL;
464 
465 	/*
466 	 * Free the 'idx' item and shift the rest up.
467 	 */
468 	free(threads->map[idx].comm);
469 
470 	for (i = idx; i < threads->nr - 1; i++)
471 		threads->map[i] = threads->map[i + 1];
472 
473 	threads->nr--;
474 	return 0;
475 }
476