?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Sync usage with man page.
[netbsd-mini2440.git] / external / gpl2 / lvm2 / dist / libdm / libdm-deptree.c
blobd17f53db8d9d5f10a86b35f503ef5a03f36955b9
1 /* $NetBSD: libdm-deptree.c,v 1.3 2009/02/18 12:16:13 haad Exp $ */
2
3 /*
4 * Copyright (C) 2005-2007 Red Hat, Inc. All rights reserved.
5 *
6 * This file is part of the device-mapper userspace tools.
7 *
8 * This copyrighted material is made available to anyone wishing to use,
9 * modify, copy, or redistribute it subject to the terms and conditions
10 * of the GNU Lesser General Public License v.2.1.
11 *
12 * You should have received a copy of the GNU Lesser General Public License
13 * along with this program; if not, write to the Free Software Foundation,
14 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 #include "dmlib.h"
18 #include "libdm-targets.h"
19 #include "libdm-common.h"
20 #include "kdev_t.h"
21 #include "dm-ioctl.h"
22
23 #include <stdarg.h>
24 #include <sys/param.h>
25 #include <sys/utsname.h>
26
27 #define MAX_TARGET_PARAMSIZE 500000
28
29 /* FIXME Fix interface so this is used only by LVM */
30 #define UUID_PREFIX "LVM-"
31
32 /* Supported segment types */
33 enum {
34 SEG_CRYPT,
35 SEG_ERROR,
36 SEG_LINEAR,
37 SEG_MIRRORED,
38 SEG_SNAPSHOT,
39 SEG_SNAPSHOT_ORIGIN,
40 SEG_STRIPED,
41 SEG_ZERO,
42 };
43
44 /* FIXME Add crypt and multipath support */
45
46 struct {
47 unsigned type;
48 const char *target;
49 } dm_segtypes[] = {
50 { SEG_CRYPT, "crypt" },
51 { SEG_ERROR, "error" },
52 { SEG_LINEAR, "linear" },
53 { SEG_MIRRORED, "mirror" },
54 { SEG_SNAPSHOT, "snapshot" },
55 { SEG_SNAPSHOT_ORIGIN, "snapshot-origin" },
56 { SEG_STRIPED, "striped" },
57 { SEG_ZERO, "zero"},
58 };
59
60 /* Some segment types have a list of areas of other devices attached */
61 struct seg_area {
62 struct dm_list list;
63
64 struct dm_tree_node *dev_node;
65
66 uint64_t offset;
67 };
68
69 /* Per-segment properties */
70 struct load_segment {
71 struct dm_list list;
72
73 unsigned type;
74
75 uint64_t size;
76
77 unsigned area_count; /* Linear + Striped + Mirrored + Crypt */
78 struct dm_list areas; /* Linear + Striped + Mirrored + Crypt */
79
80 uint32_t stripe_size; /* Striped */
81
82 int persistent; /* Snapshot */
83 uint32_t chunk_size; /* Snapshot */
84 struct dm_tree_node *cow; /* Snapshot */
85 struct dm_tree_node *origin; /* Snapshot + Snapshot origin */
86
87 struct dm_tree_node *log; /* Mirror */
88 uint32_t region_size; /* Mirror */
89 unsigned clustered; /* Mirror */
90 unsigned mirror_area_count; /* Mirror */
91 uint32_t flags; /* Mirror log */
92 char *uuid; /* Clustered mirror log */
93
94 const char *cipher; /* Crypt */
95 const char *chainmode; /* Crypt */
96 const char *iv; /* Crypt */
97 uint64_t iv_offset; /* Crypt */
98 const char *key; /* Crypt */
99 };
100
101 /* Per-device properties */
102 struct load_properties {
103 int read_only;
104 uint32_t major;
105 uint32_t minor;
106
107 uint32_t read_ahead;
108 uint32_t read_ahead_flags;
109
110 unsigned segment_count;
111 unsigned size_changed;
112 struct dm_list segs;
113
114 const char *new_name;
115 };
116
117 /* Two of these used to join two nodes with uses and used_by. */
118 struct dm_tree_link {
119 struct dm_list list;
120 struct dm_tree_node *node;
121 };
122
123 struct dm_tree_node {
124 struct dm_tree *dtree;
125
126 const char *name;
127 const char *uuid;
128 struct dm_info info;
129
130 struct dm_list uses; /* Nodes this node uses */
131 struct dm_list used_by; /* Nodes that use this node */
132
133 int activation_priority; /* 0 gets activated first */
134
135 uint16_t udev_flags; /* Udev control flags */
136
137 void *context; /* External supplied context */
138
139 struct load_properties props; /* For creation/table (re)load */
140 };
141
142 struct dm_tree {
143 struct dm_pool *mem;
144 struct dm_hash_table *devs;
145 struct dm_hash_table *uuids;
146 struct dm_tree_node root;
147 int skip_lockfs; /* 1 skips lockfs (for non-snapshots) */
148 int no_flush; /* 1 sets noflush (mirrors/multipath) */
149 uint32_t cookie;
150 };
151
152 struct dm_tree *dm_tree_create(void)
153 {
154 struct dm_tree *dtree;
155
156 if (!(dtree = dm_malloc(sizeof(*dtree)))) {
157 log_error("dm_tree_create malloc failed");
158 return NULL;
159 }
160
161 memset(dtree, 0, sizeof(*dtree));
162 dtree->root.dtree = dtree;
163 dm_list_init(&dtree->root.uses);
164 dm_list_init(&dtree->root.used_by);
165 dtree->skip_lockfs = 0;
166 dtree->no_flush = 0;
167
168 if (!(dtree->mem = dm_pool_create("dtree", 1024))) {
169 log_error("dtree pool creation failed");
170 dm_free(dtree);
171 return NULL;
172 }
173
174 if (!(dtree->devs = dm_hash_create(8))) {
175 log_error("dtree hash creation failed");
176 dm_pool_destroy(dtree->mem);
177 dm_free(dtree);
178 return NULL;
179 }
180
181 if (!(dtree->uuids = dm_hash_create(32))) {
182 log_error("dtree uuid hash creation failed");
183 dm_hash_destroy(dtree->devs);
184 dm_pool_destroy(dtree->mem);
185 dm_free(dtree);
186 return NULL;
187 }
188
189 return dtree;
190 }
191
192 void dm_tree_free(struct dm_tree *dtree)
193 {
194 if (!dtree)
195 return;
196
197 dm_hash_destroy(dtree->uuids);
198 dm_hash_destroy(dtree->devs);
199 dm_pool_destroy(dtree->mem);
200 dm_free(dtree);
201 }
202
203 static int _nodes_are_linked(struct dm_tree_node *parent,
204 struct dm_tree_node *child)
205 {
206 struct dm_tree_link *dlink;
207
208 dm_list_iterate_items(dlink, &parent->uses)
209 if (dlink->node == child)
210 return 1;
211
212 return 0;
213 }
214
215 static int _link(struct dm_list *list, struct dm_tree_node *node)
216 {
217 struct dm_tree_link *dlink;
218
219 if (!(dlink = dm_pool_alloc(node->dtree->mem, sizeof(*dlink)))) {
220 log_error("dtree link allocation failed");
221 return 0;
222 }
223
224 dlink->node = node;
225 dm_list_add(list, &dlink->list);
226
227 return 1;
228 }
229
230 static int _link_nodes(struct dm_tree_node *parent,
231 struct dm_tree_node *child)
232 {
233 if (_nodes_are_linked(parent, child))
234 return 1;
235
236 if (!_link(&parent->uses, child))
237 return 0;
238
239 if (!_link(&child->used_by, parent))
240 return 0;
241
242 return 1;
243 }
244
245 static void _unlink(struct dm_list *list, struct dm_tree_node *node)
246 {
247 struct dm_tree_link *dlink;
248
249 dm_list_iterate_items(dlink, list)
250 if (dlink->node == node) {
251 dm_list_del(&dlink->list);
252 break;
253 }
254 }
255
256 static void _unlink_nodes(struct dm_tree_node *parent,
257 struct dm_tree_node *child)
258 {
259 if (!_nodes_are_linked(parent, child))
260 return;
261
262 _unlink(&parent->uses, child);
263 _unlink(&child->used_by, parent);
264 }
265
266 static int _add_to_toplevel(struct dm_tree_node *node)
267 {
268 return _link_nodes(&node->dtree->root, node);
269 }
270
271 static void _remove_from_toplevel(struct dm_tree_node *node)
272 {
273 return _unlink_nodes(&node->dtree->root, node);
274 }
275
276 static int _add_to_bottomlevel(struct dm_tree_node *node)
277 {
278 return _link_nodes(node, &node->dtree->root);
279 }
280
281 static void _remove_from_bottomlevel(struct dm_tree_node *node)
282 {
283 return _unlink_nodes(node, &node->dtree->root);
284 }
285
286 static int _link_tree_nodes(struct dm_tree_node *parent, struct dm_tree_node *child)
287 {
288 /* Don't link to root node if child already has a parent */
289 if ((parent == &parent->dtree->root)) {
290 if (dm_tree_node_num_children(child, 1))
291 return 1;
292 } else
293 _remove_from_toplevel(child);
294
295 if ((child == &child->dtree->root)) {
296 if (dm_tree_node_num_children(parent, 0))
297 return 1;
298 } else
299 _remove_from_bottomlevel(parent);
300
301 return _link_nodes(parent, child);
302 }
303
304 static struct dm_tree_node *_create_dm_tree_node(struct dm_tree *dtree,
305 const char *name,
306 const char *uuid,
307 struct dm_info *info,
308 void *context,
309 uint16_t udev_flags)
310 {
311 struct dm_tree_node *node;
312 uint64_t dev;
313
314 if (!(node = dm_pool_zalloc(dtree->mem, sizeof(*node)))) {
315 log_error("_create_dm_tree_node alloc failed");
316 return NULL;
317 }
318
319 node->dtree = dtree;
320
321 node->name = name;
322 node->uuid = uuid;
323 node->info = *info;
324 node->context = context;
325 node->udev_flags = udev_flags;
326 node->activation_priority = 0;
327
328 dm_list_init(&node->uses);
329 dm_list_init(&node->used_by);
330 dm_list_init(&node->props.segs);
331
332 dev = MKDEV(info->major, info->minor);
333
334 if (!dm_hash_insert_binary(dtree->devs, (const char *) &dev,
335 sizeof(dev), node)) {
336 log_error("dtree node hash insertion failed");
337 dm_pool_free(dtree->mem, node);
338 return NULL;
339 }
340
341 if (uuid && *uuid &&
342 !dm_hash_insert(dtree->uuids, uuid, node)) {
343 log_error("dtree uuid hash insertion failed");
344 dm_hash_remove_binary(dtree->devs, (const char *) &dev,
345 sizeof(dev));
346 dm_pool_free(dtree->mem, node);
347 return NULL;
348 }
349
350 return node;
351 }
352
353 static struct dm_tree_node *_find_dm_tree_node(struct dm_tree *dtree,
354 uint32_t major, uint32_t minor)
355 {
356 uint64_t dev = MKDEV(major, minor);
357
358 return dm_hash_lookup_binary(dtree->devs, (const char *) &dev,
359 sizeof(dev));
360 }
361
362 static struct dm_tree_node *_find_dm_tree_node_by_uuid(struct dm_tree *dtree,
363 const char *uuid)
364 {
365 struct dm_tree_node *node;
366
367 if ((node = dm_hash_lookup(dtree->uuids, uuid)))
368 return node;
369
370 if (strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
371 return NULL;
372
373 return dm_hash_lookup(dtree->uuids, uuid + sizeof(UUID_PREFIX) - 1);
374 }
375
376 static int _deps(struct dm_task **dmt, struct dm_pool *mem, uint32_t major, uint32_t minor,
377 const char **name, const char **uuid,
378 struct dm_info *info, struct dm_deps **deps)
379 {
380 memset(info, 0, sizeof(*info));
381
382 if (!dm_is_dm_major(major)) {
383 *name = "";
384 *uuid = "";
385 *deps = NULL;
386 info->major = major;
387 info->minor = minor;
388 info->exists = 0;
389 info->live_table = 0;
390 info->inactive_table = 0;
391 info->read_only = 0;
392 return 1;
393 }
394
395 if (!(*dmt = dm_task_create(DM_DEVICE_DEPS))) {
396 log_error("deps dm_task creation failed");
397 return 0;
398 }
399
400 if (!dm_task_set_major(*dmt, major)) {
401 log_error("_deps: failed to set major for (%" PRIu32 ":%" PRIu32 ")",
402 major, minor);
403 goto failed;
404 }
405
406 if (!dm_task_set_minor(*dmt, minor)) {
407 log_error("_deps: failed to set minor for (%" PRIu32 ":%" PRIu32 ")",
408 major, minor);
409 goto failed;
410 }
411
412 if (!dm_task_run(*dmt)) {
413 log_error("_deps: task run failed for (%" PRIu32 ":%" PRIu32 ")",
414 major, minor);
415 goto failed;
416 }
417
418 if (!dm_task_get_info(*dmt, info)) {
419 log_error("_deps: failed to get info for (%" PRIu32 ":%" PRIu32 ")",
420 major, minor);
421 goto failed;
422 }
423
424 if (!info->exists) {
425 *name = "";
426 *uuid = "";
427 *deps = NULL;
428 } else {
429 if (info->major != major) {
430 log_error("Inconsistent dtree major number: %u != %u",
431 major, info->major);
432 goto failed;
433 }
434 if (info->minor != minor) {
435 log_error("Inconsistent dtree minor number: %u != %u",
436 minor, info->minor);
437 goto failed;
438 }
439 if (!(*name = dm_pool_strdup(mem, dm_task_get_name(*dmt)))) {
440 log_error("name pool_strdup failed");
441 goto failed;
442 }
443 if (!(*uuid = dm_pool_strdup(mem, dm_task_get_uuid(*dmt)))) {
444 log_error("uuid pool_strdup failed");
445 goto failed;
446 }
447 *deps = dm_task_get_deps(*dmt);
448 }
449
450 return 1;
451
452 failed:
453 dm_task_destroy(*dmt);
454 return 0;
455 }
456
457 static struct dm_tree_node *_add_dev(struct dm_tree *dtree,
458 struct dm_tree_node *parent,
459 uint32_t major, uint32_t minor)
460 {
461 struct dm_task *dmt = NULL;
462 struct dm_info info;
463 struct dm_deps *deps = NULL;
464 const char *name = NULL;
465 const char *uuid = NULL;
466 struct dm_tree_node *node = NULL;
467 uint32_t i;
468 int new = 0;
469
470 /* Already in tree? */
471 if (!(node = _find_dm_tree_node(dtree, major, minor))) {
472 if (!_deps(&dmt, dtree->mem, major, minor, &name, &uuid, &info, &deps))
473 return_NULL;
474
475 if (!(node = _create_dm_tree_node(dtree, name, uuid, &info,
476 NULL, 0)))
477 goto_out;
478 new = 1;
479 }
480
481 if (!_link_tree_nodes(parent, node)) {
482 node = NULL;
483 goto_out;
484 }
485
486 /* If node was already in tree, no need to recurse. */
487 if (!new)
488 goto out;
489
490 /* Can't recurse if not a mapped device or there are no dependencies */
491 if (!node->info.exists || !deps->count) {
492 if (!_add_to_bottomlevel(node)) {
493 stack;
494 node = NULL;
495 }
496 goto out;
497 }
498
499 /* Add dependencies to tree */
500 for (i = 0; i < deps->count; i++)
501 if (!_add_dev(dtree, node, MAJOR(deps->device[i]),
502 MINOR(deps->device[i]))) {
503 node = NULL;
504 goto_out;
505 }
506
507 out:
508 if (dmt)
509 dm_task_destroy(dmt);
510
511 return node;
512 }
513
514 static int _node_clear_table(struct dm_tree_node *dnode)
515 {
516 struct dm_task *dmt;
517 struct dm_info *info;
518 const char *name;
519 int r;
520
521 if (!(info = &dnode->info)) {
522 log_error("_node_clear_table failed: missing info");
523 return 0;
524 }
525
526 if (!(name = dm_tree_node_get_name(dnode))) {
527 log_error("_node_clear_table failed: missing name");
528 return 0;
529 }
530
531 /* Is there a table? */
532 if (!info->exists || !info->inactive_table)
533 return 1;
534
535 log_verbose("Clearing inactive table %s (%" PRIu32 ":%" PRIu32 ")",
536 name, info->major, info->minor);
537
538 if (!(dmt = dm_task_create(DM_DEVICE_CLEAR))) {
539 dm_task_destroy(dmt);
540 log_error("Table clear dm_task creation failed for %s", name);
541 return 0;
542 }
543
544 if (!dm_task_set_major(dmt, info->major) ||
545 !dm_task_set_minor(dmt, info->minor)) {
546 log_error("Failed to set device number for %s table clear", name);
547 dm_task_destroy(dmt);
548 return 0;
549 }
550
551 r = dm_task_run(dmt);
552
553 if (!dm_task_get_info(dmt, info)) {
554 log_error("_node_clear_table failed: info missing after running task for %s", name);
555 r = 0;
556 }
557
558 dm_task_destroy(dmt);
559
560 return r;
561 }
562
563 struct dm_tree_node *dm_tree_add_new_dev(struct dm_tree *dtree,
564 const char *name,
565 const char *uuid,
566 uint32_t major, uint32_t minor,
567 int read_only,
568 int clear_inactive,
569 void *context)
570 {
571 struct dm_tree_node *dnode;
572 struct dm_info info;
573 const char *name2;
574 const char *uuid2;
575
576 /* Do we need to add node to tree? */
577 if (!(dnode = dm_tree_find_node_by_uuid(dtree, uuid))) {
578 if (!(name2 = dm_pool_strdup(dtree->mem, name))) {
579 log_error("name pool_strdup failed");
580 return NULL;
581 }
582 if (!(uuid2 = dm_pool_strdup(dtree->mem, uuid))) {
583 log_error("uuid pool_strdup failed");
584 return NULL;
585 }
586
587 info.major = 0;
588 info.minor = 0;
589 info.exists = 0;
590 info.live_table = 0;
591 info.inactive_table = 0;
592 info.read_only = 0;
593
594 if (!(dnode = _create_dm_tree_node(dtree, name2, uuid2, &info,
595 context, 0)))
596 return_NULL;
597
598 /* Attach to root node until a table is supplied */
599 if (!_add_to_toplevel(dnode) || !_add_to_bottomlevel(dnode))
600 return_NULL;
601
602 dnode->props.major = major;
603 dnode->props.minor = minor;
604 dnode->props.new_name = NULL;
605 dnode->props.size_changed = 0;
606 } else if (strcmp(name, dnode->name)) {
607 /* Do we need to rename node? */
608 if (!(dnode->props.new_name = dm_pool_strdup(dtree->mem, name))) {
609 log_error("name pool_strdup failed");
610 return 0;
611 }
612 }
613
614 dnode->props.read_only = read_only ? 1 : 0;
615 dnode->props.read_ahead = DM_READ_AHEAD_AUTO;
616 dnode->props.read_ahead_flags = 0;
617
618 if (clear_inactive && !_node_clear_table(dnode))
619 return_NULL;
620
621 dnode->context = context;
622 dnode->udev_flags = 0;
623
624 return dnode;
625 }
626
627 struct dm_tree_node *dm_tree_add_new_dev_with_udev_flags(struct dm_tree *dtree,
628 const char *name,
629 const char *uuid,
630 uint32_t major,
631 uint32_t minor,
632 int read_only,
633 int clear_inactive,
634 void *context,
635 uint16_t udev_flags)
636 {
637 struct dm_tree_node *node;
638
639 if ((node = dm_tree_add_new_dev(dtree, name, uuid, major, minor, read_only,
640 clear_inactive, context)))
641 node->udev_flags = udev_flags;
642
643 return node;
644 }
645
646
647 void dm_tree_node_set_read_ahead(struct dm_tree_node *dnode,
648 uint32_t read_ahead,
649 uint32_t read_ahead_flags)
650 {
651 dnode->props.read_ahead = read_ahead;
652 dnode->props.read_ahead_flags = read_ahead_flags;
653 }
654
655 int dm_tree_add_dev(struct dm_tree *dtree, uint32_t major, uint32_t minor)
656 {
657 return _add_dev(dtree, &dtree->root, major, minor) ? 1 : 0;
658 }
659
660 const char *dm_tree_node_get_name(struct dm_tree_node *node)
661 {
662 return node->info.exists ? node->name : "";
663 }
664
665 const char *dm_tree_node_get_uuid(struct dm_tree_node *node)
666 {
667 return node->info.exists ? node->uuid : "";
668 }
669
670 const struct dm_info *dm_tree_node_get_info(struct dm_tree_node *node)
671 {
672 return &node->info;
673 }
674
675 void *dm_tree_node_get_context(struct dm_tree_node *node)
676 {
677 return node->context;
678 }
679
680 int dm_tree_node_size_changed(struct dm_tree_node *dnode)
681 {
682 return dnode->props.size_changed;
683 }
684
685 int dm_tree_node_num_children(struct dm_tree_node *node, uint32_t inverted)
686 {
687 if (inverted) {
688 if (_nodes_are_linked(&node->dtree->root, node))
689 return 0;
690 return dm_list_size(&node->used_by);
691 }
692
693 if (_nodes_are_linked(node, &node->dtree->root))
694 return 0;
695
696 return dm_list_size(&node->uses);
697 }
698
699 /*
700 * Returns 1 if no prefix supplied
701 */
702 static int _uuid_prefix_matches(const char *uuid, const char *uuid_prefix, size_t uuid_prefix_len)
703 {
704 if (!uuid_prefix)
705 return 1;
706
707 if (!strncmp(uuid, uuid_prefix, uuid_prefix_len))
708 return 1;
709
710 /* Handle transition: active device uuids might be missing the prefix */
711 if (uuid_prefix_len <= 4)
712 return 0;
713
714 if (!strncmp(uuid, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
715 return 0;
716
717 if (strncmp(uuid_prefix, UUID_PREFIX, sizeof(UUID_PREFIX) - 1))
718 return 0;
719
720 if (!strncmp(uuid, uuid_prefix + sizeof(UUID_PREFIX) - 1, uuid_prefix_len - (sizeof(UUID_PREFIX) - 1)))
721 return 1;
722
723 return 0;
724 }
725
726 /*
727 * Returns 1 if no children.
728 */
729 static int _children_suspended(struct dm_tree_node *node,
730 uint32_t inverted,
731 const char *uuid_prefix,
732 size_t uuid_prefix_len)
733 {
734 struct dm_list *list;
735 struct dm_tree_link *dlink;
736 const struct dm_info *dinfo;
737 const char *uuid;
738
739 if (inverted) {
740 if (_nodes_are_linked(&node->dtree->root, node))
741 return 1;
742 list = &node->used_by;
743 } else {
744 if (_nodes_are_linked(node, &node->dtree->root))
745 return 1;
746 list = &node->uses;
747 }
748
749 dm_list_iterate_items(dlink, list) {
750 if (!(uuid = dm_tree_node_get_uuid(dlink->node))) {
751 stack;
752 continue;
753 }
754
755 /* Ignore if it doesn't belong to this VG */
756 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
757 continue;
758
759 if (!(dinfo = dm_tree_node_get_info(dlink->node))) {
760 stack; /* FIXME Is this normal? */
761 return 0;
762 }
763
764 if (!dinfo->suspended)
765 return 0;
766 }
767
768 return 1;
769 }
770
771 /*
772 * Set major and minor to zero for root of tree.
773 */
774 struct dm_tree_node *dm_tree_find_node(struct dm_tree *dtree,
775 uint32_t major,
776 uint32_t minor)
777 {
778 if (!major && !minor)
779 return &dtree->root;
780
781 return _find_dm_tree_node(dtree, major, minor);
782 }
783
784 /*
785 * Set uuid to NULL for root of tree.
786 */
787 struct dm_tree_node *dm_tree_find_node_by_uuid(struct dm_tree *dtree,
788 const char *uuid)
789 {
790 if (!uuid || !*uuid)
791 return &dtree->root;
792
793 return _find_dm_tree_node_by_uuid(dtree, uuid);
794 }
795
796 /*
797 * First time set *handle to NULL.
798 * Set inverted to invert the tree.
799 */
800 struct dm_tree_node *dm_tree_next_child(void **handle,
801 struct dm_tree_node *parent,
802 uint32_t inverted)
803 {
804 struct dm_list **dlink = (struct dm_list **) handle;
805 struct dm_list *use_list;
806
807 if (inverted)
808 use_list = &parent->used_by;
809 else
810 use_list = &parent->uses;
811
812 if (!*dlink)
813 *dlink = dm_list_first(use_list);
814 else
815 *dlink = dm_list_next(use_list, *dlink);
816
817 return (*dlink) ? dm_list_item(*dlink, struct dm_tree_link)->node : NULL;
818 }
819
820 /*
821 * Deactivate a device with its dependencies if the uuid prefix matches.
822 */
823 static int _info_by_dev(uint32_t major, uint32_t minor, int with_open_count,
824 struct dm_info *info)
825 {
826 struct dm_task *dmt;
827 int r;
828
829 if (!(dmt = dm_task_create(DM_DEVICE_INFO))) {
830 log_error("_info_by_dev: dm_task creation failed");
831 return 0;
832 }
833
834 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
835 log_error("_info_by_dev: Failed to set device number");
836 dm_task_destroy(dmt);
837 return 0;
838 }
839
840 if (!with_open_count && !dm_task_no_open_count(dmt))
841 log_error("Failed to disable open_count");
842
843 if ((r = dm_task_run(dmt)))
844 r = dm_task_get_info(dmt, info);
845
846 dm_task_destroy(dmt);
847
848 return r;
849 }
850
851 static int _deactivate_node(const char *name, uint32_t major, uint32_t minor,
852 uint32_t *cookie, uint16_t udev_flags)
853 {
854 struct dm_task *dmt;
855 int r = 0;
856
857 log_verbose("Removing %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor);
858
859 if (!(dmt = dm_task_create(DM_DEVICE_REMOVE))) {
860 log_error("Deactivation dm_task creation failed for %s", name);
861 return 0;
862 }
863
864 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
865 log_error("Failed to set device number for %s deactivation", name);
866 goto out;
867 }
868
869 if (!dm_task_no_open_count(dmt))
870 log_error("Failed to disable open_count");
871
872 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
873 goto out;
874
875 r = dm_task_run(dmt);
876
877 /* FIXME Until kernel returns actual name so dm-ioctl.c can handle it */
878 rm_dev_node(name, dmt->cookie_set);
879
880 /* FIXME Remove node from tree or mark invalid? */
881
882 out:
883 dm_task_destroy(dmt);
884
885 return r;
886 }
887
888 static int _rename_node(const char *old_name, const char *new_name, uint32_t major,
889 uint32_t minor, uint32_t *cookie, uint16_t udev_flags)
890 {
891 struct dm_task *dmt;
892 int r = 0;
893
894 log_verbose("Renaming %s (%" PRIu32 ":%" PRIu32 ") to %s", old_name, major, minor, new_name);
895
896 if (!(dmt = dm_task_create(DM_DEVICE_RENAME))) {
897 log_error("Rename dm_task creation failed for %s", old_name);
898 return 0;
899 }
900
901 if (!dm_task_set_name(dmt, old_name)) {
902 log_error("Failed to set name for %s rename.", old_name);
903 goto out;
904 }
905
906 if (!dm_task_set_newname(dmt, new_name))
907 goto_out;
908
909 if (!dm_task_no_open_count(dmt))
910 log_error("Failed to disable open_count");
911
912 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
913 goto out;
914
915 r = dm_task_run(dmt);
916
917 out:
918 dm_task_destroy(dmt);
919
920 return r;
921 }
922
923 /* FIXME Merge with _suspend_node? */
924 static int _resume_node(const char *name, uint32_t major, uint32_t minor,
925 uint32_t read_ahead, uint32_t read_ahead_flags,
926 struct dm_info *newinfo, uint32_t *cookie,
927 uint16_t udev_flags)
928 {
929 struct dm_task *dmt;
930 int r = 0;
931
932 log_verbose("Resuming %s (%" PRIu32 ":%" PRIu32 ")", name, major, minor);
933
934 if (!(dmt = dm_task_create(DM_DEVICE_RESUME))) {
935 log_error("Suspend dm_task creation failed for %s", name);
936 return 0;
937 }
938
939 /* FIXME Kernel should fill in name on return instead */
940 if (!dm_task_set_name(dmt, name)) {
941 log_error("Failed to set readahead device name for %s", name);
942 goto out;
943 }
944
945 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
946 log_error("Failed to set device number for %s resumption.", name);
947 goto out;
948 }
949
950 if (!dm_task_no_open_count(dmt))
951 log_error("Failed to disable open_count");
952
953 if (!dm_task_set_read_ahead(dmt, read_ahead, read_ahead_flags))
954 log_error("Failed to set read ahead");
955
956 if (!dm_task_set_cookie(dmt, cookie, udev_flags))
957 goto out;
958
959 if ((r = dm_task_run(dmt)))
960 r = dm_task_get_info(dmt, newinfo);
961
962 out:
963 dm_task_destroy(dmt);
964
965 return r;
966 }
967
968 static int _suspend_node(const char *name, uint32_t major, uint32_t minor,
969 int skip_lockfs, int no_flush, struct dm_info *newinfo)
970 {
971 struct dm_task *dmt;
972 int r;
973
974 log_verbose("Suspending %s (%" PRIu32 ":%" PRIu32 ")%s%s",
975 name, major, minor,
976 skip_lockfs ? "" : " with filesystem sync",
977 no_flush ? "" : " with device flush");
978
979 if (!(dmt = dm_task_create(DM_DEVICE_SUSPEND))) {
980 log_error("Suspend dm_task creation failed for %s", name);
981 return 0;
982 }
983
984 if (!dm_task_set_major(dmt, major) || !dm_task_set_minor(dmt, minor)) {
985 log_error("Failed to set device number for %s suspension.", name);
986 dm_task_destroy(dmt);
987 return 0;
988 }
989
990 if (!dm_task_no_open_count(dmt))
991 log_error("Failed to disable open_count");
992
993 if (skip_lockfs && !dm_task_skip_lockfs(dmt))
994 log_error("Failed to set skip_lockfs flag.");
995
996 if (no_flush && !dm_task_no_flush(dmt))
997 log_error("Failed to set no_flush flag.");
998
999 if ((r = dm_task_run(dmt)))
1000 r = dm_task_get_info(dmt, newinfo);
1001
1002 dm_task_destroy(dmt);
1003
1004 return r;
1005 }
1006
1007 int dm_tree_deactivate_children(struct dm_tree_node *dnode,
1008 const char *uuid_prefix,
1009 size_t uuid_prefix_len)
1010 {
1011 void *handle = NULL;
1012 struct dm_tree_node *child = dnode;
1013 struct dm_info info;
1014 const struct dm_info *dinfo;
1015 const char *name;
1016 const char *uuid;
1017
1018 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1019 if (!(dinfo = dm_tree_node_get_info(child))) {
1020 stack;
1021 continue;
1022 }
1023
1024 if (!(name = dm_tree_node_get_name(child))) {
1025 stack;
1026 continue;
1027 }
1028
1029 if (!(uuid = dm_tree_node_get_uuid(child))) {
1030 stack;
1031 continue;
1032 }
1033
1034 /* Ignore if it doesn't belong to this VG */
1035 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1036 continue;
1037
1038 /* Refresh open_count */
1039 if (!_info_by_dev(dinfo->major, dinfo->minor, 1, &info) ||
1040 !info.exists || info.open_count)
1041 continue;
1042
1043 if (!_deactivate_node(name, info.major, info.minor,
1044 &child->dtree->cookie, child->udev_flags)) {
1045 log_error("Unable to deactivate %s (%" PRIu32
1046 ":%" PRIu32 ")", name, info.major,
1047 info.minor);
1048 continue;
1049 }
1050
1051 if (dm_tree_node_num_children(child, 0))
1052 dm_tree_deactivate_children(child, uuid_prefix, uuid_prefix_len);
1053 }
1054
1055 return 1;
1056 }
1057
1058 void dm_tree_skip_lockfs(struct dm_tree_node *dnode)
1059 {
1060 dnode->dtree->skip_lockfs = 1;
1061 }
1062
1063 void dm_tree_use_no_flush_suspend(struct dm_tree_node *dnode)
1064 {
1065 dnode->dtree->no_flush = 1;
1066 }
1067
1068 int dm_tree_suspend_children(struct dm_tree_node *dnode,
1069 const char *uuid_prefix,
1070 size_t uuid_prefix_len)
1071 {
1072 void *handle = NULL;
1073 struct dm_tree_node *child = dnode;
1074 struct dm_info info, newinfo;
1075 const struct dm_info *dinfo;
1076 const char *name;
1077 const char *uuid;
1078
1079 /* Suspend nodes at this level of the tree */
1080 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1081 if (!(dinfo = dm_tree_node_get_info(child))) {
1082 stack;
1083 continue;
1084 }
1085
1086 if (!(name = dm_tree_node_get_name(child))) {
1087 stack;
1088 continue;
1089 }
1090
1091 if (!(uuid = dm_tree_node_get_uuid(child))) {
1092 stack;
1093 continue;
1094 }
1095
1096 /* Ignore if it doesn't belong to this VG */
1097 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1098 continue;
1099
1100 /* Ensure immediate parents are already suspended */
1101 if (!_children_suspended(child, 1, uuid_prefix, uuid_prefix_len))
1102 continue;
1103
1104 if (!_info_by_dev(dinfo->major, dinfo->minor, 0, &info) ||
1105 !info.exists || info.suspended)
1106 continue;
1107
1108 if (!_suspend_node(name, info.major, info.minor,
1109 child->dtree->skip_lockfs,
1110 child->dtree->no_flush, &newinfo)) {
1111 log_error("Unable to suspend %s (%" PRIu32
1112 ":%" PRIu32 ")", name, info.major,
1113 info.minor);
1114 continue;
1115 }
1116
1117 /* Update cached info */
1118 child->info = newinfo;
1119 }
1120
1121 /* Then suspend any child nodes */
1122 handle = NULL;
1123
1124 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1125 if (!(uuid = dm_tree_node_get_uuid(child))) {
1126 stack;
1127 continue;
1128 }
1129
1130 /* Ignore if it doesn't belong to this VG */
1131 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1132 continue;
1133
1134 if (dm_tree_node_num_children(child, 0))
1135 dm_tree_suspend_children(child, uuid_prefix, uuid_prefix_len);
1136 }
1137
1138 return 1;
1139 }
1140
1141 int dm_tree_activate_children(struct dm_tree_node *dnode,
1142 const char *uuid_prefix,
1143 size_t uuid_prefix_len)
1144 {
1145 void *handle = NULL;
1146 struct dm_tree_node *child = dnode;
1147 struct dm_info newinfo;
1148 const char *name;
1149 const char *uuid;
1150 int priority;
1151
1152 /* Activate children first */
1153 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1154 if (!(uuid = dm_tree_node_get_uuid(child))) {
1155 stack;
1156 continue;
1157 }
1158
1159 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1160 continue;
1161
1162 if (dm_tree_node_num_children(child, 0))
1163 dm_tree_activate_children(child, uuid_prefix, uuid_prefix_len);
1164 }
1165
1166 handle = NULL;
1167
1168 for (priority = 0; priority < 2; priority++) {
1169 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1170 if (!(uuid = dm_tree_node_get_uuid(child))) {
1171 stack;
1172 continue;
1173 }
1174
1175 if (!_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1176 continue;
1177
1178 if (priority != child->activation_priority)
1179 continue;
1180
1181 if (!(name = dm_tree_node_get_name(child))) {
1182 stack;
1183 continue;
1184 }
1185
1186 /* Rename? */
1187 if (child->props.new_name) {
1188 if (!_rename_node(name, child->props.new_name, child->info.major,
1189 child->info.minor, &child->dtree->cookie,
1190 child->udev_flags)) {
1191 log_error("Failed to rename %s (%" PRIu32
1192 ":%" PRIu32 ") to %s", name, child->info.major,
1193 child->info.minor, child->props.new_name);
1194 return 0;
1195 }
1196 child->name = child->props.new_name;
1197 child->props.new_name = NULL;
1198 }
1199
1200 if (!child->info.inactive_table && !child->info.suspended)
1201 continue;
1202
1203 if (!_resume_node(child->name, child->info.major, child->info.minor,
1204 child->props.read_ahead, child->props.read_ahead_flags,
1205 &newinfo, &child->dtree->cookie, child->udev_flags)) {
1206 log_error("Unable to resume %s (%" PRIu32
1207 ":%" PRIu32 ")", child->name, child->info.major,
1208 child->info.minor);
1209 continue;
1210 }
1211
1212 /* Update cached info */
1213 child->info = newinfo;
1214 }
1215 }
1216
1217 handle = NULL;
1218
1219 return 1;
1220 }
1221
1222 static int _create_node(struct dm_tree_node *dnode)
1223 {
1224 int r = 0;
1225 struct dm_task *dmt;
1226
1227 log_verbose("Creating %s", dnode->name);
1228
1229 if (!(dmt = dm_task_create(DM_DEVICE_CREATE))) {
1230 log_error("Create dm_task creation failed for %s", dnode->name);
1231 return 0;
1232 }
1233
1234 if (!dm_task_set_name(dmt, dnode->name)) {
1235 log_error("Failed to set device name for %s", dnode->name);
1236 goto out;
1237 }
1238
1239 if (!dm_task_set_uuid(dmt, dnode->uuid)) {
1240 log_error("Failed to set uuid for %s", dnode->name);
1241 goto out;
1242 }
1243
1244 if (dnode->props.major &&
1245 (!dm_task_set_major(dmt, dnode->props.major) ||
1246 !dm_task_set_minor(dmt, dnode->props.minor))) {
1247 log_error("Failed to set device number for %s creation.", dnode->name);
1248 goto out;
1249 }
1250
1251 if (dnode->props.read_only && !dm_task_set_ro(dmt)) {
1252 log_error("Failed to set read only flag for %s", dnode->name);
1253 goto out;
1254 }
1255
1256 if (!dm_task_no_open_count(dmt))
1257 log_error("Failed to disable open_count");
1258
1259 if ((r = dm_task_run(dmt)))
1260 r = dm_task_get_info(dmt, &dnode->info);
1261
1262 out:
1263 dm_task_destroy(dmt);
1264
1265 return r;
1266 }
1267
1268
1269 static int _build_dev_string(char *devbuf, size_t bufsize, struct dm_tree_node *node)
1270 {
1271 if (!dm_format_dev(devbuf, bufsize, node->info.major, node->info.minor)) {
1272 log_error("Failed to format %s device number for %s as dm "
1273 "target (%u,%u)",
1274 node->name, node->uuid, node->info.major, node->info.minor);
1275 return 0;
1276 }
1277
1278 return 1;
1279 }
1280
1281 /* simplify string emiting code */
1282 #define EMIT_PARAMS(p, str...)\
1283 do {\
1284 int w;\
1285 if ((w = dm_snprintf(params + p, paramsize - (size_t) p, str)) < 0) {\
1286 stack; /* Out of space */\
1287 return -1;\
1288 }\
1289 p += w;\
1290 } while (0)
1291
1292 /*
1293 * _emit_areas_line
1294 *
1295 * Returns: 1 on success, 0 on failure
1296 */
1297 static int _emit_areas_line(struct dm_task *dmt __attribute((unused)),
1298 struct load_segment *seg, char *params,
1299 size_t paramsize, int *pos)
1300 {
1301 struct seg_area *area;
1302 char devbuf[DM_FORMAT_DEV_BUFSIZE];
1303 unsigned first_time = 1;
1304
1305 dm_list_iterate_items(area, &seg->areas) {
1306 if (!_build_dev_string(devbuf, sizeof(devbuf), area->dev_node))
1307 return_0;
1308
1309 EMIT_PARAMS(*pos, "%s%s %" PRIu64, first_time ? "" : " ",
1310 devbuf, area->offset);
1311
1312 first_time = 0;
1313 }
1314
1315 return 1;
1316 }
1317
1318 /*
1319 * Returns: 1 on success, 0 on failure
1320 */
1321 static int _mirror_emit_segment_line(struct dm_task *dmt, uint32_t major,
1322 uint32_t minor, struct load_segment *seg,
1323 uint64_t *seg_start, char *params,
1324 size_t paramsize)
1325 {
1326 int r;
1327 int block_on_error = 0;
1328 int handle_errors = 0;
1329 int dm_log_userspace = 0;
1330 struct utsname uts;
1331 unsigned log_parm_count;
1332 int pos = 0;
1333 char logbuf[DM_FORMAT_DEV_BUFSIZE];
1334 const char *logtype;
1335
1336 r = uname(&uts);
1337 if (r)
1338 return_0;
1339
1340 if ((seg->flags & DM_BLOCK_ON_ERROR)) {
1341 /*
1342 * Originally, block_on_error was an argument to the log
1343 * portion of the mirror CTR table. It was renamed to
1344 * "handle_errors" and now resides in the 'features'
1345 * section of the mirror CTR table (i.e. at the end).
1346 *
1347 * We can identify whether to use "block_on_error" or
1348 * "handle_errors" by the dm-mirror module's version
1349 * number (>= 1.12) or by the kernel version (>= 2.6.22).
1350 */
1351 if (strncmp(uts.release, "2.6.22", 6) >= 0)
1352 handle_errors = 1;
1353 else
1354 block_on_error = 1;
1355 }
1356
1357 if (seg->clustered) {
1358 /* Cluster mirrors require a UUID */
1359 if (!seg->uuid)
1360 return_0;
1361
1362 /*
1363 * Cluster mirrors used to have their own log
1364 * types. Now they are accessed through the
1365 * userspace log type.
1366 *
1367 * The dm-log-userspace module was added to the
1368 * 2.6.31 kernel.
1369 */
1370 if (strncmp(uts.release, "2.6.31", 6) >= 0)
1371 dm_log_userspace = 1;
1372 }
1373
1374 /* Region size */
1375 log_parm_count = 1;
1376
1377 /* [no]sync, block_on_error etc. */
1378 log_parm_count += hweight32(seg->flags);
1379
1380 /* "handle_errors" is a feature arg now */
1381 if (handle_errors)
1382 log_parm_count--;
1383
1384 /* DM_CORELOG does not count in the param list */
1385 if (seg->flags & DM_CORELOG)
1386 log_parm_count--;
1387
1388 if (seg->clustered) {
1389 log_parm_count++; /* For UUID */
1390
1391 if (!dm_log_userspace)
1392 EMIT_PARAMS(pos, "clustered-");
1393 }
1394
1395 if (!seg->log)
1396 logtype = "core";
1397 else {
1398 logtype = "disk";
1399 log_parm_count++;
1400 if (!_build_dev_string(logbuf, sizeof(logbuf), seg->log))
1401 return_0;
1402 }
1403
1404 if (dm_log_userspace)
1405 EMIT_PARAMS(pos, "userspace %u %s clustered-%s",
1406 log_parm_count, seg->uuid, logtype);
1407 else
1408 EMIT_PARAMS(pos, "%s %u", logtype, log_parm_count);
1409
1410 if (seg->log)
1411 EMIT_PARAMS(pos, " %s", logbuf);
1412
1413 EMIT_PARAMS(pos, " %u", seg->region_size);
1414
1415 if (seg->clustered && !dm_log_userspace)
1416 EMIT_PARAMS(pos, " %s", seg->uuid);
1417
1418 if ((seg->flags & DM_NOSYNC))
1419 EMIT_PARAMS(pos, " nosync");
1420 else if ((seg->flags & DM_FORCESYNC))
1421 EMIT_PARAMS(pos, " sync");
1422
1423 if (block_on_error)
1424 EMIT_PARAMS(pos, " block_on_error");
1425
1426 EMIT_PARAMS(pos, " %u ", seg->mirror_area_count);
1427
1428 if ((r = _emit_areas_line(dmt, seg, params, paramsize, &pos)) <= 0)
1429 return_0;
1430
1431 if (handle_errors)
1432 EMIT_PARAMS(pos, " 1 handle_errors");
1433
1434 return 1;
1435 }
1436
1437 static int _emit_segment_line(struct dm_task *dmt, uint32_t major,
1438 uint32_t minor, struct load_segment *seg,
1439 uint64_t *seg_start, char *params,
1440 size_t paramsize)
1441 {
1442 int pos = 0;
1443 int r;
1444 char originbuf[DM_FORMAT_DEV_BUFSIZE], cowbuf[DM_FORMAT_DEV_BUFSIZE];
1445
1446 switch(seg->type) {
1447 case SEG_ERROR:
1448 case SEG_ZERO:
1449 case SEG_LINEAR:
1450 break;
1451 case SEG_MIRRORED:
1452 /* Mirrors are pretty complicated - now in separate function */
1453 r = _mirror_emit_segment_line(dmt, major, minor, seg, seg_start,
1454 params, paramsize);
1455 if (!r)
1456 return_0;
1457 break;
1458 case SEG_SNAPSHOT:
1459 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin))
1460 return_0;
1461 if (!_build_dev_string(cowbuf, sizeof(cowbuf), seg->cow))
1462 return_0;
1463 EMIT_PARAMS(pos, "%s %s %c %d", originbuf, cowbuf,
1464 seg->persistent ? 'P' : 'N', seg->chunk_size);
1465 break;
1466 case SEG_SNAPSHOT_ORIGIN:
1467 if (!_build_dev_string(originbuf, sizeof(originbuf), seg->origin))
1468 return_0;
1469 EMIT_PARAMS(pos, "%s", originbuf);
1470 break;
1471 case SEG_STRIPED:
1472 EMIT_PARAMS(pos, "%u %u ", seg->area_count, seg->stripe_size);
1473 break;
1474 case SEG_CRYPT:
1475 EMIT_PARAMS(pos, "%s%s%s%s%s %s %" PRIu64 " ", seg->cipher,
1476 seg->chainmode ? "-" : "", seg->chainmode ?: "",
1477 seg->iv ? "-" : "", seg->iv ?: "", seg->key,
1478 seg->iv_offset != DM_CRYPT_IV_DEFAULT ?
1479 seg->iv_offset : *seg_start);
1480 break;
1481 }
1482
1483 switch(seg->type) {
1484 case SEG_ERROR:
1485 case SEG_SNAPSHOT:
1486 case SEG_SNAPSHOT_ORIGIN:
1487 case SEG_ZERO:
1488 break;
1489 case SEG_CRYPT:
1490 case SEG_LINEAR:
1491 case SEG_STRIPED:
1492 if ((r = _emit_areas_line(dmt, seg, params, paramsize, &pos)) <= 0) {
1493 stack;
1494 return r;
1495 }
1496 break;
1497 }
1498
1499 log_debug("Adding target to (%" PRIu32 ":%" PRIu32 "): %" PRIu64
1500 " %" PRIu64 " %s %s", major, minor,
1501 *seg_start, seg->size, dm_segtypes[seg->type].target, params);
1502
1503 if (!dm_task_add_target(dmt, *seg_start, seg->size, dm_segtypes[seg->type].target, params))
1504 return_0;
1505
1506 *seg_start += seg->size;
1507
1508 return 1;
1509 }
1510
1511 #undef EMIT_PARAMS
1512
1513 static int _emit_segment(struct dm_task *dmt, uint32_t major, uint32_t minor,
1514 struct load_segment *seg, uint64_t *seg_start)
1515 {
1516 char *params;
1517 size_t paramsize = 4096;
1518 int ret;
1519
1520 do {
1521 if (!(params = dm_malloc(paramsize))) {
1522 log_error("Insufficient space for target parameters.");
1523 return 0;
1524 }
1525
1526 params[0] = '\0';
1527 ret = _emit_segment_line(dmt, major, minor, seg, seg_start,
1528 params, paramsize);
1529 dm_free(params);
1530
1531 if (!ret)
1532 stack;
1533
1534 if (ret >= 0)
1535 return ret;
1536
1537 log_debug("Insufficient space in params[%" PRIsize_t
1538 "] for target parameters.", paramsize);
1539
1540 paramsize *= 2;
1541 } while (paramsize < MAX_TARGET_PARAMSIZE);
1542
1543 log_error("Target parameter size too big. Aborting.");
1544 return 0;
1545 }
1546
1547 static int _load_node(struct dm_tree_node *dnode)
1548 {
1549 int r = 0;
1550 struct dm_task *dmt;
1551 struct load_segment *seg;
1552 uint64_t seg_start = 0;
1553
1554 log_verbose("Loading %s table (%" PRIu32 ":%" PRIu32 ")", dnode->name,
1555 dnode->info.major, dnode->info.minor);
1556
1557 if (!(dmt = dm_task_create(DM_DEVICE_RELOAD))) {
1558 log_error("Reload dm_task creation failed for %s", dnode->name);
1559 return 0;
1560 }
1561
1562 if (!dm_task_set_major(dmt, dnode->info.major) ||
1563 !dm_task_set_minor(dmt, dnode->info.minor)) {
1564 log_error("Failed to set device number for %s reload.", dnode->name);
1565 goto out;
1566 }
1567
1568 if (dnode->props.read_only && !dm_task_set_ro(dmt)) {
1569 log_error("Failed to set read only flag for %s", dnode->name);
1570 goto out;
1571 }
1572
1573 if (!dm_task_no_open_count(dmt))
1574 log_error("Failed to disable open_count");
1575
1576 dm_list_iterate_items(seg, &dnode->props.segs)
1577 if (!_emit_segment(dmt, dnode->info.major, dnode->info.minor,
1578 seg, &seg_start))
1579 goto_out;
1580
1581 if (!dm_task_suppress_identical_reload(dmt))
1582 log_error("Failed to suppress reload of identical tables.");
1583
1584 if ((r = dm_task_run(dmt))) {
1585 r = dm_task_get_info(dmt, &dnode->info);
1586 if (r && !dnode->info.inactive_table)
1587 log_verbose("Suppressed %s identical table reload.",
1588 dnode->name);
1589
1590 if ((dnode->props.size_changed =
1591 (dm_task_get_existing_table_size(dmt) == seg_start) ? 0 : 1))
1592 log_debug("Table size changed from %" PRIu64 " to %"
1593 PRIu64 " for %s",
1594 dm_task_get_existing_table_size(dmt),
1595 seg_start, dnode->name);
1596 }
1597
1598 dnode->props.segment_count = 0;
1599
1600 out:
1601 dm_task_destroy(dmt);
1602
1603 return r;
1604 }
1605
1606 int dm_tree_preload_children(struct dm_tree_node *dnode,
1607 const char *uuid_prefix,
1608 size_t uuid_prefix_len)
1609 {
1610 void *handle = NULL;
1611 struct dm_tree_node *child;
1612 struct dm_info newinfo;
1613
1614 /* Preload children first */
1615 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1616 /* Skip existing non-device-mapper devices */
1617 if (!child->info.exists && child->info.major)
1618 continue;
1619
1620 /* Ignore if it doesn't belong to this VG */
1621 if (child->info.exists &&
1622 !_uuid_prefix_matches(child->uuid, uuid_prefix, uuid_prefix_len))
1623 continue;
1624
1625 if (dm_tree_node_num_children(child, 0))
1626 dm_tree_preload_children(child, uuid_prefix, uuid_prefix_len);
1627
1628 /* FIXME Cope if name exists with no uuid? */
1629 if (!child->info.exists) {
1630 if (!_create_node(child)) {
1631 stack;
1632 return 0;
1633 }
1634 }
1635
1636 if (!child->info.inactive_table && child->props.segment_count) {
1637 if (!_load_node(child)) {
1638 stack;
1639 return 0;
1640 }
1641 }
1642
1643 /* Propagate device size change change */
1644 if (child->props.size_changed)
1645 dnode->props.size_changed = 1;
1646
1647 /* Resume device immediately if it has parents and its size changed */
1648 if (!dm_tree_node_num_children(child, 1) || !child->props.size_changed)
1649 continue;
1650
1651 if (!child->info.inactive_table && !child->info.suspended)
1652 continue;
1653
1654 if (!_resume_node(child->name, child->info.major, child->info.minor,
1655 child->props.read_ahead, child->props.read_ahead_flags,
1656 &newinfo, &child->dtree->cookie, child->udev_flags)) {
1657 log_error("Unable to resume %s (%" PRIu32
1658 ":%" PRIu32 ")", child->name, child->info.major,
1659 child->info.minor);
1660 continue;
1661 }
1662
1663 /* Update cached info */
1664 child->info = newinfo;
1665 }
1666
1667 handle = NULL;
1668
1669 return 1;
1670 }
1671
1672 /*
1673 * Returns 1 if unsure.
1674 */
1675 int dm_tree_children_use_uuid(struct dm_tree_node *dnode,
1676 const char *uuid_prefix,
1677 size_t uuid_prefix_len)
1678 {
1679 void *handle = NULL;
1680 struct dm_tree_node *child = dnode;
1681 const char *uuid;
1682
1683 while ((child = dm_tree_next_child(&handle, dnode, 0))) {
1684 if (!(uuid = dm_tree_node_get_uuid(child))) {
1685 log_error("Failed to get uuid for dtree node.");
1686 return 1;
1687 }
1688
1689 if (_uuid_prefix_matches(uuid, uuid_prefix, uuid_prefix_len))
1690 return 1;
1691
1692 if (dm_tree_node_num_children(child, 0))
1693 dm_tree_children_use_uuid(child, uuid_prefix, uuid_prefix_len);
1694 }
1695
1696 return 0;
1697 }
1698
1699 /*
1700 * Target functions
1701 */
1702 static struct load_segment *_add_segment(struct dm_tree_node *dnode, unsigned type, uint64_t size)
1703 {
1704 struct load_segment *seg;
1705
1706 if (!(seg = dm_pool_zalloc(dnode->dtree->mem, sizeof(*seg)))) {
1707 log_error("dtree node segment allocation failed");
1708 return NULL;
1709 }
1710
1711 seg->type = type;
1712 seg->size = size;
1713 seg->area_count = 0;
1714 dm_list_init(&seg->areas);
1715 seg->stripe_size = 0;
1716 seg->persistent = 0;
1717 seg->chunk_size = 0;
1718 seg->cow = NULL;
1719 seg->origin = NULL;
1720
1721 dm_list_add(&dnode->props.segs, &seg->list);
1722 dnode->props.segment_count++;
1723
1724 return seg;
1725 }
1726
1727 int dm_tree_node_add_snapshot_origin_target(struct dm_tree_node *dnode,
1728 uint64_t size,
1729 const char *origin_uuid)
1730 {
1731 struct load_segment *seg;
1732 struct dm_tree_node *origin_node;
1733
1734 if (!(seg = _add_segment(dnode, SEG_SNAPSHOT_ORIGIN, size)))
1735 return_0;
1736
1737 if (!(origin_node = dm_tree_find_node_by_uuid(dnode->dtree, origin_uuid))) {
1738 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid);
1739 return 0;
1740 }
1741
1742 seg->origin = origin_node;
1743 if (!_link_tree_nodes(dnode, origin_node))
1744 return_0;
1745
1746 /* Resume snapshot origins after new snapshots */
1747 dnode->activation_priority = 1;
1748
1749 return 1;
1750 }
1751
1752 int dm_tree_node_add_snapshot_target(struct dm_tree_node *node,
1753 uint64_t size,
1754 const char *origin_uuid,
1755 const char *cow_uuid,
1756 int persistent,
1757 uint32_t chunk_size)
1758 {
1759 struct load_segment *seg;
1760 struct dm_tree_node *origin_node, *cow_node;
1761
1762 if (!(seg = _add_segment(node, SEG_SNAPSHOT, size)))
1763 return_0;
1764
1765 if (!(origin_node = dm_tree_find_node_by_uuid(node->dtree, origin_uuid))) {
1766 log_error("Couldn't find snapshot origin uuid %s.", origin_uuid);
1767 return 0;
1768 }
1769
1770 seg->origin = origin_node;
1771 if (!_link_tree_nodes(node, origin_node))
1772 return_0;
1773
1774 if (!(cow_node = dm_tree_find_node_by_uuid(node->dtree, cow_uuid))) {
1775 log_error("Couldn't find snapshot origin uuid %s.", cow_uuid);
1776 return 0;
1777 }
1778
1779 seg->cow = cow_node;
1780 if (!_link_tree_nodes(node, cow_node))
1781 return_0;
1782
1783 seg->persistent = persistent ? 1 : 0;
1784 seg->chunk_size = chunk_size;
1785
1786 return 1;
1787 }
1788
1789 int dm_tree_node_add_error_target(struct dm_tree_node *node,
1790 uint64_t size)
1791 {
1792 if (!_add_segment(node, SEG_ERROR, size))
1793 return_0;
1794
1795 return 1;
1796 }
1797
1798 int dm_tree_node_add_zero_target(struct dm_tree_node *node,
1799 uint64_t size)
1800 {
1801 if (!_add_segment(node, SEG_ZERO, size))
1802 return_0;
1803
1804 return 1;
1805 }
1806
1807 int dm_tree_node_add_linear_target(struct dm_tree_node *node,
1808 uint64_t size)
1809 {
1810 if (!_add_segment(node, SEG_LINEAR, size))
1811 return_0;
1812
1813 return 1;
1814 }
1815
1816 int dm_tree_node_add_striped_target(struct dm_tree_node *node,
1817 uint64_t size,
1818 uint32_t stripe_size)
1819 {
1820 struct load_segment *seg;
1821
1822 if (!(seg = _add_segment(node, SEG_STRIPED, size)))
1823 return_0;
1824
1825 seg->stripe_size = stripe_size;
1826
1827 return 1;
1828 }
1829
1830 int dm_tree_node_add_crypt_target(struct dm_tree_node *node,
1831 uint64_t size,
1832 const char *cipher,
1833 const char *chainmode,
1834 const char *iv,
1835 uint64_t iv_offset,
1836 const char *key)
1837 {
1838 struct load_segment *seg;
1839
1840 if (!(seg = _add_segment(node, SEG_CRYPT, size)))
1841 return_0;
1842
1843 seg->cipher = cipher;
1844 seg->chainmode = chainmode;
1845 seg->iv = iv;
1846 seg->iv_offset = iv_offset;
1847 seg->key = key;
1848
1849 return 1;
1850 }
1851
1852 int dm_tree_node_add_mirror_target_log(struct dm_tree_node *node,
1853 uint32_t region_size,
1854 unsigned clustered,
1855 const char *log_uuid,
1856 unsigned area_count,
1857 uint32_t flags)
1858 {
1859 struct dm_tree_node *log_node = NULL;
1860 struct load_segment *seg;
1861
1862 if (!node->props.segment_count) {
1863 log_error("Internal error: Attempt to add target area to missing segment.");
1864 return 0;
1865 }
1866
1867 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
1868
1869 if (log_uuid) {
1870 if (!(seg->uuid = dm_pool_strdup(node->dtree->mem, log_uuid))) {
1871 log_error("log uuid pool_strdup failed");
1872 return 0;
1873 }
1874 if (!(flags & DM_CORELOG)) {
1875 if (!(log_node = dm_tree_find_node_by_uuid(node->dtree, log_uuid))) {
1876 log_error("Couldn't find mirror log uuid %s.", log_uuid);
1877 return 0;
1878 }
1879
1880 if (!_link_tree_nodes(node, log_node))
1881 return_0;
1882 }
1883 }
1884
1885 seg->log = log_node;
1886 seg->region_size = region_size;
1887 seg->clustered = clustered;
1888 seg->mirror_area_count = area_count;
1889 seg->flags = flags;
1890
1891 return 1;
1892 }
1893
1894 int dm_tree_node_add_mirror_target(struct dm_tree_node *node,
1895 uint64_t size)
1896 {
1897 struct load_segment *seg;
1898
1899 if (!(seg = _add_segment(node, SEG_MIRRORED, size)))
1900 return_0;
1901
1902 return 1;
1903 }
1904
1905 static int _add_area(struct dm_tree_node *node, struct load_segment *seg, struct dm_tree_node *dev_node, uint64_t offset)
1906 {
1907 struct seg_area *area;
1908
1909 if (!(area = dm_pool_zalloc(node->dtree->mem, sizeof (*area)))) {
1910 log_error("Failed to allocate target segment area.");
1911 return 0;
1912 }
1913
1914 area->dev_node = dev_node;
1915 area->offset = offset;
1916
1917 dm_list_add(&seg->areas, &area->list);
1918 seg->area_count++;
1919
1920 return 1;
1921 }
1922
1923 int dm_tree_node_add_target_area(struct dm_tree_node *node,
1924 const char *dev_name,
1925 const char *uuid,
1926 uint64_t offset)
1927 {
1928 struct load_segment *seg;
1929 struct stat info;
1930 struct dm_tree_node *dev_node;
1931
1932 if ((!dev_name || !*dev_name) && (!uuid || !*uuid)) {
1933 log_error("dm_tree_node_add_target_area called without device");
1934 return 0;
1935 }
1936
1937 if (uuid) {
1938 if (!(dev_node = dm_tree_find_node_by_uuid(node->dtree, uuid))) {
1939 log_error("Couldn't find area uuid %s.", uuid);
1940 return 0;
1941 }
1942 if (!_link_tree_nodes(node, dev_node))
1943 return_0;
1944 } else {
1945 if (stat(dev_name, &info) < 0) {
1946 log_error("Device %s not found.", dev_name);
1947 return 0;
1948 }
1949 #ifndef __NetBSD__
1950 if (!S_ISBLK(info.st_mode)) {
1951 log_error("Device %s is not a block device.", dev_name);
1952 return 0;
1953 }
1954 #else
1955 if (S_ISBLK(info.st_mode)) {
1956 log_error("Device %s is a block device. Use raw devices on NetBSD.", dev_name);
1957 return 0;
1958 }
1959 #endif
1960 /* FIXME Check correct macro use */
1961 if (!(dev_node = _add_dev(node->dtree, node, MAJOR(info.st_rdev), MINOR(info.st_rdev))))
1962 return_0;
1963 }
1964
1965 if (!node->props.segment_count) {
1966 log_error("Internal error: Attempt to add target area to missing segment.");
1967 return 0;
1968 }
1969
1970 seg = dm_list_item(dm_list_last(&node->props.segs), struct load_segment);
1971
1972 if (!_add_area(node, seg, dev_node, offset))
1973 return_0;
1974
1975 return 1;
1976 }
1977
1978 void dm_tree_set_cookie(struct dm_tree_node *node, uint32_t cookie)
1979 {
1980 node->dtree->cookie = cookie;
1981 }
1982
1983 uint32_t dm_tree_get_cookie(struct dm_tree_node *node)
1984 {
1985 return node->dtree->cookie;
1986 }
NetBSD on the FriendlyARM MINI2440