5 files changed, 95 insertions, 104 deletions

diff --git a/fs/bio-integrity.c b/fs/bio-integrity.c
index fe2b1aa2464e..31c46a241bac 100644
--- a/fs/bio-integrity.c
+++ b/fs/bio-integrity.c
@@ -26,23 +26,23 @@
 #include <linux/workqueue.h>
 
 static struct kmem_cache *bio_integrity_slab __read_mostly;
+static mempool_t *bio_integrity_pool;
+static struct bio_set *integrity_bio_set;
 static struct workqueue_struct *kintegrityd_wq;
 
 /**
- * bio_integrity_alloc_bioset - Allocate integrity payload and attach it to bio
+ * bio_integrity_alloc - Allocate integrity payload and attach it to bio
  * @bio:        bio to attach integrity metadata to
  * @gfp_mask:   Memory allocation mask
  * @nr_vecs:    Number of integrity metadata scatter-gather elements
- * @bs:         bio_set to allocate from
  *
  * Description: This function prepares a bio for attaching integrity
  * metadata.  nr_vecs specifies the maximum number of pages containing
  * integrity metadata that can be attached.
  */
-struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio,
-                                                         gfp_t gfp_mask,
-                                                         unsigned int nr_vecs,
-                                                         struct bio_set *bs)
+struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
+                                                  gfp_t gfp_mask,
+                                                  unsigned int nr_vecs)
 {
         struct bio_integrity_payload *bip;
         struct bio_vec *iv;
@@ -50,7 +50,7 @@ struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio,
 
         BUG_ON(bio == NULL);
 
-        bip = mempool_alloc(bs->bio_integrity_pool, gfp_mask);
+        bip = mempool_alloc(bio_integrity_pool, gfp_mask);
         if (unlikely(bip == NULL)) {
                 printk(KERN_ERR "%s: could not alloc bip\n", __func__);
                 return NULL;
@@ -58,10 +58,10 @@ struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio,
 
         memset(bip, 0, sizeof(*bip));
 
-        iv = bvec_alloc_bs(gfp_mask, nr_vecs, &idx, bs);
+        iv = bvec_alloc_bs(gfp_mask, nr_vecs, &idx, integrity_bio_set);
         if (unlikely(iv == NULL)) {
                 printk(KERN_ERR "%s: could not alloc bip_vec\n", __func__);
-                mempool_free(bip, bs->bio_integrity_pool);
+                mempool_free(bip, bio_integrity_pool);
                 return NULL;
         }
 
@@ -72,35 +72,16 @@ struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *bio,
 
         return bip;
 }
-EXPORT_SYMBOL(bio_integrity_alloc_bioset);
-
-/**
- * bio_integrity_alloc - Allocate integrity payload and attach it to bio
- * @bio:        bio to attach integrity metadata to
- * @gfp_mask:   Memory allocation mask
- * @nr_vecs:    Number of integrity metadata scatter-gather elements
- *
- * Description: This function prepares a bio for attaching integrity
- * metadata.  nr_vecs specifies the maximum number of pages containing
- * integrity metadata that can be attached.
- */
-struct bio_integrity_payload *bio_integrity_alloc(struct bio *bio,
-                                                  gfp_t gfp_mask,
-                                                  unsigned int nr_vecs)
-{
-        return bio_integrity_alloc_bioset(bio, gfp_mask, nr_vecs, fs_bio_set);
-}
 EXPORT_SYMBOL(bio_integrity_alloc);
 
 /**
  * bio_integrity_free - Free bio integrity payload
  * @bio:        bio containing bip to be freed
- * @bs:         bio_set this bio was allocated from
  *
  * Description: Used to free the integrity portion of a bio. Usually
  * called from bio_free().
  */
-void bio_integrity_free(struct bio *bio, struct bio_set *bs)
+void bio_integrity_free(struct bio *bio)
 {
         struct bio_integrity_payload *bip = bio->bi_integrity;
 
@@ -111,8 +92,8 @@ void bio_integrity_free(struct bio *bio, struct bio_set *bs)
             && bip->bip_buf != NULL)
                 kfree(bip->bip_buf);
 
-        bvec_free_bs(bs, bip->bip_vec, bip->bip_pool);
-        mempool_free(bip, bs->bio_integrity_pool);
+        bvec_free_bs(integrity_bio_set, bip->bip_vec, bip->bip_pool);
+        mempool_free(bip, bio_integrity_pool);
 
         bio->bi_integrity = NULL;
 }
@@ -686,19 +667,17 @@ EXPORT_SYMBOL(bio_integrity_split);
  * @bio:        New bio
  * @bio_src:    Original bio
  * @gfp_mask:   Memory allocation mask
- * @bs:         bio_set to allocate bip from
  *
  * Description: Called to allocate a bip when cloning a bio
  */
