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

#include "util.h"
#include <api/fs/fs.h>
#include "../perf.h"
#include "cpumap.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/bitmap.h>
#include "asm/bug.h"

static int max_cpu_num;
static int max_node_num;
static int *cpunode_map;

static struct cpu_map *cpu_map__default_new(void)
{
	struct cpu_map *cpus;
	int nr_cpus;

	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	if (nr_cpus < 0)
		return NULL;

	cpus = malloc(sizeof(*cpus) + nr_cpus * sizeof(int));
	if (cpus != NULL) {
		int i;
		for (i = 0; i < nr_cpus; ++i)
			cpus->map[i] = i;

		cpus->nr = nr_cpus;
		atomic_set(&cpus->refcnt, 1);
	}

	return cpus;
}

static struct cpu_map *cpu_map__trim_new(int nr_cpus, int *tmp_cpus)
{
	size_t payload_size = nr_cpus * sizeof(int);
	struct cpu_map *cpus = malloc(sizeof(*cpus) + payload_size);

	if (cpus != NULL) {
		cpus->nr = nr_cpus;
		memcpy(cpus->map, tmp_cpus, payload_size);
		atomic_set(&cpus->refcnt, 1);
	}

	return cpus;
}

struct cpu_map *cpu_map__read(FILE *file)
{
	struct cpu_map *cpus = NULL;
	int nr_cpus = 0;
	int *tmp_cpus = NULL, *tmp;
	int max_entries = 0;
	int n, cpu, prev;
	char sep;

	sep = 0;
	prev = -1;
	for (;;) {
		n = fscanf(file, "%u%c", &cpu, &sep);
		if (n <= 0)
			break;
		if (prev >= 0) {
			int new_max = nr_cpus + cpu - prev - 1;

			if (new_max >= max_entries) {
				max_entries = new_max + MAX_NR_CPUS / 2;
				tmp = realloc(tmp_cpus, max_entries * sizeof(int));
				if (tmp == NULL)
					goto out_free_tmp;
				tmp_cpus = tmp;
			}

			while (++prev < cpu)
				tmp_cpus[nr_cpus++] = prev;
		}
		if (nr_cpus == max_entries) {
			max_entries += MAX_NR_CPUS;
			tmp = realloc(tmp_cpus, max_entries * sizeof(int));
			if (tmp == NULL)
				goto out_free_tmp;
			tmp_cpus = tmp;
		}

		tmp_cpus[nr_cpus++] = cpu;
		if (n == 2 && sep == '-')
			prev = cpu;
		else
			prev = -1;
		if (n == 1 || sep == '\n')
			break;
	}

	if (nr_cpus > 0)
		cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	else
		cpus = cpu_map__default_new();
out_free_tmp:
	free(tmp_cpus);
	return cpus;
}

static struct cpu_map *cpu_map__read_all_cpu_map(void)
{
	struct cpu_map *cpus = NULL;
	FILE *onlnf;

	onlnf = fopen("/sys/devices/system/cpu/online", "r");
	if (!onlnf)
		return cpu_map__default_new();

	cpus = cpu_map__read(onlnf);
	fclose(onlnf);
	return cpus;
}

struct cpu_map *cpu_map__new(const char *cpu_list)
{
	struct cpu_map *cpus = NULL;
	unsigned long start_cpu, end_cpu = 0;
	char *p = NULL;
	int i, nr_cpus = 0;
	int *tmp_cpus = NULL, *tmp;
	int max_entries = 0;

	if (!cpu_list)
		return cpu_map__read_all_cpu_map();

	if (!isdigit(*cpu_list))
		goto out;

	while (isdigit(*cpu_list)) {
		p = NULL;
		start_cpu = strtoul(cpu_list, &p, 0);
		if (start_cpu >= INT_MAX
		    || (*p != '\0' && *p != ',' && *p != '-'))
			goto invalid;

		if (*p == '-') {
			cpu_list = ++p;
			p = NULL;
			end_cpu = strtoul(cpu_list, &p, 0);

			if (end_cpu >= INT_MAX || (*p != '\0' && *p != ','))
				goto invalid;

			if (end_cpu < start_cpu)
				goto invalid;
		} else {
			end_cpu = start_cpu;
		}

		for (; start_cpu <= end_cpu; start_cpu++) {
			/* check for duplicates */
			for (i = 0; i < nr_cpus; i++)
				if (tmp_cpus[i] == (int)start_cpu)
					goto invalid;

			if (nr_cpus == max_entries) {
				max_entries += MAX_NR_CPUS;
				tmp = realloc(tmp_cpus, max_entries * sizeof(int));
				if (tmp == NULL)
					goto invalid;
				tmp_cpus = tmp;
			}
			tmp_cpus[nr_cpus++] = (int)start_cpu;
		}
		if (*p)
			++p;

		cpu_list = p;
	}

	if (nr_cpus > 0)
		cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	else
		cpus = cpu_map__default_new();
invalid:
	free(tmp_cpus);
out:
	return cpus;
}

