static int
OpenHandle(VMGuestLibHandle *glHandle, // OUT: The guestlib handle
VMGuestLibError *glError) // OUT: The errors when opening the handle
{
*glError = VMGuestLib_OpenHandle(glHandle);
if (*glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.openhandle.failed,
"OpenHandle failed: %s\n"),
VMGuestLib_GetErrorText(*glError));
return EX_UNAVAILABLE;
}
*glError = VMGuestLib_UpdateInfo(*glHandle);
if (*glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.update.failed,
"UpdateInfo failed: %s\n"),
VMGuestLib_GetErrorText(*glError));
return EX_TEMPFAIL;
}
return 0; // We don't return EXIT_SUCCESSS to indicate that this is not
// an exit code
}
static int
StatGetRaw(const char *encoding, // IN
const char *stat, // IN
const char *param) // IN
{
int exitStatus = EXIT_SUCCESS;
VMGuestLibError glError;
char *result = NULL;
size_t resultSize = 0;
char *arg = g_strdup_printf("%s %s", stat, param);
glError = VMGuestLib_StatGet(encoding, arg, &result, &resultSize);
if (glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.get.failed,
"Failed to get stat: %s\n"),
VMGuestLib_GetErrorText(glError));
exitStatus = EX_TEMPFAIL;
} else {
g_print("%*s", (int)resultSize, result);
}
VMGuestLib_StatFree(result, resultSize);
g_free(arg);
return exitStatus;
}
static int
StatGetCpuLimit(void)
{
int exitStatus = EXIT_SUCCESS;
uint32 cpuLimit;
VMGuestLibHandle glHandle;
VMGuestLibError glError;
exitStatus = OpenHandle(&glHandle, &glError);
if (exitStatus) {
return exitStatus;
}
glError = VMGuestLib_GetCpuLimitMHz(glHandle, &cpuLimit);
if (glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.cpumax.failed,
"Failed to get CPU limit: %s\n"),
VMGuestLib_GetErrorText(glError));
exitStatus = EX_TEMPFAIL;
} else {
g_print(SU_(stat.cpuLimit.info, "%u MHz\n"), cpuLimit);
}
VMGuestLib_CloseHandle(glHandle);
return exitStatus;
}
static int
StatGetMemorySwapped(void)
{
int exitStatus = EXIT_SUCCESS;
uint32 memSwapped;
VMGuestLibHandle glHandle;
VMGuestLibError glError;
exitStatus = OpenHandle(&glHandle, &glError);
if (exitStatus) {
return exitStatus;
}
glError = VMGuestLib_GetMemSwappedMB(glHandle, &memSwapped);
if (glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.memswap.failed,
"Failed to get swapped memory: %s\n"),
VMGuestLib_GetErrorText(glError));
exitStatus = EX_TEMPFAIL;
} else {
g_print(SU_(stat.memorySwapped.info, "%u MB\n"), memSwapped);
}
VMGuestLib_CloseHandle(glHandle);
return exitStatus;
}
static int
StatGetSessionID(void)
{
int exitStatus = EXIT_SUCCESS;
uint64 session;
VMGuestLibHandle glHandle;
VMGuestLibError glError;
exitStatus = OpenHandle(&glHandle, &glError);
if (exitStatus) {
return exitStatus;
}
glError = VMGuestLib_GetSessionId(glHandle, &session);
if (glError != VMGUESTLIB_ERROR_SUCCESS) {
ToolsCmd_PrintErr(SU_(stat.getsession.failed,
"Failed to get session ID: %s\n"),
VMGuestLib_GetErrorText(glError));
exitStatus = EX_TEMPFAIL;
} else {
g_print("0x%"FMT64"x\n", session);
}
VMGuestLib_CloseHandle(glHandle);
return exitStatus;
}
int sample(struct vg_data *pvg, unsigned int flag)
{
int rc;
VMGuestLibError ret;
rc = gettimeofday(&pvg->ts, NULL);
if (rc < 0) {
printf("gettimeofday() failed.");
return 1;
}
ret = VMGuestLib_UpdateInfo(pvg->handle);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_Updateinfo: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetSessionId(pvg->handle, &pvg->id);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetSessionId: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetHostProcessorSpeed(pvg->handle, &pvg->hostmhz);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetHostProcessorSpeed: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetCpuReservationMHz(pvg->handle, &pvg->reservemhz);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetCpuReservationMHz: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetCpuLimitMHz(pvg->handle, &pvg->limitmhz);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetCpuLimitMHz: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetCpuShares(pvg->handle, &pvg->cpushares);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetCpuShares: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetElapsedMs(pvg->handle, &pvg->elapsedms);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetElapsedMs: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetCpuUsedMs(pvg->handle, &pvg->usedms);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetCpuUsedMs: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetCpuStolenMs(pvg->handle, &pvg->stolenms);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetCpuStolenMs: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemReservationMB(pvg->handle, &pvg->reservemb);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemReservationMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemLimitMB(pvg->handle, &pvg->limitmb);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemLimitMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemShares(pvg->handle, &pvg->memshares);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemShares: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemMappedMB(pvg->handle, &pvg->mappedsize);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemMappedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemActiveMB(pvg->handle, &pvg->active);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemActiveMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemOverheadMB(pvg->handle, &pvg->overhead);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemOverheadMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemBalloonedMB(pvg->handle, &pvg->ballooned);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemBalloonedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemSwappedMB(pvg->handle, &pvg->swapped);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemSwappedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemSharedMB(pvg->handle, &pvg->sharedmb);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemSharedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemSharedSavedMB(pvg->handle,
&pvg->sharedsavedmb);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemSharedSavedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
ret = VMGuestLib_GetMemUsedMB(pvg->handle, &pvg->usedmb);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetMemUsedMB: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
#ifdef RESPOOLPATH
pvg->bufsize = BUFSIZE;
ret = VMGuestLib_GetResourcePoolPath(pvg->handle,
&pvg->bufsize,
pvg->pathbuf);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_GetResourcePoolPath: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
#endif
return 0;
}
int main (int argc, char **argv)
{
char c;
unsigned int flag = 0;
int interval = 1, count = 0, max_count = 1;
struct vg_data vg_now, vg_prev;
VMGuestLibError ret;
while ((c = getopt(argc, argv, "i:c:hvru")) != -1) {
switch(c) {
case 'i':
interval = atoi(optarg);
break;
case 'c':
max_count = atoi(optarg);
break;
case 'h':
usage();
return 0;
break;
case 'r': /* raw output */
flag |= FLAG_RAWOUTPUT;
break;
case 'v': /* verbose mode */
flag |= FLAG_VERBOSE;
break;
case 'u':
flag |= FLAG_UNIXTIME;
break;
default:
printf("Unkown option '%c'\n", c);
}
}
memset(&vg_now, 0x0, sizeof(struct vg_data));
ret = VMGuestLib_OpenHandle(&vg_now.handle);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_OpenHandle: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
if (sample(&vg_now, flag) != 0) {
goto bailout;
}
if (IS_RAWOUTPUT(flag)) {
printf("Timestamp "
"SessionId "
"HostProcessorSpeed "
"CpuReservationMHz CpuLimitMHz CpuShares "
"ElapsedMs CpuUsedMs CpuStolenMs "
"MemReservationMB MemLimitMB MemShares MemMappedMB "
"MemActiveMB MemOverheadMB MemBalloonedMB MemSwappedMB "
"MemSharedMB MemSharedSavedMB MemUsedMB\n"
);
} else {
printf("%-24s %-8s %-8s %8s %8s %8s %8s\n",
"Timestamp", "intvl(g)", "intvl(h)",
"used", "stolen", "%used", "%ready");
}
for (count = 0; count < max_count; count++) {
vg_prev = vg_now;
sleep(interval);
if (sample(&vg_now, flag) != 0) {
goto bailout;
}
output(&vg_now, &vg_prev, flag);
}
bailout:
ret = VMGuestLib_CloseHandle(vg_now.handle);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_CloseHandle: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
return 0;
}
int main (int argc, char **argv)
{
char c;
unsigned int flag = 0;
int interval = 1, count = 0, max_count = 1;
struct vg_data vg_now, vg_prev;
VMGuestLibError ret;
while ((c = getopt(argc, argv, "i:c:hvru")) != -1) {
switch(c) {
case 'i':
interval = atoi(optarg);
break;
case 'c':
max_count = atoi(optarg);
break;
case 'h':
usage();
return 0;
break;
case 'r': /* raw output */
flag |= FLAG_RAWOUTPUT;
break;
case 'v': /* verbose mode */
flag |= FLAG_VERBOSE;
break;
case 'u':
flag |= FLAG_UNIXTIME;
break;
default:
printf("Unkown option '%c'\n", c);
}
}
memset(&vg_now, 0x0, sizeof(struct vg_data));
ret = VMGuestLib_OpenHandle(&vg_now.handle);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_OpenHandle: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
if (sample(&vg_now, flag) != 0) {
goto bailout;
}
for (count = 0; count < max_count; count++) {
vg_prev = vg_now;
sleep(interval);
if (sample(&vg_now, flag) != 0) {
goto bailout;
}
output(&vg_now, &vg_prev, flag);
}
bailout:
ret = VMGuestLib_CloseHandle(vg_now.handle);
if (ret != VMGUESTLIB_ERROR_SUCCESS) {
if (IS_VERBOSE(flag)) {
printf("VMGuestLib_CloseHandle: %d (%s)\n",
ret, VMGuestLib_GetErrorText(ret));
}
return 1;
}
return 0;
}
