2 * Copyright (C) 2003 Sistina Software
3 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
5 * This file is released under the LGPL.
8 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/vmalloc.h>
12 #include <linux/dm-io.h>
13 #include <linux/dm-dirty-log.h>
15 #include <linux/device-mapper.h>
17 #define DM_MSG_PREFIX "dirty region log"
19 static LIST_HEAD(_log_types
);
20 static DEFINE_SPINLOCK(_lock
);
22 static struct dm_dirty_log_type
*__find_dirty_log_type(const char *name
)
24 struct dm_dirty_log_type
*log_type
;
26 list_for_each_entry(log_type
, &_log_types
, list
)
27 if (!strcmp(name
, log_type
->name
))
33 static struct dm_dirty_log_type
*_get_dirty_log_type(const char *name
)
35 struct dm_dirty_log_type
*log_type
;
39 log_type
= __find_dirty_log_type(name
);
40 if (log_type
&& !try_module_get(log_type
->module
))
52 * Attempt to retrieve the dm_dirty_log_type by name. If not already
53 * available, attempt to load the appropriate module.
55 * Log modules are named "dm-log-" followed by the 'type_name'.
56 * Modules may contain multiple types.
57 * This function will first try the module "dm-log-<type_name>",
58 * then truncate 'type_name' on the last '-' and try again.
60 * For example, if type_name was "clustered-disk", it would search
61 * 'dm-log-clustered-disk' then 'dm-log-clustered'.
63 * Returns: dirty_log_type* on success, NULL on failure
65 static struct dm_dirty_log_type
*get_type(const char *type_name
)
67 char *p
, *type_name_dup
;
68 struct dm_dirty_log_type
*log_type
;
73 log_type
= _get_dirty_log_type(type_name
);
77 type_name_dup
= kstrdup(type_name
, GFP_KERNEL
);
79 DMWARN("No memory left to attempt log module load for \"%s\"",
84 while (request_module("dm-log-%s", type_name_dup
) ||
85 !(log_type
= _get_dirty_log_type(type_name
))) {
86 p
= strrchr(type_name_dup
, '-');
93 DMWARN("Module for logging type \"%s\" not found.", type_name
);
100 static void put_type(struct dm_dirty_log_type
*type
)
106 if (!__find_dirty_log_type(type
->name
))
109 module_put(type
->module
);
115 int dm_dirty_log_type_register(struct dm_dirty_log_type
*type
)
120 if (!__find_dirty_log_type(type
->name
))
121 list_add(&type
->list
, &_log_types
);
128 EXPORT_SYMBOL(dm_dirty_log_type_register
);
130 int dm_dirty_log_type_unregister(struct dm_dirty_log_type
*type
)
134 if (!__find_dirty_log_type(type
->name
)) {
139 list_del(&type
->list
);
145 EXPORT_SYMBOL(dm_dirty_log_type_unregister
);
147 struct dm_dirty_log
*dm_dirty_log_create(const char *type_name
,
148 struct dm_target
*ti
,
149 int (*flush_callback_fn
)(struct dm_target
*ti
),
150 unsigned int argc
, char **argv
)
152 struct dm_dirty_log_type
*type
;
153 struct dm_dirty_log
*log
;
155 log
= kmalloc(sizeof(*log
), GFP_KERNEL
);
159 type
= get_type(type_name
);
165 log
->flush_callback_fn
= flush_callback_fn
;
167 if (type
->ctr(log
, ti
, argc
, argv
)) {
175 EXPORT_SYMBOL(dm_dirty_log_create
);
177 void dm_dirty_log_destroy(struct dm_dirty_log
*log
)
183 EXPORT_SYMBOL(dm_dirty_log_destroy
);
185 /*-----------------------------------------------------------------
186 * Persistent and core logs share a lot of their implementation.
187 * FIXME: need a reload method to be called from a resume
188 *---------------------------------------------------------------*/
190 * Magic for persistent mirrors: "MiRr"
192 #define MIRROR_MAGIC 0x4D695272
195 * The on-disk version of the metadata.
197 #define MIRROR_DISK_VERSION 2
200 struct log_header_disk
{
204 * Simple, incrementing version. no backward
211 struct log_header_core
{
218 struct dm_target
*ti
;
222 uint32_t region_size
;
223 unsigned int region_count
;
226 unsigned bitset_uint32_count
;
227 uint32_t *clean_bits
;
229 uint32_t *recovering_bits
; /* FIXME: this seems excessive */
235 DEFAULTSYNC
, /* Synchronize if necessary */
236 NOSYNC
, /* Devices known to be already in sync */
237 FORCESYNC
, /* Force a sync to happen */
240 struct dm_io_request io_req
;
246 int log_dev_flush_failed
;
247 struct dm_dev
*log_dev
;
248 struct log_header_core header
;
250 struct dm_io_region header_location
;
251 struct log_header_disk
*disk_header
;
255 * The touched member needs to be updated every time we access
256 * one of the bitsets.
258 static inline int log_test_bit(uint32_t *bs
, unsigned bit
)
260 return test_bit_le(bit
, bs
) ? 1 : 0;
263 static inline void log_set_bit(struct log_c
*l
,
264 uint32_t *bs
, unsigned bit
)
266 __set_bit_le(bit
, bs
);
267 l
->touched_cleaned
= 1;
270 static inline void log_clear_bit(struct log_c
*l
,
271 uint32_t *bs
, unsigned bit
)
273 __clear_bit_le(bit
, bs
);
274 l
->touched_dirtied
= 1;
277 /*----------------------------------------------------------------
279 *--------------------------------------------------------------*/
280 static void header_to_disk(struct log_header_core
*core
, struct log_header_disk
*disk
)
282 disk
->magic
= cpu_to_le32(core
->magic
);
283 disk
->version
= cpu_to_le32(core
->version
);
284 disk
->nr_regions
= cpu_to_le64(core
->nr_regions
);
287 static void header_from_disk(struct log_header_core
*core
, struct log_header_disk
*disk
)
289 core
->magic
= le32_to_cpu(disk
->magic
);
290 core
->version
= le32_to_cpu(disk
->version
);
291 core
->nr_regions
= le64_to_cpu(disk
->nr_regions
);
294 static int rw_header(struct log_c
*lc
, int rw
)
296 lc
->io_req
.bi_op
= rw
;
298 return dm_io(&lc
->io_req
, 1, &lc
->header_location
, NULL
);
301 static int flush_header(struct log_c
*lc
)
303 struct dm_io_region null_location
= {
304 .bdev
= lc
->header_location
.bdev
,
309 lc
->io_req
.bi_op
= REQ_OP_WRITE
;
310 lc
->io_req
.bi_op_flags
= WRITE_FLUSH
;
312 return dm_io(&lc
->io_req
, 1, &null_location
, NULL
);
315 static int read_header(struct log_c
*log
)
319 r
= rw_header(log
, READ
);
323 header_from_disk(&log
->header
, log
->disk_header
);
325 /* New log required? */
326 if (log
->sync
!= DEFAULTSYNC
|| log
->header
.magic
!= MIRROR_MAGIC
) {
327 log
->header
.magic
= MIRROR_MAGIC
;
328 log
->header
.version
= MIRROR_DISK_VERSION
;
329 log
->header
.nr_regions
= 0;
332 #ifdef __LITTLE_ENDIAN
333 if (log
->header
.version
== 1)
334 log
->header
.version
= 2;
337 if (log
->header
.version
!= MIRROR_DISK_VERSION
) {
338 DMWARN("incompatible disk log version");
345 static int _check_region_size(struct dm_target
*ti
, uint32_t region_size
)
347 if (region_size
< 2 || region_size
> ti
->len
)
350 if (!is_power_of_2(region_size
))
356 /*----------------------------------------------------------------
357 * core log constructor/destructor
359 * argv contains region_size followed optionally by [no]sync
360 *--------------------------------------------------------------*/
362 static int create_log_context(struct dm_dirty_log
*log
, struct dm_target
*ti
,
363 unsigned int argc
, char **argv
,
366 enum sync sync
= DEFAULTSYNC
;
369 uint32_t region_size
;
370 unsigned int region_count
;
371 size_t bitset_size
, buf_size
;
375 if (argc
< 1 || argc
> 2) {
376 DMWARN("wrong number of arguments to dirty region log");
381 if (!strcmp(argv
[1], "sync"))
383 else if (!strcmp(argv
[1], "nosync"))
386 DMWARN("unrecognised sync argument to "
387 "dirty region log: %s", argv
[1]);
392 if (sscanf(argv
[0], "%u%c", ®ion_size
, &dummy
) != 1 ||
393 !_check_region_size(ti
, region_size
)) {
394 DMWARN("invalid region size %s", argv
[0]);
398 region_count
= dm_sector_div_up(ti
->len
, region_size
);
400 lc
= kmalloc(sizeof(*lc
), GFP_KERNEL
);
402 DMWARN("couldn't allocate core log");
407 lc
->touched_dirtied
= 0;
408 lc
->touched_cleaned
= 0;
409 lc
->flush_failed
= 0;
410 lc
->region_size
= region_size
;
411 lc
->region_count
= region_count
;
415 * Work out how many "unsigned long"s we need to hold the bitset.
417 bitset_size
= dm_round_up(region_count
,
418 sizeof(*lc
->clean_bits
) << BYTE_SHIFT
);
419 bitset_size
>>= BYTE_SHIFT
;
421 lc
->bitset_uint32_count
= bitset_size
/ sizeof(*lc
->clean_bits
);
427 lc
->clean_bits
= vmalloc(bitset_size
);
428 if (!lc
->clean_bits
) {
429 DMWARN("couldn't allocate clean bitset");
433 lc
->disk_header
= NULL
;
436 lc
->log_dev_failed
= 0;
437 lc
->log_dev_flush_failed
= 0;
438 lc
->header_location
.bdev
= lc
->log_dev
->bdev
;
439 lc
->header_location
.sector
= 0;
442 * Buffer holds both header and bitset.
445 dm_round_up((LOG_OFFSET
<< SECTOR_SHIFT
) + bitset_size
,
446 bdev_logical_block_size(lc
->header_location
.
449 if (buf_size
> i_size_read(dev
->bdev
->bd_inode
)) {
450 DMWARN("log device %s too small: need %llu bytes",
451 dev
->name
, (unsigned long long)buf_size
);
456 lc
->header_location
.count
= buf_size
>> SECTOR_SHIFT
;
458 lc
->io_req
.mem
.type
= DM_IO_VMA
;
459 lc
->io_req
.notify
.fn
= NULL
;
460 lc
->io_req
.client
= dm_io_client_create();
461 if (IS_ERR(lc
->io_req
.client
)) {
462 r
= PTR_ERR(lc
->io_req
.client
);
463 DMWARN("couldn't allocate disk io client");
468 lc
->disk_header
= vmalloc(buf_size
);
469 if (!lc
->disk_header
) {
470 DMWARN("couldn't allocate disk log buffer");
471 dm_io_client_destroy(lc
->io_req
.client
);
476 lc
->io_req
.mem
.ptr
.vma
= lc
->disk_header
;
477 lc
->clean_bits
= (void *)lc
->disk_header
+
478 (LOG_OFFSET
<< SECTOR_SHIFT
);
481 memset(lc
->clean_bits
, -1, bitset_size
);
483 lc
->sync_bits
= vmalloc(bitset_size
);
484 if (!lc
->sync_bits
) {
485 DMWARN("couldn't allocate sync bitset");
487 vfree(lc
->clean_bits
);
489 dm_io_client_destroy(lc
->io_req
.client
);
490 vfree(lc
->disk_header
);
494 memset(lc
->sync_bits
, (sync
== NOSYNC
) ? -1 : 0, bitset_size
);
495 lc
->sync_count
= (sync
== NOSYNC
) ? region_count
: 0;
497 lc
->recovering_bits
= vzalloc(bitset_size
);
498 if (!lc
->recovering_bits
) {
499 DMWARN("couldn't allocate sync bitset");
500 vfree(lc
->sync_bits
);
502 vfree(lc
->clean_bits
);
504 dm_io_client_destroy(lc
->io_req
.client
);
505 vfree(lc
->disk_header
);
515 static int core_ctr(struct dm_dirty_log
*log
, struct dm_target
*ti
,
516 unsigned int argc
, char **argv
)
518 return create_log_context(log
, ti
, argc
, argv
, NULL
);
521 static void destroy_log_context(struct log_c
*lc
)
523 vfree(lc
->sync_bits
);
524 vfree(lc
->recovering_bits
);
528 static void core_dtr(struct dm_dirty_log
*log
)
530 struct log_c
*lc
= (struct log_c
*) log
->context
;
532 vfree(lc
->clean_bits
);
533 destroy_log_context(lc
);
536 /*----------------------------------------------------------------
537 * disk log constructor/destructor
539 * argv contains log_device region_size followed optionally by [no]sync
540 *--------------------------------------------------------------*/
541 static int disk_ctr(struct dm_dirty_log
*log
, struct dm_target
*ti
,
542 unsigned int argc
, char **argv
)
547 if (argc
< 2 || argc
> 3) {
548 DMWARN("wrong number of arguments to disk dirty region log");
552 r
= dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
), &dev
);
556 r
= create_log_context(log
, ti
, argc
- 1, argv
+ 1, dev
);
558 dm_put_device(ti
, dev
);
565 static void disk_dtr(struct dm_dirty_log
*log
)
567 struct log_c
*lc
= (struct log_c
*) log
->context
;
569 dm_put_device(lc
->ti
, lc
->log_dev
);
570 vfree(lc
->disk_header
);
571 dm_io_client_destroy(lc
->io_req
.client
);
572 destroy_log_context(lc
);
575 static void fail_log_device(struct log_c
*lc
)
577 if (lc
->log_dev_failed
)
580 lc
->log_dev_failed
= 1;
581 dm_table_event(lc
->ti
->table
);
584 static int disk_resume(struct dm_dirty_log
*log
)
588 struct log_c
*lc
= (struct log_c
*) log
->context
;
589 size_t size
= lc
->bitset_uint32_count
* sizeof(uint32_t);
591 /* read the disk header */
594 DMWARN("%s: Failed to read header on dirty region log device",
598 * If the log device cannot be read, we must assume
599 * all regions are out-of-sync. If we simply return
600 * here, the state will be uninitialized and could
601 * lead us to return 'in-sync' status for regions
602 * that are actually 'out-of-sync'.
604 lc
->header
.nr_regions
= 0;
607 /* set or clear any new bits -- device has grown */
608 if (lc
->sync
== NOSYNC
)
609 for (i
= lc
->header
.nr_regions
; i
< lc
->region_count
; i
++)
610 /* FIXME: amazingly inefficient */
611 log_set_bit(lc
, lc
->clean_bits
, i
);
613 for (i
= lc
->header
.nr_regions
; i
< lc
->region_count
; i
++)
614 /* FIXME: amazingly inefficient */
615 log_clear_bit(lc
, lc
->clean_bits
, i
);
617 /* clear any old bits -- device has shrunk */
618 for (i
= lc
->region_count
; i
% (sizeof(*lc
->clean_bits
) << BYTE_SHIFT
); i
++)
619 log_clear_bit(lc
, lc
->clean_bits
, i
);
621 /* copy clean across to sync */
622 memcpy(lc
->sync_bits
, lc
->clean_bits
, size
);
623 lc
->sync_count
= memweight(lc
->clean_bits
,
624 lc
->bitset_uint32_count
* sizeof(uint32_t));
627 /* set the correct number of regions in the header */
628 lc
->header
.nr_regions
= lc
->region_count
;
630 header_to_disk(&lc
->header
, lc
->disk_header
);
632 /* write the new header */
633 r
= rw_header(lc
, WRITE
);
635 r
= flush_header(lc
);
637 lc
->log_dev_flush_failed
= 1;
640 DMWARN("%s: Failed to write header on dirty region log device",
648 static uint32_t core_get_region_size(struct dm_dirty_log
*log
)
650 struct log_c
*lc
= (struct log_c
*) log
->context
;
651 return lc
->region_size
;
654 static int core_resume(struct dm_dirty_log
*log
)
656 struct log_c
*lc
= (struct log_c
*) log
->context
;
661 static int core_is_clean(struct dm_dirty_log
*log
, region_t region
)
663 struct log_c
*lc
= (struct log_c
*) log
->context
;
664 return log_test_bit(lc
->clean_bits
, region
);
667 static int core_in_sync(struct dm_dirty_log
*log
, region_t region
, int block
)
669 struct log_c
*lc
= (struct log_c
*) log
->context
;
670 return log_test_bit(lc
->sync_bits
, region
);
673 static int core_flush(struct dm_dirty_log
*log
)
679 static int disk_flush(struct dm_dirty_log
*log
)
682 struct log_c
*lc
= log
->context
;
684 /* only write if the log has changed */
685 if (!lc
->touched_cleaned
&& !lc
->touched_dirtied
)
688 if (lc
->touched_cleaned
&& log
->flush_callback_fn
&&
689 log
->flush_callback_fn(lc
->ti
)) {
691 * At this point it is impossible to determine which
692 * regions are clean and which are dirty (without
693 * re-reading the log off disk). So mark all of them
696 lc
->flush_failed
= 1;
697 for (i
= 0; i
< lc
->region_count
; i
++)
698 log_clear_bit(lc
, lc
->clean_bits
, i
);
701 r
= rw_header(lc
, WRITE
);
705 if (lc
->touched_dirtied
) {
706 r
= flush_header(lc
);
708 lc
->log_dev_flush_failed
= 1;
711 lc
->touched_dirtied
= 0;
713 lc
->touched_cleaned
= 0;
719 static void core_mark_region(struct dm_dirty_log
*log
, region_t region
)
721 struct log_c
*lc
= (struct log_c
*) log
->context
;
722 log_clear_bit(lc
, lc
->clean_bits
, region
);
725 static void core_clear_region(struct dm_dirty_log
*log
, region_t region
)
727 struct log_c
*lc
= (struct log_c
*) log
->context
;
728 if (likely(!lc
->flush_failed
))
729 log_set_bit(lc
, lc
->clean_bits
, region
);
732 static int core_get_resync_work(struct dm_dirty_log
*log
, region_t
*region
)
734 struct log_c
*lc
= (struct log_c
*) log
->context
;
736 if (lc
->sync_search
>= lc
->region_count
)
740 *region
= find_next_zero_bit_le(lc
->sync_bits
,
743 lc
->sync_search
= *region
+ 1;
745 if (*region
>= lc
->region_count
)
748 } while (log_test_bit(lc
->recovering_bits
, *region
));
750 log_set_bit(lc
, lc
->recovering_bits
, *region
);
754 static void core_set_region_sync(struct dm_dirty_log
*log
, region_t region
,
757 struct log_c
*lc
= (struct log_c
*) log
->context
;
759 log_clear_bit(lc
, lc
->recovering_bits
, region
);
761 log_set_bit(lc
, lc
->sync_bits
, region
);
763 } else if (log_test_bit(lc
->sync_bits
, region
)) {
765 log_clear_bit(lc
, lc
->sync_bits
, region
);
769 static region_t
core_get_sync_count(struct dm_dirty_log
*log
)
771 struct log_c
*lc
= (struct log_c
*) log
->context
;
773 return lc
->sync_count
;
776 #define DMEMIT_SYNC \
777 if (lc->sync != DEFAULTSYNC) \
778 DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
780 static int core_status(struct dm_dirty_log
*log
, status_type_t status
,
781 char *result
, unsigned int maxlen
)
784 struct log_c
*lc
= log
->context
;
787 case STATUSTYPE_INFO
:
788 DMEMIT("1 %s", log
->type
->name
);
791 case STATUSTYPE_TABLE
:
792 DMEMIT("%s %u %u ", log
->type
->name
,
793 lc
->sync
== DEFAULTSYNC
? 1 : 2, lc
->region_size
);
800 static int disk_status(struct dm_dirty_log
*log
, status_type_t status
,
801 char *result
, unsigned int maxlen
)
804 struct log_c
*lc
= log
->context
;
807 case STATUSTYPE_INFO
:
808 DMEMIT("3 %s %s %c", log
->type
->name
, lc
->log_dev
->name
,
809 lc
->log_dev_flush_failed
? 'F' :
810 lc
->log_dev_failed
? 'D' :
814 case STATUSTYPE_TABLE
:
815 DMEMIT("%s %u %s %u ", log
->type
->name
,
816 lc
->sync
== DEFAULTSYNC
? 2 : 3, lc
->log_dev
->name
,
824 static struct dm_dirty_log_type _core_type
= {
826 .module
= THIS_MODULE
,
829 .resume
= core_resume
,
830 .get_region_size
= core_get_region_size
,
831 .is_clean
= core_is_clean
,
832 .in_sync
= core_in_sync
,
834 .mark_region
= core_mark_region
,
835 .clear_region
= core_clear_region
,
836 .get_resync_work
= core_get_resync_work
,
837 .set_region_sync
= core_set_region_sync
,
838 .get_sync_count
= core_get_sync_count
,
839 .status
= core_status
,
842 static struct dm_dirty_log_type _disk_type
= {
844 .module
= THIS_MODULE
,
847 .postsuspend
= disk_flush
,
848 .resume
= disk_resume
,
849 .get_region_size
= core_get_region_size
,
850 .is_clean
= core_is_clean
,
851 .in_sync
= core_in_sync
,
853 .mark_region
= core_mark_region
,
854 .clear_region
= core_clear_region
,
855 .get_resync_work
= core_get_resync_work
,
856 .set_region_sync
= core_set_region_sync
,
857 .get_sync_count
= core_get_sync_count
,
858 .status
= disk_status
,
861 static int __init
dm_dirty_log_init(void)
865 r
= dm_dirty_log_type_register(&_core_type
);
867 DMWARN("couldn't register core log");
869 r
= dm_dirty_log_type_register(&_disk_type
);
871 DMWARN("couldn't register disk type");
872 dm_dirty_log_type_unregister(&_core_type
);
878 static void __exit
dm_dirty_log_exit(void)
880 dm_dirty_log_type_unregister(&_disk_type
);
881 dm_dirty_log_type_unregister(&_core_type
);
884 module_init(dm_dirty_log_init
);
885 module_exit(dm_dirty_log_exit
);
887 MODULE_DESCRIPTION(DM_NAME
" dirty region log");
888 MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
889 MODULE_LICENSE("GPL");