[linux-2.6-block.git] / tools / perf / util / thread_map.c

#include <dirent.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "strlist.h"
#include <string.h>
#include <api/fs/fs.h>
#include "asm/bug.h"
#include "thread_map.h"
#include "util.h"
#include "debug.h"
#include "event.h"

/* Skip "." and ".." directories */
static int filter(const struct dirent *dir)
{
	if (dir->d_name[0] == '.')
		return 0;
	else
		return 1;
}

static void thread_map__reset(struct thread_map *map, int start, int nr)
{
	size_t size = (nr - start) * sizeof(map->map[0]);

	memset(&map->map[start], 0, size);
}

static struct thread_map *thread_map__realloc(struct thread_map *map, int nr)
{
	size_t size = sizeof(*map) + sizeof(map->map[0]) * nr;
	int start = map ? map->nr : 0;

	map = realloc(map, size);
	/*
	 * We only realloc to add more items, let's reset new items.
	 */
	if (map)
		thread_map__reset(map, start, nr);

	return map;
}

#define thread_map__alloc(__nr) thread_map__realloc(NULL, __nr)

struct thread_map *thread_map__new_by_pid(pid_t pid)
{
	struct thread_map *threads;
	char name[256];
	int items;
	struct dirent **namelist = NULL;
	int i;

	sprintf(name, "/proc/%d/task", pid);
	items = scandir(name, &namelist, filter, NULL);
	if (items <= 0)
		return NULL;

	threads = thread_map__alloc(items);
	if (threads != NULL) {
		for (i = 0; i < items; i++)
			thread_map__set_pid(threads, i, atoi(namelist[i]->d_name));
		threads->nr = items;
		atomic_set(&threads->refcnt, 1);
	}

	for (i=0; i<items; i++)
		zfree(&namelist[i]);
	free(namelist);

	return threads;
}

struct thread_map *thread_map__new_by_tid(pid_t tid)
{
	struct thread_map *threads = thread_map__alloc(1);

	if (threads != NULL) {
		thread_map__set_pid(threads, 0, tid);
		threads->nr = 1;
		atomic_set(&threads->refcnt, 1);
	}

	return threads;
}

struct thread_map *thread_map__new_by_uid(uid_t uid)
{
	DIR *proc;
	int max_threads = 32, items, i;
	char path[256];
	struct dirent *dirent, **namelist = NULL;
	struct thread_map *threads = thread_map__alloc(max_threads);

	if (threads == NULL)
		goto out;

	proc = opendir("/proc");
	if (proc == NULL)
		goto out_free_threads;

	threads->nr = 0;
	atomic_set(&threads->refcnt, 1);

	while ((dirent = readdir(proc)) != NULL) {
		char *end;
		bool grow = false;
		struct stat st;
		pid_t pid = strtol(dirent->d_name, &end, 10);

		if (*end) /* only interested in proper numerical dirents */
			continue;

		snprintf(path, sizeof(path), "/proc/%s", dirent->d_name);

		if (stat(path, &st) != 0)
			continue;

		if (st.st_uid != uid)
			continue;

		snprintf(path, sizeof(path), "/proc/%d/task", pid);
		items = scandir(path, &namelist, filter, NULL);
		if (items <= 0)
			goto out_free_closedir;

		while (threads->nr + items >= max_threads) {
			max_threads *= 2;
			grow = true;
		}

		if (grow) {
			struct thread_map *tmp;

			tmp = thread_map__realloc(threads, max_threads);
			if (tmp == NULL)
				goto out_free_namelist;

			threads = tmp;
		}

		for (i = 0; i < items; i++) {
			thread_map__set_pid(threads, threads->nr + i,
					    atoi(namelist[i]->d_name));
		}

		for (i = 0; i < items; i++)
			zfree(&namelist[i]);
		free(namelist);

		threads->nr += items;
	}

out_closedir:
	closedir(proc);
out:
	return threads;

out_free_threads:
	free(threads);
	return NULL;

out_free_namelist:
	for (i = 0; i < items; i++)
		zfree(&namelist[i]);
	free(namelist);

out_free_closedir:
	zfree(&threads);
	goto out_closedir;
}

struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid)
{
	if (pid != -1)
		return thread_map__new_by_pid(pid);

	if (tid == -1 && uid != UINT_MAX)
		return thread_map__new_by_uid(uid);

	return thread_map__new_by_tid(tid);
}

static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
{
	struct thread_map *threads = NULL, *nt;
	char name[256];
	int items, total_tasks = 0;
	struct dirent **namelist = NULL;
	int i, j = 0;
	pid_t pid, prev_pid = INT_MAX;
	char *end_ptr;
	struct str_node *pos;
	struct strlist_config slist_config = { .dont_dupstr = true, };
	struct strlist *slist = strlist__new(pid_str, &slist_config);

	if (!slist)
		return NULL;

	strlist__for_each(pos, slist) {
		pid = strtol(pos->s, &end_ptr, 10);

		if (pid == INT_MIN || pid == INT_MAX ||
		    (*end_ptr != '\0' && *end_ptr != ','))
			goto out_free_threads;

		if (pid == prev_pid)
			continue;

		sprintf(name, "/proc/%d/task", pid);
		items = scandir(name, &namelist, filter, NULL);
		if (items <= 0)
			goto out_free_threads;

		total_tasks += items;
		nt = thread_map__realloc(threads, total_tasks);
		if (nt == NULL)
			goto out_free_namelist;

		threads = nt;

		for (i = 0; i < items; i++) {
			thread_map__set_pid(threads, j++, atoi(namelist[i]->d_name));
			zfree(&namelist[i]);
		}
		threads->nr = total_tasks;
		free(namelist);
	}

out:
	strlist__delete(slist);
	if (threads)
		atomic_set(&threads->refcnt, 1);
	return threads;

out_free_namelist:
	for (i = 0; i < items; i++)
		zfree(&namelist[i]);
	free(namelist);

out_free_threads:
	zfree(&threads);
	goto out;
}

