4 * Copyright (C) 2001-2002 Sistina Software (UK) Limited.
6 * This file is released under the GPL.
9 #include <linux/blkdev.h>
10 #include <linux/ctype.h>
11 #include <linux/device-mapper.h>
13 #include <linux/init.h>
14 #include <linux/kdev_t.h>
15 #include <linux/list.h>
16 #include <linux/mempool.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/vmalloc.h>
22 #include "dm-bio-list.h"
25 #define DM_MSG_PREFIX "snapshots"
28 * The percentage increment we will wake up users at
30 #define WAKE_UP_PERCENT 5
33 * kcopyd priority of snapshot operations
35 #define SNAPSHOT_COPY_PRIORITY 2
38 * Each snapshot reserves this many pages for io
40 #define SNAPSHOT_PAGES 256
42 struct workqueue_struct
*ksnapd
;
43 static void flush_queued_bios(struct work_struct
*work
);
45 struct pending_exception
{
49 * Origin buffers waiting for this to complete are held
52 struct bio_list origin_bios
;
53 struct bio_list snapshot_bios
;
56 * Short-term queue of pending exceptions prior to submission.
58 struct list_head list
;
61 * The primary pending_exception is the one that holds
62 * the ref_count and the list of origin_bios for a
63 * group of pending_exceptions. It is always last to get freed.
64 * These fields get set up when writing to the origin.
66 struct pending_exception
*primary_pe
;
69 * Number of pending_exceptions processing this chunk.
70 * When this drops to zero we must complete the origin bios.
71 * If incrementing or decrementing this, hold pe->snap->lock for
72 * the sibling concerned and not pe->primary_pe->snap->lock unless
77 /* Pointer back to snapshot context */
78 struct dm_snapshot
*snap
;
81 * 1 indicates the exception has already been sent to
88 * Hash table mapping origin volumes to lists of snapshots and
89 * a lock to protect it
91 static struct kmem_cache
*exception_cache
;
92 static struct kmem_cache
*pending_cache
;
93 static mempool_t
*pending_pool
;
96 * One of these per registered origin, held in the snapshot_origins hash
99 /* The origin device */
100 struct block_device
*bdev
;
102 struct list_head hash_list
;
104 /* List of snapshots for this origin */
105 struct list_head snapshots
;
109 * Size of the hash table for origin volumes. If we make this
110 * the size of the minors list then it should be nearly perfect
112 #define ORIGIN_HASH_SIZE 256
113 #define ORIGIN_MASK 0xFF
114 static struct list_head
*_origins
;
115 static struct rw_semaphore _origins_lock
;
117 static int init_origin_hash(void)
121 _origins
= kmalloc(ORIGIN_HASH_SIZE
* sizeof(struct list_head
),
124 DMERR("unable to allocate memory");
128 for (i
= 0; i
< ORIGIN_HASH_SIZE
; i
++)
129 INIT_LIST_HEAD(_origins
+ i
);
130 init_rwsem(&_origins_lock
);
135 static void exit_origin_hash(void)
140 static inline unsigned int origin_hash(struct block_device
*bdev
)
142 return bdev
->bd_dev
& ORIGIN_MASK
;
145 static struct origin
*__lookup_origin(struct block_device
*origin
)
147 struct list_head
*ol
;
150 ol
= &_origins
[origin_hash(origin
)];
151 list_for_each_entry (o
, ol
, hash_list
)
152 if (bdev_equal(o
->bdev
, origin
))
158 static void __insert_origin(struct origin
*o
)
160 struct list_head
*sl
= &_origins
[origin_hash(o
->bdev
)];
161 list_add_tail(&o
->hash_list
, sl
);
165 * Make a note of the snapshot and its origin so we can look it
166 * up when the origin has a write on it.
168 static int register_snapshot(struct dm_snapshot
*snap
)
171 struct block_device
*bdev
= snap
->origin
->bdev
;
173 down_write(&_origins_lock
);
174 o
= __lookup_origin(bdev
);
178 o
= kmalloc(sizeof(*o
), GFP_KERNEL
);
180 up_write(&_origins_lock
);
184 /* Initialise the struct */
185 INIT_LIST_HEAD(&o
->snapshots
);
191 list_add_tail(&snap
->list
, &o
->snapshots
);
193 up_write(&_origins_lock
);
197 static void unregister_snapshot(struct dm_snapshot
*s
)
201 down_write(&_origins_lock
);
202 o
= __lookup_origin(s
->origin
->bdev
);
205 if (list_empty(&o
->snapshots
)) {
206 list_del(&o
->hash_list
);
210 up_write(&_origins_lock
);
214 * Implementation of the exception hash tables.
216 static int init_exception_table(struct exception_table
*et
, uint32_t size
)
220 et
->hash_mask
= size
- 1;
221 et
->table
= dm_vcalloc(size
, sizeof(struct list_head
));
225 for (i
= 0; i
< size
; i
++)
226 INIT_LIST_HEAD(et
->table
+ i
);
231 static void exit_exception_table(struct exception_table
*et
, struct kmem_cache
*mem
)
233 struct list_head
*slot
;
234 struct exception
*ex
, *next
;
237 size
= et
->hash_mask
+ 1;
238 for (i
= 0; i
< size
; i
++) {
239 slot
= et
->table
+ i
;
241 list_for_each_entry_safe (ex
, next
, slot
, hash_list
)
242 kmem_cache_free(mem
, ex
);
248 static inline uint32_t exception_hash(struct exception_table
*et
, chunk_t chunk
)
250 return chunk
& et
->hash_mask
;
253 static void insert_exception(struct exception_table
*eh
, struct exception
*e
)
255 struct list_head
*l
= &eh
->table
[exception_hash(eh
, e
->old_chunk
)];
256 list_add(&e
->hash_list
, l
);
259 static inline void remove_exception(struct exception
*e
)
261 list_del(&e
->hash_list
);
265 * Return the exception data for a sector, or NULL if not
268 static struct exception
*lookup_exception(struct exception_table
*et
,
271 struct list_head
*slot
;
274 slot
= &et
->table
[exception_hash(et
, chunk
)];
275 list_for_each_entry (e
, slot
, hash_list
)
276 if (e
->old_chunk
== chunk
)
282 static inline struct exception
*alloc_exception(void)
286 e
= kmem_cache_alloc(exception_cache
, GFP_NOIO
);
288 e
= kmem_cache_alloc(exception_cache
, GFP_ATOMIC
);
293 static inline void free_exception(struct exception
*e
)
295 kmem_cache_free(exception_cache
, e
);
298 static inline struct pending_exception
*alloc_pending_exception(void)
300 return mempool_alloc(pending_pool
, GFP_NOIO
);
303 static inline void free_pending_exception(struct pending_exception
*pe
)
305 mempool_free(pe
, pending_pool
);
308 int dm_add_exception(struct dm_snapshot
*s
, chunk_t old
, chunk_t
new)
312 e
= alloc_exception();
318 insert_exception(&s
->complete
, e
);
325 static int calc_max_buckets(void)
327 /* use a fixed size of 2MB */
328 unsigned long mem
= 2 * 1024 * 1024;
329 mem
/= sizeof(struct list_head
);
335 * Rounds a number down to a power of 2.
337 static inline uint32_t round_down(uint32_t n
)
345 * Allocate room for a suitable hash table.
347 static int init_hash_tables(struct dm_snapshot
*s
)
349 sector_t hash_size
, cow_dev_size
, origin_dev_size
, max_buckets
;
352 * Calculate based on the size of the original volume or
355 cow_dev_size
= get_dev_size(s
->cow
->bdev
);
356 origin_dev_size
= get_dev_size(s
->origin
->bdev
);
357 max_buckets
= calc_max_buckets();
359 hash_size
= min(origin_dev_size
, cow_dev_size
) >> s
->chunk_shift
;
360 hash_size
= min(hash_size
, max_buckets
);
362 /* Round it down to a power of 2 */
363 hash_size
= round_down(hash_size
);
364 if (init_exception_table(&s
->complete
, hash_size
))
368 * Allocate hash table for in-flight exceptions
369 * Make this smaller than the real hash table
375 if (init_exception_table(&s
->pending
, hash_size
)) {
376 exit_exception_table(&s
->complete
, exception_cache
);
384 * Round a number up to the nearest 'size' boundary. size must
387 static inline ulong
round_up(ulong n
, ulong size
)
390 return (n
+ size
) & ~size
;
393 static int set_chunk_size(struct dm_snapshot
*s
, const char *chunk_size_arg
,
396 unsigned long chunk_size
;
399 chunk_size
= simple_strtoul(chunk_size_arg
, &value
, 10);
400 if (*chunk_size_arg
== '\0' || *value
!= '\0') {
401 *error
= "Invalid chunk size";
406 s
->chunk_size
= s
->chunk_mask
= s
->chunk_shift
= 0;
411 * Chunk size must be multiple of page size. Silently
412 * round up if it's not.
414 chunk_size
= round_up(chunk_size
, PAGE_SIZE
>> 9);
416 /* Check chunk_size is a power of 2 */
417 if (chunk_size
& (chunk_size
- 1)) {
418 *error
= "Chunk size is not a power of 2";
422 /* Validate the chunk size against the device block size */
423 if (chunk_size
% (bdev_hardsect_size(s
->cow
->bdev
) >> 9)) {
424 *error
= "Chunk size is not a multiple of device blocksize";
428 s
->chunk_size
= chunk_size
;
429 s
->chunk_mask
= chunk_size
- 1;
430 s
->chunk_shift
= ffs(chunk_size
) - 1;
436 * Construct a snapshot mapping: <origin_dev> <COW-dev> <p/n> <chunk-size>
438 static int snapshot_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
440 struct dm_snapshot
*s
;
447 ti
->error
= "requires exactly 4 arguments";
452 origin_path
= argv
[0];
454 persistent
= toupper(*argv
[2]);
456 if (persistent
!= 'P' && persistent
!= 'N') {
457 ti
->error
= "Persistent flag is not P or N";
462 s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
464 ti
->error
= "Cannot allocate snapshot context private "
470 r
= dm_get_device(ti
, origin_path
, 0, ti
->len
, FMODE_READ
, &s
->origin
);
472 ti
->error
= "Cannot get origin device";
476 r
= dm_get_device(ti
, cow_path
, 0, 0,
477 FMODE_READ
| FMODE_WRITE
, &s
->cow
);
479 dm_put_device(ti
, s
->origin
);
480 ti
->error
= "Cannot get COW device";
484 r
= set_chunk_size(s
, argv
[3], &ti
->error
);
488 s
->type
= persistent
;
493 init_rwsem(&s
->lock
);
494 spin_lock_init(&s
->pe_lock
);
495 s
->table
= ti
->table
;
497 /* Allocate hash table for COW data */
498 if (init_hash_tables(s
)) {
499 ti
->error
= "Unable to allocate hash table space";
506 if (persistent
== 'P')
507 r
= dm_create_persistent(&s
->store
);
509 r
= dm_create_transient(&s
->store
);
512 ti
->error
= "Couldn't create exception store";
517 r
= kcopyd_client_create(SNAPSHOT_PAGES
, &s
->kcopyd_client
);
519 ti
->error
= "Could not create kcopyd client";
523 /* Metadata must only be loaded into one table at once */
524 r
= s
->store
.read_metadata(&s
->store
);
526 ti
->error
= "Failed to read snapshot metadata";
530 bio_list_init(&s
->queued_bios
);
531 INIT_WORK(&s
->queued_bios_work
, flush_queued_bios
);
533 /* Add snapshot to the list of snapshots for this origin */
534 /* Exceptions aren't triggered till snapshot_resume() is called */
535 if (register_snapshot(s
)) {
537 ti
->error
= "Cannot register snapshot origin";
542 ti
->split_io
= s
->chunk_size
;
547 kcopyd_client_destroy(s
->kcopyd_client
);
550 s
->store
.destroy(&s
->store
);
553 exit_exception_table(&s
->pending
, pending_cache
);
554 exit_exception_table(&s
->complete
, exception_cache
);
557 dm_put_device(ti
, s
->cow
);
558 dm_put_device(ti
, s
->origin
);
567 static void snapshot_dtr(struct dm_target
*ti
)
569 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
571 flush_workqueue(ksnapd
);
573 /* Prevent further origin writes from using this snapshot. */
574 /* After this returns there can be no new kcopyd jobs. */
575 unregister_snapshot(s
);
577 kcopyd_client_destroy(s
->kcopyd_client
);
579 exit_exception_table(&s
->pending
, pending_cache
);
580 exit_exception_table(&s
->complete
, exception_cache
);
582 /* Deallocate memory used */
583 s
->store
.destroy(&s
->store
);
585 dm_put_device(ti
, s
->origin
);
586 dm_put_device(ti
, s
->cow
);
592 * Flush a list of buffers.
594 static void flush_bios(struct bio
*bio
)
601 generic_make_request(bio
);
606 static void flush_queued_bios(struct work_struct
*work
)
608 struct dm_snapshot
*s
=
609 container_of(work
, struct dm_snapshot
, queued_bios_work
);
610 struct bio
*queued_bios
;
613 spin_lock_irqsave(&s
->pe_lock
, flags
);
614 queued_bios
= bio_list_get(&s
->queued_bios
);
615 spin_unlock_irqrestore(&s
->pe_lock
, flags
);
617 flush_bios(queued_bios
);
621 * Error a list of buffers.
623 static void error_bios(struct bio
*bio
)
630 bio_io_error(bio
, bio
->bi_size
);
635 static void __invalidate_snapshot(struct dm_snapshot
*s
, int err
)
641 DMERR("Invalidating snapshot: Error reading/writing.");
642 else if (err
== -ENOMEM
)
643 DMERR("Invalidating snapshot: Unable to allocate exception.");
645 if (s
->store
.drop_snapshot
)
646 s
->store
.drop_snapshot(&s
->store
);
650 dm_table_event(s
->table
);
653 static void get_pending_exception(struct pending_exception
*pe
)
655 atomic_inc(&pe
->ref_count
);
658 static struct bio
*put_pending_exception(struct pending_exception
*pe
)
660 struct pending_exception
*primary_pe
;
661 struct bio
*origin_bios
= NULL
;
663 primary_pe
= pe
->primary_pe
;
666 * If this pe is involved in a write to the origin and
667 * it is the last sibling to complete then release
668 * the bios for the original write to the origin.
671 atomic_dec_and_test(&primary_pe
->ref_count
))
672 origin_bios
= bio_list_get(&primary_pe
->origin_bios
);
675 * Free the pe if it's not linked to an origin write or if
676 * it's not itself a primary pe.
678 if (!primary_pe
|| primary_pe
!= pe
)
679 free_pending_exception(pe
);
682 * Free the primary pe if nothing references it.
684 if (primary_pe
&& !atomic_read(&primary_pe
->ref_count
))
685 free_pending_exception(primary_pe
);
690 static void pending_complete(struct pending_exception
*pe
, int success
)
693 struct dm_snapshot
*s
= pe
->snap
;
694 struct bio
*origin_bios
= NULL
;
695 struct bio
*snapshot_bios
= NULL
;
699 /* Read/write error - snapshot is unusable */
700 down_write(&s
->lock
);
701 __invalidate_snapshot(s
, -EIO
);
706 e
= alloc_exception();
708 down_write(&s
->lock
);
709 __invalidate_snapshot(s
, -ENOMEM
);
715 down_write(&s
->lock
);
723 * Add a proper exception, and remove the
724 * in-flight exception from the list.
726 insert_exception(&s
->complete
, e
);
729 remove_exception(&pe
->e
);
730 snapshot_bios
= bio_list_get(&pe
->snapshot_bios
);
731 origin_bios
= put_pending_exception(pe
);
735 /* Submit any pending write bios */
737 error_bios(snapshot_bios
);
739 flush_bios(snapshot_bios
);
741 flush_bios(origin_bios
);
744 static void commit_callback(void *context
, int success
)
746 struct pending_exception
*pe
= (struct pending_exception
*) context
;
747 pending_complete(pe
, success
);
751 * Called when the copy I/O has finished. kcopyd actually runs
752 * this code so don't block.
754 static void copy_callback(int read_err
, unsigned int write_err
, void *context
)
756 struct pending_exception
*pe
= (struct pending_exception
*) context
;
757 struct dm_snapshot
*s
= pe
->snap
;
759 if (read_err
|| write_err
)
760 pending_complete(pe
, 0);
763 /* Update the metadata if we are persistent */
764 s
->store
.commit_exception(&s
->store
, &pe
->e
, commit_callback
,
769 * Dispatches the copy operation to kcopyd.
771 static void start_copy(struct pending_exception
*pe
)
773 struct dm_snapshot
*s
= pe
->snap
;
774 struct io_region src
, dest
;
775 struct block_device
*bdev
= s
->origin
->bdev
;
778 dev_size
= get_dev_size(bdev
);
781 src
.sector
= chunk_to_sector(s
, pe
->e
.old_chunk
);
782 src
.count
= min(s
->chunk_size
, dev_size
- src
.sector
);
784 dest
.bdev
= s
->cow
->bdev
;
785 dest
.sector
= chunk_to_sector(s
, pe
->e
.new_chunk
);
786 dest
.count
= src
.count
;
788 /* Hand over to kcopyd */
789 kcopyd_copy(s
->kcopyd_client
,
790 &src
, 1, &dest
, 0, copy_callback
, pe
);
794 * Looks to see if this snapshot already has a pending exception
795 * for this chunk, otherwise it allocates a new one and inserts
796 * it into the pending table.
798 * NOTE: a write lock must be held on snap->lock before calling
801 static struct pending_exception
*
802 __find_pending_exception(struct dm_snapshot
*s
, struct bio
*bio
)
805 struct pending_exception
*pe
;
806 chunk_t chunk
= sector_to_chunk(s
, bio
->bi_sector
);
809 * Is there a pending exception for this already ?
811 e
= lookup_exception(&s
->pending
, chunk
);
813 /* cast the exception to a pending exception */
814 pe
= container_of(e
, struct pending_exception
, e
);
819 * Create a new pending exception, we don't want
820 * to hold the lock while we do this.
823 pe
= alloc_pending_exception();
824 down_write(&s
->lock
);
827 free_pending_exception(pe
);
831 e
= lookup_exception(&s
->pending
, chunk
);
833 free_pending_exception(pe
);
834 pe
= container_of(e
, struct pending_exception
, e
);
838 pe
->e
.old_chunk
= chunk
;
839 bio_list_init(&pe
->origin_bios
);
840 bio_list_init(&pe
->snapshot_bios
);
841 pe
->primary_pe
= NULL
;
842 atomic_set(&pe
->ref_count
, 0);
846 if (s
->store
.prepare_exception(&s
->store
, &pe
->e
)) {
847 free_pending_exception(pe
);
851 get_pending_exception(pe
);
852 insert_exception(&s
->pending
, &pe
->e
);
858 static inline void remap_exception(struct dm_snapshot
*s
, struct exception
*e
,
861 bio
->bi_bdev
= s
->cow
->bdev
;
862 bio
->bi_sector
= chunk_to_sector(s
, e
->new_chunk
) +
863 (bio
->bi_sector
& s
->chunk_mask
);
866 static int snapshot_map(struct dm_target
*ti
, struct bio
*bio
,
867 union map_info
*map_context
)
870 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
873 struct pending_exception
*pe
= NULL
;
875 chunk
= sector_to_chunk(s
, bio
->bi_sector
);
877 /* Full snapshots are not usable */
878 /* To get here the table must be live so s->active is always set. */
882 if (unlikely(bio_barrier(bio
)))
885 /* FIXME: should only take write lock if we need
886 * to copy an exception */
887 down_write(&s
->lock
);
894 /* If the block is already remapped - use that, else remap it */
895 e
= lookup_exception(&s
->complete
, chunk
);
897 remap_exception(s
, e
, bio
);
902 * Write to snapshot - higher level takes care of RW/RO
903 * flags so we should only get this if we are
906 if (bio_rw(bio
) == WRITE
) {
907 pe
= __find_pending_exception(s
, bio
);
909 __invalidate_snapshot(s
, -ENOMEM
);
914 remap_exception(s
, &pe
->e
, bio
);
915 bio_list_add(&pe
->snapshot_bios
, bio
);
920 /* this is protected by snap->lock */
928 * FIXME: this read path scares me because we
929 * always use the origin when we have a pending
930 * exception. However I can't think of a
931 * situation where this is wrong - ejt.
933 bio
->bi_bdev
= s
->origin
->bdev
;
941 static void snapshot_resume(struct dm_target
*ti
)
943 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
945 down_write(&s
->lock
);
950 static int snapshot_status(struct dm_target
*ti
, status_type_t type
,
951 char *result
, unsigned int maxlen
)
953 struct dm_snapshot
*snap
= (struct dm_snapshot
*) ti
->private;
956 case STATUSTYPE_INFO
:
958 snprintf(result
, maxlen
, "Invalid");
960 if (snap
->store
.fraction_full
) {
961 sector_t numerator
, denominator
;
962 snap
->store
.fraction_full(&snap
->store
,
965 snprintf(result
, maxlen
, "%llu/%llu",
966 (unsigned long long)numerator
,
967 (unsigned long long)denominator
);
970 snprintf(result
, maxlen
, "Unknown");
974 case STATUSTYPE_TABLE
:
976 * kdevname returns a static pointer so we need
977 * to make private copies if the output is to
980 snprintf(result
, maxlen
, "%s %s %c %llu",
981 snap
->origin
->name
, snap
->cow
->name
,
983 (unsigned long long)snap
->chunk_size
);
990 /*-----------------------------------------------------------------
992 *---------------------------------------------------------------*/
993 static int __origin_write(struct list_head
*snapshots
, struct bio
*bio
)
995 int r
= 1, first
= 0;
996 struct dm_snapshot
*snap
;
998 struct pending_exception
*pe
, *next_pe
, *primary_pe
= NULL
;
1000 LIST_HEAD(pe_queue
);
1002 /* Do all the snapshots on this origin */
1003 list_for_each_entry (snap
, snapshots
, list
) {
1005 down_write(&snap
->lock
);
1007 /* Only deal with valid and active snapshots */
1008 if (!snap
->valid
|| !snap
->active
)
1011 /* Nothing to do if writing beyond end of snapshot */
1012 if (bio
->bi_sector
>= dm_table_get_size(snap
->table
))
1016 * Remember, different snapshots can have
1017 * different chunk sizes.
1019 chunk
= sector_to_chunk(snap
, bio
->bi_sector
);
1022 * Check exception table to see if block
1023 * is already remapped in this snapshot
1024 * and trigger an exception if not.
1026 * ref_count is initialised to 1 so pending_complete()
1027 * won't destroy the primary_pe while we're inside this loop.
1029 e
= lookup_exception(&snap
->complete
, chunk
);
1033 pe
= __find_pending_exception(snap
, bio
);
1035 __invalidate_snapshot(snap
, -ENOMEM
);
1041 * Either every pe here has same
1042 * primary_pe or none has one yet.
1045 primary_pe
= pe
->primary_pe
;
1051 bio_list_add(&primary_pe
->origin_bios
, bio
);
1056 if (!pe
->primary_pe
) {
1057 pe
->primary_pe
= primary_pe
;
1058 get_pending_exception(primary_pe
);
1063 list_add_tail(&pe
->list
, &pe_queue
);
1067 up_write(&snap
->lock
);
1074 * If this is the first time we're processing this chunk and
1075 * ref_count is now 1 it means all the pending exceptions
1076 * got completed while we were in the loop above, so it falls to
1077 * us here to remove the primary_pe and submit any origin_bios.
1080 if (first
&& atomic_dec_and_test(&primary_pe
->ref_count
)) {
1081 flush_bios(bio_list_get(&primary_pe
->origin_bios
));
1082 free_pending_exception(primary_pe
);
1083 /* If we got here, pe_queue is necessarily empty. */
1088 * Now that we have a complete pe list we can start the copying.
1090 list_for_each_entry_safe(pe
, next_pe
, &pe_queue
, list
)
1097 * Called on a write from the origin driver.
1099 static int do_origin(struct dm_dev
*origin
, struct bio
*bio
)
1104 down_read(&_origins_lock
);
1105 o
= __lookup_origin(origin
->bdev
);
1107 r
= __origin_write(&o
->snapshots
, bio
);
1108 up_read(&_origins_lock
);
1114 * Origin: maps a linear range of a device, with hooks for snapshotting.
1118 * Construct an origin mapping: <dev_path>
1119 * The context for an origin is merely a 'struct dm_dev *'
1120 * pointing to the real device.
1122 static int origin_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
1128 ti
->error
= "origin: incorrect number of arguments";
1132 r
= dm_get_device(ti
, argv
[0], 0, ti
->len
,
1133 dm_table_get_mode(ti
->table
), &dev
);
1135 ti
->error
= "Cannot get target device";
1143 static void origin_dtr(struct dm_target
*ti
)
1145 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1146 dm_put_device(ti
, dev
);
1149 static int origin_map(struct dm_target
*ti
, struct bio
*bio
,
1150 union map_info
*map_context
)
1152 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1153 bio
->bi_bdev
= dev
->bdev
;
1155 if (unlikely(bio_barrier(bio
)))
1158 /* Only tell snapshots if this is a write */
1159 return (bio_rw(bio
) == WRITE
) ? do_origin(dev
, bio
) : 1;
1162 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
1165 * Set the target "split_io" field to the minimum of all the snapshots'
1168 static void origin_resume(struct dm_target
*ti
)
1170 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1171 struct dm_snapshot
*snap
;
1173 chunk_t chunk_size
= 0;
1175 down_read(&_origins_lock
);
1176 o
= __lookup_origin(dev
->bdev
);
1178 list_for_each_entry (snap
, &o
->snapshots
, list
)
1179 chunk_size
= min_not_zero(chunk_size
, snap
->chunk_size
);
1180 up_read(&_origins_lock
);
1182 ti
->split_io
= chunk_size
;
1185 static int origin_status(struct dm_target
*ti
, status_type_t type
, char *result
,
1186 unsigned int maxlen
)
1188 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1191 case STATUSTYPE_INFO
:
1195 case STATUSTYPE_TABLE
:
1196 snprintf(result
, maxlen
, "%s", dev
->name
);
1203 static struct target_type origin_target
= {
1204 .name
= "snapshot-origin",
1205 .version
= {1, 5, 0},
1206 .module
= THIS_MODULE
,
1210 .resume
= origin_resume
,
1211 .status
= origin_status
,
1214 static struct target_type snapshot_target
= {
1216 .version
= {1, 5, 0},
1217 .module
= THIS_MODULE
,
1218 .ctr
= snapshot_ctr
,
1219 .dtr
= snapshot_dtr
,
1220 .map
= snapshot_map
,
1221 .resume
= snapshot_resume
,
1222 .status
= snapshot_status
,
1225 static int __init
dm_snapshot_init(void)
1229 r
= dm_register_target(&snapshot_target
);
1231 DMERR("snapshot target register failed %d", r
);
1235 r
= dm_register_target(&origin_target
);
1237 DMERR("Origin target register failed %d", r
);
1241 r
= init_origin_hash();
1243 DMERR("init_origin_hash failed.");
1247 exception_cache
= kmem_cache_create("dm-snapshot-ex",
1248 sizeof(struct exception
),
1249 __alignof__(struct exception
),
1251 if (!exception_cache
) {
1252 DMERR("Couldn't create exception cache.");
1258 kmem_cache_create("dm-snapshot-in",
1259 sizeof(struct pending_exception
),
1260 __alignof__(struct pending_exception
),
1262 if (!pending_cache
) {
1263 DMERR("Couldn't create pending cache.");
1268 pending_pool
= mempool_create_slab_pool(128, pending_cache
);
1269 if (!pending_pool
) {
1270 DMERR("Couldn't create pending pool.");
1275 ksnapd
= create_singlethread_workqueue("ksnapd");
1277 DMERR("Failed to create ksnapd workqueue.");
1285 mempool_destroy(pending_pool
);
1287 kmem_cache_destroy(pending_cache
);
1289 kmem_cache_destroy(exception_cache
);
1293 dm_unregister_target(&origin_target
);
1295 dm_unregister_target(&snapshot_target
);
1299 static void __exit
dm_snapshot_exit(void)
1303 destroy_workqueue(ksnapd
);
1305 r
= dm_unregister_target(&snapshot_target
);
1307 DMERR("snapshot unregister failed %d", r
);
1309 r
= dm_unregister_target(&origin_target
);
1311 DMERR("origin unregister failed %d", r
);
1314 mempool_destroy(pending_pool
);
1315 kmem_cache_destroy(pending_cache
);
1316 kmem_cache_destroy(exception_cache
);
1320 module_init(dm_snapshot_init
);
1321 module_exit(dm_snapshot_exit
);
1323 MODULE_DESCRIPTION(DM_NAME
" snapshot target");
1324 MODULE_AUTHOR("Joe Thornber");
1325 MODULE_LICENSE("GPL");