2007-07-25 23:16:30 +00:00
|
|
|
/*
|
|
|
|
* nodeinfo.c: Helper routines for OS specific node information
|
|
|
|
*
|
2015-07-06 21:03:51 +00:00
|
|
|
* Copyright (C) 2006-2008, 2010-2015 Red Hat, Inc.
|
2007-07-25 23:16:30 +00:00
|
|
|
* Copyright (C) 2006 Daniel P. Berrange
|
|
|
|
*
|
|
|
|
* 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
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2007-07-25 23:16:30 +00:00
|
|
|
*
|
|
|
|
* Author: Daniel P. Berrange <berrange@redhat.com>
|
|
|
|
*/
|
|
|
|
|
2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-12-05 21:40:15 +00:00
|
|
|
|
2007-07-25 23:16:30 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
#include <stdint.h>
|
2007-07-25 23:16:30 +00:00
|
|
|
#include <errno.h>
|
2010-03-04 22:28:40 +00:00
|
|
|
#include <dirent.h>
|
2010-04-29 03:06:46 +00:00
|
|
|
#include <sys/utsname.h>
|
2012-03-02 02:54:22 +00:00
|
|
|
#include "conf/domain_conf.h"
|
nodeinfo: Fix output on PPC64 KVM hosts
The nodeinfo is reporting incorrect number of cpus and incorrect host
topology on PPC64 KVM hosts. The KVM hypervisor on PPC64 needs only
the primary thread in a core to be online, and the secondaries offlined.
While scheduling a guest in, the kvm scheduler wakes up the secondaries to
run in guest context.
The host scheduling of the guests happen at the core level(as only primary
thread is online). The kvm scheduler exploits as many threads of the core
as needed by guest. Further, starting POWER8, the processor allows splitting
a physical core into multiple subcores with 2 or 4 threads each. Again, only
the primary thread in a subcore is online in the host. The KVM-PPC
scheduler allows guests to exploit all the offline threads in the subcore,
by bringing them online when needed.
(Kernel patches on split-core http://www.spinics.net/lists/kvm-ppc/msg09121.html)
Recently with dynamic micro-threading changes in ppc-kvm, makes sure
to utilize all the offline cpus across guests, and across guests with
different cpu topologies.
(https://www.mail-archive.com/kvm@vger.kernel.org/msg115978.html)
Since the offline cpus are brought online in the guest context, it is safe
to count them as online. Nodeinfo today discounts these offline cpus from
cpu count/topology calclulation, and the nodeinfo output is not of any help
and the host appears overcommited when it is actually not.
The patch carefully counts those offline threads whose primary threads are
online. The host topology displayed by the nodeinfo is also fixed when the
host is in valid kvm state.
Signed-off-by: Shivaprasad G Bhat <sbhat@linux.vnet.ibm.com>
Signed-off-by: Andrea Bolognani <abologna@redhat.com>
2015-07-30 09:37:04 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/ioctl.h>
|
2015-12-20 07:27:21 +00:00
|
|
|
#include <unistd.h>
|
nodeinfo: Fix output on PPC64 KVM hosts
The nodeinfo is reporting incorrect number of cpus and incorrect host
topology on PPC64 KVM hosts. The KVM hypervisor on PPC64 needs only
the primary thread in a core to be online, and the secondaries offlined.
While scheduling a guest in, the kvm scheduler wakes up the secondaries to
run in guest context.
The host scheduling of the guests happen at the core level(as only primary
thread is online). The kvm scheduler exploits as many threads of the core
as needed by guest. Further, starting POWER8, the processor allows splitting
a physical core into multiple subcores with 2 or 4 threads each. Again, only
the primary thread in a subcore is online in the host. The KVM-PPC
scheduler allows guests to exploit all the offline threads in the subcore,
by bringing them online when needed.
(Kernel patches on split-core http://www.spinics.net/lists/kvm-ppc/msg09121.html)
Recently with dynamic micro-threading changes in ppc-kvm, makes sure
to utilize all the offline cpus across guests, and across guests with
different cpu topologies.
(https://www.mail-archive.com/kvm@vger.kernel.org/msg115978.html)
Since the offline cpus are brought online in the guest context, it is safe
to count them as online. Nodeinfo today discounts these offline cpus from
cpu count/topology calclulation, and the nodeinfo output is not of any help
and the host appears overcommited when it is actually not.
The patch carefully counts those offline threads whose primary threads are
online. The host topology displayed by the nodeinfo is also fixed when the
host is in valid kvm state.
Signed-off-by: Shivaprasad G Bhat <sbhat@linux.vnet.ibm.com>
Signed-off-by: Andrea Bolognani <abologna@redhat.com>
2015-07-30 09:37:04 +00:00
|
|
|
|
|
|
|
#if HAVE_LINUX_KVM_H
|
|
|
|
# include <linux/kvm.h>
|
|
|
|
#endif
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2013-10-05 05:56:37 +00:00
|
|
|
#if defined(__FreeBSD__) || defined(__APPLE__)
|
2014-01-28 17:49:24 +00:00
|
|
|
# include <sys/time.h>
|
2012-12-17 18:12:44 +00:00
|
|
|
# include <sys/types.h>
|
|
|
|
# include <sys/sysctl.h>
|
2014-01-28 17:49:24 +00:00
|
|
|
# include <sys/resource.h>
|
2012-12-17 18:12:44 +00:00
|
|
|
#endif
|
|
|
|
|
2012-12-12 18:06:53 +00:00
|
|
|
#include "viralloc.h"
|
2015-06-26 22:27:29 +00:00
|
|
|
#include "nodeinfo.h"
|
2016-04-13 17:53:02 +00:00
|
|
|
#include "virhostcpu.h"
|
Use gnulib, starting with its physmem and getaddrinfo modules.
New files go into these directories:
gnulib/lib
gnulib/m4
gnulib/tests
* bootstrap: A wrapper around gnulib-tool.
* configure.in: Invoke gl_EARLY and gl_INIT, being careful to put gl_EARLY
before any macro that uses AC_COMPILE_IFELSE.
(AC_OUTPUT): Add lib/Makefile and gl-tests/Makefile. Remove m4/Makefile.
* Makefile.am (SUBDIRS): Add gnulib/lib and remove m4. Add gnulib/tests
early enough that those tests run before any libvirt unit tests.
* m4/Makefile.am: Remove file. Not needed.
* src/Makefile.am (INCLUDES): Add -I$(top_srcdir)/gnulib/lib -I../gnulib/lib.
(LDADDS, libvirt_la_LIBADD): Add ../gnulib/lib/libgnu.la.
* src/nodeinfo.c: Include "physmem.h".
* qemud/qemud.c, src/remote_internal.c: Include "getaddrinfo.h".
(MEMINFO_PATH, linuxNodeInfoMemPopulate): Remove definitions.
(virNodeInfoPopulate): Use physmem_total, not linuxNodeInfoMemPopulate.
* tests/Makefile.am (INCLUDES): Add -I$(top_srcdir)/gnulib/lib -I../gnulib/lib.
(LDADDS): Add ../gnulib/lib/libgnu.la.
* qemud/Makefile.am (libvirtd_LDADD): Add ../gnulib/lib/libgnu.la.
* tests/nodeinfotest.c (linuxTestCompareFiles): No longer read total
memory from a file.
Update expected output not to include "Memory: NNNN"
* tests/nodeinfodata/linux-nodeinfo-1.txt:
* tests/nodeinfodata/linux-nodeinfo-2.txt:
* tests/nodeinfodata/linux-nodeinfo-3.txt:
* tests/nodeinfodata/linux-nodeinfo-4.txt:
* tests/nodeinfodata/linux-nodeinfo-5.txt:
* tests/nodeinfodata/linux-nodeinfo-6.txt:
* src/test.c [WITH_TEST]: Remove definition of _GNU_SOURCE that
would conflict with the one now in "config.h".
* autogen.sh: Add -I gnulib/m4.
* src/conf.c, src/sexpr.c: Don't define _GNU_SOURCE.
Instead, include "config.h".
* qemud/qemud.c: Remove definition of _GNU_SOURCE.
* src/openvz_driver.c: Likewise.
* src/qemu_driver.c: Likewise.
* src/remote_internal.c: Likewise.
* configure.in: Use AC_CONFIG_AUX_DIR(build-aux), so that a bunch
of gettextize-generated files go into build-aux/, rather than in
the top-level directory.
* .cvsignore: Adjust.
* build-aux/.cvsignore: New file.
Author: Jim Meyering <meyering@redhat.com>
2007-12-05 21:31:07 +00:00
|
|
|
#include "physmem.h"
|
2012-12-13 18:21:53 +00:00
|
|
|
#include "virerror.h"
|
2010-03-04 22:28:40 +00:00
|
|
|
#include "count-one-bits.h"
|
2010-08-10 21:33:37 +00:00
|
|
|
#include "intprops.h"
|
2012-12-10 21:58:16 +00:00
|
|
|
#include "virarch.h"
|
2011-07-19 18:32:58 +00:00
|
|
|
#include "virfile.h"
|
2012-09-14 14:42:16 +00:00
|
|
|
#include "virtypedparam.h"
|
2013-04-03 10:36:23 +00:00
|
|
|
#include "virstring.h"
|
2013-10-17 14:57:29 +00:00
|
|
|
#include "virnuma.h"
|
2014-06-17 10:25:23 +00:00
|
|
|
#include "virlog.h"
|
2009-01-20 17:13:33 +00:00
|
|
|
|
|
|
|
#define VIR_FROM_THIS VIR_FROM_NONE
|
|
|
|
|
2014-06-17 10:25:23 +00:00
|
|
|
VIR_LOG_INIT("nodeinfo");
|
|
|
|
|
2015-07-17 17:07:45 +00:00
|
|
|
|
2014-01-03 18:35:50 +00:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
# define BSD_MEMORY_STATS_ALL 4
|
|
|
|
|
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetStatsFreeBSD(virNodeMemoryStatsPtr params,
|
2015-07-14 09:40:14 +00:00
|
|
|
int *nparams)
|
2014-01-03 18:35:50 +00:00
|
|
|
{
|
|
|
|
size_t i, j = 0;
|
|
|
|
unsigned long pagesize = getpagesize() >> 10;
|
|
|
|
long bufpages;
|
|
|
|
size_t bufpages_size = sizeof(bufpages);
|
|
|
|
struct field_sysctl_map {
|
|
|
|
const char *field;
|
|
|
|
const char *sysctl_name;
|
|
|
|
} sysctl_map[] = {
|
|
|
|
{VIR_NODE_MEMORY_STATS_TOTAL, "vm.stats.vm.v_page_count"},
|
|
|
|
{VIR_NODE_MEMORY_STATS_FREE, "vm.stats.vm.v_free_count"},
|
|
|
|
{VIR_NODE_MEMORY_STATS_CACHED, "vm.stats.vm.v_cache_count"},
|
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
|
|
|
if ((*nparams) == 0) {
|
|
|
|
*nparams = BSD_MEMORY_STATS_ALL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*nparams) != BSD_MEMORY_STATS_ALL) {
|
|
|
|
virReportInvalidArg(nparams,
|
|
|
|
_("nparams in %s must be %d"),
|
|
|
|
__FUNCTION__, BSD_MEMORY_STATS_ALL);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; sysctl_map[i].field != NULL; i++) {
|
|
|
|
u_int value;
|
|
|
|
size_t value_size = sizeof(value);
|
|
|
|
virNodeMemoryStatsPtr param;
|
|
|
|
|
|
|
|
if (sysctlbyname(sysctl_map[i].sysctl_name, &value,
|
|
|
|
&value_size, NULL, 0) < 0) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("sysctl failed for '%s'"),
|
|
|
|
sysctl_map[i].sysctl_name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
param = ¶ms[j++];
|
|
|
|
if (virStrcpyStatic(param->field, sysctl_map[i].field) == NULL) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Field '%s' too long for destination"),
|
|
|
|
sysctl_map[i].field);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
param->value = (unsigned long long)value * pagesize;
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
virNodeMemoryStatsPtr param = ¶ms[j++];
|
|
|
|
|
|
|
|
if (sysctlbyname("vfs.bufspace", &bufpages, &bufpages_size, NULL, 0) < 0) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("sysctl failed for '%s'"),
|
|
|
|
"vfs.bufspace");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (virStrcpyStatic(param->field, VIR_NODE_MEMORY_STATS_BUFFERS) == NULL) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("Field '%s' too long for destination"),
|
|
|
|
VIR_NODE_MEMORY_STATS_BUFFERS);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
param->value = (unsigned long long)bufpages >> 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* __FreeBSD__ */
|
2012-12-17 18:12:44 +00:00
|
|
|
|
2007-07-25 23:16:30 +00:00
|
|
|
#ifdef __linux__
|
2016-04-13 14:28:55 +00:00
|
|
|
# define SYSFS_SYSTEM_PATH "/sys/devices/system"
|
2011-06-07 01:11:17 +00:00
|
|
|
# define MEMINFO_PATH "/proc/meminfo"
|
2012-09-14 14:42:16 +00:00
|
|
|
# define SYSFS_MEMORY_SHARED_PATH "/sys/kernel/mm/ksm"
|
2015-03-26 04:48:13 +00:00
|
|
|
# define SYSFS_THREAD_SIBLINGS_LIST_LENGTH_MAX 8192
|
2011-06-07 01:02:55 +00:00
|
|
|
|
2011-06-07 01:11:17 +00:00
|
|
|
# define LINUX_NB_MEMORY_STATS_ALL 4
|
|
|
|
# define LINUX_NB_MEMORY_STATS_CELL 2
|
2007-07-25 23:16:30 +00:00
|
|
|
|
2010-08-10 21:33:37 +00:00
|
|
|
/* Return the positive decimal contents of the given
|
2012-11-01 22:20:09 +00:00
|
|
|
* DIR/cpu%u/FILE, or -1 on error. If DEFAULT_VALUE is non-negative
|
|
|
|
* and the file could not be found, return that instead of an error;
|
|
|
|
* this is useful for machines that cannot hot-unplug cpu0, or where
|
|
|
|
* hot-unplugging is disabled, or where the kernel is too old
|
|
|
|
* to support NUMA cells, etc. */
|
2010-08-10 21:33:37 +00:00
|
|
|
static int
|
nodeinfo: drop static variable
We were wasting time to malloc a copy of a constant string, then
copy it into static storage, for every call to nodeGetInfo. At
least we were lucky that it was a constant source, and thus not
subject to even worse issues with one thread clobbering the static
storage while another was using it. This gets rid of the waste,
by passing the string through the stack instead, as well as renaming
internal functions to better match our conventions.
* src/nodeinfo.c (sysfs_path): Delete.
(get_cpu_value, count_thread_siblings, parse_socket): Add
parameter, and rename...
(virNodeGetCpuValue, virNodeCountThreadSiblings)
(virNodeParseSocket): ... into a common namespace.
(cpu_online, parse_core): Inline into callers.
(linuxNodeInfoCPUPopulate): Update caller.
(nodeGetInfo): Drop a useless malloc.
2012-05-11 18:50:08 +00:00
|
|
|
virNodeGetCpuValue(const char *dir, unsigned int cpu, const char *file,
|
2012-11-01 22:20:09 +00:00
|
|
|
int default_value)
|
2010-08-10 21:33:37 +00:00
|
|
|
{
|
|
|
|
char *path;
|
|
|
|
FILE *pathfp;
|
|
|
|
int value = -1;
|
|
|
|
char value_str[INT_BUFSIZE_BOUND(value)];
|
|
|
|
char *tmp;
|
|
|
|
|
2013-07-04 10:20:00 +00:00
|
|
|
if (virAsprintf(&path, "%s/cpu%u/%s", dir, cpu, file) < 0)
|
2010-08-10 21:33:37 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
pathfp = fopen(path, "r");
|
|
|
|
if (pathfp == NULL) {
|
2012-11-01 22:20:09 +00:00
|
|
|
if (default_value >= 0 && errno == ENOENT)
|
|
|
|
value = default_value;
|
2010-08-10 21:33:37 +00:00
|
|
|
else
|
|
|
|
virReportSystemError(errno, _("cannot open %s"), path);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fgets(value_str, sizeof(value_str), pathfp) == NULL) {
|
|
|
|
virReportSystemError(errno, _("cannot read from %s"), path);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
if (virStrToLong_i(value_str, &tmp, 10, &value) < 0) {
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("could not convert '%s' to an integer"),
|
|
|
|
value_str);
|
2010-08-10 21:33:37 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2010-11-17 02:13:29 +00:00
|
|
|
VIR_FORCE_FCLOSE(pathfp);
|
2010-08-10 21:33:37 +00:00
|
|
|
VIR_FREE(path);
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2011-06-07 01:11:17 +00:00
|
|
|
|
2013-10-15 13:44:48 +00:00
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetStatsLinux(FILE *meminfo,
|
2013-10-15 13:44:48 +00:00
|
|
|
int cellNum,
|
|
|
|
virNodeMemoryStatsPtr params,
|
|
|
|
int *nparams)
|
2011-06-07 01:11:17 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
Convert 'int i' to 'size_t i' in src/node_device/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i = 0, j = 0, k = 0;
|
2011-06-07 01:11:17 +00:00
|
|
|
int found = 0;
|
|
|
|
int nr_param;
|
|
|
|
char line[1024];
|
2011-06-15 10:39:57 +00:00
|
|
|
char meminfo_hdr[VIR_NODE_MEMORY_STATS_FIELD_LENGTH];
|
2011-06-07 01:11:17 +00:00
|
|
|
unsigned long val;
|
|
|
|
struct field_conv {
|
|
|
|
const char *meminfo_hdr; // meminfo header
|
|
|
|
const char *field; // MemoryStats field name
|
|
|
|
} field_conv[] = {
|
2011-06-15 10:39:57 +00:00
|
|
|
{"MemTotal:", VIR_NODE_MEMORY_STATS_TOTAL},
|
|
|
|
{"MemFree:", VIR_NODE_MEMORY_STATS_FREE},
|
|
|
|
{"Buffers:", VIR_NODE_MEMORY_STATS_BUFFERS},
|
|
|
|
{"Cached:", VIR_NODE_MEMORY_STATS_CACHED},
|
2011-06-07 01:11:17 +00:00
|
|
|
{NULL, NULL}
|
|
|
|
};
|
|
|
|
|
2011-06-15 10:39:57 +00:00
|
|
|
if (cellNum == VIR_NODE_MEMORY_STATS_ALL_CELLS) {
|
2011-06-07 01:11:17 +00:00
|
|
|
nr_param = LINUX_NB_MEMORY_STATS_ALL;
|
|
|
|
} else {
|
|
|
|
nr_param = LINUX_NB_MEMORY_STATS_CELL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*nparams) == 0) {
|
|
|
|
/* Current number of memory stats supported by linux */
|
|
|
|
*nparams = nr_param;
|
|
|
|
ret = 0;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((*nparams) != nr_param) {
|
Santize the reporting of VIR_ERR_INVALID_ERROR
To ensure consistent error reporting of invalid arguments,
provide a number of predefined helper methods & macros.
- An arg which must not be NULL:
virCheckNonNullArgReturn(argname, retvalue)
virCheckNonNullArgGoto(argname, label)
- An arg which must be NULL
virCheckNullArgGoto(argname, label)
- An arg which must be positive (ie 1 or greater)
virCheckPositiveArgGoto(argname, label)
- An arg which must not be 0
virCheckNonZeroArgGoto(argname, label)
- An arg which must be zero
virCheckZeroArgGoto(argname, label)
- An arg which must not be negative (ie 0 or greater)
virCheckNonNegativeArgGoto(argname, label)
* src/libvirt.c, src/libvirt-qemu.c,
src/nodeinfo.c, src/datatypes.c: Update to use
virCheckXXXX macros
* po/POTFILES.in: Add libvirt-qemu.c and virterror_internal.h
* src/internal.h: Define macros for checking invalid args
* src/util/virterror_internal.h: Define macros for reporting
invalid args
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-05-25 17:41:07 +00:00
|
|
|
virReportInvalidArg(nparams,
|
|
|
|
_("nparams in %s must be %d"),
|
|
|
|
__FUNCTION__, nr_param);
|
2011-06-07 01:11:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (fgets(line, sizeof(line), meminfo) != NULL) {
|
|
|
|
char *buf = line;
|
|
|
|
|
|
|
|
if (STRPREFIX(buf, "Node ")) {
|
|
|
|
/*
|
|
|
|
* /sys/devices/system/node/nodeX/meminfo format is below.
|
|
|
|
* So, skip prefix "Node XX ".
|
|
|
|
*
|
|
|
|
* Node 0 MemTotal: 8386980 kB
|
|
|
|
* Node 0 MemFree: 5300920 kB
|
|
|
|
* :
|
|
|
|
*/
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
p = buf;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
p = strchr(p, ' ');
|
|
|
|
if (p == NULL) {
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("no prefix found"));
|
2011-06-07 01:11:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
buf = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sscanf(buf, "%s %lu kB", meminfo_hdr, &val) < 2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; field_conv[j].meminfo_hdr != NULL; j++) {
|
|
|
|
struct field_conv *convp = &field_conv[j];
|
|
|
|
|
|
|
|
if (STREQ(meminfo_hdr, convp->meminfo_hdr)) {
|
2011-06-15 10:39:57 +00:00
|
|
|
virNodeMemoryStatsPtr param = ¶ms[k++];
|
2011-06-07 01:11:17 +00:00
|
|
|
|
|
|
|
if (virStrcpyStatic(param->field, convp->field) == NULL) {
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("Field kernel memory too long for destination"));
|
2011-06-07 01:11:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
param->value = val;
|
|
|
|
found++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (found >= nr_param)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found == 0) {
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"%s", _("no available memory line found"));
|
2011-06-07 01:11:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2011-06-07 01:02:55 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2012-03-02 02:54:22 +00:00
|
|
|
|
2013-11-07 00:09:26 +00:00
|
|
|
|
|
|
|
static virBitmapPtr
|
2016-04-13 17:16:16 +00:00
|
|
|
virNodeGetSiblingsListLinux(const char *dir, int cpu_id)
|
2013-11-07 00:09:26 +00:00
|
|
|
{
|
|
|
|
char *path = NULL;
|
|
|
|
char *buf = NULL;
|
|
|
|
virBitmapPtr ret = NULL;
|
|
|
|
|
|
|
|
if (virAsprintf(&path, "%s/cpu%u/topology/thread_siblings_list",
|
|
|
|
dir, cpu_id) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (virFileReadAll(path, SYSFS_THREAD_SIBLINGS_LIST_LENGTH_MAX, &buf) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (virBitmapParse(buf, 0, &ret, virNumaGetMaxCPUs()) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2013-11-07 00:09:26 +00:00
|
|
|
VIR_FREE(buf);
|
|
|
|
VIR_FREE(path);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-07-25 23:16:30 +00:00
|
|
|
#endif
|
|
|
|
|
2016-04-13 16:28:10 +00:00
|
|
|
|
2016-04-13 16:45:22 +00:00
|
|
|
int
|
|
|
|
nodeGetInfo(virNodeInfoPtr nodeinfo)
|
|
|
|
{
|
|
|
|
virArch hostarch = virArchFromHost();
|
|
|
|
unsigned long long memorybytes;
|
|
|
|
|
|
|
|
memset(nodeinfo, 0, sizeof(*nodeinfo));
|
|
|
|
|
|
|
|
if (virStrcpyStatic(nodeinfo->model, virArchToString(hostarch)) == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2016-04-13 17:16:16 +00:00
|
|
|
if (virHostMemGetInfo(&memorybytes, NULL) < 0)
|
2016-04-13 16:45:22 +00:00
|
|
|
return -1;
|
|
|
|
nodeinfo->memory = memorybytes / 1024;
|
|
|
|
|
2016-04-13 17:16:16 +00:00
|
|
|
if (virHostCPUGetInfo(hostarch,
|
|
|
|
&nodeinfo->cpus, &nodeinfo->mhz,
|
|
|
|
&nodeinfo->nodes, &nodeinfo->sockets,
|
|
|
|
&nodeinfo->cores, &nodeinfo->threads) < 0)
|
2016-04-13 16:45:22 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-06-07 01:02:55 +00:00
|
|
|
|
2015-07-14 09:40:14 +00:00
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetStats(int cellNum ATTRIBUTE_UNUSED,
|
2015-07-14 09:40:14 +00:00
|
|
|
virNodeMemoryStatsPtr params ATTRIBUTE_UNUSED,
|
|
|
|
int *nparams ATTRIBUTE_UNUSED,
|
|
|
|
unsigned int flags)
|
2011-06-07 01:11:17 +00:00
|
|
|
{
|
|
|
|
virCheckFlags(0, -1);
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
char *meminfo_path = NULL;
|
|
|
|
FILE *meminfo;
|
2013-10-17 15:42:22 +00:00
|
|
|
int max_node;
|
2011-06-07 01:11:17 +00:00
|
|
|
|
2011-06-15 10:39:57 +00:00
|
|
|
if (cellNum == VIR_NODE_MEMORY_STATS_ALL_CELLS) {
|
2013-05-03 12:52:48 +00:00
|
|
|
if (VIR_STRDUP(meminfo_path, MEMINFO_PATH) < 0)
|
2011-06-07 01:11:17 +00:00
|
|
|
return -1;
|
|
|
|
} else {
|
2013-10-17 15:42:22 +00:00
|
|
|
if ((max_node = virNumaGetMaxNode()) < 0)
|
2011-06-07 01:11:17 +00:00
|
|
|
return -1;
|
|
|
|
|
2013-10-17 15:42:22 +00:00
|
|
|
if (cellNum > max_node) {
|
Santize the reporting of VIR_ERR_INVALID_ERROR
To ensure consistent error reporting of invalid arguments,
provide a number of predefined helper methods & macros.
- An arg which must not be NULL:
virCheckNonNullArgReturn(argname, retvalue)
virCheckNonNullArgGoto(argname, label)
- An arg which must be NULL
virCheckNullArgGoto(argname, label)
- An arg which must be positive (ie 1 or greater)
virCheckPositiveArgGoto(argname, label)
- An arg which must not be 0
virCheckNonZeroArgGoto(argname, label)
- An arg which must be zero
virCheckZeroArgGoto(argname, label)
- An arg which must not be negative (ie 0 or greater)
virCheckNonNegativeArgGoto(argname, label)
* src/libvirt.c, src/libvirt-qemu.c,
src/nodeinfo.c, src/datatypes.c: Update to use
virCheckXXXX macros
* po/POTFILES.in: Add libvirt-qemu.c and virterror_internal.h
* src/internal.h: Define macros for checking invalid args
* src/util/virterror_internal.h: Define macros for reporting
invalid args
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-05-25 17:41:07 +00:00
|
|
|
virReportInvalidArg(cellNum,
|
|
|
|
_("cellNum in %s must be less than or equal to %d"),
|
2013-10-17 15:42:22 +00:00
|
|
|
__FUNCTION__, max_node);
|
2011-06-07 01:11:17 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-04-13 14:28:55 +00:00
|
|
|
if (virAsprintf(&meminfo_path,
|
|
|
|
SYSFS_SYSTEM_PATH "/node/node%d/meminfo",
|
|
|
|
cellNum) < 0)
|
2011-06-07 01:11:17 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
meminfo = fopen(meminfo_path, "r");
|
|
|
|
|
|
|
|
if (!meminfo) {
|
|
|
|
virReportSystemError(errno,
|
|
|
|
_("cannot open %s"), meminfo_path);
|
|
|
|
VIR_FREE(meminfo_path);
|
|
|
|
return -1;
|
|
|
|
}
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetStatsLinux(meminfo, cellNum, params, nparams);
|
2011-06-07 01:11:17 +00:00
|
|
|
VIR_FORCE_FCLOSE(meminfo);
|
|
|
|
VIR_FREE(meminfo_path);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2014-01-03 18:35:50 +00:00
|
|
|
#elif defined(__FreeBSD__)
|
2016-04-13 17:16:16 +00:00
|
|
|
return virHostMemGetStatsFreeBSD(params, nparams);
|
2011-06-07 01:11:17 +00:00
|
|
|
#else
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("node memory stats not implemented on this platform"));
|
2011-06-07 01:11:17 +00:00
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-03-02 02:54:22 +00:00
|
|
|
|
2012-09-18 23:04:50 +00:00
|
|
|
#ifdef __linux__
|
2012-09-14 14:42:16 +00:00
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemSetParameterValue(virTypedParameterPtr param)
|
2012-09-14 14:42:16 +00:00
|
|
|
{
|
|
|
|
char *path = NULL;
|
|
|
|
char *strval = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
int rc = -1;
|
|
|
|
|
2012-11-28 14:11:06 +00:00
|
|
|
char *field = strchr(param->field, '_');
|
2013-01-22 22:09:23 +00:00
|
|
|
sa_assert(field);
|
2012-11-28 14:11:06 +00:00
|
|
|
field++;
|
2012-09-14 14:42:16 +00:00
|
|
|
if (virAsprintf(&path, "%s/%s",
|
|
|
|
SYSFS_MEMORY_SHARED_PATH, field) < 0) {
|
|
|
|
ret = -2;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virAsprintf(&strval, "%u", param->value.ui) == -1) {
|
|
|
|
ret = -2;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((rc = virFileWriteStr(path, strval, 0)) < 0) {
|
2012-11-28 14:11:06 +00:00
|
|
|
virReportSystemError(-rc, _("failed to set %s"), param->field);
|
2012-09-14 14:42:16 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2012-09-14 14:42:16 +00:00
|
|
|
VIR_FREE(path);
|
|
|
|
VIR_FREE(strval);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-11-28 14:11:06 +00:00
|
|
|
|
|
|
|
static bool
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemParametersAreAllSupported(virTypedParameterPtr params,
|
|
|
|
int nparams)
|
2012-11-28 14:11:06 +00:00
|
|
|
{
|
|
|
|
char *path = NULL;
|
Convert 'int i' to 'size_t i' in src/node_device/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
2012-11-28 14:11:06 +00:00
|
|
|
|
|
|
|
for (i = 0; i < nparams; i++) {
|
|
|
|
virTypedParameterPtr param = ¶ms[i];
|
|
|
|
|
|
|
|
char *field = strchr(param->field, '_');
|
2013-01-22 22:09:23 +00:00
|
|
|
sa_assert(field);
|
2012-11-28 14:11:06 +00:00
|
|
|
field++;
|
|
|
|
if (virAsprintf(&path, "%s/%s",
|
2013-07-04 10:20:00 +00:00
|
|
|
SYSFS_MEMORY_SHARED_PATH, field) < 0)
|
2012-11-28 14:11:06 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!virFileExists(path)) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_INVALID,
|
|
|
|
_("Parameter '%s' is not supported by "
|
|
|
|
"this kernel"), param->field);
|
|
|
|
VIR_FREE(path);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
VIR_FREE(path);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2012-09-18 23:04:50 +00:00
|
|
|
#endif
|
2012-09-14 14:42:16 +00:00
|
|
|
|
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemSetParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
|
2012-09-17 14:05:48 +00:00
|
|
|
int nparams ATTRIBUTE_UNUSED,
|
2012-09-14 14:42:16 +00:00
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
virCheckFlags(0, -1);
|
|
|
|
|
|
|
|
#ifdef __linux__
|
Convert 'int i' to 'size_t i' in src/node_device/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
2012-11-28 14:11:06 +00:00
|
|
|
int rc;
|
2012-09-14 14:42:16 +00:00
|
|
|
|
2013-05-03 13:34:10 +00:00
|
|
|
if (virTypedParamsValidate(params, nparams,
|
|
|
|
VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
|
|
|
|
VIR_TYPED_PARAM_UINT,
|
|
|
|
VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
|
|
|
|
VIR_TYPED_PARAM_UINT,
|
|
|
|
VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES,
|
|
|
|
VIR_TYPED_PARAM_UINT,
|
|
|
|
NULL) < 0)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
2016-04-13 17:16:16 +00:00
|
|
|
if (!virHostMemParametersAreAllSupported(params, nparams))
|
2012-11-28 14:11:06 +00:00
|
|
|
return -1;
|
2012-09-14 14:42:16 +00:00
|
|
|
|
2012-11-28 14:11:06 +00:00
|
|
|
for (i = 0; i < nparams; i++) {
|
2016-04-13 17:16:16 +00:00
|
|
|
rc = virHostMemSetParameterValue(¶ms[i]);
|
2012-10-12 08:25:42 +00:00
|
|
|
|
2014-11-07 10:27:00 +00:00
|
|
|
if (rc < 0)
|
2012-11-28 14:11:06 +00:00
|
|
|
return -1;
|
2012-09-14 14:42:16 +00:00
|
|
|
}
|
|
|
|
|
2012-11-28 14:11:06 +00:00
|
|
|
return 0;
|
2012-09-14 14:42:16 +00:00
|
|
|
#else
|
|
|
|
virReportError(VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("node set memory parameters not implemented"
|
|
|
|
" on this platform"));
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-09-18 23:04:50 +00:00
|
|
|
#ifdef __linux__
|
2012-09-14 14:42:16 +00:00
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetParameterValue(const char *field,
|
2012-09-14 14:42:16 +00:00
|
|
|
void *value)
|
|
|
|
{
|
|
|
|
char *path = NULL;
|
|
|
|
char *buf = NULL;
|
|
|
|
char *tmp = NULL;
|
|
|
|
int ret = -1;
|
|
|
|
int rc = -1;
|
|
|
|
|
|
|
|
if (virAsprintf(&path, "%s/%s",
|
2013-07-04 10:20:00 +00:00
|
|
|
SYSFS_MEMORY_SHARED_PATH, field) < 0)
|
2012-09-14 14:42:16 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2012-11-28 14:11:06 +00:00
|
|
|
if (!virFileExists(path)) {
|
|
|
|
ret = -2;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2012-09-14 14:42:16 +00:00
|
|
|
if (virFileReadAll(path, 1024, &buf) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if ((tmp = strchr(buf, '\n')))
|
|
|
|
*tmp = '\0';
|
|
|
|
|
2012-10-12 08:25:42 +00:00
|
|
|
if (STREQ(field, "pages_to_scan") ||
|
|
|
|
STREQ(field, "sleep_millisecs") ||
|
|
|
|
STREQ(field, "merge_across_nodes"))
|
2012-09-14 14:42:16 +00:00
|
|
|
rc = virStrToLong_ui(buf, NULL, 10, (unsigned int *)value);
|
|
|
|
else if (STREQ(field, "pages_shared") ||
|
|
|
|
STREQ(field, "pages_sharing") ||
|
|
|
|
STREQ(field, "pages_unshared") ||
|
|
|
|
STREQ(field, "pages_volatile") ||
|
|
|
|
STREQ(field, "full_scans"))
|
|
|
|
rc = virStrToLong_ull(buf, NULL, 10, (unsigned long long *)value);
|
|
|
|
|
|
|
|
if (rc < 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("failed to parse %s"), field);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2012-09-14 14:42:16 +00:00
|
|
|
VIR_FREE(path);
|
|
|
|
VIR_FREE(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
2012-09-18 23:04:50 +00:00
|
|
|
#endif
|
2012-09-14 14:42:16 +00:00
|
|
|
|
2012-10-12 08:25:42 +00:00
|
|
|
#define NODE_MEMORY_PARAMETERS_NUM 8
|
2012-09-14 14:42:16 +00:00
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
|
2012-09-17 14:05:48 +00:00
|
|
|
int *nparams ATTRIBUTE_UNUSED,
|
2012-09-14 14:42:16 +00:00
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
|
|
|
|
|
|
|
|
#ifdef __linux__
|
|
|
|
unsigned int pages_to_scan;
|
|
|
|
unsigned int sleep_millisecs;
|
2012-10-12 08:25:42 +00:00
|
|
|
unsigned int merge_across_nodes;
|
2012-09-14 14:42:16 +00:00
|
|
|
unsigned long long pages_shared;
|
|
|
|
unsigned long long pages_sharing;
|
|
|
|
unsigned long long pages_unshared;
|
|
|
|
unsigned long long pages_volatile;
|
|
|
|
unsigned long long full_scans = 0;
|
Convert 'int i' to 'size_t i' in src/node_device/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
2012-11-28 14:11:06 +00:00
|
|
|
int ret;
|
2012-09-14 14:42:16 +00:00
|
|
|
|
|
|
|
if ((*nparams) == 0) {
|
|
|
|
*nparams = NODE_MEMORY_PARAMETERS_NUM;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < *nparams && i < NODE_MEMORY_PARAMETERS_NUM; i++) {
|
|
|
|
virTypedParameterPtr param = ¶ms[i];
|
|
|
|
|
2012-10-17 09:23:12 +00:00
|
|
|
switch (i) {
|
2012-09-14 14:42:16 +00:00
|
|
|
case 0:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("pages_to_scan", &pages_to_scan);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
|
|
|
|
VIR_TYPED_PARAM_UINT, pages_to_scan) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("sleep_millisecs", &sleep_millisecs);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
|
|
|
|
VIR_TYPED_PARAM_UINT, sleep_millisecs) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 2:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("pages_shared", &pages_shared);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARED,
|
|
|
|
VIR_TYPED_PARAM_ULLONG, pages_shared) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("pages_sharing", &pages_sharing);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARING,
|
|
|
|
VIR_TYPED_PARAM_ULLONG, pages_sharing) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 4:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("pages_unshared", &pages_unshared);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED,
|
|
|
|
VIR_TYPED_PARAM_ULLONG, pages_unshared) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 5:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("pages_volatile", &pages_volatile);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE,
|
|
|
|
VIR_TYPED_PARAM_ULLONG, pages_volatile) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 6:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("full_scans", &full_scans);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-09-14 14:42:16 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_FULL_SCANS,
|
|
|
|
VIR_TYPED_PARAM_ULLONG, full_scans) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
2012-10-12 08:25:42 +00:00
|
|
|
case 7:
|
2016-04-13 17:16:16 +00:00
|
|
|
ret = virHostMemGetParameterValue("merge_across_nodes", &merge_across_nodes);
|
2012-11-28 14:11:06 +00:00
|
|
|
if (ret == -2)
|
|
|
|
continue;
|
|
|
|
else if (ret == -1)
|
2012-10-12 08:25:42 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_MERGE_ACROSS_NODES,
|
|
|
|
VIR_TYPED_PARAM_UINT, merge_across_nodes) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
break;
|
2012-09-14 14:42:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
virReportError(VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("node get memory parameters not implemented"
|
|
|
|
" on this platform"));
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-10-16 14:05:14 +00:00
|
|
|
|
2013-04-03 20:11:15 +00:00
|
|
|
static int
|
2016-04-13 14:28:55 +00:00
|
|
|
nodeCapsInitNUMAFake(const char *cpupath ATTRIBUTE_UNUSED,
|
2015-07-07 21:22:28 +00:00
|
|
|
virCapsPtr caps ATTRIBUTE_UNUSED)
|
2013-04-03 20:11:15 +00:00
|
|
|
{
|
|
|
|
virNodeInfo nodeinfo;
|
|
|
|
virCapsHostNUMACellCPUPtr cpus;
|
|
|
|
int ncpus;
|
|
|
|
int s, c, t;
|
2015-05-26 16:40:34 +00:00
|
|
|
int id, cid;
|
|
|
|
int onlinecpus ATTRIBUTE_UNUSED;
|
2013-04-03 20:11:15 +00:00
|
|
|
|
2016-04-13 14:28:55 +00:00
|
|
|
if (nodeGetInfo(&nodeinfo) < 0)
|
2013-04-03 20:11:15 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
ncpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
|
2015-05-26 16:40:34 +00:00
|
|
|
onlinecpus = nodeinfo.cpus;
|
2013-04-03 20:11:15 +00:00
|
|
|
|
2013-07-04 10:20:00 +00:00
|
|
|
if (VIR_ALLOC_N(cpus, ncpus) < 0)
|
2013-04-03 20:11:15 +00:00
|
|
|
return -1;
|
|
|
|
|
2015-05-26 16:40:34 +00:00
|
|
|
id = cid = 0;
|
2013-05-21 08:08:42 +00:00
|
|
|
for (s = 0; s < nodeinfo.sockets; s++) {
|
|
|
|
for (c = 0; c < nodeinfo.cores; c++) {
|
|
|
|
for (t = 0; t < nodeinfo.threads; t++) {
|
2015-05-26 16:40:34 +00:00
|
|
|
#ifdef __linux__
|
2015-07-07 21:22:28 +00:00
|
|
|
if (virNodeGetCpuValue(cpupath, id, "online", 1)) {
|
2015-05-26 16:40:34 +00:00
|
|
|
#endif
|
|
|
|
cpus[cid].id = id;
|
|
|
|
cpus[cid].socket_id = s;
|
|
|
|
cpus[cid].core_id = c;
|
|
|
|
if (!(cpus[cid].siblings = virBitmapNew(ncpus)))
|
|
|
|
goto error;
|
|
|
|
ignore_value(virBitmapSetBit(cpus[cid].siblings, id));
|
|
|
|
cid++;
|
|
|
|
#ifdef __linux__
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-04-03 20:11:15 +00:00
|
|
|
id++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virCapabilitiesAddHostNUMACell(caps, 0,
|
|
|
|
nodeinfo.memory,
|
2015-05-26 16:40:34 +00:00
|
|
|
#ifdef __linux__
|
|
|
|
onlinecpus, cpus,
|
|
|
|
#else
|
2014-06-03 13:18:27 +00:00
|
|
|
ncpus, cpus,
|
2015-05-26 16:40:34 +00:00
|
|
|
#endif
|
2014-06-06 16:12:51 +00:00
|
|
|
0, NULL,
|
2014-06-03 13:18:27 +00:00
|
|
|
0, NULL) < 0)
|
2013-04-03 20:11:15 +00:00
|
|
|
goto error;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
2013-05-21 08:08:42 +00:00
|
|
|
for (; id >= 0; id--)
|
2013-04-03 20:11:15 +00:00
|
|
|
virBitmapFree(cpus[id].siblings);
|
|
|
|
VIR_FREE(cpus);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetCellsFreeFake(unsigned long long *freeMems,
|
2013-04-03 20:11:15 +00:00
|
|
|
int startCell,
|
|
|
|
int maxCells ATTRIBUTE_UNUSED)
|
|
|
|
{
|
|
|
|
double avail = physmem_available();
|
|
|
|
|
|
|
|
if (startCell != 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("start cell %d out of range (0-%d)"),
|
|
|
|
startCell, 0);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
freeMems[0] = (unsigned long long)avail;
|
|
|
|
|
|
|
|
if (!freeMems[0]) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("Cannot determine free memory"));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
static int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetInfoFake(unsigned long long *mem,
|
|
|
|
unsigned long long *freeMem)
|
2013-04-03 20:11:15 +00:00
|
|
|
{
|
2014-06-16 12:02:34 +00:00
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (mem) {
|
|
|
|
double total = physmem_total();
|
|
|
|
if (!total) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("Cannot determine free memory"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2013-04-03 20:11:15 +00:00
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
*mem = (unsigned long long) total;
|
2013-04-03 20:11:15 +00:00
|
|
|
}
|
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
if (freeMem) {
|
|
|
|
double avail = physmem_available();
|
|
|
|
|
|
|
|
if (!avail) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("Cannot determine free memory"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
*freeMem = (unsigned long long) avail;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
2013-04-03 20:11:15 +00:00
|
|
|
}
|
|
|
|
|
2013-01-18 22:06:55 +00:00
|
|
|
/* returns 1 on success, 0 if the detection failed and -1 on hard error */
|
|
|
|
static int
|
2015-07-07 21:22:28 +00:00
|
|
|
virNodeCapsFillCPUInfo(const char *cpupath ATTRIBUTE_UNUSED,
|
|
|
|
int cpu_id ATTRIBUTE_UNUSED,
|
2013-11-07 00:09:26 +00:00
|
|
|
virCapsHostNUMACellCPUPtr cpu ATTRIBUTE_UNUSED)
|
2013-01-18 22:06:55 +00:00
|
|
|
{
|
2013-11-07 00:09:26 +00:00
|
|
|
#ifdef __linux__
|
2013-01-18 22:06:55 +00:00
|
|
|
int tmp;
|
|
|
|
cpu->id = cpu_id;
|
|
|
|
|
2015-07-07 21:22:28 +00:00
|
|
|
if ((tmp = virNodeGetCpuValue(cpupath, cpu_id,
|
2013-01-18 22:06:55 +00:00
|
|
|
"topology/physical_package_id", -1)) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu->socket_id = tmp;
|
|
|
|
|
2015-07-07 21:22:28 +00:00
|
|
|
if ((tmp = virNodeGetCpuValue(cpupath, cpu_id,
|
2013-01-18 22:06:55 +00:00
|
|
|
"topology/core_id", -1)) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cpu->core_id = tmp;
|
|
|
|
|
2016-04-13 17:16:16 +00:00
|
|
|
if (!(cpu->siblings = virNodeGetSiblingsListLinux(cpupath, cpu_id)))
|
2013-01-18 22:06:55 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
2013-11-07 00:09:26 +00:00
|
|
|
#else
|
|
|
|
virReportError(VIR_ERR_NO_SUPPORT, "%s",
|
|
|
|
_("node cpu info not implemented on this platform"));
|
|
|
|
return -1;
|
|
|
|
#endif
|
2013-01-18 22:06:55 +00:00
|
|
|
}
|
|
|
|
|
2014-06-03 13:18:27 +00:00
|
|
|
static int
|
|
|
|
virNodeCapsGetSiblingInfo(int node,
|
|
|
|
virCapsHostNUMACellSiblingInfoPtr *siblings,
|
|
|
|
int *nsiblings)
|
|
|
|
{
|
|
|
|
virCapsHostNUMACellSiblingInfoPtr tmp = NULL;
|
|
|
|
int tmp_size = 0;
|
|
|
|
int ret = -1;
|
|
|
|
int *distances = NULL;
|
|
|
|
int ndistances = 0;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
if (virNumaGetDistances(node, &distances, &ndistances) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (!distances) {
|
|
|
|
*siblings = NULL;
|
|
|
|
*nsiblings = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_ALLOC_N(tmp, ndistances) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
for (i = 0; i < ndistances; i++) {
|
|
|
|
if (!distances[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
tmp[tmp_size].node = i;
|
|
|
|
tmp[tmp_size].distance = distances[i];
|
|
|
|
tmp_size++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VIR_REALLOC_N(tmp, tmp_size) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
*siblings = tmp;
|
|
|
|
*nsiblings = tmp_size;
|
|
|
|
tmp = NULL;
|
|
|
|
tmp_size = 0;
|
|
|
|
ret = 0;
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(distances);
|
|
|
|
VIR_FREE(tmp);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-06 16:12:51 +00:00
|
|
|
static int
|
|
|
|
virNodeCapsGetPagesInfo(int node,
|
|
|
|
virCapsHostNUMACellPageInfoPtr *pageinfo,
|
|
|
|
int *npageinfo)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
unsigned int *pages_size = NULL, *pages_avail = NULL;
|
|
|
|
size_t npages, i;
|
|
|
|
|
|
|
|
if (virNumaGetPages(node, &pages_size, &pages_avail, NULL, &npages) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (VIR_ALLOC_N(*pageinfo, npages) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
*npageinfo = npages;
|
|
|
|
|
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
(*pageinfo)[i].size = pages_size[i];
|
|
|
|
(*pageinfo)[i].avail = pages_avail[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
VIR_FREE(pages_avail);
|
|
|
|
VIR_FREE(pages_size);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
int
|
2016-04-13 14:28:55 +00:00
|
|
|
nodeCapsInitNUMA(virCapsPtr caps)
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
{
|
|
|
|
int n;
|
2013-03-07 16:03:36 +00:00
|
|
|
unsigned long long memory;
|
2013-01-22 17:42:08 +00:00
|
|
|
virCapsHostNUMACellCPUPtr cpus = NULL;
|
2013-10-18 14:21:24 +00:00
|
|
|
virBitmapPtr cpumap = NULL;
|
2014-06-03 13:18:27 +00:00
|
|
|
virCapsHostNUMACellSiblingInfoPtr siblings = NULL;
|
2014-06-10 22:23:09 +00:00
|
|
|
int nsiblings = 0;
|
2014-06-06 16:12:51 +00:00
|
|
|
virCapsHostNUMACellPageInfoPtr pageinfo = NULL;
|
|
|
|
int npageinfo;
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
int ret = -1;
|
2013-01-22 17:42:08 +00:00
|
|
|
int ncpus = 0;
|
2013-10-18 14:21:24 +00:00
|
|
|
int cpu;
|
2013-01-18 22:06:55 +00:00
|
|
|
bool topology_failed = false;
|
2013-10-17 15:42:22 +00:00
|
|
|
int max_node;
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2015-07-07 21:22:28 +00:00
|
|
|
if (!virNumaIsAvailable()) {
|
2016-04-13 14:28:55 +00:00
|
|
|
ret = nodeCapsInitNUMAFake(SYSFS_SYSTEM_PATH "/cpu", caps);
|
2015-07-07 21:22:28 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2013-10-17 15:42:22 +00:00
|
|
|
if ((max_node = virNumaGetMaxNode()) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
for (n = 0; n <= max_node; n++) {
|
Convert 'int i' to 'size_t i' in src/node_device/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 14:09:33 +00:00
|
|
|
size_t i;
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2013-10-18 14:21:24 +00:00
|
|
|
if ((ncpus = virNumaGetNodeCPUs(n, &cpumap)) < 0) {
|
|
|
|
if (ncpus == -2)
|
|
|
|
continue;
|
2013-03-07 16:03:36 +00:00
|
|
|
|
2013-10-18 14:21:24 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
|
|
|
if (VIR_ALLOC_N(cpus, ncpus) < 0)
|
|
|
|
goto cleanup;
|
2013-10-18 14:21:24 +00:00
|
|
|
cpu = 0;
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2013-10-18 14:21:24 +00:00
|
|
|
for (i = 0; i < virBitmapSize(cpumap); i++) {
|
2015-03-11 15:41:57 +00:00
|
|
|
if (virBitmapIsBitSet(cpumap, i)) {
|
2016-04-13 14:28:55 +00:00
|
|
|
if (virNodeCapsFillCPUInfo(SYSFS_SYSTEM_PATH "/cpu",
|
|
|
|
i, cpus + cpu++) < 0) {
|
2013-01-18 22:06:55 +00:00
|
|
|
topology_failed = true;
|
|
|
|
virResetLastError();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
|
2014-06-03 13:18:27 +00:00
|
|
|
if (virNodeCapsGetSiblingInfo(n, &siblings, &nsiblings) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2014-06-06 16:12:51 +00:00
|
|
|
if (virNodeCapsGetPagesInfo(n, &pageinfo, &npageinfo) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2013-10-18 14:21:24 +00:00
|
|
|
/* Detect the amount of memory in the numa cell in KiB */
|
|
|
|
virNumaGetNodeMemory(n, &memory, NULL);
|
|
|
|
memory >>= 10;
|
|
|
|
|
2014-06-03 13:18:27 +00:00
|
|
|
if (virCapabilitiesAddHostNUMACell(caps, n, memory,
|
|
|
|
ncpus, cpus,
|
2014-06-06 16:12:51 +00:00
|
|
|
nsiblings, siblings,
|
|
|
|
npageinfo, pageinfo) < 0)
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
goto cleanup;
|
2013-10-18 14:21:24 +00:00
|
|
|
|
|
|
|
cpus = NULL;
|
2014-06-03 13:18:27 +00:00
|
|
|
siblings = NULL;
|
2014-06-06 16:12:51 +00:00
|
|
|
pageinfo = NULL;
|
2014-08-20 13:59:25 +00:00
|
|
|
virBitmapFree(cpumap);
|
|
|
|
cpumap = NULL;
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2014-09-04 21:00:30 +00:00
|
|
|
if ((topology_failed || ret < 0) && cpus)
|
2013-01-18 22:06:55 +00:00
|
|
|
virCapabilitiesClearHostNUMACellCPUTopology(cpus, ncpus);
|
|
|
|
|
2013-10-18 14:21:24 +00:00
|
|
|
virBitmapFree(cpumap);
|
|
|
|
VIR_FREE(cpus);
|
2014-06-03 13:18:27 +00:00
|
|
|
VIR_FREE(siblings);
|
2014-06-06 16:12:51 +00:00
|
|
|
VIR_FREE(pageinfo);
|
make NUMA-initialization code more portable and more robust
qemudCapsInitNUMA and umlCapsInitNUMA were identical, so this change
factors them into a new function, virCapsInitNUMA, and puts it in
nodeinfo.c.
In addition to factoring out the duplicates, this change also
adjusts that function definition (along with its macros) so
that it works with Fedora 9's numactl version 1, and makes it
so the code will work even if someone builds the kernel with
CONFIG_NR_CPUS > 4096.
Finally, also perform this NUMA initialization for the lxc
and openvz drivers.
* src/nodeinfo.c: Include <stdint.h>, <numa.h> and "memory.h".
(virCapsInitNUMA): Rename from qemudCapsInitNUMA and umlCapsInitNUMA.
(NUMA_MAX_N_CPUS): Define depending on NUMA API version.
(n_bits, MASK_CPU_ISSET): Define, adjust, use uint64 rather than long.
* src/nodeinfo.h: Include "capabilities.h".
(virCapsInitNUMA): Declare it.
* examples/domain-events/events-c/Makefile.am:
* src/Makefile.am: Add $(NUMACTL_CFLAGS) and $(NUMACTL_LIBS) to various
compile/link-related variables.
* src/qemu_conf.c: Include "nodeinfo.h".
(qemudCapsInitNUMA): Remove duplicate code. Adjust caller.
* src/uml_conf.c (umlCapsInitNUMA): Likewise.
Include "nodeinfo.h".
* src/lxc_conf.c: Include "nodeinfo.h".
(lxcCapsInit): Perform NUMA initialization here, too.
* src/openvz_conf.c (openvzCapsInit): And here.
Include "nodeinfo.h".
* src/libvirt_sym.version.in: Add virCapsInitNUMA so that libvirtd
can link to this function.
2008-12-21 18:55:09 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2009-06-03 13:28:02 +00:00
|
|
|
|
|
|
|
|
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetCellsFree(unsigned long long *freeMems,
|
2009-06-03 13:28:02 +00:00
|
|
|
int startCell,
|
|
|
|
int maxCells)
|
|
|
|
{
|
2013-10-17 16:30:09 +00:00
|
|
|
unsigned long long mem;
|
2009-06-03 13:28:02 +00:00
|
|
|
int n, lastCell, numCells;
|
|
|
|
int ret = -1;
|
|
|
|
int maxCell;
|
|
|
|
|
2013-10-17 14:57:29 +00:00
|
|
|
if (!virNumaIsAvailable())
|
2016-04-13 17:16:16 +00:00
|
|
|
return virHostMemGetCellsFreeFake(freeMems,
|
2013-04-03 20:11:15 +00:00
|
|
|
startCell, maxCells);
|
|
|
|
|
2013-10-17 15:42:22 +00:00
|
|
|
if ((maxCell = virNumaGetMaxNode()) < 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-06-03 13:28:02 +00:00
|
|
|
if (startCell > maxCell) {
|
2012-07-18 18:19:23 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("start cell %d out of range (0-%d)"),
|
|
|
|
startCell, maxCell);
|
2009-06-03 13:28:02 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
lastCell = startCell + maxCells - 1;
|
|
|
|
if (lastCell > maxCell)
|
|
|
|
lastCell = maxCell;
|
|
|
|
|
2013-05-21 08:08:42 +00:00
|
|
|
for (numCells = 0, n = startCell; n <= lastCell; n++) {
|
2013-10-17 16:30:09 +00:00
|
|
|
virNumaGetNodeMemory(n, NULL, &mem);
|
2013-07-08 14:03:05 +00:00
|
|
|
|
2009-06-03 13:28:02 +00:00
|
|
|
freeMems[numCells++] = mem;
|
|
|
|
}
|
|
|
|
ret = numCells;
|
|
|
|
|
2014-03-25 06:57:22 +00:00
|
|
|
cleanup:
|
2009-06-03 13:28:02 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetInfo(unsigned long long *mem,
|
|
|
|
unsigned long long *freeMem)
|
2009-06-03 13:28:02 +00:00
|
|
|
{
|
2013-10-17 15:42:22 +00:00
|
|
|
int max_node;
|
2009-06-03 13:28:02 +00:00
|
|
|
int n;
|
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
if (mem)
|
|
|
|
*mem = 0;
|
|
|
|
|
|
|
|
if (freeMem)
|
|
|
|
*freeMem = 0;
|
|
|
|
|
2013-10-17 14:57:29 +00:00
|
|
|
if (!virNumaIsAvailable())
|
2016-04-13 17:16:16 +00:00
|
|
|
return virHostMemGetInfoFake(mem, freeMem);
|
2013-04-03 20:11:15 +00:00
|
|
|
|
2013-10-17 15:42:22 +00:00
|
|
|
if ((max_node = virNumaGetMaxNode()) < 0)
|
2014-06-16 12:02:34 +00:00
|
|
|
return -1;
|
2009-06-03 13:28:02 +00:00
|
|
|
|
2013-10-17 15:42:22 +00:00
|
|
|
for (n = 0; n <= max_node; n++) {
|
2014-06-16 12:02:34 +00:00
|
|
|
unsigned long long tmp_mem = 0, tmp_freeMem = 0;
|
|
|
|
|
|
|
|
if (!virNumaNodeIsAvailable(n))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (virNumaGetNodeMemory(n, &tmp_mem, &tmp_freeMem) < 0)
|
|
|
|
return -1;
|
2013-07-08 14:03:05 +00:00
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
if (mem)
|
|
|
|
*mem += tmp_mem;
|
|
|
|
|
|
|
|
if (freeMem)
|
|
|
|
*freeMem += tmp_freeMem;
|
2009-06-03 13:28:02 +00:00
|
|
|
}
|
|
|
|
|
2014-06-16 12:02:34 +00:00
|
|
|
return 0;
|
2009-06-03 13:28:02 +00:00
|
|
|
}
|
2014-06-10 14:16:44 +00:00
|
|
|
|
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemGetFreePages(unsigned int npages,
|
|
|
|
unsigned int *pages,
|
|
|
|
int startCell,
|
|
|
|
unsigned int cellCount,
|
|
|
|
unsigned long long *counts)
|
2014-06-10 14:16:44 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
2014-09-22 10:14:27 +00:00
|
|
|
int cell, lastCell;
|
2014-06-10 14:16:44 +00:00
|
|
|
size_t i, ncounts = 0;
|
|
|
|
|
2014-09-22 10:14:27 +00:00
|
|
|
if ((lastCell = virNumaGetMaxNode()) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (startCell > lastCell) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("start cell %d out of range (0-%d)"),
|
|
|
|
startCell, lastCell);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2014-09-24 13:10:18 +00:00
|
|
|
lastCell = MIN(lastCell, startCell + (int) cellCount - 1);
|
2014-09-22 10:14:27 +00:00
|
|
|
|
2014-09-24 05:45:30 +00:00
|
|
|
for (cell = startCell; cell <= lastCell; cell++) {
|
2014-06-10 14:16:44 +00:00
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
unsigned int page_size = pages[i];
|
|
|
|
unsigned int page_free;
|
|
|
|
|
2014-06-23 13:04:11 +00:00
|
|
|
if (virNumaGetPageInfo(cell, page_size, 0, NULL, &page_free) < 0)
|
2014-06-10 14:16:44 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
counts[ncounts++] = page_free;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ncounts) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
|
|
|
|
_("no suitable info found"));
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ncounts;
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|
2014-09-18 07:47:07 +00:00
|
|
|
|
|
|
|
int
|
2016-04-13 17:16:16 +00:00
|
|
|
virHostMemAllocPages(unsigned int npages,
|
|
|
|
unsigned int *pageSizes,
|
|
|
|
unsigned long long *pageCounts,
|
|
|
|
int startCell,
|
|
|
|
unsigned int cellCount,
|
|
|
|
bool add)
|
2014-09-18 07:47:07 +00:00
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
int cell, lastCell;
|
|
|
|
size_t i, ncounts = 0;
|
|
|
|
|
|
|
|
if ((lastCell = virNumaGetMaxNode()) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (startCell > lastCell) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
_("start cell %d out of range (0-%d)"),
|
|
|
|
startCell, lastCell);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
lastCell = MIN(lastCell, startCell + (int) cellCount - 1);
|
|
|
|
|
|
|
|
for (cell = startCell; cell <= lastCell; cell++) {
|
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
unsigned int page_size = pageSizes[i];
|
|
|
|
unsigned long long page_count = pageCounts[i];
|
|
|
|
|
|
|
|
if (virNumaSetPagePoolSize(cell, page_size, page_count, add) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
ncounts++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ncounts;
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|