static struct cpu_map *cpu_map__from_entries(struct cpu_map_entries *cpus)
{
	struct cpu_map *map;

	map = cpu_map__empty_new(cpus->nr);
	if (map) {
		unsigned i;

		for (i = 0; i < cpus->nr; i++) {
			/*
			 * Special treatment for -1, which is not real cpu number,
			 * and we need to use (int) -1 to initialize map[i],
			 * otherwise it would become 65535.
			 */
			if (cpus->cpu[i] == (u16) -1)
				map->map[i] = -1;
			else
				map->map[i] = (int) cpus->cpu[i];
		}
	}

	return map;
}

static struct cpu_map *cpu_map__from_mask(struct cpu_map_mask *mask)
{
	struct cpu_map *map;
	int nr, nbits = mask->nr * mask->long_size * BITS_PER_BYTE;

	nr = bitmap_weight(mask->mask, nbits);

	map = cpu_map__empty_new(nr);
	if (map) {
		int cpu, i = 0;

		for_each_set_bit(cpu, mask->mask, nbits)
			map->map[i++] = cpu;
	}
	return map;

}

struct cpu_map *cpu_map__new_data(struct cpu_map_data *data)
{
	if (data->type == PERF_CPU_MAP__CPUS)
		return cpu_map__from_entries((struct cpu_map_entries *)data->data);
	else
		return cpu_map__from_mask((struct cpu_map_mask *)data->data);
}

size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp)
{
#define BUFSIZE 1024
	char buf[BUFSIZE];

	cpu_map__snprint(map, buf, sizeof(buf));
	return fprintf(fp, "%s\n", buf);
#undef BUFSIZE
}

struct cpu_map *cpu_map__dummy_new(void)
{
	struct cpu_map *cpus = malloc(sizeof(*cpus) + sizeof(int));

	if (cpus != NULL) {
		cpus->nr = 1;
		cpus->map[0] = -1;
		atomic_set(&cpus->refcnt, 1);
	}

	return cpus;
}

struct cpu_map *cpu_map__empty_new(int nr)
{
	struct cpu_map *cpus = malloc(sizeof(*cpus) + sizeof(int) * nr);

	if (cpus != NULL) {
		int i;

		cpus->nr = nr;
		for (i = 0; i < nr; i++)
			cpus->map[i] = -1;

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

	return cpus;
}

static void cpu_map__delete(struct cpu_map *map)
{
	if (map) {
		WARN_ONCE(atomic_read(&map->refcnt) != 0,
			  "cpu_map refcnt unbalanced\n");
		free(map);
	}
}

struct cpu_map *cpu_map__get(struct cpu_map *map)
{
	if (map)
		atomic_inc(&map->refcnt);
	return map;
}

void cpu_map__put(struct cpu_map *map)
{
	if (map && atomic_dec_and_test(&map->refcnt))
		cpu_map__delete(map);
}

static int cpu__get_topology_int(int cpu, const char *name, int *value)
{
	char path[PATH_MAX];

	snprintf(path, PATH_MAX,
		"devices/system/cpu/cpu%d/topology/%s", cpu, name);

	return sysfs__read_int(path, value);
}

int cpu_map__get_socket_id(int cpu)
{
	int value, ret = cpu__get_topology_int(cpu, "physical_package_id", &value);
	return ret ?: value;
}

int cpu_map__get_socket(struct cpu_map *map, int idx, void *data __maybe_unused)
{
	int cpu;

	if (idx > map->nr)
		return -1;

	cpu = map->map[idx];

	return cpu_map__get_socket_id(cpu);
}

static int cmp_ids(const void *a, const void *b)
{
	return *(int *)a - *(int *)b;
}

int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
		       int (*f)(struct cpu_map *map, int cpu, void *data),
		       void *data)
{
	struct cpu_map *c;
	int nr = cpus->nr;
	int cpu, s1, s2;

	/* allocate as much as possible */
	c = calloc(1, sizeof(*c) + nr * sizeof(int));
	if (!c)
		return -1;

	for (cpu = 0; cpu < nr; cpu++) {
		s1 = f(cpus, cpu, data);
		for (s2 = 0; s2 < c->nr; s2++) {
			if (s1 == c->map[s2])
				break;
		}
		if (s2 == c->nr) {
			c->map[c->nr] = s1;
			c->nr++;
		}
	}
	/* ensure we process id in increasing order */
	qsort(c->map, c->nr, sizeof(int), cmp_ids);

	atomic_set(&c->refcnt, 1);
	*res = c;
	return 0;
}

int cpu_map__get_core_id(int cpu)
{
	int value, ret = cpu__get_topology_int(cpu, "core_id", &value);
	return ret ?: value;
}

int cpu_map__get_core(struct cpu_map *map, int idx, void *data)
{
	int cpu, s;

	if (idx > map->nr)
		return -1;

	cpu = map->map[idx];

	cpu = cpu_map__get_core_id(cpu);

	s = cpu_map__get_socket(map, idx, data);
	if (s == -1)
		return -1;

	/*
	 * encode socket in upper 16 bits
	 * core_id is relative to socket, and
	 * we need a global id. So we combine
	 * socket+ core id
	 */
	return (s << 16) | (cpu & 0xffff);
}

