External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-22 05:35:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

tools: Introduce new client generic module vsh

Browse Source 
In order to share as much virsh' logic as possible with upcomming
virt-admin client we need to split virsh logic into virsh specific and
client generic features.

Since majority of virsh methods should be generic enough to be used by
other clients, it's much easier to rename virsh specific data to virshX
than doing this vice versa. It moved generic virsh commands (including info
and opts structures) to generic module vsh.c.

Besides renaming methods and structures, this patch also involves introduction
of a client specific control structure being referenced as private data in the
original control structure, introduction of a new global vsh Initializer,
which currently doesn't do much, but there is a potential for added
functionality in the future.
Lastly it introduced client hooks which are especially necessary during
client connecting phase.
This commit is contained in:
Erik Skultety 2015-06-15 18:53:58 +02:00
parent b5d63e997b
commit 834c5720e4
30 changed files with 5028 additions and 4577 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cfg.mk
View File

@ -1086,7 +1086,7 @@ $(srcdir)/src/admin/admin_client.h: $(srcdir)/src/admin/admin_protocol.x
$(MAKE) -C src admin/admin_client.h
# List all syntax-check exemptions:
exclude_file_name_regexp--sc_avoid_strcase = ^tools/virsh\.h$$
exclude_file_name_regexp--sc_avoid_strcase = ^tools/vsh\.h$$
_src1=libvirt-stream|fdstream|qemu/qemu_monitor|util/(vircommand|virfile)|xen/xend_internal|rpc/virnetsocket|lxc/lxc_controller|locking/lock_daemon
_test1=shunloadtest|virnettlscontexttest|virnettlssessiontest|vircgroupmock

3
po/POTFILES.in
View File

@ -258,7 +258,6 @@ src/xenconfig/xen_xm.c
tests/virpolkittest.c
tools/libvirt-guests.sh.in
tools/virsh.c
tools/virsh.h
tools/virsh-console.c
tools/virsh-domain-monitor.c
tools/virsh-domain.c
@ -277,3 +276,5 @@ tools/virt-host-validate-lxc.c
tools/virt-host-validate-qemu.c
tools/virt-host-validate.c
tools/virt-login-shell.c
tools/vsh.c
tools/vsh.h

1
src/libvirt_private.syms
View File

@ -2189,6 +2189,7 @@ virStringSplit;
virStringSplitCount;
virStringStripControlChars;
virStringStripIPv6Brackets;
virStringToUpper;
virStrncpy;
virStrndup;
virStrToDouble;

32
src/util/virstring.c
View File

@ -1020,3 +1020,35 @@ virStringStripControlChars(char *str)
}
str[j] = '\0';
}
/**
* virStringToUpper:
* @str: string to capitalize
* @dst: where to store the new capitalized string
*
* Capitalize the string with replacement of all '-' characters for '_'
* characters. Caller frees the result.
*
* Returns 0 if src is NULL, 1 if capitalization was successfull, -1 on failure.
*/
int
virStringToUpper(char **dst, const char *src)
{
char *cap = NULL;
size_t i;
if (!src)
return 0;
if (VIR_ALLOC_N(cap, strlen(src) + 1) < 0)
return -1;
for (i = 0; src[i]; i++) {
cap[i] = c_toupper(src[i]);
if (cap[i] == '-')
cap[i] = '_';
}
*dst = cap;
return 1;
}

1
src/util/virstring.h
View File

