mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-28 19:41:16 +00:00
The original patches adding the functionality neglected to add any form
of documentation for the stats fields returned for this group.
The stats are directly converted from qemu's 'query-stats(-schema)' QMP
command without any further interpretation. The 'query-stats-schema' has
the following disclaimer:
Note: runtime-collected statistics and their names fall outside QEMU's usual
deprecation policies. QEMU will try to keep the set of available data
stable, together with their names, but will not guarantee stability
at all costs; the same is true of providers that source statistics
externally, e.g. from Linux. For example, if the same value is being
tracked with different names on different architectures or by different
providers, one of them might be renamed. A statistic might go away if
an algorithm is changed or some code is removed; changing a default
might cause previously useful statistics to always report 0. Such
changes, however, are expected to be rare.
Since libvirt is not doing any form of conversion of the stats we can't
meaningfully document any of the returned fields. At the same time we
can't even meaningfully provide any form of API stability for the field
names.
Modify the documentation for the 'VIR_DOMAIN_STATS_VM' group both in the
API docs and in the virsh man page to reflect that and disclaim any form
of stability guarantees we provide normally.
Fixes: 8c9e3dae14
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>
Reviewed-by: Jiri Denemark <jdenemar@redhat.com>
2496 lines
73 KiB
C
2496 lines
73 KiB
C
/*
|
|
* virsh-domain-monitor.c: Commands to monitor domain status
|
|
*
|
|
* Copyright (C) 2005, 2007-2016 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include "virsh-domain-monitor.h"
|
|
#include "virsh-util.h"
|
|
|
|
#include <libxml/parser.h>
|
|
#include <libxml/xpath.h>
|
|
|
|
#include "internal.h"
|
|
#include "conf/virdomainobjlist.h"
|
|
#include "viralloc.h"
|
|
#include "virmacaddr.h"
|
|
#include "virxml.h"
|
|
#include "virstring.h"
|
|
#include "vsh-table.h"
|
|
#include "virenum.h"
|
|
|
|
VIR_ENUM_DECL(virshDomainIOError);
|
|
VIR_ENUM_IMPL(virshDomainIOError,
|
|
VIR_DOMAIN_DISK_ERROR_LAST,
|
|
N_("no error"),
|
|
N_("unspecified error"),
|
|
N_("no space"),
|
|
);
|
|
|
|
static const char *
|
|
virshDomainIOErrorToString(int error)
|
|
{
|
|
const char *str = virshDomainIOErrorTypeToString(error);
|
|
return str ? _(str) : _("unknown error");
|
|
}
|
|
|
|
/* extract description or title from domain xml */
|
|
char *
|
|
virshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
|
|
unsigned int flags)
|
|
{
|
|
char *desc = NULL;
|
|
g_autoptr(xmlDoc) doc = NULL;
|
|
g_autoptr(xmlXPathContext) ctxt = NULL;
|
|
int type;
|
|
|
|
if (title)
|
|
type = VIR_DOMAIN_METADATA_TITLE;
|
|
else
|
|
type = VIR_DOMAIN_METADATA_DESCRIPTION;
|
|
|
|
if ((desc = virDomainGetMetadata(dom, type, NULL, flags))) {
|
|
return desc;
|
|
} else {
|
|
int errCode = virGetLastErrorCode();
|
|
|
|
if (errCode == VIR_ERR_NO_DOMAIN_METADATA) {
|
|
desc = g_strdup("");
|
|
vshResetLibvirtError();
|
|
return desc;
|
|
}
|
|
|
|
if (errCode != VIR_ERR_NO_SUPPORT)
|
|
return desc;
|
|
}
|
|
|
|
/* fall back to xml */
|
|
if (virshDomainGetXMLFromDom(ctl, dom, flags, &doc, &ctxt) < 0)
|
|
return NULL;
|
|
|
|
if (title)
|
|
desc = virXPathString("string(./title[1])", ctxt);
|
|
else
|
|
desc = virXPathString("string(./description[1])", ctxt);
|
|
|
|
if (!desc)
|
|
desc = g_strdup("");
|
|
|
|
return desc;
|
|
}
|
|
|
|
VIR_ENUM_DECL(virshDomainControlState);
|
|
VIR_ENUM_IMPL(virshDomainControlState,
|
|
VIR_DOMAIN_CONTROL_LAST,
|
|
N_("ok"),
|
|
N_("background job"),
|
|
N_("occupied"),
|
|
N_("error"),
|
|
);
|
|
|
|
static const char *
|
|
virshDomainControlStateToString(int state)
|
|
{
|
|
const char *str = virshDomainControlStateTypeToString(state);
|
|
return str ? _(str) : _("unknown");
|
|
}
|
|
|
|
VIR_ENUM_DECL(virshDomainControlErrorReason);
|
|
VIR_ENUM_IMPL(virshDomainControlErrorReason,
|
|
VIR_DOMAIN_CONTROL_ERROR_REASON_LAST,
|
|
"",
|
|
N_("unknown"),
|
|
N_("monitor failure"),
|
|
N_("internal (locking) error"),
|
|
);
|
|
|
|
static const char *
|
|
virshDomainControlErrorReasonToString(int reason)
|
|
{
|
|
const char *ret = virshDomainControlErrorReasonTypeToString(reason);
|
|
return ret ? _(ret) : _("unknown");
|
|
}
|
|
|
|
VIR_ENUM_DECL(virshDomainState);
|
|
VIR_ENUM_IMPL(virshDomainState,
|
|
VIR_DOMAIN_LAST,
|
|
N_("no state"),
|
|
N_("running"),
|
|
N_("idle"),
|
|
N_("paused"),
|
|
N_("in shutdown"),
|
|
N_("shut off"),
|
|
N_("crashed"),
|
|
N_("pmsuspended"),
|
|
);
|
|
|
|
static const char *
|
|
virshDomainStateToString(int state)
|
|
{
|
|
const char *str = virshDomainStateTypeToString(state);
|
|
return str ? _(str) : _("no state");
|
|
}
|
|
|
|
VIR_ENUM_DECL(virshDomainNostateReason);
|
|
VIR_ENUM_IMPL(virshDomainNostateReason,
|
|
VIR_DOMAIN_NOSTATE_LAST,
|
|
N_("unknown"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainRunningReason);
|
|
VIR_ENUM_IMPL(virshDomainRunningReason,
|
|
VIR_DOMAIN_RUNNING_LAST,
|
|
N_("unknown"),
|
|
N_("booted"),
|
|
N_("migrated"),
|
|
N_("restored"),
|
|
N_("from snapshot"),
|
|
N_("unpaused"),
|
|
N_("migration canceled"),
|
|
N_("save canceled"),
|
|
N_("event wakeup"),
|
|
N_("crashed"),
|
|
N_("post-copy"),
|
|
N_("post-copy failed"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainBlockedReason);
|
|
VIR_ENUM_IMPL(virshDomainBlockedReason,
|
|
VIR_DOMAIN_BLOCKED_LAST,
|
|
N_("unknown"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainPausedReason);
|
|
VIR_ENUM_IMPL(virshDomainPausedReason,
|
|
VIR_DOMAIN_PAUSED_LAST,
|
|
N_("unknown"),
|
|
N_("user"),
|
|
N_("migrating"),
|
|
N_("saving"),
|
|
N_("dumping"),
|
|
N_("I/O error"),
|
|
N_("watchdog"),
|
|
N_("from snapshot"),
|
|
N_("shutting down"),
|
|
N_("creating snapshot"),
|
|
N_("crashed"),
|
|
N_("starting up"),
|
|
N_("post-copy"),
|
|
N_("post-copy failed"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainShutdownReason);
|
|
VIR_ENUM_IMPL(virshDomainShutdownReason,
|
|
VIR_DOMAIN_SHUTDOWN_LAST,
|
|
N_("unknown"),
|
|
N_("user"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainShutoffReason);
|
|
VIR_ENUM_IMPL(virshDomainShutoffReason,
|
|
VIR_DOMAIN_SHUTOFF_LAST,
|
|
N_("unknown"),
|
|
N_("shutdown"),
|
|
N_("destroyed"),
|
|
N_("crashed"),
|
|
N_("migrated"),
|
|
N_("saved"),
|
|
N_("failed"),
|
|
N_("from snapshot"),
|
|
N_("daemon"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainCrashedReason);
|
|
VIR_ENUM_IMPL(virshDomainCrashedReason,
|
|
VIR_DOMAIN_CRASHED_LAST,
|
|
N_("unknown"),
|
|
N_("panicked"),
|
|
);
|
|
|
|
VIR_ENUM_DECL(virshDomainPMSuspendedReason);
|
|
VIR_ENUM_IMPL(virshDomainPMSuspendedReason,
|
|
VIR_DOMAIN_PMSUSPENDED_LAST,
|
|
N_("unknown"),
|
|
);
|
|
|
|
static const char *
|
|
virshDomainStateReasonToString(int state, int reason)
|
|
{
|
|
const char *str = NULL;
|
|
switch ((virDomainState) state) {
|
|
case VIR_DOMAIN_NOSTATE:
|
|
str = virshDomainNostateReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_RUNNING:
|
|
str = virshDomainRunningReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_BLOCKED:
|
|
str = virshDomainBlockedReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_PAUSED:
|
|
str = virshDomainPausedReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_SHUTDOWN:
|
|
str = virshDomainShutdownReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_SHUTOFF:
|
|
str = virshDomainShutoffReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_CRASHED:
|
|
str = virshDomainCrashedReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_PMSUSPENDED:
|
|
str = virshDomainPMSuspendedReasonTypeToString(reason);
|
|
break;
|
|
case VIR_DOMAIN_LAST:
|
|
;
|
|
}
|
|
|
|
return str ? _(str) : _("unknown");
|
|
}
|
|
|
|
/*
|
|
* "dommemstat" command
|
|
*/
|
|
static const vshCmdInfo info_dommemstat[] = {
|
|
{.name = "help",
|
|
.data = N_("get memory statistics for a domain")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get memory statistics for a running domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_dommemstat[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = "period",
|
|
.type = VSH_OT_INT,
|
|
.flags = VSH_OFLAG_REQ_OPT,
|
|
.help = N_("period in seconds to set collection")
|
|
},
|
|
VIRSH_COMMON_OPT_CONFIG(N_("affect next boot")),
|
|
VIRSH_COMMON_OPT_LIVE(N_("affect running domain")),
|
|
VIRSH_COMMON_OPT_CURRENT(N_("affect current domain")),
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
const char *name;
|
|
virDomainMemoryStatStruct stats[VIR_DOMAIN_MEMORY_STAT_NR];
|
|
unsigned int nr_stats;
|
|
size_t i;
|
|
int rv = 0;
|
|
int period = -1;
|
|
bool config = vshCommandOptBool(cmd, "config");
|
|
bool live = vshCommandOptBool(cmd, "live");
|
|
bool current = vshCommandOptBool(cmd, "current");
|
|
unsigned int flags = VIR_DOMAIN_AFFECT_CURRENT;
|
|
|
|
VSH_EXCLUSIVE_OPTIONS_VAR(current, live);
|
|
VSH_EXCLUSIVE_OPTIONS_VAR(current, config);
|
|
if (config)
|
|
flags |= VIR_DOMAIN_AFFECT_CONFIG;
|
|
if (live)
|
|
flags |= VIR_DOMAIN_AFFECT_LIVE;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
|
|
return false;
|
|
|
|
/* If none of the options were specified and we're active
|
|
* then be sure to allow active modification */
|
|
if (!current && !live && !config && virDomainIsActive(dom) == 1)
|
|
flags |= VIR_DOMAIN_AFFECT_LIVE;
|
|
|
|
/* Providing a period will adjust the balloon driver collection period.
|
|
* This is not really an unsigned long, but it
|
|
*/
|
|
if ((rv = vshCommandOptInt(ctl, cmd, "period", &period)) < 0)
|
|
return false;
|
|
if (rv > 0) {
|
|
if (period < 0) {
|
|
vshError(ctl, _("Invalid collection period value '%d'"), period);
|
|
return false;
|
|
}
|
|
|
|
if (virDomainSetMemoryStatsPeriod(dom, period, flags) < 0) {
|
|
vshError(ctl, "%s",
|
|
_("Unable to change balloon collection period."));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
nr_stats = virDomainMemoryStats(dom, stats, VIR_DOMAIN_MEMORY_STAT_NR, 0);
|
|
if (nr_stats == -1) {
|
|
vshError(ctl, _("Failed to get memory statistics for domain %s"), name);
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < nr_stats; i++) {
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_IN)
|
|
vshPrint(ctl, "swap_in %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_OUT)
|
|
vshPrint(ctl, "swap_out %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT)
|
|
vshPrint(ctl, "major_fault %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT)
|
|
vshPrint(ctl, "minor_fault %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_UNUSED)
|
|
vshPrint(ctl, "unused %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_AVAILABLE)
|
|
vshPrint(ctl, "available %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_USABLE)
|
|
vshPrint(ctl, "usable %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON)
|
|
vshPrint(ctl, "actual %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_RSS)
|
|
vshPrint(ctl, "rss %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE)
|
|
vshPrint(ctl, "last_update %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_DISK_CACHES)
|
|
vshPrint(ctl, "disk_caches %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC)
|
|
vshPrint(ctl, "hugetlb_pgalloc %llu\n", stats[i].val);
|
|
if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL)
|
|
vshPrint(ctl, "hugetlb_pgfail %llu\n", stats[i].val);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domblkinfo" command
|
|
*/
|
|
static const vshCmdInfo info_domblkinfo[] = {
|
|
{.name = "help",
|
|
.data = N_("domain block device size information")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get block device size info for a domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domblkinfo[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = "device",
|
|
.type = VSH_OT_STRING,
|
|
.completer = virshDomainDiskTargetCompleter,
|
|
.help = N_("block device")
|
|
},
|
|
{.name = "human",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("Human readable output")
|
|
},
|
|
{.name = "all",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("display all block devices info")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomblkinfoGet(const virDomainBlockInfo *info,
|
|
char **cap,
|
|
char **alloc,
|
|
char **phy,
|
|
bool human)
|
|
{
|
|
if (info->capacity == 0 && info->allocation == 0 && info->physical == 0) {
|
|
*cap = g_strdup("-");
|
|
*alloc = g_strdup("-");
|
|
*phy = g_strdup("-");
|
|
} else if (!human) {
|
|
*cap = g_strdup_printf("%llu", info->capacity);
|
|
*alloc = g_strdup_printf("%llu", info->allocation);
|
|
*phy = g_strdup_printf("%llu", info->physical);
|
|
} else {
|
|
double val_cap, val_alloc, val_phy;
|
|
const char *unit_cap, *unit_alloc, *unit_phy;
|
|
|
|
val_cap = vshPrettyCapacity(info->capacity, &unit_cap);
|
|
val_alloc = vshPrettyCapacity(info->allocation, &unit_alloc);
|
|
val_phy = vshPrettyCapacity(info->physical, &unit_phy);
|
|
|
|
*cap = g_strdup_printf("%.3lf %s", val_cap, unit_cap);
|
|
*alloc = g_strdup_printf("%.3lf %s", val_alloc, unit_alloc);
|
|
*phy = g_strdup_printf("%.3lf %s", val_phy, unit_phy);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static bool
|
|
cmdDomblkinfo(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
virDomainBlockInfo info;
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
bool human = false;
|
|
bool all = false;
|
|
const char *device = NULL;
|
|
g_autoptr(xmlDoc) xmldoc = NULL;
|
|
g_autoptr(xmlXPathContext) ctxt = NULL;
|
|
int ndisks;
|
|
size_t i;
|
|
g_autofree xmlNodePtr *disks = NULL;
|
|
g_autoptr(vshTable) table = NULL;
|
|
|
|
VSH_EXCLUSIVE_OPTIONS("all", "device");
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
all = vshCommandOptBool(cmd, "all");
|
|
if (!all && vshCommandOptStringQuiet(ctl, cmd, "device", &device) <= 0) {
|
|
vshError(ctl, "command 'domblkinfo' requires <device> option");
|
|
return false;
|
|
}
|
|
|
|
human = vshCommandOptBool(cmd, "human");
|
|
|
|
if (all) {
|
|
bool active = virDomainIsActive(dom) == 1;
|
|
int rc;
|
|
|
|
if (virshDomainGetXML(ctl, cmd, 0, &xmldoc, &ctxt) < 0)
|
|
return false;
|
|
|
|
ndisks = virXPathNodeSet("./devices/disk", ctxt, &disks);
|
|
if (ndisks < 0)
|
|
return false;
|
|
|
|
/* title */
|
|
table = vshTableNew(_("Target"), _("Capacity"), _("Allocation"), _("Physical"), NULL);
|
|
if (!table)
|
|
return false;
|
|
|
|
for (i = 0; i < ndisks; i++) {
|
|
g_autofree char *target = NULL;
|
|
g_autofree char *protocol = NULL;
|
|
g_autofree char *cap = NULL;
|
|
g_autofree char *alloc = NULL;
|
|
g_autofree char *phy = NULL;
|
|
|
|
ctxt->node = disks[i];
|
|
protocol = virXPathString("string(./source/@protocol)", ctxt);
|
|
target = virXPathString("string(./target/@dev)", ctxt);
|
|
|
|
if (virXPathBoolean("boolean(./source)", ctxt) == 1) {
|
|
|
|
rc = virDomainGetBlockInfo(dom, target, &info, 0);
|
|
|
|
if (rc < 0) {
|
|
/* If protocol is present that's an indication of a
|
|
* networked storage device which cannot provide statistics,
|
|
* so generate 0 based data and get the next disk. */
|
|
if (protocol && !active &&
|
|
virGetLastErrorCode() == VIR_ERR_INTERNAL_ERROR &&
|
|
virGetLastErrorDomain() == VIR_FROM_STORAGE) {
|
|
memset(&info, 0, sizeof(info));
|
|
vshResetLibvirtError();
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
/* if we don't call virDomainGetBlockInfo() who clears 'info'
|
|
* we have to do it manually */
|
|
memset(&info, 0, sizeof(info));
|
|
}
|
|
|
|
if (!cmdDomblkinfoGet(&info, &cap, &alloc, &phy, human))
|
|
return false;
|
|
if (vshTableRowAppend(table, target, cap, alloc, phy, NULL) < 0)
|
|
return false;
|
|
}
|
|
|
|
vshTablePrintToStdout(table, ctl);
|
|
|
|
} else {
|
|
g_autofree char *cap = NULL;
|
|
g_autofree char *alloc = NULL;
|
|
g_autofree char *phy = NULL;
|
|
|
|
if (virDomainGetBlockInfo(dom, device, &info, 0) < 0)
|
|
return false;
|
|
|
|
if (!cmdDomblkinfoGet(&info, &cap, &alloc, &phy, human))
|
|
return false;
|
|
vshPrint(ctl, "%-15s %s\n", _("Capacity:"), cap);
|
|
vshPrint(ctl, "%-15s %s\n", _("Allocation:"), alloc);
|
|
vshPrint(ctl, "%-15s %s\n", _("Physical:"), phy);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domblklist" command
|
|
*/
|
|
static const vshCmdInfo info_domblklist[] = {
|
|
{.name = "help",
|
|
.data = N_("list all domain blocks")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get the summary of block devices for a domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domblklist[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = "inactive",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("get inactive rather than running configuration")
|
|
},
|
|
{.name = "details",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("additionally display the type and device value")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomblklist(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
unsigned int flags = 0;
|
|
g_autoptr(xmlDoc) xmldoc = NULL;
|
|
g_autoptr(xmlXPathContext) ctxt = NULL;
|
|
int ndisks;
|
|
g_autofree xmlNodePtr *disks = NULL;
|
|
size_t i;
|
|
bool details = false;
|
|
g_autoptr(vshTable) table = NULL;
|
|
|
|
if (vshCommandOptBool(cmd, "inactive"))
|
|
flags |= VIR_DOMAIN_XML_INACTIVE;
|
|
|
|
details = vshCommandOptBool(cmd, "details");
|
|
|
|
if (virshDomainGetXML(ctl, cmd, flags, &xmldoc, &ctxt) < 0)
|
|
return false;
|
|
|
|
ndisks = virXPathNodeSet("./devices/disk", ctxt, &disks);
|
|
if (ndisks < 0)
|
|
return false;
|
|
|
|
if (details)
|
|
table = vshTableNew(_("Type"), _("Device"), _("Target"), _("Source"), NULL);
|
|
else
|
|
table = vshTableNew(_("Target"), _("Source"), NULL);
|
|
|
|
if (!table)
|
|
return false;
|
|
|
|
for (i = 0; i < ndisks; i++) {
|
|
g_autofree char *type = NULL;
|
|
g_autofree char *device = NULL;
|
|
g_autofree char *target = NULL;
|
|
g_autofree char *source = NULL;
|
|
|
|
ctxt->node = disks[i];
|
|
|
|
type = virXPathString("string(./@type)", ctxt);
|
|
if (details) {
|
|
device = virXPathString("string(./@device)", ctxt);
|
|
if (!type || !device) {
|
|
vshPrint(ctl, "unable to query block list details");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
target = virXPathString("string(./target/@dev)", ctxt);
|
|
if (!target) {
|
|
vshError(ctl, "unable to query block list");
|
|
return false;
|
|
}
|
|
|
|
if (STREQ_NULLABLE(type, "nvme")) {
|
|
g_autofree char *namespace = NULL;
|
|
virPCIDeviceAddress addr = { 0 };
|
|
xmlNodePtr addrNode = NULL;
|
|
|
|
if (!(namespace = virXPathString("string(./source/@namespace)", ctxt)) ||
|
|
!(addrNode = virXPathNode("./source/address", ctxt)) ||
|
|
virPCIDeviceAddressParseXML(addrNode, &addr) < 0) {
|
|
vshError(ctl, "Unable to query NVMe disk address");
|
|
return false;
|
|
}
|
|
|
|
source = g_strdup_printf("nvme://%04x:%02x:%02x.%d/%s",
|
|
addr.domain, addr.bus, addr.slot,
|
|
addr.function, namespace);
|
|
} else {
|
|
source = virXPathString("string(./source/@file"
|
|
"|./source/@dev"
|
|
"|./source/@dir"
|
|
"|./source/@name"
|
|
"|./source/@volume"
|
|
"|./source/@path)", ctxt);
|
|
}
|
|
|
|
if (details) {
|
|
if (vshTableRowAppend(table, type, device, target,
|
|
NULLSTR_MINUS(source), NULL) < 0)
|
|
return false;
|
|
} else {
|
|
if (vshTableRowAppend(table, target,
|
|
NULLSTR_MINUS(source), NULL) < 0)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
vshTablePrintToStdout(table, ctl);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domiflist" command
|
|
*/
|
|
static const vshCmdInfo info_domiflist[] = {
|
|
{"help", N_("list all domain virtual interfaces")},
|
|
{"desc", N_("Get the summary of virtual interfaces for a domain.")},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domiflist[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = "inactive",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("get inactive rather than running configuration")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomiflist(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
unsigned int flags = 0;
|
|
g_autoptr(xmlDoc) xmldoc = NULL;
|
|
g_autoptr(xmlXPathContext) ctxt = NULL;
|
|
int ninterfaces;
|
|
g_autofree xmlNodePtr *interfaces = NULL;
|
|
size_t i;
|
|
g_autoptr(vshTable) table = NULL;
|
|
|
|
if (vshCommandOptBool(cmd, "inactive"))
|
|
flags |= VIR_DOMAIN_XML_INACTIVE;
|
|
|
|
if (virshDomainGetXML(ctl, cmd, flags, &xmldoc, &ctxt) < 0)
|
|
return false;
|
|
|
|
ninterfaces = virXPathNodeSet("./devices/interface", ctxt, &interfaces);
|
|
if (ninterfaces < 0)
|
|
return false;
|
|
|
|
table = vshTableNew(_("Interface"), _("Type"),
|
|
_("Source"), _("Model"), _("MAC"), NULL);
|
|
if (!table)
|
|
return false;
|
|
|
|
for (i = 0; i < ninterfaces; i++) {
|
|
g_autofree char *type = NULL;
|
|
g_autofree char *source = NULL;
|
|
g_autofree char *target = NULL;
|
|
g_autofree char *model = NULL;
|
|
g_autofree char *mac = NULL;
|
|
|
|
ctxt->node = interfaces[i];
|
|
type = virXPathString("string(./@type)", ctxt);
|
|
|
|
source = virXPathString("string(./source/@bridge"
|
|
"|./source/@dev"
|
|
"|./source/@network"
|
|
"|./source/@name"
|
|
"|./source/@path)", ctxt);
|
|
|
|
target = virXPathString("string(./target/@dev)", ctxt);
|
|
model = virXPathString("string(./model/@type)", ctxt);
|
|
mac = virXPathString("string(./mac/@address)", ctxt);
|
|
|
|
if (vshTableRowAppend(table,
|
|
target ? target : "-",
|
|
type,
|
|
source ? source : "-",
|
|
model ? model : "-",
|
|
mac ? mac : "-",
|
|
NULL) < 0)
|
|
return false;
|
|
}
|
|
|
|
vshTablePrintToStdout(table, ctl);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domif-getlink" command
|
|
*/
|
|
static const vshCmdInfo info_domif_getlink[] = {
|
|
{.name = "help",
|
|
.data = N_("get link state of a virtual interface")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get link state of a domain's virtual interface.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domif_getlink[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = "interface",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.completer = virshDomainInterfaceCompleter,
|
|
.help = N_("interface device (MAC Address)")
|
|
},
|
|
{.name = "persistent",
|
|
.type = VSH_OT_ALIAS,
|
|
.help = "config"
|
|
},
|
|
VIRSH_COMMON_OPT_CONFIG(N_("Get persistent interface state")),
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomIfGetLink(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
const char *iface = NULL;
|
|
g_autofree char *state = NULL;
|
|
g_autofree char *xpath = NULL;
|
|
virMacAddr macaddr;
|
|
char macstr[VIR_MAC_STRING_BUFLEN] = "";
|
|
g_autoptr(xmlDoc) xml = NULL;
|
|
g_autoptr(xmlXPathContext) ctxt = NULL;
|
|
g_autofree xmlNodePtr *interfaces = NULL;
|
|
int ninterfaces;
|
|
unsigned int flags = 0;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "interface", &iface) < 0)
|
|
return false;
|
|
|
|
if (vshCommandOptBool(cmd, "config"))
|
|
flags = VIR_DOMAIN_XML_INACTIVE;
|
|
|
|
if (virshDomainGetXML(ctl, cmd, flags, &xml, &ctxt) < 0)
|
|
return false;
|
|
|
|
/* normalize the mac addr */
|
|
if (virMacAddrParse(iface, &macaddr) == 0)
|
|
virMacAddrFormat(&macaddr, macstr);
|
|
|
|
xpath = g_strdup_printf("/domain/devices/interface[(mac/@address = '%s') or "
|
|
" (target/@dev = '%s')]", macstr,
|
|
iface);
|
|
|
|
if ((ninterfaces = virXPathNodeSet(xpath, ctxt, &interfaces)) < 0) {
|
|
vshError(ctl, _("Failed to extract interface information"));
|
|
return false;
|
|
}
|
|
|
|
if (ninterfaces < 1) {
|
|
if (macstr[0])
|
|
vshError(ctl, _("Interface (mac: %s) not found."), macstr);
|
|
else
|
|
vshError(ctl, _("Interface (dev: %s) not found."), iface);
|
|
|
|
return false;
|
|
} else if (ninterfaces > 1) {
|
|
vshError(ctl, _("multiple matching interfaces found"));
|
|
return false;
|
|
}
|
|
|
|
ctxt->node = interfaces[0];
|
|
|
|
if ((state = virXPathString("string(./link/@state)", ctxt)))
|
|
vshPrint(ctl, "%s %s", iface, state);
|
|
else
|
|
vshPrint(ctl, "%s up", iface);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domcontrol" command
|
|
*/
|
|
static const vshCmdInfo info_domcontrol[] = {
|
|
{.name = "help",
|
|
.data = N_("domain control interface state")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Returns state of a control interface to the domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domcontrol[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomControl(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
virDomainControlInfo info;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if (virDomainGetControlInfo(dom, &info, 0) < 0)
|
|
return false;
|
|
|
|
if (info.state != VIR_DOMAIN_CONTROL_OK &&
|
|
info.state != VIR_DOMAIN_CONTROL_ERROR) {
|
|
vshPrint(ctl, "%s (%0.3fs)\n",
|
|
virshDomainControlStateToString(info.state),
|
|
info.stateTime / 1000.0);
|
|
} else if (info.state == VIR_DOMAIN_CONTROL_ERROR && info.details > 0) {
|
|
vshPrint(ctl, "%s: %s\n",
|
|
virshDomainControlStateToString(info.state),
|
|
virshDomainControlErrorReasonToString(info.details));
|
|
} else {
|
|
vshPrint(ctl, "%s\n",
|
|
virshDomainControlStateToString(info.state));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domblkstat" command
|
|
*/
|
|
static const vshCmdInfo info_domblkstat[] = {
|
|
{.name = "help",
|
|
.data = N_("get device block stats for a domain")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get device block stats for a running domain. See man page or "
|
|
"use --human for explanation of fields")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domblkstat[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = "device",
|
|
.type = VSH_OT_STRING,
|
|
.flags = VSH_OFLAG_EMPTY_OK,
|
|
.completer = virshDomainDiskTargetCompleter,
|
|
.help = N_("block device")
|
|
},
|
|
{.name = "human",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("print a more human readable output")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
struct _domblkstat_sequence {
|
|
const char *field; /* field name */
|
|
const char *legacy; /* legacy name from previous releases */
|
|
const char *human; /* human-friendly explanation */
|
|
};
|
|
|
|
/* sequence of values for output to honor legacy format from previous
|
|
* versions */
|
|
static const struct _domblkstat_sequence domblkstat_output[] = {
|
|
{ VIR_DOMAIN_BLOCK_STATS_READ_REQ, "rd_req",
|
|
N_("number of read operations:") }, /* 0 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "rd_bytes",
|
|
N_("number of bytes read:") }, /* 1 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "wr_req",
|
|
N_("number of write operations:") }, /* 2 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "wr_bytes",
|
|
N_("number of bytes written:") }, /* 3 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_ERRS, "errs",
|
|
N_("error count:") }, /* 4 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_FLUSH_REQ, NULL,
|
|
N_("number of flush operations:") }, /* 5 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_READ_TOTAL_TIMES, NULL,
|
|
N_("total duration of reads (ns):") }, /* 6 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_WRITE_TOTAL_TIMES, NULL,
|
|
N_("total duration of writes (ns):") }, /* 7 */
|
|
{ VIR_DOMAIN_BLOCK_STATS_FLUSH_TOTAL_TIMES, NULL,
|
|
N_("total duration of flushes (ns):") }, /* 8 */
|
|
{ NULL, NULL, NULL }
|
|
};
|
|
|
|
#define DOMBLKSTAT_LEGACY_PRINT(ID, VALUE) \
|
|
if (VALUE >= 0) \
|
|
vshPrint(ctl, "%s %-*s %lld\n", device, \
|
|
human ? 31 : 0, \
|
|
human ? _(domblkstat_output[ID].human) \
|
|
: domblkstat_output[ID].legacy, \
|
|
VALUE);
|
|
|
|
static bool
|
|
cmdDomblkstat(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
const char *name = NULL, *device = NULL;
|
|
virDomainBlockStatsStruct stats;
|
|
g_autofree virTypedParameterPtr params = NULL;
|
|
virTypedParameterPtr par = NULL;
|
|
const char *field = NULL;
|
|
int rc, nparams = 0;
|
|
size_t i;
|
|
bool human = vshCommandOptBool(cmd, "human"); /* human readable output */
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
|
|
return false;
|
|
|
|
/* device argument is optional now. if it's missing, supply empty
|
|
string to denote 'all devices'. A NULL device arg would violate
|
|
API contract.
|
|
*/
|
|
if (vshCommandOptStringReq(ctl, cmd, "device", &device) < 0)
|
|
return false;
|
|
|
|
if (!device)
|
|
device = "";
|
|
|
|
rc = virDomainBlockStatsFlags(dom, device, NULL, &nparams, 0);
|
|
|
|
/* It might fail when virDomainBlockStatsFlags is not
|
|
* supported on older libvirt, fallback to use virDomainBlockStats
|
|
* then.
|
|
*/
|
|
if (rc < 0) {
|
|
/* try older API if newer is not supported */
|
|
if (last_error->code != VIR_ERR_NO_SUPPORT)
|
|
return false;
|
|
|
|
vshResetLibvirtError();
|
|
|
|
if (virDomainBlockStats(dom, device, &stats,
|
|
sizeof(stats)) == -1) {
|
|
vshError(ctl, _("Failed to get block stats %s %s"),
|
|
name, device);
|
|
return false;
|
|
}
|
|
|
|
/* human friendly output */
|
|
if (human) {
|
|
vshPrint(ctl, N_("Device: %s\n"), device);
|
|
device = "";
|
|
}
|
|
|
|
DOMBLKSTAT_LEGACY_PRINT(0, stats.rd_req);
|
|
DOMBLKSTAT_LEGACY_PRINT(1, stats.rd_bytes);
|
|
DOMBLKSTAT_LEGACY_PRINT(2, stats.wr_req);
|
|
DOMBLKSTAT_LEGACY_PRINT(3, stats.wr_bytes);
|
|
DOMBLKSTAT_LEGACY_PRINT(4, stats.errs);
|
|
} else {
|
|
params = g_new0(virTypedParameter, nparams);
|
|
if (virDomainBlockStatsFlags(dom, device, params, &nparams, 0) < 0) {
|
|
vshError(ctl, _("Failed to get block stats for domain '%s' device '%s'"), name, device);
|
|
return false;
|
|
}
|
|
|
|
/* set for prettier output */
|
|
if (human) {
|
|
vshPrint(ctl, N_("Device: %s\n"), device);
|
|
device = "";
|
|
}
|
|
|
|
/* at first print all known values in desired order */
|
|
for (i = 0; domblkstat_output[i].field != NULL; i++) {
|
|
g_autofree char *value = NULL;
|
|
|
|
if (!(par = virTypedParamsGet(params, nparams,
|
|
domblkstat_output[i].field)))
|
|
continue;
|
|
|
|
value = vshGetTypedParamValue(ctl, par);
|
|
|
|
/* to print other not supported fields, mark the already printed */
|
|
par->field[0] = '\0'; /* set the name to empty string */
|
|
|
|
/* translate into human readable or legacy spelling */
|
|
field = NULL;
|
|
if (human)
|
|
field = _(domblkstat_output[i].human);
|
|
else
|
|
field = domblkstat_output[i].legacy;
|
|
|
|
/* use the provided spelling if no translation is available */
|
|
if (!field)
|
|
field = domblkstat_output[i].field;
|
|
|
|
vshPrint(ctl, "%s %-*s %s\n", device,
|
|
human ? 31 : 0, field, value);
|
|
}
|
|
|
|
/* go through the fields again, for remaining fields */
|
|
for (i = 0; i < nparams; i++) {
|
|
g_autofree char *value = NULL;
|
|
|
|
if (!*params[i].field)
|
|
continue;
|
|
|
|
value = vshGetTypedParamValue(ctl, params+i);
|
|
vshPrint(ctl, "%s %s %s\n", device, params[i].field, value);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#undef DOMBLKSTAT_LEGACY_PRINT
|
|
|
|
/*
|
|
* "domifstat" command
|
|
*/
|
|
static const vshCmdInfo info_domifstat[] = {
|
|
{.name = "help",
|
|
.data = N_("get network interface stats for a domain")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Get network interface stats for a running domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domifstat[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = "interface",
|
|
.type = VSH_OT_DATA,
|
|
.flags = VSH_OFLAG_REQ,
|
|
.completer = virshDomainInterfaceCompleter,
|
|
.help = N_("interface device specified by name or MAC Address")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomIfstat(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
const char *name = NULL, *device = NULL;
|
|
virDomainInterfaceStatsStruct stats;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
|
|
return false;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "interface", &device) < 0)
|
|
return false;
|
|
|
|
if (virDomainInterfaceStats(dom, device, &stats, sizeof(stats)) == -1) {
|
|
vshError(ctl, _("Failed to get interface stats %s %s"), name, device);
|
|
return false;
|
|
}
|
|
|
|
if (stats.rx_bytes >= 0)
|
|
vshPrint(ctl, "%s rx_bytes %lld\n", device, stats.rx_bytes);
|
|
|
|
if (stats.rx_packets >= 0)
|
|
vshPrint(ctl, "%s rx_packets %lld\n", device, stats.rx_packets);
|
|
|
|
if (stats.rx_errs >= 0)
|
|
vshPrint(ctl, "%s rx_errs %lld\n", device, stats.rx_errs);
|
|
|
|
if (stats.rx_drop >= 0)
|
|
vshPrint(ctl, "%s rx_drop %lld\n", device, stats.rx_drop);
|
|
|
|
if (stats.tx_bytes >= 0)
|
|
vshPrint(ctl, "%s tx_bytes %lld\n", device, stats.tx_bytes);
|
|
|
|
if (stats.tx_packets >= 0)
|
|
vshPrint(ctl, "%s tx_packets %lld\n", device, stats.tx_packets);
|
|
|
|
if (stats.tx_errs >= 0)
|
|
vshPrint(ctl, "%s tx_errs %lld\n", device, stats.tx_errs);
|
|
|
|
if (stats.tx_drop >= 0)
|
|
vshPrint(ctl, "%s tx_drop %lld\n", device, stats.tx_drop);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domblkerror" command
|
|
*/
|
|
static const vshCmdInfo info_domblkerror[] = {
|
|
{.name = "help",
|
|
.data = N_("Show errors on block devices")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Show block device errors")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domblkerror[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomBlkError(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
virDomainDiskErrorPtr disks = NULL;
|
|
unsigned int ndisks = 0;
|
|
size_t i;
|
|
int count;
|
|
bool ret = false;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if ((count = virDomainGetDiskErrors(dom, NULL, 0, 0)) < 0)
|
|
goto cleanup;
|
|
|
|
if (count > 0) {
|
|
disks = g_new0(virDomainDiskError, count);
|
|
ndisks = count;
|
|
|
|
if ((count = virDomainGetDiskErrors(dom, disks, ndisks, 0)) == -1)
|
|
goto cleanup;
|
|
}
|
|
|
|
if (count == 0) {
|
|
vshPrint(ctl, _("No errors found\n"));
|
|
} else {
|
|
for (i = 0; i < count; i++) {
|
|
vshPrint(ctl, "%s: %s\n",
|
|
disks[i].disk,
|
|
virshDomainIOErrorToString(disks[i].error));
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
for (i = 0; i < ndisks; i++)
|
|
VIR_FREE(disks[i].disk);
|
|
VIR_FREE(disks);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* "dominfo" command
|
|
*/
|
|
static const vshCmdInfo info_dominfo[] = {
|
|
{.name = "help",
|
|
.data = N_("domain information")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Returns basic information about the domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_dominfo[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDominfo(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
virDomainInfo info;
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
virSecurityModel secmodel;
|
|
virSecurityLabelPtr seclabel;
|
|
int persistent = 0;
|
|
bool ret = true;
|
|
int autostart;
|
|
unsigned int id;
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
g_autofree char *ostype = NULL;
|
|
int has_managed_save = 0;
|
|
virshControl *priv = ctl->privData;
|
|
g_auto(GStrv) messages = NULL;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
id = virDomainGetID(dom);
|
|
if (id == ((unsigned int)-1))
|
|
vshPrint(ctl, "%-15s %s\n", _("Id:"), "-");
|
|
else
|
|
vshPrint(ctl, "%-15s %d\n", _("Id:"), id);
|
|
vshPrint(ctl, "%-15s %s\n", _("Name:"), virDomainGetName(dom));
|
|
|
|
if (virDomainGetUUIDString(dom, &uuid[0]) == 0)
|
|
vshPrint(ctl, "%-15s %s\n", _("UUID:"), uuid);
|
|
|
|
if ((ostype = virDomainGetOSType(dom)))
|
|
vshPrint(ctl, "%-15s %s\n", _("OS Type:"), ostype);
|
|
|
|
if (virDomainGetInfo(dom, &info) == 0) {
|
|
vshPrint(ctl, "%-15s %s\n", _("State:"),
|
|
virshDomainStateToString(info.state));
|
|
|
|
vshPrint(ctl, "%-15s %d\n", _("CPU(s):"), info.nrVirtCpu);
|
|
|
|
if (info.cpuTime != 0) {
|
|
double cpuUsed = info.cpuTime;
|
|
|
|
cpuUsed /= 1000000000.0;
|
|
|
|
vshPrint(ctl, "%-15s %.1lfs\n", _("CPU time:"), cpuUsed);
|
|
}
|
|
|
|
if (info.maxMem != UINT_MAX)
|
|
vshPrint(ctl, "%-15s %lu KiB\n", _("Max memory:"),
|
|
info.maxMem);
|
|
else
|
|
vshPrint(ctl, "%-15s %s\n", _("Max memory:"),
|
|
_("no limit"));
|
|
|
|
vshPrint(ctl, "%-15s %lu KiB\n", _("Used memory:"),
|
|
info.memory);
|
|
|
|
} else {
|
|
ret = false;
|
|
}
|
|
|
|
/* Check and display whether the domain is persistent or not */
|
|
persistent = virDomainIsPersistent(dom);
|
|
vshDebug(ctl, VSH_ERR_DEBUG, "Domain persistent flag value: %d\n",
|
|
persistent);
|
|
if (persistent < 0)
|
|
vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown"));
|
|
else
|
|
vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
|
|
|
|
/* Check and display whether the domain autostarts or not */
|
|
if (!virDomainGetAutostart(dom, &autostart)) {
|
|
vshPrint(ctl, "%-15s %s\n", _("Autostart:"),
|
|
autostart ? _("enable") : _("disable"));
|
|
}
|
|
|
|
has_managed_save = virDomainHasManagedSaveImage(dom, 0);
|
|
if (has_managed_save < 0)
|
|
vshPrint(ctl, "%-15s %s\n", _("Managed save:"), _("unknown"));
|
|
else
|
|
vshPrint(ctl, "%-15s %s\n", _("Managed save:"),
|
|
has_managed_save ? _("yes") : _("no"));
|
|
|
|
/* Security model and label information */
|
|
memset(&secmodel, 0, sizeof(secmodel));
|
|
if (virNodeGetSecurityModel(priv->conn, &secmodel) == -1) {
|
|
if (last_error->code != VIR_ERR_NO_SUPPORT) {
|
|
return false;
|
|
} else {
|
|
vshResetLibvirtError();
|
|
}
|
|
} else {
|
|
/* Only print something if a security model is active */
|
|
if (secmodel.model[0] != '\0') {
|
|
vshPrint(ctl, "%-15s %s\n", _("Security model:"), secmodel.model);
|
|
vshPrint(ctl, "%-15s %s\n", _("Security DOI:"), secmodel.doi);
|
|
|
|
/* Security labels are only valid for active domains */
|
|
seclabel = g_new0(virSecurityLabel, 1);
|
|
|
|
if (virDomainGetSecurityLabel(dom, seclabel) == -1) {
|
|
VIR_FREE(seclabel);
|
|
return false;
|
|
} else {
|
|
if (seclabel->label[0] != '\0')
|
|
vshPrint(ctl, "%-15s %s (%s)\n", _("Security label:"),
|
|
seclabel->label, seclabel->enforcing ? "enforcing" : "permissive");
|
|
}
|
|
|
|
VIR_FREE(seclabel);
|
|
}
|
|
}
|
|
|
|
if (virDomainGetMessages(dom, &messages, 0) > 0) {
|
|
size_t i;
|
|
for (i = 0; messages[i] != NULL; i++) {
|
|
vshPrint(ctl, "%-15s %s\n",
|
|
i == 0 ? _("Messages:") : "", messages[i]);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* "domstate" command
|
|
*/
|
|
static const vshCmdInfo info_domstate[] = {
|
|
{.name = "help",
|
|
.data = N_("domain state")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Returns state about a domain.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domstate[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(0),
|
|
{.name = "reason",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("also print reason for the state")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomstate(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
bool showReason = vshCommandOptBool(cmd, "reason");
|
|
int state, reason;
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if ((state = virshDomainState(ctl, dom, &reason)) < 0)
|
|
return false;
|
|
|
|
if (showReason) {
|
|
vshPrint(ctl, "%s (%s)\n",
|
|
virshDomainStateToString(state),
|
|
virshDomainStateReasonToString(state, reason));
|
|
} else {
|
|
vshPrint(ctl, "%s\n",
|
|
virshDomainStateToString(state));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "domtime" command
|
|
*/
|
|
static const vshCmdInfo info_domtime[] = {
|
|
{.name = "help",
|
|
.data = N_("domain time")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Gets or sets the domain's system time")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domtime[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = "now",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("set to the time of the host running virsh")
|
|
},
|
|
{.name = "pretty",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("print domain's time in human readable form")
|
|
},
|
|
{.name = "sync",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("instead of setting given time, synchronize from domain's RTC"),
|
|
},
|
|
{.name = "time",
|
|
.type = VSH_OT_INT,
|
|
.help = N_("time to set")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static bool
|
|
cmdDomTime(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
bool now = vshCommandOptBool(cmd, "now");
|
|
bool pretty = vshCommandOptBool(cmd, "pretty");
|
|
bool rtcSync = vshCommandOptBool(cmd, "sync");
|
|
long long seconds = 0;
|
|
unsigned int nseconds = 0;
|
|
unsigned int flags = 0;
|
|
bool doSet = false;
|
|
int rv;
|
|
|
|
VSH_EXCLUSIVE_OPTIONS("time", "now");
|
|
VSH_EXCLUSIVE_OPTIONS("time", "sync");
|
|
VSH_EXCLUSIVE_OPTIONS("now", "sync");
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
rv = vshCommandOptLongLong(ctl, cmd, "time", &seconds);
|
|
|
|
if (rv < 0) {
|
|
/* invalid integer format */
|
|
return false;
|
|
} else if (rv > 0) {
|
|
/* valid integer to set */
|
|
doSet = true;
|
|
}
|
|
|
|
if (doSet || now || rtcSync) {
|
|
if (now && ((seconds = time(NULL)) == (time_t) -1)) {
|
|
vshError(ctl, _("Unable to get current time"));
|
|
return false;
|
|
}
|
|
|
|
if (rtcSync)
|
|
flags |= VIR_DOMAIN_TIME_SYNC;
|
|
|
|
if (virDomainSetTime(dom, seconds, nseconds, flags) < 0)
|
|
return false;
|
|
|
|
} else {
|
|
if (virDomainGetTime(dom, &seconds, &nseconds, flags) < 0)
|
|
return false;
|
|
|
|
if (pretty) {
|
|
g_autoptr(GDateTime) then = NULL;
|
|
g_autofree char *thenstr = NULL;
|
|
|
|
then = g_date_time_new_from_unix_utc(seconds);
|
|
thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S");
|
|
|
|
vshPrint(ctl, _("Time: %s"), thenstr);
|
|
} else {
|
|
vshPrint(ctl, _("Time: %lld"), seconds);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* "list" command
|
|
*/
|
|
static const vshCmdInfo info_list[] = {
|
|
{.name = "help",
|
|
.data = N_("list domains")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Returns list of domains.")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
/* compare domains, pack NULLed ones at the end */
|
|
static int
|
|
virshDomainSorter(const void *a, const void *b)
|
|
{
|
|
virDomainPtr *da = (virDomainPtr *) a;
|
|
virDomainPtr *db = (virDomainPtr *) b;
|
|
unsigned int ida;
|
|
unsigned int idb;
|
|
unsigned int inactive = (unsigned int) -1;
|
|
|
|
if (*da && !*db)
|
|
return -1;
|
|
|
|
if (!*da)
|
|
return *db != NULL;
|
|
|
|
ida = virDomainGetID(*da);
|
|
idb = virDomainGetID(*db);
|
|
|
|
if (ida == inactive && idb == inactive)
|
|
return vshStrcasecmp(virDomainGetName(*da), virDomainGetName(*db));
|
|
|
|
if (ida != inactive && idb != inactive) {
|
|
if (ida > idb)
|
|
return 1;
|
|
else if (ida < idb)
|
|
return -1;
|
|
}
|
|
|
|
if (ida != inactive)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
struct virshDomainList {
|
|
virDomainPtr *domains;
|
|
size_t ndomains;
|
|
};
|
|
|
|
static void
|
|
virshDomainListFree(struct virshDomainList *domlist)
|
|
{
|
|
size_t i;
|
|
|
|
if (domlist && domlist->domains) {
|
|
for (i = 0; i < domlist->ndomains; i++)
|
|
virshDomainFree(domlist->domains[i]);
|
|
g_free(domlist->domains);
|
|
}
|
|
g_free(domlist);
|
|
}
|
|
|
|
static struct virshDomainList *
|
|
virshDomainListCollect(vshControl *ctl, unsigned int flags)
|
|
{
|
|
struct virshDomainList *list = g_new0(struct virshDomainList, 1);
|
|
size_t i;
|
|
int ret;
|
|
int *ids = NULL;
|
|
int nids = 0;
|
|
char **names = NULL;
|
|
int nnames = 0;
|
|
virDomainPtr dom;
|
|
bool success = false;
|
|
size_t deleted = 0;
|
|
int persistent;
|
|
int autostart;
|
|
int state;
|
|
int nsnap;
|
|
int nchk;
|
|
int mansave;
|
|
virshControl *priv = ctl->privData;
|
|
|
|
/* try the list with flags support (0.9.13 and later) */
|
|
if ((ret = virConnectListAllDomains(priv->conn, &list->domains,
|
|
flags)) >= 0) {
|
|
list->ndomains = ret;
|
|
goto finished;
|
|
}
|
|
|
|
/* check if the command is actually supported */
|
|
if (last_error && last_error->code == VIR_ERR_NO_SUPPORT) {
|
|
vshResetLibvirtError();
|
|
goto fallback;
|
|
}
|
|
|
|
if (last_error && last_error->code == VIR_ERR_INVALID_ARG) {
|
|
/* try the new API again but mask non-guaranteed flags */
|
|
unsigned int newflags = flags & (VIR_CONNECT_LIST_DOMAINS_ACTIVE |
|
|
VIR_CONNECT_LIST_DOMAINS_INACTIVE);
|
|
|
|
vshResetLibvirtError();
|
|
if ((ret = virConnectListAllDomains(priv->conn, &list->domains,
|
|
newflags)) >= 0) {
|
|
list->ndomains = ret;
|
|
goto filter;
|
|
}
|
|
}
|
|
|
|
/* there was an error during the first or second call */
|
|
vshError(ctl, "%s", _("Failed to list domains"));
|
|
goto cleanup;
|
|
|
|
|
|
fallback:
|
|
/* fall back to old method (0.9.12 and older) */
|
|
vshResetLibvirtError();
|
|
|
|
/* list active domains, if necessary */
|
|
if (!VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE) ||
|
|
VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE)) {
|
|
if ((nids = virConnectNumOfDomains(priv->conn)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to list active domains"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (nids) {
|
|
ids = g_new0(int, nids);
|
|
|
|
if ((nids = virConnectListDomains(priv->conn, ids, nids)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to list active domains"));
|
|
goto cleanup;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE) ||
|
|
VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE)) {
|
|
if ((nnames = virConnectNumOfDefinedDomains(priv->conn)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to list inactive domains"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (nnames) {
|
|
names = g_new0(char *, nnames);
|
|
|
|
if ((nnames = virConnectListDefinedDomains(priv->conn, names,
|
|
nnames)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to list inactive domains"));
|
|
goto cleanup;
|
|
}
|
|
}
|
|
}
|
|
|
|
list->domains = g_new0(virDomainPtr, nids + nnames);
|
|
list->ndomains = 0;
|
|
|
|
/* get active domains */
|
|
for (i = 0; i < nids; i++) {
|
|
if (!(dom = virDomainLookupByID(priv->conn, ids[i])))
|
|
continue;
|
|
list->domains[list->ndomains++] = dom;
|
|
}
|
|
|
|
/* get inactive domains */
|
|
for (i = 0; i < nnames; i++) {
|
|
if (!(dom = virDomainLookupByName(priv->conn, names[i])))
|
|
continue;
|
|
list->domains[list->ndomains++] = dom;
|
|
}
|
|
|
|
/* truncate domains that weren't found */
|
|
deleted = (nids + nnames) - list->ndomains;
|
|
|
|
filter:
|
|
/* filter list the list if the list was acquired by fallback means */
|
|
for (i = 0; i < list->ndomains; i++) {
|
|
dom = list->domains[i];
|
|
|
|
/* persistence filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_PERSISTENT)) {
|
|
if ((persistent = virDomainIsPersistent(dom)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get domain persistence info"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_PERSISTENT) && persistent) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_TRANSIENT) && !persistent)))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* domain state filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_STATE)) {
|
|
if (virDomainGetState(dom, &state, NULL, 0) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get domain state"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_RUNNING) &&
|
|
state == VIR_DOMAIN_RUNNING) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_PAUSED) &&
|
|
state == VIR_DOMAIN_PAUSED) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_SHUTOFF) &&
|
|
state == VIR_DOMAIN_SHUTOFF) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_OTHER) &&
|
|
(state != VIR_DOMAIN_RUNNING &&
|
|
state != VIR_DOMAIN_PAUSED &&
|
|
state != VIR_DOMAIN_SHUTOFF))))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* autostart filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_AUTOSTART)) {
|
|
if (virDomainGetAutostart(dom, &autostart) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get domain autostart state"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_AUTOSTART) && autostart) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART) && !autostart)))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* managed save filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_MANAGEDSAVE)) {
|
|
if ((mansave = virDomainHasManagedSaveImage(dom, 0)) < 0) {
|
|
vshError(ctl, "%s",
|
|
_("Failed to check for managed save image"));
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE) && mansave) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE) && !mansave)))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* snapshot filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_SNAPSHOT)) {
|
|
if ((nsnap = virDomainSnapshotNum(dom, 0)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get snapshot count"));
|
|
goto cleanup;
|
|
}
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT) && nsnap > 0) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT) && nsnap == 0)))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* checkpoint filter */
|
|
if (VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_CHECKPOINT)) {
|
|
if ((nchk = virDomainListAllCheckpoints(dom, NULL, 0)) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get checkpoint count"));
|
|
goto cleanup;
|
|
}
|
|
if (!((VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT) && nchk > 0) ||
|
|
(VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_NO_CHECKPOINT) && nchk == 0)))
|
|
goto remove_entry;
|
|
}
|
|
|
|
/* the domain matched all filters, it may stay */
|
|
continue;
|
|
|
|
remove_entry:
|
|
/* the domain has to be removed as it failed one of the filters */
|
|
g_clear_pointer(&list->domains[i], virshDomainFree);
|
|
deleted++;
|
|
}
|
|
|
|
finished:
|
|
/* sort the list */
|
|
if (list->domains && list->ndomains)
|
|
qsort(list->domains, list->ndomains, sizeof(*list->domains),
|
|
virshDomainSorter);
|
|
|
|
/* truncate the list if filter simulation deleted entries */
|
|
if (deleted)
|
|
VIR_SHRINK_N(list->domains, list->ndomains, deleted);
|
|
|
|
success = true;
|
|
|
|
cleanup:
|
|
for (i = 0; nnames != -1 && i < nnames; i++)
|
|
VIR_FREE(names[i]);
|
|
|
|
if (!success) {
|
|
g_clear_pointer(&list, virshDomainListFree);
|
|
}
|
|
|
|
VIR_FREE(names);
|
|
VIR_FREE(ids);
|
|
return list;
|
|
}
|
|
|
|
static const vshCmdOptDef opts_list[] = {
|
|
{.name = "inactive",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list inactive domains")
|
|
},
|
|
{.name = "all",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list inactive & active domains")
|
|
},
|
|
{.name = "transient",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list transient domains")
|
|
},
|
|
{.name = "persistent",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list persistent domains")
|
|
},
|
|
{.name = "with-snapshot",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains with existing snapshot")
|
|
},
|
|
{.name = "without-snapshot",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains without a snapshot")
|
|
},
|
|
{.name = "with-checkpoint",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains with existing checkpoint")
|
|
},
|
|
{.name = "without-checkpoint",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains without a checkpoint")
|
|
},
|
|
{.name = "state-running",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains in running state")
|
|
},
|
|
{.name = "state-paused",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains in paused state")
|
|
},
|
|
{.name = "state-shutoff",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains in shutoff state")
|
|
},
|
|
{.name = "state-other",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains in other states")
|
|
},
|
|
{.name = "autostart",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains with autostart enabled")
|
|
},
|
|
{.name = "no-autostart",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains with autostart disabled")
|
|
},
|
|
{.name = "with-managed-save",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains with managed save state")
|
|
},
|
|
{.name = "without-managed-save",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domains without managed save")
|
|
},
|
|
{.name = "uuid",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list uuid's only")
|
|
},
|
|
{.name = "name",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domain names only")
|
|
},
|
|
{.name = "id",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list domain IDs only")
|
|
},
|
|
{.name = "table",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list table (default)")
|
|
},
|
|
{.name = "managed-save",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("mark inactive domains with managed save state")
|
|
},
|
|
{.name = "title",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("show domain title")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
#define FILTER(NAME, FLAG) \
|
|
if (vshCommandOptBool(cmd, NAME)) \
|
|
flags |= (FLAG)
|
|
static bool
|
|
cmdList(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
bool managed = vshCommandOptBool(cmd, "managed-save");
|
|
bool optTitle = vshCommandOptBool(cmd, "title");
|
|
bool optTable = vshCommandOptBool(cmd, "table");
|
|
bool optUUID = vshCommandOptBool(cmd, "uuid");
|
|
bool optName = vshCommandOptBool(cmd, "name");
|
|
bool optID = vshCommandOptBool(cmd, "id");
|
|
size_t i;
|
|
char uuid[VIR_UUID_STRING_BUFLEN];
|
|
int state;
|
|
bool ret = false;
|
|
struct virshDomainList *list = NULL;
|
|
virDomainPtr dom;
|
|
char id_buf[VIR_INT64_STR_BUFLEN];
|
|
unsigned int id;
|
|
unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;
|
|
g_autoptr(vshTable) table = NULL;
|
|
|
|
/* construct filter flags */
|
|
if (vshCommandOptBool(cmd, "inactive") ||
|
|
vshCommandOptBool(cmd, "state-shutoff"))
|
|
flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE;
|
|
|
|
if (vshCommandOptBool(cmd, "all"))
|
|
flags = VIR_CONNECT_LIST_DOMAINS_INACTIVE |
|
|
VIR_CONNECT_LIST_DOMAINS_ACTIVE;
|
|
|
|
FILTER("persistent", VIR_CONNECT_LIST_DOMAINS_PERSISTENT);
|
|
FILTER("transient", VIR_CONNECT_LIST_DOMAINS_TRANSIENT);
|
|
|
|
FILTER("with-managed-save", VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE);
|
|
FILTER("without-managed-save", VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE);
|
|
|
|
FILTER("autostart", VIR_CONNECT_LIST_DOMAINS_AUTOSTART);
|
|
FILTER("no-autostart", VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART);
|
|
|
|
FILTER("with-snapshot", VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT);
|
|
FILTER("without-snapshot", VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT);
|
|
|
|
FILTER("with-checkpoint", VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT);
|
|
FILTER("without-checkpoint", VIR_CONNECT_LIST_DOMAINS_NO_CHECKPOINT);
|
|
|
|
FILTER("state-running", VIR_CONNECT_LIST_DOMAINS_RUNNING);
|
|
FILTER("state-paused", VIR_CONNECT_LIST_DOMAINS_PAUSED);
|
|
FILTER("state-shutoff", VIR_CONNECT_LIST_DOMAINS_SHUTOFF);
|
|
FILTER("state-other", VIR_CONNECT_LIST_DOMAINS_OTHER);
|
|
|
|
VSH_EXCLUSIVE_OPTIONS("table", "name");
|
|
VSH_EXCLUSIVE_OPTIONS("table", "uuid");
|
|
VSH_EXCLUSIVE_OPTIONS("table", "id");
|
|
|
|
if (!optUUID && !optName && !optID)
|
|
optTable = true;
|
|
|
|
if (!(list = virshDomainListCollect(ctl, flags)))
|
|
goto cleanup;
|
|
|
|
/* print table header in legacy mode */
|
|
if (optTable) {
|
|
if (optTitle)
|
|
table = vshTableNew(_("Id"), _("Name"), _("State"), _("Title"), NULL);
|
|
else
|
|
table = vshTableNew(_("Id"), _("Name"), _("State"), NULL);
|
|
|
|
if (!table)
|
|
goto cleanup;
|
|
}
|
|
|
|
for (i = 0; i < list->ndomains; i++) {
|
|
const char *sep = "";
|
|
|
|
dom = list->domains[i];
|
|
id = virDomainGetID(dom);
|
|
if (id != (unsigned int) -1)
|
|
g_snprintf(id_buf, sizeof(id_buf), "%d", id);
|
|
else
|
|
ignore_value(virStrcpyStatic(id_buf, "-"));
|
|
|
|
if (optTable) {
|
|
state = virshDomainState(ctl, dom, NULL);
|
|
|
|
/* Domain could've been removed in the meantime */
|
|
if (state < 0)
|
|
continue;
|
|
|
|
if (managed && state == VIR_DOMAIN_SHUTOFF &&
|
|
virDomainHasManagedSaveImage(dom, 0) > 0)
|
|
state = -2;
|
|
|
|
if (optTitle) {
|
|
g_autofree char *title = NULL;
|
|
|
|
if (!(title = virshGetDomainDescription(ctl, dom, true, 0)))
|
|
goto cleanup;
|
|
if (vshTableRowAppend(table, id_buf,
|
|
virDomainGetName(dom),
|
|
state == -2 ? _("saved")
|
|
: virshDomainStateToString(state),
|
|
title, NULL) < 0)
|
|
goto cleanup;
|
|
} else {
|
|
if (vshTableRowAppend(table, id_buf,
|
|
virDomainGetName(dom),
|
|
state == -2 ? _("saved")
|
|
: virshDomainStateToString(state),
|
|
NULL) < 0)
|
|
goto cleanup;
|
|
}
|
|
|
|
} else {
|
|
if (optUUID) {
|
|
if (virDomainGetUUIDString(dom, uuid) < 0) {
|
|
vshError(ctl, "%s", _("Failed to get domain's UUID"));
|
|
goto cleanup;
|
|
}
|
|
vshPrint(ctl, "%s", uuid);
|
|
sep = " ";
|
|
}
|
|
if (optID) {
|
|
/* If we are asked to print IDs only then do that
|
|
* only for live domains. */
|
|
if (id == (unsigned int) -1 && !optUUID && !optName)
|
|
continue;
|
|
vshPrint(ctl, "%s%s", sep, id_buf);
|
|
sep = " ";
|
|
}
|
|
if (optName) {
|
|
vshPrint(ctl, "%s%s", sep, virDomainGetName(dom));
|
|
sep = " ";
|
|
}
|
|
vshPrint(ctl, "\n");
|
|
}
|
|
}
|
|
|
|
if (optTable)
|
|
vshTablePrintToStdout(table, ctl);
|
|
|
|
ret = true;
|
|
cleanup:
|
|
virshDomainListFree(list);
|
|
return ret;
|
|
}
|
|
#undef FILTER
|
|
|
|
/*
|
|
* "domstats" command
|
|
*/
|
|
static const vshCmdInfo info_domstats[] = {
|
|
{.name = "help",
|
|
.data = N_("get statistics about one or multiple domains")
|
|
},
|
|
{.name = "desc",
|
|
.data = N_("Gets statistics about one or more (or all) domains")
|
|
},
|
|
{.name = NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domstats[] = {
|
|
{.name = "state",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain state"),
|
|
},
|
|
{.name = "cpu-total",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain physical cpu usage"),
|
|
},
|
|
{.name = "balloon",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain balloon statistics"),
|
|
},
|
|
{.name = "vcpu",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain virtual cpu information"),
|
|
},
|
|
{.name = "interface",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain network interface information"),
|
|
},
|
|
{.name = "block",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain block device statistics"),
|
|
},
|
|
{.name = "perf",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain perf event statistics"),
|
|
},
|
|
{.name = "iothread",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain IOThread information"),
|
|
},
|
|
{.name = "memory",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain memory usage"),
|
|
},
|
|
{.name = "dirtyrate",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report domain dirty rate information"),
|
|
},
|
|
{.name = "vm",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report hypervisor-specific statistics"),
|
|
},
|
|
{.name = "list-active",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only active domains"),
|
|
},
|
|
{.name = "list-inactive",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only inactive domains"),
|
|
},
|
|
{.name = "list-persistent",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only persistent domains"),
|
|
},
|
|
{.name = "list-transient",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only transient domains"),
|
|
},
|
|
{.name = "list-running",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only running domains"),
|
|
},
|
|
{.name = "list-paused",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only paused domains"),
|
|
},
|
|
{.name = "list-shutoff",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only shutoff domains"),
|
|
},
|
|
{.name = "list-other",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("list only domains in other states"),
|
|
},
|
|
{.name = "raw",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("do not pretty-print the fields"),
|
|
},
|
|
{.name = "enforce",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("enforce requested stats parameters"),
|
|
},
|
|
{.name = "backing",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("add backing chain information to block stats"),
|
|
},
|
|
{.name = "nowait",
|
|
.type = VSH_OT_BOOL,
|
|
.help = N_("report only stats that are accessible instantly"),
|
|
},
|
|
VIRSH_COMMON_OPT_DOMAIN_OT_ARGV(N_("list of domains to get stats for"), 0),
|
|
{.name = NULL}
|
|
};
|
|
|
|
|
|
static bool
|
|
virshDomainStatsPrintRecord(vshControl *ctl G_GNUC_UNUSED,
|
|
virDomainStatsRecordPtr record,
|
|
bool raw G_GNUC_UNUSED)
|
|
{
|
|
size_t i;
|
|
|
|
vshPrint(ctl, "Domain: '%s'\n", virDomainGetName(record->dom));
|
|
|
|
/* XXX: Implement pretty-printing */
|
|
|
|
for (i = 0; i < record->nparams; i++) {
|
|
g_autofree char *param = NULL;
|
|
|
|
if (!(param = vshGetTypedParamValue(ctl, record->params + i)))
|
|
return false;
|
|
|
|
vshPrint(ctl, " %s=%s\n", record->params[i].field, param);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool
|
|
cmdDomstats(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
unsigned int stats = 0;
|
|
virDomainPtr *domlist = NULL;
|
|
virDomainPtr dom;
|
|
size_t ndoms = 0;
|
|
virDomainStatsRecordPtr *records = NULL;
|
|
virDomainStatsRecordPtr *next;
|
|
bool raw = vshCommandOptBool(cmd, "raw");
|
|
int flags = 0;
|
|
const vshCmdOpt *opt = NULL;
|
|
bool ret = false;
|
|
virshControl *priv = ctl->privData;
|
|
|
|
if (vshCommandOptBool(cmd, "state"))
|
|
stats |= VIR_DOMAIN_STATS_STATE;
|
|
|
|
if (vshCommandOptBool(cmd, "cpu-total"))
|
|
stats |= VIR_DOMAIN_STATS_CPU_TOTAL;
|
|
|
|
if (vshCommandOptBool(cmd, "balloon"))
|
|
stats |= VIR_DOMAIN_STATS_BALLOON;
|
|
|
|
if (vshCommandOptBool(cmd, "vcpu"))
|
|
stats |= VIR_DOMAIN_STATS_VCPU;
|
|
|
|
if (vshCommandOptBool(cmd, "interface"))
|
|
stats |= VIR_DOMAIN_STATS_INTERFACE;
|
|
|
|
if (vshCommandOptBool(cmd, "block"))
|
|
stats |= VIR_DOMAIN_STATS_BLOCK;
|
|
|
|
if (vshCommandOptBool(cmd, "perf"))
|
|
stats |= VIR_DOMAIN_STATS_PERF;
|
|
|
|
if (vshCommandOptBool(cmd, "iothread"))
|
|
stats |= VIR_DOMAIN_STATS_IOTHREAD;
|
|
|
|
if (vshCommandOptBool(cmd, "memory"))
|
|
stats |= VIR_DOMAIN_STATS_MEMORY;
|
|
|
|
if (vshCommandOptBool(cmd, "dirtyrate"))
|
|
stats |= VIR_DOMAIN_STATS_DIRTYRATE;
|
|
|
|
if (vshCommandOptBool(cmd, "vm"))
|
|
stats |= VIR_DOMAIN_STATS_VM;
|
|
|
|
if (vshCommandOptBool(cmd, "list-active"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_ACTIVE;
|
|
|
|
if (vshCommandOptBool(cmd, "list-inactive"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_INACTIVE;
|
|
|
|
if (vshCommandOptBool(cmd, "list-persistent"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_PERSISTENT;
|
|
|
|
if (vshCommandOptBool(cmd, "list-transient"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_TRANSIENT;
|
|
|
|
if (vshCommandOptBool(cmd, "list-running"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_RUNNING;
|
|
|
|
if (vshCommandOptBool(cmd, "list-paused"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_PAUSED;
|
|
|
|
if (vshCommandOptBool(cmd, "list-shutoff"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_SHUTOFF;
|
|
|
|
if (vshCommandOptBool(cmd, "list-other"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_OTHER;
|
|
|
|
if (vshCommandOptBool(cmd, "enforce"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_ENFORCE_STATS;
|
|
|
|
if (vshCommandOptBool(cmd, "backing"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_BACKING;
|
|
|
|
if (vshCommandOptBool(cmd, "nowait"))
|
|
flags |= VIR_CONNECT_GET_ALL_DOMAINS_STATS_NOWAIT;
|
|
|
|
if (vshCommandOptBool(cmd, "domain")) {
|
|
domlist = g_new0(virDomainPtr, 1);
|
|
ndoms = 1;
|
|
|
|
while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
|
|
if (!(dom = virshLookupDomainBy(ctl, opt->data,
|
|
VIRSH_BYID |
|
|
VIRSH_BYUUID | VIRSH_BYNAME)))
|
|
goto cleanup;
|
|
|
|
if (VIR_INSERT_ELEMENT(domlist, ndoms - 1, ndoms, dom) < 0)
|
|
goto cleanup;
|
|
}
|
|
|
|
if (virDomainListGetStats(domlist,
|
|
stats,
|
|
&records,
|
|
flags) < 0)
|
|
goto cleanup;
|
|
} else {
|
|
if ((virConnectGetAllDomainStats(priv->conn,
|
|
stats,
|
|
&records,
|
|
flags)) < 0)
|
|
goto cleanup;
|
|
}
|
|
|
|
next = records;
|
|
while (*next) {
|
|
if (!virshDomainStatsPrintRecord(ctl, *next, raw))
|
|
goto cleanup;
|
|
|
|
if (*(++next))
|
|
vshPrint(ctl, "\n");
|
|
}
|
|
|
|
ret = true;
|
|
cleanup:
|
|
virDomainStatsRecordListFree(records);
|
|
virObjectListFree(domlist);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* "domifaddr" command
|
|
*/
|
|
static const vshCmdInfo info_domifaddr[] = {
|
|
{"help", N_("Get network interfaces' addresses for a running domain")},
|
|
{"desc", N_("Get network interfaces' addresses for a running domain")},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
static const vshCmdOptDef opts_domifaddr[] = {
|
|
VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
|
|
{.name = "interface",
|
|
.type = VSH_OT_STRING,
|
|
.flags = VSH_OFLAG_NONE,
|
|
.completer = virshDomainInterfaceCompleter,
|
|
.help = N_("network interface name")},
|
|
{.name = "full",
|
|
.type = VSH_OT_BOOL,
|
|
.flags = VSH_OFLAG_NONE,
|
|
.help = N_("always display names and MACs of interfaces")},
|
|
{.name = "source",
|
|
.type = VSH_OT_STRING,
|
|
.flags = VSH_OFLAG_NONE,
|
|
.completer = virshDomainInterfaceAddrSourceCompleter,
|
|
.help = N_("address source: 'lease', 'agent', or 'arp'")},
|
|
{.name = NULL}
|
|
};
|
|
|
|
VIR_ENUM_IMPL(virshDomainInterfaceAddressesSource,
|
|
VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LAST,
|
|
"lease",
|
|
"agent",
|
|
"arp");
|
|
|
|
static bool
|
|
cmdDomIfAddr(vshControl *ctl, const vshCmd *cmd)
|
|
{
|
|
g_autoptr(virshDomain) dom = NULL;
|
|
const char *ifacestr = NULL;
|
|
virDomainInterfacePtr *ifaces = NULL;
|
|
size_t i, j;
|
|
int ifaces_count = 0;
|
|
bool ret = false;
|
|
bool full = vshCommandOptBool(cmd, "full");
|
|
const char *sourcestr = NULL;
|
|
int source = VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE;
|
|
|
|
if (vshCommandOptStringReq(ctl, cmd, "interface", &ifacestr) < 0)
|
|
return false;
|
|
if (vshCommandOptStringReq(ctl, cmd, "source", &sourcestr) < 0)
|
|
return false;
|
|
|
|
if (sourcestr &&
|
|
(source = virshDomainInterfaceAddressesSourceTypeFromString(sourcestr)) < 0) {
|
|
vshError(ctl, _("Unknown data source '%s'"), sourcestr);
|
|
return false;
|
|
}
|
|
|
|
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
|
|
return false;
|
|
|
|
if ((ifaces_count = virDomainInterfaceAddresses(dom, &ifaces, source, 0)) < 0) {
|
|
vshError(ctl, _("Failed to query for interfaces addresses"));
|
|
goto cleanup;
|
|
}
|
|
|
|
vshPrintExtra(ctl, " %-10s %-20s %-8s %s\n%s%s\n", _("Name"),
|
|
_("MAC address"), _("Protocol"), _("Address"),
|
|
_("-------------------------------------------------"),
|
|
_("------------------------------"));
|
|
|
|
for (i = 0; i < ifaces_count; i++) {
|
|
virDomainInterfacePtr iface = ifaces[i];
|
|
const char *type = NULL;
|
|
|
|
if (ifacestr && STRNEQ(ifacestr, iface->name))
|
|
continue;
|
|
|
|
/* When the interface has no IP address */
|
|
if (!iface->naddrs) {
|
|
vshPrint(ctl, " %-10s %-17s %-12s %s\n",
|
|
iface->name,
|
|
iface->hwaddr ? iface->hwaddr : "N/A", "N/A", "N/A");
|
|
continue;
|
|
}
|
|
|
|
for (j = 0; j < iface->naddrs; j++) {
|
|
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
|
|
g_autofree char *ip_addr_str = NULL;
|
|
|
|
switch (iface->addrs[j].type) {
|
|
case VIR_IP_ADDR_TYPE_IPV4:
|
|
type = "ipv4";
|
|
break;
|
|
case VIR_IP_ADDR_TYPE_IPV6:
|
|
type = "ipv6";
|
|
break;
|
|
}
|
|
|
|
virBufferAsprintf(&buf, "%-12s %s/%d",
|
|
type, iface->addrs[j].addr,
|
|
iface->addrs[j].prefix);
|
|
|
|
ip_addr_str = virBufferContentAndReset(&buf);
|
|
|
|
if (!ip_addr_str)
|
|
ip_addr_str = g_strdup("");
|
|
|
|
/* Don't repeat interface name */
|
|
if (full || !j)
|
|
vshPrint(ctl, " %-10s %-17s %s\n",
|
|
iface->name,
|
|
NULLSTR_EMPTY(iface->hwaddr), ip_addr_str);
|
|
else
|
|
vshPrint(ctl, " %-10s %-17s %s\n",
|
|
"-", "-", ip_addr_str);
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
|
|
cleanup:
|
|
if (ifaces && ifaces_count > 0) {
|
|
for (i = 0; i < ifaces_count; i++)
|
|
virDomainInterfaceFree(ifaces[i]);
|
|
}
|
|
VIR_FREE(ifaces);
|
|
|
|
return ret;
|
|
}
|
|
|
|
const vshCmdDef domMonitoringCmds[] = {
|
|
{.name = "domblkerror",
|
|
.handler = cmdDomBlkError,
|
|
.opts = opts_domblkerror,
|
|
.info = info_domblkerror,
|
|
.flags = 0
|
|
},
|
|
{.name = "domblkinfo",
|
|
.handler = cmdDomblkinfo,
|
|
.opts = opts_domblkinfo,
|
|
.info = info_domblkinfo,
|
|
.flags = 0
|
|
},
|
|
{.name = "domblklist",
|
|
.handler = cmdDomblklist,
|
|
.opts = opts_domblklist,
|
|
.info = info_domblklist,
|
|
.flags = 0
|
|
},
|
|
{.name = "domblkstat",
|
|
.handler = cmdDomblkstat,
|
|
.opts = opts_domblkstat,
|
|
.info = info_domblkstat,
|
|
.flags = 0
|
|
},
|
|
{.name = "domcontrol",
|
|
.handler = cmdDomControl,
|
|
.opts = opts_domcontrol,
|
|
.info = info_domcontrol,
|
|
.flags = 0
|
|
},
|
|
{.name = "domif-getlink",
|
|
.handler = cmdDomIfGetLink,
|
|
.opts = opts_domif_getlink,
|
|
.info = info_domif_getlink,
|
|
.flags = 0
|
|
},
|
|
{.name = "domifaddr",
|
|
.handler = cmdDomIfAddr,
|
|
.opts = opts_domifaddr,
|
|
.info = info_domifaddr,
|
|
.flags = 0
|
|
},
|
|
{.name = "domiflist",
|
|
.handler = cmdDomiflist,
|
|
.opts = opts_domiflist,
|
|
.info = info_domiflist,
|
|
.flags = 0
|
|
},
|
|
{.name = "domifstat",
|
|
.handler = cmdDomIfstat,
|
|
.opts = opts_domifstat,
|
|
.info = info_domifstat,
|
|
.flags = 0
|
|
},
|
|
{.name = "dominfo",
|
|
.handler = cmdDominfo,
|
|
.opts = opts_dominfo,
|
|
.info = info_dominfo,
|
|
.flags = 0
|
|
},
|
|
{.name = "dommemstat",
|
|
.handler = cmdDomMemStat,
|
|
.opts = opts_dommemstat,
|
|
.info = info_dommemstat,
|
|
.flags = 0
|
|
},
|
|
{.name = "domstate",
|
|
.handler = cmdDomstate,
|
|
.opts = opts_domstate,
|
|
.info = info_domstate,
|
|
.flags = 0
|
|
},
|
|
{.name = "domstats",
|
|
.handler = cmdDomstats,
|
|
.opts = opts_domstats,
|
|
.info = info_domstats,
|
|
.flags = 0
|
|
},
|
|
{.name = "domtime",
|
|
.handler = cmdDomTime,
|
|
.opts = opts_domtime,
|
|
.info = info_domtime,
|
|
.flags = 0
|
|
},
|
|
{.name = "list",
|
|
.handler = cmdList,
|
|
.opts = opts_list,
|
|
.info = info_list,
|
|
.flags = 0
|
|
},
|
|
{.name = NULL}
|
|
};
|