[PATCH] mempool: use mempool_create_slab_pool()

Modify well over a dozen mempool users to call mempool_create_slab_pool()
rather than calling mempool_create() with extra arguments, saving about 30
lines of code and increasing readability.

Signed-off-by: Matthew Dobson <colpatch@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index c4a0d5d8d7f0dd4080ae63c7897c8fcdde3b10d7..bde40a6ae66533c2b07f46e1eb8d4952fc0e96ed 100644 (file)
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -2191,7 +2191,7 @@ static int cfq_init_queue(request_queue_t *q, elevator_t *e)
        if (!cfqd->cfq_hash)
                goto out_cfqhash;
 
-       cfqd->crq_pool = mempool_create(BLKDEV_MIN_RQ, mempool_alloc_slab, mempool_free_slab, crq_pool);
+       cfqd->crq_pool = mempool_create_slab_pool(BLKDEV_MIN_RQ, crq_pool);
        if (!cfqd->crq_pool)
                goto out_crqpool;
 

diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index 32fea55fac484f4fab1f42b0904f98290e28d8a4..393b86a3dbf8e189ca26913aef7692d38c3072a3 100644 (file)
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -211,9 +211,7 @@ aoeblk_gdalloc(void *vp)
                return;
        }
 
-       d->bufpool = mempool_create(MIN_BUFS,
-                                   mempool_alloc_slab, mempool_free_slab,
-                                   buf_pool_cache);
+       d->bufpool = mempool_create_slab_pool(MIN_BUFS, buf_pool_cache);
        if (d->bufpool == NULL) {
                printk(KERN_ERR "aoe: aoeblk_gdalloc: cannot allocate bufpool "
                        "for %ld.%ld\n", d->aoemajor, d->aoeminor);

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index d88b8eda39033e42d4cdb9c95454b56cf7f53729..259e86f265492bb98f5af0af59d185f9d841dd4b 100644 (file)
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -616,8 +616,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                }
        }
 
-       cc->io_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
-                                    mempool_free_slab, _crypt_io_pool);
+       cc->io_pool = mempool_create_slab_pool(MIN_IOS, _crypt_io_pool);
        if (!cc->io_pool) {
                ti->error = PFX "Cannot allocate crypt io mempool";
                goto bad3;

diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index f72a82fb943489872b3d91abdffe4cb292c92267..1816f30678ed1aaa1a0fddc3d4cb043b77c1a4da 100644 (file)
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -179,8 +179,7 @@ static struct multipath *alloc_multipath(void)
                m->queue_io = 1;
                INIT_WORK(&m->process_queued_ios, process_queued_ios, m);
                INIT_WORK(&m->trigger_event, trigger_event, m);
-               m->mpio_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
-                                             mempool_free_slab, _mpio_cache);
+               m->mpio_pool = mempool_create_slab_pool(MIN_IOS, _mpio_cache);
                if (!m->mpio_pool) {
                        kfree(m);
                        return NULL;

diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index f3759dd7828e585ed81b0819e9908fbf546da543..7401540086df49c6445faa1ffbe69613b053305d 100644 (file)
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -1174,8 +1174,7 @@ static int __init dm_snapshot_init(void)
                goto bad4;
        }
 
-       pending_pool = mempool_create(128, mempool_alloc_slab,
-                                     mempool_free_slab, pending_cache);
+       pending_pool = mempool_create_slab_pool(128, pending_cache);
        if (!pending_pool) {
                DMERR("Couldn't create pending pool.");
                r = -ENOMEM;

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 8c82373f7ff31f24b8c0439e17c00d5a8873f30d..a64798ef481e585ef9c56e85ece676f42a2494b8 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -823,13 +823,11 @@ static struct mapped_device *alloc_dev(unsigned int minor, int persistent)
        md->queue->unplug_fn = dm_unplug_all;
        md->queue->issue_flush_fn = dm_flush_all;
 
-       md->io_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
-                                    mempool_free_slab, _io_cache);
+       md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache);
        if (!md->io_pool)
                goto bad2;
 
-       md->tio_pool = mempool_create(MIN_IOS, mempool_alloc_slab,
-                                     mempool_free_slab, _tio_cache);
+       md->tio_pool = mempool_create_slab_pool(MIN_IOS, _tio_cache);
        if (!md->tio_pool)
                goto bad3;
 

diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index 0d54e8b7d9de158172ff5ba2d54455952f7e8d95..9dcb2c8a38537cab675f765e9e17a13999fd8546 100644 (file)
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -227,8 +227,7 @@ static int jobs_init(void)
        if (!_job_cache)
                return -ENOMEM;
 
-       _job_pool = mempool_create(MIN_JOBS, mempool_alloc_slab,
-                                  mempool_free_slab, _job_cache);
+       _job_pool = mempool_create_slab_pool(MIN_JOBS, _job_cache);
        if (!_job_pool) {
                kmem_cache_destroy(_job_cache);
                return -ENOMEM;

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index b09fb6307153740efc92e674ae65dade0046c8aa..7d4c5497785b3c1dd1d1709733b5a899e5547c6a 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -1179,10 +1179,9 @@ static int __init i2o_block_init(void)
                goto exit;
        }
 
