[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>

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;
	}

	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);
	}

	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;
}

size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp)
{
	int i;
	size_t printed = fprintf(fp, "%d cpu%s: ",
				 map->nr, map->nr > 1 ? "s" : "");
	for (i = 0; i < map->nr; ++i)
		printed += fprintf(fp, "%s%d", i ? ", " : "", map->map[i]);

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

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;
	}

	return cpus;
}

void cpu_map__delete(struct cpu_map *map)
{
	free(map);
}

int cpu_map__get_socket(struct cpu_map *map, int idx)
{
	FILE *fp;
	const char *mnt;
	char path[PATH_MAX];
	int cpu, ret;

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

	cpu = map->map[idx];

	mnt = sysfs__mountpoint();
	if (!mnt)
		return -1;

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

	fp = fopen(path, "r");
	if (!fp)
		return -1;
	ret = fscanf(fp, "%d", &cpu);
	fclose(fp);
	return ret == 1 ? cpu : -1;
}

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

static int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
			      int (*f)(struct cpu_map *map, int cpu))
{
	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);
		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);

	*res = c;
	return 0;
}

int cpu_map__get_core(struct cpu_map *map, int idx)
{
	FILE *fp;
	const char *mnt;
	char path[PATH_MAX];
	int cpu, ret, s;

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

	cpu = map->map[idx];

	mnt = sysfs__mountpoint();
	if (!mnt)
		return -1;

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

	fp = fopen(path, "r");
	if (!fp)
		return -1;
	ret = fscanf(fp, "%d", &cpu);
	fclose(fp);
	if (ret != 1)
		return -1;

	s = cpu_map__get_socket(map, idx);
	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);
}

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);
}