-int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
-                        gfp_t gfp_mask, struct bio_set *bs)
+int bio_integrity_clone(struct bio *bio, struct bio *bio_src, gfp_t gfp_mask)
 {
         struct bio_integrity_payload *bip_src = bio_src->bi_integrity;
         struct bio_integrity_payload *bip;
 
         BUG_ON(bip_src == NULL);
 
-        bip = bio_integrity_alloc_bioset(bio, gfp_mask, bip_src->bip_vcnt, bs);
+        bip = bio_integrity_alloc(bio, gfp_mask, bip_src->bip_vcnt);
 
         if (bip == NULL)
                 return -EIO;
@@ -714,37 +693,25 @@ int bio_integrity_clone(struct bio *bio, struct bio *bio_src,
 }
 EXPORT_SYMBOL(bio_integrity_clone);
 
-int bioset_integrity_create(struct bio_set *bs, int pool_size)
+static int __init bio_integrity_init(void)
 {
-        bs->bio_integrity_pool = mempool_create_slab_pool(pool_size,
-                                                          bio_integrity_slab);
-        if (!bs->bio_integrity_pool)
-                return -1;
-
-        return 0;
-}
-EXPORT_SYMBOL(bioset_integrity_create);
+        kintegrityd_wq = create_workqueue("kintegrityd");
 
-void bioset_integrity_free(struct bio_set *bs)
-{
-        if (bs->bio_integrity_pool)
-                mempool_destroy(bs->bio_integrity_pool);
-}
-EXPORT_SYMBOL(bioset_integrity_free);
+        if (!kintegrityd_wq)
+                panic("Failed to create kintegrityd\n");
 
-void __init bio_integrity_init_slab(void)
-{
         bio_integrity_slab = KMEM_CACHE(bio_integrity_payload,
                                         SLAB_HWCACHE_ALIGN|SLAB_PANIC);
-}
 
-static int __init integrity_init(void)
-{
-        kintegrityd_wq = create_workqueue("kintegrityd");
+        bio_integrity_pool = mempool_create_slab_pool(BIO_POOL_SIZE,
+                                                      bio_integrity_slab);
+        if (!bio_integrity_pool)
+                panic("bio_integrity: can't allocate bip pool\n");
 
-        if (!kintegrityd_wq)
-                panic("Failed to create kintegrityd\n");
+        integrity_bio_set = bioset_create(BIO_POOL_SIZE, 0);
+        if (!integrity_bio_set)
+                panic("bio_integrity: can't allocate bio_set\n");
 
         return 0;
 }
-subsys_initcall(integrity_init);
+subsys_initcall(bio_integrity_init);
diff --git a/fs/bio.c b/fs/bio.c
index d4f06327c810..a040cde7f6fd 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -248,7 +248,7 @@ void bio_free(struct bio *bio, struct bio_set *bs)
                 bvec_free_bs(bs, bio->bi_io_vec, BIO_POOL_IDX(bio));
 
         if (bio_integrity(bio))
-                bio_integrity_free(bio, bs);
+                bio_integrity_free(bio);
 
         /*
          * If we have front padding, adjust the bio pointer before freeing
@@ -301,48 +301,51 @@ void bio_init(struct bio *bio)
  **/
 struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 {
+        struct bio_vec *bvl = NULL;
         struct bio *bio = NULL;
-        void *uninitialized_var(p);
+        unsigned long idx = 0;
+        void *p = NULL;
 
         if (bs) {
                 p = mempool_alloc(bs->bio_pool, gfp_mask);
-
-                if (p)
-                        bio = p + bs->front_pad;
-        } else
+                if (!p)
+                        goto err;
+                bio = p + bs->front_pad;
+        } else {
                 bio = kmalloc(sizeof(*bio), gfp_mask);
+                if (!bio)
+                        goto err;
+        }
 
-        if (likely(bio)) {
-                struct bio_vec *bvl = NULL;
-
-                bio_init(bio);
-                if (likely(nr_iovecs)) {
-                        unsigned long uninitialized_var(idx);
-
-                        if (nr_iovecs <= BIO_INLINE_VECS) {
-                                idx = 0;
-                                bvl = bio->bi_inline_vecs;
-                                nr_iovecs = BIO_INLINE_VECS;
-                        } else {
-                                bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx,
-                                                        bs);
-                                nr_iovecs = bvec_nr_vecs(idx);
-                        }
-                        if (unlikely(!bvl)) {
-                                if (bs)
-                                        mempool_free(p, bs->bio_pool);
-                                else
-                                        kfree(bio);
-                                bio = NULL;
-                                goto out;
-                        }
-                        bio->bi_flags |= idx << BIO_POOL_OFFSET;
-                        bio->bi_max_vecs = nr_iovecs;
-                }
-                bio->bi_io_vec = bvl;
+        bio_init(bio);
+
+        if (unlikely(!nr_iovecs))
+                goto out_set;
+
+        if (nr_iovecs <= BIO_INLINE_VECS) {
+                bvl = bio->bi_inline_vecs;
+                nr_iovecs = BIO_INLINE_VECS;
+        } else {
+                bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx, bs);
+                if (unlikely(!bvl))
+                        goto err_free;
+
+                nr_iovecs = bvec_nr_vecs(idx);
         }
