1 /* $NetBSD: mirrored.c,v 1.1.1.2 2009/12/02 00:26:26 haad Exp $ */
2
3 /*
4 * Copyright (C) 2003-2004 Sistina Software, Inc. All rights reserved.
5 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
6 *
7 * This file is part of LVM2.
8 *
9 * This copyrighted material is made available to anyone wishing to use,
10 * modify, copy, or redistribute it subject to the terms and conditions
11 * of the GNU Lesser General Public License v.2.1.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 */
17
18 #include "lib.h"
19 #include "toolcontext.h"
20 #include "metadata.h"
21 #include "segtype.h"
22 #include "display.h"
23 #include "text_export.h"
24 #include "text_import.h"
25 #include "config.h"
26 #include "defaults.h"
27 #include "lvm-string.h"
28 #include "targets.h"
29 #include "activate.h"
30 #include "sharedlib.h"
31 #include "str_list.h"
32
33 #ifdef DMEVENTD
34 # include "libdevmapper-event.h"
35 #endif
36
37 static int _block_on_error_available = 0;
38 static unsigned _mirror_attributes = 0;
39
40 enum {
41 MIRR_DISABLED,
42 MIRR_RUNNING,
43 MIRR_COMPLETED
44 };
45
46 struct mirror_state {
47 uint32_t default_region_size;
48 };
49
_mirrored_name(const struct lv_segment * seg)50 static const char *_mirrored_name(const struct lv_segment *seg)
51 {
52 return seg->segtype->name;
53 }
54
_mirrored_display(const struct lv_segment * seg)55 static void _mirrored_display(const struct lv_segment *seg)
56 {
57 const char *size;
58 uint32_t s;
59
60 log_print(" Mirrors\t\t%u", seg->area_count);
61 log_print(" Mirror size\t\t%u", seg->area_len);
62 if (seg->log_lv)
63 log_print(" Mirror log volume\t%s", seg->log_lv->name);
64
65 if (seg->region_size) {
66 size = display_size(seg->lv->vg->cmd,
67 (uint64_t) seg->region_size);
68 log_print(" Mirror region size\t%s", size);
69 }
70
71 log_print(" Mirror original:");
72 display_stripe(seg, 0, " ");
73 log_print(" Mirror destinations:");
74 for (s = 1; s < seg->area_count; s++)
75 display_stripe(seg, s, " ");
76 log_print(" ");
77 }
78
_mirrored_text_import_area_count(struct config_node * sn,uint32_t * area_count)79 static int _mirrored_text_import_area_count(struct config_node *sn, uint32_t *area_count)
80 {
81 if (!get_config_uint32(sn, "mirror_count", area_count)) {
82 log_error("Couldn't read 'mirror_count' for "
83 "segment '%s'.", config_parent_name(sn));
84 return 0;
85 }
86
87 return 1;
88 }
89
_mirrored_text_import(struct lv_segment * seg,const struct config_node * sn,struct dm_hash_table * pv_hash)90 static int _mirrored_text_import(struct lv_segment *seg, const struct config_node *sn,
91 struct dm_hash_table *pv_hash)
92 {
93 const struct config_node *cn;
94 char *logname = NULL;
95
96 if (find_config_node(sn, "extents_moved")) {
97 if (get_config_uint32(sn, "extents_moved",
98 &seg->extents_copied))
99 seg->status |= PVMOVE;
100 else {
101 log_error("Couldn't read 'extents_moved' for "
102 "segment %s of logical volume %s.",
103 config_parent_name(sn), seg->lv->name);
104 return 0;
105 }
106 }
107
108 if (find_config_node(sn, "region_size")) {
109 if (!get_config_uint32(sn, "region_size",
110 &seg->region_size)) {
111 log_error("Couldn't read 'region_size' for "
112 "segment %s of logical volume %s.",
113 config_parent_name(sn), seg->lv->name);
114 return 0;
115 }
116 }
117
118 if ((cn = find_config_node(sn, "mirror_log"))) {
119 if (!cn->v || !cn->v->v.str) {
120 log_error("Mirror log type must be a string.");
121 return 0;
122 }
123 logname = cn->v->v.str;
124 if (!(seg->log_lv = find_lv(seg->lv->vg, logname))) {
125 log_error("Unrecognised mirror log in "
126 "segment %s of logical volume %s.",
127 config_parent_name(sn), seg->lv->name);
128 return 0;
129 }
130 seg->log_lv->status |= MIRROR_LOG;
131 }
132
133 if (logname && !seg->region_size) {
134 log_error("Missing region size for mirror log for "
135 "segment %s of logical volume %s.",
136 config_parent_name(sn), seg->lv->name);
137 return 0;
138 }
139
140 if (!(cn = find_config_node(sn, "mirrors"))) {
141 log_error("Couldn't find mirrors array for "
142 "segment %s of logical volume %s.",
143 config_parent_name(sn), seg->lv->name);
144 return 0;
145 }
146
147 return text_import_areas(seg, sn, cn, pv_hash, MIRROR_IMAGE);
148 }
149
_mirrored_text_export(const struct lv_segment * seg,struct formatter * f)150 static int _mirrored_text_export(const struct lv_segment *seg, struct formatter *f)
151 {
152 outf(f, "mirror_count = %u", seg->area_count);
153 if (seg->status & PVMOVE)
154 out_size(f, (uint64_t) seg->extents_copied * seg->lv->vg->extent_size,
155 "extents_moved = %" PRIu32, seg->extents_copied);
156 if (seg->log_lv)
157 outf(f, "mirror_log = \"%s\"", seg->log_lv->name);
158 if (seg->region_size)
159 outf(f, "region_size = %" PRIu32, seg->region_size);
160
161 return out_areas(f, seg, "mirror");
162 }
163
164 #ifdef DEVMAPPER_SUPPORT
_mirrored_init_target(struct dm_pool * mem,struct cmd_context * cmd)165 static struct mirror_state *_mirrored_init_target(struct dm_pool *mem,
166 struct cmd_context *cmd)
167 {
168 struct mirror_state *mirr_state;
169
170 if (!(mirr_state = dm_pool_alloc(mem, sizeof(*mirr_state)))) {
171 log_error("struct mirr_state allocation failed");
172 return NULL;
173 }
174
175 mirr_state->default_region_size = 2 *
176 find_config_tree_int(cmd,
177 "activation/mirror_region_size",
178 DEFAULT_MIRROR_REGION_SIZE);
179
180 return mirr_state;
181 }
182
_mirrored_target_percent(void ** target_state,percent_range_t * percent_range,struct dm_pool * mem,struct cmd_context * cmd,struct lv_segment * seg,char * params,uint64_t * total_numerator,uint64_t * total_denominator)183 static int _mirrored_target_percent(void **target_state,
184 percent_range_t *percent_range,
185 struct dm_pool *mem,
186 struct cmd_context *cmd,
187 struct lv_segment *seg, char *params,
188 uint64_t *total_numerator,
189 uint64_t *total_denominator)
190 {
191 struct mirror_state *mirr_state;
192 uint64_t numerator, denominator;
193 unsigned mirror_count, m;
194 int used;
195 char *pos = params;
196
197 if (!*target_state)
198 *target_state = _mirrored_init_target(mem, cmd);
199
200 mirr_state = *target_state;
201
202 /* Status line: <#mirrors> (maj:min)+ <synced>/<total_regions> */
203 log_debug("Mirror status: %s", params);
204
205 if (sscanf(pos, "%u %n", &mirror_count, &used) != 1) {
206 log_error("Failure parsing mirror status mirror count: %s",
207 params);
208 return 0;
209 }
210 pos += used;
211
212 for (m = 0; m < mirror_count; m++) {
213 if (sscanf(pos, "%*x:%*x %n", &used) != 0) {
214 log_error("Failure parsing mirror status devices: %s",
215 params);
216 return 0;
217 }
218 pos += used;
219 }
220
221 if (sscanf(pos, "%" PRIu64 "/%" PRIu64 "%n", &numerator, &denominator,
222 &used) != 2) {
223 log_error("Failure parsing mirror status fraction: %s", params);
224 return 0;
225 }
226 pos += used;
227
228 *total_numerator += numerator;
229 *total_denominator += denominator;
230
231 if (seg)
232 seg->extents_copied = seg->area_len * numerator / denominator;
233
234 if (numerator == denominator)
235 *percent_range = PERCENT_100;
236 else if (numerator == 0)
237 *percent_range = PERCENT_0;
238 else
239 *percent_range = PERCENT_0_TO_100;
240
241 return 1;
242 }
243
_add_log(struct dev_manager * dm,struct lv_segment * seg,struct dm_tree_node * node,uint32_t area_count,uint32_t region_size)244 static int _add_log(struct dev_manager *dm, struct lv_segment *seg,
245 struct dm_tree_node *node, uint32_t area_count, uint32_t region_size)
246 {
247 unsigned clustered = 0;
248 char *log_dlid = NULL;
249 uint32_t log_flags = 0;
250
251 /*
252 * Use clustered mirror log for non-exclusive activation
253 * in clustered VG.
254 */
255 if ((!(seg->lv->status & ACTIVATE_EXCL) &&
256 (vg_is_clustered(seg->lv->vg))))
257 clustered = 1;
258
259 if (seg->log_lv) {
260 /* If disk log, use its UUID */
261 if (!(log_dlid = build_dlid(dm, seg->log_lv->lvid.s, NULL))) {
262 log_error("Failed to build uuid for log LV %s.",
263 seg->log_lv->name);
264 return 0;
265 }
266 } else {
267 /* If core log, use mirror's UUID and set DM_CORELOG flag */
268 if (!(log_dlid = build_dlid(dm, seg->lv->lvid.s, NULL))) {
269 log_error("Failed to build uuid for mirror LV %s.",
270 seg->lv->name);
271 return 0;
272 }
273 log_flags |= DM_CORELOG;
274 }
275
276 if (mirror_in_sync() && !(seg->status & PVMOVE))
277 log_flags |= DM_NOSYNC;
278
279 if (_block_on_error_available && !(seg->status & PVMOVE))
280 log_flags |= DM_BLOCK_ON_ERROR;
281
282 return dm_tree_node_add_mirror_target_log(node, region_size, clustered, log_dlid, area_count, log_flags);
283 }
284
_mirrored_add_target_line(struct dev_manager * dm,struct dm_pool * mem,struct cmd_context * cmd,void ** target_state,struct lv_segment * seg,struct dm_tree_node * node,uint64_t len,uint32_t * pvmove_mirror_count)285 static int _mirrored_add_target_line(struct dev_manager *dm, struct dm_pool *mem,
286 struct cmd_context *cmd, void **target_state,
287 struct lv_segment *seg,
288 struct dm_tree_node *node, uint64_t len,
289 uint32_t *pvmove_mirror_count)
290 {
291 struct mirror_state *mirr_state;
292 uint32_t area_count = seg->area_count;
293 unsigned start_area = 0u;
294 int mirror_status = MIRR_RUNNING;
295 uint32_t region_size;
296 int r;
297
298 if (!*target_state)
299 *target_state = _mirrored_init_target(mem, cmd);
300
301 mirr_state = *target_state;
302
303 /*
304 * Mirror segment could have only 1 area temporarily
305 * if the segment is under conversion.
306 */
307 if (seg->area_count == 1)
308 mirror_status = MIRR_DISABLED;
309
310 /*
311 * For pvmove, only have one mirror segment RUNNING at once.
312 * Segments before this are COMPLETED and use 2nd area.
313 * Segments after this are DISABLED and use 1st area.
314 */
315 if (seg->status & PVMOVE) {
316 if (seg->extents_copied == seg->area_len) {
317 mirror_status = MIRR_COMPLETED;
318 start_area = 1;
319 } else if ((*pvmove_mirror_count)++) {
320 mirror_status = MIRR_DISABLED;
321 area_count = 1;
322 }
323 /* else MIRR_RUNNING */
324 }
325
326 if (mirror_status != MIRR_RUNNING) {
327 if (!dm_tree_node_add_linear_target(node, len))
328 return_0;
329 goto done;
330 }
331
332 if (!(seg->status & PVMOVE)) {
333 if (!seg->region_size) {
334 log_error("Missing region size for mirror segment.");
335 return 0;
336 }
337 region_size = seg->region_size;
338
339 } else
340 region_size = adjusted_mirror_region_size(seg->lv->vg->extent_size,
341 seg->area_len,
342 mirr_state->default_region_size);
343
344 if (!dm_tree_node_add_mirror_target(node, len))
345 return_0;
346
347 if ((r = _add_log(dm, seg, node, area_count, region_size)) <= 0) {
348 stack;
349 return r;
350 }
351
352 done:
353 return add_areas_line(dm, seg, node, start_area, area_count);
354 }
355
_mirrored_target_present(struct cmd_context * cmd,const struct lv_segment * seg,unsigned * attributes)356 static int _mirrored_target_present(struct cmd_context *cmd,
357 const struct lv_segment *seg,
358 unsigned *attributes)
359 {
360 static int _mirrored_checked = 0;
361 static int _mirrored_present = 0;
362 uint32_t maj, min, patchlevel;
363 unsigned maj2, min2, patchlevel2;
364 char vsn[80];
365
366 if (!_mirrored_checked) {
367 _mirrored_present = target_present(cmd, "mirror", 1);
368
369 /*
370 * block_on_error available as "block_on_error" log
371 * argument with mirror target >= 1.1 and <= 1.11
372 * or with 1.0 in RHEL4U3 driver >= 4.5
373 *
374 * block_on_error available as "handle_errors" mirror
375 * argument with mirror target >= 1.12.
376 *
377 * libdm-deptree.c is smart enough to handle the differences
378 * between block_on_error and handle_errors for all
379 * mirror target versions >= 1.1
380 */
381 /* FIXME Move this into libdevmapper */
382
383 if (target_version("mirror", &maj, &min, &patchlevel) &&
384 maj == 1 &&
385 ((min >= 1) ||
386 (min == 0 && driver_version(vsn, sizeof(vsn)) &&
387 sscanf(vsn, "%u.%u.%u", &maj2, &min2, &patchlevel2) == 3 &&
388 maj2 == 4 && min2 == 5 && patchlevel2 == 0))) /* RHEL4U3 */
389 _block_on_error_available = 1;
390 }
391
392 /*
393 * Check only for modules if atttributes requested and no previous check.
394 * FIXME: Fails incorrectly if cmirror was built into kernel.
395 */
396 if (attributes) {
397 if (!_mirror_attributes && module_present(cmd, "log-clustered"))
398 _mirror_attributes |= MIRROR_LOG_CLUSTERED;
399 *attributes = _mirror_attributes;
400 }
401 _mirrored_checked = 1;
402
403 return _mirrored_present;
404 }
405
406 #ifdef DMEVENTD
_get_mirror_dso_path(struct cmd_context * cmd,char ** dso)407 static int _get_mirror_dso_path(struct cmd_context *cmd, char **dso)
408 {
409 char *path;
410 const char *libpath;
411
412 if (!(path = dm_pool_alloc(cmd->mem, PATH_MAX))) {
413 log_error("Failed to allocate dmeventd library path.");
414 return 0;
415 }
416
417 libpath = find_config_tree_str(cmd, "dmeventd/mirror_library",
418 DEFAULT_DMEVENTD_MIRROR_LIB);
419
420 get_shared_library_path(cmd, libpath, path, PATH_MAX);
421
422 *dso = path;
423
424 return 1;
425 }
426
_create_dm_event_handler(const char * dmname,const char * dso,enum dm_event_mask mask)427 static struct dm_event_handler *_create_dm_event_handler(const char *dmname,
428 const char *dso,
429 enum dm_event_mask mask)
430 {
431 struct dm_event_handler *dmevh;
432
433 if (!(dmevh = dm_event_handler_create()))
434 return_0;
435
436 if (dm_event_handler_set_dso(dmevh, dso))
437 goto fail;
438
439 if (dm_event_handler_set_dev_name(dmevh, dmname))
440 goto fail;
441
442 dm_event_handler_set_event_mask(dmevh, mask);
443 return dmevh;
444
445 fail:
446 dm_event_handler_destroy(dmevh);
447 return NULL;
448 }
449
_target_monitored(struct lv_segment * seg,int * pending)450 static int _target_monitored(struct lv_segment *seg, int *pending)
451 {
452 char *dso, *name;
453 struct logical_volume *lv;
454 struct volume_group *vg;
455 enum dm_event_mask evmask = 0;
456 struct dm_event_handler *dmevh;
457
458 lv = seg->lv;
459 vg = lv->vg;
460
461 *pending = 0;
462 if (!_get_mirror_dso_path(vg->cmd, &dso))
463 return_0;
464
465 if (!(name = build_dm_name(vg->cmd->mem, vg->name, lv->name, NULL)))
466 return_0;
467
468 if (!(dmevh = _create_dm_event_handler(name, dso, DM_EVENT_ALL_ERRORS)))
469 return_0;
470
471 if (dm_event_get_registered_device(dmevh, 0)) {
472 dm_event_handler_destroy(dmevh);
473 return 0;
474 }
475
476 evmask = dm_event_handler_get_event_mask(dmevh);
477 if (evmask & DM_EVENT_REGISTRATION_PENDING) {
478 *pending = 1;
479 evmask &= ~DM_EVENT_REGISTRATION_PENDING;
480 }
481
482 dm_event_handler_destroy(dmevh);
483
484 return evmask;
485 }
486
487 /* FIXME This gets run while suspended and performs banned operations. */
_target_set_events(struct lv_segment * seg,int evmask __attribute ((unused)),int set)488 static int _target_set_events(struct lv_segment *seg,
489 int evmask __attribute((unused)), int set)
490 {
491 char *dso, *name;
492 struct logical_volume *lv;
493 struct volume_group *vg;
494 struct dm_event_handler *dmevh;
495 int r;
496
497 lv = seg->lv;
498 vg = lv->vg;
499
500 if (!_get_mirror_dso_path(vg->cmd, &dso))
501 return_0;
502
503 if (!(name = build_dm_name(vg->cmd->mem, vg->name, lv->name, NULL)))
504 return_0;
505
506 if (!(dmevh = _create_dm_event_handler(name, dso, DM_EVENT_ALL_ERRORS)))
507 return_0;
508
509 r = set ? dm_event_register_handler(dmevh) : dm_event_unregister_handler(dmevh);
510 dm_event_handler_destroy(dmevh);
511 if (!r)
512 return_0;
513
514 log_info("%s %s for events", set ? "Monitored" : "Unmonitored", name);
515
516 return 1;
517 }
518
_target_monitor_events(struct lv_segment * seg,int events)519 static int _target_monitor_events(struct lv_segment *seg, int events)
520 {
521 return _target_set_events(seg, events, 1);
522 }
523
_target_unmonitor_events(struct lv_segment * seg,int events)524 static int _target_unmonitor_events(struct lv_segment *seg, int events)
525 {
526 return _target_set_events(seg, events, 0);
527 }
528
529 #endif /* DMEVENTD */
530 #endif /* DEVMAPPER_SUPPORT */
531
_mirrored_modules_needed(struct dm_pool * mem,const struct lv_segment * seg,struct dm_list * modules)532 static int _mirrored_modules_needed(struct dm_pool *mem,
533 const struct lv_segment *seg,
534 struct dm_list *modules)
535 {
536 if (seg->log_lv &&
537 !list_segment_modules(mem, first_seg(seg->log_lv), modules))
538 return_0;
539
540 if (vg_is_clustered(seg->lv->vg) &&
541 !str_list_add(mem, modules, "clog")) {
542 log_error("cluster log string list allocation failed");
543 return 0;
544 }
545
546 if (!str_list_add(mem, modules, "mirror")) {
547 log_error("mirror string list allocation failed");
548 return 0;
549 }
550
551 return 1;
552 }
553
_mirrored_destroy(const struct segment_type * segtype)554 static void _mirrored_destroy(const struct segment_type *segtype)
555 {
556 dm_free((void *) segtype);
557 }
558
559 static struct segtype_handler _mirrored_ops = {
560 .name = _mirrored_name,
561 .display = _mirrored_display,
562 .text_import_area_count = _mirrored_text_import_area_count,
563 .text_import = _mirrored_text_import,
564 .text_export = _mirrored_text_export,
565 #ifdef DEVMAPPER_SUPPORT
566 .add_target_line = _mirrored_add_target_line,
567 .target_percent = _mirrored_target_percent,
568 .target_present = _mirrored_target_present,
569 #ifdef DMEVENTD
570 .target_monitored = _target_monitored,
571 .target_monitor_events = _target_monitor_events,
572 .target_unmonitor_events = _target_unmonitor_events,
573 #endif
574 #endif
575 .modules_needed = _mirrored_modules_needed,
576 .destroy = _mirrored_destroy,
577 };
578
579 #ifdef MIRRORED_INTERNAL
init_mirrored_segtype(struct cmd_context * cmd)580 struct segment_type *init_mirrored_segtype(struct cmd_context *cmd)
581 #else /* Shared */
582 struct segment_type *init_segtype(struct cmd_context *cmd);
583 struct segment_type *init_segtype(struct cmd_context *cmd)
584 #endif
585 {
586 struct segment_type *segtype = dm_malloc(sizeof(*segtype));
587
588 if (!segtype)
589 return_NULL;
590
591 segtype->cmd = cmd;
592 segtype->ops = &_mirrored_ops;
593 segtype->name = "mirror";
594 segtype->private = NULL;
595 segtype->flags = SEG_AREAS_MIRRORED | SEG_MONITORED;
596
597 log_very_verbose("Initialised segtype: %s", segtype->name);
598
599 return segtype;
600 }
601