shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-21 13:34:40 +03:00
Code Releases Activity

replicator: remove the code

Browse Source 
It has not been used in a long time and is not
expected to be used further.
This commit is contained in:
David Teigland 2017-10-13 14:43:15 -05:00
parent e14c0cabd9
commit 6ac1e04b3a
22 changed files with 7 additions and 1859 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
WHATS_NEW
View File

@ -1,5 +1,6 @@
Version 2.02.176 - Version 2.02.176 -
=================================== ===================================
Remove the replicator code, including configure --with-replicators.
Allow lvcreate --type mirror to work with 100%FREE. Allow lvcreate --type mirror to work with 100%FREE.
Improve selection of resource name for complex volume activation lock. Improve selection of resource name for complex volume activation lock.
Avoid cutting first character of resource name for activation lock. Avoid cutting first character of resource name for activation lock.

17
configure.in
View File

@ -408,22 +408,6 @@ AC_DEFINE_UNQUOTED([DEFAULT_RAID10_SEGTYPE], ["$DEFAULT_RAID10_SEGTYPE"],
[Default segtype used for raid10 volumes.]) [Default segtype used for raid10 volumes.])
################################################################################ ################################################################################
dnl -- asynchronous volume replicator inclusion type
AC_MSG_CHECKING(whether to include replicators)
AC_ARG_WITH(replicators,
AC_HELP_STRING([--with-replicators=TYPE],
[replicator support: internal/shared/none [none]]),
REPLICATORS=$withval, REPLICATORS=none)
AC_MSG_RESULT($REPLICATORS)
case "$REPLICATORS" in
none|shared) ;;
internal) AC_DEFINE([REPLICATOR_INTERNAL], 1,
[Define to 1 to include built-in support for replicators.]) ;;
*) AC_MSG_ERROR([--with-replicators parameter invalid ($REPLICATORS)]) ;;
esac
AC_ARG_WITH(default-sparse-segtype, AC_ARG_WITH(default-sparse-segtype,
AC_HELP_STRING([--with-default-sparse-segtype=TYPE], AC_HELP_STRING([--with-default-sparse-segtype=TYPE],
[default sparse segtype: thin/snapshot [thin]]), [default sparse segtype: thin/snapshot [thin]]),
@ -2211,7 +2195,6 @@ lib/format1/Makefile
lib/format_pool/Makefile lib/format_pool/Makefile
lib/locking/Makefile lib/locking/Makefile
lib/mirror/Makefile lib/mirror/Makefile
lib/replicator/Makefile
include/lvm-version.h include/lvm-version.h
lib/raid/Makefile lib/raid/Makefile
lib/snapshot/Makefile lib/snapshot/Makefile

3
include/configure.h.in
View File

@ -685,9 +685,6 @@
/* Define to 1 to include the LVM readline shell. */ /* Define to 1 to include the LVM readline shell. */
#undef READLINE_SUPPORT #undef READLINE_SUPPORT
/* Define to 1 to include built-in support for replicators. */
#undef REPLICATOR_INTERNAL
/* Define as the return type of signal handlers (`int' or `void'). */ /* Define as the return type of signal handlers (`int' or `void'). */
#undef RETSIGTYPE #undef RETSIGTYPE

10
lib/Makefile.in
View File

@ -36,10 +36,6 @@ ifeq ("@RAID@", "shared")
SUBDIRS += raid SUBDIRS += raid
endif endif
ifeq ("@REPLICATORS@", "shared")
SUBDIRS += replicator
endif
ifeq ("@THIN@", "shared") ifeq ("@THIN@", "shared")
SUBDIRS += thin SUBDIRS += thin
endif endif
@ -106,7 +102,6 @@ SOURCES =\
metadata/pv_manip.c \ metadata/pv_manip.c \
metadata/pv_map.c \ metadata/pv_map.c \
metadata/raid_manip.c \ metadata/raid_manip.c \
metadata/replicator_manip.c \
metadata/segtype.c \ metadata/segtype.c \
metadata/snapshot_manip.c \ metadata/snapshot_manip.c \
metadata/thin_manip.c \ metadata/thin_manip.c \
@ -165,10 +160,6 @@ ifeq ("@RAID@", "internal")
SOURCES += raid/raid.c SOURCES += raid/raid.c
endif endif
ifeq ("@REPLICATORS@", "internal")
SOURCES += replicator/replicator.c
endif
ifeq ("@THIN@", "internal") ifeq ("@THIN@", "internal")
SOURCES += thin/thin.c SOURCES += thin/thin.c
endif endif
@ -215,7 +206,6 @@ ifeq ($(MAKECMDGOALS),distclean)
mirror \ mirror \
notify \ notify \
raid \ raid \
replicator \
thin \ thin \
cache_segtype \ cache_segtype \
locking locking

21
lib/activate/activate.c
View File

@ -2125,9 +2125,6 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
goto out; goto out;
} }
if (!lv_read_replicator_vgs(lv))
goto_out;
lv_calculate_readahead(lv, NULL); lv_calculate_readahead(lv, NULL);
/* /*
@ -2249,10 +2246,8 @@ static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
out: out:
if (lv_pre_to_free) if (lv_pre_to_free)
release_vg(lv_pre_to_free->vg); release_vg(lv_pre_to_free->vg);
if (lv_to_free) { if (lv_to_free)
lv_release_replicator_vgs(lv_to_free);
release_vg(lv_to_free->vg); release_vg(lv_to_free->vg);
}
return r; return r;
} }
@ -2436,9 +2431,6 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logi
goto_out; goto_out;
} }
if (!lv_read_replicator_vgs(lv))
goto_out;
if (!monitor_dev_for_events(cmd, lv, &laopts, 0)) if (!monitor_dev_for_events(cmd, lv, &laopts, 0))
stack; stack;
@ -2453,10 +2445,8 @@ int lv_deactivate(struct cmd_context *cmd, const char *lvid_s, const struct logi
r = 0; r = 0;
} }
out: out:
if (lv_to_free) { if (lv_to_free)
lv_release_replicator_vgs(lv_to_free);
release_vg(lv_to_free->vg); release_vg(lv_to_free->vg);
}
return r; return r;
} }
@ -2571,9 +2561,6 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
goto out; goto out;
} }
if (!lv_read_replicator_vgs(lv))
goto_out;
lv_calculate_readahead(lv, NULL); lv_calculate_readahead(lv, NULL);
critical_section_inc(cmd, "activating"); critical_section_inc(cmd, "activating");
@ -2585,10 +2572,8 @@ static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
stack; stack;
out: out:
if (lv_to_free) { if (lv_to_free)
lv_release_replicator_vgs(lv_to_free);
release_vg(lv_to_free->vg); release_vg(lv_to_free->vg);
}
return r; return r;
} }

146
lib/activate/dev_manager.c
View File

@ -1774,84 +1774,6 @@ static int _add_dev_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
return 1; return 1;
} }
/*
* Add replicator devices
*
* Using _add_dev_to_dtree() directly instead of _add_lv_to_dtree()
* to avoid extra checks with extensions.
*/
static int _add_partial_replicator_to_dtree(struct dev_manager *dm,
struct dm_tree *dtree,
const struct logical_volume *lv)
{
struct logical_volume *rlv = first_seg(lv)->replicator;
struct replicator_device *rdev;
struct replicator_site *rsite;
struct dm_tree_node *rep_node, *rdev_node;
const char *uuid;
if (!lv_is_active_replicator_dev(lv)) {
if (!_add_dev_to_dtree(dm, dtree, lv->rdevice->lv,
NULL))
return_0;
return 1;
}
/* Add _rlog and replicator device */
if (!_add_dev_to_dtree(dm, dtree, first_seg(rlv)->rlog_lv, NULL))
return_0;
if (!_add_dev_to_dtree(dm, dtree, rlv, NULL))
return_0;
if (!(uuid = build_dm_uuid(dm->mem, rlv, NULL)))
return_0;
rep_node = dm_tree_find_node_by_uuid(dtree, uuid);
/* Add all related devices for replicator */
dm_list_iterate_items(rsite, &rlv->rsites)
dm_list_iterate_items(rdev, &rsite->rdevices) {
if (rsite->state == REPLICATOR_STATE_ACTIVE) {
/* Add _rimage LV */
if (!_add_dev_to_dtree(dm, dtree, rdev->lv, NULL))
return_0;
/* Add replicator-dev LV, except of the already added one */
if ((lv != rdev->replicator_dev->lv) &&
!_add_dev_to_dtree(dm, dtree,
rdev->replicator_dev->lv, NULL))
return_0;
/* If replicator exists - try connect existing heads */
if (rep_node) {
uuid = build_dm_uuid(dm->mem,
rdev->replicator_dev->lv,
NULL);
if (!uuid)
return_0;
rdev_node = dm_tree_find_node_by_uuid(dtree, uuid);
if (rdev_node)
dm_tree_node_set_presuspend_node(rdev_node,
rep_node);
}
}
if (!rdev->rsite->vg_name)
continue;
if (!_add_dev_to_dtree(dm, dtree, rdev->lv, NULL))
return_0;
if (rdev->slog &&
!_add_dev_to_dtree(dm, dtree, rdev->slog, NULL))
return_0;
}
return 1;
}
struct pool_cb_data { struct pool_cb_data {
struct dev_manager *dm; struct dev_manager *dm;
const struct logical_volume *pool_lv; const struct logical_volume *pool_lv;
@ -2156,11 +2078,6 @@ static int _add_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
} }
} }
/* Adding LV head of replicator adds all other related devs */
if (lv_is_replicator_dev(lv) &&
!_add_partial_replicator_to_dtree(dm, dtree, lv))
return_0;
/* Add any LVs used by segments in this LV */ /* Add any LVs used by segments in this LV */
dm_list_iterate_items(seg, &lv->segments) { dm_list_iterate_items(seg, &lv->segments) {
if (seg->external_lv && dm->track_external_lv_deps && if (seg->external_lv && dm->track_external_lv_deps &&
@ -2524,64 +2441,6 @@ static int _add_new_lv_to_dtree(struct dev_manager *dm, struct dm_tree *dtree,
struct lv_activate_opts *laopts, struct lv_activate_opts *laopts,
const char *layer); const char *layer);
/* Add all replicators' LVs */
static int _add_replicator_dev_target_to_dtree(struct dev_manager *dm,
struct dm_tree *dtree,
struct lv_segment *seg,
struct lv_activate_opts *laopts)
{
struct replicator_device *rdev;
struct replicator_site *rsite;
/* For inactive replicator add linear mapping */
if (!lv_is_active_replicator_dev(seg->lv)) {
if (!_add_new_lv_to_dtree(dm, dtree, seg->lv->rdevice->lv, laopts, NULL))
return_0;
return 1;
}
/* Add rlog and replicator nodes */
if (!seg->replicator ||
!first_seg(seg->replicator)->rlog_lv ||
!_add_new_lv_to_dtree(dm, dtree,
first_seg(seg->replicator)->rlog_lv,
laopts, NULL) ||
!_add_new_lv_to_dtree(dm, dtree, seg->replicator, laopts, NULL))
return_0;
/* Activation of one replicator_dev node activates all other nodes */
dm_list_iterate_items(rsite, &seg->replicator->rsites) {
dm_list_iterate_items(rdev, &rsite->rdevices) {
if (rdev->lv &&
!_add_new_lv_to_dtree(dm, dtree, rdev->lv,
laopts, NULL))
return_0;
if (rdev->slog &&
!_add_new_lv_to_dtree(dm, dtree, rdev->slog,
laopts, NULL))
return_0;
}
}
/* Add remaining replicator-dev nodes in the second loop
* to avoid multiple retries for inserting all elements */
dm_list_iterate_items(rsite, &seg->replicator->rsites) {
if (rsite->state != REPLICATOR_STATE_ACTIVE)
continue;
dm_list_iterate_items(rdev, &rsite->rdevices) {
if (rdev->replicator_dev->lv == seg->lv)
continue;
if (!rdev->replicator_dev->lv ||
!_add_new_lv_to_dtree(dm, dtree,
rdev->replicator_dev->lv,
laopts, NULL))
return_0;
}
}
return 1;
}
static int _add_new_external_lv_to_dtree(struct dev_manager *dm, static int _add_new_external_lv_to_dtree(struct dev_manager *dm,
struct dm_tree *dtree, struct dm_tree *dtree,
struct logical_volume *external_lv, struct logical_volume *external_lv,
@ -2682,11 +2541,6 @@ static int _add_segment_to_dtree(struct dev_manager *dm,
lv_layer(seg->pool_lv))) lv_layer(seg->pool_lv)))
return_0; return_0;
if (seg_is_replicator_dev(seg)) {
if (!_add_replicator_dev_target_to_dtree(dm, dtree, seg, laopts))
return_0;
}
/* Add any LVs used by this segment */ /* Add any LVs used by this segment */
for (s = 0; s < seg->area_count; ++s) { for (s = 0; s < seg->area_count; ++s) {
if ((seg_type(seg, s) == AREA_LV) && if ((seg_type(seg, s) == AREA_LV) &&

5
lib/commands/toolcontext.c
View File

@ -1501,11 +1501,6 @@ static int _init_segtypes(struct cmd_context *cmd)
dm_list_add(&cmd->segtypes, &segtype->list); dm_list_add(&cmd->segtypes, &segtype->list);
} }
#ifdef REPLICATOR_INTERNAL
if (!init_replicator_segtype(cmd, &seglib))
return 0;
#endif
#ifdef RAID_INTERNAL #ifdef RAID_INTERNAL
if (!init_raid_segtypes(cmd, &seglib)) if (!init_raid_segtypes(cmd, &seglib))
return 0; return 0;

2
lib/format_text/flags.c
View File

@ -90,8 +90,6 @@ static const struct flag _lv_flags[] = {
{PARTIAL_LV, NULL, 0}, {PARTIAL_LV, NULL, 0},
{POSTORDER_FLAG, NULL, 0}, {POSTORDER_FLAG, NULL, 0},
{VIRTUAL_ORIGIN, NULL, 0}, {VIRTUAL_ORIGIN, NULL, 0},
{REPLICATOR, NULL, 0},
{REPLICATOR_LOG, NULL, 0},
{THIN_VOLUME, NULL, 0}, {THIN_VOLUME, NULL, 0},
{THIN_POOL, NULL, 0}, {THIN_POOL, NULL, 0},
{THIN_POOL_DATA, NULL, 0}, {THIN_POOL_DATA, NULL, 0},

5
lib/locking/locking.h
View File

@ -166,10 +166,7 @@ int check_lvm1_vg_inactive(struct cmd_context *cmd, const char *vgname);
#define LCK_LV_CLUSTERED(lv) \ #define LCK_LV_CLUSTERED(lv) \
(vg_is_clustered((lv)->vg) ? LCK_CLUSTER_VG : 0) (vg_is_clustered((lv)->vg) ? LCK_CLUSTER_VG : 0)
#define lock_lv_vol(cmd, lv, flags) \ #define lock_lv_vol(cmd, lv, flags) lock_vol(cmd, (lv)->lvid.s, flags | LCK_LV_CLUSTERED(lv), lv)
(find_replicator_vgs((lv)) ? \
lock_vol(cmd, (lv)->lvid.s, flags | LCK_LV_CLUSTERED(lv), lv) : \
0)
/* /*
* Activation locks are wrapped around activation commands that have to * Activation locks are wrapped around activation commands that have to

4
lib/metadata/lv.h
View File

@ -19,7 +19,6 @@
union lvid; union lvid;
struct lv_segment; struct lv_segment;
struct replicator_device;
enum activation_change; enum activation_change;
struct logical_volume { struct logical_volume {
@ -43,9 +42,6 @@ struct logical_volume {
struct dm_list snapshot_segs; struct dm_list snapshot_segs;
struct lv_segment *snapshot; struct lv_segment *snapshot;
struct replicator_device *rdevice;/* For replicator-devs, rimages, slogs - reference to rdevice */
struct dm_list rsites; /* For replicators - all sites */
struct dm_list segments; struct dm_list segments;
struct dm_list tags; struct dm_list tags;
struct dm_list segs_using_this_lv; struct dm_list segs_using_this_lv;

1
lib/metadata/lv_manip.c
View File

@ -5748,7 +5748,6 @@ struct logical_volume *alloc_lv(struct dm_pool *mem)
dm_list_init(&lv->tags); dm_list_init(&lv->tags);
dm_list_init(&lv->segs_using_this_lv); dm_list_init(&lv->segs_using_this_lv);
dm_list_init(&lv->indirect_glvs); dm_list_init(&lv->indirect_glvs);
dm_list_init(&lv->rsites);
return lv; return lv;
} }

28
lib/metadata/merge.c
View File

@ -219,17 +219,6 @@ static void _check_non_raid_seg_members(struct lv_segment *seg, int *error_count
raid_seg_error("non-zero cow LV"); raid_seg_error("non-zero cow LV");
if (!dm_list_empty(&seg->origin_list)) /* snap */ if (!dm_list_empty(&seg->origin_list)) /* snap */
raid_seg_error("non-zero origin_list"); raid_seg_error("non-zero origin_list");
/* replicator members (deprecated) */
if (seg->replicator)
raid_seg_error("non-zero replicator");
if (seg->rlog_lv)
raid_seg_error("non-zero rlog LV");
if (seg->rlog_type)
raid_seg_error("non-zero rlog type");
if (seg->rdevice_index_highest)
raid_seg_error("non-zero rdevice_index_highests");
if (seg->rsite_index_highest)
raid_seg_error("non-zero rsite_index_highests");
/* .... more members? */ /* .... more members? */
} }
@ -513,8 +502,6 @@ int check_lv_segments(struct logical_volume *lv, int complete_vg)
struct seg_list *sl; struct seg_list *sl;
struct glv_list *glvl; struct glv_list *glvl;
int error_count = 0; int error_count = 0;
struct replicator_site *rsite;
struct replicator_device *rdev;
dm_list_iterate_items(seg, &lv->segments) { dm_list_iterate_items(seg, &lv->segments) {
seg_count++; seg_count++;
@ -551,9 +538,6 @@ int check_lv_segments(struct logical_volume *lv, int complete_vg)
} }
} }
if (seg_is_replicator(seg) && !check_replicator_segment(seg))
inc_error_count;
if (complete_vg) if (complete_vg)
_check_lv_segment(lv, seg, seg_count, &error_count); _check_lv_segment(lv, seg, seg_count, &error_count);
@ -655,18 +639,6 @@ int check_lv_segments(struct logical_volume *lv, int complete_vg)
if (seg->meta_areas && seg_is_raid_with_meta(seg) && (lv == seg_metalv(seg, s))) if (seg->meta_areas && seg_is_raid_with_meta(seg) && (lv == seg_metalv(seg, s)))
seg_found++; seg_found++;
} }
if (seg_is_replicator_dev(seg)) {
dm_list_iterate_items(rsite, &seg->replicator->rsites) {
dm_list_iterate_items(rdev, &rsite->rdevices) {
if (lv == rdev->lv || lv == rdev->slog)
seg_found++;
}
}
if (lv == seg->replicator)
seg_found++;
}
if (seg_is_replicator(seg) && lv == seg->rlog_lv)
seg_found++;
if (seg->log_lv == lv) if (seg->log_lv == lv)
seg_found++; seg_found++;
if (seg->metadata_lv == lv || seg->pool_lv == lv) if (seg->metadata_lv == lv || seg->pool_lv == lv)

