Permalink
Fetching contributors…
Cannot retrieve contributors at this time
213 lines (178 sloc) 4.69 KB
/*
* Copyright (C) 2006, Intel Corporation
* Copyright (C) 2012, Neil Horman <nhorman@tuxdriver.com>
*
* This file is part of irqbalance
*
* This program file is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program in a file named COPYING; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA
*/
/*
* This file tries to map numa affinity of pci devices to their interrupts
* In addition the PCI class information is used to refine the classification
* of interrupt sources
*/
#include "config.h"
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <sys/types.h>
#include <dirent.h>
#include "irqbalance.h"
#define SYSFS_NODE_PATH "/sys/devices/system/node"
GList *numa_nodes = NULL;
static struct topo_obj unspecified_node_template = {
.load = 0,
.number = -1,
.obj_type = OBJ_TYPE_NODE,
.mask = CPU_MASK_ALL,
.interrupts = NULL,
.children = NULL,
.parent = NULL,
.obj_type_list = &numa_nodes,
};
static struct topo_obj unspecified_node;
static void add_one_node(const char *nodename)
{
char path[PATH_MAX];
struct topo_obj *new;
char *cpustr = NULL;
FILE *f;
ssize_t ret;
size_t blen;
new = calloc(1, sizeof(struct topo_obj));
if (!new)
return;
sprintf(path, "%s/%s/cpumap", SYSFS_NODE_PATH, nodename);
f = fopen(path, "r");
if (!f) {
free(new);
return;
}
if (ferror(f)) {
cpus_clear(new->mask);
} else {
ret = getline(&cpustr, &blen, f);
if (ret <= 0) {
cpus_clear(new->mask);
} else {
cpumask_parse_user(cpustr, ret, new->mask);
free(cpustr);
}
}
fclose(f);
new->obj_type = OBJ_TYPE_NODE;
new->number = strtoul(&nodename[4], NULL, 10);
new->obj_type_list = &numa_nodes;
numa_nodes = g_list_append(numa_nodes, new);
}
void build_numa_node_list(void)
{
DIR *dir;
struct dirent *entry;
/*
* Note that we copy the unspcified node from the template here
* in the event we just freed the object tree during a rescan.
* This ensures we don't get stale list pointers anywhere
*/
memcpy(&unspecified_node, &unspecified_node_template, sizeof (struct topo_obj));
/*
* Add the unspecified node
*/
numa_nodes = g_list_append(numa_nodes, &unspecified_node);
if (!numa_avail)
return;
dir = opendir(SYSFS_NODE_PATH);
if (!dir)
return;
do {
entry = readdir(dir);
if (!entry)
break;
if ((entry->d_type == DT_DIR) &&
(strncmp(entry->d_name, "node", 4) == 0) &&
isdigit(entry->d_name[4])) {
add_one_node(entry->d_name);
}
} while (entry);
closedir(dir);
}
static void free_numa_node(gpointer data)
{
struct topo_obj *obj = data;
g_list_free(obj->children);
g_list_free(obj->interrupts);
if (data != &unspecified_node)
free(data);
}
void free_numa_node_list(void)
{
g_list_free_full(numa_nodes, free_numa_node);
numa_nodes = NULL;
}
static gint compare_node(gconstpointer a, gconstpointer b)
{
const struct topo_obj *ai = a;
const struct topo_obj *bi = b;
return (ai->number == bi->number) ? 0 : 1;
}
void connect_cpu_mem_topo(struct topo_obj *p, void *data __attribute__((unused)))
{
GList *entry;
struct topo_obj *node;
struct topo_obj *lchild;
int len;
len = g_list_length(p->numa_nodes);
if (len == 0) {
return;
} else if (len > 1) {
for_each_object(p->children, connect_cpu_mem_topo, NULL);
return;
}
entry = g_list_first(p->numa_nodes);
node = entry->data;
if (p->obj_type == OBJ_TYPE_PACKAGE && !p->parent)
p->parent = node;
entry = g_list_first(node->children);
while (entry) {
lchild = entry->data;
if (lchild == p)
break;
entry = g_list_next(entry);
}
if (!entry)
node->children = g_list_append(node->children, p);
}
void dump_numa_node_info(struct topo_obj *d, void *unused __attribute__((unused)))
{
char buffer[4096];
log(TO_CONSOLE, LOG_INFO, "NUMA NODE NUMBER: %d\n", d->number);
cpumask_scnprintf(buffer, 4096, d->mask);
log(TO_CONSOLE, LOG_INFO, "LOCAL CPU MASK: %s\n", buffer);
log(TO_CONSOLE, LOG_INFO, "\n");
}
struct topo_obj *get_numa_node(int nodeid)
{
struct topo_obj find;
GList *entry;
if (!numa_avail)
return &unspecified_node;
if (nodeid == -1)
return &unspecified_node;
find.number = nodeid;
entry = g_list_find_custom(numa_nodes, &find, compare_node);
return entry ? entry->data : NULL;
}