/* 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/kernel_max", 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);
}

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;
}
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>
a12b51c4	8
60d567e2	9	static struct cpu_map *cpu_map__default_new(void)
a12b51c4	10	{
60d567e2 ACM	11	struct cpu_map *cpus;
60d567e2 ACM	12	int nr_cpus;
a12b51c4 PM	13
a12b51c4 PM	14	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
60d567e2 ACM	15	if (nr_cpus < 0)
	16	return NULL;
	17
	18	cpus = malloc(sizeof(cpus) + nr_cpus sizeof(int));
	19	if (cpus != NULL) {
	20	int i;
	21	for (i = 0; i < nr_cpus; ++i)
	22	cpus->map[i] = i;
a12b51c4	23
60d567e2 ACM	24	cpus->nr = nr_cpus;
60d567e2 ACM	25	}
a12b51c4	26
60d567e2	27	return cpus;
a12b51c4 PM	28	}
a12b51c4 PM	29
60d567e2	30	static struct cpu_map cpu_map__trim_new(int nr_cpus, int tmp_cpus)
a12b51c4	31	{
60d567e2 ACM	32	size_t payload_size = nr_cpus * sizeof(int);
	33	struct cpu_map cpus = malloc(sizeof(cpus) + payload_size);
	34
	35	if (cpus != NULL) {
	36	cpus->nr = nr_cpus;
	37	memcpy(cpus->map, tmp_cpus, payload_size);
	38	}
	39
	40	return cpus;
	41	}
	42
7ae92e74	43	struct cpu_map cpu_map__read(FILE file)
60d567e2 ACM	44	{
60d567e2 ACM	45	struct cpu_map *cpus = NULL;
a12b51c4	46	int nr_cpus = 0;
60d567e2 ACM	47	int tmp_cpus = NULL, tmp;
60d567e2 ACM	48	int max_entries = 0;
a12b51c4 PM	49	int n, cpu, prev;
	50	char sep;
	51
a12b51c4 PM	52	sep = 0;
	53	prev = -1;
	54	for (;;) {
7ae92e74	55	n = fscanf(file, "%u%c", &cpu, &sep);
a12b51c4 PM	56	if (n <= 0)
	57	break;
	58	if (prev >= 0) {
60d567e2 ACM	59	int new_max = nr_cpus + cpu - prev - 1;
	60
	61	if (new_max >= max_entries) {
	62	max_entries = new_max + MAX_NR_CPUS / 2;
	63	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	64	if (tmp == NULL)
	65	goto out_free_tmp;
	66	tmp_cpus = tmp;
	67	}
	68
a12b51c4	69	while (++prev < cpu)
60d567e2 ACM	70	tmp_cpus[nr_cpus++] = prev;
	71	}
	72	if (nr_cpus == max_entries) {
	73	max_entries += MAX_NR_CPUS;
	74	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	75	if (tmp == NULL)
	76	goto out_free_tmp;
	77	tmp_cpus = tmp;
a12b51c4	78	}
60d567e2 ACM	79
60d567e2 ACM	80	tmp_cpus[nr_cpus++] = cpu;
a12b51c4 PM	81	if (n == 2 && sep == '-')
	82	prev = cpu;
	83	else
	84	prev = -1;
	85	if (n == 1 \|\| sep == '\n')
	86	break;
	87	}
a12b51c4	88
60d567e2 ACM	89	if (nr_cpus > 0)
	90	cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	91	else
	92	cpus = cpu_map__default_new();
	93	out_free_tmp:
	94	free(tmp_cpus);
7ae92e74 YZ	95	return cpus;
	96	}
	97
	98	static struct cpu_map *cpu_map__read_all_cpu_map(void)
	99	{
	100	struct cpu_map *cpus = NULL;
	101	FILE *onlnf;
	102
	103	onlnf = fopen("/sys/devices/system/cpu/online", "r");
	104	if (!onlnf)
	105	return cpu_map__default_new();
	106
	107	cpus = cpu_map__read(onlnf);
60d567e2 ACM	108	fclose(onlnf);
60d567e2 ACM	109	return cpus;
a12b51c4	110	}
c45c6ea2	111
60d567e2	112	struct cpu_map cpu_map__new(const char cpu_list)
c45c6ea2	113	{
60d567e2	114	struct cpu_map *cpus = NULL;
c45c6ea2 SE	115	unsigned long start_cpu, end_cpu = 0;
	116	char *p = NULL;
	117	int i, nr_cpus = 0;
60d567e2 ACM	118	int tmp_cpus = NULL, tmp;
60d567e2 ACM	119	int max_entries = 0;
c45c6ea2 SE	120
c45c6ea2 SE	121	if (!cpu_list)
60d567e2	122	return cpu_map__read_all_cpu_map();
c45c6ea2 SE	123
c45c6ea2 SE	124	if (!isdigit(*cpu_list))
60d567e2	125	goto out;
c45c6ea2 SE	126
	127	while (isdigit(*cpu_list)) {
	128	p = NULL;
	129	start_cpu = strtoul(cpu_list, &p, 0);
	130	if (start_cpu >= INT_MAX
	131	\|\| (p != '\0' && p != ',' && *p != '-'))
	132	goto invalid;
	133
	134	if (*p == '-') {
	135	cpu_list = ++p;
	136	p = NULL;
	137	end_cpu = strtoul(cpu_list, &p, 0);
	138
	139	if (end_cpu >= INT_MAX \|\| (p != '\0' && p != ','))
	140	goto invalid;
	141
	142	if (end_cpu < start_cpu)
	143	goto invalid;
	144	} else {
	145	end_cpu = start_cpu;
	146	}
	147
	148	for (; start_cpu <= end_cpu; start_cpu++) {
	149	/* check for duplicates */
	150	for (i = 0; i < nr_cpus; i++)
60d567e2	151	if (tmp_cpus[i] == (int)start_cpu)
c45c6ea2 SE	152	goto invalid;
c45c6ea2 SE	153
60d567e2 ACM	154	if (nr_cpus == max_entries) {
	155	max_entries += MAX_NR_CPUS;
	156	tmp = realloc(tmp_cpus, max_entries * sizeof(int));
	157	if (tmp == NULL)
	158	goto invalid;
	159	tmp_cpus = tmp;
	160	}
	161	tmp_cpus[nr_cpus++] = (int)start_cpu;
c45c6ea2 SE	162	}
	163	if (*p)
	164	++p;
	165
	166	cpu_list = p;
	167	}
c45c6ea2	168
60d567e2 ACM	169	if (nr_cpus > 0)
	170	cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
	171	else
	172	cpus = cpu_map__default_new();
c45c6ea2	173	invalid:
60d567e2 ACM	174	free(tmp_cpus);
	175	out:
	176	return cpus;
	177	}
	178
9ae7d335 ACM	179	size_t cpu_map__fprintf(struct cpu_map map, FILE fp)
	180	{
	181	int i;
	182	size_t printed = fprintf(fp, "%d cpu%s: ",
	183	map->nr, map->nr > 1 ? "s" : "");
	184	for (i = 0; i < map->nr; ++i)
	185	printed += fprintf(fp, "%s%d", i ? ", " : "", map->map[i]);
	186
	187	return printed + fprintf(fp, "\n");
	188	}
	189
