if (virNodeGetMemoryStatsEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
static int
if (virNodeGetFreeMemoryEnsureACL(conn) < 0)
return 0;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryParameters(params, nparams, flags);
+ return virHostMemGetParameters(params, nparams, flags);
}
static int
if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeSetMemoryParameters(params, nparams, flags);
+ return virHostMemSetParameters(params, nparams, flags);
}
static char *
# nodeinfo.h
-nodeAllocPages;
nodeCapsInitNUMA;
-nodeGetCellsFreeMemory;
nodeGetCPUCount;
nodeGetCPUMap;
nodeGetCPUStats;
-nodeGetFreePages;
nodeGetInfo;
-nodeGetMemory;
-nodeGetMemoryParameters;
-nodeGetMemoryStats;
nodeGetOnlineCPUBitmap;
nodeGetPresentCPUBitmap;
nodeGetThreadsPerSubcore;
-nodeSetMemoryParameters;
+virHostMemAllocPages;
+virHostMemGetCellsFree;
+virHostMemGetFreePages;
+virHostMemGetInfo;
+virHostMemGetParameters;
+virHostMemGetStats;
+virHostMemSetParameters;
# secret/secret_util.h
if (virNodeGetMemoryStatsEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
if (virNodeGetCellsFreeMemoryEnsureACL(conn) < 0)
return -1;
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
if (virNodeGetFreeMemoryEnsureACL(conn) < 0)
return 0;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryParameters(params, nparams, flags);
+ return virHostMemGetParameters(params, nparams, flags);
}
if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeSetMemoryParameters(params, nparams, flags);
+ return virHostMemSetParameters(params, nparams, flags);
}
if (virNodeGetFreePagesEnsureACL(conn) < 0)
return -1;
- return nodeGetFreePages(npages, pages, startCell, cellCount, counts);
+ return virHostMemGetFreePages(npages, pages, startCell, cellCount, counts);
}
if (virNodeAllocPagesEnsureACL(conn) < 0)
return -1;
- return nodeAllocPages(npages, pageSizes, pageCounts,
- startCell, cellCount, add);
+ return virHostMemAllocPages(npages, pageSizes, pageCounts,
+ startCell, cellCount, add);
}
}
static int
-freebsdNodeGetMemoryStats(virNodeMemoryStatsPtr params,
+virHostMemGetStatsFreeBSD(virNodeMemoryStatsPtr params,
int *nparams)
{
size_t i, j = 0;
}
static int
-linuxNodeGetMemoryStats(FILE *meminfo,
+virHostMemGetStatsLinux(FILE *meminfo,
int cellNum,
virNodeMemoryStatsPtr params,
int *nparams)
if (virStrcpyStatic(nodeinfo->model, virArchToString(hostarch)) == NULL)
return -1;
- if (nodeGetMemory(&memorybytes, NULL) < 0)
+ if (virHostMemGetInfo(&memorybytes, NULL) < 0)
return -1;
nodeinfo->memory = memorybytes / 1024;
}
int
-nodeGetMemoryStats(int cellNum ATTRIBUTE_UNUSED,
+virHostMemGetStats(int cellNum ATTRIBUTE_UNUSED,
virNodeMemoryStatsPtr params ATTRIBUTE_UNUSED,
int *nparams ATTRIBUTE_UNUSED,
unsigned int flags)
VIR_FREE(meminfo_path);
return -1;
}
- ret = linuxNodeGetMemoryStats(meminfo, cellNum, params, nparams);
+ ret = virHostMemGetStatsLinux(meminfo, cellNum, params, nparams);
VIR_FORCE_FCLOSE(meminfo);
VIR_FREE(meminfo_path);
return ret;
}
#elif defined(__FreeBSD__)
- return freebsdNodeGetMemoryStats(params, nparams);
+ return virHostMemGetStatsFreeBSD(params, nparams);
#else
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("node memory stats not implemented on this platform"));
#ifdef __linux__
static int
-nodeSetMemoryParameterValue(virTypedParameterPtr param)
+virHostMemSetParameterValue(virTypedParameterPtr param)
{
char *path = NULL;
char *strval = NULL;
}
static bool
-nodeMemoryParametersIsAllSupported(virTypedParameterPtr params,
- int nparams)
+virHostMemParametersAreAllSupported(virTypedParameterPtr params,
+ int nparams)
{
char *path = NULL;
size_t i;
#endif
int
-nodeSetMemoryParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
+virHostMemSetParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
int nparams ATTRIBUTE_UNUSED,
unsigned int flags)
{
NULL) < 0)
return -1;
- if (!nodeMemoryParametersIsAllSupported(params, nparams))
+ if (!virHostMemParametersAreAllSupported(params, nparams))
return -1;
for (i = 0; i < nparams; i++) {
- rc = nodeSetMemoryParameterValue(¶ms[i]);
+ rc = virHostMemSetParameterValue(¶ms[i]);
if (rc < 0)
return -1;
#ifdef __linux__
static int
-nodeGetMemoryParameterValue(const char *field,
+virHostMemGetParameterValue(const char *field,
void *value)
{
char *path = NULL;
#define NODE_MEMORY_PARAMETERS_NUM 8
int
-nodeGetMemoryParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
+virHostMemGetParameters(virTypedParameterPtr params ATTRIBUTE_UNUSED,
int *nparams ATTRIBUTE_UNUSED,
unsigned int flags)
{
switch (i) {
case 0:
- ret = nodeGetMemoryParameterValue("pages_to_scan", &pages_to_scan);
+ ret = virHostMemGetParameterValue("pages_to_scan", &pages_to_scan);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 1:
- ret = nodeGetMemoryParameterValue("sleep_millisecs", &sleep_millisecs);
+ ret = virHostMemGetParameterValue("sleep_millisecs", &sleep_millisecs);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 2:
- ret = nodeGetMemoryParameterValue("pages_shared", &pages_shared);
+ ret = virHostMemGetParameterValue("pages_shared", &pages_shared);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 3:
- ret = nodeGetMemoryParameterValue("pages_sharing", &pages_sharing);
+ ret = virHostMemGetParameterValue("pages_sharing", &pages_sharing);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 4:
- ret = nodeGetMemoryParameterValue("pages_unshared", &pages_unshared);
+ ret = virHostMemGetParameterValue("pages_unshared", &pages_unshared);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 5:
- ret = nodeGetMemoryParameterValue("pages_volatile", &pages_volatile);
+ ret = virHostMemGetParameterValue("pages_volatile", &pages_volatile);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 6:
- ret = nodeGetMemoryParameterValue("full_scans", &full_scans);
+ ret = virHostMemGetParameterValue("full_scans", &full_scans);
if (ret == -2)
continue;
else if (ret == -1)
break;
case 7:
- ret = nodeGetMemoryParameterValue("merge_across_nodes", &merge_across_nodes);
+ ret = virHostMemGetParameterValue("merge_across_nodes", &merge_across_nodes);
if (ret == -2)
continue;
else if (ret == -1)
}
static int
-nodeGetCellsFreeMemoryFake(unsigned long long *freeMems,
+virHostMemGetCellsFreeFake(unsigned long long *freeMems,
int startCell,
int maxCells ATTRIBUTE_UNUSED)
{
}
static int
-nodeGetMemoryFake(unsigned long long *mem,
- unsigned long long *freeMem)
+virHostMemGetInfoFake(unsigned long long *mem,
+ unsigned long long *freeMem)
{
int ret = -1;
int
-nodeGetCellsFreeMemory(unsigned long long *freeMems,
+virHostMemGetCellsFree(unsigned long long *freeMems,
int startCell,
int maxCells)
{
int maxCell;
if (!virNumaIsAvailable())
- return nodeGetCellsFreeMemoryFake(freeMems,
+ return virHostMemGetCellsFreeFake(freeMems,
startCell, maxCells);
if ((maxCell = virNumaGetMaxNode()) < 0)
}
int
-nodeGetMemory(unsigned long long *mem,
- unsigned long long *freeMem)
+virHostMemGetInfo(unsigned long long *mem,
+ unsigned long long *freeMem)
{
int max_node;
int n;
*freeMem = 0;
if (!virNumaIsAvailable())
- return nodeGetMemoryFake(mem, freeMem);
+ return virHostMemGetInfoFake(mem, freeMem);
if ((max_node = virNumaGetMaxNode()) < 0)
return -1;
}
int
-nodeGetFreePages(unsigned int npages,
- unsigned int *pages,
- int startCell,
- unsigned int cellCount,
- unsigned long long *counts)
+virHostMemGetFreePages(unsigned int npages,
+ unsigned int *pages,
+ int startCell,
+ unsigned int cellCount,
+ unsigned long long *counts)
{
int ret = -1;
int cell, lastCell;
}
int
-nodeAllocPages(unsigned int npages,
- unsigned int *pageSizes,
- unsigned long long *pageCounts,
- int startCell,
- unsigned int cellCount,
- bool add)
+virHostMemAllocPages(unsigned int npages,
+ unsigned int *pageSizes,
+ unsigned long long *pageCounts,
+ int startCell,
+ unsigned int cellCount,
+ bool add)
{
int ret = -1;
int cell, lastCell;
virNodeCPUStatsPtr params,
int *nparams,
unsigned int flags);
-int nodeGetMemoryStats(int cellNum,
+int virHostMemGetStats(int cellNum,
virNodeMemoryStatsPtr params,
int *nparams,
unsigned int flags);
-int nodeGetCellsFreeMemory(unsigned long long *freeMems,
+int virHostMemGetCellsFree(unsigned long long *freeMems,
int startCell,
int maxCells);
-int nodeGetMemory(unsigned long long *mem,
- unsigned long long *freeMem);
+int virHostMemGetInfo(unsigned long long *mem,
+ unsigned long long *freeMem);
virBitmapPtr nodeGetPresentCPUBitmap(void);
virBitmapPtr nodeGetOnlineCPUBitmap(void);
int nodeGetCPUCount(void);
int nodeGetThreadsPerSubcore(virArch arch);
-int nodeGetMemoryParameters(virTypedParameterPtr params,
+int virHostMemGetParameters(virTypedParameterPtr params,
int *nparams,
unsigned int flags);
-int nodeSetMemoryParameters(virTypedParameterPtr params,
+int virHostMemSetParameters(virTypedParameterPtr params,
int nparams,
unsigned int flags);
unsigned int *online,
unsigned int flags);
-int nodeGetFreePages(unsigned int npages,
- unsigned int *pages,
- int startCell,
- unsigned int cellCount,
- unsigned long long *counts);
+int virHostMemGetFreePages(unsigned int npages,
+ unsigned int *pages,
+ int startCell,
+ unsigned int cellCount,
+ unsigned long long *counts);
+
+int virHostMemAllocPages(unsigned int npages,
+ unsigned int *pageSizes,
+ unsigned long long *pageCounts,
+ int startCell,
+ unsigned int cellCount,
+ bool add);
-int nodeAllocPages(unsigned int npages,
- unsigned int *pageSizes,
- unsigned long long *pageCounts,
- int startCell,
- unsigned int cellCount,
- bool add);
#endif /* __VIR_NODEINFO_H__*/
int *nparams,
unsigned int flags)
{
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
int startCell,
int maxCells)
{
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
openvzNodeGetFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED)
{
unsigned long long freeMem;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
}
if (virNodeGetMemoryStatsEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
if (virNodeGetCellsFreeMemoryEnsureACL(conn) < 0)
return -1;
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
if (virNodeGetFreeMemoryEnsureACL(conn) < 0)
return 0;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryParameters(params, nparams, flags);
+ return virHostMemGetParameters(params, nparams, flags);
}
if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeSetMemoryParameters(params, nparams, flags);
+ return virHostMemSetParameters(params, nparams, flags);
}
if (virNodeGetFreePagesEnsureACL(conn) < 0)
return -1;
- return nodeGetFreePages(npages, pages, startCell, cellCount, counts);
+ return virHostMemGetFreePages(npages, pages, startCell, cellCount, counts);
}
if (virNodeAllocPagesEnsureACL(conn) < 0)
return -1;
- return nodeAllocPages(npages, pageSizes, pageCounts,
- startCell, cellCount, add);
+ return virHostMemAllocPages(npages, pageSizes, pageCounts,
+ startCell, cellCount, add);
}
if (virNodeGetMemoryStatsEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
if (virNodeGetCellsFreeMemoryEnsureACL(conn) < 0)
return -1;
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
if (virNodeGetFreeMemoryEnsureACL(conn) < 0)
return 0;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryParameters(params, nparams, flags);
+ return virHostMemGetParameters(params, nparams, flags);
}
if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeSetMemoryParameters(params, nparams, flags);
+ return virHostMemSetParameters(params, nparams, flags);
}
if (virNodeGetFreePagesEnsureACL(conn) < 0)
return -1;
- return nodeGetFreePages(npages, pages, startCell, cellCount, counts);
+ return virHostMemGetFreePages(npages, pages, startCell, cellCount, counts);
}
if (virNodeAllocPagesEnsureACL(conn) < 0)
return -1;
- return nodeAllocPages(npages, pageSizes, pageCounts,
- startCell, cellCount, add);
+ return virHostMemAllocPages(npages, pageSizes, pageCounts,
+ startCell, cellCount, add);
}
/* TODO: come up with better algorithm that takes huge pages into
* account. The problem is huge pages cut off regular memory. */
if (node == -1) {
- if (nodeGetMemory(&memsize, &memfree) < 0)
+ if (virHostMemGetInfo(&memsize, &memfree) < 0)
goto cleanup;
} else {
if (virNumaGetNodeMemory(node, &memsize, &memfree) < 0)
int startCell,
int maxCells)
{
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
static unsigned long long
vboxNodeGetFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED)
{
unsigned long long freeMem;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
}
{
virCheckFlags(0, -1);
- return nodeGetFreePages(npages, pages, startCell, cellCount, counts);
+ return virHostMemGetFreePages(npages, pages, startCell, cellCount, counts);
}
static int
virCheckFlags(VIR_NODE_ALLOC_PAGES_SET, -1);
- return nodeAllocPages(npages, pageSizes, pageCounts,
- startCell, cellCount, add);
+ return virHostMemAllocPages(npages, pageSizes, pageCounts,
+ startCell, cellCount, add);
}
static int
int *nparams,
unsigned int flags)
{
- return nodeGetMemoryStats(cellNum, params, nparams, flags);
+ return virHostMemGetStats(cellNum, params, nparams, flags);
}
static int
int startCell,
int maxCells)
{
- return nodeGetCellsFreeMemory(freeMems, startCell, maxCells);
+ return virHostMemGetCellsFree(freeMems, startCell, maxCells);
}
static unsigned long long
vzNodeGetFreeMemory(virConnectPtr conn ATTRIBUTE_UNUSED)
{
unsigned long long freeMem;
- if (nodeGetMemory(NULL, &freeMem) < 0)
+ if (virHostMemGetInfo(NULL, &freeMem) < 0)
return 0;
return freeMem;
}
if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeGetMemoryParameters(params, nparams, flags);
+ return virHostMemGetParameters(params, nparams, flags);
}
if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
return -1;
- return nodeSetMemoryParameters(params, nparams, flags);
+ return virHostMemSetParameters(params, nparams, flags);
}