Changeset 18879 for src/linux/universal/linux-3.3/drivers/md/dm-thin.c

Timestamp:

03/31/12 01:43:19 (15 months ago)

Author:

BrainSlayer

Message:

update kernels

File:

• src/linux/universal/linux-3.3/drivers/md/dm-thin.c (modified) (6 diffs)

src/linux/universal/linux-3.3/drivers/md/dm-thin.c

@@ -125 +125 @@
         struct bio_prison *prison;
         struct cell_key key;
-        unsigned count;
+        struct bio *holder;
         struct bio_list bios;
 };
@@ -221 +221 @@
  * cells will be unlocked even if the calling thread is blocked.
  *
- * Returns the number of entries in the cell prior to the new addition
- * or < 0 on failure.
+ * Returns 1 if the cell was already held, 0 if @inmate is the new holder.
  */
 static int bio_detain(struct bio_prison *prison, struct cell_key *key,
                       struct bio *inmate, struct cell **ref)
 {
-        int r;
+        int r = 1;
         unsigned long flags;
         uint32_t hash = hash_key(prison, key);
-        struct cell *uninitialized_var(cell), *cell2 = NULL;
+        struct cell *cell, *cell2;
 
         BUG_ON(hash > prison->nr_buckets);
 
         spin_lock_irqsave(&prison->lock, flags);
+
         cell = __search_bucket(prison->cells + hash, key);
-
-        if (!cell) {
-                /*
-                 * Allocate a new cell
-                 */
-                spin_unlock_irqrestore(&prison->lock, flags);
-                cell2 = mempool_alloc(prison->cell_pool, GFP_NOIO);
-                spin_lock_irqsave(&prison->lock, flags);
-
-                /*
-                 * We've been unlocked, so we have to double check that
-                 * nobody else has inserted this cell in the meantime.
-                 */
-                cell = __search_bucket(prison->cells + hash, key);
-
-                if (!cell) {
-                        cell = cell2;
-                        cell2 = NULL;
-
-                        cell->prison = prison;
-                        memcpy(&cell->key, key, sizeof(cell->key));
-                        cell->count = 0;
-                        bio_list_init(&cell->bios);
-                        hlist_add_head(&cell->list, prison->cells + hash);
-                }
-        }
-
-        r = cell->count++;
-        bio_list_add(&cell->bios, inmate);
+        if (cell) {
+                bio_list_add(&cell->bios, inmate);
+                goto out;
+        }
+
+        /*
+         * Allocate a new cell
+         */
         spin_unlock_irqrestore(&prison->lock, flags);
-
-        if (cell2)
+        cell2 = mempool_alloc(prison->cell_pool, GFP_NOIO);
+        spin_lock_irqsave(&prison->lock, flags);
+
+        /*
+         * We've been unlocked, so we have to double check that
+         * nobody else has inserted this cell in the meantime.
+         */
+        cell = __search_bucket(prison->cells + hash, key);
+        if (cell) {
                 mempool_free(cell2, prison->cell_pool);
+                bio_list_add(&cell->bios, inmate);
+                goto out;
+        }
+
+        /*
+         * Use new cell.
+         */
+        cell = cell2;
+
+        cell->prison = prison;
+        memcpy(&cell->key, key, sizeof(cell->key));
+        cell->holder = inmate;
+        bio_list_init(&cell->bios);
+        hlist_add_head(&cell->list, prison->cells + hash);
+
+        r = 0;
+
+out:
+        spin_unlock_irqrestore(&prison->lock, flags);
 
         *ref = cell;
@@ -284 +289 @@
         hlist_del(&cell->list);
 
-        if (inmates)
-                bio_list_merge(inmates, &cell->bios);
+        bio_list_add(inmates, cell->holder);
+        bio_list_merge(inmates, &cell->bios);
 
         mempool_free(cell, prison->cell_pool);
@@ -306 +311 @@
  * a sanity check.
  */
+static void __cell_release_singleton(struct cell *cell, struct bio *bio)
+{
+        hlist_del(&cell->list);
+        BUG_ON(cell->holder != bio);
+        BUG_ON(!bio_list_empty(&cell->bios));
+}
+
 static void cell_release_singleton(struct cell *cell, struct bio *bio)
 {
+        unsigned long flags;
         struct bio_prison *prison = cell->prison;
-        struct bio_list bios;
-        struct bio *b;
+
+        spin_lock_irqsave(&prison->lock, flags);
+        __cell_release_singleton(cell, bio);
+        spin_unlock_irqrestore(&prison->lock, flags);
+}
+
+/*
+ * Sometimes we don't want the holder, just the additional bios.
+ */
+static void __cell_release_no_holder(struct cell *cell, struct bio_list *inmates)
+{
+        struct bio_prison *prison = cell->prison;
+
+        hlist_del(&cell->list);
+        bio_list_merge(inmates, &cell->bios);
+
+        mempool_free(cell, prison->cell_pool);
+}
+
+static void cell_release_no_holder(struct cell *cell, struct bio_list *inmates)
+{
         unsigned long flags;
-
-        bio_list_init(&bios);
+        struct bio_prison *prison = cell->prison;
 
         spin_lock_irqsave(&prison->lock, flags);
-        __cell_release(cell, &bios);
+        __cell_release_no_holder(cell, inmates);
         spin_unlock_irqrestore(&prison->lock, flags);
-
-        b = bio_list_pop(&bios);
-        BUG_ON(b != bio);
-        BUG_ON(!bio_list_empty(&bios));
 }
 
@@ -801 +828 @@
  * a write bio that covers the block and has already been processed.
  */
-static void cell_defer_except(struct thin_c *tc, struct cell *cell,
-                              struct bio *exception)
+static void cell_defer_except(struct thin_c *tc, struct cell *cell)
 {
         struct bio_list bios;
-        struct bio *bio;
         struct pool *pool = tc->pool;
         unsigned long flags;
 
         bio_list_init(&bios);
-        cell_release(cell, &bios);
 
         spin_lock_irqsave(&pool->lock, flags);
-        while ((bio = bio_list_pop(&bios)))
-                if (bio != exception)
-                        bio_list_add(&pool->deferred_bios, bio);
+        cell_release_no_holder(cell, &pool->deferred_bios);
         spin_unlock_irqrestore(&pool->lock, flags);
 
@@ -855 +877 @@
          */
         if (bio) {
-                cell_defer_except(tc, m->cell, bio);
+                cell_defer_except(tc, m->cell);
                 bio_endio(bio, 0);
         } else