-out:
+        bio->bi_flags |= idx << BIO_POOL_OFFSET;
+        bio->bi_max_vecs = nr_iovecs;
+out_set:
+        bio->bi_io_vec = bvl;
+
         return bio;
+
+err_free:
+        if (bs)
+                mempool_free(p, bs->bio_pool);
+        else
+                kfree(bio);
+err:
+        return NULL;
 }
 
 struct bio *bio_alloc(gfp_t gfp_mask, int nr_iovecs)
@@ -463,7 +466,7 @@ struct bio *bio_clone(struct bio *bio, gfp_t gfp_mask)
         if (bio_integrity(bio)) {
                 int ret;
 
-                ret = bio_integrity_clone(b, bio, gfp_mask, fs_bio_set);
+                ret = bio_integrity_clone(b, bio, gfp_mask);
 
                 if (ret < 0) {
                         bio_put(b);
@@ -1526,7 +1529,6 @@ void bioset_free(struct bio_set *bs)
         if (bs->bio_pool)
                 mempool_destroy(bs->bio_pool);
 
-        bioset_integrity_free(bs);
         biovec_free_pools(bs);
         bio_put_slab(bs);
 
@@ -1567,9 +1569,6 @@ struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
         if (!bs->bio_pool)
                 goto bad;
 
-        if (bioset_integrity_create(bs, pool_size))
-                goto bad;
-
         if (!biovec_create_pools(bs, pool_size))
                 return bs;
 
@@ -1586,6 +1585,13 @@ static void __init biovec_init_slabs(void)
                 int size;
                 struct biovec_slab *bvs = bvec_slabs + i;
 
+#ifndef CONFIG_BLK_DEV_INTEGRITY
+                if (bvs->nr_vecs <= BIO_INLINE_VECS) {
+                        bvs->slab = NULL;
+                        continue;
+                }
+#endif
+
                 size = bvs->nr_vecs * sizeof(struct bio_vec);
                 bvs->slab = kmem_cache_create(bvs->name, size, 0,
                                 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
@@ -1600,7 +1606,6 @@ static int __init init_bio(void)
         if (!bio_slabs)
                 panic("bio: can't allocate bios\n");
 
-        bio_integrity_init_slab();
         biovec_init_slabs();
 
         fs_bio_set = bioset_create(BIO_POOL_SIZE, 0);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 3e18175248e0..6ec80c0fc869 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2385,7 +2385,7 @@ void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
         unsigned long thresh = 32 * 1024 * 1024;
         tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
 
-        if (current_is_pdflush() || current->flags & PF_MEMALLOC)
+        if (current->flags & PF_MEMALLOC)
                 return;
 
         num_dirty = count_range_bits(tree, &start, (u64)-1,
diff --git a/fs/super.c b/fs/super.c
index 6ce501447ada..dd4acb158b5e 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -674,7 +674,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
         return 0;
 }
 
-static void do_emergency_remount(unsigned long foo)
+static void do_emergency_remount(struct work_struct *work)
 {
         struct super_block *sb;
 
@@ -697,12 +697,19 @@ static void do_emergency_remount(unsigned long foo)
                 spin_lock(&sb_lock);
         }
         spin_unlock(&sb_lock);
+        kfree(work);
         printk("Emergency Remount complete\n");
 }
 
 void emergency_remount(void)
 {
-        pdflush_operation(do_emergency_remount, 0);
+        struct work_struct *work;
+
+        work = kmalloc(sizeof(*work), GFP_ATOMIC);
+        if (work) {
+                INIT_WORK(work, do_emergency_remount);
+                schedule_work(work);
+        }
 }
 
 /*
diff --git a/fs/sync.c b/fs/sync.c
index a16d53e5fe9d..ec95a69d17aa 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -42,9 +42,21 @@ SYSCALL_DEFINE0(sync)
         return 0;
 }
 
+static void do_sync_work(struct work_struct *work)
+{
+        do_sync(0);
+        kfree(work);
+}
+
 void emergency_sync(void)
 {
-        pdflush_operation(do_sync, 0);
+        struct work_struct *work;
+
+        work = kmalloc(sizeof(*work), GFP_ATOMIC);
+        if (work) {
+                INIT_WORK(work, do_sync_work);
+                schedule_work(work);
+        }
 }
 
 /*