-       i2o_blk_req_pool.pool = mempool_create(I2O_BLOCK_REQ_MEMPOOL_SIZE,
-                                              mempool_alloc_slab,
-                                              mempool_free_slab,
-                                              i2o_blk_req_pool.slab);
+       i2o_blk_req_pool.pool =
+               mempool_create_slab_pool(I2O_BLOCK_REQ_MEMPOOL_SIZE,
+                                        i2o_blk_req_pool.slab);
        if (!i2o_blk_req_pool.pool) {
                osm_err("can't init request mempool\n");
                rc = -ENOMEM;

diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 7b82ff090d42026cc56cb9bc04ad55b396320b82..2068b66822b7e9f871687db92a9d8ede0576f172 100644 (file)
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -3200,8 +3200,8 @@ iscsi_r2tpool_alloc(struct iscsi_session *session)
                 * Data-Out PDU's within R2T-sequence can be quite big;
                 * using mempool
                 */
-               ctask->datapool = mempool_create(ISCSI_DTASK_DEFAULT_MAX,
-                        mempool_alloc_slab, mempool_free_slab, taskcache);
+               ctask->datapool = mempool_create_slab_pool(ISCSI_DTASK_DEFAULT_MAX,
+                                                          taskcache);
                if (ctask->datapool == NULL) {
                        kfifo_free(ctask->r2tqueue);
                        iscsi_pool_free(&ctask->r2tpool, (void**)ctask->r2ts);

diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 029bbf461bb2d034441b03dfd4caff95186627d6..017729c59a49957d93b150fe80a85319a9fb5cff 100644 (file)
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -2154,8 +2154,7 @@ qla2x00_allocate_sp_pool(scsi_qla_host_t *ha)
        int      rval;
 
        rval = QLA_SUCCESS;
-       ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab,
-           mempool_free_slab, srb_cachep);
+       ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep);
        if (ha->srb_mempool == NULL) {
                qla_printk(KERN_INFO, ha, "Unable to allocate SRB mempool.\n");
                rval = QLA_FUNCTION_FAILED;

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index ede158d08d9df06830b92b6047b0a9453a71611c..8f010a314a3d8b0e9a1e7d795f5badf81718c228 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1787,9 +1787,8 @@ int __init scsi_init_queue(void)
                                        sgp->name);
                }
 
-               sgp->pool = mempool_create(SG_MEMPOOL_SIZE,
-                               mempool_alloc_slab, mempool_free_slab,
-                               sgp->slab);
+               sgp->pool = mempool_create_slab_pool(SG_MEMPOOL_SIZE,
+                                                    sgp->slab);
                if (!sgp->pool) {
                        printk(KERN_ERR "SCSI: can't init sg mempool %s\n",
                                        sgp->name);

diff --git a/fs/bio.c b/fs/bio.c
index 377046d829456396aff3a225248404abbe20b1c5..eb8fbc53f2cd73273c8639c4dcb0648b30d15f70 100644 (file)
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1141,8 +1141,7 @@ static int biovec_create_pools(struct bio_set *bs, int pool_entries, int scale)
                if (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;
        }
@@ -1179,9 +1178,7 @@ struct bio_set *bioset_create(int bio_pool_size, int bvec_pool_size, int scale)
        if (!bs)
                return NULL;
 
-       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;
 

diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 221b3334b737dc1b7d179bedf88df9258bd32b73..6b99b51d66946b16b3553d3cf9bb36172eb292a0 100644 (file)
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -738,10 +738,8 @@ cifs_init_request_bufs(void)
                cERROR(1,("cifs_min_rcv set to maximum (64)"));
        }
 
-       cifs_req_poolp = mempool_create(cifs_min_rcv,
-                                       mempool_alloc_slab,
-                                       mempool_free_slab,
-                                       cifs_req_cachep);
+       cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
+                                                 cifs_req_cachep);
 
        if(cifs_req_poolp == NULL) {
                kmem_cache_destroy(cifs_req_cachep);
@@ -771,10 +769,8 @@ cifs_init_request_bufs(void)
                cFYI(1,("cifs_min_small set to maximum (256)"));
        }
 
