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 struct dm_dirty_log_internal
{
20 struct dm_dirty_log_type
*type
;
22 struct list_head list
;
26 static LIST_HEAD(_log_types
);
27 static DEFINE_SPINLOCK(_lock
);
29 static struct dm_dirty_log_internal
*__find_dirty_log_type(const char *name
)
31 struct dm_dirty_log_internal
*log_type
;
33 list_for_each_entry(log_type
, &_log_types
, list
)
34 if (!strcmp(name
, log_type
->type
->name
))
40 static struct dm_dirty_log_internal
*_get_dirty_log_type(const char *name
)
42 struct dm_dirty_log_internal
*log_type
;
46 log_type
= __find_dirty_log_type(name
);
48 if (!log_type
->use
&& !try_module_get(log_type
->type
->module
))
63 * Attempt to retrieve the dm_dirty_log_type by name. If not already
64 * available, attempt to load the appropriate module.
66 * Log modules are named "dm-log-" followed by the 'type_name'.
67 * Modules may contain multiple types.
68 * This function will first try the module "dm-log-<type_name>",
69 * then truncate 'type_name' on the last '-' and try again.
71 * For example, if type_name was "clustered-disk", it would search
72 * 'dm-log-clustered-disk' then 'dm-log-clustered'.
74 * Returns: dirty_log_type* on success, NULL on failure
76 static struct dm_dirty_log_type
*get_type(const char *type_name
)
78 char *p
, *type_name_dup
;
79 struct dm_dirty_log_internal
*log_type
;
84 log_type
= _get_dirty_log_type(type_name
);
86 return log_type
->type
;
88 type_name_dup
= kstrdup(type_name
, GFP_KERNEL
);
90 DMWARN("No memory left to attempt log module load for \"%s\"",
95 while (request_module("dm-log-%s", type_name_dup
) ||
96 !(log_type
= _get_dirty_log_type(type_name
))) {
97 p
= strrchr(type_name_dup
, '-');
104 DMWARN("Module for logging type \"%s\" not found.", type_name
);
106 kfree(type_name_dup
);
108 return log_type
? log_type
->type
: NULL
;
111 static void put_type(struct dm_dirty_log_type
*type
)
113 struct dm_dirty_log_internal
*log_type
;
119 log_type
= __find_dirty_log_type(type
->name
);
123 if (!--log_type
->use
)
124 module_put(type
->module
);
126 BUG_ON(log_type
->use
< 0);
132 static struct dm_dirty_log_internal
*_alloc_dirty_log_type(struct dm_dirty_log_type
*type
)
134 struct dm_dirty_log_internal
*log_type
= kzalloc(sizeof(*log_type
),
138 log_type
->type
= type
;
143 int dm_dirty_log_type_register(struct dm_dirty_log_type
*type
)
145 struct dm_dirty_log_internal
*log_type
= _alloc_dirty_log_type(type
);
152 if (!__find_dirty_log_type(type
->name
))
153 list_add(&log_type
->list
, &_log_types
);
162 EXPORT_SYMBOL(dm_dirty_log_type_register
);
164 int dm_dirty_log_type_unregister(struct dm_dirty_log_type
*type
)
166 struct dm_dirty_log_internal
*log_type
;
170 log_type
= __find_dirty_log_type(type
->name
);
181 list_del(&log_type
->list
);
188 EXPORT_SYMBOL(dm_dirty_log_type_unregister
);
190 struct dm_dirty_log
*dm_dirty_log_create(const char *type_name
,
191 struct dm_target
*ti
,
192 unsigned int argc
, char **argv
)
194 struct dm_dirty_log_type
*type
;
195 struct dm_dirty_log
*log
;
197 log
= kmalloc(sizeof(*log
), GFP_KERNEL
);
201 type
= get_type(type_name
);
208 if (type
->ctr(log
, ti
, argc
, argv
)) {
216 EXPORT_SYMBOL(dm_dirty_log_create
);
218 void dm_dirty_log_destroy(struct dm_dirty_log
*log
)
224 EXPORT_SYMBOL(dm_dirty_log_destroy
);
226 /*-----------------------------------------------------------------
227 * Persistent and core logs share a lot of their implementation.
228 * FIXME: need a reload method to be called from a resume
229 *---------------------------------------------------------------*/
231 * Magic for persistent mirrors: "MiRr"
233 #define MIRROR_MAGIC 0x4D695272
236 * The on-disk version of the metadata.
238 #define MIRROR_DISK_VERSION 2
245 * Simple, incrementing version. no backward
253 struct dm_target
*ti
;
255 uint32_t region_size
;
256 unsigned int region_count
;
259 unsigned bitset_uint32_count
;
260 uint32_t *clean_bits
;
262 uint32_t *recovering_bits
; /* FIXME: this seems excessive */
268 DEFAULTSYNC
, /* Synchronize if necessary */
269 NOSYNC
, /* Devices known to be already in sync */
270 FORCESYNC
, /* Force a sync to happen */
273 struct dm_io_request io_req
;
279 struct dm_dev
*log_dev
;
280 struct log_header header
;
282 struct dm_io_region header_location
;
283 struct log_header
*disk_header
;
287 * The touched member needs to be updated every time we access
288 * one of the bitsets.
290 static inline int log_test_bit(uint32_t *bs
, unsigned bit
)
292 return ext2_test_bit(bit
, (unsigned long *) bs
) ? 1 : 0;
295 static inline void log_set_bit(struct log_c
*l
,
296 uint32_t *bs
, unsigned bit
)
298 ext2_set_bit(bit
, (unsigned long *) bs
);
302 static inline void log_clear_bit(struct log_c
*l
,
303 uint32_t *bs
, unsigned bit
)
305 ext2_clear_bit(bit
, (unsigned long *) bs
);
309 /*----------------------------------------------------------------
311 *--------------------------------------------------------------*/
312 static void header_to_disk(struct log_header
*core
, struct log_header
*disk
)
314 disk
->magic
= cpu_to_le32(core
->magic
);
315 disk
->version
= cpu_to_le32(core
->version
);
316 disk
->nr_regions
= cpu_to_le64(core
->nr_regions
);
319 static void header_from_disk(struct log_header
*core
, struct log_header
*disk
)
321 core
->magic
= le32_to_cpu(disk
->magic
);
322 core
->version
= le32_to_cpu(disk
->version
);
323 core
->nr_regions
= le64_to_cpu(disk
->nr_regions
);
326 static int rw_header(struct log_c
*lc
, int rw
)
328 lc
->io_req
.bi_rw
= rw
;
330 return dm_io(&lc
->io_req
, 1, &lc
->header_location
, NULL
);
333 static int read_header(struct log_c
*log
)
337 r
= rw_header(log
, READ
);
341 header_from_disk(&log
->header
, log
->disk_header
);
343 /* New log required? */
344 if (log
->sync
!= DEFAULTSYNC
|| log
->header
.magic
!= MIRROR_MAGIC
) {
345 log
->header
.magic
= MIRROR_MAGIC
;
346 log
->header
.version
= MIRROR_DISK_VERSION
;
347 log
->header
.nr_regions
= 0;
350 #ifdef __LITTLE_ENDIAN
351 if (log
->header
.version
== 1)
352 log
->header
.version
= 2;
355 if (log
->header
.version
!= MIRROR_DISK_VERSION
) {
356 DMWARN("incompatible disk log version");
363 static int _check_region_size(struct dm_target
*ti
, uint32_t region_size
)
365 if (region_size
< 2 || region_size
> ti
->len
)
368 if (!is_power_of_2(region_size
))
374 /*----------------------------------------------------------------
375 * core log constructor/destructor
377 * argv contains region_size followed optionally by [no]sync
378 *--------------------------------------------------------------*/
380 static int create_log_context(struct dm_dirty_log
*log
, struct dm_target
*ti
,
381 unsigned int argc
, char **argv
,
384 enum sync sync
= DEFAULTSYNC
;
387 uint32_t region_size
;
388 unsigned int region_count
;
389 size_t bitset_size
, buf_size
;
392 if (argc
< 1 || argc
> 2) {
393 DMWARN("wrong number of arguments to dirty region log");
398 if (!strcmp(argv
[1], "sync"))
400 else if (!strcmp(argv
[1], "nosync"))
403 DMWARN("unrecognised sync argument to "
404 "dirty region log: %s", argv
[1]);
409 if (sscanf(argv
[0], "%u", ®ion_size
) != 1 ||
410 !_check_region_size(ti
, region_size
)) {
411 DMWARN("invalid region size %s", argv
[0]);
415 region_count
= dm_sector_div_up(ti
->len
, region_size
);
417 lc
= kmalloc(sizeof(*lc
), GFP_KERNEL
);
419 DMWARN("couldn't allocate core log");
425 lc
->region_size
= region_size
;
426 lc
->region_count
= region_count
;
430 * Work out how many "unsigned long"s we need to hold the bitset.
432 bitset_size
= dm_round_up(region_count
,
433 sizeof(*lc
->clean_bits
) << BYTE_SHIFT
);
434 bitset_size
>>= BYTE_SHIFT
;
436 lc
->bitset_uint32_count
= bitset_size
/ sizeof(*lc
->clean_bits
);
442 lc
->clean_bits
= vmalloc(bitset_size
);
443 if (!lc
->clean_bits
) {
444 DMWARN("couldn't allocate clean bitset");
448 lc
->disk_header
= NULL
;
451 lc
->log_dev_failed
= 0;
452 lc
->header_location
.bdev
= lc
->log_dev
->bdev
;
453 lc
->header_location
.sector
= 0;
456 * Buffer holds both header and bitset.
458 buf_size
= dm_round_up((LOG_OFFSET
<< SECTOR_SHIFT
) +
459 bitset_size
, ti
->limits
.hardsect_size
);
460 lc
->header_location
.count
= buf_size
>> SECTOR_SHIFT
;
462 lc
->io_req
.mem
.type
= DM_IO_VMA
;
463 lc
->io_req
.notify
.fn
= NULL
;
464 lc
->io_req
.client
= dm_io_client_create(dm_div_up(buf_size
,
466 if (IS_ERR(lc
->io_req
.client
)) {
467 r
= PTR_ERR(lc
->io_req
.client
);
468 DMWARN("couldn't allocate disk io client");
473 lc
->disk_header
= vmalloc(buf_size
);
474 if (!lc
->disk_header
) {
475 DMWARN("couldn't allocate disk log buffer");
476 dm_io_client_destroy(lc
->io_req
.client
);
481 lc
->io_req
.mem
.ptr
.vma
= lc
->disk_header
;
482 lc
->clean_bits
= (void *)lc
->disk_header
+
483 (LOG_OFFSET
<< SECTOR_SHIFT
);
486 memset(lc
->clean_bits
, -1, bitset_size
);
488 lc
->sync_bits
= vmalloc(bitset_size
);
489 if (!lc
->sync_bits
) {
490 DMWARN("couldn't allocate sync bitset");
492 vfree(lc
->clean_bits
);
494 dm_io_client_destroy(lc
->io_req
.client
);
495 vfree(lc
->disk_header
);
499 memset(lc
->sync_bits
, (sync
== NOSYNC
) ? -1 : 0, bitset_size
);
500 lc
->sync_count
= (sync
== NOSYNC
) ? region_count
: 0;
502 lc
->recovering_bits
= vmalloc(bitset_size
);
503 if (!lc
->recovering_bits
) {
504 DMWARN("couldn't allocate sync bitset");
505 vfree(lc
->sync_bits
);
507 vfree(lc
->clean_bits
);
509 dm_io_client_destroy(lc
->io_req
.client
);
510 vfree(lc
->disk_header
);
514 memset(lc
->recovering_bits
, 0, bitset_size
);
521 static int core_ctr(struct dm_dirty_log
*log
, struct dm_target
*ti
,
522 unsigned int argc
, char **argv
)
524 return create_log_context(log
, ti
, argc
, argv
, NULL
);
527 static void destroy_log_context(struct log_c
*lc
)
529 vfree(lc
->sync_bits
);
530 vfree(lc
->recovering_bits
);
534 static void core_dtr(struct dm_dirty_log
*log
)
536 struct log_c
*lc
= (struct log_c
*) log
->context
;
538 vfree(lc
->clean_bits
);
539 destroy_log_context(lc
);
542 /*----------------------------------------------------------------
543 * disk log constructor/destructor
545 * argv contains log_device region_size followed optionally by [no]sync
546 *--------------------------------------------------------------*/
547 static int disk_ctr(struct dm_dirty_log
*log
, struct dm_target
*ti
,
548 unsigned int argc
, char **argv
)
553 if (argc
< 2 || argc
> 3) {
554 DMWARN("wrong number of arguments to disk dirty region log");
558 r
= dm_get_device(ti
, argv
[0], 0, 0 /* FIXME */,
559 FMODE_READ
| FMODE_WRITE
, &dev
);
563 r
= create_log_context(log
, ti
, argc
- 1, argv
+ 1, dev
);
565 dm_put_device(ti
, dev
);
572 static void disk_dtr(struct dm_dirty_log
*log
)
574 struct log_c
*lc
= (struct log_c
*) log
->context
;
576 dm_put_device(lc
->ti
, lc
->log_dev
);
577 vfree(lc
->disk_header
);
578 dm_io_client_destroy(lc
->io_req
.client
);
579 destroy_log_context(lc
);
582 static int count_bits32(uint32_t *addr
, unsigned size
)
586 for (i
= 0; i
< size
; i
++) {
587 count
+= hweight32(*(addr
+i
));
592 static void fail_log_device(struct log_c
*lc
)
594 if (lc
->log_dev_failed
)
597 lc
->log_dev_failed
= 1;
598 dm_table_event(lc
->ti
->table
);
601 static int disk_resume(struct dm_dirty_log
*log
)
605 struct log_c
*lc
= (struct log_c
*) log
->context
;
606 size_t size
= lc
->bitset_uint32_count
* sizeof(uint32_t);
608 /* read the disk header */
611 DMWARN("%s: Failed to read header on dirty region log device",
615 * If the log device cannot be read, we must assume
616 * all regions are out-of-sync. If we simply return
617 * here, the state will be uninitialized and could
618 * lead us to return 'in-sync' status for regions
619 * that are actually 'out-of-sync'.
621 lc
->header
.nr_regions
= 0;
624 /* set or clear any new bits -- device has grown */
625 if (lc
->sync
== NOSYNC
)
626 for (i
= lc
->header
.nr_regions
; i
< lc
->region_count
; i
++)
627 /* FIXME: amazingly inefficient */
628 log_set_bit(lc
, lc
->clean_bits
, i
);
630 for (i
= lc
->header
.nr_regions
; i
< lc
->region_count
; i
++)
631 /* FIXME: amazingly inefficient */
632 log_clear_bit(lc
, lc
->clean_bits
, i
);
634 /* clear any old bits -- device has shrunk */
635 for (i
= lc
->region_count
; i
% (sizeof(*lc
->clean_bits
) << BYTE_SHIFT
); i
++)
636 log_clear_bit(lc
, lc
->clean_bits
, i
);
638 /* copy clean across to sync */
639 memcpy(lc
->sync_bits
, lc
->clean_bits
, size
);
640 lc
->sync_count
= count_bits32(lc
->clean_bits
, lc
->bitset_uint32_count
);
643 /* set the correct number of regions in the header */
644 lc
->header
.nr_regions
= lc
->region_count
;
646 header_to_disk(&lc
->header
, lc
->disk_header
);
648 /* write the new header */
649 r
= rw_header(lc
, WRITE
);
651 DMWARN("%s: Failed to write header on dirty region log device",
659 static uint32_t core_get_region_size(struct dm_dirty_log
*log
)
661 struct log_c
*lc
= (struct log_c
*) log
->context
;
662 return lc
->region_size
;
665 static int core_resume(struct dm_dirty_log
*log
)
667 struct log_c
*lc
= (struct log_c
*) log
->context
;
672 static int core_is_clean(struct dm_dirty_log
*log
, region_t region
)
674 struct log_c
*lc
= (struct log_c
*) log
->context
;
675 return log_test_bit(lc
->clean_bits
, region
);
678 static int core_in_sync(struct dm_dirty_log
*log
, region_t region
, int block
)
680 struct log_c
*lc
= (struct log_c
*) log
->context
;
681 return log_test_bit(lc
->sync_bits
, region
);
684 static int core_flush(struct dm_dirty_log
*log
)
690 static int disk_flush(struct dm_dirty_log
*log
)
693 struct log_c
*lc
= (struct log_c
*) log
->context
;
695 /* only write if the log has changed */
699 r
= rw_header(lc
, WRITE
);
708 static void core_mark_region(struct dm_dirty_log
*log
, region_t region
)
710 struct log_c
*lc
= (struct log_c
*) log
->context
;
711 log_clear_bit(lc
, lc
->clean_bits
, region
);
714 static void core_clear_region(struct dm_dirty_log
*log
, region_t region
)
716 struct log_c
*lc
= (struct log_c
*) log
->context
;
717 log_set_bit(lc
, lc
->clean_bits
, region
);
720 static int core_get_resync_work(struct dm_dirty_log
*log
, region_t
*region
)
722 struct log_c
*lc
= (struct log_c
*) log
->context
;
724 if (lc
->sync_search
>= lc
->region_count
)
728 *region
= ext2_find_next_zero_bit(
729 (unsigned long *) lc
->sync_bits
,
732 lc
->sync_search
= *region
+ 1;
734 if (*region
>= lc
->region_count
)
737 } while (log_test_bit(lc
->recovering_bits
, *region
));
739 log_set_bit(lc
, lc
->recovering_bits
, *region
);
743 static void core_set_region_sync(struct dm_dirty_log
*log
, region_t region
,
746 struct log_c
*lc
= (struct log_c
*) log
->context
;
748 log_clear_bit(lc
, lc
->recovering_bits
, region
);
750 log_set_bit(lc
, lc
->sync_bits
, region
);
752 } else if (log_test_bit(lc
->sync_bits
, region
)) {
754 log_clear_bit(lc
, lc
->sync_bits
, region
);
758 static region_t
core_get_sync_count(struct dm_dirty_log
*log
)
760 struct log_c
*lc
= (struct log_c
*) log
->context
;
762 return lc
->sync_count
;
765 #define DMEMIT_SYNC \
766 if (lc->sync != DEFAULTSYNC) \
767 DMEMIT("%ssync ", lc->sync == NOSYNC ? "no" : "")
769 static int core_status(struct dm_dirty_log
*log
, status_type_t status
,
770 char *result
, unsigned int maxlen
)
773 struct log_c
*lc
= log
->context
;
776 case STATUSTYPE_INFO
:
777 DMEMIT("1 %s", log
->type
->name
);
780 case STATUSTYPE_TABLE
:
781 DMEMIT("%s %u %u ", log
->type
->name
,
782 lc
->sync
== DEFAULTSYNC
? 1 : 2, lc
->region_size
);
789 static int disk_status(struct dm_dirty_log
*log
, status_type_t status
,
790 char *result
, unsigned int maxlen
)
793 struct log_c
*lc
= log
->context
;
796 case STATUSTYPE_INFO
:
797 DMEMIT("3 %s %s %c", log
->type
->name
, lc
->log_dev
->name
,
798 lc
->log_dev_failed
? 'D' : 'A');
801 case STATUSTYPE_TABLE
:
802 DMEMIT("%s %u %s %u ", log
->type
->name
,
803 lc
->sync
== DEFAULTSYNC
? 2 : 3, lc
->log_dev
->name
,
811 static struct dm_dirty_log_type _core_type
= {
813 .module
= THIS_MODULE
,
816 .resume
= core_resume
,
817 .get_region_size
= core_get_region_size
,
818 .is_clean
= core_is_clean
,
819 .in_sync
= core_in_sync
,
821 .mark_region
= core_mark_region
,
822 .clear_region
= core_clear_region
,
823 .get_resync_work
= core_get_resync_work
,
824 .set_region_sync
= core_set_region_sync
,
825 .get_sync_count
= core_get_sync_count
,
826 .status
= core_status
,
829 static struct dm_dirty_log_type _disk_type
= {
831 .module
= THIS_MODULE
,
834 .postsuspend
= disk_flush
,
835 .resume
= disk_resume
,
836 .get_region_size
= core_get_region_size
,
837 .is_clean
= core_is_clean
,
838 .in_sync
= core_in_sync
,
840 .mark_region
= core_mark_region
,
841 .clear_region
= core_clear_region
,
842 .get_resync_work
= core_get_resync_work
,
843 .set_region_sync
= core_set_region_sync
,
844 .get_sync_count
= core_get_sync_count
,
845 .status
= disk_status
,
848 static int __init
dm_dirty_log_init(void)
852 r
= dm_dirty_log_type_register(&_core_type
);
854 DMWARN("couldn't register core log");
856 r
= dm_dirty_log_type_register(&_disk_type
);
858 DMWARN("couldn't register disk type");
859 dm_dirty_log_type_unregister(&_core_type
);
865 static void __exit
dm_dirty_log_exit(void)
867 dm_dirty_log_type_unregister(&_disk_type
);
868 dm_dirty_log_type_unregister(&_core_type
);
871 module_init(dm_dirty_log_init
);
872 module_exit(dm_dirty_log_exit
);
874 MODULE_DESCRIPTION(DM_NAME
" dirty region log");
875 MODULE_AUTHOR("Joe Thornber, Heinz Mauelshagen <dm-devel@redhat.com>");
876 MODULE_LICENSE("GPL");