mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-29 20:11:16 +00:00
Introduce a mock of virNumaGetNodeOfCPU() because soon we will need virNumaCPUSetToNodeset() to return predictable results. Also, fill in missing symlinks in vircaps2xmldata/. Signed-off-by: Michal Privoznik <mprivozn@redhat.com> Reviewed-by: Kristina Hanicova <khanicov@redhat.com> Reviewed-by: Andrea Bolognani <abologna@redhat.com>
216 lines
5.3 KiB
C
216 lines
5.3 KiB
C
/*
|
|
* virnumamock.c: Mock some virNuma functions using sysfs
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include "internal.h"
|
|
#include "virnuma.h"
|
|
#include "virfile.h"
|
|
#include "virstring.h"
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_NONE
|
|
|
|
#define SYSFS_SYSTEM_PATH "/sys/devices/system"
|
|
|
|
static int numa_avail = -1;
|
|
|
|
|
|
/*
|
|
* Poor man's mocked NUMA guesser. We basically check if
|
|
* /sys/devices/system/node (where /sys/devices/system can already be mocked or
|
|
* changed in the tests) exists and cache the result.
|
|
*/
|
|
bool
|
|
virNumaIsAvailable(void)
|
|
{
|
|
if (numa_avail < 0) {
|
|
g_autofree char *sysfs_node_path = NULL;
|
|
|
|
sysfs_node_path = g_strdup_printf("%s/node", SYSFS_SYSTEM_PATH);
|
|
|
|
numa_avail = virFileExists(sysfs_node_path);
|
|
}
|
|
|
|
/*
|
|
* Quite a few more things need to be mocked if NUMA is not available and
|
|
* you are using this file. Do not remove the abort() call below unless you
|
|
* make sure all under virCapabilitiesInitNUMAFake() is mocked (and whatever
|
|
* might have changed since this comment was added. You are welcome.
|
|
*/
|
|
if (!numa_avail)
|
|
abort();
|
|
|
|
return numa_avail;
|
|
}
|
|
|
|
int
|
|
virNumaGetMaxNode(void)
|
|
{
|
|
g_autoptr(virBitmap) map = NULL;
|
|
|
|
if (virFileReadValueBitmap(&map, "%s/node/online", SYSFS_SYSTEM_PATH) < 0)
|
|
return -1;
|
|
|
|
return virBitmapLastSetBit(map);
|
|
}
|
|
|
|
bool
|
|
virNumaNodeIsAvailable(int node)
|
|
{
|
|
g_autoptr(virBitmap) map = NULL;
|
|
|
|
if (virFileReadValueBitmap(&map, "%s/node/online", SYSFS_SYSTEM_PATH) < 0)
|
|
return false;
|
|
|
|
return virBitmapIsBitSet(map, node);
|
|
}
|
|
|
|
int
|
|
virNumaGetNodeMemory(int node,
|
|
unsigned long long *memsize,
|
|
unsigned long long *memfree)
|
|
{
|
|
const unsigned long long base = 1 << 30;
|
|
|
|
if (memsize)
|
|
*memsize = base * (node + 1);
|
|
|
|
if (memfree)
|
|
*memfree = base;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
virNumaGetDistances(int node G_GNUC_UNUSED,
|
|
int **distances,
|
|
int *ndistances)
|
|
{
|
|
*distances = NULL;
|
|
*ndistances = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* TODO: Adapt virNumaGetHugePageInfo{Path,Dir} to use sysfs so that the
|
|
* paths can be modified and this function can be thrown away and instead we'd
|
|
* have copied info from /sys (as we do with /sys/devices/system).
|
|
*/
|
|
int
|
|
virNumaGetPages(int node,
|
|
unsigned int **pages_size,
|
|
unsigned long long **pages_avail,
|
|
unsigned long long **pages_free,
|
|
size_t *npages)
|
|
{
|
|
const int pages_def[] = { 4, 2 * 1024, 1 * 1024 * 1024};
|
|
const int npages_def = G_N_ELEMENTS(pages_def);
|
|
size_t i = 0;
|
|
|
|
if (pages_size)
|
|
*pages_size = g_new0(unsigned int, npages_def);
|
|
|
|
if (pages_avail)
|
|
*pages_avail = g_new0(unsigned long long, npages_def);
|
|
|
|
if (pages_free)
|
|
*pages_free = g_new0(unsigned long long, npages_def);
|
|
|
|
*npages = npages_def;
|
|
if (pages_size)
|
|
memcpy(*pages_size, pages_def, sizeof(pages_def));
|
|
|
|
node++;
|
|
if (node <= 0)
|
|
node = 32;
|
|
|
|
if (pages_avail || pages_free) {
|
|
for (i = 0; i < *npages; i++) {
|
|
if (pages_avail)
|
|
(*pages_avail)[i] = (node + i) * 2 << 10;
|
|
if (pages_free)
|
|
(*pages_free)[i] = (node + i) * 1 << 10;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
virNumaGetNodeCPUs(int node, virBitmap **cpus)
|
|
{
|
|
g_autofree char *cpulist = NULL;
|
|
|
|
if (virFileReadValueString(&cpulist,
|
|
"%s/node/node%u/cpulist",
|
|
SYSFS_SYSTEM_PATH, node) < 0)
|
|
return -1;
|
|
|
|
if (STREQ(cpulist, "")) {
|
|
unsigned int max_n_cpus = virNumaGetMaxCPUs();
|
|
*cpus = virBitmapNew(max_n_cpus);
|
|
} else {
|
|
*cpus = virBitmapParseUnlimited(cpulist);
|
|
}
|
|
if (!*cpus)
|
|
return -1;
|
|
|
|
return virBitmapCountBits(*cpus);
|
|
}
|
|
|
|
int
|
|
virNumaGetNodeOfCPU(int cpu)
|
|
{
|
|
g_autoptr(DIR) cpuDir = NULL;
|
|
g_autofree char *sysfs_cpu_path = NULL;
|
|
struct dirent *ent = NULL;
|
|
int dirErr = 0;
|
|
|
|
sysfs_cpu_path = g_strdup_printf("%s/cpu/cpu%d", SYSFS_SYSTEM_PATH, cpu);
|
|
|
|
if (virDirOpen(&cpuDir, sysfs_cpu_path) < 0)
|
|
return -1;
|
|
|
|
while ((dirErr = virDirRead(cpuDir, &ent, sysfs_cpu_path)) > 0) {
|
|
g_autofree char *entPath = NULL;
|
|
const char *number = NULL;
|
|
int node;
|
|
|
|
if (!(number = STRSKIP(ent->d_name, "node")))
|
|
continue;
|
|
|
|
entPath = g_strdup_printf("%s/%s", sysfs_cpu_path, ent->d_name);
|
|
|
|
if (!virFileIsLink(entPath))
|
|
continue;
|
|
|
|
if (virStrToLong_i(number, NULL, 10, &node) < 0) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
if (dirErr < 0)
|
|
return -1;
|
|
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|