[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH] virsh: change output text words 'domain' and 'guest' to 'virtual machine'



This changes all occurrences of the words 'domain' and 'guest'  in virsh
output to 'virtual machine', plus some occurrences in comments, plus
updates the man page and 'make check' tests to match.

Some trivial typos and line lengths were fixed on the way through too.
---
Until now we use the words 'virtual machine', 'guest' and 'domain' interchangeably
in our discussions and documentation.  'virtual machine' seems to be the most
common (and the standard term in our industry), whereas 'guest' is less common,
and 'domain' seems to be a implementation legacy from Xen.  Using 'virtual machine'
here is easier on newbies, gives us a (useful) shorter abbreviation of 'vm', and
brings us more into line with industry standards.

Ideally we'd also adjust command names having a 'dom' component or commands with a
'--domain' keyword, by adding a similar 'vm' one and matching '--vm' or similar
keywords, then deprecating the previous usage.  But, it's not that important for
now given we explicitly have help text and lots of context around each.
 tests/cpuset              |    2 +-
 tests/define-dev-segfault |    2 +-
 tests/int-overflow        |    4 +-
 tests/read-bufsiz         |    2 +-
 tests/start               |    2 +-
 tests/undefine            |    8 +-
 tools/virsh.c             |  693 +++++++++++++++++++++++++++------------------
 tools/virsh.pod           |  669 +++++++++++++++++++++++---------------------
 8 files changed, 781 insertions(+), 601 deletions(-)

diff --git a/tests/cpuset b/tests/cpuset
index 800d3bc..8c47c39 100755
--- a/tests/cpuset
+++ b/tests/cpuset
@@ -40,7 +40,7 @@ sed "s/vcpu>/vcpu cpuset='aaa'>/" xml > xml-invalid || fail=1
 # Require failure and a diagnostic.
 $abs_top_builddir/tools/virsh --connect test:///default define xml-invalid > out 2>&1 && fail=1
 cat <<\EOF > exp || fail=1
-error: Failed to define domain from xml-invalid
+error: Failed to define virtual machine from xml-invalid
 error: internal error topology cpuset syntax error
 
 EOF
diff --git a/tests/define-dev-segfault b/tests/define-dev-segfault
index 19d4e67..9b2422d 100755
--- a/tests/define-dev-segfault
+++ b/tests/define-dev-segfault
@@ -68,7 +68,7 @@ url=test:///default
 $abs_top_builddir/tools/virsh --connect "$url" 'define D.xml; dumpxml D' > out 2>&1 || fail=1
 
 cat > exp <<EOF || fail=1
-Domain D defined from D.xml
+Virtual machine D defined from D.xml
 
 $(cat D.xml)
 
diff --git a/tests/int-overflow b/tests/int-overflow
index c9f5de9..a8b1d39 100755
--- a/tests/int-overflow
+++ b/tests/int-overflow
@@ -1,5 +1,5 @@
 #!/bin/bash
-# Ensure that an invalid domain ID isn't interpreted as a valid one.
+# Ensure that an invalid vm ID isn't interpreted as a valid one.
 # Before, an ID of 2^32+2 would be treated just like an ID of 2.
 
 test -z "$srcdir" && srcdir=$(pwd)
@@ -13,7 +13,7 @@ fi
 
 . "$srcdir/test-lib.sh"
 
-echo "error: failed to get domain '4294967298'" > exp || fail=1
+echo "error: failed to get virtual machine '4294967298'" > exp || fail=1
 echo domname 4294967298 | $abs_top_builddir/tools/virsh --quiet \
     --connect test://$abs_top_srcdir/examples/xml/test/testnode.xml \
     > /dev/null 2> err || fail=1
diff --git a/tests/read-bufsiz b/tests/read-bufsiz
index 2a91bcf..52af6af 100755
--- a/tests/read-bufsiz
+++ b/tests/read-bufsiz
@@ -43,7 +43,7 @@ for i in before after; do
   ( test $i = before && cat sp xml || cat xml sp ) > $in || fail=1
 
   $abs_top_builddir/tools/virsh --connect test:///default define $in > out || fail=1
-  printf "Domain newtest defined from $in\n\n" > exp || fail=1
+  printf "Virtual machine newtest defined from $in\n\n" > exp || fail=1
   compare exp out || fail=1
 done
 
diff --git a/tests/start b/tests/start
index 524b127..e274f65 100755
--- a/tests/start
+++ b/tests/start
@@ -38,7 +38,7 @@ $abs_top_builddir/tools/virsh -c $test_url start test > out 2> err && fail=1
 echo > exp || fail=1
 compare exp out || fail=1
 
-echo 'error: Domain is already active' > exp || fail=1
+echo 'error: Virtual machine is already active' > exp || fail=1
 compare exp err || fail=1
 
 (exit $fail); exit $fail
diff --git a/tests/undefine b/tests/undefine
index f89a91e..daaf0fc 100755
--- a/tests/undefine
+++ b/tests/undefine
@@ -33,7 +33,7 @@ fail=0
 $abs_top_builddir/tools/virsh -q -c test:///default undefine test > out 2>&1
 test $? = 1 || fail=1
 cat <<\EOF > exp || fail=1
-error: Failed to undefine domain test
+error: Failed to undefine virtual machine test
 error: internal error Domain 'test' is still running
 EOF
 compare exp out || fail=1
@@ -42,7 +42,7 @@ compare exp out || fail=1
 $abs_top_builddir/tools/virsh -q -c test:///default undefine 1 > out 2>&1
 test $? = 1 || fail=1
 cat <<\EOF > exp || fail=1
-error: a running domain like 1 cannot be undefined;
+error: a running virtual machine like 1 cannot be undefined;
 to undefine, first shutdown then undefine using its name or UUID
 EOF
 compare exp out || fail=1
@@ -51,8 +51,8 @@ compare exp out || fail=1
 $abs_top_builddir/tools/virsh -q -c test:///default 'shutdown test; undefine test' > out 2>&1
 test $? = 0 || fail=1
 cat <<\EOF > exp || fail=1
-Domain test is being shutdown
-Domain test has been undefined
+Virtual machine test is being shutdown
+Virtual Machine test has been undefined
 EOF
 compare exp out || fail=1
 
