1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
#include <errno.h>
#include <inttypes.h>
#include <asm/bug.h>
#include <linux/bitmap.h>
#include "mem2node.h"
#include "util.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_ON_ONCE(j == 0))
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;
}
|