struct thread_map *thread_map__new_dummy(void)
{
	struct thread_map *threads = thread_map__alloc(1);

	if (threads != NULL) {
		thread_map__set_pid(threads, 0, -1);
		threads->nr = 1;
		atomic_set(&threads->refcnt, 1);
	}
	return threads;
}

struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
{
	struct thread_map *threads = NULL, *nt;
	int ntasks = 0;
	pid_t tid, prev_tid = INT_MAX;
	char *end_ptr;
	struct str_node *pos;
	struct strlist_config slist_config = { .dont_dupstr = true, };
	struct strlist *slist;

	/* perf-stat expects threads to be generated even if tid not given */
	if (!tid_str)
		return thread_map__new_dummy();

	slist = strlist__new(tid_str, &slist_config);
	if (!slist)
		return NULL;

	strlist__for_each(pos, slist) {
		tid = strtol(pos->s, &end_ptr, 10);

		if (tid == INT_MIN || tid == INT_MAX ||
		    (*end_ptr != '\0' && *end_ptr != ','))
			goto out_free_threads;

		if (tid == prev_tid)
			continue;

		ntasks++;
		nt = thread_map__realloc(threads, ntasks);

		if (nt == NULL)
			goto out_free_threads;

		threads = nt;
		thread_map__set_pid(threads, ntasks - 1, tid);
		threads->nr = ntasks;
	}
out:
	if (threads)
		atomic_set(&threads->refcnt, 1);
	return threads;

out_free_threads:
	zfree(&threads);
	strlist__delete(slist);
	goto out;
}

struct thread_map *thread_map__new_str(const char *pid, const char *tid,
				       uid_t uid)
{
	if (pid)
		return thread_map__new_by_pid_str(pid);

	if (!tid && uid != UINT_MAX)
		return thread_map__new_by_uid(uid);

	return thread_map__new_by_tid_str(tid);
}

static void thread_map__delete(struct thread_map *threads)
{
	if (threads) {
		int i;

		WARN_ONCE(atomic_read(&threads->refcnt) != 0,
			  "thread map refcnt unbalanced\n");
		for (i = 0; i < threads->nr; i++)
			free(thread_map__comm(threads, i));
		free(threads);
	}
}

struct thread_map *thread_map__get(struct thread_map *map)
{
	if (map)
		atomic_inc(&map->refcnt);
	return map;
}

void thread_map__put(struct thread_map *map)
{
	if (map && atomic_dec_and_test(&map->refcnt))
		thread_map__delete(map);
}

size_t thread_map__fprintf(struct thread_map *threads, FILE *fp)
{
	int i;
	size_t printed = fprintf(fp, "%d thread%s: ",
				 threads->nr, threads->nr > 1 ? "s" : "");
	for (i = 0; i < threads->nr; ++i)
		printed += fprintf(fp, "%s%d", i ? ", " : "", thread_map__pid(threads, i));

	return printed + fprintf(fp, "\n");
}

static int get_comm(char **comm, pid_t pid)
{
	char *path;
	size_t size;
	int err;

	if (asprintf(&path, "%s/%d/comm", procfs__mountpoint(), pid) == -1)
		return -ENOMEM;

	err = filename__read_str(path, comm, &size);
	if (!err) {
		/*
		 * We're reading 16 bytes, while filename__read_str
		 * allocates data per BUFSIZ bytes, so we can safely
		 * mark the end of the string.
		 */
		(*comm)[size] = 0;
		rtrim(*comm);
	}

	free(path);
	return err;
}

static void comm_init(struct thread_map *map, int i)
{
	pid_t pid = thread_map__pid(map, i);
	char *comm = NULL;

	/* dummy pid comm initialization */
	if (pid == -1) {
		map->map[i].comm = strdup("dummy");
		return;
	}

	/*
	 * The comm name is like extra bonus ;-),
	 * so just warn if we fail for any reason.
	 */
	if (get_comm(&comm, pid))
		pr_warning("Couldn't resolve comm name for pid %d\n", pid);

	map->map[i].comm = comm;
}

void thread_map__read_comms(struct thread_map *threads)
{
	int i;

	for (i = 0; i < threads->nr; ++i)
		comm_init(threads, i);
}

static void thread_map__copy_event(struct thread_map *threads,
				   struct thread_map_event *event)
{
	unsigned i;

	threads->nr = (int) event->nr;

	for (i = 0; i < event->nr; i++) {
		thread_map__set_pid(threads, i, (pid_t) event->entries[i].pid);
		threads->map[i].comm = strndup(event->entries[i].comm, 16);
	}

	atomic_set(&threads->refcnt, 1);
}

struct thread_map *thread_map__new_event(struct thread_map_event *event)
{
	struct thread_map *threads;

	threads = thread_map__alloc(event->nr);
	if (threads)
		thread_map__copy_event(threads, event);

	return threads;
}

bool thread_map__has(struct thread_map *threads, pid_t pid)
{
	int i;

	for (i = 0; i < threads->nr; ++i) {
		if (threads->map[i].pid == pid)
			return true;
	}

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