diff --git a/tools/virsh.c b/tools/virsh.c
index e704799..8923fe9 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -567,14 +567,15 @@ cmdHelp(vshControl *ctl, const vshCmd *cmd)
  * "autostart" command
  */
 static const vshCmdInfo info_autostart[] = {
-    {"help", N_("autostart a domain")},
+    {"help", N_("autostart a virtual machine")},
     {"desc",
-     N_("Configure a domain to be automatically started at boot.")},
+     N_("Configure a virtual machine to be automatically started at boot.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_autostart[] = {
-    {"domain",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+               N_("virtual machine name, id or uuid")},
     {"disable", VSH_OT_BOOL, 0, N_("disable autostarting")},
     {NULL, 0, 0, NULL}
 };
@@ -596,17 +597,22 @@ cmdAutostart(vshControl *ctl, const vshCmd *cmd)
 
     if (virDomainSetAutostart(dom, autostart) < 0) {
         if (autostart)
-            vshError(ctl, _("Failed to mark domain %s as autostarted"), name);
+            vshError(ctl,
+                     _("Failed to mark virtual machine %s as autostarted"),
+                     name);
         else
-            vshError(ctl, _("Failed to unmark domain %s as autostarted"), name);
+            vshError(ctl,
+                     _("Failed to unmark virtual machine %s as autostarted"),
+                     name);
         virDomainFree(dom);
         return FALSE;
     }
 
     if (autostart)
-        vshPrint(ctl, _("Domain %s marked as autostarted\n"), name);
+        vshPrint(ctl, _("Virtual machine %s marked as autostarted\n"), name);
     else
-        vshPrint(ctl, _("Domain %s unmarked as autostarted\n"), name);
+        vshPrint(ctl,
+                 _("Virtual machine %s unmarked as autostarted\n"), name);
 
     virDomainFree(dom);
     return TRUE;
@@ -669,14 +675,15 @@ cmdConnect(vshControl *ctl, const vshCmd *cmd)
  * "console" command
  */
 static const vshCmdInfo info_console[] = {
-    {"help", N_("connect to the guest console")},
+    {"help", N_("connect to the virtual machine console")},
     {"desc",
-     N_("Connect the virtual serial console for the guest")},
+     N_("Connect the virtual serial console for the virtual machine")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_console[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -708,12 +715,12 @@ cmdRunConsole(vshControl *ctl, virDomainPtr dom)
     }
 
     if (virDomainGetInfo(dom, &dominfo) < 0) {
-        vshError(ctl, "%s", _("Unable to get domain status"));
+        vshError(ctl, "%s", _("Unable to get virtual machine status"));
         goto cleanup;
     }
 
     if (dominfo.state == VIR_DOMAIN_SHUTOFF) {
-        vshError(ctl, "%s", _("The domain is not running"));
+        vshError(ctl, "%s", _("The virtual machine is not running"));
         goto cleanup;
     }
 
@@ -734,12 +741,15 @@ cmdRunConsole(vshControl *ctl, virDomainPtr dom)
     obj = xmlXPathEval(BAD_CAST "string(/domain/devices/console/@tty)", ctxt);
     if ((obj != NULL) && ((obj->type == XPATH_STRING) &&
                           (obj->stringval != NULL) && (obj->stringval[0] != 0))) {
-        vshPrintExtra(ctl, _("Connected to domain %s\n"), virDomainGetName(dom));
+        vshPrintExtra(ctl,
+                      _("Connected to virtual machine %s\n"),
+                      virDomainGetName(dom));
         vshPrintExtra(ctl, "%s", _("Escape character is ^]\n"));
         if (vshRunConsole((const char *)obj->stringval) == 0)
             ret = TRUE;
     } else {
-        vshPrintExtra(ctl, "%s", _("No console available for domain\n"));
+        vshPrintExtra(ctl, "%s",
+                           _("No console available for virtual machine\n"));
     }
     xmlXPathFreeObject(obj);
 
@@ -778,14 +788,14 @@ cmdConsole(vshControl *ctl, const vshCmd *cmd)
  * "list" command
  */
 static const vshCmdInfo info_list[] = {
-    {"help", N_("list domains")},
-    {"desc", N_("Returns list of domains.")},
+    {"help", N_("list virtual machines")},
+    {"desc", N_("Returns list of virtual machines.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_list[] = {
-    {"inactive", VSH_OT_BOOL, 0, N_("list inactive domains")},
-    {"all", VSH_OT_BOOL, 0, N_("list inactive & active domains")},
+    {"inactive", VSH_OT_BOOL, 0, N_("list inactive virtual machines")},
+    {"all", VSH_OT_BOOL, 0, N_("list inactive & active virtual machines")},
     {NULL, 0, 0, NULL}
 };
 
@@ -807,14 +817,15 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
     if (active) {
         maxid = virConnectNumOfDomains(ctl->conn);
         if (maxid < 0) {
-            vshError(ctl, "%s", _("Failed to list active domains"));
+            vshError(ctl, "%s", _("Failed to list active virtual machines"));
             return FALSE;
         }
         if (maxid) {
             ids = vshMalloc(ctl, sizeof(int) * maxid);
 
             if ((maxid = virConnectListDomains(ctl->conn, &ids[0], maxid)) < 0) {
-                vshError(ctl, "%s", _("Failed to list active domains"));
+                vshError(ctl, "%s",
+                              _("Failed to list active virtual machines"));
                 VIR_FREE(ids);
                 return FALSE;
             }
@@ -825,7 +836,8 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
     if (inactive) {
         maxname = virConnectNumOfDefinedDomains(ctl->conn);
         if (maxname < 0) {
-            vshError(ctl, "%s", _("Failed to list inactive domains"));
+            vshError(ctl, "%s",
+                          _("Failed to list inactive virtual machines"));
             VIR_FREE(ids);
             return FALSE;
         }
@@ -833,7 +845,8 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
             names = vshMalloc(ctl, sizeof(char *) * maxname);
 
             if ((maxname = virConnectListDefinedDomains(ctl->conn, names, maxname)) < 0) {
-                vshError(ctl, "%s", _("Failed to list inactive domains"));
+                vshError(ctl, "%s",
+                              _("Failed to list inactive virtual machines"));
                 VIR_FREE(ids);
                 VIR_FREE(names);
                 return FALSE;
@@ -850,7 +863,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
         virDomainPtr dom = virDomainLookupByID(ctl->conn, ids[i]);
         const char *state;
 
-        /* this kind of work with domains is not atomic operation */
+        /* this kind of work with virtual machines is not atomic operation */
         if (!dom)
             continue;
 
@@ -870,7 +883,7 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
         virDomainPtr dom = virDomainLookupByName(ctl->conn, names[i]);
         const char *state;
 
-        /* this kind of work with domains is not atomic operation */
+        /* this kind of work with virtual machines is not atomic operation */
         if (!dom) {
             VIR_FREE(names[i]);
             continue;
@@ -895,13 +908,14 @@ cmdList(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
  * "domstate" command
  */
 static const vshCmdInfo info_domstate[] = {
-    {"help", N_("domain state")},
-    {"desc", N_("Returns state about a domain.")},
+    {"help", N_("virtual machine state")},
+    {"desc", N_("Returns state about a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domstate[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -931,13 +945,14 @@ cmdDomstate(vshControl *ctl, const vshCmd *cmd)
 /* "domblkstat" command
  */
 static const vshCmdInfo info_domblkstat[] = {
-    {"help", N_("get device block stats for a domain")},
-    {"desc", N_("Get device block stats for a running domain.")},
+    {"help", N_("get device block stats for a virtual machine")},
+    {"desc", N_("Get device block stats for a running virtual machine.")},
     {NULL,NULL}
 };
 
 static const vshCmdOptDef opts_domblkstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
     {NULL, 0, 0, NULL}
 };
@@ -988,13 +1003,14 @@ cmdDomblkstat (vshControl *ctl, const vshCmd *cmd)
 /* "domifstat" command
  */
 static const vshCmdInfo info_domifstat[] = {
-    {"help", N_("get network interface stats for a domain")},
-    {"desc", N_("Get network interface stats for a running domain.")},
+    {"help", N_("get network interface stats for a virtual machine")},
+    {"desc", N_("Get network interface stats for a running virtual machine.")},
     {NULL,NULL}
 };
 
 static const vshCmdOptDef opts_domifstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"interface", VSH_OT_DATA, VSH_OFLAG_REQ, N_("interface device")},
     {NULL, 0, 0, NULL}
 };
@@ -1055,13 +1071,14 @@ cmdDomIfstat (vshControl *ctl, const vshCmd *cmd)
  * "dommemstats" command
  */
 static const vshCmdInfo info_dommemstat[] = {
-    {"help", N_("get memory statistics for a domain")},
-    {"desc", N_("Get memory statistics for a runnng domain.")},
+    {"help", N_("get memory statistics for a virtual machine")},
+    {"desc", N_("Get memory statistics for a running virtual machine.")},
     {NULL,NULL}
 };
 
 static const vshCmdOptDef opts_dommemstat[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1081,7 +1098,9 @@ cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
 
     nr_stats = virDomainMemoryStats (dom, stats, VIR_DOMAIN_MEMORY_STAT_NR, 0);
     if (nr_stats == -1) {
-        vshError(ctl, _("Failed to get memory statistics for domain %s"), name);
+        vshError(ctl,
+                 _("Failed to get memory statistics for virtual machine %s"),
+                 name);
         virDomainFree(dom);
         return FALSE;
     }
@@ -1109,13 +1128,14 @@ cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
  * "domblkinfo" command
  */
 static const vshCmdInfo info_domblkinfo[] = {
-    {"help", N_("domain block device size information")},
-    {"desc", N_("Get block device size info for a domain.")},
+    {"help", N_("virtual machine block device size information")},
+    {"desc", N_("Get block device size info for a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domblkinfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"device", VSH_OT_DATA, VSH_OFLAG_REQ, N_("block device")},
     {NULL, 0, 0, NULL}
 };
@@ -1156,13 +1176,14 @@ cmdDomblkinfo(vshControl *ctl, const vshCmd *cmd)
  * "suspend" command
  */
 static const vshCmdInfo info_suspend[] = {
-    {"help", N_("suspend a domain")},
-    {"desc", N_("Suspend a running domain.")},
+    {"help", N_("suspend a virtual machine")},
+    {"desc", N_("Suspend a running virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_suspend[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1180,9 +1201,9 @@ cmdSuspend(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainSuspend(dom) == 0) {
-        vshPrint(ctl, _("Domain %s suspended\n"), name);
+        vshPrint(ctl, _("Virtual machine %s suspended\n"), name);
     } else {
-        vshError(ctl, _("Failed to suspend domain %s"), name);
+        vshError(ctl, _("Failed to suspend virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -1194,17 +1215,19 @@ cmdSuspend(vshControl *ctl, const vshCmd *cmd)
  * "create" command
  */
 static const vshCmdInfo info_create[] = {
-    {"help", N_("create a domain from an XML file")},
-    {"desc", N_("Create a domain.")},
+    {"help", N_("create a virtual machine from an XML file")},
+    {"desc", N_("Create a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_create[] = {
-    {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("file containing an XML domain description")},
+    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
+             N_("file containing an XML virtual machine description")},
 #ifndef WIN32
     {"console", VSH_OT_BOOL, 0, N_("attach to console after creation")},
 #endif
-    {"paused", VSH_OT_BOOL, 0, N_("leave the guest paused after creation")},
+    {"paused", VSH_OT_BOOL, 0,
+               N_("leave the virtual machine paused after creation")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1238,7 +1261,7 @@ cmdCreate(vshControl *ctl, const vshCmd *cmd)
     VIR_FREE(buffer);
 
     if (dom != NULL) {
-        vshPrint(ctl, _("Domain %s created from %s\n"),
+        vshPrint(ctl, _("Virtual machine %s created from %s\n"),
                  virDomainGetName(dom), from);
 #ifndef WIN32
         if (console)
@@ -1246,7 +1269,7 @@ cmdCreate(vshControl *ctl, const vshCmd *cmd)
 #endif
         virDomainFree(dom);
     } else {
-        vshError(ctl, _("Failed to create domain from %s"), from);
+        vshError(ctl, _("Failed to create virtual machine from %s"), from);
         ret = FALSE;
     }
     return ret;
@@ -1256,13 +1279,15 @@ cmdCreate(vshControl *ctl, const vshCmd *cmd)
  * "define" command
  */
 static const vshCmdInfo info_define[] = {
-    {"help", N_("define (but don't start) a domain from an XML file")},
-    {"desc", N_("Define a domain.")},
+    {"help",
+     N_("define (but don't start) a virtual machine from an XML file")},
+    {"desc", N_("Define a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_define[] = {
-    {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("file containing an XML domain description")},
+    {"file", VSH_OT_DATA, VSH_OFLAG_REQ,
+             N_("file containing an XML virtual machine description")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1289,11 +1314,11 @@ cmdDefine(vshControl *ctl, const vshCmd *cmd)
     VIR_FREE(buffer);
 
     if (dom != NULL) {
-        vshPrint(ctl, _("Domain %s defined from %s\n"),
+        vshPrint(ctl, _("Virtual machine %s defined from %s\n"),
                  virDomainGetName(dom), from);
         virDomainFree(dom);
     } else {
-        vshError(ctl, _("Failed to define domain from %s"), from);
+        vshError(ctl, _("Failed to define virtual machine from %s"), from);
         ret = FALSE;
     }
     return ret;
@@ -1303,13 +1328,15 @@ cmdDefine(vshControl *ctl, const vshCmd *cmd)
  * "undefine" command
  */
 static const vshCmdInfo info_undefine[] = {
-    {"help", N_("undefine an inactive domain")},
-    {"desc", N_("Undefine the configuration for an inactive domain.")},
+    {"help", N_("undefine an inactive virtual machine")},
+    {"desc",
+     N_("Undefine the configuration for an inactive virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_undefine[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1332,7 +1359,7 @@ cmdUndefine(vshControl *ctl, const vshCmd *cmd)
     if (name && virStrToLong_i(name, NULL, 10, &id) == 0
         && id >= 0 && (dom = virDomainLookupByID(ctl->conn, id))) {
         vshError(ctl,
-                 _("a running domain like %s cannot be undefined;\n"
+                 _("a running virtual machine like %s cannot be undefined;\n"
                    "to undefine, first shutdown then undefine"
                    " using its name or UUID"),
                  name);
@@ -1344,9 +1371,9 @@ cmdUndefine(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainUndefine(dom) == 0) {
-        vshPrint(ctl, _("Domain %s has been undefined\n"), name);
+        vshPrint(ctl, _("Virtual Machine %s has been undefined\n"), name);
     } else {
-        vshError(ctl, _("Failed to undefine domain %s"), name);
+        vshError(ctl, _("Failed to undefine virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -1359,19 +1386,21 @@ cmdUndefine(vshControl *ctl, const vshCmd *cmd)
  * "start" command
  */
 static const vshCmdInfo info_start[] = {
-    {"help", N_("start a (previously defined) inactive domain")},
-    {"desc", N_("Start a domain, either from the last managedsave\n"
+    {"help", N_("start a (previously defined) inactive virtual machine")},
+    {"desc", N_("Start a virtual machine, either from the last managedsave\n"
                 "    state, or via a fresh boot if no managedsave state\n"
                 "    is present.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_start[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("name of the inactive domain")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("name of the inactive virtual machine")},
 #ifndef WIN32
     {"console", VSH_OT_BOOL, 0, N_("attach to console after creation")},
 #endif
-    {"paused", VSH_OT_BOOL, 0, N_("leave the guest paused after creation")},
+    {"paused", VSH_OT_BOOL, 0,
+               N_("leave the virtual machine paused after creation")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1392,7 +1421,7 @@ cmdStart(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainGetID(dom) != (unsigned int)-1) {
-        vshError(ctl, "%s", _("Domain is already active"));
+        vshError(ctl, "%s", _("Virtual machine is already active"));
         virDomainFree(dom);
         return FALSE;
     }
@@ -1403,14 +1432,15 @@ cmdStart(vshControl *ctl, const vshCmd *cmd)
     /* Prefer older API unless we have to pass a flag.  */
     if ((flags ? virDomainCreateWithFlags(dom, flags)
          : virDomainCreate(dom)) == 0) {
-        vshPrint(ctl, _("Domain %s started\n"),
+        vshPrint(ctl, _("Virtual machine %s started\n"),
                  virDomainGetName(dom));
 #ifndef WIN32
         if (console)
             cmdRunConsole(ctl, dom);
 #endif
     } else {
-        vshError(ctl, _("Failed to start domain %s"), virDomainGetName(dom));
+        vshError(ctl, _("Failed to start virtual machine %s"),
+                      virDomainGetName(dom));
         ret = FALSE;
     }
     virDomainFree(dom);
@@ -1421,13 +1451,14 @@ cmdStart(vshControl *ctl, const vshCmd *cmd)
  * "save" command
  */
 static const vshCmdInfo info_save[] = {
-    {"help", N_("save a domain state to a file")},
-    {"desc", N_("Save a running domain.")},
+    {"help", N_("save a virtual machine state to a file")},
+    {"desc", N_("Save a running virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_save[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("where to save the data")},
     {NULL, 0, 0, NULL}
 };
@@ -1450,9 +1481,9 @@ cmdSave(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainSave(dom, to) == 0) {
-        vshPrint(ctl, _("Domain %s saved to %s\n"), name, to);
+        vshPrint(ctl, _("Virtual machine %s saved to %s\n"), name, to);
     } else {
-        vshError(ctl, _("Failed to save domain %s to %s"), name, to);
+        vshError(ctl, _("Failed to save virtual machine %s to %s"), name, to);
         ret = FALSE;
     }
 
@@ -1464,16 +1495,18 @@ cmdSave(vshControl *ctl, const vshCmd *cmd)
  * "managedsave" command
  */
 static const vshCmdInfo info_managedsave[] = {
-    {"help", N_("managed save of a domain state")},
-    {"desc", N_("Save and destroy a running domain, so it can be restarted from\n"
-                "    the same state at a later time.  When the virsh 'start'\n"
-                "    command is next run for the domain, it will automatically\n"
-                "    be started from this saved state.")},
+    {"help", N_("managed save of a virtual machine state")},
+    {"desc", N_("Save and destroy a running virtual machine, so it can be\n"
+                "    restarted from the same state at a later time.  When\n"
+                "    the virsh 'start' command is next run for the virtual\n"
+                "    machine, it will automatically be started from this\n"
+                "    saved state.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_managedsave[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1491,9 +1524,9 @@ cmdManagedSave(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainManagedSave(dom, 0) == 0) {
-        vshPrint(ctl, _("Domain %s state saved by libvirt\n"), name);
+        vshPrint(ctl, _("Virtual machine %s state saved by libvirt\n"), name);
     } else {
-        vshError(ctl, _("Failed to save domain %s state"), name);
+        vshError(ctl, _("Failed to save virtual machine %s state"), name);
         ret = FALSE;
     }
 
@@ -1505,13 +1538,15 @@ cmdManagedSave(vshControl *ctl, const vshCmd *cmd)
  * "managedsave-remove" command
  */
 static const vshCmdInfo info_managedsaveremove[] = {
-    {"help", N_("Remove managed save of a domain")},
-    {"desc", N_("Remove an existing managed save state file from a domain")},
+    {"help", N_("Remove managed save of a virtual machine")},
+    {"desc",
+     N_("Remove an existing managed save state file from a virtual machine")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_managedsaveremove[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1531,22 +1566,27 @@ cmdManagedSaveRemove(vshControl *ctl, const vshCmd *cmd)
 
     hassave = virDomainHasManagedSaveImage(dom, 0);
     if (hassave < 0) {
-        vshError(ctl, "%s", _("Failed to check for domain managed save image"));
+        vshError(ctl, "%s",
+                 _("Failed to check for virtual machine managed save image"));
         goto cleanup;
     }
 
     if (hassave) {
         if (virDomainManagedSaveRemove(dom, 0) < 0) {
-            vshError(ctl, _("Failed to remove managed save image for domain %s"),
+            vshError(ctl,
+                     _("Failed to remove managed save image for VM %s"),
                      name);
             goto cleanup;
         }
         else
-            vshPrint(ctl, _("Removed managedsave image for domain %s"), name);
+            vshPrint(ctl,
+                     _("Removed managed save image for virtual machine %s"),
+                     name);
     }
     else
-        vshPrint(ctl, _("Domain %s has no manage save image; removal skipped"),
-                 name);
+        vshPrint(ctl,
+            _("Virtual machine %s has no manage save image; removal skipped"),
+            name);
 
     ret = TRUE;
 
@@ -1565,7 +1605,7 @@ static const vshCmdInfo info_schedinfo[] = {
 };
 
 static const vshCmdOptDef opts_schedinfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine name, id or uuid")},
     {"set", VSH_OT_STRING, VSH_OFLAG_NONE, N_("parameter=value")},
     {"weight", VSH_OT_INT, VSH_OFLAG_NONE, N_("weight for XEN_CREDIT")},
     {"cap", VSH_OT_INT, VSH_OFLAG_NONE, N_("cap for XEN_CREDIT")},
@@ -1773,8 +1813,8 @@ cmdSchedinfo(vshControl *ctl, const vshCmd *cmd)
  * "restore" command
  */
 static const vshCmdInfo info_restore[] = {
-    {"help", N_("restore a domain from a saved state in a file")},
-    {"desc", N_("Restore a domain.")},
+    {"help", N_("restore a virtual machine from a saved state in a file")},
+    {"desc", N_("Restore a virtual machine.")},
     {NULL, NULL}
 };
 
@@ -1798,9 +1838,9 @@ cmdRestore(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainRestore(ctl->conn, from) == 0) {
-        vshPrint(ctl, _("Domain restored from %s\n"), from);
+        vshPrint(ctl, _("Virtual machine restored from %s\n"), from);
     } else {
-        vshError(ctl, _("Failed to restore domain from %s"), from);
+        vshError(ctl, _("Failed to restore virtual machine from %s"), from);
         ret = FALSE;
     }
     return ret;
@@ -1810,15 +1850,17 @@ cmdRestore(vshControl *ctl, const vshCmd *cmd)
  * "dump" command
  */
 static const vshCmdInfo info_dump[] = {
-    {"help", N_("dump the core of a domain to a file for analysis")},
-    {"desc", N_("Core dump a domain.")},
+    {"help", N_("dump the core of a virtual machine to a file for analysis")},
+    {"desc", N_("Core dump a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_dump[] = {
     {"live", VSH_OT_BOOL, 0, N_("perform a live core dump if supported")},
-    {"crash", VSH_OT_BOOL, 0, N_("crash the domain after core dump")},
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"crash", VSH_OT_BOOL, 0,
+                           N_("crash the virtual machine after core dump")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"file", VSH_OT_DATA, VSH_OFLAG_REQ, N_("where to dump the core")},
     {NULL, 0, 0, NULL}
 };
@@ -1847,9 +1889,10 @@ cmdDump(vshControl *ctl, const vshCmd *cmd)
         flags |= VIR_DUMP_CRASH;
 
     if (virDomainCoreDump(dom, to, flags) == 0) {
-        vshPrint(ctl, _("Domain %s dumped to %s\n"), name, to);
+        vshPrint(ctl, _("Virtual machine %s dumped to %s\n"), name, to);
     } else {
-        vshError(ctl, _("Failed to core dump domain %s to %s"), name, to);
+        vshError(ctl, _("Failed to core dump virtual machine %s to %s"),
+                      name, to);
         ret = FALSE;
     }
 
@@ -1861,13 +1904,14 @@ cmdDump(vshControl *ctl, const vshCmd *cmd)
  * "resume" command
  */
 static const vshCmdInfo info_resume[] = {
-    {"help", N_("resume a domain")},
-    {"desc", N_("Resume a previously suspended domain.")},
+    {"help", N_("resume a virtual machine")},
+    {"desc", N_("Resume a previously suspended virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_resume[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1885,9 +1929,9 @@ cmdResume(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainResume(dom) == 0) {
-        vshPrint(ctl, _("Domain %s resumed\n"), name);
+        vshPrint(ctl, _("Virtual machine %s resumed\n"), name);
     } else {
-        vshError(ctl, _("Failed to resume domain %s"), name);
+        vshError(ctl, _("Failed to resume virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -1899,13 +1943,14 @@ cmdResume(vshControl *ctl, const vshCmd *cmd)
  * "shutdown" command
  */
 static const vshCmdInfo info_shutdown[] = {
-    {"help", N_("gracefully shutdown a domain")},
-    {"desc", N_("Run shutdown in the target domain.")},
+    {"help", N_("gracefully shutdown a virtual machine")},
+    {"desc", N_("Run shutdown in the target virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_shutdown[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1923,9 +1968,9 @@ cmdShutdown(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainShutdown(dom) == 0) {
-        vshPrint(ctl, _("Domain %s is being shutdown\n"), name);
+        vshPrint(ctl, _("Virtual machine %s is being shutdown\n"), name);
     } else {
-        vshError(ctl, _("Failed to shutdown domain %s"), name);
+        vshError(ctl, _("Failed to shutdown virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -1937,13 +1982,14 @@ cmdShutdown(vshControl *ctl, const vshCmd *cmd)
  * "reboot" command
  */
 static const vshCmdInfo info_reboot[] = {
-    {"help", N_("reboot a domain")},
-    {"desc", N_("Run a reboot command in the target domain.")},
+    {"help", N_("reboot a virtual machine")},
+    {"desc", N_("Run a reboot command in the target virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_reboot[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1961,9 +2007,9 @@ cmdReboot(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainReboot(dom, 0) == 0) {
-        vshPrint(ctl, _("Domain %s is being rebooted\n"), name);
+        vshPrint(ctl, _("Virtual machine %s is being rebooted\n"), name);
     } else {
-        vshError(ctl, _("Failed to reboot domain %s"), name);
+        vshError(ctl, _("Failed to reboot virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -1975,13 +2021,14 @@ cmdReboot(vshControl *ctl, const vshCmd *cmd)
  * "destroy" command
  */
 static const vshCmdInfo info_destroy[] = {
-    {"help", N_("destroy a domain")},
-    {"desc", N_("Destroy a given domain.")},
+    {"help", N_("destroy a virtual machine")},
+    {"desc", N_("Destroy a given virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_destroy[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -1999,9 +2046,9 @@ cmdDestroy(vshControl *ctl, const vshCmd *cmd)
         return FALSE;
 
     if (virDomainDestroy(dom) == 0) {
-        vshPrint(ctl, _("Domain %s destroyed\n"), name);
+        vshPrint(ctl, _("Virtual machine %s destroyed\n"), name);
     } else {
-        vshError(ctl, _("Failed to destroy domain %s"), name);
+        vshError(ctl, _("Failed to destroy virtual machine %s"), name);
         ret = FALSE;
     }
 
@@ -2013,13 +2060,14 @@ cmdDestroy(vshControl *ctl, const vshCmd *cmd)
  * "dominfo" command
  */
 static const vshCmdInfo info_dominfo[] = {
-    {"help", N_("domain information")},
-    {"desc", N_("Returns basic information about the domain.")},
+    {"help", N_("virtual machine information")},
+    {"desc", N_("Returns basic information about the virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_dominfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2084,15 +2132,17 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
         ret = FALSE;
     }
 
-    /* Check and display whether the domain is persistent or not */
+    /* Check and display whether the virtual machine is persistent or not */
     persistent = virDomainIsPersistent(dom);
-    vshDebug(ctl, 5, "Domain persistent flag value: %d\n", persistent);
+    vshDebug(ctl, 5, "Virtual machine persistent flag value: %d\n",
+                     persistent);
     if (persistent < 0)
         vshPrint(ctl, "%-15s %s\n", _("Persistent:"), _("unknown"));
     else
-        vshPrint(ctl, "%-15s %s\n", _("Persistent:"), persistent ? _("yes") : _("no"));
+        vshPrint(ctl, "%-15s %s\n", _("Persistent:"),
+                                    persistent ? _("yes") : _("no"));
 
-    /* Check and display whether the domain autostarts or not */
+    /* Check and display whether the virtual machine autostarts or not */
     if (!virDomainGetAutostart(dom, &autostart)) {
         vshPrint(ctl, "%-15s %s\n", _("Autostart:"),
                  autostart ? _("enable") : _("disable") );
@@ -2111,7 +2161,7 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
             vshPrint(ctl, "%-15s %s\n", _("Security model:"), secmodel.model);
             vshPrint(ctl, "%-15s %s\n", _("Security DOI:"), secmodel.doi);
 
-            /* Security labels are only valid for active domains */
+            /* Security labels are only valid for active virtual machines */
             memset(&seclabel, 0, sizeof seclabel);
             if (virDomainGetSecurityLabel(dom, &seclabel) == -1) {
                 virDomainFree(dom);
@@ -2119,7 +2169,8 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
             } else {
                 if (seclabel.label[0] != '\0')
                     vshPrint(ctl, "%-15s %s (%s)\n", _("Security label:"),
-                             seclabel.label, seclabel.enforcing ? "enforcing" : "permissive");
+                             seclabel.label,
+                             seclabel.enforcing ? "enforcing" : "permissive");
             }
         }
     }
@@ -2131,13 +2182,15 @@ cmdDominfo(vshControl *ctl, const vshCmd *cmd)
  * "domjobinfo" command
  */
 static const vshCmdInfo info_domjobinfo[] = {
-    {"help", N_("domain job information")},
-    {"desc", N_("Returns information about jobs running on a domain.")},
+    {"help", N_("virtual machine job information")},
+    {"desc",
+     N_("Returns information about jobs running on a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domjobinfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2214,13 +2267,14 @@ cleanup:
  * "domjobabort" command
  */
 static const vshCmdInfo info_domjobabort[] = {
-    {"help", N_("abort active domain job")},
-    {"desc", N_("Aborts the currently running domain job")},
+    {"help", N_("abort active virtual machine job")},
+    {"desc", N_("Aborts the currently running virtual machine job")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domjobabort[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2291,12 +2345,13 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
  */
 static const vshCmdInfo info_maxvcpus[] = {
     {"help", N_("connection vcpu maximum")},
-    {"desc", N_("Show maximum number of virtual CPUs for guests on this connection.")},
+    {"desc",
+     N_("Show maximum number of virtual CPUs for VM's on this connection.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_maxvcpus[] = {
-    {"type", VSH_OT_STRING, 0, N_("domain type")},
+    {"type", VSH_OT_STRING, 0, N_("virtual machine type")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2323,17 +2378,19 @@ cmdMaxvcpus(vshControl *ctl, const vshCmd *cmd)
  * "vcpucount" command
  */
 static const vshCmdInfo info_vcpucount[] = {
-    {"help", N_("domain vcpu counts")},
-    {"desc", N_("Returns the number of virtual CPUs used by the domain.")},
+    {"help", N_("virtual machine vcpu counts")},
+    {"desc",
+     N_("Returns the number of virtual CPUs used by the virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_vcpucount[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"maximum", VSH_OT_BOOL, 0, N_("get maximum cap on vcpus")},
     {"current", VSH_OT_BOOL, 0, N_("get current vcpu usage")},
     {"config", VSH_OT_BOOL, 0, N_("get value to be used on next boot")},
-    {"live", VSH_OT_BOOL, 0, N_("get value from running domain")},
+    {"live", VSH_OT_BOOL, 0, N_("get value from running virtual machine")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2496,13 +2553,15 @@ cmdVcpucount(vshControl *ctl, const vshCmd *cmd)
  * "vcpuinfo" command
  */
 static const vshCmdInfo info_vcpuinfo[] = {
-    {"help", N_("detailed domain vcpu information")},
-    {"desc", N_("Returns basic information about the domain virtual CPUs.")},
+    {"help", N_("detailed virtual machine vcpu information")},
+    {"desc",
+     N_("Returns basic information about the virtual machine virtual CPUs.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_vcpuinfo[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2567,7 +2626,7 @@ cmdVcpuinfo(vshControl *ctl, const vshCmd *cmd)
     } else {
         if (info.state == VIR_DOMAIN_SHUTOFF) {
             vshError(ctl, "%s",
-                     _("Domain shut off, virtual CPUs not present."));
+                     _("VM shut off, virtual CPUs not present."));
         }
         ret = FALSE;
     }
@@ -2582,13 +2641,14 @@ cmdVcpuinfo(vshControl *ctl, const vshCmd *cmd)
  * "vcpupin" command
  */
 static const vshCmdInfo info_vcpupin[] = {
-    {"help", N_("control domain vcpu affinity")},
-    {"desc", N_("Pin domain VCPUs to host physical CPUs.")},
+    {"help", N_("control virtual machine vcpu affinity")},
+    {"desc", N_("Pin virtual machine VCPUs to host physical CPUs.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_vcpupin[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"vcpu", VSH_OT_INT, VSH_OFLAG_REQ, N_("vcpu number")},
     {"cpulist", VSH_OT_DATA, VSH_OFLAG_REQ, N_("host cpu number(s) (comma separated)")},
     {NULL, 0, 0, NULL}
@@ -2633,7 +2693,8 @@ cmdVcpupin(vshControl *ctl, const vshCmd *cmd)
     }
 
     if (virDomainGetInfo(dom, &info) != 0) {
-        vshError(ctl, "%s", _("vcpupin: failed to get domain informations."));
+        vshError(ctl, "%s",
+                 _("vcpupin: failed to get virtual machine information."));
         virDomainFree(dom);
         return FALSE;
     }
@@ -2719,16 +2780,17 @@ cmdVcpupin(vshControl *ctl, const vshCmd *cmd)
  */
 static const vshCmdInfo info_setvcpus[] = {
     {"help", N_("change number of virtual CPUs")},
-    {"desc", N_("Change the number of virtual CPUs in the guest domain.")},
+    {"desc", N_("Change the number of virtual CPUs in the virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_setvcpus[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {"count", VSH_OT_INT, VSH_OFLAG_REQ, N_("number of virtual CPUs")},
     {"maximum", VSH_OT_BOOL, 0, N_("set maximum limit on next boot")},
     {"config", VSH_OT_BOOL, 0, N_("affect next boot")},
-    {"live", VSH_OT_BOOL, 0, N_("affect running domain")},
+    {"live", VSH_OT_BOOL, 0, N_("affect running virtual machine")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2772,13 +2834,16 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd)
  */
 static const vshCmdInfo info_setmem[] = {
     {"help", N_("change memory allocation")},
-    {"desc", N_("Change the current memory allocation in the guest domain.")},
+    {"desc",
+     N_("Change the current memory allocation in the virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_setmem[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"kilobytes", VSH_OT_INT, VSH_OFLAG_REQ, N_("number of kilobytes of memory")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
+    {"kilobytes", VSH_OT_INT, VSH_OFLAG_REQ,
+                              N_("number of kilobytes of memory")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2811,8 +2876,9 @@ cmdSetmem(vshControl *ctl, const vshCmd *cmd)
 
     if (kilobytes > info.maxMem) {
         virDomainFree(dom);
-        vshError(ctl, _("Requested memory size %lu kb is larger than maximum of %lu kb"),
-                 kilobytes, info.maxMem);
+        vshError(ctl,
+            _("Requested memory size %lu kb is larger than maximum of %lu kb"),
+            kilobytes, info.maxMem);
         return FALSE;
     }
 
@@ -2829,13 +2895,16 @@ cmdSetmem(vshControl *ctl, const vshCmd *cmd)
  */
 static const vshCmdInfo info_setmaxmem[] = {
     {"help", N_("change maximum memory limit")},
-    {"desc", N_("Change the maximum memory allocation limit in the guest domain.")},
+    {"desc",
+     N_("Change the maximum memory allocation limit in the virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_setmaxmem[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"kilobytes", VSH_OT_INT, VSH_OFLAG_REQ, N_("maximum memory limit in kilobytes")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
+    {"kilobytes", VSH_OT_INT, VSH_OFLAG_REQ,
+                              N_("maximum memory limit in kilobytes")},
     {NULL, 0, 0, NULL}
 };
 
@@ -2887,15 +2956,17 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd)
  * "memtune" command
  */
 static const vshCmdInfo info_memtune[] = {
-    {"help", N_("Get/Set memory paramters")},
-    {"desc", N_("Get/Set the current memory paramters for the guest domain.\n" \
-                "    To get the memory parameters use following command: \n\n" \
-                "    virsh # memtune <domain>")},
+    {"help", N_("Get/Set memory parameters")},
+    {"desc",
+     N_("Get/Set the current memory parameters for the virtual machine.\n" \
+     "    To get the memory parameters use following command: \n\n" \
+     "    virsh # memtune <virtual machine>")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_memtune[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
     {"hard-limit", VSH_OT_INT, VSH_OFLAG_NONE,
      N_("Max memory in kilobytes")},
     {"soft-limit", VSH_OT_INT, VSH_OFLAG_NONE,
@@ -3082,7 +3153,7 @@ cmdNodeinfo(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
  */
 static const vshCmdInfo info_capabilities[] = {
     {"help", N_("capabilities")},
-    {"desc", N_("Returns capabilities of hypervisor/driver.")},
+    {"desc", N_("Returns capabilities of the hypervisor/driver.")},
     {NULL, NULL}
 };
 
@@ -3108,16 +3179,21 @@ cmdCapabilities (vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
  * "dumpxml" command
  */
 static const vshCmdInfo info_dumpxml[] = {
-    {"help", N_("domain information in XML")},
-    {"desc", N_("Output the domain information as an XML dump to stdout.")},
+    {"help", N_("virtual machine information in XML")},
+    {"desc",
+     N_("Output the virtual machine information as an XML dump to stdout.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_dumpxml[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"inactive", VSH_OT_BOOL, 0, N_("show inactive defined XML")},
-    {"security-info", VSH_OT_BOOL, 0, N_("include security sensitive information in XML dump")},
-    {"update-cpu", VSH_OT_BOOL, 0, N_("update guest CPU according to host CPU")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"inactive", VSH_OT_BOOL, 0,
+     N_("show inactive defined XML")},
+    {"security-info", VSH_OT_BOOL, 0,
+     N_("include security sensitive information in XML dump")},
+    {"update-cpu", VSH_OT_BOOL, 0,
+     N_("update virtual machine CPU according to host CPU")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3161,14 +3237,17 @@ cmdDumpXML(vshControl *ctl, const vshCmd *cmd)
  * "domxml-from-native" command
  */
 static const vshCmdInfo info_domxmlfromnative[] = {
-    {"help", N_("Convert native config to domain XML")},
-    {"desc", N_("Convert native guest configuration format to domain XML format.")},
+    {"help", N_("Convert native config to virtual machine XML")},
+    {"desc",
+     N_("Convert native virtual machine configuration format to XML.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domxmlfromnative[] = {
-    {"format", VSH_OT_DATA, VSH_OFLAG_REQ, N_("source config data format")},
-    {"config", VSH_OT_DATA, VSH_OFLAG_REQ, N_("config data file to import from")},
+    {"format", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("source config data format")},
+    {"config", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("config data file to import from")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3206,14 +3285,18 @@ cmdDomXMLFromNative(vshControl *ctl, const vshCmd *cmd)
  * "domxml-to-native" command
  */
 static const vshCmdInfo info_domxmltonative[] = {
-    {"help", N_("Convert domain XML to native config")},
-    {"desc", N_("Convert domain XML config to a native guest configuration format.")},
+    {"help",
+     N_("Convert virtual machine XML to native config")},
+    {"desc",
+     N_("Convert VM XML configuration to native VM configuration format.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domxmltonative[] = {
-    {"format", VSH_OT_DATA, VSH_OFLAG_REQ, N_("target config data type format")},
-    {"xml", VSH_OT_DATA, VSH_OFLAG_REQ, N_("xml data file to export from")},
+    {"format", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("target config data type format")},
+    {"xml", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("xml data file to export from")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3251,13 +3334,14 @@ cmdDomXMLToNative(vshControl *ctl, const vshCmd *cmd)
  * "domname" command
  */
 static const vshCmdInfo info_domname[] = {
-    {"help", N_("convert a domain id or UUID to domain name")},
+    {"help",
+     N_("convert a virtual machine id or UUID to virtual machine name")},
     {"desc", ""},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domname[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3281,13 +3365,15 @@ cmdDomname(vshControl *ctl, const vshCmd *cmd)
  * "domid" command
  */
 static const vshCmdInfo info_domid[] = {
-    {"help", N_("convert a domain name or UUID to domain id")},
+    {"help",
+     N_("convert a virtual machine name or UUID to virtual machine id")},
     {"desc", ""},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domid[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3316,13 +3402,14 @@ cmdDomid(vshControl *ctl, const vshCmd *cmd)
  * "domuuid" command
  */
 static const vshCmdInfo info_domuuid[] = {
-    {"help", N_("convert a domain name or id to domain UUID")},
+    {"help",
+     N_("convert a virtual machine name or id to virtual machine UUID")},
     {"desc", ""},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_domuuid[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain id or name")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine id or name")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3341,7 +3428,7 @@ cmdDomuuid(vshControl *ctl, const vshCmd *cmd)
     if (virDomainGetUUIDString(dom, uuid) != -1)
         vshPrint(ctl, "%s\n", uuid);
     else
-        vshError(ctl, "%s", _("failed to get domain UUID"));
+        vshError(ctl, "%s", _("failed to get virtual machine UUID"));
 
     virDomainFree(dom);
     return TRUE;
@@ -3351,25 +3438,39 @@ cmdDomuuid(vshControl *ctl, const vshCmd *cmd)
  * "migrate" command
  */
 static const vshCmdInfo info_migrate[] = {
-    {"help", N_("migrate domain to another host")},
-    {"desc", N_("Migrate domain to another host.  Add --live for live migration.")},
+    {"help", N_("migrate virtual machine to another host")},
+    {"desc",
+     N_("Migrate VM to another host.  Add --live for live migration.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_migrate[] = {
-    {"live", VSH_OT_BOOL, 0, N_("live migration")},
-    {"p2p", VSH_OT_BOOL, 0, N_("peer-2-peer migration")},
-    {"direct", VSH_OT_BOOL, 0, N_("direct migration")},
-    {"tunnelled", VSH_OT_BOOL, 0, N_("tunnelled migration")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist VM on destination")},
-    {"undefinesource", VSH_OT_BOOL, 0, N_("undefine VM on source")},
-    {"suspend", VSH_OT_BOOL, 0, N_("do not restart the domain on the destination host")},
-    {"copy-storage-all", VSH_OT_BOOL, 0, N_("migration with non-shared storage with full disk copy")},
-    {"copy-storage-inc", VSH_OT_BOOL, 0, N_("migration with non-shared storage with incremental copy (same base image shared between source and destination)")},
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"desturi", VSH_OT_DATA, VSH_OFLAG_REQ, N_("connection URI of the destination host")},
-    {"migrateuri", VSH_OT_DATA, 0, N_("migration URI, usually can be omitted")},
-    {"dname", VSH_OT_DATA, 0, N_("rename to new name during migration (if supported)")},
+    {"live", VSH_OT_BOOL, 0,
+     N_("live migration")},
+    {"p2p", VSH_OT_BOOL, 0,
+     N_("peer-2-peer migration")},
+    {"direct", VSH_OT_BOOL, 0,
+     N_("direct migration")},
+    {"tunnelled", VSH_OT_BOOL, 0,
+     N_("tunnelled migration")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist VM on destination")},
+    {"undefinesource", VSH_OT_BOOL, 0,
+     N_("undefine VM on source")},
+    {"suspend", VSH_OT_BOOL, 0,
+     N_("do not restart the VM on the destination host")},
+    {"copy-storage-all", VSH_OT_BOOL, 0,
+     N_("migration with non-shared storage with full disk copy")},
+    {"copy-storage-inc", VSH_OT_BOOL, 0,
+     N_("migration with non-shared storage with incremental copy (same base image shared between source and destination)")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"desturi", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("connection URI of the destination host")},
+    {"migrateuri", VSH_OT_DATA, 0,
+     N_("migration URI, usually can be omitted")},
+    {"dname", VSH_OT_DATA, 0,
+     N_("rename to new name during migration (if supported)")},
     {NULL, 0, 0, NULL}
 };
 
@@ -3454,14 +3555,18 @@ cmdMigrate (vshControl *ctl, const vshCmd *cmd)
  * "migrate-setmaxdowntime" command
  */
 static const vshCmdInfo info_migrate_setmaxdowntime[] = {
-    {"help", N_("set maximum tolerable downtime")},
-    {"desc", N_("Set maximum tolerable downtime of a domain which is being live-migrated to another host.")},
+    {"help",
+     N_("set maximum tolerable downtime")},
+    {"desc",
+     N_("Set maximum tolerable downtime of a VM live-migrating to another host.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_migrate_setmaxdowntime[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"downtime", VSH_OT_INT, VSH_OFLAG_REQ, N_("maximum tolerable downtime (in milliseconds) for migration")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"downtime", VSH_OT_INT, VSH_OFLAG_REQ,
+     N_("maximum tolerable downtime (in milliseconds) for migration")},
     {NULL, 0, 0, NULL}
 };
 
@@ -7765,8 +7870,10 @@ cmdNodeDeviceDumpXML (vshControl *ctl, const vshCmd *cmd)
  * "nodedev-dettach" command
  */
 static const vshCmdInfo info_node_device_dettach[] = {
-    {"help", N_("dettach node device from its device driver")},
-    {"desc", N_("Dettach node device from its device driver before assigning to a domain.")},
+    {"help",
+     N_("detach node device from its device driver")},
+    {"desc",
+     N_("Detach node device from its device driver before assigning to a VM.")},
     {NULL, NULL}
 };
 
@@ -7806,8 +7913,10 @@ cmdNodeDeviceDettach (vshControl *ctl, const vshCmd *cmd)
  * "nodedev-reattach" command
  */
 static const vshCmdInfo info_node_device_reattach[] = {
-    {"help", N_("reattach node device to its device driver")},
-    {"desc", N_("Reattach node device to its device driver once released by the domain.")},
+    {"help",
+     N_("reattach node device to its device driver")},
+    {"desc",
+     N_("Reattach node device to its device driver once released by the VM.")},
     {NULL, NULL}
 };
 
@@ -7847,8 +7956,10 @@ cmdNodeDeviceReAttach (vshControl *ctl, const vshCmd *cmd)
  * "nodedev-reset" command
  */
 static const vshCmdInfo info_node_device_reset[] = {
-    {"help", N_("reset node device")},
-    {"desc", N_("Reset node device before or after assigning to a domain.")},
+    {"help",
+     N_("reset node device")},
+    {"desc",
+     N_("Reset node device before or after assigning to a VM.")},
     {NULL, NULL}
 };
 
@@ -7952,7 +8063,8 @@ static const vshCmdInfo info_vncdisplay[] = {
 };
 
 static const vshCmdOptDef opts_vncdisplay[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+                            N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8027,7 +8139,7 @@ static const vshCmdInfo info_ttyconsole[] = {
 };
 
 static const vshCmdOptDef opts_ttyconsole[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8088,7 +8200,7 @@ static const vshCmdInfo info_attach_device[] = {
 };
 
 static const vshCmdOptDef opts_attach_device[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine name, id or uuid")},
     {"file",   VSH_OT_DATA, VSH_OFLAG_REQ, N_("XML file")},
     {"persistent", VSH_OT_BOOL, 0, N_("persist device attachment")},
     {NULL, 0, 0, NULL}
@@ -8155,9 +8267,12 @@ static const vshCmdInfo info_detach_device[] = {
 };
 
 static const vshCmdOptDef opts_detach_device[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"file",   VSH_OT_DATA, VSH_OFLAG_REQ, N_("XML file")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist device detachment")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"file",   VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("XML file")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist device detachment")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8222,9 +8337,12 @@ static const vshCmdInfo info_update_device[] = {
 };
 
 static const vshCmdOptDef opts_update_device[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"file",   VSH_OT_DATA, VSH_OFLAG_REQ, N_("XML file")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist device update")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"file",   VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("XML file")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist device update")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8289,14 +8407,22 @@ static const vshCmdInfo info_attach_interface[] = {
 };
 
 static const vshCmdOptDef opts_attach_interface[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"type",   VSH_OT_DATA, VSH_OFLAG_REQ, N_("network interface type")},
-    {"source", VSH_OT_DATA, VSH_OFLAG_REQ, N_("source of network interface")},
-    {"target", VSH_OT_DATA, 0, N_("target network name")},
-    {"mac",    VSH_OT_DATA, 0, N_("MAC address")},
-    {"script", VSH_OT_DATA, 0, N_("script used to bridge network interface")},
-    {"model", VSH_OT_DATA, 0, N_("model type")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist interface attachment")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"type",   VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("network interface type")},
+    {"source", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("source of network interface")},
+    {"target", VSH_OT_DATA, 0,
+     N_("target network name")},
+    {"mac",    VSH_OT_DATA, 0,
+     N_("MAC address")},
+    {"script", VSH_OT_DATA, 0,
+     N_("script used to bridge network interface")},
+    {"model", VSH_OT_DATA, 0,
+     N_("model type")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist interface attachment")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8398,10 +8524,14 @@ static const vshCmdInfo info_detach_interface[] = {
 };
 
 static const vshCmdOptDef opts_detach_interface[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"type",   VSH_OT_DATA, VSH_OFLAG_REQ, N_("network interface type")},
-    {"mac",    VSH_OT_STRING, 0, N_("MAC address")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist interface detachment")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"type",   VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("network interface type")},
+    {"mac",    VSH_OT_STRING, 0,
+     N_("MAC address")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist interface detachment")},
     {NULL, 0, 0, NULL}
 };
 
@@ -8531,7 +8661,7 @@ static const vshCmdInfo info_attach_disk[] = {
 };
 
 static const vshCmdOptDef opts_attach_disk[] = {
-    {"domain",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("virtual machine name, id or uuid")},
     {"source",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("source of disk device")},
     {"target",  VSH_OT_DATA, VSH_OFLAG_REQ, N_("target of disk device")},
     {"driver",    VSH_OT_STRING, 0, N_("driver of disk device")},
@@ -8655,9 +8785,12 @@ static const vshCmdInfo info_detach_disk[] = {
 };
 
 static const vshCmdOptDef opts_detach_disk[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"target", VSH_OT_DATA, VSH_OFLAG_REQ, N_("target of disk device")},
-    {"persistent", VSH_OT_BOOL, 0, N_("persist disk detachment")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"target", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("target of disk device")},
+    {"persistent", VSH_OT_BOOL, 0,
+     N_("persist disk detachment")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9223,13 +9356,14 @@ cmdEcho (vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd)
  * "edit" command
  */
 static const vshCmdInfo info_edit[] = {
-    {"help", N_("edit XML configuration for a domain")},
-    {"desc", N_("Edit the XML configuration for a domain.")},
+    {"help", N_("edit XML configuration for a virtual machine")},
+    {"desc", N_("Edit the XML configuration for a virtual machine.")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_edit[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9254,7 +9388,7 @@ cmdEdit (vshControl *ctl, const vshCmd *cmd)
     if (dom == NULL)
         goto cleanup;
 
-    /* Get the XML configuration of the domain. */
+    /* Get the XML configuration of the virtual machine. */
     doc = virDomainGetXMLDesc (dom, flags);
     if (!doc)
         goto cleanup;
@@ -9272,15 +9406,16 @@ cmdEdit (vshControl *ctl, const vshCmd *cmd)
 
     /* Compare original XML with edited.  Has it changed at all? */
     if (STREQ (doc, doc_edited)) {
-        vshPrint (ctl, _("Domain %s XML configuration not changed.\n"),
+        vshPrint (ctl,
+                  _("Virtual machine %s XML configuration not changed.\n"),
                   virDomainGetName (dom));
         ret = TRUE;
         goto cleanup;
     }
 
-    /* Now re-read the domain XML.  Did someone else change it while
+    /* Now re-read the virtual machine XML.  Did someone else change it while
      * it was being edited?  This also catches problems such as us
-     * losing a connection or the domain going away.
+     * losing a connection or the virtual machine going away.
      */
     doc_reread = virDomainGetXMLDesc (dom, flags);
     if (!doc_reread)
@@ -9288,17 +9423,18 @@ cmdEdit (vshControl *ctl, const vshCmd *cmd)
 
     if (STRNEQ (doc, doc_reread)) {
         vshError(ctl,
-                 "%s", _("ERROR: the XML configuration was changed by another user"));
+                 "%s",
+                 _("ERROR: the XML configuration was changed by another user"));
         goto cleanup;
     }
 
-    /* Everything checks out, so redefine the domain. */
+    /* Everything checks out, so redefine the virtual machine. */
     virDomainFree (dom);
     dom = virDomainDefineXML (ctl->conn, doc_edited);
     if (!dom)
         goto cleanup;
 
-    vshPrint (ctl, _("Domain %s XML configuration edited.\n"),
+    vshPrint (ctl, _("Virtual machine %s XML configuration edited.\n"),
               virDomainGetName(dom));
 
     ret = TRUE;
@@ -9379,8 +9515,10 @@ static const vshCmdInfo info_snapshot_create[] = {
 };
 
 static const vshCmdOptDef opts_snapshot_create[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"xmlfile", VSH_OT_DATA, 0, N_("domain snapshot XML")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"xmlfile", VSH_OT_DATA, 0,
+     N_("virtual machine snapshot XML")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9442,11 +9580,11 @@ cmdSnapshotCreate(vshControl *ctl, const vshCmd *cmd)
     name = virXPathString("string(/domainsnapshot/name)", ctxt);
     if (!name) {
         vshError(ctl, "%s",
-                 _("Could not find 'name' element in domain snapshot XML"));
+                 _("Could not find 'name' element in VM snapshot XML"));
         goto cleanup;
     }
 
-    vshPrint(ctl, _("Domain snapshot %s created"), name);
+    vshPrint(ctl, _("Virtual machine snapshot %s created"), name);
     if (from)
         vshPrint(ctl, _(" from '%s'"), from);
     vshPrint(ctl, "\n");
@@ -9478,7 +9616,8 @@ static const vshCmdInfo info_snapshot_current[] = {
 };
 
 static const vshCmdOptDef opts_snapshot_current[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9529,13 +9668,14 @@ cleanup:
  * "snapshot-list" command
  */
 static const vshCmdInfo info_snapshot_list[] = {
-    {"help", N_("List snapshots for a domain")},
+    {"help", N_("List snapshots for a virtual machine")},
     {"desc", N_("Snapshot List")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_snapshot_list[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9646,14 +9786,16 @@ cleanup:
  * "snapshot-dumpxml" command
  */
 static const vshCmdInfo info_snapshot_dumpxml[] = {
-    {"help", N_("Dump XML for a domain snapshot")},
+    {"help", N_("Dump XML for a virtual machine snapshot")},
     {"desc", N_("Snapshot Dump XML")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_snapshot_dumpxml[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ, N_("snapshot name")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("snapshot name")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9703,14 +9845,16 @@ cleanup:
  * "snapshot-revert" command
  */
 static const vshCmdInfo info_snapshot_revert[] = {
-    {"help", N_("Revert a domain to a snapshot")},
-    {"desc", N_("Revert domain to snapshot")},
+    {"help", N_("Revert a virtual machine to a snapshot")},
+    {"desc", N_("Revert virtual machine to snapshot")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_snapshot_revert[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ, N_("snapshot name")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("snapshot name")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9755,15 +9899,18 @@ cleanup:
  * "snapshot-delete" command
  */
 static const vshCmdInfo info_snapshot_delete[] = {
-    {"help", N_("Delete a domain snapshot")},
+    {"help", N_("Delete a virtual machine snapshot")},
     {"desc", N_("Snapshot Delete")},
     {NULL, NULL}
 };
 
 static const vshCmdOptDef opts_snapshot_delete[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ, N_("snapshot name")},
-    {"children", VSH_OT_BOOL, 0, N_("delete snapshot and all children")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"snapshotname", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("snapshot name")},
+    {"children", VSH_OT_BOOL, 0,
+     N_("delete snapshot and all children")},
     {NULL, 0, 0, NULL}
 };
 
@@ -9818,8 +9965,10 @@ static const vshCmdInfo info_qemu_monitor_command[] = {
 };
 
 static const vshCmdOptDef opts_qemu_monitor_command[] = {
-    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, N_("domain name, id or uuid")},
-    {"cmd", VSH_OT_DATA, VSH_OFLAG_REQ, N_("command")},
+    {"domain", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("virtual machine name, id or uuid")},
+    {"cmd", VSH_OT_DATA, VSH_OFLAG_REQ,
+     N_("command")},
     {NULL, 0, 0, NULL}
 };
 
@@ -10423,26 +10572,26 @@ vshCommandOptDomainBy(vshControl *ctl, const vshCmd *cmd,
     /* try it by ID */
     if (flag & VSH_BYID) {
         if (virStrToLong_i(n, NULL, 10, &id) == 0 && id >= 0) {
-            vshDebug(ctl, 5, "%s: <%s> seems like domain ID\n",
+            vshDebug(ctl, 5, "%s: <%s> seems like virtual machine ID\n",
                      cmd->def->name, optname);
             dom = virDomainLookupByID(ctl->conn, id);
         }
     }
     /* try it by UUID */
     if (dom==NULL && (flag & VSH_BYUUID) && strlen(n)==VIR_UUID_STRING_BUFLEN-1) {
-        vshDebug(ctl, 5, "%s: <%s> trying as domain UUID\n",
+        vshDebug(ctl, 5, "%s: <%s> trying as virtual machine UUID\n",
                  cmd->def->name, optname);
         dom = virDomainLookupByUUIDString(ctl->conn, n);
     }
     /* try it by NAME */
     if (dom==NULL && (flag & VSH_BYNAME)) {
-        vshDebug(ctl, 5, "%s: <%s> trying as domain NAME\n",
+        vshDebug(ctl, 5, "%s: <%s> trying as virtual machine NAME\n",
                  cmd->def->name, optname);
         dom = virDomainLookupByName(ctl->conn, n);
     }
 
     if (!dom)
-        vshError(ctl, _("failed to get domain '%s'"), n);
+        vshError(ctl, _("failed to get virtual machine '%s'"), n);
 
     return dom;
 }
diff --git a/tools/virsh.pod b/tools/virsh.pod
index ec57f2b..de3489a 100644
--- a/tools/virsh.pod
+++ b/tools/virsh.pod
@@ -10,29 +10,28 @@ B<virsh> [I<OPTION>]... I<COMMAND> [I<ARG>]...
 
 =head1 DESCRIPTION
 
-The B<virsh> program is the main interface for managing virsh guest
-domains. The program can be used to create, pause, and shutdown
-domains. It can also be used to list current domains. Libvirt is a C
-toolkit to interact with the virtualization capabilities of recent
-versions of Linux (and other OSes). It is free software available
-under the GNU Lesser General Public License. Virtualization of the
-Linux Operating System means the ability to run multiple instances of
-Operating Systems concurrently on a single hardware system where the
-basic resources are driven by a Linux instance. The library aims at
-providing a long term stable C API.  It currently supports Xen, QEmu,
-KVM, LXC, OpenVZ, VirtualBox, OpenNebula, and VMware ESX.
+The B<virsh> program is the main interface for managing libvirt virtual
+machines. The program can be used to create, pause, and shutdown virtual
+machines. It can also be used to list running virtual machines. Libvirt is
+a C library and toolkit to interact with the virtualization capabilities of
+Linux and other platforms. It is free software available under the GNU Lesser
+General Public License. Virtualization of the Linux Operating System means
+the ability to run multiple instances of Operating Systems concurrently on a
+single hardware system where the basic resources are driven by a Linux
+instance. The library aims at providing a long term stable C API.  It
+currently supports Xen, QEmu, KVM, LXC, OpenVZ, VirtualBox, OpenNebula,
+and VMware ESX.
 
 The basic structure of most virsh usage is:
 
-  virsh [OPTION]... <command> <domain-id> [ARG]...
+  virsh [OPTION]... <command> <virtual-machine-id> [ARGS]...
 
-Where I<command> is one of the commands listed below, I<domain-id>
-is the numeric domain id, or the domain name (which will be internally
-translated to domain id), and I<ARGS> are command specific
-options.  There are a few exceptions to this rule in the cases where
-the command in question acts on all domains, the entire machine,
-or directly on the xen hypervisor.  Those exceptions will be clear for
-each of those commands.
+Where I<command> is one of the commands listed below, I<virtual-machine-id>
+is the running numeric virtual machine id, or the VM name (which is internally
+translated to its id), and I<ARGS> are command specific options.  There are
+a few exceptions to this rule in the cases where a command acts on all
+virtual machines, the host machine, or directly on the hypervisor.  These
+exceptions are clearly indicated for each command.
 
 The B<virsh> program can be used either to run one I<COMMAND> by giving the
 command and its arguments on the shell command line, or a I<COMMAND_STRING>
@@ -101,12 +100,12 @@ non root will return an error.
 Most B<virsh> commands act synchronously, except maybe shutdown,
 setvcpus and setmem. In those cases the fact that the B<virsh>
 program returned, may not mean the action is complete and you
-must poll periodically to detect that the guest completed the
+must poll periodically to detect that the virtual machine completed the
 operation.
 
 =head1 GENERIC COMMANDS
 
-The following commands are generic i.e. not specific to a domain.
+The following commands are generic i.e. not specific to a virtual machine.
 
 =over 4
 
@@ -168,11 +167,13 @@ this is used to connect to the local Xen hypervisor, this is the default
 
 =item qemu:///system
 
-connect locally as root to the daemon supervising QEmu and KVM domains
+connect locally as root to the daemon supervising QEmu and KVM virtual
+machines
 
 =item qemu:///session
 
-connect locally as a normal user to his own set of QEmu and KVM domains
+connect locally as a normal user to their own set of QEmu and KVM virtual
+machines
 
 =item lxc:///
 
@@ -201,15 +202,15 @@ and size of the physical memory.
 Print an XML document describing the capabilities of the hypervisor
 we are currently connected to. This includes a section on the host
 capabilities in terms of CPU and features, and a set of description
-for each kind of guest which can be virtualized. For a more complete
-description see:
-  L<http://libvirt.org/formatcaps.html>
+for each kind of virtual machine which can be virtualized. For a more
+complete description see: L<http://libvirt.org/formatcaps.html>
 The XML also show the NUMA topology information if available.
 
 =item B<list> optional I<--inactive> I<--all>
 
-Prints information about one or more domains.  If no domains are
-specified it prints out information about running domains.
+Prints information about one or more virtual machines.  If no virtual
+machines are specified it prints out information about running virtual
+machines.
 
 An example format for the list is as follows:
 
@@ -218,57 +219,57 @@ B<virsh> list
 
 ----------------------------------
 
-  0 Domain-0             running
+  0 rhel-6               running
   2 fedora               paused
 
 
-Name is the name of the domain.  ID the domain numeric id.
+Name is the name of the virtual machine.  ID the virtual machine numeric id.
 State is the run state (see below).
 
 B<STATES>
 
-The State field lists 7 states for a domain, and which ones the
-current domain is in.
+The State field lists 7 states for a virtual machine, and which ones the
+current virtual machine is in.
 
 =over 4
 
 =item B<running>
 
-The domain is currently running on a CPU
+The virtual machine is currently running on a CPU
 
 =item B<idle>
 
-The domain is idle, and not running or runnable.  This can be caused
-because the domain is waiting on IO (a traditional wait state) or has
-gone to sleep because there was nothing else for it to do.
+The virtual machine is idle, and not running or runnable.  This can be caused
+because the virtual machine is waiting on IO (a traditional wait state) or
+has gone to sleep because there was nothing else for it to do.
 
 =item B<paused>
 
-The domain has been paused, usually occurring through the administrator
-running B<virsh suspend>.  When in a paused state the domain will still
-consume allocated resources like memory, but will not be eligible for
-scheduling by the hypervisor.
+The virtual machine has been paused, usually occurring through an
+administrator running B<virsh suspend>.  When in a paused state the virtual
+machine will still consume allocated resources like memory, but will not be
+eligible for scheduling by the hypervisor.
 
 =item B<shutdown>
 
-The domain is in the process of shutting down, i.e. the guest operating system
-has been notified and should be in the process of stopping its operations
-gracefully.
+The virtual machine is in the process of shutting down, i.e. the virtual
+machine operating system has been notified and should be in the process of
+stopping its operations gracefully.
 
 =item B<shut off>
 
-The domain is not running.  Usually this indicates the domain has been
-shut down completely, or has not been started.
+The virtual machine is not running.  Usually this indicates the virtual
+machine has been shut down completely, or has not been started.
 
 =item B<crashed>
 
-The domain has crashed, which is always a violent ending.  Usually
-this state can only occur if the domain has been configured not to
+The virtual machine has crashed, which is always a violent ending.  Usually
+this state can only occur if the virtual machine has been configured not to
 restart on crash.
 
 =item B<dying>
 
-The domain is in process of dying, but hasn't completely shutdown or
+The virtual machine is in process of dying, but hasn't completely shutdown or
 crashed.
 
 =back
@@ -280,134 +281,137 @@ NUMA cell if I<cellno> is provided.
 
 =item B<cpu-baseline> I<FILE>
 
-Compute baseline CPU which will be supported by all host CPUs given in <file>.
-The list of host CPUs is built by extracting all <cpu> elements from the
-<file>. Thus, the <file> can contain either a set of <cpu> elements separated
-by new lines or even a set of complete <capabilities> elements printed by
-B<capabilities> command.
+Compute baseline CPU which will be supported by all host CPUs given in
+<file>. The list of host CPUs is built by extracting all <cpu> elements from
+the <file>. Thus, the <file> can contain either a set of <cpu> elements
+separated by new lines or even a set of complete <capabilities> elements
+printed by B<capabilities> command.
 
 =item B<cpu-compare> I<FILE>
 
 Compare CPU definition from XML <file> with host CPU. The XML <file> may
-contain either host or guest CPU definition. The host CPU definition is the
+contain either a host or VM CPU definition. The host CPU definition is the
 <cpu> element and its contents as printed by B<capabilities> command. The
-guest CPU definition is the <cpu> element and its contents from domain XML
-definition. For more information on guest CPU definition see:
-L<http://libvirt.org/formatdomain.html#elementsCPU>
+VM CPU definition is the <cpu> element and its contents from a virtual
+machine XML definition. For more information on virtual machine CPU
+definitions see: L<http://libvirt.org/formatdomain.html#elementsCPU>
 
 =back
 
-=head1 DOMAIN COMMANDS
+=head1 VIRTUAL MACHINE COMMANDS
 
-The following commands manipulate domains directly, as stated
-previously most commands take domain-id as the first parameter. The
-I<domain-id> can be specified as an short integer, a name or a full UUID.
+The following commands manipulate virtual machines directly, as stated
+previously most commands take a virtual machine identifier as the first
+parameter. The I<virtual-machine-id> can be specified as an short integer,
+a name or a full UUID.
 
 =over 4
 
-=item B<autostart> optional I<--disable> I<domain-id>
+=item B<autostart> optional I<--disable> I<virtual-machine-id>
 
-Configure a domain to be automatically started at boot.
+Configure a virtual machine to be automatically started at boot.
 
 The option I<--disable> disables autostarting.
 
-=item B<console> I<domain-id>
+=item B<console> I<virtual-machine-id>
 
-Connect the virtual serial console for the guest.
+Connect the virtual serial console for the virtual machine.
 
 =item B<create> I<FILE> optional I<--console> I<--paused>
 
-Create a domain from an XML <file>. An easy way to create the XML
+Create a virtual machine from an XML <file>. An easy way to create the XML
 <file> is to use the B<dumpxml> command to obtain the definition of a
-pre-existing guest.  The domain will be paused if the I<--paused> option
-is used and supported by the driver; otherwise it will be running.
-If I<--console> is requested, attach to the console after creation.
+pre-existing virtual machine.  The virtual machine will be paused if the
+I<--paused> option is used and supported by the driver; otherwise it will be
+running.  If I<--console> is requested, attach to the console after creation.
 
 B<Example>
 
- virsh dumpxml <domain-id> > domain.xml
- edit domain.xml
- virsh create < domain.xml
+ virsh dumpxml <virtual-machine-id> > virtual_machine.xml
+ edit virtual_machine.xml
+ virsh create < virtual_machine.xml
 
 =item B<define> I<FILE>
 
-Define a domain from an XML <file>. The domain definition is registered
-but not started.
+Define a virtual machine, using the configuration in the given XML <file>.
+The virtual machine definition is added to the libvirt configuration, but the
+virtual machine is not started.
 
-=item B<destroy> I<domain-id>
+=item B<destroy> I<virtual-machine-id>
 
-Immediately terminate the domain domain-id.  This doesn't give the domain
-OS any chance to react, and it's the equivalent of ripping the power
+Immediately terminate the virtual machine.  This doesn't give the virtual
+machine OS any chance to react, and it's the equivalent of ripping the power
 cord out on a physical machine.  In most cases you will want to use
 the B<shutdown> command instead.
 
-=item B<domblkstat> I<domain> I<block-device>
+=item B<domblkstat> I<virtual-machine> I<block-device>
 
-Get device block stats for a running domain.
+Get device block stats for a running virtual machine.
 
-=item B<domifstat> I<domain> I<interface-device>
+=item B<domifstat> I<virtual-machine> I<interface-device>
 
-Get network interface stats for a running domain.
+Get network interface stats for a running virtual machine.
 
-=item B<dommemstat> I<domain>
+=item B<dommemstat> I<virtual-machine>
 
-Get memory stats for a running domain.
+Get memory stats for a running virtual machine.
 
-=item B<domblkinfo> I<domain> I<block-device>
+=item B<domblkinfo> I<virtual-machine> I<block-device>
 
-Get block device size info for a domain.
+Get block device size info for a virtual machine.
 
-=item B<dominfo> I<domain-id>
+=item B<dominfo> I<virtual-machine-id>
 
-Returns basic information about the domain.
+Returns basic information about the virtual machine.
 
-=item B<domuuid> I<domain-name-or-id>
+=item B<domuuid> I<virtual-machine-name-or-id>
 
-Convert a domain name or id to domain UUID
+Convert a virtual machine name or id to virtual machine UUID
 
-=item B<domid> I<domain-name-or-uuid>
+=item B<domid> I<virtual-machine-name-or-uuid>
 
-Convert a domain name (or UUID) to a domain id
+Convert a virtual machine name (or UUID) to a virtual machine id
 
-=item B<domjobabort> I<domain-id-or-uuid>
+=item B<domjobabort> I<virtual-machine-id-or-uuid>
 
-Abort the currently running domain job.
+Abort the currently running virtual machine job.
 
-=item B<domjobinfo> I<domain-id-or-uuid>
+=item B<domjobinfo> I<virtual-machine-id-or-uuid>
 
-Returns information about jobs running on a domain.
+Returns information about jobs running on a virtual machine.
 
-=item B<domname> I<domain-id-or-uuid>
+=item B<domname> I<virtual-machine-id-or-uuid>
 
-Convert a domain Id (or UUID) to domain name
+Convert a virtual machine Id (or UUID) to virtual machine name
 
-=item B<domstate> I<domain-id>
+=item B<domstate> I<virtual-machine-id>
 
-Returns state about a running domain.
+Returns state about a running virtual machine.
 
 =item B<domxml-from-native> I<format> I<config>
 
-Convert the file I<config> in the native guest configuration format
-named by I<format> to a domain XML format.
+Convert the file I<config> in the native virtual machine configuration format
+named by I<format> to a virtual machine XML format.
 
 =item B<domxml-to-native> I<format> I<xml>
 
-Convert the file I<xml> in domain XML format to the native guest
-configuration format named by I<format>.
+Convert the file I<xml> in virtual machine XML format to the native virtual
+machine configuration format named by I<format>.
 
-=item B<dump> I<domain-id> I<corefilepath>
+=item B<dump> I<virtual-machine-id> I<corefilepath>
 
-Dumps the core of a domain to a file for analysis.
+Dumps the core of a virtual machine to a file for analysis.
 
-=item B<dumpxml> I<domain-id> optional I<--inactive> I<--security-info> I<--update-cpu>
+=item B<dumpxml> I<virtual-machine-id> optional I<--inactive>
+I<--security-info> I<--update-cpu>
 
-Output the domain information as an XML dump to stdout, this format can be used
-by the B<create> command. Additional options affecting the XML dump may be
-used. I<--inactive> tells virsh to dump domain configuration that will be used
-on next start of the domain as opposed to the current domain configuration.
-Using I<--security-info> security sensitive information will also be included
-in the XML dump. I<--update-cpu> updates domain CPU requirements according to
-host CPU.
+Output the virtual machine information as an XML dump to stdout, this format
+can be used by the B<create> command. Additional options affecting the XML
+dump may be used. I<--inactive> tells virsh to dump virtual machine
+configuration that will be used on next start of the VM, as opposed to the
+current VM configuration.  Using I<--security-info> includes security
+sensitive information in the XML dump. I<--update-cpu> updates virtual
+machine CPU requirements according to host CPU.
 
 =item B<echo> optional I<--shell> I<--xml> I<arg>...
 
@@ -416,82 +420,87 @@ specified, then the output will be single-quoted where needed, so that
 it is suitable for reuse in a shell context.  If I<--xml> is
 specified, then the output will be escaped for use in XML.
 
-=item B<edit> I<domain-id>
+=item B<edit> I<virtual-machine-id>
 
-Edit the XML configuration file for a domain.
+Edit the XML configuration file for a virtual machine.
 
 This is equivalent to:
 
- virsh dumpxml domain > domain.xml
- edit domain.xml
- virsh define domain.xml
+ virsh dumpxml <virtual-machine-id> > virtual_machine.xml
+ edit virtual_machine.xml
+ virsh create < virtual_machine.xml
 
 except that it does some error checking.
 
 The editor used can be supplied by the C<$VISUAL> or C<$EDITOR> environment
 variables, and defaults to C<vi>.
 
-=item B<managedsave> I<domain-id>
+=item B<managedsave> I<virtual-machine-id>
 
-Save and destroy a running domain, so it can be restarted from the same
-state at a later time.  When the virsh B<start> command is next run for
-the domain, it will automatically be started from this saved state.
+Save and destroy a running virtual machine, so it can be restarted from the
+same state at a later time.  When the virsh B<start> command is next run for
+the virtual machine, it will automatically be started from this saved state.
 
-=item B<managedsave-remove> I<domain-id>
+=item B<managedsave-remove> I<virtual-machine-id>
 
-Remove the B<managedsave> state file for a domain, if it exists.  This
-ensures the domain will do a full boot the next time it is started.
+Remove the B<managedsave> state file for a virtual machine, if it exists.
+This ensures the virtual machine will do a full boot the next time it is
+started.
 
 =item B<maxvcpus> optional I<type>
 
-Provide the maximum number of virtual CPUs supported for a guest VM on
+Provide the maximum number of virtual CPUs supported for a virtual machine on
 this connection.  If provided, the I<type> parameter must be a valid
-type attribute for the <domain> element of XML.
+type attribute for the <virtual-machine> element of XML.
 
-=item B<migrate> optional I<--live> I<--suspend> I<domain-id> I<desturi>
-I<migrateuri>
+=item B<migrate> optional I<--live> I<--suspend> I<virtual-machine-id>
+I<desturi> I<migrateuri>
 
-Migrate domain to another host.  Add --live for live migration; --suspend
-leaves the domain paused on the destination host. The I<desturi> is the
-connection URI of the destination host, and I<migrateuri> is the
-migration URI, which usually can be omitted.
+Migrate virtual machine to another host.  Add --live for live migration;
+--suspend leaves the virtual machine paused on the destination host. The
+I<desturi> is the connection URI of the destination host, and I<migrateuri>
+is the migration URI, which usually can be omitted.
 
-=item B<migrate-setmaxdowntime> I<domain-id> I<downtime>
+=item B<migrate-setmaxdowntime> I<virtual-machine-id> I<downtime>
 
-Set maximum tolerable downtime for a domain which is being live-migrated to
-another host.  The I<downtime> is a number of milliseconds the guest is allowed
-to be down at the end of live migration.
+Set maximum tolerable downtime for a virtual machine which is being
+live-migrated to another host.  The I<downtime> is a number of milliseconds
+the virtual machine is allowed to be down at the end of live migration.
 
-=item B<reboot> I<domain-id>
+=item B<reboot> I<virtual-machine-id>
 
-Reboot a domain.  This acts just as if the domain had the B<reboot>
-command run from the console.  The command returns as soon as it has
-executed the reboot action, which may be significantly before the
-domain actually reboots.
+Reboot a virtual machine.  This acts just as if the virtual machine had the
+B<reboot> command run from the console.  The command returns as soon as it
+has executed the reboot action, which may be significantly before the virtual
+machine actually reboots.
 
-The exact behavior of a domain when it reboots is set by the
-I<on_reboot> parameter in the domain's XML definition.
+The exact behavior of a virtual machine when it reboots is set by the
+I<on_reboot> parameter in the virtual machine's XML definition.
 
 =item B<restore> I<state-file>
 
-Restores a domain from an B<virsh save> state file.  See I<save> for more info.
+Restores a virtual machine from an B<virsh save> state file.  See I<save> for
+more info.
 
-=item B<save> I<domain-id> I<state-file>
+=item B<save> I<virtual-machine-id> I<state-file>
 
-Saves a running domain to a state file so that it can be restored
-later.  Once saved, the domain will no longer be running on the
-system, thus the memory allocated for the domain will be free for
-other domains to use.  B<virsh restore> restores from this state file.
+Saves a running virtual machine to a state file so that it can be restored
+later.  Once saved, the virtual machine will no longer be running on the
+system, thus the memory allocated for the virtual machine will be free for
+other virtual machines to use.  B<virsh restore> restores from this state
+file.
 
 This is roughly equivalent to doing a hibernate on a running computer,
 with all the same limitations.  Open network connections may be
 severed upon restore, as TCP timeouts may have expired.
 
-=item B<schedinfo> optional I<--set> B<parameter=value> I<domain-id>
+=item B<schedinfo> optional I<--set> B<parameter=value> I<virtual-machine-id>
 
-=item B<schedinfo> optional I<--weight> B<number> optional I<--cap> B<number> I<domain-id>
+=item B<schedinfo> optional I<--weight> B<number> optional I<--cap> B<number>
+I<virtual-machine-id>
 
-Allows you to show (and set) the domain scheduler parameters. The parameters available for each hypervisor are:
+Allows you to show (and set) the virtual machine scheduler parameters. The
+parameters available for each hypervisor are:
 
 LXC, QEMU/KVM (posix scheduler): cpu_shares
 
@@ -504,116 +513,118 @@ B<Note>: The cpu_shares parameter has a valid value range of 0-262144.
 B<Note>: The weight and cap parameters are defined only for the
 XEN_CREDIT scheduler and are now I<DEPRECATED>.
 
-=item B<setmem> I<domain-id> B<kilobytes>
+=item B<setmem> I<virtual-machine-id> B<kilobytes>
 
-Change the current memory allocation in the guest domain. This should take
+Change the current memory allocation in the virtual machine. This should take
 effect immediately. The memory limit is specified in
 kilobytes.
 
-For Xen, you can only adjust the memory of a running domain if the
-domain is paravirtualized or running the PV balloon driver.
+For Xen, you can only adjust the memory of a running virtual machine if the
+virtual machine is paravirtualized or running the PV balloon driver.
 
-=item B<setmaxmem> I<domain-id> B<kilobytes>
+=item B<setmaxmem> I<virtual-machine-id> B<kilobytes>
 
-Change the maximum memory allocation limit in the guest domain. This should
-not change the current memory use. The memory limit is specified in
+Change the maximum memory allocation limit in the virtual machine. This
+should not change the current memory use. The memory limit is specified in
 kilobytes.
 
-=item B<memtune> I<domain-id> optional I<--hard-limit> B<kilobytes>
+=item B<memtune> I<virtual-machine-id> optional I<--hard-limit> B<kilobytes>
 optional I<--soft-limit> B<kilobytes> optional I<--swap-hard-limit>
 B<kilobytes> -I<--min-guarantee> B<kilobytes>
 
-Allows you to display or set the domain memory parameters. Without
+Allows you to display or set the virtual machine memory parameters. Without
 flags, the current settings are displayed; with a flag, the
 appropriate limit is adjusted if supported by the hypervisor.  LXC and
-QEMU/KVM supports I<--hard-limit>, I<--soft-limit>, and I<--swap-hard-limit>.
+QEMU/KVM supports I<--hard-limit>, I<--soft-limit>, and
+I<--swap-hard-limit>.
 
-=item B<setvcpus> I<domain-id> I<count> optional I<--maximum> I<--config>
-I<--live>
+=item B<setvcpus> I<virtual-machine-id> I<count> optional I<--maximum>
+I<--config> I<--live>
 
-Change the number of virtual CPUs active in the guest domain. Note that
+Change the number of virtual CPUs active in the virtual machine. Note that
 I<count> may be limited by host, hypervisor or limit coming from the
-original description of domain.
+original description of virtual machine.
 
-For Xen, you can only adjust the virtual CPUs of a running domain if
-the domain is paravirtualized.
+For Xen, you can only adjust the virtual CPUs of a running virtual machine
+if the virtual machine is paravirtualized.
 
 If I<--config> is specified, the change will only affect the next
-boot of a domain.  If I<--live> is specified, the domain must be
-running, and the change takes place immediately.  Both flags may be
-specified, if supported by the hypervisor.  If neither flag is given,
-then I<--live> is implied and it is up to the hypervisor whether
-I<--config> is also implied.
+boot of a virtual machine.  If I<--live> is specified, the virtual machine
+must be running, and the change takes place immediately.  Both flags may be
+specified, if supported by the hypervisor.  If neither flag is given, then
+I<--live> is implied and it is up to the hypervisor whether I<--config> is
+also implied.
 
 If I<--maximum> is specified, then you must use I<--config> and
 avoid I<--live>; this flag controls the maximum limit of vcpus that
-can be hot-plugged the next time the domain is booted.
+can be hot-plugged the next time the virtual machine is booted.
 
-=item B<shutdown> I<domain-id>
+=item B<shutdown> I<virtual-machine-id>
 
-Gracefully shuts down a domain.  This coordinates with the domain OS
-to perform graceful shutdown, so there is no guarantee that it will
-succeed, and may take a variable length of time depending on what
-services must be shutdown in the domain.
+Gracefully shuts down a virtual machine.  This coordinates with the virtual
+machine OS to perform graceful shutdown, so there is no guarantee that it
+will succeed, and may take a variable length of time depending on what
+services must be shutdown in the virtual machine.
 
-The exact behavior of a domain when it shuts down is set by the
-I<on_shutdown> parameter in the domain's XML definition.
+The exact behavior of a virtual machine when it shuts down is set by the
+I<on_shutdown> parameter in the virtual machine's XML definition.
 
-=item B<start> I<domain-name> optional I<--console> I<--paused>
+=item B<start> I<virtual-machine-name> optional I<--console> I<--paused>
 
-Start a (previously defined) inactive domain, either from the last
+Start a (previously defined) inactive virtual machine, either from the last
 B<managedsave> state, or via a fresh boot if no managedsave state is
-present.  The domain will be paused if the I<--paused> option is
+present.  The virtual machine will be paused if the I<--paused> option is
 used and supported by the driver; otherwise it will be running.
 If I<--console> is requested, attach to the console after creation.
 
-=item B<suspend> I<domain-id>
+=item B<suspend> I<virtual-machine-id>
 
-Suspend a running domain. It is kept in memory but won't be scheduled
-anymore.
+Suspend a running virtual machine. It is kept in memory but won't be
+scheduled anymore.
 
-=item B<resume> I<domain-id>
+=item B<resume> I<virtual-machine-id>
 
-Moves a domain out of the suspended state.  This will allow a previously
-suspended domain to now be eligible for scheduling by the underlying
-hypervisor.
+Moves a virtual machine out of the suspended state.  This will allow a
+previously suspended virtual machine to now be eligible for scheduling by the
+underlying hypervisor.
 
-=item B<ttyconsole> I<domain-id>
+=item B<ttyconsole> I<virtual-machine-id>
 
-Output the device used for the TTY console of the domain. If the information
-is not available the processes will provide an exit code of 1.
+Output the device used for the TTY console of the virtual machine. If the
+information is not available the processes will provide an exit code of 1.
 
-=item B<undefine> I<domain-id>
+=item B<undefine> I<virtual-machine-id>
 
-Undefine the configuration for an inactive domain. Since it's not running
-the domain name or UUID must be used as the I<domain-id>.
+Undefine the configuration for an inactive virtual machine. Since it's not
+running the virtual machine name or UUID must be used as the
+I<virtual-machine-id>.
 
-=item B<vcpucount> I<domain-id>  optional I<--maximum> I<--current>
+=item B<vcpucount> I<virtual-machine-id>  optional I<--maximum> I<--current>
 I<--config> I<--live>
 
 Print information about the virtual cpu counts of the given
-I<domain-id>.  If no flags are specified, all possible counts are
+I<virtual-machine-id>.  If no flags are specified, all possible counts are
 listed in a table; otherwise, the output is limited to just the
 numeric value requested.
 
 I<--maximum> requests information on the maximum cap of vcpus that a
-domain can add via B<setvcpus>, while I<--current> shows the current
+virtual machine can add via B<setvcpus>, while I<--current> shows the current
 usage; these two flags cannot both be specified.  I<--config>
-requests information regarding the next time the domain will be
-booted, while I<--live> requires a running domain and lists current
+requests information regarding the next time the virtual machine will be
+booted, while I<--live> requires a running virtual machine and lists current
 values; these two flags cannot both be specified.
 
-=item B<vcpuinfo> I<domain-id>
+=item B<vcpuinfo> I<virtual-machine-id>
 
-Returns basic information about the domain virtual CPUs, like the number of
-vCPUs, the running time, the affinity to physical processors.
+Returns basic information about the virtual machine virtual CPUs, like the
+number of vCPUs, the running time, the affinity to physical processors.
 
-=item B<vcpupin> I<domain-id> I<vcpu> I<cpulist>
+=item B<vcpupin> I<virtual-machine-id> I<vcpu> I<cpulist>
 
-Pin domain VCPUs to host physical CPUs. The I<vcpu> number must be provided
-and I<cpulist> is a comma separated list of physical CPU numbers.
+Pin virtual machine VCPUs to host physical CPUs. The I<vcpu> number must be
+provided and I<cpulist> is a comma separated list of physical CPU numbers.
 
-=item B<vncdisplay> I<domain-id>
+=item B<vncdisplay> I<virtual-machine-id>
 
 Output the IP address and port number for the VNC display. If the information
 is not available the processes will provide an exit code of 1.
@@ -622,24 +633,25 @@ is not available the processes will provide an exit code of 1.
 
 =head1 DEVICE COMMANDS
 
-The following commands manipulate devices associated to domains.
-The domain-id can be specified as an short integer, a name or a full UUID.
-To better understand the values allowed as options for the command
-reading the documentation at L<http://libvirt.org/formatdomain.html> on the
-format of the device sections to get the most accurate set of accepted values.
+The following commands manipulate devices associated to virtual machines.
+The virtual machine id can be specified as an short integer, a name or a full
+UUID. To better understand the values allowed as options for the command read
+the documentation at L<http://libvirt.org/formatdomain.html> on the format of
+the device sections to get the most accurate set of accepted values.
 
 =over 4
 
-=item B<attach-device> I<domain-id> I<FILE>
+=item B<attach-device> I<virtual-machine-id> I<FILE>
 
-Attach a device to the domain, using a device definition in an XML file.
-See the documentation to learn about libvirt XML format for a device.
+Attach a device to the virtual machine, using a device definition in an XML
+file. See the documentation to learn about libvirt XML format for a device.
 For cdrom and floppy devices, this command only replaces the media within
 the single existing device; consider using B<update-device> for this usage.
 
-=item B<attach-disk> I<domain-id> I<source> I<target> optional I<--driver driver> I<--subdriver subdriver> I<--type type> I<--mode mode>
+=item B<attach-disk> I<virtual-machine-id> I<source> I<target> optional
+I<--driver driver> I<--subdriver subdriver> I<--type type> I<--mode mode>
 
-Attach a new disk device to the domain.
+Attach a new disk device to the virtual machine.
 I<source> and I<target> are paths for the files and devices.
 I<driver> can be I<file>, I<tap> or I<phy> depending on the kind of access.
 I<type> can indicate I<cdrom> or I<floppy> as alternative to the disk default,
@@ -647,40 +659,45 @@ although this use only replaces the media within the existing virtual cdrom or
 floppy device; consider using B<update-device> for this usage instead.
 I<mode> can specify the two specific mode I<readonly> or I<shareable>.
 
-=item B<attach-interface> I<domain-id> I<type> I<source> optional I<--target target> I<--mac mac> I<--script script> I<--model model> I<--persistent>
+=item B<attach-interface> I<virtual-machine-id> I<type> I<source> optional
+I<--target target> I<--mac mac> I<--script script> I<--model model>
+I<--persistent>
 
-Attach a new network interface to the domain.
-I<type> can be either I<network> to indicate a physical network device or I<bridge> to indicate a bridge to a device.
+Attach a new network interface to the virtual machine.
+I<type> can be either I<network> to indicate a physical network device or
+I<bridge> to indicate a bridge to a device.
 I<source> indicates the source device.
-I<target> allows to indicate the target device in the guest.
+I<target> allows to indicate the target device in the virtual machine.
 I<mac> allows to specify the MAC address of the network interface.
 I<script> allows to specify a path to a script handling a bridge instead of
 the default one.
 I<model> allows to specify the model type.
-I<persistent> indicates the changes will affect the next boot of the domain.
+I<persistent> indicates the changes will affect the next boot of the virtual
+machine.
 
-=item B<detach-device> I<domain-id> I<FILE>
+=item B<detach-device> I<virtual-machine-id> I<FILE>
 
-Detach a device from the domain, takes the same kind of XML descriptions
-as command B<attach-device>.
+Detach a device from the virtual machine, takes the same kind of XML
+descriptions as command B<attach-device>.
 
-=item B<detach-disk> I<domain-id> I<target>
+=item B<detach-disk> I<virtual-machine-id> I<target>
 
-Detach a disk device from a domain. The I<target> is the device as seen
-from the domain.
+Detach a disk device from a virtual machine. The I<target> is the device as
+seen from the virtual machine.
 
-=item B<detach-interface> I<domain-id> I<type> optional I<--mac mac>
+=item B<detach-interface> I<virtual-machine-id> I<type> optional I<--mac mac>
 
-Detach a network interface from a domain.
-I<type> can be either I<network> to indicate a physical network device or I<bridge> to indicate a bridge to a device.
-It is recommended to use the I<mac> option to distinguish between the interfaces
-if more than one are present on the domain.
+Detach a network interface from a virtual machine.
+I<type> can be either I<network> to indicate a physical network device or
+I<bridge> to indicate a bridge to a device. It is recommended to use the
+I<mac> option to distinguish between the interfaces if more than one are
+present on the virtual machine.
 
-=item B<update-device> I<domain-id> I<file> optional I<--persistent>
+=item B<update-device> I<virtual-machine-id> I<file> optional I<--persistent>
 
-Update the characteristics of a device associated with I<domain-id>,
+Update the characteristics of a device associated with I<virtual-machine-id>,
 based on the device definition in an XML I<file>.  If the I<--persistent>
-option is used, the changes will affect the next boot of the domain.
+option is used, the changes will affect the next boot of the virtual machine.
 See the documentation to learn about libvirt XML format for a device.
 
 =back
@@ -688,11 +705,11 @@ See the documentation to learn about libvirt XML format for a device.
 =head1 VIRTUAL NETWORK COMMANDS
 
 The following commands manipulate networks. Libvirt has the capability to
-define virtual networks which can then be used by domains and linked to
-actual network devices. For more detailed information about this feature
+define virtual networks which can then be used by virtual machines and linked
+to actual network devices. For more detailed information about this feature
 see the documentation at L<http://libvirt.org/formatnetwork.html> . A lot
-of the command for virtual networks are similar to the one used for domains,
-but the way to name a virtual network is either by its name or UUID.
+of the command for virtual networks are similar to the one used for virtual
+machines, but the way to name a virtual network is either by its name or UUID.
 
 =over 4
 
@@ -763,11 +780,11 @@ Convert a network name to network UUID.
 
 The following commands manipulate storage pools. Libvirt has the
 capability to manage various storage solutions, including files, raw
-partitions, and domain-specific formats, used to provide the storage
+partitions, and virtual machine specific formats, used to provide the storage
 volumes visible as devices within virtual machines. For more detailed
 information about this feature, see the documentation at
 L<http://libvirt.org/formatstorage.html> . A lot of the commands for
-pools are similar to the ones used for domains.
+pools are similar to the ones used for virtual machines.
 
 =over 4
 
@@ -854,7 +871,7 @@ Returns basic information about the I<pool> object.
 =item B<pool-list> optional I<--inactive> I<--all> I<--details>
 
 List pool objects known to libvirt.  By default, only pools in use by
-active domains are listed; I<--inactive> lists just the inactive
+active virtual machines are listed; I<--inactive> lists just the inactive
 pools, and I<--all> lists all pools. The I<--details> option instructs
 virsh to additionally display pool persistence and capacity related
 information where available.
@@ -888,10 +905,10 @@ Returns the UUID of the named I<pool>.
 =item B<vol-create> I<pool-or-uuid> I<FILE>
 
 Create a volume from an XML <file>.
-I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
-I<FILE> is the XML <file> with the volume definition. An easy way to create the
-XML <file> is to use the B<vol-dumpxml> command to obtain the definition of a
-pre-existing volume.
+I<pool-or-uuid> is the name or UUID of the storage pool to create the volume
+in. I<FILE> is the XML <file> with the volume definition. An easy way to
+create the XML <file> is to use the B<vol-dumpxml> command to obtain the
+definition of a pre-existing volume.
 
 B<Example>
 
@@ -903,11 +920,11 @@ B<Example>
 I<pool-or-uuid>] I<vol-name-or-key-or-path>
 
 Create a volume, using another volume as input.
-I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
-I<FILE> is the XML <file> with the volume definition.
-I<--inputpool> I<pool-or-uuid> is the name or uuid of the storage pool the
-source volume is in.
-I<vol-name-or-key-or-path> is the name or key or path of the source volume.
+I<pool-or-uuid> is the name or UUID of the storage pool to create the volume
+in. I<FILE> is the XML <file> with the volume definition. I<--inputpool>
+I<pool-or-uuid> is the name or uuid of the storage pool the source volume is
+in. I<vol-name-or-key-or-path> is the name or key or path of the source
+volume.
 
 =item B<vol-create-as> I<pool-or-uuid> I<name> I<capacity> optional
 I<--allocation> I<size> I<--format> I<string> I<--backing-vol>
@@ -917,48 +934,58 @@ Create a volume from a set of arguments.
 I<pool-or-uuid> is the name or UUID of the storage pool to create the volume
 in.
 I<name> is the name of the new volume.
-I<capacity> is the size of the volume to be created, with optional k, M, G, or
-T suffix.
-I<--allocation> I<size> is the initial size to be allocated in the volume, with
-optional k, M, G, or T suffix.
-I<--format> I<string> is used in file based storage pools to specify the volume
-file format to use; raw, bochs, qcow, qcow2, vmdk.
+I<capacity> is the size of the volume to be created, with optional k, M, G,
+or T suffix.
+I<--allocation> I<size> is the initial size to be allocated in the volume,
+with optional k, M, G, or T suffix.
+I<--format> I<string> is used in file based storage pools to specify the
+volume file format to use; raw, bochs, qcow, qcow2, vmdk.
 I<--backing-vol> I<vol-name-or-key-or-path> is the source backing
 volume to be used if taking a snapshot of an existing volume.
-I<--backing-vol-format> I<string> is the format of the snapshot backing volume;
-raw, bochs, qcow, qcow2, vmdk, host_device.
+I<--backing-vol-format> I<string> is the format of the snapshot backing
+volume; raw, bochs, qcow, qcow2, vmdk, host_device.
 
-=item B<vol-clone> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path> I<name>
+=item B<vol-clone> [optional I<--pool> I<pool-or-uuid>]
+I<vol-name-or-key-or-path> I<name>
 
 Clone an existing volume.  Less powerful, but easier to type, version of
 B<vol-create-from>.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool to create the volume in.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool to create
+the volume in.
 I<vol-name-or-key-or-path> is the name or key or path of the source volume.
 I<name> is the name of the new volume.
 
-=item B<vol-delete> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+=item B<vol-delete> [optional I<--pool> I<pool-or-uuid>]
+I<vol-name-or-key-or-path>
 
 Delete a given volume.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-key-or-path> is the name or key or path of the volume to delete.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume
+is in. I<vol-name-or-key-or-path> is the name or key or path of the volume to
+delete.
 
-=item B<vol-wipe> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+=item B<vol-wipe> [optional I<--pool> I<pool-or-uuid>]
+I<vol-name-or-key-or-path>
 
-Wipe a volume, ensure data previously on the volume is not accessible to future reads.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-key-or-path> is the name or key or path of the volume to wipe.
+Wipe a volume, ensure data previously on the volume is not accessible to
+future reads. I<--pool> I<pool-or-uuid> is the name or UUID of the storage
+pool the volume is in. I<vol-name-or-key-or-path> is the name or key or path
+of the volume to wipe.
 
-=item B<vol-dumpxml> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+=item B<vol-dumpxml> [optional I<--pool> I<pool-or-uuid>]
+I<vol-name-or-key-or-path>
 
-Output the volume information as an XML dump to stdout.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-key-or-path> is the name or key or path of the volume to output the XML of.
+Output the volume information as an XML dump to stdout. I<--pool>
+I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
+I<vol-name-or-key-or-path> is the name or key or path of the volume to
+output the XML of.
 
-=item B<vol-info> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key-or-path>
+=item B<vol-info> [optional I<--pool> I<pool-or-uuid>]
+I<vol-name-or-key-or-path>
 
 Returns basic information about the given storage volume.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-key-or-path> is the name or key or path of the volume to return information for.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the
+volume is in. I<vol-name-or-key-or-path> is the name or key or path of the
+volume to return information for.
 
 =item B<vol-list> [optional I<--pool>] I<pool-or-uuid> optional I<--details>
 
@@ -977,8 +1004,9 @@ information for.
 =item B<vol-path> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-key>
 
 Return the path for a given volume.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-key> is the name or key of the volume to return the path for.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume
+is in. I<vol-name-or-key> is the name or key of the volume to return the path
+for.
 
 =item B<vol-name> I<vol-key-or-path>
 
@@ -988,8 +1016,9 @@ I<vol-key-or-path> is the key or path of the volume to return the name for.
 =item B<vol-key> [optional I<--pool> I<pool-or-uuid>] I<vol-name-or-path>
 
 Return the volume key for a given volume.
-I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume is in.
-I<vol-name-or-path> is the name or path of the volume to return the volume key for.
+I<--pool> I<pool-or-uuid> is the name or UUID of the storage pool the volume
+is in. I<vol-name-or-path> is the name or path of the volume to return the
+volume key for.
 
 =back
 
@@ -997,10 +1026,10 @@ I<vol-name-or-path> is the name or path of the volume to return the volume key f
 
 The following commands manipulate "secrets" (e.g. passwords, passphrases and
 encryption keys).  Libvirt can store secrets independently from their use, and
-other objects (e.g. volumes or domains) can refer to the secrets for encryption
-or possibly other uses.  Secrets are identified using an UUID.  See
-L<http://libvirt.org/formatsecret.html> for documentation of the XML format
-used to represent properties of secrets.
+other objects (e.g. volumes or virtual machines) can refer to the secrets for
+encryption or possibly other uses.  Secrets are identified using an UUID.
+See L<http://libvirt.org/formatsecret.html> for documentation of the XML
+format used to represent properties of secrets.
 
 =over 4
 
@@ -1038,49 +1067,49 @@ Output a list of UUIDs of known secrets to stdout.
 
 =head1 SNAPSHOT COMMMANDS
 
-The following commands manipulate domain snapshots.  Snapshots take the
-disk, memory, and device state of a domain at a point-of-time, and save it
-for future use.  They have many uses, from saving a "clean" copy of an OS
-image to saving a domain's state before a potentially destructive operation.
-Snapshots are identified with a unique name.  See
+The following commands manipulate virtual machine snapshots.  Snapshots take
+the disk, memory, and device state of a virtual machine at a point-of-time,
+and save it for future use.  They have many uses, from saving a "clean" copy
+of an OS image to saving a virtual machine's state before a potentially
+destructive operation. Snapshots are identified with a unique name.  See
 L<http://libvirt.org/formatsnapshot.html> for documentation of the XML format
 used to represent properties of snapshots.
 
 =over 4
 
-=item B<snapshot-create> I<domain> I<xmlfile>
+=item B<snapshot-create> I<virtual-machine> I<xmlfile>
 
-Create a snapshot for domain I<domain> with the properties specified in
-I<xmlfile>.  The only properties settable for a domain snapshot are the
-<name> and <description>; the rest of the fields are ignored, and
+Create a snapshot for I<virtual-machine> with the properties specified in
+I<xmlfile>.  The only properties settable for a virtual machine snapshot are
+the <name> and <description>; the rest of the fields are ignored, and
 automatically filled in by libvirt.  If I<xmlfile> is completely omitted,
 then libvirt will choose a value for all fields.
 
-=item B<snapshot-current> I<domain>
+=item B<snapshot-current> I<virtual-machine>
 
-Output the snapshot XML for the domain's current snapshot (if any).
+Output the snapshot XML for the virtual machine's current snapshot (if any).
 
-=item B<snapshot-list> I<domain>
+=item B<snapshot-list> I<virtual-machine>
 
-List all of the available snapshots for the given domain.
+List all of the available snapshots for the given virtual machine.
 
-=item B<snapshot-dumpxml> I<domain> I<snapshot>
+=item B<snapshot-dumpxml> I<virtual-machine> I<snapshot>
 
-Output the snapshot XML for the domain's snapshot named I<snapshot>.
+Output the snapshot XML for the virtual machine's snapshot named I<snapshot>.
 
-=item B<snapshot-revert> I<domain> I<snapshot>
+=item B<snapshot-revert> I<virtual-machine> I<snapshot>
 
-Revert the given domain to the snapshot specified by I<snapshot>.  Be aware
-that this is a destructive action; any changes in the domain since the
-snapshot was taken will be lost.  Also note that the state of the domain after
-snapshot-revert is complete will be the state of the domain at the time
-the original snapshot was taken.
+Revert the given virtual machine to the snapshot specified by I<snapshot>.
+Be aware that this is a destructive action; any changes in the virtual
+machine since the snapshot was taken will be lost.  Also note that the state
+of the virtual machine after snapshot-revert is complete will be the state of
+the virtual machine at the time the original snapshot was taken.
 
-=item B<snapshot-delete> I<domain> I<snapshot> I<--children>
+=item B<snapshot-delete> I<virtual-machine> I<snapshot> I<--children>
 
-Delete the snapshot for the domain named I<snapshot>.  If this snapshot
-has child snapshots, changes from this snapshot will be merged into the
-children.  If I<--children> is passed, then delete this snapshot and any
+Delete the snapshot for the virtual machine named I<snapshot>.  If this
+snapshot has child snapshots, changes from this snapshot will be merged into
+the children.  If I<--children> is passed, then delete this snapshot and any
 children of this snapshot.
 
 =back
@@ -1147,10 +1176,10 @@ problems to the libvirt developers; the reports will be ignored.
 
 =over 4
 
-=item B<qemu-monitor-command> I<domain> I<command>
+=item B<qemu-monitor-command> I<virtual-machine> I<command>
 
-Send an arbitrary monitor command I<command> to domain I<domain> through the
-qemu monitor.  The results of the command will be printed on stdout.
+Send an arbitrary monitor command I<command> to I<virtual-machine> through
+the qemu monitor.  The results of the command will be printed on stdout.
 
 =back
 
@@ -1199,15 +1228,17 @@ Messages at level ERROR or above
 
 =back
 
-For further information about debugging options consult C<http://libvirt.org/logging.html>
+For further information about debugging options consult
+C<http://libvirt.org/logging.html>
 
 =back
 
 =head1 BUGS
 
-Report any bugs discovered to the libvirt community via the mailing
-list C<http://libvirt.org/contact.html> or bug tracker C<http://libvirt.org/bugs.html>.
-Alternatively report bugs to your software distributor / vendor.
+Report any bugs discovered to the libvirt community via the mailing list
+C<http://libvirt.org/contact.html> or bug tracker
+C<http://libvirt.org/bugs.html>.  Alternatively report bugs to your software
+distributor / vendor.
 
 =head1 AUTHORS
 
-- 
1.7.2.3


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]