]> sourceware.org Git - lvm2.git/blob - libdm/libdm-deptree.c
Trying to fix the retry logic
[lvm2.git] / libdm / libdm-deptree.c
1 /*
2 * Copyright (C) 2005-2011 Red Hat, Inc. All rights reserved.
3 *
4 * This file is part of the device-mapper userspace tools.
5 *
6 * This copyrighted material is made available to anyone wishing to use,
7 * modify, copy, or redistribute it subject to the terms and conditions
8 * of the GNU Lesser General Public License v.2.1.
9 *
10 * You should have received a copy of the GNU Lesser General Public License
11 * along with this program; if not, write to the Free Software Foundation,
12 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
13 */
14
15 #include "dmlib.h"
16 #include "libdm-targets.h"
17 #include "libdm-common.h"
18 #include "kdev_t.h"
19 #include "dm-ioctl.h"
20
21 #include <stdarg.h>
22 #include <sys/param.h>
23 #include <sys/utsname.h>
24
25 #define MAX_TARGET_PARAMSIZE 500000
26
27 /* FIXME Fix interface so this is used only by LVM */
28 #define UUID_PREFIX "LVM-"
29
30 #define REPLICATOR_LOCAL_SITE 0
31
32 /* Supported segment types */
33 enum {
34 SEG_CRYPT,
35 SEG_ERROR,
36 SEG_LINEAR,
37 SEG_MIRRORED,
38 SEG_REPLICATOR,
39 SEG_REPLICATOR_DEV,
40 SEG_SNAPSHOT,
41 SEG_SNAPSHOT_ORIGIN,
42 SEG_SNAPSHOT_MERGE,
43 SEG_STRIPED,
44 SEG_ZERO,
45 SEG_THIN_POOL,
46 SEG_THIN,
47 SEG_RAID1,
48 SEG_RAID4,
49 SEG_RAID5_LA,
50 SEG_RAID5_RA,
51 SEG_RAID5_LS,
52 SEG_RAID5_RS,
53 SEG_RAID6_ZR,
54 SEG_RAID6_NR,
55 SEG_RAID6_NC,
56 SEG_LAST,
57 };
58
59 /* FIXME Add crypt and multipath support */
60
61 struct {
62 unsigned type;
63 const char *target;
64 } dm_segtypes[] = {
65 { SEG_CRYPT, "crypt" },
66 { SEG_ERROR, "error" },
67 { SEG_LINEAR, "linear" },
68 { SEG_MIRRORED, "mirror" },
69 { SEG_REPLICATOR, "replicator" },
70 { SEG_REPLICATOR_DEV, "replicator-dev" },
71 { SEG_SNAPSHOT, "snapshot" },
72 { SEG_SNAPSHOT_ORIGIN, "snapshot-origin" },
73 { SEG_SNAPSHOT_MERGE, "snapshot-merge" },
74 { SEG_STRIPED, "striped" },
75 { SEG_ZERO, "zero"},
76 { SEG_THIN_POOL, "thin-pool"},
77 { SEG_THIN, "thin"},
78 { SEG_RAID1, "raid1"},
79 { SEG_RAID4, "raid4"},
80 { SEG_RAID5_LA, "raid5_la"},
81 { SEG_RAID5_RA, "raid5_ra"},
82 { SEG_RAID5_LS, "raid5_ls"},
83 { SEG_RAID5_RS, "raid5_rs"},
84 { SEG_RAID6_ZR, "raid6_zr"},
85 { SEG_RAID6_NR, "raid6_nr"},
86 { SEG_RAID6_NC, "raid6_nc"},
87
88 /*
89 *WARNING: Since 'raid' target overloads this 1:1 mapping table
90 * for search do not add new enum elements past them!
91 */
92 { SEG_RAID5_LS, "raid5"}, /* same as "raid5_ls" (default for MD also) */
93 { SEG_RAID6_ZR, "raid6"}, /* same as "raid6_zr" */
94 { SEG_LAST, NULL },
95 };
96
97 /* Some segment types have a list of areas of other devices attached */
98 struct seg_area {
99 struct dm_list list;
100
101 struct dm_tree_node *dev_node;
102
103 uint64_t offset;
104
105 unsigned rsite_index; /* Replicator site index */
106 struct dm_tree_node *slog; /* Replicator sync log node */
107 uint64_t region_size; /* Replicator sync log size */
108 uint32_t flags; /* Replicator sync log flags */
109 };
110
111 struct thin_message {
112 struct dm_list list;
113 struct dm_thin_message message;
114 int expected_errno;
115 };
116
117 /* Replicator-log has a list of sites */
118 /* FIXME: maybe move to seg_area too? */
119 struct replicator_site {
120 struct dm_list list;
121
122 unsigned rsite_index;
123 dm_replicator_mode_t mode;
124 uint32_t async_timeout;
125 uint32_t fall_behind_ios;
126 uint64_t fall_behind_data;
127 };
128
129 /* Per-segment properties */
130 struct load_segment {
131 struct dm_list list;
132
133 unsigned type;
134
135 uint64_t size;
136
137 unsigned area_count; /* Linear + Striped + Mirrored + Crypt + Replicator */
138 struct dm_list areas; /* Linear + Striped + Mirrored + Crypt + Replicator */
139
140 uint32_t stripe_size; /* Striped + raid */
141
142 int persistent; /* Snapshot */
143 uint32_t chunk_size; /* Snapshot */
144 struct dm_tree_node *cow; /* Snapshot */
145 struct dm_tree_node *origin; /* Snapshot + Snapshot origin */
146 struct dm_tree_node *merge; /* Snapshot */
147
148 struct dm_tree_node *log; /* Mirror + Replicator */
149 uint32_t region_size; /* Mirror + raid */
150 unsigned clustered; /* Mirror */
151 unsigned mirror_area_count; /* Mirror */
152 uint32_t flags; /* Mirror log */
153 char *uuid; /* Clustered mirror log */
154
155 const char *cipher; /* Crypt */
156 const char *chainmode; /* Crypt */
157 const char *iv; /* Crypt */
158 uint64_t iv_offset; /* Crypt */
159 const char *key; /* Crypt */
160
161 const char *rlog_type; /* Replicator */
162 struct dm_list rsites; /* Replicator */
163 unsigned rsite_count; /* Replicator */
164 unsigned rdevice_count; /* Replicator */
165 struct dm_tree_node *replicator;/* Replicator-dev */
166 uint64_t rdevice_index; /* Replicator-dev */
167
168 uint64_t rebuilds; /* raid */
169
170 struct dm_tree_node *metadata; /* Thin_pool */
171 struct dm_tree_node *pool; /* Thin_pool, Thin */
172 struct dm_list thin_messages; /* Thin_pool */
173 uint64_t low_water_mark; /* Thin_pool */
174 uint32_t data_block_size; /* Thin_pool */
175 unsigned skip_block_zeroing; /* Thin_pool */
176 uint32_t device_id; /* Thin */
177
178 };
179
180 /* Per-device properties */
181 struct load_properties {
182 int read_only;
183 uint32_t major;
184 uint32_t minor;
185
186 uint32_t read_ahead;
187 uint32_t read_ahead_flags;
188
189 uint64_t thin_pool_transaction_id; /* Thin_pool */
190
191 unsigned segment_count;
192 unsigned size_changed;
193 struct dm_list segs;
194
195 const char *new_name;
196
197 /* If immediate_dev_node is set to 1, try to create the dev node
198 * as soon as possible (e.g. in preload stage even during traversal
199 * and processing of dm tree). This will also flush all stacked dev
200 * node operations, synchronizing with udev.
201 */
202 unsigned immediate_dev_node;
203
204 /*
205 * If the device size changed from zero and this is set,
206 * don't resume the device immediately, even if the device
207 * has parents. This works provided the parents do not
208 * validate the device size and is required by pvmove to
209 * avoid starting the mirror resync operation too early.
210 */
211 unsigned delay_resume_if_new;
212 };
213
214 /* Two of these used to join two nodes with uses and used_by. */
215 struct dm_tree_link {
216 struct dm_list list;
217 struct dm_tree_node *node;
218 };
219
220 struct dm_tree_node {
221 struct dm_tree *dtree;
222
223 const char *name;
224 const char *uuid;
225 struct dm_info info;
226
227 struct dm_list uses; /* Nodes this node uses */
228 struct dm_list used_by; /* Nodes that use this node */
229
230 int activation_priority; /* 0 gets activated first */
231
232 uint16_t udev_flags; /* Udev control flags */
233
234 void *context; /* External supplied context */
235
236 struct load_properties props; /* For creation/table (re)load */
237
238 /*
239 * If presuspend of child node is needed
240 * Note: only direct child is allowed
241 */
242 struct dm_tree_node *presuspend_node;
243 };
244
245 struct dm_tree {
246 struct dm_pool *mem;
247 struct dm_hash_table *devs;
248 struct dm_hash_table *uuids;
249 struct dm_tree_node root;
250 int skip_lockfs; /* 1 skips lockfs (for non-snapshots) */
251 int no_flush; /* 1 sets noflush (mirrors/multipath) */
252 int retry_remove; /* 1 retries remove if not successful */
253 uint32_t cookie;
254 };
255
256 struct dm_tree *dm_tree_create(void)
257 {
258 struct dm_pool *dmem;
259 struct dm_tree *dtree;
260
261 if (!(dmem = dm_pool_create("dtree", 1024)) ||
262 !(dtree = dm_pool_zalloc(dmem, sizeof(*dtree)))) {
263 log_error("Failed to allocate dtree.");
264 if (dmem)
265 dm_pool_destroy(dmem);
266 return NULL;
267 }
268
269 dtree->root.dtree = dtree;
270 dm_list_init(&dtree->root.uses);
271 dm_list_init(&dtree->root.used_by);
272 dtree->skip_lockfs = 0;
273 dtree->no_flush = 0;
274 dtree->mem = dmem;
275
276 if (!(dtree->devs = dm_hash_create(8))) {
277 log_error("dtree hash creation failed");
278 dm_pool_destroy(dtree->mem);
279 return NULL;
280 }
281
282 if (!(dtree->uuids = dm_hash_create(32))) {
283 log_error("dtree uuid hash creation failed");
284 dm_hash_destroy(dtree->devs);
285 dm_pool_destroy(dtree->mem);
286 return NULL;
287 }
288
289 return dtree;
290 }
291
292 void dm_tree_free(struct dm_tree *dtree)
293 {
294 if (!dtree)
295 return;
296
297 dm_hash_destroy(dtree->uuids);
298 dm_hash_destroy(dtree->devs);
299 dm_pool_destroy(dtree->mem);
300 }
301
302 static int _nodes_are_linked(const struct dm_tree_node *parent,
303 const struct dm_tree_node *child)
304 {
305 struct dm_tree_link *dlink;
306
307 dm_list_iterate_items(dlink, &parent->uses)
308 if (dlink->node == child)
309 return 1;
310
311 return 0;
312 }
313
314 static int _link(struct dm_list *list, struct dm_tree_node *node)
315 {
316 struct dm_tree_link *dlink;
317
318 if (!(dlink = dm_pool_alloc(node->dtree->mem, sizeof(*dlink)))) {
319 log_error("dtree link allocation failed");
320 return 0;
321 }
322
323 dlink->node = node;
324 dm_list_add(list, &dlink->list);
325
326 return 1;
327 }
328
329 static int _link_nodes(struct dm_tree_node *parent,
330 struct dm_tree_node *child)
331 {
332 if (_nodes_are_linked(parent, child))
333 return 1;
334
335 if (!_link(&parent->uses, child))
336 return 0;
337
338 if (!_link(&child->used_by, parent))
339 return 0;
340
341 return 1;
342 }
343
344 static void _unlink(struct dm_list *list, struct dm_tree_node *node)
345 {
346 struct dm_tree_link *dlink;
347
348 dm_list_iterate_items(dlink, list)
349 if (dlink->node == node) {
350 dm_list_del(&dlink->list);
351 break;
352 }
353 }
354
355 static void _unlink_nodes(struct dm_tree_node *parent,
356 struct dm_tree_node *child)
357 {
358 if (!_nodes_are_linked(parent, child))
359 return;
360
361 _unlink(&parent->uses, child);
362 _unlink(&child->used_by, parent);
363 }
364
365 static int _add_to_toplevel(struct dm_tree_node *node)
366 {
367 return _link_nodes(&node->dtree->root, node);
368 }
369
370 static void _remove_from_toplevel(struct dm_tree_node *node)
371 {
372 _unlink_nodes(&node->dtree->root, node);
373 }
374
375 static int _add_to_bottomlevel(struct dm_tree_node *node)
376 {
377 return _link_nodes(node, &node->dtree->root);
378 }
379
380 static void _remove_from_bottomlevel(struct dm_tree_node *node)
381 {
382 _unlink_nodes(node, &node->dtree->root);
383 }
384
385 static int _link_tree_nodes(struct dm_tree_node *parent, struct dm_tree_node *child)
386 {
387 /* Don't link to root node if child already has a parent */
388 if (parent == &parent->dtree->root) {
389 if (dm_tree_node_num_children(child, 1))
390 return 1;
391 } else
392 _remove_from_toplevel(child);
393
394 if (child == &child->dtree->root) {
395 if (dm_tree_node_num_children(parent, 0))
396 return 1;
397 } else
398 _remove_from_bottomlevel(parent);
399
400 return _link_nodes(parent, child);
401 }
402
403 static struct dm_tree_node *_create_dm_tree_node(struct dm_tree *dtree,
404 const char *name,
405 const char *uuid,
406 struct dm_info *info,
407 void *context,
408 uint16_t udev_flags)
409 {
410 struct dm_tree_node *node;
411 uint64_t dev;
412
413 if (!(node = dm_pool_zalloc(dtree->mem, sizeof(*node)))) {
414 log_error("_create_dm_tree_node alloc failed");
415 return NULL;
416 }
417
418 node->dtree = dtree;
419
420 node->name = name;
421 node->uuid = uuid;
422 node->info = *info;
423 node->context = context;
424 node->udev_flags = udev_flags;
425 node->activation_priority = 0;
426
427 dm_list_init(&node->uses);
428 dm_list_init(&node->used_by);
429 dm_list_init(&node->props.segs);
430
431 dev = MKDEV(info->major, info->minor);
432
433 if (!dm_hash_insert_binary(dtree->devs, (const char *) &dev,
434 sizeof(dev), node)) {
435 log_error("dtree node hash insertion failed");
436 dm_pool_free(dtree->mem, node);
437 return NULL;
438 }
439
440 if (uuid && *uuid &&
441 !dm_hash_insert(dtree->uuids, uuid, node)) {
442 log_error("dtree uuid hash insertion failed");
443 dm_hash_remove_binary(dtree->devs, (const char *) &dev,
444 sizeof(dev));
445 dm_pool_free(dtree->mem, node);
446 return NULL;
447 }
448
449 return node;
450 }
451
452 static struct dm_tree_node *_find_dm_tree_node(struct dm_tree *dtree,
453 uint32_t major, uint32_t minor)
454 {
455 uint64_t dev = MKDEV(major, minor);
456
457 return dm_hash_lookup_binary(dtree->devs, (const char *) &dev,
458 sizeof(dev));
459 }
460
461 static struct dm_tree_node *_find_dm_tree_node_by_uuid(struct dm_tree *dtree,
462 const char *uuid)
463 {
464 struct dm_tree_node *node;
465
466 if ((node = dm_hash_lookup(dtree->uuids, uuid)))
467 return node;
468
469 if (strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
470 return NULL;
471
472 return dm_hash_lookup(dtree->uuids, uuid + sizeof(UUID_PREFIX) - 1);
473 }
474
475 static int _deps(struct dm_task **dmt, struct dm_pool *mem, uint32_t major, uint32_t minor,
476 const char **name, const char **uuid,
477 struct dm_info *info, struct dm_deps **deps)
478 {
479 memset(info, 0, sizeof(*info));
480
481 if (!dm_is_dm_major(major)) {
482 *name = "";
483 *uuid = "";
484 *deps = NULL;
485 info->major = major;
486 info->minor = minor;
487 info->exists = 0;
488 info->live_table = 0;
489 info->inactive_table = 0;
490 info->read_only = 0;
491 return 1;
492 }
493
494 if (!(*dmt = dm_task_create(DM_DEVICE_DEPS))) {
495 log_error("deps dm_task creation failed");
496 return 0;
497 }
498
499 if (!dm_task_set_major(*dmt, major)) {
500 log_error("_deps: failed to set major for (%" PRIu32 ":%" PRIu32 ")",
501 major, minor);
502 goto failed;
503 }
504
505 if (!dm_task_set_minor(*dmt, minor)) {
506 log_error("_deps: failed to set minor for (%" PRIu32 ":%" PRIu32 ")",
507 major, minor);
508 goto failed;
509 }
510
511 if (!dm_task_run(*dmt)) {
512 log_error("_deps: task run failed for (%" PRIu32 ":%" PRIu32 ")",
513 major, minor);
514 goto failed;
515 }
516
517 if (!dm_task_get_info(*dmt, info)) {
518 log_error("_deps: failed to get info for (%" PRIu32 ":%" PRIu32 ")",
519 major, minor);
520 goto failed;
521 }
522
523 if (!info->exists) {
524 *name = "";
525 *uuid = "";
526 *deps = NULL;
527 } else {
528 if (info->major != major) {
529 log_error("Inconsistent dtree major number: %u != %u",
530 major, info->major);
531 goto failed;
532 }
533 if (info->minor != minor) {
534 log_error("Inconsistent dtree minor number: %u != %u",
535 minor, info->minor);
536 goto failed;
537 }
538 if (!(*name = dm_pool_strdup(mem, dm_task_get_name(*dmt)))) {
539 log_error("name pool_strdup failed");
540 goto failed;
541 }
542 if (!(*uuid = dm_pool_strdup(mem, dm_task_get_uuid(*dmt)))) {
543 log_error("uuid pool_strdup failed");
544 goto failed;
545 }
546 *deps = dm_task_get_deps(*dmt);
547 }
548
549 return 1;
550
551 failed:
552 dm_task_destroy(*dmt);
553 return 0;
554 }
555
556 static struct dm_tree_node *_add_dev(struct dm_tree *dtree,
557 struct dm_tree_node *parent,
558 uint32_t major, uint32_t minor,
559 uint16_t udev_flags)
560 {
561 struct dm_task *dmt = NULL;
562 struct dm_info info;
563 struct dm_deps *deps = NULL;
564 const char *name = NULL;
565 const char *uuid = NULL;
566 struct dm_tree_node *node = NULL;
567 uint32_t i;
568 int new = 0;
569
570 /* Already in tree? */
571 if (!(node = _find_dm_tree_node(dtree, major, minor))) {
572 if (!_deps(&dmt, dtree->mem, major, minor, &name, &uuid, &info, &deps))
573 return_NULL;
574
575 if (!(node = _create_dm_tree_node(dtree, name, uuid, &info,
576 NULL, udev_flags)))
577 goto_out;
578 new = 1;
579 }
580
581 if (!_link_tree_nodes(parent, node)) {
582 node = NULL;
583 goto_out;
584 }
585
586 /* If node was already in tree, no need to recurse. */
587 if (!new)
588 goto out;
589
590 /* Can't recurse if not a mapped device or there are no dependencies */
591 if (!node->info.exists || !deps->count) {
592 if (!_add_to_bottomlevel(node)) {
593 stack;
594 node = NULL;
595 }
596 goto out;
597 }
598
599 /* Add dependencies to tree */
600 for (i = 0; i < deps->count; i++)
601 if (!_add_dev(dtree, node, MAJOR(deps->device[i]),
602 MINOR(deps->device[i]), udev_flags)) {
603 node = NULL;
604 goto_out;
605 }
606
607 out:
608 if (dmt)
609 dm_task_destroy(dmt);
610
611 return node;
612 }
613
614 static int _node_clear_table(struct dm_tree_node *dnode)
615 {
616 struct dm_task *dmt;
617 struct dm_info *info;
618 const char *name;
619 int r;
620
621 if (!(info = &dnode->info)) {
622 log_error("_node_clear_table failed: missing info");
623 return 0;
624 }
625
626 if (!(name = dm_tree_node_get_name(dnode))) {
627 log_error("_node_clear_table failed: missing name");
628 return 0;
629 }
630
631 /* Is there a table? */
632 if (!info->exists || !info->inactive_table)
633 return 1;
634
635 // FIXME Get inactive deps. If any dev referenced has 1 opener and no live table, remove it after the clear.
636
637 log_verbose("Clearing inactive table %s (%" PRIu32 ":%" PRIu32 ")",
638 name, info->major, info->minor);
639
640 if (!(dmt = dm_task_create(DM_DEVICE_CLEAR))) {
641 log_error("Table clear dm_task creation failed for %s", name);
642 return 0;
643 }
644
645 if (!dm_task_set_major(dmt, info->major) ||
646 !dm_task_set_minor(dmt, info->minor)) {
647 log_error("Failed to set device number for %s table clear", name);
648 dm_task_destroy(dmt);
649 return 0;
650 }
651
652 r = dm_task_run(dmt);
653
654 if (!dm_task_get_info(dmt, info)) {
655 log_error("_node_clear_table failed: info missing after running task for %s", name);
656 r = 0;
657 }
658
659 dm_task_destroy(dmt);
660
661 return r;
662 }
663
664 struct dm_tree_node *dm_tree_add_new_dev(struct dm_tree *dtree,
665 const char *name,
666 const char *uuid,
667 uint32_t major, uint32_t minor,
668 int read_only,
669 int clear_inactive,
670 void *context)
671 {
672 struct dm_tree_node *dnode;
673 struct dm_info info;
674 const char *name2;
675 const char *uuid2;
676
677 /* Do we need to add node to tree? */
678 if (!(dnode = dm_tree_find_node_by_uuid(dtree, uuid))) {
679 if (!(name2 = dm_pool_strdup(dtree->mem, name))) {
680 log_error("name pool_strdup failed");
681 return NULL;
682 }
683 if (!(uuid2 = dm_pool_strdup(dtree->mem, uuid))) {
684 log_error("uuid pool_strdup failed");
685 return NULL;
686 }
687
688 info.major = 0;
689 info.minor = 0;
690 info.exists = 0;
691 info.live_table = 0;
692 info.inactive_table = 0;
693 info.read_only = 0;
694
695 if (!(dnode = _create_dm_tree_node(dtree, name2, uuid2, &info,
696 context, 0)))
697 return_NULL;
698
699 /* Attach to root node until a table is supplied */
700 if (!_add_to_toplevel(dnode) || !_add_to_bottomlevel(dnode))
701 return_NULL;
702
703 dnode->props.major = major;
704 dnode->props.minor = minor;
705 dnode->props.new_name = NULL;
706 dnode->props.size_changed = 0;
707 } else if (strcmp(name, dnode->name)) {
708 /* Do we need to rename node? */
709 if (!(dnode->props.new_name = dm_pool_strdup(dtree->mem, name))) {
710 log_error("name pool_strdup failed");
711 return 0;
712 }
713 }
714
715 dnode->props.read_only = read_only ? 1 : 0;
716 dnode->props.read_ahead = DM_READ_AHEAD_AUTO;
717 dnode->props.read_ahead_flags = 0;
718
719 if (clear_inactive && !_node_clear_table(dnode))
720 return_NULL;
721
722 dnode->context = context;
723 dnode->udev_flags = 0;
724
725 return dnode;
726 }
727
728 struct dm_tree_node *dm_tree_add_new_dev_with_udev_flags(struct dm_tree *dtree,
729 const char *name,
730 const char *uuid,
731 uint32_t major,
732 uint32_t minor,
733 int read_only,
734 int clear_inactive,
735 void *context,
736 uint16_t udev_flags)
737 {
738 struct dm_tree_node *node;
739
740 if ((node = dm_tree_add_new_dev(dtree, name, uuid, major, minor, read_only,
741 clear_inactive, context)))
742 node->udev_flags = udev_flags;
743
744 return node;
745 }
746
747 void dm_tree_node_set_udev_flags(struct dm_tree_node *dnode, uint16_t udev_flags)
748
749 {
750 struct dm_info *dinfo = &dnode->info;
751
752 if (udev_flags != dnode->udev_flags)
753 log_debug("Resetting %s (%" PRIu32 ":%" PRIu32
754 ") udev_flags from 0x%x to 0x%x",
755 dnode->name, dinfo->major, dinfo->minor,
756 dnode->udev_flags, udev_flags);
757 dnode->udev_flags = udev_flags;
758 }
759
760 void dm_tree_node_set_read_ahead(struct dm_tree_node *dnode,
761 uint32_t read_ahead,
762 uint32_t read_ahead_flags)
763 {
764 dnode->props.read_ahead = read_ahead;
765 dnode->props.read_ahead_flags = read_ahead_flags;
766 }
767
768 void dm_tree_node_set_presuspend_node(struct dm_tree_node *node,
769 struct dm_tree_node *presuspend_node)
770 {
771 node->presuspend_node = presuspend_node;
772 }
773
774 int dm_tree_add_dev(struct dm_tree *dtree, uint32_t major, uint32_t minor)
775 {
776 return _add_dev(dtree, &dtree->root, major, minor, 0) ? 1 : 0;
777 }
778
779 int dm_tree_add_dev_with_udev_flags(struct dm_tree *dtree, uint32_t major,
780 uint32_t minor, uint16_t udev_flags)
781 {
782 return _add_dev(dtree, &dtree->root, major, minor, udev_flags) ? 1 : 0;
783 }
784
785 const char *dm_tree_node_get_name(const struct dm_tree_node *node)
786 {
787 return node->info.exists ? node->name : "";
788 }
789
790 const char *dm_tree_node_get_uuid(const struct dm_tree_node *node)
791 {
792 return node->info.exists ? node->uuid : "";
793 }
794
795 const struct dm_info *dm_tree_node_get_info(const struct dm_tree_node *node)
796 {
797 return &node->info;
798 }
799
800 void *dm_tree_node_get_context(const struct dm_tree_node *node)
801 {
802 return node->context;
803 }
804
805 int dm_tree_node_size_changed(const struct dm_tree_node *dnode)
806 {
807 return dnode->props.size_changed;
808 }
809
810 int dm_tree_node_num_children(const struct dm_tree_node *node, uint32_t inverted)
811 {
812 if (inverted) {
813 if (_nodes_are_linked(&node->dtree->root, node))
814 return 0;
815 return dm_list_size(&node->used_by);
816 }
817
818 if (_nodes_are_linked(node, &node->dtree->root))
819 return 0;
820
821 return dm_list_size(&node->uses);
822 }
823
824 /*
825 * Returns 1 if no prefix supplied
826 */
827 static int _uuid_prefix_matches(const char *uuid, const char *uuid_prefix, size_t uuid_prefix_len)
828 {
829 if (!uuid_prefix)
830 return 1;
831
832 if (!strncmp(uuid, uuid_prefix, uuid_prefix_len))
833 return 1;
834
835 /* Handle transition: active device uuids might be missing the prefix */
836 if (uuid_prefix_len <= 4)
837 return 0;
838
839 if (!strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
840 return 0;
841
842 if (strncmp(uuid_prefix, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
843 return 0;
844
845 if (!strncmp(uuid, uuid_prefix + sizeof(UUID_PREFIX) - 1, uuid_prefix_len - (sizeof(UUID_PREFIX) - 1)))
846 return 1;
847
848 return 0;
849 }
850
851 /*
852 * Returns 1 if no children.
853 */
854 static int _children_suspended(struct dm_tree_node *node,
855 uint32_t inverted,
856 const char *uuid_prefix,
857 size_t uuid_prefix_len)
858 {
859 struct dm_list *list;
860 struct dm_tree_link *dlink;
861 const struct dm_info *dinfo;
862 const char *uuid;
863
864 if (inverted) {
865 if (_nodes_are_linked(&node->dtree->root, node))
866 return 1;
867 list = &node->used_by;
868 } else {
869 if (_nodes_are_linked(node, &node->dtree->root))
870 return 1;
871 list = &node->uses;
872 }
873
874 dm_list_iterate_items(dlink, list) {
875 if (!(uuid = dm_tree_node_get_uuid(dlink->node))) {
876 stack;
877 continue;
878 }
879
880 /* Ignore if it doesn't belong to this VG */
881 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
882 continue;
883
884 /* Ignore if parent node wants to presuspend this node */
885 if (dlink->node->presuspend_node == node)
886 continue;
887
888 if (!(dinfo = dm_tree_node_get_info(dlink->node))) {
889 stack; /* FIXME Is this normal? */
890 return 0;
891 }
892
893 if (!dinfo->suspended)
894 return 0;
895 }
896
897 return 1;
898 }
899
900 /*
901 * Set major and minor to zero for root of tree.
902 */
903 struct dm_tree_node *dm_tree_find_node(struct dm_tree *dtree,
904 uint32_t major,
905 uint32_t minor)
906 {
907 if (!major && !minor)
908 return &dtree->root;
909
910 return _find_dm_tree_node(dtree, major, minor);
911 }
912
913 /*
914 * Set uuid to NULL for root of tree.
915 */
916 struct dm_tree_node *dm_tree_find_node_by_uuid(struct dm_tree *dtree,
917 const char *uuid)
918 {
919 if (!uuid || !*uuid)
920 return &dtree->root;
921
922 return _find_dm_tree_node_by_uuid(dtree, uuid);
923 }
924
925 /*
926 * First time set *handle to NULL.
927 * Set inverted to invert the tree.
928 */
929 struct dm_tree_node *dm_tree_next_child(void **handle,
930 const struct dm_tree_node *parent,
931 uint32_t inverted)
932 {
933 struct dm_list **dlink = (struct dm_list **) handle;
934 const struct dm_list *use_list;
935
936 if (inverted)
937 use_list = &parent->used_by;
938 else
939 use_list = &parent->uses;
940
941 if (!*dlink)
942 *dlink = dm_list_first(use_list);
943 else
944 *dlink = dm_list_next(use_list, *dlink);
945
946 return (*dlink) ? dm_list_item(*dlink, struct dm_tree_link)->node : NULL;
947 }
948
949 /*
950 * Deactivate a device with its dependencies if the uuid prefix matches.
951 */
952 static int _info_by_dev(uint32_t major, uint32_t minor, int with_open_count,
953 struct dm_info *info)
954 {
955 struct dm_task *dmt;
956 int r;
957
958 if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
959 log_error("_info_by_dev: dm_task creation failed");
960 return 0;
961 }
962
963 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
964 log_error("_info_by_dev: Failed to set device number");
965 dm_task_destroy(dmt);
966 return 0;
967 }
968
969 if (!with_open_count && !dm_task_no_open_count(dmt))
970 log_error("Failed to disable open_count");
971
972 if ((r = dm_task_run(dmt)))
973 r = dm_task_get_info(dmt, info);
974
975 dm_task_destroy(dmt);
976
977 return r;
978 }
979
980 static int _check_device_not_in_use(const char *name, struct dm_info *info)
981 {
982 if (!info->exists)
983 return 1;
984
985 /* If sysfs is not used, use open_count information only. */
986 if (!*dm_sysfs_dir()) {
987 if (info->open_count) {
988 log_error("Device %s (%" PRIu32 ":%" PRIu32 ") in use",
989 name, info->major, info->minor);
990 return 0;
991 }
992
993 return 1;
994 }
995
996 if (dm_device_has_holders(info->major, info->minor)) {
997 log_error("Device %s (%" PRIu32 ":%" PRIu32 ") is used "
998 "by another device.", name, info->major, info->minor);
999 return 0;
1000 }
1001
1002 if (dm_device_has_mounted_fs(info->major, info->minor)) {
1003 log_error("Device %s (%" PRIu32 ":%" PRIu32 ") contains "
1004 "a filesystem in use.", name, info->major, info->minor);
1005 return 0;
1006 }
1007
1008 return 1;
1009 }
1010
1011 /* Check if all parent nodes of given node have open_count == 0 */
1012 static int _node_has_closed_parents(struct dm_tree_node *node,
1013 const char *uuid_prefix,
1014 size_t uuid_prefix_len)
1015 {
1016 struct dm_tree_link *dlink;
1017 const struct dm_info *dinfo;
1018 struct dm_info info;
1019 const char *uuid;
1020
1021 /* Iterate through parents of this node */
1022 dm_list_iterate_items(dlink, &node->used_by) {
1023 if (!(uuid = dm_tree_node_get_uuid(dlink->node))) {
1024 stack;
1025 continue;
1026 }
1027
1028 /* Ignore if it doesn't belong to this VG */
1029 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1030 continue;
1031
1032 if (!(dinfo = dm_tree_node_get_info(dlink->node))) {
1033 stack; /* FIXME Is this normal? */
1034 return 0;
1035 }
1036
1037 /* Refresh open_count */
1038 if (!_info_by_dev(dinfo->major, dinfo->minor, 1, &info) ||
1039 !info.exists)
1040 continue;
1041
1042 if (info.open_count) {
1043 log_debug("Node %s %d:%d has open_count %d", uuid_prefix,
1044 dinfo->major, dinfo->minor, info.open_count);
1045 return 0;
1046 }
1047 }
1048
1049 return 1;
1050 }
1051
1052 static int _deactivate_node(const char *name, uint32_t major, uint32_t minor,
1053 uint32_t *cookie, uint16_t udev_flags, int retry)
1054 {
1055 struct dm_task *dmt;
1056 int r = 0;
1057
1058 log_verbose("Removing %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor);
1059
1060 if (!(dmt = dm_task_create(DM_DEVICE_REMOVE))) {
1061 log_error("Deactivation dm_task creation failed for %s", name);
1062 return 0;
1063 }
1064
1065 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
1066 log_error("Failed to set device number for %s deactivation", name);
1067 goto out;
1068 }
1069
1070 if (!dm_task_no_open_count(dmt))
1071 log_error("Failed to disable open_count");
1072
1073 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
1074 goto out;
1075
1076
1077 if (retry)
1078 dm_task_retry_remove(dmt);
1079
1080 r = dm_task_run(dmt);
1081
1082 /* FIXME Until kernel returns actual name so dm-iface.c can handle it */
1083 rm_dev_node(name, dmt->cookie_set && !(udev_flags & DM_UDEV_DISABLE_DM_RULES_FLAG),
1084 dmt->cookie_set && (udev_flags & DM_UDEV_DISABLE_LIBRARY_FALLBACK));
1085
1086 /* FIXME Remove node from tree or mark invalid? */
1087
1088 out:
1089 dm_task_destroy(dmt);
1090
1091 return r;
1092 }
1093
1094 static int _rename_node(const char *old_name, const char *new_name, uint32_t major,
1095 uint32_t minor, uint32_t *cookie, uint16_t udev_flags)
1096 {
1097 struct dm_task *dmt;
1098 int r = 0;
1099
1100 log_verbose("Renaming %s (%" PRIu32 ":%" PRIu32 ") to %s", old_name, major, minor, new_name);
1101
1102 if (!(dmt = dm_task_create(DM_DEVICE_RENAME))) {
1103 log_error("Rename dm_task creation failed for %s", old_name);
1104 return 0;
1105 }
1106
1107 if (!dm_task_set_name(dmt, old_name)) {
1108 log_error("Failed to set name for %s rename.", old_name);
1109 goto out;
1110 }
1111
1112 if (!dm_task_set_newname(dmt, new_name))
1113 goto_out;
1114
1115 if (!dm_task_no_open_count(dmt))
1116 log_error("Failed to disable open_count");
1117
1118 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
1119 goto out;
1120
1121 r = dm_task_run(dmt);
1122
1123 out:
1124 dm_task_destroy(dmt);
1125
1126 return r;
1127 }
1128
1129 /* FIXME Merge with _suspend_node? */
1130 static int _resume_node(const char *name, uint32_t major, uint32_t minor,
1131 uint32_t read_ahead, uint32_t read_ahead_flags,
1132 struct dm_info *newinfo, uint32_t *cookie,
1133 uint16_t udev_flags, int already_suspended)
1134 {
1135 struct dm_task *dmt;
1136 int r = 0;
1137
1138 log_verbose("Resuming %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor);
1139
1140 if (!(dmt = dm_task_create(DM_DEVICE_RESUME))) {
1141 log_debug("Suspend dm_task creation failed for %s.", name);
1142 return 0;
1143 }
1144
1145 /* FIXME Kernel should fill in name on return instead */
1146 if (!dm_task_set_name(dmt, name)) {
1147 log_debug("Failed to set device name for %s resumption.", name);
1148 goto out;
1149 }
1150
1151 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
1152 log_error("Failed to set device number for %s resumption.", name);
1153 goto out;
1154 }
1155
1156 if (!dm_task_no_open_count(dmt))
1157 log_error("Failed to disable open_count");
1158
1159 if (!dm_task_set_read_ahead(dmt, read_ahead, read_ahead_flags))
1160 log_error("Failed to set read ahead");
1161
1162 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
1163 goto_out;
1164
1165 if (!(r = dm_task_run(dmt)))
1166 goto_out;
1167
1168 if (already_suspended)
1169 dec_suspended();
1170
1171 if (!(r = dm_task_get_info(dmt, newinfo)))
1172 stack;
1173
1174 out:
1175 dm_task_destroy(dmt);
1176
1177 return r;
1178 }
1179
1180 static int _suspend_node(const char *name, uint32_t major, uint32_t minor,
1181 int skip_lockfs, int no_flush, struct dm_info *newinfo)
1182 {
1183 struct dm_task *dmt;
1184 int r;
1185
1186 log_verbose("Suspending %s (%" PRIu32 ":%" PRIu32 ")%s%s",
1187 name, major, minor,
1188 skip_lockfs ? "" : " with filesystem sync",
1189 no_flush ? "" : " with device flush");
1190
1191 if (!(dmt = dm_task_create(DM_DEVICE_SUSPEND))) {
1192 log_error("Suspend dm_task creation failed for %s", name);
1193 return 0;
1194 }
1195
1196 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
1197 log_error("Failed to set device number for %s suspension.", name);
1198 dm_task_destroy(dmt);
1199 return 0;
1200 }
1201
1202 if (!dm_task_no_open_count(dmt))
1203 log_error("Failed to disable open_count");
1204
1205 if (skip_lockfs && !dm_task_skip_lockfs(dmt))
1206 log_error("Failed to set skip_lockfs flag.");
1207
1208 if (no_flush && !dm_task_no_flush(dmt))
1209 log_error("Failed to set no_flush flag.");
1210
1211 if ((r = dm_task_run(dmt))) {
1212 inc_suspended();
1213 r = dm_task_get_info(dmt, newinfo);
1214 }
1215
1216 dm_task_destroy(dmt);
1217
1218 return r;
1219 }
1220
1221 static int _thin_pool_status_transaction_id(struct dm_tree_node *dnode, uint64_t *transaction_id)
1222 {
1223 struct dm_task *dmt;
1224 int r = 0;
1225 uint64_t start, length;
1226 char *type = NULL;
1227 char *params = NULL;
1228
1229 if (!(dmt = dm_task_create(DM_DEVICE_STATUS)))
1230 return_0;
1231
1232 if (!dm_task_set_major(dmt, dnode->info.major) ||
1233 !dm_task_set_minor(dmt, dnode->info.minor)) {
1234 log_error("Failed to set major minor.");
1235 goto out;
1236 }
1237
1238 if (!dm_task_run(dmt))
1239 goto_out;
1240
1241 dm_get_next_target(dmt, NULL, &start, &length, &type, &params);
1242
1243 if (type && (strcmp(type, "thin-pool") != 0)) {
1244 log_error(INTERNAL_ERROR
1245 "Expected thin-pool target for %d:%d and got %s.",
1246 dnode->info.major, dnode->info.minor, type);
1247 goto out;
1248 }
1249
1250 if (!params || (sscanf(params, "%" PRIu64, transaction_id) != 1)) {
1251 log_error(INTERNAL_ERROR
1252 "Failed to parse transaction_id from %s.", params);
1253 goto out;
1254 }
1255
1256 log_debug("Thin pool transaction id: %" PRIu64 " status: %s.", *transaction_id, params);
1257
1258 r = 1;
1259 out:
1260 dm_task_destroy(dmt);
1261
1262 return r;
1263 }
1264
1265 static int _thin_pool_node_message(struct dm_tree_node *dnode, struct thin_message *tm)
1266 {
1267 struct dm_task *dmt;
1268 struct dm_thin_message *m = &tm->message;
1269 char buf[64];
1270 int r;
1271
1272 switch (m->type) {
1273 case DM_THIN_MESSAGE_CREATE_SNAP:
1274 r = dm_snprintf(buf, sizeof(buf), "create_snap %u %u",
1275 m->u.m_create_snap.device_id,
1276 m->u.m_create_snap.origin_id);
1277 break;
1278 case DM_THIN_MESSAGE_CREATE_THIN:
1279 r = dm_snprintf(buf, sizeof(buf), "create_thin %u",
1280 m->u.m_create_thin.device_id);
1281 break;
1282 case DM_THIN_MESSAGE_DELETE:
1283 r = dm_snprintf(buf, sizeof(buf), "delete %u",
1284 m->u.m_delete.device_id);
1285 break;
1286 case DM_THIN_MESSAGE_TRIM:
1287 r = dm_snprintf(buf, sizeof(buf), "trim %u %" PRIu64,
1288 m->u.m_trim.device_id,
1289 m->u.m_trim.new_size);
1290 break;
1291 case DM_THIN_MESSAGE_SET_TRANSACTION_ID:
1292 r = dm_snprintf(buf, sizeof(buf),
1293 "set_transaction_id %" PRIu64 " %" PRIu64,
1294 m->u.m_set_transaction_id.current_id,
1295 m->u.m_set_transaction_id.new_id);
1296 break;
1297 }
1298
1299 if (!r) {
1300 log_error("Failed to prepare message.");
1301 return 0;
1302 }
1303
1304 r = 0;
1305
1306 if (!(dmt = dm_task_create(DM_DEVICE_TARGET_MSG)))
1307 return_0;
1308
1309 if (!dm_task_set_major(dmt, dnode->info.major) ||
1310 !dm_task_set_minor(dmt, dnode->info.minor)) {
1311 log_error("Failed to set message major minor.");
1312 goto out;
1313 }
1314
1315 if (!dm_task_set_message(dmt, buf))
1316 goto_out;
1317
1318 /* Internal functionality of dm_task */
1319 dmt->expected_errno = tm->expected_errno;
1320
1321 if (!dm_task_run(dmt))
1322 goto_out;
1323
1324 r = 1;
1325 out:
1326 dm_task_destroy(dmt);
1327
1328 return r;
1329 }
1330
1331 static int _node_send_messages(struct dm_tree_node *dnode,
1332 const char *uuid_prefix,
1333 size_t uuid_prefix_len)
1334 {
1335 struct load_segment *seg;
1336 struct thin_message *tmsg;
1337 uint64_t trans_id;
1338 const char *uuid;
1339
1340 if ((dnode == &dnode->dtree->root) || /* root has props.segs uninitialized */
1341 !dnode->info.exists || (dm_list_size(&dnode->props.segs) != 1))
1342 return 1;
1343
1344 seg = dm_list_item(dm_list_last(&dnode->props.segs), struct load_segment);
1345 if (seg->type != SEG_THIN_POOL)
1346 return 1;
1347
1348 if (!(uuid = dm_tree_node_get_uuid(dnode)))
1349 return_0;
1350
1351 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len)) {
1352 log_debug("UUID \"%s\" does not match.", uuid);
1353 return 1;
1354 }
1355
1356 if (!_thin_pool_status_transaction_id(dnode, &trans_id))
1357 return_0;
1358
1359 if (trans_id == dnode->props.thin_pool_transaction_id)
1360 return 1; /* In sync - skip messages */
1361
1362 if (trans_id != (dnode->props.thin_pool_transaction_id - 1)) {
1363 log_error("Thin pool transaction_id=%" PRIu64 ", while expected: %" PRIu64 ".",
1364 trans_id, dnode->props.thin_pool_transaction_id - 1);
1365 return 0; /* Nothing to send */
1366 }
1367
1368 dm_list_iterate_items(tmsg, &seg->thin_messages)
1369 if (!(_thin_pool_node_message(dnode, tmsg)))
1370 return_0;
1371
1372 return 1;
1373 }
1374
1375 /*
1376 * FIXME Don't attempt to deactivate known internal dependencies.
1377 */
1378 static int _dm_tree_deactivate_children(struct dm_tree_node *dnode,
1379 const char *uuid_prefix,
1380 size_t uuid_prefix_len,
1381 unsigned level)
1382 {
1383 int r = 1;
1384 void *handle = NULL;
1385 struct dm_tree_node *child = dnode;
1386 struct dm_info info;
1387 const struct dm_info *dinfo;
1388 const char *name;
1389 const char *uuid;
1390
1391 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1392 if (!(dinfo = dm_tree_node_get_info(child))) {
1393 stack;
1394 continue;
1395 }
1396
1397 if (!(name = dm_tree_node_get_name(child))) {
1398 stack;
1399 continue;
1400 }
1401
1402 if (!(uuid = dm_tree_node_get_uuid(child))) {
1403 stack;
1404 continue;
1405 }
1406
1407 /* Ignore if it doesn't belong to this VG */
1408 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1409 continue;
1410
1411 /* Refresh open_count */
1412 if (!_info_by_dev(dinfo->major, dinfo->minor, 1, &info) ||
1413 !info.exists)
1414 continue;
1415
1416 if (info.open_count) {
1417 /* Skip internal non-toplevel opened nodes */
1418 if (level)
1419 continue;
1420
1421 /* When retry is not allowed, error */
1422 if (!child->dtree->retry_remove) {
1423 log_error("Unable to deactivate open %s (%" PRIu32
1424 ":%" PRIu32 ")", name, info.major, info.minor);
1425 r = 0;
1426 continue;
1427 }
1428
1429 /* Check toplevel node for holders/mounted fs */
1430 if (!_check_device_not_in_use(name, &info)) {
1431 stack;
1432 r = 0;
1433 continue;
1434 }
1435 /* Go on with retry */
1436 }
1437
1438 /* Also checking open_count in parent nodes of presuspend_node */
1439 if ((child->presuspend_node &&
1440 !_node_has_closed_parents(child->presuspend_node,
1441 uuid_prefix, uuid_prefix_len))) {
1442 /* Only report error from (likely non-internal) dependency at top level */
1443 if (!level) {
1444 log_error("Unable to deactivate open %s (%" PRIu32
1445 ":%" PRIu32 ")", name, info.major,
1446 info.minor);
1447 r = 0;
1448 }
1449 continue;
1450 }
1451
1452 /* Suspend child node first if requested */
1453 if (child->presuspend_node &&
1454 !dm_tree_suspend_children(child, uuid_prefix, uuid_prefix_len))
1455 continue;
1456
1457 if (!_deactivate_node(name, info.major, info.minor,
1458 &child->dtree->cookie, child->udev_flags,
1459 (level == 0) ? child->dtree->retry_remove : 0)) {
1460 log_error("Unable to deactivate %s (%" PRIu32
1461 ":%" PRIu32 ")", name, info.major,
1462 info.minor);
1463 r = 0;
1464 continue;
1465 } else if (info.suspended)
1466 dec_suspended();
1467
1468 if (dm_tree_node_num_children(child, 0)) {
1469 if (!_dm_tree_deactivate_children(child, uuid_prefix, uuid_prefix_len, level + 1))
1470 return_0;
1471 }
1472 }
1473
1474 return r;
1475 }
1476
1477 int dm_tree_deactivate_children(struct dm_tree_node *dnode,
1478 const char *uuid_prefix,
1479 size_t uuid_prefix_len)
1480 {
1481 return _dm_tree_deactivate_children(dnode, uuid_prefix, uuid_prefix_len, 0);
1482 }
1483
1484 void dm_tree_skip_lockfs(struct dm_tree_node *dnode)
1485 {
1486 dnode->dtree->skip_lockfs = 1;
1487 }
1488
1489 void dm_tree_use_no_flush_suspend(struct dm_tree_node *dnode)
1490 {
1491 dnode->dtree->no_flush = 1;
1492 }
1493
1494 void dm_tree_retry_remove(struct dm_tree_node *dnode)
1495 {
1496 dnode->dtree->retry_remove = 1;
1497 }
1498
1499 int dm_tree_suspend_children(struct dm_tree_node *dnode,
1500 const char *uuid_prefix,
1501 size_t uuid_prefix_len)
1502 {
1503 int r = 1;
1504 void *handle = NULL;
1505 struct dm_tree_node *child = dnode;
1506 struct dm_info info, newinfo;
1507 const struct dm_info *dinfo;
1508 const char *name;
1509 const char *uuid;
1510
1511 /* Suspend nodes at this level of the tree */
1512 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1513 if (!(dinfo = dm_tree_node_get_info(child))) {
1514 stack;
1515 continue;
1516 }
1517
1518 if (!(name = dm_tree_node_get_name(child))) {
1519 stack;
1520 continue;
1521 }
1522
1523 if (!(uuid = dm_tree_node_get_uuid(child))) {
1524 stack;
1525 continue;
1526 }
1527
1528 /* Ignore if it doesn't belong to this VG */
1529 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1530 continue;
1531
1532 /* Ensure immediate parents are already suspended */
1533 if (!_children_suspended(child, 1, uuid_prefix, uuid_prefix_len))
1534 continue;
1535
1536 if (!_info_by_dev(dinfo->major, dinfo->minor, 0, &info) ||
1537 !info.exists || info.suspended)
1538 continue;
1539
1540 if (!_suspend_node(name, info.major, info.minor,
1541 child->dtree->skip_lockfs,
1542 child->dtree->no_flush, &newinfo)) {
1543 log_error("Unable to suspend %s (%" PRIu32
1544 ":%" PRIu32 ")", name, info.major,
1545 info.minor);
1546 r = 0;
1547 continue;
1548 }
1549
1550 /* Update cached info */
1551 child->info = newinfo;
1552 }
1553
1554 /* Then suspend any child nodes */
1555 handle = NULL;
1556
1557 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1558 if (!(uuid = dm_tree_node_get_uuid(child))) {
1559 stack;
1560 continue;
1561 }
1562
1563 /* Ignore if it doesn't belong to this VG */
1564 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1565 continue;
1566
1567 if (dm_tree_node_num_children(child, 0))
1568 if (!dm_tree_suspend_children(child, uuid_prefix, uuid_prefix_len))
1569 return_0;
1570 }
1571
1572 return r;
1573 }
1574
1575 int dm_tree_activate_children(struct dm_tree_node *dnode,
1576 const char *uuid_prefix,
1577 size_t uuid_prefix_len)
1578 {
1579 int r = 1;
1580 void *handle = NULL;
1581 struct dm_tree_node *child = dnode;
1582 struct dm_info newinfo;
1583 const char *name;
1584 const char *uuid;
1585 int priority;
1586
1587 /* Activate children first */
1588 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1589 if (!(uuid = dm_tree_node_get_uuid(child))) {
1590 stack;
1591 continue;
1592 }
1593
1594 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1595 continue;
1596
1597 if (dm_tree_node_num_children(child, 0))
1598 if (!dm_tree_activate_children(child, uuid_prefix, uuid_prefix_len))
1599 return_0;
1600 }
1601
1602 handle = NULL;
1603
1604 for (priority = 0; priority < 3; priority++) {
1605 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1606 if (priority != child->activation_priority)
1607 continue;
1608
1609 if (!(uuid = dm_tree_node_get_uuid(child))) {
1610 stack;
1611 continue;
1612 }
1613
1614 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1615 continue;
1616
1617 if (!(name = dm_tree_node_get_name(child))) {
1618 stack;
1619 continue;
1620 }
1621
1622 /* Rename? */
1623 if (child->props.new_name) {
1624 if (!_rename_node(name, child->props.new_name, child->info.major,
1625 child->info.minor, &child->dtree->cookie,
1626 child->udev_flags)) {
1627 log_error("Failed to rename %s (%" PRIu32
1628 ":%" PRIu32 ") to %s", name, child->info.major,
1629 child->info.minor, child->props.new_name);
1630 return 0;
1631 }
1632 child->name = child->props.new_name;
1633 child->props.new_name = NULL;
1634 }
1635
1636 if (!child->info.inactive_table && !child->info.suspended)
1637 continue;
1638
1639 if (!_resume_node(child->name, child->info.major, child->info.minor,
1640 child->props.read_ahead, child->props.read_ahead_flags,
1641 &newinfo, &child->dtree->cookie, child->udev_flags, child->info.suspended)) {
1642 log_error("Unable to resume %s (%" PRIu32
1643 ":%" PRIu32 ")", child->name, child->info.major,
1644 child->info.minor);
1645 r = 0;
1646 continue;
1647 }
1648
1649 /* Update cached info */
1650 child->info = newinfo;
1651 }
1652 }
1653
1654 handle = NULL;
1655
1656 return r;
1657 }
1658
1659 static int _create_node(struct dm_tree_node *dnode)
1660 {
1661 int r = 0;
1662 struct dm_task *dmt;
1663
1664 log_verbose("Creating %s", dnode->name);
1665
1666 if (!(dmt = dm_task_create(DM_DEVICE_CREATE))) {
1667 log_error("Create dm_task creation failed for %s", dnode->name);
1668 return 0;
1669 }
1670
1671 if (!dm_task_set_name(dmt, dnode->name)) {
1672 log_error("Failed to set device name for %s", dnode->name);
1673 goto out;
1674 }
1675
1676 if (!dm_task_set_uuid(dmt, dnode->uuid)) {
1677 log_error("Failed to set uuid for %s", dnode->name);
1678 goto out;
1679 }
1680
1681 if (dnode->props.major &&
1682 (!dm_task_set_major(dmt, dnode->props.major) ||
1683 !dm_task_set_minor(dmt, dnode->props.minor))) {
1684 log_error("Failed to set device number for %s creation.", dnode->name);
1685 goto out;
1686 }
1687
1688 if (dnode->props.read_only && !dm_task_set_ro(dmt)) {
1689 log_error("Failed to set read only flag for %s", dnode->name);
1690 goto out;
1691 }
1692
1693 if (!dm_task_no_open_count(dmt))
1694 log_error("Failed to disable open_count");
1695
1696 if ((r = dm_task_run(dmt)))
1697 r = dm_task_get_info(dmt, &dnode->info);
1698
1699 out:
1700 dm_task_destroy(dmt);
1701
1702 return r;
1703 }
1704
1705
1706 static int _build_dev_string(char *devbuf, size_t bufsize, struct dm_tree_node *node)
1707 {
1708 if (!dm_format_dev(devbuf, bufsize, node->info.major, node->info.minor)) {
1709 log_error("Failed to format %s device number for %s as dm "
1710 "target (%u,%u)",
1711 node->name, node->uuid, node->info.major, node->info.minor);
1712 return 0;
1713 }
1714
1715 return 1;
1716 }
1717
1718 /* simplify string emiting code */
1719 #define EMIT_PARAMS(p, str...)\
1720 do {\
1721 int w;\
1722 if ((w = dm_snprintf(params + p, paramsize - (size_t) p, str)) < 0) {\
1723 stack; /* Out of space */\
1724 return -1;\
1725 }\
1726 p += w;\
1727 } while (0)
1728
1729 /*
1730 * _emit_areas_line
1731 *
1732 * Returns: 1 on success, 0 on failure
1733 */
1734 static int _emit_areas_line(struct dm_task *dmt __attribute__((unused)),
1735 struct load_segment *seg, char *params,
1736 size_t paramsize, int *pos)
1737 {
1738 struct seg_area *area;
1739 char devbuf[DM_FORMAT_DEV_BUFSIZE];
1740 unsigned first_time = 1;
1741 const char *logtype, *synctype;
1742 unsigned log_parm_count;
1743
1744 dm_list_iterate_items(area, &seg->areas) {
1745 switch (seg->type) {
1746 case SEG_REPLICATOR_DEV:
1747 if (!_build_dev_string(devbuf, sizeof(devbuf), area->dev_node))
1748 return_0;
1749
1750 EMIT_PARAMS(*pos, " %d 1 %s", area->rsite_index, devbuf);
1751 if (first_time)
1752 EMIT_PARAMS(*pos, " nolog 0");
1753 else {
1754 /* Remote devices */
1755 log_parm_count = (area->flags &
1756 (DM_NOSYNC | DM_FORCESYNC)) ? 2 : 1;
1757
1758 if (!area->slog) {
1759 devbuf[0] = 0; /* Only core log parameters */
1760 logtype = "core";
1761 } else {
1762 devbuf[0] = ' '; /* Extra space before device name */
1763 if (!_build_dev_string(devbuf + 1,
1764 sizeof(devbuf) - 1,
1765 area->slog))
1766 return_0;
1767 logtype = "disk";
1768 log_parm_count++; /* Extra sync log device name parameter */
1769 }
1770
1771 EMIT_PARAMS(*pos, " %s %u%s %" PRIu64, logtype,
1772 log_parm_count, devbuf, area->region_size);
1773
1774 synctype = (area->flags & DM_NOSYNC) ?
1775 " nosync" : (area->flags & DM_FORCESYNC) ?
1776 " sync" : NULL;
1777
1778 if (synctype)
1779 EMIT_PARAMS(*pos, "%s", synctype);
1780 }
1781 break;
1782 case SEG_RAID1:
1783 case SEG_RAID4:
1784 case SEG_RAID5_LA:
1785 case SEG_RAID5_RA:
1786 case SEG_RAID5_LS:
1787 case SEG_RAID5_RS:
1788 case SEG_RAID6_ZR:
1789 case SEG_RAID6_NR:
1790 case SEG_RAID6_NC:
1791 if (!area->dev_node) {
1792 EMIT_PARAMS(*pos, " -");
1793 break;
1794 }
1795 if (!_build_dev_string(devbuf, sizeof(devbuf), area->dev_node))
1796 return_0;
1797
1798 EMIT_PARAMS(*pos, " %s", devbuf);
1799 break;
1800 default:
1801 if (!_build_dev_string(devbuf, sizeof(devbuf), area->dev_node))
1802 return_0;
1803
1804 EMIT_PARAMS(*pos, "%s%s %" PRIu64, first_time ? "" : " ",
1805 devbuf, area->offset);
1806 }
1807
1808 first_time = 0;
1809 }
1810
1811 return 1;
1812 }
1813
1814 static int _replicator_emit_segment_line(const struct load_segment *seg, char *params,
1815 size_t paramsize, int *pos)
1816 {
1817 const struct load_segment *rlog_seg;
1818 struct replicator_site *rsite;
1819 char rlogbuf[DM_FORMAT_DEV_BUFSIZE];
1820 unsigned parm_count;
1821
1822 if (!seg->log || !_build_dev_string(rlogbuf, sizeof(rlogbuf), seg->log))
1823 return_0;
1824
1825 rlog_seg = dm_list_item(dm_list_last(&seg->log->props.segs),
1826 struct load_segment);
1827
1828 EMIT_PARAMS(*pos, "%s 4 %s 0 auto %" PRIu64,
1829 seg->rlog_type, rlogbuf, rlog_seg->size);
1830
1831 dm_list_iterate_items(rsite, &seg->rsites) {
1832 parm_count = (rsite->fall_behind_data
1833 || rsite->fall_behind_ios
1834 || rsite->async_timeout) ? 4 : 2;
1835
1836 EMIT_PARAMS(*pos, " blockdev %u %u %s", parm_count, rsite->rsite_index,
1837 (rsite->mode == DM_REPLICATOR_SYNC) ? "synchronous" : "asynchronous");
1838
1839 if (rsite->fall_behind_data)
1840 EMIT_PARAMS(*pos, " data %" PRIu64, rsite->fall_behind_data);
1841 else if (rsite->fall_behind_ios)
1842 EMIT_PARAMS(*pos, " ios %" PRIu32, rsite->fall_behind_ios);
1843 else if (rsite->async_timeout)
1844 EMIT_PARAMS(*pos, " timeout %" PRIu32, rsite->async_timeout);
1845 }
1846
1847 return 1;
1848 }
1849
1850 /*
1851 * Returns: 1 on success, 0 on failure
1852 */
1853 static int _mirror_emit_segment_line(struct dm_task *dmt, struct load_segment *seg,
1854 char *params, size_t paramsize)
1855 {
1856 int block_on_error = 0;
1857 int handle_errors = 0;
1858 int dm_log_userspace = 0;
1859 struct utsname uts;
1860 unsigned log_parm_count;
1861 int pos = 0, parts;
1862 char logbuf[DM_FORMAT_DEV_BUFSIZE];
1863 const char *logtype;
1864 unsigned kmaj = 0, kmin = 0, krel = 0;
1865
1866 if (uname(&uts) == -1) {
1867 log_error("Cannot read kernel release version.");
1868 return 0;
1869 }
1870
1871 /* Kernels with a major number of 2 always had 3 parts. */
1872 parts = sscanf(uts.release, "%u.%u.%u", &kmaj, &kmin, &krel);
1873 if (parts < 1 || (kmaj < 3 && parts < 3)) {
1874 log_error("Wrong kernel release version %s.", uts.release);
1875 return 0;
1876 }
1877
1878 if ((seg->flags & DM_BLOCK_ON_ERROR)) {
1879 /*
1880 * Originally, block_on_error was an argument to the log
1881 * portion of the mirror CTR table. It was renamed to
1882 * "handle_errors" and now resides in the 'features'
1883 * section of the mirror CTR table (i.e. at the end).
1884 *
1885 * We can identify whether to use "block_on_error" or
1886 * "handle_errors" by the dm-mirror module's version
1887 * number (>= 1.12) or by the kernel version (>= 2.6.22).
1888 */
1889 if (KERNEL_VERSION(kmaj, kmin, krel) >= KERNEL_VERSION(2, 6, 22))
1890 handle_errors = 1;
1891 else
1892 block_on_error = 1;
1893 }
1894
1895 if (seg->clustered) {
1896 /* Cluster mirrors require a UUID */
1897 if (!seg->uuid)
1898 return_0;
1899
1900 /*
1901 * Cluster mirrors used to have their own log
1902 * types. Now they are accessed through the
1903 * userspace log type.
1904 *
1905 * The dm-log-userspace module was added to the
1906 * 2.6.31 kernel.
1907 */
1908 if (KERNEL_VERSION(kmaj, kmin, krel) >= KERNEL_VERSION(2, 6, 31))
1909 dm_log_userspace = 1;
1910 }
1911
1912 /* Region size */
1913 log_parm_count = 1;
1914
1915 /* [no]sync, block_on_error etc. */
1916 log_parm_count += hweight32(seg->flags);
1917
1918 /* "handle_errors" is a feature arg now */
1919 if (handle_errors)
1920 log_parm_count--;
1921
1922 /* DM_CORELOG does not count in the param list */
1923 if (seg->flags & DM_CORELOG)
1924 log_parm_count--;
1925
1926 if (seg->clustered) {
1927 log_parm_count++; /* For UUID */
1928
1929 if (!dm_log_userspace)
1930 EMIT_PARAMS(pos, "clustered-");
1931 else
1932 /* For clustered-* type field inserted later */
1933 log_parm_count++;
1934 }
1935
1936 if (!seg->log)
1937 logtype = "core";
1938 else {
1939 logtype = "disk";
1940 log_parm_count++;
1941 if (!_build_dev_string(logbuf, sizeof(logbuf), seg->log))
1942 return_0;
1943 }
1944
1945 if (dm_log_userspace)
1946 EMIT_PARAMS(pos, "userspace %u %s clustered-%s",
1947 log_parm_count, seg->uuid, logtype);
1948 else
1949 EMIT_PARAMS(pos, "%s %u", logtype, log_parm_count);
1950
1951 if (seg->log)
1952 EMIT_PARAMS(pos, " %s", logbuf);
1953
1954 EMIT_PARAMS(pos, " %u", seg->region_size);
1955
1956 if (seg->clustered && !dm_log_userspace)
1957 EMIT_PARAMS(pos, " %s", seg->uuid);
1958
1959 if ((seg->flags & DM_NOSYNC))
1960 EMIT_PARAMS(pos, " nosync");
1961 else if ((seg->flags & DM_FORCESYNC))
1962 EMIT_PARAMS(pos, " sync");
1963
1964 if (block_on_error)
1965 EMIT_PARAMS(pos, " block_on_error");
1966
1967 EMIT_PARAMS(pos, " %u ", seg->mirror_area_count);
1968
1969 if (_emit_areas_line(dmt, seg, params, paramsize, &pos) <= 0)
1970 return_0;
1971
1972 if (handle_errors)
1973 EMIT_PARAMS(pos, " 1 handle_errors");
1974
1975 return 1;
1976 }
1977
1978 static int _raid_emit_segment_line(struct dm_task *dmt, uint32_t major,
1979 uint32_t minor, struct load_segment *seg,
1980 uint64_t *seg_start, char *params,
1981 size_t paramsize)
1982 {
1983 uint32_t i;
1984 int param_count = 1; /* mandatory 'chunk size'/'stripe size' arg */
1985 int pos = 0;
1986
1987 if ((seg->flags & DM_NOSYNC) || (seg->flags & DM_FORCESYNC))
1988 param_count++;
1989
1990 if (seg->region_size)
1991 param_count += 2;
1992
1993 /* rebuilds is 64-bit */
1994 param_count += 2 * hweight32(seg->rebuilds & 0xFFFFFFFF);
1995 param_count += 2 * hweight32(seg->rebuilds >> 32);
1996
1997 if ((seg->type == SEG_RAID1) && seg->stripe_size)
1998 log_error("WARNING: Ignoring RAID1 stripe size");
1999
2000 EMIT_PARAMS(pos, "%s %d %u", dm_segtypes[seg->type].target,
2001 param_count, seg->stripe_size);
2002
2003 if (seg->flags & DM_NOSYNC)
2004 EMIT_PARAMS(pos, " nosync");
2005 else if (seg->flags & DM_FORCESYNC)
2006 EMIT_PARAMS(pos, " sync");
2007
2008 if (seg->region_size)
2009 EMIT_PARAMS(pos, " region_size %u", seg->region_size);
2010
2011 for (i = 0; i < (seg->area_count / 2); i++)
2012 if (seg->rebuilds & (1 << i))
2013 EMIT_PARAMS(pos, " rebuild %u", i);
2014
2015 /* Print number of metadata/data device pairs */
2016 EMIT_PARAMS(pos, " %u", seg->area_count/2);
2017
2018 if (_emit_areas_line(dmt, seg, params, paramsize, &pos) <= 0)
2019 return_0;
2020
2021 return 1;
2022 }
2023
2024 static int _emit_segment_line(struct dm_task *dmt, uint32_t major,
2025 uint32_t minor, struct load_segment *seg,
2026 uint64_t *seg_start, char *params,
2027 size_t paramsize)
2028 {
2029 int pos = 0;
2030 int r;
2031 int target_type_is_raid = 0;
2032 char originbuf[DM_FORMAT_DEV_BUFSIZE], cowbuf[DM_FORMAT_DEV_BUFSIZE];
2033 char pool[DM_FORMAT_DEV_BUFSIZE], metadata[DM_FORMAT_DEV_BUFSIZE];
2034
2035 switch(seg->type) {
2036 case SEG_ERROR:
2037 case SEG_ZERO:
2038 case SEG_LINEAR:
2039 break;
2040 case SEG_MIRRORED:
2041 /* Mirrors are pretty complicated - now in separate function */
2042 r = _mirror_emit_segment_line(dmt, seg, params, paramsize);
2043 if (!r)
2044 return_0;
2045 break;
2046 case SEG_REPLICATOR:
2047 if ((r = _replicator_emit_segment_line(seg, params, paramsize,
2048 &pos)) <= 0) {
2049 stack;
2050 return r;
2051 }
2052 break;
2053 case SEG_REPLICATOR_DEV:
2054 if (!seg->replicator || !_build_dev_string(originbuf,
2055 sizeof(originbuf),
2056 seg->replicator))
2057 return_0;
2058
2059 EMIT_PARAMS(pos, "%s %" PRIu64, originbuf, seg->rdevice_index);
2060 break;
2061 case SEG_SNAPSHOT:
2062 case SEG_SNAPSHOT_MERGE:
2063 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin))
2064 return_0;
2065 if (!_build_dev_string(cowbuf, sizeof(cowbuf), seg->cow))
2066 return_0;
2067 EMIT_PARAMS(pos, "%s %s %c %d", originbuf, cowbuf,
2068 seg->persistent ? 'P' : 'N', seg->chunk_size);
2069 break;
2070 case SEG_SNAPSHOT_ORIGIN:
2071 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin))
2072 return_0;
2073 EMIT_PARAMS(pos, "%s", originbuf);
2074 break;
2075 case SEG_STRIPED:
2076 EMIT_PARAMS(pos, "%u %u ", seg->area_count, seg->stripe_size);
2077 break;
2078 case SEG_CRYPT:
2079 EMIT_PARAMS(pos, "%s%s%s%s%s %s %" PRIu64 " ", seg->cipher,
2080 seg->chainmode ? "-" : "", seg->chainmode ?: "",
2081 seg->iv ? "-" : "", seg->iv ?: "", seg->key,
2082 seg->iv_offset != DM_CRYPT_IV_DEFAULT ?
2083 seg->iv_offset : *seg_start);
2084 break;
2085 case SEG_RAID1:
2086 case SEG_RAID4:
2087 case SEG_RAID5_LA:
2088 case SEG_RAID5_RA:
2089 case SEG_RAID5_LS:
2090 case SEG_RAID5_RS:
2091 case SEG_RAID6_ZR:
2092 case SEG_RAID6_NR:
2093 case SEG_RAID6_NC:
2094 target_type_is_raid = 1;
2095 r = _raid_emit_segment_line(dmt, major, minor, seg, seg_start,
2096 params, paramsize);
2097 if (!r)
2098 return_0;
2099
2100 break;
2101 case SEG_THIN_POOL:
2102 if (!_build_dev_string(metadata, sizeof(metadata), seg->metadata))
2103 return_0;
2104 if (!_build_dev_string(pool, sizeof(pool), seg->pool))
2105 return_0;
2106 EMIT_PARAMS(pos, "%s %s %d %" PRIu64 " %s", metadata, pool,
2107 seg->data_block_size, seg->low_water_mark,
2108 seg->skip_block_zeroing ? "1 skip_block_zeroing" : "0");
2109 break;
2110 case SEG_THIN:
2111 if (!_build_dev_string(pool, sizeof(pool), seg->pool))
2112 return_0;
2113 EMIT_PARAMS(pos, "%s %d", pool, seg->device_id);
2114 break;
2115 }
2116
2117 switch(seg->type) {
2118 case SEG_ERROR:
2119 case SEG_REPLICATOR:
2120 case SEG_SNAPSHOT:
2121 case SEG_SNAPSHOT_ORIGIN:
2122 case SEG_SNAPSHOT_MERGE:
2123 case SEG_ZERO:
2124 case SEG_THIN_POOL:
2125 case SEG_THIN:
2126 break;
2127 case SEG_CRYPT:
2128 case SEG_LINEAR:
2129 case SEG_REPLICATOR_DEV:
2130 case SEG_STRIPED:
2131 if ((r = _emit_areas_line(dmt, seg, params, paramsize, &pos)) <= 0) {
2132 stack;
2133 return r;
2134 }
2135 if (!params[0]) {
2136 log_error("No parameters supplied for %s target "
2137 "%u:%u.", dm_segtypes[seg->type].target,
2138 major, minor);
2139 return 0;
2140 }
2141 break;
2142 }
2143
2144 log_debug("Adding target to (%" PRIu32 ":%" PRIu32 "): %" PRIu64
2145 " %" PRIu64 " %s %s", major, minor,
2146 *seg_start, seg->size, target_type_is_raid ? "raid" :
2147 dm_segtypes[seg->type].target, params);
2148
2149 if (!dm_task_add_target(dmt, *seg_start, seg->size,
2150 target_type_is_raid ? "raid" :
2151 dm_segtypes[seg->type].target, params))
2152 return_0;
2153
2154 *seg_start += seg->size;
2155
2156 return 1;
2157 }
2158
2159 #undef EMIT_PARAMS
2160
2161 static int _emit_segment(struct dm_task *dmt, uint32_t major, uint32_t minor,
2162 struct load_segment *seg, uint64_t *seg_start)
2163 {
2164 char *params;
2165 size_t paramsize = 4096;
2166 int ret;
2167
2168 do {
2169 if (!(params = dm_malloc(paramsize))) {
2170 log_error("Insufficient space for target parameters.");
2171 return 0;
2172 }
2173
2174 params[0] = '\0';
2175 ret = _emit_segment_line(dmt, major, minor, seg, seg_start,
2176 params, paramsize);
2177 dm_free(params);
2178
2179 if (!ret)
2180 stack;
2181
2182 if (ret >= 0)
2183 return ret;
2184
2185 log_debug("Insufficient space in params[%" PRIsize_t
2186 "] for target parameters.", paramsize);
2187
2188 paramsize *= 2;
2189 } while (paramsize < MAX_TARGET_PARAMSIZE);
2190
2191 log_error("Target parameter size too big. Aborting.");
2192 return 0;
2193 }
2194
2195 static int _load_node(struct dm_tree_node *dnode)
2196 {
2197 int r = 0;
2198 struct dm_task *dmt;
2199 struct load_segment *seg;
2200 uint64_t seg_start = 0, existing_table_size;
2201
2202 log_verbose("Loading %s table (%" PRIu32 ":%" PRIu32 ")", dnode->name,
2203 dnode->info.major, dnode->info.minor);
2204
2205 if (!(dmt = dm_task_create(DM_DEVICE_RELOAD))) {
2206 log_error("Reload dm_task creation failed for %s", dnode->name);
2207 return 0;
2208 }
2209
2210 if (!dm_task_set_major(dmt, dnode->info.major) ||
2211 !dm_task_set_minor(dmt, dnode->info.minor)) {
2212 log_error("Failed to set device number for %s reload.", dnode->name);
2213 goto out;
2214 }
2215
2216 if (dnode->props.read_only && !dm_task_set_ro(dmt)) {
2217 log_error("Failed to set read only flag for %s", dnode->name);
2218 goto out;
2219 }
2220
2221 if (!dm_task_no_open_count(dmt))
2222 log_error("Failed to disable open_count");
2223
2224 dm_list_iterate_items(seg, &dnode->props.segs)
2225 if (!_emit_segment(dmt, dnode->info.major, dnode->info.minor,
2226 seg, &seg_start))
2227 goto_out;
2228
2229 if (!dm_task_suppress_identical_reload(dmt))
2230 log_error("Failed to suppress reload of identical tables.");
2231
2232 if ((r = dm_task_run(dmt))) {
2233 r = dm_task_get_info(dmt, &dnode->info);
2234 if (r && !dnode->info.inactive_table)
2235 log_verbose("Suppressed %s identical table reload.",
2236 dnode->name);
2237
2238 existing_table_size = dm_task_get_existing_table_size(dmt);
2239 if ((dnode->props.size_changed =
2240 (existing_table_size == seg_start) ? 0 : 1)) {
2241 log_debug("Table size changed from %" PRIu64 " to %"
2242 PRIu64 " for %s", existing_table_size,
2243 seg_start, dnode->name);
2244 /*
2245 * Kernel usually skips size validation on zero-length devices
2246 * now so no need to preload them.
2247 */
2248 /* FIXME In which kernel version did this begin? */
2249 if (!existing_table_size && dnode->props.delay_resume_if_new)
2250 dnode->props.size_changed = 0;
2251 }
2252 }
2253
2254 dnode->props.segment_count = 0;
2255
2256 out:
2257 dm_task_destroy(dmt);
2258
2259 return r;
2260 }
2261
2262 int dm_tree_preload_children(struct dm_tree_node *dnode,
2263 const char *uuid_prefix,
2264 size_t uuid_prefix_len)
2265 {
2266 int r = 1;
2267 void *handle = NULL;
2268 struct dm_tree_node *child;
2269 struct dm_info newinfo;
2270 int update_devs_flag = 0;
2271
2272 /* Preload children first */
2273 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
2274 /* Skip existing non-device-mapper devices */
2275 if (!child->info.exists && child->info.major)
2276 continue;
2277
2278 /* Ignore if it doesn't belong to this VG */
2279 if (child->info.exists &&
2280 !_uuid_prefix_matches(child->uuid, uuid_prefix, uuid_prefix_len))
2281 continue;
2282
2283 if (dm_tree_node_num_children(child, 0))
2284 if (!dm_tree_preload_children(child, uuid_prefix, uuid_prefix_len))
2285 return_0;
2286
2287 /* FIXME Cope if name exists with no uuid? */
2288 if (!child->info.exists && !_create_node(child))
2289 return_0;
2290
2291 if (!child->info.inactive_table &&
2292 child->props.segment_count &&
2293 !_load_node(child))
2294 return_0;
2295
2296 /* Propagate device size change change */
2297 if (child->props.size_changed)
2298 dnode->props.size_changed = 1;
2299
2300 /* Resume device immediately if it has parents and its size changed */
2301 if (!dm_tree_node_num_children(child, 1) || !child->props.size_changed)
2302 continue;
2303
2304 if (!child->info.inactive_table && !child->info.suspended)
2305 continue;
2306
2307 if (!_resume_node(child->name, child->info.major, child->info.minor,
2308 child->props.read_ahead, child->props.read_ahead_flags,
2309 &newinfo, &child->dtree->cookie, child->udev_flags,
2310 child->info.suspended)) {
2311 log_error("Unable to resume %s (%" PRIu32
2312 ":%" PRIu32 ")", child->name, child->info.major,
2313 child->info.minor);
2314 r = 0;
2315 continue;
2316 }
2317
2318 /* Update cached info */
2319 child->info = newinfo;
2320
2321 /*
2322 * Prepare for immediate synchronization with udev and flush all stacked
2323 * dev node operations if requested by immediate_dev_node property. But
2324 * finish processing current level in the tree first.
2325 */
2326 if (child->props.immediate_dev_node)
2327 update_devs_flag = 1;
2328 }
2329
2330 handle = NULL;
2331
2332 if (update_devs_flag) {
2333 if (!dm_udev_wait(dm_tree_get_cookie(dnode)))
2334 stack;
2335 dm_tree_set_cookie(dnode, 0);
2336 }
2337
2338 if (r && !_node_send_messages(dnode, uuid_prefix, uuid_prefix_len)) {
2339 stack;
2340 if (!(dm_tree_deactivate_children(dnode, uuid_prefix, uuid_prefix_len)))
2341 log_error("Failed to deactivate %s", dnode->name);
2342 r = 0;
2343 }
2344
2345 return r;
2346 }
2347
2348 /*
2349 * Returns 1 if unsure.
2350 */
2351 int dm_tree_children_use_uuid(struct dm_tree_node *dnode,
2352 const char *uuid_prefix,
2353 size_t uuid_prefix_len)
2354 {
2355 void *handle = NULL;
2356 struct dm_tree_node *child = dnode;
2357 const char *uuid;
2358
2359 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
2360 if (!(uuid = dm_tree_node_get_uuid(child))) {
2361 log_error("Failed to get uuid for dtree node.");
2362 return 1;
2363 }
2364
2365 if (_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
2366 return 1;
2367
2368 if (dm_tree_node_num_children(child, 0))
2369 dm_tree_children_use_uuid(child, uuid_prefix, uuid_prefix_len);
2370 }
2371
2372 return 0;
2373 }
2374
2375 /*
2376 * Target functions
2377 */
2378 static struct load_segment *_add_segment(struct dm_tree_node *dnode, unsigned type, uint64_t size)
2379 {
2380 struct load_segment *seg;
2381
2382 if (!(seg = dm_pool_zalloc(dnode->dtree->mem, sizeof(*seg)))) {
2383 log_error("dtree node segment allocation failed");
2384 return NULL;
2385 }
2386
2387 seg->type = type;
2388 seg->size = size;
2389 seg->area_count = 0;
2390 dm_list_init(&seg->areas);
2391 seg->stripe_size = 0;
2392 seg->persistent = 0;
2393 seg->chunk_size = 0;
2394 seg->cow = NULL;
2395 seg->origin = NULL;
2396 seg->merge = NULL;
2397
2398 dm_list_add(&dnode->props.segs, &seg->list);
2399 dnode->props.segment_count++;
2400
2401 return seg;
2402 }
2403
2404 int dm_tree_node_add_snapshot_origin_target(struct dm_tree_node *dnode,
2405 uint64_t size,
2406 const char *origin_uuid)
2407 {
2408 struct load_segment *seg;
2409 struct dm_tree_node *origin_node;
2410
2411 if (!(seg = _add_segment(dnode, SEG_SNAPSHOT_ORIGIN, size)))
2412 return_0;
2413
2414 if (!(origin_node = dm_tree_find_node_by_uuid(dnode->dtree, origin_uuid))) {
2415 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid);
2416 return 0;
2417 }
2418
2419 seg->origin = origin_node;
2420 if (!_link_tree_nodes(dnode, origin_node))
2421 return_0;
2422
2423 /* Resume snapshot origins after new snapshots */
2424 dnode->activation_priority = 1;
2425
2426 return 1;
2427 }
2428
2429 static int _add_snapshot_target(struct dm_tree_node *node,
2430 uint64_t size,
2431 const char *origin_uuid,
2432 const char *cow_uuid,
2433 const char *merge_uuid,
2434 int persistent,
2435 uint32_t chunk_size)
2436 {
2437 struct load_segment *seg;
2438 struct dm_tree_node *origin_node, *cow_node, *merge_node;
2439 unsigned seg_type;
2440
2441 seg_type = !merge_uuid ? SEG_SNAPSHOT : SEG_SNAPSHOT_MERGE;
2442
2443 if (!(seg = _add_segment(node, seg_type, size)))
2444 return_0;
2445
2446 if (!(origin_node = dm_tree_find_node_by_uuid(node->dtree, origin_uuid))) {
2447 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid);
2448 return 0;
2449 }
2450
2451 seg->origin = origin_node;
2452 if (!_link_tree_nodes(node, origin_node))
2453 return_0;
2454
2455 if (!(cow_node = dm_tree_find_node_by_uuid(node->dtree, cow_uuid))) {
2456 log_error("Couldn't find snapshot COW device uuid %s.", cow_uuid);
2457 return 0;
2458 }
2459
2460 seg->cow = cow_node;
2461 if (!_link_tree_nodes(node, cow_node))
2462 return_0;
2463
2464 seg->persistent = persistent ? 1 : 0;
2465 seg->chunk_size = chunk_size;
2466
2467 if (merge_uuid) {
2468 if (!(merge_node = dm_tree_find_node_by_uuid(node->dtree, merge_uuid))) {
2469 /* not a pure error, merging snapshot may have been deactivated */
2470 log_verbose("Couldn't find merging snapshot uuid %s.", merge_uuid);
2471 } else {
2472 seg->merge = merge_node;
2473 /* must not link merging snapshot, would undermine activation_priority below */
2474 }
2475
2476 /* Resume snapshot-merge (acting origin) after other snapshots */
2477 node->activation_priority = 1;
2478 if (seg->merge) {
2479 /* Resume merging snapshot after snapshot-merge */
2480 seg->merge->activation_priority = 2;
2481 }
2482 }
2483
2484 return 1;
2485 }
2486
2487
2488 int dm_tree_node_add_snapshot_target(struct dm_tree_node *node,
2489 uint64_t size,
2490 const char *origin_uuid,
2491 const char *cow_uuid,
2492 int persistent,
2493 uint32_t chunk_size)
2494 {
2495 return _add_snapshot_target(node, size, origin_uuid, cow_uuid,
2496 NULL, persistent, chunk_size);
2497 }
2498
2499 int dm_tree_node_add_snapshot_merge_target(struct dm_tree_node *node,
2500 uint64_t size,
2501 const char *origin_uuid,
2502 const char *cow_uuid,
2503 const char *merge_uuid,
2504 uint32_t chunk_size)
2505 {
2506 return _add_snapshot_target(node, size, origin_uuid, cow_uuid,
2507 merge_uuid, 1, chunk_size);
2508 }
2509
2510 int dm_tree_node_add_error_target(struct dm_tree_node *node,
2511 uint64_t size)
2512 {
2513 if (!_add_segment(node, SEG_ERROR, size))
2514 return_0;
2515
2516 return 1;
2517 }
2518
2519 int dm_tree_node_add_zero_target(struct dm_tree_node *node,
2520 uint64_t size)
2521 {
2522 if (!_add_segment(node, SEG_ZERO, size))
2523 return_0;
2524
2525 return 1;
2526 }
2527
2528 int dm_tree_node_add_linear_target(struct dm_tree_node *node,
2529 uint64_t size)
2530 {
2531 if (!_add_segment(node, SEG_LINEAR, size))
2532 return_0;
2533
2534 return 1;
2535 }
2536
2537 int dm_tree_node_add_striped_target(struct dm_tree_node *node,
2538 uint64_t size,
2539 uint32_t stripe_size)
2540 {
2541 struct load_segment *seg;
2542
2543 if (!(seg = _add_segment(node, SEG_STRIPED, size)))
2544 return_0;
2545
2546 seg->stripe_size = stripe_size;
2547
2548 return 1;
2549 }
2550
2551 int dm_tree_node_add_crypt_target(struct dm_tree_node *node,
2552 uint64_t size,
2553 const char *cipher,
2554 const char *chainmode,
2555 const char *iv,
2556 uint64_t iv_offset,
2557 const char *key)
2558 {
2559 struct load_segment *seg;
2560
2561 if (!(seg = _add_segment(node, SEG_CRYPT, size)))
2562 return_0;
2563
2564 seg->cipher = cipher;
2565 seg->chainmode = chainmode;
2566 seg->iv = iv;
2567 seg->iv_offset = iv_offset;
2568 seg->key = key;
2569
2570 return 1;
2571 }
2572
2573 int dm_tree_node_add_mirror_target_log(struct dm_tree_node *node,
2574 uint32_t region_size,
2575 unsigned clustered,
2576 const char *log_uuid,
2577 unsigned area_count,
2578 uint32_t flags)
2579 {
2580 struct dm_tree_node *log_node = NULL;
2581 struct load_segment *seg;
2582
2583 if (!node->props.segment_count) {
2584 log_error(INTERNAL_ERROR "Attempt to add target area to missing segment.");
2585 return 0;
2586 }
2587
2588 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
2589
2590 if (log_uuid) {
2591 if (!(seg->uuid = dm_pool_strdup(node->dtree->mem, log_uuid))) {
2592 log_error("log uuid pool_strdup failed");
2593 return 0;
2594 }
2595 if ((flags & DM_CORELOG))
2596 /* For pvmove: immediate resume (for size validation) isn't needed. */
2597 node->props.delay_resume_if_new = 1;
2598 else {
2599 if (!(log_node = dm_tree_find_node_by_uuid(node->dtree, log_uuid))) {
2600 log_error("Couldn't find mirror log uuid %s.", log_uuid);
2601 return 0;
2602 }
2603
2604 if (clustered)
2605 log_node->props.immediate_dev_node = 1;
2606
2607 /* The kernel validates the size of disk logs. */
2608 /* FIXME Propagate to any devices below */
2609 log_node->props.delay_resume_if_new = 0;
2610
2611 if (!_link_tree_nodes(node, log_node))
2612 return_0;
2613 }
2614 }
2615
2616 seg->log = log_node;
2617 seg->region_size = region_size;
2618 seg->clustered = clustered;
2619 seg->mirror_area_count = area_count;
2620 seg->flags = flags;
2621
2622 return 1;
2623 }
2624
2625 int dm_tree_node_add_mirror_target(struct dm_tree_node *node,
2626 uint64_t size)
2627 {
2628 if (!_add_segment(node, SEG_MIRRORED, size))
2629 return_0;
2630
2631 return 1;
2632 }
2633
2634 int dm_tree_node_add_raid_target(struct dm_tree_node *node,
2635 uint64_t size,
2636 const char *raid_type,
2637 uint32_t region_size,
2638 uint32_t stripe_size,
2639 uint64_t rebuilds,
2640 uint64_t reserved2)
2641 {
2642 int i;
2643 struct load_segment *seg = NULL;
2644
2645 for (i = 0; dm_segtypes[i].target && !seg; i++)
2646 if (!strcmp(raid_type, dm_segtypes[i].target))
2647 if (!(seg = _add_segment(node,
2648 dm_segtypes[i].type, size)))
2649 return_0;
2650
2651 if (!seg)
2652 return_0;
2653
2654 seg->region_size = region_size;
2655 seg->stripe_size = stripe_size;
2656 seg->area_count = 0;
2657 seg->rebuilds = rebuilds;
2658
2659 return 1;
2660 }
2661
2662 int dm_tree_node_add_replicator_target(struct dm_tree_node *node,
2663 uint64_t size,
2664 const char *rlog_uuid,
2665 const char *rlog_type,
2666 unsigned rsite_index,
2667 dm_replicator_mode_t mode,
2668 uint32_t async_timeout,
2669 uint64_t fall_behind_data,
2670 uint32_t fall_behind_ios)
2671 {
2672 struct load_segment *rseg;
2673 struct replicator_site *rsite;
2674
2675 /* Local site0 - adds replicator segment and links rlog device */
2676 if (rsite_index == REPLICATOR_LOCAL_SITE) {
2677 if (node->props.segment_count) {
2678 log_error(INTERNAL_ERROR "Attempt to add replicator segment to already used node.");
2679 return 0;
2680 }
2681
2682 if (!(rseg = _add_segment(node, SEG_REPLICATOR, size)))
2683 return_0;
2684
2685 if (!(rseg->log = dm_tree_find_node_by_uuid(node->dtree, rlog_uuid))) {
2686 log_error("Missing replicator log uuid %s.", rlog_uuid);
2687 return 0;
2688 }
2689
2690 if (!_link_tree_nodes(node, rseg->log))
2691 return_0;
2692
2693 if (strcmp(rlog_type, "ringbuffer") != 0) {
2694 log_error("Unsupported replicator log type %s.", rlog_type);
2695 return 0;
2696 }
2697
2698 if (!(rseg->rlog_type = dm_pool_strdup(node->dtree->mem, rlog_type)))
2699 return_0;
2700
2701 dm_list_init(&rseg->rsites);
2702 rseg->rdevice_count = 0;
2703 node->activation_priority = 1;
2704 }
2705
2706 /* Add site to segment */
2707 if (mode == DM_REPLICATOR_SYNC
2708 && (async_timeout || fall_behind_ios || fall_behind_data)) {
2709 log_error("Async parameters passed for synchronnous replicator.");
2710 return 0;
2711 }
2712
2713 if (node->props.segment_count != 1) {
2714 log_error(INTERNAL_ERROR "Attempt to add remote site area before setting replicator log.");
2715 return 0;
2716 }
2717
2718 rseg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
2719 if (rseg->type != SEG_REPLICATOR) {
2720 log_error(INTERNAL_ERROR "Attempt to use non replicator segment %s.",
2721 dm_segtypes[rseg->type].target);
2722 return 0;
2723 }
2724
2725 if (!(rsite = dm_pool_zalloc(node->dtree->mem, sizeof(*rsite)))) {
2726 log_error("Failed to allocate remote site segment.");
2727 return 0;
2728 }
2729
2730 dm_list_add(&rseg->rsites, &rsite->list);
2731 rseg->rsite_count++;
2732
2733 rsite->mode = mode;
2734 rsite->async_timeout = async_timeout;
2735 rsite->fall_behind_data = fall_behind_data;
2736 rsite->fall_behind_ios = fall_behind_ios;
2737 rsite->rsite_index = rsite_index;
2738
2739 return 1;
2740 }
2741
2742 /* Appends device node to Replicator */
2743 int dm_tree_node_add_replicator_dev_target(struct dm_tree_node *node,
2744 uint64_t size,
2745 const char *replicator_uuid,
2746 uint64_t rdevice_index,
2747 const char *rdev_uuid,
2748 unsigned rsite_index,
2749 const char *slog_uuid,
2750 uint32_t slog_flags,
2751 uint32_t slog_region_size)
2752 {
2753 struct seg_area *area;
2754 struct load_segment *rseg;
2755 struct load_segment *rep_seg;
2756
2757 if (rsite_index == REPLICATOR_LOCAL_SITE) {
2758 /* Site index for local target */
2759 if (!(rseg = _add_segment(node, SEG_REPLICATOR_DEV, size)))
2760 return_0;
2761
2762 if (!(rseg->replicator = dm_tree_find_node_by_uuid(node->dtree, replicator_uuid))) {
2763 log_error("Missing replicator uuid %s.", replicator_uuid);
2764 return 0;
2765 }
2766
2767 /* Local slink0 for replicator must be always initialized first */
2768 if (rseg->replicator->props.segment_count != 1) {
2769 log_error(INTERNAL_ERROR "Attempt to use non replicator segment.");
2770 return 0;
2771 }
2772
2773 rep_seg = dm_list_item(dm_list_last(&rseg->replicator->props.segs), struct load_segment);
2774 if (rep_seg->type != SEG_REPLICATOR) {
2775 log_error(INTERNAL_ERROR "Attempt to use non replicator segment %s.",
2776 dm_segtypes[rep_seg->type].target);
2777 return 0;
2778 }
2779 rep_seg->rdevice_count++;
2780
2781 if (!_link_tree_nodes(node, rseg->replicator))
2782 return_0;
2783
2784 rseg->rdevice_index = rdevice_index;
2785 } else {
2786 /* Local slink0 for replicator must be always initialized first */
2787 if (node->props.segment_count != 1) {
2788 log_error(INTERNAL_ERROR "Attempt to use non replicator-dev segment.");
2789 return 0;
2790 }
2791
2792 rseg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
2793 if (rseg->type != SEG_REPLICATOR_DEV) {
2794 log_error(INTERNAL_ERROR "Attempt to use non replicator-dev segment %s.",
2795 dm_segtypes[rseg->type].target);
2796 return 0;
2797 }
2798 }
2799
2800 if (!(slog_flags & DM_CORELOG) && !slog_uuid) {
2801 log_error("Unspecified sync log uuid.");
2802 return 0;
2803 }
2804
2805 if (!dm_tree_node_add_target_area(node, NULL, rdev_uuid, 0))
2806 return_0;
2807
2808 area = dm_list_item(dm_list_last(&rseg->areas), struct seg_area);
2809
2810 if (!(slog_flags & DM_CORELOG)) {
2811 if (!(area->slog = dm_tree_find_node_by_uuid(node->dtree, slog_uuid))) {
2812 log_error("Couldn't find sync log uuid %s.", slog_uuid);
2813 return 0;
2814 }
2815
2816 if (!_link_tree_nodes(node, area->slog))
2817 return_0;
2818 }
2819
2820 area->flags = slog_flags;
2821 area->region_size = slog_region_size;
2822 area->rsite_index = rsite_index;
2823
2824 return 1;
2825 }
2826
2827 static int _thin_validate_device_id(uint32_t device_id)
2828 {
2829 if (device_id > DM_THIN_MAX_DEVICE_ID) {
2830 log_error("Device id %u is higher then %u.",
2831 device_id, DM_THIN_MAX_DEVICE_ID);
2832 return 0;
2833 }
2834
2835 return 1;
2836 }
2837
2838 int dm_tree_node_add_thin_pool_target(struct dm_tree_node *node,
2839 uint64_t size,
2840 uint64_t transaction_id,
2841 const char *metadata_uuid,
2842 const char *pool_uuid,
2843 uint32_t data_block_size,
2844 uint64_t low_water_mark,
2845 unsigned skip_block_zeroing)
2846 {
2847 struct load_segment *seg;
2848
2849 if (data_block_size < DM_THIN_MIN_DATA_BLOCK_SIZE) {
2850 log_error("Data block size %u is lower then %u sectors.",
2851 data_block_size, DM_THIN_MIN_DATA_BLOCK_SIZE);
2852 return 0;
2853 }
2854
2855 if (data_block_size > DM_THIN_MAX_DATA_BLOCK_SIZE) {
2856 log_error("Data block size %u is higher then %u sectors.",
2857 data_block_size, DM_THIN_MAX_DATA_BLOCK_SIZE);
2858 return 0;
2859 }
2860
2861 if (!(seg = _add_segment(node, SEG_THIN_POOL, size)))
2862 return_0;
2863
2864 if (!(seg->metadata = dm_tree_find_node_by_uuid(node->dtree, metadata_uuid))) {
2865 log_error("Missing metadata uuid %s.", metadata_uuid);
2866 return 0;
2867 }
2868
2869 if (!_link_tree_nodes(node, seg->metadata))
2870 return_0;
2871
2872 if (!(seg->pool = dm_tree_find_node_by_uuid(node->dtree, pool_uuid))) {
2873 log_error("Missing pool uuid %s.", pool_uuid);
2874 return 0;
2875 }
2876
2877 if (!_link_tree_nodes(node, seg->pool))
2878 return_0;
2879
2880 node->props.thin_pool_transaction_id = transaction_id; // compare on resume
2881 seg->low_water_mark = low_water_mark;
2882 seg->data_block_size = data_block_size;
2883 seg->skip_block_zeroing = skip_block_zeroing;
2884 dm_list_init(&seg->thin_messages);
2885
2886 return 1;
2887 }
2888
2889 int dm_tree_node_add_thin_pool_message(struct dm_tree_node *node,
2890 const struct dm_thin_message *message)
2891 {
2892 struct load_segment *seg;
2893 struct thin_message *tm;
2894
2895 if (node->props.segment_count != 1) {
2896 log_error("Thin pool node must have only one segment.");
2897 return 0;
2898 }
2899
2900 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
2901 if (seg->type != SEG_THIN_POOL) {
2902 log_error("Thin pool node has segment type %s.",
2903 dm_segtypes[seg->type].target);
2904 return 0;
2905 }
2906
2907 if (!(tm = dm_pool_zalloc(node->dtree->mem, sizeof (*tm)))) {
2908 log_error("Failed to allocate thin message.");
2909 return 0;
2910 }
2911
2912 switch (message->type) {
2913 case DM_THIN_MESSAGE_CREATE_SNAP:
2914 /* If the thin origin is active, it must be suspend first! */
2915 if (message->u.m_create_snap.device_id == message->u.m_create_snap.origin_id) {
2916 log_error("Cannot use same device id for origin and its snapshot.");
2917 return 0;
2918 }
2919 if (!_thin_validate_device_id(message->u.m_create_snap.device_id) ||
2920 !_thin_validate_device_id(message->u.m_create_snap.origin_id))
2921 return_0;
2922 tm->message.u.m_create_snap = message->u.m_create_snap;
2923 break;
2924 case DM_THIN_MESSAGE_CREATE_THIN:
2925 if (!_thin_validate_device_id(message->u.m_create_thin.device_id))
2926 return_0;
2927 tm->message.u.m_create_thin = message->u.m_create_thin;
2928 tm->expected_errno = EEXIST;
2929 break;
2930 case DM_THIN_MESSAGE_DELETE:
2931 if (!_thin_validate_device_id(message->u.m_delete.device_id))
2932 return_0;
2933 tm->message.u.m_delete = message->u.m_delete;
2934 tm->expected_errno = ENODATA;
2935 break;
2936 case DM_THIN_MESSAGE_TRIM:
2937 if (!_thin_validate_device_id(message->u.m_trim.device_id))
2938 return_0;
2939 tm->message.u.m_trim = message->u.m_trim;
2940 break;
2941 case DM_THIN_MESSAGE_SET_TRANSACTION_ID:
2942 if (message->u.m_set_transaction_id.current_id !=
2943 (message->u.m_set_transaction_id.new_id - 1)) {
2944 log_error("New transaction_id must be sequential.");
2945 return 0; /* FIXME: Maybe too strict here? */
2946 }
2947 tm->message.u.m_set_transaction_id = message->u.m_set_transaction_id;
2948 break;
2949 default:
2950 log_error("Unsupported message type %d.", (int) message->type);
2951 return 0;
2952 }
2953
2954 tm->message.type = message->type;
2955 dm_list_add(&seg->thin_messages, &tm->list);
2956
2957 return 1;
2958 }
2959
2960 int dm_tree_node_add_thin_target(struct dm_tree_node *node,
2961 uint64_t size,
2962 const char *thin_pool_uuid,
2963 uint32_t device_id)
2964 {
2965 struct load_segment *seg;
2966
2967 if (!_thin_validate_device_id(device_id))
2968 return_0;
2969
2970 if (!(seg = _add_segment(node, SEG_THIN, size)))
2971 return_0;
2972
2973 if (!(seg->pool = dm_tree_find_node_by_uuid(node->dtree, thin_pool_uuid))) {
2974 log_error("Missing thin pool uuid %s.", thin_pool_uuid);
2975 return 0;
2976 }
2977
2978 if (!_link_tree_nodes(node, seg->pool))
2979 return_0;
2980
2981 seg->device_id = device_id;
2982
2983 return 1;
2984 }
2985
2986 static int _add_area(struct dm_tree_node *node, struct load_segment *seg, struct dm_tree_node *dev_node, uint64_t offset)
2987 {
2988 struct seg_area *area;
2989
2990 if (!(area = dm_pool_zalloc(node->dtree->mem, sizeof (*area)))) {
2991 log_error("Failed to allocate target segment area.");
2992 return 0;
2993 }
2994
2995 area->dev_node = dev_node;
2996 area->offset = offset;
2997
2998 dm_list_add(&seg->areas, &area->list);
2999 seg->area_count++;
3000
3001 return 1;
3002 }
3003
3004 int dm_tree_node_add_target_area(struct dm_tree_node *node,
3005 const char *dev_name,
3006 const char *uuid,
3007 uint64_t offset)
3008 {
3009 struct load_segment *seg;
3010 struct stat info;
3011 struct dm_tree_node *dev_node;
3012
3013 if ((!dev_name || !*dev_name) && (!uuid || !*uuid)) {
3014 log_error("dm_tree_node_add_target_area called without device");
3015 return 0;
3016 }
3017
3018 if (uuid) {
3019 if (!(dev_node = dm_tree_find_node_by_uuid(node->dtree, uuid))) {
3020 log_error("Couldn't find area uuid %s.", uuid);
3021 return 0;
3022 }
3023 if (!_link_tree_nodes(node, dev_node))
3024 return_0;
3025 } else {
3026 if (stat(dev_name, &info) < 0) {
3027 log_error("Device %s not found.", dev_name);
3028 return 0;
3029 }
3030
3031 if (!S_ISBLK(info.st_mode)) {
3032 log_error("Device %s is not a block device.", dev_name);
3033 return 0;
3034 }
3035
3036 /* FIXME Check correct macro use */
3037 if (!(dev_node = _add_dev(node->dtree, node, MAJOR(info.st_rdev),
3038 MINOR(info.st_rdev), 0)))
3039 return_0;
3040 }
3041
3042 if (!node->props.segment_count) {
3043 log_error(INTERNAL_ERROR "Attempt to add target area to missing segment.");
3044 return 0;
3045 }
3046
3047 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
3048
3049 if (!_add_area(node, seg, dev_node, offset))
3050 return_0;
3051
3052 return 1;
3053 }
3054
3055 int dm_tree_node_add_null_area(struct dm_tree_node *node, uint64_t offset)
3056 {
3057 struct load_segment *seg;
3058
3059 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
3060
3061 switch (seg->type) {
3062 case SEG_RAID1:
3063 case SEG_RAID4:
3064 case SEG_RAID5_LA:
3065 case SEG_RAID5_RA:
3066 case SEG_RAID5_LS:
3067 case SEG_RAID5_RS:
3068 case SEG_RAID6_ZR:
3069 case SEG_RAID6_NR:
3070 case SEG_RAID6_NC:
3071 break;
3072 default:
3073 log_error("dm_tree_node_add_null_area() called on an unsupported segment type");
3074 return 0;
3075 }
3076
3077 if (!_add_area(node, seg, NULL, offset))
3078 return_0;
3079
3080 return 1;
3081 }
3082
3083 void dm_tree_set_cookie(struct dm_tree_node *node, uint32_t cookie)
3084 {
3085 node->dtree->cookie = cookie;
3086 }
3087
3088 uint32_t dm_tree_get_cookie(struct dm_tree_node *node)
3089 {
3090 return node->dtree->cookie;
3091 }
This page took 0.167421 seconds and 6 git commands to generate.