90
lib/metadata/metadata-exported.h
View File

@ -94,8 +94,6 @@
#define MERGING UINT64_C(0x0000000010000000) /* LV SEG */ #define MERGING UINT64_C(0x0000000010000000) /* LV SEG */
#define REPLICATOR UINT64_C(0x0000000020000000) /* LV -internal use only for replicator */
#define REPLICATOR_LOG UINT64_C(0x0000000040000000) /* LV -internal use only for replicator-dev */
#define UNLABELLED_PV UINT64_C(0x0000000080000000) /* PV -this PV had no label written yet */ #define UNLABELLED_PV UINT64_C(0x0000000080000000) /* PV -this PV had no label written yet */
#define RAID UINT64_C(0x0000000100000000) /* LV - Internal use only */ #define RAID UINT64_C(0x0000000100000000) /* LV - Internal use only */
@ -253,8 +251,6 @@
#define lv_is_pool_metadata_spare(lv) (((lv)->status & POOL_METADATA_SPARE) ? 1 : 0) #define lv_is_pool_metadata_spare(lv) (((lv)->status & POOL_METADATA_SPARE) ? 1 : 0)
#define lv_is_lockd_sanlock_lv(lv) (((lv)->status & LOCKD_SANLOCK_LV) ? 1 : 0) #define lv_is_lockd_sanlock_lv(lv) (((lv)->status & LOCKD_SANLOCK_LV) ? 1 : 0)
#define lv_is_rlog(lv) (((lv)->status & REPLICATOR_LOG) ? 1 : 0)
#define lv_is_removed(lv) (((lv)->status & LV_REMOVED) ? 1 : 0) #define lv_is_removed(lv) (((lv)->status & LV_REMOVED) ? 1 : 0)
int lv_layout_and_role(struct dm_pool *mem, const struct logical_volume *lv, int lv_layout_and_role(struct dm_pool *mem, const struct logical_volume *lv,
@ -416,53 +412,6 @@ struct lv_thin_message {
struct segment_type; struct segment_type;
/* List with vg_name, vgid and flags */
struct cmd_vg {
struct dm_list list;
const char *vg_name;
const char *vgid;
uint32_t flags;
struct volume_group *vg;
};
/* ++ Replicator datatypes */
typedef enum {
REPLICATOR_STATE_PASSIVE,
REPLICATOR_STATE_ACTIVE,
NUM_REPLICATOR_STATE
} replicator_state_t;
struct replicator_site {
struct dm_list list; /* Chained list of sites */
struct dm_list rdevices; /* Device list */
struct logical_volume *replicator; /* Reference to replicator */
const char *name; /* Site name */
const char *vg_name; /* VG name */
struct volume_group *vg; /* resolved vg (activate/deactive) */
unsigned site_index;
replicator_state_t state; /* Active or pasive state of site */
dm_replicator_mode_t op_mode; /* Operation mode sync or async fail|warn|drop|stall */
uint64_t fall_behind_data; /* Bytes */
uint32_t fall_behind_ios; /* IO operations */
uint32_t fall_behind_timeout; /* Seconds */
};
struct replicator_device {
struct dm_list list; /* Chained list of devices from same site */
struct lv_segment *replicator_dev; /* Reference to replicator-dev segment */
struct replicator_site *rsite; /* Reference to site parameters */
uint64_t device_index;
const char *name; /* Device LV name */
struct logical_volume *lv; /* LV from replicator site's VG */
struct logical_volume *slog; /* Synclog lv from VG */
const char *slog_name; /* Debug - specify size of core synclog */
};
/* -- Replicator datatypes */
struct lv_segment { struct lv_segment {
struct dm_list list; struct dm_list list;
struct logical_volume *lv; struct logical_volume *lv;
@ -514,12 +463,6 @@ struct lv_segment {
const char *policy_name; /* For cache_pool */ const char *policy_name; /* For cache_pool */
struct dm_config_node *policy_settings; /* For cache_pool */ struct dm_config_node *policy_settings; /* For cache_pool */
unsigned cleaner_policy; /* For cache */ unsigned cleaner_policy; /* For cache */
struct logical_volume *replicator;/* For replicator-devs - link to replicator LV */
struct logical_volume *rlog_lv; /* For replicators */
const char *rlog_type; /* For replicators */
uint64_t rdevice_index_highest; /* For replicators */
unsigned rsite_index_highest; /* For replicators */
}; };
#define seg_type(seg, s) (seg)->areas[(s)].type #define seg_type(seg, s) (seg)->areas[(s)].type
@ -1202,26 +1145,6 @@ int reconfigure_mirror_images(struct lv_segment *mirrored_seg, uint32_t num_mirr
int collapse_mirrored_lv(struct logical_volume *lv); int collapse_mirrored_lv(struct logical_volume *lv);
int shift_mirror_images(struct lv_segment *mirrored_seg, unsigned mimage); int shift_mirror_images(struct lv_segment *mirrored_seg, unsigned mimage);
/* ++ metadata/replicator_manip.c */
int replicator_add_replicator_dev(struct logical_volume *replicator_lv,
struct lv_segment *replicator_dev_seg);
struct logical_volume *replicator_remove_replicator_dev(struct lv_segment *rdev_seg);
int replicator_add_rlog(struct lv_segment *replicator_seg, struct logical_volume *rlog_lv);
struct logical_volume *replicator_remove_rlog(struct lv_segment *replicator_seg);
int replicator_dev_add_slog(struct replicator_device *rdev, struct logical_volume *slog);
struct logical_volume *replicator_dev_remove_slog(struct replicator_device *rdev);
int replicator_dev_add_rimage(struct replicator_device *rdev, struct logical_volume *lv);
struct logical_volume *replicator_dev_remove_rimage(struct replicator_device *rdev);
int lv_is_active_replicator_dev(const struct logical_volume *lv);
int lv_is_replicator(const struct logical_volume *lv);
int lv_is_replicator_dev(const struct logical_volume *lv);
int lv_is_rimage(const struct logical_volume *lv);
int lv_is_slog(const struct logical_volume *lv);
struct logical_volume *first_replicator_dev(const struct logical_volume *lv);
/* -- metadata/replicator_manip.c */
/* ++ metadata/raid_manip.c */ /* ++ metadata/raid_manip.c */
int lv_is_raid_with_tracking(const struct logical_volume *lv); int lv_is_raid_with_tracking(const struct logical_volume *lv);
uint32_t lv_raid_image_count(const struct logical_volume *lv); uint32_t lv_raid_image_count(const struct logical_volume *lv);
@ -1303,19 +1226,6 @@ int lv_cache_remove(struct logical_volume *cache_lv);
int wipe_cache_pool(struct logical_volume *cache_pool_lv); int wipe_cache_pool(struct logical_volume *cache_pool_lv);
/* -- metadata/cache_manip.c */ /* -- metadata/cache_manip.c */
struct cmd_vg *cmd_vg_add(struct dm_pool *mem, struct dm_list *cmd_vgs,
const char *vg_name, const char *vgid,
uint32_t flags);
struct cmd_vg *cmd_vg_lookup(struct dm_list *cmd_vgs,
const char *vg_name, const char *vgid);
int cmd_vg_read(struct cmd_context *cmd, struct dm_list *cmd_vgs);
void free_cmd_vgs(struct dm_list *cmd_vgs);
int find_replicator_vgs(const struct logical_volume *lv);
int lv_read_replicator_vgs(const struct logical_volume *lv);
void lv_release_replicator_vgs(const struct logical_volume *lv);
struct logical_volume *find_pvmove_lv(struct volume_group *vg, struct logical_volume *find_pvmove_lv(struct volume_group *vg,
struct device *dev, uint64_t lv_type); struct device *dev, uint64_t lv_type);
const struct logical_volume *find_pvmove_lv_in_lv(const struct logical_volume *lv); const struct logical_volume *find_pvmove_lv_in_lv(const struct logical_volume *lv);

4
lib/metadata/metadata.c
View File

@ -2404,8 +2404,6 @@ static int _lv_each_dependency(struct logical_volume *lv,
struct dm_list *snh; struct dm_list *snh;
struct logical_volume *deps[] = { struct logical_volume *deps[] = {
(lv->rdevice && lv != lv->rdevice->lv) ? lv->rdevice->lv : 0,
(lv->rdevice && lv != lv->rdevice->slog) ? lv->rdevice->slog : 0,
lv->snapshot ? lv->snapshot->origin : 0, lv->snapshot ? lv->snapshot->origin : 0,
lv->snapshot ? lv->snapshot->cow : 0 }; lv->snapshot ? lv->snapshot->cow : 0 };
for (i = 0; i < DM_ARRAY_SIZE(deps); ++i) { for (i = 0; i < DM_ARRAY_SIZE(deps); ++i) {
@ -2418,8 +2416,6 @@ static int _lv_each_dependency(struct logical_volume *lv,
return_0; return_0;
if (lvseg->log_lv && !fn(lvseg->log_lv, data)) if (lvseg->log_lv && !fn(lvseg->log_lv, data))
return_0; return_0;
if (lvseg->rlog_lv && !fn(lvseg->rlog_lv, data))
return_0;
if (lvseg->pool_lv && !fn(lvseg->pool_lv, data)) if (lvseg->pool_lv && !fn(lvseg->pool_lv, data))
return_0; return_0;
if (lvseg->metadata_lv && !fn(lvseg->metadata_lv, data)) if (lvseg->metadata_lv && !fn(lvseg->metadata_lv, data))

5
lib/metadata/metadata.h
View File

@ -420,11 +420,6 @@ int check_lv_segments(struct logical_volume *lv, int complete_vg);
*/ */
int lv_has_constant_stripes(struct logical_volume *lv); int lv_has_constant_stripes(struct logical_volume *lv);
/*
* Checks that a replicator segment is correct.
*/
int check_replicator_segment(const struct lv_segment *rseg);
/* /*
* Sometimes (eg, after an lvextend), it is possible to merge two * Sometimes (eg, after an lvextend), it is possible to merge two
* adjacent segments into a single segment. This function trys * adjacent segments into a single segment. This function trys

686
lib/metadata/replicator_manip.c
View File

@ -1,686 +0,0 @@
/*
* Copyright (C) 2009-2010 Red Hat, Inc. All rights reserved.
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "lib.h"
#include "locking.h"
#include "metadata.h"
#include "segtype.h"
#include "toolcontext.h"
#include "lvmetad.h"
/* Add lv as replicator_dev device */
int replicator_dev_add_rimage(struct replicator_device *rdev,
struct logical_volume *lv)
{
if (!lv || !rdev)
return_0;
if (lv_is_rimage(lv)) {
log_error("Logical volume %s is already part of other "
"replicator.", lv->name);
return 0;
}
if (rdev->lv) {
log_error("Logical volume %s can not be attached to an "
"already defined replicator device", lv->name);
return 0;
}
lv_set_hidden(lv);
lv->rdevice = rdev;
rdev->lv = lv;
return add_seg_to_segs_using_this_lv(lv, rdev->replicator_dev);
}
/* Remove lv from replicator_dev device */
struct logical_volume *replicator_dev_remove_rimage(struct replicator_device *rdev)
{
struct logical_volume *lv;
if (!rdev || !rdev->lv)
return_NULL;
lv = rdev->lv;
if (!remove_seg_from_segs_using_this_lv(lv, rdev->replicator_dev))
return_NULL;
/* FIXME: - check for site references */
rdev->lv = NULL;
lv->rdevice = NULL;
lv_set_visible(lv);
return lv;
}
int replicator_dev_add_slog(struct replicator_device *rdev,
struct logical_volume *slog)
{
if (!slog || !rdev)
return_0;
if (rdev->slog) {
log_error("Replicator device in site %s already has sync log.",
rdev->rsite->name);
return 0;
}
if (slog->rdevice) {
log_error("Sync log %s is already used by replicator %s.",
slog->name, slog->rdevice->rsite->replicator->name);
return 0;
}
lv_set_hidden(slog);
slog->rdevice = rdev;
rdev->slog = slog;
return add_seg_to_segs_using_this_lv(slog, rdev->replicator_dev);
}
struct logical_volume *replicator_dev_remove_slog(struct replicator_device *rdev)
{
struct logical_volume *lv;
if (!rdev)
return_NULL;
lv = rdev->slog;
if (!lv) {
log_error("Replicator device in site %s does not have sync log.",
rdev->rsite->name);
return NULL;
}
if (!remove_seg_from_segs_using_this_lv(lv, rdev->replicator_dev))
return_NULL;
rdev->slog = NULL;
lv->rdevice = NULL;
lv_set_visible(lv);
return lv;
}
int replicator_add_replicator_dev(struct logical_volume *replicator_lv,
struct lv_segment *replicator_dev_seg)
{
if (!replicator_lv)
return_0;
if (!(replicator_lv->status & REPLICATOR)) {
dm_list_init(&replicator_lv->rsites);
lv_set_hidden(replicator_lv);
replicator_lv->status |= REPLICATOR;
}
if (!replicator_dev_seg)
return 1;
if (replicator_dev_seg->replicator) {
log_error("Replicator device %s is already part of replicator.",
replicator_dev_seg->lv->name);
return 0;
}
replicator_dev_seg->replicator = replicator_lv;
return add_seg_to_segs_using_this_lv(replicator_lv, replicator_dev_seg);
}
/**
* Returns rimage ?? lv upon succeful detach of device
* entire LV entry should be removed by this crootall ??
*/
struct logical_volume *replicator_remove_replicator_dev(struct lv_segment *replicator_dev_seg)
{
struct logical_volume *lv = NULL;
log_error("FIXME: not implemented.");
#if 0
/* FIXME: - this is going to be complex.... */
if (!replicator_dev_seg)
return_NULL;
/* if slog or rimage - exit */
if (!remove_seg_from_segs_using_this_lv(lv, replicator_seg))
return_NULL;
replicator_seg->rlog_lv = NULL;
lv->status &= ~REPLICATOR_LOG;
lv_set_visible(lv);
#endif
return lv;
}
int replicator_add_rlog(struct lv_segment *replicator_seg,
struct logical_volume *rlog_lv)
{
if (!rlog_lv)
return_0;
if (rlog_lv->status & REPLICATOR_LOG) {
log_error("Rlog device %s is already used.", rlog_lv->name);
return 0;
}
lv_set_hidden(rlog_lv);
rlog_lv->status |= REPLICATOR_LOG;
replicator_seg->rlog_lv = rlog_lv;
return add_seg_to_segs_using_this_lv(rlog_lv, replicator_seg);
}
struct logical_volume *replicator_remove_rlog(struct lv_segment *replicator_seg)
{
struct logical_volume *lv;
if (!replicator_seg)
return_0;
if (!(lv = replicator_seg->rlog_lv)) {
log_error("Replog segment %s does not have rlog.",
replicator_seg->lv->name);
return NULL;
}
if (!remove_seg_from_segs_using_this_lv(lv, replicator_seg))
return_NULL;
replicator_seg->rlog_lv = NULL;
lv->status &= ~REPLICATOR_LOG;
lv_set_visible(lv);
return lv;
}
#if 0
/*
* Create new LV to pretend the original LV
* this target will have a 'replicator' segment
*/
int lv_add_replicator(struct logical_volume *origin, const char *rep_suffix)
{
struct logical_volume *rep_lv;
char *name;
size_t slen;
if (!(name = strstr(origin->name, rep_suffix))) {
log_error("Failed to find replicator suffix %s in LV name %s",
rep_suffix, origin->name);
return 0;
}
slen = (size_t)(name - origin->name);
name = alloca(slen + 1);
memcpy(name, origin->name, slen);
name[slen] = 0;
if ((rep_lv = find_lv(origin->vg, name))) {
rep_lv->status |= VIRTUAL;
return 1;
}
if (!(rep_lv = lv_create_empty(name, &origin->lvid,
LVM_READ | LVM_WRITE | VISIBLE_LV,
ALLOC_INHERIT, origin->vg)))
return_0;
if (!lv_add_virtual_segment(rep_lv, 0, origin->le_count,
get_segtype_from_string(origin->vg->cmd,
"error")))
return_0;
rep_lv->status |= VIRTUAL;
return 1;
}
int lv_remove_replicator(struct logical_volume *lv)
{
return 1;
}
#endif
/*
* Check all replicator structures:
* only non-clustered VG for Replicator
* only one segment in replicator LV
* site has correct combination of operation_mode parameters
* site and related devices have correct index numbers
* duplicate site names, site indexes, device names, device indexes
*/
int check_replicator_segment(const struct lv_segment *rseg)
{
struct replicator_site *rsite, *rsiteb;
struct replicator_device *rdev, *rdevb;
struct logical_volume *lv = rseg->lv;
int r = 1;
if (vg_is_clustered(lv->vg)) {
log_error("Volume Group %s of replicator %s is clustered",
lv->vg->name, lv->name);
return 0;
}
if (dm_list_size(&lv->segments) != 1) {
log_error("Replicator %s segment size %d != 1",
lv->name, dm_list_size(&lv->segments));
return 0;
}
dm_list_iterate_items(rsite, &lv->rsites) {
if (rsite->op_mode == DM_REPLICATOR_SYNC) {
if (rsite->fall_behind_timeout) {
log_error("Defined fall_behind_timeout="
"%d for sync replicator %s/%s.",
rsite->fall_behind_timeout, lv->name,
rsite->name);
r = 0;
}
if (rsite->fall_behind_ios) {
log_error("Defined fall_behind_ios="
"%d for sync replicator %s/%s.",
rsite->fall_behind_ios, lv->name, rsite->name);
r = 0;
}
if (rsite->fall_behind_data) {
log_error("Defined fall_behind_data="
FMTu64 " for sync replicator %s/%s.",
rsite->fall_behind_data, lv->name, rsite->name);
r = 0;
}
} else {
if (rsite->fall_behind_timeout && rsite->fall_behind_ios) {
log_error("Defined fall_behind_timeout and"
" fall_behind_ios for async replicator %s/%s.",
lv->name, rsite->name);
r = 0;
}
if (rsite->fall_behind_timeout && rsite->fall_behind_data) {
log_error("Defined fall_behind_timeout and"
" fall_behind_data for async replicator %s/%s.",
lv->name, rsite->name);
r = 0;
}
if (rsite->fall_behind_ios && rsite->fall_behind_data) {
log_error("Defined fall_behind_ios and"
" fall_behind_data for async replicator %s/%s.",
lv->name, rsite->name);
r = 0;
}
if (!rsite->fall_behind_ios &&
!rsite->fall_behind_data &&
!rsite->fall_behind_timeout) {
log_error("fall_behind_timeout,"
" fall_behind_ios and fall_behind_data are"
" undefined for async replicator %s/%s.",
lv->name, rsite->name);
r = 0;
}
}
dm_list_iterate_items(rsiteb, &lv->rsites) {
if (rsite == rsiteb)
break;
if (strcasecmp(rsite->name, rsiteb->name) == 0) {
log_error("Duplicate site name "
"%s detected for replicator %s.",
rsite->name, lv->name);
r = 0;
}
if ((rsite->vg_name && rsiteb->vg_name &&
strcasecmp(rsite->vg_name, rsiteb->vg_name) == 0) ||
(!rsite->vg_name && !rsiteb->vg_name)) {
log_error("Duplicate VG name "
"%s detected for replicator %s.",
(rsite->vg_name) ? rsite->vg_name : "<local>",
lv->name);
r = 0;
}
if (rsite->site_index == rsiteb->site_index) {
log_error("Duplicate site index %d detected "
"for replicator site %s/%s.",
rsite->site_index, lv->name,
rsite->name);
r = 0;
}
if (rsite->site_index > rseg->rsite_index_highest) {
log_error("Site index %d > %d (too high) "
"for replicator site %s/%s.",
rsite->site_index,
rseg->rsite_index_highest,
lv->name, rsite->name);
r = 0;
}
}
dm_list_iterate_items(rdev, &rsite->rdevices) {
dm_list_iterate_items(rdevb, &rsite->rdevices) {
if (rdev == rdevb)
break;
if (rdev->slog && (rdev->slog == rdevb->slog)) {
log_error("Duplicate sync log %s "
"detected for replicator %s.",
rdev->slog->name, lv->name);
r = 0;
}
if (strcasecmp(rdev->name, rdevb->name) == 0) {
log_error("Duplicate device name %s "
"detected for replicator %s.",
rdev->name, lv->name);
r = 0;
}
if (rdev->device_index == rdevb->device_index) {
log_error("Duplicate device index %"
PRId64 " detected for "
"replicator site %s/%s.",
rdev->device_index,
lv->name, rsite->name);
r = 0;
}
if (rdev->device_index > rseg->rdevice_index_highest) {
log_error("Device index %" PRIu64
" > %" PRIu64 " (too high) "
"for replicator site %s/%s.",
rdev->device_index,
rseg->rdevice_index_highest,
lv->name, rsite->name);
r = 0;
}
}
}
}
return r;
}
/**
* Is this segment part of active replicator
*/
int lv_is_active_replicator_dev(const struct logical_volume *lv)
{
return ((lv->status & REPLICATOR) &&
lv->rdevice &&
lv->rdevice->rsite &&
lv->rdevice->rsite->state == REPLICATOR_STATE_ACTIVE);
}
/**
* Is this LV replicator control device
*/
int lv_is_replicator(const struct logical_volume *lv)
{
return ((lv->status & REPLICATOR) &&
!dm_list_empty(&lv->segments) &&
seg_is_replicator(first_seg(lv)));
}
/**
* Is this LV replicator device
*/
int lv_is_replicator_dev(const struct logical_volume *lv)
{
return ((lv->status & REPLICATOR) &&
!dm_list_empty(&lv->segments) &&
seg_is_replicator_dev(first_seg(lv)));
}
/**
* Is this LV replicated origin lv
*/
int lv_is_rimage(const struct logical_volume *lv)
{
return (lv->rdevice && lv->rdevice->lv == lv);
}
/**
* Is this LV sync log
*/
int lv_is_slog(const struct logical_volume *lv)
{
return (lv->rdevice && lv->rdevice->slog == lv);
}
/**
* Returns first replicator-dev in site in case the LV is replicator-dev,
* NULL otherwise
*/
struct logical_volume *first_replicator_dev(const struct logical_volume *lv)
{
struct replicator_device *rdev;
struct replicator_site *rsite;
if (lv_is_replicator_dev(lv))
dm_list_iterate_items(rsite, &first_seg(lv)->replicator->rsites) {
dm_list_iterate_items(rdev, &rsite->rdevices)
return rdev->replicator_dev->lv;
break;
}
return NULL;
}
/**
* Add VG open parameters to sorted cmd_vg list.
*
* Maintain the alphabeticaly ordered list, avoid duplications.
*
* \return Returns newly created or already present cmd_vg entry,
* or NULL in error case.
*/
struct cmd_vg *cmd_vg_add(struct dm_pool *mem, struct dm_list *cmd_vgs,
const char *vg_name, const char *vgid,
uint32_t flags)
{
struct cmd_vg *cvl, *ins;
if (!vg_name && !vgid) {
log_error("Either vg_name or vgid must be set.");
return NULL;
}
/* Is it already in the list ? */
if ((cvl = cmd_vg_lookup(cmd_vgs, vg_name, vgid)))
return cvl;
if (!(cvl = dm_pool_zalloc(mem, sizeof(*cvl)))) {
log_error("Allocation of cmd_vg failed.");
return NULL;
}
if (vg_name && !(cvl->vg_name = dm_pool_strdup(mem, vg_name))) {
dm_pool_free(mem, cvl);
log_error("Allocation of vg_name failed.");
return NULL;
}
if (vgid && !(cvl->vgid = dm_pool_strdup(mem, vgid))) {
dm_pool_free(mem, cvl);
log_error("Allocation of vgid failed.");
return NULL;
}
cvl->flags = flags;
if (vg_name)
dm_list_iterate_items(ins, cmd_vgs)
if (strcmp(vg_name, ins->vg_name) < 0) {
cmd_vgs = &ins->list; /* new position */
break;
}
dm_list_add(cmd_vgs, &cvl->list);
return cvl;
}
/**
* Find cmd_vg with given vg_name in cmd_vgs list.
*
* \param cmd_vgs List of cmd_vg entries.
*
* \param vg_name Name of VG to be found.
* \param vgid UUID of VG to be found.
*
* \return Returns cmd_vg entry if vg_name or vgid is found,
* NULL otherwise.
*/
struct cmd_vg *cmd_vg_lookup(struct dm_list *cmd_vgs,
const char *vg_name, const char *vgid)
{
struct cmd_vg *cvl;
dm_list_iterate_items(cvl, cmd_vgs)
if ((vgid && cvl->vgid && !strcmp(vgid, cvl->vgid)) ||
(vg_name && cvl->vg_name && !strcmp(vg_name, cvl->vg_name)))
return cvl;
return NULL;
}
/**
* Read and lock multiple VGs stored in cmd_vgs list alphabeticaly.
* On the success list head pointer is set to VGs' cmd_vgs.
* (supports FAILED_INCONSISTENT)
*
* \param cmd_vg Contains list of cmd_vg entries.
*
* \return Returns 1 if all VG in cmd_vgs list are correctly
* openned and locked, 0 otherwise.
*/
int cmd_vg_read(struct cmd_context *cmd, struct dm_list *cmd_vgs)
{
struct cmd_vg *cvl;
/* Iterate through alphabeticaly ordered cmd_vg list */
dm_list_iterate_items(cvl, cmd_vgs) {
cvl->vg = vg_read(cmd, cvl->vg_name, cvl->vgid, cvl->flags, 0);
if (vg_read_error(cvl->vg)) {
log_debug_metadata("Failed to vg_read %s", cvl->vg_name);
return 0;
}
cvl->vg->cmd_vgs = cmd_vgs; /* Make it usable in VG */
}
return 1;
}
/**
* Release opened and locked VGs from list.
*
* \param cmd_vgs Contains list of cmd_vg entries.
*/
void free_cmd_vgs(struct dm_list *cmd_vgs)
{
struct cmd_vg *cvl;
/* Backward iterate cmd_vg list */
dm_list_iterate_back_items(cvl, cmd_vgs) {
if (vg_read_error(cvl->vg))
release_vg(cvl->vg);
else
unlock_and_release_vg(cvl->vg->cmd, cvl->vg, cvl->vg_name);
cvl->vg = NULL;
}
}
/**
* Find all needed remote VGs for processing given LV.
* Missing VGs are added to VG's cmd_vg list and flag cmd_missing_vgs is set.
*/
int find_replicator_vgs(const struct logical_volume *lv)
{
struct replicator_site *rsite;
int ret = 1;
if (!lv_is_replicator_dev(lv))
return 1;
dm_list_iterate_items(rsite, &first_seg(lv)->replicator->rsites) {
if (!rsite->vg_name || !lv->vg->cmd_vgs ||
cmd_vg_lookup(lv->vg->cmd_vgs, rsite->vg_name, NULL))
continue;
ret = 0;
/* Using cmd memory pool for cmd_vg list allocation */
if (!cmd_vg_add(lv->vg->cmd->mem, lv->vg->cmd_vgs,
rsite->vg_name, NULL, 0)) {
lv->vg->cmd_missing_vgs = 0; /* do not retry */
stack;
break;
}
log_debug_metadata("VG: %s added as missing.", rsite->vg_name);
lv->vg->cmd_missing_vgs++;
}
return ret;
}
/**
* Read all remote VGs from lv's replicator sites.
* Function is used in activation context and needs all VGs already locked.
*/
int lv_read_replicator_vgs(const struct logical_volume *lv)
{
struct replicator_device *rdev;
struct replicator_site *rsite;
struct volume_group *vg;
if (!lv_is_replicator_dev(lv))
return 1;
dm_list_iterate_items(rsite, &first_seg(lv)->replicator->rsites) {
if (!rsite->vg_name)
continue;
vg = vg_read(lv->vg->cmd, rsite->vg_name, 0, 0, 0); // READ_WITHOUT_LOCK
if (vg_read_error(vg)) {
log_error("Unable to read volume group %s",
rsite->vg_name);
goto bad;
}
rsite->vg = vg;
/* FIXME: handling missing LVs needs to be better */
dm_list_iterate_items(rdev, &rsite->rdevices)
if (!(rdev->lv = find_lv(vg, rdev->name))) {
log_error("Unable to find %s in volume group %s",
rdev->name, rsite->vg_name);
goto bad;
}
}
return 1;
bad:
lv_release_replicator_vgs(lv);
return 0;
}
/**
* Release all VG resources taken by lv's replicator sites.
* Function is used in activation context and needs all VGs already locked.
*/
void lv_release_replicator_vgs(const struct logical_volume *lv)
{
struct replicator_site *rsite;
if (!lv_is_replicator_dev(lv))
return;
dm_list_iterate_back_items(rsite, &first_seg(lv)->replicator->rsites)
if (rsite->vg_name && rsite->vg) {
release_vg(rsite->vg);
rsite->vg = NULL;
}
}

8
lib/metadata/segtype.h
View File

@ -36,8 +36,6 @@ struct dev_manager;
#define SEG_VIRTUAL (1ULL << 5) #define SEG_VIRTUAL (1ULL << 5)
#define SEG_CANNOT_BE_ZEROED (1ULL << 6) #define SEG_CANNOT_BE_ZEROED (1ULL << 6)
#define SEG_MONITORED (1ULL << 7) #define SEG_MONITORED (1ULL << 7)
#define SEG_REPLICATOR (1ULL << 8)
#define SEG_REPLICATOR_DEV (1ULL << 9)
#define SEG_RAID (1ULL << 10) #define SEG_RAID (1ULL << 10)
#define SEG_THIN_POOL (1ULL << 11) #define SEG_THIN_POOL (1ULL << 11)
#define SEG_THIN_VOLUME (1ULL << 12) #define SEG_THIN_VOLUME (1ULL << 12)
@ -198,8 +196,6 @@ struct dev_manager;
#define seg_is_raid_with_meta(seg) segtype_is_raid_with_meta((seg)->segtype) #define seg_is_raid_with_meta(seg) segtype_is_raid_with_meta((seg)->segtype)
#define seg_is_striped_raid(seg) segtype_is_striped_raid((seg)->segtype) #define seg_is_striped_raid(seg) segtype_is_striped_raid((seg)->segtype)
#define seg_is_reshapable_raid(seg) segtype_is_reshapable_raid((seg)->segtype) #define seg_is_reshapable_raid(seg) segtype_is_reshapable_raid((seg)->segtype)
#define seg_is_replicator(seg) ((seg)->segtype->flags & SEG_REPLICATOR ? 1 : 0)
#define seg_is_replicator_dev(seg) ((seg)->segtype->flags & SEG_REPLICATOR_DEV ? 1 : 0)
#define seg_is_snapshot(seg) segtype_is_snapshot((seg)->segtype) #define seg_is_snapshot(seg) segtype_is_snapshot((seg)->segtype)
#define seg_is_striped(seg) segtype_is_striped((seg)->segtype) #define seg_is_striped(seg) segtype_is_striped((seg)->segtype)
#define seg_is_thin(seg) segtype_is_thin((seg)->segtype) #define seg_is_thin(seg) segtype_is_thin((seg)->segtype)
@ -313,10 +309,6 @@ struct segment_type *init_unknown_segtype(struct cmd_context *cmd,
int init_raid_segtypes(struct cmd_context *cmd, struct segtype_library *seglib); int init_raid_segtypes(struct cmd_context *cmd, struct segtype_library *seglib);
#endif #endif
#ifdef REPLICATOR_INTERNAL
int init_replicator_segtype(struct cmd_context *cmd, struct segtype_library *seglib);
#endif
#define THIN_FEATURE_DISCARDS (1U << 0) #define THIN_FEATURE_DISCARDS (1U << 0)
#define THIN_FEATURE_EXTERNAL_ORIGIN (1U << 1) #define THIN_FEATURE_EXTERNAL_ORIGIN (1U << 1)
#define THIN_FEATURE_HELD_ROOT (1U << 2) #define THIN_FEATURE_HELD_ROOT (1U << 2)

2
lib/metadata/vg.h
View File

@ -47,8 +47,6 @@ struct volume_group {
struct format_instance *fid; struct format_instance *fid;
const struct format_type *original_fmt; /* Set when processing backup files */ const struct format_type *original_fmt; /* Set when processing backup files */
struct lvmcache_vginfo *vginfo; struct lvmcache_vginfo *vginfo;
struct dm_list *cmd_vgs;/* List of wanted/locked and opened VGs */
uint32_t cmd_missing_vgs;/* Flag marks missing VG */
uint32_t seqno; /* Metadata sequence number */ uint32_t seqno; /* Metadata sequence number */
unsigned skip_validate_lock_args : 1; unsigned skip_validate_lock_args : 1;
unsigned lvmetad_update_pending: 1; unsigned lvmetad_update_pending: 1;

1
lib/replicator/.exported_symbols
View File

@ -1 +0,0 @@
init_segtype

25
lib/replicator/Makefile.in
View File

@ -1,25 +0,0 @@
#
# Copyright (C) 2009-2010 Red Hat, Inc. All rights reserved.
#
# This file is part of LVM2.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions
# of the GNU General Public License v.2.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
srcdir = @srcdir@
top_srcdir = @top_srcdir@
top_builddir = @top_builddir@
SOURCES = replicator.c
LIB_SHARED = liblvm2replicator.$(LIB_SUFFIX)
LIB_VERSION = $(LIB_VERSION_LVM)
include $(top_builddir)/make.tmpl
install: install_lib_shared_plugin

792
lib/replicator/replicator.c
View File

@ -1,792 +0,0 @@
/*
* Copyright (C) 2009-2010 Red Hat, Inc. All rights reserved.
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "lib.h"
#include "toolcontext.h"
#include "metadata.h"
#include "segtype.h"
#include "text_export.h"
#include "activate.h"
#include "str_list.h"
#ifdef DMEVENTD
# include "libdevmapper-event.h"
#endif
/* Dm kernel module name for replicator */
#define REPLICATOR_MODULE "replicator"
#define REPLICATOR_DEV_MODULE "replicator-dev"
/*
* Macro used as return argument - returns 0.
* return is left to be written in the function for better readability.
*/
#define SEG_LOG_ERROR(t, p...) \
log_error(t " segment %s of logical volume %s.", ## p, \
dm_config_parent_name(sn), seg->lv->name), 0;
/*
* Replicator target
*/
/* FIXME: missing implementation */
static void _replicator_display(const struct lv_segment *seg)
{
//const char *size;
//uint32_t s;
log_print(" Replicator");
if (seg->rlog_lv)
log_print(" Replicator volume\t%s", seg->rlog_lv->name);
}
/* Wrapper for dm_config_get_uint32() with default value */
static uint32_t _get_config_uint32(const struct dm_config_node *cn,
const char *path,
uint32_t def)
{
uint32_t t;
return dm_config_get_uint32(cn, path, &t) ? t : def;
}
/* Wrapper for dm_config_get_uint64() with default value */
static uint64_t _get_config_uint64(const struct dm_config_node *cn,
const char *path,
uint64_t def)
{
uint64_t t;
return dm_config_get_uint64(cn, path, &t) ? t : def;
}
/* Strings replicator_state_t enum */
static const char _state_txt[NUM_REPLICATOR_STATE][8] = {
"passive",
"active"
};
/* Parse state string */
static replicator_state_t _get_state(const struct dm_config_node *sn,
const char *path, replicator_state_t def)
{
const char *str;
unsigned i;
if (dm_config_get_str(sn, path, &str)) {
for (i = 0; i < sizeof(_state_txt)/sizeof(_state_txt[0]); ++i)
if (strcasecmp(str, _state_txt[i]) == 0)
return (replicator_state_t) i;
log_warn("%s: unknown value '%s', using default '%s' state",
path, str, _state_txt[def]);
}
return def;
}
/* Strings for replicator_action_t enum */
static const char _op_mode_txt[NUM_DM_REPLICATOR_MODES][8] = {
"sync",
"warn",
"stall",
"drop",
"fail"
};
/* Parse action string */
static dm_replicator_mode_t _get_op_mode(const struct dm_config_node *sn,
const char *path, dm_replicator_mode_t def)
{
const char *str;
unsigned i;
if (dm_config_get_str(sn, path, &str)) {
for (i = 0; i < sizeof(_op_mode_txt)/sizeof(_op_mode_txt[0]); ++i)
if (strcasecmp(str, _op_mode_txt[i]) == 0) {
log_very_verbose("Setting %s to %s",
path, _op_mode_txt[i]);
return (dm_replicator_mode_t) i;
}
log_warn("%s: unknown value '%s', using default '%s' operation mode",
path, str, _op_mode_txt[def]);
}
return def;
}
static struct replicator_site *_get_site(struct logical_volume *replicator,
const char *key)
{
struct dm_pool *mem = replicator->vg->vgmem;
struct replicator_site *rsite;
dm_list_iterate_items(rsite, &replicator->rsites)
if (strcasecmp(rsite->name, key) == 0)
return rsite;
if (!(rsite = dm_pool_zalloc(mem, sizeof(*rsite))))
return_NULL;
if (!(rsite->name = dm_pool_strdup(mem, key)))
return_NULL;
rsite->replicator = replicator;
dm_list_init(&rsite->rdevices);
dm_list_add(&replicator->rsites, &rsite->list);
return rsite;
}
/* Parse replicator site element */
static int _add_site(struct lv_segment *seg,
const char *key,
const struct dm_config_node *sn)
{
struct dm_pool *mem = seg->lv->vg->vgmem;
const struct dm_config_node *cn;
struct replicator_site *rsite;
if (!(rsite = _get_site(seg->lv, key)))
return_0;
if (!dm_config_find_node(sn, "site_index"))
return SEG_LOG_ERROR("Mandatory site_index is missing for");
rsite->state = _get_state(sn, "state", REPLICATOR_STATE_PASSIVE);
rsite->site_index = _get_config_uint32(sn, "site_index", 0);
if (rsite->site_index > seg->rsite_index_highest)
return SEG_LOG_ERROR("site_index=%d > highest_site_index=%d for",
rsite->site_index, seg->rsite_index_highest);
rsite->fall_behind_data = _get_config_uint64(sn, "fall_behind_data", 0);
rsite->fall_behind_ios = _get_config_uint32(sn, "fall_behind_ios", 0);
rsite->fall_behind_timeout = _get_config_uint32(sn, "fall_behind_timeout", 0);
rsite->op_mode = DM_REPLICATOR_SYNC;
if (rsite->fall_behind_data ||
rsite->fall_behind_ios ||
rsite->fall_behind_timeout) {
if (rsite->fall_behind_data && rsite->fall_behind_ios)
return SEG_LOG_ERROR("Defined both fall_behind_data "
"and fall_behind_ios in");
if (rsite->fall_behind_data && rsite->fall_behind_timeout)
return SEG_LOG_ERROR("Defined both fall_behind_data "
"and fall_behind_timeout in");
if (rsite->fall_behind_ios && rsite->fall_behind_timeout)
return SEG_LOG_ERROR("Defined both fall_behind_ios "
"and fall_behind_timeout in");
rsite->op_mode = _get_op_mode(sn, "operation_mode",
rsite->op_mode);
}
if ((cn = dm_config_find_node(sn, "volume_group"))) {
if (!cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("volume_group must be a string in");
if (!(rsite->vg_name = dm_pool_strdup(mem, cn->v->v.str)))
return_0;
} else if (rsite->site_index != 0)
return SEG_LOG_ERROR("volume_group is mandatory for remote site in");
return 1;
}
/* Import replicator segment */
static int _replicator_text_import(struct lv_segment *seg,
const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused)))
{
const struct dm_config_node *cn;
struct logical_volume *rlog_lv;
if (!replicator_add_replicator_dev(seg->lv, NULL))
return_0;
if (!(cn = dm_config_find_node(sn, "replicator_log")) ||
!cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Replicator log type must be a string in");
if (!(rlog_lv = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown replicator log %s in",
cn->v->v.str);
if (!(cn = dm_config_find_node(sn, "replicator_log_type")) ||
!cn->v || cn->v->type != DM_CFG_STRING)
return SEG_LOG_ERROR("Replicator log's type must be a string in");
if (strcasecmp(cn->v->v.str, "ringbuffer"))
return SEG_LOG_ERROR("Only ringbuffer replicator log type is supported in");
if (!(seg->rlog_type = dm_pool_strdup(seg->lv->vg->vgmem, cn->v->v.str)))
return_0;
log_very_verbose("replicator_log = %s", rlog_lv->name);
log_very_verbose("replicator_log_type = %s", seg->rlog_type);
if (!replicator_add_rlog(seg, rlog_lv))
return_0;
seg->rdevice_index_highest = _get_config_uint64(sn, "highest_device_index", 0);
seg->rsite_index_highest = _get_config_uint32(sn, "highest_site_index", 0);
seg->region_size = _get_config_uint32(sn, "sync_log_size", 0);
for (; sn; sn = sn->sib)
if (!sn->v) {
for (cn = sn->sib; cn; cn = cn->sib)
if (!cn->v && (strcasecmp(cn->key ,sn->key) == 0))
return SEG_LOG_ERROR("Detected duplicate site "
"name %s in", sn->key);
if (!_add_site(seg, sn->key, sn->child))
return_0;
}
return 1;
}
/* Export replicator segment */
static int _replicator_text_export(const struct lv_segment *seg,
struct formatter *f)
{
struct replicator_site *rsite;
if (!seg->rlog_lv)
return_0;
outf(f, "replicator_log = \"%s\"", seg->rlog_lv->name);
outf(f, "replicator_log_type = \"%s\"", seg->rlog_type);
outf(f, "highest_device_index = %" PRIu64, seg->rdevice_index_highest);
outf(f, "highest_site_index = %d", seg->rsite_index_highest);
if (seg->region_size)
outsize(f, (uint64_t)seg->region_size,
"sync_log_size = %" PRIu32, seg->region_size);
if (!dm_list_empty(&seg->lv->rsites))
outnl(f);
dm_list_iterate_items(rsite, &seg->lv->rsites) {
outf(f, "%s {", rsite->name);
out_inc_indent(f);
outf(f, "state = \"%s\"", _state_txt[rsite->state]);
outf(f, "site_index = %d", rsite->site_index);
/* Only non-default parameters are written */
if (rsite->op_mode != DM_REPLICATOR_SYNC)
outf(f, "operation_mode = \"%s\"",
_op_mode_txt[rsite->op_mode]);
if (rsite->fall_behind_timeout)
outfc(f, "# seconds", "fall_behind_timeout = %u",
rsite->fall_behind_timeout);
if (rsite->fall_behind_ios)
outfc(f, "# io operations", "fall_behind_ios = %u",
rsite->fall_behind_ios);
if (rsite->fall_behind_data)
outsize(f, rsite->fall_behind_data, "fall_behind_data = %" PRIu64,
rsite->fall_behind_data);
if (rsite->state != REPLICATOR_STATE_ACTIVE && rsite->vg_name)
outf(f, "volume_group = \"%s\"", rsite->vg_name);
out_dec_indent(f);
outf(f, "}");
}
return 1;
}
#ifdef DEVMAPPER_SUPPORT
static int _replicator_add_target_line(struct dev_manager *dm,
struct dm_pool *mem,
struct cmd_context *cmd,
void **target_state,
struct lv_segment *seg,
const struct lv_activate_opts *laopts,
struct dm_tree_node *node,
uint64_t len,
uint32_t *pvmove_mirror_count)
{
const char *rlog_dlid;
struct replicator_site *rsite;
if (!seg->rlog_lv)
return_0;
if (!(rlog_dlid = build_dm_uuid(mem, seg->rlog_lv, NULL)))
return_0;
dm_list_iterate_items(rsite, &seg->lv->rsites) {
if (!dm_tree_node_add_replicator_target(node,
seg->rlog_lv->size,
rlog_dlid,
seg->rlog_type,
rsite->site_index,
rsite->op_mode,
rsite->fall_behind_timeout,
rsite->fall_behind_data,
rsite->fall_behind_ios)) {
if (rsite->site_index == 0) {
log_error("Failed to add replicator log '%s' "
"to replicator '%s'.",
rlog_dlid, seg->lv->name);
return 0;
}
// FIXME:
}
}
return 1;
}
/* FIXME: write something useful for replicator here */
static int _replicator_target_percent(void **target_state,
dm_percent_t *percent,
struct dm_pool *mem,
struct cmd_context *cmd,
struct lv_segment *seg,
char *params, uint64_t *total_numerator,
uint64_t *total_denominator)
{
return 1;
}
/* Check for module presence */
static int _replicator_target_present(struct cmd_context *cmd,
const struct lv_segment *seg __attribute__((unused)),
unsigned *attributes __attribute__((unused)))
{
static int _checked = 0;
static int _present = 0;
if (!activation())
return 0;
if (!_checked) {
_checked = 1;
_present = target_present(cmd, REPLICATOR_MODULE, 1);
}
return _present;
}
#endif
static int _replicator_modules_needed(struct dm_pool *mem,
const struct lv_segment *seg __attribute__((unused)),
struct dm_list *modules)
{
if (!str_list_add(mem, modules, REPLICATOR_MODULE))
return_0;
if (!str_list_add(mem, modules, REPLICATOR_DEV_MODULE))
return_0;
return 1;
}
static void _replicator_destroy(struct segment_type *segtype)
{
dm_free(segtype);
}
static struct segtype_handler _replicator_ops = {
.display = _replicator_display,
.text_import = _replicator_text_import,
.text_export = _replicator_text_export,
#ifdef DEVMAPPER_SUPPORT
.add_target_line = _replicator_add_target_line,
.target_percent = _replicator_target_percent,
.target_present = _replicator_target_present,
#endif
.modules_needed = _replicator_modules_needed,
.destroy = _replicator_destroy,
};
/*
* Replicator-dev target
*/
static void _replicator_dev_display(const struct lv_segment *seg)
{
//const char *size;
//uint32_t s;
// FIXME: debug test code for now
log_print(" Replicator\t\t%u", seg->area_count);
log_print(" Mirror size\t\t%u", seg->area_len);
if (seg->log_lv)
log_print(" Replicator log volume\t%s", seg->rlog_lv->name);
}
static int _add_device(struct lv_segment *seg,
const char *site_name,
const struct dm_config_node *sn,
uint64_t devidx)
{
struct dm_pool *mem = seg->lv->vg->vgmem;
struct logical_volume *lv = NULL;
struct logical_volume *slog_lv = NULL;
struct replicator_site *rsite = _get_site(seg->replicator, site_name);
struct replicator_device *rdev;
const char *dev_str = NULL;
const char *slog_str = NULL;
const struct dm_config_node *cn;
dm_list_iterate_items(rdev, &rsite->rdevices)
if (rdev->replicator_dev == seg)
return SEG_LOG_ERROR("Duplicate site found in");
if ((cn = dm_config_find_node(sn, "sync_log"))) {
if (!cn->v || !cn->v->v.str)
return SEG_LOG_ERROR("Sync log must be a string in");
slog_str = cn->v->v.str;
}
if (!(cn = dm_config_find_node(sn, "logical_volume")) ||
!cn->v || !cn->v->v.str)
return SEG_LOG_ERROR("Logical volume must be a string in");
dev_str = cn->v->v.str;
if (!seg->lv->rdevice) {
if (slog_str)
return SEG_LOG_ERROR("Sync log %s defined for local "
"device in", slog_str);
/* Check for device in current VG */
if (!(lv = find_lv(seg->lv->vg, dev_str)))
return SEG_LOG_ERROR("Logical volume %s not found in",
dev_str);
} else {
if (!slog_str)
return SEG_LOG_ERROR("Sync log is missing for remote "
"device in");
/* Check for slog device in current VG */
if (!(slog_lv = find_lv(seg->lv->vg, slog_str)))
return SEG_LOG_ERROR("Sync log %s not found in",
slog_str);
}
if (!(rdev = dm_pool_zalloc(mem, sizeof(*rdev))))
return_0;
if (!(rdev->name = dm_pool_strdup(mem, dev_str)))
return_0;
rdev->replicator_dev = seg;
rdev->rsite = rsite;
rdev->device_index = devidx;
if (!seg->lv->rdevice) {
if (!replicator_dev_add_rimage(rdev, lv))
return SEG_LOG_ERROR("LV inconsistency found in");
seg->lv->rdevice = rdev;
} else {
if (!slog_str ||
!(rdev->slog_name = dm_pool_strdup(mem, slog_str)))
return_0;
if (!replicator_dev_add_slog(rdev, slog_lv))
return SEG_LOG_ERROR("Sync log inconsistency found in");
}
dm_list_add(&rsite->rdevices, &rdev->list);// linked site list
return 1;
}
/* Import replicator segment */
static int _replicator_dev_text_import(struct lv_segment *seg,
const struct dm_config_node *sn,
struct dm_hash_table *pv_hash __attribute__((unused)))
{
const struct dm_config_node *cn;
struct logical_volume *replicator;
uint64_t devidx;
if (!(cn = dm_config_find_node(sn, "replicator")))
return SEG_LOG_ERROR("Replicator is missing for");
if (!cn->v || !cn->v->v.str)
return SEG_LOG_ERROR("Replicator must be a string for");
if (!(replicator = find_lv(seg->lv->vg, cn->v->v.str)))
return SEG_LOG_ERROR("Unknown replicator %s for", cn->v->v.str);
if (!replicator_add_replicator_dev(replicator, seg))
return_0;
log_very_verbose("replicator=%s", replicator->name);
/* Mandatory */
if (!dm_config_find_node(sn, "device_index") ||
!dm_config_get_uint64(sn, "device_index", &devidx))
return SEG_LOG_ERROR("Could not read 'device_index' for");
/* Read devices from sites */
for (; sn; sn = sn->sib)
if (!(sn->v) && !_add_device(seg, sn->key, sn->child, devidx))
return_0;
if (!seg->lv->rdevice)
return SEG_LOG_ERROR("Replicator device without site in");
seg->rlog_lv = NULL;
seg->lv->status |= REPLICATOR;
return 1;
}
/* Export replicator-dev segment */
static int _replicator_dev_text_export(const struct lv_segment *seg,
struct formatter *f)
{
struct replicator_site *rsite;
struct replicator_device *rdev;
if (!seg->replicator || !seg->lv->rdevice)
return_0;
outf(f, "replicator = \"%s\"", seg->replicator->name);
outf(f, "device_index = %" PRId64, seg->lv->rdevice->device_index);
outnl(f);
dm_list_iterate_items(rsite, &seg->replicator->rsites) {
dm_list_iterate_items(rdev, &rsite->rdevices) {
if (rdev->replicator_dev != seg)
continue;
outf(f, "%s {", rdev->rsite->name);
out_inc_indent(f);
outf(f, "logical_volume = \"%s\"",
rdev->name ? rdev->name : rdev->lv->name);
if (rdev->slog)
outf(f, "sync_log = \"%s\"", rdev->slog->name);
else if (rdev->slog_name)
outf(f, "sync_log = \"%s\"", rdev->slog_name);
out_dec_indent(f);
outf(f, "}");
}
}
return 1;
}
#ifdef DEVMAPPER_SUPPORT
/*
* Add target for passive site matching the device index
*/
static int _replicator_dev_add_target_line(struct dev_manager *dm,
struct dm_pool *mem,
struct cmd_context *cmd,
void **target_state,
struct lv_segment *seg,
const struct lv_activate_opts *laopts,
struct dm_tree_node *node,
uint64_t len,
uint32_t *pvmove_mirror_count)
{
const char *replicator_dlid, *rdev_dlid, *slog_dlid;
struct replicator_device *rdev, *rdev_search;
struct replicator_site *rsite;
uint32_t slog_size;
uint32_t slog_flags;
if (!lv_is_active_replicator_dev(seg->lv)) {
/* Create passive linear mapping */
log_very_verbose("Inactive replicator %s using %s.",
seg->lv->name, seg->lv->rdevice->lv->name);
if (!add_linear_area_to_dtree(node, seg->lv->size, seg->lv->vg->extent_size,
cmd->use_linear_target,
seg->lv->vg->name, seg->lv->name))
return_0;
if (!(rdev_dlid = build_dm_uuid(mem, seg->lv->rdevice->lv, NULL)))
return_0;
return dm_tree_node_add_target_area(node, NULL, rdev_dlid, 0);
}
if (seg->lv->rdevice->rsite->site_index) {
log_error("Active site with site_index != 0 (%s, %d)",
seg->lv->rdevice->rsite->name,
seg->lv->rdevice->rsite->site_index);
return 0; /* Replicator without any active site */
}
/*
* At this point all devices that have some connection with replicator
* must be present in dm_tree
*/
if (!seg_is_replicator_dev(seg) ||
!(replicator_dlid = build_dm_uuid(mem, seg->replicator, NULL)))
return_0;
/* Select remote devices with the same device index */
dm_list_iterate_items(rsite, &seg->replicator->rsites) {
if (rsite->site_index == 0) {
/* Local slink0 device */
rdev = seg->lv->rdevice;
} else {
rdev = NULL;
dm_list_iterate_items(rdev_search, &rsite->rdevices) {
if (rdev_search->replicator_dev == seg) {
rdev = rdev_search;
break;
}
}
if (!rdev) {
log_error(INTERNAL_ERROR "rdev list not found.");
return 0;
}
}
if (!rdev->lv ||
!(rdev_dlid = build_dm_uuid(mem, rdev->lv, NULL)))
return_0;
slog_dlid = NULL;
/* Using either disk or core (in memory) log */
if (rdev->slog) {
slog_flags = DM_NOSYNC;
slog_size = (uint32_t) rdev->slog->size;
if (!(slog_dlid = build_dm_uuid(mem, rdev->slog, NULL)))
return_0;
} else if (rdev->slog_name &&
sscanf(rdev->slog_name, FMTu32, &slog_size) == 1) {
slog_flags = DM_CORELOG | DM_FORCESYNC;
if (slog_size == 0) {
log_error("Failed to use empty corelog size "
"in replicator '%s'.",
rsite->replicator->name);
return 0;
}
} else {
slog_flags = DM_CORELOG | DM_FORCESYNC;
slog_size = 0; /* NOLOG */
}
if (!dm_tree_node_add_replicator_dev_target(node,
seg->lv->size,
replicator_dlid,
seg->lv->rdevice->device_index,
rdev_dlid,
rsite->site_index,
slog_dlid,
slog_flags,
slog_size)) {
return_0;
/* FIXME: handle 'state = dropped' in future */
}
}
return 1;
}
/* FIXME: write something useful for replicator-dev here */
static int _replicator_dev_target_percent(void **target_state,
dm_percent_t *percent,
struct dm_pool *mem,
struct cmd_context *cmd,
struct lv_segment *seg,
char *params,
uint64_t *total_numerator,
uint64_t *total_denominator)
{
return 1;
}
/* Check for module presence */
static int _replicator_dev_target_present(struct cmd_context *cmd,
const struct lv_segment *seg __attribute__((unused)),
unsigned *attributes __attribute__((unused)))
{
static int _checked = 0;
static int _present = 0;
if (!_checked) {
_present = target_present(cmd, REPLICATOR_DEV_MODULE, 1);
_checked = 1;
}
return _present;
}
#endif
static struct segtype_handler _replicator_dev_ops = {
.display = _replicator_dev_display,
.text_import = _replicator_dev_text_import,
.text_export = _replicator_dev_text_export,
#ifdef DEVMAPPER_SUPPORT
.add_target_line = _replicator_dev_add_target_line,
.target_percent = _replicator_dev_target_percent,
.target_present = _replicator_dev_target_present,
#endif
.modules_needed = _replicator_modules_needed,
.destroy = _replicator_destroy,
};
#ifdef REPLICATOR_INTERNAL
int init_replicator_segtype(struct cmd_context *cmd, struct segtype_library *seglib)
#else /* Shared */
int init_multiple_segtype(struct cmd_context *cmd, struct segtype_library *seglib);
int init_multiple_segtype(struct cmd_context *cmd, struct segtype_library *seglib)
#endif
{
struct segment_type *segtype;
if (!(segtype = dm_zalloc(sizeof(*segtype))))
return_0;
segtype->ops = &_replicator_ops;
segtype->name = REPLICATOR_MODULE;
segtype->private = NULL;
segtype->flags = SEG_REPLICATOR;
if (!lvm_register_segtype(seglib, segtype))
/* segtype is already destroyed */
return_0;
log_very_verbose("Initialised segtype: " REPLICATOR_MODULE);
if (!(segtype = dm_zalloc(sizeof(*segtype))))
return_0;
segtype->ops = &_replicator_dev_ops;
segtype->name = REPLICATOR_DEV_MODULE;
segtype->private = NULL;
segtype->flags = SEG_REPLICATOR_DEV;
if (!lvm_register_segtype(seglib, segtype))
/* segtype is already destroyed */
return_0;
log_very_verbose("Initialised segtype: " REPLICATOR_DEV_MODULE);
return 1;
}

6
tools/vgchange.c
View File

@ -114,11 +114,6 @@ static int _activate_lvs_in_vg(struct cmd_context *cmd, struct volume_group *vg,
if (lv_is_mirror_image(lv) || lv_is_mirror_log(lv)) if (lv_is_mirror_image(lv) || lv_is_mirror_log(lv))
continue; continue;
/* Only request activation of the first replicator-dev LV */
/* Avoids retry with all heads in case of failure */
if (lv_is_replicator_dev(lv) && (lv != first_replicator_dev(lv)))
continue;
if (lv_activation_skip(lv, activate, arg_is_set(cmd, ignoreactivationskip_ARG))) if (lv_activation_skip(lv, activate, arg_is_set(cmd, ignoreactivationskip_ARG)))
continue; continue;
@ -254,7 +249,6 @@ int vgchange_activate(struct cmd_context *cmd, struct volume_group *vg,
} }
/* Print message only if there was not found a missing VG */ /* Print message only if there was not found a missing VG */
if (!vg->cmd_missing_vgs)
log_print_unless_silent("%d logical volume(s) in volume group \"%s\" now active", log_print_unless_silent("%d logical volume(s) in volume group \"%s\" now active",
lvs_in_vg_activated(vg), vg->name); lvs_in_vg_activated(vg), vg->name);
return r; return r;