Merge commit 'gcl/merge' into merge

[karo-tx-linux.git] / drivers / md / dm-snap.c

diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 1498704467a7e12dcf33da9dd10ecd020e35efe5..ee8eb283650d6ccbe3a5a6e3d6a39ba347d6c35c 100644 (file)
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -71,7 +71,10 @@ struct dm_snapshot {
        /* List of snapshots per Origin */
        struct list_head list;
 
-       /* You can't use a snapshot if this is 0 (e.g. if full) */
+       /*
+        * You can't use a snapshot if this is 0 (e.g. if full).
+        * A snapshot-merge target never clears this.
+        */
        int valid;
 
        /* Origin writes don't trigger exceptions until this is set */
@@ -107,6 +110,21 @@ struct dm_snapshot {
        spinlock_t tracked_chunk_lock;
        struct hlist_head tracked_chunk_hash[DM_TRACKED_CHUNK_HASH_SIZE];
 
+       /*
+        * The merge operation failed if this flag is set.
+        * Failure modes are handled as follows:
+        * - I/O error reading the header
+        *      => don't load the target; abort.
+        * - Header does not have "valid" flag set
+        *      => use the origin; forget about the snapshot.
+        * - I/O error when reading exceptions
+        *      => don't load the target; abort.
+        *         (We can't use the intermediate origin state.)
+        * - I/O error while merging
+        *      => stop merging; set merge_failed; process I/O normally.
+        */
+       int merge_failed;
+
        /* Wait for events based on state_bits */
        unsigned long state_bits;
 
@@ -879,9 +897,10 @@ static void increment_pending_exceptions_done_count(void)
 
 static void snapshot_merge_next_chunks(struct dm_snapshot *s)
 {
-       int r;
+       int i, linear_chunks;
        chunk_t old_chunk, new_chunk;
        struct dm_io_region src, dest;
+       sector_t io_size;
        uint64_t previous_count;
 
        BUG_ON(!test_bit(RUNNING_MERGE, &s->state_bits));
@@ -896,20 +915,32 @@ static void snapshot_merge_next_chunks(struct dm_snapshot *s)
                goto shut;
        }
 
-       r = s->store->type->prepare_merge(s->store, &old_chunk, &new_chunk);
-       if (r <= 0) {
-               if (r < 0)
+       linear_chunks = s->store->type->prepare_merge(s->store, &old_chunk,
+                                                     &new_chunk);
+       if (linear_chunks <= 0) {
+               if (linear_chunks < 0) {
                        DMERR("Read error in exception store: "
                              "shutting down merge");
+                       down_write(&s->lock);
+                       s->merge_failed = 1;
+                       up_write(&s->lock);
+               }
                goto shut;
        }
 
-       /* TODO: use larger I/O size once we verify that kcopyd handles it */
+       /* Adjust old_chunk and new_chunk to reflect start of linear region */
+       old_chunk = old_chunk + 1 - linear_chunks;
+       new_chunk = new_chunk + 1 - linear_chunks;
+
+       /*
+        * Use one (potentially large) I/O to copy all 'linear_chunks'
+        * from the exception store to the origin
+        */
+       io_size = linear_chunks * s->store->chunk_size;
 
        dest.bdev = s->origin->bdev;
        dest.sector = chunk_to_sector(s->store, old_chunk);
-       dest.count = min((sector_t)s->store->chunk_size,
-                        get_dev_size(dest.bdev) - dest.sector);
+       dest.count = min(io_size, get_dev_size(dest.bdev) - dest.sector);
 
        src.bdev = s->cow->bdev;
        src.sector = chunk_to_sector(s->store, new_chunk);
@@ -925,7 +956,7 @@ static void snapshot_merge_next_chunks(struct dm_snapshot *s)
         * significant impact on performance.
         */
        previous_count = read_pending_exceptions_done_count();
-       while (origin_write_extent(s, dest.sector, s->store->chunk_size)) {
+       while (origin_write_extent(s, dest.sector, io_size)) {
                wait_event(_pending_exceptions_done,
                           (read_pending_exceptions_done_count() !=
                            previous_count));
@@ -935,10 +966,12 @@ static void snapshot_merge_next_chunks(struct dm_snapshot *s)
 
        down_write(&s->lock);
        s->first_merging_chunk = old_chunk;
-       s->num_merging_chunks = 1;
+       s->num_merging_chunks = linear_chunks;
        up_write(&s->lock);
 
-       __check_for_conflicting_io(s, old_chunk);
+       /* Wait until writes to all 'linear_chunks' drain */
+       for (i = 0; i < linear_chunks; i++)
+               __check_for_conflicting_io(s, old_chunk + i);
 
        dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, merge_callback, s);
        return;
@@ -977,6 +1010,7 @@ static void merge_callback(int read_err, unsigned long write_err, void *context)
 
 shut:
        down_write(&s->lock);
+       s->merge_failed = 1;
        b = __release_queued_bios_after_merge(s);
        up_write(&s->lock);
        error_bios(b);
@@ -1079,6 +1113,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        INIT_LIST_HEAD(&s->list);
        spin_lock_init(&s->pe_lock);
        s->state_bits = 0;
+       s->merge_failed = 0;
        s->first_merging_chunk = 0;
        s->num_merging_chunks = 0;
        bio_list_init(&s->bios_queued_during_merge);
@@ -1664,11 +1699,9 @@ static int snapshot_merge_map(struct dm_target *ti, struct bio *bio,
 
        down_write(&s->lock);
 
-       /* Full snapshots are not usable */
-       if (!s->valid) {
-               r = -EIO;
-               goto out_unlock;
-       }
+       /* Full merging snapshots are redirected to the origin */
+       if (!s->valid)
+               goto redirect_to_origin;
 
        /* If the block is already remapped - use that */
        e = dm_lookup_exception(&s->complete, chunk);
@@ -1691,6 +1724,7 @@ static int snapshot_merge_map(struct dm_target *ti, struct bio *bio,
                goto out_unlock;
        }
 
+redirect_to_origin:
        bio->bi_bdev = s->origin->bdev;
 
        if (bio_rw(bio) == WRITE) {
@@ -1824,6 +1858,8 @@ static int snapshot_status(struct dm_target *ti, status_type_t type,
 
                if (!snap->valid)
                        DMEMIT("Invalid");
+               else if (snap->merge_failed)
+                       DMEMIT("Merge failed");
                else {
                        if (snap->store->type->usage) {
                                sector_t total_sectors, sectors_allocated,