[Bluetooth] Use work queue to trigger URB submission

[pandora-kernel.git] / fs / bio.c

diff --git a/fs/bio.c b/fs/bio.c
index 1f3bb50..f95c874 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
+ * Copyright (C) 2001 Jens Axboe <axboe@kernel.dk>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -25,11 +25,12 @@
 #include <linux/module.h>
 #include <linux/mempool.h>
 #include <linux/workqueue.h>
+#include <linux/blktrace_api.h>
 #include <scsi/sg.h>           /* for struct sg_iovec */
 
 #define BIO_POOL_SIZE 256
 
-static kmem_cache_t *bio_slab;
+static kmem_cache_t *bio_slab __read_mostly;
 
 #define BIOVEC_NR_POOLS 6
 
@@ -38,7 +39,7 @@ static kmem_cache_t *bio_slab;
  * basically we just need to survive
  */
 #define BIO_SPLIT_ENTRIES 8    
-mempool_t *bio_split_pool;
+mempool_t *bio_split_pool __read_mostly;
 
 struct biovec_slab {
        int nr_vecs;
@@ -78,7 +79,6 @@ static struct bio_set *fs_bio_set;
 static inline struct bio_vec *bvec_alloc_bs(gfp_t gfp_mask, int nr, unsigned long *idx, struct bio_set *bs)
 {
        struct bio_vec *bvl;
-       struct biovec_slab *bp;
 
        /*
         * see comment near bvec_array define!
@@ -97,10 +97,12 @@ static inline struct bio_vec *bvec_alloc_bs(gfp_t gfp_mask, int nr, unsigned lon
         * idx now points to the pool we want to allocate from
         */
 
-       bp = bvec_slabs + *idx;
        bvl = mempool_alloc(bs->bvec_pools[*idx], gfp_mask);
-       if (bvl)
+       if (bvl) {
+               struct biovec_slab *bp = bvec_slabs + *idx;
+
                memset(bvl, 0, bp->nr_vecs * sizeof(struct bio_vec));
+       }
 
        return bvl;
 }
@@ -165,7 +167,7 @@ struct bio *bio_alloc_bioset(gfp_t gfp_mask, int nr_iovecs, struct bio_set *bs)
 
                bio_init(bio);
                if (likely(nr_iovecs)) {
-                       unsigned long idx;
+                       unsigned long idx = 0; /* shut up gcc */
 
                        bvl = bvec_alloc_bs(gfp_mask, nr_iovecs, &idx, bs);
                        if (unlikely(!bvl)) {
@@ -635,12 +637,10 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
                return ERR_PTR(-ENOMEM);
 
        ret = -ENOMEM;
-       pages = kmalloc(nr_pages * sizeof(struct page *), GFP_KERNEL);
+       pages = kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
        if (!pages)
                goto out;
 
-       memset(pages, 0, nr_pages * sizeof(struct page *));
-
        for (i = 0; i < iov_count; i++) {
                unsigned long uaddr = (unsigned long)iov[i].iov_base;
                unsigned long len = iov[i].iov_len;
@@ -655,9 +655,10 @@ static struct bio *__bio_map_user_iov(request_queue_t *q,
                                     write_to_vm, 0, &pages[cur_page], NULL);
                up_read(&current->mm->mmap_sem);
 
-               if (ret < local_nr_pages)
+               if (ret < local_nr_pages) {
+                       ret = -EFAULT;
                        goto out_unmap;
-
+               }
 
                offset = uaddr & ~PAGE_MASK;
                for (j = cur_page; j < page_limit; j++) {
@@ -1095,6 +1096,9 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
        if (!bp)
                return bp;
 
+       blk_add_trace_pdu_int(bdev_get_queue(bi->bi_bdev), BLK_TA_SPLIT, bi,
+                               bi->bi_sector + first_sectors);
+
        BUG_ON(bi->bi_vcnt != 1);
        BUG_ON(bi->bi_idx != 0);
        atomic_set(&bp->cnt, 3);
@@ -1114,6 +1118,9 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
        bp->bio1.bi_io_vec = &bp->bv1;
        bp->bio2.bi_io_vec = &bp->bv2;
 
+       bp->bio1.bi_max_vecs = 1;
+       bp->bio2.bi_max_vecs = 1;
+
        bp->bio1.bi_end_io = bio_pair_end_1;
        bp->bio2.bi_end_io = bio_pair_end_2;
 
@@ -1123,16 +1130,6 @@ struct bio_pair *bio_split(struct bio *bi, mempool_t *pool, int first_sectors)
        return bp;
 }
 
-static void *bio_pair_alloc(gfp_t gfp_flags, void *data)
-{
-       return kmalloc(sizeof(struct bio_pair), gfp_flags);
-}
-
-static void bio_pair_free(void *bp, void *data)
-{
-       kfree(bp);
-}
-
 
 /*
  * create memory pools for biovec's in a bio_set.
@@ -1146,11 +1143,10 @@ static int biovec_create_pools(struct bio_set *bs, int pool_entries, int scale)
                struct biovec_slab *bp = bvec_slabs + i;
                mempool_t **bvp = bs->bvec_pools + i;
 
-               if (i >= scale)
+               if (pool_entries > 1 && i >= scale)
                        pool_entries >>= 1;
 
-               *bvp = mempool_create(pool_entries, mempool_alloc_slab,
-                                       mempool_free_slab, bp->slab);
+               *bvp = mempool_create_slab_pool(pool_entries, bp->slab);
                if (!*bvp)
                        return -ENOMEM;
        }
@@ -1182,15 +1178,12 @@ void bioset_free(struct bio_set *bs)
 
 struct bio_set *bioset_create(int bio_pool_size, int bvec_pool_size, int scale)
 {
-       struct bio_set *bs = kmalloc(sizeof(*bs), GFP_KERNEL);
+       struct bio_set *bs = kzalloc(sizeof(*bs), GFP_KERNEL);
 
        if (!bs)
                return NULL;
 
-       memset(bs, 0, sizeof(*bs));
-       bs->bio_pool = mempool_create(bio_pool_size, mempool_alloc_slab,
-                       mempool_free_slab, bio_slab);
-
+       bs->bio_pool = mempool_create_slab_pool(bio_pool_size, bio_slab);
        if (!bs->bio_pool)
                goto bad;
 
@@ -1243,18 +1236,18 @@ static int __init init_bio(void)
                scale = 4;
 
        /*
-        * scale number of entries
+        * Limit number of entries reserved -- mempools are only used when
+        * the system is completely unable to allocate memory, so we only
+        * need enough to make progress.
         */
-       bvec_pool_entries = megabytes * 2;
-       if (bvec_pool_entries > 256)
-               bvec_pool_entries = 256;
+       bvec_pool_entries = 1 + scale;
 
        fs_bio_set = bioset_create(BIO_POOL_SIZE, bvec_pool_entries, scale);
        if (!fs_bio_set)
                panic("bio: can't allocate bios\n");
 
-       bio_split_pool = mempool_create(BIO_SPLIT_ENTRIES,
-                               bio_pair_alloc, bio_pair_free, NULL);
+       bio_split_pool = mempool_create_kmalloc_pool(BIO_SPLIT_ENTRIES,
+                                                    sizeof(struct bio_pair));
        if (!bio_split_pool)
                panic("bio: can't create split pool\n");