tests/unit/test-xs-node.c

   1 /*
   2  * QEMU XenStore XsNode testing
   3  *
   4  * Copyright © 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
   5
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qapi/error.h"
  12 #include "qemu/module.h"
  13
  14 static int nr_xs_nodes;
  15 static GList *xs_node_list;
  16
  17 #define XS_NODE_UNIT_TEST
  18
  19 /*
  20  * We don't need the core Xen definitions. And we *do* want to be able
  21  * to run the unit tests even on architectures that Xen doesn't support
  22  * (because life's too short to bother doing otherwise, and test coverage
  23  * doesn't hurt).
  24  */
  25 #define __XEN_PUBLIC_XEN_H__
  26 typedef unsigned long xen_pfn_t;
  27
  28 #include "hw/i386/kvm/xenstore_impl.c"
  29
  30 #define DOMID_QEMU 0
  31 #define DOMID_GUEST 1
  32
  33 static void dump_ref(const char *name, XsNode *n, int indent)
  34 {
  35     int i;
  36
  37     if (!indent && name) {
  38         printf("%s:\n", name);
  39     }
  40
  41     for (i = 0; i < indent; i++) {
  42         printf(" ");
  43     }
  44
  45     printf("->%p(%d, '%s'): '%.*s'%s%s\n", n, n->ref, n->name,
  46            (int)(n->content ? n->content->len : strlen("<empty>")),
  47            n->content ? (char *)n->content->data : "<empty>",
  48            n->modified_in_tx ? " MODIFIED" : "",
  49            n->deleted_in_tx ? " DELETED" : "");
  50
  51     if (n->children) {
  52         g_hash_table_foreach(n->children, (void *)dump_ref,
  53                              GINT_TO_POINTER(indent + 2));
  54     }
  55 }
  56
  57 /* This doesn't happen in qemu but we want to make valgrind happy */
  58 static void xs_impl_delete(XenstoreImplState *s, bool last)
  59 {
  60     int err;
  61
  62     xs_impl_reset_watches(s, DOMID_GUEST);
  63     g_assert(!s->nr_domu_watches);
  64
  65     err = xs_impl_rm(s, DOMID_QEMU, XBT_NULL, "/local");
  66     g_assert(!err);
  67     g_assert(s->nr_nodes == 1);
  68
  69     g_hash_table_unref(s->watches);
  70     g_hash_table_unref(s->transactions);
  71     xs_node_unref(s->root);
  72     g_free(s);
  73
  74     if (!last) {
  75         return;
  76     }
  77
  78     if (xs_node_list) {
  79         GList *l;
  80         for (l = xs_node_list; l; l = l->next) {
  81             XsNode *n = l->data;
  82             printf("Remaining node at %p name %s ref %u\n", n, n->name,
  83                    n->ref);
  84         }
  85     }
  86     g_assert(!nr_xs_nodes);
  87 }
  88
  89 struct compare_walk {
  90     char path[XENSTORE_ABS_PATH_MAX + 1];
  91     XsNode *parent_2;
  92     bool compare_ok;
  93 };
  94
  95
  96 static bool compare_perms(GList *p1, GList *p2)
  97 {
  98     while (p1) {
  99         if (!p2 || g_strcmp0(p1->data, p2->data)) {
 100             return false;
 101         }
 102         p1 = p1->next;
 103         p2 = p2->next;
 104     }
 105     return (p2 == NULL);
 106 }
 107
 108 static bool compare_content(GByteArray *c1, GByteArray *c2)
 109 {
 110     size_t len1 = 0, len2 = 0;
 111
 112     if (c1) {
 113         len1 = c1->len;
 114     }
 115     if (c2) {
 116         len2 = c2->len;
 117     }
 118     if (len1 != len2) {
 119         return false;
 120     }
 121
 122     if (!len1) {
 123         return true;
 124     }
 125
 126     return !memcmp(c1->data, c2->data, len1);
 127 }
 128
 129 static void compare_child(gpointer, gpointer, gpointer);
 130
 131 static void compare_nodes(struct compare_walk *cw, XsNode *n1, XsNode *n2)
 132 {
 133     int nr_children1 = 0, nr_children2 = 0;
 134
 135     if (n1->children) {
 136         nr_children1 = g_hash_table_size(n1->children);
 137     }
 138     if (n2->children) {
 139         nr_children2 = g_hash_table_size(n2->children);
 140     }
 141
 142     if (n1->ref != n2->ref ||
 143         n1->deleted_in_tx != n2->deleted_in_tx ||
 144         n1->modified_in_tx != n2->modified_in_tx ||
 145         !compare_perms(n1->perms, n2->perms) ||
 146         !compare_content(n1->content, n2->content) ||
 147         nr_children1 != nr_children2) {
 148         cw->compare_ok = false;
 149         printf("Compare failure on '%s'\n", cw->path);
 150     }
 151
 152     if (nr_children1) {
 153         XsNode *oldparent = cw->parent_2;
 154         cw->parent_2 = n2;
 155         g_hash_table_foreach(n1->children, compare_child, cw);
 156
 157         cw->parent_2 = oldparent;
 158     }
 159 }
 160
 161 static void compare_child(gpointer key, gpointer val, gpointer opaque)
 162 {
 163     struct compare_walk *cw = opaque;
 164     char *childname = key;
 165     XsNode *child1 = val;
 166     XsNode *child2 = g_hash_table_lookup(cw->parent_2->children, childname);
 167     int pathlen = strlen(cw->path);
 168
 169     if (!child2) {
 170         cw->compare_ok = false;
 171         printf("Child '%s' does not exist under '%s'\n", childname, cw->path);
 172         return;
 173     }
 174
 175     strncat(cw->path, "/", sizeof(cw->path) - 1);
 176     strncat(cw->path, childname, sizeof(cw->path) - 1);
 177
 178     compare_nodes(cw, child1, child2);
 179     cw->path[pathlen] = '\0';
 180 }
 181
 182 static bool compare_trees(XsNode *n1, XsNode *n2)
 183 {
 184     struct compare_walk cw;
 185
 186     cw.path[0] = '\0';
 187     cw.parent_2 = n2;
 188     cw.compare_ok = true;
 189
 190     if (!n1 || !n2) {
 191         return false;
 192     }
 193
 194     compare_nodes(&cw, n1, n2);
 195     return cw.compare_ok;
 196 }
 197
 198 static void compare_tx(gpointer key, gpointer val, gpointer opaque)
 199 {
 200     XenstoreImplState *s2 = opaque;
 201     XsTransaction *t1 = val, *t2;
 202     unsigned int tx_id = GPOINTER_TO_INT(key);
 203
 204     t2 = g_hash_table_lookup(s2->transactions, key);
 205     g_assert(t2);
 206
 207     g_assert(t1->tx_id == tx_id);
 208     g_assert(t2->tx_id == tx_id);
 209     g_assert(t1->base_tx == t2->base_tx);
 210     g_assert(t1->dom_id == t2->dom_id);
 211     if (!compare_trees(t1->root, t2->root)) {
 212         printf("Comparison failure in TX %u after serdes:\n", tx_id);
 213         dump_ref("Original", t1->root, 0);
 214         dump_ref("Deserialised", t2->root, 0);
 215         g_assert(0);
 216     }
 217     g_assert(t1->nr_nodes == t2->nr_nodes);
 218 }
 219
 220 static int write_str(XenstoreImplState *s, unsigned int dom_id,
 221                           unsigned int tx_id, const char *path,
 222                           const char *content)
 223 {
 224     GByteArray *d = g_byte_array_new();
 225     int err;
 226
 227     g_byte_array_append(d, (void *)content, strlen(content));
 228     err = xs_impl_write(s, dom_id, tx_id, path, d);
 229     g_byte_array_unref(d);
 230     return err;
 231 }
 232
 233 static void watch_cb(void *_str, const char *path, const char *token)
 234 {
 235     GString *str = _str;
 236
 237     g_string_append(str, path);
 238     g_string_append(str, token);
 239 }
 240
 241 static void check_serdes(XenstoreImplState *s)
 242 {
 243     XenstoreImplState *s2 = xs_impl_create(DOMID_GUEST);
 244     GByteArray *bytes = xs_impl_serialize(s);
 245     int nr_transactions1, nr_transactions2;
 246     int ret;
 247
 248     ret = xs_impl_deserialize(s2, bytes, DOMID_GUEST, watch_cb, NULL);
 249     g_assert(!ret);
 250
 251     g_byte_array_unref(bytes);
 252
 253     g_assert(s->last_tx == s2->last_tx);
 254     g_assert(s->root_tx == s2->root_tx);
 255
 256     if (!compare_trees(s->root, s2->root)) {
 257         printf("Comparison failure in main tree after serdes:\n");
 258         dump_ref("Original", s->root, 0);
 259         dump_ref("Deserialised", s2->root, 0);
 260         g_assert(0);
 261     }
 262
 263     nr_transactions1 = g_hash_table_size(s->transactions);
 264     nr_transactions2 = g_hash_table_size(s2->transactions);
 265     g_assert(nr_transactions1 == nr_transactions2);
 266
 267     g_hash_table_foreach(s->transactions, compare_tx, s2);
 268
 269     g_assert(s->nr_domu_watches == s2->nr_domu_watches);
 270     g_assert(s->nr_domu_transactions == s2->nr_domu_transactions);
 271     g_assert(s->nr_nodes == s2->nr_nodes);
 272     xs_impl_delete(s2, false);
 273 }
 274
 275 static XenstoreImplState *setup(void)
 276 {
 277    XenstoreImplState *s = xs_impl_create(DOMID_GUEST);
 278    char *abspath;
 279    GList *perms;
 280    int err;
 281
 282    abspath = g_strdup_printf("/local/domain/%u", DOMID_GUEST);
 283
 284    err = write_str(s, DOMID_QEMU, XBT_NULL, abspath, "");
 285    g_assert(!err);
 286    g_assert(s->nr_nodes == 4);
 287
 288    perms = g_list_append(NULL, g_strdup_printf("n%u", DOMID_QEMU));
 289    perms = g_list_append(perms, g_strdup_printf("r%u", DOMID_GUEST));
 290
 291    err = xs_impl_set_perms(s, DOMID_QEMU, XBT_NULL, abspath, perms);
 292    g_assert(!err);
 293
 294    g_list_free_full(perms, g_free);
 295    g_free(abspath);
 296
 297    abspath = g_strdup_printf("/local/domain/%u/some", DOMID_GUEST);
 298
 299    err = write_str(s, DOMID_QEMU, XBT_NULL, abspath, "");
 300    g_assert(!err);
 301    g_assert(s->nr_nodes == 5);
 302
 303    perms = g_list_append(NULL, g_strdup_printf("n%u", DOMID_GUEST));
 304
 305    err = xs_impl_set_perms(s, DOMID_QEMU, XBT_NULL, abspath, perms);
 306    g_assert(!err);
 307
 308    g_list_free_full(perms, g_free);
 309    g_free(abspath);
 310
 311    return s;
 312 }
 313
 314 static void test_xs_node_simple(void)
 315 {
 316     GByteArray *data = g_byte_array_new();
 317     XenstoreImplState *s = setup();
 318     GString *guest_watches = g_string_new(NULL);
 319     GString *qemu_watches = g_string_new(NULL);
 320     GList *items = NULL;
 321     XsNode *old_root;
 322     uint64_t gencnt;
 323     int err;
 324
 325     g_assert(s);
 326
 327     err = xs_impl_watch(s, DOMID_GUEST, "some", "guestwatch",
 328                         watch_cb, guest_watches);
 329     g_assert(!err);
 330     g_assert(guest_watches->len == strlen("someguestwatch"));
 331     g_assert(!strcmp(guest_watches->str, "someguestwatch"));
 332     g_string_truncate(guest_watches, 0);
 333
 334     err = xs_impl_watch(s, 0, "/local/domain/1/some", "qemuwatch",
 335                         watch_cb, qemu_watches);
 336     g_assert(!err);
 337     g_assert(qemu_watches->len == strlen("/local/domain/1/someqemuwatch"));
 338     g_assert(!strcmp(qemu_watches->str, "/local/domain/1/someqemuwatch"));
 339     g_string_truncate(qemu_watches, 0);
 340
 341     /* Read gives ENOENT when it should */
 342     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "foo", data);
 343     g_assert(err == ENOENT);
 344
 345     /* Write works */
 346     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative/path",
 347                     "something");
 348     g_assert(s->nr_nodes == 7);
 349     g_assert(!err);
 350     g_assert(!strcmp(guest_watches->str,
 351                      "some/relative/pathguestwatch"));
 352     g_assert(!strcmp(qemu_watches->str,
 353                      "/local/domain/1/some/relative/pathqemuwatch"));
 354
 355     g_string_truncate(qemu_watches, 0);
 356     g_string_truncate(guest_watches, 0);
 357     xs_impl_reset_watches(s, 0);
 358
 359     /* Read gives back what we wrote */
 360     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative/path", data);
 361     g_assert(!err);
 362     g_assert(data->len == strlen("something"));
 363     g_assert(!memcmp(data->data, "something", data->len));
 364
 365     /* Even if we use an absolute path */
 366     g_byte_array_set_size(data, 0);
 367     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL,
 368                        "/local/domain/1/some/relative/path", data);
 369     g_assert(!err);
 370     g_assert(data->len == strlen("something"));
 371
 372     g_assert(!qemu_watches->len);
 373     g_assert(!guest_watches->len);
 374     /* Keep a copy, to force COW mode */
 375     old_root = xs_node_ref(s->root);
 376
 377     /* Write somewhere we aren't allowed, in COW mode */
 378     err = write_str(s, DOMID_GUEST, XBT_NULL, "/local/domain/badplace",
 379                     "moredata");
 380     g_assert(err == EACCES);
 381     g_assert(s->nr_nodes == 7);
 382
 383     /* Write works again */
 384     err = write_str(s, DOMID_GUEST, XBT_NULL,
 385                     "/local/domain/1/some/relative/path2",
 386                     "something else");
 387     g_assert(!err);
 388     g_assert(s->nr_nodes == 8);
 389     g_assert(!qemu_watches->len);
 390     g_assert(!strcmp(guest_watches->str, "some/relative/path2guestwatch"));
 391     g_string_truncate(guest_watches, 0);
 392
 393     /* Overwrite an existing node */
 394     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative/path",
 395                     "another thing");
 396     g_assert(!err);
 397     g_assert(s->nr_nodes == 8);
 398     g_assert(!qemu_watches->len);
 399     g_assert(!strcmp(guest_watches->str, "some/relative/pathguestwatch"));
 400     g_string_truncate(guest_watches, 0);
 401
 402     /* We can list the two files we wrote */
 403     err = xs_impl_directory(s, DOMID_GUEST, XBT_NULL, "some/relative", &gencnt,
 404                             &items);
 405     g_assert(!err);
 406     g_assert(items);
 407     g_assert(gencnt == 2);
 408     g_assert(!strcmp(items->data, "path"));
 409     g_assert(items->next);
 410     g_assert(!strcmp(items->next->data, "path2"));
 411     g_assert(!items->next->next);
 412     g_list_free_full(items, g_free);
 413
 414     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "guestwatch",
 415                           watch_cb, guest_watches);
 416     g_assert(!err);
 417
 418     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "guestwatch",
 419                           watch_cb, guest_watches);
 420     g_assert(err == ENOENT);
 421
 422     err = xs_impl_watch(s, DOMID_GUEST, "some/relative/path2", "watchp2",
 423                         watch_cb, guest_watches);
 424     g_assert(!err);
 425     g_assert(guest_watches->len == strlen("some/relative/path2watchp2"));
 426     g_assert(!strcmp(guest_watches->str, "some/relative/path2watchp2"));
 427     g_string_truncate(guest_watches, 0);
 428
 429     err = xs_impl_watch(s, DOMID_GUEST, "/local/domain/1/some/relative",
 430                         "watchrel", watch_cb, guest_watches);
 431     g_assert(!err);
 432     g_assert(guest_watches->len ==
 433              strlen("/local/domain/1/some/relativewatchrel"));
 434     g_assert(!strcmp(guest_watches->str,
 435                      "/local/domain/1/some/relativewatchrel"));
 436     g_string_truncate(guest_watches, 0);
 437
 438     /* Write somewhere else which already existed */
 439     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative", "moredata");
 440     g_assert(!err);
 441     g_assert(s->nr_nodes == 8);
 442
 443     /* Write somewhere we aren't allowed */
 444     err = write_str(s, DOMID_GUEST, XBT_NULL, "/local/domain/badplace",
 445                     "moredata");
 446     g_assert(err == EACCES);
 447
 448     g_assert(!strcmp(guest_watches->str,
 449                      "/local/domain/1/some/relativewatchrel"));
 450     g_string_truncate(guest_watches, 0);
 451
 452     g_byte_array_set_size(data, 0);
 453     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative", data);
 454     g_assert(!err);
 455     g_assert(data->len == strlen("moredata"));
 456     g_assert(!memcmp(data->data, "moredata", data->len));
 457
 458     /* Overwrite existing data */
 459     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative", "otherdata");
 460     g_assert(!err);
 461     g_string_truncate(guest_watches, 0);
 462
 463     g_byte_array_set_size(data, 0);
 464     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative", data);
 465     g_assert(!err);
 466     g_assert(data->len == strlen("otherdata"));
 467     g_assert(!memcmp(data->data, "otherdata", data->len));
 468
 469     /* Remove the subtree */
 470     err = xs_impl_rm(s, DOMID_GUEST, XBT_NULL, "some/relative");
 471     g_assert(!err);
 472     g_assert(s->nr_nodes == 5);
 473
 474     /* Each watch fires with the least specific relevant path */
 475     g_assert(strstr(guest_watches->str,
 476                     "some/relative/path2watchp2"));
 477     g_assert(strstr(guest_watches->str,
 478                     "/local/domain/1/some/relativewatchrel"));
 479     g_string_truncate(guest_watches, 0);
 480
 481     g_byte_array_set_size(data, 0);
 482     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative", data);
 483     g_assert(err == ENOENT);
 484     g_byte_array_unref(data);
 485
 486     xs_impl_reset_watches(s, DOMID_GUEST);
 487     g_string_free(qemu_watches, true);
 488     g_string_free(guest_watches, true);
 489     xs_node_unref(old_root);
 490     xs_impl_delete(s, true);
 491 }
 492
 493
 494 static void do_test_xs_node_tx(bool fail, bool commit)
 495 {
 496     XenstoreImplState *s = setup();
 497     GString *watches = g_string_new(NULL);
 498     GByteArray *data = g_byte_array_new();
 499     unsigned int tx_id = XBT_NULL;
 500     int err;
 501
 502     g_assert(s);
 503
 504     /* Set a watch */
 505     err = xs_impl_watch(s, DOMID_GUEST, "some", "watch",
 506                         watch_cb, watches);
 507     g_assert(!err);
 508     g_assert(watches->len == strlen("somewatch"));
 509     g_assert(!strcmp(watches->str, "somewatch"));
 510     g_string_truncate(watches, 0);
 511
 512     /* Write something */
 513     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative/path",
 514                     "something");
 515     g_assert(s->nr_nodes == 7);
 516     g_assert(!err);
 517     g_assert(!strcmp(watches->str,
 518                      "some/relative/pathwatch"));
 519     g_string_truncate(watches, 0);
 520
 521     /* Create a transaction */
 522     err = xs_impl_transaction_start(s, DOMID_GUEST, &tx_id);
 523     g_assert(!err);
 524
 525     if (fail) {
 526         /* Write something else in the root */
 527         err = write_str(s, DOMID_GUEST, XBT_NULL, "some/relative/path",
 528                         "another thing");
 529         g_assert(!err);
 530         g_assert(s->nr_nodes == 7);
 531         g_assert(!strcmp(watches->str,
 532                          "some/relative/pathwatch"));
 533         g_string_truncate(watches, 0);
 534     }
 535
 536     g_assert(!watches->len);
 537
 538     /* Perform a write in the transaction */
 539     err = write_str(s, DOMID_GUEST, tx_id, "some/relative/path",
 540                     "something else");
 541     g_assert(!err);
 542     g_assert(s->nr_nodes == 7);
 543     g_assert(!watches->len);
 544
 545     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative/path", data);
 546     g_assert(!err);
 547     if (fail) {
 548         g_assert(data->len == strlen("another thing"));
 549         g_assert(!memcmp(data->data, "another thing", data->len));
 550     } else {
 551         g_assert(data->len == strlen("something"));
 552         g_assert(!memcmp(data->data, "something", data->len));
 553     }
 554     g_byte_array_set_size(data, 0);
 555
 556     err = xs_impl_read(s, DOMID_GUEST, tx_id, "some/relative/path", data);
 557     g_assert(!err);
 558     g_assert(data->len == strlen("something else"));
 559     g_assert(!memcmp(data->data, "something else", data->len));
 560     g_byte_array_set_size(data, 0);
 561
 562     check_serdes(s);
 563
 564     /* Attempt to commit the transaction */
 565     err = xs_impl_transaction_end(s, DOMID_GUEST, tx_id, commit);
 566     if (commit && fail) {
 567         g_assert(err == EAGAIN);
 568     } else {
 569         g_assert(!err);
 570     }
 571     if (commit && !fail) {
 572         g_assert(!strcmp(watches->str,
 573                          "some/relative/pathwatch"));
 574         g_string_truncate(watches, 0);
 575     } else {
 576        g_assert(!watches->len);
 577     }
 578     g_assert(s->nr_nodes == 7);
 579
 580     check_serdes(s);
 581
 582     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "watch",
 583                         watch_cb, watches);
 584     g_assert(!err);
 585
 586     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/relative/path", data);
 587     g_assert(!err);
 588     if (fail) {
 589         g_assert(data->len == strlen("another thing"));
 590         g_assert(!memcmp(data->data, "another thing", data->len));
 591     } else if (commit) {
 592         g_assert(data->len == strlen("something else"));
 593         g_assert(!memcmp(data->data, "something else", data->len));
 594     } else {
 595         g_assert(data->len == strlen("something"));
 596         g_assert(!memcmp(data->data, "something", data->len));
 597     }
 598     g_byte_array_unref(data);
 599     g_string_free(watches, true);
 600     xs_impl_delete(s, true);
 601 }
 602
 603 static void test_xs_node_tx_fail(void)
 604 {
 605     do_test_xs_node_tx(true, true);
 606 }
 607
 608 static void test_xs_node_tx_abort(void)
 609 {
 610     do_test_xs_node_tx(false, false);
 611     do_test_xs_node_tx(true, false);
 612 }
 613 static void test_xs_node_tx_succeed(void)
 614 {
 615     do_test_xs_node_tx(false, true);
 616 }
 617
 618 static void test_xs_node_tx_rm(void)
 619 {
 620     XenstoreImplState *s = setup();
 621     GString *watches = g_string_new(NULL);
 622     GByteArray *data = g_byte_array_new();
 623     unsigned int tx_id = XBT_NULL;
 624     int err;
 625
 626     g_assert(s);
 627
 628     /* Set a watch */
 629     err = xs_impl_watch(s, DOMID_GUEST, "some", "watch",
 630                         watch_cb, watches);
 631     g_assert(!err);
 632     g_assert(watches->len == strlen("somewatch"));
 633     g_assert(!strcmp(watches->str, "somewatch"));
 634     g_string_truncate(watches, 0);
 635
 636     /* Write something */
 637     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 638                     "something");
 639     g_assert(!err);
 640     g_assert(s->nr_nodes == 9);
 641     g_assert(!strcmp(watches->str,
 642                      "some/deep/dark/relative/pathwatch"));
 643     g_string_truncate(watches, 0);
 644
 645     /* Create a transaction */
 646     err = xs_impl_transaction_start(s, DOMID_GUEST, &tx_id);
 647     g_assert(!err);
 648
 649     /* Delete the tree in the transaction */
 650     err = xs_impl_rm(s, DOMID_GUEST, tx_id, "some/deep/dark");
 651     g_assert(!err);
 652     g_assert(s->nr_nodes == 9);
 653     g_assert(!watches->len);
 654
 655     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 656                        data);
 657     g_assert(!err);
 658     g_assert(data->len == strlen("something"));
 659     g_assert(!memcmp(data->data, "something", data->len));
 660     g_byte_array_set_size(data, 0);
 661
 662     check_serdes(s);
 663
 664     /* Commit the transaction */
 665     err = xs_impl_transaction_end(s, DOMID_GUEST, tx_id, true);
 666     g_assert(!err);
 667     g_assert(s->nr_nodes == 6);
 668
 669     g_assert(!strcmp(watches->str, "some/deep/darkwatch"));
 670     g_string_truncate(watches, 0);
 671
 672     /* Now the node is gone */
 673     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 674                        data);
 675     g_assert(err == ENOENT);
 676     g_byte_array_unref(data);
 677
 678     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "watch",
 679                         watch_cb, watches);
 680     g_assert(!err);
 681
 682     g_string_free(watches, true);
 683     xs_impl_delete(s, true);
 684 }
 685
 686 static void test_xs_node_tx_resurrect(void)
 687 {
 688     XenstoreImplState *s = setup();
 689     GString *watches = g_string_new(NULL);
 690     GByteArray *data = g_byte_array_new();
 691     unsigned int tx_id = XBT_NULL;
 692     int err;
 693
 694     g_assert(s);
 695
 696     /* Write something */
 697     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 698                     "something");
 699     g_assert(!err);
 700     g_assert(s->nr_nodes == 9);
 701
 702     /* Another node to remain shared */
 703     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/place/safe", "keepme");
 704     g_assert(!err);
 705     g_assert(s->nr_nodes == 11);
 706
 707     /* This node will be wiped and resurrected */
 708     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/deep/dark",
 709                     "foo");
 710     g_assert(!err);
 711     g_assert(s->nr_nodes == 11);
 712
 713     /* Set a watch */
 714     err = xs_impl_watch(s, DOMID_GUEST, "some", "watch",
 715                         watch_cb, watches);
 716     g_assert(!err);
 717     g_assert(watches->len == strlen("somewatch"));
 718     g_assert(!strcmp(watches->str, "somewatch"));
 719     g_string_truncate(watches, 0);
 720
 721     /* Create a transaction */
 722     err = xs_impl_transaction_start(s, DOMID_GUEST, &tx_id);
 723     g_assert(!err);
 724
 725     /* Delete the tree in the transaction */
 726     err = xs_impl_rm(s, DOMID_GUEST, tx_id, "some/deep");
 727     g_assert(!err);
 728     g_assert(s->nr_nodes == 11);
 729     g_assert(!watches->len);
 730
 731     /* Resurrect part of it */
 732     err = write_str(s, DOMID_GUEST, tx_id, "some/deep/dark/different/path",
 733                     "something");
 734     g_assert(!err);
 735     g_assert(s->nr_nodes == 11);
 736
 737     check_serdes(s);
 738
 739     /* Commit the transaction */
 740     err = xs_impl_transaction_end(s, DOMID_GUEST, tx_id, true);
 741     g_assert(!err);
 742     g_assert(s->nr_nodes == 11);
 743
 744     check_serdes(s);
 745
 746     /* lost data */
 747     g_assert(strstr(watches->str, "some/deep/dark/different/pathwatch"));
 748     /* topmost deleted */
 749     g_assert(strstr(watches->str, "some/deep/dark/relativewatch"));
 750     /* lost data */
 751     g_assert(strstr(watches->str, "some/deep/darkwatch"));
 752
 753     g_string_truncate(watches, 0);
 754
 755     /* Now the node is gone */
 756     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 757                        data);
 758     g_assert(err == ENOENT);
 759     g_byte_array_unref(data);
 760
 761     check_serdes(s);
 762
 763     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "watch",
 764                         watch_cb, watches);
 765     g_assert(!err);
 766
 767     g_string_free(watches, true);
 768     xs_impl_delete(s, true);
 769 }
 770
 771 static void test_xs_node_tx_resurrect2(void)
 772 {
 773     XenstoreImplState *s = setup();
 774     GString *watches = g_string_new(NULL);
 775     GByteArray *data = g_byte_array_new();
 776     unsigned int tx_id = XBT_NULL;
 777     int err;
 778
 779     g_assert(s);
 780
 781     /* Write something */
 782     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 783                     "something");
 784     g_assert(!err);
 785     g_assert(s->nr_nodes == 9);
 786
 787     /* Another node to remain shared */
 788     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/place/safe", "keepme");
 789     g_assert(!err);
 790     g_assert(s->nr_nodes == 11);
 791
 792     /* This node will be wiped and resurrected */
 793     err = write_str(s, DOMID_GUEST, XBT_NULL, "some/deep/dark",
 794                     "foo");
 795     g_assert(!err);
 796     g_assert(s->nr_nodes == 11);
 797
 798     /* Set a watch */
 799     err = xs_impl_watch(s, DOMID_GUEST, "some", "watch",
 800                         watch_cb, watches);
 801     g_assert(!err);
 802     g_assert(watches->len == strlen("somewatch"));
 803     g_assert(!strcmp(watches->str, "somewatch"));
 804     g_string_truncate(watches, 0);
 805
 806     /* Create a transaction */
 807     err = xs_impl_transaction_start(s, DOMID_GUEST, &tx_id);
 808     g_assert(!err);
 809
 810     /* Delete the tree in the transaction */
 811     err = xs_impl_rm(s, DOMID_GUEST, tx_id, "some/deep");
 812     g_assert(!err);
 813     g_assert(s->nr_nodes == 11);
 814     g_assert(!watches->len);
 815
 816     /* Resurrect part of it */
 817     err = write_str(s, DOMID_GUEST, tx_id, "some/deep/dark/relative/path",
 818                     "something");
 819     g_assert(!err);
 820     g_assert(s->nr_nodes == 11);
 821
 822     check_serdes(s);
 823
 824     /* Commit the transaction */
 825     err = xs_impl_transaction_end(s, DOMID_GUEST, tx_id, true);
 826     g_assert(!err);
 827     g_assert(s->nr_nodes == 11);
 828
 829     check_serdes(s);
 830
 831     /* lost data */
 832     g_assert(strstr(watches->str, "some/deep/dark/relative/pathwatch"));
 833     /* lost data */
 834     g_assert(strstr(watches->str, "some/deep/darkwatch"));
 835
 836     g_string_truncate(watches, 0);
 837
 838     /* Now the node is gone */
 839     err = xs_impl_read(s, DOMID_GUEST, XBT_NULL, "some/deep/dark/relative/path",
 840                        data);
 841     g_assert(!err);
 842     g_assert(data->len == strlen("something"));
 843     g_assert(!memcmp(data->data, "something", data->len));
 844
 845     g_byte_array_unref(data);
 846
 847     check_serdes(s);
 848
 849     err = xs_impl_unwatch(s, DOMID_GUEST, "some", "watch",
 850                         watch_cb, watches);
 851     g_assert(!err);
 852
 853     g_string_free(watches, true);
 854     xs_impl_delete(s, true);
 855 }
 856
 857 int main(int argc, char **argv)
 858 {
 859     g_test_init(&argc, &argv, NULL);
 860     module_call_init(MODULE_INIT_QOM);
 861
 862     g_test_add_func("/xs_node/simple", test_xs_node_simple);
 863     g_test_add_func("/xs_node/tx_abort", test_xs_node_tx_abort);
 864     g_test_add_func("/xs_node/tx_fail", test_xs_node_tx_fail);
 865     g_test_add_func("/xs_node/tx_succeed", test_xs_node_tx_succeed);
 866     g_test_add_func("/xs_node/tx_rm", test_xs_node_tx_rm);
 867     g_test_add_func("/xs_node/tx_resurrect", test_xs_node_tx_resurrect);
 868     g_test_add_func("/xs_node/tx_resurrect2", test_xs_node_tx_resurrect2);
 869
 870     return g_test_run();
 871 }