X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fvmware.c;fp=src%2Fvmware.c;h=507375e6aae546acaab01159391eba8d1a88f4d1;hb=9a32f37abb3dc012bce8eb5836a47a1d8ee9da31;hp=0000000000000000000000000000000000000000;hpb=33fdd7d22e7e122c337b0092d3c8d26e5f3caa70;p=collectd.git diff --git a/src/vmware.c b/src/vmware.c new file mode 100644 index 00000000..507375e6 --- /dev/null +++ b/src/vmware.c @@ -0,0 +1,524 @@ +#include +#include +#include +#include +#include "collectd.h" +#include "common.h" +#include "plugin.h" + +#include "vmGuestLib.h" + +/* Functions to dynamically load from the GuestLib library. */ +char const * (*GuestLib_GetErrorText)(VMGuestLibError); +VMGuestLibError (*GuestLib_OpenHandle)(VMGuestLibHandle*); +VMGuestLibError (*GuestLib_CloseHandle)(VMGuestLibHandle); +VMGuestLibError (*GuestLib_UpdateInfo)(VMGuestLibHandle handle); +VMGuestLibError (*GuestLib_GetSessionId)(VMGuestLibHandle handle, + VMSessionId *id); +VMGuestLibError (*GuestLib_GetCpuReservationMHz)(VMGuestLibHandle handle, + uint32 *cpuReservationMHz); +VMGuestLibError (*GuestLib_GetCpuLimitMHz)(VMGuestLibHandle handle, uint32 *cpuLimitMHz); +VMGuestLibError (*GuestLib_GetCpuShares)(VMGuestLibHandle handle, uint32 *cpuShares); +VMGuestLibError (*GuestLib_GetCpuUsedMs)(VMGuestLibHandle handle, uint64 *cpuUsedMs); +VMGuestLibError (*GuestLib_GetHostProcessorSpeed)(VMGuestLibHandle handle, uint32 *mhz); +VMGuestLibError (*GuestLib_GetMemReservationMB)(VMGuestLibHandle handle, + uint32 *memReservationMB); +VMGuestLibError (*GuestLib_GetMemLimitMB)(VMGuestLibHandle handle, uint32 *memLimitMB); +VMGuestLibError (*GuestLib_GetMemShares)(VMGuestLibHandle handle, uint32 *memShares); +VMGuestLibError (*GuestLib_GetMemMappedMB)(VMGuestLibHandle handle, + uint32 *memMappedMB); +VMGuestLibError (*GuestLib_GetMemActiveMB)(VMGuestLibHandle handle, uint32 *memActiveMB); +VMGuestLibError (*GuestLib_GetMemOverheadMB)(VMGuestLibHandle handle, + uint32 *memOverheadMB); +VMGuestLibError (*GuestLib_GetMemBalloonedMB)(VMGuestLibHandle handle, + uint32 *memBalloonedMB); +VMGuestLibError (*GuestLib_GetMemSwappedMB)(VMGuestLibHandle handle, + uint32 *memSwappedMB); +VMGuestLibError (*GuestLib_GetMemSharedMB)(VMGuestLibHandle handle, + uint32 *memSharedMB); +VMGuestLibError (*GuestLib_GetMemSharedSavedMB)(VMGuestLibHandle handle, + uint32 *memSharedSavedMB); +VMGuestLibError (*GuestLib_GetMemUsedMB)(VMGuestLibHandle handle, + uint32 *memUsedMB); +VMGuestLibError (*GuestLib_GetElapsedMs)(VMGuestLibHandle handle, uint64 *elapsedMs); +VMGuestLibError (*GuestLib_GetResourcePoolPath)(VMGuestLibHandle handle, + size_t *bufferSize, + char *pathBuffer); +VMGuestLibError (*GuestLib_GetCpuStolenMs)(VMGuestLibHandle handle, + uint64 *cpuStolenMs); +VMGuestLibError (*GuestLib_GetMemTargetSizeMB)(VMGuestLibHandle handle, + uint64 *memTargetSizeMB); +VMGuestLibError (*GuestLib_GetHostNumCpuCores)(VMGuestLibHandle handle, + uint32 *hostNumCpuCores); +VMGuestLibError (*GuestLib_GetHostCpuUsedMs)(VMGuestLibHandle handle, + uint64 *hostCpuUsedMs); +VMGuestLibError (*GuestLib_GetHostMemSwappedMB)(VMGuestLibHandle handle, + uint64 *hostMemSwappedMB); +VMGuestLibError (*GuestLib_GetHostMemSharedMB)(VMGuestLibHandle handle, + uint64 *hostMemSharedMB); +VMGuestLibError (*GuestLib_GetHostMemUsedMB)(VMGuestLibHandle handle, + uint64 *hostMemUsedMB); +VMGuestLibError (*GuestLib_GetHostMemPhysMB)(VMGuestLibHandle handle, + uint64 *hostMemPhysMB); +VMGuestLibError (*GuestLib_GetHostMemPhysFreeMB)(VMGuestLibHandle handle, + uint64 *hostMemPhysFreeMB); +VMGuestLibError (*GuestLib_GetHostMemKernOvhdMB)(VMGuestLibHandle handle, + uint64 *hostMemKernOvhdMB); +VMGuestLibError (*GuestLib_GetHostMemMappedMB)(VMGuestLibHandle handle, + uint64 *hostMemMappedMB); +VMGuestLibError (*GuestLib_GetHostMemUnmappedMB)(VMGuestLibHandle handle, + uint64 *hostMemUnmappedMB); +/* + * Handle for use with shared library. + */ +void *dlHandle = NULL; + +/* + * GuestLib handle. + */ +VMGuestLibHandle glHandle; + +VMGuestLibError glError; + +/* + * Macro to load a single GuestLib function from the shared library. + */ +#define LOAD_ONE_FUNC(funcname) \ + do { \ + funcname = dlsym(dlHandle, "VM" #funcname); \ + if ((dlErrStr = dlerror()) != NULL) { \ + printf("Failed to load \'%s\': \'%s\'\n", \ + #funcname, dlErrStr); \ + return FALSE; \ + } \ + } while (0) + +Bool +LoadFunctions(void) +{ + /* + * First, try to load the shared library. + */ + char const *dlErrStr; + + dlHandle = dlopen("libvmGuestLib.so", RTLD_NOW); + if (!dlHandle) { + dlErrStr = dlerror(); + printf("dlopen failed: \'%s\'\n", dlErrStr); + return FALSE; + } + + /* Load all the individual library functions. */ + LOAD_ONE_FUNC(GuestLib_GetErrorText); + LOAD_ONE_FUNC(GuestLib_OpenHandle); + LOAD_ONE_FUNC(GuestLib_CloseHandle); + LOAD_ONE_FUNC(GuestLib_UpdateInfo); + LOAD_ONE_FUNC(GuestLib_GetSessionId); + LOAD_ONE_FUNC(GuestLib_GetCpuReservationMHz); + LOAD_ONE_FUNC(GuestLib_GetCpuLimitMHz); + LOAD_ONE_FUNC(GuestLib_GetCpuShares); + LOAD_ONE_FUNC(GuestLib_GetCpuUsedMs); + LOAD_ONE_FUNC(GuestLib_GetHostProcessorSpeed); + LOAD_ONE_FUNC(GuestLib_GetMemReservationMB); + LOAD_ONE_FUNC(GuestLib_GetMemLimitMB); + LOAD_ONE_FUNC(GuestLib_GetMemShares); + LOAD_ONE_FUNC(GuestLib_GetMemMappedMB); + LOAD_ONE_FUNC(GuestLib_GetMemActiveMB); + LOAD_ONE_FUNC(GuestLib_GetMemOverheadMB); + LOAD_ONE_FUNC(GuestLib_GetMemBalloonedMB); + LOAD_ONE_FUNC(GuestLib_GetMemSwappedMB); + LOAD_ONE_FUNC(GuestLib_GetMemSharedMB); + LOAD_ONE_FUNC(GuestLib_GetMemSharedSavedMB); + LOAD_ONE_FUNC(GuestLib_GetMemUsedMB); + LOAD_ONE_FUNC(GuestLib_GetElapsedMs); + LOAD_ONE_FUNC(GuestLib_GetResourcePoolPath); + LOAD_ONE_FUNC(GuestLib_GetCpuStolenMs); + LOAD_ONE_FUNC(GuestLib_GetMemTargetSizeMB); + LOAD_ONE_FUNC(GuestLib_GetHostNumCpuCores); + LOAD_ONE_FUNC(GuestLib_GetHostCpuUsedMs); + LOAD_ONE_FUNC(GuestLib_GetHostMemSwappedMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemSharedMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemUsedMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemPhysMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemPhysFreeMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemKernOvhdMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemMappedMB); + LOAD_ONE_FUNC(GuestLib_GetHostMemUnmappedMB); + + return TRUE; +} + +static int vmware_init (void) +{ + if (!LoadFunctions()) { + ERROR ("vmware guest plugin: Unable to load GuistLib functions"); + return (-1); + } + + /* Try to load the library. */ + glError = GuestLib_OpenHandle(&glHandle); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + ERROR ("OpenHandle failed: %s", GuestLib_GetErrorText(glError)); + return (-1); + } + + return (0); +} + +static void vmware_submit_counter (const char *reading, counter_t value) +{ + value_t values[1]; + value_list_t vl = VALUE_LIST_INIT; + + values[0].counter = value; + + vl.values = values; + vl.values_len = 1; + + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "vmware", sizeof (vl.plugin)); + sstrncpy (vl.type, reading, sizeof (vl.type)); + + plugin_dispatch_values (&vl); +} + +static void vmware_submit_gauge (const char *reading, gauge_t value) +{ + value_t values[1]; + value_list_t vl = VALUE_LIST_INIT; + + values[0].gauge = value; + + vl.values = values; + vl.values_len = 1; + + sstrncpy (vl.host, hostname_g, sizeof (vl.host)); + sstrncpy (vl.plugin, "vmware", sizeof (vl.plugin)); + sstrncpy (vl.type, reading, sizeof (vl.type)); + + plugin_dispatch_values (&vl); +} + +static int vmware_read (void) +{ + counter_t value; + uint32 cpuReservationMHz = 0; + uint32 cpuLimitMHz = 0; + uint32 cpuShares = 0; + uint64 cpuUsedMs = 0; + uint32 hostMHz = 0; + uint32 memReservationMB = 0; + uint32 memLimitMB = 0; + uint32 memShares = 0; + uint32 memMappedMB = 0; + uint32 memActiveMB = 0; + uint32 memOverheadMB = 0; + uint32 memBalloonedMB = 0; + uint32 memSwappedMB = 0; + uint32 memSharedMB = 0; + uint32 memSharedSavedMB = 0; + uint32 memUsedMB = 0; + uint64 elapsedMs = 0; + uint64 cpuStolenMs = 0; + uint64 memTargetSizeMB = 0; + uint32 hostNumCpuCores = 0; + uint64 hostCpuUsedMs = 0; + uint64 hostMemSwappedMB = 0; + uint64 hostMemSharedMB = 0; + uint64 hostMemUsedMB = 0; + uint64 hostMemPhysMB = 0; + uint64 hostMemPhysFreeMB = 0; + uint64 hostMemKernOvhdMB = 0; + uint64 hostMemMappedMB = 0; + uint64 hostMemUnmappedMB = 0; + VMSessionId sessionId = 0; + + /* Attempt to retrieve info from the host. */ + VMSessionId tmpSession; + + glError = GuestLib_UpdateInfo(glHandle); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + ERROR ("UpdateInfo failed: %s", GuestLib_GetErrorText(glError)); + return (-1); + } + + /* Retrieve and check the session ID */ + glError = GuestLib_GetSessionId(glHandle, &tmpSession); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + ERROR ("Failed to get session ID: %s", GuestLib_GetErrorText(glError)); + return (-1); + } + + if (tmpSession == 0) { + ERROR ("Error: Got zero sessionId from GuestLib"); + return (-1); + } + + if (sessionId == 0) { + sessionId = tmpSession; + DEBUG ("Initial session ID is 0x%"FMT64"x", sessionId); + } else if (tmpSession != sessionId) { + sessionId = tmpSession; + DEBUG ("SESSION CHANGED: New session ID is 0x%"FMT64"x\n", sessionId); + } + + /* Retrieve all the stats. */ + /* FIXME: GENERALIZE */ + glError = GuestLib_GetCpuReservationMHz(glHandle, &cpuReservationMHz); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get CPU reservation: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) cpuReservationMHz; + vmware_submit_gauge ("cpu_reservation_mhz", value); + + glError = GuestLib_GetCpuLimitMHz(glHandle, &cpuLimitMHz); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get CPU limit: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) cpuLimitMHz; + vmware_submit_gauge ("cpu_limit_mhz", value); + + glError = GuestLib_GetCpuShares(glHandle, &cpuShares); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get cpu shares: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) cpuShares; + vmware_submit_gauge ("cpu_shares", value); + + glError = GuestLib_GetCpuUsedMs(glHandle, &cpuUsedMs); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get used ms: %s\n", GuestLib_GetErrorText(glError)); + } + value = (counter_t) cpuUsedMs; + vmware_submit_counter ("cpu_used_ms", value); + + glError = GuestLib_GetHostProcessorSpeed(glHandle, &hostMHz); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host proc speed: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) hostMHz; + vmware_submit_gauge ("host_processor_speed", value); + + glError = GuestLib_GetMemReservationMB(glHandle, &memReservationMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get mem reservation: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memReservationMB; + vmware_submit_gauge ("memory_reservation_mb", value); + + glError = GuestLib_GetMemLimitMB(glHandle, &memLimitMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get mem limit: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memLimitMB; + vmware_submit_gauge ("memory_limit_mb", value); + + glError = GuestLib_GetMemShares(glHandle, &memShares); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get mem shares: %s\n", GuestLib_GetErrorText(glError)); + memShares = 0; + } + value = (gauge_t) memShares; + vmware_submit_gauge ("memory_shares", value); + + glError = GuestLib_GetMemMappedMB(glHandle, &memMappedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get mapped mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memMappedMB; + vmware_submit_gauge ("memory_mapped_mb", value); + + glError = GuestLib_GetMemActiveMB(glHandle, &memActiveMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get active mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memActiveMB; + vmware_submit_gauge ("memory_active_mb", value); + + glError = GuestLib_GetMemOverheadMB(glHandle, &memOverheadMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get overhead mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memOverheadMB; + vmware_submit_gauge ("memory_overhead_mb", value); + + glError = GuestLib_GetMemBalloonedMB(glHandle, &memBalloonedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get ballooned mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memBalloonedMB; + vmware_submit_gauge ("memory_ballooned_mb", value); + + glError = GuestLib_GetMemSwappedMB(glHandle, &memSwappedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get swapped mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memSwappedMB; + vmware_submit_gauge ("memory_swapped_mb", value); + + glError = GuestLib_GetMemSharedMB(glHandle, &memSharedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get swapped mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memSharedMB; + vmware_submit_gauge ("memory_shared_mb", value); + + glError = GuestLib_GetMemSharedSavedMB(glHandle, &memSharedSavedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get swapped mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memSharedSavedMB; + vmware_submit_gauge ("memory_shared_saved_mb", value); + + glError = GuestLib_GetMemUsedMB(glHandle, &memUsedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get swapped mem: %s\n", GuestLib_GetErrorText(glError)); + } + value = (gauge_t) memUsedMB; + vmware_submit_gauge ("memory_used_mb", value); + + glError = GuestLib_GetElapsedMs(glHandle, &elapsedMs); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get elapsed ms: %s\n", GuestLib_GetErrorText(glError)); + } + value = (counter_t) elapsedMs; + vmware_submit_counter ("elapsed_ms", value); + + glError = GuestLib_GetCpuStolenMs(glHandle, &cpuStolenMs); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get CPU stolen: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION) { + cpuStolenMs = 0; + } + } + value = (counter_t) cpuStolenMs; + vmware_submit_counter ("cpu_stolen_ms", value); + + glError = GuestLib_GetMemTargetSizeMB(glHandle, &memTargetSizeMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get target mem size: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION) { + memTargetSizeMB = 0; + } + } + value = (gauge_t) memTargetSizeMB; + vmware_submit_gauge ("memory_target_size", value); + + glError = GuestLib_GetHostNumCpuCores(glHandle, &hostNumCpuCores); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host CPU cores: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostNumCpuCores = 0; + } + } + value = (gauge_t) hostNumCpuCores; + vmware_submit_gauge ("host_cpu_cores", value); + + glError = GuestLib_GetHostCpuUsedMs(glHandle, &hostCpuUsedMs); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host CPU used: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostCpuUsedMs = 0; + } + } + value = (counter_t) hostCpuUsedMs; + vmware_submit_counter ("host_cpu_used_ms", value); + + glError = GuestLib_GetHostMemSwappedMB(glHandle, &hostMemSwappedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host mem swapped: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemSwappedMB = 0; + } + } + value = (gauge_t) hostMemSwappedMB; + vmware_submit_gauge ("host_mem_swapped_mb", value); + + glError = GuestLib_GetHostMemSharedMB(glHandle, &hostMemSharedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host mem shared: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemSharedMB = 0; + } + } + value = (gauge_t) hostMemSharedMB; + vmware_submit_gauge ("host_mem_shared_mb", value); + + glError = GuestLib_GetHostMemUsedMB(glHandle, &hostMemUsedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host mem used: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemUsedMB = 0; + } + } + value = (gauge_t) hostMemSharedMB; + vmware_submit_gauge ("host_mem_used_mb", value); + + glError = GuestLib_GetHostMemPhysMB(glHandle, &hostMemPhysMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host phys mem: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemPhysMB = 0; + } + } + value = (gauge_t) hostMemPhysMB; + vmware_submit_gauge ("host_mem_physical_mb", value); + + glError = GuestLib_GetHostMemPhysFreeMB(glHandle, &hostMemPhysFreeMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host phys mem free: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemPhysFreeMB = 0; + } + } + value = (gauge_t) hostMemPhysFreeMB; + vmware_submit_gauge ("host_mem_physical_free_mb", value); + + glError = GuestLib_GetHostMemKernOvhdMB(glHandle, &hostMemKernOvhdMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host kernel overhead mem: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemKernOvhdMB = 0; + } + } + value = (gauge_t) hostMemKernOvhdMB; + vmware_submit_gauge ("host_mem_kernel_overhead_mb", value); + + glError = GuestLib_GetHostMemMappedMB(glHandle, &hostMemMappedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host mem mapped: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemMappedMB = 0; + } + } + value = (gauge_t) hostMemMappedMB; + vmware_submit_gauge ("host_mem_mapped_mb", value); + + glError = GuestLib_GetHostMemUnmappedMB(glHandle, &hostMemUnmappedMB); + if (glError != VMGUESTLIB_ERROR_SUCCESS) { + DEBUG ("Failed to get host mem unmapped: %s\n", GuestLib_GetErrorText(glError)); + if (glError == VMGUESTLIB_ERROR_UNSUPPORTED_VERSION || + glError == VMGUESTLIB_ERROR_NOT_AVAILABLE) { + hostMemUnmappedMB = 0; + } + } + value = (gauge_t) hostMemUnmappedMB; + vmware_submit_gauge ("host_mem_unmapped_mb", value); + + return (0); +} + +void module_register (void) +{ + plugin_register_init ("vmware", vmware_init); + plugin_register_read ("vmware", vmware_read); +}