-       cifs_sm_req_poolp = mempool_create(cifs_min_small,
-                               mempool_alloc_slab,
-                               mempool_free_slab,
-                               cifs_sm_req_cachep);
+       cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
+                                                    cifs_sm_req_cachep);
 
        if(cifs_sm_req_poolp == NULL) {
                mempool_destroy(cifs_req_poolp);
@@ -808,10 +804,8 @@ cifs_init_mids(void)
        if (cifs_mid_cachep == NULL)
                return -ENOMEM;
 
-       cifs_mid_poolp = mempool_create(3 /* a reasonable min simultan opers */,
-                                       mempool_alloc_slab,
-                                       mempool_free_slab,
-                                       cifs_mid_cachep);
+       /* 3 is a reasonable minimum number of simultaneous operations */
+       cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
        if(cifs_mid_poolp == NULL) {
                kmem_cache_destroy(cifs_mid_cachep);
                return -ENOMEM;

diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 8508043849f305cc208f34944689fe644cf42347..f28696f235c4be9932a8da84807cc2033e11a3dc 100644 (file)
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -220,8 +220,8 @@ int __init metapage_init(void)
        if (metapage_cache == NULL)
                return -ENOMEM;
 
-       metapage_mempool = mempool_create(METAPOOL_MIN_PAGES, mempool_alloc_slab,
-                                         mempool_free_slab, metapage_cache);
+       metapage_mempool = mempool_create_slab_pool(METAPOOL_MIN_PAGES,
+                                                   metapage_cache);
 
        if (metapage_mempool == NULL) {
                kmem_cache_destroy(metapage_cache);

diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 3961524fd4ab5757ba6a7c4010644f6dc91b7e3f..624ca7146b6b590d6ad6e25233250c4829fdac9a 100644 (file)
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -663,10 +663,8 @@ int nfs_init_readpagecache(void)
        if (nfs_rdata_cachep == NULL)
                return -ENOMEM;
 
-       nfs_rdata_mempool = mempool_create(MIN_POOL_READ,
-                                          mempool_alloc_slab,
-                                          mempool_free_slab,
-                                          nfs_rdata_cachep);
+       nfs_rdata_mempool = mempool_create_slab_pool(MIN_POOL_READ,
+                                                    nfs_rdata_cachep);
        if (nfs_rdata_mempool == NULL)
                return -ENOMEM;
 

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 3f5225404c973d41154c214f0d241f478da7da9d..4cfada2cc09f4fca67bac31756d018b13a8cdef1 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -1521,17 +1521,13 @@ int nfs_init_writepagecache(void)
        if (nfs_wdata_cachep == NULL)
                return -ENOMEM;
 
-       nfs_wdata_mempool = mempool_create(MIN_POOL_WRITE,
-                                          mempool_alloc_slab,
-                                          mempool_free_slab,
-                                          nfs_wdata_cachep);
+       nfs_wdata_mempool = mempool_create_slab_pool(MIN_POOL_WRITE,
+                                                    nfs_wdata_cachep);
        if (nfs_wdata_mempool == NULL)
                return -ENOMEM;
 
-       nfs_commit_mempool = mempool_create(MIN_POOL_COMMIT,
-                                          mempool_alloc_slab,
-                                          mempool_free_slab,
-                                          nfs_wdata_cachep);
+       nfs_commit_mempool = mempool_create_slab_pool(MIN_POOL_COMMIT,
+                                                     nfs_wdata_cachep);
        if (nfs_commit_mempool == NULL)
                return -ENOMEM;
 

diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 8355faf8ffded885d3557322b48b0ffd2f9b28fe..1884300417e37a3c28a920fda036e6851810e4e9 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -375,9 +375,8 @@ xfs_init_zones(void)
        if (!xfs_ioend_zone)
                goto out_destroy_vnode_zone;
 
-       xfs_ioend_pool = mempool_create(4 * MAX_BUF_PER_PAGE,
-                                       mempool_alloc_slab, mempool_free_slab,
-                                       xfs_ioend_zone);
+       xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
+                                                 xfs_ioend_zone);
        if (!xfs_ioend_pool)
                goto out_free_ioend_zone;
        return 0;

diff --git a/include/linux/i2o.h b/include/linux/i2o.h
index 5a9d8c5991719d121b25471f79b66fd9b25012b0..dd7d627bf66f306b4ee9401f06ed4fb574896a85 100644 (file)
--- a/include/linux/i2o.h
+++ b/include/linux/i2o.h
@@ -950,9 +950,7 @@ static inline int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
        if (!pool->slab)
                goto free_name;
 
-       pool->mempool =
-           mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
-                          pool->slab);
+       pool->mempool = mempool_create_slab_pool(min_nr, pool->slab);
        if (!pool->mempool)
                goto free_slab;
 

diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index b9969b91a9f73a5f149b6e5403c358a0207b0662..5c3eee76850458d1ca17511b405a473267d9cdb6 100644 (file)
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -1167,16 +1167,12 @@ rpc_init_mempool(void)
                                             NULL, NULL);
        if (!rpc_buffer_slabp)
                goto err_nomem;
-       rpc_task_mempool = mempool_create(RPC_TASK_POOLSIZE,
-                                           mempool_alloc_slab,
-                                           mempool_free_slab,
-                                           rpc_task_slabp);
+       rpc_task_mempool = mempool_create_slab_pool(RPC_TASK_POOLSIZE,
+                                                   rpc_task_slabp);
        if (!rpc_task_mempool)
                goto err_nomem;
-       rpc_buffer_mempool = mempool_create(RPC_BUFFER_POOLSIZE,
-                                           mempool_alloc_slab,
-                                           mempool_free_slab,
-                                           rpc_buffer_slabp);
+       rpc_buffer_mempool = mempool_create_slab_pool(RPC_BUFFER_POOLSIZE,
+                                                     rpc_buffer_slabp);
        if (!rpc_buffer_mempool)
                goto err_nomem;
        return 0;