60d567e2 ACM	190	struct cpu_map *cpu_map__dummy_new(void)
	191	{
	192	struct cpu_map cpus = malloc(sizeof(cpus) + sizeof(int));
	193
	194	if (cpus != NULL) {
	195	cpus->nr = 1;
	196	cpus->map[0] = -1;
	197	}
	198
	199	return cpus;
c45c6ea2	200	}
915fce20 ACM	201
	202	void cpu_map__delete(struct cpu_map *map)
	203	{
	204	free(map);
	205	}
5ac59a8a SE	206
	207	int cpu_map__get_socket(struct cpu_map *map, int idx)
	208	{
	209	FILE *fp;
	210	const char *mnt;
	211	char path[PATH_MAX];
	212	int cpu, ret;
	213
	214	if (idx > map->nr)
	215	return -1;
	216
	217	cpu = map->map[idx];
	218
cf38fada	219	mnt = sysfs__mountpoint();
5ac59a8a SE	220	if (!mnt)
	221	return -1;
	222
86ee6e18	223	snprintf(path, PATH_MAX,
5ac59a8a SE	224	"%s/devices/system/cpu/cpu%d/topology/physical_package_id",
	225	mnt, cpu);
	226
	227	fp = fopen(path, "r");
	228	if (!fp)
	229	return -1;
	230	ret = fscanf(fp, "%d", &cpu);
	231	fclose(fp);
	232	return ret == 1 ? cpu : -1;
	233	}
	234
86ee6e18	235	static int cmp_ids(const void a, const void b)
5ac59a8a	236	{
86ee6e18 SE	237	return (int )a - (int )b;
	238	}
	239
	240	static int cpu_map__build_map(struct cpu_map cpus, struct cpu_map *res,
	241	int (f)(struct cpu_map map, int cpu))
	242	{
	243	struct cpu_map *c;
5ac59a8a SE	244	int nr = cpus->nr;
	245	int cpu, s1, s2;
	246
86ee6e18 SE	247	/* allocate as much as possible */
	248	c = calloc(1, sizeof(c) + nr sizeof(int));
	249	if (!c)
5ac59a8a SE	250	return -1;
	251
	252	for (cpu = 0; cpu < nr; cpu++) {
86ee6e18 SE	253	s1 = f(cpus, cpu);
	254	for (s2 = 0; s2 < c->nr; s2++) {
	255	if (s1 == c->map[s2])
5ac59a8a SE	256	break;
5ac59a8a SE	257	}
86ee6e18 SE	258	if (s2 == c->nr) {
	259	c->map[c->nr] = s1;
	260	c->nr++;
5ac59a8a SE	261	}
5ac59a8a SE	262	}
86ee6e18 SE	263	/* ensure we process id in increasing order */
	264	qsort(c->map, c->nr, sizeof(int), cmp_ids);
	265
	266	*res = c;
5ac59a8a SE	267	return 0;
5ac59a8a SE	268	}
86ee6e18	269
12c08a9f SE	270	int cpu_map__get_core(struct cpu_map *map, int idx)
	271	{
	272	FILE *fp;
	273	const char *mnt;
	274	char path[PATH_MAX];
	275	int cpu, ret, s;
	276
	277	if (idx > map->nr)
	278	return -1;
	279
	280	cpu = map->map[idx];
	281
cf38fada	282	mnt = sysfs__mountpoint();
12c08a9f SE	283	if (!mnt)
	284	return -1;
	285
	286	snprintf(path, PATH_MAX,
	287	"%s/devices/system/cpu/cpu%d/topology/core_id",
	288	mnt, cpu);
	289
	290	fp = fopen(path, "r");
	291	if (!fp)
	292	return -1;
	293	ret = fscanf(fp, "%d", &cpu);
	294	fclose(fp);
	295	if (ret != 1)
	296	return -1;
	297
	298	s = cpu_map__get_socket(map, idx);
	299	if (s == -1)
	300	return -1;
	301
	302	/*
	303	* encode socket in upper 16 bits
	304	* core_id is relative to socket, and
	305	* we need a global id. So we combine
	306	* socket+ core id
	307	*/
	308	return (s << 16) \| (cpu & 0xffff);
	309	}
	310
86ee6e18 SE	311	int cpu_map__build_socket_map(struct cpu_map cpus, struct cpu_map *sockp)
	312	{
	313	return cpu_map__build_map(cpus, sockp, cpu_map__get_socket);
	314	}
12c08a9f SE	315
	316	int cpu_map__build_core_map(struct cpu_map cpus, struct cpu_map *corep)
	317	{
	318	return cpu_map__build_map(cpus, corep, cpu_map__get_core);
	319	}
