contrib/lvm2/dist/lib/activate/dev_manager.c

   1 /*      $NetBSD: dev_manager.c,v 1.1.1.3 2009/12/02 00:26:23 haad Exp $ */
   2
   3 /*
   4  * Copyright (C) 2002-2004 Sistina Software, Inc. All rights reserved.
   5  * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
   6  *
   7  * This file is part of LVM2.
   8  *
   9  * This copyrighted material is made available to anyone wishing to use,
  10  * modify, copy, or redistribute it subject to the terms and conditions
  11  * of the GNU Lesser General Public License v.2.1.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this program; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  16  */
  17
  18 #include "lib.h"
  19 #include "str_list.h"
  20 #include "dev_manager.h"
  21 #include "lvm-string.h"
  22 #include "fs.h"
  23 #include "defaults.h"
  24 #include "segtype.h"
  25 #include "display.h"
  26 #include "toolcontext.h"
  27 #include "targets.h"
  28 #include "config.h"
  29 #include "filter.h"
  30 #include "activate.h"
  31
  32 #include <limits.h>
  33 #include <dirent.h>
  34
  35 #define MAX_TARGET_PARAMSIZE 50000
  36 #define UUID_PREFIX "LVM-"
  37
  38 typedef enum {
  39         PRELOAD,
  40         ACTIVATE,
  41         DEACTIVATE,
  42         SUSPEND,
  43         SUSPEND_WITH_LOCKFS,
  44         CLEAN
  45 } action_t;
  46
  47 struct dev_manager {
  48         struct dm_pool *mem;
  49
  50         struct cmd_context *cmd;
  51
  52         void *target_state;
  53         uint32_t pvmove_mirror_count;
  54         int flush_required;
  55
  56         char *vg_name;
  57 };
  58
  59 struct lv_layer {
  60         struct logical_volume *lv;
  61         const char *old_name;
  62 };
  63
  64 static char *_build_dlid(struct dm_pool *mem, const char *lvid, const char *layer)
  65 {
  66         char *dlid;
  67         size_t len;
  68
  69         if (!layer)
  70                 layer = "";
  71
  72         len = sizeof(UUID_PREFIX) + sizeof(union lvid) + strlen(layer);
  73
  74         if (!(dlid = dm_pool_alloc(mem, len))) {
  75                 log_error("_build_dlid: pool allocation failed for %" PRIsize_t
  76                           " %s %s.", len, lvid, layer);
  77                 return NULL;
  78         }
  79
  80         sprintf(dlid, UUID_PREFIX "%s%s%s", lvid, (*layer) ? "-" : "", layer);
  81
  82         return dlid;
  83 }
  84
  85 char *build_dlid(struct dev_manager *dm, const char *lvid, const char *layer)
  86 {
  87         return _build_dlid(dm->mem, lvid, layer);
  88 }
  89
  90 static int _read_only_lv(struct logical_volume *lv)
  91 {
  92         return (!(lv->vg->status & LVM_WRITE) || !(lv->status & LVM_WRITE));
  93 }
  94
  95 /*
  96  * Low level device-layer operations.
  97  */
  98 static struct dm_task *_setup_task(const char *name, const char *uuid,
  99                                    uint32_t *event_nr, int task,
 100                                    uint32_t major, uint32_t minor)
 101 {
 102         struct dm_task *dmt;
 103
 104         if (!(dmt = dm_task_create(task)))
 105                 return_NULL;
 106
 107         if (name)
 108                 dm_task_set_name(dmt, name);
 109
 110         if (uuid && *uuid)
 111                 dm_task_set_uuid(dmt, uuid);
 112
 113         if (event_nr)
 114                 dm_task_set_event_nr(dmt, *event_nr);
 115
 116         if (major)
 117                 dm_task_set_major_minor(dmt, major, minor, 1);
 118
 119         return dmt;
 120 }
 121
 122 static int _info_run(const char *name, const char *dlid, struct dm_info *info,
 123                      uint32_t *read_ahead, int mknodes, int with_open_count,
 124                      int with_read_ahead, uint32_t major, uint32_t minor)
 125 {
 126         int r = 0;
 127         struct dm_task *dmt;
 128         int dmtask;
 129
 130         dmtask = mknodes ? DM_DEVICE_MKNODES : DM_DEVICE_INFO;
 131
 132         if (!(dmt = _setup_task(name, dlid, 0, dmtask, major, minor)))
 133                 return_0;
 134
 135         if (!with_open_count)
 136                 if (!dm_task_no_open_count(dmt))
 137                         log_error("Failed to disable open_count");
 138
 139         if (!dm_task_run(dmt))
 140                 goto_out;
 141
 142         if (!dm_task_get_info(dmt, info))
 143                 goto_out;
 144
 145         if (with_read_ahead && info->exists) {
 146                 if (!dm_task_get_read_ahead(dmt, read_ahead))
 147                         goto_out;
 148         } else if (read_ahead)
 149                 *read_ahead = DM_READ_AHEAD_NONE;
 150
 151         r = 1;
 152
 153       out:
 154         dm_task_destroy(dmt);
 155         return r;
 156 }
 157
 158 int device_is_usable(dev_t dev)
 159 {
 160         struct dm_task *dmt;
 161         struct dm_info info;
 162         const char *name;
 163         uint64_t start, length;
 164         char *target_type = NULL;
 165         char *params;
 166         void *next = NULL;
 167         int r = 0;
 168
 169         if (!(dmt = dm_task_create(DM_DEVICE_STATUS))) {
 170                 log_error("Failed to allocate dm_task struct to check dev status");
 171                 return 0;
 172         }
 173
 174         if (!dm_task_set_major_minor(dmt, MAJOR(dev), MINOR(dev), 1))
 175                 goto_out;
 176
 177         if (!dm_task_run(dmt)) {
 178                 log_error("Failed to get state of mapped device");
 179                 goto out;
 180         }
 181
 182         if (!dm_task_get_info(dmt, &info))
 183                 goto_out;
 184
 185         if (!info.exists || info.suspended)
 186                 goto out;
 187
 188         name = dm_task_get_name(dmt);
 189
 190         /* FIXME Also check for mirror block_on_error and mpath no paths */
 191         /* For now, we exclude all mirrors */
 192
 193         do {
 194                 next = dm_get_next_target(dmt, next, &start, &length,
 195                                           &target_type, &params);
 196                 /* Skip if target type doesn't match */
 197                 if (target_type && !strcmp(target_type, "mirror"))
 198                         goto out;
 199         } while (next);
 200
 201         /* FIXME Also check dependencies? */
 202
 203         r = 1;
 204
 205       out:
 206         dm_task_destroy(dmt);
 207         return r;
 208 }
 209
 210 static int _info(const char *name, const char *dlid, int mknodes,
 211                  int with_open_count, int with_read_ahead,
 212                  struct dm_info *info, uint32_t *read_ahead)
 213 {
 214         if (!mknodes && dlid && *dlid) {
 215                 if (_info_run(NULL, dlid, info, read_ahead, 0, with_open_count,
 216                               with_read_ahead, 0, 0) &&
 217                     info->exists)
 218                         return 1;
 219                 else if (_info_run(NULL, dlid + sizeof(UUID_PREFIX) - 1, info,
 220                                    read_ahead, 0, with_open_count,
 221                                    with_read_ahead, 0, 0) &&
 222                          info->exists)
 223                         return 1;
 224         }
 225
 226         if (name)
 227                 return _info_run(name, NULL, info, read_ahead, mknodes,
 228                                  with_open_count, with_read_ahead, 0, 0);
 229
 230         return 0;
 231 }
 232
 233 static int _info_by_dev(uint32_t major, uint32_t minor, struct dm_info *info)
 234 {
 235         return _info_run(NULL, NULL, info, NULL, 0, 0, 0, major, minor);
 236 }
 237
 238 int dev_manager_info(struct dm_pool *mem, const char *name,
 239                      const struct logical_volume *lv, int with_mknodes,
 240                      int with_open_count, int with_read_ahead,
 241                      struct dm_info *info, uint32_t *read_ahead)
 242 {
 243         const char *dlid;
 244
 245         if (!(dlid = _build_dlid(mem, lv->lvid.s, NULL))) {
 246                 log_error("dlid build failed for %s", lv->name);
 247                 return 0;
 248         }
 249
 250         return _info(name, dlid, with_mknodes, with_open_count, with_read_ahead,
 251                      info, read_ahead);
 252 }
 253
 254 /* FIXME Interface must cope with multiple targets */
 255 static int _status_run(const char *name, const char *uuid,
 256                        unsigned long long *s, unsigned long long *l,
 257                        char **t, uint32_t t_size, char **p, uint32_t p_size)
 258 {
 259         int r = 0;
 260         struct dm_task *dmt;
 261         struct dm_info info;
 262         void *next = NULL;
 263         uint64_t start, length;
 264         char *type = NULL;
 265         char *params = NULL;
 266
 267         if (!(dmt = _setup_task(name, uuid, 0, DM_DEVICE_STATUS, 0, 0)))
 268                 return_0;
 269
 270         if (!dm_task_no_open_count(dmt))
 271                 log_error("Failed to disable open_count");
 272
 273         if (!dm_task_run(dmt))
 274                 goto_out;
 275
 276         if (!dm_task_get_info(dmt, &info) || !info.exists)
 277                 goto_out;
 278
 279         do {
 280                 next = dm_get_next_target(dmt, next, &start, &length,
 281                                           &type, &params);
 282                 if (type) {
 283                         *s = start;
 284                         *l = length;
 285                         /* Make sure things are null terminated */
 286                         strncpy(*t, type, t_size);
 287                         (*t)[t_size - 1] = '\0';
 288                         strncpy(*p, params, p_size);
 289                         (*p)[p_size - 1] = '\0';
 290
 291                         r = 1;
 292                         /* FIXME Cope with multiple targets! */
 293                         break;
 294                 }
 295
 296         } while (next);
 297
 298       out:
 299         dm_task_destroy(dmt);
 300         return r;
 301 }
 302
 303 static int _status(const char *name, const char *uuid,
 304                    unsigned long long *start, unsigned long long *length,
 305                    char **type, uint32_t type_size, char **params,
 306                    uint32_t param_size) __attribute__ ((unused));
 307
 308 static int _status(const char *name, const char *uuid,
 309                    unsigned long long *start, unsigned long long *length,
 310                    char **type, uint32_t type_size, char **params,
 311                    uint32_t param_size)
 312 {
 313         if (uuid && *uuid) {
 314                 if (_status_run(NULL, uuid, start, length, type,
 315                                 type_size, params, param_size) &&
 316                     *params)
 317                         return 1;
 318                 else if (_status_run(NULL, uuid + sizeof(UUID_PREFIX) - 1, start,
 319                                      length, type, type_size, params,
 320                                      param_size) &&
 321                          *params)
 322                         return 1;
 323         }
 324
 325         if (name && _status_run(name, NULL, start, length, type, type_size,
 326                                 params, param_size))
 327                 return 1;
 328
 329         return 0;
 330 }
 331
 332 static percent_range_t _combine_percent_ranges(percent_range_t a,
 333                                                percent_range_t b)
 334 {
 335         if (a == PERCENT_INVALID || b == PERCENT_INVALID)
 336                 return PERCENT_INVALID;
 337
 338         if (a == PERCENT_100 && b == PERCENT_100)
 339                 return PERCENT_100;
 340
 341         if (a == PERCENT_0 && b == PERCENT_0)
 342                 return PERCENT_0;
 343
 344         return PERCENT_0_TO_100;
 345 }
 346
 347 static int _percent_run(struct dev_manager *dm, const char *name,
 348                         const char *dlid,
 349                         const char *target_type, int wait,
 350                         struct logical_volume *lv, float *percent,
 351                         percent_range_t *overall_percent_range,
 352                         uint32_t *event_nr)
 353 {
 354         int r = 0;
 355         struct dm_task *dmt;
 356         struct dm_info info;
 357         void *next = NULL;
 358         uint64_t start, length;
 359         char *type = NULL;
 360         char *params = NULL;
 361         struct dm_list *segh = &lv->segments;
 362         struct lv_segment *seg = NULL;
 363         struct segment_type *segtype;
 364         percent_range_t percent_range = 0, combined_percent_range = 0;
 365         int first_time = 1;
 366
 367         uint64_t total_numerator = 0, total_denominator = 0;
 368
 369         *percent = -1;
 370         *overall_percent_range = PERCENT_INVALID;
 371
 372         if (!(dmt = _setup_task(name, dlid, event_nr,
 373                                 wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS, 0, 0)))
 374                 return_0;
 375
 376         if (!dm_task_no_open_count(dmt))
 377                 log_error("Failed to disable open_count");
 378
 379         if (!dm_task_run(dmt))
 380                 goto_out;
 381
 382         if (!dm_task_get_info(dmt, &info) || !info.exists)
 383                 goto_out;
 384
 385         if (event_nr)
 386                 *event_nr = info.event_nr;
 387
 388         do {
 389                 next = dm_get_next_target(dmt, next, &start, &length, &type,
 390                                           &params);
 391                 if (lv) {
 392                         if (!(segh = dm_list_next(&lv->segments, segh))) {
 393                                 log_error("Number of segments in active LV %s "
 394                                           "does not match metadata", lv->name);
 395                                 goto out;
 396                         }
 397                         seg = dm_list_item(segh, struct lv_segment);
 398                 }
 399
 400                 if (!type || !params || strcmp(type, target_type))
 401                         continue;
 402
 403                 if (!(segtype = get_segtype_from_string(dm->cmd, type)))
 404                         continue;
 405
 406                 if (segtype->ops->target_percent &&
 407                     !segtype->ops->target_percent(&dm->target_state,
 408                                                   &percent_range, dm->mem,
 409                                                   dm->cmd, seg, params,
 410                                                   &total_numerator,
 411                                                   &total_denominator))
 412                         goto_out;
 413
 414                 if (first_time) {
 415                         combined_percent_range = percent_range;
 416                         first_time = 0;
 417                 } else
 418                         combined_percent_range =
 419                             _combine_percent_ranges(combined_percent_range,
 420                                                     percent_range);
 421         } while (next);
 422
 423         if (lv && (segh = dm_list_next(&lv->segments, segh))) {
 424                 log_error("Number of segments in active LV %s does not "
 425                           "match metadata", lv->name);
 426                 goto out;
 427         }
 428
 429         if (total_denominator) {
 430                 *percent = (float) total_numerator *100 / total_denominator;
 431                 *overall_percent_range = combined_percent_range;
 432         } else {
 433                 *percent = 100;
 434                 if (first_time)
 435                         *overall_percent_range = PERCENT_100;
 436                 else
 437                         *overall_percent_range = combined_percent_range;
 438         }
 439
 440         log_debug("LV percent: %f", *percent);
 441         r = 1;
 442
 443       out:
 444         dm_task_destroy(dmt);
 445         return r;
 446 }
 447
 448 static int _percent(struct dev_manager *dm, const char *name, const char *dlid,
 449                     const char *target_type, int wait,
 450                     struct logical_volume *lv, float *percent,
 451                     percent_range_t *overall_percent_range, uint32_t *event_nr)
 452 {
 453         if (dlid && *dlid) {
 454                 if (_percent_run(dm, NULL, dlid, target_type, wait, lv, percent,
 455                                  overall_percent_range, event_nr))
 456                         return 1;
 457                 else if (_percent_run(dm, NULL, dlid + sizeof(UUID_PREFIX) - 1,
 458                                       target_type, wait, lv, percent,
 459                                       overall_percent_range, event_nr))
 460                         return 1;
 461         }
 462
 463         if (name && _percent_run(dm, name, NULL, target_type, wait, lv, percent,
 464                                  overall_percent_range, event_nr))
 465                 return 1;
 466
 467         return 0;
 468 }
 469
 470 /*
 471  * dev_manager implementation.
 472  */
 473 struct dev_manager *dev_manager_create(struct cmd_context *cmd,
 474                                        const char *vg_name)
 475 {
 476         struct dm_pool *mem;
 477         struct dev_manager *dm;
 478
 479         if (!(mem = dm_pool_create("dev_manager", 16 * 1024)))
 480                 return_NULL;
 481
 482         if (!(dm = dm_pool_zalloc(mem, sizeof(*dm))))
 483                 goto_bad;
 484
 485         dm->cmd = cmd;
 486         dm->mem = mem;
 487
 488         if (!(dm->vg_name = dm_pool_strdup(dm->mem, vg_name)))
 489                 goto_bad;
 490
 491         dm->target_state = NULL;
 492
 493         dm_udev_set_sync_support(cmd->current_settings.udev_sync);
 494
 495         return dm;
 496
 497       bad:
 498         dm_pool_destroy(mem);
 499         return NULL;
 500 }
 501
 502 void dev_manager_destroy(struct dev_manager *dm)
 503 {
 504         dm_pool_destroy(dm->mem);
 505 }
 506
 507 void dev_manager_release(void)
 508 {
 509         dm_lib_release();
 510 }
 511
 512 void dev_manager_exit(void)
 513 {
 514         dm_lib_exit();
 515 }
 516
 517 int dev_manager_snapshot_percent(struct dev_manager *dm,
 518                                  const struct logical_volume *lv,
 519                                  float *percent, percent_range_t *percent_range)
 520 {
 521         char *name;
 522         const char *dlid;
 523
 524         /*
 525          * Build a name for the top layer.
 526          */
 527         if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, NULL)))
 528                 return_0;
 529
 530         if (!(dlid = build_dlid(dm, lv->lvid.s, NULL)))
 531                 return_0;
 532
 533         /*
 534          * Try and get some info on this device.
 535          */
 536         log_debug("Getting device status percentage for %s", name);
 537         if (!(_percent(dm, name, dlid, "snapshot", 0, NULL, percent,
 538                        percent_range, NULL)))
 539                 return_0;
 540
 541         /* FIXME dm_pool_free ? */
 542
 543         /* If the snapshot isn't available, percent will be -1 */
 544         return 1;
 545 }
 546
 547 /* FIXME Merge with snapshot_percent, auto-detecting target type */
 548 /* FIXME Cope with more than one target */
 549 int dev_manager_mirror_percent(struct dev_manager *dm,
 550                                struct logical_volume *lv, int wait,
 551                                float *percent, percent_range_t *percent_range,
 552                                uint32_t *event_nr)
 553 {
 554         char *name;
 555         const char *dlid;
 556         const char *suffix = (lv_is_origin(lv)) ? "real" : NULL;
 557
 558         /*
 559          * Build a name for the top layer.
 560          */
 561         if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, suffix)))
 562                 return_0;
 563
 564         /* FIXME dm_pool_free ? */
 565
 566         if (!(dlid = build_dlid(dm, lv->lvid.s, suffix))) {
 567                 log_error("dlid build failed for %s", lv->name);
 568                 return 0;
 569         }
 570
 571         log_debug("Getting device mirror status percentage for %s", name);
 572         if (!(_percent(dm, name, dlid, "mirror", wait, lv, percent,
 573                        percent_range, event_nr)))
 574                 return_0;
 575
 576         return 1;
 577 }
 578
 579 #if 0
 580         log_very_verbose("%s %s", sus ? "Suspending" : "Resuming", name);
 581
 582         log_verbose("Loading %s", dl->name);
 583                         log_very_verbose("Activating %s read-only", dl->name);
 584         log_very_verbose("Activated %s %s %03u:%03u", dl->name,
 585                          dl->dlid, dl->info.major, dl->info.minor);
 586
 587         if (_get_flag(dl, VISIBLE))
 588                 log_verbose("Removing %s", dl->name);
 589         else
 590                 log_very_verbose("Removing %s", dl->name);
 591
 592         log_debug("Adding target: %" PRIu64 " %" PRIu64 " %s %s",
 593                   extent_size * seg->le, extent_size * seg->len, target, params);
 594
 595         log_debug("Adding target: 0 %" PRIu64 " snapshot-origin %s",
 596                   dl->lv->size, params);
 597         log_debug("Adding target: 0 %" PRIu64 " snapshot %s", size, params);
 598         log_debug("Getting device info for %s", dl->name);
 599
 600         /* Rename? */
 601                 if ((suffix = strrchr(dl->dlid + sizeof(UUID_PREFIX) - 1, '-')))
 602                         suffix++;
 603                 new_name = build_dm_name(dm->mem, dm->vg_name, dl->lv->name,
 604                                         suffix);
 605
 606 static int _belong_to_vg(const char *vgname, const char *name)
 607 {
 608         const char *v = vgname, *n = name;
 609
 610         while (*v) {
 611                 if ((*v != *n) || (*v == '-' && *(++n) != '-'))
 612                         return 0;
 613                 v++, n++;
 614         }
 615
 616         if (*n == '-' && *(n + 1) != '-')
 617                 return 1;
 618         else
 619                 return 0;
 620 }
 621
 622         if (!(snap_seg = find_cow(lv)))
 623                 return 1;
 624
 625         old_origin = snap_seg->origin;
 626
 627         /* Was this the last active snapshot with this origin? */
 628         dm_list_iterate_items(lvl, active_head) {
 629                 active = lvl->lv;
 630                 if ((snap_seg = find_cow(active)) &&
 631                     snap_seg->origin == old_origin) {
 632                         return 1;
 633                 }
 634         }
 635
 636 #endif
 637
 638 /*************************/
 639 /*  NEW CODE STARTS HERE */
 640 /*************************/
 641
 642 int dev_manager_lv_mknodes(const struct logical_volume *lv)
 643 {
 644         char *name;
 645
 646         if (!(name = build_dm_name(lv->vg->cmd->mem, lv->vg->name,
 647                                    lv->name, NULL)))
 648                 return_0;
 649
 650         return fs_add_lv(lv, name);
 651 }
 652
 653 int dev_manager_lv_rmnodes(const struct logical_volume *lv)
 654 {
 655         return fs_del_lv(lv);
 656 }
 657
 658 static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 659                                struct logical_volume *lv, const char *layer)
 660 {
 661         char *dlid, *name;
 662         struct dm_info info, info2;
 663
 664         if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
 665                 return_0;
 666
 667         if (!(dlid = build_dlid(dm, lv->lvid.s, layer)))
 668                 return_0;
 669
 670         log_debug("Getting device info for %s [%s]", name, dlid);
 671         if (!_info(name, dlid, 0, 1, 0, &info, NULL)) {
 672                 log_error("Failed to get info for %s [%s].", name, dlid);
 673                 return 0;
 674         }
 675
 676         /*
 677          * For top level volumes verify that existing device match
 678          * requested major/minor and that major/minor pair is available for use
 679          */
 680         if (!layer && lv->major != -1 && lv->minor != -1) {
 681                 /*
 682                  * FIXME compare info.major with lv->major if multiple major support
 683                  */
 684                 if (info.exists && (info.minor != lv->minor)) {
 685                         log_error("Volume %s (%" PRIu32 ":%" PRIu32")"
 686                                   " differs from already active device "
 687                                   "(%" PRIu32 ":%" PRIu32")",
 688                                   lv->name, lv->major, lv->minor, info.major, info.minor);
 689                         return 0;
 690                 }
 691                 if (!info.exists && _info_by_dev(lv->major, lv->minor, &info2) &&
 692                     info2.exists) {
 693                         log_error("The requested major:minor pair "
 694                                   "(%" PRIu32 ":%" PRIu32") is already used",
 695                                   lv->major, lv->minor);
 696                         return 0;
 697                 }
 698         }
 699
 700         if (info.exists && !dm_tree_add_dev(dtree, info.major, info.minor)) {
 701                 log_error("Failed to add device (%" PRIu32 ":%" PRIu32") to dtree",
 702                           info.major, info.minor);
 703                 return 0;
 704         }
 705
 706         return 1;
 707 }
 708
 709 /*
 710  * Add LV and any known dependencies
 711  */
 712 static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree, struct logical_volume *lv)
 713 {
 714         if (!_add_dev_to_dtree(dm, dtree, lv, NULL))
 715                 return_0;
 716
 717         /* FIXME Can we avoid doing this every time? */
 718         if (!_add_dev_to_dtree(dm, dtree, lv, "real"))
 719                 return_0;
 720
 721         if (!_add_dev_to_dtree(dm, dtree, lv, "cow"))
 722                 return_0;
 723
 724         if (!_add_dev_to_dtree(dm, dtree, lv, "_mlog"))
 725                 return_0;
 726
 727         return 1;
 728 }
 729
 730 static struct dm_tree *_create_partial_dtree(struct dev_manager *dm, struct logical_volume *lv)
 731 {
 732         struct dm_tree *dtree;
 733         struct dm_list *snh, *snht;
 734         struct lv_segment *seg;
 735         uint32_t s;
 736
 737         if (!(dtree = dm_tree_create())) {
 738                 log_error("Partial dtree creation failed for %s.", lv->name);
 739                 return NULL;
 740         }
 741
 742         if (!_add_lv_to_dtree(dm, dtree, lv))
 743                 goto_bad;
 744
 745         /* Add any snapshots of this LV */
 746         dm_list_iterate_safe(snh, snht, &lv->snapshot_segs)
 747                 if (!_add_lv_to_dtree(dm, dtree, dm_list_struct_base(snh, struct lv_segment, origin_list)->cow))
 748                         goto_bad;
 749
 750         /* Add any LVs used by segments in this LV */
 751         dm_list_iterate_items(seg, &lv->segments)
 752                 for (s = 0; s < seg->area_count; s++)
 753                         if (seg_type(seg, s) == AREA_LV && seg_lv(seg, s)) {
 754                                 if (!_add_lv_to_dtree(dm, dtree, seg_lv(seg, s)))
 755                                         goto_bad;
 756                         }
 757
 758         return dtree;
 759
 760 bad:
 761         dm_tree_free(dtree);
 762         return NULL;
 763 }
 764
 765 static char *_add_error_device(struct dev_manager *dm, struct dm_tree *dtree,
 766                                struct lv_segment *seg, int s)
 767 {
 768         char *id, *name;
 769         char errid[32];
 770         struct dm_tree_node *node;
 771         struct lv_segment *seg_i;
 772         int segno = -1, i = 0;;
 773         uint64_t size = seg->len * seg->lv->vg->extent_size;
 774
 775         dm_list_iterate_items(seg_i, &seg->lv->segments) {
 776                 if (seg == seg_i)
 777                         segno = i;
 778                 ++i;
 779         }
 780
 781         if (segno < 0) {
 782                 log_error("_add_error_device called with bad segment");
 783                 return_NULL;
 784         }
 785
 786         sprintf(errid, "missing_%d_%d", segno, s);
 787
 788         if (!(id = build_dlid(dm, seg->lv->lvid.s, errid)))
 789                 return_NULL;
 790
 791         if (!(name = build_dm_name(dm->mem, seg->lv->vg->name,
 792                                    seg->lv->name, errid)))
 793                 return_NULL;
 794         if (!(node = dm_tree_add_new_dev(dtree, name, id, 0, 0, 0, 0, 0)))
 795                 return_NULL;
 796         if (!dm_tree_node_add_error_target(node, size))
 797                 return_NULL;
 798
 799         return id;
 800 }
 801
 802 static int _add_error_area(struct dev_manager *dm, struct dm_tree_node *node,
 803                            struct lv_segment *seg, int s)
 804 {
 805         char *dlid;
 806         uint64_t extent_size = seg->lv->vg->extent_size;
 807
 808         if (!strcmp(dm->cmd->stripe_filler, "error")) {
 809                 /*
 810                  * FIXME, the tree pointer is first field of dm_tree_node, but
 811                  * we don't have the struct definition available.
 812                  */
 813                 struct dm_tree **tree = (struct dm_tree **) node;
 814                 dlid = _add_error_device(dm, *tree, seg, s);
 815                 if (!dlid)
 816                         return_0;
 817                 dm_tree_node_add_target_area(node, NULL, dlid,
 818                                              extent_size * seg_le(seg, s));
 819         } else
 820                 dm_tree_node_add_target_area(node,
 821                                              dm->cmd->stripe_filler,
 822                                              NULL, UINT64_C(0));
 823
 824         return 1;
 825 }
 826
 827 int add_areas_line(struct dev_manager *dm, struct lv_segment *seg,
 828                    struct dm_tree_node *node, uint32_t start_area,
 829                    uint32_t areas)
 830 {
 831         uint64_t extent_size = seg->lv->vg->extent_size;
 832         uint32_t s;
 833         char *dlid;
 834
 835         for (s = start_area; s < areas; s++) {
 836                 if ((seg_type(seg, s) == AREA_PV &&
 837                      (!seg_pvseg(seg, s) ||
 838                       !seg_pv(seg, s) ||
 839                       !seg_dev(seg, s))) ||
 840                     (seg_type(seg, s) == AREA_LV && !seg_lv(seg, s))) {
 841                         if (!_add_error_area(dm, node, seg, s))
 842                                 return_0;
 843                 } else if (seg_type(seg, s) == AREA_PV)
 844                         dm_tree_node_add_target_area(node,
 845                                                         dev_name(seg_dev(seg, s)),
 846                                                         NULL,
 847                                                         (seg_pv(seg, s)->pe_start +
 848                                                          (extent_size * seg_pe(seg, s))));
 849                 else if (seg_type(seg, s) == AREA_LV) {
 850                         if (!(dlid = build_dlid(dm,
 851                                                  seg_lv(seg, s)->lvid.s,
 852                                                  NULL)))
 853                                 return_0;
 854                         dm_tree_node_add_target_area(node, NULL, dlid,
 855                                                         extent_size * seg_le(seg, s));
 856                 } else {
 857                         log_error("Internal error: Unassigned area found in LV %s.",
 858                                   seg->lv->name);
 859                         return 0;
 860                 }
 861         }
 862
 863         return 1;
 864 }
 865
 866 static int _add_origin_target_to_dtree(struct dev_manager *dm,
 867                                          struct dm_tree_node *dnode,
 868                                          struct logical_volume *lv)
 869 {
 870         const char *real_dlid;
 871
 872         if (!(real_dlid = build_dlid(dm, lv->lvid.s, "real")))
 873                 return_0;
 874
 875         if (!dm_tree_node_add_snapshot_origin_target(dnode, lv->size, real_dlid))
 876                 return_0;
 877
 878         return 1;
 879 }
 880
 881 static int _add_snapshot_target_to_dtree(struct dev_manager *dm,
 882                                            struct dm_tree_node *dnode,
 883                                            struct logical_volume *lv)
 884 {
 885         const char *origin_dlid;
 886         const char *cow_dlid;
 887         struct lv_segment *snap_seg;
 888         uint64_t size;
 889
 890         if (!(snap_seg = find_cow(lv))) {
 891                 log_error("Couldn't find snapshot for '%s'.", lv->name);
 892                 return 0;
 893         }
 894
 895         if (!(origin_dlid = build_dlid(dm, snap_seg->origin->lvid.s, "real")))
 896                 return_0;
 897
 898         if (!(cow_dlid = build_dlid(dm, snap_seg->cow->lvid.s, "cow")))
 899                 return_0;
 900
 901         size = (uint64_t) snap_seg->len * snap_seg->origin->vg->extent_size;
 902
 903         if (!dm_tree_node_add_snapshot_target(dnode, size, origin_dlid, cow_dlid, 1, snap_seg->chunk_size))
 904                 return_0;
 905
 906         return 1;
 907 }
 908
 909 static int _add_target_to_dtree(struct dev_manager *dm,
 910                                   struct dm_tree_node *dnode,
 911                                   struct lv_segment *seg)
 912 {
 913         uint64_t extent_size = seg->lv->vg->extent_size;
 914
 915         if (!seg->segtype->ops->add_target_line) {
 916                 log_error("_emit_target: Internal error: Can't handle "
 917                           "segment type %s", seg->segtype->name);
 918                 return 0;
 919         }
 920
 921         return seg->segtype->ops->add_target_line(dm, dm->mem, dm->cmd,
 922                                                   &dm->target_state, seg,
 923                                                   dnode,
 924                                                   extent_size * seg->len,
 925                                                   &dm-> pvmove_mirror_count);
 926 }
 927
 928 static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
 929                                   struct logical_volume *lv, const char *layer);
 930
 931 static int _add_segment_to_dtree(struct dev_manager *dm,
 932                                    struct dm_tree *dtree,
 933                                    struct dm_tree_node *dnode,
 934                                    struct lv_segment *seg,
 935                                    const char *layer)
 936 {
 937         uint32_t s;
 938         struct dm_list *snh;
 939         struct lv_segment *seg_present;
 940
 941         /* Ensure required device-mapper targets are loaded */
 942         seg_present = find_cow(seg->lv) ? : seg;
 943
 944         log_debug("Checking kernel supports %s segment type for %s%s%s",
 945                   seg_present->segtype->name, seg->lv->name,
 946                   layer ? "-" : "", layer ? : "");
 947
 948         if (seg_present->segtype->ops->target_present &&
 949             !seg_present->segtype->ops->target_present(seg_present->lv->vg->cmd,
 950                                                        seg_present, NULL)) {
 951                 log_error("Can't expand LV %s: %s target support missing "
 952                           "from kernel?", seg->lv->name, seg_present->segtype->name);
 953                 return 0;
 954         }
 955
 956         /* Add mirror log */
 957         if (seg->log_lv &&
 958             !_add_new_lv_to_dtree(dm, dtree, seg->log_lv, NULL))
 959                 return_0;
 960
 961         /* If this is a snapshot origin, add real LV */
 962         if (lv_is_origin(seg->lv) && !layer) {
 963                 if (vg_is_clustered(seg->lv->vg)) {
 964                         log_error("Clustered snapshots are not yet supported");
 965                         return 0;
 966                 }
 967                 if (!_add_new_lv_to_dtree(dm, dtree, seg->lv, "real"))
 968                         return_0;
 969         } else if (lv_is_cow(seg->lv) && !layer) {
 970                 if (!_add_new_lv_to_dtree(dm, dtree, seg->lv, "cow"))
 971                         return_0;
 972         } else {
 973                 /* Add any LVs used by this segment */
 974                 for (s = 0; s < seg->area_count; s++)
 975                         if ((seg_type(seg, s) == AREA_LV) &&
 976                             (!_add_new_lv_to_dtree(dm, dtree, seg_lv(seg, s), NULL)))
 977                                 return_0;
 978         }
 979
 980         /* Now we've added its dependencies, we can add the target itself */
 981         if (lv_is_origin(seg->lv) && !layer) {
 982                 if (!_add_origin_target_to_dtree(dm, dnode, seg->lv))
 983                         return_0;
 984         } else if (lv_is_cow(seg->lv) && !layer) {
 985                 if (!_add_snapshot_target_to_dtree(dm, dnode, seg->lv))
 986                         return_0;
 987         } else if (!_add_target_to_dtree(dm, dnode, seg))
 988                 return_0;
 989
 990         if (lv_is_origin(seg->lv) && !layer)
 991                 /* Add any snapshots of this LV */
 992                 dm_list_iterate(snh, &seg->lv->snapshot_segs)
 993                         if (!_add_new_lv_to_dtree(dm, dtree, dm_list_struct_base(snh, struct lv_segment, origin_list)->cow, NULL))
 994                                 return_0;
 995
 996         return 1;
 997 }
 998
 999 static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