@ -258,6 +258,7 @@ size_t virStringListLength(char **strings);
int virStringSortCompare(const void *a, const void *b);
int virStringSortRevCompare(const void *a, const void *b);
int virStringToUpper(char **dst, const char *src);
ssize_t virStringSearch(const char *str,
const char *regexp,

4
tools/Makefile.am
View File

@ -179,7 +179,11 @@ virt_login_shell_CFLAGS = \
$(PIE_CFLAGS) \
$(COVERAGE_CFLAGS)
virt_shell_SOURCES = \
vsh.c vsh.h
virsh_SOURCES = \
$(virt_shell_SOURCES) \
virsh.c virsh.h \
virsh-console.c virsh-console.h \
virsh-domain.c virsh-domain.h \

13
tools/virsh-console.c
View File

@ -295,7 +295,7 @@ virConsoleEventOnStdout(int watch ATTRIBUTE_UNUSED,
static char
vshGetEscapeChar(const char *s)
virshGetEscapeChar(const char *s)
{
if (*s == '^')
return CONTROL(c_toupper(s[1]));
@ -305,12 +305,13 @@ vshGetEscapeChar(const char *s)
int
vshRunConsole(vshControl *ctl,
virDomainPtr dom,
const char *dev_name,
unsigned int flags)
virshRunConsole(vshControl *ctl,
virDomainPtr dom,
const char *dev_name,
unsigned int flags)
{
virConsolePtr con = NULL;
virshControlPtr priv = ctl->privData;
int ret = -1;
struct sigaction old_sigquit;
@ -341,7 +342,7 @@ vshRunConsole(vshControl *ctl,
if (VIR_ALLOC(con) < 0)
goto cleanup;
con->escapeChar = vshGetEscapeChar(ctl->escapeChar);
con->escapeChar = virshGetEscapeChar(priv->escapeChar);
con->st = virStreamNew(virDomainGetConnect(dom),
VIR_STREAM_NONBLOCK);
if (!con->st)

8
tools/virsh-console.h
View File

@ -28,10 +28,10 @@
# include <virsh.h>
int vshRunConsole(vshControl *ctl,
virDomainPtr dom,
const char *dev_name,
unsigned int flags);
int virshRunConsole(vshControl *ctl,
virDomainPtr dom,
const char *dev_name,
unsigned int flags);
# endif /* !WIN32 */

202
tools/virsh-domain-monitor.c
View File

@ -40,24 +40,24 @@
#include "virxml.h"
#include "virstring.h"
VIR_ENUM_DECL(vshDomainIOError)
VIR_ENUM_IMPL(vshDomainIOError,
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 *
vshDomainIOErrorToString(int error)
virshDomainIOErrorToString(int error)
{
const char *str = vshDomainIOErrorTypeToString(error);
const char *str = virshDomainIOErrorTypeToString(error);
return str ? _(str) : _("unknown error");
}
/* extract description or title from domain xml */
char *
vshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
unsigned int flags)
virshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
unsigned int flags)
{
char *desc = NULL;
char *domxml = NULL;
@ -113,8 +113,8 @@ vshGetDomainDescription(vshControl *ctl, virDomainPtr dom, bool title,
return desc;
}
VIR_ENUM_DECL(vshDomainControlState)
VIR_ENUM_IMPL(vshDomainControlState,
VIR_ENUM_DECL(virshDomainControlState)
VIR_ENUM_IMPL(virshDomainControlState,
VIR_DOMAIN_CONTROL_LAST,
N_("ok"),
N_("background job"),
@ -122,14 +122,14 @@ VIR_ENUM_IMPL(vshDomainControlState,
N_("error"))
static const char *
vshDomainControlStateToString(int state)
virshDomainControlStateToString(int state)
{
const char *str = vshDomainControlStateTypeToString(state);
const char *str = virshDomainControlStateTypeToString(state);
return str ? _(str) : _("unknown");
}
VIR_ENUM_DECL(vshDomainControlErrorReason)
VIR_ENUM_IMPL(vshDomainControlErrorReason,
VIR_ENUM_DECL(virshDomainControlErrorReason)
VIR_ENUM_IMPL(virshDomainControlErrorReason,
VIR_DOMAIN_CONTROL_ERROR_REASON_LAST,
"",
N_("unknown"),
@ -137,14 +137,14 @@ VIR_ENUM_IMPL(vshDomainControlErrorReason,
N_("internal (locking) error"))
static const char *
vshDomainControlErrorReasonToString(int reason)
virshDomainControlErrorReasonToString(int reason)
{
const char *ret = vshDomainControlErrorReasonTypeToString(reason);
const char *ret = virshDomainControlErrorReasonTypeToString(reason);
return ret ? _(ret) : _("unknown");
}
VIR_ENUM_DECL(vshDomainState)
VIR_ENUM_IMPL(vshDomainState,
VIR_ENUM_DECL(virshDomainState)
VIR_ENUM_IMPL(virshDomainState,
VIR_DOMAIN_LAST,
N_("no state"),
N_("running"),
@ -156,19 +156,19 @@ VIR_ENUM_IMPL(vshDomainState,
N_("pmsuspended"))
static const char *
vshDomainStateToString(int state)
virshDomainStateToString(int state)
{
const char *str = vshDomainStateTypeToString(state);
const char *str = virshDomainStateTypeToString(state);
return str ? _(str) : _("no state");
}
VIR_ENUM_DECL(vshDomainNostateReason)
VIR_ENUM_IMPL(vshDomainNostateReason,
VIR_ENUM_DECL(virshDomainNostateReason)
VIR_ENUM_IMPL(virshDomainNostateReason,
VIR_DOMAIN_NOSTATE_LAST,
N_("unknown"))
VIR_ENUM_DECL(vshDomainRunningReason)
VIR_ENUM_IMPL(vshDomainRunningReason,
VIR_ENUM_DECL(virshDomainRunningReason)
VIR_ENUM_IMPL(virshDomainRunningReason,
VIR_DOMAIN_RUNNING_LAST,
N_("unknown"),
N_("booted"),
@ -181,13 +181,13 @@ VIR_ENUM_IMPL(vshDomainRunningReason,
N_("event wakeup"),
N_("crashed"))
VIR_ENUM_DECL(vshDomainBlockedReason)
VIR_ENUM_IMPL(vshDomainBlockedReason,
VIR_ENUM_DECL(virshDomainBlockedReason)
VIR_ENUM_IMPL(virshDomainBlockedReason,
VIR_DOMAIN_BLOCKED_LAST,
N_("unknown"))
VIR_ENUM_DECL(vshDomainPausedReason)
VIR_ENUM_IMPL(vshDomainPausedReason,
VIR_ENUM_DECL(virshDomainPausedReason)
VIR_ENUM_IMPL(virshDomainPausedReason,
VIR_DOMAIN_PAUSED_LAST,
N_("unknown"),
N_("user"),
@ -202,14 +202,14 @@ VIR_ENUM_IMPL(vshDomainPausedReason,
N_("crashed"),
N_("starting up"))
VIR_ENUM_DECL(vshDomainShutdownReason)
VIR_ENUM_IMPL(vshDomainShutdownReason,
VIR_ENUM_DECL(virshDomainShutdownReason)
VIR_ENUM_IMPL(virshDomainShutdownReason,
VIR_DOMAIN_SHUTDOWN_LAST,
N_("unknown"),
N_("user"))
VIR_ENUM_DECL(vshDomainShutoffReason)
VIR_ENUM_IMPL(vshDomainShutoffReason,
VIR_ENUM_DECL(virshDomainShutoffReason)
VIR_ENUM_IMPL(virshDomainShutoffReason,
VIR_DOMAIN_SHUTOFF_LAST,
N_("unknown"),
N_("shutdown"),
@ -220,45 +220,45 @@ VIR_ENUM_IMPL(vshDomainShutoffReason,
N_("failed"),
N_("from snapshot"))
VIR_ENUM_DECL(vshDomainCrashedReason)
VIR_ENUM_IMPL(vshDomainCrashedReason,
VIR_ENUM_DECL(virshDomainCrashedReason)
VIR_ENUM_IMPL(virshDomainCrashedReason,
VIR_DOMAIN_CRASHED_LAST,
N_("unknown"),
N_("panicked"))
VIR_ENUM_DECL(vshDomainPMSuspendedReason)
VIR_ENUM_IMPL(vshDomainPMSuspendedReason,
VIR_ENUM_DECL(virshDomainPMSuspendedReason)
VIR_ENUM_IMPL(virshDomainPMSuspendedReason,
VIR_DOMAIN_PMSUSPENDED_LAST,
N_("unknown"))
static const char *
vshDomainStateReasonToString(int state, int reason)
virshDomainStateReasonToString(int state, int reason)
{
const char *str = NULL;
switch ((virDomainState) state) {
case VIR_DOMAIN_NOSTATE:
str = vshDomainNostateReasonTypeToString(reason);
str = virshDomainNostateReasonTypeToString(reason);
break;
case VIR_DOMAIN_RUNNING:
str = vshDomainRunningReasonTypeToString(reason);
str = virshDomainRunningReasonTypeToString(reason);
break;
case VIR_DOMAIN_BLOCKED:
str = vshDomainBlockedReasonTypeToString(reason);
str = virshDomainBlockedReasonTypeToString(reason);
break;
case VIR_DOMAIN_PAUSED:
str = vshDomainPausedReasonTypeToString(reason);
str = virshDomainPausedReasonTypeToString(reason);
break;
case VIR_DOMAIN_SHUTDOWN:
str = vshDomainShutdownReasonTypeToString(reason);
str = virshDomainShutdownReasonTypeToString(reason);
break;
case VIR_DOMAIN_SHUTOFF:
str = vshDomainShutoffReasonTypeToString(reason);
str = virshDomainShutoffReasonTypeToString(reason);
break;
case VIR_DOMAIN_CRASHED:
str = vshDomainCrashedReasonTypeToString(reason);
str = virshDomainCrashedReasonTypeToString(reason);
break;
case VIR_DOMAIN_PMSUSPENDED:
str = vshDomainPMSuspendedReasonTypeToString(reason);
str = virshDomainPMSuspendedReasonTypeToString(reason);
break;
case VIR_DOMAIN_LAST:
;
@ -329,7 +329,7 @@ cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
if (live)
flags |= VIR_DOMAIN_AFFECT_LIVE;
if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
return false;
/* If none of the options were specified and we're active
@ -423,7 +423,7 @@ cmdDomblkinfo(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
const char *device = NULL;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "device", &device) < 0)
@ -492,7 +492,7 @@ cmdDomblklist(vshControl *ctl, const vshCmd *cmd)
details = vshCommandOptBool(cmd, "details");
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
xml = virDomainGetXMLDesc(dom, flags);
@ -608,7 +608,7 @@ cmdDomiflist(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "inactive"))
flags |= VIR_DOMAIN_XML_INACTIVE;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
xml = virDomainGetXMLDesc(dom, flags);
@ -726,7 +726,7 @@ cmdDomIfGetLink(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptStringReq(ctl, cmd, "interface", &iface) < 0)
return false;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (vshCommandOptBool(cmd, "config"))
@ -815,7 +815,7 @@ cmdDomControl(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
virDomainControlInfo info;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (virDomainGetControlInfo(dom, &info, 0) < 0) {
@ -826,15 +826,15 @@ cmdDomControl(vshControl *ctl, const vshCmd *cmd)
if (info.state != VIR_DOMAIN_CONTROL_OK &&
info.state != VIR_DOMAIN_CONTROL_ERROR) {
vshPrint(ctl, "%s (%0.3fs)\n",
vshDomainControlStateToString(info.state),
virshDomainControlStateToString(info.state),
info.stateTime / 1000.0);
} else if (info.state == VIR_DOMAIN_CONTROL_ERROR && info.details > 0) {
vshPrint(ctl, "%s: %s\n",
vshDomainControlStateToString(info.state),
vshDomainControlErrorReasonToString(info.details));
virshDomainControlStateToString(info.state),
virshDomainControlErrorReasonToString(info.details));
} else {
vshPrint(ctl, "%s\n",
vshDomainControlStateToString(info.state));
virshDomainControlStateToString(info.state));
}
cleanup:
@ -927,7 +927,7 @@ cmdDomblkstat(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
bool human = vshCommandOptBool(cmd, "human"); /* human readable output */
if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
return false;
/* device argument is optional now. if it's missing, supply empty
@ -1068,7 +1068,7 @@ cmdDomIfstat(vshControl *ctl, const vshCmd *cmd)
virDomainInterfaceStatsStruct stats;
bool ret = false;
if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
if (!(dom = virshCommandOptDomain(ctl, cmd, &name)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "interface", &device) < 0)
@ -1142,7 +1142,7 @@ cmdDomBlkError(vshControl *ctl, const vshCmd *cmd)
int count;
bool ret = false;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if ((count = virDomainGetDiskErrors(dom, NULL, 0, 0)) < 0)
@ -1163,7 +1163,7 @@ cmdDomBlkError(vshControl *ctl, const vshCmd *cmd)
for (i = 0; i < count; i++) {
vshPrint(ctl, "%s: %s\n",
disks[i].disk,
vshDomainIOErrorToString(disks[i].error));
virshDomainIOErrorToString(disks[i].error));
}
}
@ -1210,8 +1210,9 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
unsigned int id;
char *str, uuid[VIR_UUID_STRING_BUFLEN];
int has_managed_save = 0;
virshControlPtr priv = ctl->privData;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
id = virDomainGetID(dom);
@ -1231,7 +1232,7 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
if (virDomainGetInfo(dom, &info) == 0) {
vshPrint(ctl, "%-15s %s\n", _("State:"),
vshDomainStateToString(info.state));
virshDomainStateToString(info.state));
vshPrint(ctl, "%-15s %d\n", _("CPU(s):"), info.nrVirtCpu);
@ -1281,7 +1282,7 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
/* Security model and label information */
memset(&secmodel, 0, sizeof(secmodel));
if (virNodeGetSecurityModel(ctl->conn, &secmodel) == -1) {
if (virNodeGetSecurityModel(priv->conn, &secmodel) == -1) {
if (last_error->code != VIR_ERR_NO_SUPPORT) {
virDomainFree(dom);
return false;
@ -1351,21 +1352,21 @@ cmdDomstate(vshControl *ctl, const vshCmd *cmd)
bool showReason = vshCommandOptBool(cmd, "reason");
int state, reason;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if ((state = vshDomainState(ctl, dom, &reason)) < 0) {
if ((state = virshDomainState(ctl, dom, &reason)) < 0) {
ret = false;
goto cleanup;
}
if (showReason) {
vshPrint(ctl, "%s (%s)\n",
vshDomainStateToString(state),
vshDomainStateReasonToString(state, reason));
virshDomainStateToString(state),
virshDomainStateReasonToString(state, reason));
} else {
vshPrint(ctl, "%s\n",
vshDomainStateToString(state));
virshDomainStateToString(state));
}
cleanup:
@ -1429,7 +1430,7 @@ cmdDomTime(vshControl *ctl, const vshCmd *cmd)
VSH_EXCLUSIVE_OPTIONS("time", "sync");
VSH_EXCLUSIVE_OPTIONS("now", "sync");
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
rv = vshCommandOptLongLong(ctl, cmd, "time", &seconds);
@ -1496,7 +1497,7 @@ static const vshCmdInfo info_list[] = {
/* compare domains, pack NULLed ones at the end*/
static int
vshDomainSorter(const void *a, const void *b)
virshDomainSorter(const void *a, const void *b)
{
virDomainPtr *da = (virDomainPtr *) a;
virDomainPtr *db = (virDomainPtr *) b;
@ -1529,14 +1530,14 @@ vshDomainSorter(const void *a, const void *b)
return 1;
}
struct vshDomainList {
struct virshDomainList {
virDomainPtr *domains;
size_t ndomains;
};
typedef struct vshDomainList *vshDomainListPtr;
typedef struct virshDomainList *virshDomainListPtr;
static void
vshDomainListFree(vshDomainListPtr domlist)
virshDomainListFree(virshDomainListPtr domlist)
{
size_t i;
@ -1550,10 +1551,10 @@ vshDomainListFree(vshDomainListPtr domlist)
VIR_FREE(domlist);
}
static vshDomainListPtr
vshDomainListCollect(vshControl *ctl, unsigned int flags)
static virshDomainListPtr
virshDomainListCollect(vshControl *ctl, unsigned int flags)
{
vshDomainListPtr list = vshMalloc(ctl, sizeof(*list));
virshDomainListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
int *ids = NULL;
@ -1568,9 +1569,10 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
int state;
int nsnap;
int mansave;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.9.13 and later) */
if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
if ((ret = virConnectListAllDomains(priv->conn, &list->domains,
flags)) >= 0) {
list->ndomains = ret;
goto finished;
@ -1588,7 +1590,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
VIR_CONNECT_LIST_DOMAINS_INACTIVE);
vshResetLibvirtError();
if ((ret = virConnectListAllDomains(ctl->conn, &list->domains,
if ((ret = virConnectListAllDomains(priv->conn, &list->domains,
newflags)) >= 0) {
list->ndomains = ret;
goto filter;
@ -1607,7 +1609,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
/* list active domains, if necessary */
if (!VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_ACTIVE)) {
if ((nids = virConnectNumOfDomains(ctl->conn)) < 0) {
if ((nids = virConnectNumOfDomains(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to list active domains"));
goto cleanup;
}
@ -1615,7 +1617,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
if (nids) {
ids = vshMalloc(ctl, sizeof(int) * nids);
if ((nids = virConnectListDomains(ctl->conn, ids, nids)) < 0) {
if ((nids = virConnectListDomains(priv->conn, ids, nids)) < 0) {
vshError(ctl, "%s", _("Failed to list active domains"));
goto cleanup;
}
@ -1624,7 +1626,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
if (!VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_DOMAINS_INACTIVE)) {
if ((nnames = virConnectNumOfDefinedDomains(ctl->conn)) < 0) {
if ((nnames = virConnectNumOfDefinedDomains(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to list inactive domains"));
goto cleanup;
}
@ -1632,7 +1634,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
if (nnames) {
names = vshMalloc(ctl, sizeof(char *) * nnames);
if ((nnames = virConnectListDefinedDomains(ctl->conn, names,
if ((nnames = virConnectListDefinedDomains(priv->conn, names,
nnames)) < 0) {
vshError(ctl, "%s", _("Failed to list inactive domains"));
goto cleanup;
@ -1645,14 +1647,14 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
/* get active domains */
for (i = 0; i < nids; i++) {
if (!(dom = virDomainLookupByID(ctl->conn, ids[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(ctl->conn, names[i])))
if (!(dom = virDomainLookupByName(priv->conn, names[i])))
continue;
list->domains[list->ndomains++] = dom;
}
@ -1747,7 +1749,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
/* sort the list */
if (list->domains && list->ndomains)
qsort(list->domains, list->ndomains, sizeof(*list->domains),
vshDomainSorter);
virshDomainSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
@ -1760,7 +1762,7 @@ vshDomainListCollect(vshControl *ctl, unsigned int flags)
VIR_FREE(names[i]);
if (!success) {
vshDomainListFree(list);
virshDomainListFree(list);
list = NULL;
}
@ -1865,7 +1867,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd)
char uuid[VIR_UUID_STRING_BUFLEN];
int state;
bool ret = false;
vshDomainListPtr list = NULL;
virshDomainListPtr list = NULL;
virDomainPtr dom;
char id_buf[INT_BUFSIZE_BOUND(unsigned int)];
unsigned int id;
@ -1906,7 +1908,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd)
if (!optUUID && !optName)
optTable = true;
if (!(list = vshDomainListCollect(ctl, flags)))
if (!(list = virshDomainListCollect(ctl, flags)))
goto cleanup;
/* print table header in legacy mode */
@ -1931,7 +1933,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd)
else
ignore_value(virStrcpyStatic(id_buf, "-"));
state = vshDomainState(ctl, dom, NULL);
state = virshDomainState(ctl, dom, NULL);
/* Domain could've been removed in the meantime */
if (state < 0)
@ -1943,19 +1945,21 @@ cmdList(vshControl *ctl, const vshCmd *cmd)
if (optTable) {
if (optTitle) {
if (!(title = vshGetDomainDescription(ctl, dom, true, 0)))
if (!(title = virshGetDomainDescription(ctl, dom, true, 0)))
goto cleanup;
vshPrint(ctl, " %-5s %-30s %-10s %-20s\n", id_buf,
virDomainGetName(dom),
state == -2 ? _("saved") : vshDomainStateToString(state),
state == -2 ? _("saved")
: virshDomainStateToString(state),
title);
VIR_FREE(title);
} else {
vshPrint(ctl, " %-5s %-30s %s\n", id_buf,
virDomainGetName(dom),
state == -2 ? _("saved") : vshDomainStateToString(state));
state == -2 ? _("saved")
: virshDomainStateToString(state));
}
} else if (optUUID) {
if (virDomainGetUUIDString(dom, uuid) < 0) {
@ -1970,7 +1974,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd)
ret = true;
cleanup:
vshDomainListFree(list);
virshDomainListFree(list);
return ret;
}
#undef FILTER
@ -2067,9 +2071,9 @@ static const vshCmdOptDef opts_domstats[] = {
static bool
vshDomainStatsPrintRecord(vshControl *ctl ATTRIBUTE_UNUSED,
virDomainStatsRecordPtr record,
bool raw ATTRIBUTE_UNUSED)
virshDomainStatsPrintRecord(vshControl *ctl ATTRIBUTE_UNUSED,
virDomainStatsRecordPtr record,
bool raw ATTRIBUTE_UNUSED)
{
char *param;
size_t i;
@ -2104,6 +2108,7 @@ cmdDomstats(vshControl *ctl, const vshCmd *cmd)
int flags = 0;
const vshCmdOpt *opt = NULL;
bool ret = false;
virshControlPtr priv = ctl->privData;
if (vshCommandOptBool(cmd, "state"))
stats |= VIR_DOMAIN_STATS_STATE;
@ -2159,8 +2164,9 @@ cmdDomstats(vshControl *ctl, const vshCmd *cmd)
ndoms = 1;
while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
if (!(dom = vshLookupDomainBy(ctl, opt->data,
VSH_BYID | VSH_BYUUID | VSH_BYNAME)))
if (!(dom = virshLookupDomainBy(ctl, opt->data,
VIRSH_BYID |
VIRSH_BYUUID | VIRSH_BYNAME)))
goto cleanup;
if (VIR_INSERT_ELEMENT(domlist, ndoms - 1, ndoms, dom) < 0)
@ -2173,7 +2179,7 @@ cmdDomstats(vshControl *ctl, const vshCmd *cmd)
flags) < 0)
goto cleanup;
} else {
if ((virConnectGetAllDomainStats(ctl->conn,
if ((virConnectGetAllDomainStats(priv->conn,
stats,
&records,
flags)) < 0)
@ -2181,7 +2187,7 @@ cmdDomstats(vshControl *ctl, const vshCmd *cmd)
}
for (next = records; *next; next++) {
if (!vshDomainStatsPrintRecord(ctl, *next, raw))
if (!virshDomainStatsPrintRecord(ctl, *next, raw))
goto cleanup;
}
@ -2234,7 +2240,7 @@ cmdDomIfAddr(vshControl *ctl, const vshCmd *cmd)
const char *sourcestr = NULL;
int source = VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (vshCommandOptString(ctl, cmd, "interface", &ifacestr) < 0)

4
tools/virsh-domain-monitor.h
View File

@ -28,8 +28,8 @@
# include "virsh.h"
char *vshGetDomainDescription(vshControl *ctl, virDomainPtr dom,
bool title, unsigned int flags)
char *virshGetDomainDescription(vshControl *ctl, virDomainPtr dom,
bool title, unsigned int flags)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
extern const vshCmdDef domMonitoringCmds[];

1128
tools/virsh-domain.c
View File

File diff suppressed because it is too large Load Diff

15
tools/virsh-domain.h
View File

@ -28,16 +28,17 @@
# include "virsh.h"
virDomainPtr vshLookupDomainBy(vshControl *ctl,
const char *name,
unsigned int flags);
virDomainPtr virshLookupDomainBy(vshControl *ctl,
const char *name,
unsigned int flags);
virDomainPtr vshCommandOptDomainBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
virDomainPtr virshCommandOptDomainBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
/* default is lookup by Id, Name and UUID */
# define vshCommandOptDomain(_ctl, _cmd, _name) \
vshCommandOptDomainBy(_ctl, _cmd, _name, VSH_BYID|VSH_BYUUID|VSH_BYNAME)
# define virshCommandOptDomain(_ctl, _cmd, _name) \
virshCommandOptDomainBy(_ctl, _cmd, _name, \
VIRSH_BYID | VIRSH_BYUUID | VIRSH_BYNAME)
extern const vshCmdDef domManagementCmds[];

129
tools/virsh-host.c
View File

@ -57,8 +57,9 @@ static bool
cmdCapabilities(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
char *caps;
virshControlPtr priv = ctl->privData;
if ((caps = virConnectGetCapabilities(ctl->conn)) == NULL) {
if ((caps = virConnectGetCapabilities(priv->conn)) == NULL) {
vshError(ctl, "%s", _("failed to get capabilities"));
return false;
}
@ -111,6 +112,7 @@ cmdDomCapabilities(vshControl *ctl, const vshCmd *cmd)
const char *arch = NULL;
const char *machine = NULL;
const unsigned int flags = 0; /* No flags so far */
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "virttype", &virttype) < 0 ||
vshCommandOptStringReq(ctl, cmd, "emulatorbin", &emulatorbin) < 0 ||
@ -118,7 +120,7 @@ cmdDomCapabilities(vshControl *ctl, const vshCmd *cmd)
vshCommandOptStringReq(ctl, cmd, "machine", &machine) < 0)
return ret;
caps = virConnectGetDomainCapabilities(ctl->conn, emulatorbin,
caps = virConnectGetDomainCapabilities(priv->conn, emulatorbin,
arch, machine, virttype, flags);
if (!caps) {
vshError(ctl, "%s", _("failed to get emulator capabilities"));
@ -173,6 +175,7 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
char *cap_xml = NULL;
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
virshControlPtr priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
@ -180,7 +183,7 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
return false;
if (all) {
if (!(cap_xml = virConnectGetCapabilities(ctl->conn))) {
if (!(cap_xml = virConnectGetCapabilities(priv->conn))) {
vshError(ctl, "%s", _("unable to get node capabilities"));
goto cleanup;
}
@ -213,7 +216,7 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
}
VIR_FREE(val);
nodes_id[i] = id;
if (virNodeGetCellsFreeMemory(ctl->conn, &(nodes_free[i]),
if (virNodeGetCellsFreeMemory(priv->conn, &(nodes_free[i]),
id, 1) != 1) {
vshError(ctl, _("failed to get free memory for NUMA node "
"number: %lu"), id);
@ -231,12 +234,12 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
vshPrintExtra(ctl, "%5s: %10llu KiB\n", _("Total"), memory/1024);
} else {
if (cellno) {
if (virNodeGetCellsFreeMemory(ctl->conn, &memory, cell, 1) != 1)
if (virNodeGetCellsFreeMemory(priv->conn, &memory, cell, 1) != 1)
goto cleanup;
vshPrint(ctl, "%d: %llu KiB\n", cell, (memory/1024));
} else {
if ((memory = virNodeGetFreeMemory(ctl->conn)) == 0)
if ((memory = virNodeGetFreeMemory(priv->conn)) == 0)
goto cleanup;
vshPrint(ctl, "%s: %llu KiB\n", _("Total"), (memory/1024));
@ -313,6 +316,7 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
bool all = vshCommandOptBool(cmd, "all");
bool cellno = vshCommandOptBool(cmd, "cellno");
bool pagesz = vshCommandOptBool(cmd, "pagesize");
virshControlPtr priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
@ -321,7 +325,7 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
kibibytes = VIR_DIV_UP(bytes, 1024);
if (all) {
if (!(cap_xml = virConnectGetCapabilities(ctl->conn))) {
if (!(cap_xml = virConnectGetCapabilities(priv->conn))) {
vshError(ctl, "%s", _("unable to get node capabilities"));
goto cleanup;
}
@ -398,7 +402,7 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
}
VIR_FREE(val);
if (virNodeGetFreePages(ctl->conn, npages, pagesize,
if (virNodeGetFreePages(priv->conn, npages, pagesize,
cell, 1, counts, 0) < 0)
goto cleanup;
@ -434,7 +438,8 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
counts = vshMalloc(ctl, sizeof(*counts));
if (virNodeGetFreePages(ctl->conn, 1, pagesize, cell, 1, counts, 0) < 0)
if (virNodeGetFreePages(priv->conn, 1, pagesize,
cell, 1, counts, 0) < 0)
goto cleanup;
vshPrint(ctl, "%uKiB: %lld\n", *pagesize, counts[0]);
@ -506,6 +511,7 @@ cmdAllocpages(vshControl *ctl, const vshCmd *cmd)
xmlDocPtr xml = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr *nodes = NULL;
virshControlPtr priv = ctl->privData;
VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
@ -525,7 +531,7 @@ cmdAllocpages(vshControl *ctl, const vshCmd *cmd)
unsigned long nodes_cnt;
size_t i;
if (!(cap_xml = virConnectGetCapabilities(ctl->conn))) {
if (!(cap_xml = virConnectGetCapabilities(priv->conn))) {
vshError(ctl, "%s", _("unable to get node capabilities"));
goto cleanup;
}
@ -555,12 +561,12 @@ cmdAllocpages(vshControl *ctl, const vshCmd *cmd)
}
VIR_FREE(val);
if (virNodeAllocPages(ctl->conn, 1, pageSizes,
if (virNodeAllocPages(priv->conn, 1, pageSizes,
pageCounts, id, 1, flags) < 0)
goto cleanup;
}
} else {
if (virNodeAllocPages(ctl->conn, 1, pageSizes, pageCounts,
if (virNodeAllocPages(priv->conn, 1, pageSizes, pageCounts,
startCell, cellCount, flags) < 0)
goto cleanup;
}
@ -601,11 +607,12 @@ cmdMaxvcpus(vshControl *ctl, const vshCmd *cmd)
{
const char *type = NULL;
int vcpus;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0)
return false;
if ((vcpus = virConnectGetMaxVcpus(ctl->conn, type)) < 0)
if ((vcpus = virConnectGetMaxVcpus(priv->conn, type)) < 0)
return false;
vshPrint(ctl, "%d\n", vcpus);
@ -630,8 +637,9 @@ static bool
cmdNodeinfo(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
virNodeInfo info;
virshControlPtr priv = ctl->privData;
if (virNodeGetInfo(ctl->conn, &info) < 0) {
if (virNodeGetInfo(priv->conn, &info) < 0) {
vshError(ctl, "%s", _("failed to get node information"));
return false;
}
@ -678,8 +686,9 @@ cmdNodeCpuMap(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
unsigned int online;
bool pretty = vshCommandOptBool(cmd, "pretty");
bool ret = false;
virshControlPtr priv = ctl->privData;
cpunum = virNodeGetCPUMap(ctl->conn, &cpumap, &online, 0);
cpunum = virNodeGetCPUMap(priv->conn, &cpumap, &online, 0);
if (cpunum < 0) {
vshError(ctl, "%s", _("Unable to get cpu map"));
goto cleanup;
@ -735,17 +744,17 @@ static const vshCmdOptDef opts_node_cpustats[] = {
};
typedef enum {
VSH_CPU_USER,
VSH_CPU_SYSTEM,
VSH_CPU_IDLE,
VSH_CPU_IOWAIT,
VSH_CPU_INTR,
VSH_CPU_USAGE,
VSH_CPU_LAST
} vshCPUStats;
VIRSH_CPU_USER,
VIRSH_CPU_SYSTEM,
VIRSH_CPU_IDLE,
VIRSH_CPU_IOWAIT,
VIRSH_CPU_INTR,
VIRSH_CPU_USAGE,
VIRSH_CPU_LAST
} virshCPUStats;
VIR_ENUM_DECL(vshCPUStats);
VIR_ENUM_IMPL(vshCPUStats, VSH_CPU_LAST,
VIR_ENUM_DECL(virshCPUStats);
VIR_ENUM_IMPL(virshCPUStats, VIRSH_CPU_LAST,
VIR_NODE_CPU_STATS_USER,
VIR_NODE_CPU_STATS_KERNEL,
VIR_NODE_CPU_STATS_IDLE,
@ -753,7 +762,7 @@ VIR_ENUM_IMPL(vshCPUStats, VSH_CPU_LAST,
VIR_NODE_CPU_STATS_INTR,
VIR_NODE_CPU_STATS_UTILIZATION);
const char *vshCPUOutput[] = {
const char *virshCPUOutput[] = {
N_("user:"),
N_("system:"),
N_("idle:"),
@ -771,13 +780,14 @@ cmdNodeCpuStats(vshControl *ctl, const vshCmd *cmd)
virNodeCPUStatsPtr params;
int nparams = 0;
bool ret = false;
unsigned long long cpu_stats[VSH_CPU_LAST] = { 0 };
bool present[VSH_CPU_LAST] = { false };
unsigned long long cpu_stats[VIRSH_CPU_LAST] = { 0 };
bool present[VIRSH_CPU_LAST] = { false };
virshControlPtr priv = ctl->privData;
if (vshCommandOptInt(ctl, cmd, "cpu", &cpuNum) < 0)
return false;
if (virNodeGetCPUStats(ctl->conn, cpuNum, NULL, &nparams, 0) != 0) {
if (virNodeGetCPUStats(priv->conn, cpuNum, NULL, &nparams, 0) != 0) {
vshError(ctl, "%s",
_("Unable to get number of cpu stats"));
return false;
@ -791,13 +801,13 @@ cmdNodeCpuStats(vshControl *ctl, const vshCmd *cmd)
params = vshCalloc(ctl, nparams, sizeof(*params));
for (i = 0; i < 2; i++) {
if (virNodeGetCPUStats(ctl->conn, cpuNum, params, &nparams, 0) != 0) {
if (virNodeGetCPUStats(priv->conn, cpuNum, params, &nparams, 0) != 0) {
vshError(ctl, "%s", _("Unable to get node cpu stats"));
goto cleanup;
}
for (j = 0; j < nparams; j++) {
int field = vshCPUStatsTypeFromString(params[j].field);
int field = virshCPUStatsTypeFromString(params[j].field);
if (field < 0)
continue;
@ -810,34 +820,37 @@ cmdNodeCpuStats(vshControl *ctl, const vshCmd *cmd)
}
}
if (present[VSH_CPU_USAGE] || !flag_percent)
if (present[VIRSH_CPU_USAGE] || !flag_percent)
break;
sleep(1);
}
if (!flag_percent) {
for (i = 0; i < VSH_CPU_USAGE; i++) {
for (i = 0; i < VIRSH_CPU_USAGE; i++) {
if (present[i]) {
vshPrint(ctl, "%-15s %20llu\n", _(vshCPUOutput[i]),
vshPrint(ctl, "%-15s %20llu\n", _(virshCPUOutput[i]),
cpu_stats[i]);
}
}
} else {
if (present[VSH_CPU_USAGE]) {
vshPrint(ctl, "%-15s %5.1llu%%\n", _("usage:"), cpu_stats[VSH_CPU_USAGE]);
vshPrint(ctl, "%-15s %5.1llu%%\n", _("idle:"), 100 - cpu_stats[VSH_CPU_USAGE]);
if (present[VIRSH_CPU_USAGE]) {
vshPrint(ctl, "%-15s %5.1llu%%\n",
_("usage:"), cpu_stats[VIRSH_CPU_USAGE]);
vshPrint(ctl, "%-15s %5.1llu%%\n",
_("idle:"), 100 - cpu_stats[VIRSH_CPU_USAGE]);
} else {
double usage, total_time = 0;
for (i = 0; i < VSH_CPU_USAGE; i++)
for (i = 0; i < VIRSH_CPU_USAGE; i++)
total_time += cpu_stats[i];
usage = (cpu_stats[VSH_CPU_USER] + cpu_stats[VSH_CPU_SYSTEM]) / total_time * 100;
usage = (cpu_stats[VIRSH_CPU_USER] + cpu_stats[VIRSH_CPU_SYSTEM])
/ total_time * 100;
vshPrint(ctl, "%-15s %5.1lf%%\n", _("usage:"), usage);
for (i = 0; i < VSH_CPU_USAGE; i++) {
for (i = 0; i < VIRSH_CPU_USAGE; i++) {
if (present[i]) {
vshPrint(ctl, "%-15s %5.1lf%%\n", _(vshCPUOutput[i]),
vshPrint(ctl, "%-15s %5.1lf%%\n", _(virshCPUOutput[i]),
cpu_stats[i] / total_time * 100);
}
}
@ -880,12 +893,13 @@ cmdNodeMemStats(vshControl *ctl, const vshCmd *cmd)
int cellNum = VIR_NODE_MEMORY_STATS_ALL_CELLS;
virNodeMemoryStatsPtr params = NULL;
bool ret = false;
virshControlPtr priv = ctl->privData;
if (vshCommandOptInt(ctl, cmd, "cell", &cellNum) < 0)
return false;
/* get the number of memory parameters */
if (virNodeGetMemoryStats(ctl->conn, cellNum, NULL, &nparams, 0) != 0) {
if (virNodeGetMemoryStats(priv->conn, cellNum, NULL, &nparams, 0) != 0) {
vshError(ctl, "%s",
_("Unable to get number of memory stats"));
goto cleanup;
@ -899,7 +913,7 @@ cmdNodeMemStats(vshControl *ctl, const vshCmd *cmd)
/* now go get all the memory parameters */
params = vshCalloc(ctl, nparams, sizeof(*params));
if (virNodeGetMemoryStats(ctl->conn, cellNum, params, &nparams, 0) != 0) {
if (virNodeGetMemoryStats(priv->conn, cellNum, params, &nparams, 0) != 0) {
vshError(ctl, "%s", _("Unable to get memory stats"));
goto cleanup;
}
@ -949,6 +963,7 @@ cmdNodeSuspend(vshControl *ctl, const vshCmd *cmd)
const char *target = NULL;
unsigned int suspendTarget;
long long duration;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "target", &target) < 0)
return false;
@ -972,7 +987,7 @@ cmdNodeSuspend(vshControl *ctl, const vshCmd *cmd)
return false;
}
if (virNodeSuspendForDuration(ctl->conn, suspendTarget, duration, 0) < 0) {
if (virNodeSuspendForDuration(priv->conn, suspendTarget, duration, 0) < 0) {
vshError(ctl, "%s", _("The host was not suspended"));
return false;
}
@ -996,8 +1011,9 @@ static bool
cmdSysinfo(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
char *sysinfo;
virshControlPtr priv = ctl->privData;
sysinfo = virConnectGetSysinfo(ctl->conn, 0);
sysinfo = virConnectGetSysinfo(priv->conn, 0);
if (sysinfo == NULL) {
vshError(ctl, "%s", _("failed to get sysinfo"));
return false;
@ -1026,8 +1042,9 @@ static bool
cmdHostname(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
char *hostname;
virshControlPtr priv = ctl->privData;
hostname = virConnectGetHostname(ctl->conn);
hostname = virConnectGetHostname(priv->conn);
if (hostname == NULL) {
vshError(ctl, "%s", _("failed to get hostname"));
return false;
@ -1056,8 +1073,9 @@ static bool
cmdURI(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
char *uri;
virshControlPtr priv = ctl->privData;
uri = virConnectGetURI(ctl->conn);
uri = virConnectGetURI(priv->conn);
if (uri == NULL) {
vshError(ctl, "%s", _("failed to get URI"));
return false;
@ -1098,11 +1116,12 @@ cmdCPUModelNames(vshControl *ctl, const vshCmd *cmd)
size_t i;
int nmodels;
const char *arch = NULL;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "arch", &arch) < 0)
return false;
nmodels = virConnectGetCPUModelNames(ctl->conn, arch, &models, 0);
nmodels = virConnectGetCPUModelNames(priv->conn, arch, &models, 0);
if (nmodels < 0) {
vshError(ctl, "%s", _("failed to get CPU model names"));
return false;
@ -1151,8 +1170,9 @@ cmdVersion(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
unsigned int major;
unsigned int minor;
unsigned int rel;
virshControlPtr priv = ctl->privData;
hvType = virConnectGetType(ctl->conn);
hvType = virConnectGetType(priv->conn);
if (hvType == NULL) {
vshError(ctl, "%s", _("failed to get hypervisor type"));
return false;
@ -1185,7 +1205,7 @@ cmdVersion(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
vshPrint(ctl, _("Using API: %s %d.%d.%d\n"), hvType,
major, minor, rel);
ret = virConnectGetVersion(ctl->conn, &hvVersion);
ret = virConnectGetVersion(priv->conn, &hvVersion);
if (ret < 0) {
vshError(ctl, "%s", _("failed to get the hypervisor version"));
return false;
@ -1204,7 +1224,7 @@ cmdVersion(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
}
if (vshCommandOptBool(cmd, "daemon")) {
ret = virConnectGetLibVersion(ctl->conn, &daemonVersion);
ret = virConnectGetLibVersion(priv->conn, &daemonVersion);
if (ret < 0) {
vshError(ctl, "%s", _("failed to get the daemon version"));
} else {
@ -1257,6 +1277,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
int rc = -1;
size_t i;
virshControlPtr priv = ctl->privData;
if ((rc = vshCommandOptUInt(ctl, cmd, "shm-pages-to-scan", &value)) < 0) {
goto cleanup;
@ -1287,7 +1308,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
if (nparams == 0) {
/* Get the number of memory parameters */
if (virNodeGetMemoryParameters(ctl->conn, NULL, &nparams, flags) != 0) {
if (virNodeGetMemoryParameters(priv->conn, NULL, &nparams, flags) != 0) {
vshError(ctl, "%s",
_("Unable to get number of memory parameters"));
goto cleanup;
@ -1300,7 +1321,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
/* Now go get all the memory parameters */
params = vshCalloc(ctl, nparams, sizeof(*params));
if (virNodeGetMemoryParameters(ctl->conn, params, &nparams, flags) != 0) {
if (virNodeGetMemoryParameters(priv->conn, params, &nparams, flags) != 0) {
vshError(ctl, "%s", _("Unable to get memory parameters"));
goto cleanup;
}
@ -1315,7 +1336,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
VIR_FREE(str);
}
} else {
if (virNodeSetMemoryParameters(ctl->conn, params, nparams, flags) != 0)
if (virNodeSetMemoryParameters(priv->conn, params, nparams, flags) != 0)
goto error;
}

110
tools/virsh-interface.c
View File

@ -41,15 +41,16 @@
#include "virstring.h"
virInterfacePtr
vshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char **name, unsigned int flags)
virshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char **name, unsigned int flags)
{
virInterfacePtr iface = NULL;
const char *n = NULL;
bool is_mac = false;
virMacAddr dummy;
virCheckFlags(VSH_BYNAME | VSH_BYMAC, NULL);
virCheckFlags(VIRSH_BYNAME | VIRSH_BYMAC, NULL);
virshControlPtr priv = ctl->privData;
if (!optname)
optname = "interface";
@ -67,16 +68,16 @@ vshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
is_mac = true;
/* try it by NAME */
if (!is_mac && (flags & VSH_BYNAME)) {
if (!is_mac && (flags & VIRSH_BYNAME)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as interface NAME\n",
cmd->def->name, optname);
iface = virInterfaceLookupByName(ctl->conn, n);
iface = virInterfaceLookupByName(priv->conn, n);
/* try it by MAC */
} else if (is_mac && (flags & VSH_BYMAC)) {
} else if (is_mac && (flags & VIRSH_BYMAC)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as interface MAC\n",
cmd->def->name, optname);
iface = virInterfaceLookupByMACString(ctl->conn, n);
iface = virInterfaceLookupByMACString(priv->conn, n);
}
if (!iface)
@ -114,8 +115,9 @@ cmdInterfaceEdit(vshControl *ctl, const vshCmd *cmd)
virInterfacePtr iface = NULL;
virInterfacePtr iface_edited = NULL;
unsigned int flags = VIR_INTERFACE_XML_INACTIVE;
virshControlPtr priv = ctl->privData;
iface = vshCommandOptInterface(ctl, cmd, NULL);
iface = virshCommandOptInterface(ctl, cmd, NULL);
if (iface == NULL)
goto cleanup;
@ -128,7 +130,7 @@ cmdInterfaceEdit(vshControl *ctl, const vshCmd *cmd)
goto edit_cleanup; \
} while (0)
#define EDIT_DEFINE \
(iface_edited = virInterfaceDefineXML(ctl->conn, doc_edited, 0))
(iface_edited = virInterfaceDefineXML(priv->conn, doc_edited, 0))
#include "virsh-edit.c"
vshPrint(ctl, _("Interface %s XML configuration edited.\n"),
@ -146,7 +148,7 @@ cmdInterfaceEdit(vshControl *ctl, const vshCmd *cmd)
}
static int
vshInterfaceSorter(const void *a, const void *b)
virshInterfaceSorter(const void *a, const void *b)
{
virInterfacePtr *ia = (virInterfacePtr *) a;
virInterfacePtr *ib = (virInterfacePtr *) b;
@ -161,14 +163,14 @@ vshInterfaceSorter(const void *a, const void *b)
virInterfaceGetName(*ib));
}
struct vshInterfaceList {
struct virshInterfaceList {
virInterfacePtr *ifaces;
size_t nifaces;
};
typedef struct vshInterfaceList *vshInterfaceListPtr;
typedef struct virshInterfaceList *virshInterfaceListPtr;
static void
vshInterfaceListFree(vshInterfaceListPtr list)
virshInterfaceListFree(virshInterfaceListPtr list)
{
size_t i;
@ -182,11 +184,11 @@ vshInterfaceListFree(vshInterfaceListPtr list)
VIR_FREE(list);
}
static vshInterfaceListPtr
vshInterfaceListCollect(vshControl *ctl,
unsigned int flags)
static virshInterfaceListPtr
virshInterfaceListCollect(vshControl *ctl,
unsigned int flags)
{
vshInterfaceListPtr list = vshMalloc(ctl, sizeof(*list));
virshInterfaceListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
char **activeNames = NULL;
@ -197,9 +199,10 @@ vshInterfaceListCollect(vshControl *ctl,
int nActiveIfaces = 0;
int nInactiveIfaces = 0;
int nAllIfaces = 0;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllInterfaces(ctl->conn,
if ((ret = virConnectListAllInterfaces(priv->conn,
&list->ifaces,
flags)) >= 0) {
list->nifaces = ret;
@ -220,7 +223,7 @@ vshInterfaceListCollect(vshControl *ctl,
vshResetLibvirtError();
if (flags & VIR_CONNECT_LIST_INTERFACES_ACTIVE) {
nActiveIfaces = virConnectNumOfInterfaces(ctl->conn);
nActiveIfaces = virConnectNumOfInterfaces(priv->conn);
if (nActiveIfaces < 0) {
vshError(ctl, "%s", _("Failed to list active interfaces"));
goto cleanup;
@ -228,7 +231,7 @@ vshInterfaceListCollect(vshControl *ctl,
if (nActiveIfaces) {
activeNames = vshMalloc(ctl, sizeof(char *) * nActiveIfaces);
if ((nActiveIfaces = virConnectListInterfaces(ctl->conn, activeNames,
if ((nActiveIfaces = virConnectListInterfaces(priv->conn, activeNames,
nActiveIfaces)) < 0) {
vshError(ctl, "%s", _("Failed to list active interfaces"));
goto cleanup;
@ -237,7 +240,7 @@ vshInterfaceListCollect(vshControl *ctl,
}
if (flags & VIR_CONNECT_LIST_INTERFACES_INACTIVE) {
nInactiveIfaces = virConnectNumOfDefinedInterfaces(ctl->conn);
nInactiveIfaces = virConnectNumOfDefinedInterfaces(priv->conn);
if (nInactiveIfaces < 0) {
vshError(ctl, "%s", _("Failed to list inactive interfaces"));
goto cleanup;
@ -246,7 +249,7 @@ vshInterfaceListCollect(vshControl *ctl,
inactiveNames = vshMalloc(ctl, sizeof(char *) * nInactiveIfaces);
if ((nInactiveIfaces =
virConnectListDefinedInterfaces(ctl->conn, inactiveNames,
virConnectListDefinedInterfaces(priv->conn, inactiveNames,
nInactiveIfaces)) < 0) {
vshError(ctl, "%s", _("Failed to list inactive interfaces"));
goto cleanup;
@ -266,7 +269,7 @@ vshInterfaceListCollect(vshControl *ctl,
/* get active interfaces */
for (i = 0; i < nActiveIfaces; i++) {
if (!(iface = virInterfaceLookupByName(ctl->conn, activeNames[i]))) {
if (!(iface = virInterfaceLookupByName(priv->conn, activeNames[i]))) {
vshResetLibvirtError();
continue;
}
@ -275,7 +278,7 @@ vshInterfaceListCollect(vshControl *ctl,
/* get inactive interfaces */
for (i = 0; i < nInactiveIfaces; i++) {
if (!(iface = virInterfaceLookupByName(ctl->conn, inactiveNames[i]))) {
if (!(iface = virInterfaceLookupByName(priv->conn, inactiveNames[i]))) {
vshResetLibvirtError();
continue;
}
@ -289,7 +292,7 @@ vshInterfaceListCollect(vshControl *ctl,
/* sort the list */
if (list->ifaces && list->nifaces)
qsort(list->ifaces, list->nifaces,
sizeof(*list->ifaces), vshInterfaceSorter);
sizeof(*list->ifaces), virshInterfaceSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
@ -308,7 +311,7 @@ vshInterfaceListCollect(vshControl *ctl,
VIR_FREE(inactiveNames);
if (!success) {
vshInterfaceListFree(list);
virshInterfaceListFree(list);
list = NULL;
}
@ -346,7 +349,7 @@ cmdInterfaceList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
bool inactive = vshCommandOptBool(cmd, "inactive");
bool all = vshCommandOptBool(cmd, "all");
unsigned int flags = VIR_CONNECT_LIST_INTERFACES_ACTIVE;
vshInterfaceListPtr list = NULL;
virshInterfaceListPtr list = NULL;
size_t i;
if (inactive)
@ -355,7 +358,7 @@ cmdInterfaceList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
flags = VIR_CONNECT_LIST_INTERFACES_INACTIVE |
VIR_CONNECT_LIST_INTERFACES_ACTIVE;
if (!(list = vshInterfaceListCollect(ctl, flags)))
if (!(list = virshInterfaceListCollect(ctl, flags)))
return false;
vshPrintExtra(ctl, " %-20s %-10s %s\n", _("Name"), _("State"),
@ -371,7 +374,7 @@ cmdInterfaceList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
virInterfaceGetMACString(iface));
}
vshInterfaceListFree(list);
virshInterfaceListFree(list);
return true;
}
@ -402,8 +405,8 @@ cmdInterfaceName(vshControl *ctl, const vshCmd *cmd)
{
virInterfacePtr iface;
if (!(iface = vshCommandOptInterfaceBy(ctl, cmd, NULL, NULL,
VSH_BYMAC)))
if (!(iface = virshCommandOptInterfaceBy(ctl, cmd, NULL, NULL,
VIRSH_BYMAC)))
return false;
vshPrint(ctl, "%s\n", virInterfaceGetName(iface));
@ -438,8 +441,8 @@ cmdInterfaceMAC(vshControl *ctl, const vshCmd *cmd)
{
virInterfacePtr iface;
if (!(iface = vshCommandOptInterfaceBy(ctl, cmd, NULL, NULL,
VSH_BYNAME)))
if (!(iface = virshCommandOptInterfaceBy(ctl, cmd, NULL, NULL,
VIRSH_BYNAME)))
return false;
vshPrint(ctl, "%s\n", virInterfaceGetMACString(iface));
@ -485,7 +488,7 @@ cmdInterfaceDumpXML(vshControl *ctl, const vshCmd *cmd)
if (inactive)
flags |= VIR_INTERFACE_XML_INACTIVE;
if (!(iface = vshCommandOptInterface(ctl, cmd, NULL)))
if (!(iface = virshCommandOptInterface(ctl, cmd, NULL)))
return false;
dump = virInterfaceGetXMLDesc(iface, flags);
@ -530,6 +533,7 @@ cmdInterfaceDefine(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -537,7 +541,7 @@ cmdInterfaceDefine(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
iface = virInterfaceDefineXML(ctl->conn, buffer, 0);
iface = virInterfaceDefineXML(priv->conn, buffer, 0);
VIR_FREE(buffer);
if (iface != NULL) {
@ -580,7 +584,7 @@ cmdInterfaceUndefine(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(iface = vshCommandOptInterface(ctl, cmd, &name)))
if (!(iface = virshCommandOptInterface(ctl, cmd, &name)))
return false;
if (virInterfaceUndefine(iface) == 0) {
@ -623,7 +627,7 @@ cmdInterfaceStart(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(iface = vshCommandOptInterface(ctl, cmd, &name)))
if (!(iface = virshCommandOptInterface(ctl, cmd, &name)))
return false;
if (virInterfaceCreate(iface, 0) == 0) {
@ -666,7 +670,7 @@ cmdInterfaceDestroy(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(iface = vshCommandOptInterface(ctl, cmd, &name)))
if (!(iface = virshCommandOptInterface(ctl, cmd, &name)))
return false;
if (virInterfaceDestroy(iface, 0) == 0) {
@ -702,7 +706,9 @@ static const vshCmdOptDef opts_interface_begin[] = {
static bool
cmdInterfaceBegin(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
if (virInterfaceChangeBegin(ctl->conn, 0) < 0) {
virshControlPtr priv = ctl->privData;
if (virInterfaceChangeBegin(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to begin network config change transaction"));
return false;
}
@ -731,7 +737,9 @@ static const vshCmdOptDef opts_interface_commit[] = {
static bool
cmdInterfaceCommit(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
if (virInterfaceChangeCommit(ctl->conn, 0) < 0) {
virshControlPtr priv = ctl->privData;
if (virInterfaceChangeCommit(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to commit network config change transaction"));
return false;
}
@ -760,7 +768,9 @@ static const vshCmdOptDef opts_interface_rollback[] = {
static bool
cmdInterfaceRollback(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
if (virInterfaceChangeRollback(ctl->conn, 0) < 0) {
virshControlPtr priv = ctl->privData;
if (virInterfaceChangeRollback(priv->conn, 0) < 0) {
vshError(ctl, "%s", _("Failed to rollback network config change transaction"));
return false;
}
@ -823,10 +833,11 @@ cmdInterfaceBridge(vshControl *ctl, const vshCmd *cmd)
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr top_node, br_node, if_node, cur;
virshControlPtr priv = ctl->privData;
/* Get a handle to the original device */
if (!(if_handle = vshCommandOptInterfaceBy(ctl, cmd, "interface",
&if_name, VSH_BYNAME))) {
if (!(if_handle = virshCommandOptInterfaceBy(ctl, cmd, "interface",
&if_name, VIRSH_BYNAME))) {
goto cleanup;
}
@ -835,7 +846,7 @@ cmdInterfaceBridge(vshControl *ctl, const vshCmd *cmd)
goto cleanup;
/* make sure "new" device doesn't already exist */
if ((br_handle = virInterfaceLookupByName(ctl->conn, br_name))) {
if ((br_handle = virInterfaceLookupByName(priv->conn, br_name))) {
vshError(ctl, _("Network device %s already exists"), br_name);
goto cleanup;
}
@ -969,7 +980,7 @@ cmdInterfaceBridge(vshControl *ctl, const vshCmd *cmd)
/* br_xml is the new interface to define. It will automatically undefine the
* independent original interface.
*/
if (!(br_handle = virInterfaceDefineXML(ctl->conn, (char *) br_xml, 0))) {
if (!(br_handle = virInterfaceDefineXML(priv->conn, (char *) br_xml, 0))) {
vshError(ctl, _("Failed to define new bridge interface %s"),
br_name);
goto cleanup;
@ -1043,10 +1054,11 @@ cmdInterfaceUnbridge(vshControl *ctl, const vshCmd *cmd)
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr ctxt = NULL;
xmlNodePtr top_node, if_node, cur;
virshControlPtr priv = ctl->privData;
/* Get a handle to the original device */
if (!(br_handle = vshCommandOptInterfaceBy(ctl, cmd, "bridge",
&br_name, VSH_BYNAME))) {
if (!(br_handle = virshCommandOptInterfaceBy(ctl, cmd, "bridge",
&br_name, VIRSH_BYNAME))) {
goto cleanup;
}
@ -1170,7 +1182,7 @@ cmdInterfaceUnbridge(vshControl *ctl, const vshCmd *cmd)
/* if_xml is the new interface to define.
*/
if (!(if_handle = virInterfaceDefineXML(ctl->conn, (char *) if_xml, 0))) {
if (!(if_handle = virInterfaceDefineXML(priv->conn, (char *) if_xml, 0))) {
vshError(ctl, _("Failed to define new interface %s"), if_name);
goto cleanup;
}

12
tools/virsh-interface.h
View File

@ -28,14 +28,14 @@
# include "virsh.h"
virInterfacePtr vshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char **name, unsigned int flags);
virInterfacePtr virshCommandOptInterfaceBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char **name, unsigned int flags);
/* default is lookup by Name and MAC */
# define vshCommandOptInterface(_ctl, _cmd, _name) \
vshCommandOptInterfaceBy(_ctl, _cmd, NULL, _name, \
VSH_BYMAC|VSH_BYNAME)
# define virshCommandOptInterface(_ctl, _cmd, _name) \
virshCommandOptInterfaceBy(_ctl, _cmd, NULL, _name, \
VIRSH_BYMAC | VIRSH_BYNAME)
extern const vshCmdDef ifaceCmds[];

134
tools/virsh-network.c
View File

@ -34,13 +34,14 @@
#include "conf/network_conf.h"
virNetworkPtr
vshCommandOptNetworkBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags)
virshCommandOptNetworkBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags)
{
virNetworkPtr network = NULL;
const char *n = NULL;
const char *optname = "network";
virCheckFlags(VSH_BYUUID | VSH_BYNAME, NULL);
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
@ -52,16 +53,16 @@ vshCommandOptNetworkBy(vshControl *ctl, const vshCmd *cmd,
*name = n;
/* try it by UUID */
if ((flags & VSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
if ((flags & VIRSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as network UUID\n",
cmd->def->name, optname);
network = virNetworkLookupByUUIDString(ctl->conn, n);
network = virNetworkLookupByUUIDString(priv->conn, n);
}
/* try it by NAME */
if (!network && (flags & VSH_BYNAME)) {
if (!network && (flags & VIRSH_BYNAME)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as network NAME\n",
cmd->def->name, optname);
network = virNetworkLookupByName(ctl->conn, n);
network = virNetworkLookupByName(priv->conn, n);
}
if (!network)
@ -103,7 +104,7 @@ cmdNetworkAutostart(vshControl *ctl, const vshCmd *cmd)
const char *name;
int autostart;
if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
autostart = !vshCommandOptBool(cmd, "disable");
@ -155,6 +156,7 @@ cmdNetworkCreate(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -162,7 +164,7 @@ cmdNetworkCreate(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
network = virNetworkCreateXML(ctl->conn, buffer);
network = virNetworkCreateXML(priv->conn, buffer);
VIR_FREE(buffer);
if (network != NULL) {
@ -206,6 +208,7 @@ cmdNetworkDefine(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -213,7 +216,7 @@ cmdNetworkDefine(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
network = virNetworkDefineXML(ctl->conn, buffer);
network = virNetworkDefineXML(priv->conn, buffer);
VIR_FREE(buffer);
if (network != NULL) {
@ -256,7 +259,7 @@ cmdNetworkDestroy(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
if (virNetworkDestroy(network) == 0) {
@ -305,7 +308,7 @@ cmdNetworkDumpXML(vshControl *ctl, const vshCmd *cmd)
unsigned int flags = 0;
int inactive;
if (!(network = vshCommandOptNetwork(ctl, cmd, NULL)))
if (!(network = virshCommandOptNetwork(ctl, cmd, NULL)))
return false;
inactive = vshCommandOptBool(cmd, "inactive");
@ -357,7 +360,7 @@ cmdNetworkInfo(vshControl *ctl, const vshCmd *cmd)
int active = -1;
char *bridge = NULL;
if (!(network = vshCommandOptNetwork(ctl, cmd, NULL)))
if (!(network = virshCommandOptNetwork(ctl, cmd, NULL)))
return false;
vshPrint(ctl, "%-15s %s\n", _("Name:"), virNetworkGetName(network));
@ -390,7 +393,7 @@ cmdNetworkInfo(vshControl *ctl, const vshCmd *cmd)
}
static int
vshNetworkSorter(const void *a, const void *b)
virshNetworkSorter(const void *a, const void *b)
{
virNetworkPtr *na = (virNetworkPtr *) a;
virNetworkPtr *nb = (virNetworkPtr *) b;
@ -405,14 +408,14 @@ vshNetworkSorter(const void *a, const void *b)
virNetworkGetName(*nb));
}
struct vshNetworkList {
struct virshNetworkList {
virNetworkPtr *nets;
size_t nnets;
};
typedef struct vshNetworkList *vshNetworkListPtr;
typedef struct virshNetworkList *virshNetworkListPtr;
static void
vshNetworkListFree(vshNetworkListPtr list)
virshNetworkListFree(virshNetworkListPtr list)
{
size_t i;
@ -426,11 +429,11 @@ vshNetworkListFree(vshNetworkListPtr list)
VIR_FREE(list);
}
static vshNetworkListPtr
vshNetworkListCollect(vshControl *ctl,
unsigned int flags)
static virshNetworkListPtr
virshNetworkListCollect(vshControl *ctl,
unsigned int flags)
{
vshNetworkListPtr list = vshMalloc(ctl, sizeof(*list));
virshNetworkListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
char **names = NULL;
@ -442,9 +445,10 @@ vshNetworkListCollect(vshControl *ctl,
int nActiveNets = 0;
int nInactiveNets = 0;
int nAllNets = 0;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNetworks(ctl->conn,
if ((ret = virConnectListAllNetworks(priv->conn,
&list->nets,
flags)) >= 0) {
list->nnets = ret;
@ -461,7 +465,7 @@ vshNetworkListCollect(vshControl *ctl,
VIR_CONNECT_LIST_NETWORKS_INACTIVE);
vshResetLibvirtError();
if ((ret = virConnectListAllNetworks(ctl->conn, &list->nets,
if ((ret = virConnectListAllNetworks(priv->conn, &list->nets,
newflags)) >= 0) {
list->nnets = ret;
goto filter;
@ -480,7 +484,7 @@ vshNetworkListCollect(vshControl *ctl,
/* Get the number of active networks */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if ((nActiveNets = virConnectNumOfNetworks(ctl->conn)) < 0) {
if ((nActiveNets = virConnectNumOfNetworks(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of active networks"));
goto cleanup;
}
@ -489,7 +493,7 @@ vshNetworkListCollect(vshControl *ctl,
/* Get the number of inactive networks */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_INACTIVE)) {
if ((nInactiveNets = virConnectNumOfDefinedNetworks(ctl->conn)) < 0) {
if ((nInactiveNets = virConnectNumOfDefinedNetworks(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of inactive networks"));
goto cleanup;
}
@ -505,7 +509,7 @@ vshNetworkListCollect(vshControl *ctl,
/* Retrieve a list of active network names */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if (virConnectListNetworks(ctl->conn,
if (virConnectListNetworks(priv->conn,
names, nActiveNets) < 0) {
vshError(ctl, "%s", _("Failed to list active networks"));
goto cleanup;
@ -515,7 +519,7 @@ vshNetworkListCollect(vshControl *ctl,
/* Add the inactive networks to the end of the name list */
if (!VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_NETWORKS_ACTIVE)) {
if (virConnectListDefinedNetworks(ctl->conn,
if (virConnectListDefinedNetworks(priv->conn,
&names[nActiveNets],
nInactiveNets) < 0) {
vshError(ctl, "%s", _("Failed to list inactive networks"));
@ -528,14 +532,14 @@ vshNetworkListCollect(vshControl *ctl,
/* get active networks */
for (i = 0; i < nActiveNets; i++) {
if (!(net = virNetworkLookupByName(ctl->conn, names[i])))
if (!(net = virNetworkLookupByName(priv->conn, names[i])))
continue;
list->nets[list->nnets++] = net;
}
/* get inactive networks */
for (i = 0; i < nInactiveNets; i++) {
if (!(net = virNetworkLookupByName(ctl->conn, names[i])))
if (!(net = virNetworkLookupByName(priv->conn, names[i])))
continue;
list->nets[list->nnets++] = net;
}
@ -585,7 +589,7 @@ vshNetworkListCollect(vshControl *ctl,
/* sort the list */
if (list->nets && list->nnets)
qsort(list->nets, list->nnets,
sizeof(*list->nets), vshNetworkSorter);
sizeof(*list->nets), virshNetworkSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
@ -599,7 +603,7 @@ vshNetworkListCollect(vshControl *ctl,
VIR_FREE(names);
if (!success) {
vshNetworkListFree(list);
virshNetworkListFree(list);
list = NULL;
}
@ -665,7 +669,7 @@ static const vshCmdOptDef opts_network_list[] = {
static bool
cmdNetworkList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
vshNetworkListPtr list = NULL;
virshNetworkListPtr list = NULL;
size_t i;
bool ret = false;
bool optName = vshCommandOptBool(cmd, "name");
@ -697,7 +701,7 @@ cmdNetworkList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
if (!optUUID && !optName)
optTable = true;
if (!(list = vshNetworkListCollect(ctl, flags)))
if (!(list = virshNetworkListCollect(ctl, flags)))
return false;
if (optTable) {
@ -736,7 +740,7 @@ cmdNetworkList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
ret = true;
cleanup:
vshNetworkListFree(list);
virshNetworkListFree(list);
return ret;
}
#undef FILTER
@ -768,8 +772,8 @@ cmdNetworkName(vshControl *ctl, const vshCmd *cmd)
{
virNetworkPtr network;
if (!(network = vshCommandOptNetworkBy(ctl, cmd, NULL,
VSH_BYUUID)))
if (!(network = virshCommandOptNetworkBy(ctl, cmd, NULL,
VIRSH_BYUUID)))
return false;
vshPrint(ctl, "%s\n", virNetworkGetName(network));
@ -806,7 +810,7 @@ cmdNetworkStart(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name = NULL;
if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
if (virNetworkCreate(network) == 0) {
@ -848,7 +852,7 @@ cmdNetworkUndefine(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
if (virNetworkUndefine(network) == 0) {
@ -943,7 +947,7 @@ cmdNetworkUpdate(vshControl *ctl, const vshCmd *cmd)
unsigned int flags = 0;
const char *affected;
if (!(network = vshCommandOptNetwork(ctl, cmd, NULL)))
if (!(network = virshCommandOptNetwork(ctl, cmd, NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "command", &commandStr) < 0)
@ -1066,8 +1070,8 @@ cmdNetworkUuid(vshControl *ctl, const vshCmd *cmd)
virNetworkPtr network;
char uuid[VIR_UUID_STRING_BUFLEN];
if (!(network = vshCommandOptNetworkBy(ctl, cmd, NULL,
VSH_BYNAME)))
if (!(network = virshCommandOptNetworkBy(ctl, cmd, NULL,
VIRSH_BYNAME)))
return false;
if (virNetworkGetUUIDString(network, uuid) != -1)
@ -1101,7 +1105,7 @@ static const vshCmdOptDef opts_network_edit[] = {
{.name = NULL}
};
static char *vshNetworkGetXMLDesc(virNetworkPtr network)
static char *virshNetworkGetXMLDesc(virNetworkPtr network)
{
unsigned int flags = VIR_NETWORK_XML_INACTIVE;
char *doc = virNetworkGetXMLDesc(network, flags);
@ -1123,12 +1127,13 @@ cmdNetworkEdit(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
virNetworkPtr network = NULL;
virNetworkPtr network_edited = NULL;
virshControlPtr priv = ctl->privData;
network = vshCommandOptNetwork(ctl, cmd, NULL);
network = virshCommandOptNetwork(ctl, cmd, NULL);
if (network == NULL)
goto cleanup;
#define EDIT_GET_XML vshNetworkGetXMLDesc(network)
#define EDIT_GET_XML virshNetworkGetXMLDesc(network)
#define EDIT_NOT_CHANGED \
do { \
vshPrint(ctl, _("Network %s XML configuration not changed.\n"), \
@ -1137,7 +1142,7 @@ cmdNetworkEdit(vshControl *ctl, const vshCmd *cmd)
goto edit_cleanup; \
} while (0)
#define EDIT_DEFINE \
(network_edited = virNetworkDefineXML(ctl->conn, doc_edited))
(network_edited = virNetworkDefineXML(priv->conn, doc_edited))
#include "virsh-edit.c"
vshPrint(ctl, _("Network %s XML configuration edited.\n"),
@ -1158,8 +1163,8 @@ cmdNetworkEdit(vshControl *ctl, const vshCmd *cmd)
/*
* "net-event" command
*/
VIR_ENUM_DECL(vshNetworkEvent)
VIR_ENUM_IMPL(vshNetworkEvent,
VIR_ENUM_DECL(virshNetworkEvent)
VIR_ENUM_IMPL(virshNetworkEvent,
VIR_NETWORK_EVENT_LAST,
N_("Defined"),
N_("Undefined"),
@ -1167,21 +1172,21 @@ VIR_ENUM_IMPL(vshNetworkEvent,
N_("Stopped"))
static const char *
vshNetworkEventToString(int event)
virshNetworkEventToString(int event)
{
const char *str = vshNetworkEventTypeToString(event);
const char *str = virshNetworkEventTypeToString(event);
return str ? _(str) : _("unknown");
}
struct vshNetEventData {
struct virshNetEventData {
vshControl *ctl;
bool loop;
int count;
};
typedef struct vshNetEventData vshNetEventData;
typedef struct virshNetEventData virshNetEventData;
VIR_ENUM_DECL(vshNetworkEventId)
VIR_ENUM_IMPL(vshNetworkEventId,
VIR_ENUM_DECL(virshNetworkEventId)
VIR_ENUM_IMPL(virshNetworkEventId,
VIR_NETWORK_EVENT_ID_LAST,
"lifecycle")
@ -1192,12 +1197,12 @@ vshEventLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED,
int detail ATTRIBUTE_UNUSED,
void *opaque)
{
vshNetEventData *data = opaque;
virshNetEventData *data = opaque;
if (!data->loop && data->count)
return;
vshPrint(data->ctl, _("event 'lifecycle' for network %s: %s\n"),
virNetworkGetName(net), vshNetworkEventToString(event));
virNetworkGetName(net), virshNetworkEventToString(event));
data->count++;
if (!data->loop)
vshEventDone(data->ctl);
@ -1244,15 +1249,16 @@ cmdNetworkEvent(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
int eventId = -1;
int timeout = 0;
vshNetEventData data;
virshNetEventData data;
const char *eventName = NULL;
int event;
virshControlPtr priv = ctl->privData;
if (vshCommandOptBool(cmd, "list")) {
size_t i;
for (i = 0; i < VIR_NETWORK_EVENT_ID_LAST; i++)
vshPrint(ctl, "%s\n", vshNetworkEventIdTypeToString(i));
vshPrint(ctl, "%s\n", virshNetworkEventIdTypeToString(i));
return true;
}
@ -1262,7 +1268,7 @@ cmdNetworkEvent(vshControl *ctl, const vshCmd *cmd)
vshError(ctl, "%s", _("either --list or event type is required"));
return false;
}
if ((event = vshNetworkEventIdTypeFromString(eventName)) < 0) {
if ((event = virshNetworkEventIdTypeFromString(eventName)) < 0) {
vshError(ctl, _("unknown event type %s"), eventName);
return false;
}
@ -1274,11 +1280,11 @@ cmdNetworkEvent(vshControl *ctl, const vshCmd *cmd)
return false;
if (vshCommandOptBool(cmd, "network"))
net = vshCommandOptNetwork(ctl, cmd, NULL);
net = virshCommandOptNetwork(ctl, cmd, NULL);
if (vshEventStart(ctl, timeout) < 0)
goto cleanup;
if ((eventId = virConnectNetworkEventRegisterAny(ctl->conn, net, event,
if ((eventId = virConnectNetworkEventRegisterAny(priv->conn, net, event,
VIR_NETWORK_EVENT_CALLBACK(vshEventLifecyclePrint),
&data, NULL)) < 0)
goto cleanup;
@ -1301,7 +1307,7 @@ cmdNetworkEvent(vshControl *ctl, const vshCmd *cmd)
cleanup:
vshEventCleanup(ctl);
if (eventId >= 0 &&
virConnectNetworkEventDeregisterAny(ctl->conn, eventId) < 0)
virConnectNetworkEventDeregisterAny(priv->conn, eventId) < 0)
ret = false;
if (net)
virNetworkFree(net);
@ -1337,7 +1343,7 @@ static const vshCmdOptDef opts_network_dhcp_leases[] = {
};
static int
vshNetworkDHCPLeaseSorter(const void *a, const void *b)
virshNetworkDHCPLeaseSorter(const void *a, const void *b)
{
int rv = -1;
@ -1369,7 +1375,7 @@ cmdNetworkDHCPLeases(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptString(ctl, cmd, "mac", &mac) < 0)
return false;
if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
if (!(network = virshCommandOptNetwork(ctl, cmd, &name)))
return false;
if ((nleases = virNetworkGetDHCPLeases(network, mac, &leases, flags)) < 0) {
@ -1378,7 +1384,7 @@ cmdNetworkDHCPLeases(vshControl *ctl, const vshCmd *cmd)
}
/* Sort the list according to MAC Address/IAID */
qsort(leases, nleases, sizeof(*leases), vshNetworkDHCPLeaseSorter);
qsort(leases, nleases, sizeof(*leases), virshNetworkDHCPLeaseSorter);
vshPrintExtra(ctl, " %-20s %-18s %-9s %-25s %-15s %s\n%s%s\n",
_("Expiry Time"), _("MAC address"), _("Protocol"),

10
tools/virsh-network.h
View File

@ -29,13 +29,13 @@
# include "virsh.h"
virNetworkPtr
vshCommandOptNetworkBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
virshCommandOptNetworkBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
/* default is lookup by Name and UUID */
# define vshCommandOptNetwork(_ctl, _cmd, _name) \
vshCommandOptNetworkBy(_ctl, _cmd, _name, \
VSH_BYUUID|VSH_BYNAME)
# define virshCommandOptNetwork(_ctl, _cmd, _name) \
virshCommandOptNetworkBy(_ctl, _cmd, _name, \
VIRSH_BYUUID | VIRSH_BYNAME)
extern const vshCmdDef networkCmds[];

65
tools/virsh-nodedev.c
View File

@ -65,6 +65,7 @@ cmdNodeDeviceCreate(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -72,7 +73,7 @@ cmdNodeDeviceCreate(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
dev = virNodeDeviceCreateXML(ctl->conn, buffer, 0);
dev = virNodeDeviceCreateXML(priv->conn, buffer, 0);
VIR_FREE(buffer);
if (dev != NULL) {
@ -123,6 +124,7 @@ cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
const char *device_value = NULL;
char **arr = NULL;
int narr;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &device_value) < 0)
return false;
@ -137,9 +139,9 @@ cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
if (!virValidateWWN(arr[0]) || !virValidateWWN(arr[1]))
goto cleanup;
dev = virNodeDeviceLookupSCSIHostByWWN(ctl->conn, arr[0], arr[1], 0);
dev = virNodeDeviceLookupSCSIHostByWWN(priv->conn, arr[0], arr[1], 0);
} else {
dev = virNodeDeviceLookupByName(ctl->conn, device_value);
dev = virNodeDeviceLookupByName(priv->conn, device_value);
}
if (!dev) {
@ -162,22 +164,22 @@ cmdNodeDeviceDestroy(vshControl *ctl, const vshCmd *cmd)
return ret;
}
struct vshNodeList {
struct virshNodeList {
char **names;
char **parents;
};
static const char *
vshNodeListLookup(int devid, bool parent, void *opaque)
virshNodeListLookup(int devid, bool parent, void *opaque)
{
struct vshNodeList *arrays = opaque;
struct virshNodeList *arrays = opaque;
if (parent)
return arrays->parents[devid];
return arrays->names[devid];
}
static int
vshNodeDeviceSorter(const void *a, const void *b)
virshNodeDeviceSorter(const void *a, const void *b)
{
virNodeDevicePtr *na = (virNodeDevicePtr *) a;
virNodeDevicePtr *nb = (virNodeDevicePtr *) b;
@ -192,14 +194,14 @@ vshNodeDeviceSorter(const void *a, const void *b)
virNodeDeviceGetName(*nb));
}
struct vshNodeDeviceList {
struct virshNodeDeviceList {
virNodeDevicePtr *devices;
size_t ndevices;
};
typedef struct vshNodeDeviceList *vshNodeDeviceListPtr;
typedef struct virshNodeDeviceList *virshNodeDeviceListPtr;
static void
vshNodeDeviceListFree(vshNodeDeviceListPtr list)
virshNodeDeviceListFree(virshNodeDeviceListPtr list)
{
size_t i;
@ -213,13 +215,13 @@ vshNodeDeviceListFree(vshNodeDeviceListPtr list)
VIR_FREE(list);
}
static vshNodeDeviceListPtr
vshNodeDeviceListCollect(vshControl *ctl,
static virshNodeDeviceListPtr
virshNodeDeviceListCollect(vshControl *ctl,
char **capnames,
int ncapnames,
unsigned int flags)
{
vshNodeDeviceListPtr list = vshMalloc(ctl, sizeof(*list));
virshNodeDeviceListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
virNodeDevicePtr device;
@ -227,9 +229,10 @@ vshNodeDeviceListCollect(vshControl *ctl,
size_t deleted = 0;
int ndevices = 0;
char **names = NULL;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNodeDevices(ctl->conn,
if ((ret = virConnectListAllNodeDevices(priv->conn,
&list->devices,
flags)) >= 0) {
list->ndevices = ret;
@ -249,7 +252,7 @@ vshNodeDeviceListCollect(vshControl *ctl,
/* fall back to old method (0.10.1 and older) */
vshResetLibvirtError();
ndevices = virNodeNumOfDevices(ctl->conn, NULL, 0);
ndevices = virNodeNumOfDevices(priv->conn, NULL, 0);
if (ndevices < 0) {
vshError(ctl, "%s", _("Failed to count node devices"));
goto cleanup;
@ -260,7 +263,7 @@ vshNodeDeviceListCollect(vshControl *ctl,
names = vshMalloc(ctl, sizeof(char *) * ndevices);
ndevices = virNodeListDevices(ctl->conn, NULL, names, ndevices, 0);
ndevices = virNodeListDevices(priv->conn, NULL, names, ndevices, 0);
if (ndevices < 0) {
vshError(ctl, "%s", _("Failed to list node devices"));
goto cleanup;
@ -271,7 +274,7 @@ vshNodeDeviceListCollect(vshControl *ctl,
/* get the node devices */
for (i = 0; i < ndevices; i++) {
if (!(device = virNodeDeviceLookupByName(ctl->conn, names[i])))
if (!(device = virNodeDeviceLookupByName(priv->conn, names[i])))
continue;
list->devices[list->ndevices++] = device;
}
@ -336,7 +339,7 @@ vshNodeDeviceListCollect(vshControl *ctl,
/* sort the list */
if (list->devices && list->ndevices)
qsort(list->devices, list->ndevices,
sizeof(*list->devices), vshNodeDeviceSorter);
sizeof(*list->devices), virshNodeDeviceSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
@ -350,7 +353,7 @@ vshNodeDeviceListCollect(vshControl *ctl,
VIR_FREE(names);
if (!success) {
vshNodeDeviceListFree(list);
virshNodeDeviceListFree(list);
list = NULL;
}
@ -392,7 +395,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
unsigned int flags = 0;
char **caps = NULL;
int ncaps = 0;
vshNodeDeviceListPtr list = NULL;
virshNodeDeviceListPtr list = NULL;
int cap_type = -1;
ignore_value(vshCommandOptString(ctl, cmd, "cap", &cap_str));
@ -455,7 +458,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
}
}
if (!(list = vshNodeDeviceListCollect(ctl, caps, ncaps, flags))) {
if (!(list = virshNodeDeviceListCollect(ctl, caps, ncaps, flags))) {
ret = false;
goto cleanup;
}
@ -463,7 +466,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
if (tree) {
char **parents = vshMalloc(ctl, sizeof(char *) * list->ndevices);
char **names = vshMalloc(ctl, sizeof(char *) * list->ndevices);
struct vshNodeList arrays = { names, parents };
struct virshNodeList arrays = { names, parents };
for (i = 0; i < list->ndevices; i++)
names[i] = vshStrdup(ctl, virNodeDeviceGetName(list->devices[i]));
@ -480,7 +483,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
for (i = 0; i < list->ndevices; i++) {
if (parents[i] == NULL &&
vshTreePrint(ctl, vshNodeListLookup, &arrays,
vshTreePrint(ctl, virshNodeListLookup, &arrays,
list->ndevices, i) < 0)
ret = false;
}
@ -498,7 +501,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
cleanup:
virStringFreeList(caps);
vshNodeDeviceListFree(list);
virshNodeDeviceListFree(list);
return ret;
}
@ -534,6 +537,7 @@ cmdNodeDeviceDumpXML(vshControl *ctl, const vshCmd *cmd)
char **arr = NULL;
int narr;
bool ret = false;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &device_value) < 0)
return false;
@ -548,9 +552,9 @@ cmdNodeDeviceDumpXML(vshControl *ctl, const vshCmd *cmd)
if (!virValidateWWN(arr[0]) || !virValidateWWN(arr[1]))
goto cleanup;
device = virNodeDeviceLookupSCSIHostByWWN(ctl->conn, arr[0], arr[1], 0);
device = virNodeDeviceLookupSCSIHostByWWN(priv->conn, arr[0], arr[1], 0);
} else {
device = virNodeDeviceLookupByName(ctl->conn, device_value);
device = virNodeDeviceLookupByName(priv->conn, device_value);
}
if (!device) {
@ -606,13 +610,14 @@ cmdNodeDeviceDetach(vshControl *ctl, const vshCmd *cmd)
const char *driverName = NULL;
virNodeDevicePtr device;
bool ret = true;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
ignore_value(vshCommandOptString(ctl, cmd, "driver", &driverName));
if (!(device = virNodeDeviceLookupByName(ctl->conn, name))) {
if (!(device = virNodeDeviceLookupByName(priv->conn, name))) {
vshError(ctl, _("Could not find matching device '%s'"), name);
return false;
}
@ -666,11 +671,12 @@ cmdNodeDeviceReAttach(vshControl *ctl, const vshCmd *cmd)
const char *name = NULL;
virNodeDevicePtr device;
bool ret = true;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
if (!(device = virNodeDeviceLookupByName(ctl->conn, name))) {
if (!(device = virNodeDeviceLookupByName(priv->conn, name))) {
vshError(ctl, _("Could not find matching device '%s'"), name);
return false;
}
@ -715,11 +721,12 @@ cmdNodeDeviceReset(vshControl *ctl, const vshCmd *cmd)
const char *name = NULL;
virNodeDevicePtr device;
bool ret = true;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
return false;
if (!(device = virNodeDeviceLookupByName(ctl->conn, name))) {
if (!(device = virNodeDeviceLookupByName(priv->conn, name))) {
vshError(ctl, _("Could not find matching device '%s'"), name);
return false;
}

63
tools/virsh-nwfilter.c
View File

@ -33,13 +33,15 @@
#include "virutil.h"
virNWFilterPtr
vshCommandOptNWFilterBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags)
virshCommandOptNWFilterBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags)
{
virNWFilterPtr nwfilter = NULL;
const char *n = NULL;
const char *optname = "nwfilter";
virCheckFlags(VSH_BYUUID | VSH_BYNAME, NULL);
virshControlPtr priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
@ -51,16 +53,16 @@ vshCommandOptNWFilterBy(vshControl *ctl, const vshCmd *cmd,
*name = n;
/* try it by UUID */
if ((flags & VSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
if ((flags & VIRSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as nwfilter UUID\n",
cmd->def->name, optname);
nwfilter = virNWFilterLookupByUUIDString(ctl->conn, n);
nwfilter = virNWFilterLookupByUUIDString(priv->conn, n);
}
/* try it by NAME */
if (!nwfilter && (flags & VSH_BYNAME)) {
if (!nwfilter && (flags & VIRSH_BYNAME)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as nwfilter NAME\n",
cmd->def->name, optname);
nwfilter = virNWFilterLookupByName(ctl->conn, n);
nwfilter = virNWFilterLookupByName(priv->conn, n);
}
if (!nwfilter)
@ -98,6 +100,7 @@ cmdNWFilterDefine(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -105,7 +108,7 @@ cmdNWFilterDefine(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
nwfilter = virNWFilterDefineXML(ctl->conn, buffer);
nwfilter = virNWFilterDefineXML(priv->conn, buffer);
VIR_FREE(buffer);
if (nwfilter != NULL) {
@ -148,7 +151,7 @@ cmdNWFilterUndefine(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(nwfilter = vshCommandOptNWFilter(ctl, cmd, &name)))
if (!(nwfilter = virshCommandOptNWFilter(ctl, cmd, &name)))
return false;
if (virNWFilterUndefine(nwfilter) == 0) {
@ -191,7 +194,7 @@ cmdNWFilterDumpXML(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
char *dump;
if (!(nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL)))
if (!(nwfilter = virshCommandOptNWFilter(ctl, cmd, NULL)))
return false;
dump = virNWFilterGetXMLDesc(nwfilter, 0);
@ -207,7 +210,7 @@ cmdNWFilterDumpXML(vshControl *ctl, const vshCmd *cmd)
}
static int
vshNWFilterSorter(const void *a, const void *b)
virshNWFilterSorter(const void *a, const void *b)
{
virNWFilterPtr *fa = (virNWFilterPtr *) a;
virNWFilterPtr *fb = (virNWFilterPtr *) b;
@ -222,14 +225,14 @@ vshNWFilterSorter(const void *a, const void *b)
virNWFilterGetName(*fb));
}
struct vshNWFilterList {
struct virshNWFilterList {
virNWFilterPtr *filters;
size_t nfilters;
};
typedef struct vshNWFilterList *vshNWFilterListPtr;
typedef struct virshNWFilterList *virshNWFilterListPtr;
static void
vshNWFilterListFree(vshNWFilterListPtr list)
virshNWFilterListFree(virshNWFilterListPtr list)
{
size_t i;
@ -243,11 +246,11 @@ vshNWFilterListFree(vshNWFilterListPtr list)
VIR_FREE(list);
}
static vshNWFilterListPtr
vshNWFilterListCollect(vshControl *ctl,
unsigned int flags)
static virshNWFilterListPtr
virshNWFilterListCollect(vshControl *ctl,
unsigned int flags)
{
vshNWFilterListPtr list = vshMalloc(ctl, sizeof(*list));
virshNWFilterListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
virNWFilterPtr filter;
@ -255,9 +258,10 @@ vshNWFilterListCollect(vshControl *ctl,
size_t deleted = 0;
int nfilters = 0;
char **names = NULL;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllNWFilters(ctl->conn,
if ((ret = virConnectListAllNWFilters(priv->conn,
&list->filters,
flags)) >= 0) {
list->nfilters = ret;
@ -279,7 +283,7 @@ vshNWFilterListCollect(vshControl *ctl,
/* fall back to old method (0.9.13 and older) */
vshResetLibvirtError();
nfilters = virConnectNumOfNWFilters(ctl->conn);
nfilters = virConnectNumOfNWFilters(priv->conn);
if (nfilters < 0) {
vshError(ctl, "%s", _("Failed to count network filters"));
goto cleanup;
@ -290,7 +294,7 @@ vshNWFilterListCollect(vshControl *ctl,
names = vshMalloc(ctl, sizeof(char *) * nfilters);
nfilters = virConnectListNWFilters(ctl->conn, names, nfilters);
nfilters = virConnectListNWFilters(priv->conn, names, nfilters);
if (nfilters < 0) {
vshError(ctl, "%s", _("Failed to list network filters"));
goto cleanup;
@ -301,7 +305,7 @@ vshNWFilterListCollect(vshControl *ctl,
/* get the network filters */
for (i = 0; i < nfilters; i++) {
if (!(filter = virNWFilterLookupByName(ctl->conn, names[i])))
if (!(filter = virNWFilterLookupByName(priv->conn, names[i])))
continue;
list->filters[list->nfilters++] = filter;
}
@ -313,7 +317,7 @@ vshNWFilterListCollect(vshControl *ctl,
/* sort the list */
if (list->filters && list->nfilters)
qsort(list->filters, list->nfilters,
sizeof(*list->filters), vshNWFilterSorter);
sizeof(*list->filters), virshNWFilterSorter);
/* truncate the list for not found filter objects */
if (deleted)
@ -327,7 +331,7 @@ vshNWFilterListCollect(vshControl *ctl,
VIR_FREE(names);
if (!success) {
vshNWFilterListFree(list);
virshNWFilterListFree(list);
list = NULL;
}
@ -356,9 +360,9 @@ cmdNWFilterList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
size_t i;
char uuid[VIR_UUID_STRING_BUFLEN];
vshNWFilterListPtr list = NULL;
virshNWFilterListPtr list = NULL;
if (!(list = vshNWFilterListCollect(ctl, 0)))
if (!(list = virshNWFilterListCollect(ctl, 0)))
return false;
vshPrintExtra(ctl, " %-36s %-20s \n", _("UUID"), _("Name"));
@ -374,7 +378,7 @@ cmdNWFilterList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
virNWFilterGetName(nwfilter));
}
vshNWFilterListFree(list);
virshNWFilterListFree(list);
return true;
}
@ -406,8 +410,9 @@ cmdNWFilterEdit(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
virNWFilterPtr nwfilter = NULL;
virNWFilterPtr nwfilter_edited = NULL;
virshControlPtr priv = ctl->privData;
nwfilter = vshCommandOptNWFilter(ctl, cmd, NULL);
nwfilter = virshCommandOptNWFilter(ctl, cmd, NULL);
if (nwfilter == NULL)
goto cleanup;
@ -421,7 +426,7 @@ cmdNWFilterEdit(vshControl *ctl, const vshCmd *cmd)
goto edit_cleanup; \
} while (0)
#define EDIT_DEFINE \
(nwfilter_edited = virNWFilterDefineXML(ctl->conn, doc_edited))
(nwfilter_edited = virNWFilterDefineXML(priv->conn, doc_edited))
#include "virsh-edit.c"
vshPrint(ctl, _("Network filter %s XML configuration edited.\n"),

10
tools/virsh-nwfilter.h
View File

@ -29,13 +29,13 @@
# include "virsh.h"
virNWFilterPtr
vshCommandOptNWFilterBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
virshCommandOptNWFilterBy(vshControl *ctl, const vshCmd *cmd,
const char **name, unsigned int flags);
/* default is lookup by Name and UUID */
# define vshCommandOptNWFilter(_ctl, _cmd, _name) \
vshCommandOptNWFilterBy(_ctl, _cmd, _name, \
VSH_BYUUID|VSH_BYNAME)
# define virshCommandOptNWFilter(_ctl, _cmd, _name) \
virshCommandOptNWFilterBy(_ctl, _cmd, _name, \
VIRSH_BYUUID | VIRSH_BYNAME)
extern const vshCmdDef nwfilterCmds[];

130
tools/virsh-pool.c
View File

@ -34,12 +34,14 @@
#include "virstring.h"
virStoragePoolPtr
vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
const char **name, unsigned int flags)
virshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
const char **name, unsigned int flags)
{
virStoragePoolPtr pool = NULL;
const char *n = NULL;
virCheckFlags(VSH_BYUUID | VSH_BYNAME, NULL);
virshControlPtr priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
@ -51,16 +53,16 @@ vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
*name = n;
/* try it by UUID */
if ((flags & VSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
if ((flags & VIRSH_BYUUID) && strlen(n) == VIR_UUID_STRING_BUFLEN-1) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool UUID\n",
cmd->def->name, optname);
pool = virStoragePoolLookupByUUIDString(ctl->conn, n);
pool = virStoragePoolLookupByUUIDString(priv->conn, n);
}
/* try it by NAME */
if (!pool && (flags & VSH_BYNAME)) {
if (!pool && (flags & VIRSH_BYNAME)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as pool NAME\n",
cmd->def->name, optname);
pool = virStoragePoolLookupByName(ctl->conn, n);
pool = virStoragePoolLookupByName(priv->conn, n);
}
if (!pool)
@ -102,7 +104,7 @@ cmdPoolAutostart(vshControl *ctl, const vshCmd *cmd)
const char *name;
int autostart;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
autostart = !vshCommandOptBool(cmd, "disable");
@ -154,6 +156,7 @@ cmdPoolCreate(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -161,7 +164,7 @@ cmdPoolCreate(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
pool = virStoragePoolCreateXML(ctl->conn, buffer, 0);
pool = virStoragePoolCreateXML(priv->conn, buffer, 0);
VIR_FREE(buffer);
if (pool != NULL) {
@ -249,10 +252,10 @@ static const vshCmdOptDef opts_pool_X_as[] = {
};
static int
vshBuildPoolXML(vshControl *ctl,
const vshCmd *cmd,
const char **retname,
char **xml)
virshBuildPoolXML(vshControl *ctl,
const vshCmd *cmd,
const char **retname,
char **xml)
{
const char *name = NULL, *type = NULL, *srcHost = NULL, *srcPath = NULL,
*srcDev = NULL, *srcName = NULL, *srcFormat = NULL,
@ -365,15 +368,16 @@ cmdPoolCreateAs(vshControl *ctl, const vshCmd *cmd)
const char *name;
char *xml;
bool printXML = vshCommandOptBool(cmd, "print-xml");
virshControlPtr priv = ctl->privData;
if (!vshBuildPoolXML(ctl, cmd, &name, &xml))
if (!virshBuildPoolXML(ctl, cmd, &name, &xml))
return false;
if (printXML) {
vshPrint(ctl, "%s", xml);
VIR_FREE(xml);
} else {
pool = virStoragePoolCreateXML(ctl->conn, xml, 0);
pool = virStoragePoolCreateXML(priv->conn, xml, 0);
VIR_FREE(xml);
if (pool != NULL) {
@ -417,6 +421,7 @@ cmdPoolDefine(vshControl *ctl, const vshCmd *cmd)
const char *from = NULL;
bool ret = true;
char *buffer;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -424,7 +429,7 @@ cmdPoolDefine(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
pool = virStoragePoolDefineXML(ctl->conn, buffer, 0);
pool = virStoragePoolDefineXML(priv->conn, buffer, 0);
VIR_FREE(buffer);
if (pool != NULL) {
@ -458,15 +463,16 @@ cmdPoolDefineAs(vshControl *ctl, const vshCmd *cmd)
const char *name;
char *xml;
bool printXML = vshCommandOptBool(cmd, "print-xml");
virshControlPtr priv = ctl->privData;
if (!vshBuildPoolXML(ctl, cmd, &name, &xml))
if (!virshBuildPoolXML(ctl, cmd, &name, &xml))
return false;
if (printXML) {
vshPrint(ctl, "%s", xml);
VIR_FREE(xml);
} else {
pool = virStoragePoolDefineXML(ctl->conn, xml, 0);
pool = virStoragePoolDefineXML(priv->conn, xml, 0);
VIR_FREE(xml);
if (pool != NULL) {
@ -518,7 +524,7 @@ cmdPoolBuild(vshControl *ctl, const vshCmd *cmd)
const char *name;
unsigned int flags = 0;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (vshCommandOptBool(cmd, "no-overwrite"))
@ -568,7 +574,7 @@ cmdPoolDestroy(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (virStoragePoolDestroy(pool) == 0) {
@ -611,7 +617,7 @@ cmdPoolDelete(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (virStoragePoolDelete(pool, 0) == 0) {
@ -654,7 +660,7 @@ cmdPoolRefresh(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (virStoragePoolRefresh(pool, 0) == 0) {
@ -706,7 +712,7 @@ cmdPoolDumpXML(vshControl *ctl, const vshCmd *cmd)
if (inactive)
flags |= VIR_STORAGE_XML_INACTIVE;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
return false;
dump = virStoragePoolGetXMLDesc(pool, flags);
@ -722,7 +728,7 @@ cmdPoolDumpXML(vshControl *ctl, const vshCmd *cmd)
}
static int
vshStoragePoolSorter(const void *a, const void *b)
virshStoragePoolSorter(const void *a, const void *b)
{
virStoragePoolPtr *pa = (virStoragePoolPtr *) a;
virStoragePoolPtr *pb = (virStoragePoolPtr *) b;
@ -737,14 +743,14 @@ vshStoragePoolSorter(const void *a, const void *b)
virStoragePoolGetName(*pb));
}
struct vshStoragePoolList {
struct virshStoragePoolList {
virStoragePoolPtr *pools;
size_t npools;
};
typedef struct vshStoragePoolList *vshStoragePoolListPtr;
typedef struct virshStoragePoolList *virshStoragePoolListPtr;
static void
vshStoragePoolListFree(vshStoragePoolListPtr list)
virshStoragePoolListFree(virshStoragePoolListPtr list)
{
size_t i;
@ -758,11 +764,11 @@ vshStoragePoolListFree(vshStoragePoolListPtr list)
VIR_FREE(list);
}
static vshStoragePoolListPtr
vshStoragePoolListCollect(vshControl *ctl,
unsigned int flags)
static virshStoragePoolListPtr
virshStoragePoolListCollect(vshControl *ctl,
unsigned int flags)
{
vshStoragePoolListPtr list = vshMalloc(ctl, sizeof(*list));
virshStoragePoolListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
char **names = NULL;
@ -774,9 +780,10 @@ vshStoragePoolListCollect(vshControl *ctl,
int nActivePools = 0;
int nInactivePools = 0;
int nAllPools = 0;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllStoragePools(ctl->conn,
if ((ret = virConnectListAllStoragePools(priv->conn,
&list->pools,
flags)) >= 0) {
list->npools = ret;
@ -792,7 +799,7 @@ vshStoragePoolListCollect(vshControl *ctl,
unsigned int newflags = flags & (VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE |
VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE);
vshResetLibvirtError();
if ((ret = virConnectListAllStoragePools(ctl->conn, &list->pools,
if ((ret = virConnectListAllStoragePools(priv->conn, &list->pools,
newflags)) >= 0) {
list->npools = ret;
goto filter;
@ -818,7 +825,7 @@ vshStoragePoolListCollect(vshControl *ctl,
/* Get the number of active pools */
if (!VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE)) {
if ((nActivePools = virConnectNumOfStoragePools(ctl->conn)) < 0) {
if ((nActivePools = virConnectNumOfStoragePools(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of active pools "));
goto cleanup;
}
@ -827,7 +834,7 @@ vshStoragePoolListCollect(vshControl *ctl,
/* Get the number of inactive pools */
if (!VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE)) {
if ((nInactivePools = virConnectNumOfDefinedStoragePools(ctl->conn)) < 0) {
if ((nInactivePools = virConnectNumOfDefinedStoragePools(priv->conn)) < 0) {
vshError(ctl, "%s", _("Failed to get the number of inactive pools"));
goto cleanup;
}
@ -843,7 +850,7 @@ vshStoragePoolListCollect(vshControl *ctl,
/* Retrieve a list of active storage pool names */
if (!VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE)) {
if (virConnectListStoragePools(ctl->conn,
if (virConnectListStoragePools(priv->conn,
names, nActivePools) < 0) {
vshError(ctl, "%s", _("Failed to list active pools"));
goto cleanup;
@ -853,7 +860,7 @@ vshStoragePoolListCollect(vshControl *ctl,
/* Add the inactive storage pools to the end of the name list */
if (!VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_FILTERS_ACTIVE) ||
VSH_MATCH(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE)) {
if (virConnectListDefinedStoragePools(ctl->conn,
if (virConnectListDefinedStoragePools(priv->conn,
&names[nActivePools],
nInactivePools) < 0) {
vshError(ctl, "%s", _("Failed to list inactive pools"));
@ -866,14 +873,14 @@ vshStoragePoolListCollect(vshControl *ctl,
/* get active pools */
for (i = 0; i < nActivePools; i++) {
if (!(pool = virStoragePoolLookupByName(ctl->conn, names[i])))
if (!(pool = virStoragePoolLookupByName(priv->conn, names[i])))
continue;
list->pools[list->npools++] = pool;
}
/* get inactive pools */
for (i = 0; i < nInactivePools; i++) {
if (!(pool = virStoragePoolLookupByName(ctl->conn, names[i])))
if (!(pool = virStoragePoolLookupByName(priv->conn, names[i])))
continue;
list->pools[list->npools++] = pool;
}
@ -924,7 +931,7 @@ vshStoragePoolListCollect(vshControl *ctl,
/* sort the list */
if (list->pools && list->npools)
qsort(list->pools, list->npools,
sizeof(*list->pools), vshStoragePoolSorter);
sizeof(*list->pools), virshStoragePoolSorter);
/* truncate the list if filter simulation deleted entries */
if (deleted)
@ -937,7 +944,7 @@ vshStoragePoolListCollect(vshControl *ctl,
VIR_FREE(names[i]);
if (!success) {
vshStoragePoolListFree(list);
virshStoragePoolListFree(list);
list = NULL;
}
@ -946,8 +953,8 @@ vshStoragePoolListCollect(vshControl *ctl,
}
VIR_ENUM_DECL(vshStoragePoolState)
VIR_ENUM_IMPL(vshStoragePoolState,
VIR_ENUM_DECL(virshStoragePoolState)
VIR_ENUM_IMPL(virshStoragePoolState,
VIR_STORAGE_POOL_STATE_LAST,
N_("inactive"),
N_("building"),
@ -956,9 +963,9 @@ VIR_ENUM_IMPL(vshStoragePoolState,
N_("inaccessible"))
static const char *
vshStoragePoolStateToString(int state)
virshStoragePoolStateToString(int state)
{
const char *str = vshStoragePoolStateTypeToString(state);
const char *str = virshStoragePoolStateTypeToString(state);
return str ? _(str) : _("unknown");
}
@ -1032,7 +1039,7 @@ cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
};
struct poolInfoText *poolInfoTexts = NULL;
unsigned int flags = VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE;
vshStoragePoolListPtr list = NULL;
virshStoragePoolListPtr list = NULL;
const char *type = NULL;
bool details = vshCommandOptBool(cmd, "details");
bool inactive, all;
@ -1122,7 +1129,7 @@ cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
virStringFreeList(poolTypes);
}
if (!(list = vshStoragePoolListCollect(ctl, flags)))
if (!(list = virshStoragePoolListCollect(ctl, flags)))
goto cleanup;
poolInfoTexts = vshCalloc(ctl, list->npools, sizeof(*poolInfoTexts));
@ -1168,7 +1175,7 @@ cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
} else {
/* Decide which state string to display */
if (details) {
const char *state = vshStoragePoolStateToString(info.state);
const char *state = virshStoragePoolStateToString(info.state);
poolInfoTexts[i].state = vshStrdup(ctl, state);
@ -1371,7 +1378,7 @@ cmdPoolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
}
VIR_FREE(poolInfoTexts);
vshStoragePoolListFree(list);
virshStoragePoolListFree(list);
return ret;
}
@ -1416,6 +1423,7 @@ cmdPoolDiscoverSourcesAs(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
char *srcSpec = NULL;
char *srcList;
const char *initiator = NULL;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0 ||
vshCommandOptStringReq(ctl, cmd, "host", &host) < 0 ||
@ -1453,7 +1461,7 @@ cmdPoolDiscoverSourcesAs(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
srcSpec = virBufferContentAndReset(&buf);
}
srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
srcList = virConnectFindStoragePoolSources(priv->conn, type, srcSpec, 0);
VIR_FREE(srcSpec);
if (srcList == NULL) {
vshError(ctl, _("Failed to find any %s pool sources"), type);
@ -1496,6 +1504,7 @@ cmdPoolDiscoverSources(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
{
const char *type = NULL, *srcSpecFile = NULL;
char *srcSpec = NULL, *srcList;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "type", &type) < 0)
return false;
@ -1507,7 +1516,7 @@ cmdPoolDiscoverSources(vshControl * ctl, const vshCmd * cmd ATTRIBUTE_UNUSED)
&srcSpec) < 0)
return false;
srcList = virConnectFindStoragePoolSources(ctl->conn, type, srcSpec, 0);
srcList = virConnectFindStoragePoolSources(priv->conn, type, srcSpec, 0);
VIR_FREE(srcSpec);
if (srcList == NULL) {
vshError(ctl, _("Failed to find any %s pool sources"), type);
@ -1551,7 +1560,7 @@ cmdPoolInfo(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
char uuid[VIR_UUID_STRING_BUFLEN];
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
return false;
vshPrint(ctl, "%-15s %s\n", _("Name:"), virStoragePoolGetName(pool));
@ -1563,7 +1572,7 @@ cmdPoolInfo(vshControl *ctl, const vshCmd *cmd)
double val;
const char *unit;
vshPrint(ctl, "%-15s %s\n", _("State:"),
vshStoragePoolStateToString(info.state));
virshStoragePoolStateToString(info.state));
/* Check and display whether the pool is persistent or not */
persistent = virStoragePoolIsPersistent(pool);
@ -1626,8 +1635,7 @@ cmdPoolName(vshControl *ctl, const vshCmd *cmd)
{
virStoragePoolPtr pool;
if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
VSH_BYUUID)))
if (!(pool = virshCommandOptPoolBy(ctl, cmd, "pool", NULL, VIRSH_BYUUID)))
return false;
vshPrint(ctl, "%s\n", virStoragePoolGetName(pool));
@ -1664,7 +1672,7 @@ cmdPoolStart(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name = NULL;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (virStoragePoolCreate(pool, 0) == 0) {
@ -1707,7 +1715,7 @@ cmdPoolUndefine(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", &name)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", &name)))
return false;
if (virStoragePoolUndefine(pool) == 0) {
@ -1749,8 +1757,7 @@ cmdPoolUuid(vshControl *ctl, const vshCmd *cmd)
virStoragePoolPtr pool;
char uuid[VIR_UUID_STRING_BUFLEN];
if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
VSH_BYNAME)))
if (!(pool = virshCommandOptPoolBy(ctl, cmd, "pool", NULL, VIRSH_BYNAME)))
return false;
if (virStoragePoolGetUUIDString(pool, uuid) != -1)
@ -1792,8 +1799,9 @@ cmdPoolEdit(vshControl *ctl, const vshCmd *cmd)
virStoragePoolPtr pool_edited = NULL;
unsigned int flags = VIR_STORAGE_XML_INACTIVE;
char *tmp_desc = NULL;
virshControlPtr priv = ctl->privData;
pool = vshCommandOptPool(ctl, cmd, "pool", NULL);
pool = virshCommandOptPool(ctl, cmd, "pool", NULL);
if (pool == NULL)
goto cleanup;
@ -1818,7 +1826,7 @@ cmdPoolEdit(vshControl *ctl, const vshCmd *cmd)
goto edit_cleanup; \
} while (0)
#define EDIT_DEFINE \
(pool_edited = virStoragePoolDefineXML(ctl->conn, doc_edited, 0))
(pool_edited = virStoragePoolDefineXML(priv->conn, doc_edited, 0))
#include "virsh-edit.c"
vshPrint(ctl, _("Pool %s XML configuration edited.\n"),

10
tools/virsh-pool.h
View File

@ -29,13 +29,13 @@
# include "virsh.h"
virStoragePoolPtr
vshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
const char **name, unsigned int flags);
virshCommandOptPoolBy(vshControl *ctl, const vshCmd *cmd, const char *optname,
const char **name, unsigned int flags);
/* default is lookup by Name and UUID */
# define vshCommandOptPool(_ctl, _cmd, _optname, _name) \
vshCommandOptPoolBy(_ctl, _cmd, _optname, _name, \
VSH_BYUUID|VSH_BYNAME)
# define virshCommandOptPool(_ctl, _cmd, _optname, _name) \
virshCommandOptPoolBy(_ctl, _cmd, _optname, _name, \
VIRSH_BYUUID | VIRSH_BYNAME)
extern const vshCmdDef storagePoolCmds[];

51
tools/virsh-secret.c
View File

@ -35,11 +35,12 @@
#include "conf/secret_conf.h"
static virSecretPtr
vshCommandOptSecret(vshControl *ctl, const vshCmd *cmd, const char **name)
virshCommandOptSecret(vshControl *ctl, const vshCmd *cmd, const char **name)
{
virSecretPtr secret = NULL;
const char *n = NULL;
const char *optname = "secret";
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
@ -50,7 +51,7 @@ vshCommandOptSecret(vshControl *ctl, const vshCmd *cmd, const char **name)
if (name != NULL)
*name = n;
secret = virSecretLookupByUUIDString(ctl->conn, n);
secret = virSecretLookupByUUIDString(priv->conn, n);
if (secret == NULL)
vshError(ctl, _("failed to get secret '%s'"), n);
@ -88,6 +89,7 @@ cmdSecretDefine(vshControl *ctl, const vshCmd *cmd)
virSecretPtr res;
char uuid[VIR_UUID_STRING_BUFLEN];
bool ret = false;
virshControlPtr priv = ctl->privData;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
return false;
@ -95,7 +97,7 @@ cmdSecretDefine(vshControl *ctl, const vshCmd *cmd)
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0)
return false;
if (!(res = virSecretDefineXML(ctl->conn, buffer, 0))) {
if (!(res = virSecretDefineXML(priv->conn, buffer, 0))) {
vshError(ctl, _("Failed to set attributes from %s"), from);
goto cleanup;
}
@ -144,7 +146,7 @@ cmdSecretDumpXML(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
char *xml;
secret = vshCommandOptSecret(ctl, cmd, NULL);
secret = virshCommandOptSecret(ctl, cmd, NULL);
if (secret == NULL)
return false;
@ -197,7 +199,7 @@ cmdSecretSetValue(vshControl *ctl, const vshCmd *cmd)
int res;
bool ret = false;
if (!(secret = vshCommandOptSecret(ctl, cmd, NULL)))
if (!(secret = virshCommandOptSecret(ctl, cmd, NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "base64", &base64) < 0)
@ -259,7 +261,7 @@ cmdSecretGetValue(vshControl *ctl, const vshCmd *cmd)
size_t value_size;
bool ret = false;
secret = vshCommandOptSecret(ctl, cmd, NULL);
secret = virshCommandOptSecret(ctl, cmd, NULL);
if (secret == NULL)
return false;
@ -314,7 +316,7 @@ cmdSecretUndefine(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
const char *uuid;
secret = vshCommandOptSecret(ctl, cmd, &uuid);
secret = virshCommandOptSecret(ctl, cmd, &uuid);
if (secret == NULL)
return false;
@ -331,7 +333,7 @@ cmdSecretUndefine(vshControl *ctl, const vshCmd *cmd)
}
static int
vshSecretSorter(const void *a, const void *b)
virshSecretSorter(const void *a, const void *b)
{
virSecretPtr *sa = (virSecretPtr *) a;
virSecretPtr *sb = (virSecretPtr *) b;
@ -350,14 +352,14 @@ vshSecretSorter(const void *a, const void *b)
return vshStrcasecmp(uuid_sa, uuid_sb);
}
struct vshSecretList {
struct virshSecretList {
virSecretPtr *secrets;
size_t nsecrets;
};
typedef struct vshSecretList *vshSecretListPtr;
typedef struct virshSecretList *virshSecretListPtr;
static void
vshSecretListFree(vshSecretListPtr list)
virshSecretListFree(virshSecretListPtr list)
{
size_t i;
@ -371,11 +373,11 @@ vshSecretListFree(vshSecretListPtr list)
VIR_FREE(list);
}
static vshSecretListPtr
vshSecretListCollect(vshControl *ctl,
unsigned int flags)
static virshSecretListPtr
virshSecretListCollect(vshControl *ctl,
unsigned int flags)
{
vshSecretListPtr list = vshMalloc(ctl, sizeof(*list));
virshSecretListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
int ret;
virSecretPtr secret;
@ -383,9 +385,10 @@ vshSecretListCollect(vshControl *ctl,
size_t deleted = 0;
int nsecrets = 0;
char **uuids = NULL;
virshControlPtr priv = ctl->privData;
/* try the list with flags support (0.10.2 and later) */
if ((ret = virConnectListAllSecrets(ctl->conn,
if ((ret = virConnectListAllSecrets(priv->conn,
&list->secrets,
flags)) >= 0) {
list->nsecrets = ret;
@ -410,7 +413,7 @@ vshSecretListCollect(vshControl *ctl,
goto cleanup;
}
nsecrets = virConnectNumOfSecrets(ctl->conn);
nsecrets = virConnectNumOfSecrets(priv->conn);
if (nsecrets < 0) {
vshError(ctl, "%s", _("Failed to count secrets"));
goto cleanup;
@ -421,7 +424,7 @@ vshSecretListCollect(vshControl *ctl,
uuids = vshMalloc(ctl, sizeof(char *) * nsecrets);
nsecrets = virConnectListSecrets(ctl->conn, uuids, nsecrets);
nsecrets = virConnectListSecrets(priv->conn, uuids, nsecrets);
if (nsecrets < 0) {
vshError(ctl, "%s", _("Failed to list secrets"));
goto cleanup;
@ -432,7 +435,7 @@ vshSecretListCollect(vshControl *ctl,
/* get the secrets */
for (i = 0; i < nsecrets; i++) {
if (!(secret = virSecretLookupByUUIDString(ctl->conn, uuids[i])))
if (!(secret = virSecretLookupByUUIDString(priv->conn, uuids[i])))
continue;
list->secrets[list->nsecrets++] = secret;
}
@ -444,7 +447,7 @@ vshSecretListCollect(vshControl *ctl,
/* sort the list */
if (list->secrets && list->nsecrets)
qsort(list->secrets, list->nsecrets,
sizeof(*list->secrets), vshSecretSorter);
sizeof(*list->secrets), virshSecretSorter);
/* truncate the list for not found secret objects */
if (deleted)
@ -460,7 +463,7 @@ vshSecretListCollect(vshControl *ctl,
}
if (!success) {
vshSecretListFree(list);
virshSecretListFree(list);
list = NULL;
}
@ -504,7 +507,7 @@ static bool
cmdSecretList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
{
size_t i;
vshSecretListPtr list = NULL;
virshSecretListPtr list = NULL;
bool ret = false;
unsigned int flags = 0;
@ -520,7 +523,7 @@ cmdSecretList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
if (vshCommandOptBool(cmd, "no-private"))
flags |= VIR_CONNECT_LIST_SECRETS_NO_PRIVATE;
if (!(list = vshSecretListCollect(ctl, flags)))
if (!(list = virshSecretListCollect(ctl, flags)))
return false;
vshPrintExtra(ctl, " %-36s %s\n", _("UUID"), _("Usage"));
@ -551,7 +554,7 @@ cmdSecretList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
ret = true;
cleanup:
vshSecretListFree(list);
virshSecretListFree(list);
return ret;
}

155
tools/virsh-snapshot.c
View File

@ -44,8 +44,8 @@
/* Helper for snapshot-create and snapshot-create-as */
static bool
vshSnapshotCreate(vshControl *ctl, virDomainPtr dom, const char *buffer,
unsigned int flags, const char *from)
virshSnapshotCreate(vshControl *ctl, virDomainPtr dom, const char *buffer,
unsigned int flags, const char *from)
{
bool ret = false;
virDomainSnapshotPtr snapshot;
@ -199,7 +199,7 @@ cmdSnapshotCreate(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "live"))
flags |= VIR_DOMAIN_SNAPSHOT_CREATE_LIVE;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
goto cleanup;
if (vshCommandOptStringReq(ctl, cmd, "xmlfile", &from) < 0)
@ -213,7 +213,7 @@ cmdSnapshotCreate(vshControl *ctl, const vshCmd *cmd)
}
}
ret = vshSnapshotCreate(ctl, dom, buffer, flags, from);
ret = virshSnapshotCreate(ctl, dom, buffer, flags, from);
cleanup:
VIR_FREE(buffer);
@ -227,7 +227,7 @@ cmdSnapshotCreate(vshControl *ctl, const vshCmd *cmd)
* "snapshot-create-as" command
*/
static int
vshParseSnapshotMemspec(vshControl *ctl, virBufferPtr buf, const char *str)
virshParseSnapshotMemspec(vshControl *ctl, virBufferPtr buf, const char *str)
{
int ret = -1;
const char *snapshot = NULL;
@ -267,7 +267,7 @@ vshParseSnapshotMemspec(vshControl *ctl, virBufferPtr buf, const char *str)
}
static int
vshParseSnapshotDiskspec(vshControl *ctl, virBufferPtr buf, const char *str)
virshParseSnapshotDiskspec(vshControl *ctl, virBufferPtr buf, const char *str)
{
int ret = -1;
const char *name = NULL;
@ -419,7 +419,7 @@ cmdSnapshotCreateAs(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "live"))
flags |= VIR_DOMAIN_SNAPSHOT_CREATE_LIVE;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0 ||
@ -434,14 +434,14 @@ cmdSnapshotCreateAs(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptStringReq(ctl, cmd, "memspec", &memspec) < 0)
goto cleanup;
if (memspec && vshParseSnapshotMemspec(ctl, &buf, memspec) < 0)
if (memspec && virshParseSnapshotMemspec(ctl, &buf, memspec) < 0)
goto cleanup;
if (vshCommandOptBool(cmd, "diskspec")) {
virBufferAddLit(&buf, "<disks>\n");
virBufferAdjustIndent(&buf, 2);
while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
if (vshParseSnapshotDiskspec(ctl, &buf, opt->data) < 0)
if (virshParseSnapshotDiskspec(ctl, &buf, opt->data) < 0)
goto cleanup;
}
virBufferAdjustIndent(&buf, -2);
@ -463,7 +463,7 @@ cmdSnapshotCreateAs(vshControl *ctl, const vshCmd *cmd)
goto cleanup;
}
ret = vshSnapshotCreate(ctl, dom, buffer, flags, NULL);
ret = virshSnapshotCreate(ctl, dom, buffer, flags, NULL);
cleanup:
virBufferFreeAndReset(&buf);
@ -478,9 +478,9 @@ cmdSnapshotCreateAs(vshControl *ctl, const vshCmd *cmd)
* present. On success, populate *SNAP and *NAME, before returning 0.
* On failure, return -1 after issuing an error message. */
static int
vshLookupSnapshot(vshControl *ctl, const vshCmd *cmd,
const char *arg, bool exclusive, virDomainPtr dom,
virDomainSnapshotPtr *snap, const char **name)
virshLookupSnapshot(vshControl *ctl, const vshCmd *cmd,
const char *arg, bool exclusive, virDomainPtr dom,
virDomainSnapshotPtr *snap, const char **name)
{
bool current = vshCommandOptBool(cmd, "current");
const char *snapname = NULL;
@ -568,11 +568,11 @@ cmdSnapshotEdit(vshControl *ctl, const vshCmd *cmd)
vshCommandOptBool(cmd, "snapshotname"))
define_flags |= VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (vshLookupSnapshot(ctl, cmd, "snapshotname", false, dom,
&snapshot, &name) < 0)
if (virshLookupSnapshot(ctl, cmd, "snapshotname", false, dom,
&snapshot, &name) < 0)
goto cleanup;
#define EDIT_GET_XML \
@ -682,7 +682,7 @@ cmdSnapshotCurrent(vshControl *ctl, const vshCmd *cmd)
VSH_EXCLUSIVE_OPTIONS("name", "snapshotname");
if (!(dom = vshCommandOptDomain(ctl, cmd, &domname)))
if (!(dom = virshCommandOptDomain(ctl, cmd, &domname)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "snapshotname", &snapshotname) < 0)
@ -755,19 +755,20 @@ cmdSnapshotCurrent(vshControl *ctl, const vshCmd *cmd)
* proven no parent exists), and -1 on failure with error reported
* (such as no snapshot support or domain deleted in meantime). */
static int
vshGetSnapshotParent(vshControl *ctl, virDomainSnapshotPtr snapshot,
char **parent_name)
virshGetSnapshotParent(vshControl *ctl, virDomainSnapshotPtr snapshot,
char **parent_name)
{
virDomainSnapshotPtr parent = NULL;
char *xml = NULL;
xmlDocPtr xmldoc = NULL;
xmlXPathContextPtr ctxt = NULL;
int ret = -1;
virshControlPtr priv = ctl->privData;
*parent_name = NULL;
/* Try new API, since it is faster. */
if (!ctl->useSnapshotOld) {
if (!priv->useSnapshotOld) {
parent = virDomainSnapshotGetParent(snapshot, 0);
if (parent) {
/* API works, and virDomainSnapshotGetName will succeed */
@ -781,7 +782,7 @@ vshGetSnapshotParent(vshControl *ctl, virDomainSnapshotPtr snapshot,
goto cleanup;
}
/* API didn't work, fall back to XML scraping. */
ctl->useSnapshotOld = true;
priv->useSnapshotOld = true;
}
xml = virDomainSnapshotGetXMLDesc(snapshot, 0);
@ -815,8 +816,8 @@ vshGetSnapshotParent(vshControl *ctl, virDomainSnapshotPtr snapshot,
* 1 if snapshot is okay (or if snapshot is already NULL), and -1 on
* failure, with error already reported. */
static int
vshSnapshotFilter(vshControl *ctl, virDomainSnapshotPtr snapshot,
unsigned int flags)
virshSnapshotFilter(vshControl *ctl, virDomainSnapshotPtr snapshot,
unsigned int flags)
{
char *xml = NULL;
xmlDocPtr xmldoc = NULL;
@ -914,13 +915,14 @@ cmdSnapshotInfo(vshControl *ctl, const vshCmd *cmd)
unsigned int flags;
int current;
int metadata;
virshControlPtr priv = ctl->privData;
dom = vshCommandOptDomain(ctl, cmd, NULL);
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
return false;
if (vshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
if (virshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
goto cleanup;
vshPrint(ctl, "%-15s %s\n", _("Name:"), name);
@ -996,7 +998,7 @@ cmdSnapshotInfo(vshControl *ctl, const vshCmd *cmd)
/* Children, Descendants. After this point, the fallback to
* compute children is too expensive, so we gracefully quit if the
* APIs don't exist. */
if (ctl->useSnapshotOld) {
if (priv->useSnapshotOld) {
ret = true;
goto cleanup;
}
@ -1043,18 +1045,18 @@ cmdSnapshotInfo(vshControl *ctl, const vshCmd *cmd)
}
/* Helpers for collecting a list of snapshots. */
struct vshSnap {
struct virshSnap {
virDomainSnapshotPtr snap;
char *parent;
};
struct vshSnapshotList {
struct vshSnap *snaps;
struct virshSnapshotList {
struct virshSnap *snaps;
int nsnaps;
};
typedef struct vshSnapshotList *vshSnapshotListPtr;
typedef struct virshSnapshotList *virshSnapshotListPtr;
static void
vshSnapshotListFree(vshSnapshotListPtr snaplist)
virshSnapshotListFree(virshSnapshotListPtr snaplist)
{
size_t i;
@ -1072,10 +1074,10 @@ vshSnapshotListFree(vshSnapshotListPtr snaplist)
}
static int
vshSnapSorter(const void *a, const void *b)
virshSnapSorter(const void *a, const void *b)
{
const struct vshSnap *sa = a;
const struct vshSnap *sb = b;
const struct virshSnap *sa = a;
const struct virshSnap *sb = b;
if (sa->snap && !sb->snap)
return -1;
@ -1090,10 +1092,10 @@ vshSnapSorter(const void *a, const void *b)
* list is limited to descendants of the given snapshot. If FLAGS is
* given, the list is filtered. If TREE is specified, then all but
* FROM or the roots will also have parent information. */
static vshSnapshotListPtr
vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
virDomainSnapshotPtr from,
unsigned int orig_flags, bool tree)
static virshSnapshotListPtr
virshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
virDomainSnapshotPtr from,
unsigned int orig_flags, bool tree)
{
size_t i;
char **names = NULL;
@ -1101,16 +1103,17 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
bool descendants = false;
bool roots = false;
virDomainSnapshotPtr *snaps;
vshSnapshotListPtr snaplist = vshMalloc(ctl, sizeof(*snaplist));
vshSnapshotListPtr ret = NULL;
virshSnapshotListPtr snaplist = vshMalloc(ctl, sizeof(*snaplist));
virshSnapshotListPtr ret = NULL;
const char *fromname = NULL;
int start_index = -1;
int deleted = 0;
bool filter_fallback = false;
unsigned int flags = orig_flags;
virshControlPtr priv = ctl->privData;
/* Try the interface available in 0.9.13 and newer. */
if (!ctl->useSnapshotOld) {
if (!priv->useSnapshotOld) {
if (from)
count = virDomainSnapshotListAllChildren(from, &snaps, flags);
else
@ -1141,8 +1144,8 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
VIR_FREE(snaps);
if (tree) {
for (i = 0; i < count; i++) {
if (vshGetSnapshotParent(ctl, snaplist->snaps[i].snap,
&snaplist->snaps[i].parent) < 0)
if (virshGetSnapshotParent(ctl, snaplist->snaps[i].snap,
&snaplist->snaps[i].parent) < 0)
goto cleanup;
}
if (from) {
@ -1212,13 +1215,13 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
flags |= VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS;
/* Determine if we can use the new child listing API. */
if (ctl->useSnapshotOld ||
if (priv->useSnapshotOld ||
((count = virDomainSnapshotNumChildren(from, flags)) < 0 &&
last_error->code == VIR_ERR_NO_SUPPORT)) {
/* We can emulate --from. */
/* XXX can we also emulate --leaves? */
vshResetLibvirtError();
ctl->useSnapshotOld = true;
priv->useSnapshotOld = true;
flags &= ~VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS;
goto global;
}
@ -1253,7 +1256,7 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
names = vshCalloc(ctl, sizeof(*names), count);
/* Now that we have a count, collect the list. */
if (from && !ctl->useSnapshotOld) {
if (from && !priv->useSnapshotOld) {
if (tree) {
if (count)
count = virDomainSnapshotListChildrenNames(from, names + 1,
@ -1285,15 +1288,15 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
* --from together put from as the first element without a parent;
* with the old API we still need to do a post-process filtering
* based on all parent information. */
if (tree || (from && ctl->useSnapshotOld) || roots) {
for (i = (from && !ctl->useSnapshotOld); i < count; i++) {
if (from && ctl->useSnapshotOld && STREQ(names[i], fromname)) {
if (tree || (from && priv->useSnapshotOld) || roots) {
for (i = (from && !priv->useSnapshotOld); i < count; i++) {
if (from && priv->useSnapshotOld && STREQ(names[i], fromname)) {
start_index = i;
if (tree)
continue;
}
if (vshGetSnapshotParent(ctl, snaplist->snaps[i].snap,
&snaplist->snaps[i].parent) < 0)
if (virshGetSnapshotParent(ctl, snaplist->snaps[i].snap,
&snaplist->snaps[i].parent) < 0)
goto cleanup;
if ((from && ((tree && !snaplist->snaps[i].parent) ||
(!descendants &&
@ -1310,7 +1313,7 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
if (tree)
goto success;
if (ctl->useSnapshotOld && descendants) {
if (priv->useSnapshotOld && descendants) {
bool changed = false;
bool remaining = false;
@ -1384,8 +1387,8 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
if (!(orig_flags & VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION))
orig_flags |= VIR_DOMAIN_SNAPSHOT_FILTERS_LOCATION;
for (i = 0; i < snaplist->nsnaps; i++) {
switch (vshSnapshotFilter(ctl, snaplist->snaps[i].snap,
orig_flags)) {
switch (virshSnapshotFilter(ctl, snaplist->snaps[i].snap,
orig_flags)) {
case 1:
break;
case 0:
@ -1400,14 +1403,14 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
}
}
qsort(snaplist->snaps, snaplist->nsnaps, sizeof(*snaplist->snaps),
vshSnapSorter);
virshSnapSorter);
snaplist->nsnaps -= deleted;
ret = snaplist;
snaplist = NULL;
cleanup:
vshSnapshotListFree(snaplist);
virshSnapshotListFree(snaplist);
if (names && count > 0)
for (i = 0; i < count; i++)
VIR_FREE(names[i]);
@ -1416,9 +1419,9 @@ vshSnapshotListCollect(vshControl *ctl, virDomainPtr dom,
}
static const char *
vshSnapshotListLookup(int id, bool parent, void *opaque)
virshSnapshotListLookup(int id, bool parent, void *opaque)
{
vshSnapshotListPtr snaplist = opaque;
virshSnapshotListPtr snaplist = opaque;
if (parent)
return snaplist->snaps[id].parent;
return virDomainSnapshotGetName(snaplist->snaps[id].snap);
@ -1536,7 +1539,7 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd)
const char *from_snap = NULL;
char *parent_snap = NULL;
virDomainSnapshotPtr start = NULL;
vshSnapshotListPtr snaplist = NULL;
virshSnapshotListPtr snaplist = NULL;
VSH_EXCLUSIVE_OPTIONS_VAR(tree, name);
VSH_EXCLUSIVE_OPTIONS_VAR(parent, roots);
@ -1585,14 +1588,14 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd)
flags |= VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS;
}
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if ((from || current) &&
vshLookupSnapshot(ctl, cmd, "from", true, dom, &start, &from_snap) < 0)
virshLookupSnapshot(ctl, cmd, "from", true, dom, &start, &from_snap) < 0)
goto cleanup;
if (!(snaplist = vshSnapshotListCollect(ctl, dom, start, flags, tree)))
if (!(snaplist = virshSnapshotListCollect(ctl, dom, start, flags, tree)))
goto cleanup;
if (!tree && !name) {
@ -1611,7 +1614,7 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd)
if (tree) {
for (i = 0; i < snaplist->nsnaps; i++) {
if (!snaplist->snaps[i].parent &&
vshTreePrint(ctl, vshSnapshotListLookup, snaplist,
vshTreePrint(ctl, virshSnapshotListLookup, snaplist,
snaplist->nsnaps, i) < 0)
goto cleanup;
}
@ -1675,7 +1678,7 @@ cmdSnapshotList(vshControl *ctl, const vshCmd *cmd)
cleanup:
/* this frees up memory from the last iteration of the loop */
vshSnapshotListFree(snaplist);
virshSnapshotListFree(snaplist);
VIR_FREE(parent_snap);
VIR_FREE(state);
if (start)
@ -1735,7 +1738,7 @@ cmdSnapshotDumpXML(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptStringReq(ctl, cmd, "snapshotname", &name) < 0)
return false;
if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
return false;
if (!(snapshot = virDomainSnapshotLookupByName(dom, name, 0)))
@ -1795,15 +1798,15 @@ cmdSnapshotParent(vshControl *ctl, const vshCmd *cmd)
virDomainSnapshotPtr snapshot = NULL;
char *parent = NULL;
dom = vshCommandOptDomain(ctl, cmd, NULL);
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
goto cleanup;
if (vshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
if (virshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
goto cleanup;
if (vshGetSnapshotParent(ctl, snapshot, &parent) < 0)
if (virshGetSnapshotParent(ctl, snapshot, &parent) < 0)
goto cleanup;
if (!parent) {
vshError(ctl, _("snapshot '%s' has no parent"), name);
@ -1888,12 +1891,12 @@ cmdDomainSnapshotRevert(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "force"))
force = true;
dom = vshCommandOptDomain(ctl, cmd, NULL);
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
goto cleanup;
if (vshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
if (virshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
goto cleanup;
result = virDomainRevertToSnapshot(snapshot, flags);
@ -1968,12 +1971,12 @@ cmdSnapshotDelete(vshControl *ctl, const vshCmd *cmd)
virDomainSnapshotPtr snapshot = NULL;
unsigned int flags = 0;
dom = vshCommandOptDomain(ctl, cmd, NULL);
dom = virshCommandOptDomain(ctl, cmd, NULL);
if (dom == NULL)
goto cleanup;
if (vshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
if (virshLookupSnapshot(ctl, cmd, "snapshotname", true, dom,
&snapshot, &name) < 0)
goto cleanup;
if (vshCommandOptBool(cmd, "children"))

127
tools/virsh-volume.c
View File

@ -43,15 +43,17 @@
#include "virstring.h"
virStorageVolPtr
vshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char *pooloptname,
const char **name, unsigned int flags)
virshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char *pooloptname,
const char **name, unsigned int flags)
{
virStorageVolPtr vol = NULL;
virStoragePoolPtr pool = NULL;
const char *n = NULL, *p = NULL;
virCheckFlags(VSH_BYUUID | VSH_BYNAME, NULL);
virshControlPtr priv = ctl->privData;
virCheckFlags(VIRSH_BYUUID | VIRSH_BYNAME, NULL);
if (vshCommandOptStringReq(ctl, cmd, optname, &n) < 0)
return NULL;
@ -61,7 +63,7 @@ vshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
return NULL;
if (p) {
if (!(pool = vshCommandOptPoolBy(ctl, cmd, pooloptname, name, flags)))
if (!(pool = virshCommandOptPoolBy(ctl, cmd, pooloptname, name, flags)))
return NULL;
if (virStoragePoolIsActive(pool) != 1) {
@ -78,22 +80,22 @@ vshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
*name = n;
/* try it by name */
if (pool && (flags & VSH_BYNAME)) {
if (pool && (flags & VIRSH_BYNAME)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol name\n",
cmd->def->name, optname);
vol = virStorageVolLookupByName(pool, n);
}
/* try it by key */
if (!vol && (flags & VSH_BYUUID)) {
if (!vol && (flags & VIRSH_BYUUID)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol key\n",
cmd->def->name, optname);
vol = virStorageVolLookupByKey(ctl->conn, n);
vol = virStorageVolLookupByKey(priv->conn, n);
}
/* try it by path */
if (!vol && (flags & VSH_BYUUID)) {
if (!vol && (flags & VIRSH_BYUUID)) {
vshDebug(ctl, VSH_ERR_DEBUG, "%s: <%s> trying as vol path\n",
cmd->def->name, optname);
vol = virStorageVolLookupByPath(ctl->conn, n);
vol = virStorageVolLookupByPath(priv->conn, n);
}
if (!vol) {
@ -182,7 +184,7 @@ static const vshCmdOptDef opts_vol_create_as[] = {
};
static int
vshVolSize(const char *data, unsigned long long *val)
virshVolSize(const char *data, unsigned long long *val)
{
char *end;
if (virStrToLong_ull(data, &end, 10, val) < 0)
@ -201,11 +203,12 @@ cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
unsigned long long capacity, allocation = 0;
virBuffer buf = VIR_BUFFER_INITIALIZER;
unsigned long flags = 0;
virshControlPtr priv = ctl->privData;
if (vshCommandOptBool(cmd, "prealloc-metadata"))
flags |= VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "name", &name) < 0)
@ -214,13 +217,13 @@ cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptStringReq(ctl, cmd, "capacity", &capacityStr) < 0)
goto cleanup;
if (vshVolSize(capacityStr, &capacity) < 0) {
if (virshVolSize(capacityStr, &capacity) < 0) {
vshError(ctl, _("Malformed size %s"), capacityStr);
goto cleanup;
}
if (vshCommandOptString(ctl, cmd, "allocation", &allocationStr) > 0 &&
vshVolSize(allocationStr, &allocation) < 0) {
virshVolSize(allocationStr, &allocation) < 0) {
vshError(ctl, _("Malformed size %s"), allocationStr);
goto cleanup;
}
@ -265,7 +268,7 @@ cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Look up backing store volume '%s' as key\n",
cmd->def->name, snapshotStrVol);
snapVol = virStorageVolLookupByKey(ctl->conn, snapshotStrVol);
snapVol = virStorageVolLookupByKey(priv->conn, snapshotStrVol);
if (snapVol)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Backing store volume found using '%s' as key\n",
@ -277,7 +280,7 @@ cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Look up backing store volume '%s' as path\n",
cmd->def->name, snapshotStrVol);
snapVol = virStorageVolLookupByPath(ctl->conn, snapshotStrVol);
snapVol = virStorageVolLookupByPath(priv->conn, snapshotStrVol);
if (snapVol)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Backing store volume found using '%s' as path\n",
@ -380,7 +383,7 @@ cmdVolCreate(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "prealloc-metadata"))
flags |= VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
@ -460,7 +463,7 @@ cmdVolCreateFrom(vshControl *ctl, const vshCmd *cmd)
char *buffer = NULL;
unsigned int flags = 0;
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
goto cleanup;
if (vshCommandOptBool(cmd, "prealloc-metadata"))
@ -472,7 +475,7 @@ cmdVolCreateFrom(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptStringReq(ctl, cmd, "file", &from) < 0)
goto cleanup;
if (!(inputvol = vshCommandOptVol(ctl, cmd, "vol", "inputpool", NULL)))
if (!(inputvol = virshCommandOptVol(ctl, cmd, "vol", "inputpool", NULL)))
goto cleanup;
if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) {
@ -503,7 +506,7 @@ cmdVolCreateFrom(vshControl *ctl, const vshCmd *cmd)
}
static xmlChar *
vshMakeCloneXML(const char *origxml, const char *newname)
virshMakeCloneXML(const char *origxml, const char *newname)
{
xmlDocPtr doc = NULL;
@ -581,7 +584,7 @@ cmdVolClone(vshControl *ctl, const vshCmd *cmd)
bool ret = false;
unsigned int flags = 0;
if (!(origvol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(origvol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
goto cleanup;
if (vshCommandOptBool(cmd, "prealloc-metadata"))
@ -603,7 +606,7 @@ cmdVolClone(vshControl *ctl, const vshCmd *cmd)
if (!origxml)
goto cleanup;
newxml = vshMakeCloneXML(origxml, name);
newxml = virshMakeCloneXML(origxml, name);
if (!newxml) {
vshPrint(ctl, "%s", _("Failed to allocate XML buffer"));
goto cleanup;
@ -692,6 +695,7 @@ cmdVolUpload(vshControl *ctl, const vshCmd *cmd)
virStreamPtr st = NULL;
const char *name = NULL;
unsigned long long offset = 0, length = 0;
virshControlPtr priv = ctl->privData;
if (vshCommandOptULongLong(ctl, cmd, "offset", &offset) < 0)
return false;
@ -699,7 +703,7 @@ cmdVolUpload(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptULongLongWrap(ctl, cmd, "length", &length) < 0)
return false;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "file", &file) < 0)
@ -710,7 +714,7 @@ cmdVolUpload(vshControl *ctl, const vshCmd *cmd)
goto cleanup;
}
if (!(st = virStreamNew(ctl->conn, 0))) {
if (!(st = virStreamNew(priv->conn, 0))) {
vshError(ctl, _("cannot create a new stream"));
goto cleanup;
}
@ -797,6 +801,7 @@ cmdVolDownload(vshControl *ctl, const vshCmd *cmd)
const char *name = NULL;
unsigned long long offset = 0, length = 0;
bool created = false;
virshControlPtr priv = ctl->privData;
if (vshCommandOptULongLong(ctl, cmd, "offset", &offset) < 0)
return false;
@ -804,7 +809,7 @@ cmdVolDownload(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptULongLongWrap(ctl, cmd, "length", &length) < 0)
return false;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "file", &file) < 0)
@ -820,7 +825,7 @@ cmdVolDownload(vshControl *ctl, const vshCmd *cmd)
created = true;
}
if (!(st = virStreamNew(ctl->conn, 0))) {
if (!(st = virStreamNew(priv->conn, 0))) {
vshError(ctl, _("cannot create a new stream"));
goto cleanup;
}
@ -830,7 +835,7 @@ cmdVolDownload(vshControl *ctl, const vshCmd *cmd)
goto cleanup;
}
if (virStreamRecvAll(st, vshStreamSink, &fd) < 0) {
if (virStreamRecvAll(st, virshStreamSink, &fd) < 0) {
vshError(ctl, _("cannot receive data from volume %s"), name);
goto cleanup;
}
@ -892,7 +897,7 @@ cmdVolDelete(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
const char *name;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
return false;
if (virStorageVolDelete(vol, 0) == 0) {
@ -951,7 +956,7 @@ cmdVolWipe(vshControl *ctl, const vshCmd *cmd)
int algorithm = VIR_STORAGE_VOL_WIPE_ALG_ZERO;
int funcRet;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", &name)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "algorithm", &algorithm_str) < 0)
@ -982,8 +987,8 @@ cmdVolWipe(vshControl *ctl, const vshCmd *cmd)
}
VIR_ENUM_DECL(vshStorageVol)
VIR_ENUM_IMPL(vshStorageVol,
VIR_ENUM_DECL(virshStorageVol)
VIR_ENUM_IMPL(virshStorageVol,
VIR_STORAGE_VOL_LAST,
N_("file"),
N_("block"),
@ -992,9 +997,9 @@ VIR_ENUM_IMPL(vshStorageVol,
N_("netdir"))
static const char *
vshVolumeTypeToString(int type)
virshVolumeTypeToString(int type)
{
const char *str = vshStorageVolTypeToString(type);
const char *str = virshStorageVolTypeToString(type);
return str ? _(str) : _("unknown");
}
@ -1032,7 +1037,7 @@ cmdVolInfo(vshControl *ctl, const vshCmd *cmd)
virStorageVolPtr vol;
bool ret = true;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
return false;
vshPrint(ctl, "%-15s %s\n", _("Name:"), virStorageVolGetName(vol));
@ -1042,7 +1047,7 @@ cmdVolInfo(vshControl *ctl, const vshCmd *cmd)
const char *unit;
vshPrint(ctl, "%-15s %s\n", _("Type:"),
vshVolumeTypeToString(info.type));
virshVolumeTypeToString(info.type));
val = vshPrettyCapacity(info.capacity, &unit);
vshPrint(ctl, "%-15s %2.2lf %s\n", _("Capacity:"), val, unit);
@ -1115,7 +1120,7 @@ cmdVolResize(vshControl *ctl, const vshCmd *cmd)
if (vshCommandOptBool(cmd, "shrink"))
flags |= VIR_STORAGE_VOL_RESIZE_SHRINK;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
return false;
if (vshCommandOptStringReq(ctl, cmd, "capacity", &capacityStr) < 0)
@ -1137,7 +1142,7 @@ cmdVolResize(vshControl *ctl, const vshCmd *cmd)
if (delta)
flags |= VIR_STORAGE_VOL_RESIZE_DELTA;
if (vshVolSize(capacityStr, &capacity) < 0) {
if (virshVolSize(capacityStr, &capacity) < 0) {
vshError(ctl, _("Malformed size %s"), capacityStr);
goto cleanup;
}
@ -1194,7 +1199,7 @@ cmdVolDumpXML(vshControl *ctl, const vshCmd *cmd)
bool ret = true;
char *dump;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
return false;
dump = virStorageVolGetXMLDesc(vol, 0);
@ -1210,7 +1215,7 @@ cmdVolDumpXML(vshControl *ctl, const vshCmd *cmd)
}
static int
vshStorageVolSorter(const void *a, const void *b)
virshStorageVolSorter(const void *a, const void *b)
{
virStorageVolPtr *va = (virStorageVolPtr *) a;
virStorageVolPtr *vb = (virStorageVolPtr *) b;
@ -1225,14 +1230,14 @@ vshStorageVolSorter(const void *a, const void *b)
virStorageVolGetName(*vb));
}
struct vshStorageVolList {
struct virshStorageVolList {
virStorageVolPtr *vols;
size_t nvols;
};
typedef struct vshStorageVolList *vshStorageVolListPtr;
typedef struct virshStorageVolList *virshStorageVolListPtr;
static void
vshStorageVolListFree(vshStorageVolListPtr list)
virshStorageVolListFree(virshStorageVolListPtr list)
{
size_t i;
@ -1246,12 +1251,12 @@ vshStorageVolListFree(vshStorageVolListPtr list)
VIR_FREE(list);
}
static vshStorageVolListPtr
vshStorageVolListCollect(vshControl *ctl,
virStoragePoolPtr pool,
unsigned int flags)
static virshStorageVolListPtr
virshStorageVolListCollect(vshControl *ctl,
virStoragePoolPtr pool,
unsigned int flags)
{
vshStorageVolListPtr list = vshMalloc(ctl, sizeof(*list));
virshStorageVolListPtr list = vshMalloc(ctl, sizeof(*list));
size_t i;
char **names = NULL;
virStorageVolPtr vol = NULL;
@ -1314,7 +1319,7 @@ vshStorageVolListCollect(vshControl *ctl,
finished:
/* sort the list */
if (list->vols && list->nvols)
qsort(list->vols, list->nvols, sizeof(*list->vols), vshStorageVolSorter);
qsort(list->vols, list->nvols, sizeof(*list->vols), virshStorageVolSorter);
if (deleted)
VIR_SHRINK_N(list->vols, list->nvols, deleted);
@ -1328,7 +1333,7 @@ vshStorageVolListCollect(vshControl *ctl,
VIR_FREE(names);
if (!success) {
vshStorageVolListFree(list);
virshStorageVolListFree(list);
list = NULL;
}
@ -1383,13 +1388,13 @@ cmdVolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
char *type;
};
struct volInfoText *volInfoTexts = NULL;
vshStorageVolListPtr list = NULL;
virshStorageVolListPtr list = NULL;
/* Look up the pool information given to us by the user */
if (!(pool = vshCommandOptPool(ctl, cmd, "pool", NULL)))
if (!(pool = virshCommandOptPool(ctl, cmd, "pool", NULL)))
return false;
if (!(list = vshStorageVolListCollect(ctl, pool, 0)))
if (!(list = virshStorageVolListCollect(ctl, pool, 0)))
goto cleanup;
if (list->nvols > 0)
@ -1418,7 +1423,7 @@ cmdVolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
/* Volume type */
volInfoTexts[i].type = vshStrdup(ctl,
vshVolumeTypeToString(volumeInfo.type));
virshVolumeTypeToString(volumeInfo.type));
val = vshPrettyCapacity(volumeInfo.capacity, &unit);
if (virAsprintf(&volInfoTexts[i].capacity,
@ -1571,7 +1576,7 @@ cmdVolList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
VIR_FREE(outputStr);
VIR_FREE(volInfoTexts);
virStoragePoolFree(pool);
vshStorageVolListFree(list);
virshStorageVolListFree(list);
/* Return the desired value */
return ret;
@ -1604,8 +1609,8 @@ cmdVolName(vshControl *ctl, const vshCmd *cmd)
{
virStorageVolPtr vol;
if (!(vol = vshCommandOptVolBy(ctl, cmd, "vol", NULL, NULL,
VSH_BYUUID)))
if (!(vol = virshCommandOptVolBy(ctl, cmd, "vol", NULL, NULL,
VIRSH_BYUUID)))
return false;
vshPrint(ctl, "%s\n", virStorageVolGetName(vol));
@ -1647,8 +1652,8 @@ cmdVolPool(vshControl *ctl, const vshCmd *cmd)
char uuid[VIR_UUID_STRING_BUFLEN];
/* Use the supplied string to locate the volume */
if (!(vol = vshCommandOptVolBy(ctl, cmd, "vol", NULL, NULL,
VSH_BYUUID))) {
if (!(vol = virshCommandOptVolBy(ctl, cmd, "vol", NULL, NULL,
VIRSH_BYUUID))) {
return false;
}
@ -1707,7 +1712,7 @@ cmdVolKey(vshControl *ctl, const vshCmd *cmd)
{
virStorageVolPtr vol;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
return false;
vshPrint(ctl, "%s\n", virStorageVolGetKey(vol));
@ -1747,7 +1752,7 @@ cmdVolPath(vshControl *ctl, const vshCmd *cmd)
virStorageVolPtr vol;
char * StorageVolPath;
if (!(vol = vshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
if (!(vol = virshCommandOptVol(ctl, cmd, "vol", "pool", NULL)))
return false;
if ((StorageVolPath = virStorageVolGetPath(vol)) == NULL) {

14
tools/virsh-volume.h
View File

@ -28,15 +28,15 @@
# include "virsh.h"
virStorageVolPtr vshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char *pooloptname,
const char **name, unsigned int flags);
virStorageVolPtr virshCommandOptVolBy(vshControl *ctl, const vshCmd *cmd,
const char *optname,
const char *pooloptname,
const char **name, unsigned int flags);
/* default is lookup by Name and UUID */
# define vshCommandOptVol(_ctl, _cmd, _optname, _pooloptname, _name) \
vshCommandOptVolBy(_ctl, _cmd, _optname, _pooloptname, _name, \
VSH_BYUUID|VSH_BYNAME)
# define virshCommandOptVol(_ctl, _cmd, _optname, _pooloptname, _name) \
virshCommandOptVolBy(_ctl, _cmd, _optname, _pooloptname, _name, \
VIRSH_BYUUID | VIRSH_BYNAME)
extern const vshCmdDef storageVolCmds[];

3130
tools/virsh.c
View File

File diff suppressed because it is too large Load Diff

479
tools/virsh.h
View File

@ -36,492 +36,75 @@
# include "internal.h"
# include "virerror.h"
# include "virthread.h"
# include "vsh.h"
# define VSH_MAX_XML_FILE (10*1024*1024)
# define VSH_PROMPT_RW "virsh # "
# define VSH_PROMPT_RO "virsh > "
# define VIRSH_PROMPT_RW "virsh # "
# define VIRSH_PROMPT_RO "virsh > "
# define VIR_FROM_THIS VIR_FROM_NONE
# define GETTIMEOFDAY(T) gettimeofday(T, NULL)
# define VSH_MATCH(FLAG) (flags & (FLAG))
/**
* The log configuration
*/
# define MSG_BUFFER 4096
# define SIGN_NAME "virsh"
# define DIR_MODE (S_IWUSR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) /* 0755 */
# define FILE_MODE (S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH) /* 0644 */
# define LOCK_MODE (S_IWUSR | S_IRUSR) /* 0600 */
# define LVL_DEBUG "DEBUG"
# define LVL_INFO "INFO"
# define LVL_NOTICE "NOTICE"
# define LVL_WARNING "WARNING"
# define LVL_ERROR "ERROR"
/**
* vshErrorLevel:
*
* Indicates the level of a log message
*/
typedef enum {
VSH_ERR_DEBUG = 0,
VSH_ERR_INFO,
VSH_ERR_NOTICE,
VSH_ERR_WARNING,
VSH_ERR_ERROR
} vshErrorLevel;
# define VSH_DEBUG_DEFAULT VSH_ERR_ERROR
/*
* virsh command line grammar:
*
* command_line = <command>\n | <command>; <command>; ...
*
* command = <keyword> <option> [--] <data>
*
* option = <bool_option> | <int_option> | <string_option>
* data = <string>
*
* bool_option = --optionname
* int_option = --optionname <number> | --optionname=<number>
* string_option = --optionname <string> | --optionname=<string>
*
* keyword = [a-zA-Z][a-zA-Z-]*
* number = [0-9]+
* string = ('[^']*'|"([^\\"]|\\.)*"|([^ \t\n\\'"]|\\.))+
*
*/
/*
* vshCmdOptType - command option type
*/
typedef enum {
VSH_OT_BOOL, /* optional boolean option */
VSH_OT_STRING, /* optional string option */
VSH_OT_INT, /* optional or mandatory int option */
VSH_OT_DATA, /* string data (as non-option) */
VSH_OT_ARGV, /* remaining arguments */
VSH_OT_ALIAS, /* alternate spelling for a later argument */
} vshCmdOptType;
/*
* Command group types
*/
# define VSH_CMD_GRP_DOM_MANAGEMENT "Domain Management"
# define VSH_CMD_GRP_DOM_MONITORING "Domain Monitoring"
# define VSH_CMD_GRP_STORAGE_POOL "Storage Pool"
# define VSH_CMD_GRP_STORAGE_VOL "Storage Volume"
# define VSH_CMD_GRP_NETWORK "Networking"
# define VSH_CMD_GRP_NODEDEV "Node Device"
# define VSH_CMD_GRP_IFACE "Interface"
# define VSH_CMD_GRP_NWFILTER "Network Filter"
# define VSH_CMD_GRP_SECRET "Secret"
# define VSH_CMD_GRP_SNAPSHOT "Snapshot"
# define VSH_CMD_GRP_HOST_AND_HV "Host and Hypervisor"
# define VSH_CMD_GRP_VIRSH "Virsh itself"
# define VIRSH_CMD_GRP_DOM_MANAGEMENT "Domain Management"
# define VIRSH_CMD_GRP_DOM_MONITORING "Domain Monitoring"
# define VIRSH_CMD_GRP_STORAGE_POOL "Storage Pool"
# define VIRSH_CMD_GRP_STORAGE_VOL "Storage Volume"
# define VIRSH_CMD_GRP_NETWORK "Networking"
# define VIRSH_CMD_GRP_NODEDEV "Node Device"
# define VIRSH_CMD_GRP_IFACE "Interface"
# define VIRSH_CMD_GRP_NWFILTER "Network Filter"
# define VIRSH_CMD_GRP_SECRET "Secret"
# define VIRSH_CMD_GRP_SNAPSHOT "Snapshot"
# define VIRSH_CMD_GRP_HOST_AND_HV "Host and Hypervisor"
# define VIRSH_CMD_GRP_VIRSH "Virsh itself"
/*
* Command Option Flags
*/
enum {
VSH_OFLAG_NONE = 0, /* without flags */
VSH_OFLAG_REQ = (1 << 0), /* option required */
VSH_OFLAG_EMPTY_OK = (1 << 1), /* empty string option allowed */
VSH_OFLAG_REQ_OPT = (1 << 2), /* --optionname required */
};
typedef struct _virshControl virshControl;
typedef virshControl *virshControlPtr;
/* forward declarations */
typedef struct _vshCmd vshCmd;
typedef struct _vshCmdDef vshCmdDef;
typedef struct _vshCmdGrp vshCmdGrp;
typedef struct _vshCmdInfo vshCmdInfo;
typedef struct _vshCmdOpt vshCmdOpt;
typedef struct _vshCmdOptDef vshCmdOptDef;
typedef struct _vshControl vshControl;
typedef struct _vshCtrlData vshCtrlData;
typedef char **(*vshCompleter)(unsigned int flags);
/*
* vshCmdInfo -- name/value pair for information about command
*
* Commands should have at least the following names:
* "help" - short description of command
* "desc" - description of command, or empty string
*/
struct _vshCmdInfo {
const char *name; /* name of information, or NULL for list end */
const char *data; /* non-NULL information */
};
/*
* vshCmdOptDef - command option definition
*/
struct _vshCmdOptDef {
const char *name; /* the name of option, or NULL for list end */
vshCmdOptType type; /* option type */
unsigned int flags; /* flags */
const char *help; /* non-NULL help string; or for VSH_OT_ALIAS
* the name of a later public option */
vshCompleter completer; /* option completer */
unsigned int completer_flags; /* option completer flags */
};
/*
* vshCmdOpt - command options
*
* After parsing a command, all arguments to the command have been
* collected into a list of these objects.
*/
struct _vshCmdOpt {
const vshCmdOptDef *def; /* non-NULL pointer to option definition */
char *data; /* allocated data, or NULL for bool option */
vshCmdOpt *next;
};
/*
* Command Usage Flags
*/
enum {
VSH_CMD_FLAG_NOCONNECT = (1 << 0), /* no prior connection needed */
VSH_CMD_FLAG_ALIAS = (1 << 1), /* command is an alias */
};
/*
* vshCmdDef - command definition
*/
struct _vshCmdDef {
const char *name; /* name of command, or NULL for list end */
bool (*handler) (vshControl *, const vshCmd *); /* command handler */
const vshCmdOptDef *opts; /* definition of command options */
const vshCmdInfo *info; /* details about command */
unsigned int flags; /* bitwise OR of VSH_CMD_FLAG */
};
/*
* vshCmd - parsed command
*/
struct _vshCmd {
const vshCmdDef *def; /* command definition */
vshCmdOpt *opts; /* list of command arguments */
vshCmd *next; /* next command */
};
typedef struct _virshCtrlData virshCtrlData;
/*
* vshControl
*/
struct _vshControl {
char *name; /* connection name */
struct _virshControl {
virConnectPtr conn; /* connection to hypervisor (MAY BE NULL) */
vshCmd *cmd; /* the current command */
char *cmdstr; /* string with command */
bool imode; /* interactive mode? */
bool quiet; /* quiet mode */
int debug; /* print debug messages? */
bool timing; /* print timing info? */
bool readonly; /* connect readonly (first time only, not
* during explicit connect command)
*/
char *logfile; /* log file name */
int log_fd; /* log file descriptor */
char *historydir; /* readline history directory name */
char *historyfile; /* readline history file name */
bool useGetInfo; /* must use virDomainGetInfo, since
virDomainGetState is not supported */
bool useSnapshotOld; /* cannot use virDomainSnapshotGetParent or
virDomainSnapshotNumChildren */
bool blockJobNoBytes; /* true if _BANDWIDTH_BYTE blockjob flags
are missing */
virThread eventLoop;
virMutex lock;
bool eventLoopStarted;
bool quit;
int eventPipe[2]; /* Write-to-self pipe to end waiting for an
* event to occur */
int eventTimerId; /* id of event loop timeout registration */
const char *escapeChar; /* String representation of
console escape character */
int keepalive_interval; /* Client keepalive interval */
int keepalive_count; /* Client keepalive count */
# ifndef WIN32
struct termios termattr; /* settings of the tty terminal */
# endif
bool istty; /* is the terminal a tty */
};
struct _vshCmdGrp {
const char *name; /* name of group, or NULL for list end */
const char *keyword; /* help keyword */
const vshCmdDef *commands;
};
void vshError(vshControl *ctl, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(2, 3);
void vshOpenLogFile(vshControl *ctl);
void vshOutputLogFile(vshControl *ctl, int log_level, const char *format,
va_list ap)
ATTRIBUTE_FMT_PRINTF(3, 0);
void vshCloseLogFile(vshControl *ctl);
virConnectPtr vshConnect(vshControl *ctl, const char *uri, bool readonly);
const char *vshCmddefGetInfo(const vshCmdDef *cmd, const char *info);
const vshCmdDef *vshCmddefSearch(const char *cmdname);
bool vshCmddefHelp(vshControl *ctl, const char *name);
const vshCmdGrp *vshCmdGrpSearch(const char *grpname);
bool vshCmdGrpHelp(vshControl *ctl, const char *name);
int vshCommandOptInt(vshControl *ctl, const vshCmd *cmd,
const char *name, int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUInt(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUIntWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUL(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptString(vshControl *ctl, const vshCmd *cmd,
const char *name, const char **value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptStringReq(vshControl *ctl, const vshCmd *cmd,
const char *name, const char **value)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptLongLong(vshControl *ctl, const vshCmd *cmd,
const char *name, long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULongLong(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULongLongWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptScaledInt(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value,
int scale, unsigned long long max)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
bool vshCommandOptBool(const vshCmd *cmd, const char *name);
const vshCmdOpt *vshCommandOptArgv(vshControl *ctl, const vshCmd *cmd,
const vshCmdOpt *opt);
int vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd, int *timeout);
/* Filter flags for various vshCommandOpt*By() functions */
typedef enum {
VSH_BYID = (1 << 1),
VSH_BYUUID = (1 << 2),
VSH_BYNAME = (1 << 3),
VSH_BYMAC = (1 << 4),
} vshLookupByFlags;
/* Given an index, return either the name of that device (non-NULL) or
* of its parent (NULL if a root). */
typedef const char * (*vshTreeLookup)(int devid, bool parent, void *opaque);
int vshTreePrint(vshControl *ctl, vshTreeLookup lookup, void *opaque,
int num_devices, int devid);
void vshPrintExtra(vshControl *ctl, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(2, 3);
void vshDebug(vshControl *ctl, int level, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(3, 4);
/* XXX: add batch support */
# define vshPrint(_ctl, ...) vshPrintExtra(NULL, __VA_ARGS__)
/* User visible sort, so we want locale-specific case comparison. */
# define vshStrcasecmp(S1, S2) strcasecmp(S1, S2)
int vshNameSorter(const void *a, const void *b);
int vshDomainState(vshControl *ctl, virDomainPtr dom, int *reason);
virTypedParameterPtr vshFindTypedParamByName(const char *name,
virTypedParameterPtr list,
int count);
char *vshGetTypedParamValue(vshControl *ctl, virTypedParameterPtr item)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
char *vshEditWriteToTempFile(vshControl *ctl, const char *doc);
int vshEditFile(vshControl *ctl, const char *filename);
char *vshEditReadBackFile(vshControl *ctl, const char *filename);
int vshAskReedit(vshControl *ctl, const char *msg, bool relax_avail);
int vshStreamSink(virStreamPtr st, const char *bytes, size_t nbytes,
void *opaque);
double vshPrettyCapacity(unsigned long long val, const char **unit);
int vshStringToArray(const char *str, char ***array);
/* Typedefs, function prototypes for job progress reporting.
* There are used by some long lingering commands like
* migrate, dump, save, managedsave.
*/
struct _vshCtrlData {
struct _virshCtrlData {
vshControl *ctl;
const vshCmd *cmd;
int writefd;
virConnectPtr dconn;
};
/* error handling */
extern virErrorPtr last_error;
void vshReportError(vshControl *ctl);
void vshResetLibvirtError(void);
void vshSaveLibvirtError(void);
/* Filter flags for various vshCommandOpt*By() functions */
typedef enum {
VIRSH_BYID = (1 << 1),
VIRSH_BYUUID = (1 << 2),
VIRSH_BYNAME = (1 << 3),
VIRSH_BYMAC = (1 << 4),
} virshLookupByFlags;
/* terminal modifications */
bool vshTTYIsInterruptCharacter(vshControl *ctl, const char chr);
int vshTTYDisableInterrupt(vshControl *ctl);
int vshTTYRestore(vshControl *ctl);
int vshTTYMakeRaw(vshControl *ctl, bool report_errors);
bool vshTTYAvailable(vshControl *ctl);
virConnectPtr virshConnect(vshControl *ctl, const char *uri, bool readonly);
int virshDomainState(vshControl *ctl, virDomainPtr dom, int *reason);
/* waiting for events */
enum {
VSH_EVENT_INTERRUPT,
VSH_EVENT_TIMEOUT,
VSH_EVENT_DONE,
};
int vshEventStart(vshControl *ctl, int timeout_ms);
void vshEventDone(vshControl *ctl);
int vshEventWait(vshControl *ctl);
void vshEventCleanup(vshControl *ctl);
/* allocation wrappers */
void *_vshMalloc(vshControl *ctl, size_t sz, const char *filename, int line);
# define vshMalloc(_ctl, _sz) _vshMalloc(_ctl, _sz, __FILE__, __LINE__)
void *_vshCalloc(vshControl *ctl, size_t nmemb, size_t sz,
const char *filename, int line);
# define vshCalloc(_ctl, _nmemb, _sz) \
_vshCalloc(_ctl, _nmemb, _sz, __FILE__, __LINE__)
char *_vshStrdup(vshControl *ctl, const char *s, const char *filename,
int line);
# define vshStrdup(_ctl, _s) _vshStrdup(_ctl, _s, __FILE__, __LINE__)
/* Poison the raw allocating identifiers in favor of our vsh variants. */
# undef malloc
# undef calloc
# undef realloc
# undef strdup
# define malloc use_vshMalloc_instead_of_malloc
# define calloc use_vshCalloc_instead_of_calloc
# define realloc use_vshRealloc_instead_of_realloc
# define strdup use_vshStrdup_instead_of_strdup
/* Macros to help dealing with mutually exclusive options. */
/* VSH_EXCLUSIVE_OPTIONS_EXPR:
*
* @NAME1: String containing the name of the option.
* @EXPR1: Expression to validate the variable (boolean variable)
* @NAME2: String containing the name of the option.
* @EXPR2: Expression to validate the variable (boolean variable)
*
* Reject mutually exclusive command options in virsh. Use the
* provided expression to check the variables.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS_EXPR(NAME1, EXPR1, NAME2, EXPR2) \
if ((EXPR1) && (EXPR2)) { \
vshError(ctl, _("Options --%s and --%s are mutually exclusive"), \
NAME1, NAME2); \
return false; \
}
/* VSH_EXCLUSIVE_OPTIONS:
*
* @NAME1: String containing the name of the option.
* @NAME2: String containing the name of the option.
*
* Reject mutually exclusive command options in virsh. Use the
* vshCommandOptBool call to request them.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS(NAME1, NAME2) \
VSH_EXCLUSIVE_OPTIONS_EXPR(NAME1, vshCommandOptBool(cmd, NAME1), \
NAME2, vshCommandOptBool(cmd, NAME2))
/* VSH_EXCLUSIVE_OPTIONS_VAR:
*
* @VARNAME1: Boolean variable containing the value of the option of same name
* @VARNAME2: Boolean variable containing the value of the option of same name
*
* Reject mutually exclusive command options in virsh. Check in variables that
* contain the value and have same name as the option.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS_VAR(VARNAME1, VARNAME2) \
VSH_EXCLUSIVE_OPTIONS_EXPR(#VARNAME1, VARNAME1, #VARNAME2, VARNAME2)
/* Macros to help dealing with required options. */
/* VSH_REQUIRE_OPTION_EXPR:
*
* @NAME1: String containing the name of the option.
* @EXPR1: Expression to validate the variable (boolean variable).
* @NAME2: String containing the name of required option.
* @EXPR2: Expression to validate the variable (boolean variable).
*
* Check if required command options in virsh was set. Use the
* provided expression to check the variables.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION_EXPR(NAME1, EXPR1, NAME2, EXPR2) \
do { \
if ((EXPR1) && !(EXPR2)) { \
vshError(ctl, _("Option --%s is required by option --%s"), \
NAME2, NAME1); \
return false; \
} \
} while (0)
/* VSH_REQUIRE_OPTION:
*
* @NAME1: String containing the name of the option.
* @NAME2: String containing the name of required option.
*
* Check if required command options in virsh was set. Use the
* vshCommandOptBool call to request them.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION(NAME1, NAME2) \
VSH_REQUIRE_OPTION_EXPR(NAME1, vshCommandOptBool(cmd, NAME1), \
NAME2, vshCommandOptBool(cmd, NAME2))
/* VSH_REQUIRE_OPTION_VAR:
*
* @VARNAME1: Boolean variable containing the value of the option of same name.
* @VARNAME2: Boolean variable containing the value of required option of
* same name.
*
* Check if required command options in virsh was set. Check in variables
* that contain the value and have same name as the option.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION_VAR(VARNAME1, VARNAME2) \
VSH_REQUIRE_OPTION_EXPR(#VARNAME1, VARNAME1, #VARNAME2, VARNAME2)
int virshStreamSink(virStreamPtr st, const char *bytes, size_t nbytes,
void *opaque);
#endif /* VIRSH_H */

2995
tools/vsh.c Normal file
View File

File diff suppressed because it is too large Load Diff

568
tools/vsh.h Normal file
View File

@ -0,0 +1,568 @@
/*
* vsh.h: common data to be used by clients to exercise the libvirt API
*
* Copyright (C) 2005, 2007-2015 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/>.
*
* Daniel Veillard <veillard@redhat.com>
* Karel Zak <kzak@redhat.com>
* Daniel P. Berrange <berrange@redhat.com>
*/
#ifndef VSH_H
# define VSH_H
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <stdarg.h>
# include <unistd.h>
# include <sys/stat.h>
# include <termios.h>
# include "internal.h"
# include "virerror.h"
# include "virthread.h"
# define VIR_FROM_THIS VIR_FROM_NONE
# define GETTIMEOFDAY(T) gettimeofday(T, NULL)
# define VSH_MAX_XML_FILE (10*1024*1024)
# define VSH_MATCH(FLAG) (flags & (FLAG))
/**
* The log configuration
*/
# define MSG_BUFFER 4096
# define DIR_MODE (S_IWUSR | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) /* 0755 */
# define FILE_MODE (S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH) /* 0644 */
# define LOCK_MODE (S_IWUSR | S_IRUSR) /* 0600 */
# define LVL_DEBUG "DEBUG"
# define LVL_INFO "INFO"
# define LVL_NOTICE "NOTICE"
# define LVL_WARNING "WARNING"
# define LVL_ERROR "ERROR"
/**
* vshErrorLevel:
*
* Indicates the level of a log message
*/
typedef enum {
VSH_ERR_DEBUG = 0,
VSH_ERR_INFO,
VSH_ERR_NOTICE,
VSH_ERR_WARNING,
VSH_ERR_ERROR
} vshErrorLevel;
# define VSH_DEBUG_DEFAULT VSH_ERR_ERROR
/*
* virsh command line grammar:
*
* command_line = <command>\n | <command>; <command>; ...
*
* command = <keyword> <option> [--] <data>
*
* option = <bool_option> | <int_option> | <string_option>
* data = <string>
*
* bool_option = --optionname
* int_option = --optionname <number> | --optionname=<number>
* string_option = --optionname <string> | --optionname=<string>
*
* keyword = [a-zA-Z][a-zA-Z-]*
* number = [0-9]+
* string = ('[^']*'|"([^\\"]|\\.)*"|([^ \t\n\\'"]|\\.))+
*
*/
/*
* vshCmdOptType - command option type
*/
typedef enum {
VSH_OT_BOOL, /* optional boolean option */
VSH_OT_STRING, /* optional string option */
VSH_OT_INT, /* optional or mandatory int option */
VSH_OT_DATA, /* string data (as non-option) */
VSH_OT_ARGV, /* remaining arguments */
VSH_OT_ALIAS, /* alternate spelling for a later argument */
} vshCmdOptType;
/*
* Command Option Flags
*/
enum {
VSH_OFLAG_NONE = 0, /* without flags */
VSH_OFLAG_REQ = (1 << 0), /* option required */
VSH_OFLAG_EMPTY_OK = (1 << 1), /* empty string option allowed */
VSH_OFLAG_REQ_OPT = (1 << 2), /* --optionname required */
};
/* forward declarations */
typedef struct _vshClientHooks vshClientHooks;
typedef struct _vshCmd vshCmd;
typedef struct _vshCmdDef vshCmdDef;
typedef struct _vshCmdGrp vshCmdGrp;
typedef struct _vshCmdInfo vshCmdInfo;
typedef struct _vshCmdOpt vshCmdOpt;
typedef struct _vshCmdOptDef vshCmdOptDef;
typedef struct _vshControl vshControl;
typedef char **(*vshCompleter)(unsigned int flags);
/*
* vshCmdInfo -- name/value pair for information about command
*
* Commands should have at least the following names:
* "help" - short description of command
* "desc" - description of command, or empty string
*/
struct _vshCmdInfo {
const char *name; /* name of information, or NULL for list end */
const char *data; /* non-NULL information */
};
/*
* vshCmdOptDef - command option definition
*/
struct _vshCmdOptDef {
const char *name; /* the name of option, or NULL for list end */
vshCmdOptType type; /* option type */
unsigned int flags; /* flags */
const char *help; /* non-NULL help string; or for VSH_OT_ALIAS
* the name of a later public option */
vshCompleter completer; /* option completer */
unsigned int completer_flags; /* option completer flags */
};
/*
* vshCmdOpt - command options
*
* After parsing a command, all arguments to the command have been
* collected into a list of these objects.
*/
struct _vshCmdOpt {
const vshCmdOptDef *def; /* non-NULL pointer to option definition */
char *data; /* allocated data, or NULL for bool option */
vshCmdOpt *next;
};
/*
* Command Usage Flags
*/
enum {
VSH_CMD_FLAG_NOCONNECT = (1 << 0), /* no prior connection needed */
VSH_CMD_FLAG_ALIAS = (1 << 1), /* command is an alias */
};
/*
* vshCmdDef - command definition
*/
struct _vshCmdDef {
const char *name; /* name of command, or NULL for list end */
bool (*handler) (vshControl *, const vshCmd *); /* command handler */
const vshCmdOptDef *opts; /* definition of command options */
const vshCmdInfo *info; /* details about command */
unsigned int flags; /* bitwise OR of VSH_CMD_FLAG */
};
/*
* vshCmd - parsed command
*/
struct _vshCmd {
const vshCmdDef *def; /* command definition */
vshCmdOpt *opts; /* list of command arguments */
vshCmd *next; /* next command */
};
/*
* vshControl
*/
struct _vshControl {
const char *name; /* hardcoded name of the binary that cannot
* be changed without recompilation compared
* to program name */
char *connname; /* connection name */
char *progname; /* program name */
vshCmd *cmd; /* the current command */
char *cmdstr; /* string with command */
bool imode; /* interactive mode? */
bool quiet; /* quiet mode */
bool timing; /* print timing info? */
int debug; /* print debug messages? */
char *logfile; /* log file name */
int log_fd; /* log file descriptor */
char *historydir; /* readline history directory name */
char *historyfile; /* readline history file name */
virThread eventLoop;
virMutex lock;
bool eventLoopStarted;
bool quit;
int eventPipe[2]; /* Write-to-self pipe to end waiting for an
* event to occur */
int eventTimerId; /* id of event loop timeout registration */
int keepalive_interval; /* Client keepalive interval */
int keepalive_count; /* Client keepalive count */
# ifndef WIN32
struct termios termattr; /* settings of the tty terminal */
# endif
bool istty; /* is the terminal a tty */
const vshClientHooks *hooks;/* mandatory client specific hooks */
void *privData; /* client specific data */
};
typedef void *
(*vshConnectionHook)(vshControl *ctl);
struct _vshClientHooks {
vshConnectionHook connHandler;
};
struct _vshCmdGrp {
const char *name; /* name of group, or NULL for list end */
const char *keyword; /* help keyword */
const vshCmdDef *commands;
};
void vshError(vshControl *ctl, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(2, 3);
void vshOpenLogFile(vshControl *ctl);
void vshOutputLogFile(vshControl *ctl, int log_level, const char *format,
va_list ap)
ATTRIBUTE_FMT_PRINTF(3, 0);
void vshCloseLogFile(vshControl *ctl);
const char *vshCmddefGetInfo(const vshCmdDef *cmd, const char *info);
const vshCmdDef *vshCmddefSearch(const char *cmdname);
bool vshCmddefHelp(vshControl *ctl, const char *name);
const vshCmdGrp *vshCmdGrpSearch(const char *grpname);
bool vshCmdGrpHelp(vshControl *ctl, const char *name);
int vshCommandOptInt(vshControl *ctl, const vshCmd *cmd,
const char *name, int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUInt(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUIntWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned int *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptUL(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptString(vshControl *ctl, const vshCmd *cmd,
const char *name, const char **value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptStringReq(vshControl *ctl, const vshCmd *cmd,
const char *name, const char **value)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptLongLong(vshControl *ctl, const vshCmd *cmd,
const char *name, long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULongLong(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptULongLongWrap(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
int vshCommandOptScaledInt(vshControl *ctl, const vshCmd *cmd,
const char *name, unsigned long long *value,
int scale, unsigned long long max)
ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
bool vshCommandOptBool(const vshCmd *cmd, const char *name);
bool vshCommandRun(vshControl *ctl, const vshCmd *cmd);
bool vshCommandStringParse(vshControl *ctl, char *cmdstr);
const vshCmdOpt *vshCommandOptArgv(vshControl *ctl, const vshCmd *cmd,
const vshCmdOpt *opt);
bool vshCommandArgvParse(vshControl *ctl, int nargs, char **argv);
int vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd, int *timeout);
void vshPrintExtra(vshControl *ctl, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(2, 3);
int vshInit(vshControl *ctl, const vshCmdGrp *groups, const vshCmdDef *set);
void vshDeinit(vshControl *ctl);
void vshInitDebug(vshControl *ctl);
void vshDebug(vshControl *ctl, int level, const char *format, ...)
ATTRIBUTE_FMT_PRINTF(3, 4);
/* XXX: add batch support */
# define vshPrint(_ctl, ...) vshPrintExtra(NULL, __VA_ARGS__)
/* User visible sort, so we want locale-specific case comparison. */
# define vshStrcasecmp(S1, S2) strcasecmp(S1, S2)
int vshNameSorter(const void *a, const void *b);
virTypedParameterPtr vshFindTypedParamByName(const char *name,
virTypedParameterPtr list,
int count);
char *vshGetTypedParamValue(vshControl *ctl, virTypedParameterPtr item)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
double vshPrettyCapacity(unsigned long long val, const char **unit);
int vshStringToArray(const char *str, char ***array);
/* Given an index, return either the name of that device (non-NULL) or
* of its parent (NULL if a root). */
typedef const char * (*vshTreeLookup)(int devid, bool parent, void *opaque);
int vshTreePrint(vshControl *ctl, vshTreeLookup lookup, void *opaque,
int num_devices, int devid);
/* error handling */
extern virErrorPtr last_error;
void vshErrorHandler(void *opaque, virErrorPtr error);
void vshReportError(vshControl *ctl);
void vshResetLibvirtError(void);
void vshSaveLibvirtError(void);
/* file handling */
char *vshEditWriteToTempFile(vshControl *ctl, const char *doc);
int vshEditFile(vshControl *ctl, const char *filename);
char *vshEditReadBackFile(vshControl *ctl, const char *filename);
int vshAskReedit(vshControl *ctl, const char *msg, bool relax_avail);
/* terminal modifications */
bool vshTTYIsInterruptCharacter(vshControl *ctl, const char chr);
int vshTTYDisableInterrupt(vshControl *ctl);
int vshTTYRestore(vshControl *ctl);
int vshTTYMakeRaw(vshControl *ctl, bool report_errors);
bool vshTTYAvailable(vshControl *ctl);
/* waiting for events */
enum {
VSH_EVENT_INTERRUPT,
VSH_EVENT_TIMEOUT,
VSH_EVENT_DONE,
};
void vshEventCleanup(vshControl *ctl);
void vshEventDone(vshControl *ctl);
void vshEventLoop(void *opaque);
int vshEventStart(vshControl *ctl, int timeout_ms);
void vshEventTimeout(int timer, void *opaque);
int vshEventWait(vshControl *ctl);
/* generic commands */
extern const vshCmdOptDef opts_help[];
extern const vshCmdInfo info_help[];
extern const vshCmdOptDef opts_cd[];
extern const vshCmdInfo info_cd[];
extern const vshCmdOptDef opts_echo[];
extern const vshCmdInfo info_echo[];
extern const vshCmdInfo info_pwd[];
extern const vshCmdInfo info_quit[];
bool cmdHelp(vshControl *ctl, const vshCmd *cmd);
bool cmdCd(vshControl *ctl, const vshCmd *cmd);
bool cmdEcho(vshControl *ctl, const vshCmd *cmd);
bool cmdPwd(vshControl *ctl, const vshCmd *cmd);
bool cmdQuit(vshControl *ctl, const vshCmd *cmd);
# define VSH_CMD_CD \
{ \
.name = "cd", \
.handler = cmdCd, \
.opts = opts_cd, \
.info = info_cd, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
# define VSH_CMD_ECHO \
{ \
.name = "echo", \
.handler = cmdEcho, \
.opts = opts_echo, \
.info = info_echo, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
# define VSH_CMD_EXIT \
{ \
.name = "exit", \
.handler = cmdQuit, \
.opts = NULL, \
.info = info_quit, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
# define VSH_CMD_HELP \
{ \
.name = "help", \
.handler = cmdHelp, \
.opts = opts_help, \
.info = info_help, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
# define VSH_CMD_PWD \
{ \
.name = "pwd", \
.handler = cmdPwd, \
.opts = NULL, \
.info = info_pwd, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
# define VSH_CMD_QUIT \
{ \
.name = "quit", \
.handler = cmdQuit, \
.opts = NULL, \
.info = info_quit, \
.flags = VSH_CMD_FLAG_NOCONNECT \
}
/* readline */
char * vshReadline(vshControl *ctl, const char *prompt);
/* allocation wrappers */
void *_vshMalloc(vshControl *ctl, size_t sz, const char *filename, int line);
# define vshMalloc(_ctl, _sz) _vshMalloc(_ctl, _sz, __FILE__, __LINE__)
void *_vshCalloc(vshControl *ctl, size_t nmemb, size_t sz,
const char *filename, int line);
# define vshCalloc(_ctl, _nmemb, _sz) \
_vshCalloc(_ctl, _nmemb, _sz, __FILE__, __LINE__)
char *_vshStrdup(vshControl *ctl, const char *s, const char *filename,
int line);
# define vshStrdup(_ctl, _s) _vshStrdup(_ctl, _s, __FILE__, __LINE__)
/* Poison the raw allocating identifiers in favor of our vsh variants. */
# undef malloc
# undef calloc
# undef realloc
# undef strdup
# define malloc use_vshMalloc_instead_of_malloc
# define calloc use_vshCalloc_instead_of_calloc
# define realloc use_vshRealloc_instead_of_realloc
# define strdup use_vshStrdup_instead_of_strdup
/* Macros to help dealing with mutually exclusive options. */
/* VSH_EXCLUSIVE_OPTIONS_EXPR:
*
* @NAME1: String containing the name of the option.
* @EXPR1: Expression to validate the variable (boolean variable)
* @NAME2: String containing the name of the option.
* @EXPR2: Expression to validate the variable (boolean variable)
*
* Reject mutually exclusive command options in virsh. Use the
* provided expression to check the variables.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS_EXPR(NAME1, EXPR1, NAME2, EXPR2) \
if ((EXPR1) && (EXPR2)) { \
vshError(ctl, _("Options --%s and --%s are mutually exclusive"), \
NAME1, NAME2); \
return false; \
}
/* VSH_EXCLUSIVE_OPTIONS:
*
* @NAME1: String containing the name of the option.
* @NAME2: String containing the name of the option.
*
* Reject mutually exclusive command options in virsh. Use the
* vshCommandOptBool call to request them.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS(NAME1, NAME2) \
VSH_EXCLUSIVE_OPTIONS_EXPR(NAME1, vshCommandOptBool(cmd, NAME1), \
NAME2, vshCommandOptBool(cmd, NAME2))
/* VSH_EXCLUSIVE_OPTIONS_VAR:
*
* @VARNAME1: Boolean variable containing the value of the option of same name
* @VARNAME2: Boolean variable containing the value of the option of same name
*
* Reject mutually exclusive command options in virsh. Check in variables that
* contain the value and have same name as the option.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_EXCLUSIVE_OPTIONS_VAR(VARNAME1, VARNAME2) \
VSH_EXCLUSIVE_OPTIONS_EXPR(#VARNAME1, VARNAME1, #VARNAME2, VARNAME2)
/* Macros to help dealing with required options. */
/* VSH_REQUIRE_OPTION_EXPR:
*
* @NAME1: String containing the name of the option.
* @EXPR1: Expression to validate the variable (boolean variable).
* @NAME2: String containing the name of required option.
* @EXPR2: Expression to validate the variable (boolean variable).
*
* Check if required command options in virsh was set. Use the
* provided expression to check the variables.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION_EXPR(NAME1, EXPR1, NAME2, EXPR2) \
do { \
if ((EXPR1) && !(EXPR2)) { \
vshError(ctl, _("Option --%s is required by option --%s"), \
NAME2, NAME1); \
return false; \
} \
} while (0)
/* VSH_REQUIRE_OPTION:
*
* @NAME1: String containing the name of the option.
* @NAME2: String containing the name of required option.
*
* Check if required command options in virsh was set. Use the
* vshCommandOptBool call to request them.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION(NAME1, NAME2) \
VSH_REQUIRE_OPTION_EXPR(NAME1, vshCommandOptBool(cmd, NAME1), \
NAME2, vshCommandOptBool(cmd, NAME2))
/* VSH_REQUIRE_OPTION_VAR:
*
* @VARNAME1: Boolean variable containing the value of the option of same name.
* @VARNAME2: Boolean variable containing the value of required option of
* same name.
*
* Check if required command options in virsh was set. Check in variables
* that contain the value and have same name as the option.
*
* This helper does an early return and therefore it has to be called
* before anything that would require cleanup.
*/
# define VSH_REQUIRE_OPTION_VAR(VARNAME1, VARNAME2) \
VSH_REQUIRE_OPTION_EXPR(#VARNAME1, VARNAME1, #VARNAME2, VARNAME2)
#endif /* VSH_H */