7780c25b DZ	320
	321	/* setup simple routines to easily access node numbers given a cpu number */
	322	static int get_max_num(char path, int max)
	323	{
	324	size_t num;
	325	char *buf;
	326	int err = 0;
	327
	328	if (filename__read_str(path, &buf, &num))
	329	return -1;
	330
	331	buf[num] = '\0';
	332
	333	/* start on the right, to find highest node num */
	334	while (--num) {
	335	if ((buf[num] == ',') \|\| (buf[num] == '-')) {
	336	num++;
	337	break;
	338	}
	339	}
	340	if (sscanf(&buf[num], "%d", max) < 1) {
	341	err = -1;
	342	goto out;
	343	}
	344
	345	/* convert from 0-based to 1-based */
	346	(*max)++;
	347
	348	out:
	349	free(buf);
	350	return err;
	351	}
	352
	353	/* Determine highest possible cpu in the system for sparse allocation */
	354	static void set_max_cpu_num(void)
	355	{
	356	const char *mnt;
	357	char path[PATH_MAX];
	358	int ret = -1;
	359
	360	/* set up default */
	361	max_cpu_num = 4096;
	362
	363	mnt = sysfs__mountpoint();
	364	if (!mnt)
	365	goto out;
	366
	367	/* get the highest possible cpu number for a sparse allocation */
	368	ret = snprintf(path, PATH_MAX, "%s/devices/system/cpu/kernel_max", mnt);
	369	if (ret == PATH_MAX) {
	370	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
	371	goto out;
	372	}
	373
	374	ret = get_max_num(path, &max_cpu_num);
	375
	376	out:
	377	if (ret)
	378	pr_err("Failed to read max cpus, using default of %d\n", max_cpu_num);
	379	}
	380
	381	/* Determine highest possible node in the system for sparse allocation */
	382	static void set_max_node_num(void)
	383	{
384	const char *mnt;
385	char path[PATH_MAX];
386	int ret = -1;
387
388	/* set up default */
389	max_node_num = 8;
390
391	mnt = sysfs__mountpoint();
392	if (!mnt)
393	goto out;
394
395	/* get the highest possible cpu number for a sparse allocation */
396	ret = snprintf(path, PATH_MAX, "%s/devices/system/node/possible", mnt);
397	if (ret == PATH_MAX) {
398	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
399	goto out;
400	}
401
402	ret = get_max_num(path, &max_node_num);
403
404	out:
405	if (ret)
406	pr_err("Failed to read max nodes, using default of %d\n", max_node_num);
407	}
408
409	static int init_cpunode_map(void)
410	{
411	int i;
412
413	set_max_cpu_num();
414	set_max_node_num();
415
416	cpunode_map = calloc(max_cpu_num, sizeof(int));
417	if (!cpunode_map) {
418	pr_err("%s: calloc failed\n", __func__);
419	return -1;
420	}
421
422	for (i = 0; i < max_cpu_num; i++)
423	cpunode_map[i] = -1;
424
425	return 0;
426	}
427
428	int cpu__setup_cpunode_map(void)
429	{
430	struct dirent dent1, dent2;
431	DIR dir1, dir2;
432	unsigned int cpu, mem;
433	char buf[PATH_MAX];
434	char path[PATH_MAX];
435	const char *mnt;
436	int n;
437
438	/* initialize globals */
439	if (init_cpunode_map())
440	return -1;
441
442	mnt = sysfs__mountpoint();
443	if (!mnt)
444	return 0;
445
446	n = snprintf(path, PATH_MAX, "%s/devices/system/node", mnt);
447	if (n == PATH_MAX) {
448	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
449	return -1;
450	}
451
452	dir1 = opendir(path);
453	if (!dir1)
454	return 0;
455
456	/* walk tree and setup map */
457	while ((dent1 = readdir(dir1)) != NULL) {
458	if (dent1->d_type != DT_DIR \|\| sscanf(dent1->d_name, "node%u", &mem) < 1)
459	continue;
460
461	n = snprintf(buf, PATH_MAX, "%s/%s", path, dent1->d_name);
462	if (n == PATH_MAX) {
463	pr_err("sysfs path crossed PATH_MAX(%d) size\n", PATH_MAX);
464	continue;
465	}
466
467	dir2 = opendir(buf);
468	if (!dir2)
469	continue;
470	while ((dent2 = readdir(dir2)) != NULL) {
471	if (dent2->d_type != DT_LNK \|\| sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
472	continue;
473	cpunode_map[cpu] = mem;
474	}
475	closedir(dir2);
476	}
477	closedir(dir1);
478	return 0;
479	}