int cpu_map__build_socket_map(struct cpu_map *cpus, struct cpu_map **sockp)
{
	return cpu_map__build_map(cpus, sockp, cpu_map__get_socket, NULL);
}

int cpu_map__build_core_map(struct cpu_map *cpus, struct cpu_map **corep)
{
	return cpu_map__build_map(cpus, corep, cpu_map__get_core, NULL);
}

/* setup simple routines to easily access node numbers given a cpu number */
static int get_max_num(char *path, int *max)
{
	size_t num;
	char *buf;
	int err = 0;

	if (filename__read_str(path, &buf, &num))
		return -1;

	buf[num] = '\0';

	/* start on the right, to find highest node num */
	while (--num) {
		if ((buf[num] == ',') || (buf[num] == '-')) {
			num++;
			break;
		}
	}
	if (sscanf(&buf[num], "%d", max) < 1) {
		err = -1;
		goto out;
	}

	/* convert from 0-based to 1-based */
	(*max)++;

out:
	free(buf);
	return err;
}

/* Determine highest possible cpu in the system for sparse allocation */
static void set_max_cpu_num(void)
{
	const char *mnt;
	char path[PATH_MAX];
	int ret = -1;

	/* set up default */
	max_cpu_num = 4096;

	mnt = sysfs__mountpoint();
	if (!mnt)
		goto out;

	/* get the highest possible cpu number for a sparse allocation */
	ret = snprintf(path, PATH_MAX, "%s/devices/system/cpu/possible", mnt);
	if (ret == PATH_MAX) {
		pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
		goto out;
	}

	ret = get_max_num(path, &max_cpu_num);

out:
	if (ret)
		pr_err("Failed to read max cpus, using default of %d\n", max_cpu_num);
}

/* Determine highest possible node in the system for sparse allocation */
static void set_max_node_num(void)
{
	const char *mnt;
	char path[PATH_MAX];
	int ret = -1;

	/* set up default */
	max_node_num = 8;

	mnt = sysfs__mountpoint();
	if (!mnt)
		goto out;

	/* get the highest possible cpu number for a sparse allocation */
	ret = snprintf(path, PATH_MAX, "%s/devices/system/node/possible", mnt);
	if (ret == PATH_MAX) {
		pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
		goto out;
	}

	ret = get_max_num(path, &max_node_num);

out:
	if (ret)
		pr_err("Failed to read max nodes, using default of %d\n", max_node_num);
}

int cpu__max_node(void)
{
	if (unlikely(!max_node_num))
		set_max_node_num();

	return max_node_num;
}

int cpu__max_cpu(void)
{
	if (unlikely(!max_cpu_num))
		set_max_cpu_num();

	return max_cpu_num;
}

int cpu__get_node(int cpu)
{
	if (unlikely(cpunode_map == NULL)) {
		pr_debug("cpu_map not initialized\n");
		return -1;
	}

	return cpunode_map[cpu];
}

static int init_cpunode_map(void)
{
	int i;

	set_max_cpu_num();
	set_max_node_num();

	cpunode_map = calloc(max_cpu_num, sizeof(int));
	if (!cpunode_map) {
		pr_err("%s: calloc failed\n", __func__);
		return -1;
	}

	for (i = 0; i < max_cpu_num; i++)
		cpunode_map[i] = -1;

	return 0;
}

