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 static 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 DMWARN("Snapshot is marked invalid.");
533 bio_list_init(&s
->queued_bios
);
534 INIT_WORK(&s
->queued_bios_work
, flush_queued_bios
);
536 /* Add snapshot to the list of snapshots for this origin */
537 /* Exceptions aren't triggered till snapshot_resume() is called */
538 if (register_snapshot(s
)) {
540 ti
->error
= "Cannot register snapshot origin";
545 ti
->split_io
= s
->chunk_size
;
550 kcopyd_client_destroy(s
->kcopyd_client
);
553 s
->store
.destroy(&s
->store
);
556 exit_exception_table(&s
->pending
, pending_cache
);
557 exit_exception_table(&s
->complete
, exception_cache
);
560 dm_put_device(ti
, s
->cow
);
561 dm_put_device(ti
, s
->origin
);
570 static void __free_exceptions(struct dm_snapshot
*s
)
572 kcopyd_client_destroy(s
->kcopyd_client
);
573 s
->kcopyd_client
= NULL
;
575 exit_exception_table(&s
->pending
, pending_cache
);
576 exit_exception_table(&s
->complete
, exception_cache
);
578 s
->store
.destroy(&s
->store
);
581 static void snapshot_dtr(struct dm_target
*ti
)
583 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
585 flush_workqueue(ksnapd
);
587 /* Prevent further origin writes from using this snapshot. */
588 /* After this returns there can be no new kcopyd jobs. */
589 unregister_snapshot(s
);
591 __free_exceptions(s
);
593 dm_put_device(ti
, s
->origin
);
594 dm_put_device(ti
, s
->cow
);
600 * Flush a list of buffers.
602 static void flush_bios(struct bio
*bio
)
609 generic_make_request(bio
);
614 static void flush_queued_bios(struct work_struct
*work
)
616 struct dm_snapshot
*s
=
617 container_of(work
, struct dm_snapshot
, queued_bios_work
);
618 struct bio
*queued_bios
;
621 spin_lock_irqsave(&s
->pe_lock
, flags
);
622 queued_bios
= bio_list_get(&s
->queued_bios
);
623 spin_unlock_irqrestore(&s
->pe_lock
, flags
);
625 flush_bios(queued_bios
);
629 * Error a list of buffers.
631 static void error_bios(struct bio
*bio
)
638 bio_io_error(bio
, bio
->bi_size
);
643 static void __invalidate_snapshot(struct dm_snapshot
*s
, int err
)
649 DMERR("Invalidating snapshot: Error reading/writing.");
650 else if (err
== -ENOMEM
)
651 DMERR("Invalidating snapshot: Unable to allocate exception.");
653 if (s
->store
.drop_snapshot
)
654 s
->store
.drop_snapshot(&s
->store
);
658 dm_table_event(s
->table
);
661 static void get_pending_exception(struct pending_exception
*pe
)
663 atomic_inc(&pe
->ref_count
);
666 static struct bio
*put_pending_exception(struct pending_exception
*pe
)
668 struct pending_exception
*primary_pe
;
669 struct bio
*origin_bios
= NULL
;
671 primary_pe
= pe
->primary_pe
;
674 * If this pe is involved in a write to the origin and
675 * it is the last sibling to complete then release
676 * the bios for the original write to the origin.
679 atomic_dec_and_test(&primary_pe
->ref_count
))
680 origin_bios
= bio_list_get(&primary_pe
->origin_bios
);
683 * Free the pe if it's not linked to an origin write or if
684 * it's not itself a primary pe.
686 if (!primary_pe
|| primary_pe
!= pe
)
687 free_pending_exception(pe
);
690 * Free the primary pe if nothing references it.
692 if (primary_pe
&& !atomic_read(&primary_pe
->ref_count
))
693 free_pending_exception(primary_pe
);
698 static void pending_complete(struct pending_exception
*pe
, int success
)
701 struct dm_snapshot
*s
= pe
->snap
;
702 struct bio
*origin_bios
= NULL
;
703 struct bio
*snapshot_bios
= NULL
;
707 /* Read/write error - snapshot is unusable */
708 down_write(&s
->lock
);
709 __invalidate_snapshot(s
, -EIO
);
714 e
= alloc_exception();
716 down_write(&s
->lock
);
717 __invalidate_snapshot(s
, -ENOMEM
);
723 down_write(&s
->lock
);
731 * Add a proper exception, and remove the
732 * in-flight exception from the list.
734 insert_exception(&s
->complete
, e
);
737 remove_exception(&pe
->e
);
738 snapshot_bios
= bio_list_get(&pe
->snapshot_bios
);
739 origin_bios
= put_pending_exception(pe
);
743 /* Submit any pending write bios */
745 error_bios(snapshot_bios
);
747 flush_bios(snapshot_bios
);
749 flush_bios(origin_bios
);
752 static void commit_callback(void *context
, int success
)
754 struct pending_exception
*pe
= (struct pending_exception
*) context
;
755 pending_complete(pe
, success
);
759 * Called when the copy I/O has finished. kcopyd actually runs
760 * this code so don't block.
762 static void copy_callback(int read_err
, unsigned int write_err
, void *context
)
764 struct pending_exception
*pe
= (struct pending_exception
*) context
;
765 struct dm_snapshot
*s
= pe
->snap
;
767 if (read_err
|| write_err
)
768 pending_complete(pe
, 0);
771 /* Update the metadata if we are persistent */
772 s
->store
.commit_exception(&s
->store
, &pe
->e
, commit_callback
,
777 * Dispatches the copy operation to kcopyd.
779 static void start_copy(struct pending_exception
*pe
)
781 struct dm_snapshot
*s
= pe
->snap
;
782 struct io_region src
, dest
;
783 struct block_device
*bdev
= s
->origin
->bdev
;
786 dev_size
= get_dev_size(bdev
);
789 src
.sector
= chunk_to_sector(s
, pe
->e
.old_chunk
);
790 src
.count
= min(s
->chunk_size
, dev_size
- src
.sector
);
792 dest
.bdev
= s
->cow
->bdev
;
793 dest
.sector
= chunk_to_sector(s
, pe
->e
.new_chunk
);
794 dest
.count
= src
.count
;
796 /* Hand over to kcopyd */
797 kcopyd_copy(s
->kcopyd_client
,
798 &src
, 1, &dest
, 0, copy_callback
, pe
);
802 * Looks to see if this snapshot already has a pending exception
803 * for this chunk, otherwise it allocates a new one and inserts
804 * it into the pending table.
806 * NOTE: a write lock must be held on snap->lock before calling
809 static struct pending_exception
*
810 __find_pending_exception(struct dm_snapshot
*s
, struct bio
*bio
)
813 struct pending_exception
*pe
;
814 chunk_t chunk
= sector_to_chunk(s
, bio
->bi_sector
);
817 * Is there a pending exception for this already ?
819 e
= lookup_exception(&s
->pending
, chunk
);
821 /* cast the exception to a pending exception */
822 pe
= container_of(e
, struct pending_exception
, e
);
827 * Create a new pending exception, we don't want
828 * to hold the lock while we do this.
831 pe
= alloc_pending_exception();
832 down_write(&s
->lock
);
835 free_pending_exception(pe
);
839 e
= lookup_exception(&s
->pending
, chunk
);
841 free_pending_exception(pe
);
842 pe
= container_of(e
, struct pending_exception
, e
);
846 pe
->e
.old_chunk
= chunk
;
847 bio_list_init(&pe
->origin_bios
);
848 bio_list_init(&pe
->snapshot_bios
);
849 pe
->primary_pe
= NULL
;
850 atomic_set(&pe
->ref_count
, 0);
854 if (s
->store
.prepare_exception(&s
->store
, &pe
->e
)) {
855 free_pending_exception(pe
);
859 get_pending_exception(pe
);
860 insert_exception(&s
->pending
, &pe
->e
);
866 static inline void remap_exception(struct dm_snapshot
*s
, struct exception
*e
,
869 bio
->bi_bdev
= s
->cow
->bdev
;
870 bio
->bi_sector
= chunk_to_sector(s
, e
->new_chunk
) +
871 (bio
->bi_sector
& s
->chunk_mask
);
874 static int snapshot_map(struct dm_target
*ti
, struct bio
*bio
,
875 union map_info
*map_context
)
878 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
879 int r
= DM_MAPIO_REMAPPED
;
881 struct pending_exception
*pe
= NULL
;
883 chunk
= sector_to_chunk(s
, bio
->bi_sector
);
885 /* Full snapshots are not usable */
886 /* To get here the table must be live so s->active is always set. */
890 /* FIXME: should only take write lock if we need
891 * to copy an exception */
892 down_write(&s
->lock
);
899 /* If the block is already remapped - use that, else remap it */
900 e
= lookup_exception(&s
->complete
, chunk
);
902 remap_exception(s
, e
, bio
);
907 * Write to snapshot - higher level takes care of RW/RO
908 * flags so we should only get this if we are
911 if (bio_rw(bio
) == WRITE
) {
912 pe
= __find_pending_exception(s
, bio
);
914 __invalidate_snapshot(s
, -ENOMEM
);
919 remap_exception(s
, &pe
->e
, bio
);
920 bio_list_add(&pe
->snapshot_bios
, bio
);
922 r
= DM_MAPIO_SUBMITTED
;
925 /* this is protected by snap->lock */
933 * FIXME: this read path scares me because we
934 * always use the origin when we have a pending
935 * exception. However I can't think of a
936 * situation where this is wrong - ejt.
938 bio
->bi_bdev
= s
->origin
->bdev
;
946 static void snapshot_resume(struct dm_target
*ti
)
948 struct dm_snapshot
*s
= (struct dm_snapshot
*) ti
->private;
950 down_write(&s
->lock
);
955 static int snapshot_status(struct dm_target
*ti
, status_type_t type
,
956 char *result
, unsigned int maxlen
)
958 struct dm_snapshot
*snap
= (struct dm_snapshot
*) ti
->private;
961 case STATUSTYPE_INFO
:
963 snprintf(result
, maxlen
, "Invalid");
965 if (snap
->store
.fraction_full
) {
966 sector_t numerator
, denominator
;
967 snap
->store
.fraction_full(&snap
->store
,
970 snprintf(result
, maxlen
, "%llu/%llu",
971 (unsigned long long)numerator
,
972 (unsigned long long)denominator
);
975 snprintf(result
, maxlen
, "Unknown");
979 case STATUSTYPE_TABLE
:
981 * kdevname returns a static pointer so we need
982 * to make private copies if the output is to
985 snprintf(result
, maxlen
, "%s %s %c %llu",
986 snap
->origin
->name
, snap
->cow
->name
,
988 (unsigned long long)snap
->chunk_size
);
995 /*-----------------------------------------------------------------
997 *---------------------------------------------------------------*/
998 static int __origin_write(struct list_head
*snapshots
, struct bio
*bio
)
1000 int r
= DM_MAPIO_REMAPPED
, first
= 0;
1001 struct dm_snapshot
*snap
;
1002 struct exception
*e
;
1003 struct pending_exception
*pe
, *next_pe
, *primary_pe
= NULL
;
1005 LIST_HEAD(pe_queue
);
1007 /* Do all the snapshots on this origin */
1008 list_for_each_entry (snap
, snapshots
, list
) {
1010 down_write(&snap
->lock
);
1012 /* Only deal with valid and active snapshots */
1013 if (!snap
->valid
|| !snap
->active
)
1016 /* Nothing to do if writing beyond end of snapshot */
1017 if (bio
->bi_sector
>= dm_table_get_size(snap
->table
))
1021 * Remember, different snapshots can have
1022 * different chunk sizes.
1024 chunk
= sector_to_chunk(snap
, bio
->bi_sector
);
1027 * Check exception table to see if block
1028 * is already remapped in this snapshot
1029 * and trigger an exception if not.
1031 * ref_count is initialised to 1 so pending_complete()
1032 * won't destroy the primary_pe while we're inside this loop.
1034 e
= lookup_exception(&snap
->complete
, chunk
);
1038 pe
= __find_pending_exception(snap
, bio
);
1040 __invalidate_snapshot(snap
, -ENOMEM
);
1046 * Either every pe here has same
1047 * primary_pe or none has one yet.
1050 primary_pe
= pe
->primary_pe
;
1056 bio_list_add(&primary_pe
->origin_bios
, bio
);
1058 r
= DM_MAPIO_SUBMITTED
;
1061 if (!pe
->primary_pe
) {
1062 pe
->primary_pe
= primary_pe
;
1063 get_pending_exception(primary_pe
);
1068 list_add_tail(&pe
->list
, &pe_queue
);
1072 up_write(&snap
->lock
);
1079 * If this is the first time we're processing this chunk and
1080 * ref_count is now 1 it means all the pending exceptions
1081 * got completed while we were in the loop above, so it falls to
1082 * us here to remove the primary_pe and submit any origin_bios.
1085 if (first
&& atomic_dec_and_test(&primary_pe
->ref_count
)) {
1086 flush_bios(bio_list_get(&primary_pe
->origin_bios
));
1087 free_pending_exception(primary_pe
);
1088 /* If we got here, pe_queue is necessarily empty. */
1093 * Now that we have a complete pe list we can start the copying.
1095 list_for_each_entry_safe(pe
, next_pe
, &pe_queue
, list
)
1102 * Called on a write from the origin driver.
1104 static int do_origin(struct dm_dev
*origin
, struct bio
*bio
)
1107 int r
= DM_MAPIO_REMAPPED
;
1109 down_read(&_origins_lock
);
1110 o
= __lookup_origin(origin
->bdev
);
1112 r
= __origin_write(&o
->snapshots
, bio
);
1113 up_read(&_origins_lock
);
1119 * Origin: maps a linear range of a device, with hooks for snapshotting.
1123 * Construct an origin mapping: <dev_path>
1124 * The context for an origin is merely a 'struct dm_dev *'
1125 * pointing to the real device.
1127 static int origin_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
1133 ti
->error
= "origin: incorrect number of arguments";
1137 r
= dm_get_device(ti
, argv
[0], 0, ti
->len
,
1138 dm_table_get_mode(ti
->table
), &dev
);
1140 ti
->error
= "Cannot get target device";
1148 static void origin_dtr(struct dm_target
*ti
)
1150 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1151 dm_put_device(ti
, dev
);
1154 static int origin_map(struct dm_target
*ti
, struct bio
*bio
,
1155 union map_info
*map_context
)
1157 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1158 bio
->bi_bdev
= dev
->bdev
;
1160 /* Only tell snapshots if this is a write */
1161 return (bio_rw(bio
) == WRITE
) ? do_origin(dev
, bio
) : DM_MAPIO_REMAPPED
;
1164 #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
1167 * Set the target "split_io" field to the minimum of all the snapshots'
1170 static void origin_resume(struct dm_target
*ti
)
1172 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1173 struct dm_snapshot
*snap
;
1175 chunk_t chunk_size
= 0;
1177 down_read(&_origins_lock
);
1178 o
= __lookup_origin(dev
->bdev
);
1180 list_for_each_entry (snap
, &o
->snapshots
, list
)
1181 chunk_size
= min_not_zero(chunk_size
, snap
->chunk_size
);
1182 up_read(&_origins_lock
);
1184 ti
->split_io
= chunk_size
;
1187 static int origin_status(struct dm_target
*ti
, status_type_t type
, char *result
,
1188 unsigned int maxlen
)
1190 struct dm_dev
*dev
= (struct dm_dev
*) ti
->private;
1193 case STATUSTYPE_INFO
:
1197 case STATUSTYPE_TABLE
:
1198 snprintf(result
, maxlen
, "%s", dev
->name
);
1205 static struct target_type origin_target
= {
1206 .name
= "snapshot-origin",
1207 .version
= {1, 5, 0},
1208 .module
= THIS_MODULE
,
1212 .resume
= origin_resume
,
1213 .status
= origin_status
,
1216 static struct target_type snapshot_target
= {
1218 .version
= {1, 5, 0},
1219 .module
= THIS_MODULE
,
1220 .ctr
= snapshot_ctr
,
1221 .dtr
= snapshot_dtr
,
1222 .map
= snapshot_map
,
1223 .resume
= snapshot_resume
,
1224 .status
= snapshot_status
,
1227 static int __init
dm_snapshot_init(void)
1231 r
= dm_register_target(&snapshot_target
);
1233 DMERR("snapshot target register failed %d", r
);
1237 r
= dm_register_target(&origin_target
);
1239 DMERR("Origin target register failed %d", r
);
1243 r
= init_origin_hash();
1245 DMERR("init_origin_hash failed.");
1249 exception_cache
= kmem_cache_create("dm-snapshot-ex",
1250 sizeof(struct exception
),
1251 __alignof__(struct exception
),
1253 if (!exception_cache
) {
1254 DMERR("Couldn't create exception cache.");
1260 kmem_cache_create("dm-snapshot-in",
1261 sizeof(struct pending_exception
),
1262 __alignof__(struct pending_exception
),
1264 if (!pending_cache
) {
1265 DMERR("Couldn't create pending cache.");
1270 pending_pool
= mempool_create_slab_pool(128, pending_cache
);
1271 if (!pending_pool
) {
1272 DMERR("Couldn't create pending pool.");
1277 ksnapd
= create_singlethread_workqueue("ksnapd");
1279 DMERR("Failed to create ksnapd workqueue.");
1287 mempool_destroy(pending_pool
);
1289 kmem_cache_destroy(pending_cache
);
1291 kmem_cache_destroy(exception_cache
);
1295 dm_unregister_target(&origin_target
);
1297 dm_unregister_target(&snapshot_target
);
1301 static void __exit
dm_snapshot_exit(void)
1305 destroy_workqueue(ksnapd
);
1307 r
= dm_unregister_target(&snapshot_target
);
1309 DMERR("snapshot unregister failed %d", r
);
1311 r
= dm_unregister_target(&origin_target
);
1313 DMERR("origin unregister failed %d", r
);
1316 mempool_destroy(pending_pool
);
1317 kmem_cache_destroy(pending_cache
);
1318 kmem_cache_destroy(exception_cache
);
1322 module_init(dm_snapshot_init
);
1323 module_exit(dm_snapshot_exit
);
1325 MODULE_DESCRIPTION(DM_NAME
" snapshot target");
1326 MODULE_AUTHOR("Joe Thornber");
1327 MODULE_LICENSE("GPL");