linux/tools/perf/util/mem2node.c
Leo Yan 0ee281e1e4 perf mem2node: Improve warning if detected no memory nodes
Some archs (e.g. x86 and Arm64) don't enable the configuration
CONFIG_MEMORY_HOTPLUG by default, if this configuration is not enabled
when build the kernel image, the SysFS for memory nodes will be missed.
This results in perf tool has no chance to catpure the memory nodes
information, when perf tool reports the result and detects no memory
nodes, it outputs "assertion failed at util/mem2node.c:99".

The output log doesn't give out reason for the failure and users have no
clue for how to fix it.  This patch changes to use explicit way for
warning: it tells user that detected no memory nodes and suggests to
enable CONFIG_MEMORY_HOTPLUG for kernel building.

Signed-off-by: Leo Yan <leo.yan@linaro.org>
Acked-by: Jiri Olsa <jolsa@redhat.com>
Link: https://lore.kernel.org/r/20201019003613.8399-1-leo.yan@linaro.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2020-11-04 09:42:40 -03:00

140 lines
2.8 KiB
C

#include <errno.h>
#include <inttypes.h>
#include <asm/bug.h>
#include <linux/bitmap.h>
#include <linux/kernel.h>
#include <linux/zalloc.h>
#include "debug.h"
#include "env.h"
#include "mem2node.h"
struct phys_entry {
struct rb_node rb_node;
u64 start;
u64 end;
u64 node;
};
static void phys_entry__insert(struct phys_entry *entry, struct rb_root *root)
{
struct rb_node **p = &root->rb_node;
struct rb_node *parent = NULL;
struct phys_entry *e;
while (*p != NULL) {
parent = *p;
e = rb_entry(parent, struct phys_entry, rb_node);
if (entry->start < e->start)
p = &(*p)->rb_left;
else
p = &(*p)->rb_right;
}
rb_link_node(&entry->rb_node, parent, p);
rb_insert_color(&entry->rb_node, root);
}
static void
phys_entry__init(struct phys_entry *entry, u64 start, u64 bsize, u64 node)
{
entry->start = start;
entry->end = start + bsize;
entry->node = node;
RB_CLEAR_NODE(&entry->rb_node);
}
int mem2node__init(struct mem2node *map, struct perf_env *env)
{
struct memory_node *n, *nodes = &env->memory_nodes[0];
struct phys_entry *entries, *tmp_entries;
u64 bsize = env->memory_bsize;
int i, j = 0, max = 0;
memset(map, 0x0, sizeof(*map));
map->root = RB_ROOT;
for (i = 0; i < env->nr_memory_nodes; i++) {
n = &nodes[i];
max += bitmap_weight(n->set, n->size);
}
entries = zalloc(sizeof(*entries) * max);
if (!entries)
return -ENOMEM;
for (i = 0; i < env->nr_memory_nodes; i++) {
u64 bit;
n = &nodes[i];
for (bit = 0; bit < n->size; bit++) {
u64 start;
if (!test_bit(bit, n->set))
continue;
start = bit * bsize;
/*
* Merge nearby areas, we walk in order
* through the bitmap, so no need to sort.
*/
if (j > 0) {
struct phys_entry *prev = &entries[j - 1];
if ((prev->end == start) &&
(prev->node == n->node)) {
prev->end += bsize;
continue;
}
}
phys_entry__init(&entries[j++], start, bsize, n->node);
}
}
/* Cut unused entries, due to merging. */
tmp_entries = realloc(entries, sizeof(*entries) * j);
if (tmp_entries ||
WARN_ONCE(j == 0, "No memory nodes, is CONFIG_MEMORY_HOTPLUG enabled?\n"))
entries = tmp_entries;
for (i = 0; i < j; i++) {
pr_debug("mem2node %03" PRIu64 " [0x%016" PRIx64 "-0x%016" PRIx64 "]\n",
entries[i].node, entries[i].start, entries[i].end);
phys_entry__insert(&entries[i], &map->root);
}
map->entries = entries;
return 0;
}
void mem2node__exit(struct mem2node *map)
{
zfree(&map->entries);
}
int mem2node__node(struct mem2node *map, u64 addr)
{
struct rb_node **p, *parent = NULL;
struct phys_entry *entry;
p = &map->root.rb_node;
while (*p != NULL) {
parent = *p;
entry = rb_entry(parent, struct phys_entry, rb_node);
if (addr < entry->start)
p = &(*p)->rb_left;
else if (addr >= entry->end)
p = &(*p)->rb_right;
else
goto out;
}
entry = NULL;
out:
return entry ? (int) entry->node : -1;
}