1000                                   struct logical_volume *lv, const char *layer)
1001 {
1002         struct lv_segment *seg;
1003         struct lv_layer *lvlayer;
1004         struct dm_tree_node *dnode;
1005         char *name, *dlid;
1006         uint32_t max_stripe_size = UINT32_C(0);
1007         uint32_t read_ahead = lv->read_ahead;
1008         uint32_t read_ahead_flags = UINT32_C(0);
1009         uint16_t udev_flags = 0;
1010
1011         if (!(name = build_dm_name(dm->mem, lv->vg->name, lv->name, layer)))
1012                 return_0;
1013
1014         if (!(dlid = build_dlid(dm, lv->lvid.s, layer)))
1015                 return_0;
1016
1017         /* We've already processed this node if it already has a context ptr */
1018         if ((dnode = dm_tree_find_node_by_uuid(dtree, dlid)) &&
1019             dm_tree_node_get_context(dnode))
1020                 return 1;
1021
1022         if (!(lvlayer = dm_pool_alloc(dm->mem, sizeof(*lvlayer)))) {
1023                 log_error("_add_new_lv_to_dtree: pool alloc failed for %s %s.", lv->name, layer);
1024                 return 0;
1025         }
1026
1027         lvlayer->lv = lv;
1028
1029         if (layer || !lv_is_visible(lv))
1030                 udev_flags |= DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG |
1031                               DM_UDEV_DISABLE_DISK_RULES_FLAG |
1032                               DM_UDEV_DISABLE_OTHER_RULES_FLAG;
1033
1034         if (lv_is_cow(lv))
1035                 udev_flags |= DM_UDEV_LOW_PRIORITY_FLAG;
1036
1037         /*
1038          * Add LV to dtree.
1039          * If we're working with precommitted metadata, clear any
1040          * existing inactive table left behind.
1041          * Major/minor settings only apply to the visible layer.
1042          */
1043         if (!(dnode = dm_tree_add_new_dev_with_udev_flags(dtree, name, dlid,
1044                                              layer ? UINT32_C(0) : (uint32_t) lv->major,
1045                                              layer ? UINT32_C(0) : (uint32_t) lv->minor,
1046                                              _read_only_lv(lv),
1047                                              (lv->vg->status & PRECOMMITTED) ? 1 : 0,
1048                                              lvlayer,
1049                                              udev_flags)))
1050                 return_0;
1051
1052         /* Store existing name so we can do rename later */
1053         lvlayer->old_name = dm_tree_node_get_name(dnode);
1054
1055         /* Create table */
1056         dm->pvmove_mirror_count = 0u;
1057         dm_list_iterate_items(seg, &lv->segments) {
1058                 if (!_add_segment_to_dtree(dm, dtree, dnode, seg, layer))
1059                         return_0;
1060                 /* These aren't real segments in the LVM2 metadata */
1061                 if (lv_is_origin(lv) && !layer)
1062                         break;
1063                 if (lv_is_cow(lv) && !layer)
1064                         break;
1065                 if (max_stripe_size < seg->stripe_size * seg->area_count)
1066                         max_stripe_size = seg->stripe_size * seg->area_count;
1067         }
1068
1069         if (read_ahead == DM_READ_AHEAD_AUTO) {
1070                 /* we need RA at least twice a whole stripe - see the comment in md/raid0.c */
1071                 read_ahead = max_stripe_size * 2;
1072                 if (!read_ahead)
1073                         lv_calculate_readahead(lv, &read_ahead);
1074                 read_ahead_flags = DM_READ_AHEAD_MINIMUM_FLAG;
1075         }
1076
1077         dm_tree_node_set_read_ahead(dnode, read_ahead, read_ahead_flags);
1078
1079         return 1;
1080 }
1081
1082 /* FIXME: symlinks should be created/destroyed at the same time
1083  * as the kernel devices but we can't do that from within libdevmapper
1084  * at present so we must walk the tree twice instead. */
1085
1086 /*
1087  * Create LV symlinks for children of supplied root node.
1088  */
1089 static int _create_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root)
1090 {
1091         void *handle = NULL;
1092         struct dm_tree_node *child;
1093         struct lv_layer *lvlayer;
1094         char *old_vgname, *old_lvname, *old_layer;
1095         char *new_vgname, *new_lvname, *new_layer;
1096         const char *name;
1097         int r = 1;
1098
1099         while ((child = dm_tree_next_child(&handle, root, 0))) {
1100                 if (!(lvlayer = (struct lv_layer *) dm_tree_node_get_context(child)))
1101                         continue;
1102
1103                 /* Detect rename */
1104                 name = dm_tree_node_get_name(child);
1105
1106                 if (name && lvlayer->old_name && *lvlayer->old_name && strcmp(name, lvlayer->old_name)) {
1107                         if (!dm_split_lvm_name(dm->mem, lvlayer->old_name, &old_vgname, &old_lvname, &old_layer)) {
1108                                 log_error("_create_lv_symlinks: Couldn't split up old device name %s", lvlayer->old_name);
1109                                 return 0;
1110                         }
1111                         if (!dm_split_lvm_name(dm->mem, name, &new_vgname, &new_lvname, &new_layer)) {
1112                                 log_error("_create_lv_symlinks: Couldn't split up new device name %s", name);
1113                                 return 0;
1114                         }
1115                         if (!fs_rename_lv(lvlayer->lv, name, old_vgname, old_lvname))
1116                                 r = 0;
1117                         continue;
1118                 }
1119                 if (lv_is_visible(lvlayer->lv)) {
1120                         if (!dev_manager_lv_mknodes(lvlayer->lv))
1121                                 r = 0;
1122                         continue;
1123                 }
1124                 if (!dev_manager_lv_rmnodes(lvlayer->lv))
1125                         r = 0;
1126         }
1127
1128         return r;
1129 }
1130
1131 /*
1132  * Remove LV symlinks for children of supplied root node.
1133  */
1134 static int _remove_lv_symlinks(struct dev_manager *dm, struct dm_tree_node *root)
1135 {
1136         void *handle = NULL;
1137         struct dm_tree_node *child;
1138         char *vgname, *lvname, *layer;
1139         int r = 1;
1140
1141         while ((child = dm_tree_next_child(&handle, root, 0))) {
1142                 if (!dm_split_lvm_name(dm->mem, dm_tree_node_get_name(child), &vgname, &lvname, &layer)) {
1143                         r = 0;
1144                         continue;
1145                 }
1146
1147                 if (!*vgname)
1148                         continue;
1149
1150                 /* only top level layer has symlinks */
1151                 if (*layer)
1152                         continue;
1153
1154                 fs_del_lv_byname(dm->cmd->dev_dir, vgname, lvname);
1155         }
1156
1157         return r;
1158 }
1159
1160 static int _clean_tree(struct dev_manager *dm, struct dm_tree_node *root)
1161 {
1162         void *handle = NULL;
1163         struct dm_tree_node *child;
1164         char *vgname, *lvname, *layer;
1165         const char *name, *uuid;
1166         int r;
1167
1168         while ((child = dm_tree_next_child(&handle, root, 0))) {
1169                 if (!(name = dm_tree_node_get_name(child)))
1170                         continue;
1171
1172                 if (!(uuid = dm_tree_node_get_uuid(child)))
1173                         continue;
1174
1175                 if (!dm_split_lvm_name(dm->mem, name, &vgname, &lvname, &layer)) {
1176                         log_error("_clean_tree: Couldn't split up device name %s.", name);
1177                         return 0;
1178                 }
1179
1180                 /* Not meant to be top level? */
1181                 if (!*layer)
1182                         continue;
1183
1184                 dm_tree_set_cookie(root, 0);
1185                 r = dm_tree_deactivate_children(root, uuid, strlen(uuid));
1186                 if (!dm_udev_wait(dm_tree_get_cookie(root)))
1187                         stack;
1188
1189                 if (!r)
1190                         return_0;
1191         }
1192
1193         return 1;
1194 }
1195
1196 static int _tree_action(struct dev_manager *dm, struct logical_volume *lv, action_t action)
1197 {
1198         struct dm_tree *dtree;
1199         struct dm_tree_node *root;
1200         char *dlid;
1201         int r = 0;
1202
1203         if (!(dtree = _create_partial_dtree(dm, lv)))
1204                 return_0;
1205
1206         if (!(root = dm_tree_find_node(dtree, 0, 0))) {
1207                 log_error("Lost dependency tree root node");
1208                 goto out;
1209         }
1210
1211         if (!(dlid = build_dlid(dm, lv->lvid.s, NULL)))
1212                 goto_out;
1213
1214         /* Only process nodes with uuid of "LVM-" plus VG id. */
1215         switch(action) {
1216         case CLEAN:
1217                 /* Deactivate any unused non-toplevel nodes */
1218                 if (!_clean_tree(dm, root))
1219                         goto_out;
1220                 break;
1221         case DEACTIVATE:
1222                 /* Deactivate LV and all devices it references that nothing else has open. */
1223                 dm_tree_set_cookie(root, 0);
1224                 r = dm_tree_deactivate_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1);
1225                 if (!dm_udev_wait(dm_tree_get_cookie(root)))
1226                         stack;
1227                 if (!r)
1228                         goto_out;
1229                 if (!_remove_lv_symlinks(dm, root))
1230                         log_error("Failed to remove all device symlinks associated with %s.", lv->name);
1231                 break;
1232         case SUSPEND:
1233                 dm_tree_skip_lockfs(root);
1234                 if (!dm->flush_required && (lv->status & MIRRORED) && !(lv->status & PVMOVE))
1235                         dm_tree_use_no_flush_suspend(root);
1236         case SUSPEND_WITH_LOCKFS:
1237                 if (!dm_tree_suspend_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1))
1238                         goto_out;
1239                 break;
1240         case PRELOAD:
1241         case ACTIVATE:
1242                 /* Add all required new devices to tree */
1243                 if (!_add_new_lv_to_dtree(dm, dtree, lv, NULL))
1244                         goto_out;
1245
1246                 /* Preload any devices required before any suspensions */
1247                 dm_tree_set_cookie(root, 0);
1248                 r = dm_tree_preload_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1);
1249                 if (!dm_udev_wait(dm_tree_get_cookie(root)))
1250                         stack;
1251                 if (!r)
1252                         goto_out;
1253
1254                 if (dm_tree_node_size_changed(root))
1255                         dm->flush_required = 1;
1256
1257                 if (action == ACTIVATE) {
1258                         dm_tree_set_cookie(root, 0);
1259                         r = dm_tree_activate_children(root, dlid, ID_LEN + sizeof(UUID_PREFIX) - 1);
1260                         if (!dm_udev_wait(dm_tree_get_cookie(root)))
1261                                 stack;
1262                         if (!r)
1263                                 goto_out;
1264                         if (!_create_lv_symlinks(dm, root)) {
1265                                 log_error("Failed to create symlinks for %s.", lv->name);
1266                                 goto out;
1267                         }
1268                 }
1269
1270                 break;
1271         default:
1272                 log_error("_tree_action: Action %u not supported.", action);
1273                 goto out;
1274         }
1275
1276         r = 1;
1277
1278 out:
1279         dm_tree_free(dtree);
1280
1281         return r;
1282 }
1283
1284 int dev_manager_activate(struct dev_manager *dm, struct logical_volume *lv)
1285 {
1286         if (!_tree_action(dm, lv, ACTIVATE))
1287                 return_0;
1288
1289         return _tree_action(dm, lv, CLEAN);
1290 }
1291
1292 int dev_manager_preload(struct dev_manager *dm, struct logical_volume *lv,
1293                         int *flush_required)
1294 {
1295         /* FIXME Update the pvmove implementation! */
1296         if ((lv->status & PVMOVE) || (lv->status & LOCKED))
1297                 return 1;
1298
1299         if (!_tree_action(dm, lv, PRELOAD))
1300                 return 0;
1301
1302         *flush_required = dm->flush_required;
1303
1304         return 1;
1305 }
1306
1307 int dev_manager_deactivate(struct dev_manager *dm, struct logical_volume *lv)
1308 {
1309         int r;
1310
1311         r = _tree_action(dm, lv, DEACTIVATE);
1312
1313         fs_del_lv(lv);
1314
1315         return r;
1316 }
1317
1318 int dev_manager_suspend(struct dev_manager *dm, struct logical_volume *lv,
1319                         int lockfs, int flush_required)
1320 {
1321         dm->flush_required = flush_required;
1322
1323         return _tree_action(dm, lv, lockfs ? SUSPEND_WITH_LOCKFS : SUSPEND);
1324 }
1325
1326 /*
1327  * Does device use VG somewhere in its construction?
1328  * Returns 1 if uncertain.
1329  */
1330 int dev_manager_device_uses_vg(struct device *dev,
1331                                struct volume_group *vg)
1332 {
1333         struct dm_tree *dtree;
1334         struct dm_tree_node *root;
1335         char dlid[sizeof(UUID_PREFIX) + sizeof(struct id) - 1] __attribute((aligned(8)));
1336         int r = 1;
1337
1338         if (!(dtree = dm_tree_create())) {
1339                 log_error("partial dtree creation failed");
1340                 return r;
1341         }
1342
1343         if (!dm_tree_add_dev(dtree, (uint32_t) MAJOR(dev->dev), (uint32_t) MINOR(dev->dev))) {
1344                 log_error("Failed to add device %s (%" PRIu32 ":%" PRIu32") to dtree",
1345                           dev_name(dev), (uint32_t) MAJOR(dev->dev), (uint32_t) MINOR(dev->dev));
1346                 goto out;
1347         }
1348
1349         memcpy(dlid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1);
1350         memcpy(dlid + sizeof(UUID_PREFIX) - 1, &vg->id.uuid[0], sizeof(vg->id));
1351
1352         if (!(root = dm_tree_find_node(dtree, 0, 0))) {
1353                 log_error("Lost dependency tree root node");
1354                 goto out;
1355         }
1356
1357         if (dm_tree_children_use_uuid(root, dlid, sizeof(UUID_PREFIX) + sizeof(vg->id) - 1))
1358                 goto_out;
1359
1360         r = 0;
1361
1362 out:
1363         dm_tree_free(dtree);
1364         return r;
1365 }