tools/virsh-checkpoint.c

   1 /*
   2  * virsh-checkpoint.c: Commands to manage domain checkpoints
   3  *
   4  * Copyright (C) 2005-2019 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library.  If not, see
  18  * <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <config.h>
  22 #include "virsh-checkpoint.h"
  23
  24 #include <assert.h>
  25
  26 #include <libxml/parser.h>
  27 #include <libxml/tree.h>
  28 #include <libxml/xpath.h>
  29 #include <libxml/xmlsave.h>
  30
  31 #include "internal.h"
  32 #include "virbuffer.h"
  33 #include "viralloc.h"
  34 #include "virfile.h"
  35 #include "virsh-util.h"
  36 #include "virxml.h"
  37 #include "vsh-table.h"
  38
  39 /* Helper for checkpoint-create and checkpoint-create-as */
  40 static bool
  41 virshCheckpointCreate(vshControl *ctl,
  42                       virDomainPtr dom,
  43                       const char *buffer,
  44                       unsigned int flags,
  45                       const char *from)
  46 {
  47     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
  48     const char *name = NULL;
  49
  50     checkpoint = virDomainCheckpointCreateXML(dom, buffer, flags);
  51
  52     if (checkpoint == NULL)
  53         return false;
  54
  55     name = virDomainCheckpointGetName(checkpoint);
  56     if (!name) {
  57         vshError(ctl, "%s", _("Could not get checkpoint name"));
  58         return false;
  59     }
  60
  61     if (from)
  62         vshPrintExtra(ctl, _("Domain checkpoint %1$s created from '%2$s'"),
  63                       name, from);
  64     else
  65         vshPrintExtra(ctl, _("Domain checkpoint %1$s created"), name);
  66
  67     return true;
  68 }
  69
  70
  71 /*
  72  * "checkpoint-create" command
  73  */
  74 static const vshCmdInfo info_checkpoint_create = {
  75      .help = N_("Create a checkpoint from XML"),
  76      .desc = N_("Create a checkpoint from XML for use in "
  77                 "future incremental backups"),
  78 };
  79
  80 static const vshCmdOptDef opts_checkpoint_create[] = {
  81     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
  82     {.name = "xmlfile",
  83      .type = VSH_OT_STRING,
  84      .positional = true,
  85      .completer = virshCompletePathLocalExisting,
  86      .help = N_("domain checkpoint XML")
  87     },
  88     {.name = "redefine",
  89      .type = VSH_OT_BOOL,
  90      .help = N_("redefine metadata for existing checkpoint")
  91     },
  92     {.name = "redefine-validate",
  93      .type = VSH_OT_BOOL,
  94      .help = N_("validate the redefined checkpoint")
  95     },
  96     {.name = "quiesce",
  97      .type = VSH_OT_BOOL,
  98      .help = N_("quiesce guest's file systems")
  99     },
 100     {.name = NULL}
 101 };
 102
 103 static bool
 104 cmdCheckpointCreate(vshControl *ctl,
 105                     const vshCmd *cmd)
 106 {
 107     g_autoptr(virshDomain) dom = NULL;
 108     const char *from = NULL;
 109     g_autofree char *buffer = NULL;
 110     unsigned int flags = 0;
 111
 112     VSH_REQUIRE_OPTION("redefine-validate", "redefine");
 113
 114     if (vshCommandOptBool(cmd, "redefine"))
 115         flags |= VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE;
 116     if (vshCommandOptBool(cmd, "redefine-validate"))
 117         flags |= VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE_VALIDATE;
 118     if (vshCommandOptBool(cmd, "quiesce"))
 119         flags |= VIR_DOMAIN_CHECKPOINT_CREATE_QUIESCE;
 120
 121     if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
 122         return false;
 123
 124     if (vshCommandOptString(ctl, cmd, "xmlfile", &from) < 0)
 125         return false;
 126     if (!from) {
 127         buffer = g_strdup("<domaincheckpoint/>");
 128     } else {
 129         if (virFileReadAll(from, VSH_MAX_XML_FILE, &buffer) < 0) {
 130             vshSaveLibvirtError();
 131             return false;
 132         }
 133     }
 134
 135     return virshCheckpointCreate(ctl, dom, buffer, flags, from);
 136 }
 137
 138
 139 /*
 140  * "checkpoint-create-as" command
 141  */
 142 static int
 143 virshParseCheckpointDiskspec(vshControl *ctl,
 144                              virBuffer *buf,
 145                              const char *str)
 146 {
 147     int ret = -1;
 148     const char *name = NULL;
 149     const char *checkpoint = NULL;
 150     const char *bitmap = NULL;
 151     g_auto(GStrv) array = NULL;
 152     int narray;
 153     size_t i;
 154
 155     narray = vshStringToArray(str, &array);
 156     if (narray <= 0)
 157         goto cleanup;
 158
 159     name = array[0];
 160     for (i = 1; i < narray; i++) {
 161         if (!checkpoint && STRPREFIX(array[i], "checkpoint="))
 162             checkpoint = array[i] + strlen("checkpoint=");
 163         else if (!bitmap && STRPREFIX(array[i], "bitmap="))
 164             bitmap = array[i] + strlen("bitmap=");
 165         else
 166             goto cleanup;
 167     }
 168
 169     virBufferEscapeString(buf, "<disk name='%s'", name);
 170     if (checkpoint)
 171         virBufferAsprintf(buf, " checkpoint='%s'", checkpoint);
 172     if (bitmap)
 173         virBufferAsprintf(buf, " bitmap='%s'", bitmap);
 174     virBufferAddLit(buf, "/>\n");
 175     ret = 0;
 176  cleanup:
 177     if (ret < 0)
 178         vshError(ctl, _("unable to parse diskspec: %1$s"), str);
 179     return ret;
 180 }
 181
 182 static const vshCmdInfo info_checkpoint_create_as = {
 183      .help = N_("Create a checkpoint from a set of args"),
 184      .desc = N_("Create a checkpoint from arguments for use in "
 185                 "future incremental backups"),
 186 };
 187
 188 static const vshCmdOptDef opts_checkpoint_create_as[] = {
 189     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_ACTIVE),
 190     {.name = "name",
 191      .type = VSH_OT_STRING,
 192      .unwanted_positional = true,
 193      .completer = virshCompleteEmpty,
 194      .help = N_("name of checkpoint")
 195     },
 196     {.name = "description",
 197      .type = VSH_OT_STRING,
 198      .unwanted_positional = true,
 199      .completer = virshCompleteEmpty,
 200      .help = N_("description of checkpoint")
 201     },
 202     {.name = "print-xml",
 203      .type = VSH_OT_BOOL,
 204      .help = N_("print XML document rather than create")
 205     },
 206     {.name = "quiesce",
 207      .type = VSH_OT_BOOL,
 208      .help = N_("quiesce guest's file systems")
 209     },
 210     {.name = "diskspec",
 211      .type = VSH_OT_ARGV,
 212      .unwanted_positional = true,
 213      .help = N_("disk attributes: disk[,checkpoint=type][,bitmap=name]")
 214     },
 215     {.name = NULL}
 216 };
 217
 218
 219 static bool
 220 cmdCheckpointCreateAs(vshControl *ctl,
 221                       const vshCmd *cmd)
 222 {
 223     g_autoptr(virshDomain) dom = NULL;
 224     g_autofree char *buffer = NULL;
 225     const char *name = NULL;
 226     const char *desc = NULL;
 227     g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
 228     unsigned int flags = 0;
 229     const char **diskspec = NULL;
 230
 231     if (vshCommandOptBool(cmd, "quiesce"))
 232         flags |= VIR_DOMAIN_CHECKPOINT_CREATE_QUIESCE;
 233
 234     if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
 235         return false;
 236
 237     if (vshCommandOptString(ctl, cmd, "name", &name) < 0 ||
 238         vshCommandOptString(ctl, cmd, "description", &desc) < 0)
 239         return false;
 240
 241     virBufferAddLit(&buf, "<domaincheckpoint>\n");
 242     virBufferAdjustIndent(&buf, 2);
 243     virBufferEscapeString(&buf, "<name>%s</name>\n", name);
 244     virBufferEscapeString(&buf, "<description>%s</description>\n", desc);
 245
 246     if ((diskspec = vshCommandOptArgv(cmd, "diskspec"))) {
 247         virBufferAddLit(&buf, "<disks>\n");
 248         virBufferAdjustIndent(&buf, 2);
 249
 250         for (; *diskspec; diskspec++) {
 251             if (virshParseCheckpointDiskspec(ctl, &buf, *diskspec) < 0)
 252                 return false;
 253         }
 254
 255         virBufferAdjustIndent(&buf, -2);
 256         virBufferAddLit(&buf, "</disks>\n");
 257     }
 258     virBufferAdjustIndent(&buf, -2);
 259     virBufferAddLit(&buf, "</domaincheckpoint>\n");
 260
 261     buffer = virBufferContentAndReset(&buf);
 262
 263     if (vshCommandOptBool(cmd, "print-xml")) {
 264         vshPrint(ctl, "%s\n",  buffer);
 265         return true;
 266     }
 267
 268     return virshCheckpointCreate(ctl, dom, buffer, flags, NULL);
 269 }
 270
 271
 272 /* Helper for resolving --ARG name into a checkpoint
 273  * belonging to DOM.  On success, populate *CHK and *NAME, before
 274  * returning 0.  On failure, return -1 after issuing an error
 275  * message.  */
 276 static int
 277 virshLookupCheckpoint(vshControl *ctl,
 278                       const vshCmd *cmd,
 279                       const char *arg,
 280                       virDomainPtr dom,
 281                       virDomainCheckpointPtr *chk,
 282                       const char **name)
 283 {
 284     const char *chkname = NULL;
 285
 286     if (vshCommandOptString(ctl, cmd, arg, &chkname) < 0)
 287         return -1;
 288
 289     if (!(*chk = virDomainCheckpointLookupByName(dom, chkname, 0)))
 290         return -1;
 291
 292     *name = virDomainCheckpointGetName(*chk);
 293     return 0;
 294 }
 295
 296
 297 /*
 298  * "checkpoint-edit" command
 299  */
 300 static const vshCmdInfo info_checkpoint_edit = {
 301     .help = N_("edit XML for a checkpoint"),
 302     .desc = N_("Edit the domain checkpoint XML for a named checkpoint"),
 303 };
 304
 305 static const vshCmdOptDef opts_checkpoint_edit[] = {
 306     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT),
 307     {.name = "checkpointname",
 308      .type = VSH_OT_STRING,
 309      .positional = true,
 310      .required = true,
 311      .help = N_("checkpoint name"),
 312      .completer = virshCheckpointNameCompleter,
 313     },
 314     {.name = NULL}
 315 };
 316
 317 static bool
 318 cmdCheckpointEdit(vshControl *ctl,
 319                   const vshCmd *cmd)
 320 {
 321     g_autoptr(virshDomain) dom = NULL;
 322     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
 323     g_autoptr(virshDomainCheckpoint) edited = NULL;
 324     const char *name = NULL;
 325     const char *edited_name;
 326     bool ret = false;
 327     unsigned int getxml_flags = VIR_DOMAIN_CHECKPOINT_XML_SECURE;
 328     unsigned int define_flags = VIR_DOMAIN_CHECKPOINT_CREATE_REDEFINE;
 329
 330     if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
 331         return false;
 332
 333     if (virshLookupCheckpoint(ctl, cmd, "checkpointname", dom,
 334                               &checkpoint, &name) < 0)
 335         goto cleanup;
 336
 337 #define EDIT_GET_XML \
 338     virDomainCheckpointGetXMLDesc(checkpoint, getxml_flags)
 339 #define EDIT_NOT_CHANGED \
 340     do { \
 341         vshPrintExtra(ctl, \
 342                       _("Checkpoint %1$s XML configuration not changed.\n"), \
 343                       name); \
 344         ret = true; \
 345         goto edit_cleanup; \
 346     } while (0)
 347 #define EDIT_DEFINE \
 348     edited = virDomainCheckpointCreateXML(dom, doc_edited, define_flags)
 349 #include "virsh-edit.c"
 350
 351     edited_name = virDomainCheckpointGetName(edited);
 352     if (STREQ(name, edited_name)) {
 353         vshPrintExtra(ctl, _("Checkpoint %1$s edited.\n"), name);
 354     } else {
 355         unsigned int delete_flags = VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY;
 356
 357         if (virDomainCheckpointDelete(edited, delete_flags) < 0) {
 358             vshReportError(ctl);
 359             vshError(ctl, _("Failed to clean up %1$s"), edited_name);
 360             goto cleanup;
 361         }
 362         vshError(ctl, _("Cannot rename checkpoint %1$s to %2$s"),
 363                  name, edited_name);
 364         goto cleanup;
 365     }
 366
 367     ret = true;
 368
 369  cleanup:
 370     if (!ret && name)
 371         vshError(ctl, _("Failed to update %1$s"), name);
 372     return ret;
 373 }
 374
 375
 376 /* Helper function to get the name of a checkpoint's parent.  Caller
 377  * must free the result.  Returns 0 on success (including when it was
 378  * proven no parent exists), and -1 on failure with error reported
 379  * (such as no checkpoint support or domain deleted in meantime).  */
 380 static int
 381 virshGetCheckpointParent(vshControl *ctl,
 382                          virDomainCheckpointPtr checkpoint,
 383                          char **parent_name)
 384 {
 385     g_autoptr(virshDomainCheckpoint) parent = NULL;
 386     int ret = -1;
 387
 388     *parent_name = NULL;
 389
 390     parent = virDomainCheckpointGetParent(checkpoint, 0);
 391     if (parent) {
 392         /* API works, and virDomainCheckpointGetName will succeed */
 393         *parent_name = g_strdup(virDomainCheckpointGetName(parent));
 394         ret = 0;
 395     } else if (last_error->code == VIR_ERR_NO_DOMAIN_CHECKPOINT) {
 396         /* API works, and we found a root with no parent */
 397         ret = 0;
 398     }
 399
 400     if (ret < 0) {
 401         vshReportError(ctl);
 402         vshError(ctl, "%s", _("unable to determine if checkpoint has parent"));
 403     } else {
 404         vshResetLibvirtError();
 405     }
 406     return ret;
 407 }
 408
 409
 410 /*
 411  * "checkpoint-info" command
 412  */
 413 static const vshCmdInfo info_checkpoint_info = {
 414     .help = N_("checkpoint information"),
 415     .desc = N_("Returns basic information about a checkpoint."),
 416 };
 417
 418 static const vshCmdOptDef opts_checkpoint_info[] = {
 419     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT),
 420     {.name = "checkpointname",
 421      .type = VSH_OT_STRING,
 422      .positional = true,
 423      .required = true,
 424      .help = N_("checkpoint name"),
 425      .completer = virshCheckpointNameCompleter,
 426     },
 427     {.name = NULL}
 428 };
 429
 430
 431 static bool
 432 cmdCheckpointInfo(vshControl *ctl,
 433                   const vshCmd *cmd)
 434 {
 435     g_autoptr(virshDomain) dom = NULL;
 436     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
 437     const char *name;
 438     g_autofree char *parent = NULL;
 439     int count;
 440     unsigned int flags;
 441
 442     dom = virshCommandOptDomain(ctl, cmd, NULL);
 443     if (dom == NULL)
 444         return false;
 445
 446     if (virshLookupCheckpoint(ctl, cmd, "checkpointname", dom,
 447                               &checkpoint, &name) < 0)
 448         return false;
 449
 450     vshPrint(ctl, "%-15s %s\n", _("Name:"), name);
 451     vshPrint(ctl, "%-15s %s\n", _("Domain:"), virDomainGetName(dom));
 452
 453     if (virshGetCheckpointParent(ctl, checkpoint, &parent) < 0) {
 454         vshError(ctl, "%s",
 455                  _("unexpected problem querying checkpoint state"));
 456         return false;
 457     }
 458     vshPrint(ctl, "%-15s %s\n", _("Parent:"), NULLSTR_MINUS(parent));
 459
 460     /* Children, Descendants.  */
 461     flags = 0;
 462     count = virDomainCheckpointListAllChildren(checkpoint, NULL, flags);
 463     if (count < 0) {
 464         if (last_error->code == VIR_ERR_NO_SUPPORT) {
 465             vshResetLibvirtError();
 466             return true;
 467         }
 468         return false;
 469     }
 470     vshPrint(ctl, "%-15s %d\n", _("Children:"), count);
 471     flags = VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS;
 472     count = virDomainCheckpointListAllChildren(checkpoint, NULL, flags);
 473     if (count < 0)
 474         return false;
 475     vshPrint(ctl, "%-15s %d\n", _("Descendants:"), count);
 476
 477     return true;
 478 }
 479
 480
 481 /* Helpers for collecting a list of checkpoints.  */
 482 struct virshChk {
 483     virDomainCheckpointPtr chk;
 484     char *parent;
 485 };
 486 struct virshCheckpointList {
 487     struct virshChk *chks;
 488     int nchks;
 489 };
 490
 491 static void
 492 virshCheckpointListFree(struct virshCheckpointList *checkpointlist)
 493 {
 494     size_t i;
 495
 496     if (!checkpointlist)
 497         return;
 498     if (checkpointlist->chks) {
 499         for (i = 0; i < checkpointlist->nchks; i++) {
 500             virshDomainCheckpointFree(checkpointlist->chks[i].chk);
 501             g_free(checkpointlist->chks[i].parent);
 502         }
 503         g_free(checkpointlist->chks);
 504     }
 505     g_free(checkpointlist);
 506 }
 507
 508
 509 static int
 510 virshChkSorter(const void *a,
 511                const void *b,
 512                void *opaque G_GNUC_UNUSED)
 513 {
 514     const struct virshChk *sa = a;
 515     const struct virshChk *sb = b;
 516
 517     if (sa->chk && !sb->chk)
 518         return -1;
 519     if (!sa->chk)
 520         return sb->chk != NULL;
 521
 522     return vshStrcasecmp(virDomainCheckpointGetName(sa->chk),
 523                          virDomainCheckpointGetName(sb->chk));
 524 }
 525
 526
 527 /* Compute a list of checkpoints from DOM.  If FROM is provided, the
 528  * list is limited to descendants of the given checkpoint.  If FLAGS is
 529  * given, the list is filtered.  If TREE is specified, then all but
 530  * FROM or the roots will also have parent information.  */
 531 static struct virshCheckpointList *
 532 virshCheckpointListCollect(vshControl *ctl,
 533                            virDomainPtr dom,
 534                            virDomainCheckpointPtr from,
 535                            unsigned int orig_flags,
 536                            bool tree)
 537 {
 538     size_t i;
 539     int count = -1;
 540     virDomainCheckpointPtr *chks;
 541     struct virshCheckpointList *checkpointlist = NULL;
 542     struct virshCheckpointList *ret = NULL;
 543     unsigned int flags = orig_flags;
 544
 545     checkpointlist = g_new0(struct virshCheckpointList, 1);
 546
 547     if (from)
 548         count = virDomainCheckpointListAllChildren(from, &chks, flags);
 549     else
 550         count = virDomainListAllCheckpoints(dom, &chks, flags);
 551     if (count < 0) {
 552         vshError(ctl, "%s",
 553                  _("unexpected problem querying checkpoints"));
 554         goto cleanup;
 555     }
 556
 557     /* When mixing --from and --tree, we also want a copy of from
 558      * in the list, but with no parent for that one entry.  */
 559     if (from && tree)
 560         checkpointlist->chks = g_new0(struct virshChk, count + 1);
 561     else
 562         checkpointlist->chks = g_new0(struct virshChk, count);
 563     checkpointlist->nchks = count;
 564     for (i = 0; i < count; i++)
 565         checkpointlist->chks[i].chk = chks[i];
 566     VIR_FREE(chks);
 567     if (tree) {
 568         for (i = 0; i < count; i++) {
 569             if (virshGetCheckpointParent(ctl, checkpointlist->chks[i].chk,
 570                                          &checkpointlist->chks[i].parent) < 0)
 571                 goto cleanup;
 572         }
 573         if (from) {
 574             checkpointlist->chks[checkpointlist->nchks++].chk = from;
 575             virDomainCheckpointRef(from);
 576         }
 577     }
 578
 579     if (!(orig_flags & VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL) &&
 580         checkpointlist->chks) {
 581         g_qsort_with_data(checkpointlist->chks, checkpointlist->nchks,
 582                           sizeof(*checkpointlist->chks), virshChkSorter, NULL);
 583     }
 584
 585     ret = g_steal_pointer(&checkpointlist);
 586
 587  cleanup:
 588     virshCheckpointListFree(checkpointlist);
 589     return ret;
 590 }
 591
 592
 593 static const char *
 594 virshCheckpointListLookup(int id,
 595                           bool parent,
 596                           void *opaque)
 597 {
 598     struct virshCheckpointList *checkpointlist = opaque;
 599     if (parent)
 600         return checkpointlist->chks[id].parent;
 601     return virDomainCheckpointGetName(checkpointlist->chks[id].chk);
 602 }
 603
 604
 605 /*
 606  * "checkpoint-list" command
 607  */
 608 static const vshCmdInfo info_checkpoint_list = {
 609     .help = N_("List checkpoints for a domain"),
 610     .desc = N_("Checkpoint List"),
 611 };
 612
 613 static const vshCmdOptDef opts_checkpoint_list[] = {
 614     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT),
 615     {.name = "parent",
 616      .type = VSH_OT_BOOL,
 617      .help = N_("add a column showing parent checkpoint")
 618     },
 619     {.name = "roots",
 620      .type = VSH_OT_BOOL,
 621      .help = N_("list only checkpoints without parents")
 622     },
 623     {.name = "leaves",
 624      .type = VSH_OT_BOOL,
 625      .help = N_("list only checkpoints without children")
 626     },
 627     {.name = "no-leaves",
 628      .type = VSH_OT_BOOL,
 629      .help = N_("list only checkpoints that are not leaves (with children)")
 630     },
 631     {.name = "tree",
 632      .type = VSH_OT_BOOL,
 633      .help = N_("list checkpoints in a tree")
 634     },
 635     {.name = "from",
 636      .type = VSH_OT_STRING,
 637      .unwanted_positional = true,
 638      .help = N_("limit list to children of given checkpoint"),
 639      .completer = virshCheckpointNameCompleter,
 640     },
 641     {.name = "descendants",
 642      .type = VSH_OT_BOOL,
 643      .help = N_("with --from, list all descendants")
 644     },
 645     {.name = "name",
 646      .type = VSH_OT_BOOL,
 647      .help = N_("list checkpoint names only")
 648     },
 649     {.name = "topological",
 650      .type = VSH_OT_BOOL,
 651      .help = N_("sort list topologically rather than by name"),
 652     },
 653     {.name = NULL}
 654 };
 655
 656 static bool
 657 cmdCheckpointList(vshControl *ctl,
 658                   const vshCmd *cmd)
 659 {
 660     g_autoptr(virshDomain) dom = NULL;
 661     bool ret = false;
 662     unsigned int flags = 0;
 663     size_t i;
 664     virDomainCheckpointPtr checkpoint = NULL;
 665     long long creation_longlong;
 666     g_autoptr(GDateTime) then = NULL;
 667     bool tree = vshCommandOptBool(cmd, "tree");
 668     bool name = vshCommandOptBool(cmd, "name");
 669     bool from = vshCommandOptBool(cmd, "from");
 670     bool parent = vshCommandOptBool(cmd, "parent");
 671     bool roots = vshCommandOptBool(cmd, "roots");
 672     const char *from_chk = NULL;
 673     g_autoptr(virshDomainCheckpoint) start = NULL;
 674     struct virshCheckpointList *checkpointlist = NULL;
 675     g_autoptr(vshTable) table = NULL;
 676
 677     VSH_EXCLUSIVE_OPTIONS_VAR(tree, name);
 678     VSH_EXCLUSIVE_OPTIONS_VAR(parent, roots);
 679     VSH_EXCLUSIVE_OPTIONS_VAR(parent, tree);
 680     VSH_EXCLUSIVE_OPTIONS_VAR(roots, tree);
 681     VSH_EXCLUSIVE_OPTIONS_VAR(roots, from);
 682
 683 #define FILTER(option, flag) \
 684     do { \
 685         if (vshCommandOptBool(cmd, option)) { \
 686             if (tree) { \
 687                 vshError(ctl, \
 688                          _("--%1$s and --tree are mutually exclusive"), \
 689                          option); \
 690                 return false; \
 691             } \
 692             flags |= VIR_DOMAIN_CHECKPOINT_LIST_ ## flag; \
 693         } \
 694     } while (0)
 695
 696     FILTER("leaves", LEAVES);
 697     FILTER("no-leaves", NO_LEAVES);
 698 #undef FILTER
 699
 700     if (vshCommandOptBool(cmd, "topological"))
 701         flags |= VIR_DOMAIN_CHECKPOINT_LIST_TOPOLOGICAL;
 702
 703     if (roots)
 704         flags |= VIR_DOMAIN_CHECKPOINT_LIST_ROOTS;
 705
 706     if (vshCommandOptBool(cmd, "descendants")) {
 707         if (!from) {
 708             vshError(ctl, "%s",
 709                      _("--descendants requires --from"));
 710             return false;
 711         }
 712         flags |= VIR_DOMAIN_CHECKPOINT_LIST_DESCENDANTS;
 713     }
 714
 715     if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
 716         return false;
 717
 718     if (from &&
 719         virshLookupCheckpoint(ctl, cmd, "from", dom, &start, &from_chk) < 0)
 720         goto cleanup;
 721
 722     if (!(checkpointlist = virshCheckpointListCollect(ctl, dom, start, flags,
 723                                                       tree)))
 724         goto cleanup;
 725
 726     if (!tree && !name) {
 727         if (parent)
 728             table = vshTableNew(_("Name"), _("Creation Time"), _("Parent"),
 729                                 NULL);
 730         else
 731             table = vshTableNew(_("Name"), _("Creation Time"), NULL);
 732         if (!table)
 733             goto cleanup;
 734     }
 735
 736     if (tree) {
 737         for (i = 0; i < checkpointlist->nchks; i++) {
 738             if (!checkpointlist->chks[i].parent &&
 739                 vshTreePrint(ctl, virshCheckpointListLookup, checkpointlist,
 740                              checkpointlist->nchks, i) < 0)
 741                 goto cleanup;
 742         }
 743         ret = true;
 744         goto cleanup;
 745     }
 746
 747     for (i = 0; i < checkpointlist->nchks; i++) {
 748         g_autofree gchar *thenstr = NULL;
 749         g_autoptr(xmlDoc) xml = NULL;
 750         g_autoptr(xmlXPathContext) ctxt = NULL;
 751         g_autofree char *parent_chk = NULL;
 752         g_autofree char *doc = NULL;
 753         const char *chk_name;
 754
 755         checkpoint = checkpointlist->chks[i].chk;
 756         chk_name = virDomainCheckpointGetName(checkpoint);
 757         assert(chk_name);
 758
 759         if (!(doc = virDomainCheckpointGetXMLDesc(checkpoint, 0)))
 760             continue;
 761
 762         if (!(xml = virXMLParseStringCtxt(doc, _("(domain_checkpoint)"), &ctxt)))
 763             continue;
 764
 765         if (parent)
 766             parent_chk = virXPathString("string(/domaincheckpoint/parent/name)",
 767                                         ctxt);
 768
 769         if (name) {
 770             vshPrint(ctl, "%s", chk_name);
 771
 772             if (parent_chk)
 773                 vshPrint(ctl, "\t%s", parent_chk);
 774
 775             vshPrint(ctl, "\n");
 776
 777             /* just print the checkpoint name */
 778             continue;
 779         }
 780
 781         if (virXPathLongLong("string(/domaincheckpoint/creationTime)", ctxt,
 782                              &creation_longlong) < 0)
 783             continue;
 784
 785         then = g_date_time_new_from_unix_local(creation_longlong);
 786         thenstr = g_date_time_format(then, "%Y-%m-%d %H:%M:%S %z");
 787
 788         if (parent) {
 789             if (vshTableRowAppend(table, chk_name, thenstr,
 790                                   NULLSTR_EMPTY(parent_chk), NULL) < 0)
 791                 goto cleanup;
 792         } else {
 793             if (vshTableRowAppend(table, chk_name, thenstr, NULL) < 0)
 794                 goto cleanup;
 795         }
 796     }
 797
 798     if (table)
 799         vshTablePrintToStdout(table, ctl);
 800
 801     ret = true;
 802
 803  cleanup:
 804     virshCheckpointListFree(checkpointlist);
 805     return ret;
 806 }
 807
 808
 809 /*
 810  * "checkpoint-dumpxml" command
 811  */
 812 static const vshCmdInfo info_checkpoint_dumpxml = {
 813     .help = N_("Dump XML for a domain checkpoint"),
 814     .desc = N_("Checkpoint Dump XML"),
 815 };
 816
 817 static const vshCmdOptDef opts_checkpoint_dumpxml[] = {
 818     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT),
 819     {.name = "checkpointname",
 820      .type = VSH_OT_STRING,
 821      .positional = true,
 822      .required = true,
 823      .help = N_("checkpoint name"),
 824      .completer = virshCheckpointNameCompleter,
 825     },
 826     {.name = "security-info",
 827      .type = VSH_OT_BOOL,
 828      .help = N_("include security sensitive information in XML dump")
 829     },
 830     {.name = "no-domain",
 831      .type = VSH_OT_BOOL,
 832      .help = N_("exclude <domain> from XML")
 833     },
 834     {.name = "size",
 835      .type = VSH_OT_BOOL,
 836      .help = N_("include backup size estimate in XML dump")
 837     },
 838     {.name = "xpath",
 839      .type = VSH_OT_STRING,
 840      .completer = virshCompleteEmpty,
 841      .help = N_("xpath expression to filter the XML document")
 842     },
 843     {.name = "wrap",
 844      .type = VSH_OT_BOOL,
 845      .help = N_("wrap xpath results in an common root element"),
 846     },
 847     {.name = NULL}
 848 };
 849
 850 static bool
 851 cmdCheckpointDumpXML(vshControl *ctl,
 852                      const vshCmd *cmd)
 853 {
 854     g_autoptr(virshDomain) dom = NULL;
 855     const char *name = NULL;
 856     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
 857     g_autofree char *xml = NULL;
 858     unsigned int flags = 0;
 859     bool wrap = vshCommandOptBool(cmd, "wrap");
 860     const char *xpath = NULL;
 861
 862     if (vshCommandOptBool(cmd, "security-info"))
 863         flags |= VIR_DOMAIN_CHECKPOINT_XML_SECURE;
 864     if (vshCommandOptBool(cmd, "no-domain"))
 865         flags |= VIR_DOMAIN_CHECKPOINT_XML_NO_DOMAIN;
 866     if (vshCommandOptBool(cmd, "size"))
 867         flags |= VIR_DOMAIN_CHECKPOINT_XML_SIZE;
 868
 869     if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
 870         return false;
 871
 872     if (vshCommandOptStringQuiet(ctl, cmd, "xpath", &xpath) < 0)
 873         return false;
 874
 875     if (virshLookupCheckpoint(ctl, cmd, "checkpointname", dom,
 876                               &checkpoint, &name) < 0)
 877         return false;
 878
 879     if (!(xml = virDomainCheckpointGetXMLDesc(checkpoint, flags)))
 880         return false;
 881
 882     return virshDumpXML(ctl, xml, "domain-checkpoint", xpath, wrap);
 883 }
 884
 885
 886 /*
 887  * "checkpoint-parent" command
 888  */
 889 static const vshCmdInfo info_checkpoint_parent = {
 890     .help = N_("Get the name of the parent of a checkpoint"),
 891     .desc = N_("Extract the checkpoint's parent, if any"),
 892 };
 893
 894 static const vshCmdOptDef opts_checkpoint_parent[] = {
 895     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT),
 896     {.name = "checkpointname",
 897      .type = VSH_OT_STRING,
 898      .positional = true,
 899      .required = true,
 900      .help = N_("find parent of checkpoint name"),
 901      .completer = virshCheckpointNameCompleter,
 902     },
 903     {.name = NULL}
 904 };
 905
 906 static bool
 907 cmdCheckpointParent(vshControl *ctl,
 908                     const vshCmd *cmd)
 909 {
 910     g_autoptr(virshDomain) dom = NULL;
 911     const char *name = NULL;
 912     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
 913     g_autofree char *parent = NULL;
 914
 915     dom = virshCommandOptDomain(ctl, cmd, NULL);
 916     if (dom == NULL)
 917         return false;
 918
 919     if (virshLookupCheckpoint(ctl, cmd, "checkpointname", dom,
 920                               &checkpoint, &name) < 0)
 921         return false;
 922
 923     if (virshGetCheckpointParent(ctl, checkpoint, &parent) < 0)
 924         return false;
 925     if (!parent) {
 926         vshError(ctl, _("checkpoint '%1$s' has no parent"), name);
 927         return false;
 928     }
 929
 930     vshPrint(ctl, "%s", parent);
 931
 932     return true;
 933 }
 934
 935
 936 /*
 937  * "checkpoint-delete" command
 938  */
 939 static const vshCmdInfo info_checkpoint_delete = {
 940     .help = N_("Delete a domain checkpoint"),
 941     .desc = N_("Checkpoint Delete"),
 942 };
 943
 944 static const vshCmdOptDef opts_checkpoint_delete[] = {
 945     VIRSH_COMMON_OPT_DOMAIN_FULL(VIR_CONNECT_LIST_DOMAINS_HAS_CHECKPOINT |
 946                                  VIR_CONNECT_LIST_DOMAINS_ACTIVE),
 947     {.name = "checkpointname",
 948      .type = VSH_OT_STRING,
 949      .positional = true,
 950      .required = true,
 951      .help = N_("checkpoint name"),
 952      .completer = virshCheckpointNameCompleter,
 953     },
 954     {.name = "children",
 955      .type = VSH_OT_BOOL,
 956      .help = N_("delete checkpoint and all children")
 957     },
 958     {.name = "children-only",
 959      .type = VSH_OT_BOOL,
 960      .help = N_("delete children but not checkpoint")
 961     },
 962     {.name = "metadata",
 963      .type = VSH_OT_BOOL,
 964      .help = N_("delete only libvirt metadata, leaving checkpoint contents behind")
 965     },
 966     {.name = NULL}
 967 };
 968
 969 static bool
 970 cmdCheckpointDelete(vshControl *ctl,
 971                     const vshCmd *cmd)
 972 {
 973     g_autoptr(virshDomain) dom = NULL;
 974     const char *name = NULL;
 975     g_autoptr(virshDomainCheckpoint) checkpoint = NULL;
 976     unsigned int flags = 0;
 977
 978     dom = virshCommandOptDomain(ctl, cmd, NULL);
 979     if (dom == NULL)
 980         return false;
 981
 982     if (virshLookupCheckpoint(ctl, cmd, "checkpointname", dom,
 983                               &checkpoint, &name) < 0)
 984         return false;
 985
 986     if (vshCommandOptBool(cmd, "children"))
 987         flags |= VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN;
 988     if (vshCommandOptBool(cmd, "children-only"))
 989         flags |= VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY;
 990     if (vshCommandOptBool(cmd, "metadata"))
 991         flags |= VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY;
 992
 993     if (virDomainCheckpointDelete(checkpoint, flags) == 0) {
 994         if (flags & VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY)
 995             vshPrintExtra(ctl, _("Domain checkpoint %1$s children deleted\n"), name);
 996         else
 997             vshPrintExtra(ctl, _("Domain checkpoint %1$s deleted\n"), name);
 998     } else {
 999         vshError(ctl, _("Failed to delete checkpoint %1$s"), name);
1000         return false;
1001     }
1002
1003     return true;
1004 }
1005
1006
1007 const vshCmdDef checkpointCmds[] = {
1008     {.name = "checkpoint-create",
1009      .handler = cmdCheckpointCreate,
1010      .opts = opts_checkpoint_create,
1011      .info = &info_checkpoint_create,
1012      .flags = 0
1013     },
1014     {.name = "checkpoint-create-as",
1015      .handler = cmdCheckpointCreateAs,
1016      .opts = opts_checkpoint_create_as,
1017      .info = &info_checkpoint_create_as,
1018      .flags = 0
1019     },
1020     {.name = "checkpoint-delete",
1021      .handler = cmdCheckpointDelete,
1022      .opts = opts_checkpoint_delete,
1023      .info = &info_checkpoint_delete,
1024      .flags = 0
1025     },
1026     {.name = "checkpoint-dumpxml",
1027      .handler = cmdCheckpointDumpXML,
1028      .opts = opts_checkpoint_dumpxml,
1029      .info = &info_checkpoint_dumpxml,
1030      .flags = 0
1031     },
1032     {.name = "checkpoint-edit",
1033      .handler = cmdCheckpointEdit,
1034      .opts = opts_checkpoint_edit,
1035      .info = &info_checkpoint_edit,
1036      .flags = 0
1037     },
1038     {.name = "checkpoint-info",
1039      .handler = cmdCheckpointInfo,
1040      .opts = opts_checkpoint_info,
1041      .info = &info_checkpoint_info,
1042      .flags = 0
1043     },
1044     {.name = "checkpoint-list",
1045      .handler = cmdCheckpointList,
1046      .opts = opts_checkpoint_list,
1047      .info = &info_checkpoint_list,
1048      .flags = 0
1049     },
1050     {.name = "checkpoint-parent",
1051      .handler = cmdCheckpointParent,
1052      .opts = opts_checkpoint_parent,
1053      .info = &info_checkpoint_parent,
1054      .flags = 0
1055     },
1056     {.name = NULL}
1057 };