cifs: refactor new_inode() calls and inode initialization

[safe/jmp/linux-2.6] / fs / bio.c

diff --git a/fs/bio.c b/fs/bio.c
index 0146f80..062299a 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -31,6 +31,12 @@
 
 DEFINE_TRACE(block_split);
 
+/*
+ * Test patch to inline a certain number of bi_io_vec's inside the bio
+ * itself, to shrink a bio data allocation from two mempool calls to one
+ */
+#define BIO_INLINE_VECS                4
+
 static mempool_t *bio_split_pool __read_mostly;
 
 /*
@@ -174,7 +180,7 @@ struct bio_vec *bvec_alloc_bs(gfp_t gfp_mask, int nr, unsigned long *idx,
         * kzalloc() for the exact number of vecs right away.
         */
        if (!bs)
-               bvl = kzalloc(nr * sizeof(struct bio_vec), gfp_mask);
+               bvl = kmalloc(nr * sizeof(struct bio_vec), gfp_mask);
 
        /*
         * see comment near bvec_array define!
@@ -231,9 +237,6 @@ fallback:
                }
        }
 
-       if (bvl)
-               memset(bvl, 0, bvec_nr_vecs(*idx) * sizeof(struct bio_vec));
-
        return bvl;
 }
 
@@ -241,7 +244,7 @@ void bio_free(struct bio *bio, struct bio_set *bs)
 {
        void *p;
 
-       if (bio->bi_io_vec)
+       if (bio_has_allocated_vec(bio))
                bvec_free_bs(bs, bio->bi_io_vec, BIO_POOL_IDX(bio));
 
        if (bio_integrity(bio))
@@ -267,7 +270,8 @@ static void bio_fs_destructor(struct bio *bio)
 
 static void bio_kmalloc_destructor(struct bio *bio)
 {
-       kfree(bio->bi_io_vec);
+       if (bio_has_allocated_vec(bio))
+               kfree(bio->bi_io_vec);
        kfree(bio);
 }
 
@@ -314,7 +318,15 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
                if (likely(nr_iovecs)) {
                        unsigned long uninitialized_var(idx);
 
-                       bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx, bs);
+                       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(bio, bs->bio_pool);
@@ -324,7 +336,7 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
                                goto out;
                        }
                        bio->bi_flags |= idx << BIO_POOL_OFFSET;
-                       bio->bi_max_vecs = bvec_nr_vecs(idx);
+                       bio->bi_max_vecs = nr_iovecs;
                }
                bio->bi_io_vec = bvl;
        }
@@ -776,6 +788,7 @@ struct bio *bio_copy_user_iov(struct request_queue *q,
        int i, ret;
        int nr_pages = 0;
        unsigned int len = 0;
+       unsigned int offset = map_data ? map_data->offset & ~PAGE_MASK : 0;
 
        for (i = 0; i < iov_count; i++) {
                unsigned long uaddr;
@@ -802,35 +815,42 @@ struct bio *bio_copy_user_iov(struct request_queue *q,
        bio->bi_rw |= (!write_to_vm << BIO_RW);
 
        ret = 0;
-       i = 0;
+
+       if (map_data) {
+               nr_pages = 1 << map_data->page_order;
+               i = map_data->offset / PAGE_SIZE;
+       }
        while (len) {
-               unsigned int bytes;
+               unsigned int bytes = PAGE_SIZE;
 
-               if (map_data)
-                       bytes = 1U << (PAGE_SHIFT + map_data->page_order);
-               else
-                       bytes = PAGE_SIZE;
+               bytes -= offset;
 
                if (bytes > len)
                        bytes = len;
 
                if (map_data) {
-                       if (i == map_data->nr_entries) {
+                       if (i == map_data->nr_entries * nr_pages) {
                                ret = -ENOMEM;
                                break;
                        }
-                       page = map_data->pages[i++];
-               } else
+
+                       page = map_data->pages[i / nr_pages];
+                       page += (i % nr_pages);
+
+                       i++;
+               } else {
                        page = alloc_page(q->bounce_gfp | gfp_mask);
-               if (!page) {
-                       ret = -ENOMEM;
-                       break;
+                       if (!page) {
+                               ret = -ENOMEM;
+                               break;
+                       }
                }
 
-               if (bio_add_pc_page(q, bio, page, bytes, 0) < bytes)
+               if (bio_add_pc_page(q, bio, page, bytes, offset) < bytes)
                        break;
 
                len -= bytes;
+               offset = 0;
        }
 
        if (ret)
@@ -839,7 +859,7 @@ struct bio *bio_copy_user_iov(struct request_queue *q,
        /*
         * success
         */
-       if (!write_to_vm) {
+       if (!write_to_vm && (!map_data || !map_data->null_mapped)) {
                ret = __bio_copy_iov(bio, bio->bi_io_vec, iov, iov_count, 0, 0);
                if (ret)
                        goto cleanup;
@@ -1525,6 +1545,7 @@ void bioset_free(struct bio_set *bs)
  */
 struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
 {
+       unsigned int back_pad = BIO_INLINE_VECS * sizeof(struct bio_vec);
        struct bio_set *bs;
 
        bs = kzalloc(sizeof(*bs), GFP_KERNEL);
@@ -1533,7 +1554,7 @@ struct bio_set *bioset_create(unsigned int pool_size, unsigned int front_pad)
 
        bs->front_pad = front_pad;
 
-       bs->bio_slab = bio_find_or_create_slab(front_pad);
+       bs->bio_slab = bio_find_or_create_slab(front_pad + back_pad);
        if (!bs->bio_slab) {
                kfree(bs);
                return NULL;