int cpu__setup_cpunode_map(void)
{
	struct dirent *dent1, *dent2;
	DIR *dir1, *dir2;
	unsigned int cpu, mem;
	char buf[PATH_MAX];
	char path[PATH_MAX];
	const char *mnt;
	int n;

	/* initialize globals */
	if (init_cpunode_map())
		return -1;

	mnt = sysfs__mountpoint();
	if (!mnt)
		return 0;

	n = snprintf(path, PATH_MAX, "%s/devices/system/node", mnt);
	if (n == PATH_MAX) {
		pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
		return -1;
	}

	dir1 = opendir(path);
	if (!dir1)
		return 0;

	/* walk tree and setup map */
	while ((dent1 = readdir(dir1)) != NULL) {
		if (dent1->d_type != DT_DIR || sscanf(dent1->d_name, "node%u", &mem) < 1)
			continue;

		n = snprintf(buf, PATH_MAX, "%s/%s", path, dent1->d_name);
		if (n == PATH_MAX) {
			pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
			continue;
		}

		dir2 = opendir(buf);
		if (!dir2)
			continue;
		while ((dent2 = readdir(dir2)) != NULL) {
			if (dent2->d_type != DT_LNK || sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
				continue;
			cpunode_map[cpu] = mem;
		}
		closedir(dir2);
	}
	closedir(dir1);
	return 0;
}

bool cpu_map__has(struct cpu_map *cpus, int cpu)
{
	return cpu_map__idx(cpus, cpu) != -1;
}

int cpu_map__idx(struct cpu_map *cpus, int cpu)
{
	int i;

	for (i = 0; i < cpus->nr; ++i) {
		if (cpus->map[i] == cpu)
			return i;
	}

	return -1;
}

int cpu_map__cpu(struct cpu_map *cpus, int idx)
{
	return cpus->map[idx];
}

size_t cpu_map__snprint(struct cpu_map *map, char *buf, size_t size)
{
	int i, cpu, start = -1;
	bool first = true;
	size_t ret = 0;

#define COMMA first ? "" : ","

	for (i = 0; i < map->nr + 1; i++) {
		bool last = i == map->nr;

		cpu = last ? INT_MAX : map->map[i];

		if (start == -1) {
			start = i;
			if (last) {
				ret += snprintf(buf + ret, size - ret,
						"%s%d", COMMA,
						map->map[i]);
			}
		} else if (((i - start) != (cpu - map->map[start])) || last) {
			int end = i - 1;

			if (start == end) {
				ret += snprintf(buf + ret, size - ret,
						"%s%d", COMMA,
						map->map[start]);
			} else {
				ret += snprintf(buf + ret, size - ret,
						"%s%d-%d", COMMA,
						map->map[start], map->map[end]);
			}
			first = false;
			start = i;
		}
	}

#undef COMMA

	pr_debug("cpumask list: %s\n", buf);
	return ret;
}
Commit	Line	Data
a12b51c4	1	#include "util.h"
cd0cfad7	2	#include <api/fs/fs.h>
a12b51c4 PM	3	#include "../perf.h"
	4	#include "cpumap.h"
	5	#include <assert.h>
	6	#include <stdio.h>
86ee6e18	7	#include <stdlib.h>
f77b57ad	8	#include <linux/bitmap.h>
f30a79b0	9	#include "asm/bug.h"
a12b51c4	10
5ac76283 ACM	11	static int max_cpu_num;
	12	static int max_node_num;
	13	static int *cpunode_map;
	14
60d567e2	15	static struct cpu_map *cpu_map__default_new(void)
a12b51c4	16	{
60d567e2 ACM	17	struct cpu_map *cpus;
60d567e2 ACM	18	int nr_cpus;
a12b51c4 PM	19
a12b51c4 PM	20	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
60d567e2 ACM	21	if (nr_cpus < 0)
	22	return NULL;
	23
	24	cpus = malloc(sizeof(cpus) + nr_cpus sizeof(int));
	25	if (cpus != NULL) {
	26	int i;
	27	for (i = 0; i < nr_cpus; ++i)
	28	cpus->map[i] = i;
a12b51c4	29
60d567e2	30	cpus->nr = nr_cpus;
f30a79b0	31	atomic_set(&cpus->refcnt, 1);
60d567e2	32	}
a12b51c4	33
60d567e2	34	return cpus;
a12b51c4 PM	35	}
a12b51c4 PM	36
60d567e2	37	static struct cpu_map cpu_map__trim_new(int nr_cpus, int tmp_cpus)
a12b51c4	38	{
60d567e2 ACM	39	size_t payload_size = nr_cpus * sizeof(int);
	40	struct cpu_map cpus = malloc(sizeof(cpus) + payload_size);
	41
	42	if (cpus != NULL) {
	43	cpus->nr = nr_cpus;
	44	memcpy(cpus->map, tmp_cpus, payload_size);
f30a79b0	45	atomic_set(&cpus->refcnt, 1);
60d567e2 ACM	46	}
	47
	48	return cpus;
	49	}
	50
7ae92e74	51	struct cpu_map cpu_map__read(FILE file)
60d567e2 ACM	52	{
60d567e2 ACM	53	struct cpu_map *cpus = NULL;
a12b51c4	54	int nr_cpus = 0;
60d567e2 ACM	55	int tmp_cpus = NULL, tmp;
60d567e2 ACM	56	int max_entries = 0;
a12b51c4 PM	57	int n, cpu, prev;
	58	char sep;
	59
a12b51c4 PM	60	sep = 0;
	61	prev = -1;
	62	for (;;) {
7ae92e74	63	n = fscanf(file, "%u%c", &cpu, &sep);
a12b51c4 PM	64	if (n <= 0)
	65	break;
	66	if (prev >= 0) {
60d567e2 ACM	67	int new_max = nr_cpus + cpu - prev - 1;
	68
	69	if (new_max >= max_entries) {
	70	max_entries = new_max + MAX_NR_CPUS / 2;
	71	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	72	if (tmp == NULL)
	73	goto out_free_tmp;
	74	tmp_cpus = tmp;
	75	}
	76
a12b51c4	77	while (++prev < cpu)
60d567e2 ACM	78	tmp_cpus[nr_cpus++] = prev;
	79	}
	80	if (nr_cpus == max_entries) {
	81	max_entries += MAX_NR_CPUS;
	82	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	83	if (tmp == NULL)
	84	goto out_free_tmp;
	85	tmp_cpus = tmp;
a12b51c4	86	}
60d567e2 ACM	87
60d567e2 ACM	88	tmp_cpus[nr_cpus++] = cpu;
a12b51c4 PM	89	if (n == 2 && sep == '-')
	90	prev = cpu;
	91	else
	92	prev = -1;
	93	if (n == 1 \|\| sep == '\n')
	94	break;
	95	}
a12b51c4	96
60d567e2 ACM	97	if (nr_cpus > 0)
	98	cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	99	else
	100	cpus = cpu_map__default_new();
	101	out_free_tmp:
	102	free(tmp_cpus);
7ae92e74 YZ	103	return cpus;
	104	}
	105
	106	static struct cpu_map *cpu_map__read_all_cpu_map(void)
	107	{
	108	struct cpu_map *cpus = NULL;
	109	FILE *onlnf;
	110
	111	onlnf = fopen("/sys/devices/system/cpu/online", "r");
	112	if (!onlnf)
	113	return cpu_map__default_new();
	114
	115	cpus = cpu_map__read(onlnf);
60d567e2 ACM	116	fclose(onlnf);
60d567e2 ACM	117	return cpus;
a12b51c4	118	}
c45c6ea2	119
60d567e2	120	struct cpu_map cpu_map__new(const char cpu_list)
c45c6ea2	121	{
60d567e2	122	struct cpu_map *cpus = NULL;
c45c6ea2 SE	123	unsigned long start_cpu, end_cpu = 0;
	124	char *p = NULL;
	125	int i, nr_cpus = 0;
60d567e2 ACM	126	int tmp_cpus = NULL, tmp;
60d567e2 ACM	127	int max_entries = 0;
c45c6ea2 SE	128
c45c6ea2 SE	129	if (!cpu_list)
60d567e2	130	return cpu_map__read_all_cpu_map();
c45c6ea2 SE	131
c45c6ea2 SE	132	if (!isdigit(*cpu_list))
60d567e2	133	goto out;
c45c6ea2 SE	134
	135	while (isdigit(*cpu_list)) {
	136	p = NULL;
	137	start_cpu = strtoul(cpu_list, &p, 0);
	138	if (start_cpu >= INT_MAX
	139	\|\| (p != '\0' && p != ',' && *p != '-'))
	140	goto invalid;
	141
	142	if (*p == '-') {
	143	cpu_list = ++p;
	144	p = NULL;
	145	end_cpu = strtoul(cpu_list, &p, 0);
	146
	147	if (end_cpu >= INT_MAX \|\| (p != '\0' && p != ','))
	148	goto invalid;
	149
	150	if (end_cpu < start_cpu)
	151	goto invalid;
	152	} else {
	153	end_cpu = start_cpu;
	154	}
	155
	156	for (; start_cpu <= end_cpu; start_cpu++) {
	157	/* check for duplicates */
	158	for (i = 0; i < nr_cpus; i++)
60d567e2	159	if (tmp_cpus[i] == (int)start_cpu)
c45c6ea2 SE	160	goto invalid;
c45c6ea2 SE	161
60d567e2 ACM	162	if (nr_cpus == max_entries) {
	163	max_entries += MAX_NR_CPUS;
	164	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	165	if (tmp == NULL)
	166	goto invalid;
	167	tmp_cpus = tmp;
	168	}
	169	tmp_cpus[nr_cpus++] = (int)start_cpu;
c45c6ea2 SE	170	}
	171	if (*p)
	172	++p;
	173
	174	cpu_list = p;
	175	}
c45c6ea2	176
60d567e2 ACM	177	if (nr_cpus > 0)
	178	cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	179	else
	180	cpus = cpu_map__default_new();
c45c6ea2	181	invalid:
60d567e2 ACM	182	free(tmp_cpus);
	183	out:
	184	return cpus;
	185	}
	186
f77b57ad JO	187	static struct cpu_map cpu_map__from_entries(struct cpu_map_entries cpus)
	188	{
	189	struct cpu_map *map;
	190
	191	map = cpu_map__empty_new(cpus->nr);
	192	if (map) {
	193	unsigned i;
	194
15d2b995 JO	195	for (i = 0; i < cpus->nr; i++) {
	196	/*
	197	* Special treatment for -1, which is not real cpu number,
	198	* and we need to use (int) -1 to initialize map[i],
	199	* otherwise it would become 65535.
	200	*/
	201	if (cpus->cpu[i] == (u16) -1)
	202	map->map[i] = -1;
	203	else
	204	map->map[i] = (int) cpus->cpu[i];
	205	}
f77b57ad JO	206	}
	207
	208	return map;
	209	}
	210
	211	static struct cpu_map cpu_map__from_mask(struct cpu_map_mask mask)
	212	{
	213	struct cpu_map *map;
	214	int nr, nbits = mask->nr * mask->long_size * BITS_PER_BYTE;
	215
	216	nr = bitmap_weight(mask->mask, nbits);
	217
	218	map = cpu_map__empty_new(nr);
	219	if (map) {
	220	int cpu, i = 0;
	221
	222	for_each_set_bit(cpu, mask->mask, nbits)
	223	map->map[i++] = cpu;
	224	}
	225	return map;
	226
	227	}
	228
	229	struct cpu_map cpu_map__new_data(struct cpu_map_data data)
	230	{
	231	if (data->type == PERF_CPU_MAP__CPUS)
	232	return cpu_map__from_entries((struct cpu_map_entries *)data->data);
	233	else
	234	return cpu_map__from_mask((struct cpu_map_mask *)data->data);
	235	}
	236
9ae7d335 ACM	237	size_t cpu_map__fprintf(struct cpu_map map, FILE fp)
9ae7d335 ACM	238	{
a24020e6 JO	239	#define BUFSIZE 1024
a24020e6 JO	240	char buf[BUFSIZE];
9ae7d335	241
a24020e6 JO	242	cpu_map__snprint(map, buf, sizeof(buf));
	243	return fprintf(fp, "%s\n", buf);
	244	#undef BUFSIZE
9ae7d335 ACM	245	}
9ae7d335 ACM	246
60d567e2 ACM	247	struct cpu_map *cpu_map__dummy_new(void)
	248	{
	249	struct cpu_map cpus = malloc(sizeof(cpus) + sizeof(int));
	250
	251	if (cpus != NULL) {
	252	cpus->nr = 1;
	253	cpus->map[0] = -1;
f30a79b0	254	atomic_set(&cpus->refcnt, 1);
60d567e2 ACM	255	}
	256
	257	return cpus;
c45c6ea2	258	}
915fce20	259
2322f573 JO	260	struct cpu_map *cpu_map__empty_new(int nr)
	261	{
	262	struct cpu_map cpus = malloc(sizeof(cpus) + sizeof(int) * nr);
	263
	264	if (cpus != NULL) {
	265	int i;
	266
	267	cpus->nr = nr;
	268	for (i = 0; i < nr; i++)
	269	cpus->map[i] = -1;
	270
	271	atomic_set(&cpus->refcnt, 1);
	272	}
	273
	274	return cpus;
	275	}
	276
f30a79b0	277	static void cpu_map__delete(struct cpu_map *map)
915fce20	278	{
f30a79b0 JO	279	if (map) {
	280	WARN_ONCE(atomic_read(&map->refcnt) != 0,
	281	"cpu_map refcnt unbalanced\n");
	282	free(map);
	283	}
	284	}
	285
	286	struct cpu_map cpu_map__get(struct cpu_map map)
	287	{
	288	if (map)
	289	atomic_inc(&map->refcnt);
	290	return map;
	291	}
	292
	293	void cpu_map__put(struct cpu_map *map)
	294	{
	295	if (map && atomic_dec_and_test(&map->refcnt))
	296	cpu_map__delete(map);
915fce20	297	}
5ac59a8a	298
5d8cf721	299	static int cpu__get_topology_int(int cpu, const char name, int value)
5ac59a8a	300	{
5ac59a8a	301	char path[PATH_MAX];
5ac59a8a	302
86ee6e18	303	snprintf(path, PATH_MAX,
5d8cf721	304	"devices/system/cpu/cpu%d/topology/%s", cpu, name);
5ac59a8a	305
5d8cf721 ACM	306	return sysfs__read_int(path, value);
5d8cf721 ACM	307	}
193b6bd3	308
5d8cf721 ACM	309	int cpu_map__get_socket_id(int cpu)
	310	{
	311	int value, ret = cpu__get_topology_int(cpu, "physical_package_id", &value);
	312	return ret ?: value;
193b6bd3 KL	313	}
193b6bd3 KL	314
1fe7a300	315	int cpu_map__get_socket(struct cpu_map map, int idx, void data __maybe_unused)
193b6bd3 KL	316	{
	317	int cpu;
	318
	319	if (idx > map->nr)
	320	return -1;
	321
	322	cpu = map->map[idx];
	323
	324	return cpu_map__get_socket_id(cpu);
5ac59a8a SE	325	}
5ac59a8a SE	326
86ee6e18	327	static int cmp_ids(const void a, const void b)
5ac59a8a	328	{
86ee6e18 SE	329	return (int )a - (int )b;
	330	}
	331
f1cbb8f3	332	int cpu_map__build_map(struct cpu_map cpus, struct cpu_map *res,
1fe7a300 JO	333	int (f)(struct cpu_map map, int cpu, void *data),
1fe7a300 JO	334	void *data)
86ee6e18 SE	335	{
86ee6e18 SE	336	struct cpu_map *c;
5ac59a8a SE	337	int nr = cpus->nr;
	338	int cpu, s1, s2;
	339
86ee6e18 SE	340	/* allocate as much as possible */
	341	c = calloc(1, sizeof(c) + nr sizeof(int));
	342	if (!c)
5ac59a8a SE	343	return -1;
	344
	345	for (cpu = 0; cpu < nr; cpu++) {
1fe7a300	346	s1 = f(cpus, cpu, data);
86ee6e18 SE	347	for (s2 = 0; s2 < c->nr; s2++) {
86ee6e18 SE	348	if (s1 == c->map[s2])
5ac59a8a SE	349	break;
5ac59a8a SE	350	}
86ee6e18 SE	351	if (s2 == c->nr) {
	352	c->map[c->nr] = s1;
	353	c->nr++;
5ac59a8a SE	354	}
5ac59a8a SE	355	}
86ee6e18 SE	356	/* ensure we process id in increasing order */
	357	qsort(c->map, c->nr, sizeof(int), cmp_ids);
	358
bc1d0368	359	atomic_set(&c->refcnt, 1);
86ee6e18	360	*res = c;
5ac59a8a SE	361	return 0;
5ac59a8a SE	362	}
86ee6e18	363
193b6bd3	364	int cpu_map__get_core_id(int cpu)
12c08a9f	365	{
5d8cf721 ACM	366	int value, ret = cpu__get_topology_int(cpu, "core_id", &value);
5d8cf721 ACM	367	return ret ?: value;
193b6bd3 KL	368	}
193b6bd3 KL	369
1fe7a300	370	int cpu_map__get_core(struct cpu_map map, int idx, void data)
193b6bd3 KL	371	{
	372	int cpu, s;
	373
	374	if (idx > map->nr)
12c08a9f SE	375	return -1;
12c08a9f SE	376
193b6bd3 KL	377	cpu = map->map[idx];
	378
	379	cpu = cpu_map__get_core_id(cpu);
	380
1fe7a300	381	s = cpu_map__get_socket(map, idx, data);
12c08a9f SE	382	if (s == -1)
	383	return -1;
	384
	385	/*
	386	* encode socket in upper 16 bits
	387	* core_id is relative to socket, and
	388	* we need a global id. So we combine
	389	* socket+ core id
	390	*/
	391	return (s << 16) \| (cpu & 0xffff);
	392	}
	393
86ee6e18 SE	394	int cpu_map__build_socket_map(struct cpu_map cpus, struct cpu_map *sockp)
86ee6e18 SE	395	{
1fe7a300	396	return cpu_map__build_map(cpus, sockp, cpu_map__get_socket, NULL);
86ee6e18	397	}
12c08a9f SE	398
	399	int cpu_map__build_core_map(struct cpu_map cpus, struct cpu_map *corep)
	400	{
1fe7a300	401	return cpu_map__build_map(cpus, corep, cpu_map__get_core, NULL);
12c08a9f	402	}
7780c25b DZ	403
	404	/* setup simple routines to easily access node numbers given a cpu number */
	405	static int get_max_num(char path, int max)
	406	{
	407	size_t num;
	408	char *buf;
	409	int err = 0;
	410
	411	if (filename__read_str(path, &buf, &num))
	412	return -1;
	413
	414	buf[num] = '\0';
	415
	416	/* start on the right, to find highest node num */
	417	while (--num) {
	418	if ((buf[num] == ',') \|\| (buf[num] == '-')) {
	419	num++;
	420	break;
	421	}
	422	}
	423	if (sscanf(&buf[num], "%d", max) < 1) {
	424	err = -1;
	425	goto out;
	426	}
	427
	428	/* convert from 0-based to 1-based */
	429	(*max)++;
	430
	431	out:
	432	free(buf);
	433	return err;
	434	}
	435
	436	/* Determine highest possible cpu in the system for sparse allocation */
	437	static void set_max_cpu_num(void)
	438	{
	439	const char *mnt;
	440	char path[PATH_MAX];
	441	int ret = -1;
	442
	443	/* set up default */
	444	max_cpu_num = 4096;
	445
	446	mnt = sysfs__mountpoint();
	447	if (!mnt)
	448	goto out;
	449
	450	/* get the highest possible cpu number for a sparse allocation */
f5b1f4e4	451	ret = snprintf(path, PATH_MAX, "%s/devices/system/cpu/possible", mnt);
7780c25b DZ	452	if (ret == PATH_MAX) {
	453	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
	454	goto out;
	455	}
	456
	457	ret = get_max_num(path, &max_cpu_num);
	458
	459	out:
	460	if (ret)
	461	pr_err("Failed to read max cpus, using default of %d\n", max_cpu_num);
	462	}
	463
	464	/* Determine highest possible node in the system for sparse allocation */
	465	static void set_max_node_num(void)
	466	{
	467	const char *mnt;
	468	char path[PATH_MAX];
	469	int ret = -1;
	470
	471	/* set up default */
	472	max_node_num = 8;
	473
	474	mnt = sysfs__mountpoint();
	475	if (!mnt)
	476	goto out;
	477
	478	/* get the highest possible cpu number for a sparse allocation */
	479	ret = snprintf(path, PATH_MAX, "%s/devices/system/node/possible", mnt);
	480	if (ret == PATH_MAX) {
	481	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
	482	goto out;
	483	}
	484
	485	ret = get_max_num(path, &max_node_num);
	486
	487	out:
	488	if (ret)
	489	pr_err("Failed to read max nodes, using default of %d\n", max_node_num);
	490	}
	491
5ac76283 ACM	492	int cpu__max_node(void)
	493	{
	494	if (unlikely(!max_node_num))
	495	set_max_node_num();
	496
	497	return max_node_num;
	498	}
	499
	500	int cpu__max_cpu(void)
	501	{
	502	if (unlikely(!max_cpu_num))
	503	set_max_cpu_num();
	504
	505	return max_cpu_num;
	506	}
	507
	508	int cpu__get_node(int cpu)
	509	{
	510	if (unlikely(cpunode_map == NULL)) {
	511	pr_debug("cpu_map not initialized\n");
	512	return -1;
	513	}
	514
	515	return cpunode_map[cpu];
	516	}
	517
7780c25b DZ	518	static int init_cpunode_map(void)
	519	{
	520	int i;
	521
	522	set_max_cpu_num();
	523	set_max_node_num();
	524
	525	cpunode_map = calloc(max_cpu_num, sizeof(int));
	526	if (!cpunode_map) {
	527	pr_err("%s: calloc failed\n", __func__);
	528	return -1;
	529	}
	530
	531	for (i = 0; i < max_cpu_num; i++)
	532	cpunode_map[i] = -1;
	533
	534	return 0;
	535	}
	536
	537	int cpu__setup_cpunode_map(void)
	538	{
	539	struct dirent dent1, dent2;
	540	DIR dir1, dir2;
	541	unsigned int cpu, mem;
	542	char buf[PATH_MAX];
	543	char path[PATH_MAX];
	544	const char *mnt;
	545	int n;
	546
	547	/* initialize globals */
	548	if (init_cpunode_map())
	549	return -1;
	550
	551	mnt = sysfs__mountpoint();
	552	if (!mnt)
	553	return 0;
	554
	555	n = snprintf(path, PATH_MAX, "%s/devices/system/node", mnt);
	556	if (n == PATH_MAX) {
	557	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
	558	return -1;
	559	}
	560
	561	dir1 = opendir(path);
	562	if (!dir1)
	563	return 0;
	564
	565	/* walk tree and setup map */
	566	while ((dent1 = readdir(dir1)) != NULL) {
	567	if (dent1->d_type != DT_DIR \|\| sscanf(dent1->d_name, "node%u", &mem) < 1)
	568	continue;
	569
	570	n = snprintf(buf, PATH_MAX, "%s/%s", path, dent1->d_name);
	571	if (n == PATH_MAX) {
	572	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
	573	continue;
	574	}
	575
	576	dir2 = opendir(buf);
	577	if (!dir2)
	578	continue;
	579	while ((dent2 = readdir(dir2)) != NULL) {
	580	if (dent2->d_type != DT_LNK \|\| sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
	581	continue;
582	cpunode_map[cpu] = mem;
583	}
584	closedir(dir2);
585	}
586	closedir(dir1);
587	return 0;
588	}
e632aa69 JO	589
e632aa69 JO	590	bool cpu_map__has(struct cpu_map *cpus, int cpu)
9a6c582d MR	591	{
	592	return cpu_map__idx(cpus, cpu) != -1;
	593	}
	594
	595	int cpu_map__idx(struct cpu_map *cpus, int cpu)
e632aa69 JO	596	{
	597	int i;
	598
	599	for (i = 0; i < cpus->nr; ++i) {
	600	if (cpus->map[i] == cpu)
9a6c582d	601	return i;
e632aa69 JO	602	}
e632aa69 JO	603
9a6c582d MR	604	return -1;
	605	}
	606
	607	int cpu_map__cpu(struct cpu_map *cpus, int idx)
	608	{
	609	return cpus->map[idx];
e632aa69	610	}
a24020e6 JO	611
	612	size_t cpu_map__snprint(struct cpu_map map, char buf, size_t size)
	613	{
	614	int i, cpu, start = -1;
	615	bool first = true;
	616	size_t ret = 0;
	617
	618	#define COMMA first ? "" : ","
	619
	620	for (i = 0; i < map->nr + 1; i++) {
	621	bool last = i == map->nr;
	622
	623	cpu = last ? INT_MAX : map->map[i];
	624
	625	if (start == -1) {
	626	start = i;
	627	if (last) {
	628	ret += snprintf(buf + ret, size - ret,
	629	"%s%d", COMMA,
	630	map->map[i]);
	631	}
	632	} else if (((i - start) != (cpu - map->map[start])) \|\| last) {
	633	int end = i - 1;
	634
	635	if (start == end) {
	636	ret += snprintf(buf + ret, size - ret,
	637	"%s%d", COMMA,
	638	map->map[start]);
	639	} else {
	640	ret += snprintf(buf + ret, size - ret,
	641	"%s%d-%d", COMMA,
	642	map->map[start], map->map[end]);
	643	}
	644	first = false;
	645	start = i;
	646	}
	647	}
	648
	649	#undef COMMA
	650
	651	pr_debug("cpumask list: %s\n", buf);
	652	return ret;
	653	}