2 * Copyright (C) 2005-2011 Red Hat, Inc. All rights reserved.
4 * This file is part of the device-mapper userspace tools.
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.
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
16 #include "libdm-targets.h"
17 #include "libdm-common.h"
22 #include <sys/param.h>
23 #include <sys/utsname.h>
25 #define MAX_TARGET_PARAMSIZE 500000
27 /* FIXME Fix interface so this is used only by LVM */
28 #define UUID_PREFIX "LVM-"
30 #define REPLICATOR_LOCAL_SITE 0
32 #define THIN_MIN_DATA_SIZE 128
33 #define THIN_MAX_DATA_SIZE 2097152
34 #define THIN_MAX_DEVICE_ID ((1 << 24) - 1)
38 /* Supported segment types */
65 /* FIXME Add crypt and multipath support */
71 { SEG_CRYPT
, "crypt" },
72 { SEG_ERROR
, "error" },
73 { SEG_LINEAR
, "linear" },
74 { SEG_MIRRORED
, "mirror" },
75 { SEG_REPLICATOR
, "replicator" },
76 { SEG_REPLICATOR_DEV
, "replicator-dev" },
77 { SEG_SNAPSHOT
, "snapshot" },
78 { SEG_SNAPSHOT_ORIGIN
, "snapshot-origin" },
79 { SEG_SNAPSHOT_MERGE
, "snapshot-merge" },
80 { SEG_STRIPED
, "striped" },
82 { SEG_THIN_POOL
, "thin-pool"},
84 { SEG_RAID1
, "raid1"},
85 { SEG_RAID4
, "raid4"},
86 { SEG_RAID5_LA
, "raid5_la"},
87 { SEG_RAID5_RA
, "raid5_ra"},
88 { SEG_RAID5_LS
, "raid5_ls"},
89 { SEG_RAID5_RS
, "raid5_rs"},
90 { SEG_RAID6_ZR
, "raid6_zr"},
91 { SEG_RAID6_NR
, "raid6_nr"},
92 { SEG_RAID6_NC
, "raid6_nc"},
95 *WARNING: Since 'raid' target overloads this 1:1 mapping table
96 * for search do not add new enum elements past them!
98 { SEG_RAID5_LS
, "raid5"}, /* same as "raid5_ls" (default for MD also) */
99 { SEG_RAID6_ZR
, "raid6"}, /* same as "raid6_zr" */
103 /* Some segment types have a list of areas of other devices attached */
107 struct dm_tree_node
*dev_node
;
111 unsigned rsite_index
; /* Replicator site index */
112 struct dm_tree_node
*slog
; /* Replicator sync log node */
113 uint64_t region_size
; /* Replicator sync log size */
114 uint32_t flags
; /* Replicator sync log flags */
117 /* Replicator-log has a list of sites */
118 /* FIXME: maybe move to seg_area too? */
119 struct replicator_site
{
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
;
129 /* Per-segment properties */
130 struct load_segment
{
137 unsigned area_count
; /* Linear + Striped + Mirrored + Crypt + Replicator */
138 struct dm_list areas
; /* Linear + Striped + Mirrored + Crypt + Replicator */
140 uint32_t stripe_size
; /* Striped + raid */
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 */
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 */
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 */
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 */
168 uint64_t rebuilds
; /* raid */
170 struct dm_tree_node
*metadata
; /* Thin_pool */
171 struct dm_tree_node
*pool
; /* Thin_pool, Thin */
172 uint32_t data_block_size
; /* Thin_pool */
173 uint64_t low_water_mark
; /* Thin_pool */
174 unsigned skip_block_zeroeing
; /* Thin_pool */
175 uint32_t device_id
; /* Thin */
179 /* Per-device properties */
180 struct load_properties
{
186 uint32_t read_ahead_flags
;
188 unsigned segment_count
;
189 unsigned size_changed
;
192 const char *new_name
;
194 /* If immediate_dev_node is set to 1, try to create the dev node
195 * as soon as possible (e.g. in preload stage even during traversal
196 * and processing of dm tree). This will also flush all stacked dev
197 * node operations, synchronizing with udev.
199 unsigned immediate_dev_node
;
202 * If the device size changed from zero and this is set,
203 * don't resume the device immediately, even if the device
204 * has parents. This works provided the parents do not
205 * validate the device size and is required by pvmove to
206 * avoid starting the mirror resync operation too early.
208 unsigned delay_resume_if_new
;
211 /* Two of these used to join two nodes with uses and used_by. */
212 struct dm_tree_link
{
214 struct dm_tree_node
*node
;
217 struct dm_tree_node
{
218 struct dm_tree
*dtree
;
224 struct dm_list uses
; /* Nodes this node uses */
225 struct dm_list used_by
; /* Nodes that use this node */
227 int activation_priority
; /* 0 gets activated first */
229 uint16_t udev_flags
; /* Udev control flags */
231 void *context
; /* External supplied context */
233 struct load_properties props
; /* For creation/table (re)load */
236 * If presuspend of child node is needed
237 * Note: only direct child is allowed
239 struct dm_tree_node
*presuspend_node
;
244 struct dm_hash_table
*devs
;
245 struct dm_hash_table
*uuids
;
246 struct dm_tree_node root
;
247 int skip_lockfs
; /* 1 skips lockfs (for non-snapshots) */
248 int no_flush
; /* 1 sets noflush (mirrors/multipath) */
249 int retry_remove
; /* 1 retries remove if not successful */
253 struct dm_tree
*dm_tree_create(void)
255 struct dm_tree
*dtree
;
257 if (!(dtree
= dm_zalloc(sizeof(*dtree
)))) {
258 log_error("dm_tree_create malloc failed");
262 dtree
->root
.dtree
= dtree
;
263 dm_list_init(&dtree
->root
.uses
);
264 dm_list_init(&dtree
->root
.used_by
);
265 dtree
->skip_lockfs
= 0;
268 if (!(dtree
->mem
= dm_pool_create("dtree", 1024))) {
269 log_error("dtree pool creation failed");
274 if (!(dtree
->devs
= dm_hash_create(8))) {
275 log_error("dtree hash creation failed");
276 dm_pool_destroy(dtree
->mem
);
281 if (!(dtree
->uuids
= dm_hash_create(32))) {
282 log_error("dtree uuid hash creation failed");
283 dm_hash_destroy(dtree
->devs
);
284 dm_pool_destroy(dtree
->mem
);
292 void dm_tree_free(struct dm_tree
*dtree
)
297 dm_hash_destroy(dtree
->uuids
);
298 dm_hash_destroy(dtree
->devs
);
299 dm_pool_destroy(dtree
->mem
);
303 static int _nodes_are_linked(const struct dm_tree_node
*parent
,
304 const struct dm_tree_node
*child
)
306 struct dm_tree_link
*dlink
;
308 dm_list_iterate_items(dlink
, &parent
->uses
)
309 if (dlink
->node
== child
)
315 static int _link(struct dm_list
*list
, struct dm_tree_node
*node
)
317 struct dm_tree_link
*dlink
;
319 if (!(dlink
= dm_pool_alloc(node
->dtree
->mem
, sizeof(*dlink
)))) {
320 log_error("dtree link allocation failed");
325 dm_list_add(list
, &dlink
->list
);
330 static int _link_nodes(struct dm_tree_node
*parent
,
331 struct dm_tree_node
*child
)
333 if (_nodes_are_linked(parent
, child
))
336 if (!_link(&parent
->uses
, child
))
339 if (!_link(&child
->used_by
, parent
))
345 static void _unlink(struct dm_list
*list
, struct dm_tree_node
*node
)
347 struct dm_tree_link
*dlink
;
349 dm_list_iterate_items(dlink
, list
)
350 if (dlink
->node
== node
) {
351 dm_list_del(&dlink
->list
);
356 static void _unlink_nodes(struct dm_tree_node
*parent
,
357 struct dm_tree_node
*child
)
359 if (!_nodes_are_linked(parent
, child
))
362 _unlink(&parent
->uses
, child
);
363 _unlink(&child
->used_by
, parent
);
366 static int _add_to_toplevel(struct dm_tree_node
*node
)
368 return _link_nodes(&node
->dtree
->root
, node
);
371 static void _remove_from_toplevel(struct dm_tree_node
*node
)
373 _unlink_nodes(&node
->dtree
->root
, node
);
376 static int _add_to_bottomlevel(struct dm_tree_node
*node
)
378 return _link_nodes(node
, &node
->dtree
->root
);
381 static void _remove_from_bottomlevel(struct dm_tree_node
*node
)
383 _unlink_nodes(node
, &node
->dtree
->root
);
386 static int _link_tree_nodes(struct dm_tree_node
*parent
, struct dm_tree_node
*child
)
388 /* Don't link to root node if child already has a parent */
389 if (parent
== &parent
->dtree
->root
) {
390 if (dm_tree_node_num_children(child
, 1))
393 _remove_from_toplevel(child
);
395 if (child
== &child
->dtree
->root
) {
396 if (dm_tree_node_num_children(parent
, 0))
399 _remove_from_bottomlevel(parent
);
401 return _link_nodes(parent
, child
);
404 static struct dm_tree_node
*_create_dm_tree_node(struct dm_tree
*dtree
,
407 struct dm_info
*info
,
411 struct dm_tree_node
*node
;
414 if (!(node
= dm_pool_zalloc(dtree
->mem
, sizeof(*node
)))) {
415 log_error("_create_dm_tree_node alloc failed");
424 node
->context
= context
;
425 node
->udev_flags
= udev_flags
;
426 node
->activation_priority
= 0;
428 dm_list_init(&node
->uses
);
429 dm_list_init(&node
->used_by
);
430 dm_list_init(&node
->props
.segs
);
432 dev
= MKDEV(info
->major
, info
->minor
);
434 if (!dm_hash_insert_binary(dtree
->devs
, (const char *) &dev
,
435 sizeof(dev
), node
)) {
436 log_error("dtree node hash insertion failed");
437 dm_pool_free(dtree
->mem
, node
);
442 !dm_hash_insert(dtree
->uuids
, uuid
, node
)) {
443 log_error("dtree uuid hash insertion failed");
444 dm_hash_remove_binary(dtree
->devs
, (const char *) &dev
,
446 dm_pool_free(dtree
->mem
, node
);
453 static struct dm_tree_node
*_find_dm_tree_node(struct dm_tree
*dtree
,
454 uint32_t major
, uint32_t minor
)
456 uint64_t dev
= MKDEV(major
, minor
);
458 return dm_hash_lookup_binary(dtree
->devs
, (const char *) &dev
,
462 static struct dm_tree_node
*_find_dm_tree_node_by_uuid(struct dm_tree
*dtree
,
465 struct dm_tree_node
*node
;
467 if ((node
= dm_hash_lookup(dtree
->uuids
, uuid
)))
470 if (strncmp(uuid
, UUID_PREFIX
, sizeof(UUID_PREFIX
) - 1))
473 return dm_hash_lookup(dtree
->uuids
, uuid
+ sizeof(UUID_PREFIX
) - 1);
476 static int _deps(struct dm_task
**dmt
, struct dm_pool
*mem
, uint32_t major
, uint32_t minor
,
477 const char **name
, const char **uuid
,
478 struct dm_info
*info
, struct dm_deps
**deps
)
480 memset(info
, 0, sizeof(*info
));
482 if (!dm_is_dm_major(major
)) {
489 info
->live_table
= 0;
490 info
->inactive_table
= 0;
495 if (!(*dmt
= dm_task_create(DM_DEVICE_DEPS
))) {
496 log_error("deps dm_task creation failed");
500 if (!dm_task_set_major(*dmt
, major
)) {
501 log_error("_deps: failed to set major for (%" PRIu32
":%" PRIu32
")",
506 if (!dm_task_set_minor(*dmt
, minor
)) {
507 log_error("_deps: failed to set minor for (%" PRIu32
":%" PRIu32
")",
512 if (!dm_task_run(*dmt
)) {
513 log_error("_deps: task run failed for (%" PRIu32
":%" PRIu32
")",
518 if (!dm_task_get_info(*dmt
, info
)) {
519 log_error("_deps: failed to get info for (%" PRIu32
":%" PRIu32
")",
529 if (info
->major
!= major
) {
530 log_error("Inconsistent dtree major number: %u != %u",
534 if (info
->minor
!= minor
) {
535 log_error("Inconsistent dtree minor number: %u != %u",
539 if (!(*name
= dm_pool_strdup(mem
, dm_task_get_name(*dmt
)))) {
540 log_error("name pool_strdup failed");
543 if (!(*uuid
= dm_pool_strdup(mem
, dm_task_get_uuid(*dmt
)))) {
544 log_error("uuid pool_strdup failed");
547 *deps
= dm_task_get_deps(*dmt
);
553 dm_task_destroy(*dmt
);
557 static struct dm_tree_node
*_add_dev(struct dm_tree
*dtree
,
558 struct dm_tree_node
*parent
,
559 uint32_t major
, uint32_t minor
,
562 struct dm_task
*dmt
= NULL
;
564 struct dm_deps
*deps
= NULL
;
565 const char *name
= NULL
;
566 const char *uuid
= NULL
;
567 struct dm_tree_node
*node
= NULL
;
571 /* Already in tree? */
572 if (!(node
= _find_dm_tree_node(dtree
, major
, minor
))) {
573 if (!_deps(&dmt
, dtree
->mem
, major
, minor
, &name
, &uuid
, &info
, &deps
))
576 if (!(node
= _create_dm_tree_node(dtree
, name
, uuid
, &info
,
582 if (!_link_tree_nodes(parent
, node
)) {
587 /* If node was already in tree, no need to recurse. */
591 /* Can't recurse if not a mapped device or there are no dependencies */
592 if (!node
->info
.exists
|| !deps
->count
) {
593 if (!_add_to_bottomlevel(node
)) {
600 /* Add dependencies to tree */
601 for (i
= 0; i
< deps
->count
; i
++)
602 if (!_add_dev(dtree
, node
, MAJOR(deps
->device
[i
]),
603 MINOR(deps
->device
[i
]), udev_flags
)) {
610 dm_task_destroy(dmt
);
615 static int _node_clear_table(struct dm_tree_node
*dnode
)
618 struct dm_info
*info
;
622 if (!(info
= &dnode
->info
)) {
623 log_error("_node_clear_table failed: missing info");
627 if (!(name
= dm_tree_node_get_name(dnode
))) {
628 log_error("_node_clear_table failed: missing name");
632 /* Is there a table? */
633 if (!info
->exists
|| !info
->inactive_table
)
636 // FIXME Get inactive deps. If any dev referenced has 1 opener and no live table, remove it after the clear.
638 log_verbose("Clearing inactive table %s (%" PRIu32
":%" PRIu32
")",
639 name
, info
->major
, info
->minor
);
641 if (!(dmt
= dm_task_create(DM_DEVICE_CLEAR
))) {
642 log_error("Table clear dm_task creation failed for %s", name
);
646 if (!dm_task_set_major(dmt
, info
->major
) ||
647 !dm_task_set_minor(dmt
, info
->minor
)) {
648 log_error("Failed to set device number for %s table clear", name
);
649 dm_task_destroy(dmt
);
653 r
= dm_task_run(dmt
);
655 if (!dm_task_get_info(dmt
, info
)) {
656 log_error("_node_clear_table failed: info missing after running task for %s", name
);
660 dm_task_destroy(dmt
);
665 struct dm_tree_node
*dm_tree_add_new_dev(struct dm_tree
*dtree
,
668 uint32_t major
, uint32_t minor
,
673 struct dm_tree_node
*dnode
;
678 /* Do we need to add node to tree? */
679 if (!(dnode
= dm_tree_find_node_by_uuid(dtree
, uuid
))) {
680 if (!(name2
= dm_pool_strdup(dtree
->mem
, name
))) {
681 log_error("name pool_strdup failed");
684 if (!(uuid2
= dm_pool_strdup(dtree
->mem
, uuid
))) {
685 log_error("uuid pool_strdup failed");
693 info
.inactive_table
= 0;
696 if (!(dnode
= _create_dm_tree_node(dtree
, name2
, uuid2
, &info
,
700 /* Attach to root node until a table is supplied */
701 if (!_add_to_toplevel(dnode
) || !_add_to_bottomlevel(dnode
))
704 dnode
->props
.major
= major
;
705 dnode
->props
.minor
= minor
;
706 dnode
->props
.new_name
= NULL
;
707 dnode
->props
.size_changed
= 0;
708 } else if (strcmp(name
, dnode
->name
)) {
709 /* Do we need to rename node? */
710 if (!(dnode
->props
.new_name
= dm_pool_strdup(dtree
->mem
, name
))) {
711 log_error("name pool_strdup failed");
716 dnode
->props
.read_only
= read_only
? 1 : 0;
717 dnode
->props
.read_ahead
= DM_READ_AHEAD_AUTO
;
718 dnode
->props
.read_ahead_flags
= 0;
720 if (clear_inactive
&& !_node_clear_table(dnode
))
723 dnode
->context
= context
;
724 dnode
->udev_flags
= 0;
729 struct dm_tree_node
*dm_tree_add_new_dev_with_udev_flags(struct dm_tree
*dtree
,
739 struct dm_tree_node
*node
;
741 if ((node
= dm_tree_add_new_dev(dtree
, name
, uuid
, major
, minor
, read_only
,
742 clear_inactive
, context
)))
743 node
->udev_flags
= udev_flags
;
749 void dm_tree_node_set_read_ahead(struct dm_tree_node
*dnode
,
751 uint32_t read_ahead_flags
)
753 dnode
->props
.read_ahead
= read_ahead
;
754 dnode
->props
.read_ahead_flags
= read_ahead_flags
;
757 void dm_tree_node_set_presuspend_node(struct dm_tree_node
*node
,
758 struct dm_tree_node
*presuspend_node
)
760 node
->presuspend_node
= presuspend_node
;
763 int dm_tree_add_dev(struct dm_tree
*dtree
, uint32_t major
, uint32_t minor
)
765 return _add_dev(dtree
, &dtree
->root
, major
, minor
, 0) ? 1 : 0;
768 int dm_tree_add_dev_with_udev_flags(struct dm_tree
*dtree
, uint32_t major
,
769 uint32_t minor
, uint16_t udev_flags
)
771 return _add_dev(dtree
, &dtree
->root
, major
, minor
, udev_flags
) ? 1 : 0;
774 const char *dm_tree_node_get_name(const struct dm_tree_node
*node
)
776 return node
->info
.exists
? node
->name
: "";
779 const char *dm_tree_node_get_uuid(const struct dm_tree_node
*node
)
781 return node
->info
.exists
? node
->uuid
: "";
784 const struct dm_info
*dm_tree_node_get_info(const struct dm_tree_node
*node
)
789 void *dm_tree_node_get_context(const struct dm_tree_node
*node
)
791 return node
->context
;
794 int dm_tree_node_size_changed(const struct dm_tree_node
*dnode
)
796 return dnode
->props
.size_changed
;
799 int dm_tree_node_num_children(const struct dm_tree_node
*node
, uint32_t inverted
)
802 if (_nodes_are_linked(&node
->dtree
->root
, node
))
804 return dm_list_size(&node
->used_by
);
807 if (_nodes_are_linked(node
, &node
->dtree
->root
))
810 return dm_list_size(&node
->uses
);
814 * Returns 1 if no prefix supplied
816 static int _uuid_prefix_matches(const char *uuid
, const char *uuid_prefix
, size_t uuid_prefix_len
)
821 if (!strncmp(uuid
, uuid_prefix
, uuid_prefix_len
))
824 /* Handle transition: active device uuids might be missing the prefix */
825 if (uuid_prefix_len
<= 4)
828 if (!strncmp(uuid
, UUID_PREFIX
, sizeof(UUID_PREFIX
) - 1))
831 if (strncmp(uuid_prefix
, UUID_PREFIX
, sizeof(UUID_PREFIX
) - 1))
834 if (!strncmp(uuid
, uuid_prefix
+ sizeof(UUID_PREFIX
) - 1, uuid_prefix_len
- (sizeof(UUID_PREFIX
) - 1)))
841 * Returns 1 if no children.
843 static int _children_suspended(struct dm_tree_node
*node
,
845 const char *uuid_prefix
,
846 size_t uuid_prefix_len
)
848 struct dm_list
*list
;
849 struct dm_tree_link
*dlink
;
850 const struct dm_info
*dinfo
;
854 if (_nodes_are_linked(&node
->dtree
->root
, node
))
856 list
= &node
->used_by
;
858 if (_nodes_are_linked(node
, &node
->dtree
->root
))
863 dm_list_iterate_items(dlink
, list
) {
864 if (!(uuid
= dm_tree_node_get_uuid(dlink
->node
))) {
869 /* Ignore if it doesn't belong to this VG */
870 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
873 /* Ignore if parent node wants to presuspend this node */
874 if (dlink
->node
->presuspend_node
== node
)
877 if (!(dinfo
= dm_tree_node_get_info(dlink
->node
))) {
878 stack
; /* FIXME Is this normal? */
882 if (!dinfo
->suspended
)
890 * Set major and minor to zero for root of tree.
892 struct dm_tree_node
*dm_tree_find_node(struct dm_tree
*dtree
,
896 if (!major
&& !minor
)
899 return _find_dm_tree_node(dtree
, major
, minor
);
903 * Set uuid to NULL for root of tree.
905 struct dm_tree_node
*dm_tree_find_node_by_uuid(struct dm_tree
*dtree
,
911 return _find_dm_tree_node_by_uuid(dtree
, uuid
);
915 * First time set *handle to NULL.
916 * Set inverted to invert the tree.
918 struct dm_tree_node
*dm_tree_next_child(void **handle
,
919 const struct dm_tree_node
*parent
,
922 struct dm_list
**dlink
= (struct dm_list
**) handle
;
923 const struct dm_list
*use_list
;
926 use_list
= &parent
->used_by
;
928 use_list
= &parent
->uses
;
931 *dlink
= dm_list_first(use_list
);
933 *dlink
= dm_list_next(use_list
, *dlink
);
935 return (*dlink
) ? dm_list_item(*dlink
, struct dm_tree_link
)->node
: NULL
;
939 * Deactivate a device with its dependencies if the uuid prefix matches.
941 static int _info_by_dev(uint32_t major
, uint32_t minor
, int with_open_count
,
942 struct dm_info
*info
)
947 if (!(dmt
= dm_task_create(DM_DEVICE_INFO
))) {
948 log_error("_info_by_dev: dm_task creation failed");
952 if (!dm_task_set_major(dmt
, major
) || !dm_task_set_minor(dmt
, minor
)) {
953 log_error("_info_by_dev: Failed to set device number");
954 dm_task_destroy(dmt
);
958 if (!with_open_count
&& !dm_task_no_open_count(dmt
))
959 log_error("Failed to disable open_count");
961 if ((r
= dm_task_run(dmt
)))
962 r
= dm_task_get_info(dmt
, info
);
964 dm_task_destroy(dmt
);
969 static int _check_device_not_in_use(struct dm_info
*info
)
974 /* If sysfs is not used, use open_count information only. */
975 if (!*dm_sysfs_dir()) {
976 if (info
->open_count
) {
977 log_error("Device %" PRIu32
":%" PRIu32
" in use",
978 info
->major
, info
->minor
);
985 if (dm_device_has_holders(info
->major
, info
->minor
)) {
986 log_error("Device %" PRIu32
":%" PRIu32
" is used "
987 "by another device.", info
->major
, info
->minor
);
991 if (dm_device_has_mounted_fs(info
->major
, info
->minor
)) {
992 log_error("Device %" PRIu32
":%" PRIu32
" contains "
993 "a filesystem in use.", info
->major
, info
->minor
);
1000 /* Check if all parent nodes of given node have open_count == 0 */
1001 static int _node_has_closed_parents(struct dm_tree_node
*node
,
1002 const char *uuid_prefix
,
1003 size_t uuid_prefix_len
)
1005 struct dm_tree_link
*dlink
;
1006 const struct dm_info
*dinfo
;
1007 struct dm_info info
;
1010 /* Iterate through parents of this node */
1011 dm_list_iterate_items(dlink
, &node
->used_by
) {
1012 if (!(uuid
= dm_tree_node_get_uuid(dlink
->node
))) {
1017 /* Ignore if it doesn't belong to this VG */
1018 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1021 if (!(dinfo
= dm_tree_node_get_info(dlink
->node
))) {
1022 stack
; /* FIXME Is this normal? */
1026 /* Refresh open_count */
1027 if (!_info_by_dev(dinfo
->major
, dinfo
->minor
, 1, &info
) ||
1031 if (info
.open_count
) {
1032 log_debug("Node %s %d:%d has open_count %d", uuid_prefix
,
1033 dinfo
->major
, dinfo
->minor
, info
.open_count
);
1041 static int _deactivate_node(const char *name
, uint32_t major
, uint32_t minor
,
1042 uint32_t *cookie
, uint16_t udev_flags
, int retry
)
1044 struct dm_task
*dmt
;
1047 log_verbose("Removing %s (%" PRIu32
":%" PRIu32
")", name
, major
, minor
);
1049 if (!(dmt
= dm_task_create(DM_DEVICE_REMOVE
))) {
1050 log_error("Deactivation dm_task creation failed for %s", name
);
1054 if (!dm_task_set_major(dmt
, major
) || !dm_task_set_minor(dmt
, minor
)) {
1055 log_error("Failed to set device number for %s deactivation", name
);
1059 if (!dm_task_no_open_count(dmt
))
1060 log_error("Failed to disable open_count");
1062 if (!dm_task_set_cookie(dmt
, cookie
, udev_flags
))
1067 dm_task_retry_remove(dmt
);
1069 r
= dm_task_run(dmt
);
1071 /* FIXME Until kernel returns actual name so dm-iface.c can handle it */
1072 rm_dev_node(name
, dmt
->cookie_set
&& !(udev_flags
& DM_UDEV_DISABLE_DM_RULES_FLAG
),
1073 dmt
->cookie_set
&& (udev_flags
& DM_UDEV_DISABLE_LIBRARY_FALLBACK
));
1075 /* FIXME Remove node from tree or mark invalid? */
1078 dm_task_destroy(dmt
);
1083 static int _rename_node(const char *old_name
, const char *new_name
, uint32_t major
,
1084 uint32_t minor
, uint32_t *cookie
, uint16_t udev_flags
)
1086 struct dm_task
*dmt
;
1089 log_verbose("Renaming %s (%" PRIu32
":%" PRIu32
") to %s", old_name
, major
, minor
, new_name
);
1091 if (!(dmt
= dm_task_create(DM_DEVICE_RENAME
))) {
1092 log_error("Rename dm_task creation failed for %s", old_name
);
1096 if (!dm_task_set_name(dmt
, old_name
)) {
1097 log_error("Failed to set name for %s rename.", old_name
);
1101 if (!dm_task_set_newname(dmt
, new_name
))
1104 if (!dm_task_no_open_count(dmt
))
1105 log_error("Failed to disable open_count");
1107 if (!dm_task_set_cookie(dmt
, cookie
, udev_flags
))
1110 r
= dm_task_run(dmt
);
1113 dm_task_destroy(dmt
);
1118 /* FIXME Merge with _suspend_node? */
1119 static int _resume_node(const char *name
, uint32_t major
, uint32_t minor
,
1120 uint32_t read_ahead
, uint32_t read_ahead_flags
,
1121 struct dm_info
*newinfo
, uint32_t *cookie
,
1122 uint16_t udev_flags
, int already_suspended
)
1124 struct dm_task
*dmt
;
1127 log_verbose("Resuming %s (%" PRIu32
":%" PRIu32
")", name
, major
, minor
);
1129 if (!(dmt
= dm_task_create(DM_DEVICE_RESUME
))) {
1130 log_error("Suspend dm_task creation failed for %s", name
);
1134 /* FIXME Kernel should fill in name on return instead */
1135 if (!dm_task_set_name(dmt
, name
)) {
1136 log_error("Failed to set readahead device name for %s", name
);
1140 if (!dm_task_set_major(dmt
, major
) || !dm_task_set_minor(dmt
, minor
)) {
1141 log_error("Failed to set device number for %s resumption.", name
);
1145 if (!dm_task_no_open_count(dmt
))
1146 log_error("Failed to disable open_count");
1148 if (!dm_task_set_read_ahead(dmt
, read_ahead
, read_ahead_flags
))
1149 log_error("Failed to set read ahead");
1151 if (!dm_task_set_cookie(dmt
, cookie
, udev_flags
))
1154 if ((r
= dm_task_run(dmt
))) {
1155 if (already_suspended
)
1157 r
= dm_task_get_info(dmt
, newinfo
);
1161 dm_task_destroy(dmt
);
1166 static int _suspend_node(const char *name
, uint32_t major
, uint32_t minor
,
1167 int skip_lockfs
, int no_flush
, struct dm_info
*newinfo
)
1169 struct dm_task
*dmt
;
1172 log_verbose("Suspending %s (%" PRIu32
":%" PRIu32
")%s%s",
1174 skip_lockfs
? "" : " with filesystem sync",
1175 no_flush
? "" : " with device flush");
1177 if (!(dmt
= dm_task_create(DM_DEVICE_SUSPEND
))) {
1178 log_error("Suspend dm_task creation failed for %s", name
);
1182 if (!dm_task_set_major(dmt
, major
) || !dm_task_set_minor(dmt
, minor
)) {
1183 log_error("Failed to set device number for %s suspension.", name
);
1184 dm_task_destroy(dmt
);
1188 if (!dm_task_no_open_count(dmt
))
1189 log_error("Failed to disable open_count");
1191 if (skip_lockfs
&& !dm_task_skip_lockfs(dmt
))
1192 log_error("Failed to set skip_lockfs flag.");
1194 if (no_flush
&& !dm_task_no_flush(dmt
))
1195 log_error("Failed to set no_flush flag.");
1197 if ((r
= dm_task_run(dmt
))) {
1199 r
= dm_task_get_info(dmt
, newinfo
);
1202 dm_task_destroy(dmt
);
1208 * FIXME Don't attempt to deactivate known internal dependencies.
1210 static int _dm_tree_deactivate_children(struct dm_tree_node
*dnode
,
1211 const char *uuid_prefix
,
1212 size_t uuid_prefix_len
,
1216 void *handle
= NULL
;
1217 struct dm_tree_node
*child
= dnode
;
1218 struct dm_info info
;
1219 const struct dm_info
*dinfo
;
1223 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
1224 if (!(dinfo
= dm_tree_node_get_info(child
))) {
1229 if (!(name
= dm_tree_node_get_name(child
))) {
1234 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
1239 /* Ignore if it doesn't belong to this VG */
1240 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1243 /* Refresh open_count */
1244 if (!_info_by_dev(dinfo
->major
, dinfo
->minor
, 1, &info
) ||
1248 if (!_check_device_not_in_use(&info
))
1251 /* Also checking open_count in parent nodes of presuspend_node */
1252 if ((child
->presuspend_node
&&
1253 !_node_has_closed_parents(child
->presuspend_node
,
1254 uuid_prefix
, uuid_prefix_len
))) {
1255 /* Only report error from (likely non-internal) dependency at top level */
1257 log_error("Unable to deactivate open %s (%" PRIu32
1258 ":%" PRIu32
")", name
, info
.major
,
1265 /* Suspend child node first if requested */
1266 if (child
->presuspend_node
&&
1267 !dm_tree_suspend_children(child
, uuid_prefix
, uuid_prefix_len
))
1270 if (!_deactivate_node(name
, info
.major
, info
.minor
,
1271 &child
->dtree
->cookie
, child
->udev_flags
,
1272 child
->dtree
->retry_remove
)) {
1273 log_error("Unable to deactivate %s (%" PRIu32
1274 ":%" PRIu32
")", name
, info
.major
,
1278 } else if (info
.suspended
)
1281 if (dm_tree_node_num_children(child
, 0)) {
1282 if (!_dm_tree_deactivate_children(child
, uuid_prefix
, uuid_prefix_len
, level
+ 1))
1290 int dm_tree_deactivate_children(struct dm_tree_node
*dnode
,
1291 const char *uuid_prefix
,
1292 size_t uuid_prefix_len
)
1294 return _dm_tree_deactivate_children(dnode
, uuid_prefix
, uuid_prefix_len
, 0);
1297 void dm_tree_skip_lockfs(struct dm_tree_node
*dnode
)
1299 dnode
->dtree
->skip_lockfs
= 1;
1302 void dm_tree_use_no_flush_suspend(struct dm_tree_node
*dnode
)
1304 dnode
->dtree
->no_flush
= 1;
1307 void dm_tree_retry_remove(struct dm_tree_node
*dnode
)
1309 dnode
->dtree
->retry_remove
= 1;
1312 int dm_tree_suspend_children(struct dm_tree_node
*dnode
,
1313 const char *uuid_prefix
,
1314 size_t uuid_prefix_len
)
1317 void *handle
= NULL
;
1318 struct dm_tree_node
*child
= dnode
;
1319 struct dm_info info
, newinfo
;
1320 const struct dm_info
*dinfo
;
1324 /* Suspend nodes at this level of the tree */
1325 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
1326 if (!(dinfo
= dm_tree_node_get_info(child
))) {
1331 if (!(name
= dm_tree_node_get_name(child
))) {
1336 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
1341 /* Ignore if it doesn't belong to this VG */
1342 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1345 /* Ensure immediate parents are already suspended */
1346 if (!_children_suspended(child
, 1, uuid_prefix
, uuid_prefix_len
))
1349 if (!_info_by_dev(dinfo
->major
, dinfo
->minor
, 0, &info
) ||
1350 !info
.exists
|| info
.suspended
)
1353 if (!_suspend_node(name
, info
.major
, info
.minor
,
1354 child
->dtree
->skip_lockfs
,
1355 child
->dtree
->no_flush
, &newinfo
)) {
1356 log_error("Unable to suspend %s (%" PRIu32
1357 ":%" PRIu32
")", name
, info
.major
,
1363 /* Update cached info */
1364 child
->info
= newinfo
;
1367 /* Then suspend any child nodes */
1370 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
1371 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
1376 /* Ignore if it doesn't belong to this VG */
1377 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1380 if (dm_tree_node_num_children(child
, 0))
1381 if (!dm_tree_suspend_children(child
, uuid_prefix
, uuid_prefix_len
))
1388 int dm_tree_activate_children(struct dm_tree_node
*dnode
,
1389 const char *uuid_prefix
,
1390 size_t uuid_prefix_len
)
1393 void *handle
= NULL
;
1394 struct dm_tree_node
*child
= dnode
;
1395 struct dm_info newinfo
;
1400 /* Activate children first */
1401 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
1402 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
1407 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1410 if (dm_tree_node_num_children(child
, 0))
1411 if (!dm_tree_activate_children(child
, uuid_prefix
, uuid_prefix_len
))
1417 for (priority
= 0; priority
< 3; priority
++) {
1418 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
1419 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
1424 if (!_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
1427 if (priority
!= child
->activation_priority
)
1430 if (!(name
= dm_tree_node_get_name(child
))) {
1436 if (child
->props
.new_name
) {
1437 if (!_rename_node(name
, child
->props
.new_name
, child
->info
.major
,
1438 child
->info
.minor
, &child
->dtree
->cookie
,
1439 child
->udev_flags
)) {
1440 log_error("Failed to rename %s (%" PRIu32
1441 ":%" PRIu32
") to %s", name
, child
->info
.major
,
1442 child
->info
.minor
, child
->props
.new_name
);
1445 child
->name
= child
->props
.new_name
;
1446 child
->props
.new_name
= NULL
;
1449 if (!child
->info
.inactive_table
&& !child
->info
.suspended
)
1452 if (!_resume_node(child
->name
, child
->info
.major
, child
->info
.minor
,
1453 child
->props
.read_ahead
, child
->props
.read_ahead_flags
,
1454 &newinfo
, &child
->dtree
->cookie
, child
->udev_flags
, child
->info
.suspended
)) {
1455 log_error("Unable to resume %s (%" PRIu32
1456 ":%" PRIu32
")", child
->name
, child
->info
.major
,
1462 /* Update cached info */
1463 child
->info
= newinfo
;
1472 static int _create_node(struct dm_tree_node
*dnode
)
1475 struct dm_task
*dmt
;
1477 log_verbose("Creating %s", dnode
->name
);
1479 if (!(dmt
= dm_task_create(DM_DEVICE_CREATE
))) {
1480 log_error("Create dm_task creation failed for %s", dnode
->name
);
1484 if (!dm_task_set_name(dmt
, dnode
->name
)) {
1485 log_error("Failed to set device name for %s", dnode
->name
);
1489 if (!dm_task_set_uuid(dmt
, dnode
->uuid
)) {
1490 log_error("Failed to set uuid for %s", dnode
->name
);
1494 if (dnode
->props
.major
&&
1495 (!dm_task_set_major(dmt
, dnode
->props
.major
) ||
1496 !dm_task_set_minor(dmt
, dnode
->props
.minor
))) {
1497 log_error("Failed to set device number for %s creation.", dnode
->name
);
1501 if (dnode
->props
.read_only
&& !dm_task_set_ro(dmt
)) {
1502 log_error("Failed to set read only flag for %s", dnode
->name
);
1506 if (!dm_task_no_open_count(dmt
))
1507 log_error("Failed to disable open_count");
1509 if ((r
= dm_task_run(dmt
)))
1510 r
= dm_task_get_info(dmt
, &dnode
->info
);
1513 dm_task_destroy(dmt
);
1519 static int _build_dev_string(char *devbuf
, size_t bufsize
, struct dm_tree_node
*node
)
1521 if (!dm_format_dev(devbuf
, bufsize
, node
->info
.major
, node
->info
.minor
)) {
1522 log_error("Failed to format %s device number for %s as dm "
1524 node
->name
, node
->uuid
, node
->info
.major
, node
->info
.minor
);
1531 /* simplify string emiting code */
1532 #define EMIT_PARAMS(p, str...)\
1535 if ((w = dm_snprintf(params + p, paramsize - (size_t) p, str)) < 0) {\
1536 stack; /* Out of space */\
1545 * Returns: 1 on success, 0 on failure
1547 static int _emit_areas_line(struct dm_task
*dmt
__attribute__((unused
)),
1548 struct load_segment
*seg
, char *params
,
1549 size_t paramsize
, int *pos
)
1551 struct seg_area
*area
;
1552 char devbuf
[DM_FORMAT_DEV_BUFSIZE
];
1553 unsigned first_time
= 1;
1554 const char *logtype
, *synctype
;
1555 unsigned log_parm_count
;
1557 dm_list_iterate_items(area
, &seg
->areas
) {
1558 switch (seg
->type
) {
1559 case SEG_REPLICATOR_DEV
:
1560 if (!_build_dev_string(devbuf
, sizeof(devbuf
), area
->dev_node
))
1563 EMIT_PARAMS(*pos
, " %d 1 %s", area
->rsite_index
, devbuf
);
1565 EMIT_PARAMS(*pos
, " nolog 0");
1567 /* Remote devices */
1568 log_parm_count
= (area
->flags
&
1569 (DM_NOSYNC
| DM_FORCESYNC
)) ? 2 : 1;
1572 devbuf
[0] = 0; /* Only core log parameters */
1575 devbuf
[0] = ' '; /* Extra space before device name */
1576 if (!_build_dev_string(devbuf
+ 1,
1581 log_parm_count
++; /* Extra sync log device name parameter */
1584 EMIT_PARAMS(*pos
, " %s %u%s %" PRIu64
, logtype
,
1585 log_parm_count
, devbuf
, area
->region_size
);
1587 synctype
= (area
->flags
& DM_NOSYNC
) ?
1588 " nosync" : (area
->flags
& DM_FORCESYNC
) ?
1592 EMIT_PARAMS(*pos
, "%s", synctype
);
1604 if (!area
->dev_node
) {
1605 EMIT_PARAMS(*pos
, " -");
1608 if (!_build_dev_string(devbuf
, sizeof(devbuf
), area
->dev_node
))
1611 EMIT_PARAMS(*pos
, " %s", devbuf
);
1614 if (!_build_dev_string(devbuf
, sizeof(devbuf
), area
->dev_node
))
1617 EMIT_PARAMS(*pos
, "%s%s %" PRIu64
, first_time
? "" : " ",
1618 devbuf
, area
->offset
);
1627 static int _replicator_emit_segment_line(const struct load_segment
*seg
, char *params
,
1628 size_t paramsize
, int *pos
)
1630 const struct load_segment
*rlog_seg
;
1631 struct replicator_site
*rsite
;
1632 char rlogbuf
[DM_FORMAT_DEV_BUFSIZE
];
1633 unsigned parm_count
;
1635 if (!seg
->log
|| !_build_dev_string(rlogbuf
, sizeof(rlogbuf
), seg
->log
))
1638 rlog_seg
= dm_list_item(dm_list_last(&seg
->log
->props
.segs
),
1639 struct load_segment
);
1641 EMIT_PARAMS(*pos
, "%s 4 %s 0 auto %" PRIu64
,
1642 seg
->rlog_type
, rlogbuf
, rlog_seg
->size
);
1644 dm_list_iterate_items(rsite
, &seg
->rsites
) {
1645 parm_count
= (rsite
->fall_behind_data
1646 || rsite
->fall_behind_ios
1647 || rsite
->async_timeout
) ? 4 : 2;
1649 EMIT_PARAMS(*pos
, " blockdev %u %u %s", parm_count
, rsite
->rsite_index
,
1650 (rsite
->mode
== DM_REPLICATOR_SYNC
) ? "synchronous" : "asynchronous");
1652 if (rsite
->fall_behind_data
)
1653 EMIT_PARAMS(*pos
, " data %" PRIu64
, rsite
->fall_behind_data
);
1654 else if (rsite
->fall_behind_ios
)
1655 EMIT_PARAMS(*pos
, " ios %" PRIu32
, rsite
->fall_behind_ios
);
1656 else if (rsite
->async_timeout
)
1657 EMIT_PARAMS(*pos
, " timeout %" PRIu32
, rsite
->async_timeout
);
1664 * Returns: 1 on success, 0 on failure
1666 static int _mirror_emit_segment_line(struct dm_task
*dmt
, struct load_segment
*seg
,
1667 char *params
, size_t paramsize
)
1669 int block_on_error
= 0;
1670 int handle_errors
= 0;
1671 int dm_log_userspace
= 0;
1673 unsigned log_parm_count
;
1675 char logbuf
[DM_FORMAT_DEV_BUFSIZE
];
1676 const char *logtype
;
1677 unsigned kmaj
= 0, kmin
= 0, krel
= 0;
1679 if (uname(&uts
) == -1) {
1680 log_error("Cannot read kernel release version.");
1684 /* Kernels with a major number of 2 always had 3 parts. */
1685 parts
= sscanf(uts
.release
, "%u.%u.%u", &kmaj
, &kmin
, &krel
);
1686 if (parts
< 1 || (kmaj
< 3 && parts
< 3)) {
1687 log_error("Wrong kernel release version %s.", uts
.release
);
1691 if ((seg
->flags
& DM_BLOCK_ON_ERROR
)) {
1693 * Originally, block_on_error was an argument to the log
1694 * portion of the mirror CTR table. It was renamed to
1695 * "handle_errors" and now resides in the 'features'
1696 * section of the mirror CTR table (i.e. at the end).
1698 * We can identify whether to use "block_on_error" or
1699 * "handle_errors" by the dm-mirror module's version
1700 * number (>= 1.12) or by the kernel version (>= 2.6.22).
1702 if (KERNEL_VERSION(kmaj
, kmin
, krel
) >= KERNEL_VERSION(2, 6, 22))
1708 if (seg
->clustered
) {
1709 /* Cluster mirrors require a UUID */
1714 * Cluster mirrors used to have their own log
1715 * types. Now they are accessed through the
1716 * userspace log type.
1718 * The dm-log-userspace module was added to the
1721 if (KERNEL_VERSION(kmaj
, kmin
, krel
) >= KERNEL_VERSION(2, 6, 31))
1722 dm_log_userspace
= 1;
1728 /* [no]sync, block_on_error etc. */
1729 log_parm_count
+= hweight32(seg
->flags
);
1731 /* "handle_errors" is a feature arg now */
1735 /* DM_CORELOG does not count in the param list */
1736 if (seg
->flags
& DM_CORELOG
)
1739 if (seg
->clustered
) {
1740 log_parm_count
++; /* For UUID */
1742 if (!dm_log_userspace
)
1743 EMIT_PARAMS(pos
, "clustered-");
1745 /* For clustered-* type field inserted later */
1754 if (!_build_dev_string(logbuf
, sizeof(logbuf
), seg
->log
))
1758 if (dm_log_userspace
)
1759 EMIT_PARAMS(pos
, "userspace %u %s clustered-%s",
1760 log_parm_count
, seg
->uuid
, logtype
);
1762 EMIT_PARAMS(pos
, "%s %u", logtype
, log_parm_count
);
1765 EMIT_PARAMS(pos
, " %s", logbuf
);
1767 EMIT_PARAMS(pos
, " %u", seg
->region_size
);
1769 if (seg
->clustered
&& !dm_log_userspace
)
1770 EMIT_PARAMS(pos
, " %s", seg
->uuid
);
1772 if ((seg
->flags
& DM_NOSYNC
))
1773 EMIT_PARAMS(pos
, " nosync");
1774 else if ((seg
->flags
& DM_FORCESYNC
))
1775 EMIT_PARAMS(pos
, " sync");
1778 EMIT_PARAMS(pos
, " block_on_error");
1780 EMIT_PARAMS(pos
, " %u ", seg
->mirror_area_count
);
1782 if (_emit_areas_line(dmt
, seg
, params
, paramsize
, &pos
) <= 0)
1786 EMIT_PARAMS(pos
, " 1 handle_errors");
1791 static int _raid_emit_segment_line(struct dm_task
*dmt
, uint32_t major
,
1792 uint32_t minor
, struct load_segment
*seg
,
1793 uint64_t *seg_start
, char *params
,
1797 int param_count
= 1; /* mandatory 'chunk size'/'stripe size' arg */
1800 if ((seg
->flags
& DM_NOSYNC
) || (seg
->flags
& DM_FORCESYNC
))
1803 if (seg
->region_size
)
1806 tmp
= (uint32_t *)(&seg
->rebuilds
); /* rebuilds is 64-bit */
1807 param_count
+= 2 * hweight32(tmp
[0]);
1808 param_count
+= 2 * hweight32(tmp
[1]);
1810 if ((seg
->type
== SEG_RAID1
) && seg
->stripe_size
)
1811 log_error("WARNING: Ignoring RAID1 stripe size");
1813 EMIT_PARAMS(pos
, "%s %d %u", dm_segtypes
[seg
->type
].target
,
1814 param_count
, seg
->stripe_size
);
1816 if (seg
->flags
& DM_NOSYNC
)
1817 EMIT_PARAMS(pos
, " nosync");
1818 else if (seg
->flags
& DM_FORCESYNC
)
1819 EMIT_PARAMS(pos
, " sync");
1821 if (seg
->region_size
)
1822 EMIT_PARAMS(pos
, " region_size %u", seg
->region_size
);
1824 for (i
= 0; i
< (seg
->area_count
/ 2); i
++)
1825 if (seg
->rebuilds
& (1 << i
))
1826 EMIT_PARAMS(pos
, " rebuild %u", i
);
1828 /* Print number of metadata/data device pairs */
1829 EMIT_PARAMS(pos
, " %u", seg
->area_count
/2);
1831 if (_emit_areas_line(dmt
, seg
, params
, paramsize
, &pos
) <= 0)
1837 static int _emit_segment_line(struct dm_task
*dmt
, uint32_t major
,
1838 uint32_t minor
, struct load_segment
*seg
,
1839 uint64_t *seg_start
, char *params
,
1844 int target_type_is_raid
= 0;
1845 char originbuf
[DM_FORMAT_DEV_BUFSIZE
], cowbuf
[DM_FORMAT_DEV_BUFSIZE
];
1846 char pool
[DM_FORMAT_DEV_BUFSIZE
], metadata
[DM_FORMAT_DEV_BUFSIZE
];
1854 /* Mirrors are pretty complicated - now in separate function */
1855 r
= _mirror_emit_segment_line(dmt
, seg
, params
, paramsize
);
1859 case SEG_REPLICATOR
:
1860 if ((r
= _replicator_emit_segment_line(seg
, params
, paramsize
,
1866 case SEG_REPLICATOR_DEV
:
1867 if (!seg
->replicator
|| !_build_dev_string(originbuf
,
1872 EMIT_PARAMS(pos
, "%s %" PRIu64
, originbuf
, seg
->rdevice_index
);
1875 case SEG_SNAPSHOT_MERGE
:
1876 if (!_build_dev_string(originbuf
, sizeof(originbuf
), seg
->origin
))
1878 if (!_build_dev_string(cowbuf
, sizeof(cowbuf
), seg
->cow
))
1880 EMIT_PARAMS(pos
, "%s %s %c %d", originbuf
, cowbuf
,
1881 seg
->persistent
? 'P' : 'N', seg
->chunk_size
);
1883 case SEG_SNAPSHOT_ORIGIN
:
1884 if (!_build_dev_string(originbuf
, sizeof(originbuf
), seg
->origin
))
1886 EMIT_PARAMS(pos
, "%s", originbuf
);
1889 EMIT_PARAMS(pos
, "%u %u ", seg
->area_count
, seg
->stripe_size
);
1892 EMIT_PARAMS(pos
, "%s%s%s%s%s %s %" PRIu64
" ", seg
->cipher
,
1893 seg
->chainmode
? "-" : "", seg
->chainmode
?: "",
1894 seg
->iv
? "-" : "", seg
->iv
?: "", seg
->key
,
1895 seg
->iv_offset
!= DM_CRYPT_IV_DEFAULT
?
1896 seg
->iv_offset
: *seg_start
);
1907 target_type_is_raid
= 1;
1908 r
= _raid_emit_segment_line(dmt
, major
, minor
, seg
, seg_start
,
1915 if (!_build_dev_string(metadata
, sizeof(metadata
), seg
->metadata
))
1917 if (!_build_dev_string(pool
, sizeof(pool
), seg
->pool
))
1919 EMIT_PARAMS(pos
, "%s %s %d %" PRIu64
" %s", metadata
, pool
,
1920 seg
->data_block_size
, seg
->low_water_mark
,
1921 seg
->skip_block_zeroeing
? "1 skip_block_zeroing" : "");
1924 if (!_build_dev_string(pool
, sizeof(pool
), seg
->pool
))
1926 EMIT_PARAMS(pos
, "%s %d", pool
, seg
->device_id
);
1932 case SEG_REPLICATOR
:
1934 case SEG_SNAPSHOT_ORIGIN
:
1935 case SEG_SNAPSHOT_MERGE
:
1942 case SEG_REPLICATOR_DEV
:
1944 if ((r
= _emit_areas_line(dmt
, seg
, params
, paramsize
, &pos
)) <= 0) {
1949 log_error("No parameters supplied for %s target "
1950 "%u:%u.", dm_segtypes
[seg
->type
].target
,
1957 log_debug("Adding target to (%" PRIu32
":%" PRIu32
"): %" PRIu64
1958 " %" PRIu64
" %s %s", major
, minor
,
1959 *seg_start
, seg
->size
, target_type_is_raid
? "raid" :
1960 dm_segtypes
[seg
->type
].target
, params
);
1962 if (!dm_task_add_target(dmt
, *seg_start
, seg
->size
,
1963 target_type_is_raid
? "raid" :
1964 dm_segtypes
[seg
->type
].target
, params
))
1967 *seg_start
+= seg
->size
;
1974 static int _emit_segment(struct dm_task
*dmt
, uint32_t major
, uint32_t minor
,
1975 struct load_segment
*seg
, uint64_t *seg_start
)
1978 size_t paramsize
= 4096;
1982 if (!(params
= dm_malloc(paramsize
))) {
1983 log_error("Insufficient space for target parameters.");
1988 ret
= _emit_segment_line(dmt
, major
, minor
, seg
, seg_start
,
1998 log_debug("Insufficient space in params[%" PRIsize_t
1999 "] for target parameters.", paramsize
);
2002 } while (paramsize
< MAX_TARGET_PARAMSIZE
);
2004 log_error("Target parameter size too big. Aborting.");
2008 static int _load_node(struct dm_tree_node
*dnode
)
2011 struct dm_task
*dmt
;
2012 struct load_segment
*seg
;
2013 uint64_t seg_start
= 0, existing_table_size
;
2015 log_verbose("Loading %s table (%" PRIu32
":%" PRIu32
")", dnode
->name
,
2016 dnode
->info
.major
, dnode
->info
.minor
);
2018 if (!(dmt
= dm_task_create(DM_DEVICE_RELOAD
))) {
2019 log_error("Reload dm_task creation failed for %s", dnode
->name
);
2023 if (!dm_task_set_major(dmt
, dnode
->info
.major
) ||
2024 !dm_task_set_minor(dmt
, dnode
->info
.minor
)) {
2025 log_error("Failed to set device number for %s reload.", dnode
->name
);
2029 if (dnode
->props
.read_only
&& !dm_task_set_ro(dmt
)) {
2030 log_error("Failed to set read only flag for %s", dnode
->name
);
2034 if (!dm_task_no_open_count(dmt
))
2035 log_error("Failed to disable open_count");
2037 dm_list_iterate_items(seg
, &dnode
->props
.segs
)
2038 if (!_emit_segment(dmt
, dnode
->info
.major
, dnode
->info
.minor
,
2042 if (!dm_task_suppress_identical_reload(dmt
))
2043 log_error("Failed to suppress reload of identical tables.");
2045 if ((r
= dm_task_run(dmt
))) {
2046 r
= dm_task_get_info(dmt
, &dnode
->info
);
2047 if (r
&& !dnode
->info
.inactive_table
)
2048 log_verbose("Suppressed %s identical table reload.",
2051 existing_table_size
= dm_task_get_existing_table_size(dmt
);
2052 if ((dnode
->props
.size_changed
=
2053 (existing_table_size
== seg_start
) ? 0 : 1)) {
2054 log_debug("Table size changed from %" PRIu64
" to %"
2055 PRIu64
" for %s", existing_table_size
,
2056 seg_start
, dnode
->name
);
2058 * Kernel usually skips size validation on zero-length devices
2059 * now so no need to preload them.
2061 /* FIXME In which kernel version did this begin? */
2062 if (!existing_table_size
&& dnode
->props
.delay_resume_if_new
)
2063 dnode
->props
.size_changed
= 0;
2067 dnode
->props
.segment_count
= 0;
2070 dm_task_destroy(dmt
);
2075 int dm_tree_preload_children(struct dm_tree_node
*dnode
,
2076 const char *uuid_prefix
,
2077 size_t uuid_prefix_len
)
2080 void *handle
= NULL
;
2081 struct dm_tree_node
*child
;
2082 struct dm_info newinfo
;
2083 int update_devs_flag
= 0;
2085 /* Preload children first */
2086 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
2087 /* Skip existing non-device-mapper devices */
2088 if (!child
->info
.exists
&& child
->info
.major
)
2091 /* Ignore if it doesn't belong to this VG */
2092 if (child
->info
.exists
&&
2093 !_uuid_prefix_matches(child
->uuid
, uuid_prefix
, uuid_prefix_len
))
2096 if (dm_tree_node_num_children(child
, 0))
2097 if (!dm_tree_preload_children(child
, uuid_prefix
, uuid_prefix_len
))
2100 /* FIXME Cope if name exists with no uuid? */
2101 if (!child
->info
.exists
) {
2102 if (!_create_node(child
)) {
2108 if (!child
->info
.inactive_table
&& child
->props
.segment_count
) {
2109 if (!_load_node(child
)) {
2115 /* Propagate device size change change */
2116 if (child
->props
.size_changed
)
2117 dnode
->props
.size_changed
= 1;
2119 /* Resume device immediately if it has parents and its size changed */
2120 if (!dm_tree_node_num_children(child
, 1) || !child
->props
.size_changed
)
2123 if (!child
->info
.inactive_table
&& !child
->info
.suspended
)
2126 if (!_resume_node(child
->name
, child
->info
.major
, child
->info
.minor
,
2127 child
->props
.read_ahead
, child
->props
.read_ahead_flags
,
2128 &newinfo
, &child
->dtree
->cookie
, child
->udev_flags
,
2129 child
->info
.suspended
)) {
2130 log_error("Unable to resume %s (%" PRIu32
2131 ":%" PRIu32
")", child
->name
, child
->info
.major
,
2137 /* Update cached info */
2138 child
->info
= newinfo
;
2141 * Prepare for immediate synchronization with udev and flush all stacked
2142 * dev node operations if requested by immediate_dev_node property. But
2143 * finish processing current level in the tree first.
2145 if (child
->props
.immediate_dev_node
)
2146 update_devs_flag
= 1;
2152 if (update_devs_flag
) {
2153 if (!dm_udev_wait(dm_tree_get_cookie(dnode
)))
2155 dm_tree_set_cookie(dnode
, 0);
2162 * Returns 1 if unsure.
2164 int dm_tree_children_use_uuid(struct dm_tree_node
*dnode
,
2165 const char *uuid_prefix
,
2166 size_t uuid_prefix_len
)
2168 void *handle
= NULL
;
2169 struct dm_tree_node
*child
= dnode
;
2172 while ((child
= dm_tree_next_child(&handle
, dnode
, 0))) {
2173 if (!(uuid
= dm_tree_node_get_uuid(child
))) {
2174 log_error("Failed to get uuid for dtree node.");
2178 if (_uuid_prefix_matches(uuid
, uuid_prefix
, uuid_prefix_len
))
2181 if (dm_tree_node_num_children(child
, 0))
2182 dm_tree_children_use_uuid(child
, uuid_prefix
, uuid_prefix_len
);
2191 static struct load_segment
*_add_segment(struct dm_tree_node
*dnode
, unsigned type
, uint64_t size
)
2193 struct load_segment
*seg
;
2195 if (!(seg
= dm_pool_zalloc(dnode
->dtree
->mem
, sizeof(*seg
)))) {
2196 log_error("dtree node segment allocation failed");
2202 seg
->area_count
= 0;
2203 dm_list_init(&seg
->areas
);
2204 seg
->stripe_size
= 0;
2205 seg
->persistent
= 0;
2206 seg
->chunk_size
= 0;
2211 dm_list_add(&dnode
->props
.segs
, &seg
->list
);
2212 dnode
->props
.segment_count
++;
2217 int dm_tree_node_add_snapshot_origin_target(struct dm_tree_node
*dnode
,
2219 const char *origin_uuid
)
2221 struct load_segment
*seg
;
2222 struct dm_tree_node
*origin_node
;
2224 if (!(seg
= _add_segment(dnode
, SEG_SNAPSHOT_ORIGIN
, size
)))
2227 if (!(origin_node
= dm_tree_find_node_by_uuid(dnode
->dtree
, origin_uuid
))) {
2228 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid
);
2232 seg
->origin
= origin_node
;
2233 if (!_link_tree_nodes(dnode
, origin_node
))
2236 /* Resume snapshot origins after new snapshots */
2237 dnode
->activation_priority
= 1;
2242 static int _add_snapshot_target(struct dm_tree_node
*node
,
2244 const char *origin_uuid
,
2245 const char *cow_uuid
,
2246 const char *merge_uuid
,
2248 uint32_t chunk_size
)
2250 struct load_segment
*seg
;
2251 struct dm_tree_node
*origin_node
, *cow_node
, *merge_node
;
2254 seg_type
= !merge_uuid
? SEG_SNAPSHOT
: SEG_SNAPSHOT_MERGE
;
2256 if (!(seg
= _add_segment(node
, seg_type
, size
)))
2259 if (!(origin_node
= dm_tree_find_node_by_uuid(node
->dtree
, origin_uuid
))) {
2260 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid
);
2264 seg
->origin
= origin_node
;
2265 if (!_link_tree_nodes(node
, origin_node
))
2268 if (!(cow_node
= dm_tree_find_node_by_uuid(node
->dtree
, cow_uuid
))) {
2269 log_error("Couldn't find snapshot COW device uuid %s.", cow_uuid
);
2273 seg
->cow
= cow_node
;
2274 if (!_link_tree_nodes(node
, cow_node
))
2277 seg
->persistent
= persistent
? 1 : 0;
2278 seg
->chunk_size
= chunk_size
;
2281 if (!(merge_node
= dm_tree_find_node_by_uuid(node
->dtree
, merge_uuid
))) {
2282 /* not a pure error, merging snapshot may have been deactivated */
2283 log_verbose("Couldn't find merging snapshot uuid %s.", merge_uuid
);
2285 seg
->merge
= merge_node
;
2286 /* must not link merging snapshot, would undermine activation_priority below */
2289 /* Resume snapshot-merge (acting origin) after other snapshots */
2290 node
->activation_priority
= 1;
2292 /* Resume merging snapshot after snapshot-merge */
2293 seg
->merge
->activation_priority
= 2;
2301 int dm_tree_node_add_snapshot_target(struct dm_tree_node
*node
,
2303 const char *origin_uuid
,
2304 const char *cow_uuid
,
2306 uint32_t chunk_size
)
2308 return _add_snapshot_target(node
, size
, origin_uuid
, cow_uuid
,
2309 NULL
, persistent
, chunk_size
);
2312 int dm_tree_node_add_snapshot_merge_target(struct dm_tree_node
*node
,
2314 const char *origin_uuid
,
2315 const char *cow_uuid
,
2316 const char *merge_uuid
,
2317 uint32_t chunk_size
)
2319 return _add_snapshot_target(node
, size
, origin_uuid
, cow_uuid
,
2320 merge_uuid
, 1, chunk_size
);
2323 int dm_tree_node_add_error_target(struct dm_tree_node
*node
,
2326 if (!_add_segment(node
, SEG_ERROR
, size
))
2332 int dm_tree_node_add_zero_target(struct dm_tree_node
*node
,
2335 if (!_add_segment(node
, SEG_ZERO
, size
))
2341 int dm_tree_node_add_linear_target(struct dm_tree_node
*node
,
2344 if (!_add_segment(node
, SEG_LINEAR
, size
))
2350 int dm_tree_node_add_striped_target(struct dm_tree_node
*node
,
2352 uint32_t stripe_size
)
2354 struct load_segment
*seg
;
2356 if (!(seg
= _add_segment(node
, SEG_STRIPED
, size
)))
2359 seg
->stripe_size
= stripe_size
;
2364 int dm_tree_node_add_crypt_target(struct dm_tree_node
*node
,
2367 const char *chainmode
,
2372 struct load_segment
*seg
;
2374 if (!(seg
= _add_segment(node
, SEG_CRYPT
, size
)))
2377 seg
->cipher
= cipher
;
2378 seg
->chainmode
= chainmode
;
2380 seg
->iv_offset
= iv_offset
;
2386 int dm_tree_node_add_mirror_target_log(struct dm_tree_node
*node
,
2387 uint32_t region_size
,
2389 const char *log_uuid
,
2390 unsigned area_count
,
2393 struct dm_tree_node
*log_node
= NULL
;
2394 struct load_segment
*seg
;
2396 if (!node
->props
.segment_count
) {
2397 log_error(INTERNAL_ERROR
"Attempt to add target area to missing segment.");
2401 seg
= dm_list_item(dm_list_last(&node
->props
.segs
), struct load_segment
);
2404 if (!(seg
->uuid
= dm_pool_strdup(node
->dtree
->mem
, log_uuid
))) {
2405 log_error("log uuid pool_strdup failed");
2408 if ((flags
& DM_CORELOG
))
2409 /* For pvmove: immediate resume (for size validation) isn't needed. */
2410 node
->props
.delay_resume_if_new
= 1;
2412 if (!(log_node
= dm_tree_find_node_by_uuid(node
->dtree
, log_uuid
))) {
2413 log_error("Couldn't find mirror log uuid %s.", log_uuid
);
2418 log_node
->props
.immediate_dev_node
= 1;
2420 /* The kernel validates the size of disk logs. */
2421 /* FIXME Propagate to any devices below */
2422 log_node
->props
.delay_resume_if_new
= 0;
2424 if (!_link_tree_nodes(node
, log_node
))
2429 seg
->log
= log_node
;
2430 seg
->region_size
= region_size
;
2431 seg
->clustered
= clustered
;
2432 seg
->mirror_area_count
= area_count
;
2438 int dm_tree_node_add_mirror_target(struct dm_tree_node
*node
,
2441 if (!_add_segment(node
, SEG_MIRRORED
, size
))
2447 int dm_tree_node_add_raid_target(struct dm_tree_node
*node
,
2449 const char *raid_type
,
2450 uint32_t region_size
,
2451 uint32_t stripe_size
,
2456 struct load_segment
*seg
= NULL
;
2458 for (i
= 0; dm_segtypes
[i
].target
&& !seg
; i
++)
2459 if (!strcmp(raid_type
, dm_segtypes
[i
].target
))
2460 if (!(seg
= _add_segment(node
,
2461 dm_segtypes
[i
].type
, size
)))
2467 seg
->region_size
= region_size
;
2468 seg
->stripe_size
= stripe_size
;
2469 seg
->area_count
= 0;
2470 seg
->rebuilds
= rebuilds
;
2475 int dm_tree_node_add_replicator_target(struct dm_tree_node
*node
,
2477 const char *rlog_uuid
,
2478 const char *rlog_type
,
2479 unsigned rsite_index
,
2480 dm_replicator_mode_t mode
,
2481 uint32_t async_timeout
,
2482 uint64_t fall_behind_data
,
2483 uint32_t fall_behind_ios
)
2485 struct load_segment
*rseg
;
2486 struct replicator_site
*rsite
;
2488 /* Local site0 - adds replicator segment and links rlog device */
2489 if (rsite_index
== REPLICATOR_LOCAL_SITE
) {
2490 if (node
->props
.segment_count
) {
2491 log_error(INTERNAL_ERROR
"Attempt to add replicator segment to already used node.");
2495 if (!(rseg
= _add_segment(node
, SEG_REPLICATOR
, size
)))
2498 if (!(rseg
->log
= dm_tree_find_node_by_uuid(node
->dtree
, rlog_uuid
))) {
2499 log_error("Missing replicator log uuid %s.", rlog_uuid
);
2503 if (!_link_tree_nodes(node
, rseg
->log
))
2506 if (strcmp(rlog_type
, "ringbuffer") != 0) {
2507 log_error("Unsupported replicator log type %s.", rlog_type
);
2511 if (!(rseg
->rlog_type
= dm_pool_strdup(node
->dtree
->mem
, rlog_type
)))
2514 dm_list_init(&rseg
->rsites
);
2515 rseg
->rdevice_count
= 0;
2516 node
->activation_priority
= 1;
2519 /* Add site to segment */
2520 if (mode
== DM_REPLICATOR_SYNC
2521 && (async_timeout
|| fall_behind_ios
|| fall_behind_data
)) {
2522 log_error("Async parameters passed for synchronnous replicator.");
2526 if (node
->props
.segment_count
!= 1) {
2527 log_error(INTERNAL_ERROR
"Attempt to add remote site area before setting replicator log.");
2531 rseg
= dm_list_item(dm_list_last(&node
->props
.segs
), struct load_segment
);
2532 if (rseg
->type
!= SEG_REPLICATOR
) {
2533 log_error(INTERNAL_ERROR
"Attempt to use non replicator segment %s.",
2534 dm_segtypes
[rseg
->type
].target
);
2538 if (!(rsite
= dm_pool_zalloc(node
->dtree
->mem
, sizeof(*rsite
)))) {
2539 log_error("Failed to allocate remote site segment.");
2543 dm_list_add(&rseg
->rsites
, &rsite
->list
);
2544 rseg
->rsite_count
++;
2547 rsite
->async_timeout
= async_timeout
;
2548 rsite
->fall_behind_data
= fall_behind_data
;
2549 rsite
->fall_behind_ios
= fall_behind_ios
;
2550 rsite
->rsite_index
= rsite_index
;
2555 /* Appends device node to Replicator */
2556 int dm_tree_node_add_replicator_dev_target(struct dm_tree_node
*node
,
2558 const char *replicator_uuid
,
2559 uint64_t rdevice_index
,
2560 const char *rdev_uuid
,
2561 unsigned rsite_index
,
2562 const char *slog_uuid
,
2563 uint32_t slog_flags
,
2564 uint32_t slog_region_size
)
2566 struct seg_area
*area
;
2567 struct load_segment
*rseg
;
2568 struct load_segment
*rep_seg
;
2570 if (rsite_index
== REPLICATOR_LOCAL_SITE
) {
2571 /* Site index for local target */
2572 if (!(rseg
= _add_segment(node
, SEG_REPLICATOR_DEV
, size
)))
2575 if (!(rseg
->replicator
= dm_tree_find_node_by_uuid(node
->dtree
, replicator_uuid
))) {
2576 log_error("Missing replicator uuid %s.", replicator_uuid
);
2580 /* Local slink0 for replicator must be always initialized first */
2581 if (rseg
->replicator
->props
.segment_count
!= 1) {
2582 log_error(INTERNAL_ERROR
"Attempt to use non replicator segment.");
2586 rep_seg
= dm_list_item(dm_list_last(&rseg
->replicator
->props
.segs
), struct load_segment
);
2587 if (rep_seg
->type
!= SEG_REPLICATOR
) {
2588 log_error(INTERNAL_ERROR
"Attempt to use non replicator segment %s.",
2589 dm_segtypes
[rep_seg
->type
].target
);
2592 rep_seg
->rdevice_count
++;
2594 if (!_link_tree_nodes(node
, rseg
->replicator
))
2597 rseg
->rdevice_index
= rdevice_index
;
2599 /* Local slink0 for replicator must be always initialized first */
2600 if (node
->props
.segment_count
!= 1) {
2601 log_error(INTERNAL_ERROR
"Attempt to use non replicator-dev segment.");
2605 rseg
= dm_list_item(dm_list_last(&node
->props
.segs
), struct load_segment
);
2606 if (rseg
->type
!= SEG_REPLICATOR_DEV
) {
2607 log_error(INTERNAL_ERROR
"Attempt to use non replicator-dev segment %s.",
2608 dm_segtypes
[rseg
->type
].target
);
2613 if (!(slog_flags
& DM_CORELOG
) && !slog_uuid
) {
2614 log_error("Unspecified sync log uuid.");
2618 if (!dm_tree_node_add_target_area(node
, NULL
, rdev_uuid
, 0))
2621 area
= dm_list_item(dm_list_last(&rseg
->areas
), struct seg_area
);
2623 if (!(slog_flags
& DM_CORELOG
)) {
2624 if (!(area
->slog
= dm_tree_find_node_by_uuid(node
->dtree
, slog_uuid
))) {
2625 log_error("Couldn't find sync log uuid %s.", slog_uuid
);
2629 if (!_link_tree_nodes(node
, area
->slog
))
2633 area
->flags
= slog_flags
;
2634 area
->region_size
= slog_region_size
;
2635 area
->rsite_index
= rsite_index
;
2640 int dm_tree_node_add_thin_pool_target(struct dm_tree_node
*node
,
2642 uint64_t transation_id
,
2643 const char *pool_uuid
,
2644 const char *metadata_uuid
,
2645 uint32_t data_block_size
,
2646 uint64_t low_water_mark
,
2647 unsigned skip_block_zeroeing
)
2649 struct load_segment
*seg
;
2651 if (data_block_size
< THIN_MIN_DATA_SIZE
) {
2652 log_error("Data block size %d is lower then "
2653 QUOTE(THIN_MIN_DATA_SIZE
) " sectors.",
2658 if (data_block_size
> THIN_MAX_DATA_SIZE
) {
2659 log_error("Data block size %d is higher then "
2660 QUOTE(THIN_MAX_DATA_SIZE
) " sectors.",
2665 if (!(seg
= _add_segment(node
, SEG_THIN_POOL
, size
)))
2668 if (!(seg
->metadata
= dm_tree_find_node_by_uuid(node
->dtree
, metadata_uuid
))) {
2669 log_error("Missing metadata uuid %s.", metadata_uuid
);
2673 if (!_link_tree_nodes(node
, seg
->metadata
))
2676 if (!(seg
->pool
= dm_tree_find_node_by_uuid(node
->dtree
, pool_uuid
))) {
2677 log_error("Missing pool uuid %s.", pool_uuid
);
2681 if (!_link_tree_nodes(node
, seg
->pool
))
2684 seg
->data_block_size
= data_block_size
;
2685 seg
->low_water_mark
= low_water_mark
;
2686 seg
->skip_block_zeroeing
= skip_block_zeroeing
;
2691 int dm_tree_node_add_thin_target(struct dm_tree_node
*node
,
2693 const char *thin_pool_uuid
,
2696 struct load_segment
*seg
;
2698 if (device_id
> THIN_MAX_DEVICE_ID
) {
2699 log_error("Device id %d is higher then " QUOTE(THIN_MAX_DEVICE_ID
) ".",
2704 if (!(seg
= _add_segment(node
, SEG_THIN
, size
)))
2707 if (!(seg
->pool
= dm_tree_find_node_by_uuid(node
->dtree
, thin_pool_uuid
))) {
2708 log_error("Missing thin pool uuid %s.", thin_pool_uuid
);
2712 if (!_link_tree_nodes(node
, seg
->pool
))
2715 seg
->device_id
= device_id
;
2720 static int _add_area(struct dm_tree_node
*node
, struct load_segment
*seg
, struct dm_tree_node
*dev_node
, uint64_t offset
)
2722 struct seg_area
*area
;
2724 if (!(area
= dm_pool_zalloc(node
->dtree
->mem
, sizeof (*area
)))) {
2725 log_error("Failed to allocate target segment area.");
2729 area
->dev_node
= dev_node
;
2730 area
->offset
= offset
;
2732 dm_list_add(&seg
->areas
, &area
->list
);
2738 int dm_tree_node_add_target_area(struct dm_tree_node
*node
,
2739 const char *dev_name
,
2743 struct load_segment
*seg
;
2745 struct dm_tree_node
*dev_node
;
2747 if ((!dev_name
|| !*dev_name
) && (!uuid
|| !*uuid
)) {
2748 log_error("dm_tree_node_add_target_area called without device");
2753 if (!(dev_node
= dm_tree_find_node_by_uuid(node
->dtree
, uuid
))) {
2754 log_error("Couldn't find area uuid %s.", uuid
);
2757 if (!_link_tree_nodes(node
, dev_node
))
2760 if (stat(dev_name
, &info
) < 0) {
2761 log_error("Device %s not found.", dev_name
);
2765 if (!S_ISBLK(info
.st_mode
)) {
2766 log_error("Device %s is not a block device.", dev_name
);
2770 /* FIXME Check correct macro use */
2771 if (!(dev_node
= _add_dev(node
->dtree
, node
, MAJOR(info
.st_rdev
),
2772 MINOR(info
.st_rdev
), 0)))
2776 if (!node
->props
.segment_count
) {
2777 log_error(INTERNAL_ERROR
"Attempt to add target area to missing segment.");
2781 seg
= dm_list_item(dm_list_last(&node
->props
.segs
), struct load_segment
);
2783 if (!_add_area(node
, seg
, dev_node
, offset
))
2789 int dm_tree_node_add_null_area(struct dm_tree_node
*node
, uint64_t offset
)
2791 struct load_segment
*seg
;
2793 seg
= dm_list_item(dm_list_last(&node
->props
.segs
), struct load_segment
);
2795 switch (seg
->type
) {
2807 log_error("dm_tree_node_add_null_area() called on an unsupported segment type");
2811 if (!_add_area(node
, seg
, NULL
, offset
))
2817 void dm_tree_set_cookie(struct dm_tree_node
*node
, uint32_t cookie
)
2819 node
->dtree
->cookie
= cookie
;
2822 uint32_t dm_tree_get_cookie(struct dm_tree_node
*node
)
2824 return node
->dtree
->cookie
;