Merge branch 'for-2.6.28' of git://linux-nfs.org/~bfields/linux

[linux-2.6-omap-h63xx.git] / drivers / md / dm-snap.c

diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index f4fd0cee9c3d43f1c06ec288af0d7476bf4f4538..6c96db26b87c2ac4c3dd4ba6d29f99d60c24ac17 100644 (file)
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -96,7 +96,6 @@ struct dm_snap_pending_exception {
  */
 static struct kmem_cache *exception_cache;
 static struct kmem_cache *pending_cache;
-static mempool_t *pending_pool;
 
 struct dm_snap_tracked_chunk {
        struct hlist_node node;
@@ -230,19 +229,21 @@ static void __insert_origin(struct origin *o)
  */
 static int register_snapshot(struct dm_snapshot *snap)
 {
-       struct origin *o;
+       struct origin *o, *new_o;
        struct block_device *bdev = snap->origin->bdev;
 
+       new_o = kmalloc(sizeof(*new_o), GFP_KERNEL);
+       if (!new_o)
+               return -ENOMEM;
+
        down_write(&_origins_lock);
        o = __lookup_origin(bdev);
 
-       if (!o) {
+       if (o)
+               kfree(new_o);
+       else {
                /* New origin */
-               o = kmalloc(sizeof(*o), GFP_KERNEL);
-               if (!o) {
-                       up_write(&_origins_lock);
-                       return -ENOMEM;
-               }
+               o = new_o;
 
                /* Initialise the struct */
                INIT_LIST_HEAD(&o->snapshots);
@@ -364,14 +365,24 @@ static void free_exception(struct dm_snap_exception *e)
        kmem_cache_free(exception_cache, e);
 }
 
-static struct dm_snap_pending_exception *alloc_pending_exception(void)
+static struct dm_snap_pending_exception *alloc_pending_exception(struct dm_snapshot *s)
 {
-       return mempool_alloc(pending_pool, GFP_NOIO);
+       struct dm_snap_pending_exception *pe = mempool_alloc(s->pending_pool,
+                                                            GFP_NOIO);
+
+       atomic_inc(&s->pending_exceptions_count);
+       pe->snap = s;
+
+       return pe;
 }
 
 static void free_pending_exception(struct dm_snap_pending_exception *pe)
 {
-       mempool_free(pe, pending_pool);
+       struct dm_snapshot *s = pe->snap;
+
+       mempool_free(pe, s->pending_pool);
+       smp_mb__before_atomic_dec();
+       atomic_dec(&s->pending_exceptions_count);
 }
 
 static void insert_completed_exception(struct dm_snapshot *s,
@@ -596,7 +607,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
        s->valid = 1;
        s->active = 0;
-       s->last_percent = 0;
+       atomic_set(&s->pending_exceptions_count, 0);
        init_rwsem(&s->lock);
        spin_lock_init(&s->pe_lock);
        s->ti = ti;
@@ -627,12 +638,18 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad5;
        }
 
+       s->pending_pool = mempool_create_slab_pool(MIN_IOS, pending_cache);
+       if (!s->pending_pool) {
+               ti->error = "Could not allocate mempool for pending exceptions";
+               goto bad6;
+       }
+
        s->tracked_chunk_pool = mempool_create_slab_pool(MIN_IOS,
                                                         tracked_chunk_cache);
        if (!s->tracked_chunk_pool) {
                ti->error = "Could not allocate tracked_chunk mempool for "
                            "tracking reads";
-               goto bad6;
+               goto bad_tracked_chunk_pool;
        }
 
        for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
@@ -669,6 +686,9 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
  bad_load_and_register:
        mempool_destroy(s->tracked_chunk_pool);
 
+ bad_tracked_chunk_pool:
+       mempool_destroy(s->pending_pool);
+
  bad6:
        dm_kcopyd_client_destroy(s->kcopyd_client);
 
@@ -714,6 +734,14 @@ static void snapshot_dtr(struct dm_target *ti)
        /* After this returns there can be no new kcopyd jobs. */
        unregister_snapshot(s);
 
+       while (atomic_read(&s->pending_exceptions_count))
+               yield();
+       /*
+        * Ensure instructions in mempool_destroy aren't reordered
+        * before atomic_read.
+        */
+       smp_mb();
+
 #ifdef CONFIG_DM_DEBUG
        for (i = 0; i < DM_TRACKED_CHUNK_HASH_SIZE; i++)
                BUG_ON(!hlist_empty(&s->tracked_chunk_hash[i]));
@@ -723,6 +751,8 @@ static void snapshot_dtr(struct dm_target *ti)
 
        __free_exceptions(s);
 
+       mempool_destroy(s->pending_pool);
+
        dm_put_device(ti, s->origin);
        dm_put_device(ti, s->cow);
 
@@ -809,8 +839,10 @@ static struct bio *put_pending_exception(struct dm_snap_pending_exception *pe)
         * the bios for the original write to the origin.
         */
        if (primary_pe &&
-           atomic_dec_and_test(&primary_pe->ref_count))
+           atomic_dec_and_test(&primary_pe->ref_count)) {
                origin_bios = bio_list_get(&primary_pe->origin_bios);
+               free_pending_exception(primary_pe);
+       }
 
        /*
         * Free the pe if it's not linked to an origin write or if
@@ -819,12 +851,6 @@ static struct bio *put_pending_exception(struct dm_snap_pending_exception *pe)
        if (!primary_pe || primary_pe != pe)
                free_pending_exception(pe);
 
-       /*
-        * Free the primary pe if nothing references it.
-        */
-       if (primary_pe && !atomic_read(&primary_pe->ref_count))
-               free_pending_exception(primary_pe);
-
        return origin_bios;
 }
 
@@ -969,7 +995,7 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
         * to hold the lock while we do this.
         */
        up_write(&s->lock);
-       pe = alloc_pending_exception();
+       pe = alloc_pending_exception(s);
        down_write(&s->lock);
 
        if (!s->valid) {
@@ -989,7 +1015,6 @@ __find_pending_exception(struct dm_snapshot *s, struct bio *bio)
        bio_list_init(&pe->snapshot_bios);
        pe->primary_pe = NULL;
        atomic_set(&pe->ref_count, 0);
-       pe->snap = s;
        pe->started = 0;
 
        if (s->store.prepare_exception(&s->store, &pe->e)) {
@@ -1418,24 +1443,15 @@ static int __init dm_snapshot_init(void)
                goto bad5;
        }
 
-       pending_pool = mempool_create_slab_pool(128, pending_cache);
-       if (!pending_pool) {
-               DMERR("Couldn't create pending pool.");
-               r = -ENOMEM;
-               goto bad_pending_pool;
-       }
-
        ksnapd = create_singlethread_workqueue("ksnapd");
        if (!ksnapd) {
                DMERR("Failed to create ksnapd workqueue.");
                r = -ENOMEM;
-               goto bad6;
+               goto bad_pending_pool;
        }
 
        return 0;
 
-      bad6:
-       mempool_destroy(pending_pool);
       bad_pending_pool:
        kmem_cache_destroy(tracked_chunk_cache);
       bad5:
@@ -1466,7 +1482,6 @@ static void __exit dm_snapshot_exit(void)
                DMERR("origin unregister failed %d", r);
 
        exit_origin_hash();
-       mempool_destroy(pending_pool);
        kmem_cache_destroy(pending_cache);
        kmem_cache_destroy(exception_cache);
        kmem_cache_destroy(tracked_chunk_cache);